parseman 0.11.0 → 0.12.0

package/dist/plugin/index.cjs

@@ -813,12 +813,15 @@ function scanFastWsCommentsChunks(input, cur, wsKind, commentKind) {
       continue;
     }
     if (c === 47 && input.charCodeAt(pos + 1) === 42) {
-      const start = pos;
       let j = pos + 2;
       while (j + 1 < input.length && !(input.charCodeAt(j) === 42 && input.charCodeAt(j + 1) === 47)) j++;
-      pos = j + 2 <= input.length ? j + 2 : input.length;
-      chunks.push({ start, end: pos, kindIndex: commentKind });
-      continue;
+      if (j + 1 < input.length && input.charCodeAt(j) === 42 && input.charCodeAt(j + 1) === 47) {
+        const start = pos;
+        pos = j + 2;
+        chunks.push({ start, end: pos, kindIndex: commentKind });
+        continue;
+      }
+      break;
     }
     break;
   }
@@ -1315,38 +1318,108 @@ function noTrivia(root) {
   return parser({ trivia: null }, root);
 }
 
+// src/combinators/expect.ts
+function staticExpected(c) {
+  const def = c._def;
+  switch (def.tag) {
+    case "literal":
+      return [JSON.stringify(def.value)];
+    case "regex":
+      return [`/${def.source}/`];
+    case "keywords":
+      return def.words.map((w) => JSON.stringify(w));
+    case "label":
+      return [def.label];
+    case "choice":
+      return def.parsers.flatMap(staticExpected);
+    case "sequence":
+      return def.parsers.length > 0 ? staticExpected(def.parsers[0]) : [];
+    case "node":
+    case "grammar":
+    case "trivia":
+    case "optional":
+    case "many":
+    case "oneOrMore":
+    case "transform":
+    case "not":
+      return staticExpected(def.parser);
+    case "lazy":
+      return staticExpected(def.thunk());
+    default:
+      return [];
+  }
+}
+function expect(combinator, label2) {
+  const expected = label2 !== void 0 ? [label2] : staticExpected(combinator);
+  const meta = {
+    firstSet: combinator._meta.firstSet,
+    canMatchNewline: combinator._meta.canMatchNewline,
+    isTrivia: false
+  };
+  return {
+    _tag: "expect",
+    _meta: meta,
+    _def: { tag: "expect", parser: combinator, label: label2, expected },
+    parse(input, pos, ctx) {
+      const result = combinator.parse(input, pos, ctx);
+      if (result.ok) return result;
+      const error = { _tag: "parseError", span: { start: pos, end: pos }, expected };
+      ctx._errors?.push(error);
+      return { ok: true, value: error, span: { start: pos, end: pos } };
+    }
+  };
+}
+
 // src/compiler/scannable-run.ts
+var BACKSLASH = 92;
 var CLASS_ESCAPES = { t: 9, n: 10, r: 13, f: 12, v: 11, "0": 0 };
 var META = new Set("()[]{}*+?|^$.".split(""));
+function shorthandRanges(ch) {
+  return ch === "d" ? [[48, 57]] : [[48, 57], [65, 90], [97, 122], [95, 95]];
+}
 function parseClassRanges(body) {
   const ranges = [];
   let i = 0;
-  const readCp = () => {
+  const readAtom = () => {
     const ch = body[i];
     if (ch === void 0) return null;
     if (ch === "\\") {
       const e = body[i + 1];
       if (e === void 0) return null;
       i += 2;
-      return e in CLASS_ESCAPES ? CLASS_ESCAPES[e] : e.codePointAt(0);
+      if (e in CLASS_ESCAPES) return { cp: CLASS_ESCAPES[e] };
+      if (e === "d" || e === "w") return { set: shorthandRanges(e) };
+      if (e >= "a" && e <= "z" || e >= "A" && e <= "Z") return null;
+      return { cp: e.codePointAt(0) };
     }
     i += ch.length;
-    return ch.codePointAt(0);
+    return { cp: ch.codePointAt(0) };
   };
   while (i < body.length) {
-    const lo = readCp();
+    const lo = readAtom();
     if (lo === null) return null;
+    if ("set" in lo) {
+      ranges.push(...lo.set);
+      continue;
+    }
     if (body[i] === "-" && body[i + 1] !== void 0 && body[i + 1] !== "]") {
       i += 1;
-      const hi = readCp();
-      if (hi === null) return null;
-      ranges.push([lo, hi]);
+      const hi = readAtom();
+      if (hi === null || "set" in hi) return null;
+      ranges.push([lo.cp, hi.cp]);
     } else {
-      ranges.push([lo, lo]);
+      ranges.push([lo.cp, lo.cp]);
     }
   }
   return ranges.length ? ranges : null;
 }
+function classToRanges(cls) {
+  if (cls === "\\d") return shorthandRanges("d");
+  if (cls === "\\w") return shorthandRanges("w");
+  const body = cls.slice(1, -1);
+  if (body.startsWith("^")) return null;
+  return parseClassRanges(body);
+}
 function literalCodePoints(frag) {
   const out = [];
   let i = 0;
@@ -1365,13 +1438,53 @@ function literalCodePoints(frag) {
   }
   return out.length ? out : null;
 }
+function parseStringShape(source) {
+  const q = source[0];
+  if (q === void 0 || q === "\\" || META.has(q)) return null;
+  if (source.length < 3 || source[source.length - 1] !== q) return null;
+  const inner = source.slice(1, -1);
+  const CLS = String.raw`\[\^((?:\\.|[^\]])+)\]`;
+  const ESC = String.raw`\\\\(\.|\[\\s\\S\]|\[\\S\\s\])`;
+  let body;
+  let esc;
+  let m = new RegExp(`^\\((?:\\?:)?${CLS}\\|${ESC}\\)\\*$`).exec(inner);
+  if (m) {
+    body = m[1];
+    esc = m[2];
+  } else {
+    m = new RegExp(`^\\((?:\\?:)?${ESC}\\|${CLS}\\)\\*$`).exec(inner);
+    if (m) {
+      esc = m[1];
+      body = m[2];
+    }
+  }
+  if (body === void 0 || esc === void 0) return null;
+  const excluded = parseClassRanges(body);
+  if (!excluded) return null;
+  const qcp = q.codePointAt(0);
+  const inSet = (cp) => excluded.some(([lo, hi]) => cp >= lo && cp <= hi);
+  if (!inSet(qcp) || !inSet(BACKSLASH)) return null;
+  return { kind: "string", quote: qcp, excluded, escLineTerm: esc !== "." };
+}
 function parseScanShape(source) {
   let m = /^\[((?:\\.|[^\]])+)\]([+*])$/.exec(source);
   if (m) {
     if (m[1].startsWith("^")) return null;
     const ranges = parseClassRanges(m[1]);
-    return ranges ? { kind: "chars", ranges } : null;
+    return ranges ? { kind: "chars", ranges, minOne: m[2] === "+" } : null;
+  }
+  m = /^\\([dw])([+*])$/.exec(source);
+  if (m) {
+    return { kind: "chars", ranges: shorthandRanges(m[1]), minOne: m[2] === "+" };
   }
+  m = /^(\[(?:\\.|[^\]])+\]|\\[dw])(\[(?:\\.|[^\]])+\]|\\[dw])\*$/.exec(source);
+  if (m) {
+    const head = classToRanges(m[1]);
+    const tail = classToRanges(m[2]);
+    return head && tail ? { kind: "ident", head, tail } : null;
+  }
+  const str = parseStringShape(source);
+  if (str) return str;
   m = /^(.*?)\[\^((?:\\.|[^\]])+)\]\*$/.exec(source);
   if (m) {
     const open = literalCodePoints(m[1]);
@@ -1389,66 +1502,147 @@ function parseScanShape(source) {
   }
   return null;
 }
+function scanShapeFromRegex(source, flags) {
+  if (/[imsu]/.test(flags)) return null;
+  return parseScanShape(source);
+}
 var classCond = (cVar, ranges) => ranges.map(([lo, hi]) => lo === hi ? `${cVar} === ${lo}` : `(${cVar} >= ${lo} && ${cVar} <= ${hi})`).join(" || ");
 var litCond = (base, cps, firstVar) => cps.map(
   (cp, k) => k === 0 && firstVar ? `${firstVar} === ${cp}` : `input.charCodeAt(${base}${k ? ` + ${k}` : ""}) === ${cp}`
 ).join(" && ");
-function advanceExpr(shape) {
+var LINE_TERMINATORS = [10, 13, 8232, 8233];
+function stringHardStop(shape) {
+  return shape.excluded.filter(
+    ([lo, hi]) => !(lo === hi && (lo === shape.quote || lo === BACKSLASH))
+  );
+}
+var codeAt = (start, firstChar) => firstChar ?? `input.charCodeAt(${start})`;
+function emitShapeMatch(shape, start, mint, ind2, firstChar) {
   if (shape.kind === "chars") {
+    const cur = mint("_e");
     return {
       setup: [
-        `      _e++`,
-        `      while (_e < input.length) { const c2 = input.charCodeAt(_e); if (${classCond("c2", shape.ranges)}) _e++; else break }`
+        `${ind2}let ${cur} = ${start}`,
+        `${ind2}while (${cur} < input.length && (${classCond(`input.charCodeAt(${cur})`, shape.ranges)})) ${cur}++`
       ],
-      endVar: "_e"
+      // `*` always matches (possibly empty); `+` needs at least one char.
+      ok: shape.minOne ? `${cur} > ${start}` : "true",
+      end: cur
+    };
+  }
+  if (shape.kind === "ident") {
+    const cur = mint("_e");
+    return {
+      setup: [
+        `${ind2}let ${cur} = ${start}`,
+        `${ind2}if (${start} < input.length && (${classCond(codeAt(start, firstChar), shape.head)})) {`,
+        `${ind2}  ${cur} = ${start} + 1`,
+        `${ind2}  while (${cur} < input.length && (${classCond(`input.charCodeAt(${cur})`, shape.tail)})) ${cur}++`,
+        `${ind2}}`
+      ],
+      ok: `${cur} > ${start}`,
+      end: cur
     };
   }
   if (shape.kind === "until") {
+    const j2 = mint("_j");
+    const openLen2 = shape.open.length;
+    const openChk2 = openLen2 === 1 ? `${codeAt(start, firstChar)} === ${shape.open[0]}` : litCond(start, shape.open, firstChar);
+    return {
+      setup: [
+        `${ind2}let ${j2} = ${start}`,
+        `${ind2}if (${start} + ${openLen2} <= input.length && (${openChk2})) {`,
+        `${ind2}  ${j2} = ${start} + ${openLen2}`,
+        `${ind2}  while (${j2} < input.length && !(${classCond(`input.charCodeAt(${j2})`, shape.stop)})) ${j2}++`,
+        `${ind2}}`
+      ],
+      // An open-until-terminator always completes (stop char or EOF), so a matched
+      // open literal is a full match; `end === start` iff the open didn't match.
+      ok: `${j2} > ${start}`,
+      end: j2
+    };
+  }
+  if (shape.kind === "string") {
+    const okV = mint("_ok");
+    const endV2 = mint("_end");
+    const i = mint("_i");
+    const c2 = mint("_c");
+    const hard = stringHardStop(shape);
+    const ltLines = shape.escLineTerm ? [] : (() => {
+      const c3 = mint("_c");
+      return [
+        `${ind2}      const ${c3} = input.charCodeAt(${i} + 1)`,
+        `${ind2}      if (${LINE_TERMINATORS.map((t) => `${c3} === ${t}`).join(" || ")}) break`
+      ];
+    })();
     return {
       setup: [
-        `      let j = _e + ${shape.open.length}`,
-        `      while (j < input.length && !(${classCond("input.charCodeAt(j)", shape.stop)})) j++`
+        `${ind2}let ${okV} = false`,
+        `${ind2}let ${endV2} = ${start}`,
+        `${ind2}if (${start} < input.length && (${codeAt(start, firstChar)}) === ${shape.quote}) {`,
+        `${ind2}  let ${i} = ${start} + 1`,
+        `${ind2}  while (${i} < input.length) {`,
+        `${ind2}    const ${c2} = input.charCodeAt(${i})`,
+        `${ind2}    if (${c2} === ${shape.quote}) { ${okV} = true; ${endV2} = ${i} + 1; break }`,
+        `${ind2}    if (${c2} === ${BACKSLASH}) {`,
+        `${ind2}      if (${i} + 1 >= input.length) break`,
+        ...ltLines,
+        `${ind2}      ${i} += 2`,
+        `${ind2}      continue`,
+        `${ind2}    }`,
+        ...hard.length ? [`${ind2}    if (${classCond(c2, hard)}) break`] : [],
+        `${ind2}    ${i}++`,
+        `${ind2}  }`,
+        `${ind2}}`
       ],
-      endVar: "j"
+      ok: okV,
+      end: endV2
     };
   }
-  const n = shape.close.length;
+  const j = mint("_j");
+  const endV = mint("_end");
+  const openLen = shape.open.length;
+  const closeLen = shape.close.length;
+  const openChk = openLen === 1 ? `${codeAt(start, firstChar)} === ${shape.open[0]}` : litCond(start, shape.open, firstChar);
+  const closeChk = litCond(j, shape.close);
   return {
     setup: [
-      `      let j = _e + ${shape.open.length}`,
-      `      while (j + ${n - 1} < input.length && !(${litCond("j", shape.close)})) j++`
+      `${ind2}let ${j} = ${start}`,
+      `${ind2}let ${endV} = ${start}`,
+      `${ind2}if (${start} + ${openLen} <= input.length && (${openChk})) {`,
+      `${ind2}  ${j} = ${start} + ${openLen}`,
+      `${ind2}  while (${j} + ${closeLen - 1} < input.length && !(${closeChk})) ${j}++`,
+      `${ind2}  if (${j} + ${closeLen} <= input.length && (${closeChk})) ${endV} = ${j} + ${closeLen}`,
+      `${ind2}}`
     ],
-    endVar: n === 1 ? "(j + 1 <= input.length ? j + 1 : input.length)" : `(j + ${n} <= input.length ? j + ${n} : input.length)`
+    ok: `${endV} > ${start}`,
+    end: endV
   };
 }
-function guardLine(shape) {
-  const cond = shape.kind === "chars" ? classCond("c", shape.ranges) : litCond("_e", shape.open, "c");
-  return `    if (${cond}) {`;
-}
-function scanBranch(shape) {
-  if (shape.kind === "chars") {
-    return `    if (${classCond("c", shape.ranges)}) { _e++; continue }`;
-  }
-  const { setup, endVar } = advanceExpr(shape);
-  return [guardLine(shape), ...setup, `      _e = ${endVar}`, `      continue`, `    }`].join("\n");
+function scanBranch(shape, mint) {
+  const m = emitShapeMatch(shape, "_e", mint, "    ", "c");
+  return [...m.setup, `    if (${m.end} > _e) { _e = ${m.end}; continue }`].join("\n");
 }
-function captureChunk(startVar, kindIndex) {
+function scanBranchLabeled(shape, kindIndex, mint) {
+  const m = emitShapeMatch(shape, "_e", mint, "    ", "c");
   return [
+    ...m.setup,
+    `    if (${m.end} > _e) {`,
     `      if (_cap) {`,
-    `        if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(${startVar}, _e, ${kindIndex})`,
-    `        if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(${startVar}, _e, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0, ${kindIndex})`,
-    `      }`
-  ];
-}
-function scanBranchLabeled(shape, kindIndex) {
-  const { setup, endVar } = advanceExpr(shape);
-  const lines = [guardLine(shape), `      const _cs = _e`, ...setup];
-  if (endVar !== "_e") lines.push(`      _e = ${endVar}`);
-  lines.push(...captureChunk("_cs", kindIndex), `      continue`, `    }`);
-  return lines.join("\n");
+    `        if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_e, ${m.end}, ${kindIndex})`,
+    `        if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(_e, ${m.end}, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0, ${kindIndex})`,
+    `      }`,
+    `      _e = ${m.end}`,
+    `      continue`,
+    `    }`
+  ].join("\n");
 }
 
 // src/compiler/trivia-fast-path.ts
+function makeMint() {
+  let n = 0;
+  return (prefix = "_v") => `${prefix}${n++}`;
+}
 function unwrapTrivia2(p) {
   let cur = p;
   while (cur._def.tag === "trivia") cur = cur._def.parser;
@@ -1465,14 +1659,14 @@ function choiceArms(p) {
   return null;
 }
 function armShape(arm) {
-  const src = getCoreRegexDef(arm)?.source;
-  return src ? parseScanShape(src) : null;
+  const d = getCoreRegexDef(arm);
+  return d ? scanShapeFromRegex(d.source, d.flags) : null;
 }
 function analyzeTriviaFastPath(trivia2) {
   const core = unwrapTrivia2(trivia2);
-  const directSrc = getCoreRegexDef(core)?.source;
-  if (directSrc) {
-    const shape = parseScanShape(directSrc);
+  const directDef = getCoreRegexDef(core);
+  if (directDef) {
+    const shape = scanShapeFromRegex(directDef.source, directDef.flags);
     return shape && shape.kind === "chars" ? [shape] : null;
   }
   const inner = oneOrMoreInner(core);
@@ -1496,10 +1690,11 @@ var CAP_RECORD = [
   `  }`
 ].join("\n");
 function composeFastLoop(shapes) {
+  const mint = makeMint();
   return [
     `  while (_e < input.length) {`,
     `    const c = input.charCodeAt(_e)`,
-    ...shapes.map(scanBranch),
+    ...shapes.map((s) => scanBranch(s, mint)),
     `    break`,
     `  }`
   ].join("\n");
@@ -1519,20 +1714,21 @@ function analyzeLabeledScannableRun(trivia2) {
   if (!spec) return null;
   const out = [];
   for (const arm of spec.arms) {
-    const src = getCoreRegexDef(arm.parser)?.source;
-    const shape = src ? parseScanShape(src) : null;
+    const d = getCoreRegexDef(arm.parser);
+    const shape = d ? scanShapeFromRegex(d.source, d.flags) : null;
     if (!shape) return null;
     out.push({ shape, kindIndex: arm.kindIndex });
   }
   return out;
 }
 function buildLabeledScannableTriviaFnDecl(fnName, arms) {
+  const mint = makeMint();
   return [
     `function ${fnName}(input, _pos, _ctx, _cap) {`,
     `  let _e = _pos`,
     `  while (_e < input.length) {`,
     `    const c = input.charCodeAt(_e)`,
-    ...arms.map((a) => scanBranchLabeled(a.shape, a.kindIndex)),
+    ...arms.map((a) => scanBranchLabeled(a.shape, a.kindIndex, mint)),
     `    break`,
     `  }`,
     `  return _e`,
@@ -1609,6 +1805,15 @@ function buildLabeledRuntimeTriviaFnDecl(fnName, spec, rpStartIndex) {
   ].join("\n");
 }
 
+// src/compiler/scannable-terminal.ts
+function emitScannableTerminal(shape, c) {
+  const m = emitShapeMatch(shape, c.pos, c.fresh, c.ind);
+  const stmts = [...m.setup];
+  if (m.ok !== "true") stmts.push(...c.failIf(`!(${m.ok})`));
+  stmts.push(`${c.ind}const ${c.valueVar} = input.slice(${c.pos}, ${m.end})`);
+  return { stmts, endVar: m.end };
+}
+
 // src/compiler/inline-build.ts
 var MK_BUILD_RE = /^\(\s*(?:\w+\s*,\s*){3}\w+\s*\)\s*=>\s*mk\s*\(\s*(['"])([^'"]+)\1\s*,\s*\w+\s*,\s*\w+\s*,\s*\w+\s*,\s*\w+\s*\)\s*$/;
 function escapeRegExp(s) {
@@ -1730,14 +1935,45 @@ function failReturn(expected, posExpr) {
 function failReturnArr(expectedArr, posExpr) {
   return `return { ok: false, expected: ${expectedArr}, span: { start: ${posExpr}, end: ${posExpr} } }`;
 }
+function hoistExpected(ctx, constArrSource) {
+  let name = ctx.expectedMap.get(constArrSource);
+  if (name === void 0) {
+    name = `_fx${ctx.expectedDecls.length}`;
+    ctx.expectedDecls.push(`const ${name} = Object.freeze(${constArrSource})`);
+    ctx.expectedMap.set(constArrSource, name);
+  }
+  return name;
+}
 function failBody(ctx, expected, posExpr) {
-  if (ctx.failLabel) return `break ${ctx.failLabel}`;
+  if (ctx.failLabel) {
+    if (!ctx.recordFail) return `break ${ctx.failLabel}`;
+    return `{ _ctx._fe = ${posExpr}; _ctx._fx = ${hoistExpected(ctx, `[${expected}]`)}; break ${ctx.failLabel} }`;
+  }
   return failReturn(expected, posExpr);
 }
-function failArrBody(ctx, expectedArr, posExpr) {
-  if (ctx.failLabel) return `break ${ctx.failLabel}`;
+function failArrBody(ctx, expectedArr, posExpr, constant = true) {
+  if (ctx.failLabel) {
+    if (!ctx.recordFail) return `break ${ctx.failLabel}`;
+    const fx = constant ? hoistExpected(ctx, expectedArr) : expectedArr;
+    return `{ _ctx._fe = ${posExpr}; _ctx._fx = ${fx}; break ${ctx.failLabel} }`;
+  }
+  if (!constant) return `return { ok: false, expected: [...${expectedArr}], span: { start: ${posExpr}, end: ${posExpr} } }`;
   return failReturnArr(expectedArr, posExpr);
 }
+function resultFromRecorded(feExpr = "_ctx._fe", fxExpr = "_ctx._fx") {
+  return `return { ok: false, expected: [...${fxExpr}], span: { start: ${feExpr}, end: ${feExpr} } }`;
+}
+function propagateFailBody(ctx, srcCtx = "_ctx") {
+  if (srcCtx !== "_ctx") {
+    if (ctx.failLabel) {
+      if (!ctx.recordFail) return `break ${ctx.failLabel}`;
+      return `{ _ctx._fe = ${srcCtx}._fe; _ctx._fx = ${srcCtx}._fx; break ${ctx.failLabel} }`;
+    }
+    return `{ _ctx._fe = ${srcCtx}._fe; _ctx._fx = ${srcCtx}._fx; ${resultFromRecorded()} }`;
+  }
+  if (ctx.failLabel) return `break ${ctx.failLabel}`;
+  return resultFromRecorded();
+}
 function emitIfFail(ctx, cond, body) {
   return [
     `${ind(ctx)}if (${cond}) {`,
@@ -1773,13 +2009,15 @@ function pushNamedFnDecl(ctx, fnName, bodyStmts, valueVar, endVar) {
     `}`
   ].join("\n"));
 }
-function emitNamedFnCall(ctx, fnName, pos, failExpected) {
+function emitNamedFnCall(ctx, fnName, pos) {
   const vv = v(ctx, "_pfv");
   const ev = v(ctx, "_pfe");
   return {
     stmts: [
       `${ind(ctx)}const ${vv} = ${fnName}(input, ${pos}, _ctx)`,
-      ...emitIfFail(ctx, `${vv} === ${NAMED_FN_FAIL}`, failBody(ctx, failExpected, pos)),
+      // ref/lazy returns the inner failure verbatim — propagate the recorded
+      // deepest failure (shares _ctx with the named fn), not a "parser" label.
+      ...emitIfFail(ctx, `${vv} === ${NAMED_FN_FAIL}`, propagateFailBody(ctx)),
       `${ind(ctx)}const ${ev} = ${NAMED_FN_END}`
     ],
     valueVar: vv,
@@ -1889,6 +2127,27 @@ function firstSetCond(codeVar, fs) {
     (r) => r.lo === r.hi ? `${codeVar} === ${r.lo}` : `(${codeVar} >= ${r.lo} && ${codeVar} <= ${r.hi})`
   ).join(" || ");
 }
+var SWITCH_RANGE_LIMIT = 4;
+var SWITCH_MAX_CASES = 48;
+var SWITCH_MIN_CASES = 3;
+var _forceDisjointIf = false;
+function planDisjointDispatch(parsers) {
+  const cases = [];
+  let total = 0;
+  for (const p of parsers) {
+    const fs = p._meta.firstSet;
+    if (fs.kind !== "ranges") return { kind: "if" };
+    const pts = [];
+    for (const r of fs.ranges) {
+      if (r.hi - r.lo + 1 > SWITCH_RANGE_LIMIT) return { kind: "if" };
+      for (let cp = r.lo; cp <= r.hi; cp++) pts.push(cp);
+    }
+    total += pts.length;
+    if (total > SWITCH_MAX_CASES) return { kind: "if" };
+    cases.push(pts);
+  }
+  return total >= SWITCH_MIN_CASES ? { kind: "switch", cases } : { kind: "if" };
+}
 function captureRestoreBody(mL, mR, mTl, mLg) {
   const base = `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${mL}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${mR}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${mTl}`;
   return mLg ? `${base}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${mLg}` : base;
@@ -2105,6 +2364,22 @@ function emitKeywords(def, ctx, pos) {
   return { stmts, valueVar: vv, endVar };
 }
 function emitRegex(def, ctx, pos) {
+  const expectedStr = JSON.stringify(`/${def.source}/`);
+  const shape = scanShapeFromRegex(def.source, def.flags);
+  if (shape) {
+    const vv2 = v(ctx);
+    const scanned = emitScannableTerminal(shape, {
+      ind: ind(ctx),
+      pos,
+      valueVar: vv2,
+      failIf: (cond) => emitIfFail(ctx, cond, failBody(ctx, expectedStr, pos)),
+      fresh: (prefix) => v(ctx, prefix)
+    });
+    if (scanned) {
+      const stmts2 = [...scanned.stmts, ...emitLeafCapture(ctx, vv2, pos, scanned.endVar)];
+      return { stmts: stmts2, valueVar: vv2, endVar: scanned.endVar };
+    }
+  }
   const flags = "y" + def.flags.replace(/[gy]/g, "");
   const key = `${def.optimizedSource}/${flags}`;
   let rName = ctx.regexMap.get(key);
@@ -2115,7 +2390,6 @@ function emitRegex(def, ctx, pos) {
   }
   const mv = v(ctx, "_m");
   const vv = v(ctx);
-  const expectedStr = JSON.stringify(`/${def.source}/`);
   const stmts = [
     `${ind(ctx)}${rName}.lastIndex = ${pos}`,
     `${ind(ctx)}const ${mv} = ${rName}.exec(input)`,
@@ -2174,15 +2448,43 @@ function emitSeq(def, ctx, pos) {
   stmts.push(`${ind(ctx)}const ${arrV} = [${valueVars.join(", ")}]`);
   return { stmts, valueVar: arrV, endVar };
 }
+function staticExpectedArr(parsers) {
+  return JSON.stringify(parsers.flatMap((p) => {
+    const e = staticExpected(p);
+    return e.length > 0 ? e : [p._tag];
+  }));
+}
+function failsAtStart(p) {
+  const d = p._def;
+  switch (d.tag) {
+    case "literal":
+    case "regex":
+    case "keywords":
+    case "guard":
+    case "not":
+      return true;
+    case "transform":
+    case "label":
+      return failsAtStart(d.parser);
+    default:
+      return false;
+  }
+}
+function emitDisjointArm(p, ctx, pos, valV, endV) {
+  if (failsAtStart(p)) {
+    const r = emit(p, ctx, pos);
+    return [...r.stmts, `${ind(ctx)}${valV} = ${r.valueVar}`, `${ind(ctx)}${endV} = ${r.endVar}`];
+  }
+  const { stmts, okVar, valVar, endVar } = emitFallible(p, ctx, pos);
+  return [
+    ...stmts,
+    ...emitIfFail(ctx, `!${okVar}`, failArrBody(ctx, "_ctx._fx", pos, false)),
+    `${ind(ctx)}${valV} = ${valVar}`,
+    `${ind(ctx)}${endV} = ${endVar}`
+  ];
+}
 function emitChoice(def, ctx, pos) {
-  const allExpected = JSON.stringify(
-    def.parsers.map((p) => {
-      const d = p._def;
-      if (d.tag === "literal") return JSON.stringify(d.value);
-      if (d.tag === "regex") return `/${d.source}/`;
-      return p._tag;
-    })
-  );
+  const allExpected = staticExpectedArr(def.parsers);
   if (def.disjoint) {
     const codeV = v(ctx, "_code");
     const valV = v(ctx, "_chv");
@@ -2191,6 +2493,27 @@ function emitChoice(def, ctx, pos) {
       `${ind(ctx)}const ${codeV} = ${pos} < input.length ? (input.codePointAt(${pos}) ?? -1) : -1`,
       `${ind(ctx)}let ${valV}, ${endV} = ${pos}`
     ];
+    const plan = _forceDisjointIf ? { kind: "if" } : planDisjointDispatch(def.parsers);
+    if (plan.kind === "switch") {
+      stmts.push(`${ind(ctx)}switch (${codeV}) {`);
+      ctx.indent++;
+      for (let i = 0; i < def.parsers.length; i++) {
+        const p = def.parsers[i];
+        for (const cp of plan.cases[i]) stmts.push(`${ind(ctx)}case ${cp}:`);
+        stmts.push(`${ind(ctx)}{`);
+        ctx.indent++;
+        stmts.push(
+          ...emitDisjointArm(p, ctx, pos, valV, endV),
+          `${ind(ctx)}break`
+        );
+        ctx.indent--;
+        stmts.push(`${ind(ctx)}}`);
+      }
+      stmts.push(`${ind(ctx)}default: ${failArrBody(ctx, allExpected, pos)}`);
+      ctx.indent--;
+      stmts.push(`${ind(ctx)}}`);
+      return { stmts, valueVar: valV, endVar: endV };
+    }
     let first = true;
     for (const p of def.parsers) {
       const cond = firstSetCond(codeV, p._meta.firstSet);
@@ -2198,10 +2521,7 @@ function emitChoice(def, ctx, pos) {
       first = false;
       stmts.push(`${ind(ctx)}${kw} (${cond}) {`);
       ctx.indent++;
-      const r = emit(p, ctx, pos);
-      stmts.push(...r.stmts);
-      stmts.push(`${ind(ctx)}${valV} = ${r.valueVar}`);
-      stmts.push(`${ind(ctx)}${endV} = ${r.endVar}`);
+      stmts.push(...emitDisjointArm(p, ctx, pos, valV, endV));
       ctx.indent--;
       stmts.push(`${ind(ctx)}}`);
     }
@@ -2210,7 +2530,7 @@ function emitChoice(def, ctx, pos) {
   }
   return emitNonDisjoint(def, def.strategy, allExpected, ctx, pos);
 }
-function emitGreedyClassify(def, superIndex, allExpected, ctx, pos) {
+function emitGreedyClassify(def, superIndex, ctx, pos) {
   const superParser = def.parsers[superIndex];
   const regexDef = getCoreRegexDef(superParser);
   const cleanFlags = "y" + regexDef.flags.replace(/[gy]/g, "");
@@ -2225,10 +2545,11 @@ function emitGreedyClassify(def, superIndex, allExpected, ctx, pos) {
   const wordV = v(ctx, "_gw");
   const endV = v(ctx, "_ge");
   const valV = v(ctx, "_gcv");
+  const regexExpected = JSON.stringify(staticExpected(superParser));
   const stmts = [
     `${ind(ctx)}${reVar}.lastIndex = ${pos}`,
     `${ind(ctx)}const ${matchV} = ${reVar}.exec(input)`,
-    ...emitIfFail(ctx, `${matchV} === null`, failArrBody(ctx, allExpected, pos)),
+    ...emitIfFail(ctx, `${matchV} === null`, failArrBody(ctx, regexExpected, pos)),
     `${ind(ctx)}const ${wordV} = ${matchV}[0]`,
     `${ind(ctx)}const ${endV} = ${pos} + ${wordV}.length`,
     `${ind(ctx)}let ${valV}`
@@ -2286,13 +2607,15 @@ function emitLiteralsLongestFirst(def, sortedIndices, allExpected, ctx, pos) {
   stmts.push(...emitElseFail(ctx, failArrBody(ctx, allExpected, pos)));
   return { stmts, valueVar: valV, endVar: endV };
 }
-function emitFirstMatch(def, allExpected, ctx, pos) {
+function emitFirstMatch(def, ctx, pos) {
   const resValV = v(ctx, "_crv");
   const resEndV = v(ctx, "_cre");
   const resOkV = v(ctx, "_crok");
+  const slots = def.parsers.map(() => v(ctx, "_cfx"));
   const ind0 = ind(ctx);
   const stmts = [
-    `${ind0}let ${resValV}, ${resEndV} = ${pos}, ${resOkV} = false`
+    `${ind0}let ${resValV}, ${resEndV} = ${pos}, ${resOkV} = false`,
+    `${ind0}let ${slots.join(", ")}`
   ];
   for (let i = 0; i < def.parsers.length; i++) {
     const p = def.parsers[i];
@@ -2339,22 +2662,24 @@ function emitFirstMatch(def, allExpected, ctx, pos) {
       stmts.push(`${ind0}      ${resOkV} = true`);
       stmts.push(`${ind0}    }`);
       stmts.push(`${ind0}  }`);
+      stmts.push(`${ind0}  else { ${slots[i]} = _ctx._fx }`);
       if (rollback) stmts.push(`${ind0}  if (!${resOkV}) { ${rollback} }`);
     } else {
       stmts.push(`${ind0}  if (${okVar}) { ${resValV} = ${valVar}; ${resEndV} = ${endVar}; ${resOkV} = true }`);
-      if (rollback) stmts.push(`${ind0}  else { ${rollback} }`);
+      stmts.push(`${ind0}  else { ${slots[i]} = _ctx._fx${rollback ? `; ${rollback}` : ""} }`);
     }
     stmts.push(`${ind0}}`);
   }
-  stmts.push(...emitIfFail(ctx, `!${resOkV}`, failArrBody(ctx, allExpected, pos)));
+  const concatExpr = `[${slots.map((s) => `...(${s} || [])`).join(", ")}]`;
+  stmts.push(...emitIfFail(ctx, `!${resOkV}`, failArrBody(ctx, concatExpr, pos, false)));
   return { stmts, valueVar: resValV, endVar: resEndV };
 }
 function emitNonDisjoint(def, strategy, allExpected, ctx, pos) {
   if (strategy.tag === "greedyClassify")
-    return emitGreedyClassify(def, strategy.superIndex, allExpected, ctx, pos);
+    return emitGreedyClassify(def, strategy.superIndex, ctx, pos);
   if (strategy.tag === "literalsLongestFirst")
     return emitLiteralsLongestFirst(def, strategy.sortedIndices, allExpected, ctx, pos);
-  return emitFirstMatch(def, allExpected, ctx, pos);
+  return emitFirstMatch(def, ctx, pos);
 }
 function emitTransformChain(p, baseValue, endV, startPos, ctx) {
   const def = p._def;
@@ -2582,10 +2907,11 @@ function emitScanTo(def, ctx, pos) {
 }
 function emitNot(def, ctx, pos) {
   const { stmts, okVar } = emitFallible(def.parser, ctx, pos);
+  const label2 = JSON.stringify(`not(${def.parser._tag})`);
   return {
     stmts: [
       ...stmts,
-      ...emitIfFail(ctx, okVar, failBody(ctx, '"not"', pos))
+      ...emitIfFail(ctx, okVar, failBody(ctx, label2, pos))
     ],
     valueVar: "null",
     endVar: pos
@@ -2617,7 +2943,7 @@ function emitNode(def, ctx, pos) {
   const { stmts: innerStmts, okVar, endVar } = emitFallible(def.parser, ctx, pos);
   stmts.push(...innerStmts);
   stmts.push(`${i}_ctx._cstChildren = ${sc}; _ctx._cstLeaves = ${sl}; _ctx._cstRawChildren = ${sr}; _ctx.captureTrivia = ${st}; _ctx._cstTriviaLog = ${stl}`);
-  stmts.push(...emitIfFail(ctx, `!${okVar}`, failBody(ctx, '"node"', pos)));
+  stmts.push(...emitIfFail(ctx, `!${okVar}`, propagateFailBody(ctx)));
   let stV = "undefined";
   if (clonesState) {
     stV = v(ctx, "_nst");
@@ -2639,9 +2965,10 @@ function emitRuntimeFallback(parser2, ctx, pos) {
   const rv = v(ctx, "_rt");
   const vv = v(ctx, "_rtv");
   const ev = v(ctx, "_rte");
+  const failStmt = ctx.failLabel ? ctx.recordFail ? `{ _ctx._fe = ${rv}.span.start; _ctx._fx = ${rv}.expected; break ${ctx.failLabel} }` : `break ${ctx.failLabel}` : `return { ok: false, expected: ${rv}.expected, span: ${rv}.span }`;
   const stmts = [
     `${ind(ctx)}const ${rv} = _rp[${idx}].parse(input, ${pos}, _ctx)`,
-    ...emitIfFail(ctx, `!${rv}.ok`, failBody(ctx, '"runtime"', pos)),
+    ...emitIfFail(ctx, `!${rv}.ok`, failStmt),
     `${ind(ctx)}const ${vv} = ${rv}.value`,
     `${ind(ctx)}const ${ev} = ${rv}.span.end`
   ];
@@ -2678,7 +3005,7 @@ function emitLazy(p, def, ctx, pos) {
     pushNamedFnDecl(ctx, fnName2, r.stmts, r.valueVar, r.endVar);
   }
   const fnName = ctx.namedParsers.get(p);
-  return emitNamedFnCall(ctx, fnName, pos, '"parser"');
+  return emitNamedFnCall(ctx, fnName, pos);
 }
 function emitRecover(def, ctx, pos) {
   const { stmts: innerStmts, okVar, valVar, endVar } = emitFallible(def.parser, ctx, pos);
@@ -2696,7 +3023,7 @@ function emitRecover(def, ctx, pos) {
     `${ind0}    if (${sentOk}) break`,
     `${ind0}    ${scanV}++`,
     `${ind0}  }`,
-    `${ind0}  const ${errV} = { _tag: 'parseError', span: { start: ${pos}, end: ${scanV} }, expected: [] }`,
+    `${ind0}  const ${errV} = { _tag: 'parseError', span: { start: ${pos}, end: ${scanV} }, expected: ${JSON.stringify(staticExpected(def.parser))} }`,
     `${ind0}  if (_ctx._errors) _ctx._errors.push(${errV})`,
     `${ind0}  ${valVar} = ${errV}`,
     `${ind0}  ${endVar} = ${scanV}`,
@@ -2869,7 +3196,9 @@ function emit(p, ctx, pos) {
         stmts: [
           `${ind(ctx)}const ${rv} = { ..._ctx, state: _mf[${evIdx}]() }`,
           `${ind(ctx)}const ${vv} = ${fn}(input, ${pos}, ${rv})`,
-          ...emitIfFail(ctx, `${vv} === ${NAMED_FN_FAIL}`, failBody(ctx, '"withCtx"', pos)),
+          // withCtx runs on a spread child ctx — copy its recorded failure back
+          // and propagate the inner failure verbatim (interpreter parity).
+          ...emitIfFail(ctx, `${vv} === ${NAMED_FN_FAIL}`, propagateFailBody(ctx, rv)),
           `${ind(ctx)}const ${ev} = ${NAMED_FN_END}`
         ],
         valueVar: vv,
@@ -2970,7 +3299,7 @@ function analyzeLazyUsageMulti(roots) {
   const recursive = /* @__PURE__ */ new Set();
   const descended = /* @__PURE__ */ new Set();
   const active = /* @__PURE__ */ new Set();
-  function walk(p) {
+  function walk2(p) {
     const def = p._def;
     if (def.tag === "lazy") {
       counts.set(p, (counts.get(p) ?? 0) + 1);
@@ -2987,13 +3316,13 @@ function analyzeLazyUsageMulti(roots) {
         return;
       }
       active.add(p);
-      walk(resolved);
+      walk2(resolved);
       active.delete(p);
       return;
     }
-    for (const child of childrenOf(def)) walk(child);
+    for (const child of childrenOf(def)) walk2(child);
   }
-  for (const root of roots) walk(root);
+  for (const root of roots) walk2(root);
   return { counts, recursive };
 }
 function compile(combinator, mapFnSources) {
@@ -3002,6 +3331,8 @@ function compile(combinator, mapFnSources) {
     indent: 1,
     regexDecls: [],
     regexMap: /* @__PURE__ */ new Map(),
+    expectedDecls: [],
+    expectedMap: /* @__PURE__ */ new Map(),
     mapFns: [],
     mapFnSrcs: [],
     buildFns: [],
@@ -3023,6 +3354,7 @@ function compile(combinator, mapFnSources) {
   const source = [
     ...emptyTlDecls,
     ...ctx.regexDecls,
+    ...ctx.expectedDecls,
     "",
     ...namedPrelude,
     ctx.namedFnDecls.join("\n\n"),
@@ -3035,6 +3367,7 @@ function compile(combinator, mapFnSources) {
   const fn = new Function("input", "_pos", "_rp", "_mf", "_build", "_ctx", [
     ...emptyTlDecls,
     ...ctx.regexDecls,
+    ...ctx.expectedDecls,
     collatorDecl,
     ...namedPrelude,
     ...ctx.namedFnDecls.flatMap((decl, i) => i > 0 ? ["", decl] : [decl]),
@@ -3080,6 +3413,8 @@ function compileRuleMap(ruleMap) {
     indent: 1,
     regexDecls: [],
     regexMap: /* @__PURE__ */ new Map(),
+    expectedDecls: [],
+    expectedMap: /* @__PURE__ */ new Map(),
     mapFns: [],
     mapFnSrcs: [],
     buildFns: [],
@@ -3108,6 +3443,7 @@ function compileRuleMap(ruleMap) {
   const hoistedDecls = [
     ctx.needsEmptyTl ? `  const _EMPTY_TL = Object.freeze([])` : "",
     ...ctx.regexDecls.map((d) => `  ${d}`),
+    ...ctx.expectedDecls.map((d) => `  ${d}`),
     collatorDecl ? `  ${collatorDecl.trim()}` : "",
     mfDecl,
     buildDecl,
@@ -3149,12 +3485,13 @@ function buildInlineExpression(ctx, r, collatorDecl, mapFnSources, buildSources)
   const mfDecl = mapFnSources?.length ? `  const _mf = [${mapFnSources.join(", ")}]` : "";
   const buildDecl = buildSources?.length ? `  const _build = [${buildSources.join(", ")}]` : "";
   const emptyTlDecl = ctx.needsEmptyTl ? `  const _EMPTY_TL = Object.freeze([])` : "";
-  const needsWrapper = ctx.regexDecls.length > 0 || !!collatorDecl || ctx.namedFnDecls.length > 0 || !!mfDecl || !!buildDecl || !!emptyTlDecl;
+  const needsWrapper = ctx.regexDecls.length > 0 || ctx.expectedDecls.length > 0 || !!collatorDecl || ctx.namedFnDecls.length > 0 || !!mfDecl || !!buildDecl || !!emptyTlDecl;
   if (!needsWrapper) return innerFn;
   const namedPrelude = ctx.namedFnDecls.length > 0 ? namedFnPrelude() : [];
   const hoistedDecls = [
     emptyTlDecl,
     ...ctx.regexDecls.map((d) => `  ${d}`),
+    ...ctx.expectedDecls.map((d) => `  ${d}`),
     collatorDecl ? `  ${collatorDecl.trim()}` : "",
     mfDecl,
     buildDecl,
@@ -3172,58 +3509,6 @@ function buildInlineExpression(ctx, r, collatorDecl, mapFnSources, buildSources)
   ].join("\n");
 }
 
-// src/combinators/expect.ts
-function staticExpected(c) {
-  const def = c._def;
-  switch (def.tag) {
-    case "literal":
-      return [JSON.stringify(def.value)];
-    case "regex":
-      return [`/${def.source}/`];
-    case "keywords":
-      return def.words.map((w) => JSON.stringify(w));
-    case "label":
-      return [def.label];
-    case "choice":
-      return def.parsers.flatMap(staticExpected);
-    case "sequence":
-      return def.parsers.length > 0 ? staticExpected(def.parsers[0]) : [];
-    case "node":
-    case "grammar":
-    case "trivia":
-    case "optional":
-    case "many":
-    case "oneOrMore":
-    case "transform":
-    case "not":
-      return staticExpected(def.parser);
-    case "lazy":
-      return staticExpected(def.thunk());
-    default:
-      return [];
-  }
-}
-function expect(combinator, label2) {
-  const expected = label2 !== void 0 ? [label2] : staticExpected(combinator);
-  const meta = {
-    firstSet: combinator._meta.firstSet,
-    canMatchNewline: combinator._meta.canMatchNewline,
-    isTrivia: false
-  };
-  return {
-    _tag: "expect",
-    _meta: meta,
-    _def: { tag: "expect", parser: combinator, label: label2, expected },
-    parse(input, pos, ctx) {
-      const result = combinator.parse(input, pos, ctx);
-      if (result.ok) return result;
-      const error = { _tag: "parseError", span: { start: pos, end: pos }, expected };
-      ctx._errors?.push(error);
-      return { ok: true, value: error, span: { start: pos, end: pos } };
-    }
-  };
-}
-
 // src/combinators/scanTo.ts
 function scanTo(sentinel, { skip: skip2 = [], orEOF = false } = {}) {
   const meta = {
@@ -3605,6 +3890,13 @@ function evaluateWordFactory(node2, scope, code) {
 function evaluateExpr(node2, scope, code, mapFnSources) {
   return exprToCombi(node2, scope, code, mapFnSources);
 }
+function evaluateCombinatorArray(node2, scope, code) {
+  if (node2.type !== "ArrayExpression") return null;
+  const val = anyValue(node2, scope, code, []);
+  if (!Array.isArray(val) || val.length === 0) return null;
+  if (!val.every(isCombinator)) return null;
+  return val;
+}
 function evaluateParserFactory(factoryNode, scope, code, mapFnSources) {
   if (factoryNode.type !== "ArrowFunctionExpression" && factoryNode.type !== "FunctionDeclaration" && factoryNode.type !== "FunctionExpression") return null;
   const factory = factoryNode;
@@ -3908,6 +4200,12 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
             scope.set(varName, wordFactory);
             continue;
           }
+          const combiArray = evaluateCombinatorArray(init, scope, code);
+          if (combiArray) {
+            ;
+            scope.set(varName, combiArray);
+            continue;
+          }
           warn(init.start, `"${varName}" references a parseman macro import but isn't a statically-evaluable combinator`);
           continue;
         }