@rohal12/spindle-lsp 0.13.2 → 0.14.0

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;
@@ -6846,8 +6855,8 @@ function walk(node, src, out, binding, shorthand) {
       }
   }
 }
-function findCodeEnd(src, start, { goal = "expression", stop } = {}) {
-  const end = scanCodeEnd(src, start, goal, stop);
+function findCodeEnd(src, start, { goal = "expression", stop, onRunOut } = {}) {
+  const end = scanCodeEnd(src, start, goal, stop, onRunOut);
   return end < 0 && !stop ? parsedCodeEnd(src, start, goal) : end;
 }
 function parsedCodeEnd(src, start, goal) {
@@ -6865,7 +6874,11 @@ function parsedCodeEnd(src, start, goal) {
   }
   return -1;
 }
-function scanCodeEnd(src, start, goal, stop) {
+function scanCodeEnd(src, start, goal, stop, onRunOut) {
+  const ranOut = () => {
+    onRunOut?.();
+    return -1;
+  };
   const stack = [];
   let prevEnd = -1;
   let prevWord = false;
@@ -6881,11 +6894,12 @@ function scanCodeEnd(src, start, goal, stop) {
         if (!/^Unterminated/.test(message) && !inTemplate) {
           resumeAt = Math.max(tok.pos, from) + 1;
           afterOperand = false;
-          if (resumeAt >= src.length) return -1;
+          if (resumeAt >= src.length) return ranOut();
           break;
         }
         const k2 = stack.lastIndexOf("${");
-        if (!/^Unterminated template/.test(message) || k2 < 0 || templateSlip || stop) return -1;
+        if (!/^Unterminated template/.test(message) || k2 < 0 || templateSlip || stop) return /^Unterminated/.test(message) && !/^Unterminated regular/.test(message) && !(/^Unterminated string/.test(message) && prevWord && tok.pos === prevEnd) ? ranOut() : -1;
+        onRunOut?.();
         templateSlip = true;
         stack.length = k2;
         resumeAt = tok.pos;
@@ -6894,7 +6908,7 @@ function scanCodeEnd(src, start, goal, stop) {
       }
       if (tok.restarted && stack.includes("${")) return -1;
       const t = tok.type;
-      if (t === types$1.eof) return -1;
+      if (t === types$1.eof) return ranOut();
       if (t === types$1.string && prevWord && tok.start === prevEnd) return -1;
       prevWord = t === types$1.name && !WORDS_BEFORE_STRING.has(tok.value) || t === types$1.num;
       prevEnd = tok.end;
@@ -7035,7 +7049,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) {
@@ -7122,48 +7136,107 @@ function scanStringLiteral(src, start) {
 function skipLiteral(input, i2) {
   const quote = input[i2];
   const template = quote === "`";
+  let ranOut = false;
   for (let j2 = i2 + 1; j2 < input.length; ) {
     const c = input[j2];
     if (c === "\\") j2 += 2;
-    else if (c === quote) return j2 + 1;
-    else if (!template && c === "\n") return -1;
+    else if (c === quote) return {
+      end: j2 + 1,
+      ranOut
+    };
+    else if (!template && c === "\n") return {
+      end: -1,
+      ranOut
+    };
     else if (template && c === "$" && input[j2 + 1] === "{") {
-      const close = lenientClose(input, j2 + 2);
-      if (close === -1) return -1;
-      j2 = close + 1;
+      const close = lenientRead(input, j2 + 2);
+      ranOut || (ranOut = close.ranOut);
+      if (close.end === -1) return {
+        end: -1,
+        ranOut
+      };
+      j2 = close.end + 1;
     } else j2++;
   }
-  return -1;
+  return {
+    end: -1,
+    ranOut: ranOut || template
+  };
+}
+function lenientClose(input, i2, onRunOut) {
+  const { end, ranOut } = lenientRead(input, i2);
+  if (ranOut) onRunOut?.();
+  return end;
 }
-function lenientClose(input, i2) {
+function lenientRead(input, i2) {
   if (memoInput !== input) {
     memoInput = input;
     memo.clear();
   }
-  let end = memo.get(i2);
-  if (end === void 0) {
-    end = scanLenient(input, i2);
-    memo.set(i2, end);
+  let read = memo.get(i2);
+  if (read === void 0) {
+    read = scanLenient(input, i2);
+    memo.set(i2, read);
   }
-  return end;
+  return read;
 }
 function scanLenient(input, i2) {
   let depth = 0;
+  let ranOut = false;
   while (i2 < input.length) {
     const c = input[i2];
     if (c === "{") {
       depth++;
       i2++;
     } else if (c === "}") {
-      if (depth === 0) return i2;
+      if (depth === 0) return {
+        end: i2,
+        ranOut
+      };
       depth--;
       i2++;
     } else if (c === "`" || (c === '"' || c === "'") && !(i2 > 0 && NON_STRING_QUOTE_PREFIX.test(input[i2 - 1]))) {
       const close = skipLiteral(input, i2);
-      i2 = close === -1 ? i2 + 1 : close;
+      ranOut || (ranOut = close.ranOut);
+      i2 = close.end === -1 ? i2 + 1 : close.end;
     } else i2++;
   }
-  return -1;
+  return {
+    end: -1,
+    ranOut: true
+  };
+}
+function jsCodeEnd(onOpenEnd) {
+  return {
+    closeBrace(input, codeStart, lenientStart) {
+      let ranOut = false;
+      const onRunOut = () => ranOut = true;
+      const strict = findCodeEnd(input, codeStart, { onRunOut });
+      const end = strict !== -1 ? strict : lenientClose(input, lenientStart, onRunOut);
+      if (ranOut) onOpenEnd?.(input, codeStart);
+      return end;
+    },
+    rawBodyEnd(input, bodyStart, name) {
+      const closer = `\\{/${name}\\s*\\}`;
+      const first = new RegExp(closer, "gi");
+      first.lastIndex = bodyStart;
+      const firstAt = first.exec(input)?.index ?? -1;
+      if (firstAt === -1) return -1;
+      const at3 = new RegExp(closer, "iy");
+      let ranOut = false;
+      const end = findCodeEnd(input, bodyStart, {
+        goal: "statements",
+        stop: (k2) => {
+          at3.lastIndex = k2;
+          return at3.test(input);
+        },
+        onRunOut: () => ranOut = true
+      });
+      if (end !== -1) return end;
+      if (onOpenEnd && (ranOut || new RegExp(`\\{/${name}\\s*$`, "i").test(input))) onOpenEnd(input, bodyStart);
+      return firstAt;
+    }
+  };
 }
 function isCodeAttribute(name) {
   const lower = name.toLowerCase();
@@ -7195,7 +7268,7 @@ function splitSigilTemplate(template) {
   if (text2) parts.push({ text: text2 });
   return parts;
 }
-function run(source, startRule, options) {
+function run$1(source, startRule, options) {
   const hooks = options.hooks ? {
     ...defaultHooks,
     ...options.hooks
@@ -7217,7 +7290,7 @@ function run(source, startRule, options) {
   }
 }
 function analyzeMarkup(source, options = {}) {
-  const { tokens: tokens2, errors, damage } = scan(source, options);
+  const { tokens: tokens2, errors, damage } = scanMarkupTolerant(source, options);
   const hooks = {
     ...defaultHooks,
     ...options.hooks
@@ -7252,23 +7325,23 @@ function pairingError(source, error48) {
   return new MarkupError(error48.message, error48.start, line, column, error48.code, error48.end, error48.data);
 }
 function tokenizeMarkup(source, options = {}) {
-  return run(source, "Tokens", options);
+  return run$1(source, "Tokens", options);
 }
 function parseSelectors(source, at3 = 0) {
-  const found = run(source.slice(at3), "SelectorsPrefix", {});
+  const found = run$1(source.slice(at3), "SelectorsPrefix", {});
   return {
     ...found,
     end: at3 + found.end
   };
 }
 function tokenizeMarkupTolerant(source, options = {}) {
-  const { tokens: tokens2, errors } = scan(source, options);
+  const { tokens: tokens2, errors } = scanMarkupTolerant(source, options);
   return {
     tokens: tokens2,
     errors
   };
 }
-function scan(source, options) {
+function scanMarkupTolerant(source, options = {}) {
   const tokens2 = [];
   const errors = [];
   const damage = [];
@@ -7416,15 +7489,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 +7514,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 +7612,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 +7649,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 +7722,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 +7784,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 +7805,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 +7819,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 +7911,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 +7968,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 +8016,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 +8088,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 +8141,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 +8156,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 +8186,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 +8205,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 +8275,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 +8433,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 +8443,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 +8579,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 +8595,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 +8634,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 +8682,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 +8721,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 +8757,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 +8781,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 +8850,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);
@@ -8678,12 +8874,561 @@ function discoverMacros(source) {
   }
   return found;
 }
+function segmentRegions(body) {
+  const lines = body.split("\n");
+  if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  if (lines.length === 0) return [];
+  const regions = [];
+  let i2 = 0;
+  while (i2 < lines.length) {
+    const line = lines[i2];
+    const trimmed2 = line.trim();
+    if (/^<script(\s|>)/i.test(trimmed2)) {
+      const block = blockLines(lines, i2, /<\/script\s*>/i);
+      regions.push({
+        type: "script",
+        lines: block
+      });
+      i2 += block.length;
+      continue;
+    }
+    if (/^<svg(\s|>)/i.test(trimmed2)) {
+      const block = blockLines(lines, i2, /<\/svg\s*>/i);
+      regions.push({
+        type: "svg",
+        lines: block
+      });
+      i2 += block.length;
+      continue;
+    }
+    if (/^<([a-zA-Z][\w-]*)/.test(trimmed2)) {
+      const tagName = trimmed2.match(/^<([a-zA-Z][\w-]*)/)[1].toLowerCase();
+      if (VOID_ELEMENTS.has(tagName) && !lines[i2 + 1]?.trim().startsWith("<")) {
+        pushSpindleLine(regions, line);
+        i2++;
+        continue;
+      }
+      if (new RegExp(`</${tagName}\\s*>`, "i").test(trimmed2)) {
+        pushSpindleLine(regions, line);
+        i2++;
+        continue;
+      }
+      const htmlLines = [line];
+      let depth = 1;
+      i2++;
+      while (i2 < lines.length && depth > 0) {
+        htmlLines.push(lines[i2]);
+        const opens = (lines[i2].match(new RegExp(`<${tagName}(?:[\\s>]|$)`, "gi")) ?? []).length;
+        const closes2 = (lines[i2].match(new RegExp(`</${tagName}\\s*>`, "gi")) ?? []).length;
+        depth += opens - closes2;
+        i2++;
+      }
+      regions.push({
+        type: "html",
+        lines: htmlLines
+      });
+      continue;
+    }
+    pushSpindleLine(regions, line);
+    i2++;
+  }
+  return regions;
+}
+function blockLines(lines, start, close) {
+  let end = start;
+  while (end < lines.length - 1 && !close.test(lines[end])) end++;
+  return lines.slice(start, end + 1);
+}
+function pushSpindleLine(regions, line) {
+  const last2 = regions[regions.length - 1];
+  if (last2?.type === "spindle") last2.lines.push(line);
+  else regions.push({
+    type: "spindle",
+    lines: [line]
+  });
+}
+async function run(code, prettier2, options, overrides) {
+  if (!prettier2) return void 0;
+  try {
+    return await prettier2.format(code, {
+      ...options ?? DEFAULT_PRETTIER_OPTIONS,
+      ...overrides
+    });
+  } catch {
+    return;
+  }
+}
+function formatJS(code, prettier2, options) {
+  return run(code, prettier2, options, { parser: "babel" });
+}
+function formatCSS(code, prettier2, options) {
+  return run(code, prettier2, options, { parser: "css" });
+}
+function formatHTML(code, prettier2, options) {
+  return run(code, prettier2, options, {
+    parser: "html",
+    htmlWhitespaceSensitivity: "css"
+  });
+}
+function scanSpindleMarkup(text2) {
+  const tokens2 = [];
+  const tags = [];
+  const doBlocks = [];
+  let open;
+  const push = (t, inAttribute) => {
+    const match = {
+      start: t.start,
+      end: t.end,
+      token: text2.slice(t.start, t.end)
+    };
+    if (inAttribute) match.inAttribute = true;
+    tokens2.push(match);
+  };
+  for (const t of tokenizeMarkupTolerant(text2).tokens) if (t.type === "html") {
+    tags.push({
+      start: t.start,
+      end: t.end
+    });
+    for (const attribute of t.attributeSpans) {
+      if (attribute.valueStart === void 0 || attribute.valueEnd === void 0) continue;
+      const value = text2.slice(attribute.valueStart, attribute.valueEnd);
+      if (!value.includes("{")) continue;
+      for (const inner of tokenizeMarkupTolerant(value, { text: true }).tokens) if (inner.type === "macro" || inner.type === "variable" || inner.type === "expression") push({
+        start: attribute.valueStart + inner.start,
+        end: attribute.valueStart + inner.end
+      }, true);
+    }
+  } else if (t.type !== "text") {
+    if (t.type === "macro" && t.name === "do") {
+      if (!t.isClose) open = t;
+      else if (open) {
+        doBlocks.push({
+          start: open.start,
+          end: t.end,
+          bodyStart: open.end,
+          bodyEnd: t.start
+        });
+        open = void 0;
+      }
+    }
+    push(t);
+  }
+  return {
+    tokens: tokens2,
+    tags,
+    doBlocks
+  };
+}
+function multilineJsLiterals(code) {
+  const spans = [];
+  let skipUntil = 0;
+  lexJs(code, { literal(text2, index, nesting) {
+    if (nesting > 0 || index < skipUntil) return;
+    const quote = text2[0];
+    if (quote === "`") {
+      skipUntil = lexTemplate(code, index);
+      if (code.slice(index, skipUntil).includes("\n")) spans.push([index, skipUntil]);
+    } else if ((quote === '"' || quote === "'") && text2.includes("\n")) spans.push([index, index + text2.length]);
+  } }, "statements");
+  return spans;
+}
+function lineHasTag(tags, start, end) {
+  return tags.some((tag) => tag.start < end && tag.end > start);
+}
+function replaceSvgBlocks(html) {
+  const tokens2 = [];
+  return {
+    text: html.replace(/<svg[\s>][\s\S]*?<\/svg>/gi, (match) => {
+      const idx = tokens2.length;
+      tokens2.push(match);
+      return `<!--SVG:${idx}-->`;
+    }),
+    tokens: tokens2
+  };
+}
+function placeholdersIntact(text2, tokens2, placeholdersOf) {
+  return tokens2.every((_2, index) => placeholdersOf(index).reduce((count, placeholder) => count + text2.split(placeholder).length - 1, 0) === 1);
+}
+function sameSpindleTokens(before, after) {
+  const tokensOf2 = (text2) => scanSpindleMarkup(text2).tokens.map((m) => m.token);
+  const expected = tokensOf2(before);
+  const found = tokensOf2(after);
+  return expected.length === found.length && expected.every((t, i2) => t === found[i2]);
+}
+function restorePlaceholders(text2, tokens2, placeholdersOf) {
+  let result = text2;
+  tokens2.forEach((token, index) => {
+    for (const placeholder of placeholdersOf(index)) result = result.replace(placeholder, () => token);
+  });
+  return result;
+}
+function restoreSvgBlocks(text2, tokens2) {
+  return restorePlaceholders(text2, tokens2, SVG_PLACEHOLDERS);
+}
+function replaceSpindleTokens(html) {
+  const { tokens: found, tags, doBlocks } = scanSpindleMarkup(html);
+  const units = [];
+  const pushDoBlock = (block) => units.push({
+    start: block.start,
+    end: block.end,
+    token: html.slice(block.start, block.end)
+  });
+  let doIndex = 0;
+  for (const m of found) {
+    for (let block = doBlocks[doIndex]; block && block.end <= m.start; ) {
+      pushDoBlock(block);
+      block = doBlocks[++doIndex];
+    }
+    const open = doBlocks[doIndex];
+    if (open && m.start >= open.start) continue;
+    units.push(m);
+  }
+  for (; doIndex < doBlocks.length; doIndex++) pushDoBlock(doBlocks[doIndex]);
+  units.sort((a, b) => a.start - b.start);
+  const tokens2 = [];
+  const resultLines = [];
+  let unit = 0;
+  let lineStart = 0;
+  while (lineStart <= html.length) {
+    let lineEnd = lineStart;
+    const lineUnits = [];
+    for (; ; ) {
+      while (unit < units.length && units[unit].end <= lineEnd) unit++;
+      const next = units[unit];
+      const inside = next && next.start <= lineEnd ? next : void 0;
+      if (inside) {
+        lineUnits.push(inside);
+        lineEnd = inside.end;
+        unit++;
+        continue;
+      }
+      if (lineEnd >= html.length || html[lineEnd] === "\n") break;
+      lineEnd++;
+    }
+    const line = html.slice(lineStart, lineEnd);
+    const indent = line.match(/^(\s*)/)?.[1] ?? "";
+    if (lineUnits.length === 0) resultLines.push(line);
+    else if (!lineHasTag(tags, lineStart, lineEnd)) {
+      const idx = tokens2.length;
+      tokens2.push(line.trim());
+      resultLines.push(`${indent}<!--SP:${idx}-->`);
+    } else {
+      let replaced = "";
+      let last2 = lineStart;
+      for (const u of lineUnits) {
+        const idx = tokens2.length;
+        tokens2.push(u.token);
+        replaced += html.slice(last2, u.start) + (u.inAttribute ? `__SP${idx}__` : `<!--SP:${idx}-->`);
+        last2 = u.end;
+      }
+      resultLines.push(replaced + html.slice(last2, lineEnd));
+    }
+    lineStart = lineEnd + 1;
+  }
+  return {
+    text: resultLines.join("\n"),
+    tokens: tokens2
+  };
+}
+function restoreSpindleTokens(text2, tokens2) {
+  return restorePlaceholders(text2, tokens2, SPINDLE_PLACEHOLDERS);
+}
+function closedMacroNames(text2) {
+  const found = /* @__PURE__ */ new Set();
+  for (const t of tokenizeMarkupTolerant(text2).tokens) if (t.type === "macro" && t.isClose) found.add(t.name.toLowerCase());
+  return found;
+}
+function defaultIsBlock(text2, extra = []) {
+  const closed = closedMacroNames(text2);
+  for (const name of extra) closed.add(name.toLowerCase());
+  return (name) => isBlockMacro(name) || closed.has(name.toLowerCase());
+}
+async function formatPassage(body, options = {}) {
+  if (body.charCodeAt(0) === 65279) return "\uFEFF" + await formatPassage(body.slice(1), options);
+  const eol = dominantEol(body);
+  const output = await formatLf(body.replace(/\r\n/g, "\n"), options);
+  return eol === "\r\n" ? output.replace(/\n/g, "\r\n") : output;
+}
+function dominantEol(text2) {
+  const crlf = (text2.match(/\r\n/g) ?? []).length;
+  const lf = (text2.match(/\n/g) ?? []).length - crlf;
+  if (crlf !== lf) return crlf > lf ? "\r\n" : "\n";
+  return text2.indexOf("\r\n") !== -1 && text2.indexOf("\r\n") < text2.indexOf("\n") ? "\r\n" : "\n";
+}
+function replaceAll(text2, from, to) {
+  return text2.split(from).join(to);
+}
+function newlineSentinel(text2) {
+  for (let code = 57344; code <= 63743; code++) {
+    const ch = String.fromCharCode(code);
+    if (!text2.includes(ch)) return ch;
+  }
+  throw new Error("no free private-use character for the newline stand-in");
+}
+function protectMultilineTokens(body, sentinel) {
+  const { tokens: tokens2, doBlocks } = scanSpindleMarkup(body);
+  const spans = [];
+  for (const m of tokens2) if (m.token.includes("\n")) spans.push([m.start, m.end]);
+  for (const block of doBlocks) for (const [a, b] of multilineJsLiterals(body.slice(block.bodyStart, block.bodyEnd))) spans.push([block.bodyStart + a, block.bodyStart + b]);
+  return joinSpans(body, spans, sentinel);
+}
+function joinJsLiterals(code, sentinel) {
+  return joinSpans(code, multilineJsLiterals(code), sentinel);
+}
+function joinSpans(text2, spans, sentinel) {
+  let out = "";
+  let last2 = 0;
+  for (const [a, b] of [...spans].sort((x2, y) => x2[0] - y[0])) {
+    out += text2.slice(last2, a) + replaceAll(text2.slice(a, b), "\n", sentinel);
+    last2 = b;
+  }
+  return out + text2.slice(last2);
+}
+async function formatLf(text2, options) {
+  const { prettier: prettier2, prettierOptions } = options;
+  const body = text2.replace(/(?:[ \t]*\n)+[ \t]*$/, "\n");
+  if (options.kind === "script" || options.kind === "stylesheet") {
+    const format = options.kind === "script" ? formatJS : formatCSS;
+    const code = body.trim();
+    return (await format(code, prettier2, prettierOptions) ?? code).trim().replace(/\n*$/, "\n");
+  }
+  const isBlock = options.isBlock ?? defaultIsBlock(body, options.blockMacros);
+  const isDedenting = options.isDedentingSubMacro ?? ((name) => DEFAULT_DEDENTING.has(name.toLowerCase()));
+  const sentinel = newlineSentinel(body);
+  const lines = [];
+  const hardBreakLines = /* @__PURE__ */ new Set();
+  const regions = segmentRegions(protectMultilineTokens(body, sentinel));
+  for (const region of regions) {
+    if (region.type !== "spindle") region.lines = region.lines.map((l) => replaceAll(l, sentinel, "\n"));
+    if (region.type === "script") {
+      if (region.lines.length === 1) {
+        lines.push(...region.lines);
+        continue;
+      }
+      const innerCode = region.lines.slice(1, -1).join("\n");
+      const formatted = await formatJS(innerCode.trim(), prettier2, prettierOptions);
+      if (formatted === void 0 || !sameSpindleTokens(innerCode, formatted)) {
+        lines.push(...region.lines);
+        continue;
+      }
+      lines.push(region.lines[0]);
+      if (formatted.trim()) for (const fLine of joinJsLiterals(formatted.trim(), sentinel).split("\n")) lines.push("  " + fLine);
+      lines.push(region.lines[region.lines.length - 1]);
+      continue;
+    }
+    if (region.type === "svg") {
+      lines.push(...region.lines);
+      continue;
+    }
+    if (region.type === "html") {
+      const htmlText = region.lines.join("\n");
+      if (WHITESPACE_AS_WRITTEN.test(htmlText)) {
+        lines.push(...region.lines);
+        continue;
+      }
+      const { text: svgPlaceholdered, tokens: svgTokens } = replaceSvgBlocks(htmlText);
+      const { text: placeholdered, tokens: tokens2 } = replaceSpindleTokens(svgPlaceholdered);
+      const formatted = await formatHTML(placeholdered, prettier2, prettierOptions);
+      if (formatted === void 0 || !placeholdersIntact(formatted, tokens2, SPINDLE_PLACEHOLDERS) || !placeholdersIntact(formatted, svgTokens, SVG_PLACEHOLDERS)) {
+        lines.push(...region.lines);
+        continue;
+      }
+      const restored = restoreSvgBlocks(restoreSpindleTokens(formatted.trim(), tokens2.map((t) => replaceAll(t, "\n", sentinel))), svgTokens);
+      for (const fLine of restored.split("\n")) lines.push(fLine);
+      continue;
+    }
+    let indented = indentMacros(region.lines, isBlock, isDedenting);
+    if (options.maxLineLength) indented = wrapLines(indented, options.maxLineLength);
+    for (const line of indented) {
+      if (line.endsWith("  ")) hardBreakLines.add(lines.length);
+      lines.push(line);
+    }
+  }
+  let output = lines.map((l, i2) => hardBreakLines.has(i2) ? l : l.replace(/\s+$/, "")).join("\n");
+  output = output.replace(/\n*$/, "\n");
+  return replaceAll(output, sentinel, "\n");
+}
+function indentMacros(lines, isBlock, isDedenting) {
+  const macrosOnLine = macroTokensByLine(lines);
+  const bodies = [{
+    openLine: -1,
+    minCol: Infinity,
+    keepRelative: false
+  }];
+  const stack = [0];
+  const info = [];
+  const openBody = (line) => {
+    bodies.push({
+      openLine: line,
+      minCol: Infinity,
+      keepRelative: false
+    });
+    stack.push(bodies.length - 1);
+  };
+  const currentBody = () => stack[stack.length - 1];
+  const closeBody = () => stack.length > 1 ? stack.pop() : void 0;
+  const addLine = (col, text2) => {
+    const body = bodies[currentBody()];
+    body.minCol = Math.min(body.minCol, col);
+    if (LIST_ITEM_REGEX.test(text2) || CODE_FENCE_REGEX.test(text2)) body.keepRelative = true;
+    info.push({
+      body: currentBody(),
+      col,
+      text: text2
+    });
+  };
+  for (let i2 = 0; i2 < lines.length; i2++) {
+    const lineText = lines[i2];
+    const trimmed2 = lineText.trim();
+    if (trimmed2 === "") {
+      info.push(null);
+      continue;
+    }
+    const col = indentColumn(lineText);
+    const lead = lineText.length - lineText.trimStart().length;
+    const macros = macrosOnLine[i2];
+    const [first, ...rest] = macros;
+    const startsWithMacro = first !== void 0 && first.start === lead;
+    if (startsWithMacro && !first.isClose && isDedenting(first.name)) {
+      const closed2 = closeBody();
+      if (closed2 === void 0) addLine(col, trimmed2);
+      else info.push({
+        body: currentBody(),
+        closes: closed2,
+        col,
+        text: trimmed2
+      });
+      openBody(i2);
+      continue;
+    }
+    const closed = startsWithMacro && first.isClose ? closeBody() : void 0;
+    if (closed === void 0) addLine(col, trimmed2);
+    else info.push({
+      body: currentBody(),
+      closes: closed,
+      col,
+      text: trimmed2
+    });
+    if (startsWithMacro && !first.isClose && isBlock(first.name)) openBody(i2);
+    for (const macro of startsWithMacro ? rest : macros) if (macro.isClose && macro.start > lead) closeBody();
+  }
+  const outCol = [];
+  const result = [];
+  for (let i2 = 0; i2 < info.length; i2++) {
+    const line = info[i2];
+    if (!line) {
+      outCol.push(0);
+      result.push("");
+      continue;
+    }
+    let col;
+    if (line.closes !== void 0) col = outCol[bodies[line.closes].openLine];
+    else {
+      const body = bodies[line.body];
+      const isRoot = body.openLine === -1;
+      col = (isRoot ? 0 : outCol[body.openLine] + 2) + (body.keepRelative ? line.col - (isRoot ? 0 : body.minCol) : 0);
+    }
+    outCol.push(col);
+    const hardBreak = / {2,}$/.test(lines[i2]) && info[i2 + 1] ? "  " : "";
+    result.push(" ".repeat(col) + line.text + hardBreak);
+  }
+  return result;
+}
+function macroTokensByLine(lines) {
+  const byLine = lines.map(() => []);
+  const starts = [];
+  let offset2 = 0;
+  for (const line2 of lines) {
+    starts.push(offset2);
+    offset2 += line2.length + 1;
+  }
+  let line = 0;
+  for (const token of tokenizeMarkupTolerant(lines.join("\n")).tokens) {
+    if (token.type !== "macro") continue;
+    while (line + 1 < lines.length && starts[line + 1] <= token.start) line++;
+    const lineStart = starts[line];
+    byLine[line].push({
+      ...token,
+      start: token.start - lineStart,
+      end: token.end - lineStart
+    });
+  }
+  return byLine;
+}
+function indentColumn(line) {
+  let col = 0;
+  for (const ch of line) if (ch === " ") col++;
+  else if (ch === "	") col += 4 - col % 4;
+  else break;
+  return col;
+}
+function wrapLines(lines, maxLen) {
+  const result = [];
+  const javaScript = doBodyLines(lines);
+  for (const [index, line] of lines.entries()) {
+    if (line.length <= maxLen || javaScript.has(index)) {
+      result.push(line);
+      continue;
+    }
+    const trimmed2 = line.trim();
+    if (trimmed2 === "" || /^\{[\/#.]/.test(trimmed2) || /^\[\[/.test(trimmed2) || /^\{choice\b/.test(trimmed2) || /^\{choices\b/.test(trimmed2)) {
+      result.push(line);
+      continue;
+    }
+    const wrapped = wordWrap(trimmed2, maxLen, line.match(/^(\s*)/)?.[1] ?? "");
+    if (line.endsWith("  ")) wrapped[wrapped.length - 1] += "  ";
+    result.push(...wrapped);
+  }
+  return result;
+}
+function doBodyLines(lines) {
+  const found = /* @__PURE__ */ new Set();
+  const text2 = lines.join("\n");
+  for (const block of scanSpindleMarkup(text2).doBlocks) {
+    const first = text2.slice(0, block.bodyStart).split("\n").length - 1;
+    const last2 = text2.slice(0, block.bodyEnd).split("\n").length - 1;
+    for (let i2 = first; i2 <= last2; i2++) found.add(i2);
+  }
+  return found;
+}
+function wordWrap(text2, maxLen, indent) {
+  const lines = [];
+  const inToken = new Array(text2.length).fill(false);
+  for (const token of tokenizeMarkupTolerant(text2).tokens) {
+    if (token.type === "text" || token.type === "html") continue;
+    inToken.fill(true, token.start, token.end);
+  }
+  const room = maxLen - indent.length;
+  let pos = 0;
+  while (pos < text2.length) {
+    if (text2.length - pos <= room) {
+      lines.push(indent + text2.slice(pos));
+      break;
+    }
+    let breakIdx = -1;
+    for (let i2 = pos + 1; i2 < text2.length && i2 - pos <= room; i2++) if (text2[i2] === " " && !inToken[i2]) breakIdx = i2;
+    if (breakIdx === -1) {
+      for (let i2 = pos + room + 1; i2 < text2.length; i2++) if (text2[i2] === " " && !inToken[i2]) {
+        breakIdx = i2;
+        break;
+      }
+    }
+    if (breakIdx === -1) {
+      lines.push(indent + text2.slice(pos));
+      break;
+    }
+    lines.push(indent + text2.slice(pos, breakIdx));
+    pos = breakIdx + 1;
+  }
+  return lines;
+}
 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,24 +9444,33 @@ 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);
 }
 function passagePieces(source, macros = []) {
+  return passagePiecesOfTokens(source, macros, tokenizeMarkupTolerant(source).tokens);
+}
+function passagePiecesOfTokens(source, macros, tokens2) {
   const all = [...macros];
-  const { tokens: tokens2 } = tokenizeMarkupTolerant(source);
   return [...passagePiecesOf(source, tokens2, parameterLookup(all), { isBlock: blockLookup(all) })];
 }
 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 +9478,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, VOID_ELEMENTS, DEFAULT_PRETTIER_OPTIONS, SVG_PLACEHOLDERS, SPINDLE_PLACEHOLDERS, DEFAULT_DEDENTING, WHITESPACE_AS_WRITTEN, LIST_ITEM_REGEX, CODE_FENCE_REGEX, NOT_MARKUP_TAGS;
 var init_story_variables = __esm({
   "node_modules/@rohal12/spindle/dist/pkg/story-variables.js"() {
     SIGIL_SCOPES = {
@@ -8891,6 +9646,9 @@ var init_story_variables = __esm({
       delete(name) {
         this.names.delete(name);
       }
+      clear() {
+        this.names.clear();
+      }
     };
     BLOCK_MACROS = new NameSet([
       "if",
@@ -8908,6 +9666,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 +10844,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 +11774,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 +11852,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 +11971,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 +12133,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 +13793,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 +14785,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 +14813,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
@@ -14106,28 +14865,7 @@ var init_story_variables = __esm({
     NON_STRING_QUOTE_PREFIX = /[\p{L}\p{N}_\\]/u;
     memoInput = "";
     memo = /* @__PURE__ */ new Map();
-    defaultCodeEnd = {
-      closeBrace(input, codeStart, lenientStart) {
-        const end = findCodeEnd(input, codeStart);
-        return end !== -1 ? end : lenientClose(input, lenientStart);
-      },
-      rawBodyEnd(input, bodyStart, name) {
-        const closer = `\\{/${name}\\s*\\}`;
-        const first = new RegExp(closer, "gi");
-        first.lastIndex = bodyStart;
-        const firstAt = first.exec(input)?.index ?? -1;
-        if (firstAt === -1) return -1;
-        const at3 = new RegExp(closer, "iy");
-        const end = findCodeEnd(input, bodyStart, {
-          goal: "statements",
-          stop: (k2) => {
-            at3.lastIndex = k2;
-            return at3.test(input);
-          }
-        });
-        return end === -1 ? firstAt : end;
-      }
-    };
+    defaultCodeEnd = jsCodeEnd();
     defaultHooks = {
       ...defaultCodeEnd,
       isBlock: isBlockMacro,
@@ -14163,28 +14901,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 +14926,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 +14981,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 +15008,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 +15068,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 +15080,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 +15110,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 +15252,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 +15310,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 +15355,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 +15917,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;
@@ -14707,6 +15967,35 @@ var init_story_variables = __esm({
     booleanOf = (d) => d?.type === "boolean" ? d.value : void 0;
     textOf = (d) => stringOf(d)?.value;
     stringsOf = (d) => d?.type === "array" ? d.items.flatMap((item) => stringOf(item)?.value ?? []) : [];
+    VOID_ELEMENTS = /* @__PURE__ */ new Set([
+      "area",
+      "base",
+      "br",
+      "col",
+      "embed",
+      "hr",
+      "img",
+      "input",
+      "link",
+      "meta",
+      "param",
+      "source",
+      "track",
+      "wbr"
+    ]);
+    DEFAULT_PRETTIER_OPTIONS = { tabWidth: 2 };
+    SVG_PLACEHOLDERS = (i2) => [`<!--SVG:${i2}-->`];
+    SPINDLE_PLACEHOLDERS = (i2) => [`<!--SP:${i2}-->`, `__SP${i2}__`];
+    DEFAULT_DEDENTING = /* @__PURE__ */ new Set([
+      "else",
+      "elseif",
+      "next",
+      "case",
+      "default"
+    ]);
+    WHITESPACE_AS_WRITTEN = /<(?:pre|textarea)[\s>]|white-space\s*:/i;
+    LIST_ITEM_REGEX = /^(?:[-+*]|\d{1,9}[.)])(?:[ \t]|$)/;
+    CODE_FENCE_REGEX = /^(?:`{3,}|~{3,})/;
     NOT_MARKUP_TAGS = ["script", "stylesheet"];
   }
 });
@@ -14956,48 +16245,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 +16320,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 +16353,7 @@ var init_macro_registry = __esm({
         "name": "nobr",
         "block": true,
         "subMacros": [],
+        "interpolate": true,
         "source": "builtin"
       },
       {
@@ -15088,6 +16388,7 @@ var init_macro_registry = __esm({
         "block": false,
         "subMacros": [],
         "storeVar": true,
+        "interpolate": true,
         "parameters": [
           {
             "name": "variable",
@@ -15107,6 +16408,7 @@ var init_macro_registry = __esm({
         "block": false,
         "subMacros": [],
         "storeVar": true,
+        "interpolate": true,
         "parameters": [
           {
             "name": "variable",
@@ -15126,6 +16428,7 @@ var init_macro_registry = __esm({
         "block": false,
         "subMacros": [],
         "storeVar": true,
+        "interpolate": true,
         "parameters": [
           {
             "name": "variable",
@@ -15145,6 +16448,7 @@ var init_macro_registry = __esm({
         "block": false,
         "subMacros": [],
         "storeVar": true,
+        "interpolate": true,
         "parameters": [
           {
             "name": "variable",
@@ -15164,6 +16468,7 @@ var init_macro_registry = __esm({
         "block": false,
         "subMacros": [],
         "storeVar": true,
+        "interpolate": true,
         "parameters": [
           {
             "name": "variable",
@@ -15191,6 +16496,7 @@ var init_macro_registry = __esm({
           "option"
         ],
         "storeVar": true,
+        "interpolate": true,
         "parameters": [
           {
             "name": "variable",
@@ -15205,6 +16511,7 @@ var init_macro_registry = __esm({
         "block": true,
         "subMacros": [],
         "storeVar": true,
+        "interpolate": true,
         "parameters": [
           {
             "name": "variable",
@@ -15218,6 +16525,7 @@ var init_macro_registry = __esm({
         "name": "span",
         "block": true,
         "subMacros": [],
+        "interpolate": true,
         "source": "builtin"
       },
       {
@@ -23929,7 +25237,7 @@ var MINIMUM_SPINDLE_VERSION, DEFAULT_TARGET;
 var init_spindle_version = __esm({
   "src/core/workspace/spindle-version.ts"() {
     "use strict";
-    MINIMUM_SPINDLE_VERSION = "0.59.20";
+    MINIMUM_SPINDLE_VERSION = "0.60.0";
     DEFAULT_TARGET = { version: void 0, source: "default", supported: true };
   }
 });
@@ -26955,322 +28263,31 @@ function headerTags(header) {
   const unescaped = header.replace(/\\./g, "ec");
   return (unescaped.match(/\[[^\]]*\]/g) ?? []).flatMap((t) => t.slice(1, -1).split(/\s+/));
 }
-function segmentRegions(body) {
-  const lines = body.split("\n");
-  if (lines.length > 0 && lines[lines.length - 1] === "") {
-    lines.pop();
-  }
-  if (lines.length === 0) return [];
-  const regions = [];
-  let i2 = 0;
-  while (i2 < lines.length) {
-    const line = lines[i2];
-    const trimmed2 = line.trim();
-    if (/^<script(\s|>)/i.test(trimmed2)) {
-      const scriptLines = [line];
-      i2++;
-      if (/<\/script\s*>/i.test(line)) {
-        regions.push({ type: "script", lines: scriptLines });
-        continue;
-      }
-      while (i2 < lines.length && !/<\/script>/i.test(lines[i2])) {
-        scriptLines.push(lines[i2]);
-        i2++;
-      }
-      if (i2 < lines.length) {
-        scriptLines.push(lines[i2]);
-        i2++;
-      }
-      regions.push({ type: "script", lines: scriptLines });
-      continue;
-    }
-    if (/^<svg(\s|>)/i.test(trimmed2)) {
-      const svgLines = [line];
-      i2++;
-      while (i2 < lines.length && !/<\/svg>/i.test(lines[i2])) {
-        svgLines.push(lines[i2]);
-        i2++;
-      }
-      if (i2 < lines.length) {
-        svgLines.push(lines[i2]);
-        i2++;
-      }
-      regions.push({ type: "svg", lines: svgLines });
-      continue;
-    }
-    if (/^<([a-zA-Z][\w-]*)/.test(trimmed2)) {
-      const tagMatch = trimmed2.match(/^<([a-zA-Z][\w-]*)/);
-      const tagName = tagMatch[1].toLowerCase();
-      if (VOID_ELEMENTS.has(tagName) && !lines[i2 + 1]?.trim().startsWith("<")) {
-        pushSpindleLine(regions, line);
-        i2++;
-        continue;
-      }
-      const selfClosing = new RegExp(`</${tagName}\\s*>`, "i");
-      if (selfClosing.test(trimmed2)) {
-        pushSpindleLine(regions, line);
-        i2++;
-        continue;
-      }
-      const htmlLines = [line];
-      let depth = 1;
-      i2++;
-      while (i2 < lines.length && depth > 0) {
-        htmlLines.push(lines[i2]);
-        const opens = (lines[i2].match(new RegExp(`<${tagName}(?:[\\s>]|$)`, "gi")) ?? []).length;
-        const closes2 = (lines[i2].match(new RegExp(`</${tagName}\\s*>`, "gi")) ?? []).length;
-        depth += opens - closes2;
-        i2++;
-      }
-      regions.push({ type: "html", lines: htmlLines });
-      continue;
-    }
-    pushSpindleLine(regions, line);
-    i2++;
-  }
-  return regions;
-}
-function pushSpindleLine(regions, line) {
-  const last2 = regions[regions.length - 1];
-  if (last2?.type === "spindle") {
-    last2.lines.push(line);
-  } else {
-    regions.push({ type: "spindle", lines: [line] });
-  }
-}
-var PASSAGE_HEADER_REGEX, VOID_ELEMENTS;
+var PASSAGE_HEADER_REGEX;
 var init_segment = __esm({
   "src/plugins/format/segment.ts"() {
     "use strict";
     init_passage_parser();
     PASSAGE_HEADER_REGEX = /^::\s+/;
-    VOID_ELEMENTS = /* @__PURE__ */ new Set([
-      "area",
-      "base",
-      "br",
-      "col",
-      "embed",
-      "hr",
-      "img",
-      "input",
-      "link",
-      "meta",
-      "param",
-      "source",
-      "track",
-      "wbr"
-    ]);
   }
 });
 
 // src/plugins/format/prettier-bridge.ts
 async function loadPrettier() {
-  if (prettierLoaded) return prettier;
-  prettierLoaded = true;
-  try {
-    prettier = await import("prettier");
-  } catch {
-    prettier = null;
-  }
-  return prettier;
-}
-async function getBaseConfig() {
-  const p = await loadPrettier();
-  if (!p) return {};
+  prettier ??= import("prettier").catch(() => null);
+  const p = await prettier;
+  if (!p) return void 0;
   try {
     const resolved = await p.resolveConfig(process.cwd());
-    return { tabWidth: 2, ...resolved ?? {} };
-  } catch {
-    return { tabWidth: 2 };
-  }
-}
-async function formatJS(code) {
-  const p = await loadPrettier();
-  if (!p) return code;
-  try {
-    const config2 = await getBaseConfig();
-    return await p.format(code, { ...config2, parser: "babel" });
-  } catch {
-    return code;
-  }
-}
-async function formatCSS(code) {
-  const p = await loadPrettier();
-  if (!p) return code;
-  try {
-    const config2 = await getBaseConfig();
-    return await p.format(code, { ...config2, parser: "css" });
-  } catch {
-    return code;
-  }
-}
-async function formatHTML(code) {
-  const p = await loadPrettier();
-  if (!p) return code;
-  try {
-    const config2 = await getBaseConfig();
-    return await p.format(code, {
-      ...config2,
-      parser: "html",
-      htmlWhitespaceSensitivity: "ignore"
-    });
+    return { prettier: p, options: { tabWidth: 2, ...resolved ?? {} } };
   } catch {
-    return code;
+    return { prettier: p, options: { tabWidth: 2 } };
   }
 }
-var prettier, prettierLoaded;
+var prettier;
 var init_prettier_bridge = __esm({
   "src/plugins/format/prettier-bridge.ts"() {
     "use strict";
-    prettier = null;
-    prettierLoaded = false;
-  }
-});
-
-// src/plugins/format/placeholders.ts
-function scanSpindleMarkup(text2) {
-  const tokens2 = [];
-  const tags = [];
-  const doBlocks = [];
-  let open;
-  const push = (t, inAttribute) => {
-    const match = { start: t.start, end: t.end, token: text2.slice(t.start, t.end) };
-    if (inAttribute) match.inAttribute = true;
-    tokens2.push(match);
-  };
-  for (const t of tokenizeMarkupTolerant(text2).tokens) {
-    if (t.type === "html") {
-      tags.push({ start: t.start, end: t.end });
-      for (const attribute of t.attributeSpans) {
-        if (attribute.valueStart === void 0 || attribute.valueEnd === void 0) continue;
-        const value = text2.slice(attribute.valueStart, attribute.valueEnd);
-        if (!value.includes("{")) continue;
-        for (const inner of tokenizeMarkupTolerant(value, { text: true }).tokens) {
-          if (inner.type === "macro" || inner.type === "variable" || inner.type === "expression") {
-            push({ start: attribute.valueStart + inner.start, end: attribute.valueStart + inner.end }, true);
-          }
-        }
-      }
-    } else if (t.type !== "text") {
-      if (t.type === "macro" && t.name === "do") {
-        if (!t.isClose) open = t;
-        else if (open) {
-          doBlocks.push({ start: open.start, end: t.end, bodyStart: open.end, bodyEnd: t.start });
-          open = void 0;
-        }
-      }
-      push(t);
-    }
-  }
-  return { tokens: tokens2, tags, doBlocks };
-}
-function multilineJsLiterals(code) {
-  const spans = [];
-  let skipUntil = 0;
-  lexJs(code, {
-    literal(text2, index, nesting) {
-      if (nesting > 0 || index < skipUntil) return;
-      const quote = text2[0];
-      if (quote === "`") {
-        skipUntil = lexTemplate(code, index);
-        if (code.slice(index, skipUntil).includes("\n")) spans.push([index, skipUntil]);
-      } else if ((quote === '"' || quote === "'") && text2.includes("\n")) {
-        spans.push([index, index + text2.length]);
-      }
-    }
-  }, "statements");
-  return spans;
-}
-function lineHasTag(tags, start, end) {
-  return tags.some((tag) => tag.start < end && tag.end > start);
-}
-function replaceSvgBlocks(html) {
-  const tokens2 = [];
-  const result = html.replace(/<svg[\s>][\s\S]*?<\/svg>/gi, (match) => {
-    const idx = tokens2.length;
-    tokens2.push(match);
-    return `<!--SVG:${idx}-->`;
-  });
-  return { text: result, tokens: tokens2 };
-}
-function restoreSvgBlocks(text2, tokens2) {
-  let result = text2;
-  for (let i2 = 0; i2 < tokens2.length; i2++) {
-    result = result.replace(`<!--SVG:${i2}-->`, () => tokens2[i2]);
-  }
-  return result;
-}
-function replaceSpindleTokens(html) {
-  const { tokens: found, tags, doBlocks } = scanSpindleMarkup(html);
-  const units = [];
-  let doIndex = 0;
-  for (const m of found) {
-    while (doIndex < doBlocks.length && doBlocks[doIndex].end <= m.start) {
-      const block = doBlocks[doIndex++];
-      units.push({ start: block.start, end: block.end, token: html.slice(block.start, block.end) });
-    }
-    if (doBlocks[doIndex] && m.start >= doBlocks[doIndex].start) continue;
-    units.push(m);
-  }
-  for (; doIndex < doBlocks.length; doIndex++) {
-    const block = doBlocks[doIndex];
-    units.push({ start: block.start, end: block.end, token: html.slice(block.start, block.end) });
-  }
-  units.sort((a, b) => a.start - b.start);
-  const tokens2 = [];
-  const resultLines = [];
-  let unit = 0;
-  let lineStart = 0;
-  while (lineStart <= html.length) {
-    let lineEnd = lineStart;
-    const lineUnits = [];
-    for (; ; ) {
-      while (unit < units.length && units[unit].end <= lineEnd) unit++;
-      const inside = units[unit] && units[unit].start <= lineEnd ? units[unit] : void 0;
-      if (inside) {
-        lineUnits.push(inside);
-        lineEnd = inside.end;
-        unit++;
-        continue;
-      }
-      if (lineEnd >= html.length || html[lineEnd] === "\n") break;
-      lineEnd++;
-    }
-    const line = html.slice(lineStart, lineEnd);
-    const indent = line.match(/^(\s*)/)?.[1] ?? "";
-    if (lineUnits.length === 0) {
-      resultLines.push(line);
-    } else if (!lineHasTag(tags, lineStart, lineEnd)) {
-      const idx = tokens2.length;
-      tokens2.push(line.trim());
-      resultLines.push(`${indent}<!--SP:${idx}-->`);
-    } else {
-      let replaced = "";
-      let last2 = lineStart;
-      for (const u of lineUnits) {
-        const idx = tokens2.length;
-        tokens2.push(u.token);
-        replaced += html.slice(last2, u.start) + (u.inAttribute ? `__SP${idx}__` : `<!--SP:${idx}-->`);
-        last2 = u.end;
-      }
-      resultLines.push(replaced + html.slice(last2, lineEnd));
-    }
-    lineStart = lineEnd + 1;
-  }
-  return { text: resultLines.join("\n"), tokens: tokens2 };
-}
-function restoreSpindleTokens(text2, tokens2) {
-  let result = text2;
-  for (let i2 = 0; i2 < tokens2.length; i2++) {
-    result = result.replace(`<!--SP:${i2}-->`, () => tokens2[i2]);
-    result = result.replace(`__SP${i2}__`, () => tokens2[i2]);
-  }
-  return result;
-}
-var init_placeholders = __esm({
-  "src/plugins/format/placeholders.ts"() {
-    "use strict";
-    init_tooling();
   }
 });
 
@@ -27288,50 +28305,22 @@ function buildDefaultIsBlock(text2) {
 }
 async function formatDocument(text2, options) {
   if (text2.charCodeAt(0) === 65279) return "\uFEFF" + await formatDocument(text2.slice(1), options);
-  const eol = dominantEol(text2);
-  const output = await formatLf(text2.replace(/\r\n/g, "\n"), options);
+  const eol = dominantEol2(text2);
+  const output = await formatLf2(text2.replace(/\r\n/g, "\n"), options);
   return eol === "\r\n" ? output.replace(/\n/g, "\r\n") : output;
 }
-function dominantEol(text2) {
+function dominantEol2(text2) {
   const crlf = (text2.match(/\r\n/g) ?? []).length;
   const lf = (text2.match(/\n/g) ?? []).length - crlf;
   if (crlf !== lf) return crlf > lf ? "\r\n" : "\n";
   return text2.indexOf("\r\n") !== -1 && text2.indexOf("\r\n") < text2.indexOf("\n") ? "\r\n" : "\n";
 }
-function newlineSentinel(text2) {
-  for (let code = 57344; code <= 63743; code++) {
-    const ch = String.fromCharCode(code);
-    if (!text2.includes(ch)) return ch;
-  }
-  throw new Error("no free private-use character for the newline stand-in");
-}
-function protectMultilineTokens(body, sentinel) {
-  const { tokens: tokens2, doBlocks } = scanSpindleMarkup(body);
-  const spans = [];
-  for (const m of tokens2) {
-    if (m.token.includes("\n")) spans.push([m.start, m.end]);
-  }
-  for (const block of doBlocks) {
-    for (const [a, b] of multilineJsLiterals(body.slice(block.bodyStart, block.bodyEnd))) {
-      spans.push([block.bodyStart + a, block.bodyStart + b]);
-    }
-  }
-  spans.sort((x2, y) => x2[0] - y[0]);
-  let out = "";
-  let last2 = 0;
-  for (const [a, b] of spans) {
-    out += body.slice(last2, a) + body.slice(a, b).replaceAll("\n", sentinel);
-    last2 = b;
-  }
-  return out + body.slice(last2);
-}
-async function formatLf(text2, options) {
+async function formatLf2(text2, options) {
   const isBlock = options?.isBlock ?? buildDefaultIsBlock(text2);
-  const isDedenting = options?.isDedentingSubMacro ?? ((name) => DEFAULT_DEDENTING.has(name.toLowerCase()));
+  const isDedentingSubMacro = options?.isDedentingSubMacro ?? ((name) => DEFAULT_DEDENTING2.has(name.toLowerCase()));
+  const prettier2 = await loadPrettier();
   const passages = splitPassages(text2);
-  const sentinel = newlineSentinel(text2);
   const resultLines = [];
-  const hardBreakLines = /* @__PURE__ */ new Set();
   for (let pi2 = 0; pi2 < passages.length; pi2++) {
     const passage = passages[pi2];
     if (pi2 > 0 && passage.header) {
@@ -27344,226 +28333,24 @@ async function formatLf(text2, options) {
     }
     if (passage.header) {
       const header = PASSAGE_HEADER_REGEX2.test(passage.header) ? normalizePassageHeader(passage.header) : passage.header;
-      resultLines.push(header);
-    }
-    const kind = classifyPassage(passage.header);
-    if (kind === "script") {
-      const formatted = await formatJS(passage.body.trim());
-      resultLines.push(formatted.trim());
-      continue;
-    }
-    if (kind === "stylesheet") {
-      const formatted = await formatCSS(passage.body.trim());
-      resultLines.push(formatted.trim());
-      continue;
-    }
-    const regions = segmentRegions(protectMultilineTokens(passage.body, sentinel));
-    for (const region of regions) {
-      if (region.type !== "spindle") {
-        region.lines = region.lines.map((l) => l.replaceAll(sentinel, "\n"));
-      }
-      if (region.type === "script") {
-        if (region.lines.length === 1) {
-          resultLines.push(region.lines[0]);
-          continue;
-        }
-        const firstLine = region.lines[0];
-        const lastLine = region.lines[region.lines.length - 1];
-        const innerLines = region.lines.slice(1, region.lines.length - 1);
-        const innerCode = innerLines.join("\n");
-        const formatted = await formatJS(innerCode.trim());
-        resultLines.push(firstLine);
-        if (formatted.trim()) {
-          for (const fLine of formatted.trim().split("\n")) {
-            resultLines.push("  " + fLine);
-          }
-        }
-        resultLines.push(lastLine);
-        continue;
-      }
-      if (region.type === "svg") {
-        resultLines.push(...region.lines);
-        continue;
-      }
-      if (region.type === "html") {
-        const htmlText = region.lines.join("\n");
-        const { text: svgPlaceholdered, tokens: svgTokens } = replaceSvgBlocks(htmlText);
-        const { text: placeholdered, tokens: tokens2 } = replaceSpindleTokens(svgPlaceholdered);
-        const formatted = await formatHTML(placeholdered);
-        const restoredSpindle = restoreSpindleTokens(formatted.trim(), tokens2.map((t) => t.replaceAll("\n", sentinel)));
-        const restored = restoreSvgBlocks(restoredSpindle, svgTokens);
-        for (const fLine of restored.split("\n")) {
-          resultLines.push(fLine);
-        }
-        continue;
-      }
-      let indented = indentMacros(region.lines, isBlock, isDedenting);
-      if (options?.maxLineLength) {
-        indented = wrapLines(indented, options.maxLineLength);
-      }
-      for (const line of indented) {
-        if (line.endsWith("  ")) hardBreakLines.add(resultLines.length);
-        resultLines.push(line);
-      }
-    }
-  }
-  let output = resultLines.map((l, i2) => hardBreakLines.has(i2) ? l : l.replace(/\s+$/, "")).join("\n");
-  output = output.replace(/\n*$/, "\n");
-  return output.replaceAll(sentinel, "\n");
-}
-function indentMacros(lines, isBlock, isDedenting) {
-  const macrosOnLine = macroTokensByLine(lines);
-  const bodies = [{ openLine: -1, minCol: Infinity, keepRelative: false }];
-  const stack = [0];
-  const info = [];
-  const openBody = (line) => {
-    bodies.push({ openLine: line, minCol: Infinity, keepRelative: false });
-    stack.push(bodies.length - 1);
-  };
-  const closeBody = () => stack.length > 1 ? stack.pop() : void 0;
-  const addLine = (col, text2) => {
-    const body = bodies[stack[stack.length - 1]];
-    body.minCol = Math.min(body.minCol, col);
-    if (LIST_ITEM_REGEX.test(text2) || CODE_FENCE_REGEX.test(text2)) body.keepRelative = true;
-    info.push({ body: stack[stack.length - 1], col, text: text2 });
-  };
-  for (let i2 = 0; i2 < lines.length; i2++) {
-    const trimmed2 = lines[i2].trim();
-    if (trimmed2 === "") {
-      info.push(null);
-      continue;
-    }
-    const col = indentColumn(lines[i2]);
-    const lead = lines[i2].length - lines[i2].trimStart().length;
-    const [first, ...rest] = macrosOnLine[i2];
-    const startsWithMacro = first !== void 0 && first.start === lead;
-    if (startsWithMacro && !first.isClose && isDedenting(first.name)) {
-      const closed2 = closeBody();
-      if (closed2 === void 0) addLine(col, trimmed2);
-      else info.push({ body: stack[stack.length - 1], closes: closed2, col, text: trimmed2 });
-      openBody(i2);
-      continue;
-    }
-    const closed = startsWithMacro && first.isClose ? closeBody() : void 0;
-    if (closed === void 0) addLine(col, trimmed2);
-    else info.push({ body: stack[stack.length - 1], closes: closed, col, text: trimmed2 });
-    if (startsWithMacro && !first.isClose && isBlock(first.name)) {
-      openBody(i2);
-    }
-    for (const macro of startsWithMacro ? rest : macrosOnLine[i2]) {
-      if (macro.isClose && macro.start > lead) closeBody();
-    }
-  }
-  const outCol = [];
-  const result = [];
-  for (let i2 = 0; i2 < info.length; i2++) {
-    const line = info[i2];
-    if (!line) {
-      outCol.push(0);
-      result.push("");
-      continue;
-    }
-    let col;
-    if (line.closes !== void 0) {
-      col = outCol[bodies[line.closes].openLine];
-    } else {
-      const body = bodies[line.body];
-      const isRoot = body.openLine === -1;
-      const base = isRoot ? 0 : outCol[body.openLine] + 2;
-      col = base + (body.keepRelative ? line.col - (isRoot ? 0 : body.minCol) : 0);
-    }
-    outCol.push(col);
-    const hardBreak = / {2,}$/.test(lines[i2]) && info[i2 + 1] ? "  " : "";
-    result.push(" ".repeat(col) + line.text + hardBreak);
-  }
-  return result;
-}
-function macroTokensByLine(lines) {
-  const byLine = lines.map(() => []);
-  const starts = [];
-  let offset2 = 0;
-  for (const line2 of lines) {
-    starts.push(offset2);
-    offset2 += line2.length + 1;
-  }
-  let line = 0;
-  for (const token of tokenizeMarkupTolerant(lines.join("\n")).tokens) {
-    if (token.type !== "macro") continue;
-    while (line + 1 < lines.length && starts[line + 1] <= token.start) line++;
-    byLine[line].push({ ...token, start: token.start - starts[line], end: token.end - starts[line] });
-  }
-  return byLine;
-}
-function indentColumn(line) {
-  let col = 0;
-  for (const ch of line) {
-    if (ch === " ") col++;
-    else if (ch === "	") col += 4 - col % 4;
-    else break;
+      resultLines.push(header.replace(/\s+$/, ""));
+    }
+    if (passage.body === "") continue;
+    const body = await formatPassage(passage.body, {
+      kind: classifyPassage(passage.header),
+      prettier: prettier2?.prettier,
+      prettierOptions: prettier2?.options,
+      isBlock,
+      isDedentingSubMacro,
+      maxLineLength: options?.maxLineLength
+    });
+    resultLines.push(body.replace(/\n$/, ""));
   }
-  return col;
+  return resultLines.join("\n").replace(/\n*$/, "\n");
 }
 async function formatRange(text2, _range, options) {
   return formatDocument(text2, options);
 }
-function wrapLines(lines, maxLen) {
-  const result = [];
-  for (const line of lines) {
-    if (line.length <= maxLen) {
-      result.push(line);
-      continue;
-    }
-    const trimmed2 = line.trim();
-    if (trimmed2 === "" || /^::/.test(trimmed2) || /^\{[\/#.]/.test(trimmed2) || // closing/opening-only macro lines
-    /^\[\[/.test(trimmed2) || // links
-    /^\{choice\b/.test(trimmed2) || // choice macros
-    /^\{choices\b/.test(trimmed2)) {
-      result.push(line);
-      continue;
-    }
-    const indentMatch = line.match(/^(\s*)/);
-    const indent = indentMatch ? indentMatch[1] : "";
-    const wrapped = wordWrap(trimmed2, maxLen, indent);
-    if (line.endsWith("  ")) wrapped[wrapped.length - 1] += "  ";
-    result.push(...wrapped);
-  }
-  return result;
-}
-function wordWrap(text2, maxLen, indent) {
-  const lines = [];
-  const inToken = new Array(text2.length).fill(false);
-  for (const token of tokenizeMarkupTolerant(text2).tokens) {
-    if (token.type === "text" || token.type === "html") continue;
-    inToken.fill(true, token.start, token.end);
-  }
-  const room = maxLen - indent.length;
-  let pos = 0;
-  while (pos < text2.length) {
-    if (text2.length - pos <= room) {
-      lines.push(indent + text2.slice(pos));
-      break;
-    }
-    let breakIdx = -1;
-    for (let i2 = pos + 1; i2 < text2.length && i2 - pos <= room; i2++) {
-      if (text2[i2] === " " && !inToken[i2]) breakIdx = i2;
-    }
-    if (breakIdx === -1) {
-      for (let i2 = pos + room + 1; i2 < text2.length; i2++) {
-        if (text2[i2] === " " && !inToken[i2]) {
-          breakIdx = i2;
-          break;
-        }
-      }
-    }
-    if (breakIdx === -1) {
-      lines.push(indent + text2.slice(pos));
-      break;
-    }
-    lines.push(indent + text2.slice(pos, breakIdx));
-    pos = breakIdx + 1;
-  }
-  return lines;
-}
 function normalizePassageHeader(line) {
   const headerMatch = line.match(/^::\s+(.*)/);
   if (!headerMatch) return line;
@@ -27584,19 +28371,16 @@ function normalizePassageHeader(line) {
   }
   return `:: ${name}${suffix}`;
 }
-var PASSAGE_HEADER_REGEX2, DEFAULT_DEDENTING, BUILTIN_CONTAINERS, LIST_ITEM_REGEX, CODE_FENCE_REGEX, formatPlugin;
+var PASSAGE_HEADER_REGEX2, DEFAULT_DEDENTING2, BUILTIN_CONTAINERS, formatPlugin;
 var init_format = __esm({
   "src/plugins/format.ts"() {
     "use strict";
     init_tooling();
     init_segment();
     init_prettier_bridge();
-    init_placeholders();
     PASSAGE_HEADER_REGEX2 = /^(::)\s+/;
-    DEFAULT_DEDENTING = /* @__PURE__ */ new Set(["else", "elseif", "next", "case", "default"]);
+    DEFAULT_DEDENTING2 = /* @__PURE__ */ new Set(["else", "elseif", "next", "case", "default"]);
     BUILTIN_CONTAINERS = new Set(builtinMacros.filter((m) => m.block).map((m) => m.name.toLowerCase()));
-    LIST_ITEM_REGEX = /^(?:[-+*]|\d{1,9}[.)])(?:[ \t]|$)/;
-    CODE_FENCE_REGEX = /^(?:`{3,}|~{3,})/;
     formatPlugin = {
       id: "format",
       capabilities: {
@@ -27607,7 +28391,7 @@ var init_format = __esm({
         const formatOpts = {
           // Block widgets (whose body renders {@children}) are containers too
           isBlock: (name) => ctx.workspace.isContainer(name),
-          isDedentingSubMacro: (name) => DEFAULT_DEDENTING.has(name.toLowerCase())
+          isDedentingSubMacro: (name) => DEFAULT_DEDENTING2.has(name.toLowerCase())
         };
         ctx.connection.onDocumentFormatting(async (params) => {
           const text2 = ctx.workspace.documents.getText(params.textDocument.uri);
@@ -71918,7 +72702,7 @@ var init_server4 = __esm({
 
 // src/bin.ts
 var args = process.argv.slice(2);
-var VERSION = "0.13.2";
+var VERSION = "0.14.0";
 var HELP = `spindle-lsp v${VERSION}
 Language Server Protocol server for Spindle story format