@rohal12/spindle-lsp 0.13.2 → 0.13.3

package/dist/bin.js

@@ -6174,7 +6174,7 @@ function isRawMacro(name) {
   return RAW_BODY_MACROS.has(name);
 }
 function isBlockMacro(name) {
-  return BLOCK_MACROS.has(name);
+  return BLOCK_MACROS.has(name) || BLOCK_WIDGETS.has(name);
 }
 function buildAst(nodes) {
   return nodes.map(astNode);
@@ -6445,7 +6445,7 @@ function getLineInfo(input, offset2) {
 }
 function getOptions(opts) {
   var options = {};
-  for (var opt in defaultOptions) options[opt] = opts && hasOwn(opts, opt) ? opts[opt] : defaultOptions[opt];
+  for (var opt in defaultOptions) options[opt] = opts && hasOwn$1(opts, opt) ? opts[opt] : defaultOptions[opt];
   if (options.ecmaVersion === "latest") options.ecmaVersion = 1e8;
   else if (options.ecmaVersion == null) {
     if (!warnedAboutEcmaVersion && typeof console === "object" && console.warn) {
@@ -6617,7 +6617,7 @@ function transientAssignment(p, end) {
       if (t === types$1.eof) return false;
       if (depth > 0) {
         if (OPENERS.has(t)) depth++;
-        else if (CLOSERS.has(t)) depth--;
+        else if (CLOSERS$1.has(t)) depth--;
       } else if (t === types$1.bracketL) depth = 1;
       else if (t === types$1.dot) {
         q2.nextToken();
@@ -6628,6 +6628,9 @@ function transientAssignment(p, end) {
     return false;
   }
 }
+function isMemberDot(type) {
+  return type === types$1.dot || type === types$1.questionDot;
+}
 function tokenizerAt(src, start, goal, { onComment, afterOperand = false } = {}) {
   const p = new SigilParser(onComment ? {
     ...OPTIONS,
@@ -6699,6 +6702,9 @@ function bracketsBefore(src, pos) {
   };
 }
 function parseCode(src, goal = "expression") {
+  return parseWithAst(src, goal).out;
+}
+function parseWithAst(src, goal) {
   const percentAt = /* @__PURE__ */ new Map();
   for (; ; ) {
     const transientsRead = /* @__PURE__ */ new Set();
@@ -6710,7 +6716,10 @@ function parseCode(src, goal = "expression") {
       };
       walk(ast, src, out, false, false);
       out.refs.sort((a, b) => a.start - b.start);
-      return out;
+      return {
+        out,
+        ast
+      };
     } catch (error48) {
       const pos = error48.pos ?? -1;
       if (!(error48 instanceof SyntaxError) || percentAt.has(pos)) throw error48;
@@ -7035,7 +7044,7 @@ function walkTokens(src, from, handlers, nesting, goal, oneTemplate) {
     if (t === types$1.name) {
       const sigil = sigilAt(src, tok.start, tok.value);
       const property = prev === types$1.dot || prev === types$1.questionDot || (sigil === "$" || sigil === "_") && keyPosition(src, tok.end, prev);
-      if (sigil && !property) handlers.variable?.(sigil, src.slice(tok.start + 1, tok.end), tok.start, nesting);
+      if (sigil && !property) handlers.variable?.(sigil, tok.value.slice(1), tok.start, nesting, tok.end);
       else code(tok.start, tok.end);
     } else if (t === types$1.string || t === types$1.regexp || t === types$1.template || t === types$1.invalidTemplate) literal3(tok.start, tok.end);
     else if (t === types$1.backQuote) {
@@ -7416,15 +7425,15 @@ function topLevelIndices(src, isSeparator) {
   } });
   return indices;
 }
-function splitTopLevel(src, isSeparator) {
-  const segments = [];
+function topLevelSpans(src, isSeparator) {
+  const spans = [];
   let from = 0;
   for (const i2 of topLevelIndices(src, isSeparator)) {
-    segments.push(src.slice(from, i2));
+    spans.push([from, i2]);
     from = i2 + 1;
   }
-  segments.push(src.slice(from));
-  return segments;
+  spans.push([from, src.length]);
+  return spans;
 }
 function isStandaloneValue(token) {
   return startsLikeValue(token) && !endsWithOperator(token);
@@ -7441,21 +7450,31 @@ function startsLikeValue(token) {
   return false;
 }
 function trySplitOnWhitespace(raw) {
-  const args2 = splitTopLevel(raw, isWhitespace).filter(Boolean);
+  const args2 = topLevelSpans(raw, isWhitespace).filter(([a, b]) => b > a);
   if (args2.length < 2) return null;
-  for (const arg of args2) if (!isStandaloneValue(arg)) return null;
+  for (const [a, b] of args2) if (!isStandaloneValue(raw.slice(a, b))) return null;
   return args2;
 }
-function splitArgs(raw) {
-  const args2 = splitTopLevel(raw, (ch) => ch === ",").map((a) => a.trim());
+function trimmed$1(src, [start, end]) {
+  const text2 = src.slice(start, end);
+  const lead = text2.length - text2.trimStart().length;
+  return [start + lead, Math.max(start + lead, end - (text2.length - text2.trimEnd().length))];
+}
+function splitArgSpans(raw) {
+  const args2 = topLevelSpans(raw, (ch) => ch === ",").map((span) => trimmed$1(raw, span));
   const hasComma = args2.length > 1;
-  if (args2[args2.length - 1] === "") args2.pop();
+  const last2 = args2[args2.length - 1];
+  if (last2[0] === last2[1]) args2.pop();
   if (!hasComma && args2.length === 1) {
-    const split = trySplitOnWhitespace(args2[0]);
-    if (split) return split;
+    const [start, end] = args2[0];
+    const split = trySplitOnWhitespace(raw.slice(start, end));
+    if (split) return split.map(([a, b]) => [start + a, start + b]);
   }
   return args2;
 }
+function splitArgs(raw) {
+  return splitArgSpans(raw).map(([a, b]) => raw.slice(a, b));
+}
 function terms(src) {
   const spans = [];
   let start = 0;
@@ -7529,8 +7548,9 @@ function readOptions(params, src, { at: at3, spans }) {
   }
   return options;
 }
-function takeFlag(src, word) {
+function takeFlag(src, word, alone) {
   const spans = terms(src);
+  if (spans.length === 1) return alone && slice(src, spans[0]) === word ? [src.length, src.length] : null;
   if (spans.length < 2) return null;
   if (slice(src, spans[spans.length - 1]) === word) {
     const rest = [0, spans[spans.length - 2][1]];
@@ -7565,8 +7585,9 @@ function trimmed(src, at3) {
 }
 function readGroup(params, src, args2, { at: srcAt, spans }) {
   let [text2, at3] = trimmed(src ?? "", srcAt);
+  const alone = !params.some((p) => p.type !== "flag" && p.required);
   for (const flag of params.filter((p) => p.type === "flag")) {
-    const rest2 = src === null ? null : takeFlag(text2, flag.name);
+    const rest2 = src === null ? null : takeFlag(text2, flag.name, alone);
     args2[flag.name] = rest2 !== null;
     if (rest2) [text2, at3] = trimmed(slice(text2, rest2), at3 + rest2[0]);
   }
@@ -7637,9 +7658,40 @@ function passageTarget(arg) {
     name
   };
 }
+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)) 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);
+  }
+}
+function parameterError(macro, param, problem, fix) {
+  return /* @__PURE__ */ new Error(`spindle: The parameter "${param.name}" of the macro {${macro}} ${problem}. ${fix}`);
+}
+function getMacroRegistry() {
+  return Array.from(metadataRegistry.values());
+}
 function subMacroParameters(name) {
   return SUB_MACRO_PARAMETERS.get(name.toLowerCase());
 }
+function variableNameError(name, label2 = name) {
+  return name === "__proto__" ? `"${label2}" cannot be used as a variable name (${RESERVED_NAME} is reserved)` : void 0;
+}
+function ownEntries(sources, keep = () => true) {
+  const record2 = /* @__PURE__ */ Object.create(null);
+  for (const source of sources) {
+    if (!source) continue;
+    for (const key of Object.keys(source)) {
+      const value = source[key];
+      if (keep(value)) record2[key] = value;
+    }
+  }
+  return record2;
+}
 function withParseCache(fn) {
   const outer = parses;
   parses = /* @__PURE__ */ new Map();
@@ -7668,6 +7720,13 @@ function pieceOffset(piece, index) {
 function extentOf(piece) {
   return piece.kind === "code" ? piece.code.length : piece.kind === "text" ? piece.text.length : piece.length;
 }
+function widgetParameters(params, holds = {}) {
+  if (!params.some((param) => hasOwn(holds, param))) return void 0;
+  return params.map((name) => ({
+    name,
+    ...hasOwn(holds, name) ? { holds: holds[name] } : {}
+  }));
+}
 function withHolds(params, holds) {
   return params.map((param) => {
     if (param.parameters) return {
@@ -7682,8 +7741,13 @@ function withHolds(params, holds) {
 }
 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) => {
+  const widgets = new NameMap();
+  for (const { name, parameters: params, interpolate, widget } of macros) {
+    if (params) parameters.set(name, withHolds(params, holdsByDefault(interpolate)));
+    const declared = widget && widgetParameters(widget.params, widget.holds);
+    if (declared) widgets.set(name, declared);
+  }
+  const lookup = (name) => {
     let params = parameters.get(name);
     if (!params) {
       const sub = subMacroParameters(name);
@@ -7691,6 +7755,8 @@ function parameterLookup(macros) {
     }
     return params;
   };
+  if (widgets.size > 0) lookup.widget = (name) => widgets.get(name);
+  return lookup;
 }
 function codeGoal(param) {
   if (param.type === "expression" || param.type === "passage") return "expression";
@@ -7781,6 +7847,8 @@ function* codeAndText(src, tokens2, parametersOf2) {
       }
       const params = parametersOf2(name);
       if (params) yield* argPieces(args2, argsAt, params, token.name, label2);
+      const widget = parametersOf2.widget?.(name);
+      if (widget) yield* widgetPieces(args2, argsAt, widget, token.name, label2);
     }
   }
 }
@@ -7836,23 +7904,42 @@ function nestedPiece(piece, toRoot, where2) {
     ...nested
   };
 }
-function escapeOffsets(raw, at3, value) {
+function escapeAt(raw, i2, escapes) {
+  if (escapes === "quotes") {
+    const next = raw.charAt(i2 + 1);
+    return /["'\\]/.test(next) ? {
+      length: 2,
+      text: next
+    } : void 0;
+  }
+  JS_ESCAPE_RE.lastIndex = i2;
+  const written2 = JS_ESCAPE_RE.exec(raw)?.[0];
+  const text2 = written2 && stringLiteralValue(`"${written2}"`);
+  return typeof text2 === "string" ? {
+    length: written2.length,
+    text: text2
+  } : void 0;
+}
+function escapeOffsets(raw, at3, value, escapes) {
   const offsets = [];
   let escaped = false;
   let i2 = 0;
   while (offsets.length < value.length) {
     if (i2 >= raw.length) return void 0;
-    offsets.push(at3 + i2);
-    if (raw[i2] === "\\" && /["'\\]/.test(raw.charAt(i2 + 1))) {
-      escaped = true;
-      i2 += 2;
-    } else i2++;
+    const escape2 = raw[i2] === "\\" ? escapeAt(raw, i2, escapes) : void 0;
+    if (!escape2) {
+      offsets.push(at3 + i2++);
+      continue;
+    }
+    if (!value.startsWith(escape2.text, offsets.length)) return void 0;
+    for (let k2 = 0; k2 < escape2.text.length; k2++) offsets.push(at3 + i2);
+    escaped = true;
+    i2 += escape2.length;
   }
   offsets.push(at3 + i2);
   return escaped ? offsets : void 0;
 }
 function* argPieces(args2, offset2, params, macro, label2) {
-  const name = macro.toLowerCase();
   let values;
   const spans = /* @__PURE__ */ new Map();
   try {
@@ -7865,10 +7952,34 @@ function* argPieces(args2, offset2, params, macro, label2) {
       offset: offset2,
       length: args2.length,
       label: label2,
-      macro: name
+      macro: macro.toLowerCase()
     };
     return;
   }
+  yield* valuePieces(args2, offset2, params, values, spans, macro, label2, "quotes");
+}
+function* widgetPieces(args2, offset2, params, macro, label2) {
+  const written2 = splitArgSpans(args2);
+  const declared = [];
+  const values = {};
+  const spans = /* @__PURE__ */ new Map();
+  params.forEach(({ name, holds }, i2) => {
+    const span = written2[i2];
+    const value = span && stringLiteralValue(args2.slice(...span));
+    if (!holds || value == null) return;
+    const param = {
+      name,
+      type: "string",
+      holds
+    };
+    declared.push(param);
+    values[name] = value;
+    spans.set(param, span);
+  });
+  yield* valuePieces(args2, offset2, declared, values, spans, macro, label2, "javascript");
+}
+function* valuePieces(args2, offset2, params, values, spans, macro, label2, escapes) {
+  const name = macro.toLowerCase();
   function* visit(list3, from) {
     for (const param of list3) {
       const value = from[param.name];
@@ -7913,7 +8024,7 @@ function* argPieces(args2, offset2, params, macro, label2) {
       }
       const at3 = offset2 + start + (value !== written2 && /^["']/.test(written2) ? 1 : 0);
       const holds = stringHolds(param);
-      const sourceOffsets = escapeOffsets(args2.slice(at3 - offset2), at3, value);
+      const sourceOffsets = escapeOffsets(args2.slice(at3 - offset2), at3, value, escapes);
       if (holds === "expression" || holds === "statements") {
         const piece = {
           kind: "code",
@@ -7966,15 +8077,13 @@ function attributeValues(src, token) {
 function sigilExpressions(value) {
   const found = [];
   let from = 0;
-  for (const part of splitSigilTemplate(value)) {
-    if (!("expr" in part)) continue;
-    const at3 = locate(value, part.expr, from);
-    from = at3 + part.expr.length;
+  for (const part of splitSigilTemplate(value)) if ("expr" in part) {
     found.push({
       expr: part.expr,
-      at: at3
+      at: from + 1
     });
-  }
+    from += part.expr.length + 2;
+  } else from += ("text" in part ? part.text : part.verbatim).length;
   return found;
 }
 function locate(text2, part, from) {
@@ -7983,23 +8092,6 @@ function locate(text2, part, from) {
   const anywhere = text2.indexOf(part);
   return anywhere >= 0 ? anywhere : from;
 }
-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)) 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);
-  }
-}
-function parameterError(macro, param, problem, fix) {
-  return /* @__PURE__ */ new Error(`spindle: The parameter "${param.name}" of the macro {${macro}} ${problem}. ${fix}`);
-}
-function getMacroRegistry() {
-  return Array.from(metadataRegistry.values());
-}
 function textContainsChildren(text2, parametersOf2) {
   if (!text2.includes("{")) return false;
   let nodes;
@@ -8030,6 +8122,7 @@ function astContainsChildren(nodes, parametersOf2 = registeredParameters) {
       }, parametersOf2) || astContainsChildren(node.children, parametersOf2)) return true;
     }
     if (node.type === "macro") {
+      if (node.name.toLowerCase() === "widget") continue;
       if (tokenTextContainsChildren({
         isClose: false,
         nameStart: 0,
@@ -8048,9 +8141,25 @@ function astContainsChildren(nodes, parametersOf2 = registeredParameters) {
   return false;
 }
 function widgetDef({ name = "", parameters = "" }) {
+  const params = [];
+  const holds = {};
+  const badHolds = [];
+  for (const word of parameters.split(/[\s,]+/)) {
+    if (!word.startsWith("@")) continue;
+    const [param = word, written2] = word.split(/:(.*)/s);
+    params.push(param);
+    if (written2 === void 0) continue;
+    if (STRING_HOLDS.includes(written2)) holds[param] = written2;
+    else badHolds.push({
+      param,
+      written: written2
+    });
+  }
   return {
     name,
-    params: parameters.split(/[\s,]+/).filter((word) => word.startsWith("@"))
+    params,
+    ...Object.keys(holds).length > 0 ? { holds } : {},
+    ...badHolds.length > 0 ? { badHolds } : {}
   };
 }
 function parseWidgetDef(rawArgs) {
@@ -8102,8 +8211,11 @@ function widgetDefinitions$1(passages, parametersOf2 = registeredParameters) {
   }
   return found;
 }
-function blockWidgetNames(passages, parametersOf2 = registeredParameters) {
-  return widgetDefinitions$1(passages, parametersOf2).filter((def) => def.block && def.closeStart !== void 0).map((def) => def.name);
+function effectiveWidgetDefinitions(definitions) {
+  const inInit = (def) => def.passage === "StoryInit";
+  const effective = new NameMap();
+  for (const def of [...definitions.filter((def2) => !inInit(def2)), ...definitions.filter(inInit)]) if (def.closeStart !== void 0) effective.set(def.name, def);
+  return [...effective.values()];
 }
 function distance(a, b) {
   let prev = Array.from({ length: b.length + 1 }, (_2, j2) => j2);
@@ -8257,20 +8369,6 @@ function validateMarkup(passages, options) {
   for (const [passage, tokens2] of parsed) withParseCache(() => checkPassage(passage, tokens2));
   return diagnostics;
 }
-function variableNameError(name, label2 = name) {
-  return name === "__proto__" ? `"${label2}" cannot be used as a variable name (${RESERVED_NAME} is reserved)` : void 0;
-}
-function ownEntries(sources, keep = () => true) {
-  const record2 = /* @__PURE__ */ Object.create(null);
-  for (const source of sources) {
-    if (!source) continue;
-    for (const key of Object.keys(source)) {
-      const value = source[key];
-      if (keep(value)) record2[key] = value;
-    }
-  }
-  return record2;
-}
 function staticLiteral(src) {
   const reader = new Reader(src);
   const value = reader.value();
@@ -8281,6 +8379,17 @@ function entryOrder(keys) {
   const all = [...keys];
   return [...all.filter((key) => ARRAY_INDEX_RE.test(key)).sort((a, b) => Number(a) - Number(b)), ...all.filter((key) => !ARRAY_INDEX_RE.test(key))];
 }
+function regexLiterals(src, goal = "expression", handlers = {}) {
+  const ends = /* @__PURE__ */ new Map();
+  lexJs(src, {
+    ...handlers,
+    literal(text2, index, nesting) {
+      if (text2.charAt(0) === "/" && !/^\/[/*]/.test(text2)) ends.set(index, index + text2.length);
+      handlers.literal?.(text2, index, nesting);
+    }
+  }, goal);
+  return ends;
+}
 function bigintValue(digits) {
   try {
     return BigInt(digits.replace(/_/g, "")).toString();
@@ -8406,6 +8515,7 @@ function checkReference(ref2, declared) {
     const part = ref2.path[i2];
     if (current2.type === "array") return null;
     if (current2.type === "null") return null;
+    if (current2.type === "string" && isArrayIndex(part)) continue;
     const sample = PRIMITIVE_SAMPLES[current2.type];
     if (sample && part in sample) {
       const memberType = typeof sample[part];
@@ -8421,9 +8531,20 @@ function checkReference(ref2, declared) {
   }
   return null;
 }
-function referenceAt(code, index, at3) {
+function referenceAt(code, sigil, name, start, end, at3) {
+  FIELD_PATH_RE.lastIndex = end;
+  const fields = FIELD_PATH_RE.exec(code)[0];
+  return {
+    sigil,
+    name,
+    path: fields ? fields.slice(1).split(".") : [],
+    start: at3(start),
+    end: at3(end + fields.length)
+  };
+}
+function termReferenceAt(term, index, at3) {
   VAR_PATH_RE.lastIndex = index;
-  const match = VAR_PATH_RE.exec(code);
+  const match = VAR_PATH_RE.exec(term);
   if (!match) return void 0;
   const [name, ...path] = match[2].split(".");
   return {
@@ -8449,39 +8570,42 @@ function scanCode(code, at3, emit, goal = "expression") {
   }
   for (const ref2 of parsed.refs) {
     if (ref2.sigil !== "$" && ref2.sigil !== "%") continue;
-    const found = referenceAt(code, ref2.start, at3);
-    if (found) emit(found);
+    emit(referenceAt(code, ref2.sigil, ref2.name, ref2.start, ref2.end, at3));
   }
 }
 function scanCodeLeniently(code, at3, emit, goal) {
   lexJs(code, {
-    variable(sigil, _name, index) {
+    variable(sigil, name, index, _nesting, end) {
       if (sigil !== "$" && sigil !== "%") return;
-      const found = referenceAt(code, index, at3);
-      if (found) emit(found);
+      emit(referenceAt(code, sigil, name, index, end, at3));
     },
     literal() {
     }
   }, goal);
 }
-function scanArgs(token, params, at3, emit, options) {
+function scanPieces(pieces, at3, emit, options) {
+  for (const piece of pieces) {
+    const pieceAt = (i2) => at3(pieceOffset(piece, i2));
+    if (piece.kind === "code") scanCode(piece.code, pieceAt, emit, piece.goal);
+    else if (piece.kind === "text") scanInterpolations(piece.text, pieceAt, emit, {
+      ...options,
+      storeVarMacros: NO_STORE_VAR_MACROS
+    });
+  }
+}
+function scanArgs(token, parametersOf2, at3, emit, options) {
   if (!token.rawArgs) return;
+  const params = parametersOf2(token.name);
+  let byParameters = false;
   if (params) {
     if (options.all && !options.storeVarMacros.has(token.name.toLowerCase())) scanVariableParameters(token, params, at3, emit);
     const pieces = [...argPieces(token.rawArgs, token.argsStart, params, token.name, "")];
-    if (!pieces.some((piece) => piece.kind === "argument-error")) {
-      for (const piece of pieces) {
-        const pieceAt = (i2) => at3(pieceOffset(piece, i2));
-        if (piece.kind === "code") scanCode(piece.code, pieceAt, emit, piece.goal);
-        else if (piece.kind === "text") scanInterpolations(piece.text, pieceAt, emit, {
-          ...options,
-          storeVarMacros: NO_STORE_VAR_MACROS
-        });
-      }
-      return;
-    }
+    byParameters = !pieces.some((piece) => piece.kind === "argument-error");
+    if (byParameters) scanPieces(pieces, at3, emit, options);
   }
-  scanCode(token.rawArgs, (i2) => at3(token.argsStart + i2), emit);
+  if (!byParameters) scanCode(token.rawArgs, (i2) => at3(token.argsStart + i2), emit);
+  const widget = parametersOf2.widget?.(token.name);
+  if (widget) scanPieces(widgetPieces(token.rawArgs, token.argsStart, widget, token.name, ""), at3, emit, options);
 }
 function scanVariableParameters(token, params, at3, emit) {
   const spans = /* @__PURE__ */ new Map();
@@ -8494,7 +8618,7 @@ function scanVariableParameters(token, params, at3, emit) {
   for (const param of params) {
     const span = spans.get(param);
     if (param.type !== "variable" || !span) continue;
-    const ref2 = referenceAt(token.rawArgs.slice(span[0], span[1]), 0, (i2) => at3(token.argsStart + span[0] + i2));
+    const ref2 = termReferenceAt(token.rawArgs.slice(span[0], span[1]), 0, (i2) => at3(token.argsStart + span[0] + i2));
     if (ref2) emit(ref2);
   }
 }
@@ -8533,7 +8657,7 @@ function collectTokenRefs(content, tokens2, at3, emit, options) {
       else scanInterpolations(value, valueIn, emit, options);
     }
     else if (token.type === "macro" && !token.isClose) {
-      scanArgs(token, parametersOf2(token.name), at3, emit, options);
+      scanArgs(token, parametersOf2, at3, emit, options);
       scanSelectors(content, token, at3, emit, options);
       if (storeVarMacros.has(token.name.toLowerCase())) {
         const lead = token.rawArgs.length - token.rawArgs.trimStart().length;
@@ -8569,7 +8693,7 @@ function collectTokenRefs(content, tokens2, at3, emit, options) {
 function collectVariableReferences(content, options) {
   const found = [];
   withParseCache(() => collectTokenRefs(content, tokensOf(content, false, options), (i2) => i2, (ref2) => found.push(ref2), options));
-  return found;
+  return found.sort((a, b) => a.start - b.start);
 }
 function checkVariableReferences(passages, declared, options) {
   const diagnostics = [];
@@ -8593,10 +8717,13 @@ function checkVariableReferences(passages, declared, options) {
 }
 function codeOnly(source) {
   const chars = Array.from({ length: source.length }, () => " ");
-  lexJs(source, { code(ch, index) {
+  const regexes = regexLiterals(source, "statements", { code(ch, index) {
     for (let k2 = 0; k2 < ch.length; k2++) chars[index + k2] = ch[k2];
-  } }, "statements");
-  return chars.join("");
+  } });
+  return {
+    code: chars.join(""),
+    regexes
+  };
 }
 function written(props, key, read) {
   const value = read(props.get(key));
@@ -8659,18 +8786,23 @@ function macroOf(config2) {
   return macro;
 }
 function discoverMacros(source) {
-  const code = codeOnly(source);
+  const { code, regexes } = codeOnly(source);
   const found = [];
+  let bindings;
   for (const call of code.matchAll(CALL_RE)) {
     let at3 = call.index + call[0].length;
     if (code.charAt(at3) !== "{") {
       const variable = IDENTIFIER_ARGUMENT_RE.exec(code.slice(at3))?.[1];
       if (!variable) continue;
-      const declaration = new RegExp(`(?<![\\w$.])(?:const|let|var)\\s+${variable.replace(/\$/g, "\\$")}\\s*=\\s*(?=\\{)`).exec(code);
-      if (!declaration) continue;
-      at3 = declaration.index + declaration[0].length;
-    }
-    const reader = new ConfigReader(source);
+      bindings ?? (bindings = new Bindings(code));
+      const object3 = bindings.objectOf(variable, call.index, CONFIG_KEYS);
+      if (object3 === void 0) continue;
+      at3 = object3;
+    }
+    const reader = new ConfigReader(source, {
+      goal: "statements",
+      regexes
+    });
     reader.i = at3;
     const config2 = reader.datum();
     const macro = config2 && macroOf(config2);
@@ -8682,8 +8814,9 @@ function validateStoryMarkup(passages, macros, options = {}) {
   const list3 = [...passages];
   const all = [...macros];
   const known = /* @__PURE__ */ new Set();
-  const parametersOf2 = parameterLookup(all);
-  const blocks = new Set(blockWidgetNames(list3, parametersOf2).map((n7) => n7.toLowerCase()));
+  const widgets = widgetDefinitions$1(list3, parameterLookup(all));
+  const blocks = new Set(effectiveWidgetDefinitions(widgets).filter((def) => def.block).map((def) => def.name.toLowerCase()));
+  const parametersOf2 = parameterLookup([...all, ...definedWidgetMacros(widgets)]);
   for (const macro of all) {
     const name = macro.name.toLowerCase();
     known.add(name);
@@ -8699,6 +8832,12 @@ function validateStoryMarkup(passages, macros, options = {}) {
     tolerant: options.tolerant
   });
 }
+function definedWidgetMacros(widgets) {
+  return widgets.map((widget) => ({
+    name: widget.name,
+    widget
+  }));
+}
 function blockLookup(macros) {
   const blocks = new Set(macros.filter((m) => m.block).map((m) => m.name.toLowerCase()));
   return (name) => blocks.has(name.toLowerCase()) || isBlockMacro(name);
@@ -8711,12 +8850,13 @@ function passagePieces(source, macros = []) {
 function widgetDefinitions(passages, macros = []) {
   return widgetDefinitions$1(passages, parameterLookup([...macros]));
 }
-function referenceOptions(macros, all = false) {
+function referenceOptions(macros, all = false, passages = []) {
   const list3 = [...macros];
+  const widgets = widgetDefinitions$1(passages, parameterLookup(list3));
   return {
     all,
     storeVarMacros: new Set(list3.filter((m) => m.storeVar).map((m) => m.name.toLowerCase())),
-    parametersOf: parameterLookup(list3),
+    parametersOf: parameterLookup([...list3, ...definedWidgetMacros(widgets)]),
     tolerant: true
   };
 }
@@ -8724,9 +8864,10 @@ function variableReferences(source, macros = [], options = {}) {
   return collectVariableReferences(source, referenceOptions(macros, options.all));
 }
 function validateVariableReferences(passages, declarations, macros = []) {
-  return checkVariableReferences([...passages].filter((p) => !p.tags?.some((t) => NOT_MARKUP_TAGS.includes(t))), declarations, referenceOptions(macros));
+  const list3 = [...passages];
+  return checkVariableReferences(list3.filter((p) => !p.tags?.some((t) => NOT_MARKUP_TAGS.includes(t))), declarations, referenceOptions(macros, false, list3));
 }
-var SIGIL_SCOPES, SIGIL_CHARS, grammar_shared_default, LB, RB, SIGIL_SCOPES$1, withSelectors, VOID_TAGS, BRANCH_PARENT$1, LINK_SEPARATORS, NO_SELECTORS, EMAIL_AUTOLINK, peg$SyntaxError, NameMap, NameSet, BLOCK_MACROS, RAW_BODY_MACROS, BRANCHING, quoteArg, last$1, BRANCH_PARENT, isBranchTag, lowerName, nameOf, closerOf, closes, astralIdentifierCodes, astralIdentifierStartCodes, nonASCIIidentifierChars, nonASCIIidentifierStartChars, reservedWords, ecma5AndLessKeywords, keywords$1, keywordRelationalOperator, nonASCIIidentifierStart, nonASCIIidentifier, TokenType, beforeExpr, startsExpr, keywords, types$1, lineBreak, lineBreakG, nonASCIIwhitespace, skipWhiteSpace, ref, hasOwnProperty, toString, hasOwn, isArray, regexpCache, loneSurrogate, Position, SourceLocation, defaultOptions, warnedAboutEcmaVersion, SCOPE_TOP, SCOPE_FUNCTION, SCOPE_ASYNC, SCOPE_GENERATOR, SCOPE_ARROW, SCOPE_SIMPLE_CATCH, SCOPE_SUPER, SCOPE_DIRECT_SUPER, SCOPE_CLASS_STATIC_BLOCK, SCOPE_CLASS_FIELD_INIT, SCOPE_SWITCH, SCOPE_VAR, BIND_NONE, BIND_VAR, BIND_LEXICAL, BIND_FUNCTION, BIND_SIMPLE_CATCH, BIND_OUTSIDE, Parser, prototypeAccessors, pp$9, literal, DestructuringErrors, pp$8, loopLabel, switchLabel, empty$1, FUNC_STATEMENT, FUNC_HANGING_STATEMENT, FUNC_NULLABLE_ID, pp$7, TokContext, types, pp$6, pp$5, empty, pp$4, pp$3, Scope, Node, pp$2, scriptValuesAddedInUnicode, ecma9BinaryProperties, ecma10BinaryProperties, ecma11BinaryProperties, ecma12BinaryProperties, ecma13BinaryProperties, unicodeBinaryProperties, unicodeBinaryPropertiesOfStrings, unicodeGeneralCategoryValues, ecma9ScriptValues, ecma10ScriptValues, ecma11ScriptValues, ecma12ScriptValues, ecma13ScriptValues, unicodeScriptValues, data, ecmaVersion, i, list, pp$1, BranchID, RegExpValidationState, CharSetNone, CharSetOk, CharSetString, Token, pp, INVALID_TEMPLATE_ESCAPE_ERROR, OPTIONS, AT_NAME_RE, TRANS_NAME_RE, SIGIL_IDENT_RE, LINE_BREAK_RE, NOT_A_BODY_RE, OPERAND_ENDS, SigilParser, OPENERS, CLOSERS, CodeSyntaxError, last, CLOSER, isNode, NAMESPACE_NAME, WORD_RE$2, FLAGS_RE, WORDS_BEFORE_STRING, NON_STRING_QUOTE_PREFIX, memoInput, memo, defaultCodeEnd, defaultHooks, MarkupError, OFFSET_FIELD, listeners, TRAILING_OPERATOR_RE, slice, MacroArgumentError, WORD_RE$1, NUMBER_RE$1, WORD_OR_PUNCT_RE, LEADING_OPERATOR_RE, takesRest, SUB_MACRO_PARAMETERS, parses, CONDITION_MACROS, PASSAGE_BODIES, holdsByDefault, textPiece, PARAMETER_TYPES, STRING_HOLDS, metadataRegistry, registeredParameters, WIDGET_PARAMETERS, NOT_MARKUP, NOT_MARKUP_TAGS$1, BRANCH_MACROS, didYouMean, PASSAGE_ARGUMENT_HINT, BARE_WORD_RE, RESERVED_NAME, createNamespace, NUMBER_RE, IDENT_RE, KEY_RE, ARROW_RE, ARRAY_INDEX_RE, UNSUPPORTED_UNDEFINED, Reader, VAR_PATH_RE, QUOTED_VAR_ARG_RE, VALID_VAR_TYPES, PRIMITIVE_SAMPLES, UNSUPPORTED_TYPE, NO_STORE_VAR_MACROS, CALL_RE, IDENTIFIER_ARGUMENT_RE, WORD_RE, ConfigReader, stringOf, booleanOf, textOf, stringsOf, NOT_MARKUP_TAGS;
+var SIGIL_SCOPES, SIGIL_CHARS, grammar_shared_default, LB, RB, SIGIL_SCOPES$1, withSelectors, VOID_TAGS, BRANCH_PARENT$1, LINK_SEPARATORS, NO_SELECTORS, EMAIL_AUTOLINK, peg$SyntaxError, NameMap, NameSet, BLOCK_MACROS, BLOCK_WIDGETS, RAW_BODY_MACROS, BRANCHING, quoteArg, last$1, BRANCH_PARENT, isBranchTag, lowerName, nameOf, closerOf, closes, astralIdentifierCodes, astralIdentifierStartCodes, nonASCIIidentifierChars, nonASCIIidentifierStartChars, reservedWords, ecma5AndLessKeywords, keywords$1, keywordRelationalOperator, nonASCIIidentifierStart, nonASCIIidentifier, TokenType, beforeExpr, startsExpr, keywords, types$1, lineBreak, lineBreakG, nonASCIIwhitespace, skipWhiteSpace, ref, hasOwnProperty, toString, hasOwn$1, isArray, regexpCache, loneSurrogate, Position, SourceLocation, defaultOptions, warnedAboutEcmaVersion, SCOPE_TOP, SCOPE_FUNCTION, SCOPE_ASYNC, SCOPE_GENERATOR, SCOPE_ARROW, SCOPE_SIMPLE_CATCH, SCOPE_SUPER, SCOPE_DIRECT_SUPER, SCOPE_CLASS_STATIC_BLOCK, SCOPE_CLASS_FIELD_INIT, SCOPE_SWITCH, SCOPE_VAR, BIND_NONE, BIND_VAR, BIND_LEXICAL, BIND_FUNCTION, BIND_SIMPLE_CATCH, BIND_OUTSIDE, Parser, prototypeAccessors, pp$9, literal, DestructuringErrors, pp$8, loopLabel, switchLabel, empty$1, FUNC_STATEMENT, FUNC_HANGING_STATEMENT, FUNC_NULLABLE_ID, pp$7, TokContext, types, pp$6, pp$5, empty, pp$4, pp$3, Scope, Node, pp$2, scriptValuesAddedInUnicode, ecma9BinaryProperties, ecma10BinaryProperties, ecma11BinaryProperties, ecma12BinaryProperties, ecma13BinaryProperties, unicodeBinaryProperties, unicodeBinaryPropertiesOfStrings, unicodeGeneralCategoryValues, ecma9ScriptValues, ecma10ScriptValues, ecma11ScriptValues, ecma12ScriptValues, ecma13ScriptValues, unicodeScriptValues, data, ecmaVersion, i, list, pp$1, BranchID, RegExpValidationState, CharSetNone, CharSetOk, CharSetString, Token, pp, INVALID_TEMPLATE_ESCAPE_ERROR, OPTIONS, AT_NAME_RE, TRANS_NAME_RE, SIGIL_IDENT_RE, LINE_BREAK_RE, NOT_A_BODY_RE, OPERAND_ENDS, SigilParser, OPENERS, CLOSERS$1, CodeSyntaxError, last, CLOSER, isNode, NAMESPACE_NAME, WORD_RE$2, FLAGS_RE, WORDS_BEFORE_STRING, NON_STRING_QUOTE_PREFIX, memoInput, memo, defaultCodeEnd, defaultHooks, MarkupError, OFFSET_FIELD, listeners, TRAILING_OPERATOR_RE, slice, MacroArgumentError, WORD_RE$1, NUMBER_RE$1, WORD_OR_PUNCT_RE, LEADING_OPERATOR_RE, takesRest, PARAMETER_TYPES, STRING_HOLDS, metadataRegistry, SUB_MACRO_PARAMETERS, RESERVED_NAME, isArrayIndex, hasOwn, createNamespace, parses, CONDITION_MACROS, PASSAGE_BODIES, holdsByDefault, JS_ESCAPE_RE, textPiece, registeredParameters, WIDGET_PARAMETERS, NOT_MARKUP, NOT_MARKUP_TAGS$1, BRANCH_MACROS, didYouMean, PASSAGE_ARGUMENT_HINT, BARE_WORD_RE, NUMBER_RE, IDENT_RE, KEY_RE, ARROW_RE, LINE_END_RE, ARRAY_INDEX_RE, UNSUPPORTED_UNDEFINED, Reader, VAR_PATH_RE, QUOTED_VAR_ARG_RE, VALID_VAR_TYPES, PRIMITIVE_SAMPLES, UNSUPPORTED_TYPE, NO_STORE_VAR_MACROS, FIELD_PATH_RE, CLOSERS, BLOCK_WORDS, NOT_PARAMETERS, DECLARATIONS, WRITE_RE, MUTATORS, MUTATING_CALL_RE, BEFORE_BINDING, isWordChar, Bindings, CALL_RE, IDENTIFIER_ARGUMENT_RE, WORD_RE, MODIFIER_RE, KEY_START_RE, CONFIG_KEYS, ConfigReader, stringOf, booleanOf, textOf, stringsOf, NOT_MARKUP_TAGS;
 var init_story_variables = __esm({
   "node_modules/@rohal12/spindle/dist/pkg/story-variables.js"() {
     SIGIL_SCOPES = {
@@ -8891,6 +9032,9 @@ var init_story_variables = __esm({
       delete(name) {
         this.names.delete(name);
       }
+      clear() {
+        this.names.clear();
+      }
     };
     BLOCK_MACROS = new NameSet([
       "if",
@@ -8908,6 +9052,7 @@ var init_story_variables = __esm({
       "span",
       "nobr"
     ]);
+    BLOCK_WIDGETS = new NameSet();
     RAW_BODY_MACROS = /* @__PURE__ */ new Set(["do"]);
     BRANCHING = /* @__PURE__ */ new Set([
       "if",
@@ -10085,7 +10230,7 @@ var init_story_variables = __esm({
     ref = Object.prototype;
     hasOwnProperty = ref.hasOwnProperty;
     toString = ref.toString;
-    hasOwn = Object.hasOwn || (function(obj, propName) {
+    hasOwn$1 = Object.hasOwn || (function(obj, propName) {
       return hasOwnProperty.call(obj, propName);
     });
     isArray = Array.isArray || (function(obj) {
@@ -11015,7 +11160,7 @@ var init_story_variables = __esm({
       var parent = len === 0 ? null : this.privateNameStack[len - 1];
       for (var i2 = 0; i2 < used.length; ++i2) {
         var id = used[i2];
-        if (!hasOwn(declared, id.name)) {
+        if (!hasOwn$1(declared, id.name)) {
           if (parent) parent.used.push(id);
           else this.raiseRecoverable(id.start, "Private field '#" + id.name + "' must be declared in an enclosing class");
         }
@@ -11093,7 +11238,7 @@ var init_story_variables = __esm({
     pp$8.checkExport = function(exports$1, name, pos) {
       if (!exports$1) return;
       if (typeof name !== "string") name = name.type === "Identifier" ? name.name : name.value;
-      if (hasOwn(exports$1, name)) this.raiseRecoverable(pos, "Duplicate export '" + name + "'");
+      if (hasOwn$1(exports$1, name)) this.raiseRecoverable(pos, "Duplicate export '" + name + "'");
       exports$1[name] = true;
     };
     pp$8.checkPatternExport = function(exports$1, pat) {
@@ -11212,7 +11357,7 @@ var init_story_variables = __esm({
         } else first = false;
         var attr = this.parseImportAttribute();
         var keyName = attr.key.type === "Identifier" ? attr.key.name : attr.key.value;
-        if (hasOwn(attributeKeys, keyName)) this.raiseRecoverable(attr.key.start, "Duplicate attribute key '" + keyName + "'");
+        if (hasOwn$1(attributeKeys, keyName)) this.raiseRecoverable(attr.key.start, "Duplicate attribute key '" + keyName + "'");
         attributeKeys[keyName] = true;
         nodes.push(attr);
       }
@@ -11374,7 +11519,7 @@ var init_story_variables = __esm({
           if (isBind) {
             if (bindingType === BIND_LEXICAL && expr.name === "let") this.raiseRecoverable(expr.start, "let is disallowed as a lexically bound name");
             if (checkClashes) {
-              if (hasOwn(checkClashes, expr.name)) this.raiseRecoverable(expr.start, "Argument name clash");
+              if (hasOwn$1(checkClashes, expr.name)) this.raiseRecoverable(expr.start, "Argument name clash");
               checkClashes[expr.name] = true;
             }
             if (bindingType !== BIND_OUTSIDE) this.declareName(expr.name, bindingType, expr.start);
@@ -13034,7 +13179,7 @@ var init_story_variables = __esm({
       return CharSetNone;
     };
     pp$1.regexp_validateUnicodePropertyNameAndValue = function(state, name, value) {
-      if (!hasOwn(state.unicodeProperties.nonBinary, name)) state.raise("Invalid property name");
+      if (!hasOwn$1(state.unicodeProperties.nonBinary, name)) state.raise("Invalid property name");
       if (!state.unicodeProperties.nonBinary[name].test(value)) state.raise("Invalid property value");
     };
     pp$1.regexp_validateUnicodePropertyNameOrValue = function(state, nameOrValue) {
@@ -14026,15 +14171,15 @@ var init_story_variables = __esm({
         }
         const self = this;
         const prevType = self.type;
-        this.prevValue = self.value;
-        const property = type.keyword !== void 0 && (prevType === types$1.dot || prevType === types$1.questionDot) || (type === types$1._function || type === types$1._class) && notABody(self.input, self.pos);
+        this.prevValue = isMemberDot(this.typeBeforeLast) ? void 0 : self.value;
+        const property = type.keyword !== void 0 && isMemberDot(prevType) || (type === types$1._function || type === types$1._class) && notABody(self.input, self.pos);
         if (!property && (type === types$1._function || type === types$1._class)) {
           const before = type === types$1._function && prevType === types$1.name && this.prevValue === "async" && !this.breakHere ? this.typeBeforeLast : prevType;
           self.type = before === types$1.colon && this.colonEndsTernary ? types$1.parenL : before;
         }
         this.typeBeforeLast = prevType;
         super.finishToken(property ? types$1.name : type, value);
-        if (type === types$1.name && value === "of" && (prevType === types$1._const || prevType === types$1._var || this.prevValue === "let")) self.exprAllowed = false;
+        if (type === types$1.name && (isMemberDot(prevType) || value === "of" && (prevType === types$1._const || prevType === types$1._var || this.prevValue === "let"))) self.exprAllowed = false;
       }
       braceIsBlock(prevType) {
         if (prevType === types$1.colon && this.colonEndsTernary) return false;
@@ -14054,7 +14199,7 @@ var init_story_variables = __esm({
       types$1.braceL,
       types$1.dollarBraceL
     ]);
-    CLOSERS = /* @__PURE__ */ new Set([
+    CLOSERS$1 = /* @__PURE__ */ new Set([
       types$1.parenR,
       types$1.bracketR,
       types$1.braceR
@@ -14163,28 +14308,6 @@ var init_story_variables = __esm({
     WORD_OR_PUNCT_RE = /\S+/y;
     LEADING_OPERATOR_RE = /^(?:[-+*/&|^=<>?:,.]|%(?![A-Za-z_]))/;
     takesRest = (param) => param.type === "expression" || param.type === "statements" || param.type === "passage" || param.type === "text";
-    SUB_MACRO_PARAMETERS = /* @__PURE__ */ new Map([["option", [{
-      name: "value",
-      type: "string",
-      holds: "text",
-      required: true
-    }]]]);
-    parses = null;
-    CONDITION_MACROS = /* @__PURE__ */ new Set([
-      "if",
-      "elseif",
-      "case"
-    ]);
-    PASSAGE_BODIES = /* @__PURE__ */ new Set(["dialog"]);
-    holdsByDefault = (interpolate) => interpolate ? "markup" : "text";
-    textPiece = (text2, offset2, where2) => ({
-      kind: "text",
-      text: text2,
-      offset: offset2,
-      where: where2,
-      tokens: [],
-      errors: []
-    });
     new NameMap();
     new NameMap();
     new NameSet();
@@ -14210,6 +14333,34 @@ var init_story_variables = __esm({
       "statements"
     ];
     metadataRegistry = new NameMap();
+    SUB_MACRO_PARAMETERS = /* @__PURE__ */ new Map([["option", [{
+      name: "value",
+      type: "string",
+      holds: "text",
+      required: true
+    }]]]);
+    RESERVED_NAME = "__proto__";
+    isArrayIndex = (key) => /^(?:0|[1-9]\d*)$/.test(key);
+    hasOwn = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+    createNamespace = (...sources) => ownEntries(sources);
+    Object.freeze(createNamespace());
+    parses = null;
+    CONDITION_MACROS = /* @__PURE__ */ new Set([
+      "if",
+      "elseif",
+      "case"
+    ]);
+    PASSAGE_BODIES = /* @__PURE__ */ new Set(["dialog"]);
+    holdsByDefault = (interpolate) => interpolate ? "markup" : "text";
+    JS_ESCAPE_RE = /\\(?:u\{[0-9a-fA-F]+\}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{2}|[0-3][0-7]{0,2}|[4-7][0-7]?|\r\n|[^])/y;
+    textPiece = (text2, offset2, where2) => ({
+      kind: "text",
+      text: text2,
+      offset: offset2,
+      where: where2,
+      tokens: [],
+      errors: []
+    });
     registeredParameters = (name) => parameterLookup(getMacroRegistry())(name);
     WIDGET_PARAMETERS = [{
       name: "name",
@@ -14237,22 +14388,26 @@ var init_story_variables = __esm({
     didYouMean = (best, quote) => best ? ` Did you mean ${quote(best)}?` : "";
     PASSAGE_ARGUMENT_HINT = " (a passage name is a quoted string or an expression)";
     BARE_WORD_RE = /^[A-Za-z][\w$]*$/;
-    RESERVED_NAME = "__proto__";
-    createNamespace = (...sources) => ownEntries(sources);
-    Object.freeze(createNamespace());
-    NUMBER_RE = /(?:0[xX][\da-fA-F_]+|0[bB][01_]+|0[oO][0-7_]+|(?:\d[\d_]*\.?[\d_]*|\.\d[\d_]*)(?:[eE][+-]?\d+)?)(n?)/y;
+    NUMBER_RE = /(?:0[xX][\da-fA-F_]+|0[bB][01_]+|0[oO][0-7_]+|(?:\d[\d_]*\.?[\d_]*|\.\d[\d_]*)(?:[eE][+-]?\d[\d_]*)?)(n?)/y;
     IDENT_RE = /[A-Za-z_$][\w$]*/y;
     KEY_RE = /[\w$]+/y;
     ARROW_RE = /(?:async\s+)?(?:\((?:[^()]|\([^()]*\))*\)|[A-Za-z_$][\w$]*)\s*=>/y;
+    LINE_END_RE = /[\n\r\u2028\u2029]/g;
     ARRAY_INDEX_RE = /^(?:0|[1-9]\d{0,8})$/;
     UNSUPPORTED_UNDEFINED = {
       unsupported: "undefined",
       value: "undefined"
     };
     Reader = class {
-      constructor(src) {
+      /**
+      * `regexes` (see regexLiterals) are read from `src` when they are first
+      * needed, unless the caller has them already.
+      */
+      constructor(src, options = {}) {
         this.src = src;
         this.i = 0;
+        this.goal = options.goal ?? "expression";
+        this.regexes = options.regexes;
       }
       /** Skip whitespace and comments. */
       space() {
@@ -14260,8 +14415,8 @@ var init_story_variables = __esm({
         for (; ; ) {
           while (/\s/.test(src.charAt(this.i))) this.i++;
           if (src.startsWith("//", this.i)) {
-            const end = src.indexOf("\n", this.i);
-            this.i = end < 0 ? src.length : end;
+            LINE_END_RE.lastIndex = this.i;
+            this.i = LINE_END_RE.test(src) ? LINE_END_RE.lastIndex - 1 : src.length;
           } else if (src.startsWith("/*", this.i)) {
             const end = src.indexOf("*/", this.i + 2);
             this.i = end < 0 ? src.length : end + 2;
@@ -14320,10 +14475,9 @@ var init_story_variables = __esm({
           i2++;
           while (/\s/.test(src.charAt(i2))) i2++;
         }
-        NUMBER_RE.lastIndex = i2;
-        const match = NUMBER_RE.exec(src);
+        const match = this.numberAt(i2);
         if (match) {
-          this.i = NUMBER_RE.lastIndex;
+          this.i = i2 + match[0].length;
           if (!match[1]) return { shape: { type: "number" } };
           if (sign === "+") return { throws: "Cannot convert a BigInt value to a number" };
           const digits = bigintValue(match[0].slice(0, -1));
@@ -14333,11 +14487,17 @@ var init_story_variables = __esm({
           };
         }
         IDENT_RE.lastIndex = i2;
-        if (IDENT_RE.exec(src)?.[0] === "Infinity") {
+        const word = IDENT_RE.exec(src)?.[0];
+        if (word === "Infinity" || word === "NaN") {
           this.i = IDENT_RE.lastIndex;
           return { shape: { type: "number" } };
         }
       }
+      /** The numeric literal (a BigInt's `n` is `match[1]`) at `at`, if there is one. */
+      numberAt(at3) {
+        NUMBER_RE.lastIndex = at3;
+        return NUMBER_RE.exec(this.src);
+      }
       /** A keyword, a function, or a name (which is not static). */
       word() {
         const { src } = this;
@@ -14357,6 +14517,7 @@ var init_story_variables = __esm({
             this.i = end;
             return { shape: { type: "null" } };
           case "NaN":
+          case "Infinity":
             this.i = end;
             return { shape: { type: "number" } };
           case "undefined":
@@ -14498,14 +14659,22 @@ var init_story_variables = __esm({
         const { src } = this;
         const c = src.charAt(this.i);
         if (c === '"' || c === "'") return this.stringValue();
+        if (/[\d.]/.test(c)) return this.numberKey();
         KEY_RE.lastIndex = this.i;
         const found = KEY_RE.exec(src)?.[0];
         if (found === void 0) return void 0;
         this.i = KEY_RE.lastIndex;
-        if (!/^\d/.test(found)) return found;
-        const digits = found.replace(/_/g, "");
+        return found;
+      }
+      /** A number as a key: the whole literal, named as the runtime names it. */
+      numberKey() {
+        const match = this.numberAt(this.i);
+        if (!match) return void 0;
+        this.i += match[0].length;
+        if (/[\w$]/.test(this.src.charAt(this.i))) return void 0;
+        const digits = match[0].replace(/_/g, "");
         if (/^0\d/.test(digits)) return void 0;
-        if (digits.endsWith("n") && !/^0[xX]/.test(digits)) return bigintValue(digits.slice(0, -1));
+        if (match[1]) return bigintValue(digits.slice(0, -1));
         const value = Number(digits);
         return Number.isNaN(value) ? void 0 : String(value);
       }
@@ -14548,6 +14717,14 @@ var init_story_variables = __esm({
           this.space();
           return true;
         }
+        if (c === "/") {
+          this.regexes ?? (this.regexes = regexLiterals(src, this.goal));
+          const end = this.regexes.get(this.i);
+          if (end !== void 0) {
+            this.i = end;
+            return true;
+          }
+        }
         if (c === "[" || c === "{" || c === "(") return this.skipBalanced();
         if (c === "]" || c === "}" || c === ")") return false;
         this.i++;
@@ -14585,9 +14762,470 @@ var init_story_variables = __esm({
     };
     UNSUPPORTED_TYPE = "Expected number, string, boolean, array, or object.";
     NO_STORE_VAR_MACROS = /* @__PURE__ */ new Set();
+    FIELD_PATH_RE = /(?:\.\w+)*/y;
+    CLOSERS = {
+      "}": "{",
+      ")": "(",
+      "]": "["
+    };
+    BLOCK_WORDS = /* @__PURE__ */ new Set([
+      "if",
+      "for",
+      "while",
+      "switch",
+      "with",
+      "catch"
+    ]);
+    NOT_PARAMETERS = /* @__PURE__ */ new Set([
+      "if",
+      "for",
+      "while",
+      "switch",
+      "with"
+    ]);
+    DECLARATIONS = /* @__PURE__ */ new Set([
+      "const",
+      "let",
+      "var"
+    ]);
+    WRITE_RE = /(?:(?:\*\*|<<|>>>?|&&|\|\||\?\?|[-+*/%&|^])=(?!=)|=(?![=>])|\+\+|--)/y;
+    MUTATORS = /* @__PURE__ */ new Set([
+      "push",
+      "pop",
+      "shift",
+      "unshift",
+      "splice",
+      "sort",
+      "reverse",
+      "fill",
+      "copyWithin"
+    ]);
+    MUTATING_CALL_RE = /(?:Object|Reflect)\s*\.\s*(?:assign|defineProperty|defineProperties|setPrototypeOf|set|deleteProperty)\s*$/;
+    BEFORE_BINDING = {
+      "{": "{,:",
+      "[": "[,",
+      "(": "(,"
+    };
+    isWordChar = (c) => !!c && /[\w$]/.test(c);
+    Bindings = class {
+      constructor(code) {
+        this.code = code;
+        this.groups = [];
+        this.byOpen = /* @__PURE__ */ new Map();
+        this.byClose = /* @__PURE__ */ new Map();
+        this.functions = /* @__PURE__ */ new Map();
+        this.top = {
+          start: -1,
+          end: Infinity
+        };
+        this.readGroups();
+      }
+      /**
+      * The `{` of the object literal that `name`, used at `at`, is declared as
+      * (`const`, `let` or `var`), when that is the declaration it names: the
+      * innermost one in the scope of the use, that comes before it unless the
+      * use is in a function of its own. `undefined` if it names another value,
+      * more than one declaration is the innermost, or the value is written to
+      * (given another, or one of its `properties` set) where the use can follow.
+      */
+      objectOf(name, at3, properties) {
+        const { code } = this;
+        const escaped = name.replace(/\$/g, "\\$");
+        const bindings = [];
+        for (const m of code.matchAll(new RegExp(`(?<![\\w$])${escaped}(?![\\w$])`, "g"))) {
+          const binding = this.bindingAt(m.index, name.length, properties);
+          if (binding) bindings.push(binding);
+        }
+        const declarations = bindings.filter((b) => !b.write);
+        for (const b of bindings) if (b.write) b.scope = this.innermostVisible(declarations, b.at)[0]?.scope ?? this.top;
+        const found = this.innermostVisible(bindings, at3);
+        return found.length === 1 ? found[0].object : void 0;
+      }
+      /**
+      * Of the `bindings` the use at `at` can see, those in the innermost scope:
+      * the scope is the use's, and a binding comes before it, unless the use is
+      * in a function of its own.
+      */
+      innermostVisible(bindings, at3) {
+        const useFunction = this.functionStart(at3);
+        const visible = bindings.filter((b) => b.scope.start <= at3 && at3 < b.scope.end && (!b.ordered || b.at < at3 || this.functionStart(b.at) !== useFunction));
+        const innermost = Math.max(...visible.map((b) => b.scope.start));
+        return visible.filter((b) => b.scope.start === innermost);
+      }
+      readGroups() {
+        const { code, groups } = this;
+        const stack = [];
+        for (let i2 = 0; i2 < code.length; i2++) {
+          const c = code.charAt(i2);
+          if (c === "{" || c === "(" || c === "[") {
+            const group = {
+              kind: c,
+              open: i2,
+              close: code.length,
+              parent: stack[stack.length - 1]
+            };
+            groups.push(group);
+            stack.push(group);
+            this.byOpen.set(i2, group);
+          } else if (CLOSERS[c]) {
+            let k2 = stack.length - 1;
+            while (k2 >= 0 && stack[k2].kind !== CLOSERS[c]) k2--;
+            if (k2 >= 0) {
+              stack[k2].close = i2;
+              this.byClose.set(i2, stack[k2]);
+              stack.length = k2;
+            }
+          }
+        }
+      }
+      /** The innermost group that has `index` inside it, of this kind if given. */
+      innermost(index, kind) {
+        const { groups } = this;
+        for (let k2 = groups.length - 1; k2 >= 0; k2--) {
+          const g = groups[k2];
+          if (g.open < index && index < g.close && (!kind || g.kind === kind)) return g;
+        }
+      }
+      /**
+      * The word before a `(` group (`if`, `for`, `catch`, a function's name…);
+      * `for await` is `for`.
+      */
+      ownerWord(paren) {
+        const word = this.wordBefore(this.backFrom(paren.open) + 1);
+        if (word.text !== "await") return word.text;
+        const before = this.wordBefore(this.backFrom(word.start) + 1).text;
+        return before === "for" ? before : word.text;
+      }
+      /**
+      * Whether the `{` group is the body of a function (or method), or of a
+      * class static block, which has the scope of a `var` of its own.
+      */
+      isFunctionBody(group) {
+        if (group.kind !== "{") return false;
+        let known = this.functions.get(group);
+        if (known === void 0) {
+          const before = this.backFrom(group.open);
+          const { code } = this;
+          if (code.charAt(before) === ")") {
+            const params = this.byClose.get(before);
+            known = !!params && !BLOCK_WORDS.has(this.ownerWord(params));
+          } else known = code.slice(before - 1, before + 1) === "=>" || this.wordBefore(before + 1).text === "static";
+          this.functions.set(group, known);
+        }
+        return known;
+      }
+      /** The start of the function that has `index` in its body, or -1. */
+      functionStart(index) {
+        for (let g = this.innermost(index, "{"); g; g = g.parent) if (g.kind === "{" && this.isFunctionBody(g)) return g.open;
+        return -1;
+      }
+      scopeOf(group) {
+        return group ? {
+          start: group.open,
+          end: group.close
+        } : this.top;
+      }
+      /** The block `index` is in: what `let` and `const` declare for. */
+      blockAt(index) {
+        return this.scopeOf(this.innermost(index, "{"));
+      }
+      /** The function (or the whole text) `index` is in: what `var` declares for. */
+      functionAt(index) {
+        const start = this.functionStart(index);
+        return start < 0 ? this.top : this.scopeOf(this.byOpen.get(start));
+      }
+      /**
+      * What the declaration keyword `word` (`var`, `let`, `const`) declares for:
+      * the function for `var`, the block for the others, or the `for` statement,
+      * header and body, when the declaration is in its header.
+      */
+      declaredIn(word) {
+        if (word.text === "var") return this.functionAt(word.start);
+        const group = this.innermost(word.start);
+        if (group?.kind === "(" && this.ownerWord(group) === "for") return {
+          start: group.open,
+          end: this.statementEnd(group.close + 1)
+        };
+        return this.blockAt(word.start);
+      }
+      /**
+      * Where the statement that starts at `from` ends: a block, the body of an
+      * `if`, `for`, `while` or `with` (and the `else` of an `if`), or else up to
+      * a `;`, the closer of the group it is in, or a line break that is followed
+      * by a statement of its own.
+      */
+      statementEnd(from) {
+        const { code } = this;
+        const start = this.forward(from);
+        const block = this.byOpen.get(start);
+        if (block?.kind === "{") return Math.min(block.close + 1, code.length);
+        const word = this.wordAt(start);
+        if (/^(?:if|for|while|with)$/.test(word)) {
+          let paren = this.forward(start + word.length);
+          if (word === "for" && this.wordAt(paren) === "await") paren = this.forward(paren + 5);
+          const header = this.byOpen.get(paren);
+          if (header) {
+            const end = this.statementEnd(header.close + 1);
+            const next = this.forward(end);
+            return word === "if" && this.wordAt(next) === "else" ? this.statementEnd(next + 4) : end;
+          }
+        }
+        for (let end = start; end < code.length; end++) {
+          const c = code.charAt(end);
+          if (c === ";") return end + 1;
+          if (CLOSERS[c]) return end;
+          const group = this.byOpen.get(end);
+          if (group) end = group.close;
+          else if (c === "\n" && this.startsStatement(end)) return end;
+        }
+        return code.length;
+      }
+      /** Whether the line break at `index` ends a statement, and one follows. */
+      startsStatement(index) {
+        const next = this.forward(index);
+        return /[\w$)\]}]/.test(this.code.charAt(this.backFrom(index))) && isWordChar(this.code.charAt(next)) && !/^(?:in|of|instanceof|else)$/.test(this.wordAt(next));
+      }
+      /** What a parameter list, whose `)` is `close`, is the scope of: the body. */
+      bodyAfter(close) {
+        const next = this.forward(close + 1);
+        if (this.code.charAt(next) === "{") return this.scopeOf(this.byOpen.get(next));
+        return this.code.startsWith("=>", next) ? this.arrowBody(next + 2) : void 0;
+      }
+      /** The body of an arrow function, whose `=>` ends before `from`. */
+      arrowBody(from) {
+        const { code } = this;
+        const start = this.forward(from);
+        if (code.charAt(start) === "{") return this.scopeOf(this.byOpen.get(start));
+        let end = start;
+        while (end < code.length && !",;)]}".includes(code.charAt(end))) {
+          end = this.byOpen.get(end)?.close ?? end;
+          end++;
+        }
+        return {
+          start,
+          end
+        };
+      }
+      /** The index of the last character that is no space before `index`, or -1. */
+      backFrom(index) {
+        let i2 = index - 1;
+        while (i2 >= 0 && /\s/.test(this.code.charAt(i2))) i2--;
+        return i2;
+      }
+      /** The index of the first character that is no space from `index` on. */
+      forward(index) {
+        let i2 = index;
+        while (i2 < this.code.length && /\s/.test(this.code.charAt(i2))) i2++;
+        return i2;
+      }
+      /** The word that starts at `index` (empty if there is none). */
+      wordAt(index) {
+        return this.code.slice(index, this.nameEnd(index));
+      }
+      /** The word that ends before `end`, and where it starts. */
+      wordBefore(end) {
+        let start = end;
+        while (start > 0 && isWordChar(this.code.charAt(start - 1))) start--;
+        return {
+          text: this.code.slice(start, end),
+          start
+        };
+      }
+      /**
+      * What the name of `length` characters at `at` declares, or writes to, if it
+      * does. A write to a `properties` of it counts, one to another does not.
+      */
+      bindingAt(at3, length, properties) {
+        const { code } = this;
+        let before = this.backFrom(at3);
+        const spread = code.slice(before - 2, before + 1) === "...";
+        if (code.charAt(before) === "." && !spread) return void 0;
+        if (spread) before = this.backFrom(before - 2);
+        const after = this.forward(at3 + length);
+        return this.declarationAt(at3, before, spread) ?? this.patternAt(at3, before, after) ?? this.arrowParameterAt(at3, after) ?? (spread ? void 0 : this.writeAt(at3, before, after, properties));
+      }
+      /** `const x`, `let x`, `var x`, a later `y` of `let x, y`, `function x`, `class x`. */
+      declarationAt(at3, before, spread) {
+        if (spread) return void 0;
+        const word = this.code.charAt(before) === "," ? this.listKeyword(before) : this.wordBefore(before + 1);
+        if (!word || this.code.charAt(word.start - 1) === ".") return void 0;
+        if (DECLARATIONS.has(word.text)) {
+          const scope = this.declaredIn(word);
+          const init = /\s*=\s*(?=\{)/y;
+          init.lastIndex = this.nameEnd(at3);
+          return {
+            scope,
+            at: at3,
+            ordered: true,
+            object: init.test(this.code) ? init.lastIndex : void 0
+          };
+        }
+        if (word.text === "function" || word.text === "class") return {
+          scope: this.blockAt(word.start),
+          at: at3,
+          ordered: word.text === "class"
+        };
+      }
+      /**
+      * The `const`, `let` or `var` of the declaration list that the `,` at
+      * `comma` is in (`let a = 1, b`, also in a `for` header): the nearest one
+      * before it in the same brackets, that no `;` is between.
+      */
+      listKeyword(comma) {
+        const { code } = this;
+        const floor = this.innermost(comma)?.open ?? -1;
+        for (let i2 = comma - 1; i2 > floor; i2--) {
+          const c = code.charAt(i2);
+          if (c === ";") return void 0;
+          const group = CLOSERS[c] ? this.byClose.get(i2) : void 0;
+          if (group) i2 = group.open;
+          else if (isWordChar(c)) {
+            const word = this.wordBefore(i2 + 1);
+            if (DECLARATIONS.has(word.text) && code.charAt(word.start - 1) !== ".") return word;
+            i2 = word.start;
+          }
+        }
+      }
+      nameEnd(at3) {
+        let end = at3;
+        while (isWordChar(this.code.charAt(end))) end++;
+        return end;
+      }
+      /**
+      * A name in a pattern (`const { x } = …`) or a parameter list; or one a
+      * pattern assigns to (`({ x } = …)`).
+      */
+      patternAt(at3, before, after) {
+        const { code } = this;
+        const inner = this.innermost(at3);
+        if (!inner || !BEFORE_BINDING[inner.kind].includes(code.charAt(before))) return;
+        if (inner.kind === "{" && code.charAt(after) === ":") return void 0;
+        let pattern;
+        for (let group = inner; group; group = group.parent) {
+          if (group.kind === "(") {
+            const scope = NOT_PARAMETERS.has(this.ownerWord(group)) ? void 0 : this.bodyAfter(group.close);
+            return scope ? {
+              scope,
+              at: at3,
+              ordered: false
+            } : this.patternWriteAt(at3, pattern);
+          }
+          pattern = group;
+          const open = this.backFrom(group.open);
+          const word = code.charAt(open) === "," ? this.listKeyword(open) : this.wordBefore(open + 1);
+          if (word && DECLARATIONS.has(word.text)) return {
+            scope: this.declaredIn(word),
+            at: at3,
+            ordered: true
+          };
+          if (!"({[,:".includes(code.charAt(open))) break;
+        }
+        return this.patternWriteAt(at3, pattern);
+      }
+      /** `[x] = …`, `({ x } = …)`, `for ({ x } of …)`: a name that is assigned to. */
+      patternWriteAt(at3, pattern) {
+        if (!pattern) return void 0;
+        const { code } = this;
+        const open = this.backFrom(pattern.open);
+        if (/[\w$)\]]/.test(code.charAt(open))) return void 0;
+        const next = this.forward(pattern.close + 1);
+        return pattern.parent?.kind === "(" && this.ownerWord(pattern.parent) === "for" && /^(?:of|in)(?![\w$])/.test(code.slice(next)) || this.isWriteOperator(next) ? {
+          scope: this.top,
+          at: at3,
+          ordered: true,
+          write: true
+        } : void 0;
+      }
+      /** `x => …`. */
+      arrowParameterAt(at3, after) {
+        return this.code.startsWith("=>", after) ? {
+          scope: this.arrowBody(after + 2),
+          at: at3,
+          ordered: false
+        } : void 0;
+      }
+      /** Whether an assignment, `++` or `--` operator is at `index`. */
+      isWriteOperator(index) {
+        WRITE_RE.lastIndex = index;
+        return WRITE_RE.test(this.code);
+      }
+      /**
+      * `x = …`, `x += …`, `x++`, `for (x of …)`, and the writes to what it
+      * holds that change the config it is (`x.name = …`, `delete x.name`,
+      * `x.parameters.push(…)`, `Object.assign(x, …)`): a value not known.
+      */
+      writeAt(at3, before, after, properties) {
+        const { code } = this;
+        if (this.isClassBody(this.innermost(at3))) return void 0;
+        const { keys, end } = this.memberChain(after);
+        const written2 = ["++", "--"].includes(code.slice(before - 1, before + 1)) || this.isWriteOperator(end) || keys.length > 0 && (this.wordBefore(before + 1).text === "delete" || keys.length > 1 && code.charAt(end) === "(" && MUTATORS.has(keys[keys.length - 1])) || keys.length === 0 && this.isForTarget(before, end) || keys.length === 0 && this.isMutatedArgument(before, end);
+        const first = keys[0];
+        if (!written2 || first && !properties.has(first)) return void 0;
+        return {
+          scope: this.top,
+          at: at3,
+          ordered: true,
+          write: true
+        };
+      }
+      /** Whether the group is the body of a class: its members are its own. */
+      isClassBody(group) {
+        if (group?.kind !== "{") return false;
+        let start = group.open;
+        while (start > 0 && !"{};".includes(this.code.charAt(start - 1))) start--;
+        return /(?<![\w$.])class(?![\w$])/.test(this.code.slice(start, group.open));
+      }
+      /**
+      * The properties read from a name at `from` (`.a.b[c]`, a key is null if
+      * computed), and where the chain ends.
+      */
+      memberChain(from) {
+        const { code } = this;
+        const keys = [];
+        let end = from;
+        for (; ; ) {
+          let i2 = end;
+          if (code.startsWith("?.", i2)) i2 += 2;
+          else if (code.charAt(i2) === "." && code.charAt(i2 + 1) !== ".") i2++;
+          else if (code.charAt(i2) !== "[") break;
+          i2 = this.forward(i2);
+          const bracket = code.charAt(i2) === "[" ? this.byOpen.get(i2) : void 0;
+          const key = bracket ? "" : this.wordAt(i2);
+          if (!bracket && !key) break;
+          keys.push(bracket ? null : key);
+          end = this.forward(bracket ? bracket.close + 1 : i2 + key.length);
+        }
+        return {
+          keys,
+          end
+        };
+      }
+      /** `for (x of …)`: the name is assigned each item. */
+      isForTarget(before, end) {
+        const group = this.byOpen.get(before);
+        return group?.kind === "(" && this.ownerWord(group) === "for" && /^(?:of|in)(?![\w$])/.test(this.code.slice(end));
+      }
+      /** `Object.assign(x, …)` and the like: the name is the first argument. */
+      isMutatedArgument(before, end) {
+        const group = this.byOpen.get(before);
+        return group?.kind === "(" && ",)".includes(this.code.charAt(end)) && MUTATING_CALL_RE.test(this.code.slice(0, group.open));
+      }
+    };
     CALL_RE = /(?<![\w$])defineMacro\s*\(\s*/g;
     IDENTIFIER_ARGUMENT_RE = /^([A-Za-z_$][\w$]*)\s*[,)]/;
     WORD_RE = /[A-Za-z_]+/y;
+    MODIFIER_RE = /^(?:get|set|async)?$/;
+    KEY_START_RE = /[\w$'"[.*]/;
+    CONFIG_KEYS = /* @__PURE__ */ new Set([
+      "name",
+      "block",
+      "subMacros",
+      "parameters",
+      "interpolate",
+      "storeVar",
+      "merged",
+      "description"
+    ]);
     ConfigReader = class extends Reader {
       constructor(..._args) {
         super(..._args);
@@ -14686,18 +15324,47 @@ var init_story_variables = __esm({
       }
       record() {
         const props = /* @__PURE__ */ new Map();
-        return this.elements("}", () => {
-          const key = this.key();
-          this.space();
-          if (key !== void 0 && this.src.charAt(this.i) === ":") {
-            this.i++;
-            props.set(key, this.member());
-          } else if (!this.skipMember()) this.fail();
-        }) ? {
+        return this.elements("}", () => this.property(props)) ? {
           type: "object",
           props
         } : void 0;
       }
+      /**
+      * A member: what it sets replaces an earlier member of the key. One that is
+      * not a literal (a method, an accessor, a shorthand) sets its key to a
+      * value not known; a spread of an object literal sets the members of it, a
+      * spread of anything else or a computed key can set any key.
+      */
+      property(props) {
+        const { src } = this;
+        if (src.startsWith("...", this.i)) {
+          this.i += 3;
+          this.space();
+          const spread = src.charAt(this.i) === "{" ? this.record() : void 0;
+          this.space();
+          if (spread?.type === "object" && this.atElementEnd()) {
+            for (const [key, value] of spread.props) props.set(key, value);
+            return;
+          }
+          props.clear();
+        } else {
+          let key = this.key();
+          this.space();
+          if (key !== void 0 && src.charAt(this.i) === ":") {
+            this.i++;
+            props.set(key, this.member());
+            return;
+          }
+          if (MODIFIER_RE.test(key ?? "") && KEY_START_RE.test(src.charAt(this.i))) {
+            if (src.charAt(this.i) === "*") this.i++;
+            this.space();
+            key = this.key();
+          }
+          if (key === void 0) props.clear();
+          else props.set(key, void 0);
+        }
+        if (!this.skipMember()) this.fail();
+      }
       /** Stop reading: the text cannot be skipped through. */
       fail() {
         this.failed = true;
@@ -14956,48 +15623,56 @@ var init_macro_registry = __esm({
         "name": "story-title",
         "block": false,
         "subMacros": [],
+        "interpolate": true,
         "source": "builtin"
       },
       {
         "name": "back",
         "block": false,
         "subMacros": [],
+        "interpolate": true,
         "source": "builtin"
       },
       {
         "name": "forward",
         "block": false,
         "subMacros": [],
+        "interpolate": true,
         "source": "builtin"
       },
       {
         "name": "quicksave",
         "block": false,
         "subMacros": [],
+        "interpolate": true,
         "source": "builtin"
       },
       {
         "name": "quickload",
         "block": false,
         "subMacros": [],
+        "interpolate": true,
         "source": "builtin"
       },
       {
         "name": "restart",
         "block": false,
         "subMacros": [],
+        "interpolate": true,
         "source": "builtin"
       },
       {
         "name": "saves",
         "block": false,
         "subMacros": [],
+        "interpolate": true,
         "source": "builtin"
       },
       {
         "name": "settings",
         "block": false,
         "subMacros": [],
+        "interpolate": true,
         "source": "builtin"
       },
       {
@@ -15023,12 +15698,14 @@ var init_macro_registry = __esm({
         "name": "save-manager",
         "block": false,
         "subMacros": [],
+        "interpolate": true,
         "source": "builtin"
       },
       {
         "name": "settings-controls",
         "block": false,
         "subMacros": [],
+        "interpolate": true,
         "source": "builtin"
       },
       {
@@ -15054,6 +15731,7 @@ var init_macro_registry = __esm({
         "name": "nobr",
         "block": true,
         "subMacros": [],
+        "interpolate": true,
         "source": "builtin"
       },
       {
@@ -15088,6 +15766,7 @@ var init_macro_registry = __esm({
         "block": false,
         "subMacros": [],
         "storeVar": true,
+        "interpolate": true,
         "parameters": [
           {
             "name": "variable",
@@ -15107,6 +15786,7 @@ var init_macro_registry = __esm({
         "block": false,
         "subMacros": [],
         "storeVar": true,
+        "interpolate": true,
         "parameters": [
           {
             "name": "variable",
@@ -15126,6 +15806,7 @@ var init_macro_registry = __esm({
         "block": false,
         "subMacros": [],
         "storeVar": true,
+        "interpolate": true,
         "parameters": [
           {
             "name": "variable",
@@ -15145,6 +15826,7 @@ var init_macro_registry = __esm({
         "block": false,
         "subMacros": [],
         "storeVar": true,
+        "interpolate": true,
         "parameters": [
           {
             "name": "variable",
@@ -15164,6 +15846,7 @@ var init_macro_registry = __esm({
         "block": false,
         "subMacros": [],
         "storeVar": true,
+        "interpolate": true,
         "parameters": [
           {
             "name": "variable",
@@ -15191,6 +15874,7 @@ var init_macro_registry = __esm({
           "option"
         ],
         "storeVar": true,
+        "interpolate": true,
         "parameters": [
           {
             "name": "variable",
@@ -15205,6 +15889,7 @@ var init_macro_registry = __esm({
         "block": true,
         "subMacros": [],
         "storeVar": true,
+        "interpolate": true,
         "parameters": [
           {
             "name": "variable",
@@ -15218,6 +15903,7 @@ var init_macro_registry = __esm({
         "name": "span",
         "block": true,
         "subMacros": [],
+        "interpolate": true,
         "source": "builtin"
       },
       {
@@ -71918,7 +72604,7 @@ var init_server4 = __esm({
 
 // src/bin.ts
 var args = process.argv.slice(2);
-var VERSION = "0.13.2";
+var VERSION = "0.13.3";
 var HELP = `spindle-lsp v${VERSION}
 Language Server Protocol server for Spindle story format