@rhinostone/swig-jinja2 2.5.0

package/lib/filters.js

@@ -0,0 +1,1369 @@
+var utils = require('@rhinostone/swig-core/lib/utils'),
+  dateFormatter = require('@rhinostone/swig-core/lib/dateformatter'),
+  iterateFilter = require('@rhinostone/swig-core/lib/filters').iterateFilter;
+
+/**
+ * Jinja2 filter catalog.
+ *
+ * Per-flavor map consumed by `engine.install(self, frontend)` as both the
+ * `_filters` runtime map in the compiled template function and the
+ * mutation target for `setFilter`. The `.safe = true` convention is
+ * inherited from swig-core — filters marked `.safe` suppress the
+ * autoescape `e` tail injected in the parser's `parseVariable`.
+ *
+ * Filter names route through `_filters["<name>"]` at runtime (bracket
+ * access on the engine's own filter map), never through the `_ctx`
+ * prototype chain, so CVE-2023-25345 guards don't apply at this layer.
+ * Filter arg expressions inherit the expression parser's `_dangerousProps`
+ * guards.
+ *
+ * This is the bootstrap set (escape / safe + a couple of basics) that the
+ * render pipeline needs to function. The full Jinja2 catalog lands in
+ * subsequent commits.
+ */
+
+/**
+ * Uppercase the input. Recurses into arrays / objects.
+ *
+ * @example
+ * {{ "swig"|upper }}
+ * // => SWIG
+ *
+ * @param  {*} input
+ * @return {*}
+ */
+exports.upper = function (input) {
+  var out = iterateFilter.apply(exports.upper, arguments);
+  if (out !== undefined) {
+    return out;
+  }
+  return input.toString().toUpperCase();
+};
+
+/**
+ * Lowercase the input. Recurses into arrays / objects.
+ *
+ * @example
+ * {{ "SWIG"|lower }}
+ * // => swig
+ *
+ * @param  {*} input
+ * @return {*}
+ */
+exports.lower = function (input) {
+  var out = iterateFilter.apply(exports.lower, arguments);
+  if (out !== undefined) {
+    return out;
+  }
+  return input.toString().toLowerCase();
+};
+
+/**
+ * Mark the input as safe, bypassing autoescape. Jinja2 calls this filter
+ * `safe`; the value passes through untouched.
+ *
+ * @example
+ * {{ "<b>bold</b>"|safe }}
+ * // => <b>bold</b>
+ *
+ * @param  {*} input
+ * @return {*}
+ */
+exports.safe = function (input) {
+  return input;
+};
+exports.safe.safe = true;
+
+/**
+ * HTML-escape (default) or JS-escape the input. `e` is the shortcut alias
+ * applied by autoescape. The HTML branch preserves already-escaped
+ * entities (`&amp;`, `&lt;`, …) so the autoescape tail is idempotent.
+ *
+ * @example
+ * {{ "<b>"|escape }}
+ * // => &lt;b&gt;
+ *
+ * @example
+ * {{ "<b>"|e("js") }}
+ * // => <b>
+ *
+ * @param  {*}      input
+ * @param  {string} [type='html']  Pass `'js'` for JavaScript-safe escaping.
+ * @return {string}
+ */
+function escapeHtmlRest(ch) {
+  return ch === '<' ? '&lt;' : ch === '>' ? '&gt;' : ch === '"' ? '&quot;' : '&#39;';
+}
+
+exports.escape = function (input, type) {
+  var t, inp, out, i, code;
+
+  if (input === null || input === undefined) {
+    return input;
+  }
+
+  t = typeof input;
+
+  if (t !== 'string') {
+    if (t === 'object') {
+      out = iterateFilter.apply(exports.escape, arguments);
+      if (out !== undefined) {
+        return out;
+      }
+    }
+    return input;
+  }
+
+  if (type === 'js') {
+    inp = input.replace(/\\/g, '\\u005C');
+    out = '';
+    for (i = 0; i < inp.length; i += 1) {
+      code = inp.charCodeAt(i);
+      if (code < 32) {
+        code = code.toString(16).toUpperCase();
+        code = (code.length < 2) ? '0' + code : code;
+        out += '\\u00' + code;
+      } else {
+        out += inp[i];
+      }
+    }
+    return out.replace(/&/g, '\\u0026')
+      .replace(/</g, '\\u003C')
+      .replace(/>/g, '\\u003E')
+      .replace(/\'/g, '\\u0027')
+      .replace(/"/g, '\\u0022')
+      .replace(/\=/g, '\\u003D')
+      .replace(/-/g, '\\u002D')
+      .replace(/;/g, '\\u003B');
+  }
+
+  return input.replace(/&(?!amp;|lt;|gt;|quot;|#39;)/g, '&amp;')
+    .replace(/[<>"']/g, escapeHtmlRest);
+};
+exports.e = exports.escape;
+
+/**
+ * Return the number of items in a sequence (array, string) or the number
+ * of keys in a mapping (object). `count` is an alias.
+ *
+ * @example
+ * {{ "Tacos"|length }}
+ * // => 5
+ *
+ * @param  {*} input
+ * @return {number|string} The length, or "" when the input has none.
+ */
+exports.length = function (input) {
+  if (typeof input === 'object' && input !== null && !utils.isArray(input)) {
+    return utils.keys(input).length;
+  }
+  if (input && input.hasOwnProperty('length')) {
+    return input.length;
+  }
+  return '';
+};
+
+/**
+ * Alias of `length`.
+ *
+ * @example
+ * {{ items|count }}
+ * // => 3
+ *
+ * @param  {*} input
+ * @return {number|string}
+ */
+exports.count = exports.length;
+
+/**
+ * Return the first item of an array, the first character of a string, or
+ * the first value of an object.
+ *
+ * @example
+ * {{ ["a", "b", "c"]|first }}
+ * // => a
+ *
+ * @param  {*} input
+ * @return {*}
+ */
+exports.first = function (input) {
+  if (typeof input === 'object' && input !== null && !utils.isArray(input)) {
+    var keys = utils.keys(input);
+    return input[keys[0]];
+  }
+  if (typeof input === 'string') {
+    return input.substr(0, 1);
+  }
+  if (utils.isArray(input)) {
+    return input[0];
+  }
+  return input;
+};
+
+/**
+ * Return the last item of an array, the last character of a string, or
+ * the last value of an object.
+ *
+ * @example
+ * {{ ["a", "b", "c"]|last }}
+ * // => c
+ *
+ * @param  {*} input
+ * @return {*}
+ */
+exports.last = function (input) {
+  if (typeof input === 'object' && input !== null && !utils.isArray(input)) {
+    var keys = utils.keys(input);
+    return input[keys[keys.length - 1]];
+  }
+  if (typeof input === 'string') {
+    return input.charAt(input.length - 1);
+  }
+  if (utils.isArray(input)) {
+    return input[input.length - 1];
+  }
+  return input;
+};
+
+/**
+ * Join a sequence with a string glue. The default glue is the empty
+ * string (Jinja2 default), not a comma. A mapping joins its keys.
+ *
+ * @example
+ * {{ ["foo", "bar", "baz"]|join(", ") }}
+ * // => foo, bar, baz
+ *
+ * @example
+ * {{ [1, 2, 3]|join }}
+ * // => 123
+ *
+ * @param  {*}      input
+ * @param  {string} [glue='']
+ * @return {string}
+ */
+exports.join = function (input, glue) {
+  if (glue === undefined) { glue = ''; }
+  if (utils.isArray(input)) {
+    return input.join(glue);
+  }
+  if (input && typeof input === 'object') {
+    return utils.keys(input).join(glue);
+  }
+  return input;
+};
+
+/**
+ * Reverse an array or string. Does not sort — items come out in reverse
+ * input order.
+ *
+ * @example
+ * {{ [1, 2, 3]|reverse|join(",") }}
+ * // => 3,2,1
+ *
+ * @param  {array|string} input
+ * @return {array|string}
+ */
+exports.reverse = function (input) {
+  if (utils.isArray(input)) {
+    return utils.extend([], input).reverse();
+  }
+  if (typeof input === 'string') {
+    return input.split('').reverse().join('');
+  }
+  return input;
+};
+
+/**
+ * Sort an array ascending, returning a copy (does not mutate the input).
+ * Numbers sort numerically; everything else compares case-insensitively.
+ * A string sorts its characters; an object sorts its keys. Pass a truthy
+ * first argument to sort descending.
+ *
+ * @example
+ * {{ [3, 1, 2]|sort|join(",") }}
+ * // => 1,2,3
+ *
+ * @example
+ * {{ [3, 1, 2]|sort(true)|join(",") }}
+ * // => 3,2,1
+ *
+ * @param  {*}       input
+ * @param  {boolean} [reverse=false]  Sort descending when truthy.
+ * @return {*}
+ */
+exports.sort = function (input, reverse) {
+  var arr, isString = false;
+  if (utils.isArray(input)) {
+    arr = utils.extend([], input);
+  } else if (typeof input === 'string') {
+    arr = input.split('');
+    isString = true;
+  } else if (input && typeof input === 'object') {
+    arr = utils.keys(input);
+  } else {
+    return input;
+  }
+  arr.sort(function (a, b) {
+    if (typeof a === 'number' && typeof b === 'number') { return a - b; }
+    var sa = String(a).toLowerCase(), sb = String(b).toLowerCase();
+    return sa < sb ? -1 : sa > sb ? 1 : 0;
+  });
+  if (reverse) { arr.reverse(); }
+  return isString ? arr.join('') : arr;
+};
+
+/*!
+ * Resolve a possibly-dotted attribute path against an object. Returns
+ * undefined if any segment is missing. @private
+ */
+function resolveAttr(obj, path) {
+  var segs = String(path).split('.'), cur = obj, i;
+  for (i = 0; i < segs.length; i += 1) {
+    if (cur === null || cur === undefined) { return undefined; }
+    cur = cur[segs[i]];
+  }
+  return cur;
+}
+
+/**
+ * Return the input, or a default value when the input is undefined, null,
+ * or the empty string. (A missing variable arrives here as "" because the
+ * engine coerces undefined variable lookups, so the empty string counts as
+ * "needs a default".) Real falsy values 0 and false are preserved. Pass a
+ * truthy second-after argument to fall back on any falsy value instead.
+ * `d` is an alias.
+ *
+ * @example
+ * {{ missing|default("anonymous") }}
+ * // => anonymous
+ *
+ * @example
+ * {{ 0|default("n/a", true) }}
+ * // => n/a
+ *
+ * @param  {*}       input
+ * @param  {*}       [def='']
+ * @param  {boolean} [bool=false]  Fall back on any falsy value when truthy.
+ * @return {*}
+ */
+exports['default'] = function (input, def, bool) {
+  if (def === undefined) { def = ''; }
+  if (bool) {
+    return input ? input : def;
+  }
+  return (input === undefined || input === null || input === '') ? def : input;
+};
+exports.d = exports['default'];
+
+/**
+ * Absolute value of a number.
+ *
+ * @example
+ * {{ -42|abs }}
+ * // => 42
+ *
+ * @param  {number} input
+ * @return {number}
+ */
+exports.abs = function (input) {
+  var n = Number(input);
+  return isNaN(n) ? input : Math.abs(n);
+};
+
+/**
+ * Round a number to a given precision. Method is `"common"` (round half
+ * away from zero, the default), `"ceil"`, or `"floor"`.
+ *
+ * @example
+ * {{ 42.55|round(1) }}
+ * // => 42.6
+ *
+ * @example
+ * {{ 42.55|round(1, "floor") }}
+ * // => 42.5
+ *
+ * @param  {number} input
+ * @param  {number} [precision=0]
+ * @param  {string} [method='common']
+ * @return {number}
+ */
+exports.round = function (input, precision, method) {
+  var n = Number(input);
+  if (isNaN(n)) { return input; }
+  var factor = Math.pow(10, precision || 0);
+  n = n * factor;
+  if (method === 'ceil') {
+    n = Math.ceil(n);
+  } else if (method === 'floor') {
+    n = Math.floor(n);
+  } else {
+    n = (n < 0) ? -Math.round(-n) : Math.round(n);
+  }
+  return n / factor;
+};
+
+/**
+ * Convert the input to an integer, returning a default (0) when the
+ * conversion fails. A non-decimal base may be given as the third argument.
+ *
+ * @example
+ * {{ "42.7"|int }}
+ * // => 42
+ *
+ * @param  {*}      input
+ * @param  {number} [def=0]
+ * @param  {number} [base=10]
+ * @return {number}
+ */
+exports.int = function (input, def, base) {
+  if (def === undefined) { def = 0; }
+  var n = parseInt(input, base || 10);
+  return isNaN(n) ? def : n;
+};
+
+/**
+ * Convert the input to a floating-point number, returning a default (0)
+ * when the conversion fails.
+ *
+ * @example
+ * {{ "42.5"|float }}
+ * // => 42.5
+ *
+ * @param  {*}      input
+ * @param  {number} [def=0]
+ * @return {number}
+ */
+exports.float = function (input, def) {
+  if (def === undefined) { def = 0; }
+  var n = parseFloat(input);
+  return isNaN(n) ? def : n;
+};
+
+/**
+ * Truncate a string to a length, appending an ellipsis when cut. By
+ * default the cut falls back to the last word boundary; pass a truthy
+ * third argument to cut mid-word. Strings within `leeway` characters of
+ * the limit are left whole.
+ *
+ * @example
+ * {{ "foo bar baz qux"|truncate(9) }}
+ * // => foo...
+ *
+ * @param  {*}       input
+ * @param  {number}  [length=255]
+ * @param  {boolean} [killwords=false]
+ * @param  {string}  [end='...']
+ * @param  {number}  [leeway=5]
+ * @return {string}
+ */
+exports.truncate = function (input, length, killwords, end, leeway) {
+  input = String(input);
+  length = length || 255;
+  if (end === undefined) { end = '...'; }
+  if (leeway === undefined) { leeway = 5; }
+  if (input.length <= length + leeway) {
+    return input;
+  }
+  var truncated = input.substr(0, length - end.length);
+  if (!killwords) {
+    var lastSpace = truncated.lastIndexOf(' ');
+    if (lastSpace !== -1) {
+      truncated = truncated.substr(0, lastSpace);
+    }
+  }
+  return truncated + end;
+};
+
+/**
+ * Serialize the input to a JSON string, escaping the HTML-significant
+ * characters (`<`, `>`, `&`, `'`) so the result is safe to embed in a
+ * page. Marked `.safe`, so the autoescape tail does not double-escape it.
+ *
+ * @example
+ * {{ {"a": 1}|tojson }}
+ * // => {"a":1}
+ *
+ * @param  {*}      input
+ * @param  {number} [indent]  Spaces of indentation for pretty output.
+ * @return {string}
+ */
+exports.tojson = function (input, indent) {
+  var json = JSON.stringify(input, null, indent || undefined);
+  if (json === undefined) {
+    return '';
+  }
+  return json
+    .replace(/</g, '\\u003c')
+    .replace(/>/g, '\\u003e')
+    .replace(/&/g, '\\u0026')
+    .replace(/'/g, '\\u0027');
+};
+exports.tojson.safe = true;
+
+/**
+ * Group a sequence of objects by a (possibly dotted) attribute, returning
+ * a list of `{ grouper, list }` records sorted by grouper.
+ *
+ * @example
+ * {% for g in users|groupby("dept") %}{{ g.grouper }}:{{ g.list|length }} {% endfor %}
+ *
+ * @param  {Array}  input
+ * @param  {string} attribute
+ * @return {Array}  List of `{ grouper, list }`.
+ */
+exports.groupby = function (input, attribute) {
+  if (!utils.isArray(input)) {
+    return input;
+  }
+  var groups = {}, order = [];
+  utils.each(input, function (item) {
+    var key = resolveAttr(item, attribute);
+    if (!groups.hasOwnProperty(key)) {
+      groups[key] = [];
+      order.push(key);
+    }
+    groups[key].push(item);
+  });
+  order.sort();
+  return utils.map(order, function (key) {
+    return { grouper: key, list: groups[key] };
+  });
+};
+
+/**
+ * Title-case the input: every word starts with an uppercase letter and the
+ * rest are lowercased. Word boundaries are whitespace and any of
+ * `- ( [ { <` (matching Jinja2's `title`), so `foo-bar` becomes `Foo-Bar`
+ * but an apostrophe does not split a word (`don't` => `Don't`). Recurses
+ * into arrays / objects.
+ *
+ * @example
+ * {{ "hello world"|title }}
+ * // => Hello World
+ *
+ * @param  {*} input
+ * @return {*}
+ */
+exports.title = function (input) {
+  var out = iterateFilter.apply(exports.title, arguments),
+    parts,
+    res,
+    item,
+    i;
+  if (out !== undefined) {
+    return out;
+  }
+  parts = String(input).split(/([-\s(\[{<]+)/);
+  res = '';
+  for (i = 0; i < parts.length; i += 1) {
+    item = parts[i];
+    if (!item) {
+      continue;
+    }
+    res += item.charAt(0).toUpperCase() + item.substr(1).toLowerCase();
+  }
+  return res;
+};
+
+/**
+ * Capitalize the input: uppercase the first character, lowercase the rest.
+ * Recurses into arrays / objects.
+ *
+ * @example
+ * {{ "hello WORLD"|capitalize }}
+ * // => Hello world
+ *
+ * @param  {*} input
+ * @return {*}
+ */
+exports.capitalize = function (input) {
+  var out = iterateFilter.apply(exports.capitalize, arguments);
+  if (out !== undefined) {
+    return out;
+  }
+  input = input.toString();
+  return input.charAt(0).toUpperCase() + input.substr(1).toLowerCase();
+};
+
+/**
+ * Strip SGML/XML tags (and HTML comments) from the input, then collapse
+ * runs of whitespace to a single space and trim the ends — matching
+ * Jinja2's `striptags`. Recurses into arrays / objects.
+ *
+ * @example
+ * {{ "<p>hello   world</p>"|striptags }}
+ * // => hello world
+ *
+ * @param  {*} input
+ * @return {*}
+ */
+exports.striptags = function (input) {
+  var out = iterateFilter.apply(exports.striptags, arguments);
+  if (out !== undefined) {
+    return out;
+  }
+  return String(input)
+    .replace(/<!--[\s\S]*?-->/g, '')
+    .replace(/<[^>]*>/g, '')
+    .replace(/\s+/g, ' ')
+    .replace(/^\s+|\s+$/g, '');
+};
+
+/**
+ * Strip leading and trailing characters from a string. With no argument
+ * the stripped set is whitespace; pass a string of characters to strip
+ * those instead (Jinja2's `trim`). Both ends are always stripped.
+ *
+ * @example
+ * {{ "  hello  "|trim }}
+ * // => hello
+ *
+ * @example
+ * {{ "xxhixx"|trim("x") }}
+ * // => hi
+ *
+ * @param  {*}      input
+ * @param  {string} [chars]  Characters to strip; defaults to whitespace.
+ * @return {*}
+ */
+exports.trim = function (input, chars) {
+  var pattern;
+  if (typeof input !== 'string') {
+    return input;
+  }
+  if (chars === undefined || chars === null || chars === '') {
+    pattern = '\\s';
+  } else {
+    pattern = '[' + String(chars).replace(/[\\\[\]\^\-]/g, '\\$&') + ']';
+  }
+  return input
+    .replace(new RegExp('^' + pattern + '+'), '')
+    .replace(new RegExp(pattern + '+$'), '');
+};
+
+/**
+ * Replace occurrences of a literal substring with another. Unlike the
+ * native swig `replace` (regex) and the Twig `replace` (mapping), Jinja2's
+ * `replace` is a plain left-to-right literal substitution. An optional
+ * count limits how many occurrences are replaced.
+ *
+ * @example
+ * {{ "Hello World"|replace("Hello", "Goodbye") }}
+ * // => Goodbye World
+ *
+ * @example
+ * {{ "aaa"|replace("a", "b", 2) }}
+ * // => bba
+ *
+ * @param  {*}      input
+ * @param  {string} old        The substring to find.
+ * @param  {string} [neu='']   The replacement.
+ * @param  {number} [count]    Cap on the number of replacements.
+ * @return {*}
+ */
+exports.replace = function (input, old, neu, count) {
+  var limited, max, out, i, n;
+  if (typeof input !== 'string') {
+    return input;
+  }
+  old = String(old);
+  neu = (neu === undefined || neu === null) ? '' : String(neu);
+  if (old === '') {
+    return input;
+  }
+  limited = (count !== undefined && count !== null);
+  max = limited ? Number(count) : Infinity;
+  out = '';
+  i = 0;
+  n = 0;
+  while (i < input.length) {
+    if (n < max && input.substr(i, old.length) === old) {
+      out += neu;
+      i += old.length;
+      n += 1;
+    } else {
+      out += input.charAt(i);
+      i += 1;
+    }
+  }
+  return out;
+};
+
+/*!
+ * printf-style format expansion backing the `format` filter. Supports the
+ * common conversions (s d i u f F e E g G x X o c %) with optional flags
+ * (`-` `+` space `0`), width, and `.precision`. @private
+ */
+function sprintf(fmt, args) {
+  var idx = 0;
+  return fmt.replace(/%([-+ 0]*)(\d+)?(?:\.(\d+))?([sdiufFeEgGxXoc%])/g, function (m, flags, width, prec, conv) {
+    var arg, hasPrec, sign, s, num, pad;
+
+    function withSign(value) {
+      if (value < 0) { sign = '-'; return -value; }
+      if (flags.indexOf('+') !== -1) { sign = '+'; } else if (flags.indexOf(' ') !== -1) { sign = ' '; }
+      return value;
+    }
+
+    if (conv === '%') {
+      return '%';
+    }
+    arg = args[idx];
+    idx += 1;
+    flags = flags || '';
+    hasPrec = (prec !== undefined && prec !== '');
+    width = width ? parseInt(width, 10) : 0;
+    prec = hasPrec ? parseInt(prec, 10) : undefined;
+    sign = '';
+
+    switch (conv) {
+    case 's':
+      s = String(arg);
+      if (hasPrec) { s = s.substring(0, prec); }
+      break;
+    case 'd':
+    case 'i':
+    case 'u':
+      num = parseInt(arg, 10);
+      if (isNaN(num)) { num = 0; }
+      s = String(withSign(num));
+      break;
+    case 'f':
+    case 'F':
+      num = parseFloat(arg);
+      if (isNaN(num)) { num = 0; }
+      s = withSign(num).toFixed(hasPrec ? prec : 6);
+      break;
+    case 'e':
+    case 'E':
+      num = parseFloat(arg);
+      if (isNaN(num)) { num = 0; }
+      s = withSign(num).toExponential(hasPrec ? prec : 6);
+      if (conv === 'E') { s = s.toUpperCase(); }
+      break;
+    case 'g':
+    case 'G':
+      num = parseFloat(arg);
+      if (isNaN(num)) { num = 0; }
+      s = String(withSign(num));
+      if (conv === 'G') { s = s.toUpperCase(); }
+      break;
+    case 'x':
+      s = (parseInt(arg, 10) >>> 0).toString(16);
+      break;
+    case 'X':
+      s = (parseInt(arg, 10) >>> 0).toString(16).toUpperCase();
+      break;
+    case 'o':
+      s = (parseInt(arg, 10) >>> 0).toString(8);
+      break;
+    case 'c':
+      s = String.fromCharCode(parseInt(arg, 10));
+      break;
+    default:
+      return m;
+    }
+
+    pad = width - (sign.length + s.length);
+    if (pad > 0) {
+      if (flags.indexOf('-') !== -1) {
+        s = sign + s + new Array(pad + 1).join(' ');
+      } else if (flags.indexOf('0') !== -1 && conv !== 's') {
+        s = sign + new Array(pad + 1).join('0') + s;
+      } else {
+        s = new Array(pad + 1).join(' ') + sign + s;
+      }
+    } else {
+      s = sign + s;
+    }
+    return s;
+  });
+}
+
+/**
+ * printf-style string formatting (Jinja2's `format`). The `%` placeholders
+ * in the format string are filled from the filter arguments in order.
+ * Supports conversions `s d i u f F e E g G x X o c` and `%%`, with
+ * optional flags (`-` `+` space `0`), a width, and a `.precision`. Use
+ * `%%` for a literal percent sign.
+ *
+ * @example
+ * {{ "%s is %d"|format("age", 42) }}
+ * // => age is 42
+ *
+ * @example
+ * {{ "%.2f"|format(3.14159) }}
+ * // => 3.14
+ *
+ * @param  {string} input  The format string.
+ * @return {*}
+ */
+exports.format = function (input) {
+  if (typeof input !== 'string') {
+    return input;
+  }
+  return sprintf(input, Array.prototype.slice.call(arguments, 1));
+};
+
+/**
+ * Count the words in a string. Words are runs of word characters
+ * (`[A-Za-z0-9_]`), matching Jinja2's `wordcount`.
+ *
+ * @example
+ * {{ "one, two; three!"|wordcount }}
+ * // => 3
+ *
+ * @param  {*} input
+ * @return {number}
+ */
+exports.wordcount = function (input) {
+  var m = String(input).match(/\w+/g);
+  return m ? m.length : 0;
+};
+
+/**
+ * Word-wrap a string to a given line width (Jinja2's `wordwrap`). Words are
+ * packed greedily; a word longer than the width is split when
+ * `breakLongWords` is truthy (the default). Lines are joined with
+ * `wrapstring` (default newline).
+ *
+ * @example
+ * {{ "the quick brown fox"|wordwrap(10) }}
+ * // => the quick\nbrown fox
+ *
+ * @param  {*}       input
+ * @param  {number}  [width=79]
+ * @param  {boolean} [breakLongWords=true]
+ * @param  {string}  [wrapstring='\n']
+ * @return {*}
+ */
+exports.wordwrap = function (input, width, breakLongWords, wrapstring) {
+  var words, lines, cur, i, word, space, head;
+  if (typeof input !== 'string') {
+    return input;
+  }
+  if (width === undefined || width === null) { width = 79; }
+  if (breakLongWords === undefined) { breakLongWords = true; }
+  if (wrapstring === undefined || wrapstring === null) { wrapstring = '\n'; }
+  words = input.split(/\s+/);
+  lines = [];
+  cur = '';
+  for (i = 0; i < words.length; i += 1) {
+    word = words[i];
+    if (word === '') { continue; }
+    while (breakLongWords && word.length > width) {
+      space = (cur === '') ? width : width - cur.length - 1;
+      if (space <= 0) {
+        lines.push(cur);
+        cur = '';
+        space = width;
+      }
+      head = word.substr(0, space);
+      cur = (cur === '') ? head : cur + ' ' + head;
+      lines.push(cur);
+      cur = '';
+      word = word.substr(space);
+    }
+    if (word === '') { continue; }
+    if (cur === '') {
+      cur = word;
+    } else if (cur.length + 1 + word.length <= width) {
+      cur += ' ' + word;
+    } else {
+      lines.push(cur);
+      cur = word;
+    }
+  }
+  if (cur !== '') { lines.push(cur); }
+  return lines.join(wrapstring);
+};
+
+/**
+ * Indent every line of a string by `width` spaces (or a literal string).
+ * The first line and blank lines are not indented by default — pass a
+ * truthy `first` to indent the first line and a truthy `blank` to indent
+ * blank lines (Jinja2's `indent`).
+ *
+ * @example
+ * {{ "line1\nline2"|indent(4) }}
+ * // => line1\n    line2
+ *
+ * @param  {*}             input
+ * @param  {number|string} [width=4]
+ * @param  {boolean}       [first=false]
+ * @param  {boolean}       [blank=false]
+ * @return {*}
+ */
+exports.indent = function (input, width, first, blank) {
+  var indent, lines, rv, head;
+  if (width === undefined || width === null) { width = 4; }
+  indent = (typeof width === 'number') ? new Array(width + 1).join(' ') : String(width);
+  lines = (String(input) + '\n').split('\n');
+  if (lines.length && lines[lines.length - 1] === '') {
+    lines.pop();
+  }
+  if (blank) {
+    rv = lines.join('\n' + indent);
+  } else {
+    head = lines.shift();
+    rv = (head === undefined) ? '' : head;
+    if (lines.length) {
+      rv += '\n' + utils.map(lines, function (line) {
+        return line ? indent + line : line;
+      }).join('\n');
+    }
+  }
+  if (first) {
+    rv = indent + rv;
+  }
+  return rv;
+};
+
+/**
+ * Center a string in a field of the given width using spaces (Jinja2's
+ * `center`, which defers to Python `str.center`). When an odd number of
+ * pad characters is needed the extra space goes on the right.
+ *
+ * @example
+ * {{ "foo"|center(9) }}
+ * // => "   foo   "
+ *
+ * @param  {*}      input
+ * @param  {number} [width=80]
+ * @return {*}
+ */
+exports.center = function (input, width) {
+  var marg, left, right;
+  input = String(input);
+  if (width === undefined || width === null) { width = 80; }
+  marg = width - input.length;
+  if (marg <= 0) {
+    return input;
+  }
+  left = Math.floor(marg / 2) + (marg & width & 1);
+  right = marg - left;
+  return new Array(left + 1).join(' ') + input + new Array(right + 1).join(' ');
+};
+
+/**
+ * Convert the input into a list (Jinja2's `list`). A string becomes a list
+ * of its characters, an array is copied, and a mapping yields its keys. A
+ * scalar is wrapped in a single-element list (Jinja2 would raise; this
+ * degrades gracefully); null / undefined yields an empty list.
+ *
+ * @example
+ * {{ "abc"|list|join("-") }}
+ * // => a-b-c
+ *
+ * @param  {*} input
+ * @return {Array}
+ */
+exports.list = function (input) {
+  if (typeof input === 'string') {
+    return input.split('');
+  }
+  if (utils.isArray(input)) {
+    return utils.extend([], input);
+  }
+  if (input && typeof input === 'object') {
+    return utils.keys(input);
+  }
+  return (input === null || input === undefined) ? [] : [input];
+};
+
+/**
+ * Return the unique items of a sequence, preserving first-seen order
+ * (Jinja2's `unique`). String comparison is case-insensitive by default;
+ * pass a truthy `caseSensitive` to compare exactly.
+ *
+ * @example
+ * {{ [1, 2, 2, 3, 1]|unique|join(",") }}
+ * // => 1,2,3
+ *
+ * @param  {*}       input
+ * @param  {boolean} [caseSensitive=false]
+ * @return {*}
+ */
+exports.unique = function (input, caseSensitive) {
+  var seen = [], out = [];
+  if (typeof input === 'string') {
+    input = input.split('');
+  } else if (!utils.isArray(input)) {
+    return input;
+  }
+  utils.each(input, function (item) {
+    var key = (!caseSensitive && typeof item === 'string') ? item.toLowerCase() : item;
+    if (seen.indexOf(key) === -1) {
+      seen.push(key);
+      out.push(item);
+    }
+  });
+  return out;
+};
+
+/**
+ * Batch items into rows of `size` (Jinja2's `batch`). The last row holds
+ * the remainder; an optional `fill` pads the last row up to `size`. A
+ * mapping batches its values.
+ *
+ * @example
+ * {% for row in [1,2,3,4,5]|batch(2) %}[{{ row|join(",") }}]{% endfor %}
+ * // => [1,2][3,4][5]
+ *
+ * @param  {*}      input
+ * @param  {number} size
+ * @param  {*}      [fill]  Pad the last row up to `size` with this value.
+ * @return {Array}
+ */
+exports.batch = function (input, size, fill) {
+  var items, n, out, i, last;
+  if (utils.isArray(input)) {
+    items = input;
+  } else if (input && typeof input === 'object') {
+    items = [];
+    utils.each(input, function (v) { items.push(v); });
+  } else {
+    return [];
+  }
+  n = Number(size);
+  if (!isFinite(n) || n <= 0) {
+    return [];
+  }
+  n = Math.ceil(n);
+  out = [];
+  i = 0;
+  while (i < items.length) {
+    out.push(items.slice(i, i + n));
+    i += n;
+  }
+  if (fill !== undefined && out.length > 0) {
+    last = out[out.length - 1];
+    while (last.length < n) {
+      last.push(fill);
+    }
+  }
+  return out;
+};
+
+/**
+ * Distribute items across `slices` columns (Jinja2's `slice` filter — the
+ * inverse of `batch`, and distinct from the `seq[start:stop:step]`
+ * subscript). The first columns receive the extra items when the count
+ * does not divide evenly; an optional `fill` pads the shorter columns.
+ *
+ * @example
+ * {% for col in [1,2,3,4,5,6,7,8,9,10]|slice(3) %}[{{ col|join(",") }}]{% endfor %}
+ * // => [1,2,3,4][5,6,7][8,9,10]
+ *
+ * @param  {*}      input
+ * @param  {number} slices  Number of columns.
+ * @param  {*}      [fill]  Pad the shorter columns with this value.
+ * @return {Array}
+ */
+exports.slice = function (input, slices, fill) {
+  var seq, length, perSlice, withExtra, out, offset, n, start, end, tmp, i;
+  if (utils.isArray(input)) {
+    seq = input;
+  } else if (typeof input === 'string') {
+    seq = input.split('');
+  } else if (input && typeof input === 'object') {
+    seq = [];
+    utils.each(input, function (v) { seq.push(v); });
+  } else {
+    return [];
+  }
+  n = Number(slices);
+  if (!isFinite(n) || n <= 0) {
+    return [];
+  }
+  n = Math.ceil(n);
+  length = seq.length;
+  perSlice = Math.floor(length / n);
+  withExtra = length % n;
+  out = [];
+  offset = 0;
+  for (i = 0; i < n; i += 1) {
+    start = offset + i * perSlice;
+    if (i < withExtra) {
+      offset += 1;
+    }
+    end = offset + (i + 1) * perSlice;
+    tmp = seq.slice(start, end);
+    if (fill !== undefined && i >= withExtra) {
+      tmp.push(fill);
+    }
+    out.push(tmp);
+  }
+  return out;
+};
+
+/**
+ * Sort a mapping and return a list of `[key, value]` pairs (Jinja2's
+ * `dictsort`). Sorts by key by default; pass `by='value'` to sort by value.
+ * String comparison is case-insensitive unless `caseSensitive` is truthy,
+ * and `reverse` flips the order.
+ *
+ * @example
+ * {% for k, v in {"b":2,"a":1}|dictsort %}{{ k }}={{ v }};{% endfor %}
+ * // => a=1;b=2;
+ *
+ * @param  {object}  input
+ * @param  {boolean} [caseSensitive=false]
+ * @param  {string}  [by='key']  `'key'` or `'value'`.
+ * @param  {boolean} [reverse=false]
+ * @return {Array}   List of `[key, value]` pairs.
+ */
+exports.dictsort = function (input, caseSensitive, by, reverse) {
+  var pairs, idx;
+  if (!input || typeof input !== 'object' || utils.isArray(input)) {
+    return input;
+  }
+  idx = (by === 'value') ? 1 : 0;
+  pairs = utils.map(utils.keys(input), function (k) {
+    return [k, input[k]];
+  });
+  pairs.sort(function (a, b) {
+    var x = a[idx], y = b[idx];
+    if (!caseSensitive && typeof x === 'string') { x = x.toLowerCase(); }
+    if (!caseSensitive && typeof y === 'string') { y = y.toLowerCase(); }
+    if (typeof x === 'number' && typeof y === 'number') {
+      return x - y;
+    }
+    x = String(x);
+    y = String(y);
+    return (x < y) ? -1 : (x > y) ? 1 : 0;
+  });
+  if (reverse) {
+    pairs.reverse();
+  }
+  return pairs;
+};
+
+/**
+ * Sum the items of a sequence (Jinja2's `sum`). An optional `attribute`
+ * (dotted path) sums that attribute of each item; an optional `start` is
+ * added to the total. To pass a start without an attribute, use an empty
+ * attribute string: `sum("", 10)`. (Keyword-calling — `sum(start=10)` — is
+ * not supported, matching the family-wide keyword-argument non-goal.)
+ *
+ * @example
+ * {{ [1, 2, 3]|sum }}
+ * // => 6
+ *
+ * @example
+ * {{ items|sum("price") }}
+ * // sums each item's price
+ *
+ * @param  {*}      input
+ * @param  {string} [attribute]  Dotted path to sum on each item.
+ * @param  {number} [start=0]
+ * @return {number}
+ */
+exports.sum = function (input, attribute, start) {
+  var total, vals;
+  total = (start === undefined || start === null) ? 0 : Number(start);
+  if (isNaN(total)) { total = 0; }
+  if (!utils.isArray(input)) {
+    if (input && typeof input === 'object') {
+      vals = [];
+      utils.each(input, function (v) { vals.push(v); });
+      input = vals;
+    } else {
+      return total;
+    }
+  }
+  utils.each(input, function (item) {
+    var v = (attribute === undefined || attribute === null || attribute === '') ? item : resolveAttr(item, attribute),
+      n = Number(v);
+    total += isNaN(n) ? 0 : n;
+  });
+  return total;
+};
+
+/*!
+ * Shared comparison core for the `min` / `max` filters. String comparison
+ * is case-insensitive unless `caseSensitive` is truthy; numbers compare
+ * numerically. @private
+ */
+function minmax(input, caseSensitive, want) {
+  var best, found = false, vals;
+  if (typeof input === 'string') {
+    input = input.split('');
+  } else if (input && typeof input === 'object' && !utils.isArray(input)) {
+    vals = [];
+    utils.each(input, function (v) { vals.push(v); });
+    input = vals;
+  } else if (!utils.isArray(input)) {
+    return input;
+  }
+  utils.each(input, function (item) {
+    var a, b, cmp;
+    if (!found) { best = item; found = true; return; }
+    a = item;
+    b = best;
+    if (!caseSensitive) {
+      if (typeof a === 'string') { a = a.toLowerCase(); }
+      if (typeof b === 'string') { b = b.toLowerCase(); }
+    }
+    if (typeof a === 'number' && typeof b === 'number') {
+      cmp = a - b;
+    } else {
+      a = String(a);
+      b = String(b);
+      cmp = (a < b) ? -1 : (a > b) ? 1 : 0;
+    }
+    if (want === 'min' ? cmp < 0 : cmp > 0) { best = item; }
+  });
+  return found ? best : undefined;
+}
+
+/**
+ * Return the smallest item of a sequence (Jinja2's `min`). String
+ * comparison is case-insensitive unless `caseSensitive` is truthy.
+ *
+ * @example
+ * {{ [3, 1, 2]|min }}
+ * // => 1
+ *
+ * @param  {*}       input
+ * @param  {boolean} [caseSensitive=false]
+ * @return {*}
+ */
+exports.min = function (input, caseSensitive) {
+  return minmax(input, caseSensitive, 'min');
+};
+
+/**
+ * Return the largest item of a sequence (Jinja2's `max`). String
+ * comparison is case-insensitive unless `caseSensitive` is truthy.
+ *
+ * @example
+ * {{ [3, 1, 2]|max }}
+ * // => 3
+ *
+ * @param  {*}       input
+ * @param  {boolean} [caseSensitive=false]
+ * @return {*}
+ */
+exports.max = function (input, caseSensitive) {
+  return minmax(input, caseSensitive, 'max');
+};
+
+/*!
+ * Percent-encode a string for use in a URL. Outside query-string context
+ * `/` is preserved; in query-string context (`forQs`) every reserved
+ * character is encoded and spaces become `+`. @private
+ */
+function urlQuote(s, forQs) {
+  var out = encodeURIComponent(String(s)).replace(/[!*'()]/g, function (c) {
+    return '%' + c.charCodeAt(0).toString(16).toUpperCase();
+  });
+  if (!forQs) {
+    out = out.replace(/%2F/g, '/');
+  } else {
+    out = out.replace(/%20/g, '+');
+  }
+  return out;
+}
+
+/**
+ * URL-encode the input (Jinja2's `urlencode`). A string is percent-encoded
+ * for a URL path, preserving the `/` separator. A mapping or a list of
+ * `[key, value]` pairs is encoded as a query string, with spaces becoming
+ * `+`. Not marked safe — under autoescape the `&` separators are escaped
+ * on output, matching Jinja2.
+ *
+ * @example
+ * {{ "a b/c"|urlencode }}
+ * // => a%20b/c
+ *
+ * @example
+ * {{ {"q": "a b"}|urlencode }}
+ * // => q=a+b
+ *
+ * @param  {*} input
+ * @return {string}
+ */
+exports.urlencode = function (input) {
+  if (typeof input === 'string') {
+    return urlQuote(input, false);
+  }
+  if (utils.isArray(input)) {
+    return utils.map(input, function (pair) {
+      return urlQuote(pair[0], true) + '=' + urlQuote(pair[1], true);
+    }).join('&');
+  }
+  if (input && typeof input === 'object') {
+    return utils.map(utils.keys(input), function (k) {
+      return urlQuote(k, true) + '=' + urlQuote(input[k], true);
+    }).join('&');
+  }
+  return urlQuote(input, false);
+};
+
+/**
+ * Return a random item from a sequence (Jinja2's `random`). A string is
+ * treated as a sequence of characters. Non-deterministic — uses
+ * `Math.random()`.
+ *
+ * @example
+ * {{ [1, 2, 3]|random }}
+ * // => one of 1, 2, 3
+ *
+ * @param  {*} input
+ * @return {*}
+ */
+exports.random = function (input) {
+  var seq = input;
+  if (typeof input === 'string') {
+    seq = input.split('');
+  } else if (!utils.isArray(input)) {
+    return input;
+  }
+  if (!seq.length) {
+    return undefined;
+  }
+  return seq[Math.floor(Math.random() * seq.length)];
+};
+
+/**
+ * Format a date with PHP-style `date()` tokens via the swig-core date
+ * formatter. Jinja2 core has no `date` filter; this is a swig-family
+ * extension shared with the native and Twig flavors. A backslash escapes a
+ * literal character; `offset` shifts the timezone (minutes from GMT) and
+ * `abbr` sets the output-only timezone abbreviation.
+ *
+ * @example
+ * {{ published|date("F jS, Y") }}
+ * // => September 23rd, 2011
+ *
+ * @param  {?(Date|string|number)} input
+ * @param  {string} format
+ * @param  {number} [offset]  Timezone offset in minutes from GMT.
+ * @param  {string} [abbr]    Output timezone abbreviation.
+ * @return {string}
+ */
+exports.date = function (input, format, offset, abbr) {
+  var l = format.length,
+    date = new dateFormatter.DateZ(input),
+    cur,
+    i = 0,
+    out = '';
+
+  if (offset) {
+    date.setTimezoneOffset(offset, abbr);
+  }
+
+  for (i; i < l; i += 1) {
+    cur = format.charAt(i);
+    if (cur === '\\') {
+      i += 1;
+      out += (i < l) ? format.charAt(i) : cur;
+    } else if (dateFormatter.hasOwnProperty(cur)) {
+      out += dateFormatter[cur](date, offset, abbr);
+    } else {
+      out += cur;
+    }
+  }
+  return out;
+};