@thomasfosterau/effect-parse 0.1.0 → 0.2.0

package/dist/internal/numbers.d.ts

@@ -1,9 +1,7 @@
-/**
- * Number conversions shared by the `Ascii` and `Text` parsers and the
- * compilers.
- */
-import type { Input } from "../Input.js";
-import { Fail } from "../Input.js";
+import { Fail, Input } from "../Input.js";
+//#region src/internal/numbers.d.ts
+/** The text of an input slice: as is for a string, Latin-1 for bytes, joined for tokens. */
+export declare const toText: (s: Input) => string;
 /** The value of the text matched by `Ascii.float` and `Text.float`. */
 export declare const toFloat: (s: Input) => number;
 /**
@@ -20,8 +18,8 @@ export declare const floatText: <P extends object>(p: P) => P;
  * when that is near the end of a partial input.
  */
 export declare const floatScan: {
-    end: number;
-    read: number;
+  end: number;
+  read: number;
 };
 /**
  * Matches and converts what `Ascii.float` matches at `i`, when it is in
@@ -38,4 +36,5 @@ export declare const floatScan: {
 export declare const scanFloatString: (s: string, i: number, end: number) => number | Fail | undefined;
 /** {@link scanFloatString} on bytes, or the units of an ASCII compatible encoding. */
 export declare const scanFloatBytes: (b: Uint8Array, i: number, end: number) => number | Fail | undefined;
+//#endregion
 //# sourceMappingURL=numbers.d.ts.map

package/dist/internal/numbers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"numbers.d.ts","sourceRoot":"","sources":["../../src/internal/numbers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AACxC,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAMlC,uEAAuE;AACvE,eAAO,MAAM,OAAO,MAAO,KAAK,KAAG,MAYlC,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,UAAU,iBAAwB,CAAA;AAE/C,2CAA2C;AAC3C,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,MAAM,KAAK,CAAC,KAAG,CAGlD,CAAA;AAKD;;;;GAIG;AACH,eAAO,MAAM,SAAS;IAAK,GAAG;IAAK,IAAI;CAAK,CAAA;AAqE5C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,MAAO,MAAM,KAAK,MAAM,OAAO,MAAM,KAAG,MAAM,GAAG,IAAI,GAAG,SAgFnF,CAAA;AAED,sFAAsF;AACtF,eAAO,MAAM,cAAc,MAAO,UAAU,KAAK,MAAM,OAAO,MAAM,KAAG,MAAM,GAAG,IAAI,GAAG,SA2EtF,CAAA"}
+{"version":3,"file":"numbers.d.ts","names":[],"sources":["../../src/internal/numbers.ts"],"mappings":";;;qBAUa,SAAU,GAAG;;qBAIb,UAAW,GAAG;;;;;;qBAmBd,YAAU;;qBAGV,YAAa,kBAAkB,GAAG,MAAI;;;;;;qBAatC;;;;;;;;;;;;;;;;qBAiFA,kBAAmB,WAAW,WAAW,yBAAuB;;qBAmFhE,iBAAkB,GAAG,YAAY,WAAW,yBAAuB"}

package/dist/internal/numbers.js

@@ -1,302 +1,272 @@
+import * as Predicate from "effect/Predicate";
 import { Fail } from "../Input.js";
 import { latin1 } from "./text.js";
-const toText = (s) => typeof s === "string" ? s : s instanceof Uint8Array ? latin1.text(s, 0, s.length) : s.join("");
+//#region src/internal/numbers.ts
+/**
+* Number conversions shared by the `Ascii` and `Text` parsers and the
+* compilers.
+*/
+/** The text of an input slice: as is for a string, Latin-1 for bytes, joined for tokens. */
+const toText = (s) => Predicate.isString(s) ? s : s instanceof Uint8Array ? latin1.text(s, 0, s.length) : s.join("");
 /** The value of the text matched by `Ascii.float` and `Text.float`. */
-export const toFloat = (s) => {
-    if (typeof s === "string") {
-        // Plain decimal notation (as opposed to `inf` or `nan`) ends in a digit or "."
-        const last = s.charCodeAt(s.length - 1);
-        if ((last >= 48 && last <= 57) || last === 46)
-            return Number(s);
-    }
-    const t = toText(s).toLowerCase();
-    const negative = t.startsWith("-");
-    const body = t.startsWith("-") || t.startsWith("+") ? t.slice(1) : t;
-    if (body === "nan")
-        return NaN;
-    if (body.startsWith("inf"))
-        return negative ? -Infinity : Infinity;
-    return Number(t);
+const toFloat = (s) => {
+	if (Predicate.isString(s)) {
+		const last = s.charCodeAt(s.length - 1);
+		if (last >= 48 && last <= 57 || last === 46) return Number(s);
+	}
+	const t = toText(s).toLowerCase();
+	const negative = t.startsWith("-");
+	const body = t.startsWith("-") || t.startsWith("+") ? t.slice(1) : t;
+	if (body === "nan") return NaN;
+	if (body.startsWith("inf")) return negative ? -Infinity : Infinity;
+	return Number(t);
 };
 /**
- * The parsers that `Ascii.float` and `Text.float` map with `toFloat`: the
- * compilers replace them by {@link scanFloatString} and
- * {@link scanFloatBytes} when the text is in decimal notation.
- */
-export const floatTexts = new WeakSet();
+* The parsers that `Ascii.float` and `Text.float` map with `toFloat`: the
+* compilers replace them by {@link scanFloatString} and
+* {@link scanFloatBytes} when the text is in decimal notation.
+*/
+const floatTexts = /*#__PURE__*/ new WeakSet();
 /** Adds a parser to {@link floatTexts}. */
-export const floatText = (p) => {
-    floatTexts.add(p);
-    return p;
+const floatText = (p) => {
+	floatTexts.add(p);
+	return p;
 };
 /** The powers of ten that doubles represent exactly. */
-const exact = Array.from({ length: 23 }, (_, i) => Number(`1e${i}`));
+const exact = /*#__PURE__*/ Array.from({ length: 23 }, (_, i) => Number(`1e${i}`));
 /**
- * Where the latest scan ended, when it succeeded, and the furthest offset it
- * read (when it succeeded or failed): streaming builds re-run the parser
- * when that is near the end of a partial input.
- */
-export const floatScan = { end: 0, read: 0 };
+* Where the latest scan ended, when it succeeded, and the furthest offset it
+* read (when it succeeded or failed): streaming builds re-run the parser
+* when that is near the end of a partial input.
+*/
+const floatScan = {
+	end: 0,
+	read: 0
+};
 const isDigit = (c) => c >= 48 && c <= 57;
-// Exact products of doubles (Dekker), without allocating: `a * b` is
-// `productHi + productLo` exactly, barring overflow and underflow
-const Split = 134217729; // 2^27 + 1
+const Split = 134217729;
 let productHi = 0;
 let productLo = 0;
 const twoProduct = (a, b) => {
-    const p = a * b;
-    let t = Split * a;
-    const ah = t - (t - a);
-    const al = a - ah;
-    t = Split * b;
-    const bh = t - (t - b);
-    const bl = b - bh;
-    productHi = p;
-    productLo = ((ah * bh - p) + ah * bl + al * bh) + al * bl;
+	const p = a * b;
+	let t = Split * a;
+	const ah = t - (t - a);
+	const al = a - ah;
+	t = Split * b;
+	const bh = t - (t - b);
+	const bl = b - bh;
+	productHi = p;
+	productLo = ah * bh - p + ah * bl + al * bh + al * bl;
 };
 /** 2^-96: a bound on the relative error of {@link decimal}'s 19-digit path. */
 const Error19 = 1 / 2 ** 96;
 /**
- * The double nearest to `±(high * 10^low digits + low) * 10^e10`, where
- * `high` holds the first 15 significant digits, and `low` the next `lowDigits`
- * (at most 4). Returns `undefined` when this can't tell it apart from the
- * neighbouring doubles, for the caller to use `Number`.
- *
- * Up to 15 digits, the digits and a power of ten up to 10^22 are exact
- * doubles, so one multiplication or division rounds correctly (Clinger's
- * fast path). Up to 19 digits, the digits are an exact sum of two doubles,
- * and multiplying or dividing that by an exact power of ten gives the value
- * to within a relative 2^-96 (double-double arithmetic). It is then rounded
- * once, and kept only if the bounds of that error round to the same double:
- * this is never the case for an exact tie, so ties go to `Number` too.
- */
+* The double nearest to `±(high * 10^low digits + low) * 10^e10`, where
+* `high` holds the first 15 significant digits, and `low` the next `lowDigits`
+* (at most 4). Returns `undefined` when this can't tell it apart from the
+* neighbouring doubles, for the caller to use `Number`.
+*
+* Up to 15 digits, the digits and a power of ten up to 10^22 are exact
+* doubles, so one multiplication or division rounds correctly (Clinger's
+* fast path). Up to 19 digits, the digits are an exact sum of two doubles,
+* and multiplying or dividing that by an exact power of ten gives the value
+* to within a relative 2^-96 (double-double arithmetic). It is then rounded
+* once, and kept only if the bounds of that error round to the same double:
+* this is never the case for an exact tie, so ties go to `Number` too.
+*/
 const decimal = (negative, high, low, lowDigits, e10) => {
-    let v;
-    if (lowDigits === 0) {
-        if (e10 > 22 || e10 < -22)
-            return undefined;
-        v = e10 === 0 ? high : e10 > 0 ? high * exact[e10] : high / exact[-e10];
-    }
-    else {
-        if (e10 > 22 || e10 < -22)
-            return undefined;
-        // The digits: high * 10^lowDigits + low = wh + wl, exactly
-        twoProduct(high, exact[lowDigits]);
-        const wh = productHi + low;
-        const wl = productLo + (low - (wh - productHi));
-        let xh;
-        let xl;
-        if (e10 >= 0) {
-            const p = exact[e10];
-            twoProduct(wh, p);
-            xh = productHi;
-            xl = productLo + wl * p;
-        }
-        else {
-            const p = exact[-e10];
-            xh = wh / p;
-            twoProduct(xh, p);
-            xl = ((wh - productHi) - productLo + wl) / p;
-        }
-        v = xh + xl;
-        const error = (xh < 0 ? -xh : xh) * Error19;
-        if (xh + (xl + error) !== v || xh + (xl - error) !== v)
-            return undefined;
-    }
-    return negative ? -v : v;
+	let v;
+	if (lowDigits === 0) {
+		if (e10 > 22 || e10 < -22) return void 0;
+		v = e10 === 0 ? high : e10 > 0 ? high * exact[e10] : high / exact[-e10];
+	} else {
+		if (e10 > 22 || e10 < -22) return void 0;
+		twoProduct(high, exact[lowDigits]);
+		const wh = productHi + low;
+		const wl = productLo + (low - (wh - productHi));
+		let xh;
+		let xl;
+		if (e10 >= 0) {
+			const p = exact[e10];
+			twoProduct(wh, p);
+			xh = productHi;
+			xl = productLo + wl * p;
+		} else {
+			const p = exact[-e10];
+			xh = wh / p;
+			twoProduct(xh, p);
+			xl = (wh - productHi - productLo + wl) / p;
+		}
+		v = xh + xl;
+		const error = (xh < 0 ? -xh : xh) * Error19;
+		if (xh + (xl + error) !== v || xh + (xl - error) !== v) return void 0;
+	}
+	return negative ? -v : v;
 };
 /**
- * Matches and converts what `Ascii.float` matches at `i`, when it is in
- * decimal notation: an optional sign, then digits or "." (the other forms,
- * `nan` and `inf`, start with a letter). Returns the value, setting
- * `floatScan.end`; `Fail` if the float parser fails there (always with
- * `Backtrack`); or `undefined` if the text does not start like a decimal
- * number, for the caller to run the parser.
- *
- * Numbers with up to 19 significant digits and a decimal exponent up to 22
- * are converted by {@link decimal}, the rest by `Number`, so the value is
- * always what `Number` gives for the text.
- */
-export const scanFloatString = (s, i, end) => {
-    const start = i;
-    let c = i < end ? s.charCodeAt(i) : -1;
-    if (c === 45 || c === 43) {
-        c = i + 1 < end ? s.charCodeAt(i + 1) : -1;
-        if (!isDigit(c) && c !== 46)
-            return undefined;
-        i++;
-    }
-    else if (!isDigit(c) && c !== 46) {
-        return undefined;
-    }
-    // The first 15 significant digits, the next 4, how many there are in all,
-    // and the decimal exponent of the last one kept
-    let high = 0;
-    let low = 0;
-    let digits = 0;
-    let e10 = 0;
-    if (c !== 46) {
-        do {
-            if (digits < 15) {
-                if (high !== 0 || c !== 48) {
-                    high = high * 10 + (c - 48);
-                    digits++;
-                }
-            }
-            else {
-                if (digits < 19)
-                    low = low * 10 + (c - 48);
-                else
-                    e10++;
-                digits++;
-            }
-            c = ++i < end ? s.charCodeAt(i) : -1;
-        } while (isDigit(c));
-        if (c === 46)
-            c = ++i < end ? s.charCodeAt(i) : -1;
-    }
-    else {
-        // "." must be followed by a digit
-        c = ++i < end ? s.charCodeAt(i) : -1;
-        if (!isDigit(c)) {
-            floatScan.read = i;
-            return Fail;
-        }
-    }
-    while (isDigit(c)) {
-        if (digits < 15) {
-            if (high !== 0 || c !== 48) {
-                high = high * 10 + (c - 48);
-                digits++;
-            }
-            e10--;
-        }
-        else {
-            if (digits < 19) {
-                low = low * 10 + (c - 48);
-                e10--;
-            }
-            digits++;
-        }
-        c = ++i < end ? s.charCodeAt(i) : -1;
-    }
-    let read = i;
-    if (c === 101 || c === 69) {
-        // The exponent is optional: without digits, it is not consumed
-        let j = i + 1;
-        c = j < end ? s.charCodeAt(j) : -1;
-        const negative = c === 45;
-        if (negative || c === 43)
-            c = ++j < end ? s.charCodeAt(j) : -1;
-        if (isDigit(c)) {
-            let e = 0;
-            do {
-                // Past this, the number can only overflow or underflow
-                if (e < 1e6)
-                    e = e * 10 + (c - 48);
-                c = ++j < end ? s.charCodeAt(j) : -1;
-            } while (isDigit(c));
-            e10 += negative ? -e : e;
-            i = j;
-        }
-        read = j;
-    }
-    floatScan.end = i;
-    floatScan.read = read;
-    const negative = s.charCodeAt(start) === 45;
-    if (high === 0)
-        return negative ? -0 : 0;
-    const v = digits > 19 ? undefined : decimal(negative, high, low, digits > 15 ? digits - 15 : 0, e10);
-    return v === undefined ? Number(s.slice(start, i)) : v;
+* Matches and converts what `Ascii.float` matches at `i`, when it is in
+* decimal notation: an optional sign, then digits or "." (the other forms,
+* `nan` and `inf`, start with a letter). Returns the value, setting
+* `floatScan.end`; `Fail` if the float parser fails there (always with
+* `Backtrack`); or `undefined` if the text does not start like a decimal
+* number, for the caller to run the parser.
+*
+* Numbers with up to 19 significant digits and a decimal exponent up to 22
+* are converted by {@link decimal}, the rest by `Number`, so the value is
+* always what `Number` gives for the text.
+*/
+const scanFloatString = (s, i, end) => {
+	const start = i;
+	let c = i < end ? s.charCodeAt(i) : -1;
+	if (c === 45 || c === 43) {
+		c = i + 1 < end ? s.charCodeAt(i + 1) : -1;
+		if (!isDigit(c) && c !== 46) return void 0;
+		i++;
+	} else if (!isDigit(c) && c !== 46) return;
+	let high = 0;
+	let low = 0;
+	let digits = 0;
+	let e10 = 0;
+	if (c !== 46) {
+		do {
+			if (digits < 15) {
+				if (high !== 0 || c !== 48) {
+					high = high * 10 + (c - 48);
+					digits++;
+				}
+			} else {
+				if (digits < 19) low = low * 10 + (c - 48);
+				else e10++;
+				digits++;
+			}
+			c = ++i < end ? s.charCodeAt(i) : -1;
+		} while (isDigit(c));
+		if (c === 46) c = ++i < end ? s.charCodeAt(i) : -1;
+	} else {
+		c = ++i < end ? s.charCodeAt(i) : -1;
+		if (!isDigit(c)) {
+			floatScan.read = i;
+			return Fail;
+		}
+	}
+	while (isDigit(c)) {
+		if (digits < 15) {
+			if (high !== 0 || c !== 48) {
+				high = high * 10 + (c - 48);
+				digits++;
+			}
+			e10--;
+		} else {
+			if (digits < 19) {
+				low = low * 10 + (c - 48);
+				e10--;
+			}
+			digits++;
+		}
+		c = ++i < end ? s.charCodeAt(i) : -1;
+	}
+	let read = i;
+	if (c === 101 || c === 69) {
+		let j = i + 1;
+		c = j < end ? s.charCodeAt(j) : -1;
+		const negative = c === 45;
+		if (negative || c === 43) c = ++j < end ? s.charCodeAt(j) : -1;
+		if (isDigit(c)) {
+			let e = 0;
+			do {
+				if (e < 1e6) e = e * 10 + (c - 48);
+				c = ++j < end ? s.charCodeAt(j) : -1;
+			} while (isDigit(c));
+			e10 += negative ? -e : e;
+			i = j;
+		}
+		read = j;
+	}
+	floatScan.end = i;
+	floatScan.read = read;
+	const negative = s.charCodeAt(start) === 45;
+	if (high === 0) return negative ? -0 : 0;
+	const v = digits > 19 ? void 0 : decimal(negative, high, low, digits > 15 ? digits - 15 : 0, e10);
+	return v === void 0 ? Number(s.slice(start, i)) : v;
 };
 /** {@link scanFloatString} on bytes, or the units of an ASCII compatible encoding. */
-export const scanFloatBytes = (b, i, end) => {
-    const start = i;
-    let c = i < end ? b[i] : -1;
-    if (c === 45 || c === 43) {
-        c = i + 1 < end ? b[i + 1] : -1;
-        if (!isDigit(c) && c !== 46)
-            return undefined;
-        i++;
-    }
-    else if (!isDigit(c) && c !== 46) {
-        return undefined;
-    }
-    let high = 0;
-    let low = 0;
-    let digits = 0;
-    let e10 = 0;
-    if (c !== 46) {
-        do {
-            if (digits < 15) {
-                if (high !== 0 || c !== 48) {
-                    high = high * 10 + (c - 48);
-                    digits++;
-                }
-            }
-            else {
-                if (digits < 19)
-                    low = low * 10 + (c - 48);
-                else
-                    e10++;
-                digits++;
-            }
-            c = ++i < end ? b[i] : -1;
-        } while (isDigit(c));
-        if (c === 46)
-            c = ++i < end ? b[i] : -1;
-    }
-    else {
-        c = ++i < end ? b[i] : -1;
-        if (!isDigit(c)) {
-            floatScan.read = i;
-            return Fail;
-        }
-    }
-    while (isDigit(c)) {
-        if (digits < 15) {
-            if (high !== 0 || c !== 48) {
-                high = high * 10 + (c - 48);
-                digits++;
-            }
-            e10--;
-        }
-        else {
-            if (digits < 19) {
-                low = low * 10 + (c - 48);
-                e10--;
-            }
-            digits++;
-        }
-        c = ++i < end ? b[i] : -1;
-    }
-    let read = i;
-    if (c === 101 || c === 69) {
-        let j = i + 1;
-        c = j < end ? b[j] : -1;
-        const negative = c === 45;
-        if (negative || c === 43)
-            c = ++j < end ? b[j] : -1;
-        if (isDigit(c)) {
-            let e = 0;
-            do {
-                if (e < 1e6)
-                    e = e * 10 + (c - 48);
-                c = ++j < end ? b[j] : -1;
-            } while (isDigit(c));
-            e10 += negative ? -e : e;
-            i = j;
-        }
-        read = j;
-    }
-    floatScan.end = i;
-    floatScan.read = read;
-    const negative = b[start] === 45;
-    if (high === 0)
-        return negative ? -0 : 0;
-    const v = digits > 19 ? undefined : decimal(negative, high, low, digits > 15 ? digits - 15 : 0, e10);
-    return v === undefined ? Number(asciiText(b, start, i)) : v;
+const scanFloatBytes = (b, i, end) => {
+	const start = i;
+	let c = i < end ? b[i] : -1;
+	if (c === 45 || c === 43) {
+		c = i + 1 < end ? b[i + 1] : -1;
+		if (!isDigit(c) && c !== 46) return void 0;
+		i++;
+	} else if (!isDigit(c) && c !== 46) return;
+	let high = 0;
+	let low = 0;
+	let digits = 0;
+	let e10 = 0;
+	if (c !== 46) {
+		do {
+			if (digits < 15) {
+				if (high !== 0 || c !== 48) {
+					high = high * 10 + (c - 48);
+					digits++;
+				}
+			} else {
+				if (digits < 19) low = low * 10 + (c - 48);
+				else e10++;
+				digits++;
+			}
+			c = ++i < end ? b[i] : -1;
+		} while (isDigit(c));
+		if (c === 46) c = ++i < end ? b[i] : -1;
+	} else {
+		c = ++i < end ? b[i] : -1;
+		if (!isDigit(c)) {
+			floatScan.read = i;
+			return Fail;
+		}
+	}
+	while (isDigit(c)) {
+		if (digits < 15) {
+			if (high !== 0 || c !== 48) {
+				high = high * 10 + (c - 48);
+				digits++;
+			}
+			e10--;
+		} else {
+			if (digits < 19) {
+				low = low * 10 + (c - 48);
+				e10--;
+			}
+			digits++;
+		}
+		c = ++i < end ? b[i] : -1;
+	}
+	let read = i;
+	if (c === 101 || c === 69) {
+		let j = i + 1;
+		c = j < end ? b[j] : -1;
+		const negative = c === 45;
+		if (negative || c === 43) c = ++j < end ? b[j] : -1;
+		if (isDigit(c)) {
+			let e = 0;
+			do {
+				if (e < 1e6) e = e * 10 + (c - 48);
+				c = ++j < end ? b[j] : -1;
+			} while (isDigit(c));
+			e10 += negative ? -e : e;
+			i = j;
+		}
+		read = j;
+	}
+	floatScan.end = i;
+	floatScan.read = read;
+	const negative = b[start] === 45;
+	if (high === 0) return negative ? -0 : 0;
+	const v = digits > 19 ? void 0 : decimal(negative, high, low, digits > 15 ? digits - 15 : 0, e10);
+	return v === void 0 ? Number(asciiText(b, start, i)) : v;
 };
 /** The text of ASCII bytes. */
 const asciiText = (b, start, end) => String.fromCharCode.apply(null, b.subarray(start, end));
+//#endregion
+export { floatScan, floatText, floatTexts, scanFloatBytes, scanFloatString, toFloat, toText };
+
 //# sourceMappingURL=numbers.js.map