@rhinostone/swig-twig 2.0.0-alpha.3

package/lib/tags/macro.js

@@ -0,0 +1,149 @@
+/*!
+ * Phase 3 Session 10 — Twig `{% macro %}` tag.
+ *
+ * Twig macro syntax:
+ *
+ *   {% macro name() %}…{% endmacro %}
+ *   {% macro name(a, b, c) %}…{% endmacro %}
+ *
+ * Defines a reusable function bound to `_ctx.<name>`. Backend emits the
+ * full IIFE (`_utils.extend` snapshot, shadow-delete of param names from
+ * `_ctx`, body, restore) — see backend.js:236. Tag ships only semantic
+ * IR: name, params (`IRMacroParam[]`), body.
+ *
+ * Param names and the macro name are bare identifiers — dotted paths
+ * (`foo.bar`) and CVE-2023-25345 prototype-chain names (`__proto__`,
+ * `constructor`, `prototype`) are rejected at parse time. Lexer-folded
+ * dotted-path bail per `.claude/conventions.md § Lexer-folded-path bail`:
+ * single-name binding slots reject any `.` in the match before the
+ * `_dangerousProps` check.
+ *
+ * Twig kwargs (`{% macro foo(a=1, b="x") %}`) are deferred — Phase 4 with
+ * the rest of the Twig-specific surface.
+ */
+
+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');
+var _t = require('../tokentypes');
+
+exports.ends = true;
+exports.block = true;
+
+/**
+ * Parse the `{% macro %}` tag body. Extracts the macro name and the
+ * optional comma-separated parameter list. Both name and params are
+ * validated against the bare-identifier rule and the CVE-2023-25345
+ * `_dangerousProps` blocklist.
+ *
+ * Accepts both shapes:
+ *   `name` + FUNCTION/FUNCTIONEMPTY (Twig idiomatic)
+ *   `name(a, b)` lexed as FUNCTION token whose `match` is the name
+ *
+ * Stashes `[name, {name: p1}, {name: p2}, ...]` on `token.args`. Compile
+ * lifts the name off the head and passes the remaining param objects
+ * straight to `ir.macro` — the backend handles the IIFE.
+ *
+ * @param  {string} str    Tag body.
+ * @param  {number} line   Source line of the opening `{%`.
+ * @param  {object} parser The Twig parser module (unused — macro body is
+ *                         lexed locally).
+ * @param  {object} types  Twig lexer token-type enum.
+ * @param  {Array}  stack  Open-tag stack (unused — parser.js manages 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
+ *                         macro name + IRMacroParam objects.
+ * @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 checkName(name, role) {
+    if (name.indexOf('.') !== -1) {
+      utils.throwError(role + ' "' + name + '" must be a bare identifier in "macro" tag', line, opts.filename);
+    }
+    if (_dangerousProps.indexOf(name) !== -1) {
+      utils.throwError('Unsafe ' + role.toLowerCase() + ' "' + name + '" is not allowed (CVE-2023-25345)', line, opts.filename);
+    }
+  }
+
+  var head = consume();
+  if (!head) {
+    utils.throwError('Expected macro name in "macro" tag', line, opts.filename);
+  }
+
+  var name;
+  var params = [];
+
+  if (head.type === types.FUNCTIONEMPTY) {
+    name = head.match;
+    checkName(name, 'Macro name');
+  } else if (head.type === types.FUNCTION) {
+    name = head.match;
+    checkName(name, 'Macro name');
+    var first = true;
+    while (true) {
+      var tk = peek();
+      if (!tk) {
+        utils.throwError('Unclosed parameter list in "macro" tag', line, opts.filename);
+      }
+      if (tk.type === types.PARENCLOSE) {
+        consume();
+        break;
+      }
+      if (!first) {
+        if (tk.type !== types.COMMA) {
+          utils.throwError('Expected "," between parameters in "macro" tag', line, opts.filename);
+        }
+        consume();
+      }
+      first = false;
+      var pTok = consume();
+      if (!pTok || pTok.type !== types.VAR) {
+        utils.throwError('Expected parameter name in "macro" tag', line, opts.filename);
+      }
+      checkName(pTok.match, 'Parameter');
+      params.push(ir.macroParam(pTok.match));
+    }
+  } else if (head.type === types.VAR) {
+    name = head.match;
+    checkName(name, 'Macro name');
+  } else {
+    utils.throwError('Expected macro name in "macro" tag', line, opts.filename);
+  }
+
+  if (peek()) {
+    utils.throwError('Unexpected token "' + peek().match + '" after macro signature in "macro" tag', line, opts.filename);
+  }
+
+  token.args = [name].concat(params);
+  return true;
+};
+
+/**
+ * Emit an IRMacro node. Backend's `Macro` branch owns the `_ctx.<name>
+ * = function(...) { … }` IIFE + `_utils.extend` snapshot + shadow-delete
+ * of param names from `_ctx`.
+ *
+ * @return {object} IRMacro node.
+ */
+exports.compile = function (compiler, args, content, parents, options, blockName) {
+  var name = args[0];
+  var params = args.slice(1);
+  var bodyJS = compiler(content, parents, options, blockName);
+  return ir.macro(name, params, [ir.legacyJS(bodyJS)]);
+};

package/lib/tags/set.js

@@ -0,0 +1,174 @@
+/*!
+ * Phase 3 Session 7 — Twig `{% set %}` tag.
+ * Phase 3 Session 11 — extended with body-capture form.
+ *
+ * Twig `set` has two forms:
+ *
+ *   Inline:  {% set <lhs> <op> <rhs> %}
+ *   Body:    {% set <lhs> %}…{% endset %}
+ *
+ *   lhs — a bare identifier or a pure-dot path (`foo`, `foo.bar.baz`).
+ *         Bracket LHS (`foo[bar]`) is rejected at parse time — the
+ *         bracket-lvalue contract is a cross-flavor design call and
+ *         is deferred.
+ *   op  — any valid JS assignment operator (`=`, `+=`, `-=`, `*=`, `/=`).
+ *         Inline form only.
+ *   rhs — any Twig expression; parsed via `parser.parseExpr`.
+ *         Inline form only.
+ *
+ * Inline form emits an IRSet node on `token.irExpr`:
+ *
+ *   ir.set(ir.varRef(['foo', 'bar']), '=', <IRExpr value>)
+ *
+ * Body form captures the rendered content as a string via an IIFE and
+ * assigns it to the target. No dedicated IR factory — emits an
+ * IRLegacyJS fragment because the capture is a JS plumbing shape
+ * (IIFE over `_output`) that doesn't need its own IR surface.
+ *
+ * Static `exports.ends = true` is the default so the token's `ends`
+ * slot starts truthy — the body form keeps it, the inline form flips
+ * `token.ends = false` at parse time so the splitter does NOT push
+ * the inline-form token onto the open-tag stack.
+ *
+ * CVE-2023-25345 checkpoints apply twice — here on the LHS path
+ * segments, and again in the backend `checkDangerousSegment` walk —
+ * per the duplication invariant in .claude/security.md § _dangerousProps
+ * is duplicated across layers.
+ */
+
+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');
+var _t = require('../tokentypes');
+
+exports.ends = true;
+exports.block = true;
+
+/**
+ * Parse the `{% set %}` tag body and attach the appropriate IR to the
+ * token. Inline form sets `token.irExpr` and flips `token.ends = false`;
+ * body form leaves `token.ends = true` and stashes the target path on
+ * `token.args` for the compile step to pick up.
+ *
+ * @param  {string} str    Tag body (everything between `{%` and `%}`, tag name stripped).
+ * @param  {number} line   Source line of the opening `{%`.
+ * @param  {object} parser The Twig parser module (exposes `parseExpr`).
+ * @param  {object} types  Twig lexer token-type enum.
+ * @param  {Array}  stack  Open-tag stack (unused — parser.js manages the push).
+ * @param  {object} opts   Per-call options (honors `opts.filename` for filename-aware throws).
+ * @param  {object} swig   Swig instance (unused).
+ * @param  {object} token  In-progress TagToken. Body form: `token.args` gets the path;
+ *                         `token.ends` stays true. Inline form: `token.irExpr` gets
+ *                         the IRSet; `token.ends` flips to false.
+ * @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;
+  }
+
+  var lhsTok = consume();
+  if (!lhsTok || lhsTok.type !== types.VAR) {
+    utils.throwError('Expected variable name in "set" tag', line, opts.filename);
+  }
+
+  var path = lhsTok.match.split('.');
+  utils.each(path, function (segment) {
+    if (_dangerousProps.indexOf(segment) !== -1) {
+      utils.throwError('Unsafe assignment to "' + segment + '" is not allowed (CVE-2023-25345)', line, opts.filename);
+    }
+  });
+
+  // DOTKEY tail — the Twig lexer already folds dotted paths into the
+  // VAR match, but a defensive DOTKEY consumer here keeps this tag
+  // robust if a future lexer tightening splits `foo.bar` into VAR + DOTKEY.
+  while (peek() && peek().type === types.DOTKEY) {
+    var dk = consume();
+    if (_dangerousProps.indexOf(dk.match) !== -1) {
+      utils.throwError('Unsafe assignment to "' + dk.match + '" is not allowed (CVE-2023-25345)', line, opts.filename);
+    }
+    path.push(dk.match);
+  }
+
+  var next = peek();
+  if (next && next.type === types.BRACKETOPEN) {
+    utils.throwError('Bracket-notation assignment is not supported in "set" (use dot-path notation)', line, opts.filename);
+  }
+
+  if (!next) {
+    // Body-capture form — no more tokens after the LHS. Keep
+    // `token.ends = true` (the default from `exports.ends`) so the
+    // splitter pushes the token onto the open-tag stack and waits
+    // for a matching `{% endset %}`. Stash the path on `token.args`
+    // for the compile handler to consume.
+    token.args = path;
+    return true;
+  }
+
+  // Inline form — flip `token.ends = false` so the splitter does NOT
+  // push the token onto the open-tag stack.
+  token.ends = false;
+
+  var opTok = consume();
+  if (opTok.type !== types.ASSIGNMENT) {
+    utils.throwError('Expected assignment operator in "set" tag', line, opts.filename);
+  }
+
+  // Skip leading whitespace between `=` and the RHS expression so the
+  // RHS slice starts at the first meaningful token. parseExpr tolerates
+  // leading whitespace internally, but trimming here keeps the slice
+  // shape predictable for future callers.
+  while (pos < tokens.length && tokens[pos].type === types.WHITESPACE) { pos += 1; }
+
+  var rhsTokens = tokens.slice(pos);
+  if (!rhsTokens.length) {
+    utils.throwError('Expected expression after assignment in "set" tag', line, opts.filename);
+  }
+
+  var value = parser.parseExpr(rhsTokens);
+  token.irExpr = ir.set(ir.varRef(path), opTok.match, value);
+  return true;
+};
+
+/**
+ * Emit the IR for either the inline-assignment or body-capture form.
+ * Inline form returns the pre-built IRSet via `token.irExpr`. Body form
+ * compiles the captured content and wraps it in an IIFE assigned to
+ * the target.
+ *
+ * @param  {Function} compiler   Backend walker (recurses into `content`).
+ * @param  {Array}    args       Target path segments (body form only).
+ * @param  {Array}    content    Child tokens captured between `{% set %}`
+ *                               and `{% endset %}` (body form only).
+ * @param  {Array}    parents    Parent template chain (passed through).
+ * @param  {object}   options    Compile options (passed through).
+ * @param  {?string}  blockName  Enclosing block name (passed through).
+ * @param  {object}   token      The tag token. `token.irExpr` is set
+ *                               for inline form only.
+ * @return {object}   IRSet (inline) or IRLegacyJS (body).
+ */
+exports.compile = function (compiler, args, content, parents, options, blockName, token) {
+  if (token.irExpr) {
+    return token.irExpr;
+  }
+  var path = args;
+  var bodyJS = compiler(content, parents, options, blockName);
+  return ir.legacyJS(
+    '_ctx.' + path.join('.') + ' = (function () {\n' +
+    '  var _output = "";\n' +
+    bodyJS +
+    '  return _output;\n' +
+    '})();\n'
+  );
+};

package/lib/tags/verbatim.js

@@ -0,0 +1,52 @@
+/*!
+ * Phase 3 Session 11 — Twig `{% verbatim %}…{% endverbatim %}` tag.
+ *
+ * Preserves arbitrary template-like content as literal output. Inside
+ * a verbatim block, `{{ … }}`, `{% … %}` (other than `{% endverbatim %}`),
+ * and `{# … #}` are NOT parsed — the splitter in `parser.js` flips an
+ * `inVerbatim` flag that bypasses the variable/tag/comment branches and
+ * wraps each chunk as `ir.text`, so the content array handed to this
+ * tag's compile is already a list of IRText nodes.
+ *
+ * Takes no arguments. Extra tokens after `verbatim` are rejected at
+ * parse time with a filename-aware throw.
+ */
+
+var utils = require('@rhinostone/swig-core/lib/utils');
+
+/**
+ * Reject any tokens after the `verbatim` keyword. The splitter owns
+ * all content-capture behaviour via its `inVerbatim` flag, so this
+ * handler only has to validate the tag's own argument list (which
+ * must be empty).
+ *
+ * @param  {string} str    Tag body (everything after `verbatim`).
+ * @param  {number} line   Source line of the opening `{%`.
+ * @param  {object} parser The Twig parser module (unused).
+ * @param  {object} types  Twig 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 "verbatim"', line, opts.filename);
+  }
+  return true;
+};
+
+/**
+ * Return the captured content array unchanged. Each item is already
+ * an IRText node (or another pre-built IR node that the backend will
+ * splice through), so the backend's emit loop can iterate and emit
+ * without any further wrapping.
+ *
+ * @return {Array} Content node list.
+ */
+exports.compile = function (compiler, args, content) {
+  return content;
+};
+
+exports.ends = true;
+exports.block = false;

package/lib/tags/with.js

@@ -0,0 +1,133 @@
+/*!
+ * Phase 3 Session 12 — Twig `{% with %}` tag.
+ *
+ * Twig scoped-context region:
+ *
+ *   {% with %}…{% endwith %}                    (shallow copy of _ctx)
+ *   {% with <ctx> %}…{% endwith %}              (merge ctx into _ctx)
+ *   {% with <ctx> only %}…{% endwith %}         (isolated, ctx is context)
+ *   {% with only %}…{% endwith %}               (isolated, empty context)
+ *
+ * The context expression (when present) is lowered through
+ * `parser.parseExpr`, so object literals, variable references,
+ * conditionals, function calls — any Twig expression — all route
+ * through the same path.
+ *
+ * The `only` keyword is recognised as a bare VAR token at top-level
+ * paren/bracket/curly/function depth. Depth tracking prevents a nested
+ * `only` inside the context expression (unlikely but possible) from
+ * being mistaken for the keyword.
+ *
+ * The tag emits an `IRWith` node. The backend's `With` branch
+ * (packages/swig-core/lib/backend.js) owns the IIFE scaffolding that
+ * shadows `_ctx` for the body's lexical scope while letting `_output`
+ * stay in the outer scope via closure capture.
+ */
+
+var ir = require('@rhinostone/swig-core/lib/ir');
+var utils = require('@rhinostone/swig-core/lib/utils');
+
+var lexer = require('../lexer');
+var _t = require('../tokentypes');
+
+exports.ends = true;
+exports.block = false;
+
+/**
+ * Parse the `{% with %}` tag body. Extracts the optional context
+ * expression and the optional `only` keyword marker, lowers the
+ * context slice through `parser.parseExpr`, and stashes the result on
+ * `token.irExpr` along with the `isolated` flag on `token.args`.
+ *
+ * @param  {string} str    Tag body.
+ * @param  {number} line   Source line of the opening `{%`.
+ * @param  {object} parser The Twig parser module (exposes `parseExpr`).
+ * @param  {object} types  Twig 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 depth = 0;
+  var onlyIdx = -1;
+  var 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) { continue; }
+    if (tk.type !== types.VAR) { continue; }
+
+    if (tk.match === 'only' && onlyIdx === -1) {
+      onlyIdx = i;
+    }
+  }
+
+  var ctxEnd = (onlyIdx !== -1) ? onlyIdx : tokens.length;
+  var ctxTokens = sliceTrim(tokens, 0, ctxEnd, types);
+
+  var ctxExpr;
+  if (ctxTokens.length) {
+    ctxExpr = parser.parseExpr(ctxTokens);
+  }
+
+  // Trailing tokens after `only` are not allowed — `{% with ctx only extra %}`
+  // is ambiguous (is `extra` a second context slot? a stray keyword?).
+  if (onlyIdx !== -1) {
+    var tail = sliceTrim(tokens, onlyIdx + 1, tokens.length, types);
+    if (tail.length) {
+      utils.throwError('Unexpected tokens after "only" in "with" tag', line, opts.filename);
+    }
+  }
+
+  token.args = [!!(onlyIdx !== -1)];
+  token.irExpr = ctxExpr;
+  return true;
+};
+
+/**
+ * Strip WHITESPACE tokens from both ends of a slice range, returning a
+ * plain array. Parser.parseExpr skips whitespace in the interior, but
+ * leading/trailing whitespace produces a zero-length effective slice
+ * that parseExpr cannot classify; the explicit trim keeps the empty-
+ * context detection (`ctxTokens.length === 0`) honest.
+ *
+ * @param  {object[]} tokens Token stream.
+ * @param  {number}   start  Inclusive start index.
+ * @param  {number}   end    Exclusive end index.
+ * @param  {object}   types  Twig 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);
+}
+
+/**
+ * Emit an IRWith node carrying the optional context IRExpr, the
+ * `isolated` flag, and the recursively-compiled body wrapped in
+ * IRLegacyJS. The backend's `With` branch owns the IIFE-shadow of
+ * `_ctx` for the body's lexical scope.
+ *
+ * @return {object} IRWith node.
+ */
+exports.compile = function (compiler, args, content, parents, options, blockName, token) {
+  var isolated = !!args[0];
+  var bodyJS = compiler(content, parents, options, blockName);
+  return ir.withStmt(token.irExpr, isolated, [ir.legacyJS(bodyJS)]);
+};

package/lib/tokentypes.js

@@ -0,0 +1,97 @@
+/**
+ * Twig lexer token type enum — the contract between the Twig lexer and
+ * the Twig parser in @rhinostone/swig-twig.
+ *
+ * Numeric IDs in the shared range (0–25, 100) mirror
+ * @rhinostone/swig-core/lib/tokentypes by design: Twig and native Swig
+ * lower to the same swig-core IR, and aligning the IDs keeps shared
+ * consumers (e.g. backend.compile splice-through paths, CVE-2023-25345
+ * `_dangerousProps` enforcement) flavor-agnostic. The Twig parser is
+ * its own module — it does not inherit from swig-core's TokenParser —
+ * but the cognitive overhead of re-mapping IDs across flavors is not
+ * worth the freedom.
+ *
+ * Twig-only IDs (30–37) are reserved here so Session 3 can add lexer
+ * rules without renumbering. Keeping the layout stable up front avoids
+ * silent ID collisions across in-flight flavor work.
+ *
+ * See .claude/architecture/multi-flavor-ir.md § Phase 3 for the
+ * per-flavor split decision.
+ *
+ * @readonly
+ * @enum {number}
+ */
+module.exports = {
+  /** Whitespace */
+  WHITESPACE: 0,
+  /** Plain string literal */
+  STRING: 1,
+  /** Variable filter call with arguments — `|name(...)` */
+  FILTER: 2,
+  /** Variable filter call with no arguments — `|name` */
+  FILTEREMPTY: 3,
+  /** Function call with arguments — `name(...)` */
+  FUNCTION: 4,
+  /** Function call with no arguments — `name()` */
+  FUNCTIONEMPTY: 5,
+  /** Open parenthesis */
+  PARENOPEN: 6,
+  /** Close parenthesis */
+  PARENCLOSE: 7,
+  /** Comma */
+  COMMA: 8,
+  /** Variable identifier */
+  VAR: 9,
+  /** Numeric literal */
+  NUMBER: 10,
+  /** Math operator (+, -, *, /, %) */
+  OPERATOR: 11,
+  /** Open square bracket */
+  BRACKETOPEN: 12,
+  /** Close square bracket */
+  BRACKETCLOSE: 13,
+  /** Dot-key accessor — `.key` */
+  DOTKEY: 14,
+  /** Open square bracket at the start of an array literal */
+  ARRAYOPEN: 15,
+  /** Open curly brace */
+  CURLYOPEN: 17,
+  /** Close curly brace */
+  CURLYCLOSE: 18,
+  /** Colon — object literal key/value separator */
+  COLON: 19,
+  /** JavaScript-valid comparator (==, !=, <=, etc.) */
+  COMPARATOR: 20,
+  /** Boolean logic (`and`, `or`, `&&`, `||`) */
+  LOGIC: 21,
+  /** Boolean negation (`not`, `!`) */
+  NOT: 22,
+  /** Boolean literal (`true`, `false`) */
+  BOOL: 23,
+  /** Variable assignment (`=`, `+=`, `-=`, `*=`, `/=`) */
+  ASSIGNMENT: 24,
+  /** Method call open — internal */
+  METHODOPEN: 25,
+
+  /* ---- Twig-only token IDs (reserved; rules land in Session 3+) ---- */
+
+  /** Twig string-concatenation operator — `~` */
+  TILDE: 30,
+  /** Twig range operator — `..` */
+  RANGE: 31,
+  /** Twig test operator — `is` */
+  IS: 32,
+  /** Twig negated test operator — `is not` */
+  ISNOT: 33,
+  /** Twig shorthand ternary — `?:` */
+  QMARK: 34,
+  /** Twig null-coalescing operator — `??` */
+  NULLCOALESCE: 35,
+  /** Twig string-interpolation open — `#{` inside double-quoted strings */
+  INTERP_OPEN: 36,
+  /** Twig string-interpolation close — `}` matching `#{` */
+  INTERP_CLOSE: 37,
+
+  /** Unknown token */
+  UNKNOWN: 100
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@rhinostone/swig-twig",
+  "version": "2.0.0-alpha.3",
+  "description": "Twig frontend for the @rhinostone/swig-core template engine. Phase 3 of the multi-flavor architecture (see @rhinostone/swig #T16).",
+  "keywords": [
+    "template",
+    "templating",
+    "twig",
+    "swig",
+    "swig-twig",
+    "frontend"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gina-io/swig.git",
+    "directory": "packages/swig-twig"
+  },
+  "author": "Rhinostone <contact@gina.io>",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "engines": {
+    "node": ">=12"
+  },
+  "peerDependencies": {
+    "@rhinostone/swig-core": "2.0.0-alpha.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}