@thomasfosterau/effect-parse 0.1.0 → 0.2.0

package/dist/Ascii.js

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