@rhinostone/swig-django 2.7.0

package/lib/tags/autoescape.js

@@ -0,0 +1,76 @@
+/*!
+ * Django `{% autoescape %}` tag.
+ *
+ *   {% autoescape on %}{{ html }}{% endautoescape %}    (escape the region)
+ *   {% autoescape off %}{{ html }}{% endautoescape %}   (don't escape)
+ *
+ * Controls auto-escaping of variable output within its body. The escape
+ * decision is baked at parse time: the parser maintains an escape-value
+ * stack that this tag's open pushes onto and `{% endautoescape %}` pops, so
+ * each `{{ … }}` inside the region gets (or omits) the `e` filter tail
+ * accordingly. The emitted IRAutoescape node is therefore inert at the
+ * backend — it exists so the IR tree reflects the region.
+ *
+ * Only the literal keywords `on` and `off` are accepted (Django's spelling;
+ * the other flavors use `true` / `false`). `on` / `off` lex as VAR tokens,
+ * not BOOL. A runtime expression (`{% autoescape some_var %}`) is rejected
+ * at parse time — the parse-time escape model can only resolve a literal
+ * strategy.
+ */
+
+var ir = require('@rhinostone/swig-core/lib/ir');
+var utils = require('@rhinostone/swig-core/lib/utils');
+
+var lexer = require('../lexer');
+
+exports.ends = true;
+exports.block = false;
+
+/**
+ * Parse the `{% autoescape %}` tag body. Requires a single `on` / `off`
+ * VAR token and stashes the resolved boolean on `token.escapeValue` — the
+ * parser reads it to push onto the escape-value stack for the region, and
+ * compile reads it to build the IRAutoescape node.
+ *
+ * @param  {string} str    Tag body.
+ * @param  {number} line   Source line of the opening `{%`.
+ * @param  {object} parser The Django parser module (unused).
+ * @param  {object} types  Django lexer token-type enum.
+ * @param  {Array}  stack  Open-tag stack (parser.js manages the push).
+ * @param  {object} opts   Per-call options (honors `opts.filename`).
+ * @param  {object} swig   Swig instance (unused).
+ * @param  {object} token  In-progress TagToken. Gets `token.escapeValue`.
+ * @return {boolean}       Always `true` on success. Throws otherwise.
+ */
+exports.parse = function (str, line, parser, types, stack, opts, swig, token) {
+  var tokens = lexer.read(utils.strip(str));
+  var pos = 0;
+
+  while (pos < tokens.length && tokens[pos].type === types.WHITESPACE) { pos += 1; }
+  var tok = pos < tokens.length ? tokens[pos] : null;
+  if (!tok || tok.type !== types.VAR || (tok.match !== 'on' && tok.match !== 'off')) {
+    utils.throwError('Expected "on" or "off" in "autoescape" tag', line, opts.filename);
+  }
+  pos += 1;
+
+  while (pos < tokens.length && tokens[pos].type === types.WHITESPACE) { pos += 1; }
+  if (pos < tokens.length) {
+    utils.throwError('Unexpected token "' + tokens[pos].match + '" in "autoescape" tag', line, opts.filename);
+  }
+
+  token.escapeValue = (tok.match === 'on');
+  return true;
+};
+
+/**
+ * Emit an IRAutoescape node wrapping the recursively-compiled body. The
+ * body's `{{ … }}` outputs already carry (or omit) their `e` tails from
+ * parse time, so the backend emits the body verbatim; the strategy is
+ * carried for IR fidelity.
+ *
+ * @return {object} IRAutoescape node.
+ */
+exports.compile = function (compiler, args, content, parents, options, blockName, token) {
+  var bodyJS = compiler(content, parents, options, blockName);
+  return ir.autoescape(token.escapeValue, [ir.legacyJS(bodyJS)]);
+};

package/lib/tags/block.js

@@ -0,0 +1,92 @@
+/*!
+ * Django `{% block %}` tag.
+ *
+ * Named override point for template inheritance:
+ *
+ *   {% block <name> %}…{% endblock %}
+ *   {% block <name> %}…{% endblock <name> %}   (optional name on endblock)
+ *
+ * The block name is a bare identifier (dotted paths rejected) and passes
+ * the CVE-2023-25345 `_dangerousProps` guard. The parser captures the block
+ * in `template.blocks[name]` when it appears at the top level (the
+ * block-keying branch fires on `token.block && !stack.length`). The
+ * optional name after `{% endblock %}` is accepted for free: the parser's
+ * end-tag matcher keys on the first word (`endblock`) and ignores any
+ * trailing argument.
+ *
+ * Compile emits an `IRBlock` node with the body wrapped in IRLegacyJS. The
+ * backend's `Block` branch emits the body verbatim — block-override
+ * resolution happens at parse time via `engine.remapBlocks` /
+ * `importNonBlocks`, which substitutes the child's block content into the
+ * parent's token tree before backend emission.
+ *
+ * `{{ block.super }}` (Django's parent-block content access) is NOT yet
+ * supported — consistent with the Jinja2 sibling, which ships without
+ * `{{ super() }}`. The structural override (child block replaces parent
+ * block) works; rendering the parent's content inside the override is a
+ * deferred follow-up.
+ */
+
+var ir = require('@rhinostone/swig-core/lib/ir');
+var utils = require('@rhinostone/swig-core/lib/utils');
+var _dangerousProps = require('@rhinostone/swig-core/lib/security').dangerousProps;
+
+var lexer = require('../lexer');
+
+exports.ends = true;
+exports.block = true;
+
+/**
+ * Parse the `{% block %}` tag body. Extracts the bare-identifier name,
+ * validates it, and stashes it on `token.args` so the parser's top-level
+ * block-keying branch can pick it up via `token.args.join('')`.
+ *
+ * @param  {string} str    Tag body.
+ * @param  {number} line   Source line of the opening `{%`.
+ * @param  {object} parser The Django parser module (unused — names are
+ *                         plain identifiers).
+ * @param  {object} types  Django lexer token-type enum.
+ * @param  {Array}  stack  Open-tag stack (parser.js manages the push).
+ * @param  {object} opts   Per-call options (honors `opts.filename`).
+ * @param  {object} swig   Swig instance (unused).
+ * @param  {object} token  In-progress TagToken. `token.args` gets the
+ *                         block name as its single element.
+ * @return {boolean}       Always `true` on success. Throws otherwise.
+ */
+exports.parse = function (str, line, parser, types, stack, opts, swig, token) {
+  var tokens = lexer.read(utils.strip(str));
+  var pos = 0;
+
+  while (pos < tokens.length && tokens[pos].type === types.WHITESPACE) { pos += 1; }
+  var nameTok = pos < tokens.length ? tokens[pos] : null;
+  if (!nameTok || nameTok.type !== types.VAR) {
+    utils.throwError('Expected block name in "block" tag', line, opts.filename);
+  }
+  if (nameTok.match.indexOf('.') !== -1) {
+    utils.throwError('Block name "' + nameTok.match + '" must be a bare identifier', line, opts.filename);
+  }
+  if (_dangerousProps.indexOf(nameTok.match) !== -1) {
+    utils.throwError('Unsafe block name "' + nameTok.match + '" is not allowed (CVE-2023-25345)', line, opts.filename);
+  }
+
+  pos += 1;
+  while (pos < tokens.length && tokens[pos].type === types.WHITESPACE) { pos += 1; }
+  if (pos < tokens.length) {
+    utils.throwError('Unexpected token "' + tokens[pos].match + '" after block name', line, opts.filename);
+  }
+
+  token.args = [nameTok.match];
+  return true;
+};
+
+/**
+ * Emit an IRBlock node. Body is the recursively-compiled content wrapped in
+ * IRLegacyJS. Mirrors the native / Jinja2 `block` compile shape so the
+ * backend's `Block` branch treats every frontend the same.
+ *
+ * @return {object} IRBlock node.
+ */
+exports.compile = function (compiler, args, content, parents, options) {
+  var name = args.join('');
+  return ir.block(name, [ir.legacyJS(compiler(content, parents, options, name))]);
+};

package/lib/tags/comment.js

@@ -0,0 +1,42 @@
+/*!
+ * Django `{% comment %}…{% endcomment %}` tag.
+ *
+ *   {% comment %}…{% endcomment %}
+ *   {% comment "optional note" %}…{% endcomment %}
+ *
+ * Discards everything between the tags. The content is NOT parsed — like
+ * `{% verbatim %}`, the splitter flips its `inRaw` flag on the `comment` tag
+ * name (cleared on `{% endcomment %}`), so `{{ … }}` / `{% … %}` inside a
+ * comment are captured as raw text rather than parsed. That makes
+ * `{% comment %}{% some_broken_tag %}{% endcomment %}` safe — the body never
+ * reaches the parser. compile then throws the captured content away, so the
+ * comment renders nothing.
+ *
+ * An optional note after `comment` (Django allows `{% comment "why" %}`) is
+ * accepted and ignored.
+ */
+
+var ir = require('@rhinostone/swig-core/lib/ir');
+
+exports.ends = true;
+exports.block = false;
+
+/**
+ * Accept the comment tag. Any argument (the optional note) is ignored —
+ * Django places no constraint on it.
+ *
+ * @return {boolean} Always `true`.
+ */
+exports.parse = function () {
+  return true;
+};
+
+/**
+ * Emit nothing. The captured content (raw text, since the body was in the
+ * splitter's `inRaw` mode) is intentionally discarded.
+ *
+ * @return {object} An empty IRLegacyJS node.
+ */
+exports.compile = function () {
+  return ir.legacyJS('');
+};

package/lib/tags/cycle.js

@@ -0,0 +1,104 @@
+/*!
+ * Django `{% cycle %}` tag (anonymous form).
+ *
+ *   {% cycle "row1" "row2" %}      (alternates on each invocation)
+ *   {% cycle a b c %}              (values may be expressions)
+ *
+ * Cycles through its values, emitting the next one on each invocation — so
+ * inside a `{% for %}` loop it alternates per iteration. State is a
+ * per-occurrence counter stored on `_ctx` under a unique key (the same
+ * `Math.random()` scheme the for-loop uses for its loopcache), so it
+ * persists across loop iterations within a render and resets on the next
+ * render (fresh `_ctx`). Two distinct `{% cycle %}` tags never share state.
+ *
+ * Values are evaluated fresh on each invocation (Django re-evaluates), and
+ * the emitted value is autoescaped per the enclosing region (`token.escape`).
+ *
+ * The named / reusable forms — `{% cycle a b as name %}`, `{% cycle name %}`,
+ * and the `silent` modifier — are not yet supported (they need cross-tag
+ * cycle-name tracking) and are rejected with a clear message.
+ */
+
+var ir = require('@rhinostone/swig-core/lib/ir');
+var utils = require('@rhinostone/swig-core/lib/utils');
+var backend = require('@rhinostone/swig-core/lib/backend');
+
+var lexer = require('../lexer');
+
+exports.ends = false;
+exports.block = false;
+
+/*!
+ * True if a bare VAR token matching `word` appears anywhere in `tokens`.
+ * @private
+ */
+function hasKeyword(tokens, types, word) {
+  var i;
+  for (i = 0; i < tokens.length; i += 1) {
+    if (tokens[i].type === types.VAR && tokens[i].match === word) { return true; }
+  }
+  return false;
+}
+
+/**
+ * Parse the space-separated value list onto `token.irArgs` (an IRExpr[]).
+ *
+ * @param  {string} str    Tag body.
+ * @param  {number} line   Source line of the opening `{%`.
+ * @param  {object} parser The Django parser module (exposes `parseExpr`).
+ * @param  {object} types  Django lexer token-type enum.
+ * @param  {Array}  stack  Open-tag stack (unused — cycle has no body).
+ * @param  {object} opts   Per-call options (honors `opts.filename`).
+ * @param  {object} swig   Swig instance (unused).
+ * @param  {object} token  In-progress TagToken. Gets `token.irArgs`.
+ * @return {boolean}       Always `true` on success. Throws otherwise.
+ */
+exports.parse = function (str, line, parser, types, stack, opts, swig, token) {
+  var tokens = lexer.read(utils.strip(str));
+  if (!tokens.length) {
+    utils.throwError('Expected at least one value in "cycle" tag', line, opts.filename);
+  }
+  if (hasKeyword(tokens, types, 'as')) {
+    utils.throwError('Named cycles (the "as name" form of "cycle") are not yet supported', line, opts.filename);
+  }
+  if (hasKeyword(tokens, types, 'silent')) {
+    utils.throwError('The "silent" modifier on "cycle" is not yet supported', line, opts.filename);
+  }
+
+  var args = [];
+  var pos = 0;
+  while (true) {
+    while (pos < tokens.length && tokens[pos].type === types.WHITESPACE) { pos += 1; }
+    if (pos >= tokens.length) { break; }
+    var posOut = {};
+    var expr = parser.parseExpr(tokens.slice(pos), {}, posOut);
+    pos += posOut.pos;
+    args.push(expr);
+  }
+
+  token.irArgs = args;
+  return true;
+};
+
+/**
+ * Emit the stateful cycle: build the value array, advance a per-occurrence
+ * counter on `_ctx`, and append the current value (escaped per the region).
+ *
+ * @return {object} IRLegacyJS node.
+ */
+exports.compile = function (compiler, args, content, parents, options, blockName, token) {
+  var parts = [];
+  utils.each(token.irArgs, function (a) { parts.push(backend.emitExpr(a)); });
+
+  var key = ('__cycle' + Math.random()).replace(/\./g, '');
+  var value = '__cv[_ctx.' + key + ' % __cv.length]';
+  var emit = token.escape ? '_filters["e"](' + value + ')' : '_utils.coerceOutput(' + value + ')';
+
+  return ir.legacyJS(
+    '(function () {\n' +
+    '  var __cv = [' + parts.join(', ') + '];\n' +
+    '  _ctx.' + key + ' = (_ctx.' + key + ' === undefined) ? 0 : (_ctx.' + key + ' + 1);\n' +
+    '  _output += ' + emit + ';\n' +
+    '})();\n'
+  );
+};

package/lib/tags/elif.js

@@ -0,0 +1,33 @@
+/*!
+ * Django `{% elif %}` branch marker.
+ *
+ * Valid only inside an `{% if %}` body. Parses its test expression onto
+ * `token.irExpr`; the enclosing `if` tag's compile consumes the marker and
+ * splits its branches at it. The marker never reaches the backend on its
+ * own — `compile` only fires if an `elif` somehow escapes an `if`, which the
+ * parse-time stack check already prevents.
+ */
+
+var utils = require('@rhinostone/swig-core/lib/utils');
+
+var lexer = require('../lexer');
+
+exports.ends = false;
+exports.block = false;
+
+exports.parse = function (str, line, parser, types, stack, opts, swig, token) {
+  var top = stack[stack.length - 1];
+  if (!top || top.name !== 'if') {
+    utils.throwError('"elif" is only valid inside an "if" tag', line, opts.filename);
+  }
+  var tokens = lexer.read(utils.strip(str));
+  if (!tokens.length) {
+    utils.throwError('Expected conditional expression in "elif" tag', line, opts.filename);
+  }
+  token.irExpr = parser.parseExpr(tokens);
+  return true;
+};
+
+exports.compile = function () {
+  throw new Error('"elif" used outside an "if" tag.');
+};

package/lib/tags/else.js

@@ -0,0 +1,30 @@
+/*!
+ * Django `{% else %}` branch marker.
+ *
+ * Valid inside an `{% if %}` body (the final fallback branch). It carries no
+ * expression; the enclosing `if` tag's compile consumes the marker and
+ * splits its body at it. The marker never reaches the backend on its own —
+ * `compile` only fires if an `else` escapes its enclosing tag, which the
+ * parse-time stack check already prevents.
+ *
+ * Unlike the Jinja2 sibling, Django's `else` is NOT valid inside a `{% for %}`
+ * tag — Django's empty-iterable branch is the dedicated `{% empty %}` marker
+ * (added with the `for` tag in a later commit), not `{% else %}`.
+ */
+
+var utils = require('@rhinostone/swig-core/lib/utils');
+
+exports.ends = false;
+exports.block = false;
+
+exports.parse = function (str, line, parser, types, stack, opts, swig, token) {
+  var top = stack[stack.length - 1];
+  if (!top || top.name !== 'if') {
+    utils.throwError('"else" is only valid inside an "if" tag', line, opts.filename);
+  }
+  return true;
+};
+
+exports.compile = function () {
+  throw new Error('"else" used outside an "if" tag.');
+};

package/lib/tags/empty.js

@@ -0,0 +1,28 @@
+/*!
+ * Django `{% empty %}` branch marker.
+ *
+ * Valid only inside a `{% for %}` body — Django's empty-iterable fallback
+ * (the equivalent of Jinja2's `{% for … %}{% else %}`). It carries no
+ * expression; the enclosing `for` tag's compile consumes the marker and
+ * splits its body at it into the loop body and the empty body. The marker
+ * never reaches the backend on its own — `compile` only fires if an
+ * `empty` escapes its enclosing `for`, which the parse-time stack check
+ * already prevents.
+ */
+
+var utils = require('@rhinostone/swig-core/lib/utils');
+
+exports.ends = false;
+exports.block = false;
+
+exports.parse = function (str, line, parser, types, stack, opts, swig, token) {
+  var top = stack[stack.length - 1];
+  if (!top || top.name !== 'for') {
+    utils.throwError('"empty" is only valid inside a "for" tag', line, opts.filename);
+  }
+  return true;
+};
+
+exports.compile = function () {
+  throw new Error('"empty" used outside a "for" tag.');
+};

package/lib/tags/extends.js

@@ -0,0 +1,95 @@
+/*!
+ * Django `{% extends %}` tag.
+ *
+ * Declares a parent template for inheritance:
+ *
+ *   {% extends "base.html" %}      (static — compile-time)
+ *   {% extends parent_var %}       (dynamic — render-time, async path only)
+ *
+ * A static string-literal path is pushed as the single `token.args`
+ * element; the parser's splitter lifts it onto `template.parent`, and the
+ * engine's parent-chain resolution (`engine.getParents` + `remapBlocks` +
+ * `importNonBlocks`) walks the chain statically at compile time.
+ *
+ * A dynamic path is lowered through `parser.parseExpr` into an IRExpr and
+ * stashed on `token.irExpr.file`; the splitter lifts it onto the sibling
+ * `template.parentExpr` slot, which the async codegen path
+ * (`buildExtendsDeferred`) prefers over the string literal and resolves at
+ * render time via `_swig.getTemplate`. Dynamic extends therefore requires
+ * the async render path (`renderFile` with a callback against an async
+ * loader); on the synchronous render path a runtime-valued parent throws a
+ * clear "requires the async render path" error. Mirrors the cross-flavor
+ * dynamic-extends handling in native / Twig / Jinja2.
+ *
+ * Compile emits nothing — `extends` is a parse-time declaration carried via
+ * `template.parent` / `template.parentExpr` metadata; no runtime code is
+ * generated for the tag.
+ */
+
+var utils = require('@rhinostone/swig-core/lib/utils');
+
+var lexer = require('../lexer');
+
+exports.ends = false;
+exports.block = true;
+
+/**
+ * Parse the `{% extends %}` tag body.
+ *
+ * A single STRING literal is stashed (quotes stripped) as `token.args[0]`
+ * for the splitter to lift onto `template.parent`. Any other expression
+ * (VAR, member access, ...) is a dynamic path: it is lowered through
+ * `parser.parseExpr` into an IRExpr on `token.irExpr.file` (the splitter
+ * lifts it onto `template.parentExpr`) and the raw source text is kept on
+ * `token.args[0]` so the sync `template.parent` string stays truthy (the
+ * async dispatch guard keys on it).
+ *
+ * @param  {string} str    Tag body.
+ * @param  {number} line   Source line of the opening `{%`.
+ * @param  {object} parser The Django parser module (exposes `parseExpr`).
+ * @param  {object} types  Django lexer token-type enum.
+ * @param  {Array}  stack  Open-tag stack (unused — extends has no body).
+ * @param  {object} opts   Per-call options (honors `opts.filename`).
+ * @param  {object} swig   Swig instance (unused).
+ * @param  {object} token  In-progress TagToken. Gets `token.args` (raw or
+ *                         unquoted path) and, for a dynamic path,
+ *                         `token.irExpr.file` (the lowered IRExpr).
+ * @return {boolean}       Always `true` on success. Throws otherwise.
+ */
+exports.parse = function (str, line, parser, types, stack, opts, swig, token) {
+  var tokens = lexer.read(utils.strip(str));
+  var pos = 0;
+
+  while (pos < tokens.length && tokens[pos].type === types.WHITESPACE) { pos += 1; }
+  var pathTok = pos < tokens.length ? tokens[pos] : null;
+  if (!pathTok) {
+    utils.throwError('Expected parent template path in "extends" tag', line, opts.filename);
+  }
+
+  if (pathTok.type === types.STRING) {
+    pos += 1;
+    while (pos < tokens.length && tokens[pos].type === types.WHITESPACE) { pos += 1; }
+    if (pos < tokens.length) {
+      utils.throwError('Unexpected token "' + tokens[pos].match + '" after parent path in "extends" tag', line, opts.filename);
+    }
+    token.args = [pathTok.match.replace(/^['"]|['"]$/g, '')];
+    return true;
+  }
+
+  // Dynamic path: lower to an IRExpr so it resolves at render time on the
+  // async codegen path. The raw source is kept on token.args[0] so the sync
+  // template.parent string stays truthy (the async dispatch guard keys on
+  // it); buildExtendsDeferred prefers template.parentExpr.
+  token.irExpr = { file: parser.parseExpr(tokens) };
+  token.args = [utils.strip(str)];
+  return true;
+};
+
+/**
+ * No-op compile. Extends is a parse-time declaration — the parent path
+ * lives on `template.parent`, which the engine's `getParents` reads during
+ * compile. The `{% extends %}` tag itself emits no runtime code.
+ *
+ * @return {undefined}
+ */
+exports.compile = function () {};

package/lib/tags/firstof.js

@@ -0,0 +1,101 @@
+/*!
+ * Django `{% firstof %}` tag.
+ *
+ *   {% firstof a b c %}            (output the first "truthy" value)
+ *   {% firstof a b "fallback" %}   (a trailing literal is just another value)
+ *
+ * Outputs the first argument that evaluates truthy, or the empty string if
+ * none do. Each argument is lowered through `parser.parseExpr`, so variables,
+ * literals, and member access all work. A missing variable resolves to `""`
+ * (via emitVarRef) and so counts as falsy — exactly like Django.
+ *
+ * The output is autoescaped according to the enclosing region's autoescape
+ * state (the same `e`-filter tail a `{{ … }}` would get), read from
+ * `token.escape`. There is no user filter chain on a firstof value.
+ *
+ * The `{% firstof a b as var %}` assign-to-variable form (Django 1.9+) is not
+ * yet supported and is rejected with a clear message.
+ */
+
+var ir = require('@rhinostone/swig-core/lib/ir');
+var utils = require('@rhinostone/swig-core/lib/utils');
+
+var lexer = require('../lexer');
+
+exports.ends = false;
+exports.block = false;
+
+/*!
+ * True if a bare VAR token matching `word` appears anywhere in `tokens`.
+ * firstof / cycle arguments are simple values, so no paren-depth tracking is
+ * needed to spot a trailing keyword. @private
+ */
+function hasKeyword(tokens, types, word) {
+  var i;
+  for (i = 0; i < tokens.length; i += 1) {
+    if (tokens[i].type === types.VAR && tokens[i].match === word) { return true; }
+  }
+  return false;
+}
+
+/**
+ * Parse the space-separated value list onto `token.irArgs` (an IRExpr[]).
+ *
+ * @param  {string} str    Tag body.
+ * @param  {number} line   Source line of the opening `{%`.
+ * @param  {object} parser The Django parser module (exposes `parseExpr`).
+ * @param  {object} types  Django lexer token-type enum.
+ * @param  {Array}  stack  Open-tag stack (unused — firstof has no body).
+ * @param  {object} opts   Per-call options (honors `opts.filename`).
+ * @param  {object} swig   Swig instance (unused).
+ * @param  {object} token  In-progress TagToken. Gets `token.irArgs`.
+ * @return {boolean}       Always `true` on success. Throws otherwise.
+ */
+exports.parse = function (str, line, parser, types, stack, opts, swig, token) {
+  var tokens = lexer.read(utils.strip(str));
+  if (!tokens.length) {
+    utils.throwError('Expected at least one value in "firstof" tag', line, opts.filename);
+  }
+  if (hasKeyword(tokens, types, 'as')) {
+    utils.throwError('The "as" (assign-to-variable) form of "firstof" is not yet supported', line, opts.filename);
+  }
+
+  var args = [];
+  var pos = 0;
+  while (true) {
+    while (pos < tokens.length && tokens[pos].type === types.WHITESPACE) { pos += 1; }
+    if (pos >= tokens.length) { break; }
+    var posOut = {};
+    var expr = parser.parseExpr(tokens.slice(pos), {}, posOut);
+    pos += posOut.pos;
+    args.push(expr);
+  }
+
+  token.irArgs = args;
+  return true;
+};
+
+/**
+ * Emit an IROutput whose expression is the values chained with `||` and
+ * terminated by an empty-string literal (`a || b || c || ""`), so the result
+ * is the first truthy value or `""`. The `e` filter tail is appended when the
+ * region is autoescaping.
+ *
+ * @return {object} IROutput node.
+ */
+exports.compile = function (compiler, args, content, parents, options, blockName, token) {
+  var exprs = token.irArgs.slice();
+  exprs.push(ir.literal('string', ''));
+
+  var acc = exprs[exprs.length - 1];
+  var i;
+  for (i = exprs.length - 2; i >= 0; i -= 1) {
+    acc = ir.binaryOp('||', exprs[i], acc);
+  }
+
+  var tail;
+  if (token.escape) {
+    tail = [ir.filterCall('e', (typeof token.escape === 'string') ? [ir.literal('string', token.escape)] : undefined)];
+  }
+  return ir.output(acc, tail);
+};