@thomasfosterau/effect-parse 0.2.0 → 0.4.0

package/dist/internal/key.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Identity keys: a parser that keeps state across parses (resume
+ * checkpoints, reusable syntax nodes) creates one `Key` when it is built and
+ * looks its state up by that key's reference.
+ */
+/** A per-parser identity, compared by reference. */
+export declare class Key {
+  private readonly brand;
+}
+//# sourceMappingURL=key.d.ts.map

package/dist/internal/key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"key.d.ts","names":[],"sources":["../../src/internal/key.ts"],"mappings":";;;;;;qBAOa;mBAEc"}

package/dist/internal/key.js

@@ -0,0 +1,11 @@
+// src/internal/key.ts
+/**
+* Identity keys: a parser that keeps state across parses (resume
+* checkpoints, reusable syntax nodes) creates one `Key` when it is built and
+* looks its state up by that key's reference.
+*/
+/** A per-parser identity, compared by reference. */
+var Key = class {};
+export { Key };
+
+//# sourceMappingURL=key.js.map

package/dist/internal/key.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"key.js","names":[],"sources":["../../src/internal/key.ts"],"sourcesContent":["/**\n * Identity keys: a parser that keeps state across parses (resume\n * checkpoints, reusable syntax nodes) creates one `Key` when it is built and\n * looks its state up by that key's reference.\n */\n\n/** A per-parser identity, compared by reference. */\nexport class Key {\n  // Nominal: an empty class would accept any object\n  declare private readonly brand: void\n}\n"],"mappings":";;;;;;;AAOA,IAAa,MAAb,MAAiB,CAGjB"}

package/dist/internal/node.d.ts

@@ -1,6 +1,7 @@
+import * as Result from "effect/Result";
 import { ErrMode, Input, State } from "../Input.js";
+import * as Option from "effect/Option";
 import { Encoding } from "../Encoding.js";
-//#region src/internal/node.d.ts
 /** The parts of a parser the compiler needs. */
 export interface ParserLike {
   readonly step: (state: State<any>) => unknown;
@@ -102,11 +103,11 @@ export type Node = {
 } | {
   readonly _tag: "TryMap";
   readonly self: P;
-  readonly f: (a: any) => unknown;
+  readonly f: (a: any) => Result.Result<unknown, unknown>;
 } | {
   readonly _tag: "FilterMap";
   readonly self: P;
-  readonly f: (a: any) => unknown;
+  readonly f: (a: any) => Option.Option<unknown>;
 } | {
   readonly _tag: "Filter";
   readonly self: P;
@@ -248,8 +249,14 @@ export declare const bounds: (range: number | {
   readonly min?: number | undefined;
   readonly max?: number | undefined;
 } | undefined) => Bounds;
+/**
+ * Whether the compilers' one-pass float scan applies to `p`, the text
+ * parser of `Ascii.float` / `Text.float`: a `taken` (under any `expected`
+ * labels) in an encoding that `native` accepts, reading one ASCII-compatible
+ * unit at a time, or in no encoding at all.
+ */
+export declare const scansFloat: (p: ParserLike, native: (enc: Encoding<any>) => boolean) => boolean;
 /** The child parsers of a node, in evaluation order. */
 export declare const children: (node: Node) => ReadonlyArray<P>;
-//#endregion
 export {};
 //# sourceMappingURL=node.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"node.d.ts","names":[],"sources":["../../src/internal/node.ts"],"mappings":";;;;iBAaiB;WACN,OAAO,OAAO;WACd;;KAGN,IAAI;KACJ,QAAQ,OAAO;;UAGV;WACC;WACA;;;;;;;KAQN,MAAM;YAEC;WAEG;WAAyB,MAAM;;WAC/B;WAA0B;;WAC1B;WAAuB;;WACvB;WAAuB,MAAM;;WAC7B;;WACA;;WACA;WAA0B,eAAe;;WAEzC;WAAsB,UAAU;;WAChC;WAA0B,SAAS;WAAgB;WAA4B,UAAU;;WACzF;WAAwB;WAAuB;WAA0B,UAAU;;WACnF;WAAuB;WAAwB,UAAU;;WACxD;WAA4B;WAAuB;WAA0B,UAAU;IAAQ;WAC/F;WAA4B,SAAS;WAAgB,UAAU;IAAQ;WACxE;WAAuB,UAAU;;WACjC;;WACA;WAAiC,UAAU;;WAC3C;WAA6B,UAAU;;WACvC;WAAsB,UAAU;;WAEhC;WACA,QAAQ;;WAER;WACA,QAAQ;;WAER;WACA,UAAU;;WAGV;WAAsB,MAAM;WAAY,IAAI;;WAC5C;WAAqB,MAAM;WAAY;;WACvC;WAAsB,MAAM;WAAY,IAAI;;WAC5C;WAAyB,MAAM;WAAY,IAAI;;WAC/C;WAA4B,MAAM;WAAY,IAAI;;WAClD;WAAyB,MAAM;WAAY,YAAY;;WACvD;WAA0B,MAAM;WAAY,IAAI,WAAW;;WAE3D;WAAwB,MAAM;WAAY,UAAU;;WACpD;WAA4B,MAAM;;WAClC;WAAuB,MAAM;;WAC7B;WAA2B,MAAM;;WAEjC;WAAuB,MAAM;WAAY,MAAM;WAAkB,IAAI;;WACrE;WAA0B,MAAM;WAAY;;WAC5C;WAA2B,MAAM;WAAY;;WAC7C;WAA2B,MAAM;;WACjC;WAAyB,MAAM;;WAE/B;WAAsB,MAAM;;WAC5B;WAAgC,MAAM;WAAY;;WAClD;WAAuB,MAAM;;WAC7B;WAAsB,MAAM;;WAG5B;WACA,SAAS,cAAc;;WAEvB;;WAEA;WAAyB,MAAM;WAAgC,SAAS,cAAc;;WACtF;WAA0B,MAAM;WAAY,MAAM;WAAY,IAAI,QAAQ;;WAE1E;WAAsB,SAAS,cAAc;;WAE7C;WACA,UAAU;;WAEV,OAAO,SAAS,OAAO,aAAa;WACpC,WAAW;WACX,SAAS,aAAa;;WAGrB;WAAyB,MAAM;IAAM;WAEtC;WACA,MAAM;WACN;WACA,IAAI,UAAU;;WAEd,SAAS;WACT;IACP;WACQ;WAA6B,MAAM;WAAY,KAAK;IAAM;WAC1D;WAA4B,MAAM;WAAY,WAAW;IAAM;WAEhE;WACA,MAAM;WACN,WAAW;WACX,KAAK,QAAQ,QAAQ;WACrB;;WAGA;;WACA;WAA0B,MAAM;;WAChC;WAA8B,MAAM;WAAY,SAAS;;WACzD;WAA6B,MAAM;WAAY,SAAS;;WACxD;WAAwB,MAAM;WAAY;;;;WAG1C;WACA,MAAM;;WAEN;WACA;;YAGH,MAAM;YAEN,OAAO,UAAU,OAAO,QAAQ;WAAiB,MAAM;;;qBAGtD;;qBAGA,SAAU,GAAG,eAAa;;qBAG1B,SACX;WAA2B;WAAmC;kBAC7D;;qBAOU,WAAY,MAAM,SAAO,cAAc"}
+{"version":3,"file":"node.d.ts","names":[],"sources":["../../src/internal/node.ts"],"mappings":";;;;;iBAeiB;WACN,OAAO,OAAO;WACd;;KAGN,IAAI;KACJ,QAAQ,OAAO;;UAGV;WACC;WACA;;;;;;;KAQN,MAAM;YAEC;WAEG;WAAyB,MAAM;;WAC/B;WAA0B;;WAC1B;WAAuB;;WACvB;WAAuB,MAAM;;WAC7B;;WACA;;WACA;WAA0B,eAAe;;WAEzC;WAAsB,UAAU;;WAChC;WAA0B,SAAS;WAAgB;WAA4B,UAAU;;WACzF;WAAwB;WAAuB;WAA0B,UAAU;;WACnF;WAAuB;WAAwB,UAAU;;WACxD;WAA4B;WAAuB;WAA0B,UAAU;IAAQ;WAC/F;WAA4B,SAAS;WAAgB,UAAU;IAAQ;WACxE;WAAuB,UAAU;;WACjC;;WACA;WAAiC,UAAU;;WAC3C;WAA6B,UAAU;;WACvC;WAAsB,UAAU;;WAEhC;WACA,QAAQ;;WAER;WACA,QAAQ;;WAER;WACA,UAAU;;WAGV;WAAsB,MAAM;WAAY,IAAI;;WAC5C;WAAqB,MAAM;WAAY;;WACvC;WAAsB,MAAM;WAAY,IAAI;;WAC5C;WAAyB,MAAM;WAAY,IAAI,WAAW,OAAO;;WACjE;WAA4B,MAAM;WAAY,IAAI,WAAW,OAAO;;WACpE;WAAyB,MAAM;WAAY,YAAY;;WACvD;WAA0B,MAAM;WAAY,IAAI,WAAW;;WAE3D;WAAwB,MAAM;WAAY,UAAU;;WACpD;WAA4B,MAAM;;WAClC;WAAuB,MAAM;;WAC7B;WAA2B,MAAM;;WAEjC;WAAuB,MAAM;WAAY,MAAM;WAAkB,IAAI;;WACrE;WAA0B,MAAM;WAAY;;WAC5C;WAA2B,MAAM;WAAY;;WAC7C;WAA2B,MAAM;;WACjC;WAAyB,MAAM;;WAE/B;WAAsB,MAAM;;WAC5B;WAAgC,MAAM;WAAY;;WAClD;WAAuB,MAAM;;WAC7B;WAAsB,MAAM;;WAG5B;WACA,SAAS,cAAc;;WAEvB;;WAEA;WAAyB,MAAM;WAAgC,SAAS,cAAc;;WACtF;WAA0B,MAAM;WAAY,MAAM;WAAY,IAAI,QAAQ;;WAE1E;WAAsB,SAAS,cAAc;;WAE7C;WACA,UAAU;;WAEV,OAAO,SAAS,OAAO,aAAa;WACpC,WAAW;WACX,SAAS,aAAa;;WAGrB;WAAyB,MAAM;IAAM;WAEtC;WACA,MAAM;WACN;WACA,IAAI,UAAU;;WAEd,SAAS;WACT;IACP;WACQ;WAA6B,MAAM;WAAY,KAAK;IAAM;WAC1D;WAA4B,MAAM;WAAY,WAAW;IAAM;WAEhE;WACA,MAAM;WACN,WAAW;WACX,KAAK,QAAQ,QAAQ;WACrB;;WAGA;;WACA;WAA0B,MAAM;;WAChC;WAA8B,MAAM;WAAY,SAAS;;WACzD;WAA6B,MAAM;WAAY,SAAS;;WACxD;WAAwB,MAAM;WAAY;;;;WAG1C;WACA,MAAM;;WAEN;WACA;;YAGH,MAAM;YAEN,OAAO,UAAU,OAAO,QAAQ;WAAiB,MAAM;;;qBAGtD;;qBAGA,SAAU,GAAG,eAAa;;qBAG1B,SACX;WAA2B;WAAmC;kBAC7D;;;;;;;qBAYU,aAAc,GAAG,YAAY,SAAS,KAAK;;qBAU3C,WAAY,MAAM,SAAO,cAAc"}

package/dist/internal/node.js

@@ -1,5 +1,5 @@
 import * as Predicate from "effect/Predicate";
-//#region src/internal/node.ts
+// src/internal/node.ts
 /**
 * Descriptions of parsers, recorded next to their steps so that parsers can
 * be compiled (see `docs/DESIGN.md`, "Compiled parsers").
@@ -30,6 +30,19 @@ const bounds = (range) => {
 		max: range.max ?? Infinity
 	};
 };
+/**
+* Whether the compilers' one-pass float scan applies to `p`, the text
+* parser of `Ascii.float` / `Text.float`: a `taken` (under any `expected`
+* labels) in an encoding that `native` accepts, reading one ASCII-compatible
+* unit at a time, or in no encoding at all.
+*/
+const scansFloat = (p, native) => {
+	let taken = nodeOf(p);
+	while (Predicate.isTagged(taken, "Expected")) taken = nodeOf(taken.self);
+	if (!Predicate.isTagged(taken, "Taken")) return false;
+	const enc = taken.encoding;
+	return enc === void 0 || native(enc) && enc.unit === 1 && enc.asciiCompatible;
+};
 /** The child parsers of a node, in evaluation order. */
 const children = (node) => {
 	switch (node._tag) {
@@ -78,7 +91,6 @@ const children = (node) => {
 		default: return [];
 	}
 };
-//#endregion
-export { NodeId, bounds, children, nodeOf };
+export { NodeId, bounds, children, nodeOf, scansFloat };
 
 //# sourceMappingURL=node.js.map

package/dist/internal/node.js.map

@@ -1 +1 @@
-{"version":3,"file":"node.js","names":[],"sources":["../../src/internal/node.ts"],"sourcesContent":["/**\n * Descriptions of parsers, recorded next to their steps so that parsers can\n * be compiled (see `docs/DESIGN.md`, \"Compiled parsers\").\n *\n * Nodes refer to their child parsers rather than to child nodes, so a\n * child's own step is always at hand for fallback, and recursion through\n * `Suspend` is just a reference.\n */\nimport * as Predicate from \"effect/Predicate\"\nimport type { Encoding } from \"../Encoding.js\"\nimport type { ErrMode, Input, State } from \"../Input.js\"\n\n/** The parts of a parser the compiler needs. */\nexport interface ParserLike {\n  readonly step: (state: State<any>) => unknown\n  readonly name: string | undefined\n}\n\ntype P = ParserLike\ntype Step = (state: State<any>) => unknown\n\n/** A repetition range, normalized: `max` may be `Infinity`. */\ninterface Bounds {\n  readonly min: number\n  readonly max: number\n}\n\n/**\n * For token nodes: `undefined` for the `Token`/`Ascii` parsers (code points\n * of strings with lenient surrogates, bytes, or array elements), or the\n * encoding of a `Text` parser.\n */\ntype Enc = Encoding<any> | undefined\n\nexport type Node =\n  // Constants\n  | { readonly _tag: \"Opaque\"; readonly step: Step }\n  | { readonly _tag: \"Succeed\"; readonly value: unknown }\n  | { readonly _tag: \"Sync\"; readonly evaluate: () => unknown }\n  | { readonly _tag: \"Fail\"; readonly mode: ErrMode }\n  | { readonly _tag: \"Eof\" }\n  | { readonly _tag: \"Location\" }\n  | { readonly _tag: \"Suspend\"; readonly resolve: () => P }\n  // Tokens\n  | { readonly _tag: \"Any\"; readonly encoding: Enc }\n  | { readonly _tag: \"Literal\"; readonly literal: Input; readonly caseless: boolean; readonly encoding: Enc }\n  | { readonly _tag: \"OneOf\"; readonly set: unknown; readonly negate: boolean; readonly encoding: Enc }\n  | { readonly _tag: \"Take\"; readonly count: number; readonly encoding: Enc }\n  | ({ readonly _tag: \"TakeWhile\"; readonly set: unknown; readonly negate: boolean; readonly encoding: Enc } & Bounds)\n  | ({ readonly _tag: \"TakeUntil\"; readonly literal: Input; readonly encoding: Enc } & Bounds)\n  | { readonly _tag: \"Rest\"; readonly encoding: Enc }\n  | { readonly _tag: \"RestLen\" }\n  | { readonly _tag: \"TillLineEnding\"; readonly encoding: Enc }\n  | { readonly _tag: \"Identifier\"; readonly encoding: Enc }\n  | { readonly _tag: \"Bom\"; readonly encoding: Enc }\n  | {\n      readonly _tag: \"Escaped\"\n      readonly normal: P\n      /** The control character, as a code point (or a byte / unit for `Ascii`). */\n      readonly control: number\n      readonly escape: P\n      /** `takeEscaped`: return the raw slice instead of the unescaped text. */\n      readonly raw: boolean\n      readonly encoding: Enc\n    }\n  // Mapping\n  | { readonly _tag: \"Map\"; readonly self: P; readonly f: (a: any) => unknown }\n  | { readonly _tag: \"As\"; readonly self: P; readonly value: unknown }\n  | { readonly _tag: \"Tap\"; readonly self: P; readonly f: (a: any) => void }\n  | { readonly _tag: \"TryMap\"; readonly self: P; readonly f: (a: any) => unknown }\n  | { readonly _tag: \"FilterMap\"; readonly self: P; readonly f: (a: any) => unknown }\n  | { readonly _tag: \"Filter\"; readonly self: P; readonly predicate: (a: any) => boolean }\n  | { readonly _tag: \"FlatMap\"; readonly self: P; readonly f: (a: any) => P }\n  // Consumed input\n  | { readonly _tag: \"Taken\"; readonly self: P; readonly encoding: Enc }\n  | { readonly _tag: \"WithTaken\"; readonly self: P }\n  | { readonly _tag: \"Span\"; readonly self: P }\n  | { readonly _tag: \"WithSpan\"; readonly self: P }\n  // Errors\n  | { readonly _tag: \"Mode\"; readonly self: P; readonly from: ErrMode; readonly to: ErrMode }\n  | { readonly _tag: \"Context\"; readonly self: P; readonly label: string }\n  | { readonly _tag: \"Expected\"; readonly self: P; readonly description: string }\n  | { readonly _tag: \"MapError\"; readonly self: P }\n  | { readonly _tag: \"OrFail\"; readonly self: P }\n  // Control\n  | { readonly _tag: \"Opt\"; readonly self: P }\n  | { readonly _tag: \"OrElseSucceed\"; readonly self: P; readonly value: () => unknown }\n  | { readonly _tag: \"Peek\"; readonly self: P }\n  | { readonly _tag: \"Not\"; readonly self: P }\n  // Sequencing\n  | {\n      readonly _tag: \"Seq\"\n      readonly parsers: ReadonlyArray<P>\n      /** Which outputs are kept: all (a tuple), one index, or a pair of indices. */\n      readonly output: \"tuple\" | number | readonly [number, number]\n    }\n  | { readonly _tag: \"Struct\"; readonly keys: ReadonlyArray<string>; readonly parsers: ReadonlyArray<P> }\n  | { readonly _tag: \"ZipWith\"; readonly self: P; readonly that: P; readonly f: (a: any, b: any) => unknown }\n  // Choice\n  | { readonly _tag: \"Alt\"; readonly parsers: ReadonlyArray<P> }\n  | {\n      readonly _tag: \"Dispatch\"\n      readonly selector: P\n      /** A record of cases, when `dispatch` was given one. */\n      readonly cases: Readonly<Record<PropertyKey, P>> | undefined\n      readonly otherwise: P | undefined\n      readonly choose: (key: any) => P | undefined\n    }\n  // Repetition\n  | ({ readonly _tag: \"Repeat\"; readonly self: P } & Bounds)\n  | ({\n      readonly _tag: \"Fold\"\n      readonly self: P\n      readonly init: () => unknown\n      readonly f: (acc: any, a: any) => unknown\n      /** Stops the repetition once false of the accumulator (after `min` elements). */\n      readonly while: ((acc: any) => boolean) | undefined\n      readonly name: string\n    } & Bounds)\n  | ({ readonly _tag: \"RepeatTill\"; readonly self: P; readonly end: P } & Bounds)\n  | ({ readonly _tag: \"Separated\"; readonly self: P; readonly separator: P } & Bounds)\n  | {\n      readonly _tag: \"SeparatedFold\"\n      readonly self: P\n      readonly separator: P\n      readonly op: (l: any, s: any, r: any) => unknown\n      readonly right: boolean\n    }\n  // Services, recovery, debugging\n  | { readonly _tag: \"Service\" }\n  | { readonly _tag: \"Provide\"; readonly self: P }\n  | { readonly _tag: \"ResumeAfter\"; readonly self: P; readonly recover: P }\n  | { readonly _tag: \"RetryAfter\"; readonly self: P; readonly recover: P }\n  | { readonly _tag: \"Trace\"; readonly self: P; readonly name: string }\n  /** `Syntax.node`, `Syntax.token` and `Syntax.field`: identities outside `Syntax` parses. */\n  | {\n      readonly _tag: \"Syntax\"\n      readonly self: P\n      /** The node kind, or `undefined` for a field. */\n      readonly kind: string | undefined\n      readonly named: boolean\n    }\n\nexport type Tag = Node[\"_tag\"]\n\nexport type NodeOf<T extends Tag> = Extract<Node, { readonly _tag: T }>\n\n/** Where a parser's description is stored. */\nexport const NodeId: unique symbol = /*#__PURE__*/ Symbol.for(\"effect-parse/Parser/node\")\n\n/** The description of a parser: `Opaque` when it has none. */\nexport const nodeOf = (p: ParserLike): Node => (p as any)[NodeId] ?? { _tag: \"Opaque\", step: p.step }\n\n/** Normalizes a range, as `repeat`, `takeWhile`, ... do. */\nexport const bounds = (\n  range: number | { readonly min?: number | undefined; readonly max?: number | undefined } | undefined\n): Bounds => {\n  if (range === undefined) return { min: 0, max: Infinity }\n  if (Predicate.isNumber(range)) return { min: range, max: range }\n  return { min: range.min ?? 0, max: range.max ?? Infinity }\n}\n\n/** The child parsers of a node, in evaluation order. */\nexport const children = (node: Node): ReadonlyArray<P> => {\n  switch (node._tag) {\n    case \"Escaped\":\n      return [node.normal, node.escape]\n    case \"Map\":\n    case \"As\":\n    case \"Tap\":\n    case \"TryMap\":\n    case \"FilterMap\":\n    case \"Filter\":\n    case \"FlatMap\":\n    case \"Taken\":\n    case \"WithTaken\":\n    case \"Span\":\n    case \"WithSpan\":\n    case \"Mode\":\n    case \"Context\":\n    case \"Expected\":\n    case \"MapError\":\n    case \"OrFail\":\n    case \"Opt\":\n    case \"OrElseSucceed\":\n    case \"Peek\":\n    case \"Not\":\n    case \"Repeat\":\n    case \"Fold\":\n    case \"Provide\":\n    case \"Trace\":\n    case \"Syntax\":\n      return [node.self]\n    case \"ResumeAfter\":\n    case \"RetryAfter\":\n      return [node.self, node.recover]\n    case \"Seq\":\n    case \"Struct\":\n    case \"Alt\":\n      return node.parsers\n    case \"ZipWith\":\n      return [node.self, node.that]\n    case \"Dispatch\": {\n      const out: Array<P> = [node.selector]\n      if (node.cases !== undefined) {\n        for (const key of Reflect.ownKeys(node.cases)) out.push(node.cases[key as any])\n      }\n      if (node.otherwise !== undefined) out.push(node.otherwise)\n      return out\n    }\n    case \"RepeatTill\":\n      return [node.self, node.end]\n    case \"Separated\":\n    case \"SeparatedFold\":\n      return [node.self, node.separator]\n    case \"Suspend\":\n      return [node.resolve()]\n    default:\n      return []\n  }\n}\n"],"mappings":";;;;;;;;;;;AAoJA,MAAa,SAAsC,qBAAO,IAAI,0BAA0B;;AAGxF,MAAa,UAAU,MAAyB,EAAU,WAAW;CAAE,MAAM;CAAU,MAAM,EAAE;AAAK;;AAGpG,MAAa,UACX,UACW;CACX,IAAI,UAAU,KAAA,GAAW,OAAO;EAAE,KAAK;EAAG,KAAK;CAAS;CACxD,IAAI,UAAU,SAAS,KAAK,GAAG,OAAO;EAAE,KAAK;EAAO,KAAK;CAAM;CAC/D,OAAO;EAAE,KAAK,MAAM,OAAO;EAAG,KAAK,MAAM,OAAO;CAAS;AAC3D;;AAGA,MAAa,YAAY,SAAiC;CACxD,QAAQ,KAAK,MAAb;EACE,KAAK,WACH,OAAO,CAAC,KAAK,QAAQ,KAAK,MAAM;EAClC,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,UACH,OAAO,CAAC,KAAK,IAAI;EACnB,KAAK;EACL,KAAK,cACH,OAAO,CAAC,KAAK,MAAM,KAAK,OAAO;EACjC,KAAK;EACL,KAAK;EACL,KAAK,OACH,OAAO,KAAK;EACd,KAAK,WACH,OAAO,CAAC,KAAK,MAAM,KAAK,IAAI;EAC9B,KAAK,YAAY;GACf,MAAM,MAAgB,CAAC,KAAK,QAAQ;GACpC,IAAI,KAAK,UAAU,KAAA,GACjB,KAAK,MAAM,OAAO,QAAQ,QAAQ,KAAK,KAAK,GAAG,IAAI,KAAK,KAAK,MAAM,IAAW;GAEhF,IAAI,KAAK,cAAc,KAAA,GAAW,IAAI,KAAK,KAAK,SAAS;GACzD,OAAO;EACT;EACA,KAAK,cACH,OAAO,CAAC,KAAK,MAAM,KAAK,GAAG;EAC7B,KAAK;EACL,KAAK,iBACH,OAAO,CAAC,KAAK,MAAM,KAAK,SAAS;EACnC,KAAK,WACH,OAAO,CAAC,KAAK,QAAQ,CAAC;EACxB,SACE,OAAO,CAAC;CACZ;AACF"}
+{"version":3,"file":"node.js","names":[],"sources":["../../src/internal/node.ts"],"sourcesContent":["/**\n * Descriptions of parsers, recorded next to their steps so that parsers can\n * be compiled (see `docs/DESIGN.md`, \"Compiled parsers\").\n *\n * Nodes refer to their child parsers rather than to child nodes, so a\n * child's own step is always at hand for fallback, and recursion through\n * `Suspend` is just a reference.\n */\nimport * as Predicate from \"effect/Predicate\"\nimport type * as Option from \"effect/Option\"\nimport type * as Result from \"effect/Result\"\nimport type { Encoding } from \"../Encoding.js\"\nimport type { ErrMode, Input, State } from \"../Input.js\"\n\n/** The parts of a parser the compiler needs. */\nexport interface ParserLike {\n  readonly step: (state: State<any>) => unknown\n  readonly name: string | undefined\n}\n\ntype P = ParserLike\ntype Step = (state: State<any>) => unknown\n\n/** A repetition range, normalized: `max` may be `Infinity`. */\ninterface Bounds {\n  readonly min: number\n  readonly max: number\n}\n\n/**\n * For token nodes: `undefined` for the `Token`/`Ascii` parsers (code points\n * of strings with lenient surrogates, bytes, or array elements), or the\n * encoding of a `Text` parser.\n */\ntype Enc = Encoding<any> | undefined\n\nexport type Node =\n  // Constants\n  | { readonly _tag: \"Opaque\"; readonly step: Step }\n  | { readonly _tag: \"Succeed\"; readonly value: unknown }\n  | { readonly _tag: \"Sync\"; readonly evaluate: () => unknown }\n  | { readonly _tag: \"Fail\"; readonly mode: ErrMode }\n  | { readonly _tag: \"Eof\" }\n  | { readonly _tag: \"Location\" }\n  | { readonly _tag: \"Suspend\"; readonly resolve: () => P }\n  // Tokens\n  | { readonly _tag: \"Any\"; readonly encoding: Enc }\n  | { readonly _tag: \"Literal\"; readonly literal: Input; readonly caseless: boolean; readonly encoding: Enc }\n  | { readonly _tag: \"OneOf\"; readonly set: unknown; readonly negate: boolean; readonly encoding: Enc }\n  | { readonly _tag: \"Take\"; readonly count: number; readonly encoding: Enc }\n  | ({ readonly _tag: \"TakeWhile\"; readonly set: unknown; readonly negate: boolean; readonly encoding: Enc } & Bounds)\n  | ({ readonly _tag: \"TakeUntil\"; readonly literal: Input; readonly encoding: Enc } & Bounds)\n  | { readonly _tag: \"Rest\"; readonly encoding: Enc }\n  | { readonly _tag: \"RestLen\" }\n  | { readonly _tag: \"TillLineEnding\"; readonly encoding: Enc }\n  | { readonly _tag: \"Identifier\"; readonly encoding: Enc }\n  | { readonly _tag: \"Bom\"; readonly encoding: Enc }\n  | {\n      readonly _tag: \"Escaped\"\n      readonly normal: P\n      /** The control character, as a code point (or a byte / unit for `Ascii`). */\n      readonly control: number\n      readonly escape: P\n      /** `takeEscaped`: return the raw slice instead of the unescaped text. */\n      readonly raw: boolean\n      readonly encoding: Enc\n    }\n  // Mapping\n  | { readonly _tag: \"Map\"; readonly self: P; readonly f: (a: any) => unknown }\n  | { readonly _tag: \"As\"; readonly self: P; readonly value: unknown }\n  | { readonly _tag: \"Tap\"; readonly self: P; readonly f: (a: any) => void }\n  | { readonly _tag: \"TryMap\"; readonly self: P; readonly f: (a: any) => Result.Result<unknown, unknown> }\n  | { readonly _tag: \"FilterMap\"; readonly self: P; readonly f: (a: any) => Option.Option<unknown> }\n  | { readonly _tag: \"Filter\"; readonly self: P; readonly predicate: (a: any) => boolean }\n  | { readonly _tag: \"FlatMap\"; readonly self: P; readonly f: (a: any) => P }\n  // Consumed input\n  | { readonly _tag: \"Taken\"; readonly self: P; readonly encoding: Enc }\n  | { readonly _tag: \"WithTaken\"; readonly self: P }\n  | { readonly _tag: \"Span\"; readonly self: P }\n  | { readonly _tag: \"WithSpan\"; readonly self: P }\n  // Errors\n  | { readonly _tag: \"Mode\"; readonly self: P; readonly from: ErrMode; readonly to: ErrMode }\n  | { readonly _tag: \"Context\"; readonly self: P; readonly label: string }\n  | { readonly _tag: \"Expected\"; readonly self: P; readonly description: string }\n  | { readonly _tag: \"MapError\"; readonly self: P }\n  | { readonly _tag: \"OrFail\"; readonly self: P }\n  // Control\n  | { readonly _tag: \"Opt\"; readonly self: P }\n  | { readonly _tag: \"OrElseSucceed\"; readonly self: P; readonly value: () => unknown }\n  | { readonly _tag: \"Peek\"; readonly self: P }\n  | { readonly _tag: \"Not\"; readonly self: P }\n  // Sequencing\n  | {\n      readonly _tag: \"Seq\"\n      readonly parsers: ReadonlyArray<P>\n      /** Which outputs are kept: all (a tuple), one index, or a pair of indices. */\n      readonly output: \"tuple\" | number | readonly [number, number]\n    }\n  | { readonly _tag: \"Struct\"; readonly keys: ReadonlyArray<string>; readonly parsers: ReadonlyArray<P> }\n  | { readonly _tag: \"ZipWith\"; readonly self: P; readonly that: P; readonly f: (a: any, b: any) => unknown }\n  // Choice\n  | { readonly _tag: \"Alt\"; readonly parsers: ReadonlyArray<P> }\n  | {\n      readonly _tag: \"Dispatch\"\n      readonly selector: P\n      /** A record of cases, when `dispatch` was given one. */\n      readonly cases: Readonly<Record<PropertyKey, P>> | undefined\n      readonly otherwise: P | undefined\n      readonly choose: (key: any) => P | undefined\n    }\n  // Repetition\n  | ({ readonly _tag: \"Repeat\"; readonly self: P } & Bounds)\n  | ({\n      readonly _tag: \"Fold\"\n      readonly self: P\n      readonly init: () => unknown\n      readonly f: (acc: any, a: any) => unknown\n      /** Stops the repetition once false of the accumulator (after `min` elements). */\n      readonly while: ((acc: any) => boolean) | undefined\n      readonly name: string\n    } & Bounds)\n  | ({ readonly _tag: \"RepeatTill\"; readonly self: P; readonly end: P } & Bounds)\n  | ({ readonly _tag: \"Separated\"; readonly self: P; readonly separator: P } & Bounds)\n  | {\n      readonly _tag: \"SeparatedFold\"\n      readonly self: P\n      readonly separator: P\n      readonly op: (l: any, s: any, r: any) => unknown\n      readonly right: boolean\n    }\n  // Services, recovery, debugging\n  | { readonly _tag: \"Service\" }\n  | { readonly _tag: \"Provide\"; readonly self: P }\n  | { readonly _tag: \"ResumeAfter\"; readonly self: P; readonly recover: P }\n  | { readonly _tag: \"RetryAfter\"; readonly self: P; readonly recover: P }\n  | { readonly _tag: \"Trace\"; readonly self: P; readonly name: string }\n  /** `Syntax.node`, `Syntax.token` and `Syntax.field`: identities outside `Syntax` parses. */\n  | {\n      readonly _tag: \"Syntax\"\n      readonly self: P\n      /** The node kind, or `undefined` for a field. */\n      readonly kind: string | undefined\n      readonly named: boolean\n    }\n\nexport type Tag = Node[\"_tag\"]\n\nexport type NodeOf<T extends Tag> = Extract<Node, { readonly _tag: T }>\n\n/** Where a parser's description is stored. */\nexport const NodeId: unique symbol = /*#__PURE__*/ Symbol.for(\"effect-parse/Parser/node\")\n\n/** The description of a parser: `Opaque` when it has none. */\nexport const nodeOf = (p: ParserLike): Node => (p as any)[NodeId] ?? { _tag: \"Opaque\", step: p.step }\n\n/** Normalizes a range, as `repeat`, `takeWhile`, ... do. */\nexport const bounds = (\n  range: number | { readonly min?: number | undefined; readonly max?: number | undefined } | undefined\n): Bounds => {\n  if (range === undefined) return { min: 0, max: Infinity }\n  if (Predicate.isNumber(range)) return { min: range, max: range }\n  return { min: range.min ?? 0, max: range.max ?? Infinity }\n}\n\n/**\n * Whether the compilers' one-pass float scan applies to `p`, the text\n * parser of `Ascii.float` / `Text.float`: a `taken` (under any `expected`\n * labels) in an encoding that `native` accepts, reading one ASCII-compatible\n * unit at a time, or in no encoding at all.\n */\nexport const scansFloat = (p: ParserLike, native: (enc: Encoding<any>) => boolean): boolean => {\n  let taken = nodeOf(p)\n  while (Predicate.isTagged(taken, \"Expected\")) taken = nodeOf(taken.self)\n  if (!Predicate.isTagged(taken, \"Taken\")) return false\n  const enc = taken.encoding\n  // Decimal notation is ASCII, which these encodings read unit by unit\n  return enc === undefined || (native(enc) && enc.unit === 1 && enc.asciiCompatible)\n}\n\n/** The child parsers of a node, in evaluation order. */\nexport const children = (node: Node): ReadonlyArray<P> => {\n  switch (node._tag) {\n    case \"Escaped\":\n      return [node.normal, node.escape]\n    case \"Map\":\n    case \"As\":\n    case \"Tap\":\n    case \"TryMap\":\n    case \"FilterMap\":\n    case \"Filter\":\n    case \"FlatMap\":\n    case \"Taken\":\n    case \"WithTaken\":\n    case \"Span\":\n    case \"WithSpan\":\n    case \"Mode\":\n    case \"Context\":\n    case \"Expected\":\n    case \"MapError\":\n    case \"OrFail\":\n    case \"Opt\":\n    case \"OrElseSucceed\":\n    case \"Peek\":\n    case \"Not\":\n    case \"Repeat\":\n    case \"Fold\":\n    case \"Provide\":\n    case \"Trace\":\n    case \"Syntax\":\n      return [node.self]\n    case \"ResumeAfter\":\n    case \"RetryAfter\":\n      return [node.self, node.recover]\n    case \"Seq\":\n    case \"Struct\":\n    case \"Alt\":\n      return node.parsers\n    case \"ZipWith\":\n      return [node.self, node.that]\n    case \"Dispatch\": {\n      const out: Array<P> = [node.selector]\n      if (node.cases !== undefined) {\n        for (const key of Reflect.ownKeys(node.cases)) out.push(node.cases[key as any])\n      }\n      if (node.otherwise !== undefined) out.push(node.otherwise)\n      return out\n    }\n    case \"RepeatTill\":\n      return [node.self, node.end]\n    case \"Separated\":\n    case \"SeparatedFold\":\n      return [node.self, node.separator]\n    case \"Suspend\":\n      return [node.resolve()]\n    default:\n      return []\n  }\n}\n"],"mappings":";;;;;;;;;;;AAsJA,MAAa,SAAsC,qBAAO,IAAI,0BAA0B;;AAGxF,MAAa,UAAU,MAAyB,EAAU,WAAW;CAAE,MAAM;CAAU,MAAM,EAAE;AAAK;;AAGpG,MAAa,UACX,UACW;CACX,IAAI,UAAU,KAAA,GAAW,OAAO;EAAE,KAAK;EAAG,KAAK;CAAS;CACxD,IAAI,UAAU,SAAS,KAAK,GAAG,OAAO;EAAE,KAAK;EAAO,KAAK;CAAM;CAC/D,OAAO;EAAE,KAAK,MAAM,OAAO;EAAG,KAAK,MAAM,OAAO;CAAS;AAC3D;;;;;;;AAQA,MAAa,cAAc,GAAe,WAAqD;CAC7F,IAAI,QAAQ,OAAO,CAAC;CACpB,OAAO,UAAU,SAAS,OAAO,UAAU,GAAG,QAAQ,OAAO,MAAM,IAAI;CACvE,IAAI,CAAC,UAAU,SAAS,OAAO,OAAO,GAAG,OAAO;CAChD,MAAM,MAAM,MAAM;CAElB,OAAO,QAAQ,KAAA,KAAc,OAAO,GAAG,KAAK,IAAI,SAAS,KAAK,IAAI;AACpE;;AAGA,MAAa,YAAY,SAAiC;CACxD,QAAQ,KAAK,MAAb;EACE,KAAK,WACH,OAAO,CAAC,KAAK,QAAQ,KAAK,MAAM;EAClC,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,UACH,OAAO,CAAC,KAAK,IAAI;EACnB,KAAK;EACL,KAAK,cACH,OAAO,CAAC,KAAK,MAAM,KAAK,OAAO;EACjC,KAAK;EACL,KAAK;EACL,KAAK,OACH,OAAO,KAAK;EACd,KAAK,WACH,OAAO,CAAC,KAAK,MAAM,KAAK,IAAI;EAC9B,KAAK,YAAY;GACf,MAAM,MAAgB,CAAC,KAAK,QAAQ;GACpC,IAAI,KAAK,UAAU,KAAA,GACjB,KAAK,MAAM,OAAO,QAAQ,QAAQ,KAAK,KAAK,GAAG,IAAI,KAAK,KAAK,MAAM,IAAW;GAEhF,IAAI,KAAK,cAAc,KAAA,GAAW,IAAI,KAAK,KAAK,SAAS;GACzD,OAAO;EACT;EACA,KAAK,cACH,OAAO,CAAC,KAAK,MAAM,KAAK,GAAG;EAC7B,KAAK;EACL,KAAK,iBACH,OAAO,CAAC,KAAK,MAAM,KAAK,SAAS;EACnC,KAAK,WACH,OAAO,CAAC,KAAK,QAAQ,CAAC;EACxB,SACE,OAAO,CAAC;CACZ;AACF"}

package/dist/internal/numbers.d.ts

@@ -1,5 +1,4 @@
 import { Fail, Input } from "../Input.js";
-//#region src/internal/numbers.d.ts
 /** The text of an input slice: as is for a string, Latin-1 for bytes, joined for tokens. */
 export declare const toText: (s: Input) => string;
 /** The value of the text matched by `Ascii.float` and `Text.float`. */
@@ -36,5 +35,4 @@ export declare const floatScan: {
 export declare const scanFloatString: (s: string, i: number, end: number) => number | Fail | undefined;
 /** {@link scanFloatString} on bytes, or the units of an ASCII compatible encoding. */
 export declare const scanFloatBytes: (b: Uint8Array, i: number, end: number) => number | Fail | undefined;
-//#endregion
 //# sourceMappingURL=numbers.d.ts.map

package/dist/internal/numbers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"numbers.d.ts","names":[],"sources":["../../src/internal/numbers.ts"],"mappings":";;;qBAUa,SAAU,GAAG;;qBAIb,UAAW,GAAG;;;;;;qBAmBd,YAAU;;qBAGV,YAAa,kBAAkB,GAAG,MAAI;;;;;;qBAatC;;;;;;;;;;;;;;;;qBAiFA,kBAAmB,WAAW,WAAW,yBAAuB;;qBAmFhE,iBAAkB,GAAG,YAAY,WAAW,yBAAuB"}
+{"version":3,"file":"numbers.d.ts","names":[],"sources":["../../src/internal/numbers.ts"],"mappings":";;qBAUa,SAAU,GAAG;;qBAIb,UAAW,GAAG;;;;;;qBAmBd,YAAU;;qBAGV,YAAa,kBAAkB,GAAG,MAAI;;;;;;qBAatC;;;;;;;;;;;;;;;;qBAiFA,kBAAmB,WAAW,WAAW,yBAAuB;;qBAmFhE,iBAAkB,GAAG,YAAY,WAAW,yBAAuB"}

package/dist/internal/numbers.js

@@ -1,7 +1,7 @@
 import * as Predicate from "effect/Predicate";
 import { Fail } from "../Input.js";
 import { latin1 } from "./text.js";
-//#region src/internal/numbers.ts
+// src/internal/numbers.ts
 /**
 * Number conversions shared by the `Ascii` and `Text` parsers and the
 * compilers.
@@ -266,7 +266,6 @@ const scanFloatBytes = (b, i, end) => {
 };
 /** The text of ASCII bytes. */
 const asciiText = (b, start, end) => String.fromCharCode.apply(null, b.subarray(start, end));
-//#endregion
 export { floatScan, floatText, floatTexts, scanFloatBytes, scanFloatString, toFloat, toText };
 
 //# sourceMappingURL=numbers.js.map

package/dist/internal/resume.d.ts

@@ -1,9 +1,9 @@
 import { State } from "../Input.js";
-//#region src/internal/resume.d.ts
+import { Key } from "./key.js";
 /** The checkpoints of a resumable parse. */
-export type Checkpoints = Map<object, Map<number, unknown>>;
+export type Checkpoints = Map<Key, Map<number, unknown>>;
 /** Takes (and removes) the checkpoint of `key` entered at `offset`, if any. */
-export declare const take: (state: State<any>, key: object, offset: number) => unknown;
+export declare const take: (state: State<any>, key: Key, offset: number) => unknown;
 /** The result of a repetition that completed, and where it ended. */
 export declare class Done {
   readonly value: unknown;
@@ -14,8 +14,7 @@ export declare class Done {
  * Returns `value`, the result of a repetition entered at `entry`; when the
  * repetition was resumed from a checkpoint, records it as {@link Done}.
  */
-export declare const done: <A>(state: State<any>, key: object, entry: number, resumed: boolean, value: A) => A;
+export declare const done: <A>(state: State<any>, key: Key, entry: number, resumed: boolean, value: A) => A;
 /** Records the checkpoint of `key` entered at `offset`. */
-export declare const save: (state: State<any>, key: object, offset: number, checkpoint: unknown) => void;
-//#endregion
+export declare const save: (state: State<any>, key: Key, offset: number, checkpoint: unknown) => void;
 //# sourceMappingURL=resume.d.ts.map

package/dist/internal/resume.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resume.d.ts","names":[],"sources":["../../src/internal/resume.ts"],"mappings":";;;YAuBY,cAAc,YAAY;;qBAGzB,OAAQ,OAAO,YAAY,aAAa;;qBASxC;WAEA;WACA;EADA,YAAA,gBACA;;;;;;qBAQA,OAAQ,GAAG,OAAO,YAAY,aAAa,eAAe,kBAAkB,OAAO,MAAI;;qBAMvF,OAAQ,OAAO,YAAY,aAAa,gBAAgB"}
+{"version":3,"file":"resume.d.ts","names":[],"sources":["../../src/internal/resume.ts"],"mappings":";;;YAwBY,cAAc,IAAI,KAAK;;qBAGtB,OAAQ,OAAO,YAAY,KAAK,KAAK;;qBASrC;WAEA;WACA;EADA,YAAA,gBACA;;;;;;qBAQA,OAAQ,GAAG,OAAO,YAAY,KAAK,KAAK,eAAe,kBAAkB,OAAO,MAAI;;qBAMpF,OAAQ,OAAO,YAAY,KAAK,KAAK,gBAAgB"}

package/dist/internal/resume.js

@@ -1,4 +1,4 @@
-//#region src/internal/resume.ts
+// src/internal/resume.ts
 /** Takes (and removes) the checkpoint of `key` entered at `offset`, if any. */
 const take = (state, key, offset) => {
 	const byKey = state.resume?.get(key);
@@ -32,7 +32,6 @@ const save = (state, key, offset, checkpoint) => {
 	if (byKey === void 0) resume.set(key, byKey = /* @__PURE__ */ new Map());
 	byKey.set(offset, checkpoint);
 };
-//#endregion
 export { Done, done, save, take };
 
 //# sourceMappingURL=resume.js.map

package/dist/internal/resume.js.map

@@ -1 +1 @@
-{"version":3,"file":"resume.js","names":[],"sources":["../../src/internal/resume.ts"],"sourcesContent":["/**\n * Checkpoints for resumable (streaming) parses.\n *\n * In partial mode a parser only succeeds on what it has seen, so a value\n * parsed from a prefix of the input stays the same when more input\n * arrives. A repetition that runs out of input mid-way can therefore record\n * how far it got (its accumulator and position) before the failure\n * propagates. When the parse is attempted again with more input, the same\n * repetition, entered at the same offset, takes its checkpoint and carries\n * on from there instead of re-parsing every element.\n *\n * Checkpoints are keyed by a per-parser key and the offset the repetition\n * started at. Taking a checkpoint removes it, so its accumulator has a\n * single owner; the repetition saves a new one if it runs out again.\n *\n * A resumed repetition that then completes leaves a {@link Done}\n * checkpoint with its result, since the input may still run out after it\n * (in trailing whitespace, say) and the next attempt would otherwise parse\n * it all again. `Done` checkpoints stay in place when taken.\n */\nimport type { State } from \"../Input.js\"\n\n/** The checkpoints of a resumable parse. */\nexport type Checkpoints = Map<object, Map<number, unknown>>\n\n/** Takes (and removes) the checkpoint of `key` entered at `offset`, if any. */\nexport const take = (state: State<any>, key: object, offset: number): unknown => {\n  const byKey = state.resume?.get(key)\n  if (byKey === undefined) return undefined\n  const checkpoint = byKey.get(offset)\n  if (checkpoint !== undefined && !(checkpoint instanceof Done)) byKey.delete(offset)\n  return checkpoint\n}\n\n/** The result of a repetition that completed, and where it ended. */\nexport class Done {\n  constructor(\n    readonly value: unknown,\n    readonly pos: number\n  ) {}\n}\n\n/**\n * Returns `value`, the result of a repetition entered at `entry`; when the\n * repetition was resumed from a checkpoint, records it as {@link Done}.\n */\nexport const done = <A>(state: State<any>, key: object, entry: number, resumed: boolean, value: A): A => {\n  if (resumed && state.resume !== undefined) save(state, key, entry, new Done(value, state.pos))\n  return value\n}\n\n/** Records the checkpoint of `key` entered at `offset`. */\nexport const save = (state: State<any>, key: object, offset: number, checkpoint: unknown): void => {\n  const resume = state.resume\n  if (resume === undefined) return\n  let byKey = resume.get(key)\n  if (byKey === undefined) resume.set(key, (byKey = new Map()))\n  byKey.set(offset, checkpoint)\n}\n"],"mappings":";;AA0BA,MAAa,QAAQ,OAAmB,KAAa,WAA4B;CAC/E,MAAM,QAAQ,MAAM,QAAQ,IAAI,GAAG;CACnC,IAAI,UAAU,KAAA,GAAW,OAAO,KAAA;CAChC,MAAM,aAAa,MAAM,IAAI,MAAM;CACnC,IAAI,eAAe,KAAA,KAAa,EAAE,sBAAsB,OAAO,MAAM,OAAO,MAAM;CAClF,OAAO;AACT;;AAGA,IAAa,OAAb,MAAkB;CAEL;CACA;CAFX,YACE,OACA,KACA;EAFS,KAAA,QAAA;EACA,KAAA,MAAA;CACR;AACL;;;;;AAMA,MAAa,QAAW,OAAmB,KAAa,OAAe,SAAkB,UAAgB;CACvG,IAAI,WAAW,MAAM,WAAW,KAAA,GAAW,KAAK,OAAO,KAAK,OAAO,IAAI,KAAK,OAAO,MAAM,GAAG,CAAC;CAC7F,OAAO;AACT;;AAGA,MAAa,QAAQ,OAAmB,KAAa,QAAgB,eAA8B;CACjG,MAAM,SAAS,MAAM;CACrB,IAAI,WAAW,KAAA,GAAW;CAC1B,IAAI,QAAQ,OAAO,IAAI,GAAG;CAC1B,IAAI,UAAU,KAAA,GAAW,OAAO,IAAI,KAAM,wBAAQ,IAAI,IAAI,CAAE;CAC5D,MAAM,IAAI,QAAQ,UAAU;AAC9B"}
+{"version":3,"file":"resume.js","names":[],"sources":["../../src/internal/resume.ts"],"sourcesContent":["/**\n * Checkpoints for resumable (streaming) parses.\n *\n * In partial mode a parser only succeeds on what it has seen, so a value\n * parsed from a prefix of the input stays the same when more input\n * arrives. A repetition that runs out of input mid-way can therefore record\n * how far it got (its accumulator and position) before the failure\n * propagates. When the parse is attempted again with more input, the same\n * repetition, entered at the same offset, takes its checkpoint and carries\n * on from there instead of re-parsing every element.\n *\n * Checkpoints are keyed by a per-parser key and the offset the repetition\n * started at. Taking a checkpoint removes it, so its accumulator has a\n * single owner; the repetition saves a new one if it runs out again.\n *\n * A resumed repetition that then completes leaves a {@link Done}\n * checkpoint with its result, since the input may still run out after it\n * (in trailing whitespace, say) and the next attempt would otherwise parse\n * it all again. `Done` checkpoints stay in place when taken.\n */\nimport type { State } from \"../Input.js\"\nimport type { Key } from \"./key.js\"\n\n/** The checkpoints of a resumable parse. */\nexport type Checkpoints = Map<Key, Map<number, unknown>>\n\n/** Takes (and removes) the checkpoint of `key` entered at `offset`, if any. */\nexport const take = (state: State<any>, key: Key, offset: number): unknown => {\n  const byKey = state.resume?.get(key)\n  if (byKey === undefined) return undefined\n  const checkpoint = byKey.get(offset)\n  if (checkpoint !== undefined && !(checkpoint instanceof Done)) byKey.delete(offset)\n  return checkpoint\n}\n\n/** The result of a repetition that completed, and where it ended. */\nexport class Done {\n  constructor(\n    readonly value: unknown,\n    readonly pos: number\n  ) {}\n}\n\n/**\n * Returns `value`, the result of a repetition entered at `entry`; when the\n * repetition was resumed from a checkpoint, records it as {@link Done}.\n */\nexport const done = <A>(state: State<any>, key: Key, entry: number, resumed: boolean, value: A): A => {\n  if (resumed && state.resume !== undefined) save(state, key, entry, new Done(value, state.pos))\n  return value\n}\n\n/** Records the checkpoint of `key` entered at `offset`. */\nexport const save = (state: State<any>, key: Key, offset: number, checkpoint: unknown): void => {\n  const resume = state.resume\n  if (resume === undefined) return\n  let byKey = resume.get(key)\n  if (byKey === undefined) resume.set(key, (byKey = new Map()))\n  byKey.set(offset, checkpoint)\n}\n"],"mappings":";;AA2BA,MAAa,QAAQ,OAAmB,KAAU,WAA4B;CAC5E,MAAM,QAAQ,MAAM,QAAQ,IAAI,GAAG;CACnC,IAAI,UAAU,KAAA,GAAW,OAAO,KAAA;CAChC,MAAM,aAAa,MAAM,IAAI,MAAM;CACnC,IAAI,eAAe,KAAA,KAAa,EAAE,sBAAsB,OAAO,MAAM,OAAO,MAAM;CAClF,OAAO;AACT;;AAGA,IAAa,OAAb,MAAkB;CAEL;CACA;CAFX,YACE,OACA,KACA;EAFS,KAAA,QAAA;EACA,KAAA,MAAA;CACR;AACL;;;;;AAMA,MAAa,QAAW,OAAmB,KAAU,OAAe,SAAkB,UAAgB;CACpG,IAAI,WAAW,MAAM,WAAW,KAAA,GAAW,KAAK,OAAO,KAAK,OAAO,IAAI,KAAK,OAAO,MAAM,GAAG,CAAC;CAC7F,OAAO;AACT;;AAGA,MAAa,QAAQ,OAAmB,KAAU,QAAgB,eAA8B;CAC9F,MAAM,SAAS,MAAM;CACrB,IAAI,WAAW,KAAA,GAAW;CAC1B,IAAI,QAAQ,OAAO,IAAI,GAAG;CAC1B,IAAI,UAAU,KAAA,GAAW,OAAO,IAAI,KAAM,wBAAQ,IAAI,IAAI,CAAE;CAC5D,MAAM,IAAI,QAAQ,UAAU;AAC9B"}

package/dist/internal/run.d.ts

@@ -1,6 +1,5 @@
 import { Fail, State } from "../Input.js";
 import { ParserLike } from "./node.js";
-//#region src/internal/run.d.ts
 /**
  * Runs `p` on `state` from `state.pos`: its compiled form when it has one
  * and the state allows it, else its step. A compiled run that fails is
@@ -11,5 +10,4 @@ import { ParserLike } from "./node.js";
  * with streaming checkpoints) use the resumable build.
  */
 export declare const runOn: <A>(p: ParserLike, step: (state: State<any>) => A | Fail, state: State<any>, diagnostics?: boolean) => A | Fail;
-//#endregion
 //# sourceMappingURL=run.d.ts.map

package/dist/internal/run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run.d.ts","names":[],"sources":["../../src/internal/run.ts"],"mappings":";;;;;;;;;;;;qBAoBa,QAAS,GACpB,GAAG,YACH,OAAO,OAAO,eAAe,IAAI,MACjC,OAAO,YACP,0BACC,IAAI"}
+{"version":3,"file":"run.d.ts","names":[],"sources":["../../src/internal/run.ts"],"mappings":";;;;;;;;;;;qBAoBa,QAAS,GACpB,GAAG,YACH,OAAO,OAAO,eAAe,IAAI,MACjC,OAAO,YACP,0BACC,IAAI"}

package/dist/internal/run.js

@@ -1,7 +1,7 @@
 import { Fail } from "../Input.js";
 import * as Registry from "./compiler/registry.js";
 import * as Stack from "./stack.js";
-//#region src/internal/run.ts
+// src/internal/run.ts
 /**
 * Running a parser on a caller-owned `State`, compiled when possible.
 *
@@ -24,13 +24,12 @@ const runOn = (p, step, state, diagnostics = true) => {
 			const start = state.pos;
 			const a = Stack.run(compiled, state);
 			if (a !== Fail) return a;
-			state.pos = start;
+			state.rewind(start);
 			if (!diagnostics) return Fail;
 		}
 	}
 	return Stack.run(step, state);
 };
-//#endregion
 export { runOn };
 
 //# sourceMappingURL=run.js.map

package/dist/internal/run.js.map

@@ -1 +1 @@
-{"version":3,"file":"run.js","names":[],"sources":["../../src/internal/run.ts"],"sourcesContent":["/**\n * Running a parser on a caller-owned `State`, compiled when possible.\n *\n * Shared by `Parser.run` and `ParserStream.parseMany`, which keep one\n * state across many small runs.\n */\nimport { Fail, type State } from \"../Input.js\"\nimport * as Registry from \"./compiler/registry.js\"\nimport type { ParserLike } from \"./node.js\"\nimport * as Stack from \"./stack.js\"\n\n/**\n * Runs `p` on `state` from `state.pos`: its compiled form when it has one\n * and the state allows it, else its step. A compiled run that fails is\n * thrown away and the step runs again from the same position, so a\n * failure leaves the state exactly as the interpreter would; with\n * `diagnostics` false it is not, and the state keeps the compiled run's\n * `mode`, with the cursor back at the start. Partial states (and states\n * with streaming checkpoints) use the resumable build.\n */\nexport const runOn = <A>(\n  p: ParserLike,\n  step: (state: State<any>) => A | Fail,\n  state: State<any>,\n  diagnostics: boolean = true\n): A | Fail => {\n  if (state.tracer === undefined && state.recovered === undefined && state.syntax === undefined) {\n    const compiled = Registry.stepFor(p, state, state.partial || state.resume !== undefined)\n    if (compiled !== undefined) {\n      const start = state.pos\n      const a = Stack.run(compiled, state)\n      if (a !== Fail) {\n        // SAFETY: the compiled step returns what the parser's step returns\n        return a as A\n      }\n      state.pos = start\n      if (!diagnostics) return Fail\n    }\n  }\n  return Stack.run(step, state)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAoBA,MAAa,SACX,GACA,MACA,OACA,cAAuB,SACV;CACb,IAAI,MAAM,WAAW,KAAA,KAAa,MAAM,cAAc,KAAA,KAAa,MAAM,WAAW,KAAA,GAAW;EAC7F,MAAM,WAAW,SAAS,QAAQ,GAAG,OAAO,MAAM,WAAW,MAAM,WAAW,KAAA,CAAS;EACvF,IAAI,aAAa,KAAA,GAAW;GAC1B,MAAM,QAAQ,MAAM;GACpB,MAAM,IAAI,MAAM,IAAI,UAAU,KAAK;GACnC,IAAI,MAAM,MAER,OAAO;GAET,MAAM,MAAM;GACZ,IAAI,CAAC,aAAa,OAAO;EAC3B;CACF;CACA,OAAO,MAAM,IAAI,MAAM,KAAK;AAC9B"}
+{"version":3,"file":"run.js","names":[],"sources":["../../src/internal/run.ts"],"sourcesContent":["/**\n * Running a parser on a caller-owned `State`, compiled when possible.\n *\n * Shared by `Parser.run` and `ParserStream.parseMany`, which keep one\n * state across many small runs.\n */\nimport { Fail, type State } from \"../Input.js\"\nimport * as Registry from \"./compiler/registry.js\"\nimport type { ParserLike } from \"./node.js\"\nimport * as Stack from \"./stack.js\"\n\n/**\n * Runs `p` on `state` from `state.pos`: its compiled form when it has one\n * and the state allows it, else its step. A compiled run that fails is\n * thrown away and the step runs again from the same position, so a\n * failure leaves the state exactly as the interpreter would; with\n * `diagnostics` false it is not, and the state keeps the compiled run's\n * `mode`, with the cursor back at the start. Partial states (and states\n * with streaming checkpoints) use the resumable build.\n */\nexport const runOn = <A>(\n  p: ParserLike,\n  step: (state: State<any>) => A | Fail,\n  state: State<any>,\n  diagnostics: boolean = true\n): A | Fail => {\n  if (state.tracer === undefined && state.recovered === undefined && state.syntax === undefined) {\n    const compiled = Registry.stepFor(p, state, state.partial || state.resume !== undefined)\n    if (compiled !== undefined) {\n      const start = state.pos\n      const a = Stack.run(compiled, state)\n      if (a !== Fail) {\n        // SAFETY: the compiled step returns what the parser's step returns\n        return a as A\n      }\n      state.rewind(start)\n      if (!diagnostics) return Fail\n    }\n  }\n  return Stack.run(step, state)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAoBA,MAAa,SACX,GACA,MACA,OACA,cAAuB,SACV;CACb,IAAI,MAAM,WAAW,KAAA,KAAa,MAAM,cAAc,KAAA,KAAa,MAAM,WAAW,KAAA,GAAW;EAC7F,MAAM,WAAW,SAAS,QAAQ,GAAG,OAAO,MAAM,WAAW,MAAM,WAAW,KAAA,CAAS;EACvF,IAAI,aAAa,KAAA,GAAW;GAC1B,MAAM,QAAQ,MAAM;GACpB,MAAM,IAAI,MAAM,IAAI,UAAU,KAAK;GACnC,IAAI,MAAM,MAER,OAAO;GAET,MAAM,OAAO,KAAK;GAClB,IAAI,CAAC,aAAa,OAAO;EAC3B;CACF;CACA,OAAO,MAAM,IAAI,MAAM,KAAK;AAC9B"}

package/dist/internal/stack.d.ts

@@ -1,5 +1,4 @@
 import { Fail, State } from "../Input.js";
-//#region src/internal/stack.d.ts
 /**
  * Whether `e` is the engine's call-stack overflow: a `RangeError` in V8
  * and JavaScriptCore, an `InternalError` ("too much recursion") in
@@ -12,5 +11,4 @@ export declare const isStackOverflow: (e: unknown) => boolean;
  * propagate.
  */
 export declare const run: <S extends State<any>, A>(step: (state: S) => A, state: S) => A | Fail;
-//#endregion
 //# sourceMappingURL=stack.d.ts.map

package/dist/internal/stack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stack.d.ts","names":[],"sources":["../../src/internal/stack.ts"],"mappings":";;;;;;;qBAmBa,kBAAmB;;;;;;qBASnB,MAAO,UAAU,YAAY,GAAG,OAAO,OAAO,MAAM,GAAG,OAAO,MAAI,IAAI"}
+{"version":3,"file":"stack.d.ts","names":[],"sources":["../../src/internal/stack.ts"],"mappings":";;;;;;qBAoBa,kBAAmB;;;;;;qBAanB,MAAO,UAAU,YAAY,GAAG,OAAO,OAAO,MAAM,GAAG,OAAO,MAAI,IAAI"}

package/dist/internal/stack.js

@@ -1,4 +1,14 @@
-//#region src/internal/stack.ts
+import * as Predicate from "effect/Predicate";
+// src/internal/stack.ts
+/**
+* Call-stack overflows.
+*
+* The interpreter and the compiled backends recurse once (or more) per
+* nesting level of a recursive grammar, so deeply nested input, such as
+* thousands of `{`, can exhaust the call stack. The runners catch the
+* engine's overflow error and report a `TooDeep` failure instead, keeping
+* their `Result` contract on untrusted input.
+*/
 /** The message of a `TooDeep` failure. */
 const tooDeepMessage = "input is nested too deeply: parsing exhausted the call stack";
 /**
@@ -6,7 +16,7 @@ const tooDeepMessage = "input is nested too deeply: parsing exhausted the call s
 * and JavaScriptCore, an `InternalError` ("too much recursion") in
 * SpiderMonkey.
 */
-const isStackOverflow = (e) => e instanceof RangeError && /call stack/i.test(e.message) || e instanceof Error && e.name === "InternalError" && /recursion/i.test(e.message);
+const isStackOverflow = (e) => e instanceof RangeError && /call stack/i.test(e.message) || Predicate.hasProperty(e, "name") && Predicate.hasProperty(e, "message") && e.name === "InternalError" && Predicate.isString(e.message) && /recursion/i.test(e.message);
 /**
 * Runs `step`, turning a call-stack overflow into an unrecoverable
 * `TooDeep` failure at the offset parsing had reached. Other exceptions
@@ -20,7 +30,6 @@ const run = (step, state) => {
 		return state.failMessage("Cut", "TooDeep", tooDeepMessage);
 	}
 };
-//#endregion
 export { isStackOverflow, run };
 
 //# sourceMappingURL=stack.js.map

package/dist/internal/stack.js.map

@@ -1 +1 @@
-{"version":3,"file":"stack.js","names":[],"sources":["../../src/internal/stack.ts"],"sourcesContent":["/**\n * Call-stack overflows.\n *\n * The interpreter and the compiled backends recurse once (or more) per\n * nesting level of a recursive grammar, so deeply nested input, such as\n * thousands of `{`, can exhaust the call stack. The runners catch the\n * engine's overflow error and report a `TooDeep` failure instead, keeping\n * their `Result` contract on untrusted input.\n */\nimport type { Fail, State } from \"../Input.js\"\n\n/** The message of a `TooDeep` failure. */\nconst tooDeepMessage = \"input is nested too deeply: parsing exhausted the call stack\"\n\n/**\n * Whether `e` is the engine's call-stack overflow: a `RangeError` in V8\n * and JavaScriptCore, an `InternalError` (\"too much recursion\") in\n * SpiderMonkey.\n */\nexport const isStackOverflow = (e: unknown): boolean =>\n  (e instanceof RangeError && /call stack/i.test(e.message)) ||\n  (e instanceof Error && e.name === \"InternalError\" && /recursion/i.test(e.message))\n\n/**\n * Runs `step`, turning a call-stack overflow into an unrecoverable\n * `TooDeep` failure at the offset parsing had reached. Other exceptions\n * propagate.\n */\nexport const run = <S extends State<any>, A>(step: (state: S) => A, state: S): A | Fail => {\n  try {\n    return step(state)\n  } catch (e) {\n    if (!isStackOverflow(e)) throw e\n    return state.failMessage(\"Cut\", \"TooDeep\", tooDeepMessage)\n  }\n}\n"],"mappings":";;AAYA,MAAM,iBAAiB;;;;;;AAOvB,MAAa,mBAAmB,MAC7B,aAAa,cAAc,cAAc,KAAK,EAAE,OAAO,KACvD,aAAa,SAAS,EAAE,SAAS,mBAAmB,aAAa,KAAK,EAAE,OAAO;;;;;;AAOlF,MAAa,OAAgC,MAAuB,UAAuB;CACzF,IAAI;EACF,OAAO,KAAK,KAAK;CACnB,SAAS,GAAG;EACV,IAAI,CAAC,gBAAgB,CAAC,GAAG,MAAM;EAC/B,OAAO,MAAM,YAAY,OAAO,WAAW,cAAc;CAC3D;AACF"}
+{"version":3,"file":"stack.js","names":[],"sources":["../../src/internal/stack.ts"],"sourcesContent":["/**\n * Call-stack overflows.\n *\n * The interpreter and the compiled backends recurse once (or more) per\n * nesting level of a recursive grammar, so deeply nested input, such as\n * thousands of `{`, can exhaust the call stack. The runners catch the\n * engine's overflow error and report a `TooDeep` failure instead, keeping\n * their `Result` contract on untrusted input.\n */\nimport * as Predicate from \"effect/Predicate\"\nimport type { Fail, State } from \"../Input.js\"\n\n/** The message of a `TooDeep` failure. */\nconst tooDeepMessage = \"input is nested too deeply: parsing exhausted the call stack\"\n\n/**\n * Whether `e` is the engine's call-stack overflow: a `RangeError` in V8\n * and JavaScriptCore, an `InternalError` (\"too much recursion\") in\n * SpiderMonkey.\n */\nexport const isStackOverflow = (e: unknown): boolean =>\n  (e instanceof RangeError && /call stack/i.test(e.message)) ||\n  (Predicate.hasProperty(e, \"name\") &&\n    Predicate.hasProperty(e, \"message\") &&\n    e.name === \"InternalError\" &&\n    Predicate.isString(e.message) &&\n    /recursion/i.test(e.message))\n\n/**\n * Runs `step`, turning a call-stack overflow into an unrecoverable\n * `TooDeep` failure at the offset parsing had reached. Other exceptions\n * propagate.\n */\nexport const run = <S extends State<any>, A>(step: (state: S) => A, state: S): A | Fail => {\n  try {\n    return step(state)\n  } catch (e) {\n    if (!isStackOverflow(e)) throw e\n    return state.failMessage(\"Cut\", \"TooDeep\", tooDeepMessage)\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAaA,MAAM,iBAAiB;;;;;;AAOvB,MAAa,mBAAmB,MAC7B,aAAa,cAAc,cAAc,KAAK,EAAE,OAAO,KACvD,UAAU,YAAY,GAAG,MAAM,KAC9B,UAAU,YAAY,GAAG,SAAS,KAClC,EAAE,SAAS,mBACX,UAAU,SAAS,EAAE,OAAO,KAC5B,aAAa,KAAK,EAAE,OAAO;;;;;;AAO/B,MAAa,OAAgC,MAAuB,UAAuB;CACzF,IAAI;EACF,OAAO,KAAK,KAAK;CACnB,SAAS,GAAG;EACV,IAAI,CAAC,gBAAgB,CAAC,GAAG,MAAM;EAC/B,OAAO,MAAM,YAAY,OAAO,WAAW,cAAc;CAC3D;AACF"}

package/dist/internal/syntax.d.ts

@@ -1,7 +1,6 @@
-import { ErrMode, Fail, Failure, Input, Source, State } from "../Input.js";
-import * as Context from "effect/Context";
+import { ErrMode, Failure, Input, State } from "../Input.js";
+import { Key } from "./key.js";
 import { Encoding } from "../Encoding.js";
-//#region src/internal/syntax.d.ts
 /** What a failure inside an `ERROR` node was. Offsets are relative to the node. */
 export interface ErrorInfo {
   readonly failure: Failure;
@@ -12,7 +11,7 @@ export declare class Green {
   readonly kind: string;
   readonly named: boolean;
   /** The `Syntax.node` that built it; `undefined` for roots and errors, which are never reused alone. */
-  readonly key: object | undefined;
+  readonly key: Key | undefined;
   readonly width: number;
   /** How far its parse looked, relative to its start (at least `width`). */
   readonly lookahead: number;
@@ -30,7 +29,7 @@ export declare class Green {
   readonly diagnostics: Diagnostics | undefined;
   constructor(kind: string, named: boolean,
   /** The `Syntax.node` that built it; `undefined` for roots and errors, which are never reused alone. */
-  key: object | undefined, width: number,
+  key: Key | undefined, width: number,
   /** How far its parse looked, relative to its start (at least `width`). */
   lookahead: number, children: ReadonlyArray<Green>,
   /** The children's starts, relative to this node's start. */
@@ -91,7 +90,7 @@ export interface Previous {
 }
 /** The hooks that `Syntax` combinators and `Parser.resumeAfter`/`retryAfter` call. */
 export interface Builder {
-  node(state: State<any>, step: (state: State<any>) => unknown, key: object, kind: string, named: boolean): unknown;
+  node(state: State<any>, step: (state: State<any>) => unknown, key: Key, kind: string, named: boolean): unknown;
   field(state: State<any>, step: (state: State<any>) => unknown, name: string): unknown;
   /** After error recovery: `[start, pos)` was skipped after `failure`. */
   skipped(start: number, failure: Failure, mode: ErrMode): void;
@@ -100,26 +99,39 @@ export interface Builder {
    * where they leave the cursor or record a failure.
    */
   read(end: number): void;
+  /** A failure or hint was recorded at `offset`. */
+  reach(offset: number): void;
+  /** The cursor moved back from `from` to `to` (see `State.rewind`). */
+  rewound(from: number, to: number): void;
 }
-/** The parse state of a `Syntax` parse. */
-export declare class SyntaxState<I extends Input = Input> extends State<I> implements Builder {
-  cursor: number;
-  /** The furthest position the cursor reached, or failure recorded, since the innermost open node started. */
+/**
+ * The tree builder of a `Syntax` parse, reached through `state.syntax`. It
+ * is not a `State` subclass: one class of state keeps every parser's cursor
+ * and failure accesses monomorphic, whether or not the program also builds
+ * syntax trees. `State` calls {@link reach} and {@link rewound} itself.
+ */
+export declare class SyntaxBuilder implements Builder {
+  readonly state: State<any>;
+  readonly previous: Previous | undefined;
+  /**
+   * The furthest position the cursor reached before a rewind, or failure
+   * recorded, since the innermost open node started; {@link looked} adds
+   * where the cursor is now.
+   */
   highWater: number;
   /** Completed nodes waiting for their parent, in input order. */
-  stack: Array<Child>;
-  previous: Previous | undefined;
+  readonly stack: Array<Child>;
   /** How many nodes were reused from the previous tree. */
   reused: number;
   /** Where {@link find} found the last node it found. */
   lastParent: Green | undefined;
   lastParentStart: number;
-  constructor(source: I | Source<I>, options: {
-    readonly context?: Context.Context<never> | undefined;
-  }, previous: Previous | undefined);
-  failWith(mode: ErrMode, failure: Failure): Fail;
-  setHint(offset: number, expected: ReadonlyArray<string>): void;
-  node(state: State<any>, step: (state: State<any>) => unknown, key: object, kind: string, named: boolean): unknown;
+  constructor(state: State<any>, previous: Previous | undefined);
+  reach(offset: number): void;
+  rewound(from: number, to: number): void;
+  /** How far the parse looked: {@link highWater}, or the cursor if it is further. */
+  private looked;
+  node(state: State<any>, step: (state: State<any>) => unknown, key: Key, kind: string, named: boolean): unknown;
   read(end: number): void;
   /** Records `failure` as the furthest failure if it is, as `failWith` does. */
   private deepen;
@@ -141,6 +153,5 @@ export declare class SyntaxState<I extends Input = Input> extends State<I> imple
   /** The node of the previous tree built by `key` at `pos` (in the new input), if it can be reused. */
   private reusable;
 }
-//#endregion
 export {};
 //# sourceMappingURL=syntax.d.ts.map

package/dist/internal/syntax.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"syntax.d.ts","names":[],"sources":["../../src/internal/syntax.ts"],"mappings":";;;;;iBAmCiB;WACN,SAAS;WACT,MAAM;;;qBAIJ;WAEA;WACA;;WAEA;WACA;;WAEA;WACA,UAAU,cAAc;;WAExB,SAAS;;WAET,QAAQ;WACR;;WAEA,OAAO;;WAEP;;WAEA,aAAa;EAlBb,YAAA,cACA;;EAEA,yBACA;;EAEA,mBACA,UAAU,cAAc;;EAExB,SAAS;;EAET,QAAQ,+CACR;;EAEA,OAAO;;EAEP;;EAEA,aAAa;;;;;;;iBAST;;WAEN,SAAS;;WAET;;WAEA;WACA,cAAc;;;cAInB;WAEO,OAAO;WACP;WACA;EACF;EAHE,YAAA,OAAO,OACP,eACA,aACF;;qBAIE;;qBAMA,WAAY,GAAG,SAAS,kBAAgB;;;;;iBAuCpC;WACN;WACA;WACA;;;iBAIM;WACN,MAAM;WACN;WACA;WACA,UAAU,cAAc;WACxB,OAAO;;WAEP;WACA,UAAU;;;iBAIJ;EACf,KAAK,OAAO,YAAY,OAAO,OAAO,wBAAwB,aAAa,cAAc;EACzF,MAAM,OAAO,YAAY,OAAO,OAAO,wBAAwB;;EAE/D,QAAQ,eAAe,SAAS,SAAS,MAAM;;;;;EAK/C,KAAK;;;qBAIM,YAAY,UAAU,QAAQ,eAAe,MAAM,cAAc;EAGpE;;EAEA;;EAEA,OAAO,MAAM;EACb,UAAU;;EAEV;;EAEA,YAAY;EACZ;EAsBN,YAAA,QAAQ,IAAI,OAAO,IACnB;aACW,UAAU,QAAQ;KAE7B,UAAU;EAcH,SAAS,MAAM,SAAS,SAAS,UAAU;EAK3C,QAAQ,gBAAgB,UAAU;EAK3C,KAAK,OAAO,YAAY,OAAO,OAAO,wBAAwB,aAAa,cAAc;EA0DzF,KAAK;;UAMG;EAIR,MAAM,OAAO,YAAY,OAAO,OAAO,wBAAwB;EAQ/D,QAAQ,eAAe,SAAS,SAAS,MAAM;;;;;;EAiB/C,OAAO,cAAc,gBAAgB,OAAO,uBAAuB,qBAAqB;;;;;;;UAqBhF;;UAsCA"}
+{"version":3,"file":"syntax.d.ts","names":[],"sources":["../../src/internal/syntax.ts"],"mappings":";;;;iBA4CiB;WACN,SAAS;WACT,MAAM;;;qBAIJ;WAEA;WACA;;WAEA,KAAK;WACL;;WAEA;WACA,UAAU,cAAc;;WAExB,SAAS;;WAET,QAAQ;WACR;;WAEA,OAAO;;WAEP;;WAEA,aAAa;EAlBb,YAAA,cACA;;EAEA,KAAK,iBACL;;EAEA,mBACA,UAAU,cAAc;;EAExB,SAAS;;EAET,QAAQ,+CACR;;EAEA,OAAO;;EAEP;;EAEA,aAAa;;;;;;;iBAST;;WAEN,SAAS;;WAET;;WAEA;WACA,cAAc;;;cAInB;WAEO,OAAO;WACP;WACA;EACF;EAHE,YAAA,OAAO,OACP,eACA,aACF;;qBAIE;;qBAMA,WAAY,GAAG,SAAS,kBAAgB;;;;;iBAuCpC;WACN;WACA;WACA;;;iBAIM;WACN,MAAM;WACN;WACA;WACA,UAAU,cAAc;WACxB,OAAO;;WAEP;WACA,UAAU;;;iBAIJ;EACf,KAAK,OAAO,YAAY,OAAO,OAAO,wBAAwB,KAAK,KAAK,cAAc;EACtF,MAAM,OAAO,YAAY,OAAO,OAAO,wBAAwB;;EAE/D,QAAQ,eAAe,SAAS,SAAS,MAAM;;;;;EAK/C,KAAK;;EAEL,MAAM;;EAEN,QAAQ,cAAc;;;;;;;;qBASX,yBAAyB;WAgBzB,OAAO;WACP,UAAU;;;;;;EAXrB;;WAES,OAAO,MAAM;;EAEtB;;EAEA,YAAY;EACZ;EAGW,YAAA,OAAO,YACP,UAAU;EAQrB,MAAM;EAIN,QAAQ,cAAc;;UAQd;EAIR,KAAK,OAAO,YAAY,OAAO,OAAO,wBAAwB,KAAK,KAAK,cAAc;EA0DtF,KAAK;;UAMG;EAIR,MAAM,OAAO,YAAY,OAAO,OAAO,wBAAwB;EAQ/D,QAAQ,eAAe,SAAS,SAAS,MAAM;;;;;;EAiB/C,OAAO,cAAc,gBAAgB,OAAO,uBAAuB,qBAAqB;;;;;;;UAqBhF;;UAsCA"}