parseman 0.60.4 → 0.60.6

package/dist/cli/index.js

@@ -48,6 +48,12 @@ function hasOwnTriviaBoundary(p, depth = MAX_DEPTH) {
     case "oneOrMore":
     case "sepBy":
       return true;
+    // A scope that names or clears trivia keeps an outer install out of its body.
+    // Any other inherits, so it falls through at no cost in depth: line tracking
+    // wraps every rule in one, and must not change what this walk sees.
+    case "grammar":
+      if (d.triviaParser || d.clearTrivia) return false;
+      depth++;
     // Transparent wrappers — they add no position, so ask what they wrap.
     case "node":
     case "transform":
@@ -4167,214 +4173,544 @@ function scalarRootOf(combinator) {
   return scalar !== void 0 && def.tag === "grammar" && scalarTree(def.parser, /* @__PURE__ */ new Set()) ? scalar : void 0;
 }
 
-// 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 ordered = strategy?.tag === "firstMatch" || strategy?.tag === "sharedPrefix";
-  const autoNot = !disjoint && !hasGates && ordered ? 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]);
+// src/combinators/ref.ts
+function withRuleTrivia(trivia2, ctx, run) {
+  const savedLabels = ctx.triviaKindLabels;
+  ctx.trivia = trivia2;
+  ctx.triviaKindLabels = trivia2._meta.triviaKindLabels;
+  try {
+    return run();
+  } finally {
+    ctx.trivia = void 0;
+    ctx.triviaKindLabels = savedLabels;
   }
-  const scalarParsers = parsers.map(scalarOf);
-  const scalarEligible = !hasGates && parsers.every((p) => p._parseScalar !== void 0) && (disjoint || ordered);
-  const scalarExpected = parsers.flatMap(deriveExpected);
-  const parseScalar = (input, pos, ctx) => {
-    if (disjoint) {
-      const code = pos < input.length ? input.codePointAt(pos) : -1;
-      let idx = code >= 0 && code < 128 ? asciiDispatch[code] : -1;
-      if (idx < 0 && code >= 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 scalarParsers[idx](input, pos, ctx);
-        ctx._fx = deriveExpected(parsers[idx]);
-        return ~pos;
-      }
-    } else {
-      for (let i = 0; i < scalarParsers.length; i++) {
-        if (gates[i] && !gates[i](ctx.state)) continue;
-        const end = scalarParsers[i](input, pos, ctx);
-        if (end >= 0 && (!autoNot[i] || !autoNotFires(input, end, autoNot[i]))) return end;
-      }
-    }
-    ctx._fx = scalarExpected;
-    return ~pos;
+}
+var UNDEFINED_REF = new Error("ref<T>() used before .define() was called");
+function ref() {
+  let resolved = null;
+  let resolvedScalar = null;
+  let ownBoundary = false;
+  const meta = {
+    firstSet: any(),
+    canMatchNewline: true,
+    isTrivia: false
   };
-  return {
-    _tag: "choice",
+  const slot = {
+    _tag: "lazy",
     _meta: meta,
     _def: {
-      tag: "choice",
-      parsers,
-      gates,
-      disjoint,
-      strategy: strategy ?? { tag: "firstMatch" },
-      autoNot
-    },
-    _parseScalar: scalarEligible ? parseScalar : void 0,
-    parse(input, pos, ctx) {
-      const expected = [];
-      let expectedAt = pos;
-      if (disjoint) {
-        const code = pos < input.length ? input.codePointAt(pos) : -1;
-        let idx = code >= 0 && code < 128 ? asciiDispatch[code] : -1;
-        if (idx < 0 && code >= 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 } };
-        }
-        if (ctx._probe !== void 0 || ctx._tolerant) for (const p of parsers) p.parse(input, pos, ctx);
-        return { ok: false, expected: [...scalarExpected], 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 } };
+      tag: "lazy",
+      thunk: () => {
+        if (!resolved) throw UNDEFINED_REF;
+        return resolved;
       }
-      for (let i = 0; i < parsers.length; i++) {
-        if (gates[i] && !gates[i](ctx.state)) continue;
-        const mark = saveTriviaMark(ctx);
-        const split = ctx._columnsSplit;
-        const result = parsers[i].parse(input, pos, ctx);
-        if (!result.ok) {
-          rollbackTrivia(ctx, mark);
-          ctx._columnsSplit = split;
-          const at = result.span.start;
-          if (at > expectedAt) {
-            expectedAt = at;
-            expected.length = 0;
-          }
-          if (at === expectedAt) 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;
+    },
+    _parseScalar(input, pos, ctx) {
+      const scalar = resolvedScalar;
+      if (!scalar) throw new Error("ref<T>() used before .define() was called");
+      const gt = meta.grammarTrivia;
+      if (gt !== void 0 && ownBoundary && ctx.trivia === void 0) {
+        return withRuleTrivia(gt, ctx, () => scalar(input, pos, ctx));
       }
-      if (expected.length === 0) {
-        for (const parser2 of parsers) expected.push(...deriveExpected(parser2));
+      return scalar(input, pos, ctx);
+    },
+    parse(input, pos, ctx) {
+      const parser2 = resolved;
+      if (!parser2) throw new Error("ref<T>() used before .define() was called");
+      const gt = meta.grammarTrivia;
+      if (gt !== void 0 && ownBoundary && ctx.trivia === void 0) {
+        return withRuleTrivia(gt, ctx, () => parser2.parse(input, pos, ctx));
       }
-      return { ok: false, expected, span: { start: pos, end: pos } };
+      return parser2.parse(input, pos, ctx);
+    },
+    define(p) {
+      if (resolved) throw new Error("ref<T>() already defined");
+      resolved = p;
+      resolvedScalar = scalarOf(p);
+      ownBoundary = hasOwnTriviaBoundary(p);
+      meta.firstSet = p._meta.firstSet;
+      meta.canMatchNewline = p._meta.canMatchNewline;
+      meta.isTrivia = p._meta.isTrivia;
+      if (p._meta.triviaKindLabels !== void 0) meta.triviaKindLabels = p._meta.triviaKindLabels;
+      else delete meta.triviaKindLabels;
+      if (p._meta.disjoint !== void 0) meta.disjoint = p._meta.disjoint;
+      else delete meta.disjoint;
     }
   };
+  return slot;
 }
-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:${JSON.stringify([d.source, 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) {
+
+// src/compiler/value-usage.ts
+function markUnusedValues(root) {
+  const seenConsumed = /* @__PURE__ */ new WeakSet();
+  const seenUnconsumed = /* @__PURE__ */ new WeakSet();
+  const mark = (def, consumed) => {
+    if (consumed) def.valueUnused = false;
+    else if (def.valueUnused !== false) def.valueUnused = true;
+  };
+  const visit = (c, consumed) => {
+    const seen = consumed ? seenConsumed : seenUnconsumed;
+    if (seen.has(c)) return;
+    seen.add(c);
+    const def = c._def;
+    switch (def.tag) {
+      case "many":
+      case "oneOrMore":
+        mark(def, consumed);
+        visit(def.parser, consumed);
+        return;
+      case "optional":
+        visit(def.parser, consumed);
+        return;
+      case "sequence":
+        mark(def, consumed);
+        for (const p of def.parsers) visit(p, consumed);
+        return;
+      case "choice":
+        for (const p of def.parsers) visit(p, consumed);
+        return;
+      case "dispatch":
+        visit(def.selector, consumed);
+        for (const entry of def.cases) visit(entry.parser, consumed);
+        if (def.matchers) for (const entry of def.matchers) visit(entry.parser, consumed);
+        if (def.otherwise) visit(def.otherwise, consumed);
+        return;
+      case "node":
+        visit(def.parser, false);
+        return;
+      case "transform":
+        visit(def.parser, true);
+        return;
+      case "field":
+        visit(def.parser, true);
+        return;
+      case "sepBy":
+        visit(def.parser, true);
+        visit(def.separator, false);
+        return;
+      case "not":
+      case "peek":
+        visit(def.parser, false);
+        return;
+      case "grammar":
+        visit(def.parser, consumed);
+        if (def.triviaParser) visit(def.triviaParser, false);
+        return;
+      case "recover":
+        visit(def.parser, consumed);
+        visit(def.sentinel, false);
+        return;
+      case "token":
+        visit(def.parser, false);
+        return;
+      case "label":
+      case "trivia":
+      case "attempt":
+      case "withCtx":
+      case "expect":
+        visit(def.parser, consumed);
+        return;
+      case "leaf":
+        visit(def.parser, true);
+        return;
+      case "lazy":
+        return;
+      default:
+        return;
+    }
+  };
+  const resolveRoot = (c) => {
+    const guard = /* @__PURE__ */ new Set();
+    let cur = c;
+    while (!guard.has(cur)) {
+      const d = cur._def;
+      if (d.tag === "grammar") {
+        guard.add(cur);
+        cur = d.parser;
+        continue;
+      }
+      if (d.tag !== "lazy") return cur;
+      guard.add(cur);
+      try {
+        cur = d.thunk();
+      } catch {
+        return c;
+      }
+    }
+    return cur;
+  };
+  visit(resolveRoot(root), true);
+}
+
+// src/cst/root-trivia-scope.ts
+var ROOT_TRIVIA_SCOPE_REFUSAL = "parser(): selected root trivia requires classifiedTrivia() for every local trivia scope, or rootCapture: 'opaque'.";
+function refuseUnclassifiedRootScope(strict) {
+  if (strict === true) throw new TypeError(ROOT_TRIVIA_SCOPE_REFUSAL);
+}
+
+// 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 };
+}
+var TRACK_LINES_ON = () => true;
+var TRACK_LINES_OFF = () => false;
+var TRACK_LINES_INHERIT = (ctx) => ctx?.trackLines === true;
+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.");
+  }
+  const scopeTrivia = clearTrivia ? void 0 : opts.trivia ?? void 0;
+  const scopeLabels = scopeTrivia?._meta?.triviaKindLabels;
+  const refuseUnclassified = scopeTrivia !== void 0 && !scopeTrivia._meta?.rootTriviaClassified && !opaqueRootCapture;
+  const forceCaptureTrivia = opts.captureTrivia === true;
+  const trackLinesPolicy = opts.trackLines === true ? "on" : opts.trackLines === false ? "off" : "inherit";
+  const trackLinesOf = trackLinesPolicy === "on" ? TRACK_LINES_ON : trackLinesPolicy === "off" ? TRACK_LINES_OFF : TRACK_LINES_INHERIT;
+  const captureKinds = clearTrivia ? void 0 : opts.captureTriviaKinds;
+  const ownCaptureMask = captureKinds === void 0 ? void 0 : scopeLabels !== void 0 ? triviaKindMask(scopeLabels, captureKinds) : void 0;
+  const inheritCaptureMask = captureKinds !== void 0 && scopeLabels === void 0;
+  const rootScalar = scalarOf(root);
+  const scalarEligible = opts.trackLines !== true && opts.recover !== true && !opaqueRootCapture && !forceCaptureTrivia && captureKinds === void 0;
+  const parseScalar = scalarEligible ? (input, pos, ctx) => {
+    const savedTrivia = ctx.trivia;
+    const savedLabels = ctx.triviaKindLabels;
+    if (clearTrivia) {
+      ctx.trivia = void 0;
+      ctx.triviaKindLabels = void 0;
+    } else if (scopeTrivia !== void 0) {
+      ctx.trivia = scopeTrivia;
+      ctx.triviaKindLabels = scopeLabels;
+    }
+    const end = rootScalar(input, pos, ctx);
+    ctx.trivia = savedTrivia;
+    ctx.triviaKindLabels = savedLabels;
+    return end;
+  } : void 0;
+  let publicScalar;
+  const grammar = {
+    _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: "grammar",
+      parser: root,
+      triviaParser: scopeTrivia,
+      clearTrivia,
+      ...opaqueRootCapture ? { rootCapture: "opaque" } : {},
+      ...opts.captureTrivia ? { captureTrivia: true } : {},
+      trackLines: opts.trackLines ?? false,
+      constructionTrackLines: trackLinesPolicy,
+      ...captureKinds === void 0 ? {} : { constructionCaptureTriviaKinds: captureKinds }
+    },
+    _parseScalar: parseScalar,
+    parse(input, pos, _ctx) {
+      if (pos === void 0 && _ctx === void 0) {
+        publicScalar ??= scalarRootOf(grammar) ?? null;
+        if (publicScalar) {
+          const ctx2 = createParseContext();
+          const end = publicScalar(input, 0, ctx2);
+          if (end < 0) {
+            const at = ~end;
+            return { ok: false, expected: ctx2._fx ?? [], span: { start: at, end: at } };
+          }
+          return { ok: true, value: ctx2._sv, span: { start: 0, end } };
+        }
+      }
+      if (refuseUnclassified) refuseUnclassifiedRootScope(_ctx?._rootTriviaStrictScopes);
+      const trackLines = trackLinesOf(_ctx);
+      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 === void 0 ? createParseContext() : { ..._ctx };
+      ctx.trackLines = trackLines;
+      if (lineIndex) ctx._lineIndex = lineIndex;
+      if (lineContext) ctx._lineScannedTo = lineContext.lineScannedTo;
+      if (clearTrivia) {
+        ctx.trivia = void 0;
+        ctx.triviaKindLabels = void 0;
+      } else if (scopeTrivia !== void 0) {
+        ctx.trivia = scopeTrivia;
+        ctx.triviaKindLabels = scopeLabels;
+      }
+      if (forceCaptureTrivia || _ctx?.captureTrivia) ctx.captureTrivia = true;
+      if (ownCaptureMask !== void 0) ctx._triviaCaptureMask = ownCaptureMask;
+      else if (inheritCaptureMask) ctx._triviaCaptureMask = triviaKindMask(_ctx?.triviaKindLabels, captureKinds);
+      if (opaqueRootCapture) ctx._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 lineIndex ? annotateResultLines(result, normalizeLineIndex(lineIndex)) : result;
+    }
+  };
+  return grammar;
+}
+function noTrivia(root) {
+  return parser({ trivia: null }, root);
+}
+var _analyzed = /* @__PURE__ */ new WeakSet();
+function parse(combinator, input, opts = {}) {
+  if (!_analyzed.has(combinator)) {
+    _analyzed.add(combinator);
+    markUnusedValues(combinator);
+  }
+  if (!opts.trackLines && !opts.recover && combinator._def.tag === "grammar" && combinator._meta.grammarScanSkip === void 0) {
+    return combinator.parse(input);
+  }
+  const trackLines = opts.trackLines ?? combinator._meta.grammarTrackLines ?? false;
+  const lineContext = trackLines ? createParseLineContext(input, 0) : void 0;
+  const lineIndex = lineContext?.lineIndex;
+  const _errors = opts.recover ? [] : void 0;
+  const _probe = opts.recover ? { offset: input.length, best: null } : void 0;
+  const grammarTrivia = combinator._meta.grammarTrivia;
+  const grammarScanSkip = combinator._meta.grammarScanSkip;
+  const ctx = createParseContext();
+  ctx.trackLines = trackLines;
+  if (lineIndex) ctx._lineIndex = lineIndex;
+  if (lineContext) ctx._lineScannedTo = lineContext.lineScannedTo;
+  if (grammarTrivia !== void 0) {
+    ctx.trivia = grammarTrivia;
+    if (grammarTrivia._meta.triviaKindLabels) ctx.triviaKindLabels = grammarTrivia._meta.triviaKindLabels;
+  }
+  if (grammarScanSkip !== void 0) ctx.scanSkip = grammarScanSkip;
+  if (_errors !== void 0) ctx._errors = _errors;
+  if (_probe !== void 0) ctx._probe = _probe;
+  const result = combinator.parse(input, 0, ctx);
+  if (!result.ok) return lineIndex ? annotateResultLines(result, normalizeLineIndex(lineIndex)) : result;
+  const withErrors = _errors !== void 0 ? { ...result, errors: _errors, furthestFail: _probe?.best ?? null } : result;
+  return lineIndex ? annotateResultLines(withErrors, normalizeLineIndex(lineIndex)) : withErrors;
+}
+
+// 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 ordered = strategy?.tag === "firstMatch" || strategy?.tag === "sharedPrefix";
+  const autoNot = !disjoint && !hasGates && ordered ? 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]);
+  }
+  const scalarParsers = parsers.map(scalarOf);
+  const scalarEligible = !hasGates && parsers.every((p) => p._parseScalar !== void 0) && (disjoint || ordered);
+  const scalarExpected = parsers.flatMap(deriveExpected);
+  const parseScalar = (input, pos, ctx) => {
+    if (disjoint) {
+      const code = pos < input.length ? input.codePointAt(pos) : -1;
+      let idx = code >= 0 && code < 128 ? asciiDispatch[code] : -1;
+      if (idx < 0 && code >= 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 scalarParsers[idx](input, pos, ctx);
+        ctx._fx = deriveExpected(parsers[idx]);
+        return ~pos;
+      }
+    } else {
+      for (let i = 0; i < scalarParsers.length; i++) {
+        if (gates[i] && !gates[i](ctx.state)) continue;
+        const end = scalarParsers[i](input, pos, ctx);
+        if (end >= 0 && (!autoNot[i] || !autoNotFires(input, end, autoNot[i]))) return end;
+      }
+    }
+    ctx._fx = scalarExpected;
+    return ~pos;
+  };
+  return {
+    _tag: "choice",
+    _meta: meta,
+    _def: {
+      tag: "choice",
+      parsers,
+      gates,
+      disjoint,
+      strategy: strategy ?? { tag: "firstMatch" },
+      autoNot
+    },
+    _parseScalar: scalarEligible ? parseScalar : void 0,
+    parse(input, pos, ctx) {
+      const expected = [];
+      let expectedAt = pos;
+      if (disjoint) {
+        const code = pos < input.length ? input.codePointAt(pos) : -1;
+        let idx = code >= 0 && code < 128 ? asciiDispatch[code] : -1;
+        if (idx < 0 && code >= 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 } };
+        }
+        if (ctx._probe !== void 0 || ctx._tolerant) for (const p of parsers) p.parse(input, pos, ctx);
+        return { ok: false, expected: [...scalarExpected], 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 split = ctx._columnsSplit;
+        const result = parsers[i].parse(input, pos, ctx);
+        if (!result.ok) {
+          rollbackTrivia(ctx, mark);
+          ctx._columnsSplit = split;
+          const at = result.span.start;
+          if (at > expectedAt) {
+            expectedAt = at;
+            expected.length = 0;
+          }
+          if (at === expectedAt) 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;
+      }
+      if (expected.length === 0) {
+        for (const parser2 of parsers) expected.push(...deriveExpected(parser2));
+      }
+      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:${JSON.stringify([d.source, 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") {
@@ -6472,361 +6808,98 @@ function token(root) {
     parse(input, pos, ctx) {
       const savedTrivia = ctx.trivia;
       const savedKinds = ctx.triviaKindLabels;
-      const savedBuf = ctx._cstBuf;
-      const savedChildren = ctx._cstChildren;
-      const savedLeaves = ctx._cstLeaves;
-      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;
-      ctx._cstBuf = void 0;
-      ctx._cstChildren = void 0;
-      ctx._cstLeaves = void 0;
-      ctx._cstRawChildren = void 0;
-      ctx._cstTriviaLog = void 0;
-      ctx._triviaLog = void 0;
-      ctx._rootTriviaLog = void 0;
-      let result;
-      try {
-        result = root.parse(input, pos, ctx);
-      } finally {
-        ctx.trivia = savedTrivia;
-        ctx.triviaKindLabels = savedKinds;
-        ctx._cstBuf = savedBuf;
-        ctx._cstChildren = savedChildren;
-        ctx._cstLeaves = savedLeaves;
-        ctx._cstRawChildren = savedRaw;
-        ctx._cstTriviaLog = savedTriviaLog;
-        ctx._triviaLog = savedOuterTriviaLog;
-        ctx._rootTriviaLog = savedRootTriviaLog;
-      }
-      if (!result.ok) return result;
-      const span = result.span;
-      const value = input.slice(pos, span.end);
-      if (wasCapturing) pushCstLeaf(ctx, new PlainLeaf6(value, span));
-      return { ok: true, value, span };
-    }
-  };
-}
-function makeLeaf(root, fn, sourceCstValue) {
-  const cstValue = sourceCstValue ? sourceLeafValue : semanticLeafValue;
-  const meta = {
-    firstSet: root._meta.firstSet,
-    canMatchNewline: root._meta.canMatchNewline,
-    isTrivia: false
-  };
-  return {
-    _tag: "leaf",
-    _meta: meta,
-    _def: {
-      tag: "leaf",
-      parser: root,
-      fn,
-      ...sourceCstValue ? { cstValue: "source" } : {}
-    },
-    parse(input, pos, ctx) {
-      const savedBuf = ctx._cstBuf;
-      const savedChildren = ctx._cstChildren;
-      const savedLeaves = ctx._cstLeaves;
-      const savedRaw = ctx._cstRawChildren;
-      const savedTriviaLog = ctx._cstTriviaLog;
-      const savedOuterTriviaLog = ctx._triviaLog;
-      const wasCapturing = cstCaptureActive(ctx);
-      ctx._cstBuf = void 0;
-      ctx._cstChildren = void 0;
-      ctx._cstLeaves = void 0;
-      ctx._cstRawChildren = void 0;
-      ctx._cstTriviaLog = void 0;
-      ctx._triviaLog = void 0;
-      let result;
-      try {
-        result = root.parse(input, pos, ctx);
-      } finally {
-        ctx._cstBuf = savedBuf;
-        ctx._cstChildren = savedChildren;
-        ctx._cstLeaves = savedLeaves;
-        ctx._cstRawChildren = savedRaw;
-        ctx._cstTriviaLog = savedTriviaLog;
-        ctx._triviaLog = savedOuterTriviaLog;
-      }
-      if (!result.ok) return result;
-      const value = fn(result.value, result.span);
-      if (wasCapturing) pushCstLeaf(ctx, new PlainLeaf6(cstValue(ctx, input, pos, result.span.end, value), result.span));
-      return { ok: true, value, span: result.span };
-    }
-  };
-}
-function leaf(root, fn) {
-  return makeLeaf(root, fn, false);
-}
-function sourceLeaf(root, fn) {
-  return makeLeaf(root, fn, true);
-}
-
-// src/compiler/value-usage.ts
-function markUnusedValues(root) {
-  const seenConsumed = /* @__PURE__ */ new WeakSet();
-  const seenUnconsumed = /* @__PURE__ */ new WeakSet();
-  const mark = (def, consumed) => {
-    if (consumed) def.valueUnused = false;
-    else if (def.valueUnused !== false) def.valueUnused = true;
-  };
-  const visit = (c, consumed) => {
-    const seen = consumed ? seenConsumed : seenUnconsumed;
-    if (seen.has(c)) return;
-    seen.add(c);
-    const def = c._def;
-    switch (def.tag) {
-      case "many":
-      case "oneOrMore":
-        mark(def, consumed);
-        visit(def.parser, consumed);
-        return;
-      case "optional":
-        visit(def.parser, consumed);
-        return;
-      case "sequence":
-        mark(def, consumed);
-        for (const p of def.parsers) visit(p, consumed);
-        return;
-      case "choice":
-        for (const p of def.parsers) visit(p, consumed);
-        return;
-      case "dispatch":
-        visit(def.selector, consumed);
-        for (const entry of def.cases) visit(entry.parser, consumed);
-        if (def.matchers) for (const entry of def.matchers) visit(entry.parser, consumed);
-        if (def.otherwise) visit(def.otherwise, consumed);
-        return;
-      case "node":
-        visit(def.parser, false);
-        return;
-      case "transform":
-        visit(def.parser, true);
-        return;
-      case "field":
-        visit(def.parser, true);
-        return;
-      case "sepBy":
-        visit(def.parser, true);
-        visit(def.separator, false);
-        return;
-      case "not":
-      case "peek":
-        visit(def.parser, false);
-        return;
-      case "grammar":
-        visit(def.parser, consumed);
-        if (def.triviaParser) visit(def.triviaParser, false);
-        return;
-      case "recover":
-        visit(def.parser, consumed);
-        visit(def.sentinel, false);
-        return;
-      case "token":
-        visit(def.parser, false);
-        return;
-      case "label":
-      case "trivia":
-      case "attempt":
-      case "withCtx":
-      case "expect":
-        visit(def.parser, consumed);
-        return;
-      case "leaf":
-        visit(def.parser, true);
-        return;
-      case "lazy":
-        return;
-      default:
-        return;
-    }
-  };
-  const resolveRoot = (c) => {
-    const guard = /* @__PURE__ */ new Set();
-    let cur = c;
-    while (!guard.has(cur)) {
-      const d = cur._def;
-      if (d.tag === "grammar") {
-        guard.add(cur);
-        cur = d.parser;
-        continue;
-      }
-      if (d.tag !== "lazy") return cur;
-      guard.add(cur);
-      try {
-        cur = d.thunk();
-      } catch {
-        return c;
-      }
-    }
-    return cur;
-  };
-  visit(resolveRoot(root), true);
-}
-
-// src/cst/root-trivia-scope.ts
-var ROOT_TRIVIA_SCOPE_REFUSAL = "parser(): selected root trivia requires classifiedTrivia() for every local trivia scope, or rootCapture: 'opaque'.";
-function refuseUnclassifiedRootScope(strict) {
-  if (strict === true) throw new TypeError(ROOT_TRIVIA_SCOPE_REFUSAL);
-}
-
-// 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 };
-}
-var TRACK_LINES_ON = () => true;
-var TRACK_LINES_OFF = () => false;
-var TRACK_LINES_INHERIT = (ctx) => ctx?.trackLines === true;
-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.");
-  }
-  const scopeTrivia = clearTrivia ? void 0 : opts.trivia ?? void 0;
-  const scopeLabels = scopeTrivia?._meta?.triviaKindLabels;
-  const refuseUnclassified = scopeTrivia !== void 0 && !scopeTrivia._meta?.rootTriviaClassified && !opaqueRootCapture;
-  const forceCaptureTrivia = opts.captureTrivia === true;
-  const trackLinesPolicy = opts.trackLines === true ? "on" : opts.trackLines === false ? "off" : "inherit";
-  const trackLinesOf = trackLinesPolicy === "on" ? TRACK_LINES_ON : trackLinesPolicy === "off" ? TRACK_LINES_OFF : TRACK_LINES_INHERIT;
-  const captureKinds = clearTrivia ? void 0 : opts.captureTriviaKinds;
-  const ownCaptureMask = captureKinds === void 0 ? void 0 : scopeLabels !== void 0 ? triviaKindMask(scopeLabels, captureKinds) : void 0;
-  const inheritCaptureMask = captureKinds !== void 0 && scopeLabels === void 0;
-  const rootScalar = scalarOf(root);
-  const scalarEligible = opts.trackLines !== true && opts.recover !== true && !opaqueRootCapture && !forceCaptureTrivia && captureKinds === void 0;
-  const parseScalar = scalarEligible ? (input, pos, ctx) => {
-    const savedTrivia = ctx.trivia;
-    const savedLabels = ctx.triviaKindLabels;
-    if (clearTrivia) {
+      const savedBuf = ctx._cstBuf;
+      const savedChildren = ctx._cstChildren;
+      const savedLeaves = ctx._cstLeaves;
+      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;
-    } else if (scopeTrivia !== void 0) {
-      ctx.trivia = scopeTrivia;
-      ctx.triviaKindLabels = scopeLabels;
+      ctx._cstBuf = void 0;
+      ctx._cstChildren = void 0;
+      ctx._cstLeaves = void 0;
+      ctx._cstRawChildren = void 0;
+      ctx._cstTriviaLog = void 0;
+      ctx._triviaLog = void 0;
+      ctx._rootTriviaLog = void 0;
+      let result;
+      try {
+        result = root.parse(input, pos, ctx);
+      } finally {
+        ctx.trivia = savedTrivia;
+        ctx.triviaKindLabels = savedKinds;
+        ctx._cstBuf = savedBuf;
+        ctx._cstChildren = savedChildren;
+        ctx._cstLeaves = savedLeaves;
+        ctx._cstRawChildren = savedRaw;
+        ctx._cstTriviaLog = savedTriviaLog;
+        ctx._triviaLog = savedOuterTriviaLog;
+        ctx._rootTriviaLog = savedRootTriviaLog;
+      }
+      if (!result.ok) return result;
+      const span = result.span;
+      const value = input.slice(pos, span.end);
+      if (wasCapturing) pushCstLeaf(ctx, new PlainLeaf6(value, span));
+      return { ok: true, value, span };
     }
-    const end = rootScalar(input, pos, ctx);
-    ctx.trivia = savedTrivia;
-    ctx.triviaKindLabels = savedLabels;
-    return end;
-  } : void 0;
-  let publicScalar;
-  const grammar = {
-    _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 } : {}
-    },
+  };
+}
+function makeLeaf(root, fn, sourceCstValue) {
+  const cstValue = sourceCstValue ? sourceLeafValue : semanticLeafValue;
+  const meta = {
+    firstSet: root._meta.firstSet,
+    canMatchNewline: root._meta.canMatchNewline,
+    isTrivia: false
+  };
+  return {
+    _tag: "leaf",
+    _meta: meta,
     _def: {
-      tag: "grammar",
+      tag: "leaf",
       parser: root,
-      triviaParser: scopeTrivia,
-      clearTrivia,
-      ...opaqueRootCapture ? { rootCapture: "opaque" } : {},
-      ...opts.captureTrivia ? { captureTrivia: true } : {},
-      trackLines: opts.trackLines ?? false,
-      constructionTrackLines: trackLinesPolicy,
-      ...captureKinds === void 0 ? {} : { constructionCaptureTriviaKinds: captureKinds }
+      fn,
+      ...sourceCstValue ? { cstValue: "source" } : {}
     },
-    _parseScalar: parseScalar,
-    parse(input, pos, _ctx) {
-      if (pos === void 0 && _ctx === void 0) {
-        publicScalar ??= scalarRootOf(grammar) ?? null;
-        if (publicScalar) {
-          const ctx2 = createParseContext();
-          const end = publicScalar(input, 0, ctx2);
-          if (end < 0) {
-            const at = ~end;
-            return { ok: false, expected: ctx2._fx ?? [], span: { start: at, end: at } };
-          }
-          return { ok: true, value: ctx2._sv, span: { start: 0, end } };
-        }
-      }
-      if (refuseUnclassified) refuseUnclassifiedRootScope(_ctx?._rootTriviaStrictScopes);
-      const trackLines = trackLinesOf(_ctx);
-      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 === void 0 ? createParseContext() : { ..._ctx };
-      ctx.trackLines = trackLines;
-      if (lineIndex) ctx._lineIndex = lineIndex;
-      if (lineContext) ctx._lineScannedTo = lineContext.lineScannedTo;
-      if (clearTrivia) {
-        ctx.trivia = void 0;
-        ctx.triviaKindLabels = void 0;
-      } else if (scopeTrivia !== void 0) {
-        ctx.trivia = scopeTrivia;
-        if (scopeLabels) ctx.triviaKindLabels = scopeLabels;
-      }
-      if (forceCaptureTrivia || _ctx?.captureTrivia) ctx.captureTrivia = true;
-      if (ownCaptureMask !== void 0) ctx._triviaCaptureMask = ownCaptureMask;
-      else if (inheritCaptureMask) ctx._triviaCaptureMask = triviaKindMask(_ctx?.triviaKindLabels, captureKinds);
-      if (opaqueRootCapture) ctx._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);
+    parse(input, pos, ctx) {
+      const savedBuf = ctx._cstBuf;
+      const savedChildren = ctx._cstChildren;
+      const savedLeaves = ctx._cstLeaves;
+      const savedRaw = ctx._cstRawChildren;
+      const savedTriviaLog = ctx._cstTriviaLog;
+      const savedOuterTriviaLog = ctx._triviaLog;
+      const wasCapturing = cstCaptureActive(ctx);
+      ctx._cstBuf = void 0;
+      ctx._cstChildren = void 0;
+      ctx._cstLeaves = void 0;
+      ctx._cstRawChildren = void 0;
+      ctx._cstTriviaLog = void 0;
+      ctx._triviaLog = void 0;
+      let result;
+      try {
+        result = root.parse(input, pos, ctx);
+      } finally {
+        ctx._cstBuf = savedBuf;
+        ctx._cstChildren = savedChildren;
+        ctx._cstLeaves = savedLeaves;
+        ctx._cstRawChildren = savedRaw;
+        ctx._cstTriviaLog = savedTriviaLog;
+        ctx._triviaLog = savedOuterTriviaLog;
       }
-      return lineIndex ? annotateResultLines(result, normalizeLineIndex(lineIndex)) : result;
+      if (!result.ok) return result;
+      const value = fn(result.value, result.span);
+      if (wasCapturing) pushCstLeaf(ctx, new PlainLeaf6(cstValue(ctx, input, pos, result.span.end, value), result.span));
+      return { ok: true, value, span: result.span };
     }
   };
-  return grammar;
 }
-function noTrivia(root) {
-  return parser({ trivia: null }, root);
+function leaf(root, fn) {
+  return makeLeaf(root, fn, false);
 }
-var _analyzed = /* @__PURE__ */ new WeakSet();
-function parse(combinator, input, opts = {}) {
-  if (!_analyzed.has(combinator)) {
-    _analyzed.add(combinator);
-    markUnusedValues(combinator);
-  }
-  if (!opts.trackLines && !opts.recover && combinator._def.tag === "grammar" && combinator._meta.grammarScanSkip === void 0) {
-    return combinator.parse(input);
-  }
-  const trackLines = opts.trackLines ?? combinator._meta.grammarTrackLines ?? false;
-  const lineContext = trackLines ? createParseLineContext(input, 0) : void 0;
-  const lineIndex = lineContext?.lineIndex;
-  const _errors = opts.recover ? [] : void 0;
-  const _probe = opts.recover ? { offset: input.length, best: null } : void 0;
-  const grammarTrivia = combinator._meta.grammarTrivia;
-  const grammarScanSkip = combinator._meta.grammarScanSkip;
-  const ctx = createParseContext();
-  ctx.trackLines = trackLines;
-  if (lineIndex) ctx._lineIndex = lineIndex;
-  if (lineContext) ctx._lineScannedTo = lineContext.lineScannedTo;
-  if (grammarTrivia !== void 0) {
-    ctx.trivia = grammarTrivia;
-    if (grammarTrivia._meta.triviaKindLabels) ctx.triviaKindLabels = grammarTrivia._meta.triviaKindLabels;
-  }
-  if (grammarScanSkip !== void 0) ctx.scanSkip = grammarScanSkip;
-  if (_errors !== void 0) ctx._errors = _errors;
-  if (_probe !== void 0) ctx._probe = _probe;
-  const result = combinator.parse(input, 0, ctx);
-  if (!result.ok) return lineIndex ? annotateResultLines(result, normalizeLineIndex(lineIndex)) : result;
-  const withErrors = _errors !== void 0 ? { ...result, errors: _errors, furthestFail: _probe?.best ?? null } : result;
-  return lineIndex ? annotateResultLines(withErrors, normalizeLineIndex(lineIndex)) : withErrors;
+function sourceLeaf(root, fn) {
+  return makeLeaf(root, fn, true);
 }
 
 // src/combinators/attempt.ts
@@ -7110,6 +7183,7 @@ var OP_LIT_CI = 27;
 var OP_LIT_CI_TRACK = 28;
 var OP_TOKEN = 29;
 var OP_SCOPE_CAP = 30;
+var SCOPE_INHERIT = -2;
 var OP_WITHCTX = 31;
 var OP_GUARD = 32;
 var OP_ADJ = 33;
@@ -8909,7 +8983,7 @@ var Encoder = class {
         this.triviaKnown = savedKnown;
         if (d.clearTrivia === true) return this.emit(op, -1, bodyIp, flags);
         if (d.triviaParser === void 0) {
-          return cap || flags !== 0 ? this.emit(op, -1, bodyIp, flags) : bodyIp;
+          return cap ? this.emit(op, SCOPE_INHERIT, bodyIp, flags) : bodyIp;
         }
         return this.emit(op, this.triviaSlot(d.triviaParser), bodyIp, flags);
       }
@@ -10301,7 +10375,7 @@ function transfer(code, ip, at, hostCst) {
   const op = code[ip];
   if (op === OP_SCOPE || op === OP_SCOPE_CAP || op === OP_SCOPE_PLAIN) {
     const ki = code[ip + 1];
-    const tri = ki < 0 ? TRI_NONE : ki;
+    const tri = ki === SCOPE_INHERIT ? at.tri : ki < 0 ? TRI_NONE : ki;
     const cap = op === OP_SCOPE_CAP ? CAP_ON : at.cap;
     if (tri === at.tri && cap === at.cap) return at;
     return { tri, buf: at.buf, raw: at.raw, cap };
@@ -10375,7 +10449,7 @@ function scanHandoffNeeded(code, ip, labels) {
     if (l.tri === TRI_UNKNOWN) return true;
     const op = code[at];
     if (op === OP_SCAN) return true;
-    if (op === OP_TOKEN || op === OP_SCOPE_CAP) continue;
+    if (op === OP_TOKEN || op === OP_SCOPE_CAP && code[at + 1] !== SCOPE_INHERIT) continue;
     if ((op === OP_SCOPE_PLAIN || op === OP_SCOPE) && !(code[at + 1] >= 0 && l.tri === code[at + 1] && (op === OP_SCOPE_PLAIN || code[at + 3] === 0))) continue;
     kids.length = 0;
     if (!childSlots(code, at, kids)) return true;
@@ -11670,6 +11744,15 @@ return r.value
         const cap = op === OP_SCOPE_CAP;
         const flags = op === OP_SCOPE_PLAIN ? 0 : code[ip + 3];
         const child = link(code[ip + 2]);
+        if (ki === SCOPE_INHERIT) {
+          return `${head}
+const sC=ctx.captureTrivia
+ctx.captureTrivia=true
+const v=${child}(input,pos,ctx)
+ctx.captureTrivia=sC
+return v
+}`;
+        }
         const scanFor = swapLegal && ki >= 0 && !triviaLabelled[ki] ? hoist("ts", `TRIVIASCAN[${ki}]`) : "null";
         const tri = ki < 0 ? "undefined" : hoist("tv", `TRIVIA[${ki}]`);
         const lab = ki < 0 ? "undefined" : hoist("tl", `TRIVIA[${ki}]._meta.triviaKindLabels`);
@@ -13029,73 +13112,6 @@ function literal(value, opts = {}) {
   };
 }
 
-// src/combinators/ref.ts
-function withRuleTrivia(trivia2, ctx, run) {
-  const savedLabels = ctx.triviaKindLabels;
-  ctx.trivia = trivia2;
-  ctx.triviaKindLabels = trivia2._meta.triviaKindLabels;
-  try {
-    return run();
-  } finally {
-    ctx.trivia = void 0;
-    ctx.triviaKindLabels = savedLabels;
-  }
-}
-var UNDEFINED_REF = new Error("ref<T>() used before .define() was called");
-function ref() {
-  let resolved = null;
-  let resolvedScalar = null;
-  let ownBoundary = false;
-  const meta = {
-    firstSet: any(),
-    canMatchNewline: true,
-    isTrivia: false
-  };
-  const slot = {
-    _tag: "lazy",
-    _meta: meta,
-    _def: {
-      tag: "lazy",
-      thunk: () => {
-        if (!resolved) throw UNDEFINED_REF;
-        return resolved;
-      }
-    },
-    _parseScalar(input, pos, ctx) {
-      const scalar = resolvedScalar;
-      if (!scalar) throw new Error("ref<T>() used before .define() was called");
-      const gt = meta.grammarTrivia;
-      if (gt !== void 0 && ownBoundary && ctx.trivia === void 0) {
-        return withRuleTrivia(gt, ctx, () => scalar(input, pos, ctx));
-      }
-      return scalar(input, pos, ctx);
-    },
-    parse(input, pos, ctx) {
-      const parser2 = resolved;
-      if (!parser2) throw new Error("ref<T>() used before .define() was called");
-      const gt = meta.grammarTrivia;
-      if (gt !== void 0 && ownBoundary && ctx.trivia === void 0) {
-        return withRuleTrivia(gt, ctx, () => parser2.parse(input, pos, ctx));
-      }
-      return parser2.parse(input, pos, ctx);
-    },
-    define(p) {
-      if (resolved) throw new Error("ref<T>() already defined");
-      resolved = p;
-      resolvedScalar = scalarOf(p);
-      ownBoundary = hasOwnTriviaBoundary(p);
-      meta.firstSet = p._meta.firstSet;
-      meta.canMatchNewline = p._meta.canMatchNewline;
-      meta.isTrivia = p._meta.isTrivia;
-      if (p._meta.triviaKindLabels !== void 0) meta.triviaKindLabels = p._meta.triviaKindLabels;
-      else delete meta.triviaKindLabels;
-      if (p._meta.disjoint !== void 0) meta.disjoint = p._meta.disjoint;
-      else delete meta.disjoint;
-    }
-  };
-  return slot;
-}
-
 // src/combinators/scanTo.ts
 import { PlainLeaf as PlainLeaf8, PlainSpan as PlainSpan9 } from "../cst/plain.js";
 function resolveScanSkip(explicitSkip, raw, ctx) {
@@ -13415,7 +13431,7 @@ function clearOf(ranges, input, from, to) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.60.4";
+var PARSEMAN_VERSION = "0.60.6";
 
 // src/table/assemble.ts
 import { PlainBuf as PlainBuf2, PlainField, PlainLeaf as PlainLeaf9, PlainNode as PlainNode2, PlainSpan as PlainSpan10 } from "../cst/plain.js";
@@ -14928,6 +14944,16 @@ function assemble(t2, prog, cfg) {
       case OP_SCOPE_CAP:
       case OP_SCOPE_PLAIN: {
         const ki = code[ip + 1];
+        if (ki === SCOPE_INHERIT) {
+          const body = link(code[ip + 2]);
+          return (input, pos, ctx) => {
+            const savedCap = ctx.captureTrivia;
+            ctx.captureTrivia = true;
+            const v = body(input, pos, ctx);
+            ctx.captureTrivia = savedCap;
+            return v;
+          };
+        }
         const scopeTrivia = ki < 0 ? void 0 : trivia2[ki];
         const scopeLabels = scopeTrivia?._meta.triviaKindLabels;
         const scanFor = swapLegal && ki >= 0 && !triviaLabelled[ki] ? triviaScan[ki] : null;