wp-studio 1.8.1 → 1.8.2

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

@@ -3,12 +3,19 @@
 /*
  * 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\Logger;
+
+use Mustache\Exception\InvalidArgumentException;
+use Mustache\Exception\LogicException;
+use Mustache\Exception\RuntimeException;
+use Mustache\Logger;
+
 /**
  * A Mustache Stream Logger.
  *
@@ -18,9 +25,9 @@
  *
  * Hint: Try `php://stderr` for your stream URL.
  */
-class Mustache_Logger_StreamLogger extends Mustache_Logger_AbstractLogger
+class StreamLogger extends AbstractLogger
 {
-    protected static $levels = array(
+    protected static $levels = [
         self::DEBUG     => 100,
         self::INFO      => 200,
         self::NOTICE    => 250,
@@ -29,7 +36,7 @@ class Mustache_Logger_StreamLogger extends Mustache_Logger_AbstractLogger
         self::CRITICAL  => 500,
         self::ALERT     => 550,
         self::EMERGENCY => 600,
-    );
+    ];
 
     protected $level;
     protected $stream = null;
@@ -41,7 +48,7 @@ class Mustache_Logger_StreamLogger extends Mustache_Logger_AbstractLogger
      * @param resource|string $stream Resource instance or URL
      * @param int             $level  The minimum logging level at which this handler will be triggered
      */
-    public function __construct($stream, $level = Mustache_Logger::ERROR)
+    public function __construct($stream, $level = Logger::ERROR)
     {
         $this->setLevel($level);
 
@@ -65,14 +72,14 @@ class Mustache_Logger_StreamLogger extends Mustache_Logger_AbstractLogger
     /**
      * Set the minimum logging level.
      *
-     * @throws Mustache_Exception_InvalidArgumentException if the logging level is unknown
+     * @throws InvalidArgumentException if the logging level is unknown
      *
      * @param int $level The minimum logging level which will be written
      */
     public function setLevel($level)
     {
         if (!array_key_exists($level, self::$levels)) {
-            throw new Mustache_Exception_InvalidArgumentException(sprintf('Unexpected logging level: %s', $level));
+            throw new InvalidArgumentException(sprintf('Unexpected logging level: %s', $level));
         }
 
         $this->level = $level;
@@ -91,16 +98,15 @@ class Mustache_Logger_StreamLogger extends Mustache_Logger_AbstractLogger
     /**
      * Logs with an arbitrary level.
      *
-     * @throws Mustache_Exception_InvalidArgumentException if the logging level is unknown
+     * @throws InvalidArgumentException if the logging level is unknown
      *
      * @param mixed  $level
      * @param string $message
-     * @param array  $context
      */
-    public function log($level, $message, array $context = array())
+    public function log($level, $message, array $context = [])
     {
         if (!array_key_exists($level, self::$levels)) {
-            throw new Mustache_Exception_InvalidArgumentException(sprintf('Unexpected logging level: %s', $level));
+            throw new InvalidArgumentException(sprintf('Unexpected logging level: %s', $level));
         }
 
         if (self::$levels[$level] >= self::$levels[$this->level]) {
@@ -111,24 +117,24 @@ class Mustache_Logger_StreamLogger extends Mustache_Logger_AbstractLogger
     /**
      * Write a record to the log.
      *
-     * @throws Mustache_Exception_LogicException   If neither a stream resource nor url is present
-     * @throws Mustache_Exception_RuntimeException If the stream url cannot be opened
+     * @throws LogicException   If neither a stream resource nor url is present
+     * @throws RuntimeException If the stream url cannot be opened
      *
      * @param int    $level   The logging level
      * @param string $message The log message
      * @param array  $context The log context
      */
-    protected function writeLog($level, $message, array $context = array())
+    protected function writeLog($level, $message, array $context = [])
     {
         if (!is_resource($this->stream)) {
             if (!isset($this->url)) {
-                throw new Mustache_Exception_LogicException('Missing stream url, the stream can not be opened. This may be caused by a premature call to close().');
+                throw new LogicException('Missing stream url, the stream can not be opened. This may be caused by a premature call to close().');
             }
 
             $this->stream = fopen($this->url, 'a');
             if (!is_resource($this->stream)) {
                 // @codeCoverageIgnoreStart
-                throw new Mustache_Exception_RuntimeException(sprintf('The stream or file "%s" could not be opened.', $this->url));
+                throw new RuntimeException(sprintf('The stream or file "%s" could not be opened.', $this->url));
                 // @codeCoverageIgnoreEnd
             }
         }
@@ -159,7 +165,7 @@ class Mustache_Logger_StreamLogger extends Mustache_Logger_AbstractLogger
      *
      * @return string
      */
-    protected static function formatLine($level, $message, array $context = array())
+    protected static function formatLine($level, $message, array $context = [])
     {
         return sprintf(
             "%s: %s\n",
@@ -172,18 +178,17 @@ class Mustache_Logger_StreamLogger extends Mustache_Logger_AbstractLogger
      * Interpolate context values into the message placeholders.
      *
      * @param string $message
-     * @param array  $context
      *
      * @return string
      */
-    protected static function interpolateMessage($message, array $context = array())
+    protected static function interpolateMessage($message, array $context = [])
     {
         if (strpos($message, '{') === false) {
             return $message;
         }
 
         // build a replacement array with braces around the context keys
-        $replace = array();
+        $replace = [];
         foreach ($context as $key => $val) {
             $replace['{' . $key . '}'] = $val;
         }

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

@@ -3,30 +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.
  */
 
-/**
- * Describes a Mustache logger instance.
- *
- * This is identical to the Psr\Log\LoggerInterface.
- *
- * The message MUST be a string or object implementing __toString().
- *
- * The message MAY contain placeholders in the form: {foo} where foo
- * will be replaced by the context data in key "foo".
- *
- * The context array can contain arbitrary data, the only assumption that
- * can be made by implementors is that if an Exception instance is given
- * to produce a stack trace, it MUST be in a key named "exception".
- *
- * See https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-3-logger-interface.md
- * for the full interface specification.
- */
-interface Mustache_Logger
+namespace Mustache;
+
+interface Logger
 {
     /**
      * Psr\Log compatible log levels.
@@ -44,9 +29,8 @@ interface Mustache_Logger
      * System is unusable.
      *
      * @param string $message
-     * @param array  $context
      */
-    public function emergency($message, array $context = array());
+    public function emergency($message, array $context = []);
 
     /**
      * Action must be taken immediately.
@@ -55,9 +39,8 @@ interface Mustache_Logger
      * trigger the SMS alerts and wake you up.
      *
      * @param string $message
-     * @param array  $context
      */
-    public function alert($message, array $context = array());
+    public function alert($message, array $context = []);
 
     /**
      * Critical conditions.
@@ -65,18 +48,16 @@ interface Mustache_Logger
      * Example: Application component unavailable, unexpected exception.
      *
      * @param string $message
-     * @param array  $context
      */
-    public function critical($message, array $context = array());
+    public function critical($message, array $context = []);
 
     /**
      * Runtime errors that do not require immediate action but should typically
      * be logged and monitored.
      *
      * @param string $message
-     * @param array  $context
      */
-    public function error($message, array $context = array());
+    public function error($message, array $context = []);
 
     /**
      * Exceptional occurrences that are not errors.
@@ -85,17 +66,15 @@ interface Mustache_Logger
      * that are not necessarily wrong.
      *
      * @param string $message
-     * @param array  $context
      */
-    public function warning($message, array $context = array());
+    public function warning($message, array $context = []);
 
     /**
      * Normal but significant events.
      *
      * @param string $message
-     * @param array  $context
      */
-    public function notice($message, array $context = array());
+    public function notice($message, array $context = []);
 
     /**
      * Interesting events.
@@ -103,24 +82,21 @@ interface Mustache_Logger
      * Example: User logs in, SQL logs.
      *
      * @param string $message
-     * @param array  $context
      */
-    public function info($message, array $context = array());
+    public function info($message, array $context = []);
 
     /**
      * Detailed debug information.
      *
      * @param string $message
-     * @param array  $context
      */
-    public function debug($message, array $context = array());
+    public function debug($message, array $context = []);
 
     /**
      * Logs with an arbitrary level.
      *
      * @param mixed  $level
      * @param string $message
-     * @param array  $context
      */
-    public function log($level, $message, array $context = array());
+    public function log($level, $message, array $context = []);
 }

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

@@ -3,26 +3,33 @@
 /*
  * 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\SyntaxException;
+
 /**
  * Mustache Parser class.
  *
  * This class is responsible for turning a set of Mustache tokens into a parse tree.
  */
-class Mustache_Parser
+class Parser
 {
     private $lineNum;
     private $lineTokens;
     private $pragmas;
-    private $defaultPragmas = array();
+    private $defaultPragmas = [];
+
+    // Optional Mustache specs
+    private $dynamicNames = true;
+    private $inheritance = true;
 
     private $pragmaFilters;
-    private $pragmaBlocks;
 
     /**
      * Process an array of Mustache tokens and convert them into a parse tree.
@@ -31,29 +38,46 @@ class Mustache_Parser
      *
      * @return array Mustache token parse tree
      */
-    public function parse(array $tokens = array())
+    public function parse(array $tokens = [])
     {
         $this->lineNum    = -1;
         $this->lineTokens = 0;
         $this->pragmas    = $this->defaultPragmas;
 
-        $this->pragmaFilters = isset($this->pragmas[Mustache_Engine::PRAGMA_FILTERS]);
-        $this->pragmaBlocks  = isset($this->pragmas[Mustache_Engine::PRAGMA_BLOCKS]);
+        $this->pragmaFilters = isset($this->pragmas[Engine::PRAGMA_FILTERS]);
 
         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 = array();
+        $this->pragmas = [];
         foreach ($pragmas as $pragma) {
             $this->enablePragma($pragma);
         }
@@ -63,111 +87,126 @@ class Mustache_Parser
     /**
      * Helper method for recursively building a parse tree.
      *
-     * @throws Mustache_Exception_SyntaxException when nesting errors or mismatched section tags are encountered
+     * @throws SyntaxException when nesting errors or mismatched section tags are encountered
      *
      * @param array &$tokens Set of Mustache tokens
      * @param array $parent  Parent token (default: null)
      *
      * @return array Mustache Token parse tree
      */
-    private function buildTree(array &$tokens, array $parent = null)
+    private function buildTree(array &$tokens, $parent = null)
     {
-        $nodes = array();
+        $nodes = [];
 
         while (!empty($tokens)) {
             $token = array_shift($tokens);
 
-            if ($token[Mustache_Tokenizer::LINE] === $this->lineNum) {
+            if ($token[Tokenizer::LINE] === $this->lineNum) {
                 $this->lineTokens++;
             } else {
-                $this->lineNum    = $token[Mustache_Tokenizer::LINE];
+                $this->lineNum    = $token[Tokenizer::LINE];
                 $this->lineTokens = 0;
             }
 
-            if ($this->pragmaFilters && isset($token[Mustache_Tokenizer::NAME])) {
-                list($name, $filters) = $this->getNameAndFilters($token[Mustache_Tokenizer::NAME]);
-                if (!empty($filters)) {
-                    $token[Mustache_Tokenizer::NAME]    = $name;
-                    $token[Mustache_Tokenizer::FILTERS] = $filters;
+            if ($token[Tokenizer::TYPE] !== Tokenizer::T_COMMENT) {
+                if (isset($token[Tokenizer::NAME])) {
+                    list($name, $isDynamic) = $this->getDynamicName($token);
+                    if ($isDynamic) {
+                        $token[Tokenizer::NAME]    = $name;
+                        $token[Tokenizer::DYNAMIC] = true;
+                    }
+                }
+
+                if ($this->pragmaFilters && isset($token[Tokenizer::NAME])) {
+                    list($name, $filters) = $this->getNameAndFilters($token[Tokenizer::NAME]);
+                    if (!empty($filters)) {
+                        $token[Tokenizer::NAME]    = $name;
+                        $token[Tokenizer::FILTERS] = $filters;
+                    }
                 }
             }
 
-            switch ($token[Mustache_Tokenizer::TYPE]) {
-                case Mustache_Tokenizer::T_DELIM_CHANGE:
+            switch ($token[Tokenizer::TYPE]) {
+                case Tokenizer::T_DELIM_CHANGE:
                     $this->checkIfTokenIsAllowedInParent($parent, $token);
                     $this->clearStandaloneLines($nodes, $tokens);
                     break;
 
-                case Mustache_Tokenizer::T_SECTION:
-                case Mustache_Tokenizer::T_INVERTED:
+                case Tokenizer::T_SECTION:
+                case Tokenizer::T_INVERTED:
                     $this->checkIfTokenIsAllowedInParent($parent, $token);
                     $this->clearStandaloneLines($nodes, $tokens);
                     $nodes[] = $this->buildTree($tokens, $token);
                     break;
 
-                case Mustache_Tokenizer::T_END_SECTION:
+                case Tokenizer::T_END_SECTION:
                     if (!isset($parent)) {
                         $msg = sprintf(
                             'Unexpected closing tag: /%s on line %d',
-                            $token[Mustache_Tokenizer::NAME],
-                            $token[Mustache_Tokenizer::LINE]
+                            $token[Tokenizer::NAME],
+                            $token[Tokenizer::LINE]
                         );
-                        throw new Mustache_Exception_SyntaxException($msg, $token);
+                        throw new SyntaxException($msg, $token);
                     }
 
-                    if ($token[Mustache_Tokenizer::NAME] !== $parent[Mustache_Tokenizer::NAME]) {
+                    $sameName = $token[Tokenizer::NAME] !== $parent[Tokenizer::NAME];
+                    $tokenDynamic = isset($token[Tokenizer::DYNAMIC]) && $token[Tokenizer::DYNAMIC];
+                    $parentDynamic = isset($parent[Tokenizer::DYNAMIC]) && $parent[Tokenizer::DYNAMIC];
+
+                    if ($sameName || ($tokenDynamic !== $parentDynamic)) {
                         $msg = sprintf(
-                            'Nesting error: %s (on line %d) vs. %s (on line %d)',
-                            $parent[Mustache_Tokenizer::NAME],
-                            $parent[Mustache_Tokenizer::LINE],
-                            $token[Mustache_Tokenizer::NAME],
-                            $token[Mustache_Tokenizer::LINE]
+                            'Nesting error: %s%s (on line %d) vs. %s%s (on line %d)',
+                            $parentDynamic ? '*' : '',
+                            $parent[Tokenizer::NAME],
+                            $parent[Tokenizer::LINE],
+                            $tokenDynamic ? '*' : '',
+                            $token[Tokenizer::NAME],
+                            $token[Tokenizer::LINE]
                         );
-                        throw new Mustache_Exception_SyntaxException($msg, $token);
+                        throw new SyntaxException($msg, $token);
                     }
 
                     $this->clearStandaloneLines($nodes, $tokens);
-                    $parent[Mustache_Tokenizer::END]   = $token[Mustache_Tokenizer::INDEX];
-                    $parent[Mustache_Tokenizer::NODES] = $nodes;
+                    $parent[Tokenizer::END]   = $token[Tokenizer::INDEX];
+                    $parent[Tokenizer::NODES] = $nodes;
 
                     return $parent;
 
-                case Mustache_Tokenizer::T_PARTIAL:
+                case Tokenizer::T_PARTIAL:
                     $this->checkIfTokenIsAllowedInParent($parent, $token);
                     //store the whitespace prefix for laters!
                     if ($indent = $this->clearStandaloneLines($nodes, $tokens)) {
-                        $token[Mustache_Tokenizer::INDENT] = $indent[Mustache_Tokenizer::VALUE];
+                        $token[Tokenizer::INDENT] = $indent[Tokenizer::VALUE];
                     }
                     $nodes[] = $token;
                     break;
 
-                case Mustache_Tokenizer::T_PARENT:
+                case Tokenizer::T_PARENT:
                     $this->checkIfTokenIsAllowedInParent($parent, $token);
                     $nodes[] = $this->buildTree($tokens, $token);
                     break;
 
-                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;
+                case Tokenizer::T_BLOCK_VAR:
+                    if ($this->inheritance) {
+                        if (isset($parent) && $parent[Tokenizer::TYPE] === Tokenizer::T_PARENT) {
+                            $token[Tokenizer::TYPE] = Tokenizer::T_BLOCK_ARG;
                         }
                         $this->clearStandaloneLines($nodes, $tokens);
                         $nodes[] = $this->buildTree($tokens, $token);
                     } else {
                         // pretend this was just a normal "escaped" token...
-                        $token[Mustache_Tokenizer::TYPE] = Mustache_Tokenizer::T_ESCAPED;
+                        $token[Tokenizer::TYPE] = Tokenizer::T_ESCAPED;
                         // TODO: figure out how to figure out if there was a space after this dollar:
-                        $token[Mustache_Tokenizer::NAME] = '$' . $token[Mustache_Tokenizer::NAME];
+                        $token[Tokenizer::NAME] = '$' . $token[Tokenizer::NAME];
                         $nodes[] = $token;
                     }
                     break;
 
-                case Mustache_Tokenizer::T_PRAGMA:
-                    $this->enablePragma($token[Mustache_Tokenizer::NAME]);
+                case Tokenizer::T_PRAGMA:
+                    $this->enablePragma($token[Tokenizer::NAME]);
                     // no break
 
-                case Mustache_Tokenizer::T_COMMENT:
+                case Tokenizer::T_COMMENT:
                     $this->clearStandaloneLines($nodes, $tokens);
                     $nodes[] = $token;
                     break;
@@ -181,10 +220,10 @@ class Mustache_Parser
         if (isset($parent)) {
             $msg = sprintf(
                 'Missing closing tag: %s opened on line %d',
-                $parent[Mustache_Tokenizer::NAME],
-                $parent[Mustache_Tokenizer::LINE]
+                $parent[Tokenizer::NAME],
+                $parent[Tokenizer::LINE]
             );
-            throw new Mustache_Exception_SyntaxException($msg, $parent);
+            throw new SyntaxException($msg, $parent);
         }
 
         return $nodes;
@@ -220,7 +259,7 @@ class Mustache_Parser
 
         if ($next = reset($tokens)) {
             // If we're on a new line, bail.
-            if ($next[Mustache_Tokenizer::LINE] !== $this->lineNum) {
+            if ($next[Tokenizer::LINE] !== $this->lineNum) {
                 return;
             }
 
@@ -232,7 +271,7 @@ class Mustache_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[Mustache_Tokenizer::VALUE], -1) !== "\n") {
+                if (substr($next[Tokenizer::VALUE], -1) !== "\n") {
                     return;
                 }
             }
@@ -252,14 +291,12 @@ class Mustache_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[Mustache_Tokenizer::TYPE] === Mustache_Tokenizer::T_TEXT) {
-            return preg_match('/^\s*$/', $token[Mustache_Tokenizer::VALUE]);
+        if ($token[Tokenizer::TYPE] === Tokenizer::T_TEXT) {
+            return preg_match('/^\s*$/', $token[Tokenizer::VALUE]);
         }
 
         return false;
@@ -268,16 +305,58 @@ class Mustache_Parser
     /**
      * Check whether a token is allowed inside a parent tag.
      *
-     * @throws Mustache_Exception_SyntaxException if an invalid token is found inside a parent tag
+     * @throws 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[Mustache_Tokenizer::TYPE] === Mustache_Tokenizer::T_PARENT) {
-            throw new Mustache_Exception_SyntaxException('Illegal content in < parent tag', $token);
+        if (isset($parent) && $parent[Tokenizer::TYPE] === Tokenizer::T_PARENT) {
+            throw new 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 *
+     */
+    private function getDynamicName(array $token)
+    {
+        $name = $token[Tokenizer::NAME];
+        $isDynamic = false;
+
+        if ($this->dynamicNames && preg_match('/^\s*\*\s*/', $name)) {
+            $this->ensureTagAllowsDynamicNames($token);
+            $name = preg_replace('/^\s*\*\s*/', '', $name);
+            $isDynamic = true;
+        }
+
+        return [$name, $isDynamic];
+    }
+
+    /**
+     * Check whether the given token supports dynamic tag names.
+     *
+     * @throws SyntaxException when a tag does not allow *
+     */
+    private function ensureTagAllowsDynamicNames(array $token)
+    {
+        switch ($token[Tokenizer::TYPE]) {
+            case Tokenizer::T_PARTIAL:
+            case Tokenizer::T_PARENT:
+            case Tokenizer::T_END_SECTION:
+                return;
         }
+
+        $msg = sprintf(
+            'Invalid dynamic name: %s in %s tag',
+            $token[Tokenizer::NAME],
+            Tokenizer::getTagName($token[Tokenizer::TYPE])
+        );
+
+        throw new SyntaxException($msg, $token);
     }
 
     /**
@@ -292,7 +371,7 @@ class Mustache_Parser
         $filters = array_map('trim', explode('|', $name));
         $name    = array_shift($filters);
 
-        return array($name, $filters);
+        return [$name, $filters];
     }
 
     /**
@@ -305,11 +384,7 @@ class Mustache_Parser
         $this->pragmas[$name] = true;
 
         switch ($name) {
-            case Mustache_Engine::PRAGMA_BLOCKS:
-                $this->pragmaBlocks = true;
-                break;
-
-            case Mustache_Engine::PRAGMA_FILTERS:
+            case Engine::PRAGMA_FILTERS:
                 $this->pragmaFilters = true;
                 break;
         }