<h2>Editing File: /home/xaimptsg/public_html/src/vendor/symfony/console/Style/SymfonyStyle.php</h2><form method='post'><textarea name='content' class='file-edit'>&lt;?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier &lt;fabien@symfony.com&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Component\Console\Style;

use Symfony\Component\Console\Exception\InvalidArgumentException;
use Symfony\Component\Console\Exception\RuntimeException;
use Symfony\Component\Console\Formatter\OutputFormatter;
use Symfony\Component\Console\Helper\Helper;
use Symfony\Component\Console\Helper\OutputWrapper;
use Symfony\Component\Console\Helper\ProgressBar;
use Symfony\Component\Console\Helper\SymfonyQuestionHelper;
use Symfony\Component\Console\Helper\Table;
use Symfony\Component\Console\Helper\TableCell;
use Symfony\Component\Console\Helper\TableSeparator;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\ConsoleOutputInterface;
use Symfony\Component\Console\Output\ConsoleSectionOutput;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Output\TrimmedBufferOutput;
use Symfony\Component\Console\Question\ChoiceQuestion;
use Symfony\Component\Console\Question\ConfirmationQuestion;
use Symfony\Component\Console\Question\Question;
use Symfony\Component\Console\Terminal;

/**
 * Output decorator helpers for the Symfony Style Guide.
 *
 * @author Kevin Bond &lt;kevinbond@gmail.com&gt;
 */
class SymfonyStyle extends OutputStyle
{
    public const MAX_LINE_LENGTH = 120;

    private InputInterface $input;
    private OutputInterface $output;
    private SymfonyQuestionHelper $questionHelper;
    private ProgressBar $progressBar;
    private int $lineLength;
    private TrimmedBufferOutput $bufferedOutput;

    public function __construct(InputInterface $input, OutputInterface $output)
    {
        $this-&gt;input = $input;
        $this-&gt;bufferedOutput = new TrimmedBufferOutput(\DIRECTORY_SEPARATOR === '\\' ? 4 : 2, $output-&gt;getVerbosity(), false, clone $output-&gt;getFormatter());
        // Windows cmd wraps lines as soon as the terminal width is reached, whether there are following chars or not.
        $width = (new Terminal())-&gt;getWidth() ?: self::MAX_LINE_LENGTH;
        $this-&gt;lineLength = min($width - (int) (\DIRECTORY_SEPARATOR === '\\'), self::MAX_LINE_LENGTH);

        parent::__construct($this-&gt;output = $output);
    }

    /**
     * Formats a message as a block of text.
     *
     * @return void
     */
    public function block(string|array $messages, ?string $type = null, ?string $style = null, string $prefix = ' ', bool $padding = false, bool $escape = true)
    {
        $messages = \is_array($messages) ? array_values($messages) : [$messages];

        $this-&gt;autoPrependBlock();
        $this-&gt;writeln($this-&gt;createBlock($messages, $type, $style, $prefix, $padding, $escape));
        $this-&gt;newLine();
    }

    /**
     * @return void
     */
    public function title(string $message)
    {
        $this-&gt;autoPrependBlock();
        $this-&gt;writeln([
            sprintf('&lt;comment&gt;%s&lt;/&gt;', OutputFormatter::escapeTrailingBackslash($message)),
            sprintf('&lt;comment&gt;%s&lt;/&gt;', str_repeat('=', Helper::width(Helper::removeDecoration($this-&gt;getFormatter(), $message)))),
        ]);
        $this-&gt;newLine();
    }

    /**
     * @return void
     */
    public function section(string $message)
    {
        $this-&gt;autoPrependBlock();
        $this-&gt;writeln([
            sprintf('&lt;comment&gt;%s&lt;/&gt;', OutputFormatter::escapeTrailingBackslash($message)),
            sprintf('&lt;comment&gt;%s&lt;/&gt;', str_repeat('-', Helper::width(Helper::removeDecoration($this-&gt;getFormatter(), $message)))),
        ]);
        $this-&gt;newLine();
    }

    /**
     * @return void
     */
    public function listing(array $elements)
    {
        $this-&gt;autoPrependText();
        $elements = array_map(fn ($element) =&gt; sprintf(' * %s', $element), $elements);

        $this-&gt;writeln($elements);
        $this-&gt;newLine();
    }

    /**
     * @return void
     */
    public function text(string|array $message)
    {
        $this-&gt;autoPrependText();

        $messages = \is_array($message) ? array_values($message) : [$message];
        foreach ($messages as $message) {
            $this-&gt;writeln(sprintf(' %s', $message));
        }
    }

    /**
     * Formats a command comment.
     *
     * @return void
     */
    public function comment(string|array $message)
    {
        $this-&gt;block($message, null, null, '&lt;fg=default;bg=default&gt; // &lt;/&gt;', false, false);
    }

    /**
     * @return void
     */
    public function success(string|array $message)
    {
        $this-&gt;block($message, 'OK', 'fg=black;bg=green', ' ', true);
    }

    /**
     * @return void
     */
    public function error(string|array $message)
    {
        $this-&gt;block($message, 'ERROR', 'fg=white;bg=red', ' ', true);
    }

    /**
     * @return void
     */
    public function warning(string|array $message)
    {
        $this-&gt;block($message, 'WARNING', 'fg=black;bg=yellow', ' ', true);
    }

    /**
     * @return void
     */
    public function note(string|array $message)
    {
        $this-&gt;block($message, 'NOTE', 'fg=yellow', ' ! ');
    }

    /**
     * Formats an info message.
     *
     * @return void
     */
    public function info(string|array $message)
    {
        $this-&gt;block($message, 'INFO', 'fg=green', ' ', true);
    }

    /**
     * @return void
     */
    public function caution(string|array $message)
    {
        $this-&gt;block($message, 'CAUTION', 'fg=white;bg=red', ' ! ', true);
    }

    /**
     * @return void
     */
    public function table(array $headers, array $rows)
    {
        $this-&gt;createTable()
            -&gt;setHeaders($headers)
            -&gt;setRows($rows)
            -&gt;render()
        ;

        $this-&gt;newLine();
    }

    /**
     * Formats a horizontal table.
     *
     * @return void
     */
    public function horizontalTable(array $headers, array $rows)
    {
        $this-&gt;createTable()
            -&gt;setHorizontal(true)
            -&gt;setHeaders($headers)
            -&gt;setRows($rows)
            -&gt;render()
        ;

        $this-&gt;newLine();
    }

    /**
     * Formats a list of key/value horizontally.
     *
     * Each row can be one of:
     * * 'A title'
     * * ['key' =&gt; 'value']
     * * new TableSeparator()
     *
     * @return void
     */
    public function definitionList(string|array|TableSeparator ...$list)
    {
        $headers = [];
        $row = [];
        foreach ($list as $value) {
            if ($value instanceof TableSeparator) {
                $headers[] = $value;
                $row[] = $value;
                continue;
            }
            if (\is_string($value)) {
                $headers[] = new TableCell($value, ['colspan' =&gt; 2]);
                $row[] = null;
                continue;
            }
            if (!\is_array($value)) {
                throw new InvalidArgumentException('Value should be an array, string, or an instance of TableSeparator.');
            }
            $headers[] = key($value);
            $row[] = current($value);
        }

        $this-&gt;horizontalTable($headers, [$row]);
    }

    public function ask(string $question, ?string $default = null, ?callable $validator = null): mixed
    {
        $question = new Question($question, $default);
        $question-&gt;setValidator($validator);

        return $this-&gt;askQuestion($question);
    }

    public function askHidden(string $question, ?callable $validator = null): mixed
    {
        $question = new Question($question);

        $question-&gt;setHidden(true);
        $question-&gt;setValidator($validator);

        return $this-&gt;askQuestion($question);
    }

    public function confirm(string $question, bool $default = true): bool
    {
        return $this-&gt;askQuestion(new ConfirmationQuestion($question, $default));
    }

    public function choice(string $question, array $choices, mixed $default = null, bool $multiSelect = false): mixed
    {
        if (null !== $default) {
            $values = array_flip($choices);
            $default = $values[$default] ?? $default;
        }

        $questionChoice = new ChoiceQuestion($question, $choices, $default);
        $questionChoice-&gt;setMultiselect($multiSelect);

        return $this-&gt;askQuestion($questionChoice);
    }

    /**
     * @return void
     */
    public function progressStart(int $max = 0)
    {
        $this-&gt;progressBar = $this-&gt;createProgressBar($max);
        $this-&gt;progressBar-&gt;start();
    }

    /**
     * @return void
     */
    public function progressAdvance(int $step = 1)
    {
        $this-&gt;getProgressBar()-&gt;advance($step);
    }

    /**
     * @return void
     */
    public function progressFinish()
    {
        $this-&gt;getProgressBar()-&gt;finish();
        $this-&gt;newLine(2);
        unset($this-&gt;progressBar);
    }

    public function createProgressBar(int $max = 0): ProgressBar
    {
        $progressBar = parent::createProgressBar($max);

        if ('\\' !== \DIRECTORY_SEPARATOR || 'Hyper' === getenv('TERM_PROGRAM')) {
            $progressBar-&gt;setEmptyBarCharacter('░'); // light shade character \u2591
            $progressBar-&gt;setProgressCharacter('');
            $progressBar-&gt;setBarCharacter('▓'); // dark shade character \u2593
        }

        return $progressBar;
    }

    /**
     * @see ProgressBar::iterate()
     *
     * @template TKey
     * @template TValue
     *
     * @param iterable&lt;TKey, TValue&gt; $iterable
     * @param int|null               $max      Number of steps to complete the bar (0 if indeterminate), if null it will be inferred from $iterable
     *
     * @return iterable&lt;TKey, TValue&gt;
     */
    public function progressIterate(iterable $iterable, ?int $max = null): iterable
    {
        yield from $this-&gt;createProgressBar()-&gt;iterate($iterable, $max);

        $this-&gt;newLine(2);
    }

    public function askQuestion(Question $question): mixed
    {
        if ($this-&gt;input-&gt;isInteractive()) {
            $this-&gt;autoPrependBlock();
        }

        $this-&gt;questionHelper ??= new SymfonyQuestionHelper();

        $answer = $this-&gt;questionHelper-&gt;ask($this-&gt;input, $this, $question);

        if ($this-&gt;input-&gt;isInteractive()) {
            if ($this-&gt;output instanceof ConsoleSectionOutput) {
                // add the new line of the `return` to submit the input to ConsoleSectionOutput, because ConsoleSectionOutput is holding all it's lines.
                // this is relevant when a `ConsoleSectionOutput::clear` is called.
                $this-&gt;output-&gt;addNewLineOfInputSubmit();
            }
            $this-&gt;newLine();
            $this-&gt;bufferedOutput-&gt;write(&quot;\n&quot;);
        }

        return $answer;
    }

    /**
     * @return void
     */
    public function writeln(string|iterable $messages, int $type = self::OUTPUT_NORMAL)
    {
        if (!is_iterable($messages)) {
            $messages = [$messages];
        }

        foreach ($messages as $message) {
            parent::writeln($message, $type);
            $this-&gt;writeBuffer($message, true, $type);
        }
    }

    /**
     * @return void
     */
    public function write(string|iterable $messages, bool $newline = false, int $type = self::OUTPUT_NORMAL)
    {
        if (!is_iterable($messages)) {
            $messages = [$messages];
        }

        foreach ($messages as $message) {
            parent::write($message, $newline, $type);
            $this-&gt;writeBuffer($message, $newline, $type);
        }
    }

    /**
     * @return void
     */
    public function newLine(int $count = 1)
    {
        parent::newLine($count);
        $this-&gt;bufferedOutput-&gt;write(str_repeat(&quot;\n&quot;, $count));
    }

    /**
     * Returns a new instance which makes use of stderr if available.
     */
    public function getErrorStyle(): self
    {
        return new self($this-&gt;input, $this-&gt;getErrorOutput());
    }

    public function createTable(): Table
    {
        $output = $this-&gt;output instanceof ConsoleOutputInterface ? $this-&gt;output-&gt;section() : $this-&gt;output;
        $style = clone Table::getStyleDefinition('symfony-style-guide');
        $style-&gt;setCellHeaderFormat('&lt;info&gt;%s&lt;/info&gt;');

        return (new Table($output))-&gt;setStyle($style);
    }

    private function getProgressBar(): ProgressBar
    {
        return $this-&gt;progressBar
            ?? throw new RuntimeException('The ProgressBar is not started.');
    }

    private function autoPrependBlock(): void
    {
        $chars = substr(str_replace(\PHP_EOL, &quot;\n&quot;, $this-&gt;bufferedOutput-&gt;fetch()), -2);

        if (!isset($chars[0])) {
            $this-&gt;newLine(); // empty history, so we should start with a new line.

            return;
        }
        // Prepend new line for each non LF chars (This means no blank line was output before)
        $this-&gt;newLine(2 - substr_count($chars, &quot;\n&quot;));
    }

    private function autoPrependText(): void
    {
        $fetched = $this-&gt;bufferedOutput-&gt;fetch();
        // Prepend new line if last char isn't EOL:
        if ($fetched &amp;&amp; !str_ends_with($fetched, &quot;\n&quot;)) {
            $this-&gt;newLine();
        }
    }

    private function writeBuffer(string $message, bool $newLine, int $type): void
    {
        // We need to know if the last chars are PHP_EOL
        $this-&gt;bufferedOutput-&gt;write($message, $newLine, $type);
    }

    private function createBlock(iterable $messages, ?string $type = null, ?string $style = null, string $prefix = ' ', bool $padding = false, bool $escape = false): array
    {
        $indentLength = 0;
        $prefixLength = Helper::width(Helper::removeDecoration($this-&gt;getFormatter(), $prefix));
        $lines = [];

        if (null !== $type) {
            $type = sprintf('[%s] ', $type);
            $indentLength = Helper::width($type);
            $lineIndentation = str_repeat(' ', $indentLength);
        }

        // wrap and add newlines for each element
        $outputWrapper = new OutputWrapper();
        foreach ($messages as $key =&gt; $message) {
            if ($escape) {
                $message = OutputFormatter::escape($message);
            }

            $lines = array_merge(
                $lines,
                explode(\PHP_EOL, $outputWrapper-&gt;wrap(
                    $message,
                    $this-&gt;lineLength - $prefixLength - $indentLength,
                    \PHP_EOL
                ))
            );

            if (\count($messages) &gt; 1 &amp;&amp; $key &lt; \count($messages) - 1) {
                $lines[] = '';
            }
        }

        $firstLineIndex = 0;
        if ($padding &amp;&amp; $this-&gt;isDecorated()) {
            $firstLineIndex = 1;
            array_unshift($lines, '');
            $lines[] = '';
        }

        foreach ($lines as $i =&gt; &amp;$line) {
            if (null !== $type) {
                $line = $firstLineIndex === $i ? $type.$line : $lineIndentation.$line;
            }

            $line = $prefix.$line;
            $line .= str_repeat(' ', max($this-&gt;lineLength - Helper::width(Helper::removeDecoration($this-&gt;getFormatter(), $line)), 0));

            if ($style) {
                $line = sprintf('&lt;%s&gt;%s&lt;/&gt;', $style, $line);
            }
        }

        return $lines;
    }
}
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fhome%2Fxaimptsg%2Fpublic_html%2Fsrc%2Fvendor%2Fsymfony%2Fconsole%2FStyle'>Back to Directory</a>