@thomasfosterau/effect-parse 0.4.1 → 0.6.0

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 { controlCode } from \"./internal/node.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\n/** The first UTF-16 unit of a control character: what `atControl` compares with a string's units. */\nconst firstUnit = (s: string): number => s.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, firstUnit)\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, firstUnit)\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

@@ -101,7 +101,9 @@ export declare const f32: (endian: Endianness) => Parser<number, never, never, U
 export declare const f64: (endian: Endianness) => Parser<number, never, never, Uint8Array>;
 /**
  * Parses a length with `count`, then takes that many tokens (winnow's
- * `length_take`, nom's `length_data`).
+ * `length_take`, nom's `length_data`). A length that is not a non-negative
+ * integer (a negative `i8`, a fractional float) fails the parse at the
+ * length.
  *
  * @since 0.1.0
  * @category length-prefixed
@@ -109,7 +111,8 @@ export declare const f64: (endian: Endianness) => Parser<number, never, never, U
 export declare const lengthTake: <E, R, I extends Input = Uint8Array>(count: Parser<number | bigint, E, R, I>) => Parser<Slice<I>, E, R, I>;
 /**
  * Parses a length with `count`, then applies `parser` that many times
- * (winnow's `length_repeat`, nom's `length_count`).
+ * (winnow's `length_repeat`, nom's `length_count`). A length that is not a
+ * non-negative integer fails the parse at the length.
  *
  * @since 0.1.0
  * @category length-prefixed

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;;;;;;;;;;qBAiD1D,aAAc,GAAG,GAAG,UAAU,QAAQ,YACjD,OAAO,wBAAwB,GAAG,GAAG,OACpC,OAAO,MAAM,IAAI,GAAG,GAAG;;;;;;;;;qBA8Bb,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`).
@@ -145,30 +155,66 @@ const i128 = /*#__PURE__*/ byEndian(beI128, leI128);
 const f32 = /*#__PURE__*/ byEndian(beF32, leF32);
 /** @since 0.1.0 @category floats */
 const f64 = /*#__PURE__*/ byEndian(beF64, leF64);
+const MaxCount = /*#__PURE__*/ BigInt(Number.MAX_SAFE_INTEGER);
+/**
+* Whether a length read from the input is a count: a non-negative integer
+* of at most `Number.MAX_SAFE_INTEGER`. A signed, fractional or `NaN`
+* length is the input's to choose, so it fails the parse where it was read
+* (as `Parser.filter` does) and never reaches `Token.take` or
+* `Parser.repeat`, which throw on one.
+*/
+const isCount = (n) => Predicate.isBigInt(n) ? n >= 0n && n <= MaxCount : Number.isSafeInteger(n) && n >= 0;
 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`).
+* `length_take`, nom's `length_data`). A length that is not a non-negative
+* integer (a negative `i8`, a fractional float) fails the parse at the
+* length.
 *
 * @since 0.1.0
 * @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 start = state.pos;
 		const n = countStep(state);
 		if (n === Fail) return Fail;
-		return Token$1.take(toCount(n)).step(state);
+		if (!isCount(n)) {
+			state.rewind(start);
+			return state.backtrack("Verify");
+		}
+		return take(n)(state);
 	}, "lengthTake");
 };
 /**
 * Parses a length with `count`, then applies `parser` that many times
-* (winnow's `length_repeat`, nom's `length_count`).
+* (winnow's `length_repeat`, nom's `length_count`). A length that is not a
+* non-negative integer fails the parse at the length.
 *
 * @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(P.filter(count, isCount), 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`).

package/dist/Binary.js.map

@@ -1 +1 @@
-{"version":3,"file":"Binary.js","names":["Token"],"sources":["../src/Binary.ts"],"sourcesContent":["/**\n * Parsers for binary formats: fixed-width integers and floats in either\n * byte order, and length-prefixed data (winnow's `binary` module, nom's\n * `number` and `multi::length_*` parsers).\n *\n * Integers up to 32 bits are returned as `number`, wider integers as\n * `bigint`.\n *\n * @example\n * ```ts\n * import { Binary, Parser } from \"@thomasfosterau/effect-parse\"\n *\n * // A length-prefixed (u16 big-endian) payload\n * const frame = Binary.lengthTake(Binary.beU16)\n * Parser.parse(frame, new Uint8Array([0, 2, 0xca, 0xfe])) // Uint8Array [0xca, 0xfe]\n * ```\n *\n * @since 0.1.0\n */\nimport * as Predicate from \"effect/Predicate\"\nimport type { Input, Slice, State } from \"./Input.js\"\nimport { Fail } from \"./Input.js\"\nimport type { Parser } from \"./Parser.js\"\nimport * as P from \"./Parser.js\"\nimport * as Token from \"./Token.js\"\n\nexport {\n  /**\n   * Runs a bit-level parser on byte input. See the `Bits` module.\n   *\n   * @since 0.1.0\n   * @category bits\n   */\n  bits\n} from \"./Bits.js\"\n\n/**\n * A byte order. `\"native\"` is the byte order of the current platform.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Endianness = \"big\" | \"little\" | \"native\"\n\nconst nativeLittle = /*#__PURE__*/ new Uint8Array(/*#__PURE__*/ new Uint16Array([1]).buffer)[0] === 1\n\nconst fixed = <A>(\n  size: number,\n  name: string,\n  read: (view: DataView, offset: number) => A\n): Parser<A, never, never, Uint8Array> => {\n  const expected = [`${size} byte${size === 1 ? \"\" : \"s\"}`]\n  return P.make((state: State<Uint8Array>) => {\n    const pos = state.pos\n    const avail = state.end - pos\n    if (avail < size) return state.eoi(\"Token\", expected, size - avail)\n    const bytes = state.input\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)\n    state.pos = pos + size\n    return read(view, pos)\n  }, name)\n}\n\nconst readU24 = (little: boolean) => (v: DataView, o: number) =>\n  little\n    ? v.getUint8(o) | (v.getUint8(o + 1) << 8) | (v.getUint8(o + 2) << 16)\n    : (v.getUint8(o) << 16) | (v.getUint8(o + 1) << 8) | v.getUint8(o + 2)\n\nconst readI24 = (little: boolean) => {\n  const u = readU24(little)\n  return (v: DataView, o: number) => {\n    const x = u(v, o)\n    return x & 0x800000 ? x - 0x1000000 : x\n  }\n}\n\nconst readU128 = (little: boolean) => (v: DataView, o: number) => {\n  const a = v.getBigUint64(o, little)\n  const b = v.getBigUint64(o + 8, little)\n  return little ? (b << 64n) | a : (a << 64n) | b\n}\n\nconst readI128 = (little: boolean) => {\n  const u = readU128(little)\n  return (v: DataView, o: number) => BigInt.asIntN(128, u(v, o))\n}\n\n/**\n * An unsigned byte.\n *\n * @since 0.1.0\n * @category integers\n */\nexport const u8: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(1, \"u8\", (v, o) => v.getUint8(o))\n\n/**\n * A signed byte.\n *\n * @since 0.1.0\n * @category integers\n */\nexport const i8: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(1, \"i8\", (v, o) => v.getInt8(o))\n\n/** @since 0.1.0 @category integers */\nexport const beU16: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(2, \"beU16\", (v, o) =>\n  v.getUint16(o, false)\n)\n/** @since 0.1.0 @category integers */\nexport const leU16: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(2, \"leU16\", (v, o) =>\n  v.getUint16(o, true)\n)\n/** @since 0.1.0 @category integers */\nexport const beI16: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(2, \"beI16\", (v, o) =>\n  v.getInt16(o, false)\n)\n/** @since 0.1.0 @category integers */\nexport const leI16: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(2, \"leI16\", (v, o) =>\n  v.getInt16(o, true)\n)\n/** @since 0.1.0 @category integers */\nexport const beU24: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  3,\n  \"beU24\",\n  /*#__PURE__*/ readU24(false)\n)\n/** @since 0.1.0 @category integers */\nexport const leU24: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  3,\n  \"leU24\",\n  /*#__PURE__*/ readU24(true)\n)\n/** @since 0.1.0 @category integers */\nexport const beI24: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  3,\n  \"beI24\",\n  /*#__PURE__*/ readI24(false)\n)\n/** @since 0.1.0 @category integers */\nexport const leI24: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  3,\n  \"leI24\",\n  /*#__PURE__*/ readI24(true)\n)\n/** @since 0.1.0 @category integers */\nexport const beU32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(4, \"beU32\", (v, o) =>\n  v.getUint32(o, false)\n)\n/** @since 0.1.0 @category integers */\nexport const leU32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(4, \"leU32\", (v, o) =>\n  v.getUint32(o, true)\n)\n/** @since 0.1.0 @category integers */\nexport const beI32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(4, \"beI32\", (v, o) =>\n  v.getInt32(o, false)\n)\n/** @since 0.1.0 @category integers */\nexport const leI32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(4, \"leI32\", (v, o) =>\n  v.getInt32(o, true)\n)\n/** @since 0.1.0 @category integers */\nexport const beU64: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(8, \"beU64\", (v, o) =>\n  v.getBigUint64(o, false)\n)\n/** @since 0.1.0 @category integers */\nexport const leU64: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(8, \"leU64\", (v, o) =>\n  v.getBigUint64(o, true)\n)\n/** @since 0.1.0 @category integers */\nexport const beI64: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(8, \"beI64\", (v, o) =>\n  v.getBigInt64(o, false)\n)\n/** @since 0.1.0 @category integers */\nexport const leI64: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(8, \"leI64\", (v, o) =>\n  v.getBigInt64(o, true)\n)\n/** @since 0.1.0 @category integers */\nexport const beU128: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  16,\n  \"beU128\",\n  /*#__PURE__*/ readU128(false)\n)\n/** @since 0.1.0 @category integers */\nexport const leU128: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  16,\n  \"leU128\",\n  /*#__PURE__*/ readU128(true)\n)\n/** @since 0.1.0 @category integers */\nexport const beI128: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  16,\n  \"beI128\",\n  /*#__PURE__*/ readI128(false)\n)\n/** @since 0.1.0 @category integers */\nexport const leI128: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  16,\n  \"leI128\",\n  /*#__PURE__*/ readI128(true)\n)\n\n/** @since 0.1.0 @category floats */\nexport const beF32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(4, \"beF32\", (v, o) =>\n  v.getFloat32(o, false)\n)\n/** @since 0.1.0 @category floats */\nexport const leF32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(4, \"leF32\", (v, o) =>\n  v.getFloat32(o, true)\n)\n/** @since 0.1.0 @category floats */\nexport const beF64: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(8, \"beF64\", (v, o) =>\n  v.getFloat64(o, false)\n)\n/** @since 0.1.0 @category floats */\nexport const leF64: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(8, \"leF64\", (v, o) =>\n  v.getFloat64(o, true)\n)\n\nconst byEndian =\n  <A>(big: A, little: A) =>\n  (endian: Endianness): A =>\n    endian === \"big\" ? big : endian === \"little\" ? little : nativeLittle ? little : big\n\n/**\n * An unsigned 16-bit integer in the given byte order (winnow's `u16`).\n *\n * @since 0.1.0\n * @category integers\n */\nexport const u16: (endian: Endianness) => Parser<number, never, never, Uint8Array> = /*#__PURE__*/ byEndian(\n  beU16,\n  leU16\n)\n/** @since 0.1.0 @category integers */\nexport const i16: (endian: Endianness) => Parser<number, never, never, Uint8Array> = /*#__PURE__*/ byEndian(\n  beI16,\n  leI16\n)\n/** @since 0.1.0 @category integers */\nexport const u24: (endian: Endianness) => Parser<number, never, never, Uint8Array> = /*#__PURE__*/ byEndian(\n  beU24,\n  leU24\n)\n/** @since 0.1.0 @category integers */\nexport const i24: (endian: Endianness) => Parser<number, never, never, Uint8Array> = /*#__PURE__*/ byEndian(\n  beI24,\n  leI24\n)\n/** @since 0.1.0 @category integers */\nexport const u32: (endian: Endianness) => Parser<number, never, never, Uint8Array> = /*#__PURE__*/ byEndian(\n  beU32,\n  leU32\n)\n/** @since 0.1.0 @category integers */\nexport const i32: (endian: Endianness) => Parser<number, never, never, Uint8Array> = /*#__PURE__*/ byEndian(\n  beI32,\n  leI32\n)\n/** @since 0.1.0 @category integers */\nexport const u64: (endian: Endianness) => Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ byEndian(\n  beU64,\n  leU64\n)\n/** @since 0.1.0 @category integers */\nexport const i64: (endian: Endianness) => Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ byEndian(\n  beI64,\n  leI64\n)\n/** @since 0.1.0 @category integers */\nexport const u128: (endian: Endianness) => Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ byEndian(\n  beU128,\n  leU128\n)\n/** @since 0.1.0 @category integers */\nexport const i128: (endian: Endianness) => Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ byEndian(\n  beI128,\n  leI128\n)\n/** @since 0.1.0 @category floats */\nexport const f32: (endian: Endianness) => Parser<number, never, never, Uint8Array> = /*#__PURE__*/ byEndian(\n  beF32,\n  leF32\n)\n/** @since 0.1.0 @category floats */\nexport const f64: (endian: Endianness) => Parser<number, never, never, Uint8Array> = /*#__PURE__*/ byEndian(\n  beF64,\n  leF64\n)\n\nconst toCount = (n: number | bigint): number => (Predicate.isBigInt(n) ? Number(n) : n)\n\n/**\n * Parses a length with `count`, then takes that many tokens (winnow's\n * `length_take`, nom's `length_data`).\n *\n * @since 0.1.0\n * @category length-prefixed\n */\nexport const lengthTake = <E, R, I extends Input = Uint8Array>(\n  count: Parser<number | bigint, E, R, I>\n): Parser<Slice<I>, E, R, I> => {\n  const countStep = count.step\n  return P.make((state: State<I>) => {\n    const n = countStep(state)\n    if (n === Fail) return Fail\n    return (Token.take<I>(toCount(n)).step as any)(state)\n  }, \"lengthTake\")\n}\n\n/**\n * Parses a length with `count`, then applies `parser` that many times\n * (winnow's `length_repeat`, nom's `length_count`).\n *\n * @since 0.1.0\n * @category length-prefixed\n */\nexport const lengthRepeat = <E, R, I extends Input, A, E2, R2, I2 extends Input>(\n  count: Parser<number | bigint, E, R, I>,\n  parser: Parser<A, E2, R2, I2>\n): Parser<Array<A>, E | E2, R | R2, I & I2> =>\n  P.flatMap(count, (n) => P.repeat(parser, toCount(n)) as Parser<Array<A>, E2, R2, I2>)\n\n/**\n * Parses a length with `count`, takes that many tokens, and applies\n * `parser` to them (winnow's `length_and_then`, nom's `length_value`).\n * `parser` does not need to consume the whole slice.\n *\n * @since 0.1.0\n * @category length-prefixed\n */\nexport const lengthAndThen = <E, R, I extends Input, A, E2, R2>(\n  count: Parser<number | bigint, E, R, I>,\n  parser: Parser<A, E2, R2, Slice<I> & Input>\n): Parser<A, E | E2, R | R2, I> =>\n  P.mapParser(lengthTake(count) as Parser<Slice<I> & Input, E, R, I>, P.complete(parser))\n"],"mappings":"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"}
+{"version":3,"file":"Binary.js","names":["Token"],"sources":["../src/Binary.ts"],"sourcesContent":["/**\n * Parsers for binary formats: fixed-width integers and floats in either\n * byte order, and length-prefixed data (winnow's `binary` module, nom's\n * `number` and `multi::length_*` parsers).\n *\n * Integers up to 32 bits are returned as `number`, wider integers as\n * `bigint`.\n *\n * @example\n * ```ts\n * import { Binary, Parser } from \"@thomasfosterau/effect-parse\"\n *\n * // A length-prefixed (u16 big-endian) payload\n * const frame = Binary.lengthTake(Binary.beU16)\n * Parser.parse(frame, new Uint8Array([0, 2, 0xca, 0xfe])) // Uint8Array [0xca, 0xfe]\n * ```\n *\n * @since 0.1.0\n */\nimport * as Predicate from \"effect/Predicate\"\nimport type { Input, Slice, State } from \"./Input.js\"\nimport { Fail } from \"./Input.js\"\nimport type { Parser } from \"./Parser.js\"\nimport * as P from \"./Parser.js\"\nimport * as Token from \"./Token.js\"\n\nexport {\n  /**\n   * Runs a bit-level parser on byte input. See the `Bits` module.\n   *\n   * @since 0.1.0\n   * @category bits\n   */\n  bits\n} from \"./Bits.js\"\n\n/**\n * A byte order. `\"native\"` is the byte order of the current platform.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Endianness = \"big\" | \"little\" | \"native\"\n\nconst nativeLittle = /*#__PURE__*/ new Uint8Array(/*#__PURE__*/ new Uint16Array([1]).buffer)[0] === 1\n\n/** Reads a number at an offset of a state's bytes. */\ntype Read<A> = (bytes: Uint8Array, offset: number, state: State<Uint8Array>) => A\n\n/**\n * A `DataView` of a state's bytes, for the numbers integer arithmetic can't\n * read: created once per state (whose input never changes), as one per\n * read cost most of a number's time.\n */\nconst viewOf = (state: State<Uint8Array>): DataView => {\n  const b = state.input\n  return (state.view ??= new DataView(b.buffer, b.byteOffset, b.byteLength))\n}\n\n/** A {@link Read} through the state's view. */\nconst viewed =\n  <A>(read: (view: DataView, offset: number) => A): Read<A> =>\n  (_, o, s) =>\n    read(viewOf(s), o)\n\nconst fixed = <A>(size: number, name: string, read: Read<A>): Parser<A, never, never, Uint8Array> => {\n  const expected = [`${size} byte${size === 1 ? \"\" : \"s\"}`]\n  return P.described(\n    (state: State<Uint8Array>) => {\n      const pos = state.pos\n      const avail = state.end - pos\n      if (avail < size) return state.eoi(\"Token\", expected, size - avail)\n      state.pos = pos + size\n      return read(state.input, pos, state)\n    },\n    name,\n    { _tag: \"Fixed\", size, read }\n  )\n}\n\n// Integers of up to 32 bits are read from the bytes; the rest through a view\nconst readU24 =\n  (little: boolean): Read<number> =>\n  (b, o) =>\n    little ? b[o] | (b[o + 1] << 8) | (b[o + 2] << 16) : (b[o] << 16) | (b[o + 1] << 8) | b[o + 2]\n\nconst readI24 = (little: boolean): Read<number> => {\n  const u = readU24(little)\n  return (b, o, s) => (u(b, o, s) << 8) >> 8\n}\n\nconst readU128 = (little: boolean): Read<bigint> =>\n  viewed((v, o) => {\n    const a = v.getBigUint64(o, little)\n    const b = v.getBigUint64(o + 8, little)\n    return little ? (b << 64n) | a : (a << 64n) | b\n  })\n\nconst readI128 = (little: boolean): Read<bigint> => {\n  const u = readU128(little)\n  return (b, o, s) => BigInt.asIntN(128, u(b, o, s))\n}\n\n/**\n * An unsigned byte.\n *\n * @since 0.1.0\n * @category integers\n */\nexport const u8: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(1, \"u8\", (b, o) => b[o])\n\n/**\n * A signed byte.\n *\n * @since 0.1.0\n * @category integers\n */\nexport const i8: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(1, \"i8\", (b, o) => (b[o] << 24) >> 24)\n\n/** @since 0.1.0 @category integers */\nexport const beU16: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  2,\n  \"beU16\",\n  (b, o) => (b[o] << 8) | b[o + 1]\n)\n/** @since 0.1.0 @category integers */\nexport const leU16: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  2,\n  \"leU16\",\n  (b, o) => b[o] | (b[o + 1] << 8)\n)\n/** @since 0.1.0 @category integers */\nexport const beI16: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  2,\n  \"beI16\",\n  (b, o) => (((b[o] << 8) | b[o + 1]) << 16) >> 16\n)\n/** @since 0.1.0 @category integers */\nexport const leI16: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  2,\n  \"leI16\",\n  (b, o) => ((b[o] | (b[o + 1] << 8)) << 16) >> 16\n)\n/** @since 0.1.0 @category integers */\nexport const beU24: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  3,\n  \"beU24\",\n  /*#__PURE__*/ readU24(false)\n)\n/** @since 0.1.0 @category integers */\nexport const leU24: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  3,\n  \"leU24\",\n  /*#__PURE__*/ readU24(true)\n)\n/** @since 0.1.0 @category integers */\nexport const beI24: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  3,\n  \"beI24\",\n  /*#__PURE__*/ readI24(false)\n)\n/** @since 0.1.0 @category integers */\nexport const leI24: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  3,\n  \"leI24\",\n  /*#__PURE__*/ readI24(true)\n)\n/** @since 0.1.0 @category integers */\nexport const beU32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  4,\n  \"beU32\",\n  (b, o) => ((b[o] << 24) | (b[o + 1] << 16) | (b[o + 2] << 8) | b[o + 3]) >>> 0\n)\n/** @since 0.1.0 @category integers */\nexport const leU32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  4,\n  \"leU32\",\n  (b, o) => (b[o] | (b[o + 1] << 8) | (b[o + 2] << 16) | (b[o + 3] << 24)) >>> 0\n)\n/** @since 0.1.0 @category integers */\nexport const beI32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  4,\n  \"beI32\",\n  (b, o) => (b[o] << 24) | (b[o + 1] << 16) | (b[o + 2] << 8) | b[o + 3]\n)\n/** @since 0.1.0 @category integers */\nexport const leI32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  4,\n  \"leI32\",\n  (b, o) => b[o] | (b[o + 1] << 8) | (b[o + 2] << 16) | (b[o + 3] << 24)\n)\n/** @since 0.1.0 @category integers */\nexport const beU64: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  8,\n  \"beU64\",\n  /*#__PURE__*/ viewed((v, o) => v.getBigUint64(o, false))\n)\n/** @since 0.1.0 @category integers */\nexport const leU64: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  8,\n  \"leU64\",\n  /*#__PURE__*/ viewed((v, o) => v.getBigUint64(o, true))\n)\n/** @since 0.1.0 @category integers */\nexport const beI64: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  8,\n  \"beI64\",\n  /*#__PURE__*/ viewed((v, o) => v.getBigInt64(o, false))\n)\n/** @since 0.1.0 @category integers */\nexport const leI64: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  8,\n  \"leI64\",\n  /*#__PURE__*/ viewed((v, o) => v.getBigInt64(o, true))\n)\n/** @since 0.1.0 @category integers */\nexport const beU128: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  16,\n  \"beU128\",\n  /*#__PURE__*/ readU128(false)\n)\n/** @since 0.1.0 @category integers */\nexport const leU128: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  16,\n  \"leU128\",\n  /*#__PURE__*/ readU128(true)\n)\n/** @since 0.1.0 @category integers */\nexport const beI128: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  16,\n  \"beI128\",\n  /*#__PURE__*/ readI128(false)\n)\n/** @since 0.1.0 @category integers */\nexport const leI128: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  16,\n  \"leI128\",\n  /*#__PURE__*/ readI128(true)\n)\n\n/** @since 0.1.0 @category floats */\nexport const beF32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  4,\n  \"beF32\",\n  /*#__PURE__*/ viewed((v, o) => v.getFloat32(o, false))\n)\n/** @since 0.1.0 @category floats */\nexport const leF32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  4,\n  \"leF32\",\n  /*#__PURE__*/ viewed((v, o) => v.getFloat32(o, true))\n)\n/** @since 0.1.0 @category floats */\nexport const beF64: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  8,\n  \"beF64\",\n  /*#__PURE__*/ viewed((v, o) => v.getFloat64(o, false))\n)\n/** @since 0.1.0 @category floats */\nexport const leF64: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(\n  8,\n  \"leF64\",\n  /*#__PURE__*/ viewed((v, o) => v.getFloat64(o, true))\n)\n\nconst byEndian =\n  <A>(big: A, little: A) =>\n  (endian: Endianness): A =>\n    endian === \"big\" ? big : endian === \"little\" ? little : nativeLittle ? little : big\n\n/**\n * An unsigned 16-bit integer in the given byte order (winnow's `u16`).\n *\n * @since 0.1.0\n * @category integers\n */\nexport const u16: (endian: Endianness) => Parser<number, never, never, Uint8Array> = /*#__PURE__*/ byEndian(\n  beU16,\n  leU16\n)\n/** @since 0.1.0 @category integers */\nexport const i16: (endian: Endianness) => Parser<number, never, never, Uint8Array> = /*#__PURE__*/ byEndian(\n  beI16,\n  leI16\n)\n/** @since 0.1.0 @category integers */\nexport const u24: (endian: Endianness) => Parser<number, never, never, Uint8Array> = /*#__PURE__*/ byEndian(\n  beU24,\n  leU24\n)\n/** @since 0.1.0 @category integers */\nexport const i24: (endian: Endianness) => Parser<number, never, never, Uint8Array> = /*#__PURE__*/ byEndian(\n  beI24,\n  leI24\n)\n/** @since 0.1.0 @category integers */\nexport const u32: (endian: Endianness) => Parser<number, never, never, Uint8Array> = /*#__PURE__*/ byEndian(\n  beU32,\n  leU32\n)\n/** @since 0.1.0 @category integers */\nexport const i32: (endian: Endianness) => Parser<number, never, never, Uint8Array> = /*#__PURE__*/ byEndian(\n  beI32,\n  leI32\n)\n/** @since 0.1.0 @category integers */\nexport const u64: (endian: Endianness) => Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ byEndian(\n  beU64,\n  leU64\n)\n/** @since 0.1.0 @category integers */\nexport const i64: (endian: Endianness) => Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ byEndian(\n  beI64,\n  leI64\n)\n/** @since 0.1.0 @category integers */\nexport const u128: (endian: Endianness) => Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ byEndian(\n  beU128,\n  leU128\n)\n/** @since 0.1.0 @category integers */\nexport const i128: (endian: Endianness) => Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ byEndian(\n  beI128,\n  leI128\n)\n/** @since 0.1.0 @category floats */\nexport const f32: (endian: Endianness) => Parser<number, never, never, Uint8Array> = /*#__PURE__*/ byEndian(\n  beF32,\n  leF32\n)\n/** @since 0.1.0 @category floats */\nexport const f64: (endian: Endianness) => Parser<number, never, never, Uint8Array> = /*#__PURE__*/ byEndian(\n  beF64,\n  leF64\n)\n\nconst MaxCount = /*#__PURE__*/ BigInt(Number.MAX_SAFE_INTEGER)\n\n/**\n * Whether a length read from the input is a count: a non-negative integer\n * of at most `Number.MAX_SAFE_INTEGER`. A signed, fractional or `NaN`\n * length is the input's to choose, so it fails the parse where it was read\n * (as `Parser.filter` does) and never reaches `Token.take` or\n * `Parser.repeat`, which throw on one.\n */\nconst isCount = (n: number | bigint): boolean =>\n  Predicate.isBigInt(n) ? n >= 0n && n <= MaxCount : Number.isSafeInteger(n) && n >= 0\n\nconst toCount = (n: number | bigint): number => (Predicate.isBigInt(n) ? Number(n) : n)\n\n/** How many counts {@link byCount} keeps the parsers of. */\nconst CountCache = 256\n\n/**\n * `build`, keeping the parsers it built for the first {@link CountCache}\n * counts seen: length-prefixed data repeats a few lengths, and building a\n * parser per value cost several times the parse.\n */\nconst byCount = <A>(build: (n: number) => A): ((n: number | bigint) => A) => {\n  const built = new Map<number, A>()\n  return (n) => {\n    const count = toCount(n)\n    let a = built.get(count)\n    if (a === undefined) {\n      a = build(count)\n      if (built.size < CountCache) built.set(count, a)\n    }\n    return a\n  }\n}\n\n/**\n * Parses a length with `count`, then takes that many tokens (winnow's\n * `length_take`, nom's `length_data`). A length that is not a non-negative\n * integer (a negative `i8`, a fractional float) fails the parse at the\n * length.\n *\n * @since 0.1.0\n * @category length-prefixed\n */\nexport const lengthTake = <E, R, I extends Input = Uint8Array>(\n  count: Parser<number | bigint, E, R, I>\n): Parser<Slice<I>, E, R, I> => {\n  const take = byCount((n) => Token.take<I>(n).step)\n  // The count compiles with the grammar: the step is built from its (see `Parser.combinator`)\n  return P.combinator(\n    [count],\n    ([countStep]) =>\n      (state: State<I>) => {\n        const start = state.pos\n        // SAFETY: the count parser's step, interpreted or compiled, returns its output (a number or bigint) or `Fail`\n        const n = countStep(state) as number | bigint | Fail\n        if (n === Fail) return Fail\n        // As `Parser.filter` fails: at the length, backtracking\n        if (!isCount(n)) {\n          state.rewind(start)\n          return state.backtrack(\"Verify\")\n        }\n        return take(n)(state)\n      },\n    \"lengthTake\"\n  )\n}\n\n/**\n * Parses a length with `count`, then applies `parser` that many times\n * (winnow's `length_repeat`, nom's `length_count`). A length that is not a\n * non-negative integer fails the parse at the length.\n *\n * @since 0.1.0\n * @category length-prefixed\n */\nexport const lengthRepeat = <E, R, I extends Input, A, E2, R2, I2 extends Input>(\n  count: Parser<number | bigint, E, R, I>,\n  parser: Parser<A, E2, R2, I2>\n): Parser<Array<A>, E | E2, R | R2, I & I2> =>\n  P.flatMap(\n    P.filter(count, isCount),\n    byCount((n) => P.repeat(parser, n))\n  )\n\n/**\n * Parses a length with `count`, takes that many tokens, and applies\n * `parser` to them (winnow's `length_and_then`, nom's `length_value`).\n * `parser` does not need to consume the whole slice.\n *\n * @since 0.1.0\n * @category length-prefixed\n */\nexport const lengthAndThen = <E, R, I extends Input, A, E2, R2>(\n  count: Parser<number | bigint, E, R, I>,\n  parser: Parser<A, E2, R2, Slice<I> & Input>\n): Parser<A, E | E2, R | R2, I> =>\n  // SAFETY: a slice of an input is itself an input (a string, a `Uint8Array` or an array), so `Slice<I>` is an `Input`\n  P.mapParser(lengthTake(count) as Parser<Slice<I> & Input, E, R, I>, P.complete(parser))\n"],"mappings":"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"}

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":";cA4Bc;;;;;;;;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;;;;;;;;qBA+BtE,OAAQ,kBAAgB,6BAA6B;;;;;;;qBAiBrD,UAAW,kBAAgB,6BAA6B;;;;;;;;qBAwBxD,UAAW,iBAAiB,kBAAgB,6BAA6B;;;;;;;qBAsBzE,MAAM,8BAA8B"}

package/dist/Bits.js

@@ -1,5 +1,6 @@
 import { Fail, Failure } from "./Input.js";
 import { make } from "./Parser.js";
+import { checkCount } from "./internal/node.js";
 // 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);
 /**
@@ -60,10 +61,13 @@ const readBits = (state, count) => {
 	const input = state.input;
 	let pos = state.pos;
 	let value = 0;
-	for (let i = 0; i < count; i++) {
-		const byte = input[pos >>> 3];
-		value = value * 2 + (byte >>> 7 - (pos & 7) & 1);
-		pos++;
+	let left = count;
+	while (left > 0) {
+		const avail = 8 - (pos & 7);
+		const n = left < avail ? left : avail;
+		value = value * (1 << n) + (input[pos >>> 3] >>> avail - n & (1 << n) - 1);
+		pos += n;
+		left -= n;
 	}
 	state.pos = pos;
 	return value;
@@ -76,6 +80,7 @@ const readBits = (state, count) => {
 * @category parsers
 */
 const take = (count) => {
+	checkCount(count);
 	if (count > 53) throw new RangeError("Bits.take: use Bits.takeBig for more than 53 bits");
 	const expected = [`${count} bits`];
 	return make((state) => {
@@ -91,6 +96,7 @@ const take = (count) => {
 * @category parsers
 */
 const takeBig = (count) => {
+	checkCount(count);
 	const expected = [`${count} bits`];
 	return make((state) => {
 		const avail = state.end - state.pos;
@@ -113,6 +119,7 @@ const takeBig = (count) => {
 * @category parsers
 */
 const pattern = (pattern, count) => {
+	checkCount(count);
 	const expected = [`bit pattern ${pattern.toString(2).padStart(count, "0")}`];
 	return make((state) => {
 		const start = state.pos;