parser-combinators 1.2.1 → 1.2.3

package/dist-esm/parsers/anyString.js

@@ -0,0 +1,84 @@
+import { failure, success } from "../types";
+/**
+ * Optimization for `any(str(), str(), ...)` which replaces the parser tree with one parser which tries all strings together
+ */
+export function anyString(matches) {
+    const lastMatchInQuotes = `'${matches[matches.length - 1][0]}'`;
+    let tree;
+    return Object.assign((ctx) => {
+        tree ??= createSearchTree(matches);
+        const result = searchThroughTree(tree, ctx.text, ctx.index);
+        if (result) {
+            return success({ ...ctx, index: result.end }, matches[result.matchIndex][2](matches[result.matchIndex][0]));
+        }
+        else {
+            return failure(ctx, lastMatchInQuotes, ['any', lastMatchInQuotes]);
+        }
+    }, { parserType: 'anyString', matches });
+}
+function createSearchTree(matches) {
+    const tree = new Map();
+    matches.forEach((match, index) => addMatchToTree(tree, match, index));
+    return tree;
+}
+function addMatchToTree(node, match, idIndex, charIndex = 0) {
+    if (charIndex >= match[0].length) {
+        if (node.matchIndex != undefined) {
+            if (node.matchIndex > idIndex) {
+                node.matchIndex = idIndex;
+            }
+        }
+        else {
+            node.matchIndex = idIndex;
+        }
+    }
+    else {
+        const char = match[0][charIndex];
+        const lowercase = char.toLowerCase();
+        const uppercase = char.toUpperCase();
+        const newNode = new Map();
+        if (match[1] && (lowercase !== uppercase)) {
+            const lower = node.get(lowercase) ?? newNode;
+            const upper = node.get(uppercase) ?? newNode;
+            node.set(lowercase, lower);
+            node.set(uppercase, upper);
+            addMatchToTree(lower, match, idIndex, charIndex + 1);
+            if (lower !== upper) {
+                addMatchToTree(upper, match, idIndex, charIndex + 1);
+            }
+        }
+        else {
+            const charNode = node.get(char) ?? newNode;
+            node.set(char, charNode);
+            const lower = node.get(lowercase);
+            if (lower === node.get(uppercase)) {
+                const copy = new Map(lower.entries());
+                copy.matchIndex = lower.matchIndex;
+                node.set(uppercase, copy);
+            }
+            addMatchToTree(charNode, match, idIndex, charIndex + 1);
+        }
+    }
+}
+function searchThroughTree(node, text, start) {
+    let lastSuccessIndex = undefined;
+    let lastSuccessMatchIndex = undefined;
+    let currentNode = node;
+    for (let index = start; index < text.length; index++) {
+        const char = text[index];
+        if (currentNode.matchIndex != undefined && (lastSuccessMatchIndex == undefined || currentNode.matchIndex <= lastSuccessMatchIndex)) {
+            lastSuccessIndex = index;
+            lastSuccessMatchIndex = currentNode.matchIndex;
+        }
+        currentNode = currentNode.get(char);
+        if (!currentNode)
+            break;
+    }
+    if (currentNode && currentNode.matchIndex != undefined && (lastSuccessMatchIndex == undefined || currentNode.matchIndex <= lastSuccessMatchIndex)) {
+        lastSuccessIndex = text.length;
+        lastSuccessMatchIndex = currentNode.matchIndex;
+    }
+    return lastSuccessIndex == undefined
+        ? undefined
+        : { end: lastSuccessIndex, matchIndex: lastSuccessMatchIndex };
+}

package/dist-esm/parsers/between.d.ts

@@ -0,0 +1,5 @@
+import { Parser } from '../types';
+/** Parses a sequence of three parsers.
+ * @returns A parser returning only the middle parser's result.
+ */
+export declare function between<T, U, V>(left: Parser<U>, parser: Parser<T>, right: Parser<V>): Parser<T>;

package/dist-esm/parsers/between.js

@@ -0,0 +1,21 @@
+import { isFailure, success } from '../types';
+/** Parses a sequence of three parsers.
+ * @returns A parser returning only the middle parser's result.
+ */
+export function between(left, parser, right) {
+    return (ctx) => {
+        const resLeft = left(ctx);
+        if (isFailure(resLeft)) {
+            return resLeft;
+        }
+        const resParse = parser(resLeft.ctx);
+        if (isFailure(resParse)) {
+            return resParse;
+        }
+        const resRight = right(resParse.ctx);
+        if (isFailure(resRight)) {
+            return resRight;
+        }
+        return success(resRight.ctx, resParse.value);
+    };
+}

package/dist-esm/parsers/exhaust.d.ts

@@ -0,0 +1,5 @@
+import { Parser } from '../types';
+/** Parses using the passed in parser, until the input is exhausted or until the `until` condition is satisfied.
+ * @returns A parser returning an array of parsed results.
+ */
+export declare function exhaust<T, V>(parser: Parser<T>, until?: Parser<V> | null): Parser<T[]>;

package/dist-esm/parsers/exhaust.js

@@ -0,0 +1,22 @@
+import { failure, isFailure, success } from '../types';
+/** Parses using the passed in parser, until the input is exhausted or until the `until` condition is satisfied.
+ * @returns A parser returning an array of parsed results.
+ */
+export function exhaust(parser, until = null) {
+    return (ctx) => {
+        const results = [];
+        while (true) {
+            const res = parser(ctx);
+            if (isFailure(res)) {
+                if (until === null || isFailure(until(ctx))) {
+                    return failure(res.ctx, res.expected, ['exhaust', ...res.history]);
+                }
+                return success(ctx, results);
+            }
+            ctx = res.ctx;
+            results.push(res.value);
+            if (res.ctx.index === res.ctx.text.length)
+                return success(res.ctx, results);
+        }
+    };
+}

package/dist-esm/parsers/index.d.ts

@@ -0,0 +1,12 @@
+export * from './any';
+export * from './between';
+export * from './exhaust';
+export * from './many';
+export * from './map';
+export * from './opt';
+export * from './regex';
+export * from './seq';
+export { str, stri } from './str';
+export * from './recovery';
+export * from './utilities';
+export * from './values';

package/dist-esm/parsers/index.js

@@ -0,0 +1,12 @@
+export * from './any';
+export * from './between';
+export * from './exhaust';
+export * from './many';
+export * from './map';
+export * from './opt';
+export * from './regex';
+export * from './seq';
+export { str, stri } from './str';
+export * from './recovery';
+export * from './utilities';
+export * from './values';

package/dist-esm/parsers/many.d.ts

@@ -0,0 +1,17 @@
+import { Parser } from "../types";
+/** Parses zero or more occurences of the given parser.
+ * @returns A parser returning an array of many parses.
+ */
+export declare function many<T>(parser: Parser<T>): Parser<T[]>;
+/** Parses zero or more occurences of the given parser, separated with the separator parser.
+ * @returns A parser returning an array of many parses, omitting the separator.
+ */
+export declare function zeroOrMany<T, V>(item: Parser<T>, separator?: Parser<V> | undefined): Parser<T[]>;
+/** Parses one or more occurences of the given parser, separated with the separator parser.
+ * @returns A parser returning an array of many parses, omitting the separator.
+ */
+export declare function oneOrMany<T, V>(item: Parser<T>, separator?: Parser<V> | undefined): Parser<T[]>;
+/** Parses one or more occurences of the given parser, separated with the separator parser.
+ * @returns A parser returning the result of many parses, reduced using the `reducer` function passed in.
+ */
+export declare function oneOrManyRed<T, V, U = T>(item: Parser<T>, separator: Parser<V>, reducer: (left: U | T, right: T, sep: V) => U): Parser<U | T>;

package/dist-esm/parsers/many.js

@@ -0,0 +1,121 @@
+import { failure, isFailure, success } from "../types";
+/** Parses zero or more occurences of the given parser.
+ * @returns A parser returning an array of many parses.
+ */
+export function many(parser) {
+    return (ctx) => {
+        const results = [];
+        while (true) {
+            const res = parser(ctx);
+            if (isFailure(res)) {
+                return success(ctx, results);
+            }
+            ctx = res.ctx;
+            results.push(res.value);
+        }
+    };
+}
+/** Parses zero or more occurences of the given parser, separated with the separator parser.
+ * @returns A parser returning an array of many parses, omitting the separator.
+ */
+export function zeroOrMany(item, separator = undefined) {
+    if (separator) {
+        return (ctx) => {
+            const results = [];
+            const res = item(ctx);
+            if (isFailure(res)) {
+                return success(ctx, results);
+            }
+            ctx = res.ctx;
+            results.push(res.value);
+            while (true) {
+                const resSep = separator(ctx);
+                if (isFailure(resSep)) {
+                    return success(ctx, results);
+                }
+                const res = item(resSep.ctx);
+                if (isFailure(res)) {
+                    return success(ctx, results);
+                }
+                ctx = res.ctx;
+                results.push(res.value);
+            }
+        };
+    }
+    else
+        return many(item);
+}
+/** Parses one or more occurences of the given parser, separated with the separator parser.
+ * @returns A parser returning an array of many parses, omitting the separator.
+ */
+export function oneOrMany(item, separator = undefined) {
+    if (separator) {
+        return (ctx) => {
+            const results = [];
+            const res = item(ctx);
+            if (isFailure(res))
+                return res;
+            ctx = res.ctx;
+            results.push(res.value);
+            while (true) {
+                const resSep = separator(ctx);
+                if (isFailure(resSep)) {
+                    return success(ctx, results);
+                }
+                const res = item(resSep.ctx);
+                if (isFailure(res)) {
+                    return success(ctx, results);
+                }
+                ctx = res.ctx;
+                results.push(res.value);
+            }
+        };
+    }
+    else {
+        return (ctx) => {
+            const results = [];
+            const res = item(ctx);
+            if (isFailure(res))
+                return res;
+            ctx = res.ctx;
+            results.push(res.value);
+            while (true) {
+                const res = item(ctx);
+                if (isFailure(res)) {
+                    return success(ctx, results);
+                }
+                ctx = res.ctx;
+                results.push(res.value);
+            }
+        };
+    }
+}
+/** Parses one or more occurences of the given parser, separated with the separator parser.
+ * @returns A parser returning the result of many parses, reduced using the `reducer` function passed in.
+ */
+export function oneOrManyRed(item, separator, reducer) {
+    return (ctx) => {
+        const res = item(ctx);
+        if (isFailure(res))
+            return res;
+        ctx = res.ctx;
+        let result = res.value;
+        while (true) {
+            const resSep = separator(ctx);
+            if (isFailure(resSep)) {
+                return success(ctx, result);
+            }
+            const res = item(resSep.ctx);
+            if (isFailure(res)) {
+                return success(ctx, result);
+            }
+            ctx = res.ctx;
+            try {
+                result = reducer(result, res.value, resSep.value);
+            }
+            catch {
+                return failure(res.ctx, 'Error while reducing', ['oneOrManyRed']);
+            }
+        }
+    };
+}

package/dist-esm/parsers/map.d.ts

@@ -0,0 +1,5 @@
+import { Parser } from '../types';
+/** Parses the input using the given parser, then maps the output.
+ * @returns A parser that parses the same input, but has output mapped using the mapping function.
+ */
+export declare function map<A, B>(parser: Parser<A>, mapper: (val: A) => B): Parser<B>;

package/dist-esm/parsers/map.js

@@ -0,0 +1,23 @@
+import { failure, isFailure, success } from '../types';
+import { isStringParser, shouldPerformFusions } from './optimizations';
+/** Parses the input using the given parser, then maps the output.
+ * @returns A parser that parses the same input, but has output mapped using the mapping function.
+ */
+export function map(parser, mapper) {
+    let marker = {};
+    if (shouldPerformFusions() && isStringParser(parser)) {
+        marker = { parserType: 'anyString', matches: parser.matches.map(m => ([m[0], m[1], (v) => mapper(m[2](v))])) };
+    }
+    return Object.assign((ctx) => {
+        const res = parser(ctx);
+        if (isFailure(res))
+            return failure(res.ctx, res.expected, ['map', ...res.history]);
+        try {
+            const newValue = mapper(res.value);
+            return success(res.ctx, newValue);
+        }
+        catch {
+            return failure(res.ctx, 'Error while mapping', ['map']);
+        }
+    }, marker);
+}

package/dist-esm/parsers/opt.d.ts

@@ -0,0 +1,5 @@
+import { Parser } from '../types';
+/** Makes the parser optional.
+ * @returns A parser that succeeds with `null` result if the parsing didn't succeed.
+ */
+export declare function opt<T>(parser: Parser<T>): Parser<T | null>;

package/dist-esm/parsers/opt.js

@@ -0,0 +1,13 @@
+import { isFailure, success } from '../types';
+/** Makes the parser optional.
+ * @returns A parser that succeeds with `null` result if the parsing didn't succeed.
+ */
+export function opt(parser) {
+    return (ctx) => {
+        const parseResult = parser(ctx);
+        if (isFailure(parseResult)) {
+            return success(ctx, null);
+        }
+        return parseResult;
+    };
+}

package/dist-esm/parsers/optimizations.d.ts

@@ -0,0 +1,11 @@
+import { Parser } from "../types";
+import { AnyStringParser } from "./anyString";
+export declare const shouldPerformFusions: () => boolean;
+/**
+ * Disables all parser combinator fusions.
+ *
+ * Should probably be used only for testing performance.
+ */
+export declare const toggleFusions: (value: boolean) => void;
+export declare function isStringParser<T>(parser: Parser<T>): parser is AnyStringParser<T>;
+export declare function allStringParsers<T>(parsers: Parser<T>[]): parsers is AnyStringParser<T>[];

package/dist-esm/parsers/optimizations.js

@@ -0,0 +1,16 @@
+export const shouldPerformFusions = () => performFusions;
+let performFusions = true;
+/**
+ * Disables all parser combinator fusions.
+ *
+ * Should probably be used only for testing performance.
+ */
+export const toggleFusions = (value) => {
+    performFusions = value;
+};
+export function isStringParser(parser) {
+    return 'parserType' in parser && typeof parser.parserType === 'string' && parser.parserType === 'anyString';
+}
+export function allStringParsers(parsers) {
+    return parsers.every(isStringParser);
+}

package/dist-esm/parsers/recovery.d.ts

@@ -0,0 +1,14 @@
+import { Parser } from "../types";
+/**
+ * Tries to automatically recover a parsing failure by removing characters from the front.
+ *
+ * If the inner parser fails, the recovery parser will restart parsing skipping a character, up to {@link chars} skips
+ */
+export declare function recoverBySkippingChars<T>(parser: Parser<T>, chars: number): Parser<T>;
+/**
+ * Tries to automatically recover a parsing failure by adding characters to the front.
+ *
+ * If the inner parser fails, the recovery parser will restart parsing adding a character, up to {@link chars}
+ * @todo Inserting characters in the middle of a context string is inefficient - maybe there's a better way?
+ */
+export declare function recoverByAddingChars<T>(parser: Parser<T>, chars: string): Parser<T>;

package/dist-esm/parsers/recovery.js

@@ -0,0 +1,49 @@
+import { isFailure } from "../types";
+/**
+ * Tries to automatically recover a parsing failure by removing characters from the front.
+ *
+ * If the inner parser fails, the recovery parser will restart parsing skipping a character, up to {@link chars} skips
+ */
+export function recoverBySkippingChars(parser, chars) {
+    return (ctx) => {
+        let firstFailure = null;
+        for (let i = 0; i <= chars; i++) {
+            const result = parser({
+                index: ctx.index + i,
+                path: ctx.path,
+                text: ctx.text,
+            });
+            if (isFailure(result)) {
+                firstFailure ??= result;
+            }
+            else
+                return result;
+        }
+        return firstFailure;
+    };
+}
+/**
+ * Tries to automatically recover a parsing failure by adding characters to the front.
+ *
+ * If the inner parser fails, the recovery parser will restart parsing adding a character, up to {@link chars}
+ * @todo Inserting characters in the middle of a context string is inefficient - maybe there's a better way?
+ */
+export function recoverByAddingChars(parser, chars) {
+    return (ctx) => {
+        let firstFailure = null;
+        for (let i = 0; i <= chars.length; i++) {
+            const addedChars = chars.slice(0, i);
+            const result = parser({
+                index: ctx.index,
+                path: ctx.path,
+                text: `${ctx.text.slice(0, ctx.index)}${addedChars}${ctx.text.slice(ctx.index)}`,
+            });
+            if (isFailure(result)) {
+                firstFailure ??= result;
+            }
+            else
+                return result;
+        }
+        return firstFailure;
+    };
+}

package/dist-esm/parsers/regex.d.ts

@@ -0,0 +1,5 @@
+import { Parser } from '../types';
+/** Parses a regex and returns the matched result of the parse.
+ * @returns A parser parsing a given regex and returning a match.
+ */
+export declare function regex(match: RegExp | string, expected: string): Parser<string>;

package/dist-esm/parsers/regex.js

@@ -0,0 +1,17 @@
+import { failure, success } from '../types';
+/** Parses a regex and returns the matched result of the parse.
+ * @returns A parser parsing a given regex and returning a match.
+ */
+export function regex(match, expected) {
+    const regexp = new RegExp(match, typeof match === 'string' ? 'y' : match.flags + 'y');
+    return (ctx) => {
+        regexp.lastIndex = ctx.index;
+        const regexMatch = regexp.exec(ctx.text);
+        if (regexMatch !== null && regexMatch.index === ctx.index) {
+            return success({ ...ctx, index: ctx.index + regexMatch[0].length }, regexMatch[0]);
+        }
+        else {
+            return failure(ctx, expected, [expected]);
+        }
+    };
+}

package/dist-esm/parsers/seq.d.ts

@@ -0,0 +1,16 @@
+import { Parser } from '../types';
+/** Parses a sequence of parsers going from left to right, returning the results of the parsers.
+ * @returns A parser parsing the sequence of parsers.
+ */
+export declare function seq<T, U, V, W, X, Z, I, J, K, L, M>(...parsers: [Parser<T>, Parser<U>, Parser<V>, Parser<W>, Parser<X>, Parser<Z>, Parser<I>, Parser<J>, Parser<K>, Parser<L>, Parser<M>]): Parser<[T, U, V, W, X, Z, I, J, K, L, M]>;
+export declare function seq<T, U, V, W, X, Z, I, J, K, L>(...parsers: [Parser<T>, Parser<U>, Parser<V>, Parser<W>, Parser<X>, Parser<Z>, Parser<I>, Parser<J>, Parser<K>, Parser<L>]): Parser<[T, U, V, W, X, Z, I, J, K, L]>;
+export declare function seq<T, U, V, W, X, Z, I, J, K>(...parsers: [Parser<T>, Parser<U>, Parser<V>, Parser<W>, Parser<X>, Parser<Z>, Parser<I>, Parser<J>, Parser<K>]): Parser<[T, U, V, W, X, Z, I, J, K]>;
+export declare function seq<T, U, V, W, X, Z, I, J>(...parsers: [Parser<T>, Parser<U>, Parser<V>, Parser<W>, Parser<X>, Parser<Z>, Parser<I>, Parser<J>]): Parser<[T, U, V, W, X, Z, I, J]>;
+export declare function seq<T, U, V, W, X, Z, I>(...parsers: [Parser<T>, Parser<U>, Parser<V>, Parser<W>, Parser<X>, Parser<Z>, Parser<I>]): Parser<[T, U, V, W, X, Z, I]>;
+export declare function seq<T, U, V, W, X, Z>(...parsers: [Parser<T>, Parser<U>, Parser<V>, Parser<W>, Parser<X>, Parser<Z>]): Parser<[T, U, V, W, X, Z]>;
+export declare function seq<T, U, V, W, X>(...parsers: [Parser<T>, Parser<U>, Parser<V>, Parser<W>, Parser<X>]): Parser<[T, U, V, W, X]>;
+export declare function seq<T, U, V, W>(...parsers: [Parser<T>, Parser<U>, Parser<V>, Parser<W>]): Parser<[T, U, V, W]>;
+export declare function seq<T, U, V>(...parsers: [Parser<T>, Parser<U>, Parser<V>]): Parser<[T, U, V]>;
+export declare function seq<T, U>(...parsers: [Parser<T>, Parser<U>]): Parser<[T, U]>;
+export declare function seq<T>(...parsers: [Parser<T>]): Parser<[T]>;
+export declare function seq<T>(...parsers: Parser<T>[]): Parser<T[]>;

package/dist-esm/parsers/seq.js

@@ -0,0 +1,14 @@
+import { failure, isFailure, success } from '../types';
+export function seq(...parsers) {
+    return (ctx) => {
+        const values = [];
+        for (const parser of parsers) {
+            const res = parser(ctx);
+            ctx = res.ctx;
+            if (isFailure(res))
+                return failure(res.ctx, res.expected, ['seq', ...res.history]);
+            values.push(res.value);
+        }
+        return success(ctx, values);
+    };
+}

package/dist-esm/parsers/str.d.ts

@@ -0,0 +1,9 @@
+import { Parser } from '../types';
+/** Parses a string and returns it as a result of the parse.
+ * @returns A parser parsing a given string, case-sensitive.
+ */
+export declare function str<T extends string>(match: T): Parser<T>;
+/** Parses a string case-insensitively and returns it as a result of the parse.
+ * @returns A parser parsing a given string, case-insensitive.
+ */
+export declare function stri<T extends string>(match: T): Parser<Lowercase<T>>;

package/dist-esm/parsers/str.js

@@ -0,0 +1,32 @@
+import { failure, success } from '../types';
+/** Parses a string and returns it as a result of the parse.
+ * @returns A parser parsing a given string, case-sensitive.
+ */
+export function str(match) {
+    const inQuotes = `'${match}'`;
+    return Object.assign((ctx) => {
+        if (ctx.text.startsWith(match, ctx.index)) {
+            return success({ ...ctx, index: ctx.index + match.length }, match);
+        }
+        else {
+            return failure(ctx, inQuotes, [inQuotes]);
+        }
+    }, { parserType: 'anyString', matches: [[match, false, (v) => v]] });
+}
+const collator = new Intl.Collator('en', { sensitivity: 'accent' });
+/** Parses a string case-insensitively and returns it as a result of the parse.
+ * @returns A parser parsing a given string, case-insensitive.
+ */
+export function stri(match) {
+    const lowercase = match.toLowerCase();
+    const inQuotes = `'${lowercase}'`;
+    return Object.assign((ctx) => {
+        const textSlice = ctx.text.slice(ctx.index, ctx.index + match.length);
+        if (collator.compare(match, textSlice) == 0) {
+            return success({ ...ctx, index: ctx.index + match.length }, lowercase);
+        }
+        else {
+            return failure(ctx, inQuotes, [inQuotes]);
+        }
+    }, { parserType: 'anyString', matches: [[lowercase, true, (v) => v]] });
+}

package/dist-esm/parsers/utilities.d.ts

@@ -0,0 +1,30 @@
+import { Parser, Token } from '../types';
+/** Allows to make a condition on the result of the parsing function.
+ * @returns A parser returning the same but also performing a given check on the result.
+ */
+export declare function ref<T>(parser: Parser<T>, check: ((p: T) => boolean), expected?: string): Parser<T>;
+/** Changes the expected value for when the parser fails.
+ * @returns A parser returning the same but with a different expected value.
+ */
+export declare function expect<T>(parser: Parser<T>, expected: string): Parser<T>;
+/** Changes the expected value for when the parser fails. Erases the previous history.
+ * @returns A parser returning the same but with a different expected value.
+ */
+export declare function expectErase<T>(parser: Parser<T>, expected: string): Parser<T>;
+/**
+ * Marks a parser as a branch that has to be executed to the end by the {@link any} parser
+ */
+export declare function surely<T>(parser: Parser<T>): Parser<T>;
+/**
+ * Wraps the value returned by the parser with the token information (the start and end index in the text)
+ * @returns A parser returning the value wrapped in token information.
+ */
+export declare function token<T>(parser: Parser<T>): Parser<Token<T>>;
+/**
+ * Checks whether the parser parses successfully, but doesn't move the cursor forward
+ */
+export declare function lookaround<T>(parser: Parser<T>): Parser<void>;
+/**
+ * Turns a function creating a parser into a parser. Useful for recursive grammars.
+ */
+export declare function lazy<T>(parserGetter: () => Parser<T>): Parser<T>;