parseman 0.8.0 → 0.10.0

package/dist/combinators/node.d.ts

@@ -19,5 +19,19 @@ export type BuildNode<N> = (children: ReadonlyArray<unknown>, rawChildren: Reado
     start: number;
     end: number;
 }, triviaLog: readonly number[], state: unknown) => N;
-export declare function node<N>(type: string, combinator: Combinator<unknown>, build: BuildNode<N>): Combinator<N>;
+/**
+ * Options for `node()`.
+ * - `collapse` — a structural wrapper rule (a selector list, an
+ *   expression-precedence level, …) that IS its single child when it captured
+ *   exactly one. With `collapse: true`, a one-child match returns that child
+ *   directly (a leaf unwrapped to its string value, a sub-node as-is) and
+ *   `build` is NOT called; zero or two-plus children go through `build`
+ *   normally. Lets a grammar keep readable layered rules without paying a build
+ *   call per collapsing layer — and without hand-writing
+ *   `if (children.length === 1) return children[0]` in every wrapper builder.
+ */
+export type NodeOptions = {
+    collapse?: boolean;
+};
+export declare function node<N>(type: string, combinator: Combinator<unknown>, build: BuildNode<N>, opts?: NodeOptions): 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;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"}
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/combinators/node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAoD,MAAM,aAAa,CAAA;AAI/F;;;;;;;;;;;;;;;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;;;;;;;;;;GAUG;AACH,MAAM,MAAM,WAAW,GAAG;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAAA;AAShD,wBAAgB,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,UAAU,CAAC,CAAC,CAAC,CA8C7H"}

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

@@ -0,0 +1,26 @@
+import type { ParserDef } from '../types.ts';
+/**
+ * Per-node CST-trivia (4th build arg) and state-clone (5th build arg) capture is
+ * dead work when the build never declares those formal params. This module derives
+ * a build's *confirmed* formal-parameter arity so all three eval paths (interpreter,
+ * compiler, macro) can elide that capture identically.
+ *
+ * Conservative by construction: any source we can't confidently parse — rest params,
+ * destructuring, `arguments`, an unrecognized shape — yields `null` (arity unknown),
+ * and callers KEEP full capture. We only ever return a number when the parameter list
+ * is a plain comma-separated list of simple identifiers.
+ */
+type NodeDef = Extract<ParserDef, {
+    tag: 'node';
+}>;
+/**
+ * Confirmed count of simple formal parameters the build declares, or `null` when the
+ * source can't be parsed into a plain identifier list (→ caller keeps full capture).
+ */
+export declare function confirmedBuildArity(src: string): number | null;
+/** Build reads the 4th (triviaLog) arg? Unknown/unparseable → true (keep capture). */
+export declare function buildReadsTrivia(def: NodeDef): boolean;
+/** Build reads the 5th (state) arg? Unknown/unparseable → true (keep state clone). */
+export declare function buildReadsState(def: NodeDef): boolean;
+export {};
+//# sourceMappingURL=build-arity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"build-arity.d.ts","sourceRoot":"","sources":["../../src/compiler/build-arity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAE5C;;;;;;;;;;GAUG;AAEH,KAAK,OAAO,GAAG,OAAO,CAAC,SAAS,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAAA;AAkBlD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAuB9D;AAED,sFAAsF;AACtF,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAKtD;AAED,sFAAsF;AACtF,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAKrD"}

package/dist/compiler/codegen.d.ts

@@ -40,4 +40,37 @@ export type CompiledParser<T> = {
  * @see https://www.greadme.com/blog/security/what-is-content-security-policy-complete-guide
  */
 export declare function compile<T>(combinator: Combinator<T>, mapFnSources?: string[]): CompiledParser<T>;
+/**
+ * Compile every entry of a `rules(factory)` map's returned object using ONE
+ * shared codegen Ctx (regexes, named functions, map/build-fn arrays) instead
+ * of running `compile()` independently per entry.
+ *
+ * Why this exists: `compile()` per entry gives each entry its own namedParsers
+ * cache, so a sub-rule reachable from N different top-level entries (e.g.
+ * `valueList` reachable from `Declaration`, `CustomDeclaration`, `Guard`, …)
+ * gets fully re-compiled N times — on a richly cross-referential grammar
+ * (Less: ~125 rule-map entries, deep mutual reference) this multiplies total
+ * compiled size far past what the source grammar actually needs, independent
+ * of the per-ref single-use inlining `analyzeLazyUsage` already handles
+ * within one compile() call. Sharing one Ctx here means a sub-rule compiles
+ * exactly once for the WHOLE rule map, however many entries reach it.
+ *
+ * Returns a single `replacement` — ONE shared IIFE, evaluated once, whose
+ * result is the `{ key: fn, ... }` map — meant to replace the entire
+ * `rules(factory)` call-expression (not one expression per key; splicing a
+ * separate self-contained expression per key would either re-run the shared
+ * prelude once per entry or duplicate its text per entry, undoing the win).
+ * `keys` lists every entry compileRuleMap() saw, for the caller to validate
+ * against the source's own key list.
+ *
+ * Returns null (same all-or-nothing contract the per-entry `compile()` +
+ * `inlineExpression === null` check gave the plugin before) when the map
+ * contains anything that can't be inlined — a runtime-fallback parser, or an
+ * uncaptured transform/build closure source. The plugin's existing "warn and
+ * leave this rules() call interpreted" fallback covers this case unchanged.
+ */
+export declare function compileRuleMap(ruleMap: ReadonlyArray<readonly [string, Combinator<unknown>]>): {
+    keys: string[];
+    replacement: string;
+} | null;
 //# 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,EAAE,YAAY,EAAE,UAAU,EAAkB,MAAM,aAAa,CAAA;AA2/CzH,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;AAkCD;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,EAAE,MAAM,EAAE,GAAG,cAAc,CAAC,CAAC,CAAC,CAqGhG"}
+{"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;AA4jDzH,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;AAoJD;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,EAAE,MAAM,EAAE,GAAG,cAAc,CAAC,CAAC,CAAC,CAyGhG;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,GAC7D;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CA6EhD"}

package/dist/compiler/scannable-run.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Structural recognition of "scannable" parser arms — regex shapes that lower to
+ * a tight character-scan loop instead of `regex.exec` / combinator dispatch. Each
+ * shape is derived from the regex STRUCTURE, not from any hardcoded knowledge
+ * that a given regex "is whitespace" or "is a comment":
+ *
+ *   [X]+ / [X]*            → run while the char ∈ X                (chars)
+ *   <lit>[^X]*             → consume <lit>, run until char ∈ X     (until)
+ *   <open>(?:…)*<close>    → consume <open>, run to <close> literal (delimited)
+ *
+ * A `oneOrMore(choice(a, b, …))` where every arm is one of these compiles to a
+ * single char-dispatch loop with one branch per arm — any count/order, because
+ * the shapes dispatch on their first 1–2 chars and are checked in turn. Trivia
+ * (whitespace + comments) is just the value-discarded instance of this; nothing
+ * here is trivia-specific.
+ */
+export type ScanShape = {
+    kind: 'chars';
+    ranges: Array<[number, number]>;
+} | {
+    kind: 'until';
+    open: number[];
+    stop: Array<[number, number]>;
+} | {
+    kind: 'delimited';
+    open: number[];
+    close: number[];
+};
+/**
+ * Recognize one scannable arm from its regex source, or null if it isn't one of
+ * the three structural shapes. Order matters: char-class run, then
+ * open-until-terminator, then delimited.
+ */
+export declare function parseScanShape(source: string): ScanShape | null;
+/**
+ * One loop branch for a shape, dispatched on the current char `c` (= charCodeAt(_e)).
+ * Each branch advances `_e` past the matched token and `continue`s the scan loop.
+ */
+export declare function scanBranch(shape: ScanShape): string;
+/**
+ * A labeled branch: consume the shape's full token and log one [start, end,
+ * kindIndex] trivia chunk. Unlike scanBranch this always consumes the whole run
+ * (a chunk must span the entire token) and captures inline per-chunk.
+ */
+export declare function scanBranchLabeled(shape: ScanShape, kindIndex: number): string;
+//# sourceMappingURL=scannable-run.d.ts.map

package/dist/compiler/scannable-run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scannable-run.d.ts","sourceRoot":"","sources":["../../src/compiler/scannable-run.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,MAAM,MAAM,SAAS,GACjB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAAE,GAClD;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAAE,GAChE;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAAA;AAwD1D;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CA4B/D;AAuDD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAQnD;AAYD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAM7E"}

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

@@ -1,23 +1,36 @@
 import type { Combinator } from '../types.ts';
 import type { LabeledTriviaSpec } from '../cst/trivia-kinds.ts';
-export type TriviaFastKind = 'wsComments' | 'wsOnly';
+import { type ScanShape } from './scannable-run.ts';
 /**
- * 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.
+ * A trivia parser that lowers to a hand-rolled char-scan loop: `oneOrMore(choice(
+ * …))` (or `many`, min≥1) where EVERY arm is a scannable shape (a `[X]+` run, a
+ * `<lit>[^X]*` open-until-terminator, or a `<open>(?:…)*<close>` delimited token
+ * — see scannable-run.ts). Returns the per-arm shapes, or a single-element list
+ * for a bare scannable regex, or null (→ caller falls back to the regex/generic
+ * trivia path). A single alternation regex is NOT scannable (one exec matches one
+ * arm per call, defeating the loop).
  */
-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;
+export declare function analyzeTriviaFastPath(trivia: Combinator<unknown>): ScanShape[] | null;
+/** Emit a specialized `_tfN` that skips (unlabeled) trivia via a char-scan loop. */
+export declare function buildFastTriviaFnDecl(fnName: string, shapes: ScanShape[]): string;
+/**
+ * A LABELED trivia parser whose every arm is scannable → per-arm shape + kind
+ * index, or null. Same recognition as analyzeTriviaFastPath, but keyed by the
+ * labeled arm kinds so the fast loop can log each chunk's kind. Generalizes what
+ * used to be a hardcoded ws-run + block-comment special case to any scannable
+ * shape set / arm count.
+ */
+export declare function analyzeLabeledScannableRun(trivia: Combinator<unknown>): Array<{
+    shape: ScanShape;
+    kindIndex: number;
+}> | null;
+/** Emit a labeled scannable trivia `_tfN`: char-scan loop with per-chunk kind capture. */
+export declare function buildLabeledScannableTriviaFnDecl(fnName: string, arms: ReadonlyArray<{
+    shape: ScanShape;
+    kindIndex: 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;

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

@@ -1 +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"}
+{"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;AAE/D,OAAO,EAAE,KAAK,SAAS,EAAiD,MAAM,oBAAoB,CAAA;AA0BlG;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,SAAS,EAAE,GAAG,IAAI,CAyBrF;AAoBD,oFAAoF;AACpF,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,CASjF;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,GAC1B,KAAK,CAAC;IAAE,KAAK,EAAE,SAAS,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,IAAI,CAWvD;AAED,0FAA0F;AAC1F,wBAAgB,iCAAiC,CAC/C,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,aAAa,CAAC;IAAE,KAAK,EAAE,SAAS,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,GAC3D,MAAM,CAYR;AAED,kFAAkF;AAClF,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,MAAM,EAAE,GAChB,MAAM,CA+BR;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/functional/doc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"doc.d.ts","sourceRoot":"","sources":["../../src/functional/doc.ts"],"names":[],"mappings":"AAAA;;GAEG;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;;;OAGG;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"}
+{"version":3,"file":"doc.d.ts","sourceRoot":"","sources":["../../src/functional/doc.ts"],"names":[],"mappings":"AAAA;;GAEG;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;;;OAGG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,aAAa,CAAC,CAAC,CAAC,CAAA;CACtE;AA0KD;;;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"}