parseman 0.6.2 → 0.7.0

package/dist/index.cjs

@@ -45,6 +45,7 @@ __export(index_exports, {
   makeFunctionalDoc: () => makeFunctionalDoc,
   makeWord: () => makeWord,
   many: () => many,
+  noTrivia: () => noTrivia,
   node: () => node,
   not: () => not,
   offsetToLineCol: () => offsetToLineCol,
@@ -1052,8 +1053,10 @@ function optional(combinator) {
     _meta: meta,
     _def: { tag: "optional", parser: combinator },
     parse(input, pos, ctx) {
+      const mark = saveTriviaMark(ctx);
       const result = combinator.parse(input, pos, ctx);
       if (result.ok) return result;
+      rollbackTrivia(ctx, mark);
       return { ok: true, value: null, span: { start: pos, end: pos } };
     }
   };
@@ -1074,7 +1077,7 @@ function sepBy(combinator, separator) {
       const values = [first.value];
       let cur = first.span.end;
       while (cur < input.length) {
-        let mark = saveTriviaMark(ctx);
+        const loopMark = saveTriviaMark(ctx);
         let sepPos = cur;
         if (ctx.trivia) {
           if (needsDeferredTriviaCommit(ctx)) {
@@ -1087,10 +1090,9 @@ function sepBy(combinator, separator) {
         }
         const sep = separator.parse(input, sepPos, ctx);
         if (!sep.ok) {
-          rollbackTrivia(ctx, mark);
+          rollbackTrivia(ctx, loopMark);
           break;
         }
-        mark = saveTriviaMark(ctx);
         let nextPos = sep.span.end;
         if (ctx.trivia) {
           if (needsDeferredTriviaCommit(ctx)) {
@@ -1103,7 +1105,7 @@ function sepBy(combinator, separator) {
         }
         const next = combinator.parse(input, nextPos, ctx);
         if (!next.ok) {
-          rollbackTrivia(ctx, mark);
+          rollbackTrivia(ctx, loopMark);
           break;
         }
         values.push(next.value);
@@ -1306,13 +1308,15 @@ function annotateSpan(span, index) {
 
 // src/combinators/grammar.ts
 function parser(opts, root) {
+  const clearTrivia = opts.trivia === null;
   return {
     _tag: "grammar",
     _meta: root._meta,
     _def: {
       tag: "grammar",
       parser: root,
-      triviaParser: opts.trivia,
+      triviaParser: clearTrivia ? void 0 : opts.trivia ?? void 0,
+      clearTrivia,
       trackLines: opts.trackLines ?? false
     },
     parse(input, pos, _ctx) {
@@ -1320,7 +1324,11 @@ function parser(opts, root) {
       const ctx = {
         ..._ctx,
         trackLines,
-        ...opts.trivia !== void 0 ? {
+        // trivia: null clears (contiguous terms); a Combinator sets; undefined inherits.
+        ...clearTrivia ? {
+          trivia: void 0,
+          triviaKindLabels: void 0
+        } : opts.trivia != null ? {
           trivia: opts.trivia,
           ...opts.trivia._meta.triviaKindLabels ? { triviaKindLabels: opts.trivia._meta.triviaKindLabels } : {}
         } : {},
@@ -1335,6 +1343,9 @@ function parser(opts, root) {
     }
   };
 }
+function noTrivia(root) {
+  return parser({ trivia: null }, root);
+}
 function parse(combinator, input, opts = {}) {
   const trackLines = opts.trackLines ?? false;
   const _errors = opts.recover ? [] : void 0;
@@ -1673,6 +1684,41 @@ function v(ctx, prefix = "_v") {
 function ind(ctx) {
   return "  ".repeat(ctx.indent);
 }
+function reindentStmts(stmts, targetLevels) {
+  const nonEmpty = stmts.filter((s) => s.trim().length > 0);
+  if (nonEmpty.length === 0) return stmts;
+  const minLeading = Math.min(...nonEmpty.map((s) => s.length - s.trimStart().length));
+  const targetPrefix = "  ".repeat(targetLevels);
+  return stmts.map((s) => s.trim().length === 0 ? "" : targetPrefix + s.slice(minLeading));
+}
+function failReturn(expected, posExpr) {
+  return `return { ok: false, expected: [${expected}], span: { start: ${posExpr}, end: ${posExpr} } }`;
+}
+function failReturnArr(expectedArr, posExpr) {
+  return `return { ok: false, expected: ${expectedArr}, span: { start: ${posExpr}, end: ${posExpr} } }`;
+}
+function failBody(ctx, expected, posExpr) {
+  if (ctx.failLabel) return `break ${ctx.failLabel}`;
+  return failReturn(expected, posExpr);
+}
+function failArrBody(ctx, expectedArr, posExpr) {
+  if (ctx.failLabel) return `break ${ctx.failLabel}`;
+  return failReturnArr(expectedArr, posExpr);
+}
+function emitIfFail(ctx, cond, body) {
+  return [
+    `${ind(ctx)}if (${cond}) {`,
+    `${ind(ctx)}  ${body}`,
+    `${ind(ctx)}}`
+  ];
+}
+function emitElseFail(ctx, body) {
+  return [
+    `${ind(ctx)}else {`,
+    `${ind(ctx)}  ${body}`,
+    `${ind(ctx)}}`
+  ];
+}
 var NAMED_FN_FAIL = "_pfFail";
 var NAMED_FN_END = "_pfEnd";
 function namedFnPrelude() {
@@ -1683,8 +1729,10 @@ function pushNamedFnDecl(ctx, fnName, bodyStmts, valueVar, endVar) {
     `function ${fnName}(input, _pos, _ctx) {`,
     `  let _pfok = false, _pfv, _pfe = _pos`,
     `  _pfail: {`,
-    ...bodyStmts,
-    `  _pfv = ${valueVar}; _pfe = ${endVar}; _pfok = true`,
+    ...reindentStmts(bodyStmts, 2),
+    `    _pfv = ${valueVar}`,
+    `    _pfe = ${endVar}`,
+    `    _pfok = true`,
     `  }`,
     `  if (!_pfok) return ${NAMED_FN_FAIL}`,
     `  ${NAMED_FN_END} = _pfe`,
@@ -1698,7 +1746,7 @@ function emitNamedFnCall(ctx, fnName, pos, failExpected) {
   return {
     stmts: [
       `${ind(ctx)}const ${vv} = ${fnName}(input, ${pos}, _ctx)`,
-      `${ind(ctx)}if (${vv} === ${NAMED_FN_FAIL}) ${failStmt({ ...ctx, indent: 0 }, failExpected, pos).trim()}`,
+      ...emitIfFail(ctx, `${vv} === ${NAMED_FN_FAIL}`, failBody(ctx, failExpected, pos)),
       `${ind(ctx)}const ${ev} = ${NAMED_FN_END}`
     ],
     valueVar: vv,
@@ -1781,7 +1829,7 @@ function ensureTriviaFn(ctx) {
     `function ${fnName}(input, _pos, _ctx, _cap) {`,
     `  let _e = _pos`,
     `  _triv: {`,
-    ...r.stmts,
+    ...reindentStmts(r.stmts, 2),
     `    _e = ${r.endVar}`,
     `  }`,
     `  if (_cap && _e > _pos) {`,
@@ -1796,14 +1844,6 @@ function ensureTriviaFn(ctx) {
 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} } }`;
-}
-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";
@@ -1819,19 +1859,32 @@ function emitFallible(inner, ctx, pos) {
   const savedLabel = ctx.failLabel;
   const savedIndent = ctx.indent;
   ctx.failLabel = lbl;
-  ctx.indent = 0;
+  ctx.indent = savedIndent + 1;
   const r = emit(inner, ctx, pos);
   ctx.failLabel = savedLabel;
   ctx.indent = savedIndent;
   const ind0 = ind(ctx);
+  const mL = ctx.capturing ? v(ctx, "_fcl") : null;
+  const mR = ctx.capturing ? v(ctx, "_fcr") : null;
+  const mTl = ctx.capturing ? v(ctx, "_fctl") : null;
+  const mLg = ctx.capturing ? v(ctx, "_fclg") : null;
   const stmts = [
     `${ind0}let ${okV} = false, ${valV}, ${endV} = ${pos}`,
+    ...mL ? [
+      `${ind0}const ${mL} = _ctx._cstLeaves?.length ?? 0`,
+      `${ind0}const ${mR} = _ctx._cstRawChildren?.length ?? 0`,
+      `${ind0}const ${mTl} = _ctx._cstTriviaLog?.length ?? 0`,
+      `${ind0}const ${mLg} = _ctx._triviaLog?.length ?? 0`
+    ] : [],
     `${ind0}${lbl}: {`,
     ...r.stmts,
     `${ind0}  ${valV} = ${r.valueVar}`,
     `${ind0}  ${endV} = ${r.endVar}`,
     `${ind0}  ${okV} = true`,
-    `${ind0}}`
+    `${ind0}}`,
+    ...mL ? [
+      `${ind0}if (!${okV}) { if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${mL}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${mR}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${mTl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${mLg} }`
+    ] : []
   ];
   return { stmts, okVar: okV, valVar: valV, endVar: endV };
 }
@@ -1844,9 +1897,9 @@ function emitLit(def, ctx, pos) {
   if (caseInsensitive) {
     ctx.needsCollator = true;
     stmts.push(
-      `${ind(ctx)}if (${pos} + ${len} > input.length) ${failStmt({ ...ctx, indent: 0 }, expectedStr, pos).trim()}`,
+      ...emitIfFail(ctx, `${pos} + ${len} > input.length`, failBody(ctx, expectedStr, pos)),
       `${ind(ctx)}const ${vv}_s = input.slice(${pos}, ${pos} + ${len})`,
-      `${ind(ctx)}if (_collator.compare(${vv}_s, ${JSON.stringify(value)}) !== 0) ${failStmt({ ...ctx, indent: 0 }, expectedStr, pos).trim()}`,
+      ...emitIfFail(ctx, `_collator.compare(${vv}_s, ${JSON.stringify(value)}) !== 0`, failBody(ctx, expectedStr, pos)),
       `${ind(ctx)}const ${vv} = ${vv}_s`
     );
   } else if (len === 0) {
@@ -1854,7 +1907,7 @@ function emitLit(def, ctx, pos) {
   } else if (len === 1) {
     const code = value.codePointAt(0);
     stmts.push(
-      `${ind(ctx)}if (${pos} >= input.length || input.charCodeAt(${pos}) !== ${code}) ${failStmt({ ...ctx, indent: 0 }, expectedStr, pos).trim()}`,
+      ...emitIfFail(ctx, `${pos} >= input.length || input.charCodeAt(${pos}) !== ${code}`, failBody(ctx, expectedStr, pos)),
       `${ind(ctx)}const ${vv} = ${JSON.stringify(value)}`
     );
   } else if (len <= 4) {
@@ -1863,12 +1916,12 @@ function emitLit(def, ctx, pos) {
       (_, i) => `input.charCodeAt(${pos}${i > 0 ? ` + ${i}` : ""}) !== ${value.codePointAt(i)}`
     ).join(" || ");
     stmts.push(
-      `${ind(ctx)}if (${pos} + ${len} > input.length || ${checks}) ${failStmt({ ...ctx, indent: 0 }, expectedStr, pos).trim()}`,
+      ...emitIfFail(ctx, `${pos} + ${len} > input.length || ${checks}`, failBody(ctx, expectedStr, pos)),
       `${ind(ctx)}const ${vv} = ${JSON.stringify(value)}`
     );
   } else {
     stmts.push(
-      `${ind(ctx)}if (!input.startsWith(${JSON.stringify(value)}, ${pos})) ${failStmt({ ...ctx, indent: 0 }, expectedStr, pos).trim()}`,
+      ...emitIfFail(ctx, `!input.startsWith(${JSON.stringify(value)}, ${pos})`, failBody(ctx, expectedStr, pos)),
       `${ind(ctx)}const ${vv} = ${JSON.stringify(value)}`
     );
   }
@@ -1896,7 +1949,7 @@ function emitKeywords(def, ctx, pos) {
   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()}`,
+    ...emitIfFail(ctx, `${mv} === null`, failBody(ctx, '"keyword"', pos)),
     `${ind(ctx)}const ${vv} = ${mv}[0]`
   ];
   const endVar = `${pos} + ${vv}.length`;
@@ -1918,7 +1971,7 @@ function emitRegex(def, ctx, pos) {
   const stmts = [
     `${ind(ctx)}${rName}.lastIndex = ${pos}`,
     `${ind(ctx)}const ${mv} = ${rName}.exec(input)`,
-    `${ind(ctx)}if (${mv} === null) ${failStmt({ ...ctx, indent: 0 }, expectedStr, pos).trim()}`,
+    ...emitIfFail(ctx, `${mv} === null`, failBody(ctx, expectedStr, pos)),
     `${ind(ctx)}const ${vv} = ${mv}[0]`
   ];
   const endVar = `${pos} + ${vv}.length`;
@@ -1999,11 +2052,12 @@ function emitChoice(def, ctx, pos) {
       ctx.indent++;
       const r = emit(p, ctx, pos);
       stmts.push(...r.stmts);
-      stmts.push(`${ind(ctx)}${valV} = ${r.valueVar}; ${endV} = ${r.endVar}`);
+      stmts.push(`${ind(ctx)}${valV} = ${r.valueVar}`);
+      stmts.push(`${ind(ctx)}${endV} = ${r.endVar}`);
       ctx.indent--;
       stmts.push(`${ind(ctx)}}`);
     }
-    stmts.push(`${ind(ctx)}else ${failArr({ ...ctx, indent: 0 }, allExpected, pos)}`);
+    stmts.push(...emitElseFail(ctx, failArrBody(ctx, allExpected, pos)));
     return { stmts, valueVar: valV, endVar: endV };
   }
   return emitNonDisjoint(def, def.strategy, allExpected, ctx, pos);
@@ -2026,7 +2080,7 @@ function emitGreedyClassify(def, superIndex, allExpected, ctx, pos) {
   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)}`,
+    ...emitIfFail(ctx, `${matchV} === null`, failArrBody(ctx, allExpected, pos)),
     `${ind(ctx)}const ${wordV} = ${matchV}[0]`,
     `${ind(ctx)}const ${endV} = ${pos} + ${wordV}.length`,
     `${ind(ctx)}let ${valV}`
@@ -2075,12 +2129,13 @@ function emitLiteralsLongestFirst(def, sortedIndices, allExpected, ctx, pos) {
     stmts.push(
       ...emitLeafCapture(ctx, JSON.stringify(litVal), pos, litEnd),
       ...tR.stmts,
-      `${ind(ctx)}${valV} = ${tR.valueVar}; ${endV} = ${litEnd}`
+      `${ind(ctx)}${valV} = ${tR.valueVar}`,
+      `${ind(ctx)}${endV} = ${litEnd}`
     );
     ctx.indent--;
     stmts.push(`${ind(ctx)}}`);
   }
-  stmts.push(`${ind(ctx)}else ${failArr({ ...ctx, indent: 0 }, allExpected, pos)}`);
+  stmts.push(...emitElseFail(ctx, failArrBody(ctx, allExpected, pos)));
   return { stmts, valueVar: valV, endVar: endV };
 }
 function emitFirstMatch(def, allExpected, ctx, pos) {
@@ -2126,17 +2181,26 @@ function emitFirstMatch(def, allExpected, ctx, pos) {
       const rejectCond = autoNot.map(
         (check) => check.kind === "firstSet" ? firstSetCond(anCode, check.set) : `input.startsWith(${JSON.stringify(check.value)}, ${endVar})`
       ).join(" || ");
-      stmts.push(
-        `${ind0}  if (${okVar}) { const ${anCode} = ${endVar} < input.length ? input.charCodeAt(${endVar}) : -1; if (!(${rejectCond})) { ${resValV} = ${valVar}; ${resEndV} = ${endVar}; ${resOkV} = true } }`
-      );
+      stmts.push(`${ind0}  if (${okVar}) {`);
+      stmts.push(`${ind0}    const ${anCode} = ${endVar} < input.length ? input.charCodeAt(${endVar}) : -1`);
+      stmts.push(`${ind0}    if (!(${rejectCond})) {`);
+      stmts.push(`${ind0}      ${resValV} = ${valVar}`);
+      stmts.push(`${ind0}      ${resEndV} = ${endVar}`);
+      stmts.push(`${ind0}      ${resOkV} = true`);
+      stmts.push(`${ind0}    }`);
+      stmts.push(`${ind0}  }`);
       if (rollback) stmts.push(`${ind0}  if (!${resOkV}) { ${rollback} }`);
     } else {
-      stmts.push(`${ind0}  if (${okVar}) { ${resValV} = ${valVar}; ${resEndV} = ${endVar}; ${resOkV} = true }`);
+      stmts.push(`${ind0}  if (${okVar}) {`);
+      stmts.push(`${ind0}    ${resValV} = ${valVar}`);
+      stmts.push(`${ind0}    ${resEndV} = ${endVar}`);
+      stmts.push(`${ind0}    ${resOkV} = true`);
+      stmts.push(`${ind0}  }`);
       if (rollback) stmts.push(`${ind0}  else { ${rollback} }`);
     }
     stmts.push(`${ind0}}`);
   }
-  stmts.push(`${ind0}if (!${resOkV}) ${failArr({ ...ctx, indent: 0 }, allExpected, pos)}`);
+  stmts.push(...emitIfFail(ctx, `!${resOkV}`, failArrBody(ctx, allExpected, pos)));
   return { stmts, valueVar: resValV, endVar: resEndV };
 }
 function emitNonDisjoint(def, strategy, allExpected, ctx, pos) {
@@ -2261,32 +2325,26 @@ function emitSepBy(_p, def, ctx, pos) {
       const markV = v(ctx, "_mk");
       const markTl = v(ctx, "_mktl");
       const markLog = v(ctx, "_mklg");
+      const markLv = v(ctx, "_mklv");
       const spV = v(ctx, "_sp");
       stmts.push(
         `${ind(ctx)}const ${markV} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`,
         `${ind(ctx)}const ${markTl} = _ctx._cstTriviaLog ? _ctx._cstTriviaLog.length : 0`,
         `${ind(ctx)}const ${markLog} = _ctx._triviaLog ? _ctx._triviaLog.length : 0`,
+        `${ind(ctx)}const ${markLv} = _ctx._cstLeaves ? _ctx._cstLeaves.length : 0`,
         `${ind(ctx)}const ${spV} = ${capFn}(input, ${curV}, _ctx, 1)`
       );
       sepAtPos = spV;
-      const sepRollback = `if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${markLog}; `;
+      const rollbackToSep = `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${markLv}; 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");
+      stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${rollbackToSep}break }`);
       const npV = v(ctx, "_np");
-      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}; `;
+      stmts.push(`${ind(ctx)}const ${npV} = ${capFn}(input, ${sepEnd}, _ctx, 1)`);
       const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, npV);
       stmts.push(
         ...nextStmts,
-        `${ind(ctx)}if (!${nextOk}) { ${nextRollback}break }`,
+        // item failed → unwind the separator too, back to the end of the last item
+        `${ind(ctx)}if (!${nextOk}) { ${rollbackToSep}break }`,
         `${ind(ctx)}${arrV}.push(${nextVal})`,
         `${ind(ctx)}${curV} = ${nextEnd}`
       );
@@ -2308,12 +2366,21 @@ function emitSepBy(_p, def, ctx, pos) {
       );
     }
   } else {
+    const markLv = ctx.capturing ? v(ctx, "_mklv") : null;
+    const markRw = ctx.capturing ? v(ctx, "_mkrw") : null;
+    if (markLv) {
+      stmts.push(
+        `${ind(ctx)}const ${markLv} = _ctx._cstLeaves ? _ctx._cstLeaves.length : 0`,
+        `${ind(ctx)}const ${markRw} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`
+      );
+    }
     const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos);
     stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) break`);
+    const nextRb = markLv ? `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${markLv}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markRw}; ` : "";
     const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, sepEnd);
     stmts.push(
       ...nextStmts,
-      `${ind(ctx)}if (!${nextOk}) break`,
+      `${ind(ctx)}if (!${nextOk}) { ${nextRb}break }`,
       `${ind(ctx)}${arrV}.push(${nextVal})`,
       `${ind(ctx)}${curV} = ${nextEnd}`
     );
@@ -2357,12 +2424,12 @@ 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}) ${failArr({ ...ctx, indent: 0 }, expectedStr, pos)}`);
+    stmts.push(...emitIfFail(ctx, `!${foundV}`, failArrBody(ctx, 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);
+    const cap = reindentStmts(emitLeafCapture(ctx, valV, pos, curV), ctx.indent + 1);
     stmts.push(`${ind(ctx)}if (${curV} > ${pos}) {`, ...cap, `${ind(ctx)}}`);
   }
   return { stmts, valueVar: valV, endVar: curV };
@@ -2372,7 +2439,7 @@ function emitNot(def, ctx, pos) {
   return {
     stmts: [
       ...stmts,
-      `${ind(ctx)}if (${okVar}) ${failStmt({ ...ctx, indent: 0 }, '"not"', pos).trim()}`
+      ...emitIfFail(ctx, okVar, failBody(ctx, '"not"', pos))
     ],
     valueVar: "null",
     endVar: pos
@@ -2399,7 +2466,7 @@ function emitNode(def, ctx, pos) {
   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}; _ctx._cstTriviaLog = ${stl}`);
-  stmts.push(`${i}if (!${okVar}) ${failStmt({ ...ctx, indent: 0 }, '"node"', pos).trim()}`);
+  stmts.push(...emitIfFail(ctx, `!${okVar}`, failBody(ctx, '"node"', pos)));
   const stV = v(ctx, "_nst");
   stmts.push(`${i}const ${stV} = _ctx.state !== undefined ? Object.assign({}, _ctx.state) : undefined`);
   const ndV = v(ctx, "_nd");
@@ -2419,7 +2486,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) ${failStmt({ ...ctx, indent: 0 }, '"runtime"', pos).trim()}`,
+    ...emitIfFail(ctx, `!${rv}.ok`, failBody(ctx, '"runtime"', pos)),
     `${ind(ctx)}const ${vv} = ${rv}.value`,
     `${ind(ctx)}const ${ev} = ${rv}.span.end`
   ];
@@ -2453,16 +2520,14 @@ function emitRecover(def, ctx, pos) {
   const ind0 = ind(ctx);
   const scanV = v(ctx, "_sc");
   const errV = v(ctx, "_err");
-  const savedIndent = ctx.indent;
-  ctx.indent += 2;
+  const whileBodyLevels = 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,
+    ...reindentStmts(sentStmts, whileBodyLevels),
     `${ind0}    if (${sentOk}) break`,
     `${ind0}    ${scanV}++`,
     `${ind0}  }`,
@@ -2544,7 +2609,7 @@ function emit(p, ctx, pos) {
           // try skipped; if fails, keep main end
           `${ind(ctx)}let ${endV} = ${mainR.endVar}`,
           `${ind(ctx)}try {`,
-          ...skipR.stmts.map((s) => "  " + s),
+          ...reindentStmts(skipR.stmts, ctx.indent + 1),
           `${ind(ctx)}  ${endV} = ${skipR.endVar}`,
           `${ind(ctx)}} catch {}`
         ],
@@ -2561,7 +2626,10 @@ function emit(p, ctx, pos) {
     case "grammar": {
       const savedTrivia = ctx.activeTrivia;
       const savedKindLabels = ctx.triviaKindLabels;
-      if (def.triviaParser) {
+      if (def.clearTrivia) {
+        ctx.activeTrivia = void 0;
+        ctx.triviaKindLabels = void 0;
+      } else if (def.triviaParser) {
         ctx.activeTrivia = def.triviaParser;
         if (def.triviaParser._meta.triviaKindLabels) {
           ctx.triviaKindLabels = def.triviaParser._meta.triviaKindLabels;
@@ -2586,7 +2654,7 @@ function emit(p, ctx, pos) {
       const vv = v(ctx);
       return {
         stmts: [
-          `${ind(ctx)}if (!_mf[${fnIdx}](_ctx.state)) ${failStmt({ ...ctx, indent: 0 }, '"gate"', pos).trim()}`,
+          ...emitIfFail(ctx, `!_mf[${fnIdx}](_ctx.state)`, failBody(ctx, '"gate"', pos)),
           `${ind(ctx)}const ${vv} = null`
         ],
         valueVar: vv,
@@ -2618,7 +2686,7 @@ function emit(p, ctx, pos) {
         stmts: [
           `${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()}`,
+          ...emitIfFail(ctx, `${vv} === ${NAMED_FN_FAIL}`, failBody(ctx, '"withCtx"', pos)),
           `${ind(ctx)}const ${ev} = ${NAMED_FN_END}`
         ],
         valueVar: vv,
@@ -2695,7 +2763,7 @@ function compile(combinator, mapFnSources) {
     ...ctx.regexDecls,
     "",
     ...namedPrelude,
-    ...ctx.namedFnDecls,
+    ctx.namedFnDecls.join("\n\n"),
     `${collatorDecl}function _parse(input, _pos, _rp, _mf, _build, _ctx) {`,
     `  let pos = _pos`,
     ...r.stmts,
@@ -2706,7 +2774,7 @@ function compile(combinator, mapFnSources) {
     ...ctx.regexDecls,
     collatorDecl,
     ...namedPrelude,
-    ...ctx.namedFnDecls,
+    ...ctx.namedFnDecls.flatMap((decl, i) => i > 0 ? ["", decl] : [decl]),
     `let pos = _pos`,
     ...r.stmts,
     `return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`
@@ -2741,7 +2809,7 @@ function compile(combinator, mapFnSources) {
 function buildInlineExpression(ctx, r, collatorDecl, mapFnSources, buildSources) {
   const bodyLines = [
     `  let pos = _pos`,
-    ...r.stmts.map((s) => `  ${s}`),
+    ...r.stmts,
     `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`
   ];
   const innerFn = [
@@ -2754,17 +2822,23 @@ function buildInlineExpression(ctx, r, collatorDecl, mapFnSources, buildSources)
   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__ */ (() => {`,
+  const hoistedDecls = [
     ...ctx.regexDecls.map((d) => `  ${d}`),
     collatorDecl ? `  ${collatorDecl.trim()}` : "",
     mfDecl,
     buildDecl,
     ...namedPrelude.map((l) => `  ${l}`),
-    ...ctx.namedFnDecls.flatMap((f) => f.split("\n").map((l) => `  ${l}`)),
+    ...ctx.namedFnDecls.flatMap((decl, i) => {
+      const lines = decl.split("\n").map((l) => `  ${l}`);
+      return i > 0 ? ["", ...lines] : lines;
+    })
+  ].filter(Boolean);
+  return [
+    `/* @__PURE__ */ (() => {`,
+    ...hoistedDecls,
     `  return ${innerFn}`,
     `})()`
-  ].filter(Boolean).join("\n");
+  ].join("\n");
 }
 
 // src/combinators/guard.ts