wp-studio 1.8.1 → 1.8.2

package/dist/cli/wp-files/sqlite-command/vendor/mustache/mustache/src/RenderedString.php

@@ -0,0 +1,51 @@
+<?php
+
+/*
+ * This file is part of Mustache.php.
+ *
+ * (c) 2010-2025 Justin Hileman
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Mustache;
+
+/**
+ * A class representing a rendered string in Mustache.
+ *
+ * This is primarily used to prevent re-rendering of strings that have already
+ * been processed in higher-order sections.
+ *
+ * @see LambdaHelper::render()
+ * @see LambdaHelper::preventRender()
+ */
+class RenderedString
+{
+    private $value;
+
+    /**
+     * RenderedString constructor.
+     *
+     * @param string $value The rendered string value
+     */
+    public function __construct($value)
+    {
+        $this->value = (string) $value;
+    }
+
+    public function __toString()
+    {
+        return $this->value;
+    }
+
+    /**
+     * Get the rendered string value.
+     *
+     * @return string The rendered string value
+     */
+    public function getValue()
+    {
+        return $this->value;
+    }
+}

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

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

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

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

@@ -3,21 +3,23 @@
 /*
  * This file is part of Mustache.php.
  *
- * (c) 2010-2017 Justin Hileman
+ * (c) 2010-2025 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 Mustache_Template
+abstract class Template
 {
     /**
-     * @var Mustache_Engine
+     * @var Engine
      */
     protected $mustache;
 
@@ -26,12 +28,15 @@ abstract class Mustache_Template
      */
     protected $strictCallables = false;
 
+    /**
+     * @var bool
+     */
+    protected $lambdas = true;
+
     /**
      * Mustache Template constructor.
-     *
-     * @param Mustache_Engine $mustache
      */
-    public function __construct(Mustache_Engine $mustache)
+    public function __construct(Engine $mustache)
     {
         $this->mustache = $mustache;
     }
@@ -39,17 +44,17 @@ abstract class Mustache_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(array('name' => 'World')); // "Hello, World!"
+     *     echo $tpl(['name' => 'World']); // "Hello, World!"
      *
-     * @see Mustache_Template::render
+     * @see \Mustache\Template::render
      *
-     * @param mixed $context Array or object rendering context (default: array())
+     * @param mixed $context Array or object rendering context (default: [])
      *
      * @return string Rendered template
      */
-    public function __invoke($context = array())
+    public function __invoke($context = [])
     {
         return $this->render($context);
     }
@@ -57,11 +62,11 @@ abstract class Mustache_Template
     /**
      * Render this template given the rendering context.
      *
-     * @param mixed $context Array or object rendering context (default: array())
+     * @param mixed $context Array or object rendering context (default: [])
      *
      * @return string Rendered template
      */
-    public function render($context = array())
+    public function render($context = [])
     {
         return $this->renderInternal(
             $this->prepareContextStack($context)
@@ -75,12 +80,11 @@ abstract class Mustache_Template
      *
      * NOTE: This method is not part of the Mustache.php public API.
      *
-     * @param Mustache_Context $context
-     * @param string           $indent  (default: '')
+     * @param string $indent (default: '')
      *
      * @return string Rendered template
      */
-    abstract public function renderInternal(Mustache_Context $context, $indent = '');
+    abstract public function renderInternal(Context $context, $indent = '');
 
     /**
      * Tests whether a value should be iterated over (e.g. in a section context).
@@ -93,19 +97,19 @@ abstract class Mustache_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 = array(
-     *         array('name' => 'foo'),
-     *         array('name' => 'bar'),
-     *         array('name' => 'baz'),
-     *     );
+     *     $items = [
+     *         ['name' => 'foo'],
+     *         ['name' => 'bar'],
+     *         ['name' => 'baz'],
+     *     ];
      *
      * ... but this will be used as a section context block:
      *
-     *     $items = array(
-     *         1        => array('name' => 'foo'),
-     *         'banana' => array('name' => 'bar'),
-     *         42       => array('name' => 'baz'),
-     *     );
+     *     $items = [
+     *         1        => ['name' => 'foo'],
+     *         'banana' => ['name' => 'bar'],
+     *         42       => ['name' => 'baz'],
+     *     ];
      *
      * @param mixed $value
      *
@@ -115,7 +119,7 @@ abstract class Mustache_Template
     {
         switch (gettype($value)) {
             case 'object':
-                return $value instanceof Traversable;
+                return $value instanceof \Traversable;
 
             case 'array':
                 $i = 0;
@@ -139,11 +143,11 @@ abstract class Mustache_Template
      *
      * @param mixed $context Optional first context frame (default: null)
      *
-     * @return Mustache_Context
+     * @return Context
      */
     protected function prepareContextStack($context = null)
     {
-        $stack = new Mustache_Context();
+        $stack = new Context(null, $this->mustache->getBuggyPropertyShadowing());
 
         $helpers = $this->mustache->getHelpers();
         if (!$helpers->isEmpty()) {
@@ -162,17 +166,26 @@ abstract class Mustache_Template
      *
      * Invoke the value if it is callable, otherwise return the value.
      *
-     * @param mixed            $value
-     * @param Mustache_Context $context
+     * @param mixed $value
      *
      * @return string
      */
-    protected function resolveValue($value, Mustache_Context $context)
+    protected function resolveValue($value, Context $context)
     {
+        if (!$this->lambdas) {
+            return $value;
+        }
+
         if (($this->strictCallables ? is_object($value) : !is_string($value)) && is_callable($value)) {
-            return $this->mustache
-                ->loadLambda((string) call_user_func($value))
-                ->renderInternal($context);
+            $result = call_user_func($value);
+
+            if (is_string($result)) {
+                return $this->mustache
+                    ->loadLambda($result)
+                    ->renderInternal($context);
+            }
+
+            return $result;
         }
 
         return $value;

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

@@ -3,18 +3,23 @@
 /*
  * This file is part of Mustache.php.
  *
- * (c) 2010-2017 Justin Hileman
+ * (c) 2010-2025 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\InvalidArgumentException;
+use Mustache\Exception\SyntaxException;
+
 /**
  * Mustache Tokenizer class.
  *
  * This class is responsible for turning raw template source into a set of Mustache tokens.
  */
-class Mustache_Tokenizer
+class Tokenizer
 {
     // Finite state machine states
     const IN_TEXT     = 0;
@@ -38,7 +43,7 @@ class Mustache_Tokenizer
     const T_BLOCK_ARG    = '$arg';
 
     // Valid token types
-    private static $tagTypes = array(
+    private static $tagTypes = [
         self::T_SECTION      => true,
         self::T_INVERTED     => true,
         self::T_END_SECTION  => true,
@@ -51,11 +56,28 @@ class Mustache_Tokenizer
         self::T_UNESCAPED_2  => true,
         self::T_PRAGMA       => true,
         self::T_BLOCK_VAR    => true,
-    );
+    ];
+
+    private static $tagNames = [
+        self::T_SECTION      => 'section',
+        self::T_INVERTED     => 'inverted section',
+        self::T_END_SECTION  => 'section end',
+        self::T_COMMENT      => 'comment',
+        self::T_PARTIAL      => 'partial',
+        self::T_PARENT       => 'parent',
+        self::T_DELIM_CHANGE => 'set delimiter',
+        self::T_ESCAPED      => 'variable',
+        self::T_UNESCAPED    => 'unescaped variable',
+        self::T_UNESCAPED_2  => 'unescaped variable',
+        self::T_PRAGMA       => 'pragma',
+        self::T_BLOCK_VAR    => 'block variable',
+        self::T_BLOCK_ARG    => 'block variable',
+    ];
 
     // Token properties
     const TYPE    = 'type';
     const NAME    = 'name';
+    const DYNAMIC = 'dynamic';
     const OTAG    = 'otag';
     const CTAG    = 'ctag';
     const LINE    = 'line';
@@ -84,8 +106,8 @@ class Mustache_Tokenizer
     /**
      * Scan and tokenize template source.
      *
-     * @throws Mustache_Exception_SyntaxException when mismatched section tags are encountered
-     * @throws Mustache_Exception_InvalidArgumentException when $delimiters string is invalid
+     * @throws SyntaxException          when mismatched section tags are encountered
+     * @throws InvalidArgumentException when $delimiters string is invalid
      *
      * @param string $text       Mustache template source to tokenize
      * @param string $delimiters Optionally, pass initial opening and closing delimiters (default: empty string)
@@ -112,7 +134,7 @@ class Mustache_Tokenizer
 
         $this->reset();
 
-        if (is_string($delimiters) && $delimiters = trim($delimiters)) {
+        if (is_string($delimiters) && ($delimiters = trim($delimiters)) !== '') {
             $this->setDelimiters($delimiters);
         }
 
@@ -165,14 +187,14 @@ class Mustache_Tokenizer
                     $char = $text[$i];
                     // Test whether it's time to change tags.
                     if ($char === $this->ctagChar && substr($text, $i, $this->ctagLen) === $this->ctag) {
-                        $token = array(
+                        $token = [
                             self::TYPE  => $this->tagType,
                             self::NAME  => trim($this->buffer),
                             self::OTAG  => $this->otag,
                             self::CTAG  => $this->ctag,
                             self::LINE  => $this->line,
                             self::INDEX => ($this->tagType === self::T_END_SECTION) ? $this->seenTag - $this->otagLen : $i + $this->ctagLen,
-                        );
+                        ];
 
                         if ($this->tagType === self::T_UNESCAPED) {
                             // Clean up `{{{ tripleStache }}}` style tokens.
@@ -186,7 +208,7 @@ class Mustache_Tokenizer
                                         $token[self::LINE]
                                     );
 
-                                    throw new Mustache_Exception_SyntaxException($msg, $token);
+                                    throw new SyntaxException($msg, $token);
                                 }
                             } else {
                                 $lastName = $token[self::NAME];
@@ -199,7 +221,7 @@ class Mustache_Tokenizer
                                         $token[self::LINE]
                                     );
 
-                                    throw new Mustache_Exception_SyntaxException($msg, $token);
+                                    throw new SyntaxException($msg, $token);
                                 }
                             }
                         }
@@ -239,7 +261,7 @@ class Mustache_Tokenizer
         $this->state    = self::IN_TEXT;
         $this->tagType  = null;
         $this->buffer   = '';
-        $this->tokens   = array();
+        $this->tokens   = [];
         $this->seenTag  = false;
         $this->line     = 0;
 
@@ -258,11 +280,11 @@ class Mustache_Tokenizer
     private function flushBuffer()
     {
         if (strlen($this->buffer) > 0) {
-            $this->tokens[] = array(
+            $this->tokens[] = [
                 self::TYPE  => self::T_TEXT,
                 self::LINE  => $this->line,
                 self::VALUE => $this->buffer,
-            );
+            ];
             $this->buffer   = '';
         }
     }
@@ -270,7 +292,7 @@ class Mustache_Tokenizer
     /**
      * Change the current Mustache delimiters. Set new `otag` and `ctag` values.
      *
-     * @throws Mustache_Exception_SyntaxException when delimiter string is invalid
+     * @throws SyntaxException when delimiter string is invalid
      *
      * @param string $text  Mustache template source
      * @param int    $index Current tokenizer index
@@ -287,15 +309,15 @@ class Mustache_Tokenizer
             $this->throwUnclosedTagException();
         }
 
-        $token = array(
+        $token = [
             self::TYPE => self::T_DELIM_CHANGE,
             self::LINE => $this->line,
-        );
+        ];
 
         try {
             $this->setDelimiters(trim(substr($text, $startIndex, $closeIndex - $startIndex)));
-        } catch (Mustache_Exception_InvalidArgumentException $e) {
-            throw new Mustache_Exception_SyntaxException($e->getMessage(), $token);
+        } catch (InvalidArgumentException $e) {
+            throw new SyntaxException($e->getMessage(), $token);
         }
 
         $this->tokens[] = $token;
@@ -306,14 +328,14 @@ class Mustache_Tokenizer
     /**
      * Set the current Mustache `otag` and `ctag` delimiters.
      *
-     * @throws Mustache_Exception_InvalidArgumentException when delimiter string is invalid
+     * @throws InvalidArgumentException when delimiter string is invalid
      *
      * @param string $delimiters
      */
     private function setDelimiters($delimiters)
     {
         if (!preg_match('/^\s*(\S+)\s+(\S+)\s*$/', $delimiters, $matches)) {
-            throw new Mustache_Exception_InvalidArgumentException(sprintf('Invalid delimiters: %s', $delimiters));
+            throw new InvalidArgumentException(sprintf('Invalid delimiters: %s', $delimiters));
         }
 
         list($_, $otag, $ctag) = $matches;
@@ -348,11 +370,11 @@ class Mustache_Tokenizer
         $pragma = trim(substr($text, $index + 2, $end - $index - 2));
 
         // Pragmas are hoisted to the front of the template.
-        array_unshift($this->tokens, array(
+        array_unshift($this->tokens, [
             self::TYPE => self::T_PRAGMA,
             self::NAME => $pragma,
             self::LINE => 0,
-        ));
+        ]);
 
         return $end + $this->ctagLen - 1;
     }
@@ -366,13 +388,25 @@ class Mustache_Tokenizer
             $msg = sprintf('Unclosed tag on line %d', $this->line);
         }
 
-        throw new Mustache_Exception_SyntaxException($msg, array(
+        throw new SyntaxException($msg, [
             self::TYPE  => $this->tagType,
             self::NAME  => $name,
             self::OTAG  => $this->otag,
             self::CTAG  => $this->ctag,
             self::LINE  => $this->line,
             self::INDEX => $this->seenTag - $this->otagLen,
-        ));
+        ]);
+    }
+
+    /**
+     * Get the human readable name for a tag type.
+     *
+     * @param string $tagType One of the tokenizer T_* constants
+     *
+     * @return string
+     */
+    public static function getTagName($tagType)
+    {
+        return isset(self::$tagNames[$tagType]) ? self::$tagNames[$tagType] : 'unknown';
     }
 }