@thomasfosterau/effect-parse 0.0.0-stage → 0.1.0

package/dist/Encoding.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Text encodings for the `Text` module.
+ *
+ * An {@link Encoding} tells the `Text` parsers how to read Unicode code
+ * points out of an input. JavaScript strings are read natively, without any
+ * conversion. Byte inputs are decoded as they are parsed, so offsets stay
+ * byte offsets, slices that are kept as bytes (`Parser.taken`) are
+ * zero-copy views, and partial input that ends in the middle of a character
+ * reports `Incomplete`.
+ *
+ * ```ts
+ * import { Encoding, Text } from "@thomasfosterau/effect-parse"
+ *
+ * Text.utf8.encoding === Encoding.utf8
+ * Text.make(Encoding.latin1) // the Text parsers for any Encoding, including your own
+ * ```
+ *
+ * @since 0.1.0
+ */
+import * as Option from "effect/Option";
+/**
+ * A text encoding: how to read Unicode code points out of an input. The
+ * `Text` module is generic over encodings, so one grammar can parse
+ * JavaScript strings, UTF-8 bytes, UTF-16 bytes and so on.
+ *
+ * Decoding is strict: malformed sequences (invalid UTF-8, unpaired UTF-16
+ * surrogates) are reported as invalid, never replaced.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface Encoding<I extends string | Uint8Array = string | Uint8Array> {
+    /** The name of the encoding, e.g. `"UTF-8"`. Used in error messages. */
+    readonly name: string;
+    /**
+     * The size of a code unit, in input units: 1 for strings, UTF-8 and
+     * Latin-1, 2 for UTF-16 bytes. Code points start at multiples of it.
+     */
+    readonly unit: number;
+    /**
+     * Whether every input unit below `0x80` encodes the ASCII character with
+     * that value, and is never part of a longer sequence. Enables fast paths.
+     */
+    readonly asciiCompatible: boolean;
+    /**
+     * Decodes the code point starting at `offset` (with `offset < end`).
+     * Returns the code point, `-1` if the input is malformed there, or `-2` if
+     * the input ends inside a sequence (more input could complete it).
+     */
+    readonly decode: (input: I, offset: number, end: number) => number;
+    /** The number of input units that encode a code point. */
+    readonly width: (codePoint: number) => number;
+    /** Encodes a string. Throws if the string can't be represented. */
+    readonly encode: (text: string) => I;
+    /**
+     * Decodes the units `[start, end)` to a string. The parsers only call it
+     * on ranges they have checked are well formed.
+     */
+    readonly text: (input: I, start: number, end: number) => string;
+}
+/**
+ * JavaScript strings, read as UTF-16 code units. Offsets are code-unit
+ * indices and slices are plain `String.prototype.slice`s. Unpaired
+ * surrogates are malformed.
+ *
+ * @since 0.1.0
+ * @category encodings
+ */
+export declare const string: Encoding<string>;
+/**
+ * UTF-8 bytes. Overlong encodings, surrogates and code points above
+ * U+10FFFF are malformed.
+ *
+ * @since 0.1.0
+ * @category encodings
+ */
+export declare const utf8: Encoding<Uint8Array>;
+/**
+ * UTF-16 bytes, little endian. Unpaired surrogates are malformed.
+ *
+ * @since 0.1.0
+ * @category encodings
+ */
+export declare const utf16le: Encoding<Uint8Array>;
+/**
+ * UTF-16 bytes, big endian. Unpaired surrogates are malformed.
+ *
+ * @since 0.1.0
+ * @category encodings
+ */
+export declare const utf16be: Encoding<Uint8Array>;
+/**
+ * ISO-8859-1 (Latin-1) bytes: each byte is the code point U+0000 to U+00FF
+ * of the same value.
+ *
+ * @since 0.1.0
+ * @category encodings
+ */
+export declare const latin1: Encoding<Uint8Array>;
+/**
+ * Detects the encoding of bytes from a byte order mark: UTF-8
+ * (`EF BB BF`), UTF-16LE (`FF FE`) or UTF-16BE (`FE FF`). The mark itself
+ * is not skipped; parse it with `Text.bom`.
+ *
+ * @example
+ * ```ts
+ * import { Encoding } from "@thomasfosterau/effect-parse"
+ *
+ * Encoding.sniff(new Uint8Array([0xff, 0xfe, 0x41, 0x00])) // Option.some(Encoding.utf16le)
+ * ```
+ *
+ * @since 0.1.0
+ * @category utils
+ */
+export declare const sniff: (bytes: Uint8Array) => Option.Option<Encoding<Uint8Array>>;
+//# sourceMappingURL=Encoding.d.ts.map

package/dist/Encoding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Encoding.d.ts","sourceRoot":"","sources":["../src/Encoding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC;;;;;;;;;;GAUG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC,SAAS,MAAM,GAAG,UAAU,GAAG,MAAM,GAAG,UAAU;IAC3E,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB;;;OAGG;IACH,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAA;IACjC;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,MAAM,CAAA;IAClE,0DAA0D;IAC1D,QAAQ,CAAC,KAAK,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,CAAA;IAC7C,mEAAmE;IACnE,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,CAAC,CAAA;IACpC;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,MAAM,CAAA;CAChE;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAmB,CAAA;AAEvD;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAiB,CAAA;AAEvD;;;;;GAKG;AACH,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,UAAU,CAAoB,CAAA;AAE7D;;;;;GAKG;AACH,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,UAAU,CAAoB,CAAA;AAE7D;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAmB,CAAA;AAE3D;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,KAAK,UAAW,UAAU,KAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,CAK3E,CAAA"}

package/dist/Encoding.js

@@ -0,0 +1,85 @@
+/**
+ * Text encodings for the `Text` module.
+ *
+ * An {@link Encoding} tells the `Text` parsers how to read Unicode code
+ * points out of an input. JavaScript strings are read natively, without any
+ * conversion. Byte inputs are decoded as they are parsed, so offsets stay
+ * byte offsets, slices that are kept as bytes (`Parser.taken`) are
+ * zero-copy views, and partial input that ends in the middle of a character
+ * reports `Incomplete`.
+ *
+ * ```ts
+ * import { Encoding, Text } from "@thomasfosterau/effect-parse"
+ *
+ * Text.utf8.encoding === Encoding.utf8
+ * Text.make(Encoding.latin1) // the Text parsers for any Encoding, including your own
+ * ```
+ *
+ * @since 0.1.0
+ */
+import * as Option from "effect/Option";
+import * as internal from "./internal/text.js";
+/**
+ * JavaScript strings, read as UTF-16 code units. Offsets are code-unit
+ * indices and slices are plain `String.prototype.slice`s. Unpaired
+ * surrogates are malformed.
+ *
+ * @since 0.1.0
+ * @category encodings
+ */
+export const string = internal.string;
+/**
+ * UTF-8 bytes. Overlong encodings, surrogates and code points above
+ * U+10FFFF are malformed.
+ *
+ * @since 0.1.0
+ * @category encodings
+ */
+export const utf8 = internal.utf8;
+/**
+ * UTF-16 bytes, little endian. Unpaired surrogates are malformed.
+ *
+ * @since 0.1.0
+ * @category encodings
+ */
+export const utf16le = internal.utf16le;
+/**
+ * UTF-16 bytes, big endian. Unpaired surrogates are malformed.
+ *
+ * @since 0.1.0
+ * @category encodings
+ */
+export const utf16be = internal.utf16be;
+/**
+ * ISO-8859-1 (Latin-1) bytes: each byte is the code point U+0000 to U+00FF
+ * of the same value.
+ *
+ * @since 0.1.0
+ * @category encodings
+ */
+export const latin1 = internal.latin1;
+/**
+ * Detects the encoding of bytes from a byte order mark: UTF-8
+ * (`EF BB BF`), UTF-16LE (`FF FE`) or UTF-16BE (`FE FF`). The mark itself
+ * is not skipped; parse it with `Text.bom`.
+ *
+ * @example
+ * ```ts
+ * import { Encoding } from "@thomasfosterau/effect-parse"
+ *
+ * Encoding.sniff(new Uint8Array([0xff, 0xfe, 0x41, 0x00])) // Option.some(Encoding.utf16le)
+ * ```
+ *
+ * @since 0.1.0
+ * @category utils
+ */
+export const sniff = (bytes) => {
+    if (bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf)
+        return Option.some(utf8);
+    if (bytes[0] === 0xff && bytes[1] === 0xfe)
+        return Option.some(utf16le);
+    if (bytes[0] === 0xfe && bytes[1] === 0xff)
+        return Option.some(utf16be);
+    return Option.none();
+};
+//# sourceMappingURL=Encoding.js.map

package/dist/Encoding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Encoding.js","sourceRoot":"","sources":["../src/Encoding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,QAAQ,MAAM,oBAAoB,CAAA;AA2C9C;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,MAAM,GAAqB,QAAQ,CAAC,MAAM,CAAA;AAEvD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,IAAI,GAAyB,QAAQ,CAAC,IAAI,CAAA;AAEvD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,OAAO,GAAyB,QAAQ,CAAC,OAAO,CAAA;AAE7D;;;;;GAKG;AACH,MAAM,CAAC,MAAM,OAAO,GAAyB,QAAQ,CAAC,OAAO,CAAA;AAE7D;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,MAAM,GAAyB,QAAQ,CAAC,MAAM,CAAA;AAE3D;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,KAAiB,EAAuC,EAAE;IAC9E,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI;QAAE,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IACzF,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI;QAAE,OAAO,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IACvE,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI;QAAE,OAAO,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IACvE,OAAO,MAAM,CAAC,IAAI,EAAE,CAAA;AACtB,CAAC,CAAA"}

package/dist/Expression.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Operator-precedence expression parsing with a Pratt parser (from
+ * `nom-language`'s `precedence`, and winnow's expression parser).
+ *
+ * Describe the operand parser and a table of prefix, postfix and infix
+ * operators with their precedence (higher binds tighter) and associativity.
+ * Each operator carries a function that folds its operands into a result.
+ *
+ * @example
+ * ```ts
+ * import { Ascii, Expression, Parser, Token } from "@thomasfosterau/effect-parse"
+ *
+ * const op = (s: string) => Parser.delimited(Ascii.space0, Token.literal(s), Ascii.space0)
+ *
+ * const arithmetic: Parser.Parser<number, string> = Expression.make({
+ *   operand: Parser.alt(
+ *     Ascii.decInt,
+ *     Parser.delimited(op("("), Parser.suspend(() => arithmetic), op(")"))
+ *   ),
+ *   operators: [
+ *     Expression.prefix(op("-"), 4, (_, x) => -x),
+ *     Expression.postfix(op("!"), 5, (x) => factorial(x)),
+ *     Expression.infixRight(op("^"), 3, (l, _, r) => l ** r),
+ *     Expression.infixLeft(op("*"), 2, (l, _, r) => l * r),
+ *     Expression.infixLeft(op("/"), 2, (l, _, r) => l / r),
+ *     Expression.infixLeft(op("+"), 1, (l, _, r) => l + r),
+ *     Expression.infixLeft(op("-"), 1, (l, _, r) => l - r)
+ *   ]
+ * })
+ *
+ * declare const factorial: (n: number) => number
+ * Parser.parse(arithmetic, "1 + 2 * 3 ^ 2") // Result.succeed(19)
+ * ```
+ *
+ * @since 0.1.0
+ */
+import type { Input } from "./Input.js";
+import type { Parser } from "./Parser.js";
+/**
+ * An operator in an expression grammar.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type Operator<A, E = never, R = never, I extends Input = string> = Prefix<A, E, R, I> | Postfix<A, E, R, I> | Infix<A, E, R, I>;
+interface OperatorBase<E, R, I extends Input> {
+    readonly parser: Parser<unknown, E, R, I>;
+    readonly precedence: number;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+export interface Prefix<A, E = never, R = never, I extends Input = string> extends OperatorBase<E, R, I> {
+    readonly _tag: "Prefix";
+    readonly fold: (op: any, operand: A) => A;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+export interface Postfix<A, E = never, R = never, I extends Input = string> extends OperatorBase<E, R, I> {
+    readonly _tag: "Postfix";
+    readonly fold: (operand: A, op: any) => A;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+export interface Infix<A, E = never, R = never, I extends Input = string> extends OperatorBase<E, R, I> {
+    readonly _tag: "Infix";
+    readonly associativity: "left" | "right";
+    readonly fold: (left: A, op: any, right: A) => A;
+}
+/**
+ * A prefix operator, e.g. unary minus.
+ *
+ * @since 0.1.0
+ * @category operators
+ */
+export declare const prefix: <O, E, R, I extends Input, A>(parser: Parser<O, E, R, I>, precedence: number, fold: (op: O, operand: A) => A) => Prefix<A, E, R, I>;
+/**
+ * A postfix operator, e.g. factorial or a function call suffix.
+ *
+ * @since 0.1.0
+ * @category operators
+ */
+export declare const postfix: <O, E, R, I extends Input, A>(parser: Parser<O, E, R, I>, precedence: number, fold: (operand: A, op: O) => A) => Postfix<A, E, R, I>;
+/**
+ * A left-associative infix operator: `a - b - c` is `(a - b) - c`.
+ *
+ * @since 0.1.0
+ * @category operators
+ */
+export declare const infixLeft: <O, E, R, I extends Input, A>(parser: Parser<O, E, R, I>, precedence: number, fold: (left: A, op: O, right: A) => A) => Infix<A, E, R, I>;
+/**
+ * A right-associative infix operator: `a ^ b ^ c` is `a ^ (b ^ c)`.
+ *
+ * @since 0.1.0
+ * @category operators
+ */
+export declare const infixRight: <O, E, R, I extends Input, A>(parser: Parser<O, E, R, I>, precedence: number, fold: (left: A, op: O, right: A) => A) => Infix<A, E, R, I>;
+type OpError<Op> = Op extends OperatorBase<infer E, infer _R, infer _I> ? E : never;
+type OpServices<Op> = Op extends OperatorBase<infer _E, infer R, infer _I> ? R : never;
+type OpInput<Op> = [Op] extends [never] ? Input : [Op] extends [OperatorBase<infer _E, infer _R, infer I>] ? I : never;
+/**
+ * Builds an expression parser from an operand parser and an operator table.
+ *
+ * Precedences are compared numerically: higher binds tighter. A prefix
+ * operator applies to everything that binds tighter than it, so with `-`
+ * at precedence 4 and `^` at 3, `-2 ^ 2` parses as `(-2) ^ 2`.
+ *
+ * When several operators of the same kind match, the first one in the
+ * table wins, so list longer operators (`<=`) before their prefixes (`<`).
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const make: <A, E, R, I extends Input, const Ops extends ReadonlyArray<Operator<A, any, any, any>>>(options: {
+    readonly operand: Parser<A, E, R, I>;
+    readonly operators: Ops;
+}) => Parser<A, E | OpError<Ops[number]>, R | OpServices<Ops[number]>, I & OpInput<Ops[number]>>;
+export {};
+//# sourceMappingURL=Expression.d.ts.map

package/dist/Expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Expression.d.ts","sourceRoot":"","sources":["../src/Expression.ts"],"names":[],"mappings":"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"}

package/dist/Expression.js

@@ -0,0 +1,139 @@
+import { Fail, mergeFailures } from "./Input.js";
+import { make as makeParser } from "./Parser.js";
+/**
+ * A prefix operator, e.g. unary minus.
+ *
+ * @since 0.1.0
+ * @category operators
+ */
+export const prefix = (parser, precedence, fold) => ({ _tag: "Prefix", parser, precedence, fold });
+/**
+ * A postfix operator, e.g. factorial or a function call suffix.
+ *
+ * @since 0.1.0
+ * @category operators
+ */
+export const postfix = (parser, precedence, fold) => ({ _tag: "Postfix", parser, precedence, fold });
+/**
+ * A left-associative infix operator: `a - b - c` is `(a - b) - c`.
+ *
+ * @since 0.1.0
+ * @category operators
+ */
+export const infixLeft = (parser, precedence, fold) => ({ _tag: "Infix", associativity: "left", parser, precedence, fold });
+/**
+ * A right-associative infix operator: `a ^ b ^ c` is `a ^ (b ^ c)`.
+ *
+ * @since 0.1.0
+ * @category operators
+ */
+export const infixRight = (parser, precedence, fold) => ({ _tag: "Infix", associativity: "right", parser, precedence, fold });
+/**
+ * Builds an expression parser from an operand parser and an operator table.
+ *
+ * Precedences are compared numerically: higher binds tighter. A prefix
+ * operator applies to everything that binds tighter than it, so with `-`
+ * at precedence 4 and `^` at 3, `-2 ^ 2` parses as `(-2) ^ 2`.
+ *
+ * When several operators of the same kind match, the first one in the
+ * table wins, so list longer operators (`<=`) before their prefixes (`<`).
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export const make = (options) => {
+    const operand = options.operand.step;
+    const prefixes = options.operators.filter((o) => o._tag === "Prefix");
+    const postfixes = options.operators.filter((o) => o._tag === "Postfix");
+    const infixes = options.operators.filter((o) => o._tag === "Infix");
+    // Attempts each operator in turn. Returns the index of the first match
+    // (with its output in `matched`), -1 if none matched, or -2 on a fatal
+    // failure. Expectations of failed attempts are accumulated in `failure`.
+    let matched;
+    let failure;
+    const tryOps = (state, ops, mustConsume) => {
+        const start = state.pos;
+        for (let i = 0; i < ops.length; i++) {
+            const out = ops[i].parser.step(state);
+            if (out !== Fail) {
+                // A prefix or postfix operator matching nothing would apply forever
+                if (mustConsume && state.pos === start) {
+                    state.failMessage("Cut", "Assert", "prefix and postfix operators must always consume");
+                    return -2;
+                }
+                matched = out;
+                return i;
+            }
+            if (state.mode !== "Backtrack")
+                return -2;
+            failure = failure === undefined ? state.failure : mergeFailures(failure, state.failure);
+            state.pos = start;
+        }
+        return -1;
+    };
+    const expr = (state, minPower) => {
+        let lhs;
+        failure = undefined;
+        const p = tryOps(state, prefixes, true);
+        if (p === -2)
+            return Fail;
+        if (p >= 0) {
+            const op = prefixes[p];
+            const opOut = matched;
+            const operandValue = expr(state, op.precedence * 2);
+            if (operandValue === Fail)
+                return Fail;
+            lhs = op.fold(opOut, operandValue);
+        }
+        else {
+            const prefixFailure = failure;
+            lhs = operand(state);
+            if (lhs === Fail) {
+                if (prefixFailure !== undefined && state.mode === "Backtrack") {
+                    state.failWith("Backtrack", mergeFailures(prefixFailure, state.failure));
+                }
+                return Fail;
+            }
+        }
+        while (true) {
+            const start = state.pos;
+            failure = undefined;
+            const q = tryOps(state, postfixes, true);
+            if (q === -2)
+                return Fail;
+            if (q >= 0) {
+                const op = postfixes[q];
+                if (op.precedence * 2 < minPower) {
+                    state.pos = start;
+                    break;
+                }
+                lhs = op.fold(lhs, matched);
+                continue;
+            }
+            const postfixFailure = failure;
+            const i = tryOps(state, infixes, false);
+            if (i === -2)
+                return Fail;
+            if (i < 0) {
+                const f = postfixFailure === undefined ? failure : failure === undefined ? postfixFailure : mergeFailures(postfixFailure, failure);
+                if (f !== undefined && f.offset === state.pos)
+                    state.setHint(f.offset, f.expected);
+                break;
+            }
+            const op = infixes[i];
+            const leftPower = op.precedence * 2;
+            if (leftPower < minPower) {
+                state.pos = start;
+                break;
+            }
+            const opOut = matched;
+            const rhs = expr(state, op.associativity === "left" ? leftPower + 1 : leftPower);
+            if (rhs === Fail)
+                return Fail;
+            lhs = op.fold(lhs, opOut, rhs);
+        }
+        return lhs;
+    };
+    return makeParser((state) => expr(state, 0), "expression");
+};
+//# sourceMappingURL=Expression.js.map

package/dist/Expression.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Expression.js","sourceRoot":"","sources":["../src/Expression.ts"],"names":[],"mappings":"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"}