@rohal12/spindle 0.51.4 → 0.52.1

package/dist/pkg/story-variables.js

@@ -1,3 +1,1126 @@
+//#region src/js-lexer.ts
+/** Transient name after `%`: an identifier, so `%3` is never a reference. */
+var TRANS_NAME_RE = /[A-Za-z_]\w*/y;
+/** An assignment operator: `=`, `+=`, `??=`, … but not `==` or `=>`. */
+var ASSIGN_OP_RE = /(?:\*\*|<<|>>>?|&&|\|\||\?\?|[-+*/%&|^])?=(?![=>])/y;
+/** Flags after the closing `/` of a regex literal. */
+var REGEX_FLAGS_RE = /\w*/y;
+/**
+* Characters of identifiers (with the `\u…` escapes they may contain) and
+* numbers. Surrogates stand for the astral identifier characters they encode.
+*/
+var WORD_CHAR_RE = /[\p{ID_Continue}$\u200c\u200d\\\ud800-\udfff]/u;
+/** An identifier, or the rest of one after a `$`, `_` or `@` sigil. */
+var IDENT_RE = /[\p{ID_Continue}$\u200c\u200d]*/uy;
+/** A sigil variable name: the whole identifier after the sigil. */
+var VAR_NAME_RE = /^\w+$/;
+/** What may start a property name after a `get`, `set`, … modifier. */
+var KEY_START_RE = /[\p{ID_Continue}$\\"'[*#]/u;
+var SPACE_RE = /\s/;
+var LINE_TERMINATOR_RE = /[\n\r\u2028\u2029]/;
+var LINE_TERMINATOR_G = /[\n\r\u2028\u2029]/g;
+/**
+* Keywords followed by an operand rather than an operator (a declaration's
+* binding counts as one: `const of of xs`, `let { _a: x } = o`).
+*/
+var OPERAND_KEYWORDS = new Set([
+	"await",
+	"case",
+	"const",
+	"delete",
+	"do",
+	"else",
+	"in",
+	"instanceof",
+	"let",
+	"new",
+	"return",
+	"throw",
+	"typeof",
+	"var",
+	"void",
+	"yield"
+]);
+/** Keywords whose parenthesised header is followed by a statement. */
+var HEADER_KEYWORDS = new Set([
+	"for",
+	"if",
+	"while",
+	"with"
+]);
+/** Keywords that a line break ends the statement after. */
+var RESTRICTED_KEYWORDS = new Set([
+	"break",
+	"continue",
+	"return"
+]);
+/** Words that may precede a property name in an object literal or class. */
+var MODIFIERS = new Set([
+	"async",
+	"get",
+	"set",
+	"static"
+]);
+/**
+* Scan the `"…"` or `'…'` string literal opening at `start`. `end` is the
+* index just past its closing quote, or `src.length` when it is unterminated
+* (`closed` false). A backslash escapes the character after it, so a quote
+* after an even run of backslashes closes the string and one after an odd
+* run does not.
+*/
+function scanStringLiteral(src, start) {
+	const quote = src.charAt(start);
+	let i = start + 1;
+	while (i < src.length) {
+		const c = src.charAt(i);
+		if (c === "\\") i += 2;
+		else if (c === quote) return {
+			end: i + 1,
+			closed: true
+		};
+		else i++;
+	}
+	return {
+		end: src.length,
+		closed: false
+	};
+}
+/**
+* Scan the regex literal (with flags) opening at `start`. `end` is the index
+* just past it; an unterminated one (`closed` false) ends at the line break
+* (escaped or not) or the end of the source.
+*/
+function scanRegex(src, start, cache) {
+	const pending = [];
+	const done = (end, closed) => {
+		if (cache) for (const at of pending) cache.regexes.set(at, end * 2 + +closed);
+		return {
+			end,
+			closed
+		};
+	};
+	let i = start + 1;
+	while (i < src.length) {
+		const c = src.charAt(i);
+		if (c === "\\") {
+			if (LINE_TERMINATOR_RE.test(src.charAt(i + 1))) return done(i + 1, false);
+			i += 2;
+			continue;
+		}
+		if (LINE_TERMINATOR_RE.test(c)) return done(i, false);
+		if (c === "[") {
+			i = scanRegexClass(src, i, cache);
+			if (src.charAt(i) !== "]") return done(i, false);
+			i++;
+			const known = cache?.regexes.get(i);
+			if (known !== void 0) return done(Math.floor(known / 2), known % 2 === 1);
+			pending.push(i);
+			continue;
+		}
+		if (c === "/") {
+			REGEX_FLAGS_RE.lastIndex = i + 1;
+			const flags = REGEX_FLAGS_RE.exec(src)?.[0].length ?? 0;
+			return done(i + 1 + flags, true);
+		}
+		i++;
+	}
+	return done(src.length, false);
+}
+/**
+* Index of the `]` closing the regex character class opening at `open`, or
+* of the line break (or the end of the source) that leaves it unterminated.
+* Every `[` in a class reads the rest of it the same way, so the result is
+* recorded for them too: scans of `/[/[/[…` from each `/` share one pass.
+*/
+function scanRegexClass(src, open, cache) {
+	const known = cache?.classes.get(open);
+	if (known !== void 0) return known;
+	const opens = [open];
+	let i = open + 1;
+	while (i < src.length) {
+		const c = src.charAt(i);
+		if (c === "\\") {
+			if (LINE_TERMINATOR_RE.test(src.charAt(i + 1))) {
+				i++;
+				break;
+			}
+			i += 2;
+			continue;
+		}
+		if (c === "]" || LINE_TERMINATOR_RE.test(c)) break;
+		if (c === "[" && cache) opens.push(i);
+		i++;
+	}
+	i = Math.min(i, src.length);
+	if (cache) for (const o of opens) cache.classes.set(o, i);
+	return i;
+}
+/**
+* The next index from `from` on where `find` matches (-1 for none), for
+* searches from increasing positions: a search from within the stretch the
+* last one covered has the same answer.
+*/
+function nextMatch(memo, from, find) {
+	if (memo && from >= memo.from && (memo.at < 0 || from <= memo.at)) return memo.at;
+	const at = find(from);
+	if (memo) {
+		memo.from = from;
+		memo.at = at;
+	}
+	return at;
+}
+/**
+* Index just past the comment opening at `start` (`//` or `/*`), or -1 for
+* an unterminated `/*` comment.
+*/
+function findCommentEnd(src, start, cache) {
+	if (src.charAt(start + 1) === "/") {
+		const end = nextLineBreak(src, start, cache);
+		return end < 0 ? src.length : end;
+	}
+	const end = nextMatch(cache?.commentClose, start + 2, (from) => src.indexOf("*/", from));
+	return end < 0 ? -1 : end + 2;
+}
+/** Next line break from `from` on (-1 for none). */
+function nextLineBreak(src, from, cache) {
+	return nextMatch(cache?.lineEnd, from, (at) => {
+		LINE_TERMINATOR_G.lastIndex = at;
+		return LINE_TERMINATOR_G.exec(src)?.index ?? -1;
+	});
+}
+/** Is there a line break between `from` and `to`? */
+function lineBreakIn(src, from, to, cache) {
+	if (!cache) return LINE_TERMINATOR_RE.test(src.slice(from, to));
+	const at = nextLineBreak(src, from, cache);
+	return at >= 0 && at < to;
+}
+/** Index just past the comment opening at `start` (`//` or `/*`). */
+function skipComment(src, start) {
+	const end = findCommentEnd(src, start);
+	return end < 0 ? src.length : end;
+}
+/** Index of the first character from `i` on that is no space or comment. */
+function skipTrivia(src, i) {
+	while (i < src.length) {
+		const c = src.charAt(i);
+		if (SPACE_RE.test(c)) i++;
+		else if (c === "/" && "/*".includes(src.charAt(i + 1))) i = skipComment(src, i);
+		else break;
+	}
+	return i;
+}
+/** Characters that a scan checkpoint follows (`checkpointKey`). */
+var CHECKPOINT_AFTER = new Set([
+	"}",
+	"\"",
+	"'",
+	"`",
+	"/",
+	"\n",
+	"\r",
+	"\u2028",
+	"\u2029",
+	" ",
+	"	"
+]);
+/**
+* How far into a scan its results start to be shared within brackets
+* (`checkpointKey`, `knownParen`). Most scans end sooner, so they don't pay
+* for recording results no other scan will use; a long one pays this much
+* before it can use what earlier scans recorded, which keeps scans from
+* many starts about linear.
+*/
+var SHARE_AFTER = 256;
+/** A frame result: it is still open at the end of the source. */
+var UNCLOSED = -1;
+/** A frame result: a lexical error inside it ends the scan. */
+var MALFORMED = -2;
+/** A frame result: the scan stops at index `s` inside it (`STOPPED - s`). */
+var STOPPED = -3;
+/** The closers whose search for their frame a frame result may depend on. */
+var CLOSERS = [
+	")",
+	"]",
+	"}"
+];
+var FRAME_KINDS = [
+	"block",
+	"object",
+	"class",
+	"template"
+];
+/**
+* Key of a frame result, for the frames whose code lexes the same whatever
+* surrounds them: braces (a block, an object literal, a class body), a
+* template literal and its interpolations. Undefined for parentheses and
+* square brackets, which a stray closer inside may close.
+*/
+function frameKey(f) {
+	const kind = f.interpolation ? 4 : FRAME_KINDS.indexOf(f.kind);
+	return kind < 0 ? void 0 : f.open * 5 + kind;
+}
+function createJsScanCache() {
+	return {
+		checkpoints: /* @__PURE__ */ new Map(),
+		stacks: /* @__PURE__ */ new Map(),
+		parens: /* @__PURE__ */ new Map(),
+		shareAfter: SHARE_AFTER,
+		braces: /* @__PURE__ */ new Map(),
+		brackets: /* @__PURE__ */ new Map(),
+		classes: /* @__PURE__ */ new Map(),
+		regexes: /* @__PURE__ */ new Map(),
+		lineEnd: {
+			from: Infinity,
+			at: -1
+		},
+		commentClose: {
+			from: Infinity,
+			at: -1
+		}
+	};
+}
+var newContext = () => ({
+	lookahead: true,
+	brackets: /* @__PURE__ */ new Map()
+});
+/** Index of the `]` matching the `[` at `open`, or `src.length`. */
+function matchBracket(src, open, ctx) {
+	let close = ctx.brackets.get(open);
+	if (close === void 0) {
+		const ahead = {
+			lookahead: false,
+			brackets: ctx.brackets
+		};
+		close = scan(src, {}, open + 1, 0, frame("expr", "]", open), ahead);
+		ctx.brackets.set(open, close);
+	}
+	return close;
+}
+/**
+* Is the code at `i`, just past a `%name`, the rest of an assignment target
+* and its operator: ` = 1`, `.a[b] += 2`, but not `== 1`, `=> 1` or `% 2`?
+*/
+function assignmentFollows(src, i, ctx) {
+	for (;;) {
+		i = skipTrivia(src, i);
+		const c = src.charAt(i);
+		if (c === "." && src.charAt(i + 1) !== ".") {
+			IDENT_RE.lastIndex = skipTrivia(src, i + 1);
+			if (!IDENT_RE.exec(src)?.[0]) return false;
+			i = IDENT_RE.lastIndex;
+		} else if (c === "[") {
+			i = matchBracket(src, i, ctx);
+			if (i >= src.length) return false;
+			i++;
+		} else break;
+	}
+	ASSIGN_OP_RE.lastIndex = i;
+	return ASSIGN_OP_RE.test(src);
+}
+function frame(kind, closer, open = -1) {
+	return {
+		kind,
+		closer,
+		open,
+		header: false,
+		operand: false,
+		ternary: 0,
+		interpolation: false
+	};
+}
+/**
+* Walk `src`, reporting code characters, literal text and variable
+* references to `handlers` in source order. Every character is reported
+* exactly once (a variable reference covers its sigil and name). Returns
+* `src.length`.
+*/
+function lexJs(src, handlers, goal = "expression") {
+	return scan(src, handlers, 0, 0, frame(goal === "statements" ? "block" : "expr", ""), newContext());
+}
+/**
+* Find where the code starting at `start` ends, lexing it as JavaScript:
+* braces, quotes and backticks inside string, template and regex literals and
+* comments don't count.
+*
+* Without `stop`, the code ends at the first `}` in code outside the
+* brackets it opened (the `}` closing a `{…}` around it); with `stop`, at
+* the first `{` in code, at any depth, for which `stop` holds. Returns the
+* index of that `}` or `{`.
+*
+* Returns -1 when there is no such end, or when the code before it is not
+* well-formed JavaScript as far as a lexer can tell: an unterminated string,
+* regex literal or block comment, or a quote directly after an identifier or
+* number (`don't`, but not `typeof'x'`). Callers fall back to a more lenient
+* reading there, so text that only looks like code is not swallowed by an
+* apostrophe or a stray quote.
+*/
+function findCodeEnd(src, start, { goal = "expression", stop, stopKey, cache } = {}) {
+	const strict = {
+		stop,
+		malformed: false,
+		stopped: false,
+		passed: []
+	};
+	strict.cache = cache;
+	if (cache && !stop) strict.braces = cache.braces;
+	if (cache && (!stop || stopKey !== void 0)) {
+		const kindKey = `${goal} ${stop ? `stop ${stopKey}` : "}"}`;
+		let checkpoints = cache.checkpoints.get(kindKey);
+		if (!checkpoints) cache.checkpoints.set(kindKey, checkpoints = /* @__PURE__ */ new Map());
+		strict.checkpoints = checkpoints;
+		let parens = cache.parens.get(kindKey);
+		if (!parens) cache.parens.set(kindKey, parens = /* @__PURE__ */ new Map());
+		strict.parens = parens;
+	}
+	const ctx = {
+		lookahead: true,
+		brackets: cache?.brackets ?? /* @__PURE__ */ new Map(),
+		strict
+	};
+	const end = scan(src, {}, start, 0, frame(goal === "statements" ? "block" : "expr", stop ? "" : "}", start - 1), ctx);
+	if (strict.checkpoints) {
+		const ended = stop ? strict.stopped : end < src.length;
+		const result = strict.malformed ? MALFORMED : ended ? end : UNCLOSED;
+		for (const at of strict.passed) strict.checkpoints.set(at, result);
+	}
+	if (strict.malformed) return -1;
+	if (stop) return strict.stopped ? end : -1;
+	return end < src.length ? end : -1;
+}
+/**
+* Scan from `start` within `outer`. Returns `src.length`, or the index of
+* the `]` closing an `outer` square bracket, or the index just past the
+* backtick closing an `outer` template literal.
+*
+* Nested brackets, template literals and their interpolations are frames
+* on a stack, not recursive calls: however deep the nesting, the scan
+* cannot overflow the call stack.
+*/
+function scan(src, handlers, start, nesting, outer, ctx) {
+	const frames = [outer];
+	const top = () => frames[frames.length - 1];
+	/**
+	* Indices of the open frames closed by `)`, `]` and `}` (above `outer`),
+	* innermost last: the frame a closer closes is found without walking the
+	* stack.
+	*/
+	const closers = {
+		")": [],
+		"]": [],
+		"}": []
+	};
+	const innermost = (c) => {
+		const list = closers[c];
+		return list.length ? list[list.length - 1] : 0;
+	};
+	let i = start;
+	let operandNext = true;
+	let stmtNext = outer.kind === "block";
+	let arrowBody = false;
+	let keyNext = false;
+	let word = "";
+	let afterDot = false;
+	let dots = 0;
+	let afterHeaderKeyword = false;
+	let lastPunct = "";
+	let lastKeyword = "";
+	let lineBreak = false;
+	/** The next `{` at this depth opens a function or class body. */
+	let pendingBody;
+	const strict = ctx.strict;
+	const braces = strict?.braces;
+	const stacks = strict?.checkpoints && strict.cache?.stacks;
+	/**
+	* With checkpoints, per open frame the id of the stack up to it, found
+	* when a checkpoint needs it: the kind and flags of each frame, and the
+	* conditional-expression count of each but the innermost (which changes
+	* only while it is innermost, and is part of the checkpoint state). How a
+	* scan goes on depends on these, not on where the frames opened.
+	*/
+	const stackIds = stacks ? [0] : void 0;
+	/** The id of the stack of open frames (`stackIds`). */
+	function stackId() {
+		let k = frames.length - 1;
+		while (stackIds[k] === void 0) k--;
+		for (k++; k < frames.length; k++) {
+			const f = frames[k];
+			const key = `${stackIds[k - 1]} ${frames[k - 1].ternary} ${f.kind} ${f.closer} ${+f.header}${+f.operand}${+f.interpolation}`;
+			let id = stacks.get(key);
+			if (id === void 0) stacks.set(key, id = stacks.size + 1);
+			stackIds[k] = id;
+		}
+		return stackIds[frames.length - 1];
+	}
+	/** A `{…}` frame result found in `braces`, to skip to. */
+	let skipTo;
+	const parens = strict?.parens;
+	const shareAfter = strict?.cache?.shareAfter ?? SHARE_AFTER;
+	/**
+	* With `parens`, per open frame and per closer in `CLOSERS`: the lowest
+	* frame index the closer looked for its frame at, while this frame or one
+	* opened in it was innermost. Below a frame's own index, the code in it
+	* depended on what is around it. A frame's entry takes in those of the
+	* frames opened in it as they close.
+	*/
+	const lowest = parens ? [[
+		Infinity,
+		Infinity,
+		Infinity
+	]] : void 0;
+	/**
+	* How many function or class bodies to come the scan has started, and with
+	* `parens`, that count when each open frame opened. Code in a `(…)` or
+	* `[…]` that starts one replaces the one to come, and the new one can't
+	* follow once the frame is closed: none is to come then.
+	*/
+	let bodyStarts = 0;
+	const startsAt = parens ? [0] : void 0;
+	/** A `(…)` or `[…]` frame result found in `parens`, to skip to. */
+	let parenTo;
+	/** The closer `c` looked for its frame and found index `k`. */
+	function lookedFor(c, k) {
+		if (!lowest) return;
+		const entry = lowest[lowest.length - 1];
+		const n = CLOSERS.indexOf(c);
+		if (k < entry[n]) entry[n] = k;
+	}
+	/** Take the entry of the frame at index `k` into the one below it. */
+	function foldLowest(k) {
+		const from = lowest[k];
+		const into = lowest[k - 1];
+		for (let n = 0; n < 3; n++) if (from[n] < into[n]) into[n] = from[n];
+	}
+	/** Key of a `(…)` or `[…]` frame result, but for the closers it met. */
+	const parenKey = (f) => (f.open * 3 + (f.closer === "]" ? 2 : +f.header)) * 8;
+	/**
+	* Record how the frame at index `k` ends, if it is a `(…)` or `[…]`, its
+	* `lowest` entry complete: under the closers that looked below it, which
+	* found nothing to close (else the frame was closed with them).
+	*/
+	function recordParen(k, result) {
+		const f = frames[k];
+		if (k === 0 || f.closer !== ")" && f.closer !== "]") return;
+		if (f.open - start < shareAfter) return;
+		let met = 0;
+		for (let n = 0; n < 3; n++) if (lowest[k][n] < k) met |= 1 << n;
+		parens.set(parenKey(f) + met, result);
+	}
+	/** Record how the open `(…)` and `[…]` frames end: the scan ends in them. */
+	function recordOpenParens(result) {
+		if (!lowest) return;
+		for (let k = frames.length - 1; k > 0; k--) {
+			recordParen(k, result);
+			foldLowest(k);
+		}
+	}
+	/**
+	* How an earlier scan found a `(…)` or `[…]` frame opening here to end,
+	* if it did: a result recorded under closers that find nothing to close
+	* around the frame here too. The frame is not open yet.
+	*/
+	function knownParen(f) {
+		if (!parens || f.open - start < shareAfter) return void 0;
+		const at = [
+			Math.max(innermost(")"), innermost("}")),
+			Math.max(innermost("]"), innermost("}")),
+			innermost("}")
+		];
+		let stray = 0;
+		for (let n = 0; n < 3; n++) {
+			const k = at[n];
+			if (k === 0 || n < 2 && frames[k].closer !== CLOSERS[n]) stray |= 1 << n;
+		}
+		const key = parenKey(f);
+		for (let met = stray;; met = met - 1 & stray) {
+			const result = parens.get(key + met);
+			if (result !== void 0) {
+				for (let n = 0; n < 3; n++) if (met & 1 << n) lookedFor(CLOSERS[n], at[n]);
+				return result;
+			}
+			if (met === 0) return void 0;
+		}
+	}
+	/** Record how the open frames end, when the scan ends in them. */
+	function recordOpen(result) {
+		if (!braces) return;
+		for (let k = 1; k < frames.length; k++) record(frames[k], result);
+	}
+	/** Record how a frame ends. */
+	function record(f, result) {
+		const key = braces && frameKey(f);
+		if (key !== void 0) braces.set(key, result);
+	}
+	/** How an earlier scan found the frame `f` to end, if it did. */
+	const known = (f) => {
+		const key = braces && frameKey(f);
+		return key === void 0 ? void 0 : braces.get(key);
+	};
+	/** End a strict scan at a lexical error. */
+	const malformed = () => {
+		recordOpen(MALFORMED);
+		recordOpenParens(MALFORMED);
+		strict.malformed = true;
+		return src.length;
+	};
+	function push(f) {
+		stackIds?.push(void 0);
+		closers[f.closer]?.push(frames.length);
+		frames.push(f);
+		lowest?.push([
+			Infinity,
+			Infinity,
+			Infinity
+		]);
+		startsAt?.push(bodyStarts);
+	}
+	/**
+	* Just past a token or a space, line break or comment, but not within a
+	* word: the key of the position and the whole scan state there, the open
+	* frames included, which decide how the scan goes on (or undefined
+	* elsewhere). No word is being read there, and the character before is no
+	* word character, so a quote after it starts a string in any scan.
+	*
+	* Within brackets too, once the scan is long (`SHARE_AFTER`). Scans that
+	* never passed such a point in the same state each ran on to the end of
+	* the source, so many of them took quadratic time: inside an unclosed `(`
+	* in `{(}{(}{(…` (there was no point within brackets), or after the regex
+	* literals of `{a'</a </p>…` (there was no point after a space).
+	*/
+	function checkpointKey() {
+		const ternary = top().ternary;
+		if (ternary > 3 || !CHECKPOINT_AFTER.has(src.charAt(i - 1)) || frames.length > 1 && i - start < shareAfter) return;
+		let state = ternary;
+		if (operandNext) state |= 4;
+		if (stmtNext) state |= 8;
+		if (keyNext) state |= 16;
+		if (pendingBody) {
+			state |= pendingBody.frame.kind === "class" ? 32 : 64;
+			if (pendingBody.frame.operand) state |= 128;
+		}
+		if (arrowBody) state |= 256;
+		if (afterDot) state |= 512;
+		if (afterHeaderKeyword) state |= 1024;
+		if (lineBreak) state |= 2048;
+		if (RESTRICTED_KEYWORDS.has(lastKeyword)) state |= 4096;
+		if (lastPunct === "=") state |= 8192;
+		if (lastPunct === ".") state |= Math.min(dots, 4) << 14;
+		const at = i * (1 << 17) + state;
+		if (frames.length === 1) return at;
+		const body = pendingBody ? frames.length - pendingBody.depth : "";
+		return `${at} ${stackId()} ${body}`;
+	}
+	/**
+	* May a string literal follow the word just read (`word`, or a variable
+	* reference) with nothing between? Only after a keyword taking an operand
+	* (`typeof'x'`, `case"a"`), `of` in a `for` header, or a modifier before a
+	* property name (`static'x'`, `get"y"() {}`); elsewhere the quote is an
+	* apostrophe (`don't`), and the text is no JavaScript.
+	*/
+	function stringMayFollowWord() {
+		return OPERAND_KEYWORDS.has(word) || word === "of" && top().header || keyNext && MODIFIERS.has(word);
+	}
+	/** Close the frames from index `k` on. */
+	function truncate(k) {
+		if (lowest) {
+			for (let j = frames.length - 1; j >= k; j--) foldLowest(j);
+			lowest.length = k;
+			startsAt.length = k;
+		}
+		frames.length = k;
+		if (stackIds) stackIds.length = k;
+		for (const list of Object.values(closers)) while (list.length && list[list.length - 1] >= k) list.pop();
+		if (pendingBody && pendingBody.depth > k) pendingBody = void 0;
+	}
+	const code = (ch, index) => handlers.code?.(ch, index, nesting);
+	const literal = (text, index) => handlers.literal?.(text, index, nesting);
+	/** Literal text from `from` to `to`, sliced only for a handler. */
+	const literalSpan = (from, to) => handlers.literal?.(src.slice(from, to), from, nesting);
+	/** Track the word just read (`i` is the index just past it). */
+	function endWord() {
+		if (!word) return;
+		const keyword = afterDot || keyNext ? "" : word;
+		const inOperandPosition = operandNext && !stmtNext;
+		operandNext = OPERAND_KEYWORDS.has(keyword) || keyword === "of" && top().header && !operandNext;
+		afterHeaderKeyword = HEADER_KEYWORDS.has(keyword);
+		if (keyword === "function" || keyword === "class") {
+			const body = frame(keyword === "class" ? "class" : "block", "}");
+			body.operand = inOperandPosition;
+			pendingBody = {
+				depth: frames.length,
+				frame: body
+			};
+			bodyStarts++;
+		}
+		keyNext = keyNext && MODIFIERS.has(word) && KEY_START_RE.test(src.charAt(skipTrivia(src, i)));
+		stmtNext = keyword === "else" || keyword === "do" || keyword === "async" && stmtNext;
+		arrowBody = false;
+		afterDot = false;
+		lastPunct = "";
+		lastKeyword = keyword;
+		lineBreak = false;
+		word = "";
+	}
+	/** A string, template or regex literal, or a variable reference, ended. */
+	function endOperand() {
+		endWord();
+		operandNext = false;
+		stmtNext = false;
+		arrowBody = false;
+		keyNext = false;
+		afterHeaderKeyword = false;
+		afterDot = false;
+		lastPunct = "";
+		lastKeyword = "";
+		lineBreak = false;
+	}
+	/** Track an operator token: `operandNext` tells what may follow it. */
+	function endPunct(punct, nextIsOperand) {
+		operandNext = nextIsOperand;
+		stmtNext = false;
+		arrowBody = false;
+		keyNext = false;
+		afterDot = punct === "." && !nextIsOperand;
+		afterHeaderKeyword = false;
+		lastPunct = punct;
+		lastKeyword = "";
+		lineBreak = false;
+	}
+	/**
+	* A line break between tokens. After `return`, `break` or `continue` it
+	* ends the statement (ASI): `return⏎function f() {}` declares `f`.
+	*/
+	function lineBreakSeen() {
+		lineBreak = true;
+		if (RESTRICTED_KEYWORDS.has(lastKeyword)) {
+			operandNext = true;
+			stmtNext = true;
+			lastKeyword = "";
+		}
+	}
+	function open(f) {
+		push(f);
+		stmtNext = f.kind === "block";
+		keyNext = f.kind === "object" || f.kind === "class";
+	}
+	function openBrace() {
+		let f;
+		if (pendingBody?.depth === frames.length) {
+			f = pendingBody.frame;
+			pendingBody = void 0;
+		} else if (!operandNext || stmtNext || arrowBody) f = frame("block", "}");
+		else {
+			f = frame("object", "}");
+			f.operand = true;
+		}
+		f.open = i;
+		endPunct("{", true);
+		const end = known(f);
+		if (end === void 0) open(f);
+		else skipTo = {
+			frame: f,
+			end
+		};
+	}
+	/** State after the `}` closing `closed`, a block or literal. */
+	function afterBrace(closed) {
+		if (closed.operand) endPunct("}", false);
+		else {
+			endPunct("}", true);
+			stmtNext = top().kind === "block";
+			keyNext = top().kind === "class";
+		}
+	}
+	/**
+	* Close the innermost frame that `c` closes; a stray closer, with no such
+	* frame within the innermost braces (a block, an object literal, a class
+	* body or an interpolation), is ignored. So a stray `)` or `]` never
+	* closes the braces around it, and how a `{…}` ends depends only on the
+	* code inside it.
+	*/
+	function close(c) {
+		const k = Math.max(innermost(c), innermost("}"));
+		lookedFor(c, k);
+		if (k === 0 || frames[k].closer !== c) {
+			endPunct(c, c === "}");
+			return;
+		}
+		const closed = frames[k];
+		if (lowest && c !== "}") {
+			for (let j = frames.length - 1; j > k; j--) foldLowest(j);
+			const bodyStarted = bodyStarts !== startsAt[k];
+			recordParen(k, i * 2 + +bodyStarted);
+		}
+		truncate(k);
+		if (c === "]" && !ctx.lookahead) ctx.brackets.set(closed.open, i);
+		if (c === ")") {
+			endPunct(c, closed.header);
+			stmtNext = closed.header;
+		} else if (c === "]") endPunct(c, false);
+		else {
+			record(closed, i);
+			afterBrace(closed);
+		}
+	}
+	function trackCode(c) {
+		if (WORD_CHAR_RE.test(c)) {
+			word += c;
+			return;
+		}
+		endWord();
+		if (LINE_TERMINATOR_RE.test(c)) lineBreakSeen();
+		if (SPACE_RE.test(c)) return;
+		const t = top();
+		switch (c) {
+			case "(":
+			case "[": {
+				const f = frame("expr", c === "(" ? ")" : "]", i);
+				f.header = c === "(" && afterHeaderKeyword;
+				endPunct(c, true);
+				const result = knownParen(f);
+				if (result === void 0) open(f);
+				else parenTo = {
+					frame: f,
+					result
+				};
+				break;
+			}
+			case "{":
+				openBrace();
+				break;
+			case ")":
+			case "]":
+			case "}":
+				close(c);
+				break;
+			case ".":
+				dots = lastPunct === "." ? dots + 1 : 1;
+				endPunct(c, dots === 3);
+				break;
+			case ";":
+				endPunct(c, true);
+				stmtNext = t.kind === "block";
+				keyNext = t.kind === "class";
+				break;
+			case ",":
+				endPunct(c, true);
+				keyNext = t.kind === "object";
+				break;
+			case "?":
+				endPunct(c, true);
+				t.ternary++;
+				break;
+			case ":":
+				endPunct(c, true);
+				if (t.ternary > 0) t.ternary--;
+				else stmtNext = t.kind === "block";
+				break;
+			case "#":
+				endPunct(c, false);
+				afterDot = true;
+				break;
+			case "*": {
+				const key = keyNext;
+				endPunct(c, true);
+				keyNext = key;
+				break;
+			}
+			case ">": {
+				const arrow = lastPunct === "=";
+				endPunct(c, true);
+				arrowBody = arrow;
+				break;
+			}
+			default: endPunct(c, true);
+		}
+	}
+	while (i < src.length) {
+		const ch = src.charAt(i);
+		const checkpoints = strict?.checkpoints;
+		const key = checkpoints && checkpointKey();
+		if (key !== void 0) {
+			const known = checkpoints.get(key);
+			if (known === void 0) strict.passed.push(key);
+			else if (frames.length > 1 && known < 0) {
+				strict.malformed = known === MALFORMED;
+				return src.length;
+			} else if (known === MALFORMED) return malformed();
+			else if (known === UNCLOSED) {
+				i = src.length;
+				break;
+			} else {
+				strict.stopped = true;
+				return known;
+			}
+		}
+		if (top().kind === "template") {
+			if (ch === "\\") {
+				literal(src.slice(i, i + 2), i);
+				i += 2;
+			} else if (ch === "`") {
+				literal(ch, i);
+				if (frames.length === 1) return i + 1;
+				record(top(), i);
+				i++;
+				truncate(frames.length - 1);
+				endOperand();
+			} else if (ch === "$" && src.charAt(i + 1) === "{") {
+				const f = frame("expr", "}", i);
+				f.interpolation = true;
+				const end = known(f);
+				if (end === MALFORMED) return malformed();
+				if (end === UNCLOSED) {
+					i = src.length;
+					break;
+				}
+				if (end !== void 0) {
+					i = end + 1;
+					continue;
+				}
+				literal("${", i);
+				i += 2;
+				nesting++;
+				endPunct("{", true);
+				open(f);
+			} else {
+				literal(ch, i);
+				i++;
+			}
+			continue;
+		}
+		if (ch === "\"" || ch === "'") {
+			if (strict && i > start && WORD_CHAR_RE.test(src.charAt(i - 1))) {
+				if (!stringMayFollowWord()) return malformed();
+			}
+			endWord();
+			const { end, closed } = scanStringLiteral(src, i);
+			if (strict && !closed) return malformed();
+			literalSpan(i, end);
+			i = end;
+			endOperand();
+			continue;
+		}
+		if (ch === "`") {
+			endWord();
+			const f = frame("template", "`", i);
+			const end = known(f);
+			if (end === MALFORMED) return malformed();
+			if (end === UNCLOSED) {
+				i = src.length;
+				break;
+			}
+			if (end !== void 0) {
+				i = end + 1;
+				endOperand();
+				continue;
+			}
+			literal(ch, i);
+			push(f);
+			i++;
+			continue;
+		}
+		if (ch === "{" && strict?.stop?.(i)) {
+			recordOpenParens(STOPPED - i);
+			strict.stopped = true;
+			return i;
+		}
+		if (ch === "}") {
+			const k = innermost("}");
+			lookedFor("}", k);
+			if (frames[k].interpolation) {
+				endWord();
+				record(frames[k], i);
+				truncate(k);
+				nesting--;
+				literal(ch, i);
+				i++;
+				continue;
+			}
+		}
+		if (ch === "/") {
+			endWord();
+			const next = src.charAt(i + 1);
+			if (next === "/" || next === "*") {
+				let end = findCommentEnd(src, i, strict?.cache);
+				if (end < 0) {
+					if (strict) return malformed();
+					end = src.length;
+				}
+				literalSpan(i, end);
+				if (next === "*" && lineBreakIn(src, i, end, strict?.cache)) lineBreakSeen();
+				i = end;
+				continue;
+			}
+			if (operandNext) {
+				const { end, closed } = scanRegex(src, i, strict?.cache);
+				if (strict && !closed) return malformed();
+				literalSpan(i, end);
+				i = end;
+				endOperand();
+				continue;
+			}
+		}
+		if (!word && lineBreak && !operandNext && top().kind === "class") {
+			IDENT_RE.lastIndex = i;
+			const next = IDENT_RE.exec(src)?.[0];
+			if (next && next !== "in" && next !== "instanceof") keyNext = true;
+		}
+		if (ch === "@" || (ch === "$" || ch === "_") && !word) {
+			endWord();
+			IDENT_RE.lastIndex = i + 1;
+			const name = IDENT_RE.exec(src)?.[0] ?? "";
+			if (VAR_NAME_RE.test(name) && !isPropertyName(ch, i + 1 + name.length)) {
+				handlers.variable?.(ch, name, i, nesting);
+				i += 1 + name.length;
+				endOperand();
+				continue;
+			}
+		}
+		if (ch === "%") {
+			endWord();
+			TRANS_NAME_RE.lastIndex = i + 1;
+			const name = TRANS_NAME_RE.exec(src)?.[0];
+			if (name) {
+				const end = i + 1 + name.length;
+				if (operandNext || lineBreak && ctx.lookahead && assignmentFollows(src, end, ctx)) {
+					handlers.variable?.("%", name, i, nesting);
+					i = end;
+					endOperand();
+					continue;
+				}
+			}
+		}
+		if ((ch === "+" || ch === "-") && src.charAt(i + 1) === ch) {
+			endWord();
+			const postfix = !operandNext && !lineBreak;
+			code(ch, i);
+			code(ch, i + 1);
+			i += 2;
+			endPunct(ch, !postfix);
+			continue;
+		}
+		if (ch === "?") {
+			const next = src.charAt(i + 1);
+			if (next === "?" || next === "." && !/\d/.test(src.charAt(i + 2))) {
+				endWord();
+				code(ch, i);
+				code(next, i + 1);
+				i += 2;
+				dots = 1;
+				endPunct(next, next === "?");
+				continue;
+			}
+		}
+		if (ch === outer.closer && frames.length === 1) break;
+		trackCode(ch);
+		if (skipTo) {
+			const { frame: skipped, end } = skipTo;
+			skipTo = void 0;
+			if (end === MALFORMED) return malformed();
+			if (end === UNCLOSED) {
+				i = src.length;
+				break;
+			}
+			i = end;
+			afterBrace(skipped);
+			i++;
+			continue;
+		}
+		if (parenTo) {
+			const { frame: skipped, result } = parenTo;
+			parenTo = void 0;
+			if (result === MALFORMED) return malformed();
+			if (result === UNCLOSED) {
+				i = src.length;
+				break;
+			}
+			if (result <= STOPPED) {
+				recordOpenParens(result);
+				strict.stopped = true;
+				return STOPPED - result;
+			}
+			i = Math.floor(result / 2);
+			if (result % 2 === 1) pendingBody = void 0;
+			if (skipped.closer === ")") {
+				endPunct(")", skipped.header);
+				stmtNext = skipped.header;
+			} else endPunct("]", false);
+			i++;
+			continue;
+		}
+		code(ch, i);
+		i++;
+	}
+	if (i >= src.length) {
+		recordOpen(UNCLOSED);
+		recordOpenParens(UNCLOSED);
+	}
+	if (!ctx.lookahead) {
+		for (const f of frames) if (f.closer === "]") ctx.brackets.set(f.open, i);
+	}
+	return Math.min(i, src.length);
+	/**
+	* Is the `$`/`_` word ending at `end` a property name: after `.`, a key
+	* in an object literal (`{ _id: 1 }`, `{ _m() {} }`) or a member name in
+	* a class body?
+	*/
+	function isPropertyName(sigil, end) {
+		if (afterDot) return true;
+		if (!keyNext || sigil === "@") return false;
+		if (top().kind === "class") return true;
+		const next = src.charAt(skipTrivia(src, end));
+		return next === ":" || next === "(";
+	}
+}
+//#endregion
+//#region src/markup/code-attributes.ts
+/**
+* Attributes whose value is code with braces of its own, not text: event
+* handlers (`on…`, JavaScript), `pattern` (a regular expression, as in
+* `\p{L}{2,3}`) and `srcdoc` (an HTML document, with its own scripts and
+* styles). Their braces are code, so they are not read as markup: only
+* sigil references (`{$x}`, `{_x}`, `{@x}`, `{%x}` and expressions starting
+* with one) are resolved, and any other `{` is literal.
+*/
+function isCodeAttribute(name) {
+	const lower = name.toLowerCase();
+	return lower.startsWith("on") || lower === "pattern" || lower === "srcdoc";
+}
+/**
+* Split a code attribute value into literal text and its `{…}` blocks that
+* start with a sigil. Braces inside strings don't close a block; an
+* unclosed block, any other brace and backslashes are text. A block whose
+* sigil is not followed by a word character (`{$(…)}`) is code, kept
+* verbatim: not resolved, and not decoded like text.
+*/
+function splitSigilTemplate(template) {
+	const parts = [];
+	const memo = createScanMemo();
+	let text = "";
+	let i = 0;
+	while (i < template.length) {
+		const brace = template.indexOf("{", i);
+		if (brace === -1) {
+			text += template.slice(i);
+			break;
+		}
+		text += template.slice(i, brace);
+		i = brace + 1;
+		const sigil = template[i];
+		const end = sigil === "$" || sigil === "_" || sigil === "@" || sigil === "%" ? scanBalancedBrace(template, i, memo) : -1;
+		if (end === -1) {
+			text += "{";
+			continue;
+		}
+		if (text) parts.push({ text });
+		text = "";
+		const block = template.slice(i, end);
+		parts.push(/^.\w/.test(block) ? { expr: block } : { verbatim: `{${block}}` });
+		i = end + 1;
+	}
+	if (text) parts.push({ text });
+	return parts;
+}
+//#endregion
 //#region src/markup/tokenizer.ts
 /** Tag name must start with a letter (covers standard and custom elements). */
 var VALID_TAG_START = /[a-zA-Z]/;
@@ -18,6 +1141,20 @@ var HTML_VOID_TAGS = new Set([
 	"track",
 	"wbr"
 ]);
+/** Variable sigils: story ($), temporary (_), local (@), transient (%). */
+var SIGIL_CHARS = new Set([
+	"$",
+	"_",
+	"@",
+	"%"
+]);
+/**
+* Characters other than a sigil that open an expression after `{`:
+* `{(Math.max($a, 0))}`, `{!$done}`. Other characters that can start an
+* expression (quotes, digits, `[`, `-`) are left out, because braces around
+* them are common as literal text (JSON, regex quantifiers, `{[[link]]}`).
+*/
+var EXPRESSION_START = new Set(["(", "!"]);
 /** Macros whose body is JavaScript source, kept verbatim instead of tokenized. */
 var RAW_BODY_MACROS = new Set(["do"]);
 /**
@@ -84,7 +1221,7 @@ function parseSelectors(input, startIdx) {
 		while (i < input.length) if (/[a-zA-Z0-9_-]/.test(input[i])) {
 			name += input[i];
 			i++;
-		} else if (input[i] === "{" && (input[i + 1] === "$" || input[i + 1] === "_" || input[i + 1] === "@")) {
+		} else if (input[i] === "{" && SIGIL_CHARS.has(input[i + 1])) {
 			const braceStart = i;
 			i += 2;
 			while (i < input.length && /[\w.]/.test(input[i])) i++;
@@ -109,10 +1246,48 @@ function parseSelectors(input, startIdx) {
 * Parse HTML attributes from a string starting at position j.
 * Returns the attributes and the position after the last attribute.
 */
-function parseHtmlAttributes(input, j) {
+function parseHtmlAttributes(input, j, memo) {
 	const attributes = {};
+	const seen = /* @__PURE__ */ new Set();
+	return {
+		attributes,
+		endIdx: scanAttributes(input, j, memo, (name, value) => {
+			const lower = name.toLowerCase();
+			if (seen.has(lower)) return;
+			seen.add(lower);
+			Object.defineProperty(attributes, name, {
+				value,
+				enumerable: true,
+				writable: true,
+				configurable: true
+			});
+		})
+	};
+}
+/**
+* Scan the attributes of a tag from position j, handing each to `add` when
+* given. Returns the position after the last attribute.
+*
+* Where the attributes end depends only on where an attribute starts, so
+* without `add` the result is recorded for every attribute start passed (in
+* `memo.tag`) and a recorded one is used instead of scanning on. An unquoted
+* value takes in a `<`, so in `<a x=<a x=<a x=…` each opener's scan would
+* otherwise run over all the openers after it, taking quadratic time. A tag
+* whose attributes end in its `>` is consumed, so collecting the attributes
+* of those (with `add`, unrecorded) reads each character once.
+*/
+function scanAttributes(input, j, memo, add) {
+	const passed = [];
 	while (j < input.length) {
 		while (j < input.length && /\s/.test(input[j])) j++;
+		if (!add) {
+			const known = memo.tag.get(j);
+			if (known !== void 0) {
+				j = known;
+				break;
+			}
+			passed.push(j);
+		}
 		if (j >= input.length || input[j] === ">" || input[j] === "/" && input[j + 1] === ">") break;
 		const attrStart = j;
 		while (j < input.length && /[a-zA-Z0-9_\-:@]/.test(input[j])) j++;
@@ -127,31 +1302,180 @@ function parseHtmlAttributes(input, j) {
 				const quote = input[j];
 				j++;
 				const valStart = j;
-				while (j < input.length) {
-					if (input[j] === "{") {
-						const closeIdx = scanBalancedBrace(input, j + 1);
-						if (closeIdx !== -1) {
-							j = closeIdx + 1;
-							continue;
-						}
-					} else if (input[j] === quote) break;
-					j++;
-				}
-				attributes[attrName] = input.slice(valStart, j);
+				j = scanQuotedValue(input, j, quote, isCodeAttribute(attrName), memo);
+				add?.(attrName, input.slice(valStart, j));
 				if (j < input.length) j++;
 			} else {
 				const valStart = j;
-				while (j < input.length && /[^\s>]/.test(input[j])) j++;
-				attributes[attrName] = input.slice(valStart, j);
+				const run = memo.unquoted;
+				if (j < run.from || j > run.to) {
+					run.from = j;
+					while (j < input.length && /[^\s>]/.test(input[j])) j++;
+					run.to = j;
+				}
+				j = run.to;
+				add?.(attrName, input.slice(valStart, j));
+			}
+		} else add?.(attrName, "");
+	}
+	for (const at of passed) memo.tag.set(at, j);
+	return j;
+}
+/**
+* Index of the quote ending the attribute value that starts at `j`, or the
+* end of the input. A `{…}` interpolation in it is skipped whole, so quotes
+* inside it don't end the value. A code attribute's value is no markup
+* (`isCodeAttribute`): only `{` and a sigil open a reference, other braces
+* and backslashes are text, as `splitSigilTemplate` reads them.
+*
+* The value reads the same from just past an interpolation, however the scan
+* got there, so the end is recorded there (in `memo.value`), and a recorded
+* one is used. An unclosed value that skips interpolations to the end of
+* the input (`<a x="}<a x={<a x="}…`) is then read once, not once per tag.
+*/
+function scanQuotedValue(input, j, quote, code, memo) {
+	const variant = (quote === "\"" ? 0 : 2) + (code ? 1 : 0);
+	const passed = [];
+	let checkpoint = true;
+	while (j < input.length) {
+		if (checkpoint) {
+			const known = memo.value.get(j * 4 + variant);
+			if (known !== void 0) {
+				j = known;
+				break;
+			}
+			passed.push(j * 4 + variant);
+			checkpoint = false;
+		}
+		if (!code && input[j] === "\\") {
+			let k = j + 1;
+			while (input[k] === "\\") k++;
+			j = (input[k] === "{" || input[k] === "}") && (k - j) % 2 === 1 ? k + 1 : k;
+			continue;
+		}
+		if (input[j] === "{") {
+			const closeIdx = !code ? scanBlockClose(input, j, memo) : SIGIL_CHARS.has(input[j + 1]) ? scanBalancedBrace(input, j + 1, memo) : -1;
+			if (closeIdx !== -1) {
+				j = closeIdx + 1;
+				checkpoint = true;
+				continue;
 			}
-		} else attributes[attrName] = "";
+		} else if (input[j] === quote) break;
+		j++;
 	}
+	for (const at of passed) memo.value.set(at, j);
+	return j;
+}
+function createScanMemo() {
 	return {
-		attributes,
-		endIdx: j
+		code: /* @__PURE__ */ new Map(),
+		js: createJsScanCache(),
+		brace: /* @__PURE__ */ new Map(),
+		template: /* @__PURE__ */ new Map(),
+		templateText: /* @__PURE__ */ new Map(),
+		name: {
+			from: 0,
+			to: -1
+		},
+		unquoted: {
+			from: 0,
+			to: -1
+		},
+		link: /* @__PURE__ */ new Map(),
+		tag: /* @__PURE__ */ new Map(),
+		value: /* @__PURE__ */ new Map(),
+		rawClose: /* @__PURE__ */ new Map()
 	};
 }
 /**
+* Find the } closing the code that starts at position i: a `{$…}`
+* expression from its sigil on, an attribute interpolation. The code is
+* lexed as JavaScript, so only a } in code outside the brackets it opened
+* counts — not one in a string, template or regex literal or a comment —
+* and `/` after an operand divides.
+*
+* Text that is not well-formed JavaScript (an apostrophe, an unterminated
+* literal or comment, unbalanced brackets) is scanned leniently instead, as
+* prose-like macro arguments are: braces count except inside string and
+* template literals, and a quote that can't start a string (apostrophe,
+* escaped, not closed on its line) is text.
+*
+* Returns the index of the closing } or -1 if there is none. Pass the same
+* memo to repeated scans of one input to share their work.
+*/
+function scanBalancedBrace(input, i, memo = createScanMemo()) {
+	return scanClose(input, i, i, memo);
+}
+/**
+* Index of the } closing the macro whose content (name, then arguments)
+* starts at `contentStart`, or -1. The name runs up to whitespace or the }
+* (as `parseMacroContent` reads it); the arguments after it are code. The
+* lenient scan covers the whole content, as it always has.
+*/
+function scanMacroClose(input, contentStart, memo) {
+	const run = memo.name;
+	if (contentStart < run.from || contentStart > run.to) {
+		let k = contentStart;
+		while (k < input.length && input[k] !== "}" && !/\s/.test(input[k])) k++;
+		run.from = contentStart;
+		run.to = k;
+	}
+	return scanClose(input, run.to, contentStart, memo);
+}
+/**
+* Index of the } closing the `{…}` block opened at `open`, read as passage
+* text reads it: a macro (`{name args}`, `{/name}`) has its arguments lexed
+* after its name, an expression (`{$…}`, `{(…)}`, `{!…}`) from its first
+* character, after any `.class#id` selectors. Any other block is scanned as
+* code from just past the {. Returns -1 if it is unclosed.
+*/
+function scanBlockClose(input, open, memo) {
+	let at = open + 1;
+	const c = input[at];
+	if (c === "." || c === "#") {
+		at = parseSelectors(input, at).endIdx;
+		if (input[at] === " ") at++;
+	}
+	const first = input[at];
+	if (first !== void 0 && (first === "/" || /[a-zA-Z]/.test(first))) return scanMacroClose(input, at, memo);
+	return scanBalancedBrace(input, at, memo);
+}
+/** Lex the code from `codeStart`, else scan leniently from `lenientStart`. */
+function scanClose(input, codeStart, lenientStart, memo) {
+	let end = memo.code.get(lenientStart);
+	if (end === void 0) {
+		end = findCodeEnd(input, codeStart, { cache: memo.js });
+		if (end === -1) end = scanBraceLenient(input, lenientStart, memo);
+		memo.code.set(lenientStart, end);
+	}
+	return end;
+}
+/**
+* Index of the ]] closing the link whose text starts at `from`, or -1. A
+* [[ inside opens a nested pair. Each nested [[ starts a scan that reads the
+* rest the same way, so its result is recorded too: unclosed [[s don't each
+* scan to the end of the input.
+*/
+function scanLinkClose(input, from, memo) {
+	const known = memo.link.get(from);
+	if (known !== void 0) return known;
+	const opens = [from];
+	let i = from;
+	while (i < input.length) if (input[i] === "[" && input[i + 1] === "[") {
+		i += 2;
+		const inner = memo.link.get(i);
+		if (inner === void 0) opens.push(i);
+		else if (inner === -1) break;
+		else i = inner + 2;
+	} else if (input[i] === "]" && input[i + 1] === "]") {
+		memo.link.set(opens.pop(), i);
+		if (!opens.length) return i;
+		i += 2;
+	} else i++;
+	for (const open of opens) memo.link.set(open, -1);
+	return -1;
+}
+/**
 * Skip a '…' or "…" string literal opening at i.
 * Returns the index just past the closing quote, or -1 if the string is
 * not closed on the same line (JS strings can't span lines unescaped).
@@ -169,24 +1493,6 @@ function skipQuoted(input, i) {
 	return -1;
 }
 /**
-* Skip a `…` template literal opening at i, including ${…} parts.
-* Returns the index just past the closing backtick, or -1 if unclosed.
-*/
-function skipTemplate(input, i) {
-	let j = i + 1;
-	while (j < input.length) {
-		const c = input[j];
-		if (c === "\\") j += 2;
-		else if (c === "`") return j + 1;
-		else if (c === "$" && input[j + 1] === "{") {
-			const closeIdx = scanBalancedBrace(input, j + 2);
-			if (closeIdx === -1) return -1;
-			j = closeIdx + 1;
-		} else j++;
-	}
-	return -1;
-}
-/**
 * A quote directly after a letter/digit is an apostrophe (don't), not a
 * string; after a backslash it is an escaped attribute delimiter (\").
 */
@@ -194,39 +1500,131 @@ var NON_STRING_QUOTE_PREFIX = /[\p{L}\p{N}_\\]/u;
 /**
 * Scan for the balanced closing } starting at position i (just past the {).
 * Braces inside string and template literals are ignored. A quote that
-* can't start a string (apostrophe, escaped, unterminated) counts as text.
+* can't start a string (apostrophe, escaped, unterminated) counts as text,
+* and so does a backtick without a closing one.
 * Returns the index of the closing } or -1 if unbalanced.
+*
+* Template literals and their ${…} parts are scans on a stack, not
+* recursive calls, so deep nesting can't overflow the call stack. How the
+* text reads depends only on where a scan is, so a scan passing a point —
+* just past a {, a string or a template literal — goes on as a scan
+* starting there would: its result there is recorded too, and a recorded
+* result is used instead of scanning on. Scans from many starts in one
+* input then take about linear time.
 */
-function scanBalancedBrace(input, i) {
-	let depth = 1;
-	while (i < input.length) {
-		const c = input[i];
-		if (c === "{") depth++;
-		else if (c === "}") {
-			if (--depth === 0) return i;
-		} else if ((c === "\"" || c === "'") && !(i > 0 && NON_STRING_QUOTE_PREFIX.test(input[i - 1]))) {
-			const end = skipQuoted(input, i);
-			if (end !== -1) {
-				i = end;
+function scanBraceLenient(input, i, memo) {
+	const known = memo.brace.get(i);
+	if (known !== void 0) return known;
+	const stack = [{
+		template: false,
+		start: i,
+		levels: [[]]
+	}];
+	for (;;) {
+		const scan = stack[stack.length - 1];
+		let end;
+		if (scan.template) {
+			let point = true;
+			while (end === void 0 && i < input.length) {
+				if (point) {
+					const known = memo.templateText.get(i);
+					if (known !== void 0) {
+						end = known;
+						break;
+					}
+					scan.passed.push(i);
+					point = false;
+				}
+				const c = input[i];
+				if (c === "\\") {
+					i += 2;
+					point = true;
+				} else if (c === "`") end = i + 1;
+				else if (c === "$" && input[i + 1] === "{") {
+					const inner = memo.brace.get(i + 2);
+					if (inner === void 0) break;
+					if (inner === -1) end = -1;
+					else {
+						i = inner + 1;
+						point = true;
+					}
+				} else i++;
+			}
+			if (end === void 0 && i < input.length) {
+				stack.push({
+					template: false,
+					start: i + 2,
+					levels: [[]]
+				});
+				i += 2;
 				continue;
 			}
-		} else if (c === "`") {
-			const end = skipTemplate(input, i);
-			if (end !== -1) {
-				i = end;
+			end ?? (end = -1);
+		} else {
+			const { levels } = scan;
+			/** The } at `close` ends the innermost level. */
+			const closeLevel = (close) => {
+				for (const at of levels.pop()) memo.brace.set(at, close);
+				if (!levels.length) end = close;
+			};
+			while (end === void 0 && i < input.length) {
+				const c = input[i];
+				let at = -1;
+				if (c === "{") {
+					levels.push([]);
+					at = ++i;
+				} else if (c === "}") closeLevel(i++);
+				else if ((c === "\"" || c === "'") && !(i > 0 && NON_STRING_QUOTE_PREFIX.test(input[i - 1]))) {
+					const close = skipQuoted(input, i);
+					if (close === -1) i++;
+					else at = i = close;
+				} else if (c === "`") {
+					const close = memo.template.get(i);
+					if (close === void 0) break;
+					if (close === -1) i++;
+					else at = i = close;
+				} else i++;
+				if (at === -1) continue;
+				const known = memo.brace.get(at);
+				if (known === void 0) levels[levels.length - 1].push(at);
+				else if (known === -1) i = input.length;
+				else {
+					closeLevel(known);
+					i = known + 1;
+				}
+			}
+			if (end === void 0 && i < input.length) {
+				stack.push({
+					template: true,
+					start: i,
+					levels: [],
+					passed: []
+				});
+				i++;
 				continue;
 			}
+			if (end === void 0) {
+				end = -1;
+				for (const level of levels) for (const at of level) memo.brace.set(at, -1);
+			}
 		}
-		i++;
+		stack.pop();
+		(scan.template ? memo.template : memo.brace).set(scan.start, end);
+		for (const at of scan.passed ?? []) memo.templateText.set(at, end);
+		const parent = stack[stack.length - 1];
+		if (!parent) return end;
+		if (parent.template) i = end === -1 ? input.length : end + 1;
+		else i = end === -1 ? scan.start + 1 : end;
 	}
-	return -1;
 }
 /**
 * Single-pass tokenizer for Twine passage content.
 * Recognizes: [[links]], {$variable}, {_temporary}, {macroName args}
 */
-function tokenize(input) {
+function tokenize(input, options = {}) {
+	const textMode = options.text === true;
 	const tokens = [];
+	const memo = createScanMemo();
 	let i = 0;
 	let textStart = 0;
 	function flushText(end) {
@@ -238,20 +1636,44 @@ function tokenize(input) {
 		});
 	}
 	/**
-	* After an opening raw-body macro ({do}), emit everything up to the
-	* first {/name} as a single text token so JavaScript source is not
-	* parsed as markup. A literal "{/do}" inside the code would end it early.
-	* Without a closer, nothing is consumed and the AST builder reports it.
+	* After an opening raw-body macro ({do}), emit everything up to its
+	* {/name} as a single text token so JavaScript source is not parsed as
+	* markup. The body is lexed as JavaScript statements: a {/do} in code ends
+	* it, one inside a string, template or regex literal or a comment does
+	* not. If the body is not well-formed JavaScript up to a {/do} in code,
+	* the first {/do} ends it. Without a closer, nothing is consumed and the
+	* AST builder reports it.
 	*/
 	function consumeRawBody(name, isClose) {
 		const lower = name.toLowerCase();
 		if (isClose || !RAW_BODY_MACROS.has(lower)) return;
-		const closeRe = new RegExp(`\\{/${lower}\\s*\\}`, "gi");
-		closeRe.lastIndex = i;
-		const m = closeRe.exec(input);
-		if (!m) return;
-		const closeStart = m.index;
-		const closeEnd = closeStart + m[0].length;
+		const closer = `\\{/${lower}\\s*\\}`;
+		let last = memo.rawClose.get(lower);
+		if (!last || i < last.from || last.at >= 0 && i > last.at) {
+			const firstRe = new RegExp(closer, "gi");
+			firstRe.lastIndex = i;
+			last = {
+				from: i,
+				at: firstRe.exec(input)?.index ?? -1
+			};
+			memo.rawClose.set(lower, last);
+		}
+		const first = last.at;
+		if (first === -1) return;
+		const atRe = new RegExp(closer, "iy");
+		const closerAt = (k) => {
+			atRe.lastIndex = k;
+			return atRe.test(input);
+		};
+		let closeStart = findCodeEnd(input, i, {
+			goal: "statements",
+			stop: closerAt,
+			stopKey: lower,
+			cache: memo.js
+		});
+		if (closeStart === -1) closeStart = first;
+		atRe.lastIndex = closeStart;
+		const closeEnd = closeStart + atRe.exec(input)[0].length;
 		flushText(closeStart);
 		tokens.push({
 			type: "macro",
@@ -262,11 +1684,46 @@ function tokenize(input) {
 		i = closeEnd;
 		textStart = closeEnd;
 	}
+	/**
+	* Push an expression token for the `{…}` block opened at `start` whose
+	* expression starts at `exprStart`, flushing the text before it first
+	* when `flush`. Returns false, consuming nothing, if the block is unclosed.
+	*/
+	function pushExpression(exprStart, start, flush, className, id) {
+		const closeIdx = scanBalancedBrace(input, exprStart, memo);
+		if (closeIdx === -1) return false;
+		if (flush) flushText(start);
+		const token = {
+			type: "expression",
+			expression: input.slice(exprStart, closeIdx),
+			start,
+			end: closeIdx + 1
+		};
+		if (className) token.className = className;
+		if (id) token.id = id;
+		tokens.push(token);
+		i = textStart = closeIdx + 1;
+		return true;
+	}
 	while (i < input.length) {
 		if (input[i] === "\\") {
 			let k = i + 1;
 			while (input[k] === "\\") k++;
 			const next = input[k];
+			if (textMode && (next === "{" || next === "}")) {
+				const escaped = (k - i) % 2 === 1;
+				const end = escaped ? k + 1 : k;
+				const value = "\\".repeat(k - i >> 1) + (escaped ? next : "");
+				flushText(i);
+				if (value) tokens.push({
+					type: "text",
+					value,
+					start: i,
+					end
+				});
+				i = textStart = end;
+				continue;
+			}
 			if ((next === "{" || next === "}") && (k - i) % 2 === 1) {
 				flushText(k - 1);
 				tokens.push({
@@ -282,7 +1739,7 @@ function tokenize(input) {
 			i = k;
 			continue;
 		}
-		if (input[i] === "[" && input[i + 1] === "[") {
+		if (!textMode && input[i] === "[" && input[i + 1] === "[") {
 			flushText(i);
 			const start = i;
 			i += 2;
@@ -295,23 +1752,15 @@ function tokenize(input) {
 				i = parsed.endIdx;
 				if (input[i] === " ") i++;
 			}
-			let depth = 1;
 			const innerStart = i;
-			while (i < input.length && depth > 0) if (input[i] === "[" && input[i + 1] === "[") {
-				depth++;
-				i += 2;
-			} else if (input[i] === "]" && input[i + 1] === "]") {
-				depth--;
-				if (depth === 0) break;
-				i += 2;
-			} else i++;
-			if (depth !== 0) {
+			const closeIdx = scanLinkClose(input, innerStart, memo);
+			if (closeIdx === -1) {
 				i = start + 2;
 				textStart = start;
 				continue;
 			}
-			const inner = input.slice(innerStart, i);
-			i += 2;
+			const inner = input.slice(innerStart, closeIdx);
+			i = closeIdx + 2;
 			const { display, target } = parseLink(inner);
 			const linkToken = {
 				type: "link",
@@ -359,7 +1808,7 @@ function tokenize(input) {
 						textStart = i;
 						continue;
 					}
-					const closeIdx$ = scanBalancedBrace(input, nameStart);
+					const closeIdx$ = scanBalancedBrace(input, nameStart - 1, memo);
 					if (closeIdx$ !== -1) {
 						const expression = input.slice(afterSelectors, closeIdx$);
 						i = closeIdx$ + 1;
@@ -399,7 +1848,7 @@ function tokenize(input) {
 						textStart = i;
 						continue;
 					}
-					const closeIdx_ = scanBalancedBrace(input, nameStart);
+					const closeIdx_ = scanBalancedBrace(input, nameStart - 1, memo);
 					if (closeIdx_ !== -1) {
 						const expression = input.slice(afterSelectors, closeIdx_);
 						i = closeIdx_ + 1;
@@ -439,7 +1888,7 @@ function tokenize(input) {
 						textStart = i;
 						continue;
 					}
-					const closeIdx_at = scanBalancedBrace(input, nameStart);
+					const closeIdx_at = scanBalancedBrace(input, nameStart - 1, memo);
 					if (closeIdx_at !== -1) {
 						const expression = input.slice(afterSelectors, closeIdx_at);
 						i = closeIdx_at + 1;
@@ -479,7 +1928,7 @@ function tokenize(input) {
 						textStart = i;
 						continue;
 					}
-					const closeIdx_pct = scanBalancedBrace(input, nameStart);
+					const closeIdx_pct = scanBalancedBrace(input, nameStart - 1, memo);
 					if (closeIdx_pct !== -1) {
 						const expression = input.slice(afterSelectors, closeIdx_pct);
 						i = closeIdx_pct + 1;
@@ -499,9 +1948,10 @@ function tokenize(input) {
 					textStart = start;
 					continue;
 				}
+				if (EXPRESSION_START.has(charAfter) && pushExpression(afterSelectors, start, false, className, id)) continue;
 				if (charAfter !== void 0 && /[a-zA-Z]/.test(charAfter)) {
 					const contentStart = afterSelectors;
-					const closeIdx = scanBalancedBrace(input, contentStart);
+					const closeIdx = scanMacroClose(input, contentStart, memo);
 					if (closeIdx === -1) {
 						i = start + 1;
 						textStart = start;
@@ -547,7 +1997,7 @@ function tokenize(input) {
 					textStart = i;
 					continue;
 				}
-				const closeIdx = scanBalancedBrace(input, nameStart);
+				const closeIdx = scanBalancedBrace(input, nameStart - 1, memo);
 				if (closeIdx !== -1) {
 					const expression = input.slice(start + 1, closeIdx);
 					i = closeIdx + 1;
@@ -582,7 +2032,7 @@ function tokenize(input) {
 					textStart = i;
 					continue;
 				}
-				const closeIdx = scanBalancedBrace(input, nameStart);
+				const closeIdx = scanBalancedBrace(input, nameStart - 1, memo);
 				if (closeIdx !== -1) {
 					const expression = input.slice(start + 1, closeIdx);
 					i = closeIdx + 1;
@@ -617,7 +2067,7 @@ function tokenize(input) {
 					textStart = i;
 					continue;
 				}
-				const closeIdx = scanBalancedBrace(input, nameStart);
+				const closeIdx = scanBalancedBrace(input, nameStart - 1, memo);
 				if (closeIdx !== -1) {
 					const expression = input.slice(start + 1, closeIdx);
 					i = closeIdx + 1;
@@ -652,7 +2102,7 @@ function tokenize(input) {
 					textStart = i;
 					continue;
 				}
-				const closeIdx = scanBalancedBrace(input, nameStart);
+				const closeIdx = scanBalancedBrace(input, nameStart - 1, memo);
 				if (closeIdx !== -1) {
 					const expression = input.slice(start + 1, closeIdx);
 					i = closeIdx + 1;
@@ -669,10 +2119,15 @@ function tokenize(input) {
 				textStart = start;
 				continue;
 			}
+			if (EXPRESSION_START.has(nextChar)) {
+				if (pushExpression(i + 1, start, true)) continue;
+				i++;
+				continue;
+			}
 			if (nextChar !== void 0 && (nextChar === "/" || /[a-zA-Z]/.test(nextChar))) {
 				flushText(i);
 				const contentStart = i + 1;
-				const closeIdx = scanBalancedBrace(input, contentStart);
+				const closeIdx = scanMacroClose(input, contentStart, memo);
 				if (closeIdx === -1) {
 					i = start + 1;
 					textStart = start;
@@ -696,7 +2151,7 @@ function tokenize(input) {
 			i++;
 			continue;
 		}
-		if (input[i] === "<") {
+		if (!textMode && input[i] === "<") {
 			const start = i;
 			let j = i + 1;
 			const isClose = input[j] === "/";
@@ -729,8 +2184,8 @@ function tokenize(input) {
 					continue;
 				}
 			} else {
-				const parsed = parseHtmlAttributes(input, j);
-				j = parsed.endIdx;
+				const attrsStart = j;
+				j = scanAttributes(input, attrsStart, memo);
 				let isSelfClose = HTML_VOID_TAGS.has(tagLower);
 				if (input[j] === "/") {
 					isSelfClose = true;
@@ -742,7 +2197,7 @@ function tokenize(input) {
 					tokens.push({
 						type: "html",
 						tag,
-						attributes: parsed.attributes,
+						attributes: parseHtmlAttributes(input, attrsStart, memo).attributes,
 						isClose: false,
 						isSelfClose,
 						start,
@@ -762,14 +2217,41 @@ function tokenize(input) {
 	return tokens;
 }
 //#endregion
+//#region src/utils/error-message.ts
+/**
+* The message to show for a caught value. Anything can be thrown, not only
+* Errors: an Error gives its message, a string is its own message, and any
+* other value gives `fallback` when one is passed, else its string form
+* (never `undefined`). An empty message also gives `fallback`, or for an
+* Error its string form (e.g. "Error").
+*/
+function errorMessage(err, fallback) {
+	if (err instanceof Error) return err.message || fallback || String(err);
+	if (typeof err === "string" && err !== "") return err;
+	return fallback ?? String(err);
+}
+//#endregion
+//#region src/utils/namespace.ts
+/** The variable name no namespace can hold. */
+var RESERVED_NAME = "__proto__";
+/** A namespace with no prototype holding the own entries of `sources`. */
+function createNamespace(...sources) {
+	const ns = Object.create(null);
+	for (const source of sources) {
+		if (!source) continue;
+		for (const key of Object.keys(source)) ns[key] = source[key];
+	}
+	return ns;
+}
+Object.freeze(createNamespace());
+//#endregion
 //#region src/story-variables.ts
 function declarationRegex(sigil) {
 	const escaped = sigil.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 	return new RegExp(`^${escaped}(\\w+)\\s*=\\s*(.+)$`);
 }
-var VAR_REF_RE = /\$(\w+(?:\.\w+)*)/g;
-/** `{` followed by a sigil starts an interpolation block inside literal text. */
-var INTERP_START_RE = /^[$_@%]\w/;
+/** A `$name` reference with its dot path, at a `$` the lexer found. */
+var VAR_PATH_RE = /\$(\w+(?:\.\w+)*)/y;
 /** Quoted first argument of an input macro naming a story variable. */
 var QUOTED_VAR_ARG_RE = /^["']\$(\w+(?:\.\w+)*)["']?$/;
 var FOR_LOCAL_RE = /\{for\s+@(\w+)(?:\s*,\s*@(\w+))?\s+of\b/g;
@@ -812,17 +2294,18 @@ function parseStoryVariables(content, sigil = "$") {
 		const match = line.match(DECLARATION_RE);
 		if (!match) throw new Error(`${passageName}: Invalid declaration: "${line}". Expected: ${sigil}name = value`);
 		const [, name, expr] = match;
+		if (name === "__proto__") throw new Error(`${passageName}: "${sigil}${name}" cannot be used as a variable name (${RESERVED_NAME} is reserved)`);
 		let value;
 		try {
 			value = new Function("return (" + expr + ")")();
 		} catch (err) {
-			throw new Error(`${passageName}: Failed to evaluate "${sigil}${name} = ${expr}": ${err instanceof Error ? err.message : err}`);
+			throw new Error(`${passageName}: Failed to evaluate "${sigil}${name} = ${expr}": ${errorMessage(err)}`);
 		}
 		let fieldSchema;
 		try {
 			fieldSchema = inferSchema(value);
 		} catch (err) {
-			throw new Error(`${passageName}: ${err instanceof Error ? err.message : err}`);
+			throw new Error(`${passageName}: ${errorMessage(err)}`);
 		}
 		schema.set(name, {
 			...fieldSchema,
@@ -854,6 +2337,7 @@ function extractForLocals(content) {
 function validateRef(ref, schema, forLocals) {
 	const parts = ref.split(".");
 	const rootName = parts[0];
+	if (rootName === "__proto__") return `"$${rootName}" cannot be used as a variable name (${RESERVED_NAME} is reserved)`;
 	if (forLocals.has(rootName)) return null;
 	const rootSchema = schema.get(rootName);
 	if (!rootSchema) return `Undeclared variable: $${ref}`;
@@ -888,89 +2372,59 @@ var BUILTIN_STORE_VAR_MACROS = [
 	"textarea",
 	"textbox"
 ];
-/** Report every `$var.path` in a code segment free of strings/comments. */
-function scanRefs(segment, onRef) {
-	for (const match of segment.matchAll(VAR_REF_RE)) onRef(match[1]);
-}
-/** Index of the quote closing the string opened at `start` (or the end). */
-function findClosingQuote(code, start) {
-	const quote = code[start];
-	let i = start + 1;
-	while (i < code.length && code[i] !== quote) i += code[i] === "\\" ? 2 : 1;
-	return Math.min(i, code.length);
-}
+var NO_STORE_VAR_MACROS = /* @__PURE__ */ new Set();
 /**
-* Scan literal text (string contents, HTML attribute values) for `{$…}`
-* interpolation blocks, which interpolating macros and HTML attributes
-* resolve at runtime. A bare `$word` in literal text is not a reference.
+* Scan the value of a code attribute (`onclick`, see isCodeAttribute) for
+* the `{$…}` references resolved in it; its other braces are code.
 */
-function scanInterpolations(text, onRef) {
-	let i = text.indexOf("{");
-	while (i !== -1) {
-		const next = INTERP_START_RE.test(text.slice(i + 1, i + 3)) ? scanCode(text, i + 1, onRef, true) : i + 1;
-		i = text.indexOf("{", next);
-	}
+function scanSigilReferences(value, onRef) {
+	for (const part of splitSigilTemplate(value)) if ("expr" in part) scanCode(part.expr, onRef);
 }
 /**
-* Scan a template literal starting just after its opening backtick: literal
-* parts are text, `${…}` parts are code. Returns the index just past the
-* closing backtick.
+* Scan literal text (string contents, HTML attribute values) for the markup
+* that labels and HTML attributes evaluate at runtime: `{$…}` displays,
+* expressions and macros, read as in passage text. A bare `$word` in
+* literal text is not a reference.
 */
-function scanTemplate(code, start, onRef) {
-	let i = start;
-	let textStart = start;
-	while (i < code.length) {
-		const ch = code[i];
-		if (ch === "\\") i += 2;
-		else if (ch === "`") {
-			scanInterpolations(code.slice(textStart, i), onRef);
-			return i + 1;
-		} else if (ch === "$" && code[i + 1] === "{") {
-			scanInterpolations(code.slice(textStart, i), onRef);
-			i = textStart = scanCode(code, i + 2, onRef, true);
-		} else i++;
-	}
-	scanInterpolations(code.slice(textStart), onRef);
-	return code.length;
+function scanInterpolations(text, onRef, storeVarMacros = NO_STORE_VAR_MACROS) {
+	if (!text.includes("{")) return;
+	collectTokenRefs(text, tokenize(text, { text: true }), storeVarMacros, onRef);
 }
 /**
-* Report `$var` references in JavaScript code. Like the string-aware
-* expression transformer, sigils inside string literals are left alone while
-* template-literal `${…}` parts are code; comments are skipped too. When
-* `nested`, stops at the `}` closing the enclosing block and returns the index
-* just past it.
+* Report `$var` references in JavaScript code, lexed as the expression
+* engine lexes it (`lexJs`): references in code, but none inside string or
+* regex literals or comments, nor property names (`a.$b`, `{ $b: 1 }`).
+* The text of string and template literals is scanned for the markup that
+* labels evaluate (`{$…}`); the `${…}` parts of template literals are code.
 */
-function scanCode(code, start, onRef, nested = false) {
-	let i = start;
-	let segStart = start;
-	let depth = 0;
-	while (i < code.length) {
-		const ch = code[i];
-		const next = code[i + 1];
-		const isComment = ch === "/" && (next === "/" || next === "*");
-		if (ch === "\"" || ch === "'" || ch === "`" || isComment) {
-			scanRefs(code.slice(segStart, i), onRef);
-			if (ch === "`") i = scanTemplate(code, i + 1, onRef);
-			else if (isComment) {
-				const close = code.indexOf(next === "/" ? "\n" : "*/", i + 2);
-				i = close === -1 ? code.length : next === "/" ? close : close + 2;
-			} else {
-				const close = findClosingQuote(code, i);
-				scanInterpolations(code.slice(i + 1, close), onRef);
-				i = Math.min(close + 1, code.length);
+function scanCode(code, onRef, goal = "expression") {
+	/** Open template literals: their text so far, null in an interpolation. */
+	const templates = [];
+	lexJs(code, {
+		variable(sigil, _name, index) {
+			if (sigil !== "$") return;
+			VAR_PATH_RE.lastIndex = index;
+			onRef(VAR_PATH_RE.exec(code)[1]);
+		},
+		literal(text, _index, nesting) {
+			const template = templates[templates.length - 1];
+			if (template?.nesting === nesting) if (template.text === null) template.text = "";
+			else if (text === "`" || text === "${") {
+				scanInterpolations(template.text, onRef);
+				if (text === "`") templates.pop();
+				else template.text = null;
+			} else template.text += text;
+			else if (text === "`") templates.push({
+				nesting,
+				text: ""
+			});
+			else if (text[0] === "\"" || text[0] === "'") {
+				const { closed } = scanStringLiteral(text, 0);
+				scanInterpolations(text.slice(1, closed ? -1 : void 0), onRef);
 			}
-			segStart = i;
-			continue;
-		}
-		if (nested && ch === "{") depth++;
-		else if (nested && ch === "}" && depth-- === 0) {
-			scanRefs(code.slice(segStart, i), onRef);
-			return i + 1;
 		}
-		i++;
-	}
-	scanRefs(code.slice(segStart), onRef);
-	return code.length;
+	}, goal);
+	for (const t of templates) if (t.text) scanInterpolations(t.text, onRef);
 }
 /**
 * Report the `$var` references a passage evaluates at runtime: `{$var}`
@@ -979,15 +2433,19 @@ function scanCode(code, start, onRef, nested = false) {
 * interpolations in HTML attributes. Prose is literal text and not scanned.
 */
 function collectPassageRefs(content, storeVarMacros, onRef) {
-	const tokens = tokenize(content);
+	collectTokenRefs(content, tokenize(content), storeVarMacros, onRef);
+}
+/** Report the `$var` references in the tokens of `content`. */
+function collectTokenRefs(content, tokens, storeVarMacros, onRef) {
 	for (let t = 0; t < tokens.length; t++) {
 		const token = tokens[t];
 		if (token.type === "variable") {
 			if (token.scope === "variable" && token.name) onRef(token.name);
-		} else if (token.type === "expression") scanCode(token.expression, 0, onRef);
-		else if (token.type === "html") for (const value of Object.values(token.attributes)) scanInterpolations(value, onRef);
+		} else if (token.type === "expression") scanCode(token.expression, onRef);
+		else if (token.type === "html") for (const [name, value] of Object.entries(token.attributes)) if (isCodeAttribute(name)) scanSigilReferences(value, onRef);
+		else scanInterpolations(value, onRef, storeVarMacros);
 		else if (token.type === "macro" && !token.isClose) {
-			scanCode(token.rawArgs, 0, onRef);
+			scanCode(token.rawArgs, onRef);
 			if (storeVarMacros.has(token.name.toLowerCase())) {
 				const first = token.rawArgs.trim().split(/\s+/)[0] ?? "";
 				const quoted = QUOTED_VAR_ARG_RE.exec(first);
@@ -1001,7 +2459,7 @@ function collectPassageRefs(content, storeVarMacros, onRef) {
 					close++;
 				}
 				if (close < tokens.length) {
-					scanCode(content.slice(token.end, tokens[close].start), 0, onRef);
+					scanCode(content.slice(token.end, tokens[close].start), onRef, "statements");
 					t = close;
 				}
 			}
@@ -1029,10 +2487,11 @@ function validatePassages(passages, schema, storeVarMacros = BUILTIN_STORE_VAR_M
 	return errors;
 }
 /**
-* Extract default values from the schema as a plain object.
+* Extract default values from the schema as a record without a prototype,
+* like the namespaces it initializes (see utils/namespace.ts).
 */
 function extractDefaults(schema) {
-	const defaults = {};
+	const defaults = createNamespace();
 	for (const [name, varSchema] of schema) defaults[name] = varSchema.default;
 	return defaults;
 }