text: """Default variable filters."""
  import random as random_module
  import re
  import types
  from decimal import ROUND_HALF_UP, Context, Decimal, InvalidOperation
  from functools import wraps
  from operator import itemgetter
  from pprint import pformat
  from urllib.parse import quote
  
  from django.utils import formats
  from django.utils.dateformat import format, time_format
  from django.utils.encoding import iri_to_uri
  from django.utils.html import (
      avoid_wrapping, conditional_escape, escape, escapejs,
      json_script as _json_script, linebreaks, strip_tags, urlize as _urlize,
  )
  from django.utils.safestring import SafeData, mark_safe
  from django.utils.text import (
      Truncator, normalize_newlines, phone2numeric, slugify as _slugify, wrap,
  )
  from django.utils.timesince import timesince, timeuntil
  from django.utils.translation import gettext, ngettext
  
  from .base import Variable, VariableDoesNotExist
  from .library import Library
  
  register = Library()
  
  
  #######################
  # STRING DECORATOR    #
  #######################
  
  def stringfilter(func):
      """
      Decorator for filters which should only receive strings. The object
      passed as the first positional argument will be converted to a string.
      """
      def _dec(*args, **kwargs):
          args = list(args)
          args[0] = str(args[0])
          if (isinstance(args[0], SafeData) and
                  getattr(_dec._decorated_function, 'is_safe', False)):
              return mark_safe(func(*args, **kwargs))
          return func(*args, **kwargs)
  
      # Include a reference to the real function (used to check original
      # arguments by the template parser, and to bear the 'is_safe' attribute
      # when multiple decorators are applied).
      _dec._decorated_function = getattr(func, '_decorated_function', func)
  
      return wraps(func)(_dec)
  
  
  ###################
  # STRINGS         #
  ###################
  
  @register.filter(is_safe=True)
  @stringfilter
  def addslashes(value):
      """
      Add slashes before quotes. Useful for escaping strings in CSV, for
      example. Less useful for escaping JavaScript; use the ``escapejs``
      filter instead.
      """
      return value.replace('\\', '\\\\').replace('"', '\\"').replace("'", "\\'")
  
  
  @register.filter(is_safe=True)
  @stringfilter
  def capfirst(value):
      """Capitalize the first character of the value."""
      return value and value[0].upper() + value[1:]
  
  
  @register.filter("escapejs")
  @stringfilter
  def escapejs_filter(value):
      """Hex encode characters for use in JavaScript strings."""
      return escapejs(value)
  
  
  @register.filter(is_safe=True)
  def json_script(value, element_id):
      """
      Output value JSON-encoded, wrapped in a <script type="application/json">
      tag.
      """
      return _json_script(value, element_id)
  
  
  @register.filter(is_safe=True)
  def floatformat(text, arg=-1):
      """
      Display a float to a specified number of decimal places.
  
      If called without an argument, display the floating point number with one
      decimal place -- but only if there's a decimal place to be displayed:
  
      * num1 = 34.23234
      * num2 = 34.00000
      * num3 = 34.26000
      * {{ num1|floatformat }} displays "34.2"
      * {{ num2|floatformat }} displays "34"
      * {{ num3|floatformat }} displays "34.3"
  
      If arg is positive, always display exactly arg number of decimal places:
  
      * {{ num1|floatformat:3 }} displays "34.232"
      * {{ num2|floatformat:3 }} displays "34.000"
      * {{ num3|floatformat:3 }} displays "34.260"
  
      If arg is negative, display arg number of decimal places -- but only if
      there are places to be displayed:
  
      * {{ num1|floatformat:"-3" }} displays "34.232"
      * {{ num2|floatformat:"-3" }} displays "34"
      * {{ num3|floatformat:"-3" }} displays "34.260"
  
      If the input float is infinity or NaN, display the string representation
      of that value.
      """
      try:
          input_val = repr(text)
          d = Decimal(input_val)
      except InvalidOperation:
          try:
              d = Decimal(str(float(text)))
          except (ValueError, InvalidOperation, TypeError):
              return ''
      try:
          p = int(arg)
      except ValueError:
          return input_val
  
      try:
          m = int(d) - d
      except (ValueError, OverflowError, InvalidOperation):
          return input_val
  
      if not m and p < 0:
          return mark_safe(formats.number_format('%d' % (int(d)), 0))
  
      exp = Decimal(1).scaleb(-abs(p))
      # Set the precision high enough to avoid an exception (#15789).
      tupl = d.as_tuple()
      units = len(tupl[1])
      units += -tupl[2] if m else tupl[2]
      prec = abs(p) + units + 1
  
      # Avoid conversion to scientific notation by accessing `sign`, `digits`,
      # and `exponent` from Decimal.as_tuple() directly.
      sign, digits, exponent = d.quantize(exp, ROUND_HALF_UP, Context(prec=prec)).as_tuple()
      digits = [str(digit) for digit in reversed(digits)]
      while len(digits) <= abs(exponent):
          digits.append('0')
      digits.insert(-exponent, '.')
      if sign:
          digits.append('-')
      number = ''.join(reversed(digits))
      return mark_safe(formats.number_format(number, abs(p)))
  
  
  @register.filter(is_safe=True)
  @stringfilter
  def iriencode(value):
      """Escape an IRI value for use in a URL."""
      return iri_to_uri(value)
  
  
  @register.filter(is_safe=True, needs_autoescape=True)
  @stringfilter
  def linenumbers(value, autoescape=True):
      """Display text with line numbers."""
      lines = value.split('\n')
      # Find the maximum width of the line count, for use with zero padding
      # string format command
      width = str(len(str(len(lines))))
      if not autoescape or isinstance(value, SafeData):
          for i, line in enumerate(lines):
              lines[i] = ("%0" + width + "d. %s") % (i + 1, line)
      else:
          for i, line in enumerate(lines):
              lines[i] = ("%0" + width + "d. %s") % (i + 1, escape(line))
      return mark_safe('\n'.join(lines))
  
  
  @register.filter(is_safe=True)
  @stringfilter
  def lower(value):
      """Convert a string into all lowercase."""
      return value.lower()
  
  
  @register.filter(is_safe=False)
  @stringfilter
  def make_list(value):
      """
      Return the value turned into a list.
  
      For an integer, it's a list of digits.
      For a string, it's a list of characters.
      """
      return list(value)
  
  
  @register.filter(is_safe=True)
  @stringfilter
  def slugify(value):
      """
      Convert to ASCII. Convert spaces to hyphens. Remove characters that aren't
      alphanumerics, underscores, or hyphens. Convert to lowercase. Also strip
      leading and trailing whitespace.
      """
      return _slugify(value)
  
  
  @register.filter(is_safe=True)
  def stringformat(value, arg):
      """
      Format the variable according to the arg, a string formatting specifier.
  
      This specifier uses Python string formatting syntax, with the exception
      that the leading "%" is dropped.
  
      See https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting
      for documentation of Python string formatting.
      """
      if isinstance(value, tuple):
          value = str(value)
      try:
          return ("%" + str(arg)) % value
      except (ValueError, TypeError):
          return ""
  
  
  @register.filter(is_safe=True)
  @stringfilter
  def title(value):
      """Convert a string into titlecase."""
      t = re.sub("([a-z])'([A-Z])", lambda m: m.group(0).lower(), value.title())
      return re.sub(r"\d([A-Z])", lambda m: m.group(0).lower(), t)
  
  
  @register.filter(is_safe=True)
  @stringfilter
  def truncatechars(value, arg):
      """Truncate a string after `arg` number of characters."""
      try:
          length = int(arg)
      except ValueError:  # Invalid literal for int().
          return value  # Fail silently.
      return Truncator(value).chars(length)
  
  
  @register.filter(is_safe=True)
  @stringfilter
  def truncatechars_html(value, arg):
      """
      Truncate HTML after `arg` number of chars.
      Preserve newlines in the HTML.
      """
      try:
          length = int(arg)
      except ValueError:  # invalid literal for int()
          return value  # Fail silently.
      return Truncator(value).chars(length, html=True)
  
  
  @register.filter(is_safe=True)
  @stringfilter
  def truncatewords(value, arg):
      """
      Truncate a string after `arg` number of words.
      Remove newlines within the string.
      """
      try:
          length = int(arg)
      except ValueError:  # Invalid literal for int().
          return value  # Fail silently.
      return Truncator(value).words(length, truncate=' ...')
  
  
  @register.filter(is_safe=True)
  @stringfilter
  def truncatewords_html(value, arg):
      """
      Truncate HTML after `arg` number of words.
      Preserve newlines in the HTML.
      """
      try:
          length = int(arg)
      except ValueError:  # invalid literal for int()
          return value  # Fail silently.
      return Truncator(value).words(length, html=True, truncate=' ...')
  
  
  @register.filter(is_safe=False)
  @stringfilter
  def upper(value):
      """Convert a string into all uppercase."""
      return value.upper()
  
  
  @register.filter(is_safe=False)
  @stringfilter
  def urlencode(value, safe=None):
      """
      Escape a value for use in a URL.
  
      The ``safe`` parameter determines the characters which should not be
      escaped by Python's quote() function. If not provided, use the default safe
      characters (but an empty string can be provided when *all* characters
      should be escaped).
      """
      kwargs = {}
      if safe is not None:
          kwargs['safe'] = safe
      return quote(value, **kwargs)
  
  
  @register.filter(is_safe=True, needs_autoescape=True)
  @stringfilter
  def urlize(value, autoescape=True):
      """Convert URLs in plain text into clickable links."""
      return mark_safe(_urlize(value, nofollow=True, autoescape=autoescape))
  
  
  @register.filter(is_safe=True, needs_autoescape=True)
  @stringfilter
  def urlizetrunc(value, limit, autoescape=True):
      """
      Convert URLs into clickable links, truncating URLs to the given character
      limit, and adding 'rel=nofollow' attribute to discourage spamming.
  
      Argument: Length to truncate URLs to.
      """
      return mark_safe(_urlize(value, trim_url_limit=int(limit), nofollow=True, autoescape=autoescape))
  
  
  @register.filter(is_safe=False)
  @stringfilter
  def wordcount(value):
      """Return the number of words."""
      return len(value.split())
  
  
  @register.filter(is_safe=True)
  @stringfilter
  def wordwrap(value, arg):
      """Wrap words at `arg` line length."""
      return wrap(value, int(arg))
  
  
  @register.filter(is_safe=True)
  @stringfilter
  def ljust(value, arg):
      """Left-align the value in a field of a given width."""
      return value.ljust(int(arg))
  
  
  @register.filter(is_safe=True)
  @stringfilter
  def rjust(value, arg):
      """Right-align the value in a field of a given width."""
      return value.rjust(int(arg))
  
  
  @register.filter(is_safe=True)
  @stringfilter
  def center(value, arg):
      """Center the value in a field of a given width."""
      return value.center(int(arg))
  
  
  @register.filter
  @stringfilter
  def cut(value, arg):
      """Remove all values of arg from the given string."""
      safe = isinstance(value, SafeData)
      value = value.replace(arg, '')
      if safe and arg != ';':
          return mark_safe(value)
      return value
  
  
  ###################
  # HTML STRINGS    #
  ###################
  
  @register.filter("escape", is_safe=True)
  @stringfilter
  def escape_filter(value):
      """Mark the value as a string that should be auto-escaped."""
      return conditional_escape(value)
  
  
  @register.filter(is_safe=True)
  @stringfilter
  def force_escape(value):
      """
      Escape a string's HTML. Return a new string containing the escaped
      characters (as opposed to "escape", which marks the content for later
      possible escaping).
      """
      return escape(value)
  
  
  @register.filter("linebreaks", is_safe=True, needs_autoescape=True)
  @stringfilter
  def linebreaks_filter(value, autoescape=True):
      """
      Replace line breaks in plain text with appropriate HTML; a single
      newline becomes an HTML line break (``<br>``) and a new line
      followed by a blank line becomes a paragraph break (``</p>``).
      """
      autoescape = autoescape and not isinstance(value, SafeData)
      return mark_safe(linebreaks(value, autoescape))
  
  
  @register.filter(is_safe=True, needs_autoescape=True)
  @stringfilter
  def linebreaksbr(value, autoescape=True):
      """
      Convert all newlines in a piece of plain text to HTML line breaks
      (``<br>``).
      """
      autoescape = autoescape and not isinstance(value, SafeData)
      value = normalize_newlines(value)
      if autoescape:
          value = escape(value)
      return mark_safe(value.replace('\n', '<br>'))
  
  
  @register.filter(is_safe=True)
  @stringfilter
  def safe(value):
      """Mark the value as a string that should not be auto-escaped."""
      return mark_safe(value)
  
  
  @register.filter(is_safe=True)
  def safeseq(value):
      """
      A "safe" filter for sequences. Mark each element in the sequence,
      individually, as safe, after converting them to strings. Return a list
      with the results.
      """
      return [mark_safe(obj) for obj in value]
  
  
  @register.filter(is_safe=True)
  @stringfilter
  def striptags(value):
      """Strip all [X]HTML tags."""
      return strip_tags(value)
  
  
  ###################
  # LISTS           #
  ###################
  
  def _property_resolver(arg):
      """
      When arg is convertible to float, behave like operator.itemgetter(arg)
      Otherwise, behave like Variable(arg).resolve
  
      >>> _property_resolver(1)('abc')
      'b'
      >>> _property_resolver('1')('abc')
      Traceback (most recent call last):
      ...
      TypeError: string indices must be integers
      >>> class Foo:
      ...     a = 42
      ...     b = 3.14
      ...     c = 'Hey!'
      >>> _property_resolver('b')(Foo())
      3.14
      """
      try:
          float(arg)
      except ValueError:
          return Variable(arg).resolve
      else:
          return itemgetter(arg)
  
  
  @register.filter(is_safe=False)
  def dictsort(value, arg):
      """
      Given a list of dicts, return that list sorted by the property given in
      the argument.
      """
      try:
          return sorted(value, key=_property_resolver(arg))
      except (TypeError, VariableDoesNotExist):
          return ''
  
  
  @register.filter(is_safe=False)
  def dictsortreversed(value, arg):
      """
      Given a list of dicts, return that list sorted in reverse order by the
      property given in the argument.
      """
      try:
          return sorted(value, key=_property_resolver(arg), reverse=True)
      except (TypeError, VariableDoesNotExist):
          return ''
  
  
  @register.filter(is_safe=False)
  def first(value):
      """Return the first item in a list."""
      try:
          return value[0]
      except IndexError:
          return ''
  
  
  @register.filter(is_safe=True, needs_autoescape=True)
  def join(value, arg, autoescape=True):
      """Join a list with a string, like Python's ``str.join(list)``."""
      try:
          if autoescape:
              value = [conditional_escape(v) for v in value]
          data = conditional_escape(arg).join(value)
      except TypeError:  # Fail silently if arg isn't iterable.
          return value
      return mark_safe(data)
  
  
  @register.filter(is_safe=True)
  def last(value):
      """Return the last item in a list."""
      try:
          return value[-1]
      except IndexError:
          return ''
  
  
  @register.filter(is_safe=False)
  def length(value):
      """Return the length of the value - useful for lists."""
      try:
          return len(value)
      except (ValueError, TypeError):
          return 0
  
  
  @register.filter(is_safe=False)
  def length_is(value, arg):
      """Return a boolean of whether the value's length is the argument."""
      try:
          return len(value) == int(arg)
      except (ValueError, TypeError):
          return ''
  
  
  @register.filter(is_safe=True)
  def random(value):
      """Return a random item from the list."""
      return random_module.choice(value)
  
  
  @register.filter("slice", is_safe=True)
  def slice_filter(value, arg):
      """
      Return a slice of the list using the same syntax as Python's list slicing.
      """
      try:
          bits = []
          for x in str(arg).split(':'):
              if not x:
                  bits.append(None)
              else:
                  bits.append(int(x))
          return value[slice(*bits)]
  
      except (ValueError, TypeError):
          return value  # Fail silently.
  
  
  @register.filter(is_safe=True, needs_autoescape=True)
  def unordered_list(value, autoescape=True):
      """
      Recursively take a self-nested list and return an HTML unordered list --
      WITHOUT opening and closing <ul> tags.
  
      Assume the list is in the proper format. For example, if ``var`` contains:
      ``['States', ['Kansas', ['Lawrence', 'Topeka'], 'Illinois']]``, then
      ``{{ var|unordered_list }}`` returns::
  
          <li>States
          <ul>
                  <li>Kansas
                  <ul>
                          <li>Lawrence</li>
                          <li>Topeka</li>
                  </ul>
                  </li>
                  <li>Illinois</li>
          </ul>
          </li>
      """
      if autoescape:
          escaper = conditional_escape
      else:
          def escaper(x):
              return x
  
      def walk_items(item_list):
          item_iterator = iter(item_list)
          try:
              item = next(item_iterator)
              while True:
                  try:
                      next_item = next(item_iterator)
                  except StopIteration:
                      yield item, None
                      break
                  if isinstance(next_item, (list, tuple, types.GeneratorType)):
                      try:
                          iter(next_item)
                      except TypeError:
                          pass
                      else:
                          yield item, next_item
                          item = next(item_iterator)
                          continue
                  yield item, None
                  item = next_item
          except StopIteration:
              pass
  
      def list_formatter(item_list, tabs=1):
          indent = '\t' * tabs
          output = []
          for item, children in walk_items(item_list):
              sublist = ''
              if children:
                  sublist = '\n%s<ul>\n%s\n%s</ul>\n%s' % (
                      indent, list_formatter(children, tabs + 1), indent, indent)
              output.append('%s<li>%s%s</li>' % (
                  indent, escaper(item), sublist))
          return '\n'.join(output)
  
      return mark_safe(list_formatter(value))
  
  
  ###################
  # INTEGERS        #
  ###################
  
  @register.filter(is_safe=False)
  def add(value, arg):
      """Add the arg to the value."""
      try:
          return int(value) + int(arg)
      except (ValueError, TypeError):
          try:
              return value + arg
          except Exception:
              return ''
  
  
  @register.filter(is_safe=False)
  def get_digit(value, arg):
      """
      Given a whole number, return the requested digit of it, where 1 is the
      right-most digit, 2 is the second-right-most digit, etc. Return the
      original value for invalid input (if input or argument is not an integer,
      or if argument is less than 1). Otherwise, output is always an integer.
      """
      try:
          arg = int(arg)
          value = int(value)
      except ValueError:
          return value  # Fail silently for an invalid argument
      if arg < 1:
          return value
      try:
          return int(str(value)[-arg])
      except IndexError:
          return 0
  
  
  ###################
  # DATES           #
  ###################
  
  @register.filter(expects_localtime=True, is_safe=False)
  def date(value, arg=None):
      """Format a date according to the given format."""
      if value in (None, ''):
          return ''
      try:
          return formats.date_format(value, arg)
      except AttributeError:
          try:
              return format(value, arg)
          except AttributeError:
              return ''
  
  
  @register.filter(expects_localtime=True, is_safe=False)
  def time(value, arg=None):
      """Format a time according to the given format."""
      if value in (None, ''):
          return ''
      try:
          return formats.time_format(value, arg)
      except (AttributeError, TypeError):
          try:
              return time_format(value, arg)
          except (AttributeError, TypeError):
              return ''
  
  
  @register.filter("timesince", is_safe=False)
  def timesince_filter(value, arg=None):
      """Format a date as the time since that date (i.e. "4 days, 6 hours")."""
      if not value:
          return ''
      try:
          if arg:
              return timesince(value, arg)
          return timesince(value)
      except (ValueError, TypeError):
          return ''
  
  
  @register.filter("timeuntil", is_safe=False)
  def timeuntil_filter(value, arg=None):
      """Format a date as the time until that date (i.e. "4 days, 6 hours")."""
      if not value:
          return ''
      try:
          return timeuntil(value, arg)
      except (ValueError, TypeError):
          return ''
  
  
  ###################
  # LOGIC           #
  ###################
  
  @register.filter(is_safe=False)
  def default(value, arg):
      """If value is unavailable, use given default."""
      return value or arg
  
  
  @register.filter(is_safe=False)
  def default_if_none(value, arg):
      """If value is None, use given default."""
      if value is None:
          return arg
      return value
  
  
  @register.filter(is_safe=False)
  def divisibleby(value, arg):
      """Return True if the value is divisible by the argument."""
      return int(value) % int(arg) == 0
  
  
  @register.filter(is_safe=False)
  def yesno(value, arg=None):
      """
      Given a string mapping values for true, false, and (optionally) None,
      return one of those strings according to the value:
  
      ==========  ======================  ==================================
      Value       Argument                Outputs
      ==========  ======================  ==================================
      ``True``    ``"yeah,no,maybe"``     ``yeah``
      ``False``   ``"yeah,no,maybe"``     ``no``
      ``None``    ``"yeah,no,maybe"``     ``maybe``
      ``None``    ``"yeah,no"``           ``"no"`` (converts None to False
                                          if no mapping for None is given.
      ==========  ======================  ==================================
      """
      if arg is None:
          arg = gettext('yes,no,maybe')
      bits = arg.split(',')
      if len(bits) < 2:
          return value  # Invalid arg.
      try:
          yes, no, maybe = bits
      except ValueError:
          # Unpack list of wrong size (no "maybe" value provided).
          yes, no, maybe = bits[0], bits[1], bits[1]
      if value is None:
          return maybe
      if value:
          return yes
      return no
  
  
  ###################
  # MISC            #
  ###################
  
  @register.filter(is_safe=True)
  def filesizeformat(bytes_):
      """
      Format the value like a 'human-readable' file size (i.e. 13 KB, 4.1 MB,
      102 bytes, etc.).
      """
      try:
          bytes_ = float(bytes_)
      except (TypeError, ValueError, UnicodeDecodeError):
          value = ngettext("%(size)d byte", "%(size)d bytes", 0) % {'size': 0}
          return avoid_wrapping(value)
  
      def filesize_number_format(value):
          return formats.number_format(round(value, 1), 1)
  
      KB = 1 << 10
      MB = 1 << 20
      GB = 1 << 30
      TB = 1 << 40
      PB = 1 << 50
  
      negative = bytes_ < 0
      if negative:
          bytes_ = -bytes_  # Allow formatting of negative numbers.
  
      if bytes_ < KB:
          value = ngettext("%(size)d byte", "%(size)d bytes", bytes_) % {'size': bytes_}
      elif bytes_ < MB:
          value = gettext("%s KB") % filesize_number_format(bytes_ / KB)
      elif bytes_ < GB:
          value = gettext("%s MB") % filesize_number_format(bytes_ / MB)
      elif bytes_ < TB:
          value = gettext("%s GB") % filesize_number_format(bytes_ / GB)
      elif bytes_ < PB:
          value = gettext("%s TB") % filesize_number_format(bytes_ / TB)
      else:
          value = gettext("%s PB") % filesize_number_format(bytes_ / PB)
  
      if negative:
          value = "-%s" % value
      return avoid_wrapping(value)
  
  
  @register.filter(is_safe=False)
  def pluralize(value, arg='s'):
      """
      Return a plural suffix if the value is not 1. By default, use 's' as the
      suffix:
  
      * If value is 0, vote{{ value|pluralize }} display "votes".
      * If value is 1, vote{{ value|pluralize }} display "vote".
      * If value is 2, vote{{ value|pluralize }} display "votes".
  
      If an argument is provided, use that string instead:
  
      * If value is 0, class{{ value|pluralize:"es" }} display "classes".
      * If value is 1, class{{ value|pluralize:"es" }} display "class".
      * If value is 2, class{{ value|pluralize:"es" }} display "classes".
  
      If the provided argument contains a comma, use the text before the comma
      for the singular case and the text after the comma for the plural case:
  
      * If value is 0, cand{{ value|pluralize:"y,ies" }} display "candies".
      * If value is 1, cand{{ value|pluralize:"y,ies" }} display "candy".
      * If value is 2, cand{{ value|pluralize:"y,ies" }} display "candies".
      """
      if ',' not in arg:
          arg = ',' + arg
      bits = arg.split(',')
      if len(bits) > 2:
          return ''
      singular_suffix, plural_suffix = bits[:2]
  
      try:
          if float(value) != 1:
              return plural_suffix
      except ValueError:  # Invalid string that's not a number.
          pass
      except TypeError:  # Value isn't a string or a number; maybe it's a list?
          try:
              if len(value) != 1:
                  return plural_suffix
          except TypeError:  # len() of unsized object.
              pass
      return singular_suffix
  
  
  @register.filter("phone2numeric", is_safe=True)
  def phone2numeric_filter(value):
      """Take a phone number and converts it in to its numerical equivalent."""
      return phone2numeric(value)
  
  
  @register.filter(is_safe=True)
  def pprint(value):
      """A wrapper around pprint.pprint -- for debugging, really."""
      try:
          return pformat(value)
      except Exception as e:
          return "Error in formatting: %s: %s" % (e.__class__.__name__, e)
  