+
+ 1
+
+
+ 2
+
+
+XML;
+
+$doc = new DOMDocument;
+$doc->loadXML($xml);
+assertThat($doc, hasXPath("book", 2));
+```
+
diff --git a/vendor/hamcrest/hamcrest-php/composer.json b/vendor/hamcrest/hamcrest-php/composer.json
new file mode 100644
index 0000000..ddffd19
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/composer.json
@@ -0,0 +1,37 @@
+{
+ "name": "hamcrest/hamcrest-php",
+ "type": "library",
+ "description": "This is the PHP port of Hamcrest Matchers",
+ "keywords": ["test"],
+ "license": "BSD-3-Clause",
+ "authors": [
+ ],
+
+ "autoload": {
+ "classmap": ["hamcrest"]
+ },
+ "autoload-dev": {
+ "classmap": ["tests", "generator"]
+ },
+
+ "require": {
+ "php": "^7.4|^8.0"
+ },
+
+ "require-dev": {
+ "phpunit/php-file-iterator": "^1.4 || ^2.0 || ^3.0",
+ "phpunit/phpunit": "^4.8.36 || ^5.7 || ^6.5 || ^7.0 || ^8.0 || ^9.0"
+ },
+
+ "replace": {
+ "kodova/hamcrest-php": "*",
+ "davedevelopment/hamcrest-php": "*",
+ "cordoval/hamcrest-php": "*"
+ },
+
+ "extra": {
+ "branch-alias": {
+ "dev-master": "2.1-dev"
+ }
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/generator/FactoryCall.php b/vendor/hamcrest/hamcrest-php/generator/FactoryCall.php
new file mode 100644
index 0000000..83965b2
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/generator/FactoryCall.php
@@ -0,0 +1,41 @@
+method = $method;
+ $this->name = $name;
+ }
+
+ public function getMethod()
+ {
+ return $this->method;
+ }
+
+ public function getName()
+ {
+ return $this->name;
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/generator/FactoryClass.php b/vendor/hamcrest/hamcrest-php/generator/FactoryClass.php
new file mode 100644
index 0000000..a09cb73
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/generator/FactoryClass.php
@@ -0,0 +1,71 @@
+file = $file;
+ $this->reflector = $class;
+ $this->extractFactoryMethods();
+ }
+
+ public function extractFactoryMethods()
+ {
+ $this->methods = array();
+ foreach ($this->getPublicStaticMethods() as $method) {
+ if ($method->isFactory()) {
+ $this->methods[] = $method;
+ }
+ }
+ }
+
+ public function getPublicStaticMethods()
+ {
+ $methods = array();
+ foreach ($this->reflector->getMethods(ReflectionMethod::IS_STATIC) as $method) {
+ if ($method->isPublic() && $method->getDeclaringClass() == $this->reflector) {
+ $methods[] = new FactoryMethod($this, $method);
+ }
+ }
+ return $methods;
+ }
+
+ public function getFile()
+ {
+ return $this->file;
+ }
+
+ public function getName()
+ {
+ return $this->reflector->name;
+ }
+
+ public function isFactory()
+ {
+ return !empty($this->methods);
+ }
+
+ public function getMethods()
+ {
+ return $this->methods;
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/generator/FactoryFile.php b/vendor/hamcrest/hamcrest-php/generator/FactoryFile.php
new file mode 100644
index 0000000..dd6109b
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/generator/FactoryFile.php
@@ -0,0 +1,121 @@
+file = $file;
+ $this->indent = $indent;
+ }
+
+ abstract public function addCall(FactoryCall $call);
+
+ abstract public function build();
+
+ public function addFileHeader()
+ {
+ $this->code = '';
+ $this->addPart('file_header');
+ }
+
+ public function addPart($name)
+ {
+ $this->addCode($this->readPart($name));
+ }
+
+ public function addCode($code)
+ {
+ $this->code .= $code;
+ }
+
+ public function readPart($name)
+ {
+ return file_get_contents(__DIR__ . "/parts/$name.txt");
+ }
+
+ public function generateFactoryCall(FactoryCall $call)
+ {
+ $method = $call->getMethod();
+ $code = $method->getComment($this->indent) . "\n";
+ $code .= $this->generateDeclaration($call->getName(), $method);
+ $code .= $this->generateCall($method);
+ $code .= $this->generateClosing();
+ return $code;
+ }
+
+ public function generateDeclaration($name, FactoryMethod $method)
+ {
+ $code = $this->indent . $this->getDeclarationModifiers()
+ . 'function ' . $name . '('
+ . $this->generateDeclarationArguments($method)
+ . ')' . "\n" . $this->indent . '{' . "\n";
+ return $code;
+ }
+
+ public function getDeclarationModifiers()
+ {
+ return '';
+ }
+
+ public function generateDeclarationArguments(FactoryMethod $method)
+ {
+ if ($method->acceptsVariableArguments()) {
+ return '/* args... */';
+ } else {
+ return $method->getParameterDeclarations();
+ }
+ }
+
+ public function generateImport(FactoryMethod $method)
+ {
+ return $this->indent . self::INDENT . "require_once '" . $method->getClass()->getFile() . "';" . "\n";
+ }
+
+ public function generateCall(FactoryMethod $method)
+ {
+ $code = '';
+ if ($method->acceptsVariableArguments()) {
+ $code .= $this->indent . self::INDENT . '$args = func_get_args();' . "\n";
+ }
+
+ $code .= $this->indent . self::INDENT . 'return ';
+ if ($method->acceptsVariableArguments()) {
+ $code .= 'call_user_func_array(array(\''
+ . '\\' . $method->getClassName() . '\', \''
+ . $method->getName() . '\'), $args);' . "\n";
+ } else {
+ $code .= '\\' . $method->getClassName() . '::'
+ . $method->getName() . '('
+ . $method->getParameterInvocations() . ');' . "\n";
+ }
+
+ return $code;
+ }
+
+ public function generateClosing()
+ {
+ return $this->indent . '}' . "\n";
+ }
+
+ public function write()
+ {
+ file_put_contents($this->file, $this->code);
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/generator/FactoryGenerator.php b/vendor/hamcrest/hamcrest-php/generator/FactoryGenerator.php
new file mode 100644
index 0000000..242875a
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/generator/FactoryGenerator.php
@@ -0,0 +1,124 @@
+path = $path;
+ $this->factoryFiles = array();
+ }
+
+ public function addFactoryFile(FactoryFile $factoryFile)
+ {
+ $this->factoryFiles[] = $factoryFile;
+ }
+
+ public function generate()
+ {
+ $classes = $this->getClassesWithFactoryMethods();
+ foreach ($classes as $class) {
+ foreach ($class->getMethods() as $method) {
+ foreach ($method->getCalls() as $call) {
+ foreach ($this->factoryFiles as $file) {
+ $file->addCall($call);
+ }
+ }
+ }
+ }
+ }
+
+ public function write()
+ {
+ foreach ($this->factoryFiles as $file) {
+ $file->build();
+ $file->write();
+ }
+ }
+
+ public function getClassesWithFactoryMethods()
+ {
+ $classes = array();
+ $files = $this->getSortedFiles();
+ foreach ($files as $file) {
+ $class = $this->getFactoryClass($file);
+ if ($class !== null) {
+ $classes[] = $class;
+ }
+ }
+
+ return $classes;
+ }
+
+ public function getSortedFiles()
+ {
+ $iter = $this->getFileIterator();
+ $files = array();
+ foreach ($iter as $file) {
+ $files[] = $file;
+ }
+ sort($files, SORT_STRING);
+
+ return $files;
+ }
+
+ private function getFileIterator()
+ {
+ $factoryClass = class_exists('File_Iterator_Factory') ? 'File_Iterator_Factory' : 'SebastianBergmann\FileIterator\Factory';
+
+ $factory = new $factoryClass();
+
+ return $factory->getFileIterator($this->path, '.php');
+ }
+
+ public function getFactoryClass($file)
+ {
+ $name = $this->getFactoryClassName($file);
+ if ($name !== null) {
+ require_once $file;
+
+ if (class_exists($name)) {
+ $class = new FactoryClass(substr($file, strpos($file, 'Hamcrest/')), new ReflectionClass($name));
+ if ($class->isFactory()) {
+ return $class;
+ }
+ }
+ }
+
+ return null;
+ }
+
+ public function getFactoryClassName($file)
+ {
+ $content = file_get_contents($file);
+ if (preg_match('/namespace\s+(.+);/', $content, $namespace)
+ && preg_match('/\n\s*class\s+(\w+)\s+extends\b/', $content, $className)
+ && preg_match('/@factory\b/', $content)
+ ) {
+ return $namespace[1] . '\\' . $className[1];
+ }
+
+ return null;
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/generator/FactoryMethod.php b/vendor/hamcrest/hamcrest-php/generator/FactoryMethod.php
new file mode 100644
index 0000000..8a05371
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/generator/FactoryMethod.php
@@ -0,0 +1,231 @@
+class = $class;
+ $this->reflector = $reflector;
+ $this->extractCommentWithoutLeadingShashesAndStars();
+ $this->extractFactoryNamesFromComment();
+ $this->extractParameters();
+ }
+
+ public function extractCommentWithoutLeadingShashesAndStars()
+ {
+ $this->comment = explode("\n", $this->reflector->getDocComment());
+ foreach ($this->comment as &$line) {
+ $line = preg_replace('#^\s*(/\\*+|\\*+/|\\*)\s?#', '', $line);
+ }
+ $this->trimLeadingBlankLinesFromComment();
+ $this->trimTrailingBlankLinesFromComment();
+ }
+
+ public function trimLeadingBlankLinesFromComment()
+ {
+ while (count($this->comment) > 0) {
+ $line = array_shift($this->comment);
+ if (trim($line) != '') {
+ array_unshift($this->comment, $line);
+ break;
+ }
+ }
+ }
+
+ public function trimTrailingBlankLinesFromComment()
+ {
+ while (count($this->comment) > 0) {
+ $line = array_pop($this->comment);
+ if (trim($line) != '') {
+ array_push($this->comment, $line);
+ break;
+ }
+ }
+ }
+
+ public function extractFactoryNamesFromComment()
+ {
+ $this->calls = array();
+ for ($i = 0; $i < count($this->comment); $i++) {
+ if ($this->extractFactoryNamesFromLine($this->comment[$i])) {
+ unset($this->comment[$i]);
+ }
+ }
+ $this->trimTrailingBlankLinesFromComment();
+ }
+
+ public function extractFactoryNamesFromLine($line)
+ {
+ if (preg_match('/^\s*@factory(\s+(.+))?$/', $line, $match)) {
+ $this->createCalls(
+ $this->extractFactoryNamesFromAnnotation(
+ isset($match[2]) ? trim($match[2]) : null
+ )
+ );
+ return true;
+ }
+ return false;
+ }
+
+ public function extractFactoryNamesFromAnnotation($value)
+ {
+ $primaryName = $this->reflector->getName();
+ if (empty($value)) {
+ return array($primaryName);
+ }
+ preg_match_all('/(\.{3}|-|[a-zA-Z_][a-zA-Z_0-9]*)/', $value, $match);
+ $names = $match[0];
+ if (in_array('...', $names)) {
+ $this->isVarArgs = true;
+ }
+ if (!in_array('-', $names) && !in_array($primaryName, $names)) {
+ array_unshift($names, $primaryName);
+ }
+ return $names;
+ }
+
+ public function createCalls(array $names)
+ {
+ $names = array_unique($names);
+ foreach ($names as $name) {
+ if ($name != '-' && $name != '...') {
+ $this->calls[] = new FactoryCall($this, $name);
+ }
+ }
+ }
+
+ public function extractParameters()
+ {
+ $this->parameters = array();
+ if (!$this->isVarArgs) {
+ foreach ($this->reflector->getParameters() as $parameter) {
+ $this->parameters[] = new FactoryParameter($this, $parameter);
+ }
+ }
+ }
+
+ public function getParameterDeclarations()
+ {
+ if ($this->isVarArgs || !$this->hasParameters()) {
+ return '';
+ }
+ $params = array();
+ foreach ($this->parameters as /** @var $parameter FactoryParameter */
+ $parameter) {
+ $params[] = $parameter->getDeclaration();
+ }
+ return implode(', ', $params);
+ }
+
+ public function getParameterInvocations()
+ {
+ if ($this->isVarArgs) {
+ return '';
+ }
+ $params = array();
+ foreach ($this->parameters as $parameter) {
+ $params[] = $parameter->getInvocation();
+ }
+ return implode(', ', $params);
+ }
+
+
+ public function getClass()
+ {
+ return $this->class;
+ }
+
+ public function getClassName()
+ {
+ return $this->class->getName();
+ }
+
+ public function getName()
+ {
+ return $this->reflector->name;
+ }
+
+ public function isFactory()
+ {
+ return count($this->calls) > 0;
+ }
+
+ public function getCalls()
+ {
+ return $this->calls;
+ }
+
+ public function acceptsVariableArguments()
+ {
+ return $this->isVarArgs;
+ }
+
+ public function hasParameters()
+ {
+ return !empty($this->parameters);
+ }
+
+ public function getParameters()
+ {
+ return $this->parameters;
+ }
+
+ public function getFullName()
+ {
+ return $this->getClassName() . '::' . $this->getName();
+ }
+
+ public function getCommentText()
+ {
+ return implode("\n", $this->comment);
+ }
+
+ public function getComment($indent = '')
+ {
+ $comment = $indent . '/**';
+ foreach ($this->comment as $line) {
+ $comment .= "\n" . rtrim($indent . ' * ' . $line);
+ }
+ $comment .= "\n" . $indent . ' */';
+ return $comment;
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/generator/FactoryParameter.php b/vendor/hamcrest/hamcrest-php/generator/FactoryParameter.php
new file mode 100644
index 0000000..2e5cb9e
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/generator/FactoryParameter.php
@@ -0,0 +1,131 @@
+method = $method;
+ $this->reflector = $reflector;
+ }
+
+ /**
+ * Compute the declaration code.
+ *
+ * @return string
+ */
+ public function getDeclaration()
+ {
+ $code = $this->getTypeCode() . $this->getInvocation();
+
+ if ($this->reflector->isOptional()) {
+ $default = $this->reflector->getDefaultValue();
+ if (is_null($default)) {
+ $default = 'null';
+ } elseif (is_bool($default)) {
+ $default = $default ? 'true' : 'false';
+ } elseif (is_string($default)) {
+ $default = "'" . $default . "'";
+ } elseif (is_numeric($default)) {
+ $default = strval($default);
+ } elseif (is_array($default)) {
+ $default = 'array()';
+ } else {
+ echo 'Warning: unknown default type for ' . $this->getMethod()->getFullName() . "\n";
+ var_dump($default);
+ $default = 'null';
+ }
+ $code .= ' = ' . $default;
+ }
+ return $code;
+ }
+
+ /**
+ * Compute the type code for the parameter.
+ *
+ * @return string
+ */
+ private function getTypeCode()
+ {
+ // Handle PHP 5 separately
+ if (PHP_VERSION_ID < 70000) {
+ if ($this->reflector->isArray()) {
+ return 'array';
+ }
+
+ $class = $this->reflector->getClass();
+
+ return $class ? sprintf('\\%s ', $class->getName()) : '';
+ }
+
+ if (!$this->reflector->hasType()) {
+ return '';
+ }
+
+ $type = $this->reflector->getType();
+ $name = self::getQualifiedName($type);
+
+ // PHP 7.1+ supports nullable types via a leading question mark
+ return (PHP_VERSION_ID >= 70100 && $type->allowsNull()) ? sprintf('?%s ', $name) : sprintf('%s ', $name);
+ }
+
+ /**
+ * Compute qualified name for the given type.
+ *
+ * This function knows how to prefix class names with a leading slash and
+ * also how to handle PHP 8's union types.
+ *
+ * @param ReflectionType $type
+ *
+ * @return string
+ */
+ private static function getQualifiedName(ReflectionType $type)
+ {
+ // PHP 8 union types can be recursively processed
+ if ($type instanceof ReflectionUnionType) {
+ return implode('|', array_map(function (ReflectionType $type) {
+ // The "self::" call within a Closure is fine here because this
+ // code will only ever be executed on PHP 7.0+
+ return self::getQualifiedName($type);
+ }, $type->getTypes()));
+ }
+
+ // PHP 7.0 doesn't have named types, but 7.1+ does
+ $name = $type instanceof ReflectionNamedType ? $type->getName() : (string) $type;
+
+ return $type->isBuiltin() ? $name : sprintf('\\%s', $name);
+ }
+
+ /**
+ * Compute the invocation code.
+ *
+ * @return string
+ */
+ public function getInvocation()
+ {
+ return sprintf('$%s', $this->reflector->getName());
+ }
+
+ /**
+ * Compute the method name.
+ *
+ * @return string
+ */
+ public function getMethod()
+ {
+ return $this->method;
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/generator/GlobalFunctionFile.php b/vendor/hamcrest/hamcrest-php/generator/GlobalFunctionFile.php
new file mode 100644
index 0000000..ec8b1b3
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/generator/GlobalFunctionFile.php
@@ -0,0 +1,42 @@
+functions = '';
+ }
+
+ public function addCall(FactoryCall $call)
+ {
+ $this->functions .= "\n" . $this->generateFactoryCall($call);
+ }
+
+ public function build()
+ {
+ $this->addFileHeader();
+ $this->addPart('functions_imports');
+ $this->addPart('functions_header');
+ $this->addCode($this->functions);
+ $this->addPart('functions_footer');
+ }
+
+ public function generateFactoryCall(FactoryCall $call)
+ {
+ $code = "if (!function_exists('{$call->getName()}')) {\n";
+ $code.= parent::generateFactoryCall($call);
+ $code.= "}\n";
+
+ return $code;
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/generator/StaticMethodFile.php b/vendor/hamcrest/hamcrest-php/generator/StaticMethodFile.php
new file mode 100644
index 0000000..44cec02
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/generator/StaticMethodFile.php
@@ -0,0 +1,38 @@
+methods = '';
+ }
+
+ public function addCall(FactoryCall $call)
+ {
+ $this->methods .= PHP_EOL . $this->generateFactoryCall($call);
+ }
+
+ public function getDeclarationModifiers()
+ {
+ return 'public static ';
+ }
+
+ public function build()
+ {
+ $this->addFileHeader();
+ $this->addPart('matchers_imports');
+ $this->addPart('matchers_header');
+ $this->addCode($this->methods);
+ $this->addPart('matchers_footer');
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/generator/parts/file_header.txt b/vendor/hamcrest/hamcrest-php/generator/parts/file_header.txt
new file mode 100644
index 0000000..7b352e4
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/generator/parts/file_header.txt
@@ -0,0 +1,7 @@
+
+ * //With an identifier
+ * assertThat("assertion identifier", $apple->flavour(), equalTo("tasty"));
+ * //Without an identifier
+ * assertThat($apple->flavour(), equalTo("tasty"));
+ * //Evaluating a boolean expression
+ * assertThat("some error", $a > $b);
+ *
+ */
+ function assertThat()
+ {
+ $args = func_get_args();
+ call_user_func_array(
+ array('Hamcrest\MatcherAssert', 'assertThat'),
+ $args
+ );
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/generator/parts/functions_imports.txt b/vendor/hamcrest/hamcrest-php/generator/parts/functions_imports.txt
new file mode 100644
index 0000000..e69de29
diff --git a/vendor/hamcrest/hamcrest-php/generator/parts/matchers_footer.txt b/vendor/hamcrest/hamcrest-php/generator/parts/matchers_footer.txt
new file mode 100644
index 0000000..5c34318
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/generator/parts/matchers_footer.txt
@@ -0,0 +1 @@
+}
diff --git a/vendor/hamcrest/hamcrest-php/generator/parts/matchers_header.txt b/vendor/hamcrest/hamcrest-php/generator/parts/matchers_header.txt
new file mode 100644
index 0000000..4f8bb2b
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/generator/parts/matchers_header.txt
@@ -0,0 +1,7 @@
+
+
+/**
+ * A series of static factories for all hamcrest matchers.
+ */
+class Matchers
+{
diff --git a/vendor/hamcrest/hamcrest-php/generator/parts/matchers_imports.txt b/vendor/hamcrest/hamcrest-php/generator/parts/matchers_imports.txt
new file mode 100644
index 0000000..7dd6849
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/generator/parts/matchers_imports.txt
@@ -0,0 +1,2 @@
+
+namespace Hamcrest;
\ No newline at end of file
diff --git a/vendor/hamcrest/hamcrest-php/generator/run.php b/vendor/hamcrest/hamcrest-php/generator/run.php
new file mode 100644
index 0000000..924d752
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/generator/run.php
@@ -0,0 +1,37 @@
+addFactoryFile(new StaticMethodFile(STATIC_MATCHERS_FILE));
+$generator->addFactoryFile(new GlobalFunctionFile(GLOBAL_FUNCTIONS_FILE));
+$generator->generate();
+$generator->write();
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest.php
new file mode 100644
index 0000000..55a2dd8
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest.php
@@ -0,0 +1,882 @@
+
+ * //With an identifier
+ * assertThat("assertion identifier", $apple->flavour(), equalTo("tasty"));
+ * //Without an identifier
+ * assertThat($apple->flavour(), equalTo("tasty"));
+ * //Evaluating a boolean expression
+ * assertThat("some error", $a > $b);
+ *
+ */
+ function assertThat()
+ {
+ $args = func_get_args();
+ call_user_func_array(
+ array('Hamcrest\MatcherAssert', 'assertThat'),
+ $args
+ );
+ }
+}
+
+if (!function_exists('anArray')) {
+ /**
+ * Evaluates to true only if each $matcher[$i] is satisfied by $array[$i].
+ */
+ function anArray(/* args... */)
+ {
+ $args = func_get_args();
+ return call_user_func_array(array('\Hamcrest\Arrays\IsArray', 'anArray'), $args);
+ }
+}
+
+if (!function_exists('hasItemInArray')) {
+ /**
+ * Evaluates to true if any item in an array satisfies the given matcher.
+ *
+ * @param mixed $item as a {@link Hamcrest\Matcher} or a value.
+ *
+ * @return \Hamcrest\Arrays\IsArrayContaining
+ */
+ function hasItemInArray($item)
+ {
+ return \Hamcrest\Arrays\IsArrayContaining::hasItemInArray($item);
+ }
+}
+
+if (!function_exists('hasValue')) {
+ /**
+ * Evaluates to true if any item in an array satisfies the given matcher.
+ *
+ * @param mixed $item as a {@link Hamcrest\Matcher} or a value.
+ *
+ * @return \Hamcrest\Arrays\IsArrayContaining
+ */
+ function hasValue($item)
+ {
+ return \Hamcrest\Arrays\IsArrayContaining::hasItemInArray($item);
+ }
+}
+
+if (!function_exists('arrayContainingInAnyOrder')) {
+ /**
+ * An array with elements that match the given matchers.
+ */
+ function arrayContainingInAnyOrder(/* args... */)
+ {
+ $args = func_get_args();
+ return call_user_func_array(array('\Hamcrest\Arrays\IsArrayContainingInAnyOrder', 'arrayContainingInAnyOrder'), $args);
+ }
+}
+
+if (!function_exists('containsInAnyOrder')) {
+ /**
+ * An array with elements that match the given matchers.
+ */
+ function containsInAnyOrder(/* args... */)
+ {
+ $args = func_get_args();
+ return call_user_func_array(array('\Hamcrest\Arrays\IsArrayContainingInAnyOrder', 'arrayContainingInAnyOrder'), $args);
+ }
+}
+
+if (!function_exists('arrayContaining')) {
+ /**
+ * An array with elements that match the given matchers in the same order.
+ */
+ function arrayContaining(/* args... */)
+ {
+ $args = func_get_args();
+ return call_user_func_array(array('\Hamcrest\Arrays\IsArrayContainingInOrder', 'arrayContaining'), $args);
+ }
+}
+
+if (!function_exists('contains')) {
+ /**
+ * An array with elements that match the given matchers in the same order.
+ */
+ function contains(/* args... */)
+ {
+ $args = func_get_args();
+ return call_user_func_array(array('\Hamcrest\Arrays\IsArrayContainingInOrder', 'arrayContaining'), $args);
+ }
+}
+
+if (!function_exists('hasKeyInArray')) {
+ /**
+ * Evaluates to true if any key in an array matches the given matcher.
+ *
+ * @param mixed $key as a {@link Hamcrest\Matcher} or a value.
+ *
+ * @return \Hamcrest\Arrays\IsArrayContainingKey
+ */
+ function hasKeyInArray($key)
+ {
+ return \Hamcrest\Arrays\IsArrayContainingKey::hasKeyInArray($key);
+ }
+}
+
+if (!function_exists('hasKey')) {
+ /**
+ * Evaluates to true if any key in an array matches the given matcher.
+ *
+ * @param mixed $key as a {@link Hamcrest\Matcher} or a value.
+ *
+ * @return \Hamcrest\Arrays\IsArrayContainingKey
+ */
+ function hasKey($key)
+ {
+ return \Hamcrest\Arrays\IsArrayContainingKey::hasKeyInArray($key);
+ }
+}
+
+if (!function_exists('hasKeyValuePair')) {
+ /**
+ * Test if an array has both an key and value in parity with each other.
+ */
+ function hasKeyValuePair($key, $value)
+ {
+ return \Hamcrest\Arrays\IsArrayContainingKeyValuePair::hasKeyValuePair($key, $value);
+ }
+}
+
+if (!function_exists('hasEntry')) {
+ /**
+ * Test if an array has both an key and value in parity with each other.
+ */
+ function hasEntry($key, $value)
+ {
+ return \Hamcrest\Arrays\IsArrayContainingKeyValuePair::hasKeyValuePair($key, $value);
+ }
+}
+
+if (!function_exists('arrayWithSize')) {
+ /**
+ * Does array size satisfy a given matcher?
+ *
+ * @param \Hamcrest\Matcher|int $size as a {@link Hamcrest\Matcher} or a value.
+ *
+ * @return \Hamcrest\Arrays\IsArrayWithSize
+ */
+ function arrayWithSize($size)
+ {
+ return \Hamcrest\Arrays\IsArrayWithSize::arrayWithSize($size);
+ }
+}
+
+if (!function_exists('emptyArray')) {
+ /**
+ * Matches an empty array.
+ */
+ function emptyArray()
+ {
+ return \Hamcrest\Arrays\IsArrayWithSize::emptyArray();
+ }
+}
+
+if (!function_exists('nonEmptyArray')) {
+ /**
+ * Matches an empty array.
+ */
+ function nonEmptyArray()
+ {
+ return \Hamcrest\Arrays\IsArrayWithSize::nonEmptyArray();
+ }
+}
+
+if (!function_exists('emptyTraversable')) {
+ /**
+ * Returns true if traversable is empty.
+ */
+ function emptyTraversable()
+ {
+ return \Hamcrest\Collection\IsEmptyTraversable::emptyTraversable();
+ }
+}
+
+if (!function_exists('nonEmptyTraversable')) {
+ /**
+ * Returns true if traversable is not empty.
+ */
+ function nonEmptyTraversable()
+ {
+ return \Hamcrest\Collection\IsEmptyTraversable::nonEmptyTraversable();
+ }
+}
+
+if (!function_exists('traversableWithSize')) {
+ /**
+ * Does traversable size satisfy a given matcher?
+ */
+ function traversableWithSize($size)
+ {
+ return \Hamcrest\Collection\IsTraversableWithSize::traversableWithSize($size);
+ }
+}
+
+if (!function_exists('allOf')) {
+ /**
+ * Evaluates to true only if ALL of the passed in matchers evaluate to true.
+ */
+ function allOf(/* args... */)
+ {
+ $args = func_get_args();
+ return call_user_func_array(array('\Hamcrest\Core\AllOf', 'allOf'), $args);
+ }
+}
+
+if (!function_exists('anyOf')) {
+ /**
+ * Evaluates to true if ANY of the passed in matchers evaluate to true.
+ */
+ function anyOf(/* args... */)
+ {
+ $args = func_get_args();
+ return call_user_func_array(array('\Hamcrest\Core\AnyOf', 'anyOf'), $args);
+ }
+}
+
+if (!function_exists('noneOf')) {
+ /**
+ * Evaluates to false if ANY of the passed in matchers evaluate to true.
+ */
+ function noneOf(/* args... */)
+ {
+ $args = func_get_args();
+ return call_user_func_array(array('\Hamcrest\Core\AnyOf', 'noneOf'), $args);
+ }
+}
+
+if (!function_exists('both')) {
+ /**
+ * This is useful for fluently combining matchers that must both pass.
+ * For example:
+ *
+ * assertThat($string, both(containsString("a"))->andAlso(containsString("b")));
+ *
+ */
+ function both(\Hamcrest\Matcher $matcher)
+ {
+ return \Hamcrest\Core\CombinableMatcher::both($matcher);
+ }
+}
+
+if (!function_exists('either')) {
+ /**
+ * This is useful for fluently combining matchers where either may pass,
+ * for example:
+ *
+ * assertThat($string, either(containsString("a"))->orElse(containsString("b")));
+ *
+ */
+ function either(\Hamcrest\Matcher $matcher)
+ {
+ return \Hamcrest\Core\CombinableMatcher::either($matcher);
+ }
+}
+
+if (!function_exists('describedAs')) {
+ /**
+ * Wraps an existing matcher and overrides the description when it fails.
+ */
+ function describedAs(/* args... */)
+ {
+ $args = func_get_args();
+ return call_user_func_array(array('\Hamcrest\Core\DescribedAs', 'describedAs'), $args);
+ }
+}
+
+if (!function_exists('everyItem')) {
+ /**
+ * @param Matcher $itemMatcher
+ * A matcher to apply to every element in an array.
+ *
+ * @return \Hamcrest\Core\Every
+ * Evaluates to TRUE for a collection in which every item matches $itemMatcher
+ */
+ function everyItem(\Hamcrest\Matcher $itemMatcher)
+ {
+ return \Hamcrest\Core\Every::everyItem($itemMatcher);
+ }
+}
+
+if (!function_exists('hasToString')) {
+ /**
+ * Does array size satisfy a given matcher?
+ */
+ function hasToString($matcher)
+ {
+ return \Hamcrest\Core\HasToString::hasToString($matcher);
+ }
+}
+
+if (!function_exists('is')) {
+ /**
+ * Decorates another Matcher, retaining the behavior but allowing tests
+ * to be slightly more expressive.
+ *
+ * For example: assertThat($cheese, equalTo($smelly))
+ * vs. assertThat($cheese, is(equalTo($smelly)))
+ */
+ function is($value)
+ {
+ return \Hamcrest\Core\Is::is($value);
+ }
+}
+
+if (!function_exists('anything')) {
+ /**
+ * This matcher always evaluates to true.
+ *
+ * @param string $description A meaningful string used when describing itself.
+ *
+ * @return \Hamcrest\Core\IsAnything
+ */
+ function anything($description = 'ANYTHING')
+ {
+ return \Hamcrest\Core\IsAnything::anything($description);
+ }
+}
+
+if (!function_exists('hasItem')) {
+ /**
+ * Test if the value is an array containing this matcher.
+ *
+ * Example:
+ *
+ * assertThat(array('a', 'b'), hasItem(equalTo('b')));
+ * //Convenience defaults to equalTo()
+ * assertThat(array('a', 'b'), hasItem('b'));
+ *
+ */
+ function hasItem(/* args... */)
+ {
+ $args = func_get_args();
+ return call_user_func_array(array('\Hamcrest\Core\IsCollectionContaining', 'hasItem'), $args);
+ }
+}
+
+if (!function_exists('hasItems')) {
+ /**
+ * Test if the value is an array containing elements that match all of these
+ * matchers.
+ *
+ * Example:
+ *
+ * assertThat(array('a', 'b', 'c'), hasItems(equalTo('a'), equalTo('b')));
+ *
+ */
+ function hasItems(/* args... */)
+ {
+ $args = func_get_args();
+ return call_user_func_array(array('\Hamcrest\Core\IsCollectionContaining', 'hasItems'), $args);
+ }
+}
+
+if (!function_exists('equalTo')) {
+ /**
+ * Is the value equal to another value, as tested by the use of the "=="
+ * comparison operator?
+ */
+ function equalTo($item)
+ {
+ return \Hamcrest\Core\IsEqual::equalTo($item);
+ }
+}
+
+if (!function_exists('identicalTo')) {
+ /**
+ * Tests of the value is identical to $value as tested by the "===" operator.
+ */
+ function identicalTo($value)
+ {
+ return \Hamcrest\Core\IsIdentical::identicalTo($value);
+ }
+}
+
+if (!function_exists('anInstanceOf')) {
+ /**
+ * Is the value an instance of a particular type?
+ * This version assumes no relationship between the required type and
+ * the signature of the method that sets it up, for example in
+ * assertThat($anObject, anInstanceOf('Thing'));
+ */
+ function anInstanceOf($theClass)
+ {
+ return \Hamcrest\Core\IsInstanceOf::anInstanceOf($theClass);
+ }
+}
+
+if (!function_exists('any')) {
+ /**
+ * Is the value an instance of a particular type?
+ * This version assumes no relationship between the required type and
+ * the signature of the method that sets it up, for example in
+ * assertThat($anObject, anInstanceOf('Thing'));
+ */
+ function any($theClass)
+ {
+ return \Hamcrest\Core\IsInstanceOf::anInstanceOf($theClass);
+ }
+}
+
+if (!function_exists('not')) {
+ /**
+ * Matches if value does not match $value.
+ */
+ function not($value)
+ {
+ return \Hamcrest\Core\IsNot::not($value);
+ }
+}
+
+if (!function_exists('nullValue')) {
+ /**
+ * Matches if value is null.
+ */
+ function nullValue()
+ {
+ return \Hamcrest\Core\IsNull::nullValue();
+ }
+}
+
+if (!function_exists('notNullValue')) {
+ /**
+ * Matches if value is not null.
+ */
+ function notNullValue()
+ {
+ return \Hamcrest\Core\IsNull::notNullValue();
+ }
+}
+
+if (!function_exists('sameInstance')) {
+ /**
+ * Creates a new instance of IsSame.
+ *
+ * @param mixed $object
+ * The predicate evaluates to true only when the argument is
+ * this object.
+ *
+ * @return \Hamcrest\Core\IsSame
+ */
+ function sameInstance($object)
+ {
+ return \Hamcrest\Core\IsSame::sameInstance($object);
+ }
+}
+
+if (!function_exists('typeOf')) {
+ /**
+ * Is the value a particular built-in type?
+ */
+ function typeOf($theType)
+ {
+ return \Hamcrest\Core\IsTypeOf::typeOf($theType);
+ }
+}
+
+if (!function_exists('set')) {
+ /**
+ * Matches if value (class, object, or array) has named $property.
+ */
+ function set($property)
+ {
+ return \Hamcrest\Core\Set::set($property);
+ }
+}
+
+if (!function_exists('notSet')) {
+ /**
+ * Matches if value (class, object, or array) does not have named $property.
+ */
+ function notSet($property)
+ {
+ return \Hamcrest\Core\Set::notSet($property);
+ }
+}
+
+if (!function_exists('closeTo')) {
+ /**
+ * Matches if value is a number equal to $value within some range of
+ * acceptable error $delta.
+ */
+ function closeTo($value, $delta)
+ {
+ return \Hamcrest\Number\IsCloseTo::closeTo($value, $delta);
+ }
+}
+
+if (!function_exists('comparesEqualTo')) {
+ /**
+ * The value is not > $value, nor < $value.
+ */
+ function comparesEqualTo($value)
+ {
+ return \Hamcrest\Number\OrderingComparison::comparesEqualTo($value);
+ }
+}
+
+if (!function_exists('greaterThan')) {
+ /**
+ * The value is > $value.
+ */
+ function greaterThan($value)
+ {
+ return \Hamcrest\Number\OrderingComparison::greaterThan($value);
+ }
+}
+
+if (!function_exists('greaterThanOrEqualTo')) {
+ /**
+ * The value is >= $value.
+ */
+ function greaterThanOrEqualTo($value)
+ {
+ return \Hamcrest\Number\OrderingComparison::greaterThanOrEqualTo($value);
+ }
+}
+
+if (!function_exists('atLeast')) {
+ /**
+ * The value is >= $value.
+ */
+ function atLeast($value)
+ {
+ return \Hamcrest\Number\OrderingComparison::greaterThanOrEqualTo($value);
+ }
+}
+
+if (!function_exists('lessThan')) {
+ /**
+ * The value is < $value.
+ */
+ function lessThan($value)
+ {
+ return \Hamcrest\Number\OrderingComparison::lessThan($value);
+ }
+}
+
+if (!function_exists('lessThanOrEqualTo')) {
+ /**
+ * The value is <= $value.
+ */
+ function lessThanOrEqualTo($value)
+ {
+ return \Hamcrest\Number\OrderingComparison::lessThanOrEqualTo($value);
+ }
+}
+
+if (!function_exists('atMost')) {
+ /**
+ * The value is <= $value.
+ */
+ function atMost($value)
+ {
+ return \Hamcrest\Number\OrderingComparison::lessThanOrEqualTo($value);
+ }
+}
+
+if (!function_exists('isEmptyString')) {
+ /**
+ * Matches if value is a zero-length string.
+ */
+ function isEmptyString()
+ {
+ return \Hamcrest\Text\IsEmptyString::isEmptyString();
+ }
+}
+
+if (!function_exists('emptyString')) {
+ /**
+ * Matches if value is a zero-length string.
+ */
+ function emptyString()
+ {
+ return \Hamcrest\Text\IsEmptyString::isEmptyString();
+ }
+}
+
+if (!function_exists('isEmptyOrNullString')) {
+ /**
+ * Matches if value is null or a zero-length string.
+ */
+ function isEmptyOrNullString()
+ {
+ return \Hamcrest\Text\IsEmptyString::isEmptyOrNullString();
+ }
+}
+
+if (!function_exists('nullOrEmptyString')) {
+ /**
+ * Matches if value is null or a zero-length string.
+ */
+ function nullOrEmptyString()
+ {
+ return \Hamcrest\Text\IsEmptyString::isEmptyOrNullString();
+ }
+}
+
+if (!function_exists('isNonEmptyString')) {
+ /**
+ * Matches if value is a non-zero-length string.
+ */
+ function isNonEmptyString()
+ {
+ return \Hamcrest\Text\IsEmptyString::isNonEmptyString();
+ }
+}
+
+if (!function_exists('nonEmptyString')) {
+ /**
+ * Matches if value is a non-zero-length string.
+ */
+ function nonEmptyString()
+ {
+ return \Hamcrest\Text\IsEmptyString::isNonEmptyString();
+ }
+}
+
+if (!function_exists('equalToIgnoringCase')) {
+ /**
+ * Matches if value is a string equal to $string, regardless of the case.
+ */
+ function equalToIgnoringCase($string)
+ {
+ return \Hamcrest\Text\IsEqualIgnoringCase::equalToIgnoringCase($string);
+ }
+}
+
+if (!function_exists('equalToIgnoringWhiteSpace')) {
+ /**
+ * Matches if value is a string equal to $string, regardless of whitespace.
+ */
+ function equalToIgnoringWhiteSpace($string)
+ {
+ return \Hamcrest\Text\IsEqualIgnoringWhiteSpace::equalToIgnoringWhiteSpace($string);
+ }
+}
+
+if (!function_exists('matchesPattern')) {
+ /**
+ * Matches if value is a string that matches regular expression $pattern.
+ */
+ function matchesPattern($pattern)
+ {
+ return \Hamcrest\Text\MatchesPattern::matchesPattern($pattern);
+ }
+}
+
+if (!function_exists('containsString')) {
+ /**
+ * Matches if value is a string that contains $substring.
+ */
+ function containsString($substring)
+ {
+ return \Hamcrest\Text\StringContains::containsString($substring);
+ }
+}
+
+if (!function_exists('containsStringIgnoringCase')) {
+ /**
+ * Matches if value is a string that contains $substring regardless of the case.
+ */
+ function containsStringIgnoringCase($substring)
+ {
+ return \Hamcrest\Text\StringContainsIgnoringCase::containsStringIgnoringCase($substring);
+ }
+}
+
+if (!function_exists('stringContainsInOrder')) {
+ /**
+ * Matches if value contains $substrings in a constrained order.
+ */
+ function stringContainsInOrder(/* args... */)
+ {
+ $args = func_get_args();
+ return call_user_func_array(array('\Hamcrest\Text\StringContainsInOrder', 'stringContainsInOrder'), $args);
+ }
+}
+
+if (!function_exists('endsWith')) {
+ /**
+ * Matches if value is a string that ends with $substring.
+ */
+ function endsWith($substring)
+ {
+ return \Hamcrest\Text\StringEndsWith::endsWith($substring);
+ }
+}
+
+if (!function_exists('startsWith')) {
+ /**
+ * Matches if value is a string that starts with $substring.
+ */
+ function startsWith($substring)
+ {
+ return \Hamcrest\Text\StringStartsWith::startsWith($substring);
+ }
+}
+
+if (!function_exists('arrayValue')) {
+ /**
+ * Is the value an array?
+ */
+ function arrayValue()
+ {
+ return \Hamcrest\Type\IsArray::arrayValue();
+ }
+}
+
+if (!function_exists('booleanValue')) {
+ /**
+ * Is the value a boolean?
+ */
+ function booleanValue()
+ {
+ return \Hamcrest\Type\IsBoolean::booleanValue();
+ }
+}
+
+if (!function_exists('boolValue')) {
+ /**
+ * Is the value a boolean?
+ */
+ function boolValue()
+ {
+ return \Hamcrest\Type\IsBoolean::booleanValue();
+ }
+}
+
+if (!function_exists('callableValue')) {
+ /**
+ * Is the value callable?
+ */
+ function callableValue()
+ {
+ return \Hamcrest\Type\IsCallable::callableValue();
+ }
+}
+
+if (!function_exists('doubleValue')) {
+ /**
+ * Is the value a float/double?
+ */
+ function doubleValue()
+ {
+ return \Hamcrest\Type\IsDouble::doubleValue();
+ }
+}
+
+if (!function_exists('floatValue')) {
+ /**
+ * Is the value a float/double?
+ */
+ function floatValue()
+ {
+ return \Hamcrest\Type\IsDouble::doubleValue();
+ }
+}
+
+if (!function_exists('integerValue')) {
+ /**
+ * Is the value an integer?
+ */
+ function integerValue()
+ {
+ return \Hamcrest\Type\IsInteger::integerValue();
+ }
+}
+
+if (!function_exists('intValue')) {
+ /**
+ * Is the value an integer?
+ */
+ function intValue()
+ {
+ return \Hamcrest\Type\IsInteger::integerValue();
+ }
+}
+
+if (!function_exists('numericValue')) {
+ /**
+ * Is the value a numeric?
+ */
+ function numericValue()
+ {
+ return \Hamcrest\Type\IsNumeric::numericValue();
+ }
+}
+
+if (!function_exists('objectValue')) {
+ /**
+ * Is the value an object?
+ */
+ function objectValue()
+ {
+ return \Hamcrest\Type\IsObject::objectValue();
+ }
+}
+
+if (!function_exists('anObject')) {
+ /**
+ * Is the value an object?
+ */
+ function anObject()
+ {
+ return \Hamcrest\Type\IsObject::objectValue();
+ }
+}
+
+if (!function_exists('resourceValue')) {
+ /**
+ * Is the value a resource?
+ */
+ function resourceValue()
+ {
+ return \Hamcrest\Type\IsResource::resourceValue();
+ }
+}
+
+if (!function_exists('scalarValue')) {
+ /**
+ * Is the value a scalar (boolean, integer, double, or string)?
+ */
+ function scalarValue()
+ {
+ return \Hamcrest\Type\IsScalar::scalarValue();
+ }
+}
+
+if (!function_exists('stringValue')) {
+ /**
+ * Is the value a string?
+ */
+ function stringValue()
+ {
+ return \Hamcrest\Type\IsString::stringValue();
+ }
+}
+
+if (!function_exists('hasXPath')) {
+ /**
+ * Wraps $matcher with {@link Hamcrest\Core\IsEqual)
+ * if it's not a matcher and the XPath in count()
+ * if it's an integer.
+ */
+ function hasXPath($xpath, $matcher = null)
+ {
+ return \Hamcrest\Xml\HasXPath::hasXPath($xpath, $matcher);
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Arrays/IsArray.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Arrays/IsArray.php
new file mode 100644
index 0000000..9ea5697
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Arrays/IsArray.php
@@ -0,0 +1,118 @@
+_elementMatchers = $elementMatchers;
+ }
+
+ protected function matchesSafely($array)
+ {
+ if (array_keys($array) != array_keys($this->_elementMatchers)) {
+ return false;
+ }
+
+ /** @var $matcher \Hamcrest\Matcher */
+ foreach ($this->_elementMatchers as $k => $matcher) {
+ if (!$matcher->matches($array[$k])) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ protected function describeMismatchSafely($actual, Description $mismatchDescription)
+ {
+ if (count($actual) != count($this->_elementMatchers)) {
+ $mismatchDescription->appendText('array length was ' . count($actual));
+
+ return;
+ } elseif (array_keys($actual) != array_keys($this->_elementMatchers)) {
+ $mismatchDescription->appendText('array keys were ')
+ ->appendValueList(
+ $this->descriptionStart(),
+ $this->descriptionSeparator(),
+ $this->descriptionEnd(),
+ array_keys($actual)
+ )
+ ;
+
+ return;
+ }
+
+ /** @var $matcher \Hamcrest\Matcher */
+ foreach ($this->_elementMatchers as $k => $matcher) {
+ if (!$matcher->matches($actual[$k])) {
+ $mismatchDescription->appendText('element ')->appendValue($k)
+ ->appendText(' was ')->appendValue($actual[$k]);
+
+ return;
+ }
+ }
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description->appendList(
+ $this->descriptionStart(),
+ $this->descriptionSeparator(),
+ $this->descriptionEnd(),
+ $this->_elementMatchers
+ );
+ }
+
+ /**
+ * Evaluates to true only if each $matcher[$i] is satisfied by $array[$i].
+ *
+ * @factory ...
+ */
+ public static function anArray(/* args... */)
+ {
+ $args = func_get_args();
+
+ return new self(Util::createMatcherArray($args));
+ }
+
+ // -- Protected Methods
+
+ protected function descriptionStart()
+ {
+ return '[';
+ }
+
+ protected function descriptionSeparator()
+ {
+ return ', ';
+ }
+
+ protected function descriptionEnd()
+ {
+ return ']';
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContaining.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContaining.php
new file mode 100644
index 0000000..0e4a1ed
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContaining.php
@@ -0,0 +1,63 @@
+_elementMatcher = $elementMatcher;
+ }
+
+ protected function matchesSafely($array)
+ {
+ foreach ($array as $element) {
+ if ($this->_elementMatcher->matches($element)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ protected function describeMismatchSafely($array, Description $mismatchDescription)
+ {
+ $mismatchDescription->appendText('was ')->appendValue($array);
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description
+ ->appendText('an array containing ')
+ ->appendDescriptionOf($this->_elementMatcher)
+ ;
+ }
+
+ /**
+ * Evaluates to true if any item in an array satisfies the given matcher.
+ *
+ * @param mixed $item as a {@link Hamcrest\Matcher} or a value.
+ *
+ * @return \Hamcrest\Arrays\IsArrayContaining
+ * @factory hasValue
+ */
+ public static function hasItemInArray($item)
+ {
+ return new self(Util::wrapValueWithIsEqual($item));
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContainingInAnyOrder.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContainingInAnyOrder.php
new file mode 100644
index 0000000..9009026
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContainingInAnyOrder.php
@@ -0,0 +1,59 @@
+_elementMatchers = $elementMatchers;
+ }
+
+ protected function matchesSafelyWithDiagnosticDescription($array, Description $mismatchDescription)
+ {
+ $matching = new MatchingOnce($this->_elementMatchers, $mismatchDescription);
+
+ foreach ($array as $element) {
+ if (!$matching->matches($element)) {
+ return false;
+ }
+ }
+
+ return $matching->isFinished($array);
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description->appendList('[', ', ', ']', $this->_elementMatchers)
+ ->appendText(' in any order')
+ ;
+ }
+
+ /**
+ * An array with elements that match the given matchers.
+ *
+ * @factory containsInAnyOrder ...
+ */
+ public static function arrayContainingInAnyOrder(/* args... */)
+ {
+ $args = func_get_args();
+
+ return new self(Util::createMatcherArray($args));
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContainingInOrder.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContainingInOrder.php
new file mode 100644
index 0000000..6115740
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContainingInOrder.php
@@ -0,0 +1,57 @@
+_elementMatchers = $elementMatchers;
+ }
+
+ protected function matchesSafelyWithDiagnosticDescription($array, Description $mismatchDescription)
+ {
+ $series = new SeriesMatchingOnce($this->_elementMatchers, $mismatchDescription);
+
+ foreach ($array as $element) {
+ if (!$series->matches($element)) {
+ return false;
+ }
+ }
+
+ return $series->isFinished();
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description->appendList('[', ', ', ']', $this->_elementMatchers);
+ }
+
+ /**
+ * An array with elements that match the given matchers in the same order.
+ *
+ * @factory contains ...
+ */
+ public static function arrayContaining(/* args... */)
+ {
+ $args = func_get_args();
+
+ return new self(Util::createMatcherArray($args));
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContainingKey.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContainingKey.php
new file mode 100644
index 0000000..523477e
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContainingKey.php
@@ -0,0 +1,75 @@
+_keyMatcher = $keyMatcher;
+ }
+
+ protected function matchesSafely($array)
+ {
+ foreach ($array as $key => $element) {
+ if ($this->_keyMatcher->matches($key)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ protected function describeMismatchSafely($array, Description $mismatchDescription)
+ {
+ //Not using appendValueList() so that keys can be shown
+ $mismatchDescription->appendText('array was ')
+ ->appendText('[')
+ ;
+ $loop = false;
+ foreach ($array as $key => $value) {
+ if ($loop) {
+ $mismatchDescription->appendText(', ');
+ }
+ $mismatchDescription->appendValue($key)->appendText(' => ')->appendValue($value);
+ $loop = true;
+ }
+ $mismatchDescription->appendText(']');
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description
+ ->appendText('array with key ')
+ ->appendDescriptionOf($this->_keyMatcher)
+ ;
+ }
+
+ /**
+ * Evaluates to true if any key in an array matches the given matcher.
+ *
+ * @param mixed $key as a {@link Hamcrest\Matcher} or a value.
+ *
+ * @return \Hamcrest\Arrays\IsArrayContainingKey
+ * @factory hasKey
+ */
+ public static function hasKeyInArray($key)
+ {
+ return new self(Util::wrapValueWithIsEqual($key));
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContainingKeyValuePair.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContainingKeyValuePair.php
new file mode 100644
index 0000000..9ac3eba
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContainingKeyValuePair.php
@@ -0,0 +1,80 @@
+_keyMatcher = $keyMatcher;
+ $this->_valueMatcher = $valueMatcher;
+ }
+
+ protected function matchesSafely($array)
+ {
+ foreach ($array as $key => $value) {
+ if ($this->_keyMatcher->matches($key) && $this->_valueMatcher->matches($value)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ protected function describeMismatchSafely($array, Description $mismatchDescription)
+ {
+ //Not using appendValueList() so that keys can be shown
+ $mismatchDescription->appendText('array was ')
+ ->appendText('[')
+ ;
+ $loop = false;
+ foreach ($array as $key => $value) {
+ if ($loop) {
+ $mismatchDescription->appendText(', ');
+ }
+ $mismatchDescription->appendValue($key)->appendText(' => ')->appendValue($value);
+ $loop = true;
+ }
+ $mismatchDescription->appendText(']');
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description->appendText('array containing [')
+ ->appendDescriptionOf($this->_keyMatcher)
+ ->appendText(' => ')
+ ->appendDescriptionOf($this->_valueMatcher)
+ ->appendText(']')
+ ;
+ }
+
+ /**
+ * Test if an array has both an key and value in parity with each other.
+ *
+ * @factory hasEntry
+ */
+ public static function hasKeyValuePair($key, $value)
+ {
+ return new self(
+ Util::wrapValueWithIsEqual($key),
+ Util::wrapValueWithIsEqual($value)
+ );
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayWithSize.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayWithSize.php
new file mode 100644
index 0000000..074375c
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayWithSize.php
@@ -0,0 +1,73 @@
+_elementMatchers = $elementMatchers;
+ $this->_mismatchDescription = $mismatchDescription;
+ }
+
+ public function matches($item)
+ {
+ return $this->_isNotSurplus($item) && $this->_isMatched($item);
+ }
+
+ public function isFinished($items)
+ {
+ if (empty($this->_elementMatchers)) {
+ return true;
+ }
+
+ $this->_mismatchDescription
+ ->appendText('No item matches: ')->appendList('', ', ', '', $this->_elementMatchers)
+ ->appendText(' in ')->appendValueList('[', ', ', ']', $items)
+ ;
+
+ return false;
+ }
+
+ // -- Private Methods
+
+ private function _isNotSurplus($item)
+ {
+ if (empty($this->_elementMatchers)) {
+ $this->_mismatchDescription->appendText('Not matched: ')->appendValue($item);
+
+ return false;
+ }
+
+ return true;
+ }
+
+ private function _isMatched($item)
+ {
+ /** @var $matcher \Hamcrest\Matcher */
+ foreach ($this->_elementMatchers as $i => $matcher) {
+ if ($matcher->matches($item)) {
+ unset($this->_elementMatchers[$i]);
+
+ return true;
+ }
+ }
+
+ $this->_mismatchDescription->appendText('Not matched: ')->appendValue($item);
+
+ return false;
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Arrays/SeriesMatchingOnce.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Arrays/SeriesMatchingOnce.php
new file mode 100644
index 0000000..12a912d
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Arrays/SeriesMatchingOnce.php
@@ -0,0 +1,75 @@
+_elementMatchers = $elementMatchers;
+ $this->_keys = array_keys($elementMatchers);
+ $this->_mismatchDescription = $mismatchDescription;
+ }
+
+ public function matches($item)
+ {
+ return $this->_isNotSurplus($item) && $this->_isMatched($item);
+ }
+
+ public function isFinished()
+ {
+ if (!empty($this->_elementMatchers)) {
+ $nextMatcher = current($this->_elementMatchers);
+ $this->_mismatchDescription->appendText('No item matched: ')->appendDescriptionOf($nextMatcher);
+
+ return false;
+ }
+
+ return true;
+ }
+
+ // -- Private Methods
+
+ private function _isNotSurplus($item)
+ {
+ if (empty($this->_elementMatchers)) {
+ $this->_mismatchDescription->appendText('Not matched: ')->appendValue($item);
+
+ return false;
+ }
+
+ return true;
+ }
+
+ private function _isMatched($item)
+ {
+ $this->_nextMatchKey = array_shift($this->_keys);
+ $nextMatcher = array_shift($this->_elementMatchers);
+
+ if (!$nextMatcher->matches($item)) {
+ $this->_describeMismatch($nextMatcher, $item);
+
+ return false;
+ }
+
+ return true;
+ }
+
+ private function _describeMismatch(Matcher $matcher, $item)
+ {
+ $this->_mismatchDescription->appendText('item with key ' . $this->_nextMatchKey . ': ');
+ $matcher->describeMismatch($item, $this->_mismatchDescription);
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/AssertionError.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/AssertionError.php
new file mode 100644
index 0000000..3a2a0e7
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/AssertionError.php
@@ -0,0 +1,10 @@
+append($text);
+
+ return $this;
+ }
+
+ public function appendDescriptionOf(SelfDescribing $value)
+ {
+ $value->describeTo($this);
+
+ return $this;
+ }
+
+ public function appendValue($value)
+ {
+ if (is_null($value)) {
+ $this->append('null');
+ } elseif (is_string($value)) {
+ $this->_toPhpSyntax($value);
+ } elseif (is_float($value)) {
+ $this->append('<');
+ $this->append($value);
+ $this->append('F>');
+ } elseif (is_bool($value)) {
+ $this->append('<');
+ $this->append($value ? 'true' : 'false');
+ $this->append('>');
+ } elseif (is_array($value) || $value instanceof \Iterator || $value instanceof \IteratorAggregate) {
+ $this->appendValueList('[', ', ', ']', $value);
+ } elseif (is_object($value) && !method_exists($value, '__toString')) {
+ $this->append('<');
+ $this->append(get_class($value));
+ $this->append('>');
+ } else {
+ $this->append('<');
+ $this->append($value);
+ $this->append('>');
+ }
+
+ return $this;
+ }
+
+ public function appendValueList($start, $separator, $end, $values)
+ {
+ $list = array();
+ foreach ($values as $v) {
+ $list[] = new SelfDescribingValue($v);
+ }
+
+ $this->appendList($start, $separator, $end, $list);
+
+ return $this;
+ }
+
+ public function appendList($start, $separator, $end, $values)
+ {
+ $this->append($start);
+
+ $separate = false;
+
+ foreach ($values as $value) {
+ /*if (!($value instanceof Hamcrest\SelfDescribing)) {
+ $value = new Hamcrest\Internal\SelfDescribingValue($value);
+ }*/
+
+ if ($separate) {
+ $this->append($separator);
+ }
+
+ $this->appendDescriptionOf($value);
+
+ $separate = true;
+ }
+
+ $this->append($end);
+
+ return $this;
+ }
+
+ // -- Protected Methods
+
+ /**
+ * Append the String $str to the description.
+ */
+ abstract protected function append($str);
+
+ // -- Private Methods
+
+ private function _toPhpSyntax($value)
+ {
+ $str = '"';
+ for ($i = 0, $len = strlen($value); $i < $len; ++$i) {
+ switch ($value[$i]) {
+ case '"':
+ $str .= '\\"';
+ break;
+
+ case "\t":
+ $str .= '\\t';
+ break;
+
+ case "\r":
+ $str .= '\\r';
+ break;
+
+ case "\n":
+ $str .= '\\n';
+ break;
+
+ default:
+ $str .= $value[$i];
+ }
+ }
+ $str .= '"';
+ $this->append($str);
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/BaseMatcher.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/BaseMatcher.php
new file mode 100644
index 0000000..0605569
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/BaseMatcher.php
@@ -0,0 +1,30 @@
+appendText('was ')->appendValue($item);
+ }
+
+ public function __toString()
+ {
+ return StringDescription::toString($this);
+ }
+
+ public function __invoke()
+ {
+ return call_user_func_array(array($this, 'matches'), func_get_args());
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Collection/IsEmptyTraversable.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Collection/IsEmptyTraversable.php
new file mode 100644
index 0000000..8ab58ea
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Collection/IsEmptyTraversable.php
@@ -0,0 +1,71 @@
+_empty = $empty;
+ }
+
+ public function matches($item)
+ {
+ if (!$item instanceof \Traversable) {
+ return false;
+ }
+
+ foreach ($item as $value) {
+ return !$this->_empty;
+ }
+
+ return $this->_empty;
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description->appendText($this->_empty ? 'an empty traversable' : 'a non-empty traversable');
+ }
+
+ /**
+ * Returns true if traversable is empty.
+ *
+ * @factory
+ */
+ public static function emptyTraversable()
+ {
+ if (!self::$_INSTANCE) {
+ self::$_INSTANCE = new self;
+ }
+
+ return self::$_INSTANCE;
+ }
+
+ /**
+ * Returns true if traversable is not empty.
+ *
+ * @factory
+ */
+ public static function nonEmptyTraversable()
+ {
+ if (!self::$_NOT_INSTANCE) {
+ self::$_NOT_INSTANCE = new self(false);
+ }
+
+ return self::$_NOT_INSTANCE;
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Collection/IsTraversableWithSize.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Collection/IsTraversableWithSize.php
new file mode 100644
index 0000000..c95edc5
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Collection/IsTraversableWithSize.php
@@ -0,0 +1,47 @@
+false.
+ */
+class AllOf extends DiagnosingMatcher
+{
+
+ private $_matchers;
+
+ public function __construct(array $matchers)
+ {
+ Util::checkAllAreMatchers($matchers);
+
+ $this->_matchers = $matchers;
+ }
+
+ public function matchesWithDiagnosticDescription($item, Description $mismatchDescription)
+ {
+ /** @var $matcher \Hamcrest\Matcher */
+ foreach ($this->_matchers as $matcher) {
+ if (!$matcher->matches($item)) {
+ $mismatchDescription->appendDescriptionOf($matcher)->appendText(' ');
+ $matcher->describeMismatch($item, $mismatchDescription);
+
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description->appendList('(', ' and ', ')', $this->_matchers);
+ }
+
+ /**
+ * Evaluates to true only if ALL of the passed in matchers evaluate to true.
+ *
+ * @factory ...
+ */
+ public static function allOf(/* args... */)
+ {
+ $args = func_get_args();
+
+ return new self(Util::createMatcherArray($args));
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/AnyOf.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/AnyOf.php
new file mode 100644
index 0000000..4504279
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/AnyOf.php
@@ -0,0 +1,58 @@
+true.
+ */
+class AnyOf extends ShortcutCombination
+{
+
+ public function __construct(array $matchers)
+ {
+ parent::__construct($matchers);
+ }
+
+ public function matches($item)
+ {
+ return $this->matchesWithShortcut($item, true);
+ }
+
+ public function describeTo(Description $description)
+ {
+ $this->describeToWithOperator($description, 'or');
+ }
+
+ /**
+ * Evaluates to true if ANY of the passed in matchers evaluate to true.
+ *
+ * @factory ...
+ */
+ public static function anyOf(/* args... */)
+ {
+ $args = func_get_args();
+
+ return new self(Util::createMatcherArray($args));
+ }
+
+ /**
+ * Evaluates to false if ANY of the passed in matchers evaluate to true.
+ *
+ * @factory ...
+ */
+ public static function noneOf(/* args... */)
+ {
+ $args = func_get_args();
+
+ return IsNot::not(
+ new self(Util::createMatcherArray($args))
+ );
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/CombinableMatcher.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/CombinableMatcher.php
new file mode 100644
index 0000000..e3b4aa7
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/CombinableMatcher.php
@@ -0,0 +1,78 @@
+_matcher = $matcher;
+ }
+
+ public function matches($item)
+ {
+ return $this->_matcher->matches($item);
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description->appendDescriptionOf($this->_matcher);
+ }
+
+ /** Diversion from Hamcrest-Java... Logical "and" not permitted */
+ public function andAlso(Matcher $other)
+ {
+ return new self(new AllOf($this->_templatedListWith($other)));
+ }
+
+ /** Diversion from Hamcrest-Java... Logical "or" not permitted */
+ public function orElse(Matcher $other)
+ {
+ return new self(new AnyOf($this->_templatedListWith($other)));
+ }
+
+ /**
+ * This is useful for fluently combining matchers that must both pass.
+ * For example:
+ *
+ * assertThat($string, both(containsString("a"))->andAlso(containsString("b")));
+ *
+ *
+ * @factory
+ */
+ public static function both(Matcher $matcher)
+ {
+ return new self($matcher);
+ }
+
+ /**
+ * This is useful for fluently combining matchers where either may pass,
+ * for example:
+ *
+ * assertThat($string, either(containsString("a"))->orElse(containsString("b")));
+ *
+ *
+ * @factory
+ */
+ public static function either(Matcher $matcher)
+ {
+ return new self($matcher);
+ }
+
+ // -- Private Methods
+
+ private function _templatedListWith(Matcher $other)
+ {
+ return array($this->_matcher, $other);
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/DescribedAs.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/DescribedAs.php
new file mode 100644
index 0000000..5b2583f
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/DescribedAs.php
@@ -0,0 +1,68 @@
+_descriptionTemplate = $descriptionTemplate;
+ $this->_matcher = $matcher;
+ $this->_values = $values;
+ }
+
+ public function matches($item)
+ {
+ return $this->_matcher->matches($item);
+ }
+
+ public function describeTo(Description $description)
+ {
+ $textStart = 0;
+ while (preg_match(self::ARG_PATTERN, $this->_descriptionTemplate, $matches, PREG_OFFSET_CAPTURE, $textStart)) {
+ $text = $matches[0][0];
+ $index = $matches[1][0];
+ $offset = $matches[0][1];
+
+ $description->appendText(substr($this->_descriptionTemplate, $textStart, $offset - $textStart));
+ $description->appendValue($this->_values[$index]);
+
+ $textStart = $offset + strlen($text);
+ }
+
+ if ($textStart < strlen($this->_descriptionTemplate)) {
+ $description->appendText(substr($this->_descriptionTemplate, $textStart));
+ }
+ }
+
+ /**
+ * Wraps an existing matcher and overrides the description when it fails.
+ *
+ * @factory ...
+ */
+ public static function describedAs(/* $description, Hamcrest\Matcher $matcher, $values... */)
+ {
+ $args = func_get_args();
+ $description = array_shift($args);
+ $matcher = array_shift($args);
+ $values = $args;
+
+ return new self($description, $matcher, $values);
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/Every.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/Every.php
new file mode 100644
index 0000000..d686f8d
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/Every.php
@@ -0,0 +1,56 @@
+_matcher = $matcher;
+ }
+
+ protected function matchesSafelyWithDiagnosticDescription($items, Description $mismatchDescription)
+ {
+ foreach ($items as $item) {
+ if (!$this->_matcher->matches($item)) {
+ $mismatchDescription->appendText('an item ');
+ $this->_matcher->describeMismatch($item, $mismatchDescription);
+
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description->appendText('every item is ')->appendDescriptionOf($this->_matcher);
+ }
+
+ /**
+ * @param Matcher $itemMatcher
+ * A matcher to apply to every element in an array.
+ *
+ * @return \Hamcrest\Core\Every
+ * Evaluates to TRUE for a collection in which every item matches $itemMatcher
+ *
+ * @factory
+ */
+ public static function everyItem(Matcher $itemMatcher)
+ {
+ return new self($itemMatcher);
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/HasToString.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/HasToString.php
new file mode 100644
index 0000000..45bd910
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/HasToString.php
@@ -0,0 +1,56 @@
+toString();
+ }
+
+ return (string) $actual;
+ }
+
+ /**
+ * Does array size satisfy a given matcher?
+ *
+ * @factory
+ */
+ public static function hasToString($matcher)
+ {
+ return new self(Util::wrapValueWithIsEqual($matcher));
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/Is.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/Is.php
new file mode 100644
index 0000000..41266dc
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/Is.php
@@ -0,0 +1,57 @@
+_matcher = $matcher;
+ }
+
+ public function matches($arg)
+ {
+ return $this->_matcher->matches($arg);
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description->appendText('is ')->appendDescriptionOf($this->_matcher);
+ }
+
+ public function describeMismatch($item, Description $mismatchDescription)
+ {
+ $this->_matcher->describeMismatch($item, $mismatchDescription);
+ }
+
+ /**
+ * Decorates another Matcher, retaining the behavior but allowing tests
+ * to be slightly more expressive.
+ *
+ * For example: assertThat($cheese, equalTo($smelly))
+ * vs. assertThat($cheese, is(equalTo($smelly)))
+ *
+ * @factory
+ */
+ public static function is($value)
+ {
+ return new self(Util::wrapValueWithIsEqual($value));
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/IsAnything.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/IsAnything.php
new file mode 100644
index 0000000..f20e6c0
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/IsAnything.php
@@ -0,0 +1,45 @@
+true.
+ */
+class IsAnything extends BaseMatcher
+{
+
+ private $_message;
+
+ public function __construct($message = 'ANYTHING')
+ {
+ $this->_message = $message;
+ }
+
+ public function matches($item)
+ {
+ return true;
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description->appendText($this->_message);
+ }
+
+ /**
+ * This matcher always evaluates to true.
+ *
+ * @param string $description A meaningful string used when describing itself.
+ *
+ * @return \Hamcrest\Core\IsAnything
+ * @factory
+ */
+ public static function anything($description = 'ANYTHING')
+ {
+ return new self($description);
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/IsCollectionContaining.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/IsCollectionContaining.php
new file mode 100644
index 0000000..5e60426
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/IsCollectionContaining.php
@@ -0,0 +1,93 @@
+_elementMatcher = $elementMatcher;
+ }
+
+ protected function matchesSafely($items)
+ {
+ foreach ($items as $item) {
+ if ($this->_elementMatcher->matches($item)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ protected function describeMismatchSafely($items, Description $mismatchDescription)
+ {
+ $mismatchDescription->appendText('was ')->appendValue($items);
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description
+ ->appendText('a collection containing ')
+ ->appendDescriptionOf($this->_elementMatcher)
+ ;
+ }
+
+ /**
+ * Test if the value is an array containing this matcher.
+ *
+ * Example:
+ *
+ * assertThat(array('a', 'b'), hasItem(equalTo('b')));
+ * //Convenience defaults to equalTo()
+ * assertThat(array('a', 'b'), hasItem('b'));
+ *
+ *
+ * @factory ...
+ */
+ public static function hasItem()
+ {
+ $args = func_get_args();
+ $firstArg = array_shift($args);
+
+ return new self(Util::wrapValueWithIsEqual($firstArg));
+ }
+
+ /**
+ * Test if the value is an array containing elements that match all of these
+ * matchers.
+ *
+ * Example:
+ *
+ * assertThat(array('a', 'b', 'c'), hasItems(equalTo('a'), equalTo('b')));
+ *
+ *
+ * @factory ...
+ */
+ public static function hasItems(/* args... */)
+ {
+ $args = func_get_args();
+ $matchers = array();
+
+ foreach ($args as $arg) {
+ $matchers[] = self::hasItem($arg);
+ }
+
+ return AllOf::allOf($matchers);
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/IsEqual.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/IsEqual.php
new file mode 100644
index 0000000..523fba0
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/IsEqual.php
@@ -0,0 +1,44 @@
+_item = $item;
+ }
+
+ public function matches($arg)
+ {
+ return (($arg == $this->_item) && ($this->_item == $arg));
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description->appendValue($this->_item);
+ }
+
+ /**
+ * Is the value equal to another value, as tested by the use of the "=="
+ * comparison operator?
+ *
+ * @factory
+ */
+ public static function equalTo($item)
+ {
+ return new self($item);
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/IsIdentical.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/IsIdentical.php
new file mode 100644
index 0000000..28f7b36
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/IsIdentical.php
@@ -0,0 +1,38 @@
+_value = $value;
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description->appendValue($this->_value);
+ }
+
+ /**
+ * Tests of the value is identical to $value as tested by the "===" operator.
+ *
+ * @factory
+ */
+ public static function identicalTo($value)
+ {
+ return new self($value);
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/IsInstanceOf.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/IsInstanceOf.php
new file mode 100644
index 0000000..7a5c92a
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/IsInstanceOf.php
@@ -0,0 +1,67 @@
+_theClass = $theClass;
+ }
+
+ protected function matchesWithDiagnosticDescription($item, Description $mismatchDescription)
+ {
+ if (!is_object($item)) {
+ $mismatchDescription->appendText('was ')->appendValue($item);
+
+ return false;
+ }
+
+ if (!($item instanceof $this->_theClass)) {
+ $mismatchDescription->appendText('[' . get_class($item) . '] ')
+ ->appendValue($item);
+
+ return false;
+ }
+
+ return true;
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description->appendText('an instance of ')
+ ->appendText($this->_theClass)
+ ;
+ }
+
+ /**
+ * Is the value an instance of a particular type?
+ * This version assumes no relationship between the required type and
+ * the signature of the method that sets it up, for example in
+ * assertThat($anObject, anInstanceOf('Thing'));
+ *
+ * @factory any
+ */
+ public static function anInstanceOf($theClass)
+ {
+ return new self($theClass);
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/IsNot.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/IsNot.php
new file mode 100644
index 0000000..167f0d0
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/IsNot.php
@@ -0,0 +1,44 @@
+_matcher = $matcher;
+ }
+
+ public function matches($arg)
+ {
+ return !$this->_matcher->matches($arg);
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description->appendText('not ')->appendDescriptionOf($this->_matcher);
+ }
+
+ /**
+ * Matches if value does not match $value.
+ *
+ * @factory
+ */
+ public static function not($value)
+ {
+ return new self(Util::wrapValueWithIsEqual($value));
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/IsNull.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/IsNull.php
new file mode 100644
index 0000000..91a454c
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/IsNull.php
@@ -0,0 +1,56 @@
+appendText('null');
+ }
+
+ /**
+ * Matches if value is null.
+ *
+ * @factory
+ */
+ public static function nullValue()
+ {
+ if (!self::$_INSTANCE) {
+ self::$_INSTANCE = new self();
+ }
+
+ return self::$_INSTANCE;
+ }
+
+ /**
+ * Matches if value is not null.
+ *
+ * @factory
+ */
+ public static function notNullValue()
+ {
+ if (!self::$_NOT_INSTANCE) {
+ self::$_NOT_INSTANCE = IsNot::not(self::nullValue());
+ }
+
+ return self::$_NOT_INSTANCE;
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/IsSame.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/IsSame.php
new file mode 100644
index 0000000..8107870
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/IsSame.php
@@ -0,0 +1,51 @@
+_object = $object;
+ }
+
+ public function matches($object)
+ {
+ return ($object === $this->_object) && ($this->_object === $object);
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description->appendText('sameInstance(')
+ ->appendValue($this->_object)
+ ->appendText(')')
+ ;
+ }
+
+ /**
+ * Creates a new instance of IsSame.
+ *
+ * @param mixed $object
+ * The predicate evaluates to true only when the argument is
+ * this object.
+ *
+ * @return \Hamcrest\Core\IsSame
+ * @factory
+ */
+ public static function sameInstance($object)
+ {
+ return new self($object);
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/IsTypeOf.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/IsTypeOf.php
new file mode 100644
index 0000000..d24f0f9
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/IsTypeOf.php
@@ -0,0 +1,71 @@
+_theType = strtolower($theType);
+ }
+
+ public function matches($item)
+ {
+ return strtolower(gettype($item)) == $this->_theType;
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description->appendText(self::getTypeDescription($this->_theType));
+ }
+
+ public function describeMismatch($item, Description $description)
+ {
+ if ($item === null) {
+ $description->appendText('was null');
+ } else {
+ $description->appendText('was ')
+ ->appendText(self::getTypeDescription(strtolower(gettype($item))))
+ ->appendText(' ')
+ ->appendValue($item)
+ ;
+ }
+ }
+
+ public static function getTypeDescription($type)
+ {
+ if ($type == 'null') {
+ return 'null';
+ }
+
+ return (strpos('aeiou', substr($type, 0, 1)) === false ? 'a ' : 'an ')
+ . $type;
+ }
+
+ /**
+ * Is the value a particular built-in type?
+ *
+ * @factory
+ */
+ public static function typeOf($theType)
+ {
+ return new self($theType);
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/Set.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/Set.php
new file mode 100644
index 0000000..cdc45d5
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/Set.php
@@ -0,0 +1,95 @@
+
+ * assertThat(array('a', 'b'), set('b'));
+ * assertThat($foo, set('bar'));
+ * assertThat('Server', notSet('defaultPort'));
+ *
+ *
+ * @todo Replace $property with a matcher and iterate all property names.
+ */
+class Set extends BaseMatcher
+{
+
+ private $_property;
+ private $_not;
+
+ public function __construct($property, $not = false)
+ {
+ $this->_property = $property;
+ $this->_not = $not;
+ }
+
+ public function matches($item)
+ {
+ if ($item === null) {
+ return false;
+ }
+ $property = $this->_property;
+ if (is_array($item)) {
+ $result = isset($item[$property]);
+ } elseif (is_object($item)) {
+ $result = isset($item->$property);
+ } elseif (is_string($item)) {
+ $result = isset($item::$$property);
+ } else {
+ throw new \InvalidArgumentException('Must pass an object, array, or class name');
+ }
+
+ return $this->_not ? !$result : $result;
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description->appendText($this->_not ? 'unset property ' : 'set property ')->appendText($this->_property);
+ }
+
+ public function describeMismatch($item, Description $description)
+ {
+ $value = '';
+ if (!$this->_not) {
+ $description->appendText('was not set');
+ } else {
+ $property = $this->_property;
+ if (is_array($item)) {
+ $value = $item[$property];
+ } elseif (is_object($item)) {
+ $value = $item->$property;
+ } elseif (is_string($item)) {
+ $value = $item::$$property;
+ }
+ parent::describeMismatch($value, $description);
+ }
+ }
+
+ /**
+ * Matches if value (class, object, or array) has named $property.
+ *
+ * @factory
+ */
+ public static function set($property)
+ {
+ return new self($property);
+ }
+
+ /**
+ * Matches if value (class, object, or array) does not have named $property.
+ *
+ * @factory
+ */
+ public static function notSet($property)
+ {
+ return new self($property, true);
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/ShortcutCombination.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/ShortcutCombination.php
new file mode 100644
index 0000000..d93db74
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Core/ShortcutCombination.php
@@ -0,0 +1,43 @@
+
+ */
+ private $_matchers;
+
+ public function __construct(array $matchers)
+ {
+ Util::checkAllAreMatchers($matchers);
+
+ $this->_matchers = $matchers;
+ }
+
+ protected function matchesWithShortcut($item, $shortcut)
+ {
+ /** @var $matcher \Hamcrest\Matcher */
+ foreach ($this->_matchers as $matcher) {
+ if ($matcher->matches($item) == $shortcut) {
+ return $shortcut;
+ }
+ }
+
+ return !$shortcut;
+ }
+
+ public function describeToWithOperator(Description $description, $operator)
+ {
+ $description->appendList('(', ' ' . $operator . ' ', ')', $this->_matchers);
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Description.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Description.php
new file mode 100644
index 0000000..266bc1c
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Description.php
@@ -0,0 +1,70 @@
+matchesWithDiagnosticDescription($item, new NullDescription());
+ }
+
+ public function describeMismatch($item, Description $mismatchDescription)
+ {
+ $this->matchesWithDiagnosticDescription($item, $mismatchDescription);
+ }
+
+ abstract protected function matchesWithDiagnosticDescription($item, Description $mismatchDescription);
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/FeatureMatcher.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/FeatureMatcher.php
new file mode 100644
index 0000000..59f6cc7
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/FeatureMatcher.php
@@ -0,0 +1,67 @@
+featureValueOf() in a subclass to pull out the feature to be
+ * matched against.
+ */
+abstract class FeatureMatcher extends TypeSafeDiagnosingMatcher
+{
+
+ private $_subMatcher;
+ private $_featureDescription;
+ private $_featureName;
+
+ /**
+ * Constructor.
+ *
+ * @param string $type
+ * @param string $subtype
+ * @param \Hamcrest\Matcher $subMatcher The matcher to apply to the feature
+ * @param string $featureDescription Descriptive text to use in describeTo
+ * @param string $featureName Identifying text for mismatch message
+ */
+ public function __construct($type, $subtype, Matcher $subMatcher, $featureDescription, $featureName)
+ {
+ parent::__construct($type, $subtype);
+
+ $this->_subMatcher = $subMatcher;
+ $this->_featureDescription = $featureDescription;
+ $this->_featureName = $featureName;
+ }
+
+ /**
+ * Implement this to extract the interesting feature.
+ *
+ * @param mixed $actual the target object
+ *
+ * @return mixed the feature to be matched
+ */
+ abstract protected function featureValueOf($actual);
+
+ public function matchesSafelyWithDiagnosticDescription($actual, Description $mismatchDescription)
+ {
+ $featureValue = $this->featureValueOf($actual);
+
+ if (!$this->_subMatcher->matches($featureValue)) {
+ $mismatchDescription->appendText($this->_featureName)
+ ->appendText(' was ')->appendValue($featureValue);
+
+ return false;
+ }
+
+ return true;
+ }
+
+ final public function describeTo(Description $description)
+ {
+ $description->appendText($this->_featureDescription)->appendText(' ')
+ ->appendDescriptionOf($this->_subMatcher)
+ ;
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Internal/SelfDescribingValue.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Internal/SelfDescribingValue.php
new file mode 100644
index 0000000..995da71
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Internal/SelfDescribingValue.php
@@ -0,0 +1,27 @@
+_value = $value;
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description->appendValue($this->_value);
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Matcher.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Matcher.php
new file mode 100644
index 0000000..e5dcf09
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Matcher.php
@@ -0,0 +1,50 @@
+
+ * Matcher implementations should NOT directly implement this interface .
+ * Instead, extend the {@link Hamcrest\BaseMatcher} abstract class,
+ * which will ensure that the Matcher API can grow to support
+ * new features and remain compatible with all Matcher implementations.
+ *
+ * For easy access to common Matcher implementations, use the static factory
+ * methods in {@link Hamcrest\CoreMatchers}.
+ *
+ * @see Hamcrest\CoreMatchers
+ * @see Hamcrest\BaseMatcher
+ */
+interface Matcher extends SelfDescribing
+{
+
+ /**
+ * Evaluates the matcher for argument $item .
+ *
+ * @param mixed $item the object against which the matcher is evaluated.
+ *
+ * @return boolean true if $item matches,
+ * otherwise false.
+ *
+ * @see Hamcrest\BaseMatcher
+ */
+ public function matches($item);
+
+ /**
+ * Generate a description of why the matcher has not accepted the item.
+ * The description will be part of a larger description of why a matching
+ * failed, so it should be concise.
+ * This method assumes that matches($item) is false, but
+ * will not check this.
+ *
+ * @param mixed $item The item that the Matcher has rejected.
+ * @param Description $description
+ * @return
+ */
+ public function describeMismatch($item, Description $description);
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/MatcherAssert.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/MatcherAssert.php
new file mode 100644
index 0000000..d546dbe
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/MatcherAssert.php
@@ -0,0 +1,118 @@
+
+ * // With an identifier
+ * assertThat("apple flavour", $apple->flavour(), equalTo("tasty"));
+ * // Without an identifier
+ * assertThat($apple->flavour(), equalTo("tasty"));
+ * // Evaluating a boolean expression
+ * assertThat("some error", $a > $b);
+ * assertThat($a > $b);
+ *
+ */
+ public static function assertThat(/* $args ... */)
+ {
+ $args = func_get_args();
+ switch (count($args)) {
+ case 1:
+ self::$_count++;
+ if (!$args[0]) {
+ throw new AssertionError();
+ }
+ break;
+
+ case 2:
+ self::$_count++;
+ if ($args[1] instanceof Matcher) {
+ self::doAssert('', $args[0], $args[1]);
+ } elseif (!$args[1]) {
+ throw new AssertionError($args[0]);
+ }
+ break;
+
+ case 3:
+ self::$_count++;
+ self::doAssert(
+ $args[0],
+ $args[1],
+ Util::wrapValueWithIsEqual($args[2])
+ );
+ break;
+
+ default:
+ throw new \InvalidArgumentException('assertThat() requires one to three arguments');
+ }
+ }
+
+ /**
+ * Returns the number of assertions performed.
+ *
+ * @return int
+ */
+ public static function getCount()
+ {
+ return self::$_count;
+ }
+
+ /**
+ * Resets the number of assertions performed to zero.
+ */
+ public static function resetCount()
+ {
+ self::$_count = 0;
+ }
+
+ /**
+ * Performs the actual assertion logic.
+ *
+ * If $matcher doesn't match $actual,
+ * throws a {@link Hamcrest\AssertionError} with a description
+ * of the failure along with the optional $identifier.
+ *
+ * @param string $identifier added to the message upon failure
+ * @param mixed $actual value to compare against $matcher
+ * @param \Hamcrest\Matcher $matcher applied to $actual
+ * @throws AssertionError
+ */
+ private static function doAssert($identifier, $actual, Matcher $matcher)
+ {
+ if (!$matcher->matches($actual)) {
+ $description = new StringDescription();
+ if (!empty($identifier)) {
+ $description->appendText($identifier . PHP_EOL);
+ }
+ $description->appendText('Expected: ')
+ ->appendDescriptionOf($matcher)
+ ->appendText(PHP_EOL . ' but: ');
+
+ $matcher->describeMismatch($actual, $description);
+
+ throw new AssertionError((string) $description);
+ }
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Matchers.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Matchers.php
new file mode 100644
index 0000000..23232e4
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Matchers.php
@@ -0,0 +1,713 @@
+
+ * assertThat($string, both(containsString("a"))->andAlso(containsString("b")));
+ *
+ */
+ public static function both(\Hamcrest\Matcher $matcher)
+ {
+ return \Hamcrest\Core\CombinableMatcher::both($matcher);
+ }
+
+ /**
+ * This is useful for fluently combining matchers where either may pass,
+ * for example:
+ *
+ * assertThat($string, either(containsString("a"))->orElse(containsString("b")));
+ *
+ */
+ public static function either(\Hamcrest\Matcher $matcher)
+ {
+ return \Hamcrest\Core\CombinableMatcher::either($matcher);
+ }
+
+ /**
+ * Wraps an existing matcher and overrides the description when it fails.
+ */
+ public static function describedAs(/* args... */)
+ {
+ $args = func_get_args();
+ return call_user_func_array(array('\Hamcrest\Core\DescribedAs', 'describedAs'), $args);
+ }
+
+ /**
+ * @param Matcher $itemMatcher
+ * A matcher to apply to every element in an array.
+ *
+ * @return \Hamcrest\Core\Every
+ * Evaluates to TRUE for a collection in which every item matches $itemMatcher
+ */
+ public static function everyItem(\Hamcrest\Matcher $itemMatcher)
+ {
+ return \Hamcrest\Core\Every::everyItem($itemMatcher);
+ }
+
+ /**
+ * Does array size satisfy a given matcher?
+ */
+ public static function hasToString($matcher)
+ {
+ return \Hamcrest\Core\HasToString::hasToString($matcher);
+ }
+
+ /**
+ * Decorates another Matcher, retaining the behavior but allowing tests
+ * to be slightly more expressive.
+ *
+ * For example: assertThat($cheese, equalTo($smelly))
+ * vs. assertThat($cheese, is(equalTo($smelly)))
+ */
+ public static function is($value)
+ {
+ return \Hamcrest\Core\Is::is($value);
+ }
+
+ /**
+ * This matcher always evaluates to true.
+ *
+ * @param string $description A meaningful string used when describing itself.
+ *
+ * @return \Hamcrest\Core\IsAnything
+ */
+ public static function anything($description = 'ANYTHING')
+ {
+ return \Hamcrest\Core\IsAnything::anything($description);
+ }
+
+ /**
+ * Test if the value is an array containing this matcher.
+ *
+ * Example:
+ *
+ * assertThat(array('a', 'b'), hasItem(equalTo('b')));
+ * //Convenience defaults to equalTo()
+ * assertThat(array('a', 'b'), hasItem('b'));
+ *
+ */
+ public static function hasItem(/* args... */)
+ {
+ $args = func_get_args();
+ return call_user_func_array(array('\Hamcrest\Core\IsCollectionContaining', 'hasItem'), $args);
+ }
+
+ /**
+ * Test if the value is an array containing elements that match all of these
+ * matchers.
+ *
+ * Example:
+ *
+ * assertThat(array('a', 'b', 'c'), hasItems(equalTo('a'), equalTo('b')));
+ *
+ */
+ public static function hasItems(/* args... */)
+ {
+ $args = func_get_args();
+ return call_user_func_array(array('\Hamcrest\Core\IsCollectionContaining', 'hasItems'), $args);
+ }
+
+ /**
+ * Is the value equal to another value, as tested by the use of the "=="
+ * comparison operator?
+ */
+ public static function equalTo($item)
+ {
+ return \Hamcrest\Core\IsEqual::equalTo($item);
+ }
+
+ /**
+ * Tests of the value is identical to $value as tested by the "===" operator.
+ */
+ public static function identicalTo($value)
+ {
+ return \Hamcrest\Core\IsIdentical::identicalTo($value);
+ }
+
+ /**
+ * Is the value an instance of a particular type?
+ * This version assumes no relationship between the required type and
+ * the signature of the method that sets it up, for example in
+ * assertThat($anObject, anInstanceOf('Thing'));
+ */
+ public static function anInstanceOf($theClass)
+ {
+ return \Hamcrest\Core\IsInstanceOf::anInstanceOf($theClass);
+ }
+
+ /**
+ * Is the value an instance of a particular type?
+ * This version assumes no relationship between the required type and
+ * the signature of the method that sets it up, for example in
+ * assertThat($anObject, anInstanceOf('Thing'));
+ */
+ public static function any($theClass)
+ {
+ return \Hamcrest\Core\IsInstanceOf::anInstanceOf($theClass);
+ }
+
+ /**
+ * Matches if value does not match $value.
+ */
+ public static function not($value)
+ {
+ return \Hamcrest\Core\IsNot::not($value);
+ }
+
+ /**
+ * Matches if value is null.
+ */
+ public static function nullValue()
+ {
+ return \Hamcrest\Core\IsNull::nullValue();
+ }
+
+ /**
+ * Matches if value is not null.
+ */
+ public static function notNullValue()
+ {
+ return \Hamcrest\Core\IsNull::notNullValue();
+ }
+
+ /**
+ * Creates a new instance of IsSame.
+ *
+ * @param mixed $object
+ * The predicate evaluates to true only when the argument is
+ * this object.
+ *
+ * @return \Hamcrest\Core\IsSame
+ */
+ public static function sameInstance($object)
+ {
+ return \Hamcrest\Core\IsSame::sameInstance($object);
+ }
+
+ /**
+ * Is the value a particular built-in type?
+ */
+ public static function typeOf($theType)
+ {
+ return \Hamcrest\Core\IsTypeOf::typeOf($theType);
+ }
+
+ /**
+ * Matches if value (class, object, or array) has named $property.
+ */
+ public static function set($property)
+ {
+ return \Hamcrest\Core\Set::set($property);
+ }
+
+ /**
+ * Matches if value (class, object, or array) does not have named $property.
+ */
+ public static function notSet($property)
+ {
+ return \Hamcrest\Core\Set::notSet($property);
+ }
+
+ /**
+ * Matches if value is a number equal to $value within some range of
+ * acceptable error $delta.
+ */
+ public static function closeTo($value, $delta)
+ {
+ return \Hamcrest\Number\IsCloseTo::closeTo($value, $delta);
+ }
+
+ /**
+ * The value is not > $value, nor < $value.
+ */
+ public static function comparesEqualTo($value)
+ {
+ return \Hamcrest\Number\OrderingComparison::comparesEqualTo($value);
+ }
+
+ /**
+ * The value is > $value.
+ */
+ public static function greaterThan($value)
+ {
+ return \Hamcrest\Number\OrderingComparison::greaterThan($value);
+ }
+
+ /**
+ * The value is >= $value.
+ */
+ public static function greaterThanOrEqualTo($value)
+ {
+ return \Hamcrest\Number\OrderingComparison::greaterThanOrEqualTo($value);
+ }
+
+ /**
+ * The value is >= $value.
+ */
+ public static function atLeast($value)
+ {
+ return \Hamcrest\Number\OrderingComparison::greaterThanOrEqualTo($value);
+ }
+
+ /**
+ * The value is < $value.
+ */
+ public static function lessThan($value)
+ {
+ return \Hamcrest\Number\OrderingComparison::lessThan($value);
+ }
+
+ /**
+ * The value is <= $value.
+ */
+ public static function lessThanOrEqualTo($value)
+ {
+ return \Hamcrest\Number\OrderingComparison::lessThanOrEqualTo($value);
+ }
+
+ /**
+ * The value is <= $value.
+ */
+ public static function atMost($value)
+ {
+ return \Hamcrest\Number\OrderingComparison::lessThanOrEqualTo($value);
+ }
+
+ /**
+ * Matches if value is a zero-length string.
+ */
+ public static function isEmptyString()
+ {
+ return \Hamcrest\Text\IsEmptyString::isEmptyString();
+ }
+
+ /**
+ * Matches if value is a zero-length string.
+ */
+ public static function emptyString()
+ {
+ return \Hamcrest\Text\IsEmptyString::isEmptyString();
+ }
+
+ /**
+ * Matches if value is null or a zero-length string.
+ */
+ public static function isEmptyOrNullString()
+ {
+ return \Hamcrest\Text\IsEmptyString::isEmptyOrNullString();
+ }
+
+ /**
+ * Matches if value is null or a zero-length string.
+ */
+ public static function nullOrEmptyString()
+ {
+ return \Hamcrest\Text\IsEmptyString::isEmptyOrNullString();
+ }
+
+ /**
+ * Matches if value is a non-zero-length string.
+ */
+ public static function isNonEmptyString()
+ {
+ return \Hamcrest\Text\IsEmptyString::isNonEmptyString();
+ }
+
+ /**
+ * Matches if value is a non-zero-length string.
+ */
+ public static function nonEmptyString()
+ {
+ return \Hamcrest\Text\IsEmptyString::isNonEmptyString();
+ }
+
+ /**
+ * Matches if value is a string equal to $string, regardless of the case.
+ */
+ public static function equalToIgnoringCase($string)
+ {
+ return \Hamcrest\Text\IsEqualIgnoringCase::equalToIgnoringCase($string);
+ }
+
+ /**
+ * Matches if value is a string equal to $string, regardless of whitespace.
+ */
+ public static function equalToIgnoringWhiteSpace($string)
+ {
+ return \Hamcrest\Text\IsEqualIgnoringWhiteSpace::equalToIgnoringWhiteSpace($string);
+ }
+
+ /**
+ * Matches if value is a string that matches regular expression $pattern.
+ */
+ public static function matchesPattern($pattern)
+ {
+ return \Hamcrest\Text\MatchesPattern::matchesPattern($pattern);
+ }
+
+ /**
+ * Matches if value is a string that contains $substring.
+ */
+ public static function containsString($substring)
+ {
+ return \Hamcrest\Text\StringContains::containsString($substring);
+ }
+
+ /**
+ * Matches if value is a string that contains $substring regardless of the case.
+ */
+ public static function containsStringIgnoringCase($substring)
+ {
+ return \Hamcrest\Text\StringContainsIgnoringCase::containsStringIgnoringCase($substring);
+ }
+
+ /**
+ * Matches if value contains $substrings in a constrained order.
+ */
+ public static function stringContainsInOrder(/* args... */)
+ {
+ $args = func_get_args();
+ return call_user_func_array(array('\Hamcrest\Text\StringContainsInOrder', 'stringContainsInOrder'), $args);
+ }
+
+ /**
+ * Matches if value is a string that ends with $substring.
+ */
+ public static function endsWith($substring)
+ {
+ return \Hamcrest\Text\StringEndsWith::endsWith($substring);
+ }
+
+ /**
+ * Matches if value is a string that starts with $substring.
+ */
+ public static function startsWith($substring)
+ {
+ return \Hamcrest\Text\StringStartsWith::startsWith($substring);
+ }
+
+ /**
+ * Is the value an array?
+ */
+ public static function arrayValue()
+ {
+ return \Hamcrest\Type\IsArray::arrayValue();
+ }
+
+ /**
+ * Is the value a boolean?
+ */
+ public static function booleanValue()
+ {
+ return \Hamcrest\Type\IsBoolean::booleanValue();
+ }
+
+ /**
+ * Is the value a boolean?
+ */
+ public static function boolValue()
+ {
+ return \Hamcrest\Type\IsBoolean::booleanValue();
+ }
+
+ /**
+ * Is the value callable?
+ */
+ public static function callableValue()
+ {
+ return \Hamcrest\Type\IsCallable::callableValue();
+ }
+
+ /**
+ * Is the value a float/double?
+ */
+ public static function doubleValue()
+ {
+ return \Hamcrest\Type\IsDouble::doubleValue();
+ }
+
+ /**
+ * Is the value a float/double?
+ */
+ public static function floatValue()
+ {
+ return \Hamcrest\Type\IsDouble::doubleValue();
+ }
+
+ /**
+ * Is the value an integer?
+ */
+ public static function integerValue()
+ {
+ return \Hamcrest\Type\IsInteger::integerValue();
+ }
+
+ /**
+ * Is the value an integer?
+ */
+ public static function intValue()
+ {
+ return \Hamcrest\Type\IsInteger::integerValue();
+ }
+
+ /**
+ * Is the value a numeric?
+ */
+ public static function numericValue()
+ {
+ return \Hamcrest\Type\IsNumeric::numericValue();
+ }
+
+ /**
+ * Is the value an object?
+ */
+ public static function objectValue()
+ {
+ return \Hamcrest\Type\IsObject::objectValue();
+ }
+
+ /**
+ * Is the value an object?
+ */
+ public static function anObject()
+ {
+ return \Hamcrest\Type\IsObject::objectValue();
+ }
+
+ /**
+ * Is the value a resource?
+ */
+ public static function resourceValue()
+ {
+ return \Hamcrest\Type\IsResource::resourceValue();
+ }
+
+ /**
+ * Is the value a scalar (boolean, integer, double, or string)?
+ */
+ public static function scalarValue()
+ {
+ return \Hamcrest\Type\IsScalar::scalarValue();
+ }
+
+ /**
+ * Is the value a string?
+ */
+ public static function stringValue()
+ {
+ return \Hamcrest\Type\IsString::stringValue();
+ }
+
+ /**
+ * Wraps $matcher with {@link Hamcrest\Core\IsEqual)
+ * if it's not a matcher and the XPath in count()
+ * if it's an integer.
+ */
+ public static function hasXPath($xpath, $matcher = null)
+ {
+ return \Hamcrest\Xml\HasXPath::hasXPath($xpath, $matcher);
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/NullDescription.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/NullDescription.php
new file mode 100644
index 0000000..aae8e46
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/NullDescription.php
@@ -0,0 +1,43 @@
+_value = $value;
+ $this->_delta = $delta;
+ }
+
+ protected function matchesSafely($item)
+ {
+ return $this->_actualDelta($item) <= 0.0;
+ }
+
+ protected function describeMismatchSafely($item, Description $mismatchDescription)
+ {
+ $mismatchDescription->appendValue($item)
+ ->appendText(' differed by ')
+ ->appendValue($this->_actualDelta($item))
+ ;
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description->appendText('a numeric value within ')
+ ->appendValue($this->_delta)
+ ->appendText(' of ')
+ ->appendValue($this->_value)
+ ;
+ }
+
+ /**
+ * Matches if value is a number equal to $value within some range of
+ * acceptable error $delta.
+ *
+ * @factory
+ */
+ public static function closeTo($value, $delta)
+ {
+ return new self($value, $delta);
+ }
+
+ // -- Private Methods
+
+ private function _actualDelta($item)
+ {
+ return (abs(($item - $this->_value)) - $this->_delta);
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Number/OrderingComparison.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Number/OrderingComparison.php
new file mode 100644
index 0000000..369d0cf
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Number/OrderingComparison.php
@@ -0,0 +1,132 @@
+_value = $value;
+ $this->_minCompare = $minCompare;
+ $this->_maxCompare = $maxCompare;
+ }
+
+ protected function matchesSafely($other)
+ {
+ $compare = $this->_compare($this->_value, $other);
+
+ return ($this->_minCompare <= $compare) && ($compare <= $this->_maxCompare);
+ }
+
+ protected function describeMismatchSafely($item, Description $mismatchDescription)
+ {
+ $mismatchDescription
+ ->appendValue($item)->appendText(' was ')
+ ->appendText($this->_comparison($this->_compare($this->_value, $item)))
+ ->appendText(' ')->appendValue($this->_value)
+ ;
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description->appendText('a value ')
+ ->appendText($this->_comparison($this->_minCompare))
+ ;
+ if ($this->_minCompare != $this->_maxCompare) {
+ $description->appendText(' or ')
+ ->appendText($this->_comparison($this->_maxCompare))
+ ;
+ }
+ $description->appendText(' ')->appendValue($this->_value);
+ }
+
+ /**
+ * The value is not > $value, nor < $value.
+ *
+ * @factory
+ */
+ public static function comparesEqualTo($value)
+ {
+ return new self($value, 0, 0);
+ }
+
+ /**
+ * The value is > $value.
+ *
+ * @factory
+ */
+ public static function greaterThan($value)
+ {
+ return new self($value, -1, -1);
+ }
+
+ /**
+ * The value is >= $value.
+ *
+ * @factory atLeast
+ */
+ public static function greaterThanOrEqualTo($value)
+ {
+ return new self($value, -1, 0);
+ }
+
+ /**
+ * The value is < $value.
+ *
+ * @factory
+ */
+ public static function lessThan($value)
+ {
+ return new self($value, 1, 1);
+ }
+
+ /**
+ * The value is <= $value.
+ *
+ * @factory atMost
+ */
+ public static function lessThanOrEqualTo($value)
+ {
+ return new self($value, 0, 1);
+ }
+
+ // -- Private Methods
+
+ private function _compare($left, $right)
+ {
+ $a = $left;
+ $b = $right;
+
+ if ($a < $b) {
+ return -1;
+ } elseif ($a == $b) {
+ return 0;
+ } else {
+ return 1;
+ }
+ }
+
+ private function _comparison($compare)
+ {
+ if ($compare > 0) {
+ return 'less than';
+ } elseif ($compare == 0) {
+ return 'equal to';
+ } else {
+ return 'greater than';
+ }
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/SelfDescribing.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/SelfDescribing.php
new file mode 100644
index 0000000..872fdf9
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/SelfDescribing.php
@@ -0,0 +1,23 @@
+_out = (string) $out;
+ }
+
+ public function __toString()
+ {
+ return $this->_out;
+ }
+
+ /**
+ * Return the description of a {@link Hamcrest\SelfDescribing} object as a
+ * String.
+ *
+ * @param \Hamcrest\SelfDescribing $selfDescribing
+ * The object to be described.
+ *
+ * @return string
+ * The description of the object.
+ */
+ public static function toString(SelfDescribing $selfDescribing)
+ {
+ $self = new self();
+
+ return (string) $self->appendDescriptionOf($selfDescribing);
+ }
+
+ /**
+ * Alias for {@link toString()}.
+ */
+ public static function asString(SelfDescribing $selfDescribing)
+ {
+ return self::toString($selfDescribing);
+ }
+
+ // -- Protected Methods
+
+ protected function append($str)
+ {
+ $this->_out .= $str;
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/IsEmptyString.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/IsEmptyString.php
new file mode 100644
index 0000000..2ae61b9
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/IsEmptyString.php
@@ -0,0 +1,85 @@
+_empty = $empty;
+ }
+
+ public function matches($item)
+ {
+ return $this->_empty
+ ? ($item === '')
+ : is_string($item) && $item !== '';
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description->appendText($this->_empty ? 'an empty string' : 'a non-empty string');
+ }
+
+ /**
+ * Matches if value is a zero-length string.
+ *
+ * @factory emptyString
+ */
+ public static function isEmptyString()
+ {
+ if (!self::$_INSTANCE) {
+ self::$_INSTANCE = new self(true);
+ }
+
+ return self::$_INSTANCE;
+ }
+
+ /**
+ * Matches if value is null or a zero-length string.
+ *
+ * @factory nullOrEmptyString
+ */
+ public static function isEmptyOrNullString()
+ {
+ if (!self::$_NULL_OR_EMPTY_INSTANCE) {
+ self::$_NULL_OR_EMPTY_INSTANCE = AnyOf::anyOf(
+ IsNull::nullvalue(),
+ self::isEmptyString()
+ );
+ }
+
+ return self::$_NULL_OR_EMPTY_INSTANCE;
+ }
+
+ /**
+ * Matches if value is a non-zero-length string.
+ *
+ * @factory nonEmptyString
+ */
+ public static function isNonEmptyString()
+ {
+ if (!self::$_NOT_INSTANCE) {
+ self::$_NOT_INSTANCE = new self(false);
+ }
+
+ return self::$_NOT_INSTANCE;
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/IsEqualIgnoringCase.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/IsEqualIgnoringCase.php
new file mode 100644
index 0000000..3836a8c
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/IsEqualIgnoringCase.php
@@ -0,0 +1,52 @@
+_string = $string;
+ }
+
+ protected function matchesSafely($item)
+ {
+ return strtolower($this->_string) === strtolower($item);
+ }
+
+ protected function describeMismatchSafely($item, Description $mismatchDescription)
+ {
+ $mismatchDescription->appendText('was ')->appendText($item);
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description->appendText('equalToIgnoringCase(')
+ ->appendValue($this->_string)
+ ->appendText(')')
+ ;
+ }
+
+ /**
+ * Matches if value is a string equal to $string, regardless of the case.
+ *
+ * @factory
+ */
+ public static function equalToIgnoringCase($string)
+ {
+ return new self($string);
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/IsEqualIgnoringWhiteSpace.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/IsEqualIgnoringWhiteSpace.php
new file mode 100644
index 0000000..853692b
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/IsEqualIgnoringWhiteSpace.php
@@ -0,0 +1,66 @@
+_string = $string;
+ }
+
+ protected function matchesSafely($item)
+ {
+ return (strtolower($this->_stripSpace($item))
+ === strtolower($this->_stripSpace($this->_string)));
+ }
+
+ protected function describeMismatchSafely($item, Description $mismatchDescription)
+ {
+ $mismatchDescription->appendText('was ')->appendText($item);
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description->appendText('equalToIgnoringWhiteSpace(')
+ ->appendValue($this->_string)
+ ->appendText(')')
+ ;
+ }
+
+ /**
+ * Matches if value is a string equal to $string, regardless of whitespace.
+ *
+ * @factory
+ */
+ public static function equalToIgnoringWhiteSpace($string)
+ {
+ return new self($string);
+ }
+
+ // -- Private Methods
+
+ private function _stripSpace($string)
+ {
+ $parts = preg_split("/[\r\n\t ]+/", $string);
+ foreach ($parts as $i => $part) {
+ $parts[$i] = trim($part, " \r\n\t");
+ }
+
+ return trim(implode(' ', $parts), " \r\n\t");
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/MatchesPattern.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/MatchesPattern.php
new file mode 100644
index 0000000..fa0d68e
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/MatchesPattern.php
@@ -0,0 +1,40 @@
+_substring, (string) $item) >= 1;
+ }
+
+ protected function relationship()
+ {
+ return 'matching';
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/StringContains.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/StringContains.php
new file mode 100644
index 0000000..b92786b
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/StringContains.php
@@ -0,0 +1,45 @@
+_substring);
+ }
+
+ /**
+ * Matches if value is a string that contains $substring.
+ *
+ * @factory
+ */
+ public static function containsString($substring)
+ {
+ return new self($substring);
+ }
+
+ // -- Protected Methods
+
+ protected function evalSubstringOf($item)
+ {
+ return (false !== strpos((string) $item, $this->_substring));
+ }
+
+ protected function relationship()
+ {
+ return 'containing';
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/StringContainsIgnoringCase.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/StringContainsIgnoringCase.php
new file mode 100644
index 0000000..69f37c2
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/StringContainsIgnoringCase.php
@@ -0,0 +1,40 @@
+_substring));
+ }
+
+ protected function relationship()
+ {
+ return 'containing in any case';
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/StringContainsInOrder.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/StringContainsInOrder.php
new file mode 100644
index 0000000..e75de65
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/StringContainsInOrder.php
@@ -0,0 +1,66 @@
+_substrings = $substrings;
+ }
+
+ protected function matchesSafely($item)
+ {
+ $fromIndex = 0;
+
+ foreach ($this->_substrings as $substring) {
+ if (false === $fromIndex = strpos($item, $substring, $fromIndex)) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ protected function describeMismatchSafely($item, Description $mismatchDescription)
+ {
+ $mismatchDescription->appendText('was ')->appendText($item);
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description->appendText('a string containing ')
+ ->appendValueList('', ', ', '', $this->_substrings)
+ ->appendText(' in order')
+ ;
+ }
+
+ /**
+ * Matches if value contains $substrings in a constrained order.
+ *
+ * @factory ...
+ */
+ public static function stringContainsInOrder(/* args... */)
+ {
+ $args = func_get_args();
+
+ if (isset($args[0]) && is_array($args[0])) {
+ $args = $args[0];
+ }
+
+ return new self($args);
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/StringEndsWith.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/StringEndsWith.php
new file mode 100644
index 0000000..f802ee4
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/StringEndsWith.php
@@ -0,0 +1,40 @@
+_substring))) === $this->_substring);
+ }
+
+ protected function relationship()
+ {
+ return 'ending with';
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/StringStartsWith.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/StringStartsWith.php
new file mode 100644
index 0000000..79c9565
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/StringStartsWith.php
@@ -0,0 +1,40 @@
+_substring)) === $this->_substring);
+ }
+
+ protected function relationship()
+ {
+ return 'starting with';
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/SubstringMatcher.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/SubstringMatcher.php
new file mode 100644
index 0000000..e560ad6
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Text/SubstringMatcher.php
@@ -0,0 +1,45 @@
+_substring = $substring;
+ }
+
+ protected function matchesSafely($item)
+ {
+ return $this->evalSubstringOf($item);
+ }
+
+ protected function describeMismatchSafely($item, Description $mismatchDescription)
+ {
+ $mismatchDescription->appendText('was "')->appendText($item)->appendText('"');
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description->appendText('a string ')
+ ->appendText($this->relationship())
+ ->appendText(' ')
+ ->appendValue($this->_substring)
+ ;
+ }
+
+ abstract protected function evalSubstringOf($string);
+
+ abstract protected function relationship();
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Type/IsArray.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Type/IsArray.php
new file mode 100644
index 0000000..9179102
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Type/IsArray.php
@@ -0,0 +1,32 @@
+isHexadecimal($item)) {
+ return true;
+ }
+
+ return is_numeric($item);
+ }
+
+ /**
+ * Return if the string passed is a valid hexadecimal number.
+ * This check is necessary because PHP 7 doesn't recognize hexadecimal string as numeric anymore.
+ *
+ * @param mixed $item
+ * @return boolean
+ */
+ private function isHexadecimal($item)
+ {
+ if (is_string($item) && preg_match('/^0x(.*)$/', $item, $matches)) {
+ return ctype_xdigit($matches[1]);
+ }
+
+ return false;
+ }
+
+ /**
+ * Is the value a numeric?
+ *
+ * @factory
+ */
+ public static function numericValue()
+ {
+ return new self;
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Type/IsObject.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Type/IsObject.php
new file mode 100644
index 0000000..65918fc
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Type/IsObject.php
@@ -0,0 +1,32 @@
+matchesSafelyWithDiagnosticDescription($item, new NullDescription());
+ }
+
+ final public function describeMismatchSafely($item, Description $mismatchDescription)
+ {
+ $this->matchesSafelyWithDiagnosticDescription($item, $mismatchDescription);
+ }
+
+ // -- Protected Methods
+
+ /**
+ * Subclasses should implement these. The item will already have been checked for
+ * the specific type.
+ */
+ abstract protected function matchesSafelyWithDiagnosticDescription($item, Description $mismatchDescription);
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/TypeSafeMatcher.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/TypeSafeMatcher.php
new file mode 100644
index 0000000..56e299a
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/TypeSafeMatcher.php
@@ -0,0 +1,107 @@
+_expectedType = $expectedType;
+ $this->_expectedSubtype = $expectedSubtype;
+ }
+
+ final public function matches($item)
+ {
+ return $this->_isSafeType($item) && $this->matchesSafely($item);
+ }
+
+ final public function describeMismatch($item, Description $mismatchDescription)
+ {
+ if (!$this->_isSafeType($item)) {
+ parent::describeMismatch($item, $mismatchDescription);
+ } else {
+ $this->describeMismatchSafely($item, $mismatchDescription);
+ }
+ }
+
+ // -- Protected Methods
+
+ /**
+ * The item will already have been checked for the specific type and subtype.
+ */
+ abstract protected function matchesSafely($item);
+
+ /**
+ * The item will already have been checked for the specific type and subtype.
+ */
+ abstract protected function describeMismatchSafely($item, Description $mismatchDescription);
+
+ // -- Private Methods
+
+ private function _isSafeType($value)
+ {
+ switch ($this->_expectedType) {
+
+ case self::TYPE_ANY:
+ return true;
+
+ case self::TYPE_STRING:
+ return is_string($value) || is_numeric($value);
+
+ case self::TYPE_NUMERIC:
+ return is_numeric($value) || is_string($value);
+
+ case self::TYPE_ARRAY:
+ return is_array($value);
+
+ case self::TYPE_OBJECT:
+ return is_object($value)
+ && ($this->_expectedSubtype === null
+ || $value instanceof $this->_expectedSubtype);
+
+ case self::TYPE_RESOURCE:
+ return is_resource($value)
+ && ($this->_expectedSubtype === null
+ || get_resource_type($value) == $this->_expectedSubtype);
+
+ case self::TYPE_BOOLEAN:
+ return true;
+
+ default:
+ return true;
+
+ }
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Util.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Util.php
new file mode 100644
index 0000000..169b036
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Util.php
@@ -0,0 +1,76 @@
+ all items are
+ */
+ public static function createMatcherArray(array $items)
+ {
+ //Extract single array item
+ if (count($items) == 1 && is_array($items[0])) {
+ $items = $items[0];
+ }
+
+ //Replace non-matchers
+ foreach ($items as &$item) {
+ if (!($item instanceof Matcher)) {
+ $item = Core\IsEqual::equalTo($item);
+ }
+ }
+
+ return $items;
+ }
+}
diff --git a/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Xml/HasXPath.php b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Xml/HasXPath.php
new file mode 100644
index 0000000..bedf969
--- /dev/null
+++ b/vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest/Xml/HasXPath.php
@@ -0,0 +1,195 @@
+_xpath = $xpath;
+ $this->_matcher = $matcher;
+ }
+
+ /**
+ * Matches if the XPath matches against the DOM node and the matcher.
+ *
+ * @param string|\DOMNode $actual
+ * @param Description $mismatchDescription
+ * @return bool
+ */
+ protected function matchesWithDiagnosticDescription($actual, Description $mismatchDescription)
+ {
+ if (is_string($actual)) {
+ $actual = $this->createDocument($actual);
+ } elseif (!$actual instanceof \DOMNode) {
+ $mismatchDescription->appendText('was ')->appendValue($actual);
+
+ return false;
+ }
+ $result = $this->evaluate($actual);
+ if ($result instanceof \DOMNodeList) {
+ return $this->matchesContent($result, $mismatchDescription);
+ } else {
+ return $this->matchesExpression($result, $mismatchDescription);
+ }
+ }
+
+ /**
+ * Creates and returns a DOMDocument from the given
+ * XML or HTML string.
+ *
+ * @param string $text
+ * @return \DOMDocument built from $text
+ * @throws \InvalidArgumentException if the document is not valid
+ */
+ protected function createDocument($text)
+ {
+ $document = new \DOMDocument();
+ if (preg_match('/^\s*<\?xml/', $text)) {
+ if (!@$document->loadXML($text)) {
+ throw new \InvalidArgumentException('Must pass a valid XML document');
+ }
+ } else {
+ if (!@$document->loadHTML($text)) {
+ throw new \InvalidArgumentException('Must pass a valid HTML or XHTML document');
+ }
+ }
+
+ return $document;
+ }
+
+ /**
+ * Applies the configured XPath to the DOM node and returns either
+ * the result if it's an expression or the node list if it's a query.
+ *
+ * @param \DOMNode $node context from which to issue query
+ * @return mixed result of expression or DOMNodeList from query
+ */
+ protected function evaluate(\DOMNode $node)
+ {
+ if ($node instanceof \DOMDocument) {
+ $xpathDocument = new \DOMXPath($node);
+
+ return $xpathDocument->evaluate($this->_xpath);
+ } else {
+ $xpathDocument = new \DOMXPath($node->ownerDocument);
+
+ return $xpathDocument->evaluate($this->_xpath, $node);
+ }
+ }
+
+ /**
+ * Matches if the list of nodes is not empty and the content of at least
+ * one node matches the configured matcher, if supplied.
+ *
+ * @param \DOMNodeList $nodes selected by the XPath query
+ * @param Description $mismatchDescription
+ * @return bool
+ */
+ protected function matchesContent(\DOMNodeList $nodes, Description $mismatchDescription)
+ {
+ if ($nodes->length == 0) {
+ $mismatchDescription->appendText('XPath returned no results');
+ } elseif ($this->_matcher === null) {
+ return true;
+ } else {
+ foreach ($nodes as $node) {
+ if ($this->_matcher->matches($node->textContent)) {
+ return true;
+ }
+ }
+ $content = array();
+ foreach ($nodes as $node) {
+ $content[] = $node->textContent;
+ }
+ $mismatchDescription->appendText('XPath returned ')
+ ->appendValue($content);
+ }
+
+ return false;
+ }
+
+ /**
+ * Matches if the result of the XPath expression matches the configured
+ * matcher or evaluates to true if there is none.
+ *
+ * @param mixed $result result of the XPath expression
+ * @param Description $mismatchDescription
+ * @return bool
+ */
+ protected function matchesExpression($result, Description $mismatchDescription)
+ {
+ if ($this->_matcher === null) {
+ if ($result) {
+ return true;
+ }
+ $mismatchDescription->appendText('XPath expression result was ')
+ ->appendValue($result);
+ } else {
+ if ($this->_matcher->matches($result)) {
+ return true;
+ }
+ $mismatchDescription->appendText('XPath expression result ');
+ $this->_matcher->describeMismatch($result, $mismatchDescription);
+ }
+
+ return false;
+ }
+
+ public function describeTo(Description $description)
+ {
+ $description->appendText('XML or HTML document with XPath "')
+ ->appendText($this->_xpath)
+ ->appendText('"');
+ if ($this->_matcher !== null) {
+ $description->appendText(' ');
+ $this->_matcher->describeTo($description);
+ }
+ }
+
+ /**
+ * Wraps $matcher with {@link Hamcrest\Core\IsEqual)
+ * if it's not a matcher and the XPath in count()
+ * if it's an integer.
+ *
+ * @factory
+ */
+ public static function hasXPath($xpath, $matcher = null)
+ {
+ if ($matcher === null || $matcher instanceof Matcher) {
+ return new self($xpath, $matcher);
+ } elseif (is_int($matcher) && strpos($xpath, 'count(') !== 0) {
+ $xpath = 'count(' . $xpath . ')';
+ }
+
+ return new self($xpath, IsEqual::equalTo($matcher));
+ }
+}
diff --git a/vendor/mockery/mockery/.phpstorm.meta.php b/vendor/mockery/mockery/.phpstorm.meta.php
new file mode 100644
index 0000000..bb7acee
--- /dev/null
+++ b/vendor/mockery/mockery/.phpstorm.meta.php
@@ -0,0 +1,11 @@
+ "@"]));
+override(\Mockery::spy(0), map(["" => "@"]));
+override(\Mockery::namedMock(0), map(["" => "@"]));
+override(\Mockery::instanceMock(0), map(["" => "@"]));
+override(\mock(0), map(["" => "@"]));
+override(\spy(0), map(["" => "@"]));
+override(\namedMock(0), map(["" => "@"]));
\ No newline at end of file
diff --git a/vendor/mockery/mockery/.readthedocs.yml b/vendor/mockery/mockery/.readthedocs.yml
new file mode 100644
index 0000000..7150d7b
--- /dev/null
+++ b/vendor/mockery/mockery/.readthedocs.yml
@@ -0,0 +1,24 @@
+# Read the Docs configuration file for Sphinx projects
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+# Set the OS, Python version and other tools we might need
+build:
+ os: ubuntu-22.04
+ tools:
+ python: "3.12"
+
+# Build documentation in the "docs/" directory with Sphinx
+sphinx:
+ configuration: docs/conf.py
+
+# Build documentation in additional formats such as PDF and ePub
+formats: all
+
+# Build requirements for our documentation
+# See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html
+python:
+ install:
+ - requirements: docs/requirements.txt
diff --git a/vendor/mockery/mockery/CHANGELOG.md b/vendor/mockery/mockery/CHANGELOG.md
new file mode 100644
index 0000000..2180be2
--- /dev/null
+++ b/vendor/mockery/mockery/CHANGELOG.md
@@ -0,0 +1,419 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [1.6.12] - 2024-05-15
+
+### Changed
+
+- [1420: Update `psalm-baseline.xml` ](https://github.com/mockery/mockery/pull/1420)
+- [1419: Update e2e-test.sh](https://github.com/mockery/mockery/pull/1419)
+- [1413: Upgrade `phar` tools and `phive.xml` configuration](https://github.com/mockery/mockery/pull/1413)
+
+### Fixed
+
+- [1415: Fix mocking anonymous classes](https://github.com/mockery/mockery/pull/1415)
+- [1411: Mocking final classes reports unresolvable type by PHPStan](https://github.com/mockery/mockery/issues/1411)
+- [1410: Fix PHP Doc Comments](https://github.com/mockery/mockery/pull/1410)
+
+### Security
+
+- [1417: Bump `Jinja2` from `3.1.3` to `3.1.4` fix CVE-2024-34064](https://github.com/mockery/mockery/pull/1417)
+- [1412: Bump `idna` from `3.6` to `3.7` fix CVE-2024-3651](https://github.com/mockery/mockery/pull/1412)
+
+## [1.6.11] - 2024-03-21
+
+### Fixed
+
+- [1407: Fix constants map generics doc comments](https://github.com/mockery/mockery/pull/1407)
+- [1406: Fix reserved words used to name a class, interface or trait](https://github.com/mockery/mockery/pull/1406)
+- [1403: Fix regression - partial construction with trait methods](https://github.com/mockery/mockery/pull/1403)
+- [1401: Improve `Mockery::mock()` parameter type compatibility with array typehints](https://github.com/mockery/mockery/pull/1401)
+
+## [1.6.10] - 2024-03-19
+
+### Added
+
+- [1398: [PHP 8.4] Fixes for implicit nullability deprecation](https://github.com/mockery/mockery/pull/1398)
+
+### Fixed
+
+- [1397: Fix mock method $args parameter type](https://github.com/mockery/mockery/pull/1397)
+- [1396: Fix `1.6.8` release](https://github.com/mockery/mockery/pull/1396)
+
+## [1.6.9] - 2024-03-12
+
+- [1394: Revert v1.6.8 release](https://github.com/mockery/mockery/pull/1394)
+
+## [1.6.8] - 2024-03-12
+
+- [1393: Changelog v1.6.8](https://github.com/mockery/mockery/pull/1393)
+- [1392: Refactor remaining codebase](https://github.com/mockery/mockery/pull/1392)
+- [1391: Update actions to use Node 20](https://github.com/mockery/mockery/pull/1391)
+- [1390: Update `ReadTheDocs` dependencies](https://github.com/mockery/mockery/pull/1390)
+- [1389: Refactor `library/Mockery/Matcher/*`](https://github.com/mockery/mockery/pull/1389)
+- [1388: Refactor `library/Mockery/Loader/*`](https://github.com/mockery/mockery/pull/1388)
+- [1387: Refactor `library/Mockery/CountValidator/*`](https://github.com/mockery/mockery/pull/1387)
+- [1386: Add PHPUnit 10+ attributes](https://github.com/mockery/mockery/pull/1386)
+- [1385: Update composer dependencies and clean up](https://github.com/mockery/mockery/pull/1385)
+- [1384: Update `psalm-baseline.xml`](https://github.com/mockery/mockery/pull/1384)
+- [1383: Refactor `library/helpers.php`](https://github.com/mockery/mockery/pull/1383)
+- [1382: Refactor `library/Mockery/VerificationExpectation.php`](https://github.com/mockery/mockery/pull/1382)
+- [1381: Refactor `library/Mockery/VerificationDirector.php`](https://github.com/mockery/mockery/pull/1381)
+- [1380: Refactor `library/Mockery/QuickDefinitionsConfiguration.php`](https://github.com/mockery/mockery/pull/1380)
+- [1379: Refactor `library/Mockery/Undefined.php`](https://github.com/mockery/mockery/pull/1379)
+- [1378: Refactor `library/Mockery/Reflector.php`](https://github.com/mockery/mockery/pull/1378)
+- [1377: Refactor `library/Mockery/ReceivedMethodCalls.php`](https://github.com/mockery/mockery/pull/1377)
+- [1376: Refactor `library/Mockery.php`](https://github.com/mockery/mockery/pull/1376)
+- [1375: Refactor `library/Mockery/MockInterface.php`](https://github.com/mockery/mockery/pull/1375)
+- [1374: Refactor `library/Mockery/MethodCall.php`](https://github.com/mockery/mockery/pull/1374)
+- [1373: Refactor `library/Mockery/LegacyMockInterface.php`](https://github.com/mockery/mockery/pull/1373)
+- [1372: Refactor `library/Mockery/Instantiator.php`](https://github.com/mockery/mockery/pull/1372)
+- [1371: Refactor `library/Mockery/HigherOrderMessage.php`](https://github.com/mockery/mockery/pull/1371)
+- [1370: Refactor `library/Mockery/ExpectsHigherOrderMessage.php`](https://github.com/mockery/mockery/pull/1370)
+- [1369: Refactor `library/Mockery/ExpectationInterface.php`](https://github.com/mockery/mockery/pull/1369)
+- [1368: Refactor `library/Mockery/ExpectationDirector.php`](https://github.com/mockery/mockery/pull/1368)
+- [1367: Refactor `library/Mockery/Expectation.php`](https://github.com/mockery/mockery/pull/1367)
+- [1366: Refactor `library/Mockery/Exception.php`](https://github.com/mockery/mockery/pull/1366)
+- [1365: Refactor `library/Mockery/Container.php`](https://github.com/mockery/mockery/pull/1365)
+- [1364: Refactor `library/Mockery/Configuration.php`](https://github.com/mockery/mockery/pull/1364)
+- [1363: Refactor `library/Mockery/CompositeExpectation.php`](https://github.com/mockery/mockery/pull/1363)
+- [1362: Refactor `library/Mockery/ClosureWrapper.php`](https://github.com/mockery/mockery/pull/1362)
+- [1361: Refactor `library/Mockery.php`](https://github.com/mockery/mockery/pull/1361)
+- [1360: Refactor Container](https://github.com/mockery/mockery/pull/1360)
+- [1355: Fix the namespace in the SubsetTest class](https://github.com/mockery/mockery/pull/1355)
+- [1354: Add array-like objects support to hasKey/hasValue matchers](https://github.com/mockery/mockery/pull/1354)
+
+## [1.6.7] - 2023-12-09
+
+### Added
+
+- [#1338: Support PHPUnit constraints as matchers](https://github.com/mockery/mockery/pull/1338)
+- [#1336: Add factory methods for `IsEqual` and `IsSame` matchers](https://github.com/mockery/mockery/pull/1336)
+
+### Fixed
+
+- [#1346: Fix test namespaces](https://github.com/mockery/mockery/pull/1346)
+- [#1343: Update documentation default theme and build version](https://github.com/mockery/mockery/pull/1343)
+- [#1329: Prevent `shouldNotReceive` from getting overridden by invocation count methods](https://github.com/mockery/mockery/pull/1329)
+
+### Changed
+
+- [#1351: Update psalm-baseline.xml](https://github.com/mockery/mockery/pull/1351)
+- [#1350: Changelog v1.6.7](https://github.com/mockery/mockery/pull/1350)
+- [#1349: Cleanup](https://github.com/mockery/mockery/pull/1349)
+- [#1348: Update makefile](https://github.com/mockery/mockery/pull/1348)
+- [#1347: Bump phars dependencies](https://github.com/mockery/mockery/pull/1347)
+- [#1344: Disabled travis-ci and sensiolabs webhooks](https://github.com/mockery/mockery/issues/1344)
+- [#1342: Add `.readthedocs.yml` configuration](https://github.com/mockery/mockery/pull/1342)
+- [#1340: docs: Remove misplaced semicolumn from code snippet](https://github.com/mockery/mockery/pull/1340)
+
+## 1.6.6 (2023-08-08)
+
+- [#1327: Changelog v1.6.6](https://github.com/mockery/mockery/pull/1327)
+- [#1325: Keep the file that caused an error for inspection](https://github.com/mockery/mockery/pull/1325)
+- [#1324: Fix Regression - Replace `+` Array Union Operator with `array_merge`](https://github.com/mockery/mockery/pull/1324)
+
+## 1.6.5 (2023-08-05)
+
+- [#1322: Changelog v1.6.5](https://github.com/mockery/mockery/pull/1322)
+- [#1321: Autoload Test Fixtures Based on PHP Runtime Version](https://github.com/mockery/mockery/pull/1321)
+- [#1320: Clean up mocks on destruct](https://github.com/mockery/mockery/pull/1320)
+- [#1318: Fix misspelling in docs](https://github.com/mockery/mockery/pull/1318)
+- [#1316: Fix compatibility issues with PHP 7.3](https://github.com/mockery/mockery/pull/1316)
+- [#1315: Fix PHP 7.3 issues](https://github.com/mockery/mockery/issues/1315)
+- [#1314: Add Security Policy](https://github.com/mockery/mockery/pull/1314)
+- [#1313: Type declaration for `iterable|object`.](https://github.com/mockery/mockery/pull/1313)
+- [#1312: Mock disjunctive normal form types](https://github.com/mockery/mockery/pull/1312)
+- [#1299: Test PHP `8.3` language features](https://github.com/mockery/mockery/pull/1299)
+
+## 1.6.4 (2023-07-19)
+
+- [#1308: Changelog v1.6.4](https://github.com/mockery/mockery/pull/1308)
+- [#1307: Revert `src` to `library` for `1.6.x`](https://github.com/mockery/mockery/pull/1307)
+
+## 1.6.3 (2023-07-18)
+
+- [#1304: Remove `extra.branch-alias` and update composer information](https://github.com/mockery/mockery/pull/1304)
+- [#1303: Update `.gitattributes`](https://github.com/mockery/mockery/pull/1303)
+- [#1302: Changelog v1.6.3](https://github.com/mockery/mockery/pull/1302)
+- [#1301: Fix mocking classes with `new` initializers in method and attribute params on PHP 8.1](https://github.com/mockery/mockery/pull/1301)
+- [#1298: Update default repository branch to latest release branch](https://github.com/mockery/mockery/issues/1298)
+- [#1297: Update `Makefile` for contributors](https://github.com/mockery/mockery/pull/1297)
+- [#1294: Correct return types of Mock for phpstan](https://github.com/mockery/mockery/pull/1294)
+- [#1290: Rename directory `library` to `src`](https://github.com/mockery/mockery/pull/1290)
+- [#1288: Update codecov workflow](https://github.com/mockery/mockery/pull/1288)
+- [#1287: Update psalm configuration and workflow](https://github.com/mockery/mockery/pull/1287)
+- [#1286: Update phpunit workflow](https://github.com/mockery/mockery/pull/1286)
+- [#1285: Enforce the minimum required PHP version](https://github.com/mockery/mockery/pull/1285)
+- [#1283: Update license and copyright information](https://github.com/mockery/mockery/pull/1283)
+- [#1282: Create `COPYRIGHT.md` file](https://github.com/mockery/mockery/pull/1282)
+- [#1279: Bump `vimeo/psalm` from `5.9.0` to `5.12.0`](https://github.com/mockery/mockery/pull/1279)
+
+## 1.6.2 (2023-06-07)
+
+- [#1276: Add `IsEqual` Argument Matcher](https://github.com/mockery/mockery/pull/1276)
+- [#1275: Add `IsSame` Argument Matcher](https://github.com/mockery/mockery/pull/1275)
+- [#1274: Update composer branch alias](https://github.com/mockery/mockery/pull/1274)
+- [#1271: Support PHP 8.2 `true` Literal Type](https://github.com/mockery/mockery/pull/1271)
+- [#1270: Support PHP 8.0 `false` Literal Type](https://github.com/mockery/mockery/pull/1270)
+
+## 1.6.1 (2023-06-05)
+
+- [#1267 Drops support for PHP <7.4](https://github.com/mockery/mockery/pull/1267)
+- [#1192 Updated changelog for version 1.5.1 to include changes from #1180](https://github.com/mockery/mockery/pull/1192)
+- [#1196 Update example in README.md](https://github.com/mockery/mockery/pull/1196)
+- [#1199 Fix function parameter default enum value](https://github.com/mockery/mockery/pull/1199)
+- [#1205 Deal with null type in PHP8.2](https://github.com/mockery/mockery/pull/1205)
+- [#1208 Import MockeryTestCase fully qualified class name](https://github.com/mockery/mockery/pull/1208)
+- [#1210 Add support for target class attributes](https://github.com/mockery/mockery/pull/1210)
+- [#1212 docs: Add missing comma](https://github.com/mockery/mockery/pull/1212)
+- [#1216 Fixes code generation for intersection types](https://github.com/mockery/mockery/pull/1216)
+- [#1217 Add MockeryExceptionInterface](https://github.com/mockery/mockery/pull/1217)
+- [#1218 tidy: avoids require](https://github.com/mockery/mockery/pull/1218)
+- [#1222 Add .editorconfig](https://github.com/mockery/mockery/pull/1222)
+- [#1225 Switch to PSR-4 autoload](https://github.com/mockery/mockery/pull/1225)
+- [#1226 Refactoring risky tests](https://github.com/mockery/mockery/pull/1226)
+- [#1230 Add vimeo/psalm and psalm/plugin-phpunit](https://github.com/mockery/mockery/pull/1230)
+- [#1232 Split PHPUnit TestSuites for PHP 8.2](https://github.com/mockery/mockery/pull/1232)
+- [#1233 Bump actions/checkout to v3](https://github.com/mockery/mockery/pull/1233)
+- [#1234 Bump nick-invision/retry to v2](https://github.com/mockery/mockery/pull/1234)
+- [#1235 Setup Codecov for code coverage](https://github.com/mockery/mockery/pull/1235)
+- [#1236 Add Psalm CI Check](https://github.com/mockery/mockery/pull/1236)
+- [#1237 Unignore composer.lock file](https://github.com/mockery/mockery/pull/1237)
+- [#1239 Prevent CI run duplication](https://github.com/mockery/mockery/pull/1239)
+- [#1241 Add PHPUnit workflow for PHP 8.3](https://github.com/mockery/mockery/pull/1241)
+- [#1244 Improve ClassAttributesPass for Dynamic Properties](https://github.com/mockery/mockery/pull/1244)
+- [#1245 Deprecate hamcrest/hamcrest-php package](https://github.com/mockery/mockery/pull/1245)
+- [#1246 Add BUG_REPORT.yml Issue template](https://github.com/mockery/mockery/pull/1246)
+- [#1250 Deprecate PHP <=8.0](https://github.com/mockery/mockery/issues/1250)
+- [#1253 Prevent array to string conversion when serialising a Subset matcher](https://github.com/mockery/mockery/issues/1253)
+
+## 1.6.0 (2023-06-05) [DELETED]
+
+This tag was deleted due to a mistake with the composer.json PHP version
+constraint, see [#1266](https://github.com/mockery/mockery/issues/1266)
+
+## 1.3.6 (2022-09-07)
+
+- PHP 8.2 | Fix "Use of "parent" in callables is deprecated" notice #1169
+
+## 1.5.1 (2022-09-07)
+
+- [PHP 8.2] Various tests: explicitly declare properties #1170
+- [PHP 8.2] Fix "Use of "parent" in callables is deprecated" notice #1169
+- [PHP 8.1] Support intersection types #1164
+- Handle final `__toString` methods #1162
+- Only count assertions on expectations which can fail a test #1180
+
+## 1.5.0 (2022-01-20)
+
+- Override default call count expectations via expects() #1146
+- Mock methods with static return types #1157
+- Mock methods with mixed return type #1156
+- Mock classes with new in initializers on PHP 8.1 #1160
+- Removes redundant PHPUnitConstraint #1158
+
+## 1.4.4 (2021-09-13)
+
+- Fixes auto-generated return values #1144
+- Adds support for tentative types #1130
+- Fixes for PHP 8.1 Support (#1130 and #1140)
+- Add method that allows defining a set of arguments the mock should yield #1133
+- Added option to configure default matchers for objects `\Mockery::getConfiguration()->setDefaultMatcher($class, $matcherClass)` #1120
+
+## 1.3.5 (2021-09-13)
+
+- Fix auto-generated return values with union types #1143
+- Adds support for tentative types #1130
+- Fixes for PHP 8.1 Support (#1130 and #1140)
+- Add method that allows defining a set of arguments the mock should yield #1133
+- Added option to configure default matchers for objects `\Mockery::getConfiguration()->setDefaultMatcher($class, $matcherClass)` #1120
+
+## 1.4.3 (2021-02-24)
+
+- Fixes calls to fetchMock before initialisation #1113
+- Allow shouldIgnoreMissing() to behave in a recursive fashion #1097
+- Custom object formatters #766 (Needs Docs)
+- Fix crash on a union type including null #1106
+
+## 1.3.4 (2021-02-24)
+
+- Fixes calls to fetchMock before initialisation #1113
+- Fix crash on a union type including null #1106
+
+## 1.4.2 (2020-08-11)
+
+- Fix array to string conversion in ConstantsPass (#1086)
+- Fixed nullable PHP 8.0 union types (#1088, #1089)
+- Fixed support for PHP 8.0 parent type (#1088, #1089)
+- Fixed PHP 8.0 mixed type support (#1088, #1089)
+- Fixed PHP 8.0 union return types (#1088, #1089)
+
+## 1.4.1 (2020-07-09)
+
+- Allow quick definitions to use 'at least once' expectation
+ `\Mockery::getConfiguration()->getQuickDefinitions()->shouldBeCalledAtLeastOnce(true)` (#1056)
+- Added provisional support for PHP 8.0 (#1068, #1072,#1079)
+- Fix mocking methods with iterable return type without specifying a return value (#1075)
+
+## 1.3.3 (2020-08-11)
+
+- Fix array to string conversion in ConstantsPass (#1086)
+- Fixed nullable PHP 8.0 union types (#1088)
+- Fixed support for PHP 8.0 parent type (#1088)
+- Fixed PHP 8.0 mixed type support (#1088)
+- Fixed PHP 8.0 union return types (#1088)
+
+## 1.3.2 (2020-07-09)
+
+- Fix mocking with anonymous classes (#1039)
+- Fix andAnyOthers() to properly match earlier expectations (#1051)
+- Added provisional support for PHP 8.0 (#1068, #1072,#1079)
+- Fix mocking methods with iterable return type without specifying a return value (#1075)
+
+## 1.4.0 (2020-05-19)
+
+- Fix mocking with anonymous classes (#1039)
+- Fix andAnyOthers() to properly match earlier expectations (#1051)
+- Drops support for PHP < 7.3 and PHPUnit < 8 (#1059)
+
+## 1.3.1 (2019-12-26)
+
+- Revert improved exception debugging due to BC breaks (#1032)
+
+## 1.3.0 (2019-11-24)
+
+- Added capture `Mockery::capture` convenience matcher (#1020)
+- Added `andReturnArg` to echo back an argument passed to a an expectation (#992)
+- Improved exception debugging (#1000)
+- Fixed `andSet` to not reuse properties between mock objects (#1012)
+
+## 1.2.4 (2019-09-30)
+
+- Fix a bug introduced with previous release, for empty method definition lists (#1009)
+
+## 1.2.3 (2019-08-07)
+
+- Allow mocking classes that have allows and expects methods (#868)
+- Allow passing thru __call method in all mock types (experimental) (#969)
+- Add support for `!` to blacklist methods (#959)
+- Added `withSomeOfArgs` to partial match a list of args (#967)
+- Fix chained demeter calls with type hint (#956)
+
+## 1.2.2 (2019-02-13)
+
+- Fix a BC breaking change for PHP 5.6/PHPUnit 5.7.27 (#947)
+
+## 1.2.1 (2019-02-07)
+
+- Support for PHPUnit 8 (#942)
+- Allow mocking static methods called on instance (#938)
+
+## 1.2.0 (2018-10-02)
+
+- Starts counting default expectations towards count (#910)
+- Adds workaround for some HHVM return types (#909)
+- Adds PhpStorm metadata support for autocomplete etc (#904)
+- Further attempts to support multiple PHPUnit versions (#903)
+- Allows setting constructor expectations on instance mocks (#900)
+- Adds workaround for HHVM memoization decorator (#893)
+- Adds experimental support for callable spys (#712)
+
+## 1.1.0 (2018-05-08)
+
+- Allows use of string method names in allows and expects (#794)
+- Finalises allows and expects syntax in API (#799)
+- Search for handlers in a case instensitive way (#801)
+- Deprecate allowMockingMethodsUnnecessarily (#808)
+- Fix risky tests (#769)
+- Fix namespace in TestListener (#812)
+- Fixed conflicting mock names (#813)
+- Clean elses (#819)
+- Updated protected method mocking exception message (#826)
+- Map of constants to mock (#829)
+- Simplify foreach with `in_array` function (#830)
+- Typehinted return value on Expectation#verify. (#832)
+- Fix shouldNotHaveReceived with HigherOrderMessage (#842)
+- Deprecates shouldDeferMissing (#839)
+- Adds support for return type hints in Demeter chains (#848)
+- Adds shouldNotReceive to composite expectation (#847)
+- Fix internal error when using --static-backup (#845)
+- Adds `andAnyOtherArgs` as an optional argument matcher (#860)
+- Fixes namespace qualifying with namespaced named mocks (#872)
+- Added possibility to add Constructor-Expections on hard dependencies, read: Mockery::mock('overload:...') (#781)
+
+## 1.0.0 (2017-09-06)
+
+- Destructors (`__destruct`) are stubbed out where it makes sense
+- Allow passing a closure argument to `withArgs()` to validate multiple arguments at once.
+- `Mockery\Adapter\Phpunit\TestListener` has been rewritten because it
+ incorrectly marked some tests as risky. It will no longer verify mock
+ expectations but instead check that tests do that themselves. PHPUnit 6 is
+ required if you want to use this fail safe.
+- Removes SPL Class Loader
+- Removed object recorder feature
+- Bumped minimum PHP version to 5.6
+- `andThrow` will now throw anything `\Throwable`
+- Adds `allows` and `expects` syntax
+- Adds optional global helpers for `mock`, `namedMock` and `spy`
+- Adds ability to create objects using traits
+- `Mockery\Matcher\MustBe` was deprecated
+- Marked `Mockery\MockInterface` as internal
+- Subset matcher matches recursively
+- BC BREAK - Spies return `null` by default from ignored (non-mocked) methods with nullable return type
+- Removed extracting getter methods of object instances
+- BC BREAK - Remove implicit regex matching when trying to match string arguments, introduce `\Mockery::pattern()` when regex matching is needed
+- Fix Mockery not getting closed in cases of failing test cases
+- Fix Mockery not setting properties on overloaded instance mocks
+- BC BREAK - Fix Mockery not trying default expectations if there is any concrete expectation
+- BC BREAK - Mockery's PHPUnit integration will mark a test as risky if it
+ thinks one it's exceptions has been swallowed in PHPUnit > 5.7.6. Use `$e->dismiss()` to dismiss.
+
+## 0.9.4 (XXXX-XX-XX)
+
+- `shouldIgnoreMissing` will respect global `allowMockingNonExistentMethods`
+ config
+- Some support for variadic parameters
+- Hamcrest is now a required dependency
+- Instance mocks now respect `shouldIgnoreMissing` call on control instance
+- This will be the *last version to support PHP 5.3*
+- Added `Mockery\Adapter\Phpunit\MockeryPHPUnitIntegration` trait
+- Added `makePartial` to `Mockery\MockInterface` as it was missing
+
+## 0.9.3 (2014-12-22)
+
+- Added a basic spy implementation
+- Added `Mockery\Adapter\Phpunit\MockeryTestCase` for more reliable PHPUnit
+ integration
+
+## 0.9.2 (2014-09-03)
+
+- Some workarounds for the serialisation problems created by changes to PHP in 5.5.13, 5.4.29,
+ 5.6.
+- Demeter chains attempt to reuse doubles as they see fit, so for foo->bar and
+ foo->baz, we'll attempt to use the same foo
+
+## 0.9.1 (2014-05-02)
+
+- Allow specifying consecutive exceptions to be thrown with `andThrowExceptions`
+- Allow specifying methods which can be mocked when using
+ `Mockery\Configuration::allowMockingNonExistentMethods(false)` with
+ `Mockery\MockInterface::shouldAllowMockingMethod($methodName)`
+- Added andReturnSelf method: `$mock->shouldReceive("foo")->andReturnSelf()`
+- `shouldIgnoreMissing` now takes an optional value that will be return instead
+ of null, e.g. `$mock->shouldIgnoreMissing($mock)`
+
+## 0.9.0 (2014-02-05)
+
+- Allow mocking classes with final __wakeup() method
+- Quick definitions are now always `byDefault`
+- Allow mocking of protected methods with `shouldAllowMockingProtectedMethods`
+- Support official Hamcrest package
+- Generator completely rewritten
+- Easily create named mocks with namedMock
diff --git a/vendor/mockery/mockery/CONTRIBUTING.md b/vendor/mockery/mockery/CONTRIBUTING.md
new file mode 100644
index 0000000..d828fb3
--- /dev/null
+++ b/vendor/mockery/mockery/CONTRIBUTING.md
@@ -0,0 +1,82 @@
+# Contributing
+
+
+We'd love you to help out with mockery and no contribution is too small.
+
+
+## Reporting Bugs
+
+Issues can be reported on the [issue tracker](https://github.com/mockery/mockery/issues).
+Please try and report any bugs with a minimal reproducible example, it will make things easier for other
+contributors and your problems will hopefully be resolved quickly.
+
+
+## Requesting Features
+
+We're always interested to hear about your ideas and you can request features by
+creating a ticket in the [issue tracker](https://github.com/mockery/mockery/issues). We can't always guarantee
+someone will jump on it straight away, but putting it out there to see if anyone
+else is interested is a good idea.
+
+Likewise, if a feature you would like is already listed in
+the issue tracker, add a :+1: so that other contributors know it's a feature
+that would help others.
+
+
+## Contributing code and documentation
+
+We loosely follow the
+[PSR-1](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-1-basic-coding-standard.md)
+and
+[PSR-2](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-2-coding-style-guide.md) coding standards,
+but we'll probably merge any code that looks close enough.
+
+* Fork the [repository](https://github.com/mockery/mockery) on GitHub
+* Add the code for your feature or bug
+* Add some tests for your feature or bug
+* Optionally, but preferably, write some documentation
+* Optionally, update the CHANGELOG.md file with your feature or
+ [BC](http://en.wikipedia.org/wiki/Backward_compatibility) break
+* Send a [Pull Request](https://help.github.com/articles/creating-a-pull-request) to the
+ correct target branch (see below)
+
+If you have a big change or would like to discuss something, create an issue in
+the [issue tracker](https://github.com/mockery/mockery/issues) or jump in to \#mockery on freenode
+
+
+Any code you contribute must be licensed under the [BSD 3-Clause License](http://opensource.org/licenses/BSD-3-Clause).
+
+## Target Branch
+
+Mockery may have several active branches at any one time and roughly follows a
+[Git Branching Model](https://igor.io/2013/10/21/git-branching-model.html).
+Generally, if you're developing a new feature, you want to be targeting the
+master branch, if it's a bug fix, you want to be targeting a release branch,
+e.g. 0.8.
+
+
+## Testing Mockery
+
+To run the unit tests for Mockery, clone the git repository, download Composer using
+the instructions at [http://getcomposer.org/download/](http://getcomposer.org/download/),
+then install the dependencies with `php /path/to/composer.phar install`.
+
+This will install the required dev dependencies and create the
+autoload files required by the unit tests. You may run the `vendor/bin/phpunit` command
+to run the unit tests. If everything goes to plan, there will be no failed tests!
+
+
+## Debugging Mockery
+
+Mockery and its code generation can be difficult to debug. A good start is to
+use the `RequireLoader`, which will dump the code generated by mockery to a file
+before requiring it, rather than using eval. This will help with stack traces,
+and you will be able to open the mock class in your editor.
+
+``` php
+
+// tests/bootstrap.php
+
+Mockery::setLoader(new Mockery\Loader\RequireLoader(sys_get_temp_dir()));
+
+```
diff --git a/vendor/mockery/mockery/COPYRIGHT.md b/vendor/mockery/mockery/COPYRIGHT.md
new file mode 100644
index 0000000..b3b19bc
--- /dev/null
+++ b/vendor/mockery/mockery/COPYRIGHT.md
@@ -0,0 +1,7 @@
+# Copyright
+
+- Copyright (c) [2009](https://github.com/mockery/mockery/commit/1d96f88142abe804ab9e893a5f07933f63e9bff9), [Pádraic Brady](https://github.com/padraic)
+- Copyright (c) [2011](https://github.com/mockery/mockery/commit/94dbb63aab37c659f63ea6e34acc6958928b0f59), [Robert Basic](https://github.com/robertbasic)
+- Copyright (c) [2012](https://github.com/mockery/mockery/commit/64e3ad6960eb3202b5b91b91a4ef1cf6252f0fef), [Dave Marshall](https://github.com/davedevelopment)
+- Copyright (c) [2013](https://github.com/mockery/mockery/commit/270ddd0bd051251e36a5688c52fc2638a097b110), [Graham Campbell](https://github.com/GrahamCampbell)
+- Copyright (c) [2017](https://github.com/mockery/mockery/commit/ba28b84c416b95924886bbd64a6a2f68e863536a), [Nathanael Esayeas](https://github.com/ghostwriter)
diff --git a/vendor/mockery/mockery/LICENSE b/vendor/mockery/mockery/LICENSE
new file mode 100644
index 0000000..1a9030c
--- /dev/null
+++ b/vendor/mockery/mockery/LICENSE
@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2009-2023, Pádraic Brady
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/mockery/mockery/README.md b/vendor/mockery/mockery/README.md
new file mode 100644
index 0000000..2697734
--- /dev/null
+++ b/vendor/mockery/mockery/README.md
@@ -0,0 +1,294 @@
+Mockery
+=======
+
+[](https://github.com/mockery/mockery/actions)
+[](https://www.php.net/supported-versions)
+[](https://codecov.io/gh/mockery/mockery)
+[](https://shepherd.dev/github/mockery/mockery)
+[](https://packagist.org/packages/mockery/mockery)
+[](https://packagist.org/packages/mockery/mockery)
+
+Mockery is a simple yet flexible PHP mock object framework for use in unit testing
+with PHPUnit, PHPSpec or any other testing framework. Its core goal is to offer a
+test double framework with a succinct API capable of clearly defining all possible
+object operations and interactions using a human readable Domain Specific Language
+(DSL). Designed as a drop in alternative to PHPUnit's phpunit-mock-objects library,
+Mockery is easy to integrate with PHPUnit and can operate alongside
+phpunit-mock-objects without the World ending.
+
+Mockery is released under a New BSD License.
+
+## Installation
+
+To install Mockery, run the command below and you will get the latest
+version
+
+```sh
+composer require --dev mockery/mockery
+```
+
+## Documentation
+
+In older versions, this README file was the documentation for Mockery. Over time
+we have improved this, and have created an extensive documentation for you. Please
+use this README file as a starting point for Mockery, but do read the documentation
+to learn how to use Mockery.
+
+The current version can be seen at [docs.mockery.io](http://docs.mockery.io).
+
+## PHPUnit Integration
+
+Mockery ships with some helpers if you are using PHPUnit. You can extend the
+[`Mockery\Adapter\Phpunit\MockeryTestCase`](library/Mockery/Adapter/Phpunit/MockeryTestCase.php)
+class instead of `PHPUnit\Framework\TestCase`, or if you are already using a
+custom base class for your tests, take a look at the traits available in the
+[`Mockery\Adapter\Phpunit`](library/Mockery/Adapter/Phpunit) namespace.
+
+## Test Doubles
+
+Test doubles (often called mocks) simulate the behaviour of real objects. They are
+commonly utilised to offer test isolation, to stand in for objects which do not
+yet exist, or to allow for the exploratory design of class APIs without
+requiring actual implementation up front.
+
+The benefits of a test double framework are to allow for the flexible generation
+and configuration of test doubles. They allow the setting of expected method calls
+and/or return values using a flexible API which is capable of capturing every
+possible real object behaviour in way that is stated as close as possible to a
+natural language description. Use the `Mockery::mock` method to create a test
+double.
+
+``` php
+$double = Mockery::mock();
+```
+
+If you need Mockery to create a test double to satisfy a particular type hint,
+you can pass the type to the `mock` method.
+
+``` php
+class Book {}
+
+interface BookRepository {
+ function find($id): Book;
+ function findAll(): array;
+ function add(Book $book): void;
+}
+
+$double = Mockery::mock(BookRepository::class);
+```
+
+A detailed explanation of creating and working with test doubles is given in the
+documentation, [Creating test doubles](http://docs.mockery.io/en/latest/reference/creating_test_doubles.html)
+section.
+
+## Method Stubs 🎫
+
+A method stub is a mechanism for having your test double return canned responses
+to certain method calls. With stubs, you don't care how many times, if at all,
+the method is called. Stubs are used to provide indirect input to the system
+under test.
+
+``` php
+$double->allows()->find(123)->andReturns(new Book());
+
+$book = $double->find(123);
+```
+
+If you have used Mockery before, you might see something new in the example
+above — we created a method stub using `allows`, instead of the "old"
+`shouldReceive` syntax. This is a new feature of Mockery v1, but fear not,
+the trusty ol' `shouldReceive` is still here.
+
+For new users of Mockery, the above example can also be written as:
+
+``` php
+$double->shouldReceive('find')->with(123)->andReturn(new Book());
+$book = $double->find(123);
+```
+
+If your stub doesn't require specific arguments, you can also use this shortcut
+for setting up multiple calls at once:
+
+``` php
+$double->allows([
+ "findAll" => [new Book(), new Book()],
+]);
+```
+
+or
+
+``` php
+$double->shouldReceive('findAll')
+ ->andReturn([new Book(), new Book()]);
+```
+
+You can also use this shortcut, which creates a double and sets up some stubs in
+one call:
+
+``` php
+$double = Mockery::mock(BookRepository::class, [
+ "findAll" => [new Book(), new Book()],
+]);
+```
+
+## Method Call Expectations 📲
+
+A Method call expectation is a mechanism to allow you to verify that a
+particular method has been called. You can specify the parameters and you can
+also specify how many times you expect it to be called. Method call expectations
+are used to verify indirect output of the system under test.
+
+``` php
+$book = new Book();
+
+$double = Mockery::mock(BookRepository::class);
+$double->expects()->add($book);
+```
+
+During the test, Mockery accept calls to the `add` method as prescribed.
+After you have finished exercising the system under test, you need to
+tell Mockery to check that the method was called as expected, using the
+`Mockery::close` method. One way to do that is to add it to your `tearDown`
+method in PHPUnit.
+
+``` php
+
+public function tearDown()
+{
+ Mockery::close();
+}
+```
+
+The `expects()` method automatically sets up an expectation that the method call
+(and matching parameters) is called **once and once only**. You can choose to change
+this if you are expecting more calls.
+
+``` php
+$double->expects()->add($book)->twice();
+```
+
+If you have used Mockery before, you might see something new in the example
+above — we created a method expectation using `expects`, instead of the "old"
+`shouldReceive` syntax. This is a new feature of Mockery v1, but same as with
+`allows` in the previous section, it can be written in the "old" style.
+
+For new users of Mockery, the above example can also be written as:
+
+``` php
+$double->shouldReceive('find')
+ ->with(123)
+ ->once()
+ ->andReturn(new Book());
+$book = $double->find(123);
+```
+
+A detailed explanation of declaring expectations on method calls, please
+read the documentation, the [Expectation declarations](http://docs.mockery.io/en/latest/reference/expectations.html)
+section. After that, you can also learn about the new `allows` and `expects` methods
+in the [Alternative shouldReceive syntax](http://docs.mockery.io/en/latest/reference/alternative_should_receive_syntax.html)
+section.
+
+It is worth mentioning that one way of setting up expectations is no better or worse
+than the other. Under the hood, `allows` and `expects` are doing the same thing as
+`shouldReceive`, at times in "less words", and as such it comes to a personal preference
+of the programmer which way to use.
+
+## Test Spies 🕵️
+
+By default, all test doubles created with the `Mockery::mock` method will only
+accept calls that they have been configured to `allow` or `expect` (or in other words,
+calls that they `shouldReceive`). Sometimes we don't necessarily care about all of the
+calls that are going to be made to an object. To facilitate this, we can tell Mockery
+to ignore any calls it has not been told to expect or allow. To do so, we can tell a
+test double `shouldIgnoreMissing`, or we can create the double using the `Mocker::spy`
+shortcut.
+
+``` php
+// $double = Mockery::mock()->shouldIgnoreMissing();
+$double = Mockery::spy();
+
+$double->foo(); // null
+$double->bar(); // null
+```
+
+Further to this, sometimes we want to have the object accept any call during the test execution
+and then verify the calls afterwards. For these purposes, we need our test
+double to act as a Spy. All mockery test doubles record the calls that are made
+to them for verification afterwards by default:
+
+``` php
+$double->baz(123);
+
+$double->shouldHaveReceived()->baz(123); // null
+$double->shouldHaveReceived()->baz(12345); // Uncaught Exception Mockery\Exception\InvalidCountException...
+```
+
+Please refer to the [Spies](http://docs.mockery.io/en/latest/reference/spies.html) section
+of the documentation to learn more about the spies.
+
+## Utilities 🔌
+
+### Global Helpers
+
+Mockery ships with a handful of global helper methods, you just need to ask
+Mockery to declare them.
+
+``` php
+Mockery::globalHelpers();
+
+$mock = mock(Some::class);
+$spy = spy(Some::class);
+
+$spy->shouldHaveReceived()
+ ->foo(anyArgs());
+```
+
+All of the global helpers are wrapped in a `!function_exists` call to avoid
+conflicts. So if you already have a global function called `spy`, Mockery will
+silently skip the declaring its own `spy` function.
+
+### Testing Traits
+
+As Mockery ships with code generation capabilities, it was trivial to add
+functionality allowing users to create objects on the fly that use particular
+traits. Any abstract methods defined by the trait will be created and can have
+expectations or stubs configured like normal Test Doubles.
+
+``` php
+trait Foo {
+ function foo() {
+ return $this->doFoo();
+ }
+
+ abstract function doFoo();
+}
+
+$double = Mockery::mock(Foo::class);
+$double->allows()->doFoo()->andReturns(123);
+$double->foo(); // int(123)
+```
+
+## Versioning
+
+The Mockery team attempts to adhere to [Semantic Versioning](http://semver.org),
+however, some of Mockery's internals are considered private and will be open to
+change at any time. Just because a class isn't final, or a method isn't marked
+private, does not mean it constitutes part of the API we guarantee under the
+versioning scheme.
+
+### Alternative Runtimes
+
+Mockery 1.3 was the last version to support HHVM 3 and PHP 5. There is no support for HHVM 4+.
+
+## A new home for Mockery
+
+⚠️️ Update your remotes! Mockery has transferred to a new location. While it was once
+at `padraic/mockery`, it is now at `mockery/mockery`. While your
+existing repositories will redirect transparently for any operations, take some
+time to transition to the new URL.
+```sh
+$ git remote set-url upstream https://github.com/mockery/mockery.git
+```
+Replace `upstream` with the name of the remote you use locally; `upstream` is commonly
+used but you may be using something else. Run `git remote -v` to see what you're actually
+using.
diff --git a/vendor/mockery/mockery/SECURITY.md b/vendor/mockery/mockery/SECURITY.md
new file mode 100644
index 0000000..cc8790e
--- /dev/null
+++ b/vendor/mockery/mockery/SECURITY.md
@@ -0,0 +1,14 @@
+# Security Policy
+
+## Supported Versions
+
+| Version | Supported |
+| ------- | ------------------ |
+| `2.0.x` | `yes` |
+| `1.6.x` | `yes` |
+| `1.5.x` | `yes` |
+| `<1.5.x` | `no` |
+
+## Reporting a Vulnerability
+
+To report a security vulnerability, please [`Open a draft security advisory`](https://github.com/mockery/mockery/security/advisories/new) so we can coordinate the fix and disclosure.
diff --git a/vendor/mockery/mockery/composer.json b/vendor/mockery/mockery/composer.json
new file mode 100644
index 0000000..6f03cf2
--- /dev/null
+++ b/vendor/mockery/mockery/composer.json
@@ -0,0 +1,119 @@
+{
+ "name": "mockery/mockery",
+ "description": "Mockery is a simple yet flexible PHP mock object framework",
+ "license": "BSD-3-Clause",
+ "type": "library",
+ "keywords": [
+ "bdd",
+ "library",
+ "mock",
+ "mock objects",
+ "mockery",
+ "stub",
+ "tdd",
+ "test",
+ "test double",
+ "testing"
+ ],
+ "authors": [
+ {
+ "name": "Pádraic Brady",
+ "email": "padraic.brady@gmail.com",
+ "homepage": "https://github.com/padraic",
+ "role": "Author"
+ },
+ {
+ "name": "Dave Marshall",
+ "email": "dave.marshall@atstsolutions.co.uk",
+ "homepage": "https://davedevelopment.co.uk",
+ "role": "Developer"
+ },
+ {
+ "name": "Nathanael Esayeas",
+ "email": "nathanael.esayeas@protonmail.com",
+ "homepage": "https://github.com/ghostwriter",
+ "role": "Lead Developer"
+ }
+ ],
+ "homepage": "https://github.com/mockery/mockery",
+ "support": {
+ "issues": "https://github.com/mockery/mockery/issues",
+ "source": "https://github.com/mockery/mockery",
+ "docs": "https://docs.mockery.io/",
+ "rss": "https://github.com/mockery/mockery/releases.atom",
+ "security": "https://github.com/mockery/mockery/security/advisories"
+ },
+ "require": {
+ "php": ">=7.3",
+ "lib-pcre": ">=7.0",
+ "hamcrest/hamcrest-php": "^2.0.1"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^8.5 || ^9.6.17",
+ "symplify/easy-coding-standard": "^12.1.14"
+ },
+ "conflict": {
+ "phpunit/phpunit": "<8.0"
+ },
+ "autoload": {
+ "psr-4": {
+ "Mockery\\": "library/Mockery"
+ },
+ "files": [
+ "library/helpers.php",
+ "library/Mockery.php"
+ ]
+ },
+ "autoload-dev": {
+ "psr-4": {
+ "Fixture\\": "tests/Fixture/",
+ "Mockery\\Tests\\Unit\\": "tests/Unit",
+ "test\\": "tests/"
+ },
+ "files": [
+ "fixtures/autoload.php",
+ "vendor/hamcrest/hamcrest-php/hamcrest/Hamcrest.php"
+ ]
+ },
+ "config": {
+ "optimize-autoloader": true,
+ "platform": {
+ "php": "7.3.999"
+ },
+ "preferred-install": "dist",
+ "sort-packages": true
+ },
+ "scripts": {
+ "check": [
+ "@composer validate",
+ "@ecs",
+ "@test"
+ ],
+ "docs": "vendor/bin/phpdoc -d library -t docs/api",
+ "ecs": [
+ "@ecs:fix",
+ "@ecs:check"
+ ],
+ "ecs:check": "ecs check --clear-cache || true",
+ "ecs:fix": "ecs check --clear-cache --fix",
+ "phive": [
+ "tools/phive update --force-accept-unsigned",
+ "tools/phive purge"
+ ],
+ "phpunit": "vendor/bin/phpunit --do-not-cache-result --colors=always",
+ "phpunit:coverage": "@phpunit --coverage-clover=coverage.xml",
+ "psalm": "tools/psalm --no-cache --show-info=true",
+ "psalm:alter": "tools/psalm --no-cache --alter --allow-backwards-incompatible-changes=false --safe-types",
+ "psalm:baseline": "@psalm --no-diff --set-baseline=psalm-baseline.xml",
+ "psalm:dry-run": "@psalm:alter --issues=all --dry-run",
+ "psalm:fix": "@psalm:alter --issues=UnnecessaryVarAnnotation,MissingPureAnnotation,MissingImmutableAnnotation",
+ "psalm:security": "@psalm --no-diff --taint-analysis",
+ "psalm:shepherd": "@psalm --no-diff --shepherd --stats --output-format=github",
+ "test": [
+ "@phpunit --stop-on-defect",
+ "@psalm",
+ "@psalm:security",
+ "@psalm:dry-run"
+ ]
+ }
+}
diff --git a/vendor/mockery/mockery/composer.lock b/vendor/mockery/mockery/composer.lock
new file mode 100644
index 0000000..603f969
--- /dev/null
+++ b/vendor/mockery/mockery/composer.lock
@@ -0,0 +1,1867 @@
+{
+ "_readme": [
+ "This file locks the dependencies of your project to a known state",
+ "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
+ "This file is @generated automatically"
+ ],
+ "content-hash": "e70f68192a56a148f93ad7a1c0779be3",
+ "packages": [
+ {
+ "name": "hamcrest/hamcrest-php",
+ "version": "v2.0.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/hamcrest/hamcrest-php.git",
+ "reference": "8c3d0a3f6af734494ad8f6fbbee0ba92422859f3"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/hamcrest/hamcrest-php/zipball/8c3d0a3f6af734494ad8f6fbbee0ba92422859f3",
+ "reference": "8c3d0a3f6af734494ad8f6fbbee0ba92422859f3",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^5.3|^7.0|^8.0"
+ },
+ "replace": {
+ "cordoval/hamcrest-php": "*",
+ "davedevelopment/hamcrest-php": "*",
+ "kodova/hamcrest-php": "*"
+ },
+ "require-dev": {
+ "phpunit/php-file-iterator": "^1.4 || ^2.0",
+ "phpunit/phpunit": "^4.8.36 || ^5.7 || ^6.5 || ^7.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "2.1-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "hamcrest"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "description": "This is the PHP port of Hamcrest Matchers",
+ "keywords": [
+ "test"
+ ],
+ "support": {
+ "issues": "https://github.com/hamcrest/hamcrest-php/issues",
+ "source": "https://github.com/hamcrest/hamcrest-php/tree/v2.0.1"
+ },
+ "time": "2020-07-09T08:09:16+00:00"
+ }
+ ],
+ "packages-dev": [
+ {
+ "name": "doctrine/instantiator",
+ "version": "1.5.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/doctrine/instantiator.git",
+ "reference": "0a0fa9780f5d4e507415a065172d26a98d02047b"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/doctrine/instantiator/zipball/0a0fa9780f5d4e507415a065172d26a98d02047b",
+ "reference": "0a0fa9780f5d4e507415a065172d26a98d02047b",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.1 || ^8.0"
+ },
+ "require-dev": {
+ "doctrine/coding-standard": "^9 || ^11",
+ "ext-pdo": "*",
+ "ext-phar": "*",
+ "phpbench/phpbench": "^0.16 || ^1",
+ "phpstan/phpstan": "^1.4",
+ "phpstan/phpstan-phpunit": "^1",
+ "phpunit/phpunit": "^7.5 || ^8.5 || ^9.5",
+ "vimeo/psalm": "^4.30 || ^5.4"
+ },
+ "type": "library",
+ "autoload": {
+ "psr-4": {
+ "Doctrine\\Instantiator\\": "src/Doctrine/Instantiator/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Marco Pivetta",
+ "email": "ocramius@gmail.com",
+ "homepage": "https://ocramius.github.io/"
+ }
+ ],
+ "description": "A small, lightweight utility to instantiate objects in PHP without invoking their constructors",
+ "homepage": "https://www.doctrine-project.org/projects/instantiator.html",
+ "keywords": [
+ "constructor",
+ "instantiate"
+ ],
+ "support": {
+ "issues": "https://github.com/doctrine/instantiator/issues",
+ "source": "https://github.com/doctrine/instantiator/tree/1.5.0"
+ },
+ "funding": [
+ {
+ "url": "https://www.doctrine-project.org/sponsorship.html",
+ "type": "custom"
+ },
+ {
+ "url": "https://www.patreon.com/phpdoctrine",
+ "type": "patreon"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/doctrine%2Finstantiator",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2022-12-30T00:15:36+00:00"
+ },
+ {
+ "name": "myclabs/deep-copy",
+ "version": "1.11.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/myclabs/DeepCopy.git",
+ "reference": "7284c22080590fb39f2ffa3e9057f10a4ddd0e0c"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/myclabs/DeepCopy/zipball/7284c22080590fb39f2ffa3e9057f10a4ddd0e0c",
+ "reference": "7284c22080590fb39f2ffa3e9057f10a4ddd0e0c",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.1 || ^8.0"
+ },
+ "conflict": {
+ "doctrine/collections": "<1.6.8",
+ "doctrine/common": "<2.13.3 || >=3,<3.2.2"
+ },
+ "require-dev": {
+ "doctrine/collections": "^1.6.8",
+ "doctrine/common": "^2.13.3 || ^3.2.2",
+ "phpunit/phpunit": "^7.5.20 || ^8.5.23 || ^9.5.13"
+ },
+ "type": "library",
+ "autoload": {
+ "files": [
+ "src/DeepCopy/deep_copy.php"
+ ],
+ "psr-4": {
+ "DeepCopy\\": "src/DeepCopy/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "description": "Create deep copies (clones) of your objects",
+ "keywords": [
+ "clone",
+ "copy",
+ "duplicate",
+ "object",
+ "object graph"
+ ],
+ "support": {
+ "issues": "https://github.com/myclabs/DeepCopy/issues",
+ "source": "https://github.com/myclabs/DeepCopy/tree/1.11.1"
+ },
+ "funding": [
+ {
+ "url": "https://tidelift.com/funding/github/packagist/myclabs/deep-copy",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2023-03-08T13:26:56+00:00"
+ },
+ {
+ "name": "nikic/php-parser",
+ "version": "v4.18.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/nikic/PHP-Parser.git",
+ "reference": "1bcbb2179f97633e98bbbc87044ee2611c7d7999"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/nikic/PHP-Parser/zipball/1bcbb2179f97633e98bbbc87044ee2611c7d7999",
+ "reference": "1bcbb2179f97633e98bbbc87044ee2611c7d7999",
+ "shasum": ""
+ },
+ "require": {
+ "ext-tokenizer": "*",
+ "php": ">=7.0"
+ },
+ "require-dev": {
+ "ircmaxell/php-yacc": "^0.0.7",
+ "phpunit/phpunit": "^6.5 || ^7.0 || ^8.0 || ^9.0"
+ },
+ "bin": [
+ "bin/php-parse"
+ ],
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "4.9-dev"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "PhpParser\\": "lib/PhpParser"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Nikita Popov"
+ }
+ ],
+ "description": "A PHP parser written in PHP",
+ "keywords": [
+ "parser",
+ "php"
+ ],
+ "support": {
+ "issues": "https://github.com/nikic/PHP-Parser/issues",
+ "source": "https://github.com/nikic/PHP-Parser/tree/v4.18.0"
+ },
+ "time": "2023-12-10T21:03:43+00:00"
+ },
+ {
+ "name": "phar-io/manifest",
+ "version": "2.0.3",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/phar-io/manifest.git",
+ "reference": "97803eca37d319dfa7826cc2437fc020857acb53"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/phar-io/manifest/zipball/97803eca37d319dfa7826cc2437fc020857acb53",
+ "reference": "97803eca37d319dfa7826cc2437fc020857acb53",
+ "shasum": ""
+ },
+ "require": {
+ "ext-dom": "*",
+ "ext-phar": "*",
+ "ext-xmlwriter": "*",
+ "phar-io/version": "^3.0.1",
+ "php": "^7.2 || ^8.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "2.0.x-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Arne Blankerts",
+ "email": "arne@blankerts.de",
+ "role": "Developer"
+ },
+ {
+ "name": "Sebastian Heuer",
+ "email": "sebastian@phpeople.de",
+ "role": "Developer"
+ },
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "Developer"
+ }
+ ],
+ "description": "Component for reading phar.io manifest information from a PHP Archive (PHAR)",
+ "support": {
+ "issues": "https://github.com/phar-io/manifest/issues",
+ "source": "https://github.com/phar-io/manifest/tree/2.0.3"
+ },
+ "time": "2021-07-20T11:28:43+00:00"
+ },
+ {
+ "name": "phar-io/version",
+ "version": "3.2.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/phar-io/version.git",
+ "reference": "4f7fd7836c6f332bb2933569e566a0d6c4cbed74"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/phar-io/version/zipball/4f7fd7836c6f332bb2933569e566a0d6c4cbed74",
+ "reference": "4f7fd7836c6f332bb2933569e566a0d6c4cbed74",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.2 || ^8.0"
+ },
+ "type": "library",
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Arne Blankerts",
+ "email": "arne@blankerts.de",
+ "role": "Developer"
+ },
+ {
+ "name": "Sebastian Heuer",
+ "email": "sebastian@phpeople.de",
+ "role": "Developer"
+ },
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "Developer"
+ }
+ ],
+ "description": "Library for handling version information and constraints",
+ "support": {
+ "issues": "https://github.com/phar-io/version/issues",
+ "source": "https://github.com/phar-io/version/tree/3.2.1"
+ },
+ "time": "2022-02-21T01:04:05+00:00"
+ },
+ {
+ "name": "phpunit/php-code-coverage",
+ "version": "9.2.30",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/php-code-coverage.git",
+ "reference": "ca2bd87d2f9215904682a9cb9bb37dda98e76089"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/php-code-coverage/zipball/ca2bd87d2f9215904682a9cb9bb37dda98e76089",
+ "reference": "ca2bd87d2f9215904682a9cb9bb37dda98e76089",
+ "shasum": ""
+ },
+ "require": {
+ "ext-dom": "*",
+ "ext-libxml": "*",
+ "ext-xmlwriter": "*",
+ "nikic/php-parser": "^4.18 || ^5.0",
+ "php": ">=7.3",
+ "phpunit/php-file-iterator": "^3.0.3",
+ "phpunit/php-text-template": "^2.0.2",
+ "sebastian/code-unit-reverse-lookup": "^2.0.2",
+ "sebastian/complexity": "^2.0",
+ "sebastian/environment": "^5.1.2",
+ "sebastian/lines-of-code": "^1.0.3",
+ "sebastian/version": "^3.0.1",
+ "theseer/tokenizer": "^1.2.0"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3"
+ },
+ "suggest": {
+ "ext-pcov": "PHP extension that provides line coverage",
+ "ext-xdebug": "PHP extension that provides line coverage as well as branch and path coverage"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "9.2-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Library that provides collection, processing, and rendering functionality for PHP code coverage information.",
+ "homepage": "https://github.com/sebastianbergmann/php-code-coverage",
+ "keywords": [
+ "coverage",
+ "testing",
+ "xunit"
+ ],
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/php-code-coverage/issues",
+ "security": "https://github.com/sebastianbergmann/php-code-coverage/security/policy",
+ "source": "https://github.com/sebastianbergmann/php-code-coverage/tree/9.2.30"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2023-12-22T06:47:57+00:00"
+ },
+ {
+ "name": "phpunit/php-file-iterator",
+ "version": "3.0.6",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/php-file-iterator.git",
+ "reference": "cf1c2e7c203ac650e352f4cc675a7021e7d1b3cf"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/php-file-iterator/zipball/cf1c2e7c203ac650e352f4cc675a7021e7d1b3cf",
+ "reference": "cf1c2e7c203ac650e352f4cc675a7021e7d1b3cf",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "3.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "FilterIterator implementation that filters files based on a list of suffixes.",
+ "homepage": "https://github.com/sebastianbergmann/php-file-iterator/",
+ "keywords": [
+ "filesystem",
+ "iterator"
+ ],
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/php-file-iterator/issues",
+ "source": "https://github.com/sebastianbergmann/php-file-iterator/tree/3.0.6"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2021-12-02T12:48:52+00:00"
+ },
+ {
+ "name": "phpunit/php-invoker",
+ "version": "3.1.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/php-invoker.git",
+ "reference": "5a10147d0aaf65b58940a0b72f71c9ac0423cc67"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/php-invoker/zipball/5a10147d0aaf65b58940a0b72f71c9ac0423cc67",
+ "reference": "5a10147d0aaf65b58940a0b72f71c9ac0423cc67",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "ext-pcntl": "*",
+ "phpunit/phpunit": "^9.3"
+ },
+ "suggest": {
+ "ext-pcntl": "*"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "3.1-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Invoke callables with a timeout",
+ "homepage": "https://github.com/sebastianbergmann/php-invoker/",
+ "keywords": [
+ "process"
+ ],
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/php-invoker/issues",
+ "source": "https://github.com/sebastianbergmann/php-invoker/tree/3.1.1"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2020-09-28T05:58:55+00:00"
+ },
+ {
+ "name": "phpunit/php-text-template",
+ "version": "2.0.4",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/php-text-template.git",
+ "reference": "5da5f67fc95621df9ff4c4e5a84d6a8a2acf7c28"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/php-text-template/zipball/5da5f67fc95621df9ff4c4e5a84d6a8a2acf7c28",
+ "reference": "5da5f67fc95621df9ff4c4e5a84d6a8a2acf7c28",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "2.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Simple template engine.",
+ "homepage": "https://github.com/sebastianbergmann/php-text-template/",
+ "keywords": [
+ "template"
+ ],
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/php-text-template/issues",
+ "source": "https://github.com/sebastianbergmann/php-text-template/tree/2.0.4"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2020-10-26T05:33:50+00:00"
+ },
+ {
+ "name": "phpunit/php-timer",
+ "version": "5.0.3",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/php-timer.git",
+ "reference": "5a63ce20ed1b5bf577850e2c4e87f4aa902afbd2"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/php-timer/zipball/5a63ce20ed1b5bf577850e2c4e87f4aa902afbd2",
+ "reference": "5a63ce20ed1b5bf577850e2c4e87f4aa902afbd2",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "5.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Utility class for timing",
+ "homepage": "https://github.com/sebastianbergmann/php-timer/",
+ "keywords": [
+ "timer"
+ ],
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/php-timer/issues",
+ "source": "https://github.com/sebastianbergmann/php-timer/tree/5.0.3"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2020-10-26T13:16:10+00:00"
+ },
+ {
+ "name": "phpunit/phpunit",
+ "version": "9.6.17",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/phpunit.git",
+ "reference": "1a156980d78a6666721b7e8e8502fe210b587fcd"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/phpunit/zipball/1a156980d78a6666721b7e8e8502fe210b587fcd",
+ "reference": "1a156980d78a6666721b7e8e8502fe210b587fcd",
+ "shasum": ""
+ },
+ "require": {
+ "doctrine/instantiator": "^1.3.1 || ^2",
+ "ext-dom": "*",
+ "ext-json": "*",
+ "ext-libxml": "*",
+ "ext-mbstring": "*",
+ "ext-xml": "*",
+ "ext-xmlwriter": "*",
+ "myclabs/deep-copy": "^1.10.1",
+ "phar-io/manifest": "^2.0.3",
+ "phar-io/version": "^3.0.2",
+ "php": ">=7.3",
+ "phpunit/php-code-coverage": "^9.2.28",
+ "phpunit/php-file-iterator": "^3.0.5",
+ "phpunit/php-invoker": "^3.1.1",
+ "phpunit/php-text-template": "^2.0.3",
+ "phpunit/php-timer": "^5.0.2",
+ "sebastian/cli-parser": "^1.0.1",
+ "sebastian/code-unit": "^1.0.6",
+ "sebastian/comparator": "^4.0.8",
+ "sebastian/diff": "^4.0.3",
+ "sebastian/environment": "^5.1.3",
+ "sebastian/exporter": "^4.0.5",
+ "sebastian/global-state": "^5.0.1",
+ "sebastian/object-enumerator": "^4.0.3",
+ "sebastian/resource-operations": "^3.0.3",
+ "sebastian/type": "^3.2",
+ "sebastian/version": "^3.0.2"
+ },
+ "suggest": {
+ "ext-soap": "To be able to generate mocks based on WSDL files",
+ "ext-xdebug": "PHP extension that provides line coverage as well as branch and path coverage"
+ },
+ "bin": [
+ "phpunit"
+ ],
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "9.6-dev"
+ }
+ },
+ "autoload": {
+ "files": [
+ "src/Framework/Assert/Functions.php"
+ ],
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "The PHP Unit Testing framework.",
+ "homepage": "https://phpunit.de/",
+ "keywords": [
+ "phpunit",
+ "testing",
+ "xunit"
+ ],
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/phpunit/issues",
+ "security": "https://github.com/sebastianbergmann/phpunit/security/policy",
+ "source": "https://github.com/sebastianbergmann/phpunit/tree/9.6.17"
+ },
+ "funding": [
+ {
+ "url": "https://phpunit.de/sponsors.html",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/phpunit/phpunit",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2024-02-23T13:14:51+00:00"
+ },
+ {
+ "name": "sebastian/cli-parser",
+ "version": "1.0.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/cli-parser.git",
+ "reference": "442e7c7e687e42adc03470c7b668bc4b2402c0b2"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/cli-parser/zipball/442e7c7e687e42adc03470c7b668bc4b2402c0b2",
+ "reference": "442e7c7e687e42adc03470c7b668bc4b2402c0b2",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Library for parsing CLI options",
+ "homepage": "https://github.com/sebastianbergmann/cli-parser",
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/cli-parser/issues",
+ "source": "https://github.com/sebastianbergmann/cli-parser/tree/1.0.1"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2020-09-28T06:08:49+00:00"
+ },
+ {
+ "name": "sebastian/code-unit",
+ "version": "1.0.8",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/code-unit.git",
+ "reference": "1fc9f64c0927627ef78ba436c9b17d967e68e120"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/code-unit/zipball/1fc9f64c0927627ef78ba436c9b17d967e68e120",
+ "reference": "1fc9f64c0927627ef78ba436c9b17d967e68e120",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Collection of value objects that represent the PHP code units",
+ "homepage": "https://github.com/sebastianbergmann/code-unit",
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/code-unit/issues",
+ "source": "https://github.com/sebastianbergmann/code-unit/tree/1.0.8"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2020-10-26T13:08:54+00:00"
+ },
+ {
+ "name": "sebastian/code-unit-reverse-lookup",
+ "version": "2.0.3",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/code-unit-reverse-lookup.git",
+ "reference": "ac91f01ccec49fb77bdc6fd1e548bc70f7faa3e5"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/code-unit-reverse-lookup/zipball/ac91f01ccec49fb77bdc6fd1e548bc70f7faa3e5",
+ "reference": "ac91f01ccec49fb77bdc6fd1e548bc70f7faa3e5",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "2.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Looks up which function or method a line of code belongs to",
+ "homepage": "https://github.com/sebastianbergmann/code-unit-reverse-lookup/",
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/code-unit-reverse-lookup/issues",
+ "source": "https://github.com/sebastianbergmann/code-unit-reverse-lookup/tree/2.0.3"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2020-09-28T05:30:19+00:00"
+ },
+ {
+ "name": "sebastian/comparator",
+ "version": "4.0.8",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/comparator.git",
+ "reference": "fa0f136dd2334583309d32b62544682ee972b51a"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/comparator/zipball/fa0f136dd2334583309d32b62544682ee972b51a",
+ "reference": "fa0f136dd2334583309d32b62544682ee972b51a",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3",
+ "sebastian/diff": "^4.0",
+ "sebastian/exporter": "^4.0"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "4.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ },
+ {
+ "name": "Jeff Welch",
+ "email": "whatthejeff@gmail.com"
+ },
+ {
+ "name": "Volker Dusch",
+ "email": "github@wallbash.com"
+ },
+ {
+ "name": "Bernhard Schussek",
+ "email": "bschussek@2bepublished.at"
+ }
+ ],
+ "description": "Provides the functionality to compare PHP values for equality",
+ "homepage": "https://github.com/sebastianbergmann/comparator",
+ "keywords": [
+ "comparator",
+ "compare",
+ "equality"
+ ],
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/comparator/issues",
+ "source": "https://github.com/sebastianbergmann/comparator/tree/4.0.8"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2022-09-14T12:41:17+00:00"
+ },
+ {
+ "name": "sebastian/complexity",
+ "version": "2.0.3",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/complexity.git",
+ "reference": "25f207c40d62b8b7aa32f5ab026c53561964053a"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/complexity/zipball/25f207c40d62b8b7aa32f5ab026c53561964053a",
+ "reference": "25f207c40d62b8b7aa32f5ab026c53561964053a",
+ "shasum": ""
+ },
+ "require": {
+ "nikic/php-parser": "^4.18 || ^5.0",
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "2.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Library for calculating the complexity of PHP code units",
+ "homepage": "https://github.com/sebastianbergmann/complexity",
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/complexity/issues",
+ "source": "https://github.com/sebastianbergmann/complexity/tree/2.0.3"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2023-12-22T06:19:30+00:00"
+ },
+ {
+ "name": "sebastian/diff",
+ "version": "4.0.5",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/diff.git",
+ "reference": "74be17022044ebaaecfdf0c5cd504fc9cd5a7131"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/diff/zipball/74be17022044ebaaecfdf0c5cd504fc9cd5a7131",
+ "reference": "74be17022044ebaaecfdf0c5cd504fc9cd5a7131",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3",
+ "symfony/process": "^4.2 || ^5"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "4.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ },
+ {
+ "name": "Kore Nordmann",
+ "email": "mail@kore-nordmann.de"
+ }
+ ],
+ "description": "Diff implementation",
+ "homepage": "https://github.com/sebastianbergmann/diff",
+ "keywords": [
+ "diff",
+ "udiff",
+ "unidiff",
+ "unified diff"
+ ],
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/diff/issues",
+ "source": "https://github.com/sebastianbergmann/diff/tree/4.0.5"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2023-05-07T05:35:17+00:00"
+ },
+ {
+ "name": "sebastian/environment",
+ "version": "5.1.5",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/environment.git",
+ "reference": "830c43a844f1f8d5b7a1f6d6076b784454d8b7ed"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/environment/zipball/830c43a844f1f8d5b7a1f6d6076b784454d8b7ed",
+ "reference": "830c43a844f1f8d5b7a1f6d6076b784454d8b7ed",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3"
+ },
+ "suggest": {
+ "ext-posix": "*"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "5.1-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Provides functionality to handle HHVM/PHP environments",
+ "homepage": "http://www.github.com/sebastianbergmann/environment",
+ "keywords": [
+ "Xdebug",
+ "environment",
+ "hhvm"
+ ],
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/environment/issues",
+ "source": "https://github.com/sebastianbergmann/environment/tree/5.1.5"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2023-02-03T06:03:51+00:00"
+ },
+ {
+ "name": "sebastian/exporter",
+ "version": "4.0.5",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/exporter.git",
+ "reference": "ac230ed27f0f98f597c8a2b6eb7ac563af5e5b9d"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/exporter/zipball/ac230ed27f0f98f597c8a2b6eb7ac563af5e5b9d",
+ "reference": "ac230ed27f0f98f597c8a2b6eb7ac563af5e5b9d",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3",
+ "sebastian/recursion-context": "^4.0"
+ },
+ "require-dev": {
+ "ext-mbstring": "*",
+ "phpunit/phpunit": "^9.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "4.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ },
+ {
+ "name": "Jeff Welch",
+ "email": "whatthejeff@gmail.com"
+ },
+ {
+ "name": "Volker Dusch",
+ "email": "github@wallbash.com"
+ },
+ {
+ "name": "Adam Harvey",
+ "email": "aharvey@php.net"
+ },
+ {
+ "name": "Bernhard Schussek",
+ "email": "bschussek@gmail.com"
+ }
+ ],
+ "description": "Provides the functionality to export PHP variables for visualization",
+ "homepage": "https://www.github.com/sebastianbergmann/exporter",
+ "keywords": [
+ "export",
+ "exporter"
+ ],
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/exporter/issues",
+ "source": "https://github.com/sebastianbergmann/exporter/tree/4.0.5"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2022-09-14T06:03:37+00:00"
+ },
+ {
+ "name": "sebastian/global-state",
+ "version": "5.0.6",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/global-state.git",
+ "reference": "bde739e7565280bda77be70044ac1047bc007e34"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/global-state/zipball/bde739e7565280bda77be70044ac1047bc007e34",
+ "reference": "bde739e7565280bda77be70044ac1047bc007e34",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3",
+ "sebastian/object-reflector": "^2.0",
+ "sebastian/recursion-context": "^4.0"
+ },
+ "require-dev": {
+ "ext-dom": "*",
+ "phpunit/phpunit": "^9.3"
+ },
+ "suggest": {
+ "ext-uopz": "*"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "5.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Snapshotting of global state",
+ "homepage": "http://www.github.com/sebastianbergmann/global-state",
+ "keywords": [
+ "global state"
+ ],
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/global-state/issues",
+ "source": "https://github.com/sebastianbergmann/global-state/tree/5.0.6"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2023-08-02T09:26:13+00:00"
+ },
+ {
+ "name": "sebastian/lines-of-code",
+ "version": "1.0.4",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/lines-of-code.git",
+ "reference": "e1e4a170560925c26d424b6a03aed157e7dcc5c5"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/lines-of-code/zipball/e1e4a170560925c26d424b6a03aed157e7dcc5c5",
+ "reference": "e1e4a170560925c26d424b6a03aed157e7dcc5c5",
+ "shasum": ""
+ },
+ "require": {
+ "nikic/php-parser": "^4.18 || ^5.0",
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Library for counting the lines of code in PHP source code",
+ "homepage": "https://github.com/sebastianbergmann/lines-of-code",
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/lines-of-code/issues",
+ "source": "https://github.com/sebastianbergmann/lines-of-code/tree/1.0.4"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2023-12-22T06:20:34+00:00"
+ },
+ {
+ "name": "sebastian/object-enumerator",
+ "version": "4.0.4",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/object-enumerator.git",
+ "reference": "5c9eeac41b290a3712d88851518825ad78f45c71"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/object-enumerator/zipball/5c9eeac41b290a3712d88851518825ad78f45c71",
+ "reference": "5c9eeac41b290a3712d88851518825ad78f45c71",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3",
+ "sebastian/object-reflector": "^2.0",
+ "sebastian/recursion-context": "^4.0"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "4.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Traverses array structures and object graphs to enumerate all referenced objects",
+ "homepage": "https://github.com/sebastianbergmann/object-enumerator/",
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/object-enumerator/issues",
+ "source": "https://github.com/sebastianbergmann/object-enumerator/tree/4.0.4"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2020-10-26T13:12:34+00:00"
+ },
+ {
+ "name": "sebastian/object-reflector",
+ "version": "2.0.4",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/object-reflector.git",
+ "reference": "b4f479ebdbf63ac605d183ece17d8d7fe49c15c7"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/object-reflector/zipball/b4f479ebdbf63ac605d183ece17d8d7fe49c15c7",
+ "reference": "b4f479ebdbf63ac605d183ece17d8d7fe49c15c7",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "2.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Allows reflection of object attributes, including inherited and non-public ones",
+ "homepage": "https://github.com/sebastianbergmann/object-reflector/",
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/object-reflector/issues",
+ "source": "https://github.com/sebastianbergmann/object-reflector/tree/2.0.4"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2020-10-26T13:14:26+00:00"
+ },
+ {
+ "name": "sebastian/recursion-context",
+ "version": "4.0.5",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/recursion-context.git",
+ "reference": "e75bd0f07204fec2a0af9b0f3cfe97d05f92efc1"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/recursion-context/zipball/e75bd0f07204fec2a0af9b0f3cfe97d05f92efc1",
+ "reference": "e75bd0f07204fec2a0af9b0f3cfe97d05f92efc1",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "4.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ },
+ {
+ "name": "Jeff Welch",
+ "email": "whatthejeff@gmail.com"
+ },
+ {
+ "name": "Adam Harvey",
+ "email": "aharvey@php.net"
+ }
+ ],
+ "description": "Provides functionality to recursively process PHP variables",
+ "homepage": "https://github.com/sebastianbergmann/recursion-context",
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/recursion-context/issues",
+ "source": "https://github.com/sebastianbergmann/recursion-context/tree/4.0.5"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2023-02-03T06:07:39+00:00"
+ },
+ {
+ "name": "sebastian/resource-operations",
+ "version": "3.0.3",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/resource-operations.git",
+ "reference": "0f4443cb3a1d92ce809899753bc0d5d5a8dd19a8"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/resource-operations/zipball/0f4443cb3a1d92ce809899753bc0d5d5a8dd19a8",
+ "reference": "0f4443cb3a1d92ce809899753bc0d5d5a8dd19a8",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "3.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Provides a list of PHP built-in functions that operate on resources",
+ "homepage": "https://www.github.com/sebastianbergmann/resource-operations",
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/resource-operations/issues",
+ "source": "https://github.com/sebastianbergmann/resource-operations/tree/3.0.3"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2020-09-28T06:45:17+00:00"
+ },
+ {
+ "name": "sebastian/type",
+ "version": "3.2.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/type.git",
+ "reference": "75e2c2a32f5e0b3aef905b9ed0b179b953b3d7c7"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/type/zipball/75e2c2a32f5e0b3aef905b9ed0b179b953b3d7c7",
+ "reference": "75e2c2a32f5e0b3aef905b9ed0b179b953b3d7c7",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.5"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "3.2-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Collection of value objects that represent the types of the PHP type system",
+ "homepage": "https://github.com/sebastianbergmann/type",
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/type/issues",
+ "source": "https://github.com/sebastianbergmann/type/tree/3.2.1"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2023-02-03T06:13:03+00:00"
+ },
+ {
+ "name": "sebastian/version",
+ "version": "3.0.2",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/version.git",
+ "reference": "c6c1022351a901512170118436c764e473f6de8c"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/version/zipball/c6c1022351a901512170118436c764e473f6de8c",
+ "reference": "c6c1022351a901512170118436c764e473f6de8c",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "3.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Library that helps with managing the version number of Git-hosted PHP projects",
+ "homepage": "https://github.com/sebastianbergmann/version",
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/version/issues",
+ "source": "https://github.com/sebastianbergmann/version/tree/3.0.2"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2020-09-28T06:39:44+00:00"
+ },
+ {
+ "name": "symplify/easy-coding-standard",
+ "version": "12.1.14",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/easy-coding-standard/easy-coding-standard.git",
+ "reference": "e3c4a241ee36704f7cf920d5931f39693e64afd5"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/easy-coding-standard/easy-coding-standard/zipball/e3c4a241ee36704f7cf920d5931f39693e64afd5",
+ "reference": "e3c4a241ee36704f7cf920d5931f39693e64afd5",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.2"
+ },
+ "conflict": {
+ "friendsofphp/php-cs-fixer": "<3.46",
+ "phpcsstandards/php_codesniffer": "<3.8",
+ "symplify/coding-standard": "<12.1"
+ },
+ "bin": [
+ "bin/ecs"
+ ],
+ "type": "library",
+ "autoload": {
+ "files": [
+ "bootstrap.php"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "description": "Use Coding Standard with 0-knowledge of PHP-CS-Fixer and PHP_CodeSniffer",
+ "keywords": [
+ "Code style",
+ "automation",
+ "fixer",
+ "static analysis"
+ ],
+ "support": {
+ "issues": "https://github.com/easy-coding-standard/easy-coding-standard/issues",
+ "source": "https://github.com/easy-coding-standard/easy-coding-standard/tree/12.1.14"
+ },
+ "funding": [
+ {
+ "url": "https://www.paypal.me/rectorphp",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/tomasvotruba",
+ "type": "github"
+ }
+ ],
+ "time": "2024-02-23T13:10:40+00:00"
+ },
+ {
+ "name": "theseer/tokenizer",
+ "version": "1.2.2",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/theseer/tokenizer.git",
+ "reference": "b2ad5003ca10d4ee50a12da31de12a5774ba6b96"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/theseer/tokenizer/zipball/b2ad5003ca10d4ee50a12da31de12a5774ba6b96",
+ "reference": "b2ad5003ca10d4ee50a12da31de12a5774ba6b96",
+ "shasum": ""
+ },
+ "require": {
+ "ext-dom": "*",
+ "ext-tokenizer": "*",
+ "ext-xmlwriter": "*",
+ "php": "^7.2 || ^8.0"
+ },
+ "type": "library",
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Arne Blankerts",
+ "email": "arne@blankerts.de",
+ "role": "Developer"
+ }
+ ],
+ "description": "A small library for converting tokenized PHP source code into XML and potentially other formats",
+ "support": {
+ "issues": "https://github.com/theseer/tokenizer/issues",
+ "source": "https://github.com/theseer/tokenizer/tree/1.2.2"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/theseer",
+ "type": "github"
+ }
+ ],
+ "time": "2023-11-20T00:12:19+00:00"
+ }
+ ],
+ "aliases": [],
+ "minimum-stability": "stable",
+ "stability-flags": [],
+ "prefer-stable": false,
+ "prefer-lowest": false,
+ "platform": {
+ "php": ">=7.3",
+ "lib-pcre": ">=7.0"
+ },
+ "platform-dev": [],
+ "platform-overrides": {
+ "php": "7.3.999"
+ },
+ "plugin-api-version": "2.6.0"
+}
diff --git a/vendor/mockery/mockery/docs/.gitignore b/vendor/mockery/mockery/docs/.gitignore
new file mode 100644
index 0000000..e35d885
--- /dev/null
+++ b/vendor/mockery/mockery/docs/.gitignore
@@ -0,0 +1 @@
+_build
diff --git a/vendor/mockery/mockery/docs/Makefile b/vendor/mockery/mockery/docs/Makefile
new file mode 100644
index 0000000..9a8c940
--- /dev/null
+++ b/vendor/mockery/mockery/docs/Makefile
@@ -0,0 +1,177 @@
+# Makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS =
+SPHINXBUILD = sphinx-build
+PAPER =
+BUILDDIR = _build
+
+# User-friendly check for sphinx-build
+ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1)
+$(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don't have Sphinx installed, grab it from http://sphinx-doc.org/)
+endif
+
+# Internal variables.
+PAPEROPT_a4 = -D latex_paper_size=a4
+PAPEROPT_letter = -D latex_paper_size=letter
+ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
+# the i18n builder cannot share the environment and doctrees with the others
+I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
+
+.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext
+
+help:
+ @echo "Please use \`make ' where is one of"
+ @echo " html to make standalone HTML files"
+ @echo " dirhtml to make HTML files named index.html in directories"
+ @echo " singlehtml to make a single large HTML file"
+ @echo " pickle to make pickle files"
+ @echo " json to make JSON files"
+ @echo " htmlhelp to make HTML files and a HTML help project"
+ @echo " qthelp to make HTML files and a qthelp project"
+ @echo " devhelp to make HTML files and a Devhelp project"
+ @echo " epub to make an epub"
+ @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
+ @echo " latexpdf to make LaTeX files and run them through pdflatex"
+ @echo " latexpdfja to make LaTeX files and run them through platex/dvipdfmx"
+ @echo " text to make text files"
+ @echo " man to make manual pages"
+ @echo " texinfo to make Texinfo files"
+ @echo " info to make Texinfo files and run them through makeinfo"
+ @echo " gettext to make PO message catalogs"
+ @echo " changes to make an overview of all changed/added/deprecated items"
+ @echo " xml to make Docutils-native XML files"
+ @echo " pseudoxml to make pseudoxml-XML files for display purposes"
+ @echo " linkcheck to check all external links for integrity"
+ @echo " doctest to run all doctests embedded in the documentation (if enabled)"
+
+clean:
+ rm -rf $(BUILDDIR)/*
+
+html:
+ $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
+ @echo
+ @echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
+
+dirhtml:
+ $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
+ @echo
+ @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
+
+singlehtml:
+ $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
+ @echo
+ @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
+
+pickle:
+ $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
+ @echo
+ @echo "Build finished; now you can process the pickle files."
+
+json:
+ $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
+ @echo
+ @echo "Build finished; now you can process the JSON files."
+
+htmlhelp:
+ $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
+ @echo
+ @echo "Build finished; now you can run HTML Help Workshop with the" \
+ ".hhp project file in $(BUILDDIR)/htmlhelp."
+
+qthelp:
+ $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
+ @echo
+ @echo "Build finished; now you can run "qcollectiongenerator" with the" \
+ ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
+ @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/MockeryDocs.qhcp"
+ @echo "To view the help file:"
+ @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/MockeryDocs.qhc"
+
+devhelp:
+ $(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
+ @echo
+ @echo "Build finished."
+ @echo "To view the help file:"
+ @echo "# mkdir -p $$HOME/.local/share/devhelp/MockeryDocs"
+ @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/MockeryDocs"
+ @echo "# devhelp"
+
+epub:
+ $(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
+ @echo
+ @echo "Build finished. The epub file is in $(BUILDDIR)/epub."
+
+latex:
+ $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+ @echo
+ @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
+ @echo "Run \`make' in that directory to run these through (pdf)latex" \
+ "(use \`make latexpdf' here to do that automatically)."
+
+latexpdf:
+ $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+ @echo "Running LaTeX files through pdflatex..."
+ $(MAKE) -C $(BUILDDIR)/latex all-pdf
+ @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
+
+latexpdfja:
+ $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+ @echo "Running LaTeX files through platex and dvipdfmx..."
+ $(MAKE) -C $(BUILDDIR)/latex all-pdf-ja
+ @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
+
+text:
+ $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
+ @echo
+ @echo "Build finished. The text files are in $(BUILDDIR)/text."
+
+man:
+ $(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
+ @echo
+ @echo "Build finished. The manual pages are in $(BUILDDIR)/man."
+
+texinfo:
+ $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
+ @echo
+ @echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
+ @echo "Run \`make' in that directory to run these through makeinfo" \
+ "(use \`make info' here to do that automatically)."
+
+info:
+ $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
+ @echo "Running Texinfo files through makeinfo..."
+ make -C $(BUILDDIR)/texinfo info
+ @echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
+
+gettext:
+ $(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
+ @echo
+ @echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
+
+changes:
+ $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
+ @echo
+ @echo "The overview file is in $(BUILDDIR)/changes."
+
+linkcheck:
+ $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
+ @echo
+ @echo "Link check complete; look for any errors in the above output " \
+ "or in $(BUILDDIR)/linkcheck/output.txt."
+
+doctest:
+ $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
+ @echo "Testing of doctests in the sources finished, look at the " \
+ "results in $(BUILDDIR)/doctest/output.txt."
+
+xml:
+ $(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml
+ @echo
+ @echo "Build finished. The XML files are in $(BUILDDIR)/xml."
+
+pseudoxml:
+ $(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml
+ @echo
+ @echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml."
diff --git a/vendor/mockery/mockery/docs/README.md b/vendor/mockery/mockery/docs/README.md
new file mode 100644
index 0000000..63ca69d
--- /dev/null
+++ b/vendor/mockery/mockery/docs/README.md
@@ -0,0 +1,4 @@
+mockery-docs
+============
+
+Document for the PHP Mockery framework on readthedocs.org
\ No newline at end of file
diff --git a/vendor/mockery/mockery/docs/_static/.gitkeep b/vendor/mockery/mockery/docs/_static/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/vendor/mockery/mockery/docs/conf.py b/vendor/mockery/mockery/docs/conf.py
new file mode 100644
index 0000000..d0f6960
--- /dev/null
+++ b/vendor/mockery/mockery/docs/conf.py
@@ -0,0 +1,268 @@
+# -*- coding: utf-8 -*-
+#
+# Mockery Docs documentation build configuration file, created by
+# sphinx-quickstart on Mon Mar 3 14:04:26 2014.
+#
+# This file is execfile()d with the current directory set to its
+# containing dir.
+#
+# Note that not all possible configuration values are present in this
+# autogenerated file.
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+
+import sys
+import os
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#sys.path.insert(0, os.path.abspath('.'))
+
+# -- General configuration ------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+#needs_sphinx = '1.0'
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+ 'sphinx.ext.todo',
+ 'sphinx_rtd_theme',
+]
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The suffix of source filenames.
+source_suffix = '.rst'
+
+# The encoding of source files.
+#source_encoding = 'utf-8-sig'
+
+# The master toctree document.
+master_doc = 'index'
+
+# General information about the project.
+project = u'Mockery Docs'
+copyright = u'Pádraic Brady, Dave Marshall and contributors'
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+# The short X.Y version.
+version = '1.6'
+# The full version, including alpha/beta/rc tags.
+release = '1.6.x'
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#language = None
+
+# There are two options for replacing |today|: either, you set today to some
+# non-false value, then it is used:
+#today = ''
+# Else, today_fmt is used as the format for a strftime call.
+#today_fmt = '%B %d, %Y'
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+exclude_patterns = ['_build']
+
+# The reST default role (used for this markup: `text`) to use for all
+# documents.
+#default_role = None
+
+# If true, '()' will be appended to :func: etc. cross-reference text.
+#add_function_parentheses = True
+
+# If true, the current module name will be prepended to all description
+# unit titles (such as .. function::).
+#add_module_names = True
+
+# If true, sectionauthor and moduleauthor directives will be shown in the
+# output. They are ignored by default.
+#show_authors = False
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'sphinx'
+
+# A list of ignored prefixes for module index sorting.
+#modindex_common_prefix = []
+
+# If true, keep warnings as "system message" paragraphs in the built documents.
+#keep_warnings = False
+
+
+# -- Options for HTML output ----------------------------------------------
+
+# The theme to use for HTML and HTML Help pages. See the documentation for
+# a list of builtin themes.
+html_theme = 'sphinx_rtd_theme'
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further. For a list of options available for each theme, see the
+# documentation.
+#html_theme_options = {}
+
+# Add any paths that contain custom themes here, relative to this directory.
+#html_theme_path = []
+
+# The name of an image file (within the static path) to use as favicon of the
+# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
+# pixels large.
+#html_favicon = None
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
+
+# Add any extra paths that contain custom files (such as robots.txt or
+# .htaccess) here, relative to this directory. These files are copied
+# directly to the root of the documentation.
+#html_extra_path = []
+
+# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
+# using the given strftime format.
+#html_last_updated_fmt = '%b %d, %Y'
+
+# If true, SmartyPants will be used to convert quotes and dashes to
+# typographically correct entities.
+#html_use_smartypants = True
+
+# Custom sidebar templates, maps document names to template names.
+#html_sidebars = {}
+
+# Additional templates that should be rendered to pages, maps page names to
+# template names.
+#html_additional_pages = {}
+
+# If false, no module index is generated.
+#html_domain_indices = True
+
+# If false, no index is generated.
+#html_use_index = True
+
+# If true, the index is split into individual pages for each letter.
+#html_split_index = False
+
+# If true, links to the reST sources are added to the pages.
+#html_show_sourcelink = True
+
+# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
+#html_show_sphinx = True
+
+# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
+#html_show_copyright = True
+
+# If true, an OpenSearch description file will be output, and all pages will
+# contain a `_.
+To install Mockery using Composer, first install Composer for your project
+using the instructions on the `Composer download page `_
+to do it's job. To speed up things, Mockery caches internally the information it
+gathers via reflection. In some cases, this caching can cause problems.
+
+The **only** known situation when this occurs is when PHPUnit's ``--static-backup`` option
+is used. If you use ``--static-backup`` and you get an error that looks like the
+following:
+
+.. code-block:: php
+
+ Error: Internal error: Failed to retrieve the reflection object
+
+We suggest turning off the reflection cache as so:
+
+.. code-block:: php
+
+ \Mockery::getConfiguration()->disableReflectionCache();
+
+Turning it back on can be done like so:
+
+.. code-block:: php
+
+ \Mockery::getConfiguration()->enableReflectionCache();
+
+In no other situation should you be required turn this reflection cache off.
diff --git a/vendor/mockery/mockery/docs/mockery/exceptions.rst b/vendor/mockery/mockery/docs/mockery/exceptions.rst
new file mode 100644
index 0000000..623b158
--- /dev/null
+++ b/vendor/mockery/mockery/docs/mockery/exceptions.rst
@@ -0,0 +1,65 @@
+.. index::
+ single: Mockery; Exceptions
+
+Mockery Exceptions
+==================
+
+Mockery throws three types of exceptions when it cannot verify a mock object.
+
+#. ``\Mockery\Exception\InvalidCountException``
+#. ``\Mockery\Exception\InvalidOrderException``
+#. ``\Mockery\Exception\NoMatchingExpectationException``
+
+You can capture any of these exceptions in a try...catch block to query them
+for specific information which is also passed along in the exception message
+but is provided separately from getters should they be useful when logging or
+reformatting output.
+
+\Mockery\Exception\InvalidCountException
+----------------------------------------
+
+The exception class is used when a method is called too many (or too few)
+times and offers the following methods:
+
+* ``getMock()`` - return actual mock object
+* ``getMockName()`` - return the name of the mock object
+* ``getMethodName()`` - return the name of the method the failing expectation
+ is attached to
+* ``getExpectedCount()`` - return expected calls
+* ``getExpectedCountComparative()`` - returns a string, e.g. ``<=`` used to
+ compare to actual count
+* ``getActualCount()`` - return actual calls made with given argument
+ constraints
+
+\Mockery\Exception\InvalidOrderException
+----------------------------------------
+
+The exception class is used when a method is called outside the expected order
+set using the ``ordered()`` and ``globally()`` expectation modifiers. It
+offers the following methods:
+
+* ``getMock()`` - return actual mock object
+* ``getMockName()`` - return the name of the mock object
+* ``getMethodName()`` - return the name of the method the failing expectation
+ is attached to
+* ``getExpectedOrder()`` - returns an integer represented the expected index
+ for which this call was expected
+* ``getActualOrder()`` - return the actual index at which this method call
+ occurred.
+
+\Mockery\Exception\NoMatchingExpectationException
+-------------------------------------------------
+
+The exception class is used when a method call does not match any known
+expectation. All expectations are uniquely identified in a mock object by the
+method name and the list of expected arguments. You can disable this exception
+and opt for returning NULL from all unexpected method calls by using the
+earlier mentioned shouldIgnoreMissing() behaviour modifier. This exception
+class offers the following methods:
+
+* ``getMock()`` - return actual mock object
+* ``getMockName()`` - return the name of the mock object
+* ``getMethodName()`` - return the name of the method the failing expectation
+ is attached to
+* ``getActualArguments()`` - return actual arguments used to search for a
+ matching expectation
diff --git a/vendor/mockery/mockery/docs/mockery/gotchas.rst b/vendor/mockery/mockery/docs/mockery/gotchas.rst
new file mode 100644
index 0000000..92c566d
--- /dev/null
+++ b/vendor/mockery/mockery/docs/mockery/gotchas.rst
@@ -0,0 +1,44 @@
+.. index::
+ single: Mockery; Gotchas
+
+Gotchas!
+========
+
+Mocking objects in PHP has its limitations and gotchas. Some functionality
+can't be mocked or can't be mocked YET! If you locate such a circumstance,
+please please (pretty please with sugar on top) create a new issue on GitHub
+so it can be documented and resolved where possible. Here is a list to note:
+
+1. Classes containing public ``__wakeup()`` methods can be mocked but the
+ mocked ``__wakeup()`` method will perform no actions and cannot have
+ expectations set for it. This is necessary since Mockery must serialize and
+ unserialize objects to avoid some ``__construct()`` insanity and attempting
+ to mock a ``__wakeup()`` method as normal leads to a
+ ``BadMethodCallException`` being thrown.
+
+2. Mockery has two scenarios where real classes are replaced: Instance mocks
+ and alias mocks. Both will generate PHP fatal errors if the real class is
+ loaded, usually via a require or include statement. Only use these two mock
+ types where autoloading is in place and where classes are not explicitly
+ loaded on a per-file basis using ``require()``, ``require_once()``, etc.
+
+3. Internal PHP classes are not entirely capable of being fully analysed using
+ ``Reflection``. For example, ``Reflection`` cannot reveal details of
+ expected parameters to the methods of such internal classes. As a result,
+ there will be problems where a method parameter is defined to accept a
+ value by reference (Mockery cannot detect this condition and will assume a
+ pass by value on scalars and arrays). If references as internal class
+ method parameters are needed, you should use the
+ ``\Mockery\Configuration::setInternalClassMethodParamMap()`` method.
+ Note, however that internal class parameter overriding is not available in
+ PHP 8 since incompatible signatures have been reclassified as fatal errors.
+
+4. Creating a mock implementing a certain interface with incorrect case in the
+ interface name, and then creating a second mock implementing the same
+ interface, but this time with the correct case, will have undefined behavior
+ due to PHP's ``class_exists`` and related functions being case insensitive.
+ Using the ``::class`` keyword in PHP can help you avoid these mistakes.
+
+The gotchas noted above are largely down to PHP's architecture and are assumed
+to be unavoidable. But - if you figure out a solution (or a better one than
+what may exist), let us know!
diff --git a/vendor/mockery/mockery/docs/mockery/index.rst b/vendor/mockery/mockery/docs/mockery/index.rst
new file mode 100644
index 0000000..b698d6c
--- /dev/null
+++ b/vendor/mockery/mockery/docs/mockery/index.rst
@@ -0,0 +1,12 @@
+Mockery
+=======
+
+.. toctree::
+ :hidden:
+
+ configuration
+ exceptions
+ reserved_method_names
+ gotchas
+
+.. include:: map.rst.inc
diff --git a/vendor/mockery/mockery/docs/mockery/map.rst.inc b/vendor/mockery/mockery/docs/mockery/map.rst.inc
new file mode 100644
index 0000000..46ffa97
--- /dev/null
+++ b/vendor/mockery/mockery/docs/mockery/map.rst.inc
@@ -0,0 +1,4 @@
+* :doc:`/mockery/configuration`
+* :doc:`/mockery/exceptions`
+* :doc:`/mockery/reserved_method_names`
+* :doc:`/mockery/gotchas`
diff --git a/vendor/mockery/mockery/docs/mockery/reserved_method_names.rst b/vendor/mockery/mockery/docs/mockery/reserved_method_names.rst
new file mode 100644
index 0000000..5ad58d4
--- /dev/null
+++ b/vendor/mockery/mockery/docs/mockery/reserved_method_names.rst
@@ -0,0 +1,33 @@
+.. index::
+ single: Reserved Method Names
+
+Reserved Method Names
+=====================
+
+As you may have noticed, Mockery uses a number of methods called directly on
+all mock objects, for example ``shouldReceive()``. Such methods are necessary
+in order to setup expectations on the given mock, and so they cannot be
+implemented on the classes or objects being mocked without creating a method
+name collision (reported as a PHP fatal error). The methods reserved by
+Mockery are:
+
+* ``shouldReceive()``
+* ``shouldNotReceive()``
+* ``allows()``
+* ``expects()``
+* ``shouldAllowMockingMethod()``
+* ``shouldIgnoreMissing()``
+* ``asUndefined()``
+* ``shouldAllowMockingProtectedMethods()``
+* ``makePartial()``
+* ``byDefault()``
+* ``shouldHaveReceived()``
+* ``shouldHaveBeenCalled()``
+* ``shouldNotHaveReceived()``
+* ``shouldNotHaveBeenCalled()``
+
+
+In addition, all mocks utilise a set of added methods and protected properties
+which cannot exist on the class or object being mocked. These are far less
+likely to cause collisions. All properties are prefixed with ``_mockery`` and
+all method names with ``mockery_``.
diff --git a/vendor/mockery/mockery/docs/reference/alternative_should_receive_syntax.rst b/vendor/mockery/mockery/docs/reference/alternative_should_receive_syntax.rst
new file mode 100644
index 0000000..78c1e83
--- /dev/null
+++ b/vendor/mockery/mockery/docs/reference/alternative_should_receive_syntax.rst
@@ -0,0 +1,91 @@
+.. index::
+ single: Alternative shouldReceive Syntax
+
+Alternative shouldReceive Syntax
+================================
+
+As of Mockery 1.0.0, we support calling methods as we would call any PHP method,
+and not as string arguments to Mockery ``should*`` methods.
+
+The two Mockery methods that enable this are ``allows()`` and ``expects()``.
+
+Allows
+------
+
+We use ``allows()`` when we create stubs for methods that return a predefined
+return value, but for these method stubs we don't care how many times, or if at
+all, were they called.
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->allows([
+ 'name_of_method_1' => 'return value',
+ 'name_of_method_2' => 'return value',
+ ]);
+
+This is equivalent with the following ``shouldReceive`` syntax:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive([
+ 'name_of_method_1' => 'return value',
+ 'name_of_method_2' => 'return value',
+ ]);
+
+Note that with this format, we also tell Mockery that we don't care about the
+arguments to the stubbed methods.
+
+If we do care about the arguments, we would do it like so:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->allows()
+ ->name_of_method_1($arg1)
+ ->andReturn('return value');
+
+This is equivalent with the following ``shouldReceive`` syntax:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('name_of_method_1')
+ ->with($arg1)
+ ->andReturn('return value');
+
+Expects
+-------
+
+We use ``expects()`` when we want to verify that a particular method was called:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->expects()
+ ->name_of_method_1($arg1)
+ ->andReturn('return value');
+
+This is equivalent with the following ``shouldReceive`` syntax:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('name_of_method_1')
+ ->once()
+ ->with($arg1)
+ ->andReturn('return value');
+
+By default ``expects()`` sets up an expectation that the method should be called
+once and once only. If we expect more than one call to the method, we can change
+that expectation:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->expects()
+ ->name_of_method_1($arg1)
+ ->twice()
+ ->andReturn('return value');
+
diff --git a/vendor/mockery/mockery/docs/reference/argument_validation.rst b/vendor/mockery/mockery/docs/reference/argument_validation.rst
new file mode 100644
index 0000000..9351ce4
--- /dev/null
+++ b/vendor/mockery/mockery/docs/reference/argument_validation.rst
@@ -0,0 +1,338 @@
+.. index::
+ single: Argument Validation
+
+Argument Validation
+===================
+
+The arguments passed to the ``with()`` declaration when setting up an
+expectation determine the criteria for matching method calls to expectations.
+Thus, we can setup up many expectations for a single method, each
+differentiated by the expected arguments. Such argument matching is done on a
+"best fit" basis. This ensures explicit matches take precedence over
+generalised matches.
+
+An explicit match is merely where the expected argument and the actual
+argument are easily equated (i.e. using ``===`` or ``==``). More generalised
+matches are possible using regular expressions, class hinting and the
+available generic matchers. The purpose of generalised matchers is to allow
+arguments be defined in non-explicit terms, e.g. ``Mockery::any()`` passed to
+``with()`` will match **any** argument in that position.
+
+Mockery's generic matchers do not cover all possibilities but offers optional
+support for the Hamcrest library of matchers. Hamcrest is a PHP port of the
+similarly named Java library (which has been ported also to Python, Erlang,
+etc). By using Hamcrest, Mockery does not need to duplicate Hamcrest's already
+impressive utility which itself promotes a natural English DSL.
+
+The examples below show Mockery matchers and their Hamcrest equivalent, if there
+is one. Hamcrest uses functions (no namespacing).
+
+.. note::
+
+ If you don't wish to use the global Hamcrest functions, they are all exposed
+ through the ``\Hamcrest\Matchers`` class as well, as static methods. Thus,
+ ``identicalTo($arg)`` is the same as ``\Hamcrest\Matchers::identicalTo($arg)``
+
+The most common matcher is the ``with()`` matcher:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('foo')
+ ->with(1):
+
+It tells mockery that it should receive a call to the ``foo`` method with the
+integer ``1`` as an argument. In cases like this, Mockery first tries to match
+the arguments using ``===`` (identical) comparison operator. If the argument is
+a primitive, and if it fails the identical comparison, Mockery does a fallback
+to the ``==`` (equals) comparison operator.
+
+When matching objects as arguments, Mockery only does the strict ``===``
+comparison, which means only the same ``$object`` will match:
+
+.. code-block:: php
+
+ $object = new stdClass();
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive("foo")
+ ->with($object);
+
+ // Hamcrest equivalent
+ $mock->shouldReceive("foo")
+ ->with(identicalTo($object));
+
+A different instance of ``stdClass`` will **not** match.
+
+.. note::
+
+ The ``Mockery\Matcher\MustBe`` matcher has been deprecated.
+
+If we need a loose comparison of objects, we can do that using Hamcrest's
+``equalTo`` matcher:
+
+.. code-block:: php
+
+ $mock->shouldReceive("foo")
+ ->with(equalTo(new stdClass));
+
+In cases when we don't care about the type, or the value of an argument, just
+that any argument is present, we use ``any()``:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive("foo")
+ ->with(\Mockery::any());
+
+ // Hamcrest equivalent
+ $mock->shouldReceive("foo")
+ ->with(anything())
+
+Anything and everything passed in this argument slot is passed unconstrained.
+
+Validating Types and Resources
+------------------------------
+
+The ``type()`` matcher accepts any string which can be attached to ``is_`` to
+form a valid type check.
+
+To match any PHP resource, we could do the following:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive("foo")
+ ->with(\Mockery::type('resource'));
+
+ // Hamcrest equivalents
+ $mock->shouldReceive("foo")
+ ->with(resourceValue());
+ $mock->shouldReceive("foo")
+ ->with(typeOf('resource'));
+
+It will return a ``true`` from an ``is_resource()`` call, if the provided
+argument to the method is a PHP resource. For example, ``\Mockery::type('float')``
+or Hamcrest's ``floatValue()`` and ``typeOf('float')`` checks use ``is_float()``,
+and ``\Mockery::type('callable')`` or Hamcrest's ``callable()`` uses
+``is_callable()``.
+
+The ``type()`` matcher also accepts a class or interface name to be used in an
+``instanceof`` evaluation of the actual argument. Hamcrest uses ``anInstanceOf()``.
+
+A full list of the type checkers is available at
+`php.net `_ or browse Hamcrest's function
+list in
+`the Hamcrest code `_.
+
+.. _argument-validation-complex-argument-validation:
+
+Complex Argument Validation
+---------------------------
+
+If we want to perform a complex argument validation, the ``on()`` matcher is
+invaluable. It accepts a closure (anonymous function) to which the actual
+argument will be passed.
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive("foo")
+ ->with(\Mockery::on(closure));
+
+If the closure evaluates to (i.e. returns) boolean ``true`` then the argument is
+assumed to have matched the expectation.
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+
+ $mock->shouldReceive('foo')
+ ->with(\Mockery::on(function ($argument) {
+ if ($argument % 2 == 0) {
+ return true;
+ }
+ return false;
+ }));
+
+ $mock->foo(4); // matches the expectation
+ $mock->foo(3); // throws a NoMatchingExpectationException
+
+.. note::
+
+ There is no Hamcrest version of the ``on()`` matcher.
+
+We can also perform argument validation by passing a closure to ``withArgs()``
+method. The closure will receive all arguments passed in the call to the expected
+method and if it evaluates (i.e. returns) to boolean ``true``, then the list of
+arguments is assumed to have matched the expectation:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive("foo")
+ ->withArgs(closure);
+
+The closure can also handle optional parameters, so if an optional parameter is
+missing in the call to the expected method, it doesn't necessary means that the
+list of arguments doesn't match the expectation.
+
+.. code-block:: php
+
+ $closure = function ($odd, $even, $sum = null) {
+ $result = ($odd % 2 != 0) && ($even % 2 == 0);
+ if (!is_null($sum)) {
+ return $result && ($odd + $even == $sum);
+ }
+ return $result;
+ };
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('foo')->withArgs($closure);
+
+ $mock->foo(1, 2); // It matches the expectation: the optional argument is not needed
+ $mock->foo(1, 2, 3); // It also matches the expectation: the optional argument pass the validation
+ $mock->foo(1, 2, 4); // It doesn't match the expectation: the optional doesn't pass the validation
+
+.. note::
+
+ In previous versions, Mockery's ``with()`` would attempt to do a pattern
+ matching against the arguments, attempting to use the argument as a
+ regular expression. Over time this proved to be not such a great idea, so
+ we removed this functionality, and have introduced ``Mockery::pattern()``
+ instead.
+
+If we would like to match an argument against a regular expression, we can use
+the ``\Mockery::pattern()``:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('foo')
+ ->with(\Mockery::pattern('/^foo/'));
+
+ // Hamcrest equivalent
+ $mock->shouldReceive('foo')
+ ->with(matchesPattern('/^foo/'));
+
+The ``ducktype()`` matcher is an alternative to matching by class type:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('foo')
+ ->with(\Mockery::ducktype('foo', 'bar'));
+
+It matches any argument which is an object containing the provided list of
+methods to call.
+
+.. note::
+
+ There is no Hamcrest version of the ``ducktype()`` matcher.
+
+Capturing Arguments
+-------------------
+
+If we want to perform multiple validations on a single argument, the ``capture``
+matcher provides a streamlined alternative to using the ``on()`` matcher.
+It accepts a variable which the actual argument will be assigned.
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive("foo")
+ ->with(\Mockery::capture($bar));
+
+This will assign *any* argument passed to ``foo`` to the local ``$bar`` variable to
+then perform additional validation using assertions.
+
+.. note::
+
+ The ``capture`` matcher always evaluates to ``true``. As such, we should always
+ perform additional argument validation.
+
+Additional Argument Matchers
+----------------------------
+
+The ``not()`` matcher matches any argument which is not equal or identical to
+the matcher's parameter:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('foo')
+ ->with(\Mockery::not(2));
+
+ // Hamcrest equivalent
+ $mock->shouldReceive('foo')
+ ->with(not(2));
+
+``anyOf()`` matches any argument which equals any one of the given parameters:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('foo')
+ ->with(\Mockery::anyOf(1, 2));
+
+ // Hamcrest equivalent
+ $mock->shouldReceive('foo')
+ ->with(anyOf(1,2));
+
+``notAnyOf()`` matches any argument which is not equal or identical to any of
+the given parameters:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('foo')
+ ->with(\Mockery::notAnyOf(1, 2));
+
+.. note::
+
+ There is no Hamcrest version of the ``notAnyOf()`` matcher.
+
+``subset()`` matches any argument which is any array containing the given array
+subset:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('foo')
+ ->with(\Mockery::subset(array(0 => 'foo')));
+
+This enforces both key naming and values, i.e. both the key and value of each
+actual element is compared.
+
+.. note::
+
+ There is no Hamcrest version of this functionality, though Hamcrest can check
+ a single entry using ``hasEntry()`` or ``hasKeyValuePair()``.
+
+``contains()`` matches any argument which is an array containing the listed
+values:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('foo')
+ ->with(\Mockery::contains(value1, value2));
+
+The naming of keys is ignored.
+
+``hasKey()`` matches any argument which is an array containing the given key
+name:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('foo')
+ ->with(\Mockery::hasKey(key));
+
+``hasValue()`` matches any argument which is an array containing the given
+value:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('foo')
+ ->with(\Mockery::hasValue(value));
diff --git a/vendor/mockery/mockery/docs/reference/creating_test_doubles.rst b/vendor/mockery/mockery/docs/reference/creating_test_doubles.rst
new file mode 100644
index 0000000..b675514
--- /dev/null
+++ b/vendor/mockery/mockery/docs/reference/creating_test_doubles.rst
@@ -0,0 +1,435 @@
+.. index::
+ single: Reference; Creating Test Doubles
+
+Creating Test Doubles
+=====================
+
+Mockery's main goal is to help us create test doubles. It can create stubs,
+mocks, and spies.
+
+Stubs and mocks are created the same. The difference between the two is that a
+stub only returns a preset result when called, while a mock needs to have
+expectations set on the method calls it expects to receive.
+
+Spies are a type of test doubles that keep track of the calls they received, and
+allow us to inspect these calls after the fact.
+
+When creating a test double object, we can pass in an identifier as a name for
+our test double. If we pass it no identifier, the test double name will be
+unknown. Furthermore, the identifier does not have to be a class name. It is a
+good practice, and our recommendation, to always name the test doubles with the
+same name as the underlying class we are creating test doubles for.
+
+If the identifier we use for our test double is a name of an existing class,
+the test double will inherit the type of the class (via inheritance), i.e. the
+mock object will pass type hints or ``instanceof`` evaluations for the existing
+class. This is useful when a test double must be of a specific type, to satisfy
+the expectations our code has.
+
+Stubs and mocks
+---------------
+
+Stubs and mocks are created by calling the ``\Mockery::mock()`` method. The
+following example shows how to create a stub, or a mock, object named "foo":
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('foo');
+
+The mock object created like this is the loosest form of mocks possible, and is
+an instance of ``\Mockery\MockInterface``.
+
+.. note::
+
+ All test doubles created with Mockery are an instance of
+ ``\Mockery\MockInterface``, regardless are they a stub, mock or a spy.
+
+To create a stub or a mock object with no name, we can call the ``mock()``
+method with no parameters:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock();
+
+As we stated earlier, we don't recommend creating stub or mock objects without
+a name.
+
+Classes, abstracts, interfaces
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The recommended way to create a stub or a mock object is by using a name of
+an existing class we want to create a test double of:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+
+This stub or mock object will have the type of ``MyClass``, through inheritance.
+
+Stub or mock objects can be based on any concrete class, abstract class or even
+an interface. The primary purpose is to ensure the mock object inherits a
+specific type for type hinting.
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyInterface');
+
+This stub or mock object will implement the ``MyInterface`` interface.
+
+.. note::
+
+ Classes marked final, or classes that have methods marked final cannot be
+ mocked fully. Mockery supports creating partial mocks for these cases.
+ Partial mocks will be explained later in the documentation.
+
+Mockery also supports creating stub or mock objects based on a single existing
+class, which must implement one or more interfaces. We can do this by providing
+a comma-separated list of the class and interfaces as the first argument to the
+``\Mockery::mock()`` method:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass, MyInterface, OtherInterface');
+
+This stub or mock object will now be of type ``MyClass`` and implement the
+``MyInterface`` and ``OtherInterface`` interfaces.
+
+.. note::
+
+ The class name doesn't need to be the first member of the list but it's a
+ friendly convention to use for readability.
+
+We can tell a mock to implement the desired interfaces by passing the list of
+interfaces as the second argument:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass', 'MyInterface, OtherInterface');
+
+For all intents and purposes, this is the same as the previous example.
+
+Spies
+-----
+
+The third type of test doubles Mockery supports are spies. The main difference
+between spies and mock objects is that with spies we verify the calls made
+against our test double after the calls were made. We would use a spy when we
+don't necessarily care about all of the calls that are going to be made to an
+object.
+
+A spy will return ``null`` for all method calls it receives. It is not possible
+to tell a spy what will be the return value of a method call. If we do that, then
+we would deal with a mock object, and not with a spy.
+
+We create a spy by calling the ``\Mockery::spy()`` method:
+
+.. code-block:: php
+
+ $spy = \Mockery::spy('MyClass');
+
+Just as with stubs or mocks, we can tell Mockery to base a spy on any concrete
+or abstract class, or to implement any number of interfaces:
+
+.. code-block:: php
+
+ $spy = \Mockery::spy('MyClass, MyInterface, OtherInterface');
+
+This spy will now be of type ``MyClass`` and implement the ``MyInterface`` and
+``OtherInterface`` interfaces.
+
+.. note::
+
+ The ``\Mockery::spy()`` method call is actually a shorthand for calling
+ ``\Mockery::mock()->shouldIgnoreMissing()``. The ``shouldIgnoreMissing``
+ method is a "behaviour modifier". We'll discuss them a bit later.
+
+Mocks vs. Spies
+---------------
+
+Let's try and illustrate the difference between mocks and spies with the
+following example:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $spy = \Mockery::spy('MyClass');
+
+ $mock->shouldReceive('foo')->andReturn(42);
+
+ $mockResult = $mock->foo();
+ $spyResult = $spy->foo();
+
+ $spy->shouldHaveReceived()->foo();
+
+ var_dump($mockResult); // int(42)
+ var_dump($spyResult); // null
+
+As we can see from this example, with a mock object we set the call expectations
+before the call itself, and we get the return result we expect it to return.
+With a spy object on the other hand, we verify the call has happened after the
+fact. The return result of a method call against a spy is always ``null``.
+
+We also have a dedicated chapter to :doc:`spies` only.
+
+.. _creating-test-doubles-partial-test-doubles:
+
+Partial Test Doubles
+--------------------
+
+Partial doubles are useful when we want to stub out, set expectations for, or
+spy on *some* methods of a class, but run the actual code for other methods.
+
+We differentiate between three types of partial test doubles:
+
+ * runtime partial test doubles,
+ * generated partial test doubles, and
+ * proxied partial test doubles.
+
+Runtime partial test doubles
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+What we call a runtime partial, involves creating a test double and then telling
+it to make itself partial. Any method calls that the double hasn't been told to
+allow or expect, will act as they would on a normal instance of the object.
+
+.. code-block:: php
+
+ class Foo {
+ function foo() { return 123; }
+ function bar() { return $this->foo(); }
+ }
+
+ $foo = mock(Foo::class)->makePartial();
+ $foo->foo(); // int(123);
+
+We can then tell the test double to allow or expect calls as with any other
+Mockery double.
+
+.. code-block:: php
+
+ $foo->shouldReceive('foo')->andReturn(456);
+ $foo->bar(); // int(456)
+
+See the cookbook entry on :doc:`../cookbook/big_parent_class` for an example
+usage of runtime partial test doubles.
+
+Generated partial test doubles
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The second type of partial double we can create is what we call a generated
+partial. With generated partials, we specifically tell Mockery which methods
+we want to be able to allow or expect calls to. All other methods will run the
+actual code *directly*, so stubs and expectations on these methods will not
+work.
+
+.. code-block:: php
+
+ class Foo {
+ function foo() { return 123; }
+ function bar() { return $this->foo(); }
+ }
+
+ $foo = mock("Foo[foo]");
+
+ $foo->foo(); // error, no expectation set
+
+ $foo->shouldReceive('foo')->andReturn(456);
+ $foo->foo(); // int(456)
+
+ // setting an expectation for this has no effect
+ $foo->shouldReceive('bar')->andReturn(999);
+ $foo->bar(); // int(456)
+
+It's also possible to specify explicitly which methods to run directly using
+the `!method` syntax:
+
+.. code-block:: php
+
+ class Foo {
+ function foo() { return 123; }
+ function bar() { return $this->foo(); }
+ }
+
+ $foo = mock("Foo[!foo]");
+
+ $foo->foo(); // int(123)
+
+ $foo->bar(); // error, no expectation set
+
+.. note::
+
+ Even though we support generated partial test doubles, we do not recommend
+ using them.
+
+ One of the reasons why is because a generated partial will call the original
+ constructor of the mocked class. This can have unwanted side-effects during
+ testing application code.
+
+ See :doc:`../cookbook/not_calling_the_constructor` for more details.
+
+Proxied partial test doubles
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+A proxied partial mock is a partial of last resort. We may encounter a class
+which is simply not capable of being mocked because it has been marked as
+final. Similarly, we may find a class with methods marked as final. In such a
+scenario, we cannot simply extend the class and override methods to mock - we
+need to get creative.
+
+.. code-block:: php
+
+ $mock = \Mockery::mock(new MyClass);
+
+Yes, the new mock is a Proxy. It intercepts calls and reroutes them to the
+proxied object (which we construct and pass in) for methods which are not
+subject to any expectations. Indirectly, this allows us to mock methods
+marked final since the Proxy is not subject to those limitations. The tradeoff
+should be obvious - a proxied partial will fail any typehint checks for the
+class being mocked since it cannot extend that class.
+
+.. _creating-test-doubles-aliasing:
+
+Aliasing
+--------
+
+Prefixing the valid name of a class (which is NOT currently loaded) with
+"alias:" will generate an "alias mock". Alias mocks create a class alias with
+the given classname to stdClass and are generally used to enable the mocking
+of public static methods. Expectations set on the new mock object which refer
+to static methods will be used by all static calls to this class.
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('alias:MyClass');
+
+
+.. note::
+
+ Even though aliasing classes is supported, we do not recommend it.
+
+Overloading
+-----------
+
+Prefixing the valid name of a class (which is NOT currently loaded) with
+"overload:" will generate an alias mock (as with "alias:") except that created
+new instances of that class will import any expectations set on the origin
+mock (``$mock``). The origin mock is never verified since it's used an
+expectation store for new instances. For this purpose we use the term "instance
+mock" to differentiate it from the simpler "alias mock".
+
+In other words, an instance mock will "intercept" when a new instance of the
+mocked class is created, then the mock will be used instead. This is useful
+especially when mocking hard dependencies which will be discussed later.
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('overload:MyClass');
+
+.. note::
+
+ Using alias/instance mocks across more than one test will generate a fatal
+ error since we can't have two classes of the same name. To avoid this,
+ run each test of this kind in a separate PHP process (which is supported
+ out of the box by both PHPUnit and PHPT).
+
+
+.. _creating-test-doubles-named-mocks:
+
+Named Mocks
+-----------
+
+The ``namedMock()`` method will generate a class called by the first argument,
+so in this example ``MyClassName``. The rest of the arguments are treated in the
+same way as the ``mock`` method:
+
+.. code-block:: php
+
+ $mock = \Mockery::namedMock('MyClassName', 'DateTime');
+
+This example would create a class called ``MyClassName`` that extends
+``DateTime``.
+
+Named mocks are quite an edge case, but they can be useful when code depends
+on the ``__CLASS__`` magic constant, or when we need two derivatives of an
+abstract type, that are actually different classes.
+
+See the cookbook entry on :doc:`../cookbook/class_constants` for an example
+usage of named mocks.
+
+.. note::
+
+ We can only create a named mock once, any subsequent calls to
+ ``namedMock``, with different arguments are likely to cause exceptions.
+
+.. _creating-test-doubles-constructor-arguments:
+
+Constructor Arguments
+---------------------
+
+Sometimes the mocked class has required constructor arguments. We can pass these
+to Mockery as an indexed array, as the 2nd argument:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass', [$constructorArg1, $constructorArg2]);
+
+or if we need the ``MyClass`` to implement an interface as well, as the 3rd
+argument:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass', 'MyInterface', [$constructorArg1, $constructorArg2]);
+
+Mockery now knows to pass in ``$constructorArg1`` and ``$constructorArg2`` as
+arguments to the constructor.
+
+.. _creating-test-doubles-behavior-modifiers:
+
+Behavior Modifiers
+------------------
+
+When creating a mock object, we may wish to use some commonly preferred
+behaviours that are not the default in Mockery.
+
+The use of the ``shouldIgnoreMissing()`` behaviour modifier will label this
+mock object as a Passive Mock:
+
+.. code-block:: php
+
+ \Mockery::mock('MyClass')->shouldIgnoreMissing();
+
+In such a mock object, calls to methods which are not covered by expectations
+will return ``null`` instead of the usual error about there being no expectation
+matching the call.
+
+On PHP >= 7.0.0, methods with missing expectations that have a return type
+will return either a mock of the object (if return type is a class) or a
+"falsy" primitive value, e.g. empty string, empty array, zero for ints and
+floats, false for bools, or empty closures.
+
+On PHP >= 7.1.0, methods with missing expectations and nullable return type
+will return null.
+
+We can optionally prefer to return an object of type ``\Mockery\Undefined``
+(i.e. a ``null`` object) (which was the 0.7.2 behaviour) by using an
+additional modifier:
+
+.. code-block:: php
+
+ \Mockery::mock('MyClass')->shouldIgnoreMissing()->asUndefined();
+
+The returned object is nothing more than a placeholder so if, by some act of
+fate, it's erroneously used somewhere it shouldn't, it will likely not pass a
+logic check.
+
+We have encountered the ``makePartial()`` method before, as it is the method we
+use to create runtime partial test doubles:
+
+.. code-block:: php
+
+ \Mockery::mock('MyClass')->makePartial();
+
+This form of mock object will defer all methods not subject to an expectation to
+the parent class of the mock, i.e. ``MyClass``. Whereas the previous
+``shouldIgnoreMissing()`` returned ``null``, this behaviour simply calls the
+parent's matching method.
diff --git a/vendor/mockery/mockery/docs/reference/demeter_chains.rst b/vendor/mockery/mockery/docs/reference/demeter_chains.rst
new file mode 100644
index 0000000..1dad5ef
--- /dev/null
+++ b/vendor/mockery/mockery/docs/reference/demeter_chains.rst
@@ -0,0 +1,38 @@
+.. index::
+ single: Mocking; Demeter Chains
+
+Mocking Demeter Chains And Fluent Interfaces
+============================================
+
+Both of these terms refer to the growing practice of invoking statements
+similar to:
+
+.. code-block:: php
+
+ $object->foo()->bar()->zebra()->alpha()->selfDestruct();
+
+The long chain of method calls isn't necessarily a bad thing, assuming they
+each link back to a local object the calling class knows. As a fun example,
+Mockery's long chains (after the first ``shouldReceive()`` method) all call to
+the same instance of ``\Mockery\Expectation``. However, sometimes this is not
+the case and the chain is constantly crossing object boundaries.
+
+In either case, mocking such a chain can be a horrible task. To make it easier
+Mockery supports demeter chain mocking. Essentially, we shortcut through the
+chain and return a defined value from the final call. For example, let's
+assume ``selfDestruct()`` returns the string "Ten!" to $object (an instance of
+``CaptainsConsole``). Here's how we could mock it.
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('CaptainsConsole');
+ $mock->shouldReceive('foo->bar->zebra->alpha->selfDestruct')->andReturn('Ten!');
+
+The above expectation can follow any previously seen format or expectation,
+except that the method name is simply the string of all expected chain calls
+separated by ``->``. Mockery will automatically setup the chain of expected
+calls with its final return values, regardless of whatever intermediary object
+might be used in the real implementation.
+
+Arguments to all members of the chain (except the final call) are ignored in
+this process.
diff --git a/vendor/mockery/mockery/docs/reference/expectations.rst b/vendor/mockery/mockery/docs/reference/expectations.rst
new file mode 100644
index 0000000..4430e97
--- /dev/null
+++ b/vendor/mockery/mockery/docs/reference/expectations.rst
@@ -0,0 +1,533 @@
+.. index::
+ single: Expectations
+
+Expectation Declarations
+========================
+
+.. note::
+
+ In order for our expectations to work we MUST call ``Mockery::close()``,
+ preferably in a callback method such as ``tearDown`` or ``_after``
+ (depending on whether or not we're integrating Mockery with another
+ framework). This static call cleans up the Mockery container used by the
+ current test, and run any verification tasks needed for our expectations.
+
+Once we have created a mock object, we'll often want to start defining how
+exactly it should behave (and how it should be called). This is where the
+Mockery expectation declarations take over.
+
+Declaring Method Call Expectations
+----------------------------------
+
+To tell our test double to expect a call for a method with a given name, we use
+the ``shouldReceive`` method:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('name_of_method');
+
+This is the starting expectation upon which all other expectations and
+constraints are appended.
+
+We can declare more than one method call to be expected:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('name_of_method_1', 'name_of_method_2');
+
+All of these will adopt any chained expectations or constraints.
+
+It is possible to declare the expectations for the method calls, along with
+their return values:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive([
+ 'name_of_method_1' => 'return value 1',
+ 'name_of_method_2' => 'return value 2',
+ ]);
+
+There's also a shorthand way of setting up method call expectations and their
+return values:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass', ['name_of_method_1' => 'return value 1', 'name_of_method_2' => 'return value 2']);
+
+All of these will adopt any additional chained expectations or constraints.
+
+We can declare that a test double should not expect a call to the given method
+name:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldNotReceive('name_of_method');
+
+This method is a convenience method for calling ``shouldReceive()->never()``.
+
+Declaring Method Argument Expectations
+--------------------------------------
+
+For every method we declare expectation for, we can add constraints that the
+defined expectations apply only to the method calls that match the expected
+argument list:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('name_of_method')
+ ->with($arg1, $arg2, ...);
+ // or
+ $mock->shouldReceive('name_of_method')
+ ->withArgs([$arg1, $arg2, ...]);
+
+We can add a lot more flexibility to argument matching using the built in
+matcher classes (see later). For example, ``\Mockery::any()`` matches any
+argument passed to that position in the ``with()`` parameter list. Mockery also
+allows Hamcrest library matchers - for example, the Hamcrest function
+``anything()`` is equivalent to ``\Mockery::any()``.
+
+It's important to note that this means all expectations attached only apply to
+the given method when it is called with these exact arguments:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+
+ $mock->shouldReceive('foo')->with('Hello');
+
+ $mock->foo('Goodbye'); // throws a NoMatchingExpectationException
+
+This allows for setting up differing expectations based on the arguments
+provided to expected calls.
+
+Argument matching with closures
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Instead of providing a built-in matcher for each argument, we can provide a
+closure that matches all passed arguments at once:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('name_of_method')
+ ->withArgs(closure);
+
+The given closure receives all the arguments passed in the call to the expected
+method. In this way, this expectation only applies to method calls where passed
+arguments make the closure evaluate to true:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+
+ $mock->shouldReceive('foo')->withArgs(function ($arg) {
+ if ($arg % 2 == 0) {
+ return true;
+ }
+ return false;
+ });
+
+ $mock->foo(4); // matches the expectation
+ $mock->foo(3); // throws a NoMatchingExpectationException
+
+Argument matching with some of given values
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+We can provide expected arguments that match passed arguments when mocked method
+is called.
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('name_of_method')
+ ->withSomeOfArgs(arg1, arg2, arg3, ...);
+
+The given expected arguments order doesn't matter.
+Check if expected values are included or not, but type should be matched:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('foo')
+ ->withSomeOfArgs(1, 2);
+
+ $mock->foo(1, 2, 3); // matches the expectation
+ $mock->foo(3, 2, 1); // matches the expectation (passed order doesn't matter)
+ $mock->foo('1', '2'); // throws a NoMatchingExpectationException (type should be matched)
+ $mock->foo(3); // throws a NoMatchingExpectationException
+
+Any, or no arguments
+^^^^^^^^^^^^^^^^^^^^
+
+We can declare that the expectation matches a method call regardless of what
+arguments are passed:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('name_of_method')
+ ->withAnyArgs();
+
+This is set by default unless otherwise specified.
+
+We can declare that the expectation matches method calls with zero arguments:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('name_of_method')
+ ->withNoArgs();
+
+Declaring Return Value Expectations
+-----------------------------------
+
+For mock objects, we can tell Mockery what return values to return from the
+expected method calls.
+
+For that we can use the ``andReturn()`` method:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('name_of_method')
+ ->andReturn($value);
+
+This sets a value to be returned from the expected method call.
+
+It is possible to set up expectation for multiple return values. By providing
+a sequence of return values, we tell Mockery what value to return on every
+subsequent call to the method:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('name_of_method')
+ ->andReturn($value1, $value2, ...)
+
+The first call will return ``$value1`` and the second call will return ``$value2``.
+
+If we call the method more times than the number of return values we declared,
+Mockery will return the final value for any subsequent method call:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+
+ $mock->shouldReceive('foo')->andReturn(1, 2, 3);
+
+ $mock->foo(); // int(1)
+ $mock->foo(); // int(2)
+ $mock->foo(); // int(3)
+ $mock->foo(); // int(3)
+
+The same can be achieved using the alternative syntax:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('name_of_method')
+ ->andReturnValues([$value1, $value2, ...])
+
+It accepts a simple array instead of a list of parameters. The order of return
+is determined by the numerical index of the given array with the last array
+member being returned on all calls once previous return values are exhausted.
+
+The following two options are primarily for communication with test readers:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('name_of_method')
+ ->andReturnNull();
+ // or
+ $mock->shouldReceive('name_of_method')
+ ->andReturn([null]);
+
+They mark the mock object method call as returning ``null`` or nothing.
+
+Sometimes we want to calculate the return results of the method calls, based on
+the arguments passed to the method. We can do that with the ``andReturnUsing()``
+method which accepts one or more closure:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('name_of_method')
+ ->andReturnUsing(closure, ...);
+
+Closures can be queued by passing them as extra parameters as for ``andReturn()``.
+
+Occasionally, it can be useful to echo back one of the arguments that a method
+is called with. In this case we can use the ``andReturnArg()`` method; the
+argument to be returned is specified by its index in the arguments list:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('name_of_method')
+ ->andReturnArg(1);
+
+This returns the second argument (index #1) from the list of arguments when the
+method is called.
+
+.. note::
+
+ We cannot currently mix ``andReturnUsing()`` or ``andReturnArg`` with
+ ``andReturn()``.
+
+If we are mocking fluid interfaces, the following method will be helpful:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('name_of_method')
+ ->andReturnSelf();
+
+It sets the return value to the mocked class name.
+
+Throwing Exceptions
+-------------------
+
+We can tell the method of mock objects to throw exceptions:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('name_of_method')
+ ->andThrow(new Exception);
+
+It will throw the given ``Exception`` object when called.
+
+Rather than an object, we can pass in the ``Exception`` class, message and/or code to
+use when throwing an ``Exception`` from the mocked method:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('name_of_method')
+ ->andThrow('exception_name', 'message', 123456789);
+
+.. _expectations-setting-public-properties:
+
+Setting Public Properties
+-------------------------
+
+Used with an expectation so that when a matching method is called, we can cause
+a mock object's public property to be set to a specified value, by using
+``andSet()`` or ``set()``:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('name_of_method')
+ ->andSet($property, $value);
+ // or
+ $mock->shouldReceive('name_of_method')
+ ->set($property, $value);
+
+In cases where we want to call the real method of the class that was mocked and
+return its result, the ``passthru()`` method tells the expectation to bypass
+a return queue:
+
+.. code-block:: php
+
+ passthru()
+
+It allows expectation matching and call count validation to be applied against
+real methods while still calling the real class method with the expected
+arguments.
+
+Declaring Call Count Expectations
+---------------------------------
+
+Besides setting expectations on the arguments of the method calls, and the
+return values of those same calls, we can set expectations on how many times
+should any method be called.
+
+When a call count expectation is not met, a
+``\Mockery\Expectation\InvalidCountException`` will be thrown.
+
+.. note::
+
+ It is absolutely required to call ``\Mockery::close()`` at the end of our
+ tests, for example in the ``tearDown()`` method of PHPUnit. Otherwise
+ Mockery will not verify the calls made against our mock objects.
+
+We can declare that the expected method may be called zero or more times:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('name_of_method')
+ ->zeroOrMoreTimes();
+
+This is the default for all methods unless otherwise set.
+
+To tell Mockery to expect an exact number of calls to a method, we can use the
+following:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('name_of_method')
+ ->times($n);
+
+where ``$n`` is the number of times the method should be called.
+
+A couple of most common cases got their shorthand methods.
+
+To declare that the expected method must be called one time only:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('name_of_method')
+ ->once();
+
+To declare that the expected method must be called two times:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('name_of_method')
+ ->twice();
+
+To declare that the expected method must never be called:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('name_of_method')
+ ->never();
+
+Call count modifiers
+^^^^^^^^^^^^^^^^^^^^
+
+The call count expectations can have modifiers set.
+
+If we want to tell Mockery the minimum number of times a method should be called,
+we use ``atLeast()``:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('name_of_method')
+ ->atLeast()
+ ->times(3);
+
+``atLeast()->times(3)`` means the call must be called at least three times
+(given matching method args) but never less than three times.
+
+Similarly, we can tell Mockery the maximum number of times a method should be
+called, using ``atMost()``:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('name_of_method')
+ ->atMost()
+ ->times(3);
+
+``atMost()->times(3)`` means the call must be called no more than three times.
+If the method gets no calls at all, the expectation will still be met.
+
+We can also set a range of call counts, using ``between()``:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ $mock->shouldReceive('name_of_method')
+ ->between($min, $max);
+
+This is actually identical to using ``atLeast()->times($min)->atMost()->times($max)``
+but is provided as a shorthand. It may be followed by a ``times()`` call with no
+parameter to preserve the APIs natural language readability.
+
+Multiple Calls with Different Expectations
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+If a method is expected to get called multiple times with different arguments
+and/or return values we can simply repeat the expectations. The same of course
+also works if we expect multiple calls to different methods.
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass');
+ // Expectations for the 1st call
+ $mock->shouldReceive('name_of_method')
+ ->once()
+ ->with('arg1')
+ ->andReturn($value1)
+
+ // 2nd call to same method
+ ->shouldReceive('name_of_method')
+ ->once()
+ ->with('arg2')
+ ->andReturn($value2)
+
+ // final call to another method
+ ->shouldReceive('other_method')
+ ->once()
+ ->with('other')
+ ->andReturn($value_other);
+
+Expectation Declaration Utilities
+---------------------------------
+
+Declares that this method is expected to be called in a specific order in
+relation to similarly marked methods.
+
+.. code-block:: php
+
+ ordered()
+
+The order is dictated by the order in which this modifier is actually used when
+setting up mocks.
+
+Declares the method as belonging to an order group (which can be named or
+numbered). Methods within a group can be called in any order, but the ordered
+calls from outside the group are ordered in relation to the group:
+
+.. code-block:: php
+
+ ordered(group)
+
+We can set up so that method1 is called before group1 which is in turn called
+before method2.
+
+When called prior to ``ordered()`` or ``ordered(group)``, it declares this
+ordering to apply across all mock objects (not just the current mock):
+
+.. code-block:: php
+
+ globally()
+
+This allows for dictating order expectations across multiple mocks.
+
+The ``byDefault()`` marks an expectation as a default. Default expectations are
+applied unless a non-default expectation is created:
+
+.. code-block:: php
+
+ byDefault()
+
+These later expectations immediately replace the previously defined default.
+This is useful so we can setup default mocks in our unit test ``setup()`` and
+later tweak them in specific tests as needed.
+
+Returns the current mock object from an expectation chain:
+
+.. code-block:: php
+
+ getMock()
+
+Useful where we prefer to keep mock setups as a single statement, e.g.:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('foo')->shouldReceive('foo')->andReturn(1)->getMock();
diff --git a/vendor/mockery/mockery/docs/reference/final_methods_classes.rst b/vendor/mockery/mockery/docs/reference/final_methods_classes.rst
new file mode 100644
index 0000000..dd0fa5b
--- /dev/null
+++ b/vendor/mockery/mockery/docs/reference/final_methods_classes.rst
@@ -0,0 +1,29 @@
+.. index::
+ single: Mocking; Final Classes/Methods
+
+Dealing with Final Classes/Methods
+==================================
+
+One of the primary restrictions of mock objects in PHP, is that mocking
+classes or methods marked final is hard. The final keyword prevents methods so
+marked from being replaced in subclasses (subclassing is how mock objects can
+inherit the type of the class or object being mocked).
+
+The simplest solution is to implement an interface in your final class and
+typehint against / mock this.
+
+However this may not be possible in some third party libraries.
+Mockery does allow creating "proxy mocks" from classes marked final, or from
+classes with methods marked final. This offers all the usual mock object
+goodness but the resulting mock will not inherit the class type of the object
+being mocked, i.e. it will not pass any instanceof comparison. Methods marked
+as final will be proxied to the original method, i.e., final methods can't be
+mocked.
+
+We can create a proxy mock by passing the instantiated object we wish to
+mock into ``\Mockery::mock()``, i.e. Mockery will then generate a Proxy to the
+real object and selectively intercept method calls for the purposes of setting
+and meeting expectations.
+
+See the :ref:`creating-test-doubles-partial-test-doubles` chapter, the subsection
+about proxied partial test doubles.
diff --git a/vendor/mockery/mockery/docs/reference/index.rst b/vendor/mockery/mockery/docs/reference/index.rst
new file mode 100644
index 0000000..7d6a038
--- /dev/null
+++ b/vendor/mockery/mockery/docs/reference/index.rst
@@ -0,0 +1,23 @@
+Reference
+=========
+
+.. toctree::
+ :hidden:
+
+ creating_test_doubles
+ expectations
+ argument_validation
+ alternative_should_receive_syntax
+ spies
+ instance_mocking
+ partial_mocks
+ protected_methods
+ public_properties
+ public_static_properties
+ pass_by_reference_behaviours
+ demeter_chains
+ final_methods_classes
+ magic_methods
+ phpunit_integration
+
+.. include:: map.rst.inc
diff --git a/vendor/mockery/mockery/docs/reference/instance_mocking.rst b/vendor/mockery/mockery/docs/reference/instance_mocking.rst
new file mode 100644
index 0000000..9d1aa28
--- /dev/null
+++ b/vendor/mockery/mockery/docs/reference/instance_mocking.rst
@@ -0,0 +1,22 @@
+.. index::
+ single: Mocking; Instance
+
+Instance Mocking
+================
+
+Instance mocking means that a statement like:
+
+.. code-block:: php
+
+ $obj = new \MyNamespace\Foo;
+
+...will actually generate a mock object. This is done by replacing the real
+class with an instance mock (similar to an alias mock), as with mocking public
+methods. The alias will import its expectations from the original mock of
+that type (note that the original is never verified and should be ignored
+after its expectations are setup). This lets you intercept instantiation where
+you can't simply inject a replacement object.
+
+As before, this does not prevent a require statement from including the real
+class and triggering a fatal PHP error. It's intended for use where
+autoloading is the primary class loading mechanism.
diff --git a/vendor/mockery/mockery/docs/reference/magic_methods.rst b/vendor/mockery/mockery/docs/reference/magic_methods.rst
new file mode 100644
index 0000000..39591cf
--- /dev/null
+++ b/vendor/mockery/mockery/docs/reference/magic_methods.rst
@@ -0,0 +1,16 @@
+.. index::
+ single: Mocking; Magic Methods
+
+PHP Magic Methods
+=================
+
+PHP magic methods which are prefixed with a double underscore, e.g.
+``__set()``, pose a particular problem in mocking and unit testing in general.
+It is strongly recommended that unit tests and mock objects do not directly
+refer to magic methods. Instead, refer only to the virtual methods and
+properties these magic methods simulate.
+
+Following this piece of advice will ensure we are testing the real API of
+classes and also ensures there is no conflict should Mockery override these
+magic methods, which it will inevitably do in order to support its role in
+intercepting method calls and properties.
diff --git a/vendor/mockery/mockery/docs/reference/map.rst.inc b/vendor/mockery/mockery/docs/reference/map.rst.inc
new file mode 100644
index 0000000..883bc3c
--- /dev/null
+++ b/vendor/mockery/mockery/docs/reference/map.rst.inc
@@ -0,0 +1,14 @@
+* :doc:`/reference/creating_test_doubles`
+* :doc:`/reference/expectations`
+* :doc:`/reference/argument_validation`
+* :doc:`/reference/alternative_should_receive_syntax`
+* :doc:`/reference/spies`
+* :doc:`/reference/partial_mocks`
+* :doc:`/reference/protected_methods`
+* :doc:`/reference/public_properties`
+* :doc:`/reference/public_static_properties`
+* :doc:`/reference/pass_by_reference_behaviours`
+* :doc:`/reference/demeter_chains`
+* :doc:`/reference/final_methods_classes`
+* :doc:`/reference/magic_methods`
+* :doc:`/reference/phpunit_integration`
diff --git a/vendor/mockery/mockery/docs/reference/partial_mocks.rst b/vendor/mockery/mockery/docs/reference/partial_mocks.rst
new file mode 100644
index 0000000..457eb8d
--- /dev/null
+++ b/vendor/mockery/mockery/docs/reference/partial_mocks.rst
@@ -0,0 +1,108 @@
+.. index::
+ single: Mocking; Partial Mocks
+
+Creating Partial Mocks
+======================
+
+Partial mocks are useful when we only need to mock several methods of an
+object leaving the remainder free to respond to calls normally (i.e. as
+implemented). Mockery implements three distinct strategies for creating
+partials. Each has specific advantages and disadvantages so which strategy we
+use will depend on our own preferences and the source code in need of
+mocking.
+
+We have previously talked a bit about :ref:`creating-test-doubles-partial-test-doubles`,
+but we'd like to expand on the subject a bit here.
+
+#. Runtime partial test doubles
+#. Generated partial test doubles
+#. Proxied Partial Mock
+
+Runtime partial test doubles
+----------------------------
+
+A runtime partial test double, also known as a passive partial mock, is a kind
+of a default state of being for a mocked object.
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass')->makePartial();
+
+With a runtime partial, we assume that all methods will simply defer to the
+parent class (``MyClass``) original methods unless a method call matches a
+known expectation. If we have no matching expectation for a specific method
+call, that call is deferred to the class being mocked. Since the division
+between mocked and unmocked calls depends entirely on the expectations we
+define, there is no need to define which methods to mock in advance.
+
+See the cookbook entry on :doc:`../cookbook/big_parent_class` for an example
+usage of runtime partial test doubles.
+
+Generated Partial Test Doubles
+------------------------------
+
+A generated partial test double, also known as a traditional partial mock,
+defines ahead of time which methods of a class are to be mocked and which are
+to be left unmocked (i.e. callable as normal). The syntax for creating
+traditional mocks is:
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyClass[foo,bar]');
+
+In the above example, the ``foo()`` and ``bar()`` methods of MyClass will be
+mocked but no other MyClass methods are touched. We will need to define
+expectations for the ``foo()`` and ``bar()`` methods to dictate their mocked
+behaviour.
+
+Don't forget that we can pass in constructor arguments since unmocked methods
+may rely on those!
+
+.. code-block:: php
+
+ $mock = \Mockery::mock('MyNamespace\MyClass[foo]', array($arg1, $arg2));
+
+See the :ref:`creating-test-doubles-constructor-arguments` section to read up
+on them.
+
+.. note::
+
+ Even though we support generated partial test doubles, we do not recommend
+ using them.
+
+Proxied Partial Mock
+--------------------
+
+A proxied partial mock is a partial of last resort. We may encounter a class
+which is simply not capable of being mocked because it has been marked as
+final. Similarly, we may find a class with methods marked as final. In such a
+scenario, we cannot simply extend the class and override methods to mock - we
+need to get creative.
+
+.. code-block:: php
+
+ $mock = \Mockery::mock(new MyClass);
+
+Yes, the new mock is a Proxy. It intercepts calls and reroutes them to the
+proxied object (which we construct and pass in) for methods which are not
+subject to any expectations. Indirectly, this allows us to mock methods
+marked final since the Proxy is not subject to those limitations. The tradeoff
+should be obvious - a proxied partial will fail any typehint checks for the
+class being mocked since it cannot extend that class.
+
+Special Internal Cases
+----------------------
+
+All mock objects, with the exception of Proxied Partials, allows us to make
+any expectation call to the underlying real class method using the ``passthru()``
+expectation call. This will return values from the real call and bypass any
+mocked return queue (which can simply be omitted obviously).
+
+There is a fourth kind of partial mock reserved for internal use. This is
+automatically generated when we attempt to mock a class containing methods
+marked final. Since we cannot override such methods, they are simply left
+unmocked. Typically, we don't need to worry about this but if we really
+really must mock a final method, the only possible means is through a Proxied
+Partial Mock. SplFileInfo, for example, is a common class subject to this form
+of automatic internal partial since it contains public final methods used
+internally.
diff --git a/vendor/mockery/mockery/docs/reference/pass_by_reference_behaviours.rst b/vendor/mockery/mockery/docs/reference/pass_by_reference_behaviours.rst
new file mode 100644
index 0000000..5e2e457
--- /dev/null
+++ b/vendor/mockery/mockery/docs/reference/pass_by_reference_behaviours.rst
@@ -0,0 +1,130 @@
+.. index::
+ single: Pass-By-Reference Method Parameter Behaviour
+
+Preserving Pass-By-Reference Method Parameter Behaviour
+=======================================================
+
+PHP Class method may accept parameters by reference. In this case, changes
+made to the parameter (a reference to the original variable passed to the
+method) are reflected in the original variable. An example:
+
+.. code-block:: php
+
+ class Foo
+ {
+
+ public function bar(&$a)
+ {
+ $a++;
+ }
+
+ }
+
+ $baz = 1;
+ $foo = new Foo;
+ $foo->bar($baz);
+
+ echo $baz; // will echo the integer 2
+
+In the example above, the variable ``$baz`` is passed by reference to
+``Foo::bar()`` (notice the ``&`` symbol in front of the parameter?). Any
+change ``bar()`` makes to the parameter reference is reflected in the original
+variable, ``$baz``.
+
+Mockery handles references correctly for all methods where it can analyse
+the parameter (using ``Reflection``) to see if it is passed by reference. To
+mock how a reference is manipulated by the class method, we can use a closure
+argument matcher to manipulate it, i.e. ``\Mockery::on()`` - see the
+:ref:`argument-validation-complex-argument-validation` chapter.
+
+There is an exception for internal PHP classes where Mockery cannot analyse
+method parameters using ``Reflection`` (a limitation in PHP). To work around
+this, we can explicitly declare method parameters for an internal class using
+``\Mockery\Configuration::setInternalClassMethodParamMap()``.
+
+Here's an example using ``MongoCollection::insert()``. ``MongoCollection`` is
+an internal class offered by the mongo extension from PECL. Its ``insert()``
+method accepts an array of data as the first parameter, and an optional
+options array as the second parameter. The original data array is updated
+(i.e. when a ``insert()`` pass-by-reference parameter) to include a new
+``_id`` field. We can mock this behaviour using a configured parameter map (to
+tell Mockery to expect a pass by reference parameter) and a ``Closure``
+attached to the expected method parameter to be updated.
+
+Here's a PHPUnit unit test verifying that this pass-by-reference behaviour is
+preserved:
+
+.. code-block:: php
+
+ public function testCanOverrideExpectedParametersOfInternalPHPClassesToPreserveRefs()
+ {
+ \Mockery::getConfiguration()->setInternalClassMethodParamMap(
+ 'MongoCollection',
+ 'insert',
+ array('&$data', '$options = array()')
+ );
+ $m = \Mockery::mock('MongoCollection');
+ $m->shouldReceive('insert')->with(
+ \Mockery::on(function(&$data) {
+ if (!is_array($data)) return false;
+ $data['_id'] = 123;
+ return true;
+ }),
+ \Mockery::any()
+ );
+
+ $data = array('a'=>1,'b'=>2);
+ $m->insert($data);
+
+ $this->assertTrue(isset($data['_id']));
+ $this->assertEquals(123, $data['_id']);
+
+ \Mockery::resetContainer();
+ }
+
+Protected Methods
+-----------------
+
+When dealing with protected methods, and trying to preserve pass by reference
+behavior for them, a different approach is required.
+
+.. code-block:: php
+
+ class Model
+ {
+ public function test(&$data)
+ {
+ return $this->doTest($data);
+ }
+
+ protected function doTest(&$data)
+ {
+ $data['something'] = 'wrong';
+ return $this;
+ }
+ }
+
+ class Test extends \PHPUnit\Framework\TestCase
+ {
+ public function testModel()
+ {
+ $mock = \Mockery::mock('Model[test]')->shouldAllowMockingProtectedMethods();
+
+ $mock->shouldReceive('test')
+ ->with(\Mockery::on(function(&$data) {
+ $data['something'] = 'wrong';
+ return true;
+ }));
+
+ $data = array('foo' => 'bar');
+
+ $mock->test($data);
+ $this->assertTrue(isset($data['something']));
+ $this->assertEquals('wrong', $data['something']);
+ }
+ }
+
+This is quite an edge case, so we need to change the original code a little bit,
+by creating a public method that will call our protected method, and then mock
+that, instead of the protected method. This new public method will act as a
+proxy to our protected method.
diff --git a/vendor/mockery/mockery/docs/reference/phpunit_integration.rst b/vendor/mockery/mockery/docs/reference/phpunit_integration.rst
new file mode 100644
index 0000000..669a8ca
--- /dev/null
+++ b/vendor/mockery/mockery/docs/reference/phpunit_integration.rst
@@ -0,0 +1,145 @@
+.. index::
+ single: PHPUnit Integration
+
+PHPUnit Integration
+===================
+
+Mockery was designed as a simple-to-use *standalone* mock object framework, so
+its need for integration with any testing framework is entirely optional. To
+integrate Mockery, we need to define a ``tearDown()`` method for our tests
+containing the following (we may use a shorter ``\Mockery`` namespace
+alias):
+
+.. code-block:: php
+
+ public function tearDown() {
+ \Mockery::close();
+ }
+
+This static call cleans up the Mockery container used by the current test, and
+run any verification tasks needed for our expectations.
+
+For some added brevity when it comes to using Mockery, we can also explicitly
+use the Mockery namespace with a shorter alias. For example:
+
+.. code-block:: php
+
+ use \Mockery as m;
+
+ class SimpleTest extends \PHPUnit\Framework\TestCase
+ {
+ public function testSimpleMock() {
+ $mock = m::mock('simplemock');
+ $mock->shouldReceive('foo')->with(5, m::any())->once()->andReturn(10);
+
+ $this->assertEquals(10, $mock->foo(5));
+ }
+
+ public function tearDown() {
+ m::close();
+ }
+ }
+
+Mockery ships with an autoloader so we don't need to litter our tests with
+``require_once()`` calls. To use it, ensure Mockery is on our
+``include_path`` and add the following to our test suite's ``Bootstrap.php``
+or ``TestHelper.php`` file:
+
+.. code-block:: php
+
+ require_once 'Mockery/Loader.php';
+ require_once 'Hamcrest/Hamcrest.php';
+
+ $loader = new \Mockery\Loader;
+ $loader->register();
+
+If we are using Composer, we can simplify this to including the Composer
+generated autoloader file:
+
+.. code-block:: php
+
+ require __DIR__ . '/../vendor/autoload.php'; // assuming vendor is one directory up
+
+.. caution::
+
+ Prior to Hamcrest 1.0.0, the ``Hamcrest.php`` file name had a small "h"
+ (i.e. ``hamcrest.php``). If upgrading Hamcrest to 1.0.0 remember to check
+ the file name is updated for all your projects.)
+
+To integrate Mockery into PHPUnit and avoid having to call the close method
+and have Mockery remove itself from code coverage reports, have your test case
+extends the ``\Mockery\Adapter\Phpunit\MockeryTestCase``:
+
+.. code-block:: php
+
+ class MyTest extends \Mockery\Adapter\Phpunit\MockeryTestCase
+ {
+
+ }
+
+An alternative is to use the supplied trait:
+
+.. code-block:: php
+
+ class MyTest extends \PHPUnit\Framework\TestCase
+ {
+ use \Mockery\Adapter\Phpunit\MockeryPHPUnitIntegration;
+ }
+
+Extending ``MockeryTestCase`` or using the ``MockeryPHPUnitIntegration``
+trait is **the recommended way** of integrating Mockery with PHPUnit,
+since Mockery 1.0.0.
+
+PHPUnit listener
+----------------
+
+Before the 1.0.0 release, Mockery provided a PHPUnit listener that would
+call ``Mockery::close()`` for us at the end of a test. This has changed
+significantly since the 1.0.0 version.
+
+Now, Mockery provides a PHPUnit listener that makes tests fail if
+``Mockery::close()`` has not been called. It can help identify tests where
+we've forgotten to include the trait or extend the ``MockeryTestCase``.
+
+If we are using PHPUnit's XML configuration approach, we can include the
+following to load the ``TestListener``:
+
+.. code-block:: xml
+
+
+
+
+Make sure Composer's or Mockery's autoloader is present in the bootstrap file
+or we will need to also define a "file" attribute pointing to the file of the
+``TestListener`` class.
+
+If we are creating the test suite programmatically we may add the listener
+like this:
+
+.. code-block:: php
+
+ // Create the suite.
+ $suite = new PHPUnit\Framework\TestSuite();
+
+ // Create the listener and add it to the suite.
+ $result = new PHPUnit\Framework\TestResult();
+ $result->addListener(new \Mockery\Adapter\Phpunit\TestListener());
+
+ // Run the tests.
+ $suite->run($result);
+
+.. caution::
+
+ PHPUnit provides a functionality that allows
+ `tests to run in a separated process `_,
+ to ensure better isolation. Mockery verifies the mocks expectations using the
+ ``Mockery::close()`` method, and provides a PHPUnit listener, that automatically
+ calls this method for us after every test.
+
+ However, this listener is not called in the right process when using
+ PHPUnit's process isolation, resulting in expectations that might not be
+ respected, but without raising any ``Mockery\Exception``. To avoid this,
+ we cannot rely on the supplied Mockery PHPUnit ``TestListener``, and we need
+ to explicitly call ``Mockery::close``. The easiest solution to include this
+ call in the ``tearDown()`` method, as explained previously.
diff --git a/vendor/mockery/mockery/docs/reference/protected_methods.rst b/vendor/mockery/mockery/docs/reference/protected_methods.rst
new file mode 100644
index 0000000..ec4a5ba
--- /dev/null
+++ b/vendor/mockery/mockery/docs/reference/protected_methods.rst
@@ -0,0 +1,26 @@
+.. index::
+ single: Mocking; Protected Methods
+
+Mocking Protected Methods
+=========================
+
+By default, Mockery does not allow mocking protected methods. We do not recommend
+mocking protected methods, but there are cases when there is no other solution.
+
+For those cases we have the ``shouldAllowMockingProtectedMethods()`` method. It
+instructs Mockery to specifically allow mocking of protected methods, for that
+one class only:
+
+.. code-block:: php
+
+ class MyClass
+ {
+ protected function foo()
+ {
+ }
+ }
+
+ $mock = \Mockery::mock('MyClass')
+ ->shouldAllowMockingProtectedMethods();
+ $mock->shouldReceive('foo');
+
diff --git a/vendor/mockery/mockery/docs/reference/public_properties.rst b/vendor/mockery/mockery/docs/reference/public_properties.rst
new file mode 100644
index 0000000..3165668
--- /dev/null
+++ b/vendor/mockery/mockery/docs/reference/public_properties.rst
@@ -0,0 +1,20 @@
+.. index::
+ single: Mocking; Public Properties
+
+Mocking Public Properties
+=========================
+
+Mockery allows us to mock properties in several ways. One way is that we can set
+a public property and its value on any mock object. The second is that we can
+use the expectation methods ``set()`` and ``andSet()`` to set property values if
+that expectation is ever met.
+
+You can read more about :ref:`expectations-setting-public-properties`.
+
+.. note::
+
+ In general, Mockery does not support mocking any magic methods since these
+ are generally not considered a public API (and besides it is a bit difficult
+ to differentiate them when you badly need them for mocking!). So please mock
+ virtual properties (those relying on ``__get()`` and ``__set()``) as if they
+ were actually declared on the class.
diff --git a/vendor/mockery/mockery/docs/reference/public_static_properties.rst b/vendor/mockery/mockery/docs/reference/public_static_properties.rst
new file mode 100644
index 0000000..2396efc
--- /dev/null
+++ b/vendor/mockery/mockery/docs/reference/public_static_properties.rst
@@ -0,0 +1,15 @@
+.. index::
+ single: Mocking; Public Static Methods
+
+Mocking Public Static Methods
+=============================
+
+Static methods are not called on real objects, so normal mock objects can't
+mock them. Mockery supports class aliased mocks, mocks representing a class
+name which would normally be loaded (via autoloading or a require statement)
+in the system under test. These aliases block that loading (unless via a
+require statement - so please use autoloading!) and allow Mockery to intercept
+static method calls and add expectations for them.
+
+See the :ref:`creating-test-doubles-aliasing` section for more information on
+creating aliased mocks, for the purpose of mocking public static methods.
diff --git a/vendor/mockery/mockery/docs/reference/spies.rst b/vendor/mockery/mockery/docs/reference/spies.rst
new file mode 100644
index 0000000..1663918
--- /dev/null
+++ b/vendor/mockery/mockery/docs/reference/spies.rst
@@ -0,0 +1,154 @@
+.. index::
+ single: Reference; Spies
+
+Spies
+=====
+
+Spies are a type of test doubles, but they differ from stubs or mocks in that,
+that the spies record any interaction between the spy and the System Under Test
+(SUT), and allow us to make assertions against those interactions after the fact.
+
+Creating a spy means we don't have to set up expectations for every method call
+the double might receive during the test, some of which may not be relevant to
+the current test. A spy allows us to make assertions about the calls we care
+about for this test only, reducing the chances of over-specification and making
+our tests more clear.
+
+Spies also allow us to follow the more familiar Arrange-Act-Assert or
+Given-When-Then style within our tests. With mocks, we have to follow a less
+familiar style, something along the lines of Arrange-Expect-Act-Assert, where
+we have to tell our mocks what to expect before we act on the SUT, then assert
+that those expectations were met:
+
+.. code-block:: php
+
+ // arrange
+ $mock = \Mockery::mock('MyDependency');
+ $sut = new MyClass($mock);
+
+ // expect
+ $mock->shouldReceive('foo')
+ ->once()
+ ->with('bar');
+
+ // act
+ $sut->callFoo();
+
+ // assert
+ \Mockery::close();
+
+Spies allow us to skip the expect part and move the assertion to after we have
+acted on the SUT, usually making our tests more readable:
+
+.. code-block:: php
+
+ // arrange
+ $spy = \Mockery::spy('MyDependency');
+ $sut = new MyClass($spy);
+
+ // act
+ $sut->callFoo();
+
+ // assert
+ $spy->shouldHaveReceived()
+ ->foo()
+ ->with('bar');
+
+On the other hand, spies are far less restrictive than mocks, meaning tests are
+usually less precise, as they let us get away with more. This is usually a
+good thing, they should only be as precise as they need to be, but while spies
+make our tests more intent-revealing, they do tend to reveal less about the
+design of the SUT. If we're having to setup lots of expectations for a mock,
+in lots of different tests, our tests are trying to tell us something - the SUT
+is doing too much and probably should be refactored. We don't get this with
+spies, they simply ignore the calls that aren't relevant to them.
+
+Another downside to using spies is debugging. When a mock receives a call that
+it wasn't expecting, it immediately throws an exception (failing fast), giving
+us a nice stack trace or possibly even invoking our debugger. With spies, we're
+simply asserting calls were made after the fact, so if the wrong calls were made,
+we don't have quite the same just in time context we have with the mocks.
+
+Finally, if we need to define a return value for our test double, we can't do
+that with a spy, only with a mock object.
+
+.. note::
+
+ This documentation page is an adaption of the blog post titled
+ `"Mockery Spies" `_,
+ published by Dave Marshall on his blog. Dave is the original author of spies
+ in Mockery.
+
+Spies Reference
+---------------
+
+To verify that a method was called on a spy, we use the ``shouldHaveReceived()``
+method:
+
+.. code-block:: php
+
+ $spy->shouldHaveReceived('foo');
+
+To verify that a method was **not** called on a spy, we use the
+``shouldNotHaveReceived()`` method:
+
+.. code-block:: php
+
+ $spy->shouldNotHaveReceived('foo');
+
+We can also do argument matching with spies:
+
+.. code-block:: php
+
+ $spy->shouldHaveReceived('foo')
+ ->with('bar');
+
+Argument matching is also possible by passing in an array of arguments to
+match:
+
+.. code-block:: php
+
+ $spy->shouldHaveReceived('foo', ['bar']);
+
+Although when verifying a method was not called, the argument matching can only
+be done by supplying the array of arguments as the 2nd argument to the
+``shouldNotHaveReceived()`` method:
+
+.. code-block:: php
+
+ $spy->shouldNotHaveReceived('foo', ['bar']);
+
+This is due to Mockery's internals.
+
+Finally, when expecting calls that should have been received, we can also verify
+the number of calls:
+
+.. code-block:: php
+
+ $spy->shouldHaveReceived('foo')
+ ->with('bar')
+ ->twice();
+
+Alternative shouldReceive syntax
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+As of Mockery 1.0.0, we support calling methods as we would call any PHP method,
+and not as string arguments to Mockery ``should*`` methods.
+
+In cases of spies, this only applies to the ``shouldHaveReceived()`` method:
+
+.. code-block:: php
+
+ $spy->shouldHaveReceived()
+ ->foo('bar');
+
+We can set expectation on number of calls as well:
+
+.. code-block:: php
+
+ $spy->shouldHaveReceived()
+ ->foo('bar')
+ ->twice();
+
+Unfortunately, due to limitations we can't support the same syntax for the
+``shouldNotHaveReceived()`` method.
diff --git a/vendor/mockery/mockery/docs/requirements.txt b/vendor/mockery/mockery/docs/requirements.txt
new file mode 100644
index 0000000..2f74b4c
--- /dev/null
+++ b/vendor/mockery/mockery/docs/requirements.txt
@@ -0,0 +1,25 @@
+alabaster==0.7.16
+Babel==2.14.0
+certifi==2024.2.2
+charset-normalizer==3.3.2
+docutils==0.20.1
+idna==3.7
+imagesize==1.4.1
+Jinja2==3.1.4
+MarkupSafe==2.1.5
+packaging==24.0
+Pygments==2.17.2
+requests==2.31.0
+setuptools==69.2.0
+snowballstemmer==2.2.0
+Sphinx==7.3.7
+sphinx-rtd-theme==2.0.0
+sphinxcontrib-applehelp==1.0.8
+sphinxcontrib-devhelp==1.0.6
+sphinxcontrib-htmlhelp==2.0.5
+sphinxcontrib-jquery==4.1
+sphinxcontrib-jsmath==1.0.1
+sphinxcontrib-qthelp==1.0.7
+sphinxcontrib-serializinghtml==1.1.10
+urllib3==2.2.1
+wheel==0.43.0
diff --git a/vendor/mockery/mockery/library/Mockery.php b/vendor/mockery/mockery/library/Mockery.php
new file mode 100644
index 0000000..1370cea
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery.php
@@ -0,0 +1,1062 @@
+
+ */
+ private static $_filesToCleanUp = [];
+
+ /**
+ * Return instance of AndAnyOtherArgs matcher.
+ *
+ * @return AndAnyOtherArgs
+ */
+ public static function andAnyOtherArgs()
+ {
+ return new AndAnyOtherArgs();
+ }
+
+ /**
+ * Return instance of AndAnyOtherArgs matcher.
+ *
+ * An alternative name to `andAnyOtherArgs` so
+ * the API stays closer to `any` as well.
+ *
+ * @return AndAnyOtherArgs
+ */
+ public static function andAnyOthers()
+ {
+ return new AndAnyOtherArgs();
+ }
+
+ /**
+ * Return instance of ANY matcher.
+ *
+ * @return Any
+ */
+ public static function any()
+ {
+ return new Any();
+ }
+
+ /**
+ * Return instance of ANYOF matcher.
+ *
+ * @template TAnyOf
+ *
+ * @param TAnyOf ...$args
+ *
+ * @return AnyOf
+ */
+ public static function anyOf(...$args)
+ {
+ return new AnyOf($args);
+ }
+
+ /**
+ * @return array
+ *
+ * @deprecated since 1.3.2 and will be removed in 2.0.
+ */
+ public static function builtInTypes()
+ {
+ return ['array', 'bool', 'callable', 'float', 'int', 'iterable', 'object', 'self', 'string', 'void'];
+ }
+
+ /**
+ * Return instance of CLOSURE matcher.
+ *
+ * @template TReference
+ *
+ * @param TReference $reference
+ *
+ * @return ClosureMatcher
+ */
+ public static function capture(&$reference)
+ {
+ $closure = static function ($argument) use (&$reference) {
+ $reference = $argument;
+ return true;
+ };
+
+ return new ClosureMatcher($closure);
+ }
+
+ /**
+ * Static shortcut to closing up and verifying all mocks in the global
+ * container, and resetting the container static variable to null.
+ *
+ * @return void
+ */
+ public static function close()
+ {
+ foreach (self::$_filesToCleanUp as $fileName) {
+ @\unlink($fileName);
+ }
+
+ self::$_filesToCleanUp = [];
+
+ if (self::$_container === null) {
+ return;
+ }
+
+ $container = self::$_container;
+
+ self::$_container = null;
+
+ $container->mockery_teardown();
+
+ $container->mockery_close();
+ }
+
+ /**
+ * Return instance of CONTAINS matcher.
+ *
+ * @template TContains
+ *
+ * @param TContains $args
+ *
+ * @return Contains
+ */
+ public static function contains(...$args)
+ {
+ return new Contains($args);
+ }
+
+ /**
+ * @param class-string $fqn
+ *
+ * @return void
+ */
+ public static function declareClass($fqn)
+ {
+ static::declareType($fqn, 'class');
+ }
+
+ /**
+ * @param class-string $fqn
+ *
+ * @return void
+ */
+ public static function declareInterface($fqn)
+ {
+ static::declareType($fqn, 'interface');
+ }
+
+ /**
+ * Return instance of DUCKTYPE matcher.
+ *
+ * @template TDucktype
+ *
+ * @param TDucktype ...$args
+ *
+ * @return Ducktype
+ */
+ public static function ducktype(...$args)
+ {
+ return new Ducktype($args);
+ }
+
+ /**
+ * Static fetching of a mock associated with a name or explicit class poser.
+ *
+ * @template TFetchMock of object
+ *
+ * @param class-string $name
+ *
+ * @return null|(LegacyMockInterface&MockInterface&TFetchMock)
+ */
+ public static function fetchMock($name)
+ {
+ return self::getContainer()->fetchMock($name);
+ }
+
+ /**
+ * Utility method to format method name and arguments into a string.
+ *
+ * @param string $method
+ *
+ * @return string
+ */
+ public static function formatArgs($method, ?array $arguments = null)
+ {
+ if ($arguments === null) {
+ return $method . '()';
+ }
+
+ $formattedArguments = [];
+ foreach ($arguments as $argument) {
+ $formattedArguments[] = self::formatArgument($argument);
+ }
+
+ return $method . '(' . \implode(', ', $formattedArguments) . ')';
+ }
+
+ /**
+ * Utility function to format objects to printable arrays.
+ *
+ * @return string
+ */
+ public static function formatObjects(?array $objects = null)
+ {
+ static $formatting;
+
+ if ($formatting) {
+ return '[Recursion]';
+ }
+
+ if ($objects === null) {
+ return '';
+ }
+
+ $objects = \array_filter($objects, 'is_object');
+ if ($objects === []) {
+ return '';
+ }
+
+ $formatting = true;
+ $parts = [];
+
+ foreach ($objects as $object) {
+ $parts[\get_class($object)] = self::objectToArray($object);
+ }
+
+ $formatting = false;
+
+ return 'Objects: ( ' . \var_export($parts, true) . ')';
+ }
+
+ /**
+ * Lazy loader and Getter for the global
+ * configuration container.
+ *
+ * @return Configuration
+ */
+ public static function getConfiguration()
+ {
+ if (self::$_config === null) {
+ self::$_config = new Configuration();
+ }
+
+ return self::$_config;
+ }
+
+ /**
+ * Lazy loader and getter for the container property.
+ *
+ * @return Container
+ */
+ public static function getContainer()
+ {
+ if (self::$_container === null) {
+ self::$_container = new Container(self::getGenerator(), self::getLoader());
+ }
+
+ return self::$_container;
+ }
+
+ /**
+ * Creates and returns a default generator
+ * used inside this class.
+ *
+ * @return CachingGenerator
+ */
+ public static function getDefaultGenerator()
+ {
+ return new CachingGenerator(StringManipulationGenerator::withDefaultPasses());
+ }
+
+ /**
+ * Gets an EvalLoader to be used as default.
+ *
+ * @return EvalLoader
+ */
+ public static function getDefaultLoader()
+ {
+ return new EvalLoader();
+ }
+
+ /**
+ * Lazy loader method and getter for
+ * the generator property.
+ *
+ * @return Generator
+ */
+ public static function getGenerator()
+ {
+ if (self::$_generator === null) {
+ self::$_generator = self::getDefaultGenerator();
+ }
+
+ return self::$_generator;
+ }
+
+ /**
+ * Lazy loader method and getter for
+ * the $_loader property.
+ *
+ * @return Loader
+ */
+ public static function getLoader()
+ {
+ if (self::$_loader === null) {
+ self::$_loader = self::getDefaultLoader();
+ }
+
+ return self::$_loader;
+ }
+
+ /**
+ * Defines the global helper functions
+ *
+ * @return void
+ */
+ public static function globalHelpers()
+ {
+ require_once __DIR__ . '/helpers.php';
+ }
+
+ /**
+ * Return instance of HASKEY matcher.
+ *
+ * @template THasKey
+ *
+ * @param THasKey $key
+ *
+ * @return HasKey
+ */
+ public static function hasKey($key)
+ {
+ return new HasKey($key);
+ }
+
+ /**
+ * Return instance of HASVALUE matcher.
+ *
+ * @template THasValue
+ *
+ * @param THasValue $val
+ *
+ * @return HasValue
+ */
+ public static function hasValue($val)
+ {
+ return new HasValue($val);
+ }
+
+ /**
+ * Static and Semantic shortcut to Container::mock().
+ *
+ * @template TInstanceMock
+ *
+ * @param array|TInstanceMock|array> $args
+ *
+ * @return LegacyMockInterface&MockInterface&TInstanceMock
+ */
+ public static function instanceMock(...$args)
+ {
+ return self::getContainer()->mock(...$args);
+ }
+
+ /**
+ * @param string $type
+ *
+ * @return bool
+ *
+ * @deprecated since 1.3.2 and will be removed in 2.0.
+ */
+ public static function isBuiltInType($type)
+ {
+ return \in_array($type, self::builtInTypes(), true);
+ }
+
+ /**
+ * Return instance of IsEqual matcher.
+ *
+ * @template TExpected
+ *
+ * @param TExpected $expected
+ */
+ public static function isEqual($expected): IsEqual
+ {
+ return new IsEqual($expected);
+ }
+
+ /**
+ * Return instance of IsSame matcher.
+ *
+ * @template TExpected
+ *
+ * @param TExpected $expected
+ */
+ public static function isSame($expected): IsSame
+ {
+ return new IsSame($expected);
+ }
+
+ /**
+ * Static shortcut to Container::mock().
+ *
+ * @template TMock of object
+ *
+ * @param array|TMock|Closure(LegacyMockInterface&MockInterface&TMock):LegacyMockInterface&MockInterface&TMock|array> $args
+ *
+ * @return LegacyMockInterface&MockInterface&TMock
+ */
+ public static function mock(...$args)
+ {
+ return self::getContainer()->mock(...$args);
+ }
+
+ /**
+ * Return instance of MUSTBE matcher.
+ *
+ * @template TExpected
+ *
+ * @param TExpected $expected
+ *
+ * @return MustBe
+ */
+ public static function mustBe($expected)
+ {
+ return new MustBe($expected);
+ }
+
+ /**
+ * Static shortcut to Container::mock(), first argument names the mock.
+ *
+ * @template TNamedMock
+ *
+ * @param array|TNamedMock|array> $args
+ *
+ * @return LegacyMockInterface&MockInterface&TNamedMock
+ */
+ public static function namedMock(...$args)
+ {
+ $name = \array_shift($args);
+
+ $builder = new MockConfigurationBuilder();
+ $builder->setName($name);
+
+ \array_unshift($args, $builder);
+
+ return self::getContainer()->mock(...$args);
+ }
+
+ /**
+ * Return instance of NOT matcher.
+ *
+ * @template TNotExpected
+ *
+ * @param TNotExpected $expected
+ *
+ * @return Not
+ */
+ public static function not($expected)
+ {
+ return new Not($expected);
+ }
+
+ /**
+ * Return instance of NOTANYOF matcher.
+ *
+ * @template TNotAnyOf
+ *
+ * @param TNotAnyOf ...$args
+ *
+ * @return NotAnyOf
+ */
+ public static function notAnyOf(...$args)
+ {
+ return new NotAnyOf($args);
+ }
+
+ /**
+ * Return instance of CLOSURE matcher.
+ *
+ * @template TClosure of Closure
+ *
+ * @param TClosure $closure
+ *
+ * @return ClosureMatcher
+ */
+ public static function on($closure)
+ {
+ return new ClosureMatcher($closure);
+ }
+
+ /**
+ * Utility function to parse shouldReceive() arguments and generate
+ * expectations from such as needed.
+ *
+ * @template TReturnArgs
+ *
+ * @param TReturnArgs ...$args
+ * @param Closure $add
+ *
+ * @return CompositeExpectation
+ */
+ public static function parseShouldReturnArgs(LegacyMockInterface $mock, $args, $add)
+ {
+ $composite = new CompositeExpectation();
+
+ foreach ($args as $arg) {
+ if (\is_string($arg)) {
+ $composite->add(self::buildDemeterChain($mock, $arg, $add));
+
+ continue;
+ }
+
+ if (\is_array($arg)) {
+ foreach ($arg as $k => $v) {
+ $composite->add(self::buildDemeterChain($mock, $k, $add)->andReturn($v));
+ }
+ }
+ }
+
+ return $composite;
+ }
+
+ /**
+ * Return instance of PATTERN matcher.
+ *
+ * @template TPatter
+ *
+ * @param TPatter $expected
+ *
+ * @return Pattern
+ */
+ public static function pattern($expected)
+ {
+ return new Pattern($expected);
+ }
+
+ /**
+ * Register a file to be deleted on tearDown.
+ *
+ * @param string $fileName
+ */
+ public static function registerFileForCleanUp($fileName)
+ {
+ self::$_filesToCleanUp[] = $fileName;
+ }
+
+ /**
+ * Reset the container to null.
+ *
+ * @return void
+ */
+ public static function resetContainer()
+ {
+ self::$_container = null;
+ }
+
+ /**
+ * Static shortcut to Container::self().
+ *
+ * @throws LogicException
+ *
+ * @return LegacyMockInterface|MockInterface
+ */
+ public static function self()
+ {
+ if (self::$_container === null) {
+ throw new LogicException('You have not declared any mocks yet');
+ }
+
+ return self::$_container->self();
+ }
+
+ /**
+ * Set the container.
+ *
+ * @return Container
+ */
+ public static function setContainer(Container $container)
+ {
+ return self::$_container = $container;
+ }
+
+ /**
+ * Setter for the $_generator static property.
+ */
+ public static function setGenerator(Generator $generator)
+ {
+ self::$_generator = $generator;
+ }
+
+ /**
+ * Setter for the $_loader static property.
+ */
+ public static function setLoader(Loader $loader)
+ {
+ self::$_loader = $loader;
+ }
+
+ /**
+ * Static and semantic shortcut for getting a mock from the container
+ * and applying the spy's expected behavior into it.
+ *
+ * @template TSpy
+ *
+ * @param array|TSpy|Closure(LegacyMockInterface&MockInterface&TSpy):LegacyMockInterface&MockInterface&TSpy|array> $args
+ *
+ * @return LegacyMockInterface&MockInterface&TSpy
+ */
+ public static function spy(...$args)
+ {
+ if ($args !== [] && $args[0] instanceof Closure) {
+ $args[0] = new ClosureWrapper($args[0]);
+ }
+
+ return self::getContainer()->mock(...$args)->shouldIgnoreMissing();
+ }
+
+ /**
+ * Return instance of SUBSET matcher.
+ *
+ * @param bool $strict - (Optional) True for strict comparison, false for loose
+ *
+ * @return Subset
+ */
+ public static function subset(array $part, $strict = true)
+ {
+ return new Subset($part, $strict);
+ }
+
+ /**
+ * Return instance of TYPE matcher.
+ *
+ * @template TExpectedType
+ *
+ * @param TExpectedType $expected
+ *
+ * @return Type
+ */
+ public static function type($expected)
+ {
+ return new Type($expected);
+ }
+
+ /**
+ * Sets up expectations on the members of the CompositeExpectation and
+ * builds up any demeter chain that was passed to shouldReceive.
+ *
+ * @param string $arg
+ * @param Closure $add
+ *
+ * @throws MockeryException
+ *
+ * @return ExpectationInterface
+ */
+ protected static function buildDemeterChain(LegacyMockInterface $mock, $arg, $add)
+ {
+ $container = $mock->mockery_getContainer();
+ $methodNames = \explode('->', $arg);
+
+ \reset($methodNames);
+
+ if (
+ ! $mock->mockery_isAnonymous()
+ && ! self::getConfiguration()->mockingNonExistentMethodsAllowed()
+ && ! \in_array(\current($methodNames), $mock->mockery_getMockableMethods(), true)
+ ) {
+ throw new MockeryException(
+ "Mockery's configuration currently forbids mocking the method "
+ . \current($methodNames) . ' as it does not exist on the class or object '
+ . 'being mocked'
+ );
+ }
+
+ /** @var Closure $nextExp */
+ $nextExp = static function ($method) use ($add) {
+ return $add($method);
+ };
+
+ $parent = \get_class($mock);
+
+ /** @var null|ExpectationInterface $expectations */
+ $expectations = null;
+ while (true) {
+ $method = \array_shift($methodNames);
+ $expectations = $mock->mockery_getExpectationsFor($method);
+
+ if ($expectations === null || self::noMoreElementsInChain($methodNames)) {
+ $expectations = $nextExp($method);
+ if (self::noMoreElementsInChain($methodNames)) {
+ break;
+ }
+
+ $mock = self::getNewDemeterMock($container, $parent, $method, $expectations);
+ } else {
+ $demeterMockKey = $container->getKeyOfDemeterMockFor($method, $parent);
+ if ($demeterMockKey !== null) {
+ $mock = self::getExistingDemeterMock($container, $demeterMockKey);
+ }
+ }
+
+ $parent .= '->' . $method;
+
+ $nextExp = static function ($n) use ($mock) {
+ return $mock->allows($n);
+ };
+ }
+
+ return $expectations;
+ }
+
+ /**
+ * Utility method for recursively generating a representation of the given array.
+ *
+ * @template TArray or array
+ *
+ * @param TArray $argument
+ * @param int $nesting
+ *
+ * @return TArray
+ */
+ private static function cleanupArray($argument, $nesting = 3)
+ {
+ if ($nesting === 0) {
+ return '...';
+ }
+
+ foreach ($argument as $key => $value) {
+ if (\is_array($value)) {
+ $argument[$key] = self::cleanupArray($value, $nesting - 1);
+
+ continue;
+ }
+
+ if (\is_object($value)) {
+ $argument[$key] = self::objectToArray($value, $nesting - 1);
+ }
+ }
+
+ return $argument;
+ }
+
+ /**
+ * Utility method used for recursively generating
+ * an object or array representation.
+ *
+ * @template TArgument
+ *
+ * @param TArgument $argument
+ * @param int $nesting
+ *
+ * @return mixed
+ */
+ private static function cleanupNesting($argument, $nesting)
+ {
+ if (\is_object($argument)) {
+ $object = self::objectToArray($argument, $nesting - 1);
+ $object['class'] = \get_class($argument);
+
+ return $object;
+ }
+
+ if (\is_array($argument)) {
+ return self::cleanupArray($argument, $nesting - 1);
+ }
+
+ return $argument;
+ }
+
+ /**
+ * @param string $fqn
+ * @param string $type
+ */
+ private static function declareType($fqn, $type): void
+ {
+ $targetCode = '
+ */
+ private static function extractInstancePublicProperties($object, $nesting)
+ {
+ $reflection = new ReflectionClass($object);
+ $properties = $reflection->getProperties(ReflectionProperty::IS_PUBLIC);
+ $cleanedProperties = [];
+
+ foreach ($properties as $publicProperty) {
+ if (! $publicProperty->isStatic()) {
+ $name = $publicProperty->getName();
+ try {
+ $cleanedProperties[$name] = self::cleanupNesting($object->{$name}, $nesting);
+ } catch (Exception $exception) {
+ $cleanedProperties[$name] = $exception->getMessage();
+ }
+ }
+ }
+
+ return $cleanedProperties;
+ }
+
+ /**
+ * Gets the string representation
+ * of any passed argument.
+ *
+ * @param mixed $argument
+ * @param int $depth
+ *
+ * @return mixed
+ */
+ private static function formatArgument($argument, $depth = 0)
+ {
+ if ($argument instanceof MatcherInterface) {
+ return (string) $argument;
+ }
+
+ if (\is_object($argument)) {
+ return 'object(' . \get_class($argument) . ')';
+ }
+
+ if (\is_int($argument) || \is_float($argument)) {
+ return $argument;
+ }
+
+ if (\is_array($argument)) {
+ if ($depth === 1) {
+ $argument = '[...]';
+ } else {
+ $sample = [];
+ foreach ($argument as $key => $value) {
+ $key = \is_int($key) ? $key : \sprintf("'%s'", $key);
+ $value = self::formatArgument($value, $depth + 1);
+ $sample[] = \sprintf('%s => %s', $key, $value);
+ }
+
+ $argument = '[' . \implode(', ', $sample) . ']';
+ }
+
+ return (\strlen($argument) > 1000) ? \substr($argument, 0, 1000) . '...]' : $argument;
+ }
+
+ if (\is_bool($argument)) {
+ return $argument ? 'true' : 'false';
+ }
+
+ if (\is_resource($argument)) {
+ return 'resource(...)';
+ }
+
+ if ($argument === null) {
+ return 'NULL';
+ }
+
+ return "'" . $argument . "'";
+ }
+
+ /**
+ * Gets a specific demeter mock from the ones kept by the container.
+ *
+ * @template TMock of object
+ *
+ * @param class-string $demeterMockKey
+ *
+ * @return null|(LegacyMockInterface&MockInterface&TMock)
+ */
+ private static function getExistingDemeterMock(Container $container, $demeterMockKey)
+ {
+ return $container->getMocks()[$demeterMockKey] ?? null;
+ }
+
+ /**
+ * Gets a new demeter configured
+ * mock from the container.
+ *
+ * @param string $parent
+ * @param string $method
+ *
+ * @return LegacyMockInterface&MockInterface
+ */
+ private static function getNewDemeterMock(Container $container, $parent, $method, ExpectationInterface $exp)
+ {
+ $newMockName = 'demeter_' . \md5($parent) . '_' . $method;
+
+ $parRef = null;
+
+ $parentMock = $exp->getMock();
+ if ($parentMock !== null) {
+ $parRef = new ReflectionObject($parentMock);
+ }
+
+ if ($parRef instanceof ReflectionObject && $parRef->hasMethod($method)) {
+ $parRefMethod = $parRef->getMethod($method);
+ $parRefMethodRetType = Reflector::getReturnType($parRefMethod, true);
+
+ if ($parRefMethodRetType !== null) {
+ $returnTypes = \explode('|', $parRefMethodRetType);
+
+ $filteredReturnTypes = array_filter($returnTypes, static function (string $type): bool {
+ return ! Reflector::isReservedWord($type);
+ });
+
+ if ($filteredReturnTypes !== []) {
+ $nameBuilder = new MockNameBuilder();
+
+ $nameBuilder->addPart('\\' . $newMockName);
+
+ $mock = self::namedMock(
+ $nameBuilder->build(),
+ ...$filteredReturnTypes
+ );
+
+ $exp->andReturn($mock);
+
+ return $mock;
+ }
+ }
+ }
+
+ $mock = $container->mock($newMockName);
+ $exp->andReturn($mock);
+
+ return $mock;
+ }
+
+ /**
+ * Checks if the passed array representing a demeter
+ * chain with the method names is empty.
+ *
+ * @return bool
+ */
+ private static function noMoreElementsInChain(array $methodNames)
+ {
+ return $methodNames === [];
+ }
+
+ /**
+ * Utility function to turn public properties and public get* and is* method values into an array.
+ *
+ * @param object $object
+ * @param int $nesting
+ *
+ * @return array
+ */
+ private static function objectToArray($object, $nesting = 3)
+ {
+ if ($nesting === 0) {
+ return ['...'];
+ }
+
+ $defaultFormatter = static function ($object, $nesting) {
+ return [
+ 'properties' => self::extractInstancePublicProperties($object, $nesting),
+ ];
+ };
+
+ $class = \get_class($object);
+
+ $formatter = self::getConfiguration()->getObjectFormatter($class, $defaultFormatter);
+
+ $array = [
+ 'class' => $class,
+ 'identity' => '#' . \md5(\spl_object_hash($object)),
+ ];
+
+ return \array_merge($array, $formatter($object, $nesting));
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Adapter/Phpunit/MockeryPHPUnitIntegration.php b/vendor/mockery/mockery/library/Mockery/Adapter/Phpunit/MockeryPHPUnitIntegration.php
new file mode 100644
index 0000000..a6d5b8f
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Adapter/Phpunit/MockeryPHPUnitIntegration.php
@@ -0,0 +1,86 @@
+addToAssertionCount(Mockery::getContainer()->mockery_getExpectationCount());
+ }
+
+ protected function checkMockeryExceptions()
+ {
+ if (! method_exists($this, 'markAsRisky')) {
+ return;
+ }
+
+ foreach (Mockery::getContainer()->mockery_thrownExceptions() as $e) {
+ if (! $e->dismissed()) {
+ $this->markAsRisky();
+ }
+ }
+ }
+
+ protected function closeMockery()
+ {
+ Mockery::close();
+ $this->mockeryOpen = false;
+ }
+
+ /**
+ * Performs assertions shared by all tests of a test case. This method is
+ * called before execution of a test ends and before the tearDown method.
+ */
+ protected function mockeryAssertPostConditions()
+ {
+ $this->addMockeryExpectationsToAssertionCount();
+ $this->checkMockeryExceptions();
+ $this->closeMockery();
+
+ parent::assertPostConditions();
+ }
+
+ /**
+ * @after
+ */
+ #[After]
+ protected function purgeMockeryContainer()
+ {
+ if ($this->mockeryOpen) {
+ // post conditions wasn't called, so test probably failed
+ Mockery::close();
+ }
+ }
+
+ /**
+ * @before
+ */
+ #[Before]
+ protected function startMockery()
+ {
+ $this->mockeryOpen = true;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Adapter/Phpunit/MockeryPHPUnitIntegrationAssertPostConditions.php b/vendor/mockery/mockery/library/Mockery/Adapter/Phpunit/MockeryPHPUnitIntegrationAssertPostConditions.php
new file mode 100644
index 0000000..e4a80b5
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Adapter/Phpunit/MockeryPHPUnitIntegrationAssertPostConditions.php
@@ -0,0 +1,21 @@
+mockeryAssertPostConditions();
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Adapter/Phpunit/MockeryTestCase.php b/vendor/mockery/mockery/library/Mockery/Adapter/Phpunit/MockeryTestCase.php
new file mode 100644
index 0000000..942f1c0
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Adapter/Phpunit/MockeryTestCase.php
@@ -0,0 +1,27 @@
+mockeryTestSetUp();
+ }
+
+ protected function tearDown(): void
+ {
+ $this->mockeryTestTearDown();
+ parent::tearDown();
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Adapter/Phpunit/TestListener.php b/vendor/mockery/mockery/library/Mockery/Adapter/Phpunit/TestListener.php
new file mode 100644
index 0000000..1ae8458
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Adapter/Phpunit/TestListener.php
@@ -0,0 +1,38 @@
+trait = new TestListenerTrait();
+ }
+
+ public function endTest(Test $test, float $time): void
+ {
+ $this->trait->endTest($test, $time);
+ }
+
+ public function startTestSuite(TestSuite $suite): void
+ {
+ $this->trait->startTestSuite();
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Adapter/Phpunit/TestListenerTrait.php b/vendor/mockery/mockery/library/Mockery/Adapter/Phpunit/TestListenerTrait.php
new file mode 100644
index 0000000..45c6b3f
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Adapter/Phpunit/TestListenerTrait.php
@@ -0,0 +1,84 @@
+getStatus() !== BaseTestRunner::STATUS_PASSED) {
+ // If the test didn't pass there is no guarantee that
+ // verifyMockObjects and assertPostConditions have been called.
+ // And even if it did, the point here is to prevent false
+ // negatives, not to make failing tests fail for more reasons.
+ return;
+ }
+
+ try {
+ // The self() call is used as a sentinel. Anything that throws if
+ // the container is closed already will do.
+ Mockery::self();
+ } catch (LogicException $logicException) {
+ return;
+ }
+
+ $e = new ExpectationFailedException(
+ sprintf(
+ "Mockery's expectations have not been verified. Make sure that \Mockery::close() is called at the end of the test. Consider using %s\MockeryPHPUnitIntegration or extending %s\MockeryTestCase.",
+ __NAMESPACE__,
+ __NAMESPACE__
+ )
+ );
+
+ /** @var \PHPUnit\Framework\TestResult $result */
+ $result = $test->getTestResultObject();
+
+ if ($result !== null) {
+ $result->addFailure($test, $e, $time);
+ }
+ }
+
+ public function startTestSuite()
+ {
+ if (method_exists(Blacklist::class, 'addDirectory')) {
+ (new Blacklist())->getBlacklistedDirectories();
+ Blacklist::addDirectory(dirname((new ReflectionClass(Mockery::class))->getFileName()));
+ } else {
+ Blacklist::$blacklistedClassNames[Mockery::class] = 1;
+ }
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/ClosureWrapper.php b/vendor/mockery/mockery/library/Mockery/ClosureWrapper.php
new file mode 100644
index 0000000..fae8871
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/ClosureWrapper.php
@@ -0,0 +1,36 @@
+closure = $closure;
+ }
+
+ /**
+ * @return mixed
+ */
+ public function __invoke()
+ {
+ return ($this->closure)(...func_get_args());
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/CompositeExpectation.php b/vendor/mockery/mockery/library/Mockery/CompositeExpectation.php
new file mode 100644
index 0000000..fa03c39
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/CompositeExpectation.php
@@ -0,0 +1,150 @@
+
+ */
+ protected $_expectations = [];
+
+ /**
+ * Intercept any expectation calls and direct against all expectations
+ *
+ * @param string $method
+ *
+ * @return self
+ */
+ public function __call($method, array $args)
+ {
+ foreach ($this->_expectations as $expectation) {
+ $expectation->{$method}(...$args);
+ }
+
+ return $this;
+ }
+
+ /**
+ * Return the string summary of this composite expectation
+ *
+ * @return string
+ */
+ public function __toString()
+ {
+ $parts = array_map(static function (ExpectationInterface $expectation): string {
+ return (string) $expectation;
+ }, $this->_expectations);
+
+ return '[' . implode(', ', $parts) . ']';
+ }
+
+ /**
+ * Add an expectation to the composite
+ *
+ * @param ExpectationInterface|HigherOrderMessage $expectation
+ *
+ * @return void
+ */
+ public function add($expectation)
+ {
+ $this->_expectations[] = $expectation;
+ }
+
+ /**
+ * @param mixed ...$args
+ */
+ public function andReturn(...$args)
+ {
+ return $this->__call(__FUNCTION__, $args);
+ }
+
+ /**
+ * Set a return value, or sequential queue of return values
+ *
+ * @param mixed ...$args
+ *
+ * @return self
+ */
+ public function andReturns(...$args)
+ {
+ return $this->andReturn(...$args);
+ }
+
+ /**
+ * Return the parent mock of the first expectation
+ *
+ * @return LegacyMockInterface&MockInterface
+ */
+ public function getMock()
+ {
+ reset($this->_expectations);
+ $first = current($this->_expectations);
+ return $first->getMock();
+ }
+
+ /**
+ * Return order number of the first expectation
+ *
+ * @return int
+ */
+ public function getOrderNumber()
+ {
+ reset($this->_expectations);
+ $first = current($this->_expectations);
+ return $first->getOrderNumber();
+ }
+
+ /**
+ * Mockery API alias to getMock
+ *
+ * @return LegacyMockInterface&MockInterface
+ */
+ public function mock()
+ {
+ return $this->getMock();
+ }
+
+ /**
+ * Starts a new expectation addition on the first mock which is the primary target outside of a demeter chain
+ *
+ * @param mixed ...$args
+ *
+ * @return Expectation
+ */
+ public function shouldNotReceive(...$args)
+ {
+ reset($this->_expectations);
+ $first = current($this->_expectations);
+ return $first->getMock()->shouldNotReceive(...$args);
+ }
+
+ /**
+ * Starts a new expectation addition on the first mock which is the primary target, outside of a demeter chain
+ *
+ * @param mixed ...$args
+ *
+ * @return Expectation
+ */
+ public function shouldReceive(...$args)
+ {
+ reset($this->_expectations);
+ $first = current($this->_expectations);
+ return $first->getMock()->shouldReceive(...$args);
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Configuration.php b/vendor/mockery/mockery/library/Mockery/Configuration.php
new file mode 100644
index 0000000..d415d9e
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Configuration.php
@@ -0,0 +1,406 @@
+ ['MY_CONST' => 123, 'OTHER_CONST' => 'foo']]
+ *
+ * @var array|scalar>>
+ */
+ protected $_constantsMap = [];
+
+ /**
+ * Default argument matchers
+ *
+ * e.g. ['class' => 'matcher']
+ *
+ * @var array
+ */
+ protected $_defaultMatchers = [];
+
+ /**
+ * Parameter map for use with PHP internal classes.
+ *
+ * e.g. ['class' => ['method' => ['param1', 'param2']]]
+ *
+ * @var array>>
+ */
+ protected $_internalClassParamMap = [];
+
+ /**
+ * Custom object formatters
+ *
+ * e.g. ['class' => static fn($object) => 'formatted']
+ *
+ * @var array
+ */
+ protected $_objectFormatters = [];
+
+ /**
+ * @var QuickDefinitionsConfiguration
+ */
+ protected $_quickDefinitionsConfiguration;
+
+ /**
+ * Boolean assertion is reflection caching enabled or not. It should be
+ * always enabled, except when using PHPUnit's --static-backup option.
+ *
+ * @see https://github.com/mockery/mockery/issues/268
+ */
+ protected $_reflectionCacheEnabled = true;
+
+ public function __construct()
+ {
+ $this->_quickDefinitionsConfiguration = new QuickDefinitionsConfiguration();
+ }
+
+ /**
+ * Set boolean to allow/prevent unnecessary mocking of methods
+ *
+ * @param bool $flag
+ *
+ * @return void
+ *
+ * @deprecated since 1.4.0
+ */
+ public function allowMockingMethodsUnnecessarily($flag = true)
+ {
+ @trigger_error(
+ sprintf('The %s method is deprecated and will be removed in a future version of Mockery', __METHOD__),
+ E_USER_DEPRECATED
+ );
+
+ $this->_allowMockingMethodsUnnecessarily = (bool) $flag;
+ }
+
+ /**
+ * Set boolean to allow/prevent mocking of non-existent methods
+ *
+ * @param bool $flag
+ *
+ * @return void
+ */
+ public function allowMockingNonExistentMethods($flag = true)
+ {
+ $this->_allowMockingNonExistentMethod = (bool) $flag;
+ }
+
+ /**
+ * Disable reflection caching
+ *
+ * It should be always enabled, except when using
+ * PHPUnit's --static-backup option.
+ *
+ * @see https://github.com/mockery/mockery/issues/268
+ *
+ * @return void
+ */
+ public function disableReflectionCache()
+ {
+ $this->_reflectionCacheEnabled = false;
+ }
+
+ /**
+ * Enable reflection caching
+ *
+ * It should be always enabled, except when using
+ * PHPUnit's --static-backup option.
+ *
+ * @see https://github.com/mockery/mockery/issues/268
+ *
+ * @return void
+ */
+ public function enableReflectionCache()
+ {
+ $this->_reflectionCacheEnabled = true;
+ }
+
+ /**
+ * Get the map of constants to be used in the mock generator
+ *
+ * @return array|scalar>>
+ */
+ public function getConstantsMap()
+ {
+ return $this->_constantsMap;
+ }
+
+ /**
+ * Get the default matcher for a given class
+ *
+ * @param class-string $class
+ *
+ * @return null|class-string
+ */
+ public function getDefaultMatcher($class)
+ {
+ $classes = [];
+
+ $parentClass = $class;
+
+ do {
+ $classes[] = $parentClass;
+
+ $parentClass = get_parent_class($parentClass);
+ } while ($parentClass !== false);
+
+ $classesAndInterfaces = array_merge($classes, class_implements($class));
+
+ foreach ($classesAndInterfaces as $type) {
+ if (array_key_exists($type, $this->_defaultMatchers)) {
+ return $this->_defaultMatchers[$type];
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * Get the parameter map of an internal PHP class method
+ *
+ * @param class-string $class
+ * @param string $method
+ *
+ * @return null|array
+ */
+ public function getInternalClassMethodParamMap($class, $method)
+ {
+ $class = strtolower($class);
+ $method = strtolower($method);
+ if (! array_key_exists($class, $this->_internalClassParamMap)) {
+ return null;
+ }
+
+ if (! array_key_exists($method, $this->_internalClassParamMap[$class])) {
+ return null;
+ }
+
+ return $this->_internalClassParamMap[$class][$method];
+ }
+
+ /**
+ * Get the parameter maps of internal PHP classes
+ *
+ * @return array>>
+ */
+ public function getInternalClassMethodParamMaps()
+ {
+ return $this->_internalClassParamMap;
+ }
+
+ /**
+ * Get the object formatter for a class
+ *
+ * @param class-string $class
+ * @param Closure $defaultFormatter
+ *
+ * @return Closure
+ */
+ public function getObjectFormatter($class, $defaultFormatter)
+ {
+ $parentClass = $class;
+
+ do {
+ $classes[] = $parentClass;
+
+ $parentClass = get_parent_class($parentClass);
+ } while ($parentClass !== false);
+
+ $classesAndInterfaces = array_merge($classes, class_implements($class));
+
+ foreach ($classesAndInterfaces as $type) {
+ if (array_key_exists($type, $this->_objectFormatters)) {
+ return $this->_objectFormatters[$type];
+ }
+ }
+
+ return $defaultFormatter;
+ }
+
+ /**
+ * Returns the quick definitions configuration
+ */
+ public function getQuickDefinitions(): QuickDefinitionsConfiguration
+ {
+ return $this->_quickDefinitionsConfiguration;
+ }
+
+ /**
+ * Return flag indicating whether mocking non-existent methods allowed
+ *
+ * @return bool
+ *
+ * @deprecated since 1.4.0
+ */
+ public function mockingMethodsUnnecessarilyAllowed()
+ {
+ @trigger_error(
+ sprintf('The %s method is deprecated and will be removed in a future version of Mockery', __METHOD__),
+ E_USER_DEPRECATED
+ );
+
+ return $this->_allowMockingMethodsUnnecessarily;
+ }
+
+ /**
+ * Return flag indicating whether mocking non-existent methods allowed
+ *
+ * @return bool
+ */
+ public function mockingNonExistentMethodsAllowed()
+ {
+ return $this->_allowMockingNonExistentMethod;
+ }
+
+ /**
+ * Is reflection cache enabled?
+ *
+ * @return bool
+ */
+ public function reflectionCacheEnabled()
+ {
+ return $this->_reflectionCacheEnabled;
+ }
+
+ /**
+ * Remove all overridden parameter maps from internal PHP classes.
+ *
+ * @return void
+ */
+ public function resetInternalClassMethodParamMaps()
+ {
+ $this->_internalClassParamMap = [];
+ }
+
+ /**
+ * Set a map of constants to be used in the mock generator
+ *
+ * e.g. ['MyClass' => ['MY_CONST' => 123, 'ARRAY_CONST' => ['foo', 'bar']]]
+ *
+ * @param array|scalar>> $map
+ *
+ * @return void
+ */
+ public function setConstantsMap(array $map)
+ {
+ $this->_constantsMap = $map;
+ }
+
+ /**
+ * @param class-string $class
+ * @param class-string $matcherClass
+ *
+ * @throws InvalidArgumentException
+ *
+ * @return void
+ */
+ public function setDefaultMatcher($class, $matcherClass)
+ {
+ $isHamcrest = is_a($matcherClass, Matcher::class, true)
+ || is_a($matcherClass, Hamcrest_Matcher::class, true);
+
+ if ($isHamcrest) {
+ @trigger_error('Hamcrest package has been deprecated and will be removed in 2.0', E_USER_DEPRECATED);
+ }
+
+ if (! $isHamcrest && ! is_a($matcherClass, MatcherInterface::class, true)) {
+ throw new InvalidArgumentException(sprintf(
+ "Matcher class must implement %s, '%s' given.",
+ MatcherInterface::class,
+ $matcherClass
+ ));
+ }
+
+ $this->_defaultMatchers[$class] = $matcherClass;
+ }
+
+ /**
+ * Set a parameter map (array of param signature strings) for the method of an internal PHP class.
+ *
+ * @param class-string $class
+ * @param string $method
+ * @param list $map
+ *
+ * @throws LogicException
+ *
+ * @return void
+ */
+ public function setInternalClassMethodParamMap($class, $method, array $map)
+ {
+ if (PHP_MAJOR_VERSION > 7) {
+ throw new LogicException(
+ 'Internal class parameter overriding is not available in PHP 8. Incompatible signatures have been reclassified as fatal errors.'
+ );
+ }
+
+ $class = strtolower($class);
+
+ if (! array_key_exists($class, $this->_internalClassParamMap)) {
+ $this->_internalClassParamMap[$class] = [];
+ }
+
+ $this->_internalClassParamMap[$class][strtolower($method)] = $map;
+ }
+
+ /**
+ * Set a custom object formatter for a class
+ *
+ * @param class-string $class
+ * @param Closure $formatterCallback
+ *
+ * @return void
+ */
+ public function setObjectFormatter($class, $formatterCallback)
+ {
+ $this->_objectFormatters[$class] = $formatterCallback;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Container.php b/vendor/mockery/mockery/library/Mockery/Container.php
new file mode 100644
index 0000000..ddba888
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Container.php
@@ -0,0 +1,678 @@
+
+ */
+ protected $_groups = [];
+
+ /**
+ * @var LoaderInterface
+ */
+ protected $_loader;
+
+ /**
+ * Store of mock objects
+ *
+ * @var array|array-key,LegacyMockInterface&MockInterface&TMockObject>
+ */
+ protected $_mocks = [];
+
+ /**
+ * @var array
+ */
+ protected $_namedMocks = [];
+
+ /**
+ * @var Instantiator
+ */
+ protected $instantiator;
+
+ public function __construct(?Generator $generator = null, ?LoaderInterface $loader = null, ?Instantiator $instantiator = null)
+ {
+ $this->_generator = $generator instanceof Generator ? $generator : Mockery::getDefaultGenerator();
+ $this->_loader = $loader instanceof LoaderInterface ? $loader : Mockery::getDefaultLoader();
+ $this->instantiator = $instantiator instanceof Instantiator ? $instantiator : new Instantiator();
+ }
+
+ /**
+ * Return a specific remembered mock according to the array index it
+ * was stored to in this container instance
+ *
+ * @template TMock of object
+ *
+ * @param class-string $reference
+ *
+ * @return null|(LegacyMockInterface&MockInterface&TMock)
+ */
+ public function fetchMock($reference)
+ {
+ return $this->_mocks[$reference] ?? null;
+ }
+
+ /**
+ * @return Generator
+ */
+ public function getGenerator()
+ {
+ return $this->_generator;
+ }
+
+ /**
+ * @param string $method
+ * @param string $parent
+ *
+ * @return null|string
+ */
+ public function getKeyOfDemeterMockFor($method, $parent)
+ {
+ $keys = array_keys($this->_mocks);
+
+ $match = preg_grep('/__demeter_' . md5($parent) . sprintf('_%s$/', $method), $keys);
+ if ($match === false) {
+ return null;
+ }
+
+ if ($match === []) {
+ return null;
+ }
+
+ return array_values($match)[0];
+ }
+
+ /**
+ * @return LoaderInterface
+ */
+ public function getLoader()
+ {
+ return $this->_loader;
+ }
+
+ /**
+ * @template TMock of object
+ * @return array|array-key,LegacyMockInterface&MockInterface&TMockObject>
+ */
+ public function getMocks()
+ {
+ return $this->_mocks;
+ }
+
+ /**
+ * @return void
+ */
+ public function instanceMock()
+ {
+ }
+
+ /**
+ * see http://php.net/manual/en/language.oop5.basic.php
+ *
+ * @param string $className
+ *
+ * @return bool
+ */
+ public function isValidClassName($className)
+ {
+ if ($className[0] === '\\') {
+ $className = substr($className, 1); // remove the first backslash
+ }
+
+ // all the namespaces and class name should match the regex
+ return array_filter(
+ explode('\\', $className),
+ static function ($name): bool {
+ return ! preg_match('/^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*$/', $name);
+ }
+ ) === [];
+ }
+
+ /**
+ * Generates a new mock object for this container
+ *
+ * I apologies in advance for this. A God Method just fits the API which
+ * doesn't require differentiating between classes, interfaces, abstracts,
+ * names or partials - just so long as it's something that can be mocked.
+ * I'll refactor it one day so it's easier to follow.
+ *
+ * @template TMock of object
+ *
+ * @param array|TMock|Closure(LegacyMockInterface&MockInterface&TMock):LegacyMockInterface&MockInterface&TMock|array> $args
+ *
+ * @throws ReflectionException|RuntimeException
+ *
+ * @return LegacyMockInterface&MockInterface&TMock
+ */
+ public function mock(...$args)
+ {
+ /** @var null|MockConfigurationBuilder $builder */
+ $builder = null;
+ /** @var null|callable $expectationClosure */
+ $expectationClosure = null;
+ $partialMethods = null;
+ $quickDefinitions = [];
+ $constructorArgs = null;
+ $blocks = [];
+
+ if (count($args) > 1) {
+ $finalArg = array_pop($args);
+
+ if (is_callable($finalArg) && is_object($finalArg)) {
+ $expectationClosure = $finalArg;
+ } else {
+ $args[] = $finalArg;
+ }
+ }
+
+ foreach ($args as $k => $arg) {
+ if ($arg instanceof MockConfigurationBuilder) {
+ $builder = $arg;
+
+ unset($args[$k]);
+ }
+ }
+
+ reset($args);
+
+ $builder = $builder ?? new MockConfigurationBuilder();
+ $mockeryConfiguration = Mockery::getConfiguration();
+ $builder->setParameterOverrides($mockeryConfiguration->getInternalClassMethodParamMaps());
+ $builder->setConstantsMap($mockeryConfiguration->getConstantsMap());
+
+ while ($args !== []) {
+ $arg = array_shift($args);
+
+ // check for multiple interfaces
+ if (is_string($arg)) {
+ foreach (explode('|', $arg) as $type) {
+ if ($arg === 'null') {
+ // skip PHP 8 'null's
+ continue;
+ }
+
+ if (strpos($type, ',') && !strpos($type, ']')) {
+ $interfaces = explode(',', str_replace(' ', '', $type));
+
+ $builder->addTargets($interfaces);
+
+ continue;
+ }
+
+ if (strpos($type, 'alias:') === 0) {
+ $type = str_replace('alias:', '', $type);
+
+ $builder->addTarget('stdClass');
+ $builder->setName($type);
+
+ continue;
+ }
+
+ if (strpos($type, 'overload:') === 0) {
+ $type = str_replace('overload:', '', $type);
+
+ $builder->setInstanceMock(true);
+ $builder->addTarget('stdClass');
+ $builder->setName($type);
+
+ continue;
+ }
+
+ if ($type[strlen($type) - 1] === ']') {
+ $parts = explode('[', $type);
+
+ $class = $parts[0];
+
+ if (! class_exists($class, true) && ! interface_exists($class, true)) {
+ throw new Exception('Can only create a partial mock from an existing class or interface');
+ }
+
+ $builder->addTarget($class);
+
+ $partialMethods = array_filter(
+ explode(',', strtolower(rtrim(str_replace(' ', '', $parts[1]), ']')))
+ );
+
+ foreach ($partialMethods as $partialMethod) {
+ if ($partialMethod[0] === '!') {
+ $builder->addBlackListedMethod(substr($partialMethod, 1));
+
+ continue;
+ }
+
+ $builder->addWhiteListedMethod($partialMethod);
+ }
+
+ continue;
+ }
+
+ if (class_exists($type, true) || interface_exists($type, true) || trait_exists($type, true)) {
+ $builder->addTarget($type);
+
+ continue;
+ }
+
+ if (! $mockeryConfiguration->mockingNonExistentMethodsAllowed()) {
+ throw new Exception(sprintf("Mockery can't find '%s' so can't mock it", $type));
+ }
+
+ if (! $this->isValidClassName($type)) {
+ throw new Exception('Class name contains invalid characters');
+ }
+
+ $builder->addTarget($type);
+
+ // unions are "sum" types and not "intersections", and so we must only process the first part
+ break;
+ }
+
+ continue;
+ }
+
+ if (is_object($arg)) {
+ $builder->addTarget($arg);
+
+ continue;
+ }
+
+ if (is_array($arg)) {
+ if ([] !== $arg && array_keys($arg) !== range(0, count($arg) - 1)) {
+ // if associative array
+ if (array_key_exists(self::BLOCKS, $arg)) {
+ $blocks = $arg[self::BLOCKS];
+ }
+
+ unset($arg[self::BLOCKS]);
+
+ $quickDefinitions = $arg;
+
+ continue;
+ }
+
+ $constructorArgs = $arg;
+
+ continue;
+ }
+
+ throw new Exception(sprintf(
+ 'Unable to parse arguments sent to %s::mock()', get_class($this)
+ ));
+ }
+
+ $builder->addBlackListedMethods($blocks);
+
+ if ($constructorArgs !== null) {
+ $builder->addBlackListedMethod('__construct'); // we need to pass through
+ } else {
+ $builder->setMockOriginalDestructor(true);
+ }
+
+ if ($partialMethods !== null && $constructorArgs === null) {
+ $constructorArgs = [];
+ }
+
+ $config = $builder->getMockConfiguration();
+
+ $this->checkForNamedMockClashes($config);
+
+ $def = $this->getGenerator()->generate($config);
+
+ $className = $def->getClassName();
+ if (class_exists($className, $attemptAutoload = false)) {
+ $rfc = new ReflectionClass($className);
+ if (! $rfc->implementsInterface(LegacyMockInterface::class)) {
+ throw new RuntimeException(sprintf('Could not load mock %s, class already exists', $className));
+ }
+ }
+
+ $this->getLoader()->load($def);
+
+ $mock = $this->_getInstance($className, $constructorArgs);
+ $mock->mockery_init($this, $config->getTargetObject(), $config->isInstanceMock());
+
+ if ($quickDefinitions !== []) {
+ if ($mockeryConfiguration->getQuickDefinitions()->shouldBeCalledAtLeastOnce()) {
+ $mock->shouldReceive($quickDefinitions)->atLeast()->once();
+ } else {
+ $mock->shouldReceive($quickDefinitions)->byDefault();
+ }
+ }
+
+ // if the last parameter passed to mock() is a closure,
+ if ($expectationClosure instanceof Closure) {
+ // call the closure with the mock object
+ $expectationClosure($mock);
+ }
+
+ return $this->rememberMock($mock);
+ }
+
+ /**
+ * Fetch the next available allocation order number
+ *
+ * @return int
+ */
+ public function mockery_allocateOrder()
+ {
+ return ++$this->_allocatedOrder;
+ }
+
+ /**
+ * Reset the container to its original state
+ *
+ * @return void
+ */
+ public function mockery_close()
+ {
+ foreach ($this->_mocks as $mock) {
+ $mock->mockery_teardown();
+ }
+
+ $this->_mocks = [];
+ }
+
+ /**
+ * Get current ordered number
+ *
+ * @return int
+ */
+ public function mockery_getCurrentOrder()
+ {
+ return $this->_currentOrder;
+ }
+
+ /**
+ * Gets the count of expectations on the mocks
+ *
+ * @return int
+ */
+ public function mockery_getExpectationCount()
+ {
+ $count = 0;
+ foreach ($this->_mocks as $mock) {
+ $count += $mock->mockery_getExpectationCount();
+ }
+
+ return $count;
+ }
+
+ /**
+ * Fetch array of ordered groups
+ *
+ * @return array
+ */
+ public function mockery_getGroups()
+ {
+ return $this->_groups;
+ }
+
+ /**
+ * Set current ordered number
+ *
+ * @param int $order
+ *
+ * @return int The current order number that was set
+ */
+ public function mockery_setCurrentOrder($order)
+ {
+ return $this->_currentOrder = $order;
+ }
+
+ /**
+ * Set ordering for a group
+ *
+ * @param string $group
+ * @param int $order
+ *
+ * @return void
+ */
+ public function mockery_setGroup($group, $order)
+ {
+ $this->_groups[$group] = $order;
+ }
+
+ /**
+ * Tear down tasks for this container
+ *
+ * @throws PHPException
+ */
+ public function mockery_teardown()
+ {
+ try {
+ $this->mockery_verify();
+ } catch (PHPException $phpException) {
+ $this->mockery_close();
+
+ throw $phpException;
+ }
+ }
+
+ /**
+ * Retrieves all exceptions thrown by mocks
+ *
+ * @return array
+ */
+ public function mockery_thrownExceptions()
+ {
+ /** @var array $exceptions */
+ $exceptions = [];
+
+ foreach ($this->_mocks as $mock) {
+ foreach ($mock->mockery_thrownExceptions() as $exception) {
+ $exceptions[] = $exception;
+ }
+ }
+
+ return $exceptions;
+ }
+
+ /**
+ * Validate the current mock's ordering
+ *
+ * @param string $method
+ * @param int $order
+ *
+ * @throws Exception
+ */
+ public function mockery_validateOrder($method, $order, LegacyMockInterface $mock)
+ {
+ if ($order < $this->_currentOrder) {
+ $exception = new InvalidOrderException(
+ sprintf(
+ 'Method %s called out of order: expected order %d, was %d',
+ $method,
+ $order,
+ $this->_currentOrder
+ )
+ );
+
+ $exception->setMock($mock)
+ ->setMethodName($method)
+ ->setExpectedOrder($order)
+ ->setActualOrder($this->_currentOrder);
+
+ throw $exception;
+ }
+
+ $this->mockery_setCurrentOrder($order);
+ }
+
+ /**
+ * Verify the container mocks
+ */
+ public function mockery_verify()
+ {
+ foreach ($this->_mocks as $mock) {
+ $mock->mockery_verify();
+ }
+ }
+
+ /**
+ * Store a mock and set its container reference
+ *
+ * @template TRememberMock of object
+ *
+ * @param LegacyMockInterface&MockInterface&TRememberMock $mock
+ *
+ * @return LegacyMockInterface&MockInterface&TRememberMock
+ */
+ public function rememberMock(LegacyMockInterface $mock)
+ {
+ $class = get_class($mock);
+
+ if (! array_key_exists($class, $this->_mocks)) {
+ return $this->_mocks[$class] = $mock;
+ }
+
+ /**
+ * This condition triggers for an instance mock where origin mock
+ * is already remembered
+ */
+ return $this->_mocks[] = $mock;
+ }
+
+ /**
+ * Retrieve the last remembered mock object,
+ * which is the same as saying retrieve the current mock being programmed where you have yet to call mock()
+ * to change it thus why the method name is "self" since it will be used during the programming of the same mock.
+ *
+ * @return LegacyMockInterface|MockInterface
+ */
+ public function self()
+ {
+ $mocks = array_values($this->_mocks);
+ $index = count($mocks) - 1;
+ return $mocks[$index];
+ }
+
+ /**
+ * @template TMock of object
+ * @template TMixed
+ *
+ * @param class-string $mockName
+ * @param null|array $constructorArgs
+ *
+ * @return TMock
+ */
+ protected function _getInstance($mockName, $constructorArgs = null)
+ {
+ if ($constructorArgs !== null) {
+ return (new ReflectionClass($mockName))->newInstanceArgs($constructorArgs);
+ }
+
+ try {
+ $instance = $this->instantiator->instantiate($mockName);
+ } catch (PHPException $phpException) {
+ /** @var class-string $internalMockName */
+ $internalMockName = $mockName . '_Internal';
+
+ if (! class_exists($internalMockName)) {
+ eval(sprintf(
+ 'class %s extends %s { public function __construct() {} }',
+ $internalMockName,
+ $mockName
+ ));
+ }
+
+ $instance = new $internalMockName();
+ }
+
+ return $instance;
+ }
+
+ protected function checkForNamedMockClashes($config)
+ {
+ $name = $config->getName();
+
+ if ($name === null) {
+ return;
+ }
+
+ $hash = $config->getHash();
+
+ if (array_key_exists($name, $this->_namedMocks) && $hash !== $this->_namedMocks[$name]) {
+ throw new Exception(
+ sprintf("The mock named '%s' has been already defined with a different mock configuration", $name)
+ );
+ }
+
+ $this->_namedMocks[$name] = $hash;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/CountValidator/AtLeast.php b/vendor/mockery/mockery/library/Mockery/CountValidator/AtLeast.php
new file mode 100644
index 0000000..f250d75
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/CountValidator/AtLeast.php
@@ -0,0 +1,58 @@
+_limit > $n) {
+ $exception = new InvalidCountException(
+ 'Method ' . (string) $this->_expectation
+ . ' from ' . $this->_expectation->getMock()->mockery_getName()
+ . ' should be called' . PHP_EOL
+ . ' at least ' . $this->_limit . ' times but called ' . $n
+ . ' times.'
+ );
+
+ $exception->setMock($this->_expectation->getMock())
+ ->setMethodName((string) $this->_expectation)
+ ->setExpectedCountComparative('>=')
+ ->setExpectedCount($this->_limit)
+ ->setActualCount($n);
+ throw $exception;
+ }
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/CountValidator/AtMost.php b/vendor/mockery/mockery/library/Mockery/CountValidator/AtMost.php
new file mode 100644
index 0000000..11bbe37
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/CountValidator/AtMost.php
@@ -0,0 +1,45 @@
+_limit < $n) {
+ $exception = new InvalidCountException(
+ 'Method ' . (string) $this->_expectation
+ . ' from ' . $this->_expectation->getMock()->mockery_getName()
+ . ' should be called' . PHP_EOL
+ . ' at most ' . $this->_limit . ' times but called ' . $n
+ . ' times.'
+ );
+ $exception->setMock($this->_expectation->getMock())
+ ->setMethodName((string) $this->_expectation)
+ ->setExpectedCountComparative('<=')
+ ->setExpectedCount($this->_limit)
+ ->setActualCount($n);
+ throw $exception;
+ }
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/CountValidator/CountValidatorAbstract.php b/vendor/mockery/mockery/library/Mockery/CountValidator/CountValidatorAbstract.php
new file mode 100644
index 0000000..3ecfde3
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/CountValidator/CountValidatorAbstract.php
@@ -0,0 +1,62 @@
+_expectation = $expectation;
+ $this->_limit = $limit;
+ }
+
+ /**
+ * Checks if the validator can accept an additional nth call
+ *
+ * @param int $n
+ *
+ * @return bool
+ */
+ public function isEligible($n)
+ {
+ return $n < $this->_limit;
+ }
+
+ /**
+ * Validate the call count against this validator
+ *
+ * @param int $n
+ *
+ * @return bool
+ */
+ abstract public function validate($n);
+}
diff --git a/vendor/mockery/mockery/library/Mockery/CountValidator/CountValidatorInterface.php b/vendor/mockery/mockery/library/Mockery/CountValidator/CountValidatorInterface.php
new file mode 100644
index 0000000..1cbf4cc
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/CountValidator/CountValidatorInterface.php
@@ -0,0 +1,24 @@
+_limit !== $n) {
+ $because = $this->_expectation->getExceptionMessage();
+
+ $exception = new InvalidCountException(
+ 'Method ' . (string) $this->_expectation
+ . ' from ' . $this->_expectation->getMock()->mockery_getName()
+ . ' should be called' . PHP_EOL
+ . ' exactly ' . $this->_limit . ' times but called ' . $n
+ . ' times.'
+ . ($because ? ' Because ' . $this->_expectation->getExceptionMessage() : '')
+ );
+ $exception->setMock($this->_expectation->getMock())
+ ->setMethodName((string) $this->_expectation)
+ ->setExpectedCountComparative('=')
+ ->setExpectedCount($this->_limit)
+ ->setActualCount($n);
+ throw $exception;
+ }
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/CountValidator/Exception.php b/vendor/mockery/mockery/library/Mockery/CountValidator/Exception.php
new file mode 100644
index 0000000..b1c20cd
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/CountValidator/Exception.php
@@ -0,0 +1,18 @@
+dismissed = true;
+ // we sometimes stack them
+ $previous = $this->getPrevious();
+ if (! $previous instanceof self) {
+ return;
+ }
+
+ $previous->dismiss();
+ }
+
+ /**
+ * @return bool
+ */
+ public function dismissed()
+ {
+ return $this->dismissed;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Exception/InvalidArgumentException.php b/vendor/mockery/mockery/library/Mockery/Exception/InvalidArgumentException.php
new file mode 100644
index 0000000..d76e275
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Exception/InvalidArgumentException.php
@@ -0,0 +1,15 @@
+actual;
+ }
+
+ /**
+ * @return int
+ */
+ public function getExpectedCount()
+ {
+ return $this->expected;
+ }
+
+ /**
+ * @return string
+ */
+ public function getExpectedCountComparative()
+ {
+ return $this->expectedComparative;
+ }
+
+ /**
+ * @return string|null
+ */
+ public function getMethodName()
+ {
+ return $this->method;
+ }
+
+ /**
+ * @return LegacyMockInterface|null
+ */
+ public function getMock()
+ {
+ return $this->mockObject;
+ }
+
+ /**
+ * @throws RuntimeException
+ * @return string|null
+ */
+ public function getMockName()
+ {
+ $mock = $this->getMock();
+
+ if ($mock === null) {
+ return '';
+ }
+
+ return $mock->mockery_getName();
+ }
+
+ /**
+ * @param int $count
+ * @return self
+ */
+ public function setActualCount($count)
+ {
+ $this->actual = $count;
+ return $this;
+ }
+
+ /**
+ * @param int $count
+ * @return self
+ */
+ public function setExpectedCount($count)
+ {
+ $this->expected = $count;
+ return $this;
+ }
+
+ /**
+ * @param string $comp
+ * @return self
+ */
+ public function setExpectedCountComparative($comp)
+ {
+ if (! in_array($comp, ['=', '>', '<', '>=', '<='], true)) {
+ throw new RuntimeException('Illegal comparative for expected call counts set: ' . $comp);
+ }
+
+ $this->expectedComparative = $comp;
+ return $this;
+ }
+
+ /**
+ * @param string $name
+ * @return self
+ */
+ public function setMethodName($name)
+ {
+ $this->method = $name;
+ return $this;
+ }
+
+ /**
+ * @return self
+ */
+ public function setMock(LegacyMockInterface $mock)
+ {
+ $this->mockObject = $mock;
+ return $this;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Exception/InvalidOrderException.php b/vendor/mockery/mockery/library/Mockery/Exception/InvalidOrderException.php
new file mode 100644
index 0000000..cf5bb70
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Exception/InvalidOrderException.php
@@ -0,0 +1,125 @@
+actual;
+ }
+
+ /**
+ * @return int
+ */
+ public function getExpectedOrder()
+ {
+ return $this->expected;
+ }
+
+ /**
+ * @return string|null
+ */
+ public function getMethodName()
+ {
+ return $this->method;
+ }
+
+ /**
+ * @return LegacyMockInterface|null
+ */
+ public function getMock()
+ {
+ return $this->mockObject;
+ }
+
+ /**
+ * @return string|null
+ */
+ public function getMockName()
+ {
+ $mock = $this->getMock();
+
+ if ($mock === null) {
+ return $mock;
+ }
+
+ return $mock->mockery_getName();
+ }
+
+ /**
+ * @param int $count
+ *
+ * @return self
+ */
+ public function setActualOrder($count)
+ {
+ $this->actual = $count;
+ return $this;
+ }
+
+ /**
+ * @param int $count
+ *
+ * @return self
+ */
+ public function setExpectedOrder($count)
+ {
+ $this->expected = $count;
+ return $this;
+ }
+
+ /**
+ * @param string $name
+ *
+ * @return self
+ */
+ public function setMethodName($name)
+ {
+ $this->method = $name;
+ return $this;
+ }
+
+ /**
+ * @return self
+ */
+ public function setMock(LegacyMockInterface $mock)
+ {
+ $this->mockObject = $mock;
+ return $this;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Exception/MockeryExceptionInterface.php b/vendor/mockery/mockery/library/Mockery/Exception/MockeryExceptionInterface.php
new file mode 100644
index 0000000..5ce07ee
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Exception/MockeryExceptionInterface.php
@@ -0,0 +1,19 @@
+
+ */
+ protected $actual = [];
+
+ /**
+ * @var string|null
+ */
+ protected $method = null;
+
+ /**
+ * @var LegacyMockInterface|null
+ */
+ protected $mockObject = null;
+
+ /**
+ * @return array
+ */
+ public function getActualArguments()
+ {
+ return $this->actual;
+ }
+
+ /**
+ * @return string|null
+ */
+ public function getMethodName()
+ {
+ return $this->method;
+ }
+
+ /**
+ * @return LegacyMockInterface|null
+ */
+ public function getMock()
+ {
+ return $this->mockObject;
+ }
+
+ /**
+ * @return string|null
+ */
+ public function getMockName()
+ {
+ $mock = $this->getMock();
+
+ if ($mock === null) {
+ return $mock;
+ }
+
+ return $mock->mockery_getName();
+ }
+
+ /**
+ * @todo Rename param `count` to `args`
+ * @template TMixed
+ *
+ * @param array $count
+ * @return self
+ */
+ public function setActualArguments($count)
+ {
+ $this->actual = $count;
+ return $this;
+ }
+
+ /**
+ * @param string $name
+ * @return self
+ */
+ public function setMethodName($name)
+ {
+ $this->method = $name;
+ return $this;
+ }
+
+ /**
+ * @return self
+ */
+ public function setMock(LegacyMockInterface $mock)
+ {
+ $this->mockObject = $mock;
+ return $this;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Exception/RuntimeException.php b/vendor/mockery/mockery/library/Mockery/Exception/RuntimeException.php
new file mode 100644
index 0000000..5d4f643
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Exception/RuntimeException.php
@@ -0,0 +1,17 @@
+_mock = $mock;
+ $this->_name = $name;
+ $this->withAnyArgs();
+ }
+
+ /**
+ * Cloning logic
+ */
+ public function __clone()
+ {
+ $newValidators = [];
+
+ $countValidators = $this->_countValidators;
+
+ foreach ($countValidators as $validator) {
+ $newValidators[] = clone $validator;
+ }
+
+ $this->_countValidators = $newValidators;
+ }
+
+ /**
+ * Return a string with the method name and arguments formatted
+ *
+ * @return string
+ */
+ public function __toString()
+ {
+ return Mockery::formatArgs($this->_name, $this->_expectedArgs);
+ }
+
+ /**
+ * Set a return value, or sequential queue of return values
+ *
+ * @param mixed ...$args
+ *
+ * @return self
+ */
+ public function andReturn(...$args)
+ {
+ $this->_returnQueue = $args;
+
+ return $this;
+ }
+
+ /**
+ * Sets up a closure to return the nth argument from the expected method call
+ *
+ * @param int $index
+ *
+ * @return self
+ */
+ public function andReturnArg($index)
+ {
+ if (! is_int($index) || $index < 0) {
+ throw new InvalidArgumentException(
+ 'Invalid argument index supplied. Index must be a non-negative integer.'
+ );
+ }
+
+ $closure = static function (...$args) use ($index) {
+ if (array_key_exists($index, $args)) {
+ return $args[$index];
+ }
+
+ throw new OutOfBoundsException(
+ 'Cannot return an argument value. No argument exists for the index ' . $index
+ );
+ };
+
+ $this->_closureQueue = [$closure];
+
+ return $this;
+ }
+
+ /**
+ * @return self
+ */
+ public function andReturnFalse()
+ {
+ return $this->andReturn(false);
+ }
+
+ /**
+ * Return null. This is merely a language construct for Mock describing.
+ *
+ * @return self
+ */
+ public function andReturnNull()
+ {
+ return $this->andReturn(null);
+ }
+
+ /**
+ * Set a return value, or sequential queue of return values
+ *
+ * @param mixed ...$args
+ *
+ * @return self
+ */
+ public function andReturns(...$args)
+ {
+ return $this->andReturn(...$args);
+ }
+
+ /**
+ * Return this mock, like a fluent interface
+ *
+ * @return self
+ */
+ public function andReturnSelf()
+ {
+ return $this->andReturn($this->_mock);
+ }
+
+ /**
+ * @return self
+ */
+ public function andReturnTrue()
+ {
+ return $this->andReturn(true);
+ }
+
+ /**
+ * Return a self-returning black hole object.
+ *
+ * @return self
+ */
+ public function andReturnUndefined()
+ {
+ return $this->andReturn(new Undefined());
+ }
+
+ /**
+ * Set a closure or sequence of closures with which to generate return
+ * values. The arguments passed to the expected method are passed to the
+ * closures as parameters.
+ *
+ * @param callable ...$args
+ *
+ * @return self
+ */
+ public function andReturnUsing(...$args)
+ {
+ $this->_closureQueue = $args;
+
+ return $this;
+ }
+
+ /**
+ * Set a sequential queue of return values with an array
+ *
+ * @return self
+ */
+ public function andReturnValues(array $values)
+ {
+ return $this->andReturn(...$values);
+ }
+
+ /**
+ * Register values to be set to a public property each time this expectation occurs
+ *
+ * @param string $name
+ * @param array ...$values
+ *
+ * @return self
+ */
+ public function andSet($name, ...$values)
+ {
+ $this->_setQueue[$name] = $values;
+
+ return $this;
+ }
+
+ /**
+ * Set Exception class and arguments to that class to be thrown
+ *
+ * @param string|Throwable $exception
+ * @param string $message
+ * @param int $code
+ *
+ * @return self
+ */
+ public function andThrow($exception, $message = '', $code = 0, ?\Exception $previous = null)
+ {
+ $this->_throw = true;
+
+ if (is_object($exception)) {
+ return $this->andReturn($exception);
+ }
+
+ return $this->andReturn(new $exception($message, $code, $previous));
+ }
+
+ /**
+ * Set Exception classes to be thrown
+ *
+ * @return self
+ */
+ public function andThrowExceptions(array $exceptions)
+ {
+ $this->_throw = true;
+
+ foreach ($exceptions as $exception) {
+ if (! is_object($exception)) {
+ throw new Exception('You must pass an array of exception objects to andThrowExceptions');
+ }
+ }
+
+ return $this->andReturnValues($exceptions);
+ }
+
+ public function andThrows($exception, $message = '', $code = 0, ?\Exception $previous = null)
+ {
+ return $this->andThrow($exception, $message, $code, $previous);
+ }
+
+ /**
+ * Sets up a closure that will yield each of the provided args
+ *
+ * @param mixed ...$args
+ *
+ * @return self
+ */
+ public function andYield(...$args)
+ {
+ $closure = static function () use ($args) {
+ foreach ($args as $arg) {
+ yield $arg;
+ }
+ };
+
+ $this->_closureQueue = [$closure];
+
+ return $this;
+ }
+
+ /**
+ * Sets next count validator to the AtLeast instance
+ *
+ * @return self
+ */
+ public function atLeast()
+ {
+ $this->_countValidatorClass = AtLeast::class;
+
+ return $this;
+ }
+
+ /**
+ * Sets next count validator to the AtMost instance
+ *
+ * @return self
+ */
+ public function atMost()
+ {
+ $this->_countValidatorClass = AtMost::class;
+
+ return $this;
+ }
+
+ /**
+ * Set the exception message
+ *
+ * @param string $message
+ *
+ * @return $this
+ */
+ public function because($message)
+ {
+ $this->_because = $message;
+
+ return $this;
+ }
+
+ /**
+ * Shorthand for setting minimum and maximum constraints on call counts
+ *
+ * @param int $minimum
+ * @param int $maximum
+ */
+ public function between($minimum, $maximum)
+ {
+ return $this->atLeast()->times($minimum)->atMost()->times($maximum);
+ }
+
+ /**
+ * Mark this expectation as being a default
+ *
+ * @return self
+ */
+ public function byDefault()
+ {
+ $director = $this->_mock->mockery_getExpectationsFor($this->_name);
+
+ if ($director instanceof ExpectationDirector) {
+ $director->makeExpectationDefault($this);
+ }
+
+ return $this;
+ }
+
+ /**
+ * @return null|string
+ */
+ public function getExceptionMessage()
+ {
+ return $this->_because;
+ }
+
+ /**
+ * Return the parent mock of the expectation
+ *
+ * @return LegacyMockInterface|MockInterface
+ */
+ public function getMock()
+ {
+ return $this->_mock;
+ }
+
+ public function getName()
+ {
+ return $this->_name;
+ }
+
+ /**
+ * Return order number
+ *
+ * @return int
+ */
+ public function getOrderNumber()
+ {
+ return $this->_orderNumber;
+ }
+
+ /**
+ * Indicates call order should apply globally
+ *
+ * @return self
+ */
+ public function globally()
+ {
+ $this->_globally = true;
+
+ return $this;
+ }
+
+ /**
+ * Check if there is a constraint on call count
+ *
+ * @return bool
+ */
+ public function isCallCountConstrained()
+ {
+ return $this->_countValidators !== [];
+ }
+
+ /**
+ * Checks if this expectation is eligible for additional calls
+ *
+ * @return bool
+ */
+ public function isEligible()
+ {
+ foreach ($this->_countValidators as $validator) {
+ if (! $validator->isEligible($this->_actualCount)) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ /**
+ * Check if passed arguments match an argument expectation
+ *
+ * @return bool
+ */
+ public function matchArgs(array $args)
+ {
+ if ($this->isArgumentListMatcher()) {
+ return $this->_matchArg($this->_expectedArgs[0], $args);
+ }
+
+ $argCount = count($args);
+
+ $expectedArgsCount = count($this->_expectedArgs);
+
+ if ($argCount === $expectedArgsCount) {
+ return $this->_matchArgs($args);
+ }
+
+ $lastExpectedArgument = $this->_expectedArgs[$expectedArgsCount - 1];
+
+ if ($lastExpectedArgument instanceof AndAnyOtherArgs) {
+ $firstCorrespondingKey = array_search($lastExpectedArgument, $this->_expectedArgs, true);
+
+ $args = array_slice($args, 0, $firstCorrespondingKey);
+
+ return $this->_matchArgs($args);
+ }
+
+ return false;
+ }
+
+ /**
+ * Indicates that this expectation is never expected to be called
+ *
+ * @return self
+ */
+ public function never()
+ {
+ return $this->times(0);
+ }
+
+ /**
+ * Indicates that this expectation is expected exactly once
+ *
+ * @return self
+ */
+ public function once()
+ {
+ return $this->times(1);
+ }
+
+ /**
+ * Indicates that this expectation must be called in a specific given order
+ *
+ * @param string $group Name of the ordered group
+ *
+ * @return self
+ */
+ public function ordered($group = null)
+ {
+ if ($this->_globally) {
+ $this->_globalOrderNumber = $this->_defineOrdered($group, $this->_mock->mockery_getContainer());
+ } else {
+ $this->_orderNumber = $this->_defineOrdered($group, $this->_mock);
+ }
+
+ $this->_globally = false;
+
+ return $this;
+ }
+
+ /**
+ * Flag this expectation as calling the original class method with
+ * the provided arguments instead of using a return value queue.
+ *
+ * @return self
+ */
+ public function passthru()
+ {
+ if ($this->_mock instanceof Mock) {
+ throw new Exception(
+ 'Mock Objects not created from a loaded/existing class are incapable of passing method calls through to a parent class'
+ );
+ }
+
+ $this->_passthru = true;
+
+ return $this;
+ }
+
+ /**
+ * Alias to andSet(). Allows the natural English construct
+ * - set('foo', 'bar')->andReturn('bar')
+ *
+ * @param string $name
+ * @param mixed $value
+ *
+ * @return self
+ */
+ public function set($name, $value)
+ {
+ return $this->andSet(...func_get_args());
+ }
+
+ /**
+ * Indicates the number of times this expectation should occur
+ *
+ * @param int $limit
+ *
+ * @throws InvalidArgumentException
+ *
+ * @return self
+ */
+ public function times($limit = null)
+ {
+ if ($limit === null) {
+ return $this;
+ }
+
+ if (! is_int($limit)) {
+ throw new InvalidArgumentException('The passed Times limit should be an integer value');
+ }
+
+ if ($this->_expectedCount === 0) {
+ @trigger_error(self::ERROR_ZERO_INVOCATION, E_USER_DEPRECATED);
+ // throw new \InvalidArgumentException(self::ERROR_ZERO_INVOCATION);
+ }
+
+ if ($limit === 0) {
+ $this->_countValidators = [];
+ }
+
+ $this->_expectedCount = $limit;
+
+ $this->_countValidators[$this->_countValidatorClass] = new $this->_countValidatorClass($this, $limit);
+
+ if ($this->_countValidatorClass !== Exact::class) {
+ $this->_countValidatorClass = Exact::class;
+
+ unset($this->_countValidators[$this->_countValidatorClass]);
+ }
+
+ return $this;
+ }
+
+ /**
+ * Indicates that this expectation is expected exactly twice
+ *
+ * @return self
+ */
+ public function twice()
+ {
+ return $this->times(2);
+ }
+
+ /**
+ * Verify call order
+ *
+ * @return void
+ */
+ public function validateOrder()
+ {
+ if ($this->_orderNumber) {
+ $this->_mock->mockery_validateOrder((string) $this, $this->_orderNumber, $this->_mock);
+ }
+
+ if ($this->_globalOrderNumber) {
+ $this->_mock->mockery_getContainer()->mockery_validateOrder(
+ (string) $this,
+ $this->_globalOrderNumber,
+ $this->_mock
+ );
+ }
+ }
+
+ /**
+ * Verify this expectation
+ *
+ * @return void
+ */
+ public function verify()
+ {
+ foreach ($this->_countValidators as $validator) {
+ $validator->validate($this->_actualCount);
+ }
+ }
+
+ /**
+ * Verify the current call, i.e. that the given arguments match those
+ * of this expectation
+ *
+ * @throws Throwable
+ *
+ * @return mixed
+ */
+ public function verifyCall(array $args)
+ {
+ $this->validateOrder();
+
+ ++$this->_actualCount;
+
+ if ($this->_passthru === true) {
+ return $this->_mock->mockery_callSubjectMethod($this->_name, $args);
+ }
+
+ $return = $this->_getReturnValue($args);
+
+ $this->throwAsNecessary($return);
+
+ $this->_setValues();
+
+ return $return;
+ }
+
+ /**
+ * Expected argument setter for the expectation
+ *
+ * @param mixed ...$args
+ *
+ * @return self
+ */
+ public function with(...$args)
+ {
+ return $this->withArgs($args);
+ }
+
+ /**
+ * Set expectation that any arguments are acceptable
+ *
+ * @return self
+ */
+ public function withAnyArgs()
+ {
+ $this->_expectedArgs = [new AnyArgs()];
+
+ return $this;
+ }
+
+ /**
+ * Expected arguments for the expectation passed as an array or a closure that matches each passed argument on
+ * each function call.
+ *
+ * @param array|Closure $argsOrClosure
+ *
+ * @return self
+ */
+ public function withArgs($argsOrClosure)
+ {
+ if (is_array($argsOrClosure)) {
+ return $this->withArgsInArray($argsOrClosure);
+ }
+
+ if ($argsOrClosure instanceof Closure) {
+ return $this->withArgsMatchedByClosure($argsOrClosure);
+ }
+
+ throw new InvalidArgumentException(sprintf(
+ 'Call to %s with an invalid argument (%s), only array and closure are allowed',
+ __METHOD__,
+ $argsOrClosure
+ ));
+ }
+
+ /**
+ * Set with() as no arguments expected
+ *
+ * @return self
+ */
+ public function withNoArgs()
+ {
+ $this->_expectedArgs = [new NoArgs()];
+
+ return $this;
+ }
+
+ /**
+ * Expected arguments should partially match the real arguments
+ *
+ * @param mixed ...$expectedArgs
+ *
+ * @return self
+ */
+ public function withSomeOfArgs(...$expectedArgs)
+ {
+ return $this->withArgs(static function (...$args) use ($expectedArgs): bool {
+ foreach ($expectedArgs as $expectedArg) {
+ if (! in_array($expectedArg, $args, true)) {
+ return false;
+ }
+ }
+
+ return true;
+ });
+ }
+
+ /**
+ * Indicates this expectation should occur zero or more times
+ *
+ * @return self
+ */
+ public function zeroOrMoreTimes()
+ {
+ return $this->atLeast()->never();
+ }
+
+ /**
+ * Setup the ordering tracking on the mock or mock container
+ *
+ * @param string $group
+ * @param object $ordering
+ *
+ * @return int
+ */
+ protected function _defineOrdered($group, $ordering)
+ {
+ $groups = $ordering->mockery_getGroups();
+ if ($group === null) {
+ return $ordering->mockery_allocateOrder();
+ }
+
+ if (array_key_exists($group, $groups)) {
+ return $groups[$group];
+ }
+
+ $result = $ordering->mockery_allocateOrder();
+
+ $ordering->mockery_setGroup($group, $result);
+
+ return $result;
+ }
+
+ /**
+ * Fetch the return value for the matching args
+ *
+ * @return mixed
+ */
+ protected function _getReturnValue(array $args)
+ {
+ $closureQueueCount = count($this->_closureQueue);
+
+ if ($closureQueueCount > 1) {
+ return array_shift($this->_closureQueue)(...$args);
+ }
+
+ if ($closureQueueCount > 0) {
+ return current($this->_closureQueue)(...$args);
+ }
+
+ $returnQueueCount = count($this->_returnQueue);
+
+ if ($returnQueueCount > 1) {
+ return array_shift($this->_returnQueue);
+ }
+
+ if ($returnQueueCount > 0) {
+ return current($this->_returnQueue);
+ }
+
+ return $this->_mock->mockery_returnValueForMethod($this->_name);
+ }
+
+ /**
+ * Check if passed argument matches an argument expectation
+ *
+ * @param mixed $expected
+ * @param mixed $actual
+ *
+ * @return bool
+ */
+ protected function _matchArg($expected, &$actual)
+ {
+ if ($expected === $actual) {
+ return true;
+ }
+
+ if ($expected instanceof MatcherInterface) {
+ return $expected->match($actual);
+ }
+
+ if ($expected instanceof Constraint) {
+ return (bool) $expected->evaluate($actual, '', true);
+ }
+
+ if ($expected instanceof Matcher || $expected instanceof Hamcrest_Matcher) {
+ @trigger_error('Hamcrest package has been deprecated and will be removed in 2.0', E_USER_DEPRECATED);
+
+ return $expected->matches($actual);
+ }
+
+ if (is_object($expected)) {
+ $matcher = Mockery::getConfiguration()->getDefaultMatcher(get_class($expected));
+
+ return $matcher === null ? false : $this->_matchArg(new $matcher($expected), $actual);
+ }
+
+ if (is_object($actual) && is_string($expected) && $actual instanceof $expected) {
+ return true;
+ }
+
+ return $expected == $actual;
+ }
+
+ /**
+ * Check if the passed arguments match the expectations, one by one.
+ *
+ * @param array $args
+ *
+ * @return bool
+ */
+ protected function _matchArgs($args)
+ {
+ for ($index = 0, $argCount = count($args); $index < $argCount; ++$index) {
+ $param = &$args[$index];
+
+ if (! $this->_matchArg($this->_expectedArgs[$index], $param)) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ /**
+ * Sets public properties with queued values to the mock object
+ *
+ * @return void
+ */
+ protected function _setValues()
+ {
+ $mockClass = get_class($this->_mock);
+
+ $container = $this->_mock->mockery_getContainer();
+
+ $mocks = $container->getMocks();
+
+ foreach ($this->_setQueue as $name => &$values) {
+ if ($values === []) {
+ continue;
+ }
+
+ $value = array_shift($values);
+
+ $this->_mock->{$name} = $value;
+
+ foreach ($mocks as $mock) {
+ if (! $mock instanceof $mockClass) {
+ continue;
+ }
+
+ if (! $mock->mockery_isInstance()) {
+ continue;
+ }
+
+ $mock->{$name} = $value;
+ }
+ }
+ }
+
+ /**
+ * @template TExpectedArg
+ *
+ * @param TExpectedArg $expectedArg
+ *
+ * @return bool
+ */
+ private function isAndAnyOtherArgumentsMatcher($expectedArg)
+ {
+ return $expectedArg instanceof AndAnyOtherArgs;
+ }
+
+ /**
+ * Check if the registered expectation is an ArgumentListMatcher
+ *
+ * @return bool
+ */
+ private function isArgumentListMatcher()
+ {
+ return $this->_expectedArgs !== [] && $this->_expectedArgs[0] instanceof ArgumentListMatcher;
+ }
+
+ /**
+ * Throws an exception if the expectation has been configured to do so
+ *
+ * @param Throwable $return
+ *
+ * @throws Throwable
+ *
+ * @return void
+ */
+ private function throwAsNecessary($return)
+ {
+ if (! $this->_throw) {
+ return;
+ }
+
+ if (! $return instanceof Throwable) {
+ return;
+ }
+
+ throw $return;
+ }
+
+ /**
+ * Expected arguments for the expectation passed as an array
+ *
+ * @return self
+ */
+ private function withArgsInArray(array $arguments)
+ {
+ if ($arguments === []) {
+ return $this->withNoArgs();
+ }
+
+ $this->_expectedArgs = $arguments;
+
+ return $this;
+ }
+
+ /**
+ * Expected arguments have to be matched by the given closure.
+ *
+ * @return self
+ */
+ private function withArgsMatchedByClosure(Closure $closure)
+ {
+ $this->_expectedArgs = [new MultiArgumentClosure($closure)];
+
+ return $this;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/ExpectationDirector.php b/vendor/mockery/mockery/library/Mockery/ExpectationDirector.php
new file mode 100644
index 0000000..286268b
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/ExpectationDirector.php
@@ -0,0 +1,242 @@
+
+ */
+ protected $_defaults = [];
+
+ /**
+ * Stores an array of all expectations for this mock
+ *
+ * @var list
+ */
+ protected $_expectations = [];
+
+ /**
+ * The expected order of next call
+ *
+ * @var int
+ */
+ protected $_expectedOrder = null;
+
+ /**
+ * Mock object the director is attached to
+ *
+ * @var LegacyMockInterface|MockInterface
+ */
+ protected $_mock = null;
+
+ /**
+ * Method name the director is directing
+ *
+ * @var string
+ */
+ protected $_name = null;
+
+ /**
+ * Constructor
+ *
+ * @param string $name
+ */
+ public function __construct($name, LegacyMockInterface $mock)
+ {
+ $this->_name = $name;
+ $this->_mock = $mock;
+ }
+
+ /**
+ * Add a new expectation to the director
+ */
+ public function addExpectation(Expectation $expectation)
+ {
+ $this->_expectations[] = $expectation;
+ }
+
+ /**
+ * Handle a method call being directed by this instance
+ *
+ * @return mixed
+ */
+ public function call(array $args)
+ {
+ $expectation = $this->findExpectation($args);
+ if ($expectation !== null) {
+ return $expectation->verifyCall($args);
+ }
+
+ $exception = new NoMatchingExpectationException(
+ 'No matching handler found for '
+ . $this->_mock->mockery_getName() . '::'
+ . Mockery::formatArgs($this->_name, $args)
+ . '. Either the method was unexpected or its arguments matched'
+ . ' no expected argument list for this method'
+ . PHP_EOL . PHP_EOL
+ . Mockery::formatObjects($args)
+ );
+
+ $exception->setMock($this->_mock)
+ ->setMethodName($this->_name)
+ ->setActualArguments($args);
+
+ throw $exception;
+ }
+
+ /**
+ * Attempt to locate an expectation matching the provided args
+ *
+ * @return mixed
+ */
+ public function findExpectation(array $args)
+ {
+ $expectation = null;
+
+ if ($this->_expectations !== []) {
+ $expectation = $this->_findExpectationIn($this->_expectations, $args);
+ }
+
+ if ($expectation === null && $this->_defaults !== []) {
+ return $this->_findExpectationIn($this->_defaults, $args);
+ }
+
+ return $expectation;
+ }
+
+ /**
+ * Return all expectations assigned to this director
+ *
+ * @return array
+ */
+ public function getDefaultExpectations()
+ {
+ return $this->_defaults;
+ }
+
+ /**
+ * Return the number of expectations assigned to this director.
+ *
+ * @return int
+ */
+ public function getExpectationCount()
+ {
+ $count = 0;
+
+ $expectations = $this->getExpectations();
+
+ if ($expectations === []) {
+ $expectations = $this->getDefaultExpectations();
+ }
+
+ foreach ($expectations as $expectation) {
+ if ($expectation->isCallCountConstrained()) {
+ ++$count;
+ }
+ }
+
+ return $count;
+ }
+
+ /**
+ * Return all expectations assigned to this director
+ *
+ * @return array
+ */
+ public function getExpectations()
+ {
+ return $this->_expectations;
+ }
+
+ /**
+ * Make the given expectation a default for all others assuming it was correctly created last
+ *
+ * @throws Exception
+ *
+ * @return void
+ */
+ public function makeExpectationDefault(Expectation $expectation)
+ {
+ if (end($this->_expectations) === $expectation) {
+ array_pop($this->_expectations);
+
+ array_unshift($this->_defaults, $expectation);
+
+ return;
+ }
+
+ throw new Exception('Cannot turn a previously defined expectation into a default');
+ }
+
+ /**
+ * Verify all expectations of the director
+ *
+ * @throws Exception
+ *
+ * @return void
+ */
+ public function verify()
+ {
+ if ($this->_expectations !== []) {
+ foreach ($this->_expectations as $expectation) {
+ $expectation->verify();
+ }
+
+ return;
+ }
+
+ foreach ($this->_defaults as $expectation) {
+ $expectation->verify();
+ }
+ }
+
+ /**
+ * Search current array of expectations for a match
+ *
+ * @param array $expectations
+ *
+ * @return null|ExpectationInterface
+ */
+ protected function _findExpectationIn(array $expectations, array $args)
+ {
+ foreach ($expectations as $expectation) {
+ if (! $expectation->isEligible()) {
+ continue;
+ }
+
+ if (! $expectation->matchArgs($args)) {
+ continue;
+ }
+
+ return $expectation;
+ }
+
+ foreach ($expectations as $expectation) {
+ if ($expectation->matchArgs($args)) {
+ return $expectation;
+ }
+ }
+
+ return null;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/ExpectationInterface.php b/vendor/mockery/mockery/library/Mockery/ExpectationInterface.php
new file mode 100644
index 0000000..29c27d3
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/ExpectationInterface.php
@@ -0,0 +1,38 @@
+once();
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Generator/CachingGenerator.php b/vendor/mockery/mockery/library/Mockery/Generator/CachingGenerator.php
new file mode 100644
index 0000000..deff12e
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Generator/CachingGenerator.php
@@ -0,0 +1,43 @@
+
+ */
+ protected $cache = [];
+
+ /**
+ * @var Generator
+ */
+ protected $generator;
+
+ public function __construct(Generator $generator)
+ {
+ $this->generator = $generator;
+ }
+
+ /**
+ * @return string
+ */
+ public function generate(MockConfiguration $config)
+ {
+ $hash = $config->getHash();
+
+ if (array_key_exists($hash, $this->cache)) {
+ return $this->cache[$hash];
+ }
+
+ return $this->cache[$hash] = $this->generator->generate($config);
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Generator/DefinedTargetClass.php b/vendor/mockery/mockery/library/Mockery/Generator/DefinedTargetClass.php
new file mode 100644
index 0000000..f2a3f32
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Generator/DefinedTargetClass.php
@@ -0,0 +1,188 @@
+rfc = $rfc;
+ $this->name = $alias ?? $rfc->getName();
+ }
+
+ /**
+ * @return class-string
+ */
+ public function __toString()
+ {
+ return $this->name;
+ }
+
+ /**
+ * @param class-string $name
+ * @param class-string|null $alias
+ * @return self
+ */
+ public static function factory($name, $alias = null)
+ {
+ return new self(new ReflectionClass($name), $alias);
+ }
+
+ /**
+ * @return list
+ */
+ public function getAttributes()
+ {
+ if (PHP_VERSION_ID < 80000) {
+ return [];
+ }
+
+ return array_unique(
+ array_merge(
+ ['\AllowDynamicProperties'],
+ array_map(
+ static function (ReflectionAttribute $attribute): string {
+ return '\\' . $attribute->getName();
+ },
+ $this->rfc->getAttributes()
+ )
+ )
+ );
+ }
+
+ /**
+ * @return array
+ */
+ public function getInterfaces()
+ {
+ return array_map(
+ static function (ReflectionClass $interface): self {
+ return new self($interface);
+ },
+ $this->rfc->getInterfaces()
+ );
+ }
+
+ /**
+ * @return list
+ */
+ public function getMethods()
+ {
+ return array_map(
+ static function (ReflectionMethod $method): Method {
+ return new Method($method);
+ },
+ $this->rfc->getMethods()
+ );
+ }
+
+ /**
+ * @return class-string
+ */
+ public function getName()
+ {
+ return $this->name;
+ }
+
+ /**
+ * @return string
+ */
+ public function getNamespaceName()
+ {
+ return $this->rfc->getNamespaceName();
+ }
+
+ /**
+ * @return string
+ */
+ public function getShortName()
+ {
+ return $this->rfc->getShortName();
+ }
+
+ /**
+ * @return bool
+ */
+ public function hasInternalAncestor()
+ {
+ if ($this->rfc->isInternal()) {
+ return true;
+ }
+
+ $child = $this->rfc;
+ while ($parent = $child->getParentClass()) {
+ if ($parent->isInternal()) {
+ return true;
+ }
+
+ $child = $parent;
+ }
+
+ return false;
+ }
+
+ /**
+ * @param class-string $interface
+ * @return bool
+ */
+ public function implementsInterface($interface)
+ {
+ return $this->rfc->implementsInterface($interface);
+ }
+
+ /**
+ * @return bool
+ */
+ public function inNamespace()
+ {
+ return $this->rfc->inNamespace();
+ }
+
+ /**
+ * @return bool
+ */
+ public function isAbstract()
+ {
+ return $this->rfc->isAbstract();
+ }
+
+ /**
+ * @return bool
+ */
+ public function isFinal()
+ {
+ return $this->rfc->isFinal();
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Generator/Generator.php b/vendor/mockery/mockery/library/Mockery/Generator/Generator.php
new file mode 100644
index 0000000..9dc59c8
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Generator/Generator.php
@@ -0,0 +1,19 @@
+method = $method;
+ }
+
+ /**
+ * @template TArgs
+ * @template TMixed
+ *
+ * @param string $method
+ * @param array $args
+ *
+ * @return TMixed
+ */
+ public function __call($method, $args)
+ {
+ /** @var TMixed */
+ return $this->method->{$method}(...$args);
+ }
+
+ /**
+ * @return list
+ */
+ public function getParameters()
+ {
+ return array_map(static function (ReflectionParameter $parameter) {
+ return new Parameter($parameter);
+ }, $this->method->getParameters());
+ }
+
+ /**
+ * @return null|string
+ */
+ public function getReturnType()
+ {
+ return Reflector::getReturnType($this->method);
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Generator/MockConfiguration.php b/vendor/mockery/mockery/library/Mockery/Generator/MockConfiguration.php
new file mode 100644
index 0000000..1849c3e
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Generator/MockConfiguration.php
@@ -0,0 +1,709 @@
+
+ */
+ protected $allMethods = [];
+
+ /**
+ * Methods that should specifically not be mocked
+ *
+ * This is currently populated with stuff we don't know how to deal with, should really be somewhere else
+ */
+ protected $blackListedMethods = [];
+
+ protected $constantsMap = [];
+
+ /**
+ * An instance mock is where we override the original class before it's autoloaded
+ *
+ * @var bool
+ */
+ protected $instanceMock = false;
+
+ /**
+ * If true, overrides original class destructor
+ *
+ * @var bool
+ */
+ protected $mockOriginalDestructor = false;
+
+ /**
+ * The class name we'd like to use for a generated mock
+ *
+ * @var string|null
+ */
+ protected $name;
+
+ /**
+ * Param overrides
+ *
+ * @var array
+ */
+ protected $parameterOverrides = [];
+
+ /**
+ * A class that we'd like to mock
+ * @var TargetClassInterface|null
+ */
+ protected $targetClass;
+
+ /**
+ * @var class-string|null
+ */
+ protected $targetClassName;
+
+ /**
+ * @var array
+ */
+ protected $targetInterfaceNames = [];
+
+ /**
+ * A number of interfaces we'd like to mock, keyed by name to attempt to keep unique
+ *
+ * @var array
+ */
+ protected $targetInterfaces = [];
+
+ /**
+ * An object we'd like our mock to proxy to
+ *
+ * @var object|null
+ */
+ protected $targetObject;
+
+ /**
+ * @var array
+ */
+ protected $targetTraitNames = [];
+
+ /**
+ * A number of traits we'd like to mock, keyed by name to attempt to keep unique
+ *
+ * @var array
+ */
+ protected $targetTraits = [];
+
+ /**
+ * If not empty, only these methods will be mocked
+ *
+ * @var array
+ */
+ protected $whiteListedMethods = [];
+
+ /**
+ * @param array $targets
+ * @param array $blackListedMethods
+ * @param array $whiteListedMethods
+ * @param string|null $name
+ * @param bool $instanceMock
+ * @param array $parameterOverrides
+ * @param bool $mockOriginalDestructor
+ * @param array|scalar> $constantsMap
+ */
+ public function __construct(
+ array $targets = [],
+ array $blackListedMethods = [],
+ array $whiteListedMethods = [],
+ $name = null,
+ $instanceMock = false,
+ array $parameterOverrides = [],
+ $mockOriginalDestructor = false,
+ array $constantsMap = []
+ ) {
+ $this->addTargets($targets);
+ $this->blackListedMethods = $blackListedMethods;
+ $this->whiteListedMethods = $whiteListedMethods;
+ $this->name = $name;
+ $this->instanceMock = $instanceMock;
+ $this->parameterOverrides = $parameterOverrides;
+ $this->mockOriginalDestructor = $mockOriginalDestructor;
+ $this->constantsMap = $constantsMap;
+ }
+
+ /**
+ * Generate a suitable name based on the config
+ *
+ * @return string
+ */
+ public function generateName()
+ {
+ $nameBuilder = new MockNameBuilder();
+
+ $targetObject = $this->getTargetObject();
+ if ($targetObject !== null) {
+ $className = get_class($targetObject);
+
+ $nameBuilder->addPart(strpos($className, '@') !== false ? md5($className) : $className);
+ }
+
+ $targetClass = $this->getTargetClass();
+ if ($targetClass instanceof TargetClassInterface) {
+ $className = $targetClass->getName();
+
+ $nameBuilder->addPart(strpos($className, '@') !== false ? md5($className) : $className);
+ }
+
+ foreach ($this->getTargetInterfaces() as $targetInterface) {
+ $nameBuilder->addPart($targetInterface->getName());
+ }
+
+ return $nameBuilder->build();
+ }
+
+ /**
+ * @return array
+ */
+ public function getBlackListedMethods()
+ {
+ return $this->blackListedMethods;
+ }
+
+ /**
+ * @return array>
+ */
+ public function getConstantsMap()
+ {
+ return $this->constantsMap;
+ }
+
+ /**
+ * Attempt to create a hash of the configuration, in order to allow caching
+ *
+ * @TODO workout if this will work
+ *
+ * @return string
+ */
+ public function getHash()
+ {
+ $vars = [
+ 'targetClassName' => $this->targetClassName,
+ 'targetInterfaceNames' => $this->targetInterfaceNames,
+ 'targetTraitNames' => $this->targetTraitNames,
+ 'name' => $this->name,
+ 'blackListedMethods' => $this->blackListedMethods,
+ 'whiteListedMethod' => $this->whiteListedMethods,
+ 'instanceMock' => $this->instanceMock,
+ 'parameterOverrides' => $this->parameterOverrides,
+ 'mockOriginalDestructor' => $this->mockOriginalDestructor,
+ ];
+
+ return md5(serialize($vars));
+ }
+
+ /**
+ * Gets a list of methods from the classes, interfaces and objects and filters them appropriately.
+ * Lot's of filtering going on, perhaps we could have filter classes to iterate through
+ *
+ * @return list
+ */
+ public function getMethodsToMock()
+ {
+ $methods = $this->getAllMethods();
+
+ foreach ($methods as $key => $method) {
+ if ($method->isFinal()) {
+ unset($methods[$key]);
+ }
+ }
+
+ /**
+ * Whitelist trumps everything else
+ */
+ $whiteListedMethods = $this->getWhiteListedMethods();
+ if ($whiteListedMethods !== []) {
+ $whitelist = array_map('strtolower', $whiteListedMethods);
+
+ return array_filter($methods, static function ($method) use ($whitelist) {
+ if ($method->isAbstract()) {
+ return true;
+ }
+
+ return in_array(strtolower($method->getName()), $whitelist, true);
+ });
+ }
+
+ /**
+ * Remove blacklisted methods
+ */
+ $blackListedMethods = $this->getBlackListedMethods();
+ if ($blackListedMethods !== []) {
+ $blacklist = array_map('strtolower', $blackListedMethods);
+
+ $methods = array_filter($methods, static function ($method) use ($blacklist) {
+ return ! in_array(strtolower($method->getName()), $blacklist, true);
+ });
+ }
+
+ /**
+ * Internal objects can not be instantiated with newInstanceArgs and if
+ * they implement Serializable, unserialize will have to be called. As
+ * such, we can't mock it and will need a pass to add a dummy
+ * implementation
+ */
+ $targetClass = $this->getTargetClass();
+
+ if (
+ $targetClass !== null
+ && $targetClass->implementsInterface(Serializable::class)
+ && $targetClass->hasInternalAncestor()
+ ) {
+ $methods = array_filter($methods, static function ($method) {
+ return $method->getName() !== 'unserialize';
+ });
+ }
+
+ return array_values($methods);
+ }
+
+ /**
+ * @return string|null
+ */
+ public function getName()
+ {
+ return $this->name;
+ }
+
+ /**
+ * @return string
+ */
+ public function getNamespaceName()
+ {
+ $parts = explode('\\', $this->getName());
+ array_pop($parts);
+
+ if ($parts !== []) {
+ return implode('\\', $parts);
+ }
+
+ return '';
+ }
+
+ /**
+ * @return array
+ */
+ public function getParameterOverrides()
+ {
+ return $this->parameterOverrides;
+ }
+
+ /**
+ * @return string
+ */
+ public function getShortName()
+ {
+ $parts = explode('\\', $this->getName());
+ return array_pop($parts);
+ }
+
+ /**
+ * @return null|TargetClassInterface
+ */
+ public function getTargetClass()
+ {
+ if ($this->targetClass) {
+ return $this->targetClass;
+ }
+
+ if (! $this->targetClassName) {
+ return null;
+ }
+
+ if (class_exists($this->targetClassName)) {
+ $alias = null;
+ if (strpos($this->targetClassName, '@') !== false) {
+ $alias = (new MockNameBuilder())
+ ->addPart('anonymous_class')
+ ->addPart(md5($this->targetClassName))
+ ->build();
+ class_alias($this->targetClassName, $alias);
+ }
+
+ $dtc = DefinedTargetClass::factory($this->targetClassName, $alias);
+
+ if ($this->getTargetObject() === null && $dtc->isFinal()) {
+ throw new Exception(
+ 'The class ' . $this->targetClassName . ' is marked final and its methods'
+ . ' cannot be replaced. Classes marked final can be passed in'
+ . ' to \Mockery::mock() as instantiated objects to create a'
+ . ' partial mock, but only if the mock is not subject to type'
+ . ' hinting checks.'
+ );
+ }
+
+ $this->targetClass = $dtc;
+ } else {
+ $this->targetClass = UndefinedTargetClass::factory($this->targetClassName);
+ }
+
+ return $this->targetClass;
+ }
+
+ /**
+ * @return class-string|null
+ */
+ public function getTargetClassName()
+ {
+ return $this->targetClassName;
+ }
+
+ /**
+ * @return list
+ */
+ public function getTargetInterfaces()
+ {
+ if ($this->targetInterfaces !== []) {
+ return $this->targetInterfaces;
+ }
+
+ foreach ($this->targetInterfaceNames as $targetInterface) {
+ if (! interface_exists($targetInterface)) {
+ $this->targetInterfaces[] = UndefinedTargetClass::factory($targetInterface);
+ continue;
+ }
+
+ $dtc = DefinedTargetClass::factory($targetInterface);
+ $extendedInterfaces = array_keys($dtc->getInterfaces());
+ $extendedInterfaces[] = $targetInterface;
+
+ $traversableFound = false;
+ $iteratorShiftedToFront = false;
+ foreach ($extendedInterfaces as $interface) {
+ if (! $traversableFound && preg_match('/^\\?Iterator(|Aggregate)$/i', $interface)) {
+ break;
+ }
+
+ if (preg_match('/^\\\\?IteratorAggregate$/i', $interface)) {
+ $this->targetInterfaces[] = DefinedTargetClass::factory('\\IteratorAggregate');
+ $iteratorShiftedToFront = true;
+
+ continue;
+ }
+
+ if (preg_match('/^\\\\?Iterator$/i', $interface)) {
+ $this->targetInterfaces[] = DefinedTargetClass::factory('\\Iterator');
+ $iteratorShiftedToFront = true;
+
+ continue;
+ }
+
+ if (preg_match('/^\\\\?Traversable$/i', $interface)) {
+ $traversableFound = true;
+ }
+ }
+
+ if ($traversableFound && ! $iteratorShiftedToFront) {
+ $this->targetInterfaces[] = DefinedTargetClass::factory('\\IteratorAggregate');
+ }
+
+ /**
+ * We never straight up implement Traversable
+ */
+ $isTraversable = preg_match('/^\\\\?Traversable$/i', $targetInterface);
+ if ($isTraversable === 0 || $isTraversable === false) {
+ $this->targetInterfaces[] = $dtc;
+ }
+ }
+
+ return $this->targetInterfaces = array_unique($this->targetInterfaces);
+ }
+
+ /**
+ * @return object|null
+ */
+ public function getTargetObject()
+ {
+ return $this->targetObject;
+ }
+
+ /**
+ * @return list
+ */
+ public function getTargetTraits()
+ {
+ if ($this->targetTraits !== []) {
+ return $this->targetTraits;
+ }
+
+ foreach ($this->targetTraitNames as $targetTrait) {
+ $this->targetTraits[] = DefinedTargetClass::factory($targetTrait);
+ }
+
+ $this->targetTraits = array_unique($this->targetTraits); // just in case
+ return $this->targetTraits;
+ }
+
+ /**
+ * @return array
+ */
+ public function getWhiteListedMethods()
+ {
+ return $this->whiteListedMethods;
+ }
+
+ /**
+ * @return bool
+ */
+ public function isInstanceMock()
+ {
+ return $this->instanceMock;
+ }
+
+ /**
+ * @return bool
+ */
+ public function isMockOriginalDestructor()
+ {
+ return $this->mockOriginalDestructor;
+ }
+
+ /**
+ * @param class-string $className
+ * @return self
+ */
+ public function rename($className)
+ {
+ $targets = [];
+
+ if ($this->targetClassName) {
+ $targets[] = $this->targetClassName;
+ }
+
+ if ($this->targetInterfaceNames) {
+ $targets = array_merge($targets, $this->targetInterfaceNames);
+ }
+
+ if ($this->targetTraitNames) {
+ $targets = array_merge($targets, $this->targetTraitNames);
+ }
+
+ if ($this->targetObject) {
+ $targets[] = $this->targetObject;
+ }
+
+ return new self(
+ $targets,
+ $this->blackListedMethods,
+ $this->whiteListedMethods,
+ $className,
+ $this->instanceMock,
+ $this->parameterOverrides,
+ $this->mockOriginalDestructor,
+ $this->constantsMap
+ );
+ }
+
+ /**
+ * We declare the __callStatic method to handle undefined stuff, if the class
+ * we're mocking has also defined it, we need to comply with their interface
+ *
+ * @return bool
+ */
+ public function requiresCallStaticTypeHintRemoval()
+ {
+ foreach ($this->getAllMethods() as $method) {
+ if ($method->getName() === '__callStatic') {
+ $params = $method->getParameters();
+
+ if (! array_key_exists(1, $params)) {
+ return false;
+ }
+
+ return ! $params[1]->isArray();
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * We declare the __call method to handle undefined stuff, if the class
+ * we're mocking has also defined it, we need to comply with their interface
+ *
+ * @return bool
+ */
+ public function requiresCallTypeHintRemoval()
+ {
+ foreach ($this->getAllMethods() as $method) {
+ if ($method->getName() === '__call') {
+ $params = $method->getParameters();
+ return ! $params[1]->isArray();
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * @param class-string|object $target
+ */
+ protected function addTarget($target)
+ {
+ if (is_object($target)) {
+ $this->setTargetObject($target);
+ $this->setTargetClassName(get_class($target));
+ return;
+ }
+
+ if ($target[0] !== '\\') {
+ $target = '\\' . $target;
+ }
+
+ if (class_exists($target)) {
+ $this->setTargetClassName($target);
+ return;
+ }
+
+ if (interface_exists($target)) {
+ $this->addTargetInterfaceName($target);
+ return;
+ }
+
+ if (trait_exists($target)) {
+ $this->addTargetTraitName($target);
+ return;
+ }
+
+ /**
+ * Default is to set as class, or interface if class already set
+ *
+ * Don't like this condition, can't remember what the default
+ * targetClass is for
+ */
+ if ($this->getTargetClassName()) {
+ $this->addTargetInterfaceName($target);
+ return;
+ }
+
+ $this->setTargetClassName($target);
+ }
+
+ /**
+ * If we attempt to implement Traversable,
+ * we must ensure we are also implementing either Iterator or IteratorAggregate,
+ * and that whichever one it is comes before Traversable in the list of implements.
+ *
+ * @param class-string $targetInterface
+ */
+ protected function addTargetInterfaceName($targetInterface)
+ {
+ $this->targetInterfaceNames[] = $targetInterface;
+ }
+
+ /**
+ * @param array $interfaces
+ */
+ protected function addTargets($interfaces)
+ {
+ foreach ($interfaces as $interface) {
+ $this->addTarget($interface);
+ }
+ }
+
+ /**
+ * @param class-string $targetTraitName
+ */
+ protected function addTargetTraitName($targetTraitName)
+ {
+ $this->targetTraitNames[] = $targetTraitName;
+ }
+
+ /**
+ * @return list
+ */
+ protected function getAllMethods()
+ {
+ if ($this->allMethods) {
+ return $this->allMethods;
+ }
+
+ $classes = $this->getTargetInterfaces();
+
+ if ($this->getTargetClass()) {
+ $classes[] = $this->getTargetClass();
+ }
+
+ $methods = [];
+ foreach ($classes as $class) {
+ $methods = array_merge($methods, $class->getMethods());
+ }
+
+ foreach ($this->getTargetTraits() as $trait) {
+ foreach ($trait->getMethods() as $method) {
+ if ($method->isAbstract()) {
+ $methods[] = $method;
+ }
+ }
+ }
+
+ $names = [];
+ $methods = array_filter($methods, static function ($method) use (&$names) {
+ if (in_array($method->getName(), $names, true)) {
+ return false;
+ }
+
+ $names[] = $method->getName();
+ return true;
+ });
+
+ return $this->allMethods = $methods;
+ }
+
+ /**
+ * @param class-string $targetClassName
+ */
+ protected function setTargetClassName($targetClassName)
+ {
+ $this->targetClassName = $targetClassName;
+ }
+
+ /**
+ * @param object $object
+ */
+ protected function setTargetObject($object)
+ {
+ $this->targetObject = $object;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Generator/MockConfigurationBuilder.php b/vendor/mockery/mockery/library/Mockery/Generator/MockConfigurationBuilder.php
new file mode 100644
index 0000000..989325e
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Generator/MockConfigurationBuilder.php
@@ -0,0 +1,252 @@
+
+ */
+ protected $blackListedMethods = [
+ '__call',
+ '__callStatic',
+ '__clone',
+ '__wakeup',
+ '__set',
+ '__get',
+ '__toString',
+ '__isset',
+ '__destruct',
+ '__debugInfo', ## mocking this makes it difficult to debug with xdebug
+
+ // below are reserved words in PHP
+ '__halt_compiler', 'abstract', 'and', 'array', 'as',
+ 'break', 'callable', 'case', 'catch', 'class',
+ 'clone', 'const', 'continue', 'declare', 'default',
+ 'die', 'do', 'echo', 'else', 'elseif',
+ 'empty', 'enddeclare', 'endfor', 'endforeach', 'endif',
+ 'endswitch', 'endwhile', 'eval', 'exit', 'extends',
+ 'final', 'for', 'foreach', 'function', 'global',
+ 'goto', 'if', 'implements', 'include', 'include_once',
+ 'instanceof', 'insteadof', 'interface', 'isset', 'list',
+ 'namespace', 'new', 'or', 'print', 'private',
+ 'protected', 'public', 'require', 'require_once', 'return',
+ 'static', 'switch', 'throw', 'trait', 'try',
+ 'unset', 'use', 'var', 'while', 'xor',
+ ];
+
+ /**
+ * @var array
+ */
+ protected $constantsMap = [];
+
+ /**
+ * @var bool
+ */
+ protected $instanceMock = false;
+
+ /**
+ * @var bool
+ */
+ protected $mockOriginalDestructor = false;
+
+ /**
+ * @var string
+ */
+ protected $name;
+
+ /**
+ * @var array
+ */
+ protected $parameterOverrides = [];
+
+ /**
+ * @var list
+ */
+ protected $php7SemiReservedKeywords = [
+ 'callable', 'class', 'trait', 'extends', 'implements', 'static', 'abstract', 'final',
+ 'public', 'protected', 'private', 'const', 'enddeclare', 'endfor', 'endforeach', 'endif',
+ 'endwhile', 'and', 'global', 'goto', 'instanceof', 'insteadof', 'interface', 'namespace', 'new',
+ 'or', 'xor', 'try', 'use', 'var', 'exit', 'list', 'clone', 'include', 'include_once', 'throw',
+ 'array', 'print', 'echo', 'require', 'require_once', 'return', 'else', 'elseif', 'default',
+ 'break', 'continue', 'switch', 'yield', 'function', 'if', 'endswitch', 'finally', 'for', 'foreach',
+ 'declare', 'case', 'do', 'while', 'as', 'catch', 'die', 'self', 'parent',
+ ];
+
+ /**
+ * @var array
+ */
+ protected $targets = [];
+
+ /**
+ * @var array
+ */
+ protected $whiteListedMethods = [];
+
+ public function __construct()
+ {
+ $this->blackListedMethods = array_diff($this->blackListedMethods, $this->php7SemiReservedKeywords);
+ }
+
+ /**
+ * @param string $blackListedMethod
+ * @return self
+ */
+ public function addBlackListedMethod($blackListedMethod)
+ {
+ $this->blackListedMethods[] = $blackListedMethod;
+ return $this;
+ }
+
+ /**
+ * @param list $blackListedMethods
+ * @return self
+ */
+ public function addBlackListedMethods(array $blackListedMethods)
+ {
+ foreach ($blackListedMethods as $method) {
+ $this->addBlackListedMethod($method);
+ }
+
+ return $this;
+ }
+
+ /**
+ * @param class-string $target
+ * @return self
+ */
+ public function addTarget($target)
+ {
+ $this->targets[] = $target;
+
+ return $this;
+ }
+
+ /**
+ * @param list $targets
+ * @return self
+ */
+ public function addTargets($targets)
+ {
+ foreach ($targets as $target) {
+ $this->addTarget($target);
+ }
+
+ return $this;
+ }
+
+ /**
+ * @return self
+ */
+ public function addWhiteListedMethod($whiteListedMethod)
+ {
+ $this->whiteListedMethods[] = $whiteListedMethod;
+ return $this;
+ }
+
+ /**
+ * @return self
+ */
+ public function addWhiteListedMethods(array $whiteListedMethods)
+ {
+ foreach ($whiteListedMethods as $method) {
+ $this->addWhiteListedMethod($method);
+ }
+
+ return $this;
+ }
+
+ /**
+ * @return MockConfiguration
+ */
+ public function getMockConfiguration()
+ {
+ return new MockConfiguration(
+ $this->targets,
+ $this->blackListedMethods,
+ $this->whiteListedMethods,
+ $this->name,
+ $this->instanceMock,
+ $this->parameterOverrides,
+ $this->mockOriginalDestructor,
+ $this->constantsMap
+ );
+ }
+
+ /**
+ * @param list $blackListedMethods
+ * @return self
+ */
+ public function setBlackListedMethods(array $blackListedMethods)
+ {
+ $this->blackListedMethods = $blackListedMethods;
+ return $this;
+ }
+
+ /**
+ * @return self
+ */
+ public function setConstantsMap(array $map)
+ {
+ $this->constantsMap = $map;
+
+ return $this;
+ }
+
+ /**
+ * @param bool $instanceMock
+ */
+ public function setInstanceMock($instanceMock)
+ {
+ $this->instanceMock = (bool) $instanceMock;
+
+ return $this;
+ }
+
+ /**
+ * @param bool $mockDestructor
+ */
+ public function setMockOriginalDestructor($mockDestructor)
+ {
+ $this->mockOriginalDestructor = (bool) $mockDestructor;
+ return $this;
+ }
+
+ /**
+ * @param string $name
+ */
+ public function setName($name)
+ {
+ $this->name = $name;
+ return $this;
+ }
+
+ /**
+ * @return self
+ */
+ public function setParameterOverrides(array $overrides)
+ {
+ $this->parameterOverrides = $overrides;
+ return $this;
+ }
+
+ /**
+ * @param list $whiteListedMethods
+ * @return self
+ */
+ public function setWhiteListedMethods(array $whiteListedMethods)
+ {
+ $this->whiteListedMethods = $whiteListedMethods;
+ return $this;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Generator/MockDefinition.php b/vendor/mockery/mockery/library/Mockery/Generator/MockDefinition.php
new file mode 100644
index 0000000..337c31f
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Generator/MockDefinition.php
@@ -0,0 +1,64 @@
+getName()) {
+ throw new InvalidArgumentException('MockConfiguration must contain a name');
+ }
+
+ $this->config = $config;
+ $this->code = $code;
+ }
+
+ /**
+ * @return string
+ */
+ public function getClassName()
+ {
+ return $this->config->getName();
+ }
+
+ /**
+ * @return string
+ */
+ public function getCode()
+ {
+ return $this->code;
+ }
+
+ /**
+ * @return MockConfiguration
+ */
+ public function getConfig()
+ {
+ return $this->config;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Generator/MockNameBuilder.php b/vendor/mockery/mockery/library/Mockery/Generator/MockNameBuilder.php
new file mode 100644
index 0000000..424cdc5
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Generator/MockNameBuilder.php
@@ -0,0 +1,51 @@
+
+ */
+ protected $parts = [];
+
+ /**
+ * @param string $part
+ */
+ public function addPart($part)
+ {
+ $this->parts[] = $part;
+
+ return $this;
+ }
+
+ /**
+ * @return string
+ */
+ public function build()
+ {
+ $parts = ['Mockery', static::$mockCounter++];
+
+ foreach ($this->parts as $part) {
+ $parts[] = str_replace('\\', '_', $part);
+ }
+
+ return implode('_', $parts);
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Generator/Parameter.php b/vendor/mockery/mockery/library/Mockery/Generator/Parameter.php
new file mode 100644
index 0000000..442a713
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Generator/Parameter.php
@@ -0,0 +1,130 @@
+rfp = $rfp;
+ }
+
+ /**
+ * Proxy all method calls to the reflection parameter.
+ *
+ * @template TMixed
+ * @template TResult
+ *
+ * @param string $method
+ * @param array $args
+ *
+ * @return TResult
+ */
+ public function __call($method, array $args)
+ {
+ /** @var TResult */
+ return $this->rfp->{$method}(...$args);
+ }
+
+ /**
+ * Get the reflection class for the parameter type, if it exists.
+ *
+ * This will be null if there was no type, or it was a scalar or a union.
+ *
+ * @return null|ReflectionClass
+ *
+ * @deprecated since 1.3.3 and will be removed in 2.0.
+ */
+ public function getClass()
+ {
+ $typeHint = Reflector::getTypeHint($this->rfp, true);
+
+ return class_exists($typeHint) ? DefinedTargetClass::factory($typeHint, false) : null;
+ }
+
+ /**
+ * Get the name of the parameter.
+ *
+ * Some internal classes have funny looking definitions!
+ *
+ * @return string
+ */
+ public function getName()
+ {
+ $name = $this->rfp->getName();
+
+ if (! $name || $name === '...') {
+ return 'arg' . self::$parameterCounter++;
+ }
+
+ return $name;
+ }
+
+ /**
+ * Get the string representation for the paramater type.
+ *
+ * @return null|string
+ */
+ public function getTypeHint()
+ {
+ return Reflector::getTypeHint($this->rfp);
+ }
+
+ /**
+ * Get the string representation for the paramater type.
+ *
+ * @return string
+ *
+ * @deprecated since 1.3.2 and will be removed in 2.0. Use getTypeHint() instead.
+ */
+ public function getTypeHintAsString()
+ {
+ return (string) Reflector::getTypeHint($this->rfp, true);
+ }
+
+ /**
+ * Determine if the parameter is an array.
+ *
+ * @return bool
+ */
+ public function isArray()
+ {
+ return Reflector::isArray($this->rfp);
+ }
+
+ /**
+ * Determine if the parameter is variadic.
+ *
+ * @return bool
+ */
+ public function isVariadic()
+ {
+ return $this->rfp->isVariadic();
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/AvoidMethodClashPass.php b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/AvoidMethodClashPass.php
new file mode 100644
index 0000000..4a7e2a5
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/AvoidMethodClashPass.php
@@ -0,0 +1,42 @@
+getName();
+ }, $config->getMethodsToMock());
+
+ foreach (['allows', 'expects'] as $method) {
+ if (in_array($method, $names, true)) {
+ $code = preg_replace(sprintf('#// start method %s.*// end method %s#ms', $method, $method), '', $code);
+
+ $code = str_replace(' implements MockInterface', ' implements LegacyMockInterface', $code);
+ }
+ }
+
+ return $code;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/CallTypeHintPass.php b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/CallTypeHintPass.php
new file mode 100644
index 0000000..747fdee
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/CallTypeHintPass.php
@@ -0,0 +1,42 @@
+requiresCallTypeHintRemoval()) {
+ $code = str_replace(
+ 'public function __call($method, array $args)',
+ 'public function __call($method, $args)',
+ $code
+ );
+ }
+
+ if ($config->requiresCallStaticTypeHintRemoval()) {
+ return str_replace(
+ 'public static function __callStatic($method, array $args)',
+ 'public static function __callStatic($method, $args)',
+ $code
+ );
+ }
+
+ return $code;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/ClassAttributesPass.php b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/ClassAttributesPass.php
new file mode 100644
index 0000000..86b157e
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/ClassAttributesPass.php
@@ -0,0 +1,40 @@
+getTargetClass();
+
+ if (! $class) {
+ return $code;
+ }
+
+ /** @var array $attributes */
+ $attributes = $class->getAttributes();
+
+ if ($attributes !== []) {
+ return str_replace('#[\AllowDynamicProperties]', '#[' . implode(',', $attributes) . ']', $code);
+ }
+
+ return $code;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/ClassNamePass.php b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/ClassNamePass.php
new file mode 100644
index 0000000..0280a06
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/ClassNamePass.php
@@ -0,0 +1,35 @@
+getNamespaceName();
+
+ $namespace = ltrim($namespace, '\\');
+
+ $className = $config->getShortName();
+
+ $code = str_replace('namespace Mockery;', $namespace !== '' ? 'namespace ' . $namespace . ';' : '', $code);
+
+ return str_replace('class Mock', 'class ' . $className, $code);
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/ClassPass.php b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/ClassPass.php
new file mode 100644
index 0000000..ba4826c
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/ClassPass.php
@@ -0,0 +1,49 @@
+getTargetClass();
+
+ if (! $target) {
+ return $code;
+ }
+
+ if ($target->isFinal()) {
+ return $code;
+ }
+
+ $className = ltrim($target->getName(), '\\');
+
+ if (! class_exists($className)) {
+ Mockery::declareClass($className);
+ }
+
+ return str_replace(
+ 'implements MockInterface',
+ 'extends \\' . $className . ' implements MockInterface',
+ $code
+ );
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/ConstantsPass.php b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/ConstantsPass.php
new file mode 100644
index 0000000..1088a0d
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/ConstantsPass.php
@@ -0,0 +1,51 @@
+getConstantsMap();
+ if ($cm === []) {
+ return $code;
+ }
+
+ $name = $config->getName();
+ if (! array_key_exists($name, $cm)) {
+ return $code;
+ }
+
+ $constantsCode = '';
+ foreach ($cm[$name] as $constant => $value) {
+ $constantsCode .= sprintf("\n const %s = %s;\n", $constant, var_export($value, true));
+ }
+
+ $offset = strrpos($code, '}');
+ if ($offset === false) {
+ return $code;
+ }
+
+ return substr_replace($code, $constantsCode, $offset) . '}' . PHP_EOL;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/InstanceMockPass.php b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/InstanceMockPass.php
new file mode 100644
index 0000000..78adba4
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/InstanceMockPass.php
@@ -0,0 +1,78 @@
+_mockery_ignoreVerification = false;
+ \$associatedRealObject = \Mockery::fetchMock(__CLASS__);
+
+ foreach (get_object_vars(\$this) as \$attr => \$val) {
+ if (\$attr !== "_mockery_ignoreVerification" && \$attr !== "_mockery_expectations") {
+ \$this->\$attr = \$associatedRealObject->\$attr;
+ }
+ }
+
+ \$directors = \$associatedRealObject->mockery_getExpectations();
+ foreach (\$directors as \$method=>\$director) {
+ // get the director method needed
+ \$existingDirector = \$this->mockery_getExpectationsFor(\$method);
+ if (!\$existingDirector) {
+ \$existingDirector = new \Mockery\ExpectationDirector(\$method, \$this);
+ \$this->mockery_setExpectationsFor(\$method, \$existingDirector);
+ }
+ \$expectations = \$director->getExpectations();
+ foreach (\$expectations as \$expectation) {
+ \$clonedExpectation = clone \$expectation;
+ \$existingDirector->addExpectation(\$clonedExpectation);
+ }
+ \$defaultExpectations = \$director->getDefaultExpectations();
+ foreach (array_reverse(\$defaultExpectations) as \$expectation) {
+ \$clonedExpectation = clone \$expectation;
+ \$existingDirector->addExpectation(\$clonedExpectation);
+ \$existingDirector->makeExpectationDefault(\$clonedExpectation);
+ }
+ }
+ \Mockery::getContainer()->rememberMock(\$this);
+
+ \$this->_mockery_constructorCalled(func_get_args());
+ }
+MOCK;
+
+ /**
+ * @param string $code
+ * @return string
+ */
+ public function apply($code, MockConfiguration $config)
+ {
+ if ($config->isInstanceMock()) {
+ return $this->appendToClass($code, static::INSTANCE_MOCK_CODE);
+ }
+
+ return $code;
+ }
+
+ protected function appendToClass($class, $code)
+ {
+ $lastBrace = strrpos($class, '}');
+ return substr($class, 0, $lastBrace) . $code . "\n }\n";
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/InterfacePass.php b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/InterfacePass.php
new file mode 100644
index 0000000..4eabcb0
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/InterfacePass.php
@@ -0,0 +1,41 @@
+getTargetInterfaces() as $i) {
+ $name = ltrim($i->getName(), '\\');
+ if (! interface_exists($name)) {
+ Mockery::declareInterface($name);
+ }
+ }
+
+ $interfaces = array_reduce($config->getTargetInterfaces(), static function ($code, $i) {
+ return $code . ', \\' . ltrim($i->getName(), '\\');
+ }, '');
+
+ return str_replace('implements MockInterface', 'implements MockInterface' . $interfaces, $code);
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/MagicMethodTypeHintsPass.php b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/MagicMethodTypeHintsPass.php
new file mode 100644
index 0000000..f4191fd
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/MagicMethodTypeHintsPass.php
@@ -0,0 +1,197 @@
+getMagicMethods($config->getTargetClass());
+ foreach ($config->getTargetInterfaces() as $interface) {
+ $magicMethods = array_merge($magicMethods, $this->getMagicMethods($interface));
+ }
+
+ foreach ($magicMethods as $method) {
+ $code = $this->applyMagicTypeHints($code, $method);
+ }
+
+ return $code;
+ }
+
+ /**
+ * Returns the magic methods within the
+ * passed DefinedTargetClass.
+ *
+ * @return array
+ */
+ public function getMagicMethods(?TargetClassInterface $class = null)
+ {
+ if (! $class instanceof TargetClassInterface) {
+ return [];
+ }
+
+ return array_filter($class->getMethods(), function (Method $method) {
+ return in_array($method->getName(), $this->mockMagicMethods, true);
+ });
+ }
+
+ protected function renderTypeHint(Parameter $param)
+ {
+ $typeHint = $param->getTypeHint();
+
+ return $typeHint === null ? '' : sprintf('%s ', $typeHint);
+ }
+
+ /**
+ * Applies type hints of magic methods from
+ * class to the passed code.
+ *
+ * @param int $code
+ *
+ * @return string
+ */
+ private function applyMagicTypeHints($code, Method $method)
+ {
+ if ($this->isMethodWithinCode($code, $method)) {
+ $namedParameters = $this->getOriginalParameters($code, $method);
+ $code = preg_replace(
+ $this->getDeclarationRegex($method->getName()),
+ $this->getMethodDeclaration($method, $namedParameters),
+ $code
+ );
+ }
+
+ return $code;
+ }
+
+ /**
+ * Returns a regex string used to match the
+ * declaration of some method.
+ *
+ * @param string $methodName
+ *
+ * @return string
+ */
+ private function getDeclarationRegex($methodName)
+ {
+ return sprintf('/public\s+(?:static\s+)?function\s+%s\s*\(.*\)\s*(?=\{)/i', $methodName);
+ }
+
+ /**
+ * Gets the declaration code, as a string, for the passed method.
+ *
+ * @param array $namedParameters
+ *
+ * @return string
+ */
+ private function getMethodDeclaration(Method $method, array $namedParameters)
+ {
+ $declaration = 'public';
+ $declaration .= $method->isStatic() ? ' static' : '';
+ $declaration .= ' function ' . $method->getName() . '(';
+
+ foreach ($method->getParameters() as $index => $parameter) {
+ $declaration .= $this->renderTypeHint($parameter);
+ $name = $namedParameters[$index] ?? $parameter->getName();
+ $declaration .= '$' . $name;
+ $declaration .= ',';
+ }
+
+ $declaration = rtrim($declaration, ',');
+ $declaration .= ') ';
+
+ $returnType = $method->getReturnType();
+ if ($returnType !== null) {
+ $declaration .= sprintf(': %s', $returnType);
+ }
+
+ return $declaration;
+ }
+
+ /**
+ * Returns the method original parameters, as they're
+ * described in the $code string.
+ *
+ * @param int $code
+ *
+ * @return array
+ */
+ private function getOriginalParameters($code, Method $method)
+ {
+ $matches = [];
+ $parameterMatches = [];
+
+ preg_match($this->getDeclarationRegex($method->getName()), $code, $matches);
+
+ if ($matches !== []) {
+ preg_match_all('/(?<=\$)(\w+)+/i', $matches[0], $parameterMatches);
+ }
+
+ $groupMatches = end($parameterMatches);
+
+ return is_array($groupMatches) ? $groupMatches : [$groupMatches];
+ }
+
+ /**
+ * Checks if the method is declared within code.
+ *
+ * @param int $code
+ *
+ * @return bool
+ */
+ private function isMethodWithinCode($code, Method $method)
+ {
+ return preg_match($this->getDeclarationRegex($method->getName()), $code) === 1;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/MethodDefinitionPass.php b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/MethodDefinitionPass.php
new file mode 100644
index 0000000..68d37f9
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/MethodDefinitionPass.php
@@ -0,0 +1,199 @@
+getMethodsToMock() as $method) {
+ if ($method->isPublic()) {
+ $methodDef = 'public';
+ } elseif ($method->isProtected()) {
+ $methodDef = 'protected';
+ } else {
+ $methodDef = 'private';
+ }
+
+ if ($method->isStatic()) {
+ $methodDef .= ' static';
+ }
+
+ $methodDef .= ' function ';
+ $methodDef .= $method->returnsReference() ? ' & ' : '';
+ $methodDef .= $method->getName();
+ $methodDef .= $this->renderParams($method, $config);
+ $methodDef .= $this->renderReturnType($method);
+ $methodDef .= $this->renderMethodBody($method, $config);
+
+ $code = $this->appendToClass($code, $methodDef);
+ }
+
+ return $code;
+ }
+
+ protected function appendToClass($class, $code)
+ {
+ $lastBrace = strrpos($class, '}');
+ return substr($class, 0, $lastBrace) . $code . "\n }\n";
+ }
+
+ protected function renderParams(Method $method, $config)
+ {
+ $class = $method->getDeclaringClass();
+ if ($class->isInternal()) {
+ $overrides = $config->getParameterOverrides();
+
+ if (isset($overrides[strtolower($class->getName())][$method->getName()])) {
+ return '(' . implode(',', $overrides[strtolower($class->getName())][$method->getName()]) . ')';
+ }
+ }
+
+ $methodParams = [];
+ $params = $method->getParameters();
+ $isPhp81 = PHP_VERSION_ID >= 80100;
+ foreach ($params as $param) {
+ $paramDef = $this->renderTypeHint($param);
+ $paramDef .= $param->isPassedByReference() ? '&' : '';
+ $paramDef .= $param->isVariadic() ? '...' : '';
+ $paramDef .= '$' . $param->getName();
+
+ if (! $param->isVariadic()) {
+ if ($param->isDefaultValueAvailable() !== false) {
+ $defaultValue = $param->getDefaultValue();
+
+ if (is_object($defaultValue)) {
+ $prefix = get_class($defaultValue);
+ if ($isPhp81) {
+ if (enum_exists($prefix)) {
+ $prefix = var_export($defaultValue, true);
+ } elseif (
+ ! $param->isDefaultValueConstant() &&
+ // "Parameter #1 [ F\Q\CN $a = new \F\Q\CN(param1, param2: 2) ]
+ preg_match(
+ '#\s.*?\s=\snew\s(.*?)\s]$#',
+ $param->__toString(),
+ $matches
+ ) === 1
+ ) {
+ $prefix = 'new ' . $matches[1];
+ }
+ }
+ } else {
+ $prefix = var_export($defaultValue, true);
+ }
+
+ $paramDef .= ' = ' . $prefix;
+ } elseif ($param->isOptional()) {
+ $paramDef .= ' = null';
+ }
+ }
+
+ $methodParams[] = $paramDef;
+ }
+
+ return '(' . implode(', ', $methodParams) . ')';
+ }
+
+ protected function renderReturnType(Method $method)
+ {
+ $type = $method->getReturnType();
+
+ return $type ? sprintf(': %s', $type) : '';
+ }
+
+ protected function renderTypeHint(Parameter $param)
+ {
+ $typeHint = $param->getTypeHint();
+
+ return $typeHint === null ? '' : sprintf('%s ', $typeHint);
+ }
+
+ private function renderMethodBody($method, $config)
+ {
+ $invoke = $method->isStatic() ? 'static::_mockery_handleStaticMethodCall' : '$this->_mockery_handleMethodCall';
+ $body = <<getDeclaringClass();
+ $class_name = strtolower($class->getName());
+ $overrides = $config->getParameterOverrides();
+ if (isset($overrides[$class_name][$method->getName()])) {
+ $params = array_values($overrides[$class_name][$method->getName()]);
+ $paramCount = count($params);
+ for ($i = 0; $i < $paramCount; ++$i) {
+ $param = $params[$i];
+ if (strpos($param, '&') !== false) {
+ $body .= << {$i}) {
+ \$argv[{$i}] = {$param};
+}
+
+BODY;
+ }
+ }
+ } else {
+ $params = array_values($method->getParameters());
+ $paramCount = count($params);
+ for ($i = 0; $i < $paramCount; ++$i) {
+ $param = $params[$i];
+ if (! $param->isPassedByReference()) {
+ continue;
+ }
+
+ $body .= << {$i}) {
+ \$argv[{$i}] =& \${$param->getName()};
+}
+
+BODY;
+ }
+ }
+
+ $body .= "\$ret = {$invoke}(__FUNCTION__, \$argv);\n";
+
+ if (! in_array($method->getReturnType(), ['never', 'void'], true)) {
+ $body .= "return \$ret;\n";
+ }
+
+ return $body . "}\n";
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/Pass.php b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/Pass.php
new file mode 100644
index 0000000..9200873
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/Pass.php
@@ -0,0 +1,22 @@
+ '/public function __wakeup\(\)\s+\{.*?\}/sm',
+ '__toString' => '/public function __toString\(\)\s+(:\s+string)?\s*\{.*?\}/sm',
+ ];
+
+ /**
+ * @param string $code
+ * @return string
+ */
+ public function apply($code, MockConfiguration $config)
+ {
+ $target = $config->getTargetClass();
+
+ if (! $target instanceof TargetClassInterface) {
+ return $code;
+ }
+
+ foreach ($target->getMethods() as $method) {
+ if (! $method->isFinal()) {
+ continue;
+ }
+
+ if (! isset($this->methods[$method->getName()])) {
+ continue;
+ }
+
+ $code = preg_replace($this->methods[$method->getName()], '', $code);
+ }
+
+ return $code;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/RemoveDestructorPass.php b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/RemoveDestructorPass.php
new file mode 100644
index 0000000..7fd86e7
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/RemoveDestructorPass.php
@@ -0,0 +1,39 @@
+getTargetClass();
+
+ if (! $target) {
+ return $code;
+ }
+
+ if (! $config->isMockOriginalDestructor()) {
+ return preg_replace('/public function __destruct\(\)\s+\{.*?\}/sm', '', $code);
+ }
+
+ return $code;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/RemoveUnserializeForInternalSerializableClassesPass.php b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/RemoveUnserializeForInternalSerializableClassesPass.php
new file mode 100644
index 0000000..5bbb578
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/RemoveUnserializeForInternalSerializableClassesPass.php
@@ -0,0 +1,57 @@
+getTargetClass();
+
+ if (! $target) {
+ return $code;
+ }
+
+ if (! $target->hasInternalAncestor() || ! $target->implementsInterface('Serializable')) {
+ return $code;
+ }
+
+ return $this->appendToClass(
+ $code,
+ PHP_VERSION_ID < 80100 ? self::DUMMY_METHOD_DEFINITION_LEGACY : self::DUMMY_METHOD_DEFINITION
+ );
+ }
+
+ protected function appendToClass($class, $code)
+ {
+ $lastBrace = strrpos($class, '}');
+ return substr($class, 0, $lastBrace) . $code . "\n }\n";
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/TraitPass.php b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/TraitPass.php
new file mode 100644
index 0000000..faf2a90
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulation/Pass/TraitPass.php
@@ -0,0 +1,39 @@
+getTargetTraits();
+
+ if ($traits === []) {
+ return $code;
+ }
+
+ $useStatements = array_map(static function ($trait) {
+ return 'use \\\\' . ltrim($trait->getName(), '\\') . ';';
+ }, $traits);
+
+ return preg_replace('/^{$/m', "{\n " . implode("\n ", $useStatements) . "\n", $code);
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Generator/StringManipulationGenerator.php b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulationGenerator.php
new file mode 100644
index 0000000..5cb1421
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Generator/StringManipulationGenerator.php
@@ -0,0 +1,102 @@
+
+ */
+ protected $passes = [];
+
+ /**
+ * @var string
+ */
+ private $code;
+
+ /**
+ * @param list $passes
+ */
+ public function __construct(array $passes)
+ {
+ $this->passes = $passes;
+
+ $this->code = file_get_contents(__DIR__ . '/../Mock.php');
+ }
+
+ /**
+ * @param Pass $pass
+ * @return void
+ */
+ public function addPass(Pass $pass)
+ {
+ $this->passes[] = $pass;
+ }
+
+ /**
+ * @return MockDefinition
+ */
+ public function generate(MockConfiguration $config)
+ {
+ $className = $config->getName() ?: $config->generateName();
+
+ $namedConfig = $config->rename($className);
+
+ $code = $this->code;
+ foreach ($this->passes as $pass) {
+ $code = $pass->apply($code, $namedConfig);
+ }
+
+ return new MockDefinition($namedConfig, $code);
+ }
+
+ /**
+ * Creates a new StringManipulationGenerator with the default passes
+ *
+ * @return StringManipulationGenerator
+ */
+ public static function withDefaultPasses()
+ {
+ return new static([
+ new CallTypeHintPass(),
+ new MagicMethodTypeHintsPass(),
+ new ClassPass(),
+ new TraitPass(),
+ new ClassNamePass(),
+ new InstanceMockPass(),
+ new InterfacePass(),
+ new AvoidMethodClashPass(),
+ new MethodDefinitionPass(),
+ new RemoveUnserializeForInternalSerializableClassesPass(),
+ new RemoveBuiltinMethodsThatAreFinalPass(),
+ new RemoveDestructorPass(),
+ new ConstantsPass(),
+ new ClassAttributesPass(),
+ ]);
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Generator/TargetClassInterface.php b/vendor/mockery/mockery/library/Mockery/Generator/TargetClassInterface.php
new file mode 100644
index 0000000..730ae1b
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Generator/TargetClassInterface.php
@@ -0,0 +1,104 @@
+
+ */
+ public function getAttributes();
+
+ /**
+ * Returns the targetClass's interfaces.
+ *
+ * @return array
+ */
+ public function getInterfaces();
+
+ /**
+ * Returns the targetClass's methods.
+ *
+ * @return array
+ */
+ public function getMethods();
+
+ /**
+ * Returns the targetClass's name.
+ *
+ * @return class-string
+ */
+ public function getName();
+
+ /**
+ * Returns the targetClass's namespace name.
+ *
+ * @return string
+ */
+ public function getNamespaceName();
+
+ /**
+ * Returns the targetClass's short name.
+ *
+ * @return string
+ */
+ public function getShortName();
+
+ /**
+ * Returns whether the targetClass has
+ * an internal ancestor.
+ *
+ * @return bool
+ */
+ public function hasInternalAncestor();
+
+ /**
+ * Returns whether the targetClass is in
+ * the passed interface.
+ *
+ * @param class-string|string $interface
+ *
+ * @return bool
+ */
+ public function implementsInterface($interface);
+
+ /**
+ * Returns whether the targetClass is in namespace.
+ *
+ * @return bool
+ */
+ public function inNamespace();
+
+ /**
+ * Returns whether the targetClass is abstract.
+ *
+ * @return bool
+ */
+ public function isAbstract();
+
+ /**
+ * Returns whether the targetClass is final.
+ *
+ * @return bool
+ */
+ public function isFinal();
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Generator/UndefinedTargetClass.php b/vendor/mockery/mockery/library/Mockery/Generator/UndefinedTargetClass.php
new file mode 100644
index 0000000..ea72202
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Generator/UndefinedTargetClass.php
@@ -0,0 +1,141 @@
+name = $name;
+ }
+
+ /**
+ * @return class-string
+ */
+ public function __toString()
+ {
+ return $this->name;
+ }
+
+ /**
+ * @param class-string $name
+ * @return self
+ */
+ public static function factory($name)
+ {
+ return new self($name);
+ }
+
+ /**
+ * @return list
+ */
+ public function getAttributes()
+ {
+ return [];
+ }
+
+ /**
+ * @return list
+ */
+ public function getInterfaces()
+ {
+ return [];
+ }
+
+ /**
+ * @return list
+ */
+ public function getMethods()
+ {
+ return [];
+ }
+
+ /**
+ * @return class-string
+ */
+ public function getName()
+ {
+ return $this->name;
+ }
+
+ /**
+ * @return string
+ */
+ public function getNamespaceName()
+ {
+ $parts = explode('\\', ltrim($this->getName(), '\\'));
+ array_pop($parts);
+ return implode('\\', $parts);
+ }
+
+ /**
+ * @return string
+ */
+ public function getShortName()
+ {
+ $parts = explode('\\', $this->getName());
+ return array_pop($parts);
+ }
+
+ /**
+ * @return bool
+ */
+ public function hasInternalAncestor()
+ {
+ return false;
+ }
+
+ /**
+ * @param class-string $interface
+ * @return bool
+ */
+ public function implementsInterface($interface)
+ {
+ return false;
+ }
+
+ /**
+ * @return bool
+ */
+ public function inNamespace()
+ {
+ return $this->getNamespaceName() !== '';
+ }
+
+ /**
+ * @return bool
+ */
+ public function isAbstract()
+ {
+ return false;
+ }
+
+ /**
+ * @return bool
+ */
+ public function isFinal()
+ {
+ return false;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/HigherOrderMessage.php b/vendor/mockery/mockery/library/Mockery/HigherOrderMessage.php
new file mode 100644
index 0000000..42df34b
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/HigherOrderMessage.php
@@ -0,0 +1,52 @@
+mock = $mock;
+ $this->method = $method;
+ }
+
+ /**
+ * @param string $method
+ * @param array $args
+ *
+ * @return Expectation|ExpectationInterface|HigherOrderMessage
+ */
+ public function __call($method, $args)
+ {
+ if ($this->method === 'shouldNotHaveReceived') {
+ return $this->mock->{$this->method}($method, $args);
+ }
+
+ $expectation = $this->mock->{$this->method}($method);
+
+ return $expectation->withArgs($args);
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Instantiator.php b/vendor/mockery/mockery/library/Mockery/Instantiator.php
new file mode 100644
index 0000000..11b8e5b
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Instantiator.php
@@ -0,0 +1,147 @@
+ $className
+ *
+ * @throws InvalidArgumentException
+ * @throws UnexpectedValueException
+ *
+ * @return TClass
+ */
+ public function instantiate($className): object
+ {
+ return $this->buildFactory($className)();
+ }
+
+ /**
+ * @throws UnexpectedValueException
+ */
+ private function attemptInstantiationViaUnSerialization(
+ ReflectionClass $reflectionClass,
+ string $serializedString
+ ): void {
+ set_error_handler(static function ($code, $message, $file, $line) use ($reflectionClass, &$error): void {
+ $msg = sprintf(
+ 'Could not produce an instance of "%s" via un-serialization, since an error was triggered in file "%s" at line "%d"',
+ $reflectionClass->getName(),
+ $file,
+ $line
+ );
+
+ $error = new UnexpectedValueException($msg, 0, new Exception($message, $code));
+ });
+
+ try {
+ unserialize($serializedString);
+ } catch (Exception $exception) {
+ restore_error_handler();
+
+ throw new UnexpectedValueException(
+ sprintf(
+ 'An exception was raised while trying to instantiate an instance of "%s" via un-serialization',
+ $reflectionClass->getName()
+ ),
+ 0,
+ $exception
+ );
+ }
+
+ restore_error_handler();
+
+ if ($error instanceof UnexpectedValueException) {
+ throw $error;
+ }
+ }
+
+ /**
+ * Builds a {@see Closure} capable of instantiating the given $className without invoking its constructor.
+ */
+ private function buildFactory(string $className): Closure
+ {
+ $reflectionClass = $this->getReflectionClass($className);
+
+ if ($this->isInstantiableViaReflection($reflectionClass)) {
+ return static function () use ($reflectionClass) {
+ return $reflectionClass->newInstanceWithoutConstructor();
+ };
+ }
+
+ $serializedString = sprintf('O:%d:"%s":0:{}', strlen($className), $className);
+
+ $this->attemptInstantiationViaUnSerialization($reflectionClass, $serializedString);
+
+ return static function () use ($serializedString) {
+ return unserialize($serializedString);
+ };
+ }
+
+ /**
+ * @throws InvalidArgumentException
+ */
+ private function getReflectionClass(string $className): ReflectionClass
+ {
+ if (! class_exists($className)) {
+ throw new InvalidArgumentException(sprintf('Class:%s does not exist', $className));
+ }
+
+ $reflection = new ReflectionClass($className);
+
+ if ($reflection->isAbstract()) {
+ throw new InvalidArgumentException(sprintf('Class:%s is an abstract class', $className));
+ }
+
+ return $reflection;
+ }
+
+ /**
+ * Verifies whether the given class is to be considered internal
+ */
+ private function hasInternalAncestors(ReflectionClass $reflectionClass): bool
+ {
+ do {
+ if ($reflectionClass->isInternal()) {
+ return true;
+ }
+ } while ($reflectionClass = $reflectionClass->getParentClass());
+
+ return false;
+ }
+
+ /**
+ * Verifies if the class is instantiable via reflection
+ */
+ private function isInstantiableViaReflection(ReflectionClass $reflectionClass): bool
+ {
+ return ! ($reflectionClass->isInternal() && $reflectionClass->isFinal());
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/LegacyMockInterface.php b/vendor/mockery/mockery/library/Mockery/LegacyMockInterface.php
new file mode 100644
index 0000000..5c904e1
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/LegacyMockInterface.php
@@ -0,0 +1,258 @@
+ $args
+ *
+ * @return null|Expectation
+ */
+ public function mockery_findExpectation($method, array $args);
+
+ /**
+ * Return the container for this mock
+ *
+ * @return Container
+ */
+ public function mockery_getContainer();
+
+ /**
+ * Get current ordered number
+ *
+ * @return int
+ */
+ public function mockery_getCurrentOrder();
+
+ /**
+ * Gets the count of expectations for this mock
+ *
+ * @return int
+ */
+ public function mockery_getExpectationCount();
+
+ /**
+ * Return the expectations director for the given method
+ *
+ * @param string $method
+ *
+ * @return null|ExpectationDirector
+ */
+ public function mockery_getExpectationsFor($method);
+
+ /**
+ * Fetch array of ordered groups
+ *
+ * @return array
+ */
+ public function mockery_getGroups();
+
+ /**
+ * @return string[]
+ */
+ public function mockery_getMockableMethods();
+
+ /**
+ * @return array
+ */
+ public function mockery_getMockableProperties();
+
+ /**
+ * Return the name for this mock
+ *
+ * @return string
+ */
+ public function mockery_getName();
+
+ /**
+ * Alternative setup method to constructor
+ *
+ * @param object $partialObject
+ *
+ * @return void
+ */
+ public function mockery_init(?Container $container = null, $partialObject = null);
+
+ /**
+ * @return bool
+ */
+ public function mockery_isAnonymous();
+
+ /**
+ * Set current ordered number
+ *
+ * @param int $order
+ *
+ * @return int
+ */
+ public function mockery_setCurrentOrder($order);
+
+ /**
+ * Return the expectations director for the given method
+ *
+ * @param string $method
+ *
+ * @return null|ExpectationDirector
+ */
+ public function mockery_setExpectationsFor($method, ExpectationDirector $director);
+
+ /**
+ * Set ordering for a group
+ *
+ * @param string $group
+ * @param int $order
+ *
+ * @return void
+ */
+ public function mockery_setGroup($group, $order);
+
+ /**
+ * Tear down tasks for this mock
+ *
+ * @return void
+ */
+ public function mockery_teardown();
+
+ /**
+ * Validate the current mock's ordering
+ *
+ * @param string $method
+ * @param int $order
+ *
+ * @throws Exception
+ *
+ * @return void
+ */
+ public function mockery_validateOrder($method, $order);
+
+ /**
+ * Iterate across all expectation directors and validate each
+ *
+ * @throws Throwable
+ *
+ * @return void
+ */
+ public function mockery_verify();
+
+ /**
+ * Allows additional methods to be mocked that do not explicitly exist on mocked class
+ *
+ * @param string $method the method name to be mocked
+ * @return self
+ */
+ public function shouldAllowMockingMethod($method);
+
+ /**
+ * @return self
+ */
+ public function shouldAllowMockingProtectedMethods();
+
+ /**
+ * Set mock to defer unexpected methods to its parent if possible
+ *
+ * @deprecated since 1.4.0. Please use makePartial() instead.
+ *
+ * @return self
+ */
+ public function shouldDeferMissing();
+
+ /**
+ * @return self
+ */
+ public function shouldHaveBeenCalled();
+
+ /**
+ * @template TMixed
+ * @param string $method
+ * @param null|array|Closure $args
+ *
+ * @return self
+ */
+ public function shouldHaveReceived($method, $args = null);
+
+ /**
+ * Set mock to ignore unexpected methods and return Undefined class
+ *
+ * @template TReturnValue
+ *
+ * @param null|TReturnValue $returnValue the default return value for calls to missing functions on this mock
+ *
+ * @return self
+ */
+ public function shouldIgnoreMissing($returnValue = null);
+
+ /**
+ * @template TMixed
+ * @param null|array $args (optional)
+ *
+ * @return self
+ */
+ public function shouldNotHaveBeenCalled(?array $args = null);
+
+ /**
+ * @template TMixed
+ * @param string $method
+ * @param null|array|Closure $args
+ *
+ * @return self
+ */
+ public function shouldNotHaveReceived($method, $args = null);
+
+ /**
+ * Shortcut method for setting an expectation that a method should not be called.
+ *
+ * @param string ...$methodNames one or many methods that are expected not to be called in this mock
+ *
+ * @return Expectation|ExpectationInterface|HigherOrderMessage
+ */
+ public function shouldNotReceive(...$methodNames);
+
+ /**
+ * Set expected method calls
+ *
+ * @param string ...$methodNames one or many methods that are expected to be called in this mock
+ *
+ * @return Expectation|ExpectationInterface|HigherOrderMessage
+ */
+ public function shouldReceive(...$methodNames);
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Loader/EvalLoader.php b/vendor/mockery/mockery/library/Mockery/Loader/EvalLoader.php
new file mode 100644
index 0000000..63247e8
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Loader/EvalLoader.php
@@ -0,0 +1,32 @@
+getClassName(), false)) {
+ return;
+ }
+
+ eval('?>' . $definition->getCode());
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Loader/Loader.php b/vendor/mockery/mockery/library/Mockery/Loader/Loader.php
new file mode 100644
index 0000000..90d5689
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Loader/Loader.php
@@ -0,0 +1,23 @@
+path = realpath($path);
+ }
+
+ public function __destruct()
+ {
+ $files = array_diff(glob($this->path . DIRECTORY_SEPARATOR . 'Mockery_*.php') ?: [], [$this->lastPath]);
+
+ foreach ($files as $file) {
+ @unlink($file);
+ }
+ }
+
+ /**
+ * Load the given mock definition
+ *
+ * @return void
+ */
+ public function load(MockDefinition $definition)
+ {
+ if (class_exists($definition->getClassName(), false)) {
+ return;
+ }
+
+ $this->lastPath = sprintf('%s%s%s.php', $this->path, DIRECTORY_SEPARATOR, uniqid('Mockery_', false));
+
+ file_put_contents($this->lastPath, $definition->getCode());
+
+ if (file_exists($this->lastPath)) {
+ require $this->lastPath;
+ }
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Matcher/AndAnyOtherArgs.php b/vendor/mockery/mockery/library/Mockery/Matcher/AndAnyOtherArgs.php
new file mode 100644
index 0000000..f4a698e
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Matcher/AndAnyOtherArgs.php
@@ -0,0 +1,38 @@
+';
+ }
+
+ /**
+ * Check if the actual value matches the expected.
+ *
+ * @template TMixed
+ *
+ * @param TMixed $actual
+ *
+ * @return bool
+ */
+ public function match(&$actual)
+ {
+ return true;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Matcher/Any.php b/vendor/mockery/mockery/library/Mockery/Matcher/Any.php
new file mode 100644
index 0000000..5bb4b2f
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Matcher/Any.php
@@ -0,0 +1,38 @@
+';
+ }
+
+ /**
+ * Check if the actual value matches the expected.
+ *
+ * @template TMixed
+ *
+ * @param TMixed $actual
+ *
+ * @return bool
+ */
+ public function match(&$actual)
+ {
+ return true;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Matcher/AnyArgs.php b/vendor/mockery/mockery/library/Mockery/Matcher/AnyArgs.php
new file mode 100644
index 0000000..0e1ce8c
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Matcher/AnyArgs.php
@@ -0,0 +1,31 @@
+';
+ }
+
+ /**
+ * @template TMixed
+ *
+ * @param TMixed $actual
+ *
+ * @return bool
+ */
+ public function match(&$actual)
+ {
+ return true;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Matcher/AnyOf.php b/vendor/mockery/mockery/library/Mockery/Matcher/AnyOf.php
new file mode 100644
index 0000000..425dcae
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Matcher/AnyOf.php
@@ -0,0 +1,41 @@
+';
+ }
+
+ /**
+ * Check if the actual value does not match the expected (in this
+ * case it's specifically NOT expected).
+ *
+ * @template TMixed
+ *
+ * @param TMixed $actual
+ *
+ * @return bool
+ */
+ public function match(&$actual)
+ {
+ return in_array($actual, $this->_expected, true);
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Matcher/ArgumentListMatcher.php b/vendor/mockery/mockery/library/Mockery/Matcher/ArgumentListMatcher.php
new file mode 100644
index 0000000..56e58f6
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Matcher/ArgumentListMatcher.php
@@ -0,0 +1,15 @@
+';
+ }
+
+ /**
+ * Check if the actual value matches the expected.
+ *
+ * @template TMixed
+ *
+ * @param TMixed $actual
+ *
+ * @return bool
+ */
+ public function match(&$actual)
+ {
+ return ($this->_expected)($actual) === true;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Matcher/Contains.php b/vendor/mockery/mockery/library/Mockery/Matcher/Contains.php
new file mode 100644
index 0000000..9fdeb83
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Matcher/Contains.php
@@ -0,0 +1,61 @@
+_expected as $v) {
+ $elements[] = (string) $v;
+ }
+
+ return '';
+ }
+
+ /**
+ * Check if the actual value matches the expected.
+ *
+ * @template TMixed
+ *
+ * @param TMixed $actual
+ *
+ * @return bool
+ */
+ public function match(&$actual)
+ {
+ $values = array_values($actual);
+ foreach ($this->_expected as $exp) {
+ $match = false;
+ foreach ($values as $val) {
+ if ($exp === $val || $exp == $val) {
+ $match = true;
+ break;
+ }
+ }
+
+ if ($match === false) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Matcher/Ducktype.php b/vendor/mockery/mockery/library/Mockery/Matcher/Ducktype.php
new file mode 100644
index 0000000..3f3a9ef
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Matcher/Ducktype.php
@@ -0,0 +1,52 @@
+_expected) . ']>';
+ }
+
+ /**
+ * Check if the actual value matches the expected.
+ *
+ * @template TMixed
+ *
+ * @param TMixed $actual
+ *
+ * @return bool
+ */
+ public function match(&$actual)
+ {
+ if (! is_object($actual)) {
+ return false;
+ }
+
+ foreach ($this->_expected as $method) {
+ if (! method_exists($actual, $method)) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Matcher/HasKey.php b/vendor/mockery/mockery/library/Mockery/Matcher/HasKey.php
new file mode 100644
index 0000000..15ef915
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Matcher/HasKey.php
@@ -0,0 +1,48 @@
+', $this->_expected);
+ }
+
+ /**
+ * Check if the actual value matches the expected.
+ *
+ * @template TMixed
+ *
+ * @param TMixed $actual
+ *
+ * @return bool
+ */
+ public function match(&$actual)
+ {
+ if (! is_array($actual) && ! $actual instanceof ArrayAccess) {
+ return false;
+ }
+
+ return array_key_exists($this->_expected, (array) $actual);
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Matcher/HasValue.php b/vendor/mockery/mockery/library/Mockery/Matcher/HasValue.php
new file mode 100644
index 0000000..8d37a5f
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Matcher/HasValue.php
@@ -0,0 +1,47 @@
+_expected . ']>';
+ }
+
+ /**
+ * Check if the actual value matches the expected.
+ *
+ * @template TMixed
+ *
+ * @param TMixed $actual
+ *
+ * @return bool
+ */
+ public function match(&$actual)
+ {
+ if (! is_array($actual) && ! $actual instanceof ArrayAccess) {
+ return false;
+ }
+
+ return in_array($this->_expected, (array) $actual, true);
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Matcher/IsEqual.php b/vendor/mockery/mockery/library/Mockery/Matcher/IsEqual.php
new file mode 100644
index 0000000..72d1a02
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Matcher/IsEqual.php
@@ -0,0 +1,38 @@
+';
+ }
+
+ /**
+ * Check if the actual value matches the expected.
+ *
+ * @template TMixed
+ *
+ * @param TMixed $actual
+ *
+ * @return bool
+ */
+ public function match(&$actual)
+ {
+ return $this->_expected == $actual;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Matcher/IsSame.php b/vendor/mockery/mockery/library/Mockery/Matcher/IsSame.php
new file mode 100644
index 0000000..7671448
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Matcher/IsSame.php
@@ -0,0 +1,38 @@
+';
+ }
+
+ /**
+ * Check if the actual value matches the expected.
+ *
+ * @template TMixed
+ *
+ * @param TMixed $actual
+ *
+ * @return bool
+ */
+ public function match(&$actual)
+ {
+ return $this->_expected === $actual;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Matcher/MatcherAbstract.php b/vendor/mockery/mockery/library/Mockery/Matcher/MatcherAbstract.php
new file mode 100644
index 0000000..813950a
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Matcher/MatcherAbstract.php
@@ -0,0 +1,39 @@
+_expected = $expected;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Matcher/MatcherInterface.php b/vendor/mockery/mockery/library/Mockery/Matcher/MatcherInterface.php
new file mode 100644
index 0000000..19154ea
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Matcher/MatcherInterface.php
@@ -0,0 +1,36 @@
+';
+ }
+
+ /**
+ * Check if the actual value matches the expected.
+ * Actual passed by reference to preserve reference trail (where applicable)
+ * back to the original method parameter.
+ *
+ * @template TMixed
+ *
+ * @param TMixed $actual
+ *
+ * @return bool
+ */
+ public function match(&$actual)
+ {
+ return ($this->_expected)(...$actual) === true;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Matcher/MustBe.php b/vendor/mockery/mockery/library/Mockery/Matcher/MustBe.php
new file mode 100644
index 0000000..d365bc7
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Matcher/MustBe.php
@@ -0,0 +1,47 @@
+';
+ }
+
+ /**
+ * Check if the actual value matches the expected.
+ *
+ * @template TMixed
+ *
+ * @param TMixed $actual
+ *
+ * @return bool
+ */
+ public function match(&$actual)
+ {
+ if (! is_object($actual)) {
+ return $this->_expected === $actual;
+ }
+
+ return $this->_expected == $actual;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Matcher/NoArgs.php b/vendor/mockery/mockery/library/Mockery/Matcher/NoArgs.php
new file mode 100644
index 0000000..37438f1
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Matcher/NoArgs.php
@@ -0,0 +1,33 @@
+';
+ }
+
+ /**
+ * @template TMixed
+ *
+ * @param TMixed $actual
+ *
+ * @return bool
+ */
+ public function match(&$actual)
+ {
+ return count($actual) === 0;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Matcher/Not.php b/vendor/mockery/mockery/library/Mockery/Matcher/Not.php
new file mode 100644
index 0000000..133007e
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Matcher/Not.php
@@ -0,0 +1,39 @@
+';
+ }
+
+ /**
+ * Check if the actual value does not match the expected (in this
+ * case it's specifically NOT expected).
+ *
+ * @template TMixed
+ *
+ * @param TMixed $actual
+ *
+ * @return bool
+ */
+ public function match(&$actual)
+ {
+ return $actual !== $this->_expected;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Matcher/NotAnyOf.php b/vendor/mockery/mockery/library/Mockery/Matcher/NotAnyOf.php
new file mode 100644
index 0000000..567b24e
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Matcher/NotAnyOf.php
@@ -0,0 +1,45 @@
+';
+ }
+
+ /**
+ * Check if the actual value does not match the expected (in this
+ * case it's specifically NOT expected).
+ *
+ * @template TMixed
+ *
+ * @param TMixed $actual
+ *
+ * @return bool
+ */
+ public function match(&$actual)
+ {
+ foreach ($this->_expected as $exp) {
+ if ($actual === $exp || $actual == $exp) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Matcher/Pattern.php b/vendor/mockery/mockery/library/Mockery/Matcher/Pattern.php
new file mode 100644
index 0000000..b2e84df
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Matcher/Pattern.php
@@ -0,0 +1,40 @@
+';
+ }
+
+ /**
+ * Check if the actual value matches the expected pattern.
+ *
+ * @template TMixed
+ *
+ * @param TMixed $actual
+ *
+ * @return bool
+ */
+ public function match(&$actual)
+ {
+ return preg_match($this->_expected, (string) $actual) >= 1;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Matcher/Subset.php b/vendor/mockery/mockery/library/Mockery/Matcher/Subset.php
new file mode 100644
index 0000000..96893fb
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Matcher/Subset.php
@@ -0,0 +1,99 @@
+expected = $expected;
+ $this->strict = $strict;
+ }
+
+ /**
+ * Return a string representation of this Matcher
+ *
+ * @return string
+ */
+ public function __toString()
+ {
+ return 'formatArray($this->expected) . '>';
+ }
+
+ /**
+ * @param array $expected Expected subset of data
+ *
+ * @return Subset
+ */
+ public static function loose(array $expected)
+ {
+ return new static($expected, false);
+ }
+
+ /**
+ * Check if the actual value matches the expected.
+ *
+ * @template TMixed
+ *
+ * @param TMixed $actual
+ *
+ * @return bool
+ */
+ public function match(&$actual)
+ {
+ if (! is_array($actual)) {
+ return false;
+ }
+
+ if ($this->strict) {
+ return $actual === array_replace_recursive($actual, $this->expected);
+ }
+
+ return $actual == array_replace_recursive($actual, $this->expected);
+ }
+
+ /**
+ * @param array $expected Expected subset of data
+ *
+ * @return Subset
+ */
+ public static function strict(array $expected)
+ {
+ return new static($expected, true);
+ }
+
+ /**
+ * Recursively format an array into the string representation for this matcher
+ *
+ * @return string
+ */
+ protected function formatArray(array $array)
+ {
+ $elements = [];
+ foreach ($array as $k => $v) {
+ $elements[] = $k . '=' . (is_array($v) ? $this->formatArray($v) : (string) $v);
+ }
+
+ return '[' . implode(', ', $elements) . ']';
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Matcher/Type.php b/vendor/mockery/mockery/library/Mockery/Matcher/Type.php
new file mode 100644
index 0000000..8265b60
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Matcher/Type.php
@@ -0,0 +1,59 @@
+_expected) . '>';
+ }
+
+ /**
+ * Check if the actual value matches the expected.
+ *
+ * @template TMixed
+ *
+ * @param TMixed $actual
+ *
+ * @return bool
+ */
+ public function match(&$actual)
+ {
+ $function = $this->_expected === 'real' ? 'is_float' : 'is_' . strtolower($this->_expected);
+
+ if (function_exists($function)) {
+ return $function($actual);
+ }
+
+ if (! is_string($this->_expected)) {
+ return false;
+ }
+
+ if (class_exists($this->_expected) || interface_exists($this->_expected)) {
+ return $actual instanceof $this->_expected;
+ }
+
+ return false;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/MethodCall.php b/vendor/mockery/mockery/library/Mockery/MethodCall.php
new file mode 100644
index 0000000..f331514
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/MethodCall.php
@@ -0,0 +1,50 @@
+method = $method;
+ $this->args = $args;
+ }
+
+ /**
+ * @return array
+ */
+ public function getArgs()
+ {
+ return $this->args;
+ }
+
+ /**
+ * @return string
+ */
+ public function getMethod()
+ {
+ return $this->method;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Mock.php b/vendor/mockery/mockery/library/Mockery/Mock.php
new file mode 100644
index 0000000..068cce3
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Mock.php
@@ -0,0 +1,1020 @@
+_mockery_container = $container;
+ if (!is_null($partialObject)) {
+ $this->_mockery_partial = $partialObject;
+ }
+
+ if (!\Mockery::getConfiguration()->mockingNonExistentMethodsAllowed()) {
+ foreach ($this->mockery_getMethods() as $method) {
+ if ($method->isPublic()) {
+ $this->_mockery_mockableMethods[] = $method->getName();
+ }
+ }
+ }
+
+ $this->_mockery_instanceMock = $instanceMock;
+
+ $this->_mockery_parentClass = get_parent_class($this);
+ }
+
+ /**
+ * Set expected method calls
+ *
+ * @param string ...$methodNames one or many methods that are expected to be called in this mock
+ *
+ * @return ExpectationInterface|Expectation|HigherOrderMessage
+ */
+ public function shouldReceive(...$methodNames)
+ {
+ if ($methodNames === []) {
+ return new HigherOrderMessage($this, 'shouldReceive');
+ }
+
+ foreach ($methodNames as $method) {
+ if ('' === $method) {
+ throw new \InvalidArgumentException('Received empty method name');
+ }
+ }
+
+ $self = $this;
+ $allowMockingProtectedMethods = $this->_mockery_allowMockingProtectedMethods;
+ return \Mockery::parseShouldReturnArgs(
+ $this,
+ $methodNames,
+ static function ($method) use ($self, $allowMockingProtectedMethods) {
+ $rm = $self->mockery_getMethod($method);
+ if ($rm) {
+ if ($rm->isPrivate()) {
+ throw new \InvalidArgumentException($method . '() cannot be mocked as it is a private method');
+ }
+
+ if (!$allowMockingProtectedMethods && $rm->isProtected()) {
+ throw new \InvalidArgumentException($method . '() cannot be mocked as it is a protected method and mocking protected methods is not enabled for the currently used mock object. Use shouldAllowMockingProtectedMethods() to enable mocking of protected methods.');
+ }
+ }
+
+ $director = $self->mockery_getExpectationsFor($method);
+ if (!$director) {
+ $director = new ExpectationDirector($method, $self);
+ $self->mockery_setExpectationsFor($method, $director);
+ }
+
+ $expectation = new Expectation($self, $method);
+ $director->addExpectation($expectation);
+ return $expectation;
+ }
+ );
+ }
+
+ // start method allows
+ /**
+ * @param mixed $something String method name or map of method => return
+ * @return self|ExpectationInterface|Expectation|HigherOrderMessage
+ */
+ public function allows($something = [])
+ {
+ if (is_string($something)) {
+ return $this->shouldReceive($something);
+ }
+
+ if (empty($something)) {
+ return $this->shouldReceive();
+ }
+
+ foreach ($something as $method => $returnValue) {
+ $this->shouldReceive($method)->andReturn($returnValue);
+ }
+
+ return $this;
+ }
+
+ // end method allows
+ // start method expects
+ /**
+ /**
+ * @param mixed $something String method name (optional)
+ * @return ExpectationInterface|Expectation|ExpectsHigherOrderMessage
+ */
+ public function expects($something = null)
+ {
+ if (is_string($something)) {
+ return $this->shouldReceive($something)->once();
+ }
+
+ return new ExpectsHigherOrderMessage($this);
+ }
+
+ // end method expects
+ /**
+ * Shortcut method for setting an expectation that a method should not be called.
+ *
+ * @param string ...$methodNames one or many methods that are expected not to be called in this mock
+ * @return ExpectationInterface|Expectation|HigherOrderMessage
+ */
+ public function shouldNotReceive(...$methodNames)
+ {
+ if ($methodNames === []) {
+ return new HigherOrderMessage($this, 'shouldNotReceive');
+ }
+
+ $expectation = call_user_func_array(function (string $methodNames) {
+ return $this->shouldReceive($methodNames);
+ }, $methodNames);
+ $expectation->never();
+ return $expectation;
+ }
+
+ /**
+ * Allows additional methods to be mocked that do not explicitly exist on mocked class
+ *
+ * @param string $method name of the method to be mocked
+ * @return Mock|MockInterface|LegacyMockInterface
+ */
+ public function shouldAllowMockingMethod($method)
+ {
+ $this->_mockery_mockableMethods[] = $method;
+ return $this;
+ }
+
+ /**
+ * Set mock to ignore unexpected methods and return Undefined class
+ * @param mixed $returnValue the default return value for calls to missing functions on this mock
+ * @param bool $recursive Specify if returned mocks should also have shouldIgnoreMissing set
+ * @return static
+ */
+ public function shouldIgnoreMissing($returnValue = null, $recursive = false)
+ {
+ $this->_mockery_ignoreMissing = true;
+ $this->_mockery_ignoreMissingRecursive = $recursive;
+ $this->_mockery_defaultReturnValue = $returnValue;
+ return $this;
+ }
+
+ public function asUndefined()
+ {
+ $this->_mockery_ignoreMissing = true;
+ $this->_mockery_defaultReturnValue = new Undefined();
+ return $this;
+ }
+
+ /**
+ * @return static
+ */
+ public function shouldAllowMockingProtectedMethods()
+ {
+ if (!\Mockery::getConfiguration()->mockingNonExistentMethodsAllowed()) {
+ foreach ($this->mockery_getMethods() as $method) {
+ if ($method->isProtected()) {
+ $this->_mockery_mockableMethods[] = $method->getName();
+ }
+ }
+ }
+
+ $this->_mockery_allowMockingProtectedMethods = true;
+ return $this;
+ }
+
+
+ /**
+ * Set mock to defer unexpected methods to it's parent
+ *
+ * This is particularly useless for this class, as it doesn't have a parent,
+ * but included for completeness
+ *
+ * @deprecated 2.0.0 Please use makePartial() instead
+ *
+ * @return static
+ */
+ public function shouldDeferMissing()
+ {
+ return $this->makePartial();
+ }
+
+ /**
+ * Set mock to defer unexpected methods to it's parent
+ *
+ * It was an alias for shouldDeferMissing(), which will be removed
+ * in 2.0.0.
+ *
+ * @return static
+ */
+ public function makePartial()
+ {
+ $this->_mockery_deferMissing = true;
+ return $this;
+ }
+
+ /**
+ * In the event shouldReceive() accepting one or more methods/returns,
+ * this method will switch them from normal expectations to default
+ * expectations
+ *
+ * @return self
+ */
+ public function byDefault()
+ {
+ foreach ($this->_mockery_expectations as $director) {
+ $exps = $director->getExpectations();
+ foreach ($exps as $exp) {
+ $exp->byDefault();
+ }
+ }
+
+ return $this;
+ }
+
+ /**
+ * Capture calls to this mock
+ */
+ public function __call($method, array $args)
+ {
+ return $this->_mockery_handleMethodCall($method, $args);
+ }
+
+ public static function __callStatic($method, array $args)
+ {
+ return self::_mockery_handleStaticMethodCall($method, $args);
+ }
+
+ /**
+ * Forward calls to this magic method to the __call method
+ */
+ #[\ReturnTypeWillChange]
+ public function __toString()
+ {
+ return $this->__call('__toString', []);
+ }
+
+ /**
+ * Iterate across all expectation directors and validate each
+ *
+ * @throws Exception
+ * @return void
+ */
+ public function mockery_verify()
+ {
+ if ($this->_mockery_verified) {
+ return;
+ }
+
+ if (property_exists($this, '_mockery_ignoreVerification') && $this->_mockery_ignoreVerification !== null
+ && $this->_mockery_ignoreVerification == true) {
+ return;
+ }
+
+ $this->_mockery_verified = true;
+ foreach ($this->_mockery_expectations as $director) {
+ $director->verify();
+ }
+ }
+
+ /**
+ * Gets a list of exceptions thrown by this mock
+ *
+ * @return array
+ */
+ public function mockery_thrownExceptions()
+ {
+ return $this->_mockery_thrownExceptions;
+ }
+
+ /**
+ * Tear down tasks for this mock
+ *
+ * @return void
+ */
+ public function mockery_teardown()
+ {
+ }
+
+ /**
+ * Fetch the next available allocation order number
+ *
+ * @return int
+ */
+ public function mockery_allocateOrder()
+ {
+ ++$this->_mockery_allocatedOrder;
+ return $this->_mockery_allocatedOrder;
+ }
+
+ /**
+ * Set ordering for a group
+ *
+ * @param mixed $group
+ * @param int $order
+ */
+ public function mockery_setGroup($group, $order)
+ {
+ $this->_mockery_groups[$group] = $order;
+ }
+
+ /**
+ * Fetch array of ordered groups
+ *
+ * @return array
+ */
+ public function mockery_getGroups()
+ {
+ return $this->_mockery_groups;
+ }
+
+ /**
+ * Set current ordered number
+ *
+ * @param int $order
+ */
+ public function mockery_setCurrentOrder($order)
+ {
+ $this->_mockery_currentOrder = $order;
+ return $this->_mockery_currentOrder;
+ }
+
+ /**
+ * Get current ordered number
+ *
+ * @return int
+ */
+ public function mockery_getCurrentOrder()
+ {
+ return $this->_mockery_currentOrder;
+ }
+
+ /**
+ * Validate the current mock's ordering
+ *
+ * @param string $method
+ * @param int $order
+ * @throws \Mockery\Exception
+ * @return void
+ */
+ public function mockery_validateOrder($method, $order)
+ {
+ if ($order < $this->_mockery_currentOrder) {
+ $exception = new InvalidOrderException(
+ 'Method ' . self::class . '::' . $method . '()'
+ . ' called out of order: expected order '
+ . $order . ', was ' . $this->_mockery_currentOrder
+ );
+ $exception->setMock($this)
+ ->setMethodName($method)
+ ->setExpectedOrder($order)
+ ->setActualOrder($this->_mockery_currentOrder);
+ throw $exception;
+ }
+
+ $this->mockery_setCurrentOrder($order);
+ }
+
+ /**
+ * Gets the count of expectations for this mock
+ *
+ * @return int
+ */
+ public function mockery_getExpectationCount()
+ {
+ $count = $this->_mockery_expectations_count;
+ foreach ($this->_mockery_expectations as $director) {
+ $count += $director->getExpectationCount();
+ }
+
+ return $count;
+ }
+
+ /**
+ * Return the expectations director for the given method
+ *
+ * @var string $method
+ * @return ExpectationDirector|null
+ */
+ public function mockery_setExpectationsFor($method, ExpectationDirector $director)
+ {
+ $this->_mockery_expectations[$method] = $director;
+ }
+
+ /**
+ * Return the expectations director for the given method
+ *
+ * @var string $method
+ * @return ExpectationDirector|null
+ */
+ public function mockery_getExpectationsFor($method)
+ {
+ if (isset($this->_mockery_expectations[$method])) {
+ return $this->_mockery_expectations[$method];
+ }
+ }
+
+ /**
+ * Find an expectation matching the given method and arguments
+ *
+ * @var string $method
+ * @var array $args
+ * @return Expectation|null
+ */
+ public function mockery_findExpectation($method, array $args)
+ {
+ if (!isset($this->_mockery_expectations[$method])) {
+ return null;
+ }
+
+ $director = $this->_mockery_expectations[$method];
+
+ return $director->findExpectation($args);
+ }
+
+ /**
+ * Return the container for this mock
+ *
+ * @return Container
+ */
+ public function mockery_getContainer()
+ {
+ return $this->_mockery_container;
+ }
+
+ /**
+ * Return the name for this mock
+ *
+ * @return string
+ */
+ public function mockery_getName()
+ {
+ return self::class;
+ }
+
+ /**
+ * @return array
+ */
+ public function mockery_getMockableProperties()
+ {
+ return $this->_mockery_mockableProperties;
+ }
+
+ public function __isset($name)
+ {
+ if (false !== stripos($name, '_mockery_')) {
+ return false;
+ }
+
+ if (!$this->_mockery_parentClass) {
+ return false;
+ }
+
+ if (!method_exists($this->_mockery_parentClass, '__isset')) {
+ return false;
+ }
+
+ return call_user_func($this->_mockery_parentClass . '::__isset', $name);
+ }
+
+ public function mockery_getExpectations()
+ {
+ return $this->_mockery_expectations;
+ }
+
+ /**
+ * Calls a parent class method and returns the result. Used in a passthru
+ * expectation where a real return value is required while still taking
+ * advantage of expectation matching and call count verification.
+ *
+ * @param string $name
+ * @param array $args
+ * @return mixed
+ */
+ public function mockery_callSubjectMethod($name, array $args)
+ {
+ if (!method_exists($this, $name) && $this->_mockery_parentClass && method_exists($this->_mockery_parentClass, '__call')) {
+ return call_user_func($this->_mockery_parentClass . '::__call', $name, $args);
+ }
+
+ return call_user_func_array($this->_mockery_parentClass . '::' . $name, $args);
+ }
+
+ /**
+ * @return string[]
+ */
+ public function mockery_getMockableMethods()
+ {
+ return $this->_mockery_mockableMethods;
+ }
+
+ /**
+ * @return bool
+ */
+ public function mockery_isAnonymous()
+ {
+ $rfc = new \ReflectionClass($this);
+
+ // PHP 8 has Stringable interface
+ $interfaces = array_filter($rfc->getInterfaces(), static function ($i) {
+ return $i->getName() !== 'Stringable';
+ });
+
+ return false === $rfc->getParentClass() && 2 === count($interfaces);
+ }
+
+ public function mockery_isInstance()
+ {
+ return $this->_mockery_instanceMock;
+ }
+
+ public function __wakeup()
+ {
+ /**
+ * This does not add __wakeup method support. It's a blind method and any
+ * expected __wakeup work will NOT be performed. It merely cuts off
+ * annoying errors where a __wakeup exists but is not essential when
+ * mocking
+ */
+ }
+
+ public function __destruct()
+ {
+ /**
+ * Overrides real class destructor in case if class was created without original constructor
+ */
+ }
+
+ public function mockery_getMethod($name)
+ {
+ foreach ($this->mockery_getMethods() as $method) {
+ if ($method->getName() == $name) {
+ return $method;
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * @param string $name Method name.
+ *
+ * @return mixed Generated return value based on the declared return value of the named method.
+ */
+ public function mockery_returnValueForMethod($name)
+ {
+ $rm = $this->mockery_getMethod($name);
+
+ if ($rm === null) {
+ return null;
+ }
+
+ $returnType = Reflector::getSimplestReturnType($rm);
+
+ switch ($returnType) {
+ case null: return null;
+ case 'string': return '';
+ case 'int': return 0;
+ case 'float': return 0.0;
+ case 'bool': return false;
+ case 'true': return true;
+ case 'false': return false;
+
+ case 'array':
+ case 'iterable':
+ return [];
+
+ case 'callable':
+ case '\Closure':
+ return static function () : void {
+ };
+
+ case '\Traversable':
+ case '\Generator':
+ $generator = static function () {
+ yield;
+ };
+ return $generator();
+
+ case 'void':
+ return null;
+
+ case 'static':
+ return $this;
+
+ case 'object':
+ $mock = \Mockery::mock();
+ if ($this->_mockery_ignoreMissingRecursive) {
+ $mock->shouldIgnoreMissing($this->_mockery_defaultReturnValue, true);
+ }
+
+ return $mock;
+
+ default:
+ $mock = \Mockery::mock($returnType);
+ if ($this->_mockery_ignoreMissingRecursive) {
+ $mock->shouldIgnoreMissing($this->_mockery_defaultReturnValue, true);
+ }
+
+ return $mock;
+ }
+ }
+
+ public function shouldHaveReceived($method = null, $args = null)
+ {
+ if ($method === null) {
+ return new HigherOrderMessage($this, 'shouldHaveReceived');
+ }
+
+ $expectation = new VerificationExpectation($this, $method);
+ if (null !== $args) {
+ $expectation->withArgs($args);
+ }
+
+ $expectation->atLeast()->once();
+ $director = new VerificationDirector($this->_mockery_getReceivedMethodCalls(), $expectation);
+ ++$this->_mockery_expectations_count;
+ $director->verify();
+ return $director;
+ }
+
+ public function shouldHaveBeenCalled()
+ {
+ return $this->shouldHaveReceived('__invoke');
+ }
+
+ public function shouldNotHaveReceived($method = null, $args = null)
+ {
+ if ($method === null) {
+ return new HigherOrderMessage($this, 'shouldNotHaveReceived');
+ }
+
+ $expectation = new VerificationExpectation($this, $method);
+ if (null !== $args) {
+ $expectation->withArgs($args);
+ }
+
+ $expectation->never();
+ $director = new VerificationDirector($this->_mockery_getReceivedMethodCalls(), $expectation);
+ ++$this->_mockery_expectations_count;
+ $director->verify();
+ return null;
+ }
+
+ public function shouldNotHaveBeenCalled(?array $args = null)
+ {
+ return $this->shouldNotHaveReceived('__invoke', $args);
+ }
+
+ protected static function _mockery_handleStaticMethodCall($method, array $args)
+ {
+ $associatedRealObject = \Mockery::fetchMock(self::class);
+ try {
+ return $associatedRealObject->__call($method, $args);
+ } catch (BadMethodCallException $badMethodCallException) {
+ throw new BadMethodCallException(
+ 'Static method ' . $associatedRealObject->mockery_getName() . '::' . $method
+ . '() does not exist on this mock object',
+ 0,
+ $badMethodCallException
+ );
+ }
+ }
+
+ protected function _mockery_getReceivedMethodCalls()
+ {
+ return $this->_mockery_receivedMethodCalls ?: $this->_mockery_receivedMethodCalls = new ReceivedMethodCalls();
+ }
+
+ /**
+ * Called when an instance Mock was created and its constructor is getting called
+ *
+ * @see \Mockery\Generator\StringManipulation\Pass\InstanceMockPass
+ * @param array $args
+ */
+ protected function _mockery_constructorCalled(array $args)
+ {
+ if (!isset($this->_mockery_expectations['__construct']) /* _mockery_handleMethodCall runs the other checks */) {
+ return;
+ }
+
+ $this->_mockery_handleMethodCall('__construct', $args);
+ }
+
+ protected function _mockery_findExpectedMethodHandler($method)
+ {
+ if (isset($this->_mockery_expectations[$method])) {
+ return $this->_mockery_expectations[$method];
+ }
+
+ $lowerCasedMockeryExpectations = array_change_key_case($this->_mockery_expectations, CASE_LOWER);
+ $lowerCasedMethod = strtolower($method);
+
+ return $lowerCasedMockeryExpectations[$lowerCasedMethod] ?? null;
+ }
+
+ protected function _mockery_handleMethodCall($method, array $args)
+ {
+ $this->_mockery_getReceivedMethodCalls()->push(new MethodCall($method, $args));
+
+ $rm = $this->mockery_getMethod($method);
+ if ($rm && $rm->isProtected() && !$this->_mockery_allowMockingProtectedMethods) {
+ if ($rm->isAbstract()) {
+ return;
+ }
+
+ try {
+ $prototype = $rm->getPrototype();
+ if ($prototype->isAbstract()) {
+ return;
+ }
+ } catch (\ReflectionException $re) {
+ // noop - there is no hasPrototype method
+ }
+
+ if (null === $this->_mockery_parentClass) {
+ $this->_mockery_parentClass = get_parent_class($this);
+ }
+
+ return call_user_func_array($this->_mockery_parentClass . '::' . $method, $args);
+ }
+
+ $handler = $this->_mockery_findExpectedMethodHandler($method);
+
+ if ($handler !== null && !$this->_mockery_disableExpectationMatching) {
+ try {
+ return $handler->call($args);
+ } catch (NoMatchingExpectationException $e) {
+ if (!$this->_mockery_ignoreMissing && !$this->_mockery_deferMissing) {
+ throw $e;
+ }
+ }
+ }
+
+ if (!is_null($this->_mockery_partial) &&
+ (method_exists($this->_mockery_partial, $method) || method_exists($this->_mockery_partial, '__call'))) {
+ return $this->_mockery_partial->{$method}(...$args);
+ }
+
+ if ($this->_mockery_deferMissing && is_callable($this->_mockery_parentClass . '::' . $method)
+ && (!$this->hasMethodOverloadingInParentClass() || ($this->_mockery_parentClass && method_exists($this->_mockery_parentClass, $method)))) {
+ return call_user_func_array($this->_mockery_parentClass . '::' . $method, $args);
+ }
+
+ if ($this->_mockery_deferMissing && $this->_mockery_parentClass && method_exists($this->_mockery_parentClass, '__call')) {
+ return call_user_func($this->_mockery_parentClass . '::__call', $method, $args);
+ }
+
+ if ($method === '__toString') {
+ // __toString is special because we force its addition to the class API regardless of the
+ // original implementation. Thus, we should always return a string rather than honor
+ // _mockery_ignoreMissing and break the API with an error.
+ return sprintf('%s#%s', self::class, spl_object_hash($this));
+ }
+
+ if ($this->_mockery_ignoreMissing && (\Mockery::getConfiguration()->mockingNonExistentMethodsAllowed() || (!is_null($this->_mockery_partial) && method_exists($this->_mockery_partial, $method)) || is_callable($this->_mockery_parentClass . '::' . $method))) {
+ if ($this->_mockery_defaultReturnValue instanceof Undefined) {
+ return $this->_mockery_defaultReturnValue->{$method}(...$args);
+ }
+
+ if (null === $this->_mockery_defaultReturnValue) {
+ return $this->mockery_returnValueForMethod($method);
+ }
+
+ return $this->_mockery_defaultReturnValue;
+ }
+
+ $message = 'Method ' . self::class . '::' . $method .
+ '() does not exist on this mock object';
+
+ if (!is_null($rm)) {
+ $message = 'Received ' . self::class .
+ '::' . $method . '(), but no expectations were specified';
+ }
+
+ $bmce = new BadMethodCallException($message);
+ $this->_mockery_thrownExceptions[] = $bmce;
+ throw $bmce;
+ }
+
+ /**
+ * Uses reflection to get the list of all
+ * methods within the current mock object
+ *
+ * @return array
+ */
+ protected function mockery_getMethods()
+ {
+ if (static::$_mockery_methods && \Mockery::getConfiguration()->reflectionCacheEnabled()) {
+ return static::$_mockery_methods;
+ }
+
+ if ($this->_mockery_partial !== null) {
+ $reflected = new \ReflectionObject($this->_mockery_partial);
+ } else {
+ $reflected = new \ReflectionClass($this);
+ }
+
+ return static::$_mockery_methods = $reflected->getMethods();
+ }
+
+ private function hasMethodOverloadingInParentClass()
+ {
+ // if there's __call any name would be callable
+ return is_callable($this->_mockery_parentClass . '::aFunctionNameThatNoOneWouldEverUseInRealLife12345');
+ }
+
+ /**
+ * @return array
+ */
+ private function getNonPublicMethods()
+ {
+ return array_map(
+ static function ($method) {
+ return $method->getName();
+ },
+ array_filter($this->mockery_getMethods(), static function ($method) {
+ return !$method->isPublic();
+ })
+ );
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/MockInterface.php b/vendor/mockery/mockery/library/Mockery/MockInterface.php
new file mode 100644
index 0000000..9dc5364
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/MockInterface.php
@@ -0,0 +1,28 @@
+ return
+ *
+ * @return Expectation|ExpectationInterface|HigherOrderMessage|self
+ */
+ public function allows($something = []);
+
+ /**
+ * @param mixed $something String method name (optional)
+ *
+ * @return Expectation|ExpectationInterface|ExpectsHigherOrderMessage
+ */
+ public function expects($something = null);
+}
diff --git a/vendor/mockery/mockery/library/Mockery/QuickDefinitionsConfiguration.php b/vendor/mockery/mockery/library/Mockery/QuickDefinitionsConfiguration.php
new file mode 100644
index 0000000..aef28b7
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/QuickDefinitionsConfiguration.php
@@ -0,0 +1,47 @@
+_quickDefinitionsApplicationMode = $newValue
+ ? self::QUICK_DEFINITIONS_MODE_MOCK_AT_LEAST_ONCE
+ : self::QUICK_DEFINITIONS_MODE_DEFAULT_EXPECTATION;
+ }
+
+ return $this->_quickDefinitionsApplicationMode === self::QUICK_DEFINITIONS_MODE_MOCK_AT_LEAST_ONCE;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/ReceivedMethodCalls.php b/vendor/mockery/mockery/library/Mockery/ReceivedMethodCalls.php
new file mode 100644
index 0000000..4ec1c67
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/ReceivedMethodCalls.php
@@ -0,0 +1,38 @@
+methodCalls[] = $methodCall;
+ }
+
+ public function verify(Expectation $expectation)
+ {
+ foreach ($this->methodCalls as $methodCall) {
+ if ($methodCall->getMethod() !== $expectation->getName()) {
+ continue;
+ }
+
+ if (! $expectation->matchArgs($methodCall->getArgs())) {
+ continue;
+ }
+
+ $expectation->verifyCall($methodCall->getArgs());
+ }
+
+ $expectation->verify();
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Reflector.php b/vendor/mockery/mockery/library/Mockery/Reflector.php
new file mode 100644
index 0000000..8e4fc15
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Reflector.php
@@ -0,0 +1,316 @@
+
+ */
+ public const BUILTIN_TYPES = ['array', 'bool', 'int', 'float', 'null', 'object', 'string'];
+
+ /**
+ * List of reserved words.
+ *
+ * @var list
+ */
+ public const RESERVED_WORDS = ['bool', 'true', 'false', 'float', 'int', 'iterable', 'mixed', 'never', 'null', 'object', 'string', 'void'];
+
+ /**
+ * Iterable.
+ *
+ * @var list
+ */
+ private const ITERABLE = ['iterable'];
+
+ /**
+ * Traversable array.
+ *
+ * @var list
+ */
+ private const TRAVERSABLE_ARRAY = ['\Traversable', 'array'];
+
+ /**
+ * Compute the string representation for the return type.
+ *
+ * @param bool $withoutNullable
+ *
+ * @return null|string
+ */
+ public static function getReturnType(ReflectionMethod $method, $withoutNullable = false)
+ {
+ $type = $method->getReturnType();
+
+ if (! $type instanceof ReflectionType && method_exists($method, 'getTentativeReturnType')) {
+ $type = $method->getTentativeReturnType();
+ }
+
+ if (! $type instanceof ReflectionType) {
+ return null;
+ }
+
+ $typeHint = self::getTypeFromReflectionType($type, $method->getDeclaringClass());
+
+ return (! $withoutNullable && $type->allowsNull()) ? self::formatNullableType($typeHint) : $typeHint;
+ }
+
+ /**
+ * Compute the string representation for the simplest return type.
+ *
+ * @return null|string
+ */
+ public static function getSimplestReturnType(ReflectionMethod $method)
+ {
+ $type = $method->getReturnType();
+
+ if (! $type instanceof ReflectionType && method_exists($method, 'getTentativeReturnType')) {
+ $type = $method->getTentativeReturnType();
+ }
+
+ if (! $type instanceof ReflectionType || $type->allowsNull()) {
+ return null;
+ }
+
+ $typeInformation = self::getTypeInformation($type, $method->getDeclaringClass());
+
+ // return the first primitive type hint
+ foreach ($typeInformation as $info) {
+ if ($info['isPrimitive']) {
+ return $info['typeHint'];
+ }
+ }
+
+ // if no primitive type, return the first type
+ foreach ($typeInformation as $info) {
+ return $info['typeHint'];
+ }
+
+ return null;
+ }
+
+ /**
+ * Compute the string representation for the paramater type.
+ *
+ * @param bool $withoutNullable
+ *
+ * @return null|string
+ */
+ public static function getTypeHint(ReflectionParameter $param, $withoutNullable = false)
+ {
+ if (! $param->hasType()) {
+ return null;
+ }
+
+ $type = $param->getType();
+ $declaringClass = $param->getDeclaringClass();
+ $typeHint = self::getTypeFromReflectionType($type, $declaringClass);
+
+ return (! $withoutNullable && $type->allowsNull()) ? self::formatNullableType($typeHint) : $typeHint;
+ }
+
+ /**
+ * Determine if the parameter is typed as an array.
+ *
+ * @return bool
+ */
+ public static function isArray(ReflectionParameter $param)
+ {
+ $type = $param->getType();
+
+ return $type instanceof ReflectionNamedType && $type->getName();
+ }
+
+ /**
+ * Determine if the given type is a reserved word.
+ */
+ public static function isReservedWord(string $type): bool
+ {
+ return in_array(strtolower($type), self::RESERVED_WORDS, true);
+ }
+
+ /**
+ * Format the given type as a nullable type.
+ */
+ private static function formatNullableType(string $typeHint): string
+ {
+ if ($typeHint === 'mixed') {
+ return $typeHint;
+ }
+
+ if (strpos($typeHint, 'null') !== false) {
+ return $typeHint;
+ }
+
+ if (PHP_VERSION_ID < 80000) {
+ return sprintf('?%s', $typeHint);
+ }
+
+ return sprintf('%s|null', $typeHint);
+ }
+
+ private static function getTypeFromReflectionType(ReflectionType $type, ReflectionClass $declaringClass): string
+ {
+ if ($type instanceof ReflectionNamedType) {
+ $typeHint = $type->getName();
+
+ if ($type->isBuiltin()) {
+ return $typeHint;
+ }
+
+ if ($typeHint === 'static') {
+ return $typeHint;
+ }
+
+ // 'self' needs to be resolved to the name of the declaring class
+ if ($typeHint === 'self') {
+ $typeHint = $declaringClass->getName();
+ }
+
+ // 'parent' needs to be resolved to the name of the parent class
+ if ($typeHint === 'parent') {
+ $typeHint = $declaringClass->getParentClass()->getName();
+ }
+
+ // class names need prefixing with a slash
+ return sprintf('\\%s', $typeHint);
+ }
+
+ if ($type instanceof ReflectionIntersectionType) {
+ $types = array_map(
+ static function (ReflectionType $type) use ($declaringClass): string {
+ return self::getTypeFromReflectionType($type, $declaringClass);
+ },
+ $type->getTypes()
+ );
+
+ return implode('&', $types);
+ }
+
+ if ($type instanceof ReflectionUnionType) {
+ $types = array_map(
+ static function (ReflectionType $type) use ($declaringClass): string {
+ return self::getTypeFromReflectionType($type, $declaringClass);
+ },
+ $type->getTypes()
+ );
+
+ $intersect = array_intersect(self::TRAVERSABLE_ARRAY, $types);
+ if ($intersect === self::TRAVERSABLE_ARRAY) {
+ $types = array_merge(self::ITERABLE, array_diff($types, self::TRAVERSABLE_ARRAY));
+ }
+
+ return implode(
+ '|',
+ array_map(
+ static function (string $type): string {
+ return strpos($type, '&') === false ? $type : sprintf('(%s)', $type);
+ },
+ $types
+ )
+ );
+ }
+
+ throw new InvalidArgumentException('Unknown ReflectionType: ' . get_debug_type($type));
+ }
+
+ /**
+ * Get the string representation of the given type.
+ *
+ * @return list
+ */
+ private static function getTypeInformation(ReflectionType $type, ReflectionClass $declaringClass): array
+ {
+ // PHP 8 union types and PHP 8.1 intersection types can be recursively processed
+ if ($type instanceof ReflectionUnionType || $type instanceof ReflectionIntersectionType) {
+ $types = [];
+
+ foreach ($type->getTypes() as $innterType) {
+ foreach (self::getTypeInformation($innterType, $declaringClass) as $info) {
+ if ($info['typeHint'] === 'null' && $info['isPrimitive']) {
+ continue;
+ }
+
+ $types[] = $info;
+ }
+ }
+
+ return $types;
+ }
+
+ // $type must be an instance of \ReflectionNamedType
+ $typeHint = $type->getName();
+
+ // builtins can be returned as is
+ if ($type->isBuiltin()) {
+ return [
+ [
+ 'typeHint' => $typeHint,
+ 'isPrimitive' => in_array($typeHint, self::BUILTIN_TYPES, true),
+ ],
+ ];
+ }
+
+ // 'static' can be returned as is
+ if ($typeHint === 'static') {
+ return [
+ [
+ 'typeHint' => $typeHint,
+ 'isPrimitive' => false,
+ ],
+ ];
+ }
+
+ // 'self' needs to be resolved to the name of the declaring class
+ if ($typeHint === 'self') {
+ $typeHint = $declaringClass->getName();
+ }
+
+ // 'parent' needs to be resolved to the name of the parent class
+ if ($typeHint === 'parent') {
+ $typeHint = $declaringClass->getParentClass()->getName();
+ }
+
+ // class names need prefixing with a slash
+ return [
+ [
+ 'typeHint' => sprintf('\\%s', $typeHint),
+ 'isPrimitive' => false,
+ ],
+ ];
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/Undefined.php b/vendor/mockery/mockery/library/Mockery/Undefined.php
new file mode 100644
index 0000000..ca3ace4
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/Undefined.php
@@ -0,0 +1,39 @@
+receivedMethodCalls = $receivedMethodCalls;
+ $this->expectation = $expectation;
+ }
+
+ /**
+ * @return self
+ */
+ public function atLeast()
+ {
+ return $this->cloneWithoutCountValidatorsApplyAndVerify('atLeast', []);
+ }
+
+ /**
+ * @return self
+ */
+ public function atMost()
+ {
+ return $this->cloneWithoutCountValidatorsApplyAndVerify('atMost', []);
+ }
+
+ /**
+ * @param int $minimum
+ * @param int $maximum
+ *
+ * @return self
+ */
+ public function between($minimum, $maximum)
+ {
+ return $this->cloneWithoutCountValidatorsApplyAndVerify('between', [$minimum, $maximum]);
+ }
+
+ /**
+ * @return self
+ */
+ public function once()
+ {
+ return $this->cloneWithoutCountValidatorsApplyAndVerify('once', []);
+ }
+
+ /**
+ * @param int $limit
+ *
+ * @return self
+ */
+ public function times($limit = null)
+ {
+ return $this->cloneWithoutCountValidatorsApplyAndVerify('times', [$limit]);
+ }
+
+ /**
+ * @return self
+ */
+ public function twice()
+ {
+ return $this->cloneWithoutCountValidatorsApplyAndVerify('twice', []);
+ }
+
+ public function verify()
+ {
+ $this->receivedMethodCalls->verify($this->expectation);
+ }
+
+ /**
+ * @template TArgs
+ *
+ * @param TArgs $args
+ *
+ * @return self
+ */
+ public function with(...$args)
+ {
+ return $this->cloneApplyAndVerify('with', $args);
+ }
+
+ /**
+ * @return self
+ */
+ public function withAnyArgs()
+ {
+ return $this->cloneApplyAndVerify('withAnyArgs', []);
+ }
+
+ /**
+ * @template TArgs
+ *
+ * @param TArgs $args
+ *
+ * @return self
+ */
+ public function withArgs($args)
+ {
+ return $this->cloneApplyAndVerify('withArgs', [$args]);
+ }
+
+ /**
+ * @return self
+ */
+ public function withNoArgs()
+ {
+ return $this->cloneApplyAndVerify('withNoArgs', []);
+ }
+
+ /**
+ * @param string $method
+ * @param array $args
+ *
+ * @return self
+ */
+ protected function cloneApplyAndVerify($method, $args)
+ {
+ $verificationExpectation = clone $this->expectation;
+
+ $verificationExpectation->{$method}(...$args);
+
+ $verificationDirector = new self($this->receivedMethodCalls, $verificationExpectation);
+
+ $verificationDirector->verify();
+
+ return $verificationDirector;
+ }
+
+ /**
+ * @param string $method
+ * @param array $args
+ *
+ * @return self
+ */
+ protected function cloneWithoutCountValidatorsApplyAndVerify($method, $args)
+ {
+ $verificationExpectation = clone $this->expectation;
+
+ $verificationExpectation->clearCountValidators();
+
+ $verificationExpectation->{$method}(...$args);
+
+ $verificationDirector = new self($this->receivedMethodCalls, $verificationExpectation);
+
+ $verificationDirector->verify();
+
+ return $verificationDirector;
+ }
+}
diff --git a/vendor/mockery/mockery/library/Mockery/VerificationExpectation.php b/vendor/mockery/mockery/library/Mockery/VerificationExpectation.php
new file mode 100644
index 0000000..9e36f6c
--- /dev/null
+++ b/vendor/mockery/mockery/library/Mockery/VerificationExpectation.php
@@ -0,0 +1,29 @@
+_actualCount = 0;
+ }
+
+ /**
+ * @return void
+ */
+ public function clearCountValidators()
+ {
+ $this->_countValidators = [];
+ }
+}
diff --git a/vendor/mockery/mockery/library/helpers.php b/vendor/mockery/mockery/library/helpers.php
new file mode 100644
index 0000000..8f15857
--- /dev/null
+++ b/vendor/mockery/mockery/library/helpers.php
@@ -0,0 +1,77 @@
+|TMock|Closure(LegacyMockInterface&MockInterface&TMock):LegacyMockInterface&MockInterface&TMock|array> $args
+ *
+ * @return LegacyMockInterface&MockInterface&TMock
+ */
+ function mock(...$args)
+ {
+ return Mockery::mock(...$args);
+ }
+}
+
+if (! \function_exists('spy')) {
+ /**
+ * @template TSpy of object
+ *
+ * @param array|TSpy|Closure(LegacyMockInterface&MockInterface&TSpy):LegacyMockInterface&MockInterface&TSpy|array> $args
+ *
+ * @return LegacyMockInterface&MockInterface&TSpy
+ */
+ function spy(...$args)
+ {
+ return Mockery::spy(...$args);
+ }
+}
+
+if (! \function_exists('namedMock')) {
+ /**
+ * @template TNamedMock of object
+ *
+ * @param array|TNamedMock|array> $args
+ *
+ * @return LegacyMockInterface&MockInterface&TNamedMock
+ */
+ function namedMock(...$args)
+ {
+ return Mockery::namedMock(...$args);
+ }
+}
+
+if (! \function_exists('anyArgs')) {
+ function anyArgs(): AnyArgs
+ {
+ return new AnyArgs();
+ }
+}
+
+if (! \function_exists('andAnyOtherArgs')) {
+ function andAnyOtherArgs(): AndAnyOtherArgs
+ {
+ return new AndAnyOtherArgs();
+ }
+}
+
+if (! \function_exists('andAnyOthers')) {
+ function andAnyOthers(): AndAnyOtherArgs
+ {
+ return new AndAnyOtherArgs();
+ }
+}
diff --git a/vendor/myclabs/deep-copy/LICENSE b/vendor/myclabs/deep-copy/LICENSE
new file mode 100644
index 0000000..c3e8350
--- /dev/null
+++ b/vendor/myclabs/deep-copy/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 My C-Sense
+
+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.
diff --git a/vendor/myclabs/deep-copy/README.md b/vendor/myclabs/deep-copy/README.md
new file mode 100644
index 0000000..88ae14c
--- /dev/null
+++ b/vendor/myclabs/deep-copy/README.md
@@ -0,0 +1,406 @@
+# DeepCopy
+
+DeepCopy helps you create deep copies (clones) of your objects. It is designed to handle cycles in the association graph.
+
+[](https://packagist.org/packages/myclabs/deep-copy)
+[](https://github.com/myclabs/DeepCopy/actions/workflows/ci.yaml)
+
+## Table of Contents
+
+1. [How](#how)
+1. [Why](#why)
+ 1. [Using simply `clone`](#using-simply-clone)
+ 1. [Overriding `__clone()`](#overriding-__clone)
+ 1. [With `DeepCopy`](#with-deepcopy)
+1. [How it works](#how-it-works)
+1. [Going further](#going-further)
+ 1. [Matchers](#matchers)
+ 1. [Property name](#property-name)
+ 1. [Specific property](#specific-property)
+ 1. [Type](#type)
+ 1. [Filters](#filters)
+ 1. [`SetNullFilter`](#setnullfilter-filter)
+ 1. [`KeepFilter`](#keepfilter-filter)
+ 1. [`DoctrineCollectionFilter`](#doctrinecollectionfilter-filter)
+ 1. [`DoctrineEmptyCollectionFilter`](#doctrineemptycollectionfilter-filter)
+ 1. [`DoctrineProxyFilter`](#doctrineproxyfilter-filter)
+ 1. [`ReplaceFilter`](#replacefilter-type-filter)
+ 1. [`ShallowCopyFilter`](#shallowcopyfilter-type-filter)
+1. [Edge cases](#edge-cases)
+1. [Contributing](#contributing)
+ 1. [Tests](#tests)
+
+
+## How?
+
+Install with Composer:
+
+```
+composer require myclabs/deep-copy
+```
+
+Use it:
+
+```php
+use DeepCopy\DeepCopy;
+
+$copier = new DeepCopy();
+$myCopy = $copier->copy($myObject);
+```
+
+
+## Why?
+
+- How do you create copies of your objects?
+
+```php
+$myCopy = clone $myObject;
+```
+
+- How do you create **deep** copies of your objects (i.e. copying also all the objects referenced in the properties)?
+
+You use [`__clone()`](http://www.php.net/manual/en/language.oop5.cloning.php#object.clone) and implement the behavior
+yourself.
+
+- But how do you handle **cycles** in the association graph?
+
+Now you're in for a big mess :(
+
+
+
+
+### Using simply `clone`
+
+
+
+
+### Overriding `__clone()`
+
+
+
+
+### With `DeepCopy`
+
+
+
+
+## How it works
+
+DeepCopy recursively traverses all the object's properties and clones them. To avoid cloning the same object twice it
+keeps a hash map of all instances and thus preserves the object graph.
+
+To use it:
+
+```php
+use function DeepCopy\deep_copy;
+
+$copy = deep_copy($var);
+```
+
+Alternatively, you can create your own `DeepCopy` instance to configure it differently for example:
+
+```php
+use DeepCopy\DeepCopy;
+
+$copier = new DeepCopy(true);
+
+$copy = $copier->copy($var);
+```
+
+You may want to roll your own deep copy function:
+
+```php
+namespace Acme;
+
+use DeepCopy\DeepCopy;
+
+function deep_copy($var)
+{
+ static $copier = null;
+
+ if (null === $copier) {
+ $copier = new DeepCopy(true);
+ }
+
+ return $copier->copy($var);
+}
+```
+
+
+## Going further
+
+You can add filters to customize the copy process.
+
+The method to add a filter is `DeepCopy\DeepCopy::addFilter($filter, $matcher)`,
+with `$filter` implementing `DeepCopy\Filter\Filter`
+and `$matcher` implementing `DeepCopy\Matcher\Matcher`.
+
+We provide some generic filters and matchers.
+
+
+### Matchers
+
+ - `DeepCopy\Matcher` applies on a object attribute.
+ - `DeepCopy\TypeMatcher` applies on any element found in graph, including array elements.
+
+
+#### Property name
+
+The `PropertyNameMatcher` will match a property by its name:
+
+```php
+use DeepCopy\Matcher\PropertyNameMatcher;
+
+// Will apply a filter to any property of any objects named "id"
+$matcher = new PropertyNameMatcher('id');
+```
+
+
+#### Specific property
+
+The `PropertyMatcher` will match a specific property of a specific class:
+
+```php
+use DeepCopy\Matcher\PropertyMatcher;
+
+// Will apply a filter to the property "id" of any objects of the class "MyClass"
+$matcher = new PropertyMatcher('MyClass', 'id');
+```
+
+
+#### Type
+
+The `TypeMatcher` will match any element by its type (instance of a class or any value that could be parameter of
+[gettype()](http://php.net/manual/en/function.gettype.php) function):
+
+```php
+use DeepCopy\TypeMatcher\TypeMatcher;
+
+// Will apply a filter to any object that is an instance of Doctrine\Common\Collections\Collection
+$matcher = new TypeMatcher('Doctrine\Common\Collections\Collection');
+```
+
+
+### Filters
+
+- `DeepCopy\Filter` applies a transformation to the object attribute matched by `DeepCopy\Matcher`
+- `DeepCopy\TypeFilter` applies a transformation to any element matched by `DeepCopy\TypeMatcher`
+
+By design, matching a filter will stop the chain of filters (i.e. the next ones will not be applied).
+Using the ([`ChainableFilter`](#chainablefilter-filter)) won't stop the chain of filters.
+
+
+#### `SetNullFilter` (filter)
+
+Let's say for example that you are copying a database record (or a Doctrine entity), so you want the copy not to have
+any ID:
+
+```php
+use DeepCopy\DeepCopy;
+use DeepCopy\Filter\SetNullFilter;
+use DeepCopy\Matcher\PropertyNameMatcher;
+
+$object = MyClass::load(123);
+echo $object->id; // 123
+
+$copier = new DeepCopy();
+$copier->addFilter(new SetNullFilter(), new PropertyNameMatcher('id'));
+
+$copy = $copier->copy($object);
+
+echo $copy->id; // null
+```
+
+
+#### `KeepFilter` (filter)
+
+If you want a property to remain untouched (for example, an association to an object):
+
+```php
+use DeepCopy\DeepCopy;
+use DeepCopy\Filter\KeepFilter;
+use DeepCopy\Matcher\PropertyMatcher;
+
+$copier = new DeepCopy();
+$copier->addFilter(new KeepFilter(), new PropertyMatcher('MyClass', 'category'));
+
+$copy = $copier->copy($object);
+// $copy->category has not been touched
+```
+
+
+#### `ChainableFilter` (filter)
+
+If you use cloning on proxy classes, you might want to apply two filters for:
+1. loading the data
+2. applying a transformation
+
+You can use the `ChainableFilter` as a decorator of the proxy loader filter, which won't stop the chain of filters (i.e.
+the next ones may be applied).
+
+
+```php
+use DeepCopy\DeepCopy;
+use DeepCopy\Filter\ChainableFilter;
+use DeepCopy\Filter\Doctrine\DoctrineProxyFilter;
+use DeepCopy\Filter\SetNullFilter;
+use DeepCopy\Matcher\Doctrine\DoctrineProxyMatcher;
+use DeepCopy\Matcher\PropertyNameMatcher;
+
+$copier = new DeepCopy();
+$copier->addFilter(new ChainableFilter(new DoctrineProxyFilter()), new DoctrineProxyMatcher());
+$copier->addFilter(new SetNullFilter(), new PropertyNameMatcher('id'));
+
+$copy = $copier->copy($object);
+
+echo $copy->id; // null
+```
+
+
+#### `DoctrineCollectionFilter` (filter)
+
+If you use Doctrine and want to copy an entity, you will need to use the `DoctrineCollectionFilter`:
+
+```php
+use DeepCopy\DeepCopy;
+use DeepCopy\Filter\Doctrine\DoctrineCollectionFilter;
+use DeepCopy\Matcher\PropertyTypeMatcher;
+
+$copier = new DeepCopy();
+$copier->addFilter(new DoctrineCollectionFilter(), new PropertyTypeMatcher('Doctrine\Common\Collections\Collection'));
+
+$copy = $copier->copy($object);
+```
+
+
+#### `DoctrineEmptyCollectionFilter` (filter)
+
+If you use Doctrine and want to copy an entity who contains a `Collection` that you want to be reset, you can use the
+`DoctrineEmptyCollectionFilter`
+
+```php
+use DeepCopy\DeepCopy;
+use DeepCopy\Filter\Doctrine\DoctrineEmptyCollectionFilter;
+use DeepCopy\Matcher\PropertyMatcher;
+
+$copier = new DeepCopy();
+$copier->addFilter(new DoctrineEmptyCollectionFilter(), new PropertyMatcher('MyClass', 'myProperty'));
+
+$copy = $copier->copy($object);
+
+// $copy->myProperty will return an empty collection
+```
+
+
+#### `DoctrineProxyFilter` (filter)
+
+If you use Doctrine and use cloning on lazy loaded entities, you might encounter errors mentioning missing fields on a
+Doctrine proxy class (...\\\_\_CG\_\_\Proxy).
+You can use the `DoctrineProxyFilter` to load the actual entity behind the Doctrine proxy class.
+**Make sure, though, to put this as one of your very first filters in the filter chain so that the entity is loaded
+before other filters are applied!**
+We recommend to decorate the `DoctrineProxyFilter` with the `ChainableFilter` to allow applying other filters to the
+cloned lazy loaded entities.
+
+```php
+use DeepCopy\DeepCopy;
+use DeepCopy\Filter\Doctrine\DoctrineProxyFilter;
+use DeepCopy\Matcher\Doctrine\DoctrineProxyMatcher;
+
+$copier = new DeepCopy();
+$copier->addFilter(new ChainableFilter(new DoctrineProxyFilter()), new DoctrineProxyMatcher());
+
+$copy = $copier->copy($object);
+
+// $copy should now contain a clone of all entities, including those that were not yet fully loaded.
+```
+
+
+#### `ReplaceFilter` (type filter)
+
+1. If you want to replace the value of a property:
+
+```php
+use DeepCopy\DeepCopy;
+use DeepCopy\Filter\ReplaceFilter;
+use DeepCopy\Matcher\PropertyMatcher;
+
+$copier = new DeepCopy();
+$callback = function ($currentValue) {
+ return $currentValue . ' (copy)'
+};
+$copier->addFilter(new ReplaceFilter($callback), new PropertyMatcher('MyClass', 'title'));
+
+$copy = $copier->copy($object);
+
+// $copy->title will contain the data returned by the callback, e.g. 'The title (copy)'
+```
+
+2. If you want to replace whole element:
+
+```php
+use DeepCopy\DeepCopy;
+use DeepCopy\TypeFilter\ReplaceFilter;
+use DeepCopy\TypeMatcher\TypeMatcher;
+
+$copier = new DeepCopy();
+$callback = function (MyClass $myClass) {
+ return get_class($myClass);
+};
+$copier->addTypeFilter(new ReplaceFilter($callback), new TypeMatcher('MyClass'));
+
+$copy = $copier->copy([new MyClass, 'some string', new MyClass]);
+
+// $copy will contain ['MyClass', 'some string', 'MyClass']
+```
+
+
+The `$callback` parameter of the `ReplaceFilter` constructor accepts any PHP callable.
+
+
+#### `ShallowCopyFilter` (type filter)
+
+Stop *DeepCopy* from recursively copying element, using standard `clone` instead:
+
+```php
+use DeepCopy\DeepCopy;
+use DeepCopy\TypeFilter\ShallowCopyFilter;
+use DeepCopy\TypeMatcher\TypeMatcher;
+use Mockery as m;
+
+$this->deepCopy = new DeepCopy();
+$this->deepCopy->addTypeFilter(
+ new ShallowCopyFilter,
+ new TypeMatcher(m\MockInterface::class)
+);
+
+$myServiceWithMocks = new MyService(m::mock(MyDependency1::class), m::mock(MyDependency2::class));
+// All mocks will be just cloned, not deep copied
+```
+
+
+## Edge cases
+
+The following structures cannot be deep-copied with PHP Reflection. As a result they are shallow cloned and filters are
+not applied. There is two ways for you to handle them:
+
+- Implement your own `__clone()` method
+- Use a filter with a type matcher
+
+
+## Contributing
+
+DeepCopy is distributed under the MIT license.
+
+
+### Tests
+
+Running the tests is simple:
+
+```php
+vendor/bin/phpunit
+```
+
+### Support
+
+Get professional support via [the Tidelift Subscription](https://tidelift.com/subscription/pkg/packagist-myclabs-deep-copy?utm_source=packagist-myclabs-deep-copy&utm_medium=referral&utm_campaign=readme).
diff --git a/vendor/myclabs/deep-copy/composer.json b/vendor/myclabs/deep-copy/composer.json
new file mode 100644
index 0000000..f115fff
--- /dev/null
+++ b/vendor/myclabs/deep-copy/composer.json
@@ -0,0 +1,43 @@
+{
+ "name": "myclabs/deep-copy",
+ "description": "Create deep copies (clones) of your objects",
+ "license": "MIT",
+ "type": "library",
+ "keywords": [
+ "clone",
+ "copy",
+ "duplicate",
+ "object",
+ "object graph"
+ ],
+ "require": {
+ "php": "^7.1 || ^8.0"
+ },
+ "require-dev": {
+ "doctrine/collections": "^1.6.8",
+ "doctrine/common": "^2.13.3 || ^3.2.2",
+ "phpspec/prophecy": "^1.10",
+ "phpunit/phpunit": "^7.5.20 || ^8.5.23 || ^9.5.13"
+ },
+ "conflict": {
+ "doctrine/collections": "<1.6.8",
+ "doctrine/common": "<2.13.3 || >=3 <3.2.2"
+ },
+ "autoload": {
+ "psr-4": {
+ "DeepCopy\\": "src/DeepCopy/"
+ },
+ "files": [
+ "src/DeepCopy/deep_copy.php"
+ ]
+ },
+ "autoload-dev": {
+ "psr-4": {
+ "DeepCopyTest\\": "tests/DeepCopyTest/",
+ "DeepCopy\\": "fixtures/"
+ }
+ },
+ "config": {
+ "sort-packages": true
+ }
+}
diff --git a/vendor/myclabs/deep-copy/src/DeepCopy/DeepCopy.php b/vendor/myclabs/deep-copy/src/DeepCopy/DeepCopy.php
new file mode 100644
index 0000000..a944697
--- /dev/null
+++ b/vendor/myclabs/deep-copy/src/DeepCopy/DeepCopy.php
@@ -0,0 +1,328 @@
+ Filter, 'matcher' => Matcher] pairs.
+ */
+ private $filters = [];
+
+ /**
+ * Type Filters to apply.
+ *
+ * @var array Array of ['filter' => Filter, 'matcher' => Matcher] pairs.
+ */
+ private $typeFilters = [];
+
+ /**
+ * @var bool
+ */
+ private $skipUncloneable = false;
+
+ /**
+ * @var bool
+ */
+ private $useCloneMethod;
+
+ /**
+ * @param bool $useCloneMethod If set to true, when an object implements the __clone() function, it will be used
+ * instead of the regular deep cloning.
+ */
+ public function __construct($useCloneMethod = false)
+ {
+ $this->useCloneMethod = $useCloneMethod;
+
+ $this->addTypeFilter(new ArrayObjectFilter($this), new TypeMatcher(ArrayObject::class));
+ $this->addTypeFilter(new DateIntervalFilter(), new TypeMatcher(DateInterval::class));
+ $this->addTypeFilter(new DatePeriodFilter(), new TypeMatcher(DatePeriod::class));
+ $this->addTypeFilter(new SplDoublyLinkedListFilter($this), new TypeMatcher(SplDoublyLinkedList::class));
+ }
+
+ /**
+ * If enabled, will not throw an exception when coming across an uncloneable property.
+ *
+ * @param $skipUncloneable
+ *
+ * @return $this
+ */
+ public function skipUncloneable($skipUncloneable = true)
+ {
+ $this->skipUncloneable = $skipUncloneable;
+
+ return $this;
+ }
+
+ /**
+ * Deep copies the given object.
+ *
+ * @template TObject
+ *
+ * @param TObject $object
+ *
+ * @return TObject
+ */
+ public function copy($object)
+ {
+ $this->hashMap = [];
+
+ return $this->recursiveCopy($object);
+ }
+
+ public function addFilter(Filter $filter, Matcher $matcher)
+ {
+ $this->filters[] = [
+ 'matcher' => $matcher,
+ 'filter' => $filter,
+ ];
+ }
+
+ public function prependFilter(Filter $filter, Matcher $matcher)
+ {
+ array_unshift($this->filters, [
+ 'matcher' => $matcher,
+ 'filter' => $filter,
+ ]);
+ }
+
+ public function addTypeFilter(TypeFilter $filter, TypeMatcher $matcher)
+ {
+ $this->typeFilters[] = [
+ 'matcher' => $matcher,
+ 'filter' => $filter,
+ ];
+ }
+
+ public function prependTypeFilter(TypeFilter $filter, TypeMatcher $matcher)
+ {
+ array_unshift($this->typeFilters, [
+ 'matcher' => $matcher,
+ 'filter' => $filter,
+ ]);
+ }
+
+ private function recursiveCopy($var)
+ {
+ // Matches Type Filter
+ if ($filter = $this->getFirstMatchedTypeFilter($this->typeFilters, $var)) {
+ return $filter->apply($var);
+ }
+
+ // Resource
+ if (is_resource($var)) {
+ return $var;
+ }
+
+ // Array
+ if (is_array($var)) {
+ return $this->copyArray($var);
+ }
+
+ // Scalar
+ if (! is_object($var)) {
+ return $var;
+ }
+
+ // Enum
+ if (PHP_VERSION_ID >= 80100 && enum_exists(get_class($var))) {
+ return $var;
+ }
+
+ // Object
+ return $this->copyObject($var);
+ }
+
+ /**
+ * Copy an array
+ * @param array $array
+ * @return array
+ */
+ private function copyArray(array $array)
+ {
+ foreach ($array as $key => $value) {
+ $array[$key] = $this->recursiveCopy($value);
+ }
+
+ return $array;
+ }
+
+ /**
+ * Copies an object.
+ *
+ * @param object $object
+ *
+ * @throws CloneException
+ *
+ * @return object
+ */
+ private function copyObject($object)
+ {
+ $objectHash = spl_object_hash($object);
+
+ if (isset($this->hashMap[$objectHash])) {
+ return $this->hashMap[$objectHash];
+ }
+
+ $reflectedObject = new ReflectionObject($object);
+ $isCloneable = $reflectedObject->isCloneable();
+
+ if (false === $isCloneable) {
+ if ($this->skipUncloneable) {
+ $this->hashMap[$objectHash] = $object;
+
+ return $object;
+ }
+
+ throw new CloneException(
+ sprintf(
+ 'The class "%s" is not cloneable.',
+ $reflectedObject->getName()
+ )
+ );
+ }
+
+ $newObject = clone $object;
+ $this->hashMap[$objectHash] = $newObject;
+
+ if ($this->useCloneMethod && $reflectedObject->hasMethod('__clone')) {
+ return $newObject;
+ }
+
+ if ($newObject instanceof DateTimeInterface || $newObject instanceof DateTimeZone) {
+ return $newObject;
+ }
+
+ foreach (ReflectionHelper::getProperties($reflectedObject) as $property) {
+ $this->copyObjectProperty($newObject, $property);
+ }
+
+ return $newObject;
+ }
+
+ private function copyObjectProperty($object, ReflectionProperty $property)
+ {
+ // Ignore static properties
+ if ($property->isStatic()) {
+ return;
+ }
+
+ // Ignore readonly properties
+ if (method_exists($property, 'isReadOnly') && $property->isReadOnly()) {
+ return;
+ }
+
+ // Apply the filters
+ foreach ($this->filters as $item) {
+ /** @var Matcher $matcher */
+ $matcher = $item['matcher'];
+ /** @var Filter $filter */
+ $filter = $item['filter'];
+
+ if ($matcher->matches($object, $property->getName())) {
+ $filter->apply(
+ $object,
+ $property->getName(),
+ function ($object) {
+ return $this->recursiveCopy($object);
+ }
+ );
+
+ if ($filter instanceof ChainableFilter) {
+ continue;
+ }
+
+ // If a filter matches, we stop processing this property
+ return;
+ }
+ }
+
+ if (PHP_VERSION_ID < 80100) {
+ $property->setAccessible(true);
+ }
+
+ // Ignore uninitialized properties (for PHP >7.4)
+ if (method_exists($property, 'isInitialized') && !$property->isInitialized($object)) {
+ return;
+ }
+
+ $propertyValue = $property->getValue($object);
+
+ // Copy the property
+ $property->setValue($object, $this->recursiveCopy($propertyValue));
+ }
+
+ /**
+ * Returns first filter that matches variable, `null` if no such filter found.
+ *
+ * @param array $filterRecords Associative array with 2 members: 'filter' with value of type {@see TypeFilter} and
+ * 'matcher' with value of type {@see TypeMatcher}
+ * @param mixed $var
+ *
+ * @return TypeFilter|null
+ */
+ private function getFirstMatchedTypeFilter(array $filterRecords, $var)
+ {
+ $matched = $this->first(
+ $filterRecords,
+ function (array $record) use ($var) {
+ /* @var TypeMatcher $matcher */
+ $matcher = $record['matcher'];
+
+ return $matcher->matches($var);
+ }
+ );
+
+ return isset($matched) ? $matched['filter'] : null;
+ }
+
+ /**
+ * Returns first element that matches predicate, `null` if no such element found.
+ *
+ * @param array $elements Array of ['filter' => Filter, 'matcher' => Matcher] pairs.
+ * @param callable $predicate Predicate arguments are: element.
+ *
+ * @return array|null Associative array with 2 members: 'filter' with value of type {@see TypeFilter} and 'matcher'
+ * with value of type {@see TypeMatcher} or `null`.
+ */
+ private function first(array $elements, callable $predicate)
+ {
+ foreach ($elements as $element) {
+ if (call_user_func($predicate, $element)) {
+ return $element;
+ }
+ }
+
+ return null;
+ }
+}
diff --git a/vendor/myclabs/deep-copy/src/DeepCopy/Exception/CloneException.php b/vendor/myclabs/deep-copy/src/DeepCopy/Exception/CloneException.php
new file mode 100644
index 0000000..c046706
--- /dev/null
+++ b/vendor/myclabs/deep-copy/src/DeepCopy/Exception/CloneException.php
@@ -0,0 +1,9 @@
+filter = $filter;
+ }
+
+ public function apply($object, $property, $objectCopier)
+ {
+ $this->filter->apply($object, $property, $objectCopier);
+ }
+}
diff --git a/vendor/myclabs/deep-copy/src/DeepCopy/Filter/Doctrine/DoctrineCollectionFilter.php b/vendor/myclabs/deep-copy/src/DeepCopy/Filter/Doctrine/DoctrineCollectionFilter.php
new file mode 100644
index 0000000..66e91e5
--- /dev/null
+++ b/vendor/myclabs/deep-copy/src/DeepCopy/Filter/Doctrine/DoctrineCollectionFilter.php
@@ -0,0 +1,35 @@
+setAccessible(true);
+ }
+ $oldCollection = $reflectionProperty->getValue($object);
+
+ $newCollection = $oldCollection->map(
+ function ($item) use ($objectCopier) {
+ return $objectCopier($item);
+ }
+ );
+
+ $reflectionProperty->setValue($object, $newCollection);
+ }
+}
diff --git a/vendor/myclabs/deep-copy/src/DeepCopy/Filter/Doctrine/DoctrineEmptyCollectionFilter.php b/vendor/myclabs/deep-copy/src/DeepCopy/Filter/Doctrine/DoctrineEmptyCollectionFilter.php
new file mode 100644
index 0000000..fa1c034
--- /dev/null
+++ b/vendor/myclabs/deep-copy/src/DeepCopy/Filter/Doctrine/DoctrineEmptyCollectionFilter.php
@@ -0,0 +1,30 @@
+setAccessible(true);
+ }
+
+ $reflectionProperty->setValue($object, new ArrayCollection());
+ }
+}
\ No newline at end of file
diff --git a/vendor/myclabs/deep-copy/src/DeepCopy/Filter/Doctrine/DoctrineProxyFilter.php b/vendor/myclabs/deep-copy/src/DeepCopy/Filter/Doctrine/DoctrineProxyFilter.php
new file mode 100644
index 0000000..8bee8f7
--- /dev/null
+++ b/vendor/myclabs/deep-copy/src/DeepCopy/Filter/Doctrine/DoctrineProxyFilter.php
@@ -0,0 +1,22 @@
+__load();
+ }
+}
diff --git a/vendor/myclabs/deep-copy/src/DeepCopy/Filter/Filter.php b/vendor/myclabs/deep-copy/src/DeepCopy/Filter/Filter.php
new file mode 100644
index 0000000..85ba18c
--- /dev/null
+++ b/vendor/myclabs/deep-copy/src/DeepCopy/Filter/Filter.php
@@ -0,0 +1,18 @@
+callback = $callable;
+ }
+
+ /**
+ * Replaces the object property by the result of the callback called with the object property.
+ *
+ * {@inheritdoc}
+ */
+ public function apply($object, $property, $objectCopier)
+ {
+ $reflectionProperty = ReflectionHelper::getProperty($object, $property);
+ if (PHP_VERSION_ID < 80100) {
+ $reflectionProperty->setAccessible(true);
+ }
+
+ $value = call_user_func($this->callback, $reflectionProperty->getValue($object));
+
+ $reflectionProperty->setValue($object, $value);
+ }
+}
diff --git a/vendor/myclabs/deep-copy/src/DeepCopy/Filter/SetNullFilter.php b/vendor/myclabs/deep-copy/src/DeepCopy/Filter/SetNullFilter.php
new file mode 100644
index 0000000..6722272
--- /dev/null
+++ b/vendor/myclabs/deep-copy/src/DeepCopy/Filter/SetNullFilter.php
@@ -0,0 +1,26 @@
+setAccessible(true);
+ }
+ $reflectionProperty->setValue($object, null);
+ }
+}
diff --git a/vendor/myclabs/deep-copy/src/DeepCopy/Matcher/Doctrine/DoctrineProxyMatcher.php b/vendor/myclabs/deep-copy/src/DeepCopy/Matcher/Doctrine/DoctrineProxyMatcher.php
new file mode 100644
index 0000000..c5887b1
--- /dev/null
+++ b/vendor/myclabs/deep-copy/src/DeepCopy/Matcher/Doctrine/DoctrineProxyMatcher.php
@@ -0,0 +1,22 @@
+class = $class;
+ $this->property = $property;
+ }
+
+ /**
+ * Matches a specific property of a specific class.
+ *
+ * {@inheritdoc}
+ */
+ public function matches($object, $property)
+ {
+ return ($object instanceof $this->class) && $property == $this->property;
+ }
+}
diff --git a/vendor/myclabs/deep-copy/src/DeepCopy/Matcher/PropertyNameMatcher.php b/vendor/myclabs/deep-copy/src/DeepCopy/Matcher/PropertyNameMatcher.php
new file mode 100644
index 0000000..c8ec0d2
--- /dev/null
+++ b/vendor/myclabs/deep-copy/src/DeepCopy/Matcher/PropertyNameMatcher.php
@@ -0,0 +1,32 @@
+property = $property;
+ }
+
+ /**
+ * Matches a property by its name.
+ *
+ * {@inheritdoc}
+ */
+ public function matches($object, $property)
+ {
+ return $property == $this->property;
+ }
+}
diff --git a/vendor/myclabs/deep-copy/src/DeepCopy/Matcher/PropertyTypeMatcher.php b/vendor/myclabs/deep-copy/src/DeepCopy/Matcher/PropertyTypeMatcher.php
new file mode 100644
index 0000000..7980bfa
--- /dev/null
+++ b/vendor/myclabs/deep-copy/src/DeepCopy/Matcher/PropertyTypeMatcher.php
@@ -0,0 +1,54 @@
+propertyType = $propertyType;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function matches($object, $property)
+ {
+ try {
+ $reflectionProperty = ReflectionHelper::getProperty($object, $property);
+ } catch (ReflectionException $exception) {
+ return false;
+ }
+
+ if (PHP_VERSION_ID < 80100) {
+ $reflectionProperty->setAccessible(true);
+ }
+
+ // Uninitialized properties (for PHP >7.4)
+ if (method_exists($reflectionProperty, 'isInitialized') && !$reflectionProperty->isInitialized($object)) {
+ // null instanceof $this->propertyType
+ return false;
+ }
+
+ return $reflectionProperty->getValue($object) instanceof $this->propertyType;
+ }
+}
diff --git a/vendor/myclabs/deep-copy/src/DeepCopy/Reflection/ReflectionHelper.php b/vendor/myclabs/deep-copy/src/DeepCopy/Reflection/ReflectionHelper.php
new file mode 100644
index 0000000..742410c
--- /dev/null
+++ b/vendor/myclabs/deep-copy/src/DeepCopy/Reflection/ReflectionHelper.php
@@ -0,0 +1,78 @@
+getProperties() does not return private properties from ancestor classes.
+ *
+ * @author muratyaman@gmail.com
+ * @see http://php.net/manual/en/reflectionclass.getproperties.php
+ *
+ * @param ReflectionClass $ref
+ *
+ * @return ReflectionProperty[]
+ */
+ public static function getProperties(ReflectionClass $ref)
+ {
+ $props = $ref->getProperties();
+ $propsArr = array();
+
+ foreach ($props as $prop) {
+ $propertyName = $prop->getName();
+ $propsArr[$propertyName] = $prop;
+ }
+
+ if ($parentClass = $ref->getParentClass()) {
+ $parentPropsArr = self::getProperties($parentClass);
+ foreach ($propsArr as $key => $property) {
+ $parentPropsArr[$key] = $property;
+ }
+
+ return $parentPropsArr;
+ }
+
+ return $propsArr;
+ }
+
+ /**
+ * Retrieves property by name from object and all its ancestors.
+ *
+ * @param object|string $object
+ * @param string $name
+ *
+ * @throws PropertyException
+ * @throws ReflectionException
+ *
+ * @return ReflectionProperty
+ */
+ public static function getProperty($object, $name)
+ {
+ $reflection = is_object($object) ? new ReflectionObject($object) : new ReflectionClass($object);
+
+ if ($reflection->hasProperty($name)) {
+ return $reflection->getProperty($name);
+ }
+
+ if ($parentClass = $reflection->getParentClass()) {
+ return self::getProperty($parentClass->getName(), $name);
+ }
+
+ throw new PropertyException(
+ sprintf(
+ 'The class "%s" doesn\'t have a property with the given name: "%s".',
+ is_object($object) ? get_class($object) : $object,
+ $name
+ )
+ );
+ }
+}
diff --git a/vendor/myclabs/deep-copy/src/DeepCopy/TypeFilter/Date/DateIntervalFilter.php b/vendor/myclabs/deep-copy/src/DeepCopy/TypeFilter/Date/DateIntervalFilter.php
new file mode 100644
index 0000000..becd1cf
--- /dev/null
+++ b/vendor/myclabs/deep-copy/src/DeepCopy/TypeFilter/Date/DateIntervalFilter.php
@@ -0,0 +1,33 @@
+ $propertyValue) {
+ $copy->{$propertyName} = $propertyValue;
+ }
+
+ return $copy;
+ }
+}
diff --git a/vendor/myclabs/deep-copy/src/DeepCopy/TypeFilter/Date/DatePeriodFilter.php b/vendor/myclabs/deep-copy/src/DeepCopy/TypeFilter/Date/DatePeriodFilter.php
new file mode 100644
index 0000000..6bd2f7e
--- /dev/null
+++ b/vendor/myclabs/deep-copy/src/DeepCopy/TypeFilter/Date/DatePeriodFilter.php
@@ -0,0 +1,42 @@
+= 80200 && $element->include_end_date) {
+ $options |= DatePeriod::INCLUDE_END_DATE;
+ }
+ if (!$element->include_start_date) {
+ $options |= DatePeriod::EXCLUDE_START_DATE;
+ }
+
+ if ($element->getEndDate()) {
+ return new DatePeriod($element->getStartDate(), $element->getDateInterval(), $element->getEndDate(), $options);
+ }
+
+ if (PHP_VERSION_ID >= 70217) {
+ $recurrences = $element->getRecurrences();
+ } else {
+ $recurrences = $element->recurrences - $element->include_start_date;
+ }
+
+ return new DatePeriod($element->getStartDate(), $element->getDateInterval(), $recurrences, $options);
+ }
+}
diff --git a/vendor/myclabs/deep-copy/src/DeepCopy/TypeFilter/ReplaceFilter.php b/vendor/myclabs/deep-copy/src/DeepCopy/TypeFilter/ReplaceFilter.php
new file mode 100644
index 0000000..164f8b8
--- /dev/null
+++ b/vendor/myclabs/deep-copy/src/DeepCopy/TypeFilter/ReplaceFilter.php
@@ -0,0 +1,30 @@
+callback = $callable;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function apply($element)
+ {
+ return call_user_func($this->callback, $element);
+ }
+}
diff --git a/vendor/myclabs/deep-copy/src/DeepCopy/TypeFilter/ShallowCopyFilter.php b/vendor/myclabs/deep-copy/src/DeepCopy/TypeFilter/ShallowCopyFilter.php
new file mode 100644
index 0000000..a5fbd7a
--- /dev/null
+++ b/vendor/myclabs/deep-copy/src/DeepCopy/TypeFilter/ShallowCopyFilter.php
@@ -0,0 +1,17 @@
+copier = $copier;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function apply($arrayObject)
+ {
+ $clone = clone $arrayObject;
+ foreach ($arrayObject->getArrayCopy() as $k => $v) {
+ $clone->offsetSet($k, $this->copier->copy($v));
+ }
+
+ return $clone;
+ }
+}
+
diff --git a/vendor/myclabs/deep-copy/src/DeepCopy/TypeFilter/Spl/SplDoublyLinkedList.php b/vendor/myclabs/deep-copy/src/DeepCopy/TypeFilter/Spl/SplDoublyLinkedList.php
new file mode 100644
index 0000000..c5644cf
--- /dev/null
+++ b/vendor/myclabs/deep-copy/src/DeepCopy/TypeFilter/Spl/SplDoublyLinkedList.php
@@ -0,0 +1,10 @@
+copier = $copier;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function apply($element)
+ {
+ $newElement = clone $element;
+
+ $copy = $this->createCopyClosure();
+
+ return $copy($newElement);
+ }
+
+ private function createCopyClosure()
+ {
+ $copier = $this->copier;
+
+ $copy = function (SplDoublyLinkedList $list) use ($copier) {
+ // Replace each element in the list with a deep copy of itself
+ for ($i = 1; $i <= $list->count(); $i++) {
+ $copy = $copier->recursiveCopy($list->shift());
+
+ $list->push($copy);
+ }
+
+ return $list;
+ };
+
+ return Closure::bind($copy, null, DeepCopy::class);
+ }
+}
diff --git a/vendor/myclabs/deep-copy/src/DeepCopy/TypeFilter/TypeFilter.php b/vendor/myclabs/deep-copy/src/DeepCopy/TypeFilter/TypeFilter.php
new file mode 100644
index 0000000..5785a7d
--- /dev/null
+++ b/vendor/myclabs/deep-copy/src/DeepCopy/TypeFilter/TypeFilter.php
@@ -0,0 +1,13 @@
+type = $type;
+ }
+
+ /**
+ * @param mixed $element
+ *
+ * @return boolean
+ */
+ public function matches($element)
+ {
+ return is_object($element) ? is_a($element, $this->type) : gettype($element) === $this->type;
+ }
+}
diff --git a/vendor/myclabs/deep-copy/src/DeepCopy/deep_copy.php b/vendor/myclabs/deep-copy/src/DeepCopy/deep_copy.php
new file mode 100644
index 0000000..55dcc92
--- /dev/null
+++ b/vendor/myclabs/deep-copy/src/DeepCopy/deep_copy.php
@@ -0,0 +1,20 @@
+copy($value);
+ }
+}
diff --git a/vendor/nikic/php-parser/LICENSE b/vendor/nikic/php-parser/LICENSE
new file mode 100644
index 0000000..2e56718
--- /dev/null
+++ b/vendor/nikic/php-parser/LICENSE
@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2011, Nikita Popov
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/nikic/php-parser/README.md b/vendor/nikic/php-parser/README.md
new file mode 100644
index 0000000..edb3ed3
--- /dev/null
+++ b/vendor/nikic/php-parser/README.md
@@ -0,0 +1,233 @@
+PHP Parser
+==========
+
+[](https://coveralls.io/github/nikic/PHP-Parser?branch=master)
+
+This is a PHP parser written in PHP. Its purpose is to simplify static code analysis and
+manipulation.
+
+[**Documentation for version 5.x**][doc_master] (current; for running on PHP >= 7.4; for parsing PHP 7.0 to PHP 8.4, with limited support for parsing PHP 5.x).
+
+[Documentation for version 4.x][doc_4_x] (supported; for running on PHP >= 7.0; for parsing PHP 5.2 to PHP 8.3).
+
+Features
+--------
+
+The main features provided by this library are:
+
+ * Parsing PHP 7, and PHP 8 code into an abstract syntax tree (AST).
+ * Invalid code can be parsed into a partial AST.
+ * The AST contains accurate location information.
+ * Dumping the AST in human-readable form.
+ * Converting an AST back to PHP code.
+ * Formatting can be preserved for partially changed ASTs.
+ * Infrastructure to traverse and modify ASTs.
+ * Resolution of namespaced names.
+ * Evaluation of constant expressions.
+ * Builders to simplify AST construction for code generation.
+ * Converting an AST into JSON and back.
+
+Quick Start
+-----------
+
+Install the library using [composer](https://getcomposer.org):
+
+ php composer.phar require nikic/php-parser
+
+Parse some PHP code into an AST and dump the result in human-readable form:
+
+```php
+createForNewestSupportedVersion();
+try {
+ $ast = $parser->parse($code);
+} catch (Error $error) {
+ echo "Parse error: {$error->getMessage()}\n";
+ return;
+}
+
+$dumper = new NodeDumper;
+echo $dumper->dump($ast) . "\n";
+```
+
+This dumps an AST looking something like this:
+
+```
+array(
+ 0: Stmt_Function(
+ attrGroups: array(
+ )
+ byRef: false
+ name: Identifier(
+ name: test
+ )
+ params: array(
+ 0: Param(
+ attrGroups: array(
+ )
+ flags: 0
+ type: null
+ byRef: false
+ variadic: false
+ var: Expr_Variable(
+ name: foo
+ )
+ default: null
+ )
+ )
+ returnType: null
+ stmts: array(
+ 0: Stmt_Expression(
+ expr: Expr_FuncCall(
+ name: Name(
+ name: var_dump
+ )
+ args: array(
+ 0: Arg(
+ name: null
+ value: Expr_Variable(
+ name: foo
+ )
+ byRef: false
+ unpack: false
+ )
+ )
+ )
+ )
+ )
+ )
+)
+```
+
+Let's traverse the AST and perform some kind of modification. For example, drop all function bodies:
+
+```php
+use PhpParser\Node;
+use PhpParser\Node\Stmt\Function_;
+use PhpParser\NodeTraverser;
+use PhpParser\NodeVisitorAbstract;
+
+$traverser = new NodeTraverser();
+$traverser->addVisitor(new class extends NodeVisitorAbstract {
+ public function enterNode(Node $node) {
+ if ($node instanceof Function_) {
+ // Clean out the function body
+ $node->stmts = [];
+ }
+ }
+});
+
+$ast = $traverser->traverse($ast);
+echo $dumper->dump($ast) . "\n";
+```
+
+This gives us an AST where the `Function_::$stmts` are empty:
+
+```
+array(
+ 0: Stmt_Function(
+ attrGroups: array(
+ )
+ byRef: false
+ name: Identifier(
+ name: test
+ )
+ params: array(
+ 0: Param(
+ attrGroups: array(
+ )
+ type: null
+ byRef: false
+ variadic: false
+ var: Expr_Variable(
+ name: foo
+ )
+ default: null
+ )
+ )
+ returnType: null
+ stmts: array(
+ )
+ )
+)
+```
+
+Finally, we can convert the new AST back to PHP code:
+
+```php
+use PhpParser\PrettyPrinter;
+
+$prettyPrinter = new PrettyPrinter\Standard;
+echo $prettyPrinter->prettyPrintFile($ast);
+```
+
+This gives us our original code, minus the `var_dump()` call inside the function:
+
+```php
+createForVersion($attributes['version']);
+$dumper = new PhpParser\NodeDumper([
+ 'dumpComments' => true,
+ 'dumpPositions' => $attributes['with-positions'],
+]);
+$prettyPrinter = new PhpParser\PrettyPrinter\Standard;
+
+$traverser = new PhpParser\NodeTraverser();
+$traverser->addVisitor(new PhpParser\NodeVisitor\NameResolver);
+
+foreach ($files as $file) {
+ if ($file === '-') {
+ $code = file_get_contents('php://stdin');
+ fwrite(STDERR, "====> Stdin:\n");
+ } else if (strpos($file, ' Code $code\n");
+ } else {
+ if (!file_exists($file)) {
+ fwrite(STDERR, "File $file does not exist.\n");
+ exit(1);
+ }
+
+ $code = file_get_contents($file);
+ fwrite(STDERR, "====> File $file:\n");
+ }
+
+ if ($attributes['with-recovery']) {
+ $errorHandler = new PhpParser\ErrorHandler\Collecting;
+ $stmts = $parser->parse($code, $errorHandler);
+ foreach ($errorHandler->getErrors() as $error) {
+ $message = formatErrorMessage($error, $code, $attributes['with-column-info']);
+ fwrite(STDERR, $message . "\n");
+ }
+ if (null === $stmts) {
+ continue;
+ }
+ } else {
+ try {
+ $stmts = $parser->parse($code);
+ } catch (PhpParser\Error $error) {
+ $message = formatErrorMessage($error, $code, $attributes['with-column-info']);
+ fwrite(STDERR, $message . "\n");
+ exit(1);
+ }
+ }
+
+ foreach ($operations as $operation) {
+ if ('dump' === $operation) {
+ fwrite(STDERR, "==> Node dump:\n");
+ echo $dumper->dump($stmts, $code), "\n";
+ } elseif ('pretty-print' === $operation) {
+ fwrite(STDERR, "==> Pretty print:\n");
+ echo $prettyPrinter->prettyPrintFile($stmts), "\n";
+ } elseif ('json-dump' === $operation) {
+ fwrite(STDERR, "==> JSON dump:\n");
+ echo json_encode($stmts, JSON_PRETTY_PRINT), "\n";
+ } elseif ('var-dump' === $operation) {
+ fwrite(STDERR, "==> var_dump():\n");
+ var_dump($stmts);
+ } elseif ('resolve-names' === $operation) {
+ fwrite(STDERR, "==> Resolved names.\n");
+ $stmts = $traverser->traverse($stmts);
+ }
+ }
+}
+
+function formatErrorMessage(PhpParser\Error $e, $code, $withColumnInfo) {
+ if ($withColumnInfo && $e->hasColumnInfo()) {
+ return $e->getMessageWithColumnInfo($code);
+ } else {
+ return $e->getMessage();
+ }
+}
+
+function showHelp($error = '') {
+ if ($error) {
+ fwrite(STDERR, $error . "\n\n");
+ }
+ fwrite($error ? STDERR : STDOUT, <<<'OUTPUT'
+Usage: php-parse [operations] file1.php [file2.php ...]
+ or: php-parse [operations] " false,
+ 'with-positions' => false,
+ 'with-recovery' => false,
+ 'version' => PhpParser\PhpVersion::getNewestSupported(),
+ ];
+
+ array_shift($args);
+ $parseOptions = true;
+ foreach ($args as $arg) {
+ if (!$parseOptions) {
+ $files[] = $arg;
+ continue;
+ }
+
+ switch ($arg) {
+ case '--dump':
+ case '-d':
+ $operations[] = 'dump';
+ break;
+ case '--pretty-print':
+ case '-p':
+ $operations[] = 'pretty-print';
+ break;
+ case '--json-dump':
+ case '-j':
+ $operations[] = 'json-dump';
+ break;
+ case '--var-dump':
+ $operations[] = 'var-dump';
+ break;
+ case '--resolve-names':
+ case '-N':
+ $operations[] = 'resolve-names';
+ break;
+ case '--with-column-info':
+ case '-c':
+ $attributes['with-column-info'] = true;
+ break;
+ case '--with-positions':
+ case '-P':
+ $attributes['with-positions'] = true;
+ break;
+ case '--with-recovery':
+ case '-r':
+ $attributes['with-recovery'] = true;
+ break;
+ case '--help':
+ case '-h':
+ showHelp();
+ break;
+ case '--':
+ $parseOptions = false;
+ break;
+ default:
+ if (preg_match('/^--version=(.*)$/', $arg, $matches)) {
+ $attributes['version'] = PhpParser\PhpVersion::fromString($matches[1]);
+ } elseif ($arg[0] === '-' && \strlen($arg[0]) > 1) {
+ showHelp("Invalid operation $arg.");
+ } else {
+ $files[] = $arg;
+ }
+ }
+ }
+
+ return [$operations, $files, $attributes];
+}
diff --git a/vendor/nikic/php-parser/composer.json b/vendor/nikic/php-parser/composer.json
new file mode 100644
index 0000000..7a8591d
--- /dev/null
+++ b/vendor/nikic/php-parser/composer.json
@@ -0,0 +1,43 @@
+{
+ "name": "nikic/php-parser",
+ "type": "library",
+ "description": "A PHP parser written in PHP",
+ "keywords": [
+ "php",
+ "parser"
+ ],
+ "license": "BSD-3-Clause",
+ "authors": [
+ {
+ "name": "Nikita Popov"
+ }
+ ],
+ "require": {
+ "php": ">=7.4",
+ "ext-tokenizer": "*",
+ "ext-json": "*",
+ "ext-ctype": "*"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.0",
+ "ircmaxell/php-yacc": "^0.0.7"
+ },
+ "extra": {
+ "branch-alias": {
+ "dev-master": "5.x-dev"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "PhpParser\\": "lib/PhpParser"
+ }
+ },
+ "autoload-dev": {
+ "psr-4": {
+ "PhpParser\\": "test/PhpParser/"
+ }
+ },
+ "bin": [
+ "bin/php-parse"
+ ]
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Builder.php b/vendor/nikic/php-parser/lib/PhpParser/Builder.php
new file mode 100644
index 0000000..d6aa124
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Builder.php
@@ -0,0 +1,12 @@
+ */
+ protected array $attributes = [];
+ /** @var list */
+ protected array $constants = [];
+
+ /** @var list */
+ protected array $attributeGroups = [];
+ /** @var Identifier|Node\Name|Node\ComplexType|null */
+ protected ?Node $type = null;
+
+ /**
+ * Creates a class constant builder
+ *
+ * @param string|Identifier $name Name
+ * @param Node\Expr|bool|null|int|float|string|array|\UnitEnum $value Value
+ */
+ public function __construct($name, $value) {
+ $this->constants = [new Const_($name, BuilderHelpers::normalizeValue($value))];
+ }
+
+ /**
+ * Add another constant to const group
+ *
+ * @param string|Identifier $name Name
+ * @param Node\Expr|bool|null|int|float|string|array|\UnitEnum $value Value
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function addConst($name, $value) {
+ $this->constants[] = new Const_($name, BuilderHelpers::normalizeValue($value));
+
+ return $this;
+ }
+
+ /**
+ * Makes the constant public.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makePublic() {
+ $this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::PUBLIC);
+
+ return $this;
+ }
+
+ /**
+ * Makes the constant protected.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makeProtected() {
+ $this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::PROTECTED);
+
+ return $this;
+ }
+
+ /**
+ * Makes the constant private.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makePrivate() {
+ $this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::PRIVATE);
+
+ return $this;
+ }
+
+ /**
+ * Makes the constant final.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makeFinal() {
+ $this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::FINAL);
+
+ return $this;
+ }
+
+ /**
+ * Sets doc comment for the constant.
+ *
+ * @param PhpParser\Comment\Doc|string $docComment Doc comment to set
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function setDocComment($docComment) {
+ $this->attributes = [
+ 'comments' => [BuilderHelpers::normalizeDocComment($docComment)]
+ ];
+
+ return $this;
+ }
+
+ /**
+ * Adds an attribute group.
+ *
+ * @param Node\Attribute|Node\AttributeGroup $attribute
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function addAttribute($attribute) {
+ $this->attributeGroups[] = BuilderHelpers::normalizeAttribute($attribute);
+
+ return $this;
+ }
+
+ /**
+ * Sets the constant type.
+ *
+ * @param string|Node\Name|Identifier|Node\ComplexType $type
+ *
+ * @return $this
+ */
+ public function setType($type) {
+ $this->type = BuilderHelpers::normalizeType($type);
+
+ return $this;
+ }
+
+ /**
+ * Returns the built class node.
+ *
+ * @return Stmt\ClassConst The built constant node
+ */
+ public function getNode(): PhpParser\Node {
+ return new Stmt\ClassConst(
+ $this->constants,
+ $this->flags,
+ $this->attributes,
+ $this->attributeGroups,
+ $this->type
+ );
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Builder/Class_.php b/vendor/nikic/php-parser/lib/PhpParser/Builder/Class_.php
new file mode 100644
index 0000000..6f39431
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Builder/Class_.php
@@ -0,0 +1,151 @@
+ */
+ protected array $implements = [];
+ protected int $flags = 0;
+ /** @var list */
+ protected array $uses = [];
+ /** @var list */
+ protected array $constants = [];
+ /** @var list */
+ protected array $properties = [];
+ /** @var list */
+ protected array $methods = [];
+ /** @var list */
+ protected array $attributeGroups = [];
+
+ /**
+ * Creates a class builder.
+ *
+ * @param string $name Name of the class
+ */
+ public function __construct(string $name) {
+ $this->name = $name;
+ }
+
+ /**
+ * Extends a class.
+ *
+ * @param Name|string $class Name of class to extend
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function extend($class) {
+ $this->extends = BuilderHelpers::normalizeName($class);
+
+ return $this;
+ }
+
+ /**
+ * Implements one or more interfaces.
+ *
+ * @param Name|string ...$interfaces Names of interfaces to implement
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function implement(...$interfaces) {
+ foreach ($interfaces as $interface) {
+ $this->implements[] = BuilderHelpers::normalizeName($interface);
+ }
+
+ return $this;
+ }
+
+ /**
+ * Makes the class abstract.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makeAbstract() {
+ $this->flags = BuilderHelpers::addClassModifier($this->flags, Modifiers::ABSTRACT);
+
+ return $this;
+ }
+
+ /**
+ * Makes the class final.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makeFinal() {
+ $this->flags = BuilderHelpers::addClassModifier($this->flags, Modifiers::FINAL);
+
+ return $this;
+ }
+
+ /**
+ * Makes the class readonly.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makeReadonly() {
+ $this->flags = BuilderHelpers::addClassModifier($this->flags, Modifiers::READONLY);
+
+ return $this;
+ }
+
+ /**
+ * Adds a statement.
+ *
+ * @param Stmt|PhpParser\Builder $stmt The statement to add
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function addStmt($stmt) {
+ $stmt = BuilderHelpers::normalizeNode($stmt);
+
+ if ($stmt instanceof Stmt\Property) {
+ $this->properties[] = $stmt;
+ } elseif ($stmt instanceof Stmt\ClassMethod) {
+ $this->methods[] = $stmt;
+ } elseif ($stmt instanceof Stmt\TraitUse) {
+ $this->uses[] = $stmt;
+ } elseif ($stmt instanceof Stmt\ClassConst) {
+ $this->constants[] = $stmt;
+ } else {
+ throw new \LogicException(sprintf('Unexpected node of type "%s"', $stmt->getType()));
+ }
+
+ return $this;
+ }
+
+ /**
+ * Adds an attribute group.
+ *
+ * @param Node\Attribute|Node\AttributeGroup $attribute
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function addAttribute($attribute) {
+ $this->attributeGroups[] = BuilderHelpers::normalizeAttribute($attribute);
+
+ return $this;
+ }
+
+ /**
+ * Returns the built class node.
+ *
+ * @return Stmt\Class_ The built class node
+ */
+ public function getNode(): PhpParser\Node {
+ return new Stmt\Class_($this->name, [
+ 'flags' => $this->flags,
+ 'extends' => $this->extends,
+ 'implements' => $this->implements,
+ 'stmts' => array_merge($this->uses, $this->constants, $this->properties, $this->methods),
+ 'attrGroups' => $this->attributeGroups,
+ ], $this->attributes);
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Builder/Declaration.php b/vendor/nikic/php-parser/lib/PhpParser/Builder/Declaration.php
new file mode 100644
index 0000000..488b721
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Builder/Declaration.php
@@ -0,0 +1,50 @@
+ */
+ protected array $attributes = [];
+
+ /**
+ * Adds a statement.
+ *
+ * @param PhpParser\Node\Stmt|PhpParser\Builder $stmt The statement to add
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ abstract public function addStmt($stmt);
+
+ /**
+ * Adds multiple statements.
+ *
+ * @param (PhpParser\Node\Stmt|PhpParser\Builder)[] $stmts The statements to add
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function addStmts(array $stmts) {
+ foreach ($stmts as $stmt) {
+ $this->addStmt($stmt);
+ }
+
+ return $this;
+ }
+
+ /**
+ * Sets doc comment for the declaration.
+ *
+ * @param PhpParser\Comment\Doc|string $docComment Doc comment to set
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function setDocComment($docComment) {
+ $this->attributes['comments'] = [
+ BuilderHelpers::normalizeDocComment($docComment)
+ ];
+
+ return $this;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Builder/EnumCase.php b/vendor/nikic/php-parser/lib/PhpParser/Builder/EnumCase.php
new file mode 100644
index 0000000..c766321
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Builder/EnumCase.php
@@ -0,0 +1,86 @@
+ */
+ protected array $attributes = [];
+
+ /** @var list */
+ protected array $attributeGroups = [];
+
+ /**
+ * Creates an enum case builder.
+ *
+ * @param string|Identifier $name Name
+ */
+ public function __construct($name) {
+ $this->name = $name;
+ }
+
+ /**
+ * Sets the value.
+ *
+ * @param Node\Expr|string|int $value
+ *
+ * @return $this
+ */
+ public function setValue($value) {
+ $this->value = BuilderHelpers::normalizeValue($value);
+
+ return $this;
+ }
+
+ /**
+ * Sets doc comment for the constant.
+ *
+ * @param PhpParser\Comment\Doc|string $docComment Doc comment to set
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function setDocComment($docComment) {
+ $this->attributes = [
+ 'comments' => [BuilderHelpers::normalizeDocComment($docComment)]
+ ];
+
+ return $this;
+ }
+
+ /**
+ * Adds an attribute group.
+ *
+ * @param Node\Attribute|Node\AttributeGroup $attribute
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function addAttribute($attribute) {
+ $this->attributeGroups[] = BuilderHelpers::normalizeAttribute($attribute);
+
+ return $this;
+ }
+
+ /**
+ * Returns the built enum case node.
+ *
+ * @return Stmt\EnumCase The built constant node
+ */
+ public function getNode(): PhpParser\Node {
+ return new Stmt\EnumCase(
+ $this->name,
+ $this->value,
+ $this->attributeGroups,
+ $this->attributes
+ );
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Builder/Enum_.php b/vendor/nikic/php-parser/lib/PhpParser/Builder/Enum_.php
new file mode 100644
index 0000000..c00df03
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Builder/Enum_.php
@@ -0,0 +1,116 @@
+ */
+ protected array $implements = [];
+ /** @var list */
+ protected array $uses = [];
+ /** @var list */
+ protected array $enumCases = [];
+ /** @var list */
+ protected array $constants = [];
+ /** @var list */
+ protected array $methods = [];
+ /** @var list */
+ protected array $attributeGroups = [];
+
+ /**
+ * Creates an enum builder.
+ *
+ * @param string $name Name of the enum
+ */
+ public function __construct(string $name) {
+ $this->name = $name;
+ }
+
+ /**
+ * Sets the scalar type.
+ *
+ * @param string|Identifier $scalarType
+ *
+ * @return $this
+ */
+ public function setScalarType($scalarType) {
+ $this->scalarType = BuilderHelpers::normalizeType($scalarType);
+
+ return $this;
+ }
+
+ /**
+ * Implements one or more interfaces.
+ *
+ * @param Name|string ...$interfaces Names of interfaces to implement
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function implement(...$interfaces) {
+ foreach ($interfaces as $interface) {
+ $this->implements[] = BuilderHelpers::normalizeName($interface);
+ }
+
+ return $this;
+ }
+
+ /**
+ * Adds a statement.
+ *
+ * @param Stmt|PhpParser\Builder $stmt The statement to add
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function addStmt($stmt) {
+ $stmt = BuilderHelpers::normalizeNode($stmt);
+
+ if ($stmt instanceof Stmt\EnumCase) {
+ $this->enumCases[] = $stmt;
+ } elseif ($stmt instanceof Stmt\ClassMethod) {
+ $this->methods[] = $stmt;
+ } elseif ($stmt instanceof Stmt\TraitUse) {
+ $this->uses[] = $stmt;
+ } elseif ($stmt instanceof Stmt\ClassConst) {
+ $this->constants[] = $stmt;
+ } else {
+ throw new \LogicException(sprintf('Unexpected node of type "%s"', $stmt->getType()));
+ }
+
+ return $this;
+ }
+
+ /**
+ * Adds an attribute group.
+ *
+ * @param Node\Attribute|Node\AttributeGroup $attribute
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function addAttribute($attribute) {
+ $this->attributeGroups[] = BuilderHelpers::normalizeAttribute($attribute);
+
+ return $this;
+ }
+
+ /**
+ * Returns the built class node.
+ *
+ * @return Stmt\Enum_ The built enum node
+ */
+ public function getNode(): PhpParser\Node {
+ return new Stmt\Enum_($this->name, [
+ 'scalarType' => $this->scalarType,
+ 'implements' => $this->implements,
+ 'stmts' => array_merge($this->uses, $this->enumCases, $this->constants, $this->methods),
+ 'attrGroups' => $this->attributeGroups,
+ ], $this->attributes);
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Builder/FunctionLike.php b/vendor/nikic/php-parser/lib/PhpParser/Builder/FunctionLike.php
new file mode 100644
index 0000000..ff79cb6
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Builder/FunctionLike.php
@@ -0,0 +1,73 @@
+returnByRef = true;
+
+ return $this;
+ }
+
+ /**
+ * Adds a parameter.
+ *
+ * @param Node\Param|Param $param The parameter to add
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function addParam($param) {
+ $param = BuilderHelpers::normalizeNode($param);
+
+ if (!$param instanceof Node\Param) {
+ throw new \LogicException(sprintf('Expected parameter node, got "%s"', $param->getType()));
+ }
+
+ $this->params[] = $param;
+
+ return $this;
+ }
+
+ /**
+ * Adds multiple parameters.
+ *
+ * @param (Node\Param|Param)[] $params The parameters to add
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function addParams(array $params) {
+ foreach ($params as $param) {
+ $this->addParam($param);
+ }
+
+ return $this;
+ }
+
+ /**
+ * Sets the return type for PHP 7.
+ *
+ * @param string|Node\Name|Node\Identifier|Node\ComplexType $type
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function setReturnType($type) {
+ $this->returnType = BuilderHelpers::normalizeType($type);
+
+ return $this;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Builder/Function_.php b/vendor/nikic/php-parser/lib/PhpParser/Builder/Function_.php
new file mode 100644
index 0000000..48f5f69
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Builder/Function_.php
@@ -0,0 +1,67 @@
+ */
+ protected array $stmts = [];
+
+ /** @var list */
+ protected array $attributeGroups = [];
+
+ /**
+ * Creates a function builder.
+ *
+ * @param string $name Name of the function
+ */
+ public function __construct(string $name) {
+ $this->name = $name;
+ }
+
+ /**
+ * Adds a statement.
+ *
+ * @param Node|PhpParser\Builder $stmt The statement to add
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function addStmt($stmt) {
+ $this->stmts[] = BuilderHelpers::normalizeStmt($stmt);
+
+ return $this;
+ }
+
+ /**
+ * Adds an attribute group.
+ *
+ * @param Node\Attribute|Node\AttributeGroup $attribute
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function addAttribute($attribute) {
+ $this->attributeGroups[] = BuilderHelpers::normalizeAttribute($attribute);
+
+ return $this;
+ }
+
+ /**
+ * Returns the built function node.
+ *
+ * @return Stmt\Function_ The built function node
+ */
+ public function getNode(): Node {
+ return new Stmt\Function_($this->name, [
+ 'byRef' => $this->returnByRef,
+ 'params' => $this->params,
+ 'returnType' => $this->returnType,
+ 'stmts' => $this->stmts,
+ 'attrGroups' => $this->attributeGroups,
+ ], $this->attributes);
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Builder/Interface_.php b/vendor/nikic/php-parser/lib/PhpParser/Builder/Interface_.php
new file mode 100644
index 0000000..13dd3f7
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Builder/Interface_.php
@@ -0,0 +1,94 @@
+ */
+ protected array $extends = [];
+ /** @var list */
+ protected array $constants = [];
+ /** @var list */
+ protected array $methods = [];
+ /** @var list */
+ protected array $attributeGroups = [];
+
+ /**
+ * Creates an interface builder.
+ *
+ * @param string $name Name of the interface
+ */
+ public function __construct(string $name) {
+ $this->name = $name;
+ }
+
+ /**
+ * Extends one or more interfaces.
+ *
+ * @param Name|string ...$interfaces Names of interfaces to extend
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function extend(...$interfaces) {
+ foreach ($interfaces as $interface) {
+ $this->extends[] = BuilderHelpers::normalizeName($interface);
+ }
+
+ return $this;
+ }
+
+ /**
+ * Adds a statement.
+ *
+ * @param Stmt|PhpParser\Builder $stmt The statement to add
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function addStmt($stmt) {
+ $stmt = BuilderHelpers::normalizeNode($stmt);
+
+ if ($stmt instanceof Stmt\ClassConst) {
+ $this->constants[] = $stmt;
+ } elseif ($stmt instanceof Stmt\ClassMethod) {
+ // we erase all statements in the body of an interface method
+ $stmt->stmts = null;
+ $this->methods[] = $stmt;
+ } else {
+ throw new \LogicException(sprintf('Unexpected node of type "%s"', $stmt->getType()));
+ }
+
+ return $this;
+ }
+
+ /**
+ * Adds an attribute group.
+ *
+ * @param Node\Attribute|Node\AttributeGroup $attribute
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function addAttribute($attribute) {
+ $this->attributeGroups[] = BuilderHelpers::normalizeAttribute($attribute);
+
+ return $this;
+ }
+
+ /**
+ * Returns the built interface node.
+ *
+ * @return Stmt\Interface_ The built interface node
+ */
+ public function getNode(): PhpParser\Node {
+ return new Stmt\Interface_($this->name, [
+ 'extends' => $this->extends,
+ 'stmts' => array_merge($this->constants, $this->methods),
+ 'attrGroups' => $this->attributeGroups,
+ ], $this->attributes);
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Builder/Method.php b/vendor/nikic/php-parser/lib/PhpParser/Builder/Method.php
new file mode 100644
index 0000000..8358dbe
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Builder/Method.php
@@ -0,0 +1,147 @@
+|null */
+ protected ?array $stmts = [];
+
+ /** @var list */
+ protected array $attributeGroups = [];
+
+ /**
+ * Creates a method builder.
+ *
+ * @param string $name Name of the method
+ */
+ public function __construct(string $name) {
+ $this->name = $name;
+ }
+
+ /**
+ * Makes the method public.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makePublic() {
+ $this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::PUBLIC);
+
+ return $this;
+ }
+
+ /**
+ * Makes the method protected.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makeProtected() {
+ $this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::PROTECTED);
+
+ return $this;
+ }
+
+ /**
+ * Makes the method private.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makePrivate() {
+ $this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::PRIVATE);
+
+ return $this;
+ }
+
+ /**
+ * Makes the method static.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makeStatic() {
+ $this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::STATIC);
+
+ return $this;
+ }
+
+ /**
+ * Makes the method abstract.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makeAbstract() {
+ if (!empty($this->stmts)) {
+ throw new \LogicException('Cannot make method with statements abstract');
+ }
+
+ $this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::ABSTRACT);
+ $this->stmts = null; // abstract methods don't have statements
+
+ return $this;
+ }
+
+ /**
+ * Makes the method final.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makeFinal() {
+ $this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::FINAL);
+
+ return $this;
+ }
+
+ /**
+ * Adds a statement.
+ *
+ * @param Node|PhpParser\Builder $stmt The statement to add
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function addStmt($stmt) {
+ if (null === $this->stmts) {
+ throw new \LogicException('Cannot add statements to an abstract method');
+ }
+
+ $this->stmts[] = BuilderHelpers::normalizeStmt($stmt);
+
+ return $this;
+ }
+
+ /**
+ * Adds an attribute group.
+ *
+ * @param Node\Attribute|Node\AttributeGroup $attribute
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function addAttribute($attribute) {
+ $this->attributeGroups[] = BuilderHelpers::normalizeAttribute($attribute);
+
+ return $this;
+ }
+
+ /**
+ * Returns the built method node.
+ *
+ * @return Stmt\ClassMethod The built method node
+ */
+ public function getNode(): Node {
+ return new Stmt\ClassMethod($this->name, [
+ 'flags' => $this->flags,
+ 'byRef' => $this->returnByRef,
+ 'params' => $this->params,
+ 'returnType' => $this->returnType,
+ 'stmts' => $this->stmts,
+ 'attrGroups' => $this->attributeGroups,
+ ], $this->attributes);
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Builder/Namespace_.php b/vendor/nikic/php-parser/lib/PhpParser/Builder/Namespace_.php
new file mode 100644
index 0000000..80fe6f8
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Builder/Namespace_.php
@@ -0,0 +1,45 @@
+name = null !== $name ? BuilderHelpers::normalizeName($name) : null;
+ }
+
+ /**
+ * Adds a statement.
+ *
+ * @param Node|PhpParser\Builder $stmt The statement to add
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function addStmt($stmt) {
+ $this->stmts[] = BuilderHelpers::normalizeStmt($stmt);
+
+ return $this;
+ }
+
+ /**
+ * Returns the built node.
+ *
+ * @return Stmt\Namespace_ The built node
+ */
+ public function getNode(): Node {
+ return new Stmt\Namespace_($this->name, $this->stmts, $this->attributes);
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Builder/Param.php b/vendor/nikic/php-parser/lib/PhpParser/Builder/Param.php
new file mode 100644
index 0000000..324a32b
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Builder/Param.php
@@ -0,0 +1,171 @@
+ */
+ protected array $attributeGroups = [];
+
+ /**
+ * Creates a parameter builder.
+ *
+ * @param string $name Name of the parameter
+ */
+ public function __construct(string $name) {
+ $this->name = $name;
+ }
+
+ /**
+ * Sets default value for the parameter.
+ *
+ * @param mixed $value Default value to use
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function setDefault($value) {
+ $this->default = BuilderHelpers::normalizeValue($value);
+
+ return $this;
+ }
+
+ /**
+ * Sets type for the parameter.
+ *
+ * @param string|Node\Name|Node\Identifier|Node\ComplexType $type Parameter type
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function setType($type) {
+ $this->type = BuilderHelpers::normalizeType($type);
+ if ($this->type == 'void') {
+ throw new \LogicException('Parameter type cannot be void');
+ }
+
+ return $this;
+ }
+
+ /**
+ * Make the parameter accept the value by reference.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makeByRef() {
+ $this->byRef = true;
+
+ return $this;
+ }
+
+ /**
+ * Make the parameter variadic
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makeVariadic() {
+ $this->variadic = true;
+
+ return $this;
+ }
+
+ /**
+ * Makes the (promoted) parameter public.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makePublic() {
+ $this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::PUBLIC);
+
+ return $this;
+ }
+
+ /**
+ * Makes the (promoted) parameter protected.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makeProtected() {
+ $this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::PROTECTED);
+
+ return $this;
+ }
+
+ /**
+ * Makes the (promoted) parameter private.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makePrivate() {
+ $this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::PRIVATE);
+
+ return $this;
+ }
+
+ /**
+ * Makes the (promoted) parameter readonly.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makeReadonly() {
+ $this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::READONLY);
+
+ return $this;
+ }
+
+ /**
+ * Gives the promoted property private(set) visibility.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makePrivateSet() {
+ $this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::PRIVATE_SET);
+
+ return $this;
+ }
+
+ /**
+ * Gives the promoted property protected(set) visibility.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makeProtectedSet() {
+ $this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::PROTECTED_SET);
+
+ return $this;
+ }
+
+ /**
+ * Adds an attribute group.
+ *
+ * @param Node\Attribute|Node\AttributeGroup $attribute
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function addAttribute($attribute) {
+ $this->attributeGroups[] = BuilderHelpers::normalizeAttribute($attribute);
+
+ return $this;
+ }
+
+ /**
+ * Returns the built parameter node.
+ *
+ * @return Node\Param The built parameter node
+ */
+ public function getNode(): Node {
+ return new Node\Param(
+ new Node\Expr\Variable($this->name),
+ $this->default, $this->type, $this->byRef, $this->variadic, [], $this->flags, $this->attributeGroups
+ );
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Builder/Property.php b/vendor/nikic/php-parser/lib/PhpParser/Builder/Property.php
new file mode 100644
index 0000000..c80fe48
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Builder/Property.php
@@ -0,0 +1,223 @@
+ */
+ protected array $attributes = [];
+ /** @var null|Identifier|Name|ComplexType */
+ protected ?Node $type = null;
+ /** @var list */
+ protected array $attributeGroups = [];
+ /** @var list */
+ protected array $hooks = [];
+
+ /**
+ * Creates a property builder.
+ *
+ * @param string $name Name of the property
+ */
+ public function __construct(string $name) {
+ $this->name = $name;
+ }
+
+ /**
+ * Makes the property public.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makePublic() {
+ $this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::PUBLIC);
+
+ return $this;
+ }
+
+ /**
+ * Makes the property protected.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makeProtected() {
+ $this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::PROTECTED);
+
+ return $this;
+ }
+
+ /**
+ * Makes the property private.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makePrivate() {
+ $this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::PRIVATE);
+
+ return $this;
+ }
+
+ /**
+ * Makes the property static.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makeStatic() {
+ $this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::STATIC);
+
+ return $this;
+ }
+
+ /**
+ * Makes the property readonly.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makeReadonly() {
+ $this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::READONLY);
+
+ return $this;
+ }
+
+ /**
+ * Makes the property abstract. Requires at least one property hook to be specified as well.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makeAbstract() {
+ $this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::ABSTRACT);
+
+ return $this;
+ }
+
+ /**
+ * Makes the property final.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makeFinal() {
+ $this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::FINAL);
+
+ return $this;
+ }
+
+ /**
+ * Gives the property private(set) visibility.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makePrivateSet() {
+ $this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::PRIVATE_SET);
+
+ return $this;
+ }
+
+ /**
+ * Gives the property protected(set) visibility.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makeProtectedSet() {
+ $this->flags = BuilderHelpers::addModifier($this->flags, Modifiers::PROTECTED_SET);
+
+ return $this;
+ }
+
+ /**
+ * Sets default value for the property.
+ *
+ * @param mixed $value Default value to use
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function setDefault($value) {
+ $this->default = BuilderHelpers::normalizeValue($value);
+
+ return $this;
+ }
+
+ /**
+ * Sets doc comment for the property.
+ *
+ * @param PhpParser\Comment\Doc|string $docComment Doc comment to set
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function setDocComment($docComment) {
+ $this->attributes = [
+ 'comments' => [BuilderHelpers::normalizeDocComment($docComment)]
+ ];
+
+ return $this;
+ }
+
+ /**
+ * Sets the property type for PHP 7.4+.
+ *
+ * @param string|Name|Identifier|ComplexType $type
+ *
+ * @return $this
+ */
+ public function setType($type) {
+ $this->type = BuilderHelpers::normalizeType($type);
+
+ return $this;
+ }
+
+ /**
+ * Adds an attribute group.
+ *
+ * @param Node\Attribute|Node\AttributeGroup $attribute
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function addAttribute($attribute) {
+ $this->attributeGroups[] = BuilderHelpers::normalizeAttribute($attribute);
+
+ return $this;
+ }
+
+ /**
+ * Adds a property hook.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function addHook(Node\PropertyHook $hook) {
+ $this->hooks[] = $hook;
+
+ return $this;
+ }
+
+ /**
+ * Returns the built class node.
+ *
+ * @return Stmt\Property The built property node
+ */
+ public function getNode(): PhpParser\Node {
+ if ($this->flags & Modifiers::ABSTRACT && !$this->hooks) {
+ throw new PhpParser\Error('Only hooked properties may be declared abstract');
+ }
+
+ return new Stmt\Property(
+ $this->flags !== 0 ? $this->flags : Modifiers::PUBLIC,
+ [
+ new Node\PropertyItem($this->name, $this->default)
+ ],
+ $this->attributes,
+ $this->type,
+ $this->attributeGroups,
+ $this->hooks
+ );
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Builder/TraitUse.php b/vendor/nikic/php-parser/lib/PhpParser/Builder/TraitUse.php
new file mode 100644
index 0000000..cf21c82
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Builder/TraitUse.php
@@ -0,0 +1,65 @@
+and($trait);
+ }
+ }
+
+ /**
+ * Adds used trait.
+ *
+ * @param Node\Name|string $trait Trait name
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function and($trait) {
+ $this->traits[] = BuilderHelpers::normalizeName($trait);
+ return $this;
+ }
+
+ /**
+ * Adds trait adaptation.
+ *
+ * @param Stmt\TraitUseAdaptation|Builder\TraitUseAdaptation $adaptation Trait adaptation
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function with($adaptation) {
+ $adaptation = BuilderHelpers::normalizeNode($adaptation);
+
+ if (!$adaptation instanceof Stmt\TraitUseAdaptation) {
+ throw new \LogicException('Adaptation must have type TraitUseAdaptation');
+ }
+
+ $this->adaptations[] = $adaptation;
+ return $this;
+ }
+
+ /**
+ * Returns the built node.
+ *
+ * @return Node The built node
+ */
+ public function getNode(): Node {
+ return new Stmt\TraitUse($this->traits, $this->adaptations);
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Builder/TraitUseAdaptation.php b/vendor/nikic/php-parser/lib/PhpParser/Builder/TraitUseAdaptation.php
new file mode 100644
index 0000000..fee0958
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Builder/TraitUseAdaptation.php
@@ -0,0 +1,145 @@
+type = self::TYPE_UNDEFINED;
+
+ $this->trait = is_null($trait) ? null : BuilderHelpers::normalizeName($trait);
+ $this->method = BuilderHelpers::normalizeIdentifier($method);
+ }
+
+ /**
+ * Sets alias of method.
+ *
+ * @param Node\Identifier|string $alias Alias for adapted method
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function as($alias) {
+ if ($this->type === self::TYPE_UNDEFINED) {
+ $this->type = self::TYPE_ALIAS;
+ }
+
+ if ($this->type !== self::TYPE_ALIAS) {
+ throw new \LogicException('Cannot set alias for not alias adaptation buider');
+ }
+
+ $this->alias = BuilderHelpers::normalizeIdentifier($alias);
+ return $this;
+ }
+
+ /**
+ * Sets adapted method public.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makePublic() {
+ $this->setModifier(Modifiers::PUBLIC);
+ return $this;
+ }
+
+ /**
+ * Sets adapted method protected.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makeProtected() {
+ $this->setModifier(Modifiers::PROTECTED);
+ return $this;
+ }
+
+ /**
+ * Sets adapted method private.
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function makePrivate() {
+ $this->setModifier(Modifiers::PRIVATE);
+ return $this;
+ }
+
+ /**
+ * Adds overwritten traits.
+ *
+ * @param Node\Name|string ...$traits Traits for overwrite
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function insteadof(...$traits) {
+ if ($this->type === self::TYPE_UNDEFINED) {
+ if (is_null($this->trait)) {
+ throw new \LogicException('Precedence adaptation must have trait');
+ }
+
+ $this->type = self::TYPE_PRECEDENCE;
+ }
+
+ if ($this->type !== self::TYPE_PRECEDENCE) {
+ throw new \LogicException('Cannot add overwritten traits for not precedence adaptation buider');
+ }
+
+ foreach ($traits as $trait) {
+ $this->insteadof[] = BuilderHelpers::normalizeName($trait);
+ }
+
+ return $this;
+ }
+
+ protected function setModifier(int $modifier): void {
+ if ($this->type === self::TYPE_UNDEFINED) {
+ $this->type = self::TYPE_ALIAS;
+ }
+
+ if ($this->type !== self::TYPE_ALIAS) {
+ throw new \LogicException('Cannot set access modifier for not alias adaptation buider');
+ }
+
+ if (is_null($this->modifier)) {
+ $this->modifier = $modifier;
+ } else {
+ throw new \LogicException('Multiple access type modifiers are not allowed');
+ }
+ }
+
+ /**
+ * Returns the built node.
+ *
+ * @return Node The built node
+ */
+ public function getNode(): Node {
+ switch ($this->type) {
+ case self::TYPE_ALIAS:
+ return new Stmt\TraitUseAdaptation\Alias($this->trait, $this->method, $this->modifier, $this->alias);
+ case self::TYPE_PRECEDENCE:
+ return new Stmt\TraitUseAdaptation\Precedence($this->trait, $this->method, $this->insteadof);
+ default:
+ throw new \LogicException('Type of adaptation is not defined');
+ }
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Builder/Trait_.php b/vendor/nikic/php-parser/lib/PhpParser/Builder/Trait_.php
new file mode 100644
index 0000000..ffa1bd5
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Builder/Trait_.php
@@ -0,0 +1,83 @@
+ */
+ protected array $uses = [];
+ /** @var list */
+ protected array $constants = [];
+ /** @var list */
+ protected array $properties = [];
+ /** @var list */
+ protected array $methods = [];
+ /** @var list */
+ protected array $attributeGroups = [];
+
+ /**
+ * Creates an interface builder.
+ *
+ * @param string $name Name of the interface
+ */
+ public function __construct(string $name) {
+ $this->name = $name;
+ }
+
+ /**
+ * Adds a statement.
+ *
+ * @param Stmt|PhpParser\Builder $stmt The statement to add
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function addStmt($stmt) {
+ $stmt = BuilderHelpers::normalizeNode($stmt);
+
+ if ($stmt instanceof Stmt\Property) {
+ $this->properties[] = $stmt;
+ } elseif ($stmt instanceof Stmt\ClassMethod) {
+ $this->methods[] = $stmt;
+ } elseif ($stmt instanceof Stmt\TraitUse) {
+ $this->uses[] = $stmt;
+ } elseif ($stmt instanceof Stmt\ClassConst) {
+ $this->constants[] = $stmt;
+ } else {
+ throw new \LogicException(sprintf('Unexpected node of type "%s"', $stmt->getType()));
+ }
+
+ return $this;
+ }
+
+ /**
+ * Adds an attribute group.
+ *
+ * @param Node\Attribute|Node\AttributeGroup $attribute
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function addAttribute($attribute) {
+ $this->attributeGroups[] = BuilderHelpers::normalizeAttribute($attribute);
+
+ return $this;
+ }
+
+ /**
+ * Returns the built trait node.
+ *
+ * @return Stmt\Trait_ The built interface node
+ */
+ public function getNode(): PhpParser\Node {
+ return new Stmt\Trait_(
+ $this->name, [
+ 'stmts' => array_merge($this->uses, $this->constants, $this->properties, $this->methods),
+ 'attrGroups' => $this->attributeGroups,
+ ], $this->attributes
+ );
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Builder/Use_.php b/vendor/nikic/php-parser/lib/PhpParser/Builder/Use_.php
new file mode 100644
index 0000000..b82cf13
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Builder/Use_.php
@@ -0,0 +1,49 @@
+name = BuilderHelpers::normalizeName($name);
+ $this->type = $type;
+ }
+
+ /**
+ * Sets alias for used name.
+ *
+ * @param string $alias Alias to use (last component of full name by default)
+ *
+ * @return $this The builder instance (for fluid interface)
+ */
+ public function as(string $alias) {
+ $this->alias = $alias;
+ return $this;
+ }
+
+ /**
+ * Returns the built node.
+ *
+ * @return Stmt\Use_ The built node
+ */
+ public function getNode(): Node {
+ return new Stmt\Use_([
+ new Node\UseItem($this->name, $this->alias)
+ ], $this->type);
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/BuilderFactory.php b/vendor/nikic/php-parser/lib/PhpParser/BuilderFactory.php
new file mode 100644
index 0000000..07642f9
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/BuilderFactory.php
@@ -0,0 +1,375 @@
+args($args)
+ );
+ }
+
+ /**
+ * Creates a namespace builder.
+ *
+ * @param null|string|Node\Name $name Name of the namespace
+ *
+ * @return Builder\Namespace_ The created namespace builder
+ */
+ public function namespace($name): Builder\Namespace_ {
+ return new Builder\Namespace_($name);
+ }
+
+ /**
+ * Creates a class builder.
+ *
+ * @param string $name Name of the class
+ *
+ * @return Builder\Class_ The created class builder
+ */
+ public function class(string $name): Builder\Class_ {
+ return new Builder\Class_($name);
+ }
+
+ /**
+ * Creates an interface builder.
+ *
+ * @param string $name Name of the interface
+ *
+ * @return Builder\Interface_ The created interface builder
+ */
+ public function interface(string $name): Builder\Interface_ {
+ return new Builder\Interface_($name);
+ }
+
+ /**
+ * Creates a trait builder.
+ *
+ * @param string $name Name of the trait
+ *
+ * @return Builder\Trait_ The created trait builder
+ */
+ public function trait(string $name): Builder\Trait_ {
+ return new Builder\Trait_($name);
+ }
+
+ /**
+ * Creates an enum builder.
+ *
+ * @param string $name Name of the enum
+ *
+ * @return Builder\Enum_ The created enum builder
+ */
+ public function enum(string $name): Builder\Enum_ {
+ return new Builder\Enum_($name);
+ }
+
+ /**
+ * Creates a trait use builder.
+ *
+ * @param Node\Name|string ...$traits Trait names
+ *
+ * @return Builder\TraitUse The created trait use builder
+ */
+ public function useTrait(...$traits): Builder\TraitUse {
+ return new Builder\TraitUse(...$traits);
+ }
+
+ /**
+ * Creates a trait use adaptation builder.
+ *
+ * @param Node\Name|string|null $trait Trait name
+ * @param Node\Identifier|string $method Method name
+ *
+ * @return Builder\TraitUseAdaptation The created trait use adaptation builder
+ */
+ public function traitUseAdaptation($trait, $method = null): Builder\TraitUseAdaptation {
+ if ($method === null) {
+ $method = $trait;
+ $trait = null;
+ }
+
+ return new Builder\TraitUseAdaptation($trait, $method);
+ }
+
+ /**
+ * Creates a method builder.
+ *
+ * @param string $name Name of the method
+ *
+ * @return Builder\Method The created method builder
+ */
+ public function method(string $name): Builder\Method {
+ return new Builder\Method($name);
+ }
+
+ /**
+ * Creates a parameter builder.
+ *
+ * @param string $name Name of the parameter
+ *
+ * @return Builder\Param The created parameter builder
+ */
+ public function param(string $name): Builder\Param {
+ return new Builder\Param($name);
+ }
+
+ /**
+ * Creates a property builder.
+ *
+ * @param string $name Name of the property
+ *
+ * @return Builder\Property The created property builder
+ */
+ public function property(string $name): Builder\Property {
+ return new Builder\Property($name);
+ }
+
+ /**
+ * Creates a function builder.
+ *
+ * @param string $name Name of the function
+ *
+ * @return Builder\Function_ The created function builder
+ */
+ public function function(string $name): Builder\Function_ {
+ return new Builder\Function_($name);
+ }
+
+ /**
+ * Creates a namespace/class use builder.
+ *
+ * @param Node\Name|string $name Name of the entity (namespace or class) to alias
+ *
+ * @return Builder\Use_ The created use builder
+ */
+ public function use($name): Builder\Use_ {
+ return new Builder\Use_($name, Use_::TYPE_NORMAL);
+ }
+
+ /**
+ * Creates a function use builder.
+ *
+ * @param Node\Name|string $name Name of the function to alias
+ *
+ * @return Builder\Use_ The created use function builder
+ */
+ public function useFunction($name): Builder\Use_ {
+ return new Builder\Use_($name, Use_::TYPE_FUNCTION);
+ }
+
+ /**
+ * Creates a constant use builder.
+ *
+ * @param Node\Name|string $name Name of the const to alias
+ *
+ * @return Builder\Use_ The created use const builder
+ */
+ public function useConst($name): Builder\Use_ {
+ return new Builder\Use_($name, Use_::TYPE_CONSTANT);
+ }
+
+ /**
+ * Creates a class constant builder.
+ *
+ * @param string|Identifier $name Name
+ * @param Node\Expr|bool|null|int|float|string|array $value Value
+ *
+ * @return Builder\ClassConst The created use const builder
+ */
+ public function classConst($name, $value): Builder\ClassConst {
+ return new Builder\ClassConst($name, $value);
+ }
+
+ /**
+ * Creates an enum case builder.
+ *
+ * @param string|Identifier $name Name
+ *
+ * @return Builder\EnumCase The created use const builder
+ */
+ public function enumCase($name): Builder\EnumCase {
+ return new Builder\EnumCase($name);
+ }
+
+ /**
+ * Creates node a for a literal value.
+ *
+ * @param Expr|bool|null|int|float|string|array|\UnitEnum $value $value
+ */
+ public function val($value): Expr {
+ return BuilderHelpers::normalizeValue($value);
+ }
+
+ /**
+ * Creates variable node.
+ *
+ * @param string|Expr $name Name
+ */
+ public function var($name): Expr\Variable {
+ if (!\is_string($name) && !$name instanceof Expr) {
+ throw new \LogicException('Variable name must be string or Expr');
+ }
+
+ return new Expr\Variable($name);
+ }
+
+ /**
+ * Normalizes an argument list.
+ *
+ * Creates Arg nodes for all arguments and converts literal values to expressions.
+ *
+ * @param array $args List of arguments to normalize
+ *
+ * @return list
+ */
+ public function args(array $args): array {
+ $normalizedArgs = [];
+ foreach ($args as $key => $arg) {
+ if (!($arg instanceof Arg)) {
+ $arg = new Arg(BuilderHelpers::normalizeValue($arg));
+ }
+ if (\is_string($key)) {
+ $arg->name = BuilderHelpers::normalizeIdentifier($key);
+ }
+ $normalizedArgs[] = $arg;
+ }
+ return $normalizedArgs;
+ }
+
+ /**
+ * Creates a function call node.
+ *
+ * @param string|Name|Expr $name Function name
+ * @param array $args Function arguments
+ */
+ public function funcCall($name, array $args = []): Expr\FuncCall {
+ return new Expr\FuncCall(
+ BuilderHelpers::normalizeNameOrExpr($name),
+ $this->args($args)
+ );
+ }
+
+ /**
+ * Creates a method call node.
+ *
+ * @param Expr $var Variable the method is called on
+ * @param string|Identifier|Expr $name Method name
+ * @param array $args Method arguments
+ */
+ public function methodCall(Expr $var, $name, array $args = []): Expr\MethodCall {
+ return new Expr\MethodCall(
+ $var,
+ BuilderHelpers::normalizeIdentifierOrExpr($name),
+ $this->args($args)
+ );
+ }
+
+ /**
+ * Creates a static method call node.
+ *
+ * @param string|Name|Expr $class Class name
+ * @param string|Identifier|Expr $name Method name
+ * @param array $args Method arguments
+ */
+ public function staticCall($class, $name, array $args = []): Expr\StaticCall {
+ return new Expr\StaticCall(
+ BuilderHelpers::normalizeNameOrExpr($class),
+ BuilderHelpers::normalizeIdentifierOrExpr($name),
+ $this->args($args)
+ );
+ }
+
+ /**
+ * Creates an object creation node.
+ *
+ * @param string|Name|Expr $class Class name
+ * @param array $args Constructor arguments
+ */
+ public function new($class, array $args = []): Expr\New_ {
+ return new Expr\New_(
+ BuilderHelpers::normalizeNameOrExpr($class),
+ $this->args($args)
+ );
+ }
+
+ /**
+ * Creates a constant fetch node.
+ *
+ * @param string|Name $name Constant name
+ */
+ public function constFetch($name): Expr\ConstFetch {
+ return new Expr\ConstFetch(BuilderHelpers::normalizeName($name));
+ }
+
+ /**
+ * Creates a property fetch node.
+ *
+ * @param Expr $var Variable holding object
+ * @param string|Identifier|Expr $name Property name
+ */
+ public function propertyFetch(Expr $var, $name): Expr\PropertyFetch {
+ return new Expr\PropertyFetch($var, BuilderHelpers::normalizeIdentifierOrExpr($name));
+ }
+
+ /**
+ * Creates a class constant fetch node.
+ *
+ * @param string|Name|Expr $class Class name
+ * @param string|Identifier|Expr $name Constant name
+ */
+ public function classConstFetch($class, $name): Expr\ClassConstFetch {
+ return new Expr\ClassConstFetch(
+ BuilderHelpers::normalizeNameOrExpr($class),
+ BuilderHelpers::normalizeIdentifierOrExpr($name)
+ );
+ }
+
+ /**
+ * Creates nested Concat nodes from a list of expressions.
+ *
+ * @param Expr|string ...$exprs Expressions or literal strings
+ */
+ public function concat(...$exprs): Concat {
+ $numExprs = count($exprs);
+ if ($numExprs < 2) {
+ throw new \LogicException('Expected at least two expressions');
+ }
+
+ $lastConcat = $this->normalizeStringExpr($exprs[0]);
+ for ($i = 1; $i < $numExprs; $i++) {
+ $lastConcat = new Concat($lastConcat, $this->normalizeStringExpr($exprs[$i]));
+ }
+ return $lastConcat;
+ }
+
+ /**
+ * @param string|Expr $expr
+ */
+ private function normalizeStringExpr($expr): Expr {
+ if ($expr instanceof Expr) {
+ return $expr;
+ }
+
+ if (\is_string($expr)) {
+ return new String_($expr);
+ }
+
+ throw new \LogicException('Expected string or Expr');
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/BuilderHelpers.php b/vendor/nikic/php-parser/lib/PhpParser/BuilderHelpers.php
new file mode 100644
index 0000000..f29a691
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/BuilderHelpers.php
@@ -0,0 +1,338 @@
+getNode();
+ }
+
+ if ($node instanceof Node) {
+ return $node;
+ }
+
+ throw new \LogicException('Expected node or builder object');
+ }
+
+ /**
+ * Normalizes a node to a statement.
+ *
+ * Expressions are wrapped in a Stmt\Expression node.
+ *
+ * @param Node|Builder $node The node to normalize
+ *
+ * @return Stmt The normalized statement node
+ */
+ public static function normalizeStmt($node): Stmt {
+ $node = self::normalizeNode($node);
+ if ($node instanceof Stmt) {
+ return $node;
+ }
+
+ if ($node instanceof Expr) {
+ return new Stmt\Expression($node);
+ }
+
+ throw new \LogicException('Expected statement or expression node');
+ }
+
+ /**
+ * Normalizes strings to Identifier.
+ *
+ * @param string|Identifier $name The identifier to normalize
+ *
+ * @return Identifier The normalized identifier
+ */
+ public static function normalizeIdentifier($name): Identifier {
+ if ($name instanceof Identifier) {
+ return $name;
+ }
+
+ if (\is_string($name)) {
+ return new Identifier($name);
+ }
+
+ throw new \LogicException('Expected string or instance of Node\Identifier');
+ }
+
+ /**
+ * Normalizes strings to Identifier, also allowing expressions.
+ *
+ * @param string|Identifier|Expr $name The identifier to normalize
+ *
+ * @return Identifier|Expr The normalized identifier or expression
+ */
+ public static function normalizeIdentifierOrExpr($name) {
+ if ($name instanceof Identifier || $name instanceof Expr) {
+ return $name;
+ }
+
+ if (\is_string($name)) {
+ return new Identifier($name);
+ }
+
+ throw new \LogicException('Expected string or instance of Node\Identifier or Node\Expr');
+ }
+
+ /**
+ * Normalizes a name: Converts string names to Name nodes.
+ *
+ * @param Name|string $name The name to normalize
+ *
+ * @return Name The normalized name
+ */
+ public static function normalizeName($name): Name {
+ if ($name instanceof Name) {
+ return $name;
+ }
+
+ if (is_string($name)) {
+ if (!$name) {
+ throw new \LogicException('Name cannot be empty');
+ }
+
+ if ($name[0] === '\\') {
+ return new Name\FullyQualified(substr($name, 1));
+ }
+
+ if (0 === strpos($name, 'namespace\\')) {
+ return new Name\Relative(substr($name, strlen('namespace\\')));
+ }
+
+ return new Name($name);
+ }
+
+ throw new \LogicException('Name must be a string or an instance of Node\Name');
+ }
+
+ /**
+ * Normalizes a name: Converts string names to Name nodes, while also allowing expressions.
+ *
+ * @param Expr|Name|string $name The name to normalize
+ *
+ * @return Name|Expr The normalized name or expression
+ */
+ public static function normalizeNameOrExpr($name) {
+ if ($name instanceof Expr) {
+ return $name;
+ }
+
+ if (!is_string($name) && !($name instanceof Name)) {
+ throw new \LogicException(
+ 'Name must be a string or an instance of Node\Name or Node\Expr'
+ );
+ }
+
+ return self::normalizeName($name);
+ }
+
+ /**
+ * Normalizes a type: Converts plain-text type names into proper AST representation.
+ *
+ * In particular, builtin types become Identifiers, custom types become Names and nullables
+ * are wrapped in NullableType nodes.
+ *
+ * @param string|Name|Identifier|ComplexType $type The type to normalize
+ *
+ * @return Name|Identifier|ComplexType The normalized type
+ */
+ public static function normalizeType($type) {
+ if (!is_string($type)) {
+ if (
+ !$type instanceof Name && !$type instanceof Identifier &&
+ !$type instanceof ComplexType
+ ) {
+ throw new \LogicException(
+ 'Type must be a string, or an instance of Name, Identifier or ComplexType'
+ );
+ }
+ return $type;
+ }
+
+ $nullable = false;
+ if (strlen($type) > 0 && $type[0] === '?') {
+ $nullable = true;
+ $type = substr($type, 1);
+ }
+
+ $builtinTypes = [
+ 'array',
+ 'callable',
+ 'bool',
+ 'int',
+ 'float',
+ 'string',
+ 'iterable',
+ 'void',
+ 'object',
+ 'null',
+ 'false',
+ 'mixed',
+ 'never',
+ 'true',
+ ];
+
+ $lowerType = strtolower($type);
+ if (in_array($lowerType, $builtinTypes)) {
+ $type = new Identifier($lowerType);
+ } else {
+ $type = self::normalizeName($type);
+ }
+
+ $notNullableTypes = [
+ 'void', 'mixed', 'never',
+ ];
+ if ($nullable && in_array((string) $type, $notNullableTypes)) {
+ throw new \LogicException(sprintf('%s type cannot be nullable', $type));
+ }
+
+ return $nullable ? new NullableType($type) : $type;
+ }
+
+ /**
+ * Normalizes a value: Converts nulls, booleans, integers,
+ * floats, strings and arrays into their respective nodes
+ *
+ * @param Node\Expr|bool|null|int|float|string|array|\UnitEnum $value The value to normalize
+ *
+ * @return Expr The normalized value
+ */
+ public static function normalizeValue($value): Expr {
+ if ($value instanceof Node\Expr) {
+ return $value;
+ }
+
+ if (is_null($value)) {
+ return new Expr\ConstFetch(
+ new Name('null')
+ );
+ }
+
+ if (is_bool($value)) {
+ return new Expr\ConstFetch(
+ new Name($value ? 'true' : 'false')
+ );
+ }
+
+ if (is_int($value)) {
+ return new Scalar\Int_($value);
+ }
+
+ if (is_float($value)) {
+ return new Scalar\Float_($value);
+ }
+
+ if (is_string($value)) {
+ return new Scalar\String_($value);
+ }
+
+ if (is_array($value)) {
+ $items = [];
+ $lastKey = -1;
+ foreach ($value as $itemKey => $itemValue) {
+ // for consecutive, numeric keys don't generate keys
+ if (null !== $lastKey && ++$lastKey === $itemKey) {
+ $items[] = new Node\ArrayItem(
+ self::normalizeValue($itemValue)
+ );
+ } else {
+ $lastKey = null;
+ $items[] = new Node\ArrayItem(
+ self::normalizeValue($itemValue),
+ self::normalizeValue($itemKey)
+ );
+ }
+ }
+
+ return new Expr\Array_($items);
+ }
+
+ if ($value instanceof \UnitEnum) {
+ return new Expr\ClassConstFetch(new FullyQualified(\get_class($value)), new Identifier($value->name));
+ }
+
+ throw new \LogicException('Invalid value');
+ }
+
+ /**
+ * Normalizes a doc comment: Converts plain strings to PhpParser\Comment\Doc.
+ *
+ * @param Comment\Doc|string $docComment The doc comment to normalize
+ *
+ * @return Comment\Doc The normalized doc comment
+ */
+ public static function normalizeDocComment($docComment): Comment\Doc {
+ if ($docComment instanceof Comment\Doc) {
+ return $docComment;
+ }
+
+ if (is_string($docComment)) {
+ return new Comment\Doc($docComment);
+ }
+
+ throw new \LogicException('Doc comment must be a string or an instance of PhpParser\Comment\Doc');
+ }
+
+ /**
+ * Normalizes a attribute: Converts attribute to the Attribute Group if needed.
+ *
+ * @param Node\Attribute|Node\AttributeGroup $attribute
+ *
+ * @return Node\AttributeGroup The Attribute Group
+ */
+ public static function normalizeAttribute($attribute): Node\AttributeGroup {
+ if ($attribute instanceof Node\AttributeGroup) {
+ return $attribute;
+ }
+
+ if (!($attribute instanceof Node\Attribute)) {
+ throw new \LogicException('Attribute must be an instance of PhpParser\Node\Attribute or PhpParser\Node\AttributeGroup');
+ }
+
+ return new Node\AttributeGroup([$attribute]);
+ }
+
+ /**
+ * Adds a modifier and returns new modifier bitmask.
+ *
+ * @param int $modifiers Existing modifiers
+ * @param int $modifier Modifier to set
+ *
+ * @return int New modifiers
+ */
+ public static function addModifier(int $modifiers, int $modifier): int {
+ Modifiers::verifyModifier($modifiers, $modifier);
+ return $modifiers | $modifier;
+ }
+
+ /**
+ * Adds a modifier and returns new modifier bitmask.
+ * @return int New modifiers
+ */
+ public static function addClassModifier(int $existingModifiers, int $modifierToSet): int {
+ Modifiers::verifyClassModifier($existingModifiers, $modifierToSet);
+ return $existingModifiers | $modifierToSet;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Comment.php b/vendor/nikic/php-parser/lib/PhpParser/Comment.php
new file mode 100644
index 0000000..01b341e
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Comment.php
@@ -0,0 +1,209 @@
+text = $text;
+ $this->startLine = $startLine;
+ $this->startFilePos = $startFilePos;
+ $this->startTokenPos = $startTokenPos;
+ $this->endLine = $endLine;
+ $this->endFilePos = $endFilePos;
+ $this->endTokenPos = $endTokenPos;
+ }
+
+ /**
+ * Gets the comment text.
+ *
+ * @return string The comment text (including comment delimiters like /*)
+ */
+ public function getText(): string {
+ return $this->text;
+ }
+
+ /**
+ * Gets the line number the comment started on.
+ *
+ * @return int Line number (or -1 if not available)
+ * @phpstan-return -1|positive-int
+ */
+ public function getStartLine(): int {
+ return $this->startLine;
+ }
+
+ /**
+ * Gets the file offset the comment started on.
+ *
+ * @return int File offset (or -1 if not available)
+ */
+ public function getStartFilePos(): int {
+ return $this->startFilePos;
+ }
+
+ /**
+ * Gets the token offset the comment started on.
+ *
+ * @return int Token offset (or -1 if not available)
+ */
+ public function getStartTokenPos(): int {
+ return $this->startTokenPos;
+ }
+
+ /**
+ * Gets the line number the comment ends on.
+ *
+ * @return int Line number (or -1 if not available)
+ * @phpstan-return -1|positive-int
+ */
+ public function getEndLine(): int {
+ return $this->endLine;
+ }
+
+ /**
+ * Gets the file offset the comment ends on.
+ *
+ * @return int File offset (or -1 if not available)
+ */
+ public function getEndFilePos(): int {
+ return $this->endFilePos;
+ }
+
+ /**
+ * Gets the token offset the comment ends on.
+ *
+ * @return int Token offset (or -1 if not available)
+ */
+ public function getEndTokenPos(): int {
+ return $this->endTokenPos;
+ }
+
+ /**
+ * Gets the comment text.
+ *
+ * @return string The comment text (including comment delimiters like /*)
+ */
+ public function __toString(): string {
+ return $this->text;
+ }
+
+ /**
+ * Gets the reformatted comment text.
+ *
+ * "Reformatted" here means that we try to clean up the whitespace at the
+ * starts of the lines. This is necessary because we receive the comments
+ * without leading whitespace on the first line, but with leading whitespace
+ * on all subsequent lines.
+ *
+ * Additionally, this normalizes CRLF newlines to LF newlines.
+ */
+ public function getReformattedText(): string {
+ $text = str_replace("\r\n", "\n", $this->text);
+ $newlinePos = strpos($text, "\n");
+ if (false === $newlinePos) {
+ // Single line comments don't need further processing
+ return $text;
+ }
+ if (preg_match('(^.*(?:\n\s+\*.*)+$)', $text)) {
+ // Multi line comment of the type
+ //
+ // /*
+ // * Some text.
+ // * Some more text.
+ // */
+ //
+ // is handled by replacing the whitespace sequences before the * by a single space
+ return preg_replace('(^\s+\*)m', ' *', $text);
+ }
+ if (preg_match('(^/\*\*?\s*\n)', $text) && preg_match('(\n(\s*)\*/$)', $text, $matches)) {
+ // Multi line comment of the type
+ //
+ // /*
+ // Some text.
+ // Some more text.
+ // */
+ //
+ // is handled by removing the whitespace sequence on the line before the closing
+ // */ on all lines. So if the last line is " */", then " " is removed at the
+ // start of all lines.
+ return preg_replace('(^' . preg_quote($matches[1]) . ')m', '', $text);
+ }
+ if (preg_match('(^/\*\*?\s*(?!\s))', $text, $matches)) {
+ // Multi line comment of the type
+ //
+ // /* Some text.
+ // Some more text.
+ // Indented text.
+ // Even more text. */
+ //
+ // is handled by removing the difference between the shortest whitespace prefix on all
+ // lines and the length of the "/* " opening sequence.
+ $prefixLen = $this->getShortestWhitespacePrefixLen(substr($text, $newlinePos + 1));
+ $removeLen = $prefixLen - strlen($matches[0]);
+ return preg_replace('(^\s{' . $removeLen . '})m', '', $text);
+ }
+
+ // No idea how to format this comment, so simply return as is
+ return $text;
+ }
+
+ /**
+ * Get length of shortest whitespace prefix (at the start of a line).
+ *
+ * If there is a line with no prefix whitespace, 0 is a valid return value.
+ *
+ * @param string $str String to check
+ * @return int Length in characters. Tabs count as single characters.
+ */
+ private function getShortestWhitespacePrefixLen(string $str): int {
+ $lines = explode("\n", $str);
+ $shortestPrefixLen = \PHP_INT_MAX;
+ foreach ($lines as $line) {
+ preg_match('(^\s*)', $line, $matches);
+ $prefixLen = strlen($matches[0]);
+ if ($prefixLen < $shortestPrefixLen) {
+ $shortestPrefixLen = $prefixLen;
+ }
+ }
+ return $shortestPrefixLen;
+ }
+
+ /**
+ * @return array{nodeType:string, text:mixed, line:mixed, filePos:mixed}
+ */
+ public function jsonSerialize(): array {
+ // Technically not a node, but we make it look like one anyway
+ $type = $this instanceof Comment\Doc ? 'Comment_Doc' : 'Comment';
+ return [
+ 'nodeType' => $type,
+ 'text' => $this->text,
+ // TODO: Rename these to include "start".
+ 'line' => $this->startLine,
+ 'filePos' => $this->startFilePos,
+ 'tokenPos' => $this->startTokenPos,
+ 'endLine' => $this->endLine,
+ 'endFilePos' => $this->endFilePos,
+ 'endTokenPos' => $this->endTokenPos,
+ ];
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Comment/Doc.php b/vendor/nikic/php-parser/lib/PhpParser/Comment/Doc.php
new file mode 100644
index 0000000..bb3e914
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Comment/Doc.php
@@ -0,0 +1,6 @@
+fallbackEvaluator = $fallbackEvaluator ?? function (Expr $expr) {
+ throw new ConstExprEvaluationException(
+ "Expression of type {$expr->getType()} cannot be evaluated"
+ );
+ };
+ }
+
+ /**
+ * Silently evaluates a constant expression into a PHP value.
+ *
+ * Thrown Errors, warnings or notices will be converted into a ConstExprEvaluationException.
+ * The original source of the exception is available through getPrevious().
+ *
+ * If some part of the expression cannot be evaluated, the fallback evaluator passed to the
+ * constructor will be invoked. By default, if no fallback is provided, an exception of type
+ * ConstExprEvaluationException is thrown.
+ *
+ * See class doc comment for caveats and limitations.
+ *
+ * @param Expr $expr Constant expression to evaluate
+ * @return mixed Result of evaluation
+ *
+ * @throws ConstExprEvaluationException if the expression cannot be evaluated or an error occurred
+ */
+ public function evaluateSilently(Expr $expr) {
+ set_error_handler(function ($num, $str, $file, $line) {
+ throw new \ErrorException($str, 0, $num, $file, $line);
+ });
+
+ try {
+ return $this->evaluate($expr);
+ } catch (\Throwable $e) {
+ if (!$e instanceof ConstExprEvaluationException) {
+ $e = new ConstExprEvaluationException(
+ "An error occurred during constant expression evaluation", 0, $e);
+ }
+ throw $e;
+ } finally {
+ restore_error_handler();
+ }
+ }
+
+ /**
+ * Directly evaluates a constant expression into a PHP value.
+ *
+ * May generate Error exceptions, warnings or notices. Use evaluateSilently() to convert these
+ * into a ConstExprEvaluationException.
+ *
+ * If some part of the expression cannot be evaluated, the fallback evaluator passed to the
+ * constructor will be invoked. By default, if no fallback is provided, an exception of type
+ * ConstExprEvaluationException is thrown.
+ *
+ * See class doc comment for caveats and limitations.
+ *
+ * @param Expr $expr Constant expression to evaluate
+ * @return mixed Result of evaluation
+ *
+ * @throws ConstExprEvaluationException if the expression cannot be evaluated
+ */
+ public function evaluateDirectly(Expr $expr) {
+ return $this->evaluate($expr);
+ }
+
+ /** @return mixed */
+ private function evaluate(Expr $expr) {
+ if ($expr instanceof Scalar\Int_
+ || $expr instanceof Scalar\Float_
+ || $expr instanceof Scalar\String_
+ ) {
+ return $expr->value;
+ }
+
+ if ($expr instanceof Expr\Array_) {
+ return $this->evaluateArray($expr);
+ }
+
+ // Unary operators
+ if ($expr instanceof Expr\UnaryPlus) {
+ return +$this->evaluate($expr->expr);
+ }
+ if ($expr instanceof Expr\UnaryMinus) {
+ return -$this->evaluate($expr->expr);
+ }
+ if ($expr instanceof Expr\BooleanNot) {
+ return !$this->evaluate($expr->expr);
+ }
+ if ($expr instanceof Expr\BitwiseNot) {
+ return ~$this->evaluate($expr->expr);
+ }
+
+ if ($expr instanceof Expr\BinaryOp) {
+ return $this->evaluateBinaryOp($expr);
+ }
+
+ if ($expr instanceof Expr\Ternary) {
+ return $this->evaluateTernary($expr);
+ }
+
+ if ($expr instanceof Expr\ArrayDimFetch && null !== $expr->dim) {
+ return $this->evaluate($expr->var)[$this->evaluate($expr->dim)];
+ }
+
+ if ($expr instanceof Expr\ConstFetch) {
+ return $this->evaluateConstFetch($expr);
+ }
+
+ return ($this->fallbackEvaluator)($expr);
+ }
+
+ private function evaluateArray(Expr\Array_ $expr): array {
+ $array = [];
+ foreach ($expr->items as $item) {
+ if (null !== $item->key) {
+ $array[$this->evaluate($item->key)] = $this->evaluate($item->value);
+ } elseif ($item->unpack) {
+ $array = array_merge($array, $this->evaluate($item->value));
+ } else {
+ $array[] = $this->evaluate($item->value);
+ }
+ }
+ return $array;
+ }
+
+ /** @return mixed */
+ private function evaluateTernary(Expr\Ternary $expr) {
+ if (null === $expr->if) {
+ return $this->evaluate($expr->cond) ?: $this->evaluate($expr->else);
+ }
+
+ return $this->evaluate($expr->cond)
+ ? $this->evaluate($expr->if)
+ : $this->evaluate($expr->else);
+ }
+
+ /** @return mixed */
+ private function evaluateBinaryOp(Expr\BinaryOp $expr) {
+ if ($expr instanceof Expr\BinaryOp\Coalesce
+ && $expr->left instanceof Expr\ArrayDimFetch
+ ) {
+ // This needs to be special cased to respect BP_VAR_IS fetch semantics
+ return $this->evaluate($expr->left->var)[$this->evaluate($expr->left->dim)]
+ ?? $this->evaluate($expr->right);
+ }
+
+ // The evaluate() calls are repeated in each branch, because some of the operators are
+ // short-circuiting and evaluating the RHS in advance may be illegal in that case
+ $l = $expr->left;
+ $r = $expr->right;
+ switch ($expr->getOperatorSigil()) {
+ case '&': return $this->evaluate($l) & $this->evaluate($r);
+ case '|': return $this->evaluate($l) | $this->evaluate($r);
+ case '^': return $this->evaluate($l) ^ $this->evaluate($r);
+ case '&&': return $this->evaluate($l) && $this->evaluate($r);
+ case '||': return $this->evaluate($l) || $this->evaluate($r);
+ case '??': return $this->evaluate($l) ?? $this->evaluate($r);
+ case '.': return $this->evaluate($l) . $this->evaluate($r);
+ case '/': return $this->evaluate($l) / $this->evaluate($r);
+ case '==': return $this->evaluate($l) == $this->evaluate($r);
+ case '>': return $this->evaluate($l) > $this->evaluate($r);
+ case '>=': return $this->evaluate($l) >= $this->evaluate($r);
+ case '===': return $this->evaluate($l) === $this->evaluate($r);
+ case 'and': return $this->evaluate($l) and $this->evaluate($r);
+ case 'or': return $this->evaluate($l) or $this->evaluate($r);
+ case 'xor': return $this->evaluate($l) xor $this->evaluate($r);
+ case '-': return $this->evaluate($l) - $this->evaluate($r);
+ case '%': return $this->evaluate($l) % $this->evaluate($r);
+ case '*': return $this->evaluate($l) * $this->evaluate($r);
+ case '!=': return $this->evaluate($l) != $this->evaluate($r);
+ case '!==': return $this->evaluate($l) !== $this->evaluate($r);
+ case '+': return $this->evaluate($l) + $this->evaluate($r);
+ case '**': return $this->evaluate($l) ** $this->evaluate($r);
+ case '<<': return $this->evaluate($l) << $this->evaluate($r);
+ case '>>': return $this->evaluate($l) >> $this->evaluate($r);
+ case '<': return $this->evaluate($l) < $this->evaluate($r);
+ case '<=': return $this->evaluate($l) <= $this->evaluate($r);
+ case '<=>': return $this->evaluate($l) <=> $this->evaluate($r);
+ case '|>':
+ $lval = $this->evaluate($l);
+ return $this->evaluate($r)($lval);
+ }
+
+ throw new \Exception('Should not happen');
+ }
+
+ /** @return mixed */
+ private function evaluateConstFetch(Expr\ConstFetch $expr) {
+ $name = $expr->name->toLowerString();
+ switch ($name) {
+ case 'null': return null;
+ case 'false': return false;
+ case 'true': return true;
+ }
+
+ return ($this->fallbackEvaluator)($expr);
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Error.php b/vendor/nikic/php-parser/lib/PhpParser/Error.php
new file mode 100644
index 0000000..f81f0c4
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Error.php
@@ -0,0 +1,173 @@
+ */
+ protected array $attributes;
+
+ /**
+ * Creates an Exception signifying a parse error.
+ *
+ * @param string $message Error message
+ * @param array $attributes Attributes of node/token where error occurred
+ */
+ public function __construct(string $message, array $attributes = []) {
+ $this->rawMessage = $message;
+ $this->attributes = $attributes;
+ $this->updateMessage();
+ }
+
+ /**
+ * Gets the error message
+ *
+ * @return string Error message
+ */
+ public function getRawMessage(): string {
+ return $this->rawMessage;
+ }
+
+ /**
+ * Gets the line the error starts in.
+ *
+ * @return int Error start line
+ * @phpstan-return -1|positive-int
+ */
+ public function getStartLine(): int {
+ return $this->attributes['startLine'] ?? -1;
+ }
+
+ /**
+ * Gets the line the error ends in.
+ *
+ * @return int Error end line
+ * @phpstan-return -1|positive-int
+ */
+ public function getEndLine(): int {
+ return $this->attributes['endLine'] ?? -1;
+ }
+
+ /**
+ * Gets the attributes of the node/token the error occurred at.
+ *
+ * @return array
+ */
+ public function getAttributes(): array {
+ return $this->attributes;
+ }
+
+ /**
+ * Sets the attributes of the node/token the error occurred at.
+ *
+ * @param array $attributes
+ */
+ public function setAttributes(array $attributes): void {
+ $this->attributes = $attributes;
+ $this->updateMessage();
+ }
+
+ /**
+ * Sets the line of the PHP file the error occurred in.
+ *
+ * @param string $message Error message
+ */
+ public function setRawMessage(string $message): void {
+ $this->rawMessage = $message;
+ $this->updateMessage();
+ }
+
+ /**
+ * Sets the line the error starts in.
+ *
+ * @param int $line Error start line
+ */
+ public function setStartLine(int $line): void {
+ $this->attributes['startLine'] = $line;
+ $this->updateMessage();
+ }
+
+ /**
+ * Returns whether the error has start and end column information.
+ *
+ * For column information enable the startFilePos and endFilePos in the lexer options.
+ */
+ public function hasColumnInfo(): bool {
+ return isset($this->attributes['startFilePos'], $this->attributes['endFilePos']);
+ }
+
+ /**
+ * Gets the start column (1-based) into the line where the error started.
+ *
+ * @param string $code Source code of the file
+ */
+ public function getStartColumn(string $code): int {
+ if (!$this->hasColumnInfo()) {
+ throw new \RuntimeException('Error does not have column information');
+ }
+
+ return $this->toColumn($code, $this->attributes['startFilePos']);
+ }
+
+ /**
+ * Gets the end column (1-based) into the line where the error ended.
+ *
+ * @param string $code Source code of the file
+ */
+ public function getEndColumn(string $code): int {
+ if (!$this->hasColumnInfo()) {
+ throw new \RuntimeException('Error does not have column information');
+ }
+
+ return $this->toColumn($code, $this->attributes['endFilePos']);
+ }
+
+ /**
+ * Formats message including line and column information.
+ *
+ * @param string $code Source code associated with the error, for calculation of the columns
+ *
+ * @return string Formatted message
+ */
+ public function getMessageWithColumnInfo(string $code): string {
+ return sprintf(
+ '%s from %d:%d to %d:%d', $this->getRawMessage(),
+ $this->getStartLine(), $this->getStartColumn($code),
+ $this->getEndLine(), $this->getEndColumn($code)
+ );
+ }
+
+ /**
+ * Converts a file offset into a column.
+ *
+ * @param string $code Source code that $pos indexes into
+ * @param int $pos 0-based position in $code
+ *
+ * @return int 1-based column (relative to start of line)
+ */
+ private function toColumn(string $code, int $pos): int {
+ if ($pos > strlen($code)) {
+ throw new \RuntimeException('Invalid position information');
+ }
+
+ $lineStartPos = strrpos($code, "\n", $pos - strlen($code));
+ if (false === $lineStartPos) {
+ $lineStartPos = -1;
+ }
+
+ return $pos - $lineStartPos;
+ }
+
+ /**
+ * Updates the exception message after a change to rawMessage or rawLine.
+ */
+ protected function updateMessage(): void {
+ $this->message = $this->rawMessage;
+
+ if (-1 === $this->getStartLine()) {
+ $this->message .= ' on unknown line';
+ } else {
+ $this->message .= ' on line ' . $this->getStartLine();
+ }
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/ErrorHandler.php b/vendor/nikic/php-parser/lib/PhpParser/ErrorHandler.php
new file mode 100644
index 0000000..51ad730
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/ErrorHandler.php
@@ -0,0 +1,12 @@
+errors[] = $error;
+ }
+
+ /**
+ * Get collected errors.
+ *
+ * @return Error[]
+ */
+ public function getErrors(): array {
+ return $this->errors;
+ }
+
+ /**
+ * Check whether there are any errors.
+ */
+ public function hasErrors(): bool {
+ return !empty($this->errors);
+ }
+
+ /**
+ * Reset/clear collected errors.
+ */
+ public function clearErrors(): void {
+ $this->errors = [];
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/ErrorHandler/Throwing.php b/vendor/nikic/php-parser/lib/PhpParser/ErrorHandler/Throwing.php
new file mode 100644
index 0000000..dff33dd
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/ErrorHandler/Throwing.php
@@ -0,0 +1,17 @@
+type = $type;
+ $this->old = $old;
+ $this->new = $new;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Internal/Differ.php b/vendor/nikic/php-parser/lib/PhpParser/Internal/Differ.php
new file mode 100644
index 0000000..253e175
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Internal/Differ.php
@@ -0,0 +1,178 @@
+isEqual = $isEqual;
+ }
+
+ /**
+ * Calculate diff (edit script) from $old to $new.
+ *
+ * @param T[] $old Original array
+ * @param T[] $new New array
+ *
+ * @return DiffElem[] Diff (edit script)
+ */
+ public function diff(array $old, array $new): array {
+ $old = \array_values($old);
+ $new = \array_values($new);
+ list($trace, $x, $y) = $this->calculateTrace($old, $new);
+ return $this->extractDiff($trace, $x, $y, $old, $new);
+ }
+
+ /**
+ * Calculate diff, including "replace" operations.
+ *
+ * If a sequence of remove operations is followed by the same number of add operations, these
+ * will be coalesced into replace operations.
+ *
+ * @param T[] $old Original array
+ * @param T[] $new New array
+ *
+ * @return DiffElem[] Diff (edit script), including replace operations
+ */
+ public function diffWithReplacements(array $old, array $new): array {
+ return $this->coalesceReplacements($this->diff($old, $new));
+ }
+
+ /**
+ * @param T[] $old
+ * @param T[] $new
+ * @return array{array>, int, int}
+ */
+ private function calculateTrace(array $old, array $new): array {
+ $n = \count($old);
+ $m = \count($new);
+ $max = $n + $m;
+ $v = [1 => 0];
+ $trace = [];
+ for ($d = 0; $d <= $max; $d++) {
+ $trace[] = $v;
+ for ($k = -$d; $k <= $d; $k += 2) {
+ if ($k === -$d || ($k !== $d && $v[$k - 1] < $v[$k + 1])) {
+ $x = $v[$k + 1];
+ } else {
+ $x = $v[$k - 1] + 1;
+ }
+
+ $y = $x - $k;
+ while ($x < $n && $y < $m && ($this->isEqual)($old[$x], $new[$y])) {
+ $x++;
+ $y++;
+ }
+
+ $v[$k] = $x;
+ if ($x >= $n && $y >= $m) {
+ return [$trace, $x, $y];
+ }
+ }
+ }
+ throw new \Exception('Should not happen');
+ }
+
+ /**
+ * @param array> $trace
+ * @param T[] $old
+ * @param T[] $new
+ * @return DiffElem[]
+ */
+ private function extractDiff(array $trace, int $x, int $y, array $old, array $new): array {
+ $result = [];
+ for ($d = \count($trace) - 1; $d >= 0; $d--) {
+ $v = $trace[$d];
+ $k = $x - $y;
+
+ if ($k === -$d || ($k !== $d && $v[$k - 1] < $v[$k + 1])) {
+ $prevK = $k + 1;
+ } else {
+ $prevK = $k - 1;
+ }
+
+ $prevX = $v[$prevK];
+ $prevY = $prevX - $prevK;
+
+ while ($x > $prevX && $y > $prevY) {
+ $result[] = new DiffElem(DiffElem::TYPE_KEEP, $old[$x - 1], $new[$y - 1]);
+ $x--;
+ $y--;
+ }
+
+ if ($d === 0) {
+ break;
+ }
+
+ while ($x > $prevX) {
+ $result[] = new DiffElem(DiffElem::TYPE_REMOVE, $old[$x - 1], null);
+ $x--;
+ }
+
+ while ($y > $prevY) {
+ $result[] = new DiffElem(DiffElem::TYPE_ADD, null, $new[$y - 1]);
+ $y--;
+ }
+ }
+ return array_reverse($result);
+ }
+
+ /**
+ * Coalesce equal-length sequences of remove+add into a replace operation.
+ *
+ * @param DiffElem[] $diff
+ * @return DiffElem[]
+ */
+ private function coalesceReplacements(array $diff): array {
+ $newDiff = [];
+ $c = \count($diff);
+ for ($i = 0; $i < $c; $i++) {
+ $diffType = $diff[$i]->type;
+ if ($diffType !== DiffElem::TYPE_REMOVE) {
+ $newDiff[] = $diff[$i];
+ continue;
+ }
+
+ $j = $i;
+ while ($j < $c && $diff[$j]->type === DiffElem::TYPE_REMOVE) {
+ $j++;
+ }
+
+ $k = $j;
+ while ($k < $c && $diff[$k]->type === DiffElem::TYPE_ADD) {
+ $k++;
+ }
+
+ if ($j - $i === $k - $j) {
+ $len = $j - $i;
+ for ($n = 0; $n < $len; $n++) {
+ $newDiff[] = new DiffElem(
+ DiffElem::TYPE_REPLACE, $diff[$i + $n]->old, $diff[$j + $n]->new
+ );
+ }
+ } else {
+ for (; $i < $k; $i++) {
+ $newDiff[] = $diff[$i];
+ }
+ }
+ $i = $k - 1;
+ }
+ return $newDiff;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Internal/PrintableNewAnonClassNode.php b/vendor/nikic/php-parser/lib/PhpParser/Internal/PrintableNewAnonClassNode.php
new file mode 100644
index 0000000..b30a99a
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Internal/PrintableNewAnonClassNode.php
@@ -0,0 +1,71 @@
+ $attributes Attributes
+ */
+ public function __construct(
+ array $attrGroups, int $flags, array $args, ?Node\Name $extends, array $implements,
+ array $stmts, array $attributes
+ ) {
+ parent::__construct($attributes);
+ $this->attrGroups = $attrGroups;
+ $this->flags = $flags;
+ $this->args = $args;
+ $this->extends = $extends;
+ $this->implements = $implements;
+ $this->stmts = $stmts;
+ }
+
+ public static function fromNewNode(Expr\New_ $newNode): self {
+ $class = $newNode->class;
+ assert($class instanceof Node\Stmt\Class_);
+ // We don't assert that $class->name is null here, to allow consumers to assign unique names
+ // to anonymous classes for their own purposes. We simplify ignore the name here.
+ return new self(
+ $class->attrGroups, $class->flags, $newNode->args, $class->extends, $class->implements,
+ $class->stmts, $newNode->getAttributes()
+ );
+ }
+
+ public function getType(): string {
+ return 'Expr_PrintableNewAnonClass';
+ }
+
+ public function getSubNodeNames(): array {
+ return ['attrGroups', 'flags', 'args', 'extends', 'implements', 'stmts'];
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Internal/TokenPolyfill.php b/vendor/nikic/php-parser/lib/PhpParser/Internal/TokenPolyfill.php
new file mode 100644
index 0000000..36022d0
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Internal/TokenPolyfill.php
@@ -0,0 +1,237 @@
+= 80000) {
+ class TokenPolyfill extends \PhpToken {
+ }
+ return;
+}
+
+/**
+ * This is a polyfill for the PhpToken class introduced in PHP 8.0. We do not actually polyfill
+ * PhpToken, because composer might end up picking a different polyfill implementation, which does
+ * not meet our requirements.
+ *
+ * @internal
+ */
+class TokenPolyfill {
+ /** @var int The ID of the token. Either a T_* constant of a character code < 256. */
+ public int $id;
+ /** @var string The textual content of the token. */
+ public string $text;
+ /** @var int The 1-based starting line of the token (or -1 if unknown). */
+ public int $line;
+ /** @var int The 0-based starting position of the token (or -1 if unknown). */
+ public int $pos;
+
+ /** @var array Tokens ignored by the PHP parser. */
+ private const IGNORABLE_TOKENS = [
+ \T_WHITESPACE => true,
+ \T_COMMENT => true,
+ \T_DOC_COMMENT => true,
+ \T_OPEN_TAG => true,
+ ];
+
+ /** @var array Tokens that may be part of a T_NAME_* identifier. */
+ private static array $identifierTokens;
+
+ /**
+ * Create a Token with the given ID and text, as well optional line and position information.
+ */
+ final public function __construct(int $id, string $text, int $line = -1, int $pos = -1) {
+ $this->id = $id;
+ $this->text = $text;
+ $this->line = $line;
+ $this->pos = $pos;
+ }
+
+ /**
+ * Get the name of the token. For single-char tokens this will be the token character.
+ * Otherwise it will be a T_* style name, or null if the token ID is unknown.
+ */
+ public function getTokenName(): ?string {
+ if ($this->id < 256) {
+ return \chr($this->id);
+ }
+
+ $name = token_name($this->id);
+ return $name === 'UNKNOWN' ? null : $name;
+ }
+
+ /**
+ * Check whether the token is of the given kind. The kind may be either an integer that matches
+ * the token ID, a string that matches the token text, or an array of integers/strings. In the
+ * latter case, the function returns true if any of the kinds in the array match.
+ *
+ * @param int|string|(int|string)[] $kind
+ */
+ public function is($kind): bool {
+ if (\is_int($kind)) {
+ return $this->id === $kind;
+ }
+ if (\is_string($kind)) {
+ return $this->text === $kind;
+ }
+ if (\is_array($kind)) {
+ foreach ($kind as $entry) {
+ if (\is_int($entry)) {
+ if ($this->id === $entry) {
+ return true;
+ }
+ } elseif (\is_string($entry)) {
+ if ($this->text === $entry) {
+ return true;
+ }
+ } else {
+ throw new \TypeError(
+ 'Argument #1 ($kind) must only have elements of type string|int, ' .
+ gettype($entry) . ' given');
+ }
+ }
+ return false;
+ }
+ throw new \TypeError(
+ 'Argument #1 ($kind) must be of type string|int|array, ' .gettype($kind) . ' given');
+ }
+
+ /**
+ * Check whether this token would be ignored by the PHP parser. Returns true for T_WHITESPACE,
+ * T_COMMENT, T_DOC_COMMENT and T_OPEN_TAG, and false for everything else.
+ */
+ public function isIgnorable(): bool {
+ return isset(self::IGNORABLE_TOKENS[$this->id]);
+ }
+
+ /**
+ * Return the textual content of the token.
+ */
+ public function __toString(): string {
+ return $this->text;
+ }
+
+ /**
+ * Tokenize the given source code and return an array of tokens.
+ *
+ * This performs certain canonicalizations to match the PHP 8.0 token format:
+ * * Bad characters are represented using T_BAD_CHARACTER rather than omitted.
+ * * T_COMMENT does not include trailing newlines, instead the newline is part of a following
+ * T_WHITESPACE token.
+ * * Namespaced names are represented using T_NAME_* tokens.
+ *
+ * @return static[]
+ */
+ public static function tokenize(string $code, int $flags = 0): array {
+ self::init();
+
+ $tokens = [];
+ $line = 1;
+ $pos = 0;
+ $origTokens = \token_get_all($code, $flags);
+
+ $numTokens = \count($origTokens);
+ for ($i = 0; $i < $numTokens; $i++) {
+ $token = $origTokens[$i];
+ if (\is_string($token)) {
+ if (\strlen($token) === 2) {
+ // b" and B" are tokenized as single-char tokens, even though they aren't.
+ $tokens[] = new static(\ord('"'), $token, $line, $pos);
+ $pos += 2;
+ } else {
+ $tokens[] = new static(\ord($token), $token, $line, $pos);
+ $pos++;
+ }
+ } else {
+ $id = $token[0];
+ $text = $token[1];
+
+ // Emulate PHP 8.0 comment format, which does not include trailing whitespace anymore.
+ if ($id === \T_COMMENT && \substr($text, 0, 2) !== '/*' &&
+ \preg_match('/(\r\n|\n|\r)$/D', $text, $matches)
+ ) {
+ $trailingNewline = $matches[0];
+ $text = \substr($text, 0, -\strlen($trailingNewline));
+ $tokens[] = new static($id, $text, $line, $pos);
+ $pos += \strlen($text);
+
+ if ($i + 1 < $numTokens && $origTokens[$i + 1][0] === \T_WHITESPACE) {
+ // Move trailing newline into following T_WHITESPACE token, if it already exists.
+ $origTokens[$i + 1][1] = $trailingNewline . $origTokens[$i + 1][1];
+ $origTokens[$i + 1][2]--;
+ } else {
+ // Otherwise, we need to create a new T_WHITESPACE token.
+ $tokens[] = new static(\T_WHITESPACE, $trailingNewline, $line, $pos);
+ $line++;
+ $pos += \strlen($trailingNewline);
+ }
+ continue;
+ }
+
+ // Emulate PHP 8.0 T_NAME_* tokens, by combining sequences of T_NS_SEPARATOR and
+ // T_STRING into a single token.
+ if (($id === \T_NS_SEPARATOR || isset(self::$identifierTokens[$id]))) {
+ $newText = $text;
+ $lastWasSeparator = $id === \T_NS_SEPARATOR;
+ for ($j = $i + 1; $j < $numTokens; $j++) {
+ if ($lastWasSeparator) {
+ if (!isset(self::$identifierTokens[$origTokens[$j][0]])) {
+ break;
+ }
+ $lastWasSeparator = false;
+ } else {
+ if ($origTokens[$j][0] !== \T_NS_SEPARATOR) {
+ break;
+ }
+ $lastWasSeparator = true;
+ }
+ $newText .= $origTokens[$j][1];
+ }
+ if ($lastWasSeparator) {
+ // Trailing separator is not part of the name.
+ $j--;
+ $newText = \substr($newText, 0, -1);
+ }
+ if ($j > $i + 1) {
+ if ($id === \T_NS_SEPARATOR) {
+ $id = \T_NAME_FULLY_QUALIFIED;
+ } elseif ($id === \T_NAMESPACE) {
+ $id = \T_NAME_RELATIVE;
+ } else {
+ $id = \T_NAME_QUALIFIED;
+ }
+ $tokens[] = new static($id, $newText, $line, $pos);
+ $pos += \strlen($newText);
+ $i = $j - 1;
+ continue;
+ }
+ }
+
+ $tokens[] = new static($id, $text, $line, $pos);
+ $line += \substr_count($text, "\n");
+ $pos += \strlen($text);
+ }
+ }
+ return $tokens;
+ }
+
+ /** Initialize private static state needed by tokenize(). */
+ private static function init(): void {
+ if (isset(self::$identifierTokens)) {
+ return;
+ }
+
+ // Based on semi_reserved production.
+ self::$identifierTokens = \array_fill_keys([
+ \T_STRING,
+ \T_STATIC, \T_ABSTRACT, \T_FINAL, \T_PRIVATE, \T_PROTECTED, \T_PUBLIC, \T_READONLY,
+ \T_INCLUDE, \T_INCLUDE_ONCE, \T_EVAL, \T_REQUIRE, \T_REQUIRE_ONCE, \T_LOGICAL_OR, \T_LOGICAL_XOR, \T_LOGICAL_AND,
+ \T_INSTANCEOF, \T_NEW, \T_CLONE, \T_EXIT, \T_IF, \T_ELSEIF, \T_ELSE, \T_ENDIF, \T_ECHO, \T_DO, \T_WHILE,
+ \T_ENDWHILE, \T_FOR, \T_ENDFOR, \T_FOREACH, \T_ENDFOREACH, \T_DECLARE, \T_ENDDECLARE, \T_AS, \T_TRY, \T_CATCH,
+ \T_FINALLY, \T_THROW, \T_USE, \T_INSTEADOF, \T_GLOBAL, \T_VAR, \T_UNSET, \T_ISSET, \T_EMPTY, \T_CONTINUE, \T_GOTO,
+ \T_FUNCTION, \T_CONST, \T_RETURN, \T_PRINT, \T_YIELD, \T_LIST, \T_SWITCH, \T_ENDSWITCH, \T_CASE, \T_DEFAULT,
+ \T_BREAK, \T_ARRAY, \T_CALLABLE, \T_EXTENDS, \T_IMPLEMENTS, \T_NAMESPACE, \T_TRAIT, \T_INTERFACE, \T_CLASS,
+ \T_CLASS_C, \T_TRAIT_C, \T_FUNC_C, \T_METHOD_C, \T_LINE, \T_FILE, \T_DIR, \T_NS_C, \T_HALT_COMPILER, \T_FN,
+ \T_MATCH,
+ ], true);
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Internal/TokenStream.php b/vendor/nikic/php-parser/lib/PhpParser/Internal/TokenStream.php
new file mode 100644
index 0000000..cdbe2bd
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Internal/TokenStream.php
@@ -0,0 +1,282 @@
+tokens = $tokens;
+ $this->indentMap = $this->calcIndentMap($tabWidth);
+ }
+
+ /**
+ * Whether the given position is immediately surrounded by parenthesis.
+ *
+ * @param int $startPos Start position
+ * @param int $endPos End position
+ */
+ public function haveParens(int $startPos, int $endPos): bool {
+ return $this->haveTokenImmediatelyBefore($startPos, '(')
+ && $this->haveTokenImmediatelyAfter($endPos, ')');
+ }
+
+ /**
+ * Whether the given position is immediately surrounded by braces.
+ *
+ * @param int $startPos Start position
+ * @param int $endPos End position
+ */
+ public function haveBraces(int $startPos, int $endPos): bool {
+ return ($this->haveTokenImmediatelyBefore($startPos, '{')
+ || $this->haveTokenImmediatelyBefore($startPos, T_CURLY_OPEN))
+ && $this->haveTokenImmediatelyAfter($endPos, '}');
+ }
+
+ /**
+ * Check whether the position is directly preceded by a certain token type.
+ *
+ * During this check whitespace and comments are skipped.
+ *
+ * @param int $pos Position before which the token should occur
+ * @param int|string $expectedTokenType Token to check for
+ *
+ * @return bool Whether the expected token was found
+ */
+ public function haveTokenImmediatelyBefore(int $pos, $expectedTokenType): bool {
+ $tokens = $this->tokens;
+ $pos--;
+ for (; $pos >= 0; $pos--) {
+ $token = $tokens[$pos];
+ if ($token->is($expectedTokenType)) {
+ return true;
+ }
+ if (!$token->isIgnorable()) {
+ break;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Check whether the position is directly followed by a certain token type.
+ *
+ * During this check whitespace and comments are skipped.
+ *
+ * @param int $pos Position after which the token should occur
+ * @param int|string $expectedTokenType Token to check for
+ *
+ * @return bool Whether the expected token was found
+ */
+ public function haveTokenImmediatelyAfter(int $pos, $expectedTokenType): bool {
+ $tokens = $this->tokens;
+ $pos++;
+ for ($c = \count($tokens); $pos < $c; $pos++) {
+ $token = $tokens[$pos];
+ if ($token->is($expectedTokenType)) {
+ return true;
+ }
+ if (!$token->isIgnorable()) {
+ break;
+ }
+ }
+ return false;
+ }
+
+ /** @param int|string|(int|string)[] $skipTokenType */
+ public function skipLeft(int $pos, $skipTokenType): int {
+ $tokens = $this->tokens;
+
+ $pos = $this->skipLeftWhitespace($pos);
+ if ($skipTokenType === \T_WHITESPACE) {
+ return $pos;
+ }
+
+ if (!$tokens[$pos]->is($skipTokenType)) {
+ // Shouldn't happen. The skip token MUST be there
+ throw new \Exception('Encountered unexpected token');
+ }
+ $pos--;
+
+ return $this->skipLeftWhitespace($pos);
+ }
+
+ /** @param int|string|(int|string)[] $skipTokenType */
+ public function skipRight(int $pos, $skipTokenType): int {
+ $tokens = $this->tokens;
+
+ $pos = $this->skipRightWhitespace($pos);
+ if ($skipTokenType === \T_WHITESPACE) {
+ return $pos;
+ }
+
+ if (!$tokens[$pos]->is($skipTokenType)) {
+ // Shouldn't happen. The skip token MUST be there
+ throw new \Exception('Encountered unexpected token');
+ }
+ $pos++;
+
+ return $this->skipRightWhitespace($pos);
+ }
+
+ /**
+ * Return first non-whitespace token position smaller or equal to passed position.
+ *
+ * @param int $pos Token position
+ * @return int Non-whitespace token position
+ */
+ public function skipLeftWhitespace(int $pos): int {
+ $tokens = $this->tokens;
+ for (; $pos >= 0; $pos--) {
+ if (!$tokens[$pos]->isIgnorable()) {
+ break;
+ }
+ }
+ return $pos;
+ }
+
+ /**
+ * Return first non-whitespace position greater or equal to passed position.
+ *
+ * @param int $pos Token position
+ * @return int Non-whitespace token position
+ */
+ public function skipRightWhitespace(int $pos): int {
+ $tokens = $this->tokens;
+ for ($count = \count($tokens); $pos < $count; $pos++) {
+ if (!$tokens[$pos]->isIgnorable()) {
+ break;
+ }
+ }
+ return $pos;
+ }
+
+ /** @param int|string|(int|string)[] $findTokenType */
+ public function findRight(int $pos, $findTokenType): int {
+ $tokens = $this->tokens;
+ for ($count = \count($tokens); $pos < $count; $pos++) {
+ if ($tokens[$pos]->is($findTokenType)) {
+ return $pos;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * Whether the given position range contains a certain token type.
+ *
+ * @param int $startPos Starting position (inclusive)
+ * @param int $endPos Ending position (exclusive)
+ * @param int|string $tokenType Token type to look for
+ * @return bool Whether the token occurs in the given range
+ */
+ public function haveTokenInRange(int $startPos, int $endPos, $tokenType): bool {
+ $tokens = $this->tokens;
+ for ($pos = $startPos; $pos < $endPos; $pos++) {
+ if ($tokens[$pos]->is($tokenType)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public function haveTagInRange(int $startPos, int $endPos): bool {
+ return $this->haveTokenInRange($startPos, $endPos, \T_OPEN_TAG)
+ || $this->haveTokenInRange($startPos, $endPos, \T_CLOSE_TAG);
+ }
+
+ /**
+ * Get indentation before token position.
+ *
+ * @param int $pos Token position
+ *
+ * @return int Indentation depth (in spaces)
+ */
+ public function getIndentationBefore(int $pos): int {
+ return $this->indentMap[$pos];
+ }
+
+ /**
+ * Get the code corresponding to a token offset range, optionally adjusted for indentation.
+ *
+ * @param int $from Token start position (inclusive)
+ * @param int $to Token end position (exclusive)
+ * @param int $indent By how much the code should be indented (can be negative as well)
+ *
+ * @return string Code corresponding to token range, adjusted for indentation
+ */
+ public function getTokenCode(int $from, int $to, int $indent): string {
+ $tokens = $this->tokens;
+ $result = '';
+ for ($pos = $from; $pos < $to; $pos++) {
+ $token = $tokens[$pos];
+ $id = $token->id;
+ $text = $token->text;
+ if ($id === \T_CONSTANT_ENCAPSED_STRING || $id === \T_ENCAPSED_AND_WHITESPACE) {
+ $result .= $text;
+ } else {
+ // TODO Handle non-space indentation
+ if ($indent < 0) {
+ $result .= str_replace("\n" . str_repeat(" ", -$indent), "\n", $text);
+ } elseif ($indent > 0) {
+ $result .= str_replace("\n", "\n" . str_repeat(" ", $indent), $text);
+ } else {
+ $result .= $text;
+ }
+ }
+ }
+ return $result;
+ }
+
+ /**
+ * Precalculate the indentation at every token position.
+ *
+ * @return int[] Token position to indentation map
+ */
+ private function calcIndentMap(int $tabWidth): array {
+ $indentMap = [];
+ $indent = 0;
+ foreach ($this->tokens as $i => $token) {
+ $indentMap[] = $indent;
+
+ if ($token->id === \T_WHITESPACE) {
+ $content = $token->text;
+ $newlinePos = \strrpos($content, "\n");
+ if (false !== $newlinePos) {
+ $indent = $this->getIndent(\substr($content, $newlinePos + 1), $tabWidth);
+ } elseif ($i === 1 && $this->tokens[0]->id === \T_OPEN_TAG &&
+ $this->tokens[0]->text[\strlen($this->tokens[0]->text) - 1] === "\n") {
+ // Special case: Newline at the end of opening tag followed by whitespace.
+ $indent = $this->getIndent($content, $tabWidth);
+ }
+ }
+ }
+
+ // Add a sentinel for one past end of the file
+ $indentMap[] = $indent;
+
+ return $indentMap;
+ }
+
+ private function getIndent(string $ws, int $tabWidth): int {
+ $spaces = \substr_count($ws, " ");
+ $tabs = \substr_count($ws, "\t");
+ assert(\strlen($ws) === $spaces + $tabs);
+ return $spaces + $tabs * $tabWidth;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/JsonDecoder.php b/vendor/nikic/php-parser/lib/PhpParser/JsonDecoder.php
new file mode 100644
index 0000000..7be4142
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/JsonDecoder.php
@@ -0,0 +1,108 @@
+[] Node type to reflection class map */
+ private array $reflectionClassCache;
+
+ /** @return mixed */
+ public function decode(string $json) {
+ $value = json_decode($json, true);
+ if (json_last_error()) {
+ throw new \RuntimeException('JSON decoding error: ' . json_last_error_msg());
+ }
+
+ return $this->decodeRecursive($value);
+ }
+
+ /**
+ * @param mixed $value
+ * @return mixed
+ */
+ private function decodeRecursive($value) {
+ if (\is_array($value)) {
+ if (isset($value['nodeType'])) {
+ if ($value['nodeType'] === 'Comment' || $value['nodeType'] === 'Comment_Doc') {
+ return $this->decodeComment($value);
+ }
+ return $this->decodeNode($value);
+ }
+ return $this->decodeArray($value);
+ }
+ return $value;
+ }
+
+ private function decodeArray(array $array): array {
+ $decodedArray = [];
+ foreach ($array as $key => $value) {
+ $decodedArray[$key] = $this->decodeRecursive($value);
+ }
+ return $decodedArray;
+ }
+
+ private function decodeNode(array $value): Node {
+ $nodeType = $value['nodeType'];
+ if (!\is_string($nodeType)) {
+ throw new \RuntimeException('Node type must be a string');
+ }
+
+ $reflectionClass = $this->reflectionClassFromNodeType($nodeType);
+ $node = $reflectionClass->newInstanceWithoutConstructor();
+
+ if (isset($value['attributes'])) {
+ if (!\is_array($value['attributes'])) {
+ throw new \RuntimeException('Attributes must be an array');
+ }
+
+ $node->setAttributes($this->decodeArray($value['attributes']));
+ }
+
+ foreach ($value as $name => $subNode) {
+ if ($name === 'nodeType' || $name === 'attributes') {
+ continue;
+ }
+
+ $node->$name = $this->decodeRecursive($subNode);
+ }
+
+ return $node;
+ }
+
+ private function decodeComment(array $value): Comment {
+ $className = $value['nodeType'] === 'Comment' ? Comment::class : Comment\Doc::class;
+ if (!isset($value['text'])) {
+ throw new \RuntimeException('Comment must have text');
+ }
+
+ return new $className(
+ $value['text'],
+ $value['line'] ?? -1, $value['filePos'] ?? -1, $value['tokenPos'] ?? -1,
+ $value['endLine'] ?? -1, $value['endFilePos'] ?? -1, $value['endTokenPos'] ?? -1
+ );
+ }
+
+ /** @return \ReflectionClass */
+ private function reflectionClassFromNodeType(string $nodeType): \ReflectionClass {
+ if (!isset($this->reflectionClassCache[$nodeType])) {
+ $className = $this->classNameFromNodeType($nodeType);
+ $this->reflectionClassCache[$nodeType] = new \ReflectionClass($className);
+ }
+ return $this->reflectionClassCache[$nodeType];
+ }
+
+ /** @return class-string */
+ private function classNameFromNodeType(string $nodeType): string {
+ $className = 'PhpParser\\Node\\' . strtr($nodeType, '_', '\\');
+ if (class_exists($className)) {
+ return $className;
+ }
+
+ $className .= '_';
+ if (class_exists($className)) {
+ return $className;
+ }
+
+ throw new \RuntimeException("Unknown node type \"$nodeType\"");
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Lexer.php b/vendor/nikic/php-parser/lib/PhpParser/Lexer.php
new file mode 100644
index 0000000..5e2ece9
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Lexer.php
@@ -0,0 +1,116 @@
+postprocessTokens($tokens, $errorHandler);
+
+ if (false !== $scream) {
+ ini_set('xdebug.scream', $scream);
+ }
+
+ return $tokens;
+ }
+
+ private function handleInvalidCharacter(Token $token, ErrorHandler $errorHandler): void {
+ $chr = $token->text;
+ if ($chr === "\0") {
+ // PHP cuts error message after null byte, so need special case
+ $errorMsg = 'Unexpected null byte';
+ } else {
+ $errorMsg = sprintf(
+ 'Unexpected character "%s" (ASCII %d)', $chr, ord($chr)
+ );
+ }
+
+ $errorHandler->handleError(new Error($errorMsg, [
+ 'startLine' => $token->line,
+ 'endLine' => $token->line,
+ 'startFilePos' => $token->pos,
+ 'endFilePos' => $token->pos,
+ ]));
+ }
+
+ private function isUnterminatedComment(Token $token): bool {
+ return $token->is([\T_COMMENT, \T_DOC_COMMENT])
+ && substr($token->text, 0, 2) === '/*'
+ && substr($token->text, -2) !== '*/';
+ }
+
+ /**
+ * @param list $tokens
+ */
+ protected function postprocessTokens(array &$tokens, ErrorHandler $errorHandler): void {
+ // This function reports errors (bad characters and unterminated comments) in the token
+ // array, and performs certain canonicalizations:
+ // * Use PHP 8.1 T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG and
+ // T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG tokens used to disambiguate intersection types.
+ // * Add a sentinel token with ID 0.
+
+ $numTokens = \count($tokens);
+ if ($numTokens === 0) {
+ // Empty input edge case: Just add the sentinel token.
+ $tokens[] = new Token(0, "\0", 1, 0);
+ return;
+ }
+
+ for ($i = 0; $i < $numTokens; $i++) {
+ $token = $tokens[$i];
+ if ($token->id === \T_BAD_CHARACTER) {
+ $this->handleInvalidCharacter($token, $errorHandler);
+ }
+
+ if ($token->id === \ord('&')) {
+ $next = $i + 1;
+ while (isset($tokens[$next]) && $tokens[$next]->id === \T_WHITESPACE) {
+ $next++;
+ }
+ $followedByVarOrVarArg = isset($tokens[$next]) &&
+ $tokens[$next]->is([\T_VARIABLE, \T_ELLIPSIS]);
+ $token->id = $followedByVarOrVarArg
+ ? \T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG
+ : \T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG;
+ }
+ }
+
+ // Check for unterminated comment
+ $lastToken = $tokens[$numTokens - 1];
+ if ($this->isUnterminatedComment($lastToken)) {
+ $errorHandler->handleError(new Error('Unterminated comment', [
+ 'startLine' => $lastToken->line,
+ 'endLine' => $lastToken->getEndLine(),
+ 'startFilePos' => $lastToken->pos,
+ 'endFilePos' => $lastToken->getEndPos(),
+ ]));
+ }
+
+ // Add sentinel token.
+ $tokens[] = new Token(0, "\0", $lastToken->getEndLine(), $lastToken->getEndPos());
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Lexer/Emulative.php b/vendor/nikic/php-parser/lib/PhpParser/Lexer/Emulative.php
new file mode 100644
index 0000000..3185e80
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Lexer/Emulative.php
@@ -0,0 +1,230 @@
+ */
+ private array $emulators = [];
+
+ private PhpVersion $targetPhpVersion;
+
+ private PhpVersion $hostPhpVersion;
+
+ /**
+ * @param PhpVersion|null $phpVersion PHP version to emulate. Defaults to newest supported.
+ */
+ public function __construct(?PhpVersion $phpVersion = null) {
+ $this->targetPhpVersion = $phpVersion ?? PhpVersion::getNewestSupported();
+ $this->hostPhpVersion = PhpVersion::getHostVersion();
+
+ $emulators = [
+ new MatchTokenEmulator(),
+ new NullsafeTokenEmulator(),
+ new AttributeEmulator(),
+ new EnumTokenEmulator(),
+ new ReadonlyTokenEmulator(),
+ new ExplicitOctalEmulator(),
+ new ReadonlyFunctionTokenEmulator(),
+ new PropertyTokenEmulator(),
+ new AsymmetricVisibilityTokenEmulator(),
+ new PipeOperatorEmulator(),
+ new VoidCastEmulator(),
+ ];
+
+ // Collect emulators that are relevant for the PHP version we're running
+ // and the PHP version we're targeting for emulation.
+ foreach ($emulators as $emulator) {
+ $emulatorPhpVersion = $emulator->getPhpVersion();
+ if ($this->isForwardEmulationNeeded($emulatorPhpVersion)) {
+ $this->emulators[] = $emulator;
+ } elseif ($this->isReverseEmulationNeeded($emulatorPhpVersion)) {
+ $this->emulators[] = new ReverseEmulator($emulator);
+ }
+ }
+ }
+
+ public function tokenize(string $code, ?ErrorHandler $errorHandler = null): array {
+ $emulators = array_filter($this->emulators, function ($emulator) use ($code) {
+ return $emulator->isEmulationNeeded($code);
+ });
+
+ if (empty($emulators)) {
+ // Nothing to emulate, yay
+ return parent::tokenize($code, $errorHandler);
+ }
+
+ if ($errorHandler === null) {
+ $errorHandler = new ErrorHandler\Throwing();
+ }
+
+ $this->patches = [];
+ foreach ($emulators as $emulator) {
+ $code = $emulator->preprocessCode($code, $this->patches);
+ }
+
+ $collector = new ErrorHandler\Collecting();
+ $tokens = parent::tokenize($code, $collector);
+ $this->sortPatches();
+ $tokens = $this->fixupTokens($tokens);
+
+ $errors = $collector->getErrors();
+ if (!empty($errors)) {
+ $this->fixupErrors($errors);
+ foreach ($errors as $error) {
+ $errorHandler->handleError($error);
+ }
+ }
+
+ foreach ($emulators as $emulator) {
+ $tokens = $emulator->emulate($code, $tokens);
+ }
+
+ return $tokens;
+ }
+
+ private function isForwardEmulationNeeded(PhpVersion $emulatorPhpVersion): bool {
+ return $this->hostPhpVersion->older($emulatorPhpVersion)
+ && $this->targetPhpVersion->newerOrEqual($emulatorPhpVersion);
+ }
+
+ private function isReverseEmulationNeeded(PhpVersion $emulatorPhpVersion): bool {
+ return $this->hostPhpVersion->newerOrEqual($emulatorPhpVersion)
+ && $this->targetPhpVersion->older($emulatorPhpVersion);
+ }
+
+ private function sortPatches(): void {
+ // Patches may be contributed by different emulators.
+ // Make sure they are sorted by increasing patch position.
+ usort($this->patches, function ($p1, $p2) {
+ return $p1[0] <=> $p2[0];
+ });
+ }
+
+ /**
+ * @param list $tokens
+ * @return list
+ */
+ private function fixupTokens(array $tokens): array {
+ if (\count($this->patches) === 0) {
+ return $tokens;
+ }
+
+ // Load first patch
+ $patchIdx = 0;
+ list($patchPos, $patchType, $patchText) = $this->patches[$patchIdx];
+
+ // We use a manual loop over the tokens, because we modify the array on the fly
+ $posDelta = 0;
+ $lineDelta = 0;
+ for ($i = 0, $c = \count($tokens); $i < $c; $i++) {
+ $token = $tokens[$i];
+ $pos = $token->pos;
+ $token->pos += $posDelta;
+ $token->line += $lineDelta;
+ $localPosDelta = 0;
+ $len = \strlen($token->text);
+ while ($patchPos >= $pos && $patchPos < $pos + $len) {
+ $patchTextLen = \strlen($patchText);
+ if ($patchType === 'remove') {
+ if ($patchPos === $pos && $patchTextLen === $len) {
+ // Remove token entirely
+ array_splice($tokens, $i, 1, []);
+ $i--;
+ $c--;
+ } else {
+ // Remove from token string
+ $token->text = substr_replace(
+ $token->text, '', $patchPos - $pos + $localPosDelta, $patchTextLen
+ );
+ $localPosDelta -= $patchTextLen;
+ }
+ $lineDelta -= \substr_count($patchText, "\n");
+ } elseif ($patchType === 'add') {
+ // Insert into the token string
+ $token->text = substr_replace(
+ $token->text, $patchText, $patchPos - $pos + $localPosDelta, 0
+ );
+ $localPosDelta += $patchTextLen;
+ $lineDelta += \substr_count($patchText, "\n");
+ } elseif ($patchType === 'replace') {
+ // Replace inside the token string
+ $token->text = substr_replace(
+ $token->text, $patchText, $patchPos - $pos + $localPosDelta, $patchTextLen
+ );
+ } else {
+ assert(false);
+ }
+
+ // Fetch the next patch
+ $patchIdx++;
+ if ($patchIdx >= \count($this->patches)) {
+ // No more patches. However, we still need to adjust position.
+ $patchPos = \PHP_INT_MAX;
+ break;
+ }
+
+ list($patchPos, $patchType, $patchText) = $this->patches[$patchIdx];
+ }
+
+ $posDelta += $localPosDelta;
+ }
+ return $tokens;
+ }
+
+ /**
+ * Fixup line and position information in errors.
+ *
+ * @param Error[] $errors
+ */
+ private function fixupErrors(array $errors): void {
+ foreach ($errors as $error) {
+ $attrs = $error->getAttributes();
+
+ $posDelta = 0;
+ $lineDelta = 0;
+ foreach ($this->patches as $patch) {
+ list($patchPos, $patchType, $patchText) = $patch;
+ if ($patchPos >= $attrs['startFilePos']) {
+ // No longer relevant
+ break;
+ }
+
+ if ($patchType === 'add') {
+ $posDelta += strlen($patchText);
+ $lineDelta += substr_count($patchText, "\n");
+ } elseif ($patchType === 'remove') {
+ $posDelta -= strlen($patchText);
+ $lineDelta -= substr_count($patchText, "\n");
+ }
+ }
+
+ $attrs['startFilePos'] += $posDelta;
+ $attrs['endFilePos'] += $posDelta;
+ $attrs['startLine'] += $lineDelta;
+ $attrs['endLine'] += $lineDelta;
+ $error->setAttributes($attrs);
+ }
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/AsymmetricVisibilityTokenEmulator.php b/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/AsymmetricVisibilityTokenEmulator.php
new file mode 100644
index 0000000..084bb75
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/AsymmetricVisibilityTokenEmulator.php
@@ -0,0 +1,93 @@
+ \T_PUBLIC_SET,
+ \T_PROTECTED => \T_PROTECTED_SET,
+ \T_PRIVATE => \T_PRIVATE_SET,
+ ];
+ for ($i = 0, $c = count($tokens); $i < $c; ++$i) {
+ $token = $tokens[$i];
+ if (isset($map[$token->id]) && $i + 3 < $c && $tokens[$i + 1]->text === '(' &&
+ $tokens[$i + 2]->id === \T_STRING && \strtolower($tokens[$i + 2]->text) === 'set' &&
+ $tokens[$i + 3]->text === ')' &&
+ $this->isKeywordContext($tokens, $i)
+ ) {
+ array_splice($tokens, $i, 4, [
+ new Token(
+ $map[$token->id], $token->text . '(' . $tokens[$i + 2]->text . ')',
+ $token->line, $token->pos),
+ ]);
+ $c -= 3;
+ }
+ }
+
+ return $tokens;
+ }
+
+ public function reverseEmulate(string $code, array $tokens): array {
+ $reverseMap = [
+ \T_PUBLIC_SET => \T_PUBLIC,
+ \T_PROTECTED_SET => \T_PROTECTED,
+ \T_PRIVATE_SET => \T_PRIVATE,
+ ];
+ for ($i = 0, $c = count($tokens); $i < $c; ++$i) {
+ $token = $tokens[$i];
+ if (isset($reverseMap[$token->id]) &&
+ \preg_match('/(public|protected|private)\((set)\)/i', $token->text, $matches)
+ ) {
+ [, $modifier, $set] = $matches;
+ $modifierLen = \strlen($modifier);
+ array_splice($tokens, $i, 1, [
+ new Token($reverseMap[$token->id], $modifier, $token->line, $token->pos),
+ new Token(\ord('('), '(', $token->line, $token->pos + $modifierLen),
+ new Token(\T_STRING, $set, $token->line, $token->pos + $modifierLen + 1),
+ new Token(\ord(')'), ')', $token->line, $token->pos + $modifierLen + 4),
+ ]);
+ $i += 3;
+ $c += 3;
+ }
+ }
+
+ return $tokens;
+ }
+
+ /** @param Token[] $tokens */
+ protected function isKeywordContext(array $tokens, int $pos): bool {
+ $prevToken = $this->getPreviousNonSpaceToken($tokens, $pos);
+ if ($prevToken === null) {
+ return false;
+ }
+ return $prevToken->id !== \T_OBJECT_OPERATOR
+ && $prevToken->id !== \T_NULLSAFE_OBJECT_OPERATOR;
+ }
+
+ /** @param Token[] $tokens */
+ private function getPreviousNonSpaceToken(array $tokens, int $start): ?Token {
+ for ($i = $start - 1; $i >= 0; --$i) {
+ if ($tokens[$i]->id === T_WHITESPACE) {
+ continue;
+ }
+
+ return $tokens[$i];
+ }
+
+ return null;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/AttributeEmulator.php b/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/AttributeEmulator.php
new file mode 100644
index 0000000..2c12f33
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/AttributeEmulator.php
@@ -0,0 +1,49 @@
+text === '#' && isset($tokens[$i + 1]) && $tokens[$i + 1]->text === '[') {
+ array_splice($tokens, $i, 2, [
+ new Token(\T_ATTRIBUTE, '#[', $token->line, $token->pos),
+ ]);
+ $c--;
+ continue;
+ }
+ }
+
+ return $tokens;
+ }
+
+ public function reverseEmulate(string $code, array $tokens): array {
+ // TODO
+ return $tokens;
+ }
+
+ public function preprocessCode(string $code, array &$patches): string {
+ $pos = 0;
+ while (false !== $pos = strpos($code, '#[', $pos)) {
+ // Replace #[ with %[
+ $code[$pos] = '%';
+ $patches[] = [$pos, 'replace', '#'];
+ $pos += 2;
+ }
+ return $code;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/EnumTokenEmulator.php b/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/EnumTokenEmulator.php
new file mode 100644
index 0000000..5418f52
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/EnumTokenEmulator.php
@@ -0,0 +1,26 @@
+id === \T_WHITESPACE
+ && $tokens[$pos + 2]->id === \T_STRING;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/ExplicitOctalEmulator.php b/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/ExplicitOctalEmulator.php
new file mode 100644
index 0000000..9cadf42
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/ExplicitOctalEmulator.php
@@ -0,0 +1,45 @@
+id == \T_LNUMBER && $token->text === '0' &&
+ isset($tokens[$i + 1]) && $tokens[$i + 1]->id == \T_STRING &&
+ preg_match('/[oO][0-7]+(?:_[0-7]+)*/', $tokens[$i + 1]->text)
+ ) {
+ $tokenKind = $this->resolveIntegerOrFloatToken($tokens[$i + 1]->text);
+ array_splice($tokens, $i, 2, [
+ new Token($tokenKind, '0' . $tokens[$i + 1]->text, $token->line, $token->pos),
+ ]);
+ $c--;
+ }
+ }
+ return $tokens;
+ }
+
+ private function resolveIntegerOrFloatToken(string $str): int {
+ $str = substr($str, 1);
+ $str = str_replace('_', '', $str);
+ $num = octdec($str);
+ return is_float($num) ? \T_DNUMBER : \T_LNUMBER;
+ }
+
+ public function reverseEmulate(string $code, array $tokens): array {
+ // Explicit octals were not legal code previously, don't bother.
+ return $tokens;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/KeywordEmulator.php b/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/KeywordEmulator.php
new file mode 100644
index 0000000..066e7cd
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/KeywordEmulator.php
@@ -0,0 +1,60 @@
+getKeywordString()) !== false;
+ }
+
+ /** @param Token[] $tokens */
+ protected function isKeywordContext(array $tokens, int $pos): bool {
+ $prevToken = $this->getPreviousNonSpaceToken($tokens, $pos);
+ if ($prevToken === null) {
+ return false;
+ }
+ return $prevToken->id !== \T_OBJECT_OPERATOR
+ && $prevToken->id !== \T_NULLSAFE_OBJECT_OPERATOR;
+ }
+
+ public function emulate(string $code, array $tokens): array {
+ $keywordString = $this->getKeywordString();
+ foreach ($tokens as $i => $token) {
+ if ($token->id === T_STRING && strtolower($token->text) === $keywordString
+ && $this->isKeywordContext($tokens, $i)) {
+ $token->id = $this->getKeywordToken();
+ }
+ }
+
+ return $tokens;
+ }
+
+ /** @param Token[] $tokens */
+ private function getPreviousNonSpaceToken(array $tokens, int $start): ?Token {
+ for ($i = $start - 1; $i >= 0; --$i) {
+ if ($tokens[$i]->id === T_WHITESPACE) {
+ continue;
+ }
+
+ return $tokens[$i];
+ }
+
+ return null;
+ }
+
+ public function reverseEmulate(string $code, array $tokens): array {
+ $keywordToken = $this->getKeywordToken();
+ foreach ($tokens as $token) {
+ if ($token->id === $keywordToken) {
+ $token->id = \T_STRING;
+ }
+ }
+
+ return $tokens;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/MatchTokenEmulator.php b/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/MatchTokenEmulator.php
new file mode 100644
index 0000000..0fa5fbc
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/MatchTokenEmulator.php
@@ -0,0 +1,19 @@
+') !== false;
+ }
+
+ public function emulate(string $code, array $tokens): array {
+ // We need to manually iterate and manage a count because we'll change
+ // the tokens array on the way
+ for ($i = 0, $c = count($tokens); $i < $c; ++$i) {
+ $token = $tokens[$i];
+ if ($token->text === '?' && isset($tokens[$i + 1]) && $tokens[$i + 1]->id === \T_OBJECT_OPERATOR) {
+ array_splice($tokens, $i, 2, [
+ new Token(\T_NULLSAFE_OBJECT_OPERATOR, '?->', $token->line, $token->pos),
+ ]);
+ $c--;
+ continue;
+ }
+
+ // Handle ?-> inside encapsed string.
+ if ($token->id === \T_ENCAPSED_AND_WHITESPACE && isset($tokens[$i - 1])
+ && $tokens[$i - 1]->id === \T_VARIABLE
+ && preg_match('/^\?->([a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*)/', $token->text, $matches)
+ ) {
+ $replacement = [
+ new Token(\T_NULLSAFE_OBJECT_OPERATOR, '?->', $token->line, $token->pos),
+ new Token(\T_STRING, $matches[1], $token->line, $token->pos + 3),
+ ];
+ $matchLen = \strlen($matches[0]);
+ if ($matchLen !== \strlen($token->text)) {
+ $replacement[] = new Token(
+ \T_ENCAPSED_AND_WHITESPACE,
+ \substr($token->text, $matchLen),
+ $token->line, $token->pos + $matchLen
+ );
+ }
+ array_splice($tokens, $i, 1, $replacement);
+ $c += \count($replacement) - 1;
+ continue;
+ }
+ }
+
+ return $tokens;
+ }
+
+ public function reverseEmulate(string $code, array $tokens): array {
+ // ?-> was not valid code previously, don't bother.
+ return $tokens;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/PipeOperatorEmulator.php b/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/PipeOperatorEmulator.php
new file mode 100644
index 0000000..b561692
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/PipeOperatorEmulator.php
@@ -0,0 +1,45 @@
+') !== false;
+ }
+
+ public function emulate(string $code, array $tokens): array {
+ for ($i = 0, $c = count($tokens); $i < $c; ++$i) {
+ $token = $tokens[$i];
+ if ($token->text === '|' && isset($tokens[$i + 1]) && $tokens[$i + 1]->text === '>') {
+ array_splice($tokens, $i, 2, [
+ new Token(\T_PIPE, '|>', $token->line, $token->pos),
+ ]);
+ $c--;
+ }
+ }
+ return $tokens;
+ }
+
+ public function reverseEmulate(string $code, array $tokens): array {
+ for ($i = 0, $c = count($tokens); $i < $c; ++$i) {
+ $token = $tokens[$i];
+ if ($token->id === \T_PIPE) {
+ array_splice($tokens, $i, 1, [
+ new Token(\ord('|'), '|', $token->line, $token->pos),
+ new Token(\ord('>'), '>', $token->line, $token->pos + 1),
+ ]);
+ $i++;
+ $c++;
+ }
+ }
+ return $tokens;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/PropertyTokenEmulator.php b/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/PropertyTokenEmulator.php
new file mode 100644
index 0000000..71b7fc2
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/PropertyTokenEmulator.php
@@ -0,0 +1,19 @@
+text === '(' ||
+ ($tokens[$pos + 1]->id === \T_WHITESPACE &&
+ isset($tokens[$pos + 2]) &&
+ $tokens[$pos + 2]->text === '(')));
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/ReverseEmulator.php b/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/ReverseEmulator.php
new file mode 100644
index 0000000..851b5c4
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/ReverseEmulator.php
@@ -0,0 +1,37 @@
+emulator = $emulator;
+ }
+
+ public function getPhpVersion(): PhpVersion {
+ return $this->emulator->getPhpVersion();
+ }
+
+ public function isEmulationNeeded(string $code): bool {
+ return $this->emulator->isEmulationNeeded($code);
+ }
+
+ public function emulate(string $code, array $tokens): array {
+ return $this->emulator->reverseEmulate($code, $tokens);
+ }
+
+ public function reverseEmulate(string $code, array $tokens): array {
+ return $this->emulator->emulate($code, $tokens);
+ }
+
+ public function preprocessCode(string $code, array &$patches): string {
+ return $code;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/TokenEmulator.php b/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/TokenEmulator.php
new file mode 100644
index 0000000..fec2f19
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Lexer/TokenEmulator/TokenEmulator.php
@@ -0,0 +1,30 @@
+text !== '(') {
+ continue;
+ }
+
+ $numTokens = 1;
+ $text = '(';
+ $j = $i + 1;
+ if ($j < $c && $tokens[$j]->id === \T_WHITESPACE && preg_match('/[ \t]+/', $tokens[$j]->text)) {
+ $text .= $tokens[$j]->text;
+ $numTokens++;
+ $j++;
+ }
+
+ if ($j >= $c || $tokens[$j]->id !== \T_STRING || \strtolower($tokens[$j]->text) !== 'void') {
+ continue;
+ }
+
+ $text .= $tokens[$j]->text;
+ $numTokens++;
+ $k = $j + 1;
+ if ($k < $c && $tokens[$k]->id === \T_WHITESPACE && preg_match('/[ \t]+/', $tokens[$k]->text)) {
+ $text .= $tokens[$k]->text;
+ $numTokens++;
+ $k++;
+ }
+
+ if ($k >= $c || $tokens[$k]->text !== ')') {
+ continue;
+ }
+
+ $text .= ')';
+ $numTokens++;
+ array_splice($tokens, $i, $numTokens, [
+ new Token(\T_VOID_CAST, $text, $token->line, $token->pos),
+ ]);
+ $c -= $numTokens - 1;
+ }
+ return $tokens;
+ }
+
+ public function reverseEmulate(string $code, array $tokens): array {
+ for ($i = 0, $c = count($tokens); $i < $c; ++$i) {
+ $token = $tokens[$i];
+ if ($token->id !== \T_VOID_CAST) {
+ continue;
+ }
+
+ if (!preg_match('/^\(([ \t]*)(void)([ \t]*)\)$/i', $token->text, $match)) {
+ throw new \LogicException('Unexpected T_VOID_CAST contents');
+ }
+
+ $newTokens = [];
+ $pos = $token->pos;
+
+ $newTokens[] = new Token(\ord('('), '(', $token->line, $pos);
+ $pos++;
+
+ if ($match[1] !== '') {
+ $newTokens[] = new Token(\T_WHITESPACE, $match[1], $token->line, $pos);
+ $pos += \strlen($match[1]);
+ }
+
+ $newTokens[] = new Token(\T_STRING, $match[2], $token->line, $pos);
+ $pos += \strlen($match[2]);
+
+ if ($match[3] !== '') {
+ $newTokens[] = new Token(\T_WHITESPACE, $match[3], $token->line, $pos);
+ $pos += \strlen($match[3]);
+ }
+
+ $newTokens[] = new Token(\ord(')'), ')', $token->line, $pos);
+
+ array_splice($tokens, $i, 1, $newTokens);
+ $i += \count($newTokens) - 1;
+ $c += \count($newTokens) - 1;
+ }
+ return $tokens;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Modifiers.php b/vendor/nikic/php-parser/lib/PhpParser/Modifiers.php
new file mode 100644
index 0000000..0f0f22d
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Modifiers.php
@@ -0,0 +1,85 @@
+ 'public',
+ self::PROTECTED => 'protected',
+ self::PRIVATE => 'private',
+ self::STATIC => 'static',
+ self::ABSTRACT => 'abstract',
+ self::FINAL => 'final',
+ self::READONLY => 'readonly',
+ self::PUBLIC_SET => 'public(set)',
+ self::PROTECTED_SET => 'protected(set)',
+ self::PRIVATE_SET => 'private(set)',
+ ];
+
+ public static function toString(int $modifier): string {
+ if (!isset(self::TO_STRING_MAP[$modifier])) {
+ throw new \InvalidArgumentException("Unknown modifier $modifier");
+ }
+ return self::TO_STRING_MAP[$modifier];
+ }
+
+ private static function isValidModifier(int $modifier): bool {
+ $isPow2 = ($modifier & ($modifier - 1)) == 0 && $modifier != 0;
+ return $isPow2 && $modifier <= self::PRIVATE_SET;
+ }
+
+ /**
+ * @internal
+ */
+ public static function verifyClassModifier(int $a, int $b): void {
+ assert(self::isValidModifier($b));
+ if (($a & $b) != 0) {
+ throw new Error(
+ 'Multiple ' . self::toString($b) . ' modifiers are not allowed');
+ }
+
+ if ($a & 48 && $b & 48) {
+ throw new Error('Cannot use the final modifier on an abstract class');
+ }
+ }
+
+ /**
+ * @internal
+ */
+ public static function verifyModifier(int $a, int $b): void {
+ assert(self::isValidModifier($b));
+ if (($a & Modifiers::VISIBILITY_MASK && $b & Modifiers::VISIBILITY_MASK) ||
+ ($a & Modifiers::VISIBILITY_SET_MASK && $b & Modifiers::VISIBILITY_SET_MASK)
+ ) {
+ throw new Error('Multiple access type modifiers are not allowed');
+ }
+
+ if (($a & $b) != 0) {
+ throw new Error(
+ 'Multiple ' . self::toString($b) . ' modifiers are not allowed');
+ }
+
+ if ($a & 48 && $b & 48) {
+ throw new Error('Cannot use the final modifier on an abstract class member');
+ }
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/NameContext.php b/vendor/nikic/php-parser/lib/PhpParser/NameContext.php
new file mode 100644
index 0000000..2265ecc
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/NameContext.php
@@ -0,0 +1,284 @@
+ [aliasName => originalName]] */
+ protected array $aliases = [];
+
+ /** @var Name[][] Same as $aliases but preserving original case */
+ protected array $origAliases = [];
+
+ /** @var ErrorHandler Error handler */
+ protected ErrorHandler $errorHandler;
+
+ /**
+ * Create a name context.
+ *
+ * @param ErrorHandler $errorHandler Error handling used to report errors
+ */
+ public function __construct(ErrorHandler $errorHandler) {
+ $this->errorHandler = $errorHandler;
+ }
+
+ /**
+ * Start a new namespace.
+ *
+ * This also resets the alias table.
+ *
+ * @param Name|null $namespace Null is the global namespace
+ */
+ public function startNamespace(?Name $namespace = null): void {
+ $this->namespace = $namespace;
+ $this->origAliases = $this->aliases = [
+ Stmt\Use_::TYPE_NORMAL => [],
+ Stmt\Use_::TYPE_FUNCTION => [],
+ Stmt\Use_::TYPE_CONSTANT => [],
+ ];
+ }
+
+ /**
+ * Add an alias / import.
+ *
+ * @param Name $name Original name
+ * @param string $aliasName Aliased name
+ * @param Stmt\Use_::TYPE_* $type One of Stmt\Use_::TYPE_*
+ * @param array $errorAttrs Attributes to use to report an error
+ */
+ public function addAlias(Name $name, string $aliasName, int $type, array $errorAttrs = []): void {
+ // Constant names are case sensitive, everything else case insensitive
+ if ($type === Stmt\Use_::TYPE_CONSTANT) {
+ $aliasLookupName = $aliasName;
+ } else {
+ $aliasLookupName = strtolower($aliasName);
+ }
+
+ if (isset($this->aliases[$type][$aliasLookupName])) {
+ $typeStringMap = [
+ Stmt\Use_::TYPE_NORMAL => '',
+ Stmt\Use_::TYPE_FUNCTION => 'function ',
+ Stmt\Use_::TYPE_CONSTANT => 'const ',
+ ];
+
+ $this->errorHandler->handleError(new Error(
+ sprintf(
+ 'Cannot use %s%s as %s because the name is already in use',
+ $typeStringMap[$type], $name, $aliasName
+ ),
+ $errorAttrs
+ ));
+ return;
+ }
+
+ $this->aliases[$type][$aliasLookupName] = $name;
+ $this->origAliases[$type][$aliasName] = $name;
+ }
+
+ /**
+ * Get current namespace.
+ *
+ * @return null|Name Namespace (or null if global namespace)
+ */
+ public function getNamespace(): ?Name {
+ return $this->namespace;
+ }
+
+ /**
+ * Get resolved name.
+ *
+ * @param Name $name Name to resolve
+ * @param Stmt\Use_::TYPE_* $type One of Stmt\Use_::TYPE_{FUNCTION|CONSTANT}
+ *
+ * @return null|Name Resolved name, or null if static resolution is not possible
+ */
+ public function getResolvedName(Name $name, int $type): ?Name {
+ // don't resolve special class names
+ if ($type === Stmt\Use_::TYPE_NORMAL && $name->isSpecialClassName()) {
+ if (!$name->isUnqualified()) {
+ $this->errorHandler->handleError(new Error(
+ sprintf("'\\%s' is an invalid class name", $name->toString()),
+ $name->getAttributes()
+ ));
+ }
+ return $name;
+ }
+
+ // fully qualified names are already resolved
+ if ($name->isFullyQualified()) {
+ return $name;
+ }
+
+ // Try to resolve aliases
+ if (null !== $resolvedName = $this->resolveAlias($name, $type)) {
+ return $resolvedName;
+ }
+
+ if ($type !== Stmt\Use_::TYPE_NORMAL && $name->isUnqualified()) {
+ if (null === $this->namespace) {
+ // outside of a namespace unaliased unqualified is same as fully qualified
+ return new FullyQualified($name, $name->getAttributes());
+ }
+
+ // Cannot resolve statically
+ return null;
+ }
+
+ // if no alias exists prepend current namespace
+ return FullyQualified::concat($this->namespace, $name, $name->getAttributes());
+ }
+
+ /**
+ * Get resolved class name.
+ *
+ * @param Name $name Class ame to resolve
+ *
+ * @return Name Resolved name
+ */
+ public function getResolvedClassName(Name $name): Name {
+ return $this->getResolvedName($name, Stmt\Use_::TYPE_NORMAL);
+ }
+
+ /**
+ * Get possible ways of writing a fully qualified name (e.g., by making use of aliases).
+ *
+ * @param string $name Fully-qualified name (without leading namespace separator)
+ * @param Stmt\Use_::TYPE_* $type One of Stmt\Use_::TYPE_*
+ *
+ * @return Name[] Possible representations of the name
+ */
+ public function getPossibleNames(string $name, int $type): array {
+ $lcName = strtolower($name);
+
+ if ($type === Stmt\Use_::TYPE_NORMAL) {
+ // self, parent and static must always be unqualified
+ if ($lcName === "self" || $lcName === "parent" || $lcName === "static") {
+ return [new Name($name)];
+ }
+ }
+
+ // Collect possible ways to write this name, starting with the fully-qualified name
+ $possibleNames = [new FullyQualified($name)];
+
+ if (null !== $nsRelativeName = $this->getNamespaceRelativeName($name, $lcName, $type)) {
+ // Make sure there is no alias that makes the normally namespace-relative name
+ // into something else
+ if (null === $this->resolveAlias($nsRelativeName, $type)) {
+ $possibleNames[] = $nsRelativeName;
+ }
+ }
+
+ // Check for relevant namespace use statements
+ foreach ($this->origAliases[Stmt\Use_::TYPE_NORMAL] as $alias => $orig) {
+ $lcOrig = $orig->toLowerString();
+ if (0 === strpos($lcName, $lcOrig . '\\')) {
+ $possibleNames[] = new Name($alias . substr($name, strlen($lcOrig)));
+ }
+ }
+
+ // Check for relevant type-specific use statements
+ foreach ($this->origAliases[$type] as $alias => $orig) {
+ if ($type === Stmt\Use_::TYPE_CONSTANT) {
+ // Constants are complicated-sensitive
+ $normalizedOrig = $this->normalizeConstName($orig->toString());
+ if ($normalizedOrig === $this->normalizeConstName($name)) {
+ $possibleNames[] = new Name($alias);
+ }
+ } else {
+ // Everything else is case-insensitive
+ if ($orig->toLowerString() === $lcName) {
+ $possibleNames[] = new Name($alias);
+ }
+ }
+ }
+
+ return $possibleNames;
+ }
+
+ /**
+ * Get shortest representation of this fully-qualified name.
+ *
+ * @param string $name Fully-qualified name (without leading namespace separator)
+ * @param Stmt\Use_::TYPE_* $type One of Stmt\Use_::TYPE_*
+ *
+ * @return Name Shortest representation
+ */
+ public function getShortName(string $name, int $type): Name {
+ $possibleNames = $this->getPossibleNames($name, $type);
+
+ // Find shortest name
+ $shortestName = null;
+ $shortestLength = \INF;
+ foreach ($possibleNames as $possibleName) {
+ $length = strlen($possibleName->toCodeString());
+ if ($length < $shortestLength) {
+ $shortestName = $possibleName;
+ $shortestLength = $length;
+ }
+ }
+
+ return $shortestName;
+ }
+
+ private function resolveAlias(Name $name, int $type): ?FullyQualified {
+ $firstPart = $name->getFirst();
+
+ if ($name->isQualified()) {
+ // resolve aliases for qualified names, always against class alias table
+ $checkName = strtolower($firstPart);
+ if (isset($this->aliases[Stmt\Use_::TYPE_NORMAL][$checkName])) {
+ $alias = $this->aliases[Stmt\Use_::TYPE_NORMAL][$checkName];
+ return FullyQualified::concat($alias, $name->slice(1), $name->getAttributes());
+ }
+ } elseif ($name->isUnqualified()) {
+ // constant aliases are case-sensitive, function aliases case-insensitive
+ $checkName = $type === Stmt\Use_::TYPE_CONSTANT ? $firstPart : strtolower($firstPart);
+ if (isset($this->aliases[$type][$checkName])) {
+ // resolve unqualified aliases
+ return new FullyQualified($this->aliases[$type][$checkName], $name->getAttributes());
+ }
+ }
+
+ // No applicable aliases
+ return null;
+ }
+
+ private function getNamespaceRelativeName(string $name, string $lcName, int $type): ?Name {
+ if (null === $this->namespace) {
+ return new Name($name);
+ }
+
+ if ($type === Stmt\Use_::TYPE_CONSTANT) {
+ // The constants true/false/null always resolve to the global symbols, even inside a
+ // namespace, so they may be used without qualification
+ if ($lcName === "true" || $lcName === "false" || $lcName === "null") {
+ return new Name($name);
+ }
+ }
+
+ $namespacePrefix = strtolower($this->namespace . '\\');
+ if (0 === strpos($lcName, $namespacePrefix)) {
+ return new Name(substr($name, strlen($namespacePrefix)));
+ }
+
+ return null;
+ }
+
+ private function normalizeConstName(string $name): string {
+ $nsSep = strrpos($name, '\\');
+ if (false === $nsSep) {
+ return $name;
+ }
+
+ // Constants have case-insensitive namespace and case-sensitive short-name
+ $ns = substr($name, 0, $nsSep);
+ $shortName = substr($name, $nsSep + 1);
+ return strtolower($ns) . '\\' . $shortName;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node.php b/vendor/nikic/php-parser/lib/PhpParser/Node.php
new file mode 100644
index 0000000..fd2a9b7
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node.php
@@ -0,0 +1,150 @@
+
+ */
+ public function getAttributes(): array;
+
+ /**
+ * Replaces all the attributes of this node.
+ *
+ * @param array $attributes
+ */
+ public function setAttributes(array $attributes): void;
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Arg.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Arg.php
new file mode 100644
index 0000000..6680efa
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Arg.php
@@ -0,0 +1,44 @@
+ $attributes Additional attributes
+ * @param Identifier|null $name Parameter name (for named parameters)
+ */
+ public function __construct(
+ Expr $value, bool $byRef = false, bool $unpack = false, array $attributes = [],
+ ?Identifier $name = null
+ ) {
+ $this->attributes = $attributes;
+ $this->name = $name;
+ $this->value = $value;
+ $this->byRef = $byRef;
+ $this->unpack = $unpack;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['name', 'value', 'byRef', 'unpack'];
+ }
+
+ public function getType(): string {
+ return 'Arg';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/ArrayItem.php b/vendor/nikic/php-parser/lib/PhpParser/Node/ArrayItem.php
new file mode 100644
index 0000000..fa1cff5
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/ArrayItem.php
@@ -0,0 +1,43 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Expr $value, ?Expr $key = null, bool $byRef = false, array $attributes = [], bool $unpack = false) {
+ $this->attributes = $attributes;
+ $this->key = $key;
+ $this->value = $value;
+ $this->byRef = $byRef;
+ $this->unpack = $unpack;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['key', 'value', 'byRef', 'unpack'];
+ }
+
+ public function getType(): string {
+ return 'ArrayItem';
+ }
+}
+
+// @deprecated compatibility alias
+class_alias(ArrayItem::class, Expr\ArrayItem::class);
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Attribute.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Attribute.php
new file mode 100644
index 0000000..9d89243
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Attribute.php
@@ -0,0 +1,33 @@
+ Attribute arguments */
+ public array $args;
+
+ /**
+ * @param Node\Name $name Attribute name
+ * @param list $args Attribute arguments
+ * @param array $attributes Additional node attributes
+ */
+ public function __construct(Name $name, array $args = [], array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->name = $name;
+ $this->args = $args;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['name', 'args'];
+ }
+
+ public function getType(): string {
+ return 'Attribute';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/AttributeGroup.php b/vendor/nikic/php-parser/lib/PhpParser/Node/AttributeGroup.php
new file mode 100644
index 0000000..b9eb588
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/AttributeGroup.php
@@ -0,0 +1,27 @@
+ $attributes Additional node attributes
+ */
+ public function __construct(array $attrs, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->attrs = $attrs;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['attrs'];
+ }
+
+ public function getType(): string {
+ return 'AttributeGroup';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/ClosureUse.php b/vendor/nikic/php-parser/lib/PhpParser/Node/ClosureUse.php
new file mode 100644
index 0000000..e313280
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/ClosureUse.php
@@ -0,0 +1,36 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Expr\Variable $var, bool $byRef = false, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->var = $var;
+ $this->byRef = $byRef;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['var', 'byRef'];
+ }
+
+ public function getType(): string {
+ return 'ClosureUse';
+ }
+}
+
+// @deprecated compatibility alias
+class_alias(ClosureUse::class, Expr\ClosureUse::class);
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/ComplexType.php b/vendor/nikic/php-parser/lib/PhpParser/Node/ComplexType.php
new file mode 100644
index 0000000..05a5e5e
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/ComplexType.php
@@ -0,0 +1,13 @@
+ $attributes Additional attributes
+ */
+ public function __construct($name, Expr $value, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->name = \is_string($name) ? new Identifier($name) : $name;
+ $this->value = $value;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['name', 'value'];
+ }
+
+ public function getType(): string {
+ return 'Const';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/DeclareItem.php b/vendor/nikic/php-parser/lib/PhpParser/Node/DeclareItem.php
new file mode 100644
index 0000000..55c1fe4
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/DeclareItem.php
@@ -0,0 +1,37 @@
+value pair node.
+ *
+ * @param string|Node\Identifier $key Key
+ * @param Node\Expr $value Value
+ * @param array $attributes Additional attributes
+ */
+ public function __construct($key, Node\Expr $value, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->key = \is_string($key) ? new Node\Identifier($key) : $key;
+ $this->value = $value;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['key', 'value'];
+ }
+
+ public function getType(): string {
+ return 'DeclareItem';
+ }
+}
+
+// @deprecated compatibility alias
+class_alias(DeclareItem::class, Stmt\DeclareDeclare::class);
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr.php
new file mode 100644
index 0000000..8b7dbb6
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr.php
@@ -0,0 +1,8 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Expr $var, ?Expr $dim = null, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->var = $var;
+ $this->dim = $dim;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['var', 'dim'];
+ }
+
+ public function getType(): string {
+ return 'Expr_ArrayDimFetch';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/ArrayItem.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/ArrayItem.php
new file mode 100644
index 0000000..55ef163
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/ArrayItem.php
@@ -0,0 +1,15 @@
+ $attributes Additional attributes
+ */
+ public function __construct(array $items = [], array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->items = $items;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['items'];
+ }
+
+ public function getType(): string {
+ return 'Expr_Array';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/ArrowFunction.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/ArrowFunction.php
new file mode 100644
index 0000000..0e98ce9
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/ArrowFunction.php
@@ -0,0 +1,84 @@
+ false : Whether the closure is static
+ * 'byRef' => false : Whether to return by reference
+ * 'params' => array() : Parameters
+ * 'returnType' => null : Return type
+ * 'attrGroups' => array() : PHP attribute groups
+ * @param array $attributes Additional attributes
+ */
+ public function __construct(array $subNodes, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->static = $subNodes['static'] ?? false;
+ $this->byRef = $subNodes['byRef'] ?? false;
+ $this->params = $subNodes['params'] ?? [];
+ $this->returnType = $subNodes['returnType'] ?? null;
+ $this->expr = $subNodes['expr'];
+ $this->attrGroups = $subNodes['attrGroups'] ?? [];
+ }
+
+ public function getSubNodeNames(): array {
+ return ['attrGroups', 'static', 'byRef', 'params', 'returnType', 'expr'];
+ }
+
+ public function returnsByRef(): bool {
+ return $this->byRef;
+ }
+
+ public function getParams(): array {
+ return $this->params;
+ }
+
+ public function getReturnType() {
+ return $this->returnType;
+ }
+
+ public function getAttrGroups(): array {
+ return $this->attrGroups;
+ }
+
+ /**
+ * @return Node\Stmt\Return_[]
+ */
+ public function getStmts(): array {
+ return [new Node\Stmt\Return_($this->expr)];
+ }
+
+ public function getType(): string {
+ return 'Expr_ArrowFunction';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Assign.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Assign.php
new file mode 100644
index 0000000..dcbf84d
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Assign.php
@@ -0,0 +1,33 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Expr $var, Expr $expr, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->var = $var;
+ $this->expr = $expr;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['var', 'expr'];
+ }
+
+ public function getType(): string {
+ return 'Expr_Assign';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp.php
new file mode 100644
index 0000000..5209a64
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp.php
@@ -0,0 +1,29 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Expr $var, Expr $expr, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->var = $var;
+ $this->expr = $expr;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['var', 'expr'];
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/BitwiseAnd.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/BitwiseAnd.php
new file mode 100644
index 0000000..4f3623f
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/AssignOp/BitwiseAnd.php
@@ -0,0 +1,11 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Expr $var, Expr $expr, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->var = $var;
+ $this->expr = $expr;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['var', 'expr'];
+ }
+
+ public function getType(): string {
+ return 'Expr_AssignRef';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp.php
new file mode 100644
index 0000000..1b92bd4
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp.php
@@ -0,0 +1,37 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Expr $left, Expr $right, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->left = $left;
+ $this->right = $right;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['left', 'right'];
+ }
+
+ /**
+ * Get the operator sigil for this binary operation.
+ *
+ * In the case there are multiple possible sigils for an operator, this method does not
+ * necessarily return the one used in the parsed code.
+ */
+ abstract public function getOperatorSigil(): string;
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/BitwiseAnd.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/BitwiseAnd.php
new file mode 100644
index 0000000..5930c54
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/BitwiseAnd.php
@@ -0,0 +1,15 @@
+';
+ }
+
+ public function getType(): string {
+ return 'Expr_BinaryOp_Greater';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/GreaterOrEqual.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/GreaterOrEqual.php
new file mode 100644
index 0000000..4d440b1
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/GreaterOrEqual.php
@@ -0,0 +1,15 @@
+=';
+ }
+
+ public function getType(): string {
+ return 'Expr_BinaryOp_GreaterOrEqual';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Identical.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Identical.php
new file mode 100644
index 0000000..e25d17c
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Identical.php
@@ -0,0 +1,15 @@
+';
+ }
+
+ public function getType(): string {
+ return 'Expr_BinaryOp_Pipe';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Plus.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Plus.php
new file mode 100644
index 0000000..fe34b84
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Plus.php
@@ -0,0 +1,15 @@
+>';
+ }
+
+ public function getType(): string {
+ return 'Expr_BinaryOp_ShiftRight';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Smaller.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Smaller.php
new file mode 100644
index 0000000..01e9b23
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BinaryOp/Smaller.php
@@ -0,0 +1,15 @@
+';
+ }
+
+ public function getType(): string {
+ return 'Expr_BinaryOp_Spaceship';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BitwiseNot.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BitwiseNot.php
new file mode 100644
index 0000000..b7175a7
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BitwiseNot.php
@@ -0,0 +1,29 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Expr $expr, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->expr = $expr;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['expr'];
+ }
+
+ public function getType(): string {
+ return 'Expr_BitwiseNot';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BooleanNot.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BooleanNot.php
new file mode 100644
index 0000000..c66d233
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/BooleanNot.php
@@ -0,0 +1,29 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Expr $expr, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->expr = $expr;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['expr'];
+ }
+
+ public function getType(): string {
+ return 'Expr_BooleanNot';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/CallLike.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/CallLike.php
new file mode 100644
index 0000000..86e781c
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/CallLike.php
@@ -0,0 +1,60 @@
+
+ */
+ abstract public function getRawArgs(): array;
+
+ /**
+ * Returns whether this call expression is actually a first class callable.
+ */
+ public function isFirstClassCallable(): bool {
+ $rawArgs = $this->getRawArgs();
+ return count($rawArgs) === 1 && current($rawArgs) instanceof VariadicPlaceholder;
+ }
+
+ /**
+ * Assert that this is not a first-class callable and return only ordinary Args.
+ *
+ * @return Arg[]
+ */
+ public function getArgs(): array {
+ assert(!$this->isFirstClassCallable());
+ return $this->getRawArgs();
+ }
+
+ /**
+ * Retrieves a specific argument from the raw arguments.
+ *
+ * Returns the named argument that matches the given `$name`, or the
+ * positional (unnamed) argument that exists at the given `$position`,
+ * otherwise, returns `null` for first-class callables or if no match is found.
+ */
+ public function getArg(string $name, int $position): ?Arg {
+ if ($this->isFirstClassCallable()) {
+ return null;
+ }
+ foreach ($this->getRawArgs() as $i => $arg) {
+ if ($arg->unpack) {
+ continue;
+ }
+ if (
+ ($arg->name !== null && $arg->name->toString() === $name)
+ || ($arg->name === null && $i === $position)
+ ) {
+ return $arg;
+ }
+ }
+ return null;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Cast.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Cast.php
new file mode 100644
index 0000000..c2751de
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Cast.php
@@ -0,0 +1,25 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Expr $expr, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->expr = $expr;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['expr'];
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Cast/Array_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Cast/Array_.php
new file mode 100644
index 0000000..471cb82
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Cast/Array_.php
@@ -0,0 +1,11 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Node $class, $name, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->class = $class;
+ $this->name = \is_string($name) ? new Identifier($name) : $name;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['class', 'name'];
+ }
+
+ public function getType(): string {
+ return 'Expr_ClassConstFetch';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Clone_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Clone_.php
new file mode 100644
index 0000000..d85bc9a
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Clone_.php
@@ -0,0 +1,29 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Expr $expr, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->expr = $expr;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['expr'];
+ }
+
+ public function getType(): string {
+ return 'Expr_Clone';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Closure.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Closure.php
new file mode 100644
index 0000000..0680446
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Closure.php
@@ -0,0 +1,86 @@
+ false : Whether the closure is static
+ * 'byRef' => false : Whether to return by reference
+ * 'params' => array(): Parameters
+ * 'uses' => array(): use()s
+ * 'returnType' => null : Return type
+ * 'stmts' => array(): Statements
+ * 'attrGroups' => array(): PHP attributes groups
+ * @param array $attributes Additional attributes
+ */
+ public function __construct(array $subNodes = [], array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->static = $subNodes['static'] ?? false;
+ $this->byRef = $subNodes['byRef'] ?? false;
+ $this->params = $subNodes['params'] ?? [];
+ $this->uses = $subNodes['uses'] ?? [];
+ $this->returnType = $subNodes['returnType'] ?? null;
+ $this->stmts = $subNodes['stmts'] ?? [];
+ $this->attrGroups = $subNodes['attrGroups'] ?? [];
+ }
+
+ public function getSubNodeNames(): array {
+ return ['attrGroups', 'static', 'byRef', 'params', 'uses', 'returnType', 'stmts'];
+ }
+
+ public function returnsByRef(): bool {
+ return $this->byRef;
+ }
+
+ public function getParams(): array {
+ return $this->params;
+ }
+
+ public function getReturnType() {
+ return $this->returnType;
+ }
+
+ /** @return Node\Stmt[] */
+ public function getStmts(): array {
+ return $this->stmts;
+ }
+
+ public function getAttrGroups(): array {
+ return $this->attrGroups;
+ }
+
+ public function getType(): string {
+ return 'Expr_Closure';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/ClosureUse.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/ClosureUse.php
new file mode 100644
index 0000000..279aa26
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/ClosureUse.php
@@ -0,0 +1,15 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Name $name, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->name = $name;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['name'];
+ }
+
+ public function getType(): string {
+ return 'Expr_ConstFetch';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Empty_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Empty_.php
new file mode 100644
index 0000000..d2f3050
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Empty_.php
@@ -0,0 +1,29 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Expr $expr, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->expr = $expr;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['expr'];
+ }
+
+ public function getType(): string {
+ return 'Expr_Empty';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Error.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Error.php
new file mode 100644
index 0000000..43010ac
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Error.php
@@ -0,0 +1,30 @@
+ $attributes Additional attributes
+ */
+ public function __construct(array $attributes = []) {
+ $this->attributes = $attributes;
+ }
+
+ public function getSubNodeNames(): array {
+ return [];
+ }
+
+ public function getType(): string {
+ return 'Expr_Error';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/ErrorSuppress.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/ErrorSuppress.php
new file mode 100644
index 0000000..32625a2
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/ErrorSuppress.php
@@ -0,0 +1,29 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Expr $expr, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->expr = $expr;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['expr'];
+ }
+
+ public function getType(): string {
+ return 'Expr_ErrorSuppress';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Eval_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Eval_.php
new file mode 100644
index 0000000..5120b1b
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Eval_.php
@@ -0,0 +1,29 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Expr $expr, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->expr = $expr;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['expr'];
+ }
+
+ public function getType(): string {
+ return 'Expr_Eval';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Exit_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Exit_.php
new file mode 100644
index 0000000..cf00246
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Exit_.php
@@ -0,0 +1,33 @@
+ $attributes Additional attributes
+ */
+ public function __construct(?Expr $expr = null, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->expr = $expr;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['expr'];
+ }
+
+ public function getType(): string {
+ return 'Expr_Exit';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/FuncCall.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/FuncCall.php
new file mode 100644
index 0000000..0b85840
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/FuncCall.php
@@ -0,0 +1,38 @@
+ Arguments */
+ public array $args;
+
+ /**
+ * Constructs a function call node.
+ *
+ * @param Node\Name|Expr $name Function name
+ * @param array $args Arguments
+ * @param array $attributes Additional attributes
+ */
+ public function __construct(Node $name, array $args = [], array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->name = $name;
+ $this->args = $args;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['name', 'args'];
+ }
+
+ public function getType(): string {
+ return 'Expr_FuncCall';
+ }
+
+ public function getRawArgs(): array {
+ return $this->args;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Include_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Include_.php
new file mode 100644
index 0000000..e1187b1
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Include_.php
@@ -0,0 +1,38 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Expr $expr, int $type, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->expr = $expr;
+ $this->type = $type;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['expr', 'type'];
+ }
+
+ public function getType(): string {
+ return 'Expr_Include';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Instanceof_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Instanceof_.php
new file mode 100644
index 0000000..a2783cb
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Instanceof_.php
@@ -0,0 +1,35 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Expr $expr, Node $class, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->expr = $expr;
+ $this->class = $class;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['expr', 'class'];
+ }
+
+ public function getType(): string {
+ return 'Expr_Instanceof';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Isset_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Isset_.php
new file mode 100644
index 0000000..4f80fff
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Isset_.php
@@ -0,0 +1,29 @@
+ $attributes Additional attributes
+ */
+ public function __construct(array $vars, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->vars = $vars;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['vars'];
+ }
+
+ public function getType(): string {
+ return 'Expr_Isset';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/List_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/List_.php
new file mode 100644
index 0000000..496b7b3
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/List_.php
@@ -0,0 +1,34 @@
+ $attributes Additional attributes
+ */
+ public function __construct(array $items, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->items = $items;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['items'];
+ }
+
+ public function getType(): string {
+ return 'Expr_List';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Match_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Match_.php
new file mode 100644
index 0000000..cd028a2
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Match_.php
@@ -0,0 +1,32 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Node\Expr $cond, array $arms = [], array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->cond = $cond;
+ $this->arms = $arms;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['cond', 'arms'];
+ }
+
+ public function getType(): string {
+ return 'Expr_Match';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/MethodCall.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/MethodCall.php
new file mode 100644
index 0000000..2703c75
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/MethodCall.php
@@ -0,0 +1,45 @@
+ Arguments */
+ public array $args;
+
+ /**
+ * Constructs a function call node.
+ *
+ * @param Expr $var Variable holding object
+ * @param string|Identifier|Expr $name Method name
+ * @param array $args Arguments
+ * @param array $attributes Additional attributes
+ */
+ public function __construct(Expr $var, $name, array $args = [], array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->var = $var;
+ $this->name = \is_string($name) ? new Identifier($name) : $name;
+ $this->args = $args;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['var', 'name', 'args'];
+ }
+
+ public function getType(): string {
+ return 'Expr_MethodCall';
+ }
+
+ public function getRawArgs(): array {
+ return $this->args;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/New_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/New_.php
new file mode 100644
index 0000000..eedaaa1
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/New_.php
@@ -0,0 +1,40 @@
+ Arguments */
+ public array $args;
+
+ /**
+ * Constructs a function call node.
+ *
+ * @param Node\Name|Expr|Node\Stmt\Class_ $class Class name (or class node for anonymous classes)
+ * @param array $args Arguments
+ * @param array $attributes Additional attributes
+ */
+ public function __construct(Node $class, array $args = [], array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->class = $class;
+ $this->args = $args;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['class', 'args'];
+ }
+
+ public function getType(): string {
+ return 'Expr_New';
+ }
+
+ public function getRawArgs(): array {
+ return $this->args;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/NullsafeMethodCall.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/NullsafeMethodCall.php
new file mode 100644
index 0000000..a151f71
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/NullsafeMethodCall.php
@@ -0,0 +1,45 @@
+ Arguments */
+ public array $args;
+
+ /**
+ * Constructs a nullsafe method call node.
+ *
+ * @param Expr $var Variable holding object
+ * @param string|Identifier|Expr $name Method name
+ * @param array $args Arguments
+ * @param array $attributes Additional attributes
+ */
+ public function __construct(Expr $var, $name, array $args = [], array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->var = $var;
+ $this->name = \is_string($name) ? new Identifier($name) : $name;
+ $this->args = $args;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['var', 'name', 'args'];
+ }
+
+ public function getType(): string {
+ return 'Expr_NullsafeMethodCall';
+ }
+
+ public function getRawArgs(): array {
+ return $this->args;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/NullsafePropertyFetch.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/NullsafePropertyFetch.php
new file mode 100644
index 0000000..6f73a16
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/NullsafePropertyFetch.php
@@ -0,0 +1,35 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Expr $var, $name, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->var = $var;
+ $this->name = \is_string($name) ? new Identifier($name) : $name;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['var', 'name'];
+ }
+
+ public function getType(): string {
+ return 'Expr_NullsafePropertyFetch';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/PostDec.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/PostDec.php
new file mode 100644
index 0000000..3dca8fd
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/PostDec.php
@@ -0,0 +1,29 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Expr $var, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->var = $var;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['var'];
+ }
+
+ public function getType(): string {
+ return 'Expr_PostDec';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/PostInc.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/PostInc.php
new file mode 100644
index 0000000..bc990c3
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/PostInc.php
@@ -0,0 +1,29 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Expr $var, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->var = $var;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['var'];
+ }
+
+ public function getType(): string {
+ return 'Expr_PostInc';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/PreDec.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/PreDec.php
new file mode 100644
index 0000000..2f16873
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/PreDec.php
@@ -0,0 +1,29 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Expr $var, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->var = $var;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['var'];
+ }
+
+ public function getType(): string {
+ return 'Expr_PreDec';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/PreInc.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/PreInc.php
new file mode 100644
index 0000000..fd455f5
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/PreInc.php
@@ -0,0 +1,29 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Expr $var, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->var = $var;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['var'];
+ }
+
+ public function getType(): string {
+ return 'Expr_PreInc';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Print_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Print_.php
new file mode 100644
index 0000000..6057476
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Print_.php
@@ -0,0 +1,29 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Expr $expr, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->expr = $expr;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['expr'];
+ }
+
+ public function getType(): string {
+ return 'Expr_Print';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/PropertyFetch.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/PropertyFetch.php
new file mode 100644
index 0000000..8c416a8
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/PropertyFetch.php
@@ -0,0 +1,35 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Expr $var, $name, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->var = $var;
+ $this->name = \is_string($name) ? new Identifier($name) : $name;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['var', 'name'];
+ }
+
+ public function getType(): string {
+ return 'Expr_PropertyFetch';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/ShellExec.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/ShellExec.php
new file mode 100644
index 0000000..e400351
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/ShellExec.php
@@ -0,0 +1,30 @@
+ $attributes Additional attributes
+ */
+ public function __construct(array $parts, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->parts = $parts;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['parts'];
+ }
+
+ public function getType(): string {
+ return 'Expr_ShellExec';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/StaticCall.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/StaticCall.php
new file mode 100644
index 0000000..707f34b
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/StaticCall.php
@@ -0,0 +1,45 @@
+ Arguments */
+ public array $args;
+
+ /**
+ * Constructs a static method call node.
+ *
+ * @param Node\Name|Expr $class Class name
+ * @param string|Identifier|Expr $name Method name
+ * @param array $args Arguments
+ * @param array $attributes Additional attributes
+ */
+ public function __construct(Node $class, $name, array $args = [], array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->class = $class;
+ $this->name = \is_string($name) ? new Identifier($name) : $name;
+ $this->args = $args;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['class', 'name', 'args'];
+ }
+
+ public function getType(): string {
+ return 'Expr_StaticCall';
+ }
+
+ public function getRawArgs(): array {
+ return $this->args;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/StaticPropertyFetch.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/StaticPropertyFetch.php
new file mode 100644
index 0000000..4836a65
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/StaticPropertyFetch.php
@@ -0,0 +1,36 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Node $class, $name, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->class = $class;
+ $this->name = \is_string($name) ? new VarLikeIdentifier($name) : $name;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['class', 'name'];
+ }
+
+ public function getType(): string {
+ return 'Expr_StaticPropertyFetch';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Ternary.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Ternary.php
new file mode 100644
index 0000000..d4837e6
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Ternary.php
@@ -0,0 +1,37 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Expr $cond, ?Expr $if, Expr $else, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->cond = $cond;
+ $this->if = $if;
+ $this->else = $else;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['cond', 'if', 'else'];
+ }
+
+ public function getType(): string {
+ return 'Expr_Ternary';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Throw_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Throw_.php
new file mode 100644
index 0000000..ee49f83
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Throw_.php
@@ -0,0 +1,29 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Node\Expr $expr, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->expr = $expr;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['expr'];
+ }
+
+ public function getType(): string {
+ return 'Expr_Throw';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/UnaryMinus.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/UnaryMinus.php
new file mode 100644
index 0000000..cd06f74
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/UnaryMinus.php
@@ -0,0 +1,29 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Expr $expr, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->expr = $expr;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['expr'];
+ }
+
+ public function getType(): string {
+ return 'Expr_UnaryMinus';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/UnaryPlus.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/UnaryPlus.php
new file mode 100644
index 0000000..1b44f7b
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/UnaryPlus.php
@@ -0,0 +1,29 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Expr $expr, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->expr = $expr;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['expr'];
+ }
+
+ public function getType(): string {
+ return 'Expr_UnaryPlus';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Variable.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Variable.php
new file mode 100644
index 0000000..bab7492
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Variable.php
@@ -0,0 +1,29 @@
+ $attributes Additional attributes
+ */
+ public function __construct($name, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->name = $name;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['name'];
+ }
+
+ public function getType(): string {
+ return 'Expr_Variable';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/YieldFrom.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/YieldFrom.php
new file mode 100644
index 0000000..5cff88f
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/YieldFrom.php
@@ -0,0 +1,29 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Expr $expr, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->expr = $expr;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['expr'];
+ }
+
+ public function getType(): string {
+ return 'Expr_YieldFrom';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Yield_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Yield_.php
new file mode 100644
index 0000000..bd81e69
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Expr/Yield_.php
@@ -0,0 +1,33 @@
+ $attributes Additional attributes
+ */
+ public function __construct(?Expr $value = null, ?Expr $key = null, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->key = $key;
+ $this->value = $value;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['key', 'value'];
+ }
+
+ public function getType(): string {
+ return 'Expr_Yield';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/FunctionLike.php b/vendor/nikic/php-parser/lib/PhpParser/Node/FunctionLike.php
new file mode 100644
index 0000000..58f653a
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/FunctionLike.php
@@ -0,0 +1,40 @@
+ */
+ private static array $specialClassNames = [
+ 'self' => true,
+ 'parent' => true,
+ 'static' => true,
+ ];
+
+ /**
+ * Constructs an identifier node.
+ *
+ * @param string $name Identifier as string
+ * @param array $attributes Additional attributes
+ */
+ public function __construct(string $name, array $attributes = []) {
+ if ($name === '') {
+ throw new \InvalidArgumentException('Identifier name cannot be empty');
+ }
+
+ $this->attributes = $attributes;
+ $this->name = $name;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['name'];
+ }
+
+ /**
+ * Get identifier as string.
+ *
+ * @psalm-return non-empty-string
+ * @return string Identifier as string.
+ */
+ public function toString(): string {
+ return $this->name;
+ }
+
+ /**
+ * Get lowercased identifier as string.
+ *
+ * @psalm-return non-empty-string&lowercase-string
+ * @return string Lowercased identifier as string
+ */
+ public function toLowerString(): string {
+ return strtolower($this->name);
+ }
+
+ /**
+ * Checks whether the identifier is a special class name (self, parent or static).
+ *
+ * @return bool Whether identifier is a special class name
+ */
+ public function isSpecialClassName(): bool {
+ return isset(self::$specialClassNames[strtolower($this->name)]);
+ }
+
+ /**
+ * Get identifier as string.
+ *
+ * @psalm-return non-empty-string
+ * @return string Identifier as string
+ */
+ public function __toString(): string {
+ return $this->name;
+ }
+
+ public function getType(): string {
+ return 'Identifier';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/InterpolatedStringPart.php b/vendor/nikic/php-parser/lib/PhpParser/Node/InterpolatedStringPart.php
new file mode 100644
index 0000000..576dac4
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/InterpolatedStringPart.php
@@ -0,0 +1,32 @@
+ $attributes Additional attributes
+ */
+ public function __construct(string $value, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->value = $value;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['value'];
+ }
+
+ public function getType(): string {
+ return 'InterpolatedStringPart';
+ }
+}
+
+// @deprecated compatibility alias
+class_alias(InterpolatedStringPart::class, Scalar\EncapsedStringPart::class);
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/IntersectionType.php b/vendor/nikic/php-parser/lib/PhpParser/Node/IntersectionType.php
new file mode 100644
index 0000000..3b39cf1
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/IntersectionType.php
@@ -0,0 +1,27 @@
+ $attributes Additional attributes
+ */
+ public function __construct(array $types, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->types = $types;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['types'];
+ }
+
+ public function getType(): string {
+ return 'IntersectionType';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/MatchArm.php b/vendor/nikic/php-parser/lib/PhpParser/Node/MatchArm.php
new file mode 100644
index 0000000..192216d
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/MatchArm.php
@@ -0,0 +1,29 @@
+ */
+ public ?array $conds;
+ public Expr $body;
+
+ /**
+ * @param null|list $conds
+ */
+ public function __construct(?array $conds, Node\Expr $body, array $attributes = []) {
+ $this->conds = $conds;
+ $this->body = $body;
+ $this->attributes = $attributes;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['conds', 'body'];
+ }
+
+ public function getType(): string {
+ return 'MatchArm';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Name.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Name.php
new file mode 100644
index 0000000..932080b
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Name.php
@@ -0,0 +1,278 @@
+ */
+ private static array $specialClassNames = [
+ 'self' => true,
+ 'parent' => true,
+ 'static' => true,
+ ];
+
+ /**
+ * Constructs a name node.
+ *
+ * @param string|string[]|self $name Name as string, part array or Name instance (copy ctor)
+ * @param array $attributes Additional attributes
+ */
+ final public function __construct($name, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->name = self::prepareName($name);
+ }
+
+ public function getSubNodeNames(): array {
+ return ['name'];
+ }
+
+ /**
+ * Get parts of name (split by the namespace separator).
+ *
+ * @psalm-return non-empty-list
+ * @return string[] Parts of name
+ */
+ public function getParts(): array {
+ return \explode('\\', $this->name);
+ }
+
+ /**
+ * Gets the first part of the name, i.e. everything before the first namespace separator.
+ *
+ * @return string First part of the name
+ */
+ public function getFirst(): string {
+ if (false !== $pos = \strpos($this->name, '\\')) {
+ return \substr($this->name, 0, $pos);
+ }
+ return $this->name;
+ }
+
+ /**
+ * Gets the last part of the name, i.e. everything after the last namespace separator.
+ *
+ * @return string Last part of the name
+ */
+ public function getLast(): string {
+ if (false !== $pos = \strrpos($this->name, '\\')) {
+ return \substr($this->name, $pos + 1);
+ }
+ return $this->name;
+ }
+
+ /**
+ * Checks whether the name is unqualified. (E.g. Name)
+ *
+ * @return bool Whether the name is unqualified
+ */
+ public function isUnqualified(): bool {
+ return false === \strpos($this->name, '\\');
+ }
+
+ /**
+ * Checks whether the name is qualified. (E.g. Name\Name)
+ *
+ * @return bool Whether the name is qualified
+ */
+ public function isQualified(): bool {
+ return false !== \strpos($this->name, '\\');
+ }
+
+ /**
+ * Checks whether the name is fully qualified. (E.g. \Name)
+ *
+ * @return bool Whether the name is fully qualified
+ */
+ public function isFullyQualified(): bool {
+ return false;
+ }
+
+ /**
+ * Checks whether the name is explicitly relative to the current namespace. (E.g. namespace\Name)
+ *
+ * @return bool Whether the name is relative
+ */
+ public function isRelative(): bool {
+ return false;
+ }
+
+ /**
+ * Returns a string representation of the name itself, without taking the name type into
+ * account (e.g., not including a leading backslash for fully qualified names).
+ *
+ * @psalm-return non-empty-string
+ * @return string String representation
+ */
+ public function toString(): string {
+ return $this->name;
+ }
+
+ /**
+ * Returns a string representation of the name as it would occur in code (e.g., including
+ * leading backslash for fully qualified names.
+ *
+ * @psalm-return non-empty-string
+ * @return string String representation
+ */
+ public function toCodeString(): string {
+ return $this->toString();
+ }
+
+ /**
+ * Returns lowercased string representation of the name, without taking the name type into
+ * account (e.g., no leading backslash for fully qualified names).
+ *
+ * @psalm-return non-empty-string&lowercase-string
+ * @return string Lowercased string representation
+ */
+ public function toLowerString(): string {
+ return strtolower($this->name);
+ }
+
+ /**
+ * Checks whether the identifier is a special class name (self, parent or static).
+ *
+ * @return bool Whether identifier is a special class name
+ */
+ public function isSpecialClassName(): bool {
+ return isset(self::$specialClassNames[strtolower($this->name)]);
+ }
+
+ /**
+ * Returns a string representation of the name by imploding the namespace parts with the
+ * namespace separator.
+ *
+ * @psalm-return non-empty-string
+ * @return string String representation
+ */
+ public function __toString(): string {
+ return $this->name;
+ }
+
+ /**
+ * Gets a slice of a name (similar to array_slice).
+ *
+ * This method returns a new instance of the same type as the original and with the same
+ * attributes.
+ *
+ * If the slice is empty, null is returned. The null value will be correctly handled in
+ * concatenations using concat().
+ *
+ * Offset and length have the same meaning as in array_slice().
+ *
+ * @param int $offset Offset to start the slice at (may be negative)
+ * @param int|null $length Length of the slice (may be negative)
+ *
+ * @return static|null Sliced name
+ */
+ public function slice(int $offset, ?int $length = null) {
+ if ($offset === 1 && $length === null) {
+ // Short-circuit the common case.
+ if (false !== $pos = \strpos($this->name, '\\')) {
+ return new static(\substr($this->name, $pos + 1));
+ }
+ return null;
+ }
+
+ $parts = \explode('\\', $this->name);
+ $numParts = \count($parts);
+
+ $realOffset = $offset < 0 ? $offset + $numParts : $offset;
+ if ($realOffset < 0 || $realOffset > $numParts) {
+ throw new \OutOfBoundsException(sprintf('Offset %d is out of bounds', $offset));
+ }
+
+ if (null === $length) {
+ $realLength = $numParts - $realOffset;
+ } else {
+ $realLength = $length < 0 ? $length + $numParts - $realOffset : $length;
+ if ($realLength < 0 || $realLength > $numParts - $realOffset) {
+ throw new \OutOfBoundsException(sprintf('Length %d is out of bounds', $length));
+ }
+ }
+
+ if ($realLength === 0) {
+ // Empty slice is represented as null
+ return null;
+ }
+
+ return new static(array_slice($parts, $realOffset, $realLength), $this->attributes);
+ }
+
+ /**
+ * Concatenate two names, yielding a new Name instance.
+ *
+ * The type of the generated instance depends on which class this method is called on, for
+ * example Name\FullyQualified::concat() will yield a Name\FullyQualified instance.
+ *
+ * If one of the arguments is null, a new instance of the other name will be returned. If both
+ * arguments are null, null will be returned. As such, writing
+ * Name::concat($namespace, $shortName)
+ * where $namespace is a Name node or null will work as expected.
+ *
+ * @param string|string[]|self|null $name1 The first name
+ * @param string|string[]|self|null $name2 The second name
+ * @param array $attributes Attributes to assign to concatenated name
+ *
+ * @return static|null Concatenated name
+ */
+ public static function concat($name1, $name2, array $attributes = []) {
+ if (null === $name1 && null === $name2) {
+ return null;
+ }
+ if (null === $name1) {
+ return new static($name2, $attributes);
+ }
+ if (null === $name2) {
+ return new static($name1, $attributes);
+ } else {
+ return new static(
+ self::prepareName($name1) . '\\' . self::prepareName($name2), $attributes
+ );
+ }
+ }
+
+ /**
+ * Prepares a (string, array or Name node) name for use in name changing methods by converting
+ * it to a string.
+ *
+ * @param string|string[]|self $name Name to prepare
+ *
+ * @psalm-return non-empty-string
+ * @return string Prepared name
+ */
+ private static function prepareName($name): string {
+ if (\is_string($name)) {
+ if ('' === $name) {
+ throw new \InvalidArgumentException('Name cannot be empty');
+ }
+
+ return $name;
+ }
+ if (\is_array($name)) {
+ if (empty($name)) {
+ throw new \InvalidArgumentException('Name cannot be empty');
+ }
+
+ return implode('\\', $name);
+ }
+ if ($name instanceof self) {
+ return $name->name;
+ }
+
+ throw new \InvalidArgumentException(
+ 'Expected string, array of parts or Name instance'
+ );
+ }
+
+ public function getType(): string {
+ return 'Name';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Name/FullyQualified.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Name/FullyQualified.php
new file mode 100644
index 0000000..2118378
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Name/FullyQualified.php
@@ -0,0 +1,49 @@
+toString();
+ }
+
+ public function getType(): string {
+ return 'Name_FullyQualified';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Name/Relative.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Name/Relative.php
new file mode 100644
index 0000000..0226a4e
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Name/Relative.php
@@ -0,0 +1,49 @@
+toString();
+ }
+
+ public function getType(): string {
+ return 'Name_Relative';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/NullableType.php b/vendor/nikic/php-parser/lib/PhpParser/Node/NullableType.php
new file mode 100644
index 0000000..b99acd1
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/NullableType.php
@@ -0,0 +1,29 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Node $type, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->type = $type;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['type'];
+ }
+
+ public function getType(): string {
+ return 'NullableType';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Param.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Param.php
new file mode 100644
index 0000000..6cbb84c
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Param.php
@@ -0,0 +1,123 @@
+ $attributes Additional attributes
+ * @param int $flags Optional visibility flags
+ * @param list $attrGroups PHP attribute groups
+ * @param PropertyHook[] $hooks Property hooks for promoted properties
+ */
+ public function __construct(
+ Expr $var, ?Expr $default = null, ?Node $type = null,
+ bool $byRef = false, bool $variadic = false,
+ array $attributes = [],
+ int $flags = 0,
+ array $attrGroups = [],
+ array $hooks = []
+ ) {
+ $this->attributes = $attributes;
+ $this->type = $type;
+ $this->byRef = $byRef;
+ $this->variadic = $variadic;
+ $this->var = $var;
+ $this->default = $default;
+ $this->flags = $flags;
+ $this->attrGroups = $attrGroups;
+ $this->hooks = $hooks;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['attrGroups', 'flags', 'type', 'byRef', 'variadic', 'var', 'default', 'hooks'];
+ }
+
+ public function getType(): string {
+ return 'Param';
+ }
+
+ /**
+ * Whether this parameter uses constructor property promotion.
+ */
+ public function isPromoted(): bool {
+ return $this->flags !== 0 || $this->hooks !== [];
+ }
+
+ public function isFinal(): bool {
+ return (bool) ($this->flags & Modifiers::FINAL);
+ }
+
+ public function isPublic(): bool {
+ $public = (bool) ($this->flags & Modifiers::PUBLIC);
+ if ($public) {
+ return true;
+ }
+
+ if (!$this->isPromoted()) {
+ return false;
+ }
+
+ return ($this->flags & Modifiers::VISIBILITY_MASK) === 0;
+ }
+
+ public function isProtected(): bool {
+ return (bool) ($this->flags & Modifiers::PROTECTED);
+ }
+
+ public function isPrivate(): bool {
+ return (bool) ($this->flags & Modifiers::PRIVATE);
+ }
+
+ public function isReadonly(): bool {
+ return (bool) ($this->flags & Modifiers::READONLY);
+ }
+
+ /**
+ * Whether the promoted property has explicit public(set) visibility.
+ */
+ public function isPublicSet(): bool {
+ return (bool) ($this->flags & Modifiers::PUBLIC_SET);
+ }
+
+ /**
+ * Whether the promoted property has explicit protected(set) visibility.
+ */
+ public function isProtectedSet(): bool {
+ return (bool) ($this->flags & Modifiers::PROTECTED_SET);
+ }
+
+ /**
+ * Whether the promoted property has explicit private(set) visibility.
+ */
+ public function isPrivateSet(): bool {
+ return (bool) ($this->flags & Modifiers::PRIVATE_SET);
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/PropertyHook.php b/vendor/nikic/php-parser/lib/PhpParser/Node/PropertyHook.php
new file mode 100644
index 0000000..349b9ce
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/PropertyHook.php
@@ -0,0 +1,105 @@
+ 0 : Flags
+ * 'byRef' => false : Whether hook returns by reference
+ * 'params' => array(): Parameters
+ * 'attrGroups' => array(): PHP attribute groups
+ * @param array $attributes Additional attributes
+ */
+ public function __construct($name, $body, array $subNodes = [], array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->name = \is_string($name) ? new Identifier($name) : $name;
+ $this->body = $body;
+ $this->flags = $subNodes['flags'] ?? 0;
+ $this->byRef = $subNodes['byRef'] ?? false;
+ $this->params = $subNodes['params'] ?? [];
+ $this->attrGroups = $subNodes['attrGroups'] ?? [];
+ }
+
+ public function returnsByRef(): bool {
+ return $this->byRef;
+ }
+
+ public function getParams(): array {
+ return $this->params;
+ }
+
+ public function getReturnType() {
+ return null;
+ }
+
+ /**
+ * Whether the property hook is final.
+ */
+ public function isFinal(): bool {
+ return (bool) ($this->flags & Modifiers::FINAL);
+ }
+
+ public function getStmts(): ?array {
+ if ($this->body instanceof Expr) {
+ $name = $this->name->toLowerString();
+ if ($name === 'get') {
+ return [new Return_($this->body)];
+ }
+ if ($name === 'set') {
+ if (!$this->hasAttribute('propertyName')) {
+ throw new \LogicException(
+ 'Can only use getStmts() on a "set" hook if the "propertyName" attribute is set');
+ }
+
+ $propName = $this->getAttribute('propertyName');
+ $prop = new PropertyFetch(new Variable('this'), (string) $propName);
+ return [new Expression(new Assign($prop, $this->body))];
+ }
+ throw new \LogicException('Unknown property hook "' . $name . '"');
+ }
+ return $this->body;
+ }
+
+ public function getAttrGroups(): array {
+ return $this->attrGroups;
+ }
+
+ public function getType(): string {
+ return 'PropertyHook';
+ }
+
+ public function getSubNodeNames(): array {
+ return ['attrGroups', 'flags', 'byRef', 'name', 'params', 'body'];
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/PropertyItem.php b/vendor/nikic/php-parser/lib/PhpParser/Node/PropertyItem.php
new file mode 100644
index 0000000..101611e
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/PropertyItem.php
@@ -0,0 +1,37 @@
+ $attributes Additional attributes
+ */
+ public function __construct($name, ?Node\Expr $default = null, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->name = \is_string($name) ? new Node\VarLikeIdentifier($name) : $name;
+ $this->default = $default;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['name', 'default'];
+ }
+
+ public function getType(): string {
+ return 'PropertyItem';
+ }
+}
+
+// @deprecated compatibility alias
+class_alias(PropertyItem::class, Stmt\PropertyProperty::class);
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar.php
new file mode 100644
index 0000000..3df2572
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar.php
@@ -0,0 +1,6 @@
+ $attributes Additional attributes
+ */
+ public function __construct(float $value, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->value = $value;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['value'];
+ }
+
+ /**
+ * @param mixed[] $attributes
+ */
+ public static function fromString(string $str, array $attributes = []): Float_ {
+ $attributes['rawValue'] = $str;
+ $float = self::parse($str);
+
+ return new Float_($float, $attributes);
+ }
+
+ /**
+ * @internal
+ *
+ * Parses a DNUMBER token like PHP would.
+ *
+ * @param string $str A string number
+ *
+ * @return float The parsed number
+ */
+ public static function parse(string $str): float {
+ $str = str_replace('_', '', $str);
+
+ // Check whether this is one of the special integer notations.
+ if ('0' === $str[0]) {
+ // hex
+ if ('x' === $str[1] || 'X' === $str[1]) {
+ return hexdec($str);
+ }
+
+ // bin
+ if ('b' === $str[1] || 'B' === $str[1]) {
+ return bindec($str);
+ }
+
+ // oct, but only if the string does not contain any of '.eE'.
+ if (false === strpbrk($str, '.eE')) {
+ // substr($str, 0, strcspn($str, '89')) cuts the string at the first invalid digit
+ // (8 or 9) so that only the digits before that are used.
+ return octdec(substr($str, 0, strcspn($str, '89')));
+ }
+ }
+
+ // dec
+ return (float) $str;
+ }
+
+ public function getType(): string {
+ return 'Scalar_Float';
+ }
+}
+
+// @deprecated compatibility alias
+class_alias(Float_::class, DNumber::class);
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/Int_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/Int_.php
new file mode 100644
index 0000000..bcc257a
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/Int_.php
@@ -0,0 +1,82 @@
+ $attributes Additional attributes
+ */
+ public function __construct(int $value, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->value = $value;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['value'];
+ }
+
+ /**
+ * Constructs an Int node from a string number literal.
+ *
+ * @param string $str String number literal (decimal, octal, hex or binary)
+ * @param array $attributes Additional attributes
+ * @param bool $allowInvalidOctal Whether to allow invalid octal numbers (PHP 5)
+ *
+ * @return Int_ The constructed LNumber, including kind attribute
+ */
+ public static function fromString(string $str, array $attributes = [], bool $allowInvalidOctal = false): Int_ {
+ $attributes['rawValue'] = $str;
+
+ $str = str_replace('_', '', $str);
+
+ if ('0' !== $str[0] || '0' === $str) {
+ $attributes['kind'] = Int_::KIND_DEC;
+ return new Int_((int) $str, $attributes);
+ }
+
+ if ('x' === $str[1] || 'X' === $str[1]) {
+ $attributes['kind'] = Int_::KIND_HEX;
+ return new Int_(hexdec($str), $attributes);
+ }
+
+ if ('b' === $str[1] || 'B' === $str[1]) {
+ $attributes['kind'] = Int_::KIND_BIN;
+ return new Int_(bindec($str), $attributes);
+ }
+
+ if (!$allowInvalidOctal && strpbrk($str, '89')) {
+ throw new Error('Invalid numeric literal', $attributes);
+ }
+
+ // Strip optional explicit octal prefix.
+ if ('o' === $str[1] || 'O' === $str[1]) {
+ $str = substr($str, 2);
+ }
+
+ // use intval instead of octdec to get proper cutting behavior with malformed numbers
+ $attributes['kind'] = Int_::KIND_OCT;
+ return new Int_(intval($str, 8), $attributes);
+ }
+
+ public function getType(): string {
+ return 'Scalar_Int';
+ }
+}
+
+// @deprecated compatibility alias
+class_alias(Int_::class, LNumber::class);
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/InterpolatedString.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/InterpolatedString.php
new file mode 100644
index 0000000..9336dfe
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/InterpolatedString.php
@@ -0,0 +1,34 @@
+ $attributes Additional attributes
+ */
+ public function __construct(array $parts, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->parts = $parts;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['parts'];
+ }
+
+ public function getType(): string {
+ return 'Scalar_InterpolatedString';
+ }
+}
+
+// @deprecated compatibility alias
+class_alias(InterpolatedString::class, Encapsed::class);
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/LNumber.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/LNumber.php
new file mode 100644
index 0000000..868d78f
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/LNumber.php
@@ -0,0 +1,15 @@
+ $attributes Additional attributes
+ */
+ public function __construct(array $attributes = []) {
+ $this->attributes = $attributes;
+ }
+
+ public function getSubNodeNames(): array {
+ return [];
+ }
+
+ /**
+ * Get name of magic constant.
+ *
+ * @return string Name of magic constant
+ */
+ abstract public function getName(): string;
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/MagicConst/Class_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/MagicConst/Class_.php
new file mode 100644
index 0000000..732ed14
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Scalar/MagicConst/Class_.php
@@ -0,0 +1,15 @@
+ Escaped character to its decoded value */
+ protected static array $replacements = [
+ '\\' => '\\',
+ '$' => '$',
+ 'n' => "\n",
+ 'r' => "\r",
+ 't' => "\t",
+ 'f' => "\f",
+ 'v' => "\v",
+ 'e' => "\x1B",
+ ];
+
+ /**
+ * Constructs a string scalar node.
+ *
+ * @param string $value Value of the string
+ * @param array $attributes Additional attributes
+ */
+ public function __construct(string $value, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->value = $value;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['value'];
+ }
+
+ /**
+ * @param array $attributes
+ * @param bool $parseUnicodeEscape Whether to parse PHP 7 \u escapes
+ */
+ public static function fromString(string $str, array $attributes = [], bool $parseUnicodeEscape = true): self {
+ $attributes['kind'] = ($str[0] === "'" || ($str[1] === "'" && ($str[0] === 'b' || $str[0] === 'B')))
+ ? Scalar\String_::KIND_SINGLE_QUOTED
+ : Scalar\String_::KIND_DOUBLE_QUOTED;
+
+ $attributes['rawValue'] = $str;
+
+ $string = self::parse($str, $parseUnicodeEscape);
+
+ return new self($string, $attributes);
+ }
+
+ /**
+ * @internal
+ *
+ * Parses a string token.
+ *
+ * @param string $str String token content
+ * @param bool $parseUnicodeEscape Whether to parse PHP 7 \u escapes
+ *
+ * @return string The parsed string
+ */
+ public static function parse(string $str, bool $parseUnicodeEscape = true): string {
+ $bLength = 0;
+ if ('b' === $str[0] || 'B' === $str[0]) {
+ $bLength = 1;
+ }
+
+ if ('\'' === $str[$bLength]) {
+ return str_replace(
+ ['\\\\', '\\\''],
+ ['\\', '\''],
+ substr($str, $bLength + 1, -1)
+ );
+ } else {
+ return self::parseEscapeSequences(
+ substr($str, $bLength + 1, -1), '"', $parseUnicodeEscape
+ );
+ }
+ }
+
+ /**
+ * @internal
+ *
+ * Parses escape sequences in strings (all string types apart from single quoted).
+ *
+ * @param string $str String without quotes
+ * @param null|string $quote Quote type
+ * @param bool $parseUnicodeEscape Whether to parse PHP 7 \u escapes
+ *
+ * @return string String with escape sequences parsed
+ */
+ public static function parseEscapeSequences(string $str, ?string $quote, bool $parseUnicodeEscape = true): string {
+ if (null !== $quote) {
+ $str = str_replace('\\' . $quote, $quote, $str);
+ }
+
+ $extra = '';
+ if ($parseUnicodeEscape) {
+ $extra = '|u\{([0-9a-fA-F]+)\}';
+ }
+
+ return preg_replace_callback(
+ '~\\\\([\\\\$nrtfve]|[xX][0-9a-fA-F]{1,2}|[0-7]{1,3}' . $extra . ')~',
+ function ($matches) {
+ $str = $matches[1];
+
+ if (isset(self::$replacements[$str])) {
+ return self::$replacements[$str];
+ }
+ if ('x' === $str[0] || 'X' === $str[0]) {
+ return chr(hexdec(substr($str, 1)));
+ }
+ if ('u' === $str[0]) {
+ $dec = hexdec($matches[2]);
+ // If it overflowed to float, treat as INT_MAX, it will throw an error anyway.
+ return self::codePointToUtf8(\is_int($dec) ? $dec : \PHP_INT_MAX);
+ } else {
+ return chr(octdec($str) & 255);
+ }
+ },
+ $str
+ );
+ }
+
+ /**
+ * Converts a Unicode code point to its UTF-8 encoded representation.
+ *
+ * @param int $num Code point
+ *
+ * @return string UTF-8 representation of code point
+ */
+ private static function codePointToUtf8(int $num): string {
+ if ($num <= 0x7F) {
+ return chr($num);
+ }
+ if ($num <= 0x7FF) {
+ return chr(($num >> 6) + 0xC0) . chr(($num & 0x3F) + 0x80);
+ }
+ if ($num <= 0xFFFF) {
+ return chr(($num >> 12) + 0xE0) . chr((($num >> 6) & 0x3F) + 0x80) . chr(($num & 0x3F) + 0x80);
+ }
+ if ($num <= 0x1FFFFF) {
+ return chr(($num >> 18) + 0xF0) . chr((($num >> 12) & 0x3F) + 0x80)
+ . chr((($num >> 6) & 0x3F) + 0x80) . chr(($num & 0x3F) + 0x80);
+ }
+ throw new Error('Invalid UTF-8 codepoint escape sequence: Codepoint too large');
+ }
+
+ public function getType(): string {
+ return 'Scalar_String';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/StaticVar.php b/vendor/nikic/php-parser/lib/PhpParser/Node/StaticVar.php
new file mode 100644
index 0000000..517c0ed
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/StaticVar.php
@@ -0,0 +1,39 @@
+ $attributes Additional attributes
+ */
+ public function __construct(
+ Expr\Variable $var, ?Node\Expr $default = null, array $attributes = []
+ ) {
+ $this->attributes = $attributes;
+ $this->var = $var;
+ $this->default = $default;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['var', 'default'];
+ }
+
+ public function getType(): string {
+ return 'StaticVar';
+ }
+}
+
+// @deprecated compatibility alias
+class_alias(StaticVar::class, Stmt\StaticVar::class);
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt.php
new file mode 100644
index 0000000..481d31a
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt.php
@@ -0,0 +1,8 @@
+ $attributes Additional attributes
+ */
+ public function __construct(array $stmts, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->stmts = $stmts;
+ }
+
+ public function getType(): string {
+ return 'Stmt_Block';
+ }
+
+ public function getSubNodeNames(): array {
+ return ['stmts'];
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Break_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Break_.php
new file mode 100644
index 0000000..d2bcc5e
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Break_.php
@@ -0,0 +1,29 @@
+ $attributes Additional attributes
+ */
+ public function __construct(?Node\Expr $num = null, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->num = $num;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['num'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_Break';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Case_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Case_.php
new file mode 100644
index 0000000..a06ca18
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Case_.php
@@ -0,0 +1,33 @@
+ $attributes Additional attributes
+ */
+ public function __construct(?Node\Expr $cond, array $stmts = [], array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->cond = $cond;
+ $this->stmts = $stmts;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['cond', 'stmts'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_Case';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Catch_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Catch_.php
new file mode 100644
index 0000000..e8d39c9
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Catch_.php
@@ -0,0 +1,40 @@
+ $attributes Additional attributes
+ */
+ public function __construct(
+ array $types, ?Expr\Variable $var = null, array $stmts = [], array $attributes = []
+ ) {
+ $this->attributes = $attributes;
+ $this->types = $types;
+ $this->var = $var;
+ $this->stmts = $stmts;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['types', 'var', 'stmts'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_Catch';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/ClassConst.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/ClassConst.php
new file mode 100644
index 0000000..9bdce1f
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/ClassConst.php
@@ -0,0 +1,77 @@
+ $attributes Additional attributes
+ * @param list $attrGroups PHP attribute groups
+ * @param null|Node\Identifier|Node\Name|Node\ComplexType $type Type declaration
+ */
+ public function __construct(
+ array $consts,
+ int $flags = 0,
+ array $attributes = [],
+ array $attrGroups = [],
+ ?Node $type = null
+ ) {
+ $this->attributes = $attributes;
+ $this->flags = $flags;
+ $this->consts = $consts;
+ $this->attrGroups = $attrGroups;
+ $this->type = $type;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['attrGroups', 'flags', 'type', 'consts'];
+ }
+
+ /**
+ * Whether constant is explicitly or implicitly public.
+ */
+ public function isPublic(): bool {
+ return ($this->flags & Modifiers::PUBLIC) !== 0
+ || ($this->flags & Modifiers::VISIBILITY_MASK) === 0;
+ }
+
+ /**
+ * Whether constant is protected.
+ */
+ public function isProtected(): bool {
+ return (bool) ($this->flags & Modifiers::PROTECTED);
+ }
+
+ /**
+ * Whether constant is private.
+ */
+ public function isPrivate(): bool {
+ return (bool) ($this->flags & Modifiers::PRIVATE);
+ }
+
+ /**
+ * Whether constant is final.
+ */
+ public function isFinal(): bool {
+ return (bool) ($this->flags & Modifiers::FINAL);
+ }
+
+ public function getType(): string {
+ return 'Stmt_ClassConst';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/ClassLike.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/ClassLike.php
new file mode 100644
index 0000000..e652177
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/ClassLike.php
@@ -0,0 +1,109 @@
+
+ */
+ public function getTraitUses(): array {
+ $traitUses = [];
+ foreach ($this->stmts as $stmt) {
+ if ($stmt instanceof TraitUse) {
+ $traitUses[] = $stmt;
+ }
+ }
+ return $traitUses;
+ }
+
+ /**
+ * @return list
+ */
+ public function getConstants(): array {
+ $constants = [];
+ foreach ($this->stmts as $stmt) {
+ if ($stmt instanceof ClassConst) {
+ $constants[] = $stmt;
+ }
+ }
+ return $constants;
+ }
+
+ /**
+ * @return list
+ */
+ public function getProperties(): array {
+ $properties = [];
+ foreach ($this->stmts as $stmt) {
+ if ($stmt instanceof Property) {
+ $properties[] = $stmt;
+ }
+ }
+ return $properties;
+ }
+
+ /**
+ * Gets property with the given name defined directly in this class/interface/trait.
+ *
+ * @param string $name Name of the property
+ *
+ * @return Property|null Property node or null if the property does not exist
+ */
+ public function getProperty(string $name): ?Property {
+ foreach ($this->stmts as $stmt) {
+ if ($stmt instanceof Property) {
+ foreach ($stmt->props as $prop) {
+ if ($prop instanceof PropertyItem && $name === $prop->name->toString()) {
+ return $stmt;
+ }
+ }
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Gets all methods defined directly in this class/interface/trait
+ *
+ * @return list
+ */
+ public function getMethods(): array {
+ $methods = [];
+ foreach ($this->stmts as $stmt) {
+ if ($stmt instanceof ClassMethod) {
+ $methods[] = $stmt;
+ }
+ }
+ return $methods;
+ }
+
+ /**
+ * Gets method with the given name defined directly in this class/interface/trait.
+ *
+ * @param string $name Name of the method (compared case-insensitively)
+ *
+ * @return ClassMethod|null Method node or null if the method does not exist
+ */
+ public function getMethod(string $name): ?ClassMethod {
+ $lowerName = strtolower($name);
+ foreach ($this->stmts as $stmt) {
+ if ($stmt instanceof ClassMethod && $lowerName === $stmt->name->toLowerString()) {
+ return $stmt;
+ }
+ }
+ return null;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/ClassMethod.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/ClassMethod.php
new file mode 100644
index 0000000..59c0519
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/ClassMethod.php
@@ -0,0 +1,154 @@
+ */
+ private static array $magicNames = [
+ '__construct' => true,
+ '__destruct' => true,
+ '__call' => true,
+ '__callstatic' => true,
+ '__get' => true,
+ '__set' => true,
+ '__isset' => true,
+ '__unset' => true,
+ '__sleep' => true,
+ '__wakeup' => true,
+ '__tostring' => true,
+ '__set_state' => true,
+ '__clone' => true,
+ '__invoke' => true,
+ '__debuginfo' => true,
+ '__serialize' => true,
+ '__unserialize' => true,
+ ];
+
+ /**
+ * Constructs a class method node.
+ *
+ * @param string|Node\Identifier $name Name
+ * @param array{
+ * flags?: int,
+ * byRef?: bool,
+ * params?: Node\Param[],
+ * returnType?: null|Node\Identifier|Node\Name|Node\ComplexType,
+ * stmts?: Node\Stmt[]|null,
+ * attrGroups?: Node\AttributeGroup[],
+ * } $subNodes Array of the following optional subnodes:
+ * 'flags => 0 : Flags
+ * 'byRef' => false : Whether to return by reference
+ * 'params' => array() : Parameters
+ * 'returnType' => null : Return type
+ * 'stmts' => array() : Statements
+ * 'attrGroups' => array() : PHP attribute groups
+ * @param array $attributes Additional attributes
+ */
+ public function __construct($name, array $subNodes = [], array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->flags = $subNodes['flags'] ?? $subNodes['type'] ?? 0;
+ $this->byRef = $subNodes['byRef'] ?? false;
+ $this->name = \is_string($name) ? new Node\Identifier($name) : $name;
+ $this->params = $subNodes['params'] ?? [];
+ $this->returnType = $subNodes['returnType'] ?? null;
+ $this->stmts = array_key_exists('stmts', $subNodes) ? $subNodes['stmts'] : [];
+ $this->attrGroups = $subNodes['attrGroups'] ?? [];
+ }
+
+ public function getSubNodeNames(): array {
+ return ['attrGroups', 'flags', 'byRef', 'name', 'params', 'returnType', 'stmts'];
+ }
+
+ public function returnsByRef(): bool {
+ return $this->byRef;
+ }
+
+ public function getParams(): array {
+ return $this->params;
+ }
+
+ public function getReturnType() {
+ return $this->returnType;
+ }
+
+ public function getStmts(): ?array {
+ return $this->stmts;
+ }
+
+ public function getAttrGroups(): array {
+ return $this->attrGroups;
+ }
+
+ /**
+ * Whether the method is explicitly or implicitly public.
+ */
+ public function isPublic(): bool {
+ return ($this->flags & Modifiers::PUBLIC) !== 0
+ || ($this->flags & Modifiers::VISIBILITY_MASK) === 0;
+ }
+
+ /**
+ * Whether the method is protected.
+ */
+ public function isProtected(): bool {
+ return (bool) ($this->flags & Modifiers::PROTECTED);
+ }
+
+ /**
+ * Whether the method is private.
+ */
+ public function isPrivate(): bool {
+ return (bool) ($this->flags & Modifiers::PRIVATE);
+ }
+
+ /**
+ * Whether the method is abstract.
+ */
+ public function isAbstract(): bool {
+ return (bool) ($this->flags & Modifiers::ABSTRACT);
+ }
+
+ /**
+ * Whether the method is final.
+ */
+ public function isFinal(): bool {
+ return (bool) ($this->flags & Modifiers::FINAL);
+ }
+
+ /**
+ * Whether the method is static.
+ */
+ public function isStatic(): bool {
+ return (bool) ($this->flags & Modifiers::STATIC);
+ }
+
+ /**
+ * Whether the method is magic.
+ */
+ public function isMagic(): bool {
+ return isset(self::$magicNames[$this->name->toLowerString()]);
+ }
+
+ public function getType(): string {
+ return 'Stmt_ClassMethod';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Class_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Class_.php
new file mode 100644
index 0000000..3f492b7
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Class_.php
@@ -0,0 +1,94 @@
+ 0 : Flags
+ * 'extends' => null : Name of extended class
+ * 'implements' => array(): Names of implemented interfaces
+ * 'stmts' => array(): Statements
+ * 'attrGroups' => array(): PHP attribute groups
+ * @param array $attributes Additional attributes
+ */
+ public function __construct($name, array $subNodes = [], array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->flags = $subNodes['flags'] ?? $subNodes['type'] ?? 0;
+ $this->name = \is_string($name) ? new Node\Identifier($name) : $name;
+ $this->extends = $subNodes['extends'] ?? null;
+ $this->implements = $subNodes['implements'] ?? [];
+ $this->stmts = $subNodes['stmts'] ?? [];
+ $this->attrGroups = $subNodes['attrGroups'] ?? [];
+ }
+
+ public function getSubNodeNames(): array {
+ return ['attrGroups', 'flags', 'name', 'extends', 'implements', 'stmts'];
+ }
+
+ /**
+ * Whether the class is explicitly abstract.
+ */
+ public function isAbstract(): bool {
+ return (bool) ($this->flags & Modifiers::ABSTRACT);
+ }
+
+ /**
+ * Whether the class is final.
+ */
+ public function isFinal(): bool {
+ return (bool) ($this->flags & Modifiers::FINAL);
+ }
+
+ public function isReadonly(): bool {
+ return (bool) ($this->flags & Modifiers::READONLY);
+ }
+
+ /**
+ * Whether the class is anonymous.
+ */
+ public function isAnonymous(): bool {
+ return null === $this->name;
+ }
+
+ public function getType(): string {
+ return 'Stmt_Class';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Const_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Const_.php
new file mode 100644
index 0000000..c54d678
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Const_.php
@@ -0,0 +1,37 @@
+ $attributes Additional attributes
+ * @param list $attrGroups PHP attribute groups
+ */
+ public function __construct(
+ array $consts,
+ array $attributes = [],
+ array $attrGroups = []
+ ) {
+ $this->attributes = $attributes;
+ $this->attrGroups = $attrGroups;
+ $this->consts = $consts;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['attrGroups', 'consts'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_Const';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Continue_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Continue_.php
new file mode 100644
index 0000000..54e979d
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Continue_.php
@@ -0,0 +1,29 @@
+ $attributes Additional attributes
+ */
+ public function __construct(?Node\Expr $num = null, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->num = $num;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['num'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_Continue';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/DeclareDeclare.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/DeclareDeclare.php
new file mode 100644
index 0000000..c186134
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/DeclareDeclare.php
@@ -0,0 +1,17 @@
+ $attributes Additional attributes
+ */
+ public function __construct(array $declares, ?array $stmts = null, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->declares = $declares;
+ $this->stmts = $stmts;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['declares', 'stmts'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_Declare';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Do_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Do_.php
new file mode 100644
index 0000000..6124442
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Do_.php
@@ -0,0 +1,33 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Node\Expr $cond, array $stmts = [], array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->cond = $cond;
+ $this->stmts = $stmts;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['stmts', 'cond'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_Do';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Echo_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Echo_.php
new file mode 100644
index 0000000..4d42452
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Echo_.php
@@ -0,0 +1,29 @@
+ $attributes Additional attributes
+ */
+ public function __construct(array $exprs, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->exprs = $exprs;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['exprs'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_Echo';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/ElseIf_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/ElseIf_.php
new file mode 100644
index 0000000..b26d59c
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/ElseIf_.php
@@ -0,0 +1,33 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Node\Expr $cond, array $stmts = [], array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->cond = $cond;
+ $this->stmts = $stmts;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['cond', 'stmts'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_ElseIf';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Else_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Else_.php
new file mode 100644
index 0000000..3d2b066
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Else_.php
@@ -0,0 +1,29 @@
+ $attributes Additional attributes
+ */
+ public function __construct(array $stmts = [], array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->stmts = $stmts;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['stmts'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_Else';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/EnumCase.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/EnumCase.php
new file mode 100644
index 0000000..c071a0a
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/EnumCase.php
@@ -0,0 +1,36 @@
+ $attrGroups PHP attribute groups
+ * @param array $attributes Additional attributes
+ */
+ public function __construct($name, ?Node\Expr $expr = null, array $attrGroups = [], array $attributes = []) {
+ parent::__construct($attributes);
+ $this->name = \is_string($name) ? new Node\Identifier($name) : $name;
+ $this->expr = $expr;
+ $this->attrGroups = $attrGroups;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['attrGroups', 'name', 'expr'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_EnumCase';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Enum_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Enum_.php
new file mode 100644
index 0000000..7eea6a6
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Enum_.php
@@ -0,0 +1,44 @@
+ null : Scalar type
+ * 'implements' => array() : Names of implemented interfaces
+ * 'stmts' => array() : Statements
+ * 'attrGroups' => array() : PHP attribute groups
+ * @param array $attributes Additional attributes
+ */
+ public function __construct($name, array $subNodes = [], array $attributes = []) {
+ $this->name = \is_string($name) ? new Node\Identifier($name) : $name;
+ $this->scalarType = $subNodes['scalarType'] ?? null;
+ $this->implements = $subNodes['implements'] ?? [];
+ $this->stmts = $subNodes['stmts'] ?? [];
+ $this->attrGroups = $subNodes['attrGroups'] ?? [];
+
+ parent::__construct($attributes);
+ }
+
+ public function getSubNodeNames(): array {
+ return ['attrGroups', 'name', 'scalarType', 'implements', 'stmts'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_Enum';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Expression.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Expression.php
new file mode 100644
index 0000000..89751fa
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Expression.php
@@ -0,0 +1,32 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Node\Expr $expr, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->expr = $expr;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['expr'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_Expression';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Finally_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Finally_.php
new file mode 100644
index 0000000..69ecf25
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Finally_.php
@@ -0,0 +1,29 @@
+ $attributes Additional attributes
+ */
+ public function __construct(array $stmts = [], array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->stmts = $stmts;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['stmts'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_Finally';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/For_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/For_.php
new file mode 100644
index 0000000..6f2fbb9
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/For_.php
@@ -0,0 +1,47 @@
+ array(): Init expressions
+ * 'cond' => array(): Loop conditions
+ * 'loop' => array(): Loop expressions
+ * 'stmts' => array(): Statements
+ * @param array $attributes Additional attributes
+ */
+ public function __construct(array $subNodes = [], array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->init = $subNodes['init'] ?? [];
+ $this->cond = $subNodes['cond'] ?? [];
+ $this->loop = $subNodes['loop'] ?? [];
+ $this->stmts = $subNodes['stmts'] ?? [];
+ }
+
+ public function getSubNodeNames(): array {
+ return ['init', 'cond', 'loop', 'stmts'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_For';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Foreach_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Foreach_.php
new file mode 100644
index 0000000..c5d9a8b
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Foreach_.php
@@ -0,0 +1,50 @@
+ null : Variable to assign key to
+ * 'byRef' => false : Whether to assign value by reference
+ * 'stmts' => array(): Statements
+ * @param array $attributes Additional attributes
+ */
+ public function __construct(Node\Expr $expr, Node\Expr $valueVar, array $subNodes = [], array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->expr = $expr;
+ $this->keyVar = $subNodes['keyVar'] ?? null;
+ $this->byRef = $subNodes['byRef'] ?? false;
+ $this->valueVar = $valueVar;
+ $this->stmts = $subNodes['stmts'] ?? [];
+ }
+
+ public function getSubNodeNames(): array {
+ return ['expr', 'keyVar', 'byRef', 'valueVar', 'stmts'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_Foreach';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Function_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Function_.php
new file mode 100644
index 0000000..2111bab
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Function_.php
@@ -0,0 +1,81 @@
+ false : Whether to return by reference
+ * 'params' => array(): Parameters
+ * 'returnType' => null : Return type
+ * 'stmts' => array(): Statements
+ * 'attrGroups' => array(): PHP attribute groups
+ * @param array $attributes Additional attributes
+ */
+ public function __construct($name, array $subNodes = [], array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->byRef = $subNodes['byRef'] ?? false;
+ $this->name = \is_string($name) ? new Node\Identifier($name) : $name;
+ $this->params = $subNodes['params'] ?? [];
+ $this->returnType = $subNodes['returnType'] ?? null;
+ $this->stmts = $subNodes['stmts'] ?? [];
+ $this->attrGroups = $subNodes['attrGroups'] ?? [];
+ }
+
+ public function getSubNodeNames(): array {
+ return ['attrGroups', 'byRef', 'name', 'params', 'returnType', 'stmts'];
+ }
+
+ public function returnsByRef(): bool {
+ return $this->byRef;
+ }
+
+ public function getParams(): array {
+ return $this->params;
+ }
+
+ public function getReturnType() {
+ return $this->returnType;
+ }
+
+ public function getAttrGroups(): array {
+ return $this->attrGroups;
+ }
+
+ /** @return Node\Stmt[] */
+ public function getStmts(): array {
+ return $this->stmts;
+ }
+
+ public function getType(): string {
+ return 'Stmt_Function';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Global_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Global_.php
new file mode 100644
index 0000000..d3ab12f
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Global_.php
@@ -0,0 +1,29 @@
+ $attributes Additional attributes
+ */
+ public function __construct(array $vars, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->vars = $vars;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['vars'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_Global';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Goto_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Goto_.php
new file mode 100644
index 0000000..26a0d01
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Goto_.php
@@ -0,0 +1,30 @@
+ $attributes Additional attributes
+ */
+ public function __construct($name, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->name = \is_string($name) ? new Identifier($name) : $name;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['name'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_Goto';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/GroupUse.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/GroupUse.php
new file mode 100644
index 0000000..0ec8e9d
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/GroupUse.php
@@ -0,0 +1,41 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Name $prefix, array $uses, int $type = Use_::TYPE_NORMAL, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->type = $type;
+ $this->prefix = $prefix;
+ $this->uses = $uses;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['type', 'prefix', 'uses'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_GroupUse';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/HaltCompiler.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/HaltCompiler.php
new file mode 100644
index 0000000..665bacd
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/HaltCompiler.php
@@ -0,0 +1,29 @@
+ $attributes Additional attributes
+ */
+ public function __construct(string $remaining, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->remaining = $remaining;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['remaining'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_HaltCompiler';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/If_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/If_.php
new file mode 100644
index 0000000..544390f
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/If_.php
@@ -0,0 +1,46 @@
+ array(): Statements
+ * 'elseifs' => array(): Elseif clauses
+ * 'else' => null : Else clause
+ * @param array $attributes Additional attributes
+ */
+ public function __construct(Node\Expr $cond, array $subNodes = [], array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->cond = $cond;
+ $this->stmts = $subNodes['stmts'] ?? [];
+ $this->elseifs = $subNodes['elseifs'] ?? [];
+ $this->else = $subNodes['else'] ?? null;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['cond', 'stmts', 'elseifs', 'else'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_If';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/InlineHTML.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/InlineHTML.php
new file mode 100644
index 0000000..0515d02
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/InlineHTML.php
@@ -0,0 +1,29 @@
+ $attributes Additional attributes
+ */
+ public function __construct(string $value, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->value = $value;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['value'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_InlineHTML';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Interface_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Interface_.php
new file mode 100644
index 0000000..9359064
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Interface_.php
@@ -0,0 +1,40 @@
+ array(): Name of extended interfaces
+ * 'stmts' => array(): Statements
+ * 'attrGroups' => array(): PHP attribute groups
+ * @param array $attributes Additional attributes
+ */
+ public function __construct($name, array $subNodes = [], array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->name = \is_string($name) ? new Node\Identifier($name) : $name;
+ $this->extends = $subNodes['extends'] ?? [];
+ $this->stmts = $subNodes['stmts'] ?? [];
+ $this->attrGroups = $subNodes['attrGroups'] ?? [];
+ }
+
+ public function getSubNodeNames(): array {
+ return ['attrGroups', 'name', 'extends', 'stmts'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_Interface';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Label.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Label.php
new file mode 100644
index 0000000..658468d
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Label.php
@@ -0,0 +1,30 @@
+ $attributes Additional attributes
+ */
+ public function __construct($name, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->name = \is_string($name) ? new Identifier($name) : $name;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['name'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_Label';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Namespace_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Namespace_.php
new file mode 100644
index 0000000..f5b59ad
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Namespace_.php
@@ -0,0 +1,37 @@
+ $attributes Additional attributes
+ */
+ public function __construct(?Node\Name $name = null, ?array $stmts = [], array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->name = $name;
+ $this->stmts = $stmts;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['name', 'stmts'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_Namespace';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Nop.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Nop.php
new file mode 100644
index 0000000..3acfa46
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Nop.php
@@ -0,0 +1,16 @@
+ $attributes Additional attributes
+ * @param null|Identifier|Name|ComplexType $type Type declaration
+ * @param Node\AttributeGroup[] $attrGroups PHP attribute groups
+ * @param Node\PropertyHook[] $hooks Property hooks
+ */
+ public function __construct(int $flags, array $props, array $attributes = [], ?Node $type = null, array $attrGroups = [], array $hooks = []) {
+ $this->attributes = $attributes;
+ $this->flags = $flags;
+ $this->props = $props;
+ $this->type = $type;
+ $this->attrGroups = $attrGroups;
+ $this->hooks = $hooks;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['attrGroups', 'flags', 'type', 'props', 'hooks'];
+ }
+
+ /**
+ * Whether the property is explicitly or implicitly public.
+ */
+ public function isPublic(): bool {
+ return ($this->flags & Modifiers::PUBLIC) !== 0
+ || ($this->flags & Modifiers::VISIBILITY_MASK) === 0;
+ }
+
+ /**
+ * Whether the property is protected.
+ */
+ public function isProtected(): bool {
+ return (bool) ($this->flags & Modifiers::PROTECTED);
+ }
+
+ /**
+ * Whether the property is private.
+ */
+ public function isPrivate(): bool {
+ return (bool) ($this->flags & Modifiers::PRIVATE);
+ }
+
+ /**
+ * Whether the property is static.
+ */
+ public function isStatic(): bool {
+ return (bool) ($this->flags & Modifiers::STATIC);
+ }
+
+ /**
+ * Whether the property is readonly.
+ */
+ public function isReadonly(): bool {
+ return (bool) ($this->flags & Modifiers::READONLY);
+ }
+
+ /**
+ * Whether the property is abstract.
+ */
+ public function isAbstract(): bool {
+ return (bool) ($this->flags & Modifiers::ABSTRACT);
+ }
+
+ /**
+ * Whether the property is final.
+ */
+ public function isFinal(): bool {
+ return (bool) ($this->flags & Modifiers::FINAL);
+ }
+
+ /**
+ * Whether the property has explicit public(set) visibility.
+ */
+ public function isPublicSet(): bool {
+ return (bool) ($this->flags & Modifiers::PUBLIC_SET);
+ }
+
+ /**
+ * Whether the property has explicit protected(set) visibility.
+ */
+ public function isProtectedSet(): bool {
+ return (bool) ($this->flags & Modifiers::PROTECTED_SET);
+ }
+
+ /**
+ * Whether the property has explicit private(set) visibility.
+ */
+ public function isPrivateSet(): bool {
+ return (bool) ($this->flags & Modifiers::PRIVATE_SET);
+ }
+
+ public function getType(): string {
+ return 'Stmt_Property';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/PropertyProperty.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/PropertyProperty.php
new file mode 100644
index 0000000..62556e7
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/PropertyProperty.php
@@ -0,0 +1,17 @@
+ $attributes Additional attributes
+ */
+ public function __construct(?Node\Expr $expr = null, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->expr = $expr;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['expr'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_Return';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/StaticVar.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/StaticVar.php
new file mode 100644
index 0000000..a3c5fa6
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/StaticVar.php
@@ -0,0 +1,15 @@
+ $attributes Additional attributes
+ */
+ public function __construct(array $vars, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->vars = $vars;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['vars'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_Static';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Switch_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Switch_.php
new file mode 100644
index 0000000..21e5efa
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Switch_.php
@@ -0,0 +1,33 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Node\Expr $cond, array $cases, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->cond = $cond;
+ $this->cases = $cases;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['cond', 'cases'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_Switch';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/TraitUse.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/TraitUse.php
new file mode 100644
index 0000000..7705a57
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/TraitUse.php
@@ -0,0 +1,33 @@
+ $attributes Additional attributes
+ */
+ public function __construct(array $traits, array $adaptations = [], array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->traits = $traits;
+ $this->adaptations = $adaptations;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['traits', 'adaptations'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_TraitUse';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/TraitUseAdaptation.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/TraitUseAdaptation.php
new file mode 100644
index 0000000..987bc88
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/TraitUseAdaptation.php
@@ -0,0 +1,12 @@
+ $attributes Additional attributes
+ */
+ public function __construct(?Node\Name $trait, $method, ?int $newModifier, $newName, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->trait = $trait;
+ $this->method = \is_string($method) ? new Node\Identifier($method) : $method;
+ $this->newModifier = $newModifier;
+ $this->newName = \is_string($newName) ? new Node\Identifier($newName) : $newName;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['trait', 'method', 'newModifier', 'newName'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_TraitUseAdaptation_Alias';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/TraitUseAdaptation/Precedence.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/TraitUseAdaptation/Precedence.php
new file mode 100644
index 0000000..7bc4083
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/TraitUseAdaptation/Precedence.php
@@ -0,0 +1,33 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Node\Name $trait, $method, array $insteadof, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->trait = $trait;
+ $this->method = \is_string($method) ? new Node\Identifier($method) : $method;
+ $this->insteadof = $insteadof;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['trait', 'method', 'insteadof'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_TraitUseAdaptation_Precedence';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Trait_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Trait_.php
new file mode 100644
index 0000000..5f2b330
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Trait_.php
@@ -0,0 +1,34 @@
+ array(): Statements
+ * 'attrGroups' => array(): PHP attribute groups
+ * @param array $attributes Additional attributes
+ */
+ public function __construct($name, array $subNodes = [], array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->name = \is_string($name) ? new Node\Identifier($name) : $name;
+ $this->stmts = $subNodes['stmts'] ?? [];
+ $this->attrGroups = $subNodes['attrGroups'] ?? [];
+ }
+
+ public function getSubNodeNames(): array {
+ return ['attrGroups', 'name', 'stmts'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_Trait';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/TryCatch.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/TryCatch.php
new file mode 100644
index 0000000..6414c46
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/TryCatch.php
@@ -0,0 +1,37 @@
+ $attributes Additional attributes
+ */
+ public function __construct(array $stmts, array $catches, ?Finally_ $finally = null, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->stmts = $stmts;
+ $this->catches = $catches;
+ $this->finally = $finally;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['stmts', 'catches', 'finally'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_TryCatch';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Unset_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Unset_.php
new file mode 100644
index 0000000..c211beb
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/Unset_.php
@@ -0,0 +1,29 @@
+ $attributes Additional attributes
+ */
+ public function __construct(array $vars, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->vars = $vars;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['vars'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_Unset';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/UseUse.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/UseUse.php
new file mode 100644
index 0000000..9e504f8
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/UseUse.php
@@ -0,0 +1,17 @@
+ $attributes Additional attributes
+ */
+ public function __construct(array $uses, int $type = self::TYPE_NORMAL, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->type = $type;
+ $this->uses = $uses;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['type', 'uses'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_Use';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/While_.php b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/While_.php
new file mode 100644
index 0000000..2f7aed2
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/Stmt/While_.php
@@ -0,0 +1,33 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Node\Expr $cond, array $stmts = [], array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->cond = $cond;
+ $this->stmts = $stmts;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['cond', 'stmts'];
+ }
+
+ public function getType(): string {
+ return 'Stmt_While';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/UnionType.php b/vendor/nikic/php-parser/lib/PhpParser/Node/UnionType.php
new file mode 100644
index 0000000..bad88d2
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/UnionType.php
@@ -0,0 +1,27 @@
+ $attributes Additional attributes
+ */
+ public function __construct(array $types, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->types = $types;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['types'];
+ }
+
+ public function getType(): string {
+ return 'UnionType';
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/UseItem.php b/vendor/nikic/php-parser/lib/PhpParser/Node/UseItem.php
new file mode 100644
index 0000000..a7d9fc4
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/UseItem.php
@@ -0,0 +1,55 @@
+ $attributes Additional attributes
+ */
+ public function __construct(Node\Name $name, $alias = null, int $type = Use_::TYPE_UNKNOWN, array $attributes = []) {
+ $this->attributes = $attributes;
+ $this->type = $type;
+ $this->name = $name;
+ $this->alias = \is_string($alias) ? new Identifier($alias) : $alias;
+ }
+
+ public function getSubNodeNames(): array {
+ return ['type', 'name', 'alias'];
+ }
+
+ /**
+ * Get alias. If not explicitly given this is the last component of the used name.
+ */
+ public function getAlias(): Identifier {
+ if (null !== $this->alias) {
+ return $this->alias;
+ }
+
+ return new Identifier($this->name->getLast());
+ }
+
+ public function getType(): string {
+ return 'UseItem';
+ }
+}
+
+// @deprecated compatibility alias
+class_alias(UseItem::class, Stmt\UseUse::class);
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Node/VarLikeIdentifier.php b/vendor/nikic/php-parser/lib/PhpParser/Node/VarLikeIdentifier.php
new file mode 100644
index 0000000..9baa6fe
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Node/VarLikeIdentifier.php
@@ -0,0 +1,16 @@
+ $attributes Additional attributes
+ */
+ public function __construct(array $attributes = []) {
+ $this->attributes = $attributes;
+ }
+
+ public function getType(): string {
+ return 'VariadicPlaceholder';
+ }
+
+ public function getSubNodeNames(): array {
+ return [];
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/NodeAbstract.php b/vendor/nikic/php-parser/lib/PhpParser/NodeAbstract.php
new file mode 100644
index 0000000..a6a50ae
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/NodeAbstract.php
@@ -0,0 +1,181 @@
+ Attributes */
+ protected array $attributes;
+
+ /**
+ * Creates a Node.
+ *
+ * @param array $attributes Array of attributes
+ */
+ public function __construct(array $attributes = []) {
+ $this->attributes = $attributes;
+ }
+
+ /**
+ * Gets line the node started in (alias of getStartLine).
+ *
+ * @return int Start line (or -1 if not available)
+ * @phpstan-return -1|positive-int
+ */
+ public function getLine(): int {
+ return $this->attributes['startLine'] ?? -1;
+ }
+
+ /**
+ * Gets line the node started in.
+ *
+ * Requires the 'startLine' attribute to be enabled in the lexer (enabled by default).
+ *
+ * @return int Start line (or -1 if not available)
+ * @phpstan-return -1|positive-int
+ */
+ public function getStartLine(): int {
+ return $this->attributes['startLine'] ?? -1;
+ }
+
+ /**
+ * Gets the line the node ended in.
+ *
+ * Requires the 'endLine' attribute to be enabled in the lexer (enabled by default).
+ *
+ * @return int End line (or -1 if not available)
+ * @phpstan-return -1|positive-int
+ */
+ public function getEndLine(): int {
+ return $this->attributes['endLine'] ?? -1;
+ }
+
+ /**
+ * Gets the token offset of the first token that is part of this node.
+ *
+ * The offset is an index into the array returned by Lexer::getTokens().
+ *
+ * Requires the 'startTokenPos' attribute to be enabled in the lexer (DISABLED by default).
+ *
+ * @return int Token start position (or -1 if not available)
+ */
+ public function getStartTokenPos(): int {
+ return $this->attributes['startTokenPos'] ?? -1;
+ }
+
+ /**
+ * Gets the token offset of the last token that is part of this node.
+ *
+ * The offset is an index into the array returned by Lexer::getTokens().
+ *
+ * Requires the 'endTokenPos' attribute to be enabled in the lexer (DISABLED by default).
+ *
+ * @return int Token end position (or -1 if not available)
+ */
+ public function getEndTokenPos(): int {
+ return $this->attributes['endTokenPos'] ?? -1;
+ }
+
+ /**
+ * Gets the file offset of the first character that is part of this node.
+ *
+ * Requires the 'startFilePos' attribute to be enabled in the lexer (DISABLED by default).
+ *
+ * @return int File start position (or -1 if not available)
+ */
+ public function getStartFilePos(): int {
+ return $this->attributes['startFilePos'] ?? -1;
+ }
+
+ /**
+ * Gets the file offset of the last character that is part of this node.
+ *
+ * Requires the 'endFilePos' attribute to be enabled in the lexer (DISABLED by default).
+ *
+ * @return int File end position (or -1 if not available)
+ */
+ public function getEndFilePos(): int {
+ return $this->attributes['endFilePos'] ?? -1;
+ }
+
+ /**
+ * Gets all comments directly preceding this node.
+ *
+ * The comments are also available through the "comments" attribute.
+ *
+ * @return Comment[]
+ */
+ public function getComments(): array {
+ return $this->attributes['comments'] ?? [];
+ }
+
+ /**
+ * Gets the doc comment of the node.
+ *
+ * @return null|Comment\Doc Doc comment object or null
+ */
+ public function getDocComment(): ?Comment\Doc {
+ $comments = $this->getComments();
+ for ($i = count($comments) - 1; $i >= 0; $i--) {
+ $comment = $comments[$i];
+ if ($comment instanceof Comment\Doc) {
+ return $comment;
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * Sets the doc comment of the node.
+ *
+ * This will either replace an existing doc comment or add it to the comments array.
+ *
+ * @param Comment\Doc $docComment Doc comment to set
+ */
+ public function setDocComment(Comment\Doc $docComment): void {
+ $comments = $this->getComments();
+ for ($i = count($comments) - 1; $i >= 0; $i--) {
+ if ($comments[$i] instanceof Comment\Doc) {
+ // Replace existing doc comment.
+ $comments[$i] = $docComment;
+ $this->setAttribute('comments', $comments);
+ return;
+ }
+ }
+
+ // Append new doc comment.
+ $comments[] = $docComment;
+ $this->setAttribute('comments', $comments);
+ }
+
+ public function setAttribute(string $key, $value): void {
+ $this->attributes[$key] = $value;
+ }
+
+ public function hasAttribute(string $key): bool {
+ return array_key_exists($key, $this->attributes);
+ }
+
+ public function getAttribute(string $key, $default = null) {
+ if (array_key_exists($key, $this->attributes)) {
+ return $this->attributes[$key];
+ }
+
+ return $default;
+ }
+
+ public function getAttributes(): array {
+ return $this->attributes;
+ }
+
+ public function setAttributes(array $attributes): void {
+ $this->attributes = $attributes;
+ }
+
+ /**
+ * @return array
+ */
+ public function jsonSerialize(): array {
+ return ['nodeType' => $this->getType()] + get_object_vars($this);
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/NodeDumper.php b/vendor/nikic/php-parser/lib/PhpParser/NodeDumper.php
new file mode 100644
index 0000000..7d62d03
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/NodeDumper.php
@@ -0,0 +1,299 @@
+ true,
+ 'startLine' => true,
+ 'endLine' => true,
+ 'startFilePos' => true,
+ 'endFilePos' => true,
+ 'startTokenPos' => true,
+ 'endTokenPos' => true,
+ ];
+
+ /**
+ * Constructs a NodeDumper.
+ *
+ * Supported options:
+ * * bool dumpComments: Whether comments should be dumped.
+ * * bool dumpPositions: Whether line/offset information should be dumped. To dump offset
+ * information, the code needs to be passed to dump().
+ * * bool dumpOtherAttributes: Whether non-comment, non-position attributes should be dumped.
+ *
+ * @param array $options Options (see description)
+ */
+ public function __construct(array $options = []) {
+ $this->dumpComments = !empty($options['dumpComments']);
+ $this->dumpPositions = !empty($options['dumpPositions']);
+ $this->dumpOtherAttributes = !empty($options['dumpOtherAttributes']);
+ }
+
+ /**
+ * Dumps a node or array.
+ *
+ * @param array|Node $node Node or array to dump
+ * @param string|null $code Code corresponding to dumped AST. This only needs to be passed if
+ * the dumpPositions option is enabled and the dumping of node offsets
+ * is desired.
+ *
+ * @return string Dumped value
+ */
+ public function dump($node, ?string $code = null): string {
+ $this->code = $code;
+ $this->res = '';
+ $this->nl = "\n";
+ $this->dumpRecursive($node, false);
+ return $this->res;
+ }
+
+ /** @param mixed $node */
+ protected function dumpRecursive($node, bool $indent = true): void {
+ if ($indent) {
+ $this->nl .= " ";
+ }
+ if ($node instanceof Node) {
+ $this->res .= $node->getType();
+ if ($this->dumpPositions && null !== $p = $this->dumpPosition($node)) {
+ $this->res .= $p;
+ }
+ $this->res .= '(';
+
+ foreach ($node->getSubNodeNames() as $key) {
+ $this->res .= "$this->nl " . $key . ': ';
+
+ $value = $node->$key;
+ if (\is_int($value)) {
+ if ('flags' === $key || 'newModifier' === $key) {
+ $this->res .= $this->dumpFlags($value);
+ continue;
+ }
+ if ('type' === $key && $node instanceof Include_) {
+ $this->res .= $this->dumpIncludeType($value);
+ continue;
+ }
+ if ('type' === $key
+ && ($node instanceof Use_ || $node instanceof UseItem || $node instanceof GroupUse)) {
+ $this->res .= $this->dumpUseType($value);
+ continue;
+ }
+ }
+ $this->dumpRecursive($value);
+ }
+
+ if ($this->dumpComments && $comments = $node->getComments()) {
+ $this->res .= "$this->nl comments: ";
+ $this->dumpRecursive($comments);
+ }
+
+ if ($this->dumpOtherAttributes) {
+ foreach ($node->getAttributes() as $key => $value) {
+ if (isset(self::IGNORE_ATTRIBUTES[$key])) {
+ continue;
+ }
+
+ $this->res .= "$this->nl $key: ";
+ if (\is_int($value)) {
+ if ('kind' === $key) {
+ if ($node instanceof Int_) {
+ $this->res .= $this->dumpIntKind($value);
+ continue;
+ }
+ if ($node instanceof String_ || $node instanceof InterpolatedString) {
+ $this->res .= $this->dumpStringKind($value);
+ continue;
+ }
+ if ($node instanceof Array_) {
+ $this->res .= $this->dumpArrayKind($value);
+ continue;
+ }
+ if ($node instanceof List_) {
+ $this->res .= $this->dumpListKind($value);
+ continue;
+ }
+ }
+ }
+ $this->dumpRecursive($value);
+ }
+ }
+ $this->res .= "$this->nl)";
+ } elseif (\is_array($node)) {
+ $this->res .= 'array(';
+ foreach ($node as $key => $value) {
+ $this->res .= "$this->nl " . $key . ': ';
+ $this->dumpRecursive($value);
+ }
+ $this->res .= "$this->nl)";
+ } elseif ($node instanceof Comment) {
+ $this->res .= \str_replace("\n", $this->nl, $node->getReformattedText());
+ } elseif (\is_string($node)) {
+ $this->res .= \str_replace("\n", $this->nl, $node);
+ } elseif (\is_int($node) || \is_float($node)) {
+ $this->res .= $node;
+ } elseif (null === $node) {
+ $this->res .= 'null';
+ } elseif (false === $node) {
+ $this->res .= 'false';
+ } elseif (true === $node) {
+ $this->res .= 'true';
+ } else {
+ throw new \InvalidArgumentException('Can only dump nodes and arrays.');
+ }
+ if ($indent) {
+ $this->nl = \substr($this->nl, 0, -4);
+ }
+ }
+
+ protected function dumpFlags(int $flags): string {
+ $strs = [];
+ if ($flags & Modifiers::PUBLIC) {
+ $strs[] = 'PUBLIC';
+ }
+ if ($flags & Modifiers::PROTECTED) {
+ $strs[] = 'PROTECTED';
+ }
+ if ($flags & Modifiers::PRIVATE) {
+ $strs[] = 'PRIVATE';
+ }
+ if ($flags & Modifiers::ABSTRACT) {
+ $strs[] = 'ABSTRACT';
+ }
+ if ($flags & Modifiers::STATIC) {
+ $strs[] = 'STATIC';
+ }
+ if ($flags & Modifiers::FINAL) {
+ $strs[] = 'FINAL';
+ }
+ if ($flags & Modifiers::READONLY) {
+ $strs[] = 'READONLY';
+ }
+ if ($flags & Modifiers::PUBLIC_SET) {
+ $strs[] = 'PUBLIC_SET';
+ }
+ if ($flags & Modifiers::PROTECTED_SET) {
+ $strs[] = 'PROTECTED_SET';
+ }
+ if ($flags & Modifiers::PRIVATE_SET) {
+ $strs[] = 'PRIVATE_SET';
+ }
+
+ if ($strs) {
+ return implode(' | ', $strs) . ' (' . $flags . ')';
+ } else {
+ return (string) $flags;
+ }
+ }
+
+ /** @param array $map */
+ private function dumpEnum(int $value, array $map): string {
+ if (!isset($map[$value])) {
+ return (string) $value;
+ }
+ return $map[$value] . ' (' . $value . ')';
+ }
+
+ private function dumpIncludeType(int $type): string {
+ return $this->dumpEnum($type, [
+ Include_::TYPE_INCLUDE => 'TYPE_INCLUDE',
+ Include_::TYPE_INCLUDE_ONCE => 'TYPE_INCLUDE_ONCE',
+ Include_::TYPE_REQUIRE => 'TYPE_REQUIRE',
+ Include_::TYPE_REQUIRE_ONCE => 'TYPE_REQUIRE_ONCE',
+ ]);
+ }
+
+ private function dumpUseType(int $type): string {
+ return $this->dumpEnum($type, [
+ Use_::TYPE_UNKNOWN => 'TYPE_UNKNOWN',
+ Use_::TYPE_NORMAL => 'TYPE_NORMAL',
+ Use_::TYPE_FUNCTION => 'TYPE_FUNCTION',
+ Use_::TYPE_CONSTANT => 'TYPE_CONSTANT',
+ ]);
+ }
+
+ private function dumpIntKind(int $kind): string {
+ return $this->dumpEnum($kind, [
+ Int_::KIND_BIN => 'KIND_BIN',
+ Int_::KIND_OCT => 'KIND_OCT',
+ Int_::KIND_DEC => 'KIND_DEC',
+ Int_::KIND_HEX => 'KIND_HEX',
+ ]);
+ }
+
+ private function dumpStringKind(int $kind): string {
+ return $this->dumpEnum($kind, [
+ String_::KIND_SINGLE_QUOTED => 'KIND_SINGLE_QUOTED',
+ String_::KIND_DOUBLE_QUOTED => 'KIND_DOUBLE_QUOTED',
+ String_::KIND_HEREDOC => 'KIND_HEREDOC',
+ String_::KIND_NOWDOC => 'KIND_NOWDOC',
+ ]);
+ }
+
+ private function dumpArrayKind(int $kind): string {
+ return $this->dumpEnum($kind, [
+ Array_::KIND_LONG => 'KIND_LONG',
+ Array_::KIND_SHORT => 'KIND_SHORT',
+ ]);
+ }
+
+ private function dumpListKind(int $kind): string {
+ return $this->dumpEnum($kind, [
+ List_::KIND_LIST => 'KIND_LIST',
+ List_::KIND_ARRAY => 'KIND_ARRAY',
+ ]);
+ }
+
+ /**
+ * Dump node position, if possible.
+ *
+ * @param Node $node Node for which to dump position
+ *
+ * @return string|null Dump of position, or null if position information not available
+ */
+ protected function dumpPosition(Node $node): ?string {
+ if (!$node->hasAttribute('startLine') || !$node->hasAttribute('endLine')) {
+ return null;
+ }
+
+ $start = $node->getStartLine();
+ $end = $node->getEndLine();
+ if ($node->hasAttribute('startFilePos') && $node->hasAttribute('endFilePos')
+ && null !== $this->code
+ ) {
+ $start .= ':' . $this->toColumn($this->code, $node->getStartFilePos());
+ $end .= ':' . $this->toColumn($this->code, $node->getEndFilePos());
+ }
+ return "[$start - $end]";
+ }
+
+ // Copied from Error class
+ private function toColumn(string $code, int $pos): int {
+ if ($pos > strlen($code)) {
+ throw new \RuntimeException('Invalid position information');
+ }
+
+ $lineStartPos = strrpos($code, "\n", $pos - strlen($code));
+ if (false === $lineStartPos) {
+ $lineStartPos = -1;
+ }
+
+ return $pos - $lineStartPos;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/NodeFinder.php b/vendor/nikic/php-parser/lib/PhpParser/NodeFinder.php
new file mode 100644
index 0000000..96c8452
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/NodeFinder.php
@@ -0,0 +1,90 @@
+traverse($nodes);
+
+ return $visitor->getFoundNodes();
+ }
+
+ /**
+ * Find all nodes that are instances of a certain class.
+
+ * @template TNode as Node
+ *
+ * @param Node|Node[] $nodes Single node or array of nodes to search in
+ * @param class-string $class Class name
+ *
+ * @return TNode[] Found nodes (all instances of $class)
+ */
+ public function findInstanceOf($nodes, string $class): array {
+ return $this->find($nodes, function ($node) use ($class) {
+ return $node instanceof $class;
+ });
+ }
+
+ /**
+ * Find first node satisfying a filter callback.
+ *
+ * @param Node|Node[] $nodes Single node or array of nodes to search in
+ * @param callable $filter Filter callback: function(Node $node) : bool
+ *
+ * @return null|Node Found node (or null if none found)
+ */
+ public function findFirst($nodes, callable $filter): ?Node {
+ if ($nodes === []) {
+ return null;
+ }
+
+ if (!is_array($nodes)) {
+ $nodes = [$nodes];
+ }
+
+ $visitor = new FirstFindingVisitor($filter);
+
+ $traverser = new NodeTraverser($visitor);
+ $traverser->traverse($nodes);
+
+ return $visitor->getFoundNode();
+ }
+
+ /**
+ * Find first node that is an instance of a certain class.
+ *
+ * @template TNode as Node
+ *
+ * @param Node|Node[] $nodes Single node or array of nodes to search in
+ * @param class-string $class Class name
+ *
+ * @return null|TNode Found node, which is an instance of $class (or null if none found)
+ */
+ public function findFirstInstanceOf($nodes, string $class): ?Node {
+ return $this->findFirst($nodes, function ($node) use ($class) {
+ return $node instanceof $class;
+ });
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/NodeTraverser.php b/vendor/nikic/php-parser/lib/PhpParser/NodeTraverser.php
new file mode 100644
index 0000000..6a5c2ad
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/NodeTraverser.php
@@ -0,0 +1,287 @@
+ Visitors */
+ protected array $visitors = [];
+
+ /** @var bool Whether traversal should be stopped */
+ protected bool $stopTraversal;
+
+ /**
+ * Create a traverser with the given visitors.
+ *
+ * @param NodeVisitor ...$visitors Node visitors
+ */
+ public function __construct(NodeVisitor ...$visitors) {
+ $this->visitors = $visitors;
+ }
+
+ /**
+ * Adds a visitor.
+ *
+ * @param NodeVisitor $visitor Visitor to add
+ */
+ public function addVisitor(NodeVisitor $visitor): void {
+ $this->visitors[] = $visitor;
+ }
+
+ /**
+ * Removes an added visitor.
+ */
+ public function removeVisitor(NodeVisitor $visitor): void {
+ $index = array_search($visitor, $this->visitors);
+ if ($index !== false) {
+ array_splice($this->visitors, $index, 1, []);
+ }
+ }
+
+ /**
+ * Traverses an array of nodes using the registered visitors.
+ *
+ * @param Node[] $nodes Array of nodes
+ *
+ * @return Node[] Traversed array of nodes
+ */
+ public function traverse(array $nodes): array {
+ $this->stopTraversal = false;
+
+ foreach ($this->visitors as $visitor) {
+ if (null !== $return = $visitor->beforeTraverse($nodes)) {
+ $nodes = $return;
+ }
+ }
+
+ $nodes = $this->traverseArray($nodes);
+
+ for ($i = \count($this->visitors) - 1; $i >= 0; --$i) {
+ $visitor = $this->visitors[$i];
+ if (null !== $return = $visitor->afterTraverse($nodes)) {
+ $nodes = $return;
+ }
+ }
+
+ return $nodes;
+ }
+
+ /**
+ * Recursively traverse a node.
+ *
+ * @param Node $node Node to traverse.
+ */
+ protected function traverseNode(Node $node): void {
+ foreach ($node->getSubNodeNames() as $name) {
+ $subNode = $node->$name;
+
+ if (\is_array($subNode)) {
+ $node->$name = $this->traverseArray($subNode);
+ if ($this->stopTraversal) {
+ break;
+ }
+
+ continue;
+ }
+
+ if (!$subNode instanceof Node) {
+ continue;
+ }
+
+ $traverseChildren = true;
+ $visitorIndex = -1;
+
+ foreach ($this->visitors as $visitorIndex => $visitor) {
+ $return = $visitor->enterNode($subNode);
+ if (null !== $return) {
+ if ($return instanceof Node) {
+ $this->ensureReplacementReasonable($subNode, $return);
+ $subNode = $node->$name = $return;
+ } elseif (NodeVisitor::DONT_TRAVERSE_CHILDREN === $return) {
+ $traverseChildren = false;
+ } elseif (NodeVisitor::DONT_TRAVERSE_CURRENT_AND_CHILDREN === $return) {
+ $traverseChildren = false;
+ break;
+ } elseif (NodeVisitor::STOP_TRAVERSAL === $return) {
+ $this->stopTraversal = true;
+ break 2;
+ } elseif (NodeVisitor::REPLACE_WITH_NULL === $return) {
+ $node->$name = null;
+ continue 2;
+ } else {
+ throw new \LogicException(
+ 'enterNode() returned invalid value of type ' . gettype($return)
+ );
+ }
+ }
+ }
+
+ if ($traverseChildren) {
+ $this->traverseNode($subNode);
+ if ($this->stopTraversal) {
+ break;
+ }
+ }
+
+ for (; $visitorIndex >= 0; --$visitorIndex) {
+ $visitor = $this->visitors[$visitorIndex];
+ $return = $visitor->leaveNode($subNode);
+
+ if (null !== $return) {
+ if ($return instanceof Node) {
+ $this->ensureReplacementReasonable($subNode, $return);
+ $subNode = $node->$name = $return;
+ } elseif (NodeVisitor::STOP_TRAVERSAL === $return) {
+ $this->stopTraversal = true;
+ break 2;
+ } elseif (NodeVisitor::REPLACE_WITH_NULL === $return) {
+ $node->$name = null;
+ break;
+ } elseif (\is_array($return)) {
+ throw new \LogicException(
+ 'leaveNode() may only return an array ' .
+ 'if the parent structure is an array'
+ );
+ } else {
+ throw new \LogicException(
+ 'leaveNode() returned invalid value of type ' . gettype($return)
+ );
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Recursively traverse array (usually of nodes).
+ *
+ * @param Node[] $nodes Array to traverse
+ *
+ * @return Node[] Result of traversal (may be original array or changed one)
+ */
+ protected function traverseArray(array $nodes): array {
+ $doNodes = [];
+
+ foreach ($nodes as $i => $node) {
+ if (!$node instanceof Node) {
+ if (\is_array($node)) {
+ throw new \LogicException('Invalid node structure: Contains nested arrays');
+ }
+ continue;
+ }
+
+ $traverseChildren = true;
+ $visitorIndex = -1;
+
+ foreach ($this->visitors as $visitorIndex => $visitor) {
+ $return = $visitor->enterNode($node);
+ if (null !== $return) {
+ if ($return instanceof Node) {
+ $this->ensureReplacementReasonable($node, $return);
+ $nodes[$i] = $node = $return;
+ } elseif (\is_array($return)) {
+ $doNodes[] = [$i, $return];
+ continue 2;
+ } elseif (NodeVisitor::REMOVE_NODE === $return) {
+ $doNodes[] = [$i, []];
+ continue 2;
+ } elseif (NodeVisitor::DONT_TRAVERSE_CHILDREN === $return) {
+ $traverseChildren = false;
+ } elseif (NodeVisitor::DONT_TRAVERSE_CURRENT_AND_CHILDREN === $return) {
+ $traverseChildren = false;
+ break;
+ } elseif (NodeVisitor::STOP_TRAVERSAL === $return) {
+ $this->stopTraversal = true;
+ break 2;
+ } elseif (NodeVisitor::REPLACE_WITH_NULL === $return) {
+ throw new \LogicException(
+ 'REPLACE_WITH_NULL can not be used if the parent structure is an array');
+ } else {
+ throw new \LogicException(
+ 'enterNode() returned invalid value of type ' . gettype($return)
+ );
+ }
+ }
+ }
+
+ if ($traverseChildren) {
+ $this->traverseNode($node);
+ if ($this->stopTraversal) {
+ break;
+ }
+ }
+
+ for (; $visitorIndex >= 0; --$visitorIndex) {
+ $visitor = $this->visitors[$visitorIndex];
+ $return = $visitor->leaveNode($node);
+
+ if (null !== $return) {
+ if ($return instanceof Node) {
+ $this->ensureReplacementReasonable($node, $return);
+ $nodes[$i] = $node = $return;
+ } elseif (\is_array($return)) {
+ $doNodes[] = [$i, $return];
+ break;
+ } elseif (NodeVisitor::REMOVE_NODE === $return) {
+ $doNodes[] = [$i, []];
+ break;
+ } elseif (NodeVisitor::STOP_TRAVERSAL === $return) {
+ $this->stopTraversal = true;
+ break 2;
+ } elseif (NodeVisitor::REPLACE_WITH_NULL === $return) {
+ throw new \LogicException(
+ 'REPLACE_WITH_NULL can not be used if the parent structure is an array');
+ } else {
+ throw new \LogicException(
+ 'leaveNode() returned invalid value of type ' . gettype($return)
+ );
+ }
+ }
+ }
+ }
+
+ if (!empty($doNodes)) {
+ while (list($i, $replace) = array_pop($doNodes)) {
+ array_splice($nodes, $i, 1, $replace);
+ }
+ }
+
+ return $nodes;
+ }
+
+ private function ensureReplacementReasonable(Node $old, Node $new): void {
+ if ($old instanceof Node\Stmt && $new instanceof Node\Expr) {
+ throw new \LogicException(
+ "Trying to replace statement ({$old->getType()}) " .
+ "with expression ({$new->getType()}). Are you missing a " .
+ "Stmt_Expression wrapper?"
+ );
+ }
+
+ if ($old instanceof Node\Expr && $new instanceof Node\Stmt) {
+ throw new \LogicException(
+ "Trying to replace expression ({$old->getType()}) " .
+ "with statement ({$new->getType()})"
+ );
+ }
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/NodeTraverserInterface.php b/vendor/nikic/php-parser/lib/PhpParser/NodeTraverserInterface.php
new file mode 100644
index 0000000..c3992b3
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/NodeTraverserInterface.php
@@ -0,0 +1,26 @@
+ $node stays as-is
+ * * array (of Nodes)
+ * => The return value is merged into the parent array (at the position of the $node)
+ * * NodeVisitor::REMOVE_NODE
+ * => $node is removed from the parent array
+ * * NodeVisitor::REPLACE_WITH_NULL
+ * => $node is replaced with null
+ * * NodeVisitor::DONT_TRAVERSE_CHILDREN
+ * => Children of $node are not traversed. $node stays as-is
+ * * NodeVisitor::DONT_TRAVERSE_CURRENT_AND_CHILDREN
+ * => Further visitors for the current node are skipped, and its children are not
+ * traversed. $node stays as-is.
+ * * NodeVisitor::STOP_TRAVERSAL
+ * => Traversal is aborted. $node stays as-is
+ * * otherwise
+ * => $node is set to the return value
+ *
+ * @param Node $node Node
+ *
+ * @return null|int|Node|Node[] Replacement node (or special return value)
+ */
+ public function enterNode(Node $node);
+
+ /**
+ * Called when leaving a node.
+ *
+ * Return value semantics:
+ * * null
+ * => $node stays as-is
+ * * NodeVisitor::REMOVE_NODE
+ * => $node is removed from the parent array
+ * * NodeVisitor::REPLACE_WITH_NULL
+ * => $node is replaced with null
+ * * NodeVisitor::STOP_TRAVERSAL
+ * => Traversal is aborted. $node stays as-is
+ * * array (of Nodes)
+ * => The return value is merged into the parent array (at the position of the $node)
+ * * otherwise
+ * => $node is set to the return value
+ *
+ * @param Node $node Node
+ *
+ * @return null|int|Node|Node[] Replacement node (or special return value)
+ */
+ public function leaveNode(Node $node);
+
+ /**
+ * Called once after traversal.
+ *
+ * Return value semantics:
+ * * null: $nodes stays as-is
+ * * otherwise: $nodes is set to the return value
+ *
+ * @param Node[] $nodes Array of nodes
+ *
+ * @return null|Node[] Array of nodes
+ */
+ public function afterTraverse(array $nodes);
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/CloningVisitor.php b/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/CloningVisitor.php
new file mode 100644
index 0000000..cba9249
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/CloningVisitor.php
@@ -0,0 +1,19 @@
+setAttribute('origNode', $origNode);
+ return $node;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/CommentAnnotatingVisitor.php b/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/CommentAnnotatingVisitor.php
new file mode 100644
index 0000000..5e2aed3
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/CommentAnnotatingVisitor.php
@@ -0,0 +1,82 @@
+ Token positions of comments */
+ private array $commentPositions = [];
+
+ /**
+ * Create a comment annotation visitor.
+ *
+ * @param Token[] $tokens Token array
+ */
+ public function __construct(array $tokens) {
+ $this->tokens = $tokens;
+
+ // Collect positions of comments. We use this to avoid traversing parts of the AST where
+ // there are no comments.
+ foreach ($tokens as $i => $token) {
+ if ($token->id === \T_COMMENT || $token->id === \T_DOC_COMMENT) {
+ $this->commentPositions[] = $i;
+ }
+ }
+ }
+
+ public function enterNode(Node $node) {
+ $nextCommentPos = current($this->commentPositions);
+ if ($nextCommentPos === false) {
+ // No more comments.
+ return self::STOP_TRAVERSAL;
+ }
+
+ $oldPos = $this->pos;
+ $this->pos = $pos = $node->getStartTokenPos();
+ if ($nextCommentPos > $oldPos && $nextCommentPos < $pos) {
+ $comments = [];
+ while (--$pos >= $oldPos) {
+ $token = $this->tokens[$pos];
+ if ($token->id === \T_DOC_COMMENT) {
+ $comments[] = new Comment\Doc(
+ $token->text, $token->line, $token->pos, $pos,
+ $token->getEndLine(), $token->getEndPos() - 1, $pos);
+ continue;
+ }
+ if ($token->id === \T_COMMENT) {
+ $comments[] = new Comment(
+ $token->text, $token->line, $token->pos, $pos,
+ $token->getEndLine(), $token->getEndPos() - 1, $pos);
+ continue;
+ }
+ if ($token->id !== \T_WHITESPACE) {
+ break;
+ }
+ }
+ if (!empty($comments)) {
+ $node->setAttribute('comments', array_reverse($comments));
+ }
+
+ do {
+ $nextCommentPos = next($this->commentPositions);
+ } while ($nextCommentPos !== false && $nextCommentPos < $this->pos);
+ }
+
+ $endPos = $node->getEndTokenPos();
+ if ($nextCommentPos > $endPos) {
+ // Skip children if there are no comments located inside this node.
+ $this->pos = $endPos;
+ return self::DONT_TRAVERSE_CHILDREN;
+ }
+
+ return null;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/FindingVisitor.php b/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/FindingVisitor.php
new file mode 100644
index 0000000..65a1bd3
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/FindingVisitor.php
@@ -0,0 +1,47 @@
+ Found nodes */
+ protected array $foundNodes;
+
+ public function __construct(callable $filterCallback) {
+ $this->filterCallback = $filterCallback;
+ }
+
+ /**
+ * Get found nodes satisfying the filter callback.
+ *
+ * Nodes are returned in pre-order.
+ *
+ * @return list Found nodes
+ */
+ public function getFoundNodes(): array {
+ return $this->foundNodes;
+ }
+
+ public function beforeTraverse(array $nodes): ?array {
+ $this->foundNodes = [];
+
+ return null;
+ }
+
+ public function enterNode(Node $node) {
+ $filterCallback = $this->filterCallback;
+ if ($filterCallback($node)) {
+ $this->foundNodes[] = $node;
+ }
+
+ return null;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/FirstFindingVisitor.php b/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/FirstFindingVisitor.php
new file mode 100644
index 0000000..05deed5
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/FirstFindingVisitor.php
@@ -0,0 +1,49 @@
+filterCallback = $filterCallback;
+ }
+
+ /**
+ * Get found node satisfying the filter callback.
+ *
+ * Returns null if no node satisfies the filter callback.
+ *
+ * @return null|Node Found node (or null if not found)
+ */
+ public function getFoundNode(): ?Node {
+ return $this->foundNode;
+ }
+
+ public function beforeTraverse(array $nodes): ?array {
+ $this->foundNode = null;
+
+ return null;
+ }
+
+ public function enterNode(Node $node) {
+ $filterCallback = $this->filterCallback;
+ if ($filterCallback($node)) {
+ $this->foundNode = $node;
+ return NodeVisitor::STOP_TRAVERSAL;
+ }
+
+ return null;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/NameResolver.php b/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/NameResolver.php
new file mode 100644
index 0000000..e0066f2
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/NameResolver.php
@@ -0,0 +1,269 @@
+nameContext = new NameContext($errorHandler ?? new ErrorHandler\Throwing());
+ $this->preserveOriginalNames = $options['preserveOriginalNames'] ?? false;
+ $this->replaceNodes = $options['replaceNodes'] ?? true;
+ }
+
+ /**
+ * Get name resolution context.
+ */
+ public function getNameContext(): NameContext {
+ return $this->nameContext;
+ }
+
+ public function beforeTraverse(array $nodes): ?array {
+ $this->nameContext->startNamespace();
+ return null;
+ }
+
+ public function enterNode(Node $node) {
+ if ($node instanceof Stmt\Namespace_) {
+ $this->nameContext->startNamespace($node->name);
+ } elseif ($node instanceof Stmt\Use_) {
+ foreach ($node->uses as $use) {
+ $this->addAlias($use, $node->type, null);
+ }
+ } elseif ($node instanceof Stmt\GroupUse) {
+ foreach ($node->uses as $use) {
+ $this->addAlias($use, $node->type, $node->prefix);
+ }
+ } elseif ($node instanceof Stmt\Class_) {
+ if (null !== $node->extends) {
+ $node->extends = $this->resolveClassName($node->extends);
+ }
+
+ foreach ($node->implements as &$interface) {
+ $interface = $this->resolveClassName($interface);
+ }
+
+ $this->resolveAttrGroups($node);
+ if (null !== $node->name) {
+ $this->addNamespacedName($node);
+ } else {
+ $node->namespacedName = null;
+ }
+ } elseif ($node instanceof Stmt\Interface_) {
+ foreach ($node->extends as &$interface) {
+ $interface = $this->resolveClassName($interface);
+ }
+
+ $this->resolveAttrGroups($node);
+ $this->addNamespacedName($node);
+ } elseif ($node instanceof Stmt\Enum_) {
+ foreach ($node->implements as &$interface) {
+ $interface = $this->resolveClassName($interface);
+ }
+
+ $this->resolveAttrGroups($node);
+ $this->addNamespacedName($node);
+ } elseif ($node instanceof Stmt\Trait_) {
+ $this->resolveAttrGroups($node);
+ $this->addNamespacedName($node);
+ } elseif ($node instanceof Stmt\Function_) {
+ $this->resolveSignature($node);
+ $this->resolveAttrGroups($node);
+ $this->addNamespacedName($node);
+ } elseif ($node instanceof Stmt\ClassMethod
+ || $node instanceof Expr\Closure
+ || $node instanceof Expr\ArrowFunction
+ ) {
+ $this->resolveSignature($node);
+ $this->resolveAttrGroups($node);
+ } elseif ($node instanceof Stmt\Property) {
+ if (null !== $node->type) {
+ $node->type = $this->resolveType($node->type);
+ }
+ $this->resolveAttrGroups($node);
+ } elseif ($node instanceof Node\PropertyHook) {
+ foreach ($node->params as $param) {
+ $param->type = $this->resolveType($param->type);
+ $this->resolveAttrGroups($param);
+ }
+ $this->resolveAttrGroups($node);
+ } elseif ($node instanceof Stmt\Const_) {
+ foreach ($node->consts as $const) {
+ $this->addNamespacedName($const);
+ }
+ $this->resolveAttrGroups($node);
+ } elseif ($node instanceof Stmt\ClassConst) {
+ if (null !== $node->type) {
+ $node->type = $this->resolveType($node->type);
+ }
+ $this->resolveAttrGroups($node);
+ } elseif ($node instanceof Stmt\EnumCase) {
+ $this->resolveAttrGroups($node);
+ } elseif ($node instanceof Expr\StaticCall
+ || $node instanceof Expr\StaticPropertyFetch
+ || $node instanceof Expr\ClassConstFetch
+ || $node instanceof Expr\New_
+ || $node instanceof Expr\Instanceof_
+ ) {
+ if ($node->class instanceof Name) {
+ $node->class = $this->resolveClassName($node->class);
+ }
+ } elseif ($node instanceof Stmt\Catch_) {
+ foreach ($node->types as &$type) {
+ $type = $this->resolveClassName($type);
+ }
+ } elseif ($node instanceof Expr\FuncCall) {
+ if ($node->name instanceof Name) {
+ $node->name = $this->resolveName($node->name, Stmt\Use_::TYPE_FUNCTION);
+ }
+ } elseif ($node instanceof Expr\ConstFetch) {
+ $node->name = $this->resolveName($node->name, Stmt\Use_::TYPE_CONSTANT);
+ } elseif ($node instanceof Stmt\TraitUse) {
+ foreach ($node->traits as &$trait) {
+ $trait = $this->resolveClassName($trait);
+ }
+
+ foreach ($node->adaptations as $adaptation) {
+ if (null !== $adaptation->trait) {
+ $adaptation->trait = $this->resolveClassName($adaptation->trait);
+ }
+
+ if ($adaptation instanceof Stmt\TraitUseAdaptation\Precedence) {
+ foreach ($adaptation->insteadof as &$insteadof) {
+ $insteadof = $this->resolveClassName($insteadof);
+ }
+ }
+ }
+ }
+
+ return null;
+ }
+
+ /** @param Stmt\Use_::TYPE_* $type */
+ private function addAlias(Node\UseItem $use, int $type, ?Name $prefix = null): void {
+ // Add prefix for group uses
+ $name = $prefix ? Name::concat($prefix, $use->name) : $use->name;
+ // Type is determined either by individual element or whole use declaration
+ $type |= $use->type;
+
+ $this->nameContext->addAlias(
+ $name, (string) $use->getAlias(), $type, $use->getAttributes()
+ );
+ }
+
+ /** @param Stmt\Function_|Stmt\ClassMethod|Expr\Closure|Expr\ArrowFunction $node */
+ private function resolveSignature($node): void {
+ foreach ($node->params as $param) {
+ $param->type = $this->resolveType($param->type);
+ $this->resolveAttrGroups($param);
+ }
+ $node->returnType = $this->resolveType($node->returnType);
+ }
+
+ /**
+ * @template T of Node\Identifier|Name|Node\ComplexType|null
+ * @param T $node
+ * @return T
+ */
+ private function resolveType(?Node $node): ?Node {
+ if ($node instanceof Name) {
+ return $this->resolveClassName($node);
+ }
+ if ($node instanceof Node\NullableType) {
+ $node->type = $this->resolveType($node->type);
+ return $node;
+ }
+ if ($node instanceof Node\UnionType || $node instanceof Node\IntersectionType) {
+ foreach ($node->types as &$type) {
+ $type = $this->resolveType($type);
+ }
+ return $node;
+ }
+ return $node;
+ }
+
+ /**
+ * Resolve name, according to name resolver options.
+ *
+ * @param Name $name Function or constant name to resolve
+ * @param Stmt\Use_::TYPE_* $type One of Stmt\Use_::TYPE_*
+ *
+ * @return Name Resolved name, or original name with attribute
+ */
+ protected function resolveName(Name $name, int $type): Name {
+ if (!$this->replaceNodes) {
+ $resolvedName = $this->nameContext->getResolvedName($name, $type);
+ if (null !== $resolvedName) {
+ $name->setAttribute('resolvedName', $resolvedName);
+ } else {
+ $name->setAttribute('namespacedName', FullyQualified::concat(
+ $this->nameContext->getNamespace(), $name, $name->getAttributes()));
+ }
+ return $name;
+ }
+
+ if ($this->preserveOriginalNames) {
+ // Save the original name
+ $originalName = $name;
+ $name = clone $originalName;
+ $name->setAttribute('originalName', $originalName);
+ }
+
+ $resolvedName = $this->nameContext->getResolvedName($name, $type);
+ if (null !== $resolvedName) {
+ return $resolvedName;
+ }
+
+ // unqualified names inside a namespace cannot be resolved at compile-time
+ // add the namespaced version of the name as an attribute
+ $name->setAttribute('namespacedName', FullyQualified::concat(
+ $this->nameContext->getNamespace(), $name, $name->getAttributes()));
+ return $name;
+ }
+
+ protected function resolveClassName(Name $name): Name {
+ return $this->resolveName($name, Stmt\Use_::TYPE_NORMAL);
+ }
+
+ protected function addNamespacedName(Node $node): void {
+ $node->namespacedName = Name::concat(
+ $this->nameContext->getNamespace(), (string) $node->name);
+ }
+
+ protected function resolveAttrGroups(Node $node): void {
+ foreach ($node->attrGroups as $attrGroup) {
+ foreach ($attrGroup->attrs as $attr) {
+ $attr->name = $this->resolveClassName($attr->name);
+ }
+ }
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/NodeConnectingVisitor.php b/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/NodeConnectingVisitor.php
new file mode 100644
index 0000000..70e051e
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/NodeConnectingVisitor.php
@@ -0,0 +1,73 @@
+$weakReferences=false on the child node, the parent node can be accessed through
+ * $node->getAttribute('parent'), the previous
+ * node can be accessed through $node->getAttribute('previous'),
+ * and the next node can be accessed through $node->getAttribute('next').
+ *
+ * With $weakReferences=true attribute names are prefixed by "weak_", e.g. "weak_parent".
+ */
+final class NodeConnectingVisitor extends NodeVisitorAbstract {
+ /**
+ * @var Node[]
+ */
+ private array $stack = [];
+
+ /**
+ * @var ?Node
+ */
+ private $previous;
+
+ private bool $weakReferences;
+
+ public function __construct(bool $weakReferences = false) {
+ $this->weakReferences = $weakReferences;
+ }
+
+ public function beforeTraverse(array $nodes) {
+ $this->stack = [];
+ $this->previous = null;
+ }
+
+ public function enterNode(Node $node) {
+ if (!empty($this->stack)) {
+ $parent = $this->stack[count($this->stack) - 1];
+ if ($this->weakReferences) {
+ $node->setAttribute('weak_parent', \WeakReference::create($parent));
+ } else {
+ $node->setAttribute('parent', $parent);
+ }
+ }
+
+ if ($this->previous !== null) {
+ if (
+ $this->weakReferences
+ ) {
+ if ($this->previous->getAttribute('weak_parent') === $node->getAttribute('weak_parent')) {
+ $node->setAttribute('weak_previous', \WeakReference::create($this->previous));
+ $this->previous->setAttribute('weak_next', \WeakReference::create($node));
+ }
+ } elseif ($this->previous->getAttribute('parent') === $node->getAttribute('parent')) {
+ $node->setAttribute('previous', $this->previous);
+ $this->previous->setAttribute('next', $node);
+ }
+ }
+
+ $this->stack[] = $node;
+ }
+
+ public function leaveNode(Node $node) {
+ $this->previous = $node;
+
+ array_pop($this->stack);
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/ParentConnectingVisitor.php b/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/ParentConnectingVisitor.php
new file mode 100644
index 0000000..abf6e37
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/NodeVisitor/ParentConnectingVisitor.php
@@ -0,0 +1,51 @@
+$weakReferences=false on the child node, the parent node can be accessed through
+ * $node->getAttribute('parent').
+ *
+ * With $weakReferences=true the attribute name is "weak_parent" instead.
+ */
+final class ParentConnectingVisitor extends NodeVisitorAbstract {
+ /**
+ * @var Node[]
+ */
+ private array $stack = [];
+
+ private bool $weakReferences;
+
+ public function __construct(bool $weakReferences = false) {
+ $this->weakReferences = $weakReferences;
+ }
+
+ public function beforeTraverse(array $nodes) {
+ $this->stack = [];
+ }
+
+ public function enterNode(Node $node) {
+ if (!empty($this->stack)) {
+ $parent = $this->stack[count($this->stack) - 1];
+ if ($this->weakReferences) {
+ $node->setAttribute('weak_parent', \WeakReference::create($parent));
+ } else {
+ $node->setAttribute('parent', $parent);
+ }
+ }
+
+ $this->stack[] = $node;
+ }
+
+ public function leaveNode(Node $node) {
+ array_pop($this->stack);
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/NodeVisitorAbstract.php b/vendor/nikic/php-parser/lib/PhpParser/NodeVisitorAbstract.php
new file mode 100644
index 0000000..6fb15cc
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/NodeVisitorAbstract.php
@@ -0,0 +1,24 @@
+'",
+ "T_IS_GREATER_OR_EQUAL",
+ "T_SL",
+ "T_SR",
+ "'+'",
+ "'-'",
+ "'.'",
+ "'*'",
+ "'/'",
+ "'%'",
+ "'!'",
+ "T_INSTANCEOF",
+ "'~'",
+ "T_INC",
+ "T_DEC",
+ "T_INT_CAST",
+ "T_DOUBLE_CAST",
+ "T_STRING_CAST",
+ "T_ARRAY_CAST",
+ "T_OBJECT_CAST",
+ "T_BOOL_CAST",
+ "T_UNSET_CAST",
+ "'@'",
+ "T_POW",
+ "'['",
+ "T_NEW",
+ "T_CLONE",
+ "T_EXIT",
+ "T_IF",
+ "T_ELSEIF",
+ "T_ELSE",
+ "T_ENDIF",
+ "T_LNUMBER",
+ "T_DNUMBER",
+ "T_STRING",
+ "T_STRING_VARNAME",
+ "T_VARIABLE",
+ "T_NUM_STRING",
+ "T_INLINE_HTML",
+ "T_ENCAPSED_AND_WHITESPACE",
+ "T_CONSTANT_ENCAPSED_STRING",
+ "T_ECHO",
+ "T_DO",
+ "T_WHILE",
+ "T_ENDWHILE",
+ "T_FOR",
+ "T_ENDFOR",
+ "T_FOREACH",
+ "T_ENDFOREACH",
+ "T_DECLARE",
+ "T_ENDDECLARE",
+ "T_AS",
+ "T_SWITCH",
+ "T_MATCH",
+ "T_ENDSWITCH",
+ "T_CASE",
+ "T_DEFAULT",
+ "T_BREAK",
+ "T_CONTINUE",
+ "T_GOTO",
+ "T_FUNCTION",
+ "T_FN",
+ "T_CONST",
+ "T_RETURN",
+ "T_TRY",
+ "T_CATCH",
+ "T_FINALLY",
+ "T_USE",
+ "T_INSTEADOF",
+ "T_GLOBAL",
+ "T_STATIC",
+ "T_ABSTRACT",
+ "T_FINAL",
+ "T_PRIVATE",
+ "T_PROTECTED",
+ "T_PUBLIC",
+ "T_READONLY",
+ "T_PUBLIC_SET",
+ "T_PROTECTED_SET",
+ "T_PRIVATE_SET",
+ "T_VAR",
+ "T_UNSET",
+ "T_ISSET",
+ "T_EMPTY",
+ "T_HALT_COMPILER",
+ "T_CLASS",
+ "T_TRAIT",
+ "T_INTERFACE",
+ "T_ENUM",
+ "T_EXTENDS",
+ "T_IMPLEMENTS",
+ "T_OBJECT_OPERATOR",
+ "T_NULLSAFE_OBJECT_OPERATOR",
+ "T_LIST",
+ "T_ARRAY",
+ "T_CALLABLE",
+ "T_CLASS_C",
+ "T_TRAIT_C",
+ "T_METHOD_C",
+ "T_FUNC_C",
+ "T_PROPERTY_C",
+ "T_LINE",
+ "T_FILE",
+ "T_START_HEREDOC",
+ "T_END_HEREDOC",
+ "T_DOLLAR_OPEN_CURLY_BRACES",
+ "T_CURLY_OPEN",
+ "T_PAAMAYIM_NEKUDOTAYIM",
+ "T_NAMESPACE",
+ "T_NS_C",
+ "T_DIR",
+ "T_NS_SEPARATOR",
+ "T_ELLIPSIS",
+ "T_NAME_FULLY_QUALIFIED",
+ "T_NAME_QUALIFIED",
+ "T_NAME_RELATIVE",
+ "T_ATTRIBUTE",
+ "';'",
+ "']'",
+ "'('",
+ "')'",
+ "'{'",
+ "'}'",
+ "'`'",
+ "'\"'",
+ "'$'"
+ );
+
+ protected array $tokenToSymbol = array(
+ 0, 173, 173, 173, 173, 173, 173, 173, 173, 173,
+ 173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
+ 173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
+ 173, 173, 173, 57, 171, 173, 172, 56, 173, 173,
+ 166, 167, 54, 51, 9, 52, 53, 55, 173, 173,
+ 173, 173, 173, 173, 173, 173, 173, 173, 32, 164,
+ 45, 17, 47, 31, 69, 173, 173, 173, 173, 173,
+ 173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
+ 173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
+ 173, 71, 173, 165, 37, 173, 170, 173, 173, 173,
+ 173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
+ 173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
+ 173, 173, 173, 168, 36, 169, 59, 173, 173, 173,
+ 173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
+ 173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
+ 173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
+ 173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
+ 173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
+ 173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
+ 173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
+ 173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
+ 173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
+ 173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
+ 173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
+ 173, 173, 173, 173, 173, 173, 173, 173, 173, 173,
+ 173, 173, 173, 173, 173, 173, 1, 2, 3, 4,
+ 5, 6, 7, 8, 10, 11, 12, 13, 14, 15,
+ 16, 18, 19, 20, 21, 22, 23, 24, 25, 26,
+ 27, 28, 29, 30, 33, 34, 35, 38, 39, 40,
+ 41, 42, 43, 44, 46, 48, 49, 50, 58, 60,
+ 61, 62, 63, 64, 65, 66, 67, 68, 70, 72,
+ 73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
+ 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
+ 93, 94, 95, 96, 97, 98, 99, 100, 101, 102,
+ 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
+ 113, 114, 115, 116, 117, 118, 119, 120, 121, 122,
+ 123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
+ 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
+ 143, 144, 145, 146, 147, 148, 149, 150, 151, 152,
+ 153, 154, 155, 156, 157, 158, 159, 160, 161, 162,
+ 163
+ );
+
+ protected array $action = array(
+ 133, 134, 135, 575, 136, 137, 1049, 766, 767, 768,
+ 138, 41, 850, -341, 495, 1390,-32766,-32766,-32766, 1008,
+ 841, 1145, 1146, 1147, 1141, 1140, 1139, 1148, 1142, 1143,
+ 1144,-32766,-32766,-32766, -195, 760, 759,-32766, -194,-32766,
+ -32766,-32766,-32766,-32766,-32766,-32766,-32767,-32767,-32767,-32767,
+ -32767, 0,-32766, 3, 4, 769, 1145, 1146, 1147, 1141,
+ 1140, 1139, 1148, 1142, 1143, 1144, 388, 389, 448, 272,
+ 53, 391, 773, 774, 775, 776, 433, 5, 434, 571,
+ 337, 39, 254, 29, 298, 830, 777, 778, 779, 780,
+ 781, 782, 783, 784, 785, 786, 806, 576, 807, 808,
+ 809, 810, 798, 799, 353, 354, 801, 802, 787, 788,
+ 789, 791, 792, 793, 364, 833, 834, 835, 836, 837,
+ 577, -382, 306, -382, 794, 795, 578, 579, 244, 818,
+ 816, 817, 829, 813, 814, 1313, 38, 580, 581, 812,
+ 582, 583, 584, 585, 1325, 586, 587, 481, 482, -628,
+ 496, 1009, 815, 588, 589, 140, 139, -628, 133, 134,
+ 135, 575, 136, 137, 1085, 766, 767, 768, 138, 41,
+ -32766, -341, 1046, 1041, 1040, 1039, 1045, 1042, 1043, 1044,
+ -32766,-32766,-32766,-32767,-32767,-32767,-32767, 106, 107, 108,
+ 109, 110, -195, 760, 759, 1058, -194,-32766,-32766,-32766,
+ 149,-32766, 852,-32766,-32766,-32766,-32766,-32766,-32766,-32766,
+ 936, 303, 257, 769,-32766,-32766,-32766, 850,-32766, 297,
+ -32766,-32766,-32766,-32766,-32766, 1371, 1355, 272, 53, 391,
+ 773, 774, 775, 776, -625,-32766, 434,-32766,-32766,-32766,
+ -32766, 730, -625, 830, 777, 778, 779, 780, 781, 782,
+ 783, 784, 785, 786, 806, 576, 807, 808, 809, 810,
+ 798, 799, 353, 354, 801, 802, 787, 788, 789, 791,
+ 792, 793, 364, 833, 834, 835, 836, 837, 577, -579,
+ -275, 317, 794, 795, 578, 579, -577, 818, 816, 817,
+ 829, 813, 814, 957, 926, 580, 581, 812, 582, 583,
+ 584, 585, 144, 586, 587, 841, 336,-32766,-32766,-32766,
+ 815, 588, 589, -628, 139, -628, 133, 134, 135, 575,
+ 136, 137, 1082, 766, 767, 768, 138, 41,-32766, 1375,
+ -32766,-32766,-32766,-32766,-32766,-32766,-32766, 1374, 629, 388,
+ 389,-32766,-32766,-32766,-32766,-32766, -579, -579, 1081, 433,
+ 321, 760, 759, -577, -577,-32766, 1293,-32766,-32766, 111,
+ 112, 113, -579, 282, 843, 851, 623, 1400, 936, -577,
+ 1401, 769, 333, 938, -585, 114, -579, 725, 294, 298,
+ 1119, -584, 349, -577, 752, 272, 53, 391, 773, 774,
+ 775, 776, 145, 86, 434, 306, 336, 336, -625, 731,
+ -625, 830, 777, 778, 779, 780, 781, 782, 783, 784,
+ 785, 786, 806, 576, 807, 808, 809, 810, 798, 799,
+ 353, 354, 801, 802, 787, 788, 789, 791, 792, 793,
+ 364, 833, 834, 835, 836, 837, 577, -576, 850, -578,
+ 794, 795, 578, 579, 845, 818, 816, 817, 829, 813,
+ 814, 727, 926, 580, 581, 812, 582, 583, 584, 585,
+ 740, 586, 587, 243, 1055,-32766,-32766, -85, 815, 588,
+ 589, 878, 152, 879, 133, 134, 135, 575, 136, 137,
+ 1087, 766, 767, 768, 138, 41, 350, 961, 960, 1058,
+ 1058, 1058,-32766,-32766,-32766, 841,-32766, 131, 977, 978,
+ 400, 1055, 10, 979, -576, -576, -578, -578, 378, 760,
+ 759, 936, 973, 290, 297, 297,-32766, 846, 936, 154,
+ -576, 79, -578, 382, 849, 936, 1058, 336, 878, 769,
+ 879, 938, -583, -85, -576, 725, -578, 959, 108, 109,
+ 110, 1058, 732, 272, 53, 391, 773, 774, 775, 776,
+ 290, 155, 434, 470, 471, 472, 735, 760, 759, 830,
+ 777, 778, 779, 780, 781, 782, 783, 784, 785, 786,
+ 806, 576, 807, 808, 809, 810, 798, 799, 353, 354,
+ 801, 802, 787, 788, 789, 791, 792, 793, 364, 833,
+ 834, 835, 836, 837, 577, 926, 434, 847, 794, 795,
+ 578, 579, 926, 818, 816, 817, 829, 813, 814, 926,
+ 398, 580, 581, 812, 582, 583, 584, 585, 452, 586,
+ 587, 157, 87, 88, 89, 453, 815, 588, 589, 454,
+ 152, 790, 761, 762, 763, 764, 765, 158, 766, 767,
+ 768, 803, 804, 40, 27, 90, 91, 92, 93, 94,
+ 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
+ 105, 106, 107, 108, 109, 110, 111, 112, 113, 1134,
+ 282, 1055, 455,-32766, 994, 1288, 1287, 1289, 725, 390,
+ 389, 938, 114, 856, 1120, 725, 769, 159, 938, 433,
+ 672, 23, 725, 1118, 691, 692, 1058,-32766, 153, 416,
+ 770, 771, 772, 773, 774, 775, 776, -78, -619, 839,
+ -619, -581, 386, 387, 392, 393, 830, 777, 778, 779,
+ 780, 781, 782, 783, 784, 785, 786, 806, 828, 807,
+ 808, 809, 810, 798, 799, 800, 827, 801, 802, 787,
+ 788, 789, 791, 792, 793, 832, 833, 834, 835, 836,
+ 837, 838, 161, 663, 664, 794, 795, 796, 797, 36,
+ 818, 816, 817, 829, 813, 814, -58, -57, 805, 811,
+ 812, 819, 820, 822, 821, -87, 823, 824, -581, -581,
+ 128, 129, 141, 815, 826, 825, 54, 55, 56, 57,
+ 527, 58, 59, 142, -110, 148, 162, 60, 61, -110,
+ 62, -110, 936, 163, 164, 165, 313, 166, -581, -110,
+ -110, -110, -110, -110, -110, -110, -110, -110, -110, -110,
+ 1293, -84, 953, -78, -73, -72, -71, -70, -69, -68,
+ -67, -66, -65, 742, -46, 63, 64, -18, -575, 1286,
+ 146, 65, 51, 66, 251, 252, 67, 68, 69, 70,
+ 71, 72, 73, 74, 281, 31, 273, 47, 450, 528,
+ 291, -357, 741, 1319, 1320, 529, 744, 850, 935, 151,
+ 295, 1317, 45, 22, 530, 1284, 531, -309, 532, -305,
+ 533, 286, 936, 534, 535, 287, 926, 292, 48, 49,
+ 456, 385, 384, 293, 50, 536, 342, 296, 282, 1057,
+ 376, 348, 850, 299, 300, -575, -575, 1279, 114, 307,
+ 308, 701, 538, 539, 540, 150, 841,-32766, 1288, 1287,
+ 1289, -575, 850, 294, 542, 543, 1402, 1305, 1306, 1307,
+ 1308, 1310, 1302, 1303, 305, -575, 716, -110, -110, 130,
+ 1309, 1304, -110, 593, 1288, 1287, 1289, 306, 13, 673,
+ 75, -110, 1152, 678, 331, 332, 336, -154, -154, -154,
+ -32766, 718, 694, -4, 936, 938, 926, 314, 478, 725,
+ 506, 1324, -154, 705, -154, 679, -154, 695, -154, 974,
+ 1326, -541, 306, 312, 311, 79, 849, 661, 383, 43,
+ 320, 336, 37, 1252, 0, 0, 52, 0, 0, 977,
+ 978, 0, 760, 759, 537,-32766, 0, 0, 0, 706,
+ 0, 0, 912, 973, -110, -110, -110, 35, 115, 116,
+ 117, 118, 119, 120, 121, 122, 123, 124, 125, 126,
+ 127, -531, 11, 707, 708, 31, 274, 30, 380, 955,
+ 599, -613, 306, 627, 0, 938, 0, 850, 926, 725,
+ -154, 1317, 1288, 1287, 1289, 44, -612, 749, 290, 750,
+ 1194, 1196, 869, 309, 310, 917, 1018, 995, 1002, 992,
+ 383, -575, 446, 1003, 915, 990, 1123, 304, 1126, 381,
+ 1127, 977, 978, 1124, 1125, 1131, 537, 1279, 1314, 861,
+ 330, 760, 759, 132, 541, 973, -110, -110, -110, 1341,
+ 1359, 1393, 1293, 666, 542, 543, -611, 1305, 1306, 1307,
+ 1308, 1310, 1302, 1303, -585, -584, -583, -582, 21, -525,
+ 1309, 1304, 1, 32, 760, 759, 33, 938,-32766, -278,
+ 77, 725, -4, -16, 1286, 332, 336, 42, -575, -575,
+ 46,-32766,-32766,-32766, 76,-32766, 80,-32766, 81,-32766,
+ 82, 83,-32766, 84, -575, 85, 147,-32766,-32766,-32766,
+ 156,-32766, 160,-32766,-32766, 249, 379, 1286, -575,-32766,
+ 430, 31, 273, 338,-32766,-32766,-32766, 365,-32766, 366,
+ -32766,-32766,-32766, 850, 850,-32766, 367, 1317, 368, 369,
+ -32766,-32766,-32766, 370, 371, 372,-32766,-32766, 373, 374,
+ 375, 377,-32766, 430, 447, 570, 31, 274, -276, -275,
+ 15, 16, 78, 17,-32766, 18, 20, 414, 850, -110,
+ -110, 497, 1317, 1279, -110, 498, 505, 508, 509, 510,
+ 511, 515, 516, -110, 517, 525, 604, 711, 1088, 1084,
+ 1234, 543,-32766, 1305, 1306, 1307, 1308, 1310, 1302, 1303,
+ 1315, 1086, 1083, -50, 1064, 1274, 1309, 1304, 1279, 1060,
+ -280, -102, 14, 19, 306, 24, 77, 79, 415, 303,
+ 413, 332, 336, 336, 618, 624, 543, 652, 1305, 1306,
+ 1307, 1308, 1310, 1302, 1303, 717, 143, 1238, 1292, 1235,
+ 1372, 1309, 1304, 726, 729, 733,-32766, 734, 736, 737,
+ 738, 77, 1286, 419, 739, 743, 332, 336, 728,-32766,
+ -32766,-32766, 746,-32766, 913,-32766, 1397,-32766, 1399, 872,
+ -32766, 871, 967, 1010, 1398,-32766,-32766,-32766, 966,-32766,
+ 964,-32766,-32766, 965, 968, 1286, 1267,-32766, 430, 946,
+ 956, 944,-32766,-32766,-32766, 1000,-32766, 1001,-32766,-32766,
+ -32766, 650, 1396,-32766, 1353, 1342, 1360, 1369,-32766,-32766,
+ -32766, 1318,-32766, 336,-32766,-32766, 936, 0, 1286, 0,
+ -32766, 430, 0, 0, 0,-32766,-32766,-32766, 0,-32766,
+ 0,-32766,-32766,-32766, 0, 0,-32766, 0, 0, 936,
+ 0,-32766,-32766,-32766, 0,-32766, 0,-32766,-32766, 0,
+ 0, 1286, 0,-32766, 430, 0, 0, 0,-32766,-32766,
+ -32766, 0,-32766, 0,-32766,-32766,-32766, 0, 0,-32766,
+ 0, 0, 0, 501,-32766,-32766,-32766, 0,-32766, 0,
+ -32766,-32766, 0, 0, 1286, 606,-32766, 430, 0, 0,
+ 0,-32766,-32766,-32766, 0,-32766, 0,-32766,-32766,-32766,
+ 926, 0,-32766, 2, 0, 0, 0,-32766,-32766,-32766,
+ 0, 0, 0,-32766,-32766, 0, -253, -253, -253,-32766,
+ 430, 0, 383, 926, 0, 0, 0, 0, 0, 0,
+ 0,-32766, 0, 977, 978, 0, 0, 0, 537, -252,
+ -252, -252, 0, 0, 0, 383, 912, 973, -110, -110,
+ -110, 0, 0, 0, 0, 0, 977, 978, 0, 0,
+ 0, 537, 0, 0, 0, 0, 0, 0, 0, 912,
+ 973, -110, -110, -110,-32766, 0, 0, 0, 0, 938,
+ 1286, 0, 0, 725, -253, 0, 0,-32766,-32766,-32766,
+ 0,-32766, 0,-32766, 0,-32766, 0, 0,-32766, 0,
+ 0, 0, 938,-32766,-32766,-32766, 725, -252, 0,-32766,
+ -32766, 0, 0, 0, 0,-32766, 430, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,-32766
+ );
+
+ protected array $actionCheck = array(
+ 3, 4, 5, 6, 7, 8, 1, 10, 11, 12,
+ 13, 14, 83, 9, 32, 86, 10, 11, 12, 32,
+ 81, 117, 118, 119, 120, 121, 122, 123, 124, 125,
+ 126, 10, 11, 12, 9, 38, 39, 31, 9, 33,
+ 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
+ 44, 0, 31, 9, 9, 58, 117, 118, 119, 120,
+ 121, 122, 123, 124, 125, 126, 107, 108, 109, 72,
+ 73, 74, 75, 76, 77, 78, 117, 9, 81, 86,
+ 71, 152, 153, 9, 31, 88, 89, 90, 91, 92,
+ 93, 94, 95, 96, 97, 98, 99, 100, 101, 102,
+ 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
+ 113, 114, 115, 116, 117, 118, 119, 120, 121, 122,
+ 123, 107, 163, 109, 127, 128, 129, 130, 15, 132,
+ 133, 134, 135, 136, 137, 1, 9, 140, 141, 142,
+ 143, 144, 145, 146, 151, 148, 149, 138, 139, 1,
+ 168, 164, 155, 156, 157, 9, 159, 9, 3, 4,
+ 5, 6, 7, 8, 167, 10, 11, 12, 13, 14,
+ 117, 167, 119, 120, 121, 122, 123, 124, 125, 126,
+ 10, 11, 12, 45, 46, 47, 48, 49, 50, 51,
+ 52, 53, 167, 38, 39, 142, 167, 10, 11, 12,
+ 9, 31, 1, 33, 34, 35, 36, 37, 38, 39,
+ 1, 167, 9, 58, 10, 11, 12, 83, 31, 166,
+ 33, 34, 35, 36, 37, 1, 1, 72, 73, 74,
+ 75, 76, 77, 78, 1, 31, 81, 33, 34, 35,
+ 36, 32, 9, 88, 89, 90, 91, 92, 93, 94,
+ 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
+ 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
+ 115, 116, 117, 118, 119, 120, 121, 122, 123, 71,
+ 167, 9, 127, 128, 129, 130, 71, 132, 133, 134,
+ 135, 136, 137, 1, 85, 140, 141, 142, 143, 144,
+ 145, 146, 168, 148, 149, 81, 172, 10, 11, 12,
+ 155, 156, 157, 165, 159, 167, 3, 4, 5, 6,
+ 7, 8, 167, 10, 11, 12, 13, 14, 31, 1,
+ 33, 34, 35, 10, 10, 11, 12, 9, 52, 107,
+ 108, 10, 11, 12, 10, 11, 138, 139, 1, 117,
+ 9, 38, 39, 138, 139, 31, 1, 33, 34, 54,
+ 55, 56, 154, 58, 81, 164, 1, 81, 1, 154,
+ 84, 58, 9, 164, 166, 70, 168, 168, 31, 31,
+ 164, 166, 9, 168, 168, 72, 73, 74, 75, 76,
+ 77, 78, 168, 168, 81, 163, 172, 172, 165, 32,
+ 167, 88, 89, 90, 91, 92, 93, 94, 95, 96,
+ 97, 98, 99, 100, 101, 102, 103, 104, 105, 106,
+ 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
+ 117, 118, 119, 120, 121, 122, 123, 71, 83, 71,
+ 127, 128, 129, 130, 161, 132, 133, 134, 135, 136,
+ 137, 168, 85, 140, 141, 142, 143, 144, 145, 146,
+ 168, 148, 149, 98, 117, 117, 117, 32, 155, 156,
+ 157, 107, 159, 109, 3, 4, 5, 6, 7, 8,
+ 167, 10, 11, 12, 13, 14, 9, 73, 74, 142,
+ 142, 142, 10, 11, 12, 81, 141, 15, 118, 119,
+ 107, 117, 109, 123, 138, 139, 138, 139, 9, 38,
+ 39, 1, 132, 166, 166, 166, 117, 81, 1, 15,
+ 154, 166, 154, 9, 160, 1, 142, 172, 107, 58,
+ 109, 164, 166, 98, 168, 168, 168, 123, 51, 52,
+ 53, 142, 32, 72, 73, 74, 75, 76, 77, 78,
+ 166, 15, 81, 133, 134, 135, 32, 38, 39, 88,
+ 89, 90, 91, 92, 93, 94, 95, 96, 97, 98,
+ 99, 100, 101, 102, 103, 104, 105, 106, 107, 108,
+ 109, 110, 111, 112, 113, 114, 115, 116, 117, 118,
+ 119, 120, 121, 122, 123, 85, 81, 161, 127, 128,
+ 129, 130, 85, 132, 133, 134, 135, 136, 137, 85,
+ 9, 140, 141, 142, 143, 144, 145, 146, 9, 148,
+ 149, 15, 10, 11, 12, 9, 155, 156, 157, 9,
+ 159, 3, 4, 5, 6, 7, 8, 15, 10, 11,
+ 12, 13, 14, 31, 102, 33, 34, 35, 36, 37,
+ 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 127,
+ 58, 117, 9, 117, 164, 160, 161, 162, 168, 107,
+ 108, 164, 70, 9, 169, 168, 58, 15, 164, 117,
+ 76, 77, 168, 1, 76, 77, 142, 141, 102, 103,
+ 72, 73, 74, 75, 76, 77, 78, 17, 165, 81,
+ 167, 71, 107, 108, 107, 108, 88, 89, 90, 91,
+ 92, 93, 94, 95, 96, 97, 98, 99, 100, 101,
+ 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
+ 112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
+ 122, 123, 15, 112, 113, 127, 128, 129, 130, 15,
+ 132, 133, 134, 135, 136, 137, 17, 17, 140, 141,
+ 142, 143, 144, 145, 146, 32, 148, 149, 138, 139,
+ 17, 17, 17, 155, 156, 157, 2, 3, 4, 5,
+ 6, 7, 8, 17, 102, 17, 17, 13, 14, 107,
+ 16, 109, 1, 17, 17, 17, 114, 17, 168, 117,
+ 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
+ 1, 32, 39, 32, 32, 32, 32, 32, 32, 32,
+ 32, 32, 32, 32, 32, 51, 52, 32, 71, 81,
+ 32, 57, 71, 59, 60, 61, 62, 63, 64, 65,
+ 66, 67, 68, 69, 32, 71, 72, 73, 74, 75,
+ 32, 169, 32, 79, 80, 81, 32, 83, 32, 32,
+ 38, 87, 88, 89, 90, 117, 92, 36, 94, 36,
+ 96, 36, 1, 99, 100, 36, 85, 36, 104, 105,
+ 106, 107, 108, 36, 110, 111, 36, 38, 58, 141,
+ 116, 117, 83, 38, 38, 138, 139, 123, 70, 138,
+ 139, 78, 128, 129, 130, 71, 81, 86, 160, 161,
+ 162, 154, 83, 31, 140, 141, 84, 143, 144, 145,
+ 146, 147, 148, 149, 150, 168, 81, 118, 119, 168,
+ 156, 157, 123, 90, 160, 161, 162, 163, 98, 91,
+ 166, 132, 83, 97, 170, 171, 172, 76, 77, 78,
+ 141, 93, 95, 0, 1, 164, 85, 115, 98, 168,
+ 98, 151, 91, 81, 93, 101, 95, 101, 97, 132,
+ 151, 154, 163, 137, 136, 166, 160, 114, 107, 164,
+ 136, 172, 168, 170, -1, -1, 71, -1, -1, 118,
+ 119, -1, 38, 39, 123, 141, -1, -1, -1, 117,
+ -1, -1, 131, 132, 133, 134, 135, 17, 18, 19,
+ 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+ 30, 154, 154, 141, 142, 71, 72, 154, 154, 159,
+ 158, 166, 163, 158, -1, 164, -1, 83, 85, 168,
+ 169, 87, 160, 161, 162, 164, 166, 164, 166, 164,
+ 60, 61, 164, 138, 139, 164, 164, 164, 164, 164,
+ 107, 71, 109, 164, 164, 164, 164, 114, 164, 154,
+ 164, 118, 119, 164, 164, 164, 123, 123, 165, 165,
+ 168, 38, 39, 168, 131, 132, 133, 134, 135, 165,
+ 165, 165, 1, 165, 140, 141, 166, 143, 144, 145,
+ 146, 147, 148, 149, 166, 166, 166, 166, 155, 166,
+ 156, 157, 166, 166, 38, 39, 166, 164, 75, 167,
+ 166, 168, 169, 32, 81, 171, 172, 166, 138, 139,
+ 166, 88, 89, 90, 166, 92, 166, 94, 166, 96,
+ 166, 166, 99, 166, 154, 166, 166, 104, 105, 106,
+ 166, 75, 166, 110, 111, 166, 168, 81, 168, 116,
+ 117, 71, 72, 166, 88, 89, 90, 166, 92, 166,
+ 94, 128, 96, 83, 83, 99, 166, 87, 166, 166,
+ 104, 105, 106, 166, 166, 166, 110, 111, 166, 166,
+ 166, 166, 116, 117, 166, 166, 71, 72, 167, 167,
+ 167, 167, 159, 167, 128, 167, 167, 167, 83, 118,
+ 119, 167, 87, 123, 123, 167, 167, 167, 167, 167,
+ 167, 167, 167, 132, 167, 167, 167, 167, 167, 167,
+ 167, 141, 141, 143, 144, 145, 146, 147, 148, 149,
+ 167, 167, 167, 32, 167, 167, 156, 157, 123, 167,
+ 167, 167, 167, 167, 163, 167, 166, 166, 169, 167,
+ 167, 171, 172, 172, 167, 167, 141, 167, 143, 144,
+ 145, 146, 147, 148, 149, 167, 32, 167, 167, 167,
+ 167, 156, 157, 168, 168, 168, 75, 168, 168, 168,
+ 168, 166, 81, 169, 168, 168, 171, 172, 168, 88,
+ 89, 90, 169, 92, 169, 94, 169, 96, 169, 169,
+ 99, 169, 169, 169, 169, 104, 105, 106, 169, 75,
+ 169, 110, 111, 169, 169, 81, 169, 116, 117, 169,
+ 169, 169, 88, 89, 90, 169, 92, 169, 94, 128,
+ 96, 169, 169, 99, 169, 169, 169, 169, 104, 105,
+ 106, 171, 75, 172, 110, 111, 1, -1, 81, -1,
+ 116, 117, -1, -1, -1, 88, 89, 90, -1, 92,
+ -1, 94, 128, 96, -1, -1, 99, -1, -1, 1,
+ -1, 104, 105, 106, -1, 75, -1, 110, 111, -1,
+ -1, 81, -1, 116, 117, -1, -1, -1, 88, 89,
+ 90, -1, 92, -1, 94, 128, 96, -1, -1, 99,
+ -1, -1, -1, 103, 104, 105, 106, -1, 75, -1,
+ 110, 111, -1, -1, 81, 82, 116, 117, -1, -1,
+ -1, 88, 89, 90, -1, 92, -1, 94, 128, 96,
+ 85, -1, 99, 166, -1, -1, -1, 104, 105, 106,
+ -1, -1, -1, 110, 111, -1, 101, 102, 103, 116,
+ 117, -1, 107, 85, -1, -1, -1, -1, -1, -1,
+ -1, 128, -1, 118, 119, -1, -1, -1, 123, 101,
+ 102, 103, -1, -1, -1, 107, 131, 132, 133, 134,
+ 135, -1, -1, -1, -1, -1, 118, 119, -1, -1,
+ -1, 123, -1, -1, -1, -1, -1, -1, -1, 131,
+ 132, 133, 134, 135, 75, -1, -1, -1, -1, 164,
+ 81, -1, -1, 168, 169, -1, -1, 88, 89, 90,
+ -1, 92, -1, 94, -1, 96, -1, -1, 99, -1,
+ -1, -1, 164, 104, 105, 106, 168, 169, -1, 110,
+ 111, -1, -1, -1, -1, 116, 117, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 128
+ );
+
+ protected array $actionBase = array(
+ 0, 155, -3, 313, 471, 471, 881, 963, 1365, 1388,
+ 892, 134, 515, -61, 367, 524, 524, 801, 524, 209,
+ 510, 283, 517, 517, 517, 920, 855, 628, 628, 855,
+ 628, 1053, 1053, 1053, 1053, 1086, 1086, 1320, 1320, 1353,
+ 1254, 1221, 1449, 1449, 1449, 1449, 1449, 1287, 1449, 1449,
+ 1449, 1449, 1449, 1287, 1449, 1449, 1449, 1449, 1449, 1449,
+ 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449,
+ 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449,
+ 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449,
+ 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449,
+ 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449,
+ 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449,
+ 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449,
+ 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449,
+ 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449,
+ 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449, 1449,
+ 1449, 1449, 1449, 1449, 1449, 1449, 1449, 201, -13, 44,
+ 365, 744, 1102, 1120, 1107, 1121, 1096, 1095, 1103, 1108,
+ 1122, 1183, 1185, 837, 1186, 1187, 1182, 1188, 1110, 938,
+ 1098, 1118, 612, 612, 612, 612, 612, 612, 612, 612,
+ 612, 612, 612, 612, 612, 612, 612, 612, 612, 612,
+ 612, 612, 612, 612, 612, 612, 612, 612, 612, 612,
+ 323, 482, 334, 331, 331, 331, 331, 331, 331, 331,
+ 331, 331, 331, 331, 331, 331, 331, 331, 331, 331,
+ 331, 331, 331, 964, 964, 21, 21, 21, 324, 1135,
+ 1100, 1135, 1135, 1135, 1135, 1135, 1135, 1135, 1135, 297,
+ 204, 1000, 187, 170, 170, 6, 6, 6, 6, 6,
+ 692, 53, 1101, 819, 819, 138, 138, 138, 138, 542,
+ 14, 347, 355, -41, 348, 232, 384, 384, 487, 487,
+ 554, 554, 349, 349, 554, 554, 554, 399, 399, 399,
+ 399, 208, 215, 366, 364, -7, 864, 224, 224, 224,
+ 224, 864, 864, 864, 864, 829, 1190, 864, 1011, 1027,
+ 864, 864, 368, 767, 767, 925, 305, 305, 305, 767,
+ 421, -71, -71, 421, 380, -71, 225, 286, 556, 847,
+ 572, 543, 556, 640, 771, 233, 148, 826, 605, 826,
+ 1094, 831, 831, 802, 792, 921, 1140, 1123, 874, 1176,
+ 876, 1178, 420, 9, 791, 1093, 1093, 1093, 1093, 1093,
+ 1093, 1093, 1093, 1093, 1093, 1093, 1191, 519, 1094, 436,
+ 1191, 1191, 1191, 519, 519, 519, 519, 519, 519, 519,
+ 519, 805, 519, 519, 641, 436, 614, 618, 436, 860,
+ 519, 877, 201, 201, 201, 201, 201, 201, 201, 201,
+ 201, 201, 201, -18, 201, 201, -13, 292, 292, 201,
+ 216, 5, 292, 292, 292, 292, 201, 201, 201, 201,
+ 605, 840, 882, 607, 435, 885, 29, 840, 840, 840,
+ 4, 113, 25, 841, 843, 393, 835, 835, 835, 869,
+ 956, 956, 835, 839, 835, 869, 835, 835, 956, 956,
+ 879, 956, 146, 609, 373, 514, 616, 956, 272, 835,
+ 835, 835, 835, 854, 956, 45, 68, 620, 835, 203,
+ 191, 835, 835, 854, 848, 828, 846, 956, 956, 956,
+ 854, 499, 846, 846, 846, 893, 895, 873, 822, 363,
+ 341, 674, 127, 783, 822, 822, 835, 601, 873, 822,
+ 873, 822, 880, 822, 822, 822, 873, 822, 839, 477,
+ 822, 779, 786, 663, 74, 822, 51, 978, 980, 743,
+ 982, 971, 984, 1038, 985, 987, 1125, 953, 999, 974,
+ 989, 1039, 960, 957, 836, 763, 764, 878, 827, 951,
+ 838, 838, 838, 948, 949, 838, 838, 838, 838, 838,
+ 838, 838, 838, 763, 923, 884, 853, 1013, 765, 776,
+ 1069, 820, 1145, 823, 1011, 978, 987, 789, 974, 989,
+ 960, 957, 800, 799, 797, 798, 796, 795, 793, 794,
+ 808, 1071, 1072, 990, 825, 778, 1049, 1020, 1143, 922,
+ 1022, 1023, 1050, 1073, 898, 1083, 1147, 844, 1149, 1150,
+ 924, 1028, 1126, 838, 940, 875, 934, 1027, 950, 763,
+ 935, 1084, 1085, 1043, 824, 1054, 1058, 998, 870, 842,
+ 936, 1152, 1029, 1032, 1033, 1127, 1129, 891, 1044, 962,
+ 1059, 872, 1099, 1060, 1061, 1062, 1063, 1130, 1153, 1131,
+ 890, 1132, 901, 858, 1041, 856, 1154, 504, 851, 857,
+ 866, 1035, 536, 1007, 1136, 1134, 1155, 1064, 1065, 1067,
+ 1159, 1161, 994, 902, 1046, 867, 1048, 1042, 903, 904,
+ 606, 865, 1087, 845, 849, 859, 622, 672, 1164, 1165,
+ 1167, 996, 830, 833, 905, 909, 1088, 832, 1092, 1170,
+ 737, 910, 1171, 1070, 787, 788, 690, 750, 749, 790,
+ 868, 1137, 883, 852, 850, 1034, 788, 834, 911, 1172,
+ 912, 914, 916, 1068, 919, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 784, 784, 784, 784, 784,
+ 784, 784, 784, 784, 628, 628, 628, 628, 784, 784,
+ 784, 784, 784, 784, 784, 628, 784, 784, 784, 628,
+ 628, 0, 0, 628, 0, 784, 784, 784, 784, 784,
+ 784, 784, 784, 784, 784, 784, 784, 784, 784, 784,
+ 784, 784, 784, 784, 784, 784, 784, 784, 784, 784,
+ 784, 784, 784, 784, 784, 784, 784, 784, 784, 784,
+ 784, 784, 784, 784, 784, 784, 784, 784, 784, 784,
+ 784, 784, 784, 784, 784, 784, 784, 784, 784, 784,
+ 784, 784, 784, 784, 784, 784, 784, 784, 784, 784,
+ 784, 784, 784, 784, 784, 784, 784, 784, 784, 784,
+ 784, 784, 784, 784, 784, 784, 784, 784, 784, 784,
+ 784, 784, 784, 784, 784, 784, 784, 784, 784, 784,
+ 784, 784, 784, 784, 784, 784, 784, 784, 784, 784,
+ 784, 784, 784, 784, 784, 784, 784, 784, 784, 784,
+ 784, 784, 784, 784, 784, 784, 784, 784, 784, 784,
+ 784, 784, 784, 784, 784, 784, 784, 784, 784, 784,
+ 784, 612, 612, 612, 612, 612, 612, 612, 612, 612,
+ 612, 612, 612, 612, 612, 612, 612, 612, 612, 612,
+ 612, 612, 612, 612, 612, 612, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 612, 612, 612, 612, 612, 612,
+ 612, 612, 612, 612, 612, 612, 612, 612, 612, 612,
+ 612, 612, 612, 612, 612, 612, 612, 758, 758, 612,
+ 612, 612, 612, 758, 758, 758, 758, 758, 758, 758,
+ 758, 758, 758, 612, 612, 0, 612, 612, 612, 612,
+ 612, 612, 612, 612, 879, 758, 758, 758, 758, 305,
+ 305, 305, 305, -96, -96, 758, 758, 380, 758, 380,
+ 758, 758, 305, 305, 758, 758, 758, 758, 758, 758,
+ 758, 758, 758, 758, 758, 0, 0, 0, 436, -71,
+ 758, 839, 839, 839, 839, 758, 758, 758, 758, -71,
+ -71, 758, 414, 414, 758, 758, 0, 0, 0, 0,
+ 0, 0, 0, 0, 436, 0, 0, 436, 0, 0,
+ 839, 839, 758, 380, 879, 328, 758, 0, 0, 0,
+ 0, 436, 839, 436, 519, -71, -71, 519, 519, 292,
+ 201, 328, 596, 596, 596, 596, 0, 0, 605, 879,
+ 879, 879, 879, 879, 879, 879, 879, 879, 879, 879,
+ 839, 0, 879, 0, 839, 839, 839, 0, 0, 0,
+ 0, 0, 0, 0, 0, 956, 0, 0, 0, 0,
+ 0, 0, 0, 839, 0, 956, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 839, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 838, 870, 0, 0, 870,
+ 0, 838, 838, 838, 0, 0, 0, 865, 832
+ );
+
+ protected array $actionDefault = array(
+ 3,32767,32767,32767, 102, 102,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767, 100,
+ 32767, 631, 631, 631, 631,32767,32767, 257, 102,32767,
+ 32767, 500, 415, 415, 415,32767,32767,32767, 573, 573,
+ 573, 573, 573, 17,32767,32767,32767,32767,32767,32767,
+ 32767, 500,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767, 36, 7, 8, 10, 11, 49, 338,
+ 100,32767,32767,32767,32767,32767,32767,32767,32767, 102,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767, 624,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767, 403, 494, 504, 482, 483, 485, 486, 414,
+ 574, 630, 344, 627, 342, 413, 146, 354, 343, 245,
+ 261, 505, 262, 506, 509, 510, 218, 400, 150, 151,
+ 446, 501, 448, 499, 503, 447, 420, 427, 428, 429,
+ 430, 431, 432, 433, 434, 435, 436, 437, 438, 439,
+ 418, 419, 502,32767,32767, 479, 478, 477, 444,32767,
+ 32767,32767,32767,32767,32767,32767,32767, 102,32767, 445,
+ 449, 417, 452, 450, 451, 468, 469, 466, 467, 470,
+ 32767, 323,32767,32767,32767, 471, 472, 473, 474, 381,
+ 379,32767,32767, 111, 323, 111,32767,32767, 459, 460,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767, 517, 567, 476,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767, 102,32767,32767,
+ 32767, 100, 569, 441, 443, 537, 454, 455, 453, 421,
+ 32767, 542,32767, 102,32767, 544,32767,32767,32767,32767,
+ 32767,32767,32767, 568,32767, 575, 575,32767, 530, 100,
+ 196,32767, 543, 196, 196,32767,32767,32767,32767,32767,
+ 32767,32767,32767, 638, 530, 110, 110, 110, 110, 110,
+ 110, 110, 110, 110, 110, 110,32767, 196, 110,32767,
+ 32767,32767, 100, 196, 196, 196, 196, 196, 196, 196,
+ 196, 545, 196, 196, 191,32767, 271, 273, 102, 592,
+ 196, 547,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 530, 464, 139,32767, 532, 139, 575, 456, 457, 458,
+ 575, 575, 575, 319, 296,32767,32767,32767,32767,32767,
+ 545, 545, 100, 100, 100, 100,32767,32767,32767,32767,
+ 111, 516, 99, 99, 99, 99, 99, 103, 101,32767,
+ 32767,32767,32767, 226,32767, 101, 101, 99,32767, 101,
+ 101,32767,32767, 226, 228, 215, 230,32767, 596, 597,
+ 226, 101, 230, 230, 230, 250, 250, 519, 325, 101,
+ 99, 101, 101, 198, 325, 325,32767, 101, 519, 325,
+ 519, 325, 200, 325, 325, 325, 519, 325,32767, 101,
+ 325, 217, 403, 99, 99, 325,32767,32767,32767, 532,
+ 32767,32767,32767,32767,32767,32767,32767, 225,32767,32767,
+ 32767,32767,32767,32767,32767,32767, 562,32767, 580, 594,
+ 462, 463, 465, 579, 577, 487, 488, 489, 490, 491,
+ 492, 493, 496, 626,32767, 536,32767,32767,32767, 353,
+ 32767, 636,32767,32767,32767, 9, 74, 525, 42, 43,
+ 51, 57, 551, 552, 553, 554, 548, 549, 555, 550,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767, 637,32767, 575,32767,
+ 32767,32767,32767, 461, 557, 602,32767,32767, 576, 629,
+ 32767,32767,32767,32767,32767,32767,32767,32767, 139,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767, 562,
+ 32767, 137,32767,32767,32767,32767,32767,32767,32767,32767,
+ 558,32767,32767,32767, 575,32767,32767,32767,32767, 321,
+ 318,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767, 575,32767,32767,
+ 32767,32767,32767, 298,32767, 315,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767, 399, 532, 301, 303, 304,32767,
+ 32767,32767,32767, 375,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767, 153, 153, 3, 3, 356,
+ 153, 153, 153, 356, 356, 153, 356, 356, 356, 153,
+ 153, 153, 153, 153, 153, 283, 186, 265, 268, 250,
+ 250, 153, 367, 153
+ );
+
+ protected array $goto = array(
+ 202, 169, 202, 202, 202, 1056, 842, 712, 359, 670,
+ 671, 598, 688, 689, 690, 748, 653, 655, 591, 929,
+ 675, 930, 1090, 721, 699, 702, 1028, 710, 719, 1024,
+ 171, 171, 171, 171, 226, 203, 199, 199, 181, 183,
+ 221, 199, 199, 199, 199, 199, 1180, 200, 200, 200,
+ 200, 200, 1180, 193, 194, 195, 196, 197, 198, 223,
+ 221, 224, 550, 551, 431, 552, 555, 556, 557, 558,
+ 559, 560, 561, 562, 172, 173, 174, 201, 175, 176,
+ 177, 170, 178, 179, 180, 182, 220, 222, 225, 245,
+ 248, 259, 260, 262, 263, 264, 265, 266, 267, 268,
+ 269, 275, 276, 277, 278, 288, 289, 326, 327, 328,
+ 437, 438, 439, 613, 227, 228, 229, 230, 231, 232,
+ 233, 234, 235, 236, 237, 238, 239, 240, 241, 184,
+ 242, 185, 194, 195, 196, 197, 198, 223, 204, 205,
+ 206, 207, 246, 186, 187, 208, 188, 209, 205, 189,
+ 247, 204, 168, 210, 211, 190, 212, 213, 214, 191,
+ 215, 216, 192, 217, 218, 219, 285, 283, 285, 285,
+ 870, 1089, 1091, 1094, 615, 255, 255, 255, 255, 255,
+ 441, 677, 614, 1130, 884, 867, 436, 329, 323, 324,
+ 345, 608, 440, 346, 442, 654, 724, 492, 521, 715,
+ 896, 1128, 993, 883, 494, 253, 253, 253, 253, 250,
+ 256, 489, 1361, 1362, 1386, 1386, 925, 920, 921, 934,
+ 876, 922, 873, 923, 924, 874, 877, 363, 928, 881,
+ 480, 480, 868, 880, 1386, 848, 474, 363, 363, 480,
+ 1117, 1112, 1113, 1114, 1229, 351, 362, 362, 362, 362,
+ 1389, 1389, 429, 363, 363, 1017, 902, 363, 989, 1403,
+ 747, 360, 361, 566, 1026, 1021, 1056, 1285, 1285, 1285,
+ 569, 352, 351, 363, 363, 605, 1056, 1285, 848, 1056,
+ 848, 1056, 1056, 1137, 1138, 1056, 1056, 1056, 1056, 1056,
+ 1056, 1056, 1056, 1056, 1056, 1056, 357, 1261, 962, 637,
+ 674, 1285, 1262, 1265, 963, 1266, 1285, 1285, 1285, 1285,
+ 1376, 435, 1285, 628, 402, 1285, 1285, 1368, 1368, 1368,
+ 1368, 1347, 574, 567, 1062, 1061, 1059, 1059, 958, 958,
+ 697, 970, 1014, 942, 1051, 1067, 1068, 943, 565, 565,
+ 565, 603, 513, 522, 514, 863, 676, 863, 565, 709,
+ 520, 1176, 318, 567, 574, 600, 601, 319, 611, 617,
+ 844, 633, 634, 1080, 8, 709, 9, 449, 709, 28,
+ 1065, 1066, 467, 335, 316, 569, 698, 987, 987, 987,
+ 987, 1363, 1364, 467, 639, 639, 981, 988, 609, 631,
+ 1316, 1316, 1316, 1316, 1316, 1316, 1316, 1316, 1316, 1316,
+ 1335, 1335, 863, 469, 682, 469, 1335, 1335, 1335, 1335,
+ 1335, 1335, 1335, 1335, 1335, 1335, 347, 258, 258, 626,
+ 640, 643, 644, 645, 646, 667, 668, 669, 723, 632,
+ 460, 860, 460, 460, 460, 1358, 1358, 1358, 553, 553,
+ 1278, 985, 420, 720, 553, 1358, 553, 553, 553, 553,
+ 553, 553, 553, 553, 451, 889, 568, 595, 568, 647,
+ 649, 651, 568, 976, 595, 411, 405, 473, 886, 1276,
+ 1370, 1370, 1370, 1370, 909, 866, 909, 909, 1036, 483,
+ 612, 484, 485, 751, 563, 563, 563, 563, 894, 619,
+ 1101, 1394, 1395, 412, 1332, 1332, 898, 490, 1151, 1354,
+ 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
+ 279, 1105, 334, 334, 334, 998, 892, 0, 1280, 1047,
+ 0, 0, 863, 0, 0, 460, 460, 460, 460, 460,
+ 460, 460, 460, 460, 460, 460, 0, 0, 460, 1103,
+ 554, 554, 0, 1356, 1356, 1103, 554, 554, 554, 554,
+ 554, 554, 554, 554, 554, 554, 621, 622, 417, 418,
+ 947, 1166, 0, 686, 0, 687, 0, 422, 423, 424,
+ 0, 700, 1033, 0, 425, 1281, 1282, 0, 1268, 355,
+ 888, 0, 680, 1012, 858, 0, 0, 0, 882, 443,
+ 0, 1268, 0, 897, 885, 1100, 1104, 0, 0, 0,
+ 1275, 0, 443, 0, 1283, 1344, 1345, 996, 0, 0,
+ 1063, 1063, 0, 0, 0, 681, 1074, 1070, 1071, 404,
+ 407, 616, 620, 0, 0, 0, 0, 0, 0, 0,
+ 986, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1149, 901, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1031, 1031
+ );
+
+ protected array $gotoCheck = array(
+ 42, 42, 42, 42, 42, 73, 6, 73, 97, 86,
+ 86, 48, 86, 86, 86, 48, 48, 48, 127, 65,
+ 48, 65, 131, 9, 48, 48, 48, 48, 48, 48,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 23, 23, 23, 23,
+ 15, 130, 130, 130, 134, 5, 5, 5, 5, 5,
+ 66, 66, 8, 8, 35, 26, 66, 66, 66, 66,
+ 66, 66, 66, 66, 66, 66, 8, 84, 8, 8,
+ 35, 8, 49, 35, 84, 5, 5, 5, 5, 5,
+ 5, 185, 185, 185, 191, 191, 15, 15, 15, 15,
+ 15, 15, 15, 15, 15, 15, 15, 14, 15, 15,
+ 157, 157, 27, 15, 191, 12, 159, 14, 14, 157,
+ 15, 15, 15, 15, 159, 177, 24, 24, 24, 24,
+ 191, 191, 43, 14, 14, 50, 45, 14, 50, 14,
+ 50, 97, 97, 50, 50, 50, 73, 73, 73, 73,
+ 14, 177, 177, 14, 14, 181, 73, 73, 12, 73,
+ 12, 73, 73, 148, 148, 73, 73, 73, 73, 73,
+ 73, 73, 73, 73, 73, 73, 188, 79, 79, 56,
+ 56, 73, 79, 79, 79, 79, 73, 73, 73, 73,
+ 190, 13, 73, 13, 62, 73, 73, 9, 9, 9,
+ 9, 14, 76, 76, 119, 119, 89, 89, 9, 9,
+ 89, 89, 103, 73, 89, 89, 89, 73, 19, 19,
+ 19, 104, 163, 14, 163, 22, 64, 22, 19, 7,
+ 163, 158, 76, 76, 76, 76, 76, 76, 76, 76,
+ 7, 76, 76, 115, 46, 7, 46, 113, 7, 76,
+ 120, 120, 19, 178, 178, 14, 117, 19, 19, 19,
+ 19, 187, 187, 19, 108, 108, 19, 19, 2, 2,
+ 108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
+ 179, 179, 22, 83, 121, 83, 179, 179, 179, 179,
+ 179, 179, 179, 179, 179, 179, 29, 5, 5, 81,
+ 81, 81, 81, 81, 81, 81, 81, 81, 81, 80,
+ 23, 18, 23, 23, 23, 134, 134, 134, 165, 165,
+ 14, 93, 93, 93, 165, 134, 165, 165, 165, 165,
+ 165, 165, 165, 165, 83, 39, 9, 9, 9, 85,
+ 85, 85, 9, 92, 9, 28, 9, 9, 37, 169,
+ 134, 134, 134, 134, 25, 25, 25, 25, 110, 9,
+ 9, 9, 9, 99, 107, 107, 107, 107, 9, 107,
+ 133, 9, 9, 31, 180, 180, 41, 160, 151, 134,
+ 180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
+ 24, 136, 24, 24, 24, 96, 9, -1, 20, 114,
+ -1, -1, 22, -1, -1, 23, 23, 23, 23, 23,
+ 23, 23, 23, 23, 23, 23, -1, -1, 23, 134,
+ 182, 182, -1, 134, 134, 134, 182, 182, 182, 182,
+ 182, 182, 182, 182, 182, 182, 17, 17, 82, 82,
+ 17, 17, -1, 82, -1, 82, -1, 82, 82, 82,
+ -1, 82, 17, -1, 82, 20, 20, -1, 20, 82,
+ 17, -1, 17, 17, 20, -1, -1, -1, 17, 118,
+ -1, 20, -1, 16, 16, 16, 16, -1, -1, -1,
+ 17, -1, 118, -1, 20, 20, 20, 16, -1, -1,
+ 118, 118, -1, -1, -1, 118, 118, 118, 118, 59,
+ 59, 59, 59, -1, -1, -1, -1, -1, -1, -1,
+ 16, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 16, 16, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 107, 107
+ );
+
+ protected array $gotoBase = array(
+ 0, 0, -339, 0, 0, 174, -7, 339, 171, 10,
+ 0, 0, -69, -36, -78, -186, 130, 81, 114, 66,
+ 117, 0, 62, 160, 240, 468, 178, 225, 118, 112,
+ 0, 45, 0, 0, 0, -195, 0, 119, 0, 122,
+ 0, 44, -1, 226, 0, 227, -387, 0, -715, 182,
+ 241, 0, 0, 0, 0, 0, 256, 0, 0, 570,
+ 0, 0, 269, 0, 102, 3, -63, 0, 0, 0,
+ 0, 0, 0, -5, 0, 0, -31, 0, 0, -120,
+ 110, 53, 54, 120, -286, -33, -724, 0, 0, 40,
+ 0, 0, 124, 129, 0, 0, 61, -488, 0, 67,
+ 0, 0, 0, 294, 295, 0, 0, 453, 141, 0,
+ 100, 0, 0, 83, -3, 82, 0, 86, 318, 38,
+ 78, 107, 0, 0, 0, 0, 0, 16, 0, 0,
+ 168, 20, 0, 108, 163, 0, 58, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 4, 0,
+ 0, 43, 0, 0, 0, 0, 0, 193, 101, -38,
+ 46, 0, 0, -166, 0, 195, 0, 0, 0, 92,
+ 0, 0, 0, 0, 0, 0, 0, -60, 42, 157,
+ 251, 243, 297, 0, 0, -97, 0, 1, 263, 0,
+ 276, -101, 0, 0
+ );
+
+ protected array $gotoDefault = array(
+ -32768, 526, 755, 7, 756, 951, 831, 840, 590, 544,
+ 722, 356, 641, 432, 1352, 927, 1165, 610, 859, 1294,
+ 1300, 468, 862, 340, 745, 939, 910, 911, 408, 395,
+ 875, 406, 665, 642, 507, 895, 464, 887, 499, 890,
+ 463, 899, 167, 428, 524, 903, 6, 906, 572, 937,
+ 991, 396, 914, 397, 693, 916, 594, 918, 919, 403,
+ 409, 410, 1170, 602, 638, 931, 261, 596, 932, 394,
+ 933, 941, 399, 401, 703, 479, 518, 512, 421, 1132,
+ 597, 625, 662, 457, 486, 636, 648, 635, 493, 444,
+ 426, 339, 975, 983, 500, 477, 997, 358, 1005, 753,
+ 1178, 656, 502, 1013, 657, 1020, 1023, 545, 546, 491,
+ 1035, 271, 1038, 503, 1048, 26, 683, 1053, 1054, 684,
+ 658, 1076, 659, 685, 660, 1078, 476, 592, 1179, 475,
+ 1093, 1099, 465, 1102, 1340, 466, 1106, 270, 1109, 284,
+ 427, 445, 1115, 1116, 12, 1122, 713, 714, 25, 280,
+ 523, 1150, 704,-32768,-32768,-32768,-32768, 462, 1177, 461,
+ 1249, 1251, 573, 504, 1269, 301, 1272, 696, 519, 1277,
+ 458, 1343, 459, 547, 487, 325, 548, 1387, 315, 343,
+ 322, 564, 302, 344, 549, 488, 1349, 1357, 341, 34,
+ 1377, 1388, 607, 630
+ );
+
+ protected array $ruleToNonTerminal = array(
+ 0, 1, 3, 3, 2, 5, 5, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 7, 7, 7,
+ 7, 7, 7, 7, 7, 8, 8, 9, 10, 11,
+ 11, 11, 12, 12, 13, 13, 14, 15, 15, 16,
+ 16, 17, 17, 18, 18, 21, 21, 22, 23, 23,
+ 24, 24, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 29, 29, 30, 30, 32, 34,
+ 34, 28, 36, 36, 33, 38, 38, 35, 35, 37,
+ 37, 39, 39, 31, 40, 40, 41, 43, 44, 44,
+ 45, 45, 46, 46, 48, 47, 47, 47, 47, 49,
+ 49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
+ 49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
+ 49, 49, 49, 25, 25, 50, 69, 69, 72, 72,
+ 71, 70, 70, 63, 75, 75, 76, 76, 77, 77,
+ 78, 78, 79, 79, 80, 80, 80, 80, 26, 26,
+ 27, 27, 27, 27, 27, 88, 88, 90, 90, 83,
+ 83, 91, 91, 92, 92, 92, 84, 84, 87, 87,
+ 85, 85, 93, 94, 94, 57, 57, 65, 65, 68,
+ 68, 68, 67, 95, 95, 96, 58, 58, 58, 58,
+ 97, 97, 98, 98, 99, 99, 100, 101, 101, 102,
+ 102, 103, 103, 55, 55, 51, 51, 105, 53, 53,
+ 106, 52, 52, 54, 54, 64, 64, 64, 64, 81,
+ 81, 109, 109, 111, 111, 112, 112, 112, 112, 112,
+ 112, 112, 112, 110, 110, 110, 115, 115, 115, 115,
+ 89, 89, 118, 118, 118, 119, 119, 116, 116, 120,
+ 120, 122, 122, 123, 123, 117, 124, 124, 121, 125,
+ 125, 125, 125, 113, 113, 82, 82, 82, 20, 20,
+ 20, 128, 128, 128, 128, 129, 129, 129, 127, 126,
+ 126, 131, 131, 131, 130, 130, 60, 132, 132, 133,
+ 61, 135, 135, 136, 136, 137, 137, 86, 138, 138,
+ 138, 138, 138, 138, 138, 143, 143, 144, 144, 145,
+ 145, 145, 145, 145, 146, 147, 147, 142, 142, 139,
+ 139, 141, 141, 149, 149, 148, 148, 148, 148, 148,
+ 148, 148, 148, 148, 148, 140, 150, 150, 152, 151,
+ 151, 153, 153, 114, 154, 154, 156, 156, 156, 155,
+ 155, 62, 104, 157, 157, 56, 56, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 164, 165, 165, 166, 158, 158, 163,
+ 163, 167, 168, 168, 169, 170, 171, 171, 171, 171,
+ 19, 19, 73, 73, 73, 73, 159, 159, 159, 159,
+ 173, 173, 162, 162, 162, 160, 160, 179, 179, 179,
+ 179, 179, 179, 179, 179, 179, 179, 180, 180, 180,
+ 108, 182, 182, 182, 182, 161, 161, 161, 161, 161,
+ 161, 161, 161, 59, 59, 176, 176, 176, 176, 176,
+ 183, 183, 172, 172, 172, 172, 184, 184, 184, 184,
+ 184, 184, 74, 74, 66, 66, 66, 66, 134, 134,
+ 134, 134, 187, 186, 175, 175, 175, 175, 175, 175,
+ 175, 174, 174, 174, 185, 185, 185, 185, 107, 181,
+ 189, 189, 188, 188, 190, 190, 190, 190, 190, 190,
+ 190, 190, 178, 178, 178, 178, 177, 192, 191, 191,
+ 191, 191, 191, 191, 191, 191, 193, 193, 193, 193
+ );
+
+ protected array $ruleToLength = array(
+ 1, 1, 2, 0, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 0, 1, 1, 2, 1, 3, 4, 1, 2,
+ 0, 1, 1, 1, 1, 4, 3, 5, 4, 3,
+ 4, 1, 3, 4, 1, 1, 8, 7, 2, 3,
+ 1, 2, 3, 1, 2, 3, 1, 1, 3, 1,
+ 3, 1, 2, 2, 3, 1, 3, 2, 3, 1,
+ 3, 3, 2, 0, 1, 1, 1, 1, 1, 3,
+ 7, 10, 5, 7, 9, 5, 3, 3, 3, 3,
+ 3, 3, 1, 2, 5, 7, 9, 6, 5, 6,
+ 3, 2, 1, 1, 1, 1, 0, 2, 1, 3,
+ 8, 0, 4, 2, 1, 3, 0, 1, 0, 1,
+ 0, 1, 3, 1, 1, 1, 1, 1, 8, 9,
+ 7, 8, 7, 6, 8, 0, 2, 0, 2, 1,
+ 2, 1, 2, 1, 1, 1, 0, 2, 0, 2,
+ 0, 2, 2, 1, 3, 1, 4, 1, 4, 1,
+ 1, 4, 2, 1, 3, 3, 3, 4, 4, 5,
+ 0, 2, 4, 3, 1, 1, 7, 0, 2, 1,
+ 3, 3, 4, 1, 4, 0, 2, 5, 0, 2,
+ 6, 0, 2, 0, 3, 1, 2, 1, 1, 2,
+ 0, 1, 3, 0, 2, 1, 1, 1, 1, 1,
+ 1, 1, 1, 7, 9, 6, 1, 2, 1, 1,
+ 1, 1, 1, 1, 1, 1, 3, 3, 3, 1,
+ 3, 3, 3, 3, 3, 1, 3, 3, 1, 1,
+ 2, 1, 1, 0, 1, 0, 2, 2, 2, 4,
+ 3, 2, 4, 4, 3, 3, 1, 3, 1, 1,
+ 3, 2, 2, 3, 1, 1, 2, 3, 1, 1,
+ 2, 3, 1, 1, 3, 2, 0, 1, 5, 5,
+ 6, 10, 3, 5, 1, 1, 3, 0, 2, 4,
+ 5, 4, 4, 4, 3, 1, 1, 1, 1, 1,
+ 1, 0, 1, 1, 2, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 2, 1, 3, 1, 1,
+ 3, 0, 2, 0, 5, 8, 1, 3, 3, 0,
+ 2, 2, 2, 3, 1, 0, 1, 1, 3, 3,
+ 3, 4, 4, 1, 1, 2, 2, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 2, 2, 2, 2, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 5, 4, 3,
+ 4, 4, 2, 2, 4, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 1, 3, 2,
+ 1, 2, 4, 2, 2, 8, 9, 8, 9, 9,
+ 10, 9, 10, 8, 3, 2, 2, 1, 1, 0,
+ 4, 2, 1, 3, 2, 1, 2, 2, 2, 4,
+ 1, 1, 1, 1, 1, 1, 1, 1, 3, 1,
+ 1, 1, 0, 1, 1, 0, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 3, 5, 3,
+ 3, 4, 1, 1, 3, 1, 1, 1, 1, 1,
+ 3, 2, 3, 0, 1, 1, 3, 1, 1, 1,
+ 1, 1, 1, 3, 1, 1, 1, 4, 4, 1,
+ 4, 4, 0, 1, 1, 1, 3, 3, 1, 4,
+ 2, 2, 1, 3, 1, 4, 4, 3, 3, 3,
+ 3, 1, 3, 1, 1, 3, 1, 1, 4, 1,
+ 1, 1, 3, 1, 1, 2, 1, 3, 4, 3,
+ 2, 0, 2, 2, 1, 2, 1, 1, 1, 4,
+ 3, 3, 3, 3, 6, 3, 1, 1, 2, 1
+ );
+
+ protected function initReduceCallbacks(): void {
+ $this->reduceCallbacks = [
+ 0 => null,
+ 1 => static function ($self, $stackPos) {
+ $self->semValue = $self->handleNamespaces($self->semStack[$stackPos-(1-1)]);
+ },
+ 2 => static function ($self, $stackPos) {
+ if ($self->semStack[$stackPos-(2-2)] !== null) { $self->semStack[$stackPos-(2-1)][] = $self->semStack[$stackPos-(2-2)]; } $self->semValue = $self->semStack[$stackPos-(2-1)];;
+ },
+ 3 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 4 => static function ($self, $stackPos) {
+ $nop = $self->maybeCreateZeroLengthNop($self->tokenPos);;
+ if ($nop !== null) { $self->semStack[$stackPos-(1-1)][] = $nop; } $self->semValue = $self->semStack[$stackPos-(1-1)];
+ },
+ 5 => null,
+ 6 => null,
+ 7 => null,
+ 8 => null,
+ 9 => null,
+ 10 => null,
+ 11 => null,
+ 12 => null,
+ 13 => null,
+ 14 => null,
+ 15 => null,
+ 16 => null,
+ 17 => null,
+ 18 => null,
+ 19 => null,
+ 20 => null,
+ 21 => null,
+ 22 => null,
+ 23 => null,
+ 24 => null,
+ 25 => null,
+ 26 => null,
+ 27 => null,
+ 28 => null,
+ 29 => null,
+ 30 => null,
+ 31 => null,
+ 32 => null,
+ 33 => null,
+ 34 => null,
+ 35 => null,
+ 36 => null,
+ 37 => null,
+ 38 => null,
+ 39 => null,
+ 40 => null,
+ 41 => null,
+ 42 => null,
+ 43 => null,
+ 44 => null,
+ 45 => null,
+ 46 => null,
+ 47 => null,
+ 48 => null,
+ 49 => null,
+ 50 => null,
+ 51 => null,
+ 52 => null,
+ 53 => null,
+ 54 => null,
+ 55 => null,
+ 56 => null,
+ 57 => null,
+ 58 => null,
+ 59 => null,
+ 60 => null,
+ 61 => null,
+ 62 => null,
+ 63 => null,
+ 64 => null,
+ 65 => null,
+ 66 => null,
+ 67 => null,
+ 68 => null,
+ 69 => null,
+ 70 => null,
+ 71 => null,
+ 72 => null,
+ 73 => null,
+ 74 => null,
+ 75 => null,
+ 76 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(1-1)]; if ($self->semValue === "emitError(new Error('Cannot use "getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos])));
+ },
+ 77 => null,
+ 78 => null,
+ 79 => null,
+ 80 => null,
+ 81 => null,
+ 82 => null,
+ 83 => null,
+ 84 => null,
+ 85 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Identifier($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 86 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Identifier($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 87 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Identifier($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 88 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Identifier($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 89 => static function ($self, $stackPos) {
+ $self->semValue = new Name($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 90 => static function ($self, $stackPos) {
+ $self->semValue = new Name($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 91 => static function ($self, $stackPos) {
+ $self->semValue = new Name($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 92 => static function ($self, $stackPos) {
+ $self->semValue = new Name($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 93 => static function ($self, $stackPos) {
+ $self->semValue = new Name($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 94 => null,
+ 95 => static function ($self, $stackPos) {
+ $self->semValue = new Name(substr($self->semStack[$stackPos-(1-1)], 1), $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 96 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Variable(substr($self->semStack[$stackPos-(1-1)], 1), $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 97 => static function ($self, $stackPos) {
+ /* nothing */
+ },
+ 98 => static function ($self, $stackPos) {
+ /* nothing */
+ },
+ 99 => static function ($self, $stackPos) {
+ /* nothing */
+ },
+ 100 => static function ($self, $stackPos) {
+ $self->emitError(new Error('A trailing comma is not allowed here', $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos])));
+ },
+ 101 => null,
+ 102 => null,
+ 103 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Attribute($self->semStack[$stackPos-(1-1)], [], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 104 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Attribute($self->semStack[$stackPos-(2-1)], $self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 105 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 106 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 107 => static function ($self, $stackPos) {
+ $self->semValue = new Node\AttributeGroup($self->semStack[$stackPos-(4-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 108 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 109 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(2-1)][] = $self->semStack[$stackPos-(2-2)]; $self->semValue = $self->semStack[$stackPos-(2-1)];
+ },
+ 110 => static function ($self, $stackPos) {
+ $self->semValue = [];
+ },
+ 111 => null,
+ 112 => null,
+ 113 => null,
+ 114 => null,
+ 115 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\HaltCompiler($self->handleHaltCompiler(), $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 116 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Namespace_($self->semStack[$stackPos-(3-2)], null, $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ $self->semValue->setAttribute('kind', Stmt\Namespace_::KIND_SEMICOLON);
+ $self->checkNamespace($self->semValue);
+ },
+ 117 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Namespace_($self->semStack[$stackPos-(5-2)], $self->semStack[$stackPos-(5-4)], $self->getAttributes($self->tokenStartStack[$stackPos-(5-1)], $self->tokenEndStack[$stackPos]));
+ $self->semValue->setAttribute('kind', Stmt\Namespace_::KIND_BRACED);
+ $self->checkNamespace($self->semValue);
+ },
+ 118 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Namespace_(null, $self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ $self->semValue->setAttribute('kind', Stmt\Namespace_::KIND_BRACED);
+ $self->checkNamespace($self->semValue);
+ },
+ 119 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Use_($self->semStack[$stackPos-(3-2)], Stmt\Use_::TYPE_NORMAL, $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 120 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Use_($self->semStack[$stackPos-(4-3)], $self->semStack[$stackPos-(4-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 121 => null,
+ 122 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Const_($self->semStack[$stackPos-(3-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]), []);
+ },
+ 123 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Const_($self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]), $self->semStack[$stackPos-(4-1)]);
+ $self->checkConstantAttributes($self->semValue);
+ },
+ 124 => static function ($self, $stackPos) {
+ $self->semValue = Stmt\Use_::TYPE_FUNCTION;
+ },
+ 125 => static function ($self, $stackPos) {
+ $self->semValue = Stmt\Use_::TYPE_CONSTANT;
+ },
+ 126 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\GroupUse($self->semStack[$stackPos-(8-3)], $self->semStack[$stackPos-(8-6)], $self->semStack[$stackPos-(8-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(8-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 127 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\GroupUse($self->semStack[$stackPos-(7-2)], $self->semStack[$stackPos-(7-5)], Stmt\Use_::TYPE_UNKNOWN, $self->getAttributes($self->tokenStartStack[$stackPos-(7-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 128 => null,
+ 129 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 130 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 131 => null,
+ 132 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 133 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 134 => null,
+ 135 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 136 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 137 => static function ($self, $stackPos) {
+ $self->semValue = new Node\UseItem($self->semStack[$stackPos-(1-1)], null, Stmt\Use_::TYPE_UNKNOWN, $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos])); $self->checkUseUse($self->semValue, $stackPos-(1-1));
+ },
+ 138 => static function ($self, $stackPos) {
+ $self->semValue = new Node\UseItem($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], Stmt\Use_::TYPE_UNKNOWN, $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos])); $self->checkUseUse($self->semValue, $stackPos-(3-3));
+ },
+ 139 => static function ($self, $stackPos) {
+ $self->semValue = new Node\UseItem($self->semStack[$stackPos-(1-1)], null, Stmt\Use_::TYPE_UNKNOWN, $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos])); $self->checkUseUse($self->semValue, $stackPos-(1-1));
+ },
+ 140 => static function ($self, $stackPos) {
+ $self->semValue = new Node\UseItem($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], Stmt\Use_::TYPE_UNKNOWN, $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos])); $self->checkUseUse($self->semValue, $stackPos-(3-3));
+ },
+ 141 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(1-1)]; $self->semValue->type = Stmt\Use_::TYPE_NORMAL;
+ },
+ 142 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(2-2)]; $self->semValue->type = $self->semStack[$stackPos-(2-1)];
+ },
+ 143 => null,
+ 144 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 145 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 146 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Const_($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 147 => null,
+ 148 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 149 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 150 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Const_(new Node\Identifier($self->semStack[$stackPos-(3-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos-(3-1)])), $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 151 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Const_(new Node\Identifier($self->semStack[$stackPos-(3-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos-(3-1)])), $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 152 => static function ($self, $stackPos) {
+ if ($self->semStack[$stackPos-(2-2)] !== null) { $self->semStack[$stackPos-(2-1)][] = $self->semStack[$stackPos-(2-2)]; } $self->semValue = $self->semStack[$stackPos-(2-1)];;
+ },
+ 153 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 154 => static function ($self, $stackPos) {
+ $nop = $self->maybeCreateZeroLengthNop($self->tokenPos);;
+ if ($nop !== null) { $self->semStack[$stackPos-(1-1)][] = $nop; } $self->semValue = $self->semStack[$stackPos-(1-1)];
+ },
+ 155 => null,
+ 156 => null,
+ 157 => null,
+ 158 => static function ($self, $stackPos) {
+ throw new Error('__HALT_COMPILER() can only be used from the outermost scope', $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 159 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Block($self->semStack[$stackPos-(3-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 160 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\If_($self->semStack[$stackPos-(7-3)], ['stmts' => $self->semStack[$stackPos-(7-5)], 'elseifs' => $self->semStack[$stackPos-(7-6)], 'else' => $self->semStack[$stackPos-(7-7)]], $self->getAttributes($self->tokenStartStack[$stackPos-(7-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 161 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\If_($self->semStack[$stackPos-(10-3)], ['stmts' => $self->semStack[$stackPos-(10-6)], 'elseifs' => $self->semStack[$stackPos-(10-7)], 'else' => $self->semStack[$stackPos-(10-8)]], $self->getAttributes($self->tokenStartStack[$stackPos-(10-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 162 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\While_($self->semStack[$stackPos-(5-3)], $self->semStack[$stackPos-(5-5)], $self->getAttributes($self->tokenStartStack[$stackPos-(5-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 163 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Do_($self->semStack[$stackPos-(7-5)], $self->semStack[$stackPos-(7-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(7-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 164 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\For_(['init' => $self->semStack[$stackPos-(9-3)], 'cond' => $self->semStack[$stackPos-(9-5)], 'loop' => $self->semStack[$stackPos-(9-7)], 'stmts' => $self->semStack[$stackPos-(9-9)]], $self->getAttributes($self->tokenStartStack[$stackPos-(9-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 165 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Switch_($self->semStack[$stackPos-(5-3)], $self->semStack[$stackPos-(5-5)], $self->getAttributes($self->tokenStartStack[$stackPos-(5-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 166 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Break_($self->semStack[$stackPos-(3-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 167 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Continue_($self->semStack[$stackPos-(3-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 168 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Return_($self->semStack[$stackPos-(3-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 169 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Global_($self->semStack[$stackPos-(3-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 170 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Static_($self->semStack[$stackPos-(3-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 171 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Echo_($self->semStack[$stackPos-(3-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 172 => static function ($self, $stackPos) {
+
+ $self->semValue = new Stmt\InlineHTML($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ $self->semValue->setAttribute('hasLeadingNewline', $self->inlineHtmlHasLeadingNewline($stackPos-(1-1)));
+
+ },
+ 173 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Expression($self->semStack[$stackPos-(2-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 174 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Unset_($self->semStack[$stackPos-(5-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(5-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 175 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Foreach_($self->semStack[$stackPos-(7-3)], $self->semStack[$stackPos-(7-5)][0], ['keyVar' => null, 'byRef' => $self->semStack[$stackPos-(7-5)][1], 'stmts' => $self->semStack[$stackPos-(7-7)]], $self->getAttributes($self->tokenStartStack[$stackPos-(7-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 176 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Foreach_($self->semStack[$stackPos-(9-3)], $self->semStack[$stackPos-(9-7)][0], ['keyVar' => $self->semStack[$stackPos-(9-5)], 'byRef' => $self->semStack[$stackPos-(9-7)][1], 'stmts' => $self->semStack[$stackPos-(9-9)]], $self->getAttributes($self->tokenStartStack[$stackPos-(9-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 177 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Foreach_($self->semStack[$stackPos-(6-3)], new Expr\Error($self->getAttributes($self->tokenStartStack[$stackPos-(6-4)], $self->tokenEndStack[$stackPos-(6-4)])), ['stmts' => $self->semStack[$stackPos-(6-6)]], $self->getAttributes($self->tokenStartStack[$stackPos-(6-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 178 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Declare_($self->semStack[$stackPos-(5-3)], $self->semStack[$stackPos-(5-5)], $self->getAttributes($self->tokenStartStack[$stackPos-(5-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 179 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\TryCatch($self->semStack[$stackPos-(6-3)], $self->semStack[$stackPos-(6-5)], $self->semStack[$stackPos-(6-6)], $self->getAttributes($self->tokenStartStack[$stackPos-(6-1)], $self->tokenEndStack[$stackPos])); $self->checkTryCatch($self->semValue);
+ },
+ 180 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Goto_($self->semStack[$stackPos-(3-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 181 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Label($self->semStack[$stackPos-(2-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 182 => static function ($self, $stackPos) {
+ $self->semValue = null; /* means: no statement */
+ },
+ 183 => null,
+ 184 => static function ($self, $stackPos) {
+ $self->semValue = $self->maybeCreateNop($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]);
+ },
+ 185 => static function ($self, $stackPos) {
+ if ($self->semStack[$stackPos-(1-1)] instanceof Stmt\Block) { $self->semValue = $self->semStack[$stackPos-(1-1)]->stmts; } else if ($self->semStack[$stackPos-(1-1)] === null) { $self->semValue = []; } else { $self->semValue = [$self->semStack[$stackPos-(1-1)]]; };
+ },
+ 186 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 187 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(2-1)][] = $self->semStack[$stackPos-(2-2)]; $self->semValue = $self->semStack[$stackPos-(2-1)];
+ },
+ 188 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 189 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 190 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Catch_($self->semStack[$stackPos-(8-3)], $self->semStack[$stackPos-(8-4)], $self->semStack[$stackPos-(8-7)], $self->getAttributes($self->tokenStartStack[$stackPos-(8-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 191 => static function ($self, $stackPos) {
+ $self->semValue = null;
+ },
+ 192 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Finally_($self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 193 => null,
+ 194 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 195 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 196 => static function ($self, $stackPos) {
+ $self->semValue = false;
+ },
+ 197 => static function ($self, $stackPos) {
+ $self->semValue = true;
+ },
+ 198 => static function ($self, $stackPos) {
+ $self->semValue = false;
+ },
+ 199 => static function ($self, $stackPos) {
+ $self->semValue = true;
+ },
+ 200 => static function ($self, $stackPos) {
+ $self->semValue = false;
+ },
+ 201 => static function ($self, $stackPos) {
+ $self->semValue = true;
+ },
+ 202 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(3-2)];
+ },
+ 203 => static function ($self, $stackPos) {
+ $self->semValue = [];
+ },
+ 204 => null,
+ 205 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Identifier($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 206 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Identifier($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 207 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Identifier($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 208 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Function_($self->semStack[$stackPos-(8-3)], ['byRef' => $self->semStack[$stackPos-(8-2)], 'params' => $self->semStack[$stackPos-(8-5)], 'returnType' => $self->semStack[$stackPos-(8-7)], 'stmts' => $self->semStack[$stackPos-(8-8)], 'attrGroups' => []], $self->getAttributes($self->tokenStartStack[$stackPos-(8-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 209 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Function_($self->semStack[$stackPos-(9-4)], ['byRef' => $self->semStack[$stackPos-(9-3)], 'params' => $self->semStack[$stackPos-(9-6)], 'returnType' => $self->semStack[$stackPos-(9-8)], 'stmts' => $self->semStack[$stackPos-(9-9)], 'attrGroups' => $self->semStack[$stackPos-(9-1)]], $self->getAttributes($self->tokenStartStack[$stackPos-(9-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 210 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Class_($self->semStack[$stackPos-(7-2)], ['type' => $self->semStack[$stackPos-(7-1)], 'extends' => $self->semStack[$stackPos-(7-3)], 'implements' => $self->semStack[$stackPos-(7-4)], 'stmts' => $self->semStack[$stackPos-(7-6)], 'attrGroups' => []], $self->getAttributes($self->tokenStartStack[$stackPos-(7-1)], $self->tokenEndStack[$stackPos]));
+ $self->checkClass($self->semValue, $stackPos-(7-2));
+ },
+ 211 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Class_($self->semStack[$stackPos-(8-3)], ['type' => $self->semStack[$stackPos-(8-2)], 'extends' => $self->semStack[$stackPos-(8-4)], 'implements' => $self->semStack[$stackPos-(8-5)], 'stmts' => $self->semStack[$stackPos-(8-7)], 'attrGroups' => $self->semStack[$stackPos-(8-1)]], $self->getAttributes($self->tokenStartStack[$stackPos-(8-1)], $self->tokenEndStack[$stackPos]));
+ $self->checkClass($self->semValue, $stackPos-(8-3));
+ },
+ 212 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Interface_($self->semStack[$stackPos-(7-3)], ['extends' => $self->semStack[$stackPos-(7-4)], 'stmts' => $self->semStack[$stackPos-(7-6)], 'attrGroups' => $self->semStack[$stackPos-(7-1)]], $self->getAttributes($self->tokenStartStack[$stackPos-(7-1)], $self->tokenEndStack[$stackPos]));
+ $self->checkInterface($self->semValue, $stackPos-(7-3));
+ },
+ 213 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Trait_($self->semStack[$stackPos-(6-3)], ['stmts' => $self->semStack[$stackPos-(6-5)], 'attrGroups' => $self->semStack[$stackPos-(6-1)]], $self->getAttributes($self->tokenStartStack[$stackPos-(6-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 214 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Enum_($self->semStack[$stackPos-(8-3)], ['scalarType' => $self->semStack[$stackPos-(8-4)], 'implements' => $self->semStack[$stackPos-(8-5)], 'stmts' => $self->semStack[$stackPos-(8-7)], 'attrGroups' => $self->semStack[$stackPos-(8-1)]], $self->getAttributes($self->tokenStartStack[$stackPos-(8-1)], $self->tokenEndStack[$stackPos]));
+ $self->checkEnum($self->semValue, $stackPos-(8-3));
+ },
+ 215 => static function ($self, $stackPos) {
+ $self->semValue = null;
+ },
+ 216 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(2-2)];
+ },
+ 217 => static function ($self, $stackPos) {
+ $self->semValue = null;
+ },
+ 218 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(2-2)];
+ },
+ 219 => static function ($self, $stackPos) {
+ $self->semValue = 0;
+ },
+ 220 => null,
+ 221 => null,
+ 222 => static function ($self, $stackPos) {
+ $self->checkClassModifier($self->semStack[$stackPos-(2-1)], $self->semStack[$stackPos-(2-2)], $stackPos-(2-2)); $self->semValue = $self->semStack[$stackPos-(2-1)] | $self->semStack[$stackPos-(2-2)];
+ },
+ 223 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::ABSTRACT;
+ },
+ 224 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::FINAL;
+ },
+ 225 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::READONLY;
+ },
+ 226 => static function ($self, $stackPos) {
+ $self->semValue = null;
+ },
+ 227 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(2-2)];
+ },
+ 228 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 229 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(2-2)];
+ },
+ 230 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 231 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(2-2)];
+ },
+ 232 => null,
+ 233 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 234 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 235 => null,
+ 236 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(4-2)];
+ },
+ 237 => null,
+ 238 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(4-2)];
+ },
+ 239 => static function ($self, $stackPos) {
+ if ($self->semStack[$stackPos-(1-1)] instanceof Stmt\Block) { $self->semValue = $self->semStack[$stackPos-(1-1)]->stmts; } else if ($self->semStack[$stackPos-(1-1)] === null) { $self->semValue = []; } else { $self->semValue = [$self->semStack[$stackPos-(1-1)]]; };
+ },
+ 240 => static function ($self, $stackPos) {
+ $self->semValue = null;
+ },
+ 241 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(4-2)];
+ },
+ 242 => null,
+ 243 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 244 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 245 => static function ($self, $stackPos) {
+ $self->semValue = new Node\DeclareItem($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 246 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(3-2)];
+ },
+ 247 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(4-3)];
+ },
+ 248 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(4-2)];
+ },
+ 249 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(5-3)];
+ },
+ 250 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 251 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(2-1)][] = $self->semStack[$stackPos-(2-2)]; $self->semValue = $self->semStack[$stackPos-(2-1)];
+ },
+ 252 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Case_($self->semStack[$stackPos-(4-2)], $self->semStack[$stackPos-(4-4)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 253 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Case_(null, $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 254 => null,
+ 255 => null,
+ 256 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Match_($self->semStack[$stackPos-(7-3)], $self->semStack[$stackPos-(7-6)], $self->getAttributes($self->tokenStartStack[$stackPos-(7-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 257 => static function ($self, $stackPos) {
+ $self->semValue = [];
+ },
+ 258 => null,
+ 259 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 260 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 261 => static function ($self, $stackPos) {
+ $self->semValue = new Node\MatchArm($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 262 => static function ($self, $stackPos) {
+ $self->semValue = new Node\MatchArm(null, $self->semStack[$stackPos-(4-4)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 263 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(1-1)];
+ },
+ 264 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(4-2)];
+ },
+ 265 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 266 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(2-1)][] = $self->semStack[$stackPos-(2-2)]; $self->semValue = $self->semStack[$stackPos-(2-1)];
+ },
+ 267 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\ElseIf_($self->semStack[$stackPos-(5-3)], $self->semStack[$stackPos-(5-5)], $self->getAttributes($self->tokenStartStack[$stackPos-(5-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 268 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 269 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(2-1)][] = $self->semStack[$stackPos-(2-2)]; $self->semValue = $self->semStack[$stackPos-(2-1)];
+ },
+ 270 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\ElseIf_($self->semStack[$stackPos-(6-3)], $self->semStack[$stackPos-(6-6)], $self->getAttributes($self->tokenStartStack[$stackPos-(6-1)], $self->tokenEndStack[$stackPos])); $self->fixupAlternativeElse($self->semValue);
+ },
+ 271 => static function ($self, $stackPos) {
+ $self->semValue = null;
+ },
+ 272 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Else_($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 273 => static function ($self, $stackPos) {
+ $self->semValue = null;
+ },
+ 274 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Else_($self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos])); $self->fixupAlternativeElse($self->semValue);
+ },
+ 275 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)], false);
+ },
+ 276 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(2-2)], true);
+ },
+ 277 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)], false);
+ },
+ 278 => static function ($self, $stackPos) {
+ $self->semValue = array($self->fixupArrayDestructuring($self->semStack[$stackPos-(1-1)]), false);
+ },
+ 279 => null,
+ 280 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 281 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 282 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 283 => static function ($self, $stackPos) {
+ $self->semValue = 0;
+ },
+ 284 => static function ($self, $stackPos) {
+ $self->checkModifier($self->semStack[$stackPos-(2-1)], $self->semStack[$stackPos-(2-2)], $stackPos-(2-2)); $self->semValue = $self->semStack[$stackPos-(2-1)] | $self->semStack[$stackPos-(2-2)];
+ },
+ 285 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::PUBLIC;
+ },
+ 286 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::PROTECTED;
+ },
+ 287 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::PRIVATE;
+ },
+ 288 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::PUBLIC_SET;
+ },
+ 289 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::PROTECTED_SET;
+ },
+ 290 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::PRIVATE_SET;
+ },
+ 291 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::READONLY;
+ },
+ 292 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::FINAL;
+ },
+ 293 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Param($self->semStack[$stackPos-(7-6)], null, $self->semStack[$stackPos-(7-3)], $self->semStack[$stackPos-(7-4)], $self->semStack[$stackPos-(7-5)], $self->getAttributes($self->tokenStartStack[$stackPos-(7-1)], $self->tokenEndStack[$stackPos]), $self->semStack[$stackPos-(7-2)], $self->semStack[$stackPos-(7-1)], $self->semStack[$stackPos-(7-7)]);
+ $self->checkParam($self->semValue);
+ $self->addPropertyNameToHooks($self->semValue);
+ },
+ 294 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Param($self->semStack[$stackPos-(9-6)], $self->semStack[$stackPos-(9-8)], $self->semStack[$stackPos-(9-3)], $self->semStack[$stackPos-(9-4)], $self->semStack[$stackPos-(9-5)], $self->getAttributes($self->tokenStartStack[$stackPos-(9-1)], $self->tokenEndStack[$stackPos]), $self->semStack[$stackPos-(9-2)], $self->semStack[$stackPos-(9-1)], $self->semStack[$stackPos-(9-9)]);
+ $self->checkParam($self->semValue);
+ $self->addPropertyNameToHooks($self->semValue);
+ },
+ 295 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Param(new Expr\Error($self->getAttributes($self->tokenStartStack[$stackPos-(6-1)], $self->tokenEndStack[$stackPos])), null, $self->semStack[$stackPos-(6-3)], $self->semStack[$stackPos-(6-4)], $self->semStack[$stackPos-(6-5)], $self->getAttributes($self->tokenStartStack[$stackPos-(6-1)], $self->tokenEndStack[$stackPos]), $self->semStack[$stackPos-(6-2)], $self->semStack[$stackPos-(6-1)]);
+ },
+ 296 => null,
+ 297 => static function ($self, $stackPos) {
+ $self->semValue = new Node\NullableType($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 298 => static function ($self, $stackPos) {
+ $self->semValue = new Node\UnionType($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 299 => null,
+ 300 => null,
+ 301 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Name('static', $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 302 => static function ($self, $stackPos) {
+ $self->semValue = $self->handleBuiltinTypes($self->semStack[$stackPos-(1-1)]);
+ },
+ 303 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Identifier('array', $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 304 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Identifier('callable', $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 305 => null,
+ 306 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(3-2)];
+ },
+ 307 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)]);
+ },
+ 308 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 309 => null,
+ 310 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(3-2)];
+ },
+ 311 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)]);
+ },
+ 312 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 313 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)]);
+ },
+ 314 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 315 => static function ($self, $stackPos) {
+ $self->semValue = new Node\IntersectionType($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 316 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)]);
+ },
+ 317 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 318 => static function ($self, $stackPos) {
+ $self->semValue = new Node\IntersectionType($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 319 => null,
+ 320 => static function ($self, $stackPos) {
+ $self->semValue = new Node\NullableType($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 321 => static function ($self, $stackPos) {
+ $self->semValue = new Node\UnionType($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 322 => null,
+ 323 => static function ($self, $stackPos) {
+ $self->semValue = null;
+ },
+ 324 => null,
+ 325 => static function ($self, $stackPos) {
+ $self->semValue = null;
+ },
+ 326 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(2-2)];
+ },
+ 327 => static function ($self, $stackPos) {
+ $self->semValue = null;
+ },
+ 328 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 329 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(4-2)];
+ },
+ 330 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(3-2)]);
+ },
+ 331 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 332 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(4-2)];
+ },
+ 333 => static function ($self, $stackPos) {
+ $self->semValue = array(new Node\Arg($self->semStack[$stackPos-(4-2)], false, false, $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos])));
+ },
+ 334 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(3-2)]);
+ },
+ 335 => static function ($self, $stackPos) {
+ $self->semValue = array(new Node\Arg($self->semStack[$stackPos-(3-1)], false, false, $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos-(3-1)])), $self->semStack[$stackPos-(3-3)]);
+ },
+ 336 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 337 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 338 => static function ($self, $stackPos) {
+ $self->semValue = new Node\VariadicPlaceholder($self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 339 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 340 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 341 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Arg($self->semStack[$stackPos-(2-2)], true, false, $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 342 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Arg($self->semStack[$stackPos-(2-2)], false, true, $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 343 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Arg($self->semStack[$stackPos-(3-3)], false, false, $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]), $self->semStack[$stackPos-(3-1)]);
+ },
+ 344 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Arg($self->semStack[$stackPos-(1-1)], false, false, $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 345 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(1-1)];
+ },
+ 346 => null,
+ 347 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 348 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 349 => null,
+ 350 => null,
+ 351 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 352 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 353 => static function ($self, $stackPos) {
+ $self->semValue = new Node\StaticVar($self->semStack[$stackPos-(1-1)], null, $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 354 => static function ($self, $stackPos) {
+ $self->semValue = new Node\StaticVar($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 355 => static function ($self, $stackPos) {
+ if ($self->semStack[$stackPos-(2-2)] !== null) { $self->semStack[$stackPos-(2-1)][] = $self->semStack[$stackPos-(2-2)]; $self->semValue = $self->semStack[$stackPos-(2-1)]; } else { $self->semValue = $self->semStack[$stackPos-(2-1)]; }
+ },
+ 356 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 357 => static function ($self, $stackPos) {
+ $nop = $self->maybeCreateZeroLengthNop($self->tokenPos);;
+ if ($nop !== null) { $self->semStack[$stackPos-(1-1)][] = $nop; } $self->semValue = $self->semStack[$stackPos-(1-1)];
+ },
+ 358 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Property($self->semStack[$stackPos-(5-2)], $self->semStack[$stackPos-(5-4)], $self->getAttributes($self->tokenStartStack[$stackPos-(5-1)], $self->tokenEndStack[$stackPos]), $self->semStack[$stackPos-(5-3)], $self->semStack[$stackPos-(5-1)]);
+ },
+ 359 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\ClassConst($self->semStack[$stackPos-(5-4)], $self->semStack[$stackPos-(5-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(5-1)], $self->tokenEndStack[$stackPos]), $self->semStack[$stackPos-(5-1)]);
+ $self->checkClassConst($self->semValue, $stackPos-(5-2));
+ },
+ 360 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\ClassConst($self->semStack[$stackPos-(6-5)], $self->semStack[$stackPos-(6-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(6-1)], $self->tokenEndStack[$stackPos]), $self->semStack[$stackPos-(6-1)], $self->semStack[$stackPos-(6-4)]);
+ $self->checkClassConst($self->semValue, $stackPos-(6-2));
+ },
+ 361 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\ClassMethod($self->semStack[$stackPos-(10-5)], ['type' => $self->semStack[$stackPos-(10-2)], 'byRef' => $self->semStack[$stackPos-(10-4)], 'params' => $self->semStack[$stackPos-(10-7)], 'returnType' => $self->semStack[$stackPos-(10-9)], 'stmts' => $self->semStack[$stackPos-(10-10)], 'attrGroups' => $self->semStack[$stackPos-(10-1)]], $self->getAttributes($self->tokenStartStack[$stackPos-(10-1)], $self->tokenEndStack[$stackPos]));
+ $self->checkClassMethod($self->semValue, $stackPos-(10-2));
+ },
+ 362 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\TraitUse($self->semStack[$stackPos-(3-2)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 363 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\EnumCase($self->semStack[$stackPos-(5-3)], $self->semStack[$stackPos-(5-4)], $self->semStack[$stackPos-(5-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(5-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 364 => static function ($self, $stackPos) {
+ $self->semValue = null; /* will be skipped */
+ },
+ 365 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 366 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(3-2)];
+ },
+ 367 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 368 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(2-1)][] = $self->semStack[$stackPos-(2-2)]; $self->semValue = $self->semStack[$stackPos-(2-1)];
+ },
+ 369 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\TraitUseAdaptation\Precedence($self->semStack[$stackPos-(4-1)][0], $self->semStack[$stackPos-(4-1)][1], $self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 370 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\TraitUseAdaptation\Alias($self->semStack[$stackPos-(5-1)][0], $self->semStack[$stackPos-(5-1)][1], $self->semStack[$stackPos-(5-3)], $self->semStack[$stackPos-(5-4)], $self->getAttributes($self->tokenStartStack[$stackPos-(5-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 371 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\TraitUseAdaptation\Alias($self->semStack[$stackPos-(4-1)][0], $self->semStack[$stackPos-(4-1)][1], $self->semStack[$stackPos-(4-3)], null, $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 372 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\TraitUseAdaptation\Alias($self->semStack[$stackPos-(4-1)][0], $self->semStack[$stackPos-(4-1)][1], null, $self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 373 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\TraitUseAdaptation\Alias($self->semStack[$stackPos-(4-1)][0], $self->semStack[$stackPos-(4-1)][1], null, $self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 374 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)]);
+ },
+ 375 => null,
+ 376 => static function ($self, $stackPos) {
+ $self->semValue = array(null, $self->semStack[$stackPos-(1-1)]);
+ },
+ 377 => static function ($self, $stackPos) {
+ $self->semValue = null;
+ },
+ 378 => null,
+ 379 => null,
+ 380 => static function ($self, $stackPos) {
+ $self->semValue = 0;
+ },
+ 381 => static function ($self, $stackPos) {
+ $self->semValue = 0;
+ },
+ 382 => null,
+ 383 => null,
+ 384 => static function ($self, $stackPos) {
+ $self->checkModifier($self->semStack[$stackPos-(2-1)], $self->semStack[$stackPos-(2-2)], $stackPos-(2-2)); $self->semValue = $self->semStack[$stackPos-(2-1)] | $self->semStack[$stackPos-(2-2)];
+ },
+ 385 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::PUBLIC;
+ },
+ 386 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::PROTECTED;
+ },
+ 387 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::PRIVATE;
+ },
+ 388 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::PUBLIC_SET;
+ },
+ 389 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::PROTECTED_SET;
+ },
+ 390 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::PRIVATE_SET;
+ },
+ 391 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::STATIC;
+ },
+ 392 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::ABSTRACT;
+ },
+ 393 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::FINAL;
+ },
+ 394 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::READONLY;
+ },
+ 395 => null,
+ 396 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 397 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 398 => static function ($self, $stackPos) {
+ $self->semValue = new Node\VarLikeIdentifier(substr($self->semStack[$stackPos-(1-1)], 1), $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 399 => static function ($self, $stackPos) {
+ $self->semValue = new Node\PropertyItem($self->semStack[$stackPos-(1-1)], null, $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 400 => static function ($self, $stackPos) {
+ $self->semValue = new Node\PropertyItem($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 401 => static function ($self, $stackPos) {
+ $self->semValue = [];
+ },
+ 402 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(2-1)][] = $self->semStack[$stackPos-(2-2)]; $self->semValue = $self->semStack[$stackPos-(2-1)];
+ },
+ 403 => static function ($self, $stackPos) {
+ $self->semValue = [];
+ },
+ 404 => static function ($self, $stackPos) {
+ $self->semValue = new Node\PropertyHook($self->semStack[$stackPos-(5-4)], $self->semStack[$stackPos-(5-5)], ['flags' => $self->semStack[$stackPos-(5-2)], 'byRef' => $self->semStack[$stackPos-(5-3)], 'params' => [], 'attrGroups' => $self->semStack[$stackPos-(5-1)]], $self->getAttributes($self->tokenStartStack[$stackPos-(5-1)], $self->tokenEndStack[$stackPos]));
+ $self->checkPropertyHook($self->semValue, null);
+ },
+ 405 => static function ($self, $stackPos) {
+ $self->semValue = new Node\PropertyHook($self->semStack[$stackPos-(8-4)], $self->semStack[$stackPos-(8-8)], ['flags' => $self->semStack[$stackPos-(8-2)], 'byRef' => $self->semStack[$stackPos-(8-3)], 'params' => $self->semStack[$stackPos-(8-6)], 'attrGroups' => $self->semStack[$stackPos-(8-1)]], $self->getAttributes($self->tokenStartStack[$stackPos-(8-1)], $self->tokenEndStack[$stackPos]));
+ $self->checkPropertyHook($self->semValue, $stackPos-(8-5));
+ },
+ 406 => static function ($self, $stackPos) {
+ $self->semValue = null;
+ },
+ 407 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(3-2)];
+ },
+ 408 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(3-2)];
+ },
+ 409 => static function ($self, $stackPos) {
+ $self->semValue = 0;
+ },
+ 410 => static function ($self, $stackPos) {
+ $self->checkPropertyHookModifiers($self->semStack[$stackPos-(2-1)], $self->semStack[$stackPos-(2-2)], $stackPos-(2-2)); $self->semValue = $self->semStack[$stackPos-(2-1)] | $self->semStack[$stackPos-(2-2)];
+ },
+ 411 => null,
+ 412 => null,
+ 413 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 414 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 415 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 416 => null,
+ 417 => null,
+ 418 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Assign($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 419 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Assign($self->fixupArrayDestructuring($self->semStack[$stackPos-(3-1)]), $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 420 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Assign($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 421 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignRef($self->semStack[$stackPos-(4-1)], $self->semStack[$stackPos-(4-4)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 422 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignRef($self->semStack[$stackPos-(4-1)], $self->semStack[$stackPos-(4-4)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ if (!$self->phpVersion->allowsAssignNewByReference()) {
+ $self->emitError(new Error('Cannot assign new by reference', $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos])));
+ }
+
+ },
+ 423 => null,
+ 424 => null,
+ 425 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\FuncCall(new Node\Name($self->semStack[$stackPos-(2-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos-(2-1)])), $self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 426 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Clone_($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 427 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignOp\Plus($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 428 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignOp\Minus($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 429 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignOp\Mul($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 430 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignOp\Div($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 431 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignOp\Concat($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 432 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignOp\Mod($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 433 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignOp\BitwiseAnd($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 434 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignOp\BitwiseOr($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 435 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignOp\BitwiseXor($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 436 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignOp\ShiftLeft($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 437 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignOp\ShiftRight($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 438 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignOp\Pow($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 439 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignOp\Coalesce($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 440 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\PostInc($self->semStack[$stackPos-(2-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 441 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\PreInc($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 442 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\PostDec($self->semStack[$stackPos-(2-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 443 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\PreDec($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 444 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\BooleanOr($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 445 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\BooleanAnd($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 446 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\LogicalOr($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 447 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\LogicalAnd($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 448 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\LogicalXor($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 449 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\BitwiseOr($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 450 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\BitwiseAnd($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 451 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\BitwiseAnd($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 452 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\BitwiseXor($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 453 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\Concat($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 454 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\Plus($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 455 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\Minus($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 456 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\Mul($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 457 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\Div($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 458 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\Mod($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 459 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\ShiftLeft($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 460 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\ShiftRight($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 461 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\Pow($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 462 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\UnaryPlus($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 463 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\UnaryMinus($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 464 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BooleanNot($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 465 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BitwiseNot($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 466 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\Identical($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 467 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\NotIdentical($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 468 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\Equal($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 469 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\NotEqual($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 470 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\Spaceship($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 471 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\Smaller($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 472 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\SmallerOrEqual($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 473 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\Greater($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 474 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\GreaterOrEqual($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 475 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Instanceof_($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 476 => static function ($self, $stackPos) {
+
+ $self->semValue = $self->semStack[$stackPos-(3-2)];
+ if ($self->semValue instanceof Expr\ArrowFunction) {
+ $self->parenthesizedArrowFunctions->offsetSet($self->semValue);
+ }
+
+ },
+ 477 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Ternary($self->semStack[$stackPos-(5-1)], $self->semStack[$stackPos-(5-3)], $self->semStack[$stackPos-(5-5)], $self->getAttributes($self->tokenStartStack[$stackPos-(5-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 478 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Ternary($self->semStack[$stackPos-(4-1)], null, $self->semStack[$stackPos-(4-4)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 479 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\Coalesce($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 480 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Isset_($self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 481 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Empty_($self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 482 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Include_($self->semStack[$stackPos-(2-2)], Expr\Include_::TYPE_INCLUDE, $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 483 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Include_($self->semStack[$stackPos-(2-2)], Expr\Include_::TYPE_INCLUDE_ONCE, $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 484 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Eval_($self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 485 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Include_($self->semStack[$stackPos-(2-2)], Expr\Include_::TYPE_REQUIRE, $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 486 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Include_($self->semStack[$stackPos-(2-2)], Expr\Include_::TYPE_REQUIRE_ONCE, $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 487 => static function ($self, $stackPos) {
+ $attrs = $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]);
+ $attrs['kind'] = $self->getIntCastKind($self->semStack[$stackPos-(2-1)]);
+ $self->semValue = new Expr\Cast\Int_($self->semStack[$stackPos-(2-2)], $attrs);
+ },
+ 488 => static function ($self, $stackPos) {
+ $attrs = $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]);
+ $attrs['kind'] = $self->getFloatCastKind($self->semStack[$stackPos-(2-1)]);
+ $self->semValue = new Expr\Cast\Double($self->semStack[$stackPos-(2-2)], $attrs);
+ },
+ 489 => static function ($self, $stackPos) {
+ $attrs = $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]);
+ $attrs['kind'] = $self->getStringCastKind($self->semStack[$stackPos-(2-1)]);
+ $self->semValue = new Expr\Cast\String_($self->semStack[$stackPos-(2-2)], $attrs);
+ },
+ 490 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Cast\Array_($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 491 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Cast\Object_($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 492 => static function ($self, $stackPos) {
+ $attrs = $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]);
+ $attrs['kind'] = $self->getBoolCastKind($self->semStack[$stackPos-(2-1)]);
+ $self->semValue = new Expr\Cast\Bool_($self->semStack[$stackPos-(2-2)], $attrs);
+ },
+ 493 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Cast\Unset_($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 494 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Cast\Void_($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 495 => static function ($self, $stackPos) {
+ $self->semValue = $self->createExitExpr($self->semStack[$stackPos-(2-1)], $stackPos-(2-1), $self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 496 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ErrorSuppress($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 497 => null,
+ 498 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ShellExec($self->semStack[$stackPos-(3-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 499 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Print_($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 500 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Yield_(null, null, $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 501 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Yield_($self->semStack[$stackPos-(2-2)], null, $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 502 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Yield_($self->semStack[$stackPos-(4-4)], $self->semStack[$stackPos-(4-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 503 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\YieldFrom($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 504 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Throw_($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 505 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ArrowFunction(['static' => false, 'byRef' => $self->semStack[$stackPos-(8-2)], 'params' => $self->semStack[$stackPos-(8-4)], 'returnType' => $self->semStack[$stackPos-(8-6)], 'expr' => $self->semStack[$stackPos-(8-8)], 'attrGroups' => []], $self->getAttributes($self->tokenStartStack[$stackPos-(8-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 506 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ArrowFunction(['static' => true, 'byRef' => $self->semStack[$stackPos-(9-3)], 'params' => $self->semStack[$stackPos-(9-5)], 'returnType' => $self->semStack[$stackPos-(9-7)], 'expr' => $self->semStack[$stackPos-(9-9)], 'attrGroups' => []], $self->getAttributes($self->tokenStartStack[$stackPos-(9-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 507 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Closure(['static' => false, 'byRef' => $self->semStack[$stackPos-(8-2)], 'params' => $self->semStack[$stackPos-(8-4)], 'uses' => $self->semStack[$stackPos-(8-6)], 'returnType' => $self->semStack[$stackPos-(8-7)], 'stmts' => $self->semStack[$stackPos-(8-8)], 'attrGroups' => []], $self->getAttributes($self->tokenStartStack[$stackPos-(8-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 508 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Closure(['static' => true, 'byRef' => $self->semStack[$stackPos-(9-3)], 'params' => $self->semStack[$stackPos-(9-5)], 'uses' => $self->semStack[$stackPos-(9-7)], 'returnType' => $self->semStack[$stackPos-(9-8)], 'stmts' => $self->semStack[$stackPos-(9-9)], 'attrGroups' => []], $self->getAttributes($self->tokenStartStack[$stackPos-(9-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 509 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ArrowFunction(['static' => false, 'byRef' => $self->semStack[$stackPos-(9-3)], 'params' => $self->semStack[$stackPos-(9-5)], 'returnType' => $self->semStack[$stackPos-(9-7)], 'expr' => $self->semStack[$stackPos-(9-9)], 'attrGroups' => $self->semStack[$stackPos-(9-1)]], $self->getAttributes($self->tokenStartStack[$stackPos-(9-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 510 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ArrowFunction(['static' => true, 'byRef' => $self->semStack[$stackPos-(10-4)], 'params' => $self->semStack[$stackPos-(10-6)], 'returnType' => $self->semStack[$stackPos-(10-8)], 'expr' => $self->semStack[$stackPos-(10-10)], 'attrGroups' => $self->semStack[$stackPos-(10-1)]], $self->getAttributes($self->tokenStartStack[$stackPos-(10-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 511 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Closure(['static' => false, 'byRef' => $self->semStack[$stackPos-(9-3)], 'params' => $self->semStack[$stackPos-(9-5)], 'uses' => $self->semStack[$stackPos-(9-7)], 'returnType' => $self->semStack[$stackPos-(9-8)], 'stmts' => $self->semStack[$stackPos-(9-9)], 'attrGroups' => $self->semStack[$stackPos-(9-1)]], $self->getAttributes($self->tokenStartStack[$stackPos-(9-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 512 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Closure(['static' => true, 'byRef' => $self->semStack[$stackPos-(10-4)], 'params' => $self->semStack[$stackPos-(10-6)], 'uses' => $self->semStack[$stackPos-(10-8)], 'returnType' => $self->semStack[$stackPos-(10-9)], 'stmts' => $self->semStack[$stackPos-(10-10)], 'attrGroups' => $self->semStack[$stackPos-(10-1)]], $self->getAttributes($self->tokenStartStack[$stackPos-(10-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 513 => static function ($self, $stackPos) {
+ $self->semValue = array(new Stmt\Class_(null, ['type' => $self->semStack[$stackPos-(8-2)], 'extends' => $self->semStack[$stackPos-(8-4)], 'implements' => $self->semStack[$stackPos-(8-5)], 'stmts' => $self->semStack[$stackPos-(8-7)], 'attrGroups' => $self->semStack[$stackPos-(8-1)]], $self->getAttributes($self->tokenStartStack[$stackPos-(8-1)], $self->tokenEndStack[$stackPos])), $self->semStack[$stackPos-(8-3)]);
+ $self->checkClass($self->semValue[0], -1);
+ },
+ 514 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\New_($self->semStack[$stackPos-(3-2)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 515 => static function ($self, $stackPos) {
+ list($class, $ctorArgs) = $self->semStack[$stackPos-(2-2)]; $self->semValue = new Expr\New_($class, $ctorArgs, $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 516 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\New_($self->semStack[$stackPos-(2-2)], [], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 517 => null,
+ 518 => null,
+ 519 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 520 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(4-3)];
+ },
+ 521 => null,
+ 522 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 523 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 524 => static function ($self, $stackPos) {
+ $self->semValue = new Node\ClosureUse($self->semStack[$stackPos-(2-2)], $self->semStack[$stackPos-(2-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 525 => static function ($self, $stackPos) {
+ $self->semValue = new Name($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 526 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\FuncCall($self->semStack[$stackPos-(2-1)], $self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 527 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\FuncCall($self->semStack[$stackPos-(2-1)], $self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 528 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\FuncCall($self->semStack[$stackPos-(2-1)], $self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 529 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\StaticCall($self->semStack[$stackPos-(4-1)], $self->semStack[$stackPos-(4-3)], $self->semStack[$stackPos-(4-4)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 530 => static function ($self, $stackPos) {
+ $self->semValue = new Name($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 531 => null,
+ 532 => static function ($self, $stackPos) {
+ $self->semValue = new Name($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 533 => static function ($self, $stackPos) {
+ $self->semValue = new Name($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 534 => static function ($self, $stackPos) {
+ $self->semValue = new Name\FullyQualified(substr($self->semStack[$stackPos-(1-1)], 1), $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 535 => static function ($self, $stackPos) {
+ $self->semValue = new Name\Relative(substr($self->semStack[$stackPos-(1-1)], 10), $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 536 => null,
+ 537 => null,
+ 538 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(3-2)];
+ },
+ 539 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Error($self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos])); $self->errorState = 2;
+ },
+ 540 => null,
+ 541 => null,
+ 542 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 543 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]); foreach ($self->semValue as $s) { if ($s instanceof Node\InterpolatedStringPart) { $s->value = Node\Scalar\String_::parseEscapeSequences($s->value, '`', $self->phpVersion->supportsUnicodeEscapes()); } };
+ },
+ 544 => static function ($self, $stackPos) {
+ foreach ($self->semStack[$stackPos-(1-1)] as $s) { if ($s instanceof Node\InterpolatedStringPart) { $s->value = Node\Scalar\String_::parseEscapeSequences($s->value, '`', $self->phpVersion->supportsUnicodeEscapes()); } }; $self->semValue = $self->semStack[$stackPos-(1-1)];
+ },
+ 545 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 546 => null,
+ 547 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ConstFetch($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 548 => static function ($self, $stackPos) {
+ $self->semValue = new Scalar\MagicConst\Line($self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 549 => static function ($self, $stackPos) {
+ $self->semValue = new Scalar\MagicConst\File($self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 550 => static function ($self, $stackPos) {
+ $self->semValue = new Scalar\MagicConst\Dir($self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 551 => static function ($self, $stackPos) {
+ $self->semValue = new Scalar\MagicConst\Class_($self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 552 => static function ($self, $stackPos) {
+ $self->semValue = new Scalar\MagicConst\Trait_($self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 553 => static function ($self, $stackPos) {
+ $self->semValue = new Scalar\MagicConst\Method($self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 554 => static function ($self, $stackPos) {
+ $self->semValue = new Scalar\MagicConst\Function_($self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 555 => static function ($self, $stackPos) {
+ $self->semValue = new Scalar\MagicConst\Namespace_($self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 556 => static function ($self, $stackPos) {
+ $self->semValue = new Scalar\MagicConst\Property($self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 557 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ClassConstFetch($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 558 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ClassConstFetch($self->semStack[$stackPos-(5-1)], $self->semStack[$stackPos-(5-4)], $self->getAttributes($self->tokenStartStack[$stackPos-(5-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 559 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ClassConstFetch($self->semStack[$stackPos-(3-1)], new Expr\Error($self->getAttributes($self->tokenStartStack[$stackPos-(3-3)], $self->tokenEndStack[$stackPos-(3-3)])), $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos])); $self->errorState = 2;
+ },
+ 560 => static function ($self, $stackPos) {
+ $attrs = $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]); $attrs['kind'] = Expr\Array_::KIND_SHORT;
+ $self->semValue = new Expr\Array_($self->semStack[$stackPos-(3-2)], $attrs);
+ },
+ 561 => static function ($self, $stackPos) {
+ $attrs = $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]); $attrs['kind'] = Expr\Array_::KIND_LONG;
+ $self->semValue = new Expr\Array_($self->semStack[$stackPos-(4-3)], $attrs);
+ $self->createdArrays->offsetSet($self->semValue);
+ },
+ 562 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(1-1)]; $self->createdArrays->offsetSet($self->semValue);
+ },
+ 563 => static function ($self, $stackPos) {
+ $self->semValue = Scalar\String_::fromString($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]), $self->phpVersion->supportsUnicodeEscapes());
+ },
+ 564 => static function ($self, $stackPos) {
+ $attrs = $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]); $attrs['kind'] = Scalar\String_::KIND_DOUBLE_QUOTED;
+ foreach ($self->semStack[$stackPos-(3-2)] as $s) { if ($s instanceof Node\InterpolatedStringPart) { $s->value = Node\Scalar\String_::parseEscapeSequences($s->value, '"', $self->phpVersion->supportsUnicodeEscapes()); } }; $self->semValue = new Scalar\InterpolatedString($self->semStack[$stackPos-(3-2)], $attrs);
+ },
+ 565 => static function ($self, $stackPos) {
+ $self->semValue = $self->parseLNumber($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]), $self->phpVersion->allowsInvalidOctals());
+ },
+ 566 => static function ($self, $stackPos) {
+ $self->semValue = Scalar\Float_::fromString($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 567 => null,
+ 568 => null,
+ 569 => null,
+ 570 => static function ($self, $stackPos) {
+ $self->semValue = $self->parseDocString($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-2)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]), $self->getAttributes($self->tokenStartStack[$stackPos-(3-3)], $self->tokenEndStack[$stackPos-(3-3)]), true);
+ },
+ 571 => static function ($self, $stackPos) {
+ $self->semValue = $self->parseDocString($self->semStack[$stackPos-(2-1)], '', $self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]), $self->getAttributes($self->tokenStartStack[$stackPos-(2-2)], $self->tokenEndStack[$stackPos-(2-2)]), true);
+ },
+ 572 => static function ($self, $stackPos) {
+ $self->semValue = $self->parseDocString($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-2)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]), $self->getAttributes($self->tokenStartStack[$stackPos-(3-3)], $self->tokenEndStack[$stackPos-(3-3)]), true);
+ },
+ 573 => static function ($self, $stackPos) {
+ $self->semValue = null;
+ },
+ 574 => null,
+ 575 => null,
+ 576 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(3-2)];
+ },
+ 577 => null,
+ 578 => null,
+ 579 => null,
+ 580 => null,
+ 581 => null,
+ 582 => null,
+ 583 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(3-2)];
+ },
+ 584 => null,
+ 585 => null,
+ 586 => null,
+ 587 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ArrayDimFetch($self->semStack[$stackPos-(4-1)], $self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 588 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ArrayDimFetch($self->semStack[$stackPos-(4-1)], $self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 589 => null,
+ 590 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\MethodCall($self->semStack[$stackPos-(4-1)], $self->semStack[$stackPos-(4-3)], $self->semStack[$stackPos-(4-4)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 591 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\NullsafeMethodCall($self->semStack[$stackPos-(4-1)], $self->semStack[$stackPos-(4-3)], $self->semStack[$stackPos-(4-4)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 592 => static function ($self, $stackPos) {
+ $self->semValue = null;
+ },
+ 593 => null,
+ 594 => null,
+ 595 => null,
+ 596 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\PropertyFetch($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 597 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\NullsafePropertyFetch($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 598 => null,
+ 599 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Variable($self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 600 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Variable($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 601 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Variable(new Expr\Error($self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos])), $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos])); $self->errorState = 2;
+ },
+ 602 => static function ($self, $stackPos) {
+ $var = $self->semStack[$stackPos-(1-1)]->name; $self->semValue = \is_string($var) ? new Node\VarLikeIdentifier($var, $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos])) : $var;
+ },
+ 603 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\StaticPropertyFetch($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 604 => null,
+ 605 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ArrayDimFetch($self->semStack[$stackPos-(4-1)], $self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 606 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ArrayDimFetch($self->semStack[$stackPos-(4-1)], $self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 607 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\PropertyFetch($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 608 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\NullsafePropertyFetch($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 609 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\StaticPropertyFetch($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 610 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\StaticPropertyFetch($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 611 => null,
+ 612 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(3-2)];
+ },
+ 613 => null,
+ 614 => null,
+ 615 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(3-2)];
+ },
+ 616 => null,
+ 617 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Error($self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos])); $self->errorState = 2;
+ },
+ 618 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\List_($self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos])); $self->semValue->setAttribute('kind', Expr\List_::KIND_LIST);
+ $self->postprocessList($self->semValue);
+ },
+ 619 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(1-1)]; $end = count($self->semValue)-1; if ($self->semValue[$end]->value instanceof Expr\Error) array_pop($self->semValue);
+ },
+ 620 => null,
+ 621 => static function ($self, $stackPos) {
+ /* do nothing -- prevent default action of $$=$self->semStack[$1]. See $551. */
+ },
+ 622 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 623 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 624 => static function ($self, $stackPos) {
+ $self->semValue = new Node\ArrayItem($self->semStack[$stackPos-(1-1)], null, false, $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 625 => static function ($self, $stackPos) {
+ $self->semValue = new Node\ArrayItem($self->semStack[$stackPos-(2-2)], null, true, $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 626 => static function ($self, $stackPos) {
+ $self->semValue = new Node\ArrayItem($self->semStack[$stackPos-(1-1)], null, false, $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 627 => static function ($self, $stackPos) {
+ $self->semValue = new Node\ArrayItem($self->semStack[$stackPos-(3-3)], $self->semStack[$stackPos-(3-1)], false, $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 628 => static function ($self, $stackPos) {
+ $self->semValue = new Node\ArrayItem($self->semStack[$stackPos-(4-4)], $self->semStack[$stackPos-(4-1)], true, $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 629 => static function ($self, $stackPos) {
+ $self->semValue = new Node\ArrayItem($self->semStack[$stackPos-(3-3)], $self->semStack[$stackPos-(3-1)], false, $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 630 => static function ($self, $stackPos) {
+ $self->semValue = new Node\ArrayItem($self->semStack[$stackPos-(2-2)], null, false, $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]), true);
+ },
+ 631 => static function ($self, $stackPos) {
+ /* Create an Error node now to remember the position. We'll later either report an error,
+ or convert this into a null element, depending on whether this is a creation or destructuring context. */
+ $attrs = $self->createEmptyElemAttributes($self->tokenPos);
+ $self->semValue = new Node\ArrayItem(new Expr\Error($attrs), null, false, $attrs);
+ },
+ 632 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(2-1)][] = $self->semStack[$stackPos-(2-2)]; $self->semValue = $self->semStack[$stackPos-(2-1)];
+ },
+ 633 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(2-1)][] = $self->semStack[$stackPos-(2-2)]; $self->semValue = $self->semStack[$stackPos-(2-1)];
+ },
+ 634 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 635 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(2-1)], $self->semStack[$stackPos-(2-2)]);
+ },
+ 636 => static function ($self, $stackPos) {
+ $attrs = $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]); $attrs['rawValue'] = $self->semStack[$stackPos-(1-1)]; $self->semValue = new Node\InterpolatedStringPart($self->semStack[$stackPos-(1-1)], $attrs);
+ },
+ 637 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Variable($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 638 => null,
+ 639 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ArrayDimFetch($self->semStack[$stackPos-(4-1)], $self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 640 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\PropertyFetch($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 641 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\NullsafePropertyFetch($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 642 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Variable($self->semStack[$stackPos-(3-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 643 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Variable($self->semStack[$stackPos-(3-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 644 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ArrayDimFetch($self->semStack[$stackPos-(6-2)], $self->semStack[$stackPos-(6-4)], $self->getAttributes($self->tokenStartStack[$stackPos-(6-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 645 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(3-2)];
+ },
+ 646 => static function ($self, $stackPos) {
+ $self->semValue = new Scalar\String_($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 647 => static function ($self, $stackPos) {
+ $self->semValue = $self->parseNumString($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 648 => static function ($self, $stackPos) {
+ $self->semValue = $self->parseNumString('-' . $self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 649 => null,
+ ];
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/Parser/Php8.php b/vendor/nikic/php-parser/lib/PhpParser/Parser/Php8.php
new file mode 100644
index 0000000..aed45d7
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/Parser/Php8.php
@@ -0,0 +1,2917 @@
+'",
+ "T_IS_GREATER_OR_EQUAL",
+ "T_PIPE",
+ "'.'",
+ "T_SL",
+ "T_SR",
+ "'+'",
+ "'-'",
+ "'*'",
+ "'/'",
+ "'%'",
+ "'!'",
+ "T_INSTANCEOF",
+ "'~'",
+ "T_INC",
+ "T_DEC",
+ "T_INT_CAST",
+ "T_DOUBLE_CAST",
+ "T_STRING_CAST",
+ "T_ARRAY_CAST",
+ "T_OBJECT_CAST",
+ "T_BOOL_CAST",
+ "T_UNSET_CAST",
+ "'@'",
+ "T_POW",
+ "'['",
+ "T_NEW",
+ "T_CLONE",
+ "T_EXIT",
+ "T_IF",
+ "T_ELSEIF",
+ "T_ELSE",
+ "T_ENDIF",
+ "T_LNUMBER",
+ "T_DNUMBER",
+ "T_STRING",
+ "T_STRING_VARNAME",
+ "T_VARIABLE",
+ "T_NUM_STRING",
+ "T_INLINE_HTML",
+ "T_ENCAPSED_AND_WHITESPACE",
+ "T_CONSTANT_ENCAPSED_STRING",
+ "T_ECHO",
+ "T_DO",
+ "T_WHILE",
+ "T_ENDWHILE",
+ "T_FOR",
+ "T_ENDFOR",
+ "T_FOREACH",
+ "T_ENDFOREACH",
+ "T_DECLARE",
+ "T_ENDDECLARE",
+ "T_AS",
+ "T_SWITCH",
+ "T_MATCH",
+ "T_ENDSWITCH",
+ "T_CASE",
+ "T_DEFAULT",
+ "T_BREAK",
+ "T_CONTINUE",
+ "T_GOTO",
+ "T_FUNCTION",
+ "T_FN",
+ "T_CONST",
+ "T_RETURN",
+ "T_TRY",
+ "T_CATCH",
+ "T_FINALLY",
+ "T_USE",
+ "T_INSTEADOF",
+ "T_GLOBAL",
+ "T_STATIC",
+ "T_ABSTRACT",
+ "T_FINAL",
+ "T_PRIVATE",
+ "T_PROTECTED",
+ "T_PUBLIC",
+ "T_READONLY",
+ "T_PUBLIC_SET",
+ "T_PROTECTED_SET",
+ "T_PRIVATE_SET",
+ "T_VAR",
+ "T_UNSET",
+ "T_ISSET",
+ "T_EMPTY",
+ "T_HALT_COMPILER",
+ "T_CLASS",
+ "T_TRAIT",
+ "T_INTERFACE",
+ "T_ENUM",
+ "T_EXTENDS",
+ "T_IMPLEMENTS",
+ "T_OBJECT_OPERATOR",
+ "T_NULLSAFE_OBJECT_OPERATOR",
+ "T_LIST",
+ "T_ARRAY",
+ "T_CALLABLE",
+ "T_CLASS_C",
+ "T_TRAIT_C",
+ "T_METHOD_C",
+ "T_FUNC_C",
+ "T_PROPERTY_C",
+ "T_LINE",
+ "T_FILE",
+ "T_START_HEREDOC",
+ "T_END_HEREDOC",
+ "T_DOLLAR_OPEN_CURLY_BRACES",
+ "T_CURLY_OPEN",
+ "T_PAAMAYIM_NEKUDOTAYIM",
+ "T_NAMESPACE",
+ "T_NS_C",
+ "T_DIR",
+ "T_NS_SEPARATOR",
+ "T_ELLIPSIS",
+ "T_NAME_FULLY_QUALIFIED",
+ "T_NAME_QUALIFIED",
+ "T_NAME_RELATIVE",
+ "T_ATTRIBUTE",
+ "';'",
+ "']'",
+ "'('",
+ "')'",
+ "'{'",
+ "'}'",
+ "'`'",
+ "'\"'",
+ "'$'"
+ );
+
+ protected array $tokenToSymbol = array(
+ 0, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 58, 172, 174, 173, 57, 174, 174,
+ 167, 168, 55, 53, 9, 54, 50, 56, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 32, 165,
+ 45, 17, 47, 31, 70, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 72, 174, 166, 37, 174, 171, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 169, 36, 170, 60, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 1, 2, 3, 4,
+ 5, 6, 7, 8, 10, 11, 12, 13, 14, 15,
+ 16, 18, 19, 20, 21, 22, 23, 24, 25, 26,
+ 27, 28, 29, 30, 33, 34, 35, 38, 39, 40,
+ 41, 42, 43, 44, 46, 48, 49, 51, 52, 59,
+ 61, 62, 63, 64, 65, 66, 67, 68, 69, 71,
+ 73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
+ 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
+ 93, 94, 95, 96, 97, 98, 99, 100, 101, 102,
+ 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
+ 113, 114, 115, 116, 117, 118, 119, 120, 121, 122,
+ 123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
+ 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
+ 143, 144, 145, 146, 147, 148, 149, 150, 151, 152,
+ 153, 154, 155, 156, 157, 158, 159, 160, 161, 162,
+ 163, 164
+ );
+
+ protected array $action = array(
+ 132, 133, 134, 582, 135, 136, 162, 779, 780, 781,
+ 137, 41, 863,-32766, 970, 1404, -584, 974, 973, 1302,
+ 0, 395, 396, 455, 246, 854,-32766,-32766,-32766,-32766,
+ -32766, 440,-32766, 27,-32766, 773, 772,-32766,-32766,-32766,
+ -32766, 508,-32766,-32766,-32766,-32766,-32766,-32766,-32766,-32766,
+ 131,-32766,-32766,-32766,-32766, 437, 782, 859, 1148,-32766,
+ 949,-32766,-32766,-32766,-32766,-32766,-32766, 972, 1385, 300,
+ 271, 53, 398, 786, 787, 788, 789, 305, 865, 441,
+ -341, 39, 254, -584, -584, -195, 843, 790, 791, 792,
+ 793, 794, 795, 796, 797, 798, 799, 819, 583, 820,
+ 821, 822, 823, 811, 812, 353, 354, 814, 815, 800,
+ 801, 802, 804, 805, 806, 368, 846, 847, 848, 849,
+ 850, 584, 1062, -194, 856, 807, 808, 585, 586, 3,
+ 831, 829, 830, 842, 826, 827, 4, 860, 587, 588,
+ 825, 589, 590, 591, 592, 939, 593, 594, 5, 854,
+ -32766,-32766,-32766, 828, 595, 596,-32766, 138, 764, 132,
+ 133, 134, 582, 135, 136, 1098, 779, 780, 781, 137,
+ 41,-32766,-32766,-32766,-32766,-32766,-32766, -275, 1302, 613,
+ 153, 1071, 749, 990, 991,-32766,-32766,-32766, 992,-32766,
+ 891,-32766, 892,-32766, 773, 772,-32766, 986, 1309, 397,
+ 396,-32766,-32766,-32766, 858, 299, 630,-32766,-32766, 440,
+ 502, 736,-32766,-32766, 437, 782,-32767,-32767,-32767,-32767,
+ 106, 107, 108, 109, 951,-32766, 1021, 29, 734, 271,
+ 53, 398, 786, 787, 788, 789, 144, 1071, 441, -341,
+ 332, 38, 864, 862, -195, 843, 790, 791, 792, 793,
+ 794, 795, 796, 797, 798, 799, 819, 583, 820, 821,
+ 822, 823, 811, 812, 353, 354, 814, 815, 800, 801,
+ 802, 804, 805, 806, 368, 846, 847, 848, 849, 850,
+ 584, 863, -194, 139, 807, 808, 585, 586, 323, 831,
+ 829, 830, 842, 826, 827, 1370, 148, 587, 588, 825,
+ 589, 590, 591, 592, 245, 593, 594, 395, 396,-32766,
+ -32766,-32766, 828, 595, 596, -85, 138, 440, 132, 133,
+ 134, 582, 135, 136, 1095, 779, 780, 781, 137, 41,
+ -32766,-32766,-32766,-32766,-32766, 51, 578, 1302, 257,-32766,
+ 636, 107, 108, 109,-32766,-32766,-32766, 503,-32766, 316,
+ -32766,-32766,-32766, 773, 772,-32766, -383, 166, -383, 1022,
+ -32766,-32766,-32766, 305, 79, 1133,-32766,-32766, 1414, 762,
+ 332, 1415,-32766, 437, 782,-32766, 1071, 110, 111, 112,
+ 113, 114, -85, 283,-32766, 477, 478, 479, 271, 53,
+ 398, 786, 787, 788, 789, 115, 407, 441, 10,-32766,
+ 299, 1341, 306, 307, 843, 790, 791, 792, 793, 794,
+ 795, 796, 797, 798, 799, 819, 583, 820, 821, 822,
+ 823, 811, 812, 353, 354, 814, 815, 800, 801, 802,
+ 804, 805, 806, 368, 846, 847, 848, 849, 850, 584,
+ 320, 1068, -582, 807, 808, 585, 586, 1389, 831, 829,
+ 830, 842, 826, 827, 329, 1388, 587, 588, 825, 589,
+ 590, 591, 592, 86, 593, 594, 1071, 332,-32766,-32766,
+ -32766, 828, 595, 596, 349, 151, -581, 132, 133, 134,
+ 582, 135, 136, 1100, 779, 780, 781, 137, 41,-32766,
+ 290,-32766,-32766,-32766,-32766,-32766,-32766,-32766,-32767,-32767,
+ -32767,-32767,-32767,-32766,-32766,-32766, 891, 1175, 892, -582,
+ -582, 754, 773, 772, 1159, 1160, 1161, 1155, 1154, 1153,
+ 1162, 1156, 1157, 1158,-32766, -582,-32766,-32766,-32766,-32766,
+ -32766,-32766,-32766, 782,-32766,-32766,-32766, -588, -78,-32766,
+ -32766,-32766, 350, -581, -581,-32766,-32766, 271, 53, 398,
+ 786, 787, 788, 789, 383,-32766, 441,-32766,-32766, -581,
+ -32766, 773, 772, 843, 790, 791, 792, 793, 794, 795,
+ 796, 797, 798, 799, 819, 583, 820, 821, 822, 823,
+ 811, 812, 353, 354, 814, 815, 800, 801, 802, 804,
+ 805, 806, 368, 846, 847, 848, 849, 850, 584, -620,
+ 1068, -620, 807, 808, 585, 586, 389, 831, 829, 830,
+ 842, 826, 827, 441, 405, 587, 588, 825, 589, 590,
+ 591, 592, 333, 593, 594, 1071, 87, 88, 89, 459,
+ 828, 595, 596, 460, 151, 803, 774, 775, 776, 777,
+ 778, 854, 779, 780, 781, 816, 817, 40, 461, 90,
+ 91, 92, 93, 94, 95, 96, 97, 98, 99, 100,
+ 101, 102, 103, 104, 105, 106, 107, 108, 109, 110,
+ 111, 112, 113, 114, 462, 283, 1329, 1159, 1160, 1161,
+ 1155, 1154, 1153, 1162, 1156, 1157, 1158, 115, 869, 488,
+ 489, 782, 1304, 1303, 1305, 108, 109, 1132, 154,-32766,
+ -32766, 1134, 679, 23, 156, 783, 784, 785, 786, 787,
+ 788, 789, 698, 699, 852, 152, 423, -580, 393, 394,
+ 157, 843, 790, 791, 792, 793, 794, 795, 796, 797,
+ 798, 799, 819, 841, 820, 821, 822, 823, 811, 812,
+ 813, 840, 814, 815, 800, 801, 802, 804, 805, 806,
+ 845, 846, 847, 848, 849, 850, 851, 1094, -578, 863,
+ 807, 808, 809, 810, -58, 831, 829, 830, 842, 826,
+ 827, 399, 400, 818, 824, 825, 832, 833, 835, 834,
+ 294, 836, 837, 158, -580, -580, 160, 294, 828, 839,
+ 838, 54, 55, 56, 57, 534, 58, 59, 36, -110,
+ -580, -57, 60, 61, -110, 62, -110, 670, 671, 129,
+ 130, 312, -587, 140, -110, -110, -110, -110, -110, -110,
+ -110, -110, -110, -110, -110, -578, -578, 141, 147, 949,
+ 161, 712, -87, 163, 164, 165, -84, 949, -78, -73,
+ -72, -578, 63, 64, 143, -309, -71, 65, 332, 66,
+ 251, 252, 67, 68, 69, 70, 71, 72, 73, 74,
+ 739, 31, 276, 47, 457, 535, -357, 713, 740, 1335,
+ 1336, 536, -70, 863, 1068, -69, -68, 1333, 45, 22,
+ 537, 949, 538, -67, 539, -66, 540, 52, -65, 541,
+ 542, 714, 715, -46, 48, 49, 463, 392, 391, 1071,
+ 50, 543, -18, 145, 281, 1302, 381, 348, 291, 750,
+ 1304, 1303, 1305, 1295, 939, 753, 290, 948, 545, 546,
+ 547, 150, 939, 290, -305, 295, 288, 289, 292, 293,
+ 549, 550, 338, 1321, 1322, 1323, 1324, 1326, 1318, 1319,
+ 304, 1300, 296, 301, 302, 283, 1325, 1320, 773, 772,
+ 1304, 1303, 1305, 305, 308, 309, 75, -154, -154, -154,
+ 327, 328, 332, 966, 854, 1070, 939, 149, 115, 1416,
+ 388, 680, -154, 708, -154, 725, -154, 13, -154, 668,
+ 723, 313, 31, 277, 1304, 1303, 1305, 863, 390,-32766,
+ 600, 1166, 987, 951, 863, 310, 701, 734, 1333, 990,
+ 991, 951,-32766, 686, 544, 734, 949, 685, 606, 1340,
+ 485, 513, 925, 986, -110, -110, -110, 35, 116, 117,
+ 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
+ 128, 702, 949, 634, 1295, 773, 772, 741, -579, 305,
+ -614, 1334, 0, 0, 0, 951, 311, 949, 0, 734,
+ -154, 549, 550, 319, 1321, 1322, 1323, 1324, 1326, 1318,
+ 1319, 1209, 1211, 744, 0, 1342, 0, 1325, 1320, -544,
+ -534, 0, -578,-32766, -4, 949, 11, 77, 751, 1302,
+ 30, 387, 328, 332, 862, 43,-32766,-32766,-32766, -613,
+ -32766, 939,-32766, 968,-32766, 44, 759,-32766, 1330, 773,
+ 772, 760,-32766,-32766,-32766, -579, -579, 882,-32766,-32766,
+ 930, 1031, 1008, 1015,-32766, 437, 1005, 939, 1016, 928,
+ 1003, -579, 1137, 1140, 1141, 1138,-32766, 1177, 1139, 1145,
+ 37, 874, 939, -586, 1357, 1374, 1407,-32766, 673, -578,
+ -578, -612, -588, 1302, -587, -586, -585, 31, 276, -528,
+ -32766,-32766,-32766, 1,-32766, -578,-32766, 78,-32766, 863,
+ 939,-32766, 32, 1333, -278, 33,-32766,-32766,-32766, 42,
+ 1007, 46,-32766,-32766, 734, 76, 80, 81,-32766, 437,
+ 82, 83, 390, 84, 453, 31, 277, 85, 146, 303,
+ -32766, 155, 159, 990, 991, 249, 951, 863, 544, 1295,
+ 734, 1333, 334, 369, 370, 371, 548, 986, -110, -110,
+ -110, 951, 372, 326, 373, 734, 374, 550, 375, 1321,
+ 1322, 1323, 1324, 1326, 1318, 1319, 376, 377, 422, 378,
+ 21, -50, 1325, 1320, 379, 382, 454, 1295, 577, 951,
+ 380, 384, 77, 734, -4, -276, -275, 328, 332, 15,
+ 16, 17, 18, 20, 363, 550, 421, 1321, 1322, 1323,
+ 1324, 1326, 1318, 1319, 142, 504, 505, 512, 515, 516,
+ 1325, 1320, 949, 517, 518,-32766, 522, 523, 524, 531,
+ 77, 1302, 611, 718, 1101, 328, 332, 1097,-32766,-32766,
+ -32766, 1250,-32766, 1331,-32766, 949,-32766, 1099, 1096,-32766,
+ 1077, 1290, 1309, 1073,-32766,-32766,-32766, -280,-32766, -102,
+ -32766,-32766, 14, 19, 1302, 24,-32766, 437, 323, 420,
+ 625,-32766,-32766,-32766, 631,-32766, 659,-32766,-32766,-32766,
+ 724, 1254,-32766, -16, 1308, 1251, 1386,-32766,-32766,-32766,
+ 735,-32766, 738,-32766,-32766, 742, 743, 1302, 745,-32766,
+ 437, 746, 747, 748,-32766,-32766,-32766, 939,-32766, 300,
+ -32766,-32766,-32766, 752, 1309,-32766, 764, 737, 332, 765,
+ -32766,-32766,-32766, -253, -253, -253,-32766,-32766, 426, 390,
+ 939, 756,-32766, 437, 926, 863, 1411, 1413, 885, 884,
+ 990, 991, 980, 1023,-32766, 544, -252, -252, -252, 1412,
+ 979, 977, 390, 925, 986, -110, -110, -110, 978, 981,
+ 1283, 959, 969, 990, 991, 957, 1176, 1172, 544, 1126,
+ -110, -110, 1013, 1014, 657, -110, 925, 986, -110, -110,
+ -110, 1410, 2, 1368, -110, 1268, 951, 1383, 0, 0,
+ 734, -253, 0,-32766, 0, 0,-32766, 863, 1059, 1054,
+ 1053, 1052, 1058, 1055, 1056, 1057, 0, 0, 0, 951,
+ 0, 0, 0, 734, -252, 305, 0, 0, 79, 0,
+ 0, 1071, 0, 0, 332, 0, 0, 0, 0, 0,
+ 0, 0, -110, -110, 0, 0, 0, -110, 0, 0,
+ 0, 0, 0, 0, 0, 299, -110, 0, 0, 0,
+ 0, 0, 0, 0, 0,-32766, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 305, 0, 0,
+ 79, 0, 0, 0, 0, 0, 332
+ );
+
+ protected array $actionCheck = array(
+ 3, 4, 5, 6, 7, 8, 17, 10, 11, 12,
+ 13, 14, 84, 76, 1, 87, 72, 74, 75, 82,
+ 0, 108, 109, 110, 15, 82, 89, 90, 91, 10,
+ 93, 118, 95, 103, 97, 38, 39, 100, 10, 11,
+ 12, 104, 105, 106, 107, 10, 11, 12, 111, 112,
+ 15, 10, 11, 12, 117, 118, 59, 82, 128, 31,
+ 1, 33, 34, 35, 36, 37, 129, 124, 1, 31,
+ 73, 74, 75, 76, 77, 78, 79, 164, 1, 82,
+ 9, 153, 154, 139, 140, 9, 89, 90, 91, 92,
+ 93, 94, 95, 96, 97, 98, 99, 100, 101, 102,
+ 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
+ 113, 114, 115, 116, 117, 118, 119, 120, 121, 122,
+ 123, 124, 1, 9, 82, 128, 129, 130, 131, 9,
+ 133, 134, 135, 136, 137, 138, 9, 162, 141, 142,
+ 143, 144, 145, 146, 147, 86, 149, 150, 9, 82,
+ 10, 11, 12, 156, 157, 158, 118, 160, 169, 3,
+ 4, 5, 6, 7, 8, 168, 10, 11, 12, 13,
+ 14, 31, 76, 33, 34, 35, 36, 168, 82, 83,
+ 15, 143, 169, 119, 120, 89, 90, 91, 124, 93,
+ 108, 95, 110, 97, 38, 39, 100, 133, 1, 108,
+ 109, 105, 106, 107, 162, 167, 1, 111, 112, 118,
+ 32, 169, 118, 117, 118, 59, 45, 46, 47, 48,
+ 49, 50, 51, 52, 165, 129, 32, 9, 169, 73,
+ 74, 75, 76, 77, 78, 79, 169, 143, 82, 168,
+ 173, 9, 165, 161, 168, 89, 90, 91, 92, 93,
+ 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
+ 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
+ 114, 115, 116, 117, 118, 119, 120, 121, 122, 123,
+ 124, 84, 168, 9, 128, 129, 130, 131, 168, 133,
+ 134, 135, 136, 137, 138, 1, 9, 141, 142, 143,
+ 144, 145, 146, 147, 99, 149, 150, 108, 109, 10,
+ 11, 12, 156, 157, 158, 32, 160, 118, 3, 4,
+ 5, 6, 7, 8, 168, 10, 11, 12, 13, 14,
+ 31, 76, 33, 34, 35, 72, 87, 82, 9, 142,
+ 54, 50, 51, 52, 89, 90, 91, 169, 93, 9,
+ 95, 118, 97, 38, 39, 100, 108, 15, 110, 165,
+ 105, 106, 107, 164, 167, 165, 111, 112, 82, 169,
+ 173, 85, 117, 118, 59, 118, 143, 53, 54, 55,
+ 56, 57, 99, 59, 129, 134, 135, 136, 73, 74,
+ 75, 76, 77, 78, 79, 71, 108, 82, 110, 142,
+ 167, 152, 139, 140, 89, 90, 91, 92, 93, 94,
+ 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
+ 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
+ 115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
+ 9, 118, 72, 128, 129, 130, 131, 1, 133, 134,
+ 135, 136, 137, 138, 9, 9, 141, 142, 143, 144,
+ 145, 146, 147, 169, 149, 150, 143, 173, 10, 11,
+ 12, 156, 157, 158, 9, 160, 72, 3, 4, 5,
+ 6, 7, 8, 168, 10, 11, 12, 13, 14, 31,
+ 167, 33, 34, 35, 36, 37, 38, 39, 40, 41,
+ 42, 43, 44, 10, 11, 12, 108, 165, 110, 139,
+ 140, 169, 38, 39, 118, 119, 120, 121, 122, 123,
+ 124, 125, 126, 127, 31, 155, 33, 34, 35, 36,
+ 37, 38, 39, 59, 10, 11, 12, 167, 17, 10,
+ 11, 12, 9, 139, 140, 10, 11, 73, 74, 75,
+ 76, 77, 78, 79, 9, 31, 82, 33, 34, 155,
+ 31, 38, 39, 89, 90, 91, 92, 93, 94, 95,
+ 96, 97, 98, 99, 100, 101, 102, 103, 104, 105,
+ 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
+ 116, 117, 118, 119, 120, 121, 122, 123, 124, 166,
+ 118, 168, 128, 129, 130, 131, 9, 133, 134, 135,
+ 136, 137, 138, 82, 9, 141, 142, 143, 144, 145,
+ 146, 147, 72, 149, 150, 143, 10, 11, 12, 9,
+ 156, 157, 158, 9, 160, 3, 4, 5, 6, 7,
+ 8, 82, 10, 11, 12, 13, 14, 31, 9, 33,
+ 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
+ 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
+ 54, 55, 56, 57, 9, 59, 1, 118, 119, 120,
+ 121, 122, 123, 124, 125, 126, 127, 71, 9, 139,
+ 140, 59, 161, 162, 163, 51, 52, 1, 15, 53,
+ 54, 170, 77, 78, 15, 73, 74, 75, 76, 77,
+ 78, 79, 77, 78, 82, 103, 104, 72, 108, 109,
+ 15, 89, 90, 91, 92, 93, 94, 95, 96, 97,
+ 98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
+ 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
+ 118, 119, 120, 121, 122, 123, 124, 1, 72, 84,
+ 128, 129, 130, 131, 17, 133, 134, 135, 136, 137,
+ 138, 108, 109, 141, 142, 143, 144, 145, 146, 147,
+ 31, 149, 150, 15, 139, 140, 15, 31, 156, 157,
+ 158, 2, 3, 4, 5, 6, 7, 8, 15, 103,
+ 155, 17, 13, 14, 108, 16, 110, 113, 114, 17,
+ 17, 115, 167, 17, 118, 119, 120, 121, 122, 123,
+ 124, 125, 126, 127, 128, 139, 140, 17, 17, 1,
+ 17, 82, 32, 17, 17, 17, 32, 1, 32, 32,
+ 32, 155, 53, 54, 169, 36, 32, 58, 173, 60,
+ 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
+ 32, 72, 73, 74, 75, 76, 170, 118, 32, 80,
+ 81, 82, 32, 84, 118, 32, 32, 88, 89, 90,
+ 91, 1, 93, 32, 95, 32, 97, 72, 32, 100,
+ 101, 142, 143, 32, 105, 106, 107, 108, 109, 143,
+ 111, 112, 32, 32, 32, 82, 117, 118, 32, 32,
+ 161, 162, 163, 124, 86, 32, 167, 32, 129, 130,
+ 131, 32, 86, 167, 36, 38, 36, 36, 36, 36,
+ 141, 142, 36, 144, 145, 146, 147, 148, 149, 150,
+ 151, 118, 38, 38, 38, 59, 157, 158, 38, 39,
+ 161, 162, 163, 164, 139, 140, 167, 77, 78, 79,
+ 171, 172, 173, 39, 82, 142, 86, 72, 71, 85,
+ 155, 92, 92, 79, 94, 94, 96, 99, 98, 115,
+ 82, 116, 72, 73, 161, 162, 163, 84, 108, 87,
+ 91, 84, 133, 165, 84, 137, 96, 169, 88, 119,
+ 120, 165, 142, 102, 124, 169, 1, 98, 159, 152,
+ 99, 99, 132, 133, 134, 135, 136, 17, 18, 19,
+ 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+ 30, 102, 1, 159, 124, 38, 39, 32, 72, 164,
+ 167, 172, -1, -1, -1, 165, 138, 1, -1, 169,
+ 170, 141, 142, 137, 144, 145, 146, 147, 148, 149,
+ 150, 61, 62, 32, -1, 152, -1, 157, 158, 155,
+ 155, -1, 72, 76, 0, 1, 155, 167, 32, 82,
+ 155, 155, 172, 173, 161, 165, 89, 90, 91, 167,
+ 93, 86, 95, 160, 97, 165, 165, 100, 166, 38,
+ 39, 165, 105, 106, 107, 139, 140, 165, 111, 112,
+ 165, 165, 165, 165, 117, 118, 165, 86, 165, 165,
+ 165, 155, 165, 165, 165, 165, 129, 165, 165, 165,
+ 169, 166, 86, 167, 166, 166, 166, 76, 166, 139,
+ 140, 167, 167, 82, 167, 167, 167, 72, 73, 167,
+ 89, 90, 91, 167, 93, 155, 95, 160, 97, 84,
+ 86, 100, 167, 88, 168, 167, 105, 106, 107, 167,
+ 165, 167, 111, 112, 169, 167, 167, 167, 117, 118,
+ 167, 167, 108, 167, 110, 72, 73, 167, 167, 115,
+ 129, 167, 167, 119, 120, 167, 165, 84, 124, 124,
+ 169, 88, 167, 167, 167, 167, 132, 133, 134, 135,
+ 136, 165, 167, 169, 167, 169, 167, 142, 167, 144,
+ 145, 146, 147, 148, 149, 150, 167, 167, 170, 167,
+ 156, 32, 157, 158, 167, 167, 167, 124, 167, 165,
+ 167, 169, 167, 169, 170, 168, 168, 172, 173, 168,
+ 168, 168, 168, 168, 168, 142, 168, 144, 145, 146,
+ 147, 148, 149, 150, 32, 168, 168, 168, 168, 168,
+ 157, 158, 1, 168, 168, 76, 168, 168, 168, 168,
+ 167, 82, 168, 168, 168, 172, 173, 168, 89, 90,
+ 91, 168, 93, 168, 95, 1, 97, 168, 168, 100,
+ 168, 168, 1, 168, 105, 106, 107, 168, 76, 168,
+ 111, 112, 168, 168, 82, 168, 117, 118, 168, 168,
+ 168, 89, 90, 91, 168, 93, 168, 95, 129, 97,
+ 168, 168, 100, 32, 168, 168, 168, 105, 106, 107,
+ 169, 76, 169, 111, 112, 169, 169, 82, 169, 117,
+ 118, 169, 169, 169, 89, 90, 91, 86, 93, 31,
+ 95, 129, 97, 169, 1, 100, 169, 169, 173, 169,
+ 105, 106, 107, 102, 103, 104, 111, 112, 170, 108,
+ 86, 170, 117, 118, 170, 84, 170, 170, 170, 170,
+ 119, 120, 170, 170, 129, 124, 102, 103, 104, 170,
+ 170, 170, 108, 132, 133, 134, 135, 136, 170, 170,
+ 170, 170, 170, 119, 120, 170, 170, 170, 124, 170,
+ 119, 120, 170, 170, 170, 124, 132, 133, 134, 135,
+ 136, 170, 167, 170, 133, 171, 165, 170, -1, -1,
+ 169, 170, -1, 142, -1, -1, 118, 84, 120, 121,
+ 122, 123, 124, 125, 126, 127, -1, -1, -1, 165,
+ -1, -1, -1, 169, 170, 164, -1, -1, 167, -1,
+ -1, 143, -1, -1, 173, -1, -1, -1, -1, -1,
+ -1, -1, 119, 120, -1, -1, -1, 124, -1, -1,
+ -1, -1, -1, -1, -1, 167, 133, -1, -1, -1,
+ -1, -1, -1, -1, -1, 142, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 164, -1, -1,
+ 167, -1, -1, -1, -1, -1, 173
+ );
+
+ protected array $actionBase = array(
+ 0, 156, -3, 315, 474, 474, 880, 1074, 1271, 1294,
+ 749, 675, 531, 559, 836, 1031, 1031, 1046, 1031, 828,
+ 1005, 42, 59, 59, 59, 963, 898, 632, 632, 898,
+ 632, 997, 997, 997, 997, 1061, 1061, -63, -63, 96,
+ 1232, 1199, 255, 255, 255, 255, 255, 1265, 255, 255,
+ 255, 255, 255, 1265, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 77, 194, 120,
+ 205, 1197, 783, 1150, 1163, 1152, 1166, 1145, 1144, 1151,
+ 1156, 1167, 1261, 1263, 889, 1254, 1267, 1158, 972, 1147,
+ 1162, 962, 616, 616, 616, 616, 616, 616, 616, 616,
+ 616, 616, 616, 616, 616, 616, 616, 616, 616, 616,
+ 616, 616, 616, 616, 616, 616, 616, 616, 616, 19,
+ 35, 535, 41, 41, 41, 41, 41, 41, 41, 41,
+ 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
+ 41, 41, 529, 529, 529, 910, 910, 524, 299, 1113,
+ 1075, 1113, 1113, 1113, 1113, 1113, 1113, 1113, 1113, 140,
+ 28, 1000, 493, 493, 458, 458, 458, 458, 458, 696,
+ 1328, 1301, 171, 171, 171, 171, 1363, 1363, -70, 523,
+ 248, 756, 291, 197, -87, 644, 38, 199, 323, 323,
+ 482, 482, 233, 233, 482, 482, 482, 324, 324, 94,
+ 94, 94, 94, 82, 249, 860, 67, 67, 67, 67,
+ 860, 860, 860, 860, 913, 869, 860, 1036, 1049, 860,
+ 860, 370, 645, 966, 646, 646, 398, -72, -72, 398,
+ 64, -72, 294, 286, 257, 859, 91, 433, 257, 1073,
+ 404, 686, 686, 815, 686, 686, 686, 923, 610, 923,
+ 1141, 902, 902, 861, 807, 964, 1198, 1168, 901, 1252,
+ 929, 1253, 1200, 342, 251, -56, 263, 550, 806, 1139,
+ 1139, 1139, 1139, 1139, 1139, 1139, 1139, 1139, 1139, 1139,
+ 1139, 1195, 523, 1141, -25, 1247, 1249, 1195, 1195, 1195,
+ 523, 523, 523, 523, 523, 523, 523, 523, 870, 523,
+ 523, 694, -25, 625, 635, -25, 896, 523, 915, 77,
+ 77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
+ 178, 77, 77, 194, 13, 13, 77, 200, 121, 13,
+ 13, 13, -11, 13, 77, 77, 77, 610, 886, 849,
+ 663, 283, 874, 114, 886, 886, 886, 71, 9, 76,
+ 809, 888, 288, 882, 882, 882, 907, 986, 986, 882,
+ 903, 882, 907, 882, 882, 986, 986, 875, 986, 274,
+ 620, 465, 597, 624, 986, 340, 882, 882, 882, 882,
+ 916, 986, 127, 139, 639, 882, 329, 287, 882, 882,
+ 916, 858, 876, 908, 986, 986, 986, 916, 545, 908,
+ 908, 908, 931, 936, 864, 872, 445, 431, 679, 232,
+ 924, 872, 872, 882, 605, 864, 872, 864, 872, 933,
+ 872, 872, 872, 864, 872, 903, 533, 872, 813, 665,
+ 218, 872, 882, 20, 1008, 1009, 800, 1010, 1002, 1013,
+ 1069, 1014, 1016, 1171, 982, 1028, 1004, 1020, 1071, 998,
+ 995, 885, 792, 793, 921, 914, 979, 897, 897, 897,
+ 975, 977, 897, 897, 897, 897, 897, 897, 897, 897,
+ 792, 932, 926, 899, 1037, 796, 810, 1114, 857, 1214,
+ 1264, 1036, 1008, 1016, 804, 1004, 1020, 998, 995, 856,
+ 853, 844, 851, 843, 840, 808, 814, 871, 1116, 1119,
+ 1021, 920, 811, 1085, 1038, 1211, 1044, 1045, 1047, 1088,
+ 1123, 942, 1125, 1216, 895, 1217, 1218, 965, 1051, 1173,
+ 897, 974, 873, 968, 1049, 978, 792, 969, 1129, 1130,
+ 1081, 961, 1097, 1098, 1072, 911, 884, 970, 1219, 1059,
+ 1060, 1062, 1176, 1177, 930, 1082, 996, 1099, 912, 1058,
+ 1100, 1101, 1105, 1106, 1179, 1222, 1182, 922, 1183, 945,
+ 879, 1077, 909, 1223, 165, 892, 893, 906, 1068, 683,
+ 1035, 1184, 1208, 1229, 1108, 1109, 1110, 1230, 1231, 1024,
+ 946, 1083, 900, 1084, 1078, 947, 948, 689, 905, 1132,
+ 890, 891, 904, 705, 768, 1238, 1239, 1240, 1025, 877,
+ 894, 951, 953, 1133, 887, 1135, 1241, 771, 954, 1242,
+ 1115, 816, 817, 521, 784, 747, 818, 881, 1194, 925,
+ 865, 878, 1067, 817, 883, 955, 1245, 957, 958, 959,
+ 1111, 960, 1086, 1246, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 789, 789,
+ 789, 789, 789, 789, 789, 789, 789, 632, 632, 632,
+ 632, 789, 789, 789, 789, 789, 789, 789, 632, 789,
+ 789, 789, 632, 632, 0, 0, 632, 0, 789, 789,
+ 789, 789, 789, 789, 789, 789, 789, 789, 789, 789,
+ 789, 789, 789, 789, 789, 789, 789, 789, 789, 789,
+ 789, 789, 789, 789, 789, 789, 789, 789, 789, 789,
+ 789, 789, 789, 789, 789, 789, 789, 789, 789, 789,
+ 789, 789, 789, 789, 789, 789, 789, 789, 789, 789,
+ 789, 789, 789, 789, 789, 789, 789, 789, 789, 789,
+ 789, 789, 789, 789, 789, 789, 789, 789, 789, 789,
+ 789, 789, 789, 789, 789, 789, 789, 789, 789, 789,
+ 789, 789, 789, 789, 789, 789, 789, 789, 789, 789,
+ 789, 789, 789, 789, 789, 789, 789, 789, 789, 789,
+ 789, 789, 789, 789, 789, 789, 789, 789, 789, 789,
+ 789, 789, 789, 789, 789, 789, 789, 789, 789, 789,
+ 789, 789, 789, 789, 789, 789, 789, 789, 789, 789,
+ 789, 789, 789, 789, 616, 616, 616, 616, 616, 616,
+ 616, 616, 616, 616, 616, 616, 616, 616, 616, 616,
+ 616, 616, 616, 616, 616, 616, 616, 616, 616, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 616, 616, 616, 616,
+ 616, 616, 616, 616, 616, 616, 616, 616, 616, 616,
+ 616, 616, 616, 616, 616, 616, 616, 616, 616, 616,
+ 616, 616, 823, 823, 616, 616, 823, 823, 823, 823,
+ 823, 823, 823, 823, 823, 823, 616, 616, 0, 616,
+ 616, 616, 616, 616, 616, 616, 875, 823, 823, 324,
+ 324, 324, 324, 823, 823, 396, 396, 396, 823, 324,
+ 823, 64, 324, 823, 64, 823, 823, 823, 823, 823,
+ 823, 823, 823, 823, 0, 0, 823, 823, 823, 823,
+ -25, -72, 823, 903, 903, 903, 903, 823, 823, 823,
+ 823, -72, -72, 823, -57, -57, 823, 823, 0, 0,
+ 0, 324, 324, -25, 0, 0, -25, 0, 0, 903,
+ 903, 823, 64, 875, 446, 823, 342, 0, 0, 0,
+ 0, 0, 0, 0, -25, 903, -25, 523, -72, -72,
+ 523, 523, 13, 77, 446, 612, 612, 612, 612, 77,
+ 0, 0, 0, 0, 0, 610, 875, 875, 875, 875,
+ 875, 875, 875, 875, 875, 875, 875, 875, 903, 0,
+ 875, 0, 875, 875, 903, 903, 903, 0, 0, 0,
+ 0, 0, 0, 0, 0, 986, 0, 0, 0, 0,
+ 0, 0, 0, 903, 0, 986, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 903, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 897, 911, 0, 0, 911,
+ 0, 897, 897, 897, 0, 0, 0, 905, 887
+ );
+
+ protected array $actionDefault = array(
+ 3,32767,32767,32767, 102, 102,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767, 100,
+ 32767, 632, 632, 632, 632,32767,32767, 257, 102,32767,
+ 32767, 503, 417, 417, 417,32767,32767,32767, 576, 576,
+ 576, 576, 576, 17,32767,32767,32767,32767,32767,32767,
+ 32767, 503,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767, 36, 7, 8, 10, 11, 49, 338, 100,
+ 32767,32767,32767,32767,32767,32767,32767,32767, 102,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767, 404, 625,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767, 497, 507, 485, 486, 488, 489, 416, 577,
+ 631, 344, 628, 342, 415, 146, 354, 343, 245, 261,
+ 508, 262, 509, 512, 513, 218, 401, 150, 151, 448,
+ 504, 450, 502, 506, 449, 422, 429, 430, 431, 432,
+ 433, 434, 435, 436, 437, 438, 439, 440, 441, 420,
+ 421, 505, 482, 481, 480,32767,32767, 446, 447,32767,
+ 32767,32767,32767,32767,32767,32767,32767, 102,32767, 451,
+ 454, 419, 452, 453, 470, 471, 468, 469, 472,32767,
+ 323,32767, 473, 474, 475, 476,32767,32767, 382, 196,
+ 380,32767, 477,32767, 111, 455, 323, 111,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767, 461, 462,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767, 102,32767,32767,32767,
+ 100, 520, 570, 479, 456, 457,32767, 545,32767, 102,
+ 32767, 547,32767,32767,32767,32767,32767,32767,32767,32767,
+ 572, 443, 445, 540, 626, 423, 629,32767, 533, 100,
+ 196,32767, 546, 196, 196,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767, 571,32767, 639, 533, 110,
+ 110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
+ 110,32767, 196, 110,32767, 110, 110,32767,32767, 100,
+ 196, 196, 196, 196, 196, 196, 196, 196, 548, 196,
+ 196, 191,32767, 271, 273, 102, 594, 196, 550,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767, 404,32767,32767,32767,32767, 533, 466, 139,
+ 32767, 535, 139, 578, 458, 459, 460, 578, 578, 578,
+ 319, 296,32767,32767,32767,32767,32767, 548, 548, 100,
+ 100, 100, 100,32767,32767,32767,32767, 111, 519, 99,
+ 99, 99, 99, 99, 103, 101,32767,32767,32767,32767,
+ 226,32767, 101, 101, 99,32767, 101, 101,32767,32767,
+ 226, 228, 215, 230,32767, 598, 599, 226, 101, 230,
+ 230, 230, 250, 250, 522, 325, 101, 99, 101, 101,
+ 198, 325, 325,32767, 101, 522, 325, 522, 325, 200,
+ 325, 325, 325, 522, 325,32767, 101, 325, 217, 99,
+ 99, 325,32767,32767,32767,32767, 535,32767,32767,32767,
+ 32767,32767,32767,32767, 225,32767,32767,32767,32767,32767,
+ 32767,32767,32767, 565,32767, 583, 596, 464, 465, 467,
+ 582, 580, 490, 491, 492, 493, 494, 495, 496, 499,
+ 627,32767, 539,32767,32767,32767, 353,32767, 637,32767,
+ 32767,32767, 9, 74, 528, 42, 43, 51, 57, 554,
+ 555, 556, 557, 551, 552, 558, 553,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767, 638,32767, 578,32767,32767,32767,32767,
+ 463, 560, 604,32767,32767, 579, 630,32767,32767,32767,
+ 32767,32767,32767,32767,32767, 139,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767, 565,32767, 137,32767,
+ 32767,32767,32767,32767,32767,32767,32767, 561,32767,32767,
+ 32767, 578,32767,32767,32767,32767, 321, 318,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767, 578,32767,32767,32767,32767,32767,
+ 298,32767, 315,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767, 400, 535, 301, 303, 304,32767,32767,32767,32767,
+ 376,32767,32767,32767,32767,32767,32767,32767,32767,32767,
+ 32767,32767,32767,32767, 153, 153, 3, 3, 356, 153,
+ 153, 153, 356, 356, 153, 356, 356, 356, 153, 153,
+ 153, 153, 153, 153, 153, 283, 186, 265, 268, 250,
+ 250, 153, 368, 153, 402, 402, 411
+ );
+
+ protected array $goto = array(
+ 201, 169, 201, 201, 201, 1069, 598, 719, 448, 684,
+ 644, 681, 443, 345, 341, 342, 344, 615, 447, 346,
+ 449, 661, 481, 728, 570, 570, 570, 570, 1245, 626,
+ 172, 172, 172, 172, 225, 202, 198, 198, 182, 184,
+ 220, 198, 198, 198, 198, 198, 1195, 199, 199, 199,
+ 199, 199, 1195, 192, 193, 194, 195, 196, 197, 222,
+ 220, 223, 557, 558, 438, 559, 562, 563, 564, 565,
+ 566, 567, 568, 569, 173, 174, 175, 200, 176, 177,
+ 178, 170, 179, 180, 181, 183, 219, 221, 224, 242,
+ 247, 248, 259, 260, 262, 263, 264, 265, 266, 267,
+ 268, 272, 273, 274, 275, 282, 285, 297, 298, 324,
+ 325, 444, 445, 446, 620, 226, 227, 228, 229, 230,
+ 231, 232, 233, 234, 235, 236, 237, 238, 239, 240,
+ 241, 193, 194, 195, 196, 197, 222, 203, 204, 205,
+ 206, 243, 185, 186, 207, 187, 208, 204, 188, 244,
+ 203, 168, 209, 210, 189, 211, 212, 213, 190, 214,
+ 215, 171, 216, 217, 218, 191, 287, 284, 287, 287,
+ 883, 255, 255, 255, 255, 255, 1125, 605, 487, 487,
+ 622, 758, 660, 662, 1103, 359, 682, 487, 1075, 1074,
+ 706, 709, 1041, 717, 726, 1037, 733, 922, 879, 922,
+ 922, 253, 253, 253, 253, 250, 256, 646, 646, 1078,
+ 1079, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332, 1332,
+ 1332, 880, 351, 938, 933, 934, 947, 889, 935, 886,
+ 936, 937, 887, 890, 476, 941, 894, 476, 1044, 1044,
+ 893, 364, 364, 364, 364, 352, 351, 532, 1131, 1127,
+ 1128, 1351, 1351, 331, 315, 1351, 1351, 1351, 1351, 1351,
+ 1351, 1351, 1351, 1351, 1351, 1069, 1301, 1072, 1072, 704,
+ 983, 1301, 1301, 1064, 1080, 1081, 1069, 942, 1301, 943,
+ 458, 1069, 881, 1069, 1069, 1069, 1069, 1069, 1069, 1069,
+ 1069, 1069, 897, 855, 1069, 1069, 1069, 1069, 677, 678,
+ 1301, 695, 696, 697, 1006, 1301, 1301, 1301, 1301, 450,
+ 909, 1301, 436, 896, 1301, 1301, 1382, 1382, 1382, 1382,
+ 915, 581, 574, 499, 612, 450, 367, 971, 971, 955,
+ 501, 1076, 1076, 956, 1400, 1400, 367, 367, 688, 1087,
+ 1083, 1084, 572, 411, 414, 623, 627, 572, 572, 367,
+ 367, 1400, 357, 367, 572, 1417, 1377, 1378, 317, 574,
+ 581, 607, 608, 318, 618, 624, 1390, 640, 641, 1027,
+ 576, 1403, 1403, 367, 367, 28, 474, 520, 442, 521,
+ 635, 1000, 1000, 1000, 1000, 527, 409, 474, 1348, 1348,
+ 994, 1001, 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348,
+ 1348, 1348, 633, 647, 650, 651, 652, 653, 674, 675,
+ 676, 730, 732, 561, 561, 258, 258, 561, 561, 561,
+ 561, 561, 561, 561, 561, 561, 561, 610, 1362, 467,
+ 683, 467, 876, 616, 638, 876, 467, 467, 1191, 861,
+ 1373, 360, 361, 1093, 456, 1373, 1373, 560, 560, 705,
+ 432, 560, 1373, 560, 560, 560, 560, 560, 560, 560,
+ 560, 1277, 975, 575, 602, 575, 1278, 1281, 976, 575,
+ 1282, 602, 689, 412, 480, 1384, 1384, 1384, 1384, 347,
+ 873, 716, 576, 861, 876, 861, 490, 619, 491, 492,
+ 639, 8, 857, 9, 902, 907, 989, 716, 1408, 1409,
+ 716, 1369, 418, 1296, 278, 899, 330, 1174, 424, 425,
+ 1292, 330, 330, 693, 1049, 694, 1114, 429, 430, 431,
+ 761, 707, 1060, 905, 433, 1102, 1104, 1107, 355, 467,
+ 467, 467, 467, 467, 467, 467, 467, 467, 467, 467,
+ 467, 419, 339, 467, 911, 467, 467, 1294, 628, 629,
+ 1116, 497, 960, 1181, 621, 1144, 1371, 1371, 1116, 1118,
+ 1297, 1298, 1011, 1284, 1046, 1151, 1179, 1152, 731, 871,
+ 528, 722, 901, 1142, 687, 1025, 1284, 496, 1375, 1376,
+ 895, 910, 898, 1113, 1117, 998, 427, 727, 1165, 1299,
+ 1359, 1360, 1291, 1030, 386, 1009, 1002, 0, 757, 0,
+ 0, 573, 1039, 1034, 654, 656, 658, 0, 0, 0,
+ 0, 0, 0, 0, 0, 876, 0, 0, 999, 0,
+ 766, 766, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1163, 914
+ );
+
+ protected array $gotoCheck = array(
+ 42, 42, 42, 42, 42, 73, 127, 73, 66, 66,
+ 56, 56, 66, 66, 66, 66, 66, 66, 66, 66,
+ 66, 66, 159, 9, 107, 107, 107, 107, 159, 107,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 23, 23, 23, 23,
+ 15, 5, 5, 5, 5, 5, 15, 48, 157, 157,
+ 134, 48, 48, 48, 131, 97, 48, 157, 119, 119,
+ 48, 48, 48, 48, 48, 48, 48, 25, 25, 25,
+ 25, 5, 5, 5, 5, 5, 5, 108, 108, 120,
+ 120, 108, 108, 108, 108, 108, 108, 108, 108, 108,
+ 108, 26, 177, 15, 15, 15, 15, 15, 15, 15,
+ 15, 15, 15, 15, 83, 15, 15, 83, 107, 107,
+ 15, 24, 24, 24, 24, 177, 177, 76, 15, 15,
+ 15, 179, 179, 178, 178, 179, 179, 179, 179, 179,
+ 179, 179, 179, 179, 179, 73, 73, 89, 89, 89,
+ 89, 73, 73, 89, 89, 89, 73, 65, 73, 65,
+ 83, 73, 27, 73, 73, 73, 73, 73, 73, 73,
+ 73, 73, 35, 6, 73, 73, 73, 73, 86, 86,
+ 73, 86, 86, 86, 49, 73, 73, 73, 73, 118,
+ 35, 73, 43, 35, 73, 73, 9, 9, 9, 9,
+ 45, 76, 76, 84, 181, 118, 14, 9, 9, 73,
+ 84, 118, 118, 73, 191, 191, 14, 14, 118, 118,
+ 118, 118, 19, 59, 59, 59, 59, 19, 19, 14,
+ 14, 191, 188, 14, 19, 14, 187, 187, 76, 76,
+ 76, 76, 76, 76, 76, 76, 190, 76, 76, 103,
+ 14, 191, 191, 14, 14, 76, 19, 163, 13, 163,
+ 13, 19, 19, 19, 19, 163, 62, 19, 180, 180,
+ 19, 19, 180, 180, 180, 180, 180, 180, 180, 180,
+ 180, 180, 81, 81, 81, 81, 81, 81, 81, 81,
+ 81, 81, 81, 182, 182, 5, 5, 182, 182, 182,
+ 182, 182, 182, 182, 182, 182, 182, 104, 14, 23,
+ 64, 23, 22, 2, 2, 22, 23, 23, 158, 12,
+ 134, 97, 97, 115, 113, 134, 134, 165, 165, 117,
+ 14, 165, 134, 165, 165, 165, 165, 165, 165, 165,
+ 165, 79, 79, 9, 9, 9, 79, 79, 79, 9,
+ 79, 9, 121, 9, 9, 134, 134, 134, 134, 29,
+ 18, 7, 14, 12, 22, 12, 9, 9, 9, 9,
+ 80, 46, 7, 46, 39, 9, 92, 7, 9, 9,
+ 7, 134, 28, 20, 24, 37, 24, 156, 82, 82,
+ 169, 24, 24, 82, 110, 82, 133, 82, 82, 82,
+ 99, 82, 114, 9, 82, 130, 130, 130, 82, 23,
+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+ 23, 31, 9, 23, 41, 23, 23, 14, 17, 17,
+ 134, 160, 17, 17, 8, 8, 134, 134, 134, 136,
+ 20, 20, 96, 20, 17, 149, 149, 149, 8, 20,
+ 8, 8, 17, 8, 17, 17, 20, 185, 185, 185,
+ 17, 16, 16, 16, 16, 93, 93, 93, 152, 20,
+ 20, 20, 17, 50, 141, 16, 50, -1, 50, -1,
+ -1, 50, 50, 50, 85, 85, 85, -1, -1, -1,
+ -1, -1, -1, -1, -1, 22, -1, -1, 16, -1,
+ 24, 24, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 16, 16
+ );
+
+ protected array $gotoBase = array(
+ 0, 0, -303, 0, 0, 170, 280, 471, 543, 10,
+ 0, 0, 136, 31, 22, -186, 111, 66, 164, 71,
+ 95, 0, 148, 160, 235, 191, 214, 275, 155, 176,
+ 0, 86, 0, 0, 0, -92, 0, 156, 0, 165,
+ 0, 85, -1, 286, 0, 291, -270, 0, -558, 284,
+ 579, 0, 0, 0, 0, 0, -33, 0, 0, 294,
+ 0, 0, 341, 0, 184, 261, -237, 0, 0, 0,
+ 0, 0, 0, -5, 0, 0, -32, 0, 0, 37,
+ 172, 32, -3, -50, -167, 105, -444, 0, 0, -21,
+ 0, 0, 161, 274, 0, 0, 101, -318, 0, 97,
+ 0, 0, 0, 331, 381, 0, 0, -7, -38, 0,
+ 131, 0, 0, 158, 90, 162, 0, 159, 39, -100,
+ -83, 173, 0, 0, 0, 0, 0, 4, 0, 0,
+ 522, 182, 0, 127, 169, 0, 99, 0, 0, 0,
+ 0, -171, 0, 0, 0, 0, 0, 0, 0, 287,
+ 0, 0, 126, 0, 0, 0, 144, 141, 188, -255,
+ 93, 0, 0, -138, 0, 202, 0, 0, 0, 128,
+ 0, 0, 0, 0, 0, 0, 0, -82, -74, 6,
+ 143, 292, 168, 0, 0, 270, 0, -31, 319, 0,
+ 332, 20, 0, 0
+ );
+
+ protected array $gotoDefault = array(
+ -32768, 533, 768, 7, 769, 964, 844, 853, 597, 551,
+ 729, 356, 648, 439, 1367, 940, 1180, 617, 872, 1310,
+ 1316, 475, 875, 336, 755, 952, 923, 924, 415, 402,
+ 888, 413, 672, 649, 514, 908, 471, 900, 506, 903,
+ 470, 912, 167, 435, 530, 916, 6, 919, 579, 950,
+ 1004, 403, 927, 404, 700, 929, 601, 931, 932, 410,
+ 416, 417, 1185, 609, 645, 944, 261, 603, 945, 401,
+ 946, 954, 406, 408, 710, 486, 525, 519, 428, 1146,
+ 604, 632, 669, 464, 493, 643, 655, 642, 500, 451,
+ 434, 335, 988, 996, 507, 484, 1010, 358, 1018, 763,
+ 1193, 663, 509, 1026, 664, 1033, 1036, 552, 553, 498,
+ 1048, 270, 1051, 510, 1061, 26, 690, 1066, 1067, 691,
+ 665, 1089, 666, 692, 667, 1091, 483, 599, 1194, 482,
+ 1106, 1112, 472, 1115, 1356, 473, 1119, 269, 1122, 286,
+ 362, 385, 452, 1129, 1130, 12, 1136, 720, 721, 25,
+ 280, 529, 1164, 711, 1170, 279, 1173, 469, 1192, 468,
+ 1265, 1267, 580, 511, 1285, 321, 1288, 703, 526, 1293,
+ 465, 1358, 466, 554, 494, 343, 555, 1401, 314, 365,
+ 340, 571, 322, 366, 556, 495, 1364, 1372, 337, 34,
+ 1391, 1402, 614, 637
+ );
+
+ protected array $ruleToNonTerminal = array(
+ 0, 1, 3, 3, 2, 5, 5, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 7, 7, 7,
+ 7, 7, 7, 7, 7, 8, 8, 9, 10, 11,
+ 11, 11, 12, 12, 13, 13, 14, 15, 15, 16,
+ 16, 17, 17, 18, 18, 21, 21, 22, 23, 23,
+ 24, 24, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 29, 29, 30, 30, 32, 34,
+ 34, 28, 36, 36, 33, 38, 38, 35, 35, 37,
+ 37, 39, 39, 31, 40, 40, 41, 43, 44, 44,
+ 45, 45, 46, 46, 48, 47, 47, 47, 47, 49,
+ 49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
+ 49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
+ 49, 49, 49, 25, 25, 50, 69, 69, 72, 72,
+ 71, 70, 70, 63, 75, 75, 76, 76, 77, 77,
+ 78, 78, 79, 79, 80, 80, 80, 80, 26, 26,
+ 27, 27, 27, 27, 27, 88, 88, 90, 90, 83,
+ 83, 91, 91, 92, 92, 92, 84, 84, 87, 87,
+ 85, 85, 93, 94, 94, 57, 57, 65, 65, 68,
+ 68, 68, 67, 95, 95, 96, 58, 58, 58, 58,
+ 97, 97, 98, 98, 99, 99, 100, 101, 101, 102,
+ 102, 103, 103, 55, 55, 51, 51, 105, 53, 53,
+ 106, 52, 52, 54, 54, 64, 64, 64, 64, 81,
+ 81, 109, 109, 111, 111, 112, 112, 112, 112, 112,
+ 112, 112, 112, 110, 110, 110, 115, 115, 115, 115,
+ 89, 89, 118, 118, 118, 119, 119, 116, 116, 120,
+ 120, 122, 122, 123, 123, 117, 124, 124, 121, 125,
+ 125, 125, 125, 113, 113, 82, 82, 82, 20, 20,
+ 20, 128, 128, 128, 128, 129, 129, 129, 127, 126,
+ 126, 131, 131, 131, 130, 130, 60, 132, 132, 133,
+ 61, 135, 135, 136, 136, 137, 137, 86, 138, 138,
+ 138, 138, 138, 138, 138, 138, 144, 144, 145, 145,
+ 146, 146, 146, 146, 146, 147, 148, 148, 143, 143,
+ 139, 139, 142, 142, 150, 150, 149, 149, 149, 149,
+ 149, 149, 149, 149, 149, 149, 140, 151, 151, 153,
+ 152, 152, 141, 141, 114, 114, 154, 154, 156, 156,
+ 156, 155, 155, 62, 104, 157, 157, 56, 56, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 42, 164, 165, 165, 166,
+ 158, 158, 163, 163, 167, 168, 168, 169, 170, 171,
+ 171, 171, 171, 19, 19, 73, 73, 73, 73, 159,
+ 159, 159, 159, 173, 173, 162, 162, 162, 160, 160,
+ 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
+ 180, 180, 180, 108, 182, 182, 182, 182, 161, 161,
+ 161, 161, 161, 161, 161, 161, 59, 59, 176, 176,
+ 176, 176, 176, 183, 183, 172, 172, 172, 172, 184,
+ 184, 184, 184, 184, 74, 74, 66, 66, 66, 66,
+ 134, 134, 134, 134, 187, 186, 175, 175, 175, 175,
+ 175, 175, 174, 174, 174, 185, 185, 185, 185, 107,
+ 181, 189, 189, 188, 188, 190, 190, 190, 190, 190,
+ 190, 190, 190, 178, 178, 178, 178, 177, 192, 191,
+ 191, 191, 191, 191, 191, 191, 191, 193, 193, 193,
+ 193
+ );
+
+ protected array $ruleToLength = array(
+ 1, 1, 2, 0, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 0, 1, 1, 2, 1, 3, 4, 1, 2,
+ 0, 1, 1, 1, 1, 4, 3, 5, 4, 3,
+ 4, 1, 3, 4, 1, 1, 8, 7, 2, 3,
+ 1, 2, 3, 1, 2, 3, 1, 1, 3, 1,
+ 3, 1, 2, 2, 3, 1, 3, 2, 3, 1,
+ 3, 3, 2, 0, 1, 1, 1, 1, 1, 3,
+ 7, 10, 5, 7, 9, 5, 3, 3, 3, 3,
+ 3, 3, 1, 2, 5, 7, 9, 6, 5, 6,
+ 3, 2, 1, 1, 1, 1, 0, 2, 1, 3,
+ 8, 0, 4, 2, 1, 3, 0, 1, 0, 1,
+ 0, 1, 3, 1, 1, 1, 1, 1, 8, 9,
+ 7, 8, 7, 6, 8, 0, 2, 0, 2, 1,
+ 2, 1, 2, 1, 1, 1, 0, 2, 0, 2,
+ 0, 2, 2, 1, 3, 1, 4, 1, 4, 1,
+ 1, 4, 2, 1, 3, 3, 3, 4, 4, 5,
+ 0, 2, 4, 3, 1, 1, 7, 0, 2, 1,
+ 3, 3, 4, 1, 4, 0, 2, 5, 0, 2,
+ 6, 0, 2, 0, 3, 1, 2, 1, 1, 2,
+ 0, 1, 3, 0, 2, 1, 1, 1, 1, 1,
+ 1, 1, 1, 7, 9, 6, 1, 2, 1, 1,
+ 1, 1, 1, 1, 1, 1, 3, 3, 3, 1,
+ 3, 3, 3, 3, 3, 1, 3, 3, 1, 1,
+ 2, 1, 1, 0, 1, 0, 2, 2, 2, 4,
+ 3, 2, 4, 4, 3, 3, 1, 3, 1, 1,
+ 3, 2, 2, 3, 1, 1, 2, 3, 1, 1,
+ 2, 3, 1, 1, 3, 2, 0, 1, 5, 7,
+ 5, 6, 10, 3, 5, 1, 1, 3, 0, 2,
+ 4, 5, 4, 4, 4, 3, 1, 1, 1, 1,
+ 1, 1, 0, 1, 1, 2, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 2, 1, 3, 1,
+ 1, 3, 0, 2, 0, 3, 5, 8, 1, 3,
+ 3, 0, 2, 2, 2, 3, 1, 0, 1, 1,
+ 3, 3, 3, 4, 4, 1, 1, 2, 2, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 2, 2, 2, 2, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 2, 2, 2, 2, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 5, 4, 3, 4, 4, 2, 2, 4, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 1, 3, 2, 1, 2, 4, 2, 2, 8, 9,
+ 8, 9, 9, 10, 9, 10, 8, 3, 2, 2,
+ 1, 1, 0, 4, 2, 1, 3, 2, 1, 2,
+ 2, 2, 4, 1, 1, 1, 1, 1, 1, 1,
+ 1, 3, 1, 1, 1, 0, 1, 1, 0, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 3, 5, 3, 3, 4, 1, 1, 3, 1, 1,
+ 1, 1, 1, 3, 2, 3, 0, 1, 1, 3,
+ 1, 1, 1, 1, 1, 1, 3, 1, 1, 1,
+ 4, 1, 4, 4, 0, 1, 1, 1, 3, 3,
+ 1, 4, 2, 2, 1, 3, 1, 4, 3, 3,
+ 3, 3, 1, 3, 1, 1, 3, 1, 1, 4,
+ 1, 1, 1, 3, 1, 1, 2, 1, 3, 4,
+ 3, 2, 0, 2, 2, 1, 2, 1, 1, 1,
+ 4, 3, 3, 3, 3, 6, 3, 1, 1, 2,
+ 1
+ );
+
+ protected function initReduceCallbacks(): void {
+ $this->reduceCallbacks = [
+ 0 => null,
+ 1 => static function ($self, $stackPos) {
+ $self->semValue = $self->handleNamespaces($self->semStack[$stackPos-(1-1)]);
+ },
+ 2 => static function ($self, $stackPos) {
+ if ($self->semStack[$stackPos-(2-2)] !== null) { $self->semStack[$stackPos-(2-1)][] = $self->semStack[$stackPos-(2-2)]; } $self->semValue = $self->semStack[$stackPos-(2-1)];;
+ },
+ 3 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 4 => static function ($self, $stackPos) {
+ $nop = $self->maybeCreateZeroLengthNop($self->tokenPos);;
+ if ($nop !== null) { $self->semStack[$stackPos-(1-1)][] = $nop; } $self->semValue = $self->semStack[$stackPos-(1-1)];
+ },
+ 5 => null,
+ 6 => null,
+ 7 => null,
+ 8 => null,
+ 9 => null,
+ 10 => null,
+ 11 => null,
+ 12 => null,
+ 13 => null,
+ 14 => null,
+ 15 => null,
+ 16 => null,
+ 17 => null,
+ 18 => null,
+ 19 => null,
+ 20 => null,
+ 21 => null,
+ 22 => null,
+ 23 => null,
+ 24 => null,
+ 25 => null,
+ 26 => null,
+ 27 => null,
+ 28 => null,
+ 29 => null,
+ 30 => null,
+ 31 => null,
+ 32 => null,
+ 33 => null,
+ 34 => null,
+ 35 => null,
+ 36 => null,
+ 37 => null,
+ 38 => null,
+ 39 => null,
+ 40 => null,
+ 41 => null,
+ 42 => null,
+ 43 => null,
+ 44 => null,
+ 45 => null,
+ 46 => null,
+ 47 => null,
+ 48 => null,
+ 49 => null,
+ 50 => null,
+ 51 => null,
+ 52 => null,
+ 53 => null,
+ 54 => null,
+ 55 => null,
+ 56 => null,
+ 57 => null,
+ 58 => null,
+ 59 => null,
+ 60 => null,
+ 61 => null,
+ 62 => null,
+ 63 => null,
+ 64 => null,
+ 65 => null,
+ 66 => null,
+ 67 => null,
+ 68 => null,
+ 69 => null,
+ 70 => null,
+ 71 => null,
+ 72 => null,
+ 73 => null,
+ 74 => null,
+ 75 => null,
+ 76 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(1-1)]; if ($self->semValue === "emitError(new Error('Cannot use "getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos])));
+ },
+ 77 => null,
+ 78 => null,
+ 79 => null,
+ 80 => null,
+ 81 => null,
+ 82 => null,
+ 83 => null,
+ 84 => null,
+ 85 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Identifier($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 86 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Identifier($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 87 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Identifier($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 88 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Identifier($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 89 => static function ($self, $stackPos) {
+ $self->semValue = new Name($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 90 => static function ($self, $stackPos) {
+ $self->semValue = new Name($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 91 => static function ($self, $stackPos) {
+ $self->semValue = new Name($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 92 => static function ($self, $stackPos) {
+ $self->semValue = new Name($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 93 => static function ($self, $stackPos) {
+ $self->semValue = new Name($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 94 => null,
+ 95 => static function ($self, $stackPos) {
+ $self->semValue = new Name(substr($self->semStack[$stackPos-(1-1)], 1), $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 96 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Variable(substr($self->semStack[$stackPos-(1-1)], 1), $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 97 => static function ($self, $stackPos) {
+ /* nothing */
+ },
+ 98 => static function ($self, $stackPos) {
+ /* nothing */
+ },
+ 99 => static function ($self, $stackPos) {
+ /* nothing */
+ },
+ 100 => static function ($self, $stackPos) {
+ $self->emitError(new Error('A trailing comma is not allowed here', $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos])));
+ },
+ 101 => null,
+ 102 => null,
+ 103 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Attribute($self->semStack[$stackPos-(1-1)], [], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 104 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Attribute($self->semStack[$stackPos-(2-1)], $self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 105 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 106 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 107 => static function ($self, $stackPos) {
+ $self->semValue = new Node\AttributeGroup($self->semStack[$stackPos-(4-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 108 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 109 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(2-1)][] = $self->semStack[$stackPos-(2-2)]; $self->semValue = $self->semStack[$stackPos-(2-1)];
+ },
+ 110 => static function ($self, $stackPos) {
+ $self->semValue = [];
+ },
+ 111 => null,
+ 112 => null,
+ 113 => null,
+ 114 => null,
+ 115 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\HaltCompiler($self->handleHaltCompiler(), $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 116 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Namespace_($self->semStack[$stackPos-(3-2)], null, $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ $self->semValue->setAttribute('kind', Stmt\Namespace_::KIND_SEMICOLON);
+ $self->checkNamespace($self->semValue);
+ },
+ 117 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Namespace_($self->semStack[$stackPos-(5-2)], $self->semStack[$stackPos-(5-4)], $self->getAttributes($self->tokenStartStack[$stackPos-(5-1)], $self->tokenEndStack[$stackPos]));
+ $self->semValue->setAttribute('kind', Stmt\Namespace_::KIND_BRACED);
+ $self->checkNamespace($self->semValue);
+ },
+ 118 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Namespace_(null, $self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ $self->semValue->setAttribute('kind', Stmt\Namespace_::KIND_BRACED);
+ $self->checkNamespace($self->semValue);
+ },
+ 119 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Use_($self->semStack[$stackPos-(3-2)], Stmt\Use_::TYPE_NORMAL, $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 120 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Use_($self->semStack[$stackPos-(4-3)], $self->semStack[$stackPos-(4-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 121 => null,
+ 122 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Const_($self->semStack[$stackPos-(3-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]), []);
+ },
+ 123 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Const_($self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]), $self->semStack[$stackPos-(4-1)]);
+ $self->checkConstantAttributes($self->semValue);
+ },
+ 124 => static function ($self, $stackPos) {
+ $self->semValue = Stmt\Use_::TYPE_FUNCTION;
+ },
+ 125 => static function ($self, $stackPos) {
+ $self->semValue = Stmt\Use_::TYPE_CONSTANT;
+ },
+ 126 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\GroupUse($self->semStack[$stackPos-(8-3)], $self->semStack[$stackPos-(8-6)], $self->semStack[$stackPos-(8-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(8-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 127 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\GroupUse($self->semStack[$stackPos-(7-2)], $self->semStack[$stackPos-(7-5)], Stmt\Use_::TYPE_UNKNOWN, $self->getAttributes($self->tokenStartStack[$stackPos-(7-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 128 => null,
+ 129 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 130 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 131 => null,
+ 132 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 133 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 134 => null,
+ 135 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 136 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 137 => static function ($self, $stackPos) {
+ $self->semValue = new Node\UseItem($self->semStack[$stackPos-(1-1)], null, Stmt\Use_::TYPE_UNKNOWN, $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos])); $self->checkUseUse($self->semValue, $stackPos-(1-1));
+ },
+ 138 => static function ($self, $stackPos) {
+ $self->semValue = new Node\UseItem($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], Stmt\Use_::TYPE_UNKNOWN, $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos])); $self->checkUseUse($self->semValue, $stackPos-(3-3));
+ },
+ 139 => static function ($self, $stackPos) {
+ $self->semValue = new Node\UseItem($self->semStack[$stackPos-(1-1)], null, Stmt\Use_::TYPE_UNKNOWN, $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos])); $self->checkUseUse($self->semValue, $stackPos-(1-1));
+ },
+ 140 => static function ($self, $stackPos) {
+ $self->semValue = new Node\UseItem($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], Stmt\Use_::TYPE_UNKNOWN, $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos])); $self->checkUseUse($self->semValue, $stackPos-(3-3));
+ },
+ 141 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(1-1)]; $self->semValue->type = Stmt\Use_::TYPE_NORMAL;
+ },
+ 142 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(2-2)]; $self->semValue->type = $self->semStack[$stackPos-(2-1)];
+ },
+ 143 => null,
+ 144 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 145 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 146 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Const_($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 147 => null,
+ 148 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 149 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 150 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Const_(new Node\Identifier($self->semStack[$stackPos-(3-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos-(3-1)])), $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 151 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Const_(new Node\Identifier($self->semStack[$stackPos-(3-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos-(3-1)])), $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 152 => static function ($self, $stackPos) {
+ if ($self->semStack[$stackPos-(2-2)] !== null) { $self->semStack[$stackPos-(2-1)][] = $self->semStack[$stackPos-(2-2)]; } $self->semValue = $self->semStack[$stackPos-(2-1)];;
+ },
+ 153 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 154 => static function ($self, $stackPos) {
+ $nop = $self->maybeCreateZeroLengthNop($self->tokenPos);;
+ if ($nop !== null) { $self->semStack[$stackPos-(1-1)][] = $nop; } $self->semValue = $self->semStack[$stackPos-(1-1)];
+ },
+ 155 => null,
+ 156 => null,
+ 157 => null,
+ 158 => static function ($self, $stackPos) {
+ throw new Error('__HALT_COMPILER() can only be used from the outermost scope', $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 159 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Block($self->semStack[$stackPos-(3-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 160 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\If_($self->semStack[$stackPos-(7-3)], ['stmts' => $self->semStack[$stackPos-(7-5)], 'elseifs' => $self->semStack[$stackPos-(7-6)], 'else' => $self->semStack[$stackPos-(7-7)]], $self->getAttributes($self->tokenStartStack[$stackPos-(7-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 161 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\If_($self->semStack[$stackPos-(10-3)], ['stmts' => $self->semStack[$stackPos-(10-6)], 'elseifs' => $self->semStack[$stackPos-(10-7)], 'else' => $self->semStack[$stackPos-(10-8)]], $self->getAttributes($self->tokenStartStack[$stackPos-(10-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 162 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\While_($self->semStack[$stackPos-(5-3)], $self->semStack[$stackPos-(5-5)], $self->getAttributes($self->tokenStartStack[$stackPos-(5-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 163 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Do_($self->semStack[$stackPos-(7-5)], $self->semStack[$stackPos-(7-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(7-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 164 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\For_(['init' => $self->semStack[$stackPos-(9-3)], 'cond' => $self->semStack[$stackPos-(9-5)], 'loop' => $self->semStack[$stackPos-(9-7)], 'stmts' => $self->semStack[$stackPos-(9-9)]], $self->getAttributes($self->tokenStartStack[$stackPos-(9-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 165 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Switch_($self->semStack[$stackPos-(5-3)], $self->semStack[$stackPos-(5-5)], $self->getAttributes($self->tokenStartStack[$stackPos-(5-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 166 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Break_($self->semStack[$stackPos-(3-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 167 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Continue_($self->semStack[$stackPos-(3-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 168 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Return_($self->semStack[$stackPos-(3-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 169 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Global_($self->semStack[$stackPos-(3-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 170 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Static_($self->semStack[$stackPos-(3-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 171 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Echo_($self->semStack[$stackPos-(3-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 172 => static function ($self, $stackPos) {
+
+ $self->semValue = new Stmt\InlineHTML($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ $self->semValue->setAttribute('hasLeadingNewline', $self->inlineHtmlHasLeadingNewline($stackPos-(1-1)));
+
+ },
+ 173 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Expression($self->semStack[$stackPos-(2-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 174 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Unset_($self->semStack[$stackPos-(5-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(5-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 175 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Foreach_($self->semStack[$stackPos-(7-3)], $self->semStack[$stackPos-(7-5)][0], ['keyVar' => null, 'byRef' => $self->semStack[$stackPos-(7-5)][1], 'stmts' => $self->semStack[$stackPos-(7-7)]], $self->getAttributes($self->tokenStartStack[$stackPos-(7-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 176 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Foreach_($self->semStack[$stackPos-(9-3)], $self->semStack[$stackPos-(9-7)][0], ['keyVar' => $self->semStack[$stackPos-(9-5)], 'byRef' => $self->semStack[$stackPos-(9-7)][1], 'stmts' => $self->semStack[$stackPos-(9-9)]], $self->getAttributes($self->tokenStartStack[$stackPos-(9-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 177 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Foreach_($self->semStack[$stackPos-(6-3)], new Expr\Error($self->getAttributes($self->tokenStartStack[$stackPos-(6-4)], $self->tokenEndStack[$stackPos-(6-4)])), ['stmts' => $self->semStack[$stackPos-(6-6)]], $self->getAttributes($self->tokenStartStack[$stackPos-(6-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 178 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Declare_($self->semStack[$stackPos-(5-3)], $self->semStack[$stackPos-(5-5)], $self->getAttributes($self->tokenStartStack[$stackPos-(5-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 179 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\TryCatch($self->semStack[$stackPos-(6-3)], $self->semStack[$stackPos-(6-5)], $self->semStack[$stackPos-(6-6)], $self->getAttributes($self->tokenStartStack[$stackPos-(6-1)], $self->tokenEndStack[$stackPos])); $self->checkTryCatch($self->semValue);
+ },
+ 180 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Goto_($self->semStack[$stackPos-(3-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 181 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Label($self->semStack[$stackPos-(2-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 182 => static function ($self, $stackPos) {
+ $self->semValue = null; /* means: no statement */
+ },
+ 183 => null,
+ 184 => static function ($self, $stackPos) {
+ $self->semValue = $self->maybeCreateNop($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]);
+ },
+ 185 => static function ($self, $stackPos) {
+ if ($self->semStack[$stackPos-(1-1)] instanceof Stmt\Block) { $self->semValue = $self->semStack[$stackPos-(1-1)]->stmts; } else if ($self->semStack[$stackPos-(1-1)] === null) { $self->semValue = []; } else { $self->semValue = [$self->semStack[$stackPos-(1-1)]]; };
+ },
+ 186 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 187 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(2-1)][] = $self->semStack[$stackPos-(2-2)]; $self->semValue = $self->semStack[$stackPos-(2-1)];
+ },
+ 188 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 189 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 190 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Catch_($self->semStack[$stackPos-(8-3)], $self->semStack[$stackPos-(8-4)], $self->semStack[$stackPos-(8-7)], $self->getAttributes($self->tokenStartStack[$stackPos-(8-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 191 => static function ($self, $stackPos) {
+ $self->semValue = null;
+ },
+ 192 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Finally_($self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 193 => null,
+ 194 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 195 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 196 => static function ($self, $stackPos) {
+ $self->semValue = false;
+ },
+ 197 => static function ($self, $stackPos) {
+ $self->semValue = true;
+ },
+ 198 => static function ($self, $stackPos) {
+ $self->semValue = false;
+ },
+ 199 => static function ($self, $stackPos) {
+ $self->semValue = true;
+ },
+ 200 => static function ($self, $stackPos) {
+ $self->semValue = false;
+ },
+ 201 => static function ($self, $stackPos) {
+ $self->semValue = true;
+ },
+ 202 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(3-2)];
+ },
+ 203 => static function ($self, $stackPos) {
+ $self->semValue = [];
+ },
+ 204 => null,
+ 205 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Identifier($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 206 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Identifier($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 207 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Identifier($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 208 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Function_($self->semStack[$stackPos-(8-3)], ['byRef' => $self->semStack[$stackPos-(8-2)], 'params' => $self->semStack[$stackPos-(8-5)], 'returnType' => $self->semStack[$stackPos-(8-7)], 'stmts' => $self->semStack[$stackPos-(8-8)], 'attrGroups' => []], $self->getAttributes($self->tokenStartStack[$stackPos-(8-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 209 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Function_($self->semStack[$stackPos-(9-4)], ['byRef' => $self->semStack[$stackPos-(9-3)], 'params' => $self->semStack[$stackPos-(9-6)], 'returnType' => $self->semStack[$stackPos-(9-8)], 'stmts' => $self->semStack[$stackPos-(9-9)], 'attrGroups' => $self->semStack[$stackPos-(9-1)]], $self->getAttributes($self->tokenStartStack[$stackPos-(9-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 210 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Class_($self->semStack[$stackPos-(7-2)], ['type' => $self->semStack[$stackPos-(7-1)], 'extends' => $self->semStack[$stackPos-(7-3)], 'implements' => $self->semStack[$stackPos-(7-4)], 'stmts' => $self->semStack[$stackPos-(7-6)], 'attrGroups' => []], $self->getAttributes($self->tokenStartStack[$stackPos-(7-1)], $self->tokenEndStack[$stackPos]));
+ $self->checkClass($self->semValue, $stackPos-(7-2));
+ },
+ 211 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Class_($self->semStack[$stackPos-(8-3)], ['type' => $self->semStack[$stackPos-(8-2)], 'extends' => $self->semStack[$stackPos-(8-4)], 'implements' => $self->semStack[$stackPos-(8-5)], 'stmts' => $self->semStack[$stackPos-(8-7)], 'attrGroups' => $self->semStack[$stackPos-(8-1)]], $self->getAttributes($self->tokenStartStack[$stackPos-(8-1)], $self->tokenEndStack[$stackPos]));
+ $self->checkClass($self->semValue, $stackPos-(8-3));
+ },
+ 212 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Interface_($self->semStack[$stackPos-(7-3)], ['extends' => $self->semStack[$stackPos-(7-4)], 'stmts' => $self->semStack[$stackPos-(7-6)], 'attrGroups' => $self->semStack[$stackPos-(7-1)]], $self->getAttributes($self->tokenStartStack[$stackPos-(7-1)], $self->tokenEndStack[$stackPos]));
+ $self->checkInterface($self->semValue, $stackPos-(7-3));
+ },
+ 213 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Trait_($self->semStack[$stackPos-(6-3)], ['stmts' => $self->semStack[$stackPos-(6-5)], 'attrGroups' => $self->semStack[$stackPos-(6-1)]], $self->getAttributes($self->tokenStartStack[$stackPos-(6-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 214 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Enum_($self->semStack[$stackPos-(8-3)], ['scalarType' => $self->semStack[$stackPos-(8-4)], 'implements' => $self->semStack[$stackPos-(8-5)], 'stmts' => $self->semStack[$stackPos-(8-7)], 'attrGroups' => $self->semStack[$stackPos-(8-1)]], $self->getAttributes($self->tokenStartStack[$stackPos-(8-1)], $self->tokenEndStack[$stackPos]));
+ $self->checkEnum($self->semValue, $stackPos-(8-3));
+ },
+ 215 => static function ($self, $stackPos) {
+ $self->semValue = null;
+ },
+ 216 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(2-2)];
+ },
+ 217 => static function ($self, $stackPos) {
+ $self->semValue = null;
+ },
+ 218 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(2-2)];
+ },
+ 219 => static function ($self, $stackPos) {
+ $self->semValue = 0;
+ },
+ 220 => null,
+ 221 => null,
+ 222 => static function ($self, $stackPos) {
+ $self->checkClassModifier($self->semStack[$stackPos-(2-1)], $self->semStack[$stackPos-(2-2)], $stackPos-(2-2)); $self->semValue = $self->semStack[$stackPos-(2-1)] | $self->semStack[$stackPos-(2-2)];
+ },
+ 223 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::ABSTRACT;
+ },
+ 224 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::FINAL;
+ },
+ 225 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::READONLY;
+ },
+ 226 => static function ($self, $stackPos) {
+ $self->semValue = null;
+ },
+ 227 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(2-2)];
+ },
+ 228 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 229 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(2-2)];
+ },
+ 230 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 231 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(2-2)];
+ },
+ 232 => null,
+ 233 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 234 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 235 => null,
+ 236 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(4-2)];
+ },
+ 237 => null,
+ 238 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(4-2)];
+ },
+ 239 => static function ($self, $stackPos) {
+ if ($self->semStack[$stackPos-(1-1)] instanceof Stmt\Block) { $self->semValue = $self->semStack[$stackPos-(1-1)]->stmts; } else if ($self->semStack[$stackPos-(1-1)] === null) { $self->semValue = []; } else { $self->semValue = [$self->semStack[$stackPos-(1-1)]]; };
+ },
+ 240 => static function ($self, $stackPos) {
+ $self->semValue = null;
+ },
+ 241 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(4-2)];
+ },
+ 242 => null,
+ 243 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 244 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 245 => static function ($self, $stackPos) {
+ $self->semValue = new Node\DeclareItem($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 246 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(3-2)];
+ },
+ 247 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(4-3)];
+ },
+ 248 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(4-2)];
+ },
+ 249 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(5-3)];
+ },
+ 250 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 251 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(2-1)][] = $self->semStack[$stackPos-(2-2)]; $self->semValue = $self->semStack[$stackPos-(2-1)];
+ },
+ 252 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Case_($self->semStack[$stackPos-(4-2)], $self->semStack[$stackPos-(4-4)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 253 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Case_(null, $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 254 => null,
+ 255 => null,
+ 256 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Match_($self->semStack[$stackPos-(7-3)], $self->semStack[$stackPos-(7-6)], $self->getAttributes($self->tokenStartStack[$stackPos-(7-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 257 => static function ($self, $stackPos) {
+ $self->semValue = [];
+ },
+ 258 => null,
+ 259 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 260 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 261 => static function ($self, $stackPos) {
+ $self->semValue = new Node\MatchArm($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 262 => static function ($self, $stackPos) {
+ $self->semValue = new Node\MatchArm(null, $self->semStack[$stackPos-(4-4)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 263 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(1-1)];
+ },
+ 264 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(4-2)];
+ },
+ 265 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 266 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(2-1)][] = $self->semStack[$stackPos-(2-2)]; $self->semValue = $self->semStack[$stackPos-(2-1)];
+ },
+ 267 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\ElseIf_($self->semStack[$stackPos-(5-3)], $self->semStack[$stackPos-(5-5)], $self->getAttributes($self->tokenStartStack[$stackPos-(5-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 268 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 269 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(2-1)][] = $self->semStack[$stackPos-(2-2)]; $self->semValue = $self->semStack[$stackPos-(2-1)];
+ },
+ 270 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\ElseIf_($self->semStack[$stackPos-(6-3)], $self->semStack[$stackPos-(6-6)], $self->getAttributes($self->tokenStartStack[$stackPos-(6-1)], $self->tokenEndStack[$stackPos])); $self->fixupAlternativeElse($self->semValue);
+ },
+ 271 => static function ($self, $stackPos) {
+ $self->semValue = null;
+ },
+ 272 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Else_($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 273 => static function ($self, $stackPos) {
+ $self->semValue = null;
+ },
+ 274 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Else_($self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos])); $self->fixupAlternativeElse($self->semValue);
+ },
+ 275 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)], false);
+ },
+ 276 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(2-2)], true);
+ },
+ 277 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)], false);
+ },
+ 278 => static function ($self, $stackPos) {
+ $self->semValue = array($self->fixupArrayDestructuring($self->semStack[$stackPos-(1-1)]), false);
+ },
+ 279 => null,
+ 280 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 281 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 282 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 283 => static function ($self, $stackPos) {
+ $self->semValue = 0;
+ },
+ 284 => static function ($self, $stackPos) {
+ $self->checkModifier($self->semStack[$stackPos-(2-1)], $self->semStack[$stackPos-(2-2)], $stackPos-(2-2)); $self->semValue = $self->semStack[$stackPos-(2-1)] | $self->semStack[$stackPos-(2-2)];
+ },
+ 285 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::PUBLIC;
+ },
+ 286 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::PROTECTED;
+ },
+ 287 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::PRIVATE;
+ },
+ 288 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::PUBLIC_SET;
+ },
+ 289 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::PROTECTED_SET;
+ },
+ 290 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::PRIVATE_SET;
+ },
+ 291 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::READONLY;
+ },
+ 292 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::FINAL;
+ },
+ 293 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Param($self->semStack[$stackPos-(7-6)], null, $self->semStack[$stackPos-(7-3)], $self->semStack[$stackPos-(7-4)], $self->semStack[$stackPos-(7-5)], $self->getAttributes($self->tokenStartStack[$stackPos-(7-1)], $self->tokenEndStack[$stackPos]), $self->semStack[$stackPos-(7-2)], $self->semStack[$stackPos-(7-1)], $self->semStack[$stackPos-(7-7)]);
+ $self->checkParam($self->semValue);
+ $self->addPropertyNameToHooks($self->semValue);
+ },
+ 294 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Param($self->semStack[$stackPos-(9-6)], $self->semStack[$stackPos-(9-8)], $self->semStack[$stackPos-(9-3)], $self->semStack[$stackPos-(9-4)], $self->semStack[$stackPos-(9-5)], $self->getAttributes($self->tokenStartStack[$stackPos-(9-1)], $self->tokenEndStack[$stackPos]), $self->semStack[$stackPos-(9-2)], $self->semStack[$stackPos-(9-1)], $self->semStack[$stackPos-(9-9)]);
+ $self->checkParam($self->semValue);
+ $self->addPropertyNameToHooks($self->semValue);
+ },
+ 295 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Param(new Expr\Error($self->getAttributes($self->tokenStartStack[$stackPos-(6-1)], $self->tokenEndStack[$stackPos])), null, $self->semStack[$stackPos-(6-3)], $self->semStack[$stackPos-(6-4)], $self->semStack[$stackPos-(6-5)], $self->getAttributes($self->tokenStartStack[$stackPos-(6-1)], $self->tokenEndStack[$stackPos]), $self->semStack[$stackPos-(6-2)], $self->semStack[$stackPos-(6-1)]);
+ },
+ 296 => null,
+ 297 => static function ($self, $stackPos) {
+ $self->semValue = new Node\NullableType($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 298 => static function ($self, $stackPos) {
+ $self->semValue = new Node\UnionType($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 299 => null,
+ 300 => null,
+ 301 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Name('static', $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 302 => static function ($self, $stackPos) {
+ $self->semValue = $self->handleBuiltinTypes($self->semStack[$stackPos-(1-1)]);
+ },
+ 303 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Identifier('array', $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 304 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Identifier('callable', $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 305 => null,
+ 306 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(3-2)];
+ },
+ 307 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)]);
+ },
+ 308 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 309 => null,
+ 310 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(3-2)];
+ },
+ 311 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)]);
+ },
+ 312 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 313 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)]);
+ },
+ 314 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 315 => static function ($self, $stackPos) {
+ $self->semValue = new Node\IntersectionType($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 316 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)]);
+ },
+ 317 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 318 => static function ($self, $stackPos) {
+ $self->semValue = new Node\IntersectionType($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 319 => null,
+ 320 => static function ($self, $stackPos) {
+ $self->semValue = new Node\NullableType($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 321 => static function ($self, $stackPos) {
+ $self->semValue = new Node\UnionType($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 322 => null,
+ 323 => static function ($self, $stackPos) {
+ $self->semValue = null;
+ },
+ 324 => null,
+ 325 => static function ($self, $stackPos) {
+ $self->semValue = null;
+ },
+ 326 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(2-2)];
+ },
+ 327 => static function ($self, $stackPos) {
+ $self->semValue = null;
+ },
+ 328 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 329 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(4-2)];
+ },
+ 330 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(3-2)]);
+ },
+ 331 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 332 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(4-2)];
+ },
+ 333 => static function ($self, $stackPos) {
+ $self->semValue = array(new Node\Arg($self->semStack[$stackPos-(4-2)], false, false, $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos])));
+ },
+ 334 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(3-2)]);
+ },
+ 335 => static function ($self, $stackPos) {
+ $self->semValue = array(new Node\Arg($self->semStack[$stackPos-(3-1)], false, false, $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos-(3-1)])), $self->semStack[$stackPos-(3-3)]);
+ },
+ 336 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 337 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 338 => static function ($self, $stackPos) {
+ $self->semValue = new Node\VariadicPlaceholder($self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 339 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 340 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 341 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Arg($self->semStack[$stackPos-(2-2)], true, false, $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 342 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Arg($self->semStack[$stackPos-(2-2)], false, true, $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 343 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Arg($self->semStack[$stackPos-(3-3)], false, false, $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]), $self->semStack[$stackPos-(3-1)]);
+ },
+ 344 => static function ($self, $stackPos) {
+ $self->semValue = new Node\Arg($self->semStack[$stackPos-(1-1)], false, false, $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 345 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(1-1)];
+ },
+ 346 => null,
+ 347 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 348 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 349 => null,
+ 350 => null,
+ 351 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 352 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 353 => static function ($self, $stackPos) {
+ $self->semValue = new Node\StaticVar($self->semStack[$stackPos-(1-1)], null, $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 354 => static function ($self, $stackPos) {
+ $self->semValue = new Node\StaticVar($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 355 => static function ($self, $stackPos) {
+ if ($self->semStack[$stackPos-(2-2)] !== null) { $self->semStack[$stackPos-(2-1)][] = $self->semStack[$stackPos-(2-2)]; $self->semValue = $self->semStack[$stackPos-(2-1)]; } else { $self->semValue = $self->semStack[$stackPos-(2-1)]; }
+ },
+ 356 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 357 => static function ($self, $stackPos) {
+ $nop = $self->maybeCreateZeroLengthNop($self->tokenPos);;
+ if ($nop !== null) { $self->semStack[$stackPos-(1-1)][] = $nop; } $self->semValue = $self->semStack[$stackPos-(1-1)];
+ },
+ 358 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Property($self->semStack[$stackPos-(5-2)], $self->semStack[$stackPos-(5-4)], $self->getAttributes($self->tokenStartStack[$stackPos-(5-1)], $self->tokenEndStack[$stackPos]), $self->semStack[$stackPos-(5-3)], $self->semStack[$stackPos-(5-1)]);
+ },
+ 359 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\Property($self->semStack[$stackPos-(7-2)], $self->semStack[$stackPos-(7-4)], $self->getAttributes($self->tokenStartStack[$stackPos-(7-1)], $self->tokenEndStack[$stackPos]), $self->semStack[$stackPos-(7-3)], $self->semStack[$stackPos-(7-1)], $self->semStack[$stackPos-(7-6)]);
+ $self->checkPropertyHooksForMultiProperty($self->semValue, $stackPos-(7-5));
+ $self->checkEmptyPropertyHookList($self->semStack[$stackPos-(7-6)], $stackPos-(7-5));
+ $self->addPropertyNameToHooks($self->semValue);
+ },
+ 360 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\ClassConst($self->semStack[$stackPos-(5-4)], $self->semStack[$stackPos-(5-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(5-1)], $self->tokenEndStack[$stackPos]), $self->semStack[$stackPos-(5-1)]);
+ $self->checkClassConst($self->semValue, $stackPos-(5-2));
+ },
+ 361 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\ClassConst($self->semStack[$stackPos-(6-5)], $self->semStack[$stackPos-(6-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(6-1)], $self->tokenEndStack[$stackPos]), $self->semStack[$stackPos-(6-1)], $self->semStack[$stackPos-(6-4)]);
+ $self->checkClassConst($self->semValue, $stackPos-(6-2));
+ },
+ 362 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\ClassMethod($self->semStack[$stackPos-(10-5)], ['type' => $self->semStack[$stackPos-(10-2)], 'byRef' => $self->semStack[$stackPos-(10-4)], 'params' => $self->semStack[$stackPos-(10-7)], 'returnType' => $self->semStack[$stackPos-(10-9)], 'stmts' => $self->semStack[$stackPos-(10-10)], 'attrGroups' => $self->semStack[$stackPos-(10-1)]], $self->getAttributes($self->tokenStartStack[$stackPos-(10-1)], $self->tokenEndStack[$stackPos]));
+ $self->checkClassMethod($self->semValue, $stackPos-(10-2));
+ },
+ 363 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\TraitUse($self->semStack[$stackPos-(3-2)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 364 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\EnumCase($self->semStack[$stackPos-(5-3)], $self->semStack[$stackPos-(5-4)], $self->semStack[$stackPos-(5-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(5-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 365 => static function ($self, $stackPos) {
+ $self->semValue = null; /* will be skipped */
+ },
+ 366 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 367 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(3-2)];
+ },
+ 368 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 369 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(2-1)][] = $self->semStack[$stackPos-(2-2)]; $self->semValue = $self->semStack[$stackPos-(2-1)];
+ },
+ 370 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\TraitUseAdaptation\Precedence($self->semStack[$stackPos-(4-1)][0], $self->semStack[$stackPos-(4-1)][1], $self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 371 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\TraitUseAdaptation\Alias($self->semStack[$stackPos-(5-1)][0], $self->semStack[$stackPos-(5-1)][1], $self->semStack[$stackPos-(5-3)], $self->semStack[$stackPos-(5-4)], $self->getAttributes($self->tokenStartStack[$stackPos-(5-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 372 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\TraitUseAdaptation\Alias($self->semStack[$stackPos-(4-1)][0], $self->semStack[$stackPos-(4-1)][1], $self->semStack[$stackPos-(4-3)], null, $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 373 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\TraitUseAdaptation\Alias($self->semStack[$stackPos-(4-1)][0], $self->semStack[$stackPos-(4-1)][1], null, $self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 374 => static function ($self, $stackPos) {
+ $self->semValue = new Stmt\TraitUseAdaptation\Alias($self->semStack[$stackPos-(4-1)][0], $self->semStack[$stackPos-(4-1)][1], null, $self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 375 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)]);
+ },
+ 376 => null,
+ 377 => static function ($self, $stackPos) {
+ $self->semValue = array(null, $self->semStack[$stackPos-(1-1)]);
+ },
+ 378 => static function ($self, $stackPos) {
+ $self->semValue = null;
+ },
+ 379 => null,
+ 380 => null,
+ 381 => static function ($self, $stackPos) {
+ $self->semValue = 0;
+ },
+ 382 => static function ($self, $stackPos) {
+ $self->semValue = 0;
+ },
+ 383 => null,
+ 384 => null,
+ 385 => static function ($self, $stackPos) {
+ $self->checkModifier($self->semStack[$stackPos-(2-1)], $self->semStack[$stackPos-(2-2)], $stackPos-(2-2)); $self->semValue = $self->semStack[$stackPos-(2-1)] | $self->semStack[$stackPos-(2-2)];
+ },
+ 386 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::PUBLIC;
+ },
+ 387 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::PROTECTED;
+ },
+ 388 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::PRIVATE;
+ },
+ 389 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::PUBLIC_SET;
+ },
+ 390 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::PROTECTED_SET;
+ },
+ 391 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::PRIVATE_SET;
+ },
+ 392 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::STATIC;
+ },
+ 393 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::ABSTRACT;
+ },
+ 394 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::FINAL;
+ },
+ 395 => static function ($self, $stackPos) {
+ $self->semValue = Modifiers::READONLY;
+ },
+ 396 => null,
+ 397 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 398 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 399 => static function ($self, $stackPos) {
+ $self->semValue = new Node\VarLikeIdentifier(substr($self->semStack[$stackPos-(1-1)], 1), $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 400 => static function ($self, $stackPos) {
+ $self->semValue = new Node\PropertyItem($self->semStack[$stackPos-(1-1)], null, $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 401 => static function ($self, $stackPos) {
+ $self->semValue = new Node\PropertyItem($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 402 => static function ($self, $stackPos) {
+ $self->semValue = [];
+ },
+ 403 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(2-1)][] = $self->semStack[$stackPos-(2-2)]; $self->semValue = $self->semStack[$stackPos-(2-1)];
+ },
+ 404 => static function ($self, $stackPos) {
+ $self->semValue = [];
+ },
+ 405 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(3-2)]; $self->checkEmptyPropertyHookList($self->semStack[$stackPos-(3-2)], $stackPos-(3-1));
+ },
+ 406 => static function ($self, $stackPos) {
+ $self->semValue = new Node\PropertyHook($self->semStack[$stackPos-(5-4)], $self->semStack[$stackPos-(5-5)], ['flags' => $self->semStack[$stackPos-(5-2)], 'byRef' => $self->semStack[$stackPos-(5-3)], 'params' => [], 'attrGroups' => $self->semStack[$stackPos-(5-1)]], $self->getAttributes($self->tokenStartStack[$stackPos-(5-1)], $self->tokenEndStack[$stackPos]));
+ $self->checkPropertyHook($self->semValue, null);
+ },
+ 407 => static function ($self, $stackPos) {
+ $self->semValue = new Node\PropertyHook($self->semStack[$stackPos-(8-4)], $self->semStack[$stackPos-(8-8)], ['flags' => $self->semStack[$stackPos-(8-2)], 'byRef' => $self->semStack[$stackPos-(8-3)], 'params' => $self->semStack[$stackPos-(8-6)], 'attrGroups' => $self->semStack[$stackPos-(8-1)]], $self->getAttributes($self->tokenStartStack[$stackPos-(8-1)], $self->tokenEndStack[$stackPos]));
+ $self->checkPropertyHook($self->semValue, $stackPos-(8-5));
+ },
+ 408 => static function ($self, $stackPos) {
+ $self->semValue = null;
+ },
+ 409 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(3-2)];
+ },
+ 410 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(3-2)];
+ },
+ 411 => static function ($self, $stackPos) {
+ $self->semValue = 0;
+ },
+ 412 => static function ($self, $stackPos) {
+ $self->checkPropertyHookModifiers($self->semStack[$stackPos-(2-1)], $self->semStack[$stackPos-(2-2)], $stackPos-(2-2)); $self->semValue = $self->semStack[$stackPos-(2-1)] | $self->semStack[$stackPos-(2-2)];
+ },
+ 413 => null,
+ 414 => null,
+ 415 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 416 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 417 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 418 => null,
+ 419 => null,
+ 420 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Assign($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 421 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Assign($self->fixupArrayDestructuring($self->semStack[$stackPos-(3-1)]), $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 422 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Assign($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 423 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignRef($self->semStack[$stackPos-(4-1)], $self->semStack[$stackPos-(4-4)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 424 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignRef($self->semStack[$stackPos-(4-1)], $self->semStack[$stackPos-(4-4)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ if (!$self->phpVersion->allowsAssignNewByReference()) {
+ $self->emitError(new Error('Cannot assign new by reference', $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos])));
+ }
+
+ },
+ 425 => null,
+ 426 => null,
+ 427 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\FuncCall(new Node\Name($self->semStack[$stackPos-(2-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos-(2-1)])), $self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 428 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Clone_($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 429 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignOp\Plus($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 430 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignOp\Minus($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 431 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignOp\Mul($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 432 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignOp\Div($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 433 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignOp\Concat($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 434 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignOp\Mod($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 435 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignOp\BitwiseAnd($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 436 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignOp\BitwiseOr($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 437 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignOp\BitwiseXor($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 438 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignOp\ShiftLeft($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 439 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignOp\ShiftRight($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 440 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignOp\Pow($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 441 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\AssignOp\Coalesce($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 442 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\PostInc($self->semStack[$stackPos-(2-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 443 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\PreInc($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 444 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\PostDec($self->semStack[$stackPos-(2-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 445 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\PreDec($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 446 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\BooleanOr($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 447 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\BooleanAnd($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 448 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\LogicalOr($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 449 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\LogicalAnd($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 450 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\LogicalXor($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 451 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\BitwiseOr($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 452 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\BitwiseAnd($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 453 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\BitwiseAnd($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 454 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\BitwiseXor($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 455 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\Concat($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 456 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\Plus($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 457 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\Minus($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 458 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\Mul($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 459 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\Div($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 460 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\Mod($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 461 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\ShiftLeft($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 462 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\ShiftRight($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 463 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\Pow($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 464 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\UnaryPlus($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 465 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\UnaryMinus($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 466 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BooleanNot($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 467 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BitwiseNot($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 468 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\Identical($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 469 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\NotIdentical($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 470 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\Equal($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 471 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\NotEqual($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 472 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\Spaceship($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 473 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\Smaller($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 474 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\SmallerOrEqual($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 475 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\Greater($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 476 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\GreaterOrEqual($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 477 => static function ($self, $stackPos) {
+
+ $self->semValue = new Expr\BinaryOp\Pipe($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ $self->checkPipeOperatorParentheses($self->semStack[$stackPos-(3-3)]);
+
+ },
+ 478 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Instanceof_($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 479 => static function ($self, $stackPos) {
+
+ $self->semValue = $self->semStack[$stackPos-(3-2)];
+ if ($self->semValue instanceof Expr\ArrowFunction) {
+ $self->parenthesizedArrowFunctions->offsetSet($self->semValue);
+ }
+
+ },
+ 480 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Ternary($self->semStack[$stackPos-(5-1)], $self->semStack[$stackPos-(5-3)], $self->semStack[$stackPos-(5-5)], $self->getAttributes($self->tokenStartStack[$stackPos-(5-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 481 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Ternary($self->semStack[$stackPos-(4-1)], null, $self->semStack[$stackPos-(4-4)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 482 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\BinaryOp\Coalesce($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 483 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Isset_($self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 484 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Empty_($self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 485 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Include_($self->semStack[$stackPos-(2-2)], Expr\Include_::TYPE_INCLUDE, $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 486 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Include_($self->semStack[$stackPos-(2-2)], Expr\Include_::TYPE_INCLUDE_ONCE, $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 487 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Eval_($self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 488 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Include_($self->semStack[$stackPos-(2-2)], Expr\Include_::TYPE_REQUIRE, $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 489 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Include_($self->semStack[$stackPos-(2-2)], Expr\Include_::TYPE_REQUIRE_ONCE, $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 490 => static function ($self, $stackPos) {
+ $attrs = $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]);
+ $attrs['kind'] = $self->getIntCastKind($self->semStack[$stackPos-(2-1)]);
+ $self->semValue = new Expr\Cast\Int_($self->semStack[$stackPos-(2-2)], $attrs);
+ },
+ 491 => static function ($self, $stackPos) {
+ $attrs = $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]);
+ $attrs['kind'] = $self->getFloatCastKind($self->semStack[$stackPos-(2-1)]);
+ $self->semValue = new Expr\Cast\Double($self->semStack[$stackPos-(2-2)], $attrs);
+ },
+ 492 => static function ($self, $stackPos) {
+ $attrs = $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]);
+ $attrs['kind'] = $self->getStringCastKind($self->semStack[$stackPos-(2-1)]);
+ $self->semValue = new Expr\Cast\String_($self->semStack[$stackPos-(2-2)], $attrs);
+ },
+ 493 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Cast\Array_($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 494 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Cast\Object_($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 495 => static function ($self, $stackPos) {
+ $attrs = $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]);
+ $attrs['kind'] = $self->getBoolCastKind($self->semStack[$stackPos-(2-1)]);
+ $self->semValue = new Expr\Cast\Bool_($self->semStack[$stackPos-(2-2)], $attrs);
+ },
+ 496 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Cast\Unset_($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 497 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Cast\Void_($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 498 => static function ($self, $stackPos) {
+ $self->semValue = $self->createExitExpr($self->semStack[$stackPos-(2-1)], $stackPos-(2-1), $self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 499 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ErrorSuppress($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 500 => null,
+ 501 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ShellExec($self->semStack[$stackPos-(3-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 502 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Print_($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 503 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Yield_(null, null, $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 504 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Yield_($self->semStack[$stackPos-(2-2)], null, $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 505 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Yield_($self->semStack[$stackPos-(4-4)], $self->semStack[$stackPos-(4-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 506 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\YieldFrom($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 507 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Throw_($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 508 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ArrowFunction(['static' => false, 'byRef' => $self->semStack[$stackPos-(8-2)], 'params' => $self->semStack[$stackPos-(8-4)], 'returnType' => $self->semStack[$stackPos-(8-6)], 'expr' => $self->semStack[$stackPos-(8-8)], 'attrGroups' => []], $self->getAttributes($self->tokenStartStack[$stackPos-(8-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 509 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ArrowFunction(['static' => true, 'byRef' => $self->semStack[$stackPos-(9-3)], 'params' => $self->semStack[$stackPos-(9-5)], 'returnType' => $self->semStack[$stackPos-(9-7)], 'expr' => $self->semStack[$stackPos-(9-9)], 'attrGroups' => []], $self->getAttributes($self->tokenStartStack[$stackPos-(9-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 510 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Closure(['static' => false, 'byRef' => $self->semStack[$stackPos-(8-2)], 'params' => $self->semStack[$stackPos-(8-4)], 'uses' => $self->semStack[$stackPos-(8-6)], 'returnType' => $self->semStack[$stackPos-(8-7)], 'stmts' => $self->semStack[$stackPos-(8-8)], 'attrGroups' => []], $self->getAttributes($self->tokenStartStack[$stackPos-(8-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 511 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Closure(['static' => true, 'byRef' => $self->semStack[$stackPos-(9-3)], 'params' => $self->semStack[$stackPos-(9-5)], 'uses' => $self->semStack[$stackPos-(9-7)], 'returnType' => $self->semStack[$stackPos-(9-8)], 'stmts' => $self->semStack[$stackPos-(9-9)], 'attrGroups' => []], $self->getAttributes($self->tokenStartStack[$stackPos-(9-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 512 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ArrowFunction(['static' => false, 'byRef' => $self->semStack[$stackPos-(9-3)], 'params' => $self->semStack[$stackPos-(9-5)], 'returnType' => $self->semStack[$stackPos-(9-7)], 'expr' => $self->semStack[$stackPos-(9-9)], 'attrGroups' => $self->semStack[$stackPos-(9-1)]], $self->getAttributes($self->tokenStartStack[$stackPos-(9-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 513 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ArrowFunction(['static' => true, 'byRef' => $self->semStack[$stackPos-(10-4)], 'params' => $self->semStack[$stackPos-(10-6)], 'returnType' => $self->semStack[$stackPos-(10-8)], 'expr' => $self->semStack[$stackPos-(10-10)], 'attrGroups' => $self->semStack[$stackPos-(10-1)]], $self->getAttributes($self->tokenStartStack[$stackPos-(10-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 514 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Closure(['static' => false, 'byRef' => $self->semStack[$stackPos-(9-3)], 'params' => $self->semStack[$stackPos-(9-5)], 'uses' => $self->semStack[$stackPos-(9-7)], 'returnType' => $self->semStack[$stackPos-(9-8)], 'stmts' => $self->semStack[$stackPos-(9-9)], 'attrGroups' => $self->semStack[$stackPos-(9-1)]], $self->getAttributes($self->tokenStartStack[$stackPos-(9-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 515 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Closure(['static' => true, 'byRef' => $self->semStack[$stackPos-(10-4)], 'params' => $self->semStack[$stackPos-(10-6)], 'uses' => $self->semStack[$stackPos-(10-8)], 'returnType' => $self->semStack[$stackPos-(10-9)], 'stmts' => $self->semStack[$stackPos-(10-10)], 'attrGroups' => $self->semStack[$stackPos-(10-1)]], $self->getAttributes($self->tokenStartStack[$stackPos-(10-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 516 => static function ($self, $stackPos) {
+ $self->semValue = array(new Stmt\Class_(null, ['type' => $self->semStack[$stackPos-(8-2)], 'extends' => $self->semStack[$stackPos-(8-4)], 'implements' => $self->semStack[$stackPos-(8-5)], 'stmts' => $self->semStack[$stackPos-(8-7)], 'attrGroups' => $self->semStack[$stackPos-(8-1)]], $self->getAttributes($self->tokenStartStack[$stackPos-(8-1)], $self->tokenEndStack[$stackPos])), $self->semStack[$stackPos-(8-3)]);
+ $self->checkClass($self->semValue[0], -1);
+ },
+ 517 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\New_($self->semStack[$stackPos-(3-2)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 518 => static function ($self, $stackPos) {
+ list($class, $ctorArgs) = $self->semStack[$stackPos-(2-2)]; $self->semValue = new Expr\New_($class, $ctorArgs, $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 519 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\New_($self->semStack[$stackPos-(2-2)], [], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 520 => null,
+ 521 => null,
+ 522 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 523 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(4-3)];
+ },
+ 524 => null,
+ 525 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 526 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 527 => static function ($self, $stackPos) {
+ $self->semValue = new Node\ClosureUse($self->semStack[$stackPos-(2-2)], $self->semStack[$stackPos-(2-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 528 => static function ($self, $stackPos) {
+ $self->semValue = new Name($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 529 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\FuncCall($self->semStack[$stackPos-(2-1)], $self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 530 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\FuncCall($self->semStack[$stackPos-(2-1)], $self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 531 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\FuncCall($self->semStack[$stackPos-(2-1)], $self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 532 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\StaticCall($self->semStack[$stackPos-(4-1)], $self->semStack[$stackPos-(4-3)], $self->semStack[$stackPos-(4-4)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 533 => static function ($self, $stackPos) {
+ $self->semValue = new Name($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 534 => null,
+ 535 => static function ($self, $stackPos) {
+ $self->semValue = new Name($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 536 => static function ($self, $stackPos) {
+ $self->semValue = new Name($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 537 => static function ($self, $stackPos) {
+ $self->semValue = new Name\FullyQualified(substr($self->semStack[$stackPos-(1-1)], 1), $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 538 => static function ($self, $stackPos) {
+ $self->semValue = new Name\Relative(substr($self->semStack[$stackPos-(1-1)], 10), $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 539 => null,
+ 540 => null,
+ 541 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(3-2)];
+ },
+ 542 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Error($self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos])); $self->errorState = 2;
+ },
+ 543 => null,
+ 544 => null,
+ 545 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 546 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]); foreach ($self->semValue as $s) { if ($s instanceof Node\InterpolatedStringPart) { $s->value = Node\Scalar\String_::parseEscapeSequences($s->value, '`', $self->phpVersion->supportsUnicodeEscapes()); } };
+ },
+ 547 => static function ($self, $stackPos) {
+ foreach ($self->semStack[$stackPos-(1-1)] as $s) { if ($s instanceof Node\InterpolatedStringPart) { $s->value = Node\Scalar\String_::parseEscapeSequences($s->value, '`', $self->phpVersion->supportsUnicodeEscapes()); } }; $self->semValue = $self->semStack[$stackPos-(1-1)];
+ },
+ 548 => static function ($self, $stackPos) {
+ $self->semValue = array();
+ },
+ 549 => null,
+ 550 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ConstFetch($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 551 => static function ($self, $stackPos) {
+ $self->semValue = new Scalar\MagicConst\Line($self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 552 => static function ($self, $stackPos) {
+ $self->semValue = new Scalar\MagicConst\File($self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 553 => static function ($self, $stackPos) {
+ $self->semValue = new Scalar\MagicConst\Dir($self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 554 => static function ($self, $stackPos) {
+ $self->semValue = new Scalar\MagicConst\Class_($self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 555 => static function ($self, $stackPos) {
+ $self->semValue = new Scalar\MagicConst\Trait_($self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 556 => static function ($self, $stackPos) {
+ $self->semValue = new Scalar\MagicConst\Method($self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 557 => static function ($self, $stackPos) {
+ $self->semValue = new Scalar\MagicConst\Function_($self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 558 => static function ($self, $stackPos) {
+ $self->semValue = new Scalar\MagicConst\Namespace_($self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 559 => static function ($self, $stackPos) {
+ $self->semValue = new Scalar\MagicConst\Property($self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 560 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ClassConstFetch($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 561 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ClassConstFetch($self->semStack[$stackPos-(5-1)], $self->semStack[$stackPos-(5-4)], $self->getAttributes($self->tokenStartStack[$stackPos-(5-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 562 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ClassConstFetch($self->semStack[$stackPos-(3-1)], new Expr\Error($self->getAttributes($self->tokenStartStack[$stackPos-(3-3)], $self->tokenEndStack[$stackPos-(3-3)])), $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos])); $self->errorState = 2;
+ },
+ 563 => static function ($self, $stackPos) {
+ $attrs = $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]); $attrs['kind'] = Expr\Array_::KIND_SHORT;
+ $self->semValue = new Expr\Array_($self->semStack[$stackPos-(3-2)], $attrs);
+ },
+ 564 => static function ($self, $stackPos) {
+ $attrs = $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]); $attrs['kind'] = Expr\Array_::KIND_LONG;
+ $self->semValue = new Expr\Array_($self->semStack[$stackPos-(4-3)], $attrs);
+ $self->createdArrays->offsetSet($self->semValue);
+ },
+ 565 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(1-1)]; $self->createdArrays->offsetSet($self->semValue);
+ },
+ 566 => static function ($self, $stackPos) {
+ $self->semValue = Scalar\String_::fromString($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]), $self->phpVersion->supportsUnicodeEscapes());
+ },
+ 567 => static function ($self, $stackPos) {
+ $attrs = $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]); $attrs['kind'] = Scalar\String_::KIND_DOUBLE_QUOTED;
+ foreach ($self->semStack[$stackPos-(3-2)] as $s) { if ($s instanceof Node\InterpolatedStringPart) { $s->value = Node\Scalar\String_::parseEscapeSequences($s->value, '"', $self->phpVersion->supportsUnicodeEscapes()); } }; $self->semValue = new Scalar\InterpolatedString($self->semStack[$stackPos-(3-2)], $attrs);
+ },
+ 568 => static function ($self, $stackPos) {
+ $self->semValue = $self->parseLNumber($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]), $self->phpVersion->allowsInvalidOctals());
+ },
+ 569 => static function ($self, $stackPos) {
+ $self->semValue = Scalar\Float_::fromString($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 570 => null,
+ 571 => null,
+ 572 => null,
+ 573 => static function ($self, $stackPos) {
+ $self->semValue = $self->parseDocString($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-2)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]), $self->getAttributes($self->tokenStartStack[$stackPos-(3-3)], $self->tokenEndStack[$stackPos-(3-3)]), true);
+ },
+ 574 => static function ($self, $stackPos) {
+ $self->semValue = $self->parseDocString($self->semStack[$stackPos-(2-1)], '', $self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]), $self->getAttributes($self->tokenStartStack[$stackPos-(2-2)], $self->tokenEndStack[$stackPos-(2-2)]), true);
+ },
+ 575 => static function ($self, $stackPos) {
+ $self->semValue = $self->parseDocString($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-2)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]), $self->getAttributes($self->tokenStartStack[$stackPos-(3-3)], $self->tokenEndStack[$stackPos-(3-3)]), true);
+ },
+ 576 => static function ($self, $stackPos) {
+ $self->semValue = null;
+ },
+ 577 => null,
+ 578 => null,
+ 579 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(3-2)];
+ },
+ 580 => null,
+ 581 => null,
+ 582 => null,
+ 583 => null,
+ 584 => null,
+ 585 => null,
+ 586 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(3-2)];
+ },
+ 587 => null,
+ 588 => null,
+ 589 => null,
+ 590 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ArrayDimFetch($self->semStack[$stackPos-(4-1)], $self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 591 => null,
+ 592 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\MethodCall($self->semStack[$stackPos-(4-1)], $self->semStack[$stackPos-(4-3)], $self->semStack[$stackPos-(4-4)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 593 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\NullsafeMethodCall($self->semStack[$stackPos-(4-1)], $self->semStack[$stackPos-(4-3)], $self->semStack[$stackPos-(4-4)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 594 => static function ($self, $stackPos) {
+ $self->semValue = null;
+ },
+ 595 => null,
+ 596 => null,
+ 597 => null,
+ 598 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\PropertyFetch($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 599 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\NullsafePropertyFetch($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 600 => null,
+ 601 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Variable($self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 602 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Variable($self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 603 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Variable(new Expr\Error($self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos])), $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos])); $self->errorState = 2;
+ },
+ 604 => static function ($self, $stackPos) {
+ $var = $self->semStack[$stackPos-(1-1)]->name; $self->semValue = \is_string($var) ? new Node\VarLikeIdentifier($var, $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos])) : $var;
+ },
+ 605 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\StaticPropertyFetch($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 606 => null,
+ 607 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ArrayDimFetch($self->semStack[$stackPos-(4-1)], $self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 608 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\PropertyFetch($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 609 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\NullsafePropertyFetch($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 610 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\StaticPropertyFetch($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 611 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\StaticPropertyFetch($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 612 => null,
+ 613 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(3-2)];
+ },
+ 614 => null,
+ 615 => null,
+ 616 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(3-2)];
+ },
+ 617 => null,
+ 618 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Error($self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos])); $self->errorState = 2;
+ },
+ 619 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\List_($self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos])); $self->semValue->setAttribute('kind', Expr\List_::KIND_LIST);
+ $self->postprocessList($self->semValue);
+ },
+ 620 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(1-1)]; $end = count($self->semValue)-1; if ($self->semValue[$end]->value instanceof Expr\Error) array_pop($self->semValue);
+ },
+ 621 => null,
+ 622 => static function ($self, $stackPos) {
+ /* do nothing -- prevent default action of $$=$self->semStack[$1]. See $551. */
+ },
+ 623 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(3-1)][] = $self->semStack[$stackPos-(3-3)]; $self->semValue = $self->semStack[$stackPos-(3-1)];
+ },
+ 624 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 625 => static function ($self, $stackPos) {
+ $self->semValue = new Node\ArrayItem($self->semStack[$stackPos-(1-1)], null, false, $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 626 => static function ($self, $stackPos) {
+ $self->semValue = new Node\ArrayItem($self->semStack[$stackPos-(2-2)], null, true, $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 627 => static function ($self, $stackPos) {
+ $self->semValue = new Node\ArrayItem($self->semStack[$stackPos-(1-1)], null, false, $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 628 => static function ($self, $stackPos) {
+ $self->semValue = new Node\ArrayItem($self->semStack[$stackPos-(3-3)], $self->semStack[$stackPos-(3-1)], false, $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 629 => static function ($self, $stackPos) {
+ $self->semValue = new Node\ArrayItem($self->semStack[$stackPos-(4-4)], $self->semStack[$stackPos-(4-1)], true, $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 630 => static function ($self, $stackPos) {
+ $self->semValue = new Node\ArrayItem($self->semStack[$stackPos-(3-3)], $self->semStack[$stackPos-(3-1)], false, $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 631 => static function ($self, $stackPos) {
+ $self->semValue = new Node\ArrayItem($self->semStack[$stackPos-(2-2)], null, false, $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]), true);
+ },
+ 632 => static function ($self, $stackPos) {
+ /* Create an Error node now to remember the position. We'll later either report an error,
+ or convert this into a null element, depending on whether this is a creation or destructuring context. */
+ $attrs = $self->createEmptyElemAttributes($self->tokenPos);
+ $self->semValue = new Node\ArrayItem(new Expr\Error($attrs), null, false, $attrs);
+ },
+ 633 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(2-1)][] = $self->semStack[$stackPos-(2-2)]; $self->semValue = $self->semStack[$stackPos-(2-1)];
+ },
+ 634 => static function ($self, $stackPos) {
+ $self->semStack[$stackPos-(2-1)][] = $self->semStack[$stackPos-(2-2)]; $self->semValue = $self->semStack[$stackPos-(2-1)];
+ },
+ 635 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(1-1)]);
+ },
+ 636 => static function ($self, $stackPos) {
+ $self->semValue = array($self->semStack[$stackPos-(2-1)], $self->semStack[$stackPos-(2-2)]);
+ },
+ 637 => static function ($self, $stackPos) {
+ $attrs = $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]); $attrs['rawValue'] = $self->semStack[$stackPos-(1-1)]; $self->semValue = new Node\InterpolatedStringPart($self->semStack[$stackPos-(1-1)], $attrs);
+ },
+ 638 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Variable($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 639 => null,
+ 640 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ArrayDimFetch($self->semStack[$stackPos-(4-1)], $self->semStack[$stackPos-(4-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(4-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 641 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\PropertyFetch($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 642 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\NullsafePropertyFetch($self->semStack[$stackPos-(3-1)], $self->semStack[$stackPos-(3-3)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 643 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Variable($self->semStack[$stackPos-(3-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 644 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\Variable($self->semStack[$stackPos-(3-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(3-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 645 => static function ($self, $stackPos) {
+ $self->semValue = new Expr\ArrayDimFetch($self->semStack[$stackPos-(6-2)], $self->semStack[$stackPos-(6-4)], $self->getAttributes($self->tokenStartStack[$stackPos-(6-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 646 => static function ($self, $stackPos) {
+ $self->semValue = $self->semStack[$stackPos-(3-2)];
+ },
+ 647 => static function ($self, $stackPos) {
+ $self->semValue = new Scalar\String_($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 648 => static function ($self, $stackPos) {
+ $self->semValue = $self->parseNumString($self->semStack[$stackPos-(1-1)], $self->getAttributes($self->tokenStartStack[$stackPos-(1-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 649 => static function ($self, $stackPos) {
+ $self->semValue = $self->parseNumString('-' . $self->semStack[$stackPos-(2-2)], $self->getAttributes($self->tokenStartStack[$stackPos-(2-1)], $self->tokenEndStack[$stackPos]));
+ },
+ 650 => null,
+ ];
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/ParserAbstract.php b/vendor/nikic/php-parser/lib/PhpParser/ParserAbstract.php
new file mode 100644
index 0000000..aaa6637
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/ParserAbstract.php
@@ -0,0 +1,1335 @@
+ Map of PHP token IDs to drop */
+ protected array $dropTokens;
+ /** @var int[] Map of external symbols (static::T_*) to internal symbols */
+ protected array $tokenToSymbol;
+ /** @var string[] Map of symbols to their names */
+ protected array $symbolToName;
+ /** @var array Names of the production rules (only necessary for debugging) */
+ protected array $productions;
+
+ /** @var int[] Map of states to a displacement into the $action table. The corresponding action for this
+ * state/symbol pair is $action[$actionBase[$state] + $symbol]. If $actionBase[$state] is 0, the
+ * action is defaulted, i.e. $actionDefault[$state] should be used instead. */
+ protected array $actionBase;
+ /** @var int[] Table of actions. Indexed according to $actionBase comment. */
+ protected array $action;
+ /** @var int[] Table indexed analogously to $action. If $actionCheck[$actionBase[$state] + $symbol] != $symbol
+ * then the action is defaulted, i.e. $actionDefault[$state] should be used instead. */
+ protected array $actionCheck;
+ /** @var int[] Map of states to their default action */
+ protected array $actionDefault;
+ /** @var callable[] Semantic action callbacks */
+ protected array $reduceCallbacks;
+
+ /** @var int[] Map of non-terminals to a displacement into the $goto table. The corresponding goto state for this
+ * non-terminal/state pair is $goto[$gotoBase[$nonTerminal] + $state] (unless defaulted) */
+ protected array $gotoBase;
+ /** @var int[] Table of states to goto after reduction. Indexed according to $gotoBase comment. */
+ protected array $goto;
+ /** @var int[] Table indexed analogously to $goto. If $gotoCheck[$gotoBase[$nonTerminal] + $state] != $nonTerminal
+ * then the goto state is defaulted, i.e. $gotoDefault[$nonTerminal] should be used. */
+ protected array $gotoCheck;
+ /** @var int[] Map of non-terminals to the default state to goto after their reduction */
+ protected array $gotoDefault;
+
+ /** @var int[] Map of rules to the non-terminal on their left-hand side, i.e. the non-terminal to use for
+ * determining the state to goto after reduction. */
+ protected array $ruleToNonTerminal;
+ /** @var int[] Map of rules to the length of their right-hand side, which is the number of elements that have to
+ * be popped from the stack(s) on reduction. */
+ protected array $ruleToLength;
+
+ /*
+ * The following members are part of the parser state:
+ */
+
+ /** @var mixed Temporary value containing the result of last semantic action (reduction) */
+ protected $semValue;
+ /** @var mixed[] Semantic value stack (contains values of tokens and semantic action results) */
+ protected array $semStack;
+ /** @var int[] Token start position stack */
+ protected array $tokenStartStack;
+ /** @var int[] Token end position stack */
+ protected array $tokenEndStack;
+
+ /** @var ErrorHandler Error handler */
+ protected ErrorHandler $errorHandler;
+ /** @var int Error state, used to avoid error floods */
+ protected int $errorState;
+
+ /** @var \SplObjectStorage|null Array nodes created during parsing, for postprocessing of empty elements. */
+ protected ?\SplObjectStorage $createdArrays;
+
+ /** @var \SplObjectStorage|null
+ * Arrow functions that are wrapped in parentheses, to enforce the pipe operator parentheses requirements.
+ */
+ protected ?\SplObjectStorage $parenthesizedArrowFunctions;
+
+ /** @var Token[] Tokens for the current parse */
+ protected array $tokens;
+ /** @var int Current position in token array */
+ protected int $tokenPos;
+
+ /**
+ * Initialize $reduceCallbacks map.
+ */
+ abstract protected function initReduceCallbacks(): void;
+
+ /**
+ * Creates a parser instance.
+ *
+ * Options:
+ * * phpVersion: ?PhpVersion,
+ *
+ * @param Lexer $lexer A lexer
+ * @param PhpVersion $phpVersion PHP version to target, defaults to latest supported. This
+ * option is best-effort: Even if specified, parsing will generally assume the latest
+ * supported version and only adjust behavior in minor ways, for example by omitting
+ * errors in older versions and interpreting type hints as a name or identifier depending
+ * on version.
+ */
+ public function __construct(Lexer $lexer, ?PhpVersion $phpVersion = null) {
+ $this->lexer = $lexer;
+ $this->phpVersion = $phpVersion ?? PhpVersion::getNewestSupported();
+
+ $this->initReduceCallbacks();
+ $this->phpTokenToSymbol = $this->createTokenMap();
+ $this->dropTokens = array_fill_keys(
+ [\T_WHITESPACE, \T_OPEN_TAG, \T_COMMENT, \T_DOC_COMMENT, \T_BAD_CHARACTER], true
+ );
+ }
+
+ /**
+ * Parses PHP code into a node tree.
+ *
+ * If a non-throwing error handler is used, the parser will continue parsing after an error
+ * occurred and attempt to build a partial AST.
+ *
+ * @param string $code The source code to parse
+ * @param ErrorHandler|null $errorHandler Error handler to use for lexer/parser errors, defaults
+ * to ErrorHandler\Throwing.
+ *
+ * @return Node\Stmt[]|null Array of statements (or null non-throwing error handler is used and
+ * the parser was unable to recover from an error).
+ */
+ public function parse(string $code, ?ErrorHandler $errorHandler = null): ?array {
+ $this->errorHandler = $errorHandler ?: new ErrorHandler\Throwing();
+ $this->createdArrays = new \SplObjectStorage();
+ $this->parenthesizedArrowFunctions = new \SplObjectStorage();
+
+ $this->tokens = $this->lexer->tokenize($code, $this->errorHandler);
+ $result = $this->doParse();
+
+ // Report errors for any empty elements used inside arrays. This is delayed until after the main parse,
+ // because we don't know a priori whether a given array expression will be used in a destructuring context
+ // or not.
+ foreach ($this->createdArrays as $node) {
+ foreach ($node->items as $item) {
+ if ($item->value instanceof Expr\Error) {
+ $this->errorHandler->handleError(
+ new Error('Cannot use empty array elements in arrays', $item->getAttributes()));
+ }
+ }
+ }
+
+ // Clear out some of the interior state, so we don't hold onto unnecessary
+ // memory between uses of the parser
+ $this->tokenStartStack = [];
+ $this->tokenEndStack = [];
+ $this->semStack = [];
+ $this->semValue = null;
+ $this->createdArrays = null;
+ $this->parenthesizedArrowFunctions = null;
+
+ if ($result !== null) {
+ $traverser = new NodeTraverser(new CommentAnnotatingVisitor($this->tokens));
+ $traverser->traverse($result);
+ }
+
+ return $result;
+ }
+
+ public function getTokens(): array {
+ return $this->tokens;
+ }
+
+ /** @return Stmt[]|null */
+ protected function doParse(): ?array {
+ // We start off with no lookahead-token
+ $symbol = self::SYMBOL_NONE;
+ $tokenValue = null;
+ $this->tokenPos = -1;
+
+ // Keep stack of start and end attributes
+ $this->tokenStartStack = [];
+ $this->tokenEndStack = [0];
+
+ // Start off in the initial state and keep a stack of previous states
+ $state = 0;
+ $stateStack = [$state];
+
+ // Semantic value stack (contains values of tokens and semantic action results)
+ $this->semStack = [];
+
+ // Current position in the stack(s)
+ $stackPos = 0;
+
+ $this->errorState = 0;
+
+ for (;;) {
+ //$this->traceNewState($state, $symbol);
+
+ if ($this->actionBase[$state] === 0) {
+ $rule = $this->actionDefault[$state];
+ } else {
+ if ($symbol === self::SYMBOL_NONE) {
+ do {
+ $token = $this->tokens[++$this->tokenPos];
+ $tokenId = $token->id;
+ } while (isset($this->dropTokens[$tokenId]));
+
+ // Map the lexer token id to the internally used symbols.
+ $tokenValue = $token->text;
+ if (!isset($this->phpTokenToSymbol[$tokenId])) {
+ throw new \RangeException(sprintf(
+ 'The lexer returned an invalid token (id=%d, value=%s)',
+ $tokenId, $tokenValue
+ ));
+ }
+ $symbol = $this->phpTokenToSymbol[$tokenId];
+
+ //$this->traceRead($symbol);
+ }
+
+ $idx = $this->actionBase[$state] + $symbol;
+ if ((($idx >= 0 && $idx < $this->actionTableSize && $this->actionCheck[$idx] === $symbol)
+ || ($state < $this->YY2TBLSTATE
+ && ($idx = $this->actionBase[$state + $this->numNonLeafStates] + $symbol) >= 0
+ && $idx < $this->actionTableSize && $this->actionCheck[$idx] === $symbol))
+ && ($action = $this->action[$idx]) !== $this->defaultAction) {
+ /*
+ * >= numNonLeafStates: shift and reduce
+ * > 0: shift
+ * = 0: accept
+ * < 0: reduce
+ * = -YYUNEXPECTED: error
+ */
+ if ($action > 0) {
+ /* shift */
+ //$this->traceShift($symbol);
+
+ ++$stackPos;
+ $stateStack[$stackPos] = $state = $action;
+ $this->semStack[$stackPos] = $tokenValue;
+ $this->tokenStartStack[$stackPos] = $this->tokenPos;
+ $this->tokenEndStack[$stackPos] = $this->tokenPos;
+ $symbol = self::SYMBOL_NONE;
+
+ if ($this->errorState) {
+ --$this->errorState;
+ }
+
+ if ($action < $this->numNonLeafStates) {
+ continue;
+ }
+
+ /* $yyn >= numNonLeafStates means shift-and-reduce */
+ $rule = $action - $this->numNonLeafStates;
+ } else {
+ $rule = -$action;
+ }
+ } else {
+ $rule = $this->actionDefault[$state];
+ }
+ }
+
+ for (;;) {
+ if ($rule === 0) {
+ /* accept */
+ //$this->traceAccept();
+ return $this->semValue;
+ }
+ if ($rule !== $this->unexpectedTokenRule) {
+ /* reduce */
+ //$this->traceReduce($rule);
+
+ $ruleLength = $this->ruleToLength[$rule];
+ try {
+ $callback = $this->reduceCallbacks[$rule];
+ if ($callback !== null) {
+ $callback($this, $stackPos);
+ } elseif ($ruleLength > 0) {
+ $this->semValue = $this->semStack[$stackPos - $ruleLength + 1];
+ }
+ } catch (Error $e) {
+ if (-1 === $e->getStartLine()) {
+ $e->setStartLine($this->tokens[$this->tokenPos]->line);
+ }
+
+ $this->emitError($e);
+ // Can't recover from this type of error
+ return null;
+ }
+
+ /* Goto - shift nonterminal */
+ $lastTokenEnd = $this->tokenEndStack[$stackPos];
+ $stackPos -= $ruleLength;
+ $nonTerminal = $this->ruleToNonTerminal[$rule];
+ $idx = $this->gotoBase[$nonTerminal] + $stateStack[$stackPos];
+ if ($idx >= 0 && $idx < $this->gotoTableSize && $this->gotoCheck[$idx] === $nonTerminal) {
+ $state = $this->goto[$idx];
+ } else {
+ $state = $this->gotoDefault[$nonTerminal];
+ }
+
+ ++$stackPos;
+ $stateStack[$stackPos] = $state;
+ $this->semStack[$stackPos] = $this->semValue;
+ $this->tokenEndStack[$stackPos] = $lastTokenEnd;
+ if ($ruleLength === 0) {
+ // Empty productions use the start attributes of the lookahead token.
+ $this->tokenStartStack[$stackPos] = $this->tokenPos;
+ }
+ } else {
+ /* error */
+ switch ($this->errorState) {
+ case 0:
+ $msg = $this->getErrorMessage($symbol, $state);
+ $this->emitError(new Error($msg, $this->getAttributesForToken($this->tokenPos)));
+ // Break missing intentionally
+ // no break
+ case 1:
+ case 2:
+ $this->errorState = 3;
+
+ // Pop until error-expecting state uncovered
+ while (!(
+ (($idx = $this->actionBase[$state] + $this->errorSymbol) >= 0
+ && $idx < $this->actionTableSize && $this->actionCheck[$idx] === $this->errorSymbol)
+ || ($state < $this->YY2TBLSTATE
+ && ($idx = $this->actionBase[$state + $this->numNonLeafStates] + $this->errorSymbol) >= 0
+ && $idx < $this->actionTableSize && $this->actionCheck[$idx] === $this->errorSymbol)
+ ) || ($action = $this->action[$idx]) === $this->defaultAction) { // Not totally sure about this
+ if ($stackPos <= 0) {
+ // Could not recover from error
+ return null;
+ }
+ $state = $stateStack[--$stackPos];
+ //$this->tracePop($state);
+ }
+
+ //$this->traceShift($this->errorSymbol);
+ ++$stackPos;
+ $stateStack[$stackPos] = $state = $action;
+
+ // We treat the error symbol as being empty, so we reset the end attributes
+ // to the end attributes of the last non-error symbol
+ $this->tokenStartStack[$stackPos] = $this->tokenPos;
+ $this->tokenEndStack[$stackPos] = $this->tokenEndStack[$stackPos - 1];
+ break;
+
+ case 3:
+ if ($symbol === 0) {
+ // Reached EOF without recovering from error
+ return null;
+ }
+
+ //$this->traceDiscard($symbol);
+ $symbol = self::SYMBOL_NONE;
+ break 2;
+ }
+ }
+
+ if ($state < $this->numNonLeafStates) {
+ break;
+ }
+
+ /* >= numNonLeafStates means shift-and-reduce */
+ $rule = $state - $this->numNonLeafStates;
+ }
+ }
+ }
+
+ protected function emitError(Error $error): void {
+ $this->errorHandler->handleError($error);
+ }
+
+ /**
+ * Format error message including expected tokens.
+ *
+ * @param int $symbol Unexpected symbol
+ * @param int $state State at time of error
+ *
+ * @return string Formatted error message
+ */
+ protected function getErrorMessage(int $symbol, int $state): string {
+ $expectedString = '';
+ if ($expected = $this->getExpectedTokens($state)) {
+ $expectedString = ', expecting ' . implode(' or ', $expected);
+ }
+
+ return 'Syntax error, unexpected ' . $this->symbolToName[$symbol] . $expectedString;
+ }
+
+ /**
+ * Get limited number of expected tokens in given state.
+ *
+ * @param int $state State
+ *
+ * @return string[] Expected tokens. If too many, an empty array is returned.
+ */
+ protected function getExpectedTokens(int $state): array {
+ $expected = [];
+
+ $base = $this->actionBase[$state];
+ foreach ($this->symbolToName as $symbol => $name) {
+ $idx = $base + $symbol;
+ if ($idx >= 0 && $idx < $this->actionTableSize && $this->actionCheck[$idx] === $symbol
+ || $state < $this->YY2TBLSTATE
+ && ($idx = $this->actionBase[$state + $this->numNonLeafStates] + $symbol) >= 0
+ && $idx < $this->actionTableSize && $this->actionCheck[$idx] === $symbol
+ ) {
+ if ($this->action[$idx] !== $this->unexpectedTokenRule
+ && $this->action[$idx] !== $this->defaultAction
+ && $symbol !== $this->errorSymbol
+ ) {
+ if (count($expected) === 4) {
+ /* Too many expected tokens */
+ return [];
+ }
+
+ $expected[] = $name;
+ }
+ }
+ }
+
+ return $expected;
+ }
+
+ /**
+ * Get attributes for a node with the given start and end token positions.
+ *
+ * @param int $tokenStartPos Token position the node starts at
+ * @param int $tokenEndPos Token position the node ends at
+ * @return array Attributes
+ */
+ protected function getAttributes(int $tokenStartPos, int $tokenEndPos): array {
+ $startToken = $this->tokens[$tokenStartPos];
+ $afterEndToken = $this->tokens[$tokenEndPos + 1];
+ return [
+ 'startLine' => $startToken->line,
+ 'startTokenPos' => $tokenStartPos,
+ 'startFilePos' => $startToken->pos,
+ 'endLine' => $afterEndToken->line,
+ 'endTokenPos' => $tokenEndPos,
+ 'endFilePos' => $afterEndToken->pos - 1,
+ ];
+ }
+
+ /**
+ * Get attributes for a single token at the given token position.
+ *
+ * @return array Attributes
+ */
+ protected function getAttributesForToken(int $tokenPos): array {
+ if ($tokenPos < \count($this->tokens) - 1) {
+ return $this->getAttributes($tokenPos, $tokenPos);
+ }
+
+ // Get attributes for the sentinel token.
+ $token = $this->tokens[$tokenPos];
+ return [
+ 'startLine' => $token->line,
+ 'startTokenPos' => $tokenPos,
+ 'startFilePos' => $token->pos,
+ 'endLine' => $token->line,
+ 'endTokenPos' => $tokenPos,
+ 'endFilePos' => $token->pos,
+ ];
+ }
+
+ /*
+ * Tracing functions used for debugging the parser.
+ */
+
+ /*
+ protected function traceNewState($state, $symbol): void {
+ echo '% State ' . $state
+ . ', Lookahead ' . ($symbol == self::SYMBOL_NONE ? '--none--' : $this->symbolToName[$symbol]) . "\n";
+ }
+
+ protected function traceRead($symbol): void {
+ echo '% Reading ' . $this->symbolToName[$symbol] . "\n";
+ }
+
+ protected function traceShift($symbol): void {
+ echo '% Shift ' . $this->symbolToName[$symbol] . "\n";
+ }
+
+ protected function traceAccept(): void {
+ echo "% Accepted.\n";
+ }
+
+ protected function traceReduce($n): void {
+ echo '% Reduce by (' . $n . ') ' . $this->productions[$n] . "\n";
+ }
+
+ protected function tracePop($state): void {
+ echo '% Recovering, uncovered state ' . $state . "\n";
+ }
+
+ protected function traceDiscard($symbol): void {
+ echo '% Discard ' . $this->symbolToName[$symbol] . "\n";
+ }
+ */
+
+ /*
+ * Helper functions invoked by semantic actions
+ */
+
+ /**
+ * Moves statements of semicolon-style namespaces into $ns->stmts and checks various error conditions.
+ *
+ * @param Node\Stmt[] $stmts
+ * @return Node\Stmt[]
+ */
+ protected function handleNamespaces(array $stmts): array {
+ $hasErrored = false;
+ $style = $this->getNamespacingStyle($stmts);
+ if (null === $style) {
+ // not namespaced, nothing to do
+ return $stmts;
+ }
+ if ('brace' === $style) {
+ // For braced namespaces we only have to check that there are no invalid statements between the namespaces
+ $afterFirstNamespace = false;
+ foreach ($stmts as $stmt) {
+ if ($stmt instanceof Node\Stmt\Namespace_) {
+ $afterFirstNamespace = true;
+ } elseif (!$stmt instanceof Node\Stmt\HaltCompiler
+ && !$stmt instanceof Node\Stmt\Nop
+ && $afterFirstNamespace && !$hasErrored) {
+ $this->emitError(new Error(
+ 'No code may exist outside of namespace {}', $stmt->getAttributes()));
+ $hasErrored = true; // Avoid one error for every statement
+ }
+ }
+ return $stmts;
+ } else {
+ // For semicolon namespaces we have to move the statements after a namespace declaration into ->stmts
+ $resultStmts = [];
+ $targetStmts = &$resultStmts;
+ $lastNs = null;
+ foreach ($stmts as $stmt) {
+ if ($stmt instanceof Node\Stmt\Namespace_) {
+ if ($lastNs !== null) {
+ $this->fixupNamespaceAttributes($lastNs);
+ }
+ if ($stmt->stmts === null) {
+ $stmt->stmts = [];
+ $targetStmts = &$stmt->stmts;
+ $resultStmts[] = $stmt;
+ } else {
+ // This handles the invalid case of mixed style namespaces
+ $resultStmts[] = $stmt;
+ $targetStmts = &$resultStmts;
+ }
+ $lastNs = $stmt;
+ } elseif ($stmt instanceof Node\Stmt\HaltCompiler) {
+ // __halt_compiler() is not moved into the namespace
+ $resultStmts[] = $stmt;
+ } else {
+ $targetStmts[] = $stmt;
+ }
+ }
+ if ($lastNs !== null) {
+ $this->fixupNamespaceAttributes($lastNs);
+ }
+ return $resultStmts;
+ }
+ }
+
+ private function fixupNamespaceAttributes(Node\Stmt\Namespace_ $stmt): void {
+ // We moved the statements into the namespace node, as such the end of the namespace node
+ // needs to be extended to the end of the statements.
+ if (empty($stmt->stmts)) {
+ return;
+ }
+
+ // We only move the builtin end attributes here. This is the best we can do with the
+ // knowledge we have.
+ $endAttributes = ['endLine', 'endFilePos', 'endTokenPos'];
+ $lastStmt = $stmt->stmts[count($stmt->stmts) - 1];
+ foreach ($endAttributes as $endAttribute) {
+ if ($lastStmt->hasAttribute($endAttribute)) {
+ $stmt->setAttribute($endAttribute, $lastStmt->getAttribute($endAttribute));
+ }
+ }
+ }
+
+ /** @return array */
+ private function getNamespaceErrorAttributes(Namespace_ $node): array {
+ $attrs = $node->getAttributes();
+ // Adjust end attributes to only cover the "namespace" keyword, not the whole namespace.
+ if (isset($attrs['startLine'])) {
+ $attrs['endLine'] = $attrs['startLine'];
+ }
+ if (isset($attrs['startTokenPos'])) {
+ $attrs['endTokenPos'] = $attrs['startTokenPos'];
+ }
+ if (isset($attrs['startFilePos'])) {
+ $attrs['endFilePos'] = $attrs['startFilePos'] + \strlen('namespace') - 1;
+ }
+ return $attrs;
+ }
+
+ /**
+ * Determine namespacing style (semicolon or brace)
+ *
+ * @param Node[] $stmts Top-level statements.
+ *
+ * @return null|string One of "semicolon", "brace" or null (no namespaces)
+ */
+ private function getNamespacingStyle(array $stmts): ?string {
+ $style = null;
+ $hasNotAllowedStmts = false;
+ foreach ($stmts as $i => $stmt) {
+ if ($stmt instanceof Node\Stmt\Namespace_) {
+ $currentStyle = null === $stmt->stmts ? 'semicolon' : 'brace';
+ if (null === $style) {
+ $style = $currentStyle;
+ if ($hasNotAllowedStmts) {
+ $this->emitError(new Error(
+ 'Namespace declaration statement has to be the very first statement in the script',
+ $this->getNamespaceErrorAttributes($stmt)
+ ));
+ }
+ } elseif ($style !== $currentStyle) {
+ $this->emitError(new Error(
+ 'Cannot mix bracketed namespace declarations with unbracketed namespace declarations',
+ $this->getNamespaceErrorAttributes($stmt)
+ ));
+ // Treat like semicolon style for namespace normalization
+ return 'semicolon';
+ }
+ continue;
+ }
+
+ /* declare(), __halt_compiler() and nops can be used before a namespace declaration */
+ if ($stmt instanceof Node\Stmt\Declare_
+ || $stmt instanceof Node\Stmt\HaltCompiler
+ || $stmt instanceof Node\Stmt\Nop) {
+ continue;
+ }
+
+ /* There may be a hashbang line at the very start of the file */
+ if ($i === 0 && $stmt instanceof Node\Stmt\InlineHTML && preg_match('/\A#!.*\r?\n\z/', $stmt->value)) {
+ continue;
+ }
+
+ /* Everything else if forbidden before namespace declarations */
+ $hasNotAllowedStmts = true;
+ }
+ return $style;
+ }
+
+ /** @return Name|Identifier */
+ protected function handleBuiltinTypes(Name $name) {
+ if (!$name->isUnqualified()) {
+ return $name;
+ }
+
+ $lowerName = $name->toLowerString();
+ if (!$this->phpVersion->supportsBuiltinType($lowerName)) {
+ return $name;
+ }
+
+ return new Node\Identifier($lowerName, $name->getAttributes());
+ }
+
+ /**
+ * Get combined start and end attributes at a stack location
+ *
+ * @param int $stackPos Stack location
+ *
+ * @return array Combined start and end attributes
+ */
+ protected function getAttributesAt(int $stackPos): array {
+ return $this->getAttributes($this->tokenStartStack[$stackPos], $this->tokenEndStack[$stackPos]);
+ }
+
+ protected function getFloatCastKind(string $cast): int {
+ $cast = strtolower($cast);
+ if (strpos($cast, 'float') !== false) {
+ return Double::KIND_FLOAT;
+ }
+
+ if (strpos($cast, 'real') !== false) {
+ return Double::KIND_REAL;
+ }
+
+ return Double::KIND_DOUBLE;
+ }
+
+ protected function getIntCastKind(string $cast): int {
+ $cast = strtolower($cast);
+ if (strpos($cast, 'integer') !== false) {
+ return Expr\Cast\Int_::KIND_INTEGER;
+ }
+
+ return Expr\Cast\Int_::KIND_INT;
+ }
+
+ protected function getBoolCastKind(string $cast): int {
+ $cast = strtolower($cast);
+ if (strpos($cast, 'boolean') !== false) {
+ return Expr\Cast\Bool_::KIND_BOOLEAN;
+ }
+
+ return Expr\Cast\Bool_::KIND_BOOL;
+ }
+
+ protected function getStringCastKind(string $cast): int {
+ $cast = strtolower($cast);
+ if (strpos($cast, 'binary') !== false) {
+ return Expr\Cast\String_::KIND_BINARY;
+ }
+
+ return Expr\Cast\String_::KIND_STRING;
+ }
+
+ /** @param array $attributes */
+ protected function parseLNumber(string $str, array $attributes, bool $allowInvalidOctal = false): Int_ {
+ try {
+ return Int_::fromString($str, $attributes, $allowInvalidOctal);
+ } catch (Error $error) {
+ $this->emitError($error);
+ // Use dummy value
+ return new Int_(0, $attributes);
+ }
+ }
+
+ /**
+ * Parse a T_NUM_STRING token into either an integer or string node.
+ *
+ * @param string $str Number string
+ * @param array $attributes Attributes
+ *
+ * @return Int_|String_ Integer or string node.
+ */
+ protected function parseNumString(string $str, array $attributes) {
+ if (!preg_match('/^(?:0|-?[1-9][0-9]*)$/', $str)) {
+ return new String_($str, $attributes);
+ }
+
+ $num = +$str;
+ if (!is_int($num)) {
+ return new String_($str, $attributes);
+ }
+
+ return new Int_($num, $attributes);
+ }
+
+ /** @param array $attributes */
+ protected function stripIndentation(
+ string $string, int $indentLen, string $indentChar,
+ bool $newlineAtStart, bool $newlineAtEnd, array $attributes
+ ): string {
+ if ($indentLen === 0) {
+ return $string;
+ }
+
+ $start = $newlineAtStart ? '(?:(?<=\n)|\A)' : '(?<=\n)';
+ $end = $newlineAtEnd ? '(?:(?=[\r\n])|\z)' : '(?=[\r\n])';
+ $regex = '/' . $start . '([ \t]*)(' . $end . ')?/';
+ return preg_replace_callback(
+ $regex,
+ function ($matches) use ($indentLen, $indentChar, $attributes) {
+ $prefix = substr($matches[1], 0, $indentLen);
+ if (false !== strpos($prefix, $indentChar === " " ? "\t" : " ")) {
+ $this->emitError(new Error(
+ 'Invalid indentation - tabs and spaces cannot be mixed', $attributes
+ ));
+ } elseif (strlen($prefix) < $indentLen && !isset($matches[2])) {
+ $this->emitError(new Error(
+ 'Invalid body indentation level ' .
+ '(expecting an indentation level of at least ' . $indentLen . ')',
+ $attributes
+ ));
+ }
+ return substr($matches[0], strlen($prefix));
+ },
+ $string
+ );
+ }
+
+ /**
+ * @param string|(Expr|InterpolatedStringPart)[] $contents
+ * @param array $attributes
+ * @param array $endTokenAttributes
+ */
+ protected function parseDocString(
+ string $startToken, $contents, string $endToken,
+ array $attributes, array $endTokenAttributes, bool $parseUnicodeEscape
+ ): Expr {
+ $kind = strpos($startToken, "'") === false
+ ? String_::KIND_HEREDOC : String_::KIND_NOWDOC;
+
+ $regex = '/\A[bB]?<<<[ \t]*[\'"]?([a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)[\'"]?(?:\r\n|\n|\r)\z/';
+ $result = preg_match($regex, $startToken, $matches);
+ assert($result === 1);
+ $label = $matches[1];
+
+ $result = preg_match('/\A[ \t]*/', $endToken, $matches);
+ assert($result === 1);
+ $indentation = $matches[0];
+
+ $attributes['kind'] = $kind;
+ $attributes['docLabel'] = $label;
+ $attributes['docIndentation'] = $indentation;
+
+ $indentHasSpaces = false !== strpos($indentation, " ");
+ $indentHasTabs = false !== strpos($indentation, "\t");
+ if ($indentHasSpaces && $indentHasTabs) {
+ $this->emitError(new Error(
+ 'Invalid indentation - tabs and spaces cannot be mixed',
+ $endTokenAttributes
+ ));
+
+ // Proceed processing as if this doc string is not indented
+ $indentation = '';
+ }
+
+ $indentLen = \strlen($indentation);
+ $indentChar = $indentHasSpaces ? " " : "\t";
+
+ if (\is_string($contents)) {
+ if ($contents === '') {
+ $attributes['rawValue'] = $contents;
+ return new String_('', $attributes);
+ }
+
+ $contents = $this->stripIndentation(
+ $contents, $indentLen, $indentChar, true, true, $attributes
+ );
+ $contents = preg_replace('~(\r\n|\n|\r)\z~', '', $contents);
+ $attributes['rawValue'] = $contents;
+
+ if ($kind === String_::KIND_HEREDOC) {
+ $contents = String_::parseEscapeSequences($contents, null, $parseUnicodeEscape);
+ }
+
+ return new String_($contents, $attributes);
+ } else {
+ assert(count($contents) > 0);
+ if (!$contents[0] instanceof Node\InterpolatedStringPart) {
+ // If there is no leading encapsed string part, pretend there is an empty one
+ $this->stripIndentation(
+ '', $indentLen, $indentChar, true, false, $contents[0]->getAttributes()
+ );
+ }
+
+ $newContents = [];
+ foreach ($contents as $i => $part) {
+ if ($part instanceof Node\InterpolatedStringPart) {
+ $isLast = $i === \count($contents) - 1;
+ $part->value = $this->stripIndentation(
+ $part->value, $indentLen, $indentChar,
+ $i === 0, $isLast, $part->getAttributes()
+ );
+ if ($isLast) {
+ $part->value = preg_replace('~(\r\n|\n|\r)\z~', '', $part->value);
+ }
+ $part->setAttribute('rawValue', $part->value);
+ $part->value = String_::parseEscapeSequences($part->value, null, $parseUnicodeEscape);
+ if ('' === $part->value) {
+ continue;
+ }
+ }
+ $newContents[] = $part;
+ }
+ return new InterpolatedString($newContents, $attributes);
+ }
+ }
+
+ protected function createCommentFromToken(Token $token, int $tokenPos): Comment {
+ assert($token->id === \T_COMMENT || $token->id == \T_DOC_COMMENT);
+ return \T_DOC_COMMENT === $token->id
+ ? new Comment\Doc($token->text, $token->line, $token->pos, $tokenPos,
+ $token->getEndLine(), $token->getEndPos() - 1, $tokenPos)
+ : new Comment($token->text, $token->line, $token->pos, $tokenPos,
+ $token->getEndLine(), $token->getEndPos() - 1, $tokenPos);
+ }
+
+ /**
+ * Get last comment before the given token position, if any
+ */
+ protected function getCommentBeforeToken(int $tokenPos): ?Comment {
+ while (--$tokenPos >= 0) {
+ $token = $this->tokens[$tokenPos];
+ if (!isset($this->dropTokens[$token->id])) {
+ break;
+ }
+
+ if ($token->id === \T_COMMENT || $token->id === \T_DOC_COMMENT) {
+ return $this->createCommentFromToken($token, $tokenPos);
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Create a zero-length nop to capture preceding comments, if any.
+ */
+ protected function maybeCreateZeroLengthNop(int $tokenPos): ?Nop {
+ $comment = $this->getCommentBeforeToken($tokenPos);
+ if ($comment === null) {
+ return null;
+ }
+
+ $commentEndLine = $comment->getEndLine();
+ $commentEndFilePos = $comment->getEndFilePos();
+ $commentEndTokenPos = $comment->getEndTokenPos();
+ $attributes = [
+ 'startLine' => $commentEndLine,
+ 'endLine' => $commentEndLine,
+ 'startFilePos' => $commentEndFilePos + 1,
+ 'endFilePos' => $commentEndFilePos,
+ 'startTokenPos' => $commentEndTokenPos + 1,
+ 'endTokenPos' => $commentEndTokenPos,
+ ];
+ return new Nop($attributes);
+ }
+
+ protected function maybeCreateNop(int $tokenStartPos, int $tokenEndPos): ?Nop {
+ if ($this->getCommentBeforeToken($tokenStartPos) === null) {
+ return null;
+ }
+ return new Nop($this->getAttributes($tokenStartPos, $tokenEndPos));
+ }
+
+ protected function handleHaltCompiler(): string {
+ // Prevent the lexer from returning any further tokens.
+ $nextToken = $this->tokens[$this->tokenPos + 1];
+ $this->tokenPos = \count($this->tokens) - 2;
+
+ // Return text after __halt_compiler.
+ return $nextToken->id === \T_INLINE_HTML ? $nextToken->text : '';
+ }
+
+ protected function inlineHtmlHasLeadingNewline(int $stackPos): bool {
+ $tokenPos = $this->tokenStartStack[$stackPos];
+ $token = $this->tokens[$tokenPos];
+ assert($token->id == \T_INLINE_HTML);
+ if ($tokenPos > 0) {
+ $prevToken = $this->tokens[$tokenPos - 1];
+ assert($prevToken->id == \T_CLOSE_TAG);
+ return false !== strpos($prevToken->text, "\n")
+ || false !== strpos($prevToken->text, "\r");
+ }
+ return true;
+ }
+
+ /**
+ * @return array
+ */
+ protected function createEmptyElemAttributes(int $tokenPos): array {
+ return $this->getAttributesForToken($tokenPos);
+ }
+
+ protected function fixupArrayDestructuring(Array_ $node): Expr\List_ {
+ $this->createdArrays->offsetUnset($node);
+ return new Expr\List_(array_map(function (Node\ArrayItem $item) {
+ if ($item->value instanceof Expr\Error) {
+ // We used Error as a placeholder for empty elements, which are legal for destructuring.
+ return null;
+ }
+ if ($item->value instanceof Array_) {
+ return new Node\ArrayItem(
+ $this->fixupArrayDestructuring($item->value),
+ $item->key, $item->byRef, $item->getAttributes());
+ }
+ return $item;
+ }, $node->items), ['kind' => Expr\List_::KIND_ARRAY] + $node->getAttributes());
+ }
+
+ protected function postprocessList(Expr\List_ $node): void {
+ foreach ($node->items as $i => $item) {
+ if ($item->value instanceof Expr\Error) {
+ // We used Error as a placeholder for empty elements, which are legal for destructuring.
+ $node->items[$i] = null;
+ }
+ }
+ }
+
+ /** @param ElseIf_|Else_ $node */
+ protected function fixupAlternativeElse($node): void {
+ // Make sure a trailing nop statement carrying comments is part of the node.
+ $numStmts = \count($node->stmts);
+ if ($numStmts !== 0 && $node->stmts[$numStmts - 1] instanceof Nop) {
+ $nopAttrs = $node->stmts[$numStmts - 1]->getAttributes();
+ if (isset($nopAttrs['endLine'])) {
+ $node->setAttribute('endLine', $nopAttrs['endLine']);
+ }
+ if (isset($nopAttrs['endFilePos'])) {
+ $node->setAttribute('endFilePos', $nopAttrs['endFilePos']);
+ }
+ if (isset($nopAttrs['endTokenPos'])) {
+ $node->setAttribute('endTokenPos', $nopAttrs['endTokenPos']);
+ }
+ }
+ }
+
+ protected function checkClassModifier(int $a, int $b, int $modifierPos): void {
+ try {
+ Modifiers::verifyClassModifier($a, $b);
+ } catch (Error $error) {
+ $error->setAttributes($this->getAttributesAt($modifierPos));
+ $this->emitError($error);
+ }
+ }
+
+ protected function checkModifier(int $a, int $b, int $modifierPos): void {
+ // Jumping through some hoops here because verifyModifier() is also used elsewhere
+ try {
+ Modifiers::verifyModifier($a, $b);
+ } catch (Error $error) {
+ $error->setAttributes($this->getAttributesAt($modifierPos));
+ $this->emitError($error);
+ }
+ }
+
+ protected function checkParam(Param $node): void {
+ if ($node->variadic && null !== $node->default) {
+ $this->emitError(new Error(
+ 'Variadic parameter cannot have a default value',
+ $node->default->getAttributes()
+ ));
+ }
+ }
+
+ protected function checkTryCatch(TryCatch $node): void {
+ if (empty($node->catches) && null === $node->finally) {
+ $this->emitError(new Error(
+ 'Cannot use try without catch or finally', $node->getAttributes()
+ ));
+ }
+ }
+
+ protected function checkNamespace(Namespace_ $node): void {
+ if (null !== $node->stmts) {
+ foreach ($node->stmts as $stmt) {
+ if ($stmt instanceof Namespace_) {
+ $this->emitError(new Error(
+ 'Namespace declarations cannot be nested', $stmt->getAttributes()
+ ));
+ }
+ }
+ }
+ }
+
+ private function checkClassName(?Identifier $name, int $namePos): void {
+ if (null !== $name && $name->isSpecialClassName()) {
+ $this->emitError(new Error(
+ sprintf('Cannot use \'%s\' as class name as it is reserved', $name),
+ $this->getAttributesAt($namePos)
+ ));
+ }
+ }
+
+ /** @param Name[] $interfaces */
+ private function checkImplementedInterfaces(array $interfaces): void {
+ foreach ($interfaces as $interface) {
+ if ($interface->isSpecialClassName()) {
+ $this->emitError(new Error(
+ sprintf('Cannot use \'%s\' as interface name as it is reserved', $interface),
+ $interface->getAttributes()
+ ));
+ }
+ }
+ }
+
+ protected function checkClass(Class_ $node, int $namePos): void {
+ $this->checkClassName($node->name, $namePos);
+
+ if ($node->extends && $node->extends->isSpecialClassName()) {
+ $this->emitError(new Error(
+ sprintf('Cannot use \'%s\' as class name as it is reserved', $node->extends),
+ $node->extends->getAttributes()
+ ));
+ }
+
+ $this->checkImplementedInterfaces($node->implements);
+ }
+
+ protected function checkInterface(Interface_ $node, int $namePos): void {
+ $this->checkClassName($node->name, $namePos);
+ $this->checkImplementedInterfaces($node->extends);
+ }
+
+ protected function checkEnum(Enum_ $node, int $namePos): void {
+ $this->checkClassName($node->name, $namePos);
+ $this->checkImplementedInterfaces($node->implements);
+ }
+
+ protected function checkClassMethod(ClassMethod $node, int $modifierPos): void {
+ if ($node->flags & Modifiers::STATIC) {
+ switch ($node->name->toLowerString()) {
+ case '__construct':
+ $this->emitError(new Error(
+ sprintf('Constructor %s() cannot be static', $node->name),
+ $this->getAttributesAt($modifierPos)));
+ break;
+ case '__destruct':
+ $this->emitError(new Error(
+ sprintf('Destructor %s() cannot be static', $node->name),
+ $this->getAttributesAt($modifierPos)));
+ break;
+ case '__clone':
+ $this->emitError(new Error(
+ sprintf('Clone method %s() cannot be static', $node->name),
+ $this->getAttributesAt($modifierPos)));
+ break;
+ }
+ }
+
+ if ($node->flags & Modifiers::READONLY) {
+ $this->emitError(new Error(
+ sprintf('Method %s() cannot be readonly', $node->name),
+ $this->getAttributesAt($modifierPos)));
+ }
+ }
+
+ protected function checkClassConst(ClassConst $node, int $modifierPos): void {
+ foreach ([Modifiers::STATIC, Modifiers::ABSTRACT, Modifiers::READONLY] as $modifier) {
+ if ($node->flags & $modifier) {
+ $this->emitError(new Error(
+ "Cannot use '" . Modifiers::toString($modifier) . "' as constant modifier",
+ $this->getAttributesAt($modifierPos)));
+ }
+ }
+ }
+
+ protected function checkUseUse(UseItem $node, int $namePos): void {
+ if ($node->alias && $node->alias->isSpecialClassName()) {
+ $this->emitError(new Error(
+ sprintf(
+ 'Cannot use %s as %s because \'%2$s\' is a special class name',
+ $node->name, $node->alias
+ ),
+ $this->getAttributesAt($namePos)
+ ));
+ }
+ }
+
+ protected function checkPropertyHooksForMultiProperty(Property $property, int $hookPos): void {
+ if (count($property->props) > 1) {
+ $this->emitError(new Error(
+ 'Cannot use hooks when declaring multiple properties', $this->getAttributesAt($hookPos)));
+ }
+ }
+
+ /** @param PropertyHook[] $hooks */
+ protected function checkEmptyPropertyHookList(array $hooks, int $hookPos): void {
+ if (empty($hooks)) {
+ $this->emitError(new Error(
+ 'Property hook list cannot be empty', $this->getAttributesAt($hookPos)));
+ }
+ }
+
+ protected function checkPropertyHook(PropertyHook $hook, ?int $paramListPos): void {
+ $name = $hook->name->toLowerString();
+ if ($name !== 'get' && $name !== 'set') {
+ $this->emitError(new Error(
+ 'Unknown hook "' . $hook->name . '", expected "get" or "set"',
+ $hook->name->getAttributes()));
+ }
+ if ($name === 'get' && $paramListPos !== null) {
+ $this->emitError(new Error(
+ 'get hook must not have a parameter list', $this->getAttributesAt($paramListPos)));
+ }
+ }
+
+ protected function checkPropertyHookModifiers(int $a, int $b, int $modifierPos): void {
+ try {
+ Modifiers::verifyModifier($a, $b);
+ } catch (Error $error) {
+ $error->setAttributes($this->getAttributesAt($modifierPos));
+ $this->emitError($error);
+ }
+
+ if ($b != Modifiers::FINAL) {
+ $this->emitError(new Error(
+ 'Cannot use the ' . Modifiers::toString($b) . ' modifier on a property hook',
+ $this->getAttributesAt($modifierPos)));
+ }
+ }
+
+ protected function checkConstantAttributes(Const_ $node): void {
+ if ($node->attrGroups !== [] && count($node->consts) > 1) {
+ $this->emitError(new Error(
+ 'Cannot use attributes on multiple constants at once', $node->getAttributes()));
+ }
+ }
+
+ protected function checkPipeOperatorParentheses(Expr $node): void {
+ if ($node instanceof Expr\ArrowFunction && !$this->parenthesizedArrowFunctions->offsetExists($node)) {
+ $this->emitError(new Error(
+ 'Arrow functions on the right hand side of |> must be parenthesized', $node->getAttributes()));
+ }
+ }
+
+ /**
+ * @param Property|Param $node
+ */
+ protected function addPropertyNameToHooks(Node $node): void {
+ if ($node instanceof Property) {
+ $name = $node->props[0]->name->toString();
+ } else {
+ $name = $node->var->name;
+ }
+ foreach ($node->hooks as $hook) {
+ $hook->setAttribute('propertyName', $name);
+ }
+ }
+
+ /** @param array $args */
+ private function isSimpleExit(array $args): bool {
+ if (\count($args) === 0) {
+ return true;
+ }
+ if (\count($args) === 1) {
+ $arg = $args[0];
+ return $arg instanceof Arg && $arg->name === null &&
+ $arg->byRef === false && $arg->unpack === false;
+ }
+ return false;
+ }
+
+ /**
+ * @param array $args
+ * @param array $attrs
+ */
+ protected function createExitExpr(string $name, int $namePos, array $args, array $attrs): Expr {
+ if ($this->isSimpleExit($args)) {
+ // Create Exit node for backwards compatibility.
+ $attrs['kind'] = strtolower($name) === 'exit' ? Expr\Exit_::KIND_EXIT : Expr\Exit_::KIND_DIE;
+ return new Expr\Exit_(\count($args) === 1 ? $args[0]->value : null, $attrs);
+ }
+ return new Expr\FuncCall(new Name($name, $this->getAttributesAt($namePos)), $args, $attrs);
+ }
+
+ /**
+ * Creates the token map.
+ *
+ * The token map maps the PHP internal token identifiers
+ * to the identifiers used by the Parser. Additionally it
+ * maps T_OPEN_TAG_WITH_ECHO to T_ECHO and T_CLOSE_TAG to ';'.
+ *
+ * @return array The token map
+ */
+ protected function createTokenMap(): array {
+ $tokenMap = [];
+
+ // Single-char tokens use an identity mapping.
+ for ($i = 0; $i < 256; ++$i) {
+ $tokenMap[$i] = $i;
+ }
+
+ foreach ($this->symbolToName as $name) {
+ if ($name[0] === 'T') {
+ $tokenMap[\constant($name)] = constant(static::class . '::' . $name);
+ }
+ }
+
+ // T_OPEN_TAG_WITH_ECHO with dropped T_OPEN_TAG results in T_ECHO
+ $tokenMap[\T_OPEN_TAG_WITH_ECHO] = static::T_ECHO;
+ // T_CLOSE_TAG is equivalent to ';'
+ $tokenMap[\T_CLOSE_TAG] = ord(';');
+
+ // We have created a map from PHP token IDs to external symbol IDs.
+ // Now map them to the internal symbol ID.
+ $fullTokenMap = [];
+ foreach ($tokenMap as $phpToken => $extSymbol) {
+ $intSymbol = $this->tokenToSymbol[$extSymbol];
+ if ($intSymbol === $this->invalidSymbol) {
+ continue;
+ }
+ $fullTokenMap[$phpToken] = $intSymbol;
+ }
+
+ return $fullTokenMap;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/ParserFactory.php b/vendor/nikic/php-parser/lib/PhpParser/ParserFactory.php
new file mode 100644
index 0000000..3a7586e
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/ParserFactory.php
@@ -0,0 +1,42 @@
+isHostVersion()) {
+ $lexer = new Lexer();
+ } else {
+ $lexer = new Lexer\Emulative($version);
+ }
+ if ($version->id >= 80000) {
+ return new Php8($lexer, $version);
+ }
+ return new Php7($lexer, $version);
+ }
+
+ /**
+ * Create a parser targeting the newest version supported by this library. Code for older
+ * versions will be accepted if there have been no relevant backwards-compatibility breaks in
+ * PHP.
+ */
+ public function createForNewestSupportedVersion(): Parser {
+ return $this->createForVersion(PhpVersion::getNewestSupported());
+ }
+
+ /**
+ * Create a parser targeting the host PHP version, that is the PHP version we're currently
+ * running on. This parser will not use any token emulation.
+ */
+ public function createForHostVersion(): Parser {
+ return $this->createForVersion(PhpVersion::getHostVersion());
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/PhpVersion.php b/vendor/nikic/php-parser/lib/PhpParser/PhpVersion.php
new file mode 100644
index 0000000..9517d72
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/PhpVersion.php
@@ -0,0 +1,175 @@
+ 50100,
+ 'callable' => 50400,
+ 'bool' => 70000,
+ 'int' => 70000,
+ 'float' => 70000,
+ 'string' => 70000,
+ 'iterable' => 70100,
+ 'void' => 70100,
+ 'object' => 70200,
+ 'null' => 80000,
+ 'false' => 80000,
+ 'mixed' => 80000,
+ 'never' => 80100,
+ 'true' => 80200,
+ ];
+
+ private function __construct(int $id) {
+ $this->id = $id;
+ }
+
+ /**
+ * Create a PhpVersion object from major and minor version components.
+ */
+ public static function fromComponents(int $major, int $minor): self {
+ return new self($major * 10000 + $minor * 100);
+ }
+
+ /**
+ * Get the newest PHP version supported by this library. Support for this version may be partial,
+ * if it is still under development.
+ */
+ public static function getNewestSupported(): self {
+ return self::fromComponents(8, 5);
+ }
+
+ /**
+ * Get the host PHP version, that is the PHP version we're currently running on.
+ */
+ public static function getHostVersion(): self {
+ return self::fromComponents(\PHP_MAJOR_VERSION, \PHP_MINOR_VERSION);
+ }
+
+ /**
+ * Parse the version from a string like "8.1".
+ */
+ public static function fromString(string $version): self {
+ if (!preg_match('/^(\d+)\.(\d+)/', $version, $matches)) {
+ throw new \LogicException("Invalid PHP version \"$version\"");
+ }
+ return self::fromComponents((int) $matches[1], (int) $matches[2]);
+ }
+
+ /**
+ * Check whether two versions are the same.
+ */
+ public function equals(PhpVersion $other): bool {
+ return $this->id === $other->id;
+ }
+
+ /**
+ * Check whether this version is greater than or equal to the argument.
+ */
+ public function newerOrEqual(PhpVersion $other): bool {
+ return $this->id >= $other->id;
+ }
+
+ /**
+ * Check whether this version is older than the argument.
+ */
+ public function older(PhpVersion $other): bool {
+ return $this->id < $other->id;
+ }
+
+ /**
+ * Check whether this is the host PHP version.
+ */
+ public function isHostVersion(): bool {
+ return $this->equals(self::getHostVersion());
+ }
+
+ /**
+ * Check whether this PHP version supports the given builtin type. Type name must be lowercase.
+ */
+ public function supportsBuiltinType(string $type): bool {
+ $minVersion = self::BUILTIN_TYPE_VERSIONS[$type] ?? null;
+ return $minVersion !== null && $this->id >= $minVersion;
+ }
+
+ /**
+ * Whether this version supports [] array literals.
+ */
+ public function supportsShortArraySyntax(): bool {
+ return $this->id >= 50400;
+ }
+
+ /**
+ * Whether this version supports [] for destructuring.
+ */
+ public function supportsShortArrayDestructuring(): bool {
+ return $this->id >= 70100;
+ }
+
+ /**
+ * Whether this version supports flexible heredoc/nowdoc.
+ */
+ public function supportsFlexibleHeredoc(): bool {
+ return $this->id >= 70300;
+ }
+
+ /**
+ * Whether this version supports trailing commas in parameter lists.
+ */
+ public function supportsTrailingCommaInParamList(): bool {
+ return $this->id >= 80000;
+ }
+
+ /**
+ * Whether this version allows "$var =& new Obj".
+ */
+ public function allowsAssignNewByReference(): bool {
+ return $this->id < 70000;
+ }
+
+ /**
+ * Whether this version allows invalid octals like "08".
+ */
+ public function allowsInvalidOctals(): bool {
+ return $this->id < 70000;
+ }
+
+ /**
+ * Whether this version allows DEL (\x7f) to occur in identifiers.
+ */
+ public function allowsDelInIdentifiers(): bool {
+ return $this->id < 70100;
+ }
+
+ /**
+ * Whether this version supports yield in expression context without parentheses.
+ */
+ public function supportsYieldWithoutParentheses(): bool {
+ return $this->id >= 70000;
+ }
+
+ /**
+ * Whether this version supports unicode escape sequences in strings.
+ */
+ public function supportsUnicodeEscapes(): bool {
+ return $this->id >= 70000;
+ }
+
+ /*
+ * Whether this version supports attributes.
+ */
+ public function supportsAttributes(): bool {
+ return $this->id >= 80000;
+ }
+
+ public function supportsNewDereferenceWithoutParentheses(): bool {
+ return $this->id >= 80400;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/PrettyPrinter.php b/vendor/nikic/php-parser/lib/PhpParser/PrettyPrinter.php
new file mode 100644
index 0000000..892c686
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/PrettyPrinter.php
@@ -0,0 +1,51 @@
+pAttrGroups($node->attrGroups, $this->phpVersion->supportsAttributes())
+ . $this->pModifiers($node->flags)
+ . ($node->type ? $this->p($node->type) . ' ' : '')
+ . ($node->byRef ? '&' : '')
+ . ($node->variadic ? '...' : '')
+ . $this->p($node->var)
+ . ($node->default ? ' = ' . $this->p($node->default) : '')
+ . ($node->hooks ? ' {' . $this->pStmts($node->hooks) . $this->nl . '}' : '');
+ }
+
+ protected function pArg(Node\Arg $node): string {
+ return ($node->name ? $node->name->toString() . ': ' : '')
+ . ($node->byRef ? '&' : '') . ($node->unpack ? '...' : '')
+ . $this->p($node->value);
+ }
+
+ protected function pVariadicPlaceholder(Node\VariadicPlaceholder $node): string {
+ return '...';
+ }
+
+ protected function pConst(Node\Const_ $node): string {
+ return $node->name . ' = ' . $this->p($node->value);
+ }
+
+ protected function pNullableType(Node\NullableType $node): string {
+ return '?' . $this->p($node->type);
+ }
+
+ protected function pUnionType(Node\UnionType $node): string {
+ $types = [];
+ foreach ($node->types as $typeNode) {
+ if ($typeNode instanceof Node\IntersectionType) {
+ $types[] = '('. $this->p($typeNode) . ')';
+ continue;
+ }
+ $types[] = $this->p($typeNode);
+ }
+ return implode('|', $types);
+ }
+
+ protected function pIntersectionType(Node\IntersectionType $node): string {
+ return $this->pImplode($node->types, '&');
+ }
+
+ protected function pIdentifier(Node\Identifier $node): string {
+ return $node->name;
+ }
+
+ protected function pVarLikeIdentifier(Node\VarLikeIdentifier $node): string {
+ return '$' . $node->name;
+ }
+
+ protected function pAttribute(Node\Attribute $node): string {
+ return $this->p($node->name)
+ . ($node->args ? '(' . $this->pCommaSeparated($node->args) . ')' : '');
+ }
+
+ protected function pAttributeGroup(Node\AttributeGroup $node): string {
+ return '#[' . $this->pCommaSeparated($node->attrs) . ']';
+ }
+
+ // Names
+
+ protected function pName(Name $node): string {
+ return $node->name;
+ }
+
+ protected function pName_FullyQualified(Name\FullyQualified $node): string {
+ return '\\' . $node->name;
+ }
+
+ protected function pName_Relative(Name\Relative $node): string {
+ return 'namespace\\' . $node->name;
+ }
+
+ // Magic Constants
+
+ protected function pScalar_MagicConst_Class(MagicConst\Class_ $node): string {
+ return '__CLASS__';
+ }
+
+ protected function pScalar_MagicConst_Dir(MagicConst\Dir $node): string {
+ return '__DIR__';
+ }
+
+ protected function pScalar_MagicConst_File(MagicConst\File $node): string {
+ return '__FILE__';
+ }
+
+ protected function pScalar_MagicConst_Function(MagicConst\Function_ $node): string {
+ return '__FUNCTION__';
+ }
+
+ protected function pScalar_MagicConst_Line(MagicConst\Line $node): string {
+ return '__LINE__';
+ }
+
+ protected function pScalar_MagicConst_Method(MagicConst\Method $node): string {
+ return '__METHOD__';
+ }
+
+ protected function pScalar_MagicConst_Namespace(MagicConst\Namespace_ $node): string {
+ return '__NAMESPACE__';
+ }
+
+ protected function pScalar_MagicConst_Trait(MagicConst\Trait_ $node): string {
+ return '__TRAIT__';
+ }
+
+ protected function pScalar_MagicConst_Property(MagicConst\Property $node): string {
+ return '__PROPERTY__';
+ }
+
+ // Scalars
+
+ private function indentString(string $str): string {
+ return str_replace("\n", $this->nl, $str);
+ }
+
+ protected function pScalar_String(Scalar\String_ $node): string {
+ $kind = $node->getAttribute('kind', Scalar\String_::KIND_SINGLE_QUOTED);
+ switch ($kind) {
+ case Scalar\String_::KIND_NOWDOC:
+ $label = $node->getAttribute('docLabel');
+ if ($label && !$this->containsEndLabel($node->value, $label)) {
+ $shouldIdent = $this->phpVersion->supportsFlexibleHeredoc();
+ $nl = $shouldIdent ? $this->nl : $this->newline;
+ if ($node->value === '') {
+ return "<<<'$label'$nl$label{$this->docStringEndToken}";
+ }
+
+ // Make sure trailing \r is not combined with following \n into CRLF.
+ if ($node->value[strlen($node->value) - 1] !== "\r") {
+ $value = $shouldIdent ? $this->indentString($node->value) : $node->value;
+ return "<<<'$label'$nl$value$nl$label{$this->docStringEndToken}";
+ }
+ }
+ /* break missing intentionally */
+ // no break
+ case Scalar\String_::KIND_SINGLE_QUOTED:
+ return $this->pSingleQuotedString($node->value);
+ case Scalar\String_::KIND_HEREDOC:
+ $label = $node->getAttribute('docLabel');
+ $escaped = $this->escapeString($node->value, null);
+ if ($label && !$this->containsEndLabel($escaped, $label)) {
+ $nl = $this->phpVersion->supportsFlexibleHeredoc() ? $this->nl : $this->newline;
+ if ($escaped === '') {
+ return "<<<$label$nl$label{$this->docStringEndToken}";
+ }
+
+ return "<<<$label$nl$escaped$nl$label{$this->docStringEndToken}";
+ }
+ /* break missing intentionally */
+ // no break
+ case Scalar\String_::KIND_DOUBLE_QUOTED:
+ return '"' . $this->escapeString($node->value, '"') . '"';
+ }
+ throw new \Exception('Invalid string kind');
+ }
+
+ protected function pScalar_InterpolatedString(Scalar\InterpolatedString $node): string {
+ if ($node->getAttribute('kind') === Scalar\String_::KIND_HEREDOC) {
+ $label = $node->getAttribute('docLabel');
+ if ($label && !$this->encapsedContainsEndLabel($node->parts, $label)) {
+ $nl = $this->phpVersion->supportsFlexibleHeredoc() ? $this->nl : $this->newline;
+ if (count($node->parts) === 1
+ && $node->parts[0] instanceof Node\InterpolatedStringPart
+ && $node->parts[0]->value === ''
+ ) {
+ return "<<<$label$nl$label{$this->docStringEndToken}";
+ }
+
+ return "<<<$label$nl" . $this->pEncapsList($node->parts, null)
+ . "$nl$label{$this->docStringEndToken}";
+ }
+ }
+ return '"' . $this->pEncapsList($node->parts, '"') . '"';
+ }
+
+ protected function pScalar_Int(Scalar\Int_ $node): string {
+ if ($node->getAttribute('shouldPrintRawValue') === true) {
+ return $node->getAttribute('rawValue');
+ }
+
+ if ($node->value === -\PHP_INT_MAX - 1) {
+ // PHP_INT_MIN cannot be represented as a literal,
+ // because the sign is not part of the literal
+ return '(-' . \PHP_INT_MAX . '-1)';
+ }
+
+ $kind = $node->getAttribute('kind', Scalar\Int_::KIND_DEC);
+
+ if (Scalar\Int_::KIND_DEC === $kind) {
+ return (string) $node->value;
+ }
+
+ if ($node->value < 0) {
+ $sign = '-';
+ $str = (string) -$node->value;
+ } else {
+ $sign = '';
+ $str = (string) $node->value;
+ }
+ switch ($kind) {
+ case Scalar\Int_::KIND_BIN:
+ return $sign . '0b' . base_convert($str, 10, 2);
+ case Scalar\Int_::KIND_OCT:
+ return $sign . '0' . base_convert($str, 10, 8);
+ case Scalar\Int_::KIND_HEX:
+ return $sign . '0x' . base_convert($str, 10, 16);
+ }
+ throw new \Exception('Invalid number kind');
+ }
+
+ protected function pScalar_Float(Scalar\Float_ $node): string {
+ if (!is_finite($node->value)) {
+ if ($node->value === \INF) {
+ return '1.0E+1000';
+ }
+ if ($node->value === -\INF) {
+ return '-1.0E+1000';
+ } else {
+ return '\NAN';
+ }
+ }
+
+ // Try to find a short full-precision representation
+ $stringValue = sprintf('%.16G', $node->value);
+ if ($node->value !== (float) $stringValue) {
+ $stringValue = sprintf('%.17G', $node->value);
+ }
+
+ // %G is locale dependent and there exists no locale-independent alternative. We don't want
+ // mess with switching locales here, so let's assume that a comma is the only non-standard
+ // decimal separator we may encounter...
+ $stringValue = str_replace(',', '.', $stringValue);
+
+ // ensure that number is really printed as float
+ return preg_match('/^-?[0-9]+$/', $stringValue) ? $stringValue . '.0' : $stringValue;
+ }
+
+ // Assignments
+
+ protected function pExpr_Assign(Expr\Assign $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(Expr\Assign::class, $this->p($node->var) . ' = ', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_AssignRef(Expr\AssignRef $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(Expr\AssignRef::class, $this->p($node->var) . ' =& ', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_AssignOp_Plus(AssignOp\Plus $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(AssignOp\Plus::class, $this->p($node->var) . ' += ', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_AssignOp_Minus(AssignOp\Minus $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(AssignOp\Minus::class, $this->p($node->var) . ' -= ', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_AssignOp_Mul(AssignOp\Mul $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(AssignOp\Mul::class, $this->p($node->var) . ' *= ', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_AssignOp_Div(AssignOp\Div $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(AssignOp\Div::class, $this->p($node->var) . ' /= ', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_AssignOp_Concat(AssignOp\Concat $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(AssignOp\Concat::class, $this->p($node->var) . ' .= ', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_AssignOp_Mod(AssignOp\Mod $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(AssignOp\Mod::class, $this->p($node->var) . ' %= ', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_AssignOp_BitwiseAnd(AssignOp\BitwiseAnd $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(AssignOp\BitwiseAnd::class, $this->p($node->var) . ' &= ', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_AssignOp_BitwiseOr(AssignOp\BitwiseOr $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(AssignOp\BitwiseOr::class, $this->p($node->var) . ' |= ', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_AssignOp_BitwiseXor(AssignOp\BitwiseXor $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(AssignOp\BitwiseXor::class, $this->p($node->var) . ' ^= ', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_AssignOp_ShiftLeft(AssignOp\ShiftLeft $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(AssignOp\ShiftLeft::class, $this->p($node->var) . ' <<= ', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_AssignOp_ShiftRight(AssignOp\ShiftRight $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(AssignOp\ShiftRight::class, $this->p($node->var) . ' >>= ', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_AssignOp_Pow(AssignOp\Pow $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(AssignOp\Pow::class, $this->p($node->var) . ' **= ', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_AssignOp_Coalesce(AssignOp\Coalesce $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(AssignOp\Coalesce::class, $this->p($node->var) . ' ??= ', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ // Binary expressions
+
+ protected function pExpr_BinaryOp_Plus(BinaryOp\Plus $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pInfixOp(BinaryOp\Plus::class, $node->left, ' + ', $node->right, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_BinaryOp_Minus(BinaryOp\Minus $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pInfixOp(BinaryOp\Minus::class, $node->left, ' - ', $node->right, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_BinaryOp_Mul(BinaryOp\Mul $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pInfixOp(BinaryOp\Mul::class, $node->left, ' * ', $node->right, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_BinaryOp_Div(BinaryOp\Div $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pInfixOp(BinaryOp\Div::class, $node->left, ' / ', $node->right, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_BinaryOp_Concat(BinaryOp\Concat $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pInfixOp(BinaryOp\Concat::class, $node->left, ' . ', $node->right, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_BinaryOp_Mod(BinaryOp\Mod $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pInfixOp(BinaryOp\Mod::class, $node->left, ' % ', $node->right, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_BinaryOp_BooleanAnd(BinaryOp\BooleanAnd $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pInfixOp(BinaryOp\BooleanAnd::class, $node->left, ' && ', $node->right, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_BinaryOp_BooleanOr(BinaryOp\BooleanOr $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pInfixOp(BinaryOp\BooleanOr::class, $node->left, ' || ', $node->right, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_BinaryOp_BitwiseAnd(BinaryOp\BitwiseAnd $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pInfixOp(BinaryOp\BitwiseAnd::class, $node->left, ' & ', $node->right, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_BinaryOp_BitwiseOr(BinaryOp\BitwiseOr $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pInfixOp(BinaryOp\BitwiseOr::class, $node->left, ' | ', $node->right, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_BinaryOp_BitwiseXor(BinaryOp\BitwiseXor $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pInfixOp(BinaryOp\BitwiseXor::class, $node->left, ' ^ ', $node->right, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_BinaryOp_ShiftLeft(BinaryOp\ShiftLeft $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pInfixOp(BinaryOp\ShiftLeft::class, $node->left, ' << ', $node->right, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_BinaryOp_ShiftRight(BinaryOp\ShiftRight $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pInfixOp(BinaryOp\ShiftRight::class, $node->left, ' >> ', $node->right, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_BinaryOp_Pow(BinaryOp\Pow $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pInfixOp(BinaryOp\Pow::class, $node->left, ' ** ', $node->right, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_BinaryOp_LogicalAnd(BinaryOp\LogicalAnd $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pInfixOp(BinaryOp\LogicalAnd::class, $node->left, ' and ', $node->right, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_BinaryOp_LogicalOr(BinaryOp\LogicalOr $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pInfixOp(BinaryOp\LogicalOr::class, $node->left, ' or ', $node->right, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_BinaryOp_LogicalXor(BinaryOp\LogicalXor $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pInfixOp(BinaryOp\LogicalXor::class, $node->left, ' xor ', $node->right, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_BinaryOp_Equal(BinaryOp\Equal $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pInfixOp(BinaryOp\Equal::class, $node->left, ' == ', $node->right, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_BinaryOp_NotEqual(BinaryOp\NotEqual $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pInfixOp(BinaryOp\NotEqual::class, $node->left, ' != ', $node->right, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_BinaryOp_Identical(BinaryOp\Identical $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pInfixOp(BinaryOp\Identical::class, $node->left, ' === ', $node->right, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_BinaryOp_NotIdentical(BinaryOp\NotIdentical $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pInfixOp(BinaryOp\NotIdentical::class, $node->left, ' !== ', $node->right, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_BinaryOp_Spaceship(BinaryOp\Spaceship $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pInfixOp(BinaryOp\Spaceship::class, $node->left, ' <=> ', $node->right, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_BinaryOp_Greater(BinaryOp\Greater $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pInfixOp(BinaryOp\Greater::class, $node->left, ' > ', $node->right, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_BinaryOp_GreaterOrEqual(BinaryOp\GreaterOrEqual $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pInfixOp(BinaryOp\GreaterOrEqual::class, $node->left, ' >= ', $node->right, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_BinaryOp_Smaller(BinaryOp\Smaller $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pInfixOp(BinaryOp\Smaller::class, $node->left, ' < ', $node->right, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_BinaryOp_SmallerOrEqual(BinaryOp\SmallerOrEqual $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pInfixOp(BinaryOp\SmallerOrEqual::class, $node->left, ' <= ', $node->right, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_BinaryOp_Coalesce(BinaryOp\Coalesce $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pInfixOp(BinaryOp\Coalesce::class, $node->left, ' ?? ', $node->right, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_BinaryOp_Pipe(BinaryOp\Pipe $node, int $precedence, int $lhsPrecedence): string {
+ if ($node->right instanceof Expr\ArrowFunction) {
+ // Force parentheses around arrow functions.
+ $lhsPrecedence = $this->precedenceMap[Expr\ArrowFunction::class][0];
+ }
+ return $this->pInfixOp(BinaryOp\Pipe::class, $node->left, ' |> ', $node->right, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_Instanceof(Expr\Instanceof_ $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPostfixOp(
+ Expr\Instanceof_::class, $node->expr,
+ ' instanceof ' . $this->pNewOperand($node->class),
+ $precedence, $lhsPrecedence);
+ }
+
+ // Unary expressions
+
+ protected function pExpr_BooleanNot(Expr\BooleanNot $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(Expr\BooleanNot::class, '!', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_BitwiseNot(Expr\BitwiseNot $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(Expr\BitwiseNot::class, '~', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_UnaryMinus(Expr\UnaryMinus $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(Expr\UnaryMinus::class, '-', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_UnaryPlus(Expr\UnaryPlus $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(Expr\UnaryPlus::class, '+', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_PreInc(Expr\PreInc $node): string {
+ return '++' . $this->p($node->var);
+ }
+
+ protected function pExpr_PreDec(Expr\PreDec $node): string {
+ return '--' . $this->p($node->var);
+ }
+
+ protected function pExpr_PostInc(Expr\PostInc $node): string {
+ return $this->p($node->var) . '++';
+ }
+
+ protected function pExpr_PostDec(Expr\PostDec $node): string {
+ return $this->p($node->var) . '--';
+ }
+
+ protected function pExpr_ErrorSuppress(Expr\ErrorSuppress $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(Expr\ErrorSuppress::class, '@', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_YieldFrom(Expr\YieldFrom $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(Expr\YieldFrom::class, 'yield from ', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_Print(Expr\Print_ $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(Expr\Print_::class, 'print ', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ // Casts
+
+ protected function pExpr_Cast_Int(Cast\Int_ $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(Cast\Int_::class, '(int) ', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_Cast_Double(Cast\Double $node, int $precedence, int $lhsPrecedence): string {
+ $kind = $node->getAttribute('kind', Cast\Double::KIND_DOUBLE);
+ if ($kind === Cast\Double::KIND_DOUBLE) {
+ $cast = '(double)';
+ } elseif ($kind === Cast\Double::KIND_FLOAT) {
+ $cast = '(float)';
+ } else {
+ assert($kind === Cast\Double::KIND_REAL);
+ $cast = '(real)';
+ }
+ return $this->pPrefixOp(Cast\Double::class, $cast . ' ', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_Cast_String(Cast\String_ $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(Cast\String_::class, '(string) ', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_Cast_Array(Cast\Array_ $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(Cast\Array_::class, '(array) ', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_Cast_Object(Cast\Object_ $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(Cast\Object_::class, '(object) ', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_Cast_Bool(Cast\Bool_ $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(Cast\Bool_::class, '(bool) ', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_Cast_Unset(Cast\Unset_ $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(Cast\Unset_::class, '(unset) ', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_Cast_Void(Cast\Void_ $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(Cast\Void_::class, '(void) ', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ // Function calls and similar constructs
+
+ protected function pExpr_FuncCall(Expr\FuncCall $node): string {
+ return $this->pCallLhs($node->name)
+ . '(' . $this->pMaybeMultiline($node->args) . ')';
+ }
+
+ protected function pExpr_MethodCall(Expr\MethodCall $node): string {
+ return $this->pDereferenceLhs($node->var) . '->' . $this->pObjectProperty($node->name)
+ . '(' . $this->pMaybeMultiline($node->args) . ')';
+ }
+
+ protected function pExpr_NullsafeMethodCall(Expr\NullsafeMethodCall $node): string {
+ return $this->pDereferenceLhs($node->var) . '?->' . $this->pObjectProperty($node->name)
+ . '(' . $this->pMaybeMultiline($node->args) . ')';
+ }
+
+ protected function pExpr_StaticCall(Expr\StaticCall $node): string {
+ return $this->pStaticDereferenceLhs($node->class) . '::'
+ . ($node->name instanceof Expr
+ ? ($node->name instanceof Expr\Variable
+ ? $this->p($node->name)
+ : '{' . $this->p($node->name) . '}')
+ : $node->name)
+ . '(' . $this->pMaybeMultiline($node->args) . ')';
+ }
+
+ protected function pExpr_Empty(Expr\Empty_ $node): string {
+ return 'empty(' . $this->p($node->expr) . ')';
+ }
+
+ protected function pExpr_Isset(Expr\Isset_ $node): string {
+ return 'isset(' . $this->pCommaSeparated($node->vars) . ')';
+ }
+
+ protected function pExpr_Eval(Expr\Eval_ $node): string {
+ return 'eval(' . $this->p($node->expr) . ')';
+ }
+
+ protected function pExpr_Include(Expr\Include_ $node, int $precedence, int $lhsPrecedence): string {
+ static $map = [
+ Expr\Include_::TYPE_INCLUDE => 'include',
+ Expr\Include_::TYPE_INCLUDE_ONCE => 'include_once',
+ Expr\Include_::TYPE_REQUIRE => 'require',
+ Expr\Include_::TYPE_REQUIRE_ONCE => 'require_once',
+ ];
+
+ return $this->pPrefixOp(Expr\Include_::class, $map[$node->type] . ' ', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_List(Expr\List_ $node): string {
+ $syntax = $node->getAttribute('kind',
+ $this->phpVersion->supportsShortArrayDestructuring() ? Expr\List_::KIND_ARRAY : Expr\List_::KIND_LIST);
+ if ($syntax === Expr\List_::KIND_ARRAY) {
+ return '[' . $this->pMaybeMultiline($node->items, true) . ']';
+ } else {
+ return 'list(' . $this->pMaybeMultiline($node->items, true) . ')';
+ }
+ }
+
+ // Other
+
+ protected function pExpr_Error(Expr\Error $node): string {
+ throw new \LogicException('Cannot pretty-print AST with Error nodes');
+ }
+
+ protected function pExpr_Variable(Expr\Variable $node): string {
+ if ($node->name instanceof Expr) {
+ return '${' . $this->p($node->name) . '}';
+ } else {
+ return '$' . $node->name;
+ }
+ }
+
+ protected function pExpr_Array(Expr\Array_ $node): string {
+ $syntax = $node->getAttribute('kind',
+ $this->shortArraySyntax ? Expr\Array_::KIND_SHORT : Expr\Array_::KIND_LONG);
+ if ($syntax === Expr\Array_::KIND_SHORT) {
+ return '[' . $this->pMaybeMultiline($node->items, true) . ']';
+ } else {
+ return 'array(' . $this->pMaybeMultiline($node->items, true) . ')';
+ }
+ }
+
+ protected function pKey(?Node $node): string {
+ if ($node === null) {
+ return '';
+ }
+
+ // => is not really an operator and does not typically participate in precedence resolution.
+ // However, there is an exception if yield expressions with keys are involved:
+ // [yield $a => $b] is interpreted as [(yield $a => $b)], so we need to ensure that
+ // [(yield $a) => $b] is printed with parentheses. We approximate this by lowering the LHS
+ // precedence to that of yield (which will also print unnecessary parentheses for rare low
+ // precedence unary operators like include).
+ $yieldPrecedence = $this->precedenceMap[Expr\Yield_::class][0];
+ return $this->p($node, self::MAX_PRECEDENCE, $yieldPrecedence) . ' => ';
+ }
+
+ protected function pArrayItem(Node\ArrayItem $node): string {
+ return $this->pKey($node->key)
+ . ($node->byRef ? '&' : '')
+ . ($node->unpack ? '...' : '')
+ . $this->p($node->value);
+ }
+
+ protected function pExpr_ArrayDimFetch(Expr\ArrayDimFetch $node): string {
+ return $this->pDereferenceLhs($node->var)
+ . '[' . (null !== $node->dim ? $this->p($node->dim) : '') . ']';
+ }
+
+ protected function pExpr_ConstFetch(Expr\ConstFetch $node): string {
+ return $this->p($node->name);
+ }
+
+ protected function pExpr_ClassConstFetch(Expr\ClassConstFetch $node): string {
+ return $this->pStaticDereferenceLhs($node->class) . '::' . $this->pObjectProperty($node->name);
+ }
+
+ protected function pExpr_PropertyFetch(Expr\PropertyFetch $node): string {
+ return $this->pDereferenceLhs($node->var) . '->' . $this->pObjectProperty($node->name);
+ }
+
+ protected function pExpr_NullsafePropertyFetch(Expr\NullsafePropertyFetch $node): string {
+ return $this->pDereferenceLhs($node->var) . '?->' . $this->pObjectProperty($node->name);
+ }
+
+ protected function pExpr_StaticPropertyFetch(Expr\StaticPropertyFetch $node): string {
+ return $this->pStaticDereferenceLhs($node->class) . '::$' . $this->pObjectProperty($node->name);
+ }
+
+ protected function pExpr_ShellExec(Expr\ShellExec $node): string {
+ return '`' . $this->pEncapsList($node->parts, '`') . '`';
+ }
+
+ protected function pExpr_Closure(Expr\Closure $node): string {
+ return $this->pAttrGroups($node->attrGroups, true)
+ . $this->pStatic($node->static)
+ . 'function ' . ($node->byRef ? '&' : '')
+ . '(' . $this->pParams($node->params) . ')'
+ . (!empty($node->uses) ? ' use (' . $this->pCommaSeparated($node->uses) . ')' : '')
+ . (null !== $node->returnType ? ': ' . $this->p($node->returnType) : '')
+ . ' {' . $this->pStmts($node->stmts) . $this->nl . '}';
+ }
+
+ protected function pExpr_Match(Expr\Match_ $node): string {
+ return 'match (' . $this->p($node->cond) . ') {'
+ . $this->pCommaSeparatedMultiline($node->arms, true)
+ . $this->nl
+ . '}';
+ }
+
+ protected function pMatchArm(Node\MatchArm $node): string {
+ $result = '';
+ if ($node->conds) {
+ for ($i = 0, $c = \count($node->conds); $i + 1 < $c; $i++) {
+ $result .= $this->p($node->conds[$i]) . ', ';
+ }
+ $result .= $this->pKey($node->conds[$i]);
+ } else {
+ $result = 'default => ';
+ }
+ return $result . $this->p($node->body);
+ }
+
+ protected function pExpr_ArrowFunction(Expr\ArrowFunction $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(
+ Expr\ArrowFunction::class,
+ $this->pAttrGroups($node->attrGroups, true)
+ . $this->pStatic($node->static)
+ . 'fn' . ($node->byRef ? '&' : '')
+ . '(' . $this->pParams($node->params) . ')'
+ . (null !== $node->returnType ? ': ' . $this->p($node->returnType) : '')
+ . ' => ',
+ $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pClosureUse(Node\ClosureUse $node): string {
+ return ($node->byRef ? '&' : '') . $this->p($node->var);
+ }
+
+ protected function pExpr_New(Expr\New_ $node): string {
+ if ($node->class instanceof Stmt\Class_) {
+ $args = $node->args ? '(' . $this->pMaybeMultiline($node->args) . ')' : '';
+ return 'new ' . $this->pClassCommon($node->class, $args);
+ }
+ return 'new ' . $this->pNewOperand($node->class)
+ . '(' . $this->pMaybeMultiline($node->args) . ')';
+ }
+
+ protected function pExpr_Clone(Expr\Clone_ $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(Expr\Clone_::class, 'clone ', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_Ternary(Expr\Ternary $node, int $precedence, int $lhsPrecedence): string {
+ // a bit of cheating: we treat the ternary as a binary op where the ?...: part is the operator.
+ // this is okay because the part between ? and : never needs parentheses.
+ return $this->pInfixOp(Expr\Ternary::class,
+ $node->cond, ' ?' . (null !== $node->if ? ' ' . $this->p($node->if) . ' ' : '') . ': ', $node->else,
+ $precedence, $lhsPrecedence
+ );
+ }
+
+ protected function pExpr_Exit(Expr\Exit_ $node): string {
+ $kind = $node->getAttribute('kind', Expr\Exit_::KIND_DIE);
+ return ($kind === Expr\Exit_::KIND_EXIT ? 'exit' : 'die')
+ . (null !== $node->expr ? '(' . $this->p($node->expr) . ')' : '');
+ }
+
+ protected function pExpr_Throw(Expr\Throw_ $node, int $precedence, int $lhsPrecedence): string {
+ return $this->pPrefixOp(Expr\Throw_::class, 'throw ', $node->expr, $precedence, $lhsPrecedence);
+ }
+
+ protected function pExpr_Yield(Expr\Yield_ $node, int $precedence, int $lhsPrecedence): string {
+ if ($node->value === null) {
+ $opPrecedence = $this->precedenceMap[Expr\Yield_::class][0];
+ return $opPrecedence >= $lhsPrecedence ? '(yield)' : 'yield';
+ } else {
+ if (!$this->phpVersion->supportsYieldWithoutParentheses()) {
+ return '(yield ' . $this->pKey($node->key) . $this->p($node->value) . ')';
+ }
+ return $this->pPrefixOp(
+ Expr\Yield_::class, 'yield ' . $this->pKey($node->key),
+ $node->value, $precedence, $lhsPrecedence);
+ }
+ }
+
+ // Declarations
+
+ protected function pStmt_Namespace(Stmt\Namespace_ $node): string {
+ if ($this->canUseSemicolonNamespaces) {
+ return 'namespace ' . $this->p($node->name) . ';'
+ . $this->nl . $this->pStmts($node->stmts, false);
+ } else {
+ return 'namespace' . (null !== $node->name ? ' ' . $this->p($node->name) : '')
+ . ' {' . $this->pStmts($node->stmts) . $this->nl . '}';
+ }
+ }
+
+ protected function pStmt_Use(Stmt\Use_ $node): string {
+ return 'use ' . $this->pUseType($node->type)
+ . $this->pCommaSeparated($node->uses) . ';';
+ }
+
+ protected function pStmt_GroupUse(Stmt\GroupUse $node): string {
+ return 'use ' . $this->pUseType($node->type) . $this->pName($node->prefix)
+ . '\{' . $this->pCommaSeparated($node->uses) . '};';
+ }
+
+ protected function pUseItem(Node\UseItem $node): string {
+ return $this->pUseType($node->type) . $this->p($node->name)
+ . (null !== $node->alias ? ' as ' . $node->alias : '');
+ }
+
+ protected function pUseType(int $type): string {
+ return $type === Stmt\Use_::TYPE_FUNCTION ? 'function '
+ : ($type === Stmt\Use_::TYPE_CONSTANT ? 'const ' : '');
+ }
+
+ protected function pStmt_Interface(Stmt\Interface_ $node): string {
+ return $this->pAttrGroups($node->attrGroups)
+ . 'interface ' . $node->name
+ . (!empty($node->extends) ? ' extends ' . $this->pCommaSeparated($node->extends) : '')
+ . $this->nl . '{' . $this->pStmts($node->stmts) . $this->nl . '}';
+ }
+
+ protected function pStmt_Enum(Stmt\Enum_ $node): string {
+ return $this->pAttrGroups($node->attrGroups)
+ . 'enum ' . $node->name
+ . ($node->scalarType ? ' : ' . $this->p($node->scalarType) : '')
+ . (!empty($node->implements) ? ' implements ' . $this->pCommaSeparated($node->implements) : '')
+ . $this->nl . '{' . $this->pStmts($node->stmts) . $this->nl . '}';
+ }
+
+ protected function pStmt_Class(Stmt\Class_ $node): string {
+ return $this->pClassCommon($node, ' ' . $node->name);
+ }
+
+ protected function pStmt_Trait(Stmt\Trait_ $node): string {
+ return $this->pAttrGroups($node->attrGroups)
+ . 'trait ' . $node->name
+ . $this->nl . '{' . $this->pStmts($node->stmts) . $this->nl . '}';
+ }
+
+ protected function pStmt_EnumCase(Stmt\EnumCase $node): string {
+ return $this->pAttrGroups($node->attrGroups)
+ . 'case ' . $node->name
+ . ($node->expr ? ' = ' . $this->p($node->expr) : '')
+ . ';';
+ }
+
+ protected function pStmt_TraitUse(Stmt\TraitUse $node): string {
+ return 'use ' . $this->pCommaSeparated($node->traits)
+ . (empty($node->adaptations)
+ ? ';'
+ : ' {' . $this->pStmts($node->adaptations) . $this->nl . '}');
+ }
+
+ protected function pStmt_TraitUseAdaptation_Precedence(Stmt\TraitUseAdaptation\Precedence $node): string {
+ return $this->p($node->trait) . '::' . $node->method
+ . ' insteadof ' . $this->pCommaSeparated($node->insteadof) . ';';
+ }
+
+ protected function pStmt_TraitUseAdaptation_Alias(Stmt\TraitUseAdaptation\Alias $node): string {
+ return (null !== $node->trait ? $this->p($node->trait) . '::' : '')
+ . $node->method . ' as'
+ . (null !== $node->newModifier ? ' ' . rtrim($this->pModifiers($node->newModifier), ' ') : '')
+ . (null !== $node->newName ? ' ' . $node->newName : '')
+ . ';';
+ }
+
+ protected function pStmt_Property(Stmt\Property $node): string {
+ return $this->pAttrGroups($node->attrGroups)
+ . (0 === $node->flags ? 'var ' : $this->pModifiers($node->flags))
+ . ($node->type ? $this->p($node->type) . ' ' : '')
+ . $this->pCommaSeparated($node->props)
+ . ($node->hooks ? ' {' . $this->pStmts($node->hooks) . $this->nl . '}' : ';');
+ }
+
+ protected function pPropertyItem(Node\PropertyItem $node): string {
+ return '$' . $node->name
+ . (null !== $node->default ? ' = ' . $this->p($node->default) : '');
+ }
+
+ protected function pPropertyHook(Node\PropertyHook $node): string {
+ return $this->pAttrGroups($node->attrGroups)
+ . $this->pModifiers($node->flags)
+ . ($node->byRef ? '&' : '') . $node->name
+ . ($node->params ? '(' . $this->pParams($node->params) . ')' : '')
+ . (\is_array($node->body) ? ' {' . $this->pStmts($node->body) . $this->nl . '}'
+ : ($node->body !== null ? ' => ' . $this->p($node->body) : '') . ';');
+ }
+
+ protected function pStmt_ClassMethod(Stmt\ClassMethod $node): string {
+ return $this->pAttrGroups($node->attrGroups)
+ . $this->pModifiers($node->flags)
+ . 'function ' . ($node->byRef ? '&' : '') . $node->name
+ . '(' . $this->pParams($node->params) . ')'
+ . (null !== $node->returnType ? ': ' . $this->p($node->returnType) : '')
+ . (null !== $node->stmts
+ ? $this->nl . '{' . $this->pStmts($node->stmts) . $this->nl . '}'
+ : ';');
+ }
+
+ protected function pStmt_ClassConst(Stmt\ClassConst $node): string {
+ return $this->pAttrGroups($node->attrGroups)
+ . $this->pModifiers($node->flags)
+ . 'const '
+ . (null !== $node->type ? $this->p($node->type) . ' ' : '')
+ . $this->pCommaSeparated($node->consts) . ';';
+ }
+
+ protected function pStmt_Function(Stmt\Function_ $node): string {
+ return $this->pAttrGroups($node->attrGroups)
+ . 'function ' . ($node->byRef ? '&' : '') . $node->name
+ . '(' . $this->pParams($node->params) . ')'
+ . (null !== $node->returnType ? ': ' . $this->p($node->returnType) : '')
+ . $this->nl . '{' . $this->pStmts($node->stmts) . $this->nl . '}';
+ }
+
+ protected function pStmt_Const(Stmt\Const_ $node): string {
+ return $this->pAttrGroups($node->attrGroups)
+ . 'const '
+ . $this->pCommaSeparated($node->consts) . ';';
+ }
+
+ protected function pStmt_Declare(Stmt\Declare_ $node): string {
+ return 'declare (' . $this->pCommaSeparated($node->declares) . ')'
+ . (null !== $node->stmts ? ' {' . $this->pStmts($node->stmts) . $this->nl . '}' : ';');
+ }
+
+ protected function pDeclareItem(Node\DeclareItem $node): string {
+ return $node->key . '=' . $this->p($node->value);
+ }
+
+ // Control flow
+
+ protected function pStmt_If(Stmt\If_ $node): string {
+ return 'if (' . $this->p($node->cond) . ') {'
+ . $this->pStmts($node->stmts) . $this->nl . '}'
+ . ($node->elseifs ? ' ' . $this->pImplode($node->elseifs, ' ') : '')
+ . (null !== $node->else ? ' ' . $this->p($node->else) : '');
+ }
+
+ protected function pStmt_ElseIf(Stmt\ElseIf_ $node): string {
+ return 'elseif (' . $this->p($node->cond) . ') {'
+ . $this->pStmts($node->stmts) . $this->nl . '}';
+ }
+
+ protected function pStmt_Else(Stmt\Else_ $node): string {
+ if (\count($node->stmts) === 1 && $node->stmts[0] instanceof Stmt\If_) {
+ // Print as "else if" rather than "else { if }"
+ return 'else ' . $this->p($node->stmts[0]);
+ }
+ return 'else {' . $this->pStmts($node->stmts) . $this->nl . '}';
+ }
+
+ protected function pStmt_For(Stmt\For_ $node): string {
+ return 'for ('
+ . $this->pCommaSeparated($node->init) . ';' . (!empty($node->cond) ? ' ' : '')
+ . $this->pCommaSeparated($node->cond) . ';' . (!empty($node->loop) ? ' ' : '')
+ . $this->pCommaSeparated($node->loop)
+ . ') {' . $this->pStmts($node->stmts) . $this->nl . '}';
+ }
+
+ protected function pStmt_Foreach(Stmt\Foreach_ $node): string {
+ return 'foreach (' . $this->p($node->expr) . ' as '
+ . (null !== $node->keyVar ? $this->p($node->keyVar) . ' => ' : '')
+ . ($node->byRef ? '&' : '') . $this->p($node->valueVar) . ') {'
+ . $this->pStmts($node->stmts) . $this->nl . '}';
+ }
+
+ protected function pStmt_While(Stmt\While_ $node): string {
+ return 'while (' . $this->p($node->cond) . ') {'
+ . $this->pStmts($node->stmts) . $this->nl . '}';
+ }
+
+ protected function pStmt_Do(Stmt\Do_ $node): string {
+ return 'do {' . $this->pStmts($node->stmts) . $this->nl
+ . '} while (' . $this->p($node->cond) . ');';
+ }
+
+ protected function pStmt_Switch(Stmt\Switch_ $node): string {
+ return 'switch (' . $this->p($node->cond) . ') {'
+ . $this->pStmts($node->cases) . $this->nl . '}';
+ }
+
+ protected function pStmt_Case(Stmt\Case_ $node): string {
+ return (null !== $node->cond ? 'case ' . $this->p($node->cond) : 'default') . ':'
+ . $this->pStmts($node->stmts);
+ }
+
+ protected function pStmt_TryCatch(Stmt\TryCatch $node): string {
+ return 'try {' . $this->pStmts($node->stmts) . $this->nl . '}'
+ . ($node->catches ? ' ' . $this->pImplode($node->catches, ' ') : '')
+ . ($node->finally !== null ? ' ' . $this->p($node->finally) : '');
+ }
+
+ protected function pStmt_Catch(Stmt\Catch_ $node): string {
+ return 'catch (' . $this->pImplode($node->types, '|')
+ . ($node->var !== null ? ' ' . $this->p($node->var) : '')
+ . ') {' . $this->pStmts($node->stmts) . $this->nl . '}';
+ }
+
+ protected function pStmt_Finally(Stmt\Finally_ $node): string {
+ return 'finally {' . $this->pStmts($node->stmts) . $this->nl . '}';
+ }
+
+ protected function pStmt_Break(Stmt\Break_ $node): string {
+ return 'break' . ($node->num !== null ? ' ' . $this->p($node->num) : '') . ';';
+ }
+
+ protected function pStmt_Continue(Stmt\Continue_ $node): string {
+ return 'continue' . ($node->num !== null ? ' ' . $this->p($node->num) : '') . ';';
+ }
+
+ protected function pStmt_Return(Stmt\Return_ $node): string {
+ return 'return' . (null !== $node->expr ? ' ' . $this->p($node->expr) : '') . ';';
+ }
+
+ protected function pStmt_Label(Stmt\Label $node): string {
+ return $node->name . ':';
+ }
+
+ protected function pStmt_Goto(Stmt\Goto_ $node): string {
+ return 'goto ' . $node->name . ';';
+ }
+
+ // Other
+
+ protected function pStmt_Expression(Stmt\Expression $node): string {
+ return $this->p($node->expr) . ';';
+ }
+
+ protected function pStmt_Echo(Stmt\Echo_ $node): string {
+ return 'echo ' . $this->pCommaSeparated($node->exprs) . ';';
+ }
+
+ protected function pStmt_Static(Stmt\Static_ $node): string {
+ return 'static ' . $this->pCommaSeparated($node->vars) . ';';
+ }
+
+ protected function pStmt_Global(Stmt\Global_ $node): string {
+ return 'global ' . $this->pCommaSeparated($node->vars) . ';';
+ }
+
+ protected function pStaticVar(Node\StaticVar $node): string {
+ return $this->p($node->var)
+ . (null !== $node->default ? ' = ' . $this->p($node->default) : '');
+ }
+
+ protected function pStmt_Unset(Stmt\Unset_ $node): string {
+ return 'unset(' . $this->pCommaSeparated($node->vars) . ');';
+ }
+
+ protected function pStmt_InlineHTML(Stmt\InlineHTML $node): string {
+ $newline = $node->getAttribute('hasLeadingNewline', true) ? $this->newline : '';
+ return '?>' . $newline . $node->value . 'remaining;
+ }
+
+ protected function pStmt_Nop(Stmt\Nop $node): string {
+ return '';
+ }
+
+ protected function pStmt_Block(Stmt\Block $node): string {
+ return '{' . $this->pStmts($node->stmts) . $this->nl . '}';
+ }
+
+ // Helpers
+
+ protected function pClassCommon(Stmt\Class_ $node, string $afterClassToken): string {
+ return $this->pAttrGroups($node->attrGroups, $node->name === null)
+ . $this->pModifiers($node->flags)
+ . 'class' . $afterClassToken
+ . (null !== $node->extends ? ' extends ' . $this->p($node->extends) : '')
+ . (!empty($node->implements) ? ' implements ' . $this->pCommaSeparated($node->implements) : '')
+ . $this->nl . '{' . $this->pStmts($node->stmts) . $this->nl . '}';
+ }
+
+ protected function pObjectProperty(Node $node): string {
+ if ($node instanceof Expr) {
+ return '{' . $this->p($node) . '}';
+ } else {
+ assert($node instanceof Node\Identifier);
+ return $node->name;
+ }
+ }
+
+ /** @param (Expr|Node\InterpolatedStringPart)[] $encapsList */
+ protected function pEncapsList(array $encapsList, ?string $quote): string {
+ $return = '';
+ foreach ($encapsList as $element) {
+ if ($element instanceof Node\InterpolatedStringPart) {
+ $return .= $this->escapeString($element->value, $quote);
+ } else {
+ $return .= '{' . $this->p($element) . '}';
+ }
+ }
+
+ return $return;
+ }
+
+ protected function pSingleQuotedString(string $string): string {
+ // It is idiomatic to only escape backslashes when necessary, i.e. when followed by ', \ or
+ // the end of the string ('Foo\Bar' instead of 'Foo\\Bar'). However, we also don't want to
+ // produce an odd number of backslashes, so '\\\\a' should not get rendered as '\\\a', even
+ // though that would be legal.
+ $regex = '/\'|\\\\(?=[\'\\\\]|$)|(?<=\\\\)\\\\/';
+ return '\'' . preg_replace($regex, '\\\\$0', $string) . '\'';
+ }
+
+ protected function escapeString(string $string, ?string $quote): string {
+ if (null === $quote) {
+ // For doc strings, don't escape newlines
+ $escaped = addcslashes($string, "\t\f\v$\\");
+ // But do escape isolated \r. Combined with the terminating newline, it might get
+ // interpreted as \r\n and dropped from the string contents.
+ $escaped = preg_replace('/\r(?!\n)/', '\\r', $escaped);
+ if ($this->phpVersion->supportsFlexibleHeredoc()) {
+ $escaped = $this->indentString($escaped);
+ }
+ } else {
+ $escaped = addcslashes($string, "\n\r\t\f\v$" . $quote . "\\");
+ }
+
+ // Escape control characters and non-UTF-8 characters.
+ // Regex based on https://stackoverflow.com/a/11709412/385378.
+ $regex = '/(
+ [\x00-\x08\x0E-\x1F] # Control characters
+ | [\xC0-\xC1] # Invalid UTF-8 Bytes
+ | [\xF5-\xFF] # Invalid UTF-8 Bytes
+ | \xE0(?=[\x80-\x9F]) # Overlong encoding of prior code point
+ | \xF0(?=[\x80-\x8F]) # Overlong encoding of prior code point
+ | [\xC2-\xDF](?![\x80-\xBF]) # Invalid UTF-8 Sequence Start
+ | [\xE0-\xEF](?![\x80-\xBF]{2}) # Invalid UTF-8 Sequence Start
+ | [\xF0-\xF4](?![\x80-\xBF]{3}) # Invalid UTF-8 Sequence Start
+ | (?<=[\x00-\x7F\xF5-\xFF])[\x80-\xBF] # Invalid UTF-8 Sequence Middle
+ | (? $part) {
+ if ($part instanceof Node\InterpolatedStringPart
+ && $this->containsEndLabel($this->escapeString($part->value, null), $label, $i === 0)
+ ) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ protected function pDereferenceLhs(Node $node): string {
+ if (!$this->dereferenceLhsRequiresParens($node)) {
+ return $this->p($node);
+ } else {
+ return '(' . $this->p($node) . ')';
+ }
+ }
+
+ protected function pStaticDereferenceLhs(Node $node): string {
+ if (!$this->staticDereferenceLhsRequiresParens($node)) {
+ return $this->p($node);
+ } else {
+ return '(' . $this->p($node) . ')';
+ }
+ }
+
+ protected function pCallLhs(Node $node): string {
+ if (!$this->callLhsRequiresParens($node)) {
+ return $this->p($node);
+ } else {
+ return '(' . $this->p($node) . ')';
+ }
+ }
+
+ protected function pNewOperand(Node $node): string {
+ if (!$this->newOperandRequiresParens($node)) {
+ return $this->p($node);
+ } else {
+ return '(' . $this->p($node) . ')';
+ }
+ }
+
+ /**
+ * @param Node[] $nodes
+ */
+ protected function hasNodeWithComments(array $nodes): bool {
+ foreach ($nodes as $node) {
+ if ($node && $node->getComments()) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /** @param Node[] $nodes */
+ protected function pMaybeMultiline(array $nodes, bool $trailingComma = false): string {
+ if (!$this->hasNodeWithComments($nodes)) {
+ return $this->pCommaSeparated($nodes);
+ } else {
+ return $this->pCommaSeparatedMultiline($nodes, $trailingComma) . $this->nl;
+ }
+ }
+
+ /** @param Node\Param[] $params
+ */
+ private function hasParamWithAttributes(array $params): bool {
+ foreach ($params as $param) {
+ if ($param->attrGroups) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /** @param Node\Param[] $params */
+ protected function pParams(array $params): string {
+ if ($this->hasNodeWithComments($params) ||
+ ($this->hasParamWithAttributes($params) && !$this->phpVersion->supportsAttributes())
+ ) {
+ return $this->pCommaSeparatedMultiline($params, $this->phpVersion->supportsTrailingCommaInParamList()) . $this->nl;
+ }
+ return $this->pCommaSeparated($params);
+ }
+
+ /** @param Node\AttributeGroup[] $nodes */
+ protected function pAttrGroups(array $nodes, bool $inline = false): string {
+ $result = '';
+ $sep = $inline ? ' ' : $this->nl;
+ foreach ($nodes as $node) {
+ $result .= $this->p($node) . $sep;
+ }
+
+ return $result;
+ }
+}
diff --git a/vendor/nikic/php-parser/lib/PhpParser/PrettyPrinterAbstract.php b/vendor/nikic/php-parser/lib/PhpParser/PrettyPrinterAbstract.php
new file mode 100644
index 0000000..448bc84
--- /dev/null
+++ b/vendor/nikic/php-parser/lib/PhpParser/PrettyPrinterAbstract.php
@@ -0,0 +1,1706 @@
+ */
+ protected array $precedenceMap = [
+ // [precedence, precedenceLHS, precedenceRHS]
+ // Where the latter two are the precedences to use for the LHS and RHS of a binary operator,
+ // where 1 is added to one of the sides depending on associativity. This information is not
+ // used for unary operators and set to -1.
+ Expr\Clone_::class => [-10, 0, 1],
+ BinaryOp\Pow::class => [ 0, 0, 1],
+ Expr\BitwiseNot::class => [ 10, -1, -1],
+ Expr\UnaryPlus::class => [ 10, -1, -1],
+ Expr\UnaryMinus::class => [ 10, -1, -1],
+ Cast\Int_::class => [ 10, -1, -1],
+ Cast\Double::class => [ 10, -1, -1],
+ Cast\String_::class => [ 10, -1, -1],
+ Cast\Array_::class => [ 10, -1, -1],
+ Cast\Object_::class => [ 10, -1, -1],
+ Cast\Bool_::class => [ 10, -1, -1],
+ Cast\Unset_::class => [ 10, -1, -1],
+ Expr\ErrorSuppress::class => [ 10, -1, -1],
+ Expr\Instanceof_::class => [ 20, -1, -1],
+ Expr\BooleanNot::class => [ 30, -1, -1],
+ BinaryOp\Mul::class => [ 40, 41, 40],
+ BinaryOp\Div::class => [ 40, 41, 40],
+ BinaryOp\Mod::class => [ 40, 41, 40],
+ BinaryOp\Plus::class => [ 50, 51, 50],
+ BinaryOp\Minus::class => [ 50, 51, 50],
+ // FIXME: This precedence is incorrect for PHP 8.
+ BinaryOp\Concat::class => [ 50, 51, 50],
+ BinaryOp\ShiftLeft::class => [ 60, 61, 60],
+ BinaryOp\ShiftRight::class => [ 60, 61, 60],
+ BinaryOp\Pipe::class => [ 65, 66, 65],
+ BinaryOp\Smaller::class => [ 70, 70, 70],
+ BinaryOp\SmallerOrEqual::class => [ 70, 70, 70],
+ BinaryOp\Greater::class => [ 70, 70, 70],
+ BinaryOp\GreaterOrEqual::class => [ 70, 70, 70],
+ BinaryOp\Equal::class => [ 80, 80, 80],
+ BinaryOp\NotEqual::class => [ 80, 80, 80],
+ BinaryOp\Identical::class => [ 80, 80, 80],
+ BinaryOp\NotIdentical::class => [ 80, 80, 80],
+ BinaryOp\Spaceship::class => [ 80, 80, 80],
+ BinaryOp\BitwiseAnd::class => [ 90, 91, 90],
+ BinaryOp\BitwiseXor::class => [100, 101, 100],
+ BinaryOp\BitwiseOr::class => [110, 111, 110],
+ BinaryOp\BooleanAnd::class => [120, 121, 120],
+ BinaryOp\BooleanOr::class => [130, 131, 130],
+ BinaryOp\Coalesce::class => [140, 140, 141],
+ Expr\Ternary::class => [150, 150, 150],
+ Expr\Assign::class => [160, -1, -1],
+ Expr\AssignRef::class => [160, -1, -1],
+ AssignOp\Plus::class => [160, -1, -1],
+ AssignOp\Minus::class => [160, -1, -1],
+ AssignOp\Mul::class => [160, -1, -1],
+ AssignOp\Div::class => [160, -1, -1],
+ AssignOp\Concat::class => [160, -1, -1],
+ AssignOp\Mod::class => [160, -1, -1],
+ AssignOp\BitwiseAnd::class => [160, -1, -1],
+ AssignOp\BitwiseOr::class => [160, -1, -1],
+ AssignOp\BitwiseXor::class => [160, -1, -1],
+ AssignOp\ShiftLeft::class => [160, -1, -1],
+ AssignOp\ShiftRight::class => [160, -1, -1],
+ AssignOp\Pow::class => [160, -1, -1],
+ AssignOp\Coalesce::class => [160, -1, -1],
+ Expr\YieldFrom::class => [170, -1, -1],
+ Expr\Yield_::class => [175, -1, -1],
+ Expr\Print_::class => [180, -1, -1],
+ BinaryOp\LogicalAnd::class => [190, 191, 190],
+ BinaryOp\LogicalXor::class => [200, 201, 200],
+ BinaryOp\LogicalOr::class => [210, 211, 210],
+ Expr\Include_::class => [220, -1, -1],
+ Expr\ArrowFunction::class => [230, -1, -1],
+ Expr\Throw_::class => [240, -1, -1],
+ Expr\Cast\Void_::class => [250, -1, -1],
+ ];
+
+ /** @var int Current indentation level. */
+ protected int $indentLevel;
+ /** @var string String for single level of indentation */
+ private string $indent;
+ /** @var int Width in spaces to indent by. */
+ private int $indentWidth;
+ /** @var bool Whether to use tab indentation. */
+ private bool $useTabs;
+ /** @var int Width in spaces of one tab. */
+ private int $tabWidth = 4;
+
+ /** @var string Newline style. Does not include current indentation. */
+ protected string $newline;
+ /** @var string Newline including current indentation. */
+ protected string $nl;
+ /** @var string|null Token placed at end of doc string to ensure it is followed by a newline.
+ * Null if flexible doc strings are used. */
+ protected ?string $docStringEndToken;
+ /** @var bool Whether semicolon namespaces can be used (i.e. no global namespace is used) */
+ protected bool $canUseSemicolonNamespaces;
+ /** @var bool Whether to use short array syntax if the node specifies no preference */
+ protected bool $shortArraySyntax;
+ /** @var PhpVersion PHP version to target */
+ protected PhpVersion $phpVersion;
+
+ /** @var TokenStream|null Original tokens for use in format-preserving pretty print */
+ protected ?TokenStream $origTokens;
+ /** @var Internal\Differ Differ for node lists */
+ protected Differ $nodeListDiffer;
+ /** @var array Map determining whether a certain character is a label character */
+ protected array $labelCharMap;
+ /**
+ * @var array> Map from token classes and subnode names to FIXUP_* constants.
+ * This is used during format-preserving prints to place additional parens/braces if necessary.
+ */
+ protected array $fixupMap;
+ /**
+ * @var array 
+
+[support-level-image]: https://img.shields.io/badge/support-active-green.svg
+[php-image]: https://img.shields.io/badge/php-7.4%2B-green.svg
+[packagist-image]: https://img.shields.io/packagist/dt/10up/wp_mock.svg
+[packagist-url]: https://packagist.org/packages/10up/wp_mock
+[coveralls-image]: https://coveralls.io/repos/github/10up/wp_mock/badge.svg?branch=trunk
+[coveralls-url]: https://coveralls.io/github/10up/wp_mock?branch=trunk
+[license-image]: https://img.shields.io/badge/License-BSD%203--Clause-blue.svg
+[license-url]: https://github.com/10up/wp_mock/blob/trunk/LICENSE.md
\ No newline at end of file
diff --git a/vendor/10up/wp_mock/bootstrap.php.dist b/vendor/10up/wp_mock/bootstrap.php.dist
new file mode 100644
index 0000000..7bb2440
--- /dev/null
+++ b/vendor/10up/wp_mock/bootstrap.php.dist
@@ -0,0 +1,5 @@
+=7.4 < 9",
+ "phpunit/phpunit": "^9.6",
+ "mockery/mockery": "^1.6",
+ "antecedent/patchwork": "^2.1"
+ },
+ "require-dev": {
+ "behat/behat": "^v3.11.0",
+ "sebastian/comparator": "^4.0.8",
+ "php-coveralls/php-coveralls": "^v2.7",
+ "sempro/phpunit-pretty-print": "^1.4",
+ "phpstan/phpstan": "^1.10",
+ "phpstan/phpstan-phpunit": "^1.3",
+ "phpstan/phpstan-mockery": "^1.1",
+ "phpcompatibility/php-compatibility": "^9.3",
+ "php-stubs/wordpress-globals": "^0.2",
+ "php-stubs/wordpress-stubs": "^6.3",
+ "friendsofphp/php-cs-fixer": "^3.4",
+ "dealerdirect/phpcodesniffer-composer-installer": "^0.7"
+ },
+ "autoload": {
+ "psr-4": {
+ "WP_Mock\\": "./php/WP_Mock"
+ },
+ "classmap": [
+ "php/WP_Mock.php"
+ ]
+ },
+ "autoload-dev": {
+ "psr-4": {
+ "WP_Mock\\Tests\\": "tests/"
+ },
+ "classmap": [
+ "tests"
+ ]
+ },
+ "config": {
+ "platform": {
+ "php": "7.4"
+ },
+ "allow-plugins": {
+ "dealerdirect/phpcodesniffer-composer-installer": true
+ }
+ },
+ "scripts": {
+ "test:behat": "behat",
+ "test:phpunit": "phpunit",
+ "test:phpunitcov": "phpunit --coverage-clover build/logs/clover.xml",
+ "test": [
+ "@test:behat",
+ "@test:phpunit"
+ ],
+ "coverage": [
+ "@test:behat",
+ "@test:phpunitcov"
+ ],
+ "post-install-cmd": "\"vendor/bin/phpcs\" --config-set installed_paths vendor/phpcompatibility/php-compatibility",
+ "post-update-cmd": "\"vendor/bin/phpcs\" --config-set installed_paths vendor/phpcompatibility/php-compatibility"
+ }
+}
diff --git a/vendor/10up/wp_mock/composer.lock b/vendor/10up/wp_mock/composer.lock
new file mode 100644
index 0000000..0104ad1
--- /dev/null
+++ b/vendor/10up/wp_mock/composer.lock
@@ -0,0 +1,5518 @@
+{
+ "_readme": [
+ "This file locks the dependencies of your project to a known state",
+ "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
+ "This file is @generated automatically"
+ ],
+ "content-hash": "a1855a9cad4977b6e16eb92ce3a72929",
+ "packages": [
+ {
+ "name": "antecedent/patchwork",
+ "version": "2.1.27",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/antecedent/patchwork.git",
+ "reference": "16a1ab81559aabf14acb616141e801b32777f085"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/antecedent/patchwork/zipball/16a1ab81559aabf14acb616141e801b32777f085",
+ "reference": "16a1ab81559aabf14acb616141e801b32777f085",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=5.4.0"
+ },
+ "require-dev": {
+ "phpunit/phpunit": ">=4"
+ },
+ "type": "library",
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Ignas Rudaitis",
+ "email": "ignas.rudaitis@gmail.com"
+ }
+ ],
+ "description": "Method redefinition (monkey-patching) functionality for PHP.",
+ "homepage": "https://antecedent.github.io/patchwork/",
+ "keywords": [
+ "aop",
+ "aspect",
+ "interception",
+ "monkeypatching",
+ "redefinition",
+ "runkit",
+ "testing"
+ ],
+ "support": {
+ "issues": "https://github.com/antecedent/patchwork/issues",
+ "source": "https://github.com/antecedent/patchwork/tree/2.1.27"
+ },
+ "time": "2023-12-03T18:46:49+00:00"
+ },
+ {
+ "name": "doctrine/instantiator",
+ "version": "1.5.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/doctrine/instantiator.git",
+ "reference": "0a0fa9780f5d4e507415a065172d26a98d02047b"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/doctrine/instantiator/zipball/0a0fa9780f5d4e507415a065172d26a98d02047b",
+ "reference": "0a0fa9780f5d4e507415a065172d26a98d02047b",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.1 || ^8.0"
+ },
+ "require-dev": {
+ "doctrine/coding-standard": "^9 || ^11",
+ "ext-pdo": "*",
+ "ext-phar": "*",
+ "phpbench/phpbench": "^0.16 || ^1",
+ "phpstan/phpstan": "^1.4",
+ "phpstan/phpstan-phpunit": "^1",
+ "phpunit/phpunit": "^7.5 || ^8.5 || ^9.5",
+ "vimeo/psalm": "^4.30 || ^5.4"
+ },
+ "type": "library",
+ "autoload": {
+ "psr-4": {
+ "Doctrine\\Instantiator\\": "src/Doctrine/Instantiator/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Marco Pivetta",
+ "email": "ocramius@gmail.com",
+ "homepage": "https://ocramius.github.io/"
+ }
+ ],
+ "description": "A small, lightweight utility to instantiate objects in PHP without invoking their constructors",
+ "homepage": "https://www.doctrine-project.org/projects/instantiator.html",
+ "keywords": [
+ "constructor",
+ "instantiate"
+ ],
+ "support": {
+ "issues": "https://github.com/doctrine/instantiator/issues",
+ "source": "https://github.com/doctrine/instantiator/tree/1.5.0"
+ },
+ "funding": [
+ {
+ "url": "https://www.doctrine-project.org/sponsorship.html",
+ "type": "custom"
+ },
+ {
+ "url": "https://www.patreon.com/phpdoctrine",
+ "type": "patreon"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/doctrine%2Finstantiator",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2022-12-30T00:15:36+00:00"
+ },
+ {
+ "name": "hamcrest/hamcrest-php",
+ "version": "v2.0.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/hamcrest/hamcrest-php.git",
+ "reference": "8c3d0a3f6af734494ad8f6fbbee0ba92422859f3"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/hamcrest/hamcrest-php/zipball/8c3d0a3f6af734494ad8f6fbbee0ba92422859f3",
+ "reference": "8c3d0a3f6af734494ad8f6fbbee0ba92422859f3",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^5.3|^7.0|^8.0"
+ },
+ "replace": {
+ "cordoval/hamcrest-php": "*",
+ "davedevelopment/hamcrest-php": "*",
+ "kodova/hamcrest-php": "*"
+ },
+ "require-dev": {
+ "phpunit/php-file-iterator": "^1.4 || ^2.0",
+ "phpunit/phpunit": "^4.8.36 || ^5.7 || ^6.5 || ^7.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "2.1-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "hamcrest"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "description": "This is the PHP port of Hamcrest Matchers",
+ "keywords": [
+ "test"
+ ],
+ "support": {
+ "issues": "https://github.com/hamcrest/hamcrest-php/issues",
+ "source": "https://github.com/hamcrest/hamcrest-php/tree/v2.0.1"
+ },
+ "time": "2020-07-09T08:09:16+00:00"
+ },
+ {
+ "name": "mockery/mockery",
+ "version": "1.6.7",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/mockery/mockery.git",
+ "reference": "0cc058854b3195ba21dc6b1f7b1f60f4ef3a9c06"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/mockery/mockery/zipball/0cc058854b3195ba21dc6b1f7b1f60f4ef3a9c06",
+ "reference": "0cc058854b3195ba21dc6b1f7b1f60f4ef3a9c06",
+ "shasum": ""
+ },
+ "require": {
+ "hamcrest/hamcrest-php": "^2.0.1",
+ "lib-pcre": ">=7.0",
+ "php": ">=7.3"
+ },
+ "conflict": {
+ "phpunit/phpunit": "<8.0"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^8.5 || ^9.6.10",
+ "symplify/easy-coding-standard": "^12.0.8"
+ },
+ "type": "library",
+ "autoload": {
+ "files": [
+ "library/helpers.php",
+ "library/Mockery.php"
+ ],
+ "psr-4": {
+ "Mockery\\": "library/Mockery"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Pádraic Brady",
+ "email": "padraic.brady@gmail.com",
+ "homepage": "https://github.com/padraic",
+ "role": "Author"
+ },
+ {
+ "name": "Dave Marshall",
+ "email": "dave.marshall@atstsolutions.co.uk",
+ "homepage": "https://davedevelopment.co.uk",
+ "role": "Developer"
+ },
+ {
+ "name": "Nathanael Esayeas",
+ "email": "nathanael.esayeas@protonmail.com",
+ "homepage": "https://github.com/ghostwriter",
+ "role": "Lead Developer"
+ }
+ ],
+ "description": "Mockery is a simple yet flexible PHP mock object framework",
+ "homepage": "https://github.com/mockery/mockery",
+ "keywords": [
+ "BDD",
+ "TDD",
+ "library",
+ "mock",
+ "mock objects",
+ "mockery",
+ "stub",
+ "test",
+ "test double",
+ "testing"
+ ],
+ "support": {
+ "docs": "https://docs.mockery.io/",
+ "issues": "https://github.com/mockery/mockery/issues",
+ "rss": "https://github.com/mockery/mockery/releases.atom",
+ "security": "https://github.com/mockery/mockery/security/advisories",
+ "source": "https://github.com/mockery/mockery"
+ },
+ "time": "2023-12-10T02:24:34+00:00"
+ },
+ {
+ "name": "myclabs/deep-copy",
+ "version": "1.11.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/myclabs/DeepCopy.git",
+ "reference": "7284c22080590fb39f2ffa3e9057f10a4ddd0e0c"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/myclabs/DeepCopy/zipball/7284c22080590fb39f2ffa3e9057f10a4ddd0e0c",
+ "reference": "7284c22080590fb39f2ffa3e9057f10a4ddd0e0c",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.1 || ^8.0"
+ },
+ "conflict": {
+ "doctrine/collections": "<1.6.8",
+ "doctrine/common": "<2.13.3 || >=3,<3.2.2"
+ },
+ "require-dev": {
+ "doctrine/collections": "^1.6.8",
+ "doctrine/common": "^2.13.3 || ^3.2.2",
+ "phpunit/phpunit": "^7.5.20 || ^8.5.23 || ^9.5.13"
+ },
+ "type": "library",
+ "autoload": {
+ "files": [
+ "src/DeepCopy/deep_copy.php"
+ ],
+ "psr-4": {
+ "DeepCopy\\": "src/DeepCopy/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "description": "Create deep copies (clones) of your objects",
+ "keywords": [
+ "clone",
+ "copy",
+ "duplicate",
+ "object",
+ "object graph"
+ ],
+ "support": {
+ "issues": "https://github.com/myclabs/DeepCopy/issues",
+ "source": "https://github.com/myclabs/DeepCopy/tree/1.11.1"
+ },
+ "funding": [
+ {
+ "url": "https://tidelift.com/funding/github/packagist/myclabs/deep-copy",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2023-03-08T13:26:56+00:00"
+ },
+ {
+ "name": "nikic/php-parser",
+ "version": "v4.18.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/nikic/PHP-Parser.git",
+ "reference": "1bcbb2179f97633e98bbbc87044ee2611c7d7999"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/nikic/PHP-Parser/zipball/1bcbb2179f97633e98bbbc87044ee2611c7d7999",
+ "reference": "1bcbb2179f97633e98bbbc87044ee2611c7d7999",
+ "shasum": ""
+ },
+ "require": {
+ "ext-tokenizer": "*",
+ "php": ">=7.0"
+ },
+ "require-dev": {
+ "ircmaxell/php-yacc": "^0.0.7",
+ "phpunit/phpunit": "^6.5 || ^7.0 || ^8.0 || ^9.0"
+ },
+ "bin": [
+ "bin/php-parse"
+ ],
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "4.9-dev"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "PhpParser\\": "lib/PhpParser"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Nikita Popov"
+ }
+ ],
+ "description": "A PHP parser written in PHP",
+ "keywords": [
+ "parser",
+ "php"
+ ],
+ "support": {
+ "issues": "https://github.com/nikic/PHP-Parser/issues",
+ "source": "https://github.com/nikic/PHP-Parser/tree/v4.18.0"
+ },
+ "time": "2023-12-10T21:03:43+00:00"
+ },
+ {
+ "name": "phar-io/manifest",
+ "version": "2.0.3",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/phar-io/manifest.git",
+ "reference": "97803eca37d319dfa7826cc2437fc020857acb53"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/phar-io/manifest/zipball/97803eca37d319dfa7826cc2437fc020857acb53",
+ "reference": "97803eca37d319dfa7826cc2437fc020857acb53",
+ "shasum": ""
+ },
+ "require": {
+ "ext-dom": "*",
+ "ext-phar": "*",
+ "ext-xmlwriter": "*",
+ "phar-io/version": "^3.0.1",
+ "php": "^7.2 || ^8.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "2.0.x-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Arne Blankerts",
+ "email": "arne@blankerts.de",
+ "role": "Developer"
+ },
+ {
+ "name": "Sebastian Heuer",
+ "email": "sebastian@phpeople.de",
+ "role": "Developer"
+ },
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "Developer"
+ }
+ ],
+ "description": "Component for reading phar.io manifest information from a PHP Archive (PHAR)",
+ "support": {
+ "issues": "https://github.com/phar-io/manifest/issues",
+ "source": "https://github.com/phar-io/manifest/tree/2.0.3"
+ },
+ "time": "2021-07-20T11:28:43+00:00"
+ },
+ {
+ "name": "phar-io/version",
+ "version": "3.2.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/phar-io/version.git",
+ "reference": "4f7fd7836c6f332bb2933569e566a0d6c4cbed74"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/phar-io/version/zipball/4f7fd7836c6f332bb2933569e566a0d6c4cbed74",
+ "reference": "4f7fd7836c6f332bb2933569e566a0d6c4cbed74",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.2 || ^8.0"
+ },
+ "type": "library",
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Arne Blankerts",
+ "email": "arne@blankerts.de",
+ "role": "Developer"
+ },
+ {
+ "name": "Sebastian Heuer",
+ "email": "sebastian@phpeople.de",
+ "role": "Developer"
+ },
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "Developer"
+ }
+ ],
+ "description": "Library for handling version information and constraints",
+ "support": {
+ "issues": "https://github.com/phar-io/version/issues",
+ "source": "https://github.com/phar-io/version/tree/3.2.1"
+ },
+ "time": "2022-02-21T01:04:05+00:00"
+ },
+ {
+ "name": "phpunit/php-code-coverage",
+ "version": "9.2.30",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/php-code-coverage.git",
+ "reference": "ca2bd87d2f9215904682a9cb9bb37dda98e76089"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/php-code-coverage/zipball/ca2bd87d2f9215904682a9cb9bb37dda98e76089",
+ "reference": "ca2bd87d2f9215904682a9cb9bb37dda98e76089",
+ "shasum": ""
+ },
+ "require": {
+ "ext-dom": "*",
+ "ext-libxml": "*",
+ "ext-xmlwriter": "*",
+ "nikic/php-parser": "^4.18 || ^5.0",
+ "php": ">=7.3",
+ "phpunit/php-file-iterator": "^3.0.3",
+ "phpunit/php-text-template": "^2.0.2",
+ "sebastian/code-unit-reverse-lookup": "^2.0.2",
+ "sebastian/complexity": "^2.0",
+ "sebastian/environment": "^5.1.2",
+ "sebastian/lines-of-code": "^1.0.3",
+ "sebastian/version": "^3.0.1",
+ "theseer/tokenizer": "^1.2.0"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3"
+ },
+ "suggest": {
+ "ext-pcov": "PHP extension that provides line coverage",
+ "ext-xdebug": "PHP extension that provides line coverage as well as branch and path coverage"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "9.2-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Library that provides collection, processing, and rendering functionality for PHP code coverage information.",
+ "homepage": "https://github.com/sebastianbergmann/php-code-coverage",
+ "keywords": [
+ "coverage",
+ "testing",
+ "xunit"
+ ],
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/php-code-coverage/issues",
+ "security": "https://github.com/sebastianbergmann/php-code-coverage/security/policy",
+ "source": "https://github.com/sebastianbergmann/php-code-coverage/tree/9.2.30"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2023-12-22T06:47:57+00:00"
+ },
+ {
+ "name": "phpunit/php-file-iterator",
+ "version": "3.0.6",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/php-file-iterator.git",
+ "reference": "cf1c2e7c203ac650e352f4cc675a7021e7d1b3cf"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/php-file-iterator/zipball/cf1c2e7c203ac650e352f4cc675a7021e7d1b3cf",
+ "reference": "cf1c2e7c203ac650e352f4cc675a7021e7d1b3cf",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "3.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "FilterIterator implementation that filters files based on a list of suffixes.",
+ "homepage": "https://github.com/sebastianbergmann/php-file-iterator/",
+ "keywords": [
+ "filesystem",
+ "iterator"
+ ],
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/php-file-iterator/issues",
+ "source": "https://github.com/sebastianbergmann/php-file-iterator/tree/3.0.6"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2021-12-02T12:48:52+00:00"
+ },
+ {
+ "name": "phpunit/php-invoker",
+ "version": "3.1.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/php-invoker.git",
+ "reference": "5a10147d0aaf65b58940a0b72f71c9ac0423cc67"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/php-invoker/zipball/5a10147d0aaf65b58940a0b72f71c9ac0423cc67",
+ "reference": "5a10147d0aaf65b58940a0b72f71c9ac0423cc67",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "ext-pcntl": "*",
+ "phpunit/phpunit": "^9.3"
+ },
+ "suggest": {
+ "ext-pcntl": "*"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "3.1-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Invoke callables with a timeout",
+ "homepage": "https://github.com/sebastianbergmann/php-invoker/",
+ "keywords": [
+ "process"
+ ],
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/php-invoker/issues",
+ "source": "https://github.com/sebastianbergmann/php-invoker/tree/3.1.1"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2020-09-28T05:58:55+00:00"
+ },
+ {
+ "name": "phpunit/php-text-template",
+ "version": "2.0.4",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/php-text-template.git",
+ "reference": "5da5f67fc95621df9ff4c4e5a84d6a8a2acf7c28"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/php-text-template/zipball/5da5f67fc95621df9ff4c4e5a84d6a8a2acf7c28",
+ "reference": "5da5f67fc95621df9ff4c4e5a84d6a8a2acf7c28",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "2.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Simple template engine.",
+ "homepage": "https://github.com/sebastianbergmann/php-text-template/",
+ "keywords": [
+ "template"
+ ],
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/php-text-template/issues",
+ "source": "https://github.com/sebastianbergmann/php-text-template/tree/2.0.4"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2020-10-26T05:33:50+00:00"
+ },
+ {
+ "name": "phpunit/php-timer",
+ "version": "5.0.3",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/php-timer.git",
+ "reference": "5a63ce20ed1b5bf577850e2c4e87f4aa902afbd2"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/php-timer/zipball/5a63ce20ed1b5bf577850e2c4e87f4aa902afbd2",
+ "reference": "5a63ce20ed1b5bf577850e2c4e87f4aa902afbd2",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "5.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Utility class for timing",
+ "homepage": "https://github.com/sebastianbergmann/php-timer/",
+ "keywords": [
+ "timer"
+ ],
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/php-timer/issues",
+ "source": "https://github.com/sebastianbergmann/php-timer/tree/5.0.3"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2020-10-26T13:16:10+00:00"
+ },
+ {
+ "name": "phpunit/phpunit",
+ "version": "9.6.15",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/phpunit.git",
+ "reference": "05017b80304e0eb3f31d90194a563fd53a6021f1"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/phpunit/zipball/05017b80304e0eb3f31d90194a563fd53a6021f1",
+ "reference": "05017b80304e0eb3f31d90194a563fd53a6021f1",
+ "shasum": ""
+ },
+ "require": {
+ "doctrine/instantiator": "^1.3.1 || ^2",
+ "ext-dom": "*",
+ "ext-json": "*",
+ "ext-libxml": "*",
+ "ext-mbstring": "*",
+ "ext-xml": "*",
+ "ext-xmlwriter": "*",
+ "myclabs/deep-copy": "^1.10.1",
+ "phar-io/manifest": "^2.0.3",
+ "phar-io/version": "^3.0.2",
+ "php": ">=7.3",
+ "phpunit/php-code-coverage": "^9.2.28",
+ "phpunit/php-file-iterator": "^3.0.5",
+ "phpunit/php-invoker": "^3.1.1",
+ "phpunit/php-text-template": "^2.0.3",
+ "phpunit/php-timer": "^5.0.2",
+ "sebastian/cli-parser": "^1.0.1",
+ "sebastian/code-unit": "^1.0.6",
+ "sebastian/comparator": "^4.0.8",
+ "sebastian/diff": "^4.0.3",
+ "sebastian/environment": "^5.1.3",
+ "sebastian/exporter": "^4.0.5",
+ "sebastian/global-state": "^5.0.1",
+ "sebastian/object-enumerator": "^4.0.3",
+ "sebastian/resource-operations": "^3.0.3",
+ "sebastian/type": "^3.2",
+ "sebastian/version": "^3.0.2"
+ },
+ "suggest": {
+ "ext-soap": "To be able to generate mocks based on WSDL files",
+ "ext-xdebug": "PHP extension that provides line coverage as well as branch and path coverage"
+ },
+ "bin": [
+ "phpunit"
+ ],
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "9.6-dev"
+ }
+ },
+ "autoload": {
+ "files": [
+ "src/Framework/Assert/Functions.php"
+ ],
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "The PHP Unit Testing framework.",
+ "homepage": "https://phpunit.de/",
+ "keywords": [
+ "phpunit",
+ "testing",
+ "xunit"
+ ],
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/phpunit/issues",
+ "security": "https://github.com/sebastianbergmann/phpunit/security/policy",
+ "source": "https://github.com/sebastianbergmann/phpunit/tree/9.6.15"
+ },
+ "funding": [
+ {
+ "url": "https://phpunit.de/sponsors.html",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/phpunit/phpunit",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2023-12-01T16:55:19+00:00"
+ },
+ {
+ "name": "sebastian/cli-parser",
+ "version": "1.0.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/cli-parser.git",
+ "reference": "442e7c7e687e42adc03470c7b668bc4b2402c0b2"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/cli-parser/zipball/442e7c7e687e42adc03470c7b668bc4b2402c0b2",
+ "reference": "442e7c7e687e42adc03470c7b668bc4b2402c0b2",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Library for parsing CLI options",
+ "homepage": "https://github.com/sebastianbergmann/cli-parser",
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/cli-parser/issues",
+ "source": "https://github.com/sebastianbergmann/cli-parser/tree/1.0.1"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2020-09-28T06:08:49+00:00"
+ },
+ {
+ "name": "sebastian/code-unit",
+ "version": "1.0.8",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/code-unit.git",
+ "reference": "1fc9f64c0927627ef78ba436c9b17d967e68e120"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/code-unit/zipball/1fc9f64c0927627ef78ba436c9b17d967e68e120",
+ "reference": "1fc9f64c0927627ef78ba436c9b17d967e68e120",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Collection of value objects that represent the PHP code units",
+ "homepage": "https://github.com/sebastianbergmann/code-unit",
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/code-unit/issues",
+ "source": "https://github.com/sebastianbergmann/code-unit/tree/1.0.8"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2020-10-26T13:08:54+00:00"
+ },
+ {
+ "name": "sebastian/code-unit-reverse-lookup",
+ "version": "2.0.3",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/code-unit-reverse-lookup.git",
+ "reference": "ac91f01ccec49fb77bdc6fd1e548bc70f7faa3e5"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/code-unit-reverse-lookup/zipball/ac91f01ccec49fb77bdc6fd1e548bc70f7faa3e5",
+ "reference": "ac91f01ccec49fb77bdc6fd1e548bc70f7faa3e5",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "2.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Looks up which function or method a line of code belongs to",
+ "homepage": "https://github.com/sebastianbergmann/code-unit-reverse-lookup/",
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/code-unit-reverse-lookup/issues",
+ "source": "https://github.com/sebastianbergmann/code-unit-reverse-lookup/tree/2.0.3"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2020-09-28T05:30:19+00:00"
+ },
+ {
+ "name": "sebastian/comparator",
+ "version": "4.0.8",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/comparator.git",
+ "reference": "fa0f136dd2334583309d32b62544682ee972b51a"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/comparator/zipball/fa0f136dd2334583309d32b62544682ee972b51a",
+ "reference": "fa0f136dd2334583309d32b62544682ee972b51a",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3",
+ "sebastian/diff": "^4.0",
+ "sebastian/exporter": "^4.0"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "4.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ },
+ {
+ "name": "Jeff Welch",
+ "email": "whatthejeff@gmail.com"
+ },
+ {
+ "name": "Volker Dusch",
+ "email": "github@wallbash.com"
+ },
+ {
+ "name": "Bernhard Schussek",
+ "email": "bschussek@2bepublished.at"
+ }
+ ],
+ "description": "Provides the functionality to compare PHP values for equality",
+ "homepage": "https://github.com/sebastianbergmann/comparator",
+ "keywords": [
+ "comparator",
+ "compare",
+ "equality"
+ ],
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/comparator/issues",
+ "source": "https://github.com/sebastianbergmann/comparator/tree/4.0.8"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2022-09-14T12:41:17+00:00"
+ },
+ {
+ "name": "sebastian/complexity",
+ "version": "2.0.3",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/complexity.git",
+ "reference": "25f207c40d62b8b7aa32f5ab026c53561964053a"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/complexity/zipball/25f207c40d62b8b7aa32f5ab026c53561964053a",
+ "reference": "25f207c40d62b8b7aa32f5ab026c53561964053a",
+ "shasum": ""
+ },
+ "require": {
+ "nikic/php-parser": "^4.18 || ^5.0",
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "2.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Library for calculating the complexity of PHP code units",
+ "homepage": "https://github.com/sebastianbergmann/complexity",
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/complexity/issues",
+ "source": "https://github.com/sebastianbergmann/complexity/tree/2.0.3"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2023-12-22T06:19:30+00:00"
+ },
+ {
+ "name": "sebastian/diff",
+ "version": "4.0.5",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/diff.git",
+ "reference": "74be17022044ebaaecfdf0c5cd504fc9cd5a7131"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/diff/zipball/74be17022044ebaaecfdf0c5cd504fc9cd5a7131",
+ "reference": "74be17022044ebaaecfdf0c5cd504fc9cd5a7131",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3",
+ "symfony/process": "^4.2 || ^5"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "4.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ },
+ {
+ "name": "Kore Nordmann",
+ "email": "mail@kore-nordmann.de"
+ }
+ ],
+ "description": "Diff implementation",
+ "homepage": "https://github.com/sebastianbergmann/diff",
+ "keywords": [
+ "diff",
+ "udiff",
+ "unidiff",
+ "unified diff"
+ ],
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/diff/issues",
+ "source": "https://github.com/sebastianbergmann/diff/tree/4.0.5"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2023-05-07T05:35:17+00:00"
+ },
+ {
+ "name": "sebastian/environment",
+ "version": "5.1.5",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/environment.git",
+ "reference": "830c43a844f1f8d5b7a1f6d6076b784454d8b7ed"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/environment/zipball/830c43a844f1f8d5b7a1f6d6076b784454d8b7ed",
+ "reference": "830c43a844f1f8d5b7a1f6d6076b784454d8b7ed",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3"
+ },
+ "suggest": {
+ "ext-posix": "*"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "5.1-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Provides functionality to handle HHVM/PHP environments",
+ "homepage": "http://www.github.com/sebastianbergmann/environment",
+ "keywords": [
+ "Xdebug",
+ "environment",
+ "hhvm"
+ ],
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/environment/issues",
+ "source": "https://github.com/sebastianbergmann/environment/tree/5.1.5"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2023-02-03T06:03:51+00:00"
+ },
+ {
+ "name": "sebastian/exporter",
+ "version": "4.0.5",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/exporter.git",
+ "reference": "ac230ed27f0f98f597c8a2b6eb7ac563af5e5b9d"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/exporter/zipball/ac230ed27f0f98f597c8a2b6eb7ac563af5e5b9d",
+ "reference": "ac230ed27f0f98f597c8a2b6eb7ac563af5e5b9d",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3",
+ "sebastian/recursion-context": "^4.0"
+ },
+ "require-dev": {
+ "ext-mbstring": "*",
+ "phpunit/phpunit": "^9.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "4.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ },
+ {
+ "name": "Jeff Welch",
+ "email": "whatthejeff@gmail.com"
+ },
+ {
+ "name": "Volker Dusch",
+ "email": "github@wallbash.com"
+ },
+ {
+ "name": "Adam Harvey",
+ "email": "aharvey@php.net"
+ },
+ {
+ "name": "Bernhard Schussek",
+ "email": "bschussek@gmail.com"
+ }
+ ],
+ "description": "Provides the functionality to export PHP variables for visualization",
+ "homepage": "https://www.github.com/sebastianbergmann/exporter",
+ "keywords": [
+ "export",
+ "exporter"
+ ],
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/exporter/issues",
+ "source": "https://github.com/sebastianbergmann/exporter/tree/4.0.5"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2022-09-14T06:03:37+00:00"
+ },
+ {
+ "name": "sebastian/global-state",
+ "version": "5.0.6",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/global-state.git",
+ "reference": "bde739e7565280bda77be70044ac1047bc007e34"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/global-state/zipball/bde739e7565280bda77be70044ac1047bc007e34",
+ "reference": "bde739e7565280bda77be70044ac1047bc007e34",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3",
+ "sebastian/object-reflector": "^2.0",
+ "sebastian/recursion-context": "^4.0"
+ },
+ "require-dev": {
+ "ext-dom": "*",
+ "phpunit/phpunit": "^9.3"
+ },
+ "suggest": {
+ "ext-uopz": "*"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "5.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Snapshotting of global state",
+ "homepage": "http://www.github.com/sebastianbergmann/global-state",
+ "keywords": [
+ "global state"
+ ],
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/global-state/issues",
+ "source": "https://github.com/sebastianbergmann/global-state/tree/5.0.6"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2023-08-02T09:26:13+00:00"
+ },
+ {
+ "name": "sebastian/lines-of-code",
+ "version": "1.0.4",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/lines-of-code.git",
+ "reference": "e1e4a170560925c26d424b6a03aed157e7dcc5c5"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/lines-of-code/zipball/e1e4a170560925c26d424b6a03aed157e7dcc5c5",
+ "reference": "e1e4a170560925c26d424b6a03aed157e7dcc5c5",
+ "shasum": ""
+ },
+ "require": {
+ "nikic/php-parser": "^4.18 || ^5.0",
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Library for counting the lines of code in PHP source code",
+ "homepage": "https://github.com/sebastianbergmann/lines-of-code",
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/lines-of-code/issues",
+ "source": "https://github.com/sebastianbergmann/lines-of-code/tree/1.0.4"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2023-12-22T06:20:34+00:00"
+ },
+ {
+ "name": "sebastian/object-enumerator",
+ "version": "4.0.4",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/object-enumerator.git",
+ "reference": "5c9eeac41b290a3712d88851518825ad78f45c71"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/object-enumerator/zipball/5c9eeac41b290a3712d88851518825ad78f45c71",
+ "reference": "5c9eeac41b290a3712d88851518825ad78f45c71",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3",
+ "sebastian/object-reflector": "^2.0",
+ "sebastian/recursion-context": "^4.0"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "4.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Traverses array structures and object graphs to enumerate all referenced objects",
+ "homepage": "https://github.com/sebastianbergmann/object-enumerator/",
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/object-enumerator/issues",
+ "source": "https://github.com/sebastianbergmann/object-enumerator/tree/4.0.4"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2020-10-26T13:12:34+00:00"
+ },
+ {
+ "name": "sebastian/object-reflector",
+ "version": "2.0.4",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/object-reflector.git",
+ "reference": "b4f479ebdbf63ac605d183ece17d8d7fe49c15c7"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/object-reflector/zipball/b4f479ebdbf63ac605d183ece17d8d7fe49c15c7",
+ "reference": "b4f479ebdbf63ac605d183ece17d8d7fe49c15c7",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "2.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Allows reflection of object attributes, including inherited and non-public ones",
+ "homepage": "https://github.com/sebastianbergmann/object-reflector/",
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/object-reflector/issues",
+ "source": "https://github.com/sebastianbergmann/object-reflector/tree/2.0.4"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2020-10-26T13:14:26+00:00"
+ },
+ {
+ "name": "sebastian/recursion-context",
+ "version": "4.0.5",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/recursion-context.git",
+ "reference": "e75bd0f07204fec2a0af9b0f3cfe97d05f92efc1"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/recursion-context/zipball/e75bd0f07204fec2a0af9b0f3cfe97d05f92efc1",
+ "reference": "e75bd0f07204fec2a0af9b0f3cfe97d05f92efc1",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "4.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ },
+ {
+ "name": "Jeff Welch",
+ "email": "whatthejeff@gmail.com"
+ },
+ {
+ "name": "Adam Harvey",
+ "email": "aharvey@php.net"
+ }
+ ],
+ "description": "Provides functionality to recursively process PHP variables",
+ "homepage": "https://github.com/sebastianbergmann/recursion-context",
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/recursion-context/issues",
+ "source": "https://github.com/sebastianbergmann/recursion-context/tree/4.0.5"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2023-02-03T06:07:39+00:00"
+ },
+ {
+ "name": "sebastian/resource-operations",
+ "version": "3.0.3",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/resource-operations.git",
+ "reference": "0f4443cb3a1d92ce809899753bc0d5d5a8dd19a8"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/resource-operations/zipball/0f4443cb3a1d92ce809899753bc0d5d5a8dd19a8",
+ "reference": "0f4443cb3a1d92ce809899753bc0d5d5a8dd19a8",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "3.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Provides a list of PHP built-in functions that operate on resources",
+ "homepage": "https://www.github.com/sebastianbergmann/resource-operations",
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/resource-operations/issues",
+ "source": "https://github.com/sebastianbergmann/resource-operations/tree/3.0.3"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2020-09-28T06:45:17+00:00"
+ },
+ {
+ "name": "sebastian/type",
+ "version": "3.2.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/type.git",
+ "reference": "75e2c2a32f5e0b3aef905b9ed0b179b953b3d7c7"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/type/zipball/75e2c2a32f5e0b3aef905b9ed0b179b953b3d7c7",
+ "reference": "75e2c2a32f5e0b3aef905b9ed0b179b953b3d7c7",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^9.5"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "3.2-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Collection of value objects that represent the types of the PHP type system",
+ "homepage": "https://github.com/sebastianbergmann/type",
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/type/issues",
+ "source": "https://github.com/sebastianbergmann/type/tree/3.2.1"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2023-02-03T06:13:03+00:00"
+ },
+ {
+ "name": "sebastian/version",
+ "version": "3.0.2",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/version.git",
+ "reference": "c6c1022351a901512170118436c764e473f6de8c"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/version/zipball/c6c1022351a901512170118436c764e473f6de8c",
+ "reference": "c6c1022351a901512170118436c764e473f6de8c",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "3.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Library that helps with managing the version number of Git-hosted PHP projects",
+ "homepage": "https://github.com/sebastianbergmann/version",
+ "support": {
+ "issues": "https://github.com/sebastianbergmann/version/issues",
+ "source": "https://github.com/sebastianbergmann/version/tree/3.0.2"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/sebastianbergmann",
+ "type": "github"
+ }
+ ],
+ "time": "2020-09-28T06:39:44+00:00"
+ },
+ {
+ "name": "theseer/tokenizer",
+ "version": "1.2.2",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/theseer/tokenizer.git",
+ "reference": "b2ad5003ca10d4ee50a12da31de12a5774ba6b96"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/theseer/tokenizer/zipball/b2ad5003ca10d4ee50a12da31de12a5774ba6b96",
+ "reference": "b2ad5003ca10d4ee50a12da31de12a5774ba6b96",
+ "shasum": ""
+ },
+ "require": {
+ "ext-dom": "*",
+ "ext-tokenizer": "*",
+ "ext-xmlwriter": "*",
+ "php": "^7.2 || ^8.0"
+ },
+ "type": "library",
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Arne Blankerts",
+ "email": "arne@blankerts.de",
+ "role": "Developer"
+ }
+ ],
+ "description": "A small library for converting tokenized PHP source code into XML and potentially other formats",
+ "support": {
+ "issues": "https://github.com/theseer/tokenizer/issues",
+ "source": "https://github.com/theseer/tokenizer/tree/1.2.2"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/theseer",
+ "type": "github"
+ }
+ ],
+ "time": "2023-11-20T00:12:19+00:00"
+ }
+ ],
+ "packages-dev": [
+ {
+ "name": "behat/behat",
+ "version": "v3.13.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/Behat/Behat.git",
+ "reference": "9dd7cdb309e464ddeab095cd1a5151c2dccba4ab"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/Behat/Behat/zipball/9dd7cdb309e464ddeab095cd1a5151c2dccba4ab",
+ "reference": "9dd7cdb309e464ddeab095cd1a5151c2dccba4ab",
+ "shasum": ""
+ },
+ "require": {
+ "behat/gherkin": "^4.9.0",
+ "behat/transliterator": "^1.2",
+ "ext-mbstring": "*",
+ "php": "^7.2 || ^8.0",
+ "psr/container": "^1.0 || ^2.0",
+ "symfony/config": "^4.4 || ^5.0 || ^6.0",
+ "symfony/console": "^4.4 || ^5.0 || ^6.0",
+ "symfony/dependency-injection": "^4.4 || ^5.0 || ^6.0",
+ "symfony/event-dispatcher": "^4.4 || ^5.0 || ^6.0",
+ "symfony/translation": "^4.4 || ^5.0 || ^6.0",
+ "symfony/yaml": "^4.4 || ^5.0 || ^6.0"
+ },
+ "require-dev": {
+ "herrera-io/box": "~1.6.1",
+ "phpspec/prophecy": "^1.15",
+ "phpunit/phpunit": "^8.5 || ^9.0",
+ "symfony/process": "^4.4 || ^5.0 || ^6.0",
+ "vimeo/psalm": "^4.8"
+ },
+ "suggest": {
+ "ext-dom": "Needed to output test results in JUnit format."
+ },
+ "bin": [
+ "bin/behat"
+ ],
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "3.x-dev"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "Behat\\Hook\\": "src/Behat/Hook/",
+ "Behat\\Step\\": "src/Behat/Step/",
+ "Behat\\Behat\\": "src/Behat/Behat/",
+ "Behat\\Testwork\\": "src/Behat/Testwork/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Konstantin Kudryashov",
+ "email": "ever.zet@gmail.com",
+ "homepage": "http://everzet.com"
+ }
+ ],
+ "description": "Scenario-oriented BDD framework for PHP",
+ "homepage": "http://behat.org/",
+ "keywords": [
+ "Agile",
+ "BDD",
+ "ScenarioBDD",
+ "Scrum",
+ "StoryBDD",
+ "User story",
+ "business",
+ "development",
+ "documentation",
+ "examples",
+ "symfony",
+ "testing"
+ ],
+ "support": {
+ "issues": "https://github.com/Behat/Behat/issues",
+ "source": "https://github.com/Behat/Behat/tree/v3.13.0"
+ },
+ "time": "2023-04-18T15:40:53+00:00"
+ },
+ {
+ "name": "behat/gherkin",
+ "version": "v4.9.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/Behat/Gherkin.git",
+ "reference": "0bc8d1e30e96183e4f36db9dc79caead300beff4"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/Behat/Gherkin/zipball/0bc8d1e30e96183e4f36db9dc79caead300beff4",
+ "reference": "0bc8d1e30e96183e4f36db9dc79caead300beff4",
+ "shasum": ""
+ },
+ "require": {
+ "php": "~7.2|~8.0"
+ },
+ "require-dev": {
+ "cucumber/cucumber": "dev-gherkin-22.0.0",
+ "phpunit/phpunit": "~8|~9",
+ "symfony/yaml": "~3|~4|~5"
+ },
+ "suggest": {
+ "symfony/yaml": "If you want to parse features, represented in YAML files"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "4.x-dev"
+ }
+ },
+ "autoload": {
+ "psr-0": {
+ "Behat\\Gherkin": "src/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Konstantin Kudryashov",
+ "email": "ever.zet@gmail.com",
+ "homepage": "http://everzet.com"
+ }
+ ],
+ "description": "Gherkin DSL parser for PHP",
+ "homepage": "http://behat.org/",
+ "keywords": [
+ "BDD",
+ "Behat",
+ "Cucumber",
+ "DSL",
+ "gherkin",
+ "parser"
+ ],
+ "support": {
+ "issues": "https://github.com/Behat/Gherkin/issues",
+ "source": "https://github.com/Behat/Gherkin/tree/v4.9.0"
+ },
+ "time": "2021-10-12T13:05:09+00:00"
+ },
+ {
+ "name": "behat/transliterator",
+ "version": "v1.5.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/Behat/Transliterator.git",
+ "reference": "baac5873bac3749887d28ab68e2f74db3a4408af"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/Behat/Transliterator/zipball/baac5873bac3749887d28ab68e2f74db3a4408af",
+ "reference": "baac5873bac3749887d28ab68e2f74db3a4408af",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.2"
+ },
+ "require-dev": {
+ "chuyskywalker/rolling-curl": "^3.1",
+ "php-yaoi/php-yaoi": "^1.0",
+ "phpunit/phpunit": "^8.5.25 || ^9.5.19"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.x-dev"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "Behat\\Transliterator\\": "src/Behat/Transliterator"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "Artistic-1.0"
+ ],
+ "description": "String transliterator",
+ "keywords": [
+ "i18n",
+ "slug",
+ "transliterator"
+ ],
+ "support": {
+ "issues": "https://github.com/Behat/Transliterator/issues",
+ "source": "https://github.com/Behat/Transliterator/tree/v1.5.0"
+ },
+ "time": "2022-03-30T09:27:43+00:00"
+ },
+ {
+ "name": "composer/pcre",
+ "version": "3.1.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/composer/pcre.git",
+ "reference": "00104306927c7a0919b4ced2aaa6782c1e61a3c9"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/composer/pcre/zipball/00104306927c7a0919b4ced2aaa6782c1e61a3c9",
+ "reference": "00104306927c7a0919b4ced2aaa6782c1e61a3c9",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.4 || ^8.0"
+ },
+ "require-dev": {
+ "phpstan/phpstan": "^1.3",
+ "phpstan/phpstan-strict-rules": "^1.1",
+ "symfony/phpunit-bridge": "^5"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-main": "3.x-dev"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "Composer\\Pcre\\": "src"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Jordi Boggiano",
+ "email": "j.boggiano@seld.be",
+ "homepage": "http://seld.be"
+ }
+ ],
+ "description": "PCRE wrapping library that offers type-safe preg_* replacements.",
+ "keywords": [
+ "PCRE",
+ "preg",
+ "regex",
+ "regular expression"
+ ],
+ "support": {
+ "issues": "https://github.com/composer/pcre/issues",
+ "source": "https://github.com/composer/pcre/tree/3.1.1"
+ },
+ "funding": [
+ {
+ "url": "https://packagist.com",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/composer",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/composer/composer",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2023-10-11T07:11:09+00:00"
+ },
+ {
+ "name": "composer/semver",
+ "version": "3.4.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/composer/semver.git",
+ "reference": "35e8d0af4486141bc745f23a29cc2091eb624a32"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/composer/semver/zipball/35e8d0af4486141bc745f23a29cc2091eb624a32",
+ "reference": "35e8d0af4486141bc745f23a29cc2091eb624a32",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^5.3.2 || ^7.0 || ^8.0"
+ },
+ "require-dev": {
+ "phpstan/phpstan": "^1.4",
+ "symfony/phpunit-bridge": "^4.2 || ^5"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-main": "3.x-dev"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "Composer\\Semver\\": "src"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Nils Adermann",
+ "email": "naderman@naderman.de",
+ "homepage": "http://www.naderman.de"
+ },
+ {
+ "name": "Jordi Boggiano",
+ "email": "j.boggiano@seld.be",
+ "homepage": "http://seld.be"
+ },
+ {
+ "name": "Rob Bast",
+ "email": "rob.bast@gmail.com",
+ "homepage": "http://robbast.nl"
+ }
+ ],
+ "description": "Semver library that offers utilities, version constraint parsing and validation.",
+ "keywords": [
+ "semantic",
+ "semver",
+ "validation",
+ "versioning"
+ ],
+ "support": {
+ "irc": "ircs://irc.libera.chat:6697/composer",
+ "issues": "https://github.com/composer/semver/issues",
+ "source": "https://github.com/composer/semver/tree/3.4.0"
+ },
+ "funding": [
+ {
+ "url": "https://packagist.com",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/composer",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/composer/composer",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2023-08-31T09:50:34+00:00"
+ },
+ {
+ "name": "composer/xdebug-handler",
+ "version": "3.0.3",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/composer/xdebug-handler.git",
+ "reference": "ced299686f41dce890debac69273b47ffe98a40c"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/composer/xdebug-handler/zipball/ced299686f41dce890debac69273b47ffe98a40c",
+ "reference": "ced299686f41dce890debac69273b47ffe98a40c",
+ "shasum": ""
+ },
+ "require": {
+ "composer/pcre": "^1 || ^2 || ^3",
+ "php": "^7.2.5 || ^8.0",
+ "psr/log": "^1 || ^2 || ^3"
+ },
+ "require-dev": {
+ "phpstan/phpstan": "^1.0",
+ "phpstan/phpstan-strict-rules": "^1.1",
+ "symfony/phpunit-bridge": "^6.0"
+ },
+ "type": "library",
+ "autoload": {
+ "psr-4": {
+ "Composer\\XdebugHandler\\": "src"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "John Stevenson",
+ "email": "john-stevenson@blueyonder.co.uk"
+ }
+ ],
+ "description": "Restarts a process without Xdebug.",
+ "keywords": [
+ "Xdebug",
+ "performance"
+ ],
+ "support": {
+ "irc": "irc://irc.freenode.org/composer",
+ "issues": "https://github.com/composer/xdebug-handler/issues",
+ "source": "https://github.com/composer/xdebug-handler/tree/3.0.3"
+ },
+ "funding": [
+ {
+ "url": "https://packagist.com",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/composer",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/composer/composer",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2022-02-25T21:32:43+00:00"
+ },
+ {
+ "name": "dealerdirect/phpcodesniffer-composer-installer",
+ "version": "v0.7.2",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/Dealerdirect/phpcodesniffer-composer-installer.git",
+ "reference": "1c968e542d8843d7cd71de3c5c9c3ff3ad71a1db"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/Dealerdirect/phpcodesniffer-composer-installer/zipball/1c968e542d8843d7cd71de3c5c9c3ff3ad71a1db",
+ "reference": "1c968e542d8843d7cd71de3c5c9c3ff3ad71a1db",
+ "shasum": ""
+ },
+ "require": {
+ "composer-plugin-api": "^1.0 || ^2.0",
+ "php": ">=5.3",
+ "squizlabs/php_codesniffer": "^2.0 || ^3.1.0 || ^4.0"
+ },
+ "require-dev": {
+ "composer/composer": "*",
+ "php-parallel-lint/php-parallel-lint": "^1.3.1",
+ "phpcompatibility/php-compatibility": "^9.0"
+ },
+ "type": "composer-plugin",
+ "extra": {
+ "class": "Dealerdirect\\Composer\\Plugin\\Installers\\PHPCodeSniffer\\Plugin"
+ },
+ "autoload": {
+ "psr-4": {
+ "Dealerdirect\\Composer\\Plugin\\Installers\\PHPCodeSniffer\\": "src/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Franck Nijhof",
+ "email": "franck.nijhof@dealerdirect.com",
+ "homepage": "http://www.frenck.nl",
+ "role": "Developer / IT Manager"
+ },
+ {
+ "name": "Contributors",
+ "homepage": "https://github.com/Dealerdirect/phpcodesniffer-composer-installer/graphs/contributors"
+ }
+ ],
+ "description": "PHP_CodeSniffer Standards Composer Installer Plugin",
+ "homepage": "http://www.dealerdirect.com",
+ "keywords": [
+ "PHPCodeSniffer",
+ "PHP_CodeSniffer",
+ "code quality",
+ "codesniffer",
+ "composer",
+ "installer",
+ "phpcbf",
+ "phpcs",
+ "plugin",
+ "qa",
+ "quality",
+ "standard",
+ "standards",
+ "style guide",
+ "stylecheck",
+ "tests"
+ ],
+ "support": {
+ "issues": "https://github.com/dealerdirect/phpcodesniffer-composer-installer/issues",
+ "source": "https://github.com/dealerdirect/phpcodesniffer-composer-installer"
+ },
+ "time": "2022-02-04T12:51:07+00:00"
+ },
+ {
+ "name": "friendsofphp/php-cs-fixer",
+ "version": "v3.42.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/PHP-CS-Fixer/PHP-CS-Fixer.git",
+ "reference": "632ef1be3447a9b890bef06147475facee535d0f"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/PHP-CS-Fixer/PHP-CS-Fixer/zipball/632ef1be3447a9b890bef06147475facee535d0f",
+ "reference": "632ef1be3447a9b890bef06147475facee535d0f",
+ "shasum": ""
+ },
+ "require": {
+ "composer/semver": "^3.4",
+ "composer/xdebug-handler": "^3.0.3",
+ "ext-json": "*",
+ "ext-tokenizer": "*",
+ "php": "^7.4 || ^8.0",
+ "sebastian/diff": "^4.0 || ^5.0",
+ "symfony/console": "^5.4 || ^6.0 || ^7.0",
+ "symfony/event-dispatcher": "^5.4 || ^6.0 || ^7.0",
+ "symfony/filesystem": "^5.4 || ^6.0 || ^7.0",
+ "symfony/finder": "^5.4 || ^6.0 || ^7.0",
+ "symfony/options-resolver": "^5.4 || ^6.0 || ^7.0",
+ "symfony/polyfill-mbstring": "^1.28",
+ "symfony/polyfill-php80": "^1.28",
+ "symfony/polyfill-php81": "^1.28",
+ "symfony/process": "^5.4 || ^6.0 || ^7.0",
+ "symfony/stopwatch": "^5.4 || ^6.0 || ^7.0"
+ },
+ "require-dev": {
+ "facile-it/paraunit": "^1.3 || ^2.0",
+ "justinrainbow/json-schema": "^5.2",
+ "keradus/cli-executor": "^2.1",
+ "mikey179/vfsstream": "^1.6.11",
+ "php-coveralls/php-coveralls": "^2.7",
+ "php-cs-fixer/accessible-object": "^1.1",
+ "php-cs-fixer/phpunit-constraint-isidenticalstring": "^1.4",
+ "php-cs-fixer/phpunit-constraint-xmlmatchesxsd": "^1.4",
+ "phpunit/phpunit": "^9.6",
+ "symfony/yaml": "^5.4 || ^6.0 || ^7.0"
+ },
+ "suggest": {
+ "ext-dom": "For handling output formats in XML",
+ "ext-mbstring": "For handling non-UTF8 characters."
+ },
+ "bin": [
+ "php-cs-fixer"
+ ],
+ "type": "application",
+ "autoload": {
+ "psr-4": {
+ "PhpCsFixer\\": "src/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Fabien Potencier",
+ "email": "fabien@symfony.com"
+ },
+ {
+ "name": "Dariusz Rumiński",
+ "email": "dariusz.ruminski@gmail.com"
+ }
+ ],
+ "description": "A tool to automatically fix PHP code style",
+ "keywords": [
+ "Static code analysis",
+ "fixer",
+ "standards",
+ "static analysis"
+ ],
+ "support": {
+ "issues": "https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/issues",
+ "source": "https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/tree/v3.42.0"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/keradus",
+ "type": "github"
+ }
+ ],
+ "time": "2023-12-24T14:38:51+00:00"
+ },
+ {
+ "name": "guzzlehttp/guzzle",
+ "version": "7.8.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/guzzle/guzzle.git",
+ "reference": "41042bc7ab002487b876a0683fc8dce04ddce104"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/guzzle/guzzle/zipball/41042bc7ab002487b876a0683fc8dce04ddce104",
+ "reference": "41042bc7ab002487b876a0683fc8dce04ddce104",
+ "shasum": ""
+ },
+ "require": {
+ "ext-json": "*",
+ "guzzlehttp/promises": "^1.5.3 || ^2.0.1",
+ "guzzlehttp/psr7": "^1.9.1 || ^2.5.1",
+ "php": "^7.2.5 || ^8.0",
+ "psr/http-client": "^1.0",
+ "symfony/deprecation-contracts": "^2.2 || ^3.0"
+ },
+ "provide": {
+ "psr/http-client-implementation": "1.0"
+ },
+ "require-dev": {
+ "bamarni/composer-bin-plugin": "^1.8.2",
+ "ext-curl": "*",
+ "php-http/client-integration-tests": "dev-master#2c025848417c1135031fdf9c728ee53d0a7ceaee as 3.0.999",
+ "php-http/message-factory": "^1.1",
+ "phpunit/phpunit": "^8.5.36 || ^9.6.15",
+ "psr/log": "^1.1 || ^2.0 || ^3.0"
+ },
+ "suggest": {
+ "ext-curl": "Required for CURL handler support",
+ "ext-intl": "Required for Internationalized Domain Name (IDN) support",
+ "psr/log": "Required for using the Log middleware"
+ },
+ "type": "library",
+ "extra": {
+ "bamarni-bin": {
+ "bin-links": true,
+ "forward-command": false
+ }
+ },
+ "autoload": {
+ "files": [
+ "src/functions_include.php"
+ ],
+ "psr-4": {
+ "GuzzleHttp\\": "src/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Graham Campbell",
+ "email": "hello@gjcampbell.co.uk",
+ "homepage": "https://github.com/GrahamCampbell"
+ },
+ {
+ "name": "Michael Dowling",
+ "email": "mtdowling@gmail.com",
+ "homepage": "https://github.com/mtdowling"
+ },
+ {
+ "name": "Jeremy Lindblom",
+ "email": "jeremeamia@gmail.com",
+ "homepage": "https://github.com/jeremeamia"
+ },
+ {
+ "name": "George Mponos",
+ "email": "gmponos@gmail.com",
+ "homepage": "https://github.com/gmponos"
+ },
+ {
+ "name": "Tobias Nyholm",
+ "email": "tobias.nyholm@gmail.com",
+ "homepage": "https://github.com/Nyholm"
+ },
+ {
+ "name": "Márk Sági-Kazár",
+ "email": "mark.sagikazar@gmail.com",
+ "homepage": "https://github.com/sagikazarmark"
+ },
+ {
+ "name": "Tobias Schultze",
+ "email": "webmaster@tubo-world.de",
+ "homepage": "https://github.com/Tobion"
+ }
+ ],
+ "description": "Guzzle is a PHP HTTP client library",
+ "keywords": [
+ "client",
+ "curl",
+ "framework",
+ "http",
+ "http client",
+ "psr-18",
+ "psr-7",
+ "rest",
+ "web service"
+ ],
+ "support": {
+ "issues": "https://github.com/guzzle/guzzle/issues",
+ "source": "https://github.com/guzzle/guzzle/tree/7.8.1"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/GrahamCampbell",
+ "type": "github"
+ },
+ {
+ "url": "https://github.com/Nyholm",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/guzzlehttp/guzzle",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2023-12-03T20:35:24+00:00"
+ },
+ {
+ "name": "guzzlehttp/promises",
+ "version": "2.0.2",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/guzzle/promises.git",
+ "reference": "bbff78d96034045e58e13dedd6ad91b5d1253223"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/guzzle/promises/zipball/bbff78d96034045e58e13dedd6ad91b5d1253223",
+ "reference": "bbff78d96034045e58e13dedd6ad91b5d1253223",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.2.5 || ^8.0"
+ },
+ "require-dev": {
+ "bamarni/composer-bin-plugin": "^1.8.2",
+ "phpunit/phpunit": "^8.5.36 || ^9.6.15"
+ },
+ "type": "library",
+ "extra": {
+ "bamarni-bin": {
+ "bin-links": true,
+ "forward-command": false
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "GuzzleHttp\\Promise\\": "src/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Graham Campbell",
+ "email": "hello@gjcampbell.co.uk",
+ "homepage": "https://github.com/GrahamCampbell"
+ },
+ {
+ "name": "Michael Dowling",
+ "email": "mtdowling@gmail.com",
+ "homepage": "https://github.com/mtdowling"
+ },
+ {
+ "name": "Tobias Nyholm",
+ "email": "tobias.nyholm@gmail.com",
+ "homepage": "https://github.com/Nyholm"
+ },
+ {
+ "name": "Tobias Schultze",
+ "email": "webmaster@tubo-world.de",
+ "homepage": "https://github.com/Tobion"
+ }
+ ],
+ "description": "Guzzle promises library",
+ "keywords": [
+ "promise"
+ ],
+ "support": {
+ "issues": "https://github.com/guzzle/promises/issues",
+ "source": "https://github.com/guzzle/promises/tree/2.0.2"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/GrahamCampbell",
+ "type": "github"
+ },
+ {
+ "url": "https://github.com/Nyholm",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/guzzlehttp/promises",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2023-12-03T20:19:20+00:00"
+ },
+ {
+ "name": "guzzlehttp/psr7",
+ "version": "2.6.2",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/guzzle/psr7.git",
+ "reference": "45b30f99ac27b5ca93cb4831afe16285f57b8221"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/guzzle/psr7/zipball/45b30f99ac27b5ca93cb4831afe16285f57b8221",
+ "reference": "45b30f99ac27b5ca93cb4831afe16285f57b8221",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.2.5 || ^8.0",
+ "psr/http-factory": "^1.0",
+ "psr/http-message": "^1.1 || ^2.0",
+ "ralouphie/getallheaders": "^3.0"
+ },
+ "provide": {
+ "psr/http-factory-implementation": "1.0",
+ "psr/http-message-implementation": "1.0"
+ },
+ "require-dev": {
+ "bamarni/composer-bin-plugin": "^1.8.2",
+ "http-interop/http-factory-tests": "^0.9",
+ "phpunit/phpunit": "^8.5.36 || ^9.6.15"
+ },
+ "suggest": {
+ "laminas/laminas-httphandlerrunner": "Emit PSR-7 responses"
+ },
+ "type": "library",
+ "extra": {
+ "bamarni-bin": {
+ "bin-links": true,
+ "forward-command": false
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "GuzzleHttp\\Psr7\\": "src/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Graham Campbell",
+ "email": "hello@gjcampbell.co.uk",
+ "homepage": "https://github.com/GrahamCampbell"
+ },
+ {
+ "name": "Michael Dowling",
+ "email": "mtdowling@gmail.com",
+ "homepage": "https://github.com/mtdowling"
+ },
+ {
+ "name": "George Mponos",
+ "email": "gmponos@gmail.com",
+ "homepage": "https://github.com/gmponos"
+ },
+ {
+ "name": "Tobias Nyholm",
+ "email": "tobias.nyholm@gmail.com",
+ "homepage": "https://github.com/Nyholm"
+ },
+ {
+ "name": "Márk Sági-Kazár",
+ "email": "mark.sagikazar@gmail.com",
+ "homepage": "https://github.com/sagikazarmark"
+ },
+ {
+ "name": "Tobias Schultze",
+ "email": "webmaster@tubo-world.de",
+ "homepage": "https://github.com/Tobion"
+ },
+ {
+ "name": "Márk Sági-Kazár",
+ "email": "mark.sagikazar@gmail.com",
+ "homepage": "https://sagikazarmark.hu"
+ }
+ ],
+ "description": "PSR-7 message implementation that also provides common utility methods",
+ "keywords": [
+ "http",
+ "message",
+ "psr-7",
+ "request",
+ "response",
+ "stream",
+ "uri",
+ "url"
+ ],
+ "support": {
+ "issues": "https://github.com/guzzle/psr7/issues",
+ "source": "https://github.com/guzzle/psr7/tree/2.6.2"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/GrahamCampbell",
+ "type": "github"
+ },
+ {
+ "url": "https://github.com/Nyholm",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/guzzlehttp/psr7",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2023-12-03T20:05:35+00:00"
+ },
+ {
+ "name": "php-coveralls/php-coveralls",
+ "version": "v2.7.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/php-coveralls/php-coveralls.git",
+ "reference": "b36fa4394e519dafaddc04ae03976bc65a25ba15"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/php-coveralls/php-coveralls/zipball/b36fa4394e519dafaddc04ae03976bc65a25ba15",
+ "reference": "b36fa4394e519dafaddc04ae03976bc65a25ba15",
+ "shasum": ""
+ },
+ "require": {
+ "ext-json": "*",
+ "ext-simplexml": "*",
+ "guzzlehttp/guzzle": "^6.0 || ^7.0",
+ "php": "^7.0 || ^8.0",
+ "psr/log": "^1.0 || ^2.0",
+ "symfony/config": "^2.1 || ^3.0 || ^4.0 || ^5.0 || ^6.0 || ^7.0",
+ "symfony/console": "^2.1 || ^3.0 || ^4.0 || ^5.0 || ^6.0 || ^7.0",
+ "symfony/stopwatch": "^2.0 || ^3.0 || ^4.0 || ^5.0 || ^6.0 || ^7.0",
+ "symfony/yaml": "^2.0.5 || ^3.0 || ^4.0 || ^5.0 || ^6.0 || ^7.0"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^4.8.35 || ^5.4.3 || ^6.0 || ^7.0 || >=8.0 <8.5.29 || >=9.0 <9.5.23",
+ "sanmai/phpunit-legacy-adapter": "^6.1 || ^8.0"
+ },
+ "suggest": {
+ "symfony/http-kernel": "Allows Symfony integration"
+ },
+ "bin": [
+ "bin/php-coveralls"
+ ],
+ "type": "library",
+ "autoload": {
+ "psr-4": {
+ "PhpCoveralls\\": "src/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Kitamura Satoshi",
+ "email": "with.no.parachute@gmail.com",
+ "homepage": "https://www.facebook.com/satooshi.jp",
+ "role": "Original creator"
+ },
+ {
+ "name": "Takashi Matsuo",
+ "email": "tmatsuo@google.com"
+ },
+ {
+ "name": "Google Inc"
+ },
+ {
+ "name": "Dariusz Ruminski",
+ "email": "dariusz.ruminski@gmail.com",
+ "homepage": "https://github.com/keradus"
+ },
+ {
+ "name": "Contributors",
+ "homepage": "https://github.com/php-coveralls/php-coveralls/graphs/contributors"
+ }
+ ],
+ "description": "PHP client library for Coveralls API",
+ "homepage": "https://github.com/php-coveralls/php-coveralls",
+ "keywords": [
+ "ci",
+ "coverage",
+ "github",
+ "test"
+ ],
+ "support": {
+ "issues": "https://github.com/php-coveralls/php-coveralls/issues",
+ "source": "https://github.com/php-coveralls/php-coveralls/tree/v2.7.0"
+ },
+ "time": "2023-11-22T10:21:01+00:00"
+ },
+ {
+ "name": "php-stubs/wordpress-globals",
+ "version": "v0.2.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/php-stubs/wordpress-globals.git",
+ "reference": "748a1fb2ae8fda94844bd0545935095dbf404b32"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/php-stubs/wordpress-globals/zipball/748a1fb2ae8fda94844bd0545935095dbf404b32",
+ "reference": "748a1fb2ae8fda94844bd0545935095dbf404b32",
+ "shasum": ""
+ },
+ "require-dev": {
+ "php": "~7.1"
+ },
+ "suggest": {
+ "php-stubs/wordpress-stubs": "Up-to-date WordPress function and class declaration stubs",
+ "szepeviktor/phpstan-wordpress": "WordPress extensions for PHPStan"
+ },
+ "type": "library",
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "description": "Global variables and global constants from WordPress core.",
+ "homepage": "https://github.com/php-stubs/wordpress-globals",
+ "keywords": [
+ "PHPStan",
+ "constants",
+ "globals",
+ "static analysis",
+ "wordpress"
+ ],
+ "support": {
+ "issues": "https://github.com/php-stubs/wordpress-globals/issues",
+ "source": "https://github.com/php-stubs/wordpress-globals/tree/master"
+ },
+ "time": "2020-01-13T06:12:59+00:00"
+ },
+ {
+ "name": "php-stubs/wordpress-stubs",
+ "version": "v6.4.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/php-stubs/wordpress-stubs.git",
+ "reference": "6d6063cf9464a306ca2a0529705d41312b08500b"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/php-stubs/wordpress-stubs/zipball/6d6063cf9464a306ca2a0529705d41312b08500b",
+ "reference": "6d6063cf9464a306ca2a0529705d41312b08500b",
+ "shasum": ""
+ },
+ "require-dev": {
+ "dealerdirect/phpcodesniffer-composer-installer": "^1.0",
+ "nikic/php-parser": "^4.13",
+ "php": "^7.4 || ~8.0.0",
+ "php-stubs/generator": "^0.8.3",
+ "phpdocumentor/reflection-docblock": "^5.3",
+ "phpstan/phpstan": "^1.10.12",
+ "phpunit/phpunit": "^9.5",
+ "szepeviktor/phpcs-psr-12-neutron-hybrid-ruleset": "^0.8"
+ },
+ "suggest": {
+ "paragonie/sodium_compat": "Pure PHP implementation of libsodium",
+ "symfony/polyfill-php80": "Symfony polyfill backporting some PHP 8.0+ features to lower PHP versions",
+ "szepeviktor/phpstan-wordpress": "WordPress extensions for PHPStan"
+ },
+ "type": "library",
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "description": "WordPress function and class declaration stubs for static analysis.",
+ "homepage": "https://github.com/php-stubs/wordpress-stubs",
+ "keywords": [
+ "PHPStan",
+ "static analysis",
+ "wordpress"
+ ],
+ "support": {
+ "issues": "https://github.com/php-stubs/wordpress-stubs/issues",
+ "source": "https://github.com/php-stubs/wordpress-stubs/tree/v6.4.1"
+ },
+ "time": "2023-11-10T00:33:47+00:00"
+ },
+ {
+ "name": "phpcompatibility/php-compatibility",
+ "version": "9.3.5",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/PHPCompatibility/PHPCompatibility.git",
+ "reference": "9fb324479acf6f39452e0655d2429cc0d3914243"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/PHPCompatibility/PHPCompatibility/zipball/9fb324479acf6f39452e0655d2429cc0d3914243",
+ "reference": "9fb324479acf6f39452e0655d2429cc0d3914243",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=5.3",
+ "squizlabs/php_codesniffer": "^2.3 || ^3.0.2"
+ },
+ "conflict": {
+ "squizlabs/php_codesniffer": "2.6.2"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "~4.5 || ^5.0 || ^6.0 || ^7.0"
+ },
+ "suggest": {
+ "dealerdirect/phpcodesniffer-composer-installer": "^0.5 || This Composer plugin will sort out the PHPCS 'installed_paths' automatically.",
+ "roave/security-advisories": "dev-master || Helps prevent installing dependencies with known security issues."
+ },
+ "type": "phpcodesniffer-standard",
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "LGPL-3.0-or-later"
+ ],
+ "authors": [
+ {
+ "name": "Wim Godden",
+ "homepage": "https://github.com/wimg",
+ "role": "lead"
+ },
+ {
+ "name": "Juliette Reinders Folmer",
+ "homepage": "https://github.com/jrfnl",
+ "role": "lead"
+ },
+ {
+ "name": "Contributors",
+ "homepage": "https://github.com/PHPCompatibility/PHPCompatibility/graphs/contributors"
+ }
+ ],
+ "description": "A set of sniffs for PHP_CodeSniffer that checks for PHP cross-version compatibility.",
+ "homepage": "http://techblog.wimgodden.be/tag/codesniffer/",
+ "keywords": [
+ "compatibility",
+ "phpcs",
+ "standards"
+ ],
+ "support": {
+ "issues": "https://github.com/PHPCompatibility/PHPCompatibility/issues",
+ "source": "https://github.com/PHPCompatibility/PHPCompatibility"
+ },
+ "time": "2019-12-27T09:44:58+00:00"
+ },
+ {
+ "name": "phpstan/phpstan",
+ "version": "1.10.50",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/phpstan/phpstan.git",
+ "reference": "06a98513ac72c03e8366b5a0cb00750b487032e4"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/phpstan/phpstan/zipball/06a98513ac72c03e8366b5a0cb00750b487032e4",
+ "reference": "06a98513ac72c03e8366b5a0cb00750b487032e4",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.2|^8.0"
+ },
+ "conflict": {
+ "phpstan/phpstan-shim": "*"
+ },
+ "bin": [
+ "phpstan",
+ "phpstan.phar"
+ ],
+ "type": "library",
+ "autoload": {
+ "files": [
+ "bootstrap.php"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "description": "PHPStan - PHP Static Analysis Tool",
+ "keywords": [
+ "dev",
+ "static analysis"
+ ],
+ "support": {
+ "docs": "https://phpstan.org/user-guide/getting-started",
+ "forum": "https://github.com/phpstan/phpstan/discussions",
+ "issues": "https://github.com/phpstan/phpstan/issues",
+ "security": "https://github.com/phpstan/phpstan/security/policy",
+ "source": "https://github.com/phpstan/phpstan-src"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/ondrejmirtes",
+ "type": "github"
+ },
+ {
+ "url": "https://github.com/phpstan",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/phpstan/phpstan",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2023-12-13T10:59:42+00:00"
+ },
+ {
+ "name": "phpstan/phpstan-mockery",
+ "version": "1.1.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/phpstan/phpstan-mockery.git",
+ "reference": "6aa86bd8e9c9a1be97baf0558d4a2ed1374736a6"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/phpstan/phpstan-mockery/zipball/6aa86bd8e9c9a1be97baf0558d4a2ed1374736a6",
+ "reference": "6aa86bd8e9c9a1be97baf0558d4a2ed1374736a6",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.2 || ^8.0",
+ "phpstan/phpstan": "^1.10"
+ },
+ "require-dev": {
+ "mockery/mockery": "^1.2.4",
+ "nikic/php-parser": "^4.13.0",
+ "php-parallel-lint/php-parallel-lint": "^1.2",
+ "phpstan/phpstan-phpunit": "^1.0",
+ "phpstan/phpstan-strict-rules": "^1.0",
+ "phpunit/phpunit": "^9.5"
+ },
+ "type": "phpstan-extension",
+ "extra": {
+ "phpstan": {
+ "includes": [
+ "extension.neon"
+ ]
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "PHPStan\\": "src/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "description": "PHPStan Mockery extension",
+ "support": {
+ "issues": "https://github.com/phpstan/phpstan-mockery/issues",
+ "source": "https://github.com/phpstan/phpstan-mockery/tree/1.1.1"
+ },
+ "time": "2023-02-18T13:54:03+00:00"
+ },
+ {
+ "name": "phpstan/phpstan-phpunit",
+ "version": "1.3.15",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/phpstan/phpstan-phpunit.git",
+ "reference": "70ecacc64fe8090d8d2a33db5a51fe8e88acd93a"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/phpstan/phpstan-phpunit/zipball/70ecacc64fe8090d8d2a33db5a51fe8e88acd93a",
+ "reference": "70ecacc64fe8090d8d2a33db5a51fe8e88acd93a",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.2 || ^8.0",
+ "phpstan/phpstan": "^1.10"
+ },
+ "conflict": {
+ "phpunit/phpunit": "<7.0"
+ },
+ "require-dev": {
+ "nikic/php-parser": "^4.13.0",
+ "php-parallel-lint/php-parallel-lint": "^1.2",
+ "phpstan/phpstan-strict-rules": "^1.5.1",
+ "phpunit/phpunit": "^9.5"
+ },
+ "type": "phpstan-extension",
+ "extra": {
+ "phpstan": {
+ "includes": [
+ "extension.neon",
+ "rules.neon"
+ ]
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "PHPStan\\": "src/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "description": "PHPUnit extensions and rules for PHPStan",
+ "support": {
+ "issues": "https://github.com/phpstan/phpstan-phpunit/issues",
+ "source": "https://github.com/phpstan/phpstan-phpunit/tree/1.3.15"
+ },
+ "time": "2023-10-09T18:58:39+00:00"
+ },
+ {
+ "name": "psr/container",
+ "version": "1.1.2",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/php-fig/container.git",
+ "reference": "513e0666f7216c7459170d56df27dfcefe1689ea"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/php-fig/container/zipball/513e0666f7216c7459170d56df27dfcefe1689ea",
+ "reference": "513e0666f7216c7459170d56df27dfcefe1689ea",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.4.0"
+ },
+ "type": "library",
+ "autoload": {
+ "psr-4": {
+ "Psr\\Container\\": "src/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "PHP-FIG",
+ "homepage": "https://www.php-fig.org/"
+ }
+ ],
+ "description": "Common Container Interface (PHP FIG PSR-11)",
+ "homepage": "https://github.com/php-fig/container",
+ "keywords": [
+ "PSR-11",
+ "container",
+ "container-interface",
+ "container-interop",
+ "psr"
+ ],
+ "support": {
+ "issues": "https://github.com/php-fig/container/issues",
+ "source": "https://github.com/php-fig/container/tree/1.1.2"
+ },
+ "time": "2021-11-05T16:50:12+00:00"
+ },
+ {
+ "name": "psr/event-dispatcher",
+ "version": "1.0.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/php-fig/event-dispatcher.git",
+ "reference": "dbefd12671e8a14ec7f180cab83036ed26714bb0"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/php-fig/event-dispatcher/zipball/dbefd12671e8a14ec7f180cab83036ed26714bb0",
+ "reference": "dbefd12671e8a14ec7f180cab83036ed26714bb0",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.2.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.0.x-dev"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "Psr\\EventDispatcher\\": "src/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "PHP-FIG",
+ "homepage": "http://www.php-fig.org/"
+ }
+ ],
+ "description": "Standard interfaces for event handling.",
+ "keywords": [
+ "events",
+ "psr",
+ "psr-14"
+ ],
+ "support": {
+ "issues": "https://github.com/php-fig/event-dispatcher/issues",
+ "source": "https://github.com/php-fig/event-dispatcher/tree/1.0.0"
+ },
+ "time": "2019-01-08T18:20:26+00:00"
+ },
+ {
+ "name": "psr/http-client",
+ "version": "1.0.3",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/php-fig/http-client.git",
+ "reference": "bb5906edc1c324c9a05aa0873d40117941e5fa90"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/php-fig/http-client/zipball/bb5906edc1c324c9a05aa0873d40117941e5fa90",
+ "reference": "bb5906edc1c324c9a05aa0873d40117941e5fa90",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.0 || ^8.0",
+ "psr/http-message": "^1.0 || ^2.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.0.x-dev"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "Psr\\Http\\Client\\": "src/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "PHP-FIG",
+ "homepage": "https://www.php-fig.org/"
+ }
+ ],
+ "description": "Common interface for HTTP clients",
+ "homepage": "https://github.com/php-fig/http-client",
+ "keywords": [
+ "http",
+ "http-client",
+ "psr",
+ "psr-18"
+ ],
+ "support": {
+ "source": "https://github.com/php-fig/http-client"
+ },
+ "time": "2023-09-23T14:17:50+00:00"
+ },
+ {
+ "name": "psr/http-factory",
+ "version": "1.0.2",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/php-fig/http-factory.git",
+ "reference": "e616d01114759c4c489f93b099585439f795fe35"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/php-fig/http-factory/zipball/e616d01114759c4c489f93b099585439f795fe35",
+ "reference": "e616d01114759c4c489f93b099585439f795fe35",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.0.0",
+ "psr/http-message": "^1.0 || ^2.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.0.x-dev"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "Psr\\Http\\Message\\": "src/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "PHP-FIG",
+ "homepage": "https://www.php-fig.org/"
+ }
+ ],
+ "description": "Common interfaces for PSR-7 HTTP message factories",
+ "keywords": [
+ "factory",
+ "http",
+ "message",
+ "psr",
+ "psr-17",
+ "psr-7",
+ "request",
+ "response"
+ ],
+ "support": {
+ "source": "https://github.com/php-fig/http-factory/tree/1.0.2"
+ },
+ "time": "2023-04-10T20:10:41+00:00"
+ },
+ {
+ "name": "psr/http-message",
+ "version": "2.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/php-fig/http-message.git",
+ "reference": "402d35bcb92c70c026d1a6a9883f06b2ead23d71"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/php-fig/http-message/zipball/402d35bcb92c70c026d1a6a9883f06b2ead23d71",
+ "reference": "402d35bcb92c70c026d1a6a9883f06b2ead23d71",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.2 || ^8.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "2.0.x-dev"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "Psr\\Http\\Message\\": "src/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "PHP-FIG",
+ "homepage": "https://www.php-fig.org/"
+ }
+ ],
+ "description": "Common interface for HTTP messages",
+ "homepage": "https://github.com/php-fig/http-message",
+ "keywords": [
+ "http",
+ "http-message",
+ "psr",
+ "psr-7",
+ "request",
+ "response"
+ ],
+ "support": {
+ "source": "https://github.com/php-fig/http-message/tree/2.0"
+ },
+ "time": "2023-04-04T09:54:51+00:00"
+ },
+ {
+ "name": "psr/log",
+ "version": "1.1.4",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/php-fig/log.git",
+ "reference": "d49695b909c3b7628b6289db5479a1c204601f11"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/php-fig/log/zipball/d49695b909c3b7628b6289db5479a1c204601f11",
+ "reference": "d49695b909c3b7628b6289db5479a1c204601f11",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=5.3.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.1.x-dev"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "Psr\\Log\\": "Psr/Log/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "PHP-FIG",
+ "homepage": "https://www.php-fig.org/"
+ }
+ ],
+ "description": "Common interface for logging libraries",
+ "homepage": "https://github.com/php-fig/log",
+ "keywords": [
+ "log",
+ "psr",
+ "psr-3"
+ ],
+ "support": {
+ "source": "https://github.com/php-fig/log/tree/1.1.4"
+ },
+ "time": "2021-05-03T11:20:27+00:00"
+ },
+ {
+ "name": "ralouphie/getallheaders",
+ "version": "3.0.3",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/ralouphie/getallheaders.git",
+ "reference": "120b605dfeb996808c31b6477290a714d356e822"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/ralouphie/getallheaders/zipball/120b605dfeb996808c31b6477290a714d356e822",
+ "reference": "120b605dfeb996808c31b6477290a714d356e822",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=5.6"
+ },
+ "require-dev": {
+ "php-coveralls/php-coveralls": "^2.1",
+ "phpunit/phpunit": "^5 || ^6.5"
+ },
+ "type": "library",
+ "autoload": {
+ "files": [
+ "src/getallheaders.php"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Ralph Khattar",
+ "email": "ralph.khattar@gmail.com"
+ }
+ ],
+ "description": "A polyfill for getallheaders.",
+ "support": {
+ "issues": "https://github.com/ralouphie/getallheaders/issues",
+ "source": "https://github.com/ralouphie/getallheaders/tree/develop"
+ },
+ "time": "2019-03-08T08:55:37+00:00"
+ },
+ {
+ "name": "sempro/phpunit-pretty-print",
+ "version": "1.4.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/s360digital/phpunit-pretty-print.git",
+ "reference": "fa623aa8a17aece4a2b69e54b07a5e37572d1f1d"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/s360digital/phpunit-pretty-print/zipball/fa623aa8a17aece4a2b69e54b07a5e37572d1f1d",
+ "reference": "fa623aa8a17aece4a2b69e54b07a5e37572d1f1d",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.1.0",
+ "phpunit/phpunit": "^7 || ^8 || ^9"
+ },
+ "require-dev": {
+ "friendsofphp/php-cs-fixer": "^2.16"
+ },
+ "type": "library",
+ "autoload": {
+ "psr-4": {
+ "Sempro\\PHPUnitPrettyPrinter\\": "src/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "description": "Prettify PHPUnit output",
+ "support": {
+ "issues": "https://github.com/s360digital/phpunit-pretty-print/issues",
+ "source": "https://github.com/s360digital/phpunit-pretty-print/tree/1.4.0"
+ },
+ "time": "2021-01-04T13:25:10+00:00"
+ },
+ {
+ "name": "squizlabs/php_codesniffer",
+ "version": "3.8.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/PHPCSStandards/PHP_CodeSniffer.git",
+ "reference": "5805f7a4e4958dbb5e944ef1e6edae0a303765e7"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/PHPCSStandards/PHP_CodeSniffer/zipball/5805f7a4e4958dbb5e944ef1e6edae0a303765e7",
+ "reference": "5805f7a4e4958dbb5e944ef1e6edae0a303765e7",
+ "shasum": ""
+ },
+ "require": {
+ "ext-simplexml": "*",
+ "ext-tokenizer": "*",
+ "ext-xmlwriter": "*",
+ "php": ">=5.4.0"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^4.0 || ^5.0 || ^6.0 || ^7.0 || ^8.0 || ^9.0"
+ },
+ "bin": [
+ "bin/phpcs",
+ "bin/phpcbf"
+ ],
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "3.x-dev"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Greg Sherwood",
+ "role": "Former lead"
+ },
+ {
+ "name": "Juliette Reinders Folmer",
+ "role": "Current lead"
+ },
+ {
+ "name": "Contributors",
+ "homepage": "https://github.com/PHPCSStandards/PHP_CodeSniffer/graphs/contributors"
+ }
+ ],
+ "description": "PHP_CodeSniffer tokenizes PHP, JavaScript and CSS files and detects violations of a defined set of coding standards.",
+ "homepage": "https://github.com/PHPCSStandards/PHP_CodeSniffer",
+ "keywords": [
+ "phpcs",
+ "standards",
+ "static analysis"
+ ],
+ "support": {
+ "issues": "https://github.com/PHPCSStandards/PHP_CodeSniffer/issues",
+ "security": "https://github.com/PHPCSStandards/PHP_CodeSniffer/security/policy",
+ "source": "https://github.com/PHPCSStandards/PHP_CodeSniffer",
+ "wiki": "https://github.com/PHPCSStandards/PHP_CodeSniffer/wiki"
+ },
+ "funding": [
+ {
+ "url": "https://github.com/PHPCSStandards",
+ "type": "github"
+ },
+ {
+ "url": "https://github.com/jrfnl",
+ "type": "github"
+ },
+ {
+ "url": "https://opencollective.com/php_codesniffer",
+ "type": "open_collective"
+ }
+ ],
+ "time": "2023-12-08T12:32:31+00:00"
+ },
+ {
+ "name": "symfony/config",
+ "version": "v5.4.31",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/config.git",
+ "reference": "dd5ea39de228813aba0c23c3a4153da2a4cf3cd9"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/config/zipball/dd5ea39de228813aba0c23c3a4153da2a4cf3cd9",
+ "reference": "dd5ea39de228813aba0c23c3a4153da2a4cf3cd9",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.2.5",
+ "symfony/deprecation-contracts": "^2.1|^3",
+ "symfony/filesystem": "^4.4|^5.0|^6.0",
+ "symfony/polyfill-ctype": "~1.8",
+ "symfony/polyfill-php80": "^1.16",
+ "symfony/polyfill-php81": "^1.22"
+ },
+ "conflict": {
+ "symfony/finder": "<4.4"
+ },
+ "require-dev": {
+ "symfony/event-dispatcher": "^4.4|^5.0|^6.0",
+ "symfony/finder": "^4.4|^5.0|^6.0",
+ "symfony/messenger": "^4.4|^5.0|^6.0",
+ "symfony/service-contracts": "^1.1|^2|^3",
+ "symfony/yaml": "^4.4|^5.0|^6.0"
+ },
+ "suggest": {
+ "symfony/yaml": "To use the yaml reference dumper"
+ },
+ "type": "library",
+ "autoload": {
+ "psr-4": {
+ "Symfony\\Component\\Config\\": ""
+ },
+ "exclude-from-classmap": [
+ "/Tests/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Fabien Potencier",
+ "email": "fabien@symfony.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "Helps you find, load, combine, autofill and validate configuration values of any kind",
+ "homepage": "https://symfony.com",
+ "support": {
+ "source": "https://github.com/symfony/config/tree/v5.4.31"
+ },
+ "funding": [
+ {
+ "url": "https://symfony.com/sponsor",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/fabpot",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2023-11-09T08:22:43+00:00"
+ },
+ {
+ "name": "symfony/console",
+ "version": "v5.4.32",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/console.git",
+ "reference": "c70df1ffaf23a8d340bded3cfab1b86752ad6ed7"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/console/zipball/c70df1ffaf23a8d340bded3cfab1b86752ad6ed7",
+ "reference": "c70df1ffaf23a8d340bded3cfab1b86752ad6ed7",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.2.5",
+ "symfony/deprecation-contracts": "^2.1|^3",
+ "symfony/polyfill-mbstring": "~1.0",
+ "symfony/polyfill-php73": "^1.9",
+ "symfony/polyfill-php80": "^1.16",
+ "symfony/service-contracts": "^1.1|^2|^3",
+ "symfony/string": "^5.1|^6.0"
+ },
+ "conflict": {
+ "psr/log": ">=3",
+ "symfony/dependency-injection": "<4.4",
+ "symfony/dotenv": "<5.1",
+ "symfony/event-dispatcher": "<4.4",
+ "symfony/lock": "<4.4",
+ "symfony/process": "<4.4"
+ },
+ "provide": {
+ "psr/log-implementation": "1.0|2.0"
+ },
+ "require-dev": {
+ "psr/log": "^1|^2",
+ "symfony/config": "^4.4|^5.0|^6.0",
+ "symfony/dependency-injection": "^4.4|^5.0|^6.0",
+ "symfony/event-dispatcher": "^4.4|^5.0|^6.0",
+ "symfony/lock": "^4.4|^5.0|^6.0",
+ "symfony/process": "^4.4|^5.0|^6.0",
+ "symfony/var-dumper": "^4.4|^5.0|^6.0"
+ },
+ "suggest": {
+ "psr/log": "For using the console logger",
+ "symfony/event-dispatcher": "",
+ "symfony/lock": "",
+ "symfony/process": ""
+ },
+ "type": "library",
+ "autoload": {
+ "psr-4": {
+ "Symfony\\Component\\Console\\": ""
+ },
+ "exclude-from-classmap": [
+ "/Tests/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Fabien Potencier",
+ "email": "fabien@symfony.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "Eases the creation of beautiful and testable command line interfaces",
+ "homepage": "https://symfony.com",
+ "keywords": [
+ "cli",
+ "command-line",
+ "console",
+ "terminal"
+ ],
+ "support": {
+ "source": "https://github.com/symfony/console/tree/v5.4.32"
+ },
+ "funding": [
+ {
+ "url": "https://symfony.com/sponsor",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/fabpot",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2023-11-18T18:23:04+00:00"
+ },
+ {
+ "name": "symfony/dependency-injection",
+ "version": "v5.4.33",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/dependency-injection.git",
+ "reference": "14969a558cd6382b2a12b14b20ef9a851a02da79"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/dependency-injection/zipball/14969a558cd6382b2a12b14b20ef9a851a02da79",
+ "reference": "14969a558cd6382b2a12b14b20ef9a851a02da79",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.2.5",
+ "psr/container": "^1.1.1",
+ "symfony/deprecation-contracts": "^2.1|^3",
+ "symfony/polyfill-php80": "^1.16",
+ "symfony/polyfill-php81": "^1.22",
+ "symfony/service-contracts": "^1.1.6|^2"
+ },
+ "conflict": {
+ "ext-psr": "<1.1|>=2",
+ "symfony/config": "<5.3",
+ "symfony/finder": "<4.4",
+ "symfony/proxy-manager-bridge": "<4.4",
+ "symfony/yaml": "<4.4.26"
+ },
+ "provide": {
+ "psr/container-implementation": "1.0",
+ "symfony/service-implementation": "1.0|2.0"
+ },
+ "require-dev": {
+ "symfony/config": "^5.3|^6.0",
+ "symfony/expression-language": "^4.4|^5.0|^6.0",
+ "symfony/yaml": "^4.4.26|^5.0|^6.0"
+ },
+ "suggest": {
+ "symfony/config": "",
+ "symfony/expression-language": "For using expressions in service container configuration",
+ "symfony/finder": "For using double-star glob patterns or when GLOB_BRACE portability is required",
+ "symfony/proxy-manager-bridge": "Generate service proxies to lazy load them",
+ "symfony/yaml": ""
+ },
+ "type": "library",
+ "autoload": {
+ "psr-4": {
+ "Symfony\\Component\\DependencyInjection\\": ""
+ },
+ "exclude-from-classmap": [
+ "/Tests/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Fabien Potencier",
+ "email": "fabien@symfony.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "Allows you to standardize and centralize the way objects are constructed in your application",
+ "homepage": "https://symfony.com",
+ "support": {
+ "source": "https://github.com/symfony/dependency-injection/tree/v5.4.33"
+ },
+ "funding": [
+ {
+ "url": "https://symfony.com/sponsor",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/fabpot",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2023-11-30T08:15:37+00:00"
+ },
+ {
+ "name": "symfony/deprecation-contracts",
+ "version": "v2.5.2",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/deprecation-contracts.git",
+ "reference": "e8b495ea28c1d97b5e0c121748d6f9b53d075c66"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/deprecation-contracts/zipball/e8b495ea28c1d97b5e0c121748d6f9b53d075c66",
+ "reference": "e8b495ea28c1d97b5e0c121748d6f9b53d075c66",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.1"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-main": "2.5-dev"
+ },
+ "thanks": {
+ "name": "symfony/contracts",
+ "url": "https://github.com/symfony/contracts"
+ }
+ },
+ "autoload": {
+ "files": [
+ "function.php"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Nicolas Grekas",
+ "email": "p@tchwork.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "A generic function and convention to trigger deprecation notices",
+ "homepage": "https://symfony.com",
+ "support": {
+ "source": "https://github.com/symfony/deprecation-contracts/tree/v2.5.2"
+ },
+ "funding": [
+ {
+ "url": "https://symfony.com/sponsor",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/fabpot",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2022-01-02T09:53:40+00:00"
+ },
+ {
+ "name": "symfony/event-dispatcher",
+ "version": "v5.4.26",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/event-dispatcher.git",
+ "reference": "5dcc00e03413f05c1e7900090927bb7247cb0aac"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/event-dispatcher/zipball/5dcc00e03413f05c1e7900090927bb7247cb0aac",
+ "reference": "5dcc00e03413f05c1e7900090927bb7247cb0aac",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.2.5",
+ "symfony/deprecation-contracts": "^2.1|^3",
+ "symfony/event-dispatcher-contracts": "^2|^3",
+ "symfony/polyfill-php80": "^1.16"
+ },
+ "conflict": {
+ "symfony/dependency-injection": "<4.4"
+ },
+ "provide": {
+ "psr/event-dispatcher-implementation": "1.0",
+ "symfony/event-dispatcher-implementation": "2.0"
+ },
+ "require-dev": {
+ "psr/log": "^1|^2|^3",
+ "symfony/config": "^4.4|^5.0|^6.0",
+ "symfony/dependency-injection": "^4.4|^5.0|^6.0",
+ "symfony/error-handler": "^4.4|^5.0|^6.0",
+ "symfony/expression-language": "^4.4|^5.0|^6.0",
+ "symfony/http-foundation": "^4.4|^5.0|^6.0",
+ "symfony/service-contracts": "^1.1|^2|^3",
+ "symfony/stopwatch": "^4.4|^5.0|^6.0"
+ },
+ "suggest": {
+ "symfony/dependency-injection": "",
+ "symfony/http-kernel": ""
+ },
+ "type": "library",
+ "autoload": {
+ "psr-4": {
+ "Symfony\\Component\\EventDispatcher\\": ""
+ },
+ "exclude-from-classmap": [
+ "/Tests/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Fabien Potencier",
+ "email": "fabien@symfony.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "Provides tools that allow your application components to communicate with each other by dispatching events and listening to them",
+ "homepage": "https://symfony.com",
+ "support": {
+ "source": "https://github.com/symfony/event-dispatcher/tree/v5.4.26"
+ },
+ "funding": [
+ {
+ "url": "https://symfony.com/sponsor",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/fabpot",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2023-07-06T06:34:20+00:00"
+ },
+ {
+ "name": "symfony/event-dispatcher-contracts",
+ "version": "v2.5.2",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/event-dispatcher-contracts.git",
+ "reference": "f98b54df6ad059855739db6fcbc2d36995283fe1"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/event-dispatcher-contracts/zipball/f98b54df6ad059855739db6fcbc2d36995283fe1",
+ "reference": "f98b54df6ad059855739db6fcbc2d36995283fe1",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.2.5",
+ "psr/event-dispatcher": "^1"
+ },
+ "suggest": {
+ "symfony/event-dispatcher-implementation": ""
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-main": "2.5-dev"
+ },
+ "thanks": {
+ "name": "symfony/contracts",
+ "url": "https://github.com/symfony/contracts"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "Symfony\\Contracts\\EventDispatcher\\": ""
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Nicolas Grekas",
+ "email": "p@tchwork.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "Generic abstractions related to dispatching event",
+ "homepage": "https://symfony.com",
+ "keywords": [
+ "abstractions",
+ "contracts",
+ "decoupling",
+ "interfaces",
+ "interoperability",
+ "standards"
+ ],
+ "support": {
+ "source": "https://github.com/symfony/event-dispatcher-contracts/tree/v2.5.2"
+ },
+ "funding": [
+ {
+ "url": "https://symfony.com/sponsor",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/fabpot",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2022-01-02T09:53:40+00:00"
+ },
+ {
+ "name": "symfony/filesystem",
+ "version": "v5.4.25",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/filesystem.git",
+ "reference": "0ce3a62c9579a53358d3a7eb6b3dfb79789a6364"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/filesystem/zipball/0ce3a62c9579a53358d3a7eb6b3dfb79789a6364",
+ "reference": "0ce3a62c9579a53358d3a7eb6b3dfb79789a6364",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.2.5",
+ "symfony/polyfill-ctype": "~1.8",
+ "symfony/polyfill-mbstring": "~1.8",
+ "symfony/polyfill-php80": "^1.16"
+ },
+ "type": "library",
+ "autoload": {
+ "psr-4": {
+ "Symfony\\Component\\Filesystem\\": ""
+ },
+ "exclude-from-classmap": [
+ "/Tests/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Fabien Potencier",
+ "email": "fabien@symfony.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "Provides basic utilities for the filesystem",
+ "homepage": "https://symfony.com",
+ "support": {
+ "source": "https://github.com/symfony/filesystem/tree/v5.4.25"
+ },
+ "funding": [
+ {
+ "url": "https://symfony.com/sponsor",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/fabpot",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2023-05-31T13:04:02+00:00"
+ },
+ {
+ "name": "symfony/finder",
+ "version": "v5.4.27",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/finder.git",
+ "reference": "ff4bce3c33451e7ec778070e45bd23f74214cd5d"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/finder/zipball/ff4bce3c33451e7ec778070e45bd23f74214cd5d",
+ "reference": "ff4bce3c33451e7ec778070e45bd23f74214cd5d",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.2.5",
+ "symfony/deprecation-contracts": "^2.1|^3",
+ "symfony/polyfill-php80": "^1.16"
+ },
+ "type": "library",
+ "autoload": {
+ "psr-4": {
+ "Symfony\\Component\\Finder\\": ""
+ },
+ "exclude-from-classmap": [
+ "/Tests/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Fabien Potencier",
+ "email": "fabien@symfony.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "Finds files and directories via an intuitive fluent interface",
+ "homepage": "https://symfony.com",
+ "support": {
+ "source": "https://github.com/symfony/finder/tree/v5.4.27"
+ },
+ "funding": [
+ {
+ "url": "https://symfony.com/sponsor",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/fabpot",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2023-07-31T08:02:31+00:00"
+ },
+ {
+ "name": "symfony/options-resolver",
+ "version": "v5.4.21",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/options-resolver.git",
+ "reference": "4fe5cf6ede71096839f0e4b4444d65dd3a7c1eb9"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/options-resolver/zipball/4fe5cf6ede71096839f0e4b4444d65dd3a7c1eb9",
+ "reference": "4fe5cf6ede71096839f0e4b4444d65dd3a7c1eb9",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.2.5",
+ "symfony/deprecation-contracts": "^2.1|^3",
+ "symfony/polyfill-php73": "~1.0",
+ "symfony/polyfill-php80": "^1.16"
+ },
+ "type": "library",
+ "autoload": {
+ "psr-4": {
+ "Symfony\\Component\\OptionsResolver\\": ""
+ },
+ "exclude-from-classmap": [
+ "/Tests/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Fabien Potencier",
+ "email": "fabien@symfony.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "Provides an improved replacement for the array_replace PHP function",
+ "homepage": "https://symfony.com",
+ "keywords": [
+ "config",
+ "configuration",
+ "options"
+ ],
+ "support": {
+ "source": "https://github.com/symfony/options-resolver/tree/v5.4.21"
+ },
+ "funding": [
+ {
+ "url": "https://symfony.com/sponsor",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/fabpot",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2023-02-14T08:03:56+00:00"
+ },
+ {
+ "name": "symfony/polyfill-ctype",
+ "version": "v1.28.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/polyfill-ctype.git",
+ "reference": "ea208ce43cbb04af6867b4fdddb1bdbf84cc28cb"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/polyfill-ctype/zipball/ea208ce43cbb04af6867b4fdddb1bdbf84cc28cb",
+ "reference": "ea208ce43cbb04af6867b4fdddb1bdbf84cc28cb",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.1"
+ },
+ "provide": {
+ "ext-ctype": "*"
+ },
+ "suggest": {
+ "ext-ctype": "For best performance"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-main": "1.28-dev"
+ },
+ "thanks": {
+ "name": "symfony/polyfill",
+ "url": "https://github.com/symfony/polyfill"
+ }
+ },
+ "autoload": {
+ "files": [
+ "bootstrap.php"
+ ],
+ "psr-4": {
+ "Symfony\\Polyfill\\Ctype\\": ""
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Gert de Pagter",
+ "email": "BackEndTea@gmail.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "Symfony polyfill for ctype functions",
+ "homepage": "https://symfony.com",
+ "keywords": [
+ "compatibility",
+ "ctype",
+ "polyfill",
+ "portable"
+ ],
+ "support": {
+ "source": "https://github.com/symfony/polyfill-ctype/tree/v1.28.0"
+ },
+ "funding": [
+ {
+ "url": "https://symfony.com/sponsor",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/fabpot",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2023-01-26T09:26:14+00:00"
+ },
+ {
+ "name": "symfony/polyfill-intl-grapheme",
+ "version": "v1.28.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/polyfill-intl-grapheme.git",
+ "reference": "875e90aeea2777b6f135677f618529449334a612"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/polyfill-intl-grapheme/zipball/875e90aeea2777b6f135677f618529449334a612",
+ "reference": "875e90aeea2777b6f135677f618529449334a612",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.1"
+ },
+ "suggest": {
+ "ext-intl": "For best performance"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-main": "1.28-dev"
+ },
+ "thanks": {
+ "name": "symfony/polyfill",
+ "url": "https://github.com/symfony/polyfill"
+ }
+ },
+ "autoload": {
+ "files": [
+ "bootstrap.php"
+ ],
+ "psr-4": {
+ "Symfony\\Polyfill\\Intl\\Grapheme\\": ""
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Nicolas Grekas",
+ "email": "p@tchwork.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "Symfony polyfill for intl's grapheme_* functions",
+ "homepage": "https://symfony.com",
+ "keywords": [
+ "compatibility",
+ "grapheme",
+ "intl",
+ "polyfill",
+ "portable",
+ "shim"
+ ],
+ "support": {
+ "source": "https://github.com/symfony/polyfill-intl-grapheme/tree/v1.28.0"
+ },
+ "funding": [
+ {
+ "url": "https://symfony.com/sponsor",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/fabpot",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2023-01-26T09:26:14+00:00"
+ },
+ {
+ "name": "symfony/polyfill-intl-normalizer",
+ "version": "v1.28.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/polyfill-intl-normalizer.git",
+ "reference": "8c4ad05dd0120b6a53c1ca374dca2ad0a1c4ed92"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/polyfill-intl-normalizer/zipball/8c4ad05dd0120b6a53c1ca374dca2ad0a1c4ed92",
+ "reference": "8c4ad05dd0120b6a53c1ca374dca2ad0a1c4ed92",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.1"
+ },
+ "suggest": {
+ "ext-intl": "For best performance"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-main": "1.28-dev"
+ },
+ "thanks": {
+ "name": "symfony/polyfill",
+ "url": "https://github.com/symfony/polyfill"
+ }
+ },
+ "autoload": {
+ "files": [
+ "bootstrap.php"
+ ],
+ "psr-4": {
+ "Symfony\\Polyfill\\Intl\\Normalizer\\": ""
+ },
+ "classmap": [
+ "Resources/stubs"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Nicolas Grekas",
+ "email": "p@tchwork.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "Symfony polyfill for intl's Normalizer class and related functions",
+ "homepage": "https://symfony.com",
+ "keywords": [
+ "compatibility",
+ "intl",
+ "normalizer",
+ "polyfill",
+ "portable",
+ "shim"
+ ],
+ "support": {
+ "source": "https://github.com/symfony/polyfill-intl-normalizer/tree/v1.28.0"
+ },
+ "funding": [
+ {
+ "url": "https://symfony.com/sponsor",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/fabpot",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2023-01-26T09:26:14+00:00"
+ },
+ {
+ "name": "symfony/polyfill-mbstring",
+ "version": "v1.28.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/polyfill-mbstring.git",
+ "reference": "42292d99c55abe617799667f454222c54c60e229"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/polyfill-mbstring/zipball/42292d99c55abe617799667f454222c54c60e229",
+ "reference": "42292d99c55abe617799667f454222c54c60e229",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.1"
+ },
+ "provide": {
+ "ext-mbstring": "*"
+ },
+ "suggest": {
+ "ext-mbstring": "For best performance"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-main": "1.28-dev"
+ },
+ "thanks": {
+ "name": "symfony/polyfill",
+ "url": "https://github.com/symfony/polyfill"
+ }
+ },
+ "autoload": {
+ "files": [
+ "bootstrap.php"
+ ],
+ "psr-4": {
+ "Symfony\\Polyfill\\Mbstring\\": ""
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Nicolas Grekas",
+ "email": "p@tchwork.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "Symfony polyfill for the Mbstring extension",
+ "homepage": "https://symfony.com",
+ "keywords": [
+ "compatibility",
+ "mbstring",
+ "polyfill",
+ "portable",
+ "shim"
+ ],
+ "support": {
+ "source": "https://github.com/symfony/polyfill-mbstring/tree/v1.28.0"
+ },
+ "funding": [
+ {
+ "url": "https://symfony.com/sponsor",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/fabpot",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2023-07-28T09:04:16+00:00"
+ },
+ {
+ "name": "symfony/polyfill-php73",
+ "version": "v1.28.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/polyfill-php73.git",
+ "reference": "fe2f306d1d9d346a7fee353d0d5012e401e984b5"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/polyfill-php73/zipball/fe2f306d1d9d346a7fee353d0d5012e401e984b5",
+ "reference": "fe2f306d1d9d346a7fee353d0d5012e401e984b5",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.1"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-main": "1.28-dev"
+ },
+ "thanks": {
+ "name": "symfony/polyfill",
+ "url": "https://github.com/symfony/polyfill"
+ }
+ },
+ "autoload": {
+ "files": [
+ "bootstrap.php"
+ ],
+ "psr-4": {
+ "Symfony\\Polyfill\\Php73\\": ""
+ },
+ "classmap": [
+ "Resources/stubs"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Nicolas Grekas",
+ "email": "p@tchwork.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "Symfony polyfill backporting some PHP 7.3+ features to lower PHP versions",
+ "homepage": "https://symfony.com",
+ "keywords": [
+ "compatibility",
+ "polyfill",
+ "portable",
+ "shim"
+ ],
+ "support": {
+ "source": "https://github.com/symfony/polyfill-php73/tree/v1.28.0"
+ },
+ "funding": [
+ {
+ "url": "https://symfony.com/sponsor",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/fabpot",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2023-01-26T09:26:14+00:00"
+ },
+ {
+ "name": "symfony/polyfill-php80",
+ "version": "v1.31.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/polyfill-php80.git",
+ "reference": "60328e362d4c2c802a54fcbf04f9d3fb892b4cf8"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/polyfill-php80/zipball/60328e362d4c2c802a54fcbf04f9d3fb892b4cf8",
+ "reference": "60328e362d4c2c802a54fcbf04f9d3fb892b4cf8",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.2"
+ },
+ "type": "library",
+ "extra": {
+ "thanks": {
+ "name": "symfony/polyfill",
+ "url": "https://github.com/symfony/polyfill"
+ }
+ },
+ "autoload": {
+ "files": [
+ "bootstrap.php"
+ ],
+ "psr-4": {
+ "Symfony\\Polyfill\\Php80\\": ""
+ },
+ "classmap": [
+ "Resources/stubs"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Ion Bazan",
+ "email": "ion.bazan@gmail.com"
+ },
+ {
+ "name": "Nicolas Grekas",
+ "email": "p@tchwork.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "Symfony polyfill backporting some PHP 8.0+ features to lower PHP versions",
+ "homepage": "https://symfony.com",
+ "keywords": [
+ "compatibility",
+ "polyfill",
+ "portable",
+ "shim"
+ ],
+ "support": {
+ "source": "https://github.com/symfony/polyfill-php80/tree/v1.31.0"
+ },
+ "funding": [
+ {
+ "url": "https://symfony.com/sponsor",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/fabpot",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2024-09-09T11:45:10+00:00"
+ },
+ {
+ "name": "symfony/polyfill-php81",
+ "version": "v1.28.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/polyfill-php81.git",
+ "reference": "7581cd600fa9fd681b797d00b02f068e2f13263b"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/polyfill-php81/zipball/7581cd600fa9fd681b797d00b02f068e2f13263b",
+ "reference": "7581cd600fa9fd681b797d00b02f068e2f13263b",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.1"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-main": "1.28-dev"
+ },
+ "thanks": {
+ "name": "symfony/polyfill",
+ "url": "https://github.com/symfony/polyfill"
+ }
+ },
+ "autoload": {
+ "files": [
+ "bootstrap.php"
+ ],
+ "psr-4": {
+ "Symfony\\Polyfill\\Php81\\": ""
+ },
+ "classmap": [
+ "Resources/stubs"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Nicolas Grekas",
+ "email": "p@tchwork.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "Symfony polyfill backporting some PHP 8.1+ features to lower PHP versions",
+ "homepage": "https://symfony.com",
+ "keywords": [
+ "compatibility",
+ "polyfill",
+ "portable",
+ "shim"
+ ],
+ "support": {
+ "source": "https://github.com/symfony/polyfill-php81/tree/v1.28.0"
+ },
+ "funding": [
+ {
+ "url": "https://symfony.com/sponsor",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/fabpot",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2023-01-26T09:26:14+00:00"
+ },
+ {
+ "name": "symfony/process",
+ "version": "v5.4.46",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/process.git",
+ "reference": "01906871cb9b5e3cf872863b91aba4ec9767daf4"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/process/zipball/01906871cb9b5e3cf872863b91aba4ec9767daf4",
+ "reference": "01906871cb9b5e3cf872863b91aba4ec9767daf4",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.2.5",
+ "symfony/polyfill-php80": "^1.16"
+ },
+ "type": "library",
+ "autoload": {
+ "psr-4": {
+ "Symfony\\Component\\Process\\": ""
+ },
+ "exclude-from-classmap": [
+ "/Tests/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Fabien Potencier",
+ "email": "fabien@symfony.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "Executes commands in sub-processes",
+ "homepage": "https://symfony.com",
+ "support": {
+ "source": "https://github.com/symfony/process/tree/v5.4.46"
+ },
+ "funding": [
+ {
+ "url": "https://symfony.com/sponsor",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/fabpot",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2024-11-06T09:18:28+00:00"
+ },
+ {
+ "name": "symfony/service-contracts",
+ "version": "v2.5.2",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/service-contracts.git",
+ "reference": "4b426aac47d6427cc1a1d0f7e2ac724627f5966c"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/service-contracts/zipball/4b426aac47d6427cc1a1d0f7e2ac724627f5966c",
+ "reference": "4b426aac47d6427cc1a1d0f7e2ac724627f5966c",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.2.5",
+ "psr/container": "^1.1",
+ "symfony/deprecation-contracts": "^2.1|^3"
+ },
+ "conflict": {
+ "ext-psr": "<1.1|>=2"
+ },
+ "suggest": {
+ "symfony/service-implementation": ""
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-main": "2.5-dev"
+ },
+ "thanks": {
+ "name": "symfony/contracts",
+ "url": "https://github.com/symfony/contracts"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "Symfony\\Contracts\\Service\\": ""
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Nicolas Grekas",
+ "email": "p@tchwork.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "Generic abstractions related to writing services",
+ "homepage": "https://symfony.com",
+ "keywords": [
+ "abstractions",
+ "contracts",
+ "decoupling",
+ "interfaces",
+ "interoperability",
+ "standards"
+ ],
+ "support": {
+ "source": "https://github.com/symfony/service-contracts/tree/v2.5.2"
+ },
+ "funding": [
+ {
+ "url": "https://symfony.com/sponsor",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/fabpot",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2022-05-30T19:17:29+00:00"
+ },
+ {
+ "name": "symfony/stopwatch",
+ "version": "v5.4.21",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/stopwatch.git",
+ "reference": "f83692cd869a6f2391691d40a01e8acb89e76fee"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/stopwatch/zipball/f83692cd869a6f2391691d40a01e8acb89e76fee",
+ "reference": "f83692cd869a6f2391691d40a01e8acb89e76fee",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.2.5",
+ "symfony/service-contracts": "^1|^2|^3"
+ },
+ "type": "library",
+ "autoload": {
+ "psr-4": {
+ "Symfony\\Component\\Stopwatch\\": ""
+ },
+ "exclude-from-classmap": [
+ "/Tests/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Fabien Potencier",
+ "email": "fabien@symfony.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "Provides a way to profile code",
+ "homepage": "https://symfony.com",
+ "support": {
+ "source": "https://github.com/symfony/stopwatch/tree/v5.4.21"
+ },
+ "funding": [
+ {
+ "url": "https://symfony.com/sponsor",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/fabpot",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2023-02-14T08:03:56+00:00"
+ },
+ {
+ "name": "symfony/string",
+ "version": "v5.4.32",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/string.git",
+ "reference": "91bf4453d65d8231688a04376c3a40efe0770f04"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/string/zipball/91bf4453d65d8231688a04376c3a40efe0770f04",
+ "reference": "91bf4453d65d8231688a04376c3a40efe0770f04",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.2.5",
+ "symfony/polyfill-ctype": "~1.8",
+ "symfony/polyfill-intl-grapheme": "~1.0",
+ "symfony/polyfill-intl-normalizer": "~1.0",
+ "symfony/polyfill-mbstring": "~1.0",
+ "symfony/polyfill-php80": "~1.15"
+ },
+ "conflict": {
+ "symfony/translation-contracts": ">=3.0"
+ },
+ "require-dev": {
+ "symfony/error-handler": "^4.4|^5.0|^6.0",
+ "symfony/http-client": "^4.4|^5.0|^6.0",
+ "symfony/translation-contracts": "^1.1|^2",
+ "symfony/var-exporter": "^4.4|^5.0|^6.0"
+ },
+ "type": "library",
+ "autoload": {
+ "files": [
+ "Resources/functions.php"
+ ],
+ "psr-4": {
+ "Symfony\\Component\\String\\": ""
+ },
+ "exclude-from-classmap": [
+ "/Tests/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Nicolas Grekas",
+ "email": "p@tchwork.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "Provides an object-oriented API to strings and deals with bytes, UTF-8 code points and grapheme clusters in a unified way",
+ "homepage": "https://symfony.com",
+ "keywords": [
+ "grapheme",
+ "i18n",
+ "string",
+ "unicode",
+ "utf-8",
+ "utf8"
+ ],
+ "support": {
+ "source": "https://github.com/symfony/string/tree/v5.4.32"
+ },
+ "funding": [
+ {
+ "url": "https://symfony.com/sponsor",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/fabpot",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2023-11-26T13:43:46+00:00"
+ },
+ {
+ "name": "symfony/translation",
+ "version": "v5.4.31",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/translation.git",
+ "reference": "ba72f72fceddf36f00bd495966b5873f2d17ad8f"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/translation/zipball/ba72f72fceddf36f00bd495966b5873f2d17ad8f",
+ "reference": "ba72f72fceddf36f00bd495966b5873f2d17ad8f",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.2.5",
+ "symfony/deprecation-contracts": "^2.1|^3",
+ "symfony/polyfill-mbstring": "~1.0",
+ "symfony/polyfill-php80": "^1.16",
+ "symfony/translation-contracts": "^2.3"
+ },
+ "conflict": {
+ "symfony/config": "<4.4",
+ "symfony/console": "<5.3",
+ "symfony/dependency-injection": "<5.0",
+ "symfony/http-kernel": "<5.0",
+ "symfony/twig-bundle": "<5.0",
+ "symfony/yaml": "<4.4"
+ },
+ "provide": {
+ "symfony/translation-implementation": "2.3"
+ },
+ "require-dev": {
+ "psr/log": "^1|^2|^3",
+ "symfony/config": "^4.4|^5.0|^6.0",
+ "symfony/console": "^5.4|^6.0",
+ "symfony/dependency-injection": "^5.0|^6.0",
+ "symfony/finder": "^4.4|^5.0|^6.0",
+ "symfony/http-client-contracts": "^1.1|^2.0|^3.0",
+ "symfony/http-kernel": "^5.0|^6.0",
+ "symfony/intl": "^4.4|^5.0|^6.0",
+ "symfony/polyfill-intl-icu": "^1.21",
+ "symfony/service-contracts": "^1.1.2|^2|^3",
+ "symfony/yaml": "^4.4|^5.0|^6.0"
+ },
+ "suggest": {
+ "psr/log-implementation": "To use logging capability in translator",
+ "symfony/config": "",
+ "symfony/yaml": ""
+ },
+ "type": "library",
+ "autoload": {
+ "files": [
+ "Resources/functions.php"
+ ],
+ "psr-4": {
+ "Symfony\\Component\\Translation\\": ""
+ },
+ "exclude-from-classmap": [
+ "/Tests/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Fabien Potencier",
+ "email": "fabien@symfony.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "Provides tools to internationalize your application",
+ "homepage": "https://symfony.com",
+ "support": {
+ "source": "https://github.com/symfony/translation/tree/v5.4.31"
+ },
+ "funding": [
+ {
+ "url": "https://symfony.com/sponsor",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/fabpot",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2023-11-03T16:16:43+00:00"
+ },
+ {
+ "name": "symfony/translation-contracts",
+ "version": "v2.5.2",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/translation-contracts.git",
+ "reference": "136b19dd05cdf0709db6537d058bcab6dd6e2dbe"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/translation-contracts/zipball/136b19dd05cdf0709db6537d058bcab6dd6e2dbe",
+ "reference": "136b19dd05cdf0709db6537d058bcab6dd6e2dbe",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.2.5"
+ },
+ "suggest": {
+ "symfony/translation-implementation": ""
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-main": "2.5-dev"
+ },
+ "thanks": {
+ "name": "symfony/contracts",
+ "url": "https://github.com/symfony/contracts"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "Symfony\\Contracts\\Translation\\": ""
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Nicolas Grekas",
+ "email": "p@tchwork.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "Generic abstractions related to translation",
+ "homepage": "https://symfony.com",
+ "keywords": [
+ "abstractions",
+ "contracts",
+ "decoupling",
+ "interfaces",
+ "interoperability",
+ "standards"
+ ],
+ "support": {
+ "source": "https://github.com/symfony/translation-contracts/tree/v2.5.2"
+ },
+ "funding": [
+ {
+ "url": "https://symfony.com/sponsor",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/fabpot",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2022-06-27T16:58:25+00:00"
+ },
+ {
+ "name": "symfony/yaml",
+ "version": "v5.4.31",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/yaml.git",
+ "reference": "f387675d7f5fc4231f7554baa70681f222f73563"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/yaml/zipball/f387675d7f5fc4231f7554baa70681f222f73563",
+ "reference": "f387675d7f5fc4231f7554baa70681f222f73563",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.2.5",
+ "symfony/deprecation-contracts": "^2.1|^3",
+ "symfony/polyfill-ctype": "^1.8"
+ },
+ "conflict": {
+ "symfony/console": "<5.3"
+ },
+ "require-dev": {
+ "symfony/console": "^5.3|^6.0"
+ },
+ "suggest": {
+ "symfony/console": "For validating YAML files using the lint command"
+ },
+ "bin": [
+ "Resources/bin/yaml-lint"
+ ],
+ "type": "library",
+ "autoload": {
+ "psr-4": {
+ "Symfony\\Component\\Yaml\\": ""
+ },
+ "exclude-from-classmap": [
+ "/Tests/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Fabien Potencier",
+ "email": "fabien@symfony.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "Loads and dumps YAML files",
+ "homepage": "https://symfony.com",
+ "support": {
+ "source": "https://github.com/symfony/yaml/tree/v5.4.31"
+ },
+ "funding": [
+ {
+ "url": "https://symfony.com/sponsor",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/fabpot",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2023-11-03T14:41:28+00:00"
+ }
+ ],
+ "aliases": [],
+ "minimum-stability": "stable",
+ "stability-flags": [],
+ "prefer-stable": true,
+ "prefer-lowest": false,
+ "platform": {
+ "php": ">=7.4 < 9"
+ },
+ "platform-dev": [],
+ "platform-overrides": {
+ "php": "7.4"
+ },
+ "plugin-api-version": "2.6.0"
+}
diff --git a/vendor/10up/wp_mock/php/WP_Mock.php b/vendor/10up/wp_mock/php/WP_Mock.php
new file mode 100644
index 0000000..49ef1f3
--- /dev/null
+++ b/vendor/10up/wp_mock/php/WP_Mock.php
@@ -0,0 +1,549 @@
+flush();
+ self::$functionsManager->flush();
+
+ Mockery::close();
+ Handler::cleanup();
+ }
+
+ /**
+ * Fire a specific (mocked) callback when an apply_filters() call is used.
+ *
+ * @param string $filter
+ *
+ * @return \WP_Mock\Filter
+ */
+ public static function onFilter($filter)
+ {
+ self::$event_manager->called($filter, 'filter');
+ return self::$event_manager->filter($filter);
+ }
+
+ /**
+ * Fire a specific (mocked) callback when a do_action() call is used.
+ *
+ * @param string $action
+ *
+ * @return \WP_Mock\Action
+ */
+ public static function onAction($action)
+ {
+ return self::$event_manager->action($action);
+ }
+
+ /**
+ * Get a filter or action added callback object
+ *
+ * @param string $hook
+ * @param string $type
+ *
+ * @return \WP_Mock\HookedCallback
+ */
+ public static function onHookAdded($hook, $type = 'filter')
+ {
+ return self::$event_manager->callback($hook, $type);
+ }
+
+ /**
+ * Get a filter added callback object
+ *
+ * @param string $hook
+ *
+ * @return \WP_Mock\HookedCallback
+ */
+ public static function onFilterAdded($hook)
+ {
+ return self::onHookAdded($hook, 'filter');
+ }
+
+ /**
+ * Get an action added callback object
+ *
+ * @param string $hook
+ *
+ * @return \WP_Mock\HookedCallback
+ */
+ public static function onActionAdded($hook)
+ {
+ return self::onHookAdded($hook, 'action');
+ }
+
+ /**
+ * Alert the Event Manager that an action has been invoked.
+ *
+ * @param string $action
+ */
+ public static function invokeAction($action)
+ {
+ self::$event_manager->called($action);
+ }
+
+ public static function addFilter($hook)
+ {
+ self::addHook($hook, 'filter');
+ }
+
+ public static function addAction($hook)
+ {
+ self::addHook($hook, 'action');
+ }
+
+ public static function addHook($hook, $type = 'filter')
+ {
+ $type_name = "$type::$hook";
+ self::$event_manager->called($type_name, 'callback');
+ }
+
+ /**
+ * Adds an expectation that an action will be called during the test.
+ *
+ * @param string $action expected action
+ * @returnv oid
+ */
+ public static function expectAction(string $action) : void
+ {
+ $intercept = Mockery::mock('intercept');
+ $intercept->shouldReceive('intercepted')->atLeast()->once();
+ $args = func_get_args();
+ $args = count($args) > 1 ? array_slice($args, 1) : array( null );
+
+ $mocked_action = self::onAction($action);
+ $responder = call_user_func_array(array( $mocked_action, 'with' ), $args);
+ $responder->perform([$intercept, 'intercepted']);
+ }
+
+ /**
+ * Adds an expectation that a filter will be applied during the test.
+ *
+ * @param string $filter expected filter
+ * @return void
+ */
+ public static function expectFilter(string $filter) : void
+ {
+ $intercept = Mockery::mock('intercept');
+ $intercept->shouldReceive('intercepted')->atLeast()->once()->andReturnUsing(function ($value) {
+ return $value;
+ });
+ $args = func_num_args() > 1 ? array_slice(func_get_args(), 1) : array( null );
+
+ $mocked_filter = self::onFilter($filter);
+ $responder = call_user_func_array(array( $mocked_filter, 'with' ), $args);
+ $responder->reply(new WP_Mock\InvokedFilterValue(array( $intercept, 'intercepted' )));
+ }
+
+ /**
+ * Asserts that all actions are called.
+ *
+ * @return void
+ */
+ public static function assertActionsCalled() : void
+ {
+ $allActionsCalled = self::$event_manager->allActionsCalled();
+ $failed = implode(', ', self::$event_manager->expectedActions());
+ PHPUnit\Framework\Assert::assertTrue($allActionsCalled, 'Method failed to invoke actions: ' . $failed);
+ }
+
+ /**
+ * Asserts that all filters are called.
+ *
+ * @return void
+ */
+ public static function assertFiltersCalled() : void
+ {
+ $allFiltersCalled = self::$event_manager->allFiltersCalled();
+ $failed = implode(', ', self::$event_manager->expectedFilters());
+ PHPUnit\Framework\Assert::assertTrue($allFiltersCalled, 'Method failed to invoke filters: ' . $failed);
+ }
+
+ /**
+ * Adds an expectation that an action hook should be added.
+ *
+ * @param string $action the action hook name
+ * @param string|callable-string|callable|Type $callback the callback that should be registered
+ * @param int $priority the priority it should be registered at
+ * @param int $args the number of arguments that should be allowed
+ * @return void
+ */
+ public static function expectActionAdded(string $action, $callback, int $priority = 10, int $args = 1) : void
+ {
+ self::expectHookAdded('action', $action, $callback, $priority, $args);
+ }
+
+ /**
+ * Adds an expectation that an action hook should not be added.
+ *
+ * @param string $action the action hook name
+ * @param string|callable-string|callable|Type $callback the callback that should be registered
+ * @param int $priority the priority it should be registered at
+ * @param int $args the number of arguments that should be allowed
+ * @return void
+ */
+ public static function expectActionNotAdded(string $action, $callback, int $priority = 10, int $args = 1) : void
+ {
+ self::expectHookNotAdded('action', $action, $callback, $priority, $args);
+ }
+
+ /**
+ * Add an expectation that a filter hook should be added.
+ *
+ * @param string $filter the filter hook name
+ * @param string|callable-string|callable|Type $callback the callback that should be registered
+ * @param int $priority the priority it should be registered at
+ * @param int $args the number of arguments that should be allowed
+ * @return void
+ */
+ public static function expectFilterAdded(string $filter, $callback, int $priority = 10, int $args = 1) : void
+ {
+ self::expectHookAdded('filter', $filter, $callback, $priority, $args);
+ }
+
+ /**
+ * Adds an expectation that a filter hook should not be added.
+ *
+ * @param string $filter the filter hook name
+ * @param string|callable-string|callable|Type $callback the callback that should be registered
+ * @param int $priority the priority it should be registered at
+ * @param int $args the number of arguments that should be allowed
+ * @return void
+ */
+ public static function expectFilterNotAdded(string $filter, $callback, int $priority = 10, int $args = 10) : void
+ {
+ self::expectHookNotAdded('filter', $filter, $callback, $priority, $args);
+ }
+
+ /**
+ * Adds an expectation that a hook should be added.
+ *
+ * Based {@see Mockery\MockInterface::shouldReceive()}.
+ *
+ * @param string $type the type of hook being added ('action' or 'filter')
+ * @param string $hook the hook name
+ * @param string|callable-string|callable|Type $callback the callback that should be registered
+ * @param int $priority the priority it should be registered at
+ * @param int $args the number of arguments that should be allowed
+ * @return void
+ */
+ public static function expectHookAdded(string $type, string $hook, $callback, int $priority = 10, int $args = 1) : void
+ {
+ $intercept = Mockery::mock('intercept');
+ $intercept->shouldReceive('intercepted')->atLeast()->once();
+
+ /** @var WP_Mock\HookedCallbackResponder $responder */
+ $responder = self::onHookAdded($hook, $type)
+ ->with($callback, $priority, $args);
+ $responder->perform([$intercept, 'intercepted']);
+ }
+
+ /**
+ * Adds an expectation that a hook should not be added.
+ *
+ * Based {@see Mockery\MockInterface::shouldNotReceive()}.
+ *
+ * @param string $type the type of hook being added ('action' or 'filter')
+ * @param string $hook the hook name
+ * @param string|callable-string|callable|Type $callback the callback that should be registered
+ * @param int $priority the priority it should be registered at
+ * @param int $args the number of arguments that should be allowed
+ * @return void
+ */
+ public static function expectHookNotAdded(string $type, string $hook, $callback, int $priority = 10, int $args = 1) : void
+ {
+ $intercept = Mockery::mock('intercept');
+ $intercept->shouldNotReceive('intercepted');
+
+ /** @var WP_Mock\HookedCallbackResponder $responder */
+ $responder = self::onHookAdded($hook, $type)
+ ->with($callback, $priority, $args);
+ $responder->perform([$intercept, 'intercepted']);
+ }
+
+ /**
+ * Asserts that all hooks are added.
+ *
+ * @return void
+ */
+ public static function assertHooksAdded() : void
+ {
+ $allHooksAdded = self::$event_manager->allHooksAdded();
+ $failed = implode(', ', self::$event_manager->expectedHooks());
+ PHPUnit\Framework\Assert::assertTrue($allHooksAdded, 'Method failed to add hooks: ' . $failed);
+ }
+
+ /**
+ * Mocks a WordPress API function.
+ *
+ * This function registers a mock object for a WordPress function and, if necessary, dynamically defines the function.
+ *
+ * Pass the function name as the first argument (e.g. `wp_remote_get()`) and pass in details about the expectations in the $args param.
+ * The arguments have a few options for defining expectations about how the WordPress function should be used during a test.
+ *
+ * Currently, it accepts the following settings:
+ *
+ * - `times`: Defines expectations for the number of times a function should be called. The default is `0` or more times.
+ * To expect the function to be called an exact amount of times, set times to a non-negative numeric value.
+ * To specify that the function should be called a minimum number of times, use a string with the minimum followed by '+' (e.g. '3+' means 3 or more times).
+ * Append a '-' to indicate a maximum number of times a function should be called (e.g. '3-' means no more than 3 times).
+ * To indicate a range, use '-' between two numbers (e.g. '2-5' means at least 2 times and no more than 5 times).
+ *
+ * - `return`: Defines the value (if any) that the function should return.
+ * If you pass a `Closure` as the return value, the function will return whatever the closure's return value.
+ *
+ * - `return_in_order`: Use this if your function will be called multiple times in the test but needs to have different return values.
+ * Set this to an array of return values. Each time the function is called, it will return the next value in the sequence until it reaches the last value, which will become the return value for all subsequent calls.
+ * For example, if you are mocking `is_single()`, you can set `return_in_order` to `[false, true]`. The first time is_single() is called it will return false.
+ * The second and all subsequent times it will return true. Setting this value overrides return, so if you set both, return will be ignored.
+ *
+ * - `return_arg`: Use this to specify that the function should return one of its arguments. `return_arg` should be the position of the argument in the arguments array, so `0` for the first argument, `1` for the second, etc.
+ * You can also set this to true, which is equivalent to `0`. This will override both return and return_in_order.
+ *
+ * - `args`: Use this to set expectations about what the arguments passed to the function should be.
+ * This value should always be an array with the arguments in order.
+ * Like with `return`, if you use a `Closure`, its return value will be used to validate the argument expectations.
+ * WP_Mock has several helper functions to make this feature more flexible. There are static methods on the \WP_Mock\Functions class. They are:
+ * - {@see Functions::type($type)} Expects an argument of a certain type. This can be any core PHP data type (string, int, resource, callable, etc.) or any class or interface name.
+ * - {@see Functions::anyOf($values)} Expects the argument to be any value in the `$values` array.
+ * In addition to these helper functions, you can indicate that the argument can be any value of any type by using `*`.
+ * So, for example, if you are expecting `get_post_meta()` to be called, the `args` array might look something like this: `[$post->ID, 'some_meta_key', true]`.
+ *
+ * Returns the {@see Mockery\Expectation} object with the function expectations added.
+ * It is possible to use Mockery methods to add expectations to the object returned, which will then be combined with any expectations that may have been passed as arguments.
+ *
+ * @param string $function function name
+ * @param mixed[] $args optional arguments to set expectations
+ * @return Mockery\Expectation
+ * @throws InvalidArgumentException
+ */
+ public static function userFunction(string $function, array $args = [])
+ {
+ return self::$functionsManager->register($function, $args);
+ }
+
+ /**
+ * A wrapper for {@see WP_Mock::userFunction()} that will simply set/override the return to be a function that echoes the value that its passed.
+ *
+ * For example, `esc_attr_e()` may need to be mocked, and it must echo some value.
+ * {@see WP_Mock::echoFunction()} will set `esc_attr_e()` to echo the value its passed:
+ *
+ * WP_Mock::echoFunction('esc_attr_e');
+ * esc_attr_e('some_value'); // echoes "some_value"
+ *
+ * @param string $function function name
+ * @param mixed[]|scalar $args optional arguments
+ * @return Mockery\Expectation
+ * @throws InvalidArgumentException
+ */
+ public static function echoFunction(string $function, $args = [])
+ {
+ /** @var array