parser-combinators 1.1.2 → 1.2.0

package/LICENSE

@@ -0,0 +1,12 @@
+Copyright 2022 Michał Isalski
+
+Permission to use, copy, modify, and/or distribute
+this software for any purpose with or without fee is hereby granted,
+provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT,
+OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -1,12 +1,11 @@
 ## Parser Combinators
 
-![GitHub Workflow Status (branch)](https://img.shields.io/github/workflow/status/michalusio/Parser/CI/master)
+[![CI](https://github.com/michalusio/Parser/actions/workflows/CI.yml/badge.svg)](https://github.com/michalusio/Parser/actions/workflows/CI.yml)
 [![CodeQL](https://github.com/michalusio/Parser/actions/workflows/codeql-analysis.yml/badge.svg?branch=master)](https://github.com/michalusio/Parser/actions/workflows/codeql-analysis.yml)
-![Codecov](https://img.shields.io/codecov/c/github/michalusio/Parser)
+[![codecov](https://codecov.io/gh/michalusio/Parser/branch/master/graph/badge.svg?token=gtTR0hPodY)](https://codecov.io/gh/michalusio/Parser)
 
 ![NPM](https://img.shields.io/npm/l/parser-combinators)
 [![NPM Version](https://badge.fury.io/js/parser-combinators.svg)](https://badge.fury.io/js/parser-combinators)
-[![No Dependencies](https://status.david-dm.org/gh/michalusio/parser.svg)](https://status.david-dm.org/)
 
 A library of parser combinators, with which you can create your own parsers.
 
@@ -34,10 +33,14 @@ A library of parser combinators, with which you can create your own parsers.
   - `opt`ional
   - `regex`
   - `seq`uence
-  - `str`ing
+  - `str`ing and `stri`ng (case-insensitive)
 - Utility combinators:
   - `ref`er
   - `expect`
+  - `expectErase`
+  - `surely`
+  - `token`
+  - `lookaround`
 - Ready-made value combinators:
   - `spaces`
   - `spacesPlus`
@@ -45,6 +48,27 @@ A library of parser combinators, with which you can create your own parsers.
   - `bool` (and `boolP`)
   - `int` (and `intP`)
   - `real` (and `realP`)
+  - `eof`
+- Recovery combinators:
+  - `recoverBySkippingChars`
+  - `recoverByAddingChars`
+- Whole parsers:
+  - Extended Backus-Naur Form (`EBNF`)
+  - JavaScript Object Notation (`JSON`)
+
+##### Optimization remarks:
+
+Combining many string parsers using an `any` parser uses parser fusion.
+This means that a parser of the form e.g. `any(str(...), ..., str())` is automatically converted into a search trie.
+This drastically decreases the number of callbacks, and improves performance because all search strings are checked "at once" by going over the trie.
+
+Nested `any` parsers are also supported, as well as `stri` parsers, so all of these undergo fusion:
+
+    any(str('QeQMTvqJuS'), str('IoOYSLNPlM'), str('SpFMUWpzHs'))
+
+    any(str('QeQMTvqJuS'), any(str('IoOYSLNPlM'), str('SpFMUWpzHs')))
+
+    any(str('QeQMTvqJuS'), stri('QeQMTvqJuS'), str('QeqmtabeacErEmTDUUIFcFpsAJhfwqXN'), str('SpFMUWpzHs'))
 
 ### Example usage:
 
@@ -81,3 +105,24 @@ A library of parser combinators, with which you can create your own parsers.
         'The number must be over 1.5!'
     );
     const result = ParseText(' number: 1.25  ', parser); // Will throw a ParseError('The number must be over 1.5!')
+
+##### Pretty messages available on parsing errors:
+
+    import { spacesPlus, str } from 'parser-combinators/parsers';
+    import { ParseText } from 'parser-combinators';
+
+    const parser = seq(
+      str('Lazy fox jumps'), spacesPlus, str('over'), spacesPlus, str('a lazy dog')
+    );
+
+    try {
+      const result = ParseText('Lazy fox jumps under a lazy dog', parser);
+    } catch (e) {
+      console.error(e.getPrettyErrorMessage());
+    }
+
+Will write:
+
+    Parse error, expected over at char 15 (line 1, col 16):
+    Lazy fox jumps under a lazy dog
+    ---------------^

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./parsers";
+export * from "./parser";

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./parsers"), exports);
+__exportStar(require("./parser"), exports);

package/{parser.d.ts → dist/parser.d.ts}

@@ -1,16 +1,9 @@
-import { Parser } from './types';
-/** Parses the utf-8 content of a given file's content.
- * @param path The path to the file to parse.
- * @param parser The parser to use.
- * @returns The result of the parse.
- * @throws {ParseError} if the parsing fails or the parser does not consume the full input.
- */
-export declare function ParseFile<T>(path: string, parser: Parser<T>): T;
-/** Parses the given string.
- * @param text The string to parse.
- * @param parser The parser to use.
- * @param path The path of the parsed text. Can be used for error reporting.
- * @returns The result of the parse.
- * @throws {ParseError} if the parsing fails or the parser does not consume the full input.
- */
-export declare function ParseText<T>(text: string, parser: Parser<T>, path?: string): T;
+import { Parser } from './types';
+/** Parses the given string.
+ * @param text The string to parse.
+ * @param parser The parser to use.
+ * @param path The path of the parsed text. Can be used for error reporting.
+ * @returns The result of the parse.
+ * @throws {ParseError} if the parsing fails or the parser does not consume the full input.
+ */
+export declare function ParseText<T>(text: string, parser: Parser<T>, path?: string): T;

package/{parser.js → dist/parser.js}

@@ -1,34 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParseText = exports.ParseFile = void 0;
-const fs = require("fs");
-const types_1 = require("./types");
-/** Parses the utf-8 content of a given file's content.
- * @param path The path to the file to parse.
- * @param parser The parser to use.
- * @returns The result of the parse.
- * @throws {ParseError} if the parsing fails or the parser does not consume the full input.
- */
-function ParseFile(path, parser) {
-    const text = fs.readFileSync(path, 'utf8');
-    return ParseText(text, parser, path);
-}
-exports.ParseFile = ParseFile;
-/** Parses the given string.
- * @param text The string to parse.
- * @param parser The parser to use.
- * @param path The path of the parsed text. Can be used for error reporting.
- * @returns The result of the parse.
- * @throws {ParseError} if the parsing fails or the parser does not consume the full input.
- */
-function ParseText(text, parser, path = '') {
-    const res = parser({ text, path, index: 0 });
-    if ((0, types_1.isFailure)(res)) {
-        throw new types_1.ParseError(`Parse error, expected ${[...res.history].pop()} at char ${res.ctx.index}`, text, res.ctx.index, res.history);
-    }
-    if (res.ctx.index !== text.length) {
-        throw new types_1.ParseError(`Parse error at index ${res.ctx.index}`, text, res.ctx.index, []);
-    }
-    return res.value;
-}
-exports.ParseText = ParseText;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseText = ParseText;
+const types_1 = require("./types");
+/** Parses the given string.
+ * @param text The string to parse.
+ * @param parser The parser to use.
+ * @param path The path of the parsed text. Can be used for error reporting.
+ * @returns The result of the parse.
+ * @throws {ParseError} if the parsing fails or the parser does not consume the full input.
+ */
+function ParseText(text, parser, path = '') {
+    const res = parser({ text, path, index: 0 });
+    if ((0, types_1.isFailure)(res)) {
+        throw new types_1.ParseError(`Parse error, expected ${[...res.history].pop()} at char ${res.ctx.index}`, text, res.ctx.index, res.history);
+    }
+    if (res.ctx.index !== text.length) {
+        throw new types_1.ParseError(`Parse error, expected end of text at char ${res.ctx.index}`, text, res.ctx.index, []);
+    }
+    return res.value;
+}

package/{parsers → dist/parsers}/any.d.ts

@@ -1,15 +1,16 @@
-import { Parser } from '../types';
-/** Parses the input using any passed parser, trying from left to right.
- * @returns A parser returning the result of the first parser that succeeds, or the failure that has come the furthest.
- */
-export declare function any<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 any<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 any<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 any<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 any<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 any<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 any<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 any<T, U, V, W>(...parsers: [Parser<T>, Parser<U>, Parser<V>, Parser<W>]): Parser<T | U | V | W>;
-export declare function any<T, U, V>(...parsers: [Parser<T>, Parser<U>, Parser<V>]): Parser<T | U | V>;
-export declare function any<T, U>(...parsers: [Parser<T>, Parser<U>]): Parser<T | U>;
-export declare function any<T>(...parsers: [Parser<T>]): Parser<T>;
+import { Parser } from '../types';
+/** Parses the input using any passed parser, trying from left to right.
+ * @returns A parser returning the result of the first parser that succeeds, or the failure that has come the furthest.
+ */
+export declare function any<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 any<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 any<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 any<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 any<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 any<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 any<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 any<T, U, V, W>(...parsers: [Parser<T>, Parser<U>, Parser<V>, Parser<W>]): Parser<T | U | V | W>;
+export declare function any<T, U, V>(...parsers: [Parser<T>, Parser<U>, Parser<V>]): Parser<T | U | V>;
+export declare function any<T, U>(...parsers: [Parser<T>, Parser<U>]): Parser<T | U>;
+export declare function any<T>(...parsers: [Parser<T>]): Parser<T>;
+export declare function any<T>(...parsers: Parser<T>[]): Parser<T>;

package/dist/parsers/any.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.any = any;
+const types_1 = require("../types");
+const anyString_1 = require("./anyString");
+const utilities_1 = require("./utilities");
+const optimizableTypes = ['str', 'stri', 'anyString'];
+function any(...parsers) {
+    let marker = {};
+    if ((0, utilities_1.shouldPerformFusions)() && parsers.every(p => 'parserType' in p && typeof p.parserType === 'string' && optimizableTypes.includes(p.parserType))) {
+        const optimizableParsers = parsers;
+        const matches = optimizableParsers.flatMap(p => {
+            switch (p.parserType) {
+                case 'anyString':
+                    return p.matches;
+                case 'str':
+                    return [[p.match, false]];
+                case 'stri':
+                    return [[p.match, true]];
+            }
+        });
+        // Not fusing if not enough matches
+        // We do pass the matches forward though, because a parser above may want to fuse
+        if (matches.length > 10) {
+            return (0, anyString_1.anyString)(matches);
+        }
+        else {
+            marker = { parserType: 'anyString', matches };
+        }
+    }
+    return Object.assign((ctx) => {
+        const expected = [];
+        for (const parser of parsers) {
+            const res = parser(ctx);
+            if ((0, types_1.isFailure)(res)) {
+                if (res.history.includes('surely')) {
+                    return (0, types_1.failure)(res.ctx, res.expected, res.history.filter(h => h !== 'surely'));
+                }
+                expected.push(res);
+            }
+            else
+                return res;
+        }
+        const longest = expected.reduce((a, b) => a.history.length > b.history.length ? a : b);
+        return (0, types_1.failure)(longest.ctx, longest.expected, ['any', ...longest.history]);
+    }, marker);
+}

package/dist/parsers/anyString.d.ts

@@ -0,0 +1,15 @@
+import { Parser } from "../types";
+import { StrIParser, StrParser } from "./str";
+type AnyStringParser<T> = Parser<T> & {
+    parserType: 'anyString';
+    /**
+     * if flag is true, match case-insensitive
+     */
+    matches: (readonly [string, boolean])[];
+};
+export type OptimizableStrParser<T> = AnyStringParser<T> | StrParser<T> | StrIParser<T>;
+/**
+ * Optimization for `any(str(), str(), ...)` which replaces the parser tree with one parser which tries all strings together
+ */
+export declare function anyString<T extends string>(matches: (readonly [string, boolean])[]): AnyStringParser<T>;
+export {};

package/dist/parsers/anyString.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anyString = anyString;
+const types_1 = require("../types");
+/**
+ * Optimization for `any(str(), str(), ...)` which replaces the parser tree with one parser which tries all strings together
+ */
+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 (0, types_1.success)({ ...ctx, index: result.end }, matches[result.matchIndex][0]);
+        }
+        else {
+            return (0, types_1.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) {
+            node.matchIndex = Math.min(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/{parsers → dist/parsers}/between.d.ts

@@ -1,5 +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>;
+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/{parsers → dist/parsers}/between.js

@@ -1,21 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.between = void 0;
-const types_1 = require("../types");
-const seq_1 = require("./seq");
-/** Parses a sequence of three parsers.
- * @returns A parser returning only the middle parser's result.
- */
-function between(left, parser, right) {
-    const sequence = (0, seq_1.seq)(left, parser, right);
-    return (ctx) => {
-        const res = sequence(ctx);
-        if ((0, types_1.isFailure)(res)) {
-            const newHistory = [...res.history];
-            newHistory.splice(0, 1);
-            return (0, types_1.failure)(res.ctx, res.expected, ['between', ...newHistory]);
-        }
-        return { ...res, value: res.value[1] };
-    };
-}
-exports.between = between;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.between = between;
+const types_1 = require("../types");
+const seq_1 = require("./seq");
+/** Parses a sequence of three parsers.
+ * @returns A parser returning only the middle parser's result.
+ */
+function between(left, parser, right) {
+    const sequence = (0, seq_1.seq)(left, parser, right);
+    return (ctx) => {
+        const res = sequence(ctx);
+        if ((0, types_1.isFailure)(res)) {
+            const newHistory = [...res.history];
+            newHistory.splice(0, 1);
+            return (0, types_1.failure)(res.ctx, res.expected, ['between', ...newHistory]);
+        }
+        return { ...res, value: res.value[1] };
+    };
+}

package/{parsers → dist/parsers}/exhaust.d.ts

@@ -1,5 +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[]>;
+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/{parsers → dist/parsers}/exhaust.js

@@ -1,27 +1,25 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.exhaust = void 0;
-const types_1 = require("../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.
- */
-function exhaust(parser, until = null) {
-    return (ctx) => {
-        const results = [];
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            const res = parser(ctx);
-            if ((0, types_1.isFailure)(res)) {
-                if (until === null || (0, types_1.isFailure)(until(ctx))) {
-                    return (0, types_1.failure)(res.ctx, res.expected, ['exhaust', ...res.history]);
-                }
-                return (0, types_1.success)(ctx, results);
-            }
-            ctx = res.ctx;
-            results.push(res.value);
-            if (res.ctx.index === res.ctx.text.length)
-                return (0, types_1.success)(res.ctx, results);
-        }
-    };
-}
-exports.exhaust = exhaust;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exhaust = exhaust;
+const types_1 = require("../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.
+ */
+function exhaust(parser, until = null) {
+    return (ctx) => {
+        const results = [];
+        while (true) {
+            const res = parser(ctx);
+            if ((0, types_1.isFailure)(res)) {
+                if (until === null || (0, types_1.isFailure)(until(ctx))) {
+                    return (0, types_1.failure)(res.ctx, res.expected, ['exhaust', ...res.history]);
+                }
+                return (0, types_1.success)(ctx, results);
+            }
+            ctx = res.ctx;
+            results.push(res.value);
+            if (res.ctx.index === res.ctx.text.length)
+                return (0, types_1.success)(res.ctx, results);
+        }
+    };
+}

package/{parsers → dist/parsers}/index.d.ts

@@ -1,11 +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 * from './str';
-export * from './utilities';
-export * from './values';
+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/{parsers → dist/parsers}/index.js

@@ -1,23 +1,31 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./any"), exports);
-__exportStar(require("./between"), exports);
-__exportStar(require("./exhaust"), exports);
-__exportStar(require("./many"), exports);
-__exportStar(require("./map"), exports);
-__exportStar(require("./opt"), exports);
-__exportStar(require("./regex"), exports);
-__exportStar(require("./seq"), exports);
-__exportStar(require("./str"), exports);
-__exportStar(require("./utilities"), exports);
-__exportStar(require("./values"), exports);
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stri = exports.str = void 0;
+__exportStar(require("./any"), exports);
+__exportStar(require("./between"), exports);
+__exportStar(require("./exhaust"), exports);
+__exportStar(require("./many"), exports);
+__exportStar(require("./map"), exports);
+__exportStar(require("./opt"), exports);
+__exportStar(require("./regex"), exports);
+__exportStar(require("./seq"), exports);
+var str_1 = require("./str");
+Object.defineProperty(exports, "str", { enumerable: true, get: function () { return str_1.str; } });
+Object.defineProperty(exports, "stri", { enumerable: true, get: function () { return str_1.stri; } });
+__exportStar(require("./recovery"), exports);
+__exportStar(require("./utilities"), exports);
+__exportStar(require("./values"), exports);

package/{parsers → dist/parsers}/many.d.ts

@@ -1,17 +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>): 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>): 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>;
+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>): 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>;