parseman 0.50.6 → 0.51.0

package/dist/table/assemble.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assemble.d.ts","sourceRoot":"","sources":["../../src/table/assemble.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"assemble.d.ts","sourceRoot":"","sources":["../../src/table/assemble.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AACH,OAAO,KAAK,EAAE,UAAU,EAAsB,YAAY,EAA0B,MAAM,aAAa,CAAA;AAyCvG;;;;;;;;;;;;;GAaG;AACH,OAAO,EAGL,KAAK,cAAc,EAAsB,KAAK,aAAa,EAC1C,KAAK,YAAY,EAAE,KAAK,SAAS,EACnD,MAAM,cAAc,CAAA;AA4ErB;;;;;;;;;;;;;GAaG;AACH,KAAK,KAAK,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,KAAK,OAAO,CAAA;AA+CvE;;;;;;;;GAQG;AACH,MAAM,MAAM,MAAM,GAAG;IACnB,6EAA6E;IAC7E,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB;;;;OAIG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAA;IACpC;;;;;OAKG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,SAAS,CAAA;IACpE,+EAA+E;IAC/E,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;IAC5B;;;;;;;;;;;;;;;;;OAiBG;IACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAC1B;;;;;;;;;;;;;;;;;OAiBG;IACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAC1B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;CACxB,CAAA;AAiBD,+CAA+C;AAC/C,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAExC;AAED,MAAM,MAAM,QAAQ,GAAG;IACrB,qDAAqD;IACrD,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAA;IAChD,QAAQ,CAAC,GAAG,EAAE,MAAM,MAAM,CAAA;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,EAAE,YAAY,KAAK,IAAI,CAAA;IAC3C,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,EAAE,MAAM,IAAI,CAAA;IAC3B,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC,SAAS,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE,CAAA;IAC9D;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IACrC;;;;;;;;OAQG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAA;CACzC,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,GAAG,QAAQ,CA+7GpF;AAED;;;;;;;;;;GAUG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAe;IACjC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAc;IACnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA0D;IAChF;;;;;;OAMG;IACH,OAAO,CAAC,aAAa,CAAyC;IAC9D,OAAO,CAAC,cAAc,CAAyC;IAE/D,YAAY,IAAI,EAAE,YAAY,EAAE,QAAQ,GAAE,aAAkC,EAG3E;IAED,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CASzB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;IACH,MAAM,CAAC,GAAG,EAAE,YAAY,GAAG,QAAQ,CAkClC;CACF;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,YAAY,GAAG,cAAc,EACrC,gBAAgB,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAM,GACvD,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAgD3B"}

package/dist/table/emit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../../src/table/emit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAG/D,OAAO,EAAU,KAAK,MAAM,EAAE,MAAM,eAAe,CAAA;AAyHnD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,EAAE,CAMhE;AAkFD,MAAM,MAAM,WAAW,GAAG;IACxB,oCAAoC;IACpC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;IACtB;;;;;;;OAOG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACvC;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACtC,8CAA8C;IAC9C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;IACzB;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAC7B,CAAA;AAmED,wBAAgB,eAAe,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,GAAE,WAAgB,GAAG,MAAM,CAYlF;AAED,MAAM,MAAM,qBAAqB,GAAG,WAAW,GAAG;IAChD;;;;;;;;OAQG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,4EAA4E;IAC5E,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CACjC,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,GAAE,qBAA0B,GAAG,MAAM,CAWhG;AAED,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG;IAC5C;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAClD,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,aAAa,EAAE,IAAI,GAAE,iBAAsB,GAAG,MAAM,CA0B5F;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAExD"}
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../../src/table/emit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAG/D,OAAO,EAAU,KAAK,MAAM,EAAE,MAAM,eAAe,CAAA;AA2HnD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,EAAE,CAMhE;AAoFD,MAAM,MAAM,WAAW,GAAG;IACxB,oCAAoC;IACpC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;IACtB;;;;;;;OAOG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACvC;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACtC,8CAA8C;IAC9C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;IACzB;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAC7B,CAAA;AAmED,wBAAgB,eAAe,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,GAAE,WAAgB,GAAG,MAAM,CAYlF;AAED,MAAM,MAAM,qBAAqB,GAAG,WAAW,GAAG;IAChD;;;;;;;;OAQG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,4EAA4E;IAC5E,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CACjC,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,GAAE,qBAA0B,GAAG,MAAM,CAWhG;AAED,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG;IAC5C;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAClD,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,aAAa,EAAE,IAAI,GAAE,iBAAsB,GAAG,MAAM,CA0B5F;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAExD"}

package/dist/table/encode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../src/table/encode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgB,UAAU,EAAuB,MAAM,aAAa,CAAA;AAwBhF,OAAO,KAAK,EAAmE,YAAY,EAAc,MAAM,cAAc,CAAA;AAS7H,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAA;AA0B9E,8EAA8E;AAC9E,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,YAAY,GAAG,EAAE,MAAM,EAAqE;CAC7F;AAED,8EAA8E;AAC9E,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,KAAK,GAAG,KAAK,CAAA;IACjC,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAA;IAC7B;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAC3B;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,mBAAmB,CAAA;CACxC,CAAA;AAutDD,wBAAgB,WAAW,CACzB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,EAC5C,QAAQ,GAAE,aAAkB,GAC3B,YAAY,CAEd;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,EAC5C,QAAQ,GAAE,aAAkB,GAC3B;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,MAAM,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAA;CAAE,CA+BnD"}
+{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../src/table/encode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgB,UAAU,EAAuB,MAAM,aAAa,CAAA;AAwBhF,OAAO,KAAK,EAAmE,YAAY,EAAc,MAAM,cAAc,CAAA;AAS7H,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAA;AA0B9E,8EAA8E;AAC9E,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,YAAY,GAAG,EAAE,MAAM,EAAqE;CAC7F;AAED,8EAA8E;AAC9E,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,KAAK,GAAG,KAAK,CAAA;IACjC,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAA;IAC7B;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAC3B;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,mBAAmB,CAAA;CACxC,CAAA;AA+tDD,wBAAgB,WAAW,CACzB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,EAC5C,QAAQ,GAAE,aAAkB,GAC3B,YAAY,CAEd;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,EAC5C,QAAQ,GAAE,aAAkB,GAC3B;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,MAAM,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAA;CAAE,CA+BnD"}

package/dist/table/exec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exec.d.ts","sourceRoot":"","sources":["../../src/table/exec.ts"],"names":[],"mappings":"AA6CA,OAAO,EAEL,KAAK,cAAc,EACF,KAAK,YAAY,EAAE,KAAK,SAAS,EACnD,MAAM,cAAc,CAAA;AA0BrB;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,EAAE;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,UAAU,CAAA;IAChB,+EAA+E;IAC/E,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC,CAAA;IAChC;;;;;;;;;;;OAWG;IACH,cAAc,EAAE,MAAM,CAAA;IACtB,YAAY,EAAE,MAAM,CAAA;IACpB,sFAAsF;IACtF,eAAe,EAAE,MAAM,CAAA;IACvB,YAAY,EAAE,MAAM,CAAA;IACpB,qFAAqF;IACrF,YAAY,EAAE,MAAM,CAAA;CAC+H,CAAA;AAUrJ,wBAAgB,kBAAkB,IAAI,IAAI,CASzC;AA4jDD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,YAAY,GAAG,cAAc;AACrC;;;;;;;;GAQG;AACH,IAAI,GAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAO,EACjC,gBAAgB,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAM,GACvD,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CA8B3B"}
+{"version":3,"file":"exec.d.ts","sourceRoot":"","sources":["../../src/table/exec.ts"],"names":[],"mappings":"AA6CA,OAAO,EAEL,KAAK,cAAc,EACF,KAAK,YAAY,EAAE,KAAK,SAAS,EACnD,MAAM,cAAc,CAAA;AA0BrB;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,EAAE;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,UAAU,CAAA;IAChB,+EAA+E;IAC/E,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC,CAAA;IAChC;;;;;;;;;;;OAWG;IACH,cAAc,EAAE,MAAM,CAAA;IACtB,YAAY,EAAE,MAAM,CAAA;IACpB,sFAAsF;IACtF,eAAe,EAAE,MAAM,CAAA;IACvB,YAAY,EAAE,MAAM,CAAA;IACpB,qFAAqF;IACrF,YAAY,EAAE,MAAM,CAAA;CAC+H,CAAA;AAUrJ,wBAAgB,kBAAkB,IAAI,IAAI,CASzC;AAkkDD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,YAAY,GAAG,cAAc;AACrC;;;;;;;;GAQG;AACH,IAAI,GAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAO,EACjC,gBAAgB,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAM,GACvD,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CA8B3B"}

package/dist/table/index.js

@@ -1,12 +1,12 @@
 // src/combinators/first-set.ts
-function classifyFinalChoice(arms, resolve) {
+function classifyFinalChoice(arms, resolve, activeTrivia) {
   const firstSets = [];
   const nullable2 = [];
   let exclusive = true;
   for (const arm of arms) {
     const empty2 = matchesEmpty(arm, /* @__PURE__ */ new Set(), resolve);
     nullable2.push(empty2);
-    firstSets.push(empty2 ? { kind: "any" } : firstSetOf(arm, /* @__PURE__ */ new Set(), resolve));
+    firstSets.push(empty2 ? { kind: "any" } : firstSetOf(arm, /* @__PURE__ */ new Set(), resolve, activeTrivia));
     if (empty2) exclusive = false;
   }
   if (exclusive) {
@@ -67,7 +67,7 @@ function intersects(a, b) {
   return false;
 }
 function fromChar(code) {
-  return { kind: "ranges", ranges: [{ lo: code, hi: code }] };
+  return fromRange(code, code);
 }
 function startsFirstSet(combinator, input, pos) {
   const fs = combinator._meta.firstSet;
@@ -160,11 +160,10 @@ function matchesEmptyBody(p, seen, resolve) {
   }
 }
 function isZeroWidthAssertion(p) {
-  const tag = p._def.tag;
-  return tag === "not" || tag === "adjacency";
+  return p._tag === "not" || p._tag === "adjacency";
 }
 function isPositiveLookahead(p) {
-  return p._def.tag === "peek";
+  return p._tag === "peek";
 }
 function narrowBy(acc, constraint) {
   if (constraint.kind === "any") return acc;
@@ -180,34 +179,42 @@ function narrowBy(acc, constraint) {
   return ranges.length === 0 ? { kind: "empty" } : { kind: "ranges", ranges };
 }
 function applyAssertion(fs, assertion) {
-  if (assertion === null) return fs;
-  if (fs.kind === "empty") return assertion;
-  return narrowBy(fs, assertion) ?? fs;
+  return assertion === null ? fs : fs.kind === "empty" ? assertion : narrowBy(fs, assertion);
 }
-function sequenceFirstSet(parsers) {
-  let fs = empty();
-  let assertion = null;
-  for (const p of parsers) {
+function sequenceSet(parsers, fs, empties, trivia2) {
+  const afterBoundary = (i) => {
+    const rest = at(i);
+    return trivia2 ? union(rest, fs(trivia2)) : rest;
+  };
+  const at = (i) => {
+    const p = parsers[i];
     if (isPositiveLookahead(p)) {
-      assertion = narrowBy(assertion, p._meta.firstSet);
-      continue;
+      const constraint = fs(p);
+      return i + 1 === parsers.length ? constraint : applyAssertion(afterBoundary(i + 1), constraint);
     }
-    if (!isZeroWidthAssertion(p)) fs = union(fs, p._meta.firstSet);
-    if (!matchesEmpty(p)) return applyAssertion(fs, assertion);
-  }
-  return applyAssertion(fs, assertion);
+    if (isZeroWidthAssertion(p)) {
+      return i + 1 === parsers.length ? empty() : afterBoundary(i + 1);
+    }
+    const first = fs(p);
+    if (!empties(p) || i + 1 === parsers.length) return first;
+    return union(first, afterBoundary(i + 1));
+  };
+  return at(0);
+}
+function sequenceFirstSet(parsers) {
+  return sequenceSet(parsers, (p) => p._meta.firstSet, matchesEmpty);
 }
-function firstSetOf(p, seen = /* @__PURE__ */ new Set(), resolve) {
+function firstSetOf(p, seen = /* @__PURE__ */ new Set(), resolve, activeTrivia) {
   if (seen.has(p)) return any();
   seen.add(p);
   try {
-    return firstSetBody(p, seen, resolve);
+    return firstSetBody(p, seen, resolve, activeTrivia);
   } finally {
     seen.delete(p);
   }
 }
-function firstSetBody(p, seen, resolve) {
-  const fs = (c) => firstSetOf(c, seen, resolve);
+function firstSetBody(p, seen, resolve, activeTrivia) {
+  const fs = (c) => firstSetOf(c, seen, resolve, activeTrivia);
   const empties = (c) => matchesEmpty(c, /* @__PURE__ */ new Set(), resolve);
   const d = p._def;
   switch (d.tag) {
@@ -233,17 +240,7 @@ function firstSetBody(p, seen, resolve) {
       return out;
     }
     case "sequence": {
-      let out = empty();
-      let assertion = null;
-      for (const term of d.parsers) {
-        if (isPositiveLookahead(term)) {
-          assertion = narrowBy(assertion, fs(term));
-          continue;
-        }
-        if (!isZeroWidthAssertion(term)) out = union(out, fs(term));
-        if (!empties(term)) return applyAssertion(out, assertion);
-      }
-      return applyAssertion(out, assertion);
+      return sequenceSet(d.parsers, fs, empties, activeTrivia);
     }
     case "peek": {
       const inner = d.parser;
@@ -258,12 +255,16 @@ function firstSetBody(p, seen, resolve) {
     case "token":
     case "leaf":
     case "node":
-    case "grammar":
-    case "expect":
-      return fs(d.parser);
     case "sepBy":
+    case "expect":
       return fs(d.parser);
-    // both min 0 and min 1 start with the item
+    case "grammar":
+      return firstSetOf(
+        d.parser,
+        seen,
+        resolve,
+        d.clearTrivia ? null : d.triviaParser ?? activeTrivia
+      );
     default:
       return p._meta.firstSet;
   }
@@ -3499,7 +3500,7 @@ function resolveScanSkip(explicitSkip, raw, ctx) {
   out.push(...explicitSkip);
   return out;
 }
-function scanTo(sentinel, { skip, raw = false, orEOF = false } = {}) {
+function scanTo(sentinel, { skip, raw = false, orEOF = false, recoverAt, stopAt } = {}) {
   const meta = {
     firstSet: any(),
     canMatchNewline: true,
@@ -3509,7 +3510,15 @@ function scanTo(sentinel, { skip, raw = false, orEOF = false } = {}) {
   return {
     _tag: "scanTo",
     _meta: meta,
-    _def: { tag: "scanTo", sentinel, skip: explicitSkip, raw, orEOF },
+    _def: {
+      tag: "scanTo",
+      sentinel,
+      skip: explicitSkip,
+      raw,
+      orEOF,
+      ...recoverAt === void 0 ? {} : { recoverAt },
+      ...stopAt === void 0 ? {} : { stopAt }
+    },
     parse(input, pos, ctx) {
       let cur = pos;
       const skip2 = resolveScanSkip(explicitSkip, raw, ctx);
@@ -3521,28 +3530,130 @@ function scanTo(sentinel, { skip, raw = false, orEOF = false } = {}) {
           pushCstLeaf(ctx, leaf);
         }
       };
-      while (cur < input.length) {
-        const s = sentinel.parse(input, cur, probeCtx);
-        if (s.ok) {
+      if (recoverAt === void 0 && stopAt === void 0) {
+        while (cur < input.length) {
+          const s = sentinel.parse(input, cur, probeCtx);
+          if (s.ok) {
+            if (ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, cur);
+            emit(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, probeCtx);
+            if (r.ok && r.span.end > cur) {
+              cur = r.span.end;
+              advanced = true;
+              break;
+            }
+          }
+          if (!advanced) cur++;
+        }
+        if (orEOF) {
           if (ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, cur);
           emit(cur);
           return { ok: true, value: input.slice(pos, cur), span: { start: pos, end: cur } };
         }
+        const sentDef2 = sentinel._def;
+        const expected2 = sentDef2.tag === "literal" ? [JSON.stringify(sentDef2.value)] : ["sentinel"];
+        return { ok: false, expected: expected2, span: { start: pos, end: cur } };
+      }
+      let recovery = -1;
+      let firstSentinel = -1;
+      let sentinelCount = 0;
+      let recoveryErrorCount = -1;
+      let sentinelErrorCount = -1;
+      const succeed = (end) => {
+        if (ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, end);
+        emit(end);
+        return { ok: true, value: input.slice(pos, end), span: { start: pos, end } };
+      };
+      const recoveredEnd = () => {
+        const acceptSentinel = firstSentinel >= 0 && (sentinelCount & 1) === 1;
+        const errors = ctx._errors;
+        if (errors !== void 0) {
+          const keep = acceptSentinel ? sentinelErrorCount : recoveryErrorCount;
+          if (keep >= 0 && errors.length > keep) errors.length = keep;
+        }
+        return acceptSentinel ? firstSentinel : recovery;
+      };
+      while (cur < input.length) {
+        const sentinelProbeErrorCount = ctx._errors?.length ?? -1;
+        const s = sentinel.parse(input, cur, probeCtx);
+        const sentinelProbeErrors = ctx._errors;
+        if (sentinelProbeErrors !== void 0 && sentinelProbeErrorCount >= 0 && sentinelProbeErrors.length > sentinelProbeErrorCount) {
+          sentinelProbeErrors.length = sentinelProbeErrorCount;
+        }
+        if (s.ok) {
+          if (recovery < 0) return succeed(cur);
+          if (s.span.end <= cur) {
+            throw new TypeError("scanTo recovery requires a sentinel that consumes input");
+          }
+          if (firstSentinel < 0) {
+            firstSentinel = cur;
+            sentinelErrorCount = sentinelProbeErrorCount;
+          }
+          sentinelCount++;
+          cur = s.span.end;
+          continue;
+        }
+        if (stopAt !== void 0) {
+          const errorCount = ctx._errors?.length ?? -1;
+          const stop = stopAt.parse(input, cur, probeCtx);
+          const errors = ctx._errors;
+          if (errors !== void 0 && errorCount >= 0 && errors.length > errorCount) {
+            errors.length = errorCount;
+          }
+          if (stop.ok) {
+            if (recovery < 0) {
+              recovery = cur;
+              recoveryErrorCount = errorCount;
+            }
+            return succeed(recoveredEnd());
+          }
+        }
         let advanced = false;
         for (const skipper of skip2) {
+          const errorCount = ctx._errors?.length ?? -1;
           const r = skipper.parse(input, cur, probeCtx);
           if (r.ok && r.span.end > cur) {
             cur = r.span.end;
             advanced = true;
             break;
           }
+          const errors = ctx._errors;
+          if (errors !== void 0 && errorCount >= 0 && errors.length > errorCount) {
+            errors.length = errorCount;
+          }
         }
-        if (!advanced) cur++;
+        if (advanced) continue;
+        if (recoverAt !== void 0) {
+          const errorCount = ctx._errors?.length ?? -1;
+          const recover = recoverAt.parse(input, cur, probeCtx);
+          const errors = ctx._errors;
+          if (errors !== void 0 && errorCount >= 0 && errors.length > errorCount) {
+            errors.length = errorCount;
+          }
+          if (recover.ok) {
+            if (recover.span.end <= cur) {
+              throw new TypeError("scanTo recoverAt must consume input");
+            }
+            if (recovery < 0) {
+              recovery = cur;
+              recoveryErrorCount = errorCount;
+            }
+            if (firstSentinel >= 0 && (sentinelCount & 1) === 1) {
+              return succeed(recoveredEnd());
+            }
+            cur = recover.span.end;
+            continue;
+          }
+        }
+        cur++;
       }
+      if (recovery >= 0) return succeed(recoveredEnd());
       if (orEOF) {
-        if (ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, cur);
-        emit(cur);
-        return { ok: true, value: input.slice(pos, cur), span: { start: pos, end: cur } };
+        return succeed(cur);
       }
       const sentDef = sentinel._def;
       const expected = sentDef.tag === "literal" ? [JSON.stringify(sentDef.value)] : ["sentinel"];
@@ -3919,7 +4030,7 @@ function parserHasOwnFields(p, seen = /* @__PURE__ */ new Set()) {
     case "grammar":
       return parserHasOwnFields(d.parser, seen) || (d.triviaParser ? parserHasOwnFields(d.triviaParser, seen) : false);
     case "scanTo":
-      return parserHasOwnFields(d.sentinel, seen) || d.skip.some((x) => parserHasOwnFields(x, seen));
+      return parserHasOwnFields(d.sentinel, seen) || d.skip.some((x) => parserHasOwnFields(x, seen)) || d.recoverAt !== void 0 && parserHasOwnFields(d.recoverAt, seen) || d.stopAt !== void 0 && parserHasOwnFields(d.stopAt, seen);
     case "recover":
       return parserHasOwnFields(d.parser, seen) || parserHasOwnFields(d.sentinel, seen);
     case "routed":
@@ -3973,7 +4084,7 @@ function parserUsesRouted(parser, seen = /* @__PURE__ */ new Set()) {
     case "grammar":
       return parserUsesRouted(def.parser, seen) || (def.triviaParser ? parserUsesRouted(def.triviaParser, seen) : false);
     case "scanTo":
-      return parserUsesRouted(def.sentinel, seen) || def.skip.some((entry) => parserUsesRouted(entry, seen));
+      return parserUsesRouted(def.sentinel, seen) || def.skip.some((entry) => parserUsesRouted(entry, seen)) || def.recoverAt !== void 0 && parserUsesRouted(def.recoverAt, seen) || def.stopAt !== void 0 && parserUsesRouted(def.stopAt, seen);
     case "recover":
       return parserUsesRouted(def.parser, seen) || parserUsesRouted(def.sentinel, seen);
     case "lazy":
@@ -8247,6 +8358,8 @@ function assemble(t, prog, cfg) {
   for (const s of prog.scans ?? []) {
     for (const r of s.skip) labelExtraIps.push(r[0]);
     if (s.sentinel !== void 0) labelExtraIps.push(s.sentinel[0]);
+    if (s.recoverAt !== void 0) labelExtraIps.push(s.recoverAt[0]);
+    if (s.stopAt !== void 0) labelExtraIps.push(s.stopAt[0]);
   }
   for (const set of prog.scanSkip ?? []) for (const r of set) labelExtraIps.push(r[0]);
   const closureLabels = computeSiteLabels(
@@ -10932,6 +11045,8 @@ function assemble(t, prog, cfg) {
     for (const s of prog.scans ?? []) {
       for (const r of s.skip) extraIps.push(r[0]);
       if (s.sentinel !== void 0) extraIps.push(s.sentinel[0]);
+      if (s.recoverAt !== void 0) extraIps.push(s.recoverAt[0]);
+      if (s.stopAt !== void 0) extraIps.push(s.stopAt[0]);
     }
     for (const set of prog.scanSkip ?? []) for (const r of set) extraIps.push(r[0]);
     const roots = [...Object.values(prog.rules), ...extraIps];
@@ -11143,7 +11258,13 @@ function assemble(t, prog, cfg) {
       continue;
     }
     const sentDef = typeof s.sent === "string" ? { tag: "literal", value: s.sent, caseInsensitive: false } : void 0;
-    scansArr.push(scanTo(subtreeComb(s.sentinel, sentDef), { skip, raw, orEOF: (s.flags & 2) !== 0 }));
+    scansArr.push(scanTo(subtreeComb(s.sentinel, sentDef), {
+      skip,
+      raw,
+      orEOF: (s.flags & 2) !== 0,
+      ...s.recoverAt === void 0 ? {} : { recoverAt: subtreeComb(s.recoverAt) },
+      ...s.stopAt === void 0 ? {} : { stopAt: subtreeComb(s.stopAt) }
+    }));
   }
   const scans = scansArr;
   const scanSkip = (prog.scanSkip ?? []).map((set) => set.map((r) => subtreeComb(r)));
@@ -11336,7 +11457,12 @@ function childrenOf(d) {
     case "recover":
       return [d.parser, d.sentinel];
     case "scanTo":
-      return [d.sentinel, ...d.skip];
+      return [
+        d.sentinel,
+        ...d.skip,
+        ...d.recoverAt === void 0 ? [] : [d.recoverAt],
+        ...d.stopAt === void 0 ? [] : [d.stopAt]
+      ];
     case "grammar":
       return d.triviaParser ? [d.parser, d.triviaParser] : [d.parser];
     case "routed":
@@ -11607,7 +11733,7 @@ function hasNodeDef(p, seen = /* @__PURE__ */ new Set()) {
     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));
+      return hasNodeDef(d.sentinel, seen) || d.skip.some((x) => hasNodeDef(x, seen)) || d.recoverAt !== void 0 && hasNodeDef(d.recoverAt, seen) || d.stopAt !== void 0 && hasNodeDef(d.stopAt, seen);
     case "recover":
       return hasNodeDef(d.parser, seen) || hasNodeDef(d.sentinel, seen);
     case "expect":
@@ -11656,7 +11782,7 @@ function hasDirectBuildDef(p, seen = /* @__PURE__ */ new Set()) {
     case "sepBy":
       return hasDirectBuildDef(d.parser, seen) || hasDirectBuildDef(d.separator, seen);
     case "scanTo":
-      return hasDirectBuildDef(d.sentinel, seen) || d.skip.some((x) => hasDirectBuildDef(x, seen));
+      return hasDirectBuildDef(d.sentinel, seen) || d.skip.some((x) => hasDirectBuildDef(x, seen)) || d.recoverAt !== void 0 && hasDirectBuildDef(d.recoverAt, seen) || d.stopAt !== void 0 && hasDirectBuildDef(d.stopAt, seen);
     case "recover":
       return hasDirectBuildDef(d.parser, seen) || hasDirectBuildDef(d.sentinel, seen);
     case "routed":
@@ -11693,7 +11819,7 @@ function mayCommitFailure(p, seen = /* @__PURE__ */ new Set(), resolve) {
     case "withCtx":
       return mayCommitFailure(d.parser, seen, resolve);
     case "scanTo":
-      return mayCommitFailure(d.sentinel, seen, resolve) || d.skip.some((x) => mayCommitFailure(x, seen, resolve));
+      return mayCommitFailure(d.sentinel, seen, resolve) || d.skip.some((x) => mayCommitFailure(x, seen, resolve)) || d.recoverAt !== void 0 && mayCommitFailure(d.recoverAt, seen, resolve) || d.stopAt !== void 0 && mayCommitFailure(d.stopAt, seen, resolve);
     case "lazy": {
       try {
         return mayCommitFailure(d.thunk(), seen, resolve);
@@ -12471,7 +12597,9 @@ var Encoder = class {
   followClass(parsers, i) {
     let fs = { kind: "empty" };
     const rr = this.refResolver();
-    for (let j = i + 1; j < parsers.length; j++) fs = union(fs, firstSetOf(parsers[j], /* @__PURE__ */ new Set(), rr));
+    for (let j = i + 1; j < parsers.length; j++) {
+      fs = union(fs, firstSetOf(parsers[j], /* @__PURE__ */ new Set(), rr, this.activeTrivia));
+    }
     return this.charClass(fs);
   }
   constant(v) {
@@ -12688,7 +12816,7 @@ var Encoder = class {
    */
   subtree(c) {
     const ip = this.node(c).ip;
-    const fs = firstSetOf(c, /* @__PURE__ */ new Set(), this.refResolver());
+    const fs = firstSetOf(c, /* @__PURE__ */ new Set(), this.refResolver(), this.activeTrivia);
     return [ip, fs.kind === "empty" ? -2 : this.charClass(fs)];
   }
   /** Pool one scan spec. One per combinator: `node()` memoizes by identity. */
@@ -12834,6 +12962,8 @@ var Encoder = class {
         flags: (d.raw ? 1 : 0) | (d.orEOF ? 2 : 0),
         skip: d.skip.map((c) => this.subtree(c)),
         sentinel: this.subtree(d.sentinel),
+        ...d.recoverAt === void 0 ? {} : { recoverAt: this.subtree(d.recoverAt) },
+        ...d.stopAt === void 0 ? {} : { stopAt: this.subtree(d.stopAt) },
         sent: sentDef.tag === "literal" ? sentDef.value : null
       }));
     }
@@ -12907,12 +13037,12 @@ var Encoder = class {
           return this.covWrap(gated, armCovIds?.[src], 1);
         });
         const rr = this.refResolver();
-        const finalChoice = classifyFinalChoice(arms, rr);
+        const finalChoice = classifyFinalChoice(arms, rr, this.activeTrivia);
         const transactionalFirst = arms.map((arm, i) => {
           if (!finalChoice.nullable[i]) return void 0;
           const def = arm._def;
           if (def.tag !== "attempt" || matchesEmpty(def.parser, /* @__PURE__ */ new Set(), rr)) return void 0;
-          return firstSetOf(def.parser, /* @__PURE__ */ new Set(), rr);
+          return firstSetOf(def.parser, /* @__PURE__ */ new Set(), rr, this.activeTrivia);
         });
         const gateFirst = finalChoice.firstSets.map((first, i) => transactionalFirst[i] ?? first);
         const classes = gateFirst.map((first, i) => finalChoice.nullable[i] && transactionalFirst[i] === void 0 ? -1 : this.charClass(first));
@@ -12959,7 +13089,7 @@ var Encoder = class {
       case "oneOrMore": {
         const child = this.node(d.parser).ip;
         const rr = this.refResolver();
-        const itemClass = matchesEmpty(d.parser, /* @__PURE__ */ new Set(), rr) ? -1 : this.existingCharClass(firstSetOf(d.parser, /* @__PURE__ */ new Set(), rr));
+        const itemClass = matchesEmpty(d.parser, /* @__PURE__ */ new Set(), rr) ? -1 : this.existingCharClass(firstSetOf(d.parser, /* @__PURE__ */ new Set(), rr, this.activeTrivia));
         const op = d.valueUnused ? OP_REPV : OP_REP;
         const min = d.tag === "many" ? 0 : d.min;
         return this.rec ? this.emit(op, child, min, d.max ?? -1, -1, 0, this.expected(deriveExpected(d.parser)), itemClass) : this.emit(op, child, min, d.max ?? -1, -1, 0);
@@ -12977,7 +13107,7 @@ var Encoder = class {
             sep,
             flags,
             this.expected(deriveExpected(d.parser)),
-            this.charClass(firstSetOf(d.separator, /* @__PURE__ */ new Set(), this.refResolver()))
+            this.charClass(firstSetOf(d.separator, /* @__PURE__ */ new Set(), this.refResolver(), this.activeTrivia))
           );
         }
         return d.min >= 2 ? this.emit(OP_REP, child, d.min, d.max ?? -1, sep, flags, this.expected(deriveExpected(d.parser))) : this.emit(OP_REP, child, d.min, d.max ?? -1, sep, flags);
@@ -13032,7 +13162,7 @@ var Encoder = class {
           d.tags === void 0 ? -1 : this.constant(d.tags)
         );
         if (matchesEmpty(d.parser)) return body;
-        const fs = d.parser._def.tag === "lazy" ? firstSetOf(d.parser, /* @__PURE__ */ new Set(), this.refResolver()) : d.parser._meta.firstSet;
+        const fs = d.parser._def.tag === "lazy" ? firstSetOf(d.parser, /* @__PURE__ */ new Set(), this.refResolver(), this.activeTrivia) : d.parser._meta.firstSet;
         if (fs.kind === "any") return body;
         const cls = this.charClass(fs);
         if (cls < 0) return body;
@@ -13146,7 +13276,7 @@ var Encoder = class {
       case "attempt": {
         const inner = this.emit(OP_ATTEMPT, this.node(d.parser).ip);
         if (!this.failureNeedsRollback(d.parser, void 0)) this.failureRollbackCleanSites.add(inner);
-        const fs = d.parser._def.tag === "lazy" ? firstSetOf(d.parser, /* @__PURE__ */ new Set(), this.refResolver()) : d.parser._meta.firstSet;
+        const fs = d.parser._def.tag === "lazy" ? firstSetOf(d.parser, /* @__PURE__ */ new Set(), this.refResolver(), this.activeTrivia) : d.parser._meta.firstSet;
         if (fs.kind === "any" || matchesEmpty(d.parser)) return inner;
         const cls = this.charClass(fs);
         if (cls < 0) return inner;
@@ -13267,6 +13397,8 @@ var Encoder = class {
     const refs = [];
     for (const s of this.scans) {
       if (s.sentinel !== void 0) refs.push(s.sentinel);
+      if (s.recoverAt !== void 0) refs.push(s.recoverAt);
+      if (s.stopAt !== void 0) refs.push(s.stopAt);
       refs.push(...s.skip);
     }
     for (const set of this.scanSkipSets) refs.push(...set);
@@ -13286,7 +13418,9 @@ var Encoder = class {
     this.scans = this.scans.map((s) => ({
       ...s,
       skip: s.skip.map(res),
-      ...s.sentinel === void 0 ? {} : { sentinel: res(s.sentinel) }
+      ...s.sentinel === void 0 ? {} : { sentinel: res(s.sentinel) },
+      ...s.recoverAt === void 0 ? {} : { recoverAt: res(s.recoverAt) },
+      ...s.stopAt === void 0 ? {} : { stopAt: res(s.stopAt) }
     }));
     this.scanSkipSets = this.scanSkipSets.map((set) => set.map(res));
   }
@@ -13414,6 +13548,8 @@ function emitRef(r) {
 function emitScanSpec(s) {
   const parts = [`kind:${s.kind}`, `flags:${s.flags}`, `skip:[${s.skip.map(emitRef).join(",")}]`];
   if (s.sentinel !== void 0) parts.push(`sentinel:${emitRef(s.sentinel)}`);
+  if (s.recoverAt !== void 0) parts.push(`recoverAt:${emitRef(s.recoverAt)}`);
+  if (s.stopAt !== void 0) parts.push(`stopAt:${emitRef(s.stopAt)}`);
   if (s.sent !== void 0) parts.push(`sent:${s.sent === null ? "null" : jsString(s.sent)}`);
   if (s.open !== void 0) parts.push(`open:${jsString(s.open)}`);
   if (s.close !== void 0) parts.push(`close:${jsString(s.close)}`);
@@ -13440,6 +13576,8 @@ function emitAssemblies(prog, cfgs) {
   for (const s of prog.scans ?? []) {
     for (const r of s.skip) extraIps.push(r[0]);
     if (s.sentinel !== void 0) extraIps.push(s.sentinel[0]);
+    if (s.recoverAt !== void 0) extraIps.push(s.recoverAt[0]);
+    if (s.stopAt !== void 0) extraIps.push(s.stopAt[0]);
   }
   for (const set of prog.scanSkip ?? []) for (const r of set) extraIps.push(r[0]);
   const out = [];
@@ -13608,7 +13746,12 @@ function children(def, winners) {
     case "sepBy":
       return [def.parser, def.separator];
     case "scanTo":
-      return [def.sentinel, ...def.skip];
+      return [
+        def.sentinel,
+        ...def.skip,
+        ...def.recoverAt === void 0 ? [] : [def.recoverAt],
+        ...def.stopAt === void 0 ? [] : [def.stopAt]
+      ];
     case "lazy": {
       let resolved;
       try {
@@ -13721,7 +13864,7 @@ function payloadKey(p, d) {
     case "expect":
       return `expect\0${d.label ?? ""}\0${d.expected.join("
")}`;
     case "scanTo":
-      return `scanTo\0${d.raw}\0${d.orEOF}`;
+      return `scanTo\0${d.raw}\0${d.orEOF}\0${d.recoverAt !== void 0}\0${d.stopAt !== void 0}`;
     case "guard":
       return `guard\0${fnKey(d.predSrc, d.predicate)}`;
     case "adjacency":
@@ -13836,8 +13979,12 @@ function segment(d, index) {
       return index === 0 ? "sepBy.item" : "sepBy.sep";
     case "recover":
       return index === 0 ? "recover.body" : "recover.sentinel";
-    case "scanTo":
-      return index === 0 ? "scanTo.sentinel" : `scanTo.skip[${index - 1}]`;
+    case "scanTo": {
+      if (index === 0) return "scanTo.sentinel";
+      if (index <= d.skip.length) return `scanTo.skip[${index - 1}]`;
+      if (d.recoverAt !== void 0 && index === d.skip.length + 1) return "scanTo.recoverAt";
+      return "scanTo.stopAt";
+    }
     default:
       return d.tag;
   }
@@ -15097,7 +15244,12 @@ function childrenOf2(def) {
     case "sepBy":
       return [def.parser, def.separator];
     case "scanTo":
-      return [def.sentinel, ...def.skip];
+      return [
+        def.sentinel,
+        ...def.skip,
+        ...def.recoverAt === void 0 ? [] : [def.recoverAt],
+        ...def.stopAt === void 0 ? [] : [def.stopAt]
+      ];
     case "routed":
       return def.fallback ? [def.fallback] : [];
     case "literal":