parseman 0.57.0 → 0.58.1

package/dist/table/lex-program.d.ts

@@ -13,11 +13,15 @@ export declare const LEX_NODE_SEQUENCE2 = 1;
 export declare const LEX_NODE_SEQUENCE3 = 2;
 export declare const LEX_NODE_SEQUENCE4 = 3;
 export declare const LEX_NODE_SEQUENCE5 = 4;
-export declare const LEX_NODE_CHOICE2 = 5;
-export declare const LEX_NODE_CHOICE4 = 6;
-export declare const LEX_NODE_CHOICE8 = 7;
+/**
+ * `[op, armCount, exclusive, choiceFx, (armClass, armFx) × armCount]`: any arity,
+ * no padding. `exclusive` is the character choice's one-arm dispatch decision.
+ */
+export declare const LEX_NODE_CHOICE = 5;
 export declare const LEX_NODE_NOT = 8;
 export declare const LEX_NODE_OPTIONAL = 9;
+/** `[op, min, max]` after the item: a separator-less repeat, `max` −1 unbounded. */
+export declare const LEX_NODE_REPEAT = 10;
 export declare function lexProgramDigest(words: readonly number[]): number;
 /** Decode one fixed selected-body tuple. There is no lexical opcode loop on
  * the parse path: each supported tuple becomes one scalar closure here. */

package/dist/table/lex-program.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lex-program.d.ts","sourceRoot":"","sources":["../../src/table/lex-program.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AACtD,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAEjE;;0EAE0E;AAC1E,MAAM,MAAM,gBAAgB,GAAG;IAC7B,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,EAAE,IAAI,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,MAAM,CAAA;IACnF,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAED,eAAO,MAAM,iBAAiB,IAAI,CAAA;AAClC,eAAO,MAAM,kBAAkB,IAAI,CAAA;AACnC,eAAO,MAAM,kBAAkB,IAAI,CAAA;AACnC,eAAO,MAAM,kBAAkB,IAAI,CAAA;AACnC,eAAO,MAAM,kBAAkB,IAAI,CAAA;AACnC,eAAO,MAAM,gBAAgB,IAAI,CAAA;AACjC,eAAO,MAAM,gBAAgB,IAAI,CAAA;AACjC,eAAO,MAAM,gBAAgB,IAAI,CAAA;AACjC,eAAO,MAAM,YAAY,IAAI,CAAA;AAC7B,eAAO,MAAM,iBAAiB,IAAI,CAAA;AAElC,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAOjE;AA+QD;2EAC2E;AAC3E,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,cAAc,EACpB,QAAQ,EAAE,SAAS,iBAAiB,EAAE,EACtC,OAAO,EAAE,SAAS,aAAa,EAAE,EACjC,QAAQ,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,GACvC,gBAAgB,CAyHlB"}
+{"version":3,"file":"lex-program.d.ts","sourceRoot":"","sources":["../../src/table/lex-program.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAG3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AACtD,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAEjE;;0EAE0E;AAC1E,MAAM,MAAM,gBAAgB,GAAG;IAC7B,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,EAAE,IAAI,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,MAAM,CAAA;IACnF,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAED,eAAO,MAAM,iBAAiB,IAAI,CAAA;AAClC,eAAO,MAAM,kBAAkB,IAAI,CAAA;AACnC,eAAO,MAAM,kBAAkB,IAAI,CAAA;AACnC,eAAO,MAAM,kBAAkB,IAAI,CAAA;AACnC,eAAO,MAAM,kBAAkB,IAAI,CAAA;AACnC;;;GAGG;AACH,eAAO,MAAM,eAAe,IAAI,CAAA;AAChC,eAAO,MAAM,YAAY,IAAI,CAAA;AAC7B,eAAO,MAAM,iBAAiB,IAAI,CAAA;AAClC,oFAAoF;AACpF,eAAO,MAAM,eAAe,KAAK,CAAA;AAEjC,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAOjE;AAoaD;2EAC2E;AAC3E,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,cAAc,EACpB,QAAQ,EAAE,SAAS,iBAAiB,EAAE,EACtC,OAAO,EAAE,SAAS,aAAa,EAAE,EACjC,QAAQ,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,GACvC,gBAAgB,CAyHlB"}

package/dist/table/ops.d.ts

@@ -477,6 +477,14 @@ export declare const OP_LEX_BODY = 42;
 export declare const OP_LEX_PROGRAM = 43;
 /** `SOURCE_LEAF f c` — `sourceLeaf()`: reduce semantically, capture source text. */
 export declare const OP_SOURCE_LEAF = 44;
+/**
+ * `RGATE cls child fx` — a choice arm that opens with the token its `dispatch()`
+ * already routed. `cls` is what may follow that token (the arm's next term,
+ * with the sequence's trivia), tested at the routed token's END; a miss fails
+ * there with the next term's set `fx`, as running the arm would. No routed token
+ * at this position, a completions probe, or tolerant recovery enters the arm.
+ */
+export declare const OP_RGATE = 45;
 /**
  * `DISPATCH sel d other otherRouted n a1 … an` — `dispatch()`.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"ops.d.ts","sourceRoot":"","sources":["../../src/table/ops.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,wDAAwD;AACxD,eAAO,MAAM,MAAM,IAAI,CAAA;AACvB,gEAAgE;AAChE,eAAO,MAAM,KAAK,IAAI,CAAA;AACtB,6EAA6E;AAC7E,eAAO,MAAM,MAAM,IAAI,CAAA;AACvB,iFAAiF;AACjF,eAAO,MAAM,OAAO,IAAI,CAAA;AACxB;;;;;;;;;GASG;AACH,eAAO,MAAM,SAAS,IAAI,CAAA;AAC1B;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,IAAI,CAAA;AACvB,2CAA2C;AAC3C,eAAO,MAAM,OAAO,IAAI,CAAA;AACxB;;;;kDAIkD;AAClD,eAAO,MAAM,MAAM,IAAI,CAAA;AACvB,qEAAqE;AACrE,eAAO,MAAM,QAAQ,IAAI,CAAA;AACzB;;;;;;;;;;;;;;;;;;;;;iCAqBiC;AACjC,eAAO,MAAM,OAAO,KAAK,CAAA;AACzB,2CAA2C;AAC3C,eAAO,MAAM,OAAO,KAAK,CAAA;AACzB,8EAA8E;AAC9E,eAAO,MAAM,OAAO,KAAK,CAAA;AACzB,+CAA+C;AAC/C,eAAO,MAAM,MAAM,KAAK,CAAA;AACxB;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,KAAK,CAAA;AACzB,oEAAoE;AACpE,eAAO,MAAM,OAAO,KAAK,CAAA;AACzB,0CAA0C;AAC1C,eAAO,MAAM,QAAQ,KAAK,CAAA;AAC1B;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,KAAK,CAAA;AAC9B,eAAO,MAAM,WAAW,KAAK,CAAA;AAC7B,eAAO,MAAM,aAAa,KAAK,CAAA;AAC/B;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,QAAQ,KAAK,CAAA;AAC1B;;;GAGG;AACH,eAAO,MAAM,SAAS,KAAK,CAAA;AAC3B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,OAAO,KAAK,CAAA;AACzB;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,OAAO,KAAK,CAAA;AACzB;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,KAAK,CAAA;AAC1B;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,KAAK,CAAA;AAC3B,gEAAgE;AAChE,eAAO,MAAM,eAAe,KAAK,CAAA;AACjC;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,KAAK,CAAA;AAC1B;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,YAAY,KAAK,CAAA;AAC9B;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU,KAAK,CAAA;AAC5B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ,KAAK,CAAA;AAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,MAAM,KAAK,CAAA;AACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,SAAS,KAAK,CAAA;AAC3B;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,SAAS,KAAK,CAAA;AAC3B;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,UAAU,KAAK,CAAA;AAC5B;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,OAAO,KAAK,CAAA;AACzB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,UAAU,KAAK,CAAA;AAC5B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ,KAAK,CAAA;AAC1B;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,MAAM,KAAK,CAAA;AACxB;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc,KAAK,CAAA;AAChC;;;;;;;;;GASG;AACH;kFACkF;AAClF,eAAO,MAAM,WAAW,KAAK,CAAA;AAC7B,0EAA0E;AAC1E,eAAO,MAAM,cAAc,KAAK,CAAA;AAChC,oFAAoF;AACpF,eAAO,MAAM,cAAc,KAAK,CAAA;AAChC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,WAAW,KAAK,CAAA;AAC7B;;;;GAIG;AACH,eAAO,MAAM,SAAS,KAAK,CAAA;AAE3B,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAe3C,CAAA"}
+{"version":3,"file":"ops.d.ts","sourceRoot":"","sources":["../../src/table/ops.ts"],"names":[],"mappings":"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"}

package/dist/table/run-support.d.ts

@@ -35,4 +35,23 @@ export declare function spanLines(ctx: ParseContext, start: number, end: number)
 export declare function rawEntry(v: unknown, input: string, s: number, e: number): unknown;
 /** `input`'s code point at `pos`, or −1 at EOF. Surrogate-pair aware. */
 export declare function lead(input: string, pos: number): number;
+type CollapseBuild = (children: readonly unknown[], fields: undefined, span: {
+    start: number;
+    end: number;
+}, rawChildren: readonly unknown[], triviaLog: readonly number[], state: undefined) => unknown;
+/**
+ * A PASS-THROUGH COLLAPSE whose one child built `undefined` (`site-labels.ts`
+ * `passCollapse`).
+ *
+ * A collapse over a single node is that node: the node publishes its value into
+ * the collector the collapse's parent opened, exactly where the collapse would
+ * have published it, over the same span. So both engines run the body with no
+ * frame of the collapse's own and hand its value up. The one value a frame would
+ * have treated differently is `undefined`, which a frame does not count as a
+ * child: the collapse then builds from no children. This is that case — take the
+ * child's publication back and publish the build instead, as the frame would
+ * have. The caller has already set `EC.e`.
+ */
+export declare function collapseEmpty(ctx: ParseContext, build: CollapseBuild, input: string, pos: number, end: number, readsRaw: boolean): unknown;
+export {};
 //# sourceMappingURL=run-support.d.ts.map

package/dist/table/run-support.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run-support.d.ts","sourceRoot":"","sources":["../../src/table/run-support.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,MAAM,MAAM,IAAI,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAA;AACjD,MAAM,MAAM,QAAQ,GAAG,IAAI,GAAG;IAC5B,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,2EAA2E;AAC3E,wBAAgB,OAAO,CAAC,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAS3E;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,QAAQ,CAGjF;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAUjF;AAED,yEAAyE;AACzE,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAKvD"}
+{"version":3,"file":"run-support.d.ts","sourceRoot":"","sources":["../../src/table/run-support.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAG/C,MAAM,MAAM,IAAI,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAA;AACjD,MAAM,MAAM,QAAQ,GAAG,IAAI,GAAG;IAC5B,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,2EAA2E;AAC3E,wBAAgB,OAAO,CAAC,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAS3E;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,QAAQ,CAGjF;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAUjF;AAED,yEAAyE;AACzE,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAKvD;AAKD,KAAK,aAAa,GAAG,CACnB,QAAQ,EAAE,SAAS,OAAO,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EACrF,WAAW,EAAE,SAAS,OAAO,EAAE,EAAE,SAAS,EAAE,SAAS,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,KAC5E,OAAO,CAAA;AAEZ;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,YAAY,EAAE,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAClG,OAAO,CAST"}

package/dist/table/scalar-terminal.d.ts

@@ -10,6 +10,8 @@ export declare function makeScalarRecognizer(op: number, spec: unknown): ScalarR
 export declare function scalarTerminalNodeChild(code: ArrayLike<number>, ip: number): number;
 /** Direct untracked terminal whose recognition `not()` can inspect without materializing it. */
 export declare function scalarTerminalNotChild(code: ArrayLike<number>, ip: number): number;
+/** The same terminal under `peek()`: its match decides the lookahead, and nothing it captured survives it. */
+export declare function scalarTerminalPeekChild(code: ArrayLike<number>, ip: number): number;
 /**
  * A direct scalar terminal that every successful execution of `ip` must match
  * first, through wrappers that cannot consume or select before their child.

package/dist/table/scalar-terminal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scalar-terminal.d.ts","sourceRoot":"","sources":["../../src/table/scalar-terminal.ts"],"names":[],"mappings":"AAMA,4FAA4F;AAC5F,MAAM,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;AAEpF;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,gBAAgB,GAAG,SAAS,CAwB5F;AAED,iGAAiG;AACjG,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAKnF;AAED,gGAAgG;AAChG,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAKlF;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,SAAI,EAAE,cAAc,UAAO,EAAE,WAAW,UAAQ,GAC5F,MAAM,CA4CR;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAA;IACrC,0EAA0E;IAC1E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB,CAAA;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,GAClC,qBAAqB,GAAG,SAAS,CAmEnC;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,SAAS,EAAE,SAAS,OAAO,EAAE,EAAE,EAAE,EAAE,MAAM,EAClE,QAAQ,SAAI,EAAE,KAAK,SAAI,GACtB,SAAS,MAAM,EAAE,GAAG,SAAS,CAwD/B;AAED;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,SAAS,EAAE,SAAS,OAAO,EAAE,EAAE,KAAK,EAAE,MAAM,GACpE,SAAS,MAAM,EAAE,GAAG,SAAS,CAW/B"}
+{"version":3,"file":"scalar-terminal.d.ts","sourceRoot":"","sources":["../../src/table/scalar-terminal.ts"],"names":[],"mappings":"AAMA,4FAA4F;AAC5F,MAAM,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;AAEpF;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,gBAAgB,GAAG,SAAS,CAwB5F;AAED,iGAAiG;AACjG,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAKnF;AAED,gGAAgG;AAChG,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAKlF;AAED,8GAA8G;AAC9G,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAKnF;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,SAAI,EAAE,cAAc,UAAO,EAAE,WAAW,UAAQ,GAC5F,MAAM,CA4CR;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAA;IACrC,0EAA0E;IAC1E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB,CAAA;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,GAClC,qBAAqB,GAAG,SAAS,CAmEnC;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,SAAS,EAAE,SAAS,OAAO,EAAE,EAAE,EAAE,EAAE,MAAM,EAClE,QAAQ,SAAI,EAAE,KAAK,SAAI,GACtB,SAAS,MAAM,EAAE,GAAG,SAAS,CAwD/B;AAED;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,SAAS,EAAE,SAAS,OAAO,EAAE,EAAE,KAAK,EAAE,MAAM,GACpE,SAAS,MAAM,EAAE,GAAG,SAAS,CAW/B"}

package/dist/table/site-labels.d.ts

@@ -46,6 +46,28 @@ export declare const TOP: SiteLabel;
  * unemittable regardless.
  */
 export declare function reachableSites(code: Int32Array, roots: Iterable<number>): Set<number>;
+/**
+ * A node both engines lower as a PASS-THROUGH COLLAPSE (`run-support.ts`
+ * `collapseEmpty`): `collapse: true` over a direct reducer, no projection, no CST
+ * host, no line tracking, whose body is one node behind wrappers that consume and
+ * capture nothing (a first-set gate, a trivia scope, a rule reference). One
+ * predicate, so the two engines and the labels cannot disagree on a site.
+ */
+export declare function passCollapse(code: Int32Array, ip: number, hostCst: boolean): boolean;
+/**
+ * A collapse that a FIRST CHARACTER can reduce to a pass-through: its body is a
+ * sequence of `optional`/`not` terms, each behind a first-character gate, then
+ * one node. Where the character at the collapse's start opens none of those
+ * terms (nor its sequence's trivia — the engines test that against the site's
+ * label), every one of them matches empty there and the body is that node alone.
+ * `leads` are the gate rows, `lits` the constant indices of direct literal terms,
+ * `last` the node term. Not a `passCollapse`.
+ */
+export declare function gatedPassCollapse(code: Int32Array, ip: number, hostCst: boolean): {
+    leads: number[];
+    lits: number[];
+    last: number;
+} | undefined;
 /** A site's label, or `TOP` for anything the walk did not reach. */
 export type SiteLabels = {
     at: (ip: number) => SiteLabel;
@@ -63,4 +85,48 @@ export type SiteLabels = {
  * lattice has height three and the walk terminates.
  */
 export declare function computeSiteLabels(code: Int32Array, roots: Iterable<number>, hostCst: boolean): SiteLabels;
+/**
+ * Does a piece entered at `ip` need the caller's INSTALLED trivia scanner handed
+ * across an engine boundary?
+ *
+ * Each table engine keeps its own installed-scanner slot, and the two hand theirs
+ * across at every call between them. A site whose label names its trivia (`tri`)
+ * reads no slot: both engines lower its skips onto that trivia's own scanner, and
+ * a call out of it can hand that scanner across instead of the slot. Only a site
+ * whose trivia the labels cannot name (`TRI_UNKNOWN`) reads the slot. So the
+ * handoff is needed exactly when such a site is reachable from `ip` before a
+ * scope installs a scanner of its own (an aliased scope, which installs what is
+ * already installed, does not). `false` is also the answer for a body with no
+ * trivia at all.
+ */
+/**
+ * A trivia scope that writes only what its label proves is already in force, so
+ * it runs as its child. A slot scope under that same slot is one; so is a scope
+ * with no trivia where the label proves none (inside `token()` or another such
+ * scope), since every way to `TRI_NONE` leaves no trivia, no kind labels and no
+ * scanner — what this scope would write. `OP_SCOPE_PLAIN` has no root policy; a
+ * policy-bearing `OP_SCOPE` is one only with policy zero, and `OP_SCOPE_CAP`
+ * never is, since it raises `captureTrivia`. `TRI_UNKNOWN` matches nothing.
+ */
+export declare function scopeIsIdentity(code: Int32Array, ip: number, at: SiteLabel): boolean;
+export declare function scanHandoffNeeded(code: Int32Array, ip: number, labels: SiteLabels): boolean;
+/**
+ * The first characters that can start trivia at a site labelled `tri`, as code
+ * point ranges: none for `TRI_NONE`, `undefined` where the labels cannot name the
+ * trivia or its first set is unbounded.
+ */
+export declare function triviaLeadRanges(tri: number, trivia: readonly ({
+    _meta: {
+        firstSet: {
+            kind: string;
+            ranges?: readonly {
+                lo: number;
+                hi: number;
+            }[];
+        };
+    };
+} | undefined)[]): readonly {
+    lo: number;
+    hi: number;
+}[] | undefined;
 //# sourceMappingURL=site-labels.d.ts.map

package/dist/table/site-labels.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"site-labels.d.ts","sourceRoot":"","sources":["../../src/table/site-labels.ts"],"names":[],"mappings":"AAoEA,iFAAiF;AACjF,eAAO,MAAM,WAAW,KAAK,CAAA;AAC7B,qDAAqD;AACrD,eAAO,MAAM,QAAQ,KAAK,CAAA;AAC1B,0EAA0E;AAE1E,qDAAqD;AACrD,eAAO,MAAM,WAAW,IAAI,CAAA;AAC5B,yDAAyD;AACzD,eAAO,MAAM,OAAO,IAAI,CAAA;AACxB,uDAAuD;AACvD,eAAO,MAAM,MAAM,IAAI,CAAA;AAEvB,0DAA0D;AAC1D,eAAO,MAAM,WAAW,IAAI,CAAA;AAC5B,uCAAuC;AACvC,eAAO,MAAM,WAAW,IAAI,CAAA;AAC5B,oDAAoD;AACpD,eAAO,MAAM,QAAQ,IAAI,CAAA;AAEzB,MAAM,MAAM,SAAS,GAAG;IACtB,mFAAmF;IACnF,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB;;;OAGG;IACH,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAA;IACrB,kDAAkD;IAClD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,4CAA4C;IAC5C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,wDAAwD;AACxD,eAAO,MAAM,GAAG,EAAE,SAAgF,CAAA;AAWlG;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAarF;AA8DD,oEAAoE;AACpE,MAAM,MAAM,UAAU,GAAG;IAAE,EAAE,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,SAAS,CAAA;CAAE,CAAA;AAE1D;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,EACvB,OAAO,EAAE,OAAO,GACf,UAAU,CA6BZ"}
+{"version":3,"file":"site-labels.d.ts","sourceRoot":"","sources":["../../src/table/site-labels.ts"],"names":[],"mappings":"AAoEA,iFAAiF;AACjF,eAAO,MAAM,WAAW,KAAK,CAAA;AAC7B,qDAAqD;AACrD,eAAO,MAAM,QAAQ,KAAK,CAAA;AAC1B,0EAA0E;AAE1E,qDAAqD;AACrD,eAAO,MAAM,WAAW,IAAI,CAAA;AAC5B,yDAAyD;AACzD,eAAO,MAAM,OAAO,IAAI,CAAA;AACxB,uDAAuD;AACvD,eAAO,MAAM,MAAM,IAAI,CAAA;AAEvB,0DAA0D;AAC1D,eAAO,MAAM,WAAW,IAAI,CAAA;AAC5B,uCAAuC;AACvC,eAAO,MAAM,WAAW,IAAI,CAAA;AAC5B,oDAAoD;AACpD,eAAO,MAAM,QAAQ,IAAI,CAAA;AAEzB,MAAM,MAAM,SAAS,GAAG;IACtB,mFAAmF;IACnF,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB;;;OAGG;IACH,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAA;IACrB,kDAAkD;IAClD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,4CAA4C;IAC5C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,wDAAwD;AACxD,eAAO,MAAM,GAAG,EAAE,SAAgF,CAAA;AAWlG;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAarF;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAYpF;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG;IAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAuB/I;AAqED,oEAAoE;AACpE,MAAM,MAAM,UAAU,GAAG;IAAE,EAAE,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,SAAS,CAAA;CAAE,CAAA;AAE1D;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,EACvB,OAAO,EAAE,OAAO,GACf,UAAU,CA6BZ;AAED;;;;;;;;;;;;;GAaG;AACH;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,SAAS,GAAG,OAAO,CAKpF;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAG,OAAO,CAqB3F;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC;IAAE,KAAK,EAAE;QAAE,QAAQ,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,MAAM,CAAC,EAAE,SAAS;gBAAE,EAAE,EAAE,MAAM,CAAC;gBAAC,EAAE,EAAE,MAAM,CAAA;aAAE,EAAE,CAAA;SAAE,CAAA;KAAE,CAAA;CAAE,GAAG,SAAS,CAAC,EAAE,GACtI,SAAS;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,EAAE,GAAG,SAAS,CAOnD"}

package/dist/version.d.ts

@@ -13,5 +13,5 @@
  * Kept in sync with `package.json` by `test/unit/version-sync.test.ts`, which fails
  * the build if this constant drifts from the published version.
  */
-export declare const PARSEMAN_VERSION = "0.57.0";
+export declare const PARSEMAN_VERSION = "0.58.1";
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parseman",
-  "version": "0.57.0",
+  "version": "0.58.1",
   "packageManager": "pnpm@10.15.1",
   "engines": {
     "node": "^20.19.0 || >=22.13.0"

package/src/combinators/dispatch.ts

@@ -105,10 +105,19 @@ export function branchUsesRouted(branch: { parser: Combinator<unknown>; usesRout
 }
 
 export function asciiFoldKey(key: string): string {
-  let out = ''
-  for (let i = 0; i < key.length; i++) {
+  // A key with no ASCII capital is its own fold: every dispatch on a lowercase
+  // word asks, and building the same string again a character at a time cost an
+  // allocation per character.
+  let i = 0
+  for (; i < key.length; i++) {
     const c = key.charCodeAt(i)
-    out += String.fromCharCode(c >= 65 && c <= 90 ? c + 32 : c)
+    if (c >= 65 && c <= 90) break
+  }
+  if (i === key.length) return key
+  let out = key.slice(0, i)
+  for (; i < key.length; i++) {
+    const c = key.charCodeAt(i)
+    out += c >= 65 && c <= 90 ? String.fromCharCode(c + 32) : key[i]!
   }
   return out
 }

package/src/compiler/token-alphabet.ts

@@ -37,6 +37,7 @@ import type { BalancedSpec } from '../combinators/scanTo.ts'
 import { deriveExpected } from '../combinators/expect.ts'
 import { assertionFailureExpected, directTerminalFailureExpected } from '../combinators/expected.ts'
 import { keywordsRegExp } from '../combinators/keywords.ts'
+import { hasOwnTriviaBoundary } from '../combinators/trivia-boundary.ts'
 
 /** A terminal in the derived alphabet, with its globally assigned id. */
 export type TokenTerminal =
@@ -135,12 +136,17 @@ export type ExecutableLexNode =
   | {
     readonly kind: 'choice'
     readonly arms: readonly ExecutableLexNode[]
-    readonly firstSets: readonly FirstSet[]
+    /** The authored arms: the encoder classifies them as the character choice would. */
+    readonly parsers: readonly Combinator<unknown>[]
+    /** Inside a no-trivia scope of the token, where the encoder's trivia is none. */
+    readonly cleared: boolean
     readonly armExpected: readonly (readonly string[])[]
     readonly expected: readonly string[]
   }
   | { readonly kind: 'not'; readonly body: ExecutableLexNode; readonly expected: readonly string[] }
   | { readonly kind: 'optional'; readonly body: ExecutableLexNode }
+  /** A separator-less `many`/`oneOrMore`; `max` −1 is unbounded. */
+  | { readonly kind: 'repeat'; readonly body: ExecutableLexNode; readonly min: number; readonly max: number }
 
 export type ExecutableFixedLexBody = {
   readonly kind: 'fixed-tree'
@@ -204,9 +210,22 @@ export function selectOptionalSuffixLexBody(ir: LexicalIr): LexBodyCandidate {
 /** Unwrap only scopes that token() has already installed identically. The
  * returned parser is still the authored terminal/sequence; no effectful wrapper
  * or final named winner is guessed from construction metadata. */
+/**
+ * A rule reference made with no trivia in force reinstalls the rule's own
+ * ambient trivia when the rule has a position that reads it (`ref.ts`, the
+ * encoder's `scopedRef`), and inside a token none is in force. Such a rule's
+ * terms are then trivia-separated, which a lexical body does not model, so the
+ * reference is not lowered.
+ */
+function reinstallsRuleTrivia(reference: Combinator<unknown>, target: Combinator<unknown>): boolean {
+  return (reference._meta.grammarTrivia ?? target._meta.grammarTrivia) !== undefined
+    && hasOwnTriviaBoundary(target)
+}
+
 function directTokenBodyParser(
   parser: Combinator<unknown>,
   resolve?: (name: string) => Combinator<unknown> | undefined,
+  scope?: { cleared: boolean },
 ): Combinator<unknown> | undefined {
   const outer = parser._def
   if (outer.tag !== 'token') return undefined
@@ -220,12 +239,13 @@ function directTokenBodyParser(
         || wrapper.captureTrivia === true || wrapper.rootCapture === 'opaque'
         || wrapper.constructionTrackLines !== 'inherit'
         || wrapper.constructionCaptureTriviaKinds !== undefined) return undefined
+      if (scope !== undefined) scope.cleared = true
       body = wrapper.parser
       continue
     }
     if (wrapper.tag === 'lazy') {
       const target = resolvedLazyTarget(body, resolve)
-      if (target === undefined) return undefined
+      if (target === undefined || reinstallsRuleTrivia(body, target)) return undefined
       body = target
       continue
     }
@@ -436,6 +456,7 @@ function directFixedLexNode(
   resolve: ((name: string) => Combinator<unknown> | undefined) | undefined,
   active: Set<Combinator<unknown>>,
   pureOnly = false,
+  cleared = false,
 ): ExecutableLexNode | undefined {
   let current = parser
   const wrappers = new Set<Combinator<unknown>>()
@@ -444,7 +465,7 @@ function directFixedLexNode(
     const def = current._def
     if (def.tag === 'lazy') {
       const target = resolvedLazyTarget(current, resolve)
-      if (target === undefined) return undefined
+      if (target === undefined || reinstallsRuleTrivia(current, target)) return undefined
       current = target
       continue
     }
@@ -459,43 +480,57 @@ function directFixedLexNode(
     if (terminal !== undefined) return { kind: 'terminal', terminal }
     const def = current._def
     if (def.tag === 'grammar') {
+      // A scope with no trivia of its own writes nothing under a token that is
+      // not already in force: a cleared one runs as its child in the table
+      // (`scopeIsIdentity`) and an inheriting one encodes no row. Its line
+      // policy is the table's own (`hasScopedTrackLines`). So it is its child
+      // at any position.
+      if (def.triviaParser === undefined && def.captureTrivia !== true
+        && def.rootCapture !== 'opaque' && def.constructionCaptureTriviaKinds === undefined) {
+        return directFixedLexNode(def.parser, resolve, active, pureOnly, cleared || def.clearTrivia === true)
+      }
       if (!pureOnly || (def.parser._def.tag !== 'token'
         && (def.clearTrivia !== true || def.triviaParser !== undefined
           || def.captureTrivia === true || def.rootCapture === 'opaque'))) return undefined
-      return directFixedLexNode(def.parser, resolve, active, true)
+      return directFixedLexNode(def.parser, resolve, active, true, cleared)
     }
     if (def.tag === 'sequence') {
       if (def.parsers.length < 2 || def.parsers.length > 5) return undefined
-      const parts = def.parsers.map(part => directFixedLexNode(part, resolve, active, pureOnly))
+      const parts = def.parsers.map(part => directFixedLexNode(part, resolve, active, pureOnly, cleared))
       if (parts.some(part => part === undefined)) return undefined
       return { kind: 'sequence', parts: parts as ExecutableLexNode[] }
     }
     if (def.tag === 'choice') {
-      if ((def.parsers.length !== 2 && def.parsers.length !== 4 && def.parsers.length !== 8)
+      if (def.parsers.length < 2
         || def.strategy.tag !== 'firstMatch'
         || def.gates.some(gate => gate !== null)
         || def.autoNot.some(check => check !== null)) return undefined
-      const arms = def.parsers.map(arm => directFixedLexNode(arm, resolve, active, pureOnly))
+      const arms = def.parsers.map(arm => directFixedLexNode(arm, resolve, active, pureOnly, cleared))
       if (arms.some(arm => arm === undefined)) return undefined
-      const final = classifyFinalChoice(def.parsers, resolve)
       return {
         kind: 'choice', arms: arms as ExecutableLexNode[],
-        firstSets: final.firstSets,
+        parsers: def.parsers, cleared,
         armExpected: def.parsers.map(deriveExpected),
         expected: def.parsers.flatMap(deriveExpected),
       }
     }
     if (def.tag === 'not') {
-      const body = directFixedLexNode(def.parser, resolve, active, true)
+      const body = directFixedLexNode(def.parser, resolve, active, true, cleared)
       return body === undefined ? undefined : {
         kind: 'not', body,
         expected: assertionFailureExpected(false, def.parser._tag),
       }
     }
     if (def.tag === 'optional') {
-      const body = directFixedLexNode(def.parser, resolve, active, pureOnly)
+      const body = directFixedLexNode(def.parser, resolve, active, pureOnly, cleared)
       return body === undefined ? undefined : { kind: 'optional', body }
     }
+    if (def.tag === 'many' || def.tag === 'oneOrMore') {
+      const body = directFixedLexNode(def.parser, resolve, active, pureOnly, cleared)
+      return body === undefined ? undefined : {
+        kind: 'repeat', body, min: def.tag === 'many' ? 0 : def.min, max: def.max ?? -1,
+      }
+    }
     return undefined
   } finally {
     active.delete(current)
@@ -506,9 +541,10 @@ export function directFixedTokenBody(
   parser: Combinator<unknown>,
   resolve?: (name: string) => Combinator<unknown> | undefined,
 ): ExecutableFixedLexBody | undefined {
-  const body = directTokenBodyParser(parser, resolve)
+  const scope = { cleared: false }
+  const body = directTokenBodyParser(parser, resolve, scope)
   if (body === undefined) return undefined
-  const root = directFixedLexNode(body, resolve, new Set())
+  const root = directFixedLexNode(body, resolve, new Set(), false, scope.cleared)
   return root === undefined ? undefined : { kind: 'fixed-tree', root }
 }
 
@@ -1556,8 +1592,11 @@ function normalizeLexical(
   if (stack.has(parser)) return { refusal: 'recursive token body' }
   stack.add(parser)
   try {
-    return withLexicalControl(session, parser._def.tag, () =>
-      normalizeLexicalBody(parser, resolve, stack, session))
+    // A nested `balanced()` is its scanner machine, not the transform that
+    // builds its value — `sequence('@', balanced('{', '}'))` as a skipper.
+    return normalizeBalancedLexical(parser, resolve, session)
+      ?? withLexicalControl(session, parser._def.tag, () =>
+        normalizeLexicalBody(parser, resolve, stack, session))
   } finally {
     stack.delete(parser)
   }
@@ -1841,8 +1880,9 @@ function fixedBindingProjection(
   // and the emitted adapter captures that site's named body after linking every
   // scan root. Only ambient trivia/scanSkip remain live runtime callbacks; they
   // are scanner POLICY, never binding authority for these authored own children.
-  // Recovery/withCtx still have no equivalent named template.
-  if (edge.parentTag === 'recover' || edge.parentTag === 'withCtx') readerMask = 0b011
+  // Recovery still has no equivalent named template. `withCtx` has one: the
+  // emitter's OP_WITHCTX body calls its child by the name `link()` minted.
+  if (edge.parentTag === 'recover') readerMask = 0b011
   // Sequence strict, adjacency, and recovery bodies now all use scalar block
   // chains, so no supported variant is withheld here.
   const words = [

package/src/cst/capture-buffer.ts

@@ -111,6 +111,31 @@ export function pushCstChild(ctx: ParseContext, built: unknown, rawEntry: unknow
   if (ctx._cstRawChildren) ctx._cstRawChildren.push(rawEntry)
 }
 
+/**
+ * Undo the LAST `pushCstChild` into the active collector, whichever form it took:
+ * a child the lazy buffer's empty sentinel dropped (`undefined` first) leaves no
+ * semantic entry to remove, only its raw one.
+ */
+export function popCstChild(ctx: ParseContext): void {
+  const b = ctx._cstBuf
+  if (b) {
+    const ch = b.ch
+    if (b.rawOnly !== true && ch) {
+      ch.pop()
+      if (ch.length === 1) { b.single = ch[0]; b.ch = undefined }
+    }
+    if (b.noRaw === true) b.rawLen = (b.rawLen ?? 1) - 1
+    else if (b.raw) {
+      b.raw.pop()
+      if (b.raw.length === 1) { b.rawSingle = b.raw[0]; b.raw = undefined }
+    } else b.rawSingle = undefined
+    return
+  }
+  if (ctx._cstChildren) ctx._cstChildren.pop()
+  else if (ctx._cstLeaves) ctx._cstLeaves.pop()
+  if (ctx._cstRawChildren) ctx._cstRawChildren.pop()
+}
+
 export function cstRawLen(ctx: ParseContext): number {
   const b = ctx._cstBuf
   if (b) {