@vituum/vite-plugin-latte 1.2.0 → 1.3.0

package/vendor/latte/latte/src/Latte/Essential/Filters.php

@@ -23,6 +23,9 @@ use function is_array, is_string, count, strlen;
  */
 final class Filters
 {
+	public ?string $locale = null;
+
+
 	/**
 	 * Converts HTML to plain text.
 	 */
@@ -35,7 +38,7 @@ final class Filters
 
 
 	/**
-	 * Removes tags from HTML (but remains HTML entites).
+	 * Removes tags from HTML (but remains HTML entities).
 	 */
 	public static function stripTags(FilterInfo $info, $s): string
 	{
@@ -168,14 +171,11 @@ final class Filters
 	 */
 	public static function date(string|int|\DateTimeInterface|\DateInterval|null $time, ?string $format = null): ?string
 	{
+		$format ??= Latte\Runtime\Filters::$dateFormat;
 		if ($time == null) { // intentionally ==
 			return null;
-		}
-
-		$format ??= Latte\Runtime\Filters::$dateFormat;
-		if ($time instanceof \DateInterval) {
+		} elseif ($time instanceof \DateInterval) {
 			return $time->format($format);
-
 		} elseif (is_numeric($time)) {
 			$time = (new \DateTime)->setTimestamp((int) $time);
 		} elseif (!$time instanceof \DateTimeInterface) {
@@ -194,10 +194,75 @@ final class Filters
 	}
 
 
+	/**
+	 * Date/time formatting according to locale.
+	 */
+	public function localDate(
+		string|int|\DateTimeInterface|null $value,
+		?string $format = null,
+		?string $date = null,
+		?string $time = null,
+	): ?string
+	{
+		if ($this->locale === null) {
+			throw new Latte\RuntimeException('Filter |localDate requires the locale to be set using Engine::setLocale()');
+		} elseif ($value == null) { // intentionally ==
+			return null;
+		} elseif (is_numeric($value)) {
+			$value = (new \DateTime)->setTimestamp((int) $value);
+		} elseif (!$value instanceof \DateTimeInterface) {
+			$value = new \DateTime($value);
+			$errors = \DateTime::getLastErrors();
+			if (!empty($errors['warnings'])) {
+				throw new \InvalidArgumentException(reset($errors['warnings']));
+			}
+		}
+
+		if ($format === null) {
+			$xlt = ['' => \IntlDateFormatter::NONE, 'full' => \IntlDateFormatter::FULL, 'long' => \IntlDateFormatter::LONG, 'medium' => \IntlDateFormatter::MEDIUM, 'short' => \IntlDateFormatter::SHORT,
+				'relative-full' => \IntlDateFormatter::RELATIVE_FULL, 'relative-long' => \IntlDateFormatter::RELATIVE_LONG, 'relative-medium' => \IntlDateFormatter::RELATIVE_MEDIUM, 'relative-short' => \IntlDateFormatter::RELATIVE_SHORT];
+			$date ??= $time === null ? 'long' : null;
+			$formatter = new \IntlDateFormatter($this->locale, $xlt[$date], $xlt[$time]);
+		} else {
+			$formatter = new \IntlDateFormatter($this->locale, pattern: (new \IntlDatePatternGenerator($this->locale))->getBestPattern($format));
+		}
+
+		$res = $formatter->format($value);
+		$res = preg_replace('~(\d\.) ~', "\$1\u{a0}", $res);
+		return $res;
+	}
+
+
+	/**
+	 * Formats a number with grouped thousands and optionally decimal digits according to locale.
+	 */
+	public function number(
+		float $number,
+		string|int $patternOrDecimals = 0,
+		string $decimalSeparator = '.',
+		string $thousandsSeparator = ',',
+	): string
+	{
+		if (is_int($patternOrDecimals) && $patternOrDecimals < 0) {
+			throw new Latte\RuntimeException('Filter |number: the number of decimal must not be negative');
+		} elseif ($this->locale === null || func_num_args() > 2) {
+			return number_format($number, $patternOrDecimals, $decimalSeparator, $thousandsSeparator);
+		}
+
+		$formatter = new \NumberFormatter($this->locale, \NumberFormatter::DECIMAL);
+		if (is_string($patternOrDecimals)) {
+			$formatter->setPattern($patternOrDecimals);
+		} else {
+			$formatter->setAttribute(\NumberFormatter::FRACTION_DIGITS, $patternOrDecimals);
+		}
+		return $formatter->format($number);
+	}
+
+
 	/**
 	 * Converts to human-readable file size.
 	 */
-	public static function bytes(float $bytes, int $precision = 2): string
+	public function bytes(float $bytes, int $precision = 2): string
 	{
 		$bytes = round($bytes);
 		$units = ['B', 'kB', 'MB', 'GB', 'TB', 'PB'];
@@ -209,7 +274,15 @@ final class Filters
 			$bytes /= 1024;
 		}
 
-		return round($bytes, $precision) . ' ' . $unit;
+		if ($this->locale === null) {
+			$bytes = (string) round($bytes, $precision);
+		} else {
+			$formatter = new \NumberFormatter($this->locale, \NumberFormatter::DECIMAL);
+			$formatter->setAttribute(\NumberFormatter::MAX_FRACTION_DIGITS, $precision);
+			$bytes = $formatter->format($bytes);
+		}
+
+		return $bytes . ' ' . $unit;
 	}
 
 
@@ -455,7 +528,7 @@ final class Filters
 	 * @param  iterable<K, V>  $data
 	 * @return iterable<K, V>
 	 */
-	public static function sort(
+	public function sort(
 		iterable $data,
 		?\Closure $comparison = null,
 		string|int|\Closure|null $by = null,
@@ -469,7 +542,16 @@ final class Filters
 			$by = $byKey === true ? null : $byKey;
 		}
 
-		$comparison ??= fn($a, $b) => $a <=> $b;
+		if ($comparison) {
+		} elseif ($this->locale === null) {
+			$comparison = fn($a, $b) => $a <=> $b;
+		} else {
+			$collator = new \Collator($this->locale);
+			$comparison = fn($a, $b) => is_string($a) && is_string($b)
+				? $collator->compare($a, $b)
+				: $a <=> $b;
+		}
+
 		$comparison = match (true) {
 			$by === null => $comparison,
 			$by instanceof \Closure => fn($a, $b) => $comparison($by($a), $by($b)),
@@ -524,6 +606,24 @@ final class Filters
 	}
 
 
+	/**
+	 * Filters elements according to a given $predicate. Maintains original keys.
+	 * @template K
+	 * @template V
+	 * @param  iterable<K, V>  $iterable
+	 * @param  callable(V, K, iterable<K, V>): bool  $predicate
+	 * @return iterable<K, V>
+	 */
+	public static function filter(iterable $iterable, callable $predicate): iterable
+	{
+		foreach ($iterable as $k => $v) {
+			if ($predicate($v, $k, $iterable)) {
+				yield $k => $v;
+			}
+		}
+	}
+
+
 	/**
 	 * Returns value clamped to the inclusive range of min and max.
 	 */

package/vendor/latte/latte/src/Latte/Essential/Nodes/ImportNode.php

@@ -9,6 +9,7 @@ declare(strict_types=1);
 
 namespace Latte\Essential\Nodes;
 
+use Latte\Compiler\Nodes\Php\Expression\ArrayNode;
 use Latte\Compiler\Nodes\Php\ExpressionNode;
 use Latte\Compiler\Nodes\StatementNode;
 use Latte\Compiler\PrintContext;
@@ -16,11 +17,12 @@ use Latte\Compiler\Tag;
 
 
 /**
- * {import "file"}
+ * {import "file"[, args]}
  */
 class ImportNode extends StatementNode
 {
 	public ExpressionNode $file;
+	public ArrayNode $args;
 
 
 	public static function create(Tag $tag): static
@@ -28,6 +30,8 @@ class ImportNode extends StatementNode
 		$tag->expectArguments();
 		$node = new static;
 		$node->file = $tag->parser->parseUnquotedStringOrExpression();
+		$tag->parser->stream->tryConsume(',');
+		$node->args = $tag->parser->parseArguments();
 		return $node;
 	}
 
@@ -35,8 +39,9 @@ class ImportNode extends StatementNode
 	public function print(PrintContext $context): string
 	{
 		return $context->format(
-			'$this->createTemplate(%node, $this->params, "import")->render() %line;',
+			'$this->createTemplate(%node, %node? + $this->params, "import")->render() %line;',
 			$this->file,
+			$this->args,
 			$this->position,
 		);
 	}
@@ -45,5 +50,6 @@ class ImportNode extends StatementNode
 	public function &getIterator(): \Generator
 	{
 		yield $this->file;
+		yield $this->args;
 	}
 }

package/vendor/latte/latte/src/Latte/Essential/Nodes/VarNode.php

@@ -10,8 +10,10 @@ declare(strict_types=1);
 namespace Latte\Essential\Nodes;
 
 use Latte\Compiler\Nodes\Php\Expression\AssignNode;
+use Latte\Compiler\Nodes\Php\Expression\AssignOpNode;
+use Latte\Compiler\Nodes\Php\Expression\AuxiliaryNode;
+use Latte\Compiler\Nodes\Php\Expression\TernaryNode;
 use Latte\Compiler\Nodes\Php\Expression\VariableNode;
-use Latte\Compiler\Nodes\Php\ExpressionNode;
 use Latte\Compiler\Nodes\Php\Scalar\NullNode;
 use Latte\Compiler\Nodes\StatementNode;
 use Latte\Compiler\PrintContext;
@@ -67,25 +69,19 @@ class VarNode extends StatementNode
 	public function print(PrintContext $context): string
 	{
 		$res = [];
-		if ($this->default) {
-			foreach ($this->assignments as $assign) {
+		foreach ($this->assignments as $assign) {
+			if ($this->default) {
 				assert($assign->var instanceof VariableNode);
-				if ($assign->var->name instanceof ExpressionNode) {
-					$var = $assign->var->name->print($context);
-				} else {
-					$var = $context->encodeString($assign->var->name);
-				}
-				$res[] = $var . ' => ' . $assign->expr->print($context);
+				$assign = new AssignOpNode(
+					$assign->var,
+					'??',
+					new TernaryNode(
+						new AuxiliaryNode(fn() => 'array_key_exists(' . $context->encodeString($assign->var->name) . ', get_defined_vars())'),
+						new NullNode,
+						$assign->expr,
+					),
+				);
 			}
-
-			return $context->format(
-				'extract([%raw], EXTR_SKIP) %line;',
-				implode(', ', $res),
-				$this->position,
-			);
-		}
-
-		foreach ($this->assignments as $assign) {
 			$res[] = $assign->print($context);
 		}
 

package/vendor/latte/latte/src/Latte/Essential/TranslatorExtension.php

@@ -50,7 +50,7 @@ final class TranslatorExtension extends Latte\Extension
 	public function getFilters(): array
 	{
 		return [
-			'translate' => fn(Latte\Runtime\FilterInfo $fi, ...$args): string => $this->translator
+			'translate' => fn(Latte\Runtime\FilterInfo $fi, ...$args) => $this->translator
 				? ($this->translator)(...$args)
 				: $args[0],
 		];

package/vendor/latte/latte/src/Latte/Loaders/FileLoader.php

@@ -59,7 +59,7 @@ class FileLoader implements Latte\Loader
 	 */
 	public function getReferredName(string $file, string $referringFile): string
 	{
-		if ($this->baseDir || !preg_match('#/|\\\\|[a-z][a-z0-9+.-]*:#iA', $file)) {
+		if ($this->baseDir || !preg_match('#/|\\\\|[a-z]:|phar:#iA', $file)) {
 			$file = $this->normalizePath($referringFile . '/../' . $file);
 		}
 
@@ -78,15 +78,16 @@ class FileLoader implements Latte\Loader
 
 	protected static function normalizePath(string $path): string
 	{
+		preg_match('#^([a-z]:|phar://.+?/)?(.*)#i', $path, $m);
 		$res = [];
-		foreach (explode('/', strtr($path, '\\', '/')) as $part) {
-			if ($part === '..' && $res && end($res) !== '..') {
+		foreach (explode('/', strtr($m[2], '\\', '/')) as $part) {
+			if ($part === '..' && $res && end($res) !== '..' && end($res) !== '') {
 				array_pop($res);
 			} elseif ($part !== '.') {
 				$res[] = $part;
 			}
 		}
 
-		return implode(DIRECTORY_SEPARATOR, $res);
+		return $m[1] . implode(DIRECTORY_SEPARATOR, $res);
 	}
 }

package/vendor/latte/latte/src/Latte/Runtime/Template.php

@@ -138,7 +138,7 @@ class Template
 
 		$params = $this->prepare();
 
-		if ($this->parentName === null && isset($this->global->coreParentFinder)) {
+		if ($this->parentName === null && !$this->referringTemplate && isset($this->global->coreParentFinder)) {
 			$this->parentName = ($this->global->coreParentFinder)($this);
 		}
 

package/vendor/latte/latte/src/Latte/Sandbox/Nodes/FunctionCallNode.php

@@ -26,6 +26,5 @@ class FunctionCallNode extends Expression\FunctionCallNode
 		return '$this->global->sandbox->call('
 			. $context->memberAsString($this->name) . ', '
 			. $context->argumentsAsArray($this->args) . ')';
-
 	}
 }

package/vendor/nette/utils/.phpstorm.meta.php

@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PHPSTORM_META;
+
+override(\Nette\Utils\Arrays::get(0), elementType(0));
+override(\Nette\Utils\Arrays::getRef(0), elementType(0));
+override(\Nette\Utils\Arrays::grep(0), type(0));
+override(\Nette\Utils\Arrays::toObject(0), type(1));
+
+expectedArguments(\Nette\Utils\Image::resize(), 2, \Nette\Utils\Image::ShrinkOnly, \Nette\Utils\Image::Stretch, \Nette\Utils\Image::OrSmaller, \Nette\Utils\Image::OrBigger, \Nette\Utils\Image::Cover);
+expectedArguments(\Nette\Utils\Image::calculateSize(), 4, \Nette\Utils\Image::ShrinkOnly, \Nette\Utils\Image::Stretch, \Nette\Utils\Image::OrSmaller, \Nette\Utils\Image::OrBigger, \Nette\Utils\Image::Cover);

package/vendor/nette/utils/composer.json

@@ -0,0 +1,51 @@
+{
+	"name": "nette/utils",
+	"description": "🛠  Nette Utils: lightweight utilities for string & array manipulation, image handling, safe JSON encoding/decoding, validation, slug or strong password generating etc.",
+	"keywords": ["nette", "images", "json", "password", "validation", "utility", "string", "array", "core", "slugify", "utf-8", "unicode", "paginator", "datetime"],
+	"homepage": "https://nette.org",
+	"license": ["BSD-3-Clause", "GPL-2.0-only", "GPL-3.0-only"],
+	"authors": [
+		{
+			"name": "David Grudl",
+			"homepage": "https://davidgrudl.com"
+		},
+		{
+			"name": "Nette Community",
+			"homepage": "https://nette.org/contributors"
+		}
+	],
+	"require": {
+		"php": "8.0 - 8.4"
+	},
+	"require-dev": {
+		"nette/tester": "^2.5",
+		"tracy/tracy": "^2.9",
+		"phpstan/phpstan": "^1.0",
+		"jetbrains/phpstorm-attributes": "dev-master"
+	},
+	"conflict": {
+		"nette/finder": "<3",
+		"nette/schema": "<1.2.2"
+	},
+	"suggest": {
+		"ext-iconv": "to use Strings::webalize(), toAscii(), chr() and reverse()",
+		"ext-json": "to use Nette\\Utils\\Json",
+		"ext-intl": "to use Strings::webalize(), toAscii(), normalize() and compare()",
+		"ext-mbstring": "to use Strings::lower() etc...",
+		"ext-gd": "to use Image",
+		"ext-tokenizer": "to use Nette\\Utils\\Reflection::getUseStatements()"
+	},
+	"autoload": {
+		"classmap": ["src/"]
+	},
+	"minimum-stability": "dev",
+	"scripts": {
+		"phpstan": "phpstan analyse",
+		"tester": "tester tests -s"
+	},
+	"extra": {
+		"branch-alias": {
+			"dev-master": "4.0-dev"
+		}
+	}
+}

package/vendor/nette/utils/license.md

@@ -0,0 +1,60 @@
+Licenses
+========
+
+Good news! You may use Nette Framework under the terms of either
+the New BSD License or the GNU General Public License (GPL) version 2 or 3.
+
+The BSD License is recommended for most projects. It is easy to understand and it
+places almost no restrictions on what you can do with the framework. If the GPL
+fits better to your project, you can use the framework under this license.
+
+You don't have to notify anyone which license you are using. You can freely
+use Nette Framework in commercial projects as long as the copyright header
+remains intact.
+
+Please be advised that the name "Nette Framework" is a protected trademark and its
+usage has some limitations. So please do not use word "Nette" in the name of your
+project or top-level domain, and choose a name that stands on its own merits.
+If your stuff is good, it will not take long to establish a reputation for yourselves.
+
+
+New BSD License
+---------------
+
+Copyright (c) 2004, 2014 David Grudl (https://davidgrudl.com)
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+	* Redistributions of source code must retain the above copyright notice,
+	this list of conditions and the following disclaimer.
+
+	* Redistributions in binary form must reproduce the above copyright notice,
+	this list of conditions and the following disclaimer in the documentation
+	and/or other materials provided with the distribution.
+
+	* Neither the name of "Nette Framework" nor the names of its contributors
+	may be used to endorse or promote products derived from this software
+	without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are
+disclaimed. In no event shall the copyright owner or contributors be liable for
+any direct, indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused and on
+any theory of liability, whether in contract, strict liability, or tort
+(including negligence or otherwise) arising in any way out of the use of this
+software, even if advised of the possibility of such damage.
+
+
+GNU General Public License
+--------------------------
+
+GPL licenses are very very long, so instead of including them here we offer
+you URLs with full text:
+
+- [GPL version 2](http://www.gnu.org/licenses/gpl-2.0.html)
+- [GPL version 3](http://www.gnu.org/licenses/gpl-3.0.html)

package/vendor/nette/utils/readme.md

@@ -0,0 +1,55 @@
+[![Nette Utils](https://github.com/nette/utils/assets/194960/c33fdb74-0652-4cad-ac6e-c1ce0d29e32a)](https://doc.nette.org/en/utils)
+
+[![Downloads this Month](https://img.shields.io/packagist/dm/nette/utils.svg)](https://packagist.org/packages/nette/utils)
+[![Tests](https://github.com/nette/utils/workflows/Tests/badge.svg?branch=master)](https://github.com/nette/utils/actions)
+[![Coverage Status](https://coveralls.io/repos/github/nette/utils/badge.svg?branch=master)](https://coveralls.io/github/nette/utils?branch=master)
+[![Latest Stable Version](https://poser.pugx.org/nette/utils/v/stable)](https://github.com/nette/utils/releases)
+[![License](https://img.shields.io/badge/license-New%20BSD-blue.svg)](https://github.com/nette/utils/blob/master/license.md)
+
+
+Introduction
+------------
+
+In package nette/utils you will find a set of useful classes for everyday use:
+
+✅ [Arrays](https://doc.nette.org/utils/arrays)<br>
+✅ [Callback](https://doc.nette.org/utils/callback) - PHP callbacks<br>
+✅ [Filesystem](https://doc.nette.org/utils/filesystem) - copying, renaming, …<br>
+✅ [Finder](https://doc.nette.org/utils/finder) - finds files and directories<br>
+✅ [Floats](https://doc.nette.org/utils/floats) - floating point numbers<br>
+✅ [Helper Functions](https://doc.nette.org/utils/helpers)<br>
+✅ [HTML elements](https://doc.nette.org/utils/html-elements) - generate HTML<br>
+✅ [Images](https://doc.nette.org/utils/images) - crop, resize, rotate images<br>
+✅ [Iterables](https://doc.nette.org/utils/iterables) <br>
+✅ [JSON](https://doc.nette.org/utils/json) - encoding and decoding<br>
+✅ [Generating Random Strings](https://doc.nette.org/utils/random)<br>
+✅ [Paginator](https://doc.nette.org/utils/paginator) - pagination math<br>
+✅ [PHP Reflection](https://doc.nette.org/utils/reflection)<br>
+✅ [Strings](https://doc.nette.org/utils/strings) - useful text functions<br>
+✅ [SmartObject](https://doc.nette.org/utils/smartobject) - PHP object enhancements<br>
+✅ [Type](https://doc.nette.org/utils/type) - PHP data type<br>
+✅ [Validation](https://doc.nette.org/utils/validators) - validate inputs<br>
+
+ <!---->
+
+Installation
+------------
+
+The recommended way to install is via Composer:
+
+```
+composer require nette/utils
+```
+
+Nette Utils 4.0 is compatible with PHP 8.0 to 8.4.
+
+ <!---->
+
+[Support Me](https://github.com/sponsors/dg)
+--------------------------------------------
+
+Do you like Nette Utils? Are you looking forward to the new features?
+
+[![Buy me a coffee](https://files.nette.org/icons/donation-3.svg)](https://github.com/sponsors/dg)
+
+Thank you!

package/vendor/nette/utils/src/HtmlStringable.php

@@ -0,0 +1,22 @@
+<?php
+
+/**
+ * This file is part of the Nette Framework (https://nette.org)
+ * Copyright (c) 2004 David Grudl (https://davidgrudl.com)
+ */
+
+declare(strict_types=1);
+
+namespace Nette;
+
+
+interface HtmlStringable
+{
+	/**
+	 * Returns string in HTML format
+	 */
+	function __toString(): string;
+}
+
+
+interface_exists(Utils\IHtmlString::class);

package/vendor/nette/utils/src/Iterators/CachingIterator.php

@@ -0,0 +1,150 @@
+<?php
+
+/**
+ * This file is part of the Nette Framework (https://nette.org)
+ * Copyright (c) 2004 David Grudl (https://davidgrudl.com)
+ */
+
+declare(strict_types=1);
+
+namespace Nette\Iterators;
+
+use Nette;
+
+
+/**
+ * Smarter caching iterator.
+ *
+ * @property-read bool $first
+ * @property-read bool $last
+ * @property-read bool $empty
+ * @property-read bool $odd
+ * @property-read bool $even
+ * @property-read int $counter
+ * @property-read mixed $nextKey
+ * @property-read mixed $nextValue
+ */
+class CachingIterator extends \CachingIterator implements \Countable
+{
+	use Nette\SmartObject;
+
+	private int $counter = 0;
+
+
+	public function __construct(iterable|\stdClass $iterable)
+	{
+		$iterable = $iterable instanceof \stdClass
+			? new \ArrayIterator($iterable)
+			: Nette\Utils\Iterables::toIterator($iterable);
+		parent::__construct($iterable, 0);
+	}
+
+
+	/**
+	 * Is the current element the first one?
+	 */
+	public function isFirst(?int $gridWidth = null): bool
+	{
+		return $this->counter === 1 || ($gridWidth && $this->counter !== 0 && (($this->counter - 1) % $gridWidth) === 0);
+	}
+
+
+	/**
+	 * Is the current element the last one?
+	 */
+	public function isLast(?int $gridWidth = null): bool
+	{
+		return !$this->hasNext() || ($gridWidth && ($this->counter % $gridWidth) === 0);
+	}
+
+
+	/**
+	 * Is the iterator empty?
+	 */
+	public function isEmpty(): bool
+	{
+		return $this->counter === 0;
+	}
+
+
+	/**
+	 * Is the counter odd?
+	 */
+	public function isOdd(): bool
+	{
+		return $this->counter % 2 === 1;
+	}
+
+
+	/**
+	 * Is the counter even?
+	 */
+	public function isEven(): bool
+	{
+		return $this->counter % 2 === 0;
+	}
+
+
+	/**
+	 * Returns the counter.
+	 */
+	public function getCounter(): int
+	{
+		return $this->counter;
+	}
+
+
+	/**
+	 * Returns the count of elements.
+	 */
+	public function count(): int
+	{
+		$inner = $this->getInnerIterator();
+		if ($inner instanceof \Countable) {
+			return $inner->count();
+
+		} else {
+			throw new Nette\NotSupportedException('Iterator is not countable.');
+		}
+	}
+
+
+	/**
+	 * Forwards to the next element.
+	 */
+	public function next(): void
+	{
+		parent::next();
+		if (parent::valid()) {
+			$this->counter++;
+		}
+	}
+
+
+	/**
+	 * Rewinds the Iterator.
+	 */
+	public function rewind(): void
+	{
+		parent::rewind();
+		$this->counter = parent::valid() ? 1 : 0;
+	}
+
+
+	/**
+	 * Returns the next key.
+	 */
+	public function getNextKey(): mixed
+	{
+		return $this->getInnerIterator()->key();
+	}
+
+
+	/**
+	 * Returns the next element.
+	 */
+	public function getNextValue(): mixed
+	{
+		return $this->getInnerIterator()->current();
+	}
+}