@thomasfosterau/effect-parse 0.5.0 → 0.6.0

package/dist/Text.js

@@ -2,6 +2,7 @@ import * as Predicate from "effect/Predicate";
 import { Fail } from "./Input.js";
 import * as P from "./Parser.js";
 import { floatText } from "./internal/numbers.js";
+import { bounds, checkCount, controlCode } from "./internal/node.js";
 import { codePointPredicate, compile, indexOf, matchLiteral } from "./internal/tokens.js";
 import * as internal from "./internal/text.js";
 import { escapedImpl, overflow, takeEscapedImpl, toFloat as toFloat$1 } from "./Ascii.js";
@@ -177,9 +178,8 @@ const isPunctuation = /*#__PURE__*/ makePredicate("isPunctuation", /^\p{P}$/u);
 */
 const isControl = /*#__PURE__*/ makePredicate("isControl", /^\p{Cc}$/u);
 const normalize = (r) => {
-	if (r === void 0) return [0, Infinity];
-	if (Predicate.isNumber(r)) return [r, r];
-	return [r.min ?? 0, r.max ?? Infinity];
+	const { max, min } = bounds(r);
+	return [min, max];
 };
 const isAsciiDigit = /*#__PURE__*/ codePointPredicate("isAsciiDigit", (c) => c >= 48 && c <= 57, [[48, 57]]);
 const isAsciiHexDigit = /*#__PURE__*/ codePointPredicate("isAsciiHexDigit", (c) => c >= 48 && c <= 57 || c >= 65 && c <= 70 || c >= 97 && c <= 102, [
@@ -328,6 +328,7 @@ const make = (encoding) => {
 		});
 	};
 	const take = (count) => {
+		checkCount(count);
 		const expected = [count === 1 ? "1 character" : `${count} characters`];
 		return P.described((state) => {
 			if (state.inputKind === 1) state.encoding = enc;
@@ -463,8 +464,7 @@ const make = (encoding) => {
 	const exponent = P.opt(P.seq(oneOfImpl("eE", false), sign, asciiDigits));
 	const unsignedFloat = P.alt(P.seq(caseless("inf"), P.opt(caseless("inity"))), P.seq(literal("."), asciiDigits, exponent), P.seq(asciiDigits, P.opt(P.seq(literal("."), P.opt(asciiDigits))), exponent));
 	const floatText$1 = floatText(taken(P.alt(caseless("nan"), P.seq(sign, unsignedFloat))).pipe(P.expected("number")));
-	const matchControl = (control) => {
-		const ctrl = control.codePointAt(0);
+	const matchControl = (ctrl) => {
 		return (state) => {
 			if (internal.next(enc, state) !== ctrl) return false;
 			state.pos += internal.width;
@@ -513,8 +513,14 @@ const make = (encoding) => {
 		decBigInt: signed.pipe(P.map((s) => BigInt(s.startsWith("+") ? s.slice(1) : s))),
 		hexUint: hexDigits.pipe(P.tryMap((s) => overflow(parseInt(s, 16))), P.named("hexUint")),
 		float: floatText$1.pipe(P.map(toFloat$1), P.named("float")),
-		takeEscaped: (normal, control, escapable) => takeEscapedImpl(normal, matchControl(control), escapable, (state, start) => internal.textIn(enc, state, start, state.pos), internal.firstCodePoint(control), enc),
-		escaped: (normal, control, escape) => escapedImpl(normal, matchControl(control), escape, internal.firstCodePoint(control), enc)
+		takeEscaped: (normal, control, escapable) => {
+			const ctrl = controlCode(control, internal.firstCodePoint);
+			return takeEscapedImpl(normal, matchControl(ctrl), escapable, (state, start) => internal.textIn(enc, state, start, state.pos), ctrl, enc);
+		},
+		escaped: (normal, control, escape) => {
+			const ctrl = controlCode(control, internal.firstCodePoint);
+			return escapedImpl(normal, matchControl(ctrl), escape, ctrl, enc);
+		}
 	};
 };
 /**

package/dist/Text.js.map

@@ -1 +1 @@
-{"version":3,"file":"Text.js","names":["floatText","markFloatText","toFloat"],"sources":["../src/Text.ts"],"sourcesContent":["/**\n * Unicode text parsers, generic over the input's encoding.\n *\n * `Text.make(encoding)` builds one set of parsers ({@link TextParsers}) for\n * an {@link Encoding.Encoding}, and ready-made sets are provided for\n * JavaScript strings and the common byte encodings:\n *\n * | Parsers | Input | Offsets |\n * |---|---|---|\n * | `Text.string` | `string` | UTF-16 code units |\n * | `Text.utf8` | `Uint8Array` of UTF-8 | bytes |\n * | `Text.utf16le`, `Text.utf16be` | `Uint8Array` of UTF-16 | bytes |\n * | `Text.latin1` | `Uint8Array` of ISO-8859-1 | bytes |\n *\n * Every set has the same members, and every parser returns `string`s, so a\n * grammar written against `TextParsers<I>` parses all of them:\n *\n * ```ts\n * import { Parser, Text } from \"@thomasfosterau/effect-parse\"\n *\n * const greeting = <I extends string | Uint8Array>(T: Text.TextParsers<I>) =>\n *   Parser.preceded(T.literal(\"¡hola \"), T.identifier)\n *\n * Parser.parse(greeting(Text.string), \"¡hola mundo\")                           // \"mundo\"\n * Parser.parse(greeting(Text.utf8), new TextEncoder().encode(\"¡hola Zoë\"))    // \"Zoë\"\n * ```\n *\n * Tokens are Unicode code points, and character classes follow Unicode\n * properties: `alpha1` matches `\"Ωμέγα\"`, `space1` matches a no-break space.\n * Use the `Ascii` module for the ASCII-only classes.\n *\n * Decoding is strict. Malformed input (invalid UTF-8, unpaired surrogates)\n * never matches, and error messages point at it. On partial input, a\n * character split across chunks reports `Incomplete`, so byte streams can be\n * parsed as text without decoding them first.\n *\n * @since 0.1.0\n */\nimport * as Predicate from \"effect/Predicate\"\nimport type { Encoding } from \"./Encoding.js\"\nimport * as Encodings from \"./Encoding.js\"\nimport type { State } from \"./Input.js\"\nimport { Fail } from \"./Input.js\"\nimport { escapedImpl, overflow, takeEscapedImpl, toFloat } from \"./Ascii.js\"\nimport { codePointPredicate, compile, indexOf, matchLiteral } from \"./internal/tokens.js\"\nimport { floatText as markFloatText } from \"./internal/numbers.js\"\nimport * as internal from \"./internal/text.js\"\nimport type { Node } from \"./internal/node.js\"\nimport type { ErrorKind } from \"./ParseError.js\"\nimport type { Parser, Range } from \"./Parser.js\"\nimport * as P from \"./Parser.js\"\nimport type { StringTokenSet } from \"./Token.js\"\n\n// -----------------------------------------------------------------------------\n// Unicode predicates\n// -----------------------------------------------------------------------------\n\n/**\n * A predicate over characters. It accepts a one-character string or a code\n * point.\n *\n * @since 0.1.0\n * @category models\n */\nexport type CharPredicate = (char: string | number) => boolean\n\nconst toCodePoint = (c: string | number): number => (Predicate.isNumber(c) ? c : (c.codePointAt(0) ?? -1))\n\nconst makePredicate = (name: string, re: RegExp): CharPredicate => {\n  // Results for the Basic Multilingual Plane are cached: a table lookup is\n  // much faster than a regular expression test.\n  let ascii: Uint8Array | undefined\n  let bmp: Uint8Array | undefined\n  return codePointPredicate(name, (c: string | number): boolean => {\n    const x = toCodePoint(c)\n    if (x < 0) return false\n    let table: Uint8Array\n    if (x < 128) table = ascii ??= new Uint8Array(128)\n    else if (x < 0x10000) table = bmp ??= new Uint8Array(0x10000)\n    else return re.test(String.fromCodePoint(x))\n    let v = table[x]\n    if (v === 0) table[x] = v = re.test(String.fromCharCode(x)) ? 2 : 1\n    return v === 2\n  })\n}\n\n/**\n * A predicate testing a Unicode property, using the syntax of regular\n * expression property escapes (`\\p{...}`): a general category (`\"Lu\"`,\n * `\"Letter\"`), a binary property (`\"Emoji\"`, `\"Dash\"`) or a script\n * (`\"Script=Greek\"`).\n *\n * @example\n * ```ts\n * import { Text } from \"@thomasfosterau/effect-parse\"\n *\n * const greek = Text.string.takeWhile(Text.property(\"Script=Greek\"), { min: 1 })\n * ```\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const property = (name: string): CharPredicate => makePredicate(name, new RegExp(`^\\\\p{${name}}$`, \"u\"))\n\n/**\n * Letters and other alphabetic characters (the Unicode `Alphabetic`\n * property, Rust's `char::is_alphabetic`).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isAlphabetic: CharPredicate = /*#__PURE__*/ makePredicate(\"isAlphabetic\", /^\\p{Alphabetic}$/u)\n\n/**\n * Letters (general category `L`).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isLetter: CharPredicate = /*#__PURE__*/ makePredicate(\"isLetter\", /^\\p{L}$/u)\n\n/**\n * Uppercase characters (the Unicode `Uppercase` property).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isUppercase: CharPredicate = /*#__PURE__*/ makePredicate(\"isUppercase\", /^\\p{Uppercase}$/u)\n\n/**\n * Lowercase characters (the Unicode `Lowercase` property).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isLowercase: CharPredicate = /*#__PURE__*/ makePredicate(\"isLowercase\", /^\\p{Lowercase}$/u)\n\n/**\n * Decimal digits of any script (general category `Nd`): `0`–`9`, `٠`–`٩`,\n * `०`–`९`, ...\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isDecimalDigit: CharPredicate = /*#__PURE__*/ makePredicate(\"isDecimalDigit\", /^\\p{Nd}$/u)\n\n/**\n * Numeric characters (general category `N`), including `½` and `Ⅻ` (Rust's\n * `char::is_numeric`).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isNumeric: CharPredicate = /*#__PURE__*/ makePredicate(\"isNumeric\", /^\\p{N}$/u)\n\n/**\n * Alphabetic or numeric characters (Rust's `char::is_alphanumeric`).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isAlphanumeric: CharPredicate = /*#__PURE__*/ makePredicate(\"isAlphanumeric\", /^[\\p{Alphabetic}\\p{N}]$/u)\n\n/**\n * Whitespace, including line breaks (the Unicode `White_Space` property,\n * Rust's `char::is_whitespace`).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isWhitespace: CharPredicate = /*#__PURE__*/ makePredicate(\"isWhitespace\", /^\\p{White_Space}$/u)\n\n/**\n * Whitespace that does not break lines: `White_Space` except `\\n`, `\\v`,\n * `\\f`, `\\r`, U+0085, U+2028 and U+2029. Includes tabs and no-break spaces.\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isSpace: CharPredicate = /*#__PURE__*/ makePredicate(\n  \"isSpace\",\n  /^(?![\\n\\v\\f\\r\\u0085\\u2028\\u2029])\\p{White_Space}$/u\n)\n\n/**\n * Characters that can start an identifier (the Unicode `ID_Start` property,\n * see UAX #31).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isIdStart: CharPredicate = /*#__PURE__*/ makePredicate(\"isIdStart\", /^\\p{ID_Start}$/u)\n\n/**\n * Characters that can continue an identifier (the Unicode `ID_Continue`\n * property, see UAX #31).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isIdContinue: CharPredicate = /*#__PURE__*/ makePredicate(\"isIdContinue\", /^\\p{ID_Continue}$/u)\n\n/**\n * Punctuation (general category `P`).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isPunctuation: CharPredicate = /*#__PURE__*/ makePredicate(\"isPunctuation\", /^\\p{P}$/u)\n\n/**\n * Control characters (general category `Cc`).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isControl: CharPredicate = /*#__PURE__*/ makePredicate(\"isControl\", /^\\p{Cc}$/u)\n\n// -----------------------------------------------------------------------------\n// Parsers\n// -----------------------------------------------------------------------------\n\n/**\n * The text parsers for one encoding. Build a set with {@link make}, or use\n * {@link string}, {@link utf8}, {@link utf16le}, {@link utf16be} or\n * {@link latin1}.\n *\n * Every parser returns text as a `string`, whatever the input. To keep a\n * slice of a byte input as bytes instead, use `Parser.taken`.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface TextParsers<I extends string | Uint8Array> {\n  /** The encoding these parsers read. */\n  readonly encoding: Encoding<I>\n\n  // Tokens\n\n  /** Any single character (code point). */\n  readonly any: Parser<string, never, never, I>\n  /**\n   * A literal string, returned as written. On byte inputs it is matched in\n   * its encoded form.\n   */\n  readonly literal: <const L extends string>(literal: L) => Parser<L, never, never, I>\n  /**\n   * A literal string, ignoring case (by simple Unicode case folding, so\n   * `\"straße\"` matches `\"STRAßE\"` but not `\"STRASSE\"`). Returns the input as\n   * written.\n   */\n  readonly caseless: (literal: string) => Parser<string, never, never, I>\n  /** One character belonging to a set (the characters of a string, a range, a predicate, or an array of these). */\n  readonly oneOf: (set: StringTokenSet) => Parser<string, never, never, I>\n  /** One character *not* belonging to a set. */\n  readonly noneOf: (set: StringTokenSet) => Parser<string, never, never, I>\n  /** An optional byte order mark, U+FEFF. Returns whether one was present. */\n  readonly bom: Parser<boolean, never, never, I>\n\n  // Slices\n\n  /** Exactly `count` characters. */\n  readonly take: (count: number) => Parser<string, never, never, I>\n  /** The longest run of characters belonging to a set, with a count in `range` (default: any). */\n  readonly takeWhile: (set: StringTokenSet, range?: Range) => Parser<string, never, never, I>\n  /** The longest run of characters *not* belonging to a set, with a count in `range`. */\n  readonly takeTill: (set: StringTokenSet, range?: Range) => Parser<string, never, never, I>\n  /** Characters up to (not including) the first occurrence of a literal. */\n  readonly takeUntil: (literal: string, range?: Range) => Parser<string, never, never, I>\n  /** The rest of the input. */\n  readonly rest: Parser<string, never, never, I>\n  /**\n   * Runs a parser and returns the text it consumed (`Parser.taken`, decoded\n   * to a `string`).\n   */\n  readonly taken: <A, E, R>(self: Parser<A, E, R, I>) => Parser<string, E, R, I>\n\n  // Character classes\n\n  /** Zero or more alphabetic characters ({@link isAlphabetic}). */\n  readonly alpha0: Parser<string, never, never, I>\n  /** One or more alphabetic characters ({@link isAlphabetic}). */\n  readonly alpha1: Parser<string, never, never, I>\n  /** Zero or more decimal digits of any script ({@link isDecimalDigit}). */\n  readonly digit0: Parser<string, never, never, I>\n  /** One or more decimal digits of any script ({@link isDecimalDigit}). */\n  readonly digit1: Parser<string, never, never, I>\n  /** Zero or more alphanumeric characters ({@link isAlphanumeric}). */\n  readonly alphanumeric0: Parser<string, never, never, I>\n  /** One or more alphanumeric characters ({@link isAlphanumeric}). */\n  readonly alphanumeric1: Parser<string, never, never, I>\n  /** Zero or more non-breaking whitespace characters ({@link isSpace}). */\n  readonly space0: Parser<string, never, never, I>\n  /** One or more non-breaking whitespace characters ({@link isSpace}). */\n  readonly space1: Parser<string, never, never, I>\n  /** Zero or more whitespace characters, including line breaks ({@link isWhitespace}). */\n  readonly multispace0: Parser<string, never, never, I>\n  /** One or more whitespace characters, including line breaks ({@link isWhitespace}). */\n  readonly multispace1: Parser<string, never, never, I>\n  /**\n   * An identifier: an {@link isIdStart} character or `_`, then any\n   * {@link isIdContinue} characters (UAX #31 default identifiers).\n   */\n  readonly identifier: Parser<string, never, never, I>\n\n  // Line endings\n\n  /** `\\n` */\n  readonly newline: Parser<\"\\n\", never, never, I>\n  /** `\\r\\n` */\n  readonly crlf: Parser<\"\\r\\n\", never, never, I>\n  /** `\\t` */\n  readonly tab: Parser<\"\\t\", never, never, I>\n  /** `\\n` or `\\r\\n`. */\n  readonly lineEnding: Parser<\"\\n\" | \"\\r\\n\", never, never, I>\n  /** Everything up to (not including) a line ending. A `\\r` not followed by `\\n` is an error. */\n  readonly tillLineEnding: Parser<string, never, never, I>\n\n  // Numbers (ASCII digits, as in most languages)\n\n  /** An unsigned decimal integer of ASCII digits. Fails if it is not a safe integer. */\n  readonly decUint: Parser<number, string, never, I>\n  /** A signed decimal integer of ASCII digits. Fails if it is not a safe integer. */\n  readonly decInt: Parser<number, string, never, I>\n  /** An unsigned decimal integer of ASCII digits, as a `bigint`. */\n  readonly decBigUint: Parser<bigint, never, never, I>\n  /** A signed decimal integer of ASCII digits, as a `bigint`. */\n  readonly decBigInt: Parser<bigint, never, never, I>\n  /** A hexadecimal unsigned integer, without prefix. Fails if it is not a safe integer. */\n  readonly hexUint: Parser<number, string, never, I>\n  /** A floating point number, as accepted by `Ascii.float`. */\n  readonly float: Parser<number, never, never, I>\n\n  // Escapes\n\n  /**\n   * Recognizes text containing escape sequences, returning it raw (see\n   * `Ascii.takeEscaped`). `control` is the escape character.\n   */\n  readonly takeEscaped: <A, E, R, B, E2, R2>(\n    normal: Parser<A, E, R, I>,\n    control: string,\n    escapable: Parser<B, E2, R2, I>\n  ) => Parser<string, E | E2, R | R2, I>\n  /**\n   * Parses text containing escape sequences, returning it unescaped (see\n   * `Ascii.escaped`). `control` is the escape character.\n   */\n  readonly escaped: <E, R, E2, R2>(\n    normal: Parser<string, E, R, I>,\n    control: string,\n    escape: Parser<string, E2, R2, I>\n  ) => Parser<string, E | E2, R | R2, I>\n}\n\nconst normalize = (r: Range | undefined): [number, number] => {\n  if (r === undefined) return [0, Infinity]\n  if (Predicate.isNumber(r)) return [r, r]\n  return [r.min ?? 0, r.max ?? Infinity]\n}\n\nconst isAsciiDigit = /*#__PURE__*/ codePointPredicate(\"isAsciiDigit\", (c: number): boolean => c >= 48 && c <= 57, [\n  [48, 57]\n])\nconst isAsciiHexDigit = /*#__PURE__*/ codePointPredicate(\n  \"isAsciiHexDigit\",\n  (c: number): boolean => (c >= 48 && c <= 57) || (c >= 65 && c <= 70) || (c >= 97 && c <= 102),\n  [\n    [48, 57],\n    [65, 70],\n    [97, 102]\n  ]\n)\nconst isLineBreak = (c: number): boolean => c === 10 || c === 13\n\nconst expectedAny = [\"any character\"]\nconst expectedLineEnding = [\"line ending\"]\nconst expectedIdentifier = [\"identifier\"]\n\n/**\n * Builds the text parsers for an encoding.\n *\n * @example\n * ```ts\n * import { Encoding, Parser, Text } from \"@thomasfosterau/effect-parse\"\n *\n * const T = Text.make(Encoding.latin1)\n * Parser.parse(T.alpha1, new Uint8Array([0x63, 0x61, 0x66, 0xe9])) // \"café\"\n * ```\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const make = <I extends string | Uint8Array>(encoding: Encoding<I>): TextParsers<I> => {\n  const enc = encoding\n  const fast = internal.fastLimit(enc)\n\n  // Each parser records its encoding on byte input (`state.encoding`), so\n  // that errors can show the input as text.\n  const backtrack = (state: State<any>, kind: ErrorKind, expected: ReadonlyArray<string>, offset = state.pos): Fail =>\n    state.backtrack(kind, expected, offset)\n\n  /** The text `[start, end)` after checking it is well formed, or `Fail`. */\n  const textOf = (\n    state: State<any>,\n    start: number,\n    end: number,\n    kind: ErrorKind,\n    expected: ReadonlyArray<string>\n  ): string | Fail => {\n    const count = internal.validate(enc, state, start, end)\n    if (count < 0) return backtrack(state, kind, expected, -1 - count)\n    return internal.textIn(enc, state, start, end)\n  }\n\n  const takeWhileText = (\n    test: (cp: number) => boolean,\n    r: Range | undefined,\n    negate: boolean,\n    name: string,\n    expected: ReadonlyArray<string>,\n    kind: ErrorKind,\n    hint: boolean,\n    set: unknown = test\n  ): Parser<string, never, never, I> => {\n    const [min, max] = normalize(r)\n    return P.described<string, never, never, I>(\n      (state: State<any>) => {\n        if (state.inputKind === 1) state.encoding = enc\n        const start = state.pos\n        internal.scan(enc, state, test, negate, max, state.pos, fast)\n        const offset = internal.scanOffset\n        const count = internal.scanCount\n        const stop = internal.scanStop\n        if (state.partial && (stop === internal.End || stop === internal.Truncated))\n          return state.incomplete(1, expected)\n        if (count < min) return backtrack(state, kind, expected, offset)\n        // More matching characters would have been accepted where we stopped\n        if (hint && count < max) state.setHint(offset, expected)\n        state.pos = offset\n        return internal.textIn(enc, state, start, offset)\n      },\n      name,\n      { _tag: \"TakeWhile\", set, negate, min, max, encoding: enc }\n    )\n  }\n\n  const any: Parser<string, never, never, I> = P.described<string, never, never, I>(\n    (state: State<any>) => {\n      if (state.inputKind === 1) state.encoding = enc\n      const cp = internal.next(enc, state)\n      if (cp < 0) return internal.failAt(state, cp, \"Token\", expectedAny)\n      state.pos += internal.width\n      return internal.charOf(cp)\n    },\n    \"any\",\n    { _tag: \"Any\", encoding: enc }\n  )\n\n  const literal = <const L extends string>(lit: L): Parser<L, never, never, I> => {\n    const encoded = enc.encode(lit)\n    const len = encoded.length\n    const expected = [JSON.stringify(lit)]\n    const node: Node = { _tag: \"Literal\", literal: lit, caseless: false, encoding: enc }\n    if (len === 1) {\n      // Single unit literals (punctuation, mostly) are compared directly\n      const unit = Predicate.isString(encoded) ? encoded.charCodeAt(0) : encoded[0]\n      return P.described<L, never, never, I>(\n        (state: State<any>) => {\n          const pos = state.pos\n          if (state.inputKind === 1) state.encoding = enc\n          if (pos >= state.end) return state.eoi(\"Literal\", expected, 1)\n          const input = state.input\n          // SAFETY: a `Text` parser runs on strings or `Uint8Array`s, and `inputKind` 0 is set only for a string\n          if ((state.inputKind === 0 ? (input as string).charCodeAt(pos) : (input as Uint8Array)[pos]) !== unit) {\n            return backtrack(state, \"Literal\", expected)\n          }\n          state.pos = pos + 1\n          return lit\n        },\n        expected[0],\n        node\n      )\n    }\n    return P.described<L, never, never, I>(\n      (state: State<any>) => {\n        if (state.inputKind === 1) state.encoding = enc\n        const r = matchLiteral(state, encoded, false)\n        if (r === -1) return backtrack(state, \"Literal\", expected)\n        if (r === -2) {\n          if (state.partial) return state.incomplete(len - (state.end - state.pos), expected)\n          return backtrack(state, \"Literal\", expected)\n        }\n        state.pos += len\n        return lit\n      },\n      expected[0],\n      node\n    )\n  }\n\n  const caseless = (lit: string): Parser<string, never, never, I> => {\n    const folded = Array.from(lit, (c) => internal.fold(internal.firstCodePoint(c)))\n    const expected = [`${JSON.stringify(lit)} (case insensitive)`]\n    return P.described<string, never, never, I>(\n      (state: State<any>) => {\n        if (state.inputKind === 1) state.encoding = enc\n        const start = state.pos\n        let pos = start\n        for (let i = 0; i < folded.length; i++) {\n          const cp = internal.next(enc, state, pos)\n          if (cp === internal.End || cp === internal.Truncated) {\n            return state.partial ? state.incomplete(1, expected) : backtrack(state, \"Literal\", expected)\n          }\n          if (cp < 0 || internal.fold(cp) !== folded[i]) {\n            state.syntax?.read(pos + Math.max(internal.width, 1))\n            return backtrack(state, \"Literal\", expected)\n          }\n          pos += internal.width\n        }\n        state.pos = pos\n        return internal.textIn(enc, state, start, pos)\n      },\n      expected[0],\n      { _tag: \"Literal\", literal: lit, caseless: true, encoding: enc }\n    )\n  }\n\n  const oneOfImpl = (set: StringTokenSet, negate: boolean): Parser<string, never, never, I> => {\n    const m = compile(set, \"string\")\n    const test = m.code\n    const expected = [negate ? `anything but ${m.description}` : m.description]\n    const kind: ErrorKind = negate ? \"NoneOf\" : \"OneOf\"\n    return P.described<string, never, never, I>(\n      (state: State<any>) => {\n        if (state.inputKind === 1) state.encoding = enc\n        const cp = internal.next(enc, state)\n        if (cp < 0) return internal.failAt(state, cp, kind, expected)\n        const w = internal.width\n        if (test(cp) === negate) return state.backtrack(kind, expected)\n        state.pos += w\n        return internal.charOf(cp)\n      },\n      expected[0],\n      { _tag: \"OneOf\", set, negate, encoding: enc }\n    )\n  }\n\n  const take = (count: number): Parser<string, never, never, I> => {\n    const expected = [count === 1 ? \"1 character\" : `${count} characters`]\n    return P.described<string, never, never, I>(\n      (state: State<any>) => {\n        if (state.inputKind === 1) state.encoding = enc\n        const start = state.pos\n        let pos = start\n        for (let got = 0; got < count; got++) {\n          const cp = internal.next(enc, state, pos)\n          if (cp === internal.End) return state.eoi(\"Take\", expected, count - got)\n          if (cp < 0) return internal.failAt(state, cp, \"Take\", expected, pos)\n          pos += internal.width\n        }\n        state.pos = pos\n        return internal.textIn(enc, state, start, pos)\n      },\n      \"take\",\n      { _tag: \"Take\", count, encoding: enc }\n    )\n  }\n\n  const takeUntil = (lit: string, r?: Range): Parser<string, never, never, I> => {\n    const [min, max] = normalize(r)\n    const needle = enc.encode(lit)\n    const unit = enc.unit\n    const expected = [JSON.stringify(lit)]\n    return P.described<string, never, never, I>(\n      (state: State<any>) => {\n        if (state.inputKind === 1) state.encoding = enc\n        const start = state.pos\n        let idx = indexOf(state, needle, start)\n        // Multi-unit encodings: only accept matches on a character boundary\n        while (unit > 1 && idx >= 0 && (idx - start) % unit !== 0) idx = indexOf(state, needle, idx + 1)\n        if (idx < 0) {\n          if (state.partial) return state.incomplete(0, expected)\n          return backtrack(state, \"TakeUntil\", expected, state.end)\n        }\n        // The literal was read but is not consumed\n        state.syntax?.read(idx + needle.length)\n        const count = internal.validate(enc, state, start, idx)\n        if (count < 0) return backtrack(state, \"TakeUntil\", expected, -1 - count)\n        // As in winnow, the first occurrence must lie within the range\n        if (count < min) return backtrack(state, \"TakeUntil\", expected, idx)\n        if (count > max) return backtrack(state, \"TakeUntil\", expected)\n        state.pos = idx\n        return internal.textIn(enc, state, start, idx)\n      },\n      \"takeUntil\",\n      { _tag: \"TakeUntil\", literal: lit, min, max, encoding: enc }\n    )\n  }\n\n  const always = () => true\n  const rest: Parser<string, never, never, I> = P.described<string, never, never, I>(\n    (state: State<any>) => {\n      if (state.inputKind === 1) state.encoding = enc\n      const start = state.pos\n      internal.scan(enc, state, always, false, Infinity, state.pos, fast)\n      const offset = internal.scanOffset\n      if (internal.scanStop === internal.Truncated) return state.incomplete(1, expectedAny)\n      if (internal.scanStop === internal.Invalid) return backtrack(state, \"Token\", expectedAny, offset)\n      state.pos = offset\n      return internal.textIn(enc, state, start, offset)\n    },\n    \"rest\",\n    { _tag: \"Rest\", encoding: enc }\n  )\n\n  const taken = <A, E, R>(self: Parser<A, E, R, I>): Parser<string, E, R, I> => {\n    const step = self.step\n    return P.described<string, E, R, I>(\n      (state: State<any>) => {\n        if (state.inputKind === 1) state.encoding = enc\n        const start = state.pos\n        if (step(state) === Fail) return Fail\n        return textOf(state, start, state.pos, \"Slice\", expectedAny)\n      },\n      self.name,\n      { _tag: \"Taken\", self, encoding: enc }\n    )\n  }\n\n  const cls = (test: CharPredicate, min: 0 | 1, description: string, kind: ErrorKind, hint = true) =>\n    takeWhileText(test, { min }, false, `${kind.toLowerCase()}${min}`, [description], kind, hint)\n\n  const identifierStart = (cp: number) => cp === 95 || isIdStart(cp)\n  const identifier: Parser<string, never, never, I> = P.described<string, never, never, I>(\n    (state: State<any>) => {\n      if (state.inputKind === 1) state.encoding = enc\n      const start = state.pos\n      const cp = internal.next(enc, state)\n      if (cp < 0) return internal.failAt(state, cp, \"TakeWhile\", expectedIdentifier)\n      if (!identifierStart(cp)) return state.backtrack(\"TakeWhile\", expectedIdentifier)\n      internal.scan(enc, state, isIdContinue, false, Infinity, start + internal.width, fast)\n      const stop = internal.scanStop\n      if (state.partial && (stop === internal.End || stop === internal.Truncated)) {\n        return state.incomplete(1, expectedIdentifier)\n      }\n      state.pos = internal.scanOffset\n      return internal.textIn(enc, state, start, state.pos)\n    },\n    \"identifier\",\n    { _tag: \"Identifier\", encoding: enc }\n  )\n\n  // Decoded rather than matched as a literal, as not every encoding can encode it\n  const bom: Parser<boolean, never, never, I> = P.described<boolean, never, never, I>(\n    (state: State<any>) => {\n      if (state.inputKind === 1) state.encoding = enc\n      const cp = internal.next(enc, state)\n      if (cp === 0xfeff) {\n        state.pos += internal.width\n        return true\n      }\n      if (cp === internal.Truncated || (cp === internal.End && state.partial)) {\n        return state.incomplete(1, [\"byte order mark\"])\n      }\n      return false\n    },\n    \"bom\",\n    { _tag: \"Bom\", encoding: enc }\n  )\n\n  const newline = literal(\"\\n\")\n  const crlf = literal(\"\\r\\n\")\n\n  const tillLineEnding: Parser<string, never, never, I> = P.described<string, never, never, I>(\n    (state: State<any>) => {\n      if (state.inputKind === 1) state.encoding = enc\n      const start = state.pos\n      internal.scan(enc, state, isLineBreak, true, Infinity, state.pos, fast)\n      const offset = internal.scanOffset\n      const stop = internal.scanStop\n      if (stop === internal.Truncated || (stop === internal.End && state.partial)) {\n        return state.incomplete(1, expectedLineEnding)\n      }\n      if (stop === internal.Invalid) return backtrack(state, \"LineEnding\", expectedLineEnding, offset)\n      if (stop === 0 && internal.next(enc, state, offset) === 13) {\n        const cr = internal.width\n        // The line feed after it is read, not consumed\n        state.syntax?.read(offset + 2 * cr)\n        const after = internal.next(enc, state, offset + cr)\n        if (after === internal.End && state.partial) return state.incomplete(1, expectedLineEnding)\n        if (after !== 10) return backtrack(state, \"LineEnding\", expectedLineEnding, offset)\n      }\n      state.pos = offset\n      return internal.textIn(enc, state, start, offset)\n    },\n    \"tillLineEnding\",\n    { _tag: \"TillLineEnding\", encoding: enc }\n  )\n\n  const asciiDigits = takeWhileText(isAsciiDigit, { min: 1 }, false, \"digit1\", [\"digit\"], \"Digit\", true)\n  const hexDigits = takeWhileText(\n    isAsciiHexDigit,\n    { min: 1 },\n    false,\n    \"hexDigit1\",\n    [\"hexadecimal digit\"],\n    \"HexDigit\",\n    true\n  )\n  const sign = P.opt(oneOfImpl(\"+-\", false))\n  const signed = taken(P.seq(sign, asciiDigits))\n\n  const exponent = P.opt(P.seq(oneOfImpl(\"eE\", false), sign, asciiDigits))\n  const unsignedFloat = P.alt(\n    P.seq(caseless(\"inf\"), P.opt(caseless(\"inity\"))),\n    P.seq(literal(\".\"), asciiDigits, exponent),\n    P.seq(asciiDigits, P.opt(P.seq(literal(\".\"), P.opt(asciiDigits))), exponent)\n  )\n  const floatText = markFloatText(taken(P.alt(caseless(\"nan\"), P.seq(sign, unsignedFloat))).pipe(P.expected(\"number\")))\n\n  const matchControl = (control: string) => {\n    const ctrl = control.codePointAt(0)\n    return (state: State<any>): boolean => {\n      if (internal.next(enc, state) !== ctrl) return false\n      state.pos += internal.width\n      return true\n    }\n  }\n\n  return {\n    encoding,\n    any,\n    literal,\n    caseless,\n    oneOf: (set) => oneOfImpl(set, false),\n    noneOf: (set) => oneOfImpl(set, true),\n    bom,\n    take,\n    takeWhile: (set, r) => {\n      const m = compile(set, \"string\")\n      return takeWhileText(m.code, r, false, \"takeWhile\", [m.description], \"TakeWhile\", false, set)\n    },\n    takeTill: (set, r) => {\n      const m = compile(set, \"string\")\n      return takeWhileText(m.code, r, true, \"takeTill\", [`anything but ${m.description}`], \"TakeWhile\", false, set)\n    },\n    takeUntil,\n    rest,\n    taken,\n    alpha0: cls(isAlphabetic, 0, \"letter\", \"Alpha\"),\n    alpha1: cls(isAlphabetic, 1, \"letter\", \"Alpha\"),\n    digit0: cls(isDecimalDigit, 0, \"digit\", \"Digit\"),\n    digit1: cls(isDecimalDigit, 1, \"digit\", \"Digit\"),\n    alphanumeric0: cls(isAlphanumeric, 0, \"letter or digit\", \"AlphaNumeric\"),\n    alphanumeric1: cls(isAlphanumeric, 1, \"letter or digit\", \"AlphaNumeric\"),\n    space0: cls(isSpace, 0, \"space\", \"Space\", false),\n    space1: cls(isSpace, 1, \"space\", \"Space\", false),\n    multispace0: cls(isWhitespace, 0, \"whitespace\", \"MultiSpace\", false),\n    multispace1: cls(isWhitespace, 1, \"whitespace\", \"MultiSpace\", false),\n    identifier,\n    newline,\n    crlf,\n    tab: literal(\"\\t\"),\n    lineEnding: P.alt(newline, crlf).pipe(P.expected(\"line ending\")),\n    tillLineEnding,\n    decUint: asciiDigits.pipe(\n      P.tryMap((s) => overflow(Number(s))),\n      P.named(\"decUint\")\n    ),\n    decInt: signed.pipe(\n      P.tryMap((s) => overflow(Number(s))),\n      P.named(\"decInt\")\n    ),\n    decBigUint: asciiDigits.pipe(P.map((s) => BigInt(s))),\n    decBigInt: signed.pipe(P.map((s) => BigInt(s.startsWith(\"+\") ? s.slice(1) : s))),\n    hexUint: hexDigits.pipe(\n      P.tryMap((s) => overflow(parseInt(s, 16))),\n      P.named(\"hexUint\")\n    ),\n    float: floatText.pipe(P.map(toFloat), P.named(\"float\")),\n    takeEscaped: (normal, control, escapable) =>\n      takeEscapedImpl(\n        normal,\n        matchControl(control),\n        escapable,\n        (state, start) => internal.textIn(enc, state, start, state.pos),\n        internal.firstCodePoint(control),\n        enc\n      ),\n    escaped: (normal, control, escape) =>\n      escapedImpl(normal, matchControl(control), escape, internal.firstCodePoint(control), enc)\n  }\n}\n\n/**\n * Text parsers for JavaScript strings.\n *\n * @since 0.1.0\n * @category instances\n */\nexport const string: TextParsers<string> = /*#__PURE__*/ make(Encodings.string)\n\n/**\n * Text parsers for UTF-8 encoded bytes.\n *\n * @example\n * ```ts\n * import { Parser, Text } from \"@thomasfosterau/effect-parse\"\n *\n * const bytes = new TextEncoder().encode(\"naïve café\")\n * Parser.parse(Parser.separatedPair(Text.utf8.alpha1, Text.utf8.space1, Text.utf8.alpha1), bytes)\n * // Result.succeed([\"naïve\", \"café\"])\n * ```\n *\n * @since 0.1.0\n * @category instances\n */\nexport const utf8: TextParsers<Uint8Array> = /*#__PURE__*/ make(Encodings.utf8)\n\n/**\n * Text parsers for UTF-16 little endian bytes.\n *\n * @since 0.1.0\n * @category instances\n */\nexport const utf16le: TextParsers<Uint8Array> = /*#__PURE__*/ make(Encodings.utf16le)\n\n/**\n * Text parsers for UTF-16 big endian bytes.\n *\n * @since 0.1.0\n * @category instances\n */\nexport const utf16be: TextParsers<Uint8Array> = /*#__PURE__*/ make(Encodings.utf16be)\n\n/**\n * Text parsers for ISO-8859-1 (Latin-1) bytes.\n *\n * @since 0.1.0\n * @category instances\n */\nexport const latin1: TextParsers<Uint8Array> = /*#__PURE__*/ make(Encodings.latin1)\n"],"mappings":"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"}
+{"version":3,"file":"Text.js","names":["floatText","markFloatText","toFloat"],"sources":["../src/Text.ts"],"sourcesContent":["/**\n * Unicode text parsers, generic over the input's encoding.\n *\n * `Text.make(encoding)` builds one set of parsers ({@link TextParsers}) for\n * an {@link Encoding.Encoding}, and ready-made sets are provided for\n * JavaScript strings and the common byte encodings:\n *\n * | Parsers | Input | Offsets |\n * |---|---|---|\n * | `Text.string` | `string` | UTF-16 code units |\n * | `Text.utf8` | `Uint8Array` of UTF-8 | bytes |\n * | `Text.utf16le`, `Text.utf16be` | `Uint8Array` of UTF-16 | bytes |\n * | `Text.latin1` | `Uint8Array` of ISO-8859-1 | bytes |\n *\n * Every set has the same members, and every parser returns `string`s, so a\n * grammar written against `TextParsers<I>` parses all of them:\n *\n * ```ts\n * import { Parser, Text } from \"@thomasfosterau/effect-parse\"\n *\n * const greeting = <I extends string | Uint8Array>(T: Text.TextParsers<I>) =>\n *   Parser.preceded(T.literal(\"¡hola \"), T.identifier)\n *\n * Parser.parse(greeting(Text.string), \"¡hola mundo\")                           // \"mundo\"\n * Parser.parse(greeting(Text.utf8), new TextEncoder().encode(\"¡hola Zoë\"))    // \"Zoë\"\n * ```\n *\n * Tokens are Unicode code points, and character classes follow Unicode\n * properties: `alpha1` matches `\"Ωμέγα\"`, `space1` matches a no-break space.\n * Use the `Ascii` module for the ASCII-only classes.\n *\n * Decoding is strict. Malformed input (invalid UTF-8, unpaired surrogates)\n * never matches, and error messages point at it. On partial input, a\n * character split across chunks reports `Incomplete`, so byte streams can be\n * parsed as text without decoding them first.\n *\n * @since 0.1.0\n */\nimport * as Predicate from \"effect/Predicate\"\nimport type { Encoding } from \"./Encoding.js\"\nimport * as Encodings from \"./Encoding.js\"\nimport type { State } from \"./Input.js\"\nimport { Fail } from \"./Input.js\"\nimport { escapedImpl, overflow, takeEscapedImpl, toFloat } from \"./Ascii.js\"\nimport { codePointPredicate, compile, indexOf, matchLiteral } from \"./internal/tokens.js\"\nimport { floatText as markFloatText } from \"./internal/numbers.js\"\nimport * as internal from \"./internal/text.js\"\nimport type { Node } from \"./internal/node.js\"\nimport { bounds, checkCount, controlCode } from \"./internal/node.js\"\nimport type { ErrorKind } from \"./ParseError.js\"\nimport type { Parser, Range } from \"./Parser.js\"\nimport * as P from \"./Parser.js\"\nimport type { StringTokenSet } from \"./Token.js\"\n\n// -----------------------------------------------------------------------------\n// Unicode predicates\n// -----------------------------------------------------------------------------\n\n/**\n * A predicate over characters. It accepts a one-character string or a code\n * point.\n *\n * @since 0.1.0\n * @category models\n */\nexport type CharPredicate = (char: string | number) => boolean\n\nconst toCodePoint = (c: string | number): number => (Predicate.isNumber(c) ? c : (c.codePointAt(0) ?? -1))\n\nconst makePredicate = (name: string, re: RegExp): CharPredicate => {\n  // Results for the Basic Multilingual Plane are cached: a table lookup is\n  // much faster than a regular expression test.\n  let ascii: Uint8Array | undefined\n  let bmp: Uint8Array | undefined\n  return codePointPredicate(name, (c: string | number): boolean => {\n    const x = toCodePoint(c)\n    if (x < 0) return false\n    let table: Uint8Array\n    if (x < 128) table = ascii ??= new Uint8Array(128)\n    else if (x < 0x10000) table = bmp ??= new Uint8Array(0x10000)\n    else return re.test(String.fromCodePoint(x))\n    let v = table[x]\n    if (v === 0) table[x] = v = re.test(String.fromCharCode(x)) ? 2 : 1\n    return v === 2\n  })\n}\n\n/**\n * A predicate testing a Unicode property, using the syntax of regular\n * expression property escapes (`\\p{...}`): a general category (`\"Lu\"`,\n * `\"Letter\"`), a binary property (`\"Emoji\"`, `\"Dash\"`) or a script\n * (`\"Script=Greek\"`).\n *\n * @example\n * ```ts\n * import { Text } from \"@thomasfosterau/effect-parse\"\n *\n * const greek = Text.string.takeWhile(Text.property(\"Script=Greek\"), { min: 1 })\n * ```\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const property = (name: string): CharPredicate => makePredicate(name, new RegExp(`^\\\\p{${name}}$`, \"u\"))\n\n/**\n * Letters and other alphabetic characters (the Unicode `Alphabetic`\n * property, Rust's `char::is_alphabetic`).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isAlphabetic: CharPredicate = /*#__PURE__*/ makePredicate(\"isAlphabetic\", /^\\p{Alphabetic}$/u)\n\n/**\n * Letters (general category `L`).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isLetter: CharPredicate = /*#__PURE__*/ makePredicate(\"isLetter\", /^\\p{L}$/u)\n\n/**\n * Uppercase characters (the Unicode `Uppercase` property).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isUppercase: CharPredicate = /*#__PURE__*/ makePredicate(\"isUppercase\", /^\\p{Uppercase}$/u)\n\n/**\n * Lowercase characters (the Unicode `Lowercase` property).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isLowercase: CharPredicate = /*#__PURE__*/ makePredicate(\"isLowercase\", /^\\p{Lowercase}$/u)\n\n/**\n * Decimal digits of any script (general category `Nd`): `0`–`9`, `٠`–`٩`,\n * `०`–`९`, ...\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isDecimalDigit: CharPredicate = /*#__PURE__*/ makePredicate(\"isDecimalDigit\", /^\\p{Nd}$/u)\n\n/**\n * Numeric characters (general category `N`), including `½` and `Ⅻ` (Rust's\n * `char::is_numeric`).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isNumeric: CharPredicate = /*#__PURE__*/ makePredicate(\"isNumeric\", /^\\p{N}$/u)\n\n/**\n * Alphabetic or numeric characters (Rust's `char::is_alphanumeric`).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isAlphanumeric: CharPredicate = /*#__PURE__*/ makePredicate(\"isAlphanumeric\", /^[\\p{Alphabetic}\\p{N}]$/u)\n\n/**\n * Whitespace, including line breaks (the Unicode `White_Space` property,\n * Rust's `char::is_whitespace`).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isWhitespace: CharPredicate = /*#__PURE__*/ makePredicate(\"isWhitespace\", /^\\p{White_Space}$/u)\n\n/**\n * Whitespace that does not break lines: `White_Space` except `\\n`, `\\v`,\n * `\\f`, `\\r`, U+0085, U+2028 and U+2029. Includes tabs and no-break spaces.\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isSpace: CharPredicate = /*#__PURE__*/ makePredicate(\n  \"isSpace\",\n  /^(?![\\n\\v\\f\\r\\u0085\\u2028\\u2029])\\p{White_Space}$/u\n)\n\n/**\n * Characters that can start an identifier (the Unicode `ID_Start` property,\n * see UAX #31).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isIdStart: CharPredicate = /*#__PURE__*/ makePredicate(\"isIdStart\", /^\\p{ID_Start}$/u)\n\n/**\n * Characters that can continue an identifier (the Unicode `ID_Continue`\n * property, see UAX #31).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isIdContinue: CharPredicate = /*#__PURE__*/ makePredicate(\"isIdContinue\", /^\\p{ID_Continue}$/u)\n\n/**\n * Punctuation (general category `P`).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isPunctuation: CharPredicate = /*#__PURE__*/ makePredicate(\"isPunctuation\", /^\\p{P}$/u)\n\n/**\n * Control characters (general category `Cc`).\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isControl: CharPredicate = /*#__PURE__*/ makePredicate(\"isControl\", /^\\p{Cc}$/u)\n\n// -----------------------------------------------------------------------------\n// Parsers\n// -----------------------------------------------------------------------------\n\n/**\n * The text parsers for one encoding. Build a set with {@link make}, or use\n * {@link string}, {@link utf8}, {@link utf16le}, {@link utf16be} or\n * {@link latin1}.\n *\n * Every parser returns text as a `string`, whatever the input. To keep a\n * slice of a byte input as bytes instead, use `Parser.taken`.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface TextParsers<I extends string | Uint8Array> {\n  /** The encoding these parsers read. */\n  readonly encoding: Encoding<I>\n\n  // Tokens\n\n  /** Any single character (code point). */\n  readonly any: Parser<string, never, never, I>\n  /**\n   * A literal string, returned as written. On byte inputs it is matched in\n   * its encoded form.\n   */\n  readonly literal: <const L extends string>(literal: L) => Parser<L, never, never, I>\n  /**\n   * A literal string, ignoring case (by simple Unicode case folding, so\n   * `\"straße\"` matches `\"STRAßE\"` but not `\"STRASSE\"`). Returns the input as\n   * written.\n   */\n  readonly caseless: (literal: string) => Parser<string, never, never, I>\n  /** One character belonging to a set (the characters of a string, a range, a predicate, or an array of these). */\n  readonly oneOf: (set: StringTokenSet) => Parser<string, never, never, I>\n  /** One character *not* belonging to a set. */\n  readonly noneOf: (set: StringTokenSet) => Parser<string, never, never, I>\n  /** An optional byte order mark, U+FEFF. Returns whether one was present. */\n  readonly bom: Parser<boolean, never, never, I>\n\n  // Slices\n\n  /** Exactly `count` characters. */\n  readonly take: (count: number) => Parser<string, never, never, I>\n  /** The longest run of characters belonging to a set, with a count in `range` (default: any). */\n  readonly takeWhile: (set: StringTokenSet, range?: Range) => Parser<string, never, never, I>\n  /** The longest run of characters *not* belonging to a set, with a count in `range`. */\n  readonly takeTill: (set: StringTokenSet, range?: Range) => Parser<string, never, never, I>\n  /** Characters up to (not including) the first occurrence of a literal. */\n  readonly takeUntil: (literal: string, range?: Range) => Parser<string, never, never, I>\n  /** The rest of the input. */\n  readonly rest: Parser<string, never, never, I>\n  /**\n   * Runs a parser and returns the text it consumed (`Parser.taken`, decoded\n   * to a `string`).\n   */\n  readonly taken: <A, E, R>(self: Parser<A, E, R, I>) => Parser<string, E, R, I>\n\n  // Character classes\n\n  /** Zero or more alphabetic characters ({@link isAlphabetic}). */\n  readonly alpha0: Parser<string, never, never, I>\n  /** One or more alphabetic characters ({@link isAlphabetic}). */\n  readonly alpha1: Parser<string, never, never, I>\n  /** Zero or more decimal digits of any script ({@link isDecimalDigit}). */\n  readonly digit0: Parser<string, never, never, I>\n  /** One or more decimal digits of any script ({@link isDecimalDigit}). */\n  readonly digit1: Parser<string, never, never, I>\n  /** Zero or more alphanumeric characters ({@link isAlphanumeric}). */\n  readonly alphanumeric0: Parser<string, never, never, I>\n  /** One or more alphanumeric characters ({@link isAlphanumeric}). */\n  readonly alphanumeric1: Parser<string, never, never, I>\n  /** Zero or more non-breaking whitespace characters ({@link isSpace}). */\n  readonly space0: Parser<string, never, never, I>\n  /** One or more non-breaking whitespace characters ({@link isSpace}). */\n  readonly space1: Parser<string, never, never, I>\n  /** Zero or more whitespace characters, including line breaks ({@link isWhitespace}). */\n  readonly multispace0: Parser<string, never, never, I>\n  /** One or more whitespace characters, including line breaks ({@link isWhitespace}). */\n  readonly multispace1: Parser<string, never, never, I>\n  /**\n   * An identifier: an {@link isIdStart} character or `_`, then any\n   * {@link isIdContinue} characters (UAX #31 default identifiers).\n   */\n  readonly identifier: Parser<string, never, never, I>\n\n  // Line endings\n\n  /** `\\n` */\n  readonly newline: Parser<\"\\n\", never, never, I>\n  /** `\\r\\n` */\n  readonly crlf: Parser<\"\\r\\n\", never, never, I>\n  /** `\\t` */\n  readonly tab: Parser<\"\\t\", never, never, I>\n  /** `\\n` or `\\r\\n`. */\n  readonly lineEnding: Parser<\"\\n\" | \"\\r\\n\", never, never, I>\n  /** Everything up to (not including) a line ending. A `\\r` not followed by `\\n` is an error. */\n  readonly tillLineEnding: Parser<string, never, never, I>\n\n  // Numbers (ASCII digits, as in most languages)\n\n  /** An unsigned decimal integer of ASCII digits. Fails if it is not a safe integer. */\n  readonly decUint: Parser<number, string, never, I>\n  /** A signed decimal integer of ASCII digits. Fails if it is not a safe integer. */\n  readonly decInt: Parser<number, string, never, I>\n  /** An unsigned decimal integer of ASCII digits, as a `bigint`. */\n  readonly decBigUint: Parser<bigint, never, never, I>\n  /** A signed decimal integer of ASCII digits, as a `bigint`. */\n  readonly decBigInt: Parser<bigint, never, never, I>\n  /** A hexadecimal unsigned integer, without prefix. Fails if it is not a safe integer. */\n  readonly hexUint: Parser<number, string, never, I>\n  /** A floating point number, as accepted by `Ascii.float`. */\n  readonly float: Parser<number, never, never, I>\n\n  // Escapes\n\n  /**\n   * Recognizes text containing escape sequences, returning it raw (see\n   * `Ascii.takeEscaped`). `control` is the escape character.\n   */\n  readonly takeEscaped: <A, E, R, B, E2, R2>(\n    normal: Parser<A, E, R, I>,\n    control: string,\n    escapable: Parser<B, E2, R2, I>\n  ) => Parser<string, E | E2, R | R2, I>\n  /**\n   * Parses text containing escape sequences, returning it unescaped (see\n   * `Ascii.escaped`). `control` is the escape character.\n   */\n  readonly escaped: <E, R, E2, R2>(\n    normal: Parser<string, E, R, I>,\n    control: string,\n    escape: Parser<string, E2, R2, I>\n  ) => Parser<string, E | E2, R | R2, I>\n}\n\nconst normalize = (r: Range | undefined): [number, number] => {\n  const { max, min } = bounds(r)\n  return [min, max]\n}\n\nconst isAsciiDigit = /*#__PURE__*/ codePointPredicate(\"isAsciiDigit\", (c: number): boolean => c >= 48 && c <= 57, [\n  [48, 57]\n])\nconst isAsciiHexDigit = /*#__PURE__*/ codePointPredicate(\n  \"isAsciiHexDigit\",\n  (c: number): boolean => (c >= 48 && c <= 57) || (c >= 65 && c <= 70) || (c >= 97 && c <= 102),\n  [\n    [48, 57],\n    [65, 70],\n    [97, 102]\n  ]\n)\nconst isLineBreak = (c: number): boolean => c === 10 || c === 13\n\nconst expectedAny = [\"any character\"]\nconst expectedLineEnding = [\"line ending\"]\nconst expectedIdentifier = [\"identifier\"]\n\n/**\n * Builds the text parsers for an encoding.\n *\n * @example\n * ```ts\n * import { Encoding, Parser, Text } from \"@thomasfosterau/effect-parse\"\n *\n * const T = Text.make(Encoding.latin1)\n * Parser.parse(T.alpha1, new Uint8Array([0x63, 0x61, 0x66, 0xe9])) // \"café\"\n * ```\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const make = <I extends string | Uint8Array>(encoding: Encoding<I>): TextParsers<I> => {\n  const enc = encoding\n  const fast = internal.fastLimit(enc)\n\n  // Each parser records its encoding on byte input (`state.encoding`), so\n  // that errors can show the input as text.\n  const backtrack = (state: State<any>, kind: ErrorKind, expected: ReadonlyArray<string>, offset = state.pos): Fail =>\n    state.backtrack(kind, expected, offset)\n\n  /** The text `[start, end)` after checking it is well formed, or `Fail`. */\n  const textOf = (\n    state: State<any>,\n    start: number,\n    end: number,\n    kind: ErrorKind,\n    expected: ReadonlyArray<string>\n  ): string | Fail => {\n    const count = internal.validate(enc, state, start, end)\n    if (count < 0) return backtrack(state, kind, expected, -1 - count)\n    return internal.textIn(enc, state, start, end)\n  }\n\n  const takeWhileText = (\n    test: (cp: number) => boolean,\n    r: Range | undefined,\n    negate: boolean,\n    name: string,\n    expected: ReadonlyArray<string>,\n    kind: ErrorKind,\n    hint: boolean,\n    set: unknown = test\n  ): Parser<string, never, never, I> => {\n    const [min, max] = normalize(r)\n    return P.described<string, never, never, I>(\n      (state: State<any>) => {\n        if (state.inputKind === 1) state.encoding = enc\n        const start = state.pos\n        internal.scan(enc, state, test, negate, max, state.pos, fast)\n        const offset = internal.scanOffset\n        const count = internal.scanCount\n        const stop = internal.scanStop\n        if (state.partial && (stop === internal.End || stop === internal.Truncated))\n          return state.incomplete(1, expected)\n        if (count < min) return backtrack(state, kind, expected, offset)\n        // More matching characters would have been accepted where we stopped\n        if (hint && count < max) state.setHint(offset, expected)\n        state.pos = offset\n        return internal.textIn(enc, state, start, offset)\n      },\n      name,\n      { _tag: \"TakeWhile\", set, negate, min, max, encoding: enc }\n    )\n  }\n\n  const any: Parser<string, never, never, I> = P.described<string, never, never, I>(\n    (state: State<any>) => {\n      if (state.inputKind === 1) state.encoding = enc\n      const cp = internal.next(enc, state)\n      if (cp < 0) return internal.failAt(state, cp, \"Token\", expectedAny)\n      state.pos += internal.width\n      return internal.charOf(cp)\n    },\n    \"any\",\n    { _tag: \"Any\", encoding: enc }\n  )\n\n  const literal = <const L extends string>(lit: L): Parser<L, never, never, I> => {\n    const encoded = enc.encode(lit)\n    const len = encoded.length\n    const expected = [JSON.stringify(lit)]\n    const node: Node = { _tag: \"Literal\", literal: lit, caseless: false, encoding: enc }\n    if (len === 1) {\n      // Single unit literals (punctuation, mostly) are compared directly\n      const unit = Predicate.isString(encoded) ? encoded.charCodeAt(0) : encoded[0]\n      return P.described<L, never, never, I>(\n        (state: State<any>) => {\n          const pos = state.pos\n          if (state.inputKind === 1) state.encoding = enc\n          if (pos >= state.end) return state.eoi(\"Literal\", expected, 1)\n          const input = state.input\n          // SAFETY: a `Text` parser runs on strings or `Uint8Array`s, and `inputKind` 0 is set only for a string\n          if ((state.inputKind === 0 ? (input as string).charCodeAt(pos) : (input as Uint8Array)[pos]) !== unit) {\n            return backtrack(state, \"Literal\", expected)\n          }\n          state.pos = pos + 1\n          return lit\n        },\n        expected[0],\n        node\n      )\n    }\n    return P.described<L, never, never, I>(\n      (state: State<any>) => {\n        if (state.inputKind === 1) state.encoding = enc\n        const r = matchLiteral(state, encoded, false)\n        if (r === -1) return backtrack(state, \"Literal\", expected)\n        if (r === -2) {\n          if (state.partial) return state.incomplete(len - (state.end - state.pos), expected)\n          return backtrack(state, \"Literal\", expected)\n        }\n        state.pos += len\n        return lit\n      },\n      expected[0],\n      node\n    )\n  }\n\n  const caseless = (lit: string): Parser<string, never, never, I> => {\n    const folded = Array.from(lit, (c) => internal.fold(internal.firstCodePoint(c)))\n    const expected = [`${JSON.stringify(lit)} (case insensitive)`]\n    return P.described<string, never, never, I>(\n      (state: State<any>) => {\n        if (state.inputKind === 1) state.encoding = enc\n        const start = state.pos\n        let pos = start\n        for (let i = 0; i < folded.length; i++) {\n          const cp = internal.next(enc, state, pos)\n          if (cp === internal.End || cp === internal.Truncated) {\n            return state.partial ? state.incomplete(1, expected) : backtrack(state, \"Literal\", expected)\n          }\n          if (cp < 0 || internal.fold(cp) !== folded[i]) {\n            state.syntax?.read(pos + Math.max(internal.width, 1))\n            return backtrack(state, \"Literal\", expected)\n          }\n          pos += internal.width\n        }\n        state.pos = pos\n        return internal.textIn(enc, state, start, pos)\n      },\n      expected[0],\n      { _tag: \"Literal\", literal: lit, caseless: true, encoding: enc }\n    )\n  }\n\n  const oneOfImpl = (set: StringTokenSet, negate: boolean): Parser<string, never, never, I> => {\n    const m = compile(set, \"string\")\n    const test = m.code\n    const expected = [negate ? `anything but ${m.description}` : m.description]\n    const kind: ErrorKind = negate ? \"NoneOf\" : \"OneOf\"\n    return P.described<string, never, never, I>(\n      (state: State<any>) => {\n        if (state.inputKind === 1) state.encoding = enc\n        const cp = internal.next(enc, state)\n        if (cp < 0) return internal.failAt(state, cp, kind, expected)\n        const w = internal.width\n        if (test(cp) === negate) return state.backtrack(kind, expected)\n        state.pos += w\n        return internal.charOf(cp)\n      },\n      expected[0],\n      { _tag: \"OneOf\", set, negate, encoding: enc }\n    )\n  }\n\n  const take = (count: number): Parser<string, never, never, I> => {\n    checkCount(count)\n    const expected = [count === 1 ? \"1 character\" : `${count} characters`]\n    return P.described<string, never, never, I>(\n      (state: State<any>) => {\n        if (state.inputKind === 1) state.encoding = enc\n        const start = state.pos\n        let pos = start\n        for (let got = 0; got < count; got++) {\n          const cp = internal.next(enc, state, pos)\n          if (cp === internal.End) return state.eoi(\"Take\", expected, count - got)\n          if (cp < 0) return internal.failAt(state, cp, \"Take\", expected, pos)\n          pos += internal.width\n        }\n        state.pos = pos\n        return internal.textIn(enc, state, start, pos)\n      },\n      \"take\",\n      { _tag: \"Take\", count, encoding: enc }\n    )\n  }\n\n  const takeUntil = (lit: string, r?: Range): Parser<string, never, never, I> => {\n    const [min, max] = normalize(r)\n    const needle = enc.encode(lit)\n    const unit = enc.unit\n    const expected = [JSON.stringify(lit)]\n    return P.described<string, never, never, I>(\n      (state: State<any>) => {\n        if (state.inputKind === 1) state.encoding = enc\n        const start = state.pos\n        let idx = indexOf(state, needle, start)\n        // Multi-unit encodings: only accept matches on a character boundary\n        while (unit > 1 && idx >= 0 && (idx - start) % unit !== 0) idx = indexOf(state, needle, idx + 1)\n        if (idx < 0) {\n          if (state.partial) return state.incomplete(0, expected)\n          return backtrack(state, \"TakeUntil\", expected, state.end)\n        }\n        // The literal was read but is not consumed\n        state.syntax?.read(idx + needle.length)\n        const count = internal.validate(enc, state, start, idx)\n        if (count < 0) return backtrack(state, \"TakeUntil\", expected, -1 - count)\n        // As in winnow, the first occurrence must lie within the range\n        if (count < min) return backtrack(state, \"TakeUntil\", expected, idx)\n        if (count > max) return backtrack(state, \"TakeUntil\", expected)\n        state.pos = idx\n        return internal.textIn(enc, state, start, idx)\n      },\n      \"takeUntil\",\n      { _tag: \"TakeUntil\", literal: lit, min, max, encoding: enc }\n    )\n  }\n\n  const always = () => true\n  const rest: Parser<string, never, never, I> = P.described<string, never, never, I>(\n    (state: State<any>) => {\n      if (state.inputKind === 1) state.encoding = enc\n      const start = state.pos\n      internal.scan(enc, state, always, false, Infinity, state.pos, fast)\n      const offset = internal.scanOffset\n      if (internal.scanStop === internal.Truncated) return state.incomplete(1, expectedAny)\n      if (internal.scanStop === internal.Invalid) return backtrack(state, \"Token\", expectedAny, offset)\n      state.pos = offset\n      return internal.textIn(enc, state, start, offset)\n    },\n    \"rest\",\n    { _tag: \"Rest\", encoding: enc }\n  )\n\n  const taken = <A, E, R>(self: Parser<A, E, R, I>): Parser<string, E, R, I> => {\n    const step = self.step\n    return P.described<string, E, R, I>(\n      (state: State<any>) => {\n        if (state.inputKind === 1) state.encoding = enc\n        const start = state.pos\n        if (step(state) === Fail) return Fail\n        return textOf(state, start, state.pos, \"Slice\", expectedAny)\n      },\n      self.name,\n      { _tag: \"Taken\", self, encoding: enc }\n    )\n  }\n\n  const cls = (test: CharPredicate, min: 0 | 1, description: string, kind: ErrorKind, hint = true) =>\n    takeWhileText(test, { min }, false, `${kind.toLowerCase()}${min}`, [description], kind, hint)\n\n  const identifierStart = (cp: number) => cp === 95 || isIdStart(cp)\n  const identifier: Parser<string, never, never, I> = P.described<string, never, never, I>(\n    (state: State<any>) => {\n      if (state.inputKind === 1) state.encoding = enc\n      const start = state.pos\n      const cp = internal.next(enc, state)\n      if (cp < 0) return internal.failAt(state, cp, \"TakeWhile\", expectedIdentifier)\n      if (!identifierStart(cp)) return state.backtrack(\"TakeWhile\", expectedIdentifier)\n      internal.scan(enc, state, isIdContinue, false, Infinity, start + internal.width, fast)\n      const stop = internal.scanStop\n      if (state.partial && (stop === internal.End || stop === internal.Truncated)) {\n        return state.incomplete(1, expectedIdentifier)\n      }\n      state.pos = internal.scanOffset\n      return internal.textIn(enc, state, start, state.pos)\n    },\n    \"identifier\",\n    { _tag: \"Identifier\", encoding: enc }\n  )\n\n  // Decoded rather than matched as a literal, as not every encoding can encode it\n  const bom: Parser<boolean, never, never, I> = P.described<boolean, never, never, I>(\n    (state: State<any>) => {\n      if (state.inputKind === 1) state.encoding = enc\n      const cp = internal.next(enc, state)\n      if (cp === 0xfeff) {\n        state.pos += internal.width\n        return true\n      }\n      if (cp === internal.Truncated || (cp === internal.End && state.partial)) {\n        return state.incomplete(1, [\"byte order mark\"])\n      }\n      return false\n    },\n    \"bom\",\n    { _tag: \"Bom\", encoding: enc }\n  )\n\n  const newline = literal(\"\\n\")\n  const crlf = literal(\"\\r\\n\")\n\n  const tillLineEnding: Parser<string, never, never, I> = P.described<string, never, never, I>(\n    (state: State<any>) => {\n      if (state.inputKind === 1) state.encoding = enc\n      const start = state.pos\n      internal.scan(enc, state, isLineBreak, true, Infinity, state.pos, fast)\n      const offset = internal.scanOffset\n      const stop = internal.scanStop\n      if (stop === internal.Truncated || (stop === internal.End && state.partial)) {\n        return state.incomplete(1, expectedLineEnding)\n      }\n      if (stop === internal.Invalid) return backtrack(state, \"LineEnding\", expectedLineEnding, offset)\n      if (stop === 0 && internal.next(enc, state, offset) === 13) {\n        const cr = internal.width\n        // The line feed after it is read, not consumed\n        state.syntax?.read(offset + 2 * cr)\n        const after = internal.next(enc, state, offset + cr)\n        if (after === internal.End && state.partial) return state.incomplete(1, expectedLineEnding)\n        if (after !== 10) return backtrack(state, \"LineEnding\", expectedLineEnding, offset)\n      }\n      state.pos = offset\n      return internal.textIn(enc, state, start, offset)\n    },\n    \"tillLineEnding\",\n    { _tag: \"TillLineEnding\", encoding: enc }\n  )\n\n  const asciiDigits = takeWhileText(isAsciiDigit, { min: 1 }, false, \"digit1\", [\"digit\"], \"Digit\", true)\n  const hexDigits = takeWhileText(\n    isAsciiHexDigit,\n    { min: 1 },\n    false,\n    \"hexDigit1\",\n    [\"hexadecimal digit\"],\n    \"HexDigit\",\n    true\n  )\n  const sign = P.opt(oneOfImpl(\"+-\", false))\n  const signed = taken(P.seq(sign, asciiDigits))\n\n  const exponent = P.opt(P.seq(oneOfImpl(\"eE\", false), sign, asciiDigits))\n  const unsignedFloat = P.alt(\n    P.seq(caseless(\"inf\"), P.opt(caseless(\"inity\"))),\n    P.seq(literal(\".\"), asciiDigits, exponent),\n    P.seq(asciiDigits, P.opt(P.seq(literal(\".\"), P.opt(asciiDigits))), exponent)\n  )\n  const floatText = markFloatText(taken(P.alt(caseless(\"nan\"), P.seq(sign, unsignedFloat))).pipe(P.expected(\"number\")))\n\n  const matchControl = (ctrl: number) => {\n    return (state: State<any>): boolean => {\n      if (internal.next(enc, state) !== ctrl) return false\n      state.pos += internal.width\n      return true\n    }\n  }\n\n  return {\n    encoding,\n    any,\n    literal,\n    caseless,\n    oneOf: (set) => oneOfImpl(set, false),\n    noneOf: (set) => oneOfImpl(set, true),\n    bom,\n    take,\n    takeWhile: (set, r) => {\n      const m = compile(set, \"string\")\n      return takeWhileText(m.code, r, false, \"takeWhile\", [m.description], \"TakeWhile\", false, set)\n    },\n    takeTill: (set, r) => {\n      const m = compile(set, \"string\")\n      return takeWhileText(m.code, r, true, \"takeTill\", [`anything but ${m.description}`], \"TakeWhile\", false, set)\n    },\n    takeUntil,\n    rest,\n    taken,\n    alpha0: cls(isAlphabetic, 0, \"letter\", \"Alpha\"),\n    alpha1: cls(isAlphabetic, 1, \"letter\", \"Alpha\"),\n    digit0: cls(isDecimalDigit, 0, \"digit\", \"Digit\"),\n    digit1: cls(isDecimalDigit, 1, \"digit\", \"Digit\"),\n    alphanumeric0: cls(isAlphanumeric, 0, \"letter or digit\", \"AlphaNumeric\"),\n    alphanumeric1: cls(isAlphanumeric, 1, \"letter or digit\", \"AlphaNumeric\"),\n    space0: cls(isSpace, 0, \"space\", \"Space\", false),\n    space1: cls(isSpace, 1, \"space\", \"Space\", false),\n    multispace0: cls(isWhitespace, 0, \"whitespace\", \"MultiSpace\", false),\n    multispace1: cls(isWhitespace, 1, \"whitespace\", \"MultiSpace\", false),\n    identifier,\n    newline,\n    crlf,\n    tab: literal(\"\\t\"),\n    lineEnding: P.alt(newline, crlf).pipe(P.expected(\"line ending\")),\n    tillLineEnding,\n    decUint: asciiDigits.pipe(\n      P.tryMap((s) => overflow(Number(s))),\n      P.named(\"decUint\")\n    ),\n    decInt: signed.pipe(\n      P.tryMap((s) => overflow(Number(s))),\n      P.named(\"decInt\")\n    ),\n    decBigUint: asciiDigits.pipe(P.map((s) => BigInt(s))),\n    decBigInt: signed.pipe(P.map((s) => BigInt(s.startsWith(\"+\") ? s.slice(1) : s))),\n    hexUint: hexDigits.pipe(\n      P.tryMap((s) => overflow(parseInt(s, 16))),\n      P.named(\"hexUint\")\n    ),\n    float: floatText.pipe(P.map(toFloat), P.named(\"float\")),\n    takeEscaped: (normal, control, escapable) => {\n      const ctrl = controlCode(control, internal.firstCodePoint)\n      return takeEscapedImpl(\n        normal,\n        matchControl(ctrl),\n        escapable,\n        (state, start) => internal.textIn(enc, state, start, state.pos),\n        ctrl,\n        enc\n      )\n    },\n    escaped: (normal, control, escape) => {\n      const ctrl = controlCode(control, internal.firstCodePoint)\n      return escapedImpl(normal, matchControl(ctrl), escape, ctrl, enc)\n    }\n  }\n}\n\n/**\n * Text parsers for JavaScript strings.\n *\n * @since 0.1.0\n * @category instances\n */\nexport const string: TextParsers<string> = /*#__PURE__*/ make(Encodings.string)\n\n/**\n * Text parsers for UTF-8 encoded bytes.\n *\n * @example\n * ```ts\n * import { Parser, Text } from \"@thomasfosterau/effect-parse\"\n *\n * const bytes = new TextEncoder().encode(\"naïve café\")\n * Parser.parse(Parser.separatedPair(Text.utf8.alpha1, Text.utf8.space1, Text.utf8.alpha1), bytes)\n * // Result.succeed([\"naïve\", \"café\"])\n * ```\n *\n * @since 0.1.0\n * @category instances\n */\nexport const utf8: TextParsers<Uint8Array> = /*#__PURE__*/ make(Encodings.utf8)\n\n/**\n * Text parsers for UTF-16 little endian bytes.\n *\n * @since 0.1.0\n * @category instances\n */\nexport const utf16le: TextParsers<Uint8Array> = /*#__PURE__*/ make(Encodings.utf16le)\n\n/**\n * Text parsers for UTF-16 big endian bytes.\n *\n * @since 0.1.0\n * @category instances\n */\nexport const utf16be: TextParsers<Uint8Array> = /*#__PURE__*/ make(Encodings.utf16be)\n\n/**\n * Text parsers for ISO-8859-1 (Latin-1) bytes.\n *\n * @since 0.1.0\n * @category instances\n */\nexport const latin1: TextParsers<Uint8Array> = /*#__PURE__*/ make(Encodings.latin1)\n"],"mappings":"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"}

package/dist/Token.d.ts

@@ -165,7 +165,16 @@ export declare const oneOf: <I extends Input = string>(set: TokenSet<I>) => Pars
  */
 export declare const noneOf: <I extends Input = string>(set: TokenSet<I>) => Parser<Token<NoInfer<I>>, never, never, NoInfer<I>>;
 /**
- * Takes exactly `count` tokens (winnow's and nom's `take`).
+ * Takes exactly `count` tokens (winnow's and nom's `take`). `count` must be
+ * a non-negative integer: anything else throws a `RangeError` here, when
+ * the parser is built.
+ *
+ * @example
+ * ```ts
+ * import { Parser, Token } from "@thomasfosterau/effect-parse"
+ *
+ * Parser.parsePeek(Token.take(2), "abc") // Result.succeed(["c", "ab"])
+ * ```
  *
  * @since 0.1.0
  * @category slices

package/dist/Token.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Token.d.ts","names":[],"sources":["../src/Token.ts"],"mappings":";;;;;;;;;iBA0DiB,WAAW;WACjB;WACA,MAAM;WACN,IAAI;;;;;;;;qBASF,QAAS,2BAA2B,MAAM,GAAG,IAAI,MAAI,WAAW;cAE/D;;;;;;;;;iBAUG;GACd;YACS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA8BC,aACX,cACA,YAAY,+BACZ,SAAS,6CACR;;;;;;;;;;YAkBS,0BAER,qBACA,eACE,4BACF,cAAc;;;;;;;;YASN,iCAGR,aACA,qBACA,eACE,4BACF,cAAc;;;;;;;;YASN,SAAS,KAAK,mBACtB,iBACA,UAAU,aACR,eACA,UAAU,oBAAoB,OAC1B,OAAO,iBAAiB,cAAc;;;;;;;;qBA6CnC,KAAK;;;;;;;;;;;;;;;qBAkBL,WAAY,UAAU,qBAAmB,OAAO,MAAM,QAAQ,mBAAmB,QAAQ;;;;;;;iBAUrF;SACR,kBAAkB,SAAS,IAAI,OAAO;GAC5C,SAAS,aAAa,OAAO,0BAA0B;SACjD,GAAG,SAAS,cAAc,KAAK,OAAO,cAAc,kBAAkB,cAAc;;;;;;;;;;;;;;;;;;qBAmBhF,SAAS;;qBAGT,cAAe,KAAK,OAAO,sBAAoB;;;;;;;;;;;;;;;;;qBA0C/C,QAAS,UAAU,gBAC9B,KAAK,SAAS,OACb,OAAO,MAAM,QAAQ,mBAAmB,QAAQ;;;;;;;;qBAuBtC,SAAU,UAAU,gBAC/B,KAAK,SAAS,OACb,OAAO,MAAM,QAAQ,mBAAmB,QAAQ;;;;;;;qBAsBtC,OAAQ,UAAU,gBAAgB,kBAAgB,OAAO,MAAM,QAAQ,mBAAmB,QAAQ;;qBAsBlG,gBAAiB,UAAU,OACtC,cACA,GAAG,mBACH,iBACA,cACA,sBACA,OAAM,WACN,mBACC,OAAO,MAAM,QAAQ,mBAAmB,QAAQ;;;;;;;;;;;;;;;;;;;;qBAuCtC,YAAa,UAAU,gBAClC,KAAK,SAAS,IACd,QAAQ,UACP,OAAO,MAAM,QAAQ,mBAAmB,QAAQ;;;;;;;;qBAStC,WAAY,UAAU,gBACjC,KAAK,SAAS,IACd,QAAQ,UACP,OAAO,MAAM,QAAQ,mBAAmB,QAAQ;;;;;;;iBAQlC;GACd,iBAAiB,QAAQ,QAAQ;GACjC,SAAS,YAAY,QAAQ,QAAQ,OAAO,0BAA0B;GACtE,GAAG,SAAS,cAAc,IAAI,QAAQ,QAAQ,OAAO,cAAc,kBAAkB,cAAc;;;;;;;;;;qBAWzF,WAAW;;;;;;;iBAqDP;GACd,UAAU,uBAAuB,QAAQ,QAAQ;GACjD,UAAU,cAAc,aAAa,QAAQ,QAAQ,OAAO,0BAA0B;;;;;;;;;;;;;;;;;;;;;;qBAuB5E,cAAc;;;;;;;qBAiCd,MAAM;;;;;;;qBAUN,SAAU,UAAU,qBAAmB,OAAO,MAAM,QAAQ,mBAAmB,QAAQ;;;;;;;;qBAWvF,SAAS,6BAA6B;;;;;;;;qBAetC,UAAW,UAAU,gBAChC,YAAY,OAAO,MAAM,mBACxB,OAAO,MAAM,QAAQ,mBAAmB,QAAQ"}
+{"version":3,"file":"Token.d.ts","names":[],"sources":["../src/Token.ts"],"mappings":";;;;;;;;;iBA0DiB,WAAW;WACjB;WACA,MAAM;WACN,IAAI;;;;;;;;qBASF,QAAS,2BAA2B,MAAM,GAAG,IAAI,MAAI,WAAW;cAE/D;;;;;;;;;iBAUG;GACd;YACS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA8BC,aACX,cACA,YAAY,+BACZ,SAAS,6CACR;;;;;;;;;;YAkBS,0BAER,qBACA,eACE,4BACF,cAAc;;;;;;;;YASN,iCAGR,aACA,qBACA,eACE,4BACF,cAAc;;;;;;;;YASN,SAAS,KAAK,mBACtB,iBACA,UAAU,aACR,eACA,UAAU,oBAAoB,OAC1B,OAAO,iBAAiB,cAAc;;;;;;;;qBA6CnC,KAAK;;;;;;;;;;;;;;;qBAkBL,WAAY,UAAU,qBAAmB,OAAO,MAAM,QAAQ,mBAAmB,QAAQ;;;;;;;iBAUrF;SACR,kBAAkB,SAAS,IAAI,OAAO;GAC5C,SAAS,aAAa,OAAO,0BAA0B;SACjD,GAAG,SAAS,cAAc,KAAK,OAAO,cAAc,kBAAkB,cAAc;;;;;;;;;;;;;;;;;;qBAmBhF,SAAS;;qBAGT,cAAe,KAAK,OAAO,sBAAoB;;;;;;;;;;;;;;;;;qBA0C/C,QAAS,UAAU,gBAC9B,KAAK,SAAS,OACb,OAAO,MAAM,QAAQ,mBAAmB,QAAQ;;;;;;;;qBAuBtC,SAAU,UAAU,gBAC/B,KAAK,SAAS,OACb,OAAO,MAAM,QAAQ,mBAAmB,QAAQ;;;;;;;;;;;;;;;;qBA+BtC,OAAQ,UAAU,gBAAgB,kBAAgB,OAAO,MAAM,QAAQ,mBAAmB,QAAQ;;qBAsBlG,gBAAiB,UAAU,OACtC,cACA,GAAG,mBACH,iBACA,cACA,sBACA,OAAM,WACN,mBACC,OAAO,MAAM,QAAQ,mBAAmB,QAAQ;;;;;;;;;;;;;;;;;;;;qBAuCtC,YAAa,UAAU,gBAClC,KAAK,SAAS,IACd,QAAQ,UACP,OAAO,MAAM,QAAQ,mBAAmB,QAAQ;;;;;;;;qBAStC,WAAY,UAAU,gBACjC,KAAK,SAAS,IACd,QAAQ,UACP,OAAO,MAAM,QAAQ,mBAAmB,QAAQ;;;;;;;iBAQlC;GACd,iBAAiB,QAAQ,QAAQ;GACjC,SAAS,YAAY,QAAQ,QAAQ,OAAO,0BAA0B;GACtE,GAAG,SAAS,cAAc,IAAI,QAAQ,QAAQ,OAAO,cAAc,kBAAkB,cAAc;;;;;;;;;;qBAWzF,WAAW;;;;;;;iBAqDP;GACd,UAAU,uBAAuB,QAAQ,QAAQ;GACjD,UAAU,cAAc,aAAa,QAAQ,QAAQ,OAAO,0BAA0B;;;;;;;;;;;;;;;;;;;;;;qBAuB5E,cAAc;;;;;;;qBAiCd,MAAM;;;;;;;qBAUN,SAAU,UAAU,qBAAmB,OAAO,MAAM,QAAQ,mBAAmB,QAAQ;;;;;;;;qBAWvF,SAAS,6BAA6B;;;;;;;;qBAetC,UAAW,UAAU,gBAChC,YAAY,OAAO,MAAM,mBACxB,OAAO,MAAM,QAAQ,mBAAmB,QAAQ"}

package/dist/Token.js

@@ -1,7 +1,7 @@
 import * as Predicate from "effect/Predicate";
 import { described } from "./Parser.js";
+import { bounds, checkCount } from "./internal/node.js";
 import { End, NoMatch, advance, codePointPredicate, compileAny, countTokens, describeLiteral, indexOf, indexOfAny, matchLiteral, nextIf, scan, splitSurrogate } from "./internal/tokens.js";
-import { bounds } from "./internal/node.js";
 // src/Token.ts
 /**
 * Parsers for individual tokens and slices of tokens (winnow's `token`
@@ -212,12 +212,22 @@ const noneOf = (set) => {
 	});
 };
 /**
-* Takes exactly `count` tokens (winnow's and nom's `take`).
+* Takes exactly `count` tokens (winnow's and nom's `take`). `count` must be
+* a non-negative integer: anything else throws a `RangeError` here, when
+* the parser is built.
+*
+* @example
+* ```ts
+* import { Parser, Token } from "@thomasfosterau/effect-parse"
+*
+* Parser.parsePeek(Token.take(2), "abc") // Result.succeed(["c", "ab"])
+* ```
 *
 * @since 0.1.0
 * @category slices
 */
 const take = (count) => {
+	checkCount(count);
 	const expected = [count === 1 ? "1 token" : `${count} tokens`];
 	return described((state) => {
 		const start = state.pos;
@@ -232,9 +242,8 @@ const take = (count) => {
 	});
 };
 const normalize = (r) => {
-	if (r === void 0) return [0, Infinity];
-	if (Predicate.isNumber(r)) return [r, r];
-	return [r.min ?? 0, r.max ?? Infinity];
+	const { max, min } = bounds(r);
+	return [min, max];
 };
 /** @internal */
 const takeWhileImpl = (set, r, negate, name, description, kind = "TakeWhile", hint = false) => {

package/dist/Token.js.map

@@ -1 +1 @@
-{"version":3,"file":"Token.js","names":[],"sources":["../src/Token.ts"],"sourcesContent":["/**\n * Parsers for individual tokens and slices of tokens (winnow's `token`\n * module, nom's `bytes` module).\n *\n * Parsers here work on every input kind: `string` (tokens are code points),\n * `Uint8Array` (tokens are bytes) and arrays (tokens are elements). Parsers\n * whose input type cannot be inferred from their arguments take a type\n * parameter that defaults to `string`:\n *\n * ```ts\n * import { Token } from \"@thomasfosterau/effect-parse\"\n *\n * Token.take(4)              // Parser<string, never, never, string>\n * Token.take<Uint8Array>(4)  // Parser<Uint8Array, never, never, Uint8Array>\n * ```\n *\n * On partial input (see `Parser.parsePartial`), parsers that reach the end\n * of the available data report `Incomplete` rather than succeeding early or\n * failing.\n *\n * @since 0.1.0\n */\nimport * as Predicate from \"effect/Predicate\"\nimport type { Input, Slice, State, Token } from \"./Input.js\"\nimport {\n  advance,\n  codePointPredicate,\n  compileAny,\n  countTokens,\n  describeLiteral,\n  End,\n  indexOf,\n  indexOfAny,\n  matchLiteral,\n  nextIf,\n  NoMatch,\n  scan,\n  splitSurrogate\n} from \"./internal/tokens.js\"\nimport type { ErrorKind } from \"./ParseError.js\"\nimport { bounds } from \"./internal/node.js\"\nimport type { Parser, Range } from \"./Parser.js\"\nimport { described } from \"./Parser.js\"\n\nexport type {\n  /**\n   * @since 0.1.0\n   * @category models\n   */\n  Token\n}\n\n/**\n * An inclusive range of tokens, e.g. `Token.range(\"a\", \"z\")`.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface TokenRange<T> {\n  readonly _tag: \"TokenRange\"\n  readonly from: T\n  readonly to: T\n}\n\n/**\n * Creates an inclusive token range (winnow's `'a'..='z'`).\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const range = <T extends string | number>(from: T, to: T): TokenRange<T> => ({ _tag: \"TokenRange\", from, to })\n\ndeclare const CodePointsBrand: unique symbol\n\n/**\n * A predicate over code points, made with {@link codePoints}. In a token set\n * it receives each character as a number, so testing a character allocates\n * nothing.\n *\n * @since 0.2.0\n * @category models\n */\nexport interface CodePoints {\n  (codePoint: number): boolean\n  readonly [CodePointsBrand]: true\n}\n\n/**\n * Declares a character class as a predicate over code points, for token sets\n * on string, `Text` and byte inputs. `name` describes it in error messages.\n *\n * A plain `(char: string) => boolean` predicate receives each character as a\n * string, which costs an allocation per character tested; a `codePoints`\n * predicate receives the code point itself (a byte, on byte input).\n *\n * `ranges` optionally lists the code points the predicate accepts, as\n * inclusive `[from, to]` pairs. Compiled parsers then test the ranges\n * instead of calling the predicate, so they must agree with it exactly.\n *\n * @example\n * ```ts\n * import { Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const isNameStart = Token.codePoints(\n *   \"name start\",\n *   (c) => (c >= 0x61 && c <= 0x7a) || c === 0x5f || c >= 0xc0,\n *   [[0x5f, 0x5f], [0x61, 0x7a], [0xc0, 0x10ffff]]\n * )\n * const name = Token.takeWhile([isNameStart, Token.range(\"0\", \"9\")], { min: 1 })\n * ```\n *\n * @since 0.2.0\n * @category constructors\n */\nexport const codePoints = (\n  name: string,\n  predicate: (codePoint: number) => boolean,\n  ranges?: ReadonlyArray<readonly [number, number]>\n): CodePoints =>\n  // Wrapped, so the caller's function is left unmarked.\n  // SAFETY: `CodePointsBrand` is a declared, phantom key, so the marked function is all a `CodePoints` is at runtime\n  codePointPredicate(\n    name,\n    (c: number): boolean => predicate(c),\n    ranges?.map(([from, to]) => [from, to] as const)\n  ) as CodePoints\n\n/**\n * A set of string tokens: the characters of a string, a range, a predicate,\n * or an array of these. Strings, ranges, {@link codePoints} predicates and\n * the `Ascii` and `Text` predicates test characters without allocating; a\n * `(char: string) => boolean` predicate allocates a string per character.\n *\n * @since 0.1.0\n * @category models\n */\nexport type StringTokenSet =\n  | string\n  | TokenRange<string>\n  | CodePoints\n  | ((char: string) => boolean)\n  | ReadonlyArray<StringTokenSet>\n\n/**\n * A set of byte tokens: a byte, the (ASCII) characters of a string, a\n * `Uint8Array` of bytes, a range, a predicate, or an array of these.\n *\n * @since 0.1.0\n * @category models\n */\nexport type ByteTokenSet =\n  | number\n  | string\n  | Uint8Array\n  | TokenRange<number>\n  | CodePoints\n  | ((byte: number) => boolean)\n  | ReadonlyArray<ByteTokenSet>\n\n/**\n * A set of tokens (winnow's `ContainsToken`). For array inputs, a set is a\n * predicate or an array of allowed elements (compared with `===`).\n *\n * @since 0.1.0\n * @category models\n */\nexport type TokenSet<I> = I extends string\n  ? StringTokenSet\n  : I extends Uint8Array\n    ? ByteTokenSet\n    : I extends ReadonlyArray<infer T>\n      ? ((token: T) => boolean) | ReadonlyArray<T>\n      : never\n\nconst expectedAny = [\"any token\"]\n\nconst anyStep = (state: State<Input>): unknown => {\n  const pos = state.pos\n  if (pos >= state.end) return state.eoi(\"Token\", expectedAny, 1)\n  switch (state.inputKind) {\n    case 0: {\n      // SAFETY: `inputKind` 0 is set only for a string input\n      const s = state.input as string\n      if (splitSurrogate(state, pos)) return state.incomplete(1, expectedAny)\n      const c = s.charCodeAt(pos)\n      if (c >= 0xd800 && c <= 0xdbff && pos + 1 < s.length && (s.charCodeAt(pos + 1) & 0xfc00) === 0xdc00) {\n        state.pos = pos + 2\n        return s.slice(pos, pos + 2)\n      }\n      state.pos = pos + 1\n      return s[pos]\n    }\n    case 1:\n      state.pos = pos + 1\n      // SAFETY: `inputKind` 1 is set only for a `Uint8Array` input\n      return (state.input as Uint8Array)[pos]\n    default:\n      state.pos = pos + 1\n      // SAFETY: `inputKind` 2 is set for every input that is neither a string nor a `Uint8Array`, an array\n      return (state.input as ReadonlyArray<unknown>)[pos]\n  }\n}\n\n/** The parser behind `any` and `anyToken`, on every input kind. */\nconst anyInput: Parser<unknown, never, never, Input> = /*#__PURE__*/ described(anyStep, \"any\", {\n  _tag: \"Any\",\n  encoding: undefined\n})\n\n/**\n * Matches any single token: a character of a string (winnow's `any`, nom's\n * `anychar`).\n *\n * @since 0.1.0\n * @category tokens\n */\nexport const any: Parser<string> =\n  // SAFETY: on string input, `anyStep` returns the character (one or two code units) at the position, a string\n  anyInput as Parser<string>\n\n/**\n * Matches any single token of an input of type `I`.\n *\n * @example\n * ```ts\n * import { Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const byte = Token.anyToken<Uint8Array>()\n * Parser.parse(byte, new Uint8Array([7])) // Result.succeed(7)\n * ```\n *\n * @since 0.1.0\n * @category tokens\n */\nexport const anyToken = <I extends Input = string>(): Parser<Token<NoInfer<I>>, never, never, NoInfer<I>> =>\n  // SAFETY: `anyStep` handles every input kind, returning the token at the position (a character, byte or element)\n  anyInput as Parser<Token<NoInfer<I>>, never, never, NoInfer<I>>\n\n/**\n * The overloads of {@link literal}.\n *\n * @since 0.5.0\n * @category tokens\n */\nexport interface LiteralFn {\n  <const L extends string>(literal: L): Parser<L, never, never, string>\n  (literal: Uint8Array): Parser<Uint8Array, never, never, Uint8Array>\n  <const T>(literal: ReadonlyArray<T>): Parser<ReadonlyArray<T>, never, never, ReadonlyArray<T>>\n}\n\n/**\n * Matches a literal sequence of tokens (winnow's `literal`, nom's `tag`).\n * Strings are matched against string input, `Uint8Array`s against byte\n * input, and arrays element-wise (with `===`) against array input.\n *\n * @example\n * ```ts\n * import { Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const keyword = Parser.alt(Token.literal(\"true\"), Token.literal(\"false\"))\n * //    ^? Parser<\"true\" | \"false\">\n * ```\n *\n * @since 0.1.0\n * @category tokens\n */\nexport const literal: LiteralFn = (lit: Input): Parser<any, never, never, any> => literalImpl(lit, false)\n\n/** @internal */\nexport const literalImpl = (lit: Input, caseless: boolean): Parser<any, never, never, any> => {\n  const description = describeLiteral(lit)\n  const expected = [caseless ? `${description} (case insensitive)` : description]\n  // A string literal may also be matched against byte input (as UTF-8)\n  let asBytes: Uint8Array | undefined\n  const literalKind = Predicate.isString(lit) ? 0 : lit instanceof Uint8Array ? 1 : 2\n  return described(\n    (state: State<Input>) => {\n      const pos = state.pos\n      // SAFETY: `literalKind` 0 is set only for a string literal\n      const l = literalKind === 0 && state.inputKind === 1 ? (asBytes ??= new TextEncoder().encode(lit as string)) : lit\n      const len = l.length\n      const r = matchLiteral(state, l, caseless)\n      if (r === -1) return state.backtrack(\"Literal\", expected)\n      if (r === -2) {\n        if (state.partial) return state.incomplete(len - (state.end - pos), expected)\n        return state.backtrack(\"Literal\", expected)\n      }\n      state.pos = pos + len\n      return caseless || state.inputKind !== literalKind ? state.slice(pos, pos + len) : lit\n    },\n    description,\n    { _tag: \"Literal\", literal: lit, caseless, encoding: undefined }\n  )\n}\n\n/**\n * Matches one token belonging to a set, returning it (winnow's and nom's\n * `one_of`).\n *\n * @example\n * ```ts\n * import { Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const sign = Token.oneOf(\"+-\")\n * const lower = Token.oneOf(Token.range(\"a\", \"z\"))\n * const hexByte = Token.oneOf<Uint8Array>([Token.range(0x30, 0x39), Token.range(0x61, 0x66)])\n * ```\n *\n * @since 0.1.0\n * @category tokens\n */\nexport const oneOf = <I extends Input = string>(\n  set: TokenSet<I>\n): Parser<Token<NoInfer<I>>, never, never, NoInfer<I>> => {\n  const m = compileAny(set)\n  const expected = [m.description]\n  return described(\n    (state) => {\n      const t = nextIf(state, m, false)\n      if (t === End) return state.eoi(\"OneOf\", expected, 1)\n      if (t === NoMatch) return state.backtrack(\"OneOf\", expected)\n      // SAFETY: past `End` and `NoMatch`, `nextIf` returns the token it consumed from the parser's input `I`\n      return t as Token<I>\n    },\n    m.description,\n    { _tag: \"OneOf\", set, negate: false, encoding: undefined }\n  )\n}\n\n/**\n * Matches one token *not* belonging to a set, returning it (winnow's and\n * nom's `none_of`).\n *\n * @since 0.1.0\n * @category tokens\n */\nexport const noneOf = <I extends Input = string>(\n  set: TokenSet<I>\n): Parser<Token<NoInfer<I>>, never, never, NoInfer<I>> => {\n  const m = compileAny(set)\n  const expected = [`anything but ${m.description}`]\n  return described(\n    (state) => {\n      const t = nextIf(state, m, true)\n      if (t === End) return state.eoi(\"NoneOf\", expected, 1)\n      if (t === NoMatch) return state.backtrack(\"NoneOf\", expected)\n      // SAFETY: past `End` and `NoMatch`, `nextIf` returns the token it consumed from the parser's input `I`\n      return t as Token<I>\n    },\n    expected[0],\n    { _tag: \"OneOf\", set, negate: true, encoding: undefined }\n  )\n}\n\n/**\n * Takes exactly `count` tokens (winnow's and nom's `take`).\n *\n * @since 0.1.0\n * @category slices\n */\nexport const take = <I extends Input = string>(count: number): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> => {\n  const expected = [count === 1 ? \"1 token\" : `${count} tokens`]\n  return described(\n    (state) => {\n      const start = state.pos\n      const { count: got, offset } = advance(state, start, count)\n      if (got < count) return state.eoi(\"Take\", expected, count - got)\n      state.pos = offset\n      return state.slice(start, offset)\n    },\n    \"take\",\n    { _tag: \"Take\", count, encoding: undefined }\n  )\n}\n\nconst normalize = (r: Range | undefined): [number, number] => {\n  if (r === undefined) return [0, Infinity]\n  if (Predicate.isNumber(r)) return [r, r]\n  return [r.min ?? 0, r.max ?? Infinity]\n}\n\n/** @internal */\nexport const takeWhileImpl = <I extends Input>(\n  set: unknown,\n  r: Range | undefined,\n  negate: boolean,\n  name: string,\n  description?: string,\n  kind: ErrorKind = \"TakeWhile\",\n  hint = false\n): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> => {\n  const m = compileAny(set)\n  const [min, max] = normalize(r)\n  const expected = [description ?? (negate ? `anything but ${m.description}` : m.description)]\n  return described(\n    (state) => {\n      const start = state.pos\n      const { count, hitEnd, offset } = scan(state, m, negate, max)\n      if (hitEnd && state.partial) return state.incomplete(1, expected)\n      if (count < min) return state.backtrack(kind, expected, offset)\n      // More matching tokens would have been accepted where we stopped\n      if (hint && count < max) state.setHint(offset, expected)\n      state.pos = offset\n      return state.slice(start, offset)\n    },\n    name,\n    { _tag: \"TakeWhile\", set, negate, min, max, encoding: undefined }\n  )\n}\n\n/**\n * Takes the longest run of tokens belonging to a set, with the number of\n * tokens constrained by `range` (default: zero or more). This is winnow's\n * `take_while(range, set)`, and nom's `take_while`, `take_while1` and\n * `take_while_m_n`.\n *\n * @example\n * ```ts\n * import { Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const identifier = Token.takeWhile(\n *   [Token.range(\"a\", \"z\"), Token.range(\"A\", \"Z\"), \"_\"],\n *   { min: 1 }\n * )\n * ```\n *\n * @since 0.1.0\n * @category slices\n */\nexport const takeWhile = <I extends Input = string>(\n  set: TokenSet<I>,\n  range?: Range\n): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> => takeWhileImpl(set, range, false, \"takeWhile\")\n\n/**\n * Takes the longest run of tokens *not* belonging to a set (winnow's\n * `take_till`, nom's `take_till` and `take_till1`).\n *\n * @since 0.1.0\n * @category slices\n */\nexport const takeTill = <I extends Input = string>(\n  set: TokenSet<I>,\n  range?: Range\n): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> => takeWhileImpl(set, range, true, \"takeTill\")\n\n/**\n * The overloads of {@link takeUntil}.\n *\n * @since 0.5.0\n * @category slices\n */\nexport interface TakeUntilFn {\n  (literal: string, range?: Range): Parser<string, never, never, string>\n  (literal: Uint8Array, range?: Range): Parser<Uint8Array, never, never, Uint8Array>\n  <T>(literal: ReadonlyArray<T>, range?: Range): Parser<ReadonlyArray<T>, never, never, ReadonlyArray<T>>\n}\n\n/**\n * Takes tokens up to (not including) the first occurrence of a literal\n * (winnow's `take_until`, nom's `take_until`). The literal is not\n * consumed. `range` constrains the number of tokens taken.\n *\n * @since 0.1.0\n * @category slices\n */\nexport const takeUntil: TakeUntilFn = (lit: Input, r?: Range): Parser<any, never, never, any> =>\n  untilParser(\n    (state, from) => indexOf(state, lit, from),\n    // A string literal is up to three bytes per unit of UTF-8\n    (state) => lit.length * (Predicate.isString(lit) && state.inputKind === 1 ? 3 : 1),\n    [describeLiteral(lit)],\n    r,\n    \"takeUntil\",\n    { _tag: \"TakeUntil\", literal: lit, ...bounds(r), encoding: undefined }\n  )\n\n/**\n * The parser of `takeUntil` and `takeUntilAny`: `search` finds the first\n * occurrence, which is not consumed (`read` is how far past it the search\n * read). As in winnow, the first occurrence must lie within the range.\n */\nconst untilParser = (\n  search: (state: State<Input>, from: number) => number,\n  read: (state: State<Input>) => number,\n  expected: ReadonlyArray<string>,\n  r: Range | undefined,\n  name: string,\n  node: Parameters<typeof described>[2]\n): Parser<any, never, never, any> => {\n  const [min, max] = normalize(r)\n  return described(\n    (state: State<Input>) => {\n      const start = state.pos\n      const idx = search(state, start)\n      if (idx < 0) {\n        if (state.partial) return state.incomplete(0, expected)\n        return state.backtrack(\"TakeUntil\", expected, state.end)\n      }\n      state.syntax?.read(idx + read(state))\n      if (min > 0 || max !== Infinity) {\n        const count = countTokens(state, start, idx)\n        if (count < min) return state.backtrack(\"TakeUntil\", expected, idx)\n        if (count > max) return state.backtrack(\"TakeUntil\", expected)\n      }\n      state.pos = idx\n      return state.slice(start, idx)\n    },\n    name,\n    node\n  )\n}\n\n/**\n * The overloads of {@link takeUntilAny}.\n *\n * @since 0.5.0\n * @category slices\n */\nexport interface TakeUntilAnyFn {\n  (literals: ReadonlyArray<string>, range?: Range): Parser<string, never, never, string>\n  (literals: ReadonlyArray<Uint8Array>, range?: Range): Parser<Uint8Array, never, never, Uint8Array>\n}\n\n/**\n * Takes tokens up to (not including) the first occurrence of any of\n * several literals: {@link takeUntil} for a set of them, the search a\n * multi-pattern prefilter makes. No literal is consumed. `range` constrains\n * the number of tokens taken. On bytes, `Compiler.wasm` searches with SIMD\n * (Teddy, from ripgrep), sixteen bytes at a time.\n *\n * @example\n * ```ts\n * import { Parser, Token } from \"@thomasfosterau/effect-parse\"\n * import * as Result from \"effect/Result\"\n *\n * const upTo = Parser.seq(Token.takeUntilAny([\"Holmes\", \"Watson\"]), Token.rest)\n * console.log(Result.getOrThrow(Parser.parseSync(upTo, \"Dr. Watson and Holmes\")))\n * // [\"Dr. \", \"Watson and Holmes\"]\n * ```\n *\n * @since 0.5.0\n * @category slices\n */\nexport const takeUntilAny: TakeUntilAnyFn = (\n  literals: ReadonlyArray<Input>,\n  r?: Range\n): Parser<any, never, never, any> => {\n  const longest = Math.max(0, ...literals.map((lit) => lit.length))\n  return untilParser(\n    (state, from) => indexOfAny(state, literals, from),\n    // Every literal was read up to where it would end (a string literal is up to three bytes per unit of UTF-8)\n    (state) => longest * (state.inputKind === 1 ? 3 : 1),\n    literals.map(describeLiteral),\n    r,\n    \"takeUntilAny\",\n    { _tag: \"TakeUntilAny\", literals, ...bounds(r), encoding: undefined }\n  )\n}\n\n/** The parser behind `rest` and `restOf`, on every input kind. */\nconst restInput: Parser<unknown, never, never, Input> = /*#__PURE__*/ described(\n  (state) => {\n    const start = state.pos\n    state.pos = state.end\n    return state.slice(start, state.end)\n  },\n  \"rest\",\n  { _tag: \"Rest\", encoding: undefined }\n)\n\n/**\n * Takes the rest of the input (winnow's and nom's `rest`).\n *\n * @since 0.1.0\n * @category slices\n */\nexport const rest: Parser<string> =\n  // SAFETY: on string input, `State.slice` returns a string\n  restInput as Parser<string>\n\n/**\n * Takes the rest of an input of type `I`.\n *\n * @since 0.1.0\n * @category slices\n */\nexport const restOf = <I extends Input = string>(): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> =>\n  // SAFETY: `State.slice` returns the input's own slice type for every input kind, so `restInput` returns `Slice<I>`\n  restInput as Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>>\n\n/**\n * Returns the length of the remaining input without consuming it (winnow's\n * and nom's `rest_len`).\n *\n * @since 0.1.0\n * @category slices\n */\nexport const restLen: Parser<number, never, never, Input> = /*#__PURE__*/ described(\n  (state) => state.end - state.pos,\n  \"restLen\",\n  {\n    _tag: \"RestLen\"\n  }\n)\n\n/**\n * Matches a token satisfying a predicate (nom's `satisfy`). Equivalent to\n * `Token.oneOf(predicate)`.\n *\n * @since 0.1.0\n * @category tokens\n */\nexport const satisfy = <I extends Input = string>(\n  predicate: (token: Token<I>) => boolean\n): Parser<Token<NoInfer<I>>, never, never, NoInfer<I>> =>\n  // SAFETY: a predicate over the input's tokens is a member of `TokenSet<I>` for each input kind\n  oneOf<I>(predicate as TokenSet<I>)\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsEA,MAAa,SAAoC,MAAS,QAA0B;CAAE,MAAM;CAAc;CAAM;AAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CnH,MAAa,cACX,MACA,WACA,WAIA,mBACE,OACC,MAAuB,UAAU,CAAC,GACnC,QAAQ,KAAK,CAAC,MAAM,QAAQ,CAAC,MAAM,EAAE,CAAU,CACjD;AAiDF,MAAM,cAAc,CAAC,WAAW;AAEhC,MAAM,WAAW,UAAiC;CAChD,MAAM,MAAM,MAAM;CAClB,IAAI,OAAO,MAAM,KAAK,OAAO,MAAM,IAAI,SAAS,aAAa,CAAC;CAC9D,QAAQ,MAAM,WAAd;EACE,KAAK,GAAG;GAEN,MAAM,IAAI,MAAM;GAChB,IAAI,eAAe,OAAO,GAAG,GAAG,OAAO,MAAM,WAAW,GAAG,WAAW;GACtE,MAAM,IAAI,EAAE,WAAW,GAAG;GAC1B,IAAI,KAAK,SAAU,KAAK,SAAU,MAAM,IAAI,EAAE,WAAW,EAAE,WAAW,MAAM,CAAC,IAAI,WAAY,OAAQ;IACnG,MAAM,MAAM,MAAM;IAClB,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC;GAC7B;GACA,MAAM,MAAM,MAAM;GAClB,OAAO,EAAE;EACX;EACA,KAAK;GACH,MAAM,MAAM,MAAM;GAElB,OAAQ,MAAM,MAAqB;EACrC;GACE,MAAM,MAAM,MAAM;GAElB,OAAQ,MAAM,MAAiC;CACnD;AACF;;AAGA,MAAM,WAA+D,wBAAU,SAAS,OAAO;CAC7F,MAAM;CACN,UAAU,KAAA;AACZ,CAAC;;;;;;;;AASD,MAAa,MAEX;;;;;;;;;;;;;;;AAgBF,MAAa,iBAEX;;;;;;;;;;;;;;;;;AA8BF,MAAa,WAAsB,QAA+C,YAAY,KAAK,KAAK;;AAGxG,MAAa,eAAe,KAAY,aAAsD;CAC5F,MAAM,cAAc,gBAAgB,GAAG;CACvC,MAAM,WAAW,CAAC,WAAW,GAAG,YAAY,uBAAuB,WAAW;CAE9E,IAAI;CACJ,MAAM,cAAc,UAAU,SAAS,GAAG,IAAI,IAAI,eAAe,aAAa,IAAI;CAClF,OAAO,WACJ,UAAwB;EACvB,MAAM,MAAM,MAAM;EAElB,MAAM,IAAI,gBAAgB,KAAK,MAAM,cAAc,IAAK,YAAY,IAAI,YAAY,CAAC,CAAC,OAAO,GAAa,IAAK;EAC/G,MAAM,MAAM,EAAE;EACd,MAAM,IAAI,aAAa,OAAO,GAAG,QAAQ;EACzC,IAAI,MAAM,IAAI,OAAO,MAAM,UAAU,WAAW,QAAQ;EACxD,IAAI,MAAM,IAAI;GACZ,IAAI,MAAM,SAAS,OAAO,MAAM,WAAW,OAAO,MAAM,MAAM,MAAM,QAAQ;GAC5E,OAAO,MAAM,UAAU,WAAW,QAAQ;EAC5C;EACA,MAAM,MAAM,MAAM;EAClB,OAAO,YAAY,MAAM,cAAc,cAAc,MAAM,MAAM,KAAK,MAAM,GAAG,IAAI;CACrF,GACA,aACA;EAAE,MAAM;EAAW,SAAS;EAAK;EAAU,UAAU,KAAA;CAAU,CACjE;AACF;;;;;;;;;;;;;;;;;AAkBA,MAAa,SACX,QACwD;CACxD,MAAM,IAAI,WAAW,GAAG;CACxB,MAAM,WAAW,CAAC,EAAE,WAAW;CAC/B,OAAO,WACJ,UAAU;EACT,MAAM,IAAI,OAAO,OAAO,GAAG,KAAK;EAChC,IAAI,MAAM,KAAK,OAAO,MAAM,IAAI,SAAS,UAAU,CAAC;EACpD,IAAI,MAAM,SAAS,OAAO,MAAM,UAAU,SAAS,QAAQ;EAE3D,OAAO;CACT,GACA,EAAE,aACF;EAAE,MAAM;EAAS;EAAK,QAAQ;EAAO,UAAU,KAAA;CAAU,CAC3D;AACF;;;;;;;;AASA,MAAa,UACX,QACwD;CACxD,MAAM,IAAI,WAAW,GAAG;CACxB,MAAM,WAAW,CAAC,gBAAgB,EAAE,aAAa;CACjD,OAAO,WACJ,UAAU;EACT,MAAM,IAAI,OAAO,OAAO,GAAG,IAAI;EAC/B,IAAI,MAAM,KAAK,OAAO,MAAM,IAAI,UAAU,UAAU,CAAC;EACrD,IAAI,MAAM,SAAS,OAAO,MAAM,UAAU,UAAU,QAAQ;EAE5D,OAAO;CACT,GACA,SAAS,IACT;EAAE,MAAM;EAAS;EAAK,QAAQ;EAAM,UAAU,KAAA;CAAU,CAC1D;AACF;;;;;;;AAQA,MAAa,QAAkC,UAAuE;CACpH,MAAM,WAAW,CAAC,UAAU,IAAI,YAAY,GAAG,MAAM,QAAQ;CAC7D,OAAO,WACJ,UAAU;EACT,MAAM,QAAQ,MAAM;EACpB,MAAM,EAAE,OAAO,KAAK,WAAW,QAAQ,OAAO,OAAO,KAAK;EAC1D,IAAI,MAAM,OAAO,OAAO,MAAM,IAAI,QAAQ,UAAU,QAAQ,GAAG;EAC/D,MAAM,MAAM;EACZ,OAAO,MAAM,MAAM,OAAO,MAAM;CAClC,GACA,QACA;EAAE,MAAM;EAAQ;EAAO,UAAU,KAAA;CAAU,CAC7C;AACF;AAEA,MAAM,aAAa,MAA2C;CAC5D,IAAI,MAAM,KAAA,GAAW,OAAO,CAAC,GAAG,QAAQ;CACxC,IAAI,UAAU,SAAS,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC;CACvC,OAAO,CAAC,EAAE,OAAO,GAAG,EAAE,OAAO,QAAQ;AACvC;;AAGA,MAAa,iBACX,KACA,GACA,QACA,MACA,aACA,OAAkB,aAClB,OAAO,UACiD;CACxD,MAAM,IAAI,WAAW,GAAG;CACxB,MAAM,CAAC,KAAK,OAAO,UAAU,CAAC;CAC9B,MAAM,WAAW,CAAC,gBAAgB,SAAS,gBAAgB,EAAE,gBAAgB,EAAE,YAAY;CAC3F,OAAO,WACJ,UAAU;EACT,MAAM,QAAQ,MAAM;EACpB,MAAM,EAAE,OAAO,QAAQ,WAAW,KAAK,OAAO,GAAG,QAAQ,GAAG;EAC5D,IAAI,UAAU,MAAM,SAAS,OAAO,MAAM,WAAW,GAAG,QAAQ;EAChE,IAAI,QAAQ,KAAK,OAAO,MAAM,UAAU,MAAM,UAAU,MAAM;EAE9D,IAAI,QAAQ,QAAQ,KAAK,MAAM,QAAQ,QAAQ,QAAQ;EACvD,MAAM,MAAM;EACZ,OAAO,MAAM,MAAM,OAAO,MAAM;CAClC,GACA,MACA;EAAE,MAAM;EAAa;EAAK;EAAQ;EAAK;EAAK,UAAU,KAAA;CAAU,CAClE;AACF;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,aACX,KACA,UACwD,cAAc,KAAK,OAAO,OAAO,WAAW;;;;;;;;AAStG,MAAa,YACX,KACA,UACwD,cAAc,KAAK,OAAO,MAAM,UAAU;;;;;;;;;AAsBpG,MAAa,aAA0B,KAAY,MACjD,aACG,OAAO,SAAS,QAAQ,OAAO,KAAK,IAAI,IAExC,UAAU,IAAI,UAAU,UAAU,SAAS,GAAG,KAAK,MAAM,cAAc,IAAI,IAAI,IAChF,CAAC,gBAAgB,GAAG,CAAC,GACrB,GACA,aACA;CAAE,MAAM;CAAa,SAAS;CAAK,GAAG,OAAO,CAAC;CAAG,UAAU,KAAA;AAAU,CACvE;;;;;;AAOF,MAAM,eACJ,QACA,MACA,UACA,GACA,MACA,SACmC;CACnC,MAAM,CAAC,KAAK,OAAO,UAAU,CAAC;CAC9B,OAAO,WACJ,UAAwB;EACvB,MAAM,QAAQ,MAAM;EACpB,MAAM,MAAM,OAAO,OAAO,KAAK;EAC/B,IAAI,MAAM,GAAG;GACX,IAAI,MAAM,SAAS,OAAO,MAAM,WAAW,GAAG,QAAQ;GACtD,OAAO,MAAM,UAAU,aAAa,UAAU,MAAM,GAAG;EACzD;EACA,MAAM,QAAQ,KAAK,MAAM,KAAK,KAAK,CAAC;EACpC,IAAI,MAAM,KAAK,QAAQ,UAAU;GAC/B,MAAM,QAAQ,YAAY,OAAO,OAAO,GAAG;GAC3C,IAAI,QAAQ,KAAK,OAAO,MAAM,UAAU,aAAa,UAAU,GAAG;GAClE,IAAI,QAAQ,KAAK,OAAO,MAAM,UAAU,aAAa,QAAQ;EAC/D;EACA,MAAM,MAAM;EACZ,OAAO,MAAM,MAAM,OAAO,GAAG;CAC/B,GACA,MACA,IACF;AACF;;;;;;;;;;;;;;;;;;;;;AAiCA,MAAa,gBACX,UACA,MACmC;CACnC,MAAM,UAAU,KAAK,IAAI,GAAG,GAAG,SAAS,KAAK,QAAQ,IAAI,MAAM,CAAC;CAChE,OAAO,aACJ,OAAO,SAAS,WAAW,OAAO,UAAU,IAAI,IAEhD,UAAU,WAAW,MAAM,cAAc,IAAI,IAAI,IAClD,SAAS,IAAI,eAAe,GAC5B,GACA,gBACA;EAAE,MAAM;EAAgB;EAAU,GAAG,OAAO,CAAC;EAAG,UAAU,KAAA;CAAU,CACtE;AACF;;AAGA,MAAM,YAAgE,yBACnE,UAAU;CACT,MAAM,QAAQ,MAAM;CACpB,MAAM,MAAM,MAAM;CAClB,OAAO,MAAM,MAAM,OAAO,MAAM,GAAG;AACrC,GACA,QACA;CAAE,MAAM;CAAQ,UAAU,KAAA;AAAU,CACtC;;;;;;;AAQA,MAAa,OAEX;;;;;;;AAQF,MAAa,eAEX;;;;;;;;AASF,MAAa,UAA6D,yBACvE,UAAU,MAAM,MAAM,MAAM,KAC7B,WACA,EACE,MAAM,UACR,CACF;;;;;;;;AASA,MAAa,WACX,cAGA,MAAS,SAAwB"}
+{"version":3,"file":"Token.js","names":[],"sources":["../src/Token.ts"],"sourcesContent":["/**\n * Parsers for individual tokens and slices of tokens (winnow's `token`\n * module, nom's `bytes` module).\n *\n * Parsers here work on every input kind: `string` (tokens are code points),\n * `Uint8Array` (tokens are bytes) and arrays (tokens are elements). Parsers\n * whose input type cannot be inferred from their arguments take a type\n * parameter that defaults to `string`:\n *\n * ```ts\n * import { Token } from \"@thomasfosterau/effect-parse\"\n *\n * Token.take(4)              // Parser<string, never, never, string>\n * Token.take<Uint8Array>(4)  // Parser<Uint8Array, never, never, Uint8Array>\n * ```\n *\n * On partial input (see `Parser.parsePartial`), parsers that reach the end\n * of the available data report `Incomplete` rather than succeeding early or\n * failing.\n *\n * @since 0.1.0\n */\nimport * as Predicate from \"effect/Predicate\"\nimport type { Input, Slice, State, Token } from \"./Input.js\"\nimport {\n  advance,\n  codePointPredicate,\n  compileAny,\n  countTokens,\n  describeLiteral,\n  End,\n  indexOf,\n  indexOfAny,\n  matchLiteral,\n  nextIf,\n  NoMatch,\n  scan,\n  splitSurrogate\n} from \"./internal/tokens.js\"\nimport type { ErrorKind } from \"./ParseError.js\"\nimport { bounds, checkCount } from \"./internal/node.js\"\nimport type { Parser, Range } from \"./Parser.js\"\nimport { described } from \"./Parser.js\"\n\nexport type {\n  /**\n   * @since 0.1.0\n   * @category models\n   */\n  Token\n}\n\n/**\n * An inclusive range of tokens, e.g. `Token.range(\"a\", \"z\")`.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface TokenRange<T> {\n  readonly _tag: \"TokenRange\"\n  readonly from: T\n  readonly to: T\n}\n\n/**\n * Creates an inclusive token range (winnow's `'a'..='z'`).\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const range = <T extends string | number>(from: T, to: T): TokenRange<T> => ({ _tag: \"TokenRange\", from, to })\n\ndeclare const CodePointsBrand: unique symbol\n\n/**\n * A predicate over code points, made with {@link codePoints}. In a token set\n * it receives each character as a number, so testing a character allocates\n * nothing.\n *\n * @since 0.2.0\n * @category models\n */\nexport interface CodePoints {\n  (codePoint: number): boolean\n  readonly [CodePointsBrand]: true\n}\n\n/**\n * Declares a character class as a predicate over code points, for token sets\n * on string, `Text` and byte inputs. `name` describes it in error messages.\n *\n * A plain `(char: string) => boolean` predicate receives each character as a\n * string, which costs an allocation per character tested; a `codePoints`\n * predicate receives the code point itself (a byte, on byte input).\n *\n * `ranges` optionally lists the code points the predicate accepts, as\n * inclusive `[from, to]` pairs. Compiled parsers then test the ranges\n * instead of calling the predicate, so they must agree with it exactly.\n *\n * @example\n * ```ts\n * import { Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const isNameStart = Token.codePoints(\n *   \"name start\",\n *   (c) => (c >= 0x61 && c <= 0x7a) || c === 0x5f || c >= 0xc0,\n *   [[0x5f, 0x5f], [0x61, 0x7a], [0xc0, 0x10ffff]]\n * )\n * const name = Token.takeWhile([isNameStart, Token.range(\"0\", \"9\")], { min: 1 })\n * ```\n *\n * @since 0.2.0\n * @category constructors\n */\nexport const codePoints = (\n  name: string,\n  predicate: (codePoint: number) => boolean,\n  ranges?: ReadonlyArray<readonly [number, number]>\n): CodePoints =>\n  // Wrapped, so the caller's function is left unmarked.\n  // SAFETY: `CodePointsBrand` is a declared, phantom key, so the marked function is all a `CodePoints` is at runtime\n  codePointPredicate(\n    name,\n    (c: number): boolean => predicate(c),\n    ranges?.map(([from, to]) => [from, to] as const)\n  ) as CodePoints\n\n/**\n * A set of string tokens: the characters of a string, a range, a predicate,\n * or an array of these. Strings, ranges, {@link codePoints} predicates and\n * the `Ascii` and `Text` predicates test characters without allocating; a\n * `(char: string) => boolean` predicate allocates a string per character.\n *\n * @since 0.1.0\n * @category models\n */\nexport type StringTokenSet =\n  | string\n  | TokenRange<string>\n  | CodePoints\n  | ((char: string) => boolean)\n  | ReadonlyArray<StringTokenSet>\n\n/**\n * A set of byte tokens: a byte, the (ASCII) characters of a string, a\n * `Uint8Array` of bytes, a range, a predicate, or an array of these.\n *\n * @since 0.1.0\n * @category models\n */\nexport type ByteTokenSet =\n  | number\n  | string\n  | Uint8Array\n  | TokenRange<number>\n  | CodePoints\n  | ((byte: number) => boolean)\n  | ReadonlyArray<ByteTokenSet>\n\n/**\n * A set of tokens (winnow's `ContainsToken`). For array inputs, a set is a\n * predicate or an array of allowed elements (compared with `===`).\n *\n * @since 0.1.0\n * @category models\n */\nexport type TokenSet<I> = I extends string\n  ? StringTokenSet\n  : I extends Uint8Array\n    ? ByteTokenSet\n    : I extends ReadonlyArray<infer T>\n      ? ((token: T) => boolean) | ReadonlyArray<T>\n      : never\n\nconst expectedAny = [\"any token\"]\n\nconst anyStep = (state: State<Input>): unknown => {\n  const pos = state.pos\n  if (pos >= state.end) return state.eoi(\"Token\", expectedAny, 1)\n  switch (state.inputKind) {\n    case 0: {\n      // SAFETY: `inputKind` 0 is set only for a string input\n      const s = state.input as string\n      if (splitSurrogate(state, pos)) return state.incomplete(1, expectedAny)\n      const c = s.charCodeAt(pos)\n      if (c >= 0xd800 && c <= 0xdbff && pos + 1 < s.length && (s.charCodeAt(pos + 1) & 0xfc00) === 0xdc00) {\n        state.pos = pos + 2\n        return s.slice(pos, pos + 2)\n      }\n      state.pos = pos + 1\n      return s[pos]\n    }\n    case 1:\n      state.pos = pos + 1\n      // SAFETY: `inputKind` 1 is set only for a `Uint8Array` input\n      return (state.input as Uint8Array)[pos]\n    default:\n      state.pos = pos + 1\n      // SAFETY: `inputKind` 2 is set for every input that is neither a string nor a `Uint8Array`, an array\n      return (state.input as ReadonlyArray<unknown>)[pos]\n  }\n}\n\n/** The parser behind `any` and `anyToken`, on every input kind. */\nconst anyInput: Parser<unknown, never, never, Input> = /*#__PURE__*/ described(anyStep, \"any\", {\n  _tag: \"Any\",\n  encoding: undefined\n})\n\n/**\n * Matches any single token: a character of a string (winnow's `any`, nom's\n * `anychar`).\n *\n * @since 0.1.0\n * @category tokens\n */\nexport const any: Parser<string> =\n  // SAFETY: on string input, `anyStep` returns the character (one or two code units) at the position, a string\n  anyInput as Parser<string>\n\n/**\n * Matches any single token of an input of type `I`.\n *\n * @example\n * ```ts\n * import { Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const byte = Token.anyToken<Uint8Array>()\n * Parser.parse(byte, new Uint8Array([7])) // Result.succeed(7)\n * ```\n *\n * @since 0.1.0\n * @category tokens\n */\nexport const anyToken = <I extends Input = string>(): Parser<Token<NoInfer<I>>, never, never, NoInfer<I>> =>\n  // SAFETY: `anyStep` handles every input kind, returning the token at the position (a character, byte or element)\n  anyInput as Parser<Token<NoInfer<I>>, never, never, NoInfer<I>>\n\n/**\n * The overloads of {@link literal}.\n *\n * @since 0.5.0\n * @category tokens\n */\nexport interface LiteralFn {\n  <const L extends string>(literal: L): Parser<L, never, never, string>\n  (literal: Uint8Array): Parser<Uint8Array, never, never, Uint8Array>\n  <const T>(literal: ReadonlyArray<T>): Parser<ReadonlyArray<T>, never, never, ReadonlyArray<T>>\n}\n\n/**\n * Matches a literal sequence of tokens (winnow's `literal`, nom's `tag`).\n * Strings are matched against string input, `Uint8Array`s against byte\n * input, and arrays element-wise (with `===`) against array input.\n *\n * @example\n * ```ts\n * import { Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const keyword = Parser.alt(Token.literal(\"true\"), Token.literal(\"false\"))\n * //    ^? Parser<\"true\" | \"false\">\n * ```\n *\n * @since 0.1.0\n * @category tokens\n */\nexport const literal: LiteralFn = (lit: Input): Parser<any, never, never, any> => literalImpl(lit, false)\n\n/** @internal */\nexport const literalImpl = (lit: Input, caseless: boolean): Parser<any, never, never, any> => {\n  const description = describeLiteral(lit)\n  const expected = [caseless ? `${description} (case insensitive)` : description]\n  // A string literal may also be matched against byte input (as UTF-8)\n  let asBytes: Uint8Array | undefined\n  const literalKind = Predicate.isString(lit) ? 0 : lit instanceof Uint8Array ? 1 : 2\n  return described(\n    (state: State<Input>) => {\n      const pos = state.pos\n      // SAFETY: `literalKind` 0 is set only for a string literal\n      const l = literalKind === 0 && state.inputKind === 1 ? (asBytes ??= new TextEncoder().encode(lit as string)) : lit\n      const len = l.length\n      const r = matchLiteral(state, l, caseless)\n      if (r === -1) return state.backtrack(\"Literal\", expected)\n      if (r === -2) {\n        if (state.partial) return state.incomplete(len - (state.end - pos), expected)\n        return state.backtrack(\"Literal\", expected)\n      }\n      state.pos = pos + len\n      return caseless || state.inputKind !== literalKind ? state.slice(pos, pos + len) : lit\n    },\n    description,\n    { _tag: \"Literal\", literal: lit, caseless, encoding: undefined }\n  )\n}\n\n/**\n * Matches one token belonging to a set, returning it (winnow's and nom's\n * `one_of`).\n *\n * @example\n * ```ts\n * import { Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const sign = Token.oneOf(\"+-\")\n * const lower = Token.oneOf(Token.range(\"a\", \"z\"))\n * const hexByte = Token.oneOf<Uint8Array>([Token.range(0x30, 0x39), Token.range(0x61, 0x66)])\n * ```\n *\n * @since 0.1.0\n * @category tokens\n */\nexport const oneOf = <I extends Input = string>(\n  set: TokenSet<I>\n): Parser<Token<NoInfer<I>>, never, never, NoInfer<I>> => {\n  const m = compileAny(set)\n  const expected = [m.description]\n  return described(\n    (state) => {\n      const t = nextIf(state, m, false)\n      if (t === End) return state.eoi(\"OneOf\", expected, 1)\n      if (t === NoMatch) return state.backtrack(\"OneOf\", expected)\n      // SAFETY: past `End` and `NoMatch`, `nextIf` returns the token it consumed from the parser's input `I`\n      return t as Token<I>\n    },\n    m.description,\n    { _tag: \"OneOf\", set, negate: false, encoding: undefined }\n  )\n}\n\n/**\n * Matches one token *not* belonging to a set, returning it (winnow's and\n * nom's `none_of`).\n *\n * @since 0.1.0\n * @category tokens\n */\nexport const noneOf = <I extends Input = string>(\n  set: TokenSet<I>\n): Parser<Token<NoInfer<I>>, never, never, NoInfer<I>> => {\n  const m = compileAny(set)\n  const expected = [`anything but ${m.description}`]\n  return described(\n    (state) => {\n      const t = nextIf(state, m, true)\n      if (t === End) return state.eoi(\"NoneOf\", expected, 1)\n      if (t === NoMatch) return state.backtrack(\"NoneOf\", expected)\n      // SAFETY: past `End` and `NoMatch`, `nextIf` returns the token it consumed from the parser's input `I`\n      return t as Token<I>\n    },\n    expected[0],\n    { _tag: \"OneOf\", set, negate: true, encoding: undefined }\n  )\n}\n\n/**\n * Takes exactly `count` tokens (winnow's and nom's `take`). `count` must be\n * a non-negative integer: anything else throws a `RangeError` here, when\n * the parser is built.\n *\n * @example\n * ```ts\n * import { Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * Parser.parsePeek(Token.take(2), \"abc\") // Result.succeed([\"c\", \"ab\"])\n * ```\n *\n * @since 0.1.0\n * @category slices\n */\nexport const take = <I extends Input = string>(count: number): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> => {\n  checkCount(count)\n  const expected = [count === 1 ? \"1 token\" : `${count} tokens`]\n  return described(\n    (state) => {\n      const start = state.pos\n      const { count: got, offset } = advance(state, start, count)\n      if (got < count) return state.eoi(\"Take\", expected, count - got)\n      state.pos = offset\n      return state.slice(start, offset)\n    },\n    \"take\",\n    { _tag: \"Take\", count, encoding: undefined }\n  )\n}\n\nconst normalize = (r: Range | undefined): [number, number] => {\n  const { max, min } = bounds(r)\n  return [min, max]\n}\n\n/** @internal */\nexport const takeWhileImpl = <I extends Input>(\n  set: unknown,\n  r: Range | undefined,\n  negate: boolean,\n  name: string,\n  description?: string,\n  kind: ErrorKind = \"TakeWhile\",\n  hint = false\n): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> => {\n  const m = compileAny(set)\n  const [min, max] = normalize(r)\n  const expected = [description ?? (negate ? `anything but ${m.description}` : m.description)]\n  return described(\n    (state) => {\n      const start = state.pos\n      const { count, hitEnd, offset } = scan(state, m, negate, max)\n      if (hitEnd && state.partial) return state.incomplete(1, expected)\n      if (count < min) return state.backtrack(kind, expected, offset)\n      // More matching tokens would have been accepted where we stopped\n      if (hint && count < max) state.setHint(offset, expected)\n      state.pos = offset\n      return state.slice(start, offset)\n    },\n    name,\n    { _tag: \"TakeWhile\", set, negate, min, max, encoding: undefined }\n  )\n}\n\n/**\n * Takes the longest run of tokens belonging to a set, with the number of\n * tokens constrained by `range` (default: zero or more). This is winnow's\n * `take_while(range, set)`, and nom's `take_while`, `take_while1` and\n * `take_while_m_n`.\n *\n * @example\n * ```ts\n * import { Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const identifier = Token.takeWhile(\n *   [Token.range(\"a\", \"z\"), Token.range(\"A\", \"Z\"), \"_\"],\n *   { min: 1 }\n * )\n * ```\n *\n * @since 0.1.0\n * @category slices\n */\nexport const takeWhile = <I extends Input = string>(\n  set: TokenSet<I>,\n  range?: Range\n): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> => takeWhileImpl(set, range, false, \"takeWhile\")\n\n/**\n * Takes the longest run of tokens *not* belonging to a set (winnow's\n * `take_till`, nom's `take_till` and `take_till1`).\n *\n * @since 0.1.0\n * @category slices\n */\nexport const takeTill = <I extends Input = string>(\n  set: TokenSet<I>,\n  range?: Range\n): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> => takeWhileImpl(set, range, true, \"takeTill\")\n\n/**\n * The overloads of {@link takeUntil}.\n *\n * @since 0.5.0\n * @category slices\n */\nexport interface TakeUntilFn {\n  (literal: string, range?: Range): Parser<string, never, never, string>\n  (literal: Uint8Array, range?: Range): Parser<Uint8Array, never, never, Uint8Array>\n  <T>(literal: ReadonlyArray<T>, range?: Range): Parser<ReadonlyArray<T>, never, never, ReadonlyArray<T>>\n}\n\n/**\n * Takes tokens up to (not including) the first occurrence of a literal\n * (winnow's `take_until`, nom's `take_until`). The literal is not\n * consumed. `range` constrains the number of tokens taken.\n *\n * @since 0.1.0\n * @category slices\n */\nexport const takeUntil: TakeUntilFn = (lit: Input, r?: Range): Parser<any, never, never, any> =>\n  untilParser(\n    (state, from) => indexOf(state, lit, from),\n    // A string literal is up to three bytes per unit of UTF-8\n    (state) => lit.length * (Predicate.isString(lit) && state.inputKind === 1 ? 3 : 1),\n    [describeLiteral(lit)],\n    r,\n    \"takeUntil\",\n    { _tag: \"TakeUntil\", literal: lit, ...bounds(r), encoding: undefined }\n  )\n\n/**\n * The parser of `takeUntil` and `takeUntilAny`: `search` finds the first\n * occurrence, which is not consumed (`read` is how far past it the search\n * read). As in winnow, the first occurrence must lie within the range.\n */\nconst untilParser = (\n  search: (state: State<Input>, from: number) => number,\n  read: (state: State<Input>) => number,\n  expected: ReadonlyArray<string>,\n  r: Range | undefined,\n  name: string,\n  node: Parameters<typeof described>[2]\n): Parser<any, never, never, any> => {\n  const [min, max] = normalize(r)\n  return described(\n    (state: State<Input>) => {\n      const start = state.pos\n      const idx = search(state, start)\n      if (idx < 0) {\n        if (state.partial) return state.incomplete(0, expected)\n        return state.backtrack(\"TakeUntil\", expected, state.end)\n      }\n      state.syntax?.read(idx + read(state))\n      if (min > 0 || max !== Infinity) {\n        const count = countTokens(state, start, idx)\n        if (count < min) return state.backtrack(\"TakeUntil\", expected, idx)\n        if (count > max) return state.backtrack(\"TakeUntil\", expected)\n      }\n      state.pos = idx\n      return state.slice(start, idx)\n    },\n    name,\n    node\n  )\n}\n\n/**\n * The overloads of {@link takeUntilAny}.\n *\n * @since 0.5.0\n * @category slices\n */\nexport interface TakeUntilAnyFn {\n  (literals: ReadonlyArray<string>, range?: Range): Parser<string, never, never, string>\n  (literals: ReadonlyArray<Uint8Array>, range?: Range): Parser<Uint8Array, never, never, Uint8Array>\n}\n\n/**\n * Takes tokens up to (not including) the first occurrence of any of\n * several literals: {@link takeUntil} for a set of them, the search a\n * multi-pattern prefilter makes. No literal is consumed. `range` constrains\n * the number of tokens taken. On bytes, `Compiler.wasm` searches with SIMD\n * (Teddy, from ripgrep), sixteen bytes at a time.\n *\n * @example\n * ```ts\n * import { Parser, Token } from \"@thomasfosterau/effect-parse\"\n * import * as Result from \"effect/Result\"\n *\n * const upTo = Parser.seq(Token.takeUntilAny([\"Holmes\", \"Watson\"]), Token.rest)\n * console.log(Result.getOrThrow(Parser.parseSync(upTo, \"Dr. Watson and Holmes\")))\n * // [\"Dr. \", \"Watson and Holmes\"]\n * ```\n *\n * @since 0.5.0\n * @category slices\n */\nexport const takeUntilAny: TakeUntilAnyFn = (\n  literals: ReadonlyArray<Input>,\n  r?: Range\n): Parser<any, never, never, any> => {\n  const longest = Math.max(0, ...literals.map((lit) => lit.length))\n  return untilParser(\n    (state, from) => indexOfAny(state, literals, from),\n    // Every literal was read up to where it would end (a string literal is up to three bytes per unit of UTF-8)\n    (state) => longest * (state.inputKind === 1 ? 3 : 1),\n    literals.map(describeLiteral),\n    r,\n    \"takeUntilAny\",\n    { _tag: \"TakeUntilAny\", literals, ...bounds(r), encoding: undefined }\n  )\n}\n\n/** The parser behind `rest` and `restOf`, on every input kind. */\nconst restInput: Parser<unknown, never, never, Input> = /*#__PURE__*/ described(\n  (state) => {\n    const start = state.pos\n    state.pos = state.end\n    return state.slice(start, state.end)\n  },\n  \"rest\",\n  { _tag: \"Rest\", encoding: undefined }\n)\n\n/**\n * Takes the rest of the input (winnow's and nom's `rest`).\n *\n * @since 0.1.0\n * @category slices\n */\nexport const rest: Parser<string> =\n  // SAFETY: on string input, `State.slice` returns a string\n  restInput as Parser<string>\n\n/**\n * Takes the rest of an input of type `I`.\n *\n * @since 0.1.0\n * @category slices\n */\nexport const restOf = <I extends Input = string>(): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> =>\n  // SAFETY: `State.slice` returns the input's own slice type for every input kind, so `restInput` returns `Slice<I>`\n  restInput as Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>>\n\n/**\n * Returns the length of the remaining input without consuming it (winnow's\n * and nom's `rest_len`).\n *\n * @since 0.1.0\n * @category slices\n */\nexport const restLen: Parser<number, never, never, Input> = /*#__PURE__*/ described(\n  (state) => state.end - state.pos,\n  \"restLen\",\n  {\n    _tag: \"RestLen\"\n  }\n)\n\n/**\n * Matches a token satisfying a predicate (nom's `satisfy`). Equivalent to\n * `Token.oneOf(predicate)`.\n *\n * @since 0.1.0\n * @category tokens\n */\nexport const satisfy = <I extends Input = string>(\n  predicate: (token: Token<I>) => boolean\n): Parser<Token<NoInfer<I>>, never, never, NoInfer<I>> =>\n  // SAFETY: a predicate over the input's tokens is a member of `TokenSet<I>` for each input kind\n  oneOf<I>(predicate as TokenSet<I>)\n"],"mappings":"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"}

package/dist/internal/compiler/closure.d.ts

@@ -1,6 +1,6 @@
 import { State } from "../../Input.js";
-import { Backend } from "./registry.js";
 import { Node, ParserLike } from "../node.js";
+import { Backend } from "./registry.js";
 import { FirstSets } from "./first.js";
 export type Step = (state: State<any>) => any;
 /** A parser that the compiler left to its interpreted step. */

package/dist/internal/compiler/closure.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"closure.d.ts","names":[],"sources":["../../../src/internal/compiler/closure.ts"],"mappings":";;;;YA+BY,QAAQ,OAAO;;iBAGV;WACN;WACA,KAAK;WACL;;iBAy0DM;WACN,UAAU,GAAG,YAAY,kBAAkB;WAC3C,OAAO,GAAG,YAAY,MAAM,MAAM;WAClC,QAAQ;WACR,WAAW,cAAc;;qBAGvB,wBAAyB,iBAAiB,wBAAoB;;iBAW1D;WACN,MAAM;WACN,WAAW,cAAc;;;qBAWvB,SAAS"}
+{"version":3,"file":"closure.d.ts","names":[],"sources":["../../../src/internal/compiler/closure.ts"],"mappings":";;;;YAgCY,QAAQ,OAAO;;iBAGV;WACN;WACA,KAAK;WACL;;iBA+zDM;WACN,UAAU,GAAG,YAAY,kBAAkB;WAC3C,OAAO,GAAG,YAAY,MAAM,MAAM;WAClC,QAAQ;WACR,WAAW,cAAc;;qBAGvB,wBAAyB,iBAAiB,wBAAoB;;iBAW1D;WACN,MAAM;WACN,WAAW,cAAc;;;qBAWvB,SAAS"}

package/dist/internal/compiler/closure.js

@@ -3,12 +3,13 @@ import * as Result from "effect/Result";
 import { Fail } from "../../Input.js";
 import { floatScan, floatTexts, scanFloatBytes, scanFloatString, toFloat } from "../numbers.js";
 import { Key } from "../key.js";
+import { Defer, nodeOf, scansFloat } from "../node.js";
 import * as Resume from "../resume.js";
 import { countTokens, indexOf, indexOfAny } from "../tokens.js";
 import * as Option from "effect/Option";
 import { charOf, fastLimit, firstCodePoint, fold, textIn, utf16be, utf16le, utf8, utf8Text, validate } from "../text.js";
 import { addEntry, flushEntries, fromEntries, isPlainKey } from "../entries.js";
-import { Defer, nodeOf, scansFloat } from "../node.js";
+import { tupleStep } from "../tuple.js";
 import { buildsEntries, pairOf } from "./entries.js";
 import { FirstSets, planAlt } from "./first.js";
 import { SearchHead, StopCache, nextStop, stopChars } from "./search.js";
@@ -466,15 +467,7 @@ var Compiler = class {
 		const steps = node.parsers.map((q, i) => this.compile(q, keep(i)));
 		const n = steps.length;
 		if (!used) return this.chain(steps);
-		if (output === "tuple") return (s) => {
-			const out = new Array(n);
-			for (let i = 0; i < n; i++) {
-				const a = steps[i](s);
-				if (a === Fail) return Fail;
-				out[i] = a;
-			}
-			return out;
-		};
+		if (output === "tuple") return tupleStep(steps);
 		if (Predicate.isNumber(output)) {
 			if (n === 2) {
 				const a = steps[0];
@@ -610,7 +603,6 @@ var Compiler = class {
 	}
 	repeat(node, used) {
 		const { max, min } = node;
-		const checkLoop = max === Infinity;
 		const isFold = Predicate.isTagged(node, "Fold");
 		const cond = isFold ? node.while : void 0;
 		const c = this.compile(node.self, used);
@@ -655,7 +647,7 @@ var Compiler = class {
 					s.pos = start;
 					return resumed ? Resume.done(s, key, entry, true, acc) : acc;
 				}
-				if (checkLoop && s.pos === start) {
+				if (s.pos === start) {
 					s.mode = CUT;
 					return Fail;
 				}
@@ -720,7 +712,6 @@ var Compiler = class {
 			return true;
 		};
 		const { max, min } = node;
-		const checkLoop = max === Infinity;
 		const resumable = this.resumable;
 		const site = new Key();
 		if (Predicate.isTagged(node, "Repeat")) return (s) => {
@@ -744,7 +735,7 @@ var Compiler = class {
 					else if (j === vi) value = a;
 				}
 				if (!ok) return stopEntries(s, site, at, resumed, acc, count, start, min);
-				if (checkLoop && s.pos === start) {
+				if (s.pos === start) {
 					s.mode = CUT;
 					return Fail;
 				}
@@ -773,7 +764,7 @@ var Compiler = class {
 			while (count < max) {
 				const start = s.pos;
 				if (sep(s) === Fail) return stopEntries(s, site, at, resumed, acc, count, start, min);
-				if (checkLoop && s.pos === start) {
+				if (s.pos === start) {
 					s.mode = CUT;
 					return Fail;
 				}
@@ -810,7 +801,6 @@ var Compiler = class {
 	}
 	separated(node, used) {
 		const { max, min } = node;
-		const checkLoop = max === Infinity;
 		const c = this.compile(node.self, used);
 		const sep = this.compile(node.separator, false);
 		const resumable = this.resumable;
@@ -858,7 +848,7 @@ var Compiler = class {
 					s.pos = start;
 					return resumed ? Resume.done(s, key, entry, true, acc) : acc;
 				}
-				if (checkLoop && s.pos === start) {
+				if (s.pos === start) {
 					s.mode = CUT;
 					return Fail;
 				}