parseman 0.2.0 → 0.3.0

package/dist/combinators/probe.d.ts

@@ -0,0 +1,13 @@
+import type { ParseContext, ParseFail } from '../types.ts';
+/**
+ * Creates a ParseFail and, if a completions probe is active, records it.
+ *
+ * Rules:
+ * - Only failures at or before the probe's target offset are eligible.
+ * - A deeper failure (higher pos) replaces the current best.
+ * - A tie (same pos) merges expected arrays — this is what makes choice arms
+ *   aggregate their alternatives rather than each overwriting the last.
+ * - Shallower failures are ignored.
+ */
+export declare function failAt(ctx: ParseContext, expected: string[], pos: number): ParseFail;
+//# sourceMappingURL=probe.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"probe.d.ts","sourceRoot":"","sources":["../../src/combinators/probe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAE1D;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,CAYpF"}

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,CA4B5B;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,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"}

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;AA2H9F,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;AA4H9F,wBAAgB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,SAAK,GAAG,UAAU,CAAC,MAAM,CAAC,CA2B9E"}

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;AAEpF,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CAwB9D;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CA0BnE;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,CA+B5F"}
+{"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"}

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,CA6CpB;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,aAAkB,GAC1B,UAAU,CAAC,MAAM,CAAC,CAMpB"}
+{"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"}

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;AAG/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,CAuC9B"}
+{"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"}

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

@@ -0,0 +1,33 @@
+import type { ParseContext } from '../types.ts';
+/**
+ * Result of scanning trivia: the position after it, plus a `commit()` that
+ * records the matched trivia tokens into the active rawChildren collector.
+ * Recording is deferred so callers that may reject the following item (e.g.
+ * many()/oneOrMore() retries) can advance speculatively without recording
+ * trivia that doesn't actually sit between two accepted items.
+ */
+export type TriviaScan = {
+    end: number;
+    commit: () => void;
+};
+/**
+ * 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;
+/**
+ * Consume trivia at `cur`, recording it immediately. For callers that always
+ * accept the trivia between two committed terms (e.g. sequence/sepBy).
+ */
+export declare function consumeTrivia(input: string, cur: number, ctx: ParseContext): number;
+//# sourceMappingURL=trivia-skip.d.ts.map

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

@@ -0,0 +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"}

package/dist/combinators/withCtx.d.ts

@@ -1,6 +1,6 @@
 import type { Combinator } from '../types.ts';
 /**
- * Runs `parser` with `ctx.user` set to `extra` for the duration of the parse.
+ * Runs `parser` 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 },

package/dist/compiler/codegen.d.ts

@@ -2,12 +2,21 @@
  * Compile a Combinator<T> definition tree into an optimized JavaScript function.
  *
  * Design: every sub-emitter uses early-return on failure. Fallible contexts
- * (many loops, non-disjoint choice arms) wrap inner code in IIFEs so
- * early-return keeps working uniformly throughout.
+ * (optional, sepBy loops, many loops) use labeled blocks so early-exit is a
+ * `break <label>` rather than an IIFE return — no function call, no result
+ * object allocation per node.
  */
-import type { Combinator, ParseResult } from '../types.ts';
+import type { Combinator, ParseResult, ParseError } from '../types.ts';
 export type CompiledParser<T> = {
     parse(input: string, 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.
+     * Always returns ParseOk — top-level failures are still ParseFail.
+     */
+    parseWithErrors(input: string, pos?: number): ParseResult<T> & {
+        errors: ParseError[];
+    };
     /** The generated source (for inspection / future source maps) */
     source: string;
     /**
@@ -19,5 +28,5 @@ export type CompiledParser<T> = {
      */
     inlineExpression: string | null;
 };
-export declare function compile<T>(parser: Combinator<T>): CompiledParser<T>;
+export declare function compile<T>(parser: 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;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,UAAU,EAAuB,WAAW,EAAgC,MAAM,aAAa,CAAA;AAowB7G,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI;IAC9B,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAAA;IAClD,iEAAiE;IACjE,MAAM,EAAE,MAAM,CAAA;IACd;;;;;;OAMG;IACH,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAA;CAChC,CAAA;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CA0DnE"}
+{"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"}

package/dist/cst/grammar.d.ts

@@ -28,7 +28,7 @@ export type Refs<T> = {
  *       Expr = (g: Refs<this>) => choice(g.Atom, sequence(g.Expr, literal('+')))
  *
  * Convention:
- *   Capital letter → CSTNode-producing rule (span + savedContext + children)
+ *   Capital letter → CSTNode-producing rule (span + state + children)
  *   lowercase      → transparent helper (terminals bubble up as CSTLeaf in the
  *                    nearest enclosing capital rule)
  *
@@ -46,6 +46,33 @@ export type Refs<T> = {
  */
 export declare class Parser<N extends NodeLike = CSTNode> {
     private _built;
+    /** Set in a subclass to enable automatic trivia skipping between sequence terms. */
+    protected _trivia?: Combinator<unknown>;
+    /**
+     * Set in a subclass to make the rule name optional in `parse()`.
+     * When defined, `parse(input)` is equivalent to `parse(defaultRule, input)`.
+     */
+    protected _defaultRule?: RuleKeys<this>;
+    /**
+     * Set `true` in a subclass to record trivia (whitespace/comments) consumed
+     * between terms into each node's rawChildren as separate CSTTrivia tokens.
+     * Requires `_trivia` to be set. Default: trivia is skipped without recording.
+     */
+    protected _captureTrivia?: boolean;
+    /**
+     * When set, makeParseDoc injects this array as ctx._triviaLog so each
+     * scanTrivia.commit() pushes [runStart, runEnd] pairs into it.
+     * Reset to [] before each parse() call in any subclass that uses it.
+     */
+    protected _triviaLog?: number[];
+    /**
+     * Optional map of public entry-point aliases → actual rule names. Lets callers
+     * `parse('value', src)` when the grammar's rule is `ValueList`, removing
+     * per-adapter name-translation tables.
+     */
+    protected _aliases?: Record<string, string>;
+    /** Resolve an alias to its target rule name (identity if not aliased). */
+    protected _resolveRule(name: string): string;
     private _build;
     /**
      * Override to produce a custom AST node instead of a plain CSTNode.
@@ -56,7 +83,7 @@ export declare class Parser<N extends NodeLike = CSTNode> {
      * grammar is whitespace-sensitive (e.g. CSS descendant vs adjacent combinators).
      * The default implementation ignores `rawChildren`.
      */
-    protected buildNode(type: string, span: Span, children: ReadonlyArray<N | CSTLeaf | CSTError>, savedContext: unknown, _rawChildren: ReadonlyArray<CSTRawChild>): N;
+    protected buildNode(type: string, span: Span, children: ReadonlyArray<N | CSTLeaf | CSTError>, state: unknown, _rawChildren: ReadonlyArray<CSTRawChild>): N;
     /** Wrap an inner combinator so it produces a CSTNode on each match. */
     private _makeNodeParser;
     /** Reconstruct a node with a new children array (used by IncrementalParser). */
@@ -72,8 +99,12 @@ export declare class Parser<N extends NodeLike = CSTNode> {
      *
      *   // In an editor — just keep calling edit():
      *   const doc2 = doc.edit(newSrc, changeStart, changeEnd)
+     *
+     * If the grammar defines `_defaultRule`, the rule name may be omitted:
+     *   const doc = css.parse(src)  // uses _defaultRule
      */
     parse(ruleName: RuleKeys<this>, input: string): ParseDoc<N>;
+    parse(input: string): ParseDoc<N>;
     /**
      * Get the compiled Combinator for a named rule.
      * Triggers lazy initialization on first call.

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

@@ -1 +1 @@
-{"version":3,"file":"grammar.d.ts","sourceRoot":"","sources":["../../src/cst/grammar.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,IAAI,EAAE,MAAM,aAAa,CAAA;AAE1F,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAa,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAE9F,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAMhD,KAAK,OAAO,GAAG,GAAG,GAAC,GAAG,GAAC,GAAG,GAAC,GAAG,GAAC,GAAG,GAAC,GAAG,GAAC,GAAG,GAAC,GAAG,GAAC,GAAG,GAAC,GAAG,GAAC,GAAG,GAAC,GAAG,GAAC,GAAG,GAAC,GAAG,GACvD,GAAG,GAAC,GAAG,GAAC,GAAG,GAAC,GAAG,GAAC,GAAG,GAAC,GAAG,GAAC,GAAG,GAAC,GAAG,GAAC,GAAG,GAAC,GAAG,GAAC,GAAG,GAAC,GAAG,CAAA;AAE9D,sEAAsE;AACtE,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI;KACvB,CAAC,IAAI,MAAM,CAAC,GAAG,MAAM,GAAG,CAAC,SAAS,GAAG,OAAO,GAAG,MAAM,EAAE,GAAG,CAAC,GAAG,KAAK;CACrE,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,CAAA;AAEnB;;;;;;;GAOG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI;KACnB,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,IAAI,MAAM,EAAE,GAAG,KAAK,GAC3C,CAAC,CAAC,CAAC,CAAC,SAAS,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,GAChC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,KAAK,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,GAC5C,KAAK,GACN,CAAC,CAAC,CAAC,CAAC,SAAS,UAAU,CAAC,MAAM,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,GAChD,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,KAAK,UAAU,CAAC,MAAM,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,GAC5D,KAAK;CACT,CAAA;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,MAAM,CAAC,CAAC,SAAS,QAAQ,GAAG,OAAO;IAC9C,OAAO,CAAC,MAAM,CAAQ;IAEtB,OAAO,CAAC,MAAM;IA2Cd;;;;;;;;OAQG;IACH,SAAS,CAAC,SAAS,CACjB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,aAAa,CAAC,CAAC,GAAG,OAAO,GAAG,QAAQ,CAAC,EAC/C,YAAY,EAAE,OAAO,EACrB,YAAY,EAAE,aAAa,CAAC,WAAW,CAAC,GACvC,CAAC,CAEH;IAED,uEAAuE;IACvE,OAAO,CAAC,eAAe;IAoCvB,gFAAgF;IAChF,OAAO,CAAC,IAAI,EAAE,CAAC,EAAE,WAAW,EAAE,aAAa,CAAC,CAAC,GAAG,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,CAEtE;IAED;;;;;;;;;;;OAWG;IACH,KAAK,CAAC,QAAQ,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAC,CAE1D;IAED;;;OAGG;IACH,IAAI,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAKxC;CACF"}
+{"version":3,"file":"grammar.d.ts","sourceRoot":"","sources":["../../src/cst/grammar.ts"],"names":[],"mappings":"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"}

package/dist/cst/incremental.d.ts

@@ -1,4 +1,4 @@
-import type { ParseFail } from '../types.ts';
+import type { Combinator, ParseFail } from '../types.ts';
 import type { Parser } from './grammar.ts';
 import type { NodeLike } from './types.ts';
 /**
@@ -16,6 +16,8 @@ export interface ParseDoc<N extends NodeLike = NodeLike> {
     readonly tree: N | null;
     readonly errors: ParseFail[];
     readonly input: string;
+    /** Offset reached by the top-level rule. < input.length means input was left unconsumed. */
+    readonly consumedEnd: number;
     /**
      * Incrementally re-parse after a text change.
      *
@@ -34,5 +36,5 @@ export interface ParseDoc<N extends NodeLike = NodeLike> {
      */
     edit(from: number, to: number, replacement: string): ParseDoc<N>;
 }
-export declare function makeParseDoc<N extends NodeLike>(parser: Parser<N>, ruleName: string, input: string): ParseDoc<N>;
+export declare function makeParseDoc<N extends NodeLike>(parser: Parser<N>, ruleName: string, input: string, trivia?: Combinator<unknown>, captureTrivia?: boolean, triviaLog?: number[]): ParseDoc<N>;
 //# sourceMappingURL=incremental.d.ts.map

package/dist/cst/incremental.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"incremental.d.ts","sourceRoot":"","sources":["../../src/cst/incremental.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgB,SAAS,EAAE,MAAM,aAAa,CAAA;AAC1D,OAAO,KAAK,EAAE,MAAM,EAAY,MAAM,cAAc,CAAA;AACpD,OAAO,KAAK,EAAqB,QAAQ,EAAE,MAAM,YAAY,CAAA;AAM7D;;;;;;;;;;GAUG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ;IACrD,QAAQ,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,SAAS,EAAE,CAAA;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB;;;;;;;;;;;;;;;OAeG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAA;CACjE;AA+GD,wBAAgB,YAAY,CAAC,CAAC,SAAS,QAAQ,EAC7C,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EACjB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,GACZ,QAAQ,CAAC,CAAC,CAAC,CAOb"}
+{"version":3,"file":"incremental.d.ts","sourceRoot":"","sources":["../../src/cst/incremental.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAgB,SAAS,EAAE,MAAM,aAAa,CAAA;AACtE,OAAO,KAAK,EAAE,MAAM,EAAY,MAAM,cAAc,CAAA;AACpD,OAAO,KAAK,EAAqB,QAAQ,EAAE,MAAM,YAAY,CAAA;AAM7D;;;;;;;;;;GAUG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ;IACrD,QAAQ,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,SAAS,EAAE,CAAA;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,4FAA4F;IAC5F,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B;;;;;;;;;;;;;;;OAeG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAA;CACjE;AAsHD,wBAAgB,YAAY,CAAC,CAAC,SAAS,QAAQ,EAC7C,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EACjB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAC5B,aAAa,CAAC,EAAE,OAAO,EACvB,SAAS,CAAC,EAAE,MAAM,EAAE,GACnB,QAAQ,CAAC,CAAC,CAAC,CAYb"}

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

@@ -0,0 +1,50 @@
+import type { Span } from '../types.ts';
+/** One captured trivia token (a whitespace run or a comment) with its source span. */
+export type TriviaToken = {
+    readonly value: string;
+    readonly span: Span;
+};
+/**
+ * Before/after offset index of captured trivia. Built from a tree's rawChildren
+ * (trivia is only present there when the grammar enables `_captureTrivia`).
+ *
+ *   index.before.get(node.span.start)  // trivia immediately before a node
+ *   index.after.get(node.span.end)     // trivia immediately after a node
+ *
+ * A given trivia run is registered under BOTH the following item's start
+ * (`before`) and the preceding item's end (`after`), so either lookup finds it.
+ */
+export type TriviaIndex = {
+    readonly before: Map<number, TriviaToken[]>;
+    readonly after: Map<number, TriviaToken[]>;
+};
+/**
+ * Options for trailing/leading trivia at the document boundary. A repeating root
+ * (e.g. `many()`) rolls back the trivia after its last item — it's "trailing" and
+ * belongs to the enclosing context, which at the document root is the document
+ * itself. Pass `{ input, trivia }` to re-scan and register that boundary trivia,
+ * so a round-trippable trivia map isn't missing the run before EOF.
+ */
+export type TriviaIndexOptions = {
+    /** The full source string. */
+    input: string;
+    /**
+     * A regex matching ONE trivia token (a whitespace run or a comment). Applied
+     * repeatedly to tokenize the boundary trivia. Each match becomes one token, so
+     * write it to match a maximal run, e.g.
+     * `/[ \t\n\r\f]+|\/\*(?:[^*]|\*(?!\/))*\*\//`.
+     */
+    trivia: RegExp;
+};
+/**
+ * Walk a CST/AST node tree (anything exposing `children` whose items carry
+ * `_tag`/`span`, with trivia items tagged `'trivia'`) and build a before/after
+ * trivia index. Generic over the node type — formatters, LSPs, and codemods all
+ * need this, and Parseman already owns trivia capture.
+ *
+ * With `opts`, also captures leading trivia (before the root's content) and
+ * trailing trivia (after it, up to EOF) — the document boundaries a repeating
+ * root rolls back.
+ */
+export declare function buildTriviaIndex(root: unknown, opts?: TriviaIndexOptions): TriviaIndex;
+//# sourceMappingURL=trivia-index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trivia-index.d.ts","sourceRoot":"","sources":["../../src/cst/trivia-index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAEvC,sFAAsF;AACtF,MAAM,MAAM,WAAW,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;CAAE,CAAA;AAEzE;;;;;;;;;GASG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,CAAA;IAC3C,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,CAAA;CAC3C,CAAA;AAiBD;;;;;;GAMG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,8BAA8B;IAC9B,KAAK,EAAE,MAAM,CAAA;IACb;;;;;OAKG;IACH,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,kBAAkB,GAAG,WAAW,CAqEtF"}

package/dist/cst/types.d.ts

@@ -6,14 +6,14 @@ import type { Span } from '../types.ts';
  *
  * `children` only needs to be iterable with items that have `_tag` so the
  * traversal code can distinguish sub-nodes from leaves. For incremental
- * replacement, nodes are reconstructed via object spread — so plain objects
- * work naturally; class instances with non-enumerable properties do not.
+ * replacement, `rebuild()` on the Parser calls `buildNode()` rather than
+ * object-spreading, so overriding `buildNode` handles class instances correctly.
  */
 export type NodeLike = {
     readonly _tag: 'node';
     readonly type: string;
     readonly span: Span;
-    readonly savedContext: unknown;
+    readonly state: unknown;
     readonly children: ReadonlyArray<{
         readonly _tag: string;
     }>;
@@ -30,11 +30,11 @@ export type CSTNode = {
     readonly span: Span;
     readonly children: CSTChild[];
     /**
-     * Shallow clone of ctx.user at the moment this node's parse began.
+     * Shallow clone of ctx.state at the moment this node's parse began.
      * Used as the re-entry point for incremental re-parsing.
-     * Only meaningful when ctx.user is primitives-only (no mutable objects).
+     * Only meaningful when ctx.state is primitives-only (no mutable objects).
      */
-    readonly savedContext: unknown;
+    readonly state: unknown;
 };
 /**
  * A terminal token — the result of a literal() or regex() match inside a CST rule.
@@ -57,7 +57,7 @@ export type CSTError = {
     readonly span: Span;
     readonly expected: string[];
     readonly children: CSTChild[];
-    readonly savedContext: unknown;
+    readonly state: unknown;
 };
 export type CSTChild = CSTNode | CSTLeaf | CSTError;
 /**

package/dist/cst/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/cst/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAEvC;;;;;;;;;GASG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;IACnB,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAA;IAC9B,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAC5D,CAAA;AAED;;;;GAIG;AACH,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,2DAA2D;IAC3D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;IACnB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,EAAE,CAAA;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAA;CAC/B,CAAA;AAED;;;;GAIG;AACH,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;CACpB,CAAA;AAED;;;;GAIG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;IACnB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;IAC3B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,EAAE,CAAA;IAC7B,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAA;CAC/B,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,CAAA;AAEnD;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;CACpB,CAAA;AAED,wFAAwF;AACxF,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,OAAO,GAAG,SAAS,GAAG,QAAQ,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/cst/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAEvC;;;;;;;;;GASG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;IACnB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAC5D,CAAA;AAED;;;;GAIG;AACH,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,2DAA2D;IAC3D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;IACnB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,EAAE,CAAA;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;CACxB,CAAA;AAED;;;;GAIG;AACH,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;CACpB,CAAA;AAED;;;;GAIG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;IACnB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;IAC3B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,EAAE,CAAA;IAC7B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,CAAA;AAEnD;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;CACpB,CAAA;AAED,wFAAwF;AACxF,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,OAAO,GAAG,SAAS,GAAG,QAAQ,CAAA"}

package/dist/functional/doc.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Functional incremental document — a class-free counterpart to ParseDoc.
+ *
+ * The class-based Parser bakes a rule registry (method name → combinator) and
+ * a `rebuild()` hook into the grammar object. A *functional* grammar produces
+ * the same two ingredients without a class:
+ *
+ *   - the registry is the object returned by `rules()` (rule name → parser fn),
+ *     which the macro compiles to a map of independently-callable functions;
+ *   - `rebuild` is supplied by the caller (or defaults to a shallow spread),
+ *     since functional nodes are whatever the `transform()` callbacks produced.
+ *
+ * Given those, incremental re-parsing is identical in spirit to the class path:
+ * locate the smallest node containing the edit, re-parse that single rule from
+ * its start offset, and graft the result back into the tree if its end lands
+ * where the edit's delta predicts.
+ *
+ * This module has no dependency on the `Parser` class — it is what lets the
+ * class be removed once grammars move to the functional shape.
+ */
+import type { ParseContext, ParseFail, ParseResult } from '../types.ts';
+import type { NodeLike, CSTLeaf, CSTError } from '../cst/types.ts';
+/** A single compiled (or interpreted) rule: parse from `pos`, producing node `N`. */
+export type RuleFn<N> = (input: string, pos: number, ctx: ParseContext) => ParseResult<N>;
+/** Rule name → parser function. This is exactly the shape `rules()` returns. */
+export type Registry<N> = Record<string, RuleFn<N>>;
+export type FunctionalDocOptions<N extends NodeLike> = {
+    /** Initial grammar state threaded into ctx.state for the root parse. */
+    state?: unknown;
+    /**
+     * Reconstruct a parent node with one child replaced (used when grafting a
+     * re-parsed subtree into its ancestors). Defaults to a shallow spread, which
+     * works for plain-object nodes; class-instance ASTs should supply their own.
+     */
+    rebuild?: (node: N, children: ReadonlyArray<N | CSTLeaf | CSTError>) => N;
+};
+export interface FunctionalDoc<N extends NodeLike> {
+    readonly tree: N | null;
+    readonly errors: ParseFail[];
+    readonly input: string;
+    /**
+     * Incrementally re-parse after a text change. `from`/`to` are byte offsets in
+     * the OLD input; `replacement` fills that range. Mirrors editor change events
+     * (see ParseDoc.edit for the mapping).
+     */
+    edit(from: number, to: number, replacement: string): FunctionalDoc<N>;
+}
+/**
+ * Parse `input` from `rootRule` and wrap the result in a FunctionalDoc that can
+ * be incrementally re-parsed via `.edit()`.
+ */
+export declare function makeFunctionalDoc<N extends NodeLike>(registry: Registry<N>, rootRule: string, input: string, opts?: FunctionalDocOptions<N>): FunctionalDoc<N>;
+//# sourceMappingURL=doc.d.ts.map

package/dist/functional/doc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doc.d.ts","sourceRoot":"","sources":["../../src/functional/doc.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AACvE,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAElE,qFAAqF;AACrF,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,KAAK,WAAW,CAAC,CAAC,CAAC,CAAA;AAEzF,gFAAgF;AAChF,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAA;AAEnD,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,QAAQ,IAAI;IACrD,wEAAwE;IACxE,KAAK,CAAC,EAAE,OAAO,CAAA;IACf;;;;OAIG;IACH,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,aAAa,CAAC,CAAC,GAAG,OAAO,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAA;CAC1E,CAAA;AAED,MAAM,WAAW,aAAa,CAAC,CAAC,SAAS,QAAQ;IAC/C,QAAQ,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,SAAS,EAAE,CAAA;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB;;;;OAIG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,aAAa,CAAC,CAAC,CAAC,CAAA;CACtE;AAuHD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,QAAQ,EAClD,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EACrB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,IAAI,GAAE,oBAAoB,CAAC,CAAC,CAAM,GACjC,aAAa,CAAC,CAAC,CAAC,CASlB"}