html2pdf

html2pdf-master/vendor/symfony/yaml/.gitignore

@@ -0,0 +1,3 @@
+vendor/
+composer.lock
+phpunit.xml

html2pdf-master/vendor/symfony/yaml/CHANGELOG.md

@@ -0,0 +1,131 @@
+CHANGELOG
+=========
+
+3.3.0
+-----
+
+ * Starting an unquoted string with a question mark followed by a space is
+   deprecated and will throw a `ParseException` in Symfony 4.0.
+
+ * Deprecated support for implicitly parsing non-string mapping keys as strings.
+   Mapping keys that are no strings will lead to a `ParseException` in Symfony
+   4.0. Use quotes to opt-in for keys to be parsed as strings.
+
+   Before:
+
+   ```php
+   $yaml = <<<YAML
+   null: null key
+   true: boolean true
+   2.0: float key
+   YAML;
+
+   Yaml::parse($yaml);
+   ```
+
+   After:
+
+   ```php
+
+   $yaml = <<<YAML
+   "null": null key
+   "true": boolean true
+   "2.0": float key
+   YAML;
+
+   Yaml::parse($yaml);
+   ```
+
+ * Omitted mapping values will be parsed as `null`.
+
+ * Omitting the key of a mapping is deprecated and will throw a `ParseException` in Symfony 4.0.
+
+ * Added support for dumping empty PHP arrays as YAML sequences:
+
+   ```php
+   Yaml::dump([], 0, 0, Yaml::DUMP_EMPTY_ARRAY_AS_SEQUENCE);
+   ```
+
+3.2.0
+-----
+
+ * Mappings with a colon (`:`) that is not followed by a whitespace are deprecated
+   when the mapping key is not quoted and will lead to a `ParseException` in
+   Symfony 4.0 (e.g. `foo:bar` must be `foo: bar`).
+
+ * Added support for parsing PHP constants:
+
+   ```php
+   Yaml::parse('!php/const:PHP_INT_MAX', Yaml::PARSE_CONSTANT);
+   ```
+
+ * Support for silently ignoring duplicate mapping keys in YAML has been
+   deprecated and will lead to a `ParseException` in Symfony 4.0.
+
+3.1.0
+-----
+
+ * Added support to dump `stdClass` and `ArrayAccess` objects as YAML mappings
+   through the `Yaml::DUMP_OBJECT_AS_MAP` flag.
+
+ * Strings that are not UTF-8 encoded will be dumped as base64 encoded binary
+   data.
+
+ * Added support for dumping multi line strings as literal blocks.
+
+ * Added support for parsing base64 encoded binary data when they are tagged
+   with the `!!binary` tag.
+
+ * Added support for parsing timestamps as `\DateTime` objects:
+
+   ```php
+   Yaml::parse('2001-12-15 21:59:43.10 -5', Yaml::PARSE_DATETIME);
+   ```
+
+ * `\DateTime` and `\DateTimeImmutable` objects are dumped as YAML timestamps.
+
+ * Deprecated usage of `%` at the beginning of an unquoted string.
+
+ * Added support for customizing the YAML parser behavior through an optional bit field:
+
+   ```php
+   Yaml::parse('{ "foo": "bar", "fiz": "cat" }', Yaml::PARSE_EXCEPTION_ON_INVALID_TYPE | Yaml::PARSE_OBJECT | Yaml::PARSE_OBJECT_FOR_MAP);
+   ```
+
+ * Added support for customizing the dumped YAML string through an optional bit field:
+
+   ```php
+   Yaml::dump(array('foo' => new A(), 'bar' => 1), 0, 0, Yaml::DUMP_EXCEPTION_ON_INVALID_TYPE | Yaml::DUMP_OBJECT);
+   ```
+
+3.0.0
+-----
+
+ * Yaml::parse() now throws an exception when a blackslash is not escaped
+   in double-quoted strings
+
+2.8.0
+-----
+
+ * Deprecated usage of a colon in an unquoted mapping value
+ * Deprecated usage of @, \`, | and > at the beginning of an unquoted string
+ * When surrounding strings with double-quotes, you must now escape `\` characters. Not
+   escaping those characters (when surrounded by double-quotes) is deprecated.
+
+   Before:
+
+   ```yml
+   class: "Foo\Var"
+   ```
+
+   After:
+
+   ```yml
+   class: "Foo\\Var"
+   ```
+
+2.1.0
+-----
+
+ * Yaml::parse() does not evaluate loaded files as PHP files by default
+   anymore (call Yaml::enablePhpParsing() to get back the old behavior)

html2pdf-master/vendor/symfony/yaml/Command/LintCommand.php

@@ -0,0 +1,245 @@
+<?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 Symfony\Component\Yaml\Command;
+
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Style\SymfonyStyle;
+use Symfony\Component\Yaml\Exception\ParseException;
+use Symfony\Component\Yaml\Parser;
+use Symfony\Component\Yaml\Yaml;
+
+/**
+ * Validates YAML files syntax and outputs encountered errors.
+ *
+ * @author Grégoire Pineau <lyrixx@lyrixx.info>
+ * @author Robin Chalas <robin.chalas@gmail.com>
+ */
+class LintCommand extends Command
+{
+    private $parser;
+    private $format;
+    private $displayCorrectFiles;
+    private $directoryIteratorProvider;
+    private $isReadableProvider;
+
+    public function __construct($name = null, $directoryIteratorProvider = null, $isReadableProvider = null)
+    {
+        parent::__construct($name);
+
+        $this->directoryIteratorProvider = $directoryIteratorProvider;
+        $this->isReadableProvider = $isReadableProvider;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function configure()
+    {
+        $this
+            ->setName('lint:yaml')
+            ->setDescription('Lints a file and outputs encountered errors')
+            ->addArgument('filename', null, 'A file or a directory or STDIN')
+            ->addOption('format', null, InputOption::VALUE_REQUIRED, 'The output format', 'txt')
+            ->setHelp(<<<EOF
+The <info>%command.name%</info> command lints a YAML file and outputs to STDOUT
+the first encountered syntax error.
+
+You can validates YAML contents passed from STDIN:
+
+  <info>cat filename | php %command.full_name%</info>
+
+You can also validate the syntax of a file:
+
+  <info>php %command.full_name% filename</info>
+
+Or of a whole directory:
+
+  <info>php %command.full_name% dirname</info>
+  <info>php %command.full_name% dirname --format=json</info>
+
+EOF
+            )
+        ;
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output)
+    {
+        $io = new SymfonyStyle($input, $output);
+        $filename = $input->getArgument('filename');
+        $this->format = $input->getOption('format');
+        $this->displayCorrectFiles = $output->isVerbose();
+
+        if (!$filename) {
+            if (!$stdin = $this->getStdin()) {
+                throw new \RuntimeException('Please provide a filename or pipe file content to STDIN.');
+            }
+
+            return $this->display($io, array($this->validate($stdin)));
+        }
+
+        if (!$this->isReadable($filename)) {
+            throw new \RuntimeException(sprintf('File or directory "%s" is not readable.', $filename));
+        }
+
+        $filesInfo = array();
+        foreach ($this->getFiles($filename) as $file) {
+            $filesInfo[] = $this->validate(file_get_contents($file), $file);
+        }
+
+        return $this->display($io, $filesInfo);
+    }
+
+    private function validate($content, $file = null)
+    {
+        $prevErrorHandler = set_error_handler(function ($level, $message, $file, $line) use (&$prevErrorHandler) {
+            if (E_USER_DEPRECATED === $level) {
+                throw new ParseException($message);
+            }
+
+            return $prevErrorHandler ? $prevErrorHandler($level, $message, $file, $line) : false;
+        });
+
+        try {
+            $this->getParser()->parse($content, Yaml::PARSE_CONSTANT);
+        } catch (ParseException $e) {
+            return array('file' => $file, 'valid' => false, 'message' => $e->getMessage());
+        } finally {
+            restore_error_handler();
+        }
+
+        return array('file' => $file, 'valid' => true);
+    }
+
+    private function display(SymfonyStyle $io, array $files)
+    {
+        switch ($this->format) {
+            case 'txt':
+                return $this->displayTxt($io, $files);
+            case 'json':
+                return $this->displayJson($io, $files);
+            default:
+                throw new \InvalidArgumentException(sprintf('The format "%s" is not supported.', $this->format));
+        }
+    }
+
+    private function displayTxt(SymfonyStyle $io, array $filesInfo)
+    {
+        $countFiles = count($filesInfo);
+        $erroredFiles = 0;
+
+        foreach ($filesInfo as $info) {
+            if ($info['valid'] && $this->displayCorrectFiles) {
+                $io->comment('<info>OK</info>'.($info['file'] ? sprintf(' in %s', $info['file']) : ''));
+            } elseif (!$info['valid']) {
+                ++$erroredFiles;
+                $io->text('<error> ERROR </error>'.($info['file'] ? sprintf(' in %s', $info['file']) : ''));
+                $io->text(sprintf('<error> >> %s</error>', $info['message']));
+            }
+        }
+
+        if ($erroredFiles === 0) {
+            $io->success(sprintf('All %d YAML files contain valid syntax.', $countFiles));
+        } else {
+            $io->warning(sprintf('%d YAML files have valid syntax and %d contain errors.', $countFiles - $erroredFiles, $erroredFiles));
+        }
+
+        return min($erroredFiles, 1);
+    }
+
+    private function displayJson(SymfonyStyle $io, array $filesInfo)
+    {
+        $errors = 0;
+
+        array_walk($filesInfo, function (&$v) use (&$errors) {
+            $v['file'] = (string) $v['file'];
+            if (!$v['valid']) {
+                ++$errors;
+            }
+        });
+
+        $io->writeln(json_encode($filesInfo, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES));
+
+        return min($errors, 1);
+    }
+
+    private function getFiles($fileOrDirectory)
+    {
+        if (is_file($fileOrDirectory)) {
+            yield new \SplFileInfo($fileOrDirectory);
+
+            return;
+        }
+
+        foreach ($this->getDirectoryIterator($fileOrDirectory) as $file) {
+            if (!in_array($file->getExtension(), array('yml', 'yaml'))) {
+                continue;
+            }
+
+            yield $file;
+        }
+    }
+
+    private function getStdin()
+    {
+        if (0 !== ftell(STDIN)) {
+            return;
+        }
+
+        $inputs = '';
+        while (!feof(STDIN)) {
+            $inputs .= fread(STDIN, 1024);
+        }
+
+        return $inputs;
+    }
+
+    private function getParser()
+    {
+        if (!$this->parser) {
+            $this->parser = new Parser();
+        }
+
+        return $this->parser;
+    }
+
+    private function getDirectoryIterator($directory)
+    {
+        $default = function ($directory) {
+            return new \RecursiveIteratorIterator(
+                new \RecursiveDirectoryIterator($directory, \FilesystemIterator::SKIP_DOTS | \FilesystemIterator::FOLLOW_SYMLINKS),
+                \RecursiveIteratorIterator::LEAVES_ONLY
+            );
+        };
+
+        if (null !== $this->directoryIteratorProvider) {
+            return call_user_func($this->directoryIteratorProvider, $directory, $default);
+        }
+
+        return $default($directory);
+    }
+
+    private function isReadable($fileOrDirectory)
+    {
+        $default = function ($fileOrDirectory) {
+            return is_readable($fileOrDirectory);
+        };
+
+        if (null !== $this->isReadableProvider) {
+            return call_user_func($this->isReadableProvider, $fileOrDirectory, $default);
+        }
+
+        return $default($fileOrDirectory);
+    }
+}

html2pdf-master/vendor/symfony/yaml/Dumper.php

@@ -0,0 +1,127 @@
+<?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 Symfony\Component\Yaml;
+
+/**
+ * Dumper dumps PHP variables to YAML strings.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class Dumper
+{
+    /**
+     * The amount of spaces to use for indentation of nested nodes.
+     *
+     * @var int
+     */
+    protected $indentation;
+
+    /**
+     * @param int $indentation
+     */
+    public function __construct($indentation = 4)
+    {
+        if ($indentation < 1) {
+            throw new \InvalidArgumentException('The indentation must be greater than zero.');
+        }
+
+        $this->indentation = $indentation;
+    }
+
+    /**
+     * Sets the indentation.
+     *
+     * @param int $num The amount of spaces to use for indentation of nested nodes
+     *
+     * @deprecated since version 3.1, to be removed in 4.0. Pass the indentation to the constructor instead.
+     */
+    public function setIndentation($num)
+    {
+        @trigger_error('The '.__METHOD__.' method is deprecated since version 3.1 and will be removed in 4.0. Pass the indentation to the constructor instead.', E_USER_DEPRECATED);
+
+        $this->indentation = (int) $num;
+    }
+
+    /**
+     * Dumps a PHP value to YAML.
+     *
+     * @param mixed $input  The PHP value
+     * @param int   $inline The level where you switch to inline YAML
+     * @param int   $indent The level of indentation (used internally)
+     * @param int   $flags  A bit field of Yaml::DUMP_* constants to customize the dumped YAML string
+     *
+     * @return string The YAML representation of the PHP value
+     */
+    public function dump($input, $inline = 0, $indent = 0, $flags = 0)
+    {
+        if (is_bool($flags)) {
+            @trigger_error('Passing a boolean flag to toggle exception handling is deprecated since version 3.1 and will be removed in 4.0. Use the Yaml::DUMP_EXCEPTION_ON_INVALID_TYPE flag instead.', E_USER_DEPRECATED);
+
+            if ($flags) {
+                $flags = Yaml::DUMP_EXCEPTION_ON_INVALID_TYPE;
+            } else {
+                $flags = 0;
+            }
+        }
+
+        if (func_num_args() >= 5) {
+            @trigger_error('Passing a boolean flag to toggle object support is deprecated since version 3.1 and will be removed in 4.0. Use the Yaml::DUMP_OBJECT flag instead.', E_USER_DEPRECATED);
+
+            if (func_get_arg(4)) {
+                $flags |= Yaml::DUMP_OBJECT;
+            }
+        }
+
+        $output = '';
+        $prefix = $indent ? str_repeat(' ', $indent) : '';
+        $dumpObjectAsInlineMap = true;
+
+        if (Yaml::DUMP_OBJECT_AS_MAP & $flags && ($input instanceof \ArrayObject || $input instanceof \stdClass)) {
+            $dumpObjectAsInlineMap = empty((array) $input);
+        }
+
+        if ($inline <= 0 || (!is_array($input) && $dumpObjectAsInlineMap) || empty($input)) {
+            $output .= $prefix.Inline::dump($input, $flags);
+        } else {
+            $dumpAsMap = Inline::isHash($input);
+
+            foreach ($input as $key => $value) {
+                if ($inline >= 1 && Yaml::DUMP_MULTI_LINE_LITERAL_BLOCK & $flags && is_string($value) && false !== strpos($value, "\n")) {
+                    $output .= sprintf("%s%s%s |\n", $prefix, $dumpAsMap ? Inline::dump($key, $flags).':' : '-', '');
+
+                    foreach (preg_split('/\n|\r\n/', $value) as $row) {
+                        $output .= sprintf("%s%s%s\n", $prefix, str_repeat(' ', $this->indentation), $row);
+                    }
+
+                    continue;
+                }
+
+                $dumpObjectAsInlineMap = true;
+
+                if (Yaml::DUMP_OBJECT_AS_MAP & $flags && ($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 ? Inline::dump($key, $flags).':' : '-',
+                    $willBeInlined ? ' ' : "\n",
+                    $this->dump($value, $inline - 1, $willBeInlined ? 0 : $indent + $this->indentation, $flags)
+                ).($willBeInlined ? "\n" : '');
+            }
+        }
+
+        return $output;
+    }
+}

html2pdf-master/vendor/symfony/yaml/Escaper.php

@@ -0,0 +1,101 @@
+<?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 Symfony\Component\Yaml;
+
+/**
+ * Escaper encapsulates escaping rules for single and double-quoted
+ * YAML strings.
+ *
+ * @author Matthew Lewinski <matthew@lewinski.org>
+ *
+ * @internal
+ */
+class Escaper
+{
+    // Characters that would cause a dumped string to require double quoting.
+    const REGEX_CHARACTER_TO_ESCAPE = "[\\x00-\\x1f]|\xc2\x85|\xc2\xa0|\xe2\x80\xa8|\xe2\x80\xa9";
+
+    // Mapping arrays for escaping a double quoted string. The backslash is
+    // first to ensure proper escaping because str_replace operates iteratively
+    // on the input arrays. This ordering of the characters avoids the use of strtr,
+    // which performs more slowly.
+    private static $escapees = array('\\', '\\\\', '\\"', '"',
+                                     "\x00",  "\x01",  "\x02",  "\x03",  "\x04",  "\x05",  "\x06",  "\x07",
+                                     "\x08",  "\x09",  "\x0a",  "\x0b",  "\x0c",  "\x0d",  "\x0e",  "\x0f",
+                                     "\x10",  "\x11",  "\x12",  "\x13",  "\x14",  "\x15",  "\x16",  "\x17",
+                                     "\x18",  "\x19",  "\x1a",  "\x1b",  "\x1c",  "\x1d",  "\x1e",  "\x1f",
+                                     "\xc2\x85", "\xc2\xa0", "\xe2\x80\xa8", "\xe2\x80\xa9",
+                               );
+    private static $escaped = array('\\\\', '\\"', '\\\\', '\\"',
+                                     '\\0',   '\\x01', '\\x02', '\\x03', '\\x04', '\\x05', '\\x06', '\\a',
+                                     '\\b',   '\\t',   '\\n',   '\\v',   '\\f',   '\\r',   '\\x0e', '\\x0f',
+                                     '\\x10', '\\x11', '\\x12', '\\x13', '\\x14', '\\x15', '\\x16', '\\x17',
+                                     '\\x18', '\\x19', '\\x1a', '\\e',   '\\x1c', '\\x1d', '\\x1e', '\\x1f',
+                                     '\\N', '\\_', '\\L', '\\P',
+                              );
+
+    /**
+     * Determines if a PHP value would require double quoting in YAML.
+     *
+     * @param string $value A PHP value
+     *
+     * @return bool True if the value would require double quotes
+     */
+    public static function requiresDoubleQuoting($value)
+    {
+        return 0 < preg_match('/'.self::REGEX_CHARACTER_TO_ESCAPE.'/u', $value);
+    }
+
+    /**
+     * Escapes and surrounds a PHP value with double quotes.
+     *
+     * @param string $value A PHP value
+     *
+     * @return string The quoted, escaped string
+     */
+    public static function escapeWithDoubleQuotes($value)
+    {
+        return sprintf('"%s"', str_replace(self::$escapees, self::$escaped, $value));
+    }
+
+    /**
+     * Determines if a PHP value would require single quoting in YAML.
+     *
+     * @param string $value A PHP value
+     *
+     * @return bool True if the value would require single quotes
+     */
+    public static function requiresSingleQuoting($value)
+    {
+        // Determines if a PHP value is entirely composed of a value that would
+        // require single quoting in YAML.
+        if (in_array(strtolower($value), array('null', '~', 'true', 'false', 'y', 'n', 'yes', 'no', 'on', 'off'))) {
+            return true;
+        }
+
+        // Determines if the PHP value contains any single characters that would
+        // cause it to require single quoting in YAML.
+        return 0 < preg_match('/[ \s \' " \: \{ \} \[ \] , & \* \# \?] | \A[ \- ? | < > = ! % @ ` ]/x', $value);
+    }
+
+    /**
+     * Escapes and surrounds a PHP value with single quotes.
+     *
+     * @param string $value A PHP value
+     *
+     * @return string The quoted, escaped string
+     */
+    public static function escapeWithSingleQuotes($value)
+    {
+        return sprintf("'%s'", str_replace('\'', '\'\'', $value));
+    }
+}

html2pdf-master/vendor/symfony/yaml/Exception/DumpException.php

@@ -0,0 +1,21 @@
+<?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 Symfony\Component\Yaml\Exception;
+
+/**
+ * Exception class thrown when an error occurs during dumping.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class DumpException extends RuntimeException
+{
+}

html2pdf-master/vendor/symfony/yaml/Exception/ExceptionInterface.php

@@ -0,0 +1,21 @@
+<?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 Symfony\Component\Yaml\Exception;
+
+/**
+ * Exception interface for all exceptions thrown by the component.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+interface ExceptionInterface
+{
+}

html2pdf-master/vendor/symfony/yaml/Exception/ParseException.php

@@ -0,0 +1,141 @@
+<?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 Symfony\Component\Yaml\Exception;
+
+/**
+ * Exception class thrown when an error occurs during parsing.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class ParseException extends RuntimeException
+{
+    private $parsedFile;
+    private $parsedLine;
+    private $snippet;
+    private $rawMessage;
+
+    /**
+     * Constructor.
+     *
+     * @param string          $message    The error message
+     * @param int             $parsedLine The line where the error occurred
+     * @param string|null     $snippet    The snippet of code near the problem
+     * @param string|null     $parsedFile The file name where the error occurred
+     * @param \Exception|null $previous   The previous exception
+     */
+    public function __construct($message, $parsedLine = -1, $snippet = null, $parsedFile = null, \Exception $previous = null)
+    {
+        $this->parsedFile = $parsedFile;
+        $this->parsedLine = $parsedLine;
+        $this->snippet = $snippet;
+        $this->rawMessage = $message;
+
+        $this->updateRepr();
+
+        parent::__construct($this->message, 0, $previous);
+    }
+
+    /**
+     * Gets the snippet of code near the error.
+     *
+     * @return string The snippet of code
+     */
+    public function getSnippet()
+    {
+        return $this->snippet;
+    }
+
+    /**
+     * Sets the snippet of code near the error.
+     *
+     * @param string $snippet The code snippet
+     */
+    public function setSnippet($snippet)
+    {
+        $this->snippet = $snippet;
+
+        $this->updateRepr();
+    }
+
+    /**
+     * Gets the filename where the error occurred.
+     *
+     * This method returns null if a string is parsed.
+     *
+     * @return string The filename
+     */
+    public function getParsedFile()
+    {
+        return $this->parsedFile;
+    }
+
+    /**
+     * Sets the filename where the error occurred.
+     *
+     * @param string $parsedFile The filename
+     */
+    public function setParsedFile($parsedFile)
+    {
+        $this->parsedFile = $parsedFile;
+
+        $this->updateRepr();
+    }
+
+    /**
+     * Gets the line where the error occurred.
+     *
+     * @return int The file line
+     */
+    public function getParsedLine()
+    {
+        return $this->parsedLine;
+    }
+
+    /**
+     * Sets the line where the error occurred.
+     *
+     * @param int $parsedLine The file line
+     */
+    public function setParsedLine($parsedLine)
+    {
+        $this->parsedLine = $parsedLine;
+
+        $this->updateRepr();
+    }
+
+    private function updateRepr()
+    {
+        $this->message = $this->rawMessage;
+
+        $dot = false;
+        if ('.' === substr($this->message, -1)) {
+            $this->message = substr($this->message, 0, -1);
+            $dot = true;
+        }
+
+        if (null !== $this->parsedFile) {
+            $this->message .= sprintf(' in %s', json_encode($this->parsedFile, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE));
+        }
+
+        if ($this->parsedLine >= 0) {
+            $this->message .= sprintf(' at line %d', $this->parsedLine);
+        }
+
+        if ($this->snippet) {
+            $this->message .= sprintf(' (near "%s")', $this->snippet);
+        }
+
+        if ($dot) {
+            $this->message .= '.';
+        }
+    }
+}

html2pdf-master/vendor/symfony/yaml/Exception/RuntimeException.php

@@ -0,0 +1,21 @@
+<?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 Symfony\Component\Yaml\Exception;
+
+/**
+ * Exception class thrown when an error occurs during parsing.
+ *
+ * @author Romain Neutron <imprec@gmail.com>
+ */
+class RuntimeException extends \RuntimeException implements ExceptionInterface
+{
+}

html2pdf-master/vendor/symfony/yaml/Inline.php

@@ -0,0 +1,809 @@
+<?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 Symfony\Component\Yaml;
+
+use Symfony\Component\Yaml\Exception\ParseException;
+use Symfony\Component\Yaml\Exception\DumpException;
+use Symfony\Component\Yaml\Tag\TaggedValue;
+
+/**
+ * Inline implements a YAML parser/dumper for the YAML inline syntax.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class Inline
+{
+    const REGEX_QUOTED_STRING = '(?:"([^"\\\\]*+(?:\\\\.[^"\\\\]*+)*+)"|\'([^\']*+(?:\'\'[^\']*+)*+)\')';
+
+    public static $parsedLineNumber;
+
+    private static $exceptionOnInvalidType = false;
+    private static $objectSupport = false;
+    private static $objectForMap = false;
+    private static $constantSupport = false;
+
+    /**
+     * Converts a YAML string to a PHP value.
+     *
+     * @param string $value      A YAML string
+     * @param int    $flags      A bit field of PARSE_* constants to customize the YAML parser behavior
+     * @param array  $references Mapping of variable names to values
+     *
+     * @return mixed A PHP value
+     *
+     * @throws ParseException
+     */
+    public static function parse($value, $flags = 0, $references = array())
+    {
+        if (is_bool($flags)) {
+            @trigger_error('Passing a boolean flag to toggle exception handling is deprecated since version 3.1 and will be removed in 4.0. Use the Yaml::PARSE_EXCEPTION_ON_INVALID_TYPE flag instead.', E_USER_DEPRECATED);
+
+            if ($flags) {
+                $flags = Yaml::PARSE_EXCEPTION_ON_INVALID_TYPE;
+            } else {
+                $flags = 0;
+            }
+        }
+
+        if (func_num_args() >= 3 && !is_array($references)) {
+            @trigger_error('Passing a boolean flag to toggle object support is deprecated since version 3.1 and will be removed in 4.0. Use the Yaml::PARSE_OBJECT flag instead.', E_USER_DEPRECATED);
+
+            if ($references) {
+                $flags |= Yaml::PARSE_OBJECT;
+            }
+
+            if (func_num_args() >= 4) {
+                @trigger_error('Passing a boolean flag to toggle object for map support is deprecated since version 3.1 and will be removed in 4.0. Use the Yaml::PARSE_OBJECT_FOR_MAP flag instead.', E_USER_DEPRECATED);
+
+                if (func_get_arg(3)) {
+                    $flags |= Yaml::PARSE_OBJECT_FOR_MAP;
+                }
+            }
+
+            if (func_num_args() >= 5) {
+                $references = func_get_arg(4);
+            } else {
+                $references = array();
+            }
+        }
+
+        self::$exceptionOnInvalidType = (bool) (Yaml::PARSE_EXCEPTION_ON_INVALID_TYPE & $flags);
+        self::$objectSupport = (bool) (Yaml::PARSE_OBJECT & $flags);
+        self::$objectForMap = (bool) (Yaml::PARSE_OBJECT_FOR_MAP & $flags);
+        self::$constantSupport = (bool) (Yaml::PARSE_CONSTANT & $flags);
+
+        $value = trim($value);
+
+        if ('' === $value) {
+            return '';
+        }
+
+        if (2 /* MB_OVERLOAD_STRING */ & (int) ini_get('mbstring.func_overload')) {
+            $mbEncoding = mb_internal_encoding();
+            mb_internal_encoding('ASCII');
+        }
+
+        $i = 0;
+        $tag = self::parseTag($value, $i, $flags);
+        switch ($value[$i]) {
+            case '[':
+                $result = self::parseSequence($value, $flags, $i, $references);
+                ++$i;
+                break;
+            case '{':
+                $result = self::parseMapping($value, $flags, $i, $references);
+                ++$i;
+                break;
+            default:
+                $result = self::parseScalar($value, $flags, null, $i, null === $tag, $references);
+        }
+
+        if (null !== $tag) {
+            return new TaggedValue($tag, $result);
+        }
+
+        // some comments are allowed at the end
+        if (preg_replace('/\s+#.*$/A', '', substr($value, $i))) {
+            throw new ParseException(sprintf('Unexpected characters near "%s".', substr($value, $i)));
+        }
+
+        if (isset($mbEncoding)) {
+            mb_internal_encoding($mbEncoding);
+        }
+
+        return $result;
+    }
+
+    /**
+     * Dumps a given PHP variable to a YAML string.
+     *
+     * @param mixed $value The PHP variable to convert
+     * @param int   $flags A bit field of Yaml::DUMP_* constants to customize the dumped YAML string
+     *
+     * @return string The YAML string representing the PHP value
+     *
+     * @throws DumpException When trying to dump PHP resource
+     */
+    public static function dump($value, $flags = 0)
+    {
+        if (is_bool($flags)) {
+            @trigger_error('Passing a boolean flag to toggle exception handling is deprecated since version 3.1 and will be removed in 4.0. Use the Yaml::DUMP_EXCEPTION_ON_INVALID_TYPE flag instead.', E_USER_DEPRECATED);
+
+            if ($flags) {
+                $flags = Yaml::DUMP_EXCEPTION_ON_INVALID_TYPE;
+            } else {
+                $flags = 0;
+            }
+        }
+
+        if (func_num_args() >= 3) {
+            @trigger_error('Passing a boolean flag to toggle object support is deprecated since version 3.1 and will be removed in 4.0. Use the Yaml::DUMP_OBJECT flag instead.', E_USER_DEPRECATED);
+
+            if (func_get_arg(2)) {
+                $flags |= Yaml::DUMP_OBJECT;
+            }
+        }
+
+        switch (true) {
+            case is_resource($value):
+                if (Yaml::DUMP_EXCEPTION_ON_INVALID_TYPE & $flags) {
+                    throw new DumpException(sprintf('Unable to dump PHP resources in a YAML file ("%s").', get_resource_type($value)));
+                }
+
+                return 'null';
+            case $value instanceof \DateTimeInterface:
+                return $value->format('c');
+            case is_object($value):
+                if ($value instanceof TaggedValue) {
+                    return '!'.$value->getTag().' '.self::dump($value->getValue(), $flags);
+                }
+
+                if (Yaml::DUMP_OBJECT & $flags) {
+                    return '!php/object:'.serialize($value);
+                }
+
+                if (Yaml::DUMP_OBJECT_AS_MAP & $flags && ($value instanceof \stdClass || $value instanceof \ArrayObject)) {
+                    return self::dumpArray($value, $flags & ~Yaml::DUMP_EMPTY_ARRAY_AS_SEQUENCE);
+                }
+
+                if (Yaml::DUMP_EXCEPTION_ON_INVALID_TYPE & $flags) {
+                    throw new DumpException('Object support when dumping a YAML file has been disabled.');
+                }
+
+                return 'null';
+            case is_array($value):
+                return self::dumpArray($value, $flags);
+            case null === $value:
+                return 'null';
+            case true === $value:
+                return 'true';
+            case false === $value:
+                return 'false';
+            case ctype_digit($value):
+                return is_string($value) ? "'$value'" : (int) $value;
+            case is_numeric($value):
+                $locale = setlocale(LC_NUMERIC, 0);
+                if (false !== $locale) {
+                    setlocale(LC_NUMERIC, 'C');
+                }
+                if (is_float($value)) {
+                    $repr = (string) $value;
+                    if (is_infinite($value)) {
+                        $repr = str_ireplace('INF', '.Inf', $repr);
+                    } elseif (floor($value) == $value && $repr == $value) {
+                        // Preserve float data type since storing a whole number will result in integer value.
+                        $repr = '!!float '.$repr;
+                    }
+                } else {
+                    $repr = is_string($value) ? "'$value'" : (string) $value;
+                }
+                if (false !== $locale) {
+                    setlocale(LC_NUMERIC, $locale);
+                }
+
+                return $repr;
+            case '' == $value:
+                return "''";
+            case self::isBinaryString($value):
+                return '!!binary '.base64_encode($value);
+            case Escaper::requiresDoubleQuoting($value):
+                return Escaper::escapeWithDoubleQuotes($value);
+            case Escaper::requiresSingleQuoting($value):
+            case Parser::preg_match('{^[0-9]+[_0-9]*$}', $value):
+            case Parser::preg_match(self::getHexRegex(), $value):
+            case Parser::preg_match(self::getTimestampRegex(), $value):
+                return Escaper::escapeWithSingleQuotes($value);
+            default:
+                return $value;
+        }
+    }
+
+    /**
+     * Check if given array is hash or just normal indexed array.
+     *
+     * @internal
+     *
+     * @param array|\ArrayObject|\stdClass $value The PHP array or array-like object to check
+     *
+     * @return bool true if value is hash array, false otherwise
+     */
+    public static function isHash($value)
+    {
+        if ($value instanceof \stdClass || $value instanceof \ArrayObject) {
+            return true;
+        }
+
+        $expectedKey = 0;
+
+        foreach ($value as $key => $val) {
+            if ($key !== $expectedKey++) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Dumps a PHP array to a YAML string.
+     *
+     * @param array $value The PHP array to dump
+     * @param int   $flags A bit field of Yaml::DUMP_* constants to customize the dumped YAML string
+     *
+     * @return string The YAML string representing the PHP array
+     */
+    private static function dumpArray($value, $flags)
+    {
+        // array
+        if (($value || Yaml::DUMP_EMPTY_ARRAY_AS_SEQUENCE & $flags) && !self::isHash($value)) {
+            $output = array();
+            foreach ($value as $val) {
+                $output[] = self::dump($val, $flags);
+            }
+
+            return sprintf('[%s]', implode(', ', $output));
+        }
+
+        // hash
+        $output = array();
+        foreach ($value as $key => $val) {
+            $output[] = sprintf('%s: %s', self::dump($key, $flags), self::dump($val, $flags));
+        }
+
+        return sprintf('{ %s }', implode(', ', $output));
+    }
+
+    /**
+     * Parses a YAML scalar.
+     *
+     * @param string   $scalar
+     * @param int      $flags
+     * @param string[] $delimiters
+     * @param int      &$i
+     * @param bool     $evaluate
+     * @param array    $references
+     *
+     * @return string
+     *
+     * @throws ParseException When malformed inline YAML string is parsed
+     *
+     * @internal
+     */
+    public static function parseScalar($scalar, $flags = 0, $delimiters = null, &$i = 0, $evaluate = true, $references = array(), $legacyOmittedKeySupport = false)
+    {
+        if (in_array($scalar[$i], array('"', "'"))) {
+            // quoted scalar
+            $output = self::parseQuotedScalar($scalar, $i);
+
+            if (null !== $delimiters) {
+                $tmp = ltrim(substr($scalar, $i), ' ');
+                if (!in_array($tmp[0], $delimiters)) {
+                    throw new ParseException(sprintf('Unexpected characters (%s).', substr($scalar, $i)));
+                }
+            }
+        } else {
+            // "normal" string
+            if (!$delimiters) {
+                $output = substr($scalar, $i);
+                $i += strlen($output);
+
+                // remove comments
+                if (Parser::preg_match('/[ \t]+#/', $output, $match, PREG_OFFSET_CAPTURE)) {
+                    $output = substr($output, 0, $match[0][1]);
+                }
+            } elseif (Parser::preg_match('/^(.'.($legacyOmittedKeySupport ? '+' : '*').'?)('.implode('|', $delimiters).')/', substr($scalar, $i), $match)) {
+                $output = $match[1];
+                $i += strlen($output);
+            } else {
+                throw new ParseException(sprintf('Malformed inline YAML string: %s.', $scalar));
+            }
+
+            // a non-quoted string cannot start with @ or ` (reserved) nor with a scalar indicator (| or >)
+            if ($output && ('@' === $output[0] || '`' === $output[0] || '|' === $output[0] || '>' === $output[0])) {
+                throw new ParseException(sprintf('The reserved indicator "%s" cannot start a plain scalar; you need to quote the scalar.', $output[0]));
+            }
+
+            if ($output && '%' === $output[0]) {
+                @trigger_error(sprintf('Not quoting the scalar "%s" starting with the "%%" indicator character is deprecated since Symfony 3.1 and will throw a ParseException in 4.0.', $output), E_USER_DEPRECATED);
+            }
+
+            if ($evaluate) {
+                $output = self::evaluateScalar($output, $flags, $references);
+            }
+        }
+
+        return $output;
+    }
+
+    /**
+     * Parses a YAML quoted scalar.
+     *
+     * @param string $scalar
+     * @param int    &$i
+     *
+     * @return string
+     *
+     * @throws ParseException When malformed inline YAML string is parsed
+     */
+    private static function parseQuotedScalar($scalar, &$i)
+    {
+        if (!Parser::preg_match('/'.self::REGEX_QUOTED_STRING.'/Au', substr($scalar, $i), $match)) {
+            throw new ParseException(sprintf('Malformed inline YAML string: %s.', substr($scalar, $i)));
+        }
+
+        $output = substr($match[0], 1, strlen($match[0]) - 2);
+
+        $unescaper = new Unescaper();
+        if ('"' == $scalar[$i]) {
+            $output = $unescaper->unescapeDoubleQuotedString($output);
+        } else {
+            $output = $unescaper->unescapeSingleQuotedString($output);
+        }
+
+        $i += strlen($match[0]);
+
+        return $output;
+    }
+
+    /**
+     * Parses a YAML sequence.
+     *
+     * @param string $sequence
+     * @param int    $flags
+     * @param int    &$i
+     * @param array  $references
+     *
+     * @return array
+     *
+     * @throws ParseException When malformed inline YAML string is parsed
+     */
+    private static function parseSequence($sequence, $flags, &$i = 0, $references = array())
+    {
+        $output = array();
+        $len = strlen($sequence);
+        ++$i;
+
+        // [foo, bar, ...]
+        while ($i < $len) {
+            if (']' === $sequence[$i]) {
+                return $output;
+            }
+            if (',' === $sequence[$i] || ' ' === $sequence[$i]) {
+                ++$i;
+
+                continue;
+            }
+
+            $tag = self::parseTag($sequence, $i, $flags);
+            switch ($sequence[$i]) {
+                case '[':
+                    // nested sequence
+                    $value = self::parseSequence($sequence, $flags, $i, $references);
+                    break;
+                case '{':
+                    // nested mapping
+                    $value = self::parseMapping($sequence, $flags, $i, $references);
+                    break;
+                default:
+                    $isQuoted = in_array($sequence[$i], array('"', "'"));
+                    $value = self::parseScalar($sequence, $flags, array(',', ']'), $i, null === $tag, $references);
+
+                    // the value can be an array if a reference has been resolved to an array var
+                    if (is_string($value) && !$isQuoted && false !== strpos($value, ': ')) {
+                        // embedded mapping?
+                        try {
+                            $pos = 0;
+                            $value = self::parseMapping('{'.$value.'}', $flags, $pos, $references);
+                        } catch (\InvalidArgumentException $e) {
+                            // no, it's not
+                        }
+                    }
+
+                    --$i;
+            }
+
+            if (null !== $tag) {
+                $value = new TaggedValue($tag, $value);
+            }
+
+            $output[] = $value;
+
+            ++$i;
+        }
+
+        throw new ParseException(sprintf('Malformed inline YAML string: %s.', $sequence));
+    }
+
+    /**
+     * Parses a YAML mapping.
+     *
+     * @param string $mapping
+     * @param int    $flags
+     * @param int    &$i
+     * @param array  $references
+     *
+     * @return array|\stdClass
+     *
+     * @throws ParseException When malformed inline YAML string is parsed
+     */
+    private static function parseMapping($mapping, $flags, &$i = 0, $references = array())
+    {
+        $output = array();
+        $len = strlen($mapping);
+        ++$i;
+
+        // {foo: bar, bar:foo, ...}
+        while ($i < $len) {
+            switch ($mapping[$i]) {
+                case ' ':
+                case ',':
+                    ++$i;
+                    continue 2;
+                case '}':
+                    if (self::$objectForMap) {
+                        return (object) $output;
+                    }
+
+                    return $output;
+            }
+
+            // key
+            $isKeyQuoted = in_array($mapping[$i], array('"', "'"), true);
+            $key = self::parseScalar($mapping, $flags, array(':', ' '), $i, false, array(), true);
+
+            if (':' !== $key && false === $i = strpos($mapping, ':', $i)) {
+                break;
+            }
+
+            if (':' === $key) {
+                @trigger_error('Omitting the key of a mapping is deprecated and will throw a ParseException in 4.0.', E_USER_DEPRECATED);
+            }
+
+            if (!(Yaml::PARSE_KEYS_AS_STRINGS & $flags)) {
+                $evaluatedKey = self::evaluateScalar($key, $flags, $references);
+
+                if ('' !== $key && $evaluatedKey !== $key && !is_string($evaluatedKey) && !is_int($evaluatedKey)) {
+                    @trigger_error('Implicit casting of incompatible mapping keys to strings is deprecated since version 3.3 and will throw \Symfony\Component\Yaml\Exception\ParseException in 4.0. Quote your evaluable mapping keys instead.', E_USER_DEPRECATED);
+                }
+            }
+
+            if (':' !== $key && !$isKeyQuoted && (!isset($mapping[$i + 1]) || !in_array($mapping[$i + 1], array(' ', ',', '[', ']', '{', '}'), true))) {
+                @trigger_error('Using a colon after an unquoted mapping key that is not followed by an indication character (i.e. " ", ",", "[", "]", "{", "}") is deprecated since version 3.2 and will throw a ParseException in 4.0.', E_USER_DEPRECATED);
+            }
+
+            while ($i < $len) {
+                if (':' === $mapping[$i] || ' ' === $mapping[$i]) {
+                    ++$i;
+
+                    continue;
+                }
+
+                $tag = self::parseTag($mapping, $i, $flags);
+                $duplicate = false;
+                switch ($mapping[$i]) {
+                    case '[':
+                        // nested sequence
+                        $value = self::parseSequence($mapping, $flags, $i, $references);
+                        // Spec: Keys MUST be unique; first one wins.
+                        // Parser cannot abort this mapping earlier, since lines
+                        // are processed sequentially.
+                        if (isset($output[$key])) {
+                            @trigger_error(sprintf('Duplicate key "%s" detected whilst parsing YAML. Silent handling of duplicate mapping keys in YAML is deprecated since version 3.2 and will throw \Symfony\Component\Yaml\Exception\ParseException in 4.0.', $key), E_USER_DEPRECATED);
+                            $duplicate = true;
+                        }
+                        break;
+                    case '{':
+                        // nested mapping
+                        $value = self::parseMapping($mapping, $flags, $i, $references);
+                        // Spec: Keys MUST be unique; first one wins.
+                        // Parser cannot abort this mapping earlier, since lines
+                        // are processed sequentially.
+                        if (isset($output[$key])) {
+                            @trigger_error(sprintf('Duplicate key "%s" detected whilst parsing YAML. Silent handling of duplicate mapping keys in YAML is deprecated since version 3.2 and will throw \Symfony\Component\Yaml\Exception\ParseException in 4.0.', $key), E_USER_DEPRECATED);
+                            $duplicate = true;
+                        }
+                        break;
+                    default:
+                        $value = self::parseScalar($mapping, $flags, array(',', '}'), $i, null === $tag, $references);
+                        // Spec: Keys MUST be unique; first one wins.
+                        // Parser cannot abort this mapping earlier, since lines
+                        // are processed sequentially.
+                        if (isset($output[$key])) {
+                            @trigger_error(sprintf('Duplicate key "%s" detected whilst parsing YAML. Silent handling of duplicate mapping keys in YAML is deprecated since version 3.2 and will throw \Symfony\Component\Yaml\Exception\ParseException in 4.0.', $key), E_USER_DEPRECATED);
+                            $duplicate = true;
+                        }
+                        --$i;
+                }
+
+                if (!$duplicate) {
+                    if (null !== $tag) {
+                        $output[$key] = new TaggedValue($tag, $value);
+                    } else {
+                        $output[$key] = $value;
+                    }
+                }
+                ++$i;
+
+                continue 2;
+            }
+        }
+
+        throw new ParseException(sprintf('Malformed inline YAML string: %s.', $mapping));
+    }
+
+    /**
+     * Evaluates scalars and replaces magic values.
+     *
+     * @param string $scalar
+     * @param int    $flags
+     * @param array  $references
+     *
+     * @return mixed The evaluated YAML string
+     *
+     * @throws ParseException when object parsing support was disabled and the parser detected a PHP object or when a reference could not be resolved
+     */
+    private static function evaluateScalar($scalar, $flags, $references = array())
+    {
+        $scalar = trim($scalar);
+        $scalarLower = strtolower($scalar);
+
+        if (0 === strpos($scalar, '*')) {
+            if (false !== $pos = strpos($scalar, '#')) {
+                $value = substr($scalar, 1, $pos - 2);
+            } else {
+                $value = substr($scalar, 1);
+            }
+
+            // an unquoted *
+            if (false === $value || '' === $value) {
+                throw new ParseException('A reference must contain at least one character.');
+            }
+
+            if (!array_key_exists($value, $references)) {
+                throw new ParseException(sprintf('Reference "%s" does not exist.', $value));
+            }
+
+            return $references[$value];
+        }
+
+        switch (true) {
+            case 'null' === $scalarLower:
+            case '' === $scalar:
+            case '~' === $scalar:
+                return;
+            case 'true' === $scalarLower:
+                return true;
+            case 'false' === $scalarLower:
+                return false;
+            case $scalar[0] === '!':
+                switch (true) {
+                    case 0 === strpos($scalar, '!str'):
+                        return (string) substr($scalar, 5);
+                    case 0 === strpos($scalar, '! '):
+                        return (int) self::parseScalar(substr($scalar, 2), $flags);
+                    case 0 === strpos($scalar, '!php/object:'):
+                        if (self::$objectSupport) {
+                            return unserialize(substr($scalar, 12));
+                        }
+
+                        if (self::$exceptionOnInvalidType) {
+                            throw new ParseException('Object support when parsing a YAML file has been disabled.');
+                        }
+
+                        return;
+                    case 0 === strpos($scalar, '!!php/object:'):
+                        if (self::$objectSupport) {
+                            @trigger_error('The !!php/object tag to indicate dumped PHP objects is deprecated since version 3.1 and will be removed in 4.0. Use the !php/object tag instead.', E_USER_DEPRECATED);
+
+                            return unserialize(substr($scalar, 13));
+                        }
+
+                        if (self::$exceptionOnInvalidType) {
+                            throw new ParseException('Object support when parsing a YAML file has been disabled.');
+                        }
+
+                        return;
+                    case 0 === strpos($scalar, '!php/const:'):
+                        if (self::$constantSupport) {
+                            if (defined($const = substr($scalar, 11))) {
+                                return constant($const);
+                            }
+
+                            throw new ParseException(sprintf('The constant "%s" is not defined.', $const));
+                        }
+                        if (self::$exceptionOnInvalidType) {
+                            throw new ParseException(sprintf('The string "%s" could not be parsed as a constant. Have you forgotten to pass the "Yaml::PARSE_CONSTANT" flag to the parser?', $scalar));
+                        }
+
+                        return;
+                    case 0 === strpos($scalar, '!!float '):
+                        return (float) substr($scalar, 8);
+                    case 0 === strpos($scalar, '!!binary '):
+                        return self::evaluateBinaryScalar(substr($scalar, 9));
+                    default:
+                        @trigger_error(sprintf('Using the unquoted scalar value "%s" is deprecated since version 3.3 and will be considered as a tagged value in 4.0. You must quote it.', $scalar), E_USER_DEPRECATED);
+                }
+
+            // Optimize for returning strings.
+            case $scalar[0] === '+' || $scalar[0] === '-' || $scalar[0] === '.' || is_numeric($scalar[0]):
+                switch (true) {
+                    case Parser::preg_match('{^[+-]?[0-9][0-9_]*$}', $scalar):
+                        $scalar = str_replace('_', '', (string) $scalar);
+                        // omitting the break / return as integers are handled in the next case
+                    case ctype_digit($scalar):
+                        $raw = $scalar;
+                        $cast = (int) $scalar;
+
+                        return '0' == $scalar[0] ? octdec($scalar) : (((string) $raw == (string) $cast) ? $cast : $raw);
+                    case '-' === $scalar[0] && ctype_digit(substr($scalar, 1)):
+                        $raw = $scalar;
+                        $cast = (int) $scalar;
+
+                        return '0' == $scalar[1] ? octdec($scalar) : (((string) $raw === (string) $cast) ? $cast : $raw);
+                    case is_numeric($scalar):
+                    case Parser::preg_match(self::getHexRegex(), $scalar):
+                        $scalar = str_replace('_', '', $scalar);
+
+                        return '0x' === $scalar[0].$scalar[1] ? hexdec($scalar) : (float) $scalar;
+                    case '.inf' === $scalarLower:
+                    case '.nan' === $scalarLower:
+                        return -log(0);
+                    case '-.inf' === $scalarLower:
+                        return log(0);
+                    case Parser::preg_match('/^(-|\+)?[0-9][0-9,]*(\.[0-9_]+)?$/', $scalar):
+                    case Parser::preg_match('/^(-|\+)?[0-9][0-9_]*(\.[0-9_]+)?$/', $scalar):
+                        if (false !== strpos($scalar, ',')) {
+                            @trigger_error('Using the comma as a group separator for floats is deprecated since version 3.2 and will be removed in 4.0.', E_USER_DEPRECATED);
+                        }
+
+                        return (float) str_replace(array(',', '_'), '', $scalar);
+                    case Parser::preg_match(self::getTimestampRegex(), $scalar):
+                        if (Yaml::PARSE_DATETIME & $flags) {
+                            // When no timezone is provided in the parsed date, YAML spec says we must assume UTC.
+                            return new \DateTime($scalar, new \DateTimeZone('UTC'));
+                        }
+
+                        $timeZone = date_default_timezone_get();
+                        date_default_timezone_set('UTC');
+                        $time = strtotime($scalar);
+                        date_default_timezone_set($timeZone);
+
+                        return $time;
+                }
+        }
+
+        return (string) $scalar;
+    }
+
+    /**
+     * @param string $value
+     * @param int    &$i
+     * @param int    $flags
+     *
+     * @return null|string
+     */
+    private static function parseTag($value, &$i, $flags)
+    {
+        if ('!' !== $value[$i]) {
+            return;
+        }
+
+        $tagLength = strcspn($value, " \t\n", $i + 1);
+        $tag = substr($value, $i + 1, $tagLength);
+
+        $nextOffset = $i + $tagLength + 1;
+        $nextOffset += strspn($value, ' ', $nextOffset);
+
+        // Is followed by a scalar
+        if (!isset($value[$nextOffset]) || !in_array($value[$nextOffset], array('[', '{'), true)) {
+            // Manage scalars in {@link self::evaluateScalar()}
+            return;
+        }
+
+        // Built-in tags
+        if ($tag && '!' === $tag[0]) {
+            throw new ParseException(sprintf('The built-in tag "!%s" is not implemented.', $tag));
+        }
+
+        if (Yaml::PARSE_CUSTOM_TAGS & $flags) {
+            $i = $nextOffset;
+
+            return $tag;
+        }
+
+        throw new ParseException(sprintf('Tags support is not enabled. Enable the `Yaml::PARSE_CUSTOM_TAGS` flag to use "!%s".', $tag));
+    }
+
+    /**
+     * @param string $scalar
+     *
+     * @return string
+     *
+     * @internal
+     */
+    public static function evaluateBinaryScalar($scalar)
+    {
+        $parsedBinaryData = self::parseScalar(preg_replace('/\s/', '', $scalar));
+
+        if (0 !== (strlen($parsedBinaryData) % 4)) {
+            throw new ParseException(sprintf('The normalized base64 encoded data (data without whitespace characters) length must be a multiple of four (%d bytes given).', strlen($parsedBinaryData)));
+        }
+
+        if (!Parser::preg_match('#^[A-Z0-9+/]+={0,2}$#i', $parsedBinaryData)) {
+            throw new ParseException(sprintf('The base64 encoded data (%s) contains invalid characters.', $parsedBinaryData));
+        }
+
+        return base64_decode($parsedBinaryData, true);
+    }
+
+    private static function isBinaryString($value)
+    {
+        return !preg_match('//u', $value) || preg_match('/[^\x00\x07-\x0d\x1B\x20-\xff]/', $value);
+    }
+
+    /**
+     * Gets a regex that matches a YAML date.
+     *
+     * @return string The regular expression
+     *
+     * @see http://www.yaml.org/spec/1.2/spec.html#id2761573
+     */
+    private static function getTimestampRegex()
+    {
+        return <<<EOF
+        ~^
+        (?P<year>[0-9][0-9][0-9][0-9])
+        -(?P<month>[0-9][0-9]?)
+        -(?P<day>[0-9][0-9]?)
+        (?:(?:[Tt]|[ \t]+)
+        (?P<hour>[0-9][0-9]?)
+        :(?P<minute>[0-9][0-9])
+        :(?P<second>[0-9][0-9])
+        (?:\.(?P<fraction>[0-9]*))?
+        (?:[ \t]*(?P<tz>Z|(?P<tz_sign>[-+])(?P<tz_hour>[0-9][0-9]?)
+        (?::(?P<tz_minute>[0-9][0-9]))?))?)?
+        $~x
+EOF;
+    }
+
+    /**
+     * Gets a regex that matches a YAML number in hexadecimal notation.
+     *
+     * @return string
+     */
+    private static function getHexRegex()
+    {
+        return '~^0x[0-9a-f_]++$~i';
+    }
+}

html2pdf-master/vendor/symfony/yaml/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2004-2017 Fabien Potencier
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

html2pdf-master/vendor/symfony/yaml/README.md

@@ -0,0 +1,13 @@
+Yaml Component
+==============
+
+The Yaml component loads and dumps YAML files.
+
+Resources
+---------
+
+  * [Documentation](https://symfony.com/doc/current/components/yaml/index.html)
+  * [Contributing](https://symfony.com/doc/current/contributing/index.html)
+  * [Report issues](https://github.com/symfony/symfony/issues) and
+    [send Pull Requests](https://github.com/symfony/symfony/pulls)
+    in the [main Symfony repository](https://github.com/symfony/symfony)

html2pdf-master/vendor/symfony/yaml/Tag/TaggedValue.php

@@ -0,0 +1,48 @@
+<?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 Symfony\Component\Yaml\Tag;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ * @author Guilhem N. <egetick@gmail.com>
+ */
+final class TaggedValue
+{
+    private $tag;
+    private $value;
+
+    /**
+     * @param string $tag
+     * @param mixed  $value
+     */
+    public function __construct($tag, $value)
+    {
+        $this->tag = $tag;
+        $this->value = $value;
+    }
+
+    /**
+     * @return string
+     */
+    public function getTag()
+    {
+        return $this->tag;
+    }
+
+    /**
+     * @return mixed
+     */
+    public function getValue()
+    {
+        return $this->value;
+    }
+}

html2pdf-master/vendor/symfony/yaml/Tests/Command/LintCommandTest.php

@@ -0,0 +1,121 @@
+<?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 Symfony\Component\Yaml\Tests\Command;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Yaml\Command\LintCommand;
+use Symfony\Component\Console\Application;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Tester\CommandTester;
+
+/**
+ * Tests the YamlLintCommand.
+ *
+ * @author Robin Chalas <robin.chalas@gmail.com>
+ */
+class LintCommandTest extends TestCase
+{
+    private $files;
+
+    public function testLintCorrectFile()
+    {
+        $tester = $this->createCommandTester();
+        $filename = $this->createFile('foo: bar');
+
+        $ret = $tester->execute(array('filename' => $filename), array('verbosity' => OutputInterface::VERBOSITY_VERBOSE, 'decorated' => false));
+
+        $this->assertEquals(0, $ret, 'Returns 0 in case of success');
+        $this->assertRegExp('/^\/\/ OK in /', trim($tester->getDisplay()));
+    }
+
+    public function testLintIncorrectFile()
+    {
+        $incorrectContent = '
+foo:
+bar';
+        $tester = $this->createCommandTester();
+        $filename = $this->createFile($incorrectContent);
+
+        $ret = $tester->execute(array('filename' => $filename), array('decorated' => false));
+
+        $this->assertEquals(1, $ret, 'Returns 1 in case of error');
+        $this->assertContains('Unable to parse at line 3 (near "bar").', trim($tester->getDisplay()));
+    }
+
+    public function testConstantAsKey()
+    {
+        $yaml = <<<YAML
+!php/const:Symfony\Component\Yaml\Tests\Command\Foo::TEST: bar
+YAML;
+        $ret = $this->createCommandTester()->execute(array('filename' => $this->createFile($yaml)), array('verbosity' => OutputInterface::VERBOSITY_VERBOSE, 'decorated' => false));
+        $this->assertSame(0, $ret, 'lint:yaml exits with code 0 in case of success');
+    }
+
+    /**
+     * @expectedException \RuntimeException
+     */
+    public function testLintFileNotReadable()
+    {
+        $tester = $this->createCommandTester();
+        $filename = $this->createFile('');
+        unlink($filename);
+
+        $ret = $tester->execute(array('filename' => $filename), array('decorated' => false));
+    }
+
+    /**
+     * @return string Path to the new file
+     */
+    private function createFile($content)
+    {
+        $filename = tempnam(sys_get_temp_dir().'/framework-yml-lint-test', 'sf-');
+        file_put_contents($filename, $content);
+
+        $this->files[] = $filename;
+
+        return $filename;
+    }
+
+    /**
+     * @return CommandTester
+     */
+    protected function createCommandTester()
+    {
+        $application = new Application();
+        $application->add(new LintCommand());
+        $command = $application->find('lint:yaml');
+
+        return new CommandTester($command);
+    }
+
+    protected function setUp()
+    {
+        $this->files = array();
+        @mkdir(sys_get_temp_dir().'/framework-yml-lint-test');
+    }
+
+    protected function tearDown()
+    {
+        foreach ($this->files as $file) {
+            if (file_exists($file)) {
+                unlink($file);
+            }
+        }
+
+        rmdir(sys_get_temp_dir().'/framework-yml-lint-test');
+    }
+}
+
+class Foo
+{
+    const TEST = 'foo';
+}

html2pdf-master/vendor/symfony/yaml/Tests/DumperTest.php

@@ -0,0 +1,478 @@
+<?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 Symfony\Component\Yaml\Tests;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Yaml\Parser;
+use Symfony\Component\Yaml\Dumper;
+use Symfony\Component\Yaml\Yaml;
+
+class DumperTest extends TestCase
+{
+    protected $parser;
+    protected $dumper;
+    protected $path;
+
+    protected $array = array(
+        '' => 'bar',
+        'foo' => '#bar',
+        'foo\'bar' => array(),
+        'bar' => array(1, 'foo'),
+        'foobar' => array(
+            'foo' => 'bar',
+            'bar' => array(1, 'foo'),
+            'foobar' => array(
+                'foo' => 'bar',
+                'bar' => array(1, 'foo'),
+            ),
+        ),
+    );
+
+    protected function setUp()
+    {
+        $this->parser = new Parser();
+        $this->dumper = new Dumper();
+        $this->path = __DIR__.'/Fixtures';
+    }
+
+    protected function tearDown()
+    {
+        $this->parser = null;
+        $this->dumper = null;
+        $this->path = null;
+        $this->array = null;
+    }
+
+    public function testIndentationInConstructor()
+    {
+        $dumper = new Dumper(7);
+        $expected = <<<'EOF'
+'': bar
+foo: '#bar'
+'foo''bar': {  }
+bar:
+       - 1
+       - foo
+foobar:
+       foo: bar
+       bar:
+              - 1
+              - foo
+       foobar:
+              foo: bar
+              bar:
+                     - 1
+                     - foo
+
+EOF;
+        $this->assertEquals($expected, $dumper->dump($this->array, 4, 0));
+    }
+
+    /**
+     * @group legacy
+     */
+    public function testSetIndentation()
+    {
+        $this->dumper->setIndentation(7);
+
+        $expected = <<<'EOF'
+'': bar
+foo: '#bar'
+'foo''bar': {  }
+bar:
+       - 1
+       - foo
+foobar:
+       foo: bar
+       bar:
+              - 1
+              - foo
+       foobar:
+              foo: bar
+              bar:
+                     - 1
+                     - foo
+
+EOF;
+        $this->assertEquals($expected, $this->dumper->dump($this->array, 4, 0));
+    }
+
+    public function testSpecifications()
+    {
+        $files = $this->parser->parse(file_get_contents($this->path.'/index.yml'));
+        foreach ($files as $file) {
+            $yamls = file_get_contents($this->path.'/'.$file.'.yml');
+
+            // split YAMLs documents
+            foreach (preg_split('/^---( %YAML\:1\.0)?/m', $yamls) as $yaml) {
+                if (!$yaml) {
+                    continue;
+                }
+
+                $test = $this->parser->parse($yaml);
+                if (isset($test['dump_skip']) && $test['dump_skip']) {
+                    continue;
+                } elseif (isset($test['todo']) && $test['todo']) {
+                    // TODO
+                } else {
+                    eval('$expected = '.trim($test['php']).';');
+                    $this->assertSame($expected, $this->parser->parse($this->dumper->dump($expected, 10), Yaml::PARSE_KEYS_AS_STRINGS), $test['test']);
+                }
+            }
+        }
+    }
+
+    public function testInlineLevel()
+    {
+        $expected = <<<'EOF'
+{ '': bar, foo: '#bar', 'foo''bar': {  }, bar: [1, foo], foobar: { foo: bar, bar: [1, foo], foobar: { foo: bar, bar: [1, foo] } } }
+EOF;
+        $this->assertEquals($expected, $this->dumper->dump($this->array, -10), '->dump() takes an inline level argument');
+        $this->assertEquals($expected, $this->dumper->dump($this->array, 0), '->dump() takes an inline level argument');
+
+        $expected = <<<'EOF'
+'': bar
+foo: '#bar'
+'foo''bar': {  }
+bar: [1, foo]
+foobar: { foo: bar, bar: [1, foo], foobar: { foo: bar, bar: [1, foo] } }
+
+EOF;
+        $this->assertEquals($expected, $this->dumper->dump($this->array, 1), '->dump() takes an inline level argument');
+
+        $expected = <<<'EOF'
+'': bar
+foo: '#bar'
+'foo''bar': {  }
+bar:
+    - 1
+    - foo
+foobar:
+    foo: bar
+    bar: [1, foo]
+    foobar: { foo: bar, bar: [1, foo] }
+
+EOF;
+        $this->assertEquals($expected, $this->dumper->dump($this->array, 2), '->dump() takes an inline level argument');
+
+        $expected = <<<'EOF'
+'': bar
+foo: '#bar'
+'foo''bar': {  }
+bar:
+    - 1
+    - foo
+foobar:
+    foo: bar
+    bar:
+        - 1
+        - foo
+    foobar:
+        foo: bar
+        bar: [1, foo]
+
+EOF;
+        $this->assertEquals($expected, $this->dumper->dump($this->array, 3), '->dump() takes an inline level argument');
+
+        $expected = <<<'EOF'
+'': bar
+foo: '#bar'
+'foo''bar': {  }
+bar:
+    - 1
+    - foo
+foobar:
+    foo: bar
+    bar:
+        - 1
+        - foo
+    foobar:
+        foo: bar
+        bar:
+            - 1
+            - foo
+
+EOF;
+        $this->assertEquals($expected, $this->dumper->dump($this->array, 4), '->dump() takes an inline level argument');
+        $this->assertEquals($expected, $this->dumper->dump($this->array, 10), '->dump() takes an inline level argument');
+    }
+
+    public function testObjectSupportEnabled()
+    {
+        $dump = $this->dumper->dump(array('foo' => new A(), 'bar' => 1), 0, 0, Yaml::DUMP_OBJECT);
+
+        $this->assertEquals('{ foo: !php/object:O:30:"Symfony\Component\Yaml\Tests\A":1:{s:1:"a";s:3:"foo";}, bar: 1 }', $dump, '->dump() is able to dump objects');
+    }
+
+    /**
+     * @group legacy
+     */
+    public function testObjectSupportEnabledPassingTrue()
+    {
+        $dump = $this->dumper->dump(array('foo' => new A(), 'bar' => 1), 0, 0, false, true);
+
+        $this->assertEquals('{ foo: !php/object:O:30:"Symfony\Component\Yaml\Tests\A":1:{s:1:"a";s:3:"foo";}, bar: 1 }', $dump, '->dump() is able to dump objects');
+    }
+
+    public function testObjectSupportDisabledButNoExceptions()
+    {
+        $dump = $this->dumper->dump(array('foo' => new A(), 'bar' => 1));
+
+        $this->assertEquals('{ foo: null, bar: 1 }', $dump, '->dump() does not dump objects when disabled');
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Yaml\Exception\DumpException
+     */
+    public function testObjectSupportDisabledWithExceptions()
+    {
+        $this->dumper->dump(array('foo' => new A(), 'bar' => 1), 0, 0, Yaml::DUMP_EXCEPTION_ON_INVALID_TYPE);
+    }
+
+    /**
+     * @group legacy
+     * @expectedException \Symfony\Component\Yaml\Exception\DumpException
+     */
+    public function testObjectSupportDisabledWithExceptionsPassingTrue()
+    {
+        $this->dumper->dump(array('foo' => new A(), 'bar' => 1), 0, 0, true);
+    }
+
+    public function testEmptyArray()
+    {
+        $dump = $this->dumper->dump(array());
+        $this->assertEquals('{  }', $dump);
+
+        $dump = $this->dumper->dump(array(), 0, 0, Yaml::DUMP_EMPTY_ARRAY_AS_SEQUENCE);
+        $this->assertEquals('[]', $dump);
+
+        $dump = $this->dumper->dump(array(), 9, 0, Yaml::DUMP_EMPTY_ARRAY_AS_SEQUENCE);
+        $this->assertEquals('[]', $dump);
+
+        $dump = $this->dumper->dump(new \ArrayObject(), 0, 0, Yaml::DUMP_EMPTY_ARRAY_AS_SEQUENCE | Yaml::DUMP_OBJECT_AS_MAP);
+        $this->assertEquals('{  }', $dump);
+
+        $dump = $this->dumper->dump(new \stdClass(), 0, 0, Yaml::DUMP_EMPTY_ARRAY_AS_SEQUENCE | Yaml::DUMP_OBJECT_AS_MAP);
+        $this->assertEquals('{  }', $dump);
+    }
+
+    /**
+     * @dataProvider getEscapeSequences
+     */
+    public function testEscapedEscapeSequencesInQuotedScalar($input, $expected)
+    {
+        $this->assertEquals($expected, $this->dumper->dump($input));
+    }
+
+    public function getEscapeSequences()
+    {
+        return array(
+            'empty string' => array('', "''"),
+            'null' => array("\x0", '"\\0"'),
+            'bell' => array("\x7", '"\\a"'),
+            'backspace' => array("\x8", '"\\b"'),
+            'horizontal-tab' => array("\t", '"\\t"'),
+            'line-feed' => array("\n", '"\\n"'),
+            'vertical-tab' => array("\v", '"\\v"'),
+            'form-feed' => array("\xC", '"\\f"'),
+            'carriage-return' => array("\r", '"\\r"'),
+            'escape' => array("\x1B", '"\\e"'),
+            'space' => array(' ', "' '"),
+            'double-quote' => array('"', "'\"'"),
+            'slash' => array('/', '/'),
+            'backslash' => array('\\', '\\'),
+            'next-line' => array("\xC2\x85", '"\\N"'),
+            'non-breaking-space' => array("\xc2\xa0", '"\\_"'),
+            'line-separator' => array("\xE2\x80\xA8", '"\\L"'),
+            'paragraph-separator' => array("\xE2\x80\xA9", '"\\P"'),
+            'colon' => array(':', "':'"),
+        );
+    }
+
+    public function testBinaryDataIsDumpedBase64Encoded()
+    {
+        $binaryData = file_get_contents(__DIR__.'/Fixtures/arrow.gif');
+        $expected = '{ data: !!binary '.base64_encode($binaryData).' }';
+
+        $this->assertSame($expected, $this->dumper->dump(array('data' => $binaryData)));
+    }
+
+    public function testNonUtf8DataIsDumpedBase64Encoded()
+    {
+        // "für" (ISO-8859-1 encoded)
+        $this->assertSame('!!binary ZsM/cg==', $this->dumper->dump("f\xc3\x3fr"));
+    }
+
+    /**
+     * @dataProvider objectAsMapProvider
+     */
+    public function testDumpObjectAsMap($object, $expected)
+    {
+        $yaml = $this->dumper->dump($object, 0, 0, Yaml::DUMP_OBJECT_AS_MAP);
+
+        $this->assertEquals($expected, Yaml::parse($yaml, Yaml::PARSE_OBJECT_FOR_MAP));
+    }
+
+    public function objectAsMapProvider()
+    {
+        $tests = array();
+
+        $bar = new \stdClass();
+        $bar->class = 'classBar';
+        $bar->args = array('bar');
+        $zar = new \stdClass();
+        $foo = new \stdClass();
+        $foo->bar = $bar;
+        $foo->zar = $zar;
+        $object = new \stdClass();
+        $object->foo = $foo;
+        $tests['stdClass'] = array($object, $object);
+
+        $arrayObject = new \ArrayObject();
+        $arrayObject['foo'] = 'bar';
+        $arrayObject['baz'] = 'foobar';
+        $parsedArrayObject = new \stdClass();
+        $parsedArrayObject->foo = 'bar';
+        $parsedArrayObject->baz = 'foobar';
+        $tests['ArrayObject'] = array($arrayObject, $parsedArrayObject);
+
+        $a = new A();
+        $tests['arbitrary-object'] = array($a, null);
+
+        return $tests;
+    }
+
+    public function testDumpingArrayObjectInstancesRespectsInlineLevel()
+    {
+        $deep = new \ArrayObject(array('deep1' => 'd', 'deep2' => 'e'));
+        $inner = new \ArrayObject(array('inner1' => 'b', 'inner2' => 'c', 'inner3' => $deep));
+        $outer = new \ArrayObject(array('outer1' => 'a', 'outer2' => $inner));
+
+        $yaml = $this->dumper->dump($outer, 2, 0, Yaml::DUMP_OBJECT_AS_MAP);
+
+        $expected = <<<YAML
+outer1: a
+outer2:
+    inner1: b
+    inner2: c
+    inner3: { deep1: d, deep2: e }
+
+YAML;
+        $this->assertSame($expected, $yaml);
+    }
+
+    public function testDumpingArrayObjectInstancesWithNumericKeysInlined()
+    {
+        $deep = new \ArrayObject(array('d', 'e'));
+        $inner = new \ArrayObject(array('b', 'c', $deep));
+        $outer = new \ArrayObject(array('a', $inner));
+
+        $yaml = $this->dumper->dump($outer, 0, 0, Yaml::DUMP_OBJECT_AS_MAP);
+        $expected = <<<YAML
+{ 0: a, 1: { 0: b, 1: c, 2: { 0: d, 1: e } } }
+YAML;
+        $this->assertSame($expected, $yaml);
+    }
+
+    public function testDumpingArrayObjectInstancesWithNumericKeysRespectsInlineLevel()
+    {
+        $deep = new \ArrayObject(array('d', 'e'));
+        $inner = new \ArrayObject(array('b', 'c', $deep));
+        $outer = new \ArrayObject(array('a', $inner));
+        $yaml = $this->dumper->dump($outer, 2, 0, Yaml::DUMP_OBJECT_AS_MAP);
+        $expected = <<<YAML
+0: a
+1:
+    0: b
+    1: c
+    2: { 0: d, 1: e }
+
+YAML;
+        $this->assertEquals($expected, $yaml);
+    }
+
+    public function testDumpEmptyArrayObjectInstanceAsMap()
+    {
+        $this->assertSame('{  }', $this->dumper->dump(new \ArrayObject(), 2, 0, Yaml::DUMP_OBJECT_AS_MAP));
+    }
+
+    public function testDumpEmptyStdClassInstanceAsMap()
+    {
+        $this->assertSame('{  }', $this->dumper->dump(new \stdClass(), 2, 0, Yaml::DUMP_OBJECT_AS_MAP));
+    }
+
+    public function testDumpingStdClassInstancesRespectsInlineLevel()
+    {
+        $deep = new \stdClass();
+        $deep->deep1 = 'd';
+        $deep->deep2 = 'e';
+
+        $inner = new \stdClass();
+        $inner->inner1 = 'b';
+        $inner->inner2 = 'c';
+        $inner->inner3 = $deep;
+
+        $outer = new \stdClass();
+        $outer->outer1 = 'a';
+        $outer->outer2 = $inner;
+
+        $yaml = $this->dumper->dump($outer, 2, 0, Yaml::DUMP_OBJECT_AS_MAP);
+
+        $expected = <<<YAML
+outer1: a
+outer2:
+    inner1: b
+    inner2: c
+    inner3: { deep1: d, deep2: e }
+
+YAML;
+        $this->assertSame($expected, $yaml);
+    }
+
+    public function testDumpMultiLineStringAsScalarBlock()
+    {
+        $data = array(
+            'data' => array(
+                'single_line' => 'foo bar baz',
+                'multi_line' => "foo\nline with trailing spaces:\n  \nbar\r\ninteger like line:\n123456789\nempty line:\n\nbaz",
+                'nested_inlined_multi_line_string' => array(
+                    'inlined_multi_line' => "foo\nbar\r\nempty line:\n\nbaz",
+                ),
+            ),
+        );
+
+        $this->assertSame(file_get_contents(__DIR__.'/Fixtures/multiple_lines_as_literal_block.yml'), $this->dumper->dump($data, 2, 0, Yaml::DUMP_MULTI_LINE_LITERAL_BLOCK));
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage The indentation must be greater than zero
+     */
+    public function testZeroIndentationThrowsException()
+    {
+        new Dumper(0);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage The indentation must be greater than zero
+     */
+    public function testNegativeIndentationThrowsException()
+    {
+        new Dumper(-4);
+    }
+}
+
+class A
+{
+    public $a = 'foo';
+}

html2pdf-master/vendor/symfony/yaml/Tests/Fixtures/YtsAnchorAlias.yml

@@ -0,0 +1,31 @@
+--- %YAML:1.0
+test: Simple Alias Example
+brief: >
+    If you need to refer to the same item of data twice,
+    you can give that item an alias.  The alias is a plain
+    string, starting with an ampersand.  The item may then
+    be referred to by the alias throughout your document
+    by using an asterisk before the name of the alias.
+    This is called an anchor.
+yaml: |
+    - &showell Steve
+    - Clark
+    - Brian
+    - Oren
+    - *showell
+php: |
+    array('Steve', 'Clark', 'Brian', 'Oren', 'Steve')
+
+---
+test: Alias of a Mapping
+brief: >
+    An alias can be used on any item of data, including
+    sequences, mappings, and other complex data types.
+yaml: |
+    - &hello
+        Meat: pork
+        Starch: potato
+    - banana
+    - *hello
+php: |
+    array(array('Meat'=>'pork', 'Starch'=>'potato'), 'banana', array('Meat'=>'pork', 'Starch'=>'potato'))

html2pdf-master/vendor/symfony/yaml/Tests/Fixtures/YtsBasicTests.yml

@@ -0,0 +1,202 @@
+--- %YAML:1.0
+test: Simple Sequence
+brief: |
+    You can specify a list in YAML by placing each
+    member of the list on a new line with an opening
+    dash. These lists are called sequences.
+yaml: |
+    - apple
+    - banana
+    - carrot
+php: |
+    array('apple', 'banana', 'carrot')
+---
+test: Sequence With Item Being Null In The Middle
+brief: |
+    You can specify a list in YAML by placing each
+    member of the list on a new line with an opening
+    dash. These lists are called sequences.
+yaml: |
+    - apple
+    -
+    - carrot
+php: |
+    array('apple', null, 'carrot')
+---
+test: Sequence With Last Item Being Null
+brief: |
+    You can specify a list in YAML by placing each
+    member of the list on a new line with an opening
+    dash. These lists are called sequences.
+yaml: |
+    - apple
+    - banana
+    -
+php: |
+    array('apple', 'banana', null)
+---
+test: Nested Sequences
+brief: |
+    You can include a sequence within another
+    sequence by giving the sequence an empty
+    dash, followed by an indented list.
+yaml: |
+    -
+     - foo
+     - bar
+     - baz
+php: |
+    array(array('foo', 'bar', 'baz'))
+---
+test: Mixed Sequences
+brief: |
+    Sequences can contain any YAML data,
+    including strings and other sequences.
+yaml: |
+    - apple
+    -
+     - foo
+     - bar
+     - x123
+    - banana
+    - carrot
+php: |
+    array('apple', array('foo', 'bar', 'x123'), 'banana', 'carrot')
+---
+test: Deeply Nested Sequences
+brief: |
+    Sequences can be nested even deeper, with each
+    level of indentation representing a level of
+    depth.
+yaml: |
+    -
+     -
+      - uno
+      - dos
+php: |
+    array(array(array('uno', 'dos')))
+---
+test: Simple Mapping
+brief: |
+    You can add a keyed list (also known as a dictionary or
+    hash) to your document by placing each member of the
+    list on a new line, with a colon separating the key
+    from its value.  In YAML, this type of list is called
+    a mapping.
+yaml: |
+    foo: whatever
+    bar: stuff
+php: |
+    array('foo' => 'whatever', 'bar' => 'stuff')
+---
+test: Sequence in a Mapping
+brief: |
+    A value in a mapping can be a sequence.
+yaml: |
+    foo: whatever
+    bar:
+     - uno
+     - dos
+php: |
+    array('foo' => 'whatever', 'bar' => array('uno', 'dos'))
+---
+test: Nested Mappings
+brief: |
+    A value in a mapping can be another mapping.
+yaml: |
+    foo: whatever
+    bar:
+     fruit: apple
+     name: steve
+     sport: baseball
+php: |
+    array(
+      'foo' => 'whatever',
+      'bar' => array(
+         'fruit' => 'apple',
+         'name' => 'steve',
+         'sport' => 'baseball'
+       )
+    )
+---
+test: Mixed Mapping
+brief: |
+    A mapping can contain any assortment
+    of mappings and sequences as values.
+yaml: |
+    foo: whatever
+    bar:
+     -
+       fruit: apple
+       name: steve
+       sport: baseball
+     - more
+     -
+       python: rocks
+       perl: papers
+       ruby: scissorses
+php: |
+    array(
+      'foo' => 'whatever',
+      'bar' => array(
+        array(
+            'fruit' => 'apple',
+            'name' => 'steve',
+            'sport' => 'baseball'
+        ),
+        'more',
+        array(
+            'python' => 'rocks',
+            'perl' => 'papers',
+            'ruby' => 'scissorses'
+        )
+      )
+    )
+---
+test: Mapping-in-Sequence Shortcut
+todo: true
+brief: |
+     If you are adding a mapping to a sequence, you
+     can place the mapping on the same line as the
+     dash as a shortcut.
+yaml: |
+     - work on YAML.py:
+        - work on Store
+php: |
+    array(array('work on YAML.py' => array('work on Store')))
+---
+test: Sequence-in-Mapping Shortcut
+todo: true
+brief: |
+     The dash in a sequence counts as indentation, so
+     you can add a sequence inside of a mapping without
+     needing spaces as indentation.
+yaml: |
+     allow:
+     - 'localhost'
+     - '%.sourceforge.net'
+     - '%.freepan.org'
+php: |
+     array('allow' => array('localhost', '%.sourceforge.net', '%.freepan.org'))
+---
+todo: true
+test: Merge key
+brief: |
+     A merge key ('<<') can be used in a mapping to insert other mappings.  If
+     the value associated with the merge key is a mapping, each of its key/value
+     pairs is inserted into the current mapping.
+yaml: |
+     mapping:
+       name: Joe
+       job: Accountant
+       <<:
+         age: 38
+php: |
+     array(
+       'mapping' =>
+       array(
+         'name' => 'Joe',
+         'job' => 'Accountant',
+         'age' => 38
+       )
+     )

html2pdf-master/vendor/symfony/yaml/Tests/Fixtures/YtsBlockMapping.yml

@@ -0,0 +1,51 @@
+---
+test: One Element Mapping
+brief: |
+    A mapping with one key/value pair
+yaml: |
+    foo: bar
+php: |
+    array('foo' => 'bar')
+---
+test: Multi Element Mapping
+brief: |
+    More than one key/value pair
+yaml: |
+    red: baron
+    white: walls
+    blue: berries
+php: |
+    array(
+     'red' => 'baron',
+     'white' => 'walls',
+     'blue' => 'berries',
+    )
+---
+test: Values aligned
+brief: |
+    Often times human editors of documents will align the values even
+    though YAML emitters generally don't.
+yaml: |
+    red:   baron
+    white: walls
+    blue:  berries
+php: |
+    array(
+     'red' => 'baron',
+     'white' => 'walls',
+     'blue' => 'berries',
+    )
+---
+test: Colons aligned
+brief: |
+    Spaces can come before the ': ' key/value separator.
+yaml: |
+    red   : baron
+    white : walls
+    blue  : berries
+php: |
+    array(
+     'red' => 'baron',
+     'white' => 'walls',
+     'blue' => 'berries',
+    )

html2pdf-master/vendor/symfony/yaml/Tests/Fixtures/YtsDocumentSeparator.yml

@@ -0,0 +1,85 @@
+--- %YAML:1.0
+test: Trailing Document Separator
+todo: true
+brief: >
+    You can separate YAML documents
+    with a string of three dashes.
+yaml: |
+    - foo: 1
+      bar: 2
+    ---
+    more: stuff
+python: |
+    [
+        [ { 'foo': 1, 'bar': 2 } ],
+        { 'more': 'stuff' }
+    ]
+ruby: |
+    [ { 'foo' => 1, 'bar' => 2 } ]
+
+---
+test: Leading Document Separator
+todo: true
+brief: >
+    You can explicitly give an opening
+    document separator to your YAML stream.
+yaml: |
+    ---
+    - foo: 1
+      bar: 2
+    ---
+    more: stuff
+python: |
+    [
+        [ {'foo': 1, 'bar': 2}],
+        {'more': 'stuff'}
+    ]
+ruby: |
+    [ { 'foo' => 1, 'bar' => 2 } ]
+
+---
+test: YAML Header
+todo: true
+brief: >
+    The opening separator can contain directives
+    to the YAML parser, such as the version
+    number.
+yaml: |
+    --- %YAML:1.0
+    foo: 1
+    bar: 2
+php: |
+    array('foo' => 1, 'bar' => 2)
+documents: 1
+
+---
+test: Red Herring Document Separator
+brief: >
+    Separators included in blocks or strings
+    are treated as blocks or strings, as the
+    document separator should have no indentation
+    preceding it.
+yaml: |
+    foo: |
+        ---
+php: |
+    array('foo' => "---\n")
+
+---
+test: Multiple Document Separators in Block
+brief: >
+    This technique allows you to embed other YAML
+    documents within literal blocks.
+yaml: |
+    foo: |
+        ---
+        foo: bar
+        ---
+        yo: baz
+    bar: |
+        fooness
+php: |
+    array(
+       'foo' => "---\nfoo: bar\n---\nyo: baz\n",
+       'bar' => "fooness\n"
+    )

html2pdf-master/vendor/symfony/yaml/Tests/Fixtures/YtsErrorTests.yml

@@ -0,0 +1,25 @@
+---
+test: Missing value for hash item
+todo: true
+brief: |
+    Third item in this hash doesn't have a value
+yaml: |
+    okay: value
+    also okay: ~
+    causes error because no value specified
+    last key: value okay here too
+python-error: causes error because no value specified
+
+---
+test: Not indenting enough
+brief: |
+    There was a bug in PyYaml where it was off by one
+    in the indentation check.  It was allowing the YAML
+    below.
+# This is actually valid YAML now. Someone should tell showell.
+yaml: |
+    foo:
+    firstline: 1
+    secondline: 2
+php: |
+  array('foo' => null, 'firstline' => 1, 'secondline' => 2)

html2pdf-master/vendor/symfony/yaml/Tests/Fixtures/YtsFlowCollections.yml

@@ -0,0 +1,60 @@
+---
+test: Simple Inline Array
+brief: >
+    Sequences can be contained on a
+    single line, using the inline syntax.
+    Separate each entry with commas and
+    enclose in square brackets.
+yaml: |
+    seq: [ a, b, c ]
+php: |
+    array('seq' => array('a', 'b', 'c'))
+---
+test: Simple Inline Hash
+brief: >
+    Mapping can also be contained on
+    a single line, using the inline
+    syntax.  Each key-value pair is
+    separated by a colon, with a comma
+    between each entry in the mapping.
+    Enclose with curly braces.
+yaml: |
+    hash: { name: Steve, foo: bar }
+php: |
+    array('hash' => array('name' => 'Steve', 'foo' => 'bar'))
+---
+test: Multi-line Inline Collections
+todo: true
+brief: >
+    Both inline sequences and inline mappings
+    can span multiple lines, provided that you
+    indent the additional lines.
+yaml: |
+    languages: [ Ruby,
+                 Perl,
+                 Python ]
+    websites: { YAML: yaml.org,
+                Ruby: ruby-lang.org,
+                Python: python.org,
+                Perl: use.perl.org }
+php: |
+    array(
+      'languages' => array('Ruby', 'Perl', 'Python'),
+      'websites' => array(
+        'YAML' => 'yaml.org',
+        'Ruby' => 'ruby-lang.org',
+        'Python' => 'python.org',
+        'Perl' => 'use.perl.org'
+      )
+    )
+---
+test: Commas in Values (not in the spec!)
+todo: true
+brief: >
+    List items in collections are delimited by commas, but
+    there must be a space after each comma.  This allows you
+    to add numbers without quoting.
+yaml: |
+    attendances: [ 45,123, 70,000, 17,222 ]
+php: |
+    array('attendances' => array(45123, 70000, 17222))

html2pdf-master/vendor/symfony/yaml/Tests/Fixtures/YtsFoldedScalars.yml

@@ -0,0 +1,176 @@
+--- %YAML:1.0
+test: Single ending newline
+brief: >
+    A pipe character, followed by an indented
+    block of text is treated as a literal
+    block, in which newlines are preserved
+    throughout the block, including the final
+    newline.
+yaml: |
+    ---
+    this: |
+        Foo
+        Bar
+php: |
+    array('this' => "Foo\nBar\n")
+---
+test: The '+' indicator
+brief: >
+    The '+' indicator says to keep newlines at the end of text
+    blocks.
+yaml: |
+    normal: |
+      extra new lines not kept
+
+    preserving: |+
+      extra new lines are kept
+
+
+    dummy: value
+php: |
+    array(
+        'normal' => "extra new lines not kept\n",
+        'preserving' => "extra new lines are kept\n\n\n",
+        'dummy' => 'value'
+    )
+---
+test: Three trailing newlines in literals
+brief: >
+    To give you more control over how space
+    is preserved in text blocks, YAML has
+    the keep '+' and chomp '-' indicators.
+    The keep indicator will preserve all
+    ending newlines, while the chomp indicator
+    will strip all ending newlines.
+yaml: |
+    clipped: |
+        This has one newline.
+
+
+
+    same as "clipped" above: "This has one newline.\n"
+
+    stripped: |-
+        This has no newline.
+
+
+
+    same as "stripped" above: "This has no newline."
+
+    kept: |+
+        This has four newlines.
+
+
+
+    same as "kept" above: "This has four newlines.\n\n\n\n"
+php: |
+    array(
+      'clipped' => "This has one newline.\n",
+      'same as "clipped" above' => "This has one newline.\n",
+      'stripped' => 'This has no newline.',
+      'same as "stripped" above' => 'This has no newline.',
+      'kept' => "This has four newlines.\n\n\n\n",
+      'same as "kept" above' => "This has four newlines.\n\n\n\n"
+    )
+---
+test: Extra trailing newlines with spaces
+todo: true
+brief: >
+    Normally, only a single newline is kept
+    from the end of a literal block, unless the
+    keep '+' character is used in combination
+    with the pipe.  The following example
+    will preserve all ending whitespace
+    since the last line of both literal blocks
+    contains spaces which extend past the indentation
+    level.
+yaml: |
+    ---
+    this: |
+        Foo
+
+
+    kept: |+
+        Foo
+
+
+php: |
+    array('this' => "Foo\n\n  \n",
+      'kept' => "Foo\n\n  \n" )
+
+---
+test: Folded Block in a Sequence
+brief: >
+    A greater-then character, followed by an indented
+    block of text is treated as a folded block, in
+    which lines of text separated by a single newline
+    are concatenated as a single line.
+yaml: |
+    ---
+    - apple
+    - banana
+    - >
+        can't you see
+        the beauty of yaml?
+        hmm
+    - dog
+php: |
+    array(
+        'apple',
+        'banana',
+        "can't you see the beauty of yaml? hmm\n",
+        'dog'
+    )
+---
+test: Folded Block as a Mapping Value
+brief: >
+    Both literal and folded blocks can be
+    used in collections, as values in a
+    sequence or a mapping.
+yaml: |
+    ---
+    quote: >
+        Mark McGwire's
+        year was crippled
+        by a knee injury.
+    source: espn
+php: |
+    array(
+        'quote' => "Mark McGwire's year was crippled by a knee injury.\n",
+        'source' => 'espn'
+    )
+---
+test: Three trailing newlines in folded blocks
+brief: >
+    The keep and chomp indicators can also
+    be applied to folded blocks.
+yaml: |
+    clipped: >
+        This has one newline.
+
+
+
+    same as "clipped" above: "This has one newline.\n"
+
+    stripped: >-
+        This has no newline.
+
+
+
+    same as "stripped" above: "This has no newline."
+
+    kept: >+
+        This has four newlines.
+
+
+
+    same as "kept" above: "This has four newlines.\n\n\n\n"
+php: |
+    array(
+      'clipped' => "This has one newline.\n",
+      'same as "clipped" above' => "This has one newline.\n",
+      'stripped' => 'This has no newline.',
+      'same as "stripped" above' => 'This has no newline.',
+      'kept' => "This has four newlines.\n\n\n\n",
+      'same as "kept" above' => "This has four newlines.\n\n\n\n"
+    )

html2pdf-master/vendor/symfony/yaml/Tests/Fixtures/YtsNullsAndEmpties.yml

@@ -0,0 +1,45 @@
+--- %YAML:1.0
+test: Empty Sequence
+brief: >
+    You can represent the empty sequence
+    with an empty inline sequence.
+yaml: |
+    empty: []
+php: |
+    array('empty' => array())
+---
+test: Empty Mapping
+brief: >
+    You can represent the empty mapping
+    with an empty inline mapping.
+yaml: |
+    empty: {}
+php: |
+    array('empty' => array())
+---
+test: Empty Sequence as Entire Document
+yaml: |
+    []
+php: |
+    array()
+---
+test: Empty Mapping as Entire Document
+yaml: |
+    {}
+php: |
+    array()
+---
+test: Null as Document
+yaml: |
+    ~
+php: |
+    null
+---
+test: Empty String
+brief: >
+    You can represent an empty string
+    with a pair of quotes.
+yaml: |
+    ''
+php: |
+    ''

html2pdf-master/vendor/symfony/yaml/Tests/Fixtures/YtsTypeTransfers.yml

@@ -0,0 +1,266 @@
+--- %YAML:1.0
+test: Strings
+brief: >
+    Any group of characters beginning with an
+    alphabetic or numeric character is a string,
+    unless it belongs to one of the groups below
+    (such as an Integer or Time).
+yaml: |
+    String
+php: |
+    'String'
+---
+test: String characters
+brief: >
+    A string can contain any alphabetic or
+    numeric character, along with many
+    punctuation characters, including the
+    period, dash, space, quotes, exclamation, and
+    question mark.
+yaml: |
+    - What's Yaml?
+    - It's for writing data structures in plain text.
+    - And?
+    - And what? That's not good enough for you?
+    - No, I mean, "And what about Yaml?"
+    - Oh, oh yeah. Uh.. Yaml for Ruby.
+php: |
+    array(
+      "What's Yaml?",
+      "It's for writing data structures in plain text.",
+      "And?",
+      "And what? That's not good enough for you?",
+      "No, I mean, \"And what about Yaml?\"",
+      "Oh, oh yeah. Uh.. Yaml for Ruby."
+    )
+---
+test: Indicators in Strings
+brief: >
+    Be careful using indicators in strings.  In particular,
+    the comma, colon, and pound sign must be used carefully.
+yaml: |
+    the colon followed by space is an indicator: but is a string:right here
+    same for the pound sign: here we have it#in a string
+    the comma can, honestly, be used in most cases: [ but not in, inline collections ]
+php: |
+    array(
+      'the colon followed by space is an indicator' => 'but is a string:right here',
+      'same for the pound sign' => 'here we have it#in a string',
+      'the comma can, honestly, be used in most cases' => array('but not in', 'inline collections')
+    )
+---
+test: Forcing Strings
+brief: >
+    Any YAML type can be forced into a string using the
+    explicit !str method.
+yaml: |
+    date string: !str 2001-08-01
+    number string: !str 192
+php: |
+    array(
+      'date string' => '2001-08-01',
+      'number string' => '192'
+    )
+---
+test: Single-quoted Strings
+brief: >
+    You can also enclose your strings within single quotes,
+    which allows use of slashes, colons, and other indicators
+    freely.  Inside single quotes, you can represent a single
+    quote in your string by using two single quotes next to
+    each other.
+yaml: |
+    all my favorite symbols: '#:!/%.)'
+    a few i hate: '&(*'
+    why do i hate them?: 'it''s very hard to explain'
+    entities: '£ me'
+php: |
+    array(
+      'all my favorite symbols' => '#:!/%.)',
+      'a few i hate' => '&(*',
+      'why do i hate them?' => 'it\'s very hard to explain',
+      'entities' => '£ me'
+    )
+---
+test: Double-quoted Strings
+brief: >
+    Enclosing strings in double quotes allows you
+    to use escapings to represent ASCII and
+    Unicode characters.
+yaml: |
+    i know where i want my line breaks: "one here\nand another here\n"
+php: |
+    array(
+      'i know where i want my line breaks' => "one here\nand another here\n"
+    )
+---
+test: Multi-line Quoted Strings
+todo: true
+brief: >
+    Both single- and double-quoted strings may be
+    carried on to new lines in your YAML document.
+    They must be indented a step and indentation
+    is interpreted as a single space.
+yaml: |
+    i want a long string: "so i'm going to
+      let it go on and on to other lines
+      until i end it with a quote."
+php: |
+    array('i want a long string' => "so i'm going to ".
+         "let it go on and on to other lines ".
+         "until i end it with a quote."
+    )
+
+---
+test: Plain scalars
+todo: true
+brief: >
+    Unquoted strings may also span multiple lines, if they
+    are free of YAML space indicators and indented.
+yaml: |
+    - My little toe is broken in two places;
+    - I'm crazy to have skied this way;
+    - I'm not the craziest he's seen, since there was always the German guy
+      who skied for 3 hours on a broken shin bone (just below the kneecap);
+    - Nevertheless, second place is respectable, and he doesn't
+      recommend going for the record;
+    - He's going to put my foot in plaster for a month;
+    - This would impair my skiing ability somewhat for the
+      duration, as can be imagined.
+php: |
+    array(
+      "My little toe is broken in two places;",
+      "I'm crazy to have skied this way;",
+      "I'm not the craziest he's seen, since there was always ".
+         "the German guy who skied for 3 hours on a broken shin ".
+         "bone (just below the kneecap);",
+      "Nevertheless, second place is respectable, and he doesn't ".
+         "recommend going for the record;",
+      "He's going to put my foot in plaster for a month;",
+      "This would impair my skiing ability somewhat for the duration, ".
+         "as can be imagined."
+    )
+---
+test: 'Null'
+brief: >
+    You can use the tilde '~' character for a null value.
+yaml: |
+    name: Mr. Show
+    hosted by: Bob and David
+    date of next season: ~
+php: |
+    array(
+      'name' => 'Mr. Show',
+      'hosted by' => 'Bob and David',
+      'date of next season' => null
+    )
+---
+test: Boolean
+brief: >
+    You can use 'true' and 'false' for Boolean values.
+yaml: |
+    Is Gus a Liar?: true
+    Do I rely on Gus for Sustenance?: false
+php: |
+    array(
+      'Is Gus a Liar?' => true,
+      'Do I rely on Gus for Sustenance?' => false
+    )
+---
+test: Integers
+dump_skip: true
+brief: >
+    An integer is a series of numbers, optionally
+    starting with a positive or negative sign.  Integers
+    may also contain commas for readability.
+yaml: |
+    zero: 0
+    simple: 12
+php: |
+    array(
+      'zero' => 0,
+      'simple' => 12,
+    )
+---
+test: Positive Big Integer
+deprecated: true
+dump_skip: true
+brief: >
+    An integer is a series of numbers, optionally
+    starting with a positive or negative sign.  Integers
+    may also contain commas for readability.
+yaml: |
+    one-thousand: 1,000
+php: |
+    array(
+      'one-thousand' => 1000.0,
+    )
+---
+test: Negative Big Integer
+deprecated: true
+dump_skip: true
+brief: >
+    An integer is a series of numbers, optionally
+    starting with a positive or negative sign.  Integers
+    may also contain commas for readability.
+yaml: |
+    negative one-thousand: -1,000
+php: |
+    array(
+      'negative one-thousand' => -1000.0
+    )
+---
+test: Floats
+dump_skip: true
+brief: >
+     Floats are represented by numbers with decimals,
+     allowing for scientific notation, as well as
+     positive and negative infinity and "not a number."
+yaml: |
+     a simple float: 2.00
+     scientific notation: 1.00009e+3
+php: |
+     array(
+       'a simple float' => 2.0,
+       'scientific notation' => 1000.09
+     )
+---
+test: Larger Float
+dump_skip: true
+deprecated: true
+brief: >
+     Floats are represented by numbers with decimals,
+     allowing for scientific notation, as well as
+     positive and negative infinity and "not a number."
+yaml: |
+     larger float: 1,000.09
+php: |
+     array(
+       'larger float' => 1000.09,
+     )
+---
+test: Time
+todo: true
+brief: >
+    You can represent timestamps by using
+    ISO8601 format, or a variation which
+    allows spaces between the date, time and
+    time zone.
+yaml: |
+    iso8601: 2001-12-14t21:59:43.10-05:00
+    space separated: 2001-12-14 21:59:43.10 -05:00
+php: |
+    array(
+      'iso8601' => mktime( 2001, 12, 14, 21, 59, 43, 0.10, "-05:00" ),
+      'space separated' => mktime( 2001, 12, 14, 21, 59, 43, 0.10, "-05:00" )
+    )
+---
+test: Date
+todo: true
+brief: >
+    A date can be represented by its year,
+    month and day in ISO8601 order.
+yaml: |
+    1976-07-31
+php: |
+    date( 1976, 7, 31 )

html2pdf-master/vendor/symfony/yaml/Tests/Fixtures/booleanMappingKeys.yml

@@ -0,0 +1,11 @@
+--- %YAML:1.0
+test: Miscellaneous
+spec: 2.21
+yaml: |
+  true: true
+  false: false
+php: |
+  array(
+    'true' => true,
+    'false' => false,
+  )

html2pdf-master/vendor/symfony/yaml/Tests/Fixtures/embededPhp.yml

@@ -0,0 +1 @@
+value: <?php echo 1 + 2 + 3 ?>

html2pdf-master/vendor/symfony/yaml/Tests/Fixtures/escapedCharacters.yml

@@ -0,0 +1,155 @@
+test: outside double quotes
+yaml: |
+    \0 \ \a \b \n
+php: |
+    "\\0 \\ \\a \\b \\n"
+---
+test: null
+yaml: |
+    "\0"
+php: |
+    "\x00"
+---
+test: bell
+yaml: |
+    "\a"
+php: |
+    "\x07"
+---
+test: backspace
+yaml: |
+    "\b"
+php: |
+    "\x08"
+---
+test: horizontal tab (1)
+yaml: |
+    "\t"
+php: |
+    "\x09"
+---
+test: horizontal tab (2)
+yaml: |
+    "\	"
+php: |
+    "\x09"
+---
+test: line feed
+yaml: |
+    "\n"
+php: |
+    "\x0a"
+---
+test: vertical tab
+yaml: |
+    "\v"
+php: |
+    "\x0b"
+---
+test: form feed
+yaml: |
+    "\f"
+php: |
+    "\x0c"
+---
+test: carriage return
+yaml: |
+    "\r"
+php: |
+    "\x0d"
+---
+test: escape
+yaml: |
+    "\e"
+php: |
+   "\x1b"
+---
+test: space
+yaml: |
+    "\ "
+php: |
+    "\x20"
+---
+test: slash
+yaml: |
+    "\/"
+php: |
+    "\x2f"
+---
+test: backslash
+yaml: |
+    "\\"
+php: |
+    "\\"
+---
+test: Unicode next line
+yaml: |
+    "\N"
+php: |
+    "\xc2\x85"
+---
+test: Unicode non-breaking space
+yaml: |
+    "\_"
+php: |
+    "\xc2\xa0"
+---
+test: Unicode line separator
+yaml: |
+    "\L"
+php: |
+    "\xe2\x80\xa8"
+---
+test: Unicode paragraph separator
+yaml: |
+    "\P"
+php: |
+    "\xe2\x80\xa9"
+---
+test: Escaped 8-bit Unicode
+yaml: |
+    "\x42"
+php: |
+    "B"
+---
+test: Escaped 16-bit Unicode
+yaml: |
+    "\u20ac"
+php: |
+    "\xe2\x82\xac"
+---
+test: Escaped 32-bit Unicode
+yaml: |
+    "\U00000043"
+php: |
+    "C"
+---
+test: Example 5.13 Escaped Characters
+note: |
+    Currently throws an error parsing first line. Maybe Symfony Yaml doesn't support
+    continuation of string across multiple lines? Keeping test here but disabled.
+todo: true
+yaml: |
+    "Fun with \\
+    \" \a \b \e \f \
+    \n \r \t \v \0 \
+    \  \_ \N \L \P \
+    \x41 \u0041 \U00000041"
+php: |
+    "Fun with \x5C\n\x22 \x07 \x08 \x1B \x0C\n\x0A \x0D \x09 \x0B \x00\n\x20 \xA0 \x85 \xe2\x80\xa8 \xe2\x80\xa9\nA A A"
+---
+test: Double quotes with a line feed
+yaml: |
+   { double: "some value\n \"some quoted string\" and 'some single quotes one'" }
+php: |
+    array(
+        'double' => "some value\n \"some quoted string\" and 'some single quotes one'"
+    )
+---
+test: Backslashes
+yaml: |
+    { single: 'foo\Var', no-quotes: foo\Var, double: "foo\\Var" }
+php: |
+    array(
+        'single' => 'foo\Var', 'no-quotes' => 'foo\Var', 'double' => 'foo\Var'
+    )

html2pdf-master/vendor/symfony/yaml/Tests/Fixtures/index.yml

@@ -0,0 +1,18 @@
+- escapedCharacters
+- sfComments
+- sfCompact
+- sfTests
+- sfObjects
+- sfMergeKey
+- sfQuotes
+- YtsAnchorAlias
+- YtsBasicTests
+- YtsBlockMapping
+- YtsDocumentSeparator
+- YtsErrorTests
+- YtsFlowCollections
+- YtsFoldedScalars
+- YtsNullsAndEmpties
+- YtsSpecificationExamples
+- YtsTypeTransfers
+- unindentedCollections

html2pdf-master/vendor/symfony/yaml/Tests/Fixtures/legacyBooleanMappingKeys.yml

@@ -0,0 +1,23 @@
+--- %YAML:1.0
+test: Miscellaneous
+spec: 2.21
+yaml: |
+  true: true
+  false: false
+php: |
+  array(
+    1 => true,
+    0 => false,
+  )
+---
+test: Boolean
+yaml: |
+   false: used as key
+   logical:  true
+   answer: false
+php: |
+   array(
+     false => 'used as key',
+     'logical' => true,
+     'answer' => false
+   )

html2pdf-master/vendor/symfony/yaml/Tests/Fixtures/legacyNonStringKeys.yml

@@ -0,0 +1,2 @@
+- legacyBooleanMappingKeys
+- legacyNullMappingKey

html2pdf-master/vendor/symfony/yaml/Tests/Fixtures/legacyNullMappingKey.yml

@@ -0,0 +1,9 @@
+--- %YAML:1.0
+test: Miscellaneous
+spec: 2.21
+yaml: |
+  null: ~
+php: |
+  array(
+    '' => null,
+  )

html2pdf-master/vendor/symfony/yaml/Tests/Fixtures/multiple_lines_as_literal_block.yml

@@ -0,0 +1,13 @@
+data:
+    single_line: 'foo bar baz'
+    multi_line: |
+        foo
+        line with trailing spaces:
+          
+        bar
+        integer like line:
+        123456789
+        empty line:
+        
+        baz
+    nested_inlined_multi_line_string: { inlined_multi_line: "foo\nbar\r\nempty line:\n\nbaz" }

html2pdf-master/vendor/symfony/yaml/Tests/Fixtures/nonStringKeys.yml

@@ -0,0 +1,3 @@
+- booleanMappingKeys
+- numericMappingKeys
+- nullMappingKey

html2pdf-master/vendor/symfony/yaml/Tests/Fixtures/nullMappingKey.yml

@@ -0,0 +1,9 @@
+--- %YAML:1.0
+test: Miscellaneous
+spec: 2.21
+yaml: |
+  null: ~
+php: |
+  array(
+    'null' => null,
+  )

html2pdf-master/vendor/symfony/yaml/Tests/Fixtures/numericMappingKeys.yml

@@ -0,0 +1,23 @@
+--- %YAML:1.0
+test: A sequence with an unordered array
+brief: >
+  A sequence with an unordered array
+yaml: |
+  1: foo
+  0: bar
+php: |
+  array(1 => 'foo', 0 => 'bar')
+---
+test: Integers as Map Keys
+brief: >
+    An integer can be used as dictionary key.
+yaml: |
+    1: one
+    2: two
+    3: three
+php: |
+    array(
+        1 => 'one',
+        2 => 'two',
+        3 => 'three'
+    )

html2pdf-master/vendor/symfony/yaml/Tests/Fixtures/sfComments.yml

@@ -0,0 +1,76 @@
+--- %YAML:1.0
+test: Comments at the end of a line
+brief: >
+    Comments at the end of a line
+yaml: |
+    ex1: "foo # bar"
+    ex2: "foo # bar" # comment
+    ex3: 'foo # bar' # comment
+    ex4: foo # comment
+    ex5: foo	#	comment with tab before  
+    ex6: foo#foo # comment here
+    ex7: foo 	# ignore me # and me
+php: |
+    array('ex1' => 'foo # bar', 'ex2' => 'foo # bar', 'ex3' => 'foo # bar', 'ex4' => 'foo', 'ex5' => 'foo', 'ex6' => 'foo#foo', 'ex7' => 'foo')
+---
+test: Comments in the middle
+brief: >
+  Comments in the middle
+yaml: |
+    foo:
+    # some comment
+    # some comment
+      bar: foo
+    # some comment
+    # some comment
+php: |
+    array('foo' => array('bar' => 'foo'))
+---
+test: Comments on a hash line
+brief: >
+  Comments on a hash line
+yaml: |
+    foo:   # a comment
+      foo: bar # a comment
+php: |
+    array('foo' => array('foo' => 'bar'))
+---
+test: 'Value starting with a #'
+brief: >
+  'Value starting with a #'
+yaml: |
+    foo:   '#bar'
+php: |
+    array('foo' => '#bar')
+---
+test: Document starting with a comment and a separator
+brief: >
+  Commenting before document start is allowed
+yaml: |
+    # document comment
+    ---
+    foo: bar # a comment
+php: |
+    array('foo' => 'bar')
+---
+test: Comment containing a colon on a hash line
+brief: >
+    Comment containing a colon on a scalar line
+yaml: 'foo # comment: this is also part of the comment'
+php: |
+    'foo'
+---
+test: 'Hash key containing a #'
+brief: >
+    'Hash key containing a #'
+yaml: 'foo#bar: baz'
+php: |
+    array('foo#bar' => 'baz')
+---
+test: 'Hash key ending with a space and a #'
+brief: >
+    'Hash key ending with a space and a #'
+yaml: |
+    'foo #': baz
+php: |
+    array('foo #' => 'baz')

html2pdf-master/vendor/symfony/yaml/Tests/Fixtures/sfCompact.yml

@@ -0,0 +1,159 @@
+--- %YAML:1.0
+test: Compact notation
+brief: |
+    Compact notation for sets of mappings with single element
+yaml: |
+  ---
+  # products purchased
+  - item    : Super Hoop
+  - item    : Basketball
+    quantity: 1
+  - item:
+      name: Big Shoes
+      nick: Biggies
+    quantity: 1
+php: |
+  array (
+    array (
+      'item' => 'Super Hoop',
+    ),
+    array (
+      'item' => 'Basketball',
+      'quantity' => 1,
+    ),
+    array (
+      'item' => array(
+        'name' => 'Big Shoes',
+        'nick' => 'Biggies'
+      ),
+      'quantity' => 1
+    )
+  )
+---
+test: Compact notation combined with inline notation
+brief: |
+    Combinations of compact and inline notation are allowed
+yaml: |
+  ---
+  items:
+    - { item: Super Hoop, quantity: 1 }
+    - [ Basketball, Big Shoes ]
+php: |
+  array (
+    'items' => array (
+      array (
+        'item' => 'Super Hoop',
+        'quantity' => 1,
+      ),
+      array (
+        'Basketball',
+        'Big Shoes'
+      )
+    )
+  )
+--- %YAML:1.0
+test: Compact notation
+brief: |
+    Compact notation for sets of mappings with single element
+yaml: |
+  ---
+  # products purchased
+  - item    : Super Hoop
+  - item    : Basketball
+    quantity: 1
+  - item:
+      name: Big Shoes
+      nick: Biggies
+    quantity: 1
+php: |
+  array (
+    array (
+      'item' => 'Super Hoop',
+    ),
+    array (
+      'item' => 'Basketball',
+      'quantity' => 1,
+    ),
+    array (
+      'item' => array(
+        'name' => 'Big Shoes',
+        'nick' => 'Biggies'
+      ),
+      'quantity' => 1
+    )
+  )
+---
+test: Compact notation combined with inline notation
+brief: |
+    Combinations of compact and inline notation are allowed
+yaml: |
+  ---
+  items:
+    - { item: Super Hoop, quantity: 1 }
+    - [ Basketball, Big Shoes ]
+php: |
+  array (
+    'items' => array (
+      array (
+        'item' => 'Super Hoop',
+        'quantity' => 1,
+      ),
+      array (
+        'Basketball',
+        'Big Shoes'
+      )
+    )
+  )
+--- %YAML:1.0
+test: Compact notation
+brief: |
+    Compact notation for sets of mappings with single element
+yaml: |
+  ---
+  # products purchased
+  - item    : Super Hoop
+  - item    : Basketball
+    quantity: 1
+  - item:
+      name: Big Shoes
+      nick: Biggies
+    quantity: 1
+php: |
+  array (
+    array (
+      'item' => 'Super Hoop',
+    ),
+    array (
+      'item' => 'Basketball',
+      'quantity' => 1,
+    ),
+    array (
+      'item' => array(
+        'name' => 'Big Shoes',
+        'nick' => 'Biggies'
+      ),
+      'quantity' => 1
+    )
+  )
+---
+test: Compact notation combined with inline notation
+brief: |
+    Combinations of compact and inline notation are allowed
+yaml: |
+  ---
+  items:
+    - { item: Super Hoop, quantity: 1 }
+    - [ Basketball, Big Shoes ]
+php: |
+  array (
+    'items' => array (
+      array (
+        'item' => 'Super Hoop',
+        'quantity' => 1,
+      ),
+      array (
+        'Basketball',
+        'Big Shoes'
+      )
+    )
+  )

html2pdf-master/vendor/symfony/yaml/Tests/Fixtures/sfMergeKey.yml

@@ -0,0 +1,55 @@
+--- %YAML:1.0
+test: Simple In Place Substitution
+brief: >
+    If you want to reuse an entire alias, only overwriting what is different
+    you can use a << in place substitution. This is not part of the official
+    YAML spec, but a widely implemented extension. See the following URL for
+    details: http://yaml.org/type/merge.html
+yaml: |
+    foo: &foo
+        a: Steve
+        b: Clark
+        c: Brian
+        e: notnull
+    bar:
+        a: before
+        d: other
+        e: ~
+        <<: *foo
+        b: new
+        x: Oren
+        c:
+            foo: bar
+            bar: foo
+    foo2: &foo2
+        a: Ballmer
+    ding: &dong [ fi, fei, fo, fam]
+    check:
+        <<:
+            - *foo
+            - *dong
+        isit: tested
+    head:
+        <<: [ *foo , *dong , *foo2 ]
+    taz: &taz
+        a: Steve
+        w:
+            p: 1234
+    nested:
+        <<: *taz
+        d: Doug
+        w: &nestedref
+            p: 12345
+        z:
+            <<: *nestedref
+php: |
+    array(
+        'foo' => array('a' => 'Steve', 'b' => 'Clark', 'c' => 'Brian', 'e' => 'notnull'),
+        'bar' => array('a' => 'before', 'd' => 'other', 'e' => null, 'b' => 'new', 'c' => array('foo' => 'bar', 'bar' => 'foo'), 'x' => 'Oren'),
+        'foo2' => array('a' => 'Ballmer'),
+        'ding' => array('fi', 'fei', 'fo', 'fam'),
+        'check' => array('a' => 'Steve', 'b' => 'Clark', 'c' => 'Brian', 'e' => 'notnull', 'fi', 'fei', 'fo', 'fam', 'isit' => 'tested'),
+        'head' => array('a' => 'Steve', 'b' => 'Clark', 'c' => 'Brian', 'e' => 'notnull', 'fi', 'fei', 'fo', 'fam'),
+        'taz' => array('a' => 'Steve', 'w' => array('p' => 1234)),
+        'nested' => array('a' => 'Steve', 'w' => array('p' => 12345), 'd' => 'Doug', 'z' => array('p' => 12345))
+    )

html2pdf-master/vendor/symfony/yaml/Tests/Fixtures/sfObjects.yml

@@ -0,0 +1,11 @@
+--- %YAML:1.0
+test: Objects
+brief: >
+    Comments at the end of a line
+yaml: |
+    ex1: "foo # bar"
+    ex2: "foo # bar" # comment
+    ex3: 'foo # bar' # comment
+    ex4: foo # comment
+php: |
+    array('ex1' => 'foo # bar', 'ex2' => 'foo # bar', 'ex3' => 'foo # bar', 'ex4' => 'foo')

html2pdf-master/vendor/symfony/yaml/Tests/Fixtures/sfQuotes.yml

@@ -0,0 +1,33 @@
+--- %YAML:1.0
+test: Some characters at the beginning of a string must be escaped
+brief: >
+    Some characters at the beginning of a string must be escaped
+yaml: |
+    foo: '| bar'
+php: |
+    array('foo' => '| bar')
+---
+test: A key can be a quoted string
+brief: >
+  A key can be a quoted string
+yaml: |
+    "foo1": bar
+    'foo2': bar
+    "foo \" bar": bar
+    'foo '' bar': bar
+    'foo3: ': bar
+    "foo4: ": bar
+    foo5: { "foo \" bar: ": bar, 'foo '' bar: ': bar }
+php: |
+    array(
+      'foo1' => 'bar',
+      'foo2' => 'bar',
+      'foo " bar' => 'bar',
+      'foo \' bar' => 'bar',
+      'foo3: ' => 'bar',
+      'foo4: ' => 'bar',
+      'foo5' => array(
+        'foo " bar: ' => 'bar',
+        'foo \' bar: ' => 'bar',
+      ),
+    )

html2pdf-master/vendor/symfony/yaml/Tests/Fixtures/sfTests.yml

@@ -0,0 +1,140 @@
+--- %YAML:1.0
+test: Multiple quoted string on one line
+brief: >
+    Multiple quoted string on one line
+yaml: |
+    stripped_title: { name: "foo bar", help: "bar foo" }
+php: |
+    array('stripped_title' => array('name' => 'foo bar', 'help' => 'bar foo'))
+---
+test: Empty sequence
+yaml: |
+    foo: [ ]
+php: |
+    array('foo' => array())
+---
+test: Empty value
+yaml: |
+    foo:
+php: |
+    array('foo' => null)
+---
+test: Inline string parsing
+brief: >
+    Inline string parsing
+yaml: |
+    test: ['complex: string', 'another [string]']
+php: |
+    array('test' => array('complex: string', 'another [string]'))
+---
+test: Boolean
+brief: >
+    Boolean
+yaml: |
+    - false
+    - true
+    - null
+    - ~
+    - 'false'
+    - 'true'
+    - 'null'
+    - '~'
+php: |
+    array(
+      false,
+      true,
+      null,
+      null,
+      'false',
+      'true',
+      'null',
+      '~',
+    )
+---
+test: Empty lines in literal blocks
+brief: >
+  Empty lines in literal blocks
+yaml: |
+  foo:
+    bar: |
+      foo
+
+
+        
+      bar
+php: |
+  array('foo' => array('bar' => "foo\n\n\n  \nbar\n"))
+---
+test: Empty lines in folded blocks
+brief: >
+  Empty lines in folded blocks
+yaml: |
+  foo:
+    bar: >
+
+      foo
+
+      
+      bar
+php: |
+  array('foo' => array('bar' => "\nfoo\n\nbar\n"))
+---
+test: IP addresses
+brief: >
+  IP addresses
+yaml: |
+  foo: 10.0.0.2
+php: |
+  array('foo' => '10.0.0.2')
+---
+test: A sequence with an embedded mapping
+brief: >
+  A sequence with an embedded mapping
+yaml: |
+  - foo
+  - bar: { bar: foo }
+php: |
+  array('foo', array('bar' => array('bar' => 'foo')))
+---
+test: Octal
+brief: as in spec example 2.19, octal value is converted
+yaml: |
+  foo: 0123
+php: |
+  array('foo' => 83)
+---
+test: Octal strings
+brief: Octal notation in a string must remain a string
+yaml: |
+  foo: "0123"
+php: |
+  array('foo' => '0123')
+---
+test: Octal strings
+brief: Octal notation in a string must remain a string
+yaml: |
+  foo: '0123'
+php: |
+  array('foo' => '0123')
+---
+test: Octal strings
+brief: Octal notation in a string must remain a string
+yaml: |
+  foo: |
+    0123
+php: |
+  array('foo' => "0123\n")
+---
+test: Document as a simple hash
+brief: Document as a simple hash
+yaml: |
+  { foo: bar }
+php: |
+  array('foo' => 'bar')
+---
+test: Document as a simple array
+brief: Document as a simple array
+yaml: |
+  [ foo, bar ]
+php: |
+  array('foo', 'bar')

html2pdf-master/vendor/symfony/yaml/Tests/Fixtures/unindentedCollections.yml

@@ -0,0 +1,82 @@
+--- %YAML:1.0
+test: Unindented collection
+brief: >
+    Unindented collection
+yaml: |
+    collection:
+    - item1
+    - item2
+    - item3
+php: |
+    array('collection' => array('item1', 'item2', 'item3'))
+---
+test: Nested unindented collection (two levels)
+brief: >
+    Nested unindented collection
+yaml: |
+    collection:
+        key:
+        - a
+        - b
+        - c
+php: |
+    array('collection' => array('key' => array('a', 'b', 'c')))
+---
+test: Nested unindented collection (three levels)
+brief: >
+    Nested unindented collection
+yaml: |
+    collection:
+        key:
+            subkey:
+            - one
+            - two
+            - three
+php: |
+    array('collection' => array('key' => array('subkey' => array('one', 'two', 'three'))))
+---
+test: Key/value after unindented collection (1)
+brief: >
+    Key/value after unindented collection (1)
+yaml: |
+    collection:
+        key:
+        - a
+        - b
+        - c
+    foo: bar
+php: |
+    array('collection' => array('key' => array('a', 'b', 'c')), 'foo' => 'bar')
+---
+test: Key/value after unindented collection (at the same level)
+brief: >
+    Key/value after unindented collection
+yaml: |
+    collection:
+        key:
+        - a
+        - b
+        - c
+        foo: bar
+php: |
+    array('collection' => array('key' => array('a', 'b', 'c'), 'foo' => 'bar'))
+---
+test: Shortcut Key after unindented collection
+brief: >
+    Key/value after unindented collection
+yaml: |
+    collection:
+    - key: foo
+      foo: bar
+php: |
+    array('collection' => array(array('key' => 'foo', 'foo' => 'bar')))
+---
+test: Shortcut Key after unindented collection with custom spaces
+brief: >
+    Key/value after unindented collection
+yaml: |
+    collection:
+    -  key: foo
+       foo: bar
+php: |
+    array('collection' => array(array('key' => 'foo', 'foo' => 'bar')))

html2pdf-master/vendor/symfony/yaml/Tests/InlineTest.php

@@ -0,0 +1,758 @@
+<?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 Symfony\Component\Yaml\Tests;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Yaml\Exception\ParseException;
+use Symfony\Component\Yaml\Inline;
+use Symfony\Component\Yaml\Yaml;
+
+class InlineTest extends TestCase
+{
+    /**
+     * @dataProvider getTestsForParse
+     */
+    public function testParse($yaml, $value, $flags = 0)
+    {
+        $this->assertSame($value, Inline::parse($yaml, $flags), sprintf('::parse() converts an inline YAML to a PHP structure (%s)', $yaml));
+    }
+
+    /**
+     * @dataProvider getTestsForParseWithMapObjects
+     */
+    public function testParseWithMapObjects($yaml, $value, $flags = Yaml::PARSE_OBJECT_FOR_MAP)
+    {
+        $actual = Inline::parse($yaml, $flags);
+
+        $this->assertSame(serialize($value), serialize($actual));
+    }
+
+    /**
+     * @dataProvider getTestsForParsePhpConstants
+     */
+    public function testParsePhpConstants($yaml, $value)
+    {
+        $actual = Inline::parse($yaml, Yaml::PARSE_CONSTANT);
+
+        $this->assertSame($value, $actual);
+    }
+
+    public function getTestsForParsePhpConstants()
+    {
+        return array(
+            array('!php/const:Symfony\Component\Yaml\Yaml::PARSE_CONSTANT', Yaml::PARSE_CONSTANT),
+            array('!php/const:PHP_INT_MAX', PHP_INT_MAX),
+            array('[!php/const:PHP_INT_MAX]', array(PHP_INT_MAX)),
+            array('{ foo: !php/const:PHP_INT_MAX }', array('foo' => PHP_INT_MAX)),
+        );
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Yaml\Exception\ParseException
+     * @expectedExceptionMessage The constant "WRONG_CONSTANT" is not defined
+     */
+    public function testParsePhpConstantThrowsExceptionWhenUndefined()
+    {
+        Inline::parse('!php/const:WRONG_CONSTANT', Yaml::PARSE_CONSTANT);
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Yaml\Exception\ParseException
+     * @expectedExceptionMessageRegExp #The string "!php/const:PHP_INT_MAX" could not be parsed as a constant.*#
+     */
+    public function testParsePhpConstantThrowsExceptionOnInvalidType()
+    {
+        Inline::parse('!php/const:PHP_INT_MAX', Yaml::PARSE_EXCEPTION_ON_INVALID_TYPE);
+    }
+
+    /**
+     * @group legacy
+     * @dataProvider getTestsForParseWithMapObjects
+     */
+    public function testParseWithMapObjectsPassingTrue($yaml, $value)
+    {
+        $actual = Inline::parse($yaml, false, false, true);
+
+        $this->assertSame(serialize($value), serialize($actual));
+    }
+
+    /**
+     * @dataProvider getTestsForDump
+     */
+    public function testDump($yaml, $value, $parseFlags = 0)
+    {
+        $this->assertEquals($yaml, Inline::dump($value), sprintf('::dump() converts a PHP structure to an inline YAML (%s)', $yaml));
+
+        $this->assertSame($value, Inline::parse(Inline::dump($value), $parseFlags), 'check consistency');
+    }
+
+    public function testDumpNumericValueWithLocale()
+    {
+        $locale = setlocale(LC_NUMERIC, 0);
+        if (false === $locale) {
+            $this->markTestSkipped('Your platform does not support locales.');
+        }
+
+        try {
+            $requiredLocales = array('fr_FR.UTF-8', 'fr_FR.UTF8', 'fr_FR.utf-8', 'fr_FR.utf8', 'French_France.1252');
+            if (false === setlocale(LC_NUMERIC, $requiredLocales)) {
+                $this->markTestSkipped('Could not set any of required locales: '.implode(', ', $requiredLocales));
+            }
+
+            $this->assertEquals('1.2', Inline::dump(1.2));
+            $this->assertContains('fr', strtolower(setlocale(LC_NUMERIC, 0)));
+        } finally {
+            setlocale(LC_NUMERIC, $locale);
+        }
+    }
+
+    public function testHashStringsResemblingExponentialNumericsShouldNotBeChangedToINF()
+    {
+        $value = '686e444';
+
+        $this->assertSame($value, Inline::parse(Inline::dump($value)));
+    }
+
+    /**
+     * @expectedException        \Symfony\Component\Yaml\Exception\ParseException
+     * @expectedExceptionMessage Found unknown escape character "\V".
+     */
+    public function testParseScalarWithNonEscapedBlackslashShouldThrowException()
+    {
+        Inline::parse('"Foo\Var"');
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Yaml\Exception\ParseException
+     */
+    public function testParseScalarWithNonEscapedBlackslashAtTheEndShouldThrowException()
+    {
+        Inline::parse('"Foo\\"');
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Yaml\Exception\ParseException
+     */
+    public function testParseScalarWithIncorrectlyQuotedStringShouldThrowException()
+    {
+        $value = "'don't do somthin' like that'";
+        Inline::parse($value);
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Yaml\Exception\ParseException
+     */
+    public function testParseScalarWithIncorrectlyDoubleQuotedStringShouldThrowException()
+    {
+        $value = '"don"t do somthin" like that"';
+        Inline::parse($value);
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Yaml\Exception\ParseException
+     */
+    public function testParseInvalidMappingKeyShouldThrowException()
+    {
+        $value = '{ "foo " bar": "bar" }';
+        Inline::parse($value);
+    }
+
+    /**
+     * @group legacy
+     * @expectedDeprecation Using a colon after an unquoted mapping key that is not followed by an indication character (i.e. " ", ",", "[", "]", "{", "}") is deprecated since version 3.2 and will throw a ParseException in 4.0.
+     * throws \Symfony\Component\Yaml\Exception\ParseException in 4.0
+     */
+    public function testParseMappingKeyWithColonNotFollowedBySpace()
+    {
+        Inline::parse('{1:""}');
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Yaml\Exception\ParseException
+     */
+    public function testParseInvalidMappingShouldThrowException()
+    {
+        Inline::parse('[foo] bar');
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Yaml\Exception\ParseException
+     */
+    public function testParseInvalidSequenceShouldThrowException()
+    {
+        Inline::parse('{ foo: bar } bar');
+    }
+
+    public function testParseScalarWithCorrectlyQuotedStringShouldReturnString()
+    {
+        $value = "'don''t do somthin'' like that'";
+        $expect = "don't do somthin' like that";
+
+        $this->assertSame($expect, Inline::parseScalar($value));
+    }
+
+    /**
+     * @dataProvider getDataForParseReferences
+     */
+    public function testParseReferences($yaml, $expected)
+    {
+        $this->assertSame($expected, Inline::parse($yaml, 0, array('var' => 'var-value')));
+    }
+
+    /**
+     * @group legacy
+     * @dataProvider getDataForParseReferences
+     */
+    public function testParseReferencesAsFifthArgument($yaml, $expected)
+    {
+        $this->assertSame($expected, Inline::parse($yaml, false, false, false, array('var' => 'var-value')));
+    }
+
+    public function getDataForParseReferences()
+    {
+        return array(
+            'scalar' => array('*var', 'var-value'),
+            'list' => array('[ *var ]', array('var-value')),
+            'list-in-list' => array('[[ *var ]]', array(array('var-value'))),
+            'map-in-list' => array('[ { key: *var } ]', array(array('key' => 'var-value'))),
+            'embedded-mapping-in-list' => array('[ key: *var ]', array(array('key' => 'var-value'))),
+            'map' => array('{ key: *var }', array('key' => 'var-value')),
+            'list-in-map' => array('{ key: [*var] }', array('key' => array('var-value'))),
+            'map-in-map' => array('{ foo: { bar: *var } }', array('foo' => array('bar' => 'var-value'))),
+        );
+    }
+
+    public function testParseMapReferenceInSequence()
+    {
+        $foo = array(
+            'a' => 'Steve',
+            'b' => 'Clark',
+            'c' => 'Brian',
+        );
+        $this->assertSame(array($foo), Inline::parse('[*foo]', 0, array('foo' => $foo)));
+    }
+
+    /**
+     * @group legacy
+     */
+    public function testParseMapReferenceInSequenceAsFifthArgument()
+    {
+        $foo = array(
+            'a' => 'Steve',
+            'b' => 'Clark',
+            'c' => 'Brian',
+        );
+        $this->assertSame(array($foo), Inline::parse('[*foo]', false, false, false, array('foo' => $foo)));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Yaml\Exception\ParseException
+     * @expectedExceptionMessage A reference must contain at least one character.
+     */
+    public function testParseUnquotedAsterisk()
+    {
+        Inline::parse('{ foo: * }');
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Yaml\Exception\ParseException
+     * @expectedExceptionMessage A reference must contain at least one character.
+     */
+    public function testParseUnquotedAsteriskFollowedByAComment()
+    {
+        Inline::parse('{ foo: * #foo }');
+    }
+
+    /**
+     * @dataProvider getReservedIndicators
+     * @expectedException \Symfony\Component\Yaml\Exception\ParseException
+     * @expectedExceptionMessage cannot start a plain scalar; you need to quote the scalar.
+     */
+    public function testParseUnquotedScalarStartingWithReservedIndicator($indicator)
+    {
+        Inline::parse(sprintf('{ foo: %sfoo }', $indicator));
+    }
+
+    public function getReservedIndicators()
+    {
+        return array(array('@'), array('`'));
+    }
+
+    /**
+     * @dataProvider getScalarIndicators
+     * @expectedException \Symfony\Component\Yaml\Exception\ParseException
+     * @expectedExceptionMessage cannot start a plain scalar; you need to quote the scalar.
+     */
+    public function testParseUnquotedScalarStartingWithScalarIndicator($indicator)
+    {
+        Inline::parse(sprintf('{ foo: %sfoo }', $indicator));
+    }
+
+    public function getScalarIndicators()
+    {
+        return array(array('|'), array('>'));
+    }
+
+    /**
+     * @group legacy
+     * @expectedDeprecation Not quoting the scalar "%bar " starting with the "%" indicator character is deprecated since Symfony 3.1 and will throw a ParseException in 4.0.
+     * throws \Symfony\Component\Yaml\Exception\ParseException in 4.0
+     */
+    public function testParseUnquotedScalarStartingWithPercentCharacter()
+    {
+        Inline::parse('{ foo: %bar }');
+    }
+
+    /**
+     * @dataProvider getDataForIsHash
+     */
+    public function testIsHash($array, $expected)
+    {
+        $this->assertSame($expected, Inline::isHash($array));
+    }
+
+    public function getDataForIsHash()
+    {
+        return array(
+            array(array(), false),
+            array(array(1, 2, 3), false),
+            array(array(2 => 1, 1 => 2, 0 => 3), true),
+            array(array('foo' => 1, 'bar' => 2), true),
+        );
+    }
+
+    public function getTestsForParse()
+    {
+        return array(
+            array('', ''),
+            array('null', null),
+            array('false', false),
+            array('true', true),
+            array('12', 12),
+            array('-12', -12),
+            array('1_2', 12),
+            array('_12', '_12'),
+            array('12_', 12),
+            array('"quoted string"', 'quoted string'),
+            array("'quoted string'", 'quoted string'),
+            array('12.30e+02', 12.30e+02),
+            array('123.45_67', 123.4567),
+            array('0x4D2', 0x4D2),
+            array('0x_4_D_2_', 0x4D2),
+            array('02333', 02333),
+            array('0_2_3_3_3', 02333),
+            array('.Inf', -log(0)),
+            array('-.Inf', log(0)),
+            array("'686e444'", '686e444'),
+            array('686e444', 646e444),
+            array('123456789123456789123456789123456789', '123456789123456789123456789123456789'),
+            array('"foo\r\nbar"', "foo\r\nbar"),
+            array("'foo#bar'", 'foo#bar'),
+            array("'foo # bar'", 'foo # bar'),
+            array("'#cfcfcf'", '#cfcfcf'),
+            array('::form_base.html.twig', '::form_base.html.twig'),
+
+            // Pre-YAML-1.2 booleans
+            array("'y'", 'y'),
+            array("'n'", 'n'),
+            array("'yes'", 'yes'),
+            array("'no'", 'no'),
+            array("'on'", 'on'),
+            array("'off'", 'off'),
+
+            array('2007-10-30', gmmktime(0, 0, 0, 10, 30, 2007)),
+            array('2007-10-30T02:59:43Z', gmmktime(2, 59, 43, 10, 30, 2007)),
+            array('2007-10-30 02:59:43 Z', gmmktime(2, 59, 43, 10, 30, 2007)),
+            array('1960-10-30 02:59:43 Z', gmmktime(2, 59, 43, 10, 30, 1960)),
+            array('1730-10-30T02:59:43Z', gmmktime(2, 59, 43, 10, 30, 1730)),
+
+            array('"a \\"string\\" with \'quoted strings inside\'"', 'a "string" with \'quoted strings inside\''),
+            array("'a \"string\" with ''quoted strings inside'''", 'a "string" with \'quoted strings inside\''),
+
+            // sequences
+            // urls are no key value mapping. see #3609. Valid yaml "key: value" mappings require a space after the colon
+            array('[foo, http://urls.are/no/mappings, false, null, 12]', array('foo', 'http://urls.are/no/mappings', false, null, 12)),
+            array('[  foo  ,   bar , false  ,  null     ,  12  ]', array('foo', 'bar', false, null, 12)),
+            array('[\'foo,bar\', \'foo bar\']', array('foo,bar', 'foo bar')),
+
+            // mappings
+            array('{foo: bar,bar: foo,false: false,null: null,integer: 12}', array('foo' => 'bar', 'bar' => 'foo', 'false' => false, 'null' => null, 'integer' => 12), Yaml::PARSE_KEYS_AS_STRINGS),
+            array('{ foo  : bar, bar : foo,  false  :   false,  null  :   null,  integer :  12  }', array('foo' => 'bar', 'bar' => 'foo', 'false' => false, 'null' => null, 'integer' => 12), Yaml::PARSE_KEYS_AS_STRINGS),
+            array('{foo: \'bar\', bar: \'foo: bar\'}', array('foo' => 'bar', 'bar' => 'foo: bar')),
+            array('{\'foo\': \'bar\', "bar": \'foo: bar\'}', array('foo' => 'bar', 'bar' => 'foo: bar')),
+            array('{\'foo\'\'\': \'bar\', "bar\"": \'foo: bar\'}', array('foo\'' => 'bar', 'bar"' => 'foo: bar')),
+            array('{\'foo: \': \'bar\', "bar: ": \'foo: bar\'}', array('foo: ' => 'bar', 'bar: ' => 'foo: bar')),
+            array('{"foo:bar": "baz"}', array('foo:bar' => 'baz')),
+            array('{"foo":"bar"}', array('foo' => 'bar')),
+
+            // nested sequences and mappings
+            array('[foo, [bar, foo]]', array('foo', array('bar', 'foo'))),
+            array('[foo, {bar: foo}]', array('foo', array('bar' => 'foo'))),
+            array('{ foo: {bar: foo} }', array('foo' => array('bar' => 'foo'))),
+            array('{ foo: [bar, foo] }', array('foo' => array('bar', 'foo'))),
+            array('{ foo:{bar: foo} }', array('foo' => array('bar' => 'foo'))),
+            array('{ foo:[bar, foo] }', array('foo' => array('bar', 'foo'))),
+
+            array('[  foo, [  bar, foo  ]  ]', array('foo', array('bar', 'foo'))),
+
+            array('[{ foo: {bar: foo} }]', array(array('foo' => array('bar' => 'foo')))),
+
+            array('[foo, [bar, [foo, [bar, foo]], foo]]', array('foo', array('bar', array('foo', array('bar', 'foo')), 'foo'))),
+
+            array('[foo, {bar: foo, foo: [foo, {bar: foo}]}, [foo, {bar: foo}]]', array('foo', array('bar' => 'foo', 'foo' => array('foo', array('bar' => 'foo'))), array('foo', array('bar' => 'foo')))),
+
+            array('[foo, bar: { foo: bar }]', array('foo', '1' => array('bar' => array('foo' => 'bar')))),
+            array('[foo, \'@foo.baz\', { \'%foo%\': \'foo is %foo%\', bar: \'%foo%\' }, true, \'@service_container\']', array('foo', '@foo.baz', array('%foo%' => 'foo is %foo%', 'bar' => '%foo%'), true, '@service_container')),
+        );
+    }
+
+    public function getTestsForParseWithMapObjects()
+    {
+        return array(
+            array('', ''),
+            array('null', null),
+            array('false', false),
+            array('true', true),
+            array('12', 12),
+            array('-12', -12),
+            array('"quoted string"', 'quoted string'),
+            array("'quoted string'", 'quoted string'),
+            array('12.30e+02', 12.30e+02),
+            array('0x4D2', 0x4D2),
+            array('02333', 02333),
+            array('.Inf', -log(0)),
+            array('-.Inf', log(0)),
+            array("'686e444'", '686e444'),
+            array('686e444', 646e444),
+            array('123456789123456789123456789123456789', '123456789123456789123456789123456789'),
+            array('"foo\r\nbar"', "foo\r\nbar"),
+            array("'foo#bar'", 'foo#bar'),
+            array("'foo # bar'", 'foo # bar'),
+            array("'#cfcfcf'", '#cfcfcf'),
+            array('::form_base.html.twig', '::form_base.html.twig'),
+
+            array('2007-10-30', gmmktime(0, 0, 0, 10, 30, 2007)),
+            array('2007-10-30T02:59:43Z', gmmktime(2, 59, 43, 10, 30, 2007)),
+            array('2007-10-30 02:59:43 Z', gmmktime(2, 59, 43, 10, 30, 2007)),
+            array('1960-10-30 02:59:43 Z', gmmktime(2, 59, 43, 10, 30, 1960)),
+            array('1730-10-30T02:59:43Z', gmmktime(2, 59, 43, 10, 30, 1730)),
+
+            array('"a \\"string\\" with \'quoted strings inside\'"', 'a "string" with \'quoted strings inside\''),
+            array("'a \"string\" with ''quoted strings inside'''", 'a "string" with \'quoted strings inside\''),
+
+            // sequences
+            // urls are no key value mapping. see #3609. Valid yaml "key: value" mappings require a space after the colon
+            array('[foo, http://urls.are/no/mappings, false, null, 12]', array('foo', 'http://urls.are/no/mappings', false, null, 12)),
+            array('[  foo  ,   bar , false  ,  null     ,  12  ]', array('foo', 'bar', false, null, 12)),
+            array('[\'foo,bar\', \'foo bar\']', array('foo,bar', 'foo bar')),
+
+            // mappings
+            array('{foo: bar,bar: foo,false: false,null: null,integer: 12}', (object) array('foo' => 'bar', 'bar' => 'foo', 'false' => false, 'null' => null, 'integer' => 12), Yaml::PARSE_OBJECT_FOR_MAP | Yaml::PARSE_KEYS_AS_STRINGS),
+            array('{ foo  : bar, bar : foo,  false  :   false,  null  :   null,  integer :  12  }', (object) array('foo' => 'bar', 'bar' => 'foo', 'false' => false, 'null' => null, 'integer' => 12), Yaml::PARSE_OBJECT_FOR_MAP | Yaml::PARSE_KEYS_AS_STRINGS),
+            array('{foo: \'bar\', bar: \'foo: bar\'}', (object) array('foo' => 'bar', 'bar' => 'foo: bar')),
+            array('{\'foo\': \'bar\', "bar": \'foo: bar\'}', (object) array('foo' => 'bar', 'bar' => 'foo: bar')),
+            array('{\'foo\'\'\': \'bar\', "bar\"": \'foo: bar\'}', (object) array('foo\'' => 'bar', 'bar"' => 'foo: bar')),
+            array('{\'foo: \': \'bar\', "bar: ": \'foo: bar\'}', (object) array('foo: ' => 'bar', 'bar: ' => 'foo: bar')),
+            array('{"foo:bar": "baz"}', (object) array('foo:bar' => 'baz')),
+            array('{"foo":"bar"}', (object) array('foo' => 'bar')),
+
+            // nested sequences and mappings
+            array('[foo, [bar, foo]]', array('foo', array('bar', 'foo'))),
+            array('[foo, {bar: foo}]', array('foo', (object) array('bar' => 'foo'))),
+            array('{ foo: {bar: foo} }', (object) array('foo' => (object) array('bar' => 'foo'))),
+            array('{ foo: [bar, foo] }', (object) array('foo' => array('bar', 'foo'))),
+
+            array('[  foo, [  bar, foo  ]  ]', array('foo', array('bar', 'foo'))),
+
+            array('[{ foo: {bar: foo} }]', array((object) array('foo' => (object) array('bar' => 'foo')))),
+
+            array('[foo, [bar, [foo, [bar, foo]], foo]]', array('foo', array('bar', array('foo', array('bar', 'foo')), 'foo'))),
+
+            array('[foo, {bar: foo, foo: [foo, {bar: foo}]}, [foo, {bar: foo}]]', array('foo', (object) array('bar' => 'foo', 'foo' => array('foo', (object) array('bar' => 'foo'))), array('foo', (object) array('bar' => 'foo')))),
+
+            array('[foo, bar: { foo: bar }]', array('foo', '1' => (object) array('bar' => (object) array('foo' => 'bar')))),
+            array('[foo, \'@foo.baz\', { \'%foo%\': \'foo is %foo%\', bar: \'%foo%\' }, true, \'@service_container\']', array('foo', '@foo.baz', (object) array('%foo%' => 'foo is %foo%', 'bar' => '%foo%'), true, '@service_container')),
+
+            array('{}', new \stdClass()),
+            array('{ foo  : bar, bar : {}  }', (object) array('foo' => 'bar', 'bar' => new \stdClass())),
+            array('{ foo  : [], bar : {}  }', (object) array('foo' => array(), 'bar' => new \stdClass())),
+            array('{foo: \'bar\', bar: {} }', (object) array('foo' => 'bar', 'bar' => new \stdClass())),
+            array('{\'foo\': \'bar\', "bar": {}}', (object) array('foo' => 'bar', 'bar' => new \stdClass())),
+            array('{\'foo\': \'bar\', "bar": \'{}\'}', (object) array('foo' => 'bar', 'bar' => '{}')),
+
+            array('[foo, [{}, {}]]', array('foo', array(new \stdClass(), new \stdClass()))),
+            array('[foo, [[], {}]]', array('foo', array(array(), new \stdClass()))),
+            array('[foo, [[{}, {}], {}]]', array('foo', array(array(new \stdClass(), new \stdClass()), new \stdClass()))),
+            array('[foo, {bar: {}}]', array('foo', '1' => (object) array('bar' => new \stdClass()))),
+        );
+    }
+
+    public function getTestsForDump()
+    {
+        return array(
+            array('null', null),
+            array('false', false),
+            array('true', true),
+            array('12', 12),
+            array("'1_2'", '1_2'),
+            array('_12', '_12'),
+            array("'12_'", '12_'),
+            array("'quoted string'", 'quoted string'),
+            array('!!float 1230', 12.30e+02),
+            array('1234', 0x4D2),
+            array('1243', 02333),
+            array("'0x_4_D_2_'", '0x_4_D_2_'),
+            array("'0_2_3_3_3'", '0_2_3_3_3'),
+            array('.Inf', -log(0)),
+            array('-.Inf', log(0)),
+            array("'686e444'", '686e444'),
+            array('"foo\r\nbar"', "foo\r\nbar"),
+            array("'foo#bar'", 'foo#bar'),
+            array("'foo # bar'", 'foo # bar'),
+            array("'#cfcfcf'", '#cfcfcf'),
+
+            array("'a \"string\" with ''quoted strings inside'''", 'a "string" with \'quoted strings inside\''),
+
+            array("'-dash'", '-dash'),
+            array("'-'", '-'),
+
+            // Pre-YAML-1.2 booleans
+            array("'y'", 'y'),
+            array("'n'", 'n'),
+            array("'yes'", 'yes'),
+            array("'no'", 'no'),
+            array("'on'", 'on'),
+            array("'off'", 'off'),
+
+            // sequences
+            array('[foo, bar, false, null, 12]', array('foo', 'bar', false, null, 12)),
+            array('[\'foo,bar\', \'foo bar\']', array('foo,bar', 'foo bar')),
+
+            // mappings
+            array('{ foo: bar, bar: foo, \'false\': false, \'null\': null, integer: 12 }', array('foo' => 'bar', 'bar' => 'foo', 'false' => false, 'null' => null, 'integer' => 12), Yaml::PARSE_KEYS_AS_STRINGS),
+            array('{ foo: bar, bar: \'foo: bar\' }', array('foo' => 'bar', 'bar' => 'foo: bar')),
+
+            // nested sequences and mappings
+            array('[foo, [bar, foo]]', array('foo', array('bar', 'foo'))),
+
+            array('[foo, [bar, [foo, [bar, foo]], foo]]', array('foo', array('bar', array('foo', array('bar', 'foo')), 'foo'))),
+
+            array('{ foo: { bar: foo } }', array('foo' => array('bar' => 'foo'))),
+
+            array('[foo, { bar: foo }]', array('foo', array('bar' => 'foo'))),
+
+            array('[foo, { bar: foo, foo: [foo, { bar: foo }] }, [foo, { bar: foo }]]', array('foo', array('bar' => 'foo', 'foo' => array('foo', array('bar' => 'foo'))), array('foo', array('bar' => 'foo')))),
+
+            array('[foo, \'@foo.baz\', { \'%foo%\': \'foo is %foo%\', bar: \'%foo%\' }, true, \'@service_container\']', array('foo', '@foo.baz', array('%foo%' => 'foo is %foo%', 'bar' => '%foo%'), true, '@service_container')),
+
+            array('{ foo: { bar: { 1: 2, baz: 3 } } }', array('foo' => array('bar' => array(1 => 2, 'baz' => 3))), Yaml::PARSE_KEYS_AS_STRINGS),
+        );
+    }
+
+    /**
+     * @dataProvider getTimestampTests
+     */
+    public function testParseTimestampAsUnixTimestampByDefault($yaml, $year, $month, $day, $hour, $minute, $second)
+    {
+        $this->assertSame(gmmktime($hour, $minute, $second, $month, $day, $year), Inline::parse($yaml));
+    }
+
+    /**
+     * @dataProvider getTimestampTests
+     */
+    public function testParseTimestampAsDateTimeObject($yaml, $year, $month, $day, $hour, $minute, $second, $timezone)
+    {
+        $expected = new \DateTime($yaml);
+        $expected->setTimeZone(new \DateTimeZone('UTC'));
+        $expected->setDate($year, $month, $day);
+
+        if (\PHP_VERSION_ID >= 70100) {
+            $expected->setTime($hour, $minute, $second, 1000000 * ($second - (int) $second));
+        } else {
+            $expected->setTime($hour, $minute, $second);
+        }
+
+        $date = Inline::parse($yaml, Yaml::PARSE_DATETIME);
+        $this->assertEquals($expected, $date);
+        $this->assertSame($timezone, $date->format('O'));
+    }
+
+    public function getTimestampTests()
+    {
+        return array(
+            'canonical' => array('2001-12-15T02:59:43.1Z', 2001, 12, 15, 2, 59, 43.1, '+0000'),
+            'ISO-8601' => array('2001-12-15t21:59:43.10-05:00', 2001, 12, 16, 2, 59, 43.1, '-0500'),
+            'spaced' => array('2001-12-15 21:59:43.10 -5', 2001, 12, 16, 2, 59, 43.1, '-0500'),
+            'date' => array('2001-12-15', 2001, 12, 15, 0, 0, 0, '+0000'),
+        );
+    }
+
+    /**
+     * @dataProvider getTimestampTests
+     */
+    public function testParseNestedTimestampListAsDateTimeObject($yaml, $year, $month, $day, $hour, $minute, $second)
+    {
+        $expected = new \DateTime($yaml);
+        $expected->setTimeZone(new \DateTimeZone('UTC'));
+        $expected->setDate($year, $month, $day);
+        if (\PHP_VERSION_ID >= 70100) {
+            $expected->setTime($hour, $minute, $second, 1000000 * ($second - (int) $second));
+        } else {
+            $expected->setTime($hour, $minute, $second);
+        }
+
+        $expectedNested = array('nested' => array($expected));
+        $yamlNested = "{nested: [$yaml]}";
+
+        $this->assertEquals($expectedNested, Inline::parse($yamlNested, Yaml::PARSE_DATETIME));
+    }
+
+    /**
+     * @dataProvider getDateTimeDumpTests
+     */
+    public function testDumpDateTime($dateTime, $expected)
+    {
+        $this->assertSame($expected, Inline::dump($dateTime));
+    }
+
+    public function getDateTimeDumpTests()
+    {
+        $tests = array();
+
+        $dateTime = new \DateTime('2001-12-15 21:59:43', new \DateTimeZone('UTC'));
+        $tests['date-time-utc'] = array($dateTime, '2001-12-15T21:59:43+00:00');
+
+        $dateTime = new \DateTimeImmutable('2001-07-15 21:59:43', new \DateTimeZone('Europe/Berlin'));
+        $tests['immutable-date-time-europe-berlin'] = array($dateTime, '2001-07-15T21:59:43+02:00');
+
+        return $tests;
+    }
+
+    /**
+     * @dataProvider getBinaryData
+     */
+    public function testParseBinaryData($data)
+    {
+        $this->assertSame('Hello world', Inline::parse($data));
+    }
+
+    public function getBinaryData()
+    {
+        return array(
+            'enclosed with double quotes' => array('!!binary "SGVsbG8gd29ybGQ="'),
+            'enclosed with single quotes' => array("!!binary 'SGVsbG8gd29ybGQ='"),
+            'containing spaces' => array('!!binary  "SGVs bG8gd 29ybGQ="'),
+        );
+    }
+
+    /**
+     * @dataProvider getInvalidBinaryData
+     * @expectedException \Symfony\Component\Yaml\Exception\ParseException
+     */
+    public function testParseInvalidBinaryData($data, $expectedMessage)
+    {
+        if (method_exists($this, 'expectException')) {
+            $this->expectExceptionMessageRegExp($expectedMessage);
+        } else {
+            $this->setExpectedExceptionRegExp(ParseException::class, $expectedMessage);
+        }
+
+        Inline::parse($data);
+    }
+
+    public function getInvalidBinaryData()
+    {
+        return array(
+            'length not a multiple of four' => array('!!binary "SGVsbG8d29ybGQ="', '/The normalized base64 encoded data \(data without whitespace characters\) length must be a multiple of four \(\d+ bytes given\)/'),
+            'invalid characters' => array('!!binary "SGVsbG8#d29ybGQ="', '/The base64 encoded data \(.*\) contains invalid characters/'),
+            'too many equals characters' => array('!!binary "SGVsbG8gd29yb==="', '/The base64 encoded data \(.*\) contains invalid characters/'),
+            'misplaced equals character' => array('!!binary "SGVsbG8gd29ybG=Q"', '/The base64 encoded data \(.*\) contains invalid characters/'),
+        );
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Yaml\Exception\ParseException
+     * @expectedExceptionMessage Malformed inline YAML string: {this, is not, supported}.
+     */
+    public function testNotSupportedMissingValue()
+    {
+        Inline::parse('{this, is not, supported}');
+    }
+
+    public function testVeryLongQuotedStrings()
+    {
+        $longStringWithQuotes = str_repeat("x\r\n\\\"x\"x", 1000);
+
+        $yamlString = Inline::dump(array('longStringWithQuotes' => $longStringWithQuotes));
+        $arrayFromYaml = Inline::parse($yamlString);
+
+        $this->assertEquals($longStringWithQuotes, $arrayFromYaml['longStringWithQuotes']);
+    }
+
+    /**
+     * @group legacy
+     * @expectedDeprecation Omitting the key of a mapping is deprecated and will throw a ParseException in 4.0.
+     */
+    public function testOmittedMappingKeyIsParsedAsColon()
+    {
+        $this->assertSame(array(':' => 'foo'), Inline::parse('{: foo}'));
+    }
+
+    /**
+     * @dataProvider getTestsForNullValues
+     */
+    public function testParseMissingMappingValueAsNull($yaml, $expected)
+    {
+        $this->assertSame($expected, Inline::parse($yaml));
+    }
+
+    public function getTestsForNullValues()
+    {
+        return array(
+            'null before closing curly brace' => array('{foo:}', array('foo' => null)),
+            'null before comma' => array('{foo:, bar: baz}', array('foo' => null, 'bar' => 'baz')),
+        );
+    }
+
+    public function testTheEmptyStringIsAValidMappingKey()
+    {
+        $this->assertSame(array('' => 'foo'), Inline::parse('{ "": foo }'));
+    }
+
+    /**
+     * @group legacy
+     * @expectedDeprecation Implicit casting of incompatible mapping keys to strings is deprecated since version 3.3 and will throw \Symfony\Component\Yaml\Exception\ParseException in 4.0. Quote your evaluable mapping keys instead.
+     * @dataProvider getNotPhpCompatibleMappingKeyData
+     */
+    public function testImplicitStringCastingOfMappingKeysIsDeprecated($yaml, $expected)
+    {
+        $this->assertSame($expected, Inline::parse($yaml));
+    }
+
+    /**
+     * @dataProvider getNotPhpCompatibleMappingKeyData
+     */
+    public function testExplicitStringCastingOfMappingKeys($yaml, $expected)
+    {
+        $this->assertSame($expected, Inline::parse($yaml, Yaml::PARSE_KEYS_AS_STRINGS));
+    }
+
+    public function getNotPhpCompatibleMappingKeyData()
+    {
+        return array(
+            'boolean-true' => array('{true: "foo"}', array('true' => 'foo')),
+            'boolean-false' => array('{false: "foo"}', array('false' => 'foo')),
+            'null' => array('{null: "foo"}', array('null' => 'foo')),
+            'float' => array('{0.25: "foo"}', array('0.25' => 'foo')),
+        );
+    }
+}

html2pdf-master/vendor/symfony/yaml/Tests/ParseExceptionTest.php

@@ -0,0 +1,34 @@
+<?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 Symfony\Component\Yaml\Tests;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Yaml\Exception\ParseException;
+
+class ParseExceptionTest extends TestCase
+{
+    public function testGetMessage()
+    {
+        $exception = new ParseException('Error message', 42, 'foo: bar', '/var/www/app/config.yml');
+        $message = 'Error message in "/var/www/app/config.yml" at line 42 (near "foo: bar")';
+
+        $this->assertEquals($message, $exception->getMessage());
+    }
+
+    public function testGetMessageWithUnicodeInFilename()
+    {
+        $exception = new ParseException('Error message', 42, 'foo: bar', 'äöü.yml');
+        $message = 'Error message in "äöü.yml" at line 42 (near "foo: bar")';
+
+        $this->assertEquals($message, $exception->getMessage());
+    }
+}

html2pdf-master/vendor/symfony/yaml/Tests/YamlTest.php

@@ -0,0 +1,44 @@
+<?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 Symfony\Component\Yaml\Tests;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Yaml\Yaml;
+
+class YamlTest extends TestCase
+{
+    public function testParseAndDump()
+    {
+        $data = array('lorem' => 'ipsum', 'dolor' => 'sit');
+        $yml = Yaml::dump($data);
+        $parsed = Yaml::parse($yml);
+        $this->assertEquals($data, $parsed);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage The indentation must be greater than zero
+     */
+    public function testZeroIndentationThrowsException()
+    {
+        Yaml::dump(array('lorem' => 'ipsum', 'dolor' => 'sit'), 2, 0);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage The indentation must be greater than zero
+     */
+    public function testNegativeIndentationThrowsException()
+    {
+        Yaml::dump(array('lorem' => 'ipsum', 'dolor' => 'sit'), 2, -4);
+    }
+}

html2pdf-master/vendor/symfony/yaml/Unescaper.php

@@ -0,0 +1,142 @@
+<?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 Symfony\Component\Yaml;
+
+use Symfony\Component\Yaml\Exception\ParseException;
+
+/**
+ * Unescaper encapsulates unescaping rules for single and double-quoted
+ * YAML strings.
+ *
+ * @author Matthew Lewinski <matthew@lewinski.org>
+ *
+ * @internal
+ */
+class Unescaper
+{
+    /**
+     * Regex fragment that matches an escaped character in a double quoted string.
+     */
+    const REGEX_ESCAPED_CHARACTER = '\\\\(x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8}|.)';
+
+    /**
+     * Unescapes a single quoted string.
+     *
+     * @param string $value A single quoted string
+     *
+     * @return string The unescaped string
+     */
+    public function unescapeSingleQuotedString($value)
+    {
+        return str_replace('\'\'', '\'', $value);
+    }
+
+    /**
+     * Unescapes a double quoted string.
+     *
+     * @param string $value A double quoted string
+     *
+     * @return string The unescaped string
+     */
+    public function unescapeDoubleQuotedString($value)
+    {
+        $callback = function ($match) {
+            return $this->unescapeCharacter($match[0]);
+        };
+
+        // evaluate the string
+        return preg_replace_callback('/'.self::REGEX_ESCAPED_CHARACTER.'/u', $callback, $value);
+    }
+
+    /**
+     * Unescapes a character that was found in a double-quoted string.
+     *
+     * @param string $value An escaped character
+     *
+     * @return string The unescaped character
+     */
+    private function unescapeCharacter($value)
+    {
+        switch ($value[1]) {
+            case '0':
+                return "\x0";
+            case 'a':
+                return "\x7";
+            case 'b':
+                return "\x8";
+            case 't':
+                return "\t";
+            case "\t":
+                return "\t";
+            case 'n':
+                return "\n";
+            case 'v':
+                return "\xB";
+            case 'f':
+                return "\xC";
+            case 'r':
+                return "\r";
+            case 'e':
+                return "\x1B";
+            case ' ':
+                return ' ';
+            case '"':
+                return '"';
+            case '/':
+                return '/';
+            case '\\':
+                return '\\';
+            case 'N':
+                // U+0085 NEXT LINE
+                return "\xC2\x85";
+            case '_':
+                // U+00A0 NO-BREAK SPACE
+                return "\xC2\xA0";
+            case 'L':
+                // U+2028 LINE SEPARATOR
+                return "\xE2\x80\xA8";
+            case 'P':
+                // U+2029 PARAGRAPH SEPARATOR
+                return "\xE2\x80\xA9";
+            case 'x':
+                return self::utf8chr(hexdec(substr($value, 2, 2)));
+            case 'u':
+                return self::utf8chr(hexdec(substr($value, 2, 4)));
+            case 'U':
+                return self::utf8chr(hexdec(substr($value, 2, 8)));
+            default:
+                throw new ParseException(sprintf('Found unknown escape character "%s".', $value));
+        }
+    }
+
+    /**
+     * Get the UTF-8 character for the given code point.
+     *
+     * @param int $c The unicode code point
+     *
+     * @return string The corresponding UTF-8 character
+     */
+    private static function utf8chr($c)
+    {
+        if (0x80 > $c %= 0x200000) {
+            return chr($c);
+        }
+        if (0x800 > $c) {
+            return chr(0xC0 | $c >> 6).chr(0x80 | $c & 0x3F);
+        }
+        if (0x10000 > $c) {
+            return chr(0xE0 | $c >> 12).chr(0x80 | $c >> 6 & 0x3F).chr(0x80 | $c & 0x3F);
+        }
+
+        return chr(0xF0 | $c >> 18).chr(0x80 | $c >> 12 & 0x3F).chr(0x80 | $c >> 6 & 0x3F).chr(0x80 | $c & 0x3F);
+    }
+}

html2pdf-master/vendor/symfony/yaml/Yaml.php

@@ -0,0 +1,122 @@
+<?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 Symfony\Component\Yaml;
+
+use Symfony\Component\Yaml\Exception\ParseException;
+
+/**
+ * Yaml offers convenience methods to load and dump YAML.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class Yaml
+{
+    const DUMP_OBJECT = 1;
+    const PARSE_EXCEPTION_ON_INVALID_TYPE = 2;
+    const PARSE_OBJECT = 4;
+    const PARSE_OBJECT_FOR_MAP = 8;
+    const DUMP_EXCEPTION_ON_INVALID_TYPE = 16;
+    const PARSE_DATETIME = 32;
+    const DUMP_OBJECT_AS_MAP = 64;
+    const DUMP_MULTI_LINE_LITERAL_BLOCK = 128;
+    const PARSE_CONSTANT = 256;
+    const PARSE_CUSTOM_TAGS = 512;
+    const DUMP_EMPTY_ARRAY_AS_SEQUENCE = 1024;
+    const PARSE_KEYS_AS_STRINGS = 2048;
+
+    /**
+     * Parses YAML into a PHP value.
+     *
+     *  Usage:
+     *  <code>
+     *   $array = Yaml::parse(file_get_contents('config.yml'));
+     *   print_r($array);
+     *  </code>
+     *
+     * @param string $input A string containing YAML
+     * @param int    $flags A bit field of PARSE_* constants to customize the YAML parser behavior
+     *
+     * @return mixed The YAML converted to a PHP value
+     *
+     * @throws ParseException If the YAML is not valid
+     */
+    public static function parse($input, $flags = 0)
+    {
+        if (is_bool($flags)) {
+            @trigger_error('Passing a boolean flag to toggle exception handling is deprecated since version 3.1 and will be removed in 4.0. Use the PARSE_EXCEPTION_ON_INVALID_TYPE flag instead.', E_USER_DEPRECATED);
+
+            if ($flags) {
+                $flags = self::PARSE_EXCEPTION_ON_INVALID_TYPE;
+            } else {
+                $flags = 0;
+            }
+        }
+
+        if (func_num_args() >= 3) {
+            @trigger_error('Passing a boolean flag to toggle object support is deprecated since version 3.1 and will be removed in 4.0. Use the PARSE_OBJECT flag instead.', E_USER_DEPRECATED);
+
+            if (func_get_arg(2)) {
+                $flags |= self::PARSE_OBJECT;
+            }
+        }
+
+        if (func_num_args() >= 4) {
+            @trigger_error('Passing a boolean flag to toggle object for map support is deprecated since version 3.1 and will be removed in 4.0. Use the Yaml::PARSE_OBJECT_FOR_MAP flag instead.', E_USER_DEPRECATED);
+
+            if (func_get_arg(3)) {
+                $flags |= self::PARSE_OBJECT_FOR_MAP;
+            }
+        }
+
+        $yaml = new Parser();
+
+        return $yaml->parse($input, $flags);
+    }
+
+    /**
+     * Dumps a PHP value to a YAML string.
+     *
+     * The dump method, when supplied with an array, will do its best
+     * to convert the array into friendly YAML.
+     *
+     * @param mixed $input  The PHP value
+     * @param int   $inline The level where you switch to inline YAML
+     * @param int   $indent The amount of spaces to use for indentation of nested nodes
+     * @param int   $flags  A bit field of DUMP_* constants to customize the dumped YAML string
+     *
+     * @return string A YAML string representing the original PHP value
+     */
+    public static function dump($input, $inline = 2, $indent = 4, $flags = 0)
+    {
+        if (is_bool($flags)) {
+            @trigger_error('Passing a boolean flag to toggle exception handling is deprecated since version 3.1 and will be removed in 4.0. Use the DUMP_EXCEPTION_ON_INVALID_TYPE flag instead.', E_USER_DEPRECATED);
+
+            if ($flags) {
+                $flags = self::DUMP_EXCEPTION_ON_INVALID_TYPE;
+            } else {
+                $flags = 0;
+            }
+        }
+
+        if (func_num_args() >= 5) {
+            @trigger_error('Passing a boolean flag to toggle object support is deprecated since version 3.1 and will be removed in 4.0. Use the DUMP_OBJECT flag instead.', E_USER_DEPRECATED);
+
+            if (func_get_arg(4)) {
+                $flags |= self::DUMP_OBJECT;
+            }
+        }
+
+        $yaml = new Dumper($indent);
+
+        return $yaml->dump($input, $inline, 0, $flags);
+    }
+}

html2pdf-master/vendor/symfony/yaml/composer.json

@@ -0,0 +1,39 @@
+{
+    "name": "symfony/yaml",
+    "type": "library",
+    "description": "Symfony Yaml Component",
+    "keywords": [],
+    "homepage": "https://symfony.com",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Fabien Potencier",
+            "email": "fabien@symfony.com"
+        },
+        {
+            "name": "Symfony Community",
+            "homepage": "https://symfony.com/contributors"
+        }
+    ],
+    "require": {
+        "php": ">=5.5.9"
+    },
+    "require-dev": {
+        "symfony/console": "~2.8|~3.0"
+    },
+    "suggest": {
+        "symfony/console": "For validating YAML files using the lint command"
+    },
+    "autoload": {
+        "psr-4": { "Symfony\\Component\\Yaml\\": "" },
+        "exclude-from-classmap": [
+            "/Tests/"
+        ]
+    },
+    "minimum-stability": "dev",
+    "extra": {
+        "branch-alias": {
+            "dev-master": "3.3-dev"
+        }
+    }
+}

html2pdf-master/vendor/symfony/yaml/phpunit.xml.dist

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:noNamespaceSchemaLocation="http://schema.phpunit.de/4.1/phpunit.xsd"
+         backupGlobals="false"
+         colors="true"
+         bootstrap="vendor/autoload.php"
+         failOnRisky="true"
+         failOnWarning="true"
+>
+    <php>
+        <ini name="error_reporting" value="-1" />
+    </php>
+
+    <testsuites>
+        <testsuite name="Symfony Yaml Component Test Suite">
+            <directory>./Tests/</directory>
+        </testsuite>
+    </testsuites>
+
+    <filter>
+        <whitelist>
+            <directory>./</directory>
+            <exclude>
+                <directory>./Tests</directory>
+                <directory>./vendor</directory>
+            </exclude>
+        </whitelist>
+    </filter>
+</phpunit>