sjabloon 0.11.0 → 0.13.0

package/lib/core.js

@@ -8,14 +8,16 @@
  * backs every entry, so the diagnostics store below authenticates diagnostics
  * across all of them.
  */
+import { adopt, mint, relocate as relocateFault, store } from "waarmerk";
 import { compile, isDiagnostic as isXprsnDiagnostic, relocate as relocateXprsn } from "xprsn";
 
 /**
  * @import { SjabloonDiagnostic, SjabloonErrorCode, SjabloonFunctions, SjabloonRenderer, SjabloonValues } from './types.js'
+ * @import { Relocation, Store } from 'waarmerk'
+ * @import { XprsnErrorCode } from 'xprsn'
  * @template A
- * @typedef {(scope: any, acc: A, scratch?: any) => void} Node One compiled node: appends into
- *   `acc` and returns nothing. The third slot is a scratch local some editions declare as a
- *   parameter to save a `let`; callers pass two arguments.
+ * @typedef {(scope: any, acc: A) => void} Node One compiled node: appends into
+ *   `acc` and returns nothing.
  */
 
 /**
@@ -29,81 +31,54 @@ import { compile, isDiagnostic as isXprsnDiagnostic, relocate as relocateXprsn }
  * @typedef {any[]} Tok
  */
 
-const BLOCKED = /^(?:__proto__|constructor|prototype)$/;
-// Error -> the `names` set of the compile that threw it. The map's keys are
-// what authenticates a diagnostic module-wide; the value is the per-template
-// origin each renderer's own `isDiagnostic` compares against.
-/** @type {WeakMap<any, any>} */
-const DIAGNOSTICS = new WeakMap();
-const mark = DIAGNOSTICS.set.bind(DIAGNOSTICS);
-const owns = DIAGNOSTICS.has.bind(DIAGNOSTICS);
-const origin = DIAGNOSTICS.get.bind(DIAGNOSTICS);
+/**
+ * This module's identity, carrying its code union. Naming the union here is
+ * what puts every code below under `tsc`: waarmerk checks a code against the
+ * store it is thrown into, so one this module does not declare fails at the
+ * line that throws it rather than shipping — which is how SJABLOON_TOO_DEEP
+ * got out for two releases.
+ *
+ * The union is spelled with xprsn's beside this module's own, because most
+ * diagnostics here are xprsn errors translated into template coordinates.
+ * Saying so here is what makes `SjabloonDiagnostic.code` true by construction,
+ * and it keeps `SjabloonErrorCode` meaning what its siblings' unions mean: the
+ * codes this package mints. The store's value is the per-template origin each
+ * renderer's own `isDiagnostic` compares against.
+ *
+ * @type {Store<SjabloonErrorCode | XprsnErrorCode>}
+ */
+const diags = store("sjabloon");
 
 /**
  * Check whether an error was produced or translated by sjabloon.
  *
  * Every entry shares one core, so a diagnostic thrown through any of them
  * authenticates through all of them.
- *
- * @param {unknown} error Any thrown value.
- * @returns {error is SjabloonDiagnostic} Whether `error` is an authentic sjabloon diagnostic.
  */
-export const isDiagnostic = owns;
+export const isDiagnostic = diags.isDiagnostic;
 
-/**
- * Intrinsics captured at module load, exactly as `mark` is: a copy is built
- * from a captured prototype table rather than through the original's
- * `constructor`, so replacing a prototype's `constructor` cannot make
- * `relocate` mint an authenticated value that is not an Error. Only
- * `SyntaxError` is listed because `fault` mints nothing else; every other
- * class a sjabloon diagnostic can carry arrives via xprsn and is relocated by
- * xprsn above.
- */
-const DESCS = Object.getOwnPropertyDescriptors,
-  DEFINE = Object.defineProperties,
-  PROTO = Object.getPrototypeOf,
-  SYNTAX = SyntaxError.prototype;
-/** @type {(p: any) => (msg: string) => Error} */
-const kindOf = (p) => (p === SYNTAX ? SyntaxError : Error);
 /**
  * Copy a diagnostic into an embedder's coordinates.
  *
- * Relocation lives here, beside the authentication it has to satisfy: the copy
- * is registered in the same store as the original, under the original's origin,
- * so it passes `isDiagnostic` and the owning renderer's own `isDiagnostic`
- * alike. The original is never mutated, and every own field comes
- * across by descriptor — the frozen `blocks` context stays frozen and
- * non-writable — so a field added here is never a field an embedder forgets.
+ * Most diagnostics here are xprsn errors translated into template coordinates,
+ * and those are registered in both stores. Letting xprsn make that half of the
+ * copy is what keeps the copy registered in both — the same reason relocation
+ * lives with authentication in the first place. `adopt` with no fields then,
+ * not with `blocks`: the descriptors already carried that across, and defining
+ * it again would redefine a non-configurable property.
  *
  * @param {unknown} diag A diagnostic produced or translated by sjabloon.
- * @param {{ prefix?: string, offset?: number }} [opts] `prefix` is prepended to
- *   the message verbatim; `offset` shifts `start` and `end`.
+ * @param {Relocation} [opts]
  * @returns {SjabloonDiagnostic} The relocated copy.
  * @throws {TypeError} When `diag` is not a sjabloon diagnostic.
  */
-export const relocate = (diag, { prefix = "", offset = 0 } = {}) => {
-  if (!isDiagnostic(diag)) throw TypeError("Not a sjabloon diagnostic");
-  // Most diagnostics here are xprsn errors translated into template
-  // coordinates, and those are registered in both stores. Letting xprsn make
-  // that half of the copy is what keeps the copy registered in both — the same
-  // reason relocation lives with authentication in the first place. Bare
-  // `mark`, not `attach`: the descriptors already carried `blocks` across,
-  // and attach would redefine a non-configurable property.
-  if (isXprsnDiagnostic(diag)) {
-    const moved = relocateXprsn(diag, { prefix, offset });
-    return (mark(moved, origin(diag)), /** @type {SjabloonDiagnostic} */ (moved));
-  }
-  let d = /** @type {any} */ (diag),
-    props = DESCS(d),
-    copy = kindOf(PROTO(d))(prefix + d.message);
-  delete props.message;
-  delete props.stack;
-  if (props.start) {
-    props.start.value += offset;
-    props.end.value += offset;
-  }
-  DEFINE(copy, props);
-  return (mark(copy, origin(d)), /** @type {SjabloonDiagnostic} */ (copy));
+export const relocate = (diag, opts) => {
+  const d = /** @type {any} */ (diag);
+  return /** @type {any} */ (
+    isXprsnDiagnostic(d)
+      ? adopt(diags, relocateXprsn(d, opts), undefined, diags.origin(d))
+      : relocateFault(diags, d, opts)
+  );
 };
 
 // Linear scan into text/tag/raw tokens. Dashes hug braces (`{{- x -}}` trims;
@@ -120,38 +95,23 @@ const EMPTY = Object.freeze({});
 // Shared parser state; parsing is synchronous so this is safe.
 // LIT/VAL/RAW are the compiling profile's node builders — read only while
 // parsing, never at render time, so the hot path stays free of indirection.
-/** @type {Tok[]} */
-let tokens;
-/** @type {number} */
-let i;
-/** @type {SjabloonFunctions | undefined} */
-let fns;
-/** @type {Tok} */
-let last;
-/** @type {string[]} */
-let bound;
-/** @type {Set<string>} */
-let names;
+let /** @type {Tok[]} */ tokens, /** @type {Tok} */ last, /** @type {string} */ source;
+let /** @type {number} */ i;
+let /** @type {SjabloonFunctions | undefined} */ fns, /** @type {string[]} */ bound;
+// The compile's `tag`, read once per interpolation while parsing and never at
+// render time. Always callable, so the parse has no branch to take for the
+// embedders that do not ask: this one names nothing.
+let NO_TAG = () => undefined;
+let /** @type {(expr: string) => object | undefined} */ tagOf = NO_TAG;
+let /** @type {Set<string>} */ names, /** @type {Set<string>} */ functions;
 /** @type {{ name: string, start: number, end: number }[]} */
 let reads;
-/** @type {Set<string>} */
-let functions;
-/** @type {string} */
-let source;
 /** @type {{ type: string, start: number, end: number }[]} */
 let blocks;
-/** Nesting budget shared by `#if`/`#each`/`#elif` (see DEPTH). */
-/** @type {number} */
-let nest;
 // The profile's node builders. `any` rather than `Node<A>`: `make()` is generic
 // per edition, but these are module-level and shared across all three, so no
 // single A applies here.
-/** @type {any} */
-let LIT;
-/** @type {any} */
-let VAL;
-/** @type {any} */
-let RAW;
+let /** @type {any} */ LIT, /** @type {any} */ VAL, /** @type {any} */ RAW;
 let lexTriple = 1,
   lxRaw = 0,
   lxP = 0,
@@ -178,7 +138,8 @@ let takeScanned = (a) => {
   const r = +(lxB > lxP) & +(source[lxB - 1] === "-"),
     whole = source.slice(lxP, lxB - r),
     body = whole.trim(),
-    start = lxP + whole.length - whole.trimStart().length,
+    // search returns -1 on all-whitespace, so start sits on the last `{`.
+    start = lxP + whole.search(/\S/),
     end = lxB + 2 + lxRaw;
   // oxlint-disable-next-line no-unused-expressions
   lxL && trimPrev();
@@ -189,51 +150,37 @@ let takeScanned = (a) => {
 
 /** @param {number} [a] */
 let lexStep = (a = source.indexOf("{{", i)) => {
-  if (a < 0) return (tokens.push([0, source.slice(i)]), 0);
-  if (a > i) tokens.push([0, source.slice(i, a)]);
-  lxRaw = +(source[a + 2] === "{");
-  lxP = a + 2 + lxRaw;
-  lxL = +(source[lxP] === "-");
-  lxP += lxL;
-  findEnd(a);
-  if (lxB < 0) return (tokens.push([0, source.slice(a)]), 0);
-  takeScanned(a);
-  return 1;
-};
-
-let lex = () => {
-  tokens = [];
-  i = 0;
-  lexTriple = 1;
-  while (i < source.length && lexStep());
+  if (a >= 0) {
+    if (a > i) tokens.push([0, source.slice(i, a)]);
+    lxRaw = +(source[a + 2] === "{");
+    lxP = a + 2 + lxRaw;
+    lxL = +(source[lxP] === "-");
+    lxP += lxL;
+    findEnd(a);
+    if (lxB >= 0) return (takeScanned(a), 1);
+    // An opener with no closer is text from its own `{{` on: rewind to it and
+    // fall into the shared tail below.
+    i = a;
+  }
+  // Both dead ends end the scan the same way — the rest of the source is one
+  // final text token.
+  return (tokens.push([0, source.slice(i)]), 0);
 };
 
 let snap = () => Object.freeze(blocks.slice());
-// Block nesting is capped so a pathological template fails as a deterministic
-// SyntaxError at the offending opener, far below the native stack limit.
-const DEPTH = 256;
 /**
+ * Mint one block frame. Nesting is capped at 256 so a pathological template
+ * fails as a deterministic SyntaxError at the offending opener, far below the
+ * native stack limit.
+ *
  * @param {string} type
  * @param {Tok} t
  */
 let opener = (type, t) => {
   // oxlint-disable-next-line no-unused-expressions
-  nest < DEPTH || fault("Template too deeply nested", "SJABLOON_TOO_DEEP", t);
-  nest++;
+  blocks.length < 256 || fault("Template too deeply nested", "SJABLOON_TOO_DEEP", t);
   return Object.freeze({ type, start: t[2], end: t[3] });
 };
-/**
- * @template {object} E
- * @param {E} e
- * @param {any} context
- * @param {any} own The owning compile's `names` set, this diagnostic's origin.
- * @returns {E}
- */
-let attach = (e, context, own) => {
-  Object.defineProperty(e, "blocks", { value: context, enumerable: true });
-  mark(e, own);
-  return e;
-};
 /**
  * Throw a located compile-time diagnostic. `code` is typed to the published
  * union, so a code that is not declared in `types.d.ts` fails to compile here
@@ -242,24 +189,11 @@ let attach = (e, context, own) => {
  *
  * @param {string} msg
  * @param {SjabloonErrorCode} code
- * @param {any[]} [t] The token to point at; omitted for end-of-source faults.
+ * @param {any[]} [t] The token to point at; defaults to an end-of-source point.
  * @returns {never}
  */
-const fault = (
-  msg,
-  code,
-  t,
-  start = t == null ? source.length : t[2],
-  end = t == null ? source.length : t[3],
-) => {
-  const e = /** @type {SyntaxError & { code: SjabloonErrorCode, start: number, end: number }} */ (
-    SyntaxError(msg)
-  );
-  e.code = code;
-  e.start = start;
-  e.end = end;
-  throw attach(e, snap(), names);
-};
+const fault = (msg, code, t = [0, 0, source.length, source.length], start = t[2], end = t[3]) =>
+  mint(diags, SyntaxError, msg, { code, start, end, blocks: snap() }, names);
 /**
  * Re-locate a diagnostic thrown by a nested compile or render into this
  * template's coordinates, then rethrow it as ours. Always throws.
@@ -273,7 +207,7 @@ const fault = (
  */
 const translated = (e, start, context, own, guard = isXprsnDiagnostic) => {
   if (!guard(e)) throw e;
-  throw attach(relocateXprsn(e, { offset: start }), context, own);
+  throw adopt(diags, relocateXprsn(e, { offset: start }), { blocks: context }, own);
 };
 /**
  * @param {Tok} t
@@ -300,10 +234,11 @@ let run = (nodes, scope, acc) => {
 /**
  * @param {string} expr
  * @param {number} start
- * @param {any} context
+ * @param {any} [context] The block context this expression sits in; every
+ *   caller wants the frames as they stand at the call, so it defaults to them.
  * @returns {(v: any) => any}
  */
-let compileExpr = (expr, start, context) => {
+let compileExpr = (expr, start, context = snap()) => {
   // The compiling template's origin, captured now: the render-time catch below
   // runs long after the module-level `names` has moved on to other compiles.
   const own = names;
@@ -340,61 +275,64 @@ let compileExpr = (expr, start, context) => {
 };
 
 /**
- * @param {string} stop
+ * The shared else tail of `#if` and `#each`. An `{{#else}}` parses one more
+ * branch; with or without one, the tag standing here has to be the closer, and
+ * anything else is an unexpected tag either way — so both paths leave through
+ * the one check below, and the else branch is whatever was parsed or nothing.
+ *
+ * @param {string} close
  * @param {Node<any>[]} [nodes]
- */
-let closeTail = (stop, nodes = parse([stop])) =>
-  // oxlint-disable-next-line no-unused-expressions
-  (last[1] === stop || unexpected(last), nodes);
-
-// One `#if`/`#elif` link: parse its branch, then recurse on the chain tail.
-/**
- * @param {string} tag
- * @param {Tok} [t]
  * @returns {Node<any>[]}
  */
-let nestElif = (tag, t = last) => {
-  // Elif chains share the nest budget so they fail closed before the native
-  // stack, without appearing as extra `#if` frames in diagnostic context.
-  // oxlint-disable-next-line no-unused-expressions
-  nest < DEPTH || fault("Template too deeply nested", "SJABLOON_TOO_DEEP", t);
-  nest++;
-  const next = branch(compileExpr(tag.slice(6), t[4] + 6, snap()));
-  nest--;
-  return [next];
-};
-
-/** @param {string} tag @returns {Node<any>[]} */
-let elseChain = (tag) => {
-  if (tag.startsWith("#elif ")) return nestElif(tag);
-  if (tag === "#else") return closeTail("/if");
+let elseTail = (close, nodes = []) => {
   // oxlint-disable-next-line no-unused-expressions
-  tag === "/if" || unexpected(last);
-  return [];
+  last[1] === "#else" && (nodes = parse([close]));
+  return last[1] === close ? nodes : unexpected(last);
 };
 
 /**
+ * One `#if` branch and whatever hangs off it. An `{{#elif}}` link is itself a
+ * branch, so the chain tail recurses straight back in here rather than through
+ * a helper. The block `opener` mints for one is discarded, never pushed: an
+ * elif link is not an extra `#if` frame in diagnostic context and does not
+ * count toward the nesting cap. `t` doubles as the scratch slot for the link
+ * it builds.
+ *
  * @param {(v: any) => any} cond
+ * @param {Node<any>[]} [then]
+ * @param {any} [t]
+ * @param {any} [els]
  * @returns {Node<any>}
  */
-let branch = (cond) => {
-  const then = parse(["#elif", "#else", "/if"]);
-  const els = elseChain(last[1]);
-  return (scope, acc) => run(cond(scope) ? then : els, scope, acc);
-};
+let branch =
+  (
+    cond,
+    then = parse(["/if", "#elif", "#else"]),
+    t = last,
+    els = t[1].startsWith("#elif ")
+      ? (opener("elif", t), (t = branch(compileExpr(t[1].slice(6), t[4] + 6))), [t])
+      : elseTail("/if"),
+  ) =>
+  (scope, acc) =>
+    run(cond(scope) ? then : els, scope, acc);
 
 /**
+ * What one `#each` walks: the values themselves for an array, the own keys for
+ * an object. The caller has already asked whether the collection is an array —
+ * that answer decides the key shape too, so it is passed in rather than asked
+ * twice, and it is what tells the loop whether an element is a value or a key
+ * to index back through. No pair array is built: the key list is the walk.
+ *
  * @param {any} listValue
+ * @param {boolean} arr
+ * @returns {any[]}
  */
-let eachPairs = (listValue) => {
-  if (Array.isArray(listValue)) return listValue.slice();
-  if (listValue && typeof listValue === "object")
-    return Object.keys(listValue).map((k) => [listValue[k], k]);
-  return [];
-};
-
-let eachEmpty = () =>
-  last[1] === "#else" ? closeTail("/each") : last[1] === "/each" ? [] : unexpected(last);
+let eachPairs = (listValue, arr) =>
+  arr
+    ? listValue.slice()
+    : listValue && typeof listValue === "object"
+      ? Object.keys(listValue)
+      : [];
 
 /**
  * @param {Tok} t
@@ -404,7 +342,7 @@ let eachEmpty = () =>
  */
 let checkBinding = (t, tag, name, at) => {
   // oxlint-disable-next-line no-unused-expressions
-  BLOCKED.test(name) &&
+  /^(?:__proto__|constructor|prototype)$/.test(name) &&
     fault("Bad {{" + tag + "}}", "SJABLOON_BLOCKED_BINDING", t, at, at + name.length);
 };
 
@@ -422,7 +360,7 @@ let parseEach = (t, tag, nodes) => {
     idx = m[4],
     at = t[4] + tag.length - m[2].length;
   checkBinding(t, tag, name, at);
-  const list = compileExpr(m[1], t[4] + 6, snap());
+  const list = compileExpr(m[1], t[4] + 6);
   const mark = bound.length;
   bound.push(name);
   if (idx) {
@@ -430,23 +368,23 @@ let parseEach = (t, tag, nodes) => {
     bound.push(idx);
   }
   bound.push("loop");
-  const body = parse(["#else", "/each"]);
+  const body = parse(["/each", "#else"]);
   bound.length = mark;
-  const empty = eachEmpty();
+  const empty = elseTail("/each");
   blocks.pop();
-  nest--;
   nodes.push((scope, acc) => {
     const listValue = list(scope),
       arr = Array.isArray(listValue);
-    const pairs = eachPairs(listValue);
+    const pairs = eachPairs(listValue, arr);
     if (!pairs.length) return run(empty, scope, acc);
     pairs.forEach((x, j) => {
-      const item = arr ? x : x[0],
-        key = arr ? j : x[1];
       const child = Object.create(scope);
-      child[name] = item;
-      if (idx) child[idx] = key;
-      child["@"] = item;
+      // The loop variable and the `@` anchor name the same element, so one
+      // write lands in both slots. `x` is the element itself for an array and
+      // the own key to index back through for an object; the index variable,
+      // wanted only when the template declared one, is the mirror of that.
+      child[name] = child["@"] = arr ? x : listValue[x];
+      if (idx) child[idx] = arr ? j : x;
       child.loop = {
         index: j + 1,
         index0: j,
@@ -476,7 +414,7 @@ let emitLeaf = (t, nodes) => {
       "SJABLOON_RAW_TAG",
       t,
     );
-  nodes.push(RAW(compileExpr(t[1], t[4], snap())));
+  nodes.push(RAW(compileExpr(t[1], t[4])));
 };
 
 /**
@@ -487,9 +425,8 @@ let emitLeaf = (t, nodes) => {
 let emitBlock = (t, tag, nodes) => {
   if (tag.startsWith("#if ")) {
     blocks.push(opener("if", t));
-    nodes.push(branch(compileExpr(tag.slice(4), t[4] + 4, snap())));
+    nodes.push(branch(compileExpr(tag.slice(4), t[4] + 4)));
     blocks.pop();
-    nest--;
     return;
   }
   if (/^#each(?:\s|$)/.test(tag)) return parseEach(t, tag, nodes);
@@ -506,7 +443,7 @@ let emitTag = (t, tag, nodes) => {
   if (tag[0] === "!") return;
   if (tag[0] === "#") return emitBlock(t, tag, nodes);
   if (tag[0] === "/") unexpected(t);
-  nodes.push(VAL(compileExpr(t[1], t[4], snap())));
+  nodes.push(VAL(compileExpr(t[1], t[4]), tagOf(t[1])));
 };
 
 /**
@@ -522,6 +459,12 @@ let takeToken = (t, stops, nodes) => {
 };
 
 /**
+ * Parse until one of `stops` is reached, or to the end of the token stream.
+ *
+ * `stops[0]` is the block's closer and the rest are its interior tags, so the
+ * unclosed diagnostic below reads the head of the list rather than measuring
+ * its way to the tail. Membership is order-blind; keep the closer first.
+ *
  * @param {string[]} stops
  * @returns {Node<any>[]}
  */
@@ -531,20 +474,10 @@ let parse = (stops) => {
     if (takeToken(t, stops, nodes)) return nodes;
   }
   // oxlint-disable-next-line no-unused-expressions
-  stops.length && fault("Missing {{" + stops[stops.length - 1] + "}}", "SJABLOON_UNCLOSED_BLOCK");
+  stops.length && fault("Missing {{" + stops[0] + "}}", "SJABLOON_UNCLOSED_BLOCK");
   return nodes;
 };
 
-/**
- * Literal text node for the string editions: append `text` onto `acc.text`.
- *
- * @param {string} text
- * @returns {Node<{ text: string }>}
- */
-export const litNode = (text) => (scope, acc) => {
-  acc.text += text;
-};
-
 /**
  * Display text for one interpolated value — the scalar rule every edition and
  * the root `text()` join share. A valid `Date` renders as ISO 8601 UTC
@@ -605,7 +538,8 @@ export const display = (value) =>
  *
  * A profile is `[lit, val, raw, seed, take]`:
  *   lit(text)  node emitting one static text run
- *   val(expr)  node emitting a `{{ }}` interpolation
+ *   val(expr, tagged)  node emitting a `{{ }}` interpolation, carrying what
+ *              the compile's `tag` returned for it (undefined when untagged)
  *   raw(expr)  node emitting a `{{{ }}}` interpolation
  *   seed()     a fresh output accumulator, one per render
  *   take(acc)  the render's return value
@@ -615,7 +549,7 @@ export const display = (value) =>
  * @template T What one render returns.
  * @param {[
  *   lit: (text: string) => Node<A>,
- *   val: (expr: (scope: any) => any) => Node<A>,
+ *   val: (expr: (scope: any) => any, tagged: object | undefined) => Node<A>,
  *   raw: ((expr: (scope: any) => any) => Node<A>) | 0,
  *   seed: () => A,
  *   take: (acc: A) => T,
@@ -632,7 +566,7 @@ export let make = ([lit, val, raw, seed, take]) => {
   /**
    * @param {string} str
    * @param {SjabloonFunctions} [funcs]
-   * @param {{ bound?: Iterable<string> }} [opts]
+   * @param {{ bound?: Iterable<string>, tag?: (expr: string) => object | undefined }} [opts]
    * @returns {SjabloonRenderer<T>}
    */
   function template(str, funcs, opts) {
@@ -641,21 +575,27 @@ export let make = ([lit, val, raw, seed, take]) => {
     fns = funcs;
     // `$` (root) and `@` (current item) are engine-bound anchors, always in
     // scope, so they never count as caller-supplied `names` — and neither does
-    // anything the embedder declares bound. A loop, not a spread: the
+    // anything the embedder declares bound. `Array.from`, not a spread: the
     // bundler's transpile turns an iterable spread into a concat that would
-    // wrap a Set instead of unpacking it.
-    bound = ["$", "@"];
-    if (opts && opts.bound) for (const name of opts.bound) bound.push(name);
+    // wrap a Set instead of unpacking it. `Object(opts)` stands in for the
+    // missing-opts check; nothing iterable comes out of an empty string.
+    let { bound: declared = "", tag = NO_TAG } = Object(opts);
+    bound = ["$", "@"].concat(Array.from(/** @type {Iterable<string>} */ (declared)));
+    tagOf = tag;
     names = new Set();
     reads = [];
     functions = new Set();
     source = String(str);
     blocks = [];
-    nest = 0;
-    lex();
+    // The lexer's own state, then one linear pass: inline here because it runs
+    // exactly once per compile and the parser rewinds `i` straight after.
+    tokens = [];
+    i = 0;
+    lexTriple = 1;
+    while (i < source.length && lexStep());
     i = 0;
-    // Deeply nested blocks fail as SJABLOON_TOO_DEEP at DEPTH via opener(),
-    // including elif chains — well below the native stack.
+    // Deeply nested blocks fail as SJABLOON_TOO_DEEP at the cap in opener(),
+    // well below the native stack.
     let nodes = parse([]);
     // The trusted-scope render, and the one render body: the caller's chain
     // already carries the anchors, so no wrapper is created and nothing is
@@ -690,7 +630,7 @@ export let make = ([lit, val, raw, seed, take]) => {
     // `fault` and at render time by the closures `compileExpr` built. Captured
     // now — the module-level `names` moves on to the next compile.
     const o = names;
-    f.isDiagnostic = (/** @type {unknown} */ x) => origin(x) === o;
+    f.isDiagnostic = (/** @type {unknown} */ x) => diags.origin(x) === o;
     f.scoped = scoped;
     return f;
   }

package/lib/html.d.ts

@@ -1,5 +1,5 @@
 export * from "./types.js";
-import type { SjabloonFunctions, SjabloonRenderer, SjabloonValues } from "./types.js";
+import type { SjabloonRender, SjabloonTemplate } from "./types.js";
 
 /**
  * Compile a template once, render it many times to an HTML string.
@@ -7,15 +7,6 @@ import type { SjabloonFunctions, SjabloonRenderer, SjabloonValues } from "./type
  * `{{ expr }}` HTML-escapes (`& < > " '`) and `{{{ expr }}}` interpolates raw.
  * This is the only edition that knows what HTML is; the rest of sjabloon leaves
  * escaping to the output edge.
- *
- * @see SjabloonRenderer for `names`/`functions`, SjabloonScope for `$` and `@`.
- * @throws {SyntaxError} On malformed tags, unclosed blocks, or bad expressions.
  */
-export function template(
-  str: string,
-  funcs?: SjabloonFunctions,
-  opts?: { bound?: Iterable<string> },
-): SjabloonRenderer<string>;
-
-/** Compile and render in one go. Shorthand for `template(str, funcs)(values)`. */
-export function render(str: string, values?: SjabloonValues, funcs?: SjabloonFunctions): string;
+export const template: SjabloonTemplate<string>;
+export const render: SjabloonRender<string>;

package/lib/html.js

@@ -3,19 +3,21 @@
  * 0.6's behaviour, kept for templates that target HTML directly. Everything
  * else in sjabloon is output-neutral; escaping lives here and nowhere else.
  */
-import { display, litNode, make } from "./core.js";
+import { display, make } from "./core.js";
 
 /** @type {Record<string, string>} */
 const ESC = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" };
-/** @param {string} s Already display text — both call sites pass `display()`. */
-const esc = (s) => s.replace(/[&<>"']/g, (c) => ESC[c]);
 
 export { isDiagnostic, relocate } from "./core.js";
 
+// The string accumulator is this edition's own shape, so its profile is stated
+// here rather than named in the core: every node is shorter than an import of
+// it, and the core stays the parser alone. `{{ }}` escapes at the markup edge;
+// `{{{ }}}` is the same display text, verbatim.
 export const { template, render } = make([
-  litNode,
-  (expr) => (scope, acc, value) => ((value = expr(scope)), (acc.text += esc(display(value)))),
-  (expr) => (scope, acc, value) => ((value = expr(scope)), (acc.text += display(value))),
+  (text) => (scope, acc) => (acc.text += text),
+  (expr) => (scope, acc) => (acc.text += display(expr(scope)).replace(/[&<>"']/g, (c) => ESC[c])),
+  (expr) => (scope, acc) => (acc.text += display(expr(scope))),
   () => ({ text: "" }),
   (acc) => acc.text,
 ]);