1 files changed, 77 insertions, 37 deletions

diff --git a/deps/v8/third_party/jinja2/tests.py b/deps/v8/third_party/jinja2/tests.py
index fabd4ce51b..a467cf08b5 100644
--- a/deps/v8/third_party/jinja2/tests.py
+++ b/deps/v8/third_party/jinja2/tests.py
@@ -1,36 +1,32 @@
-# -*- coding: utf-8 -*-
 """Built-in template tests used with the ``is`` operator."""
-import decimal
 import operator
-import re
+import typing as t
+from collections import abc
+from numbers import Number
 
-from ._compat import abc
-from ._compat import integer_types
-from ._compat import string_types
-from ._compat import text_type
 from .runtime import Undefined
+from .utils import pass_environment
 
-number_re = re.compile(r"^-?\d+(\.\d+)?$")
-regex_type = type(number_re)
-test_callable = callable
+if t.TYPE_CHECKING:
+    from .environment import Environment
 
 
-def test_odd(value):
+def test_odd(value: int) -> bool:
     """Return true if the variable is odd."""
     return value % 2 == 1
 
 
-def test_even(value):
+def test_even(value: int) -> bool:
     """Return true if the variable is even."""
     return value % 2 == 0
 
 
-def test_divisibleby(value, num):
+def test_divisibleby(value: int, num: int) -> bool:
     """Check if a variable is divisible by a number."""
     return value % num == 0
 
 
-def test_defined(value):
+def test_defined(value: t.Any) -> bool:
     """Return true if the variable is defined:
 
     .. sourcecode:: jinja
@@ -47,17 +43,57 @@ def test_defined(value):
     return not isinstance(value, Undefined)
 
 
-def test_undefined(value):
+def test_undefined(value: t.Any) -> bool:
     """Like :func:`defined` but the other way round."""
     return isinstance(value, Undefined)
 
 
-def test_none(value):
+@pass_environment
+def test_filter(env: "Environment", value: str) -> bool:
+    """Check if a filter exists by name. Useful if a filter may be
+    optionally available.
+
+    .. code-block:: jinja
+
+        {% if 'markdown' is filter %}
+            {{ value | markdown }}
+        {% else %}
+            {{ value }}
+        {% endif %}
+
+    .. versionadded:: 3.0
+    """
+    return value in env.filters
+
+
+@pass_environment
+def test_test(env: "Environment", value: str) -> bool:
+    """Check if a test exists by name. Useful if a test may be
+    optionally available.
+
+    .. code-block:: jinja
+
+        {% if 'loud' is test %}
+            {% if value is loud %}
+                {{ value|upper }}
+            {% else %}
+                {{ value|lower }}
+            {% endif %}
+        {% else %}
+            {{ value }}
+        {% endif %}
+
+    .. versionadded:: 3.0
+    """
+    return value in env.tests
+
+
+def test_none(value: t.Any) -> bool:
     """Return true if the variable is none."""
     return value is None
 
 
-def test_boolean(value):
+def test_boolean(value: t.Any) -> bool:
     """Return true if the object is a boolean value.
 
     .. versionadded:: 2.11
@@ -65,7 +101,7 @@ def test_boolean(value):
     return value is True or value is False
 
 
-def test_false(value):
+def test_false(value: t.Any) -> bool:
     """Return true if the object is False.
 
     .. versionadded:: 2.11
@@ -73,7 +109,7 @@ def test_false(value):
     return value is False
 
 
-def test_true(value):
+def test_true(value: t.Any) -> bool:
     """Return true if the object is True.
 
     .. versionadded:: 2.11
@@ -82,16 +118,16 @@ def test_true(value):
 
 
 # NOTE: The existing 'number' test matches booleans and floats
-def test_integer(value):
+def test_integer(value: t.Any) -> bool:
     """Return true if the object is an integer.
 
     .. versionadded:: 2.11
     """
-    return isinstance(value, integer_types) and value is not True and value is not False
+    return isinstance(value, int) and value is not True and value is not False
 
 
 # NOTE: The existing 'number' test matches booleans and integers
-def test_float(value):
+def test_float(value: t.Any) -> bool:
     """Return true if the object is a float.
 
     .. versionadded:: 2.11
@@ -99,22 +135,22 @@ def test_float(value):
     return isinstance(value, float)
 
 
-def test_lower(value):
+def test_lower(value: str) -> bool:
     """Return true if the variable is lowercased."""
-    return text_type(value).islower()
+    return str(value).islower()
 
 
-def test_upper(value):
+def test_upper(value: str) -> bool:
     """Return true if the variable is uppercased."""
-    return text_type(value).isupper()
+    return str(value).isupper()
 
 
-def test_string(value):
+def test_string(value: t.Any) -> bool:
     """Return true if the object is a string."""
-    return isinstance(value, string_types)
+    return isinstance(value, str)
 
 
-def test_mapping(value):
+def test_mapping(value: t.Any) -> bool:
     """Return true if the object is a mapping (dict etc.).
 
     .. versionadded:: 2.6
@@ -122,12 +158,12 @@ def test_mapping(value):
     return isinstance(value, abc.Mapping)
 
 
-def test_number(value):
+def test_number(value: t.Any) -> bool:
     """Return true if the variable is a number."""
-    return isinstance(value, integer_types + (float, complex, decimal.Decimal))
+    return isinstance(value, Number)
 
 
-def test_sequence(value):
+def test_sequence(value: t.Any) -> bool:
     """Return true if the variable is a sequence. Sequences are variables
     that are iterable.
     """
@@ -136,10 +172,11 @@ def test_sequence(value):
         value.__getitem__
     except Exception:
         return False
+
     return True
 
 
-def test_sameas(value, other):
+def test_sameas(value: t.Any, other: t.Any) -> bool:
     """Check if an object points to the same memory address than another
     object:
 
@@ -152,21 +189,22 @@ def test_sameas(value, other):
     return value is other
 
 
-def test_iterable(value):
+def test_iterable(value: t.Any) -> bool:
     """Check if it's possible to iterate over an object."""
     try:
         iter(value)
     except TypeError:
         return False
+
     return True
 
 
-def test_escaped(value):
+def test_escaped(value: t.Any) -> bool:
     """Check if the value is escaped."""
     return hasattr(value, "__html__")
 
 
-def test_in(value, seq):
+def test_in(value: t.Any, seq: t.Container) -> bool:
     """Check if value is in seq.
 
     .. versionadded:: 2.10
@@ -180,6 +218,8 @@ TESTS = {
     "divisibleby": test_divisibleby,
     "defined": test_defined,
     "undefined": test_undefined,
+    "filter": test_filter,
+    "test": test_test,
     "none": test_none,
     "boolean": test_boolean,
     "false": test_false,
@@ -193,7 +233,7 @@ TESTS = {
     "number": test_number,
     "sequence": test_sequence,
     "iterable": test_iterable,
-    "callable": test_callable,
+    "callable": callable,
     "sameas": test_sameas,
     "escaped": test_escaped,
     "in": test_in,