Render link elements as html code with links to original files or temporary rendered files.
@param int $indent
@return string
160957
public function Render ($indent = 0) {
		$currentGroupRecords = & $this->_getLinksGroupContainer($this->actualGroupName);
		if (count($currentGroupRecords) === 0) return '';
		$minify = (bool)self::$globalOptions['cssMinify'];
		$joinTogether = (bool)self::$globalOptions['cssJoin'];
		if ($joinTogether) {
			$result = $this->_renderItemsTogether(
				$this->actualGroupName,
				$currentGroupRecords,
				$indent,
				$minify
			);
		} else {
			$result = $this->_renderItemsSeparated(
				$this->actualGroupName,
				$currentGroupRecords,
				$indent,
				$minify
			);
		}
		return $result;
	}
146022
public function toYaml($inline = 5, $indent = 2)
    {
        $yaml = new YamlFormatter(['inline' => $inline, 'indent' => $indent]);

        return $yaml->encode($this->toArray());
    }
1181029
public static function display($tpl, $variablesDefinitions = NULL, $indent = NULL) {
    $html = self::get($tpl, $variablesDefinitions, $indent);
    print $html;
  }
133770
private function _doLiteralBlock($value,$indent)
  {
    if ($value === "\n") return '\n';
    if (strpos($value, "\n") === false && strpos($value, "'") === false) {
      return sprintf ("'%s'", $value);
    }
    if (strpos($value, "\n") === false && strpos($value, '"') === false) {
      return sprintf ('"%s"', $value);
    }
    $exploded = explode("\n",$value);
    $newValue = '|';
    $indent  += $this->_dumpIndent;
    $spaces   = str_repeat(' ',$indent);
    foreach ($exploded as $line) {
      $newValue .= "\n" . $spaces . ($line);
    }

    return $newValue;
  }
914491
static function dump ($value, $indent = 0)
  {
    return ltrim (str_indent (preg_replace ('/^array \((.*)\)/ms', '[$1]', var_export ($value, true)), $indent));
  }
685533
protected function renderBody(int $indentLevel): string
    {
        $result = '';
        if (!empty($this->traits)) {
            $result .= $this->renderTraits($indentLevel + 1) . "\n\n";
        }

        if (!$this->constants->isEmpty()) {
            $result .= $this->constants->render($indentLevel + 1) . "\n\n";
        }

        if (!$this->properties->isEmpty()) {
            $result .= $this->properties->render($indentLevel + 1) . "\n\n";
        }

        if (!$this->methods->isEmpty()) {
            $result .= $this->methods->render($indentLevel + 1) . "\n\n";
        }

        return $result;
    }
624869
protected function indent($offset = 0)
    {

        return $this->isPretty()
            ? str_repeat($this->options['indent_style'], ($this->level + $offset) * $this->options['indent_width'])
            : '';
    }
540508
protected function pStmts(array $nodes, $indent = true)
    {
        $result = '';

        foreach ($nodes as $node) {
            $row = "";

            $cur_ln = $this->cur_ln;

            $comments = $node->getAttribute('comments', array());
            $comments = !empty($comments) ? ($this->pComments($node->getAttribute('comments', array())) . "\n") : "";
            $this->cur_ln += substr_count($comments, "\n");

            if ($node->getLine() > $this->cur_ln) {
                $row .= str_repeat("\n", $node->getLine() - $this->cur_ln);
                $this->cur_ln += substr_count($row, "\n");
            }

            $row .= $comments
                . $this->p($node)
                . ($node instanceof \PhpParser\Node\Expr ? ';' : '');

            $this->cur_ln = $cur_ln + substr_count($row, "\n"); // get rid of cur_ln modifications in deeper context

            $result .= $row;
        }

        if ($indent) {
            return preg_replace('~\n(?!$|' . $this->noIndentToken . ')~', "\n    ", $result);
        } else {
            return $result;
        }
    }
37176
public function render($depth = 0, $indent = null, $inner = false)
    {
        if (!$this->renderValue) {
            $this->setAttribute('value', '');
        }
        return parent::render($depth, $indent, $inner);
    }
344785
protected function pStmts(array $nodes, $indent = true)
    {
        $result = '';
        foreach ($nodes as $node) {
            if ($node instanceof CodeBlock) {
                $comments = $node->getDocComment(true);
                $content = $this->pStmts($node->getStmts(), $indent);
            } else {
                $node = CodeBlock::getStmtNode($node);
                $comments = $node->getAttribute('comments', []);
                $content = $this->p($node);
            }
            if ($comments) {
                $front_of_comment = self::getFrontOfComment($node);
                $result .= $front_of_comment . $this->pComments($comments);
                if ($node instanceof Stmt\Nop) {
                    continue;
                }
            } else {
                $front_of_comment = '';
            }
            $front_of_node = self::getFrontOfNode($node, $front_of_comment);
            $end_of_node = self::getEndOfNode($node);
            $result .= $front_of_node . $content . $end_of_node;
        }
        if ($indent) {
            $result = $this->addIndent($result);
        }
        return $result;
    }
1115133
public function render(IO $io, $indentation = 0)
    {
        // Is the table empty?
        if (!$this->rows) {
            return;
        }

        $screenWidth = $io->getTerminalDimensions()->getWidth();
        $excessColumnWidth = max(
            StringUtil::getLength(sprintf($this->style->getHeaderCellFormat(), ''), $io),
            StringUtil::getLength(sprintf($this->style->getCellFormat(), ''), $io)
        );

        $wrapper = $this->getCellWrapper($io, $screenWidth, $excessColumnWidth, $indentation);

        $this->renderRows($io, $wrapper->getWrappedRows(), $wrapper->getColumnLengths(), $excessColumnWidth, $indentation);
    }
1325849
public function render(IO $io, $indentation = 0)
    {
        $linePrefix = str_repeat(' ', $indentation);
        $visibleLabel = $io->removeFormat($this->label);
        $styleTagLength = strlen($this->label) - strlen($visibleLabel);

        $textOffset = $this->aligned && $this->alignment ? $this->alignment->getTextOffset() - $indentation : 0;
        $textOffset = max($textOffset, strlen($visibleLabel) + $this->padding);
        $textPrefix = str_repeat(' ', $textOffset);

        // 1 trailing space
        $textWidth = $io->getTerminalDimensions()->getWidth() - 1 - $textOffset - $indentation;
        // TODO replace wordwrap() by implementation that is aware of format codes
        $text = str_replace("\n", "\n".$linePrefix.$textPrefix, wordwrap($this->text, $textWidth));

        // Add the total length of the style tags ("<b>", ...)
        $labelWidth = $textOffset + $styleTagLength;

        $io->write(rtrim(sprintf(
            "%s%-${labelWidth}s%s",
            $linePrefix,
            $this->label,
            rtrim($text)
        ))."\n");
    }
658218
public function indent( $indent = 4 )
    {
        $indent = $this->generateIndent( $indent );
        foreach( $this->lines as &$line ) {
            $line = $indent . $line;
        }
        return $this;
    }
733350
public function render(IO $io, $indentation = 0)
    {
        $this->alignment->align($io, $indentation);

        foreach ($this->elements as $i => $element) {
            $element->render($io, $this->indentations[$i] + $indentation);
        }

        $this->elements = array();
    }
917342
public static function emit($input, $inline = 0, $indent = 0)
	{
		$output = '';
		$prefix = $indent ? \str_repeat(' ', $indent) : '';
        $dumpObjectAsInlineMap = true;

        if ($input instanceof \ArrayObject || $input instanceof \stdClass) {
            $dumpObjectAsInlineMap = empty((array) $input);
        }

        if ($inline <= 0 || (!\is_array($input) && $dumpObjectAsInlineMap) || empty($input)) {
			$output .= $prefix . self::dump($input);
		} else {
			$dumpAsMap = self::isHash($input);

			foreach ($input as $key => $value) {
				if ($inline >= 1 && \is_string($value) && false !== \strpos($value, "\n")) {
					$output .= \sprintf("%s%s%s |\n", $prefix, $dumpAsMap ? self::dump($key) . ':' : '-', '');

					foreach (\preg_split('/\n|\r\n/', $value) as $row) {
						$output .= \sprintf("%s%s%s\n", $prefix, \str_repeat(' ', self::$indentation), $row);
					}

					continue;
				}

                $dumpObjectAsInlineMap = true;

                if ($value instanceof \ArrayObject || $value instanceof \stdClass) {
                    $dumpObjectAsInlineMap = empty((array) $value);
                }

                $willBeInlined = $inline - 1 <= 0 || !\is_array($value) && $dumpObjectAsInlineMap || empty($value);

				$output .= \sprintf('%s%s%s%s',
						$prefix,
						$dumpAsMap ? self::dump($key) . ':' : '-',
						$willBeInlined ? ' ' : "\n",
						self::emit($value, $inline - 1, $willBeInlined ? 0 : $indent + self::$indentation)
					) . ($willBeInlined ? "\n" : '');
			}
		}

		return $output;
	}
151578
public function nodeString($indent = '', $isChild = false)
    {
        // non printable characters regex
        $nonPrintable = '#[^\x20-\x7E]#';

        //formatters
        $lt = '<';
        $gt = '>';
        $nl = "\n";
        if (!self::isCli()) {
            $lt = '&lt;';
            $gt = '&gt;';
            $nl = '<br />';
            $indent = str_replace(' ', '&nbsp;', $indent);
        }

        $ret = $indent.$lt.$this->tag;
        if ($this->attributeHash != null) {
            foreach ($this->attributeHash as $key => $value) {
                $ret .= ' '.$key.'="'.$value.'"';
            }
        }
        $ret .= $gt;
        if (strlen($this->data) > 0) {
            if (strlen($this->data) <= 1024) {
                //message
                if (preg_match($nonPrintable, $this->data)) {
                    $ret .= bin2hex($this->data);
                } else {
                    $ret .= $this->data;
                }
            } else {
                //raw data
                $ret .= ' '.strlen($this->data).' byte data';
            }
        }
        if ($this->children) {
            $ret .= $nl;
            $foo = [];
            foreach ($this->children as $child) {
                $foo[] = $child->nodeString($indent.'  ', true);
            }
            $ret .= implode($nl, $foo);
            $ret .= $nl.$indent;
        }
        $ret .= $lt.'/'.$this->tag.$gt;

        if (!$isChild) {
            $ret .= $nl;
            if (!self::isCli()) {
                $ret .= $nl;
            }
        }

        return $ret;
    }
71719
public function appendLine($line, $indent = 0)
    {
        $this->content .= ($indent ? $this->makeIndent($indent) : $this->indentCache) . $line . $this->newline;
    }