parseman 0.43.0 → 0.44.0

package/dist/spec/index.js

@@ -576,1448 +576,1535 @@ function pushTriviaLogEntry(ctx, start, end, kindIndex) {
   }
 }
 
-// src/recovery/scan.ts
-function probeAt(sentinel, input, pos, ctx) {
-  const s = {
-    _probe: ctx._probe,
-    _errors: ctx._errors,
-    _cstLeaves: ctx._cstLeaves,
-    _cstChildren: ctx._cstChildren,
-    _cstRawChildren: ctx._cstRawChildren,
-    _cstTriviaLog: ctx._cstTriviaLog,
-    _triviaLog: ctx._triviaLog,
-    _fields: ctx._fields,
-    _cstBuf: ctx._cstBuf,
-    _tolerant: ctx._tolerant,
-    _sync: ctx._sync
-  };
-  ctx._probe = void 0;
-  ctx._errors = void 0;
-  ctx._cstLeaves = void 0;
-  ctx._cstChildren = void 0;
-  ctx._cstRawChildren = void 0;
-  ctx._cstTriviaLog = void 0;
-  ctx._triviaLog = void 0;
-  ctx._fields = void 0;
-  ctx._cstBuf = void 0;
-  ctx._tolerant = void 0;
-  ctx._sync = void 0;
-  try {
-    return sentinel.parse(input, pos, ctx).ok;
-  } finally {
-    ctx._probe = s._probe;
-    ctx._errors = s._errors;
-    ctx._cstLeaves = s._cstLeaves;
-    ctx._cstChildren = s._cstChildren;
-    ctx._cstRawChildren = s._cstRawChildren;
-    ctx._cstTriviaLog = s._cstTriviaLog;
-    ctx._triviaLog = s._triviaLog;
-    ctx._fields = s._fields;
-    ctx._cstBuf = s._cstBuf;
-    ctx._tolerant = s._tolerant;
-    ctx._sync = s._sync;
-  }
+// src/cst/trivia-kinds.ts
+var labeledTriviaSpecs = /* @__PURE__ */ new WeakMap();
+function unwrapTrivia(p) {
+  let cur = p;
+  while (cur._def.tag === "trivia") cur = cur._def.parser;
+  return cur;
 }
-function orSentinel(a, b) {
-  if (b === void 0) return a;
-  return {
-    _tag: "orSentinel",
-    _meta: { firstSet: { kind: "any" }, canMatchNewline: false, isTrivia: false },
-    _def: { tag: "unknown" },
-    parse(input, pos, ctx) {
-      const ra = a.parse(input, pos, ctx);
-      if (ra.ok) return ra;
-      return b.parse(input, pos, ctx);
-    }
-  };
+function peelLabel(p) {
+  if (p._def.tag === "label") return { label: p._def.label, parser: p._def.parser };
+  return null;
 }
-function firstSetSentinel(fs) {
-  if (fs.kind !== "ranges" || fs.ranges.length === 0) return null;
-  const ranges = fs.ranges;
-  return {
-    _tag: "firstSetSentinel",
-    _meta: { firstSet: fs, canMatchNewline: false, isTrivia: false },
-    _def: { tag: "unknown" },
-    parse(input, pos) {
-      const code = pos < input.length ? input.codePointAt(pos) : void 0;
-      if (code !== void 0) {
-        for (const r of ranges) {
-          if (code >= r.lo && code <= r.hi) return { ok: true, value: null, span: { start: pos, end: pos } };
-        }
+function analyzeLabeledTrivia(trivia2) {
+  const cached = labeledTriviaSpecs.get(trivia2);
+  if (cached !== void 0) return cached;
+  let core = unwrapTrivia(trivia2);
+  let minRepeats = 1;
+  if (core._def.tag === "oneOrMore") {
+    core = core._def.parser;
+    minRepeats = 1;
+  } else if (core._def.tag === "many") {
+    core = core._def.parser;
+    minRepeats = 0;
+  }
+  const arms = [];
+  if (core._def.tag === "choice") {
+    for (let i = 0; i < core._def.parsers.length; i++) {
+      const peeled = peelLabel(core._def.parsers[i]);
+      if (!peeled) {
+        labeledTriviaSpecs.set(trivia2, null);
+        return null;
       }
-      return { ok: false, expected: [], span: { start: pos, end: pos } };
+      arms.push({ label: peeled.label, kindIndex: i, parser: peeled.parser });
+    }
+  } else {
+    const peeled = peelLabel(core);
+    if (!peeled) {
+      labeledTriviaSpecs.set(trivia2, null);
+      return null;
     }
+    arms.push({ label: peeled.label, kindIndex: 0, parser: peeled.parser });
+  }
+  const spec = {
+    labels: arms.map((a) => a.label),
+    arms,
+    minRepeats
   };
+  labeledTriviaSpecs.set(trivia2, spec);
+  return spec;
 }
-function recoverScan(input, from, ctx, sync, expected) {
-  let scanPos = from;
-  while (scanPos < input.length && !probeAt(sync, input, scanPos, ctx)) scanPos++;
-  const span = { start: from, end: scanPos };
-  if (ctx.trackLines) recordLineRangeFromContext(ctx, input, from, scanPos);
-  const error = { _tag: "parseError", span: ctx.trackLines ? annotateSpanFromLineContext(span, ctx) : span, expected };
-  ctx._errors?.push(error);
-  return { error, end: scanPos };
-}
-function matchesAt(sentinel, input, pos, ctx) {
-  return probeAt(sentinel, input, pos, ctx);
+function matchArmAt(input, pos, arm, state) {
+  if (!startsFirstSet(arm, input, pos)) return null;
+  const r = arm.parse(input, pos, { trackLines: false, state });
+  if (!r.ok || r.span.end <= pos) return null;
+  return { end: r.span.end };
 }
-function captureError(ctx, error) {
-  if (cstCaptureActive(ctx)) pushCstChild(ctx, error, error);
+function scanLabeledTriviaChunks(input, cur, spec, state) {
+  const chunks = [];
+  let pos = cur;
+  while (pos < input.length) {
+    let matched = null;
+    for (const arm of spec.arms) {
+      const m = matchArmAt(input, pos, arm.parser, state);
+      if (m) {
+        matched = { end: m.end, kindIndex: arm.kindIndex };
+        break;
+      }
+    }
+    if (!matched) break;
+    chunks.push({ start: pos, end: matched.end, kindIndex: matched.kindIndex });
+    pos = matched.end;
+  }
+  if (chunks.length < spec.minRepeats) {
+    return { end: cur, chunks: [] };
+  }
+  return { end: pos, chunks };
 }
-
-// src/combinators/expect.ts
-function deriveExpected(c) {
-  return [...new Set(derive(c, /* @__PURE__ */ new Set()))];
+function scanLabeledTriviaEnd(input, cur, spec, state) {
+  let pos = cur;
+  let count = 0;
+  while (pos < input.length) {
+    let matched = null;
+    for (const arm of spec.arms) {
+      matched = matchArmAt(input, pos, arm.parser, state);
+      if (matched) break;
+    }
+    if (!matched) break;
+    pos = matched.end;
+    count++;
+  }
+  return count < spec.minRepeats ? cur : pos;
 }
-function derive(c, seen) {
-  const deriveExpected2 = (p) => derive(p, seen);
-  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(deriveExpected2);
-    case "dispatch":
-      return deriveExpected2(def.selector);
-    // Union through the NULLABLE prefix, mirroring `sequenceFirstSet`. A leading
-    // `optional(…)`/`many(…)` can match nothing, so the term after it is equally
-    // able to fail first — deriving from term 0 alone named a token the parse
-    // never actually required. A leading `not(…)` is zero-width and contributes
-    // nothing (its own expectation is about what must NOT be here), but it is
-    // nullable, so keep scanning past it. Stop at the first term that must match.
-    case "sequence": {
-      const out = [];
-      for (const term of def.parsers) {
-        if (!isZeroWidthAssertion(term)) out.push(...deriveExpected2(term));
-        if (!matchesEmpty(term)) break;
+function visitLabeledTrivia(input, cur, spec, state, visit) {
+  if (spec.minRepeats > 1) return void 0;
+  let pos = cur;
+  let count = 0;
+  while (pos < input.length) {
+    let matched = null;
+    for (const arm of spec.arms) {
+      const match = matchArmAt(input, pos, arm.parser, state);
+      if (match) {
+        matched = { end: match.end, kindIndex: arm.kindIndex };
+        break;
       }
-      return out;
     }
-    case "attempt":
-      return deriveExpected2(def.parser);
-    // Delegating wrappers whose first-token failure is their inner parser's — must
-    // pass through so a start-failure (and the first-set-miss fast-path in attempt/
-    // node, which reads this) names the real expected token, not the wrapper tag.
-    case "field":
-    case "withCtx":
-    case "recover":
-      return deriveExpected2(def.parser);
-    case "skip":
-      return deriveExpected2(def.main);
-    case "expect":
-      return def.expected;
-    case "node":
-    case "grammar":
-    case "trivia":
-    case "token":
-    case "leaf":
-    case "optional":
-    case "many":
-    case "oneOrMore":
-    case "transform":
-    case "not":
-    case "peek":
-      return deriveExpected2(def.parser);
-    case "routed":
-      return ["routed()"];
-    case "lazy": {
-      const name = c._ruleName;
-      if (seen.has(c)) return name ? [name] : [];
-      seen.add(c);
-      try {
-        return deriveExpected2(def.thunk());
-      } catch {
-        return name ? [name] : [];
-      } finally {
-        seen.delete(c);
+    if (!matched) break;
+    visit(pos, matched.end, matched.kindIndex);
+    pos = matched.end;
+    count++;
+  }
+  return count < spec.minRepeats ? cur : pos;
+}
+function recordTriviaChunks(ctx, chunks) {
+  const kinds = ctx.triviaKindLabels;
+  const mask = ctx._triviaCaptureMask;
+  const rootLog = ctx._rootTriviaLog;
+  const rootKinds = ctx._rootTriviaKindIndex;
+  const rootMark = rootLog?.length ?? 0;
+  for (const ch of chunks) {
+    pushTriviaLogEntry(ctx, ch.start, ch.end, kinds ? ch.kindIndex : void 0);
+    const rootKindIndex = ctx._rootTriviaCapture === false || rootLog === void 0 || rootKinds === void 0 || kinds === void 0 ? -1 : rootKinds[kinds[ch.kindIndex] ?? ""] ?? -1;
+    if (rootKindIndex >= 0) {
+      rootLog.push(0, 0, ch.start, ch.end, rootKindIndex);
+    }
+    if (ctx.captureTrivia && (ctx._cstBuf !== void 0 || ctx._cstTriviaLog !== void 0)) {
+      if (mask === void 0 || kinds === void 0 || (mask & 1 << ch.kindIndex) !== 0) {
+        pushCstTriviaEntry(ctx, ch.start, ch.end, kinds ? ch.kindIndex : void 0);
       }
     }
-    default:
-      return [];
   }
-}
-function expect(combinator, label2) {
-  const expected = label2 !== void 0 ? [label2] : deriveExpected(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 span = { start: pos, end: pos };
-      const error = { _tag: "parseError", span: ctx.trackLines ? annotateSpanFromLineContext(span, ctx) : span, expected };
-      ctx._errors?.push(error);
-      if (ctx._tolerant) captureError(ctx, error);
-      return { ok: true, value: error, span: { start: pos, end: pos } };
+  if (rootLog !== void 0 && rootLog.length !== rootMark && chunks.length > 0) {
+    const start = chunks[0].start;
+    const end = chunks[chunks.length - 1].end;
+    for (let offset = rootMark; offset < rootLog.length; offset += 5) {
+      rootLog[offset] = start;
+      rootLog[offset + 1] = end;
     }
-  };
+  }
 }
-
-// src/combinators/choice.ts
-function choice(...args) {
-  const parsers = args.map((a) => "gate" in a ? a.combinator : a);
-  const gates = args.map((a) => "gate" in a ? a.gate : null);
-  const hasGates = gates.some((g) => g !== null);
-  const disjoint = areDisjoint(parsers.map((p) => p._meta.firstSet)) && parsers.every((p) => !matchesEmpty(p));
-  let combined = { kind: "empty" };
-  for (const p of parsers) combined = union(combined, p._meta.firstSet);
-  const meta = {
-    firstSet: combined,
-    canMatchNewline: parsers.some((p) => p._meta.canMatchNewline),
-    isTrivia: false,
-    disjoint
-  };
-  const strategy = disjoint || hasGates ? null : detectStrategy(parsers);
-  const autoNot = !disjoint && !hasGates && (strategy?.tag === "firstMatch" || strategy?.tag === "sharedPrefix") ? computeAutoNot(parsers) : parsers.map(() => null);
-  let greedyLitMap = null;
-  let sortedParsers = null;
-  const asciiDispatch = disjoint ? buildAsciiDispatch(parsers) : null;
-  if (strategy?.tag === "greedyClassify") {
-    greedyLitMap = /* @__PURE__ */ new Map();
-    for (let i = 0; i < parsers.length; i++) {
-      if (i === strategy.superIndex) continue;
-      const litVal = getCoreLiteralValue(parsers[i]);
-      if (litVal !== null) greedyLitMap.set(litVal, i);
-    }
-  } else if (strategy?.tag === "literalsLongestFirst") {
-    sortedParsers = strategy.sortedIndices.map((i) => parsers[i]);
+function triviaKindMask(labels, keep) {
+  if (!labels) return void 0;
+  let mask = 0;
+  for (const name of keep) {
+    const idx = labels.indexOf(name);
+    if (idx >= 0) mask |= 1 << idx;
+  }
+  return mask;
+}
+
+// src/combinators/grammar.ts
+function annotateResultLines(result, index) {
+  const annotated = { ...result, span: annotateSpan(result.span, index) };
+  const errors = annotated.errors;
+  if (errors) {
+    ;
+    annotated.errors = errors.map((error) => ({
+      ...error,
+      span: annotateSpan(error.span, index)
+    }));
+  }
+  return annotated;
+}
+function createParseLineContext(input, pos) {
+  const lineIndex = createLineIndex();
+  if (pos > 0) recordLineRange(lineIndex, input, 0, pos);
+  return { lineIndex, lineScannedTo: pos };
+}
+function parser(opts, root) {
+  const clearTrivia = opts.trivia === null;
+  const opaqueRootCapture = opts.rootCapture === "opaque";
+  if (opaqueRootCapture && opts.trivia === void 0) {
+    throw new TypeError("parser({ rootCapture: 'opaque' }) requires an explicit trivia scope.");
   }
   return {
-    _tag: "choice",
-    _meta: meta,
+    _tag: "grammar",
+    _meta: {
+      ...root._meta,
+      // Trivia classification describes this grammar's own active trivia
+      // scope. A directly nested grammar may have classified trivia of its
+      // own, but that must not advertise classification for this wrapper.
+      triviaKindLabels: void 0,
+      rootTriviaClassified: void 0,
+      ...opts.trivia?._meta?.triviaKindLabels ? { triviaKindLabels: opts.trivia._meta.triviaKindLabels } : {},
+      ...opts.trivia?._meta?.rootTriviaClassified ? { rootTriviaClassified: true } : {}
+    },
     _def: {
-      tag: "choice",
-      parsers,
-      gates,
-      disjoint,
-      strategy: strategy ?? { tag: "firstMatch" },
-      autoNot
+      tag: "grammar",
+      parser: root,
+      triviaParser: clearTrivia ? void 0 : opts.trivia ?? void 0,
+      clearTrivia,
+      ...opaqueRootCapture ? { rootCapture: "opaque" } : {},
+      ...opts.captureTrivia ? { captureTrivia: true } : {},
+      trackLines: opts.trackLines ?? false
     },
-    parse(input, pos, ctx) {
-      const expected = [];
-      if (disjoint && pos < input.length) {
-        const code = input.codePointAt(pos);
-        let idx = code < 128 ? asciiDispatch[code] : -1;
-        if (idx < 0) {
-          for (let i = 0; i < parsers.length; i++) {
-            if (inFirstSet(code, parsers[i]._meta.firstSet)) {
-              idx = i;
-              break;
-            }
-          }
-        }
-        if (idx >= 0) {
-          const gate = gates[idx];
-          if (gate && !gate(ctx.state)) {
-            return { ok: false, expected: deriveExpected(parsers[idx]), span: { start: pos, end: pos } };
-          }
-          const result = parsers[idx].parse(input, pos, ctx);
-          if (result.ok) return result;
-          expected.push(...result.expected);
-          if (result.committed) return { ok: false, expected, span: { start: pos, end: pos }, committed: true };
-          return { ok: false, expected, span: { start: pos, end: pos } };
-        }
-        return {
-          ok: false,
-          expected: parsers.flatMap((p) => {
-            const r = p.parse(input, pos, ctx);
-            return r.ok ? [] : r.expected;
-          }),
-          span: { start: pos, end: pos }
-        };
-      }
-      if (strategy?.tag === "greedyClassify") {
-        const superResult = parsers[strategy.superIndex].parse(input, pos, ctx);
-        if (!superResult.ok) return superResult;
-        const end = superResult.span.end;
-        const litIdx = greedyLitMap.get(input.slice(pos, end));
-        if (litIdx !== void 0) {
-          const litVal = getCoreLiteralValue(parsers[litIdx]);
-          const value = applyTransforms(parsers[litIdx], litVal, { start: pos, end });
-          return { ok: true, value, span: { start: pos, end } };
-        }
-        return superResult;
-      }
-      if (strategy?.tag === "literalsLongestFirst") {
-        for (const p of sortedParsers) {
-          const r = p.parse(input, pos, ctx);
-          if (r.ok) return r;
-          expected.push(...r.expected);
-        }
-        return { ok: false, expected, span: { start: pos, end: pos } };
+    parse(input, pos, _ctx) {
+      if (_ctx?._rootTriviaStrictScopes && opts.trivia !== void 0 && opts.trivia !== null && !opts.trivia._meta.rootTriviaClassified && !opaqueRootCapture) {
+        throw new TypeError(
+          "parser(): selected root trivia requires classifiedTrivia() for every local trivia scope, or rootCapture: 'opaque'."
+        );
       }
-      for (let i = 0; i < parsers.length; i++) {
-        if (gates[i] && !gates[i](ctx.state)) continue;
-        const mark = saveCstMark(ctx);
-        const logLen = ctx._triviaLog?.length;
-        const result = parsers[i].parse(input, pos, ctx);
-        if (!result.ok) {
-          rollbackCstCapture(ctx, mark);
-          if (logLen !== void 0 && ctx._triviaLog && ctx._triviaLog.length !== logLen) ctx._triviaLog.length = logLen;
-          expected.push(...result.expected);
-          if (result.committed) return { ok: false, expected, span: result.span, committed: true };
-          continue;
-        }
-        const checks = autoNot[i];
-        if (checks && autoNotFires(input, result.span.end, checks)) {
-          rollbackCstCapture(ctx, mark);
-          if (logLen !== void 0 && ctx._triviaLog && ctx._triviaLog.length !== logLen) ctx._triviaLog.length = logLen;
-          continue;
-        }
-        return result;
+      const trackLines = opts.trackLines ?? _ctx?.trackLines ?? false;
+      const lineContext = trackLines && _ctx?._lineIndex === void 0 && _ctx?._lineStarts === void 0 ? createParseLineContext(input, pos ?? 0) : void 0;
+      const lineIndex = trackLines ? _ctx?._lineIndex ?? (_ctx?._lineStarts ? { lineStarts: _ctx._lineStarts } : lineContext.lineIndex) : void 0;
+      const ctx = {
+        ..._ctx,
+        trackLines,
+        ...lineIndex ? { _lineIndex: lineIndex } : {},
+        ...lineContext ? { _lineScannedTo: lineContext.lineScannedTo } : {},
+        // trivia: null clears (contiguous terms); a Combinator sets; undefined inherits.
+        ...clearTrivia ? {
+          trivia: void 0,
+          triviaKindLabels: void 0
+        } : opts.trivia != null ? {
+          trivia: opts.trivia,
+          ...opts.trivia._meta.triviaKindLabels ? { triviaKindLabels: opts.trivia._meta.triviaKindLabels } : {}
+        } : {},
+        ...opts.captureTrivia || _ctx?.captureTrivia ? { captureTrivia: true } : {},
+        // Kind-filter for per-node capture. Resolve against this scope's trivia
+        // labels — this parser's own trivia if it declares one, else the INHERITED
+        // labels (`_ctx.triviaKindLabels`), so captureTriviaKinds still applies when
+        // trivia is inherited rather than re-declared here. No labels → undefined
+        // (capture all).
+        ...opts.captureTriviaKinds && !clearTrivia ? { _triviaCaptureMask: triviaKindMask(opts.trivia?._meta.triviaKindLabels ?? _ctx?.triviaKindLabels, opts.captureTriviaKinds) } : {},
+        // This is a property of the local trivia scope, not a post-parse filter:
+        // nested recognition can still skip its trivia, but selected root rows
+        // must never be written for an explicitly opaque region.
+        ...opaqueRootCapture ? { _rootTriviaCapture: false } : {}
+      };
+      const result = root.parse(input, pos ?? 0, ctx);
+      if (trackLines && _ctx && ctx._lineScannedTo !== void 0) {
+        _ctx._lineScannedTo = Math.max(_ctx._lineScannedTo ?? 0, ctx._lineScannedTo);
       }
-      return { ok: false, expected, span: { start: pos, end: pos } };
+      return lineIndex ? annotateResultLines(result, normalizeLineIndex(lineIndex)) : result;
     }
   };
 }
-function detectStrategy(parsers) {
-  const regexIndices = [];
-  const literalIndices = [];
-  for (let i = 0; i < parsers.length; i++) {
-    if (getCoreRegexDef(parsers[i]) !== null) regexIndices.push(i);
-    else if (getCoreLiteralValue(parsers[i]) !== null) literalIndices.push(i);
+
+// src/cst/reflection.ts
+var GRAMMAR_REFLECTION = /* @__PURE__ */ Symbol.for("parseman.grammarReflection");
+function childrenOf(def) {
+  switch (def.tag) {
+    case "sequence":
+    case "choice":
+      return def.parsers;
+    case "dispatch":
+      return [
+        def.selector,
+        ...def.cases.map((c) => c.parser),
+        ...def.matchers ? def.matchers.map((c) => c.parser) : [],
+        ...def.otherwise ? [def.otherwise] : []
+      ];
+    case "many":
+    case "oneOrMore":
+    case "optional":
+    case "attempt":
+    case "transform":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "label":
+    case "field":
+    case "not":
+    case "peek":
+    case "node":
+    case "withCtx":
+    case "recover":
+    case "expect":
+      return [def.parser];
+    case "grammar":
+      return def.triviaParser ? [def.parser, def.triviaParser] : [def.parser];
+    case "sepBy":
+      return [def.parser, def.separator];
+    case "skip":
+      return [def.main, def.skipped];
+    case "scanTo":
+      return [def.sentinel, ...def.skip];
+    case "literal":
+    case "regex":
+    case "keywords":
+    case "routed":
+    case "guard":
+    case "lazy":
+    case "unknown":
+      return [];
   }
-  if (regexIndices.length === 1 && literalIndices.length === parsers.length - 1 && literalIndices.length > 0) {
-    const superIndex = regexIndices[0];
-    const regexDef = getCoreRegexDef(parsers[superIndex]);
-    const flags = "y" + regexDef.flags.replace(/[gy]/g, "");
-    const re = new RegExp(regexDef.source, flags);
-    const allSubsumed = literalIndices.every((i) => {
-      const litVal = getCoreLiteralValue(parsers[i]);
-      re.lastIndex = 0;
-      const m = re.exec(litVal);
-      return m !== null && m[0] === litVal;
-    });
-    if (allSubsumed) return { tag: "greedyClassify", superIndex };
+}
+function addNode(out, def) {
+  if (def.type === void 0) return;
+  const existing = out.get(def.type);
+  if (existing === void 0) {
+    out.set(def.type, def.tags === void 0 ? [] : [...def.tags]);
+    return;
   }
-  if (parsers.length === literalIndices.length) {
-    const sortedIndices = [...literalIndices].sort(
-      (a, b) => getCoreLiteralValue(parsers[b]).length - getCoreLiteralValue(parsers[a]).length
-    );
-    return { tag: "literalsLongestFirst", sortedIndices };
+  if (def.tags === void 0) return;
+  for (const tag of def.tags) {
+    if (!existing.includes(tag)) existing.push(tag);
   }
-  const shared = detectSharedPrefix(parsers);
-  if (shared !== null) return shared;
-  return { tag: "firstMatch" };
-}
-function bareLeadingTermKey(term) {
-  const d = term._def;
-  if (d.tag === "literal" && !d.caseInsensitive) return `L:${d.value}`;
-  if (d.tag === "regex") return `R:${d.source}\0${d.flags}`;
-  return null;
 }
-function detectSharedPrefix(parsers) {
-  if (parsers.length < 2) return null;
-  let key = null;
-  let prefix = null;
-  const members = [];
-  for (let i = 0; i < parsers.length; i++) {
-    const term0 = leadingTermOfArm(parsers[i]);
-    if (term0 === null) return null;
-    const k = bareLeadingTermKey(term0);
-    if (k === null) return null;
-    if (key === null) {
-      key = k;
-      prefix = term0;
-    } else if (k !== key) return null;
-    members.push(i);
+function collectFromCombinator(parser2, out, seen, followLazy = true) {
+  if (seen.has(parser2)) return;
+  seen.add(parser2);
+  const def = parser2._def;
+  if (def.tag === "lazy") {
+    if (followLazy) {
+      try {
+        collectFromCombinator(def.thunk(), out, seen, followLazy);
+      } catch {
+      }
+    }
+    return;
   }
-  if (prefix === null || members.length < 2) return null;
-  return { tag: "sharedPrefix", prefix, members };
+  if (def.tag === "node") addNode(out, def);
+  for (const child of childrenOf(def)) collectFromCombinator(child, out, seen, followLazy);
 }
-function leadingTermOfArm(arm) {
-  let d = arm._def;
-  for (; ; ) {
-    if (d.tag === "node" || d.tag === "grammar" || d.tag === "transform" || d.tag === "label") {
-      d = d.parser._def;
+function collectGrammarReflection(ruleMap, opts) {
+  const byType = /* @__PURE__ */ new Map();
+  const followLazy = opts?.followLazy !== false;
+  for (const [, rule] of ruleMap) {
+    if (!followLazy && rule._def.tag === "lazy") {
+      try {
+        const resolved = rule._def.thunk();
+        if (resolved._def.tag !== "lazy") collectFromCombinator(resolved, byType, /* @__PURE__ */ new Set(), false);
+      } catch {
+      }
       continue;
     }
-    break;
+    collectFromCombinator(rule, byType, /* @__PURE__ */ new Set(), followLazy);
   }
-  if (d.tag !== "sequence" || d.parsers.length < 2) return null;
-  return d.parsers[0];
+  return { nodes: [...byType].map(([type, tags]) => ({ type, tags })) };
 }
-function computeAutoNot(parsers) {
-  return parsers.map((p, i) => {
-    const litVal = getCoreLiteralValue(p);
-    if (litVal === null) return null;
-    const checks = [];
-    for (let j2 = i + 1; j2 < parsers.length; j2++) {
-      const other = parsers[j2];
-      const otherLit = getCoreLiteralValue(other);
-      if (otherLit !== null && otherLit.startsWith(litVal) && otherLit.length > litVal.length) {
-        checks.push({ kind: "startsWith", value: otherLit.slice(litVal.length) });
-        continue;
-      }
-      const regexDef = getCoreRegexDef(other);
-      if (regexDef !== null) {
-        const contSet = continuationFirstSet(litVal, regexDef.source, regexDef.flags);
-        if (contSet !== null) checks.push({ kind: "firstSet", set: contSet });
+function attachGrammarReflection(grammar, reflection) {
+  Object.defineProperty(grammar, GRAMMAR_REFLECTION, { value: reflection, enumerable: false, configurable: true });
+  return grammar;
+}
+
+// src/combinators/parser.ts
+var RULE_ORDER = "__parsemanRuleOrder";
+function tagRule(r, key) {
+  ;
+  r._ruleName = key;
+  if (r._def.tag === "node" && r._def.type === void 0) r._def.type = key;
+}
+function isDefinableRef(v) {
+  return !!v && typeof v === "object" && "_def" in v && v._def.tag === "lazy" && typeof v.define === "function";
+}
+function ruleNameOf(r) {
+  return r._ruleName;
+}
+function isNamedRuleRefForAnotherRule(r, key) {
+  const name = r._def.tag === "lazy" ? ruleNameOf(r) : void 0;
+  return name !== void 0 && name !== key;
+}
+function rules(a, b) {
+  const factory = typeof a === "function" ? a : b;
+  const options = typeof a === "function" ? b : a;
+  const cache = {};
+  const proxy = new Proxy(cache, {
+    get(target, key) {
+      if (typeof key !== "string") return void 0;
+      const record = target;
+      if (!(key in record)) {
+        const r = ref();
+        tagRule(r, key);
+        record[key] = r;
       }
+      return record[key];
     }
-    return checks.length > 0 ? checks : null;
   });
-}
-function autoNotFires(input, end, checks) {
-  for (const check of checks) {
-    if (check.kind === "firstSet") {
-      const code = end < input.length ? input.codePointAt(end) ?? -1 : -1;
-      if (inFirstSet(code, check.set)) return true;
+  const definitions = factory(proxy);
+  for (const key of Object.keys(definitions)) {
+    const placeholder = cache[key];
+    const parser2 = definitions[key];
+    if (placeholder === parser2) {
+      throw new Error(`rules(): rule "${key}" cannot be a direct alias to itself`);
+    }
+    if (isDefinableRef(placeholder)) {
+      if (!isNamedRuleRefForAnotherRule(parser2, key)) tagRule(parser2, key);
+      placeholder.define(parser2);
+      placeholder._meta.firstSet = parser2._meta.firstSet;
+      placeholder._meta.canMatchNewline = parser2._meta.canMatchNewline;
+    } else if (isNamedRuleRefForAnotherRule(parser2, key)) {
+      const alias = ref();
+      tagRule(alias, key);
+      alias.define(parser2);
+      alias._meta.firstSet = parser2._meta.firstSet;
+      alias._meta.canMatchNewline = parser2._meta.canMatchNewline;
+      cache[key] = alias;
     } else {
-      if (input.startsWith(check.value, end)) return true;
+      tagRule(parser2, key);
+      cache[key] = parser2;
     }
   }
-  return false;
-}
-function getCoreLiteralValue(p) {
-  const def = p._def;
-  if (def.tag === "literal" && !def.caseInsensitive) return def.value;
-  if (def.tag === "transform") return getCoreLiteralValue(def.parser);
-  return null;
-}
-function getCoreRegexDef(p) {
-  const def = p._def;
-  if (def.tag === "regex") return { source: def.source, flags: def.flags };
-  if (def.tag === "transform") return getCoreRegexDef(def.parser);
-  if (def.tag === "label") return getCoreRegexDef(def.parser);
-  return null;
-}
-function applyTransforms(p, value, span) {
-  const def = p._def;
-  if (def.tag === "transform") {
-    const inner = applyTransforms(def.parser, value, span);
-    return def.fn(inner, span);
+  if (options?.trivia != null) {
+    for (const key of Object.keys(definitions)) {
+      const rule = cache[key];
+      if (rule && !rule._meta.isTrivia) rule._meta.grammarTrivia = options.trivia;
+    }
   }
-  return value;
-}
-function continuationFirstSet(lit, source, flags) {
-  const re = new RegExp(source, "y" + flags.replace(/[gy]/g, ""));
-  re.lastIndex = 0;
-  const base = re.exec(lit);
-  if (!base || base[0] !== lit) return null;
-  const contCodes = [];
-  for (let code = 1; code < 128; code++) {
-    re.lastIndex = 0;
-    const m = re.exec(lit + String.fromCharCode(code));
-    if (m && m[0].length > lit.length) contCodes.push(code);
+  if (options?.scanSkip != null) {
+    for (const key of Object.keys(definitions)) {
+      const rule = cache[key];
+      if (rule && !rule._meta.isTrivia) rule._meta.grammarScanSkip = options.scanSkip;
+    }
   }
-  if (contCodes.length === 0) return null;
-  return codesToFirstSet(contCodes);
-}
-function codesToFirstSet(codes) {
-  codes.sort((a, b) => a - b);
-  const ranges = [];
-  let lo = codes[0], hi = codes[0];
-  for (let i = 1; i < codes.length; i++) {
-    if (codes[i] === hi + 1) {
-      hi = codes[i];
-    } else {
-      ranges.push({ lo, hi });
-      lo = hi = codes[i];
+  if (options?.hostMode === "cst") {
+    for (const key of Object.keys(definitions)) {
+      const rule = cache[key];
+      if (rule && !rule._meta.isTrivia) rule._meta.grammarHostMode = "cst";
     }
   }
-  ranges.push({ lo, hi });
-  return { kind: "ranges", ranges };
-}
-function inFirstSet(code, fs) {
-  if (fs.kind === "any") return true;
-  if (fs.kind === "empty") return false;
-  for (const r of fs.ranges) if (code >= r.lo && code <= r.hi) return true;
-  return false;
-}
-function areDisjoint(sets) {
-  if (sets.some((s) => s.kind === "any")) return false;
-  for (let i = 0; i < sets.length; i++)
-    for (let j2 = i + 1; j2 < sets.length; j2++)
-      if (intersects(sets[i], sets[j2])) return false;
-  return true;
-}
-function buildAsciiDispatch(parsers) {
-  const table = Array(128).fill(-1);
-  for (let i = 0; i < parsers.length; i++) {
-    const fs = parsers[i]._meta.firstSet;
-    if (fs.kind !== "ranges") continue;
-    for (const { lo, hi } of fs.ranges) {
-      for (let code = Math.max(0, lo); code <= Math.min(127, hi); code++) {
-        table[code] = i;
+  if (options?.trackLines === true) {
+    for (const key of Object.keys(definitions)) {
+      const rule = cache[key];
+      if (rule && !rule._meta.isTrivia) rule._meta.grammarTrackLines = true;
+    }
+    for (const key of Object.keys(definitions)) {
+      const rule = cache[key];
+      if (rule && !rule._meta.isTrivia && rule._def.tag !== "grammar") {
+        const wrapped = parser({ trackLines: true }, rule);
+        tagRule(wrapped, key);
+        wrapped._meta.grammarTrackLines = true;
+        cache[key] = wrapped;
       }
     }
   }
-  return table;
+  for (const key of Object.keys(definitions)) {
+    markUnusedValues(cache[key]);
+  }
+  Object.defineProperty(cache, RULE_ORDER, {
+    value: Object.keys(definitions),
+    enumerable: false,
+    configurable: true
+  });
+  attachGrammarReflection(cache, collectGrammarReflection(Object.keys(definitions).map((key) => [key, cache[key]])));
+  return cache;
 }
 
-// src/cst/trivia-kinds.ts
-function unwrapTrivia(p) {
-  let cur = p;
-  while (cur._def.tag === "trivia") cur = cur._def.parser;
-  return cur;
-}
-function peelLabel(p) {
-  if (p._def.tag === "label") return { label: p._def.label, parser: p._def.parser };
-  return null;
-}
-function analyzeLabeledTrivia(trivia2) {
-  let core = unwrapTrivia(trivia2);
-  let minRepeats = 1;
-  if (core._def.tag === "oneOrMore") {
-    core = core._def.parser;
-    minRepeats = 1;
-  } else if (core._def.tag === "many") {
-    core = core._def.parser;
-    minRepeats = 0;
-  }
-  const arms = [];
-  if (core._def.tag === "choice") {
-    for (let i = 0; i < core._def.parsers.length; i++) {
-      const peeled = peelLabel(core._def.parsers[i]);
-      if (!peeled) return null;
-      arms.push({ label: peeled.label, kindIndex: i, parser: peeled.parser });
-    }
-  } else {
-    const peeled = peelLabel(core);
-    if (!peeled) return null;
-    arms.push({ label: peeled.label, kindIndex: 0, parser: peeled.parser });
+// src/recovery/scan.ts
+function probeAt(sentinel, input, pos, ctx) {
+  const s = {
+    _probe: ctx._probe,
+    _errors: ctx._errors,
+    _cstLeaves: ctx._cstLeaves,
+    _cstChildren: ctx._cstChildren,
+    _cstRawChildren: ctx._cstRawChildren,
+    _cstTriviaLog: ctx._cstTriviaLog,
+    _triviaLog: ctx._triviaLog,
+    _rootTriviaLog: ctx._rootTriviaLog,
+    _fields: ctx._fields,
+    _cstBuf: ctx._cstBuf,
+    _tolerant: ctx._tolerant,
+    _sync: ctx._sync
+  };
+  ctx._probe = void 0;
+  ctx._errors = void 0;
+  ctx._cstLeaves = void 0;
+  ctx._cstChildren = void 0;
+  ctx._cstRawChildren = void 0;
+  ctx._cstTriviaLog = void 0;
+  ctx._triviaLog = void 0;
+  ctx._rootTriviaLog = void 0;
+  ctx._fields = void 0;
+  ctx._cstBuf = void 0;
+  ctx._tolerant = void 0;
+  ctx._sync = void 0;
+  try {
+    return sentinel.parse(input, pos, ctx).ok;
+  } finally {
+    ctx._probe = s._probe;
+    ctx._errors = s._errors;
+    ctx._cstLeaves = s._cstLeaves;
+    ctx._cstChildren = s._cstChildren;
+    ctx._cstRawChildren = s._cstRawChildren;
+    ctx._cstTriviaLog = s._cstTriviaLog;
+    ctx._triviaLog = s._triviaLog;
+    ctx._rootTriviaLog = s._rootTriviaLog;
+    ctx._fields = s._fields;
+    ctx._cstBuf = s._cstBuf;
+    ctx._tolerant = s._tolerant;
+    ctx._sync = s._sync;
   }
-  return { labels: arms.map((a) => a.label), arms, minRepeats };
-}
-function matchArmAt(input, pos, arm) {
-  const r = arm.parse(input, pos, { trackLines: false });
-  if (!r.ok || r.span.end <= pos) return null;
-  return { end: r.span.end };
 }
-function scanLabeledTriviaChunks(input, cur, spec) {
-  const chunks = [];
-  let pos = cur;
-  while (pos < input.length) {
-    let matched = null;
-    for (const arm of spec.arms) {
-      const m = matchArmAt(input, pos, arm.parser);
-      if (m) {
-        matched = { end: m.end, kindIndex: arm.kindIndex };
-        break;
-      }
+function orSentinel(a, b) {
+  if (b === void 0) return a;
+  return {
+    _tag: "orSentinel",
+    _meta: { firstSet: { kind: "any" }, canMatchNewline: false, isTrivia: false },
+    _def: { tag: "unknown" },
+    parse(input, pos, ctx) {
+      const ra = a.parse(input, pos, ctx);
+      if (ra.ok) return ra;
+      return b.parse(input, pos, ctx);
     }
-    if (!matched) break;
-    chunks.push({ start: pos, end: matched.end, kindIndex: matched.kindIndex });
-    pos = matched.end;
-  }
-  if (chunks.length < spec.minRepeats) {
-    return { end: cur, chunks: [] };
-  }
-  return { end: pos, chunks };
+  };
 }
-function scanFastWsCommentsChunks(input, cur, wsKind, commentKind) {
-  const chunks = [];
-  let pos = cur;
-  while (pos < input.length) {
-    const c = input.charCodeAt(pos);
-    if (c === 32 || c === 9 || c === 10 || c === 13 || c === 12) {
-      const start = pos;
-      pos++;
-      while (pos < input.length) {
-        const c2 = input.charCodeAt(pos);
-        if (c2 === 32 || c2 === 9 || c2 === 10 || c2 === 13 || c2 === 12) pos++;
-        else break;
-      }
-      chunks.push({ start, end: pos, kindIndex: wsKind });
-      continue;
-    }
-    if (c === 47 && input.charCodeAt(pos + 1) === 42) {
-      let j2 = pos + 2;
-      while (j2 + 1 < input.length && !(input.charCodeAt(j2) === 42 && input.charCodeAt(j2 + 1) === 47)) j2++;
-      if (j2 + 1 < input.length && input.charCodeAt(j2) === 42 && input.charCodeAt(j2 + 1) === 47) {
-        const start = pos;
-        pos = j2 + 2;
-        chunks.push({ start, end: pos, kindIndex: commentKind });
-        continue;
+function firstSetSentinel(fs) {
+  if (fs.kind !== "ranges" || fs.ranges.length === 0) return null;
+  const ranges = fs.ranges;
+  return {
+    _tag: "firstSetSentinel",
+    _meta: { firstSet: fs, canMatchNewline: false, isTrivia: false },
+    _def: { tag: "unknown" },
+    parse(input, pos) {
+      const code = pos < input.length ? input.codePointAt(pos) : void 0;
+      if (code !== void 0) {
+        for (const r of ranges) {
+          if (code >= r.lo && code <= r.hi) return { ok: true, value: null, span: { start: pos, end: pos } };
+        }
       }
-      break;
+      return { ok: false, expected: [], span: { start: pos, end: pos } };
     }
-    break;
-  }
-  return { end: pos, chunks };
+  };
 }
-function tryFastLabeledScan(input, cur, trivia2) {
-  const spec = analyzeLabeledTrivia(trivia2);
-  if (!spec || spec.arms.length !== 2) return null;
-  const wsArm = spec.arms.find((a) => {
-    const src = getCoreRegexDef(a.parser)?.source;
-    return src != null && !src.includes("\\*");
-  });
-  const commentArm = spec.arms.find((a) => {
-    const src = getCoreRegexDef(a.parser)?.source;
-    return src != null && src.includes("\\*");
-  });
-  if (!wsArm || !commentArm) return null;
-  const { chunks } = scanFastWsCommentsChunks(input, cur, wsArm.kindIndex, commentArm.kindIndex);
-  if (chunks.length < spec.minRepeats) return { end: cur, chunks: [] };
-  return scanFastWsCommentsChunks(input, cur, wsArm.kindIndex, commentArm.kindIndex);
+function recoverScan(input, from, ctx, sync, expected) {
+  let scanPos = from;
+  while (scanPos < input.length && !probeAt(sync, input, scanPos, ctx)) scanPos++;
+  const span = { start: from, end: scanPos };
+  if (ctx.trackLines) recordLineRangeFromContext(ctx, input, from, scanPos);
+  const error = { _tag: "parseError", span: ctx.trackLines ? annotateSpanFromLineContext(span, ctx) : span, expected };
+  ctx._errors?.push(error);
+  return { error, end: scanPos };
 }
-function recordTriviaChunks(ctx, chunks) {
-  const kinds = ctx.triviaKindLabels;
-  const mask = ctx._triviaCaptureMask;
-  for (const ch of chunks) {
-    pushTriviaLogEntry(ctx, ch.start, ch.end, kinds ? ch.kindIndex : void 0);
-    if (ctx.captureTrivia && (ctx._cstBuf !== void 0 || ctx._cstTriviaLog !== void 0)) {
-      if (mask === void 0 || kinds === void 0 || (mask & 1 << ch.kindIndex) !== 0) {
-        pushCstTriviaEntry(ctx, ch.start, ch.end, kinds ? ch.kindIndex : void 0);
-      }
-    }
-  }
+function matchesAt(sentinel, input, pos, ctx) {
+  return probeAt(sentinel, input, pos, ctx);
 }
-function triviaKindMask(labels, keep) {
-  if (!labels) return void 0;
-  let mask = 0;
-  for (const name of keep) {
-    const idx = labels.indexOf(name);
-    if (idx >= 0) mask |= 1 << idx;
-  }
-  return mask;
+function captureError(ctx, error) {
+  if (cstCaptureActive(ctx)) pushCstChild(ctx, error, error);
 }
 
-// src/combinators/grammar.ts
-function annotateResultLines(result, index) {
-  const annotated = { ...result, span: annotateSpan(result.span, index) };
-  const errors = annotated.errors;
-  if (errors) {
-    ;
-    annotated.errors = errors.map((error) => ({
-      ...error,
-      span: annotateSpan(error.span, index)
-    }));
-  }
-  return annotated;
-}
-function createParseLineContext(input, pos) {
-  const lineIndex = createLineIndex();
-  if (pos > 0) recordLineRange(lineIndex, input, 0, pos);
-  return { lineIndex, lineScannedTo: pos };
-}
-function parser(opts, root) {
-  const clearTrivia = opts.trivia === null;
-  return {
-    _tag: "grammar",
-    _meta: root._meta,
-    _def: {
-      tag: "grammar",
-      parser: root,
-      triviaParser: clearTrivia ? void 0 : opts.trivia ?? void 0,
-      clearTrivia,
-      ...opts.captureTrivia ? { captureTrivia: true } : {},
-      trackLines: opts.trackLines ?? false
-    },
-    parse(input, pos, _ctx) {
-      const trackLines = opts.trackLines ?? _ctx?.trackLines ?? false;
-      const lineContext = trackLines && _ctx?._lineIndex === void 0 && _ctx?._lineStarts === void 0 ? createParseLineContext(input, pos ?? 0) : void 0;
-      const lineIndex = trackLines ? _ctx?._lineIndex ?? (_ctx?._lineStarts ? { lineStarts: _ctx._lineStarts } : lineContext.lineIndex) : void 0;
-      const ctx = {
-        ..._ctx,
-        trackLines,
-        ...lineIndex ? { _lineIndex: lineIndex } : {},
-        ...lineContext ? { _lineScannedTo: lineContext.lineScannedTo } : {},
-        // trivia: null clears (contiguous terms); a Combinator sets; undefined inherits.
-        ...clearTrivia ? {
-          trivia: void 0,
-          triviaKindLabels: void 0
-        } : opts.trivia != null ? {
-          trivia: opts.trivia,
-          ...opts.trivia._meta.triviaKindLabels ? { triviaKindLabels: opts.trivia._meta.triviaKindLabels } : {}
-        } : {},
-        ...opts.captureTrivia || _ctx?.captureTrivia ? { captureTrivia: true } : {},
-        // Kind-filter for per-node capture. Resolve against this scope's trivia
-        // labels — this parser's own trivia if it declares one, else the INHERITED
-        // labels (`_ctx.triviaKindLabels`), so captureTriviaKinds still applies when
-        // trivia is inherited rather than re-declared here. No labels → undefined
-        // (capture all).
-        ...opts.captureTriviaKinds && !clearTrivia ? { _triviaCaptureMask: triviaKindMask(opts.trivia?._meta.triviaKindLabels ?? _ctx?.triviaKindLabels, opts.captureTriviaKinds) } : {}
-      };
-      const result = root.parse(input, pos ?? 0, ctx);
-      if (trackLines && _ctx && ctx._lineScannedTo !== void 0) {
-        _ctx._lineScannedTo = Math.max(_ctx._lineScannedTo ?? 0, ctx._lineScannedTo);
-      }
-      return lineIndex ? annotateResultLines(result, normalizeLineIndex(lineIndex)) : result;
-    }
-  };
+// src/combinators/expect.ts
+function deriveExpected(c) {
+  return [...new Set(derive(c, /* @__PURE__ */ new Set()))];
 }
-
-// src/cst/reflection.ts
-var GRAMMAR_REFLECTION = /* @__PURE__ */ Symbol.for("parseman.grammarReflection");
-function childrenOf(def) {
+function derive(c, seen) {
+  const deriveExpected2 = (p) => derive(p, seen);
+  const def = c._def;
   switch (def.tag) {
-    case "sequence":
+    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;
+      return def.parsers.flatMap(deriveExpected2);
     case "dispatch":
-      return [
-        def.selector,
-        ...def.cases.map((c) => c.parser),
-        ...def.matchers ? def.matchers.map((c) => c.parser) : [],
-        ...def.otherwise ? [def.otherwise] : []
-      ];
-    case "many":
-    case "oneOrMore":
-    case "optional":
+      return deriveExpected2(def.selector);
+    // Union through the NULLABLE prefix, mirroring `sequenceFirstSet`. A leading
+    // `optional(…)`/`many(…)` can match nothing, so the term after it is equally
+    // able to fail first — deriving from term 0 alone named a token the parse
+    // never actually required. A leading `not(…)` is zero-width and contributes
+    // nothing (its own expectation is about what must NOT be here), but it is
+    // nullable, so keep scanning past it. Stop at the first term that must match.
+    case "sequence": {
+      const out = [];
+      for (const term of def.parsers) {
+        if (!isZeroWidthAssertion(term)) out.push(...deriveExpected2(term));
+        if (!matchesEmpty(term)) break;
+      }
+      return out;
+    }
     case "attempt":
-    case "transform":
-    case "trivia":
-    case "token":
-    case "leaf":
-    case "label":
+      return deriveExpected2(def.parser);
+    // Delegating wrappers whose first-token failure is their inner parser's — must
+    // pass through so a start-failure (and the first-set-miss fast-path in attempt/
+    // node, which reads this) names the real expected token, not the wrapper tag.
     case "field":
-    case "not":
-    case "peek":
-    case "node":
     case "withCtx":
     case "recover":
-    case "expect":
-      return [def.parser];
-    case "grammar":
-      return def.triviaParser ? [def.parser, def.triviaParser] : [def.parser];
-    case "sepBy":
-      return [def.parser, def.separator];
+      return deriveExpected2(def.parser);
     case "skip":
-      return [def.main, def.skipped];
-    case "scanTo":
-      return [def.sentinel, ...def.skip];
-    case "literal":
-    case "regex":
-    case "keywords":
+      return deriveExpected2(def.main);
+    case "expect":
+      return def.expected;
+    case "node":
+    case "grammar":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "optional":
+    case "many":
+    case "oneOrMore":
+    case "transform":
+    case "not":
+    case "peek":
+      return deriveExpected2(def.parser);
     case "routed":
-    case "guard":
-    case "lazy":
-    case "unknown":
-      return [];
-  }
-}
-function addNode(out, def) {
-  if (def.type === void 0) return;
-  const existing = out.get(def.type);
-  if (existing === void 0) {
-    out.set(def.type, def.tags === void 0 ? [] : [...def.tags]);
-    return;
-  }
-  if (def.tags === void 0) return;
-  for (const tag of def.tags) {
-    if (!existing.includes(tag)) existing.push(tag);
-  }
-}
-function collectFromCombinator(parser2, out, seen, followLazy = true) {
-  if (seen.has(parser2)) return;
-  seen.add(parser2);
-  const def = parser2._def;
-  if (def.tag === "lazy") {
-    if (followLazy) {
+      return ["routed()"];
+    case "lazy": {
+      const name = c._ruleName;
+      if (seen.has(c)) return name ? [name] : [];
+      seen.add(c);
       try {
-        collectFromCombinator(def.thunk(), out, seen, followLazy);
+        return deriveExpected2(def.thunk());
       } catch {
+        return name ? [name] : [];
+      } finally {
+        seen.delete(c);
       }
     }
-    return;
+    default:
+      return [];
   }
-  if (def.tag === "node") addNode(out, def);
-  for (const child of childrenOf(def)) collectFromCombinator(child, out, seen, followLazy);
 }
-function collectGrammarReflection(ruleMap, opts) {
-  const byType = /* @__PURE__ */ new Map();
-  const followLazy = opts?.followLazy !== false;
-  for (const [, rule] of ruleMap) {
-    if (!followLazy && rule._def.tag === "lazy") {
-      try {
-        const resolved = rule._def.thunk();
-        if (resolved._def.tag !== "lazy") collectFromCombinator(resolved, byType, /* @__PURE__ */ new Set(), false);
-      } catch {
-      }
-      continue;
+function expect(combinator, label2) {
+  const expected = label2 !== void 0 ? [label2] : deriveExpected(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 span = { start: pos, end: pos };
+      const error = { _tag: "parseError", span: ctx.trackLines ? annotateSpanFromLineContext(span, ctx) : span, expected };
+      ctx._errors?.push(error);
+      if (ctx._tolerant) captureError(ctx, error);
+      return { ok: true, value: error, span: { start: pos, end: pos } };
     }
-    collectFromCombinator(rule, byType, /* @__PURE__ */ new Set(), followLazy);
-  }
-  return { nodes: [...byType].map(([type, tags]) => ({ type, tags })) };
-}
-function attachGrammarReflection(grammar, reflection) {
-  Object.defineProperty(grammar, GRAMMAR_REFLECTION, { value: reflection, enumerable: false, configurable: true });
-  return grammar;
+  };
 }
 
-// src/combinators/parser.ts
-var RULE_ORDER = "__parsemanRuleOrder";
-function tagRule(r, key) {
-  ;
-  r._ruleName = key;
-  if (r._def.tag === "node" && r._def.type === void 0) r._def.type = key;
-}
-function isDefinableRef(v) {
-  return !!v && typeof v === "object" && "_def" in v && v._def.tag === "lazy" && typeof v.define === "function";
-}
-function ruleNameOf(r) {
-  return r._ruleName;
+// src/regex/classes.ts
+var CLASS_ESCAPES = { t: 9, n: 10, r: 13, f: 12, v: 11, "0": 0 };
+var SPACE_RANGES = [
+  [9, 13],
+  [32, 32],
+  [160, 160],
+  [5760, 5760],
+  [8192, 8202],
+  [8232, 8232],
+  [8233, 8233],
+  [8239, 8239],
+  [8287, 8287],
+  [12288, 12288],
+  [65279, 65279]
+];
+function shorthandRanges(ch) {
+  if (ch === "d") return [[48, 57]];
+  if (ch === "s") return SPACE_RANGES;
+  return [[48, 57], [65, 90], [97, 122], [95, 95]];
 }
-function isNamedRuleRefForAnotherRule(r, key) {
-  const name = r._def.tag === "lazy" ? ruleNameOf(r) : void 0;
-  return name !== void 0 && name !== key;
+function readUnicodeEscape(body, i) {
+  if (body[i] !== "\\" || body[i + 1] !== "u") return null;
+  const hex = body.slice(i + 2, i + 6);
+  if (!/^[0-9a-fA-F]{4}$/.test(hex)) return null;
+  return { cp: Number.parseInt(hex, 16), next: i + 6 };
 }
-function rules(a, b) {
-  const factory = typeof a === "function" ? a : b;
-  const options = typeof a === "function" ? b : a;
-  const cache = {};
-  const proxy = new Proxy(cache, {
-    get(target, key) {
-      if (typeof key !== "string") return void 0;
-      const record = target;
-      if (!(key in record)) {
-        const r = ref();
-        tagRule(r, key);
-        record[key] = r;
+function parseClassRanges(body) {
+  const ranges = [];
+  let i = 0;
+  const readAtom = () => {
+    const ch = body[i];
+    if (ch === void 0) return null;
+    if (ch === "\\") {
+      const uni = readUnicodeEscape(body, i);
+      if (uni) {
+        i = uni.next;
+        return { cp: uni.cp };
       }
-      return record[key];
+      const e = body[i + 1];
+      if (e === void 0) return null;
+      i += 2;
+      if (e in CLASS_ESCAPES) return { cp: CLASS_ESCAPES[e] };
+      if (e === "d" || e === "w" || e === "s") return { set: shorthandRanges(e) };
+      if (e >= "a" && e <= "z" || e >= "A" && e <= "Z") return null;
+      return { cp: e.codePointAt(0) };
     }
-  });
-  const definitions = factory(proxy);
-  for (const key of Object.keys(definitions)) {
-    const placeholder = cache[key];
-    const parser2 = definitions[key];
-    if (placeholder === parser2) {
-      throw new Error(`rules(): rule "${key}" cannot be a direct alias to itself`);
+    i += ch.length;
+    return { cp: ch.codePointAt(0) };
+  };
+  while (i < body.length) {
+    const lo = readAtom();
+    if (lo === null) return null;
+    if ("set" in lo) {
+      ranges.push(...lo.set);
+      continue;
     }
-    if (isDefinableRef(placeholder)) {
-      if (!isNamedRuleRefForAnotherRule(parser2, key)) tagRule(parser2, key);
-      placeholder.define(parser2);
-      placeholder._meta.firstSet = parser2._meta.firstSet;
-      placeholder._meta.canMatchNewline = parser2._meta.canMatchNewline;
-    } else if (isNamedRuleRefForAnotherRule(parser2, key)) {
-      const alias = ref();
-      tagRule(alias, key);
-      alias.define(parser2);
-      alias._meta.firstSet = parser2._meta.firstSet;
-      alias._meta.canMatchNewline = parser2._meta.canMatchNewline;
-      cache[key] = alias;
+    if (body[i] === "-" && body[i + 1] !== void 0 && body[i + 1] !== "]") {
+      i += 1;
+      const hi = readAtom();
+      if (hi === null || "set" in hi) return null;
+      ranges.push([lo.cp, hi.cp]);
     } else {
-      tagRule(parser2, key);
-      cache[key] = parser2;
-    }
-  }
-  if (options?.trivia != null) {
-    for (const key of Object.keys(definitions)) {
-      const rule = cache[key];
-      if (rule && !rule._meta.isTrivia) rule._meta.grammarTrivia = options.trivia;
-    }
-  }
-  if (options?.scanSkip != null) {
-    for (const key of Object.keys(definitions)) {
-      const rule = cache[key];
-      if (rule && !rule._meta.isTrivia) rule._meta.grammarScanSkip = options.scanSkip;
-    }
-  }
-  if (options?.hostMode === "cst") {
-    for (const key of Object.keys(definitions)) {
-      const rule = cache[key];
-      if (rule && !rule._meta.isTrivia) rule._meta.grammarHostMode = "cst";
-    }
-  }
-  if (options?.trackLines === true) {
-    for (const key of Object.keys(definitions)) {
-      const rule = cache[key];
-      if (rule && !rule._meta.isTrivia) rule._meta.grammarTrackLines = true;
-    }
-    for (const key of Object.keys(definitions)) {
-      const rule = cache[key];
-      if (rule && !rule._meta.isTrivia && rule._def.tag !== "grammar") {
-        const wrapped = parser({ trackLines: true }, rule);
-        tagRule(wrapped, key);
-        wrapped._meta.grammarTrackLines = true;
-        cache[key] = wrapped;
-      }
+      ranges.push([lo.cp, lo.cp]);
     }
   }
-  for (const key of Object.keys(definitions)) {
-    markUnusedValues(cache[key]);
-  }
-  Object.defineProperty(cache, RULE_ORDER, {
-    value: Object.keys(definitions),
-    enumerable: false,
-    configurable: true
-  });
-  attachGrammarReflection(cache, collectGrammarReflection(Object.keys(definitions).map((key) => [key, cache[key]])));
-  return cache;
+  return ranges.length ? ranges : null;
 }
 
-// src/analysis/duplication.ts
-var WORD_RE_SRC = "-?[A-Za-z][A-Za-z0-9_-]*";
-var WORDS_RE = new RegExp(`^${WORD_RE_SRC}(?:\\|${WORD_RE_SRC})*$`);
-
-// src/combinators/probe.ts
-function failAt(ctx, expected, pos) {
-  const r = { ok: false, expected, span: { start: pos, end: pos } };
-  const probe = ctx._probe;
-  if (probe !== void 0 && pos <= probe.offset) {
-    const best = probe.best;
-    if (best === null || pos > best.span.start) {
-      probe.best = r;
-    } else if (pos === best.span.start) {
-      probe.best = { ...best, expected: [...best.expected, ...expected] };
-    }
-  }
-  return r;
+// src/combinators/trivia-skip.ts
+var NOOP_COMMIT = () => {
+};
+var fastTriviaCache = /* @__PURE__ */ new WeakMap();
+function needsDeferredTriviaCommit(ctx) {
+  return ctx._triviaLog !== void 0 || ctx._rootTriviaLog !== void 0 || ctx._cstBuf !== void 0 || ctx._cstTriviaLog !== void 0;
 }
-
-// src/combinators/literal.ts
-function asciiFoldEq(a, b) {
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    let ca = a.charCodeAt(i);
-    let cb = b.charCodeAt(i);
-    if (ca >= 65 && ca <= 90) ca += 32;
-    if (cb >= 65 && cb <= 90) cb += 32;
-    if (ca !== cb) return false;
-  }
-  return true;
+function saveTriviaMark(ctx) {
+  const m = saveCstMark(ctx);
+  return {
+    raw: m.raw,
+    tlog: m.tlog,
+    leaves: m.leaves,
+    fields: m.fields,
+    errors: m.errors,
+    log: ctx._triviaLog ? ctx._triviaLog.length : 0,
+    rootLog: ctx._rootTriviaLog ? ctx._rootTriviaLog.length : 0
+  };
 }
-function literal(value, opts = {}) {
-  const caseInsensitive = opts.caseInsensitive ?? false;
-  const firstSet = value.length > 0 ? fromChar(value.codePointAt(0)) : empty();
-  const meta = {
-    firstSet,
-    canMatchNewline: value.includes("\n"),
-    isTrivia: false
+function rollbackTrivia(ctx, mark) {
+  rollbackCstCapture(ctx, { raw: mark.raw, tlog: mark.tlog, leaves: mark.leaves, fields: mark.fields, errors: mark.errors });
+  if (ctx._triviaLog && ctx._triviaLog.length !== mark.log) ctx._triviaLog.length = mark.log;
+  if (ctx._rootTriviaLog && ctx._rootTriviaLog.length !== mark.rootLog) ctx._rootTriviaLog.length = mark.rootLog;
+}
+function parseTriviaNoCapture(triviaP, input, cur, ctx) {
+  const probeCtx = {
+    trackLines: ctx.trackLines,
+    state: ctx.state,
+    ...ctx._lineIndex ? { _lineIndex: ctx._lineIndex } : {},
+    ...ctx._lineStarts ? { _lineStarts: ctx._lineStarts } : {},
+    ...ctx._lineScannedTo !== void 0 ? { _lineScannedTo: ctx._lineScannedTo } : {}
   };
-  const canMatchNewline = meta.canMatchNewline;
-  if (caseInsensitive) {
-    const upper = value.toUpperCase();
-    const lower = value.toLowerCase();
-    const firstUpper = upper.codePointAt(0);
-    const firstLower = lower.codePointAt(0);
-    meta.firstSet = firstLower !== void 0 && firstUpper !== void 0 ? firstLower === firstUpper ? { kind: "ranges", ranges: [{ lo: firstLower, hi: firstLower }] } : { kind: "ranges", ranges: [
-      { lo: firstLower, hi: firstLower },
-      { lo: firstUpper, hi: firstUpper }
-    ] } : firstSet;
-  }
-  const expected = [JSON.stringify(value)];
-  const parse = !caseInsensitive && value.length === 1 ? (() => {
-    const code = value.charCodeAt(0);
-    return function parse2(input, pos, ctx) {
-      if (input.charCodeAt(pos) === code) {
-        const span = { start: pos, end: pos + 1 };
-        if (canMatchNewline && ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, span.end);
-        if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value, span });
-        return { ok: true, value, span };
+  const result = triviaP.parse(input, cur, probeCtx);
+  ctx._lineScannedTo = probeCtx._lineScannedTo;
+  return result;
+}
+function saveLookaheadMark(ctx) {
+  return { ...saveTriviaMark(ctx), probeBest: ctx._probe ? ctx._probe.best : null };
+}
+function rollbackLookahead(ctx, mark) {
+  rollbackTrivia(ctx, mark);
+  if (ctx._probe) ctx._probe.best = mark.probeBest;
+}
+function scanWithLabels(input, cur, ctx) {
+  const triviaP = ctx.trivia;
+  const spec = analyzeLabeledTrivia(triviaP);
+  if (!spec) return { end: cur, commit: NOOP_COMMIT };
+  const log = ctx._triviaLog;
+  const rootLog = ctx._rootTriviaLog;
+  const rootKinds = ctx._rootTriviaKindIndex;
+  const captureTl = ctx.captureTrivia && (ctx._cstBuf !== void 0 || ctx._cstTriviaLog !== void 0);
+  const mask = ctx._triviaCaptureMask;
+  let fullRows;
+  let rootRows;
+  let cstRows;
+  const visitedEnd = visitLabeledTrivia(input, cur, spec, ctx.state, (start, matchEnd, kindIndex) => {
+    if (log !== void 0) (fullRows ??= []).push(start, matchEnd, kindIndex);
+    const selectedKind = rootLog === void 0 || rootKinds === void 0 || ctx._rootTriviaCapture === false ? void 0 : rootKinds[spec.labels[kindIndex] ?? ""];
+    if (selectedKind !== void 0) (rootRows ??= []).push(start, matchEnd, selectedKind);
+    if (captureTl && (mask === void 0 || (mask & 1 << kindIndex) !== 0)) {
+      (cstRows ??= []).push(start, matchEnd, kindIndex);
+    }
+  });
+  if (visitedEnd !== void 0) {
+    if (visitedEnd === cur) return { end: cur, commit: NOOP_COMMIT };
+    return {
+      end: visitedEnd,
+      commit: () => {
+        if (fullRows !== void 0 && log !== void 0) log.push(...fullRows);
+        if (rootRows !== void 0 && rootLog !== void 0) {
+          for (let i = 0; i < rootRows.length; i += 3) {
+            rootLog.push(cur, visitedEnd, rootRows[i], rootRows[i + 1], rootRows[i + 2]);
+          }
+        }
+        if (cstRows !== void 0) {
+          for (let i = 0; i < cstRows.length; i += 3) {
+            pushCstTriviaEntry(ctx, cstRows[i], cstRows[i + 1], cstRows[i + 2]);
+          }
+        }
       }
-      return failAt(ctx, expected, pos);
     };
-  })() : function parse2(input, pos, ctx) {
-    const end = pos + value.length;
-    if (end > input.length) {
-      return failAt(ctx, expected, pos);
-    }
-    const matchedValue = caseInsensitive ? input.slice(pos, end) : value;
-    if (caseInsensitive ? asciiFoldEq(matchedValue, value) : input.startsWith(value, pos)) {
-      const span = { start: pos, end };
-      if (canMatchNewline && ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, end);
-      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value: matchedValue, span });
-      return { ok: true, value: matchedValue, span };
-    }
-    return failAt(ctx, expected, pos);
-  };
+  }
+  const { end, chunks } = scanLabeledTriviaChunks(input, cur, spec, ctx.state);
+  if (end === cur) return { end: cur, commit: NOOP_COMMIT };
   return {
-    _tag: "literal",
-    _meta: meta,
-    _def: { tag: "literal", value, caseInsensitive },
-    parse
+    end,
+    commit: () => recordTriviaChunks(ctx, chunks)
   };
 }
-
-// src/regex/classes.ts
-var CLASS_ESCAPES = { t: 9, n: 10, r: 13, f: 12, v: 11, "0": 0 };
-var SPACE_RANGES = [
-  [9, 13],
-  [32, 32],
-  [160, 160],
-  [5760, 5760],
-  [8192, 8202],
-  [8232, 8232],
-  [8233, 8233],
-  [8239, 8239],
-  [8287, 8287],
-  [12288, 12288],
-  [65279, 65279]
-];
-function shorthandRanges(ch) {
-  if (ch === "d") return [[48, 57]];
-  if (ch === "s") return SPACE_RANGES;
-  return [[48, 57], [65, 90], [97, 122], [95, 95]];
+function skipWithLabels(input, cur, ctx) {
+  const spec = analyzeLabeledTrivia(ctx.trivia);
+  if (spec) return scanLabeledTriviaEnd(input, cur, spec, ctx.state);
+  const tr = parseTriviaNoCapture(ctx.trivia, input, cur, ctx);
+  return tr.ok && tr.span.end > cur ? tr.span.end : cur;
 }
-function readUnicodeEscape(body, i) {
-  if (body[i] !== "\\" || body[i + 1] !== "u") return null;
-  const hex = body.slice(i + 2, i + 6);
-  if (!/^[0-9a-fA-F]{4}$/.test(hex)) return null;
-  return { cp: Number.parseInt(hex, 16), next: i + 6 };
+function advanceTrivia(input, cur, ctx) {
+  const triviaP = ctx.trivia;
+  if (!triviaP) return cur;
+  if (!ctx.trackLines) {
+    const fast2 = fastTriviaScanner(triviaP);
+    if (fast2) return fast2(input, cur);
+    if (ctx.triviaKindLabels) return skipWithLabels(input, cur, ctx);
+    const tr2 = triviaP.parse(input, cur, { trackLines: ctx.trackLines, state: ctx.state });
+    return tr2.ok && tr2.span.end > cur ? tr2.span.end : cur;
+  }
+  const trackTriviaLines = ctx.trackLines && triviaP._meta.canMatchNewline;
+  const fast = fastTriviaScanner(triviaP);
+  if (fast) {
+    const end = fast(input, cur);
+    if (trackTriviaLines) recordLineRangeFromContext(ctx, input, cur, end);
+    return end;
+  }
+  if (ctx.triviaKindLabels) {
+    const end = skipWithLabels(input, cur, ctx);
+    if (trackTriviaLines) recordLineRangeFromContext(ctx, input, cur, end);
+    return end;
+  }
+  const tr = parseTriviaNoCapture(triviaP, input, cur, ctx);
+  return tr.ok && tr.span.end > cur ? tr.span.end : cur;
 }
-function parseClassRanges(body) {
-  const ranges = [];
-  let i = 0;
-  const readAtom = () => {
-    const ch = body[i];
-    if (ch === void 0) return null;
-    if (ch === "\\") {
-      const uni = readUnicodeEscape(body, i);
-      if (uni) {
-        i = uni.next;
-        return { cp: uni.cp };
-      }
-      const e = body[i + 1];
-      if (e === void 0) return null;
-      i += 2;
-      if (e in CLASS_ESCAPES) return { cp: CLASS_ESCAPES[e] };
-      if (e === "d" || e === "w" || e === "s") return { set: shorthandRanges(e) };
-      if (e >= "a" && e <= "z" || e >= "A" && e <= "Z") return null;
-      return { cp: e.codePointAt(0) };
+function scanTrivia(input, cur, ctx) {
+  const triviaP = ctx.trivia;
+  if (!triviaP) return { end: cur, commit: NOOP_COMMIT };
+  const log = ctx._triviaLog;
+  const rootLog = ctx._rootTriviaLog;
+  const captureTl = ctx.captureTrivia && (ctx._cstBuf !== void 0 || ctx._cstTriviaLog !== void 0);
+  if (!ctx.trackLines) {
+    const fast2 = !ctx.triviaKindLabels ? fastTriviaScanner(triviaP) : null;
+    if (fast2 && log === void 0 && !captureTl) {
+      return { end: fast2(input, cur), commit: NOOP_COMMIT };
     }
-    i += ch.length;
-    return { cp: ch.codePointAt(0) };
-  };
-  while (i < body.length) {
-    const lo = readAtom();
-    if (lo === null) return null;
-    if ("set" in lo) {
-      ranges.push(...lo.set);
-      continue;
+    if (ctx.triviaKindLabels && (log !== void 0 || rootLog !== void 0 || captureTl)) {
+      return scanWithLabels(input, cur, ctx);
     }
-    if (body[i] === "-" && body[i + 1] !== void 0 && body[i + 1] !== "]") {
-      i += 1;
-      const hi = readAtom();
-      if (hi === null || "set" in hi) return null;
-      ranges.push([lo.cp, hi.cp]);
-    } else {
-      ranges.push([lo.cp, lo.cp]);
+    if (ctx.triviaKindLabels) return { end: skipWithLabels(input, cur, ctx), commit: NOOP_COMMIT };
+    if (log !== void 0 || rootLog !== void 0 || captureTl) {
+      const tr3 = triviaP.parse(input, cur, {
+        trackLines: log !== void 0 ? false : ctx.trackLines,
+        state: ctx.state
+      });
+      if (!tr3.ok || tr3.span.end === cur) return { end: cur, commit: NOOP_COMMIT };
+      const end = tr3.span.end;
+      return {
+        end,
+        commit: () => {
+          pushTriviaLogEntry(ctx, cur, end);
+          if (captureTl) pushCstTriviaEntry(ctx, cur, end);
+        }
+      };
     }
+    const tr2 = triviaP.parse(input, cur, { trackLines: ctx.trackLines, state: ctx.state });
+    return { end: tr2.ok ? tr2.span.end : cur, commit: NOOP_COMMIT };
   }
-  return ranges.length ? ranges : null;
-}
-
-// src/combinators/regex.ts
-var firstSetAnalyzer = null;
-var permissiveFirstSet = () => ({ firstSet: any(), canMatchNewline: true });
-var SCAN_BAIL_AT = 64;
-function inRanges(cp, ranges) {
-  for (let i = 0; i < ranges.length; i++) {
-    const [lo, hi] = ranges[i];
-    if (cp >= lo && cp <= hi) return true;
+  const trackTriviaLines = ctx.trackLines && triviaP._meta.canMatchNewline;
+  const fast = !ctx.triviaKindLabels ? fastTriviaScanner(triviaP) : null;
+  if (fast && log === void 0 && !captureTl) {
+    const end = fast(input, cur);
+    if (trackTriviaLines) recordLineRangeFromContext(ctx, input, cur, end);
+    return { end, commit: NOOP_COMMIT };
   }
-  return false;
-}
-function readClassRanges(body) {
-  if (body.startsWith("^")) return null;
-  return parseClassRanges(body);
-}
-function shortScanner(source, flags) {
-  if (/[imsuvy]/.test(flags)) return null;
-  let ranges = null;
-  let quant = "";
-  if (source[0] === "[") {
-    let end = 1;
-    while (end < source.length && source[end] !== "]") {
-      if (source[end] === "\\") end += 2;
-      else end++;
+  if (ctx.triviaKindLabels && (log !== void 0 || rootLog !== void 0 || captureTl)) {
+    const scan = scanWithLabels(input, cur, ctx);
+    if (trackTriviaLines) recordLineRangeFromContext(ctx, input, cur, scan.end);
+    return scan;
+  }
+  if (ctx.triviaKindLabels) {
+    const end = skipWithLabels(input, cur, ctx);
+    if (trackTriviaLines) recordLineRangeFromContext(ctx, input, cur, end);
+    return { end, commit: NOOP_COMMIT };
+  }
+  if (log !== void 0 || rootLog !== void 0 || captureTl) {
+    const tr2 = parseTriviaNoCapture(triviaP, input, cur, ctx);
+    if (!tr2.ok || tr2.span.end === cur) return { end: cur, commit: NOOP_COMMIT };
+    const end = tr2.span.end;
+    return {
+      end,
+      commit: () => {
+        pushTriviaLogEntry(ctx, cur, end);
+        if (captureTl) pushCstTriviaEntry(ctx, cur, end);
+      }
+    };
+  }
+  const tr = parseTriviaNoCapture(triviaP, input, cur, ctx);
+  return { end: tr.ok ? tr.span.end : cur, commit: NOOP_COMMIT };
+}
+function consumeTrivia(input, cur, ctx) {
+  if (!needsDeferredTriviaCommit(ctx)) return advanceTrivia(input, cur, ctx);
+  const scan = scanTrivia(input, cur, ctx);
+  scan.commit();
+  return scan.end;
+}
+function fastTriviaScanner(trivia2) {
+  const cached = fastTriviaCache.get(trivia2);
+  if (cached !== void 0) return cached;
+  const scanner = buildFastTriviaScanner(trivia2);
+  fastTriviaCache.set(trivia2, scanner);
+  return scanner;
+}
+function buildFastTriviaScanner(trivia2) {
+  const core = trivia2._def.tag === "trivia" ? trivia2._def.parser : trivia2;
+  const direct = regexTriviaScanner(core);
+  if (direct) return direct;
+  const repeat = core._def.tag === "oneOrMore" || core._def.tag === "many" && core._def.min >= 1 ? core._def.parser : null;
+  if (!repeat) return null;
+  const one = regexTriviaScanner(repeat);
+  if (one) return loopScanner([one]);
+  if (repeat._def.tag !== "choice") return null;
+  const arms = repeat._def.parsers.map(regexTriviaScanner);
+  if (arms.some((s) => s === null)) return null;
+  return loopScanner(arms);
+}
+function loopScanner(arms) {
+  return (input, cur) => {
+    let pos = cur;
+    scan: while (pos < input.length) {
+      for (const arm of arms) {
+        const end = arm(input, pos);
+        if (end > pos) {
+          pos = end;
+          continue scan;
+        }
+      }
+      break;
     }
-    if (source[end] !== "]") return null;
-    ranges = readClassRanges(source.slice(1, end));
-    quant = source.slice(end + 1);
-  } else if (source[0] === "\\" && (source[1] === "d" || source[1] === "w" || source[1] === "s")) {
-    ranges = shorthandRanges(source[1]);
-    quant = source.slice(2);
+    return pos;
+  };
+}
+function regexTriviaScanner(parser2) {
+  if (parser2._def.tag !== "regex" || parser2._def.flags) return null;
+  const source = parser2._def.source;
+  return classRunSource(source) ?? altStarSource(source);
+}
+function inRanges(cp, ranges) {
+  for (let i = 0; i < ranges.length; i++) {
+    const r = ranges[i];
+    if (cp >= r[0] && cp <= r[1]) return true;
   }
-  if (!ranges || quant !== "+" && quant !== "*") return null;
-  const minOne = quant === "+";
-  return (input, pos) => {
-    let end = pos;
-    while (end < input.length && inRanges(input.charCodeAt(end), ranges)) {
-      end++;
-      if (end - pos >= SCAN_BAIL_AT) return void 0;
+  return false;
+}
+function classScanner(classBody) {
+  const ranges = parseClassRanges(classBody);
+  if (!ranges) return null;
+  return (input, cur) => {
+    let pos = cur;
+    while (pos < input.length && inRanges(input.charCodeAt(pos), ranges)) pos++;
+    return pos;
+  };
+}
+function untilLineBreakScanner(leaderCode) {
+  return (input, cur) => {
+    if (input.charCodeAt(cur) !== leaderCode) return cur;
+    let pos = cur + 1;
+    while (pos < input.length) {
+      const cc = input.charCodeAt(pos);
+      if (cc === 10 || cc === 13) break;
+      pos++;
     }
-    return minOne && end === pos ? null : end;
+    return pos;
   };
 }
-function asciiCaseFold(fs) {
-  if (fs.kind !== "ranges") return fs;
-  const ranges = fs.ranges.map((r) => ({ lo: r.lo, hi: r.hi }));
-  const add = (lo, hi) => {
-    if (lo <= hi) ranges.push({ lo, hi });
+function classRunSource(source) {
+  const m = /^\[([^\]^](?:[^\]]|\\.)*)\][*+]$/.exec(source);
+  return m ? classScanner(m[1]) : null;
+}
+function classifyTriviaArm(arm) {
+  const cls = /^\[([^\]^](?:[^\]]|\\.)*)\][*+]?$/.exec(arm);
+  if (cls) {
+    const ranges = parseClassRanges(cls[1]);
+    return ranges ? { kind: "class", ranges } : null;
+  }
+  const lc = /^(\\?.)\[\^\\n\\r\]\*$/.exec(arm);
+  if (lc) {
+    const marker = lc[1];
+    return { kind: "untilLineBreak", code: (marker.length === 2 ? marker[1] : marker[0]).charCodeAt(0) };
+  }
+  return null;
+}
+function armScanner(arm) {
+  if (arm.kind === "untilLineBreak") return untilLineBreakScanner(arm.code);
+  const ranges = arm.ranges;
+  return (input, cur) => {
+    let pos = cur;
+    while (pos < input.length && inRanges(input.charCodeAt(pos), ranges)) pos++;
+    return pos;
   };
-  for (const r of fs.ranges) {
-    const uLo = Math.max(r.lo, 65), uHi = Math.min(r.hi, 90);
-    add(uLo + 32, uHi + 32);
-    const lLo = Math.max(r.lo, 97), lHi = Math.min(r.hi, 122);
-    add(lLo - 32, lHi - 32);
+}
+function fusedTriviaScanner(ranges, leaders) {
+  const c0 = leaders[0];
+  const single = leaders.length === 1;
+  return (input, cur) => {
+    let pos = cur;
+    const len = input.length;
+    for (; ; ) {
+      const c = input.charCodeAt(pos);
+      if (pos < len && inRanges(c, ranges)) {
+        pos++;
+        continue;
+      }
+      if (single ? c === c0 : leaders.includes(c)) {
+        pos++;
+        while (pos < len) {
+          const cc = input.charCodeAt(pos);
+          if (cc === 10 || cc === 13) break;
+          pos++;
+        }
+        continue;
+      }
+      break;
+    }
+    return pos;
+  };
+}
+function splitTopLevelAlts(body) {
+  const arms = [];
+  let inClass = false;
+  let start = 0;
+  for (let i = 0; i < body.length; i++) {
+    const c = body[i];
+    if (c === "\\") {
+      i++;
+      continue;
+    }
+    if (inClass) {
+      if (c === "]") inClass = false;
+      continue;
+    }
+    if (c === "[") inClass = true;
+    else if (c === "(") return null;
+    else if (c === "|") {
+      arms.push(body.slice(start, i));
+      start = i + 1;
+    }
   }
-  ranges.sort((a, b) => a.lo - b.lo);
-  const merged = [];
-  for (const r of ranges) {
-    const last = merged[merged.length - 1];
-    if (last && r.lo <= last.hi + 1) last.hi = Math.max(last.hi, r.hi);
-    else merged.push({ lo: r.lo, hi: r.hi });
+  arms.push(body.slice(start));
+  return arms;
+}
+function altStarSource(source) {
+  const m = /^\(\?:(.*)\)[*+]$/.exec(source);
+  if (!m) return null;
+  const armSrcs = splitTopLevelAlts(m[1]);
+  if (!armSrcs || armSrcs.length < 2) return null;
+  const arms = [];
+  for (const src of armSrcs) {
+    const arm = classifyTriviaArm(src);
+    if (!arm) return null;
+    arms.push(arm);
   }
-  return { kind: "ranges", ranges: merged };
+  const ranges = [];
+  const leaders = [];
+  for (const arm of arms) {
+    if (arm.kind === "class") ranges.push(...arm.ranges);
+    else leaders.push(arm.code);
+  }
+  if (leaders.some((code) => inRanges(code, ranges))) {
+    return loopScanner(arms.map(armScanner));
+  }
+  if (leaders.length === 0) return armScanner({ kind: "class", ranges });
+  return fusedTriviaScanner(ranges, leaders);
 }
-function regex(pattern, flags = "") {
-  const source = typeof pattern === "string" ? pattern : pattern.source;
-  const resolvedFlags = typeof pattern === "string" ? flags : pattern.flags;
-  const anchored = new RegExp(source, "y" + resolvedFlags.replace(/[gy]/g, ""));
-  const scan = shortScanner(source, resolvedFlags);
-  const raw = (firstSetAnalyzer ?? permissiveFirstSet)(source);
-  const firstSet = !resolvedFlags.includes("i") ? raw.firstSet : resolvedFlags.includes("u") || resolvedFlags.includes("v") ? any() : asciiCaseFold(raw.firstSet);
-  const canMatchNewline = raw.canMatchNewline;
-  const meta = { firstSet, canMatchNewline, isTrivia: false };
+
+// src/combinators/choice.ts
+function choice(...args) {
+  const parsers = args.map((a) => "gate" in a ? a.combinator : a);
+  const gates = args.map((a) => "gate" in a ? a.gate : null);
+  const hasGates = gates.some((g) => g !== null);
+  const disjoint = areDisjoint(parsers.map((p) => p._meta.firstSet)) && parsers.every((p) => !matchesEmpty(p));
+  let combined = { kind: "empty" };
+  for (const p of parsers) combined = union(combined, p._meta.firstSet);
+  const meta = {
+    firstSet: combined,
+    canMatchNewline: parsers.some((p) => p._meta.canMatchNewline),
+    isTrivia: false,
+    disjoint
+  };
+  const strategy = disjoint || hasGates ? null : detectStrategy(parsers);
+  const autoNot = !disjoint && !hasGates && (strategy?.tag === "firstMatch" || strategy?.tag === "sharedPrefix") ? computeAutoNot(parsers) : parsers.map(() => null);
+  let greedyLitMap = null;
+  let sortedParsers = null;
+  const asciiDispatch = disjoint ? buildAsciiDispatch(parsers) : null;
+  if (strategy?.tag === "greedyClassify") {
+    greedyLitMap = /* @__PURE__ */ new Map();
+    for (let i = 0; i < parsers.length; i++) {
+      if (i === strategy.superIndex) continue;
+      const litVal = getCoreLiteralValue(parsers[i]);
+      if (litVal !== null) greedyLitMap.set(litVal, i);
+    }
+  } else if (strategy?.tag === "literalsLongestFirst") {
+    sortedParsers = strategy.sortedIndices.map((i) => parsers[i]);
+  }
   return {
-    _tag: "regex",
+    _tag: "choice",
     _meta: meta,
-    _def: { tag: "regex", source, flags: resolvedFlags },
+    _def: {
+      tag: "choice",
+      parsers,
+      gates,
+      disjoint,
+      strategy: strategy ?? { tag: "firstMatch" },
+      autoNot
+    },
     parse(input, pos, ctx) {
-      const scanEnd = scan?.(input, pos);
-      if (scanEnd !== void 0) {
-        if (scanEnd === null) return failAt(ctx, [`/${source}/`], pos);
-        const value = input.slice(pos, scanEnd);
-        const span2 = { start: pos, end: scanEnd };
-        if (canMatchNewline && ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, scanEnd);
-        if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value, span: span2 });
-        return { ok: true, value, span: span2 };
+      const expected = [];
+      if (disjoint && pos < input.length) {
+        const code = input.codePointAt(pos);
+        let idx = code < 128 ? asciiDispatch[code] : -1;
+        if (idx < 0) {
+          for (let i = 0; i < parsers.length; i++) {
+            if (inFirstSet(code, parsers[i]._meta.firstSet)) {
+              idx = i;
+              break;
+            }
+          }
+        }
+        if (idx >= 0) {
+          const gate = gates[idx];
+          if (gate && !gate(ctx.state)) {
+            return { ok: false, expected: deriveExpected(parsers[idx]), span: { start: pos, end: pos } };
+          }
+          const result = parsers[idx].parse(input, pos, ctx);
+          if (result.ok) return result;
+          expected.push(...result.expected);
+          if (result.committed) return { ok: false, expected, span: { start: pos, end: pos }, committed: true };
+          return { ok: false, expected, span: { start: pos, end: pos } };
+        }
+        return {
+          ok: false,
+          expected: parsers.flatMap((p) => {
+            const r = p.parse(input, pos, ctx);
+            return r.ok ? [] : r.expected;
+          }),
+          span: { start: pos, end: pos }
+        };
+      }
+      if (strategy?.tag === "greedyClassify") {
+        const superResult = parsers[strategy.superIndex].parse(input, pos, ctx);
+        if (!superResult.ok) return superResult;
+        const end = superResult.span.end;
+        const litIdx = greedyLitMap.get(input.slice(pos, end));
+        if (litIdx !== void 0) {
+          const litVal = getCoreLiteralValue(parsers[litIdx]);
+          const value = applyTransforms(parsers[litIdx], litVal, { start: pos, end });
+          return { ok: true, value, span: { start: pos, end } };
+        }
+        return superResult;
+      }
+      if (strategy?.tag === "literalsLongestFirst") {
+        for (const p of sortedParsers) {
+          const r = p.parse(input, pos, ctx);
+          if (r.ok) return r;
+          expected.push(...r.expected);
+        }
+        return { ok: false, expected, span: { start: pos, end: pos } };
+      }
+      for (let i = 0; i < parsers.length; i++) {
+        if (gates[i] && !gates[i](ctx.state)) continue;
+        const mark = saveTriviaMark(ctx);
+        const result = parsers[i].parse(input, pos, ctx);
+        if (!result.ok) {
+          rollbackTrivia(ctx, mark);
+          expected.push(...result.expected);
+          if (result.committed) return { ok: false, expected, span: result.span, committed: true };
+          continue;
+        }
+        const checks = autoNot[i];
+        if (checks && autoNotFires(input, result.span.end, checks)) {
+          rollbackTrivia(ctx, mark);
+          continue;
+        }
+        return result;
+      }
+      return { ok: false, expected, span: { start: pos, end: pos } };
+    }
+  };
+}
+function detectStrategy(parsers) {
+  const regexIndices = [];
+  const literalIndices = [];
+  for (let i = 0; i < parsers.length; i++) {
+    if (getCoreRegexDef(parsers[i]) !== null) regexIndices.push(i);
+    else if (getCoreLiteralValue(parsers[i]) !== null) literalIndices.push(i);
+  }
+  if (regexIndices.length === 1 && literalIndices.length === parsers.length - 1 && literalIndices.length > 0) {
+    const superIndex = regexIndices[0];
+    const regexDef = getCoreRegexDef(parsers[superIndex]);
+    const flags = "y" + regexDef.flags.replace(/[gy]/g, "");
+    const re = new RegExp(regexDef.source, flags);
+    const allSubsumed = literalIndices.every((i) => {
+      const litVal = getCoreLiteralValue(parsers[i]);
+      re.lastIndex = 0;
+      const m = re.exec(litVal);
+      return m !== null && m[0] === litVal;
+    });
+    if (allSubsumed) return { tag: "greedyClassify", superIndex };
+  }
+  if (parsers.length === literalIndices.length) {
+    const sortedIndices = [...literalIndices].sort(
+      (a, b) => getCoreLiteralValue(parsers[b]).length - getCoreLiteralValue(parsers[a]).length
+    );
+    return { tag: "literalsLongestFirst", sortedIndices };
+  }
+  const shared = detectSharedPrefix(parsers);
+  if (shared !== null) return shared;
+  return { tag: "firstMatch" };
+}
+function bareLeadingTermKey(term) {
+  const d = term._def;
+  if (d.tag === "literal" && !d.caseInsensitive) return `L:${d.value}`;
+  if (d.tag === "regex") return `R:${d.source}\0${d.flags}`;
+  return null;
+}
+function detectSharedPrefix(parsers) {
+  if (parsers.length < 2) return null;
+  let key = null;
+  let prefix = null;
+  const members = [];
+  for (let i = 0; i < parsers.length; i++) {
+    const term0 = leadingTermOfArm(parsers[i]);
+    if (term0 === null) return null;
+    const k = bareLeadingTermKey(term0);
+    if (k === null) return null;
+    if (key === null) {
+      key = k;
+      prefix = term0;
+    } else if (k !== key) return null;
+    members.push(i);
+  }
+  if (prefix === null || members.length < 2) return null;
+  return { tag: "sharedPrefix", prefix, members };
+}
+function leadingTermOfArm(arm) {
+  let d = arm._def;
+  for (; ; ) {
+    if (d.tag === "node" || d.tag === "grammar" || d.tag === "transform" || d.tag === "label") {
+      d = d.parser._def;
+      continue;
+    }
+    break;
+  }
+  if (d.tag !== "sequence" || d.parsers.length < 2) return null;
+  return d.parsers[0];
+}
+function computeAutoNot(parsers) {
+  return parsers.map((p, i) => {
+    const litVal = getCoreLiteralValue(p);
+    if (litVal === null) return null;
+    const checks = [];
+    for (let j2 = i + 1; j2 < parsers.length; j2++) {
+      const other = parsers[j2];
+      const otherLit = getCoreLiteralValue(other);
+      if (otherLit !== null && otherLit.startsWith(litVal) && otherLit.length > litVal.length) {
+        checks.push({ kind: "startsWith", value: otherLit.slice(litVal.length) });
+        continue;
       }
-      anchored.lastIndex = pos;
-      const m = anchored.exec(input);
-      if (m === null) {
-        return failAt(ctx, [`/${source}/`], pos);
+      const regexDef = getCoreRegexDef(other);
+      if (regexDef !== null) {
+        const contSet = continuationFirstSet(litVal, regexDef.source, regexDef.flags);
+        if (contSet !== null) checks.push({ kind: "firstSet", set: contSet });
       }
-      const span = { start: pos, end: pos + m[0].length };
-      if (canMatchNewline && ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, span.end);
-      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value: m[0], span });
-      return { ok: true, value: m[0], span };
     }
-  };
+    return checks.length > 0 ? checks : null;
+  });
 }
-
-// src/combinators/trivia-skip.ts
-var NOOP_COMMIT = () => {
-};
-var fastTriviaCache = /* @__PURE__ */ new WeakMap();
-function needsDeferredTriviaCommit(ctx) {
-  return ctx._triviaLog !== void 0 || ctx._cstBuf !== void 0 || ctx._cstTriviaLog !== void 0;
+function autoNotFires(input, end, checks) {
+  for (const check of checks) {
+    if (check.kind === "firstSet") {
+      const code = end < input.length ? input.codePointAt(end) ?? -1 : -1;
+      if (inFirstSet(code, check.set)) return true;
+    } else {
+      if (input.startsWith(check.value, end)) return true;
+    }
+  }
+  return false;
 }
-function saveTriviaMark(ctx) {
-  const m = saveCstMark(ctx);
-  return { raw: m.raw, tlog: m.tlog, leaves: m.leaves, fields: m.fields, errors: m.errors, log: ctx._triviaLog ? ctx._triviaLog.length : 0 };
+function getCoreLiteralValue(p) {
+  const def = p._def;
+  if (def.tag === "literal" && !def.caseInsensitive) return def.value;
+  if (def.tag === "transform") return getCoreLiteralValue(def.parser);
+  return null;
 }
-function rollbackTrivia(ctx, mark) {
-  rollbackCstCapture(ctx, { raw: mark.raw, tlog: mark.tlog, leaves: mark.leaves, fields: mark.fields, errors: mark.errors });
-  if (ctx._triviaLog && ctx._triviaLog.length !== mark.log) ctx._triviaLog.length = mark.log;
+function getCoreRegexDef(p) {
+  const def = p._def;
+  if (def.tag === "regex") return { source: def.source, flags: def.flags };
+  if (def.tag === "transform") return getCoreRegexDef(def.parser);
+  if (def.tag === "label") return getCoreRegexDef(def.parser);
+  return null;
 }
-function parseTriviaNoCapture(triviaP, input, cur, ctx) {
-  const probeCtx = {
-    trackLines: ctx.trackLines,
-    state: ctx.state,
-    ...ctx._lineIndex ? { _lineIndex: ctx._lineIndex } : {},
-    ...ctx._lineStarts ? { _lineStarts: ctx._lineStarts } : {},
-    ...ctx._lineScannedTo !== void 0 ? { _lineScannedTo: ctx._lineScannedTo } : {}
-  };
-  const result = triviaP.parse(input, cur, probeCtx);
-  ctx._lineScannedTo = probeCtx._lineScannedTo;
-  return result;
+function applyTransforms(p, value, span) {
+  const def = p._def;
+  if (def.tag === "transform") {
+    const inner = applyTransforms(def.parser, value, span);
+    return def.fn(inner, span);
+  }
+  return value;
 }
-function saveLookaheadMark(ctx) {
-  return { ...saveTriviaMark(ctx), probeBest: ctx._probe ? ctx._probe.best : null };
+function continuationFirstSet(lit, source, flags) {
+  const re = new RegExp(source, "y" + flags.replace(/[gy]/g, ""));
+  re.lastIndex = 0;
+  const base = re.exec(lit);
+  if (!base || base[0] !== lit) return null;
+  const contCodes = [];
+  for (let code = 1; code < 128; code++) {
+    re.lastIndex = 0;
+    const m = re.exec(lit + String.fromCharCode(code));
+    if (m && m[0].length > lit.length) contCodes.push(code);
+  }
+  if (contCodes.length === 0) return null;
+  return codesToFirstSet(contCodes);
 }
-function rollbackLookahead(ctx, mark) {
-  rollbackTrivia(ctx, mark);
-  if (ctx._probe) ctx._probe.best = mark.probeBest;
+function codesToFirstSet(codes) {
+  codes.sort((a, b) => a - b);
+  const ranges = [];
+  let lo = codes[0], hi = codes[0];
+  for (let i = 1; i < codes.length; i++) {
+    if (codes[i] === hi + 1) {
+      hi = codes[i];
+    } else {
+      ranges.push({ lo, hi });
+      lo = hi = codes[i];
+    }
+  }
+  ranges.push({ lo, hi });
+  return { kind: "ranges", ranges };
 }
-function scanWithLabels(input, cur, ctx) {
-  const triviaP = ctx.trivia;
-  const spec = analyzeLabeledTrivia(triviaP);
-  if (!spec) return { end: cur, commit: NOOP_COMMIT };
-  const fast = tryFastLabeledScan(input, cur, triviaP);
-  const { end, chunks } = fast ?? scanLabeledTriviaChunks(input, cur, spec);
-  if (end === cur) return { end: cur, commit: NOOP_COMMIT };
-  return {
-    end,
-    commit: () => recordTriviaChunks(ctx, chunks)
-  };
+function inFirstSet(code, fs) {
+  if (fs.kind === "any") return true;
+  if (fs.kind === "empty") return false;
+  for (const r of fs.ranges) if (code >= r.lo && code <= r.hi) return true;
+  return false;
 }
-function advanceTrivia(input, cur, ctx) {
-  const triviaP = ctx.trivia;
-  if (!triviaP) return cur;
-  if (!ctx.trackLines) {
-    const fast2 = fastTriviaScanner(triviaP);
-    if (fast2) return fast2(input, cur);
-    if (ctx.triviaKindLabels) {
-      const scan = scanWithLabels(input, cur, ctx);
-      return scan.end;
+function areDisjoint(sets) {
+  if (sets.some((s) => s.kind === "any")) return false;
+  for (let i = 0; i < sets.length; i++)
+    for (let j2 = i + 1; j2 < sets.length; j2++)
+      if (intersects(sets[i], sets[j2])) return false;
+  return true;
+}
+function buildAsciiDispatch(parsers) {
+  const table = Array(128).fill(-1);
+  for (let i = 0; i < parsers.length; i++) {
+    const fs = parsers[i]._meta.firstSet;
+    if (fs.kind !== "ranges") continue;
+    for (const { lo, hi } of fs.ranges) {
+      for (let code = Math.max(0, lo); code <= Math.min(127, hi); code++) {
+        table[code] = i;
+      }
     }
-    const tr2 = triviaP.parse(input, cur, { trackLines: ctx.trackLines, state: ctx.state });
-    return tr2.ok && tr2.span.end > cur ? tr2.span.end : cur;
-  }
-  const trackTriviaLines = ctx.trackLines && triviaP._meta.canMatchNewline;
-  const fast = fastTriviaScanner(triviaP);
-  if (fast) {
-    const end = fast(input, cur);
-    if (trackTriviaLines) recordLineRangeFromContext(ctx, input, cur, end);
-    return end;
-  }
-  if (ctx.triviaKindLabels) {
-    const scan = scanWithLabels(input, cur, ctx);
-    if (trackTriviaLines) recordLineRangeFromContext(ctx, input, cur, scan.end);
-    return scan.end;
   }
-  const tr = parseTriviaNoCapture(triviaP, input, cur, ctx);
-  return tr.ok && tr.span.end > cur ? tr.span.end : cur;
+  return table;
 }
-function scanTrivia(input, cur, ctx) {
-  const triviaP = ctx.trivia;
-  if (!triviaP) return { end: cur, commit: NOOP_COMMIT };
-  const log = ctx._triviaLog;
-  const captureTl = ctx.captureTrivia && (ctx._cstBuf !== void 0 || ctx._cstTriviaLog !== void 0);
-  if (!ctx.trackLines) {
-    const fast2 = !ctx.triviaKindLabels ? fastTriviaScanner(triviaP) : null;
-    if (fast2 && log === void 0 && !captureTl) {
-      return { end: fast2(input, cur), commit: NOOP_COMMIT };
-    }
-    if (ctx.triviaKindLabels && (log !== void 0 || captureTl)) {
-      return scanWithLabels(input, cur, ctx);
-    }
-    if (log !== void 0 || captureTl) {
-      const tr3 = triviaP.parse(input, cur, {
-        trackLines: log !== void 0 ? false : ctx.trackLines,
-        state: ctx.state
-      });
-      if (!tr3.ok || tr3.span.end === cur) return { end: cur, commit: NOOP_COMMIT };
-      const end = tr3.span.end;
-      return {
-        end,
-        commit: () => {
-          pushTriviaLogEntry(ctx, cur, end);
-          if (captureTl) pushCstTriviaEntry(ctx, cur, end);
-        }
-      };
+
+// src/analysis/duplication.ts
+var WORD_RE_SRC = "-?[A-Za-z][A-Za-z0-9_-]*";
+var WORDS_RE = new RegExp(`^${WORD_RE_SRC}(?:\\|${WORD_RE_SRC})*$`);
+
+// src/combinators/probe.ts
+function failAt(ctx, expected, pos) {
+  const r = { ok: false, expected, span: { start: pos, end: pos } };
+  const probe = ctx._probe;
+  if (probe !== void 0 && pos <= probe.offset) {
+    const best = probe.best;
+    if (best === null || pos > best.span.start) {
+      probe.best = r;
+    } else if (pos === best.span.start) {
+      probe.best = { ...best, expected: [...best.expected, ...expected] };
     }
-    const tr2 = triviaP.parse(input, cur, { trackLines: ctx.trackLines, state: ctx.state });
-    return { end: tr2.ok ? tr2.span.end : cur, commit: NOOP_COMMIT };
-  }
-  const trackTriviaLines = ctx.trackLines && triviaP._meta.canMatchNewline;
-  const fast = !ctx.triviaKindLabels ? fastTriviaScanner(triviaP) : null;
-  if (fast && log === void 0 && !captureTl) {
-    const end = fast(input, cur);
-    if (trackTriviaLines) recordLineRangeFromContext(ctx, input, cur, end);
-    return { end, commit: NOOP_COMMIT };
-  }
-  if (ctx.triviaKindLabels && (log !== void 0 || captureTl)) {
-    const scan = scanWithLabels(input, cur, ctx);
-    if (trackTriviaLines) recordLineRangeFromContext(ctx, input, cur, scan.end);
-    return scan;
-  }
-  if (log !== void 0 || captureTl) {
-    const tr2 = parseTriviaNoCapture(triviaP, input, cur, ctx);
-    if (!tr2.ok || tr2.span.end === cur) return { end: cur, commit: NOOP_COMMIT };
-    const end = tr2.span.end;
-    return {
-      end,
-      commit: () => {
-        pushTriviaLogEntry(ctx, cur, end);
-        if (captureTl) pushCstTriviaEntry(ctx, cur, end);
-      }
-    };
   }
-  const tr = parseTriviaNoCapture(triviaP, input, cur, ctx);
-  return { end: tr.ok ? tr.span.end : cur, commit: NOOP_COMMIT };
-}
-function consumeTrivia(input, cur, ctx) {
-  if (!needsDeferredTriviaCommit(ctx)) return advanceTrivia(input, cur, ctx);
-  const scan = scanTrivia(input, cur, ctx);
-  scan.commit();
-  return scan.end;
-}
-function fastTriviaScanner(trivia2) {
-  const cached = fastTriviaCache.get(trivia2);
-  if (cached !== void 0) return cached;
-  const scanner = buildFastTriviaScanner(trivia2);
-  fastTriviaCache.set(trivia2, scanner);
-  return scanner;
+  return r;
 }
-function buildFastTriviaScanner(trivia2) {
-  const core = trivia2._def.tag === "trivia" ? trivia2._def.parser : trivia2;
-  const direct = regexTriviaScanner(core);
-  if (direct) return direct;
-  const repeat = core._def.tag === "oneOrMore" || core._def.tag === "many" && core._def.min >= 1 ? core._def.parser : null;
-  if (!repeat) return null;
-  const one = regexTriviaScanner(repeat);
-  if (one) return loopScanner([one]);
-  if (repeat._def.tag !== "choice") return null;
-  const arms = repeat._def.parsers.map(regexTriviaScanner);
-  if (arms.some((s) => s === null)) return null;
-  return loopScanner(arms);
+
+// src/combinators/literal.ts
+function asciiFoldEq(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    let ca = a.charCodeAt(i);
+    let cb = b.charCodeAt(i);
+    if (ca >= 65 && ca <= 90) ca += 32;
+    if (cb >= 65 && cb <= 90) cb += 32;
+    if (ca !== cb) return false;
+  }
+  return true;
 }
-function loopScanner(arms) {
-  return (input, cur) => {
-    let pos = cur;
-    scan: while (pos < input.length) {
-      for (const arm of arms) {
-        const end = arm(input, pos);
-        if (end > pos) {
-          pos = end;
-          continue scan;
-        }
+function literal(value, opts = {}) {
+  const caseInsensitive = opts.caseInsensitive ?? false;
+  const firstSet = value.length > 0 ? fromChar(value.codePointAt(0)) : empty();
+  const meta = {
+    firstSet,
+    canMatchNewline: value.includes("\n"),
+    isTrivia: false
+  };
+  const canMatchNewline = meta.canMatchNewline;
+  if (caseInsensitive) {
+    const upper = value.toUpperCase();
+    const lower = value.toLowerCase();
+    const firstUpper = upper.codePointAt(0);
+    const firstLower = lower.codePointAt(0);
+    meta.firstSet = firstLower !== void 0 && firstUpper !== void 0 ? firstLower === firstUpper ? { kind: "ranges", ranges: [{ lo: firstLower, hi: firstLower }] } : { kind: "ranges", ranges: [
+      { lo: firstLower, hi: firstLower },
+      { lo: firstUpper, hi: firstUpper }
+    ] } : firstSet;
+  }
+  const expected = [JSON.stringify(value)];
+  const parse = !caseInsensitive && value.length === 1 ? (() => {
+    const code = value.charCodeAt(0);
+    return function parse2(input, pos, ctx) {
+      if (input.charCodeAt(pos) === code) {
+        const span = { start: pos, end: pos + 1 };
+        if (canMatchNewline && ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, span.end);
+        if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value, span });
+        return { ok: true, value, span };
       }
-      break;
+      return failAt(ctx, expected, pos);
+    };
+  })() : function parse2(input, pos, ctx) {
+    const end = pos + value.length;
+    if (end > input.length) {
+      return failAt(ctx, expected, pos);
     }
-    return pos;
+    const matchedValue = caseInsensitive ? input.slice(pos, end) : value;
+    if (caseInsensitive ? asciiFoldEq(matchedValue, value) : input.startsWith(value, pos)) {
+      const span = { start: pos, end };
+      if (canMatchNewline && ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, end);
+      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value: matchedValue, span });
+      return { ok: true, value: matchedValue, span };
+    }
+    return failAt(ctx, expected, pos);
+  };
+  return {
+    _tag: "literal",
+    _meta: meta,
+    _def: { tag: "literal", value, caseInsensitive },
+    parse
   };
 }
-function regexTriviaScanner(parser2) {
-  if (parser2._def.tag !== "regex" || parser2._def.flags) return null;
-  const source = parser2._def.source;
-  return classRunSource(source) ?? altStarSource(source) ?? (blockCommentSource(source) ? scanBlockComment : null);
-}
+
+// src/combinators/regex.ts
+var firstSetAnalyzer = null;
+var permissiveFirstSet = () => ({ firstSet: any(), canMatchNewline: true });
+var SCAN_BAIL_AT = 64;
 function inRanges2(cp, ranges) {
   for (let i = 0; i < ranges.length; i++) {
-    const r = ranges[i];
-    if (cp >= r[0] && cp <= r[1]) return true;
+    const [lo, hi] = ranges[i];
+    if (cp >= lo && cp <= hi) return true;
   }
   return false;
 }
-function classScanner(classBody) {
-  const ranges = parseClassRanges(classBody);
-  if (!ranges) return null;
-  return (input, cur) => {
-    let pos = cur;
-    while (pos < input.length && inRanges2(input.charCodeAt(pos), ranges)) pos++;
-    return pos;
-  };
+function readClassRanges(body) {
+  if (body.startsWith("^")) return null;
+  return parseClassRanges(body);
 }
-function lineCommentScanner(commentCode) {
-  return (input, cur) => {
-    if (input.charCodeAt(cur) !== commentCode) return cur;
-    let pos = cur + 1;
-    while (pos < input.length) {
-      const cc = input.charCodeAt(pos);
-      if (cc === 10 || cc === 13) break;
-      pos++;
+function shortScanner(source, flags) {
+  if (/[imsuvy]/.test(flags)) return null;
+  let ranges = null;
+  let quant = "";
+  if (source[0] === "[") {
+    let end = 1;
+    while (end < source.length && source[end] !== "]") {
+      if (source[end] === "\\") end += 2;
+      else end++;
     }
-    return pos;
+    if (source[end] !== "]") return null;
+    ranges = readClassRanges(source.slice(1, end));
+    quant = source.slice(end + 1);
+  } else if (source[0] === "\\" && (source[1] === "d" || source[1] === "w" || source[1] === "s")) {
+    ranges = shorthandRanges(source[1]);
+    quant = source.slice(2);
+  }
+  if (!ranges || quant !== "+" && quant !== "*") return null;
+  const minOne = quant === "+";
+  return (input, pos) => {
+    let end = pos;
+    while (end < input.length && inRanges2(input.charCodeAt(end), ranges)) {
+      end++;
+      if (end - pos >= SCAN_BAIL_AT) return void 0;
+    }
+    return minOne && end === pos ? null : end;
   };
 }
-function classRunSource(source) {
-  const m = /^\[([^\]^](?:[^\]]|\\.)*)\][*+]$/.exec(source);
-  return m ? classScanner(m[1]) : null;
-}
-function classifyTriviaArm(arm) {
-  const cls = /^\[([^\]^](?:[^\]]|\\.)*)\][*+]?$/.exec(arm);
-  if (cls) {
-    const ranges = parseClassRanges(cls[1]);
-    return ranges ? { kind: "class", ranges } : null;
+function asciiCaseFold(fs) {
+  if (fs.kind !== "ranges") return fs;
+  const ranges = fs.ranges.map((r) => ({ lo: r.lo, hi: r.hi }));
+  const add = (lo, hi) => {
+    if (lo <= hi) ranges.push({ lo, hi });
+  };
+  for (const r of fs.ranges) {
+    const uLo = Math.max(r.lo, 65), uHi = Math.min(r.hi, 90);
+    add(uLo + 32, uHi + 32);
+    const lLo = Math.max(r.lo, 97), lHi = Math.min(r.hi, 122);
+    add(lLo - 32, lHi - 32);
   }
-  const lc = /^(\\?.)\[\^\\n\\r\]\*$/.exec(arm);
-  if (lc) {
-    const marker = lc[1];
-    return { kind: "comment", code: (marker.length === 2 ? marker[1] : marker[0]).charCodeAt(0) };
+  ranges.sort((a, b) => a.lo - b.lo);
+  const merged = [];
+  for (const r of ranges) {
+    const last = merged[merged.length - 1];
+    if (last && r.lo <= last.hi + 1) last.hi = Math.max(last.hi, r.hi);
+    else merged.push({ lo: r.lo, hi: r.hi });
   }
-  return null;
-}
-function armScanner(arm) {
-  if (arm.kind === "comment") return lineCommentScanner(arm.code);
-  const ranges = arm.ranges;
-  return (input, cur) => {
-    let pos = cur;
-    while (pos < input.length && inRanges2(input.charCodeAt(pos), ranges)) pos++;
-    return pos;
-  };
+  return { kind: "ranges", ranges: merged };
 }
-function fusedTriviaScanner(ranges, commentCodes) {
-  const c0 = commentCodes[0];
-  const single = commentCodes.length === 1;
-  return (input, cur) => {
-    let pos = cur;
-    const len = input.length;
-    for (; ; ) {
-      const c = input.charCodeAt(pos);
-      if (pos < len && inRanges2(c, ranges)) {
-        pos++;
-        continue;
+function regex(pattern, flags = "") {
+  const source = typeof pattern === "string" ? pattern : pattern.source;
+  const resolvedFlags = typeof pattern === "string" ? flags : pattern.flags;
+  const anchored = new RegExp(source, "y" + resolvedFlags.replace(/[gy]/g, ""));
+  const scan = shortScanner(source, resolvedFlags);
+  const raw = (firstSetAnalyzer ?? permissiveFirstSet)(source);
+  const firstSet = !resolvedFlags.includes("i") ? raw.firstSet : resolvedFlags.includes("u") || resolvedFlags.includes("v") ? any() : asciiCaseFold(raw.firstSet);
+  const canMatchNewline = raw.canMatchNewline;
+  const meta = { firstSet, canMatchNewline, isTrivia: false };
+  return {
+    _tag: "regex",
+    _meta: meta,
+    _def: { tag: "regex", source, flags: resolvedFlags },
+    parse(input, pos, ctx) {
+      const scanEnd = scan?.(input, pos);
+      if (scanEnd !== void 0) {
+        if (scanEnd === null) return failAt(ctx, [`/${source}/`], pos);
+        const value = input.slice(pos, scanEnd);
+        const span2 = { start: pos, end: scanEnd };
+        if (canMatchNewline && ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, scanEnd);
+        if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value, span: span2 });
+        return { ok: true, value, span: span2 };
       }
-      if (single ? c === c0 : commentCodes.includes(c)) {
-        pos++;
-        while (pos < len) {
-          const cc = input.charCodeAt(pos);
-          if (cc === 10 || cc === 13) break;
-          pos++;
-        }
-        continue;
+      anchored.lastIndex = pos;
+      const m = anchored.exec(input);
+      if (m === null) {
+        return failAt(ctx, [`/${source}/`], pos);
       }
-      break;
+      const span = { start: pos, end: pos + m[0].length };
+      if (canMatchNewline && ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, span.end);
+      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value: m[0], span });
+      return { ok: true, value: m[0], span };
     }
-    return pos;
   };
 }
-function splitTopLevelAlts(body) {
-  const arms = [];
-  let inClass = false;
-  let start = 0;
-  for (let i = 0; i < body.length; i++) {
-    const c = body[i];
-    if (c === "\\") {
-      i++;
-      continue;
-    }
-    if (inClass) {
-      if (c === "]") inClass = false;
-      continue;
-    }
-    if (c === "[") inClass = true;
-    else if (c === "(") return null;
-    else if (c === "|") {
-      arms.push(body.slice(start, i));
-      start = i + 1;
-    }
-  }
-  arms.push(body.slice(start));
-  return arms;
-}
-function altStarSource(source) {
-  const m = /^\(\?:(.*)\)[*+]$/.exec(source);
-  if (!m) return null;
-  const armSrcs = splitTopLevelAlts(m[1]);
-  if (!armSrcs || armSrcs.length < 2) return null;
-  const arms = [];
-  for (const src of armSrcs) {
-    const arm = classifyTriviaArm(src);
-    if (!arm) return null;
-    arms.push(arm);
-  }
-  const ranges = [];
-  const commentCodes = [];
-  for (const arm of arms) {
-    if (arm.kind === "class") ranges.push(...arm.ranges);
-    else commentCodes.push(arm.code);
-  }
-  if (commentCodes.some((code) => inRanges2(code, ranges))) {
-    return loopScanner(arms.map(armScanner));
-  }
-  if (commentCodes.length === 0) return armScanner({ kind: "class", ranges });
-  return fusedTriviaScanner(ranges, commentCodes);
-}
-function blockCommentSource(source) {
-  return source === "\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/" || source === "\\/\\*[^]*?\\*\\/";
-}
-function scanBlockComment(input, cur) {
-  if (input.charCodeAt(cur) !== 47 || input.charCodeAt(cur + 1) !== 42) return cur;
-  const close = input.indexOf("*/", cur + 2);
-  return close === -1 ? cur : close + 2;
-}
 
 // src/combinators/sequence.ts
 function sequence(...parsers) {
@@ -2433,6 +2520,25 @@ function trivia(combinator) {
     parse: combinator.parse.bind(combinator)
   };
 }
+function classifiedTrivia(arms) {
+  const entries = Object.entries(arms);
+  if (entries.length === 0) {
+    throw new TypeError("classifiedTrivia() requires at least one named trivia arm.");
+  }
+  for (let i = 0; i < entries.length; i++) {
+    const [name, arm] = entries[i];
+    const first = arm._meta.firstSet;
+    if (matchesEmpty(arm) || first.kind !== "ranges" || first.ranges.length === 0) {
+      throw new TypeError(
+        `classifiedTrivia(): ${JSON.stringify(name)} must be non-nullable with a concrete finite first set.`
+      );
+    }
+  }
+  const labeledArms = entries.map(([name, arm]) => label(name, arm));
+  const result = trivia(oneOrMore(choice(...labeledArms)));
+  result._meta.rootTriviaClassified = true;
+  return result;
+}
 function label(name, combinator) {
   return {
     _tag: combinator._tag,
@@ -2526,8 +2632,17 @@ function scanTo(sentinel, { skip: skip2, raw = false, orEOF = false } = {}) {
   };
 }
 
+// src/cst/trivia-entries.ts
+var EMPTY_INDICES = Object.freeze([]);
+var EMPTY_GAPS = Object.freeze([]);
+var SELECTED_ROOT_STRIDE = 5;
+
 // src/compiler/scannable-run.ts
 var META = new Set("()[]{}*+?|^$.".split(""));
+var SELECTED_ROOT_OWNED_RANGE_PLACEHOLDER = Array.from(
+  { length: SELECTED_ROOT_STRIDE - 3 },
+  () => "0"
+).join(", ");
 
 // src/compiler/trivia-fast-path.ts
 var CAP_RECORD = [
@@ -2536,6 +2651,11 @@ var CAP_RECORD = [
   `    if (_cap === 1 && _ctx._cstTriviaLog !== undefined && _ctx.captureTrivia) _ctx._cstTriviaLog.push(_pos, _e, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0)`,
   `  }`
 ].join("\n");
+var SELECTED_ROOT_FINISH = [
+  `  if (_cap && _ctx._rootTriviaCapture !== false && _ctx._rootTriviaLog !== undefined && _ctx._rootTriviaLog.length !== _rootMark) {`,
+  `    for (let _ri = _rootMark; _ri < _ctx._rootTriviaLog.length; _ri += ${SELECTED_ROOT_STRIDE}) { _ctx._rootTriviaLog[_ri] = _pos; _ctx._rootTriviaLog[_ri + 1] = _e }`,
+  `  }`
+].join("\n");
 
 // src/compiler/build-arity.ts
 function cstOutputHost(build) {
@@ -2975,10 +3095,12 @@ function attempt(parser2) {
       }
       const mark = saveCstMark(ctx);
       const log = ctx._triviaLog?.length;
+      const rootLog = ctx._rootTriviaLog?.length;
       const result = parser2.parse(input, pos, ctx);
       if (result.ok) return result;
       rollbackCstCapture(ctx, mark);
       if (log !== void 0 && ctx._triviaLog && ctx._triviaLog.length !== log) ctx._triviaLog.length = log;
+      if (rootLog !== void 0 && ctx._rootTriviaLog && ctx._rootTriviaLog.length !== rootLog) ctx._rootTriviaLog.length = rootLog;
       if (result.committed) return result;
       return { ok: false, expected: result.expected, span: { start: pos, end: pos } };
     }
@@ -3158,6 +3280,7 @@ function token(root) {
       const savedRaw = ctx._cstRawChildren;
       const savedTriviaLog = ctx._cstTriviaLog;
       const savedOuterTriviaLog = ctx._triviaLog;
+      const savedRootTriviaLog = ctx._rootTriviaLog;
       const wasCapturing = cstCaptureActive(ctx);
       ctx.trivia = void 0;
       ctx.triviaKindLabels = void 0;
@@ -3167,6 +3290,7 @@ function token(root) {
       ctx._cstRawChildren = void 0;
       ctx._cstTriviaLog = void 0;
       delete ctx._triviaLog;
+      delete ctx._rootTriviaLog;
       let result;
       try {
         result = root.parse(input, pos, ctx);
@@ -3180,6 +3304,8 @@ function token(root) {
         ctx._cstTriviaLog = savedTriviaLog;
         if (savedOuterTriviaLog === void 0) delete ctx._triviaLog;
         else ctx._triviaLog = savedOuterTriviaLog;
+        if (savedRootTriviaLog === void 0) delete ctx._rootTriviaLog;
+        else ctx._rootTriviaLog = savedRootTriviaLog;
       }
       if (!result.ok) return result;
       const span = result.span;
@@ -3359,6 +3485,7 @@ function evalRuleMapIR(ir) {
     "transform",
     "skip",
     "trivia",
+    "classifiedTrivia",
     "label",
     "field",
     "expect",
@@ -3399,6 +3526,7 @@ function evalRuleMapIR(ir) {
     transform,
     skip,
     trivia,
+    classifiedTrivia,
     label,
     field,
     expect,