vendor/twig/twig/src/Extension/CoreExtension.php line 1463

Open in your IDE?
  1. <?php
  2. /*
  3.  * This file is part of Twig.
  4.  *
  5.  * (c) Fabien Potencier
  6.  *
  7.  * For the full copyright and license information, please view the LICENSE
  8.  * file that was distributed with this source code.
  9.  */
  10. namespace Twig\Extension;
  11. use Twig\Environment;
  12. use Twig\Error\LoaderError;
  13. use Twig\Error\RuntimeError;
  14. use Twig\ExpressionParser;
  15. use Twig\Markup;
  16. use Twig\Node\Expression\Binary\AddBinary;
  17. use Twig\Node\Expression\Binary\AndBinary;
  18. use Twig\Node\Expression\Binary\BitwiseAndBinary;
  19. use Twig\Node\Expression\Binary\BitwiseOrBinary;
  20. use Twig\Node\Expression\Binary\BitwiseXorBinary;
  21. use Twig\Node\Expression\Binary\ConcatBinary;
  22. use Twig\Node\Expression\Binary\DivBinary;
  23. use Twig\Node\Expression\Binary\EndsWithBinary;
  24. use Twig\Node\Expression\Binary\EqualBinary;
  25. use Twig\Node\Expression\Binary\FloorDivBinary;
  26. use Twig\Node\Expression\Binary\GreaterBinary;
  27. use Twig\Node\Expression\Binary\GreaterEqualBinary;
  28. use Twig\Node\Expression\Binary\HasEveryBinary;
  29. use Twig\Node\Expression\Binary\HasSomeBinary;
  30. use Twig\Node\Expression\Binary\InBinary;
  31. use Twig\Node\Expression\Binary\LessBinary;
  32. use Twig\Node\Expression\Binary\LessEqualBinary;
  33. use Twig\Node\Expression\Binary\MatchesBinary;
  34. use Twig\Node\Expression\Binary\ModBinary;
  35. use Twig\Node\Expression\Binary\MulBinary;
  36. use Twig\Node\Expression\Binary\NotEqualBinary;
  37. use Twig\Node\Expression\Binary\NotInBinary;
  38. use Twig\Node\Expression\Binary\OrBinary;
  39. use Twig\Node\Expression\Binary\PowerBinary;
  40. use Twig\Node\Expression\Binary\RangeBinary;
  41. use Twig\Node\Expression\Binary\SpaceshipBinary;
  42. use Twig\Node\Expression\Binary\StartsWithBinary;
  43. use Twig\Node\Expression\Binary\SubBinary;
  44. use Twig\Node\Expression\Filter\DefaultFilter;
  45. use Twig\Node\Expression\NullCoalesceExpression;
  46. use Twig\Node\Expression\Test\ConstantTest;
  47. use Twig\Node\Expression\Test\DefinedTest;
  48. use Twig\Node\Expression\Test\DivisiblebyTest;
  49. use Twig\Node\Expression\Test\EvenTest;
  50. use Twig\Node\Expression\Test\NullTest;
  51. use Twig\Node\Expression\Test\OddTest;
  52. use Twig\Node\Expression\Test\SameasTest;
  53. use Twig\Node\Expression\Unary\NegUnary;
  54. use Twig\Node\Expression\Unary\NotUnary;
  55. use Twig\Node\Expression\Unary\PosUnary;
  56. use Twig\NodeVisitor\MacroAutoImportNodeVisitor;
  57. use Twig\Source;
  58. use Twig\Template;
  59. use Twig\TemplateWrapper;
  60. use Twig\TokenParser\ApplyTokenParser;
  61. use Twig\TokenParser\BlockTokenParser;
  62. use Twig\TokenParser\DeprecatedTokenParser;
  63. use Twig\TokenParser\DoTokenParser;
  64. use Twig\TokenParser\EmbedTokenParser;
  65. use Twig\TokenParser\ExtendsTokenParser;
  66. use Twig\TokenParser\FlushTokenParser;
  67. use Twig\TokenParser\ForTokenParser;
  68. use Twig\TokenParser\FromTokenParser;
  69. use Twig\TokenParser\IfTokenParser;
  70. use Twig\TokenParser\ImportTokenParser;
  71. use Twig\TokenParser\IncludeTokenParser;
  72. use Twig\TokenParser\MacroTokenParser;
  73. use Twig\TokenParser\SetTokenParser;
  74. use Twig\TokenParser\UseTokenParser;
  75. use Twig\TokenParser\WithTokenParser;
  76. use Twig\TwigFilter;
  77. use Twig\TwigFunction;
  78. use Twig\TwigTest;
  79. final class CoreExtension extends AbstractExtension
  80. {
  81.     private $dateFormats = ['F j, Y H:i''%d days'];
  82.     private $numberFormat = [0'.'','];
  83.     private $timezone null;
  84.     /**
  85.      * Sets the default format to be used by the date filter.
  86.      *
  87.      * @param string|null $format             The default date format string
  88.      * @param string|null $dateIntervalFormat The default date interval format string
  89.      */
  90.     public function setDateFormat($format null$dateIntervalFormat null)
  91.     {
  92.         if (null !== $format) {
  93.             $this->dateFormats[0] = $format;
  94.         }
  95.         if (null !== $dateIntervalFormat) {
  96.             $this->dateFormats[1] = $dateIntervalFormat;
  97.         }
  98.     }
  99.     /**
  100.      * Gets the default format to be used by the date filter.
  101.      *
  102.      * @return array The default date format string and the default date interval format string
  103.      */
  104.     public function getDateFormat()
  105.     {
  106.         return $this->dateFormats;
  107.     }
  108.     /**
  109.      * Sets the default timezone to be used by the date filter.
  110.      *
  111.      * @param \DateTimeZone|string $timezone The default timezone string or a \DateTimeZone object
  112.      */
  113.     public function setTimezone($timezone)
  114.     {
  115.         $this->timezone $timezone instanceof \DateTimeZone $timezone : new \DateTimeZone($timezone);
  116.     }
  117.     /**
  118.      * Gets the default timezone to be used by the date filter.
  119.      *
  120.      * @return \DateTimeZone The default timezone currently in use
  121.      */
  122.     public function getTimezone()
  123.     {
  124.         if (null === $this->timezone) {
  125.             $this->timezone = new \DateTimeZone(date_default_timezone_get());
  126.         }
  127.         return $this->timezone;
  128.     }
  129.     /**
  130.      * Sets the default format to be used by the number_format filter.
  131.      *
  132.      * @param int    $decimal      the number of decimal places to use
  133.      * @param string $decimalPoint the character(s) to use for the decimal point
  134.      * @param string $thousandSep  the character(s) to use for the thousands separator
  135.      */
  136.     public function setNumberFormat($decimal$decimalPoint$thousandSep)
  137.     {
  138.         $this->numberFormat = [$decimal$decimalPoint$thousandSep];
  139.     }
  140.     /**
  141.      * Get the default format used by the number_format filter.
  142.      *
  143.      * @return array The arguments for number_format()
  144.      */
  145.     public function getNumberFormat()
  146.     {
  147.         return $this->numberFormat;
  148.     }
  149.     public function getTokenParsers(): array
  150.     {
  151.         return [
  152.             new ApplyTokenParser(),
  153.             new ForTokenParser(),
  154.             new IfTokenParser(),
  155.             new ExtendsTokenParser(),
  156.             new IncludeTokenParser(),
  157.             new BlockTokenParser(),
  158.             new UseTokenParser(),
  159.             new MacroTokenParser(),
  160.             new ImportTokenParser(),
  161.             new FromTokenParser(),
  162.             new SetTokenParser(),
  163.             new FlushTokenParser(),
  164.             new DoTokenParser(),
  165.             new EmbedTokenParser(),
  166.             new WithTokenParser(),
  167.             new DeprecatedTokenParser(),
  168.         ];
  169.     }
  170.     public function getFilters(): array
  171.     {
  172.         return [
  173.             // formatting filters
  174.             new TwigFilter('date', [$this'formatDate']),
  175.             new TwigFilter('date_modify', [$this'modifyDate']),
  176.             new TwigFilter('format', [self::class, 'sprintf']),
  177.             new TwigFilter('replace', [self::class, 'replace']),
  178.             new TwigFilter('number_format', [$this'formatNumber']),
  179.             new TwigFilter('abs''abs'),
  180.             new TwigFilter('round', [self::class, 'round']),
  181.             // encoding
  182.             new TwigFilter('url_encode', [self::class, 'urlencode']),
  183.             new TwigFilter('json_encode''json_encode'),
  184.             new TwigFilter('convert_encoding', [self::class, 'convertEncoding']),
  185.             // string filters
  186.             new TwigFilter('title', [self::class, 'titleCase'], ['needs_charset' => true]),
  187.             new TwigFilter('capitalize', [self::class, 'capitalize'], ['needs_charset' => true]),
  188.             new TwigFilter('upper', [self::class, 'upper'], ['needs_charset' => true]),
  189.             new TwigFilter('lower', [self::class, 'lower'], ['needs_charset' => true]),
  190.             new TwigFilter('striptags', [self::class, 'striptags']),
  191.             new TwigFilter('trim', [self::class, 'trim']),
  192.             new TwigFilter('nl2br', [self::class, 'nl2br'], ['pre_escape' => 'html''is_safe' => ['html']]),
  193.             new TwigFilter('spaceless', [self::class, 'spaceless'], ['is_safe' => ['html']]),
  194.             // array helpers
  195.             new TwigFilter('join', [self::class, 'join']),
  196.             new TwigFilter('split', [self::class, 'split'], ['needs_charset' => true]),
  197.             new TwigFilter('sort', [self::class, 'sort'], ['needs_environment' => true]),
  198.             new TwigFilter('merge', [self::class, 'merge']),
  199.             new TwigFilter('batch', [self::class, 'batch']),
  200.             new TwigFilter('column', [self::class, 'column']),
  201.             new TwigFilter('filter', [self::class, 'filter'], ['needs_environment' => true]),
  202.             new TwigFilter('map', [self::class, 'map'], ['needs_environment' => true]),
  203.             new TwigFilter('reduce', [self::class, 'reduce'], ['needs_environment' => true]),
  204.             // string/array filters
  205.             new TwigFilter('reverse', [self::class, 'reverse'], ['needs_charset' => true]),
  206.             new TwigFilter('length', [self::class, 'length'], ['needs_charset' => true]),
  207.             new TwigFilter('slice', [self::class, 'slice'], ['needs_charset' => true]),
  208.             new TwigFilter('first', [self::class, 'first'], ['needs_charset' => true]),
  209.             new TwigFilter('last', [self::class, 'last'], ['needs_charset' => true]),
  210.             // iteration and runtime
  211.             new TwigFilter('default', [self::class, 'default'], ['node_class' => DefaultFilter::class]),
  212.             new TwigFilter('keys', [self::class, 'keys']),
  213.         ];
  214.     }
  215.     public function getFunctions(): array
  216.     {
  217.         return [
  218.             new TwigFunction('max''max'),
  219.             new TwigFunction('min''min'),
  220.             new TwigFunction('range''range'),
  221.             new TwigFunction('constant', [self::class, 'constant']),
  222.             new TwigFunction('cycle', [self::class, 'cycle']),
  223.             new TwigFunction('random', [self::class, 'random'], ['needs_charset' => true]),
  224.             new TwigFunction('date', [$this'convertDate']),
  225.             new TwigFunction('include', [self::class, 'include'], ['needs_environment' => true'needs_context' => true'is_safe' => ['all']]),
  226.             new TwigFunction('source', [self::class, 'source'], ['needs_environment' => true'is_safe' => ['all']]),
  227.         ];
  228.     }
  229.     public function getTests(): array
  230.     {
  231.         return [
  232.             new TwigTest('even'null, ['node_class' => EvenTest::class]),
  233.             new TwigTest('odd'null, ['node_class' => OddTest::class]),
  234.             new TwigTest('defined'null, ['node_class' => DefinedTest::class]),
  235.             new TwigTest('same as'null, ['node_class' => SameasTest::class, 'one_mandatory_argument' => true]),
  236.             new TwigTest('none'null, ['node_class' => NullTest::class]),
  237.             new TwigTest('null'null, ['node_class' => NullTest::class]),
  238.             new TwigTest('divisible by'null, ['node_class' => DivisiblebyTest::class, 'one_mandatory_argument' => true]),
  239.             new TwigTest('constant'null, ['node_class' => ConstantTest::class]),
  240.             new TwigTest('empty', [self::class, 'testEmpty']),
  241.             new TwigTest('iterable''is_iterable'),
  242.         ];
  243.     }
  244.     public function getNodeVisitors(): array
  245.     {
  246.         return [new MacroAutoImportNodeVisitor()];
  247.     }
  248.     public function getOperators(): array
  249.     {
  250.         return [
  251.             [
  252.                 'not' => ['precedence' => 50'class' => NotUnary::class],
  253.                 '-' => ['precedence' => 500'class' => NegUnary::class],
  254.                 '+' => ['precedence' => 500'class' => PosUnary::class],
  255.             ],
  256.             [
  257.                 'or' => ['precedence' => 10'class' => OrBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  258.                 'and' => ['precedence' => 15'class' => AndBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  259.                 'b-or' => ['precedence' => 16'class' => BitwiseOrBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  260.                 'b-xor' => ['precedence' => 17'class' => BitwiseXorBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  261.                 'b-and' => ['precedence' => 18'class' => BitwiseAndBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  262.                 '==' => ['precedence' => 20'class' => EqualBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  263.                 '!=' => ['precedence' => 20'class' => NotEqualBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  264.                 '<=>' => ['precedence' => 20'class' => SpaceshipBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  265.                 '<' => ['precedence' => 20'class' => LessBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  266.                 '>' => ['precedence' => 20'class' => GreaterBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  267.                 '>=' => ['precedence' => 20'class' => GreaterEqualBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  268.                 '<=' => ['precedence' => 20'class' => LessEqualBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  269.                 'not in' => ['precedence' => 20'class' => NotInBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  270.                 'in' => ['precedence' => 20'class' => InBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  271.                 'matches' => ['precedence' => 20'class' => MatchesBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  272.                 'starts with' => ['precedence' => 20'class' => StartsWithBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  273.                 'ends with' => ['precedence' => 20'class' => EndsWithBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  274.                 'has some' => ['precedence' => 20'class' => HasSomeBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  275.                 'has every' => ['precedence' => 20'class' => HasEveryBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  276.                 '..' => ['precedence' => 25'class' => RangeBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  277.                 '+' => ['precedence' => 30'class' => AddBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  278.                 '-' => ['precedence' => 30'class' => SubBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  279.                 '~' => ['precedence' => 40'class' => ConcatBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  280.                 '*' => ['precedence' => 60'class' => MulBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  281.                 '/' => ['precedence' => 60'class' => DivBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  282.                 '//' => ['precedence' => 60'class' => FloorDivBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  283.                 '%' => ['precedence' => 60'class' => ModBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  284.                 'is' => ['precedence' => 100'associativity' => ExpressionParser::OPERATOR_LEFT],
  285.                 'is not' => ['precedence' => 100'associativity' => ExpressionParser::OPERATOR_LEFT],
  286.                 '**' => ['precedence' => 200'class' => PowerBinary::class, 'associativity' => ExpressionParser::OPERATOR_RIGHT],
  287.                 '??' => ['precedence' => 300'class' => NullCoalesceExpression::class, 'associativity' => ExpressionParser::OPERATOR_RIGHT],
  288.             ],
  289.         ];
  290.     }
  291.     /**
  292.      * Cycles over a value.
  293.      *
  294.      * @param \ArrayAccess|array $values
  295.      * @param int                $position The cycle position
  296.      *
  297.      * @return string The next value in the cycle
  298.      *
  299.      * @internal
  300.      */
  301.     public static function cycle($values$position): string
  302.     {
  303.         if (!\is_array($values) && !$values instanceof \ArrayAccess) {
  304.             return $values;
  305.         }
  306.         if (!\count($values)) {
  307.             throw new RuntimeError('The "cycle" function does not work on empty arrays.');
  308.         }
  309.         return $values[$position \count($values)];
  310.     }
  311.     /**
  312.      * Returns a random value depending on the supplied parameter type:
  313.      * - a random item from a \Traversable or array
  314.      * - a random character from a string
  315.      * - a random integer between 0 and the integer parameter.
  316.      *
  317.      * @param \Traversable|array|int|float|string $values The values to pick a random item from
  318.      * @param int|null                            $max    Maximum value used when $values is an int
  319.      *
  320.      * @return mixed A random value from the given sequence
  321.      *
  322.      * @throws RuntimeError when $values is an empty array (does not apply to an empty string which is returned as is)
  323.      *
  324.      * @internal
  325.      */
  326.     public static function random(string $charset$values null$max null)
  327.     {
  328.         if (null === $values) {
  329.             return null === $max mt_rand() : mt_rand(0, (int) $max);
  330.         }
  331.         if (\is_int($values) || \is_float($values)) {
  332.             if (null === $max) {
  333.                 if ($values 0) {
  334.                     $max 0;
  335.                     $min $values;
  336.                 } else {
  337.                     $max $values;
  338.                     $min 0;
  339.                 }
  340.             } else {
  341.                 $min $values;
  342.             }
  343.             return mt_rand((int) $min, (int) $max);
  344.         }
  345.         if (\is_string($values)) {
  346.             if ('' === $values) {
  347.                 return '';
  348.             }
  349.             if ('UTF-8' !== $charset) {
  350.                 $values self::convertEncoding($values'UTF-8'$charset);
  351.             }
  352.             // unicode version of str_split()
  353.             // split at all positions, but not after the start and not before the end
  354.             $values preg_split('/(?<!^)(?!$)/u'$values);
  355.             if ('UTF-8' !== $charset) {
  356.                 foreach ($values as $i => $value) {
  357.                     $values[$i] = self::convertEncoding($value$charset'UTF-8');
  358.                 }
  359.             }
  360.         }
  361.         if (!is_iterable($values)) {
  362.             return $values;
  363.         }
  364.         $values self::toArray($values);
  365.         if (=== \count($values)) {
  366.             throw new RuntimeError('The random function cannot pick from an empty array.');
  367.         }
  368.         return $values[array_rand($values1)];
  369.     }
  370.     /**
  371.      * Formats a date.
  372.      *
  373.      *   {{ post.published_at|date("m/d/Y") }}
  374.      *
  375.      * @param \DateTimeInterface|\DateInterval|string $date     A date
  376.      * @param string|null                             $format   The target format, null to use the default
  377.      * @param \DateTimeZone|string|false|null         $timezone The target timezone, null to use the default, false to leave unchanged
  378.      */
  379.     public function formatDate($date$format null$timezone null): string
  380.     {
  381.         if (null === $format) {
  382.             $formats $this->getDateFormat();
  383.             $format $date instanceof \DateInterval $formats[1] : $formats[0];
  384.         }
  385.         if ($date instanceof \DateInterval) {
  386.             return $date->format($format);
  387.         }
  388.         return $this->convertDate($date$timezone)->format($format);
  389.     }
  390.     /**
  391.      * Returns a new date object modified.
  392.      *
  393.      *   {{ post.published_at|date_modify("-1day")|date("m/d/Y") }}
  394.      *
  395.      * @param \DateTimeInterface|string $date     A date
  396.      * @param string                    $modifier A modifier string
  397.      *
  398.      * @return \DateTime|\DateTimeImmutable
  399.      *
  400.      * @internal
  401.      */
  402.     public function modifyDate($date$modifier)
  403.     {
  404.         return $this->convertDate($datefalse)->modify($modifier);
  405.     }
  406.     /**
  407.      * Returns a formatted string.
  408.      *
  409.      * @param string|null $format
  410.      * @param ...$values
  411.      *
  412.      * @internal
  413.      */
  414.     public static function sprintf($format, ...$values): string
  415.     {
  416.         return sprintf($format ?? '', ...$values);
  417.     }
  418.     /**
  419.      * @internal
  420.      */
  421.     public static function dateConverter(Environment $env$date$format null$timezone null): string
  422.     {
  423.         return $env->getExtension(self::class)->formatDate($date$format$timezone);
  424.     }
  425.     /**
  426.      * Converts an input to a \DateTime instance.
  427.      *
  428.      *    {% if date(user.created_at) < date('+2days') %}
  429.      *      {# do something #}
  430.      *    {% endif %}
  431.      *
  432.      * @param \DateTimeInterface|string|null  $date     A date or null to use the current time
  433.      * @param \DateTimeZone|string|false|null $timezone The target timezone, null to use the default, false to leave unchanged
  434.      *
  435.      * @return \DateTime|\DateTimeImmutable
  436.      */
  437.     public function convertDate($date null$timezone null)
  438.     {
  439.         // determine the timezone
  440.         if (false !== $timezone) {
  441.             if (null === $timezone) {
  442.                 $timezone $this->getTimezone();
  443.             } elseif (!$timezone instanceof \DateTimeZone) {
  444.                 $timezone = new \DateTimeZone($timezone);
  445.             }
  446.         }
  447.         // immutable dates
  448.         if ($date instanceof \DateTimeImmutable) {
  449.             return false !== $timezone $date->setTimezone($timezone) : $date;
  450.         }
  451.         if ($date instanceof \DateTime) {
  452.             $date = clone $date;
  453.             if (false !== $timezone) {
  454.                 $date->setTimezone($timezone);
  455.             }
  456.             return $date;
  457.         }
  458.         if (null === $date || 'now' === $date) {
  459.             if (null === $date) {
  460.                 $date 'now';
  461.             }
  462.             return new \DateTime($datefalse !== $timezone $timezone $this->getTimezone());
  463.         }
  464.         $asString = (string) $date;
  465.         if (ctype_digit($asString) || (!empty($asString) && '-' === $asString[0] && ctype_digit(substr($asString1)))) {
  466.             $date = new \DateTime('@'.$date);
  467.         } else {
  468.             $date = new \DateTime($date$this->getTimezone());
  469.         }
  470.         if (false !== $timezone) {
  471.             $date->setTimezone($timezone);
  472.         }
  473.         return $date;
  474.     }
  475.     /**
  476.      * Replaces strings within a string.
  477.      *
  478.      * @param string|null        $str  String to replace in
  479.      * @param array|\Traversable $from Replace values
  480.      *
  481.      * @internal
  482.      */
  483.     public static function replace($str$from): string
  484.     {
  485.         if (!is_iterable($from)) {
  486.             throw new RuntimeError(sprintf('The "replace" filter expects an array or "Traversable" as replace values, got "%s".'\is_object($from) ? \get_class($from) : \gettype($from)));
  487.         }
  488.         return strtr($str ?? ''self::toArray($from));
  489.     }
  490.     /**
  491.      * Rounds a number.
  492.      *
  493.      * @param int|float|string|null $value     The value to round
  494.      * @param int|float             $precision The rounding precision
  495.      * @param string                $method    The method to use for rounding
  496.      *
  497.      * @return int|float The rounded number
  498.      *
  499.      * @internal
  500.      */
  501.     public static function round($value$precision 0$method 'common')
  502.     {
  503.         $value = (float) $value;
  504.         if ('common' === $method) {
  505.             return round($value$precision);
  506.         }
  507.         if ('ceil' !== $method && 'floor' !== $method) {
  508.             throw new RuntimeError('The round filter only supports the "common", "ceil", and "floor" methods.');
  509.         }
  510.         return $method($value 10 ** $precision) / 10 ** $precision;
  511.     }
  512.     /**
  513.      * Formats a number.
  514.      *
  515.      * All of the formatting options can be left null, in that case the defaults will
  516.      * be used. Supplying any of the parameters will override the defaults set in the
  517.      * environment object.
  518.      *
  519.      * @param mixed       $number       A float/int/string of the number to format
  520.      * @param int|null    $decimal      the number of decimal points to display
  521.      * @param string|null $decimalPoint the character(s) to use for the decimal point
  522.      * @param string|null $thousandSep  the character(s) to use for the thousands separator
  523.      */
  524.     public function formatNumber($number$decimal null$decimalPoint null$thousandSep null): string
  525.     {
  526.         $defaults $this->getNumberFormat();
  527.         if (null === $decimal) {
  528.             $decimal $defaults[0];
  529.         }
  530.         if (null === $decimalPoint) {
  531.             $decimalPoint $defaults[1];
  532.         }
  533.         if (null === $thousandSep) {
  534.             $thousandSep $defaults[2];
  535.         }
  536.         return number_format((float) $number$decimal$decimalPoint$thousandSep);
  537.     }
  538.     /**
  539.      * URL encodes (RFC 3986) a string as a path segment or an array as a query string.
  540.      *
  541.      * @param string|array|null $url A URL or an array of query parameters
  542.      *
  543.      * @internal
  544.      */
  545.     public static function urlencode($url): string
  546.     {
  547.         if (\is_array($url)) {
  548.             return http_build_query($url'''&'\PHP_QUERY_RFC3986);
  549.         }
  550.         return rawurlencode($url ?? '');
  551.     }
  552.     /**
  553.      * Merges any number of arrays or Traversable objects.
  554.      *
  555.      *  {% set items = { 'apple': 'fruit', 'orange': 'fruit' } %}
  556.      *
  557.      *  {% set items = items|merge({ 'peugeot': 'car' }, { 'banana': 'fruit' }) %}
  558.      *
  559.      *  {# items now contains { 'apple': 'fruit', 'orange': 'fruit', 'peugeot': 'car', 'banana': 'fruit' } #}
  560.      *
  561.      * @param array|\Traversable ...$arrays Any number of arrays or Traversable objects to merge
  562.      *
  563.      * @internal
  564.      */
  565.     public static function merge(...$arrays): array
  566.     {
  567.         $result = [];
  568.         foreach ($arrays as $argNumber => $array) {
  569.             if (!is_iterable($array)) {
  570.                 throw new RuntimeError(sprintf('The merge filter only works with arrays or "Traversable", got "%s" for argument %d.'\gettype($array), $argNumber 1));
  571.             }
  572.             $result array_merge($resultself::toArray($array));
  573.         }
  574.         return $result;
  575.     }
  576.     /**
  577.      * Slices a variable.
  578.      *
  579.      * @param mixed $item         A variable
  580.      * @param int   $start        Start of the slice
  581.      * @param int   $length       Size of the slice
  582.      * @param bool  $preserveKeys Whether to preserve key or not (when the input is an array)
  583.      *
  584.      * @return mixed The sliced variable
  585.      *
  586.      * @internal
  587.      */
  588.     public static function slice(string $charset$item$start$length null$preserveKeys false)
  589.     {
  590.         if ($item instanceof \Traversable) {
  591.             while ($item instanceof \IteratorAggregate) {
  592.                 $item $item->getIterator();
  593.             }
  594.             if ($start >= && $length >= && $item instanceof \Iterator) {
  595.                 try {
  596.                     return iterator_to_array(new \LimitIterator($item$start$length ?? -1), $preserveKeys);
  597.                 } catch (\OutOfBoundsException $e) {
  598.                     return [];
  599.                 }
  600.             }
  601.             $item iterator_to_array($item$preserveKeys);
  602.         }
  603.         if (\is_array($item)) {
  604.             return \array_slice($item$start$length$preserveKeys);
  605.         }
  606.         return mb_substr((string) $item$start$length$charset);
  607.     }
  608.     /**
  609.      * Returns the first element of the item.
  610.      *
  611.      * @param mixed $item A variable
  612.      *
  613.      * @return mixed The first element of the item
  614.      *
  615.      * @internal
  616.      */
  617.     public static function first(string $charset$item)
  618.     {
  619.         $elements self::slice($charset$item01false);
  620.         return \is_string($elements) ? $elements current($elements);
  621.     }
  622.     /**
  623.      * Returns the last element of the item.
  624.      *
  625.      * @param mixed $item A variable
  626.      *
  627.      * @return mixed The last element of the item
  628.      *
  629.      * @internal
  630.      */
  631.     public static function last(string $charset$item)
  632.     {
  633.         $elements self::slice($charset$item, -11false);
  634.         return \is_string($elements) ? $elements current($elements);
  635.     }
  636.     /**
  637.      * Joins the values to a string.
  638.      *
  639.      * The separators between elements are empty strings per default, you can define them with the optional parameters.
  640.      *
  641.      *  {{ [1, 2, 3]|join(', ', ' and ') }}
  642.      *  {# returns 1, 2 and 3 #}
  643.      *
  644.      *  {{ [1, 2, 3]|join('|') }}
  645.      *  {# returns 1|2|3 #}
  646.      *
  647.      *  {{ [1, 2, 3]|join }}
  648.      *  {# returns 123 #}
  649.      *
  650.      * @param array       $value An array
  651.      * @param string      $glue  The separator
  652.      * @param string|null $and   The separator for the last pair
  653.      *
  654.      * @internal
  655.      */
  656.     public static function join($value$glue ''$and null): string
  657.     {
  658.         if (!is_iterable($value)) {
  659.             $value = (array) $value;
  660.         }
  661.         $value self::toArray($valuefalse);
  662.         if (=== \count($value)) {
  663.             return '';
  664.         }
  665.         if (null === $and || $and === $glue) {
  666.             return implode($glue$value);
  667.         }
  668.         if (=== \count($value)) {
  669.             return $value[0];
  670.         }
  671.         return implode($glue\array_slice($value0, -1)).$and.$value[\count($value) - 1];
  672.     }
  673.     /**
  674.      * Splits the string into an array.
  675.      *
  676.      *  {{ "one,two,three"|split(',') }}
  677.      *  {# returns [one, two, three] #}
  678.      *
  679.      *  {{ "one,two,three,four,five"|split(',', 3) }}
  680.      *  {# returns [one, two, "three,four,five"] #}
  681.      *
  682.      *  {{ "123"|split('') }}
  683.      *  {# returns [1, 2, 3] #}
  684.      *
  685.      *  {{ "aabbcc"|split('', 2) }}
  686.      *  {# returns [aa, bb, cc] #}
  687.      *
  688.      * @param string|null $value     A string
  689.      * @param string      $delimiter The delimiter
  690.      * @param int|null    $limit     The limit
  691.      *
  692.      * @internal
  693.      */
  694.     public static function split(string $charset$value$delimiter$limit null): array
  695.     {
  696.         $value $value ?? '';
  697.         if ('' !== $delimiter) {
  698.             return null === $limit explode($delimiter$value) : explode($delimiter$value$limit);
  699.         }
  700.         if ($limit <= 1) {
  701.             return preg_split('/(?<!^)(?!$)/u'$value);
  702.         }
  703.         $length mb_strlen($value$charset);
  704.         if ($length $limit) {
  705.             return [$value];
  706.         }
  707.         $r = [];
  708.         for ($i 0$i $length$i += $limit) {
  709.             $r[] = mb_substr($value$i$limit$charset);
  710.         }
  711.         return $r;
  712.     }
  713.     // The '_default' filter is used internally to avoid using the ternary operator
  714.     // which costs a lot for big contexts (before PHP 5.4). So, on average,
  715.     // a function call is cheaper.
  716.     /**
  717.      * @internal
  718.      */
  719.     public static function default($value$default '')
  720.     {
  721.         if (self::testEmpty($value)) {
  722.             return $default;
  723.         }
  724.         return $value;
  725.     }
  726.     /**
  727.      * Returns the keys for the given array.
  728.      *
  729.      * It is useful when you want to iterate over the keys of an array:
  730.      *
  731.      *  {% for key in array|keys %}
  732.      *      {# ... #}
  733.      *  {% endfor %}
  734.      *
  735.      * @internal
  736.      */
  737.     public static function keys($array): array
  738.     {
  739.         if ($array instanceof \Traversable) {
  740.             while ($array instanceof \IteratorAggregate) {
  741.                 $array $array->getIterator();
  742.             }
  743.             $keys = [];
  744.             if ($array instanceof \Iterator) {
  745.                 $array->rewind();
  746.                 while ($array->valid()) {
  747.                     $keys[] = $array->key();
  748.                     $array->next();
  749.                 }
  750.                 return $keys;
  751.             }
  752.             foreach ($array as $key => $item) {
  753.                 $keys[] = $key;
  754.             }
  755.             return $keys;
  756.         }
  757.         if (!\is_array($array)) {
  758.             return [];
  759.         }
  760.         return array_keys($array);
  761.     }
  762.     /**
  763.      * Reverses a variable.
  764.      *
  765.      * @param array|\Traversable|string|null $item         An array, a \Traversable instance, or a string
  766.      * @param bool                           $preserveKeys Whether to preserve key or not
  767.      *
  768.      * @return mixed The reversed input
  769.      *
  770.      * @internal
  771.      */
  772.     public static function reverse(string $charset$item$preserveKeys false)
  773.     {
  774.         if ($item instanceof \Traversable) {
  775.             return array_reverse(iterator_to_array($item), $preserveKeys);
  776.         }
  777.         if (\is_array($item)) {
  778.             return array_reverse($item$preserveKeys);
  779.         }
  780.         $string = (string) $item;
  781.         if ('UTF-8' !== $charset) {
  782.             $string self::convertEncoding($string'UTF-8'$charset);
  783.         }
  784.         preg_match_all('/./us'$string$matches);
  785.         $string implode(''array_reverse($matches[0]));
  786.         if ('UTF-8' !== $charset) {
  787.             $string self::convertEncoding($string$charset'UTF-8');
  788.         }
  789.         return $string;
  790.     }
  791.     /**
  792.      * Sorts an array.
  793.      *
  794.      * @param array|\Traversable $array
  795.      *
  796.      * @internal
  797.      */
  798.     public static function sort(Environment $env$array$arrow null): array
  799.     {
  800.         if ($array instanceof \Traversable) {
  801.             $array iterator_to_array($array);
  802.         } elseif (!\is_array($array)) {
  803.             throw new RuntimeError(sprintf('The sort filter only works with arrays or "Traversable", got "%s".'\gettype($array)));
  804.         }
  805.         if (null !== $arrow) {
  806.             self::checkArrowInSandbox($env$arrow'sort''filter');
  807.             uasort($array$arrow);
  808.         } else {
  809.             asort($array);
  810.         }
  811.         return $array;
  812.     }
  813.     /**
  814.      * @internal
  815.      */
  816.     public static function inFilter($value$compare)
  817.     {
  818.         if ($value instanceof Markup) {
  819.             $value = (string) $value;
  820.         }
  821.         if ($compare instanceof Markup) {
  822.             $compare = (string) $compare;
  823.         }
  824.         if (\is_string($compare)) {
  825.             if (\is_string($value) || \is_int($value) || \is_float($value)) {
  826.                 return '' === $value || str_contains($compare, (string) $value);
  827.             }
  828.             return false;
  829.         }
  830.         if (!is_iterable($compare)) {
  831.             return false;
  832.         }
  833.         if (\is_object($value) || \is_resource($value)) {
  834.             if (!\is_array($compare)) {
  835.                 foreach ($compare as $item) {
  836.                     if ($item === $value) {
  837.                         return true;
  838.                     }
  839.                 }
  840.                 return false;
  841.             }
  842.             return \in_array($value$comparetrue);
  843.         }
  844.         foreach ($compare as $item) {
  845.             if (=== self::compare($value$item)) {
  846.                 return true;
  847.             }
  848.         }
  849.         return false;
  850.     }
  851.     /**
  852.      * Compares two values using a more strict version of the PHP non-strict comparison operator.
  853.      *
  854.      * @see https://wiki.php.net/rfc/string_to_number_comparison
  855.      * @see https://wiki.php.net/rfc/trailing_whitespace_numerics
  856.      *
  857.      * @internal
  858.      */
  859.     public static function compare($a$b)
  860.     {
  861.         // int <=> string
  862.         if (\is_int($a) && \is_string($b)) {
  863.             $bTrim trim($b" \t\n\r\v\f");
  864.             if (!is_numeric($bTrim)) {
  865.                 return (string) $a <=> $b;
  866.             }
  867.             if ((int) $bTrim == $bTrim) {
  868.                 return $a <=> (int) $bTrim;
  869.             } else {
  870.                 return (float) $a <=> (float) $bTrim;
  871.             }
  872.         }
  873.         if (\is_string($a) && \is_int($b)) {
  874.             $aTrim trim($a" \t\n\r\v\f");
  875.             if (!is_numeric($aTrim)) {
  876.                 return $a <=> (string) $b;
  877.             }
  878.             if ((int) $aTrim == $aTrim) {
  879.                 return (int) $aTrim <=> $b;
  880.             } else {
  881.                 return (float) $aTrim <=> (float) $b;
  882.             }
  883.         }
  884.         // float <=> string
  885.         if (\is_float($a) && \is_string($b)) {
  886.             if (is_nan($a)) {
  887.                 return 1;
  888.             }
  889.             $bTrim trim($b" \t\n\r\v\f");
  890.             if (!is_numeric($bTrim)) {
  891.                 return (string) $a <=> $b;
  892.             }
  893.             return $a <=> (float) $bTrim;
  894.         }
  895.         if (\is_string($a) && \is_float($b)) {
  896.             if (is_nan($b)) {
  897.                 return 1;
  898.             }
  899.             $aTrim trim($a" \t\n\r\v\f");
  900.             if (!is_numeric($aTrim)) {
  901.                 return $a <=> (string) $b;
  902.             }
  903.             return (float) $aTrim <=> $b;
  904.         }
  905.         // fallback to <=>
  906.         return $a <=> $b;
  907.     }
  908.     /**
  909.      * @throws RuntimeError When an invalid pattern is used
  910.      *
  911.      * @internal
  912.      */
  913.     public static function matches(string $regexp, ?string $str): int
  914.     {
  915.         set_error_handler(function ($t$m) use ($regexp) {
  916.             throw new RuntimeError(sprintf('Regexp "%s" passed to "matches" is not valid'$regexp).substr($m12));
  917.         });
  918.         try {
  919.             return preg_match($regexp$str ?? '');
  920.         } finally {
  921.             restore_error_handler();
  922.         }
  923.     }
  924.     /**
  925.      * Returns a trimmed string.
  926.      *
  927.      * @param string|null $string
  928.      * @param string|null $characterMask
  929.      * @param string      $side
  930.      *
  931.      * @throws RuntimeError When an invalid trimming side is used (not a string or not 'left', 'right', or 'both')
  932.      *
  933.      * @internal
  934.      */
  935.     public static function trim($string$characterMask null$side 'both'): string
  936.     {
  937.         if (null === $characterMask) {
  938.             $characterMask " \t\n\r\0\x0B";
  939.         }
  940.         switch ($side) {
  941.             case 'both':
  942.                 return trim($string ?? ''$characterMask);
  943.             case 'left':
  944.                 return ltrim($string ?? ''$characterMask);
  945.             case 'right':
  946.                 return rtrim($string ?? ''$characterMask);
  947.             default:
  948.                 throw new RuntimeError('Trimming side must be "left", "right" or "both".');
  949.         }
  950.     }
  951.     /**
  952.      * Inserts HTML line breaks before all newlines in a string.
  953.      *
  954.      * @param string|null $string
  955.      *
  956.      * @internal
  957.      */
  958.     public static function nl2br($string): string
  959.     {
  960.         return nl2br($string ?? '');
  961.     }
  962.     /**
  963.      * Removes whitespaces between HTML tags.
  964.      *
  965.      * @param string|null $content
  966.      *
  967.      * @internal
  968.      */
  969.     public static function spaceless($content): string
  970.     {
  971.         return trim(preg_replace('/>\s+</''><'$content ?? ''));
  972.     }
  973.     /**
  974.      * @param string|null $string
  975.      * @param string      $to
  976.      * @param string      $from
  977.      *
  978.      * @internal
  979.      */
  980.     public static function convertEncoding($string$to$from): string
  981.     {
  982.         if (!\function_exists('iconv')) {
  983.             throw new RuntimeError('Unable to convert encoding: required function iconv() does not exist. You should install ext-iconv or symfony/polyfill-iconv.');
  984.         }
  985.         return iconv($from$to$string ?? '');
  986.     }
  987.     /**
  988.      * Returns the length of a variable.
  989.      *
  990.      * @param mixed $thing A variable
  991.      *
  992.      * @internal
  993.      */
  994.     public static function length(string $charset$thing): int
  995.     {
  996.         if (null === $thing) {
  997.             return 0;
  998.         }
  999.         if (\is_scalar($thing)) {
  1000.             return mb_strlen($thing$charset);
  1001.         }
  1002.         if ($thing instanceof \Countable || \is_array($thing) || $thing instanceof \SimpleXMLElement) {
  1003.             return \count($thing);
  1004.         }
  1005.         if ($thing instanceof \Traversable) {
  1006.             return iterator_count($thing);
  1007.         }
  1008.         if (method_exists($thing'__toString')) {
  1009.             return mb_strlen((string) $thing$charset);
  1010.         }
  1011.         return 1;
  1012.     }
  1013.     /**
  1014.      * Converts a string to uppercase.
  1015.      *
  1016.      * @param string|null $string A string
  1017.      *
  1018.      * @internal
  1019.      */
  1020.     public static function upper(string $charset$string): string
  1021.     {
  1022.         return mb_strtoupper($string ?? ''$charset);
  1023.     }
  1024.     /**
  1025.      * Converts a string to lowercase.
  1026.      *
  1027.      * @param string|null $string A string
  1028.      *
  1029.      * @internal
  1030.      */
  1031.     public static function lower(string $charset$string): string
  1032.     {
  1033.         return mb_strtolower($string ?? ''$charset);
  1034.     }
  1035.     /**
  1036.      * Strips HTML and PHP tags from a string.
  1037.      *
  1038.      * @param string|null          $string
  1039.      * @param string[]|string|null $allowable_tags
  1040.      *
  1041.      * @internal
  1042.      */
  1043.     public static function striptags($string$allowable_tags null): string
  1044.     {
  1045.         return strip_tags($string ?? ''$allowable_tags);
  1046.     }
  1047.     /**
  1048.      * Returns a titlecased string.
  1049.      *
  1050.      * @param string|null $string A string
  1051.      *
  1052.      * @internal
  1053.      */
  1054.     public static function titleCase(string $charset$string): string
  1055.     {
  1056.         return mb_convert_case($string ?? ''\MB_CASE_TITLE$charset);
  1057.     }
  1058.     /**
  1059.      * Returns a capitalized string.
  1060.      *
  1061.      * @param string|null $string A string
  1062.      *
  1063.      * @internal
  1064.      */
  1065.     public static function capitalize(string $charset$string): string
  1066.     {
  1067.         return mb_strtoupper(mb_substr($string ?? ''01$charset), $charset).mb_strtolower(mb_substr($string ?? ''1null$charset), $charset);
  1068.     }
  1069.     /**
  1070.      * @internal
  1071.      */
  1072.     public static function callMacro(Template $templatestring $method, array $argsint $lineno, array $contextSource $source)
  1073.     {
  1074.         if (!method_exists($template$method)) {
  1075.             $parent $template;
  1076.             while ($parent $parent->getParent($context)) {
  1077.                 if (method_exists($parent$method)) {
  1078.                     return $parent->$method(...$args);
  1079.                 }
  1080.             }
  1081.             throw new RuntimeError(sprintf('Macro "%s" is not defined in template "%s".'substr($method\strlen('macro_')), $template->getTemplateName()), $lineno$source);
  1082.         }
  1083.         return $template->$method(...$args);
  1084.     }
  1085.     /**
  1086.      * @internal
  1087.      */
  1088.     public static function ensureTraversable($seq)
  1089.     {
  1090.         if (is_iterable($seq)) {
  1091.             return $seq;
  1092.         }
  1093.         return [];
  1094.     }
  1095.     /**
  1096.      * @internal
  1097.      */
  1098.     public static function toArray($seq$preserveKeys true)
  1099.     {
  1100.         if ($seq instanceof \Traversable) {
  1101.             return iterator_to_array($seq$preserveKeys);
  1102.         }
  1103.         if (!\is_array($seq)) {
  1104.             return $seq;
  1105.         }
  1106.         return $preserveKeys $seq array_values($seq);
  1107.     }
  1108.     /**
  1109.      * Checks if a variable is empty.
  1110.      *
  1111.      *    {# evaluates to true if the foo variable is null, false, or the empty string #}
  1112.      *    {% if foo is empty %}
  1113.      *        {# ... #}
  1114.      *    {% endif %}
  1115.      *
  1116.      * @param mixed $value A variable
  1117.      *
  1118.      * @internal
  1119.      */
  1120.     public static function testEmpty($value): bool
  1121.     {
  1122.         if ($value instanceof \Countable) {
  1123.             return === \count($value);
  1124.         }
  1125.         if ($value instanceof \Traversable) {
  1126.             return !iterator_count($value);
  1127.         }
  1128.         if (\is_object($value) && method_exists($value'__toString')) {
  1129.             return '' === (string) $value;
  1130.         }
  1131.         return '' === $value || false === $value || null === $value || [] === $value;
  1132.     }
  1133.     /**
  1134.      * Renders a template.
  1135.      *
  1136.      * @param array                        $context
  1137.      * @param string|array|TemplateWrapper $template      The template to render or an array of templates to try consecutively
  1138.      * @param array                        $variables     The variables to pass to the template
  1139.      * @param bool                         $withContext
  1140.      * @param bool                         $ignoreMissing Whether to ignore missing templates or not
  1141.      * @param bool                         $sandboxed     Whether to sandbox the template or not
  1142.      *
  1143.      * @internal
  1144.      */
  1145.     public static function include(Environment $env$context$template$variables = [], $withContext true$ignoreMissing false$sandboxed false): string
  1146.     {
  1147.         $alreadySandboxed false;
  1148.         $sandbox null;
  1149.         if ($withContext) {
  1150.             $variables array_merge($context$variables);
  1151.         }
  1152.         if ($isSandboxed $sandboxed && $env->hasExtension(SandboxExtension::class)) {
  1153.             $sandbox $env->getExtension(SandboxExtension::class);
  1154.             if (!$alreadySandboxed $sandbox->isSandboxed()) {
  1155.                 $sandbox->enableSandbox();
  1156.             }
  1157.             foreach ((\is_array($template) ? $template : [$template]) as $name) {
  1158.                 // if a Template instance is passed, it might have been instantiated outside of a sandbox, check security
  1159.                 if ($name instanceof TemplateWrapper || $name instanceof Template) {
  1160.                     $name->unwrap()->checkSecurity();
  1161.                 }
  1162.             }
  1163.         }
  1164.         try {
  1165.             $loaded null;
  1166.             try {
  1167.                 $loaded $env->resolveTemplate($template);
  1168.             } catch (LoaderError $e) {
  1169.                 if (!$ignoreMissing) {
  1170.                     throw $e;
  1171.                 }
  1172.             }
  1173.             return $loaded $loaded->render($variables) : '';
  1174.         } finally {
  1175.             if ($isSandboxed && !$alreadySandboxed) {
  1176.                 $sandbox->disableSandbox();
  1177.             }
  1178.         }
  1179.     }
  1180.     /**
  1181.      * Returns a template content without rendering it.
  1182.      *
  1183.      * @param string $name          The template name
  1184.      * @param bool   $ignoreMissing Whether to ignore missing templates or not
  1185.      *
  1186.      * @internal
  1187.      */
  1188.     public static function source(Environment $env$name$ignoreMissing false): string
  1189.     {
  1190.         $loader $env->getLoader();
  1191.         try {
  1192.             return $loader->getSourceContext($name)->getCode();
  1193.         } catch (LoaderError $e) {
  1194.             if (!$ignoreMissing) {
  1195.                 throw $e;
  1196.             }
  1197.             return '';
  1198.         }
  1199.     }
  1200.     /**
  1201.      * Provides the ability to get constants from instances as well as class/global constants.
  1202.      *
  1203.      * @param string      $constant The name of the constant
  1204.      * @param object|null $object   The object to get the constant from
  1205.      *
  1206.      * @return mixed Class constants can return many types like scalars, arrays, and
  1207.      *               objects depending on the PHP version (\BackedEnum, \UnitEnum, etc.)
  1208.      *
  1209.      * @internal
  1210.      */
  1211.     public static function constant($constant$object null)
  1212.     {
  1213.         if (null !== $object) {
  1214.             if ('class' === $constant) {
  1215.                 return \get_class($object);
  1216.             }
  1217.             $constant \get_class($object).'::'.$constant;
  1218.         }
  1219.         if (!\defined($constant)) {
  1220.             if ('::class' === strtolower(substr($constant, -7))) {
  1221.                 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));
  1222.             }
  1223.             throw new RuntimeError(sprintf('Constant "%s" is undefined.'$constant));
  1224.         }
  1225.         return \constant($constant);
  1226.     }
  1227.     /**
  1228.      * Checks if a constant exists.
  1229.      *
  1230.      * @param string      $constant The name of the constant
  1231.      * @param object|null $object   The object to get the constant from
  1232.      *
  1233.      * @internal
  1234.      */
  1235.     public static function constantIsDefined($constant$object null): bool
  1236.     {
  1237.         if (null !== $object) {
  1238.             if ('class' === $constant) {
  1239.                 return true;
  1240.             }
  1241.             $constant \get_class($object).'::'.$constant;
  1242.         }
  1243.         return \defined($constant);
  1244.     }
  1245.     /**
  1246.      * Batches item.
  1247.      *
  1248.      * @param array $items An array of items
  1249.      * @param int   $size  The size of the batch
  1250.      * @param mixed $fill  A value used to fill missing items
  1251.      *
  1252.      * @internal
  1253.      */
  1254.     public static function batch($items$size$fill null$preserveKeys true): array
  1255.     {
  1256.         if (!is_iterable($items)) {
  1257.             throw new RuntimeError(sprintf('The "batch" filter expects an array or "Traversable", got "%s".'\is_object($items) ? \get_class($items) : \gettype($items)));
  1258.         }
  1259.         $size ceil($size);
  1260.         $result array_chunk(self::toArray($items$preserveKeys), $size$preserveKeys);
  1261.         if (null !== $fill && $result) {
  1262.             $last \count($result) - 1;
  1263.             if ($fillCount $size \count($result[$last])) {
  1264.                 for ($i 0$i $fillCount; ++$i) {
  1265.                     $result[$last][] = $fill;
  1266.                 }
  1267.             }
  1268.         }
  1269.         return $result;
  1270.     }
  1271.     /**
  1272.      * Returns the attribute value for a given array/object.
  1273.      *
  1274.      * @param mixed  $object            The object or array from where to get the item
  1275.      * @param mixed  $item              The item to get from the array or object
  1276.      * @param array  $arguments         An array of arguments to pass if the item is an object method
  1277.      * @param string $type              The type of attribute (@see \Twig\Template constants)
  1278.      * @param bool   $isDefinedTest     Whether this is only a defined check
  1279.      * @param bool   $ignoreStrictCheck Whether to ignore the strict attribute check or not
  1280.      * @param int    $lineno            The template line where the attribute was called
  1281.      *
  1282.      * @return mixed The attribute value, or a Boolean when $isDefinedTest is true, or null when the attribute is not set and $ignoreStrictCheck is true
  1283.      *
  1284.      * @throws RuntimeError if the attribute does not exist and Twig is running in strict mode and $isDefinedTest is false
  1285.      *
  1286.      * @internal
  1287.      */
  1288.     public static function getAttribute(Environment $envSource $source$object$item, array $arguments = [], $type /* Template::ANY_CALL */ 'any'$isDefinedTest false$ignoreStrictCheck false$sandboxed falseint $lineno = -1)
  1289.     {
  1290.         // array
  1291.         if (/* Template::METHOD_CALL */ 'method' !== $type) {
  1292.             $arrayItem \is_bool($item) || \is_float($item) ? (int) $item $item;
  1293.             if (((\is_array($object) || $object instanceof \ArrayObject) && (isset($object[$arrayItem]) || \array_key_exists($arrayItem, (array) $object)))
  1294.                 || ($object instanceof \ArrayAccess && isset($object[$arrayItem]))
  1295.             ) {
  1296.                 if ($isDefinedTest) {
  1297.                     return true;
  1298.                 }
  1299.                 return $object[$arrayItem];
  1300.             }
  1301.             if (/* Template::ARRAY_CALL */ 'array' === $type || !\is_object($object)) {
  1302.                 if ($isDefinedTest) {
  1303.                     return false;
  1304.                 }
  1305.                 if ($ignoreStrictCheck || !$env->isStrictVariables()) {
  1306.                     return;
  1307.                 }
  1308.                 if ($object instanceof \ArrayAccess) {
  1309.                     $message sprintf('Key "%s" in object with ArrayAccess of class "%s" does not exist.'$arrayItem\get_class($object));
  1310.                 } elseif (\is_object($object)) {
  1311.                     $message sprintf('Impossible to access a key "%s" on an object of class "%s" that does not implement ArrayAccess interface.'$item\get_class($object));
  1312.                 } elseif (\is_array($object)) {
  1313.                     if (empty($object)) {
  1314.                         $message sprintf('Key "%s" does not exist as the array is empty.'$arrayItem);
  1315.                     } else {
  1316.                         $message sprintf('Key "%s" for array with keys "%s" does not exist.'$arrayItemimplode(', 'array_keys($object)));
  1317.                     }
  1318.                 } elseif (/* Template::ARRAY_CALL */ 'array' === $type) {
  1319.                     if (null === $object) {
  1320.                         $message sprintf('Impossible to access a key ("%s") on a null variable.'$item);
  1321.                     } else {
  1322.                         $message sprintf('Impossible to access a key ("%s") on a %s variable ("%s").'$item\gettype($object), $object);
  1323.                     }
  1324.                 } elseif (null === $object) {
  1325.                     $message sprintf('Impossible to access an attribute ("%s") on a null variable.'$item);
  1326.                 } else {
  1327.                     $message sprintf('Impossible to access an attribute ("%s") on a %s variable ("%s").'$item\gettype($object), $object);
  1328.                 }
  1329.                 throw new RuntimeError($message$lineno$source);
  1330.             }
  1331.         }
  1332.         if (!\is_object($object)) {
  1333.             if ($isDefinedTest) {
  1334.                 return false;
  1335.             }
  1336.             if ($ignoreStrictCheck || !$env->isStrictVariables()) {
  1337.                 return;
  1338.             }
  1339.             if (null === $object) {
  1340.                 $message sprintf('Impossible to invoke a method ("%s") on a null variable.'$item);
  1341.             } elseif (\is_array($object)) {
  1342.                 $message sprintf('Impossible to invoke a method ("%s") on an array.'$item);
  1343.             } else {
  1344.                 $message sprintf('Impossible to invoke a method ("%s") on a %s variable ("%s").'$item\gettype($object), $object);
  1345.             }
  1346.             throw new RuntimeError($message$lineno$source);
  1347.         }
  1348.         if ($object instanceof Template) {
  1349.             throw new RuntimeError('Accessing \Twig\Template attributes is forbidden.'$lineno$source);
  1350.         }
  1351.         // object property
  1352.         if (/* Template::METHOD_CALL */ 'method' !== $type) {
  1353.             if (isset($object->$item) || \array_key_exists((string) $item, (array) $object)) {
  1354.                 if ($isDefinedTest) {
  1355.                     return true;
  1356.                 }
  1357.                 if ($sandboxed) {
  1358.                     $env->getExtension(SandboxExtension::class)->checkPropertyAllowed($object$item$lineno$source);
  1359.                 }
  1360.                 return $object->$item;
  1361.             }
  1362.         }
  1363.         static $cache = [];
  1364.         $class \get_class($object);
  1365.         // object method
  1366.         // precedence: getXxx() > isXxx() > hasXxx()
  1367.         if (!isset($cache[$class])) {
  1368.             $methods get_class_methods($object);
  1369.             sort($methods);
  1370.             $lcMethods array_map(function ($value) { return strtr($value'ABCDEFGHIJKLMNOPQRSTUVWXYZ''abcdefghijklmnopqrstuvwxyz'); }, $methods);
  1371.             $classCache = [];
  1372.             foreach ($methods as $i => $method) {
  1373.                 $classCache[$method] = $method;
  1374.                 $classCache[$lcName $lcMethods[$i]] = $method;
  1375.                 if ('g' === $lcName[0] && str_starts_with($lcName'get')) {
  1376.                     $name substr($method3);
  1377.                     $lcName substr($lcName3);
  1378.                 } elseif ('i' === $lcName[0] && str_starts_with($lcName'is')) {
  1379.                     $name substr($method2);
  1380.                     $lcName substr($lcName2);
  1381.                 } elseif ('h' === $lcName[0] && str_starts_with($lcName'has')) {
  1382.                     $name substr($method3);
  1383.                     $lcName substr($lcName3);
  1384.                     if (\in_array('is'.$lcName$lcMethods)) {
  1385.                         continue;
  1386.                     }
  1387.                 } else {
  1388.                     continue;
  1389.                 }
  1390.                 // skip get() and is() methods (in which case, $name is empty)
  1391.                 if ($name) {
  1392.                     if (!isset($classCache[$name])) {
  1393.                         $classCache[$name] = $method;
  1394.                     }
  1395.                     if (!isset($classCache[$lcName])) {
  1396.                         $classCache[$lcName] = $method;
  1397.                     }
  1398.                 }
  1399.             }
  1400.             $cache[$class] = $classCache;
  1401.         }
  1402.         $call false;
  1403.         if (isset($cache[$class][$item])) {
  1404.             $method $cache[$class][$item];
  1405.         } elseif (isset($cache[$class][$lcItem strtr($item'ABCDEFGHIJKLMNOPQRSTUVWXYZ''abcdefghijklmnopqrstuvwxyz')])) {
  1406.             $method $cache[$class][$lcItem];
  1407.         } elseif (isset($cache[$class]['__call'])) {
  1408.             $method $item;
  1409.             $call true;
  1410.         } else {
  1411.             if ($isDefinedTest) {
  1412.                 return false;
  1413.             }
  1414.             if ($ignoreStrictCheck || !$env->isStrictVariables()) {
  1415.                 return;
  1416.             }
  1417.             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);
  1418.         }
  1419.         if ($isDefinedTest) {
  1420.             return true;
  1421.         }
  1422.         if ($sandboxed) {
  1423.             $env->getExtension(SandboxExtension::class)->checkMethodAllowed($object$method$lineno$source);
  1424.         }
  1425.         // Some objects throw exceptions when they have __call, and the method we try
  1426.         // to call is not supported. If ignoreStrictCheck is true, we should return null.
  1427.         try {
  1428.             $ret $object->$method(...$arguments);
  1429.         } catch (\BadMethodCallException $e) {
  1430.             if ($call && ($ignoreStrictCheck || !$env->isStrictVariables())) {
  1431.                 return;
  1432.             }
  1433.             throw $e;
  1434.         }
  1435.         return $ret;
  1436.     }
  1437.     /**
  1438.      * Returns the values from a single column in the input array.
  1439.      *
  1440.      * <pre>
  1441.      *  {% set items = [{ 'fruit' : 'apple'}, {'fruit' : 'orange' }] %}
  1442.      *
  1443.      *  {% set fruits = items|column('fruit') %}
  1444.      *
  1445.      *  {# fruits now contains ['apple', 'orange'] #}
  1446.      * </pre>
  1447.      *
  1448.      * @param array|\Traversable $array An array
  1449.      * @param int|string         $name  The column name
  1450.      * @param int|string|null    $index The column to use as the index/keys for the returned array
  1451.      *
  1452.      * @return array The array of values
  1453.      *
  1454.      * @internal
  1455.      */
  1456.     public static function column($array$name$index null): array
  1457.     {
  1458.         if ($array instanceof \Traversable) {
  1459.             $array iterator_to_array($array);
  1460.         } elseif (!\is_array($array)) {
  1461.             throw new RuntimeError(sprintf('The column filter only works with arrays or "Traversable", got "%s" as first argument.'\gettype($array)));
  1462.         }
  1463.         return array_column($array$name$index);
  1464.     }
  1465.     /**
  1466.      * @internal
  1467.      */
  1468.     public static function filter(Environment $env$array$arrow)
  1469.     {
  1470.         if (!is_iterable($array)) {
  1471.             throw new RuntimeError(sprintf('The "filter" filter expects an array or "Traversable", got "%s".'\is_object($array) ? \get_class($array) : \gettype($array)));
  1472.         }
  1473.         self::checkArrowInSandbox($env$arrow'filter''filter');
  1474.         if (\is_array($array)) {
  1475.             return array_filter($array$arrow\ARRAY_FILTER_USE_BOTH);
  1476.         }
  1477.         // the IteratorIterator wrapping is needed as some internal PHP classes are \Traversable but do not implement \Iterator
  1478.         return new \CallbackFilterIterator(new \IteratorIterator($array), $arrow);
  1479.     }
  1480.     /**
  1481.      * @internal
  1482.      */
  1483.     public static function map(Environment $env$array$arrow)
  1484.     {
  1485.         self::checkArrowInSandbox($env$arrow'map''filter');
  1486.         $r = [];
  1487.         foreach ($array as $k => $v) {
  1488.             $r[$k] = $arrow($v$k);
  1489.         }
  1490.         return $r;
  1491.     }
  1492.     /**
  1493.      * @internal
  1494.      */
  1495.     public static function reduce(Environment $env$array$arrow$initial null)
  1496.     {
  1497.         self::checkArrowInSandbox($env$arrow'reduce''filter');
  1498.         if (!\is_array($array) && !$array instanceof \Traversable) {
  1499.             throw new RuntimeError(sprintf('The "reduce" filter only works with arrays or "Traversable", got "%s" as first argument.'\gettype($array)));
  1500.         }
  1501.         $accumulator $initial;
  1502.         foreach ($array as $key => $value) {
  1503.             $accumulator $arrow($accumulator$value$key);
  1504.         }
  1505.         return $accumulator;
  1506.     }
  1507.     /**
  1508.      * @internal
  1509.      */
  1510.     public static function arraySome(Environment $env$array$arrow)
  1511.     {
  1512.         self::checkArrowInSandbox($env$arrow'has some''operator');
  1513.         foreach ($array as $k => $v) {
  1514.             if ($arrow($v$k)) {
  1515.                 return true;
  1516.             }
  1517.         }
  1518.         return false;
  1519.     }
  1520.     /**
  1521.      * @internal
  1522.      */
  1523.     public static function arrayEvery(Environment $env$array$arrow)
  1524.     {
  1525.         self::checkArrowInSandbox($env$arrow'has every''operator');
  1526.         foreach ($array as $k => $v) {
  1527.             if (!$arrow($v$k)) {
  1528.                 return false;
  1529.             }
  1530.         }
  1531.         return true;
  1532.     }
  1533.     /**
  1534.      * @internal
  1535.      */
  1536.     public static function checkArrowInSandbox(Environment $env$arrow$thing$type)
  1537.     {
  1538.         if (!$arrow instanceof \Closure && $env->hasExtension(SandboxExtension::class) && $env->getExtension(SandboxExtension::class)->isSandboxed()) {
  1539.             throw new RuntimeError(sprintf('The callable passed to the "%s" %s must be a Closure in sandbox mode.'$thing$type));
  1540.         }
  1541.     }
  1542.     /**
  1543.      * @internal to be removed in Twig 4
  1544.      */
  1545.     public static function captureOutput(iterable $body): string
  1546.     {
  1547.         $output '';
  1548.         $level ob_get_level();
  1549.         ob_start();
  1550.         try {
  1551.             foreach ($body as $data) {
  1552.                 if (ob_get_length()) {
  1553.                     $output .= ob_get_clean();
  1554.                     ob_start();
  1555.                 }
  1556.                 $output .= $data;
  1557.             }
  1558.             if (ob_get_length()) {
  1559.                 $output .= ob_get_clean();
  1560.             }
  1561.         } finally {
  1562.             while (ob_get_level() > $level) {
  1563.                 ob_end_clean();
  1564.             }
  1565.         }
  1566.         return $output;
  1567.     }
  1568. }