parseman 0.4.0 → 0.6.0

package/dist/plugin/index.cjs

@@ -128,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() {
@@ -167,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);
@@ -310,109 +454,60 @@ 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/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
-  };
+// src/combinators/keywords.ts
+function word(str, boundary = "_0-9A-Za-z") {
+  return keywords([str], { boundary });
+}
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function keywords(words, opts = {}) {
+  const sorted = [...new Set(words)].sort((a, b) => b.length - a.length);
+  const alt = sorted.map(escapeRe).join("|");
+  const boundary = opts.boundary ? `(?![${opts.boundary}])` : "";
+  const flags = opts.caseInsensitive ? "iuy" : "uy";
+  const re = new RegExp(`(?:${alt})${boundary}`, flags);
+  let firstSet = empty();
+  for (const w of sorted) {
+    if (w.length === 0) continue;
+    const cp = w.codePointAt(0);
+    firstSet = union(firstSet, fromChar(cp));
+    if (opts.caseInsensitive) {
+      const u = String.fromCodePoint(cp).toUpperCase().codePointAt(0);
+      const l = String.fromCodePoint(cp).toLowerCase().codePointAt(0);
+      if (u !== void 0) firstSet = union(firstSet, fromChar(u));
+      if (l !== void 0) firstSet = union(firstSet, fromChar(l));
+    }
+  }
+  const meta = { firstSet, canMatchNewline: false, isTrivia: false };
   return {
-    _tag: "sequence",
+    _tag: "keywords",
     _meta: meta,
-    _def: { tag: "sequence", parsers },
+    _def: { tag: "keywords", words: sorted, caseInsensitive: opts.caseInsensitive ?? false, boundary: opts.boundary },
     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;
+      re.lastIndex = pos;
+      const m = re.exec(input);
+      if (m === null || m.index !== pos) {
+        return failAt(ctx, ["keyword"], pos);
       }
-      return {
-        ok: true,
-        value: values,
-        span: { start: pos, end: cur }
-      };
+      const value = m[0];
+      const span = { start: pos, end: pos + value.length };
+      const leaf = { _tag: "leaf", value, span };
+      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, leaf);
+      return { ok: true, value, span };
     }
   };
 }
 
 // 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));
@@ -496,19 +591,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;
@@ -587,6 +682,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) {
@@ -640,46 +736,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;
@@ -688,23 +1013,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;
@@ -713,45 +1038,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;
       }
@@ -761,7 +1112,7 @@ function sepBy(parser2, separator) {
 }
 
 // src/combinators/not.ts
-function not(parser2) {
+function not(combinator) {
   const meta = {
     firstSet: any(),
     // we don't know what NOT matches
@@ -771,11 +1122,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 } };
     }
@@ -783,37 +1134,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 };
     }
@@ -821,24 +1162,37 @@ 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) };
     }
   };
 }
-function trivia(parser2) {
+function trivia(combinator) {
+  const kindLabels = analyzeLabeledTrivia(combinator)?.labels;
+  return {
+    _tag: combinator._tag,
+    _meta: {
+      ...combinator._meta,
+      isTrivia: true,
+      ...kindLabels ? { triviaKindLabels: kindLabels } : {}
+    },
+    _def: { tag: "trivia", parser: combinator },
+    parse: combinator.parse.bind(combinator)
+  };
+}
+function label(name, combinator) {
   return {
-    _tag: parser2._tag,
-    _meta: { ...parser2._meta, isTrivia: true },
-    _def: { tag: "trivia", parser: parser2 },
-    parse: parser2.parse.bind(parser2)
+    _tag: combinator._tag,
+    _meta: combinator._meta,
+    _def: { tag: "label", label: name, parser: combinator },
+    parse: combinator.parse.bind(combinator)
   };
 }
 
@@ -889,7 +1243,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);
@@ -902,6 +1259,320 @@ function parser(opts, root) {
   };
 }
 
+// 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++}`;
@@ -909,12 +1580,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) {`,
@@ -924,35 +1625,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} } }`;
@@ -968,14 +1718,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`;
@@ -1041,6 +1783,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}`;
@@ -1063,31 +1832,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 = [
@@ -1099,23 +1844,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 ${tmp} = ${trivFn}(input, ${curV}, _ctx)`,
-          `${ind(ctx)}if (${tmp}.ok) ${curV} = ${tmp}.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 ${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 ${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(
@@ -1166,29 +1929,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");
@@ -1202,10 +1975,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)}}`);
   }
@@ -1213,67 +1991,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) {
@@ -1326,27 +2103,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}`
   );
@@ -1383,55 +2161,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--;
@@ -1493,27 +2286,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} } })`
   );
@@ -1547,31 +2346,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);
@@ -1607,6 +2389,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":
@@ -1619,7 +2403,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);
@@ -1655,12 +2463,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":
@@ -1695,27 +2511,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
@@ -1741,6 +2552,7 @@ function hasNodeDef(p, seen = /* @__PURE__ */ new Set()) {
     }
     case "grammar":
     case "trivia":
+    case "label":
     case "optional":
     case "many":
     case "oneOrMore":
@@ -1764,7 +2576,7 @@ function hasNodeDef(p, seen = /* @__PURE__ */ new Set()) {
       return false;
   }
 }
-function compile(parser2, mapFnSources) {
+function compile(combinator, mapFnSources) {
   const ctx = {
     vars: 0,
     indent: 1,
@@ -1778,15 +2590,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`,
@@ -1797,12 +2612,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);
@@ -1816,6 +2635,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 });
@@ -1838,12 +2660,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}`,
     `})()`
@@ -1865,10 +2689,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) {
@@ -1911,16 +2734,22 @@ function balanced(open, close, options = {}) {
 }
 
 // src/plugin/evaluator.ts
+function isWordFactory(v2) {
+  return !!v2 && typeof v2 === "object" && v2.tag === "wordFactory";
+}
 var SUPPORTED = {
   literal: (...a) => literal(a[0], a[1]),
   regex: (...a) => regex(a[0], a[1]),
+  keywords: (...a) => keywords(a[0], a[1]),
+  word: (...a) => word(a[0], a[1]),
   sequence: (...a) => sequence(...a),
   choice: (...a) => choice(...a),
   many: (...a) => many(a[0]),
   oneOrMore: (...a) => oneOrMore(a[0]),
   optional: (...a) => optional(a[0]),
   sepBy: (...a) => sepBy(a[0], a[1]),
-  trivia: (...a) => trivia(a[0])
+  trivia: (...a) => trivia(a[0]),
+  label: (...a) => label(a[0], a[1])
 };
 function isScopeEntry(v2) {
   return !!v2 && typeof v2 === "object" && "combi" in v2 && "mfSrcs" in v2;
@@ -1942,6 +2771,33 @@ function exprToCombi(node2, scope, code, mfs) {
   if (node2.type === "Identifier") return scopeGet(scope, node2.name, mfs);
   if (node2.type !== "CallExpression") return null;
   const callee = node2.callee;
+  if (callee.type === "CallExpression" && callee.callee.type === "Identifier" && callee.callee.name === "makeWord") {
+    const boundaryArg = callee.arguments[0];
+    const strArg = node2.arguments[0];
+    if (!strArg || strArg.type === "SpreadElement") return null;
+    const boundary = boundaryArg && boundaryArg.type !== "SpreadElement" ? anyValue(boundaryArg, scope, code, mfs) : "_0-9A-Za-z";
+    const str = anyValue(strArg, scope, code, mfs);
+    if (typeof boundary !== "string" || typeof str !== "string") return null;
+    try {
+      return word(str, boundary);
+    } catch {
+      return null;
+    }
+  }
+  if (callee.type === "Identifier") {
+    const factory2 = scope.get(callee.name);
+    if (isWordFactory(factory2)) {
+      const [strArg] = node2.arguments;
+      if (!strArg || strArg.type === "SpreadElement") return null;
+      const str = anyValue(strArg, scope, code, mfs);
+      if (typeof str !== "string") return null;
+      try {
+        return word(str, factory2.boundary);
+      } catch {
+        return null;
+      }
+    }
+  }
   if (callee.type !== "Identifier") return null;
   if (callee.name === "transform" && code !== void 0 && mfs !== void 0) {
     const [parserArg, fnArg] = node2.arguments;
@@ -2118,9 +2974,27 @@ function anyValue(node2, scope, code, mfs) {
     if (!propName) return null;
     return obj[propName] ?? null;
   }
-  if (node2.type === "CallExpression") return exprToCombi(node2, scope, code, mfs);
+  if (node2.type === "CallExpression") {
+    const callee = node2.callee;
+    if (callee.type === "Identifier" && callee.name === "makeWord") {
+      const boundaryArg = node2.arguments[0];
+      const boundary = boundaryArg && boundaryArg.type !== "SpreadElement" ? anyValue(boundaryArg, scope, code, mfs) : "_0-9A-Za-z";
+      if (typeof boundary !== "string") return null;
+      return { tag: "wordFactory", boundary };
+    }
+    return exprToCombi(node2, scope, code, mfs);
+  }
   return null;
 }
+function evaluateWordFactory(node2, scope, code) {
+  if (node2.type !== "CallExpression") return null;
+  const callee = node2.callee;
+  if (callee.type !== "Identifier" || callee.name !== "makeWord") return null;
+  const boundaryArg = node2.arguments[0];
+  const boundary = boundaryArg && boundaryArg.type !== "SpreadElement" ? anyValue(boundaryArg, scope, code) : "_0-9A-Za-z";
+  if (typeof boundary !== "string") return null;
+  return { tag: "wordFactory", boundary };
+}
 function evaluateExpr(node2, scope, code, mapFnSources) {
   return exprToCombi(node2, scope, code, mapFnSources);
 }
@@ -2278,23 +3152,23 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     anyUnresolved = true;
     warnings.push(`${id}:${lineOf(pos)} \u2014 ${msg} (running via the interpreter; add the plugin or simplify the declaration to compile it)`);
   };
-  const compileRulesFactory = (init, label) => {
+  const compileRulesFactory = (init, label2) => {
     const args = init.arguments;
     const factoryArg = args[0];
     if (!factoryArg) {
-      warn(init.start, `${label}: rules() needs a factory argument`);
+      warn(init.start, `${label2}: rules() needs a factory argument`);
       return null;
     }
     const ruleMap = evaluateParserFactory(factoryArg, scope, code, []);
     if (!ruleMap) {
-      warn(init.start, `${label}: rules(...) factory isn't statically evaluable`);
+      warn(init.start, `${label2}: rules(...) factory isn't statically evaluable`);
       return null;
     }
     const entries = [];
     for (const [ruleKey, rule] of ruleMap) {
       const compiled = compile(rule);
       if (compiled.inlineExpression === null) {
-        warn(init.start, `${label}: rule "${ruleKey}" couldn't be inlined`);
+        warn(init.start, `${label2}: rule "${ruleKey}" couldn't be inlined`);
         return null;
       }
       entries.push([ruleKey, compiled.inlineExpression]);
@@ -2338,6 +3212,12 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
         const mapFnSources = [];
         const parser2 = evaluateExpr(init, scope, code, mapFnSources);
         if (parser2 === null) {
+          const wordFactory = evaluateWordFactory(init, scope, code);
+          if (wordFactory) {
+            ;
+            scope.set(varName, wordFactory);
+            continue;
+          }
           warn(init.start, `"${varName}" references a parseman macro import but isn't a statically-evaluable combinator`);
           continue;
         }