parseman 0.5.0 → 0.6.1

package/dist/index.cjs

@@ -30,7 +30,6 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  Parser: () => Parser,
   annotateSpan: () => annotateSpan,
   balanced: () => balanced,
   buildLineIndex: () => buildLineIndex,
@@ -41,8 +40,10 @@ __export(index_exports, {
   guard: () => guard,
   isParseError: () => isParseError,
   keywords: () => keywords,
+  label: () => label,
   literal: () => literal,
   makeFunctionalDoc: () => makeFunctionalDoc,
+  makeWord: () => makeWord,
   many: () => many,
   node: () => node,
   not: () => not,
@@ -61,7 +62,9 @@ __export(index_exports, {
   skip: () => skip,
   transform: () => transform,
   trivia: () => trivia,
-  withCtx: () => withCtx
+  triviaEntries: () => triviaEntries,
+  withCtx: () => withCtx,
+  word: () => word
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -125,6 +128,151 @@ function failAt(ctx, expected, pos) {
   return r;
 }
 
+// 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, leaf) {
+  pushCstChild(ctx, leaf, leaf);
+}
+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)
+  };
+}
+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 arr.length = len;
+    return;
+  }
+  if (len === 0) b[keySingle] = void 0;
+}
+function rollbackCstCapture(ctx, mark) {
+  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 b.tl.length = mark.tlog;
+    }
+    return;
+  }
+  if (ctx._cstRawChildren) ctx._cstRawChildren.length = mark.raw;
+  if (ctx._cstTriviaLog) ctx._cstTriviaLog.length = mark.tlog;
+  if (ctx._cstLeaves) ctx._cstLeaves.length = mark.leaves;
+}
+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/combinators/literal.ts
 var _collatorCache = null;
 function collator() {
@@ -164,8 +312,7 @@ function literal(value, opts = {}) {
       if (matched) {
         const span = { start: pos, end };
         const leaf = { _tag: "leaf", value: slice, span };
-        if (ctx._cstLeaves) ctx._cstLeaves.push(leaf);
-        if (ctx._cstRawChildren) ctx._cstRawChildren.push(leaf);
+        if (cstCaptureActive(ctx)) pushCstLeaf(ctx, leaf);
         return { ok: true, value: slice, span };
       }
       return failAt(ctx, [JSON.stringify(value)], pos);
@@ -307,14 +454,19 @@ function regex(pattern, flags = "") {
       }
       const span = { start: pos, end: pos + m[0].length };
       const leaf = { _tag: "leaf", value: m[0], span };
-      if (ctx._cstLeaves) ctx._cstLeaves.push(leaf);
-      if (ctx._cstRawChildren) ctx._cstRawChildren.push(leaf);
+      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, leaf);
       return { ok: true, value: m[0], span };
     }
   };
 }
 
 // src/combinators/keywords.ts
+function word(str, boundary = "_0-9A-Za-z") {
+  return keywords([str], { boundary });
+}
+function makeWord(boundary = "_0-9A-Za-z") {
+  return (str) => keywords([str], { boundary });
+}
 function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -350,109 +502,15 @@ function keywords(words, opts = {}) {
       const value = m[0];
       const span = { start: pos, end: pos + value.length };
       const leaf = { _tag: "leaf", value, span };
-      if (ctx._cstLeaves) ctx._cstLeaves.push(leaf);
-      if (ctx._cstRawChildren) ctx._cstRawChildren.push(leaf);
+      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, leaf);
       return { ok: true, value, span };
     }
   };
 }
 
-// src/combinators/trivia-skip.ts
-var NOOP_COMMIT = () => {
-};
-function scanTrivia(input, cur, ctx) {
-  const triviaP = ctx.trivia;
-  if (!triviaP) return { end: cur, commit: NOOP_COMMIT };
-  const log = ctx._triviaLog;
-  if (log !== void 0) {
-    const tr2 = triviaP.parse(input, cur, { trackLines: false, state: ctx.state });
-    if (!tr2.ok || tr2.span.end === cur) return { end: cur, commit: NOOP_COMMIT };
-    const end = tr2.span.end;
-    return {
-      end,
-      commit: () => {
-        log.push(cur, end);
-      }
-    };
-  }
-  if (ctx.captureTrivia && ctx._cstRawChildren) {
-    const sink = [];
-    const tr2 = triviaP.parse(input, cur, {
-      trackLines: ctx.trackLines,
-      state: ctx.state,
-      _cstLeaves: sink
-    });
-    if (tr2.ok && tr2.span.end > cur) {
-      const out = ctx._cstRawChildren;
-      return {
-        end: tr2.span.end,
-        commit: () => {
-          for (const tok of sink) {
-            if (tok._tag === "leaf" && tok.span.end > tok.span.start) {
-              out.push({ _tag: "trivia", value: tok.value, span: tok.span });
-            }
-          }
-        }
-      };
-    }
-    return { end: cur, commit: NOOP_COMMIT };
-  }
-  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) {
-  const scan = scanTrivia(input, cur, ctx);
-  scan.commit();
-  return scan.end;
-}
-
-// src/combinators/sequence.ts
-function sequence(...parsers) {
-  const meta = {
-    firstSet: parsers[0]?._meta.firstSet ?? empty(),
-    canMatchNewline: parsers.some((p) => p._meta.canMatchNewline),
-    isTrivia: false
-  };
-  return {
-    _tag: "sequence",
-    _meta: meta,
-    _def: { tag: "sequence", parsers },
-    parse(input, pos, ctx) {
-      const values = [];
-      let cur = pos;
-      for (let i = 0; i < parsers.length; i++) {
-        if (ctx.trivia && i > 0) {
-          const scan = scanTrivia(input, cur, ctx);
-          const raw = ctx._cstRawChildren;
-          const mark = raw ? raw.length : 0;
-          scan.commit();
-          const result2 = parsers[i].parse(input, scan.end, ctx);
-          if (!result2.ok) return result2;
-          if (result2.span.end > scan.end) {
-            cur = result2.span.end;
-          } else if (raw) {
-            raw.length = mark;
-          }
-          values.push(result2.value);
-          continue;
-        }
-        const result = parsers[i].parse(input, cur, ctx);
-        if (!result.ok) return result;
-        values.push(result.value);
-        cur = result.span.end;
-      }
-      return {
-        ok: true,
-        value: values,
-        span: { start: pos, end: cur }
-      };
-    }
-  };
-}
-
 // src/combinators/choice.ts
 function choice(...args) {
-  const parsers = args.map((a) => "gate" in a ? a.parser : a);
+  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 = !hasGates && areDisjoint(parsers.map((p) => p._meta.firstSet));
@@ -536,19 +594,19 @@ function choice(...args) {
       }
       for (let i = 0; i < parsers.length; i++) {
         if (gates[i] && !gates[i](ctx.state)) continue;
-        const leavesLen = ctx._cstLeaves?.length;
-        const rawLen = ctx._cstRawChildren?.length;
+        const mark = saveCstMark(ctx);
+        const logLen = ctx._triviaLog?.length;
         const result = parsers[i].parse(input, pos, ctx);
         if (!result.ok) {
-          if (leavesLen !== void 0 && ctx._cstLeaves) ctx._cstLeaves.length = leavesLen;
-          if (rawLen !== void 0 && ctx._cstRawChildren) ctx._cstRawChildren.length = rawLen;
+          rollbackCstCapture(ctx, mark);
+          if (logLen !== void 0 && ctx._triviaLog) ctx._triviaLog.length = logLen;
           expected.push(...result.expected);
           continue;
         }
         const checks = autoNot[i];
         if (checks && autoNotFires(input, result.span.end, checks)) {
-          if (leavesLen !== void 0 && ctx._cstLeaves) ctx._cstLeaves.length = leavesLen;
-          if (rawLen !== void 0 && ctx._cstRawChildren) ctx._cstRawChildren.length = rawLen;
+          rollbackCstCapture(ctx, mark);
+          if (logLen !== void 0 && ctx._triviaLog) ctx._triviaLog.length = logLen;
           continue;
         }
         return result;
@@ -627,6 +685,7 @@ 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) {
@@ -680,46 +739,275 @@ function areDisjoint(sets) {
   return true;
 }
 
+// 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) {
+      const start = pos;
+      let j = pos + 2;
+      while (j + 1 < input.length && !(input.charCodeAt(j) === 42 && input.charCodeAt(j + 1) === 47)) j++;
+      pos = j + 2 <= input.length ? j + 2 : input.length;
+      chunks.push({ start, end: pos, kindIndex: commentKind });
+      continue;
+    }
+    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;
+  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)) {
+      pushCstTriviaEntry(ctx, ch.start, ch.end, kinds ? ch.kindIndex : void 0);
+    }
+  }
+}
+
+// src/combinators/trivia-skip.ts
+var NOOP_COMMIT = () => {
+};
+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, log: ctx._triviaLog ? ctx._triviaLog.length : 0 };
+}
+function rollbackTrivia(ctx, mark) {
+  rollbackCstCapture(ctx, { raw: mark.raw, tlog: mark.tlog, leaves: mark.leaves });
+  if (ctx._triviaLog) ctx._triviaLog.length = mark.log;
+}
+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;
+  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);
+  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 };
+}
+
+// src/combinators/sequence.ts
+function sequence(...parsers) {
+  const meta = {
+    firstSet: parsers[0]?._meta.firstSet ?? empty(),
+    canMatchNewline: parsers.some((p) => p._meta.canMatchNewline),
+    isTrivia: false
+  };
+  return {
+    _tag: "sequence",
+    _meta: meta,
+    _def: { tag: "sequence", parsers },
+    parse(input, pos, ctx) {
+      const values = [];
+      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);
+          }
+          values.push(result2.value);
+          continue;
+        }
+        const result = parsers[i].parse(input, cur, ctx);
+        if (!result.ok) return result;
+        values.push(result.value);
+        cur = result.span.end;
+      }
+      return {
+        ok: true,
+        value: values,
+        span: { start: pos, end: cur }
+      };
+    }
+  };
+}
+
 // src/combinators/repeat.ts
-function repItem(parser2, input, cur, ctx) {
-  const raw = ctx._cstRawChildren;
-  const mark = raw ? raw.length : 0;
+function repItem(combinator, input, cur, ctx) {
+  const mark = saveTriviaMark(ctx);
   let pos = cur;
   if (ctx.trivia) {
-    const scan = scanTrivia(input, cur, ctx);
-    scan.commit();
-    pos = scan.end;
+    if (needsDeferredTriviaCommit(ctx)) {
+      const scan = scanTrivia(input, cur, ctx);
+      scan.commit();
+      pos = scan.end;
+    } else {
+      pos = advanceTrivia(input, cur, ctx);
+    }
   }
   if (pos >= input.length) {
-    if (raw) raw.length = mark;
+    rollbackTrivia(ctx, mark);
     return "stop";
   }
-  const result = parser2.parse(input, pos, ctx);
+  const result = combinator.parse(input, pos, ctx);
   if (!result.ok) {
-    if (raw) raw.length = mark;
+    rollbackTrivia(ctx, mark);
     return { fail: result };
   }
   if (result.span.end === pos) {
-    if (raw) raw.length = mark;
+    rollbackTrivia(ctx, mark);
     return "stop";
   }
   return { value: result.value, end: result.span.end };
 }
-function many(parser2) {
+function many(combinator) {
   const meta = {
-    firstSet: parser2._meta.firstSet,
-    canMatchNewline: parser2._meta.canMatchNewline,
+    firstSet: combinator._meta.firstSet,
+    canMatchNewline: combinator._meta.canMatchNewline,
     isTrivia: false
   };
   return {
     _tag: "many",
     _meta: meta,
-    _def: { tag: "many", parser: parser2, min: 0 },
+    _def: { tag: "many", parser: combinator, min: 0 },
     parse(input, pos, ctx) {
       const values = [];
       let cur = pos;
       while (cur < input.length) {
-        const item = repItem(parser2, input, cur, ctx);
+        const item = repItem(combinator, input, cur, ctx);
         if (item === "stop" || "fail" in item) break;
         values.push(item.value);
         cur = item.end;
@@ -728,23 +1016,23 @@ function many(parser2) {
     }
   };
 }
-function oneOrMore(parser2) {
+function oneOrMore(combinator) {
   const meta = {
-    firstSet: parser2._meta.firstSet,
-    canMatchNewline: parser2._meta.canMatchNewline,
+    firstSet: combinator._meta.firstSet,
+    canMatchNewline: combinator._meta.canMatchNewline,
     isTrivia: false
   };
   return {
     _tag: "oneOrMore",
     _meta: meta,
-    _def: { tag: "oneOrMore", parser: parser2, min: 1 },
+    _def: { tag: "oneOrMore", parser: combinator, min: 1 },
     parse(input, pos, ctx) {
-      const first = parser2.parse(input, pos, ctx);
+      const first = combinator.parse(input, pos, ctx);
       if (!first.ok) return first;
       const values = [first.value];
       let cur = first.span.end;
       while (cur < input.length) {
-        const item = repItem(parser2, input, cur, ctx);
+        const item = repItem(combinator, input, cur, ctx);
         if (item === "stop" || "fail" in item) break;
         values.push(item.value);
         cur = item.end;
@@ -753,45 +1041,71 @@ function oneOrMore(parser2) {
     }
   };
 }
-function optional(parser2) {
+function optional(combinator) {
   const meta = {
-    firstSet: parser2._meta.firstSet,
-    canMatchNewline: parser2._meta.canMatchNewline,
+    firstSet: combinator._meta.firstSet,
+    canMatchNewline: combinator._meta.canMatchNewline,
     isTrivia: false
   };
   return {
     _tag: "optional",
     _meta: meta,
-    _def: { tag: "optional", parser: parser2 },
+    _def: { tag: "optional", parser: combinator },
     parse(input, pos, ctx) {
-      const result = parser2.parse(input, pos, ctx);
+      const result = combinator.parse(input, pos, ctx);
       if (result.ok) return result;
       return { ok: true, value: null, span: { start: pos, end: pos } };
     }
   };
 }
-function sepBy(parser2, separator) {
+function sepBy(combinator, separator) {
   const meta = {
-    firstSet: parser2._meta.firstSet,
-    canMatchNewline: parser2._meta.canMatchNewline || separator._meta.canMatchNewline,
+    firstSet: combinator._meta.firstSet,
+    canMatchNewline: combinator._meta.canMatchNewline || separator._meta.canMatchNewline,
     isTrivia: false
   };
   return {
     _tag: "sepBy",
     _meta: meta,
-    _def: { tag: "sepBy", parser: parser2, separator },
+    _def: { tag: "sepBy", parser: combinator, separator },
     parse(input, pos, ctx) {
-      const first = parser2.parse(input, pos, ctx);
+      const first = combinator.parse(input, pos, ctx);
       if (!first.ok) return { ok: true, value: [], span: { start: pos, end: pos } };
       const values = [first.value];
       let cur = first.span.end;
       while (cur < input.length) {
-        const sepPos = ctx.trivia ? consumeTrivia(input, cur, ctx) : cur;
+        let mark = 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) break;
-        const nextPos = ctx.trivia ? consumeTrivia(input, sep.span.end, ctx) : sep.span.end;
-        const next = parser2.parse(input, nextPos, ctx);
-        if (!next.ok) break;
+        if (!sep.ok) {
+          rollbackTrivia(ctx, mark);
+          break;
+        }
+        mark = 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) {
+          rollbackTrivia(ctx, mark);
+          break;
+        }
         values.push(next.value);
         cur = next.span.end;
       }
@@ -861,7 +1175,7 @@ function rules(factory) {
 }
 
 // src/combinators/not.ts
-function not(parser2) {
+function not(combinator) {
   const meta = {
     firstSet: any(),
     // we don't know what NOT matches
@@ -871,11 +1185,11 @@ function not(parser2) {
   return {
     _tag: "not",
     _meta: meta,
-    _def: { tag: "not", parser: parser2 },
+    _def: { tag: "not", parser: combinator },
     parse(input, pos, ctx) {
-      const result = parser2.parse(input, pos, ctx);
+      const result = combinator.parse(input, pos, ctx);
       if (result.ok) {
-        return { ok: false, expected: [`not(${parser2._tag})`], span: { start: pos, end: pos } };
+        return { ok: false, expected: [`not(${combinator._tag})`], span: { start: pos, end: pos } };
       }
       return { ok: true, value: null, span: { start: pos, end: pos } };
     }
@@ -883,37 +1197,27 @@ function not(parser2) {
 }
 
 // src/combinators/node.ts
-function node(type, parser2, build) {
+function node(type, combinator, build) {
   const meta = {
-    firstSet: parser2._meta.firstSet,
-    canMatchNewline: parser2._meta.canMatchNewline,
+    firstSet: combinator._meta.firstSet,
+    canMatchNewline: combinator._meta.canMatchNewline,
     isTrivia: false
   };
   return {
     _tag: "node",
     _meta: meta,
-    _def: { tag: "node", type, parser: parser2, build },
+    _def: { tag: "node", type, parser: combinator, build },
     parse(input, pos, ctx) {
-      const children = [];
-      const rawChildren = [];
-      const innerCtx = {
-        ...ctx,
-        // A node() always records the trivia between its terms — the library owns
-        // capture so grammar authors don't reconstruct it. (Matches the compiler.)
-        captureTrivia: true,
-        _cstChildren: children,
-        _cstLeaves: children,
-        _cstRawChildren: rawChildren
-      };
-      const r = parser2.parse(input, pos, innerCtx);
+      const saved = beginCstNodeCapture(ctx);
+      const r = combinator.parse(input, pos, ctx);
+      const { children, rawChildren, triviaLog } = endCstNodeCapture(ctx, saved);
       if (!r.ok) return r;
-      const built = build(children, rawChildren, r.span);
+      const state = ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
+      const built = build(children, rawChildren, r.span, triviaLog, state);
       const isNodeLike = typeof built === "object" && built !== null && built._tag === "node";
-      if (ctx._cstChildren) ctx._cstChildren.push(built);
-      if (ctx._cstRawChildren) {
-        ctx._cstRawChildren.push(
-          isNodeLike ? built : { _tag: "leaf", value: typeof built === "string" ? built : "", span: r.span }
-        );
+      const rawEntry = isNodeLike ? built : { _tag: "leaf", value: typeof built === "string" ? built : "", span: r.span };
+      if (saved.buf !== void 0 || saved.ch !== void 0) {
+        pushCstChild(ctx, built, rawEntry);
       }
       return { ok: true, value: built, span: r.span };
     }
@@ -921,13 +1225,13 @@ function node(type, parser2, build) {
 }
 
 // src/combinators/map.ts
-function transform(parser2, fn) {
+function transform(combinator, fn) {
   return {
     _tag: "transform",
-    _meta: parser2._meta,
-    _def: { tag: "transform", parser: parser2, fn },
+    _meta: combinator._meta,
+    _def: { tag: "transform", parser: combinator, fn },
     parse(input, pos, ctx) {
-      const result = parser2.parse(input, pos, ctx);
+      const result = combinator.parse(input, pos, ctx);
       if (!result.ok) return result;
       return { ...result, value: fn(result.value, result.span) };
     }
@@ -947,12 +1251,25 @@ function skip(main, skipped) {
     }
   };
 }
-function trivia(parser2) {
+function trivia(combinator) {
+  const kindLabels = analyzeLabeledTrivia(combinator)?.labels;
   return {
-    _tag: parser2._tag,
-    _meta: { ...parser2._meta, isTrivia: true },
-    _def: { tag: "trivia", parser: parser2 },
-    parse: parser2.parse.bind(parser2)
+    _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: combinator.parse.bind(combinator)
   };
 }
 
@@ -1003,7 +1320,10 @@ function parser(opts, root) {
       const ctx = {
         ..._ctx,
         trackLines,
-        ...opts.trivia !== void 0 ? { trivia: opts.trivia } : {},
+        ...opts.trivia !== void 0 ? {
+          trivia: opts.trivia,
+          ...opts.trivia._meta.triviaKindLabels ? { triviaKindLabels: opts.trivia._meta.triviaKindLabels } : {}
+        } : {},
         ...opts.captureTrivia || _ctx?.captureTrivia ? { captureTrivia: true } : {}
       };
       const result = root.parse(input, pos ?? 0, ctx);
@@ -1032,6 +1352,320 @@ function parse(combinator, input, opts = {}) {
   return withErrors;
 }
 
+// src/compiler/trivia-fast-path.ts
+var BLOCK_COMMENT = String.raw`\/\*(?:[^*]|\*(?!\/))*\*\/`;
+var WS_CLASS_SOURCES = /* @__PURE__ */ new Set([
+  String.raw`[ \t\n\r\f]+`,
+  String.raw`[ \t\n]+`,
+  String.raw`[ \t]+`,
+  String.raw`[\t\n\f\r ]+`
+]);
+function unwrapTrivia2(p) {
+  let cur = p;
+  while (cur._def.tag === "trivia") cur = cur._def.parser;
+  return cur;
+}
+function oneOrMoreInner(p) {
+  const d = p._def;
+  if (d.tag === "oneOrMore") return d.parser;
+  if (d.tag === "many" && d.min >= 1) return d.parser;
+  return null;
+}
+function choiceArms(p) {
+  if (p._def.tag === "choice") return p._def.parsers;
+  return null;
+}
+function isWsClassSource(source) {
+  return WS_CLASS_SOURCES.has(source);
+}
+function isBlockCommentSource(source) {
+  return source === BLOCK_COMMENT;
+}
+function analyzeTriviaFastPath(trivia2) {
+  const core = unwrapTrivia2(trivia2);
+  const direct = getCoreRegexDef(core)?.source;
+  if (direct) {
+    if (isWsClassSource(direct)) return "wsOnly";
+    return null;
+  }
+  const inner = oneOrMoreInner(core);
+  if (!inner) return null;
+  const innerSrc = getCoreRegexDef(inner)?.source;
+  if (innerSrc && isWsClassSource(innerSrc)) return "wsOnly";
+  const arms = choiceArms(inner);
+  if (!arms || arms.length !== 2) return null;
+  let hasWs = false;
+  let hasComment = false;
+  for (const arm of arms) {
+    const src = getCoreRegexDef(arm)?.source;
+    if (!src) return null;
+    if (isWsClassSource(src)) hasWs = true;
+    else if (isBlockCommentSource(src)) hasComment = true;
+    else return null;
+  }
+  if (hasWs && hasComment) return "wsComments";
+  return null;
+}
+var CAP_RECORD = [
+  `  if (_cap && _e > _pos) {`,
+  `    if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_pos, _e)`,
+  `    if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(_pos, _e, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0)`,
+  `  }`
+].join("\n");
+var WS_ONLY_LOOP = [
+  `  while (_e < input.length) {`,
+  `    const c = input.charCodeAt(_e)`,
+  `    if (c === 32 || c === 9 || c === 10 || c === 13 || c === 12) { _e++; continue }`,
+  `    break`,
+  `  }`
+].join("\n");
+var WS_COMMENTS_LOOP = [
+  `  while (_e < input.length) {`,
+  `    const c = input.charCodeAt(_e)`,
+  `    if (c === 32 || c === 9 || c === 10 || c === 13 || c === 12) { _e++; continue }`,
+  `    if (c === 47 && input.charCodeAt(_e + 1) === 42) {`,
+  `      let j = _e + 2`,
+  `      while (j + 1 < input.length && !(input.charCodeAt(j) === 42 && input.charCodeAt(j + 1) === 47)) j++`,
+  `      _e = j + 2 <= input.length ? j + 2 : input.length`,
+  `      continue`,
+  `    }`,
+  `    break`,
+  `  }`
+].join("\n");
+var CAP_CHUNK = (wsKind, commentKind) => [
+  `    if (c === 32 || c === 9 || c === 10 || c === 13 || c === 12) {`,
+  `      const _cs = _e`,
+  `      _e++`,
+  `      while (_e < input.length) {`,
+  `        const c2 = input.charCodeAt(_e)`,
+  `        if (c2 === 32 || c2 === 9 || c2 === 10 || c2 === 13 || c2 === 12) _e++`,
+  `        else break`,
+  `      }`,
+  `      if (_cap) {`,
+  `        if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_cs, _e, ${wsKind})`,
+  `        if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(_cs, _e, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0, ${wsKind})`,
+  `      }`,
+  `      continue`,
+  `    }`,
+  `    if (c === 47 && input.charCodeAt(_e + 1) === 42) {`,
+  `      const _cs = _e`,
+  `      let j = _e + 2`,
+  `      while (j + 1 < input.length && !(input.charCodeAt(j) === 42 && input.charCodeAt(j + 1) === 47)) j++`,
+  `      _e = j + 2 <= input.length ? j + 2 : input.length`,
+  `      if (_cap) {`,
+  `        if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_cs, _e, ${commentKind})`,
+  `        if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(_cs, _e, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0, ${commentKind})`,
+  `      }`,
+  `      continue`,
+  `    }`
+].join("\n");
+var WS_COMMENTS_LOOP_LABELED = (wsKind, commentKind) => [
+  `  while (_e < input.length) {`,
+  `    const c = input.charCodeAt(_e)`,
+  CAP_CHUNK(wsKind, commentKind),
+  `    break`,
+  `  }`
+].join("\n");
+function buildFastTriviaFnDecl(fnName, kind, kindIndices) {
+  const loop = kind === "wsComments" && kindIndices ? WS_COMMENTS_LOOP_LABELED(kindIndices.ws, kindIndices.comment) : kind === "wsComments" ? WS_COMMENTS_LOOP : WS_ONLY_LOOP;
+  const cap = kindIndices ? "" : CAP_RECORD;
+  const lines = [
+    `function ${fnName}(input, _pos, _ctx, _cap) {`,
+    `  let _e = _pos`,
+    loop
+  ];
+  if (cap) lines.push(cap);
+  lines.push(`  return _e`, `}`);
+  return lines.join("\n");
+}
+function regexArmIndex(spec, isComment) {
+  for (const arm of spec.arms) {
+    const src = getCoreRegexDef(arm.parser)?.source;
+    if (!src) return null;
+    const comment = src.includes("\\*") || src.startsWith("\\/\\/");
+    if (comment === isComment) return arm.kindIndex;
+  }
+  return null;
+}
+function buildLabeledRegexTriviaFnDecl(fnName, spec, reNames) {
+  const tryArms = spec.arms.map((arm, i) => {
+    const re = reNames[i];
+    const k = arm.kindIndex;
+    return [
+      `    ${re}.lastIndex = _e`,
+      `    const _m${i} = ${re}.exec(input)`,
+      `    if (_m${i} && _m${i}.index === _e) {`,
+      `      const _ce = _e + _m${i}[0].length`,
+      `      if (_cap) {`,
+      `        if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_e, _ce, ${k})`,
+      `        if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(_e, _ce, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0, ${k})`,
+      `      }`,
+      `      _e = _ce`,
+      `      _matched = true`,
+      `      continue`,
+      `    }`
+    ].join("\n");
+  }).join("\n");
+  return [
+    `function ${fnName}(input, _pos, _ctx, _cap) {`,
+    `  let _e = _pos`,
+    `  while (_e < input.length) {`,
+    `    let _matched = false`,
+    tryArms,
+    `    if (!_matched) break`,
+    `  }`,
+    `  return _e`,
+    `}`
+  ].join("\n");
+}
+function labeledTriviaKindIndices(trivia2) {
+  const spec = analyzeLabeledTrivia(trivia2);
+  if (!spec || spec.arms.length !== 2) return null;
+  const ws = regexArmIndex(spec, false);
+  const comment = regexArmIndex(spec, true);
+  if (ws === null || comment === null) return null;
+  return { ws, comment };
+}
+function labeledTriviaRegexArms(trivia2) {
+  const spec = analyzeLabeledTrivia(trivia2);
+  if (!spec) return null;
+  for (const arm of spec.arms) {
+    if (!getCoreRegexDef(arm.parser)) return null;
+  }
+  return spec;
+}
+function buildLabeledRuntimeTriviaFnDecl(fnName, spec, rpStartIndex) {
+  const tryArms = spec.arms.map((arm, i) => {
+    const k = arm.kindIndex;
+    const ri = rpStartIndex + i;
+    return [
+      `    const _r${i} = _rp[${ri}].parse(input, _e, _ctx)`,
+      `    if (_r${i}.ok && _r${i}.span.end > _e) {`,
+      `      const _ce = _r${i}.span.end`,
+      `      if (_cap) {`,
+      `        if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_e, _ce, ${k})`,
+      `        if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(_e, _ce, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0, ${k})`,
+      `      }`,
+      `      _e = _ce`,
+      `      _matched = true`,
+      `      continue`,
+      `    }`
+    ].join("\n");
+  }).join("\n");
+  return [
+    `function ${fnName}(input, _pos, _ctx, _cap) {`,
+    `  let _e = _pos`,
+    `  while (_e < input.length) {`,
+    `    let _matched = false`,
+    tryArms,
+    `    if (!_matched) break`,
+    `  }`,
+    `  return _e`,
+    `}`
+  ].join("\n");
+}
+
+// src/compiler/inline-build.ts
+var MK_BUILD_RE = /^\(\s*(?:\w+\s*,\s*){3}\w+\s*\)\s*=>\s*mk\s*\(\s*(['"])([^'"]+)\1\s*,\s*\w+\s*,\s*\w+\s*,\s*\w+\s*,\s*\w+\s*\)\s*$/;
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function looseMkBuildRe(type) {
+  return new RegExp(
+    String.raw`^\(\s*(?:\w+\s*,\s*){3}\w+\s*\)\s*=>\s*.+\(\s*(['"])${escapeRegExp(type)}\1\s*,\s*\w+\s*,\s*\w+\s*,\s*\w+\s*,\s*\w+\s*\)\s*$`
+  );
+}
+function analyzeMkInlineBuild(def) {
+  const src = (def.buildSrc ?? def.build.toString()).trim();
+  const strict = src.match(MK_BUILD_RE);
+  if (strict) {
+    const mkType = strict[2];
+    return mkType === def.type ? def.type : null;
+  }
+  if (looseMkBuildRe(def.type).test(src)) return def.type;
+  return null;
+}
+function emitInlineMkNodeExpr(type, chV, rawV, pos, endVar, tlV) {
+  return `{ _tag: 'node', type: ${JSON.stringify(type)}, span: { start: ${pos}, end: ${endVar} }, children: ${chV}, rawCount: ${rawV}.length, localTriviaLen: ${tlV}.length }`;
+}
+
+// src/compiler/inline-callback.ts
+var INLINE_BUILTINS = /* @__PURE__ */ new Set([
+  "parseInt",
+  "parseFloat",
+  "String",
+  "Number",
+  "Boolean",
+  "Object",
+  "Array",
+  "Math",
+  "JSON",
+  "undefined",
+  "null",
+  "true",
+  "false",
+  "NaN",
+  "Infinity"
+]);
+function escapeRegExp2(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function transformFnSource(fn, fnSrc) {
+  if (fnSrc) return fnSrc.trim();
+  const s = fn.toString().trim();
+  if (s.includes("[native code]")) return null;
+  return s;
+}
+function replaceParam(body, param, valueVar) {
+  return body.replace(new RegExp(`\\b${escapeRegExp2(param)}\\b`, "g"), valueVar);
+}
+function stripForIdCheck(body) {
+  return body.replace(/'[^'\\]*(?:\\.[^'\\]*)*'|"[^"\\]*(?:\\.[^"\\]*)*"/g, '""').replace(/\bas\s+const\b/g, "").replace(/\b[A-Za-z_$][\w$]*\s*:/g, ":");
+}
+function hasFreeIdentifiers(body, allowed) {
+  const stripped = stripForIdCheck(body);
+  const ids = stripped.match(/\b[A-Za-z_$][\w$]*\b/g) ?? [];
+  for (const id of ids) {
+    if (INLINE_BUILTINS.has(id)) continue;
+    if (allowed.has(id)) continue;
+    return true;
+  }
+  return false;
+}
+function tryInlineUnaryTransform(src, valueVar) {
+  const allowed = /* @__PURE__ */ new Set([valueVar]);
+  const nullary = src.match(/^\(\s*\)\s*=>\s*(.+)$/);
+  if (nullary) {
+    const body2 = nullary[1].trim();
+    return hasFreeIdentifiers(body2, allowed) ? null : body2;
+  }
+  const m = src.match(/^(\w+)\s*=>\s*(.+)$/);
+  if (!m) return null;
+  const body = replaceParam(m[2].trim(), m[1], valueVar);
+  return hasFreeIdentifiers(body, allowed) ? null : body;
+}
+function parseArrayDestructure(pattern, arity) {
+  const slots = [];
+  for (const part of pattern.split(",")) {
+    const name = part.trim();
+    slots.push(name === "" || name === "_" ? null : name);
+  }
+  while (slots.length < arity) slots.push(null);
+  return slots.slice(0, arity);
+}
+function tryInlineDestructureTransform(src, valueVars) {
+  const m = src.match(/^\(\s*\[([^\]]*)\]\s*\)\s*=>\s*(.+)$/s);
+  if (!m) return null;
+  const slots = parseArrayDestructure(m[1], valueVars.length);
+  let body = m[2].trim();
+  const allowed = new Set(valueVars);
+  for (let i = 0; i < slots.length; i++) {
+    const name = slots[i];
+    if (name) body = replaceParam(body, name, valueVars[i]);
+  }
+  return hasFreeIdentifiers(body, allowed) ? null : body;
+}
+
 // src/compiler/codegen.ts
 function v(ctx, prefix = "_v") {
   return `${prefix}${ctx.vars++}`;
@@ -1039,12 +1673,42 @@ function v(ctx, prefix = "_v") {
 function ind(ctx) {
   return "  ".repeat(ctx.indent);
 }
+var NAMED_FN_FAIL = "_pfFail";
+var NAMED_FN_END = "_pfEnd";
+function namedFnPrelude() {
+  return [`const ${NAMED_FN_FAIL} = {}`, `let ${NAMED_FN_END}`];
+}
+function pushNamedFnDecl(ctx, fnName, bodyStmts, valueVar, endVar) {
+  ctx.namedFnDecls.push([
+    `function ${fnName}(input, _pos, _ctx) {`,
+    `  let _pfok = false, _pfv, _pfe = _pos`,
+    `  _pfail: {`,
+    ...bodyStmts,
+    `  _pfv = ${valueVar}; _pfe = ${endVar}; _pfok = true`,
+    `  }`,
+    `  if (!_pfok) return ${NAMED_FN_FAIL}`,
+    `  ${NAMED_FN_END} = _pfe`,
+    `  return _pfv`,
+    `}`
+  ].join("\n"));
+}
+function emitNamedFnCall(ctx, fnName, pos, failExpected) {
+  const vv = v(ctx, "_pfv");
+  const ev = v(ctx, "_pfe");
+  return {
+    stmts: [
+      `${ind(ctx)}const ${vv} = ${fnName}(input, ${pos}, _ctx)`,
+      `${ind(ctx)}if (${vv} === ${NAMED_FN_FAIL}) ${failStmt({ ...ctx, indent: 0 }, failExpected, pos).trim()}`,
+      `${ind(ctx)}const ${ev} = ${NAMED_FN_END}`
+    ],
+    valueVar: vv,
+    endVar: ev
+  };
+}
 function emitLeafCapture(ctx, valExpr, startExpr, endExpr) {
   if (!ctx.capturing) return [];
+  if (ctx.capAsTrivia) return [];
   const i = ind(ctx);
-  if (ctx.capAsTrivia) {
-    return [`${i}if (_ctx._cstRawChildren) _ctx._cstRawChildren.push({ _tag: 'trivia', value: ${valExpr}, span: { start: ${startExpr}, end: ${endExpr} } })`];
-  }
   const lf = v(ctx, "_lf");
   return [
     `${i}if (_ctx._cstLeaves) {`,
@@ -1054,35 +1718,84 @@ function emitLeafCapture(ctx, valExpr, startExpr, endExpr) {
     `${i}}`
   ];
 }
-function ensureTriviaCaptureFn(ctx) {
+function ensureRegexDecl(ctx, optimizedSource, flags) {
+  const f = "y" + flags.replace(/[gy]/g, "");
+  const key = `${optimizedSource}/${f}`;
+  let rName = ctx.regexMap.get(key);
+  if (rName === void 0) {
+    rName = `_re${ctx.regexDecls.length}`;
+    ctx.regexDecls.push(`const ${rName} = /${optimizedSource}/${f}`);
+    ctx.regexMap.set(key, rName);
+  }
+  return rName;
+}
+function ensureTriviaFn(ctx) {
   const trivia2 = ctx.activeTrivia;
-  const existing = ctx.triviaCaptureNames.get(trivia2);
+  const existing = ctx.triviaFnNames.get(trivia2);
   if (existing) return existing;
-  const fnName = `_tc${ctx.triviaCaptureNames.size}`;
+  const fnName = `_tf${ctx.triviaFnNames.size}`;
+  ctx.triviaFnNames.set(trivia2, fnName);
   ctx.triviaCaptureNames.set(trivia2, fnName);
-  const saved = { indent: ctx.indent, failLabel: ctx.failLabel, asTrivia: ctx.capAsTrivia, trivia: ctx.activeTrivia };
+  const fastKind = analyzeTriviaFastPath(trivia2);
+  const kindIndices = labeledTriviaKindIndices(trivia2);
+  if (fastKind) {
+    ctx.namedFnDecls.push(buildFastTriviaFnDecl(fnName, fastKind, kindIndices ?? void 0));
+    return fnName;
+  }
+  const labeledSpec = analyzeLabeledTrivia(trivia2);
+  if (labeledSpec) {
+    const regexSpec = labeledTriviaRegexArms(trivia2);
+    if (regexSpec) {
+      const reNames = [];
+      for (const arm of regexSpec.arms) {
+        const def = arm.parser._def;
+        if (def.tag !== "regex") break;
+        reNames.push(ensureRegexDecl(ctx, def.optimizedSource, def.flags));
+      }
+      if (reNames.length === regexSpec.arms.length) {
+        ctx.namedFnDecls.push(buildLabeledRegexTriviaFnDecl(fnName, regexSpec, reNames));
+        return fnName;
+      }
+    }
+    const rpStart = ctx.runtimeParsers.length;
+    for (const arm of labeledSpec.arms) {
+      ctx.runtimeParsers.push(arm.parser);
+    }
+    ctx.namedFnDecls.push(buildLabeledRuntimeTriviaFnDecl(fnName, labeledSpec, rpStart));
+    return fnName;
+  }
+  const savedIndent = ctx.indent;
+  const savedFailLabel = ctx.failLabel;
+  const savedTrivia = ctx.activeTrivia;
+  const savedCapAsTrivia = ctx.capAsTrivia;
   ctx.indent = 2;
-  ctx.failLabel = "_cap";
+  ctx.failLabel = "_triv";
   ctx.capAsTrivia = true;
-  delete ctx.activeTrivia;
+  ctx.activeTrivia = void 0;
   const r = emit(trivia2, ctx, "_pos");
-  ctx.indent = saved.indent;
-  ctx.failLabel = saved.failLabel;
-  ctx.capAsTrivia = saved.asTrivia;
-  if (saved.trivia) ctx.activeTrivia = saved.trivia;
+  ctx.indent = savedIndent;
+  ctx.failLabel = savedFailLabel;
+  ctx.capAsTrivia = savedCapAsTrivia;
+  ctx.activeTrivia = savedTrivia;
   ctx.namedFnDecls.push([
-    `function ${fnName}(input, _pos, _ctx) {`,
+    `function ${fnName}(input, _pos, _ctx, _cap) {`,
     `  let _e = _pos`,
-    `  _cap: {`,
+    `  _triv: {`,
     ...r.stmts,
     `    _e = ${r.endVar}`,
     `  }`,
-    `  if (_ctx._triviaLog !== undefined && _e > _pos) _ctx._triviaLog.push(_pos, _e)`,
+    `  if (_cap && _e > _pos) {`,
+    `    if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_pos, _e)`,
+    `    if (_ctx._cstTriviaLog !== undefined) _ctx._cstTriviaLog.push(_pos, _e, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0)`,
+    `  }`,
     `  return _e`,
     `}`
   ].join("\n"));
   return fnName;
 }
+function ensureTriviaCaptureFn(ctx) {
+  return ensureTriviaFn(ctx);
+}
 function failStmt(ctx, expected, posExpr) {
   if (ctx.failLabel) return `${ind(ctx)}break ${ctx.failLabel}`;
   return `${ind(ctx)}return { ok: false, expected: [${expected}], span: { start: ${posExpr}, end: ${posExpr} } }`;
@@ -1098,14 +1811,6 @@ function firstSetCond(codeVar, fs) {
     (r) => r.lo === r.hi ? `${codeVar} === ${r.lo}` : `(${codeVar} >= ${r.lo} && ${codeVar} <= ${r.hi})`
   ).join(" || ");
 }
-function asIIFE(stmts, valueVar, endVar, startPos, indent) {
-  return [
-    `(() => {`,
-    ...stmts,
-    `${indent}  return { ok: true, value: ${valueVar}, span: { start: ${startPos}, end: ${endVar} } }`,
-    `${indent}})()`
-  ].join("\n");
-}
 function emitFallible(inner, ctx, pos) {
   const lbl = v(ctx, "_lbl");
   const okV = `${lbl}ok`;
@@ -1171,6 +1876,33 @@ function emitLit(def, ctx, pos) {
   stmts.push(...emitLeafCapture(ctx, vv, pos, endVar));
   return { stmts, valueVar: vv, endVar };
 }
+function escapeKeywordRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function emitKeywords(def, ctx, pos) {
+  const alt = def.words.map(escapeKeywordRe).join("|");
+  const boundary = def.boundary ? `(?![${def.boundary}])` : "";
+  const flags = def.caseInsensitive ? "iuy" : "uy";
+  const source = `(?:${alt})${boundary}`;
+  const key = `${source}/${flags}`;
+  let rName = ctx.regexMap.get(key);
+  if (rName === void 0) {
+    rName = `_re${ctx.regexDecls.length}`;
+    ctx.regexDecls.push(`const ${rName} = /${source}/${flags}`);
+    ctx.regexMap.set(key, rName);
+  }
+  const mv = v(ctx, "_m");
+  const vv = v(ctx);
+  const stmts = [
+    `${ind(ctx)}${rName}.lastIndex = ${pos}`,
+    `${ind(ctx)}const ${mv} = ${rName}.exec(input)`,
+    `${ind(ctx)}if (${mv} === null) ${failStmt({ ...ctx, indent: 0 }, '"keyword"', pos).trim()}`,
+    `${ind(ctx)}const ${vv} = ${mv}[0]`
+  ];
+  const endVar = `${pos} + ${vv}.length`;
+  stmts.push(...emitLeafCapture(ctx, vv, pos, endVar));
+  return { stmts, valueVar: vv, endVar };
+}
 function emitRegex(def, ctx, pos) {
   const flags = "y" + def.flags.replace(/[gy]/g, "");
   const key = `${def.optimizedSource}/${flags}`;
@@ -1193,31 +1925,7 @@ function emitRegex(def, ctx, pos) {
   stmts.push(...emitLeafCapture(ctx, vv, pos, endVar));
   return { stmts, valueVar: vv, endVar };
 }
-function ensureTriviaFn(ctx) {
-  const trivia2 = ctx.activeTrivia;
-  if (!ctx.namedParsers.has(trivia2)) {
-    const fnName = `_pf${ctx.namedParsers.size}`;
-    ctx.namedParsers.set(trivia2, fnName);
-    const savedIndent = ctx.indent;
-    const savedFailLabel = ctx.failLabel;
-    const savedTrivia = ctx.activeTrivia;
-    ctx.indent = 1;
-    ctx.failLabel = void 0;
-    delete ctx.activeTrivia;
-    const r = emit(trivia2, ctx, "_pos");
-    ctx.indent = savedIndent;
-    ctx.failLabel = savedFailLabel;
-    if (savedTrivia) ctx.activeTrivia = savedTrivia;
-    ctx.namedFnDecls.push([
-      `function ${fnName}(input, _pos, _ctx) {`,
-      ...r.stmts,
-      `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,
-      `}`
-    ].join("\n"));
-  }
-  return ctx.namedParsers.get(trivia2);
-}
-function emitSeq(def, ctx, pos) {
+function emitSeqValues(def, ctx, pos) {
   const startV = v(ctx, "_start");
   const curV = v(ctx, "_cur");
   const stmts = [
@@ -1229,23 +1937,41 @@ function emitSeq(def, ctx, pos) {
     if (i > 0 && ctx.activeTrivia) {
       if (ctx.capturing) {
         const capFn = ensureTriviaCaptureFn(ctx);
-        stmts.push(`${ind(ctx)}${curV} = ${capFn}(input, ${curV}, _ctx)`);
-      } else {
-        const trivFn = ensureTriviaFn(ctx);
-        const tmp = v(ctx, "_trv");
+        const markV = v(ctx, "_mk");
+        const markTl = v(ctx, "_mktl");
+        const markLog = v(ctx, "_mklg");
+        const scanEndV = v(ctx, "_sne");
+        stmts.push(
+          `${ind(ctx)}const ${markV} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`,
+          `${ind(ctx)}const ${markTl} = _ctx._cstTriviaLog ? _ctx._cstTriviaLog.length : 0`,
+          `${ind(ctx)}const ${markLog} = _ctx._triviaLog ? _ctx._triviaLog.length : 0`,
+          `${ind(ctx)}const ${scanEndV} = ${capFn}(input, ${curV}, _ctx, 1)`
+        );
+        const r2 = emit(def.parsers[i], ctx, scanEndV);
+        stmts.push(...r2.stmts);
+        const endAfterV = v(ctx, "_sea");
         stmts.push(
-          `${ind(ctx)}const ${tmp} = ${trivFn}(input, ${curV}, _ctx)`,
-          `${ind(ctx)}if (${tmp}.ok) ${curV} = ${tmp}.span.end`
+          `${ind(ctx)}const ${endAfterV} = ${r2.endVar}`,
+          `${ind(ctx)}if (${endAfterV} > ${scanEndV}) { ${curV} = ${endAfterV} } else { if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${markLog}; }`
         );
+        valueVars.push(r2.valueVar);
+        continue;
+      } else {
+        const trivFn = ensureTriviaFn(ctx);
+        stmts.push(`${ind(ctx)}${curV} = ${trivFn}(input, ${curV}, _ctx)`);
       }
     }
     const r = emit(def.parsers[i], ctx, curV);
     stmts.push(...r.stmts, `${ind(ctx)}${curV} = ${r.endVar}`);
     valueVars.push(r.valueVar);
   }
+  return { stmts, valueVar: valueVars[valueVars.length - 1] ?? "null", endVar: curV, valueVars };
+}
+function emitSeq(def, ctx, pos) {
+  const { stmts, endVar, valueVars } = emitSeqValues(def, ctx, pos);
   const arrV = v(ctx, "_arr");
   stmts.push(`${ind(ctx)}const ${arrV} = [${valueVars.join(", ")}]`);
-  return { stmts, valueVar: arrV, endVar: curV };
+  return { stmts, valueVar: arrV, endVar };
 }
 function emitChoice(def, ctx, pos) {
   const allExpected = JSON.stringify(
@@ -1296,29 +2022,39 @@ function emitGreedyClassify(def, superIndex, allExpected, ctx, pos) {
   const matchV = v(ctx, "_gm");
   const wordV = v(ctx, "_gw");
   const endV = v(ctx, "_ge");
+  const valV = v(ctx, "_gcv");
   const stmts = [
     `${ind(ctx)}${reVar}.lastIndex = ${pos}`,
     `${ind(ctx)}const ${matchV} = ${reVar}.exec(input)`,
     `${ind(ctx)}if (${matchV} === null) ${failArr({ ...ctx, indent: 0 }, allExpected, pos)}`,
     `${ind(ctx)}const ${wordV} = ${matchV}[0]`,
-    `${ind(ctx)}const ${endV} = ${pos} + ${wordV}.length`
+    `${ind(ctx)}const ${endV} = ${pos} + ${wordV}.length`,
+    `${ind(ctx)}let ${valV}`
   ];
+  let first = true;
   for (let i = 0; i < def.parsers.length; i++) {
     if (i === superIndex) continue;
     const p = def.parsers[i];
     const litVal = getCoreLiteralValue(p);
     if (litVal === null) continue;
-    stmts.push(`${ind(ctx)}if (${wordV} === ${JSON.stringify(litVal)}) {`);
+    const kw = first ? "if" : "else if";
+    first = false;
+    stmts.push(`${ind(ctx)}${kw} (${wordV} === ${JSON.stringify(litVal)}) {`);
     ctx.indent++;
     const tR = emitTransformChain(p, JSON.stringify(litVal), endV, pos, ctx);
-    stmts.push(...tR.stmts);
-    stmts.push(`${ind(ctx)}return { ok: true, value: ${tR.valueVar}, span: { start: ${pos}, end: ${endV} } }`);
+    stmts.push(...emitLeafCapture(ctx, JSON.stringify(litVal), pos, endV));
+    stmts.push(...tR.stmts, `${ind(ctx)}${valV} = ${tR.valueVar}`);
     ctx.indent--;
     stmts.push(`${ind(ctx)}}`);
   }
   const rR = emitTransformChain(superParser, wordV, endV, pos, ctx);
-  stmts.push(...rR.stmts);
-  return { stmts, valueVar: rR.valueVar, endVar: endV };
+  const regexKw = first ? "if" : "else";
+  stmts.push(`${ind(ctx)}${regexKw} {`);
+  ctx.indent++;
+  stmts.push(...emitLeafCapture(ctx, wordV, pos, endV), ...rR.stmts, `${ind(ctx)}${valV} = ${rR.valueVar}`);
+  ctx.indent--;
+  stmts.push(`${ind(ctx)}}`);
+  return { stmts, valueVar: valV, endVar: endV };
 }
 function emitLiteralsLongestFirst(def, sortedIndices, allExpected, ctx, pos) {
   const valV = v(ctx, "_llv");
@@ -1332,10 +2068,15 @@ function emitLiteralsLongestFirst(def, sortedIndices, allExpected, ctx, pos) {
     const litCond = emitLiteralCondition(litVal, pos);
     const kw = first ? "if" : "else if";
     first = false;
+    const litEnd = `${pos} + ${litLen}`;
     stmts.push(`${ind(ctx)}${kw} (${litCond}) {`);
     ctx.indent++;
-    const tR = emitTransformChain(p, JSON.stringify(litVal), `${pos} + ${litLen}`, pos, ctx);
-    stmts.push(...tR.stmts, `${ind(ctx)}${valV} = ${tR.valueVar}; ${endV} = ${pos} + ${litLen}`);
+    const tR = emitTransformChain(p, JSON.stringify(litVal), litEnd, pos, ctx);
+    stmts.push(
+      ...emitLeafCapture(ctx, JSON.stringify(litVal), pos, litEnd),
+      ...tR.stmts,
+      `${ind(ctx)}${valV} = ${tR.valueVar}; ${endV} = ${litEnd}`
+    );
     ctx.indent--;
     stmts.push(`${ind(ctx)}}`);
   }
@@ -1343,67 +2084,66 @@ function emitLiteralsLongestFirst(def, sortedIndices, allExpected, ctx, pos) {
   return { stmts, valueVar: valV, endVar: endV };
 }
 function emitFirstMatch(def, allExpected, ctx, pos) {
-  const resV = v(ctx, "_cr");
-  const stmts = [`${ind(ctx)}let ${resV}`];
+  const resValV = v(ctx, "_crv");
+  const resEndV = v(ctx, "_cre");
+  const resOkV = v(ctx, "_crok");
+  const ind0 = ind(ctx);
+  const stmts = [
+    `${ind0}let ${resValV}, ${resEndV} = ${pos}, ${resOkV} = false`
+  ];
   for (let i = 0; i < def.parsers.length; i++) {
     const p = def.parsers[i];
     const gate = def.gates[i];
     const autoNot = def.autoNot[i];
-    const savedIndent = ctx.indent;
-    const savedFailLabel = ctx.failLabel;
-    ctx.indent = 0;
-    ctx.failLabel = void 0;
-    const r = emit(p, ctx, pos);
-    ctx.indent = savedIndent;
-    ctx.failLabel = savedFailLabel;
-    const iife = asIIFE(r.stmts, r.valueVar, r.endVar, pos, ind(ctx));
     let gateCond = null;
     if (gate) {
       const gateIdx = ctx.mapFns.length;
       ctx.mapFns.push(gate);
       gateCond = `_mf[${gateIdx}](_ctx.state)`;
     }
-    const skipCond = gateCond ? `!${resV}?.ok && ${gateCond}` : `!${resV}?.ok`;
+    const skipCond = gateCond ? `!${resOkV} && ${gateCond}` : `!${resOkV}`;
     const markLeaves = ctx.capturing ? v(ctx, "_cml") : null;
     const markRaw = ctx.capturing ? v(ctx, "_cmr") : null;
-    const rollback = markLeaves ? `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${markLeaves}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markRaw}` : "";
-    const markStmts = markLeaves ? [
-      `${ind(ctx)}  const ${markLeaves} = _ctx._cstLeaves?.length ?? 0`,
-      `${ind(ctx)}  const ${markRaw} = _ctx._cstRawChildren?.length ?? 0`
-    ] : [];
-    const rollbackStmt = rollback ? `${ind(ctx)}  if (!${resV}?.ok) { ${rollback} }` : "";
+    const markTl = ctx.capturing ? v(ctx, "_cmtl") : null;
+    const markLog = ctx.capturing ? v(ctx, "_cmlg") : null;
+    const rollback = markLeaves ? `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${markLeaves}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markRaw}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${markLog}` : "";
+    stmts.push(`${ind0}if (${skipCond}) {`);
+    ctx.indent++;
+    const ind1 = ind(ctx);
+    if (markLeaves) {
+      stmts.push(
+        `${ind1}const ${markLeaves} = _ctx._cstLeaves?.length ?? 0`,
+        `${ind1}const ${markRaw} = _ctx._cstRawChildren?.length ?? 0`,
+        `${ind1}const ${markTl} = _ctx._cstTriviaLog?.length ?? 0`,
+        `${ind1}const ${markLog} = _ctx._triviaLog?.length ?? 0`
+      );
+    }
+    const { stmts: armStmts, okVar, valVar, endVar } = emitFallible(p, ctx, pos);
+    stmts.push(...armStmts);
+    ctx.indent--;
     if (autoNot && autoNot.length > 0) {
-      const tmp = v(ctx, "_ct");
       const anCode = v(ctx, "_anc");
       const rejectCond = autoNot.map(
-        (check) => check.kind === "firstSet" ? firstSetCond(anCode, check.set) : `input.startsWith(${JSON.stringify(check.value)}, ${tmp}.span.end)`
+        (check) => check.kind === "firstSet" ? firstSetCond(anCode, check.set) : `input.startsWith(${JSON.stringify(check.value)}, ${endVar})`
       ).join(" || ");
-      stmts.push(`${ind(ctx)}if (${skipCond}) {`);
-      stmts.push(...markStmts);
       stmts.push(
-        `${ind(ctx)}  const ${tmp} = (() => { try { return ${iife} } catch {} })()`,
-        `${ind(ctx)}  if (${tmp}?.ok) { const ${anCode} = ${tmp}.span.end < input.length ? input.charCodeAt(${tmp}.span.end) : -1; if (!(${rejectCond})) ${resV} = ${tmp} }`
+        `${ind0}  if (${okVar}) { const ${anCode} = ${endVar} < input.length ? input.charCodeAt(${endVar}) : -1; if (!(${rejectCond})) { ${resValV} = ${valVar}; ${resEndV} = ${endVar}; ${resOkV} = true } }`
       );
-      if (rollbackStmt) stmts.push(rollbackStmt);
-      stmts.push(`${ind(ctx)}}`);
+      if (rollback) stmts.push(`${ind0}  if (!${resOkV}) { ${rollback} }`);
     } else {
-      stmts.push(`${ind(ctx)}if (${skipCond}) {`);
-      stmts.push(...markStmts);
-      stmts.push(`${ind(ctx)}  try { ${resV} = ${iife} } catch {}`);
-      if (rollbackStmt) stmts.push(rollbackStmt);
-      stmts.push(`${ind(ctx)}}`);
+      stmts.push(`${ind0}  if (${okVar}) { ${resValV} = ${valVar}; ${resEndV} = ${endVar}; ${resOkV} = true }`);
+      if (rollback) stmts.push(`${ind0}  else { ${rollback} }`);
     }
+    stmts.push(`${ind0}}`);
   }
-  stmts.push(`${ind(ctx)}if (!${resV}?.ok) ${failArr({ ...ctx, indent: 0 }, allExpected, pos)}`);
-  return { stmts, valueVar: `${resV}.value`, endVar: `${resV}.span.end` };
+  stmts.push(`${ind0}if (!${resOkV}) ${failArr({ ...ctx, indent: 0 }, allExpected, pos)}`);
+  return { stmts, valueVar: resValV, endVar: resEndV };
 }
 function emitNonDisjoint(def, strategy, allExpected, ctx, pos) {
-  if (!ctx.capturing) {
-    if (strategy.tag === "greedyClassify")
-      return emitGreedyClassify(def, strategy.superIndex, allExpected, ctx, pos);
-    if (strategy.tag === "literalsLongestFirst")
-      return emitLiteralsLongestFirst(def, strategy.sortedIndices, allExpected, ctx, pos);
-  }
+  if (strategy.tag === "greedyClassify")
+    return emitGreedyClassify(def, strategy.superIndex, allExpected, ctx, pos);
+  if (strategy.tag === "literalsLongestFirst")
+    return emitLiteralsLongestFirst(def, strategy.sortedIndices, allExpected, ctx, pos);
   return emitFirstMatch(def, allExpected, ctx, pos);
 }
 function emitTransformChain(p, baseValue, endV, startPos, ctx) {
@@ -1456,27 +2196,28 @@ function emitMany(def, ctx, pos) {
     if (ctx.capturing) {
       const capFn = ensureTriviaCaptureFn(ctx);
       const markV = v(ctx, "_mk");
+      const markTl = v(ctx, "_mktl");
+      const markLog = v(ctx, "_mklg");
       const npV = v(ctx, "_np");
       stmts.push(
         `${ind(ctx)}const ${markV} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`,
-        `${ind(ctx)}const ${npV} = ${capFn}(input, ${curV}, _ctx)`
+        `${ind(ctx)}const ${markTl} = _ctx._cstTriviaLog ? _ctx._cstTriviaLog.length : 0`,
+        `${ind(ctx)}const ${markLog} = _ctx._triviaLog ? _ctx._triviaLog.length : 0`,
+        `${ind(ctx)}const ${npV} = ${capFn}(input, ${curV}, _ctx, 1)`
       );
       itemPos = npV;
-      rollback = `if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markV}; `;
+      rollback = `if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${markLog}; `;
     } else {
       const trivFn = ensureTriviaFn(ctx);
       const npV = v(ctx, "_np");
-      stmts.push(
-        `${ind(ctx)}let ${npV} = ${curV}`,
-        `${ind(ctx)}{ const _trv = ${trivFn}(input, ${npV}, _ctx); if (_trv.ok) ${npV} = _trv.span.end }`
-      );
+      stmts.push(`${ind(ctx)}const ${npV} = ${trivFn}(input, ${curV}, _ctx)`);
       itemPos = npV;
     }
   }
   const { stmts: iterStmts, okVar: iterOk, valVar: iterVal, endVar: iterEnd } = emitFallible(def.parser, ctx, itemPos);
   stmts.push(
     ...iterStmts,
-    `${ind(ctx)}if (!${iterOk} || ${iterEnd} === ${curV}) { ${rollback}break }`,
+    `${ind(ctx)}if (!${iterOk} || ${iterEnd} <= ${itemPos}) { ${rollback}break }`,
     `${ind(ctx)}${arrV}.push(${iterVal})`,
     `${ind(ctx)}${curV} = ${iterEnd}`
   );
@@ -1513,55 +2254,70 @@ function emitSepBy(_p, def, ctx, pos) {
     `${ind(ctx)}while (${curV} < input.length) {`
   );
   ctx.indent++;
-  let rollback = "";
-  if (ctx.capturing) {
-    const markV = v(ctx, "_mk");
-    stmts.push(`${ind(ctx)}const ${markV} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`);
-    rollback = `if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markV}; `;
-  }
   let sepAtPos = curV;
   if (ctx.activeTrivia) {
     if (ctx.capturing) {
       const capFn = ensureTriviaCaptureFn(ctx);
-      const spV = v(ctx, "_sp");
-      stmts.push(`${ind(ctx)}const ${spV} = ${capFn}(input, ${curV}, _ctx)`);
-      sepAtPos = spV;
-    } else {
-      const trivFn = ensureTriviaFn(ctx);
+      const markV = v(ctx, "_mk");
+      const markTl = v(ctx, "_mktl");
+      const markLog = v(ctx, "_mklg");
       const spV = v(ctx, "_sp");
       stmts.push(
-        `${ind(ctx)}let ${spV} = ${curV}`,
-        `${ind(ctx)}{ const _trv = ${trivFn}(input, ${spV}, _ctx); if (_trv.ok) ${spV} = _trv.span.end }`
+        `${ind(ctx)}const ${markV} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`,
+        `${ind(ctx)}const ${markTl} = _ctx._cstTriviaLog ? _ctx._cstTriviaLog.length : 0`,
+        `${ind(ctx)}const ${markLog} = _ctx._triviaLog ? _ctx._triviaLog.length : 0`,
+        `${ind(ctx)}const ${spV} = ${capFn}(input, ${curV}, _ctx, 1)`
       );
       sepAtPos = spV;
-    }
-  }
-  const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos);
-  stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${rollback}break }`);
-  let nextAtPos = sepEnd;
-  if (ctx.activeTrivia) {
-    if (ctx.capturing) {
-      const capFn = ensureTriviaCaptureFn(ctx);
+      const sepRollback = `if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${markLog}; `;
+      const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos);
+      stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${sepRollback}break }`);
+      const mark2V = v(ctx, "_mk2");
+      const mark2Tl = v(ctx, "_mktl2");
+      const mark2Log = v(ctx, "_mklg2");
       const npV = v(ctx, "_np");
-      stmts.push(`${ind(ctx)}const ${npV} = ${capFn}(input, ${sepEnd}, _ctx)`);
-      nextAtPos = npV;
+      stmts.push(
+        `${ind(ctx)}const ${mark2V} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`,
+        `${ind(ctx)}const ${mark2Tl} = _ctx._cstTriviaLog ? _ctx._cstTriviaLog.length : 0`,
+        `${ind(ctx)}const ${mark2Log} = _ctx._triviaLog ? _ctx._triviaLog.length : 0`,
+        `${ind(ctx)}const ${npV} = ${capFn}(input, ${sepEnd}, _ctx, 1)`
+      );
+      const nextRollback = `if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${mark2V}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${mark2Tl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${mark2Log}; `;
+      const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, npV);
+      stmts.push(
+        ...nextStmts,
+        `${ind(ctx)}if (!${nextOk}) { ${nextRollback}break }`,
+        `${ind(ctx)}${arrV}.push(${nextVal})`,
+        `${ind(ctx)}${curV} = ${nextEnd}`
+      );
     } else {
       const trivFn = ensureTriviaFn(ctx);
+      const spV = v(ctx, "_sp");
+      stmts.push(`${ind(ctx)}const ${spV} = ${trivFn}(input, ${curV}, _ctx)`);
+      sepAtPos = spV;
+      const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos);
+      stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) break`);
       const npV = v(ctx, "_np");
+      stmts.push(`${ind(ctx)}const ${npV} = ${trivFn}(input, ${sepEnd}, _ctx)`);
+      const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, npV);
       stmts.push(
-        `${ind(ctx)}let ${npV} = ${sepEnd}`,
-        `${ind(ctx)}{ const _trv = ${trivFn}(input, ${npV}, _ctx); if (_trv.ok) ${npV} = _trv.span.end }`
+        ...nextStmts,
+        `${ind(ctx)}if (!${nextOk}) break`,
+        `${ind(ctx)}${arrV}.push(${nextVal})`,
+        `${ind(ctx)}${curV} = ${nextEnd}`
       );
-      nextAtPos = npV;
     }
+  } else {
+    const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos);
+    stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) break`);
+    const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, sepEnd);
+    stmts.push(
+      ...nextStmts,
+      `${ind(ctx)}if (!${nextOk}) break`,
+      `${ind(ctx)}${arrV}.push(${nextVal})`,
+      `${ind(ctx)}${curV} = ${nextEnd}`
+    );
   }
-  const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, nextAtPos);
-  stmts.push(
-    ...nextStmts,
-    `${ind(ctx)}if (!${nextOk}) { ${rollback}break }`,
-    `${ind(ctx)}${arrV}.push(${nextVal})`,
-    `${ind(ctx)}${curV} = ${nextEnd}`
-  );
   ctx.indent--;
   stmts.push(`${ind(ctx)}}`);
   ctx.indent--;
@@ -1623,27 +2379,33 @@ function emitNot(def, ctx, pos) {
   };
 }
 function emitNode(def, ctx, pos) {
-  const fnIdx = ctx.buildFns.length;
-  ctx.buildFns.push(def.build);
-  ctx.buildSrcs.push(def.buildSrc ?? null);
+  const mkType = analyzeMkInlineBuild(def);
+  let buildIdx = null;
+  if (!mkType) {
+    buildIdx = ctx.buildFns.length;
+    ctx.buildFns.push(def.build);
+    ctx.buildSrcs.push(def.buildSrc ?? null);
+  }
   const i = ind(ctx);
   const chV = v(ctx, "_ch");
   const rawV = v(ctx, "_raw");
-  const sc = v(ctx, "_sc"), sl = v(ctx, "_sl"), sr = v(ctx, "_sr"), st = v(ctx, "_st");
+  const tlV = v(ctx, "_tl");
+  const sc = v(ctx, "_sc"), sl = v(ctx, "_sl"), sr = v(ctx, "_sr"), st = v(ctx, "_st"), stl = v(ctx, "_stl");
   const stmts = [
-    `${i}const ${chV} = [], ${rawV} = []`,
-    `${i}const ${sc} = _ctx._cstChildren, ${sl} = _ctx._cstLeaves, ${sr} = _ctx._cstRawChildren, ${st} = _ctx.captureTrivia`,
-    `${i}_ctx._cstChildren = ${chV}; _ctx._cstLeaves = ${chV}; _ctx._cstRawChildren = ${rawV}; _ctx.captureTrivia = true`
+    `${i}const ${chV} = [], ${rawV} = [], ${tlV} = []`,
+    `${i}const ${sc} = _ctx._cstChildren, ${sl} = _ctx._cstLeaves, ${sr} = _ctx._cstRawChildren, ${st} = _ctx.captureTrivia, ${stl} = _ctx._cstTriviaLog`,
+    `${i}_ctx._cstChildren = ${chV}; _ctx._cstLeaves = ${chV}; _ctx._cstRawChildren = ${rawV}; _ctx.captureTrivia = true; _ctx._cstTriviaLog = ${tlV}`
   ];
   const { stmts: innerStmts, okVar, endVar } = emitFallible(def.parser, ctx, pos);
   stmts.push(...innerStmts);
-  stmts.push(`${i}_ctx._cstChildren = ${sc}; _ctx._cstLeaves = ${sl}; _ctx._cstRawChildren = ${sr}; _ctx.captureTrivia = ${st}`);
+  stmts.push(`${i}_ctx._cstChildren = ${sc}; _ctx._cstLeaves = ${sl}; _ctx._cstRawChildren = ${sr}; _ctx.captureTrivia = ${st}; _ctx._cstTriviaLog = ${stl}`);
   stmts.push(`${i}if (!${okVar}) ${failStmt({ ...ctx, indent: 0 }, '"node"', pos).trim()}`);
+  const stV = v(ctx, "_nst");
+  stmts.push(`${i}const ${stV} = _ctx.state !== undefined ? Object.assign({}, _ctx.state) : undefined`);
   const ndV = v(ctx, "_nd");
+  const ndExpr = mkType ? emitInlineMkNodeExpr(mkType, chV, rawV, pos, endVar, tlV) : `_build[${buildIdx}](${chV}, ${rawV}, { start: ${pos}, end: ${endVar} }, ${tlV}, ${stV})`;
   stmts.push(
-    `${i}const ${ndV} = _build[${fnIdx}](${chV}, ${rawV}, { start: ${pos}, end: ${endVar} })`,
-    // Record into the caller's collectors (the node in children; the node, or a
-    // spanned leaf if build collapsed to a non-node value, in rawChildren).
+    `${i}const ${ndV} = ${ndExpr}`,
     `${i}if (${sc}) ${sc}.push(${ndV})`,
     `${i}if (${sr}) ${sr}.push((typeof ${ndV} === 'object' && ${ndV} !== null && ${ndV}._tag === 'node') ? ${ndV} : { _tag: 'leaf', value: typeof ${ndV} === 'string' ? ${ndV} : '', span: { start: ${pos}, end: ${endVar} } })`
   );
@@ -1677,31 +2439,14 @@ function emitLazy(p, def, ctx, pos) {
     const savedIndent = ctx.indent;
     const savedFailLabel = ctx.failLabel;
     ctx.indent = 1;
-    ctx.failLabel = void 0;
+    ctx.failLabel = "_pfail";
     const r = emit(resolved, ctx, "_pos");
     ctx.indent = savedIndent;
     ctx.failLabel = savedFailLabel;
-    ctx.namedFnDecls.push([
-      `function ${fnName2}(input, _pos, _ctx) {`,
-      ...r.stmts,
-      `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,
-      `}`
-    ].join("\n"));
+    pushNamedFnDecl(ctx, fnName2, r.stmts, r.valueVar, r.endVar);
   }
   const fnName = ctx.namedParsers.get(p);
-  const rv = v(ctx, "_pfr");
-  const vv = v(ctx, "_pfv");
-  const ev = v(ctx, "_pfe");
-  return {
-    stmts: [
-      `${ind(ctx)}const ${rv} = ${fnName}(input, ${pos}, _ctx)`,
-      `${ind(ctx)}if (!${rv}.ok) ${failStmt({ ...ctx, indent: 0 }, '"parser"', pos).trim()}`,
-      `${ind(ctx)}const ${vv} = ${rv}.value`,
-      `${ind(ctx)}const ${ev} = ${rv}.span.end`
-    ],
-    valueVar: vv,
-    endVar: ev
-  };
+  return emitNamedFnCall(ctx, fnName, pos, '"parser"');
 }
 function emitRecover(def, ctx, pos) {
   const { stmts: innerStmts, okVar, valVar, endVar } = emitFallible(def.parser, ctx, pos);
@@ -1737,6 +2482,8 @@ function emit(p, ctx, pos) {
       return emitLit(def, ctx, pos);
     case "regex":
       return emitRegex(def, ctx, pos);
+    case "keywords":
+      return emitKeywords(def, ctx, pos);
     case "sequence":
       return emitSeq(def, ctx, pos);
     case "choice":
@@ -1749,7 +2496,31 @@ function emit(p, ctx, pos) {
     case "sepBy":
       return emitSepBy(p, def, ctx, pos);
     case "transform": {
+      const fnSrc = transformFnSource(def.fn, def.fnSrc);
+      if (fnSrc && def.parser._def.tag === "sequence") {
+        const seqR = emitSeqValues(def.parser._def, ctx, pos);
+        const inlined = tryInlineDestructureTransform(fnSrc, seqR.valueVars);
+        if (inlined) {
+          const mv2 = v(ctx, "_mapped");
+          return {
+            stmts: [...seqR.stmts, `${ind(ctx)}const ${mv2} = ${inlined}`],
+            valueVar: mv2,
+            endVar: seqR.endVar
+          };
+        }
+      }
       const inner = emit(def.parser, ctx, pos);
+      if (fnSrc) {
+        const unary = tryInlineUnaryTransform(fnSrc, inner.valueVar);
+        if (unary) {
+          const mv2 = v(ctx, "_mapped");
+          return {
+            stmts: [...inner.stmts, `${ind(ctx)}const ${mv2} = ${unary}`],
+            valueVar: mv2,
+            endVar: inner.endVar
+          };
+        }
+      }
       const fnIdx = ctx.mapFns.length;
       ctx.mapFns.push(def.fn);
       ctx.mapFnSrcs.push(def.fnSrc ?? null);
@@ -1785,12 +2556,20 @@ function emit(p, ctx, pos) {
       return emitLazy(p, def, ctx, pos);
     case "trivia":
       return emit(def.parser, ctx, pos);
+    case "label":
+      return emit(def.parser, ctx, pos);
     case "grammar": {
       const savedTrivia = ctx.activeTrivia;
-      if (def.triviaParser) ctx.activeTrivia = def.triviaParser;
+      const savedKindLabels = ctx.triviaKindLabels;
+      if (def.triviaParser) {
+        ctx.activeTrivia = def.triviaParser;
+        if (def.triviaParser._meta.triviaKindLabels) {
+          ctx.triviaKindLabels = def.triviaParser._meta.triviaKindLabels;
+        }
+      }
       const r = emit(def.parser, ctx, pos);
-      if (savedTrivia === void 0) delete ctx.activeTrivia;
-      else ctx.activeTrivia = savedTrivia;
+      ctx.activeTrivia = savedTrivia;
+      ctx.triviaKindLabels = savedKindLabels;
       return r;
     }
     case "not":
@@ -1825,27 +2604,22 @@ function emit(p, ctx, pos) {
         const savedIndent = ctx.indent;
         const savedFailLabel = ctx.failLabel;
         ctx.indent = 1;
-        ctx.failLabel = void 0;
+        ctx.failLabel = "_pfail";
         const innerR = emit(innerParser, ctx, "_pos");
         ctx.indent = savedIndent;
         ctx.failLabel = savedFailLabel;
-        ctx.namedFnDecls.push([
-          `function ${fnName}(input, _pos, _ctx) {`,
-          ...innerR.stmts,
-          `  return { ok: true, value: ${innerR.valueVar}, span: { start: _pos, end: ${innerR.endVar} } }`,
-          `}`
-        ].join("\n"));
+        pushNamedFnDecl(ctx, fnName, innerR.stmts, innerR.valueVar, innerR.endVar);
       }
       const fn = ctx.namedParsers.get(innerParser);
       const rv = v(ctx, "_wcr");
-      const vv = v(ctx);
+      const vv = v(ctx, "_wcv");
       const ev = v(ctx, "_wce");
       return {
         stmts: [
-          `${ind(ctx)}const ${rv} = ${fn}(input, ${pos}, { ..._ctx, state: _mf[${evIdx}]() })`,
-          `${ind(ctx)}if (!${rv}.ok) ${failStmt({ ...ctx, indent: 0 }, '"withCtx"', pos).trim()}`,
-          `${ind(ctx)}const ${vv} = ${rv}.value`,
-          `${ind(ctx)}const ${ev} = ${rv}.span.end`
+          `${ind(ctx)}const ${rv} = { ..._ctx, state: _mf[${evIdx}]() }`,
+          `${ind(ctx)}const ${vv} = ${fn}(input, ${pos}, ${rv})`,
+          `${ind(ctx)}if (${vv} === ${NAMED_FN_FAIL}) ${failStmt({ ...ctx, indent: 0 }, '"withCtx"', pos).trim()}`,
+          `${ind(ctx)}const ${ev} = ${NAMED_FN_END}`
         ],
         valueVar: vv,
         endVar: ev
@@ -1871,6 +2645,7 @@ function hasNodeDef(p, seen = /* @__PURE__ */ new Set()) {
     }
     case "grammar":
     case "trivia":
+    case "label":
     case "optional":
     case "many":
     case "oneOrMore":
@@ -1894,7 +2669,7 @@ function hasNodeDef(p, seen = /* @__PURE__ */ new Set()) {
       return false;
   }
 }
-function compile(parser2, mapFnSources) {
+function compile(combinator, mapFnSources) {
   const ctx = {
     vars: 0,
     indent: 1,
@@ -1908,15 +2683,18 @@ function compile(parser2, mapFnSources) {
     needsCollator: false,
     namedParsers: /* @__PURE__ */ new Map(),
     triviaCaptureNames: /* @__PURE__ */ new Map(),
+    triviaFnNames: /* @__PURE__ */ new Map(),
     namedFnDecls: [],
-    capturing: hasNodeDef(parser2)
+    capturing: hasNodeDef(combinator)
   };
-  const r = emit(parser2, ctx, "_pos");
+  const r = emit(combinator, ctx, "_pos");
   const collatorDecl = ctx.needsCollator ? `const _collator = new Intl.Collator(undefined, { sensitivity: 'accent' })
 ` : "";
+  const namedPrelude = ctx.namedFnDecls.length > 0 ? [...namedFnPrelude(), ""] : [];
   const source = [
     ...ctx.regexDecls,
     "",
+    ...namedPrelude,
     ...ctx.namedFnDecls,
     `${collatorDecl}function _parse(input, _pos, _rp, _mf, _build, _ctx) {`,
     `  let pos = _pos`,
@@ -1927,12 +2705,16 @@ function compile(parser2, mapFnSources) {
   const fn = new Function("input", "_pos", "_rp", "_mf", "_build", "_ctx", [
     ...ctx.regexDecls,
     collatorDecl,
+    ...namedPrelude,
     ...ctx.namedFnDecls,
     `let pos = _pos`,
     ...r.stmts,
     `return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`
   ].join("\n"));
-  const defaultCtx = { trackLines: false };
+  const defaultCtx = {
+    trackLines: false,
+    ...ctx.triviaKindLabels ? { triviaKindLabels: ctx.triviaKindLabels } : {}
+  };
   const derivedSrcs = ctx.mapFnSrcs.length === ctx.mapFns.length && ctx.mapFnSrcs.every((s) => s !== null) ? ctx.mapFnSrcs : void 0;
   const effectiveSources = mapFnSources ?? derivedSrcs;
   const buildCovered = ctx.buildFns.length === 0 || ctx.buildSrcs.every((s) => s !== null);
@@ -1946,6 +2728,9 @@ function compile(parser2, mapFnSources) {
     parse(input, pos = 0) {
       return fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, defaultCtx);
     },
+    parseWithContext(input, parseCtx, pos = 0) {
+      return fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, parseCtx);
+    },
     parseWithErrors(input, pos = 0) {
       const errors = [];
       const result = fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, { ...defaultCtx, _errors: errors });
@@ -1968,12 +2753,14 @@ function buildInlineExpression(ctx, r, collatorDecl, mapFnSources, buildSources)
   const buildDecl = buildSources?.length ? `  const _build = [${buildSources.join(", ")}]` : "";
   const needsWrapper = ctx.regexDecls.length > 0 || !!collatorDecl || ctx.namedFnDecls.length > 0 || !!mfDecl || !!buildDecl;
   if (!needsWrapper) return innerFn;
+  const namedPrelude = ctx.namedFnDecls.length > 0 ? namedFnPrelude() : [];
   return [
     `/* @__PURE__ */ (() => {`,
     ...ctx.regexDecls.map((d) => `  ${d}`),
     collatorDecl ? `  ${collatorDecl.trim()}` : "",
     mfDecl,
     buildDecl,
+    ...namedPrelude.map((l) => `  ${l}`),
     ...ctx.namedFnDecls.flatMap((f) => f.split("\n").map((l) => `  ${l}`)),
     `  return ${innerFn}`,
     `})()`
@@ -2000,24 +2787,24 @@ function guard(predicate) {
 }
 
 // src/combinators/withCtx.ts
-function withCtx(extra, parser2) {
+function withCtx(extra, combinator) {
   const meta = {
-    firstSet: parser2._meta.firstSet,
-    canMatchNewline: parser2._meta.canMatchNewline,
+    firstSet: combinator._meta.firstSet,
+    canMatchNewline: combinator._meta.canMatchNewline,
     isTrivia: false
   };
   return {
     _tag: "withCtx",
     _meta: meta,
-    _def: { tag: "withCtx", extra, parser: parser2 },
+    _def: { tag: "withCtx", extra, parser: combinator },
     parse(input, pos, ctx) {
-      return parser2.parse(input, pos, { ...ctx, state: extra });
+      return combinator.parse(input, pos, { ...ctx, state: extra });
     }
   };
 }
 
 // src/combinators/recover.ts
-function recover(parser2, sentinel) {
+function recover(combinator, sentinel) {
   const meta = {
     firstSet: { kind: "any" },
     canMatchNewline: true,
@@ -2026,9 +2813,9 @@ function recover(parser2, sentinel) {
   return {
     _tag: "recover",
     _meta: meta,
-    _def: { tag: "recover", parser: parser2, sentinel },
+    _def: { tag: "recover", parser: combinator, sentinel },
     parse(input, pos, ctx) {
-      const result = parser2.parse(input, pos, ctx);
+      const result = combinator.parse(input, pos, ctx);
       if (result.ok) return result;
       let scanPos = pos;
       while (scanPos < input.length) {
@@ -2050,10 +2837,10 @@ function isParseError(value) {
 }
 
 // src/combinators/completions.ts
-function completionsAt(parser2, input, offset) {
+function completionsAt(combinator, input, offset) {
   const probe = { offset, best: null };
   const ctx = { trackLines: false, _probe: probe };
-  const result = parser2.parse(input.slice(0, offset), 0, ctx);
+  const result = combinator.parse(input.slice(0, offset), 0, ctx);
   if (result.ok) return [];
   const best = deeperFail(probe.best, result);
   return best?.expected ?? [];
@@ -2079,10 +2866,9 @@ function scanTo(sentinel, { skip: skip2 = [], orEOF = false } = {}) {
       let cur = pos;
       const probeCtx = { trackLines: ctx.trackLines, state: ctx.state };
       const emit2 = (end) => {
-        if (end > pos && (ctx._cstLeaves || ctx._cstRawChildren)) {
+        if (end > pos && cstCaptureActive(ctx)) {
           const leaf = { _tag: "leaf", value: input.slice(pos, end), span: { start: pos, end } };
-          if (ctx._cstLeaves) ctx._cstLeaves.push(leaf);
-          if (ctx._cstRawChildren) ctx._cstRawChildren.push(leaf);
+          pushCstLeaf(ctx, leaf);
         }
       };
       while (cur < input.length) {
@@ -2124,7 +2910,7 @@ function balanced(open, close, options = {}) {
   return combi;
 }
 
-// src/cst/incremental.ts
+// src/functional/doc.ts
 function isNode(x) {
   return typeof x === "object" && x !== null && x._tag === "node";
 }
@@ -2133,7 +2919,8 @@ function findContaining(node2, pos, path = []) {
     const child = node2.children[i];
     if (!isNode(child)) continue;
     if (child.span.start <= pos && pos < child.span.end) {
-      return findContaining(child, pos, [...path, i]) ?? { node: child, path: [...path, i] };
+      const inner = findContaining(child, pos, [...path, i]);
+      return inner ?? { node: child, path: [...path, i] };
     }
   }
   return null;
@@ -2149,249 +2936,11 @@ function ancestorsAt(root, path) {
   }
   return ancestors;
 }
-function replaceAtPath(grammar, root, path, newNode) {
-  if (path.length === 0) return newNode;
-  const [idx, ...rest] = path;
-  const newChildren = [...root.children];
-  newChildren[idx] = rest.length === 0 ? newNode : replaceAtPath(grammar, root.children[idx], rest, newNode);
-  return grammar.rebuild(root, newChildren);
-}
-var ParseDocImpl = class _ParseDocImpl {
-  _parser;
-  _ruleName;
-  _trivia;
-  _captureTrivia;
-  tree;
-  errors;
-  input;
-  /** Offset reached by the top-level rule. < input.length means input was left unconsumed. */
-  consumedEnd;
-  constructor(parser2, ruleName, tree, errors, input, trivia2, captureTrivia, consumedEnd = 0) {
-    this._parser = parser2;
-    this._ruleName = ruleName;
-    this._trivia = trivia2;
-    this._captureTrivia = captureTrivia;
-    this.tree = tree;
-    this.errors = errors;
-    this.input = input;
-    this.consumedEnd = consumedEnd;
-  }
-  edit(from, to, replacement) {
-    const newInput = this.input.slice(0, from) + replacement + this.input.slice(to);
-    if (!this.tree) return makeParseDoc(this._parser, this._ruleName, newInput, this._trivia, this._captureTrivia);
-    const delta = replacement.length - (to - from);
-    const found = findContaining(this.tree, from);
-    if (!found) return makeParseDoc(this._parser, this._ruleName, newInput, this._trivia, this._captureTrivia);
-    const ancestors = ancestorsAt(this.tree, found.path);
-    const candidates = [found];
-    const pathCopy = [...found.path];
-    for (let i = ancestors.length - 2; i >= 0; i--) {
-      pathCopy.pop();
-      candidates.push({ node: ancestors[i + 1], path: [...pathCopy] });
-    }
-    for (const candidate of candidates) {
-      const { node: node2, path } = candidate;
-      const expectedEnd = node2.span.end + delta;
-      const parser2 = this._parser.rule(node2.type);
-      const ctx = { trackLines: false, state: node2.state, ...this._trivia !== void 0 ? { trivia: this._trivia } : {}, ...this._captureTrivia ? { captureTrivia: true } : {} };
-      const r = parser2.parse(newInput, node2.span.start, ctx);
-      if (!r.ok) continue;
-      if (r.span.end === expectedEnd) {
-        const newTree = replaceAtPath(this._parser, this.tree, path, r.value);
-        return new _ParseDocImpl(this._parser, this._ruleName, newTree, [], newInput, this._trivia, this._captureTrivia);
-      }
-    }
-    return makeParseDoc(this._parser, this._ruleName, newInput, this._trivia, this._captureTrivia);
-  }
-};
-function makeParseDoc(parser2, ruleName, input, trivia2, captureTrivia, triviaLog) {
-  const ctx = {
-    trackLines: false,
-    ...trivia2 !== void 0 ? { trivia: trivia2 } : {},
-    ...captureTrivia ? { captureTrivia: true } : {},
-    ...triviaLog !== void 0 ? { _triviaLog: triviaLog } : {}
-  };
-  const r = parser2.rule(ruleName).parse(input, 0, ctx);
-  if (r.ok) {
-    return new ParseDocImpl(parser2, ruleName, r.value, [], input, trivia2, captureTrivia, r.span.end);
-  }
-  return new ParseDocImpl(parser2, ruleName, null, [{ ok: false, expected: r.expected, span: r.span }], input, trivia2, captureTrivia, r.span.start);
-}
-
-// src/cst/grammar.ts
-var Parser = class {
-  _built = false;
-  /** Set in a subclass to enable automatic trivia skipping between sequence terms. */
-  _trivia;
-  /**
-   * Set in a subclass to make the rule name optional in `parse()`.
-   * When defined, `parse(input)` is equivalent to `parse(defaultRule, input)`.
-   */
-  _defaultRule;
-  /**
-   * Set `true` in a subclass to record trivia (whitespace/comments) consumed
-   * between terms into each node's rawChildren as separate CSTTrivia tokens.
-   * Requires `_trivia` to be set. Default: trivia is skipped without recording.
-   */
-  _captureTrivia;
-  /**
-   * When set, makeParseDoc injects this array as ctx._triviaLog so each
-   * scanTrivia.commit() pushes [runStart, runEnd] pairs into it.
-   * Reset to [] before each parse() call in any subclass that uses it.
-   */
-  _triviaLog;
-  /**
-   * Optional map of public entry-point aliases → actual rule names. Lets callers
-   * `parse('value', src)` when the grammar's rule is `ValueList`, removing
-   * per-adapter name-translation tables.
-   */
-  _aliases;
-  /** Resolve an alias to its target rule name (identity if not aliased). */
-  _resolveRule(name) {
-    return this._aliases?.[name] ?? name;
-  }
-  _build() {
-    if (this._built) return;
-    this._built = true;
-    const keys = Object.keys(this).filter((k) => !k.startsWith("_"));
-    const slots = /* @__PURE__ */ new Map();
-    const g = {};
-    for (const key of keys) {
-      const val = this[key];
-      if (isCombinator(val)) {
-        const isRule = /^[A-Z]/.test(key);
-        const final = isRule ? this._makeNodeParser(key, val) : val;
-        g[key] = final;
-        Object.defineProperty(this, key, { value: final, writable: false, configurable: false });
-      } else if (typeof val === "function") {
-        const slot = ref();
-        slots.set(key, slot);
-        g[key] = slot;
-      }
-    }
-    for (const [key, slot] of slots) {
-      const thunk = this[key];
-      const inner = thunk(g);
-      const isRule = /^[A-Z]/.test(key);
-      const final = isRule ? this._makeNodeParser(key, inner) : inner;
-      slot.define(final);
-      slot._meta.firstSet = final._meta.firstSet;
-      slot._meta.canMatchNewline = final._meta.canMatchNewline;
-      Object.defineProperty(this, key, { value: final, writable: false, configurable: false });
-    }
-  }
-  /**
-   * Override to produce a custom AST node instead of a plain CSTNode.
-   * The returned object must satisfy NodeLike for IncrementalParser to work.
-   *
-   * `rawChildren` is `children` plus any trivia tokens (whitespace/comments)
-   * consumed between terms, in parse order. Use it to inspect trivia when the
-   * grammar is whitespace-sensitive (e.g. CSS descendant vs adjacent combinators).
-   * The default implementation ignores `rawChildren`.
-   */
-  buildNode(type, span, children, state, _rawChildren) {
-    return { _tag: "node", type, span, children, state };
-  }
-  /** Wrap an inner combinator so it produces a CSTNode on each match. */
-  _makeNodeParser(type, inner) {
-    const self = this;
-    const meta = {
-      firstSet: inner._meta.firstSet,
-      canMatchNewline: inner._meta.canMatchNewline,
-      isTrivia: false
-    };
-    return {
-      _tag: "cstNode",
-      _meta: meta,
-      _def: { tag: "unknown" },
-      parse(input, pos, ctx) {
-        const state = ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
-        const children = [];
-        const rawChildren = [];
-        const innerCtx = {
-          ...ctx,
-          _cstChildren: children,
-          _cstLeaves: children,
-          _cstRawChildren: rawChildren
-        };
-        const r = inner.parse(input, pos, innerCtx);
-        if (!r.ok) return r;
-        const node2 = self.buildNode(type, r.span, children, state, rawChildren);
-        const isNodeLike = typeof node2 === "object" && node2 !== null && node2._tag === "node";
-        if (ctx._cstChildren) ctx._cstChildren.push(node2);
-        if (ctx._cstRawChildren) ctx._cstRawChildren.push(
-          isNodeLike ? node2 : { _tag: "leaf", value: typeof node2 === "string" ? node2 : "", span: r.span }
-        );
-        return { ok: true, value: node2, span: r.span };
-      }
-    };
-  }
-  /** Reconstruct a node with a new children array (used by IncrementalParser). */
-  rebuild(node2, newChildren) {
-    return this.buildNode(node2.type, node2.span, newChildren, node2.state, []);
-  }
-  parse(ruleNameOrInput, input) {
-    let ruleName;
-    let src;
-    if (input === void 0) {
-      if (this._defaultRule === void 0) {
-        throw new Error("parse(input) requires a _defaultRule to be set on the grammar");
-      }
-      ruleName = this._defaultRule;
-      src = ruleNameOrInput;
-    } else {
-      ruleName = ruleNameOrInput;
-      src = input;
-    }
-    return makeParseDoc(this, this._resolveRule(ruleName), src, this._trivia, this._captureTrivia, this._triviaLog);
-  }
-  /**
-   * Get the compiled Combinator for a named rule.
-   * Triggers lazy initialization on first call.
-   */
-  rule(name) {
-    this._build();
-    const resolved = this._resolveRule(name);
-    const p = this[resolved];
-    if (!p) throw new Error(`No rule '${String(name)}' on this parser`);
-    return p;
-  }
-};
-function isCombinator(val) {
-  return val !== null && typeof val === "object" && "_tag" in val;
-}
-
-// src/functional/doc.ts
-function isNode2(x) {
-  return typeof x === "object" && x !== null && x._tag === "node";
-}
-function findContaining2(node2, pos, path = []) {
-  for (let i = 0; i < node2.children.length; i++) {
-    const child = node2.children[i];
-    if (!isNode2(child)) continue;
-    if (child.span.start <= pos && pos < child.span.end) {
-      const inner = findContaining2(child, pos, [...path, i]);
-      return inner ?? { node: child, path: [...path, i] };
-    }
-  }
-  return null;
-}
-function ancestorsAt2(root, path) {
-  const ancestors = [root];
-  let cur = root;
-  for (const idx of path.slice(0, -1)) {
-    const child = cur.children[idx];
-    if (!child || !isNode2(child)) break;
-    ancestors.push(child);
-    cur = child;
-  }
-  return ancestors;
-}
-function replaceAtPath2(rebuild, root, path, newNode) {
+function replaceAtPath(rebuild, root, path, newNode) {
   if (path.length === 0) return newNode;
   const [idx, ...rest] = path;
   const newChildren = [...root.children];
-  newChildren[idx] = rest.length === 0 ? newNode : replaceAtPath2(rebuild, root.children[idx], rest, newNode);
+  newChildren[idx] = rest.length === 0 ? newNode : replaceAtPath(rebuild, root.children[idx], rest, newNode);
   return rebuild(root, newChildren);
 }
 function defaultRebuild(node2, children) {
@@ -2417,9 +2966,9 @@ var FunctionalDocImpl = class _FunctionalDocImpl {
     const reparse = () => makeFunctionalDoc(this._registry, this._rootRule, newInput, this._opts);
     if (!this.tree) return reparse();
     const delta = replacement.length - (to - from);
-    const found = findContaining2(this.tree, from);
+    const found = findContaining(this.tree, from);
     if (!found) return reparse();
-    const ancestors = ancestorsAt2(this.tree, found.path);
+    const ancestors = ancestorsAt(this.tree, found.path);
     const candidates = [found];
     const pathCopy = [...found.path];
     for (let i = ancestors.length - 2; i >= 0; i--) {
@@ -2434,7 +2983,7 @@ var FunctionalDocImpl = class _FunctionalDocImpl {
       const r = ruleFn(newInput, node2.span.start, ctx);
       if (!r.ok) continue;
       if (r.span.end === node2.span.end + delta) {
-        const newTree = replaceAtPath2(rebuild, this.tree, path, r.value);
+        const newTree = replaceAtPath(rebuild, this.tree, path, r.value);
         return new _FunctionalDocImpl(this._registry, this._rootRule, this._opts, newTree, [], newInput);
       }
     }
@@ -2453,59 +3002,52 @@ function makeFunctionalDoc(registry, rootRule, input, opts = {}) {
 }
 
 // src/cst/trivia-index.ts
-function spanOf(c) {
-  const s = c.span;
-  return s && typeof s.start === "number" ? s : void 0;
-}
 function merge(map, key, run) {
   if (run.length === 0) return;
   const existing = map.get(key);
   if (existing) existing.push(...run);
   else map.set(key, [...run]);
 }
-function buildTriviaIndex(root, opts) {
+function buildTriviaIndex(root, input = "", opts) {
   const before = /* @__PURE__ */ new Map();
   const after = /* @__PURE__ */ new Map();
   const visit = (node2) => {
-    const raw = node2.children;
-    if (!raw) return;
-    let prevEnd;
-    let i = 0;
-    while (i < raw.length) {
-      const c = raw[i];
-      if (c._tag === "trivia") {
-        const run = [];
-        while (i < raw.length && raw[i]._tag === "trivia") {
-          const t = raw[i];
-          const sp2 = spanOf(t);
-          if (sp2 && sp2.end > sp2.start) run.push({ value: t.value ?? "", span: sp2 });
-          i++;
+    const log = node2.triviaLog;
+    const raw = node2.rawChildren;
+    if (log && log.length && raw) {
+      for (let i = 0; i < log.length; i += 3) {
+        const tStart = log[i], tEnd = log[i + 1], insertIdx = log[i + 2];
+        if (tEnd <= tStart) continue;
+        const run = [{ value: input.slice(tStart, tEnd), span: { start: tStart, end: tEnd } }];
+        const next = raw[insertIdx];
+        if (next) merge(before, next.span.start, run);
+        const prev = insertIdx > 0 ? raw[insertIdx - 1] : void 0;
+        if (prev) merge(after, prev.span.end, run);
+      }
+    }
+    const ch = node2.children;
+    if (ch) {
+      for (const c of ch) {
+        if (typeof c === "object" && c !== null && c.children !== void 0) {
+          visit(c);
         }
-        const next = i < raw.length ? spanOf(raw[i]) : void 0;
-        if (next) merge(before, next.start, run);
-        if (prevEnd !== void 0) merge(after, prevEnd, run);
-        continue;
       }
-      const sp = spanOf(c);
-      if (sp) prevEnd = sp.end;
-      if (c._tag === "node") visit(c);
-      i++;
     }
   };
-  if (root && typeof root === "object") visit(root);
-  if (opts) {
-    const rootSpan = spanOf(root);
+  if (root) visit(root);
+  if (opts && input) {
+    const rootSpan = root?.span;
     const re = new RegExp(opts.trivia.source, opts.trivia.flags.replace(/[gy]/g, "") + "y");
     const scanFrom = (from) => {
       const run = [];
       let pos = from;
       re.lastIndex = pos;
-      let m = re.exec(opts.input);
+      let m = re.exec(input);
       while (m && m.index === pos && m[0].length > 0) {
         run.push({ value: m[0], span: { start: pos, end: pos + m[0].length } });
         pos += m[0].length;
         re.lastIndex = pos;
-        m = re.exec(opts.input);
+        m = re.exec(input);
       }
       return run;
     };
@@ -2514,7 +3056,7 @@ function buildTriviaIndex(root, opts) {
       if (lead.length) merge(before, rootSpan.start, lead);
     }
     const end = rootSpan ? rootSpan.end : 0;
-    if (end < opts.input.length) {
+    if (end < input.length) {
       const trail = scanFrom(end);
       if (trail.length) {
         merge(after, end, trail);
@@ -2524,4 +3066,38 @@ function buildTriviaIndex(root, opts) {
   }
   return { before, after };
 }
+
+// src/cst/trivia-entries.ts
+function entryOffset(i, stride) {
+  return i * stride;
+}
+function triviaEntries(log, labels, opts) {
+  const baseStride = opts?.nodeLog ? 3 : 2;
+  const stride = labels ? baseStride + 1 : baseStride;
+  const length = Math.floor(log.length / stride);
+  return {
+    length,
+    labels,
+    stride,
+    start(i) {
+      return log[entryOffset(i, stride)];
+    },
+    end(i) {
+      return log[entryOffset(i, stride) + 1];
+    },
+    kindIndex(i) {
+      if (!labels) return void 0;
+      return log[entryOffset(i, stride) + baseStride];
+    },
+    kind(i) {
+      const ki = labels ? log[entryOffset(i, stride) + baseStride] : void 0;
+      return ki !== void 0 ? labels[ki] : void 0;
+    },
+    text(i, input) {
+      const s = log[entryOffset(i, stride)];
+      const e = log[entryOffset(i, stride) + 1];
+      return input.slice(s, e);
+    }
+  };
+}
 //# sourceMappingURL=index.cjs.map