gulp-phug 1.3.3 → 1.3.5

package/support/vendor/symfony/var-dumper/Cloner/Data.php

@@ -17,15 +17,15 @@ use Symfony\Component\VarDumper\Dumper\ContextProvider\SourceContextProvider;
 /**
  * @author Nicolas Grekas <p@tchwork.com>
  */
-class Data implements \ArrayAccess, \Countable, \IteratorAggregate
+class Data implements \ArrayAccess, \Countable, \IteratorAggregate, \Stringable
 {
-    private $data;
-    private $position = 0;
-    private $key = 0;
-    private $maxDepth = 20;
-    private $maxItemsPerDepth = -1;
-    private $useRefHandles = -1;
-    private $context = [];
+    private array $data;
+    private int $position = 0;
+    private int|string $key = 0;
+    private int $maxDepth = 20;
+    private int $maxItemsPerDepth = -1;
+    private int $useRefHandles = -1;
+    private array $context = [];
 
     /**
      * @param array $data An array as returned by ClonerInterface::cloneVar()
@@ -35,10 +35,7 @@ class Data implements \ArrayAccess, \Countable, \IteratorAggregate
         $this->data = $data;
     }
 
-    /**
-     * @return string|null The type of the value
-     */
-    public function getType()
+    public function getType(): ?string
     {
         $item = $this->data[$this->position][$this->key];
 
@@ -65,11 +62,13 @@ class Data implements \ArrayAccess, \Countable, \IteratorAggregate
     }
 
     /**
+     * Returns a native representation of the original value.
+     *
      * @param array|bool $recursive Whether values should be resolved recursively or not
      *
-     * @return string|int|float|bool|array|Data[]|null A native representation of the original value
+     * @return string|int|float|bool|array|Data[]|null
      */
-    public function getValue($recursive = false)
+    public function getValue(array|bool $recursive = false): string|int|float|bool|array|null
     {
         $item = $this->data[$this->position][$this->key];
 
@@ -108,27 +107,21 @@ class Data implements \ArrayAccess, \Countable, \IteratorAggregate
         return $children;
     }
 
-    /**
-     * @return int
-     */
-    public function count()
+    public function count(): int
     {
         return \count($this->getValue());
     }
 
-    /**
-     * @return \Traversable
-     */
-    public function getIterator()
+    public function getIterator(): \Traversable
     {
         if (!\is_array($value = $this->getValue())) {
-            throw new \LogicException(sprintf('"%s" object holds non-iterable type "%s".', self::class, \gettype($value)));
+            throw new \LogicException(\sprintf('"%s" object holds non-iterable type "%s".', self::class, get_debug_type($value)));
         }
 
         yield from $value;
     }
 
-    public function __get($key)
+    public function __get(string $key): mixed
     {
         if (null !== $data = $this->seek($key)) {
             $item = $this->getStub($data->data[$data->position][$data->key]);
@@ -139,41 +132,32 @@ class Data implements \ArrayAccess, \Countable, \IteratorAggregate
         return null;
     }
 
-    /**
-     * @return bool
-     */
-    public function __isset($key)
+    public function __isset(string $key): bool
     {
         return null !== $this->seek($key);
     }
 
-    /**
-     * @return bool
-     */
-    public function offsetExists($key)
+    public function offsetExists(mixed $key): bool
     {
         return $this->__isset($key);
     }
 
-    public function offsetGet($key)
+    public function offsetGet(mixed $key): mixed
     {
         return $this->__get($key);
     }
 
-    public function offsetSet($key, $value)
+    public function offsetSet(mixed $key, mixed $value): void
     {
         throw new \BadMethodCallException(self::class.' objects are immutable.');
     }
 
-    public function offsetUnset($key)
+    public function offsetUnset(mixed $key): void
     {
         throw new \BadMethodCallException(self::class.' objects are immutable.');
     }
 
-    /**
-     * @return string
-     */
-    public function __toString()
+    public function __toString(): string
     {
         $value = $this->getValue();
 
@@ -181,35 +165,27 @@ class Data implements \ArrayAccess, \Countable, \IteratorAggregate
             return (string) $value;
         }
 
-        return sprintf('%s (count=%d)', $this->getType(), \count($value));
+        return \sprintf('%s (count=%d)', $this->getType(), \count($value));
     }
 
     /**
      * Returns a depth limited clone of $this.
-     *
-     * @param int $maxDepth The max dumped depth level
-     *
-     * @return static
      */
-    public function withMaxDepth($maxDepth)
+    public function withMaxDepth(int $maxDepth): static
     {
         $data = clone $this;
-        $data->maxDepth = (int) $maxDepth;
+        $data->maxDepth = $maxDepth;
 
         return $data;
     }
 
     /**
      * Limits the number of elements per depth level.
-     *
-     * @param int $maxItemsPerDepth The max number of items dumped per depth level
-     *
-     * @return static
      */
-    public function withMaxItemsPerDepth($maxItemsPerDepth)
+    public function withMaxItemsPerDepth(int $maxItemsPerDepth): static
     {
         $data = clone $this;
-        $data->maxItemsPerDepth = (int) $maxItemsPerDepth;
+        $data->maxItemsPerDepth = $maxItemsPerDepth;
 
         return $data;
     }
@@ -218,10 +194,8 @@ class Data implements \ArrayAccess, \Countable, \IteratorAggregate
      * Enables/disables objects' identifiers tracking.
      *
      * @param bool $useRefHandles False to hide global ref. handles
-     *
-     * @return static
      */
-    public function withRefHandles($useRefHandles)
+    public function withRefHandles(bool $useRefHandles): static
     {
         $data = clone $this;
         $data->useRefHandles = $useRefHandles ? -1 : 0;
@@ -229,10 +203,7 @@ class Data implements \ArrayAccess, \Countable, \IteratorAggregate
         return $data;
     }
 
-    /**
-     * @return static
-     */
-    public function withContext(array $context)
+    public function withContext(array $context): static
     {
         $data = clone $this;
         $data->context = $context;
@@ -240,14 +211,15 @@ class Data implements \ArrayAccess, \Countable, \IteratorAggregate
         return $data;
     }
 
+    public function getContext(): array
+    {
+        return $this->context;
+    }
+
     /**
      * Seeks to a specific key in nested data structures.
-     *
-     * @param string|int $key The key to seek to
-     *
-     * @return static|null Null if the key is not set
      */
-    public function seek($key)
+    public function seek(string|int $key): ?static
     {
         $item = $this->data[$this->position][$this->key];
 
@@ -291,20 +263,18 @@ class Data implements \ArrayAccess, \Countable, \IteratorAggregate
     /**
      * Dumps data with a DumperInterface dumper.
      */
-    public function dump(DumperInterface $dumper)
+    public function dump(DumperInterface $dumper): void
     {
         $refs = [0];
         $cursor = new Cursor();
+        $cursor->hashType = -1;
+        $cursor->attr = $this->context[SourceContextProvider::class] ?? [];
+        $label = $this->context['label'] ?? '';
 
-        if ($cursor->attr = $this->context[SourceContextProvider::class] ?? []) {
-            $cursor->attr['if_links'] = true;
-            $cursor->hashType = -1;
-            $dumper->dumpScalar($cursor, 'default', '^');
-            $cursor->attr = ['if_links' => true];
-            $dumper->dumpScalar($cursor, 'default', ' ');
-            $cursor->hashType = 0;
+        if ($cursor->attr || '' !== $label) {
+            $dumper->dumpScalar($cursor, 'label', $label);
         }
-
+        $cursor->hashType = 0;
         $this->dumpItem($dumper, $cursor, $refs, $this->data[$this->position][$this->key]);
     }
 
@@ -313,7 +283,7 @@ class Data implements \ArrayAccess, \Countable, \IteratorAggregate
      *
      * @param mixed $item A Stub object or the original value being dumped
      */
-    private function dumpItem(DumperInterface $dumper, Cursor $cursor, array &$refs, $item)
+    private function dumpItem(DumperInterface $dumper, Cursor $cursor, array &$refs, mixed $item): void
     {
         $cursor->refIndex = 0;
         $cursor->softRefTo = $cursor->softRefHandle = $cursor->softRefCount = 0;
@@ -335,7 +305,7 @@ class Data implements \ArrayAccess, \Countable, \IteratorAggregate
                 }
                 $cursor->hardRefTo = $refs[$r];
                 $cursor->hardRefHandle = $this->useRefHandles & $item->handle;
-                $cursor->hardRefCount = $item->refCount;
+                $cursor->hardRefCount = 0 < $item->handle ? $item->refCount : 0;
             }
             $cursor->attr = $item->attr;
             $type = $item->class ?: \gettype($item->value);
@@ -395,8 +365,12 @@ class Data implements \ArrayAccess, \Countable, \IteratorAggregate
                     $dumper->leaveHash($cursor, $item->type, $item->class, $withChildren, $cut);
                     break;
 
+                case Stub::TYPE_SCALAR:
+                    $dumper->dumpScalar($cursor, 'default', $item->attr['value']);
+                    break;
+
                 default:
-                    throw new \RuntimeException(sprintf('Unexpected Stub type: "%s".', $item->type));
+                    throw new \RuntimeException(\sprintf('Unexpected Stub type: "%s".', $item->type));
             }
         } elseif ('array' === $type) {
             $dumper->enterHash($cursor, Cursor::HASH_INDEXED, 0, false);
@@ -435,7 +409,7 @@ class Data implements \ArrayAccess, \Countable, \IteratorAggregate
         return $hashCut;
     }
 
-    private function getStub($item)
+    private function getStub(mixed $item): mixed
     {
         if (!$item || !\is_array($item)) {
             return $item;

package/support/vendor/symfony/var-dumper/Cloner/DumperInterface.php

@@ -20,11 +20,8 @@ interface DumperInterface
 {
     /**
      * Dumps a scalar value.
-     *
-     * @param string                $type  The PHP type of the value being dumped
-     * @param string|int|float|bool $value The scalar value being dumped
      */
-    public function dumpScalar(Cursor $cursor, $type, $value);
+    public function dumpScalar(Cursor $cursor, string $type, string|int|float|bool|null $value): void;
 
     /**
      * Dumps a string.
@@ -33,24 +30,24 @@ interface DumperInterface
      * @param bool   $bin Whether $str is UTF-8 or binary encoded
      * @param int    $cut The number of characters $str has been cut by
      */
-    public function dumpString(Cursor $cursor, $str, $bin, $cut);
+    public function dumpString(Cursor $cursor, string $str, bool $bin, int $cut): void;
 
     /**
      * Dumps while entering an hash.
      *
-     * @param int        $type     A Cursor::HASH_* const for the type of hash
-     * @param string|int $class    The object class, resource type or array count
-     * @param bool       $hasChild When the dump of the hash has child item
+     * @param int             $type     A Cursor::HASH_* const for the type of hash
+     * @param string|int|null $class    The object class, resource type or array count
+     * @param bool            $hasChild When the dump of the hash has child item
      */
-    public function enterHash(Cursor $cursor, $type, $class, $hasChild);
+    public function enterHash(Cursor $cursor, int $type, string|int|null $class, bool $hasChild): void;
 
     /**
      * Dumps while leaving an hash.
      *
-     * @param int        $type     A Cursor::HASH_* const for the type of hash
-     * @param string|int $class    The object class, resource type or array count
-     * @param bool       $hasChild When the dump of the hash has child item
-     * @param int        $cut      The number of items the hash has been cut by
+     * @param int             $type     A Cursor::HASH_* const for the type of hash
+     * @param string|int|null $class    The object class, resource type or array count
+     * @param bool            $hasChild When the dump of the hash has child item
+     * @param int             $cut      The number of items the hash has been cut by
      */
-    public function leaveHash(Cursor $cursor, $type, $class, $hasChild, $cut);
+    public function leaveHash(Cursor $cursor, int $type, string|int|null $class, bool $hasChild, int $cut): void;
 }

package/support/vendor/symfony/var-dumper/Cloner/Stub.php

@@ -18,50 +18,59 @@ namespace Symfony\Component\VarDumper\Cloner;
  */
 class Stub
 {
-    const TYPE_REF = 1;
-    const TYPE_STRING = 2;
-    const TYPE_ARRAY = 3;
-    const TYPE_OBJECT = 4;
-    const TYPE_RESOURCE = 5;
+    public const TYPE_REF = 1;
+    public const TYPE_STRING = 2;
+    public const TYPE_ARRAY = 3;
+    public const TYPE_OBJECT = 4;
+    public const TYPE_RESOURCE = 5;
+    public const TYPE_SCALAR = 6;
 
-    const STRING_BINARY = 1;
-    const STRING_UTF8 = 2;
+    public const STRING_BINARY = 1;
+    public const STRING_UTF8 = 2;
 
-    const ARRAY_ASSOC = 1;
-    const ARRAY_INDEXED = 2;
+    public const ARRAY_ASSOC = 1;
+    public const ARRAY_INDEXED = 2;
 
-    public $type = self::TYPE_REF;
-    public $class = '';
-    public $value;
-    public $cut = 0;
-    public $handle = 0;
-    public $refCount = 0;
-    public $position = 0;
-    public $attr = [];
-
-    private static $defaultProperties = [];
+    public int $type = self::TYPE_REF;
+    public string|int|null $class = '';
+    public mixed $value = null;
+    public int $cut = 0;
+    public int $handle = 0;
+    public int $refCount = 0;
+    public int $position = 0;
+    public array $attr = [];
 
     /**
      * @internal
      */
-    public function __sleep(): array
-    {
-        $properties = [];
+    protected static array $propertyDefaults = [];
 
-        if (!isset(self::$defaultProperties[$c = static::class])) {
-            self::$defaultProperties[$c] = get_class_vars($c);
+    public function __serialize(): array
+    {
+        static $noDefault = new \stdClass();
 
-            foreach ((new \ReflectionClass($c))->getStaticProperties() as $k => $v) {
-                unset(self::$defaultProperties[$c][$k]);
+        if (self::class === static::class) {
+            $data = [];
+            foreach ($this as $k => $v) {
+                $default = self::$propertyDefaults[$this::class][$k] ??= ($p = new \ReflectionProperty($this, $k))->hasDefaultValue() ? $p->getDefaultValue() : ($p->hasType() ? $noDefault : null);
+                if ($noDefault === $default || $default !== $v) {
+                    $data[$k] = $v;
+                }
             }
+
+            return $data;
         }
 
-        foreach (self::$defaultProperties[$c] as $k => $v) {
-            if ($this->$k !== $v) {
-                $properties[] = $k;
+        return \Closure::bind(function () use ($noDefault) {
+            $data = [];
+            foreach ($this as $k => $v) {
+                $default = self::$propertyDefaults[$this::class][$k] ??= ($p = new \ReflectionProperty($this, $k))->hasDefaultValue() ? $p->getDefaultValue() : ($p->hasType() ? $noDefault : null);
+                if ($noDefault === $default || $default !== $v) {
+                    $data[$k] = $v;
+                }
             }
-        }
 
-        return $properties;
+            return $data;
+        }, $this, $this::class)();
     }
 }

package/support/vendor/symfony/var-dumper/Cloner/VarCloner.php

@@ -16,41 +16,30 @@ namespace Symfony\Component\VarDumper\Cloner;
  */
 class VarCloner extends AbstractCloner
 {
-    private static $gid;
-    private static $arrayCache = [];
+    private static array $arrayCache = [];
 
-    /**
-     * {@inheritdoc}
-     */
-    protected function doClone($var)
+    protected function doClone(mixed $var): array
     {
         $len = 1;                       // Length of $queue
         $pos = 0;                       // Number of cloned items past the minimum depth
         $refsCounter = 0;               // Hard references counter
-        $queue = [[$var]];    // This breadth-first queue is the return value
-        $indexedArrays = [];       // Map of queue indexes that hold numerically indexed arrays
-        $hardRefs = [];            // Map of original zval ids to stub objects
-        $objRefs = [];             // Map of original object handles to their stub object counterpart
-        $objects = [];             // Keep a ref to objects to ensure their handle cannot be reused while cloning
-        $resRefs = [];             // Map of original resource handles to their stub object counterpart
-        $values = [];              // Map of stub objects' ids to original values
+        $queue = [[$var]];              // This breadth-first queue is the return value
+        $hardRefs = [];                 // Map of original zval ids to stub objects
+        $objRefs = [];                  // Map of original object handles to their stub object counterpart
+        $objects = [];                  // Keep a ref to objects to ensure their handle cannot be reused while cloning
+        $resRefs = [];                  // Map of original resource handles to their stub object counterpart
         $maxItems = $this->maxItems;
         $maxString = $this->maxString;
         $minDepth = $this->minDepth;
         $currentDepth = 0;              // Current tree depth
         $currentDepthFinalIndex = 0;    // Final $queue index for current tree depth
         $minimumDepthReached = 0 === $minDepth; // Becomes true when minimum tree depth has been reached
-        $cookie = (object) [];          // Unique object used to detect hard references
         $a = null;                      // Array cast for nested structures
         $stub = null;                   // Stub capturing the main properties of an original item value
                                         // or null if the original value is used directly
 
-        if (!$gid = self::$gid) {
-            $gid = self::$gid = md5(random_bytes(6)); // Unique string used to detect the special $GLOBALS variable
-        }
         $arrayStub = new Stub();
         $arrayStub->type = Stub::TYPE_ARRAY;
-        $fromObjCast = false;
 
         for ($i = 0; $i < $len; ++$i) {
             // Detect when we move on to the next tree depth
@@ -62,51 +51,29 @@ class VarCloner extends AbstractCloner
                 }
             }
 
-            $refs = $vals = $queue[$i];
-            if (\PHP_VERSION_ID < 70200 && empty($indexedArrays[$i])) {
-                // see https://wiki.php.net/rfc/convert_numeric_keys_in_object_array_casts
-                foreach ($vals as $k => $v) {
-                    if (\is_int($k)) {
-                        continue;
-                    }
-                    foreach ([$k => true] as $gk => $gv) {
-                    }
-                    if ($gk !== $k) {
-                        $fromObjCast = true;
-                        $refs = $vals = array_values($queue[$i]);
-                        break;
-                    }
-                }
-            }
+            $vals = $queue[$i];
             foreach ($vals as $k => $v) {
                 // $v is the original value or a stub object in case of hard references
 
-                if (\PHP_VERSION_ID >= 70400) {
-                    $zvalIsRef = null !== \ReflectionReference::fromArrayElement($vals, $k);
-                } else {
-                    $refs[$k] = $cookie;
-                    $zvalIsRef = $vals[$k] === $cookie;
-                }
+                $zvalRef = ($r = \ReflectionReference::fromArrayElement($vals, $k)) ? $r->getId() : null;
 
-                if ($zvalIsRef) {
+                if ($zvalRef) {
                     $vals[$k] = &$stub;         // Break hard references to make $queue completely
                     unset($stub);               // independent from the original structure
-                    if ($v instanceof Stub && isset($hardRefs[spl_object_id($v)])) {
-                        $vals[$k] = $refs[$k] = $v;
+                    if (null !== $vals[$k] = $hardRefs[$zvalRef] ?? null) {
+                        $v = $vals[$k];
                         if ($v->value instanceof Stub && (Stub::TYPE_OBJECT === $v->value->type || Stub::TYPE_RESOURCE === $v->value->type)) {
                             ++$v->value->refCount;
                         }
                         ++$v->refCount;
                         continue;
                     }
-                    $refs[$k] = $vals[$k] = new Stub();
-                    $refs[$k]->value = $v;
-                    $h = spl_object_id($refs[$k]);
-                    $hardRefs[$h] = &$refs[$k];
-                    $values[$h] = $v;
+                    $vals[$k] = new Stub();
+                    $vals[$k]->value = $v;
                     $vals[$k]->handle = ++$refsCounter;
+                    $hardRefs[$zvalRef] = $vals[$k];
                 }
-                // Create $stub when the original value $v can not be used directly
+                // Create $stub when the original value $v cannot be used directly
                 // If $v is a nested structure, put that structure in array $a
                 switch (true) {
                     case null === $v:
@@ -145,44 +112,16 @@ class VarCloner extends AbstractCloner
                             continue 2;
                         }
                         $stub = $arrayStub;
-                        $stub->class = Stub::ARRAY_INDEXED;
 
-                        $j = -1;
-                        foreach ($v as $gk => $gv) {
-                            if ($gk !== ++$j) {
-                                $stub->class = Stub::ARRAY_ASSOC;
-                                break;
-                            }
-                        }
+                        $stub->class = array_is_list($v) ? Stub::ARRAY_INDEXED : Stub::ARRAY_ASSOC;
                         $a = $v;
-
-                        if (Stub::ARRAY_ASSOC === $stub->class) {
-                            // Copies of $GLOBALS have very strange behavior,
-                            // let's detect them with some black magic
-                            $a[$gid] = true;
-
-                            // Happens with copies of $GLOBALS
-                            if (isset($v[$gid])) {
-                                unset($v[$gid]);
-                                $a = [];
-                                foreach ($v as $gk => &$gv) {
-                                    $a[$gk] = &$gv;
-                                }
-                                unset($gv);
-                            } else {
-                                $a = $v;
-                            }
-                        } elseif (\PHP_VERSION_ID < 70200) {
-                            $indexedArrays[$len] = true;
-                        }
                         break;
 
                     case \is_object($v):
-                    case $v instanceof \__PHP_Incomplete_Class:
                         if (empty($objRefs[$h = spl_object_id($v)])) {
                             $stub = new Stub();
                             $stub->type = Stub::TYPE_OBJECT;
-                            $stub->class = \get_class($v);
+                            $stub->class = $v::class;
                             $stub->value = $v;
                             $stub->handle = $h;
                             $a = $this->castObject($stub, 0 < $i);
@@ -264,38 +203,16 @@ class VarCloner extends AbstractCloner
                     }
                 }
 
-                if ($zvalIsRef) {
-                    $refs[$k]->value = $stub;
-                } else {
+                if (!$zvalRef) {
                     $vals[$k] = $stub;
-                }
-            }
-
-            if ($fromObjCast) {
-                $fromObjCast = false;
-                $refs = $vals;
-                $vals = [];
-                $j = -1;
-                foreach ($queue[$i] as $k => $v) {
-                    foreach ([$k => true] as $gk => $gv) {
-                    }
-                    if ($gk !== $k) {
-                        $vals = (object) $vals;
-                        $vals->{$k} = $refs[++$j];
-                        $vals = (array) $vals;
-                    } else {
-                        $vals[$k] = $refs[++$j];
-                    }
+                } else {
+                    $hardRefs[$zvalRef]->value = $stub;
                 }
             }
 
             $queue[$i] = $vals;
         }
 
-        foreach ($values as $h => $v) {
-            $hardRefs[$h] = $v;
-        }
-
         return $queue;
     }
 }