@rohal12/spindle 0.58.0 → 0.59.1

package/dist/pkg/headless.js

@@ -103,24 +103,41 @@ var LINK_SEPARATORS = [
 	["<-", true]
 ];
 var NO_SELECTORS = {};
-function parseLink(inner) {
+/**
+* A link's display text and target, from its text `inner` (at `at` in the
+* input), with where the target is written.
+*/
+function parseLink(inner, at) {
+	/** The trimmed text from `start` to `end` of inner, and where it is. */
+	const part = (start, end) => {
+		const raw = inner.slice(start, end);
+		const value = raw.trim();
+		const from = at + start + (value ? raw.indexOf(value) : 0);
+		return {
+			value,
+			start: from,
+			end: from + value.length
+		};
+	};
 	for (const [separator, targetFirst] of LINK_SEPARATORS) {
 		const idx = inner.indexOf(separator);
 		if (idx === -1) continue;
-		const before = inner.slice(0, idx).trim();
-		const after = inner.slice(idx + separator.length).trim();
-		return targetFirst ? {
-			display: after,
-			target: before
-		} : {
-			display: before,
-			target: after
+		const before = part(0, idx);
+		const after = part(idx + separator.length, inner.length);
+		const [display, target] = targetFirst ? [after, before] : [before, after];
+		return {
+			display: display.value,
+			target: target.value,
+			targetStart: target.start,
+			targetEnd: target.end
 		};
 	}
-	const trimmed = inner.trim();
+	const whole = part(0, inner.length);
 	return {
-		display: trimmed,
-		target: trimmed
+		display: whole.value,
+		target: whole.value,
+		targetStart: whole.start,
+		targetEnd: whole.end
 	};
 }
 function quoteArg(value) {
@@ -202,6 +219,8 @@ function tokenOf(x) {
 			type: "link",
 			display: x.display,
 			target: x.target,
+			targetStart: x.targetStart,
+			targetEnd: x.targetEnd,
 			...span
 		}, x);
 		case "variable": return withSelectors({
@@ -733,8 +752,8 @@ function peg$parse(input, options) {
 	function peg$f48() {
 		return !textMode;
 	}
-	function peg$f49(s, inner) {
-		return withSelectors(lexeme("link", location(), parseLink(inner)), s);
+	function peg$f49(s, at, inner) {
+		return withSelectors(lexeme("link", location(), parseLink(inner, at)), s);
 	}
 	function peg$f50() {
 		return !textMode;
@@ -1783,7 +1802,7 @@ function peg$parse(input, options) {
 		return s0;
 	}
 	function peg$parseLinkLexeme() {
-		let s0, s1, s2, s3, s4, s5;
+		let s0, s1, s2, s3, s4, s5, s6;
 		s0 = peg$currPos;
 		peg$savedPos = peg$currPos;
 		s1 = peg$f48();
@@ -1800,19 +1819,20 @@ function peg$parse(input, options) {
 			if (s2 !== peg$FAILED) {
 				s3 = peg$parseSelectors();
 				if (s3 !== peg$FAILED) {
-					s4 = peg$currPos;
-					s5 = peg$parseLinkText();
-					s4 = input.substring(s4, peg$currPos);
+					s4 = peg$parseHere();
+					s5 = peg$currPos;
+					s6 = peg$parseLinkText();
+					s5 = input.substring(s5, peg$currPos);
 					if (input.substr(peg$currPos, 2) === peg$c5) {
-						s5 = peg$c5;
+						s6 = peg$c5;
 						peg$currPos += 2;
 					} else {
-						s5 = peg$FAILED;
+						s6 = peg$FAILED;
 						if (peg$silentFails === 0) peg$fail(peg$e9);
 					}
-					if (s5 !== peg$FAILED) {
+					if (s6 !== peg$FAILED) {
 						peg$savedPos = s0;
-						s0 = peg$f49(s3, s4);
+						s0 = peg$f49(s3, s4, s5);
 					} else {
 						peg$currPos = s0;
 						s0 = peg$FAILED;
@@ -9441,6 +9461,22 @@ function regexEnd(src, start) {
 	return -1;
 }
 /**
+* The value of `src` when it is exactly one `"…"` or `'…'` string literal,
+* as JavaScript reads it (`"\u0048all"` is `Hall`, `"\1"` is U+0001 in
+* the non-strict code passages run), otherwise `null`: other code, or a
+* literal that is not well-formed (`"\u{110000}"`).
+*/
+function stringLiteralValue(src) {
+	if (src[0] !== "\"" && src[0] !== "'") return null;
+	try {
+		const p = tokenizerAt(src, 0, "expression");
+		p.nextToken();
+		return p.type === types$1.string && p.end === src.length ? p.value : null;
+	} catch {
+		return null;
+	}
+}
+/**
 * 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
@@ -10146,20 +10182,45 @@ var PARAMETER_TYPES = [
 	"options"
 ];
 /**
+* What the value of a `string` or `text` argument holds, for the check at
+* story start and for tooling (see code-check.ts):
+* - `markup`: markup the macro renders (`{button}`'s label): its markup
+*   is checked.
+* - `text`: plain text the macro uses as written (`{checkbox}`'s label).
+* - `passage`: a passage name (`{watch}`'s `goto`): the passage must exist.
+* - `expression`, `statements`: code (`{watch}`'s condition and `run`): it
+*   is checked as code, and its variable references against the schema.
+*
+* Without it, the argument of a macro with `interpolate` holds `markup`,
+* any other `text`.
+*/
+var STRING_HOLDS = [
+	"markup",
+	"text",
+	"passage",
+	"expression",
+	"statements"
+];
+/**
 * Throw if a parameter `macro` declares (or an option of one) has no type,
 * or one that isn't a ParameterType: arguments are read by their type, and
-* there is no default.
+* there is no default. Throw too if it declares what it `holds` wrongly.
 */
 function checkParameterTypes(macro, parameters) {
+	const holdsFix = `Give a \`string\` or \`text\` parameter one of ${STRING_HOLDS.join(", ")} to hold (see docs/custom-macros.md#what-a-string-holds).`;
 	for (const param of parameters) {
 		const type = param.type;
-		if (!PARAMETER_TYPES.includes(type)) {
-			const problem = type === void 0 ? "has no type" : `has the unknown type ${JSON.stringify(type)}`;
-			throw new Error(`spindle: The parameter "${param.name}" of the macro {${macro}} ${problem}. Give it one of the types ${PARAMETER_TYPES.join(", ")} (see docs/custom-macros.md#parameter-types), or declare no parameters and read props.rawArgs.`);
-		}
+		if (!PARAMETER_TYPES.includes(type)) throw parameterError(macro, param, type === void 0 ? "has no type" : `has the unknown type ${JSON.stringify(type)}`, `Give it one of the types ${PARAMETER_TYPES.join(", ")} (see docs/custom-macros.md#parameter-types), or declare no parameters and read props.rawArgs.`);
+		const holds = param.holds;
+		if (holds !== void 0 && type !== "string" && type !== "text") throw parameterError(macro, param, `is of the type ${type}, which holds what it is`, holdsFix);
+		if (holds !== void 0 && !STRING_HOLDS.includes(holds)) throw parameterError(macro, param, `holds the unknown ${JSON.stringify(holds)}`, holdsFix);
 		if (param.parameters) checkParameterTypes(macro, param.parameters);
 	}
 }
+/** The error for the parameter `param` of `macro`: what is wrong, and the fix. */
+function parameterError(macro, param, problem, fix) {
+	return /* @__PURE__ */ new Error(`spindle: The parameter "${param.name}" of the macro {${macro}} ${problem}. ${fix}`);
+}
 var metadataRegistry = new NameMap();
 function registerMacroMetadata(name, metadata) {
 	metadataRegistry.set(name, metadata);
@@ -10242,37 +10303,6 @@ function readWholeQuoted(src) {
 	const quoted = readQuoted(src, 0);
 	return quoted && quoted.end === src.length ? quoted.value : null;
 }
-var JS_SIMPLE_ESCAPES = {
-	n: "\n",
-	t: "	",
-	r: "\r",
-	b: "\b",
-	f: "\f",
-	v: "\v",
-	"0": "\0"
-};
-/** Undo every escape of a JavaScript string literal's body. */
-function decodeJsEscapes(body) {
-	return body.replace(/\\(?:u\{([0-9a-fA-F]+)\}|u([0-9a-fA-F]{4})|x([0-9a-fA-F]{2})|(\r\n|[\n\r\u2028\u2029])|([\s\S]))/g, (_, braced, unicode, hex, lineBreak, other) => {
-		if (lineBreak !== void 0) return "";
-		const code = braced ?? unicode ?? hex;
-		if (code !== void 0) {
-			const point = parseInt(code, 16);
-			return point <= 1114111 ? String.fromCodePoint(point) : "";
-		}
-		return JS_SIMPLE_ESCAPES[other] ?? other;
-	});
-}
-/**
-* The value of `src` when it is exactly one `"…"` or `'…'` string, read as
-* the JavaScript literal it is (`"\u0048all"` is `Hall`), otherwise `null`.
-* `readWholeQuoted` keeps other escapes as written, for labels and code.
-*/
-function readWholeJsString(src) {
-	const quoted = readQuoted(src, 0);
-	if (!quoted || quoted.end !== src.length) return null;
-	return decodeJsEscapes(src.slice(1, -1));
-}
 /**
 * Strip an optional quote from each end of an unquoted-or-loosely-quoted
 * argument (`"Red`, `Red'`), leaving at least one character. This is the
@@ -13050,7 +13080,15 @@ function createIDBBackend() {
 		const rows = name === "meta";
 		/** Run one request in a transaction of its own. */
 		const request = async (mode, make) => {
-			return idbReq(make((await openDB()).transaction(name, mode).objectStore(name)));
+			const tx = (await openDB()).transaction(name, mode);
+			const result = idbReq(make(tx.objectStore(name)));
+			if (mode === "readonly") return result;
+			const committed = new Promise((resolve, reject) => {
+				tx.oncomplete = () => resolve();
+				tx.onabort = () => reject(tx.error ?? new DOMException("Transaction aborted", "AbortError"));
+			});
+			const [value] = await Promise.all([result, committed]);
+			return value;
 		};
 		return {
 			async get(key) {
@@ -13289,15 +13327,22 @@ var ERROR_HIDDEN_KEYS = [
 	"errors"
 ];
 function deepClone(value, options = {}) {
-	const seen = /* @__PURE__ */ new Map();
+	const seen = options.seen ?? /* @__PURE__ */ new Map();
 	/** Record `copy` as the copy of `obj` before its contents are copied. */
 	const keep = (obj, copy) => {
 		seen.set(obj, copy);
 		return copy;
 	};
-	/** Copy the own (enumerable) keys of `obj` into `copy`. */
+	/**
+	* Copy the own (enumerable) keys of `obj` into `copy`, symbol keys too: a
+	* save refuses them, which a copy must not hide.
+	*/
 	function copyKeys(obj, copy) {
 		for (const key of Object.keys(obj)) setOwn(copy, key, clone(obj[key]));
+		for (const sym of Object.getOwnPropertySymbols(obj)) {
+			if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) continue;
+			copy[sym] = clone(obj[sym]);
+		}
 		return copy;
 	}
 	function cloneBuiltin(val) {
@@ -13380,65 +13425,83 @@ function loosePairs() {
 /**
 * Pairs that also require the same reference structure: each object of one
 * value pairs with exactly one of the other, so shared references and
-* cycles are shared at the same places.
+* cycles are shared at the same places. `ab` and `ba` hold the pairs (and
+* may hold some already); those made are listed in `added`.
 */
-function strictPairs() {
-	const ab = /* @__PURE__ */ new Map();
-	const ba = /* @__PURE__ */ new Map();
-	const pairs = (a, b) => {
+function strictPairs(ab = /* @__PURE__ */ new Map(), ba = /* @__PURE__ */ new Map()) {
+	const added = [];
+	const pairs = ((a, b) => {
 		const known = ab.get(a);
 		if (known !== void 0) return known === b;
 		if (ba.has(b)) return false;
 		ab.set(a, b);
 		ba.set(b, a);
-	};
+		added.push([a, b]);
+	});
 	pairs.strict = true;
+	pairs.added = added;
 	return pairs;
 }
 /**
-* Whether `a` and `b` are equal as deepEqual() has it and also share
-* references at the same places (a save of one loads as the other).
-*/
-function deepEqualStrict(a, b) {
-	return equal(a, b, strictPairs());
-}
-/**
 * `curr` with each part that equals (see deepEqualStrict) the part of
 * `prev` at the same place replaced by `prev`'s: the history moments of a
 * save then share what did not change between them, which a save stores
 * once. Containers on the way to a change are copied; neither value is
-* changed. Shared references and cycles within `curr` stay so.
+* changed. The result has the reference structure of `curr`: what `curr`
+* shares or cycles through stays so, and what it does not share stays
+* apart, whichever parts are reused.
 */
 function shareEqual(prev, curr) {
+	if (!isObjectValue(prev) || !isObjectValue(curr)) return curr;
+	/** The object of the result standing for each object of `curr` met. */
 	const done = /* @__PURE__ */ new Map();
-	function share(p, c) {
-		if (p === c || !isObjectValue(c) || !isObjectValue(p)) return c;
-		if (done.has(c)) return done.get(c);
-		if (deepEqualStrict(p, c)) {
-			done.set(c, p);
-			return p;
+	/** The object of `curr` each object of `prev` in the result stands for. */
+	const used = /* @__PURE__ */ new Map();
+	/** `value` for the result: copied, as far as it is not met already. */
+	const fresh = (value) => isObjectValue(value) ? deepClone(value, {
+		keepUnregistered: true,
+		seen: done
+	}) : value;
+	/**
+	* Whether `p` and `c` are equal and so can stand for each other, which
+	* needs each object in them to stand for one object only, in the whole
+	* result. Then every pair of objects they hold is placed in the result.
+	*/
+	function reuse(p, c) {
+		const pairs = strictPairs(used, done);
+		if (equal(p, c, pairs)) return true;
+		for (const [a, b] of pairs.added) {
+			used.delete(a);
+			done.delete(b);
 		}
+		return false;
+	}
+	function share(p, c) {
+		if (!isObjectValue(c)) return c;
+		const placed = done.get(c);
+		if (placed !== void 0) return placed;
+		if (!isObjectValue(p)) return fresh(c);
+		if (reuse(p, c)) return p;
 		if (c instanceof Map && p instanceof Map) {
 			const out = /* @__PURE__ */ new Map();
 			done.set(c, out);
-			for (const [k, v] of c) out.set(k, p.has(k) ? share(p.get(k), v) : v);
+			for (const [k, v] of c) out.set(fresh(k), share(p.get(k), v));
 			return out;
 		}
 		if (Array.isArray(c) && Array.isArray(p)) {
 			const out = new Array(c.length);
 			done.set(c, out);
-			for (let i = 0; i < c.length; i++) if (i in c) out[i] = i < p.length ? share(p[i], c[i]) : c[i];
+			for (let i = 0; i < c.length; i++) if (i in c) out[i] = share(p[i], c[i]);
 			return out;
 		}
 		if (mergesWith(p, c, false)) {
 			const out = Object.create(Object.getPrototypeOf(c));
 			done.set(c, out);
 			const cr = c;
-			for (const key of Object.keys(cr)) setOwn(out, key, hasOwn(p, key) ? share(p[key], cr[key]) : cr[key]);
+			for (const key of Object.keys(cr)) setOwn(out, key, share(hasOwn(p, key) ? p[key] : void 0, cr[key]));
 			return out;
 		}
-		done.set(c, c);
-		return c;
+		return fresh(c);
 	}
 	return share(prev, curr);
 }
@@ -14912,7 +14975,10 @@ var lastNavigationVars = createNamespace();
 * object) or deleted. A recorded value is a deep copy, so that changing a
 * live value in place (a class instance is not frozen) cannot change
 * history; instances of unregistered classes are kept, as the store keeps
-* them (a save then refuses them).
+* them (a save then refuses them). The copies are made together, so what
+* variables share (an object, a cycle) stays shared in them, and a variable
+* left as it is that shares with a replaced one is recorded again, to share
+* with its copy.
 */
 function computeVarPatches(prev, curr) {
 	const forward = [];
@@ -14920,11 +14986,33 @@ function computeVarPatches(prev, curr) {
 		key,
 		deleted: true
 	});
-	for (const key of Object.keys(curr)) if (!hasOwn(prev, key) || !Object.is(prev[key], curr[key])) forward.push({
+	const seen = /* @__PURE__ */ new Map();
+	const record = (key) => forward.push({
 		key,
 		deleted: false,
-		value: deepClone(curr[key], { keepUnregistered: true })
+		value: deepClone(curr[key], {
+			keepUnregistered: true,
+			seen
+		})
 	});
+	const unchanged = [];
+	for (const key of Object.keys(curr)) if (!hasOwn(prev, key) || !Object.is(prev[key], curr[key])) record(key);
+	else if (typeof curr[key] === "object" && curr[key] !== null) unchanged.push(key);
+	for (let found = seen.size > 0; found;) {
+		found = false;
+		for (const key of unchanged) {
+			const probe = /* @__PURE__ */ new Map();
+			deepClone(curr[key], {
+				keepUnregistered: true,
+				seen: probe
+			});
+			if (![...probe.keys()].some((object) => seen.has(object))) continue;
+			record(key);
+			unchanged.splice(unchanged.indexOf(key), 1);
+			found = true;
+			break;
+		}
+	}
 	return { forward };
 }
 /**
@@ -16567,7 +16655,9 @@ var MacroArgumentError = class extends Error {
 		this.name = "MacroArgumentError";
 	}
 };
-function readValue(param, src) {
+/** Read `src`, at `place`, as `param` says. */
+function readValue(param, src, place) {
+	place.spans?.set(param, [place.at, place.at + src.length]);
 	switch (param.type) {
 		case "string": {
 			const value = readWholeQuoted(src);
@@ -16578,7 +16668,7 @@ function readValue(param, src) {
 		case "names": return src.split(",").map((name) => name.trim());
 		case "delay": return parseDelay(src);
 		case "number": return Number(src);
-		case "options": return readOptions(param.parameters ?? [], src);
+		case "options": return readOptions(param.parameters ?? [], src, place);
 		default: return src;
 	}
 }
@@ -16596,11 +16686,12 @@ function matchAt(re, src, pos) {
 }
 /**
 * Read keyword options (`goto "X" priority 5 once`). A keyword takes the
-* quoted string or digit run after it as its value; keywords that aren't
-* declared, and their values, are skipped. A keyword of a `string` parameter
-* must be followed by a quoted string.
+* quoted string (with or without whitespace before it) or digit run after
+* it as its value; keywords that aren't declared, and their values, are
+* skipped. A keyword of a `string` parameter must be followed by a quoted
+* string.
 */
-function readOptions(params, src) {
+function readOptions(params, src, { at, spans }) {
 	const options = {};
 	let i = 0;
 	while (i < src.length) {
@@ -16611,22 +16702,20 @@ function readOptions(params, src) {
 		}
 		i += key.length;
 		let val;
-		let quoted = null;
 		let j = i;
 		while (j < src.length && isWhitespace(src[j])) j++;
-		if (j > i) {
-			quoted = readQuoted(src, j);
-			const digits = quoted ? null : matchAt(DIGITS_RE, src, j);
-			if (quoted) {
-				val = quoted.value;
-				i = quoted.end;
-			} else if (digits) {
-				val = digits;
-				i = j + digits.length;
-			}
+		const quoted = readQuoted(src, j);
+		const digits = quoted || j === i ? null : matchAt(DIGITS_RE, src, j);
+		if (quoted) {
+			val = quoted.value;
+			i = quoted.end;
+		} else if (digits) {
+			val = digits;
+			i = j + digits.length;
 		}
 		const param = params.find((p) => p.name === key);
-		if (param?.type === "string" && (!quoted || val === void 0)) throw new MacroArgumentError(param, matchAt(WORD_OR_PUNCT_RE, src, j) ?? "");
+		if (param && param.type !== "flag" && val !== void 0) spans?.set(param, [at + j, at + i]);
+		if (param?.type === "string" && !quoted) throw new MacroArgumentError(param, matchAt(WORD_OR_PUNCT_RE, src, j) ?? "");
 		if (param?.type === "flag") options[key] = true;
 		else if (param?.type === "number") options[key] = Number(val ?? 0);
 		else if (param) options[key] = val;
@@ -16636,21 +16725,21 @@ function readOptions(params, src) {
 /** `inline %name` reads a transient variable; `inline % 2` is modulo. */
 var LEADING_OPERATOR_RE = /^(?:[-+*/&|^=<>?:,.]|%(?![A-Za-z_]))/;
 /**
-* The rest of `src` without the flag `word` as its last or first term, or
-* `null` if it has no such flag. Next to a binary operator the word is an
-* operand (`"a" + inline`), not a flag; the closing `/` of a regex literal
-* is not one.
+* Where the rest of `src` is without the flag `word` as its last or first
+* term, or `null` if it has no such flag. Next to a binary operator the
+* word is an operand (`"a" + inline`), not a flag; the closing `/` of a
+* regex literal is not one.
 */
 function takeFlag(src, word) {
 	const spans = terms(src);
 	if (spans.length < 2) return null;
 	if (slice(src, spans[spans.length - 1]) === word) {
-		const rest = src.slice(0, spans[spans.length - 2][1]);
-		if (!endsWithOperator(rest)) return rest;
+		const rest = [0, spans[spans.length - 2][1]];
+		if (!endsWithOperator(slice(src, rest))) return rest;
 	}
 	if (slice(src, spans[0]) === word) {
-		const rest = src.slice(spans[1][0]);
-		if (!LEADING_OPERATOR_RE.test(rest)) return rest;
+		const rest = [spans[1][0], src.length];
+		if (!LEADING_OPERATOR_RE.test(slice(src, rest))) return rest;
 	}
 	return null;
 }
@@ -16678,42 +16767,55 @@ function findSeparator(src, word) {
 	return null;
 }
 var takesRest = (param) => param.type === "expression" || param.type === "statements" || param.type === "passage" || param.type === "text";
-/** Read the parameters of one group from `src` (`null`: no text) into `args`. */
-function readGroup(params, src, args) {
-	let text = src?.trim() ?? "";
+/** The text of `src` without the whitespace around it, and where it is. */
+function trimmed(src, at) {
+	const text = src.trim();
+	return [text, text ? at + src.indexOf(text) : at];
+}
+/**
+* Read the parameters of one group from `src` (`null`: no text), which is
+* at `at` in the raw arguments, into `args`.
+*/
+function readGroup(params, src, args, { at: srcAt, spans }) {
+	let [text, at] = trimmed(src ?? "", srcAt);
 	for (const flag of params.filter((p) => p.type === "flag")) {
 		const rest = src === null ? null : takeFlag(text, flag.name);
 		args[flag.name] = rest !== null;
-		text = rest ?? text;
+		if (rest) [text, at] = trimmed(slice(text, rest), at + rest[0]);
 	}
 	const positional = params.filter((p) => p.type !== "flag");
 	if (positional.length === 0) return;
 	const lastText = positional.findIndex((p, i) => takesRest(p) && !positional.slice(i + 1).some(takesRest));
 	const restIndex = lastText < 0 ? positional.length - 1 : lastText;
-	const read = (param, value) => value === "" ? unset(param) : readValue(param, value);
+	/** Read `param` from the text from `start` to `end`. */
+	const read = (param, [start, end]) => start === end ? unset(param) : readValue(param, text.slice(start, end), {
+		at: at + start,
+		spans
+	});
 	if (positional.length === 1) {
-		args[positional[0].name] = read(positional[0], text);
+		args[positional[0].name] = read(positional[0], [0, text.length]);
 		return;
 	}
-	const spans = terms(text);
+	const parts = terms(text);
 	let from = 0;
-	let to = spans.length;
-	for (const param of positional.slice(0, restIndex)) args[param.name] = from < to ? read(param, slice(text, spans[from++])) : unset(param);
-	const readTrailing = (param, value) => {
+	let to = parts.length;
+	for (const param of positional.slice(0, restIndex)) args[param.name] = from < to ? read(param, parts[from++]) : unset(param);
+	const readTrailing = (param, span) => {
 		try {
-			return read(param, value);
+			return read(param, span);
 		} catch (error) {
 			if (error instanceof MacroArgumentError) return void 0;
 			throw error;
 		}
 	};
 	for (const param of positional.slice(restIndex + 1).reverse()) {
-		const value = from < to && !endsWithOperator(text.slice(0, spans[to - 1][0])) ? readTrailing(param, slice(text, spans[to - 1])) : void 0;
+		const value = from < to && !endsWithOperator(text.slice(0, parts[to - 1][0])) ? readTrailing(param, parts[to - 1]) : void 0;
 		args[param.name] = value ?? unset(param);
 		if (value !== void 0) to--;
+		else spans?.delete(param);
 	}
 	const rest = positional[restIndex];
-	args[rest.name] = from < to ? read(rest, text.slice(spans[from][0], spans[to - 1][1])) : unset(rest);
+	args[rest.name] = from < to ? read(rest, [parts[from][0], parts[to - 1][1]]) : unset(rest);
 }
 /** The duration a timing macro ({repeat}, {type}, {timed}/{next}) waits. */
 var DELAY_PARAMETER = {
@@ -16721,32 +16823,43 @@ var DELAY_PARAMETER = {
 	type: "delay",
 	required: true
 };
-/** Read `rawArgs` into the declared `parameters` (see above). */
-function parseMacroArgs(rawArgs, parameters) {
+/**
+* Read `rawArgs` into the declared `parameters` (see above). With `spans`,
+* note there where each argument set was read.
+*/
+function parseMacroArgs(rawArgs, parameters, spans) {
 	const args = {};
-	let rest = rawArgs.trim();
+	let [rest, restAt] = trimmed(rawArgs, 0);
 	let groupStart = 0;
 	parameters.forEach((separator, i) => {
 		if (separator.type !== "separator") return;
 		const at = rest === null ? null : findSeparator(rest, separator.name);
 		args[separator.name] = at !== null;
 		const before = at ? rest.slice(0, at[0]) : rest;
-		readGroup(parameters.slice(groupStart, i), before, args);
+		readGroup(parameters.slice(groupStart, i), before, args, {
+			at: restAt,
+			spans
+		});
 		rest = at ? rest.slice(at[1]) : null;
+		if (at) restAt += at[1];
 		groupStart = i + 1;
 	});
-	readGroup(parameters.slice(groupStart), rest, args);
+	readGroup(parameters.slice(groupStart), rest, args, {
+		at: restAt,
+		spans
+	});
 	return args;
 }
 /**
 * Read a `passage` argument as written (`{goto "Hall"}`, `{goto $room}`): a
-* quoted string is the name its JavaScript literal has (`"\u0048all"` is
-* `Hall`), anything else an expression, whose value is the name when it
+* string literal is the name JavaScript reads from it (`"\u0048all"` is
+* `Hall`), anything else (a literal that is not well-formed too) an
+* expression, whose value is the name when it
 * runs (see evaluatePassageName).
 */
 function passageTarget(arg) {
 	const expression = arg.trim();
-	const name = readWholeJsString(expression);
+	const name = stringLiteralValue(expression);
 	return name === null ? {
 		kind: "expression",
 		expression
@@ -16795,6 +16908,7 @@ function parseVarArgs(rawArgs) {
 var OPTION_PARAMETERS = [{
 	name: "value",
 	type: "string",
+	holds: "text",
 	required: true
 }];
 /** The parameters of the built-in sub-macros that take arguments. */
@@ -17269,30 +17383,59 @@ var CONDITION_MACROS = new Set([
 	"elseif",
 	"case"
 ]);
-/** Code inside the quoted strings of a macro's arguments, by parameter. */
-var CODE_IN_STRINGS = new Map([["watch", {
-	condition: "expression",
-	run: "statements"
-}]]);
-/** The `string` parameters of a macro that name a passage. */
-var PASSAGE_STRINGS = new Map([["watch", ["goto", "dialog"]]]);
-/**
-* The `text` and `string` parameters of a macro that the runtime keeps as
-* written, not as markup: an option's value, the name of a watcher.
-*/
-var LITERAL_STRINGS = new Map([
-	["option", ["value"]],
-	["watch", ["name"]],
-	["unwatch", ["name"]]
-]);
 /** Block macros whose body is the name of a passage. */
 var PASSAGE_BODIES = new Set(["dialog"]);
+/**
+* `params` with each `string` and `text` parameter (options too) saying
+* what it holds: what it declares, else `holds`.
+*/
+function withHolds(params, holds) {
+	return params.map((param) => {
+		if (param.parameters) return {
+			...param,
+			parameters: withHolds(param.parameters, holds)
+		};
+		return (param.type === "string" || param.type === "text") && !param.holds ? {
+			...param,
+			holds
+		} : param;
+	});
+}
+/**
+* The declared parameters of `macros`, by name in any case, and of the
+* built-in sub-macros (`{option}`): what the story-start check, reference
+* collection and tooling read arguments by. Each `string` and `text`
+* parameter says what it holds: what it declares, else `markup` for a macro
+* with `interpolate` (which can resolve markup) and `text` for any other.
+*/
+function parameterLookup(macros) {
+	const parameters = new NameMap();
+	for (const { name, parameters: params, interpolate } of macros) if (params) parameters.set(name, withHolds(params, holdsByDefault(interpolate)));
+	return (name) => {
+		let params = parameters.get(name);
+		if (!params) {
+			const sub = subMacroParameters(name);
+			if (sub) parameters.set(name, params = withHolds(sub, "text"));
+		}
+		return params;
+	};
+}
+/** What a `string` or `text` argument holds when its parameter doesn't say. */
+var holdsByDefault = (interpolate) => interpolate ? "markup" : "text";
 /** The goal of the code an argument of this type holds, if it is code. */
 function codeGoal(param) {
 	if (param.type === "expression" || param.type === "passage") return "expression";
 	if (param.type === "statements") return "statements";
 }
 /**
+* What a `string` or `text` argument holds: what its parameter says (see
+* parameterLookup), else markup, which is checked.
+*/
+function stringHolds(param) {
+	if (param.type !== "string" && param.type !== "text") return void 0;
+	return param.holds ?? "markup";
+}
+/**
 * The code and the markup-holding text in `tokens`, the tokens of `src`.
 * `parametersOf` gives the declared parameters of a macro, if it has any.
 */
@@ -17304,8 +17447,8 @@ function* codeAndText(src, tokens, parametersOf) {
 		if (token.type === "link") yield {
 			kind: "passage",
 			name: token.target,
-			offset: locate(src, token.target, token.start),
-			length: token.target.length,
+			offset: token.targetStart,
+			length: token.targetEnd - token.targetStart,
 			macro: "link",
 			label: src.slice(token.start, token.end)
 		};
@@ -17316,32 +17459,35 @@ function* codeAndText(src, tokens, parametersOf) {
 			goal: "expression",
 			label: `{${token.expression}}`
 		};
-		else if (token.type === "html") for (const [name, value] of Object.entries(token.attributes)) {
-			const at = locate(src, value, token.start);
-			if (!isCodeAttribute(name)) {
-				yield {
-					kind: "text",
-					text: value,
-					offset: at,
-					where: `In the ${name} attribute of <${token.tag}>: `
-				};
-				continue;
-			}
-			let from = 0;
-			for (const part of splitSigilTemplate(value)) {
-				if (!("expr" in part)) continue;
-				const k = locate(value, part.expr, from);
-				from = k + part.expr.length;
-				yield {
-					kind: "code",
-					code: part.expr,
-					offset: at + k,
-					goal: "expression",
-					label: `{${part.expr}} in the ${name} attribute of <${token.tag}>`
-				};
+		else if (token.type === "html") {
+			let cursor = token.start;
+			for (const [name, value] of Object.entries(token.attributes)) {
+				const at = locate(src, value, cursor);
+				cursor = at + value.length;
+				if (!isCodeAttribute(name)) {
+					yield {
+						kind: "text",
+						text: value,
+						offset: at,
+						where: `In the ${name} attribute of <${token.tag}>: `
+					};
+					continue;
+				}
+				let from = 0;
+				for (const part of splitSigilTemplate(value)) {
+					if (!("expr" in part)) continue;
+					const k = locate(value, part.expr, from);
+					from = k + part.expr.length;
+					yield {
+						kind: "code",
+						code: part.expr,
+						offset: at + k,
+						goal: "expression",
+						label: `{${part.expr}} in the ${name} attribute of <${token.tag}>`
+					};
+				}
 			}
-		}
-		else if (token.type === "macro" && !token.isClose) {
+		} else if (token.type === "macro" && !token.isClose) {
 			const name = token.name.toLowerCase();
 			if (name === "do") {
 				const close = closeOf(t, name);
@@ -17361,12 +17507,13 @@ function* codeAndText(src, tokens, parametersOf) {
 				const close = closeOf(t, name);
 				const body = tokens.slice(t + 1, close);
 				if (close > t + 1 && body.every((b) => b.type === "text")) {
-					const passage = src.slice(token.end, tokens[close].start).trim().replace(/^["']|["']$/g, "");
+					const text = src.slice(token.end, tokens[close].start);
+					const written = text.trim();
 					yield {
 						kind: "passage",
-						name: passage,
-						offset: locate(src, passage, token.end),
-						length: passage.length,
+						name: written.replace(/^["']|["']$/g, ""),
+						offset: token.end + text.indexOf(written),
+						length: written.length,
 						macro: name,
 						label: src.slice(token.start, token.end)
 					};
@@ -17374,7 +17521,8 @@ function* codeAndText(src, tokens, parametersOf) {
 			}
 			if (!args) continue;
 			const label = `{${token.name} ${args}}`;
-			const argsAt = locate(src, args, token.start + 1);
+			const tag = src.slice(token.start, token.end - 1);
+			const argsAt = token.start + tag.trimEnd().length - args.length;
 			if (CONDITION_MACROS.has(name)) {
 				yield {
 					kind: "code",
@@ -17393,8 +17541,9 @@ function* codeAndText(src, tokens, parametersOf) {
 /** The code and text in the arguments `args` (at `offset`) of `macro`. */
 function* argPieces(args, offset, params, macro, label) {
 	let values;
+	const spans = /* @__PURE__ */ new Map();
 	try {
-		values = parseMacroArgs(args, params);
+		values = parseMacroArgs(args, params, spans);
 	} catch (error) {
 		if (!(error instanceof MacroArgumentError)) throw error;
 		yield {
@@ -17405,11 +17554,7 @@ function* argPieces(args, offset, params, macro, label) {
 		};
 		return;
 	}
-	const key = macro.toLowerCase();
-	const inStrings = CODE_IN_STRINGS.get(key) ?? {};
-	const passageStrings = PASSAGE_STRINGS.get(key) ?? [];
-	const literalStrings = LITERAL_STRINGS.get(key) ?? [];
-	let cursor = 0;
+	const name = macro.toLowerCase();
 	/** The pieces of the parameters `list`, with their values in `from`. */
 	function* visit(list, from) {
 		for (const param of list) {
@@ -17418,47 +17563,62 @@ function* argPieces(args, offset, params, macro, label) {
 				yield* visit(param.parameters, value ?? {});
 				continue;
 			}
-			if (typeof value !== "string" || !value.trim()) continue;
-			const at = locate(args, value, cursor);
-			if (at >= cursor) cursor = at + value.length;
-			const goal = codeGoal(param) ?? inStrings[param.name];
+			const span = spans.get(param);
+			if (typeof value !== "string" || !value.trim() || !span) continue;
+			const [start, end] = span;
+			const written = args.slice(start, end);
+			/** The name as written (quotes included), at the argument. */
+			const passage = (passageName) => ({
+				kind: "passage",
+				name: passageName,
+				offset: offset + start,
+				length: end - start,
+				macro: name,
+				label
+			});
+			const goal = codeGoal(param);
+			if (param.type === "passage") {
+				const target = passageTarget(value);
+				if (target.kind === "name") {
+					yield passage(target.name);
+					continue;
+				}
+			}
 			if (goal) {
 				const piece = {
 					kind: "code",
 					code: value,
-					offset: offset + at,
+					offset: offset + start,
 					goal,
 					label
 				};
 				if (param.type === "passage") {
 					piece.passage = true;
-					piece.macro = macro.toLowerCase();
+					piece.macro = name;
 				}
-				if (!codeGoal(param)) piece.inString = true;
 				yield piece;
+				continue;
 			}
-			const written = param.type === "passage" ? value.trim() : value;
-			const target = param.type === "passage" ? passageTarget(value) : passageStrings.includes(param.name) ? {
-				kind: "name",
-				name: value
-			} : null;
-			if (target?.kind === "name") yield {
-				kind: "passage",
-				name: target.name,
-				offset: offset + at + value.indexOf(written),
-				length: written.length,
-				macro: macro.toLowerCase(),
-				label
+			const at = offset + start + (value !== written && /^["']/.test(written) ? 1 : 0);
+			const holds = stringHolds(param);
+			if (holds === "expression" || holds === "statements") yield {
+				kind: "code",
+				code: value,
+				offset: at,
+				goal: holds,
+				label,
+				inString: true
 			};
-			if (!goal && (param.type === "text" || param.type === "string") && !literalStrings.includes(param.name)) yield {
+			else if (holds === "passage") yield passage(value);
+			else if (holds === "markup") yield {
 				kind: "text",
 				text: value,
-				offset: offset + at,
+				offset: at,
 				where: `In the ${param.name} of {${macro}}: `
 			};
 		}
 	}
-	yield* visit(params, values);
+	yield* [...visit(params, values)].sort((a, b) => a.offset - b.offset);
 }
 /**
 * Index of `part` in `text` from `from` on, else anywhere, else `from`: the
@@ -17480,10 +17640,12 @@ function locate(text, part, from) {
 var WIDGET_PARAMETERS = [{
 	name: "name",
 	type: "text",
+	holds: "text",
 	required: true
 }, {
 	name: "parameters",
-	type: "text"
+	type: "text",
+	holds: "text"
 }];
 /**
 * The widget a {widget} definition's arguments declare: its name and its
@@ -17643,7 +17805,7 @@ function validateMarkup(passages, options) {
 			report(passage, base + token.start, `${where}Unknown macro {${token.name}}.${didYouMean(token.name, names, (n) => `{${n}}`)}`);
 		}
 	};
-	const parametersOf = (name) => options.parametersOf?.(name) ?? subMacroParameters(name);
+	const parametersOf = options.parametersOf ?? (() => void 0);
 	/**
 	* Check `tokens`, the tokens of `src`, which starts at `base` in the
 	* passage: their macros, the code in them and the markup in their text.
@@ -17711,7 +17873,6 @@ function declarationRegex(sigil) {
 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;
 var VALID_VAR_TYPES = new Set([
 	"number",
 	"string",
@@ -17774,30 +17935,14 @@ function parseStoryVariables(content, sigil = "$") {
 	return schema;
 }
 /**
-* Extract for-loop local variable names from passage content.
-* `{for @item of ...}` → "item"
-* `{for @index, @item of ...}` → "index", "item"
-*/
-function extractForLocals(content) {
-	const locals = /* @__PURE__ */ new Set();
-	let match;
-	FOR_LOCAL_RE.lastIndex = 0;
-	while ((match = FOR_LOCAL_RE.exec(content)) !== null) {
-		locals.add(match[1]);
-		if (match[2]) locals.add(match[2]);
-	}
-	return locals;
-}
-/**
 * Validate a single variable reference path (e.g. "player.health") against
 * the schema. Returns an error message or null if valid.
 */
-function validateRef(ref, schema, forLocals) {
+function validateRef(ref, schema) {
 	const parts = ref.split(".");
 	const rootName = parts[0];
 	const nameError = variableNameError(rootName, "$" + rootName);
 	if (nameError) return nameError;
-	if (forLocals.has(rootName)) return null;
 	const rootSchema = schema.get(rootName);
 	if (!rootSchema) return `Undeclared variable: $${ref}`;
 	let current = rootSchema;
@@ -17853,8 +17998,9 @@ function scanInterpolations(text, onRef, storeVarMacros = NO_STORE_VAR_MACROS) {
 * 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.
+* The text of string and template literals is not scanned: a string in code
+* is literal text unless a macro argument that holds markup is read as such
+* (see scanArgs); the `${…}` parts of template literals are code.
 */
 function scanCode(code, onRef, goal = "expression") {
 	const parsed = parseOrError(code, goal);
@@ -17867,37 +18013,17 @@ function scanCode(code, onRef, goal = "expression") {
 		VAR_PATH_RE.lastIndex = ref.start;
 		onRef(VAR_PATH_RE.exec(code)[1]);
 	}
-	for (const text of parsed.strings) scanInterpolations(text, onRef);
 }
 /** `scanCode` for code acorn can't parse: lexed leniently. */
 function scanCodeLeniently(code, onRef, goal) {
-	/** 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);
-			}
-		}
+		literal() {}
 	}, goal);
-	for (const t of templates) if (t.text) scanInterpolations(t.text, onRef);
 }
 /**
 * Report the `$var` references a passage evaluates at runtime: `{$var}`
@@ -17909,13 +18035,23 @@ function collectPassageRefs(content, storeVarMacros, onRef, parametersOf) {
 	withParseCache(() => collectTokenRefs(content, tokensOf(content, false), storeVarMacros, onRef, parametersOf));
 }
 /**
-* Report the references in the code that a macro's quoted arguments hold,
-* the condition and `run` action of `{watch}`: the argument scan sees only
-* the strings.
+* Report the references in the arguments of a macro by what its parameters
+* say each holds (see ParameterDef.holds): code is scanned as code and
+* markup as markup, but literal text (a placeholder, a passage name) holds
+* none. A macro without declared parameters, or arguments that do not
+* parse, are scanned as code.
 */
-function scanStringCode(token, params, onRef) {
-	if (!params || !token.rawArgs) return;
-	for (const piece of argPieces(token.rawArgs, 0, params, token.name, "")) if (piece.kind === "code" && piece.inString) scanCode(piece.code, onRef, piece.goal);
+function scanArgs(token, params, onRef) {
+	if (!token.rawArgs) return;
+	if (params) {
+		const pieces = [...argPieces(token.rawArgs, 0, params, token.name, "")];
+		if (!pieces.some((piece) => piece.kind === "argument-error")) {
+			for (const piece of pieces) if (piece.kind === "code") scanCode(piece.code, onRef, piece.goal);
+			else if (piece.kind === "text") scanInterpolations(piece.text, onRef);
+			return;
+		}
+	}
+	scanCode(token.rawArgs, onRef);
 }
 /** Report the `$var` references in the tokens of `content`. */
 function collectTokenRefs(content, tokens, storeVarMacros, onRef, parametersOf = () => void 0) {
@@ -17927,12 +18063,12 @@ function collectTokenRefs(content, tokens, storeVarMacros, onRef, parametersOf =
 		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, onRef);
-			scanStringCode(token, parametersOf(token.name), onRef);
+			scanArgs(token, parametersOf(token.name), onRef);
 			if (storeVarMacros.has(token.name.toLowerCase())) {
 				const first = token.rawArgs.trim().split(/\s+/)[0] ?? "";
 				const quoted = QUOTED_VAR_ARG_RE.exec(first);
 				if (quoted) onRef(quoted[1]);
+				else if (!/^["'`]/.test(first)) scanCode(first, onRef);
 			}
 			if (token.name === "do") {
 				let close = t + 1;
@@ -17962,9 +18098,8 @@ function validatePassages(passages, schema, storeVarMacros = BUILTIN_STORE_VAR_M
 	const storeVarSet = new Set(Array.from(storeVarMacros, (m) => m.toLowerCase()));
 	for (const [name, passage] of passages) {
 		if (NOT_MARKUP.has(name)) continue;
-		const forLocals = extractForLocals(passage.content);
 		collectPassageRefs(passage.content, storeVarSet, (ref) => {
-			const error = validateRef(ref, schema, forLocals);
+			const error = validateRef(ref, schema);
 			if (error) errors.push(`Passage "${name}": ${error}`);
 		}, parametersOf);
 	}
@@ -18221,12 +18356,16 @@ defineMacro({
 		},
 		{
 			name: "label",
-			type: "string"
+			type: "string",
+			holds: "markup"
 		}
 	],
 	render(_props, ctx) {
 		try {
-			const { currentExpr, maxExpr, labelMode } = meterArgs(ctx.args);
+			const { currentExpr, maxExpr, labelMode } = meterArgs({
+				...ctx.args,
+				label: ctx.resolve?.(ctx.args.label)
+			});
 			const current = Number(ctx.evaluate(currentExpr));
 			const max = Number(ctx.evaluate(maxExpr));
 			const pct = max === 0 ? 0 : Math.max(0, Math.min(100, current / max * 100));
@@ -18588,6 +18727,7 @@ defineMacro({
 	parameters: [{
 		name: "label",
 		type: "text",
+		holds: "markup",
 		required: true
 	}],
 	render({ rawArgs, children = [] }, ctx) {
@@ -18619,13 +18759,14 @@ defineMacro({
 	parameters: [{
 		name: "text",
 		type: "string",
+		holds: "markup",
 		required: true
 	}, {
 		name: "passage",
 		type: "passage"
 	}],
 	render({ children = [] }, ctx) {
-		const display = ctx.args.text ?? "";
+		const display = ctx.resolve?.(ctx.args.text ?? "") ?? "";
 		let passage = null;
 		let failure;
 		if (ctx.args.passage !== void 0) try {
@@ -18948,6 +19089,7 @@ defineMacro({
 	parameters: [{
 		name: "label",
 		type: "text",
+		holds: "markup",
 		required: true
 	}, {
 		name: "noclose",
@@ -19494,7 +19636,8 @@ function defineInputMacro(name, type, toValue = (input) => input !== void 0 ? St
 		storeVar: true,
 		parameters: [VARIABLE_PARAMETER, {
 			name: "placeholder",
-			type: "string"
+			type: "string",
+			holds: "text"
 		}],
 		render(_props, ctx) {
 			const placeholder = ctx.args.placeholder ?? "";
@@ -19530,7 +19673,8 @@ defineMacro({
 	storeVar: true,
 	parameters: [VARIABLE_PARAMETER, {
 		name: "label",
-		type: "text"
+		type: "text",
+		holds: "text"
 	}],
 	render(_props, ctx) {
 		const label = ctx.args.label ?? "";
@@ -19561,11 +19705,13 @@ defineMacro({
 		{
 			name: "value",
 			type: "text",
+			holds: "text",
 			required: true
 		},
 		{
 			name: "label",
-			type: "text"
+			type: "text",
+			holds: "text"
 		}
 	],
 	render(_props, ctx) {
@@ -19985,6 +20131,7 @@ defineMacro({
 	parameters: [{
 		name: "condition",
 		type: "string",
+		holds: "expression",
 		required: true
 	}, {
 		name: "options",
@@ -19992,19 +20139,23 @@ defineMacro({
 		parameters: [
 			{
 				name: "goto",
-				type: "string"
+				type: "string",
+				holds: "passage"
 			},
 			{
 				name: "dialog",
-				type: "string"
+				type: "string",
+				holds: "passage"
 			},
 			{
 				name: "run",
-				type: "string"
+				type: "string",
+				holds: "statements"
 			},
 			{
 				name: "name",
-				type: "string"
+				type: "string",
+				holds: "text"
 			},
 			{
 				name: "priority",
@@ -20033,6 +20184,7 @@ defineMacro({
 	parameters: [{
 		name: "name",
 		type: "text",
+		holds: "text",
 		required: true
 	}],
 	render(_props, ctx) {
@@ -20081,11 +20233,10 @@ function stopWithErrors(errors) {
 */
 function markupErrors(storyData, only) {
 	const macros = getMacroRegistry();
-	const parameters = new Map(macros.map((m) => [m.name.toLowerCase(), m.parameters]));
 	return validateMarkup(storyData.passages.values(), {
 		isKnownMacro: (name) => !!getMacro(name) || isSubMacro(name) || !!getWidget(name),
 		macroNames: macros.map((m) => m.name),
-		parametersOf: (name) => parameters.get(name),
+		parametersOf: parameterLookup(macros),
 		only
 	}).map(formatDiagnostic);
 }