vendor/twig/twig/src/Extension/CoreExtension.php line1412

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 {
  13. use Twig\ExpressionParser;
  14. use Twig\Node\Expression\Binary\AddBinary;
  15. use Twig\Node\Expression\Binary\AndBinary;
  16. use Twig\Node\Expression\Binary\BitwiseAndBinary;
  17. use Twig\Node\Expression\Binary\BitwiseOrBinary;
  18. use Twig\Node\Expression\Binary\BitwiseXorBinary;
  19. use Twig\Node\Expression\Binary\ConcatBinary;
  20. use Twig\Node\Expression\Binary\DivBinary;
  21. use Twig\Node\Expression\Binary\EndsWithBinary;
  22. use Twig\Node\Expression\Binary\EqualBinary;
  23. use Twig\Node\Expression\Binary\FloorDivBinary;
  24. use Twig\Node\Expression\Binary\GreaterBinary;
  25. use Twig\Node\Expression\Binary\GreaterEqualBinary;
  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\StartsWithBinary;
  38. use Twig\Node\Expression\Binary\SubBinary;
  39. use Twig\Node\Expression\Filter\DefaultFilter;
  40. use Twig\Node\Expression\NullCoalesceExpression;
  41. use Twig\Node\Expression\Test\ConstantTest;
  42. use Twig\Node\Expression\Test\DefinedTest;
  43. use Twig\Node\Expression\Test\DivisiblebyTest;
  44. use Twig\Node\Expression\Test\EvenTest;
  45. use Twig\Node\Expression\Test\NullTest;
  46. use Twig\Node\Expression\Test\OddTest;
  47. use Twig\Node\Expression\Test\SameasTest;
  48. use Twig\Node\Expression\Unary\NegUnary;
  49. use Twig\Node\Expression\Unary\NotUnary;
  50. use Twig\Node\Expression\Unary\PosUnary;
  51. use Twig\TokenParser\BlockTokenParser;
  52. use Twig\TokenParser\DeprecatedTokenParser;
  53. use Twig\TokenParser\DoTokenParser;
  54. use Twig\TokenParser\EmbedTokenParser;
  55. use Twig\TokenParser\ExtendsTokenParser;
  56. use Twig\TokenParser\FilterTokenParser;
  57. use Twig\TokenParser\FlushTokenParser;
  58. use Twig\TokenParser\ForTokenParser;
  59. use Twig\TokenParser\FromTokenParser;
  60. use Twig\TokenParser\IfTokenParser;
  61. use Twig\TokenParser\ImportTokenParser;
  62. use Twig\TokenParser\IncludeTokenParser;
  63. use Twig\TokenParser\MacroTokenParser;
  64. use Twig\TokenParser\SetTokenParser;
  65. use Twig\TokenParser\SpacelessTokenParser;
  66. use Twig\TokenParser\UseTokenParser;
  67. use Twig\TokenParser\WithTokenParser;
  68. use Twig\TwigFilter;
  69. use Twig\TwigFunction;
  70. 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.     private $escapers = [];
  79.     /**
  80.      * Defines a new escaper to be used via the escape filter.
  81.      *
  82.      * @param string   $strategy The strategy name that should be used as a strategy in the escape call
  83.      * @param callable $callable A valid PHP callable
  84.      */
  85.     public function setEscaper($strategy, callable $callable)
  86.     {
  87.         $this->escapers[$strategy] = $callable;
  88.     }
  90.     /**
  91.      * Gets all defined escapers.
  92.      *
  93.      * @return callable[] An array of escapers
  94.      */
  95.     public function getEscapers()
  96.     {
  97.         return $this->escapers;
  98.     }
  100.     /**
  101.      * Sets the default format to be used by the date filter.
  102.      *
  103.      * @param string $format             The default date format string
  104.      * @param string $dateIntervalFormat The default date interval format string
  105.      */
  106.     public function setDateFormat($format = null, $dateIntervalFormat = null)
  107.     {
  108.         if (null !== $format) {
  109.             $this->dateFormats[0] = $format;
  110.         }
  112.         if (null !== $dateIntervalFormat) {
  113.             $this->dateFormats[1] = $dateIntervalFormat;
  114.         }
  115.     }
  117.     /**
  118.      * Gets the default format to be used by the date filter.
  119.      *
  120.      * @return array The default date format string and the default date interval format string
  121.      */
  122.     public function getDateFormat()
  123.     {
  124.         return $this->dateFormats;
  125.     }
  127.     /**
  128.      * Sets the default timezone to be used by the date filter.
  129.      *
  130.      * @param \DateTimeZone|string $timezone The default timezone string or a \DateTimeZone object
  131.      */
  132.     public function setTimezone($timezone)
  133.     {
  134.         $this->timezone = $timezone instanceof \DateTimeZone ? $timezone : new \DateTimeZone($timezone);
  135.     }
  137.     /**
  138.      * Gets the default timezone to be used by the date filter.
  139.      *
  140.      * @return \DateTimeZone The default timezone currently in use
  141.      */
  142.     public function getTimezone()
  143.     {
  144.         if (null === $this->timezone) {
  145.             $this->timezone = new \DateTimeZone(date_default_timezone_get());
  146.         }
  148.         return $this->timezone;
  149.     }
  151.     /**
  152.      * Sets the default format to be used by the number_format filter.
  153.      *
  154.      * @param int    $decimal      the number of decimal places to use
  155.      * @param string $decimalPoint the character(s) to use for the decimal point
  156.      * @param string $thousandSep  the character(s) to use for the thousands separator
  157.      */
  158.     public function setNumberFormat($decimal, $decimalPoint, $thousandSep)
  159.     {
  160.         $this->numberFormat = [$decimal, $decimalPoint, $thousandSep];
  161.     }
  163.     /**
  164.      * Get the default format used by the number_format filter.
  165.      *
  166.      * @return array The arguments for number_format()
  167.      */
  168.     public function getNumberFormat()
  169.     {
  170.         return $this->numberFormat;
  171.     }
  173.     public function getTokenParsers()
  174.     {
  175.         return [
  176.             new ForTokenParser(),
  177.             new IfTokenParser(),
  178.             new ExtendsTokenParser(),
  179.             new IncludeTokenParser(),
  180.             new BlockTokenParser(),
  181.             new UseTokenParser(),
  182.             new FilterTokenParser(),
  183.             new MacroTokenParser(),
  184.             new ImportTokenParser(),
  185.             new FromTokenParser(),
  186.             new SetTokenParser(),
  187.             new SpacelessTokenParser(),
  188.             new FlushTokenParser(),
  189.             new DoTokenParser(),
  190.             new EmbedTokenParser(),
  191.             new WithTokenParser(),
  192.             new DeprecatedTokenParser(),
  193.         ];
  194.     }
  196.     public function getFilters()
  197.     {
  198.         return [
  199.             // formatting filters
  200.             new TwigFilter('date', 'twig_date_format_filter', ['needs_environment' => true]),
  201.             new TwigFilter('date_modify', 'twig_date_modify_filter', ['needs_environment' => true]),
  202.             new TwigFilter('format', 'sprintf'),
  203.             new TwigFilter('replace', 'twig_replace_filter'),
  204.             new TwigFilter('number_format', 'twig_number_format_filter', ['needs_environment' => true]),
  205.             new TwigFilter('abs', 'abs'),
  206.             new TwigFilter('round', 'twig_round'),
  208.             // encoding
  209.             new TwigFilter('url_encode', 'twig_urlencode_filter'),
  210.             new TwigFilter('json_encode', 'json_encode'),
  211.             new TwigFilter('convert_encoding', 'twig_convert_encoding'),
  213.             // string filters
  214.             new TwigFilter('title', 'twig_title_string_filter', ['needs_environment' => true]),
  215.             new TwigFilter('capitalize', 'twig_capitalize_string_filter', ['needs_environment' => true]),
  216.             new TwigFilter('upper', 'twig_upper_filter', ['needs_environment' => true]),
  217.             new TwigFilter('lower', 'twig_lower_filter', ['needs_environment' => true]),
  218.             new TwigFilter('striptags', 'strip_tags'),
  219.             new TwigFilter('trim', 'twig_trim_filter'),
  220.             new TwigFilter('nl2br', 'nl2br', ['pre_escape' => 'html', 'is_safe' => ['html']]),
  221.             new TwigFilter('spaceless', 'twig_spaceless', ['is_safe' => ['html']]),
  223.             // array helpers
  224.             new TwigFilter('join', 'twig_join_filter'),
  225.             new TwigFilter('split', 'twig_split_filter', ['needs_environment' => true]),
  226.             new TwigFilter('sort', 'twig_sort_filter'),
  227.             new TwigFilter('merge', 'twig_array_merge'),
  228.             new TwigFilter('batch', 'twig_array_batch'),
  229.             new TwigFilter('column', 'twig_array_column'),
  231.             // string/array filters
  232.             new TwigFilter('reverse', 'twig_reverse_filter', ['needs_environment' => true]),
  233.             new TwigFilter('length', 'twig_length_filter', ['needs_environment' => true]),
  234.             new TwigFilter('slice', 'twig_slice', ['needs_environment' => true]),
  235.             new TwigFilter('first', 'twig_first', ['needs_environment' => true]),
  236.             new TwigFilter('last', 'twig_last', ['needs_environment' => true]),
  238.             // iteration and runtime
  239.             new TwigFilter('default', '_twig_default_filter', ['node_class' => DefaultFilter::class]),
  240.             new TwigFilter('keys', 'twig_get_array_keys_filter'),
  242.             // escaping
  243.             new TwigFilter('escape', 'twig_escape_filter', ['needs_environment' => true, 'is_safe_callback' => 'twig_escape_filter_is_safe']),
  244.             new TwigFilter('e', 'twig_escape_filter', ['needs_environment' => true, 'is_safe_callback' => 'twig_escape_filter_is_safe']),
  245.         ];
  246.     }
  248.     public function getFunctions()
  249.     {
  250.         return [
  251.             new TwigFunction('max', 'max'),
  252.             new TwigFunction('min', 'min'),
  253.             new TwigFunction('range', 'range'),
  254.             new TwigFunction('constant', 'twig_constant'),
  255.             new TwigFunction('cycle', 'twig_cycle'),
  256.             new TwigFunction('random', 'twig_random', ['needs_environment' => true]),
  257.             new TwigFunction('date', 'twig_date_converter', ['needs_environment' => true]),
  258.             new TwigFunction('include', 'twig_include', ['needs_environment' => true, 'needs_context' => true, 'is_safe' => ['all']]),
  259.             new TwigFunction('source', 'twig_source', ['needs_environment' => true, 'is_safe' => ['all']]),
  260.         ];
  261.     }
  263.     public function getTests()
  264.     {
  265.         return [
  266.             new TwigTest('even', null, ['node_class' => EvenTest::class]),
  267.             new TwigTest('odd', null, ['node_class' => OddTest::class]),
  268.             new TwigTest('defined', null, ['node_class' => DefinedTest::class]),
  269.             new TwigTest('same as', null, ['node_class' => SameasTest::class]),
  270.             new TwigTest('none', null, ['node_class' => NullTest::class]),
  271.             new TwigTest('null', null, ['node_class' => NullTest::class]),
  272.             new TwigTest('divisible by', null, ['node_class' => DivisiblebyTest::class]),
  273.             new TwigTest('constant', null, ['node_class' => ConstantTest::class]),
  274.             new TwigTest('empty', 'twig_test_empty'),
  275.             new TwigTest('iterable', 'twig_test_iterable'),
  276.         ];
  277.     }
  279.     public function getOperators()
  280.     {
  281.         return [
  282.             [
  283.                 'not' => ['precedence' => 50, 'class' => NotUnary::class],
  284.                 '-' => ['precedence' => 500, 'class' => NegUnary::class],
  285.                 '+' => ['precedence' => 500, 'class' => PosUnary::class],
  286.             ],
  287.             [
  288.                 'or' => ['precedence' => 10, 'class' => OrBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  289.                 'and' => ['precedence' => 15, 'class' => AndBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  290.                 'b-or' => ['precedence' => 16, 'class' => BitwiseOrBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  291.                 'b-xor' => ['precedence' => 17, 'class' => BitwiseXorBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  292.                 'b-and' => ['precedence' => 18, 'class' => BitwiseAndBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  293.                 '==' => ['precedence' => 20, 'class' => EqualBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  294.                 '!=' => ['precedence' => 20, 'class' => NotEqualBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  295.                 '<' => ['precedence' => 20, 'class' => LessBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  296.                 '>' => ['precedence' => 20, 'class' => GreaterBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  297.                 '>=' => ['precedence' => 20, 'class' => GreaterEqualBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  298.                 '<=' => ['precedence' => 20, 'class' => LessEqualBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  299.                 'not in' => ['precedence' => 20, 'class' => NotInBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  300.                 'in' => ['precedence' => 20, 'class' => InBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  301.                 'matches' => ['precedence' => 20, 'class' => MatchesBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  302.                 'starts with' => ['precedence' => 20, 'class' => StartsWithBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  303.                 'ends with' => ['precedence' => 20, 'class' => EndsWithBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  304.                 '..' => ['precedence' => 25, 'class' => RangeBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  305.                 '+' => ['precedence' => 30, 'class' => AddBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  306.                 '-' => ['precedence' => 30, 'class' => SubBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  307.                 '~' => ['precedence' => 40, 'class' => ConcatBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  308.                 '*' => ['precedence' => 60, 'class' => MulBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  309.                 '/' => ['precedence' => 60, 'class' => DivBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  310.                 '//' => ['precedence' => 60, 'class' => FloorDivBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  311.                 '%' => ['precedence' => 60, 'class' => ModBinary::class, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  312.                 'is' => ['precedence' => 100, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  313.                 'is not' => ['precedence' => 100, 'associativity' => ExpressionParser::OPERATOR_LEFT],
  314.                 '**' => ['precedence' => 200, 'class' => PowerBinary::class, 'associativity' => ExpressionParser::OPERATOR_RIGHT],
  315.                 '??' => ['precedence' => 300, 'class' => NullCoalesceExpression::class, 'associativity' => ExpressionParser::OPERATOR_RIGHT],
  316.             ],
  317.         ];
  318.     }
  319. }
  321. class_alias('Twig\Extension\CoreExtension', 'Twig_Extension_Core');
  322. }
  324. namespace {
  325.     use Twig\Environment;
  326.     use Twig\Error\LoaderError;
  327.     use Twig\Error\RuntimeError;
  328.     use Twig\Extension\CoreExtension;
  329.     use Twig\Extension\SandboxExtension;
  330.     use Twig\Markup;
  331.     use Twig\Node\Expression\ConstantExpression;
  332.     use Twig\Node\Node;
  333.     use Twig\Source;
  334.     use Twig\Template;
  336.     /**
  337.  * Cycles over a value.
  338.  *
  339.  * @param \ArrayAccess|array $values
  340.  * @param int                $position The cycle position
  341.  *
  342.  * @return string The next value in the cycle
  343.  */
  344. function twig_cycle($values, $position)
  345. {
  346.     if (!\is_array($values) && !$values instanceof \ArrayAccess) {
  347.         return $values;
  348.     }
  350.     return $values[$position % \count($values)];
  351. }
  353. /**
  354.  * Returns a random value depending on the supplied parameter type:
  355.  * - a random item from a \Traversable or array
  356.  * - a random character from a string
  357.  * - a random integer between 0 and the integer parameter.
  358.  *
  359.  * @param \Traversable|array|int|float|string $values The values to pick a random item from
  360.  * @param int|null                            $max    Maximum value used when $values is an int
  361.  *
  362.  * @throws RuntimeError when $values is an empty array (does not apply to an empty string which is returned as is)
  363.  *
  364.  * @return mixed A random value from the given sequence
  365.  */
  366. function twig_random(Environment $env, $values = null, $max = null)
  367. {
  368.     if (null === $values) {
  369.         return null === $max ? mt_rand() : mt_rand(0, $max);
  370.     }
  372.     if (\is_int($values) || \is_float($values)) {
  373.         if (null === $max) {
  374.             if ($values < 0) {
  375.                 $max = 0;
  376.                 $min = $values;
  377.             } else {
  378.                 $max = $values;
  379.                 $min = 0;
  380.             }
  381.         } else {
  382.             $min = $values;
  383.             $max = $max;
  384.         }
  386.         return mt_rand($min, $max);
  387.     }
  389.     if (\is_string($values)) {
  390.         if ('' === $values) {
  391.             return '';
  392.         }
  394.         $charset = $env->getCharset();
  396.         if ('UTF-8' !== $charset) {
  397.             $values = iconv($charset, 'UTF-8', $values);
  398.         }
  400.         // unicode version of str_split()
  401.         // split at all positions, but not after the start and not before the end
  402.         $values = preg_split('/(?<!^)(?!$)/u', $values);
  404.         if ('UTF-8' !== $charset) {
  405.             foreach ($values as $i => $value) {
  406.                 $values[$i] = iconv('UTF-8', $charset, $value);
  407.             }
  408.         }
  409.     }
  411.     if (!twig_test_iterable($values)) {
  412.         return $values;
  413.     }
  415.     $values = twig_to_array($values);
  417.     if (0 === \count($values)) {
  418.         throw new RuntimeError('The random function cannot pick from an empty array.');
  419.     }
  421.     return $values[array_rand($values, 1)];
  422. }
  424. /**
  425.  * Converts a date to the given format.
  426.  *
  427.  *   {{ post.published_at|date("m/d/Y") }}
  428.  *
  429.  * @param \DateTimeInterface|\DateInterval|string $date     A date
  430.  * @param string|null                             $format   The target format, null to use the default
  431.  * @param \DateTimeZone|string|false|null         $timezone The target timezone, null to use the default, false to leave unchanged
  432.  *
  433.  * @return string The formatted date
  434.  */
  435. function twig_date_format_filter(Environment $env, $date, $format = null, $timezone = null)
  436. {
  437.     if (null === $format) {
  438.         $formats = $env->getExtension(CoreExtension::class)->getDateFormat();
  439.         $format = $date instanceof \DateInterval ? $formats[1] : $formats[0];
  440.     }
  442.     if ($date instanceof \DateInterval) {
  443.         return $date->format($format);
  444.     }
  446.     return twig_date_converter($env, $date, $timezone)->format($format);
  447. }
  449. /**
  450.  * Returns a new date object modified.
  451.  *
  452.  *   {{ post.published_at|date_modify("-1day")|date("m/d/Y") }}
  453.  *
  454.  * @param \DateTimeInterface|string $date     A date
  455.  * @param string                    $modifier A modifier string
  456.  *
  457.  * @return \DateTimeInterface
  458.  */
  459. function twig_date_modify_filter(Environment $env, $date, $modifier)
  460. {
  461.     $date = twig_date_converter($env, $date, false);
  463.     return $date->modify($modifier);
  464. }
  466. /**
  467.  * Converts an input to a \DateTime instance.
  468.  *
  469.  *    {% if date(user.created_at) < date('+2days') %}
  470.  *      {# do something #}
  471.  *    {% endif %}
  472.  *
  473.  * @param \DateTimeInterface|string|null  $date     A date or null to use the current time
  474.  * @param \DateTimeZone|string|false|null $timezone The target timezone, null to use the default, false to leave unchanged
  475.  *
  476.  * @return \DateTime
  477.  */
  478. function twig_date_converter(Environment $env, $date = null, $timezone = null)
  479. {
  480.     // determine the timezone
  481.     if (false !== $timezone) {
  482.         if (null === $timezone) {
  483.             $timezone = $env->getExtension(CoreExtension::class)->getTimezone();
  484.         } elseif (!$timezone instanceof \DateTimeZone) {
  485.             $timezone = new \DateTimeZone($timezone);
  486.         }
  487.     }
  489.     // immutable dates
  490.     if ($date instanceof \DateTimeImmutable) {
  491.         return false !== $timezone ? $date->setTimezone($timezone) : $date;
  492.     }
  494.     if ($date instanceof \DateTimeInterface) {
  495.         $date = clone $date;
  496.         if (false !== $timezone) {
  497.             $date->setTimezone($timezone);
  498.         }
  500.         return $date;
  501.     }
  503.     if (null === $date || 'now' === $date) {
  504.         return new \DateTime($date, false !== $timezone ? $timezone : $env->getExtension(CoreExtension::class)->getTimezone());
  505.     }
  507.     $asString = (string) $date;
  508.     if (ctype_digit($asString) || (!empty($asString) && '-' === $asString[0] && ctype_digit(substr($asString, 1)))) {
  509.         $date = new \DateTime('@'.$date);
  510.     } else {
  511.         $date = new \DateTime($date, $env->getExtension(CoreExtension::class)->getTimezone());
  512.     }
  514.     if (false !== $timezone) {
  515.         $date->setTimezone($timezone);
  516.     }
  518.     return $date;
  519. }
  521. /**
  522.  * Replaces strings within a string.
  523.  *
  524.  * @param string             $str  String to replace in
  525.  * @param array|\Traversable $from Replace values
  526.  *
  527.  * @return string
  528.  */
  529. function twig_replace_filter($str, $from)
  530. {
  531.     if (!twig_test_iterable($from)) {
  532.         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)));
  533.     }
  535.     return strtr($str, twig_to_array($from));
  536. }
  538. /**
  539.  * Rounds a number.
  540.  *
  541.  * @param int|float $value     The value to round
  542.  * @param int|float $precision The rounding precision
  543.  * @param string    $method    The method to use for rounding
  544.  *
  545.  * @return int|float The rounded number
  546.  */
  547. function twig_round($value, $precision = 0, $method = 'common')
  548. {
  549.     if ('common' == $method) {
  550.         return round($value, $precision);
  551.     }
  553.     if ('ceil' != $method && 'floor' != $method) {
  554.         throw new RuntimeError('The round filter only supports the "common", "ceil", and "floor" methods.');
  555.     }
  557.     return $method($value * pow(10, $precision)) / pow(10, $precision);
  558. }
  560. /**
  561.  * Number format filter.
  562.  *
  563.  * All of the formatting options can be left null, in that case the defaults will
  564.  * be used.  Supplying any of the parameters will override the defaults set in the
  565.  * environment object.
  566.  *
  567.  * @param mixed  $number       A float/int/string of the number to format
  568.  * @param int    $decimal      the number of decimal points to display
  569.  * @param string $decimalPoint the character(s) to use for the decimal point
  570.  * @param string $thousandSep  the character(s) to use for the thousands separator
  571.  *
  572.  * @return string The formatted number
  573.  */
  574. function twig_number_format_filter(Environment $env, $number, $decimal = null, $decimalPoint = null, $thousandSep = null)
  575. {
  576.     $defaults = $env->getExtension(CoreExtension::class)->getNumberFormat();
  577.     if (null === $decimal) {
  578.         $decimal = $defaults[0];
  579.     }
  581.     if (null === $decimalPoint) {
  582.         $decimalPoint = $defaults[1];
  583.     }
  585.     if (null === $thousandSep) {
  586.         $thousandSep = $defaults[2];
  587.     }
  589.     return number_format((float) $number, $decimal, $decimalPoint, $thousandSep);
  590. }
  592. /**
  593.  * URL encodes (RFC 3986) a string as a path segment or an array as a query string.
  594.  *
  595.  * @param string|array $url A URL or an array of query parameters
  596.  *
  597.  * @return string The URL encoded value
  598.  */
  599. function twig_urlencode_filter($url)
  600. {
  601.     if (\is_array($url)) {
  602.         return http_build_query($url, '', '&', PHP_QUERY_RFC3986);
  603.     }
  605.     return rawurlencode($url);
  606. }
  608. /**
  609.  * Merges an array with another one.
  610.  *
  611.  *  {% set items = { 'apple': 'fruit', 'orange': 'fruit' } %}
  612.  *
  613.  *  {% set items = items|merge({ 'peugeot': 'car' }) %}
  614.  *
  615.  *  {# items now contains { 'apple': 'fruit', 'orange': 'fruit', 'peugeot': 'car' } #}
  616.  *
  617.  * @param array|\Traversable $arr1 An array
  618.  * @param array|\Traversable $arr2 An array
  619.  *
  620.  * @return array The merged array
  621.  */
  622. function twig_array_merge($arr1, $arr2)
  623. {
  624.     if (!twig_test_iterable($arr1)) {
  625.         throw new RuntimeError(sprintf('The merge filter only works with arrays or "Traversable", got "%s" as first argument.', \gettype($arr1)));
  626.     }
  628.     if (!twig_test_iterable($arr2)) {
  629.         throw new RuntimeError(sprintf('The merge filter only works with arrays or "Traversable", got "%s" as second argument.', \gettype($arr2)));
  630.     }
  632.     return array_merge(twig_to_array($arr1), twig_to_array($arr2));
  633. }
  635. /**
  636.  * Slices a variable.
  637.  *
  638.  * @param mixed $item         A variable
  639.  * @param int   $start        Start of the slice
  640.  * @param int   $length       Size of the slice
  641.  * @param bool  $preserveKeys Whether to preserve key or not (when the input is an array)
  642.  *
  643.  * @return mixed The sliced variable
  644.  */
  645. function twig_slice(Environment $env, $item, $start, $length = null, $preserveKeys = false)
  646. {
  647.     if ($item instanceof \Traversable) {
  648.         while ($item instanceof \IteratorAggregate) {
  649.             $item = $item->getIterator();
  650.         }
  652.         if ($start >= 0 && $length >= 0 && $item instanceof \Iterator) {
  653.             try {
  654.                 return iterator_to_array(new \LimitIterator($item, $start, null === $length ? -1 : $length), $preserveKeys);
  655.             } catch (\OutOfBoundsException $e) {
  656.                 return [];
  657.             }
  658.         }
  660.         $item = iterator_to_array($item, $preserveKeys);
  661.     }
  663.     if (\is_array($item)) {
  664.         return \array_slice($item, $start, $length, $preserveKeys);
  665.     }
  667.     $item = (string) $item;
  669.     return (string) mb_substr($item, $start, $length, $env->getCharset());
  670. }
  672. /**
  673.  * Returns the first element of the item.
  674.  *
  675.  * @param mixed $item A variable
  676.  *
  677.  * @return mixed The first element of the item
  678.  */
  679. function twig_first(Environment $env, $item)
  680. {
  681.     $elements = twig_slice($env, $item, 0, 1, false);
  683.     return \is_string($elements) ? $elements : current($elements);
  684. }
  686. /**
  687.  * Returns the last element of the item.
  688.  *
  689.  * @param mixed $item A variable
  690.  *
  691.  * @return mixed The last element of the item
  692.  */
  693. function twig_last(Environment $env, $item)
  694. {
  695.     $elements = twig_slice($env, $item, -1, 1, false);
  697.     return \is_string($elements) ? $elements : current($elements);
  698. }
  700. /**
  701.  * Joins the values to a string.
  702.  *
  703.  * The separators between elements are empty strings per default, you can define them with the optional parameters.
  704.  *
  705.  *  {{ [1, 2, 3]|join(', ', ' and ') }}
  706.  *  {# returns 1, 2 and 3 #}
  707.  *
  708.  *  {{ [1, 2, 3]|join('|') }}
  709.  *  {# returns 1|2|3 #}
  710.  *
  711.  *  {{ [1, 2, 3]|join }}
  712.  *  {# returns 123 #}
  713.  *
  714.  * @param array       $value An array
  715.  * @param string      $glue  The separator
  716.  * @param string|null $and   The separator for the last pair
  717.  *
  718.  * @return string The concatenated string
  719.  */
  720. function twig_join_filter($value, $glue = '', $and = null)
  721. {
  722.     if (!twig_test_iterable($value)) {
  723.         $value = (array) $value;
  724.     }
  726.     $value = twig_to_array($value, false);
  728.     if (0 === \count($value)) {
  729.         return '';
  730.     }
  732.     if (null === $and || $and === $glue) {
  733.         return implode($glue, $value);
  734.     }
  736.     if (1 === \count($value)) {
  737.         return $value[0];
  738.     }
  740.     return implode($glue, \array_slice($value, 0, -1)).$and.$value[\count($value) - 1];
  741. }
  743. /**
  744.  * Splits the string into an array.
  745.  *
  746.  *  {{ "one,two,three"|split(',') }}
  747.  *  {# returns [one, two, three] #}
  748.  *
  749.  *  {{ "one,two,three,four,five"|split(',', 3) }}
  750.  *  {# returns [one, two, "three,four,five"] #}
  751.  *
  752.  *  {{ "123"|split('') }}
  753.  *  {# returns [1, 2, 3] #}
  754.  *
  755.  *  {{ "aabbcc"|split('', 2) }}
  756.  *  {# returns [aa, bb, cc] #}
  757.  *
  758.  * @param string $value     A string
  759.  * @param string $delimiter The delimiter
  760.  * @param int    $limit     The limit
  761.  *
  762.  * @return array The split string as an array
  763.  */
  764. function twig_split_filter(Environment $env, $value, $delimiter, $limit = null)
  765. {
  766.     if (!empty($delimiter)) {
  767.         return null === $limit ? explode($delimiter, $value) : explode($delimiter, $value, $limit);
  768.     }
  770.     if ($limit <= 1) {
  771.         return preg_split('/(?<!^)(?!$)/u', $value);
  772.     }
  774.     $length = mb_strlen($value, $env->getCharset());
  775.     if ($length < $limit) {
  776.         return [$value];
  777.     }
  779.     $r = [];
  780.     for ($i = 0; $i < $length; $i += $limit) {
  781.         $r[] = mb_substr($value, $i, $limit, $env->getCharset());
  782.     }
  784.     return $r;
  785. }
  787. // The '_default' filter is used internally to avoid using the ternary operator
  788. // which costs a lot for big contexts (before PHP 5.4). So, on average,
  789. // a function call is cheaper.
  790. /**
  791.  * @internal
  792.  */
  793. function _twig_default_filter($value, $default = '')
  794. {
  795.     if (twig_test_empty($value)) {
  796.         return $default;
  797.     }
  799.     return $value;
  800. }
  802. /**
  803.  * Returns the keys for the given array.
  804.  *
  805.  * It is useful when you want to iterate over the keys of an array:
  806.  *
  807.  *  {% for key in array|keys %}
  808.  *      {# ... #}
  809.  *  {% endfor %}
  810.  *
  811.  * @param array $array An array
  812.  *
  813.  * @return array The keys
  814.  */
  815. function twig_get_array_keys_filter($array)
  816. {
  817.     if ($array instanceof \Traversable) {
  818.         while ($array instanceof \IteratorAggregate) {
  819.             $array = $array->getIterator();
  820.         }
  822.         if ($array instanceof \Iterator) {
  823.             $keys = [];
  824.             $array->rewind();
  825.             while ($array->valid()) {
  826.                 $keys[] = $array->key();
  827.                 $array->next();
  828.             }
  830.             return $keys;
  831.         }
  833.         $keys = [];
  834.         foreach ($array as $key => $item) {
  835.             $keys[] = $key;
  836.         }
  838.         return $keys;
  839.     }
  841.     if (!\is_array($array)) {
  842.         return [];
  843.     }
  845.     return array_keys($array);
  846. }
  848. /**
  849.  * Reverses a variable.
  850.  *
  851.  * @param array|\Traversable|string $item         An array, a \Traversable instance, or a string
  852.  * @param bool                      $preserveKeys Whether to preserve key or not
  853.  *
  854.  * @return mixed The reversed input
  855.  */
  856. function twig_reverse_filter(Environment $env, $item, $preserveKeys = false)
  857. {
  858.     if ($item instanceof \Traversable) {
  859.         return array_reverse(iterator_to_array($item), $preserveKeys);
  860.     }
  862.     if (\is_array($item)) {
  863.         return array_reverse($item, $preserveKeys);
  864.     }
  866.     $string = (string) $item;
  868.     $charset = $env->getCharset();
  870.     if ('UTF-8' !== $charset) {
  871.         $item = iconv($charset, 'UTF-8', $string);
  872.     }
  874.     preg_match_all('/./us', $item, $matches);
  876.     $string = implode('', array_reverse($matches[0]));
  878.     if ('UTF-8' !== $charset) {
  879.         $string = iconv('UTF-8', $charset, $string);
  880.     }
  882.     return $string;
  883. }
  885. /**
  886.  * Sorts an array.
  887.  *
  888.  * @param array|\Traversable $array
  889.  *
  890.  * @return array
  891.  */
  892. function twig_sort_filter($array)
  893. {
  894.     if ($array instanceof \Traversable) {
  895.         $array = iterator_to_array($array);
  896.     } elseif (!\is_array($array)) {
  897.         throw new RuntimeError(sprintf('The sort filter only works with arrays or "Traversable", got "%s".', \gettype($array)));
  898.     }
  900.     asort($array);
  902.     return $array;
  903. }
  905. /**
  906.  * @internal
  907.  */
  908. function twig_in_filter($value, $compare)
  909. {
  910.     if (\is_array($compare)) {
  911.         return \in_array($value, $compare, \is_object($value) || \is_resource($value));
  912.     } elseif (\is_string($compare) && (\is_string($value) || \is_int($value) || \is_float($value))) {
  913.         return '' === $value || false !== strpos($compare, (string) $value);
  914.     } elseif ($compare instanceof \Traversable) {
  915.         if (\is_object($value) || \is_resource($value)) {
  916.             foreach ($compare as $item) {
  917.                 if ($item === $value) {
  918.                     return true;
  919.                 }
  920.             }
  921.         } else {
  922.             foreach ($compare as $item) {
  923.                 if ($item == $value) {
  924.                     return true;
  925.                 }
  926.             }
  927.         }
  929.         return false;
  930.     }
  932.     return false;
  933. }
  935. /**
  936.  * Returns a trimmed string.
  937.  *
  938.  * @return string
  939.  *
  940.  * @throws RuntimeError When an invalid trimming side is used (not a string or not 'left', 'right', or 'both')
  941.  */
  942. function twig_trim_filter($string, $characterMask = null, $side = 'both')
  943. {
  944.     if (null === $characterMask) {
  945.         $characterMask = " \t\n\r\0\x0B";
  946.     }
  948.     switch ($side) {
  949.         case 'both':
  950.             return trim($string, $characterMask);
  951.         case 'left':
  952.             return ltrim($string, $characterMask);
  953.         case 'right':
  954.             return rtrim($string, $characterMask);
  955.         default:
  956.             throw new RuntimeError('Trimming side must be "left", "right" or "both".');
  957.     }
  958. }
  960. /**
  961.  * Removes whitespaces between HTML tags.
  962.  *
  963.  * @return string
  964.  */
  965. function twig_spaceless($content)
  966. {
  967.     return trim(preg_replace('/>\s+</', '><', $content));
  968. }
  970. /**
  971.  * Escapes a string.
  972.  *
  973.  * @param mixed  $string     The value to be escaped
  974.  * @param string $strategy   The escaping strategy
  975.  * @param string $charset    The charset
  976.  * @param bool   $autoescape Whether the function is called by the auto-escaping feature (true) or by the developer (false)
  977.  *
  978.  * @return string
  979.  */
  980. function twig_escape_filter(Environment $env, $string, $strategy = 'html', $charset = null, $autoescape = false)
  981. {
  982.     if ($autoescape && $string instanceof Markup) {
  983.         return $string;
  984.     }
  986.     if (!\is_string($string)) {
  987.         if (\is_object($string) && method_exists($string, '__toString')) {
  988.             $string = (string) $string;
  989.         } elseif (\in_array($strategy, ['html', 'js', 'css', 'html_attr', 'url'])) {
  990.             return $string;
  991.         }
  992.     }
  994.     if ('' === $string) {
  995.         return '';
  996.     }
  998.     if (null === $charset) {
  999.         $charset = $env->getCharset();
  1000.     }
  1002.     switch ($strategy) {
  1003.         case 'html':
  1004.             // see https://secure.php.net/htmlspecialchars
  1006.             // Using a static variable to avoid initializing the array
  1007.             // each time the function is called. Moving the declaration on the
  1008.             // top of the function slow downs other escaping strategies.
  1009.             static $htmlspecialcharsCharsets = [
  1010.                 'ISO-8859-1' => true, 'ISO8859-1' => true,
  1011.                 'ISO-8859-15' => true, 'ISO8859-15' => true,
  1012.                 'utf-8' => true, 'UTF-8' => true,
  1013.                 'CP866' => true, 'IBM866' => true, '866' => true,
  1014.                 'CP1251' => true, 'WINDOWS-1251' => true, 'WIN-1251' => true,
  1015.                 '1251' => true,
  1016.                 'CP1252' => true, 'WINDOWS-1252' => true, '1252' => true,
  1017.                 'KOI8-R' => true, 'KOI8-RU' => true, 'KOI8R' => true,
  1018.                 'BIG5' => true, '950' => true,
  1019.                 'GB2312' => true, '936' => true,
  1020.                 'BIG5-HKSCS' => true,
  1021.                 'SHIFT_JIS' => true, 'SJIS' => true, '932' => true,
  1022.                 'EUC-JP' => true, 'EUCJP' => true,
  1023.                 'ISO8859-5' => true, 'ISO-8859-5' => true, 'MACROMAN' => true,
  1024.             ];
  1026.             if (isset($htmlspecialcharsCharsets[$charset])) {
  1027.                 return htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE, $charset);
  1028.             }
  1030.             if (isset($htmlspecialcharsCharsets[strtoupper($charset)])) {
  1031.                 // cache the lowercase variant for future iterations
  1032.                 $htmlspecialcharsCharsets[$charset] = true;
  1034.                 return htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE, $charset);
  1035.             }
  1037.             $string = iconv($charset, 'UTF-8', $string);
  1038.             $string = htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');
  1040.             return iconv('UTF-8', $charset, $string);
  1042.         case 'js':
  1043.             // escape all non-alphanumeric characters
  1044.             // into their \x or \uHHHH representations
  1045.             if ('UTF-8' !== $charset) {
  1046.                 $string = iconv($charset, 'UTF-8', $string);
  1047.             }
  1049.             if (!preg_match('//u', $string)) {
  1050.                 throw new RuntimeError('The string to escape is not a valid UTF-8 string.');
  1051.             }
  1053.             $string = preg_replace_callback('#[^a-zA-Z0-9,\._]#Su', function ($matches) {
  1054.                 $char = $matches[0];
  1056.                 /*
  1057.                  * A few characters have short escape sequences in JSON and JavaScript.
  1058.                  * Escape sequences supported only by JavaScript, not JSON, are ommitted.
  1059.                  * \" is also supported but omitted, because the resulting string is not HTML safe.
  1060.                  */
  1061.                 static $shortMap = [
  1062.                     '\\' => '\\\\',
  1063.                     '/' => '\\/',
  1064.                     "\x08" => '\b',
  1065.                     "\x0C" => '\f',
  1066.                     "\x0A" => '\n',
  1067.                     "\x0D" => '\r',
  1068.                     "\x09" => '\t',
  1069.                 ];
  1071.                 if (isset($shortMap[$char])) {
  1072.                     return $shortMap[$char];
  1073.                 }
  1075.                 // \uHHHH
  1076.                 $char = twig_convert_encoding($char, 'UTF-16BE', 'UTF-8');
  1077.                 $char = strtoupper(bin2hex($char));
  1079.                 if (4 >= \strlen($char)) {
  1080.                     return sprintf('\u%04s', $char);
  1081.                 }
  1083.                 return sprintf('\u%04s\u%04s', substr($char, 0, -4), substr($char, -4));
  1084.             }, $string);
  1086.             if ('UTF-8' !== $charset) {
  1087.                 $string = iconv('UTF-8', $charset, $string);
  1088.             }
  1090.             return $string;
  1092.         case 'css':
  1093.             if ('UTF-8' !== $charset) {
  1094.                 $string = iconv($charset, 'UTF-8', $string);
  1095.             }
  1097.             if (!preg_match('//u', $string)) {
  1098.                 throw new RuntimeError('The string to escape is not a valid UTF-8 string.');
  1099.             }
  1101.             $string = preg_replace_callback('#[^a-zA-Z0-9]#Su', function ($matches) {
  1102.                 $char = $matches[0];
  1104.                 return sprintf('\\%X ', 1 === \strlen($char) ? \ord($char) : mb_ord($char, 'UTF-8'));
  1105.             }, $string);
  1107.             if ('UTF-8' !== $charset) {
  1108.                 $string = iconv('UTF-8', $charset, $string);
  1109.             }
  1111.             return $string;
  1113.         case 'html_attr':
  1114.             if ('UTF-8' !== $charset) {
  1115.                 $string = iconv($charset, 'UTF-8', $string);
  1116.             }
  1118.             if (!preg_match('//u', $string)) {
  1119.                 throw new RuntimeError('The string to escape is not a valid UTF-8 string.');
  1120.             }
  1122.             $string = preg_replace_callback('#[^a-zA-Z0-9,\.\-_]#Su', function ($matches) {
  1123.                 /**
  1124.                  * This function is adapted from code coming from Zend Framework.
  1125.                  *
  1126.                  * @copyright Copyright (c) 2005-2012 Zend Technologies USA Inc. (https://www.zend.com)
  1127.                  * @license   https://framework.zend.com/license/new-bsd New BSD License
  1128.                  */
  1129.                 $chr = $matches[0];
  1130.                 $ord = \ord($chr);
  1132.                 /*
  1133.                  * The following replaces characters undefined in HTML with the
  1134.                  * hex entity for the Unicode replacement character.
  1135.                  */
  1136.                 if (($ord <= 0x1f && "\t" != $chr && "\n" != $chr && "\r" != $chr) || ($ord >= 0x7f && $ord <= 0x9f)) {
  1137.                     return '&#xFFFD;';
  1138.                 }
  1140.                 /*
  1141.                  * Check if the current character to escape has a name entity we should
  1142.                  * replace it with while grabbing the hex value of the character.
  1143.                  */
  1144.                 if (1 === \strlen($chr)) {
  1145.                     /*
  1146.                      * While HTML supports far more named entities, the lowest common denominator
  1147.                      * has become HTML5's XML Serialisation which is restricted to the those named
  1148.                      * entities that XML supports. Using HTML entities would result in this error:
  1149.                      *     XML Parsing Error: undefined entity
  1150.                      */
  1151.                     static $entityMap = [
  1152.                         34 => '&quot;', /* quotation mark */
  1153.                         38 => '&amp;',  /* ampersand */
  1154.                         60 => '&lt;',   /* less-than sign */
  1155.                         62 => '&gt;',   /* greater-than sign */
  1156.                     ];
  1158.                     if (isset($entityMap[$ord])) {
  1159.                         return $entityMap[$ord];
  1160.                     }
  1162.                     return sprintf('&#x%02X;', $ord);
  1163.                 }
  1165.                 /*
  1166.                  * Per OWASP recommendations, we'll use hex entities for any other
  1167.                  * characters where a named entity does not exist.
  1168.                  */
  1169.                 return sprintf('&#x%04X;', mb_ord($chr, 'UTF-8'));
  1170.             }, $string);
  1172.             if ('UTF-8' !== $charset) {
  1173.                 $string = iconv('UTF-8', $charset, $string);
  1174.             }
  1176.             return $string;
  1178.         case 'url':
  1179.             return rawurlencode($string);
  1181.         default:
  1182.             static $escapers;
  1184.             if (null === $escapers) {
  1185.                 $escapers = $env->getExtension(CoreExtension::class)->getEscapers();
  1186.             }
  1188.             if (isset($escapers[$strategy])) {
  1189.                 return $escapers[$strategy]($env, $string, $charset);
  1190.             }
  1192.             $validStrategies = implode(', ', array_merge(['html', 'js', 'url', 'css', 'html_attr'], array_keys($escapers)));
  1194.             throw new RuntimeError(sprintf('Invalid escaping strategy "%s" (valid ones: %s).', $strategy, $validStrategies));
  1195.     }
  1196. }
  1198. /**
  1199.  * @internal
  1200.  */
  1201. function twig_escape_filter_is_safe(Node $filterArgs)
  1202. {
  1203.     foreach ($filterArgs as $arg) {
  1204.         if ($arg instanceof ConstantExpression) {
  1205.             return [$arg->getAttribute('value')];
  1206.         }
  1208.         return [];
  1209.     }
  1211.     return ['html'];
  1212. }
  1214. function twig_convert_encoding($string, $to, $from)
  1215. {
  1216.     return iconv($from, $to, $string);
  1217. }
  1219. /**
  1220.  * Returns the length of a variable.
  1221.  *
  1222.  * @param mixed $thing A variable
  1223.  *
  1224.  * @return int The length of the value
  1225.  */
  1226. function twig_length_filter(Environment $env, $thing)
  1227. {
  1228.     if (null === $thing) {
  1229.         return 0;
  1230.     }
  1232.     if (is_scalar($thing)) {
  1233.         return mb_strlen($thing, $env->getCharset());
  1234.     }
  1236.     if ($thing instanceof \Countable || \is_array($thing) || $thing instanceof \SimpleXMLElement) {
  1237.         return \count($thing);
  1238.     }
  1240.     if ($thing instanceof \Traversable) {
  1241.         return iterator_count($thing);
  1242.     }
  1244.     if (method_exists($thing, '__toString') && !$thing instanceof \Countable) {
  1245.         return mb_strlen((string) $thing, $env->getCharset());
  1246.     }
  1248.     return 1;
  1249. }
  1251. /**
  1252.  * Converts a string to uppercase.
  1253.  *
  1254.  * @param string $string A string
  1255.  *
  1256.  * @return string The uppercased string
  1257.  */
  1258. function twig_upper_filter(Environment $env, $string)
  1259. {
  1260.     return mb_strtoupper($string, $env->getCharset());
  1261. }
  1263. /**
  1264.  * Converts a string to lowercase.
  1265.  *
  1266.  * @param string $string A string
  1267.  *
  1268.  * @return string The lowercased string
  1269.  */
  1270. function twig_lower_filter(Environment $env, $string)
  1271. {
  1272.     return mb_strtolower($string, $env->getCharset());
  1273. }
  1275. /**
  1276.  * Returns a titlecased string.
  1277.  *
  1278.  * @param string $string A string
  1279.  *
  1280.  * @return string The titlecased string
  1281.  */
  1282. function twig_title_string_filter(Environment $env, $string)
  1283. {
  1284.     if (null !== $charset = $env->getCharset()) {
  1285.         return mb_convert_case($string, MB_CASE_TITLE, $charset);
  1286.     }
  1288.     return ucwords(strtolower($string));
  1289. }
  1291. /**
  1292.  * Returns a capitalized string.
  1293.  *
  1294.  * @param string $string A string
  1295.  *
  1296.  * @return string The capitalized string
  1297.  */
  1298. function twig_capitalize_string_filter(Environment $env, $string)
  1299. {
  1300.     $charset = $env->getCharset();
  1302.     return mb_strtoupper(mb_substr($string, 0, 1, $charset), $charset).mb_strtolower(mb_substr($string, 1, null, $charset), $charset);
  1303. }
  1305. /**
  1306.  * @internal
  1307.  */
  1308. function twig_ensure_traversable($seq)
  1309. {
  1310.     if ($seq instanceof \Traversable || \is_array($seq)) {
  1311.         return $seq;
  1312.     }
  1314.     return [];
  1315. }
  1317. /**
  1318.  * @internal
  1319.  */
  1320. function twig_to_array($seq, $preserveKeys = true)
  1321. {
  1322.     if ($seq instanceof \Traversable) {
  1323.         return iterator_to_array($seq, $preserveKeys);
  1324.     }
  1326.     if (!\is_array($seq)) {
  1327.         return $seq;
  1328.     }
  1330.     return $preserveKeys ? $seq : array_values($seq);
  1331. }
  1333. /**
  1334.  * Checks if a variable is empty.
  1335.  *
  1336.  *    {# evaluates to true if the foo variable is null, false, or the empty string #}
  1337.  *    {% if foo is empty %}
  1338.  *        {# ... #}
  1339.  *    {% endif %}
  1340.  *
  1341.  * @param mixed $value A variable
  1342.  *
  1343.  * @return bool true if the value is empty, false otherwise
  1344.  */
  1345. function twig_test_empty($value)
  1346. {
  1347.     if ($value instanceof \Countable) {
  1348.         return 0 == \count($value);
  1349.     }
  1351.     if (\is_object($value) && method_exists($value, '__toString')) {
  1352.         return '' === (string) $value;
  1353.     }
  1355.     return '' === $value || false === $value || null === $value || [] === $value;
  1356. }
  1358. /**
  1359.  * Checks if a variable is traversable.
  1360.  *
  1361.  *    {# evaluates to true if the foo variable is an array or a traversable object #}
  1362.  *    {% if foo is iterable %}
  1363.  *        {# ... #}
  1364.  *    {% endif %}
  1365.  *
  1366.  * @param mixed $value A variable
  1367.  *
  1368.  * @return bool true if the value is traversable
  1369.  */
  1370. function twig_test_iterable($value)
  1371. {
  1372.     return $value instanceof \Traversable || \is_array($value);
  1373. }
  1375. /**
  1376.  * Renders a template.
  1377.  *
  1378.  * @param array        $context
  1379.  * @param string|array $template      The template to render or an array of templates to try consecutively
  1380.  * @param array        $variables     The variables to pass to the template
  1381.  * @param bool         $withContext
  1382.  * @param bool         $ignoreMissing Whether to ignore missing templates or not
  1383.  * @param bool         $sandboxed     Whether to sandbox the template or not
  1384.  *
  1385.  * @return string The rendered template
  1386.  */
  1387. function twig_include(Environment $env, $context, $template, $variables = [], $withContext = true, $ignoreMissing = false, $sandboxed = false)
  1388. {
  1389.     $alreadySandboxed = false;
  1390.     $sandbox = null;
  1391.     if ($withContext) {
  1392.         $variables = array_merge($context, $variables);
  1393.     }
  1395.     if ($isSandboxed = $sandboxed && $env->hasExtension(SandboxExtension::class)) {
  1396.         $sandbox = $env->getExtension(SandboxExtension::class);
  1397.         if (!$alreadySandboxed = $sandbox->isSandboxed()) {
  1398.             $sandbox->enableSandbox();
  1399.         }
  1400.     }
  1402.     try {
  1403.         $loaded = null;
  1404.         try {
  1405.             $loaded = $env->resolveTemplate($template);
  1406.         } catch (LoaderError $e) {
  1407.             if (!$ignoreMissing) {
  1408.                 throw $e;
  1409.             }
  1410.         }
  1412.         return $loaded ? $loaded->render($variables) : '';
  1413.     } finally {
  1414.         if ($isSandboxed && !$alreadySandboxed) {
  1415.             $sandbox->disableSandbox();
  1416.         }
  1417.     }
  1418. }
  1420. /**
  1421.  * Returns a template content without rendering it.
  1422.  *
  1423.  * @param string $name          The template name
  1424.  * @param bool   $ignoreMissing Whether to ignore missing templates or not
  1425.  *
  1426.  * @return string The template source
  1427.  */
  1428. function twig_source(Environment $env, $name, $ignoreMissing = false)
  1429. {
  1430.     $loader = $env->getLoader();
  1431.     try {
  1432.         return $loader->getSourceContext($name)->getCode();
  1433.     } catch (LoaderError $e) {
  1434.         if (!$ignoreMissing) {
  1435.             throw $e;
  1436.         }
  1437.     }
  1438. }
  1440. /**
  1441.  * Provides the ability to get constants from instances as well as class/global constants.
  1442.  *
  1443.  * @param string      $constant The name of the constant
  1444.  * @param object|null $object   The object to get the constant from
  1445.  *
  1446.  * @return string
  1447.  */
  1448. function twig_constant($constant, $object = null)
  1449. {
  1450.     if (null !== $object) {
  1451.         $constant = \get_class($object).'::'.$constant;
  1452.     }
  1454.     return \constant($constant);
  1455. }
  1457. /**
  1458.  * Checks if a constant exists.
  1459.  *
  1460.  * @param string      $constant The name of the constant
  1461.  * @param object|null $object   The object to get the constant from
  1462.  *
  1463.  * @return bool
  1464.  */
  1465. function twig_constant_is_defined($constant, $object = null)
  1466. {
  1467.     if (null !== $object) {
  1468.         $constant = \get_class($object).'::'.$constant;
  1469.     }
  1471.     return \defined($constant);
  1472. }
  1474. /**
  1475.  * Batches item.
  1476.  *
  1477.  * @param array $items An array of items
  1478.  * @param int   $size  The size of the batch
  1479.  * @param mixed $fill  A value used to fill missing items
  1480.  *
  1481.  * @return array
  1482.  */
  1483. function twig_array_batch($items, $size, $fill = null, $preserveKeys = true)
  1484. {
  1485.     if (!twig_test_iterable($items)) {
  1486.         throw new RuntimeError(sprintf('The "batch" filter expects an array or "Traversable", got "%s".', \is_object($items) ? \get_class($items) : \gettype($items)));
  1487.     }
  1489.     $size = ceil($size);
  1491.     $result = array_chunk(twig_to_array($items, $preserveKeys), $size, $preserveKeys);
  1493.     if (null !== $fill && $result) {
  1494.         $last = \count($result) - 1;
  1495.         if ($fillCount = $size - \count($result[$last])) {
  1496.             for ($i = 0; $i < $fillCount; ++$i) {
  1497.                 $result[$last][] = $fill;
  1498.             }
  1499.         }
  1500.     }
  1502.     return $result;
  1503. }
  1505. /**
  1506.  * Returns the attribute value for a given array/object.
  1507.  *
  1508.  * @param mixed  $object            The object or array from where to get the item
  1509.  * @param mixed  $item              The item to get from the array or object
  1510.  * @param array  $arguments         An array of arguments to pass if the item is an object method
  1511.  * @param string $type              The type of attribute (@see \Twig\Template constants)
  1512.  * @param bool   $isDefinedTest     Whether this is only a defined check
  1513.  * @param bool   $ignoreStrictCheck Whether to ignore the strict attribute check or not
  1514.  *
  1515.  * @return mixed The attribute value, or a Boolean when $isDefinedTest is true, or null when the attribute is not set and $ignoreStrictCheck is true
  1516.  *
  1517.  * @throws RuntimeError if the attribute does not exist and Twig is running in strict mode and $isDefinedTest is false
  1518.  *
  1519.  * @internal
  1520.  */
  1521. function twig_get_attribute(Environment $env, Source $source, $object, $item, array $arguments = [], $type = /* Template::ANY_CALL */ 'any', $isDefinedTest = false, $ignoreStrictCheck = false, $sandboxed = false)
  1522. {
  1523.     // array
  1524.     if (/* Template::METHOD_CALL */ 'method' !== $type) {
  1525.         $arrayItem = \is_bool($item) || \is_float($item) ? (int) $item : $item;
  1527.         if (((\is_array($object) || $object instanceof \ArrayObject) && (isset($object[$arrayItem]) || \array_key_exists($arrayItem, $object)))
  1528.             || ($object instanceof ArrayAccess && isset($object[$arrayItem]))
  1529.         ) {
  1530.             if ($isDefinedTest) {
  1531.                 return true;
  1532.             }
  1534.             return $object[$arrayItem];
  1535.         }
  1537.         if (/* Template::ARRAY_CALL */ 'array' === $type || !\is_object($object)) {
  1538.             if ($isDefinedTest) {
  1539.                 return false;
  1540.             }
  1542.             if ($ignoreStrictCheck || !$env->isStrictVariables()) {
  1543.                 return;
  1544.             }
  1546.             if ($object instanceof ArrayAccess) {
  1547.                 $message = sprintf('Key "%s" in object with ArrayAccess of class "%s" does not exist.', $arrayItem, \get_class($object));
  1548.             } elseif (\is_object($object)) {
  1549.                 $message = sprintf('Impossible to access a key "%s" on an object of class "%s" that does not implement ArrayAccess interface.', $item, \get_class($object));
  1550.             } elseif (\is_array($object)) {
  1551.                 if (empty($object)) {
  1552.                     $message = sprintf('Key "%s" does not exist as the array is empty.', $arrayItem);
  1553.                 } else {
  1554.                     $message = sprintf('Key "%s" for array with keys "%s" does not exist.', $arrayItem, implode(', ', array_keys($object)));
  1555.                 }
  1556.             } elseif (/* Template::ARRAY_CALL */ 'array' === $type) {
  1557.                 if (null === $object) {
  1558.                     $message = sprintf('Impossible to access a key ("%s") on a null variable.', $item);
  1559.                 } else {
  1560.                     $message = sprintf('Impossible to access a key ("%s") on a %s variable ("%s").', $item, \gettype($object), $object);
  1561.                 }
  1562.             } elseif (null === $object) {
  1563.                 $message = sprintf('Impossible to access an attribute ("%s") on a null variable.', $item);
  1564.             } else {
  1565.                 $message = sprintf('Impossible to access an attribute ("%s") on a %s variable ("%s").', $item, \gettype($object), $object);
  1566.             }
  1568.             throw new RuntimeError($message, -1, $source);
  1569.         }
  1570.     }
  1572.     if (!\is_object($object)) {
  1573.         if ($isDefinedTest) {
  1574.             return false;
  1575.         }
  1577.         if ($ignoreStrictCheck || !$env->isStrictVariables()) {
  1578.             return;
  1579.         }
  1581.         if (null === $object) {
  1582.             $message = sprintf('Impossible to invoke a method ("%s") on a null variable.', $item);
  1583.         } elseif (\is_array($object)) {
  1584.             $message = sprintf('Impossible to invoke a method ("%s") on an array.', $item);
  1585.         } else {
  1586.             $message = sprintf('Impossible to invoke a method ("%s") on a %s variable ("%s").', $item, \gettype($object), $object);
  1587.         }
  1589.         throw new RuntimeError($message, -1, $source);
  1590.     }
  1592.     if ($object instanceof Template) {
  1593.         throw new RuntimeError('Accessing \Twig\Template attributes is forbidden.');
  1594.     }
  1596.     // object property
  1597.     if (/* Template::METHOD_CALL */ 'method' !== $type) {
  1598.         if (isset($object->$item) || \array_key_exists((string) $item, $object)) {
  1599.             if ($isDefinedTest) {
  1600.                 return true;
  1601.             }
  1603.             if ($sandboxed) {
  1604.                 $env->getExtension(SandboxExtension::class)->checkPropertyAllowed($object, $item, $source);
  1605.             }
  1607.             return $object->$item;
  1608.         }
  1609.     }
  1611.     static $cache = [];
  1613.     $class = \get_class($object);
  1615.     // object method
  1616.     // precedence: getXxx() > isXxx() > hasXxx()
  1617.     if (!isset($cache[$class])) {
  1618.         $methods = get_class_methods($object);
  1619.         sort($methods);
  1620.         $lcMethods = array_map('strtolower', $methods);
  1621.         $classCache = [];
  1622.         foreach ($methods as $i => $method) {
  1623.             $classCache[$method] = $method;
  1624.             $classCache[$lcName = $lcMethods[$i]] = $method;
  1626.             if ('g' === $lcName[0] && 0 === strpos($lcName, 'get')) {
  1627.                 $name = substr($method, 3);
  1628.                 $lcName = substr($lcName, 3);
  1629.             } elseif ('i' === $lcName[0] && 0 === strpos($lcName, 'is')) {
  1630.                 $name = substr($method, 2);
  1631.                 $lcName = substr($lcName, 2);
  1632.             } elseif ('h' === $lcName[0] && 0 === strpos($lcName, 'has')) {
  1633.                 $name = substr($method, 3);
  1634.                 $lcName = substr($lcName, 3);
  1635.                 if (\in_array('is'.$lcName, $lcMethods)) {
  1636.                     continue;
  1637.                 }
  1638.             } else {
  1639.                 continue;
  1640.             }
  1642.             // skip get() and is() methods (in which case, $name is empty)
  1643.             if ($name) {
  1644.                 if (!isset($classCache[$name])) {
  1645.                     $classCache[$name] = $method;
  1646.                 }
  1648.                 if (!isset($classCache[$lcName])) {
  1649.                     $classCache[$lcName] = $method;
  1650.                 }
  1651.             }
  1652.         }
  1653.         $cache[$class] = $classCache;
  1654.     }
  1656.     $call = false;
  1657.     if (isset($cache[$class][$item])) {
  1658.         $method = $cache[$class][$item];
  1659.     } elseif (isset($cache[$class][$lcItem = strtolower($item)])) {
  1660.         $method = $cache[$class][$lcItem];
  1661.     } elseif (isset($cache[$class]['__call'])) {
  1662.         $method = $item;
  1663.         $call = true;
  1664.     } else {
  1665.         if ($isDefinedTest) {
  1666.             return false;
  1667.         }
  1669.         if ($ignoreStrictCheck || !$env->isStrictVariables()) {
  1670.             return;
  1671.         }
  1673.         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), -1, $source);
  1674.     }
  1676.     if ($isDefinedTest) {
  1677.         return true;
  1678.     }
  1680.     if ($sandboxed) {
  1681.         $env->getExtension(SandboxExtension::class)->checkMethodAllowed($object, $method, $source);
  1682.     }
  1684.     // Some objects throw exceptions when they have __call, and the method we try
  1685.     // to call is not supported. If ignoreStrictCheck is true, we should return null.
  1686.     try {
  1687.         $ret = $object->$method(...$arguments);
  1688.     } catch (\BadMethodCallException $e) {
  1689.         if ($call && ($ignoreStrictCheck || !$env->isStrictVariables())) {
  1690.             return;
  1691.         }
  1692.         throw $e;
  1693.     }
  1695.     return $ret;
  1696. }
  1698. /**
  1699.  * Returns the values from a single column in the input array.
  1700.  *
  1701.  * <pre>
  1702.  *  {% set items = [{ 'fruit' : 'apple'}, {'fruit' : 'orange' }] %}
  1703.  *
  1704.  *  {% set fruits = items|column('fruit') %}
  1705.  *
  1706.  *  {# fruits now contains ['apple', 'orange'] #}
  1707.  * </pre>
  1708.  *
  1709.  * @param array|Traversable $array An array
  1710.  * @param mixed             $name  The column name
  1711.  *
  1712.  * @return array The array of values
  1713.  */
  1714. function twig_array_column($array, $name): array
  1715. {
  1716.     if ($array instanceof Traversable) {
  1717.         $array = iterator_to_array($array);
  1718.     } elseif (!\is_array($array)) {
  1719.         throw new RuntimeError(sprintf('The column filter only works with arrays or "Traversable", got "%s" as first argument.', \gettype($array)));
  1720.     }
  1722.     return array_column($array, $name);
  1723. }
  1724. }