wp-studio 1.7.8-beta2 → 1.7.8-beta4

package/dist/cli/wp-files/sqlite-command/vendor/{mustache/mustache/src → wp-cli/mustache/src/Mustache}/Parser.php

@@ -3,33 +3,27 @@
 /*
  * This file is part of Mustache.php.
  *
- * (c) 2010-2025 Justin Hileman
+ * (c) 2010-2017 Justin Hileman
  *
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
 
-namespace Mustache;
-
-use Mustache\Exception\SyntaxException;
-
 /**
  * Mustache Parser class.
  *
  * This class is responsible for turning a set of Mustache tokens into a parse tree.
  */
-class Parser
+class Mustache_Parser
 {
     private $lineNum;
     private $lineTokens;
     private $pragmas;
-    private $defaultPragmas = [];
-
-    // Optional Mustache specs
-    private $dynamicNames = true;
-    private $inheritance = true;
+    private $defaultPragmas = array();
 
     private $pragmaFilters;
+    private $pragmaBlocks;
+    private $pragmaDynamicNames;
 
     /**
      * Process an array of Mustache tokens and convert them into a parse tree.
@@ -38,46 +32,30 @@ class Parser
      *
      * @return array Mustache token parse tree
      */
-    public function parse(array $tokens = [])
+    public function parse(array $tokens = array())
     {
         $this->lineNum    = -1;
         $this->lineTokens = 0;
         $this->pragmas    = $this->defaultPragmas;
 
-        $this->pragmaFilters = isset($this->pragmas[Engine::PRAGMA_FILTERS]);
+        $this->pragmaFilters      = isset($this->pragmas[Mustache_Engine::PRAGMA_FILTERS]);
+        $this->pragmaBlocks       = isset($this->pragmas[Mustache_Engine::PRAGMA_BLOCKS]);
+        $this->pragmaDynamicNames = isset($this->pragmas[Mustache_Engine::PRAGMA_DYNAMIC_NAMES]);
 
         return $this->buildTree($tokens);
     }
 
-    /**
-     * Disable optional Mustache specs.
-     *
-     * @internal Users should set options in Mustache\Engine, not here :)
-     *
-     * @param bool[] $options
-     */
-    public function setOptions(array $options)
-    {
-        if (isset($options['dynamic_names'])) {
-            $this->dynamicNames = $options['dynamic_names'] !== false;
-        }
-
-        if (isset($options['inheritance'])) {
-            $this->inheritance = $options['inheritance'] !== false;
-        }
-    }
-
     /**
      * Enable pragmas across all templates, regardless of the presence of pragma
      * tags in the individual templates.
      *
-     * @internal Users should set global pragmas in Mustache\Engine, not here :)
+     * @internal Users should set global pragmas in Mustache_Engine, not here :)
      *
      * @param string[] $pragmas
      */
     public function setPragmas(array $pragmas)
     {
-        $this->pragmas = [];
+        $this->pragmas = array();
         foreach ($pragmas as $pragma) {
             $this->enablePragma($pragma);
         }
@@ -87,7 +65,7 @@ class Parser
     /**
      * Helper method for recursively building a parse tree.
      *
-     * @throws SyntaxException when nesting errors or mismatched section tags are encountered
+     * @throws Mustache_Exception_SyntaxException when nesting errors or mismatched section tags are encountered
      *
      * @param array &$tokens Set of Mustache tokens
      * @param array $parent  Parent token (default: null)
@@ -96,117 +74,118 @@ class Parser
      */
     private function buildTree(array &$tokens, $parent = null)
     {
-        $nodes = [];
+        $nodes = array();
 
         while (!empty($tokens)) {
             $token = array_shift($tokens);
 
-            if ($token[Tokenizer::LINE] === $this->lineNum) {
+            if ($token[Mustache_Tokenizer::LINE] === $this->lineNum) {
                 $this->lineTokens++;
             } else {
-                $this->lineNum    = $token[Tokenizer::LINE];
+                $this->lineNum    = $token[Mustache_Tokenizer::LINE];
                 $this->lineTokens = 0;
             }
 
-            if ($token[Tokenizer::TYPE] !== Tokenizer::T_COMMENT) {
-                if (isset($token[Tokenizer::NAME])) {
+            if ($token[Mustache_Tokenizer::TYPE] !== Mustache_Tokenizer::T_COMMENT) {
+                if ($this->pragmaDynamicNames && isset($token[Mustache_Tokenizer::NAME])) {
                     list($name, $isDynamic) = $this->getDynamicName($token);
                     if ($isDynamic) {
-                        $token[Tokenizer::NAME]    = $name;
-                        $token[Tokenizer::DYNAMIC] = true;
+                        $token[Mustache_Tokenizer::NAME]    = $name;
+                        $token[Mustache_Tokenizer::DYNAMIC] = true;
                     }
                 }
 
-                if ($this->pragmaFilters && isset($token[Tokenizer::NAME])) {
-                    list($name, $filters) = $this->getNameAndFilters($token[Tokenizer::NAME]);
+                if ($this->pragmaFilters && isset($token[Mustache_Tokenizer::NAME])) {
+                    list($name, $filters) = $this->getNameAndFilters($token[Mustache_Tokenizer::NAME]);
                     if (!empty($filters)) {
-                        $token[Tokenizer::NAME]    = $name;
-                        $token[Tokenizer::FILTERS] = $filters;
+                        $token[Mustache_Tokenizer::NAME]    = $name;
+                        $token[Mustache_Tokenizer::FILTERS] = $filters;
                     }
                 }
             }
 
-            switch ($token[Tokenizer::TYPE]) {
-                case Tokenizer::T_DELIM_CHANGE:
+            switch ($token[Mustache_Tokenizer::TYPE]) {
+                case Mustache_Tokenizer::T_DELIM_CHANGE:
                     $this->checkIfTokenIsAllowedInParent($parent, $token);
                     $this->clearStandaloneLines($nodes, $tokens);
                     break;
 
-                case Tokenizer::T_SECTION:
-                case Tokenizer::T_INVERTED:
+                case Mustache_Tokenizer::T_SECTION:
+                case Mustache_Tokenizer::T_INVERTED:
                     $this->checkIfTokenIsAllowedInParent($parent, $token);
                     $this->clearStandaloneLines($nodes, $tokens);
                     $nodes[] = $this->buildTree($tokens, $token);
                     break;
 
-                case Tokenizer::T_END_SECTION:
+                case Mustache_Tokenizer::T_END_SECTION:
                     if (!isset($parent)) {
                         $msg = sprintf(
                             'Unexpected closing tag: /%s on line %d',
-                            $token[Tokenizer::NAME],
-                            $token[Tokenizer::LINE]
+                            $token[Mustache_Tokenizer::NAME],
+                            $token[Mustache_Tokenizer::LINE]
                         );
-                        throw new SyntaxException($msg, $token);
+                        throw new Mustache_Exception_SyntaxException($msg, $token);
                     }
 
-                    $sameName = $token[Tokenizer::NAME] !== $parent[Tokenizer::NAME];
-                    $tokenDynamic = isset($token[Tokenizer::DYNAMIC]) && $token[Tokenizer::DYNAMIC];
-                    $parentDynamic = isset($parent[Tokenizer::DYNAMIC]) && $parent[Tokenizer::DYNAMIC];
+                    $sameName = $token[Mustache_Tokenizer::NAME] !== $parent[Mustache_Tokenizer::NAME];
+                    $tokenDynamic = isset($token[Mustache_Tokenizer::DYNAMIC]) && $token[Mustache_Tokenizer::DYNAMIC];
+                    $parentDynamic = isset($parent[Mustache_Tokenizer::DYNAMIC]) && $parent[Mustache_Tokenizer::DYNAMIC];
 
                     if ($sameName || ($tokenDynamic !== $parentDynamic)) {
                         $msg = sprintf(
                             'Nesting error: %s%s (on line %d) vs. %s%s (on line %d)',
                             $parentDynamic ? '*' : '',
-                            $parent[Tokenizer::NAME],
-                            $parent[Tokenizer::LINE],
+                            $parent[Mustache_Tokenizer::NAME],
+                            $parent[Mustache_Tokenizer::LINE],
                             $tokenDynamic ? '*' : '',
-                            $token[Tokenizer::NAME],
-                            $token[Tokenizer::LINE]
+                            $token[Mustache_Tokenizer::NAME],
+                            $token[Mustache_Tokenizer::LINE]
                         );
-                        throw new SyntaxException($msg, $token);
+                        throw new Mustache_Exception_SyntaxException($msg, $token);
                     }
 
                     $this->clearStandaloneLines($nodes, $tokens);
-                    $parent[Tokenizer::END]   = $token[Tokenizer::INDEX];
-                    $parent[Tokenizer::NODES] = $nodes;
+                    $parent[Mustache_Tokenizer::END]   = $token[Mustache_Tokenizer::INDEX];
+                    $parent[Mustache_Tokenizer::NODES] = $nodes;
 
                     return $parent;
 
-                case Tokenizer::T_PARTIAL:
+                case Mustache_Tokenizer::T_PARTIAL:
                     $this->checkIfTokenIsAllowedInParent($parent, $token);
                     //store the whitespace prefix for laters!
                     if ($indent = $this->clearStandaloneLines($nodes, $tokens)) {
-                        $token[Tokenizer::INDENT] = $indent[Tokenizer::VALUE];
+                        $token[Mustache_Tokenizer::INDENT] = $indent[Mustache_Tokenizer::VALUE];
                     }
                     $nodes[] = $token;
                     break;
 
-                case Tokenizer::T_PARENT:
+                case Mustache_Tokenizer::T_PARENT:
                     $this->checkIfTokenIsAllowedInParent($parent, $token);
                     $nodes[] = $this->buildTree($tokens, $token);
                     break;
 
-                case Tokenizer::T_BLOCK_VAR:
-                    if ($this->inheritance) {
-                        if (isset($parent) && $parent[Tokenizer::TYPE] === Tokenizer::T_PARENT) {
-                            $token[Tokenizer::TYPE] = Tokenizer::T_BLOCK_ARG;
+                case Mustache_Tokenizer::T_BLOCK_VAR:
+                    if ($this->pragmaBlocks) {
+                        // BLOCKS pragma is enabled, let's do this!
+                        if (isset($parent) && $parent[Mustache_Tokenizer::TYPE] === Mustache_Tokenizer::T_PARENT) {
+                            $token[Mustache_Tokenizer::TYPE] = Mustache_Tokenizer::T_BLOCK_ARG;
                         }
                         $this->clearStandaloneLines($nodes, $tokens);
                         $nodes[] = $this->buildTree($tokens, $token);
                     } else {
                         // pretend this was just a normal "escaped" token...
-                        $token[Tokenizer::TYPE] = Tokenizer::T_ESCAPED;
+                        $token[Mustache_Tokenizer::TYPE] = Mustache_Tokenizer::T_ESCAPED;
                         // TODO: figure out how to figure out if there was a space after this dollar:
-                        $token[Tokenizer::NAME] = '$' . $token[Tokenizer::NAME];
+                        $token[Mustache_Tokenizer::NAME] = '$' . $token[Mustache_Tokenizer::NAME];
                         $nodes[] = $token;
                     }
                     break;
 
-                case Tokenizer::T_PRAGMA:
-                    $this->enablePragma($token[Tokenizer::NAME]);
+                case Mustache_Tokenizer::T_PRAGMA:
+                    $this->enablePragma($token[Mustache_Tokenizer::NAME]);
                     // no break
 
-                case Tokenizer::T_COMMENT:
+                case Mustache_Tokenizer::T_COMMENT:
                     $this->clearStandaloneLines($nodes, $tokens);
                     $nodes[] = $token;
                     break;
@@ -220,10 +199,10 @@ class Parser
         if (isset($parent)) {
             $msg = sprintf(
                 'Missing closing tag: %s opened on line %d',
-                $parent[Tokenizer::NAME],
-                $parent[Tokenizer::LINE]
+                $parent[Mustache_Tokenizer::NAME],
+                $parent[Mustache_Tokenizer::LINE]
             );
-            throw new SyntaxException($msg, $parent);
+            throw new Mustache_Exception_SyntaxException($msg, $parent);
         }
 
         return $nodes;
@@ -259,7 +238,7 @@ class Parser
 
         if ($next = reset($tokens)) {
             // If we're on a new line, bail.
-            if ($next[Tokenizer::LINE] !== $this->lineNum) {
+            if ($next[Mustache_Tokenizer::LINE] !== $this->lineNum) {
                 return;
             }
 
@@ -271,7 +250,7 @@ class Parser
             if (count($tokens) !== 1) {
                 // Unless it's the last token in the template, the next token
                 // must end in newline for this to be standalone.
-                if (substr($next[Tokenizer::VALUE], -1) !== "\n") {
+                if (substr($next[Mustache_Tokenizer::VALUE], -1) !== "\n") {
                     return;
                 }
             }
@@ -291,12 +270,14 @@ class Parser
      *
      * True if token type is T_TEXT and value is all whitespace characters.
      *
+     * @param array $token
+     *
      * @return bool True if token is a whitespace token
      */
     private function tokenIsWhitespace(array $token)
     {
-        if ($token[Tokenizer::TYPE] === Tokenizer::T_TEXT) {
-            return preg_match('/^\s*$/', $token[Tokenizer::VALUE]);
+        if ($token[Mustache_Tokenizer::TYPE] === Mustache_Tokenizer::T_TEXT) {
+            return preg_match('/^\s*$/', $token[Mustache_Tokenizer::VALUE]);
         }
 
         return false;
@@ -305,60 +286,64 @@ class Parser
     /**
      * Check whether a token is allowed inside a parent tag.
      *
-     * @throws SyntaxException if an invalid token is found inside a parent tag
+     * @throws Mustache_Exception_SyntaxException if an invalid token is found inside a parent tag
      *
      * @param array|null $parent
+     * @param array      $token
      */
     private function checkIfTokenIsAllowedInParent($parent, array $token)
     {
-        if (isset($parent) && $parent[Tokenizer::TYPE] === Tokenizer::T_PARENT) {
-            throw new SyntaxException('Illegal content in < parent tag', $token);
+        if (isset($parent) && $parent[Mustache_Tokenizer::TYPE] === Mustache_Tokenizer::T_PARENT) {
+            throw new Mustache_Exception_SyntaxException('Illegal content in < parent tag', $token);
         }
     }
 
     /**
      * Parse dynamic names.
      *
-     * @throws SyntaxException when a tag does not allow *
-     * @throws SyntaxException on multiple *s, or dots or filters with *
+     * @throws Mustache_Exception_SyntaxException when a tag does not allow *
+     * @throws Mustache_Exception_SyntaxException on multiple *s, or dots or filters with *
      */
     private function getDynamicName(array $token)
     {
-        $name = $token[Tokenizer::NAME];
+        $name = $token[Mustache_Tokenizer::NAME];
         $isDynamic = false;
 
-        if ($this->dynamicNames && preg_match('/^\s*\*\s*/', $name)) {
+        if (preg_match('/^\s*\*\s*/', $name)) {
             $this->ensureTagAllowsDynamicNames($token);
             $name = preg_replace('/^\s*\*\s*/', '', $name);
             $isDynamic = true;
         }
 
-        return [$name, $isDynamic];
+        return array($name, $isDynamic);
     }
 
     /**
      * Check whether the given token supports dynamic tag names.
      *
-     * @throws SyntaxException when a tag does not allow *
+     * @throws Mustache_Exception_SyntaxException when a tag does not allow *
+     *
+     * @param array $token
      */
     private function ensureTagAllowsDynamicNames(array $token)
     {
-        switch ($token[Tokenizer::TYPE]) {
-            case Tokenizer::T_PARTIAL:
-            case Tokenizer::T_PARENT:
-            case Tokenizer::T_END_SECTION:
+        switch ($token[Mustache_Tokenizer::TYPE]) {
+            case Mustache_Tokenizer::T_PARTIAL:
+            case Mustache_Tokenizer::T_PARENT:
+            case Mustache_Tokenizer::T_END_SECTION:
                 return;
         }
 
         $msg = sprintf(
             'Invalid dynamic name: %s in %s tag',
-            $token[Tokenizer::NAME],
-            Tokenizer::getTagName($token[Tokenizer::TYPE])
+            $token[Mustache_Tokenizer::NAME],
+            Mustache_Tokenizer::getTagName($token[Mustache_Tokenizer::TYPE])
         );
 
-        throw new SyntaxException($msg, $token);
+        throw new Mustache_Exception_SyntaxException($msg, $token);
     }
 
+
     /**
      * Split a tag name into name and filters.
      *
@@ -371,7 +356,7 @@ class Parser
         $filters = array_map('trim', explode('|', $name));
         $name    = array_shift($filters);
 
-        return [$name, $filters];
+        return array($name, $filters);
     }
 
     /**
@@ -384,9 +369,17 @@ class Parser
         $this->pragmas[$name] = true;
 
         switch ($name) {
-            case Engine::PRAGMA_FILTERS:
+            case Mustache_Engine::PRAGMA_BLOCKS:
+                $this->pragmaBlocks = true;
+                break;
+
+            case Mustache_Engine::PRAGMA_FILTERS:
                 $this->pragmaFilters = true;
                 break;
+
+            case Mustache_Engine::PRAGMA_DYNAMIC_NAMES:
+                $this->pragmaDynamicNames = true;
+                break;
         }
     }
 }

package/dist/cli/wp-files/sqlite-command/vendor/{mustache/mustache/src → wp-cli/mustache/src/Mustache}/Source/FilesystemSource.php

@@ -3,17 +3,12 @@
 /*
  * This file is part of Mustache.php.
  *
- * (c) 2010-2025 Justin Hileman
+ * (c) 2010-2017 Justin Hileman
  *
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
 
-namespace Mustache\Source;
-
-use Mustache\Exception\RuntimeException;
-use Mustache\Source;
-
 /**
  * Mustache template Filesystem Source.
  *
@@ -22,7 +17,7 @@ use Mustache\Source;
  * It is more suitable for production use, and is used by default in the
  * ProductionFilesystemLoader.
  */
-class FilesystemSource implements Source
+class Mustache_Source_FilesystemSource implements Mustache_Source
 {
     private $fileName;
     private $statProps;
@@ -32,6 +27,7 @@ class FilesystemSource implements Source
      * Filesystem Source constructor.
      *
      * @param string $fileName
+     * @param array  $statProps
      */
     public function __construct($fileName, array $statProps)
     {
@@ -42,15 +38,15 @@ class FilesystemSource implements Source
     /**
      * Get the Source key (used to generate the compiled class name).
      *
-     * @throws RuntimeException when a source file cannot be read
+     * @throws Mustache_Exception_RuntimeException when a source file cannot be read
      *
      * @return string
      */
     public function getKey()
     {
-        $chunks = [
+        $chunks = array(
             'fileName' => $this->fileName,
-        ];
+        );
 
         if (!empty($this->statProps)) {
             if (!isset($this->stat)) {
@@ -58,7 +54,7 @@ class FilesystemSource implements Source
             }
 
             if ($this->stat === false) {
-                throw new RuntimeException(sprintf('Failed to read source file "%s".', $this->fileName));
+                throw new Mustache_Exception_RuntimeException(sprintf('Failed to read source file "%s".', $this->fileName));
             }
 
             foreach ($this->statProps as $prop) {

package/dist/cli/wp-files/sqlite-command/vendor/{mustache/mustache/src → wp-cli/mustache/src/Mustache}/Source.php

@@ -3,15 +3,16 @@
 /*
  * This file is part of Mustache.php.
  *
- * (c) 2010-2025 Justin Hileman
+ * (c) 2010-2017 Justin Hileman
  *
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
 
-namespace Mustache;
-
-interface Source
+/**
+ * Mustache template Source interface.
+ */
+interface Mustache_Source
 {
     /**
      * Get the Source key (used to generate the compiled class name).

package/dist/cli/wp-files/sqlite-command/vendor/{mustache/mustache/src → wp-cli/mustache/src/Mustache}/Template.php

@@ -3,23 +3,21 @@
 /*
  * This file is part of Mustache.php.
  *
- * (c) 2010-2025 Justin Hileman
+ * (c) 2010-2017 Justin Hileman
  *
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
 
-namespace Mustache;
-
 /**
  * Abstract Mustache Template class.
  *
  * @abstract
  */
-abstract class Template
+abstract class Mustache_Template
 {
     /**
-     * @var Engine
+     * @var Mustache_Engine
      */
     protected $mustache;
 
@@ -28,15 +26,12 @@ abstract class Template
      */
     protected $strictCallables = false;
 
-    /**
-     * @var bool
-     */
-    protected $lambdas = true;
-
     /**
      * Mustache Template constructor.
+     *
+     * @param Mustache_Engine $mustache
      */
-    public function __construct(Engine $mustache)
+    public function __construct(Mustache_Engine $mustache)
     {
         $this->mustache = $mustache;
     }
@@ -44,17 +39,17 @@ abstract class Template
     /**
      * Mustache Template instances can be treated as a function and rendered by simply calling them.
      *
-     *     $m = new \Mustache\Engine;
+     *     $m = new Mustache_Engine;
      *     $tpl = $m->loadTemplate('Hello, {{ name }}!');
-     *     echo $tpl(['name' => 'World']); // "Hello, World!"
+     *     echo $tpl(array('name' => 'World')); // "Hello, World!"
      *
-     * @see \Mustache\Template::render
+     * @see Mustache_Template::render
      *
-     * @param mixed $context Array or object rendering context (default: [])
+     * @param mixed $context Array or object rendering context (default: array())
      *
      * @return string Rendered template
      */
-    public function __invoke($context = [])
+    public function __invoke($context = array())
     {
         return $this->render($context);
     }
@@ -62,11 +57,11 @@ abstract class Template
     /**
      * Render this template given the rendering context.
      *
-     * @param mixed $context Array or object rendering context (default: [])
+     * @param mixed $context Array or object rendering context (default: array())
      *
      * @return string Rendered template
      */
-    public function render($context = [])
+    public function render($context = array())
     {
         return $this->renderInternal(
             $this->prepareContextStack($context)
@@ -80,11 +75,12 @@ abstract class Template
      *
      * NOTE: This method is not part of the Mustache.php public API.
      *
-     * @param string $indent (default: '')
+     * @param Mustache_Context $context
+     * @param string           $indent  (default: '')
      *
      * @return string Rendered template
      */
-    abstract public function renderInternal(Context $context, $indent = '');
+    abstract public function renderInternal(Mustache_Context $context, $indent = '');
 
     /**
      * Tests whether a value should be iterated over (e.g. in a section context).
@@ -97,19 +93,19 @@ abstract class Template
      * between between a list of things (numeric, normalized array) and a set of variables to be used as section context
      * (associative array). In other words, this will be iterated over:
      *
-     *     $items = [
-     *         ['name' => 'foo'],
-     *         ['name' => 'bar'],
-     *         ['name' => 'baz'],
-     *     ];
+     *     $items = array(
+     *         array('name' => 'foo'),
+     *         array('name' => 'bar'),
+     *         array('name' => 'baz'),
+     *     );
      *
      * ... but this will be used as a section context block:
      *
-     *     $items = [
-     *         1        => ['name' => 'foo'],
-     *         'banana' => ['name' => 'bar'],
-     *         42       => ['name' => 'baz'],
-     *     ];
+     *     $items = array(
+     *         1        => array('name' => 'foo'),
+     *         'banana' => array('name' => 'bar'),
+     *         42       => array('name' => 'baz'),
+     *     );
      *
      * @param mixed $value
      *
@@ -119,7 +115,7 @@ abstract class Template
     {
         switch (gettype($value)) {
             case 'object':
-                return $value instanceof \Traversable;
+                return $value instanceof Traversable;
 
             case 'array':
                 $i = 0;
@@ -143,11 +139,11 @@ abstract class Template
      *
      * @param mixed $context Optional first context frame (default: null)
      *
-     * @return Context
+     * @return Mustache_Context
      */
     protected function prepareContextStack($context = null)
     {
-        $stack = new Context(null, $this->mustache->getBuggyPropertyShadowing());
+        $stack = new Mustache_Context(null, $this->mustache->useBuggyPropertyShadowing());
 
         $helpers = $this->mustache->getHelpers();
         if (!$helpers->isEmpty()) {
@@ -166,16 +162,13 @@ abstract class Template
      *
      * Invoke the value if it is callable, otherwise return the value.
      *
-     * @param mixed $value
+     * @param mixed            $value
+     * @param Mustache_Context $context
      *
      * @return string
      */
-    protected function resolveValue($value, Context $context)
+    protected function resolveValue($value, Mustache_Context $context)
     {
-        if (!$this->lambdas) {
-            return $value;
-        }
-
         if (($this->strictCallables ? is_object($value) : !is_string($value)) && is_callable($value)) {
             $result = call_user_func($value);