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

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