parseman 0.4.0 → 0.6.0

package/README.md

@@ -8,7 +8,9 @@ Write parsers in TypeScript — fast enough to run as-is, and blazing fast when
 
 ## Benchmarks
 
-Measured on Apple M2 Pro. Bars show µs per parse — shorter is faster.
+Measured on Apple M2 Pro. Bars show µs per parse — shorter is faster. Refresh: `pnpm bench`, then `pnpm bench:svg` (updates `assets/bench-*.svg`).
+
+Compared parsers: **Parséman**, Peggy, Parsimmon, Chevrotain, Nearley, and Jison (plus `JSON.parse` on JSON). Each implements the same parsing work on the bench fixtures — building JS values / row arrays / GraphQL AST nodes, not syntax-only validation. Peggy grammars in `bench/*.pegjs` are the reference; Nearley JSON uses [kach/nearley `examples/json.ne`](https://github.com/kach/nearley/blob/master/examples/json.ne); other Nearley and Jison grammars are ports of those Peggy files (`bench/vendor/`).
 
 ![JSON parsing benchmarks](https://raw.githubusercontent.com/matthew-dean/parsecraft/main/assets/bench-json.svg)
 
@@ -16,9 +18,9 @@ Measured on Apple M2 Pro. Bars show µs per parse — shorter is faster.
 
 ![GraphQL parsing benchmarks](https://raw.githubusercontent.com/matthew-dean/parsecraft/main/assets/bench-graphql.svg)
 
-Parséman has three modes — **interpreter** (zero setup, works anywhere), **macro build** (compiled by the bundler plugin at build time, zero runtime cost), and **`.compile()`** (optional runtime JIT). Most production use lands on one of the first two. The initialization section only shows parsers with a nonzero setup cost: `.compile()` costs 75–650 µs depending on grammar size; Chevrotain always costs 840–1,400 µs. Parsers not listed there start for free.
+Parséman has three modes — **interpreter** (zero setup, works anywhere), **macro build** (compiled by the bundler plugin at build time, zero runtime cost), and **`.compile()`** (optional runtime JIT). Most production use lands on one of the first two. The initialization section only shows parsers with a nonzero setup cost: `.compile()` costs 75–650 µs depending on grammar size; Chevrotain always costs 840–1,400 µs. Parsers not listed there start for free. (Init numbers are pinned on the charts — they're noisy run-to-run; warm-parse bars are the meaningful comparison.)
 
-On JSON, CSV, and GraphQL, Parséman macro beats Peggy at every fixture size in the charts above. For CST-building grammars (`node()` rules with trivia capture), the interpreter runs ~2× faster than Chevrotain on the JSON CST fixture while building an equivalent tree.
+On JSON, CSV, and GraphQL, Parséman macro beats Peggy at every fixture size in the charts above (e.g. GraphQL large: **142 µs** vs Peggy **400 µs**). For CST-building grammars (`node()` rules with trivia capture), the interpreter runs ~2× faster than Chevrotain on the JSON CST fixture while building an equivalent tree.
 
 ---
 
@@ -136,6 +138,7 @@ A combinator reads from the input at the current position and succeeds or fails
 | `sepBy(combinator, sep)` | Zero or more combinator matches separated by `sep`. |
 | `transform(combinator, fn)` | Map the result: `fn(value, span) → newValue`. |
 | `skip(main, skipped)` | Match `main` then `skipped`; return `main`'s value. |
+| `label(name, combinator)` | Attach a string label to a combinator arm (metadata). Used on trivia `choice` branches for per-chunk kind capture — see [Whitespace and comment skipping](#whitespace-and-comment-skipping). |
 | `node(type, combinator, build)` | CST/AST rule: captures the combinator's terminals into `children`/`rawChildren` and trivia offsets into a flat `triviaLog`, then calls `build(children, rawChildren, span, triviaLog)`. |
 | `ref<T>()` | Low-level forward declaration slot (use `rules()` in most cases). |
 | `not(combinator)` | Negative lookahead — succeeds (consuming nothing) when the combinator fails. |
@@ -153,6 +156,7 @@ A combinator reads from the input at the current position and succeeds or fails
 | `makeWord(boundary?)` | Returns `(str) => Combinator` with a fixed word-boundary class. Not a combinator — see [keyword disambiguation](#ordered-choice-and-keyword-disambiguation). |
 | `rules(factory)` | Named, mutually-recursive rule bundle. See [Named and recursive rules](#named-and-recursive-rules). |
 | `parser({ trivia }, combinator)` | Wrap a root combinator with document-level trivia skipping. See [Whitespace and comment skipping](#whitespace-and-comment-skipping). |
+| `triviaEntries(log, labels?, opts?)` | View over a flat trivia log: `.kind(i)`, `.text(i, input)`, `.start(i)`, `.end(i)`. Stride is 2/3 for root `_triviaLog`, 3/4 for per-node `triviaLog` when kinds are enabled. |
 
 ---
 
@@ -177,6 +181,8 @@ Two takeaways:
 
 **When NOT to collapse:** keep the parts as separate combinators wherever the builder needs them as distinct CST children — for per-field source spans (`fieldSpans`/`valueSpans`), for trivia recovered *between* the parts, or for distinct typed nodes. Correctness first; collapse only the genuinely opaque runs.
 
+For library-level codegen and macro optimizations (not grammar authoring), see [PERF_IDEAS.md](./PERF_IDEAS.md).
+
 ---
 
 ## Whitespace and comment skipping
@@ -205,6 +211,25 @@ const blockComment = sequence(literal('/*'), scanTo(literal('*/'), []))
 const ws           = trivia(many(choice(regex(/\s+/), lineComment, blockComment)))
 ```
 
+Label trivia arms so each captured chunk records its kind in `_triviaLog` / per-node `triviaLog`:
+
+```ts
+const rw = trivia(oneOrMore(choice(
+  label('whitespace', regex(/[ \t\n\r\f]+/)),
+  label('blockComment', regex(/\/\*(?:[^*]|\*(?!\/))*\*\//)),
+)))
+
+// After parse, resolve kinds lazily:
+import { triviaEntries } from 'parseman'
+const entries = triviaEntries(triviaLog, rw._meta.triviaKindLabels)
+entries.kind(0)  // 'whitespace'
+entries.text(0, input)  // slice on demand
+```
+
+`label(name, parser)` names a trivia arm; `node('Ruleset', …)` names a CST node — different namespaces, no conflict.
+
+When all trivia arms are labeled, each captured chunk appends a **kind index** to the log (stride +1). Root `_triviaLog` entries are `[start, end, kind]`; per-node `triviaLog` entries are `[start, end, insertIdx, kind]`. Without labels, strides are 2 and 3 respectively.
+
 ---
 
 ## Ordered choice and keyword disambiguation
@@ -314,7 +339,7 @@ value.define(choice(object, array, str, num, bool, nil))
 
 ## Grammars that build an AST
 
-For grammars that produce a typed CST/AST, support incremental re-parsing, or care about trivia, wrap each rule in `node(type, combinator, build)`. parseman captures the rule's terminals into `children` / `rawChildren` and records trivia as flat `[start, end, insertIdx, …]` triples in `triviaLog`, then hands all four to `build(children, rawChildren, span, triviaLog)`. **Capture is the library's job:** you don't wrap terminals to recover their spans, and you don't reconstruct trivia — it's collected as the parser runs, in both the interpreter and the compiled build. Use `buildTriviaIndex(tree, input)` to turn `triviaLog` into a before/after lookup table.
+For grammars that produce a typed CST/AST, support incremental re-parsing, or care about trivia, wrap each rule in `node(type, combinator, build)`. parseman captures the rule's terminals into `children` / `rawChildren` and records trivia as flat `[start, end, insertIdx, …]` **entries** in `triviaLog` (three numbers per whitespace/comment chunk), then hands all four to `build(children, rawChildren, span, triviaLog)`. **Capture is the library's job:** you don't wrap terminals to recover their spans, and you don't reconstruct trivia — it's collected as the parser runs, in both the interpreter and the compiled build. Use `buildTriviaIndex(tree, input)` to turn `triviaLog` into a before/after lookup table.
 
 ```ts
 import { rules, parser, node, regex, literal, sequence, many, trivia } from 'parseman'
@@ -338,7 +363,7 @@ Expr.parse('1 + 2 + 3', 0, { trackLines: false })
 
 - **`children`** — structural items in source order: spanned `CSTLeaf` terminals (`{ _tag:'leaf', value, span }`) and sub-nodes (whatever a nested `node()`'s `build` returned). A `build` that returns a bare string is recorded by the parent as a spanned leaf, so single-item "collapsing" rules keep their source span.
 - **`rawChildren`** — structural children only (same items as `children`, without trivia tokens).
-- **`triviaLog`** — flat `[start, end, insertIdx, …]` triples for whitespace/comments consumed between terms. `insertIdx` is the `rawChildren` index before which the trivia was consumed. Pass the tree to `buildTriviaIndex(tree, input)` for a `before`/`after` map of trivia tokens — useful for whitespace-sensitive syntax (e.g. CSS `div p` vs `div.p`).
+- **`triviaLog`** — flat `[start, end, insertIdx, …]` entries for whitespace/comments consumed between terms. `insertIdx` is the `rawChildren` index before which the trivia was consumed. Pass the tree to `buildTriviaIndex(tree, input)` for a `before`/`after` map of trivia tokens — useful for whitespace-sensitive syntax (e.g. CSS `div p` vs `div.p`).
 
 Each rule returned from the factory is independently callable — `Expr`, `Num` above are the **rule registry** incremental re-parsing needs. Wrap a rule's inner combinator in `parser({ trivia }, combinator)` so trivia-skipping is baked in regardless of which rule you start from; the macro compiles the wrapper (and all capture) away to flat JS.
 
@@ -385,22 +410,26 @@ vscode.workspace.onDidChangeTextDocument(event => {
 })
 ```
 
-### Inheritance — by composition
+### Extending grammars
+
+Don't copy a `rules()` factory to make a variant — export what stays the same and pass in (or wrap) what changes. `examples/json/` is the template:
 
-Share rules across grammar variants by composition: factor common rules into helpers, and let each variant swap the ones it needs. Because every rule is a plain value, a variant is just different pieces passed into the same `rules()` shape — and it all stays macro-compilable.
+| File | What changes |
+|------|----------------|
+| `parser.ts` | Base grammar + `makeJSONParser(customWs)` |
+| `jsonc.ts` | Trivia only — `makeJSONParser(jsoncWs)` |
+| `jsonl.ts` | Document shape — `sepBy(jsonValue, '\n')` with tighter trivia |
 
 ```ts
-// shared building blocks
-const makeIdent = () => regex(/[a-zA-Z_]\w*/)
-
-export const { Expr } = rules<{ Expr: Combinator<Node> }>(g => {
-  const ident = makeIdent()                       // base
-  // a JSX variant would use regex(/[a-zA-Z_$][\w$]*/) here instead
-  /* ...rules referencing ident... */
-  return { Expr: /* ... */ }
-})
+// jsonc.ts — same recursive grammar, different trivia
+export const jsoncValue = makeJSONParser(jsoncWs)
+
+// jsonl.ts — reuse jsonValue, wrap at the top
+export const jsonl = parser({ trivia: lineWs }, sepBy(jsonValue, literal('\n')))
 ```
 
+`makeJSONParser` in `parser.ts` is the knob: one `rules()` body, trivia passed in, `parser({ trivia }, value)` returned. Unchanged core → parameterize; unchanged rule, different document → wrap the export.
+
 ---
 
 ## Context-sensitive parsing
@@ -561,7 +590,9 @@ pnpm install
 pnpm test       # Vitest — interpreter + compiler parity + ordered-choice semantics
 pnpm typecheck  # TypeScript 7
 pnpm build      # ESM + CJS + .d.ts → dist/
-pnpm bench      # Parséman vs Peggy vs Parsimmon vs Chevrotain
+pnpm bench                  # Parséman vs Peggy, Parsimmon, Chevrotain, Nearley, Jison
+pnpm bench:svg              # refresh assets/bench-*.svg after bench
+pnpm bench:compile-grammars # regenerate Peggy / Nearley / Jison parser output in bench/
 ```
 
 ## License

package/dist/combinators/choice.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"choice.d.ts","sourceRoot":"","sources":["../../src/combinators/choice.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EAC+B,QAAQ,EAClD,MAAM,aAAa,CAAA;AAGpB,KAAK,SAAS,CAAC,CAAC,IAAI,CAAC,SAAS,QAAQ,CAAC,MAAM,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,UAAU,CAAC,MAAM,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,KAAK,CAAA;AACvH,KAAK,SAAS,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC,EAAE,IAAI;KACrE,CAAC,IAAI,MAAM,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAChC,CAAC,MAAM,CAAC,SAAS,UAAU,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAEjD,wBAAgB,MAAM,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,QAAQ,CAAC,OAAO,CAAC,EAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EACxH,GAAG,IAAI,EAAE,CAAC,GACT,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAiI1B;AAwFD,uEAAuE;AACvE,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,MAAM,GAAG,IAAI,CAKzE;AAED,qEAAqE;AACrE,wBAAgB,eAAe,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAKhG"}
+{"version":3,"file":"choice.d.ts","sourceRoot":"","sources":["../../src/combinators/choice.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EAC+B,QAAQ,EAClD,MAAM,aAAa,CAAA;AAIpB,KAAK,SAAS,CAAC,CAAC,IAAI,CAAC,SAAS,QAAQ,CAAC,MAAM,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,UAAU,CAAC,MAAM,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,KAAK,CAAA;AACvH,KAAK,SAAS,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC,EAAE,IAAI;KACrE,CAAC,IAAI,MAAM,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAChC,CAAC,MAAM,CAAC,SAAS,UAAU,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAEjD,wBAAgB,MAAM,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,QAAQ,CAAC,OAAO,CAAC,EAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EACxH,GAAG,IAAI,EAAE,CAAC,GACT,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAiI1B;AAwFD,uEAAuE;AACvE,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,MAAM,GAAG,IAAI,CAKzE;AAED,qEAAqE;AACrE,wBAAgB,eAAe,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAMhG"}

package/dist/combinators/completions.d.ts

@@ -13,5 +13,5 @@ import type { Combinator } from '../types.ts';
  * The returned strings use the same labels as ParseFail.expected:
  * quoted literals like `"\"{\""` and regex patterns like `"/[0-9]+/"`.
  */
-export declare function completionsAt(parser: Combinator<unknown>, input: string, offset: number): string[];
+export declare function completionsAt(combinator: Combinator<unknown>, input: string, offset: number): string[];
 //# sourceMappingURL=completions.d.ts.map

package/dist/combinators/completions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"completions.d.ts","sourceRoot":"","sources":["../../src/combinators/completions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,aAAa,CAAA;AAEtE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,EAC3B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,MAAM,EAAE,CAYV"}
+{"version":3,"file":"completions.d.ts","sourceRoot":"","sources":["../../src/combinators/completions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,aAAa,CAAA;AAEtE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAC3B,UAAU,EAAE,UAAU,CAAC,OAAO,CAAC,EAC/B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,MAAM,EAAE,CAYV"}

package/dist/combinators/grammar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"grammar.d.ts","sourceRoot":"","sources":["../../src/combinators/grammar.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAGxE,MAAM,MAAM,YAAY,GAAG;IACzB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,aAAa,GAAG,YAAY,GAAG;IACzC,MAAM,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,CAAA;IAC5B,gFAAgF;IAChF,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB,CAAA;AAED,MAAM,WAAW,cAAc,CAAC,CAAC,CAAE,SAAQ,UAAU,CAAC,CAAC,CAAC;IACtD,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAAA;IACpC,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,WAAW,CAAC,CAAC,CAAC,CAAA;CACrE;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CA6BrF;AAED,wBAAgB,KAAK,CAAC,CAAC,EACrB,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EACzB,KAAK,EAAE,MAAM,EACb,IAAI,GAAE,YAAiB,GACtB,WAAW,CAAC,CAAC,CAAC,CAehB"}
+{"version":3,"file":"grammar.d.ts","sourceRoot":"","sources":["../../src/combinators/grammar.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAGxE,MAAM,MAAM,YAAY,GAAG;IACzB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,aAAa,GAAG,YAAY,GAAG;IACzC,MAAM,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,CAAA;IAC5B,gFAAgF;IAChF,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB,CAAA;AAED,MAAM,WAAW,cAAc,CAAC,CAAC,CAAE,SAAQ,UAAU,CAAC,CAAC,CAAC;IACtD,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAAA;IACpC,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,WAAW,CAAC,CAAC,CAAC,CAAA;CACrE;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAkCrF;AAED,wBAAgB,KAAK,CAAC,CAAC,EACrB,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EACzB,KAAK,EAAE,MAAM,EACb,IAAI,GAAE,YAAiB,GACtB,WAAW,CAAC,CAAC,CAAC,CAehB"}

package/dist/combinators/keywords.d.ts

@@ -8,6 +8,28 @@ export type KeywordsOptions = {
      */
     boundary?: string;
 };
+/**
+ * Match a single keyword with an automatic word-boundary guard. Prevents
+ * matching `true` inside `trueish`. The boundary defaults to `_0-9A-Za-z`,
+ * which covers most programming-language identifiers.
+ *
+ *   word('true')              // matches "true" but not "trueish"
+ *   word('color', 'A-Za-z-') // CSS-style identifier boundary
+ */
+export declare function word(str: string, boundary?: string): Combinator<string>;
+/**
+ * Create a keyword factory with a fixed word-boundary class. Use when many
+ * keywords share the same boundary (e.g. CSS identifiers). For a single keyword,
+ * `word(str, boundary?)` is enough; you can also roll your own factory with
+ * `(s) => word(s, boundary)`.
+ *
+ *   const kw = makeWord()                    // default: '_0-9A-Za-z'
+ *   const cssKw = makeWord('A-Za-z0-9_-')    // dashes allowed in CSS idents
+ *
+ *   const query = kw('query')
+ *   const color = cssKw('color')             // matches "color" but not "color-scheme"
+ */
+export declare function makeWord(boundary?: string): (str: string) => Combinator<string>;
 /**
  * Match any one of a set of fixed keywords, longest-first (so `border` wins over
  * `bord`), with an optional trailing word-boundary guard. Compiles to a single

package/dist/combinators/keywords.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"keywords.d.ts","sourceRoot":"","sources":["../../src/combinators/keywords.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAmD,MAAM,aAAa,CAAA;AAI9F,MAAM,MAAM,eAAe,GAAG;IAC5B,gCAAgC;IAChC,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAMD;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,GAAE,eAAoB,GAAG,UAAU,CAAC,MAAM,CAAC,CA4CjG"}
+{"version":3,"file":"keywords.d.ts","sourceRoot":"","sources":["../../src/combinators/keywords.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAmD,MAAM,aAAa,CAAA;AAK9F,MAAM,MAAM,eAAe,GAAG;IAC5B,gCAAgC;IAChC,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,SAAe,GAAG,UAAU,CAAC,MAAM,CAAC,CAE7E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,SAAe,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,UAAU,CAAC,MAAM,CAAC,CAErF;AAMD;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,GAAE,eAAoB,GAAG,UAAU,CAAC,MAAM,CAAC,CA2CjG"}

package/dist/combinators/literal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"literal.d.ts","sourceRoot":"","sources":["../../src/combinators/literal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,MAAM,aAAa,CAAA;AAYpF,MAAM,MAAM,cAAc,GAAG;IAC3B,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B,CAAA;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,cAAmB,GAAG,UAAU,CAAC,MAAM,CAAC,CAgDpF"}
+{"version":3,"file":"literal.d.ts","sourceRoot":"","sources":["../../src/combinators/literal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,MAAM,aAAa,CAAA;AAapF,MAAM,MAAM,cAAc,GAAG;IAC3B,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B,CAAA;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,cAAmB,GAAG,UAAU,CAAC,MAAM,CAAC,CA+CpF"}

package/dist/combinators/map.d.ts

@@ -1,8 +1,14 @@
 import type { Combinator } from '../types.ts';
-export declare function transform<T, U>(parser: Combinator<T>, fn: (value: T, span: {
+export declare function transform<T, U>(combinator: Combinator<T>, fn: (value: T, span: {
     start: number;
     end: number;
 }) => U): Combinator<U>;
 export declare function skip<T, S>(main: Combinator<T>, skipped: Combinator<S>): Combinator<T>;
-export declare function trivia<T>(parser: Combinator<T>): Combinator<T>;
+export declare function trivia<T>(combinator: Combinator<T>): Combinator<T>;
+/**
+ * Attach a string label to a parser arm (e.g. trivia `choice` branches).
+ * Parse behavior is unchanged; the label is metadata for tooling and future
+ * trivia-kind capture (`'whitespace'`, `'blockComment'`, …).
+ */
+export declare function label<T>(name: string, combinator: Combinator<T>): Combinator<T>;
 //# sourceMappingURL=map.d.ts.map

package/dist/combinators/map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../src/combinators/map.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAA6B,MAAM,aAAa,CAAA;AAExE,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAC5B,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,EACrB,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,KAAK,CAAC,GACxD,UAAU,CAAC,CAAC,CAAC,CAWf;AAED,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAarF;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAO9D"}
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../src/combinators/map.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAA6B,MAAM,aAAa,CAAA;AAGxE,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAC5B,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EACzB,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,KAAK,CAAC,GACxD,UAAU,CAAC,CAAC,CAAC,CAWf;AAED,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAarF;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAYlE;AAED;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAO/E"}

package/dist/combinators/node.d.ts

@@ -1,17 +1,16 @@
 import type { Combinator } from '../types.ts';
 /**
- * A CST/AST node rule. Runs `parser` while collecting its terminals (and, when
- * trivia capture is on, the trivia between them) into `children` / `rawChildren`
- * arrays, then calls `build(children, rawChildren, span)` to produce the node.
- *
- * This is the functional replacement for the class `Parser`'s capital-letter
- * rules + `buildNode`: capture is owned by the library (here and in the
- * compiler), so grammar authors don't hand-wrap terminals or reconstruct trivia.
+ * A CST/AST node rule. Runs `combinator` while collecting its terminals into
+ * `children` / `rawChildren` arrays and trivia spans into `triviaLog`, then
+ * calls `build(children, rawChildren, span, triviaLog)` to produce the node.
  *
  *   - `children`    — structural items in source order: spanned CSTLeaf terminals
  *                     and sub-nodes (whatever `build` returned for inner nodes).
- *   - `rawChildren` — the same, plus CSTTrivia tokens for trivia consumed between
- *                     terms (only when the parse runs with `captureTrivia`).
+ *   - `rawChildren` — structural children only (same items as `children`).
+ *   - `triviaLog`   — flat log of trivia entries: each entry is `[start, end, insertIdx]`
+ *                     consumed between terms. `insertIdx` is the rawChildren index
+ *                     before which the trivia was consumed. Use `buildTriviaIndex`
+ *                     to turn this into a before/after lookup table.
  *
  * If `build` returns a non-node value (e.g. a bare string for a collapsed rule),
  * the parent records it as a spanned leaf so its source span is still recoverable.
@@ -19,6 +18,6 @@ import type { Combinator } from '../types.ts';
 export type BuildNode<N> = (children: ReadonlyArray<unknown>, rawChildren: ReadonlyArray<unknown>, span: {
     start: number;
     end: number;
-}) => N;
-export declare function node<N>(type: string, parser: Combinator<unknown>, build: BuildNode<N>): Combinator<N>;
+}, triviaLog: readonly number[], state: unknown) => N;
+export declare function node<N>(type: string, combinator: Combinator<unknown>, build: BuildNode<N>): Combinator<N>;
 //# sourceMappingURL=node.d.ts.map

package/dist/combinators/node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/combinators/node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,MAAM,aAAa,CAAA;AAEpF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CACzB,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC,EAChC,WAAW,EAAE,aAAa,CAAC,OAAO,CAAC,EACnC,IAAI,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,KACjC,CAAC,CAAA;AAEN,wBAAgB,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAoCrG"}
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/combinators/node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,MAAM,aAAa,CAAA;AAGpF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CACzB,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC,EAChC,WAAW,EAAE,aAAa,CAAC,OAAO,CAAC,EACnC,IAAI,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EACpC,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,KAAK,EAAE,OAAO,KACX,CAAC,CAAA;AAEN,wBAAgB,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CA+BzG"}

package/dist/combinators/not.d.ts

@@ -1,7 +1,7 @@
 import type { Combinator } from '../types.ts';
 /**
- * Negative lookahead. Succeeds (consuming nothing) when `parser` fails;
- * fails when `parser` succeeds.
+ * Negative lookahead. Succeeds (consuming nothing) when `combinator` fails;
+ * fails when `combinator` succeeds.
  *
  * The standard way to match a keyword without also matching the prefix
  * of a longer identifier:
@@ -9,5 +9,5 @@ import type { Combinator } from '../types.ts';
  *   const kwTrue = sequence(literal('true'), not(regex(/\w/)))
  *   // matches "true" in "true && x" but NOT in "trueish" or "trueness"
  */
-export declare function not(parser: Combinator<unknown>): Combinator<null>;
+export declare function not(combinator: Combinator<unknown>): Combinator<null>;
 //# sourceMappingURL=not.d.ts.map

package/dist/combinators/not.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"not.d.ts","sourceRoot":"","sources":["../../src/combinators/not.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,MAAM,aAAa,CAAA;AAGpF;;;;;;;;;GASG;AACH,wBAAgB,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,UAAU,CAAC,IAAI,CAAC,CAmBjE"}
+{"version":3,"file":"not.d.ts","sourceRoot":"","sources":["../../src/combinators/not.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,MAAM,aAAa,CAAA;AAGpF;;;;;;;;;GASG;AACH,wBAAgB,GAAG,CAAC,UAAU,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,UAAU,CAAC,IAAI,CAAC,CAmBrE"}

package/dist/combinators/recover.d.ts

@@ -1,7 +1,7 @@
 import type { Combinator, ParseError } from '../types.ts';
 export type { ParseError };
 /**
- * Error-recovery combinator. Tries `parser`; on success returns normally.
+ * Error-recovery combinator. Tries `combinator`; on success returns normally.
  * On failure, scans forward one character at a time until `sentinel` matches
  * (or EOF), then returns a ParseError node spanning the skipped range.
  * The sentinel is NOT consumed — the caller's grammar continues from there.
@@ -15,6 +15,6 @@ export type { ParseError };
  *     recover(exprStmt, literal(';'))
  *   )
  */
-export declare function recover<T>(parser: Combinator<T>, sentinel: Combinator<unknown>): Combinator<T | ParseError>;
+export declare function recover<T>(combinator: Combinator<T>, sentinel: Combinator<unknown>): Combinator<T | ParseError>;
 export declare function isParseError(value: unknown): value is ParseError;
 //# sourceMappingURL=recover.d.ts.map

package/dist/combinators/recover.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recover.d.ts","sourceRoot":"","sources":["../../src/combinators/recover.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,UAAU,EAAE,MAAM,aAAa,CAAA;AAEhG,YAAY,EAAE,UAAU,EAAE,CAAA;AAE1B;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,EACrB,QAAQ,EAAE,UAAU,CAAC,OAAO,CAAC,GAC5B,UAAU,CAAC,CAAC,GAAG,UAAU,CAAC,CA6B5B;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAEhE"}
+{"version":3,"file":"recover.d.ts","sourceRoot":"","sources":["../../src/combinators/recover.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,UAAU,EAAE,MAAM,aAAa,CAAA;AAEhG,YAAY,EAAE,UAAU,EAAE,CAAA;AAE1B;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EACzB,QAAQ,EAAE,UAAU,CAAC,OAAO,CAAC,GAC5B,UAAU,CAAC,CAAC,GAAG,UAAU,CAAC,CA6B5B;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAEhE"}

package/dist/combinators/regex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"regex.d.ts","sourceRoot":"","sources":["../../src/combinators/regex.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAmD,MAAM,aAAa,CAAA;AA4H9F,wBAAgB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,SAAK,GAAG,UAAU,CAAC,MAAM,CAAC,CA2B9E"}
+{"version":3,"file":"regex.d.ts","sourceRoot":"","sources":["../../src/combinators/regex.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAmD,MAAM,aAAa,CAAA;AA6H9F,wBAAgB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,SAAK,GAAG,UAAU,CAAC,MAAM,CAAC,CA0B9E"}

package/dist/combinators/repeat.d.ts

@@ -1,6 +1,6 @@
 import type { Combinator } from '../types.ts';
-export declare function many<T>(parser: Combinator<T>): Combinator<T[]>;
-export declare function oneOrMore<T>(parser: Combinator<T>): Combinator<T[]>;
-export declare function optional<T>(parser: Combinator<T>): Combinator<T | null>;
-export declare function sepBy<T, S>(parser: Combinator<T>, separator: Combinator<S>): Combinator<T[]>;
+export declare function many<T>(combinator: Combinator<T>): Combinator<T[]>;
+export declare function oneOrMore<T>(combinator: Combinator<T>): Combinator<T[]>;
+export declare function optional<T>(combinator: Combinator<T>): Combinator<T | null>;
+export declare function sepBy<T, S>(combinator: Combinator<T>, separator: Combinator<S>): Combinator<T[]>;
 //# sourceMappingURL=repeat.d.ts.map

package/dist/combinators/repeat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"repeat.d.ts","sourceRoot":"","sources":["../../src/combinators/repeat.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,MAAM,aAAa,CAAA;AA+CpF,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CAuB9D;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CA2BnE;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,GAAG,IAAI,CAAC,CAiBvE;AAED,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CA6B5F"}
+{"version":3,"file":"repeat.d.ts","sourceRoot":"","sources":["../../src/combinators/repeat.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,MAAM,aAAa,CAAA;AAkDpF,wBAAgB,IAAI,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CAuBlE;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CA2BvE;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,GAAG,IAAI,CAAC,CAiB3E;AAED,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CAuDhG"}

package/dist/combinators/scanTo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scanTo.d.ts","sourceRoot":"","sources":["../../src/combinators/scanTo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,MAAM,aAAa,CAAA;AAMpF,MAAM,MAAM,aAAa,GAAG;IAC1B,uGAAuG;IACvG,IAAI,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,CAAA;IAC5B;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB,CAAA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,MAAM,CACpB,QAAQ,EAAE,UAAU,CAAC,OAAO,CAAC,EAC7B,EAAE,IAAS,EAAE,KAAa,EAAE,GAAE,aAAkB,GAC/C,UAAU,CAAC,MAAM,CAAC,CA+DpB;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,aAAkB,GAC1B,UAAU,CAAC,MAAM,CAAC,CAYpB"}
+{"version":3,"file":"scanTo.d.ts","sourceRoot":"","sources":["../../src/combinators/scanTo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,MAAM,aAAa,CAAA;AAOpF,MAAM,MAAM,aAAa,GAAG;IAC1B,uGAAuG;IACvG,IAAI,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,CAAA;IAC5B;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB,CAAA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,MAAM,CACpB,QAAQ,EAAE,UAAU,CAAC,OAAO,CAAC,EAC7B,EAAE,IAAS,EAAE,KAAa,EAAE,GAAE,aAAkB,GAC/C,UAAU,CAAC,MAAM,CAAC,CA8DpB;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,aAAkB,GAC1B,UAAU,CAAC,MAAM,CAAC,CAYpB"}

package/dist/combinators/sequence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sequence.d.ts","sourceRoot":"","sources":["../../src/combinators/sequence.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAoD,MAAM,aAAa,CAAA;AAI/F,KAAK,aAAa,CAAC,CAAC,SAAS,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI;KACnD,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,UAAU,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK;CAC7D,CAAA;AAED,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,GAAG,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC,EAChF,GAAG,OAAO,EAAE,CAAC,GACZ,UAAU,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAqD9B"}
+{"version":3,"file":"sequence.d.ts","sourceRoot":"","sources":["../../src/combinators/sequence.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAoD,MAAM,aAAa,CAAA;AAI/F,KAAK,aAAa,CAAC,CAAC,SAAS,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI;KACnD,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,UAAU,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK;CAC7D,CAAA;AAED,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,GAAG,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC,EAChF,GAAG,OAAO,EAAE,CAAC,GACZ,UAAU,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAuD9B"}

package/dist/combinators/trivia-skip.d.ts

@@ -10,19 +10,25 @@ export type TriviaScan = {
     end: number;
     commit: () => void;
 };
+/** Saved lengths for rolling back speculative trivia commits. */
+export type TriviaRollbackMark = {
+    raw: number;
+    tlog: number;
+    leaves: number;
+    log: number;
+};
+/** True when trivia recording must be deferred until the following term commits. */
+export declare function needsDeferredTriviaCommit(ctx: ParseContext): boolean;
+export declare function saveTriviaMark(ctx: ParseContext): TriviaRollbackMark;
+export declare function rollbackTrivia(ctx: ParseContext, mark: TriviaRollbackMark): void;
+/**
+ * Skip trivia at `cur` and return the new position. No recording, no wrapper
+ * object — use between sequence/repeat terms when CST trivia capture is off.
+ */
+export declare function advanceTrivia(input: string, cur: number, ctx: ParseContext): number;
 /**
  * Scan trivia at `cur` using `ctx.trivia`, WITHOUT recording it. Returns the
  * position after the trivia (or `cur` if none) and a `commit()` to record it.
- *
- * Recording is gated on `ctx.captureTrivia`:
- *   - capture off (default): commit() is a no-op; trivia is skipped silently.
- *   - capture on (and a rawChildren collector is active): commit() records each
- *     maximal trivia sub-match (a whitespace run or a comment) as a separate
- *     CSTTrivia token. Relies on the trivia parser being structured so each
- *     token is a distinct leaf match.
- *
- * The trivia parser always runs with `trivia` unset in its sub-context so it
- * cannot recurse into itself.
  */
 export declare function scanTrivia(input: string, cur: number, ctx: ParseContext): TriviaScan;
 /**

package/dist/combinators/trivia-skip.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trivia-skip.d.ts","sourceRoot":"","sources":["../../src/combinators/trivia-skip.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAI/C;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,IAAI,CAAA;CAAE,CAAA;AAI5D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,UAAU,CA0CpF;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,MAAM,CAInF"}
+{"version":3,"file":"trivia-skip.d.ts","sourceRoot":"","sources":["../../src/combinators/trivia-skip.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAc/C;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,IAAI,CAAA;CAAE,CAAA;AAE5D,iEAAiE;AACjE,MAAM,MAAM,kBAAkB,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAA;AAI3F,oFAAoF;AACpF,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAEpE;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,YAAY,GAAG,kBAAkB,CAGpE;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,kBAAkB,GAAG,IAAI,CAGhF;AAiBD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,MAAM,CASnF;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,UAAU,CA6BpF;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,MAAM,CAKnF"}

package/dist/combinators/withCtx.d.ts

@@ -1,6 +1,6 @@
 import type { Combinator } from '../types.ts';
 /**
- * Runs `parser` with `ctx.state` set to `extra` for the duration of the parse.
+ * Runs `combinator` with `ctx.state` set to `extra` for the duration of the parse.
  * The outer user context is restored on exit (lexical scoping).
  *
  *   const functionBody = withCtx({ inFn: true },
@@ -9,5 +9,5 @@ import type { Combinator } from '../types.ts';
  *
  * Read back with guard() or from within a transform's span argument.
  */
-export declare function withCtx<U, T>(extra: U, parser: Combinator<T>): Combinator<T>;
+export declare function withCtx<U, T>(extra: U, combinator: Combinator<T>): Combinator<T>;
 //# sourceMappingURL=withCtx.d.ts.map

package/dist/combinators/withCtx.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"withCtx.d.ts","sourceRoot":"","sources":["../../src/combinators/withCtx.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,MAAM,aAAa,CAAA;AAEpF;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAc5E"}
+{"version":3,"file":"withCtx.d.ts","sourceRoot":"","sources":["../../src/combinators/withCtx.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,MAAM,aAAa,CAAA;AAEpF;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAchF"}

package/dist/compiler/codegen.d.ts

@@ -6,9 +6,11 @@
  * `break <label>` rather than an IIFE return — no function call, no result
  * object allocation per node.
  */
-import type { Combinator, ParseResult, ParseError } from '../types.ts';
+import type { Combinator, ParseResult, ParseContext, ParseError } from '../types.ts';
 export type CompiledParser<T> = {
     parse(input: string, pos?: number): ParseResult<T>;
+    /** Like parse(), but with a caller-supplied ParseContext (e.g. `_triviaLog` for CST grammars). */
+    parseWithContext(input: string, ctx: ParseContext, pos?: number): ParseResult<T>;
     /**
      * Like parse(), but activates error recovery. recover() nodes collect their
      * ParseErrors into result.errors instead of (only) embedding them as values.
@@ -28,5 +30,5 @@ export type CompiledParser<T> = {
      */
     inlineExpression: string | null;
 };
-export declare function compile<T>(parser: Combinator<T>, mapFnSources?: string[]): CompiledParser<T>;
+export declare function compile<T>(combinator: Combinator<T>, mapFnSources?: string[]): CompiledParser<T>;
 //# sourceMappingURL=codegen.d.ts.map

package/dist/compiler/codegen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codegen.d.ts","sourceRoot":"","sources":["../../src/compiler/codegen.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,UAAU,EAAuB,WAAW,EAAgB,UAAU,EAAkB,MAAM,aAAa,CAAA;AA6lCzH,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI;IAC9B,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAAA;IAClD;;;;OAIG;IACH,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG;QAAE,MAAM,EAAE,UAAU,EAAE,CAAA;KAAE,CAAA;IACvF,iEAAiE;IACjE,MAAM,EAAE,MAAM,CAAA;IACd;;;;;;OAMG;IACH,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAA;CAChC,CAAA;AAgCD,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,EAAE,MAAM,EAAE,GAAG,cAAc,CAAC,CAAC,CAAC,CAqF5F"}
+{"version":3,"file":"codegen.d.ts","sourceRoot":"","sources":["../../src/compiler/codegen.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,UAAU,EAAuB,WAAW,EAAE,YAAY,EAAE,UAAU,EAAkB,MAAM,aAAa,CAAA;AAuwCzH,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI;IAC9B,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAAA;IAClD,kGAAkG;IAClG,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAAA;IAChF;;;;OAIG;IACH,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG;QAAE,MAAM,EAAE,UAAU,EAAE,CAAA;KAAE,CAAA;IACvF,iEAAiE;IACjE,MAAM,EAAE,MAAM,CAAA;IACd;;;;;;OAMG;IACH,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAA;CAChC,CAAA;AAiCD,wBAAgB,OAAO,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,EAAE,MAAM,EAAE,GAAG,cAAc,CAAC,CAAC,CAAC,CAgGhG"}

package/dist/compiler/inline-build.d.ts

@@ -0,0 +1,11 @@
+import type { ParserDef } from '../types.ts';
+/**
+ * When a node() build is a thin `mk(type, …)` wrapper, emit the object literal
+ * at the call site instead of `_build[n](…)`.
+ */
+export declare function analyzeMkInlineBuild(def: Extract<ParserDef, {
+    tag: 'node';
+}>): string | null;
+/** Object literal matching `stub-build.ts` `mk()` without the function call. */
+export declare function emitInlineMkNodeExpr(type: string, chV: string, rawV: string, pos: string, endVar: string, tlV: string): string;
+//# sourceMappingURL=inline-build.d.ts.map

package/dist/compiler/inline-build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-build.d.ts","sourceRoot":"","sources":["../../src/compiler/inline-build.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAiB5C;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,CAAC,SAAS,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,MAAM,GAAG,IAAI,CAS5F;AAED,gFAAgF;AAChF,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,GACV,MAAM,CAER"}

package/dist/compiler/inline-callback.d.ts

@@ -0,0 +1,12 @@
+/** Source text for a transform callback — macro `fnSrc` or arrow `toString()`. */
+export declare function transformFnSource(fn: Function, fnSrc?: string | null): string | null;
+/** `s => expr` / `() => expr` when expr only uses the param (+ builtins). */
+export declare function tryInlineUnaryTransform(src: string, valueVar: string): string | null;
+/** Parse `[a, , c]` destructuring slots (null = ignore). */
+export declare function parseArrayDestructure(pattern: string, arity: number): (string | null)[];
+/**
+ * `([x, y]) => body` — substitute destructure names with sequence value vars.
+ * Caller must ensure body only references slotted params (+ builtins).
+ */
+export declare function tryInlineDestructureTransform(src: string, valueVars: string[]): string | null;
+//# sourceMappingURL=inline-callback.d.ts.map

package/dist/compiler/inline-callback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-callback.d.ts","sourceRoot":"","sources":["../../src/compiler/inline-callback.ts"],"names":[],"mappings":"AAUA,kFAAkF;AAClF,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAKpF;AAwBD,6EAA6E;AAC7E,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAWpF;AAED,4DAA4D;AAC5D,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAQvF;AAED;;;GAGG;AACH,wBAAgB,6BAA6B,CAC3C,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,EAAE,GAClB,MAAM,GAAG,IAAI,CAWf"}

package/dist/compiler/trivia-fast-path.d.ts

@@ -0,0 +1,24 @@
+import type { Combinator } from '../types.ts';
+import type { LabeledTriviaSpec } from '../cst/trivia-kinds.ts';
+export type TriviaFastKind = 'wsComments' | 'wsOnly';
+/**
+ * Detect trivia shapes safe to lower to a hand-rolled scan loop in compiled output.
+ * Matches CSS `rw` (`oneOrMore(choice(ws, blockComment))`) and ASCII ws-only grammars.
+ * Single alternation regexes are excluded — one regex exec matches only one arm per call.
+ */
+export declare function analyzeTriviaFastPath(trivia: Combinator<unknown>): TriviaFastKind | null;
+/** Emit a specialized `_tfN` that skips trivia without regex / combinator dispatch. */
+export declare function buildFastTriviaFnDecl(fnName: string, kind: TriviaFastKind, kindIndices?: {
+    ws: number;
+    comment: number;
+}): string;
+/** Labeled trivia with regex arms — per-chunk kind capture in compiled output. */
+export declare function buildLabeledRegexTriviaFnDecl(fnName: string, spec: LabeledTriviaSpec, reNames: string[]): string;
+export declare function labeledTriviaKindIndices(trivia: Combinator<unknown>): {
+    ws: number;
+    comment: number;
+} | null;
+export declare function labeledTriviaRegexArms(trivia: Combinator<unknown>): LabeledTriviaSpec | null;
+/** Labeled trivia via per-arm runtime parsers (non-regex or mixed arms). */
+export declare function buildLabeledRuntimeTriviaFnDecl(fnName: string, spec: LabeledTriviaSpec, rpStartIndex: number): string;
+//# sourceMappingURL=trivia-fast-path.d.ts.map

package/dist/compiler/trivia-fast-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trivia-fast-path.d.ts","sourceRoot":"","sources":["../../src/compiler/trivia-fast-path.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAE7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAG/D,MAAM,MAAM,cAAc,GAAG,YAAY,GAAG,QAAQ,CAAA;AAsCpD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,cAAc,GAAG,IAAI,CA6BxF;AAmED,uFAAuF;AACvF,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,cAAc,EACpB,WAAW,CAAC,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAC5C,MAAM,CAeR;AAYD,kFAAkF;AAClF,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,MAAM,EAAE,GAChB,MAAM,CA+BR;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAO5G;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,iBAAiB,GAAG,IAAI,CAO5F;AAED,4EAA4E;AAC5E,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,iBAAiB,EACvB,YAAY,EAAE,MAAM,GACnB,MAAM,CA8BR"}

package/dist/cst/capture-buffer.d.ts

@@ -0,0 +1,46 @@
+import type { ParseContext } from '../types.ts';
+/** Lazy per-node capture state — arrays materialized on first push. */
+export type CstCaptureBuf = {
+    single?: unknown | undefined;
+    ch?: unknown[] | undefined;
+    rawSingle?: unknown | undefined;
+    raw?: unknown[] | undefined;
+    tl?: number[] | undefined;
+};
+export declare function cstCaptureActive(ctx: ParseContext): boolean;
+export type CstNodeCaptureSaved = {
+    ch: ParseContext['_cstChildren'];
+    lv: ParseContext['_cstLeaves'];
+    raw: ParseContext['_cstRawChildren'];
+    tl: ParseContext['_cstTriviaLog'];
+    cap: boolean | undefined;
+    buf: CstCaptureBuf | undefined;
+};
+export declare function beginCstNodeCapture(ctx: ParseContext): CstNodeCaptureSaved;
+export declare function finishCstBuf(buf: CstCaptureBuf | undefined): {
+    children: unknown[];
+    rawChildren: unknown[];
+    triviaLog: number[];
+};
+export declare function endCstNodeCapture(ctx: ParseContext, saved: CstNodeCaptureSaved): {
+    children: unknown[];
+    rawChildren: unknown[];
+    triviaLog: number[];
+};
+export declare function pushCstLeaf(ctx: ParseContext, leaf: unknown): void;
+/** Record a built sub-node into the active collector (children vs rawChildren may differ). */
+export declare function pushCstChild(ctx: ParseContext, built: unknown, rawEntry: unknown): void;
+export declare function cstRawLen(ctx: ParseContext): number;
+export declare function cstLeavesLen(ctx: ParseContext): number;
+export declare function cstTlLen(ctx: ParseContext): number;
+export type CstRollbackMark = {
+    raw: number;
+    tlog: number;
+    leaves: number;
+};
+export declare function saveCstMark(ctx: ParseContext): CstRollbackMark;
+export declare function rollbackCstCapture(ctx: ParseContext, mark: CstRollbackMark): void;
+export declare function pushCstTriviaEntry(ctx: ParseContext, start: number, end: number, kindIndex?: number): void;
+export declare function pushTriviaLogEntry(ctx: ParseContext, start: number, end: number, kindIndex?: number): void;
+export declare function cstDeferredTriviaActive(ctx: ParseContext): boolean;
+//# sourceMappingURL=capture-buffer.d.ts.map

package/dist/cst/capture-buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture-buffer.d.ts","sourceRoot":"","sources":["../../src/cst/capture-buffer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,uEAAuE;AACvE,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC5B,EAAE,CAAC,EAAE,OAAO,EAAE,GAAG,SAAS,CAAA;IAC1B,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC/B,GAAG,CAAC,EAAE,OAAO,EAAE,GAAG,SAAS,CAAA;IAC3B,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAA;CAC1B,CAAA;AAKD,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAE3D;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,EAAE,YAAY,CAAC,cAAc,CAAC,CAAA;IAChC,EAAE,EAAE,YAAY,CAAC,YAAY,CAAC,CAAA;IAC9B,GAAG,EAAE,YAAY,CAAC,iBAAiB,CAAC,CAAA;IACpC,EAAE,EAAE,YAAY,CAAC,eAAe,CAAC,CAAA;IACjC,GAAG,EAAE,OAAO,GAAG,SAAS,CAAA;IACxB,GAAG,EAAE,aAAa,GAAG,SAAS,CAAA;CAC/B,CAAA;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,YAAY,GAAG,mBAAmB,CAgB1E;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,aAAa,GAAG,SAAS,GAAG;IAC5D,QAAQ,EAAE,OAAO,EAAE,CAAA;IACnB,WAAW,EAAE,OAAO,EAAE,CAAA;IACtB,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB,CAMA;AAED,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,YAAY,EACjB,KAAK,EAAE,mBAAmB,GACzB;IAAE,QAAQ,EAAE,OAAO,EAAE,CAAC;IAAC,WAAW,EAAE,OAAO,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAA;CAAE,CAStE;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAElE;AAED,8FAA8F;AAC9F,wBAAgB,YAAY,CAAC,GAAG,EAAE,YAAY,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,GAAG,IAAI,CAevF;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAOnD;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAOtD;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAIlD;AAED,MAAM,MAAM,eAAe,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AAE3E,wBAAgB,WAAW,CAAC,GAAG,EAAE,YAAY,GAAG,eAAe,CAM9D;AAkBD,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,eAAe,GAAG,IAAI,CAcjF;AAED,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,YAAY,EACjB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,SAAS,CAAC,EAAE,MAAM,GACjB,IAAI,CAkBN;AAED,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,YAAY,EACjB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,SAAS,CAAC,EAAE,MAAM,GACjB,IAAI,CAON;AAED,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAElE"}

package/dist/cst/trivia-entries.d.ts

@@ -0,0 +1,20 @@
+/** View over a flat trivia log (`_triviaLog` or per-node `triviaLog`). */
+export type TriviaEntriesView = {
+    readonly length: number;
+    readonly labels: readonly string[] | undefined;
+    readonly stride: number;
+    start(i: number): number;
+    end(i: number): number;
+    kindIndex(i: number): number | undefined;
+    kind(i: number): string | undefined;
+    text(i: number, input: string): string;
+};
+/**
+ * Wrap a flat trivia log. Stride is inferred from `labels`:
+ * - root `_triviaLog`: 2 (start, end) or 3 (+ kindIndex)
+ * - node `triviaLog`: 3 (start, end, insertIdx) or 4 (+ kindIndex)
+ */
+export declare function triviaEntries(log: readonly number[], labels?: readonly string[], opts?: {
+    nodeLog?: boolean;
+}): TriviaEntriesView;
+//# sourceMappingURL=trivia-entries.d.ts.map

package/dist/cst/trivia-entries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trivia-entries.d.ts","sourceRoot":"","sources":["../../src/cst/trivia-entries.ts"],"names":[],"mappings":"AAAA,0EAA0E;AAC1E,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAA;IAC9C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACxB,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACtB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA;IACxC,IAAI,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA;IACnC,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CACvC,CAAA;AAMD;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,SAAS,MAAM,EAAE,EACtB,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,EAC1B,IAAI,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,GAC3B,iBAAiB,CA6BnB"}