parseman 0.35.0 → 0.37.0

package/dist/spec/index.cjs

@@ -32,8 +32,2919 @@ __export(spec_exports, {
 });
 module.exports = __toCommonJS(spec_exports);
 
+// src/combinators/first-set.ts
+function resolveNamedRef(p, resolve) {
+  if (resolve === void 0) return void 0;
+  const name = p._ruleName;
+  return name === void 0 ? void 0 : resolve(name);
+}
+function union(a, b) {
+  if (a.kind === "any" || b.kind === "any") return { kind: "any" };
+  if (a.kind === "empty") return b;
+  if (b.kind === "empty") return a;
+  return { kind: "ranges", ranges: mergeRanges([...a.ranges, ...b.ranges]) };
+}
+function intersects(a, b) {
+  if (a.kind === "any" || b.kind === "any") return true;
+  if (a.kind === "empty" || b.kind === "empty") return false;
+  for (const ra of a.ranges) {
+    for (const rb of b.ranges) {
+      if (ra.lo <= rb.hi && rb.lo <= ra.hi) return true;
+    }
+  }
+  return false;
+}
+function fromChar(code) {
+  return { kind: "ranges", ranges: [{ lo: code, hi: code }] };
+}
+function startsFirstSet(combinator, input, pos) {
+  const fs = combinator._meta.firstSet;
+  if (fs.kind === "any") return true;
+  if (fs.kind === "empty") return false;
+  const code = input.codePointAt(pos);
+  if (code === void 0) return false;
+  for (const r of fs.ranges) if (code >= r.lo && code <= r.hi) return true;
+  return false;
+}
+function any() {
+  return { kind: "any" };
+}
+function empty() {
+  return { kind: "empty" };
+}
+function matchesEmpty(p, seen = /* @__PURE__ */ new Set(), resolve) {
+  if (seen.has(p)) return true;
+  seen.add(p);
+  const me = (c) => matchesEmpty(c, seen, resolve);
+  const d = p._def;
+  switch (d.tag) {
+    case "literal":
+      return d.value.length === 0;
+    case "keywords":
+      return false;
+    case "regex":
+      try {
+        const m = new RegExp(d.source).exec("");
+        return m != null && m[0] === "";
+      } catch {
+        return true;
+      }
+    case "many":
+    case "optional":
+    case "not":
+    case "peek":
+      return true;
+    // zero repetitions / absent / lookahead
+    // Default `sepBy` is `(item (sep item)*)?` — it MATCHES THE EMPTY STRING.
+    // Any `min >= 1` requires that many ITEMS, so it is nullable only when the
+    // item is. (Keying this off `min === 1` reported every `{ min: 2 }` list as
+    // nullable — safe, but wrong, and it put a bogus `nullable-prefix` note on
+    // the gating diagnostic for a list that can never match empty.)
+    case "sepBy":
+      return d.min >= 1 ? me(d.parser) : true;
+    case "oneOrMore":
+      return me(d.parser);
+    case "sequence":
+      return d.parsers.every(me);
+    case "choice":
+      return d.parsers.some(me);
+    case "transform":
+    case "label":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "expect":
+    case "withCtx":
+    case "node":
+    case "grammar":
+    case "recover":
+      return me(d.parser);
+    case "skip":
+      return me(d.main);
+    case "lazy":
+      try {
+        return me(d.thunk());
+      } catch {
+        const t = resolveNamedRef(p, resolve);
+        return t ? me(t) : true;
+      }
+    default:
+      return true;
+  }
+}
+function isZeroWidthAssertion(p) {
+  return p._def.tag === "not";
+}
+function isPositiveLookahead(p) {
+  return p._def.tag === "peek";
+}
+function narrowBy(acc, constraint) {
+  if (constraint.kind === "any") return acc;
+  if (acc === null) return constraint;
+  if (acc.kind === "any") return constraint;
+  if (acc.kind === "empty" || constraint.kind === "empty") return { kind: "empty" };
+  const ranges = [];
+  for (const a of acc.ranges) for (const b of constraint.ranges) {
+    const lo = Math.max(a.lo, b.lo);
+    const hi = Math.min(a.hi, b.hi);
+    if (lo <= hi) ranges.push({ lo, hi });
+  }
+  return ranges.length === 0 ? { kind: "empty" } : { kind: "ranges", ranges };
+}
+function applyAssertion(fs, assertion) {
+  if (assertion === null) return fs;
+  if (fs.kind === "empty") return assertion;
+  return narrowBy(fs, assertion) ?? fs;
+}
+function sequenceFirstSet(parsers) {
+  let fs = empty();
+  let assertion = null;
+  for (const p of parsers) {
+    if (isPositiveLookahead(p)) {
+      assertion = narrowBy(assertion, p._meta.firstSet);
+      continue;
+    }
+    if (!isZeroWidthAssertion(p)) fs = union(fs, p._meta.firstSet);
+    if (!matchesEmpty(p)) return applyAssertion(fs, assertion);
+  }
+  return applyAssertion(fs, assertion);
+}
+function firstSetOf(p, seen = /* @__PURE__ */ new Set(), resolve) {
+  if (seen.has(p)) return any();
+  seen.add(p);
+  const fs = (c) => firstSetOf(c, seen, resolve);
+  const empties = (c) => matchesEmpty(c, /* @__PURE__ */ new Set(), resolve);
+  const d = p._def;
+  switch (d.tag) {
+    case "literal":
+    case "regex":
+    case "keywords":
+      return p._meta.firstSet;
+    // terminals: no refs, cached set is exact
+    case "lazy":
+      try {
+        return fs(d.thunk());
+      } catch {
+        const t = resolveNamedRef(p, resolve);
+        return t ? fs(t) : any();
+      }
+    case "choice": {
+      let out = empty();
+      for (const arm of d.parsers) out = union(out, fs(arm));
+      return out;
+    }
+    case "sequence": {
+      let out = empty();
+      let assertion = null;
+      for (const term of d.parsers) {
+        if (isPositiveLookahead(term)) {
+          assertion = narrowBy(assertion, fs(term));
+          continue;
+        }
+        if (!isZeroWidthAssertion(term)) out = union(out, fs(term));
+        if (!empties(term)) return applyAssertion(out, assertion);
+      }
+      return applyAssertion(out, assertion);
+    }
+    case "peek": {
+      const inner = d.parser;
+      return empties(inner) ? any() : fs(inner);
+    }
+    case "oneOrMore":
+    case "many":
+    case "optional":
+    case "transform":
+    case "label":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "node":
+    case "grammar":
+    case "expect":
+      return fs(d.parser);
+    case "sepBy":
+      return fs(d.parser);
+    // both min 0 and min 1 start with the item
+    case "skip":
+      return fs(d.main);
+    default:
+      return p._meta.firstSet;
+  }
+}
+function mergeRanges(ranges) {
+  if (ranges.length === 0) return [];
+  const sorted = [...ranges].sort((a, b) => a.lo - b.lo);
+  const out = [{ lo: sorted[0].lo, hi: sorted[0].hi }];
+  for (let i = 1; i < sorted.length; i++) {
+    const top = out[out.length - 1];
+    const cur = sorted[i];
+    if (cur.lo <= top.hi + 1) {
+      if (cur.hi > top.hi) top.hi = cur.hi;
+    } else {
+      out.push({ lo: cur.lo, hi: cur.hi });
+    }
+  }
+  return out;
+}
+
+// src/combinators/ref.ts
+function ref() {
+  let resolved = null;
+  const meta = {
+    firstSet: any(),
+    canMatchNewline: true,
+    isTrivia: false
+  };
+  const slot = {
+    _tag: "lazy",
+    _meta: meta,
+    _def: {
+      tag: "lazy",
+      thunk: () => {
+        if (!resolved) throw new Error("ref<T>() used before .define() was called");
+        return resolved;
+      }
+    },
+    parse(input, pos, ctx) {
+      if (!resolved) throw new Error("ref<T>() used before .define() was called");
+      return resolved.parse(input, pos, ctx);
+    },
+    define(p) {
+      if (resolved) throw new Error("ref<T>() already defined");
+      resolved = 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/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 "node":
+        visit(def.parser, false);
+        return;
+      case "transform":
+        visit(def.parser, true);
+        return;
+      case "field":
+        visit(def.parser, true);
+        return;
+      case "skip":
+        visit(def.main, consumed);
+        visit(def.skipped, false);
+        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 "label":
+      case "trivia":
+      case "token":
+      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 !== "lazy") return cur;
+      guard.add(cur);
+      try {
+        cur = d.thunk();
+      } catch {
+        return c;
+      }
+    }
+    return cur;
+  };
+  visit(resolveRoot(root), true);
+}
+
 // 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 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];
+    }
+  });
+  const definitions = factory(proxy);
+  for (const key of Object.keys(definitions)) {
+    const placeholder = cache[key];
+    const parser2 = definitions[key];
+    if (placeholder !== void 0 && typeof placeholder.define === "function") {
+      tagRule(parser2, key);
+      placeholder.define(parser2);
+      placeholder._meta.firstSet = parser2._meta.firstSet;
+      placeholder._meta.canMatchNewline = parser2._meta.canMatchNewline;
+    } 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";
+    }
+  }
+  for (const key of Object.keys(definitions)) {
+    markUnusedValues(cache[key]);
+  }
+  Object.defineProperty(cache, RULE_ORDER, {
+    value: Object.keys(definitions),
+    enumerable: false,
+    configurable: true
+  });
+  return cache;
+}
+
+// src/cst/capture-buffer.ts
+var EMPTY = [];
+var EMPTY_TL = [];
+function cstCaptureActive(ctx) {
+  return ctx._cstBuf !== void 0 || ctx._cstLeaves !== void 0;
+}
+function beginCstNodeCapture(ctx) {
+  const saved = {
+    ch: ctx._cstChildren,
+    lv: ctx._cstLeaves,
+    raw: ctx._cstRawChildren,
+    tl: ctx._cstTriviaLog,
+    cap: ctx.captureTrivia,
+    buf: ctx._cstBuf
+  };
+  ctx._cstBuf = {};
+  ctx._cstChildren = void 0;
+  ctx._cstLeaves = void 0;
+  ctx._cstRawChildren = void 0;
+  ctx._cstTriviaLog = void 0;
+  ctx.captureTrivia = true;
+  return saved;
+}
+function finishCstBuf(buf) {
+  if (!buf) return { children: EMPTY, rawChildren: EMPTY, triviaLog: EMPTY_TL };
+  const children = buf.ch ?? (buf.single !== void 0 ? [buf.single] : EMPTY);
+  const rawChildren = buf.raw ?? (buf.rawSingle !== void 0 ? [buf.rawSingle] : EMPTY);
+  const triviaLog = buf.tl ?? EMPTY_TL;
+  return { children, rawChildren, triviaLog };
+}
+function endCstNodeCapture(ctx, saved) {
+  const materialized = finishCstBuf(ctx._cstBuf);
+  ctx._cstBuf = saved.buf;
+  ctx._cstChildren = saved.ch;
+  ctx._cstLeaves = saved.lv;
+  ctx._cstRawChildren = saved.raw;
+  ctx._cstTriviaLog = saved.tl;
+  ctx.captureTrivia = saved.cap;
+  return materialized;
+}
+function pushCstLeaf(ctx, leaf2) {
+  pushCstChild(ctx, leaf2, leaf2);
+}
+function pushCstChild(ctx, built, rawEntry) {
+  const b = ctx._cstBuf;
+  if (b) {
+    if (b.ch) b.ch.push(built);
+    else if (b.single !== void 0) {
+      b.ch = [b.single, built];
+      b.single = void 0;
+    } else b.single = built;
+    if (b.raw) b.raw.push(rawEntry);
+    else if (b.rawSingle !== void 0) {
+      b.raw = [b.rawSingle, rawEntry];
+      b.rawSingle = void 0;
+    } else b.rawSingle = rawEntry;
+    return;
+  }
+  if (ctx._cstChildren) ctx._cstChildren.push(built);
+  else if (ctx._cstLeaves) ctx._cstLeaves.push(built);
+  if (ctx._cstRawChildren) ctx._cstRawChildren.push(rawEntry);
+}
+function cstRawLen(ctx) {
+  const b = ctx._cstBuf;
+  if (b) {
+    if (b.raw) return b.raw.length;
+    return b.rawSingle !== void 0 ? 1 : 0;
+  }
+  return ctx._cstRawChildren?.length ?? 0;
+}
+function cstLeavesLen(ctx) {
+  const b = ctx._cstBuf;
+  if (b) {
+    if (b.ch) return b.ch.length;
+    return b.single !== void 0 ? 1 : 0;
+  }
+  return ctx._cstLeaves?.length ?? 0;
+}
+function cstTlLen(ctx) {
+  const b = ctx._cstBuf;
+  if (b) return b.tl?.length ?? 0;
+  return ctx._cstTriviaLog?.length ?? 0;
+}
+function saveCstMark(ctx) {
+  return {
+    raw: cstRawLen(ctx),
+    tlog: cstTlLen(ctx),
+    leaves: cstLeavesLen(ctx),
+    fields: ctx._fields?.length ?? 0,
+    // Speculative rollback must truncate the flat recovery-error sink in lockstep
+    // with the CST leaves: a branch that recovered (pushing a ParseError to
+    // ctx._errors AND embedding it as a CST child via captureError) then failed
+    // must remove BOTH, or the flat error survives as a GHOST that a tree walk
+    // can't see (flat run().errors would disagree with the embedded set).
+    errors: ctx._errors?.length ?? 0
+  };
+}
+function rollbackBufList(b, keyMulti, keySingle, len) {
+  const arr = b[keyMulti];
+  if (arr) {
+    if (len === 0) b[keyMulti] = void 0;
+    else if (len === 1) {
+      b[keySingle] = arr[0];
+      b[keyMulti] = void 0;
+    } else if (arr.length !== len) arr.length = len;
+    return;
+  }
+  if (len === 0) b[keySingle] = void 0;
+}
+function rollbackCstCapture(ctx, mark) {
+  if (ctx._errors && mark.errors !== void 0 && ctx._errors.length !== mark.errors) ctx._errors.length = mark.errors;
+  const b = ctx._cstBuf;
+  if (b) {
+    rollbackBufList(b, "raw", "rawSingle", mark.raw);
+    rollbackBufList(b, "ch", "single", mark.leaves);
+    if (b.tl) {
+      if (mark.tlog === 0) b.tl = void 0;
+      else if (b.tl.length !== mark.tlog) b.tl.length = mark.tlog;
+    }
+    if (ctx._fields && ctx._fields.length !== mark.fields) ctx._fields.length = mark.fields;
+    return;
+  }
+  if (ctx._cstRawChildren && ctx._cstRawChildren.length !== mark.raw) ctx._cstRawChildren.length = mark.raw;
+  if (ctx._cstTriviaLog && ctx._cstTriviaLog.length !== mark.tlog) ctx._cstTriviaLog.length = mark.tlog;
+  if (ctx._cstLeaves && ctx._cstLeaves.length !== mark.leaves) ctx._cstLeaves.length = mark.leaves;
+  if (ctx._fields && ctx._fields.length !== mark.fields) ctx._fields.length = mark.fields;
+}
+function pushCstTriviaEntry(ctx, start, end, kindIndex) {
+  const insertIdx = cstRawLen(ctx);
+  const b = ctx._cstBuf;
+  const withKind = ctx.triviaKindLabels !== void 0 && kindIndex !== void 0;
+  if (b) {
+    if (!b.tl) {
+      b.tl = withKind ? [start, end, insertIdx, kindIndex] : [start, end, insertIdx];
+    } else if (withKind) {
+      b.tl.push(start, end, insertIdx, kindIndex);
+    } else {
+      b.tl.push(start, end, insertIdx);
+    }
+    return;
+  }
+  if (ctx._cstTriviaLog) {
+    if (withKind) ctx._cstTriviaLog.push(start, end, insertIdx, kindIndex);
+    else ctx._cstTriviaLog.push(start, end, insertIdx);
+  }
+}
+function pushTriviaLogEntry(ctx, start, end, kindIndex) {
+  if (!ctx._triviaLog) return;
+  if (ctx.triviaKindLabels !== void 0 && kindIndex !== void 0) {
+    ctx._triviaLog.push(start, end, kindIndex);
+  } else {
+    ctx._triviaLog.push(start, end);
+  }
+}
+
+// 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;
+  }
+}
+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 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 } };
+        }
+      }
+      return { ok: false, expected: [], span: { start: pos, end: pos } };
+    }
+  };
+}
+function recoverScan(input, from, ctx, sync, expected) {
+  let scanPos = from;
+  while (scanPos < input.length && !probeAt(sync, input, scanPos, ctx)) scanPos++;
+  const error = { _tag: "parseError", span: { start: from, end: scanPos }, expected };
+  ctx._errors?.push(error);
+  return { error, end: scanPos };
+}
+function matchesAt(sentinel, input, pos, ctx) {
+  return probeAt(sentinel, input, pos, ctx);
+}
+function captureError(ctx, error) {
+  if (cstCaptureActive(ctx)) pushCstChild(ctx, error, error);
+}
+
+// src/combinators/expect.ts
+function deriveExpected(c) {
+  return [...new Set(derive(c, /* @__PURE__ */ new Set()))];
+}
+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);
+    // 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":
+      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 "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);
+      }
+    }
+    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 error = { _tag: "parseError", span: { start: pos, end: pos }, expected };
+      ctx._errors?.push(error);
+      if (ctx._tolerant) captureError(ctx, error);
+      return { ok: true, value: error, span: { start: pos, end: pos } };
+    }
+  };
+}
+
+// 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: "choice",
+    _meta: meta,
+    _def: {
+      tag: "choice",
+      parsers,
+      gates,
+      disjoint,
+      strategy: strategy ?? { tag: "firstMatch" },
+      autoNot
+    },
+    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);
+          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 = 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);
+          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;
+      }
+      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;
+      }
+      const regexDef = getCoreRegexDef(other);
+      if (regexDef !== null) {
+        const contSet = continuationFirstSet(litVal, regexDef.source, regexDef.flags);
+        if (contSet !== null) checks.push({ kind: "firstSet", set: contSet });
+      }
+    }
+    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;
+    } else {
+      if (input.startsWith(check.value, end)) return true;
+    }
+  }
+  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);
+  }
+  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 (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];
+    }
+  }
+  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;
+      }
+    }
+  }
+  return table;
+}
+
+// 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/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 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
+  };
+  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 (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value, span });
+        return { ok: true, value, span };
+      }
+      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 (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
+  };
+}
+
+// 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 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 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) };
+    }
+    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 (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]);
+    }
+  }
+  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;
+  }
+  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 (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 && inRanges(input.charCodeAt(end), ranges)) {
+      end++;
+      if (end - pos >= SCAN_BAIL_AT) return void 0;
+    }
+    return minOne && end === pos ? null : end;
+  };
+}
+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);
+  }
+  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 { kind: "ranges", ranges: merged };
+}
+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 (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value, span: span2 });
+        return { ok: true, value, span: span2 };
+      }
+      anchored.lastIndex = pos;
+      const m = anchored.exec(input);
+      if (m === null) {
+        return failAt(ctx, [`/${source}/`], pos);
+      }
+      const span = { start: pos, end: pos + m[0].length };
+      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value: m[0], span });
+      return { ok: true, value: m[0], span };
+    }
+  };
+}
+
+// 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 });
+  }
+  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;
+      }
+    }
+    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;
+      }
+      break;
+    }
+    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 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 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/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 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 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 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 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 advanceTrivia(input, cur, ctx) {
+  const triviaP = ctx.trivia;
+  if (!triviaP) return cur;
+  const fast = fastTriviaScanner(triviaP);
+  if (fast) return fast(input, cur);
+  if (ctx.triviaKindLabels) {
+    const scan = scanWithLabels(input, cur, ctx);
+    return scan.end;
+  }
+  const tr = triviaP.parse(input, cur, { trackLines: ctx.trackLines, state: ctx.state });
+  return tr.ok && tr.span.end > cur ? tr.span.end : cur;
+}
+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);
+  const fast = !ctx.triviaKindLabels ? fastTriviaScanner(triviaP) : null;
+  if (fast && log === void 0 && !captureTl) {
+    return { end: fast(input, cur), commit: NOOP_COMMIT };
+  }
+  if (ctx.triviaKindLabels && (log !== void 0 || captureTl)) {
+    return scanWithLabels(input, cur, ctx);
+  }
+  if (log !== void 0 || captureTl) {
+    const tr2 = triviaP.parse(input, cur, {
+      trackLines: log !== void 0 ? false : ctx.trackLines,
+      state: ctx.state
+    });
+    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 = triviaP.parse(input, cur, { trackLines: ctx.trackLines, state: ctx.state });
+  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;
+    }
+    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) ?? (blockCommentSource(source) ? scanBlockComment : null);
+}
+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;
+  }
+  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 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++;
+    }
+    return pos;
+  };
+}
+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: "comment", code: (marker.length === 2 ? marker[1] : marker[0]).charCodeAt(0) };
+  }
+  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;
+  };
+}
+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;
+      }
+      if (single ? c === c0 : commentCodes.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;
+    }
+  }
+  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) {
+  const meta = {
+    // Union through the nullable prefix — a leading optional()/many() lets a later
+    // term's first char start the sequence. Just `parsers[0]` under-approximates.
+    firstSet: sequenceFirstSet(parsers),
+    canMatchNewline: parsers.some((p) => p._meta.canMatchNewline),
+    isTrivia: false
+  };
+  const def = { tag: "sequence", parsers };
+  let followSentinels;
+  function parseTolerant(input, pos, ctx) {
+    followSentinels ??= parsers.map((_, i) => {
+      const fs = parsers.slice(i + 1).reduce(
+        (acc, p) => union(acc, firstSetOf(p)),
+        { kind: "empty" }
+      );
+      return firstSetSentinel(fs);
+    });
+    const values = def.valueUnused ? void 0 : [];
+    let cur = pos;
+    const inheritedSync = ctx._sync;
+    try {
+      for (let i = 0; i < parsers.length; i++) {
+        ctx._sync = followSentinels[i] ?? inheritedSync;
+        if (ctx.trivia && i > 0) {
+          const mark = saveTriviaMark(ctx);
+          let scanEnd;
+          if (needsDeferredTriviaCommit(ctx)) {
+            const scan = scanTrivia(input, cur, ctx);
+            scan.commit();
+            scanEnd = scan.end;
+          } else {
+            scanEnd = advanceTrivia(input, cur, ctx);
+          }
+          const result2 = parsers[i].parse(input, scanEnd, ctx);
+          if (!result2.ok) return result2;
+          if (result2.span.end > scanEnd) cur = result2.span.end;
+          else rollbackTrivia(ctx, mark);
+          if (values !== void 0) values.push(result2.value);
+          continue;
+        }
+        const result = parsers[i].parse(input, cur, ctx);
+        if (!result.ok) return result;
+        if (values !== void 0) values.push(result.value);
+        cur = result.span.end;
+      }
+    } finally {
+      ctx._sync = inheritedSync;
+    }
+    return {
+      ok: true,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      value: values ?? void 0,
+      span: { start: pos, end: cur }
+    };
+  }
+  return {
+    _tag: "sequence",
+    _meta: meta,
+    _def: def,
+    parse(input, pos, ctx) {
+      if (ctx._tolerant) return parseTolerant(input, pos, ctx);
+      const values = def.valueUnused ? void 0 : [];
+      let cur = pos;
+      for (let i = 0; i < parsers.length; i++) {
+        if (ctx.trivia && i > 0) {
+          let scanEnd;
+          let mark = saveTriviaMark(ctx);
+          if (needsDeferredTriviaCommit(ctx)) {
+            const scan = scanTrivia(input, cur, ctx);
+            scan.commit();
+            scanEnd = scan.end;
+          } else {
+            scanEnd = advanceTrivia(input, cur, ctx);
+          }
+          const result2 = parsers[i].parse(input, scanEnd, ctx);
+          if (!result2.ok) return result2;
+          if (result2.span.end > scanEnd) {
+            cur = result2.span.end;
+          } else {
+            rollbackTrivia(ctx, mark);
+          }
+          if (values !== void 0) values.push(result2.value);
+          continue;
+        }
+        const result = parsers[i].parse(input, cur, ctx);
+        if (!result.ok) return result;
+        if (values !== void 0) values.push(result.value);
+        cur = result.span.end;
+      }
+      return {
+        ok: true,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        value: values ?? void 0,
+        span: { start: pos, end: cur }
+      };
+    }
+  };
+}
+
+// src/combinators/repeat.ts
+function repItem(combinator, input, cur, ctx, guardable) {
+  const mark = saveTriviaMark(ctx);
+  let pos = cur;
+  if (ctx.trivia) {
+    if (needsDeferredTriviaCommit(ctx)) {
+      const scan = scanTrivia(input, cur, ctx);
+      scan.commit();
+      pos = scan.end;
+    } else {
+      pos = advanceTrivia(input, cur, ctx);
+    }
+  }
+  if (pos >= input.length) {
+    rollbackTrivia(ctx, mark);
+    return "stop";
+  }
+  if (guardable && ctx._probe === void 0 && !ctx._tolerant && !startsFirstSet(combinator, input, pos)) {
+    rollbackTrivia(ctx, mark);
+    return "stop";
+  }
+  const result = combinator.parse(input, pos, ctx);
+  if (!result.ok) {
+    rollbackTrivia(ctx, mark);
+    return { fail: result, failPos: pos };
+  }
+  if (result.span.end === pos) {
+    rollbackTrivia(ctx, mark);
+    return "stop";
+  }
+  return { value: result.value, end: result.span.end };
+}
+function resolveBounds(what, opts) {
+  const min = opts.min ?? 0;
+  const max = opts.max ?? Infinity;
+  const bad = (msg) => {
+    throw new RangeError(`parseman: ${what} ${msg}`);
+  };
+  if (!Number.isInteger(min) || min < 0) bad(`min must be a non-negative integer (got ${String(opts.min)})`);
+  if (max !== Infinity && (!Number.isInteger(max) || max < 1)) bad(`max must be a positive integer (got ${String(opts.max)})`);
+  if (max < min) bad(`max (${max}) is less than min (${min}) \u2014 the combinator could never succeed`);
+  return { min, max };
+}
+function many(combinator, opts = {}) {
+  const { min, max } = resolveBounds("many()", opts);
+  if (min >= 1) return atLeast(combinator, min, max);
+  const meta = {
+    firstSet: combinator._meta.firstSet,
+    canMatchNewline: combinator._meta.canMatchNewline,
+    isTrivia: false
+  };
+  const def = { tag: "many", parser: combinator, min: 0, ...max === Infinity ? {} : { max } };
+  let expected;
+  const guardable = combinator._meta.firstSet.kind !== "any" && !matchesEmpty(combinator);
+  return {
+    _tag: "many",
+    _meta: meta,
+    _def: def,
+    parse(input, pos, ctx) {
+      const values = def.valueUnused ? void 0 : [];
+      let cur = pos;
+      let count = 0;
+      while (cur < input.length) {
+        if (count >= max) break;
+        const item = repItem(combinator, input, cur, ctx, guardable);
+        if (item === "stop") break;
+        if ("fail" in item) {
+          const sync = ctx._tolerant ? ctx._sync : void 0;
+          if (sync === void 0) break;
+          if (matchesAt(sync, input, item.failPos, ctx)) break;
+          expected ??= deriveExpected(combinator);
+          const { error, end } = recoverScan(input, item.failPos, ctx, sync, expected);
+          if (values !== void 0) values.push(error);
+          captureError(ctx, error);
+          count++;
+          cur = end;
+          continue;
+        }
+        if (values !== void 0) values.push(item.value);
+        count++;
+        cur = item.end;
+      }
+      return { ok: true, value: values ?? void 0, span: { start: pos, end: cur } };
+    }
+  };
+}
+function oneOrMore(combinator, opts = {}) {
+  return many(combinator, { ...opts, min: opts.min ?? 1 });
+}
+function atLeast(combinator, min, max) {
+  const meta = {
+    firstSet: combinator._meta.firstSet,
+    canMatchNewline: combinator._meta.canMatchNewline,
+    isTrivia: false
+  };
+  const def = { tag: "oneOrMore", parser: combinator, min, ...max === Infinity ? {} : { max } };
+  let expected;
+  const guardable = combinator._meta.firstSet.kind !== "any" && !matchesEmpty(combinator);
+  return {
+    _tag: "oneOrMore",
+    _meta: meta,
+    _def: def,
+    parse(input, pos, ctx) {
+      const first = combinator.parse(input, pos, ctx);
+      if (!first.ok) return first;
+      const values = def.valueUnused ? void 0 : [first.value];
+      let cur = first.span.end;
+      let count = 1;
+      while (count < min) {
+        const item = repItem(combinator, input, cur, ctx, guardable);
+        if (item === "stop" || "fail" in item) {
+          expected ??= deriveExpected(combinator);
+          return { ok: false, expected: expected.length > 0 ? expected : [combinator._tag], span: { start: cur, end: cur } };
+        }
+        if (values !== void 0) values.push(item.value);
+        cur = item.end;
+        count++;
+      }
+      while (cur < input.length) {
+        if (count >= max) break;
+        const item = repItem(combinator, input, cur, ctx, guardable);
+        if (item === "stop") break;
+        if ("fail" in item) {
+          const sync = ctx._tolerant ? ctx._sync : void 0;
+          if (sync === void 0) break;
+          if (matchesAt(sync, input, item.failPos, ctx)) break;
+          expected ??= deriveExpected(combinator);
+          const { error, end } = recoverScan(input, item.failPos, ctx, sync, expected);
+          if (values !== void 0) values.push(error);
+          captureError(ctx, error);
+          count++;
+          cur = end;
+          continue;
+        }
+        if (values !== void 0) values.push(item.value);
+        count++;
+        cur = item.end;
+      }
+      return { ok: true, value: values ?? void 0, span: { start: pos, end: cur } };
+    }
+  };
+}
+function optional(combinator) {
+  const meta = {
+    firstSet: combinator._meta.firstSet,
+    canMatchNewline: combinator._meta.canMatchNewline,
+    isTrivia: false
+  };
+  const firstSetSkippable = !matchesEmpty(combinator);
+  return {
+    _tag: "optional",
+    _meta: meta,
+    _def: { tag: "optional", parser: combinator },
+    parse(input, pos, ctx) {
+      if (firstSetSkippable && ctx._probe === void 0 && !startsFirstSet(combinator, input, pos)) {
+        return { ok: true, value: null, span: { start: pos, end: pos } };
+      }
+      const mark = saveTriviaMark(ctx);
+      const result = combinator.parse(input, pos, ctx);
+      if (result.ok) return result;
+      rollbackTrivia(ctx, mark);
+      return { ok: true, value: null, span: { start: pos, end: pos } };
+    }
+  };
+}
+function sepBy(combinator, separator, opts = {}) {
+  const { min, max } = resolveBounds("sepBy()", opts);
+  const trailing = opts.trailing ?? "forbid";
+  const meta = {
+    firstSet: combinator._meta.firstSet,
+    canMatchNewline: combinator._meta.canMatchNewline || separator._meta.canMatchNewline,
+    isTrivia: false
+  };
+  let expected;
+  const failAt2 = (at) => {
+    expected ??= deriveExpected(combinator);
+    return { ok: false, expected: expected.length > 0 ? expected : [combinator._tag], span: { start: at, end: at } };
+  };
+  return {
+    _tag: "sepBy",
+    _meta: meta,
+    _def: {
+      tag: "sepBy",
+      parser: combinator,
+      separator,
+      min,
+      ...max === Infinity ? {} : { max },
+      ...trailing === "forbid" ? {} : { trailing }
+    },
+    parse(input, pos, ctx) {
+      const first = combinator.parse(input, pos, ctx);
+      const values = [];
+      let cur;
+      if (first.ok) {
+        values.push(first.value);
+        cur = first.span.end;
+      } else {
+        const term = ctx._tolerant ? ctx._sync : void 0;
+        if (term === void 0 || matchesAt(term, input, pos, ctx)) {
+          if (min >= 1) return failAt2(pos);
+          return { ok: true, value: [], span: { start: pos, end: pos } };
+        }
+        expected ??= deriveExpected(combinator);
+        const rec = recoverScan(input, pos, ctx, orSentinel(separator, term), expected);
+        values.push(rec.error);
+        captureError(ctx, rec.error);
+        cur = rec.end;
+      }
+      while (cur < input.length) {
+        if (values.length >= max) break;
+        const loopMark = saveTriviaMark(ctx);
+        let sepPos = cur;
+        if (ctx.trivia) {
+          if (needsDeferredTriviaCommit(ctx)) {
+            const scan = scanTrivia(input, cur, ctx);
+            scan.commit();
+            sepPos = scan.end;
+          } else {
+            sepPos = advanceTrivia(input, cur, ctx);
+          }
+        }
+        const sep = separator.parse(input, sepPos, ctx);
+        if (!sep.ok) {
+          rollbackTrivia(ctx, loopMark);
+          break;
+        }
+        const sepMark = trailing === "forbid" ? void 0 : saveTriviaMark(ctx);
+        let nextPos = sep.span.end;
+        if (ctx.trivia) {
+          if (needsDeferredTriviaCommit(ctx)) {
+            const scan = scanTrivia(input, sep.span.end, ctx);
+            scan.commit();
+            nextPos = scan.end;
+          } else {
+            nextPos = advanceTrivia(input, sep.span.end, ctx);
+          }
+        }
+        const next = combinator.parse(input, nextPos, ctx);
+        if (!next.ok) {
+          const term = ctx._tolerant ? ctx._sync : void 0;
+          if (term !== void 0 && !matchesAt(term, input, nextPos, ctx)) {
+            expected ??= deriveExpected(combinator);
+            const rec = recoverScan(input, nextPos, ctx, orSentinel(separator, term), expected);
+            values.push(rec.error);
+            captureError(ctx, rec.error);
+            cur = rec.end;
+            continue;
+          }
+          if (sepMark !== void 0) {
+            rollbackTrivia(ctx, sepMark);
+            cur = sep.span.end;
+            break;
+          }
+          rollbackTrivia(ctx, loopMark);
+          break;
+        }
+        values.push(next.value);
+        cur = next.span.end;
+      }
+      if (values.length < min) return failAt2(cur);
+      return { ok: true, value: values, span: { start: pos, end: cur } };
+    }
+  };
+}
+
+// src/combinators/map.ts
+function transform(combinator, fn) {
+  return {
+    _tag: "transform",
+    _meta: combinator._meta,
+    _def: { tag: "transform", parser: combinator, fn },
+    parse(input, pos, ctx) {
+      const result = combinator.parse(input, pos, ctx);
+      if (!result.ok) return result;
+      return { ok: true, value: fn(result.value, result.span), span: result.span };
+    }
+  };
+}
+function skip(main, skipped) {
+  return {
+    _tag: "skip",
+    _meta: main._meta,
+    _def: { tag: "skip", main, skipped },
+    parse(input, pos, ctx) {
+      const result = main.parse(input, pos, ctx);
+      if (!result.ok) return result;
+      const s = skipped.parse(input, result.span.end, ctx);
+      if (!s.ok) return result;
+      return { ok: true, value: result.value, span: { start: result.span.start, end: s.span.end } };
+    }
+  };
+}
+function trivia(combinator) {
+  const kindLabels = analyzeLabeledTrivia(combinator)?.labels;
+  return {
+    _tag: combinator._tag,
+    _meta: {
+      ...combinator._meta,
+      isTrivia: true,
+      ...kindLabels ? { triviaKindLabels: kindLabels } : {}
+    },
+    _def: { tag: "trivia", parser: combinator },
+    parse: combinator.parse.bind(combinator)
+  };
+}
+function label(name, combinator) {
+  return {
+    _tag: combinator._tag,
+    _meta: combinator._meta,
+    _def: { tag: "label", label: name, parser: combinator },
+    parse(input, pos, ctx) {
+      const result = combinator.parse(input, pos, ctx);
+      if (!result.ok) return { ok: false, expected: [name], span: result.span };
+      return result;
+    }
+  };
+}
+function field(name, combinator) {
+  return {
+    _tag: combinator._tag,
+    _meta: combinator._meta,
+    _def: { tag: "field", name, parser: combinator },
+    parse(input, pos, ctx) {
+      const result = combinator.parse(input, pos, ctx);
+      if (!result.ok) return result;
+      ctx._fields?.push({ name, value: result.value, span: result.span });
+      return result;
+    }
+  };
+}
+
+// src/combinators/scanTo.ts
+function resolveScanSkip(explicitSkip, raw, ctx) {
+  if (raw) return [];
+  const trivia2 = ctx.trivia;
+  const ambient = ctx.scanSkip;
+  if (!trivia2 && !ambient) return explicitSkip;
+  const out = [];
+  if (trivia2) out.push(trivia2);
+  if (ambient) out.push(...ambient);
+  out.push(...explicitSkip);
+  return out;
+}
+function scanTo(sentinel, { skip: skip2, raw = false, orEOF = false } = {}) {
+  const meta = {
+    firstSet: any(),
+    canMatchNewline: true,
+    isTrivia: false
+  };
+  const explicitSkip = skip2 ?? [];
+  return {
+    _tag: "scanTo",
+    _meta: meta,
+    _def: { tag: "scanTo", sentinel, skip: explicitSkip, raw, orEOF },
+    parse(input, pos, ctx) {
+      let cur = pos;
+      const skip3 = resolveScanSkip(explicitSkip, raw, ctx);
+      const probeCtx = {
+        trackLines: ctx.trackLines,
+        state: ctx.state,
+        ...ctx._errors !== void 0 ? { _errors: ctx._errors } : {}
+      };
+      const emit = (end) => {
+        if (end > pos && cstCaptureActive(ctx)) {
+          const leaf2 = { _tag: "leaf", value: input.slice(pos, end), span: { start: pos, end } };
+          pushCstLeaf(ctx, leaf2);
+        }
+      };
+      while (cur < input.length) {
+        const s = sentinel.parse(input, cur, probeCtx);
+        if (s.ok) {
+          emit(cur);
+          return { ok: true, value: input.slice(pos, cur), span: { start: pos, end: cur } };
+        }
+        let advanced = false;
+        for (const skipper of skip3) {
+          const r = skipper.parse(input, cur, probeCtx);
+          if (r.ok && r.span.end > cur) {
+            cur = r.span.end;
+            advanced = true;
+            break;
+          }
+        }
+        if (!advanced) cur++;
+      }
+      if (orEOF) {
+        emit(cur);
+        return { ok: true, value: input.slice(pos, cur), span: { start: pos, end: cur } };
+      }
+      const sentDef = sentinel._def;
+      const expected = sentDef.tag === "literal" ? [JSON.stringify(sentDef.value)] : ["sentinel"];
+      return { ok: false, expected, span: { start: pos, end: cur } };
+    }
+  };
+}
+
+// src/compiler/scannable-run.ts
+var META = new Set("()[]{}*+?|^$.".split(""));
+
+// src/compiler/trivia-fast-path.ts
+var CAP_RECORD = [
+  `  if (_cap && _e > _pos) {`,
+  `    if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_pos, _e)`,
+  `    if (_ctx._cstTriviaLog !== undefined && _ctx.captureTrivia) _ctx._cstTriviaLog.push(_pos, _e, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0)`,
+  `  }`
+].join("\n");
+
+// src/compiler/build-arity.ts
+function cstOutputHost(build) {
+  return build?._parsemanCstOutput === true;
+}
+var PARAM_LIST_RE = (
+  // (params) => ...   |   function name?(params) ...   |   single-ident arrow `x => ...`
+  /^(?:function\b[^(]*\(([^)]*)\)|\(([^)]*)\)\s*=>|([A-Za-z_$][\w$]*)\s*=>)/
+);
+var CONFIRMABLE_PARAM_RE = /^[A-Za-z_$][\w$]*\s*\??\s*(?::[^,=]+)?$/;
+function confirmedBuildArity(src) {
+  const s = src.trim();
+  const m = PARAM_LIST_RE.exec(s);
+  if (!m) return null;
+  if (m[3] !== void 0) return 1;
+  const inner = (m[1] ?? m[2] ?? "").trim();
+  if (inner === "") return 0;
+  const parts = inner.split(",");
+  for (const part of parts) {
+    if (!CONFIRMABLE_PARAM_RE.test(part.trim())) return null;
+  }
+  if (/\barguments\b/.test(s)) return null;
+  return parts.length;
+}
+function buildReadsTrivia(def) {
+  if (!def.build) return true;
+  const src = def.buildSrc ?? def.build.toString();
+  const arity = confirmedBuildArity(src);
+  if (arity === null) return true;
+  return arity >= 5;
+}
+function buildReadsState(def) {
+  if (!def.build) return true;
+  const src = def.buildSrc ?? def.build.toString();
+  const arity = confirmedBuildArity(src);
+  if (arity === null) return true;
+  return arity >= 6;
+}
+
+// src/compiler/fields.ts
+function buildReadsFields(def) {
+  if (!def.build) return true;
+  const src = def.buildSrc ?? def.build.toString();
+  const arity = confirmedBuildArity(src);
+  if (arity === null) return true;
+  return arity >= 2;
+}
+function parserHasOwnFields(p, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return false;
+  seen.add(p);
+  const d = p._def;
+  switch (d.tag) {
+    case "field":
+      return true;
+    case "node":
+      return false;
+    case "lazy": {
+      try {
+        return parserHasOwnFields(d.thunk(), seen);
+      } catch {
+        return false;
+      }
+    }
+    case "sequence":
+    case "choice":
+      return d.parsers.some((x) => parserHasOwnFields(x, seen));
+    case "sepBy":
+      return parserHasOwnFields(d.parser, seen) || parserHasOwnFields(d.separator, seen);
+    case "skip":
+      return parserHasOwnFields(d.main, seen) || parserHasOwnFields(d.skipped, seen);
+    case "grammar":
+      return parserHasOwnFields(d.parser, seen) || (d.triviaParser ? parserHasOwnFields(d.triviaParser, seen) : false);
+    case "scanTo":
+      return parserHasOwnFields(d.sentinel, seen) || d.skip.some((x) => parserHasOwnFields(x, seen));
+    case "recover":
+      return parserHasOwnFields(d.parser, seen) || parserHasOwnFields(d.sentinel, seen);
+    case "many":
+    case "oneOrMore":
+    case "optional":
+    case "attempt":
+    case "transform":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "label":
+    case "expect":
+    case "withCtx":
+    case "not":
+    case "peek":
+      return parserHasOwnFields(d.parser, seen);
+    default:
+      return false;
+  }
+}
+function buildFieldMap(captures) {
+  if (!captures?.length) return void 0;
+  const out = {};
+  for (const cap of captures) {
+    const entry = { value: cap.value, span: cap.span };
+    const current = out[cap.name];
+    if (current === void 0) out[cap.name] = entry;
+    else if (Array.isArray(current)) current.push(entry);
+    else out[cap.name] = [current, entry];
+  }
+  return out;
+}
+
+// src/combinators/case-fold.ts
+function canonical(ch) {
+  const u = ch.toUpperCase();
+  if (u.length !== 1) return ch;
+  if (ch.codePointAt(0) >= 128 && u.codePointAt(0) < 128) return ch;
+  return u;
+}
+var foldIndex = null;
+function buildFoldIndex() {
+  const byCanonical = /* @__PURE__ */ new Map();
+  for (let cp = 0; cp < 65536; cp++) {
+    if (cp >= 55296 && cp <= 57343) continue;
+    const key = canonical(String.fromCharCode(cp));
+    const bucket = byCanonical.get(key);
+    if (bucket) bucket.push(cp);
+    else byCanonical.set(key, [cp]);
+  }
+  const index = /* @__PURE__ */ new Map();
+  for (const members of byCanonical.values()) {
+    if (members.length < 2) continue;
+    for (const cp of members) index.set(cp, members);
+  }
+  return index;
+}
+function caseFoldVariants(cp) {
+  if (cp < 128) {
+    if (cp >= 65 && cp <= 90) return [cp, cp + 32];
+    if (cp >= 97 && cp <= 122) return [cp, cp - 32];
+    return [cp];
+  }
+  if (cp > 65535) return [cp];
+  foldIndex ??= buildFoldIndex();
+  return foldIndex.get(cp) ?? [cp];
+}
+
+// src/combinators/keywords.ts
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function keywords(words, opts = {}) {
+  const sorted = [...new Set(words)].sort((a, b) => b.length - a.length);
+  const alt = sorted.map(escapeRe).join("|");
+  const boundary = opts.boundary ? `(?![${opts.boundary}])` : "";
+  const flags = opts.caseInsensitive ? "iy" : "uy";
+  const re = new RegExp(`(?:${alt})${boundary}`, flags);
+  let firstSet = empty();
+  for (const w of sorted) {
+    if (w.length === 0) continue;
+    const cp = w.codePointAt(0);
+    firstSet = union(firstSet, fromChar(cp));
+    if (opts.caseInsensitive) {
+      for (const v of caseFoldVariants(cp)) firstSet = union(firstSet, fromChar(v));
+    }
+  }
+  const meta = { firstSet, canMatchNewline: false, isTrivia: false };
+  return {
+    _tag: "keywords",
+    _meta: meta,
+    _def: { tag: "keywords", words: sorted, caseInsensitive: opts.caseInsensitive ?? false, boundary: opts.boundary },
+    parse(input, pos, ctx) {
+      re.lastIndex = pos;
+      const m = re.exec(input);
+      if (m === null || m.index !== pos) {
+        return failAt(ctx, ["keyword"], pos);
+      }
+      const value = m[0];
+      const span = { start: pos, end: pos + value.length };
+      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value, span });
+      return { ok: true, value, span };
+    }
+  };
+}
+
+// src/combinators/attempt.ts
+function attempt(parser2) {
+  const guardable = parser2._meta.firstSet.kind !== "any" && !matchesEmpty(parser2);
+  let failExpected;
+  return {
+    _tag: "attempt",
+    _meta: parser2._meta,
+    _def: { tag: "attempt", parser: parser2 },
+    parse(input, pos, ctx) {
+      if (guardable && ctx._probe === void 0 && !ctx._tolerant && !startsFirstSet(parser2, input, pos)) {
+        if (failExpected === void 0) {
+          const e = deriveExpected(parser2);
+          failExpected = e.length > 0 ? e : [parser2._tag];
+        }
+        return { ok: false, expected: failExpected, span: { start: pos, end: pos } };
+      }
+      const mark = saveCstMark(ctx);
+      const log = ctx._triviaLog?.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;
+      return { ok: false, expected: result.expected, span: { start: pos, end: pos } };
+    }
+  };
+}
+
+// src/combinators/not.ts
+function not(combinator) {
+  const meta = {
+    firstSet: any(),
+    // we don't know what NOT matches
+    canMatchNewline: false,
+    isTrivia: false
+  };
+  return {
+    _tag: "not",
+    _meta: meta,
+    _def: { tag: "not", parser: combinator },
+    parse(input, pos, ctx) {
+      const mark = saveLookaheadMark(ctx);
+      const result = combinator.parse(input, pos, ctx);
+      rollbackLookahead(ctx, mark);
+      if (result.ok) {
+        return { ok: false, expected: [`not(${combinator._tag})`], span: { start: pos, end: pos } };
+      }
+      return { ok: true, value: null, span: { start: pos, end: pos } };
+    }
+  };
+}
+
+// src/combinators/peek.ts
+function peek(combinator) {
+  const meta = {
+    // A nullable body imposes no first-char constraint — `any()`, not its set.
+    firstSet: matchesEmpty(combinator) ? any() : combinator._meta.firstSet,
+    canMatchNewline: false,
+    isTrivia: false
+  };
+  return {
+    _tag: "peek",
+    _meta: meta,
+    _def: { tag: "peek", parser: combinator },
+    parse(input, pos, ctx) {
+      const mark = saveLookaheadMark(ctx);
+      const result = combinator.parse(input, pos, ctx);
+      rollbackLookahead(ctx, mark);
+      if (result.ok) return { ok: true, value: null, span: { start: pos, end: pos } };
+      return { ok: false, expected: [`peek(${combinator._tag})`], span: { start: pos, end: pos } };
+    }
+  };
+}
+
+// src/combinators/node.ts
+function unwrapChild(child) {
+  return child !== null && typeof child === "object" && child._tag === "leaf" ? child.value : child;
+}
+function isCstChild(value) {
+  return typeof value === "object" && value !== null && (value._tag === "node" || value._tag === "leaf" || value._tag === "parseError");
+}
+function missingInferredType() {
+  throw new Error('node(): inferred node type requires a rules() key; pass node("Type", parser) outside rules()');
+}
+function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
+  const hasExplicitType = typeof typeOrCombinator === "string";
+  const type = hasExplicitType ? typeOrCombinator : void 0;
+  const combinator = hasExplicitType ? combinatorOrBuild : typeOrCombinator;
+  const build = hasExplicitType ? buildOrOpts : combinatorOrBuild;
+  const opts = hasExplicitType ? maybeOpts : buildOrOpts;
+  const baseDef = { tag: "node", parser: combinator, ...type === void 0 ? {} : { type }, ...build === void 0 ? {} : { build } };
+  const meta = {
+    firstSet: combinator._meta.firstSet,
+    canMatchNewline: combinator._meta.canMatchNewline,
+    isTrivia: false
+  };
+  const unwrap = opts?.unwrap === true;
+  const collapse = opts?.collapse === true;
+  const captureTrivia = opts?.captureTrivia === true;
+  const trailingTrivia = opts?.trailingTrivia === true;
+  if (unwrap && collapse) {
+    throw new Error("node() options cannot set both unwrap and collapse");
+  }
+  const def = unwrap || collapse || captureTrivia || trailingTrivia ? { ...baseDef, ...unwrap ? { unwrap: true } : {}, ...collapse ? { collapse: true } : {}, ...captureTrivia ? { captureTrivia: true } : {}, ...trailingTrivia ? { trailingTrivia: true } : {} } : baseDef;
+  const capturesTrivia = captureTrivia || trailingTrivia || (build ? buildReadsTrivia(def) : true);
+  const clonesState = build ? buildReadsState(def) : true;
+  const hasOwnFields = parserHasOwnFields(combinator);
+  const capturesFields = hasOwnFields && (build ? buildReadsFields(def) : true);
+  const guardable = combinator._meta.firstSet.kind !== "any" && !matchesEmpty(combinator);
+  let failExpected;
+  return {
+    _tag: "node",
+    _meta: meta,
+    _def: def,
+    parse(input, pos, ctx) {
+      if (guardable && ctx._probe === void 0 && !ctx._tolerant && !startsFirstSet(combinator, input, pos)) {
+        if (failExpected === void 0) {
+          const e = deriveExpected(combinator);
+          failExpected = e.length > 0 ? e : [combinator._tag];
+        }
+        return { ok: false, expected: failExpected, span: { start: pos, end: pos } };
+      }
+      const hostCst = build !== void 0 && cstOutputHost(ctx.build);
+      const effTrivia = capturesTrivia || hostCst;
+      const effFields = capturesFields || hostCst && hasOwnFields;
+      const saved = beginCstNodeCapture(ctx);
+      const savedFields = ctx._fields;
+      ctx._fields = effFields ? [] : void 0;
+      const savedMask = ctx._triviaCaptureMask;
+      if (build === void 0 && ctx.build?._parsemanTriviaKinds !== void 0 && def.type !== void 0) {
+        ctx._triviaCaptureMask = ctx.build._parsemanTriviaKinds(def.type);
+      }
+      if (!effTrivia) ctx.captureTrivia = false;
+      let r = combinator.parse(input, pos, ctx);
+      if (r.ok && trailingTrivia && ctx.trivia) {
+        const end = consumeTrivia(input, r.span.end, ctx);
+        r = { ...r, span: { start: r.span.start, end } };
+      }
+      const fields = effFields ? buildFieldMap(ctx._fields) : void 0;
+      ctx._fields = savedFields;
+      ctx._triviaCaptureMask = savedMask;
+      const { children, rawChildren, triviaLog } = endCstNodeCapture(ctx, saved);
+      if (!r.ok) return r;
+      const st = clonesState && ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
+      const nodeType = def.type ?? missingInferredType();
+      const cstOutput = cstOutputHost(ctx.build);
+      const hostState = clonesState ? st : ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
+      const built = unwrap && children.length === 1 ? unwrapChild(children[0]) : collapse && children.length === 1 ? children[0] : !build && ctx.build?._parsemanCstCollapse && children.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children[0], children, rawChildren) ? children[0] : build ? cstOutput && ctx.build ? ctx.build(nodeType, children, fields, r.span, rawChildren, triviaLog, hostState) : build(children, fields, r.span, rawChildren, triviaLog, st) : ctx.build ? ctx.build(nodeType, children, fields, r.span, rawChildren, triviaLog, st) : { _tag: "node", type: nodeType, span: { start: r.span.start, end: r.span.end }, state: st ?? null, children };
+      const rawEntry = isCstChild(built) ? built : { _tag: "leaf", value: typeof built === "string" ? built : typeof built === "object" && built !== null ? input.slice(r.span.start, r.span.end) : "", span: r.span };
+      if (saved.buf !== void 0 || saved.ch !== void 0) {
+        pushCstChild(ctx, built, rawEntry);
+      }
+      return { ok: true, value: built, span: r.span };
+    }
+  };
+}
+
+// src/compiler/line-index.ts
+function buildLineIndex(input) {
+  const lineStarts = [0];
+  for (let i = 0; i < input.length; i++) {
+    if (input.charCodeAt(i) === 10) lineStarts.push(i + 1);
+  }
+  return { lineStarts };
+}
+function offsetToLineCol(index, offset) {
+  const { lineStarts } = index;
+  let lo = 0;
+  let hi = lineStarts.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (lineStarts[mid] <= offset) lo = mid;
+    else hi = mid - 1;
+  }
+  return { line: lo + 1, col: offset - lineStarts[lo] + 1 };
+}
+function annotateSpan(span, index) {
+  const s = offsetToLineCol(index, span.start);
+  const e = offsetToLineCol(index, span.end);
+  return {
+    ...span,
+    startLine: s.line,
+    startColumn: s.col,
+    endLine: e.line,
+    endColumn: e.col
+  };
+}
+
+// src/combinators/grammar.ts
+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 ctx = {
+        ..._ctx,
+        trackLines,
+        // 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) {
+        const idx = buildLineIndex(input);
+        return { ...result, span: annotateSpan(result.span, idx) };
+      }
+      return result;
+    }
+  };
+}
+
+// src/combinators/token.ts
+function token(root) {
+  const meta = {
+    firstSet: root._meta.firstSet,
+    canMatchNewline: root._meta.canMatchNewline,
+    isTrivia: false
+  };
+  return {
+    _tag: "token",
+    _meta: meta,
+    _def: { tag: "token", parser: 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 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;
+      delete ctx._triviaLog;
+      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;
+        if (savedOuterTriviaLog === void 0) delete ctx._triviaLog;
+        else ctx._triviaLog = savedOuterTriviaLog;
+      }
+      if (!result.ok) return result;
+      const span = result.span;
+      const value = input.slice(pos, span.end);
+      if (wasCapturing) pushCstLeaf(ctx, { _tag: "leaf", value, span });
+      return { ok: true, value, span };
+    }
+  };
+}
+function leaf(root, fn) {
+  const meta = {
+    firstSet: root._meta.firstSet,
+    canMatchNewline: root._meta.canMatchNewline,
+    isTrivia: false
+  };
+  return {
+    _tag: "leaf",
+    _meta: meta,
+    _def: { tag: "leaf", parser: root, fn },
+    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;
+      delete ctx._triviaLog;
+      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;
+        if (savedOuterTriviaLog === void 0) delete ctx._triviaLog;
+        else ctx._triviaLog = savedOuterTriviaLog;
+      }
+      if (!result.ok) return result;
+      const value = fn(result.value, result.span);
+      if (wasCapturing) pushCstLeaf(ctx, { _tag: "leaf", value, span: result.span });
+      return { ok: true, value, span: result.span };
+    }
+  };
+}
+
+// src/combinators/withCtx.ts
+function withCtx(extra, combinator) {
+  const meta = {
+    firstSet: combinator._meta.firstSet,
+    canMatchNewline: combinator._meta.canMatchNewline,
+    isTrivia: false
+  };
+  return {
+    _tag: "withCtx",
+    _meta: meta,
+    _def: { tag: "withCtx", extra, parser: combinator },
+    parse(input, pos, ctx) {
+      return combinator.parse(input, pos, { ...ctx, state: extra });
+    }
+  };
+}
+
+// src/compiler/ir-serialize.ts
+function evalRuleMapIR(ir) {
+  const _tf = (child, src, recognitionOnly = false) => {
+    let fn2;
+    try {
+      fn2 = (0, eval)(`(${src})`);
+    } catch {
+      fn2 = () => {
+        throw new Error("IR transform fn not materialized");
+      };
+    }
+    const t = transform(child, fn2);
+    t._def.fnSrc = src;
+    if (recognitionOnly) t._def.recognitionOnly = true;
+    return t;
+  };
+  const _lf = (child, src) => {
+    let fn2;
+    try {
+      fn2 = (0, eval)(`(${src})`);
+    } catch {
+      fn2 = () => {
+        throw new Error("IR leaf fn not materialized");
+      };
+    }
+    const l = leaf(child, fn2);
+    l._def.fnSrc = src;
+    return l;
+  };
+  const _nd = (type, child, src, opts, staticError) => {
+    if (staticError !== void 0 && staticError.length > 0) {
+      throw new Error(`IR direct node builder for ${type} must be macro-static and self-contained; unsupported binding(s): ${staticError.join(", ")}`);
+    }
+    const n = node(type, child, (() => {
+      throw new Error("IR node build requires static re-lowering");
+    }), opts);
+    n._def.buildSrc = src;
+    if (staticError !== void 0) n._def.buildStaticError = staticError;
+    return n;
+  };
+  const _gch = (items) => {
+    const gateSrcs = [];
+    const arms = items.map((it) => {
+      if (Array.isArray(it)) {
+        const [src, comb] = it;
+        gateSrcs.push(src);
+        let gate;
+        try {
+          gate = (0, eval)(`(${src})`);
+        } catch {
+          gate = () => {
+            throw new Error("IR gate fn not materialized");
+          };
+        }
+        return { gate, combinator: comb };
+      }
+      gateSrcs.push(null);
+      return it;
+    });
+    const c = choice(...arms);
+    const gates = c._def.gates;
+    if (gates && gates.length !== gateSrcs.length) {
+      throw new Error(`_gch: gateSrcs length ${gateSrcs.length} != choice gates length ${gates.length}`);
+    }
+    ;
+    c._def.gateSrcs = gateSrcs;
+    return c;
+  };
+  const _wc = (src, inner) => {
+    let extra;
+    try {
+      extra = (0, eval)(`(${src})`);
+    } catch {
+      extra = void 0;
+    }
+    const w = withCtx(extra, inner);
+    w._def.extraSrc = src;
+    return w;
+  };
+  const fn = new Function(
+    "rules",
+    "ref",
+    "regex",
+    "literal",
+    "keywords",
+    "sequence",
+    "choice",
+    "attempt",
+    "many",
+    "oneOrMore",
+    "optional",
+    "sepBy",
+    "not",
+    "peek",
+    "node",
+    "parser",
+    "scanTo",
+    "token",
+    "leaf",
+    "transform",
+    "skip",
+    "trivia",
+    "label",
+    "field",
+    "expect",
+    "_tf",
+    "_lf",
+    "_nd",
+    "_gch",
+    "_wc",
+    `return (${ir})`
+  );
+  const map = fn(
+    rules,
+    ref,
+    regex,
+    literal,
+    keywords,
+    sequence,
+    choice,
+    attempt,
+    many,
+    oneOrMore,
+    optional,
+    sepBy,
+    not,
+    peek,
+    node,
+    parser,
+    scanTo,
+    token,
+    leaf,
+    transform,
+    skip,
+    trivia,
+    label,
+    field,
+    expect,
+    _tf,
+    _lf,
+    _nd,
+    _gch,
+    _wc
+  );
+  return Object.entries(map);
+}
+
+// src/compiler/linker.ts
+function normalizeCstCollapse(collapse) {
+  if (collapse === true) return () => true;
+  if (Array.isArray(collapse)) {
+    const types = new Set(collapse);
+    return (type) => types.has(type);
+  }
+  return typeof collapse === "function" ? collapse : void 0;
+}
+function buildCstNode(type, children, _fields, span, _rawChildren, _triviaLog, state) {
+  return { _tag: "node", type, span: { start: span.start, end: span.end }, state: state ?? null, children: [...children] };
+}
+function cstBuildHost(typeOrOptions, children, _fields, span, rawChildren, triviaLog, state) {
+  if (typeof typeOrOptions === "string") {
+    return buildCstNode(typeOrOptions, children ?? [], _fields, span ?? { start: 0, end: 0 }, rawChildren, triviaLog, state);
+  }
+  const collapse = normalizeCstCollapse(typeOrOptions?.collapse);
+  const host = (type, children2, fields, span2, rawChildren2, triviaLog2, state2) => buildCstNode(type, children2 ?? [], fields, span2, rawChildren2, triviaLog2, state2);
+  host._parsemanCstOutput = true;
+  if (collapse) host._parsemanCstCollapse = collapse;
+  return host;
+}
+cstBuildHost._parsemanCstOutput = true;
+var COMPOSED_PIECES = /* @__PURE__ */ Symbol.for("parseman.composedPieces");
+function composedPiecesOf(grammar) {
+  const pieces = grammar[COMPOSED_PIECES];
+  return Array.isArray(pieces) ? pieces : void 0;
+}
+function isIRPiece(p) {
+  return !!p && typeof p === "object" && typeof p.ir === "string" && typeof p.ns === "string" && !("ruleFns" in p);
+}
+function carriedRuleMapsDetailed(carried) {
+  const maps = [];
+  const opaque = [];
+  for (const p of carried) {
+    if (isIRPiece(p)) {
+      maps.push(evalRuleMapIR(p.ir));
+      continue;
+    }
+    const ruleFns = p.ruleFns;
+    opaque.push({ ns: p.ns, ruleNames: ruleFns instanceof Map ? [...ruleFns.keys()] : [] });
+  }
+  return { maps, opaque };
+}
+function recoverComposedRules(grammar) {
+  const carried = composedPiecesOf(grammar);
+  if (carried === void 0) return void 0;
+  const { maps, opaque } = carriedRuleMapsDetailed(carried);
+  const rules2 = /* @__PURE__ */ new Map();
+  for (const map of maps) for (const [name, rule] of map) {
+    if (rule._def.tag === "lazy") {
+      try {
+        rule._def.thunk();
+      } catch {
+        continue;
+      }
+    }
+    rules2.set(name, rule);
+  }
+  return { rules: rules2, opaque };
+}
 
 // src/spec/model.ts
 function ruleNameOf(c) {
@@ -231,6 +3142,16 @@ function toRecord(grammar) {
     const name = ruleNameOf(grammar) ?? "start";
     return { [name]: grammar };
   }
+  const recovered = recoverComposedRules(grammar);
+  if (recovered !== void 0) {
+    if (recovered.opaque.length > 0) {
+      const named = recovered.opaque.map((o) => `"${o.ns}"${o.ruleNames.length > 0 ? ` (${o.ruleNames.length} rule(s))` : ""}`).join(", ");
+      throw new TypeError(
+        `parseman spec: this composed grammar includes opaque precompiled artifact(s) ${named} that carry compiled rule functions rather than re-lowerable IR. Their rules cannot be rendered, and emitting a spec without them would silently understate the grammar. Recompile the contributing grammar(s) so they carry IR.`
+      );
+    }
+    return Object.fromEntries(recovered.rules);
+  }
   return grammar;
 }
 function isCombinator(x) {
@@ -296,25 +3217,25 @@ function repeatOp(min, max) {
   if (min === 0 && max === 1) return "?";
   return `{${min},${max}}`;
 }
-function render(node) {
-  switch (node.kind) {
+function render(node2) {
+  switch (node2.kind) {
     case "terminal":
-      return { text: node.literal ? quote(node.text) : node.text, level: ATOM };
+      return { text: node2.literal ? quote(node2.text) : node2.text, level: ATOM };
     case "ref":
-      return { text: node.name, level: ATOM };
+      return { text: node2.name, level: ATOM };
     case "empty":
       return { text: "", level: ATOM };
     case "annotation":
-      return { text: `/* ${node.text} */`, level: ATOM };
+      return { text: `/* ${node2.text} */`, level: ATOM };
     case "seq": {
-      const text = node.items.map((it) => {
+      const text = node2.items.map((it) => {
         const r = render(it);
         return wrap(r.text, r.level, CAT);
       }).filter((t) => t.length > 0).join(" ");
       return { text, level: CAT };
     }
     case "choice": {
-      const text = node.items.map((it) => {
+      const text = node2.items.map((it) => {
         const r = render(it);
         return wrap(r.text, r.level, ALT);
       }).join(" | ");
@@ -323,27 +3244,27 @@ function render(node) {
     case "star":
     case "plus":
     case "opt": {
-      const r = render(node.item);
-      const op = node.kind === "opt" ? "?" : node.kind === "star" ? repeatOp(0, node.max) : repeatOp(node.min ?? 1, node.max);
+      const r = render(node2.item);
+      const op = node2.kind === "opt" ? "?" : node2.kind === "star" ? repeatOp(0, node2.max) : repeatOp(node2.min ?? 1, node2.max);
       return { text: `${wrap(r.text, r.level, ATOM)}${op}`, level: ATOM };
     }
     case "sepBy": {
-      const item = render(node.item);
-      const sep = render(node.sep);
+      const item = render(node2.item);
+      const sep = render(node2.sep);
       const itemA = wrap(item.text, item.level, ATOM);
       const sepA = wrap(sep.text, sep.level, CAT);
-      const tail = `(${sepA} ${itemA})${repeatOp(Math.max(node.min - 1, 0), node.max === void 0 ? void 0 : node.max - 1)}`;
-      const trail = node.trailing === "allow" ? ` ${sepA}?` : "";
+      const tail = `(${sepA} ${itemA})${repeatOp(Math.max(node2.min - 1, 0), node2.max === void 0 ? void 0 : node2.max - 1)}`;
+      const trail = node2.trailing === "allow" ? ` ${sepA}?` : "";
       const body = `${itemA} ${tail}${trail}`;
-      return node.min === 0 ? { text: `(${body})?`, level: ATOM } : { text: body, level: CAT };
+      return node2.min === 0 ? { text: `(${body})?`, level: ATOM } : { text: body, level: CAT };
     }
     case "not": {
-      const r = render(node.item);
+      const r = render(node2.item);
       return { text: `!${wrap(r.text, r.level, ATOM)}`, level: ATOM };
     }
     // PEG notation: `&` positive lookahead, `!` negative.
     case "peek": {
-      const r = render(node.item);
+      const r = render(node2.item);
       return { text: `&${wrap(r.text, r.level, ATOM)}`, level: ATOM };
     }
   }
@@ -355,8 +3276,8 @@ function renderProduction(p) {
 function renderEBNF(model) {
   return model.productions.map(renderProduction).join("\n") + "\n";
 }
-function renderExpr(node) {
-  return render(node).text;
+function renderExpr(node2) {
+  return render(node2).text;
 }
 
 // src/spec/railroad-lib.ts
@@ -917,41 +3838,41 @@ function boundLabel(min, max) {
   if (max === min) return `${min}\xD7`;
   return `${min}\u2013${max} times`;
 }
-function toDsl(node) {
-  switch (node.kind) {
+function toDsl(node2) {
+  switch (node2.kind) {
     case "terminal":
-      return `Terminal(${j(node.text)})`;
+      return `Terminal(${j(node2.text)})`;
     case "ref":
-      return `NonTerminal(${j(node.name)})`;
+      return `NonTerminal(${j(node2.name)})`;
     case "empty":
       return `Skip()`;
     case "annotation":
-      return `Comment(${j(node.text)})`;
+      return `Comment(${j(node2.text)})`;
     case "seq":
-      return `Sequence(${node.items.map(toDsl).join(", ")})`;
+      return `Sequence(${node2.items.map(toDsl).join(", ")})`;
     case "choice":
-      return `Choice(0, ${node.items.map(toDsl).join(", ")})`;
+      return `Choice(0, ${node2.items.map(toDsl).join(", ")})`;
     case "star": {
-      const b = boundLabel(0, node.max);
-      return b ? `ZeroOrMore(${toDsl(node.item)}, Comment(${j(b)}))` : `ZeroOrMore(${toDsl(node.item)})`;
+      const b = boundLabel(0, node2.max);
+      return b ? `ZeroOrMore(${toDsl(node2.item)}, Comment(${j(b)}))` : `ZeroOrMore(${toDsl(node2.item)})`;
     }
     case "plus": {
-      const b = boundLabel(node.min ?? 1, node.max);
-      return b ? `OneOrMore(${toDsl(node.item)}, Comment(${j(b)}))` : `OneOrMore(${toDsl(node.item)})`;
+      const b = boundLabel(node2.min ?? 1, node2.max);
+      return b ? `OneOrMore(${toDsl(node2.item)}, Comment(${j(b)}))` : `OneOrMore(${toDsl(node2.item)})`;
     }
     case "opt":
-      return `Optional(${toDsl(node.item)})`;
+      return `Optional(${toDsl(node2.item)})`;
     case "sepBy": {
-      const b = boundLabel(node.min, node.max);
-      const loop = b ? `Sequence(${toDsl(node.sep)}, Comment(${j(b)}))` : toDsl(node.sep);
-      const rep = `OneOrMore(${toDsl(node.item)}, ${loop})`;
-      const withTrail = node.trailing === void 0 ? rep : `Sequence(${rep}, Optional(${toDsl(node.sep)}))`;
-      return node.min === 0 ? `Optional(${withTrail})` : withTrail;
+      const b = boundLabel(node2.min, node2.max);
+      const loop = b ? `Sequence(${toDsl(node2.sep)}, Comment(${j(b)}))` : toDsl(node2.sep);
+      const rep = `OneOrMore(${toDsl(node2.item)}, ${loop})`;
+      const withTrail = node2.trailing === void 0 ? rep : `Sequence(${rep}, Optional(${toDsl(node2.sep)}))`;
+      return node2.min === 0 ? `Optional(${withTrail})` : withTrail;
     }
     case "not":
-      return `Sequence(Comment("not"), ${toDsl(node.item)})`;
+      return `Sequence(Comment("not"), ${toDsl(node2.item)})`;
     case "peek":
-      return `Sequence(Comment("peek"), ${toDsl(node.item)})`;
+      return `Sequence(Comment("peek"), ${toDsl(node2.item)})`;
   }
 }
 var _builders = null;
@@ -962,41 +3883,41 @@ function builders() {
   _builders = mod;
   return _builders;
 }
-function toDiagramNode(b, node) {
-  switch (node.kind) {
+function toDiagramNode(b, node2) {
+  switch (node2.kind) {
     case "terminal":
-      return b.Terminal(node.text);
+      return b.Terminal(node2.text);
     case "ref":
-      return b.NonTerminal(node.name);
+      return b.NonTerminal(node2.name);
     case "empty":
       return b.Skip();
     case "annotation":
-      return b.Comment(node.text);
+      return b.Comment(node2.text);
     case "seq":
-      return b.Sequence(...node.items.map((n) => toDiagramNode(b, n)));
+      return b.Sequence(...node2.items.map((n) => toDiagramNode(b, n)));
     case "choice":
-      return b.Choice(0, ...node.items.map((n) => toDiagramNode(b, n)));
+      return b.Choice(0, ...node2.items.map((n) => toDiagramNode(b, n)));
     case "star": {
-      const lbl = boundLabel(0, node.max);
-      return lbl ? b.ZeroOrMore(toDiagramNode(b, node.item), b.Comment(lbl)) : b.ZeroOrMore(toDiagramNode(b, node.item));
+      const lbl = boundLabel(0, node2.max);
+      return lbl ? b.ZeroOrMore(toDiagramNode(b, node2.item), b.Comment(lbl)) : b.ZeroOrMore(toDiagramNode(b, node2.item));
     }
     case "plus": {
-      const lbl = boundLabel(node.min ?? 1, node.max);
-      return lbl ? b.OneOrMore(toDiagramNode(b, node.item), b.Comment(lbl)) : b.OneOrMore(toDiagramNode(b, node.item));
+      const lbl = boundLabel(node2.min ?? 1, node2.max);
+      return lbl ? b.OneOrMore(toDiagramNode(b, node2.item), b.Comment(lbl)) : b.OneOrMore(toDiagramNode(b, node2.item));
     }
     case "opt":
-      return b.Optional(toDiagramNode(b, node.item));
+      return b.Optional(toDiagramNode(b, node2.item));
     case "sepBy": {
-      const lbl = boundLabel(node.min, node.max);
-      const sep = toDiagramNode(b, node.sep);
-      const rep = b.OneOrMore(toDiagramNode(b, node.item), lbl ? b.Sequence(sep, b.Comment(lbl)) : sep);
-      const withTrail = node.trailing === void 0 ? rep : b.Sequence(rep, b.Optional(toDiagramNode(b, node.sep)));
-      return node.min === 0 ? b.Optional(withTrail) : withTrail;
+      const lbl = boundLabel(node2.min, node2.max);
+      const sep = toDiagramNode(b, node2.sep);
+      const rep = b.OneOrMore(toDiagramNode(b, node2.item), lbl ? b.Sequence(sep, b.Comment(lbl)) : sep);
+      const withTrail = node2.trailing === void 0 ? rep : b.Sequence(rep, b.Optional(toDiagramNode(b, node2.sep)));
+      return node2.min === 0 ? b.Optional(withTrail) : withTrail;
     }
     case "not":
-      return b.Sequence(b.Comment("not"), toDiagramNode(b, node.item));
+      return b.Sequence(b.Comment("not"), toDiagramNode(b, node2.item));
     case "peek":
-      return b.Sequence(b.Comment("peek"), toDiagramNode(b, node.item));
+      return b.Sequence(b.Comment("peek"), toDiagramNode(b, node2.item));
   }
 }
 function renderRailroadSvg(model) {