Dumps the node descendants into a string using HTML formatting.

@param string $delimiter

@return string
1751
public function innerHtml($delimiter = '')
    {
        $innerHtml = [];

        foreach ($this->node->childNodes as $childNode) {
            $innerHtml[] = $childNode->ownerDocument->saveHTML($childNode);
        }

        return implode($delimiter, $innerHtml);
    }
569642
public function firstSegment($delimiter) {
        $parts = $this->split($delimiter);
        $returnValue = current($parts);

        return $this->createClone($returnValue);
    }
913426
private function splitSqlFile($sql, $delimiter)
    {
        $sql               = trim($sql);
        $char              = '';
        $last_char         = '';
        $ret               = array();
        $string_start      = '';
        $in_string         = FALSE;
        $escaped_backslash = FALSE;
    
        for ($i = 0; $i < mb_strlen($sql); ++$i) {
            $char =  mb_substr($sql, $i, 1); //$sql[$i];
    
            // if delimiter found, add the parsed part to the returned array
            if ($char == $delimiter && !$in_string) {
                $ret[]     = mb_substr($sql, 0, $i);
                $sql       = mb_substr($sql, $i + 1);
                $i         = 0;
                $last_char = '';
            }
    
            if ($in_string) {
                // We are in a string, first check for escaped backslashes
                if ($char == '\\') {
                    if ($last_char != '\\') {
                        $escaped_backslash = FALSE;
                    } else {
                        $escaped_backslash = !$escaped_backslash;
                    }
                }
                // then check for not escaped end of strings except for
                // backquotes than cannot be escaped
                if (($char == $string_start)
                    && ($char == '`' || !(($last_char == '\\') && !$escaped_backslash))) {
                    $in_string    = FALSE;
                    $string_start = '';
                }
            } else {
                // we are not in a string, check for start of strings
                if (($char == '"') || ($char == '\'') || ($char == '`')) {
                    $in_string    = TRUE;
                    $string_start = $char;
                }
            }
            $last_char = $char;
        } // end for
    
        // add any rest to the returned array
        if (!empty($sql)) {
            $ret[] = $sql;
        }
        return $ret;
    }
1135959
public function renderChildren($indent = 0)
    {
        if ($this->innerHtml === null) {
            $this->innerHtml = '';
            foreach ($this->children as $element) {
                $this->innerHtml .= "\n" . $element->render($indent + 1);
            }
        }

        return $this->innerHtml;
    }
467382
public function split(string $delimiter = null): StreamInterface
    {
        if (\is_null($delimiter) || $delimiter === '') {
            return $this->chunk();
        }

        $parts = \explode($delimiter, $this->value);
        $stream = new Stream(self::class);

        foreach ($parts as $part) {
            $stream = $stream->add(new self($part, $this->encoding));
        }

        return $stream;
    }
1078770
private function get_unformatted($delimiter, $orig_tag = false)
    {
        if ($orig_tag && strpos(strtolower($orig_tag), $delimiter) !== false) {
            return '';
        }

        $input_char = '';
        $content = '';
        $min_index = 0;
        $space = true;

        do {
            if ($this->pos >= $this->input_length) {
                return $content;
            }

            $input_char = $this->input[$this->pos];
            $this->pos++;

            if (in_array($input_char, $this->whitespace)) {
                if (!$space) {
                    $this->line_char_count--;
                    continue;
                }
                if ($input_char === "\n" || $input_char === "\r") {
                    $content .= "\n";
                    /*  Don't change tab indention for unformatted blocks.  If using code for html editing, this will greatly affect <pre> tags if they are specified in the 'unformatted array'
                    for ($i = 0; $i < $this->indent_level; i++) {
                      $content .= $this->indent_string;
                    }
                    $space = false; //...and make sure other indentation is erased
                    */
                    $this->line_char_count = 0;
                    continue;
                }
            }
            $content .= $input_char;
            $this->line_char_count++;
            $space = true;

        } while ( strpos(strtolower($content), $delimiter, $min_index) === false);

        return $content;
    }
1199318
private function processParams($uri, $delimiter = ':')
    {
        if (strpos($uri, $delimiter) !== false) {
            preg_match_all(static::paramsRegex(), $uri, $matches, PREG_SET_ORDER);

            foreach ($matches as $match) {
                $param = explode($delimiter, $match[1]);
                if (count($param) === 2) {
                    $plain_var = filter_var($param[1], FILTER_SANITIZE_STRING);
                    $this->params[$param[0]] = $plain_var;
                    $uri = str_replace($match[0], '', $uri);
                }
            }
        }
        return $uri;
    }
103046
public function printLinks($delimiter = null) {
        //If a temporary delimiter is given
        if ($delimiter) {
            //Temporarily set the delimiter to the passed in argument
            $temp = $this->delimiter;
            $this->delimiter = $delimiter;

            //Call the toString with the swapped delimtier
            $return = $this->__toString();

            //Reset the delimiter
            $this->delimiter = $temp;

            //return the result string
            return $return;
        } else {
            //Else, just call to string
            return $this->__toString();
        }
    }
868331
public function appendToBranch($key, $data, $delimiter = self::DEFAULT_KEY_DELIMITER)
    {
        $node = $this->findTreeBranch($key, $delimiter);

        /**
         * check if a whole tree structure is missing
         * build it if necessary
         */
        if ($this->getAmountMissingTreeNodes() > 1) {
            return $this->createTree($this->getMissingKeysByDepth(), $node);
        }

        /**
         * create just one missing node to a fully established tree with branches
         */
        $key     = array_pop(explode((string)$delimiter, trim((string)$key, (string)$delimiter)));
        $newNode = new self($node, $key, $data, $delimiter);
        $node->addChild($newNode);

        return null;
    }
256554
public function getLocalization($delimiter = '_')
    {
        @trigger_error(__METHOD__ . '() is deprecated since version 1.2 and will be removed in 2.0. Use getLocale() instead.', E_USER_DEPRECATED);

        $localization = $this->getLanguage();
        if (null != $this->getCountry()) {
            $localization .= $delimiter . $this->getCountry();
        }

        return $localization;
    }
1141762
public function capitalize( $delimiter = NULL )
	{
		$oldString		= $this->string;
		if( $delimiter === NULL ){
			$this->string	= ucfirst( $this->string );
			return $this->string !== $oldString;
		}
		else{
			return $this->capitalizeWords( $delimiter );
		}
	}
28803
public function toHTML($separator = '<br/>') {
        $output = '';

        foreach ($this->diff as $entry) {
            $element = '';
            if ($entry instanceof UnmodifiedEntry) {
                $element = 'span';
            } elseif ($entry instanceof DeletedEntry) {
                $element = 'del';
            } elseif ($entry instanceof InsertedEntry) {
                $element = 'ins';
            }
            $output .= '<' . $element . '>' . $entry . '</' . $element . '>' . $separator;
        }

        return $output;
    }
771938
public static function getVendorPrefixRegExp($delimiter = null)
    {
        $vendorPrefixValues = self::getVendorPrefixValues();
        foreach ($vendorPrefixValues as $vendorPrefixKey => $vendorPrefixValue) {
            $vendorPrefixValues[$vendorPrefixKey] = preg_quote($vendorPrefixValue, $delimiter);
        }
        return implode('|', $vendorPrefixValues);
    }
1231758
public static function explodeTrim($str, $delimiter = ',')
    {
        if (is_string($delimiter)) {
            $str = trim(preg_replace('|\\s*(?:' . preg_quote($delimiter) . ')\\s*|', $delimiter, $str));
            return explode($delimiter, $str);
        }
        return $str;
    }
545181
public function str(string $delimiter): self
    {
        $sub = \mb_strstr($this->value, $delimiter, false, (string) $this->encoding());

        if ($sub === false) {
            throw new SubstringException(\sprintf(
                'Substring "%s" not found',
                $delimiter
            ));
        }

        return new self($sub, $this->encoding);
    }
1086857
public function parse( $data = null, $type = null, $delimiter = null ) {

		if ( ! empty( $data ) ) {
			$this->input = $data;
		}

		if ( ! empty( $type ) && in_array( $type, $this->types, true ) ) {
			$this->type = $type;
		}

		if ( !empty( $delimiter ) )
			$this->delimiter = $delimiter;

		if ( method_exists( $this, "parse_{$this->type}" ) ) {
			return call_user_func( array( $this, 'parse_' . $this->type ) );
		}

		return $this->parsed;
	}
238685
function _dumpDOM(root) {
        var result = "",
            indent = "";

        function walk(node) {
            if (node.tag) {
                result += indent + "TAG " + node.tagID + " " + node.tag + " " + JSON.stringify(node.attributes) + "\n";
            } else {
                result += indent + "TEXT " + (node.tagID || "- ") + node.content + "\n";
            }
            if (node.isElement()) {
                indent += "  ";
                node.children.forEach(walk);
                indent = indent.slice(2);
            }
        }
        walk(root);

        return result;
    }