Skips elements until an element doesn't match the elements in the passed array.

@param  array  $skips The elements array to skip.
@return string        The skipped string.
970939
protected function _skip($skips)
    {
        $skipped = '';
        $count = $this->count();
        while ($this->_current < $count) {
            if (!isset($skips[$this->_data[$this->_current][0]])) {
                break;
            }
            $skipped .= $this->_data[$this->_current][1];
            $this->_current++;
        }
        return $skipped;
    }
443536
protected function excludes($excludes)
    {
        $excludes = \is_array($excludes) ? $excludes : \func_get_args();

        $this->excludes = $excludes;

        return $this;
    }
438235
@Override
    public void skipElement() throws XMLStreamException
    {
        if (mCurrToken != START_ELEMENT) {
            throw new IllegalStateException(ErrorConsts.ERR_STATE_NOT_STELEM);
        }
        int nesting = 1; // need one more end elements than start elements

        while (true) {
            int type = next();
            if (type == START_ELEMENT) {
                ++nesting;
            } else if (type == END_ELEMENT) {
                if (--nesting == 0) {
                    break;
                }
            }
        }
    }
1259643
protected function recursivelyRemoveEmptyReplacements(array $input)
    {
        foreach ($input as &$value) {
            if (\is_array($value)) {
                $value = $this->recursivelyRemoveEmptyReplacements($value);
            }
        }

        return \array_filter($input, function ($value) {
            if (\is_string($value)) {
                return ! Str::startsWith($value, ':');
            }

            return true;
        });
    }
1018471
static function skipCurly(array $tokens, &$i) {
    $iStart = $i;
    $level = 0;
    for (++$i;; ++$i) {
      if ('}' === $token = $tokens[$i]) {
        if (--$level < 0) {
          ++$i;
          return NULL;
        }
      }
      elseif ('{' === $token || T_CURLY_OPEN === $token[0] || T_DOLLAR_OPEN_CURLY_BRACES === $token[0]) {
        ++$level;
      }
      elseif ('#' === $token) {
        $i = $iStart;
        return FALSE;
      }
    }

    throw new \RuntimeException('Unreachable code.');
  }
628987
public function skip()
    {
        return !$this->present() ||
            ($this->filterEmpty() &&
                empty($this->_args[$this->name()]) &&
                !is_numeric($this->_args[$this->name()])
            );
    }
1793
private function skipEmptyLines()
    {
        $foundHeartbeat = false;
        while ($this->offset < $this->bufferSize) {
            $char = substr($this->buffer, $this->offset, 1);
            if ($char === "\x00" || $char === "\n" || $char === "\r") {
                $this->offset++;
                $foundHeartbeat = true;
            } else {
                break;
            }
        }
        if ($foundHeartbeat && $this->observer) {
            $this->observer->emptyLineReceived();
        }
    }
26295
protected function stripOptionalFlag(&$selectors)
    {
        $optional = false;

        $selector = end($selectors);
        $part = end($selector);

        if ($part === ['!optional']) {
            array_pop($selectors[count($selectors) - 1]);

            $optional = true;
        }

        return $optional;
    }
614029
public function lessThan(array $options) {
        if (isset($options['element'])) {
            if (isset($this->data[$options['element']])) {
                $than = ' "' . $this->cleanElement($options['element']) . '"';
                if ($this->elementData < $this->data[$options['element']]) {
                    return true;
                }
            }
        } else if (isset($options['value'])) {
            $than = $options['value'];
            if ($this->elementData < $options['value']) {
                return true;
            }
        }

        $this->addError($this->checkMessage('Value must be less than ' . $than, $options));
        return false;
    }
803310
public function limit($skip, $limit)
    {
        $this->limit = $limit;
        $this->skip = $skip;
        return $this;
    }
1366134
public String skipped()
    {
        int start = 0;
        if (stack.size() > 1)
        {
            start = stack.get(stack.size() - 2).end();
        }
        int end = stack.get(stack.size() - 1).start();
        return text.subSequence(start, end).toString();
    }
946530
private function skip( $nav )
	{
		if ( $this->excludeComments && $nav->getNodeType() == XML_COMMENT_NODE )
		{
			$this->commentsSkipped++;
		}
		return	( $this->excludeComments && $nav->getNodeType() == XML_COMMENT_NODE ) ||
				( $this->excludeWhitespace && $nav->IsWhitespaceNode() );
	}
251268
public function skip($message = '')
    {
        if ($this->skipped !== true) {
            $this->skipped = true;
            $this->skipped_because = $message;
        }

        return $this;
    }
125215
public function getMissingBlocks(Array $blocks = array())
    {
        $missing = array();
        $blocks  = $blocks ? $blocks : $this->getWroteBlocks();
        $last    = array_shift($blocks);

        if ($last['offset'] !== 0) {
            $missing[] = array('offset' => 0, 'size' => $last['offset']);
        }

        foreach ($blocks as $block) {
            if ($block['offset'] !== $last['offset'] + $last['size']) {
                $offset = $last['offset'] + $last['size'];
                $missing[] = array('offset' => $offset, 'size' => $block['offset'] - $offset);
            }
            $last = $block;
        }

        return $missing;
    }
50430
public function skip($skip)
    {
        if (null !== $skip) {
            if (!is_numeric($skip) || $skip != (int) $skip) {
                throw new \InvalidArgumentException('The skip is not valid.');
            }
            $skip = (int) $skip;
        }

        $this->skip = $skip;

        return $this;
    }
1044584
public static function trimRecursive(array $array)
    {
        /*
         * No elements?
         * Nothing to do
         */
        if (empty($array)) {
            return [];
        }

        $result = [];

        foreach ($array as $key => $value) {
            if (is_array($value)) {
                $result[$key] = self::trimRecursive($value);

                continue;
            }

            if (is_string($value)) {
                $value = trim($value);
            }

            $result[$key] = $value;
        }

        return $result;
    }
785366
protected static function replaceBlock(array $matches)
    {
        $matches[3] = self::removeTrailingNewline($matches[3]);

        if (preg_match_all(self::$regex, self::$childSource, $override) && in_array($matches[2], $override[2])) {
            $key      = array_search($matches[2], $override[2]);
            $override = self::removeTrailingNewline($override[3][$key]);

            $l = stripslashes(self::$l);
            $r = stripslashes(self::$r);

            if (self::$lastReplacement) {
                return preg_replace('/' . self::$l . '\$dwoo\.parent' . self::$r . '/is', $matches[3], $override);
            }

            return $l . 'block ' . $matches[1] . $matches[2] . $matches[1] . $r . preg_replace('/' . self::$l . '\$dwoo\.parent' . self::$r . '/is', $matches[3], $override) . $l . '/block' . $r;
        }

        if (preg_match(self::$regex, $matches[3])) {
            return preg_replace_callback(self::$regex, array(
                'Dwoo\Plugins\Functions\PluginExtends',
                'replaceBlock'
            ), $matches[3]);
        }

        if (self::$lastReplacement) {
            return $matches[3];
        }

        return $matches[0];
    }