1. <?php
3. /*
4.  * This file is part of Twig.
5.  *
6.  * (c) Fabien Potencier
7.  *
8.  * For the full copyright and license information, please view the LICENSE
9.  * file that was distributed with this source code.
10.  */
12. namespace Twig\Extension;
14. use Twig\DeprecatedCallableInfo;
15. use Twig\Environment;
16. use Twig\Error\LoaderError;
17. use Twig\Error\RuntimeError;
18. use Twig\Error\SyntaxError;
19. use Twig\ExpressionParser;
20. use Twig\Markup;
21. use Twig\Node\Expression\AbstractExpression;
22. use Twig\Node\Expression\Binary\AddBinary;
23. use Twig\Node\Expression\Binary\AndBinary;
24. use Twig\Node\Expression\Binary\BitwiseAndBinary;
25. use Twig\Node\Expression\Binary\BitwiseOrBinary;
26. use Twig\Node\Expression\Binary\BitwiseXorBinary;
27. use Twig\Node\Expression\Binary\ConcatBinary;
28. use Twig\Node\Expression\Binary\DivBinary;
29. use Twig\Node\Expression\Binary\ElvisBinary;
30. use Twig\Node\Expression\Binary\EndsWithBinary;
31. use Twig\Node\Expression\Binary\EqualBinary;
32. use Twig\Node\Expression\Binary\FloorDivBinary;
33. use Twig\Node\Expression\Binary\GreaterBinary;
34. use Twig\Node\Expression\Binary\GreaterEqualBinary;
35. use Twig\Node\Expression\Binary\HasEveryBinary;
36. use Twig\Node\Expression\Binary\HasSomeBinary;
37. use Twig\Node\Expression\Binary\InBinary;
38. use Twig\Node\Expression\Binary\LessBinary;
39. use Twig\Node\Expression\Binary\LessEqualBinary;
40. use Twig\Node\Expression\Binary\MatchesBinary;
41. use Twig\Node\Expression\Binary\ModBinary;
42. use Twig\Node\Expression\Binary\MulBinary;
43. use Twig\Node\Expression\Binary\NotEqualBinary;
44. use Twig\Node\Expression\Binary\NotInBinary;
45. use Twig\Node\Expression\Binary\NullCoalesceBinary;
46. use Twig\Node\Expression\Binary\OrBinary;
47. use Twig\Node\Expression\Binary\PowerBinary;
48. use Twig\Node\Expression\Binary\RangeBinary;
49. use Twig\Node\Expression\Binary\SpaceshipBinary;
50. use Twig\Node\Expression\Binary\StartsWithBinary;
51. use Twig\Node\Expression\Binary\SubBinary;
52. use Twig\Node\Expression\Binary\XorBinary;
53. use Twig\Node\Expression\BlockReferenceExpression;
54. use Twig\Node\Expression\Filter\DefaultFilter;
55. use Twig\Node\Expression\FunctionNode\EnumCasesFunction;
56. use Twig\Node\Expression\FunctionNode\EnumFunction;
57. use Twig\Node\Expression\GetAttrExpression;
58. use Twig\Node\Expression\ParentExpression;
59. use Twig\Node\Expression\Test\ConstantTest;
60. use Twig\Node\Expression\Test\DefinedTest;
61. use Twig\Node\Expression\Test\DivisiblebyTest;
62. use Twig\Node\Expression\Test\EvenTest;
63. use Twig\Node\Expression\Test\NullTest;
64. use Twig\Node\Expression\Test\OddTest;
65. use Twig\Node\Expression\Test\SameasTest;
66. use Twig\Node\Expression\Unary\NegUnary;
67. use Twig\Node\Expression\Unary\NotUnary;
68. use Twig\Node\Expression\Unary\PosUnary;
69. use Twig\Node\Node;
70. use Twig\OperatorPrecedenceChange;
71. use Twig\Parser;
72. use Twig\Sandbox\SecurityNotAllowedMethodError;
73. use Twig\Sandbox\SecurityNotAllowedPropertyError;
74. use Twig\Source;
75. use Twig\Template;
76. use Twig\TemplateWrapper;
77. use Twig\TokenParser\ApplyTokenParser;
78. use Twig\TokenParser\BlockTokenParser;
79. use Twig\TokenParser\DeprecatedTokenParser;
80. use Twig\TokenParser\DoTokenParser;
81. use Twig\TokenParser\EmbedTokenParser;
82. use Twig\TokenParser\ExtendsTokenParser;
83. use Twig\TokenParser\FlushTokenParser;
84. use Twig\TokenParser\ForTokenParser;
85. use Twig\TokenParser\FromTokenParser;
86. use Twig\TokenParser\GuardTokenParser;
87. use Twig\TokenParser\IfTokenParser;
88. use Twig\TokenParser\ImportTokenParser;
89. use Twig\TokenParser\IncludeTokenParser;
90. use Twig\TokenParser\MacroTokenParser;
91. use Twig\TokenParser\SetTokenParser;
92. use Twig\TokenParser\TypesTokenParser;
93. use Twig\TokenParser\UseTokenParser;
94. use Twig\TokenParser\WithTokenParser;
95. use Twig\TwigFilter;
96. use Twig\TwigFunction;
97. use Twig\TwigTest;
98. use Twig\Util\CallableArgumentsExtractor;
100. final class CoreExtension extends AbstractExtension
101. {
102.     public const ARRAY_LIKE_CLASSES = [
103.         'ArrayIterator',
104.         'ArrayObject',
105.         'CachingIterator',
106.         'RecursiveArrayIterator',
107.         'RecursiveCachingIterator',
108.         'SplDoublyLinkedList',
109.         'SplFixedArray',
110.         'SplObjectStorage',
111.         'SplQueue',
112.         'SplStack',
113.         'WeakMap',
114.     ];
116.     private const DEFAULT_TRIM_CHARS = " \t\n\r\0\x0B";
118.     private $dateFormats = ['F j, Y H:i', '%d days'];
119.     private $numberFormat = [0, '.', ','];
120.     private $timezone = null;
122.     /**
123.      * Sets the default format to be used by the date filter.
124.      *
125.      * @param string|null $format             The default date format string
126.      * @param string|null $dateIntervalFormat The default date interval format string
127.      */
128.     public function setDateFormat($format = null, $dateIntervalFormat = null)
129.     {
130.         if (null !== $format) {
131.             $this->dateFormats[0] = $format;
132.         }
134.         if (null !== $dateIntervalFormat) {
135.             $this->dateFormats[1] = $dateIntervalFormat;
136.         }
137.     }
139.     /**
140.      * Gets the default format to be used by the date filter.
141.      *
142.      * @return array The default date format string and the default date interval format string
143.      */
144.     public function getDateFormat()
145.     {
146.         return $this->dateFormats;
147.     }
149.     /**
150.      * Sets the default timezone to be used by the date filter.
151.      *
152.      * @param \DateTimeZone|string $timezone The default timezone string or a \DateTimeZone object
153.      */
154.     public function setTimezone($timezone)
155.     {
156.         $this->timezone = $timezone instanceof \DateTimeZone ? $timezone : new \DateTimeZone($timezone);
157.     }
159.     /**
160.      * Gets the default timezone to be used by the date filter.
161.      *
162.      * @return \DateTimeZone The default timezone currently in use
163.      */
164.     public function getTimezone()
165.     {
166.         if (null === $this->timezone) {
167.             $this->timezone = new \DateTimeZone(date_default_timezone_get());
168.         }
170.         return $this->timezone;
171.     }
173.     /**
174.      * Sets the default format to be used by the number_format filter.
175.      *
176.      * @param int    $decimal      the number of decimal places to use
177.      * @param string $decimalPoint the character(s) to use for the decimal point
178.      * @param string $thousandSep  the character(s) to use for the thousands separator
179.      */
180.     public function setNumberFormat($decimal, $decimalPoint, $thousandSep)
181.     {
182.         $this->numberFormat = [$decimal, $decimalPoint, $thousandSep];
183.     }
185.     /**
186.      * Get the default format used by the number_format filter.
187.      *
188.      * @return array The arguments for number_format()
189.      */
190.     public function getNumberFormat()
191.     {
192.         return $this->numberFormat;
193.     }
195.     public function getTokenParsers(): array
196.     {
197.         return [
198.             new ApplyTokenParser(),
199.             new ForTokenParser(),
200.             new IfTokenParser(),
201.             new ExtendsTokenParser(),
202.             new IncludeTokenParser(),
203.             new BlockTokenParser(),
204.             new UseTokenParser(),
205.             new MacroTokenParser(),
206.             new ImportTokenParser(),
207.             new FromTokenParser(),
208.             new SetTokenParser(),
209.             new TypesTokenParser(),
210.             new FlushTokenParser(),
211.             new DoTokenParser(),
212.             new EmbedTokenParser(),
213.             new WithTokenParser(),
214.             new DeprecatedTokenParser(),
215.             new GuardTokenParser(),
216.         ];
217.     }
219.     public function getFilters(): array
220.     {
221.         return [
222.             // formatting filters
223.             new TwigFilter('date', [$this, 'formatDate']),
224.             new TwigFilter('date_modify', [$this, 'modifyDate']),
225.             new TwigFilter('format', [self::class, 'sprintf']),
226.             new TwigFilter('replace', [self::class, 'replace']),
227.             new TwigFilter('number_format', [$this, 'formatNumber']),
228.             new TwigFilter('abs', 'abs'),
229.             new TwigFilter('round', [self::class, 'round']),
231.             // encoding
232.             new TwigFilter('url_encode', [self::class, 'urlencode']),
233.             new TwigFilter('json_encode', 'json_encode'),
234.             new TwigFilter('convert_encoding', [self::class, 'convertEncoding']),
236.             // string filters
237.             new TwigFilter('title', [self::class, 'titleCase'], ['needs_charset' => true]),
238.             new TwigFilter('capitalize', [self::class, 'capitalize'], ['needs_charset' => true]),
239.             new TwigFilter('upper', [self::class, 'upper'], ['needs_charset' => true]),
240.             new TwigFilter('lower', [self::class, 'lower'], ['needs_charset' => true]),
241.             new TwigFilter('striptags', [self::class, 'striptags']),
242.             new TwigFilter('trim', [self::class, 'trim']),
243.             new TwigFilter('nl2br', [self::class, 'nl2br'], ['pre_escape' => 'html', 'is_safe' => ['html']]),
244.             new TwigFilter('spaceless', [self::class, 'spaceless'], ['is_safe' => ['html'], 'deprecation_info' => new DeprecatedCallableInfo('twig/twig', '3.12')]),
246.             // array helpers
247.             new TwigFilter('join', [self::class, 'join']),
248.             new TwigFilter('split', [self::class, 'split'], ['needs_charset' => true]),
249.             new TwigFilter('sort', [self::class, 'sort'], ['needs_environment' => true]),
250.             new TwigFilter('merge', [self::class, 'merge']),
251.             new TwigFilter('batch', [self::class, 'batch']),
252.             new TwigFilter('column', [self::class, 'column']),
253.             new TwigFilter('filter', [self::class, 'filter'], ['needs_environment' => true]),
254.             new TwigFilter('map', [self::class, 'map'], ['needs_environment' => true]),
255.             new TwigFilter('reduce', [self::class, 'reduce'], ['needs_environment' => true]),
256.             new TwigFilter('find', [self::class, 'find'], ['needs_environment' => true]),
258.             // string/array filters
259.             new TwigFilter('reverse', [self::class, 'reverse'], ['needs_charset' => true]),
260.             new TwigFilter('shuffle', [self::class, 'shuffle'], ['needs_charset' => true]),
261.             new TwigFilter('length', [self::class, 'length'], ['needs_charset' => true]),
262.             new TwigFilter('slice', [self::class, 'slice'], ['needs_charset' => true]),
263.             new TwigFilter('first', [self::class, 'first'], ['needs_charset' => true]),
264.             new TwigFilter('last', [self::class, 'last'], ['needs_charset' => true]),
266.             // iteration and runtime
267.             new TwigFilter('default', [self::class, 'default'], ['node_class' => DefaultFilter::class]),
268.             new TwigFilter('keys', [self::class, 'keys']),
269.             new TwigFilter('invoke', [self::class, 'invoke']),
270.         ];
271.     }
273.     public function getFunctions(): array
274.     {
275.         return [
276.             new TwigFunction('parent', null, ['parser_callable' => [self::class, 'parseParentFunction']]),
277.             new TwigFunction('block', null, ['parser_callable' => [self::class, 'parseBlockFunction']]),
278.             new TwigFunction('attribute', null, ['parser_callable' => [self::class, 'parseAttributeFunction']]),
279.             new TwigFunction('max', 'max'),
280.             new TwigFunction('min', 'min'),
281.             new TwigFunction('range', 'range'),
282.             new TwigFunction('constant', [self::class, 'constant']),
283.             new TwigFunction('cycle', [self::class, 'cycle']),
284.             new TwigFunction('random', [self::class, 'random'], ['needs_charset' => true]),
285.             new TwigFunction('date', [$this, 'convertDate']),
286.             new TwigFunction('include', [self::class, 'include'], ['needs_environment' => true, 'needs_context' => true, 'is_safe' => ['all']]),
287.             new TwigFunction('source', [self::class, 'source'], ['needs_environment' => true, 'is_safe' => ['all']]),
288.             new TwigFunction('enum_cases', [self::class, 'enumCases'], ['node_class' => EnumCasesFunction::class]),
289.             new TwigFunction('enum', [self::class, 'enum'], ['node_class' => EnumFunction::class]),
290.         ];
291.     }
293.     public function getTests(): array
294.     {
295.         return [
296.             new TwigTest('even', null, ['node_class' => EvenTest::class]),
297.             new TwigTest('odd', null, ['node_class' => OddTest::class]),
298.             new TwigTest('defined', null, ['node_class' => DefinedTest::class]),
299.             new TwigTest('same as', null, ['node_class' => SameasTest::class, 'one_mandatory_argument' => true]),
300.             new TwigTest('none', null, ['node_class' => NullTest::class]),
301.             new TwigTest('null', null, ['node_class' => NullTest::class]),
302.             new TwigTest('divisible by', null, ['node_class' => DivisiblebyTest::class, 'one_mandatory_argument' => true]),
303.             new TwigTest('constant', null, ['node_class' => ConstantTest::class]),
304.             new TwigTest('empty', [self::class, 'testEmpty']),
305.             new TwigTest('iterable', 'is_iterable'),
306.             new TwigTest('sequence', [self::class, 'testSequence']),
307.             new TwigTest('mapping', [self::class, 'testMapping']),
308.         ];
309.     }
311.     public function getNodeVisitors(): array
312.     {
313.         return [];
314.     }
316.     public function getOperators(): array
317.     {
318.         return [
319.             [
320.                 'not' => ['precedence' => 50, 'precedence_change' => new OperatorPrecedenceChange('twig/twig', '3.15', 70), 'class' => NotUnary::class],
321.                 '-' => ['precedence' => 500, 'class' => NegUnary::class],
322.                 '+' => ['precedence' => 500, 'class' => PosUnary::class],
323.             ],
324.             [
325.                 '? :' => ['precedence' => 5, 'class' => ElvisBinary::class, 'associativity' => ExpressionParser::OPERATOR_RIGHT],
326.                 '?:' => ['precedence' => 5, 'class' => ElvisBinary::class, 'associativity' => ExpressionParser::OPERATOR_RIGHT],
327.                 '??' => ['precedence' => 300, 'precedence_change' => new OperatorPrecedenceChange('twig/twig', '3.15', 5), 'class' => NullCoalesceBinary::class, 'associativity' => ExpressionParser::OPERATOR_RIGHT],
328.                 'or' => ['precedence' => 10, 'class' => OrBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
329.                 'xor' => ['precedence' => 12, 'class' => XorBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
330.                 'and' => ['precedence' => 15, 'class' => AndBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
331.                 'b-or' => ['precedence' => 16, 'class' => BitwiseOrBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
332.                 'b-xor' => ['precedence' => 17, 'class' => BitwiseXorBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
333.                 'b-and' => ['precedence' => 18, 'class' => BitwiseAndBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
334.                 '==' => ['precedence' => 20, 'class' => EqualBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
335.                 '!=' => ['precedence' => 20, 'class' => NotEqualBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
336.                 '<=>' => ['precedence' => 20, 'class' => SpaceshipBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
337.                 '<' => ['precedence' => 20, 'class' => LessBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
338.                 '>' => ['precedence' => 20, 'class' => GreaterBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
339.                 '>=' => ['precedence' => 20, 'class' => GreaterEqualBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
340.                 '<=' => ['precedence' => 20, 'class' => LessEqualBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
341.                 'not in' => ['precedence' => 20, 'class' => NotInBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
342.                 'in' => ['precedence' => 20, 'class' => InBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
343.                 'matches' => ['precedence' => 20, 'class' => MatchesBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
344.                 'starts with' => ['precedence' => 20, 'class' => StartsWithBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
345.                 'ends with' => ['precedence' => 20, 'class' => EndsWithBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
346.                 'has some' => ['precedence' => 20, 'class' => HasSomeBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
347.                 'has every' => ['precedence' => 20, 'class' => HasEveryBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
348.                 '..' => ['precedence' => 25, 'class' => RangeBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
349.                 '+' => ['precedence' => 30, 'class' => AddBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
350.                 '-' => ['precedence' => 30, 'class' => SubBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
351.                 '~' => ['precedence' => 40, 'precedence_change' => new OperatorPrecedenceChange('twig/twig', '3.15', 27), 'class' => ConcatBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
352.                 '*' => ['precedence' => 60, 'class' => MulBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
353.                 '/' => ['precedence' => 60, 'class' => DivBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
354.                 '//' => ['precedence' => 60, 'class' => FloorDivBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
355.                 '%' => ['precedence' => 60, 'class' => ModBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
356.                 'is' => ['precedence' => 100, 'associativity' => ExpressionParser::OPERATOR_LEFT],
357.                 'is not' => ['precedence' => 100, 'associativity' => ExpressionParser::OPERATOR_LEFT],
358.                 '**' => ['precedence' => 200, 'class' => PowerBinary::class, 'associativity' => ExpressionParser::OPERATOR_RIGHT],
359.             ],
360.         ];
361.     }
363.     /**
364.      * Cycles over a sequence.
365.      *
366.      * @param array|\ArrayAccess $values   A non-empty sequence of values
367.      * @param int<0, max>        $position The position of the value to return in the cycle
368.      *
369.      * @return mixed The value at the given position in the sequence, wrapping around as needed
370.      *
371.      * @internal
372.      */
373.     public static function cycle($values, $position): mixed
374.     {
375.         if (!\is_array($values)) {
376.             if (!$values instanceof \ArrayAccess) {
377.                 throw new RuntimeError('The "cycle" function expects an array or "ArrayAccess" as first argument.');
378.             }
380.             if (!is_countable($values)) {
381.                 // To be uncommented in 4.0
382.                 // throw new RuntimeError('The "cycle" function expects a countable sequence as first argument.');
384.                 trigger_deprecation('twig/twig', '3.12', 'Passing a non-countable sequence of values to "%s()" is deprecated.', __METHOD__);
386.                 return $values;
387.             }
389.             $values = self::toArray($values, false);
390.         }
392.         if (!$count = \count($values)) {
393.             throw new RuntimeError('The "cycle" function expects a non-empty sequence.');
394.         }
396.         return $values[$position % $count];
397.     }
399.     /**
400.      * Returns a random value depending on the supplied parameter type:
401.      * - a random item from a \Traversable or array
402.      * - a random character from a string
403.      * - a random integer between 0 and the integer parameter.
404.      *
405.      * @param \Traversable|array|int|float|string $values The values to pick a random item from
406.      * @param int|null                            $max    Maximum value used when $values is an int
407.      *
408.      * @return mixed A random value from the given sequence
409.      *
410.      * @throws RuntimeError when $values is an empty array (does not apply to an empty string which is returned as is)
411.      *
412.      * @internal
413.      */
414.     public static function random(string $charset, $values = null, $max = null)
415.     {
416.         if (null === $values) {
417.             return null === $max ? mt_rand() : mt_rand(0, (int) $max);
418.         }
420.         if (\is_int($values) || \is_float($values)) {
421.             if (null === $max) {
422.                 if ($values < 0) {
423.                     $max = 0;
424.                     $min = $values;
425.                 } else {
426.                     $max = $values;
427.                     $min = 0;
428.                 }
429.             } else {
430.                 $min = $values;
431.             }
433.             return mt_rand((int) $min, (int) $max);
434.         }
436.         if (\is_string($values)) {
437.             if ('' === $values) {
438.                 return '';
439.             }
441.             if ('UTF-8' !== $charset) {
442.                 $values = self::convertEncoding($values, 'UTF-8', $charset);
443.             }
445.             // unicode version of str_split()
446.             // split at all positions, but not after the start and not before the end
447.             $values = preg_split('/(?<!^)(?!$)/u', $values);
449.             if ('UTF-8' !== $charset) {
450.                 foreach ($values as $i => $value) {
451.                     $values[$i] = self::convertEncoding($value, $charset, 'UTF-8');
452.                 }
453.             }
454.         }
456.         if (!is_iterable($values)) {
457.             return $values;
458.         }
460.         $values = self::toArray($values);
462.         if (0 === \count($values)) {
463.             throw new RuntimeError('The "random" function cannot pick from an empty sequence or mapping.');
464.         }
466.         return $values[array_rand($values, 1)];
467.     }
469.     /**
470.      * Formats a date.
471.      *
472.      *   {{ post.published_at|date("m/d/Y") }}
473.      *
474.      * @param \DateTimeInterface|\DateInterval|string|int|null $date     A date, a timestamp or null to use the current time
475.      * @param string|null                                      $format   The target format, null to use the default
476.      * @param \DateTimeZone|string|false|null                  $timezone The target timezone, null to use the default, false to leave unchanged
477.      */
478.     public function formatDate($date, $format = null, $timezone = null): string
479.     {
480.         if (null === $format) {
481.             $formats = $this->getDateFormat();
482.             $format = $date instanceof \DateInterval ? $formats[1] : $formats[0];
483.         }
485.         if ($date instanceof \DateInterval) {
486.             return $date->format($format);
487.         }
489.         return $this->convertDate($date, $timezone)->format($format);
490.     }
492.     /**
493.      * Returns a new date object modified.
494.      *
495.      *   {{ post.published_at|date_modify("-1day")|date("m/d/Y") }}
496.      *
497.      * @param \DateTimeInterface|string|int|null $date     A date, a timestamp or null to use the current time
498.      * @param string                             $modifier A modifier string
499.      *
500.      * @return \DateTime|\DateTimeImmutable
501.      *
502.      * @internal
503.      */
504.     public function modifyDate($date, $modifier)
505.     {
506.         return $this->convertDate($date, false)->modify($modifier);
507.     }
509.     /**
510.      * Returns a formatted string.
511.      *
512.      * @param string|null $format
513.      * @param ...$values
514.      *
515.      * @internal
516.      */
517.     public static function sprintf($format, ...$values): string
518.     {
519.         return \sprintf($format ?? '', ...$values);
520.     }
522.     /**
523.      * @internal
524.      */
525.     public static function dateConverter(Environment $env, $date, $format = null, $timezone = null): string
526.     {
527.         return $env->getExtension(self::class)->formatDate($date, $format, $timezone);
528.     }
530.     /**
531.      * Converts an input to a \DateTime instance.
532.      *
533.      *    {% if date(user.created_at) < date('+2days') %}
534.      *      {# do something #}
535.      *    {% endif %}
536.      *
537.      * @param \DateTimeInterface|string|int|null $date     A date, a timestamp or null to use the current time
538.      * @param \DateTimeZone|string|false|null    $timezone The target timezone, null to use the default, false to leave unchanged
539.      *
540.      * @return \DateTime|\DateTimeImmutable
541.      */
542.     public function convertDate($date = null, $timezone = null)
543.     {
544.         // determine the timezone
545.         if (false !== $timezone) {
546.             if (null === $timezone) {
547.                 $timezone = $this->getTimezone();
548.             } elseif (!$timezone instanceof \DateTimeZone) {
549.                 $timezone = new \DateTimeZone($timezone);
550.             }
551.         }
553.         // immutable dates
554.         if ($date instanceof \DateTimeImmutable) {
555.             return false !== $timezone ? $date->setTimezone($timezone) : $date;
556.         }
558.         if ($date instanceof \DateTime) {
559.             $date = clone $date;
560.             if (false !== $timezone) {
561.                 $date->setTimezone($timezone);
562.             }
564.             return $date;
565.         }
567.         if (null === $date || 'now' === $date) {
568.             if (null === $date) {
569.                 $date = 'now';
570.             }
572.             return new \DateTime($date, false !== $timezone ? $timezone : $this->getTimezone());
573.         }
575.         $asString = (string) $date;
576.         if (ctype_digit($asString) || ('' !== $asString && '-' === $asString[0] && ctype_digit(substr($asString, 1)))) {
577.             $date = new \DateTime('@'.$date);
578.         } else {
579.             $date = new \DateTime($date);
580.         }
582.         if (false !== $timezone) {
583.             $date->setTimezone($timezone);
584.         }
586.         return $date;
587.     }
589.     /**
590.      * Replaces strings within a string.
591.      *
592.      * @param string|null        $str  String to replace in
593.      * @param array|\Traversable $from Replace values
594.      *
595.      * @internal
596.      */
597.     public static function replace($str, $from): string
598.     {
599.         if (!is_iterable($from)) {
600.             throw new RuntimeError(\sprintf('The "replace" filter expects a sequence or a mapping, got "%s".', get_debug_type($from)));
601.         }
603.         return strtr($str ?? '', self::toArray($from));
604.     }
606.     /**
607.      * Rounds a number.
608.      *
609.      * @param int|float|string|null   $value     The value to round
610.      * @param int|float               $precision The rounding precision
611.      * @param 'common'|'ceil'|'floor' $method    The method to use for rounding
612.      *
613.      * @return float The rounded number
614.      *
615.      * @internal
616.      */
617.     public static function round($value, $precision = 0, $method = 'common')
618.     {
619.         $value = (float) $value;
621.         if ('common' === $method) {
622.             return round($value, $precision);
623.         }
625.         if ('ceil' !== $method && 'floor' !== $method) {
626.             throw new RuntimeError('The "round" filter only supports the "common", "ceil", and "floor" methods.');
627.         }
629.         return $method($value * 10 ** $precision) / 10 ** $precision;
630.     }
632.     /**
633.      * Formats a number.
634.      *
635.      * All of the formatting options can be left null, in that case the defaults will
636.      * be used. Supplying any of the parameters will override the defaults set in the
637.      * environment object.
638.      *
639.      * @param mixed       $number       A float/int/string of the number to format
640.      * @param int|null    $decimal      the number of decimal points to display
641.      * @param string|null $decimalPoint the character(s) to use for the decimal point
642.      * @param string|null $thousandSep  the character(s) to use for the thousands separator
643.      */
644.     public function formatNumber($number, $decimal = null, $decimalPoint = null, $thousandSep = null): string
645.     {
646.         $defaults = $this->getNumberFormat();
647.         if (null === $decimal) {
648.             $decimal = $defaults[0];
649.         }
651.         if (null === $decimalPoint) {
652.             $decimalPoint = $defaults[1];
653.         }
655.         if (null === $thousandSep) {
656.             $thousandSep = $defaults[2];
657.         }
659.         return number_format((float) $number, $decimal, $decimalPoint, $thousandSep);
660.     }
662.     /**
663.      * URL encodes (RFC 3986) a string as a path segment or an array as a query string.
664.      *
665.      * @param string|array|null $url A URL or an array of query parameters
666.      *
667.      * @internal
668.      */
669.     public static function urlencode($url): string
670.     {
671.         if (\is_array($url)) {
672.             return http_build_query($url, '', '&', \PHP_QUERY_RFC3986);
673.         }
675.         return rawurlencode($url ?? '');
676.     }
678.     /**
679.      * Merges any number of arrays or Traversable objects.
680.      *
681.      *  {% set items = { 'apple': 'fruit', 'orange': 'fruit' } %}
682.      *
683.      *  {% set items = items|merge({ 'peugeot': 'car' }, { 'banana': 'fruit' }) %}
684.      *
685.      *  {# items now contains { 'apple': 'fruit', 'orange': 'fruit', 'peugeot': 'car', 'banana': 'fruit' } #}
686.      *
687.      * @param array|\Traversable ...$arrays Any number of arrays or Traversable objects to merge
688.      *
689.      * @internal
690.      */
691.     public static function merge(...$arrays): array
692.     {
693.         $result = [];
695.         foreach ($arrays as $argNumber => $array) {
696.             if (!is_iterable($array)) {
697.                 throw new RuntimeError(\sprintf('The "merge" filter expects a sequence or a mapping, got "%s" for argument %d.', get_debug_type($array), $argNumber + 1));
698.             }
700.             $result = array_merge($result, self::toArray($array));
701.         }
703.         return $result;
704.     }
706.     /**
707.      * Slices a variable.
708.      *
709.      * @param mixed $item         A variable
710.      * @param int   $start        Start of the slice
711.      * @param int   $length       Size of the slice
712.      * @param bool  $preserveKeys Whether to preserve key or not (when the input is an array)
713.      *
714.      * @return mixed The sliced variable
715.      *
716.      * @internal
717.      */
718.     public static function slice(string $charset, $item, $start, $length = null, $preserveKeys = false)
719.     {
720.         if ($item instanceof \Traversable) {
721.             while ($item instanceof \IteratorAggregate) {
722.                 $item = $item->getIterator();
723.             }
725.             if ($start >= 0 && $length >= 0 && $item instanceof \Iterator) {
726.                 try {
727.                     return iterator_to_array(new \LimitIterator($item, $start, $length ?? -1), $preserveKeys);
728.                 } catch (\OutOfBoundsException $e) {
729.                     return [];
730.                 }
731.             }
733.             $item = iterator_to_array($item, $preserveKeys);
734.         }
736.         if (\is_array($item)) {
737.             return \array_slice($item, $start, $length, $preserveKeys);
738.         }
740.         return mb_substr((string) $item, $start, $length, $charset);
741.     }
743.     /**
744.      * Returns the first element of the item.
745.      *
746.      * @param mixed $item A variable
747.      *
748.      * @return mixed The first element of the item
749.      *
750.      * @internal
751.      */
752.     public static function first(string $charset, $item)
753.     {
754.         $elements = self::slice($charset, $item, 0, 1, false);
756.         return \is_string($elements) ? $elements : current($elements);
757.     }
759.     /**
760.      * Returns the last element of the item.
761.      *
762.      * @param mixed $item A variable
763.      *
764.      * @return mixed The last element of the item
765.      *
766.      * @internal
767.      */
768.     public static function last(string $charset, $item)
769.     {
770.         $elements = self::slice($charset, $item, -1, 1, false);
772.         return \is_string($elements) ? $elements : current($elements);
773.     }
775.     /**
776.      * Joins the values to a string.
777.      *
778.      * The separators between elements are empty strings per default, you can define them with the optional parameters.
779.      *
780.      *  {{ [1, 2, 3]|join(', ', ' and ') }}
781.      *  {# returns 1, 2 and 3 #}
782.      *
783.      *  {{ [1, 2, 3]|join('|') }}
784.      *  {# returns 1|2|3 #}
785.      *
786.      *  {{ [1, 2, 3]|join }}
787.      *  {# returns 123 #}
788.      *
789.      * @param iterable|array|string|float|int|bool|null $value An array
790.      * @param string                                    $glue  The separator
791.      * @param string|null                               $and   The separator for the last pair
792.      *
793.      * @internal
794.      */
795.     public static function join($value, $glue = '', $and = null): string
796.     {
797.         if (!is_iterable($value)) {
798.             $value = (array) $value;
799.         }
801.         $value = self::toArray($value, false);
803.         if (0 === \count($value)) {
804.             return '';
805.         }
807.         if (null === $and || $and === $glue) {
808.             return implode($glue, $value);
809.         }
811.         if (1 === \count($value)) {
812.             return $value[0];
813.         }
815.         return implode($glue, \array_slice($value, 0, -1)).$and.$value[\count($value) - 1];
816.     }
818.     /**
819.      * Splits the string into an array.
820.      *
821.      *  {{ "one,two,three"|split(',') }}
822.      *  {# returns [one, two, three] #}
823.      *
824.      *  {{ "one,two,three,four,five"|split(',', 3) }}
825.      *  {# returns [one, two, "three,four,five"] #}
826.      *
827.      *  {{ "123"|split('') }}
828.      *  {# returns [1, 2, 3] #}
829.      *
830.      *  {{ "aabbcc"|split('', 2) }}
831.      *  {# returns [aa, bb, cc] #}
832.      *
833.      * @param string|null $value     A string
834.      * @param string      $delimiter The delimiter
835.      * @param int|null    $limit     The limit
836.      *
837.      * @internal
838.      */
839.     public static function split(string $charset, $value, $delimiter, $limit = null): array
840.     {
841.         $value = $value ?? '';
843.         if ('' !== $delimiter) {
844.             return null === $limit ? explode($delimiter, $value) : explode($delimiter, $value, $limit);
845.         }
847.         if ($limit <= 1) {
848.             return preg_split('/(?<!^)(?!$)/u', $value);
849.         }
851.         $length = mb_strlen($value, $charset);
852.         if ($length < $limit) {
853.             return [$value];
854.         }
856.         $r = [];
857.         for ($i = 0; $i < $length; $i += $limit) {
858.             $r[] = mb_substr($value, $i, $limit, $charset);
859.         }
861.         return $r;
862.     }
864.     /**
865.      * @internal
866.      */
867.     public static function default($value, $default = '')
868.     {
869.         if (self::testEmpty($value)) {
870.             return $default;
871.         }
873.         return $value;
874.     }
876.     /**
877.      * Returns the keys for the given array.
878.      *
879.      * It is useful when you want to iterate over the keys of an array:
880.      *
881.      *  {% for key in array|keys %}
882.      *      {# ... #}
883.      *  {% endfor %}
884.      *
885.      * @internal
886.      */
887.     public static function keys($array): array
888.     {
889.         if ($array instanceof \Traversable) {
890.             while ($array instanceof \IteratorAggregate) {
891.                 $array = $array->getIterator();
892.             }
894.             $keys = [];
895.             if ($array instanceof \Iterator) {
896.                 $array->rewind();
897.                 while ($array->valid()) {
898.                     $keys[] = $array->key();
899.                     $array->next();
900.                 }
902.                 return $keys;
903.             }
905.             foreach ($array as $key => $item) {
906.                 $keys[] = $key;
907.             }
909.             return $keys;
910.         }
912.         if (!\is_array($array)) {
913.             return [];
914.         }
916.         return array_keys($array);
917.     }
919.     /**
920.      * Invokes a callable.
921.      *
922.      * @internal
923.      */
924.     public static function invoke(\Closure $arrow, ...$arguments): mixed
925.     {
926.         return $arrow(...$arguments);
927.     }
929.     /**
930.      * Reverses a variable.
931.      *
932.      * @param array|\Traversable|string|null $item         An array, a \Traversable instance, or a string
933.      * @param bool                           $preserveKeys Whether to preserve key or not
934.      *
935.      * @return mixed The reversed input
936.      *
937.      * @internal
938.      */
939.     public static function reverse(string $charset, $item, $preserveKeys = false)
940.     {
941.         if ($item instanceof \Traversable) {
942.             return array_reverse(iterator_to_array($item), $preserveKeys);
943.         }
945.         if (\is_array($item)) {
946.             return array_reverse($item, $preserveKeys);
947.         }
949.         $string = (string) $item;
951.         if ('UTF-8' !== $charset) {
952.             $string = self::convertEncoding($string, 'UTF-8', $charset);
953.         }
955.         preg_match_all('/./us', $string, $matches);
957.         $string = implode('', array_reverse($matches[0]));
959.         if ('UTF-8' !== $charset) {
960.             $string = self::convertEncoding($string, $charset, 'UTF-8');
961.         }
963.         return $string;
964.     }
966.     /**
967.      * Shuffles an array, a \Traversable instance, or a string.
968.      * The function does not preserve keys.
969.      *
970.      * @param array|\Traversable|string|null $item
971.      *
972.      * @return mixed
973.      *
974.      * @internal
975.      */
976.     public static function shuffle(string $charset, $item)
977.     {
978.         if (\is_string($item)) {
979.             if ('UTF-8' !== $charset) {
980.                 $item = self::convertEncoding($item, 'UTF-8', $charset);
981.             }
983.             $item = preg_split('/(?<!^)(?!$)/u', $item, -1);
984.             shuffle($item);
985.             $item = implode('', $item);
987.             if ('UTF-8' !== $charset) {
988.                 $item = self::convertEncoding($item, $charset, 'UTF-8');
989.             }
991.             return $item;
992.         }
994.         if (is_iterable($item)) {
995.             $item = self::toArray($item, false);
996.             shuffle($item);
997.         }
999.         return $item;
1000.     }
1002.     /**
1003.      * Sorts an array.
1004.      *
1005.      * @param array|\Traversable $array
1006.      * @param ?\Closure          $arrow
1007.      *
1008.      * @internal
1009.      */
1010.     public static function sort(Environment $env, $array, $arrow = null): array
1011.     {
1012.         if ($array instanceof \Traversable) {
1013.             $array = iterator_to_array($array);
1014.         } elseif (!\is_array($array)) {
1015.             throw new RuntimeError(\sprintf('The "sort" filter expects a sequence or a mapping, got "%s".', get_debug_type($array)));
1016.         }
1018.         if (null !== $arrow) {
1019.             self::checkArrow($env, $arrow, 'sort', 'filter');
1021.             uasort($array, $arrow);
1022.         } else {
1023.             asort($array);
1024.         }
1026.         return $array;
1027.     }
1029.     /**
1030.      * @internal
1031.      */
1032.     public static function inFilter($value, $compare)
1033.     {
1034.         if ($value instanceof Markup) {
1035.             $value = (string) $value;
1036.         }
1037.         if ($compare instanceof Markup) {
1038.             $compare = (string) $compare;
1039.         }
1041.         if (\is_string($compare)) {
1042.             if (\is_string($value) || \is_int($value) || \is_float($value)) {
1043.                 return '' === $value || str_contains($compare, (string) $value);
1044.             }
1046.             return false;
1047.         }
1049.         if (!is_iterable($compare)) {
1050.             return false;
1051.         }
1053.         if (\is_object($value) || \is_resource($value)) {
1054.             if (!\is_array($compare)) {
1055.                 foreach ($compare as $item) {
1056.                     if ($item === $value) {
1057.                         return true;
1058.                     }
1059.                 }
1061.                 return false;
1062.             }
1064.             return \in_array($value, $compare, true);
1065.         }
1067.         foreach ($compare as $item) {
1068.             if (0 === self::compare($value, $item)) {
1069.                 return true;
1070.             }
1071.         }
1073.         return false;
1074.     }
1076.     /**
1077.      * Compares two values using a more strict version of the PHP non-strict comparison operator.
1078.      *
1079.      * @see https://wiki.php.net/rfc/string_to_number_comparison
1080.      * @see https://wiki.php.net/rfc/trailing_whitespace_numerics
1081.      *
1082.      * @internal
1083.      */
1084.     public static function compare($a, $b)
1085.     {
1086.         // int <=> string
1087.         if (\is_int($a) && \is_string($b)) {
1088.             $bTrim = trim($b, " \t\n\r\v\f");
1089.             if (!is_numeric($bTrim)) {
1090.                 return (string) $a <=> $b;
1091.             }
1092.             if ((int) $bTrim == $bTrim) {
1093.                 return $a <=> (int) $bTrim;
1094.             } else {
1095.                 return (float) $a <=> (float) $bTrim;
1096.             }
1097.         }
1098.         if (\is_string($a) && \is_int($b)) {
1099.             $aTrim = trim($a, " \t\n\r\v\f");
1100.             if (!is_numeric($aTrim)) {
1101.                 return $a <=> (string) $b;
1102.             }
1103.             if ((int) $aTrim == $aTrim) {
1104.                 return (int) $aTrim <=> $b;
1105.             } else {
1106.                 return (float) $aTrim <=> (float) $b;
1107.             }
1108.         }
1110.         // float <=> string
1111.         if (\is_float($a) && \is_string($b)) {
1112.             if (is_nan($a)) {
1113.                 return 1;
1114.             }
1115.             $bTrim = trim($b, " \t\n\r\v\f");
1116.             if (!is_numeric($bTrim)) {
1117.                 return (string) $a <=> $b;
1118.             }
1120.             return $a <=> (float) $bTrim;
1121.         }
1122.         if (\is_string($a) && \is_float($b)) {
1123.             if (is_nan($b)) {
1124.                 return 1;
1125.             }
1126.             $aTrim = trim($a, " \t\n\r\v\f");
1127.             if (!is_numeric($aTrim)) {
1128.                 return $a <=> (string) $b;
1129.             }
1131.             return (float) $aTrim <=> $b;
1132.         }
1134.         // fallback to <=>
1135.         return $a <=> $b;
1136.     }
1138.     /**
1139.      * @throws RuntimeError When an invalid pattern is used
1140.      *
1141.      * @internal
1142.      */
1143.     public static function matches(string $regexp, ?string $str): int
1144.     {
1145.         set_error_handler(function ($t, $m) use ($regexp) {
1146.             throw new RuntimeError(\sprintf('Regexp "%s" passed to "matches" is not valid', $regexp).substr($m, 12));
1147.         });
1148.         try {
1149.             return preg_match($regexp, $str ?? '');
1150.         } finally {
1151.             restore_error_handler();
1152.         }
1153.     }
1155.     /**
1156.      * Returns a trimmed string.
1157.      *
1158.      * @param string|\Stringable|null $string
1159.      * @param string|null             $characterMask
1160.      * @param string                  $side          left, right, or both
1161.      *
1162.      * @throws RuntimeError When an invalid trimming side is used
1163.      *
1164.      * @internal
1165.      */
1166.     public static function trim($string, $characterMask = null, $side = 'both'): string|\Stringable
1167.     {
1168.         if (null === $characterMask) {
1169.             $characterMask = self::DEFAULT_TRIM_CHARS;
1170.         }
1172.         $trimmed = match ($side) {
1173.             'both' => trim($string ?? '', $characterMask),
1174.             'left' => ltrim($string ?? '', $characterMask),
1175.             'right' => rtrim($string ?? '', $characterMask),
1176.             default => throw new RuntimeError('Trimming side must be "left", "right" or "both".'),
1177.         };
1179.         // trimming a safe string with the default character mask always returns a safe string (independently of the context)
1180.         return $string instanceof Markup && self::DEFAULT_TRIM_CHARS === $characterMask ? new Markup($trimmed, $string->getCharset()) : $trimmed;
1181.     }
1183.     /**
1184.      * Inserts HTML line breaks before all newlines in a string.
1185.      *
1186.      * @param string|null $string
1187.      *
1188.      * @internal
1189.      */
1190.     public static function nl2br($string): string
1191.     {
1192.         return nl2br($string ?? '');
1193.     }
1195.     /**
1196.      * Removes whitespaces between HTML tags.
1197.      *
1198.      * @param string|null $content
1199.      *
1200.      * @internal
1201.      */
1202.     public static function spaceless($content): string
1203.     {
1204.         return trim(preg_replace('/>\s+</', '><', $content ?? ''));
1205.     }
1207.     /**
1208.      * @param string|null $string
1209.      * @param string      $to
1210.      * @param string      $from
1211.      *
1212.      * @internal
1213.      */
1214.     public static function convertEncoding($string, $to, $from): string
1215.     {
1216.         if (!\function_exists('iconv')) {
1217.             throw new RuntimeError('Unable to convert encoding: required function iconv() does not exist. You should install ext-iconv or symfony/polyfill-iconv.');
1218.         }
1220.         return iconv($from, $to, $string ?? '');
1221.     }
1223.     /**
1224.      * Returns the length of a variable.
1225.      *
1226.      * @param mixed $thing A variable
1227.      *
1228.      * @internal
1229.      */
1230.     public static function length(string $charset, $thing): int
1231.     {
1232.         if (null === $thing) {
1233.             return 0;
1234.         }
1236.         if (\is_scalar($thing)) {
1237.             return mb_strlen($thing, $charset);
1238.         }
1240.         if ($thing instanceof \Countable || \is_array($thing) || $thing instanceof \SimpleXMLElement) {
1241.             return \count($thing);
1242.         }
1244.         if ($thing instanceof \Traversable) {
1245.             return iterator_count($thing);
1246.         }
1248.         if ($thing instanceof \Stringable) {
1249.             return mb_strlen((string) $thing, $charset);
1250.         }
1252.         return 1;
1253.     }
1255.     /**
1256.      * Converts a string to uppercase.
1257.      *
1258.      * @param string|null $string A string
1259.      *
1260.      * @internal
1261.      */
1262.     public static function upper(string $charset, $string): string
1263.     {
1264.         return mb_strtoupper($string ?? '', $charset);
1265.     }
1267.     /**
1268.      * Converts a string to lowercase.
1269.      *
1270.      * @param string|null $string A string
1271.      *
1272.      * @internal
1273.      */
1274.     public static function lower(string $charset, $string): string
1275.     {
1276.         return mb_strtolower($string ?? '', $charset);
1277.     }
1279.     /**
1280.      * Strips HTML and PHP tags from a string.
1281.      *
1282.      * @param string|null          $string
1283.      * @param string[]|string|null $allowable_tags
1284.      *
1285.      * @internal
1286.      */
1287.     public static function striptags($string, $allowable_tags = null): string
1288.     {
1289.         return strip_tags($string ?? '', $allowable_tags);
1290.     }
1292.     /**
1293.      * Returns a titlecased string.
1294.      *
1295.      * @param string|null $string A string
1296.      *
1297.      * @internal
1298.      */
1299.     public static function titleCase(string $charset, $string): string
1300.     {
1301.         return mb_convert_case($string ?? '', \MB_CASE_TITLE, $charset);
1302.     }
1304.     /**
1305.      * Returns a capitalized string.
1306.      *
1307.      * @param string|null $string A string
1308.      *
1309.      * @internal
1310.      */
1311.     public static function capitalize(string $charset, $string): string
1312.     {
1313.         return mb_strtoupper(mb_substr($string ?? '', 0, 1, $charset), $charset).mb_strtolower(mb_substr($string ?? '', 1, null, $charset), $charset);
1314.     }
1316.     /**
1317.      * @internal
1318.      *
1319.      * to be removed in 4.0
1320.      */
1321.     public static function callMacro(Template $template, string $method, array $args, int $lineno, array $context, Source $source)
1322.     {
1323.         if (!method_exists($template, $method)) {
1324.             $parent = $template;
1325.             while ($parent = $parent->getParent($context)) {
1326.                 if (method_exists($parent, $method)) {
1327.                     return $parent->$method(...$args);
1328.                 }
1329.             }
1331.             throw new RuntimeError(\sprintf('Macro "%s" is not defined in template "%s".', substr($method, \strlen('macro_')), $template->getTemplateName()), $lineno, $source);
1332.         }
1334.         return $template->$method(...$args);
1335.     }
1337.     /**
1338.      * @template TSequence
1339.      *
1340.      * @param TSequence $seq
1341.      *
1342.      * @return ($seq is iterable ? TSequence : array{})
1343.      *
1344.      * @internal
1345.      */
1346.     public static function ensureTraversable($seq)
1347.     {
1348.         if (is_iterable($seq)) {
1349.             return $seq;
1350.         }
1352.         return [];
1353.     }
1355.     /**
1356.      * @internal
1357.      */
1358.     public static function toArray($seq, $preserveKeys = true)
1359.     {
1360.         if ($seq instanceof \Traversable) {
1361.             return iterator_to_array($seq, $preserveKeys);
1362.         }
1364.         if (!\is_array($seq)) {
1365.             return $seq;
1366.         }
1368.         return $preserveKeys ? $seq : array_values($seq);
1369.     }
1371.     /**
1372.      * Checks if a variable is empty.
1373.      *
1374.      *    {# evaluates to true if the foo variable is null, false, or the empty string #}
1375.      *    {% if foo is empty %}
1376.      *        {# ... #}
1377.      *    {% endif %}
1378.      *
1379.      * @param mixed $value A variable
1380.      *
1381.      * @internal
1382.      */
1383.     public static function testEmpty($value): bool
1384.     {
1385.         if ($value instanceof \Countable) {
1386.             return 0 === \count($value);
1387.         }
1389.         if ($value instanceof \Traversable) {
1390.             return !iterator_count($value);
1391.         }
1393.         if ($value instanceof \Stringable) {
1394.             return '' === (string) $value;
1395.         }
1397.         return '' === $value || false === $value || null === $value || [] === $value;
1398.     }
1400.     /**
1401.      * Checks if a variable is a sequence.
1402.      *
1403.      *    {# evaluates to true if the foo variable is a sequence #}
1404.      *    {% if foo is sequence %}
1405.      *        {# ... #}
1406.      *    {% endif %}
1407.      *
1408.      * @param mixed $value
1409.      *
1410.      * @internal
1411.      */
1412.     public static function testSequence($value): bool
1413.     {
1414.         if ($value instanceof \ArrayObject) {
1415.             $value = $value->getArrayCopy();
1416.         }
1418.         if ($value instanceof \Traversable) {
1419.             $value = iterator_to_array($value);
1420.         }
1422.         return \is_array($value) && array_is_list($value);
1423.     }
1425.     /**
1426.      * Checks if a variable is a mapping.
1427.      *
1428.      *    {# evaluates to true if the foo variable is a mapping #}
1429.      *    {% if foo is mapping %}
1430.      *        {# ... #}
1431.      *    {% endif %}
1432.      *
1433.      * @param mixed $value
1434.      *
1435.      * @internal
1436.      */
1437.     public static function testMapping($value): bool
1438.     {
1439.         if ($value instanceof \ArrayObject) {
1440.             $value = $value->getArrayCopy();
1441.         }
1443.         if ($value instanceof \Traversable) {
1444.             $value = iterator_to_array($value);
1445.         }
1447.         return (\is_array($value) && !array_is_list($value)) || \is_object($value);
1448.     }
1450.     /**
1451.      * Renders a template.
1452.      *
1453.      * @param array                        $context
1454.      * @param string|array|TemplateWrapper $template      The template to render or an array of templates to try consecutively
1455.      * @param array                        $variables     The variables to pass to the template
1456.      * @param bool                         $withContext
1457.      * @param bool                         $ignoreMissing Whether to ignore missing templates or not
1458.      * @param bool                         $sandboxed     Whether to sandbox the template or not
1459.      *
1460.      * @internal
1461.      */
1462.     public static function include(Environment $env, $context, $template, $variables = [], $withContext = true, $ignoreMissing = false, $sandboxed = false): string
1463.     {
1464.         $alreadySandboxed = false;
1465.         $sandbox = null;
1466.         if ($withContext) {
1467.             $variables = array_merge($context, $variables);
1468.         }
1470.         if ($isSandboxed = $sandboxed && $env->hasExtension(SandboxExtension::class)) {
1471.             $sandbox = $env->getExtension(SandboxExtension::class);
1472.             if (!$alreadySandboxed = $sandbox->isSandboxed()) {
1473.                 $sandbox->enableSandbox();
1474.             }
1475.         }
1477.         try {
1478.             $loaded = null;
1479.             try {
1480.                 $loaded = $env->resolveTemplate($template);
1481.             } catch (LoaderError $e) {
1482.                 if (!$ignoreMissing) {
1483.                     throw $e;
1484.                 }
1486.                 return '';
1487.             }
1489.             if ($isSandboxed) {
1490.                 $loaded->unwrap()->checkSecurity();
1491.             }
1493.             return $loaded->render($variables);
1494.         } finally {
1495.             if ($isSandboxed && !$alreadySandboxed) {
1496.                 $sandbox->disableSandbox();
1497.             }
1498.         }
1499.     }
1501.     /**
1502.      * Returns a template content without rendering it.
1503.      *
1504.      * @param string $name          The template name
1505.      * @param bool   $ignoreMissing Whether to ignore missing templates or not
1506.      *
1507.      * @internal
1508.      */
1509.     public static function source(Environment $env, $name, $ignoreMissing = false): string
1510.     {
1511.         $loader = $env->getLoader();
1512.         try {
1513.             return $loader->getSourceContext($name)->getCode();
1514.         } catch (LoaderError $e) {
1515.             if (!$ignoreMissing) {
1516.                 throw $e;
1517.             }
1519.             return '';
1520.         }
1521.     }
1523.     /**
1524.      * Returns the list of cases of the enum.
1525.      *
1526.      * @template T of \UnitEnum
1527.      *
1528.      * @param class-string<T> $enum
1529.      *
1530.      * @return list<T>
1531.      *
1532.      * @internal
1533.      */
1534.     public static function enumCases(string $enum): array
1535.     {
1536.         if (!enum_exists($enum)) {
1537.             throw new RuntimeError(\sprintf('Enum "%s" does not exist.', $enum));
1538.         }
1540.         return $enum::cases();
1541.     }
1543.     /**
1544.      * Provides the ability to access enums by their class names.
1545.      *
1546.      * @template T of \UnitEnum
1547.      *
1548.      * @param class-string<T> $enum
1549.      *
1550.      * @return T
1551.      *
1552.      * @internal
1553.      */
1554.     public static function enum(string $enum): \UnitEnum
1555.     {
1556.         if (!enum_exists($enum)) {
1557.             throw new RuntimeError(\sprintf('"%s" is not an enum.', $enum));
1558.         }
1560.         if (!$cases = $enum::cases()) {
1561.             throw new RuntimeError(\sprintf('"%s" is an empty enum.', $enum));
1562.         }
1564.         return $cases[0];
1565.     }
1567.     /**
1568.      * Provides the ability to get constants from instances as well as class/global constants.
1569.      *
1570.      * @param string      $constant     The name of the constant
1571.      * @param object|null $object       The object to get the constant from
1572.      * @param bool        $checkDefined Whether to check if the constant is defined or not
1573.      *
1574.      * @return mixed Class constants can return many types like scalars, arrays, and
1575.      *               objects depending on the PHP version (\BackedEnum, \UnitEnum, etc.)
1576.      *               When $checkDefined is true, returns true when the constant is defined, false otherwise
1577.      *
1578.      * @internal
1579.      */
1580.     public static function constant($constant, $object = null, bool $checkDefined = false)
1581.     {
1582.         if (null !== $object) {
1583.             if ('class' === $constant) {
1584.                 return $checkDefined ? true : \get_class($object);
1585.             }
1587.             $constant = \get_class($object).'::'.$constant;
1588.         }
1590.         if (!\defined($constant)) {
1591.             if ($checkDefined) {
1592.                 return false;
1593.             }
1595.             if ('::class' === strtolower(substr($constant, -7))) {
1596.                 throw new RuntimeError(\sprintf('You cannot use the Twig function "constant" to access "%s". You could provide an object and call constant("class", $object) or use the class name directly as a string.', $constant));
1597.             }
1599.             throw new RuntimeError(\sprintf('Constant "%s" is undefined.', $constant));
1600.         }
1602.         return $checkDefined ? true : \constant($constant);
1603.     }
1605.     /**
1606.      * Batches item.
1607.      *
1608.      * @param array $items An array of items
1609.      * @param int   $size  The size of the batch
1610.      * @param mixed $fill  A value used to fill missing items
1611.      *
1612.      * @internal
1613.      */
1614.     public static function batch($items, $size, $fill = null, $preserveKeys = true): array
1615.     {
1616.         if (!is_iterable($items)) {
1617.             throw new RuntimeError(\sprintf('The "batch" filter expects a sequence or a mapping, got "%s".', get_debug_type($items)));
1618.         }
1620.         $size = (int) ceil($size);
1622.         $result = array_chunk(self::toArray($items, $preserveKeys), $size, $preserveKeys);
1624.         if (null !== $fill && $result) {
1625.             $last = \count($result) - 1;
1626.             if ($fillCount = $size - \count($result[$last])) {
1627.                 for ($i = 0; $i < $fillCount; ++$i) {
1628.                     $result[$last][] = $fill;
1629.                 }
1630.             }
1631.         }
1633.         return $result;
1634.     }
1636.     /**
1637.      * Returns the attribute value for a given array/object.
1638.      *
1639.      * @param mixed  $object            The object or array from where to get the item
1640.      * @param mixed  $item              The item to get from the array or object
1641.      * @param array  $arguments         An array of arguments to pass if the item is an object method
1642.      * @param string $type              The type of attribute (@see \Twig\Template constants)
1643.      * @param bool   $isDefinedTest     Whether this is only a defined check
1644.      * @param bool   $ignoreStrictCheck Whether to ignore the strict attribute check or not
1645.      * @param int    $lineno            The template line where the attribute was called
1646.      *
1647.      * @return mixed The attribute value, or a Boolean when $isDefinedTest is true, or null when the attribute is not set and $ignoreStrictCheck is true
1648.      *
1649.      * @throws RuntimeError if the attribute does not exist and Twig is running in strict mode and $isDefinedTest is false
1650.      *
1651.      * @internal
1652.      */
1653.     public static function getAttribute(Environment $env, Source $source, $object, $item, array $arguments = [], $type = Template::ANY_CALL, $isDefinedTest = false, $ignoreStrictCheck = false, $sandboxed = false, int $lineno = -1)
1654.     {
1655.         $propertyNotAllowedError = null;
1657.         // array
1658.         if (Template::METHOD_CALL !== $type) {
1659.             $arrayItem = \is_bool($item) || \is_float($item) ? (int) $item : $item;
1661.             if ($sandboxed && $object instanceof \ArrayAccess && !\in_array($object::class, self::ARRAY_LIKE_CLASSES, true)) {
1662.                 try {
1663.                     $env->getExtension(SandboxExtension::class)->checkPropertyAllowed($object, $arrayItem, $lineno, $source);
1664.                 } catch (SecurityNotAllowedPropertyError $propertyNotAllowedError) {
1665.                     goto methodCheck;
1666.                 }
1667.             }
1669.             if (match (true) {
1670.                 \is_array($object) => \array_key_exists($arrayItem, $object),
1671.                 $object instanceof \ArrayAccess => $object->offsetExists($arrayItem),
1672.                 default => false,
1673.             }) {
1674.                 if ($isDefinedTest) {
1675.                     return true;
1676.                 }
1678.                 return $object[$arrayItem];
1679.             }
1681.             if (Template::ARRAY_CALL === $type || !\is_object($object)) {
1682.                 if ($isDefinedTest) {
1683.                     return false;
1684.                 }
1686.                 if ($ignoreStrictCheck || !$env->isStrictVariables()) {
1687.                     return;
1688.                 }
1690.                 if ($object instanceof \ArrayAccess) {
1691.                     $message = \sprintf('Key "%s" in object with ArrayAccess of class "%s" does not exist.', $arrayItem, \get_class($object));
1692.                 } elseif (\is_object($object)) {
1693.                     $message = \sprintf('Impossible to access a key "%s" on an object of class "%s" that does not implement ArrayAccess interface.', $item, \get_class($object));
1694.                 } elseif (\is_array($object)) {
1695.                     if (!$object) {
1696.                         $message = \sprintf('Key "%s" does not exist as the sequence/mapping is empty.', $arrayItem);
1697.                     } else {
1698.                         $message = \sprintf('Key "%s" for sequence/mapping with keys "%s" does not exist.', $arrayItem, implode(', ', array_keys($object)));
1699.                     }
1700.                 } elseif (Template::ARRAY_CALL === $type) {
1701.                     if (null === $object) {
1702.                         $message = \sprintf('Impossible to access a key ("%s") on a null variable.', $item);
1703.                     } else {
1704.                         $message = \sprintf('Impossible to access a key ("%s") on a %s variable ("%s").', $item, get_debug_type($object), $object);
1705.                     }
1706.                 } elseif (null === $object) {
1707.                     $message = \sprintf('Impossible to access an attribute ("%s") on a null variable.', $item);
1708.                 } else {
1709.                     $message = \sprintf('Impossible to access an attribute ("%s") on a %s variable ("%s").', $item, get_debug_type($object), $object);
1710.                 }
1712.                 throw new RuntimeError($message, $lineno, $source);
1713.             }
1714.         }
1716.         $item = (string) $item;
1718.         if (!\is_object($object)) {
1719.             if ($isDefinedTest) {
1720.                 return false;
1721.             }
1723.             if ($ignoreStrictCheck || !$env->isStrictVariables()) {
1724.                 return;
1725.             }
1727.             if (null === $object) {
1728.                 $message = \sprintf('Impossible to invoke a method ("%s") on a null variable.', $item);
1729.             } elseif (\is_array($object)) {
1730.                 $message = \sprintf('Impossible to invoke a method ("%s") on a sequence/mapping.', $item);
1731.             } else {
1732.                 $message = \sprintf('Impossible to invoke a method ("%s") on a %s variable ("%s").', $item, get_debug_type($object), $object);
1733.             }
1735.             throw new RuntimeError($message, $lineno, $source);
1736.         }
1738.         if ($object instanceof Template) {
1739.             throw new RuntimeError('Accessing \Twig\Template attributes is forbidden.', $lineno, $source);
1740.         }
1742.         // object property
1743.         if (Template::METHOD_CALL !== $type) {
1744.             if ($sandboxed) {
1745.                 try {
1746.                     $env->getExtension(SandboxExtension::class)->checkPropertyAllowed($object, $item, $lineno, $source);
1747.                 } catch (SecurityNotAllowedPropertyError $propertyNotAllowedError) {
1748.                     goto methodCheck;
1749.                 }
1750.             }
1752.             static $propertyCheckers = [];
1754.             if ($object instanceof \Closure && '__invoke' === $item) {
1755.                 return $isDefinedTest ? true : $object();
1756.             }
1758.             if (isset($object->$item)
1759.                 || ($propertyCheckers[$object::class][$item] ??= self::getPropertyChecker($object::class, $item))($object, $item)
1760.             ) {
1761.                 if ($isDefinedTest) {
1762.                     return true;
1763.                 }
1765.                 return $object->$item;
1766.             }
1768.             if ($object instanceof \DateTimeInterface && \in_array($item, ['date', 'timezone', 'timezone_type'], true)) {
1769.                 if ($isDefinedTest) {
1770.                     return true;
1771.                 }
1773.                 return ((array) $object)[$item];
1774.             }
1776.             if (\defined($object::class.'::'.$item)) {
1777.                 if ($isDefinedTest) {
1778.                     return true;
1779.                 }
1781.                 return \constant($object::class.'::'.$item);
1782.             }
1783.         }
1785.         methodCheck:
1787.         static $cache = [];
1789.         $class = \get_class($object);
1791.         // object method
1792.         // precedence: getXxx() > isXxx() > hasXxx()
1793.         if (!isset($cache[$class])) {
1794.             $methods = get_class_methods($object);
1795.             if ($object instanceof \Closure) {
1796.                 $methods[] = '__invoke';
1797.             }
1798.             sort($methods);
1799.             $lcMethods = array_map('strtolower', $methods);
1800.             $classCache = [];
1801.             foreach ($methods as $i => $method) {
1802.                 $classCache[$method] = $method;
1803.                 $classCache[$lcName = $lcMethods[$i]] = $method;
1805.                 if ('g' === $lcName[0] && str_starts_with($lcName, 'get')) {
1806.                     $name = substr($method, 3);
1807.                     $lcName = substr($lcName, 3);
1808.                 } elseif ('i' === $lcName[0] && str_starts_with($lcName, 'is')) {
1809.                     $name = substr($method, 2);
1810.                     $lcName = substr($lcName, 2);
1811.                 } elseif ('h' === $lcName[0] && str_starts_with($lcName, 'has')) {
1812.                     $name = substr($method, 3);
1813.                     $lcName = substr($lcName, 3);
1814.                     if (\in_array('is'.$lcName, $lcMethods)) {
1815.                         continue;
1816.                     }
1817.                 } else {
1818.                     continue;
1819.                 }
1821.                 // skip get() and is() methods (in which case, $name is empty)
1822.                 if ($name) {
1823.                     if (!isset($classCache[$name])) {
1824.                         $classCache[$name] = $method;
1825.                     }
1827.                     if (!isset($classCache[$lcName])) {
1828.                         $classCache[$lcName] = $method;
1829.                     }
1830.                 }
1831.             }
1832.             $cache[$class] = $classCache;
1833.         }
1835.         $call = false;
1836.         if (isset($cache[$class][$item])) {
1837.             $method = $cache[$class][$item];
1838.         } elseif (isset($cache[$class][$lcItem = strtolower($item)])) {
1839.             $method = $cache[$class][$lcItem];
1840.         } elseif (isset($cache[$class]['__call'])) {
1841.             $method = $item;
1842.             $call = true;
1843.         } else {
1844.             if ($isDefinedTest) {
1845.                 return false;
1846.             }
1848.             if ($propertyNotAllowedError) {
1849.                 throw $propertyNotAllowedError;
1850.             }
1852.             if ($ignoreStrictCheck || !$env->isStrictVariables()) {
1853.                 return;
1854.             }
1856.             throw new RuntimeError(\sprintf('Neither the property "%1$s" nor one of the methods "%1$s()", "get%1$s()"/"is%1$s()"/"has%1$s()" or "__call()" exist and have public access in class "%2$s".', $item, $class), $lineno, $source);
1857.         }
1859.         if ($sandboxed) {
1860.             try {
1861.                 $env->getExtension(SandboxExtension::class)->checkMethodAllowed($object, $method, $lineno, $source);
1862.             } catch (SecurityNotAllowedMethodError $e) {
1863.                 if ($isDefinedTest) {
1864.                     return false;
1865.                 }
1867.                 if ($propertyNotAllowedError) {
1868.                     throw $propertyNotAllowedError;
1869.                 }
1871.                 throw $e;
1872.             }
1873.         }
1875.         if ($isDefinedTest) {
1876.             return true;
1877.         }
1879.         // Some objects throw exceptions when they have __call, and the method we try
1880.         // to call is not supported. If ignoreStrictCheck is true, we should return null.
1881.         try {
1882.             $ret = $object->$method(...$arguments);
1883.         } catch (\BadMethodCallException $e) {
1884.             if ($call && ($ignoreStrictCheck || !$env->isStrictVariables())) {
1885.                 return;
1886.             }
1887.             throw $e;
1888.         }
1890.         return $ret;
1891.     }
1893.     /**
1894.      * Returns the values from a single column in the input array.
1895.      *
1896.      * <pre>
1897.      *  {% set items = [{ 'fruit' : 'apple'}, {'fruit' : 'orange' }] %}
1898.      *
1899.      *  {% set fruits = items|column('fruit') %}
1900.      *
1901.      *  {# fruits now contains ['apple', 'orange'] #}
1902.      * </pre>
1903.      *
1904.      * @param array|\Traversable $array An array
1905.      * @param int|string         $name  The column name
1906.      * @param int|string|null    $index The column to use as the index/keys for the returned array
1907.      *
1908.      * @return array The array of values
1909.      *
1910.      * @internal
1911.      */
1912.     public static function column($array, $name, $index = null): array
1913.     {
1914.         if (!is_iterable($array)) {
1915.             throw new RuntimeError(\sprintf('The "column" filter expects a sequence or a mapping, got "%s".', get_debug_type($array)));
1916.         }
1918.         if ($array instanceof \Traversable) {
1919.             $array = iterator_to_array($array);
1920.         }
1922.         return array_column($array, $name, $index);
1923.     }
1925.     /**
1926.      * @param \Closure $arrow
1927.      *
1928.      * @internal
1929.      */
1930.     public static function filter(Environment $env, $array, $arrow)
1931.     {
1932.         if (!is_iterable($array)) {
1933.             throw new RuntimeError(\sprintf('The "filter" filter expects a sequence/mapping or "Traversable", got "%s".', get_debug_type($array)));
1934.         }
1936.         self::checkArrow($env, $arrow, 'filter', 'filter');
1938.         if (\is_array($array)) {
1939.             return array_filter($array, $arrow, \ARRAY_FILTER_USE_BOTH);
1940.         }
1942.         // the IteratorIterator wrapping is needed as some internal PHP classes are \Traversable but do not implement \Iterator
1943.         return new \CallbackFilterIterator(new \IteratorIterator($array), $arrow);
1944.     }
1946.     /**
1947.      * @param \Closure $arrow
1948.      *
1949.      * @internal
1950.      */
1951.     public static function find(Environment $env, $array, $arrow)
1952.     {
1953.         if (!is_iterable($array)) {
1954.             throw new RuntimeError(\sprintf('The "find" filter expects a sequence or a mapping, got "%s".', get_debug_type($array)));
1955.         }
1957.         self::checkArrow($env, $arrow, 'find', 'filter');
1959.         foreach ($array as $k => $v) {
1960.             if ($arrow($v, $k)) {
1961.                 return $v;
1962.             }
1963.         }
1965.         return null;
1966.     }
1968.     /**
1969.      * @param \Closure $arrow
1970.      *
1971.      * @internal
1972.      */
1973.     public static function map(Environment $env, $array, $arrow)
1974.     {
1975.         if (!is_iterable($array)) {
1976.             throw new RuntimeError(\sprintf('The "map" filter expects a sequence or a mapping, got "%s".', get_debug_type($array)));
1977.         }
1979.         self::checkArrow($env, $arrow, 'map', 'filter');
1981.         $r = [];
1982.         foreach ($array as $k => $v) {
1983.             $r[$k] = $arrow($v, $k);
1984.         }
1986.         return $r;
1987.     }
1989.     /**
1990.      * @param \Closure $arrow
1991.      *
1992.      * @internal
1993.      */
1994.     public static function reduce(Environment $env, $array, $arrow, $initial = null)
1995.     {
1996.         if (!is_iterable($array)) {
1997.             throw new RuntimeError(\sprintf('The "reduce" filter expects a sequence or a mapping, got "%s".', get_debug_type($array)));
1998.         }
2000.         self::checkArrow($env, $arrow, 'reduce', 'filter');
2002.         $accumulator = $initial;
2003.         foreach ($array as $key => $value) {
2004.             $accumulator = $arrow($accumulator, $value, $key);
2005.         }
2007.         return $accumulator;
2008.     }
2010.     /**
2011.      * @param \Closure $arrow
2012.      *
2013.      * @internal
2014.      */
2015.     public static function arraySome(Environment $env, $array, $arrow)
2016.     {
2017.         if (!is_iterable($array)) {
2018.             throw new RuntimeError(\sprintf('The "has some" test expects a sequence or a mapping, got "%s".', get_debug_type($array)));
2019.         }
2021.         self::checkArrow($env, $arrow, 'has some', 'operator');
2023.         foreach ($array as $k => $v) {
2024.             if ($arrow($v, $k)) {
2025.                 return true;
2026.             }
2027.         }
2029.         return false;
2030.     }
2032.     /**
2033.      * @param \Closure $arrow
2034.      *
2035.      * @internal
2036.      */
2037.     public static function arrayEvery(Environment $env, $array, $arrow)
2038.     {
2039.         if (!is_iterable($array)) {
2040.             throw new RuntimeError(\sprintf('The "has every" test expects a sequence or a mapping, got "%s".', get_debug_type($array)));
2041.         }
2043.         self::checkArrow($env, $arrow, 'has every', 'operator');
2045.         foreach ($array as $k => $v) {
2046.             if (!$arrow($v, $k)) {
2047.                 return false;
2048.             }
2049.         }
2051.         return true;
2052.     }
2054.     /**
2055.      * @internal
2056.      */
2057.     public static function checkArrow(Environment $env, $arrow, $thing, $type)
2058.     {
2059.         if ($arrow instanceof \Closure) {
2060.             return;
2061.         }
2063.         if ($env->hasExtension(SandboxExtension::class) && $env->getExtension(SandboxExtension::class)->isSandboxed()) {
2064.             throw new RuntimeError(\sprintf('The callable passed to the "%s" %s must be a Closure in sandbox mode.', $thing, $type));
2065.         }
2067.         trigger_deprecation('twig/twig', '3.15', 'Passing a callable that is not a PHP \Closure as an argument to the "%s" %s is deprecated.', $thing, $type);
2068.     }
2070.     /**
2071.      * @internal to be removed in Twig 4
2072.      */
2073.     public static function captureOutput(iterable $body): string
2074.     {
2075.         $level = ob_get_level();
2076.         ob_start();
2078.         try {
2079.             foreach ($body as $data) {
2080.                 echo $data;
2081.             }
2082.         } catch (\Throwable $e) {
2083.             while (ob_get_level() > $level) {
2084.                 ob_end_clean();
2085.             }
2087.             throw $e;
2088.         }
2090.         return ob_get_clean();
2091.     }
2093.     /**
2094.      * @internal
2095.      */
2096.     public static function parseParentFunction(Parser $parser, Node $fakeNode, $args, int $line): AbstractExpression
2097.     {
2098.         if (!$blockName = $parser->peekBlockStack()) {
2099.             throw new SyntaxError('Calling the "parent" function outside of a block is forbidden.', $line, $parser->getStream()->getSourceContext());
2100.         }
2102.         if (!$parser->hasInheritance()) {
2103.             throw new SyntaxError('Calling the "parent" function on a template that does not call "extends" or "use" is forbidden.', $line, $parser->getStream()->getSourceContext());
2104.         }
2106.         return new ParentExpression($blockName, $line);
2107.     }
2109.     /**
2110.      * @internal
2111.      */
2112.     public static function parseBlockFunction(Parser $parser, Node $fakeNode, $args, int $line): AbstractExpression
2113.     {
2114.         $fakeFunction = new TwigFunction('block', fn ($name, $template = null) => null);
2115.         $args = (new CallableArgumentsExtractor($fakeNode, $fakeFunction))->extractArguments($args);
2117.         return new BlockReferenceExpression($args[0], $args[1] ?? null, $line);
2118.     }
2120.     /**
2121.      * @internal
2122.      */
2123.     public static function parseAttributeFunction(Parser $parser, Node $fakeNode, $args, int $line): AbstractExpression
2124.     {
2125.         $fakeFunction = new TwigFunction('attribute', fn ($variable, $attribute, $arguments = null) => null);
2126.         $args = (new CallableArgumentsExtractor($fakeNode, $fakeFunction))->extractArguments($args);
2128.         /*
2129.         Deprecation to uncomment sometimes during the lifetime of the 4.x branch
2130.         $src = $parser->getStream()->getSourceContext();
2131.         $dep = new DeprecatedCallableInfo('twig/twig', '3.15', 'The "attribute" function is deprecated, use the "." notation instead.');
2132.         $dep->setName('attribute');
2133.         $dep->setType('function');
2134.         $dep->triggerDeprecation($src->getPath() ?: $src->getName(), $line);
2135.         */
2137.         return new GetAttrExpression($args[0], $args[1], $args[2] ?? null, Template::ANY_CALL, $line);
2138.     }
2140.     private static function getPropertyChecker(string $class, string $property): \Closure
2141.     {
2142.         static $classReflectors = [];
2144.         $class = $classReflectors[$class] ??= new \ReflectionClass($class);
2146.         if (!$class->hasProperty($property)) {
2147.             static $propertyExists;
2149.             return $propertyExists ??= \Closure::fromCallable('property_exists');
2150.         }
2152.         $property = $class->getProperty($property);
2154.         if (!$property->isPublic() || $property->isStatic()) {
2155.             static $false;
2157.             return $false ??= static fn () => false;
2158.         }
2160.         return static fn ($object) => $property->isInitialized($object);
2161.     }
2162. }