Initial Commit

dependencies/symfony/process/Exception/ExceptionInterface.php

@@ -0,0 +1,20 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace WP_Ultimo\Dependencies\Symfony\Component\Process\Exception;
+
+/**
+ * Marker Interface for the Process Component.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+interface ExceptionInterface extends \Throwable
+{
+}

dependencies/symfony/process/Exception/InvalidArgumentException.php

@@ -0,0 +1,20 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace WP_Ultimo\Dependencies\Symfony\Component\Process\Exception;
+
+/**
+ * InvalidArgumentException for the Process Component.
+ *
+ * @author Romain Neutron <imprec@gmail.com>
+ */
+class InvalidArgumentException extends \InvalidArgumentException implements ExceptionInterface
+{
+}

dependencies/symfony/process/Exception/LogicException.php

@@ -0,0 +1,20 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace WP_Ultimo\Dependencies\Symfony\Component\Process\Exception;
+
+/**
+ * LogicException for the Process Component.
+ *
+ * @author Romain Neutron <imprec@gmail.com>
+ */
+class LogicException extends \LogicException implements ExceptionInterface
+{
+}

dependencies/symfony/process/Exception/ProcessFailedException.php

@@ -0,0 +1,38 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace WP_Ultimo\Dependencies\Symfony\Component\Process\Exception;
+
+use WP_Ultimo\Dependencies\Symfony\Component\Process\Process;
+/**
+ * Exception for failed processes.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class ProcessFailedException extends RuntimeException
+{
+    private $process;
+    public function __construct(Process $process)
+    {
+        if ($process->isSuccessful()) {
+            throw new InvalidArgumentException('Expected a failed process, but the given process was successful.');
+        }
+        $error = \sprintf('The command "%s" failed.' . "\n\nExit Code: %s(%s)\n\nWorking directory: %s", $process->getCommandLine(), $process->getExitCode(), $process->getExitCodeText(), $process->getWorkingDirectory());
+        if (!$process->isOutputDisabled()) {
+            $error .= \sprintf("\n\nOutput:\n================\n%s\n\nError Output:\n================\n%s", $process->getOutput(), $process->getErrorOutput());
+        }
+        parent::__construct($error);
+        $this->process = $process;
+    }
+    public function getProcess()
+    {
+        return $this->process;
+    }
+}

dependencies/symfony/process/Exception/ProcessSignaledException.php

@@ -0,0 +1,35 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace WP_Ultimo\Dependencies\Symfony\Component\Process\Exception;
+
+use WP_Ultimo\Dependencies\Symfony\Component\Process\Process;
+/**
+ * Exception that is thrown when a process has been signaled.
+ *
+ * @author Sullivan Senechal <soullivaneuh@gmail.com>
+ */
+final class ProcessSignaledException extends RuntimeException
+{
+    private $process;
+    public function __construct(Process $process)
+    {
+        $this->process = $process;
+        parent::__construct(\sprintf('The process has been signaled with signal "%s".', $process->getTermSignal()));
+    }
+    public function getProcess() : Process
+    {
+        return $this->process;
+    }
+    public function getSignal() : int
+    {
+        return $this->getProcess()->getTermSignal();
+    }
+}

dependencies/symfony/process/Exception/ProcessTimedOutException.php

@@ -0,0 +1,54 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace WP_Ultimo\Dependencies\Symfony\Component\Process\Exception;
+
+use WP_Ultimo\Dependencies\Symfony\Component\Process\Process;
+/**
+ * Exception that is thrown when a process times out.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class ProcessTimedOutException extends RuntimeException
+{
+    public const TYPE_GENERAL = 1;
+    public const TYPE_IDLE = 2;
+    private $process;
+    private $timeoutType;
+    public function __construct(Process $process, int $timeoutType)
+    {
+        $this->process = $process;
+        $this->timeoutType = $timeoutType;
+        parent::__construct(\sprintf('The process "%s" exceeded the timeout of %s seconds.', $process->getCommandLine(), $this->getExceededTimeout()));
+    }
+    public function getProcess()
+    {
+        return $this->process;
+    }
+    public function isGeneralTimeout()
+    {
+        return self::TYPE_GENERAL === $this->timeoutType;
+    }
+    public function isIdleTimeout()
+    {
+        return self::TYPE_IDLE === $this->timeoutType;
+    }
+    public function getExceededTimeout()
+    {
+        switch ($this->timeoutType) {
+            case self::TYPE_GENERAL:
+                return $this->process->getTimeout();
+            case self::TYPE_IDLE:
+                return $this->process->getIdleTimeout();
+            default:
+                throw new \LogicException(\sprintf('Unknown timeout type "%d".', $this->timeoutType));
+        }
+    }
+}

dependencies/symfony/process/Exception/RuntimeException.php

@@ -0,0 +1,20 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace WP_Ultimo\Dependencies\Symfony\Component\Process\Exception;
+
+/**
+ * RuntimeException for the Process Component.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class RuntimeException extends \RuntimeException implements ExceptionInterface
+{
+}

dependencies/symfony/process/ExecutableFinder.php

@@ -0,0 +1,77 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace WP_Ultimo\Dependencies\Symfony\Component\Process;
+
+/**
+ * Generic executable finder.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class ExecutableFinder
+{
+    private $suffixes = ['.exe', '.bat', '.cmd', '.com'];
+    /**
+     * Replaces default suffixes of executable.
+     */
+    public function setSuffixes(array $suffixes)
+    {
+        $this->suffixes = $suffixes;
+    }
+    /**
+     * Adds new possible suffix to check for executable.
+     */
+    public function addSuffix(string $suffix)
+    {
+        $this->suffixes[] = $suffix;
+    }
+    /**
+     * Finds an executable by name.
+     *
+     * @param string      $name      The executable name (without the extension)
+     * @param string|null $default   The default to return if no executable is found
+     * @param array       $extraDirs Additional dirs to check into
+     *
+     * @return string|null
+     */
+    public function find(string $name, string $default = null, array $extraDirs = [])
+    {
+        if (\ini_get('open_basedir')) {
+            $searchPath = \array_merge(\explode(\PATH_SEPARATOR, \ini_get('open_basedir')), $extraDirs);
+            $dirs = [];
+            foreach ($searchPath as $path) {
+                // Silencing against https://bugs.php.net/69240
+                if (@\is_dir($path)) {
+                    $dirs[] = $path;
+                } else {
+                    if (\basename($path) == $name && @\is_executable($path)) {
+                        return $path;
+                    }
+                }
+            }
+        } else {
+            $dirs = \array_merge(\explode(\PATH_SEPARATOR, \getenv('PATH') ?: \getenv('Path')), $extraDirs);
+        }
+        $suffixes = [''];
+        if ('\\' === \DIRECTORY_SEPARATOR) {
+            $pathExt = \getenv('PATHEXT');
+            $suffixes = \array_merge($pathExt ? \explode(\PATH_SEPARATOR, $pathExt) : $this->suffixes, $suffixes);
+        }
+        foreach ($suffixes as $suffix) {
+            foreach ($dirs as $dir) {
+                if (@\is_file($file = $dir . \DIRECTORY_SEPARATOR . $name . $suffix) && ('\\' === \DIRECTORY_SEPARATOR || @\is_executable($file))) {
+                    return $file;
+                }
+            }
+        }
+        return $default;
+    }
+}

dependencies/symfony/process/InputStream.php

@@ -0,0 +1,87 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace WP_Ultimo\Dependencies\Symfony\Component\Process;
+
+use WP_Ultimo\Dependencies\Symfony\Component\Process\Exception\RuntimeException;
+/**
+ * Provides a way to continuously write to the input of a Process until the InputStream is closed.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @implements \IteratorAggregate<int, string>
+ */
+class InputStream implements \IteratorAggregate
+{
+    /** @var callable|null */
+    private $onEmpty = null;
+    private $input = [];
+    private $open = \true;
+    /**
+     * Sets a callback that is called when the write buffer becomes empty.
+     */
+    public function onEmpty(callable $onEmpty = null)
+    {
+        $this->onEmpty = $onEmpty;
+    }
+    /**
+     * Appends an input to the write buffer.
+     *
+     * @param resource|string|int|float|bool|\Traversable|null $input The input to append as scalar,
+     *                                                                stream resource or \Traversable
+     */
+    public function write($input)
+    {
+        if (null === $input) {
+            return;
+        }
+        if ($this->isClosed()) {
+            throw new RuntimeException(\sprintf('"%s" is closed.', static::class));
+        }
+        $this->input[] = ProcessUtils::validateInput(__METHOD__, $input);
+    }
+    /**
+     * Closes the write buffer.
+     */
+    public function close()
+    {
+        $this->open = \false;
+    }
+    /**
+     * Tells whether the write buffer is closed or not.
+     */
+    public function isClosed()
+    {
+        return !$this->open;
+    }
+    /**
+     * @return \Traversable<int, string>
+     */
+    #[\ReturnTypeWillChange]
+    public function getIterator()
+    {
+        $this->open = \true;
+        while ($this->open || $this->input) {
+            if (!$this->input) {
+                (yield '');
+                continue;
+            }
+            $current = \array_shift($this->input);
+            if ($current instanceof \Iterator) {
+                yield from $current;
+            } else {
+                (yield $current);
+            }
+            if (!$this->input && $this->open && null !== ($onEmpty = $this->onEmpty)) {
+                $this->write($onEmpty($this));
+            }
+        }
+    }
+}

dependencies/symfony/process/PhpExecutableFinder.php

@@ -0,0 +1,88 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace WP_Ultimo\Dependencies\Symfony\Component\Process;
+
+/**
+ * An executable finder specifically designed for the PHP executable.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class PhpExecutableFinder
+{
+    private $executableFinder;
+    public function __construct()
+    {
+        $this->executableFinder = new ExecutableFinder();
+    }
+    /**
+     * Finds The PHP executable.
+     *
+     * @return string|false
+     */
+    public function find(bool $includeArgs = \true)
+    {
+        if ($php = \getenv('PHP_BINARY')) {
+            if (!\is_executable($php)) {
+                $command = '\\' === \DIRECTORY_SEPARATOR ? 'where' : 'command -v';
+                if ($php = \strtok(\exec($command . ' ' . \escapeshellarg($php)), \PHP_EOL)) {
+                    if (!\is_executable($php)) {
+                        return \false;
+                    }
+                } else {
+                    return \false;
+                }
+            }
+            if (@\is_dir($php)) {
+                return \false;
+            }
+            return $php;
+        }
+        $args = $this->findArguments();
+        $args = $includeArgs && $args ? ' ' . \implode(' ', $args) : '';
+        // PHP_BINARY return the current sapi executable
+        if (\PHP_BINARY && \in_array(\PHP_SAPI, ['cli', 'cli-server', 'phpdbg'], \true)) {
+            return \PHP_BINARY . $args;
+        }
+        if ($php = \getenv('PHP_PATH')) {
+            if (!@\is_executable($php) || @\is_dir($php)) {
+                return \false;
+            }
+            return $php;
+        }
+        if ($php = \getenv('PHP_PEAR_PHP_BIN')) {
+            if (@\is_executable($php) && !@\is_dir($php)) {
+                return $php;
+            }
+        }
+        if (@\is_executable($php = \PHP_BINDIR . ('\\' === \DIRECTORY_SEPARATOR ? '\\php.exe' : '/php')) && !@\is_dir($php)) {
+            return $php;
+        }
+        $dirs = [\PHP_BINDIR];
+        if ('\\' === \DIRECTORY_SEPARATOR) {
+            $dirs[] = 'C:\\xampp\\php\\';
+        }
+        return $this->executableFinder->find('php', \false, $dirs);
+    }
+    /**
+     * Finds the PHP executable arguments.
+     *
+     * @return array
+     */
+    public function findArguments()
+    {
+        $arguments = [];
+        if ('phpdbg' === \PHP_SAPI) {
+            $arguments[] = '-qrr';
+        }
+        return $arguments;
+    }
+}

dependencies/symfony/process/PhpProcess.php

@@ -0,0 +1,66 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace WP_Ultimo\Dependencies\Symfony\Component\Process;
+
+use WP_Ultimo\Dependencies\Symfony\Component\Process\Exception\LogicException;
+use WP_Ultimo\Dependencies\Symfony\Component\Process\Exception\RuntimeException;
+/**
+ * PhpProcess runs a PHP script in an independent process.
+ *
+ *     $p = new PhpProcess('<?php echo "foo"; ?>');
+ *     $p->run();
+ *     print $p->getOutput()."\n";
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class PhpProcess extends Process
+{
+    /**
+     * @param string      $script  The PHP script to run (as a string)
+     * @param string|null $cwd     The working directory or null to use the working dir of the current PHP process
+     * @param array|null  $env     The environment variables or null to use the same environment as the current PHP process
+     * @param int         $timeout The timeout in seconds
+     * @param array|null  $php     Path to the PHP binary to use with any additional arguments
+     */
+    public function __construct(string $script, string $cwd = null, array $env = null, int $timeout = 60, array $php = null)
+    {
+        if (null === $php) {
+            $executableFinder = new PhpExecutableFinder();
+            $php = $executableFinder->find(\false);
+            $php = \false === $php ? null : \array_merge([$php], $executableFinder->findArguments());
+        }
+        if ('phpdbg' === \PHP_SAPI) {
+            $file = \tempnam(\sys_get_temp_dir(), 'dbg');
+            \file_put_contents($file, $script);
+            \register_shutdown_function('unlink', $file);
+            $php[] = $file;
+            $script = null;
+        }
+        parent::__construct($php, $cwd, $env, $script, $timeout);
+    }
+    /**
+     * {@inheritdoc}
+     */
+    public static function fromShellCommandline(string $command, string $cwd = null, array $env = null, $input = null, ?float $timeout = 60)
+    {
+        throw new LogicException(\sprintf('The "%s()" method cannot be called when using "%s".', __METHOD__, self::class));
+    }
+    /**
+     * {@inheritdoc}
+     */
+    public function start(callable $callback = null, array $env = [])
+    {
+        if (null === $this->getCommandLine()) {
+            throw new RuntimeException('Unable to find the PHP executable.');
+        }
+        parent::start($callback, $env);
+    }
+}

dependencies/symfony/process/Pipes/AbstractPipes.php

@@ -0,0 +1,160 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace WP_Ultimo\Dependencies\Symfony\Component\Process\Pipes;
+
+use WP_Ultimo\Dependencies\Symfony\Component\Process\Exception\InvalidArgumentException;
+/**
+ * @author Romain Neutron <imprec@gmail.com>
+ *
+ * @internal
+ */
+abstract class AbstractPipes implements PipesInterface
+{
+    public $pipes = [];
+    private $inputBuffer = '';
+    private $input;
+    private $blocked = \true;
+    private $lastError;
+    /**
+     * @param resource|string|int|float|bool|\Iterator|null $input
+     */
+    public function __construct($input)
+    {
+        if (\is_resource($input) || $input instanceof \Iterator) {
+            $this->input = $input;
+        } elseif (\is_string($input)) {
+            $this->inputBuffer = $input;
+        } else {
+            $this->inputBuffer = (string) $input;
+        }
+    }
+    /**
+     * {@inheritdoc}
+     */
+    public function close()
+    {
+        foreach ($this->pipes as $pipe) {
+            if (\is_resource($pipe)) {
+                \fclose($pipe);
+            }
+        }
+        $this->pipes = [];
+    }
+    /**
+     * Returns true if a system call has been interrupted.
+     */
+    protected function hasSystemCallBeenInterrupted() : bool
+    {
+        $lastError = $this->lastError;
+        $this->lastError = null;
+        // stream_select returns false when the `select` system call is interrupted by an incoming signal
+        return null !== $lastError && \false !== \stripos($lastError, 'interrupted system call');
+    }
+    /**
+     * Unblocks streams.
+     */
+    protected function unblock()
+    {
+        if (!$this->blocked) {
+            return;
+        }
+        foreach ($this->pipes as $pipe) {
+            \stream_set_blocking($pipe, 0);
+        }
+        if (\is_resource($this->input)) {
+            \stream_set_blocking($this->input, 0);
+        }
+        $this->blocked = \false;
+    }
+    /**
+     * Writes input to stdin.
+     *
+     * @throws InvalidArgumentException When an input iterator yields a non supported value
+     */
+    protected function write() : ?array
+    {
+        if (!isset($this->pipes[0])) {
+            return null;
+        }
+        $input = $this->input;
+        if ($input instanceof \Iterator) {
+            if (!$input->valid()) {
+                $input = null;
+            } elseif (\is_resource($input = $input->current())) {
+                \stream_set_blocking($input, 0);
+            } elseif (!isset($this->inputBuffer[0])) {
+                if (!\is_string($input)) {
+                    if (!\is_scalar($input)) {
+                        throw new InvalidArgumentException(\sprintf('"%s" yielded a value of type "%s", but only scalars and stream resources are supported.', \get_debug_type($this->input), \get_debug_type($input)));
+                    }
+                    $input = (string) $input;
+                }
+                $this->inputBuffer = $input;
+                $this->input->next();
+                $input = null;
+            } else {
+                $input = null;
+            }
+        }
+        $r = $e = [];
+        $w = [$this->pipes[0]];
+        // let's have a look if something changed in streams
+        if (\false === @\stream_select($r, $w, $e, 0, 0)) {
+            return null;
+        }
+        foreach ($w as $stdin) {
+            if (isset($this->inputBuffer[0])) {
+                $written = \fwrite($stdin, $this->inputBuffer);
+                $this->inputBuffer = \substr($this->inputBuffer, $written);
+                if (isset($this->inputBuffer[0])) {
+                    return [$this->pipes[0]];
+                }
+            }
+            if ($input) {
+                while (\true) {
+                    $data = \fread($input, self::CHUNK_SIZE);
+                    if (!isset($data[0])) {
+                        break;
+                    }
+                    $written = \fwrite($stdin, $data);
+                    $data = \substr($data, $written);
+                    if (isset($data[0])) {
+                        $this->inputBuffer = $data;
+                        return [$this->pipes[0]];
+                    }
+                }
+                if (\feof($input)) {
+                    if ($this->input instanceof \Iterator) {
+                        $this->input->next();
+                    } else {
+                        $this->input = null;
+                    }
+                }
+            }
+        }
+        // no input to read on resource, buffer is empty
+        if (!isset($this->inputBuffer[0]) && !($this->input instanceof \Iterator ? $this->input->valid() : $this->input)) {
+            $this->input = null;
+            \fclose($this->pipes[0]);
+            unset($this->pipes[0]);
+        } elseif (!$w) {
+            return [$this->pipes[0]];
+        }
+        return null;
+    }
+    /**
+     * @internal
+     */
+    public function handleError(int $type, string $msg)
+    {
+        $this->lastError = $msg;
+    }
+}

dependencies/symfony/process/Pipes/PipesInterface.php

@@ -0,0 +1,54 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace WP_Ultimo\Dependencies\Symfony\Component\Process\Pipes;
+
+/**
+ * PipesInterface manages descriptors and pipes for the use of proc_open.
+ *
+ * @author Romain Neutron <imprec@gmail.com>
+ *
+ * @internal
+ */
+interface PipesInterface
+{
+    public const CHUNK_SIZE = 16384;
+    /**
+     * Returns an array of descriptors for the use of proc_open.
+     */
+    public function getDescriptors() : array;
+    /**
+     * Returns an array of filenames indexed by their related stream in case these pipes use temporary files.
+     *
+     * @return string[]
+     */
+    public function getFiles() : array;
+    /**
+     * Reads data in file handles and pipes.
+     *
+     * @param bool $blocking Whether to use blocking calls or not
+     * @param bool $close    Whether to close pipes if they've reached EOF
+     *
+     * @return string[] An array of read data indexed by their fd
+     */
+    public function readAndWrite(bool $blocking, bool $close = \false) : array;
+    /**
+     * Returns if the current state has open file handles or pipes.
+     */
+    public function areOpen() : bool;
+    /**
+     * Returns if pipes are able to read output.
+     */
+    public function haveReadSupport() : bool;
+    /**
+     * Closes file handles and pipes.
+     */
+    public function close();
+}

dependencies/symfony/process/Pipes/UnixPipes.php

@@ -0,0 +1,128 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace WP_Ultimo\Dependencies\Symfony\Component\Process\Pipes;
+
+use WP_Ultimo\Dependencies\Symfony\Component\Process\Process;
+/**
+ * UnixPipes implementation uses unix pipes as handles.
+ *
+ * @author Romain Neutron <imprec@gmail.com>
+ *
+ * @internal
+ */
+class UnixPipes extends AbstractPipes
+{
+    private $ttyMode;
+    private $ptyMode;
+    private $haveReadSupport;
+    public function __construct(?bool $ttyMode, bool $ptyMode, $input, bool $haveReadSupport)
+    {
+        $this->ttyMode = $ttyMode;
+        $this->ptyMode = $ptyMode;
+        $this->haveReadSupport = $haveReadSupport;
+        parent::__construct($input);
+    }
+    public function __sleep() : array
+    {
+        throw new \BadMethodCallException('Cannot serialize ' . __CLASS__);
+    }
+    public function __wakeup()
+    {
+        throw new \BadMethodCallException('Cannot unserialize ' . __CLASS__);
+    }
+    public function __destruct()
+    {
+        $this->close();
+    }
+    /**
+     * {@inheritdoc}
+     */
+    public function getDescriptors() : array
+    {
+        if (!$this->haveReadSupport) {
+            $nullstream = \fopen('/dev/null', 'c');
+            return [['pipe', 'r'], $nullstream, $nullstream];
+        }
+        if ($this->ttyMode) {
+            return [['file', '/dev/tty', 'r'], ['file', '/dev/tty', 'w'], ['file', '/dev/tty', 'w']];
+        }
+        if ($this->ptyMode && Process::isPtySupported()) {
+            return [['pty'], ['pty'], ['pty']];
+        }
+        return [
+            ['pipe', 'r'],
+            ['pipe', 'w'],
+            // stdout
+            ['pipe', 'w'],
+        ];
+    }
+    /**
+     * {@inheritdoc}
+     */
+    public function getFiles() : array
+    {
+        return [];
+    }
+    /**
+     * {@inheritdoc}
+     */
+    public function readAndWrite(bool $blocking, bool $close = \false) : array
+    {
+        $this->unblock();
+        $w = $this->write();
+        $read = $e = [];
+        $r = $this->pipes;
+        unset($r[0]);
+        // let's have a look if something changed in streams
+        \set_error_handler([$this, 'handleError']);
+        if (($r || $w) && \false === \stream_select($r, $w, $e, 0, $blocking ? Process::TIMEOUT_PRECISION * 1000000.0 : 0)) {
+            \restore_error_handler();
+            // if a system call has been interrupted, forget about it, let's try again
+            // otherwise, an error occurred, let's reset pipes
+            if (!$this->hasSystemCallBeenInterrupted()) {
+                $this->pipes = [];
+            }
+            return $read;
+        }
+        \restore_error_handler();
+        foreach ($r as $pipe) {
+            // prior PHP 5.4 the array passed to stream_select is modified and
+            // lose key association, we have to find back the key
+            $read[$type = \array_search($pipe, $this->pipes, \true)] = '';
+            do {
+                $data = @\fread($pipe, self::CHUNK_SIZE);
+                $read[$type] .= $data;
+            } while (isset($data[0]) && ($close || isset($data[self::CHUNK_SIZE - 1])));
+            if (!isset($read[$type][0])) {
+                unset($read[$type]);
+            }
+            if ($close && \feof($pipe)) {
+                \fclose($pipe);
+                unset($this->pipes[$type]);
+            }
+        }
+        return $read;
+    }
+    /**
+     * {@inheritdoc}
+     */
+    public function haveReadSupport() : bool
+    {
+        return $this->haveReadSupport;
+    }
+    /**
+     * {@inheritdoc}
+     */
+    public function areOpen() : bool
+    {
+        return (bool) $this->pipes;
+    }
+}

dependencies/symfony/process/Pipes/WindowsPipes.php

@@ -0,0 +1,171 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace WP_Ultimo\Dependencies\Symfony\Component\Process\Pipes;
+
+use WP_Ultimo\Dependencies\Symfony\Component\Process\Exception\RuntimeException;
+use WP_Ultimo\Dependencies\Symfony\Component\Process\Process;
+/**
+ * WindowsPipes implementation uses temporary files as handles.
+ *
+ * @see https://bugs.php.net/51800
+ * @see https://bugs.php.net/65650
+ *
+ * @author Romain Neutron <imprec@gmail.com>
+ *
+ * @internal
+ */
+class WindowsPipes extends AbstractPipes
+{
+    private $files = [];
+    private $fileHandles = [];
+    private $lockHandles = [];
+    private $readBytes = [Process::STDOUT => 0, Process::STDERR => 0];
+    private $haveReadSupport;
+    public function __construct($input, bool $haveReadSupport)
+    {
+        $this->haveReadSupport = $haveReadSupport;
+        if ($this->haveReadSupport) {
+            // Fix for PHP bug #51800: reading from STDOUT pipe hangs forever on Windows if the output is too big.
+            // Workaround for this problem is to use temporary files instead of pipes on Windows platform.
+            //
+            // @see https://bugs.php.net/51800
+            $pipes = [Process::STDOUT => Process::OUT, Process::STDERR => Process::ERR];
+            $tmpDir = \sys_get_temp_dir();
+            $lastError = 'unknown reason';
+            \set_error_handler(function ($type, $msg) use(&$lastError) {
+                $lastError = $msg;
+            });
+            for ($i = 0;; ++$i) {
+                foreach ($pipes as $pipe => $name) {
+                    $file = \sprintf('%s\\sf_proc_%02X.%s', $tmpDir, $i, $name);
+                    if (!($h = \fopen($file . '.lock', 'w'))) {
+                        if (\file_exists($file . '.lock')) {
+                            continue 2;
+                        }
+                        \restore_error_handler();
+                        throw new RuntimeException('A temporary file could not be opened to write the process output: ' . $lastError);
+                    }
+                    if (!\flock($h, \LOCK_EX | \LOCK_NB)) {
+                        continue 2;
+                    }
+                    if (isset($this->lockHandles[$pipe])) {
+                        \flock($this->lockHandles[$pipe], \LOCK_UN);
+                        \fclose($this->lockHandles[$pipe]);
+                    }
+                    $this->lockHandles[$pipe] = $h;
+                    if (!($h = \fopen($file, 'w')) || !\fclose($h) || !($h = \fopen($file, 'r'))) {
+                        \flock($this->lockHandles[$pipe], \LOCK_UN);
+                        \fclose($this->lockHandles[$pipe]);
+                        unset($this->lockHandles[$pipe]);
+                        continue 2;
+                    }
+                    $this->fileHandles[$pipe] = $h;
+                    $this->files[$pipe] = $file;
+                }
+                break;
+            }
+            \restore_error_handler();
+        }
+        parent::__construct($input);
+    }
+    public function __sleep() : array
+    {
+        throw new \BadMethodCallException('Cannot serialize ' . __CLASS__);
+    }
+    public function __wakeup()
+    {
+        throw new \BadMethodCallException('Cannot unserialize ' . __CLASS__);
+    }
+    public function __destruct()
+    {
+        $this->close();
+    }
+    /**
+     * {@inheritdoc}
+     */
+    public function getDescriptors() : array
+    {
+        if (!$this->haveReadSupport) {
+            $nullstream = \fopen('NUL', 'c');
+            return [['pipe', 'r'], $nullstream, $nullstream];
+        }
+        // We're not using pipe on Windows platform as it hangs (https://bugs.php.net/51800)
+        // We're not using file handles as it can produce corrupted output https://bugs.php.net/65650
+        // So we redirect output within the commandline and pass the nul device to the process
+        return [['pipe', 'r'], ['file', 'NUL', 'w'], ['file', 'NUL', 'w']];
+    }
+    /**
+     * {@inheritdoc}
+     */
+    public function getFiles() : array
+    {
+        return $this->files;
+    }
+    /**
+     * {@inheritdoc}
+     */
+    public function readAndWrite(bool $blocking, bool $close = \false) : array
+    {
+        $this->unblock();
+        $w = $this->write();
+        $read = $r = $e = [];
+        if ($blocking) {
+            if ($w) {
+                @\stream_select($r, $w, $e, 0, Process::TIMEOUT_PRECISION * 1000000.0);
+            } elseif ($this->fileHandles) {
+                \usleep(Process::TIMEOUT_PRECISION * 1000000.0);
+            }
+        }
+        foreach ($this->fileHandles as $type => $fileHandle) {
+            $data = \stream_get_contents($fileHandle, -1, $this->readBytes[$type]);
+            if (isset($data[0])) {
+                $this->readBytes[$type] += \strlen($data);
+                $read[$type] = $data;
+            }
+            if ($close) {
+                \ftruncate($fileHandle, 0);
+                \fclose($fileHandle);
+                \flock($this->lockHandles[$type], \LOCK_UN);
+                \fclose($this->lockHandles[$type]);
+                unset($this->fileHandles[$type], $this->lockHandles[$type]);
+            }
+        }
+        return $read;
+    }
+    /**
+     * {@inheritdoc}
+     */
+    public function haveReadSupport() : bool
+    {
+        return $this->haveReadSupport;
+    }
+    /**
+     * {@inheritdoc}
+     */
+    public function areOpen() : bool
+    {
+        return $this->pipes && $this->fileHandles;
+    }
+    /**
+     * {@inheritdoc}
+     */
+    public function close()
+    {
+        parent::close();
+        foreach ($this->fileHandles as $type => $handle) {
+            \ftruncate($handle, 0);
+            \fclose($handle);
+            \flock($this->lockHandles[$type], \LOCK_UN);
+            \fclose($this->lockHandles[$type]);
+        }
+        $this->fileHandles = $this->lockHandles = [];
+    }
+}

dependencies/symfony/process/ProcessUtils.php

@@ -0,0 +1,64 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace WP_Ultimo\Dependencies\Symfony\Component\Process;
+
+use WP_Ultimo\Dependencies\Symfony\Component\Process\Exception\InvalidArgumentException;
+/**
+ * ProcessUtils is a bunch of utility methods.
+ *
+ * This class contains static methods only and is not meant to be instantiated.
+ *
+ * @author Martin Hasoň <martin.hason@gmail.com>
+ */
+class ProcessUtils
+{
+    /**
+     * This class should not be instantiated.
+     */
+    private function __construct()
+    {
+    }
+    /**
+     * Validates and normalizes a Process input.
+     *
+     * @param string $caller The name of method call that validates the input
+     * @param mixed  $input  The input to validate
+     *
+     * @return mixed
+     *
+     * @throws InvalidArgumentException In case the input is not valid
+     */
+    public static function validateInput(string $caller, $input)
+    {
+        if (null !== $input) {
+            if (\is_resource($input)) {
+                return $input;
+            }
+            if (\is_string($input)) {
+                return $input;
+            }
+            if (\is_scalar($input)) {
+                return (string) $input;
+            }
+            if ($input instanceof Process) {
+                return $input->getIterator($input::ITER_SKIP_ERR);
+            }
+            if ($input instanceof \Iterator) {
+                return $input;
+            }
+            if ($input instanceof \Traversable) {
+                return new \IteratorIterator($input);
+            }
+            throw new InvalidArgumentException(\sprintf('"%s" only accepts strings, Traversable objects or stream resources.', $caller));
+        }
+        return $input;
+    }
+}