@rhinostone/swig-django 2.7.0

package/lib/tags/for.js

@@ -0,0 +1,262 @@
+/*!
+ * Django `{% for %}` tag.
+ *
+ *   {% for <val> in <iterable> %}…{% endfor %}
+ *   {% for <key>, <val> in <iterable> %}…{% endfor %}
+ *   {% for <val> in <iterable> %}…{% empty %}…{% endfor %}
+ *
+ * Surfaces Django's `forloop` context object — `forloop.counter` /
+ * `counter0` / `revcounter` / `revcounter0` / `first` / `last` /
+ * `parentloop` — by setting the opt-in `loopName` / `loopFields` /
+ * `loopParent` flags on the IRFor node. The swig-core backend owns the
+ * loopcache + `_utils.each` scaffolding (the same IIFE every flavor's `for`
+ * loop compiles to); the flags only rename the emitted loop var + counter
+ * fields and expose the enclosing loop, so nested-loop safety and the
+ * for-empty handling come for free.
+ *
+ * Loop variable names must be bare identifiers — dotted paths are rejected
+ * at parse time, and the CVE-2023-25345 `_dangerousProps` guard runs on
+ * every bound name (key and val).
+ *
+ * Django's empty-iterable branch is `{% empty %}` (NOT `{% else %}`, which
+ * is `if`-only here); it lexes as its own marker token (tags/empty.js) and
+ * compile splits the content at it into the loop body and the empty body.
+ *
+ * Django's dict-iteration pseudo-methods are supported on the iterable —
+ * `{% for k in d.keys %}`, `{% for v in d.values %}`, and the canonical
+ * `{% for key, value in d.items %}` (see rewriteDictIterable). The one-name
+ * `{% for pair in d.items %}` tuple form is rejected with a clear message.
+ *
+ * The `reversed` modifier (`{% for x in items reversed %}`) is not yet
+ * supported; it is detected and rejected with a clear message rather than
+ * the cryptic `Unexpected token "reversed"` that parseExpr's
+ * full-consumption check would otherwise raise.
+ */
+
+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');
+
+/*!
+ * Django `forloop` ↔ swig `loop` counter-field map. `first` / `last` are
+ * identical in both, so only the four counters are renamed; `parentloop`
+ * is surfaced separately via the `loopParent` flag. @private
+ */
+var DJANGO_LOOP_FIELDS = {
+  index: 'counter',
+  index0: 'counter0',
+  revindex: 'revcounter',
+  revindex0: 'revcounter0'
+};
+
+/*!
+ * Django dict-iteration pseudo-methods recognized on a `for` iterable.
+ * @private
+ */
+var DICT_PSEUDO_METHODS = { keys: true, values: true, items: true };
+
+/*!
+ * Build a resolve-flagged VarRef for an object path (the iterable with its
+ * trailing pseudo-method segment removed) so the object itself is resolved
+ * Django-style by the swig-core variable resolver. @private
+ */
+function resolveVar(path) {
+  var n = ir.varRef(path);
+  n.resolve = true;
+  return n;
+}
+
+/*!
+ * Rewrite a `for` iterable that ends in a Django dict-iteration
+ * pseudo-method (`.keys` / `.values` / `.items`), so the loop walks the
+ * mapping the way Django does. With the variable resolver in place a trailing
+ * `.keys` / `.values` / `.items` would otherwise resolve to a (usually
+ * missing) object property, yielding an empty loop.
+ *
+ *   - `.keys`   → `_utils.keys(obj)` (a plain key array; a one-name `for`
+ *                 binds each key).
+ *   - `.values` → the object itself; swig's one-name object iteration binds
+ *                 each VALUE (`_utils.each(obj, fn(value, key))`), matching
+ *                 Django.
+ *   - `.items`  → the object itself, walked with the two-name form, so swig
+ *                 binds key + value per entry exactly as Django's two-name
+ *                 `{% for k, v in d.items %}`. The one-name tuple form is
+ *                 rejected (there is no `_utils.entries` to synthesize a
+ *                 (key, value) tuple sequence flavor-locally).
+ *
+ * Anything that is not a resolved user-variable path of length >= 2 ending in
+ * one of the three names is returned unchanged. Documented divergence: the
+ * interception is unconditional, so if `obj` has a literal key named
+ * `keys` / `values` / `items`, the pseudo-method wins (Django's dict-key
+ * precedence is not honored for those three names).
+ *
+ * @param  {object}  it          Parsed iterable IRExpr.
+ * @param  {boolean} hasTwoNames Whether the loop declared `key, val`.
+ * @param  {number}  line        Source line, for error reporting.
+ * @param  {string}  filename    Template filename, for error reporting.
+ * @return {object}              The (possibly rewritten) iterable IRExpr.
+ * @private
+ */
+function rewriteDictIterable(it, hasTwoNames, line, filename) {
+  if (!it || it.type !== 'VarRef' || !it.resolve || it.path.length < 2) {
+    return it;
+  }
+  var lastSeg = it.path[it.path.length - 1];
+  if (!DICT_PSEUDO_METHODS.hasOwnProperty(lastSeg)) {
+    return it;
+  }
+  var objPath = it.path.slice(0, -1);
+  if (lastSeg === 'keys') {
+    // The synthetic `_utils.keys` callee is intentionally NOT resolve-flagged
+    // (emitFnCall reads a callee path directly, never through emitVarRef).
+    return ir.fnCall(ir.varRef(['_utils', 'keys']), [resolveVar(objPath)]);
+  }
+  if (lastSeg === 'items' && !hasTwoNames) {
+    utils.throwError('The "items" pseudo-method in a "for" tag requires two loop variables — use {% for key, value in ' + objPath.join('.') + '.items %}', line, filename);
+  }
+  // `.values` (one-name → value) and `.items` (two-name → key, value) both
+  // walk the object directly through swig's object iteration.
+  return resolveVar(objPath);
+}
+
+exports.ends = true;
+exports.block = false;
+
+/**
+ * Parse the `{% for %}` tag body. Extracts the binding names (val or
+ * key+val), validates them, then lowers the iterable expression. Names go
+ * on `token.args` (`[val]` or `[key, val]`); the iterable IR on
+ * `token.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 (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.
+ * @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;
+
+  function peek() {
+    while (pos < tokens.length && tokens[pos].type === types.WHITESPACE) { pos += 1; }
+    return pos < tokens.length ? tokens[pos] : null;
+  }
+  function consume() {
+    var t = peek();
+    if (t) { pos += 1; }
+    return t;
+  }
+
+  function takeName() {
+    var tok = consume();
+    if (!tok || tok.type !== types.VAR) {
+      utils.throwError('Expected loop variable in "for" tag', line, opts.filename);
+    }
+    if (tok.match.indexOf('.') !== -1) {
+      utils.throwError('Loop variable "' + tok.match + '" must be a bare identifier in "for" tag', line, opts.filename);
+    }
+    if (_dangerousProps.indexOf(tok.match) !== -1) {
+      utils.throwError('Unsafe loop variable "' + tok.match + '" is not allowed (CVE-2023-25345)', line, opts.filename);
+    }
+    return tok.match;
+  }
+
+  var first = takeName();
+  var val = first;
+  var key;
+
+  if (peek() && peek().type === types.COMMA) {
+    consume();
+    key = first;
+    val = takeName();
+  }
+
+  // The lexer's COMPARATOR rule requires a trailing `\s` on `in`, so
+  // `{% for x in %}` (nothing after `in`) lexes `in` as a VAR. Match on the
+  // literal string so the error stays "Expected iterable" for that shape.
+  var inTok = consume();
+  if (!inTok || inTok.match !== 'in' || (inTok.type !== types.COMPARATOR && inTok.type !== types.VAR)) {
+    utils.throwError('Expected "in" in "for" tag', line, opts.filename);
+  }
+
+  while (pos < tokens.length && tokens[pos].type === types.WHITESPACE) { pos += 1; }
+
+  var iterableTokens = tokens.slice(pos);
+  if (!iterableTokens.length) {
+    utils.throwError('Expected iterable after "in" in "for" tag', line, opts.filename);
+  }
+
+  // `{% for x in items reversed %}` — trailing `reversed` modifier (a real
+  // Django feature, not yet supported). Detect a trailing bare `reversed`
+  // VAR with an iterable before it and reject clearly. A lone `reversed`
+  // (`{% for x in reversed %}`) is a legitimate variable name and is left
+  // to parseExpr.
+  var lastTok = iterableTokens[iterableTokens.length - 1];
+  if (iterableTokens.length > 1 && lastTok.type === types.VAR && lastTok.match === 'reversed') {
+    utils.throwError('The "reversed" modifier in the "for" tag is not yet supported', line, opts.filename);
+  }
+
+  token.args = key !== undefined ? [key, val] : [val];
+  token.irExpr = rewriteDictIterable(parser.parseExpr(iterableTokens), key !== undefined, line, opts.filename);
+  return true;
+};
+
+/**
+ * Emit an IRFor node, splitting `content` at an `{% empty %}` marker into
+ * the loop body and the empty body, and setting the Django `forloop`
+ * opt-in flags. The backend's `For` branch owns the loopcache +
+ * `_utils.each` scaffolding.
+ *
+ * @return {object} IRFor node.
+ */
+exports.compile = function (compiler, args, content, parents, options, blockName, token) {
+  var val, key;
+  if (args.length === 2) {
+    key = args[0];
+    val = args[1];
+  } else {
+    val = args[0];
+    key = '__k';
+  }
+
+  var loopContent = [],
+    emptyContent = null,
+    filename = options && options.filename;
+
+  utils.each(content, function (child) {
+    if (child && child.name === 'empty') {
+      if (emptyContent !== null) {
+        utils.throwError('Multiple "empty" branches in "for" tag', null, filename);
+      }
+      emptyContent = [];
+      return;
+    }
+    if (emptyContent !== null) {
+      emptyContent.push(child);
+    } else {
+      loopContent.push(child);
+    }
+  });
+
+  var bodyJS = compiler(loopContent, parents, options, blockName);
+  var emptyBody;
+  if (emptyContent !== null) {
+    emptyBody = [ir.legacyJS(compiler(emptyContent, parents, options, blockName))];
+  }
+
+  var node = ir.forStmt(val, token.irExpr, [ir.legacyJS(bodyJS)], key, emptyBody);
+  // Opt-in loop-context flags → Django `forloop` (see ir.js IRFor typedef +
+  // the backend `For` emit). Absent on every other flavor, so their emit
+  // stays byte-identical.
+  node.loopName = 'forloop';
+  node.loopFields = DJANGO_LOOP_FIELDS;
+  node.loopParent = true;
+  return node;
+};

package/lib/tags/if.js

@@ -0,0 +1,82 @@
+/*!
+ * Django `{% if %}` / `{% elif %}` / `{% else %}` tag.
+ *
+ * Conditional: `{% if <expr> %}…{% elif <expr> %}…{% else %}…{% endif %}`.
+ * The test expression is parsed via `parser.parseExpr` and attached to
+ * `token.irExpr`. The body content is captured via the parser's open-tag
+ * stack (this tag sets `ends: true`).
+ *
+ * `{% elif %}` and `{% else %}` lex as their own tags (`ends: false`,
+ * registered in tags/index.js) and so appear as marker tokens inside this
+ * tag's `content`. The compile path walks `content`, splitting at those
+ * markers into one IRIfBranch per segment — the backend's `If` walker then
+ * emits the `if (…) { … } else if (…) { … } else { … }` envelope.
+ */
+
+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 `{% if %}` test expression onto `token.irExpr`.
+ *
+ * @param  {string} str    Tag body (tag name stripped).
+ * @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 (managed by parser.js).
+ * @param  {object} opts   Per-call options (honors `opts.filename`).
+ * @param  {object} swig   Swig instance (unused).
+ * @param  {object} token  In-progress TagToken. `token.irExpr` is set.
+ * @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 conditional expression in "if" tag', line, opts.filename);
+  }
+  token.irExpr = parser.parseExpr(tokens);
+  return true;
+};
+
+/**
+ * Split `content` at `elif` / `else` marker tokens and emit a multi-branch
+ * IRIf node.
+ *
+ * @return {object} IRIf node.
+ */
+exports.compile = function (compiler, args, content, parents, options, blockName, token) {
+  var branches = [],
+    currentTest = token.irExpr,
+    currentBody = [],
+    sawElse = false,
+    filename = options && options.filename;
+
+  function flush() {
+    branches.push(ir.ifBranch(currentTest, [ir.legacyJS(compiler(currentBody, parents, options, blockName))]));
+  }
+
+  utils.each(content, function (child) {
+    if (child && child.name === 'elif') {
+      if (sawElse) { utils.throwError('"elif" after "else" in "if" tag', null, filename); }
+      flush();
+      currentTest = child.irExpr;
+      currentBody = [];
+    } else if (child && child.name === 'else') {
+      if (sawElse) { utils.throwError('Multiple "else" branches in "if" tag', null, filename); }
+      flush();
+      currentTest = null;
+      currentBody = [];
+      sawElse = true;
+    } else {
+      currentBody.push(child);
+    }
+  });
+  flush();
+
+  return ir.ifStmt(branches);
+};

package/lib/tags/include.js

@@ -0,0 +1,200 @@
+/*!
+ * Django `{% include %}` tag.
+ *
+ * Django include syntax:
+ *
+ *   {% include "partial.html" %}                       (full caller context)
+ *   {% include "partial.html" with foo=1 bar=baz %}    (context + extra vars)
+ *   {% include "partial.html" with foo=1 only %}        (ONLY the extra vars)
+ *   {% include "partial.html" only %}                   (empty isolated context)
+ *   {% include dynamicPath %}
+ *
+ * Path is lowered through `parser.parseExpr`, so STRING literals, VAR
+ * references, member access, and any other Django expression all route
+ * through the same path.
+ *
+ * The `with` clause is space-separated `name=value` assignments (Django's
+ * shape, NOT Twig's single `{dict}` expression) — each value is lowered
+ * through `parser.parseExpr` and collected into an object literal. The
+ * trailing `only` keyword isolates the included template to just that
+ * object (the backend's `Include` selector emits the object instead of
+ * `_ctx`); without `only`, the object is merged over the caller's context.
+ * `only` may also appear without a `with`, giving an empty isolated context.
+ *
+ * Django has no `ignore missing` modifier (a missing template raises), so
+ * the IRInclude's `ignoreMissing` flag is always false here.
+ *
+ * Emits an `IRInclude` node. The backend's `Include` branch owns the
+ * `_swig.compileFile(...)` + `resolveFrom` plumbing and the
+ * isolated-vs-merged context selector.
+ */
+
+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 = false;
+exports.block = false;
+
+/**
+ * Strip WHITESPACE tokens from both ends of a slice range.
+ *
+ * @param  {object[]} tokens Token stream.
+ * @param  {number}   start  Inclusive start index.
+ * @param  {number}   end    Exclusive end index.
+ * @param  {object}   types  Lexer token-type enum.
+ * @return {object[]}        Trimmed slice.
+ * @private
+ */
+function sliceTrim(tokens, start, end, types) {
+  while (start < end && tokens[start].type === types.WHITESPACE) { start += 1; }
+  while (end > start && tokens[end - 1].type === types.WHITESPACE) { end -= 1; }
+  return tokens.slice(start, end);
+}
+
+/**
+ * Find the first depth-0 VAR token whose match equals `word`. Depth tracks
+ * paren / bracket / curly / function nesting so a keyword inside the path
+ * expression is left alone.
+ *
+ * @return {number} Token index, or -1 if not found.
+ * @private
+ */
+function findKeyword(tokens, types, word) {
+  var depth = 0, i, tk;
+  for (i = 0; i < tokens.length; i += 1) {
+    tk = tokens[i];
+    if (tk.type === types.PARENOPEN || tk.type === types.BRACKETOPEN ||
+        tk.type === types.CURLYOPEN || tk.type === types.FUNCTION) { depth += 1; continue; }
+    if (tk.type === types.PARENCLOSE || tk.type === types.BRACKETCLOSE ||
+        tk.type === types.CURLYCLOSE) { depth -= 1; continue; }
+    if (depth !== 0 || tk.type !== types.VAR) { continue; }
+    if (tk.match === word) { return i; }
+  }
+  return -1;
+}
+
+/**
+ * Parse space-separated `name = value` pairs from a token slice. Each value
+ * is one expression (parseExpr stops at the next bare name, since
+ * `<value> <name>` has no operator between them). Stops when the next token
+ * is not a `name =` start, returning the unconsumed remainder as `leftover`
+ * (e.g. a trailing `only` keyword). Django parses the kwargs greedily first,
+ * so `with x=only` binds x to the variable `only` while `with x=1 only`
+ * leaves a trailing `only`.
+ *
+ * @return {{props: object[], leftover: object[]}}
+ * @private
+ */
+function parsePairs(clause, parser, types, line, opts) {
+  var props = [];
+  var pos = 0;
+  function skipWS() { while (pos < clause.length && clause[pos].type === types.WHITESPACE) { pos += 1; } }
+
+  while (true) {
+    skipWS();
+    if (pos >= clause.length) { break; }
+    var nameTok = clause[pos];
+    if (nameTok.type !== types.VAR) { break; }
+    var j = pos + 1;
+    while (j < clause.length && clause[j].type === types.WHITESPACE) { j += 1; }
+    if (!(j < clause.length && clause[j].type === types.ASSIGNMENT && clause[j].match === '=')) {
+      break;
+    }
+    if (nameTok.match.indexOf('.') !== -1) {
+      utils.throwError('"with" assignment target "' + nameTok.match + '" must be a bare identifier in "include" tag', line, opts.filename);
+    }
+    if (_dangerousProps.indexOf(nameTok.match) !== -1) {
+      utils.throwError('Unsafe "with" assignment to "' + nameTok.match + '" is not allowed (CVE-2023-25345)', line, opts.filename);
+    }
+    pos = j + 1;
+    skipWS();
+    var posOut = {};
+    var valExpr = parser.parseExpr(clause.slice(pos), {}, posOut);
+    pos += posOut.pos;
+    props.push(ir.objectProperty(ir.literal('string', nameTok.match), valExpr));
+  }
+
+  skipWS();
+  return { props: props, leftover: clause.slice(pos) };
+}
+
+/**
+ * Parse the `{% include %}` tag body — the path expression plus the optional
+ * `with name=value …` assignments and trailing `only` keyword.
+ *
+ * @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 — include has no body).
+ * @param  {object} opts   Per-call options (honors `opts.filename`).
+ * @param  {object} swig   Swig instance (unused — backend owns load).
+ * @param  {object} token  In-progress TagToken. `token.irExpr` gets the
+ *                         IRInclude node.
+ * @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 isolated = false;
+  var ctxExpr;
+  var pathTokens;
+
+  var withIdx = findKeyword(tokens, types, 'with');
+
+  if (withIdx !== -1) {
+    pathTokens = sliceTrim(tokens, 0, withIdx, types);
+    var clause = sliceTrim(tokens, withIdx + 1, tokens.length, types);
+    var parsed = parsePairs(clause, parser, types, line, opts);
+    if (!parsed.props.length) {
+      utils.throwError('Expected at least one "name=value" assignment after "with" in "include" tag', line, opts.filename);
+    }
+    if (parsed.leftover.length === 1 && parsed.leftover[0].type === types.VAR && parsed.leftover[0].match === 'only') {
+      isolated = true;
+    } else if (parsed.leftover.length) {
+      utils.throwError('Unexpected token "' + parsed.leftover[0].match + '" after "with" assignments in "include" tag', line, opts.filename);
+    }
+    ctxExpr = ir.objectLiteral(parsed.props);
+  } else {
+    // No `with`. A trailing bare `only` (with a path before it) isolates the
+    // included template to an empty context. `{% include only %}` with no
+    // path before it is a path named `only`, not the keyword.
+    var trimmed = sliceTrim(tokens, 0, tokens.length, types);
+    var lastTok = trimmed.length ? trimmed[trimmed.length - 1] : null;
+    if (trimmed.length >= 2 && lastTok.type === types.VAR && lastTok.match === 'only') {
+      isolated = true;
+      ctxExpr = ir.objectLiteral([]);
+      pathTokens = trimmed.slice(0, trimmed.length - 1);
+    } else {
+      pathTokens = trimmed;
+    }
+  }
+
+  if (!pathTokens.length) {
+    utils.throwError('Expected template path in "include" tag', line, opts.filename);
+  }
+  var pathExpr = parser.parseExpr(pathTokens);
+
+  var resolveFrom = (opts.filename || '').replace(/\\/g, '\\\\');
+  token.irExpr = ir.include(pathExpr, ctxExpr, isolated, false, resolveFrom);
+  return true;
+};
+
+/**
+ * Return the pre-built IRInclude node. In async codegen mode, derive an
+ * IRIncludeDeferred from the same fields so the backend routes through the
+ * `_swig.getTemplate` + `await` path instead of the sync `_swig.compileFile`
+ * call.
+ *
+ * @return {object} IRInclude or IRIncludeDeferred node.
+ */
+exports.compile = function (compiler, args, content, parents, options, blockName, token) {
+  if (options && options.codegenMode === 'async') {
+    var i = token.irExpr;
+    return ir.includeDeferred(i.path, i.context, i.isolated, i.ignoreMissing, i.resolveFrom);
+  }
+  return token.irExpr;
+};

package/lib/tags/index.js

@@ -0,0 +1,37 @@
+/*!
+ * Django per-flavor tag registry.
+ *
+ * Each tag exports `{ parse, compile, ends, block }` with a Django-tailored
+ * shape:
+ *
+ *   parse(str, line, parser, types, stack, opts, swig, token) → boolean
+ *
+ * The 8th `token` argument is the in-progress TagToken. Tag implementations
+ * call `parser.parseExpr(lexer.read(str), filters)` directly and attach the
+ * resulting IRExpr to `token.irExpr`, then return true. This avoids the
+ * native-swig `parser.on(types.X, fn)` callback indirection — Django tags
+ * own their own arg-parsing path, like the Twig and Jinja2 siblings.
+ *
+ * Conditionals (if / elif / else), looping (for / empty), template
+ * inheritance (block / extends / include), the region tags (with /
+ * autoescape / spaceless / comment / verbatim), and the Django-only output
+ * tags (cycle / firstof) are registered — the full S3 tag set.
+ */
+
+module.exports = {
+  'if': require('./if'),
+  'elif': require('./elif'),
+  'else': require('./else'),
+  'for': require('./for'),
+  'empty': require('./empty'),
+  'block': require('./block'),
+  'extends': require('./extends'),
+  'include': require('./include'),
+  'with': require('./with'),
+  'autoescape': require('./autoescape'),
+  'spaceless': require('./spaceless'),
+  'comment': require('./comment'),
+  'verbatim': require('./verbatim'),
+  'cycle': require('./cycle'),
+  'firstof': require('./firstof')
+};

package/lib/tags/spaceless.js

@@ -0,0 +1,69 @@
+/*!
+ * Django `{% spaceless %}…{% endspaceless %}` tag.
+ *
+ * Removes whitespace between HTML tags within the block — every run of
+ * whitespace that sits directly between a `>` and a `<` collapses away:
+ *
+ *   {% spaceless %}
+ *     <p>
+ *       <a href="foo/">Foo</a>
+ *     </p>
+ *   {% endspaceless %}
+ *   // => <p><a href="foo/">Foo</a></p>
+ *
+ * Django's rule is strictly `>\s+<` → `><` — it does NOT strip leading /
+ * trailing whitespace of the block or whitespace inside a tag or inside
+ * text. (This is narrower than the native swig `spaceless`, which also
+ * strips the leading/trailing whitespace of the WHOLE output — a quirk this
+ * faithful port deliberately avoids.)
+ *
+ * The body is compiled into a shadowed `_output` local (the same shape the
+ * backend uses for `{% filter %}`), so the collapse is scoped to just this
+ * region's content — content emitted before / after the block is untouched.
+ *
+ * Takes no arguments. Extra tokens after `spaceless` are rejected at parse
+ * time.
+ */
+
+var ir = require('@rhinostone/swig-core/lib/ir');
+var utils = require('@rhinostone/swig-core/lib/utils');
+
+exports.ends = true;
+exports.block = false;
+
+/**
+ * Reject any tokens after the `spaceless` keyword.
+ *
+ * @param  {string} str    Tag body (everything after `spaceless`).
+ * @param  {number} line   Source line of the opening `{%`.
+ * @param  {object} parser The Django parser module (unused).
+ * @param  {object} types  Django lexer token-type enum (unused).
+ * @param  {Array}  stack  Open-tag stack (parser.js manages the push).
+ * @param  {object} opts   Per-call options (honors `opts.filename`).
+ * @return {boolean}       Always `true` on success. Throws otherwise.
+ */
+exports.parse = function (str, line, parser, types, stack, opts) {
+  var stripped = utils.strip(str || '');
+  if (stripped.length > 0) {
+    utils.throwError('Unexpected token "' + stripped + '" after "spaceless"', line, opts.filename);
+  }
+  return true;
+};
+
+/**
+ * Emit the body into a shadowed `_output` local, then append the
+ * whitespace-collapsed result to the real output. Returns an IRLegacyJS
+ * node carrying the generated JS.
+ *
+ * @return {object} IRLegacyJS node.
+ */
+exports.compile = function (compiler, args, content, parents, options, blockName) {
+  var bodyJS = compiler(content, parents, options, blockName);
+  return ir.legacyJS(
+    '_output += (function () {\n' +
+    '  var _output = "";\n' +
+    bodyJS +
+    '  return _output.replace(/>\\s+</g, "><");\n' +
+    '})();\n'
+  );
+};