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

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