parseman 0.1.7 → 0.3.0

package/dist/index.cjs

@@ -34,12 +34,17 @@ __export(index_exports, {
   annotateSpan: () => annotateSpan,
   balanced: () => balanced,
   buildLineIndex: () => buildLineIndex,
+  buildTriviaIndex: () => buildTriviaIndex,
   choice: () => choice,
   compile: () => compile,
+  completionsAt: () => completionsAt,
   guard: () => guard,
   isParseError: () => isParseError,
+  keywords: () => keywords,
   literal: () => literal,
+  makeFunctionalDoc: () => makeFunctionalDoc,
   many: () => many,
+  node: () => node,
   not: () => not,
   offsetToLineCol: () => offsetToLineCol,
   oneOrMore: () => oneOrMore,
@@ -49,6 +54,7 @@ __export(index_exports, {
   recover: () => recover,
   ref: () => ref,
   regex: () => regex,
+  rules: () => rules,
   scanTo: () => scanTo,
   sepBy: () => sepBy,
   sequence: () => sequence,
@@ -104,6 +110,21 @@ function mergeRanges(ranges) {
   return out;
 }
 
+// src/combinators/probe.ts
+function failAt(ctx, expected, pos) {
+  const r = { ok: false, expected, span: { start: pos, end: pos } };
+  const probe = ctx._probe;
+  if (probe !== void 0 && pos <= probe.offset) {
+    const best = probe.best;
+    if (best === null || pos > best.span.start) {
+      probe.best = r;
+    } else if (pos === best.span.start) {
+      probe.best = { ...best, expected: [...best.expected, ...expected] };
+    }
+  }
+  return r;
+}
+
 // src/combinators/literal.ts
 var _collatorCache = null;
 function collator() {
@@ -133,21 +154,21 @@ function literal(value, opts = {}) {
     _tag: "literal",
     _meta: meta,
     _def: { tag: "literal", value, caseInsensitive },
-    parse(input, pos, _ctx) {
+    parse(input, pos, ctx) {
       const end = pos + value.length;
       if (end > input.length) {
-        return { ok: false, expected: [JSON.stringify(value)], span: { start: pos, end: pos } };
+        return failAt(ctx, [JSON.stringify(value)], pos);
       }
       const slice = input.slice(pos, end);
       const matched = caseInsensitive ? collator().compare(slice, value) === 0 : slice === value;
       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 (ctx._cstLeaves) ctx._cstLeaves.push(leaf);
+        if (ctx._cstRawChildren) ctx._cstRawChildren.push(leaf);
         return { ok: true, value: slice, span };
       }
-      return { ok: false, expected: [JSON.stringify(value)], span: { start: pos, end: pos } };
+      return failAt(ctx, [JSON.stringify(value)], pos);
     }
   };
 }
@@ -162,38 +183,38 @@ function firstSetFromRegex(pattern) {
     return { firstSet: any(), canMatchNewline: true };
   }
 }
-function canBeEmpty(node) {
-  if (!node) return true;
-  switch (node.type) {
+function canBeEmpty(node2) {
+  if (!node2) return true;
+  switch (node2.type) {
     case "Repetition": {
-      const q = node.quantifier;
+      const q = node2.quantifier;
       return q.kind === "*" || q.kind === "?" || q.kind === "Range" && (q.from ?? 1) === 0;
     }
     case "Alternative": {
-      const exprs = node.expressions;
+      const exprs = node2.expressions;
       return !exprs || exprs.length === 0 || exprs.every((e) => canBeEmpty(e));
     }
     case "Group":
-      return canBeEmpty(node.expression);
+      return canBeEmpty(node2.expression);
     case "Disjunction":
-      return canBeEmpty(node.left) || canBeEmpty(node.right);
+      return canBeEmpty(node2.left) || canBeEmpty(node2.right);
     default:
       return false;
   }
 }
-function extractFirstSet(node) {
-  if (!node) return { firstSet: empty(), canMatchNewline: false };
-  switch (node.type) {
+function extractFirstSet(node2) {
+  if (!node2) return { firstSet: empty(), canMatchNewline: false };
+  switch (node2.type) {
     case "Disjunction": {
-      const left = extractFirstSet(node.left);
-      const right = extractFirstSet(node.right);
+      const left = extractFirstSet(node2.left);
+      const right = extractFirstSet(node2.right);
       return {
         firstSet: union(left.firstSet, right.firstSet),
         canMatchNewline: left.canMatchNewline || right.canMatchNewline
       };
     }
     case "Alternative": {
-      const exprs = node.expressions;
+      const exprs = node2.expressions;
       if (!exprs || exprs.length === 0) return { firstSet: empty(), canMatchNewline: false };
       let fs = empty();
       let canNL = false;
@@ -206,13 +227,13 @@ function extractFirstSet(node) {
       return { firstSet: fs, canMatchNewline: canNL };
     }
     case "Char": {
-      const kind = node.kind;
+      const kind = node2.kind;
       if (kind === "simple") {
-        const code = node.codePoint ?? node.value.codePointAt(0) ?? 0;
+        const code = node2.codePoint ?? node2.value.codePointAt(0) ?? 0;
         return { firstSet: fromRange(code, code), canMatchNewline: code === 10 };
       }
       if (kind === "meta") {
-        const val = node.value;
+        const val = node2.value;
         if (val === ".") return { firstSet: any(), canMatchNewline: false };
         if (val === "d") return { firstSet: fromRange(48, 57), canMatchNewline: false };
         if (val === "D") return { firstSet: any(), canMatchNewline: true };
@@ -229,7 +250,7 @@ function extractFirstSet(node) {
       return { firstSet: any(), canMatchNewline: true };
     }
     case "CharacterClass": {
-      const expressions = node.expressions;
+      const expressions = node2.expressions;
       let fs = empty();
       let canNL = false;
       for (const expr of expressions) {
@@ -244,14 +265,14 @@ function extractFirstSet(node) {
           canNL = canNL || r.canMatchNewline;
         }
       }
-      if (node.negative) return { firstSet: any(), canMatchNewline: true };
+      if (node2.negative) return { firstSet: any(), canMatchNewline: true };
       return { firstSet: fs, canMatchNewline: canNL };
     }
     case "Repetition": {
-      return extractFirstSet(node.expression);
+      return extractFirstSet(node2.expression);
     }
     case "Group": {
-      return extractFirstSet(node.expression);
+      return extractFirstSet(node2.expression);
     }
     default:
       return { firstSet: any(), canMatchNewline: true };
@@ -282,7 +303,7 @@ function regex(pattern, flags = "") {
       anchored.lastIndex = pos;
       const m = anchored.exec(input);
       if (m === null) {
-        return { ok: false, expected: [`/${source}/`], span: { start: pos, end: pos } };
+        return failAt(ctx, [`/${source}/`], pos);
       }
       const span = { start: pos, end: pos + m[0].length };
       const leaf = { _tag: "leaf", value: m[0], span };
@@ -293,6 +314,98 @@ function regex(pattern, flags = "") {
   };
 }
 
+// src/combinators/keywords.ts
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function keywords(words, opts = {}) {
+  const sorted = [...new Set(words)].sort((a, b) => b.length - a.length);
+  const alt = sorted.map(escapeRe).join("|");
+  const boundary = opts.boundary ? `(?![${opts.boundary}])` : "";
+  const flags = opts.caseInsensitive ? "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: "keywords",
+    _meta: meta,
+    _def: { tag: "keywords", words: sorted, caseInsensitive: opts.caseInsensitive ?? false, boundary: opts.boundary },
+    parse(input, pos, ctx) {
+      re.lastIndex = pos;
+      const m = re.exec(input);
+      if (m === null || m.index !== pos) {
+        return failAt(ctx, ["keyword"], pos);
+      }
+      const value = m[0];
+      const span = { start: pos, end: pos + value.length };
+      const leaf = { _tag: "leaf", value, span };
+      if (ctx._cstLeaves) ctx._cstLeaves.push(leaf);
+      if (ctx._cstRawChildren) ctx._cstRawChildren.push(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 = {
@@ -309,12 +422,19 @@ function sequence(...parsers) {
       let cur = pos;
       for (let i = 0; i < parsers.length; i++) {
         if (ctx.trivia && i > 0) {
-          const tr = ctx.trivia.parse(input, cur, { trivia: ctx.trivia, trackLines: ctx.trackLines, user: ctx.user });
-          if (tr.ok) {
-            if (ctx._cstRawChildren && tr.span.end > tr.span.start)
-              ctx._cstRawChildren.push({ _tag: "trivia", value: input.slice(tr.span.start, tr.span.end), span: tr.span });
-            cur = tr.span.end;
+          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;
@@ -415,14 +535,22 @@ function choice(...args) {
         return { ok: false, expected, span: { start: pos, end: pos } };
       }
       for (let i = 0; i < parsers.length; i++) {
-        if (gates[i] && !gates[i](ctx.user)) continue;
+        if (gates[i] && !gates[i](ctx.state)) continue;
+        const leavesLen = ctx._cstLeaves?.length;
+        const rawLen = ctx._cstRawChildren?.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;
           expected.push(...result.expected);
           continue;
         }
         const checks = autoNot[i];
-        if (checks && autoNotFires(input, result.span.end, checks)) continue;
+        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;
+          continue;
+        }
         return result;
       }
       return { ok: false, expected, span: { start: pos, end: pos } };
@@ -553,6 +681,30 @@ function areDisjoint(sets) {
 }
 
 // src/combinators/repeat.ts
+function repItem(parser2, input, cur, ctx) {
+  const raw = ctx._cstRawChildren;
+  const mark = raw ? raw.length : 0;
+  let pos = cur;
+  if (ctx.trivia) {
+    const scan = scanTrivia(input, cur, ctx);
+    scan.commit();
+    pos = scan.end;
+  }
+  if (pos >= input.length) {
+    if (raw) raw.length = mark;
+    return "stop";
+  }
+  const result = parser2.parse(input, pos, ctx);
+  if (!result.ok) {
+    if (raw) raw.length = mark;
+    return { fail: result };
+  }
+  if (result.span.end === pos) {
+    if (raw) raw.length = mark;
+    return "stop";
+  }
+  return { value: result.value, end: result.span.end };
+}
 function many(parser2) {
   const meta = {
     firstSet: parser2._meta.firstSet,
@@ -567,11 +719,10 @@ function many(parser2) {
       const values = [];
       let cur = pos;
       while (cur < input.length) {
-        const result = parser2.parse(input, cur, ctx);
-        if (!result.ok) break;
-        if (result.span.end === cur) break;
-        values.push(result.value);
-        cur = result.span.end;
+        const item = repItem(parser2, input, cur, ctx);
+        if (item === "stop" || "fail" in item) break;
+        values.push(item.value);
+        cur = item.end;
       }
       return { ok: true, value: values, span: { start: pos, end: cur } };
     }
@@ -593,11 +744,10 @@ function oneOrMore(parser2) {
       const values = [first.value];
       let cur = first.span.end;
       while (cur < input.length) {
-        const result = parser2.parse(input, cur, ctx);
-        if (!result.ok) break;
-        if (result.span.end === cur) break;
-        values.push(result.value);
-        cur = result.span.end;
+        const item = repItem(parser2, input, cur, ctx);
+        if (item === "stop" || "fail" in item) break;
+        values.push(item.value);
+        cur = item.end;
       }
       return { ok: true, value: values, span: { start: pos, end: cur } };
     }
@@ -636,26 +786,10 @@ function sepBy(parser2, separator) {
       const values = [first.value];
       let cur = first.span.end;
       while (cur < input.length) {
-        let sepPos = cur;
-        if (ctx.trivia) {
-          const triviaCtx = { trivia: ctx.trivia, trackLines: ctx.trackLines, user: ctx.user };
-          const tr = ctx.trivia.parse(input, sepPos, triviaCtx);
-          if (tr.ok) {
-            if (ctx._cstRawChildren && tr.span.end > tr.span.start) ctx._cstRawChildren.push({ _tag: "trivia", value: input.slice(tr.span.start, tr.span.end), span: tr.span });
-            sepPos = tr.span.end;
-          }
-        }
+        const sepPos = ctx.trivia ? consumeTrivia(input, cur, ctx) : cur;
         const sep = separator.parse(input, sepPos, ctx);
         if (!sep.ok) break;
-        let nextPos = sep.span.end;
-        if (ctx.trivia) {
-          const triviaCtx = { trivia: ctx.trivia, trackLines: ctx.trackLines, user: ctx.user };
-          const tr = ctx.trivia.parse(input, nextPos, triviaCtx);
-          if (tr.ok) {
-            if (ctx._cstRawChildren && tr.span.end > tr.span.start) ctx._cstRawChildren.push({ _tag: "trivia", value: input.slice(tr.span.start, tr.span.end), span: tr.span });
-            nextPos = tr.span.end;
-          }
-        }
+        const nextPos = ctx.trivia ? consumeTrivia(input, sep.span.end, ctx) : sep.span.end;
         const next = parser2.parse(input, nextPos, ctx);
         if (!next.ok) break;
         values.push(next.value);
@@ -697,7 +831,7 @@ function ref() {
 }
 
 // src/combinators/parser.ts
-function parser(factory) {
+function rules(factory) {
   const cache = {};
   const proxy = new Proxy(cache, {
     get(target, key) {
@@ -735,9 +869,9 @@ function not(parser2) {
     isTrivia: false
   };
   return {
-    _tag: "unknown",
+    _tag: "not",
     _meta: meta,
-    _def: { tag: "unknown" },
+    _def: { tag: "not", parser: parser2 },
     parse(input, pos, ctx) {
       const result = parser2.parse(input, pos, ctx);
       if (result.ok) {
@@ -748,6 +882,44 @@ function not(parser2) {
   };
 }
 
+// src/combinators/node.ts
+function node(type, parser2, build) {
+  const meta = {
+    firstSet: parser2._meta.firstSet,
+    canMatchNewline: parser2._meta.canMatchNewline,
+    isTrivia: false
+  };
+  return {
+    _tag: "node",
+    _meta: meta,
+    _def: { tag: "node", type, parser: parser2, 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);
+      if (!r.ok) return r;
+      const built = build(children, rawChildren, r.span);
+      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 }
+        );
+      }
+      return { ok: true, value: built, span: r.span };
+    }
+  };
+}
+
 // src/combinators/map.ts
 function transform(parser2, fn) {
   return {
@@ -816,15 +988,48 @@ function annotateSpan(span, index) {
 }
 
 // src/combinators/grammar.ts
-function parse(parser2, input, opts = {}) {
+function parser(opts, root) {
+  return {
+    _tag: "grammar",
+    _meta: root._meta,
+    _def: {
+      tag: "grammar",
+      parser: root,
+      triviaParser: opts.trivia,
+      trackLines: opts.trackLines ?? false
+    },
+    parse(input, pos, _ctx) {
+      const trackLines = opts.trackLines ?? _ctx?.trackLines ?? false;
+      const ctx = {
+        ..._ctx,
+        trackLines,
+        ...opts.trivia !== void 0 ? { trivia: opts.trivia } : {},
+        ...opts.captureTrivia || _ctx?.captureTrivia ? { captureTrivia: true } : {}
+      };
+      const result = root.parse(input, pos ?? 0, ctx);
+      if (trackLines) {
+        const idx = buildLineIndex(input);
+        return { ...result, span: annotateSpan(result.span, idx) };
+      }
+      return result;
+    }
+  };
+}
+function parse(combinator, input, opts = {}) {
   const trackLines = opts.trackLines ?? false;
-  const ctx = opts.trivia !== void 0 ? { trivia: opts.trivia, trackLines } : { trackLines };
-  const result = parser2.parse(input, 0, ctx);
+  const _errors = opts.recover ? [] : void 0;
+  const ctx = {
+    trackLines,
+    ..._errors !== void 0 ? { _errors } : {}
+  };
+  const result = combinator.parse(input, 0, ctx);
+  if (!result.ok) return result;
+  const withErrors = _errors !== void 0 ? { ...result, errors: _errors } : result;
   if (trackLines) {
     const idx = buildLineIndex(input);
-    return { ...result, span: annotateSpan(result.span, idx) };
+    return { ...withErrors, span: annotateSpan(withErrors.span, idx) };
   }
-  return result;
+  return withErrors;
 }
 
 // src/compiler/codegen.ts
@@ -834,9 +1039,58 @@ function v(ctx, prefix = "_v") {
 function ind(ctx) {
   return "  ".repeat(ctx.indent);
 }
+function emitLeafCapture(ctx, valExpr, startExpr, endExpr) {
+  if (!ctx.capturing) 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) {`,
+    `${i}  const ${lf} = { _tag: 'leaf', value: ${valExpr}, span: { start: ${startExpr}, end: ${endExpr} } }`,
+    `${i}  _ctx._cstLeaves.push(${lf})`,
+    `${i}  if (_ctx._cstRawChildren) _ctx._cstRawChildren.push(${lf})`,
+    `${i}}`
+  ];
+}
+function ensureTriviaCaptureFn(ctx) {
+  const trivia2 = ctx.activeTrivia;
+  const existing = ctx.triviaCaptureNames.get(trivia2);
+  if (existing) return existing;
+  const fnName = `_tc${ctx.triviaCaptureNames.size}`;
+  ctx.triviaCaptureNames.set(trivia2, fnName);
+  const saved = { indent: ctx.indent, failLabel: ctx.failLabel, asTrivia: ctx.capAsTrivia, trivia: ctx.activeTrivia };
+  ctx.indent = 2;
+  ctx.failLabel = "_cap";
+  ctx.capAsTrivia = true;
+  delete ctx.activeTrivia;
+  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.namedFnDecls.push([
+    `function ${fnName}(input, _pos, _ctx) {`,
+    `  let _e = _pos`,
+    `  _cap: {`,
+    ...r.stmts,
+    `    _e = ${r.endVar}`,
+    `  }`,
+    `  if (_ctx._triviaLog !== undefined && _e > _pos) _ctx._triviaLog.push(_pos, _e)`,
+    `  return _e`,
+    `}`
+  ].join("\n"));
+  return fnName;
+}
 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} } }`;
 }
+function failArr(ctx, expectedArr, posExpr) {
+  if (ctx.failLabel) return `${ind(ctx)}break ${ctx.failLabel}`;
+  return `${ind(ctx)}return { ok: false, expected: ${expectedArr}, span: { start: ${posExpr}, end: ${posExpr} } }`;
+}
 function firstSetCond(codeVar, fs) {
   if (fs.kind === "any") return "true";
   if (fs.kind === "empty") return "false";
@@ -852,6 +1106,30 @@ function asIIFE(stmts, valueVar, endVar, startPos, indent) {
     `${indent}})()`
   ].join("\n");
 }
+function emitFallible(inner, ctx, pos) {
+  const lbl = v(ctx, "_lbl");
+  const okV = `${lbl}ok`;
+  const valV = `${lbl}v`;
+  const endV = `${lbl}e`;
+  const savedLabel = ctx.failLabel;
+  const savedIndent = ctx.indent;
+  ctx.failLabel = lbl;
+  ctx.indent = 0;
+  const r = emit(inner, ctx, pos);
+  ctx.failLabel = savedLabel;
+  ctx.indent = savedIndent;
+  const ind0 = ind(ctx);
+  const stmts = [
+    `${ind0}let ${okV} = false, ${valV}, ${endV} = ${pos}`,
+    `${ind0}${lbl}: {`,
+    ...r.stmts,
+    `${ind0}  ${valV} = ${r.valueVar}`,
+    `${ind0}  ${endV} = ${r.endVar}`,
+    `${ind0}  ${okV} = true`,
+    `${ind0}}`
+  ];
+  return { stmts, okVar: okV, valVar: valV, endVar: endV };
+}
 function emitLit(def, ctx, pos) {
   const { value, caseInsensitive } = def;
   const len = value.length;
@@ -889,12 +1167,19 @@ function emitLit(def, ctx, pos) {
       `${ind(ctx)}const ${vv} = ${JSON.stringify(value)}`
     );
   }
-  return { stmts, valueVar: vv, endVar: len === 0 ? pos : `${pos} + ${len}` };
+  const endVar = len === 0 ? pos : `${pos} + ${len}`;
+  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 rName = `_re${ctx.regexDecls.length}`;
-  ctx.regexDecls.push(`const ${rName} = /${def.optimizedSource}/${flags}`);
+  const key = `${def.optimizedSource}/${flags}`;
+  let rName = ctx.regexMap.get(key);
+  if (rName === void 0) {
+    rName = `_re${ctx.regexDecls.length}`;
+    ctx.regexDecls.push(`const ${rName} = /${def.optimizedSource}/${flags}`);
+    ctx.regexMap.set(key, rName);
+  }
   const mv = v(ctx, "_m");
   const vv = v(ctx);
   const expectedStr = JSON.stringify(`/${def.source}/`);
@@ -904,7 +1189,9 @@ function emitRegex(def, ctx, pos) {
     `${ind(ctx)}if (${mv} === null) ${failStmt({ ...ctx, indent: 0 }, expectedStr, pos).trim()}`,
     `${ind(ctx)}const ${vv} = ${mv}[0]`
   ];
-  return { stmts, valueVar: vv, endVar: `${pos} + ${vv}.length` };
+  const endVar = `${pos} + ${vv}.length`;
+  stmts.push(...emitLeafCapture(ctx, vv, pos, endVar));
+  return { stmts, valueVar: vv, endVar };
 }
 function ensureTriviaFn(ctx) {
   const trivia2 = ctx.activeTrivia;
@@ -912,9 +1199,15 @@ function ensureTriviaFn(ctx) {
     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,
@@ -934,12 +1227,17 @@ function emitSeq(def, ctx, pos) {
   const valueVars = [];
   for (let i = 0; i < def.parsers.length; i++) {
     if (i > 0 && ctx.activeTrivia) {
-      const trivFn = ensureTriviaFn(ctx);
-      const tmp = v(ctx, "_trv");
-      stmts.push(
-        `${ind(ctx)}const ${tmp} = ${trivFn}(input, ${curV}, _ctx)`,
-        `${ind(ctx)}if (${tmp}.ok) ${curV} = ${tmp}.span.end`
-      );
+      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");
+        stmts.push(
+          `${ind(ctx)}const ${tmp} = ${trivFn}(input, ${curV}, _ctx)`,
+          `${ind(ctx)}if (${tmp}.ok) ${curV} = ${tmp}.span.end`
+        );
+      }
     }
     const r = emit(def.parsers[i], ctx, curV);
     stmts.push(...r.stmts, `${ind(ctx)}${curV} = ${r.endVar}`);
@@ -979,9 +1277,7 @@ function emitChoice(def, ctx, pos) {
       ctx.indent--;
       stmts.push(`${ind(ctx)}}`);
     }
-    stmts.push(
-      `${ind(ctx)}else return { ok: false, expected: ${allExpected}, span: { start: ${pos}, end: ${pos} } }`
-    );
+    stmts.push(`${ind(ctx)}else ${failArr({ ...ctx, indent: 0 }, allExpected, pos)}`);
     return { stmts, valueVar: valV, endVar: endV };
   }
   return emitNonDisjoint(def, def.strategy, allExpected, ctx, pos);
@@ -989,17 +1285,21 @@ function emitChoice(def, ctx, pos) {
 function emitGreedyClassify(def, superIndex, allExpected, ctx, pos) {
   const superParser = def.parsers[superIndex];
   const regexDef = getCoreRegexDef(superParser);
-  const reIdx = ctx.regexDecls.length;
-  const reVar = `_re${reIdx}`;
   const cleanFlags = "y" + regexDef.flags.replace(/[gy]/g, "");
-  ctx.regexDecls.push(`const ${reVar} = /${regexDef.source}/${cleanFlags}`);
+  const reKey = `${regexDef.source}/${cleanFlags}`;
+  let reVar = ctx.regexMap.get(reKey);
+  if (reVar === void 0) {
+    reVar = `_re${ctx.regexDecls.length}`;
+    ctx.regexDecls.push(`const ${reVar} = /${regexDef.source}/${cleanFlags}`);
+    ctx.regexMap.set(reKey, reVar);
+  }
   const matchV = v(ctx, "_gm");
   const wordV = v(ctx, "_gw");
   const endV = v(ctx, "_ge");
   const stmts = [
     `${ind(ctx)}${reVar}.lastIndex = ${pos}`,
     `${ind(ctx)}const ${matchV} = ${reVar}.exec(input)`,
-    `${ind(ctx)}if (${matchV} === null) return { ok: false, expected: ${allExpected}, span: { start: ${pos}, end: ${pos} } }`,
+    `${ind(ctx)}if (${matchV} === null) ${failArr({ ...ctx, indent: 0 }, allExpected, pos)}`,
     `${ind(ctx)}const ${wordV} = ${matchV}[0]`,
     `${ind(ctx)}const ${endV} = ${pos} + ${wordV}.length`
   ];
@@ -1039,7 +1339,7 @@ function emitLiteralsLongestFirst(def, sortedIndices, allExpected, ctx, pos) {
     ctx.indent--;
     stmts.push(`${ind(ctx)}}`);
   }
-  stmts.push(`${ind(ctx)}else return { ok: false, expected: ${allExpected}, span: { start: ${pos}, end: ${pos} } }`);
+  stmts.push(`${ind(ctx)}else ${failArr({ ...ctx, indent: 0 }, allExpected, pos)}`);
   return { stmts, valueVar: valV, endVar: endV };
 }
 function emitFirstMatch(def, allExpected, ctx, pos) {
@@ -1050,40 +1350,60 @@ function emitFirstMatch(def, allExpected, ctx, pos) {
     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.user)`;
+      gateCond = `_mf[${gateIdx}](_ctx.state)`;
     }
     const skipCond = gateCond ? `!${resV}?.ok && ${gateCond}` : `!${resV}?.ok`;
+    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} }` : "";
     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)`
       ).join(" || ");
+      stmts.push(`${ind(ctx)}if (${skipCond}) {`);
+      stmts.push(...markStmts);
       stmts.push(
-        `${ind(ctx)}if (${skipCond}) { const ${tmp} = (() => { try { return ${iife} } catch {} })(); if (${tmp}?.ok) { const ${anCode} = ${tmp}.span.end < input.length ? input.charCodeAt(${tmp}.span.end) : -1; if (!(${rejectCond})) ${resV} = ${tmp} } }`
+        `${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} }`
       );
+      if (rollbackStmt) stmts.push(rollbackStmt);
+      stmts.push(`${ind(ctx)}}`);
     } else {
-      stmts.push(`${ind(ctx)}if (${skipCond}) { try { ${resV} = ${iife} } catch {} }`);
+      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(
-    `${ind(ctx)}if (!${resV}?.ok) return { ok: false, expected: ${allExpected}, span: { start: ${pos}, end: ${pos} } }`
-  );
+  stmts.push(`${ind(ctx)}if (!${resV}?.ok) ${failArr({ ...ctx, indent: 0 }, allExpected, pos)}`);
   return { stmts, valueVar: `${resV}.value`, endVar: `${resV}.span.end` };
 }
 function emitNonDisjoint(def, strategy, 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);
+  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);
+  }
   return emitFirstMatch(def, allExpected, ctx, pos);
 }
 function emitTransformChain(p, baseValue, endV, startPos, ctx) {
@@ -1092,6 +1412,7 @@ function emitTransformChain(p, baseValue, endV, startPos, ctx) {
     const innerR = emitTransformChain(def.parser, baseValue, endV, startPos, ctx);
     const fnIdx = ctx.mapFns.length;
     ctx.mapFns.push(def.fn);
+    ctx.mapFnSrcs.push(def.fnSrc ?? null);
     const vv = v(ctx);
     return {
       stmts: [...innerR.stmts, `${ind(ctx)}const ${vv} = _mf[${fnIdx}](${innerR.valueVar}, { start: ${startPos}, end: ${endV} })`],
@@ -1119,13 +1440,6 @@ function emitMany(def, ctx, pos) {
     `${ind(ctx)}const ${arrV} = []`,
     `${ind(ctx)}let ${curV} = ${pos}`
   ];
-  const emitInnerIIFE = () => {
-    const savedIndent = ctx.indent;
-    ctx.indent = 0;
-    const r = emit(def.parser, ctx, curV);
-    ctx.indent = savedIndent;
-    return asIIFE(r.stmts, r.valueVar, r.endVar, curV, ind(ctx) + "  ");
-  };
   if (def.min === 1) {
     const firstR = emit(def.parser, ctx, curV);
     stmts.push(...firstR.stmts);
@@ -1136,11 +1450,35 @@ function emitMany(def, ctx, pos) {
   }
   stmts.push(`${ind(ctx)}while (${curV} < input.length) {`);
   ctx.indent++;
+  let itemPos = curV;
+  let rollback = "";
+  if (ctx.activeTrivia) {
+    if (ctx.capturing) {
+      const capFn = ensureTriviaCaptureFn(ctx);
+      const markV = v(ctx, "_mk");
+      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)`
+      );
+      itemPos = npV;
+      rollback = `if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markV}; `;
+    } 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 }`
+      );
+      itemPos = npV;
+    }
+  }
+  const { stmts: iterStmts, okVar: iterOk, valVar: iterVal, endVar: iterEnd } = emitFallible(def.parser, ctx, itemPos);
   stmts.push(
-    `${ind(ctx)}const _iter = (() => { try { return ${emitInnerIIFE()} } catch { return null } })()`,
-    `${ind(ctx)}if (!_iter?.ok || _iter.span.end === ${curV}) break`,
-    `${ind(ctx)}${arrV}.push(_iter.value)`,
-    `${ind(ctx)}${curV} = _iter.span.end`
+    ...iterStmts,
+    `${ind(ctx)}if (!${iterOk} || ${iterEnd} === ${curV}) { ${rollback}break }`,
+    `${ind(ctx)}${arrV}.push(${iterVal})`,
+    `${ind(ctx)}${curV} = ${iterEnd}`
   );
   ctx.indent--;
   stmts.push(`${ind(ctx)}}`);
@@ -1149,56 +1487,80 @@ function emitMany(def, ctx, pos) {
 function emitOptional(def, ctx, pos) {
   const valV = v(ctx, "_opt");
   const endV = v(ctx, "_opte");
-  const savedIndent = ctx.indent;
-  ctx.indent = 0;
-  const r = emit(def.parser, ctx, pos);
-  ctx.indent = savedIndent;
-  const iife = asIIFE(r.stmts, r.valueVar, r.endVar, pos, ind(ctx));
-  const resV = v(ctx, "_optr");
+  const { stmts: lblStmts, okVar, valVar, endVar } = emitFallible(def.parser, ctx, pos);
+  const ind0 = ind(ctx);
   const stmts = [
-    `${ind(ctx)}const ${resV} = (() => { try { return ${iife} } catch { return null } })()`,
-    `${ind(ctx)}const ${valV} = ${resV}?.ok ? ${resV}.value : null`,
-    `${ind(ctx)}const ${endV} = ${resV}?.ok ? ${resV}.span.end : ${pos}`
+    ...lblStmts,
+    `${ind0}const ${valV} = ${okVar} ? ${valVar} : null`,
+    `${ind0}const ${endV} = ${okVar} ? ${endVar} : ${pos}`
   ];
   return { stmts, valueVar: valV, endVar: endV };
 }
 function emitSepBy(_p, def, ctx, pos) {
   const arrV = v(ctx, "_arr");
   const curV = v(ctx, "_cur");
-  const iife = (inner, posExpr) => {
-    const saved = ctx.indent;
-    ctx.indent = 0;
-    const r = emit(inner, ctx, posExpr);
-    ctx.indent = saved;
-    return asIIFE(r.stmts, r.valueVar, r.endVar, posExpr, ind(ctx));
-  };
-  const firstR_saved = ctx.indent;
-  ctx.indent = 0;
-  const firstR = emit(def.parser, ctx, pos);
-  ctx.indent = firstR_saved;
-  const firstV = v(ctx, "_sb0");
-  const sepV = v(ctx, "_sbs");
-  const nextV = v(ctx, "_sbn");
+  const { stmts: firstStmts, okVar: firstOk, valVar: firstVal, endVar: firstEnd } = emitFallible(def.parser, ctx, pos);
   const stmts = [
     `${ind(ctx)}const ${arrV} = []`,
     `${ind(ctx)}let ${curV} = ${pos}`,
-    `${ind(ctx)}const ${firstV} = (() => { try { return ${asIIFE(firstR.stmts, firstR.valueVar, firstR.endVar, pos, ind(ctx))} } catch { return null } })()`,
-    `${ind(ctx)}if (${firstV}?.ok) {`
+    ...firstStmts,
+    `${ind(ctx)}if (${firstOk}) {`
   ];
   ctx.indent++;
   stmts.push(
-    `${ind(ctx)}${arrV}.push(${firstV}.value)`,
-    `${ind(ctx)}${curV} = ${firstV}.span.end`,
+    `${ind(ctx)}${arrV}.push(${firstVal})`,
+    `${ind(ctx)}${curV} = ${firstEnd}`,
     `${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 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 }`
+      );
+      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 npV = v(ctx, "_np");
+      stmts.push(`${ind(ctx)}const ${npV} = ${capFn}(input, ${sepEnd}, _ctx)`);
+      nextAtPos = npV;
+    } else {
+      const trivFn = ensureTriviaFn(ctx);
+      const npV = v(ctx, "_np");
+      stmts.push(
+        `${ind(ctx)}let ${npV} = ${sepEnd}`,
+        `${ind(ctx)}{ const _trv = ${trivFn}(input, ${npV}, _ctx); if (_trv.ok) ${npV} = _trv.span.end }`
+      );
+      nextAtPos = npV;
+    }
+  }
+  const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, nextAtPos);
   stmts.push(
-    `${ind(ctx)}const ${sepV} = (() => { try { return ${iife(def.separator, curV)} } catch { return null } })()`,
-    `${ind(ctx)}if (!${sepV}?.ok) break`,
-    `${ind(ctx)}const ${nextV} = (() => { try { return ${iife(def.parser, `${sepV}.span.end`)} } catch { return null } })()`,
-    `${ind(ctx)}if (!${nextV}?.ok) break`,
-    `${ind(ctx)}${arrV}.push(${nextV}.value)`,
-    `${ind(ctx)}${curV} = ${nextV}.span.end`
+    ...nextStmts,
+    `${ind(ctx)}if (!${nextOk}) { ${rollback}break }`,
+    `${ind(ctx)}${arrV}.push(${nextVal})`,
+    `${ind(ctx)}${curV} = ${nextEnd}`
   );
   ctx.indent--;
   stmts.push(`${ind(ctx)}}`);
@@ -1207,13 +1569,6 @@ function emitSepBy(_p, def, ctx, pos) {
   return { stmts, valueVar: arrV, endVar: curV };
 }
 function emitScanTo(def, ctx, pos) {
-  const safeIIFE = (inner, posExpr) => {
-    const saved = ctx.indent;
-    ctx.indent = 0;
-    const r = emit(inner, ctx, posExpr);
-    ctx.indent = saved;
-    return `(() => { try { return ${asIIFE(r.stmts, r.valueVar, r.endVar, posExpr, ind(ctx))} } catch { return null } })()`;
-  };
   const curV = v(ctx, "_stcur");
   const foundV = v(ctx, "_stfnd");
   const stmts = [
@@ -1222,18 +1577,19 @@ function emitScanTo(def, ctx, pos) {
     `${ind(ctx)}while (${curV} < input.length) {`
   ];
   ctx.indent++;
-  const sentV = v(ctx, "_sts");
-  stmts.push(
-    `${ind(ctx)}const ${sentV} = ${safeIIFE(def.sentinel, curV)}`,
-    `${ind(ctx)}if (${sentV}?.ok) { ${foundV} = true; break }`
-  );
+  const probeCtx = { ...ctx, capturing: false };
+  const { stmts: sentStmts, okVar: sentOk } = emitFallible(def.sentinel, probeCtx, curV);
+  stmts.push(...sentStmts, `${ind(ctx)}if (${sentOk}) { ${foundV} = true; break }`);
   if (def.skip.length > 0) {
     const advV = v(ctx, "_stadv");
     stmts.push(`${ind(ctx)}let ${advV} = false`);
     for (const skipper of def.skip) {
-      const skV = v(ctx, "_sk");
+      const { stmts: skStmts, okVar: skOk, endVar: skEnd } = emitFallible(skipper, probeCtx, curV);
       stmts.push(
-        `${ind(ctx)}if (!${advV}) { const ${skV} = ${safeIIFE(skipper, curV)}; if (${skV}?.ok && ${skV}.span.end > ${curV}) { ${curV} = ${skV}.span.end; ${advV} = true } }`
+        `${ind(ctx)}if (!${advV}) {`,
+        ...skStmts,
+        `${ind(ctx)}  if (${skOk} && ${skEnd} > ${curV}) { ${curV} = ${skEnd}; ${advV} = true }`,
+        `${ind(ctx)}}`
       );
     }
     stmts.push(`${ind(ctx)}if (!${advV}) ${curV}++`);
@@ -1245,14 +1601,54 @@ function emitScanTo(def, ctx, pos) {
   if (!def.orEOF) {
     const sentDef = def.sentinel._def;
     const expectedStr = sentDef.tag === "literal" ? JSON.stringify([JSON.stringify(sentDef.value)]) : `["sentinel"]`;
-    stmts.push(
-      `${ind(ctx)}if (!${foundV}) return { ok: false, expected: ${expectedStr}, span: { start: ${pos}, end: ${curV} } }`
-    );
+    stmts.push(`${ind(ctx)}if (!${foundV}) ${failArr({ ...ctx, indent: 0 }, expectedStr, pos)}`);
   }
   const valV = v(ctx);
   stmts.push(`${ind(ctx)}const ${valV} = input.slice(${pos}, ${curV})`);
+  if (ctx.capturing) {
+    const cap = emitLeafCapture(ctx, valV, pos, curV).map((s) => "  " + s);
+    stmts.push(`${ind(ctx)}if (${curV} > ${pos}) {`, ...cap, `${ind(ctx)}}`);
+  }
   return { stmts, valueVar: valV, endVar: curV };
 }
+function emitNot(def, ctx, pos) {
+  const { stmts, okVar } = emitFallible(def.parser, ctx, pos);
+  return {
+    stmts: [
+      ...stmts,
+      `${ind(ctx)}if (${okVar}) ${failStmt({ ...ctx, indent: 0 }, '"not"', pos).trim()}`
+    ],
+    valueVar: "null",
+    endVar: pos
+  };
+}
+function emitNode(def, ctx, pos) {
+  const fnIdx = 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 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`
+  ];
+  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}if (!${okVar}) ${failStmt({ ...ctx, indent: 0 }, '"node"', pos).trim()}`);
+  const ndV = v(ctx, "_nd");
+  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}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} } })`
+  );
+  return { stmts, valueVar: ndV, endVar };
+}
 function emitRuntimeFallback(parser2, ctx, pos) {
   const idx = ctx.runtimeParsers.length;
   ctx.runtimeParsers.push(parser2);
@@ -1261,7 +1657,7 @@ function emitRuntimeFallback(parser2, ctx, pos) {
   const ev = v(ctx, "_rte");
   const stmts = [
     `${ind(ctx)}const ${rv} = _rp[${idx}].parse(input, ${pos}, _ctx)`,
-    `${ind(ctx)}if (!${rv}.ok) return ${rv}`,
+    `${ind(ctx)}if (!${rv}.ok) ${failStmt({ ...ctx, indent: 0 }, '"runtime"', pos).trim()}`,
     `${ind(ctx)}const ${vv} = ${rv}.value`,
     `${ind(ctx)}const ${ev} = ${rv}.span.end`
   ];
@@ -1279,9 +1675,12 @@ function emitLazy(p, def, ctx, pos) {
       return emitRuntimeFallback(p, ctx, pos);
     }
     const savedIndent = ctx.indent;
+    const savedFailLabel = ctx.failLabel;
     ctx.indent = 1;
+    ctx.failLabel = void 0;
     const r = emit(resolved, ctx, "_pos");
     ctx.indent = savedIndent;
+    ctx.failLabel = savedFailLabel;
     ctx.namedFnDecls.push([
       `function ${fnName2}(input, _pos, _ctx) {`,
       ...r.stmts,
@@ -1296,7 +1695,7 @@ function emitLazy(p, def, ctx, pos) {
   return {
     stmts: [
       `${ind(ctx)}const ${rv} = ${fnName}(input, ${pos}, _ctx)`,
-      `${ind(ctx)}if (!${rv}.ok) return ${rv}`,
+      `${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`
     ],
@@ -1304,6 +1703,33 @@ function emitLazy(p, def, ctx, pos) {
     endVar: ev
   };
 }
+function emitRecover(def, ctx, pos) {
+  const { stmts: innerStmts, okVar, valVar, endVar } = emitFallible(def.parser, ctx, pos);
+  const ind0 = ind(ctx);
+  const scanV = v(ctx, "_sc");
+  const errV = v(ctx, "_err");
+  const savedIndent = ctx.indent;
+  ctx.indent += 2;
+  const { stmts: sentStmts, okVar: sentOk } = emitFallible(def.sentinel, ctx, scanV);
+  ctx.indent = savedIndent;
+  const stmts = [
+    ...innerStmts,
+    `${ind0}if (!${okVar}) {`,
+    `${ind0}  let ${scanV} = ${pos}`,
+    `${ind0}  while (${scanV} < input.length) {`,
+    ...sentStmts,
+    `${ind0}    if (${sentOk}) break`,
+    `${ind0}    ${scanV}++`,
+    `${ind0}  }`,
+    `${ind0}  const ${errV} = { _tag: 'parseError', span: { start: ${pos}, end: ${scanV} }, expected: [] }`,
+    `${ind0}  if (_ctx._errors) _ctx._errors.push(${errV})`,
+    `${ind0}  ${valVar} = ${errV}`,
+    `${ind0}  ${endVar} = ${scanV}`,
+    `${ind0}  ${okVar} = true`,
+    `${ind0}}`
+  ];
+  return { stmts, valueVar: valVar, endVar };
+}
 function emit(p, ctx, pos) {
   const def = p._def;
   switch (def.tag) {
@@ -1326,6 +1752,7 @@ function emit(p, ctx, pos) {
       const inner = emit(def.parser, ctx, pos);
       const fnIdx = ctx.mapFns.length;
       ctx.mapFns.push(def.fn);
+      ctx.mapFnSrcs.push(def.fnSrc ?? null);
       const mv = v(ctx, "_mapped");
       return {
         stmts: [
@@ -1366,15 +1793,21 @@ function emit(p, ctx, pos) {
       else ctx.activeTrivia = savedTrivia;
       return r;
     }
+    case "not":
+      return emitNot(def, ctx, pos);
+    case "node":
+      return emitNode(def, ctx, pos);
     case "scanTo":
       return emitScanTo(def, ctx, pos);
+    case "recover":
+      return emitRecover(def, ctx, pos);
     case "guard": {
       const fnIdx = ctx.mapFns.length;
       ctx.mapFns.push(def.predicate);
       const vv = v(ctx);
       return {
         stmts: [
-          `${ind(ctx)}if (!_mf[${fnIdx}](_ctx.user)) ${failStmt({ ...ctx, indent: 0 }, '"gate"', pos).trim()}`,
+          `${ind(ctx)}if (!_mf[${fnIdx}](_ctx.state)) ${failStmt({ ...ctx, indent: 0 }, '"gate"', pos).trim()}`,
           `${ind(ctx)}const ${vv} = null`
         ],
         valueVar: vv,
@@ -1390,9 +1823,12 @@ function emit(p, ctx, pos) {
         const fnName = `_wcf${ctx.namedParsers.size}`;
         ctx.namedParsers.set(innerParser, fnName);
         const savedIndent = ctx.indent;
+        const savedFailLabel = ctx.failLabel;
         ctx.indent = 1;
+        ctx.failLabel = void 0;
         const innerR = emit(innerParser, ctx, "_pos");
         ctx.indent = savedIndent;
+        ctx.failLabel = savedFailLabel;
         ctx.namedFnDecls.push([
           `function ${fnName}(input, _pos, _ctx) {`,
           ...innerR.stmts,
@@ -1406,8 +1842,8 @@ function emit(p, ctx, pos) {
       const ev = v(ctx, "_wce");
       return {
         stmts: [
-          `${ind(ctx)}const ${rv} = ${fn}(input, ${pos}, { ..._ctx, user: _mf[${evIdx}]() })`,
-          `${ind(ctx)}if (!${rv}.ok) return ${rv}`,
+          `${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`
         ],
@@ -1419,16 +1855,61 @@ function emit(p, ctx, pos) {
       return emitRuntimeFallback(p, ctx, pos);
   }
 }
-function compile(parser2) {
+function hasNodeDef(p, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return false;
+  seen.add(p);
+  const d = p._def;
+  switch (d.tag) {
+    case "node":
+      return true;
+    case "lazy": {
+      try {
+        return hasNodeDef(d.thunk(), seen);
+      } catch {
+        return false;
+      }
+    }
+    case "grammar":
+    case "trivia":
+    case "optional":
+    case "many":
+    case "oneOrMore":
+    case "not":
+    case "transform":
+      return hasNodeDef(d.parser, seen);
+    case "skip":
+      return hasNodeDef(d.main, seen) || hasNodeDef(d.skipped, seen);
+    case "sequence":
+    case "choice":
+      return d.parsers.some((x) => hasNodeDef(x, seen));
+    case "sepBy":
+      return hasNodeDef(d.parser, seen) || hasNodeDef(d.separator, seen);
+    case "scanTo":
+      return hasNodeDef(d.sentinel, seen) || d.skip.some((x) => hasNodeDef(x, seen));
+    case "recover":
+      return hasNodeDef(d.parser, seen) || hasNodeDef(d.sentinel, seen);
+    case "withCtx":
+      return hasNodeDef(d.parser, seen);
+    default:
+      return false;
+  }
+}
+function compile(parser2, mapFnSources) {
   const ctx = {
     vars: 0,
     indent: 1,
     regexDecls: [],
+    regexMap: /* @__PURE__ */ new Map(),
     mapFns: [],
+    mapFnSrcs: [],
+    buildFns: [],
+    buildSrcs: [],
     runtimeParsers: [],
     needsCollator: false,
     namedParsers: /* @__PURE__ */ new Map(),
-    namedFnDecls: []
+    triviaCaptureNames: /* @__PURE__ */ new Map(),
+    namedFnDecls: [],
+    capturing: hasNodeDef(parser2)
   };
   const r = emit(parser2, ctx, "_pos");
   const collatorDecl = ctx.needsCollator ? `const _collator = new Intl.Collator(undefined, { sensitivity: 'accent' })
@@ -1437,13 +1918,13 @@ function compile(parser2) {
     ...ctx.regexDecls,
     "",
     ...ctx.namedFnDecls,
-    `${collatorDecl}function _parse(input, _pos, _rp, _mf, _ctx) {`,
+    `${collatorDecl}function _parse(input, _pos, _rp, _mf, _build, _ctx) {`,
     `  let pos = _pos`,
     ...r.stmts,
     `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,
     `}`
   ].join("\n");
-  const fn = new Function("input", "_pos", "_rp", "_mf", "_ctx", [
+  const fn = new Function("input", "_pos", "_rp", "_mf", "_build", "_ctx", [
     ...ctx.regexDecls,
     collatorDecl,
     ...ctx.namedFnDecls,
@@ -1452,17 +1933,27 @@ function compile(parser2) {
     `return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`
   ].join("\n"));
   const defaultCtx = { trackLines: false };
-  const canInline = ctx.runtimeParsers.length === 0 && ctx.mapFns.length === 0;
-  const inlineExpression = canInline ? buildInlineExpression(ctx, r, collatorDecl) : null;
+  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);
+  const buildSources = ctx.buildFns.length === 0 ? void 0 : ctx.buildSrcs;
+  const mfCovered = ctx.mapFns.length === 0 || effectiveSources !== void 0 && effectiveSources.length === ctx.mapFns.length;
+  const canInline = ctx.runtimeParsers.length === 0 && mfCovered && buildCovered;
+  const inlineExpression = canInline ? buildInlineExpression(ctx, r, collatorDecl, effectiveSources, buildSources) : null;
   return {
     source,
     inlineExpression,
     parse(input, pos = 0) {
-      return fn(input, pos, ctx.runtimeParsers, ctx.mapFns, defaultCtx);
+      return fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, defaultCtx);
+    },
+    parseWithErrors(input, pos = 0) {
+      const errors = [];
+      const result = fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, { ...defaultCtx, _errors: errors });
+      return { ...result, errors };
     }
   };
 }
-function buildInlineExpression(ctx, r, collatorDecl) {
+function buildInlineExpression(ctx, r, collatorDecl, mapFnSources, buildSources) {
   const bodyLines = [
     `  let pos = _pos`,
     ...r.stmts.map((s) => `  ${s}`),
@@ -1473,14 +1964,16 @@ function buildInlineExpression(ctx, r, collatorDecl) {
     ...bodyLines,
     `}`
   ].join("\n");
-  const needsWrapper = ctx.regexDecls.length > 0 || !!collatorDecl || ctx.namedFnDecls.length > 0;
-  if (!needsWrapper) {
-    return innerFn;
-  }
+  const mfDecl = mapFnSources?.length ? `  const _mf = [${mapFnSources.join(", ")}]` : "";
+  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;
   return [
     `/* @__PURE__ */ (() => {`,
     ...ctx.regexDecls.map((d) => `  ${d}`),
     collatorDecl ? `  ${collatorDecl.trim()}` : "",
+    mfDecl,
+    buildDecl,
     ...ctx.namedFnDecls.flatMap((f) => f.split("\n").map((l) => `  ${l}`)),
     `  return ${innerFn}`,
     `})()`
@@ -1499,7 +1992,7 @@ function guard(predicate) {
     _meta: meta,
     _def: { tag: "guard", predicate },
     parse(_input, pos, ctx) {
-      if (predicate(ctx.user))
+      if (predicate(ctx.state))
         return { ok: true, value: null, span: { start: pos, end: pos } };
       return { ok: false, expected: ["guard"], span: { start: pos, end: pos } };
     }
@@ -1518,7 +2011,7 @@ function withCtx(extra, parser2) {
     _meta: meta,
     _def: { tag: "withCtx", extra, parser: parser2 },
     parse(input, pos, ctx) {
-      return parser2.parse(input, pos, { ...ctx, user: extra });
+      return parser2.parse(input, pos, { ...ctx, state: extra });
     }
   };
 }
@@ -1547,6 +2040,7 @@ function recover(parser2, sentinel) {
         span: { start: pos, end: scanPos },
         expected: result.expected
       };
+      ctx._errors?.push(error);
       return { ok: true, value: error, span: { start: pos, end: scanPos } };
     }
   };
@@ -1555,6 +2049,21 @@ function isParseError(value) {
   return typeof value === "object" && value !== null && value._tag === "parseError";
 }
 
+// src/combinators/completions.ts
+function completionsAt(parser2, input, offset) {
+  const probe = { offset, best: null };
+  const ctx = { trackLines: false, _probe: probe };
+  const result = parser2.parse(input.slice(0, offset), 0, ctx);
+  if (result.ok) return [];
+  const best = deeperFail(probe.best, result);
+  return best?.expected ?? [];
+}
+function deeperFail(a, b) {
+  if (!a) return b;
+  if (!b) return a;
+  return a.span.start >= b.span.start ? a : b;
+}
+
 // src/combinators/scanTo.ts
 function scanTo(sentinel, { skip: skip2 = [], orEOF = false } = {}) {
   const meta = {
@@ -1568,14 +2077,23 @@ function scanTo(sentinel, { skip: skip2 = [], orEOF = false } = {}) {
     _def: { tag: "scanTo", sentinel, skip: skip2, orEOF },
     parse(input, pos, ctx) {
       let cur = pos;
+      const probeCtx = { trackLines: ctx.trackLines, state: ctx.state };
+      const emit2 = (end) => {
+        if (end > pos && (ctx._cstLeaves || ctx._cstRawChildren)) {
+          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);
+        }
+      };
       while (cur < input.length) {
-        const s = sentinel.parse(input, cur, ctx);
+        const s = sentinel.parse(input, cur, probeCtx);
         if (s.ok) {
+          emit2(cur);
           return { ok: true, value: input.slice(pos, cur), span: { start: pos, end: cur } };
         }
         let advanced = false;
         for (const skipper of skip2) {
-          const r = skipper.parse(input, cur, ctx);
+          const r = skipper.parse(input, cur, probeCtx);
           if (r.ok && r.span.end > cur) {
             cur = r.span.end;
             advanced = true;
@@ -1585,6 +2103,7 @@ function scanTo(sentinel, { skip: skip2 = [], orEOF = false } = {}) {
         if (!advanced) cur++;
       }
       if (orEOF) {
+        emit2(cur);
         return { ok: true, value: input.slice(pos, cur), span: { start: pos, end: cur } };
       }
       const sentDef = sentinel._def;
@@ -1595,19 +2114,23 @@ function scanTo(sentinel, { skip: skip2 = [], orEOF = false } = {}) {
 }
 function balanced(open, close, options = {}) {
   const inner = scanTo(literal(close), options);
-  return transform(
+  const combi = transform(
     sequence(literal(open), inner, literal(close)),
     ([o, content, c]) => o + content + c
   );
+  if (combi._def.tag === "transform") {
+    combi._def.fnSrc = "([o, content, c]) => o + content + c";
+  }
+  return combi;
 }
 
 // src/cst/incremental.ts
 function isNode(x) {
   return typeof x === "object" && x !== null && x._tag === "node";
 }
-function findContaining(node, pos, path = []) {
-  for (let i = 0; i < node.children.length; i++) {
-    const child = node.children[i];
+function findContaining(node2, pos, path = []) {
+  for (let i = 0; i < node2.children.length; i++) {
+    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] };
@@ -1636,22 +2159,29 @@ function replaceAtPath(grammar, root, path, newNode) {
 var ParseDocImpl = class _ParseDocImpl {
   _parser;
   _ruleName;
+  _trivia;
+  _captureTrivia;
   tree;
   errors;
   input;
-  constructor(parser2, ruleName, 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);
+    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);
+    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];
@@ -1660,32 +2190,66 @@ var ParseDocImpl = class _ParseDocImpl {
       candidates.push({ node: ancestors[i + 1], path: [...pathCopy] });
     }
     for (const candidate of candidates) {
-      const { node, path } = candidate;
-      const expectedEnd = node.span.end + delta;
-      const parser2 = this._parser.rule(node.type);
-      const ctx = { trackLines: false, user: node.savedContext };
-      const r = parser2.parse(newInput, node.span.start, ctx);
+      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);
+        return new _ParseDocImpl(this._parser, this._ruleName, newTree, [], newInput, this._trivia, this._captureTrivia);
       }
     }
-    return makeParseDoc(this._parser, this._ruleName, newInput);
+    return makeParseDoc(this._parser, this._ruleName, newInput, this._trivia, this._captureTrivia);
   }
 };
-function makeParseDoc(parser2, ruleName, input) {
-  const ctx = { trackLines: false };
+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);
+    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);
+  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;
@@ -1725,8 +2289,8 @@ var Parser = class {
    * grammar is whitespace-sensitive (e.g. CSS descendant vs adjacent combinators).
    * The default implementation ignores `rawChildren`.
    */
-  buildNode(type, span, children, savedContext, _rawChildren) {
-    return { _tag: "node", type, span, children, savedContext };
+  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) {
@@ -1741,7 +2305,7 @@ var Parser = class {
       _meta: meta,
       _def: { tag: "unknown" },
       parse(input, pos, ctx) {
-        const savedContext = ctx.user !== void 0 ? Object.assign({}, ctx.user) : void 0;
+        const state = ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
         const children = [];
         const rawChildren = [];
         const innerCtx = {
@@ -1752,31 +2316,34 @@ var Parser = class {
         };
         const r = inner.parse(input, pos, innerCtx);
         if (!r.ok) return r;
-        const node = self.buildNode(type, r.span, children, savedContext, rawChildren);
-        if (ctx._cstChildren) ctx._cstChildren.push(node);
-        if (ctx._cstRawChildren) ctx._cstRawChildren.push(node);
-        return { ok: true, value: node, span: r.span };
+        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(node, newChildren) {
-    return this.buildNode(node.type, node.span, newChildren, node.savedContext, []);
+  rebuild(node2, newChildren) {
+    return this.buildNode(node2.type, node2.span, newChildren, node2.state, []);
   }
-  /**
-   * Parse input starting from a named rule, returning a ParseDoc.
-   * The doc carries the tree, any parse errors, and an edit() method
-   * for incremental re-parsing on subsequent changes.
-   *
-   *   const doc = css.parse('Stylesheet', src)
-   *   doc.tree    // the CST root, or null on failure
-   *   doc.errors  // ParseFail[], empty on success
-   *
-   *   // In an editor — just keep calling edit():
-   *   const doc2 = doc.edit(newSrc, changeStart, changeEnd)
-   */
-  parse(ruleName, input) {
-    return makeParseDoc(this, ruleName, input);
+  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.
@@ -1784,7 +2351,8 @@ var Parser = class {
    */
   rule(name) {
     this._build();
-    const p = this[name];
+    const resolved = this._resolveRule(name);
+    const p = this[resolved];
     if (!p) throw new Error(`No rule '${String(name)}' on this parser`);
     return p;
   }
@@ -1792,4 +2360,168 @@ var Parser = class {
 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) {
+  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);
+  return rebuild(root, newChildren);
+}
+function defaultRebuild(node2, children) {
+  return { ...node2, children };
+}
+var FunctionalDocImpl = class _FunctionalDocImpl {
+  _registry;
+  _rootRule;
+  _opts;
+  tree;
+  errors;
+  input;
+  constructor(registry, rootRule, opts, tree, errors, input) {
+    this._registry = registry;
+    this._rootRule = rootRule;
+    this._opts = opts;
+    this.tree = tree;
+    this.errors = errors;
+    this.input = input;
+  }
+  edit(from, to, replacement) {
+    const newInput = this.input.slice(0, from) + replacement + this.input.slice(to);
+    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);
+    if (!found) return reparse();
+    const ancestors = ancestorsAt2(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] });
+    }
+    const rebuild = this._opts.rebuild ?? defaultRebuild;
+    for (const { node: node2, path } of candidates) {
+      const ruleFn = this._registry[node2.type];
+      if (!ruleFn) continue;
+      const ctx = { trackLines: false, state: node2.state };
+      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);
+        return new _FunctionalDocImpl(this._registry, this._rootRule, this._opts, newTree, [], newInput);
+      }
+    }
+    return reparse();
+  }
+};
+function makeFunctionalDoc(registry, rootRule, input, opts = {}) {
+  const ruleFn = registry[rootRule];
+  if (!ruleFn) throw new Error(`No rule '${rootRule}' in registry`);
+  const ctx = { trackLines: false, state: opts.state };
+  const r = ruleFn(input, 0, ctx);
+  if (r.ok) {
+    return new FunctionalDocImpl(registry, rootRule, opts, r.value, [], input);
+  }
+  return new FunctionalDocImpl(registry, rootRule, opts, null, [{ ok: false, expected: r.expected, span: r.span }], input);
+}
+
+// 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) {
+  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 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);
+    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);
+      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);
+      }
+      return run;
+    };
+    if (rootSpan && rootSpan.start > 0) {
+      const lead = scanFrom(0);
+      if (lead.length) merge(before, rootSpan.start, lead);
+    }
+    const end = rootSpan ? rootSpan.end : 0;
+    if (end < opts.input.length) {
+      const trail = scanFrom(end);
+      if (trail.length) {
+        merge(after, end, trail);
+        merge(before, end + trail.reduce((n, t) => n + (t.span.end - t.span.start), 0), trail);
+      }
+    }
+  }
+  return { before, after };
+}
 //# sourceMappingURL=index.cjs.map