@thomasfosterau/effect-parse 0.4.0 → 0.5.0

package/README.md

@@ -169,6 +169,20 @@ const upper = Parser.make<string>((state) => {
 })
 ```
 
+A combinator that runs other parsers should be written with `Parser.combinator` instead, which hands it their steps. A `make` parser is opaque to the [compilers](#compiled-parsers), so in a compiled grammar it runs interpreted, and so does every parser it calls; a `combinator` receives their compiled steps there, so the parsers inside compile with the grammar:
+
+```ts
+const twice = <A>(p: Parser.Parser<A>) =>
+  Parser.combinator([p], ([step]) => (state) => {
+    const a = step(state)
+    if (a === Input.Fail) return Input.Fail
+    const b = step(state)
+    return b === Input.Fail ? Input.Fail : ([a, b] as const)
+  })
+
+Parser.parseSync(twice(Token.oneOf("ab")), "ba") // ["b", "a"]
+```
+
 A driver that makes many small runs over one buffer, such as a tokenizer reading one token at a time, can run a parser's `step` on an `Input.State` itself and reuse that state between runs. `state.reset(offset, { partial, context })` resets every per-run field, so afterwards the state behaves exactly like `new Input.State(state.input, { offset, partial, context })`, even after a run that failed or returned `Incomplete`:
 
 ```ts
@@ -187,14 +201,14 @@ const token = (offset: number) => {
 
 | Category | Combinators |
 | --- | --- |
-| Constructors | `succeed`, `sync`, `empty`, `fail`, `failMessage`, `reject`, `todo`, `suspend`, `make`, `location`, `eof` |
-| Mapping | `map`, `as`, `asVoid`, `asSome`, `tap`, `tryMap`, `tryMapUnknown`, `filterMap`, `filter`, `filterOrFail`, `mapParser`, `fromEntries` |
-| Sequencing | `seq`, `struct`, `zip`, `zipWith`, `zipLeft`, `zipRight`, `preceded`, `terminated`, `delimited`, `separatedPair`, `flatMap`, `gen`, `Do`/`bind`/`bindTo`/`let` |
+| Constructors | `succeed`, `sync`, `empty`, `fail`, `failAt`, `failMessage`, `reject`, `todo`, `suspend`, `make`, `location`, `eof` |
+| Mapping | `map`, `as`, `asVoid`, `asSome`, `tap`, `tryMap`, `tryMapUnknown`, `mapOrFail`, `filterMap`, `filter`, `filterOrFail`, `mapParser`, `fromEntries` |
+| Sequencing | `seq`, `seqWith`, `struct`, `zip`, `zipWith`, `zipLeft`, `zipRight`, `preceded`, `terminated`, `delimited`, `separatedPair`, `flatMap`, `gen`, `Do`/`bind`/`bindTo`/`let` |
 | Choice | `alt`, `orElse`, `orElseSucceed`, `dispatch`, `permutation` |
 | Repetition | `repeat`, `repeatTill`, `separated`, `separatedFoldl1`, `separatedFoldr1`, `fold` |
-| Control | `opt`, `optional`, `cond`, `peek`, `not`, `allConsuming` |
-| Consumed input | `taken`, `withTaken`, `span`, `withSpan` |
-| Errors | `cut`, `backtrack`, `complete`, `context`, `expected`, `mapError`, `orFail` |
+| Control | `opt`, `optional`, `cond`, `peek`, `not`, `allConsuming`, `withFastPath` |
+| Consumed input | `taken`, `withTaken`, `span`, `withSpan`, `mapSpan` |
+| Errors | `cut`, `backtrack`, `complete`, `context`, `expected`, `quiet`, `mapError`, `orFail` |
 | Services | `service`, `provideService`, `provide` |
 | Recovery | `resumeAfter`, `retryAfter` |
 | Debugging | `trace`, `named` |
@@ -250,18 +264,19 @@ export const json = Compiler.jit(Parser.preceded(ws, value))
 Parser.parse(json, text) // same Result as before, about 5 times faster
 ```
 
-On the JSON example, compiled parsing runs at 5–6 times the speed of the interpreter, for strings, UTF-8 and UTF-16 alike, and at 1–4 times the time of `JSON.parse` depending on the document (see [the design notes](docs/DESIGN.md#results)).
+On the JSON example, compiled parsing runs at 5–6 times the speed of the interpreter, for strings, UTF-8 and UTF-16 alike, and at 1–4 times the time of `JSON.parse` depending on the document (see [the design notes](docs/DESIGN.md#results)). That is 3–5 times as fast as the same JSON grammar in Chevrotain, the fastest of the other JavaScript parser libraries measured, and about 8 and 20 times as fast as in Peggy and Parsimmon ([the comparison](docs/DESIGN.md#against-other-javascript-parser-libraries)).
 
-There are two compilers, one function each:
+There are three compilers, one function each:
 
+- `Compiler.wasm` scans the input in WebAssembly and builds the value with generated JavaScript. It is the fastest on strings and bytes: on the JSON benchmark it takes 17–36% less time than the JIT. It uses the JIT for array input, for streaming, and where `WebAssembly` or `new Function` is unavailable.
 - `Compiler.jit` generates JavaScript where `new Function` is allowed, and falls back to the closure compiler where it isn't.
 - `Compiler.closure` never generates code. It is meant for pages with a Content Security Policy.
 
-A bundle contains only the compilers it calls. A program that compiles nothing bundles neither, and one that uses only `Compiler.closure` contains no `new Function`. esbuild keeps every member of a namespace imported from the root entry, so with esbuild import from the subpaths instead (`import * as Compiler from "@thomasfosterau/effect-parse/Compiler"`). Rolldown and Rollup drop unused members either way.
+A bundle contains only the compilers it calls. A program that compiles nothing bundles none, and one that uses only `Compiler.closure` contains no `new Function`. esbuild keeps every member of a namespace imported from the root entry, so with esbuild import from the subpaths instead (`import * as Compiler from "@thomasfosterau/effect-parse/Compiler"`). Rolldown and Rollup drop unused members either way.
 
-Both return the same parser. The code is built on the first run, for each kind of input, and cached. `parse`, `parseSync`, `parsePeek`, `parsePartial`, `parseEffect`, `ParserStream.parseMany` and `ParserStream.parseAll` use it, from any `offset`; `parseRecoverable` and tracing stay interpreted. A driver that keeps its own `Input.State` (a lexer reading one token at a time, say) runs the compiled code with `Parser.run(p, state)`; calling `p.step(state)` directly always runs interpreted.
+Each returns the same parser. The code is built on the first run, for each kind of input, and cached. `parse`, `parseSync`, `parsePeek`, `parsePartial`, `parseEffect`, `ParserStream.parseMany` and `ParserStream.parseAll` use it, from any `offset`; `parseRecoverable` and tracing stay interpreted. A driver that keeps its own `Input.State` (a lexer reading one token at a time, say) runs the compiled code with `Parser.run(p, state)`; calling `p.step(state)` directly always runs interpreted.
 
-Compiled code records no diagnostics. When it fails, the parser runs again interpreted, so errors are exactly the same, byte for byte. Callbacks should therefore be pure: on failing input they may run twice, and those whose results are unused may be skipped. Parsers built with `Parser.make` or `Parser.gen` run interpreted inside compiled code. See the [design notes](docs/DESIGN.md#6-compiled-parsers) for details.
+Compiled code records no diagnostics. When it fails, the parser runs again interpreted, so errors are exactly the same, byte for byte. Callbacks should therefore be pure: on failing input they may run twice, and those whose results are unused may be skipped. Parsers built with `Parser.make` or `Parser.gen` run interpreted inside compiled code; the parsers given to a `Parser.combinator` compile. See the [design notes](docs/DESIGN.md#6-compiled-parsers) for details.
 
 Some ways of writing a grammar compile to faster code than others:
 
@@ -280,8 +295,11 @@ Some ways of writing a grammar compile to faster code than others:
 - Give `Parser.dispatch` a record of cases, not a function. With a record, compiled code switches on the key and runs the chosen case compiled, and on `Token.any` or `Parser.peek(Token.any)` it switches on the next unit without building the key. The parser a function returns runs interpreted, and if the function builds it (`(c) => Parser.cut(p)`), it is built again on every run.
 - Build parsers once, outside callbacks and `Parser.gen` bodies. A parser built while parsing costs an allocation per combinator, every time, and is never compiled.
 - On token arrays (the output of a lexer), match tokens with `Token.oneOf`, `Token.noneOf`, `Token.takeWhile` and `Token.anyToken`, with a predicate or a list of tokens: the JIT calls the predicate inline. A `Parser.make` that reads `state.input[state.pos]` runs interpreted, and records a failure, with its expected list, every time it doesn't match.
-- Drive a lexer with `Parser.run` on one `Input.State` that you `reset` before each token: no run allocates a state, a `Result` or a slice, and the token parser runs compiled. When a failure only means "try something else", pass `{ diagnostics: false }`, so a failed compiled run isn't repeated interpreted to build an error you won't read.
+- Drive a lexer with `Parser.run` on one `Input.State` that you `reset` before each token: no run allocates a state, a `Result` or a slice, and the token parser runs compiled. When a failure only means "try something else", pass `{ diagnostics: false }`, so a failed compiled run isn't repeated interpreted to build an error you won't read. `Compiler.runner(p)` prepares the parser once and returns a function of the state that does what `Parser.run` does, without looking the compiled code up on every run: about 20% faster per token.
 - `Ascii.float` and `Text.float` convert numbers as they match them.
+- Where a scanner written by hand beats compiled code on the tokens that dominate an input, put it in front of the grammar with `Parser.withFastPath(grammar, fast)`: compiled code runs `fast` first, and it returns `Parser.Defer` for anything it doesn't handle. The grammar stays the specification: interpreted runs, and so every error, use it alone, and `Parser.verifyFastPath(grammar, fast, inputs)` lists where the two disagree, for a test to assert that there are none.
+- Build a string from parts with `Parser.fold(part, { init: () => "", f: (acc, x) => acc + x })` rather than `Parser.map(Parser.repeat(part), (parts) => parts.join(""))`: no array per string. A CSV grammar's all-quoted fields parse 40% faster that way.
+- Write the end of a run as `Token.takeTill` of one to three characters (`Token.takeTill('"')`, `Token.takeTill(",\r\n")`), not as a predicate: on string input, compiled code finds the end with `indexOf`, up to 9 times as fast on long runs.
 
 [`json-fast.ts`](examples/json-fast.ts) is the JSON example written this way; it runs records-heavy documents about 1.5 times as fast as [`json-text.ts`](examples/json-text.ts).
 
@@ -309,11 +327,14 @@ effect-parse tries hard to produce good messages without annotations:
 - Optional and repeated parsers leave _hints_, so after `repeat(digit)` a failure reads `expected digit or ")"`.
 - The furthest failure wins (the PEG heuristic), so a value that fails after a separator is reported where it failed.
 - `Parser.expected("value")` names a rule; `Parser.context("array")` adds "while parsing array".
+- `Parser.quiet(skip)` keeps a whitespace or comment skipper out of later errors: without it, every error after the skipper also expects whitespace.
 
 User errors are typed. `Parser.fail(e)`, `Parser.tryMap(f)` and `Parser.filterOrFail(pred, f)` add their error type to `E`, and the error arrives as `ParseError.cause`:
 
 ```ts
-class OutOfRange extends Schema.TaggedError<OutOfRange>()("OutOfRange", { value: Schema.Number }) {}
+class OutOfRange extends Schema.TaggedError<OutOfRange, { readonly brand: unique symbol }>()("OutOfRange", {
+  value: Schema.Finite
+}) {}
 
 const port = Ascii.decUint.pipe(
   Parser.filterOrFail(
@@ -324,6 +345,8 @@ const port = Ascii.decUint.pipe(
 // Parser<number, string | OutOfRange>
 ```
 
+These checks fail where the checked parser started. A check that can only run once a whole construct has parsed, but should point at the part at fault, returns `Parser.failAt(offset, error)` from a `flatMap`, with an offset from `Parser.location` or `Parser.withSpan`: a mismatched end tag is reported at the end tag, not at the start of the element.
+
 ## Streaming and partial input
 
 nom has separate `streaming` and `complete` modules. winnow marks the input as `Partial`. In effect-parse, partiality is decided by the runner, so every parser works in both modes:
@@ -513,7 +536,7 @@ On a 0.58 M-character JSON document (`vp run bench:syntax`), building the tree t
 | Module | Contents | winnow / nom equivalent |
 | --- | --- | --- |
 | `Parser` | the type, combinators, runners | `Parser` trait, `combinator` / `combinator`, `branch`, `multi`, `sequence` |
-| `Token` | `any`, `literal`, `oneOf`, `noneOf`, `take`, `takeWhile`, `takeTill`, `takeUntil`, `rest`, `range`, `codePoints` | `token` / `bytes` |
+| `Token` | `any`, `literal`, `oneOf`, `noneOf`, `take`, `takeWhile`, `takeTill`, `takeUntil`, `takeUntilAny`, `rest`, `range`, `codePoints` | `token` / `bytes` |
 | `Text` | Unicode parsers for any encoding: `string`, `utf8`, `utf16le`, `utf16be`, `latin1`, `make`; Unicode predicates | — |
 | `Encoding` | text encodings for `Text`, `sniff` | — |
 | `Ascii` | character classes, `lineEnding`, `decInt`, `decUint`, `hexUint`, `float`, `caseless`, `takeEscaped`, `escaped`, `Ascii.bytes.*` | `ascii` / `character`, `number` |
@@ -584,10 +607,13 @@ The `Nom` module provides the nom names directly, with nom's argument orders, fo
 - [`ini.ts`](examples/ini.ts): INI files with a generator-style parser
 - [`http.ts`](examples/http.ts): HTTP requests over bytes, complete and streamed
 - [`sexpr.ts`](examples/sexpr.ts): s-expressions with typed evaluation errors
+- [`jq.ts`](examples/jq.ts): a subset of [jq](https://jqlang.org): its filter language with the Pratt parser and its JSON input with the compiled `json-fast.ts` grammar, behind an `effect/cli` command in [`jq-cli.ts`](examples/jq-cli.ts); `vp run bench:jq` races it against the real `jq`
 - [`json-syntax.ts`](examples/json-syntax.ts): JSON as a syntax tree for editors, with fields, `ERROR` nodes for malformed elements, and incremental reparsing (tested in [`test/Syntax.test.ts`](test/Syntax.test.ts))
 
 `vp run bench` (from a clone) compares the JSON examples, on each encoding, with `JSON.parse`.
 
+[`examples/ripgrep`](examples/ripgrep) is a larger example, a package of its own: `erg`, a search tool with ripgrep's command line whose regex engine is built from these combinators (Rust's regex syntax parsed with effect-parse, and compiled to a backtracking matcher over UTF-8 bytes, behind ripgrep-style literal prefilters and a lazy DFA), with a harness that benchmarks it against ripgrep, grep and other search tools, and tests that compare its output with ripgrep's.
+
 ## Design
 
 [`docs/DESIGN.md`](docs/DESIGN.md) records the research into nom, winnow and Effect, and the reasoning behind each decision in this port.

package/dist/Ascii.d.ts

@@ -254,6 +254,16 @@ export declare const toFloat: (s: Input) => number;
  * @category numbers
  */
 export declare const float: Parser<number>;
+/**
+ * The overloads of {@link caseless}.
+ *
+ * @since 0.5.0
+ * @category literals
+ */
+export interface CaselessFn {
+  (literal: string): Parser<string>;
+  (literal: Uint8Array): Parser<Uint8Array, never, never, Uint8Array>;
+}
 /**
  * Matches a literal ignoring ASCII case (winnow's `Caseless`, nom's
  * `tag_no_case`). Returns the input as written.
@@ -261,10 +271,7 @@ export declare const float: Parser<number>;
  * @since 0.1.0
  * @category literals
  */
-export declare const caseless: {
-  (literal: string): Parser<string>;
-  (literal: Uint8Array): Parser<Uint8Array, never, never, Uint8Array>;
-};
+export declare const caseless: CaselessFn;
 /**
  * Recognizes a string containing escape sequences, returning the raw slice
  * (winnow's `take_escaped`, nom's `escaped`).

package/dist/Ascii.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Ascii.d.ts","names":[],"sources":["../src/Ascii.ts"],"mappings":";;;;;;;;;;qBAkDa,UAAU;;;;;;;qBAkBV,UAAU;;;;;;;qBAeV,aAAa;;;;;;;qBAmBb,aAAa;;;;;;;qBAeb,iBAAiB;;;;;;;qBAgBjB,UAAU;;;;;;;qBAkBV,eAAe;;;;;;;qBAmBf,YAAY;;;;;;;qBA4BZ,QAAQ;;;;;;;qBAQR,QAAQ;;;;;;;qBAQR,QAAQ;;;;;;;qBAQR,QAAQ;;;;;;;qBAQR,WAAW;;;;;;;qBAQX,WAAW;;;;;;;qBAQX,WAAW;;;;;;;qBAQX,WAAW;;;;;;;qBAQX,eAAe;;;;;;;qBAQf,eAAe;;;;;;;qBAQf,QAAQ;;;;;;;qBAQR,QAAQ;;;;;;;;qBASR,aAAa;;;;;;;;qBASb,aAAa;;;;;;;qBAYb,MAAM;;;;;;;qBAQN,SAAS;;;;;;;qBAQT,KAAK;;;;;;;qBAQL,YAAY;;;;;;;;;qBAcZ,gBAAgB;;qBAmChB,WAAY,kBAAgB,OAAO;;;;;;;;qBAUnC,SAAS;;;;;;;;;qBAaT,QAAQ;;;;;;;qBAaR,YAAY;;;;;;;qBAUZ,WAAW;;;;;;;;qBAgBX,SAAS;;qBA0BT,UAAU,GAAG;;;;;;;;;;;;;;;;qBAiBb,OAAO;;;;;;;;qBAgBP;GACV,kBAAkB;GAClB,SAAS,aAAa,OAAO,0BAA0B;;;;;;;;;;;;;;;;;;;;;qBAmC7C,cAAe,GAAG,GAAG,GAAG,UAAU,OAAO,GAAG,IAAI,IAAI,WAAW,OAC1E,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,0BACA,WAAW,OAAO,GAAG,IAAI,IAAI,QAC5B,OAAO,MAAM,IAAI,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI;;qBA4BhC,kBAAmB,GAAG,GAAG,GAAG,UAAU,OAAO,GAAG,IAAI,IAAI,WAAW,OAAO,GACrF,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,eAAe,OAAO,wBACtB,WAAW,OAAO,GAAG,IAAI,IAAI,KAC7B,QAAQ,OAAO,YAAY,kBAAkB,GAC7C,iBACA,UAAU,8BACT,OAAO,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA2EpB,UAAW,GAAG,GAAG,UAAU,OAAO,IAAI,IAAI,WAAW,OAChE,QAAQ,eAAe,GAAG,GAAG,IAC7B,0BACA,QAAQ,eAAe,IAAI,IAAI,QAC9B,eAAe,IAAI,IAAI,IAAI,IAAI,IAAI;;qBAsBzB,cAAe,GAAG,GAAG,UAAU,OAAO,IAAI,IAAI,WAAW,OACpE,QAAQ,eAAe,GAAG,GAAG,IAC7B,eAAe,OAAO,wBACtB,QAAQ,eAAe,IAAI,IAAI,KAC/B,iBACA,UAAU,8BACT,eAAe,IAAI,IAAI,IAAI,IAAI,IAAI;KA0DjC,MAAM,KACT,UAAU,aAAa,SAAS,SAAS,SAAS,MAC9C,OAAO,mBAAmB,aAAa,GAAG,GAAG,GAAG;;;;;;;;;;;;;;;;;;;;qBAsBzC;WACF,QAAQ,aAAa;WACrB,QAAQ,aAAa;WACrB,QAAQ,aAAa;WACrB,QAAQ,aAAa;WACrB,WAAW,aAAa;WACxB,WAAW,aAAa;WACxB,WAAW,aAAa;WACxB,WAAW,aAAa;WACxB,eAAe,aAAa;WAC5B,eAAe,aAAa;WAC5B,QAAQ,aAAa;WACrB,QAAQ,aAAa;WACrB,aAAa,aAAa;WAC1B,aAAa,aAAa;WAC1B,MAAM,OAAO,0BAA0B;WACvC,SAAS,OAAO,0BAA0B;WAC1C,KAAK,OAAO,0BAA0B;WACtC,YAAY,OAAO,0BAA0B;WAC7C,gBAAgB,aAAa;WAC7B,SAAS,8BAA8B;WACvC,QAAQ,8BAA8B;WACtC,YAAY,6BAA6B;WACzC,WAAW,6BAA6B;WACxC,SAAS,8BAA8B;WACvC,OAAO,6BAA6B"}
+{"version":3,"file":"Ascii.d.ts","names":[],"sources":["../src/Ascii.ts"],"mappings":"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"}

package/dist/Ascii.js

@@ -560,6 +560,11 @@ const escapedImpl = (normal, matchControl, escape, control, encoding) => {
 	});
 };
 /**
+* Gives a value the type of another view of the same parsers (see
+* {@link bytes}).
+*/
+const retype = (value) => value;
+/**
 * The parsers of this module, typed for `Uint8Array` input. Slices are
 * returned as `Uint8Array`s.
 *
@@ -582,7 +587,7 @@ const bytes = /*#__PURE__*/ (() => {
 	const lit = (s) => Token$1.literal(new TextEncoder().encode(s));
 	const crlfB = lit("\r\n");
 	const newlineB = lit("\n");
-	return {
+	const views = {
 		alpha0,
 		alpha1,
 		digit0,
@@ -609,6 +614,7 @@ const bytes = /*#__PURE__*/ (() => {
 		hexUint,
 		float
 	};
+	return retype(views);
 })();
 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 };
 

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 { 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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"}
+{"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 = (\n  set: Token.StringTokenSet,\n  min: 0 | 1,\n  description: string,\n  kind: ErrorKind,\n  hint = true\n): Parser<string> => 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      // SAFETY: `Ascii` parsers run on strings or `Uint8Array`s, and `isString` is `inputKind === 0`, set only for a string\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        // SAFETY: `Ascii` parsers run on strings or `Uint8Array`s, and `isString` is `inputKind === 0`, set only for a string\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    // SAFETY: on string input, the input type of a `Parser<string>`, the slice is a string (`bytes` retypes it for bytes)\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\"))\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 * The overloads of {@link caseless}.\n *\n * @since 0.5.0\n * @category literals\n */\nexport interface CaselessFn {\n  (literal: string): Parser<string>\n  (literal: Uint8Array): Parser<Uint8Array, never, never, Uint8Array>\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: CaselessFn = (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  // SAFETY: escapes are read from strings or `Uint8Array`s, and `inputKind` 0 is set only for a string\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    // SAFETY: the parser runs on input of type `I & I2`, and `State.slice` returns that input's own slice type\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        // SAFETY: under its own `key`, this parser saves only a resume offset (`suspendAt`) or a `Done`\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          // SAFETY: a `Done` saved under this parser's `key` holds the `S` it returned\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        // SAFETY: under its own `key`, this parser saves only an `EscapedCheckpoint` (`suspendAt`) or a `Done`\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          // SAFETY: a `Done` saved under this parser's `key` holds the string it returned\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 * Gives a value the type of another view of the same parsers (see\n * {@link bytes}).\n */\nconst retype = <T>(value: unknown): T =>\n  // SAFETY: callers pass the byte views' parsers, which are the string parsers themselves (below)\n  value as T\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  const views = {\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  }\n  // SAFETY: the string parsers run on byte input unchanged (their slices of a `Uint8Array` are `Uint8Array`s),\n  // so only their declared input and slice types differ from the byte views'\n  return retype<typeof bytes>(views)\n})()\n"],"mappings":"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"}

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;;;;;;;qBAmEC,IAAI,6BAA6B;;;;;;;qBAQjC,IAAI,6BAA6B;;qBAGjC,OAAO,6BAA6B;;qBAMpC,OAAO,6BAA6B;;qBAMpC,OAAO,6BAA6B;;qBAMpC,OAAO,6BAA6B;;qBAMpC,OAAO,6BAA6B;;qBAMpC,OAAO,6BAA6B;;qBAMpC,OAAO,6BAA6B;;qBAMpC,OAAO,6BAA6B;;qBAMpC,OAAO,6BAA6B;;qBAMpC,OAAO,6BAA6B;;qBAMpC,OAAO,6BAA6B;;qBAMpC,OAAO,6BAA6B;;qBAMpC,OAAO,6BAA6B;;qBAMpC,OAAO,6BAA6B;;qBAMpC,OAAO,6BAA6B;;qBAMpC,OAAO,6BAA6B;;qBAMpC,QAAQ,6BAA6B;;qBAMrC,QAAQ,6BAA6B;;qBAMrC,QAAQ,6BAA6B;;qBAMrC,QAAQ,6BAA6B;;qBAOrC,OAAO,6BAA6B;;qBAMpC,OAAO,6BAA6B;;qBAMpC,OAAO,6BAA6B;;qBAMpC,OAAO,6BAA6B;;;;;;;qBAiBpC,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;;;;;;;;qBAmC1D,aAAc,GAAG,GAAG,UAAU,QAAQ,YACjD,OAAO,wBAAwB,GAAG,GAAG,OACpC,OAAO,MAAM,IAAI,GAAG,GAAG;;;;;;;;qBAuBb,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;;;;;;;;;qBAc3B,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

@@ -24,34 +24,44 @@ import { bits } from "./Bits.js";
 * @since 0.1.0
 */
 const nativeLittle = (/*#__PURE__*/ new Uint8Array((/*#__PURE__*/ new Uint16Array([1])).buffer))[0] === 1;
+/**
+* A `DataView` of a state's bytes, for the numbers integer arithmetic can't
+* read: created once per state (whose input never changes), as one per
+* read cost most of a number's time.
+*/
+const viewOf = (state) => {
+	const b = state.input;
+	return state.view ??= new DataView(b.buffer, b.byteOffset, b.byteLength);
+};
+/** A {@link Read} through the state's view. */
+const viewed = (read) => (_, o, s) => read(viewOf(s), o);
 const fixed = (size, name, read) => {
 	const expected = [`${size} byte${size === 1 ? "" : "s"}`];
-	return P.make((state) => {
+	return P.described((state) => {
 		const pos = state.pos;
 		const avail = state.end - pos;
 		if (avail < size) return state.eoi("Token", expected, size - avail);
-		const bytes = state.input;
-		const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
 		state.pos = pos + size;
-		return read(view, pos);
-	}, name);
+		return read(state.input, pos, state);
+	}, name, {
+		_tag: "Fixed",
+		size,
+		read
+	});
 };
-const readU24 = (little) => (v, o) => little ? v.getUint8(o) | v.getUint8(o + 1) << 8 | v.getUint8(o + 2) << 16 : v.getUint8(o) << 16 | v.getUint8(o + 1) << 8 | v.getUint8(o + 2);
+const readU24 = (little) => (b, o) => little ? b[o] | b[o + 1] << 8 | b[o + 2] << 16 : b[o] << 16 | b[o + 1] << 8 | b[o + 2];
 const readI24 = (little) => {
 	const u = readU24(little);
-	return (v, o) => {
-		const x = u(v, o);
-		return x & 8388608 ? x - 16777216 : x;
-	};
+	return (b, o, s) => u(b, o, s) << 8 >> 8;
 };
-const readU128 = (little) => (v, o) => {
+const readU128 = (little) => viewed((v, o) => {
 	const a = v.getBigUint64(o, little);
 	const b = v.getBigUint64(o + 8, little);
 	return little ? b << 64n | a : a << 64n | b;
-};
+});
 const readI128 = (little) => {
 	const u = readU128(little);
-	return (v, o) => BigInt.asIntN(128, u(v, o));
+	return (b, o, s) => BigInt.asIntN(128, u(b, o, s));
 };
 /**
 * An unsigned byte.
@@ -59,22 +69,22 @@ const readI128 = (little) => {
 * @since 0.1.0
 * @category integers
 */
-const u8 = /*#__PURE__*/ fixed(1, "u8", (v, o) => v.getUint8(o));
+const u8 = /*#__PURE__*/ fixed(1, "u8", (b, o) => b[o]);
 /**
 * A signed byte.
 *
 * @since 0.1.0
 * @category integers
 */
-const i8 = /*#__PURE__*/ fixed(1, "i8", (v, o) => v.getInt8(o));
+const i8 = /*#__PURE__*/ fixed(1, "i8", (b, o) => b[o] << 24 >> 24);
 /** @since 0.1.0 @category integers */
-const beU16 = /*#__PURE__*/ fixed(2, "beU16", (v, o) => v.getUint16(o, false));
+const beU16 = /*#__PURE__*/ fixed(2, "beU16", (b, o) => b[o] << 8 | b[o + 1]);
 /** @since 0.1.0 @category integers */
-const leU16 = /*#__PURE__*/ fixed(2, "leU16", (v, o) => v.getUint16(o, true));
+const leU16 = /*#__PURE__*/ fixed(2, "leU16", (b, o) => b[o] | b[o + 1] << 8);
 /** @since 0.1.0 @category integers */
-const beI16 = /*#__PURE__*/ fixed(2, "beI16", (v, o) => v.getInt16(o, false));
+const beI16 = /*#__PURE__*/ fixed(2, "beI16", (b, o) => (b[o] << 8 | b[o + 1]) << 16 >> 16);
 /** @since 0.1.0 @category integers */
-const leI16 = /*#__PURE__*/ fixed(2, "leI16", (v, o) => v.getInt16(o, true));
+const leI16 = /*#__PURE__*/ fixed(2, "leI16", (b, o) => (b[o] | b[o + 1] << 8) << 16 >> 16);
 /** @since 0.1.0 @category integers */
 const beU24 = /*#__PURE__*/ fixed(3, "beU24", /*#__PURE__*/ readU24(false));
 /** @since 0.1.0 @category integers */
@@ -84,21 +94,21 @@ const beI24 = /*#__PURE__*/ fixed(3, "beI24", /*#__PURE__*/ readI24(false));
 /** @since 0.1.0 @category integers */
 const leI24 = /*#__PURE__*/ fixed(3, "leI24", /*#__PURE__*/ readI24(true));
 /** @since 0.1.0 @category integers */
-const beU32 = /*#__PURE__*/ fixed(4, "beU32", (v, o) => v.getUint32(o, false));
+const beU32 = /*#__PURE__*/ fixed(4, "beU32", (b, o) => (b[o] << 24 | b[o + 1] << 16 | b[o + 2] << 8 | b[o + 3]) >>> 0);
 /** @since 0.1.0 @category integers */
-const leU32 = /*#__PURE__*/ fixed(4, "leU32", (v, o) => v.getUint32(o, true));
+const leU32 = /*#__PURE__*/ fixed(4, "leU32", (b, o) => (b[o] | b[o + 1] << 8 | b[o + 2] << 16 | b[o + 3] << 24) >>> 0);
 /** @since 0.1.0 @category integers */
-const beI32 = /*#__PURE__*/ fixed(4, "beI32", (v, o) => v.getInt32(o, false));
+const beI32 = /*#__PURE__*/ fixed(4, "beI32", (b, o) => b[o] << 24 | b[o + 1] << 16 | b[o + 2] << 8 | b[o + 3]);
 /** @since 0.1.0 @category integers */
-const leI32 = /*#__PURE__*/ fixed(4, "leI32", (v, o) => v.getInt32(o, true));
+const leI32 = /*#__PURE__*/ fixed(4, "leI32", (b, o) => b[o] | b[o + 1] << 8 | b[o + 2] << 16 | b[o + 3] << 24);
 /** @since 0.1.0 @category integers */
-const beU64 = /*#__PURE__*/ fixed(8, "beU64", (v, o) => v.getBigUint64(o, false));
+const beU64 = /*#__PURE__*/ fixed(8, "beU64", /*#__PURE__*/ viewed((v, o) => v.getBigUint64(o, false)));
 /** @since 0.1.0 @category integers */
-const leU64 = /*#__PURE__*/ fixed(8, "leU64", (v, o) => v.getBigUint64(o, true));
+const leU64 = /*#__PURE__*/ fixed(8, "leU64", /*#__PURE__*/ viewed((v, o) => v.getBigUint64(o, true)));
 /** @since 0.1.0 @category integers */
-const beI64 = /*#__PURE__*/ fixed(8, "beI64", (v, o) => v.getBigInt64(o, false));
+const beI64 = /*#__PURE__*/ fixed(8, "beI64", /*#__PURE__*/ viewed((v, o) => v.getBigInt64(o, false)));
 /** @since 0.1.0 @category integers */
-const leI64 = /*#__PURE__*/ fixed(8, "leI64", (v, o) => v.getBigInt64(o, true));
+const leI64 = /*#__PURE__*/ fixed(8, "leI64", /*#__PURE__*/ viewed((v, o) => v.getBigInt64(o, true)));
 /** @since 0.1.0 @category integers */
 const beU128 = /*#__PURE__*/ fixed(16, "beU128", /*#__PURE__*/ readU128(false));
 /** @since 0.1.0 @category integers */
@@ -108,13 +118,13 @@ const beI128 = /*#__PURE__*/ fixed(16, "beI128", /*#__PURE__*/ readI128(false));
 /** @since 0.1.0 @category integers */
 const leI128 = /*#__PURE__*/ fixed(16, "leI128", /*#__PURE__*/ readI128(true));
 /** @since 0.1.0 @category floats */
-const beF32 = /*#__PURE__*/ fixed(4, "beF32", (v, o) => v.getFloat32(o, false));
+const beF32 = /*#__PURE__*/ fixed(4, "beF32", /*#__PURE__*/ viewed((v, o) => v.getFloat32(o, false)));
 /** @since 0.1.0 @category floats */
-const leF32 = /*#__PURE__*/ fixed(4, "leF32", (v, o) => v.getFloat32(o, true));
+const leF32 = /*#__PURE__*/ fixed(4, "leF32", /*#__PURE__*/ viewed((v, o) => v.getFloat32(o, true)));
 /** @since 0.1.0 @category floats */
-const beF64 = /*#__PURE__*/ fixed(8, "beF64", (v, o) => v.getFloat64(o, false));
+const beF64 = /*#__PURE__*/ fixed(8, "beF64", /*#__PURE__*/ viewed((v, o) => v.getFloat64(o, false)));
 /** @since 0.1.0 @category floats */
-const leF64 = /*#__PURE__*/ fixed(8, "leF64", (v, o) => v.getFloat64(o, true));
+const leF64 = /*#__PURE__*/ fixed(8, "leF64", /*#__PURE__*/ viewed((v, o) => v.getFloat64(o, true)));
 const byEndian = (big, little) => (endian) => endian === "big" ? big : endian === "little" ? little : nativeLittle ? little : big;
 /**
 * An unsigned 16-bit integer in the given byte order (winnow's `u16`).
@@ -146,6 +156,25 @@ const f32 = /*#__PURE__*/ byEndian(beF32, leF32);
 /** @since 0.1.0 @category floats */
 const f64 = /*#__PURE__*/ byEndian(beF64, leF64);
 const toCount = (n) => Predicate.isBigInt(n) ? Number(n) : n;
+/** How many counts {@link byCount} keeps the parsers of. */
+const CountCache = 256;
+/**
+* `build`, keeping the parsers it built for the first {@link CountCache}
+* counts seen: length-prefixed data repeats a few lengths, and building a
+* parser per value cost several times the parse.
+*/
+const byCount = (build) => {
+	const built = /* @__PURE__ */ new Map();
+	return (n) => {
+		const count = toCount(n);
+		let a = built.get(count);
+		if (a === void 0) {
+			a = build(count);
+			if (built.size < CountCache) built.set(count, a);
+		}
+		return a;
+	};
+};
 /**
 * Parses a length with `count`, then takes that many tokens (winnow's
 * `length_take`, nom's `length_data`).
@@ -154,11 +183,11 @@ const toCount = (n) => Predicate.isBigInt(n) ? Number(n) : n;
 * @category length-prefixed
 */
 const lengthTake = (count) => {
-	const countStep = count.step;
-	return P.make((state) => {
+	const take = byCount((n) => Token$1.take(n).step);
+	return P.combinator([count], ([countStep]) => (state) => {
 		const n = countStep(state);
 		if (n === Fail) return Fail;
-		return Token$1.take(toCount(n)).step(state);
+		return take(n)(state);
 	}, "lengthTake");
 };
 /**
@@ -168,7 +197,7 @@ const lengthTake = (count) => {
 * @since 0.1.0
 * @category length-prefixed
 */
-const lengthRepeat = (count, parser) => P.flatMap(count, (n) => P.repeat(parser, toCount(n)));
+const lengthRepeat = (count, parser) => P.flatMap(count, byCount((n) => P.repeat(parser, n)));
 /**
 * Parses a length with `count`, takes that many tokens, and applies
 * `parser` to them (winnow's `length_and_then`, nom's `length_value`).