@rohal12/spindle 0.56.0 → 0.58.0

package/dist/pkg/story-variables.js

@@ -1,12 +1,39 @@
-//#region src/markup/spindle.peggy
-var LB = String.fromCharCode(123);
-var RB = String.fromCharCode(125);
-var SIGIL_SCOPES$1 = {
+//#region src/markup/tokens.ts
+/** Variable sigils: story ($), temporary (_), local (@), transient (%). */
+var SIGIL_SCOPES = {
 	$: "variable",
 	_: "temporary",
 	"@": "local",
 	"%": "transient"
 };
+Object.fromEntries(Object.entries(SIGIL_SCOPES).map(([sigil, scope]) => [scope, sigil]));
+var SIGIL_CHARS = new Set(Object.keys(SIGIL_SCOPES));
+/** Whether `c` is a variable sigil. */
+function isSigil(c) {
+	return c !== void 0 && SIGIL_CHARS.has(c);
+}
+/** Copy the selectors set in `from` onto `target`, and return it. */
+function withSelectors$1(target, from) {
+	if (from.className) target.className = from.className;
+	if (from.id) target.id = from.id;
+	return target;
+}
+//#endregion
+//#region src/markup/grammar-shared.ts
+/**
+* What the grammar (spindle.peggy) imports from the rest of Spindle, so that
+* it holds no second copy: the generated parser imports this module's
+* default export as `shared` (see scripts/peggy.ts).
+*/
+var grammar_shared_default = {
+	SIGIL_SCOPES,
+	withSelectors: withSelectors$1
+};
+//#endregion
+//#region src/markup/spindle.peggy
+var LB = String.fromCharCode(123);
+var RB = String.fromCharCode(125);
+var { SIGIL_SCOPES: SIGIL_SCOPES$1, withSelectors } = grammar_shared_default;
 var VOID_TAGS = new Set([
 	"area",
 	"base",
@@ -64,11 +91,6 @@ function parseLink(inner) {
 function quoteArg(value) {
 	return "\"" + value.replace(/[\\"]/g, "\\$&") + "\"";
 }
-function withSelectors(target, from) {
-	if (from.className) target.className = from.className;
-	if (from.id) target.id = from.id;
-	return target;
-}
 function selectorsOf(parts) {
 	const classes = [];
 	let id = "";
@@ -288,7 +310,8 @@ function peg$parse(input, options) {
 	const peg$source = options.grammarSource;
 	const peg$startRuleFunctions = {
 		Markup: peg$parseMarkup,
-		Tokens: peg$parseTokens
+		Tokens: peg$parseTokens,
+		SelectorsPrefix: peg$parseSelectorsPrefix
 	};
 	let peg$startRuleFunction = peg$parseMarkup;
 	const peg$c0 = "\\";
@@ -690,40 +713,46 @@ function peg$parse(input, options) {
 	function peg$f53() {
 		return NO_SELECTORS;
 	}
-	function peg$f54(prefix, name) {
+	function peg$f54(s, end) {
+		return {
+			...s,
+			end
+		};
+	}
+	function peg$f55(prefix, name) {
 		return [prefix, name];
 	}
-	function peg$f55(s, sigil, name) {
+	function peg$f56(s, sigil, name) {
 		return withSelectors(lexeme("variable", location(), {
 			name,
 			scope: SIGIL_SCOPES$1[sigil]
 		}), s);
 	}
-	function peg$f56(s, expression) {
+	function peg$f57(s, expression) {
 		return withSelectors(lexeme("expression", location(), { expression }), s);
 	}
-	function peg$f57() {
+	function peg$f58() {
 		fail("Unclosed " + LB + input.substr(location().end.offset, 1) + "…: no } ends it", location());
 	}
-	function peg$f58(start) {
+	function peg$f59(start) {
 		return skipTo(hooks.closeBrace(input, start, start));
 	}
-	function peg$f59(start) {
+	function peg$f60(start) {
 		return skipEnd - offset();
 	}
-	function peg$f60(start, code) {
+	function peg$f61(start, code) {
 		return code;
 	}
-	function peg$f61(s, start, close, name, nameEnd) {
+	function peg$f62(s, start, close, name, nameEnd) {
 		return skipTo(hooks.closeBrace(input, nameEnd, start));
 	}
-	function peg$f62(s, start, close, name, nameEnd) {
+	function peg$f63(s, start, close, name, nameEnd) {
 		return skipEnd - offset();
 	}
-	function peg$f63(s, start, close, name, nameEnd, args) {
+	function peg$f64(s, start, close, name, nameEnd, args) {
 		return args;
 	}
-	function peg$f64(s, start, close, name, nameEnd, tail) {
+	function peg$f65(s, start, close, name, nameEnd, tail) {
 		const loc = location();
 		const lower = name.toLowerCase();
 		const tag = lexeme("macro", loc, {
@@ -744,19 +773,19 @@ function peg$parse(input, options) {
 		}
 		return tag;
 	}
-	function peg$f65(s) {
+	function peg$f66(s) {
 		fail("A closing tag starts with a letter after " + LB + "/", location());
 	}
-	function peg$f66() {
+	function peg$f67() {
 		return !textMode;
 	}
-	function peg$f67(tag) {
+	function peg$f68(tag) {
 		return VOID_TAGS.has(tag.lower);
 	}
-	function peg$f68(tag) {
+	function peg$f69(tag) {
 		return null;
 	}
-	function peg$f69(tag, list, slash) {
+	function peg$f70(tag, list, slash) {
 		const lower = tag.toLowerCase();
 		return lexeme("html", location(), {
 			tag,
@@ -766,7 +795,7 @@ function peg$parse(input, options) {
 			isSelfClose: !!slash || VOID_TAGS.has(lower)
 		});
 	}
-	function peg$f70(tag, bad) {
+	function peg$f71(tag, bad) {
 		const c = input.charAt(bad);
 		if (!c) fail("Unclosed tag <" + tag + ": no > ends it (write &lt; for a < that starts no tag)", location());
 		const at = {
@@ -784,7 +813,7 @@ function peg$parse(input, options) {
 		};
 		fail("Unexpected " + JSON.stringify(c) + " in the tag <" + tag + ">: expected an attribute, or > to end the tag", at);
 	}
-	function peg$f71(tag) {
+	function peg$f72(tag) {
 		return lexeme("html", location(), {
 			tag,
 			lower: tag.toLowerCase(),
@@ -793,44 +822,44 @@ function peg$parse(input, options) {
 			isSelfClose: false
 		});
 	}
-	function peg$f72(name) {
+	function peg$f73(name) {
 		attrCode = hooks.isCodeAttribute(name);
 		return true;
 	}
-	function peg$f73(name, v) {
+	function peg$f74(name, v) {
 		return v;
 	}
-	function peg$f74(name, value) {
+	function peg$f75(name, value) {
 		return [name, value ?? ""];
 	}
-	function peg$f75(v) {
+	function peg$f76(v) {
 		return v;
 	}
-	function peg$f76(v) {
+	function peg$f77(v) {
 		return v;
 	}
-	function peg$f77(q) {
+	function peg$f78(q) {
 		fail("Unclosed attribute value: the " + q + " here has no closing " + q, location());
 	}
-	function peg$f78() {
+	function peg$f79() {
 		return !attrCode;
 	}
-	function peg$f79(bs) {
+	function peg$f80(bs) {
 		return bs.length % 2 === 1;
 	}
-	function peg$f80() {
+	function peg$f81() {
 		return !attrCode;
 	}
-	function peg$f81(start, nameEnd) {
+	function peg$f82(start, nameEnd) {
 		return skipTo(hooks.closeBrace(input, nameEnd, start));
 	}
-	function peg$f82(start, nameEnd) {
+	function peg$f83(start, nameEnd) {
 		return skipEnd - offset();
 	}
-	function peg$f83() {
+	function peg$f84() {
 		return !attrCode;
 	}
-	function peg$f84() {
+	function peg$f85() {
 		return attrCode;
 	}
 	let peg$currPos = options.peg$currPos | 0;
@@ -1919,6 +1948,38 @@ function peg$parse(input, options) {
 		}
 		return s0;
 	}
+	function peg$parseSelectorsPrefix() {
+		let s0, s1, s2, s3, s4;
+		s0 = peg$currPos;
+		s1 = peg$parseSelectors();
+		if (s1 !== peg$FAILED) {
+			s2 = peg$parseHere();
+			s3 = [];
+			if (input.length > peg$currPos) {
+				s4 = input.charAt(peg$currPos);
+				peg$currPos++;
+			} else {
+				s4 = peg$FAILED;
+				if (peg$silentFails === 0) peg$fail(peg$e0);
+			}
+			while (s4 !== peg$FAILED) {
+				s3.push(s4);
+				if (input.length > peg$currPos) {
+					s4 = input.charAt(peg$currPos);
+					peg$currPos++;
+				} else {
+					s4 = peg$FAILED;
+					if (peg$silentFails === 0) peg$fail(peg$e0);
+				}
+			}
+			peg$savedPos = s0;
+			s0 = peg$f54(s1, s2);
+		} else {
+			peg$currPos = s0;
+			s0 = peg$FAILED;
+		}
+		return s0;
+	}
 	function peg$parseSelectorPart() {
 		let s0, s1, s2, s3, s4;
 		s0 = peg$currPos;
@@ -1938,7 +1999,7 @@ function peg$parse(input, options) {
 			}
 			s2 = input.substring(s2, peg$currPos);
 			peg$savedPos = s0;
-			s0 = peg$f54(s1, s2);
+			s0 = peg$f55(s1, s2);
 		} else {
 			peg$currPos = s0;
 			s0 = peg$FAILED;
@@ -2063,7 +2124,7 @@ function peg$parse(input, options) {
 					}
 					if (s5 !== peg$FAILED) {
 						peg$savedPos = s0;
-						s0 = peg$f55(s2, s3, s4);
+						s0 = peg$f56(s2, s3, s4);
 					} else {
 						peg$currPos = s0;
 						s0 = peg$FAILED;
@@ -2117,7 +2178,7 @@ function peg$parse(input, options) {
 							}
 							if (s5 !== peg$FAILED) {
 								peg$savedPos = s0;
-								s0 = peg$f56(s2, s4);
+								s0 = peg$f57(s2, s4);
 							} else {
 								peg$currPos = s0;
 								s0 = peg$FAILED;
@@ -2165,7 +2226,7 @@ function peg$parse(input, options) {
 						} else s3 = peg$FAILED;
 						if (s3 !== peg$FAILED) {
 							peg$savedPos = s0;
-							s0 = peg$f57();
+							s0 = peg$f58();
 						} else {
 							peg$currPos = s0;
 							s0 = peg$FAILED;
@@ -2187,12 +2248,12 @@ function peg$parse(input, options) {
 		s0 = peg$currPos;
 		s1 = peg$parseHere();
 		peg$savedPos = peg$currPos;
-		s2 = peg$f58(s1);
+		s2 = peg$f59(s1);
 		if (s2) s2 = void 0;
 		else s2 = peg$FAILED;
 		if (s2 !== peg$FAILED) {
 			s3 = peg$currPos;
-			s4 = peg$f59(s1);
+			s4 = peg$f60(s1);
 			s5 = peg$currPos;
 			s6 = [];
 			if (s6.length >= (s4 | 0)) s7 = peg$FAILED;
@@ -2223,7 +2284,7 @@ function peg$parse(input, options) {
 			else s3 = s4;
 			if (s3 !== peg$FAILED) {
 				peg$savedPos = s0;
-				s0 = peg$f60(s1, s3);
+				s0 = peg$f61(s1, s3);
 			} else {
 				peg$currPos = s0;
 				s0 = peg$FAILED;
@@ -2261,12 +2322,12 @@ function peg$parse(input, options) {
 					s6 = peg$parseHere();
 					s7 = peg$currPos;
 					peg$savedPos = peg$currPos;
-					s8 = peg$f61(s2, s3, s4, s5, s6);
+					s8 = peg$f62(s2, s3, s4, s5, s6);
 					if (s8) s8 = void 0;
 					else s8 = peg$FAILED;
 					if (s8 !== peg$FAILED) {
 						s9 = peg$currPos;
-						s10 = peg$f62(s2, s3, s4, s5, s6);
+						s10 = peg$f63(s2, s3, s4, s5, s6);
 						s11 = peg$currPos;
 						s12 = [];
 						if (s12.length >= (s10 | 0)) s13 = peg$FAILED;
@@ -2305,7 +2366,7 @@ function peg$parse(input, options) {
 							}
 							if (s10 !== peg$FAILED) {
 								peg$savedPos = s7;
-								s7 = peg$f63(s2, s3, s4, s5, s6, s9);
+								s7 = peg$f64(s2, s3, s4, s5, s6, s9);
 							} else {
 								peg$currPos = s7;
 								s7 = peg$FAILED;
@@ -2320,7 +2381,7 @@ function peg$parse(input, options) {
 					}
 					if (s7 === peg$FAILED) s7 = null;
 					peg$savedPos = s0;
-					s0 = peg$f64(s2, s3, s4, s5, s6, s7);
+					s0 = peg$f65(s2, s3, s4, s5, s6, s7);
 				} else {
 					peg$currPos = s0;
 					s0 = peg$FAILED;
@@ -2354,7 +2415,7 @@ function peg$parse(input, options) {
 					}
 					if (s3 !== peg$FAILED) {
 						peg$savedPos = s0;
-						s0 = peg$f65(s2);
+						s0 = peg$f66(s2);
 					} else {
 						peg$currPos = s0;
 						s0 = peg$FAILED;
@@ -2411,19 +2472,19 @@ function peg$parse(input, options) {
 		let s0, s1, s2, s3;
 		s0 = peg$currPos;
 		peg$savedPos = peg$currPos;
-		s1 = peg$f66();
+		s1 = peg$f67();
 		if (s1) s1 = void 0;
 		else s1 = peg$FAILED;
 		if (s1 !== peg$FAILED) {
 			s2 = peg$parseHtmlClose();
 			if (s2 !== peg$FAILED) {
 				peg$savedPos = peg$currPos;
-				s3 = peg$f67(s2);
+				s3 = peg$f68(s2);
 				if (s3) s3 = void 0;
 				else s3 = peg$FAILED;
 				if (s3 !== peg$FAILED) {
 					peg$savedPos = s0;
-					s0 = peg$f68(s2);
+					s0 = peg$f69(s2);
 				} else {
 					peg$currPos = s0;
 					s0 = peg$FAILED;
@@ -2475,7 +2536,7 @@ function peg$parse(input, options) {
 				}
 				if (s6 !== peg$FAILED) {
 					peg$savedPos = s0;
-					s0 = peg$f69(s2, s3, s5);
+					s0 = peg$f70(s2, s3, s5);
 				} else {
 					peg$currPos = s0;
 					s0 = peg$FAILED;
@@ -2540,7 +2601,7 @@ function peg$parse(input, options) {
 						s5 = peg$parse_();
 						s6 = peg$parseHere();
 						peg$savedPos = s0;
-						s0 = peg$f70(s2, s6);
+						s0 = peg$f71(s2, s6);
 					} else {
 						peg$currPos = s0;
 						s0 = peg$FAILED;
@@ -2579,7 +2640,7 @@ function peg$parse(input, options) {
 				}
 				if (s4 !== peg$FAILED) {
 					peg$savedPos = s0;
-					s0 = peg$f71(s2);
+					s0 = peg$f72(s2);
 				} else {
 					peg$currPos = s0;
 					s0 = peg$FAILED;
@@ -2713,7 +2774,7 @@ function peg$parse(input, options) {
 		else s2 = s3;
 		if (s2 !== peg$FAILED) {
 			peg$savedPos = peg$currPos;
-			s3 = peg$f72(s2);
+			s3 = peg$f73(s2);
 			if (s3) s3 = void 0;
 			else s3 = peg$FAILED;
 			if (s3 !== peg$FAILED) {
@@ -2731,7 +2792,7 @@ function peg$parse(input, options) {
 					s8 = peg$parseAttrValue();
 					if (s8 !== peg$FAILED) {
 						peg$savedPos = s4;
-						s4 = peg$f73(s2, s8);
+						s4 = peg$f74(s2, s8);
 					} else {
 						peg$currPos = s4;
 						s4 = peg$FAILED;
@@ -2742,7 +2803,7 @@ function peg$parse(input, options) {
 				}
 				if (s4 === peg$FAILED) s4 = null;
 				peg$savedPos = s0;
-				s0 = peg$f74(s2, s4);
+				s0 = peg$f75(s2, s4);
 			} else {
 				peg$currPos = s0;
 				s0 = peg$FAILED;
@@ -2797,7 +2858,7 @@ function peg$parse(input, options) {
 			}
 			if (s3 !== peg$FAILED) {
 				peg$savedPos = s0;
-				s0 = peg$f75(s2);
+				s0 = peg$f76(s2);
 			} else {
 				peg$currPos = s0;
 				s0 = peg$FAILED;
@@ -2849,7 +2910,7 @@ function peg$parse(input, options) {
 				}
 				if (s3 !== peg$FAILED) {
 					peg$savedPos = s0;
-					s0 = peg$f76(s2);
+					s0 = peg$f77(s2);
 				} else {
 					peg$currPos = s0;
 					s0 = peg$FAILED;
@@ -2868,7 +2929,7 @@ function peg$parse(input, options) {
 				}
 				if (s1 !== peg$FAILED) {
 					peg$savedPos = s0;
-					s1 = peg$f77(s1);
+					s1 = peg$f78(s1);
 				}
 				s0 = s1;
 				if (s0 === peg$FAILED) {
@@ -2899,7 +2960,7 @@ function peg$parse(input, options) {
 		let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
 		s0 = peg$currPos;
 		peg$savedPos = peg$currPos;
-		s1 = peg$f78();
+		s1 = peg$f79();
 		if (s1) s1 = void 0;
 		else s1 = peg$FAILED;
 		if (s1 !== peg$FAILED) {
@@ -2928,7 +2989,7 @@ function peg$parse(input, options) {
 			if (s2 !== peg$FAILED) {
 				s3 = peg$currPos;
 				peg$savedPos = peg$currPos;
-				s4 = peg$f79(s2);
+				s4 = peg$f80(s2);
 				if (s4) s4 = void 0;
 				else s4 = peg$FAILED;
 				if (s4 !== peg$FAILED) {
@@ -2967,7 +3028,7 @@ function peg$parse(input, options) {
 		if (s0 === peg$FAILED) {
 			s0 = peg$currPos;
 			peg$savedPos = peg$currPos;
-			s1 = peg$f80();
+			s1 = peg$f81();
 			if (s1) s1 = void 0;
 			else s1 = peg$FAILED;
 			if (s1 !== peg$FAILED) {
@@ -2994,12 +3055,12 @@ function peg$parse(input, options) {
 						if (s6 !== peg$FAILED) {
 							s7 = peg$parseHere();
 							peg$savedPos = peg$currPos;
-							s8 = peg$f81(s4, s7);
+							s8 = peg$f82(s4, s7);
 							if (s8) s8 = void 0;
 							else s8 = peg$FAILED;
 							if (s8 !== peg$FAILED) {
 								s9 = peg$currPos;
-								s10 = peg$f82(s4, s7);
+								s10 = peg$f83(s4, s7);
 								s11 = peg$currPos;
 								s12 = [];
 								if (s12.length >= (s10 | 0)) s13 = peg$FAILED;
@@ -3081,7 +3142,7 @@ function peg$parse(input, options) {
 			if (s0 === peg$FAILED) {
 				s0 = peg$currPos;
 				peg$savedPos = peg$currPos;
-				s1 = peg$f83();
+				s1 = peg$f84();
 				if (s1) s1 = void 0;
 				else s1 = peg$FAILED;
 				if (s1 !== peg$FAILED) {
@@ -3172,7 +3233,7 @@ function peg$parse(input, options) {
 				if (s0 === peg$FAILED) {
 					s0 = peg$currPos;
 					peg$savedPos = peg$currPos;
-					s1 = peg$f84();
+					s1 = peg$f85();
 					if (s1) s1 = void 0;
 					else s1 = peg$FAILED;
 					if (s1 !== peg$FAILED) {
@@ -3403,21 +3464,6 @@ function isBlockMacro(name) {
 	return BLOCK_MACROS.has(name);
 }
 //#endregion
-//#region src/markup/tokens.ts
-/** Variable sigils: story ($), temporary (_), local (@), transient (%). */
-var SIGIL_SCOPES = {
-	$: "variable",
-	_: "temporary",
-	"@": "local",
-	"%": "transient"
-};
-Object.fromEntries(Object.entries(SIGIL_SCOPES).map(([sigil, scope]) => [scope, sigil]));
-var SIGIL_CHARS = new Set(Object.keys(SIGIL_SCOPES));
-/** Whether `c` is a variable sigil. */
-function isSigil(c) {
-	return c !== void 0 && SIGIL_CHARS.has(c);
-}
-//#endregion
 //#region node_modules/acorn/dist/acorn.mjs
 var astralIdentifierCodes = [
 	509,
@@ -9239,6 +9285,14 @@ function* tokens(src, start, goal, options = {}) {
 function lexJs(src, handlers, goal = "expression") {
 	return walkTokens(src, 0, handlers, 0, goal, false);
 }
+/**
+* Lex the template literal opening at `start` (a backtick) as `lexJs` does,
+* its interpolations one nesting level deeper. Returns the index just past
+* its closing backtick, or `src.length` if it is unterminated.
+*/
+function lexTemplate(src, start, handlers = {}, nesting = 0) {
+	return walkTokens(src, start, handlers, nesting, "expression", true);
+}
 function walkTokens(src, from, handlers, nesting, goal, oneTemplate) {
 	const comments = [];
 	const onComment = (_block, _text, s, e) => {
@@ -9591,6 +9645,80 @@ function parseMarkup(source, options = {}) {
 function tokenizeMarkup(source, options = {}) {
 	return run(source, "Tokens", options);
 }
+/**
+* The `.class#id` selectors that start `source` at `at`, with the index just
+* past them and the one space that may follow (`end`; `at` if there are
+* none). A selector name may hold `{$name}` interpolations, as in markup.
+*/
+function parseSelectors(source, at = 0) {
+	const found = run(source.slice(at), "SelectorsPrefix", {});
+	return {
+		...found,
+		end: at + found.end
+	};
+}
+/**
+* `tokenizeMarkup` for half-typed markup: the tokens it can read, and every
+* error, instead of throwing at the first. At a malformed tag, the tokens
+* before it are kept, its first character is read as text and tokenizing
+* resumes after it, so what follows is read as if the tag had not been
+* started. Tokens and errors have offsets in `source`; for well-formed
+* markup the tokens are those of `tokenizeMarkup` and there are no errors.
+*/
+function tokenizeMarkupTolerant(source, options = {}) {
+	const tokens = [];
+	const errors = [];
+	/** `text` shifted by `base`, tokenized: the tokens or the error. */
+	const attempt = (text, base) => {
+		try {
+			return tokenizeMarkup(text, options).map((token) => shift(token, base));
+		} catch (error) {
+			if (!(error instanceof MarkupError)) throw error;
+			return error;
+		}
+	};
+	let base = 0;
+	while (base <= source.length) {
+		const rest = source.slice(base);
+		const result = attempt(rest, base);
+		if (Array.isArray(result)) {
+			tokens.push(...result);
+			break;
+		}
+		const at = base + result.offset;
+		const { line, column } = lineColumn(source, at);
+		errors.push(new MarkupError(result.reason, at, line, column));
+		let cut = result.offset;
+		let prefix = attempt(rest.slice(0, cut), base);
+		while (!Array.isArray(prefix)) {
+			cut = prefix.offset;
+			prefix = attempt(rest.slice(0, cut), base);
+		}
+		tokens.push(...prefix);
+		if (cut < rest.length) {
+			const start = base + cut;
+			tokens.push({
+				type: "text",
+				value: rest[cut],
+				start,
+				end: start + 1
+			});
+		}
+		base += cut + 1;
+	}
+	return {
+		tokens,
+		errors
+	};
+}
+/** `token` with its offsets moved `by` on. */
+function shift(token, by) {
+	return by === 0 ? token : {
+		...token,
+		start: token.start + by,
+		end: token.end + by
+	};
+}
 //#endregion
 //#region src/utils/parse-delay.ts
 /**
@@ -9618,6 +9746,15 @@ function errorMessage(err, fallback) {
 	return fallback ?? String(err);
 }
 //#endregion
+//#region src/runtime-errors.ts
+/**
+* The error for `name`, a passage name that names no passage, used in the
+* passage `from`.
+*/
+function noPassageError(name, from) {
+	return /* @__PURE__ */ new Error(`No passage named ${JSON.stringify(name)} (in passage ${JSON.stringify(from)})`);
+}
+//#endregion
 //#region src/components/macros/arg-utils.ts
 /**
 * Shared helpers for macros that split or read their raw argument text by
@@ -9668,6 +9805,37 @@ 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
@@ -9720,6 +9888,67 @@ function topLevelIndices(src, isSeparator) {
 	} });
 	return indices;
 }
+/**
+* Split `src` at every depth-0 separator (see `topLevelIndices`). Segments
+* are returned as written, untrimmed, and empty segments are kept, so
+* `n` separators always give `n + 1` segments.
+*/
+function splitTopLevel(src, isSeparator) {
+	const segments = [];
+	let from = 0;
+	for (const i of topLevelIndices(src, isSeparator)) {
+		segments.push(src.slice(from, i));
+		from = i + 1;
+	}
+	segments.push(src.slice(from));
+	return segments;
+}
+/**
+* Check whether a whitespace-delimited token looks like a standalone value
+* (not an operator or partial expression): it starts like a value and does
+* not end with an operator still waiting for its operand.
+*/
+function isStandaloneValue(token) {
+	return startsLikeValue(token) && !endsWithOperator(token);
+}
+function startsLikeValue(token) {
+	const first = token[0];
+	if (first === "\"" || first === "'" || first === "`") return true;
+	if (/^[$_@]\w|^%[A-Za-z_]/.test(token)) return true;
+	if (/\d/.test(first)) return true;
+	if ((first === "-" || first === "+") && token.length > 1 && /\d/.test(token[1])) return true;
+	if (first === "(" || first === "[" || first === "{") return true;
+	if (/^(?:true|false|null|undefined)(?![\w$])/.test(token)) return true;
+	if (first === "!" && token.length > 1 && token[1] !== "=") return true;
+	return false;
+}
+/**
+* Try to split a raw string on whitespace at depth 0 (respecting strings,
+* template literals, parentheses, brackets, and braces). Each resulting token
+* must pass `isStandaloneValue()` or the split is rejected and `null` is
+* returned.
+*/
+function trySplitOnWhitespace(raw) {
+	const args = splitTopLevel(raw, isWhitespace).filter(Boolean);
+	if (args.length < 2) return null;
+	for (const arg of args) if (!isStandaloneValue(arg)) return null;
+	return args;
+}
+/**
+* Split rawArgs by commas, respecting parentheses, brackets, braces, and
+* strings. When no top-level commas are present, also supports adjacent quoted
+* string literals separated by whitespace (e.g. `"Label" "target"`).
+*/
+function splitArgs(raw) {
+	const args = splitTopLevel(raw, (ch) => ch === ",").map((a) => a.trim());
+	const hasComma = args.length > 1;
+	if (args[args.length - 1] === "") args.pop();
+	if (!hasComma && args.length === 1) {
+		const split = trySplitOnWhitespace(args[0]);
+		if (split) return split;
+	}
+	return args;
+}
 //#endregion
 //#region src/components/macros/macro-args.ts
 /**
@@ -9756,9 +9985,23 @@ var slice = (src, [start, end]) => src.slice(start, end);
 function readText(src) {
 	return readWholeQuoted(src) ?? stripLooseQuotes(src);
 }
+/**
+* An argument that doesn't have its parameter's form: a `string` parameter
+* given anything but one quoted string.
+*/
+var MacroArgumentError = class extends Error {
+	constructor(param, src) {
+		super(`The ${param.name} must be a quoted string ("…" or '…'), ${src ? `not ${src}` : "but it has no value"}`);
+		this.name = "MacroArgumentError";
+	}
+};
 function readValue(param, src) {
 	switch (param.type) {
-		case "string": return readWholeQuoted(src) ?? void 0;
+		case "string": {
+			const value = readWholeQuoted(src);
+			if (value === null) throw new MacroArgumentError(param, src);
+			return value;
+		}
 		case "text": return readText(src);
 		case "names": return src.split(",").map((name) => name.trim());
 		case "delay": return parseDelay(src);
@@ -9773,6 +10016,7 @@ function unset(param) {
 }
 var WORD_RE = /\w+/y;
 var DIGITS_RE = /\d+/y;
+var WORD_OR_PUNCT_RE = /\S+/y;
 /** Match the sticky regex `re` at `pos`, returning the matched text. */
 function matchAt(re, src, pos) {
 	re.lastIndex = pos;
@@ -9781,7 +10025,8 @@ 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.
+* declared, and their values, are skipped. A keyword of a `string` parameter
+* must be followed by a quoted string.
 */
 function readOptions(params, src) {
 	const options = {};
@@ -9794,10 +10039,11 @@ 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) {
-			const quoted = readQuoted(src, j);
+			quoted = readQuoted(src, j);
 			const digits = quoted ? null : matchAt(DIGITS_RE, src, j);
 			if (quoted) {
 				val = quoted.value;
@@ -9808,6 +10054,7 @@ function readOptions(params, src) {
 			}
 		}
 		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?.type === "flag") options[key] = true;
 		else if (param?.type === "number") options[key] = Number(val ?? 0);
 		else if (param) options[key] = val;
@@ -9880,8 +10127,16 @@ function readGroup(params, src, args) {
 	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) => {
+		try {
+			return read(param, value);
+		} 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])) ? read(param, slice(text, spans[to - 1])) : void 0;
+		const value = from < to && !endsWithOperator(text.slice(0, spans[to - 1][0])) ? readTrailing(param, slice(text, spans[to - 1])) : void 0;
 		args[param.name] = value ?? unset(param);
 		if (value !== void 0) to--;
 	}
@@ -9905,6 +10160,34 @@ function parseMacroArgs(rawArgs, parameters) {
 	readGroup(parameters.slice(groupStart), rest, args);
 	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
+* runs (see evaluatePassageName).
+*/
+function passageTarget(arg) {
+	const expression = arg.trim();
+	const name = readWholeJsString(expression);
+	return name === null ? {
+		kind: "expression",
+		expression
+	} : {
+		kind: "name",
+		name
+	};
+}
+/**
+* The passage a `passage` argument names (`{goto "Hall"}`, `{goto $room}`):
+* the value of its expression. Throws what evaluating it throws, and if no
+* passage of the story `state` holds has that name, an error naming it and
+* the current passage.
+*/
+function evaluatePassageName(expr, evaluate, { storyData, currentPassage }) {
+	const name = String(evaluate(expr ?? ""));
+	if (storyData && !storyData.passages.has(name)) throw noPassageError(name, currentPassage);
+	return name;
+}
 //#endregion
 //#region src/widgets/widget-def.ts
 /**
@@ -9988,15 +10271,21 @@ var CONDITION_MACROS = new Set([
 	"case"
 ]);
 /** Code inside the quoted strings of a macro's arguments, by parameter. */
-var CODE_IN_STRINGS = { watch: {
+var CODE_IN_STRINGS = new Map([["watch", {
 	condition: "expression",
 	run: "statements"
-} };
+}]]);
 /** The `string` parameters of a macro that name a passage. */
-var PASSAGE_STRINGS = {
-	link: ["passage"],
-	watch: ["goto", "dialog"]
-};
+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"]);
 /** The goal of the code an argument of this type holds, if it is code. */
@@ -10017,6 +10306,8 @@ function* codeAndText(src, tokens, parametersOf) {
 			kind: "passage",
 			name: token.target,
 			offset: locate(src, token.target, token.start),
+			length: token.target.length,
+			macro: "link",
 			label: src.slice(token.start, token.end)
 		};
 		else if (token.type === "expression") yield {
@@ -10076,6 +10367,8 @@ function* codeAndText(src, tokens, parametersOf) {
 						kind: "passage",
 						name: passage,
 						offset: locate(src, passage, token.end),
+						length: passage.length,
+						macro: name,
 						label: src.slice(token.start, token.end)
 					};
 				}
@@ -10100,9 +10393,23 @@ function* codeAndText(src, tokens, parametersOf) {
 }
 /** The code and text in the arguments `args` (at `offset`) of `macro`. */
 function* argPieces(args, offset, params, macro, label) {
-	const values = parseMacroArgs(args, params);
-	const inStrings = CODE_IN_STRINGS[macro.toLowerCase()] ?? {};
-	const passageStrings = PASSAGE_STRINGS[macro.toLowerCase()] ?? [];
+	let values;
+	try {
+		values = parseMacroArgs(args, params);
+	} catch (error) {
+		if (!(error instanceof MacroArgumentError)) throw error;
+		yield {
+			kind: "argument-error",
+			message: error.message,
+			offset,
+			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;
 	/** The pieces of the parameters `list`, with their values in `from`. */
 	function* visit(list, from) {
@@ -10124,17 +10431,27 @@ function* argPieces(args, offset, params, macro, label) {
 					goal,
 					label
 				};
-				if (param.type === "passage") piece.passage = true;
+				if (param.type === "passage") {
+					piece.passage = true;
+					piece.macro = macro.toLowerCase();
+				}
+				if (!codeGoal(param)) piece.inString = true;
 				yield piece;
 			}
-			const name = param.type === "passage" ? readWholeQuoted(value.trim()) : passageStrings.includes(param.name) ? value : null;
-			if (name !== null) yield {
+			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,
-				offset: offset + at,
+				name: target.name,
+				offset: offset + at + value.indexOf(written),
+				length: written.length,
+				macro: macro.toLowerCase(),
 				label
 			};
-			if (!goal && (param.type === "text" || param.type === "string")) yield {
+			if (!goal && (param.type === "text" || param.type === "string") && !literalStrings.includes(param.name)) yield {
 				kind: "text",
 				text: value,
 				offset: offset + at,
@@ -10154,6 +10471,43 @@ function locate(text, part, from) {
 	const anywhere = text.indexOf(part);
 	return anywhere >= 0 ? anywhere : from;
 }
+/**
+* The passages the markup `src` (with the `tokens` it tokenizes to) names:
+* `[[…]]` links, the passage argument of `{goto}`, `{include}` and `{link}`
+* (and of macros that declare one), the `goto` and `dialog` actions of
+* `{watch}` and the body of `{dialog}`, in source order. A name written out
+* is a literal; the others are expressions, which name a passage when they
+* run.
+*/
+function collectPassageReferences(src, tokens, parametersOf) {
+	const refs = [];
+	for (const piece of codeAndText(src, tokens, parametersOf)) if (piece.kind === "passage") refs.push({
+		macro: piece.macro,
+		target: {
+			kind: "name",
+			name: piece.name
+		},
+		start: piece.offset,
+		end: piece.offset + piece.length
+	});
+	else if (piece.kind === "code" && piece.passage) refs.push({
+		macro: piece.macro,
+		target: passageTarget(piece.code),
+		start: piece.offset,
+		end: piece.offset + piece.code.length
+	});
+	return refs.filter((ref, i) => refs.findIndex((r) => r.start === ref.start && r.macro === ref.macro) === i);
+}
+/** The parameters of the built-in sub-macros that take arguments. */
+var SUB_MACRO_PARAMETERS = new Map([["option", [{
+	name: "value",
+	type: "string",
+	required: true
+}]]]);
+/** The parameters of the built-in sub-macro `name`, if it takes any. */
+function subMacroParameters(name) {
+	return SUB_MACRO_PARAMETERS.get(name.toLowerCase());
+}
 //#endregion
 //#region src/markup/validate.ts
 /**
@@ -10163,8 +10517,15 @@ function locate(text, part, from) {
 * line and column they are at, instead of failing when the passage renders.
 * Tooling runs it too (see src/tooling.ts).
 */
-/** Passages that hold no markup. */
-var NOT_MARKUP = new Set(["StoryVariables", "StoryTransients"]);
+/**
+* Passages that hold no markup: declarations, and the JavaScript function
+* body of SaveTitle.
+*/
+var NOT_MARKUP = new Set([
+	"StoryVariables",
+	"StoryTransients",
+	"SaveTitle"
+]);
 var NOT_MARKUP_TAGS = ["script", "stylesheet"];
 /** Branch macros, which their parent macro renders. */
 var BRANCH_MACROS = new Set([
@@ -10275,7 +10636,7 @@ function validateMarkup(passages, options) {
 			report(passage, base + token.start, `${where}Unknown macro {${token.name}}.${didYouMean(token.name, names, (n) => `{${n}}`)}`);
 		}
 	};
-	const parametersOf = options.parametersOf ?? (() => void 0);
+	const parametersOf = (name) => options.parametersOf?.(name) ?? subMacroParameters(name);
 	/**
 	* 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.
@@ -10284,6 +10645,10 @@ function validateMarkup(passages, options) {
 		checkMacros(passage, tokens, base, where);
 		for (const piece of codeAndText(src, tokens, parametersOf)) {
 			const at = base + piece.offset;
+			if (piece.kind === "argument-error") {
+				report(passage, at, `${where}${piece.message} in ${piece.label}`);
+				continue;
+			}
 			if (piece.kind === "passage") {
 				if (options.checkPassageNames !== false && !passageNames.has(piece.name)) {
 					const hint = didYouMean(piece.name, passageNames, JSON.stringify);
@@ -10317,6 +10682,58 @@ function validateMarkup(passages, options) {
 	for (const [passage, tokens] of parsed) withParseCache(() => checkTokens(passage, passage.content, tokens, 0, ""));
 	return diagnostics;
 }
+new NameMap();
+new NameMap();
+new NameSet();
+/**
+* How a macro argument is read (see components/macros/macro-args.ts). Every
+* declared parameter names one: there is no default.
+* Quoted strings accept `\"`, `\'` and `\\` escapes.
+* - `expression`: code, as written.
+* - `statements`: code run as statements (`{set}`), as written.
+* - `passage`: a passage name: a quoted string or an expression, as written.
+* - `variable`: a variable reference such as `$name` or `"$name"`, as written.
+* - `string`: one quoted string; anything else leaves the argument unset.
+* - `text`: one quoted string, or text with any loose quotes stripped.
+* - `names`: a comma-separated list of names (`@item, @i`).
+* - `delay`: a duration (`2s`, `500ms`, `300`) in milliseconds.
+* - `number`: a number.
+* - `flag`: a keyword, the parameter's name, at the start or end; a boolean.
+* - `separator`: a word (`of`) or `=` separating the parameters before it
+*   from those after it; a boolean.
+* - `options`: keywords, the names of its `parameters`, each followed by a
+*   quoted string or a number unless it is a flag.
+*/
+var PARAMETER_TYPES = [
+	"expression",
+	"statements",
+	"passage",
+	"variable",
+	"string",
+	"text",
+	"names",
+	"delay",
+	"number",
+	"flag",
+	"separator",
+	"options"
+];
+/**
+* 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.
+*/
+function checkParameterTypes(macro, parameters) {
+	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 (param.parameters) checkParameterTypes(macro, param.parameters);
+	}
+}
+new NameMap();
 //#endregion
 //#region src/utils/namespace.ts
 /** The variable name no namespace can hold. */
@@ -10407,58 +10824,84 @@ function parseStoryVariables(content, sigil = "$") {
 	}
 	return schema;
 }
-new NameMap();
-new NameMap();
-new NameSet();
+//#endregion
+//#region src/components/macros/include-args.ts
 /**
-* How a macro argument is read (see components/macros/macro-args.ts). Every
-* declared parameter names one: there is no default.
-* Quoted strings accept `\"`, `\'` and `\\` escapes.
-* - `expression`: code, as written.
-* - `statements`: code run as statements (`{set}`), as written.
-* - `passage`: a passage name: a quoted string or an expression, as written.
-* - `variable`: a variable reference such as `$name` or `"$name"`, as written.
-* - `string`: one quoted string; anything else leaves the argument unset.
-* - `text`: one quoted string, or text with any loose quotes stripped.
-* - `names`: a comma-separated list of names (`@item, @i`).
-* - `delay`: a duration (`2s`, `500ms`, `300`) in milliseconds.
-* - `number`: a number.
-* - `flag`: a keyword, the parameter's name, at the start or end; a boolean.
-* - `separator`: a word (`of`) or `=` separating the parameters before it
-*   from those after it; a boolean.
-* - `options`: keywords, the names of its `parameters`, each followed by a
-*   quoted string or a number unless it is a flag.
+* The parameters of `{include}`. A standalone `inline` flag only counts
+* outside quotes and brackets, so passage names and expressions containing
+* the word stay intact (#201).
 */
-var PARAMETER_TYPES = [
-	"expression",
-	"statements",
-	"passage",
-	"variable",
-	"string",
-	"text",
-	"names",
-	"delay",
-	"number",
-	"flag",
-	"separator",
-	"options"
-];
+var INCLUDE_PARAMETERS = [{
+	name: "inline",
+	type: "flag"
+}, {
+	name: "passage",
+	type: "passage",
+	required: true
+}];
 /**
-* 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.
+* The arguments of `{include}`: whether it has the `inline` flag, as its
+* first or last word, and the passage expression that is left.
 */
-function checkParameterTypes(macro, parameters) {
-	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 (param.parameters) checkParameterTypes(macro, param.parameters);
-	}
+function splitIncludeFlag(rawArgs) {
+	const { inline, passage } = parseMacroArgs(rawArgs, INCLUDE_PARAMETERS);
+	return {
+		inline,
+		passage
+	};
 }
-new NameMap();
+//#endregion
+//#region src/transform.ts
+/**
+* The sigil transform: the story's code with its variable references
+* (`$var`, `_var`, `@var`, `%var`) turned into the namespace lookups the
+* expression engine runs. Pure string-to-string, so tooling can use it
+* (see src/tooling.ts).
+*/
+var TRANSFORM_CACHE_MAX = 500;
+var NAMESPACES = {
+	$: "variables",
+	_: "temporary",
+	"@": "locals",
+	"%": "transient"
+};
+/** Ends with an identifier character. */
+var IDENT_END_RE = /[\p{ID_Continue}$\u200c\u200d]$/u;
+/**
+* Transform expression: $var → variables["var"], _var → temporary["var"],
+* @var → locals["var"], %var → transient["var"].
+* The lexer (`lexJs`) finds the references: only in code (string, template
+* and regex literal text and comments are left untouched), only where an
+* identifier starts (not in `a$b`, nor as the property name in `obj._x`),
+* and `%var` only where an operand is expected, since `%` is also the
+* modulo operator. `goal` tells whether `expr` is an expression or a list of
+* statements, as that decides whether a leading `{` opens an object literal
+* or a block. A reference to a variable named `__proto__` throws a
+* SyntaxError: no namespace can hold one (see utils/namespace.ts).
+*  */
+function transform(expr, goal = "expression") {
+	const key = goal === "statements" ? "s" + expr : "e" + expr;
+	const cached = transformCache.get(key);
+	if (cached !== void 0) return cached;
+	const { refs } = parseCode(expr, goal);
+	let result = "";
+	let at = 0;
+	for (const ref of refs) {
+		const error = variableNameError(ref.name, ref.sigil + ref.name);
+		if (error) throw new SyntaxError(`spindle: ${error}`);
+		result += expr.slice(at, ref.start);
+		if (ref.shorthand) result += `${ref.name}: `;
+		else if (IDENT_END_RE.test(result.slice(-2))) result += " ";
+		result += `${NAMESPACES[ref.sigil]}["${ref.name}"]`;
+		at = ref.end;
+	}
+	result += expr.slice(at);
+	if (transformCache.size >= TRANSFORM_CACHE_MAX) transformCache.delete(transformCache.keys().next().value);
+	transformCache.set(key, result);
+	return result;
+}
+/** Transformed code by goal and source. */
+var transformCache = /* @__PURE__ */ new Map();
 //#endregion
 //#region src/tooling.ts
 /**
@@ -10493,5 +10936,16 @@ function validateStoryMarkup(passages, macros, options = {}) {
 		checkPassageNames: options.checkPassageNames
 	});
 }
+/**
+* The passages the markup of `source` names (see PassageReference), against
+* the given macros: what the story-start check looks up. Malformed tags are
+* skipped, so it reads half-typed markup.
+*/
+function collectStoryPassageReferences(source, macros) {
+	const parameters = /* @__PURE__ */ new Map();
+	for (const macro of macros) parameters.set(macro.name.toLowerCase(), macro.parameters);
+	const { tokens } = tokenizeMarkupTolerant(source);
+	return collectPassageReferences(source, tokens, (name) => parameters.get(name.toLowerCase()) ?? subMacroParameters(name));
+}
 //#endregion
-export { checkParameterTypes, formatDiagnostic, parseStoryVariables, validateStoryMarkup };
+export { MarkupError, SIGIL_SCOPES, checkParameterTypes, collectStoryPassageReferences, endsWithOperator, evaluatePassageName, findCodeEnd, formatDiagnostic, isSigil, lexJs, lexTemplate, parseSelectors, parseStoryVariables, passageTarget, readQuoted, scanStringLiteral, splitArgs, splitIncludeFlag, splitTopLevel, stripLooseQuotes, tokenizeMarkup, tokenizeMarkupTolerant, transform, unescapeQuoted, validateStoryMarkup };