@thomasfosterau/effect-parse 0.2.0 → 0.4.0

package/README.md

@@ -54,6 +54,7 @@ The package was developed as `effect-nom`. Releases and the changelog are manage
 - [Errors](#errors)
 - [Streaming and partial input](#streaming-and-partial-input)
 - [Services](#services)
+- [Parsers from schemas](#parsers-from-schemas)
 - [Unicode text and encodings](#unicode-text-and-encodings)
 - [Syntax trees and incremental parsing](#syntax-trees-and-incremental-parsing)
 - [Modules](#modules)
@@ -212,6 +213,7 @@ Repetition ranges follow winnow: `Parser.repeat(p)` matches zero or more times,
 | `Parser.parseRecoverable(p, input)` | `{ value: Option<A>, errors }` with error recovery enabled |
 | `ParserStream.parseMany(p)` | `Stream<I> => Stream<A>` (see [Streaming](#streaming-and-partial-input)) |
 | `ParserSchema.make(p)` | a `Schema` decoding strings with the parser |
+| `ParserSchema.fromSchema(s)` | a `Schema` decoding strings with the parser derived from `s`, and encoding with the derived printer (see [Parsers from schemas](#parsers-from-schemas)) |
 | `Syntax.parse(p, input)` | a `Syntax.Tree`: a syntax tree, the value and the errors (see [Syntax trees](#syntax-trees-and-incremental-parsing)) |
 
 Every `Parser` runner takes an `offset` option, to start parsing part-way into the input. The result is that of parsing `input.slice(offset)`, without the copy, and offsets (`Done`'s `offset`, spans, `ParseError` offsets, lines and columns) are positions in the whole input. A lexer can read one token at a time from a buffer, compiled parsers included:
@@ -378,6 +380,47 @@ Parser.parse(Parser.provideService(number, Radix, 16), "ff") // 255
 Parser.parseEffect(number, "777").pipe(Effect.provideService(Radix, 8)) // Effect<511>
 ```
 
+## Parsers from schemas
+
+`ParserSchema.toParser` derives a parser from an Effect `Schema`, and `ParserSchema.toPrinter` the printer that writes the same text, so a text format can be declared once, as the schema of the values it holds. Annotations, set with `ParserSchema.annotate` (under the key `ParserSchema.annotationKey`), say how each part is written: a `prefix` and `suffix`, the `separator` between fields, elements or entries, the `keySeparator` of `key=value` entries, whether `whitespace` may surround that text, or a `parser` and `print` that replace the derived ones.
+
+```ts
+import { Schema } from "effect"
+
+const Point = Schema.Struct({ x: Schema.Int, y: Schema.Int }).pipe(
+  ParserSchema.annotate({ prefix: "(", separator: ",", suffix: ")", whitespace: true })
+)
+
+const Config = Schema.Struct({
+  name: Schema.String,
+  origin: Point,
+  color: Schema.optionalKey(
+    Schema.Int.pipe(ParserSchema.annotate({ parser: Ascii.hexUint, print: (n) => n.toString(16), prefix: "#" }))
+  )
+}).pipe(ParserSchema.annotate({ separator: ";", keySeparator: "=" }))
+
+const config = ParserSchema.toParser(Config)
+Parser.parse(config, "origin=( 1, -2 );name=main;color=#ff")
+// Result.succeed({ name: "main", origin: { x: 1, y: -2 }, color: 255 })
+
+Parser.parse(config, "name=main;origin=(1,x)")
+// Result.fail(ParseError):
+//   Parse error at line 1, column 21:
+//   1 | name=main;origin=(1,x)
+//     |                     ^
+//   expected one of "+-" or digit, found "x"
+
+const print = ParserSchema.toPrinter(Config)
+print({ name: "main", origin: { x: 1, y: -2 }, color: 255 })
+// Result.succeed("name=main;origin=(1,-2);color=#ff")
+```
+
+Without annotations, a struct or tuple is its fields in order, an array its elements, a union its first member that parses, and a `suspend`ed schema recursion. A string runs to the next separator or suffix; a number is decimal, and an integer when the schema checks `isInt`. A record, or a struct with a `keySeparator`, is `key=value` entries in any order. A schema's checks and transformations (a `Class`, `NumberFromString`, a brand) run as `Schema.decode` runs them, and their failures are parse errors whose `cause` is the `SchemaError`. The doc comment of `toParser` lists every rule.
+
+A printer writes the text its parser reads, without optional whitespace, and fails with a `SchemaError` on a value it cannot write so that it reads back: a string holding the separator that would end it, or a part with a `parser` but no `print`.
+
+A derived parser is an ordinary parser: it composes with the combinators, and the [compilers](#compiled-parsers) compile it. `ParserSchema.fromSchema(schema)` wraps the parser and the printer as a `Schema` from `string`. Encoding parses the printed text back, and fails if that gives a different value, so decoding what it encoded always gives the value back, even where the grammar is ambiguous.
+
 ## Unicode text and encodings
 
 `Token` reads strings by code point, but the `Ascii` character classes and numbers only cover ASCII, and they treat bytes as ASCII. The `Text` module adds Unicode parsers that work with any encoding. `Text.make(encoding)` builds a set of parsers (`Text.TextParsers<I>`), and sets are provided for the common encodings:
@@ -480,7 +523,7 @@ On a 0.58 M-character JSON document (`vp run bench:syntax`), building the tree t
 | `Compiler` | `jit`, `closure`: [compiled parsers](#compiled-parsers) | — |
 | `ParseError` | the error type, `lineColumn`, `formatExpected` | `error` |
 | `ParserStream` | `parseMany`, `parseAll` over Effect `Stream`s | `Partial` / `streaming` |
-| `ParserSchema` | `make`: a `Schema` from a parser | — |
+| `ParserSchema` | `make`: a `Schema` from a parser; `toParser`, `toPrinter`, `fromSchema`, `annotate`: a parser and printer from an annotated `Schema` | — |
 | `Syntax` | syntax trees: `node`, `token`, `field`, `parse`, incremental `reparse` and `replace`, `Tree`, `SyntaxNode`, `TreeCursor` | — (Tree-sitter) |
 | `Nom` | nom names and argument orders (`tag`, `many0`, `separatedList1`, `mapRes`, …) | nom |
 | `Input` | input types and the `State` cursor for `Parser.make` | `stream` |

package/dist/Ascii.d.ts

@@ -2,7 +2,6 @@ import * as Result from "effect/Result";
 import { Input, Slice, State } from "./Input.js";
 import { Parser } from "./Parser.js";
 import { Encoding } from "./Encoding.js";
-//#region src/Ascii.d.ts
 /**
  * `[a-zA-Z]`
  *
@@ -366,6 +365,5 @@ export declare const bytes: {
   readonly hexUint: Parser<number, string, never, Uint8Array>;
   readonly float: Parser<number, never, never, Uint8Array>;
 };
-//#endregion
 export {};
 //# sourceMappingURL=Ascii.d.ts.map

package/dist/Ascii.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Ascii.d.ts","names":[],"sources":["../src/Ascii.ts"],"mappings":"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"}
+{"version":3,"file":"Ascii.d.ts","names":[],"sources":["../src/Ascii.ts"],"mappings":"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"}

package/dist/Ascii.js

@@ -3,11 +3,12 @@ import * as Result from "effect/Result";
 import { Fail } from "./Input.js";
 import * as P from "./Parser.js";
 import * as numbers from "./internal/numbers.js";
+import { Key } from "./internal/key.js";
 import * as Resume from "./internal/resume.js";
 import { codePointPredicate } from "./internal/tokens.js";
 import * as Token$1 from "./Token.js";
 import { literalImpl, range, takeWhileImpl } from "./Token.js";
-//#region src/Ascii.ts
+// src/Ascii.ts
 /**
 * Parsers for ASCII text: character classes, line endings, numbers and
 * escaped strings (winnow's `ascii` module, nom's `character` module).
@@ -417,7 +418,7 @@ const suspendAt = (state, key, start, checkpoint) => {
 const takeEscapedImpl = (normal, matchControl, escapable, slice, control, encoding) => {
 	const normalStep = normal.step;
 	const escStep = escapable.step;
-	const key = {};
+	const key = new Key();
 	return P.described((state) => {
 		const start = state.pos;
 		let resumed = false;
@@ -440,7 +441,7 @@ const takeEscapedImpl = (normal, matchControl, escapable, slice, control, encodi
 			}
 			if (state.mode === "Incomplete") return suspendAt(state, key, start, before);
 			if (state.mode !== "Backtrack") return Fail;
-			state.pos = before;
+			state.rewind(before);
 			if (matchControl(state)) {
 				if (escStep(state) === Fail) return isIncomplete(state) ? suspendAt(state, key, start, before) : Fail;
 			} else return Resume.done(state, key, start, resumed, slice(state, start));
@@ -499,7 +500,7 @@ const escaped = (normal, control, escape) => {
 const escapedImpl = (normal, matchControl, escape, control, encoding) => {
 	const normalStep = normal.step;
 	const escStep = escape.step;
-	const key = {};
+	const key = new Key();
 	return P.described((state) => {
 		const start = state.pos;
 		let out = "";
@@ -530,7 +531,7 @@ const escapedImpl = (normal, matchControl, escape, control, encoding) => {
 					pos: before
 				});
 				if (state.mode !== "Backtrack") return Fail;
-				state.pos = before;
+				state.rewind(before);
 			}
 			if (matchControl(state)) {
 				const b = escStep(state);
@@ -609,7 +610,6 @@ const bytes = /*#__PURE__*/ (() => {
 		float
 	};
 })();
-//#endregion
 export { alpha0, alpha1, alphanumeric0, alphanumeric1, bytes, caseless, crlf, decBigInt, decBigUint, decInt, decUint, digit0, digit1, escaped, escapedImpl, float, hexDigit0, hexDigit1, hexUint, isAlpha, isAlphanumeric, isDigit, isHexDigit, isMultispace, isNewline, isOctDigit, isSpace, lineEnding, multispace0, multispace1, newline, octDigit0, octDigit1, overflow, space0, space1, tab, takeEscaped, takeEscapedImpl, tillLineEnding, toFloat };
 
 //# sourceMappingURL=Ascii.js.map

package/dist/Ascii.js.map

@@ -1 +1 @@
-{"version":3,"file":"Ascii.js","names":["floatText","Token"],"sources":["../src/Ascii.ts"],"sourcesContent":["/**\n * Parsers for ASCII text: character classes, line endings, numbers and\n * escaped strings (winnow's `ascii` module, nom's `character` module).\n *\n * The parsers are typed for `string` input. Each also works on\n * `Uint8Array` input (treating bytes as ASCII), and `Ascii.bytes` gives the\n * same parsers typed for bytes:\n *\n * ```ts\n * import { Ascii, Parser } from \"@thomasfosterau/effect-parse\"\n *\n * Parser.parse(Ascii.decUint, \"42\")                              // 42\n * Parser.parse(Ascii.bytes.decUint, new TextEncoder().encode(\"42\")) // 42\n * ```\n *\n * Partial (streaming) input is supported: for example `digit1` on the\n * partial input `\"123\"` reports `Incomplete`, since more digits may follow.\n *\n * For Unicode character classes, or for text in other encodings (UTF-8,\n * UTF-16), use the `Text` module.\n *\n * @since 0.1.0\n */\nimport * as Predicate from \"effect/Predicate\"\nimport * as Result from \"effect/Result\"\nimport type { Encoding } from \"./Encoding.js\"\nimport type { Input, Slice, State } from \"./Input.js\"\nimport { Fail } from \"./Input.js\"\nimport type { ErrorKind } from \"./ParseError.js\"\nimport type { Parser } from \"./Parser.js\"\nimport * as P from \"./Parser.js\"\nimport * as numbers from \"./internal/numbers.js\"\nimport * as Resume from \"./internal/resume.js\"\nimport { codePointPredicate } from \"./internal/tokens.js\"\nimport { literalImpl, range, takeWhileImpl } from \"./Token.js\"\nimport * as Token from \"./Token.js\"\n\n// -----------------------------------------------------------------------------\n// Character predicates\n// -----------------------------------------------------------------------------\n\nconst code = (c: string | number): number => (Predicate.isNumber(c) ? c : c.charCodeAt(0))\n\n/**\n * `[a-zA-Z]`\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isAlpha: (c: string | number) => boolean = /*#__PURE__*/ codePointPredicate(\n  \"isAlpha\",\n  (c: string | number): boolean => {\n    const x = code(c)\n    return (x >= 65 && x <= 90) || (x >= 97 && x <= 122)\n  },\n  [\n    [65, 90],\n    [97, 122]\n  ]\n)\n\n/**\n * `[0-9]`\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isDigit: (c: string | number) => boolean = /*#__PURE__*/ codePointPredicate(\n  \"isDigit\",\n  (c: string | number): boolean => {\n    const x = code(c)\n    return x >= 48 && x <= 57\n  },\n  [[48, 57]]\n)\n\n/**\n * `[0-9a-fA-F]`\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isHexDigit: (c: string | number) => boolean = /*#__PURE__*/ codePointPredicate(\n  \"isHexDigit\",\n  (c: string | number): boolean => {\n    const x = code(c)\n    return (x >= 48 && x <= 57) || (x >= 65 && x <= 70) || (x >= 97 && x <= 102)\n  },\n  [\n    [48, 57],\n    [65, 70],\n    [97, 102]\n  ]\n)\n\n/**\n * `[0-7]`\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isOctDigit: (c: string | number) => boolean = /*#__PURE__*/ codePointPredicate(\n  \"isOctDigit\",\n  (c: string | number): boolean => {\n    const x = code(c)\n    return x >= 48 && x <= 55\n  },\n  [[48, 55]]\n)\n\n/**\n * `[0-9a-zA-Z]`\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isAlphanumeric: (c: string | number) => boolean = /*#__PURE__*/ codePointPredicate(\n  \"isAlphanumeric\",\n  (c: string | number): boolean => isAlpha(c) || isDigit(c),\n  [\n    [48, 57],\n    [65, 90],\n    [97, 122]\n  ]\n)\n\n/**\n * `[ \\t]`\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isSpace: (c: string | number) => boolean = /*#__PURE__*/ codePointPredicate(\n  \"isSpace\",\n  (c: string | number): boolean => {\n    const x = code(c)\n    return x === 32 || x === 9\n  },\n  [\n    [9, 9],\n    [32, 32]\n  ]\n)\n\n/**\n * `[ \\t\\r\\n]`\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isMultispace: (c: string | number) => boolean = /*#__PURE__*/ codePointPredicate(\n  \"isMultispace\",\n  (c: string | number): boolean => {\n    const x = code(c)\n    return x === 32 || x === 9 || x === 10 || x === 13\n  },\n  [\n    [9, 10],\n    [13, 13],\n    [32, 32]\n  ]\n)\n\n/**\n * `\\n`\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isNewline: (c: string | number) => boolean = /*#__PURE__*/ codePointPredicate(\n  \"isNewline\",\n  (c: string | number): boolean => code(c) === 10,\n  [[10, 10]]\n)\n\n// Token sets usable for both string and byte input\nconst alphaSet = [/*#__PURE__*/ range(\"a\", \"z\"), /*#__PURE__*/ range(\"A\", \"Z\")]\nconst digitSet = /*#__PURE__*/ range(\"0\", \"9\")\nconst hexSet = [/*#__PURE__*/ range(\"0\", \"9\"), /*#__PURE__*/ range(\"a\", \"f\"), /*#__PURE__*/ range(\"A\", \"F\")]\nconst octSet = /*#__PURE__*/ range(\"0\", \"7\")\nconst alnumSet = [/*#__PURE__*/ range(\"a\", \"z\"), /*#__PURE__*/ range(\"A\", \"Z\"), /*#__PURE__*/ range(\"0\", \"9\")]\nconst spaceSet = \" \\t\"\nconst multispaceSet = \" \\t\\r\\n\"\n\nconst cls = (set: unknown, min: 0 | 1, description: string, kind: ErrorKind, hint = true): Parser<string> =>\n  takeWhileImpl<string>(set, { min }, false, `${kind.toLowerCase()}${min}`, description, kind, hint)\n\n// -----------------------------------------------------------------------------\n// Character classes\n// -----------------------------------------------------------------------------\n\n/**\n * Zero or more ASCII letters, `[a-zA-Z]*`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const alpha0: Parser<string> = /*#__PURE__*/ cls(alphaSet, 0, \"letter\", \"Alpha\")\n\n/**\n * One or more ASCII letters, `[a-zA-Z]+`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const alpha1: Parser<string> = /*#__PURE__*/ cls(alphaSet, 1, \"letter\", \"Alpha\")\n\n/**\n * Zero or more ASCII digits, `[0-9]*`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const digit0: Parser<string> = /*#__PURE__*/ cls(digitSet, 0, \"digit\", \"Digit\")\n\n/**\n * One or more ASCII digits, `[0-9]+`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const digit1: Parser<string> = /*#__PURE__*/ cls(digitSet, 1, \"digit\", \"Digit\")\n\n/**\n * Zero or more hexadecimal digits, `[0-9a-fA-F]*`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const hexDigit0: Parser<string> = /*#__PURE__*/ cls(hexSet, 0, \"hexadecimal digit\", \"HexDigit\")\n\n/**\n * One or more hexadecimal digits, `[0-9a-fA-F]+`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const hexDigit1: Parser<string> = /*#__PURE__*/ cls(hexSet, 1, \"hexadecimal digit\", \"HexDigit\")\n\n/**\n * Zero or more octal digits, `[0-7]*`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const octDigit0: Parser<string> = /*#__PURE__*/ cls(octSet, 0, \"octal digit\", \"OctDigit\")\n\n/**\n * One or more octal digits, `[0-7]+`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const octDigit1: Parser<string> = /*#__PURE__*/ cls(octSet, 1, \"octal digit\", \"OctDigit\")\n\n/**\n * Zero or more ASCII letters or digits, `[0-9a-zA-Z]*`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const alphanumeric0: Parser<string> = /*#__PURE__*/ cls(alnumSet, 0, \"letter or digit\", \"AlphaNumeric\")\n\n/**\n * One or more ASCII letters or digits, `[0-9a-zA-Z]+`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const alphanumeric1: Parser<string> = /*#__PURE__*/ cls(alnumSet, 1, \"letter or digit\", \"AlphaNumeric\")\n\n/**\n * Zero or more spaces and tabs, `[ \\t]*`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const space0: Parser<string> = /*#__PURE__*/ cls(spaceSet, 0, \"space\", \"Space\", false)\n\n/**\n * One or more spaces and tabs, `[ \\t]+`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const space1: Parser<string> = /*#__PURE__*/ cls(spaceSet, 1, \"space\", \"Space\", false)\n\n/**\n * Zero or more spaces, tabs, carriage returns and line feeds,\n * `[ \\t\\r\\n]*`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const multispace0: Parser<string> = /*#__PURE__*/ cls(multispaceSet, 0, \"whitespace\", \"MultiSpace\", false)\n\n/**\n * One or more spaces, tabs, carriage returns and line feeds,\n * `[ \\t\\r\\n]+`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const multispace1: Parser<string> = /*#__PURE__*/ cls(multispaceSet, 1, \"whitespace\", \"MultiSpace\", false)\n\n// -----------------------------------------------------------------------------\n// Line endings\n// -----------------------------------------------------------------------------\n\n/**\n * A carriage return followed by a line feed, `\\r\\n`.\n *\n * @since 0.1.0\n * @category line endings\n */\nexport const crlf: Parser<\"\\r\\n\"> = /*#__PURE__*/ Token.literal(\"\\r\\n\")\n\n/**\n * A line feed, `\\n` (nom's `newline`).\n *\n * @since 0.1.0\n * @category line endings\n */\nexport const newline: Parser<\"\\n\"> = /*#__PURE__*/ Token.literal(\"\\n\")\n\n/**\n * A tab, `\\t`.\n *\n * @since 0.1.0\n * @category line endings\n */\nexport const tab: Parser<\"\\t\"> = /*#__PURE__*/ Token.literal(\"\\t\")\n\n/**\n * A line ending: `\\n` or `\\r\\n`.\n *\n * @since 0.1.0\n * @category line endings\n */\nexport const lineEnding: Parser<\"\\n\" | \"\\r\\n\"> = /*#__PURE__*/ P.alt(newline, crlf).pipe(\n  /*#__PURE__*/ P.expected(\"line ending\")\n)\n\nconst expectedLineEnding = [\"line ending\"]\n\n/**\n * Everything up to (not including) a line ending, `[^\\r\\n]*` (winnow's\n * `till_line_ending`, nom's `not_line_ending`). A carriage return that is\n * not followed by a line feed is an error.\n *\n * @since 0.1.0\n * @category line endings\n */\nexport const tillLineEnding: Parser<string> = /*#__PURE__*/ P.described<string>(\n  (state: State<any>) => {\n    const start = state.pos\n    const input = state.input\n    const isString = state.inputKind === 0\n    let i = start\n    while (i < state.end) {\n      const c = isString ? (input as string).charCodeAt(i) : (input as Uint8Array)[i]\n      if (c === 10) break\n      if (c === 13) {\n        // The line feed after it is read, not consumed\n        state.syntax?.read(i + 2)\n        if (i + 1 >= state.end) {\n          if (state.partial) return state.incomplete(1, expectedLineEnding)\n          return state.backtrack(\"LineEnding\", expectedLineEnding, i)\n        }\n        const d = isString ? (input as string).charCodeAt(i + 1) : (input as Uint8Array)[i + 1]\n        if (d === 10) break\n        return state.backtrack(\"LineEnding\", expectedLineEnding, i)\n      }\n      i++\n    }\n    if (i >= state.end && state.partial) return state.incomplete(1, expectedLineEnding)\n    state.pos = i\n    return state.slice(start, i) as string\n  },\n  \"tillLineEnding\",\n  { _tag: \"TillLineEnding\", encoding: undefined }\n)\n\n// -----------------------------------------------------------------------------\n// Numbers\n// -----------------------------------------------------------------------------\n\n/** @internal */\nexport const overflow = (value: number): Result.Result<number, string> =>\n  Number.isSafeInteger(value) ? Result.succeed(value) : Result.fail(\"integer overflow\")\n\n/**\n * An unsigned decimal integer: one or more digits (winnow's `dec_uint`,\n * nom's `u32`/`u64`). Fails if the value is not a safe integer.\n *\n * @since 0.1.0\n * @category numbers\n */\nexport const decUint: Parser<number, string> = /*#__PURE__*/ digit1.pipe(\n  /*#__PURE__*/ P.tryMap((s) => overflow(Number(numbers.toText(s)))),\n  /*#__PURE__*/ P.named(\"decUint\")\n)\n\n/**\n * A signed decimal integer: an optional `+` or `-` followed by one or more\n * digits (winnow's `dec_int`, nom's `i32`/`i64`). Fails if the value is not\n * a safe integer.\n *\n * @since 0.1.0\n * @category numbers\n */\nexport const decInt: Parser<number, string> = /*#__PURE__*/ P.taken(\n  /*#__PURE__*/ P.seq(/*#__PURE__*/ P.opt(/*#__PURE__*/ Token.oneOf(\"+-\")), digit1)\n).pipe(\n  /*#__PURE__*/ P.tryMap((s) => overflow(Number(numbers.toText(s)))),\n  /*#__PURE__*/ P.named(\"decInt\")\n)\n\n/**\n * An unsigned decimal integer as a `bigint`, of any size.\n *\n * @since 0.1.0\n * @category numbers\n */\nexport const decBigUint: Parser<bigint> = /*#__PURE__*/ digit1.pipe(\n  /*#__PURE__*/ P.map((s) => BigInt(numbers.toText(s)))\n)\n\n/**\n * A signed decimal integer as a `bigint`, of any size.\n *\n * @since 0.1.0\n * @category numbers\n */\nexport const decBigInt: Parser<bigint> = /*#__PURE__*/ P.taken(\n  /*#__PURE__*/ P.seq(/*#__PURE__*/ P.opt(/*#__PURE__*/ Token.oneOf(\"+-\")), digit1)\n).pipe(\n  /*#__PURE__*/ P.map((s) => {\n    const t = numbers.toText(s)\n    return BigInt(t.startsWith(\"+\") ? t.slice(1) : t)\n  })\n)\n\n/**\n * A hexadecimal unsigned integer, without prefix (winnow's `hex_uint`, nom's\n * `hex_u32`). Fails if the value is not a safe integer.\n *\n * @since 0.1.0\n * @category numbers\n */\nexport const hexUint: Parser<number, string> = /*#__PURE__*/ hexDigit1.pipe(\n  /*#__PURE__*/ P.tryMap((s) => overflow(parseInt(numbers.toText(s), 16))),\n  /*#__PURE__*/ P.named(\"hexUint\")\n)\n\nconst sign = /*#__PURE__*/ P.opt(/*#__PURE__*/ Token.oneOf(\"+-\"))\nconst exponent = /*#__PURE__*/ P.opt(/*#__PURE__*/ P.seq(/*#__PURE__*/ Token.oneOf(\"eE\"), sign, digit1))\nconst unsignedFloat = /*#__PURE__*/ P.alt(\n  /*#__PURE__*/ P.seq(\n    /*#__PURE__*/ literalImpl(\"inf\", true),\n    /*#__PURE__*/ P.opt(/*#__PURE__*/ literalImpl(\"inity\", true))\n  ),\n  /*#__PURE__*/ P.seq(/*#__PURE__*/ Token.literal(\".\"), digit1, exponent),\n  /*#__PURE__*/ P.seq(\n    digit1,\n    /*#__PURE__*/ P.opt(/*#__PURE__*/ P.seq(/*#__PURE__*/ Token.literal(\".\"), /*#__PURE__*/ P.opt(digit1))),\n    exponent\n  )\n)\nconst floatText = /*#__PURE__*/ numbers.floatText(\n  /*#__PURE__*/ P.taken(\n    /*#__PURE__*/ P.alt(/*#__PURE__*/ literalImpl(\"nan\", true), /*#__PURE__*/ P.seq(sign, unsignedFloat))\n  ).pipe(/*#__PURE__*/ P.expected(\"number\")) as Parser<string>\n)\n\n/** @internal */\nexport const toFloat: (s: Input) => number = numbers.toFloat\n\n/**\n * A floating point number in decimal or scientific notation, including\n * `inf`, `infinity` and `nan` (case insensitive), as accepted by winnow's\n * `float` and nom's `double`.\n *\n * @example\n * ```ts\n * import { Ascii, Parser } from \"@thomasfosterau/effect-parse\"\n *\n * Parser.parse(Ascii.float, \"-1.5e3\") // Result.succeed(-1500)\n * ```\n *\n * @since 0.1.0\n * @category numbers\n */\nexport const float: Parser<number> = /*#__PURE__*/ floatText.pipe(\n  /*#__PURE__*/ P.map(toFloat),\n  /*#__PURE__*/ P.named(\"float\")\n)\n\n// -----------------------------------------------------------------------------\n// Literals\n// -----------------------------------------------------------------------------\n\n/**\n * Matches a literal ignoring ASCII case (winnow's `Caseless`, nom's\n * `tag_no_case`). Returns the input as written.\n *\n * @since 0.1.0\n * @category literals\n */\nexport const caseless: {\n  (literal: string): Parser<string>\n  (literal: Uint8Array): Parser<Uint8Array, never, never, Uint8Array>\n} = (lit: string | Uint8Array): any => literalImpl(lit, true)\n\n// -----------------------------------------------------------------------------\n// Escapes\n// -----------------------------------------------------------------------------\n\nconst controlCode = (c: string | number): number => (Predicate.isNumber(c) ? c : c.charCodeAt(0))\n\nconst atControl = (state: State<Input>, control: number): boolean => {\n  if (state.pos >= state.end) return false\n  const input = state.input\n  const c = state.inputKind === 0 ? (input as string).charCodeAt(state.pos) : (input as Uint8Array)[state.pos]\n  return c === control\n}\n\n/**\n * Recognizes a string containing escape sequences, returning the raw slice\n * (winnow's `take_escaped`, nom's `escaped`).\n *\n * - `normal` matches runs of ordinary characters (it must consume input)\n * - `control` is the escape character, e.g. `\"\\\\\"`\n * - `escapable` matches what may follow the control character\n *\n * @example\n * ```ts\n * import { Ascii, Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const raw = Ascii.takeEscaped(Ascii.alpha1, \"\\\\\", Token.oneOf(\"\\\"n\\\\\"))\n * Parser.parse(raw, \"ab\\\\\\\"cd\") // Result.succeed(\"ab\\\\\\\"cd\")\n * ```\n *\n * @since 0.1.0\n * @category escapes\n */\nexport const takeEscaped = <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(\n  normal: Parser<A, E, R, I>,\n  control: string | number,\n  escapable: Parser<B, E2, R2, I2>\n): Parser<Slice<I & I2>, E | E2, R | R2, I & I2> => {\n  const ctrl = controlCode(control)\n  return takeEscapedImpl(\n    normal,\n    (state) => {\n      if (!atControl(state, ctrl)) return false\n      state.pos++\n      return true\n    },\n    escapable,\n    (state, start) => state.slice(start, state.pos) as Slice<I & I2>,\n    ctrl,\n    undefined\n  )\n}\n\nconst isIncomplete = (state: State<any>): boolean => state.mode === \"Incomplete\"\n\n/**\n * Fails with the current (`Incomplete`) failure, recording a checkpoint\n * first in a streaming parse.\n */\nconst suspendAt = (state: State<any>, key: object, start: number, checkpoint: unknown): Fail => {\n  if (state.resume !== undefined) Resume.save(state, key, start, checkpoint)\n  return Fail\n}\n\n/** @internal */\nexport const takeEscapedImpl = <A, E, R, I extends Input, B, E2, R2, I2 extends Input, S>(\n  normal: Parser<A, E, R, I>,\n  matchControl: (state: State<any>) => boolean,\n  escapable: Parser<B, E2, R2, I2>,\n  slice: (state: State<any>, start: number) => S,\n  control: number,\n  encoding: Encoding<any> | undefined\n): Parser<S, E | E2, R | R2, I & I2> => {\n  const normalStep = normal.step\n  const escStep = escapable.step\n  const key = {}\n  return P.described(\n    (state: State<any>) => {\n      const start = state.pos\n      let resumed = false\n      if (state.resume !== undefined) {\n        const checkpoint = Resume.take(state, key, start) as number | Resume.Done | undefined\n        if (checkpoint instanceof Resume.Done) {\n          state.pos = checkpoint.pos\n          return checkpoint.value as S\n        }\n        if (checkpoint !== undefined) {\n          state.pos = checkpoint\n          resumed = true\n        }\n      }\n      while (state.pos < state.end) {\n        const before = state.pos\n        const a = normalStep(state)\n        if (a !== Fail) {\n          if (state.pos === before)\n            return state.failMessage(\"Cut\", \"Assert\", \"`takeEscaped` parsers must always consume\")\n          continue\n        }\n        if (state.mode === \"Incomplete\") return suspendAt(state, key, start, before)\n        if (state.mode !== \"Backtrack\") return Fail\n        state.pos = before\n        if (matchControl(state)) {\n          if (escStep(state) === Fail) return isIncomplete(state) ? suspendAt(state, key, start, before) : Fail\n        } else {\n          return Resume.done(state, key, start, resumed, slice(state, start))\n        }\n      }\n      if (state.partial) {\n        state.incomplete(0)\n        return suspendAt(state, key, start, state.pos)\n      }\n      return Resume.done(state, key, start, resumed, slice(state, start))\n    },\n    \"takeEscaped\",\n    { _tag: \"Escaped\", normal, control, escape: escapable, raw: true, encoding }\n  )\n}\n\n/**\n * Parses a string containing escape sequences, returning the *unescaped*\n * string (winnow's `escaped`, nom's `escaped_transform`).\n *\n * - `normal` matches runs of ordinary characters, returning them\n * - `control` is the escape character, e.g. `\"\\\\\"`\n * - `escape` parses what follows the control character, returning its\n *   replacement\n *\n * @example\n * ```ts\n * import { Ascii, Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const unescaped = Ascii.escaped(\n *   Token.takeTill(\"\\\\\\\"\"),\n *   \"\\\\\",\n *   Parser.alt(\n *     Token.literal(\"n\").pipe(Parser.as(\"\\n\")),\n *     Token.literal(\"\\\\\"),\n *     Token.literal(\"\\\"\")\n *   )\n * )\n * Parser.parse(unescaped, \"a\\\\nb\") // Result.succeed(\"a\\nb\")\n * ```\n *\n * @since 0.1.0\n * @category escapes\n */\nexport const escaped = <E, R, I extends Input, E2, R2, I2 extends Input>(\n  normal: Parser<string, E, R, I>,\n  control: string | number,\n  escape: Parser<string, E2, R2, I2>\n): Parser<string, E | E2, R | R2, I & I2> => {\n  const ctrl = controlCode(control)\n  return escapedImpl(\n    normal,\n    (state) => {\n      if (!atControl(state, ctrl)) return false\n      state.pos++\n      return true\n    },\n    escape,\n    ctrl,\n    undefined\n  )\n}\n\n/** How far `escaped` got: the text so far, and where to carry on. */\ninterface EscapedCheckpoint {\n  readonly out: string\n  readonly pos: number\n}\n\n/** @internal */\nexport const escapedImpl = <E, R, I extends Input, E2, R2, I2 extends Input>(\n  normal: Parser<string, E, R, I>,\n  matchControl: (state: State<any>) => boolean,\n  escape: Parser<string, E2, R2, I2>,\n  control: number,\n  encoding: Encoding<any> | undefined\n): Parser<string, E | E2, R | R2, I & I2> => {\n  const normalStep = normal.step\n  const escStep = escape.step\n  const key = {}\n  return P.described(\n    (state: State<any>) => {\n      const start = state.pos\n      let out = \"\"\n      let resumed = false\n      if (state.resume !== undefined) {\n        const checkpoint = Resume.take(state, key, start) as EscapedCheckpoint | Resume.Done | undefined\n        if (checkpoint instanceof Resume.Done) {\n          state.pos = checkpoint.pos\n          return checkpoint.value as string\n        }\n        if (checkpoint !== undefined) {\n          out = checkpoint.out\n          state.pos = checkpoint.pos\n          resumed = true\n        }\n      }\n      while (state.pos < state.end) {\n        const before = state.pos\n        const a = normalStep(state)\n        if (a !== Fail) {\n          if (state.pos !== before) {\n            out += a\n            continue\n          }\n          // `normal` matched nothing: fall through to the control character\n        } else {\n          if (state.mode === \"Incomplete\") return suspendAt(state, key, start, { out, pos: before })\n          if (state.mode !== \"Backtrack\") return Fail\n          state.pos = before\n        }\n        if (matchControl(state)) {\n          const b = escStep(state)\n          if (b === Fail) return isIncomplete(state) ? suspendAt(state, key, start, { out, pos: before }) : Fail\n          out += b\n        } else {\n          return Resume.done(state, key, start, resumed, out)\n        }\n      }\n      if (state.partial) {\n        state.incomplete(0)\n        return suspendAt(state, key, start, { out, pos: state.pos })\n      }\n      return Resume.done(state, key, start, resumed, out)\n    },\n    \"escaped\",\n    { _tag: \"Escaped\", normal, control, escape, raw: false, encoding }\n  )\n}\n\n// -----------------------------------------------------------------------------\n// Byte views\n// -----------------------------------------------------------------------------\n\ntype Bytes<P> =\n  P extends Parser<infer A, infer E, infer R, infer _I>\n    ? Parser<A extends string ? Uint8Array : A, E, R, Uint8Array>\n    : never\n\n/**\n * The parsers of this module, typed for `Uint8Array` input. Slices are\n * returned as `Uint8Array`s.\n *\n * @example\n * ```ts\n * import { Ascii, Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const encode = (s: string) => new TextEncoder().encode(s)\n * const header = Parser.separatedPair(\n *   Ascii.bytes.alpha1,\n *   Token.literal(encode(\": \")),\n *   Ascii.bytes.tillLineEnding\n * )\n * ```\n *\n * @since 0.1.0\n * @category byte views\n */\nexport const bytes: {\n  readonly alpha0: Bytes<typeof alpha0>\n  readonly alpha1: Bytes<typeof alpha1>\n  readonly digit0: Bytes<typeof digit0>\n  readonly digit1: Bytes<typeof digit1>\n  readonly hexDigit0: Bytes<typeof hexDigit0>\n  readonly hexDigit1: Bytes<typeof hexDigit1>\n  readonly octDigit0: Bytes<typeof octDigit0>\n  readonly octDigit1: Bytes<typeof octDigit1>\n  readonly alphanumeric0: Bytes<typeof alphanumeric0>\n  readonly alphanumeric1: Bytes<typeof alphanumeric1>\n  readonly space0: Bytes<typeof space0>\n  readonly space1: Bytes<typeof space1>\n  readonly multispace0: Bytes<typeof multispace0>\n  readonly multispace1: Bytes<typeof multispace1>\n  readonly crlf: Parser<Uint8Array, never, never, Uint8Array>\n  readonly newline: Parser<Uint8Array, never, never, Uint8Array>\n  readonly tab: Parser<Uint8Array, never, never, Uint8Array>\n  readonly lineEnding: Parser<Uint8Array, never, never, Uint8Array>\n  readonly tillLineEnding: Bytes<typeof tillLineEnding>\n  readonly decUint: Parser<number, string, never, Uint8Array>\n  readonly decInt: Parser<number, string, never, Uint8Array>\n  readonly decBigUint: Parser<bigint, never, never, Uint8Array>\n  readonly decBigInt: Parser<bigint, never, never, Uint8Array>\n  readonly hexUint: Parser<number, string, never, Uint8Array>\n  readonly float: Parser<number, never, never, Uint8Array>\n} = /*#__PURE__*/ (() => {\n  const lit = (s: string) => Token.literal(new TextEncoder().encode(s))\n  const crlfB = lit(\"\\r\\n\")\n  const newlineB = lit(\"\\n\")\n  return {\n    alpha0,\n    alpha1,\n    digit0,\n    digit1,\n    hexDigit0,\n    hexDigit1,\n    octDigit0,\n    octDigit1,\n    alphanumeric0,\n    alphanumeric1,\n    space0,\n    space1,\n    multispace0,\n    multispace1,\n    crlf: crlfB,\n    newline: newlineB,\n    tab: lit(\"\\t\"),\n    lineEnding: P.alt(newlineB, crlfB).pipe(P.expected(\"line ending\")),\n    tillLineEnding,\n    decUint,\n    decInt,\n    decBigUint,\n    decBigInt,\n    hexUint,\n    float\n  } as any\n})()\n"],"mappings":"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"}
+{"version":3,"file":"Ascii.js","names":["floatText","Token"],"sources":["../src/Ascii.ts"],"sourcesContent":["/**\n * Parsers for ASCII text: character classes, line endings, numbers and\n * escaped strings (winnow's `ascii` module, nom's `character` module).\n *\n * The parsers are typed for `string` input. Each also works on\n * `Uint8Array` input (treating bytes as ASCII), and `Ascii.bytes` gives the\n * same parsers typed for bytes:\n *\n * ```ts\n * import { Ascii, Parser } from \"@thomasfosterau/effect-parse\"\n *\n * Parser.parse(Ascii.decUint, \"42\")                              // 42\n * Parser.parse(Ascii.bytes.decUint, new TextEncoder().encode(\"42\")) // 42\n * ```\n *\n * Partial (streaming) input is supported: for example `digit1` on the\n * partial input `\"123\"` reports `Incomplete`, since more digits may follow.\n *\n * For Unicode character classes, or for text in other encodings (UTF-8,\n * UTF-16), use the `Text` module.\n *\n * @since 0.1.0\n */\nimport * as Predicate from \"effect/Predicate\"\nimport * as Result from \"effect/Result\"\nimport type { Encoding } from \"./Encoding.js\"\nimport type { Input, Slice, State } from \"./Input.js\"\nimport { Fail } from \"./Input.js\"\nimport type { ErrorKind } from \"./ParseError.js\"\nimport type { Parser } from \"./Parser.js\"\nimport * as P from \"./Parser.js\"\nimport * as numbers from \"./internal/numbers.js\"\nimport { Key } from \"./internal/key.js\"\nimport * as Resume from \"./internal/resume.js\"\nimport { codePointPredicate } from \"./internal/tokens.js\"\nimport { literalImpl, range, takeWhileImpl } from \"./Token.js\"\nimport * as Token from \"./Token.js\"\n\n// -----------------------------------------------------------------------------\n// Character predicates\n// -----------------------------------------------------------------------------\n\nconst code = (c: string | number): number => (Predicate.isNumber(c) ? c : c.charCodeAt(0))\n\n/**\n * `[a-zA-Z]`\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isAlpha: (c: string | number) => boolean = /*#__PURE__*/ codePointPredicate(\n  \"isAlpha\",\n  (c: string | number): boolean => {\n    const x = code(c)\n    return (x >= 65 && x <= 90) || (x >= 97 && x <= 122)\n  },\n  [\n    [65, 90],\n    [97, 122]\n  ]\n)\n\n/**\n * `[0-9]`\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isDigit: (c: string | number) => boolean = /*#__PURE__*/ codePointPredicate(\n  \"isDigit\",\n  (c: string | number): boolean => {\n    const x = code(c)\n    return x >= 48 && x <= 57\n  },\n  [[48, 57]]\n)\n\n/**\n * `[0-9a-fA-F]`\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isHexDigit: (c: string | number) => boolean = /*#__PURE__*/ codePointPredicate(\n  \"isHexDigit\",\n  (c: string | number): boolean => {\n    const x = code(c)\n    return (x >= 48 && x <= 57) || (x >= 65 && x <= 70) || (x >= 97 && x <= 102)\n  },\n  [\n    [48, 57],\n    [65, 70],\n    [97, 102]\n  ]\n)\n\n/**\n * `[0-7]`\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isOctDigit: (c: string | number) => boolean = /*#__PURE__*/ codePointPredicate(\n  \"isOctDigit\",\n  (c: string | number): boolean => {\n    const x = code(c)\n    return x >= 48 && x <= 55\n  },\n  [[48, 55]]\n)\n\n/**\n * `[0-9a-zA-Z]`\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isAlphanumeric: (c: string | number) => boolean = /*#__PURE__*/ codePointPredicate(\n  \"isAlphanumeric\",\n  (c: string | number): boolean => isAlpha(c) || isDigit(c),\n  [\n    [48, 57],\n    [65, 90],\n    [97, 122]\n  ]\n)\n\n/**\n * `[ \\t]`\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isSpace: (c: string | number) => boolean = /*#__PURE__*/ codePointPredicate(\n  \"isSpace\",\n  (c: string | number): boolean => {\n    const x = code(c)\n    return x === 32 || x === 9\n  },\n  [\n    [9, 9],\n    [32, 32]\n  ]\n)\n\n/**\n * `[ \\t\\r\\n]`\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isMultispace: (c: string | number) => boolean = /*#__PURE__*/ codePointPredicate(\n  \"isMultispace\",\n  (c: string | number): boolean => {\n    const x = code(c)\n    return x === 32 || x === 9 || x === 10 || x === 13\n  },\n  [\n    [9, 10],\n    [13, 13],\n    [32, 32]\n  ]\n)\n\n/**\n * `\\n`\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isNewline: (c: string | number) => boolean = /*#__PURE__*/ codePointPredicate(\n  \"isNewline\",\n  (c: string | number): boolean => code(c) === 10,\n  [[10, 10]]\n)\n\n// Token sets usable for both string and byte input\nconst alphaSet = [/*#__PURE__*/ range(\"a\", \"z\"), /*#__PURE__*/ range(\"A\", \"Z\")]\nconst digitSet = /*#__PURE__*/ range(\"0\", \"9\")\nconst hexSet = [/*#__PURE__*/ range(\"0\", \"9\"), /*#__PURE__*/ range(\"a\", \"f\"), /*#__PURE__*/ range(\"A\", \"F\")]\nconst octSet = /*#__PURE__*/ range(\"0\", \"7\")\nconst alnumSet = [/*#__PURE__*/ range(\"a\", \"z\"), /*#__PURE__*/ range(\"A\", \"Z\"), /*#__PURE__*/ range(\"0\", \"9\")]\nconst spaceSet = \" \\t\"\nconst multispaceSet = \" \\t\\r\\n\"\n\nconst cls = (set: unknown, min: 0 | 1, description: string, kind: ErrorKind, hint = true): Parser<string> =>\n  takeWhileImpl<string>(set, { min }, false, `${kind.toLowerCase()}${min}`, description, kind, hint)\n\n// -----------------------------------------------------------------------------\n// Character classes\n// -----------------------------------------------------------------------------\n\n/**\n * Zero or more ASCII letters, `[a-zA-Z]*`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const alpha0: Parser<string> = /*#__PURE__*/ cls(alphaSet, 0, \"letter\", \"Alpha\")\n\n/**\n * One or more ASCII letters, `[a-zA-Z]+`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const alpha1: Parser<string> = /*#__PURE__*/ cls(alphaSet, 1, \"letter\", \"Alpha\")\n\n/**\n * Zero or more ASCII digits, `[0-9]*`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const digit0: Parser<string> = /*#__PURE__*/ cls(digitSet, 0, \"digit\", \"Digit\")\n\n/**\n * One or more ASCII digits, `[0-9]+`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const digit1: Parser<string> = /*#__PURE__*/ cls(digitSet, 1, \"digit\", \"Digit\")\n\n/**\n * Zero or more hexadecimal digits, `[0-9a-fA-F]*`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const hexDigit0: Parser<string> = /*#__PURE__*/ cls(hexSet, 0, \"hexadecimal digit\", \"HexDigit\")\n\n/**\n * One or more hexadecimal digits, `[0-9a-fA-F]+`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const hexDigit1: Parser<string> = /*#__PURE__*/ cls(hexSet, 1, \"hexadecimal digit\", \"HexDigit\")\n\n/**\n * Zero or more octal digits, `[0-7]*`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const octDigit0: Parser<string> = /*#__PURE__*/ cls(octSet, 0, \"octal digit\", \"OctDigit\")\n\n/**\n * One or more octal digits, `[0-7]+`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const octDigit1: Parser<string> = /*#__PURE__*/ cls(octSet, 1, \"octal digit\", \"OctDigit\")\n\n/**\n * Zero or more ASCII letters or digits, `[0-9a-zA-Z]*`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const alphanumeric0: Parser<string> = /*#__PURE__*/ cls(alnumSet, 0, \"letter or digit\", \"AlphaNumeric\")\n\n/**\n * One or more ASCII letters or digits, `[0-9a-zA-Z]+`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const alphanumeric1: Parser<string> = /*#__PURE__*/ cls(alnumSet, 1, \"letter or digit\", \"AlphaNumeric\")\n\n/**\n * Zero or more spaces and tabs, `[ \\t]*`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const space0: Parser<string> = /*#__PURE__*/ cls(spaceSet, 0, \"space\", \"Space\", false)\n\n/**\n * One or more spaces and tabs, `[ \\t]+`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const space1: Parser<string> = /*#__PURE__*/ cls(spaceSet, 1, \"space\", \"Space\", false)\n\n/**\n * Zero or more spaces, tabs, carriage returns and line feeds,\n * `[ \\t\\r\\n]*`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const multispace0: Parser<string> = /*#__PURE__*/ cls(multispaceSet, 0, \"whitespace\", \"MultiSpace\", false)\n\n/**\n * One or more spaces, tabs, carriage returns and line feeds,\n * `[ \\t\\r\\n]+`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const multispace1: Parser<string> = /*#__PURE__*/ cls(multispaceSet, 1, \"whitespace\", \"MultiSpace\", false)\n\n// -----------------------------------------------------------------------------\n// Line endings\n// -----------------------------------------------------------------------------\n\n/**\n * A carriage return followed by a line feed, `\\r\\n`.\n *\n * @since 0.1.0\n * @category line endings\n */\nexport const crlf: Parser<\"\\r\\n\"> = /*#__PURE__*/ Token.literal(\"\\r\\n\")\n\n/**\n * A line feed, `\\n` (nom's `newline`).\n *\n * @since 0.1.0\n * @category line endings\n */\nexport const newline: Parser<\"\\n\"> = /*#__PURE__*/ Token.literal(\"\\n\")\n\n/**\n * A tab, `\\t`.\n *\n * @since 0.1.0\n * @category line endings\n */\nexport const tab: Parser<\"\\t\"> = /*#__PURE__*/ Token.literal(\"\\t\")\n\n/**\n * A line ending: `\\n` or `\\r\\n`.\n *\n * @since 0.1.0\n * @category line endings\n */\nexport const lineEnding: Parser<\"\\n\" | \"\\r\\n\"> = /*#__PURE__*/ P.alt(newline, crlf).pipe(\n  /*#__PURE__*/ P.expected(\"line ending\")\n)\n\nconst expectedLineEnding = [\"line ending\"]\n\n/**\n * Everything up to (not including) a line ending, `[^\\r\\n]*` (winnow's\n * `till_line_ending`, nom's `not_line_ending`). A carriage return that is\n * not followed by a line feed is an error.\n *\n * @since 0.1.0\n * @category line endings\n */\nexport const tillLineEnding: Parser<string> = /*#__PURE__*/ P.described<string>(\n  (state: State<any>) => {\n    const start = state.pos\n    const input = state.input\n    const isString = state.inputKind === 0\n    let i = start\n    while (i < state.end) {\n      const c = isString ? (input as string).charCodeAt(i) : (input as Uint8Array)[i]\n      if (c === 10) break\n      if (c === 13) {\n        // The line feed after it is read, not consumed\n        state.syntax?.read(i + 2)\n        if (i + 1 >= state.end) {\n          if (state.partial) return state.incomplete(1, expectedLineEnding)\n          return state.backtrack(\"LineEnding\", expectedLineEnding, i)\n        }\n        const d = isString ? (input as string).charCodeAt(i + 1) : (input as Uint8Array)[i + 1]\n        if (d === 10) break\n        return state.backtrack(\"LineEnding\", expectedLineEnding, i)\n      }\n      i++\n    }\n    if (i >= state.end && state.partial) return state.incomplete(1, expectedLineEnding)\n    state.pos = i\n    return state.slice(start, i) as string\n  },\n  \"tillLineEnding\",\n  { _tag: \"TillLineEnding\", encoding: undefined }\n)\n\n// -----------------------------------------------------------------------------\n// Numbers\n// -----------------------------------------------------------------------------\n\n/** @internal */\nexport const overflow = (value: number): Result.Result<number, string> =>\n  Number.isSafeInteger(value) ? Result.succeed(value) : Result.fail(\"integer overflow\")\n\n/**\n * An unsigned decimal integer: one or more digits (winnow's `dec_uint`,\n * nom's `u32`/`u64`). Fails if the value is not a safe integer.\n *\n * @since 0.1.0\n * @category numbers\n */\nexport const decUint: Parser<number, string> = /*#__PURE__*/ digit1.pipe(\n  /*#__PURE__*/ P.tryMap((s) => overflow(Number(numbers.toText(s)))),\n  /*#__PURE__*/ P.named(\"decUint\")\n)\n\n/**\n * A signed decimal integer: an optional `+` or `-` followed by one or more\n * digits (winnow's `dec_int`, nom's `i32`/`i64`). Fails if the value is not\n * a safe integer.\n *\n * @since 0.1.0\n * @category numbers\n */\nexport const decInt: Parser<number, string> = /*#__PURE__*/ P.taken(\n  /*#__PURE__*/ P.seq(/*#__PURE__*/ P.opt(/*#__PURE__*/ Token.oneOf(\"+-\")), digit1)\n).pipe(\n  /*#__PURE__*/ P.tryMap((s) => overflow(Number(numbers.toText(s)))),\n  /*#__PURE__*/ P.named(\"decInt\")\n)\n\n/**\n * An unsigned decimal integer as a `bigint`, of any size.\n *\n * @since 0.1.0\n * @category numbers\n */\nexport const decBigUint: Parser<bigint> = /*#__PURE__*/ digit1.pipe(\n  /*#__PURE__*/ P.map((s) => BigInt(numbers.toText(s)))\n)\n\n/**\n * A signed decimal integer as a `bigint`, of any size.\n *\n * @since 0.1.0\n * @category numbers\n */\nexport const decBigInt: Parser<bigint> = /*#__PURE__*/ P.taken(\n  /*#__PURE__*/ P.seq(/*#__PURE__*/ P.opt(/*#__PURE__*/ Token.oneOf(\"+-\")), digit1)\n).pipe(\n  /*#__PURE__*/ P.map((s) => {\n    const t = numbers.toText(s)\n    return BigInt(t.startsWith(\"+\") ? t.slice(1) : t)\n  })\n)\n\n/**\n * A hexadecimal unsigned integer, without prefix (winnow's `hex_uint`, nom's\n * `hex_u32`). Fails if the value is not a safe integer.\n *\n * @since 0.1.0\n * @category numbers\n */\nexport const hexUint: Parser<number, string> = /*#__PURE__*/ hexDigit1.pipe(\n  /*#__PURE__*/ P.tryMap((s) => overflow(parseInt(numbers.toText(s), 16))),\n  /*#__PURE__*/ P.named(\"hexUint\")\n)\n\nconst sign = /*#__PURE__*/ P.opt(/*#__PURE__*/ Token.oneOf(\"+-\"))\nconst exponent = /*#__PURE__*/ P.opt(/*#__PURE__*/ P.seq(/*#__PURE__*/ Token.oneOf(\"eE\"), sign, digit1))\nconst unsignedFloat = /*#__PURE__*/ P.alt(\n  /*#__PURE__*/ P.seq(\n    /*#__PURE__*/ literalImpl(\"inf\", true),\n    /*#__PURE__*/ P.opt(/*#__PURE__*/ literalImpl(\"inity\", true))\n  ),\n  /*#__PURE__*/ P.seq(/*#__PURE__*/ Token.literal(\".\"), digit1, exponent),\n  /*#__PURE__*/ P.seq(\n    digit1,\n    /*#__PURE__*/ P.opt(/*#__PURE__*/ P.seq(/*#__PURE__*/ Token.literal(\".\"), /*#__PURE__*/ P.opt(digit1))),\n    exponent\n  )\n)\nconst floatText = /*#__PURE__*/ numbers.floatText(\n  /*#__PURE__*/ P.taken(\n    /*#__PURE__*/ P.alt(/*#__PURE__*/ literalImpl(\"nan\", true), /*#__PURE__*/ P.seq(sign, unsignedFloat))\n  ).pipe(/*#__PURE__*/ P.expected(\"number\")) as Parser<string>\n)\n\n/** @internal */\nexport const toFloat: (s: Input) => number = numbers.toFloat\n\n/**\n * A floating point number in decimal or scientific notation, including\n * `inf`, `infinity` and `nan` (case insensitive), as accepted by winnow's\n * `float` and nom's `double`.\n *\n * @example\n * ```ts\n * import { Ascii, Parser } from \"@thomasfosterau/effect-parse\"\n *\n * Parser.parse(Ascii.float, \"-1.5e3\") // Result.succeed(-1500)\n * ```\n *\n * @since 0.1.0\n * @category numbers\n */\nexport const float: Parser<number> = /*#__PURE__*/ floatText.pipe(\n  /*#__PURE__*/ P.map(toFloat),\n  /*#__PURE__*/ P.named(\"float\")\n)\n\n// -----------------------------------------------------------------------------\n// Literals\n// -----------------------------------------------------------------------------\n\n/**\n * Matches a literal ignoring ASCII case (winnow's `Caseless`, nom's\n * `tag_no_case`). Returns the input as written.\n *\n * @since 0.1.0\n * @category literals\n */\nexport const caseless: {\n  (literal: string): Parser<string>\n  (literal: Uint8Array): Parser<Uint8Array, never, never, Uint8Array>\n} = (lit: string | Uint8Array): any => literalImpl(lit, true)\n\n// -----------------------------------------------------------------------------\n// Escapes\n// -----------------------------------------------------------------------------\n\nconst controlCode = (c: string | number): number => (Predicate.isNumber(c) ? c : c.charCodeAt(0))\n\nconst atControl = (state: State<Input>, control: number): boolean => {\n  if (state.pos >= state.end) return false\n  const input = state.input\n  const c = state.inputKind === 0 ? (input as string).charCodeAt(state.pos) : (input as Uint8Array)[state.pos]\n  return c === control\n}\n\n/**\n * Recognizes a string containing escape sequences, returning the raw slice\n * (winnow's `take_escaped`, nom's `escaped`).\n *\n * - `normal` matches runs of ordinary characters (it must consume input)\n * - `control` is the escape character, e.g. `\"\\\\\"`\n * - `escapable` matches what may follow the control character\n *\n * @example\n * ```ts\n * import { Ascii, Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const raw = Ascii.takeEscaped(Ascii.alpha1, \"\\\\\", Token.oneOf(\"\\\"n\\\\\"))\n * Parser.parse(raw, \"ab\\\\\\\"cd\") // Result.succeed(\"ab\\\\\\\"cd\")\n * ```\n *\n * @since 0.1.0\n * @category escapes\n */\nexport const takeEscaped = <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(\n  normal: Parser<A, E, R, I>,\n  control: string | number,\n  escapable: Parser<B, E2, R2, I2>\n): Parser<Slice<I & I2>, E | E2, R | R2, I & I2> => {\n  const ctrl = controlCode(control)\n  return takeEscapedImpl(\n    normal,\n    (state) => {\n      if (!atControl(state, ctrl)) return false\n      state.pos++\n      return true\n    },\n    escapable,\n    (state, start) => state.slice(start, state.pos) as Slice<I & I2>,\n    ctrl,\n    undefined\n  )\n}\n\nconst isIncomplete = (state: State<any>): boolean => state.mode === \"Incomplete\"\n\n/**\n * Fails with the current (`Incomplete`) failure, recording a checkpoint\n * first in a streaming parse.\n */\nconst suspendAt = (state: State<any>, key: Key, start: number, checkpoint: unknown): Fail => {\n  if (state.resume !== undefined) Resume.save(state, key, start, checkpoint)\n  return Fail\n}\n\n/** @internal */\nexport const takeEscapedImpl = <A, E, R, I extends Input, B, E2, R2, I2 extends Input, S>(\n  normal: Parser<A, E, R, I>,\n  matchControl: (state: State<any>) => boolean,\n  escapable: Parser<B, E2, R2, I2>,\n  slice: (state: State<any>, start: number) => S,\n  control: number,\n  encoding: Encoding<any> | undefined\n): Parser<S, E | E2, R | R2, I & I2> => {\n  const normalStep = normal.step\n  const escStep = escapable.step\n  const key = new Key()\n  return P.described(\n    (state: State<any>) => {\n      const start = state.pos\n      let resumed = false\n      if (state.resume !== undefined) {\n        const checkpoint = Resume.take(state, key, start) as number | Resume.Done | undefined\n        if (checkpoint instanceof Resume.Done) {\n          state.pos = checkpoint.pos\n          return checkpoint.value as S\n        }\n        if (checkpoint !== undefined) {\n          state.pos = checkpoint\n          resumed = true\n        }\n      }\n      while (state.pos < state.end) {\n        const before = state.pos\n        const a = normalStep(state)\n        if (a !== Fail) {\n          if (state.pos === before)\n            return state.failMessage(\"Cut\", \"Assert\", \"`takeEscaped` parsers must always consume\")\n          continue\n        }\n        if (state.mode === \"Incomplete\") return suspendAt(state, key, start, before)\n        if (state.mode !== \"Backtrack\") return Fail\n        state.rewind(before)\n        if (matchControl(state)) {\n          if (escStep(state) === Fail) return isIncomplete(state) ? suspendAt(state, key, start, before) : Fail\n        } else {\n          return Resume.done(state, key, start, resumed, slice(state, start))\n        }\n      }\n      if (state.partial) {\n        state.incomplete(0)\n        return suspendAt(state, key, start, state.pos)\n      }\n      return Resume.done(state, key, start, resumed, slice(state, start))\n    },\n    \"takeEscaped\",\n    { _tag: \"Escaped\", normal, control, escape: escapable, raw: true, encoding }\n  )\n}\n\n/**\n * Parses a string containing escape sequences, returning the *unescaped*\n * string (winnow's `escaped`, nom's `escaped_transform`).\n *\n * - `normal` matches runs of ordinary characters, returning them\n * - `control` is the escape character, e.g. `\"\\\\\"`\n * - `escape` parses what follows the control character, returning its\n *   replacement\n *\n * @example\n * ```ts\n * import { Ascii, Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const unescaped = Ascii.escaped(\n *   Token.takeTill(\"\\\\\\\"\"),\n *   \"\\\\\",\n *   Parser.alt(\n *     Token.literal(\"n\").pipe(Parser.as(\"\\n\")),\n *     Token.literal(\"\\\\\"),\n *     Token.literal(\"\\\"\")\n *   )\n * )\n * Parser.parse(unescaped, \"a\\\\nb\") // Result.succeed(\"a\\nb\")\n * ```\n *\n * @since 0.1.0\n * @category escapes\n */\nexport const escaped = <E, R, I extends Input, E2, R2, I2 extends Input>(\n  normal: Parser<string, E, R, I>,\n  control: string | number,\n  escape: Parser<string, E2, R2, I2>\n): Parser<string, E | E2, R | R2, I & I2> => {\n  const ctrl = controlCode(control)\n  return escapedImpl(\n    normal,\n    (state) => {\n      if (!atControl(state, ctrl)) return false\n      state.pos++\n      return true\n    },\n    escape,\n    ctrl,\n    undefined\n  )\n}\n\n/** How far `escaped` got: the text so far, and where to carry on. */\ninterface EscapedCheckpoint {\n  readonly out: string\n  readonly pos: number\n}\n\n/** @internal */\nexport const escapedImpl = <E, R, I extends Input, E2, R2, I2 extends Input>(\n  normal: Parser<string, E, R, I>,\n  matchControl: (state: State<any>) => boolean,\n  escape: Parser<string, E2, R2, I2>,\n  control: number,\n  encoding: Encoding<any> | undefined\n): Parser<string, E | E2, R | R2, I & I2> => {\n  const normalStep = normal.step\n  const escStep = escape.step\n  const key = new Key()\n  return P.described(\n    (state: State<any>) => {\n      const start = state.pos\n      let out = \"\"\n      let resumed = false\n      if (state.resume !== undefined) {\n        const checkpoint = Resume.take(state, key, start) as EscapedCheckpoint | Resume.Done | undefined\n        if (checkpoint instanceof Resume.Done) {\n          state.pos = checkpoint.pos\n          return checkpoint.value as string\n        }\n        if (checkpoint !== undefined) {\n          out = checkpoint.out\n          state.pos = checkpoint.pos\n          resumed = true\n        }\n      }\n      while (state.pos < state.end) {\n        const before = state.pos\n        const a = normalStep(state)\n        if (a !== Fail) {\n          if (state.pos !== before) {\n            out += a\n            continue\n          }\n          // `normal` matched nothing: fall through to the control character\n        } else {\n          if (state.mode === \"Incomplete\") return suspendAt(state, key, start, { out, pos: before })\n          if (state.mode !== \"Backtrack\") return Fail\n          state.rewind(before)\n        }\n        if (matchControl(state)) {\n          const b = escStep(state)\n          if (b === Fail) return isIncomplete(state) ? suspendAt(state, key, start, { out, pos: before }) : Fail\n          out += b\n        } else {\n          return Resume.done(state, key, start, resumed, out)\n        }\n      }\n      if (state.partial) {\n        state.incomplete(0)\n        return suspendAt(state, key, start, { out, pos: state.pos })\n      }\n      return Resume.done(state, key, start, resumed, out)\n    },\n    \"escaped\",\n    { _tag: \"Escaped\", normal, control, escape, raw: false, encoding }\n  )\n}\n\n// -----------------------------------------------------------------------------\n// Byte views\n// -----------------------------------------------------------------------------\n\ntype Bytes<P> =\n  P extends Parser<infer A, infer E, infer R, infer _I>\n    ? Parser<A extends string ? Uint8Array : A, E, R, Uint8Array>\n    : never\n\n/**\n * The parsers of this module, typed for `Uint8Array` input. Slices are\n * returned as `Uint8Array`s.\n *\n * @example\n * ```ts\n * import { Ascii, Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const encode = (s: string) => new TextEncoder().encode(s)\n * const header = Parser.separatedPair(\n *   Ascii.bytes.alpha1,\n *   Token.literal(encode(\": \")),\n *   Ascii.bytes.tillLineEnding\n * )\n * ```\n *\n * @since 0.1.0\n * @category byte views\n */\nexport const bytes: {\n  readonly alpha0: Bytes<typeof alpha0>\n  readonly alpha1: Bytes<typeof alpha1>\n  readonly digit0: Bytes<typeof digit0>\n  readonly digit1: Bytes<typeof digit1>\n  readonly hexDigit0: Bytes<typeof hexDigit0>\n  readonly hexDigit1: Bytes<typeof hexDigit1>\n  readonly octDigit0: Bytes<typeof octDigit0>\n  readonly octDigit1: Bytes<typeof octDigit1>\n  readonly alphanumeric0: Bytes<typeof alphanumeric0>\n  readonly alphanumeric1: Bytes<typeof alphanumeric1>\n  readonly space0: Bytes<typeof space0>\n  readonly space1: Bytes<typeof space1>\n  readonly multispace0: Bytes<typeof multispace0>\n  readonly multispace1: Bytes<typeof multispace1>\n  readonly crlf: Parser<Uint8Array, never, never, Uint8Array>\n  readonly newline: Parser<Uint8Array, never, never, Uint8Array>\n  readonly tab: Parser<Uint8Array, never, never, Uint8Array>\n  readonly lineEnding: Parser<Uint8Array, never, never, Uint8Array>\n  readonly tillLineEnding: Bytes<typeof tillLineEnding>\n  readonly decUint: Parser<number, string, never, Uint8Array>\n  readonly decInt: Parser<number, string, never, Uint8Array>\n  readonly decBigUint: Parser<bigint, never, never, Uint8Array>\n  readonly decBigInt: Parser<bigint, never, never, Uint8Array>\n  readonly hexUint: Parser<number, string, never, Uint8Array>\n  readonly float: Parser<number, never, never, Uint8Array>\n} = /*#__PURE__*/ (() => {\n  const lit = (s: string) => Token.literal(new TextEncoder().encode(s))\n  const crlfB = lit(\"\\r\\n\")\n  const newlineB = lit(\"\\n\")\n  return {\n    alpha0,\n    alpha1,\n    digit0,\n    digit1,\n    hexDigit0,\n    hexDigit1,\n    octDigit0,\n    octDigit1,\n    alphanumeric0,\n    alphanumeric1,\n    space0,\n    space1,\n    multispace0,\n    multispace1,\n    crlf: crlfB,\n    newline: newlineB,\n    tab: lit(\"\\t\"),\n    lineEnding: P.alt(newlineB, crlfB).pipe(P.expected(\"line ending\")),\n    tillLineEnding,\n    decUint,\n    decInt,\n    decBigUint,\n    decBigInt,\n    hexUint,\n    float\n  } as any\n})()\n"],"mappings":"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"}

package/dist/Binary.d.ts

@@ -1,7 +1,6 @@
 import { Input, Slice } from "./Input.js";
 import { Parser } from "./Parser.js";
 import { bits } from "./Bits.js";
-//#region src/Binary.d.ts
 /**
  * A byte order. `"native"` is the byte order of the current platform.
  *
@@ -125,6 +124,5 @@ export declare const lengthRepeat: <E, R, I extends Input, A, E2, R2, I2 extends
  * @category length-prefixed
  */
 export declare const lengthAndThen: <E, R, I extends Input, A, E2, R2>(count: Parser<number | bigint, E, R, I>, parser: Parser<A, E2, R2, Slice<I> & Input>) => Parser<A, E | E2, R | R2, I>;
-//#endregion
 export { bits };
 //# sourceMappingURL=Binary.d.ts.map

package/dist/Binary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Binary.d.ts","names":[],"sources":["../src/Binary.ts"],"mappings":";;;;;;;;;;YA0CY;;;;;;;qBAmDC,IAAI,6BAA6B;;;;;;;qBAQjC,IAAI,6BAA6B;;qBAGjC,OAAO,6BAA6B;;qBAIpC,OAAO,6BAA6B;;qBAIpC,OAAO,6BAA6B;;qBAIpC,OAAO,6BAA6B;;qBAIpC,OAAO,6BAA6B;;qBAMpC,OAAO,6BAA6B;;qBAMpC,OAAO,6BAA6B;;qBAMpC,OAAO,6BAA6B;;qBAMpC,OAAO,6BAA6B;;qBAIpC,OAAO,6BAA6B;;qBAIpC,OAAO,6BAA6B;;qBAIpC,OAAO,6BAA6B;;qBAIpC,OAAO,6BAA6B;;qBAIpC,OAAO,6BAA6B;;qBAIpC,OAAO,6BAA6B;;qBAIpC,OAAO,6BAA6B;;qBAIpC,QAAQ,6BAA6B;;qBAMrC,QAAQ,6BAA6B;;qBAMrC,QAAQ,6BAA6B;;qBAMrC,QAAQ,6BAA6B;;qBAOrC,OAAO,6BAA6B;;qBAIpC,OAAO,6BAA6B;;qBAIpC,OAAO,6BAA6B;;qBAIpC,OAAO,6BAA6B;;;;;;;qBAepC,MAAM,QAAQ,eAAe,6BAA6B;;qBAK1D,MAAM,QAAQ,eAAe,6BAA6B;;qBAK1D,MAAM,QAAQ,eAAe,6BAA6B;;qBAK1D,MAAM,QAAQ,eAAe,6BAA6B;;qBAK1D,MAAM,QAAQ,eAAe,6BAA6B;;qBAK1D,MAAM,QAAQ,eAAe,6BAA6B;;qBAK1D,MAAM,QAAQ,eAAe,6BAA6B;;qBAK1D,MAAM,QAAQ,eAAe,6BAA6B;;qBAK1D,OAAO,QAAQ,eAAe,6BAA6B;;qBAK3D,OAAO,QAAQ,eAAe,6BAA6B;;qBAK3D,MAAM,QAAQ,eAAe,6BAA6B;;qBAK1D,MAAM,QAAQ,eAAe,6BAA6B;;;;;;;;qBAc1D,aAAc,GAAG,GAAG,UAAU,QAAQ,YACjD,OAAO,wBAAwB,GAAG,GAAG,OACpC,OAAO,MAAM,IAAI,GAAG,GAAG;;;;;;;;qBAgBb,eAAgB,GAAG,GAAG,UAAU,OAAO,GAAG,IAAI,IAAI,WAAW,OACxE,OAAO,wBAAwB,GAAG,GAAG,IACrC,QAAQ,OAAO,GAAG,IAAI,IAAI,QACzB,OAAO,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI;;;;;;;;;qBAW3B,gBAAiB,GAAG,GAAG,UAAU,OAAO,GAAG,IAAI,IAC1D,OAAO,wBAAwB,GAAG,GAAG,IACrC,QAAQ,OAAO,GAAG,IAAI,IAAI,MAAM,KAAK,WACpC,OAAO,GAAG,IAAI,IAAI,IAAI,IAAI"}
+{"version":3,"file":"Binary.d.ts","names":[],"sources":["../src/Binary.ts"],"mappings":";;;;;;;;;YA0CY;;;;;;;qBAmDC,IAAI,6BAA6B;;;;;;;qBAQjC,IAAI,6BAA6B;;qBAGjC,OAAO,6BAA6B;;qBAIpC,OAAO,6BAA6B;;qBAIpC,OAAO,6BAA6B;;qBAIpC,OAAO,6BAA6B;;qBAIpC,OAAO,6BAA6B;;qBAMpC,OAAO,6BAA6B;;qBAMpC,OAAO,6BAA6B;;qBAMpC,OAAO,6BAA6B;;qBAMpC,OAAO,6BAA6B;;qBAIpC,OAAO,6BAA6B;;qBAIpC,OAAO,6BAA6B;;qBAIpC,OAAO,6BAA6B;;qBAIpC,OAAO,6BAA6B;;qBAIpC,OAAO,6BAA6B;;qBAIpC,OAAO,6BAA6B;;qBAIpC,OAAO,6BAA6B;;qBAIpC,QAAQ,6BAA6B;;qBAMrC,QAAQ,6BAA6B;;qBAMrC,QAAQ,6BAA6B;;qBAMrC,QAAQ,6BAA6B;;qBAOrC,OAAO,6BAA6B;;qBAIpC,OAAO,6BAA6B;;qBAIpC,OAAO,6BAA6B;;qBAIpC,OAAO,6BAA6B;;;;;;;qBAepC,MAAM,QAAQ,eAAe,6BAA6B;;qBAK1D,MAAM,QAAQ,eAAe,6BAA6B;;qBAK1D,MAAM,QAAQ,eAAe,6BAA6B;;qBAK1D,MAAM,QAAQ,eAAe,6BAA6B;;qBAK1D,MAAM,QAAQ,eAAe,6BAA6B;;qBAK1D,MAAM,QAAQ,eAAe,6BAA6B;;qBAK1D,MAAM,QAAQ,eAAe,6BAA6B;;qBAK1D,MAAM,QAAQ,eAAe,6BAA6B;;qBAK1D,OAAO,QAAQ,eAAe,6BAA6B;;qBAK3D,OAAO,QAAQ,eAAe,6BAA6B;;qBAK3D,MAAM,QAAQ,eAAe,6BAA6B;;qBAK1D,MAAM,QAAQ,eAAe,6BAA6B;;;;;;;;qBAc1D,aAAc,GAAG,GAAG,UAAU,QAAQ,YACjD,OAAO,wBAAwB,GAAG,GAAG,OACpC,OAAO,MAAM,IAAI,GAAG,GAAG;;;;;;;;qBAgBb,eAAgB,GAAG,GAAG,UAAU,OAAO,GAAG,IAAI,IAAI,WAAW,OACxE,OAAO,wBAAwB,GAAG,GAAG,IACrC,QAAQ,OAAO,GAAG,IAAI,IAAI,QACzB,OAAO,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI;;;;;;;;;qBAW3B,gBAAiB,GAAG,GAAG,UAAU,OAAO,GAAG,IAAI,IAC1D,OAAO,wBAAwB,GAAG,GAAG,IACrC,QAAQ,OAAO,GAAG,IAAI,IAAI,MAAM,KAAK,WACpC,OAAO,GAAG,IAAI,IAAI,IAAI,IAAI"}

package/dist/Binary.js

@@ -3,7 +3,7 @@ import { Fail } from "./Input.js";
 import * as P from "./Parser.js";
 import * as Token$1 from "./Token.js";
 import { bits } from "./Bits.js";
-//#region src/Binary.ts
+// src/Binary.ts
 /**
 * Parsers for binary formats: fixed-width integers and floats in either
 * byte order, and length-prefixed data (winnow's `binary` module, nom's
@@ -178,7 +178,6 @@ const lengthRepeat = (count, parser) => P.flatMap(count, (n) => P.repeat(parser,
 * @category length-prefixed
 */
 const lengthAndThen = (count, parser) => P.mapParser(lengthTake(count), P.complete(parser));
-//#endregion
 export { beF32, beF64, beI128, beI16, beI24, beI32, beI64, beU128, beU16, beU24, beU32, beU64, bits, f32, f64, i128, i16, i24, i32, i64, i8, leF32, leF64, leI128, leI16, leI24, leI32, leI64, leU128, leU16, leU24, leU32, leU64, lengthAndThen, lengthRepeat, lengthTake, u128, u16, u24, u32, u64, u8 };
 
 //# sourceMappingURL=Binary.js.map

package/dist/Bits.d.ts

@@ -1,5 +1,4 @@
 import { Parser } from "./Parser.js";
-//#region src/Bits.d.ts
 declare const BitInputBrand: unique symbol;
 /**
  * The input type of bit-level parsers. A `Parser<A, E, R, BitInput>` can
@@ -57,6 +56,5 @@ export declare const pattern: (pattern: number, count: number) => Parser<number,
  * @category parsers
  */
 export declare const bool: Parser<boolean, never, never, BitInput>;
-//#endregion
 export {};
 //# sourceMappingURL=Bits.d.ts.map

package/dist/Bits.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Bits.d.ts","names":[],"sources":["../src/Bits.ts"],"mappings":";;cA2Bc;;;;;;;;iBASG,iBAAiB;YACtB;;;;;;;;;qBAyDC,OAAQ,GAAG,GAAG,GAAG,MAAM,OAAO,GAAG,GAAG,GAAG,cAAY,OAAO,GAAG,GAAG,GAAG;;;;;;;;qBAYnE,QAAS,GAAG,GAAG,GAAG,MAAM,OAAO,GAAG,GAAG,GAAG,gBAAc,OAAO,GAAG,GAAG,GAAG;;;;;;;;qBAyBtE,OAAQ,kBAAgB,6BAA6B;;;;;;;qBAgBrD,UAAW,kBAAgB,6BAA6B;;;;;;;;qBAuBxD,UAAW,iBAAiB,kBAAgB,6BAA6B;;;;;;;qBAqBzE,MAAM,8BAA8B"}
+{"version":3,"file":"Bits.d.ts","names":[],"sources":["../src/Bits.ts"],"mappings":";cA2Bc;;;;;;;;iBASG,iBAAiB;YACtB;;;;;;;;;qBAyDC,OAAQ,GAAG,GAAG,GAAG,MAAM,OAAO,GAAG,GAAG,GAAG,cAAY,OAAO,GAAG,GAAG,GAAG;;;;;;;;qBAYnE,QAAS,GAAG,GAAG,GAAG,MAAM,OAAO,GAAG,GAAG,GAAG,gBAAc,OAAO,GAAG,GAAG,GAAG;;;;;;;;qBAyBtE,OAAQ,kBAAgB,6BAA6B;;;;;;;qBAgBrD,UAAW,kBAAgB,6BAA6B;;;;;;;;qBAuBxD,UAAW,iBAAiB,kBAAgB,6BAA6B;;;;;;;qBAqBzE,MAAM,8BAA8B"}

package/dist/Bits.js

@@ -1,6 +1,6 @@
 import { Fail, Failure } from "./Input.js";
 import { make } from "./Parser.js";
-//#region src/Bits.ts
+// src/Bits.ts
 const scale = (f, factor) => new Failure(factor < 1 ? Math.floor(f.offset * factor) : f.offset * factor, f.kind, f.expected, f.context, f.hasCause, f.cause, f.message, factor < 1 ? Math.ceil(f.needed * factor) : f.needed * factor);
 /**
 * Runs `step` with offsets measured in different units (bits vs bytes),
@@ -120,7 +120,7 @@ const pattern = (pattern, count) => {
 		if (avail < count) return state.eoi("Bits", expected, count - avail);
 		const value = readBits(state, count);
 		if (value !== pattern) {
-			state.pos = start;
+			state.rewind(start);
 			return state.backtrack("Bits", expected);
 		}
 		return value;
@@ -136,7 +136,6 @@ const bool = /*#__PURE__*/ make((state) => {
 	if (state.pos >= state.end) return state.eoi("Bits", ["1 bit"], 1);
 	return readBits(state, 1) === 1;
 }, "bool");
-//#endregion
 export { bits, bool, bytes, pattern, take, takeBig };
 
 //# sourceMappingURL=Bits.js.map

package/dist/Bits.js.map

@@ -1 +1 @@
-{"version":3,"file":"Bits.js","names":[],"sources":["../src/Bits.ts"],"sourcesContent":["/**\n * Bit-level parsing (winnow's `binary::bits`, nom's `bits` module).\n *\n * Bit parsers run inside {@link bits}, which switches a byte parser into\n * bit mode. Bits are read most-significant first. When `bits` finishes, any\n * remaining bits of a partly consumed byte are skipped.\n *\n * Inside `bits`, offsets count bits, so the general combinators (`alt`,\n * `repeat`, `opt`, ...) backtrack at bit granularity.\n *\n * @example\n * ```ts\n * import { Binary, Bits, Parser } from \"@thomasfosterau/effect-parse\"\n *\n * // An IPv4 header starts with a 4-bit version and a 4-bit header length\n * const versionAndLength = Bits.bits(Parser.seq(Bits.take(4), Bits.take(4)))\n *\n * Parser.parse(versionAndLength, new Uint8Array([0x45])) // Result.succeed([4, 5])\n * ```\n *\n * @since 0.1.0\n */\nimport type { State } from \"./Input.js\"\nimport { Fail, Failure } from \"./Input.js\"\nimport type { Parser } from \"./Parser.js\"\nimport { make } from \"./Parser.js\"\n\ndeclare const BitInputBrand: unique symbol\n\n/**\n * The input type of bit-level parsers. A `Parser<A, E, R, BitInput>` can\n * only be run inside {@link bits}.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface BitInput extends ReadonlyArray<never> {\n  readonly [BitInputBrand]: true\n}\n\nconst scale = (f: Failure, factor: number): Failure =>\n  new Failure(\n    factor < 1 ? Math.floor(f.offset * factor) : f.offset * factor,\n    f.kind,\n    f.expected,\n    f.context,\n    f.hasCause,\n    f.cause,\n    f.message,\n    factor < 1 ? Math.ceil(f.needed * factor) : f.needed * factor\n  )\n\n/**\n * Runs `step` with offsets measured in different units (bits vs bytes),\n * converting failure offsets back to the outer units afterwards.\n */\nconst inUnits = <A>(state: State<any>, factor: number, step: (state: State<any>) => A | Fail): A | Fail => {\n  const end = state.end\n  const deepest = state.deepest\n  state.deepest = undefined\n  state.pos = factor > 1 ? state.pos * factor : Math.ceil(state.pos * factor)\n  state.end = end * factor\n  const a = step(state)\n  state.end = end\n  const inner = state.deepest\n  state.deepest = deepest\n  if (a === Fail) {\n    state.pos = factor > 1 ? Math.floor(state.pos / factor) : state.pos / factor\n    const f = state.failure\n    state.failure = scale(f, 1 / factor)\n    // A committed failure keeps only the failures recorded after the commit\n    // (see `Parser.cut`), so none from before these units\n    if (state.mode === \"Cut\") state.deepest = undefined\n    if (inner !== undefined) {\n      const d = inner === f ? state.failure : scale(inner, 1 / factor)\n      if (state.deepest === undefined || d.offset >= state.deepest.offset) state.deepest = d\n    }\n    return Fail\n  }\n  state.pos = factor > 1 ? Math.ceil(state.pos / factor) : state.pos / factor\n  if (inner !== undefined) {\n    const d = scale(inner, 1 / factor)\n    if (deepest === undefined || d.offset >= deepest.offset) state.deepest = d\n  }\n  return a\n}\n\n/**\n * Runs a bit-level parser on byte input (winnow's and nom's `bits`). After\n * success, the input advances to the next byte boundary.\n *\n * @since 0.1.0\n * @category combinators\n */\nexport const bits = <A, E, R>(self: Parser<A, E, R, BitInput>): Parser<A, E, R, Uint8Array> => {\n  const step = self.step as unknown as (state: State<any>) => A | Fail\n  return make((state) => inUnits(state, 8, step), \"bits\")\n}\n\n/**\n * Runs a byte-level parser from within a bit-level parser (winnow's and\n * nom's `bytes`). The partly consumed byte, if any, is skipped first.\n *\n * @since 0.1.0\n * @category combinators\n */\nexport const bytes = <A, E, R>(self: Parser<A, E, R, Uint8Array>): Parser<A, E, R, BitInput> => {\n  const step = self.step as (state: State<any>) => A | Fail\n  return make((state: State<any>) => inUnits(state, 1 / 8, step), \"bytes\")\n}\n\nconst readBits = (state: State<any>, count: number): number => {\n  const input = state.input as Uint8Array\n  let pos = state.pos\n  let value = 0\n  for (let i = 0; i < count; i++) {\n    const byte = input[pos >>> 3]\n    value = value * 2 + ((byte >>> (7 - (pos & 7))) & 1)\n    pos++\n  }\n  state.pos = pos\n  return value\n}\n\n/**\n * Takes `count` bits (at most 53) as an unsigned number (winnow's and nom's\n * bit-level `take`).\n *\n * @since 0.1.0\n * @category parsers\n */\nexport const take = (count: number): Parser<number, never, never, BitInput> => {\n  if (count > 53) throw new RangeError(\"Bits.take: use Bits.takeBig for more than 53 bits\")\n  const expected = [`${count} bits`]\n  return make((state: State<any>) => {\n    const avail = state.end - state.pos\n    if (avail < count) return state.eoi(\"Bits\", expected, count - avail)\n    return readBits(state, count)\n  }, \"take\")\n}\n\n/**\n * Takes `count` bits as an unsigned `bigint`.\n *\n * @since 0.1.0\n * @category parsers\n */\nexport const takeBig = (count: number): Parser<bigint, never, never, BitInput> => {\n  const expected = [`${count} bits`]\n  return make((state: State<any>) => {\n    const avail = state.end - state.pos\n    if (avail < count) return state.eoi(\"Bits\", expected, count - avail)\n    let value = 0n\n    let remaining = count\n    while (remaining > 0) {\n      const n = Math.min(remaining, 32)\n      value = (value << BigInt(n)) | BigInt(readBits(state, n))\n      remaining -= n\n    }\n    return value\n  }, \"takeBig\")\n}\n\n/**\n * Matches `count` bits equal to `pattern` (winnow's `pattern`, nom's bit\n * `tag`).\n *\n * @since 0.1.0\n * @category parsers\n */\nexport const pattern = (pattern: number, count: number): Parser<number, never, never, BitInput> => {\n  const expected = [`bit pattern ${pattern.toString(2).padStart(count, \"0\")}`]\n  return make((state: State<any>) => {\n    const start = state.pos\n    const avail = state.end - start\n    if (avail < count) return state.eoi(\"Bits\", expected, count - avail)\n    const value = readBits(state, count)\n    if (value !== pattern) {\n      state.pos = start\n      return state.backtrack(\"Bits\", expected)\n    }\n    return value\n  }, \"pattern\")\n}\n\n/**\n * Takes one bit as a boolean (winnow's and nom's `bool`).\n *\n * @since 0.1.0\n * @category parsers\n */\nexport const bool: Parser<boolean, never, never, BitInput> = /*#__PURE__*/ make((state: State<any>) => {\n  if (state.pos >= state.end) return state.eoi(\"Bits\", [\"1 bit\"], 1)\n  return readBits(state, 1) === 1\n}, \"bool\")\n"],"mappings":"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"}
+{"version":3,"file":"Bits.js","names":[],"sources":["../src/Bits.ts"],"sourcesContent":["/**\n * Bit-level parsing (winnow's `binary::bits`, nom's `bits` module).\n *\n * Bit parsers run inside {@link bits}, which switches a byte parser into\n * bit mode. Bits are read most-significant first. When `bits` finishes, any\n * remaining bits of a partly consumed byte are skipped.\n *\n * Inside `bits`, offsets count bits, so the general combinators (`alt`,\n * `repeat`, `opt`, ...) backtrack at bit granularity.\n *\n * @example\n * ```ts\n * import { Binary, Bits, Parser } from \"@thomasfosterau/effect-parse\"\n *\n * // An IPv4 header starts with a 4-bit version and a 4-bit header length\n * const versionAndLength = Bits.bits(Parser.seq(Bits.take(4), Bits.take(4)))\n *\n * Parser.parse(versionAndLength, new Uint8Array([0x45])) // Result.succeed([4, 5])\n * ```\n *\n * @since 0.1.0\n */\nimport type { State } from \"./Input.js\"\nimport { Fail, Failure } from \"./Input.js\"\nimport type { Parser } from \"./Parser.js\"\nimport { make } from \"./Parser.js\"\n\ndeclare const BitInputBrand: unique symbol\n\n/**\n * The input type of bit-level parsers. A `Parser<A, E, R, BitInput>` can\n * only be run inside {@link bits}.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface BitInput extends ReadonlyArray<never> {\n  readonly [BitInputBrand]: true\n}\n\nconst scale = (f: Failure, factor: number): Failure =>\n  new Failure(\n    factor < 1 ? Math.floor(f.offset * factor) : f.offset * factor,\n    f.kind,\n    f.expected,\n    f.context,\n    f.hasCause,\n    f.cause,\n    f.message,\n    factor < 1 ? Math.ceil(f.needed * factor) : f.needed * factor\n  )\n\n/**\n * Runs `step` with offsets measured in different units (bits vs bytes),\n * converting failure offsets back to the outer units afterwards.\n */\nconst inUnits = <A>(state: State<any>, factor: number, step: (state: State<any>) => A | Fail): A | Fail => {\n  const end = state.end\n  const deepest = state.deepest\n  state.deepest = undefined\n  state.pos = factor > 1 ? state.pos * factor : Math.ceil(state.pos * factor)\n  state.end = end * factor\n  const a = step(state)\n  state.end = end\n  const inner = state.deepest\n  state.deepest = deepest\n  if (a === Fail) {\n    state.pos = factor > 1 ? Math.floor(state.pos / factor) : state.pos / factor\n    const f = state.failure\n    state.failure = scale(f, 1 / factor)\n    // A committed failure keeps only the failures recorded after the commit\n    // (see `Parser.cut`), so none from before these units\n    if (state.mode === \"Cut\") state.deepest = undefined\n    if (inner !== undefined) {\n      const d = inner === f ? state.failure : scale(inner, 1 / factor)\n      if (state.deepest === undefined || d.offset >= state.deepest.offset) state.deepest = d\n    }\n    return Fail\n  }\n  state.pos = factor > 1 ? Math.ceil(state.pos / factor) : state.pos / factor\n  if (inner !== undefined) {\n    const d = scale(inner, 1 / factor)\n    if (deepest === undefined || d.offset >= deepest.offset) state.deepest = d\n  }\n  return a\n}\n\n/**\n * Runs a bit-level parser on byte input (winnow's and nom's `bits`). After\n * success, the input advances to the next byte boundary.\n *\n * @since 0.1.0\n * @category combinators\n */\nexport const bits = <A, E, R>(self: Parser<A, E, R, BitInput>): Parser<A, E, R, Uint8Array> => {\n  const step = self.step as unknown as (state: State<any>) => A | Fail\n  return make((state) => inUnits(state, 8, step), \"bits\")\n}\n\n/**\n * Runs a byte-level parser from within a bit-level parser (winnow's and\n * nom's `bytes`). The partly consumed byte, if any, is skipped first.\n *\n * @since 0.1.0\n * @category combinators\n */\nexport const bytes = <A, E, R>(self: Parser<A, E, R, Uint8Array>): Parser<A, E, R, BitInput> => {\n  const step = self.step as (state: State<any>) => A | Fail\n  return make((state: State<any>) => inUnits(state, 1 / 8, step), \"bytes\")\n}\n\nconst readBits = (state: State<any>, count: number): number => {\n  const input = state.input as Uint8Array\n  let pos = state.pos\n  let value = 0\n  for (let i = 0; i < count; i++) {\n    const byte = input[pos >>> 3]\n    value = value * 2 + ((byte >>> (7 - (pos & 7))) & 1)\n    pos++\n  }\n  state.pos = pos\n  return value\n}\n\n/**\n * Takes `count` bits (at most 53) as an unsigned number (winnow's and nom's\n * bit-level `take`).\n *\n * @since 0.1.0\n * @category parsers\n */\nexport const take = (count: number): Parser<number, never, never, BitInput> => {\n  if (count > 53) throw new RangeError(\"Bits.take: use Bits.takeBig for more than 53 bits\")\n  const expected = [`${count} bits`]\n  return make((state: State<any>) => {\n    const avail = state.end - state.pos\n    if (avail < count) return state.eoi(\"Bits\", expected, count - avail)\n    return readBits(state, count)\n  }, \"take\")\n}\n\n/**\n * Takes `count` bits as an unsigned `bigint`.\n *\n * @since 0.1.0\n * @category parsers\n */\nexport const takeBig = (count: number): Parser<bigint, never, never, BitInput> => {\n  const expected = [`${count} bits`]\n  return make((state: State<any>) => {\n    const avail = state.end - state.pos\n    if (avail < count) return state.eoi(\"Bits\", expected, count - avail)\n    let value = 0n\n    let remaining = count\n    while (remaining > 0) {\n      const n = Math.min(remaining, 32)\n      value = (value << BigInt(n)) | BigInt(readBits(state, n))\n      remaining -= n\n    }\n    return value\n  }, \"takeBig\")\n}\n\n/**\n * Matches `count` bits equal to `pattern` (winnow's `pattern`, nom's bit\n * `tag`).\n *\n * @since 0.1.0\n * @category parsers\n */\nexport const pattern = (pattern: number, count: number): Parser<number, never, never, BitInput> => {\n  const expected = [`bit pattern ${pattern.toString(2).padStart(count, \"0\")}`]\n  return make((state: State<any>) => {\n    const start = state.pos\n    const avail = state.end - start\n    if (avail < count) return state.eoi(\"Bits\", expected, count - avail)\n    const value = readBits(state, count)\n    if (value !== pattern) {\n      state.rewind(start)\n      return state.backtrack(\"Bits\", expected)\n    }\n    return value\n  }, \"pattern\")\n}\n\n/**\n * Takes one bit as a boolean (winnow's and nom's `bool`).\n *\n * @since 0.1.0\n * @category parsers\n */\nexport const bool: Parser<boolean, never, never, BitInput> = /*#__PURE__*/ make((state: State<any>) => {\n  if (state.pos >= state.end) return state.eoi(\"Bits\", [\"1 bit\"], 1)\n  return readBits(state, 1) === 1\n}, \"bool\")\n"],"mappings":";;;AAwCA,MAAM,SAAS,GAAY,WACzB,IAAI,QACF,SAAS,IAAI,KAAK,MAAM,EAAE,SAAS,MAAM,IAAI,EAAE,SAAS,QACxD,EAAE,MACF,EAAE,UACF,EAAE,SACF,EAAE,UACF,EAAE,OACF,EAAE,SACF,SAAS,IAAI,KAAK,KAAK,EAAE,SAAS,MAAM,IAAI,EAAE,SAAS,MACzD;;;;;AAMF,MAAM,WAAc,OAAmB,QAAgB,SAAoD;CACzG,MAAM,MAAM,MAAM;CAClB,MAAM,UAAU,MAAM;CACtB,MAAM,UAAU,KAAA;CAChB,MAAM,MAAM,SAAS,IAAI,MAAM,MAAM,SAAS,KAAK,KAAK,MAAM,MAAM,MAAM;CAC1E,MAAM,MAAM,MAAM;CAClB,MAAM,IAAI,KAAK,KAAK;CACpB,MAAM,MAAM;CACZ,MAAM,QAAQ,MAAM;CACpB,MAAM,UAAU;CAChB,IAAI,MAAM,MAAM;EACd,MAAM,MAAM,SAAS,IAAI,KAAK,MAAM,MAAM,MAAM,MAAM,IAAI,MAAM,MAAM;EACtE,MAAM,IAAI,MAAM;EAChB,MAAM,UAAU,MAAM,GAAG,IAAI,MAAM;EAGnC,IAAI,MAAM,SAAS,OAAO,MAAM,UAAU,KAAA;EAC1C,IAAI,UAAU,KAAA,GAAW;GACvB,MAAM,IAAI,UAAU,IAAI,MAAM,UAAU,MAAM,OAAO,IAAI,MAAM;GAC/D,IAAI,MAAM,YAAY,KAAA,KAAa,EAAE,UAAU,MAAM,QAAQ,QAAQ,MAAM,UAAU;EACvF;EACA,OAAO;CACT;CACA,MAAM,MAAM,SAAS,IAAI,KAAK,KAAK,MAAM,MAAM,MAAM,IAAI,MAAM,MAAM;CACrE,IAAI,UAAU,KAAA,GAAW;EACvB,MAAM,IAAI,MAAM,OAAO,IAAI,MAAM;EACjC,IAAI,YAAY,KAAA,KAAa,EAAE,UAAU,QAAQ,QAAQ,MAAM,UAAU;CAC3E;CACA,OAAO;AACT;;;;;;;;AASA,MAAa,QAAiB,SAAiE;CAC7F,MAAM,OAAO,KAAK;CAClB,OAAO,MAAM,UAAU,QAAQ,OAAO,GAAG,IAAI,GAAG,MAAM;AACxD;;;;;;;;AASA,MAAa,SAAkB,SAAiE;CAC9F,MAAM,OAAO,KAAK;CAClB,OAAO,MAAM,UAAsB,QAAQ,OAAO,IAAI,GAAG,IAAI,GAAG,OAAO;AACzE;AAEA,MAAM,YAAY,OAAmB,UAA0B;CAC7D,MAAM,QAAQ,MAAM;CACpB,IAAI,MAAM,MAAM;CAChB,IAAI,QAAQ;CACZ,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,KAAK;EAC9B,MAAM,OAAO,MAAM,QAAQ;EAC3B,QAAQ,QAAQ,KAAM,SAAU,KAAK,MAAM,KAAO;EAClD;CACF;CACA,MAAM,MAAM;CACZ,OAAO;AACT;;;;;;;;AASA,MAAa,QAAQ,UAA0D;CAC7E,IAAI,QAAQ,IAAI,MAAM,IAAI,WAAW,mDAAmD;CACxF,MAAM,WAAW,CAAC,GAAG,MAAM,MAAM;CACjC,OAAO,MAAM,UAAsB;EACjC,MAAM,QAAQ,MAAM,MAAM,MAAM;EAChC,IAAI,QAAQ,OAAO,OAAO,MAAM,IAAI,QAAQ,UAAU,QAAQ,KAAK;EACnE,OAAO,SAAS,OAAO,KAAK;CAC9B,GAAG,MAAM;AACX;;;;;;;AAQA,MAAa,WAAW,UAA0D;CAChF,MAAM,WAAW,CAAC,GAAG,MAAM,MAAM;CACjC,OAAO,MAAM,UAAsB;EACjC,MAAM,QAAQ,MAAM,MAAM,MAAM;EAChC,IAAI,QAAQ,OAAO,OAAO,MAAM,IAAI,QAAQ,UAAU,QAAQ,KAAK;EACnE,IAAI,QAAQ;EACZ,IAAI,YAAY;EAChB,OAAO,YAAY,GAAG;GACpB,MAAM,IAAI,KAAK,IAAI,WAAW,EAAE;GAChC,QAAS,SAAS,OAAO,CAAC,IAAK,OAAO,SAAS,OAAO,CAAC,CAAC;GACxD,aAAa;EACf;EACA,OAAO;CACT,GAAG,SAAS;AACd;;;;;;;;AASA,MAAa,WAAW,SAAiB,UAA0D;CACjG,MAAM,WAAW,CAAC,eAAe,QAAQ,SAAS,CAAC,CAAC,CAAC,SAAS,OAAO,GAAG,GAAG;CAC3E,OAAO,MAAM,UAAsB;EACjC,MAAM,QAAQ,MAAM;EACpB,MAAM,QAAQ,MAAM,MAAM;EAC1B,IAAI,QAAQ,OAAO,OAAO,MAAM,IAAI,QAAQ,UAAU,QAAQ,KAAK;EACnE,MAAM,QAAQ,SAAS,OAAO,KAAK;EACnC,IAAI,UAAU,SAAS;GACrB,MAAM,OAAO,KAAK;GAClB,OAAO,MAAM,UAAU,QAAQ,QAAQ;EACzC;EACA,OAAO;CACT,GAAG,SAAS;AACd;;;;;;;AAQA,MAAa,OAA8D,oBAAM,UAAsB;CACrG,IAAI,MAAM,OAAO,MAAM,KAAK,OAAO,MAAM,IAAI,QAAQ,CAAC,OAAO,GAAG,CAAC;CACjE,OAAO,SAAS,OAAO,CAAC,MAAM;AAChC,GAAG,MAAM"}

package/dist/Compiler.d.ts

@@ -1,6 +1,5 @@
 import { Input } from "./Input.js";
 import { Parser } from "./Parser.js";
-//#region src/Compiler.d.ts
 /**
  * Compiles a parser with the JIT: generated code where `new Function` is
  * allowed, otherwise specialized closures (see {@link closure}). Returns the
@@ -35,5 +34,4 @@ export declare const jit: <A, E, R, I extends Input>(self: Parser<A, E, R, I>) =
  * @category compilation
  */
 export declare const closure: <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E, R, I>;
-//#endregion
 //# sourceMappingURL=Compiler.d.ts.map

package/dist/Compiler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Compiler.d.ts","names":[],"sources":["../src/Compiler.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBAyEa,MAAO,GAAG,GAAG,GAAG,UAAU,OAAO,MAAM,OAAO,GAAG,GAAG,GAAG,OAAK,OAAO,GAAG,GAAG,GAAG;;;;;;;;;;;;;;;;;qBAqB5E,UAAW,GAAG,GAAG,GAAG,UAAU,OAAO,MAAM,OAAO,GAAG,GAAG,GAAG,OAAK,OAAO,GAAG,GAAG,GAAG"}
+{"version":3,"file":"Compiler.d.ts","names":[],"sources":["../src/Compiler.ts"],"mappings":";;;;;;;;;;;;;;;;;;qBAyEa,MAAO,GAAG,GAAG,GAAG,UAAU,OAAO,MAAM,OAAO,GAAG,GAAG,GAAG,OAAK,OAAO,GAAG,GAAG,GAAG;;;;;;;;;;;;;;;;;qBAqB5E,UAAW,GAAG,GAAG,GAAG,UAAU,OAAO,MAAM,OAAO,GAAG,GAAG,GAAG,OAAK,OAAO,GAAG,GAAG,GAAG"}

package/dist/Compiler.js

@@ -1,7 +1,7 @@
 import { backend } from "./internal/compiler/closure.js";
 import { backend as backend$1 } from "./internal/compiler/jit.js";
 import { register } from "./internal/compiler/registry.js";
-//#region src/Compiler.ts
+// src/Compiler.ts
 /**
 * Compiles a parser with the JIT: generated code where `new Function` is
 * allowed, otherwise specialized closures (see {@link closure}). Returns the
@@ -42,7 +42,6 @@ const closure = (self) => {
 	register(self, backend);
 	return self;
 };
-//#endregion
 export { closure, jit };
 
 //# sourceMappingURL=Compiler.js.map

package/dist/Encoding.d.ts

@@ -1,5 +1,4 @@
 import * as Option from "effect/Option";
-//#region src/Encoding.d.ts
 /**
  * A text encoding: how to read Unicode code points out of an input. The
  * `Text` module is generic over encodings, so one grammar can parse
@@ -95,5 +94,4 @@ export declare const latin1: Encoding<Uint8Array>;
  * @category utils
  */
 export declare const sniff: (bytes: Uint8Array) => Option.Option<Encoding<Uint8Array>>;
-//#endregion
 //# sourceMappingURL=Encoding.d.ts.map

package/dist/Encoding.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Encoding.d.ts","names":[],"sources":["../src/Encoding.ts"],"mappings":";;;;;;;;;;;;;iBAiCiB,SAAS,mBAAmB,sBAAsB;;WAExD;;;;;WAKA;;;;;WAKA;;;;;;WAMA,SAAS,OAAO,GAAG,gBAAgB;;WAEnC,QAAQ;;WAER,SAAS,iBAAiB;;;;;WAK1B,OAAO,OAAO,GAAG,eAAe;;;;;;;;;;qBAW9B,QAAQ;;;;;;;;qBASR,MAAM,SAAS;;;;;;;qBAQf,SAAS,SAAS;;;;;;;qBAQlB,SAAS,SAAS;;;;;;;;qBASlB,QAAQ,SAAS;;;;;;;;;;;;;;;;qBAiBjB,QAAS,OAAO,eAAa,OAAO,OAAO,SAAS"}
+{"version":3,"file":"Encoding.d.ts","names":[],"sources":["../src/Encoding.ts"],"mappings":";;;;;;;;;;;;iBAiCiB,SAAS,mBAAmB,sBAAsB;;WAExD;;;;;WAKA;;;;;WAKA;;;;;;WAMA,SAAS,OAAO,GAAG,gBAAgB;;WAEnC,QAAQ;;WAER,SAAS,iBAAiB;;;;;WAK1B,OAAO,OAAO,GAAG,eAAe;;;;;;;;;;qBAW9B,QAAQ;;;;;;;;qBASR,MAAM,SAAS;;;;;;;qBAQf,SAAS,SAAS;;;;;;;qBAQlB,SAAS,SAAS;;;;;;;;qBASlB,QAAQ,SAAS;;;;;;;;;;;;;;;;qBAiBjB,QAAS,OAAO,eAAa,OAAO,OAAO,SAAS"}

package/dist/Encoding.js

@@ -1,6 +1,6 @@
 import * as Option from "effect/Option";
 import * as internal from "./internal/text.js";
-//#region src/Encoding.ts
+// src/Encoding.ts
 /**
 * Text encodings for the `Text` module.
 *
@@ -80,7 +80,6 @@ const sniff = (bytes) => {
 	if (bytes[0] === 254 && bytes[1] === 255) return Option.some(utf16be);
 	return Option.none();
 };
-//#endregion
 export { latin1, sniff, string, utf16be, utf16le, utf8 };
 
 //# sourceMappingURL=Encoding.js.map

package/dist/Expression.d.ts

@@ -1,6 +1,5 @@
 import { Input } from "./Input.js";
 import { Parser } from "./Parser.js";
-//#region src/Expression.d.ts
 /**
  * An operator in an expression grammar.
  *
@@ -85,6 +84,5 @@ export declare const make: <A, E, R, I extends Input, const Ops extends Readonly
   readonly operand: Parser<A, E, R, I>;
   readonly operators: Ops;
 }) => Parser<A, E | OpError<Ops[number]>, R | OpServices<Ops[number]>, I & OpInput<Ops[number]>>;
-//#endregion
 export {};
 //# sourceMappingURL=Expression.d.ts.map

package/dist/Expression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Expression.d.ts","names":[],"sources":["../src/Expression.ts"],"mappings":";;;;;;;;;YAgDY,SAAS,GAAG,WAAW,WAAW,UAAU,kBACpD,OAAO,GAAG,GAAG,GAAG,KAChB,QAAQ,GAAG,GAAG,GAAG,KACjB,MAAM,GAAG,GAAG,GAAG;UAET,aAAa,GAAG,GAAG,UAAU;WAC5B,QAAQ,gBAAgB,GAAG,GAAG;WAC9B;;;;;;iBAOM,OAAO,GAAG,WAAW,WAAW,UAAU,wBAAwB,aAAa,GAAG,GAAG;WAC3F;WACA,OAAO,SAAS,SAAS,MAAM;;;;;;iBAOzB,QAAQ,GAAG,WAAW,WAAW,UAAU,wBAAwB,aAAa,GAAG,GAAG;WAC5F;WACA,OAAO,SAAS,GAAG,YAAY;;;;;;iBAOzB,MAAM,GAAG,WAAW,WAAW,UAAU,wBAAwB,aAAa,GAAG,GAAG;WAC1F;WACA;WACA,OAAO,MAAM,GAAG,SAAS,OAAO,MAAM;;;;;;;;qBASpC,SAAU,GAAG,GAAG,GAAG,UAAU,OAAO,GAC/C,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,oBACA,OAAO,IAAI,GAAG,SAAS,MAAM,MAC5B,OAAO,GAAG,GAAG,GAAG;;;;;;;qBAQN,UAAW,GAAG,GAAG,GAAG,UAAU,OAAO,GAChD,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,oBACA,OAAO,SAAS,GAAG,IAAI,MAAM,MAC5B,QAAQ,GAAG,GAAG,GAAG;;;;;;;qBAQP,YAAa,GAAG,GAAG,GAAG,UAAU,OAAO,GAClD,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,oBACA,OAAO,MAAM,GAAG,IAAI,GAAG,OAAO,MAAM,MACnC,MAAM,GAAG,GAAG,GAAG;;;;;;;qBAQL,aAAc,GAAG,GAAG,GAAG,UAAU,OAAO,GACnD,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,oBACA,OAAO,MAAM,GAAG,IAAI,GAAG,OAAO,MAAM,MACnC,MAAM,GAAG,GAAG,GAAG;KAEb,QAAQ,MAAM,WAAW,mBAAmB,SAAS,UAAU,MAAM;KACrE,WAAW,MAAM,WAAW,mBAAmB,UAAU,SAAS,MAAM;KACxE,QAAQ,OAAO,sBAAsB,SAAS,aAAa,mBAAmB,UAAU,UAAU,MAAM;;;;;;;;;;;;;;qBAehG,OAAQ,GAAG,GAAG,GAAG,UAAU,aAAa,YAAY,cAAc,SAAS,oBAAoB;WACjG,SAAS,OAAO,GAAG,GAAG,GAAG;WACzB,WAAW;MAClB,OAAO,GAAG,IAAI,QAAQ,cAAc,IAAI,WAAW,cAAc,IAAI,QAAQ"}
+{"version":3,"file":"Expression.d.ts","names":[],"sources":["../src/Expression.ts"],"mappings":";;;;;;;;YAiDY,SAAS,GAAG,WAAW,WAAW,UAAU,kBACpD,OAAO,GAAG,GAAG,GAAG,KAChB,QAAQ,GAAG,GAAG,GAAG,KACjB,MAAM,GAAG,GAAG,GAAG;UAET,aAAa,GAAG,GAAG,UAAU;WAC5B,QAAQ,gBAAgB,GAAG,GAAG;WAC9B;;;;;;iBAOM,OAAO,GAAG,WAAW,WAAW,UAAU,wBAAwB,aAAa,GAAG,GAAG;WAC3F;WACA,OAAO,SAAS,SAAS,MAAM;;;;;;iBAOzB,QAAQ,GAAG,WAAW,WAAW,UAAU,wBAAwB,aAAa,GAAG,GAAG;WAC5F;WACA,OAAO,SAAS,GAAG,YAAY;;;;;;iBAOzB,MAAM,GAAG,WAAW,WAAW,UAAU,wBAAwB,aAAa,GAAG,GAAG;WAC1F;WACA;WACA,OAAO,MAAM,GAAG,SAAS,OAAO,MAAM;;;;;;;;qBASpC,SAAU,GAAG,GAAG,GAAG,UAAU,OAAO,GAC/C,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,oBACA,OAAO,IAAI,GAAG,SAAS,MAAM,MAC5B,OAAO,GAAG,GAAG,GAAG;;;;;;;qBAQN,UAAW,GAAG,GAAG,GAAG,UAAU,OAAO,GAChD,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,oBACA,OAAO,SAAS,GAAG,IAAI,MAAM,MAC5B,QAAQ,GAAG,GAAG,GAAG;;;;;;;qBAQP,YAAa,GAAG,GAAG,GAAG,UAAU,OAAO,GAClD,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,oBACA,OAAO,MAAM,GAAG,IAAI,GAAG,OAAO,MAAM,MACnC,MAAM,GAAG,GAAG,GAAG;;;;;;;qBAQL,aAAc,GAAG,GAAG,GAAG,UAAU,OAAO,GACnD,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,oBACA,OAAO,MAAM,GAAG,IAAI,GAAG,OAAO,MAAM,MACnC,MAAM,GAAG,GAAG,GAAG;KAEb,QAAQ,MAAM,WAAW,mBAAmB,SAAS,UAAU,MAAM;KACrE,WAAW,MAAM,WAAW,mBAAmB,UAAU,SAAS,MAAM;KACxE,QAAQ,OAAO,sBAAsB,SAAS,aAAa,mBAAmB,UAAU,UAAU,MAAM;;;;;;;;;;;;;;qBAehG,OAAQ,GAAG,GAAG,GAAG,UAAU,aAAa,YAAY,cAAc,SAAS,oBAAoB;WACjG,SAAS,OAAO,GAAG,GAAG,GAAG;WACzB,WAAW;MAClB,OAAO,GAAG,IAAI,QAAQ,cAAc,IAAI,WAAW,cAAc,IAAI,QAAQ"}