parser-combinators 1.2.3 → 1.2.6

package/dist/parser.js

@@ -12,7 +12,7 @@ const types_1 = require("./types");
 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);
+        throw new types_1.ParseError(`Parse error, expected ${res.history[res.history.length - 1]} 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, []);

package/dist/parsers/any.js

@@ -22,8 +22,10 @@ function any(...parsers) {
         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'));
+                const surelyIndex = res.history.findIndex(h => h === 'surely');
+                // Stryker disable next-line EqualityOperator: The > mutant results in an equivalent mutant
+                if (surelyIndex >= 0) {
+                    return (0, types_1.failure)(res.ctx, res.expected, ['any', ...res.history.slice(0, surelyIndex), ...res.history.slice(surelyIndex + 1)]);
                 }
                 expected.push(res);
             }

package/dist/parsers/anyString.js

@@ -26,14 +26,7 @@ function createSearchTree(matches) {
 }
 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;
-        }
+        node.matchIndex ??= idIndex;
     }
     else {
         const char = match[0][charIndex];
@@ -51,15 +44,17 @@ function addMatchToTree(node, match, idIndex, charIndex = 0) {
             }
         }
         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);
+            node.set(char, node.get(char) ?? newNode);
+            if (lowercase !== uppercase) {
+                const lower = node.get(lowercase);
+                const upper = node.get(uppercase);
+                if (lower != null && lower === upper) {
+                    const copy = new Map(lower.entries());
+                    copy.matchIndex = lower.matchIndex;
+                    node.set(uppercase, copy);
+                }
             }
-            addMatchToTree(charNode, match, idIndex, charIndex + 1);
+            addMatchToTree(node.get(char), match, idIndex, charIndex + 1);
         }
     }
 }

package/dist/parsers/index.d.ts

@@ -2,6 +2,9 @@ export * from './any';
 export * from './between';
 export * from './exhaust';
 export * from './many';
+export * from './zeroOrMany';
+export * from './oneOrMany';
+export * from './oneOrManyRed';
 export * from './map';
 export * from './opt';
 export * from './regex';
@@ -10,3 +13,4 @@ export { str, stri } from './str';
 export * from './recovery';
 export * from './utilities';
 export * from './values';
+export * from './readymade';

package/dist/parsers/index.js

@@ -19,6 +19,9 @@ __exportStar(require("./any"), exports);
 __exportStar(require("./between"), exports);
 __exportStar(require("./exhaust"), exports);
 __exportStar(require("./many"), exports);
+__exportStar(require("./zeroOrMany"), exports);
+__exportStar(require("./oneOrMany"), exports);
+__exportStar(require("./oneOrManyRed"), exports);
 __exportStar(require("./map"), exports);
 __exportStar(require("./opt"), exports);
 __exportStar(require("./regex"), exports);
@@ -29,3 +32,4 @@ Object.defineProperty(exports, "stri", { enumerable: true, get: function () { re
 __exportStar(require("./recovery"), exports);
 __exportStar(require("./utilities"), exports);
 __exportStar(require("./values"), exports);
+__exportStar(require("./readymade"), exports);

package/dist/parsers/many.d.ts

@@ -3,15 +3,3 @@ import { Parser } from "../types";
  * @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/parsers/many.js

@@ -1,9 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.many = many;
-exports.zeroOrMany = zeroOrMany;
-exports.oneOrMany = oneOrMany;
-exports.oneOrManyRed = oneOrManyRed;
 const types_1 = require("../types");
 /** Parses zero or more occurences of the given parser.
  * @returns A parser returning an array of many parses.
@@ -14,114 +11,15 @@ function many(parser) {
         while (true) {
             const res = parser(ctx);
             if ((0, types_1.isFailure)(res)) {
-                return (0, types_1.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.
- */
-function zeroOrMany(item, separator = undefined) {
-    if (separator) {
-        return (ctx) => {
-            const results = [];
-            const res = item(ctx);
-            if ((0, types_1.isFailure)(res)) {
-                return (0, types_1.success)(ctx, results);
-            }
-            ctx = res.ctx;
-            results.push(res.value);
-            while (true) {
-                const resSep = separator(ctx);
-                if ((0, types_1.isFailure)(resSep)) {
-                    return (0, types_1.success)(ctx, results);
-                }
-                const res = item(resSep.ctx);
-                if ((0, types_1.isFailure)(res)) {
-                    return (0, types_1.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.
- */
-function oneOrMany(item, separator = undefined) {
-    if (separator) {
-        return (ctx) => {
-            const results = [];
-            const res = item(ctx);
-            if ((0, types_1.isFailure)(res))
-                return res;
-            ctx = res.ctx;
-            results.push(res.value);
-            while (true) {
-                const resSep = separator(ctx);
-                if ((0, types_1.isFailure)(resSep)) {
-                    return (0, types_1.success)(ctx, results);
+                const surelyIndex = res.history.findIndex(h => h === 'surely');
+                // Stryker disable next-line EqualityOperator: The > mutant results in an equivalent mutant
+                if (surelyIndex >= 0) {
+                    return (0, types_1.failure)(res.ctx, res.expected, ['many', ...res.history.slice(0, surelyIndex), ...res.history.slice(surelyIndex + 1)]);
                 }
-                const res = item(resSep.ctx);
-                if ((0, types_1.isFailure)(res)) {
-                    return (0, types_1.success)(ctx, results);
-                }
-                ctx = res.ctx;
-                results.push(res.value);
+                return (0, types_1.success)(ctx, results);
             }
-        };
-    }
-    else {
-        return (ctx) => {
-            const results = [];
-            const res = item(ctx);
-            if ((0, types_1.isFailure)(res))
-                return res;
             ctx = res.ctx;
             results.push(res.value);
-            while (true) {
-                const res = item(ctx);
-                if ((0, types_1.isFailure)(res)) {
-                    return (0, types_1.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.
- */
-function oneOrManyRed(item, separator, reducer) {
-    return (ctx) => {
-        const res = item(ctx);
-        if ((0, types_1.isFailure)(res))
-            return res;
-        ctx = res.ctx;
-        let result = res.value;
-        while (true) {
-            const resSep = separator(ctx);
-            if ((0, types_1.isFailure)(resSep)) {
-                return (0, types_1.success)(ctx, result);
-            }
-            const res = item(resSep.ctx);
-            if ((0, types_1.isFailure)(res)) {
-                return (0, types_1.success)(ctx, result);
-            }
-            ctx = res.ctx;
-            try {
-                result = reducer(result, res.value, resSep.value);
-            }
-            catch {
-                return (0, types_1.failure)(res.ctx, 'Error while reducing', ['oneOrManyRed']);
-            }
         }
     };
 }

package/dist/parsers/oneOrMany.d.ts

@@ -0,0 +1,5 @@
+import { Parser } from "../types";
+/** 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[]>;

package/dist/parsers/oneOrMany.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.oneOrMany = oneOrMany;
+const types_1 = require("../types");
+/** 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.
+ */
+function oneOrMany(item, separator = undefined) {
+    if (separator) {
+        return (ctx) => {
+            const results = [];
+            const res = item(ctx);
+            if ((0, types_1.isFailure)(res)) {
+                return (0, types_1.failure)(res.ctx, res.expected, ['oneOrMany', ...res.history]);
+            }
+            ctx = res.ctx;
+            results.push(res.value);
+            while (true) {
+                const resSep = separator(ctx);
+                if ((0, types_1.isFailure)(resSep)) {
+                    const surelyIndex = resSep.history.findIndex(h => h === 'surely');
+                    // Stryker disable next-line EqualityOperator: The > mutant results in an equivalent mutant
+                    if (surelyIndex >= 0) {
+                        return (0, types_1.failure)(resSep.ctx, resSep.expected, ['oneOrMany', ...resSep.history.slice(0, surelyIndex), ...resSep.history.slice(surelyIndex + 1)]);
+                    }
+                    return (0, types_1.success)(ctx, results);
+                }
+                const res = item(resSep.ctx);
+                if ((0, types_1.isFailure)(res)) {
+                    const surelyIndex = res.history.findIndex(h => h === 'surely');
+                    // Stryker disable next-line EqualityOperator: The > mutant results in an equivalent mutant
+                    if (surelyIndex >= 0) {
+                        return (0, types_1.failure)(res.ctx, res.expected, ['oneOrMany', ...res.history.slice(0, surelyIndex), ...res.history.slice(surelyIndex + 1)]);
+                    }
+                    return (0, types_1.success)(ctx, results);
+                }
+                ctx = res.ctx;
+                results.push(res.value);
+            }
+        };
+    }
+    else {
+        return (ctx) => {
+            const results = [];
+            const res = item(ctx);
+            if ((0, types_1.isFailure)(res)) {
+                return (0, types_1.failure)(res.ctx, res.expected, ['oneOrMany', ...res.history]);
+            }
+            ctx = res.ctx;
+            results.push(res.value);
+            while (true) {
+                const res = item(ctx);
+                if ((0, types_1.isFailure)(res)) {
+                    const surelyIndex = res.history.findIndex(h => h === 'surely');
+                    // Stryker disable next-line EqualityOperator: The > mutant results in an equivalent mutant
+                    if (surelyIndex >= 0) {
+                        return (0, types_1.failure)(res.ctx, res.expected, ['oneOrMany', ...res.history.slice(0, surelyIndex), ...res.history.slice(surelyIndex + 1)]);
+                    }
+                    return (0, types_1.success)(ctx, results);
+                }
+                ctx = res.ctx;
+                results.push(res.value);
+            }
+        };
+    }
+}

package/dist/parsers/oneOrManyRed.d.ts

@@ -0,0 +1,5 @@
+import { Parser } from "../types";
+/** 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/parsers/oneOrManyRed.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.oneOrManyRed = oneOrManyRed;
+const types_1 = require("../types");
+/** 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.
+ */
+function oneOrManyRed(item, separator, reducer) {
+    return (ctx) => {
+        const res = item(ctx);
+        if ((0, types_1.isFailure)(res)) {
+            return (0, types_1.failure)(res.ctx, res.expected, ['oneOrManyRed', ...res.history]);
+        }
+        ctx = res.ctx;
+        let result = res.value;
+        while (true) {
+            const resSep = separator(ctx);
+            if ((0, types_1.isFailure)(resSep)) {
+                const surelyIndex = resSep.history.findIndex(h => h === 'surely');
+                // Stryker disable next-line EqualityOperator: The > mutant results in an equivalent mutant
+                if (surelyIndex >= 0) {
+                    return (0, types_1.failure)(resSep.ctx, resSep.expected, ['oneOrManyRed', ...resSep.history.slice(0, surelyIndex), ...resSep.history.slice(surelyIndex + 1)]);
+                }
+                return (0, types_1.success)(ctx, result);
+            }
+            const res = item(resSep.ctx);
+            if ((0, types_1.isFailure)(res)) {
+                const surelyIndex = res.history.findIndex(h => h === 'surely');
+                // Stryker disable next-line EqualityOperator: The > mutant results in an equivalent mutant
+                if (surelyIndex >= 0) {
+                    return (0, types_1.failure)(res.ctx, res.expected, ['oneOrManyRed', ...res.history.slice(0, surelyIndex), ...res.history.slice(surelyIndex + 1)]);
+                }
+                return (0, types_1.success)(ctx, result);
+            }
+            ctx = res.ctx;
+            try {
+                result = reducer(result, res.value, resSep.value);
+            }
+            catch {
+                return (0, types_1.failure)(res.ctx, 'Error while reducing', ['oneOrManyRed']);
+            }
+        }
+    };
+}

package/dist/parsers/readymade.d.ts

@@ -0,0 +1,7 @@
+import { Parser } from "../types";
+export type Json = string | number | boolean | null | {
+    [key: number]: Json;
+} | {
+    [key: string]: Json;
+};
+export declare const json: Parser<Json>;

package/dist/parsers/readymade.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.json = void 0;
+const any_1 = require("./any");
+const between_1 = require("./between");
+const zeroOrMany_1 = require("./zeroOrMany");
+const map_1 = require("./map");
+const regex_1 = require("./regex");
+const seq_1 = require("./seq");
+const str_1 = require("./str");
+const utilities_1 = require("./utilities");
+const WhiteSpace = (0, regex_1.regex)(/\s*/m, 'whitespace');
+const True = (0, map_1.map)((0, str_1.str)("true"), () => true);
+const False = (0, map_1.map)((0, str_1.str)("false"), () => false);
+const Null = (0, map_1.map)((0, str_1.str)("null"), () => null);
+const LCurly = (0, str_1.str)("{");
+const RCurly = (0, utilities_1.surely)((0, str_1.str)("}"));
+const LSquare = (0, str_1.str)("[");
+const RSquare = (0, utilities_1.surely)((0, str_1.str)("]"));
+const Quote = (0, str_1.str)('"');
+const Comma = (0, str_1.str)(",");
+const Colon = (0, utilities_1.surely)((0, str_1.str)(":"));
+const replacements = {
+    '\\\\': '\\',
+    '\\0': '\0',
+    '\\b': '\b',
+    '\\f': '\f',
+    '\\n': '\n',
+    '\\r': '\r',
+    '\\t': '\t',
+    '\\v': '\v',
+    '\\"': '"'
+};
+const StringLiteral = (0, between_1.between)(Quote, (0, map_1.map)((0, regex_1.regex)(/(?:[^\\"]|\\(?:[0bfnrtv"\\]|u[0-9a-fA-F]{4}))*/, 'string literal'), str => str.replace(/\\(?:[0bfnrtv"\\]|u[0-9a-fA-F]{4})/g, function (replace) {
+    const tabled = replacements[replace];
+    if (tabled != null) {
+        return tabled;
+    }
+    return String.fromCharCode(parseInt(replace.slice(2), 16));
+})), Quote);
+const NumberLiteral = (0, map_1.map)((0, regex_1.regex)(/-?(?:0|(?:[1-9]\d*))(?:\.\d+)?(?:[eE][+-]?\d+)?/, 'number literal'), parseFloat);
+const JArray = (0, utilities_1.lazy)(() => (0, map_1.map)((0, seq_1.seq)(LSquare, (0, utilities_1.surely)((0, seq_1.seq)(WhiteSpace, (0, zeroOrMany_1.zeroOrMany)(Value, (0, seq_1.seq)(WhiteSpace, Comma, WhiteSpace)), WhiteSpace, RSquare))), (data) => data[1][1]));
+const JObject = (0, utilities_1.lazy)(() => (0, map_1.map)((0, seq_1.seq)(LCurly, (0, utilities_1.surely)((0, seq_1.seq)(WhiteSpace, (0, zeroOrMany_1.zeroOrMany)(ObjectEntry, (0, seq_1.seq)(WhiteSpace, Comma, WhiteSpace)), WhiteSpace, RCurly))), data => Object.fromEntries(data[1][1])));
+const Value = (0, any_1.any)(StringLiteral, NumberLiteral, JObject, JArray, True, False, Null);
+const ObjectEntry = (0, map_1.map)((0, seq_1.seq)(StringLiteral, (0, utilities_1.surely)((0, seq_1.seq)(WhiteSpace, Colon, WhiteSpace, Value))), ([key, rest]) => [key, rest[3]]);
+exports.json = (0, between_1.between)(WhiteSpace, Value, WhiteSpace);

package/dist/parsers/regex.js

@@ -10,7 +10,7 @@ function regex(match, expected) {
     return (ctx) => {
         regexp.lastIndex = ctx.index;
         const regexMatch = regexp.exec(ctx.text);
-        if (regexMatch !== null && regexMatch.index === ctx.index) {
+        if (regexMatch !== null) {
             return (0, types_1.success)({ ...ctx, index: ctx.index + regexMatch[0].length }, regexMatch[0]);
         }
         else {

package/dist/parsers/utilities.js

@@ -15,7 +15,8 @@ function ref(parser, check, expected) {
     return (ctx) => {
         const res = parser(ctx);
         if (!(0, types_1.isFailure)(res) && !check(res.value)) {
-            return (0, types_1.failure)(res.ctx, expected ?? 'check', [`ref: ${expected ?? 'check'}`]);
+            const phrase = expected ?? 'check';
+            return (0, types_1.failure)(res.ctx, phrase, [`ref: ${phrase}`]);
         }
         return res;
     };

package/dist/parsers/zeroOrMany.d.ts

@@ -0,0 +1,5 @@
+import { Parser } from "../types";
+/** 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[]>;

package/dist/parsers/zeroOrMany.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zeroOrMany = zeroOrMany;
+const types_1 = require("../types");
+/** 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.
+ */
+function zeroOrMany(item, separator = undefined) {
+    if (separator) {
+        return (ctx) => {
+            const results = [];
+            const res = item(ctx);
+            if ((0, types_1.isFailure)(res)) {
+                const surelyIndex = res.history.findIndex(h => h === 'surely');
+                // Stryker disable next-line EqualityOperator: The > mutant results in an equivalent mutant
+                if (surelyIndex >= 0) {
+                    return (0, types_1.failure)(res.ctx, res.expected, ['zeroOrMany', ...res.history.slice(0, surelyIndex), ...res.history.slice(surelyIndex + 1)]);
+                }
+                return (0, types_1.success)(ctx, results);
+            }
+            ctx = res.ctx;
+            results.push(res.value);
+            while (true) {
+                const resSep = separator(ctx);
+                if ((0, types_1.isFailure)(resSep)) {
+                    const surelyIndex = resSep.history.findIndex(h => h === 'surely');
+                    // Stryker disable next-line EqualityOperator: The > mutant results in an equivalent mutant
+                    if (surelyIndex >= 0) {
+                        return (0, types_1.failure)(resSep.ctx, resSep.expected, ['zeroOrMany', ...resSep.history.slice(0, surelyIndex), ...resSep.history.slice(surelyIndex + 1)]);
+                    }
+                    return (0, types_1.success)(ctx, results);
+                }
+                const res = item(resSep.ctx);
+                if ((0, types_1.isFailure)(res)) {
+                    const surelyIndex = res.history.findIndex(h => h === 'surely');
+                    // Stryker disable next-line EqualityOperator: The > mutant results in an equivalent mutant
+                    if (surelyIndex >= 0) {
+                        return (0, types_1.failure)(res.ctx, res.expected, ['zeroOrMany', ...res.history.slice(0, surelyIndex), ...res.history.slice(surelyIndex + 1)]);
+                    }
+                    return (0, types_1.success)(ctx, results);
+                }
+                ctx = res.ctx;
+                results.push(res.value);
+            }
+        };
+    }
+    else
+        return (ctx) => {
+            const results = [];
+            while (true) {
+                const res = item(ctx);
+                if ((0, types_1.isFailure)(res)) {
+                    const surelyIndex = res.history.findIndex(h => h === 'surely');
+                    // Stryker disable next-line EqualityOperator: The > mutant results in an equivalent mutant
+                    if (surelyIndex >= 0) {
+                        return (0, types_1.failure)(res.ctx, res.expected, ['zeroOrMany', ...res.history.slice(0, surelyIndex), ...res.history.slice(surelyIndex + 1)]);
+                    }
+                    return (0, types_1.success)(ctx, results);
+                }
+                ctx = res.ctx;
+                results.push(res.value);
+            }
+        };
+}

package/dist/types.d.ts

@@ -16,6 +16,7 @@ export type Failure = Readonly<{
     ctx: Context;
     history: string[];
 }>;
+export type ParseResult<T extends Parser<unknown>> = T extends Parser<infer P> ? P : never;
 export type TokenRange = {
     start: number;
     end: number;

package/dist-esm/parser.js

@@ -9,7 +9,7 @@ import { isFailure, ParseError } from './types';
 export function ParseText(text, parser, path = '') {
     const res = parser({ text, path, index: 0 });
     if (isFailure(res)) {
-        throw new ParseError(`Parse error, expected ${[...res.history].pop()} at char ${res.ctx.index}`, text, res.ctx.index, res.history);
+        throw new ParseError(`Parse error, expected ${res.history[res.history.length - 1]} at char ${res.ctx.index}`, text, res.ctx.index, res.history);
     }
     if (res.ctx.index !== text.length) {
         throw new ParseError(`Parse error, expected end of text at char ${res.ctx.index}`, text, res.ctx.index, []);

package/dist-esm/parsers/any.js

@@ -19,8 +19,10 @@ export function any(...parsers) {
         for (const parser of parsers) {
             const res = parser(ctx);
             if (isFailure(res)) {
-                if (res.history.includes('surely')) {
-                    return failure(res.ctx, res.expected, res.history.filter(h => h !== 'surely'));
+                const surelyIndex = res.history.findIndex(h => h === 'surely');
+                // Stryker disable next-line EqualityOperator: The > mutant results in an equivalent mutant
+                if (surelyIndex >= 0) {
+                    return failure(res.ctx, res.expected, ['any', ...res.history.slice(0, surelyIndex), ...res.history.slice(surelyIndex + 1)]);
                 }
                 expected.push(res);
             }

package/dist-esm/parsers/anyString.js

@@ -23,14 +23,7 @@ function createSearchTree(matches) {
 }
 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;
-        }
+        node.matchIndex ??= idIndex;
     }
     else {
         const char = match[0][charIndex];
@@ -48,15 +41,17 @@ function addMatchToTree(node, match, idIndex, charIndex = 0) {
             }
         }
         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);
+            node.set(char, node.get(char) ?? newNode);
+            if (lowercase !== uppercase) {
+                const lower = node.get(lowercase);
+                const upper = node.get(uppercase);
+                if (lower != null && lower === upper) {
+                    const copy = new Map(lower.entries());
+                    copy.matchIndex = lower.matchIndex;
+                    node.set(uppercase, copy);
+                }
             }
-            addMatchToTree(charNode, match, idIndex, charIndex + 1);
+            addMatchToTree(node.get(char), match, idIndex, charIndex + 1);
         }
     }
 }

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

@@ -2,6 +2,9 @@ export * from './any';
 export * from './between';
 export * from './exhaust';
 export * from './many';
+export * from './zeroOrMany';
+export * from './oneOrMany';
+export * from './oneOrManyRed';
 export * from './map';
 export * from './opt';
 export * from './regex';
@@ -10,3 +13,4 @@ export { str, stri } from './str';
 export * from './recovery';
 export * from './utilities';
 export * from './values';
+export * from './readymade';

package/dist-esm/parsers/index.js

@@ -2,6 +2,9 @@ export * from './any';
 export * from './between';
 export * from './exhaust';
 export * from './many';
+export * from './zeroOrMany';
+export * from './oneOrMany';
+export * from './oneOrManyRed';
 export * from './map';
 export * from './opt';
 export * from './regex';
@@ -10,3 +13,4 @@ export { str, stri } from './str';
 export * from './recovery';
 export * from './utilities';
 export * from './values';
+export * from './readymade';

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

@@ -3,15 +3,3 @@ import { Parser } from "../types";
  * @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

@@ -8,114 +8,15 @@ export function many(parser) {
         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 surelyIndex = res.history.findIndex(h => h === 'surely');
+                // Stryker disable next-line EqualityOperator: The > mutant results in an equivalent mutant
+                if (surelyIndex >= 0) {
+                    return failure(res.ctx, res.expected, ['many', ...res.history.slice(0, surelyIndex), ...res.history.slice(surelyIndex + 1)]);
                 }
-                const res = item(resSep.ctx);
-                if (isFailure(res)) {
-                    return success(ctx, results);
-                }
-                ctx = res.ctx;
-                results.push(res.value);
+                return success(ctx, results);
             }
-        };
-    }
-    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/oneOrMany.d.ts

@@ -0,0 +1,5 @@
+import { Parser } from "../types";
+/** 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[]>;

package/dist-esm/parsers/oneOrMany.js

@@ -0,0 +1,63 @@
+import { failure, isFailure, success } from "../types";
+/** 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 failure(res.ctx, res.expected, ['oneOrMany', ...res.history]);
+            }
+            ctx = res.ctx;
+            results.push(res.value);
+            while (true) {
+                const resSep = separator(ctx);
+                if (isFailure(resSep)) {
+                    const surelyIndex = resSep.history.findIndex(h => h === 'surely');
+                    // Stryker disable next-line EqualityOperator: The > mutant results in an equivalent mutant
+                    if (surelyIndex >= 0) {
+                        return failure(resSep.ctx, resSep.expected, ['oneOrMany', ...resSep.history.slice(0, surelyIndex), ...resSep.history.slice(surelyIndex + 1)]);
+                    }
+                    return success(ctx, results);
+                }
+                const res = item(resSep.ctx);
+                if (isFailure(res)) {
+                    const surelyIndex = res.history.findIndex(h => h === 'surely');
+                    // Stryker disable next-line EqualityOperator: The > mutant results in an equivalent mutant
+                    if (surelyIndex >= 0) {
+                        return failure(res.ctx, res.expected, ['oneOrMany', ...res.history.slice(0, surelyIndex), ...res.history.slice(surelyIndex + 1)]);
+                    }
+                    return success(ctx, results);
+                }
+                ctx = res.ctx;
+                results.push(res.value);
+            }
+        };
+    }
+    else {
+        return (ctx) => {
+            const results = [];
+            const res = item(ctx);
+            if (isFailure(res)) {
+                return failure(res.ctx, res.expected, ['oneOrMany', ...res.history]);
+            }
+            ctx = res.ctx;
+            results.push(res.value);
+            while (true) {
+                const res = item(ctx);
+                if (isFailure(res)) {
+                    const surelyIndex = res.history.findIndex(h => h === 'surely');
+                    // Stryker disable next-line EqualityOperator: The > mutant results in an equivalent mutant
+                    if (surelyIndex >= 0) {
+                        return failure(res.ctx, res.expected, ['oneOrMany', ...res.history.slice(0, surelyIndex), ...res.history.slice(surelyIndex + 1)]);
+                    }
+                    return success(ctx, results);
+                }
+                ctx = res.ctx;
+                results.push(res.value);
+            }
+        };
+    }
+}

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

@@ -0,0 +1,5 @@
+import { Parser } from "../types";
+/** 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/oneOrManyRed.js

@@ -0,0 +1,41 @@
+import { failure, isFailure, success } from "../types";
+/** 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 failure(res.ctx, res.expected, ['oneOrManyRed', ...res.history]);
+        }
+        ctx = res.ctx;
+        let result = res.value;
+        while (true) {
+            const resSep = separator(ctx);
+            if (isFailure(resSep)) {
+                const surelyIndex = resSep.history.findIndex(h => h === 'surely');
+                // Stryker disable next-line EqualityOperator: The > mutant results in an equivalent mutant
+                if (surelyIndex >= 0) {
+                    return failure(resSep.ctx, resSep.expected, ['oneOrManyRed', ...resSep.history.slice(0, surelyIndex), ...resSep.history.slice(surelyIndex + 1)]);
+                }
+                return success(ctx, result);
+            }
+            const res = item(resSep.ctx);
+            if (isFailure(res)) {
+                const surelyIndex = res.history.findIndex(h => h === 'surely');
+                // Stryker disable next-line EqualityOperator: The > mutant results in an equivalent mutant
+                if (surelyIndex >= 0) {
+                    return failure(res.ctx, res.expected, ['oneOrManyRed', ...res.history.slice(0, surelyIndex), ...res.history.slice(surelyIndex + 1)]);
+                }
+                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/readymade.d.ts

@@ -0,0 +1,7 @@
+import { Parser } from "../types";
+export type Json = string | number | boolean | null | {
+    [key: number]: Json;
+} | {
+    [key: string]: Json;
+};
+export declare const json: Parser<Json>;

package/dist-esm/parsers/readymade.js

@@ -0,0 +1,43 @@
+import { any } from "./any";
+import { between } from "./between";
+import { zeroOrMany } from "./zeroOrMany";
+import { map } from "./map";
+import { regex } from "./regex";
+import { seq } from "./seq";
+import { str } from "./str";
+import { lazy, surely } from "./utilities";
+const WhiteSpace = regex(/\s*/m, 'whitespace');
+const True = map(str("true"), () => true);
+const False = map(str("false"), () => false);
+const Null = map(str("null"), () => null);
+const LCurly = str("{");
+const RCurly = surely(str("}"));
+const LSquare = str("[");
+const RSquare = surely(str("]"));
+const Quote = str('"');
+const Comma = str(",");
+const Colon = surely(str(":"));
+const replacements = {
+    '\\\\': '\\',
+    '\\0': '\0',
+    '\\b': '\b',
+    '\\f': '\f',
+    '\\n': '\n',
+    '\\r': '\r',
+    '\\t': '\t',
+    '\\v': '\v',
+    '\\"': '"'
+};
+const StringLiteral = between(Quote, map(regex(/(?:[^\\"]|\\(?:[0bfnrtv"\\]|u[0-9a-fA-F]{4}))*/, 'string literal'), str => str.replace(/\\(?:[0bfnrtv"\\]|u[0-9a-fA-F]{4})/g, function (replace) {
+    const tabled = replacements[replace];
+    if (tabled != null) {
+        return tabled;
+    }
+    return String.fromCharCode(parseInt(replace.slice(2), 16));
+})), Quote);
+const NumberLiteral = map(regex(/-?(?:0|(?:[1-9]\d*))(?:\.\d+)?(?:[eE][+-]?\d+)?/, 'number literal'), parseFloat);
+const JArray = lazy(() => map(seq(LSquare, surely(seq(WhiteSpace, zeroOrMany(Value, seq(WhiteSpace, Comma, WhiteSpace)), WhiteSpace, RSquare))), (data) => data[1][1]));
+const JObject = lazy(() => map(seq(LCurly, surely(seq(WhiteSpace, zeroOrMany(ObjectEntry, seq(WhiteSpace, Comma, WhiteSpace)), WhiteSpace, RCurly))), data => Object.fromEntries(data[1][1])));
+const Value = any(StringLiteral, NumberLiteral, JObject, JArray, True, False, Null);
+const ObjectEntry = map(seq(StringLiteral, surely(seq(WhiteSpace, Colon, WhiteSpace, Value))), ([key, rest]) => [key, rest[3]]);
+export const json = between(WhiteSpace, Value, WhiteSpace);

package/dist-esm/parsers/regex.js

@@ -7,7 +7,7 @@ export function regex(match, expected) {
     return (ctx) => {
         regexp.lastIndex = ctx.index;
         const regexMatch = regexp.exec(ctx.text);
-        if (regexMatch !== null && regexMatch.index === ctx.index) {
+        if (regexMatch !== null) {
             return success({ ...ctx, index: ctx.index + regexMatch[0].length }, regexMatch[0]);
         }
         else {

package/dist-esm/parsers/utilities.js

@@ -6,7 +6,8 @@ export function ref(parser, check, expected) {
     return (ctx) => {
         const res = parser(ctx);
         if (!isFailure(res) && !check(res.value)) {
-            return failure(res.ctx, expected ?? 'check', [`ref: ${expected ?? 'check'}`]);
+            const phrase = expected ?? 'check';
+            return failure(res.ctx, phrase, [`ref: ${phrase}`]);
         }
         return res;
     };

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

@@ -0,0 +1,5 @@
+import { Parser } from "../types";
+/** 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[]>;

package/dist-esm/parsers/zeroOrMany.js

@@ -0,0 +1,61 @@
+import { failure, isFailure, success } from "../types";
+/** 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)) {
+                const surelyIndex = res.history.findIndex(h => h === 'surely');
+                // Stryker disable next-line EqualityOperator: The > mutant results in an equivalent mutant
+                if (surelyIndex >= 0) {
+                    return failure(res.ctx, res.expected, ['zeroOrMany', ...res.history.slice(0, surelyIndex), ...res.history.slice(surelyIndex + 1)]);
+                }
+                return success(ctx, results);
+            }
+            ctx = res.ctx;
+            results.push(res.value);
+            while (true) {
+                const resSep = separator(ctx);
+                if (isFailure(resSep)) {
+                    const surelyIndex = resSep.history.findIndex(h => h === 'surely');
+                    // Stryker disable next-line EqualityOperator: The > mutant results in an equivalent mutant
+                    if (surelyIndex >= 0) {
+                        return failure(resSep.ctx, resSep.expected, ['zeroOrMany', ...resSep.history.slice(0, surelyIndex), ...resSep.history.slice(surelyIndex + 1)]);
+                    }
+                    return success(ctx, results);
+                }
+                const res = item(resSep.ctx);
+                if (isFailure(res)) {
+                    const surelyIndex = res.history.findIndex(h => h === 'surely');
+                    // Stryker disable next-line EqualityOperator: The > mutant results in an equivalent mutant
+                    if (surelyIndex >= 0) {
+                        return failure(res.ctx, res.expected, ['zeroOrMany', ...res.history.slice(0, surelyIndex), ...res.history.slice(surelyIndex + 1)]);
+                    }
+                    return success(ctx, results);
+                }
+                ctx = res.ctx;
+                results.push(res.value);
+            }
+        };
+    }
+    else
+        return (ctx) => {
+            const results = [];
+            while (true) {
+                const res = item(ctx);
+                if (isFailure(res)) {
+                    const surelyIndex = res.history.findIndex(h => h === 'surely');
+                    // Stryker disable next-line EqualityOperator: The > mutant results in an equivalent mutant
+                    if (surelyIndex >= 0) {
+                        return failure(res.ctx, res.expected, ['zeroOrMany', ...res.history.slice(0, surelyIndex), ...res.history.slice(surelyIndex + 1)]);
+                    }
+                    return success(ctx, results);
+                }
+                ctx = res.ctx;
+                results.push(res.value);
+            }
+        };
+}

package/dist-esm/types.d.ts

@@ -16,6 +16,7 @@ export type Failure = Readonly<{
     ctx: Context;
     history: string[];
 }>;
+export type ParseResult<T extends Parser<unknown>> = T extends Parser<infer P> ? P : never;
 export type TokenRange = {
     start: number;
     end: number;

package/package.json

@@ -1,61 +1,61 @@
-{
-  "name": "parser-combinators",
-  "version": "1.2.3",
-  "license": "ISC",
-  "maintainers": [
-    "Micha_i"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/michalusio/Parser.git"
-  },
-  "bugs": {
-    "url": "https://github.com/michalusio/Parser/issues"
-  },
-  "homepage": "https://github.com/michalusio/Parser#readme",
-  "description": "A library of parser combinators, with which you can create your own parsers. The library will be continuously improved in time.",
-  "scripts": {
-    "start": "tsc && node .",
-    "lint": "eslint src --ext .ts",
-    "build": "tsc",
-    "build-esm": "tsc --project tsconfig.esm.json",
-    "bundle": "npm run lint && npm run build && npm run build-esm",
-    "test:mutate": "stryker run",
-    "test:unit": "mocha",
-    "test": "nyc -e '.ts' --r html -r lcov -r text npm run test:unit"
-  },
-  "author": "Micha_i <isalski.michal@gmail.com> (https://github.com/michalusio)",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "type": "commonjs",
-  "engines": {
-    "node": ">=18"
-  },
-  "devDependencies": {
-    "@stryker-mutator/core": "^9.4.0",
-    "@stryker-mutator/mocha-runner": "^9.4.0",
-    "@stryker-mutator/typescript-checker": "^9.4.0",
-    "@types/mocha": "10.0.10",
-    "@types/node": "25.0.9",
-    "cross-env": "10.1.0",
-    "esbuild": "0.27.2",
-    "eslint": "9.39.2",
-    "mocha": "11.7.5",
-    "nyc": "17.1.0",
-    "ts-node": "10.9.2",
-    "typescript": "5.9.3",
-    "typescript-eslint": "8.53.0"
-  },
-  "keywords": [
-    "parser",
-    "combinator",
-    "parser-combinator",
-    "parsing",
-    "combining",
-    "functional"
-  ],
-  "prettier": {
-    "tabWidth": 4,
-    "useTabs": false
-  }
-}
+{
+  "name": "parser-combinators",
+  "version": "1.2.6",
+  "license": "ISC",
+  "maintainers": [
+    "Micha_i"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/michalusio/Parser.git"
+  },
+  "bugs": {
+    "url": "https://github.com/michalusio/Parser/issues"
+  },
+  "homepage": "https://github.com/michalusio/Parser#readme",
+  "description": "A library of parser combinators, with which you can create your own parsers. The library will be continuously improved in time.",
+  "scripts": {
+    "start": "tsc && node .",
+    "lint": "eslint src --ext .ts",
+    "build": "tsc",
+    "build-esm": "tsc --project tsconfig.esm.json",
+    "bundle": "npm run lint && npm run build && npm run build-esm",
+    "test:mutate": "stryker run",
+    "test:unit": "mocha",
+    "test": "nyc -e '.ts' --r html -r lcov -r text npm run test:unit"
+  },
+  "author": "Micha_i <isalski.michal@gmail.com> (https://github.com/michalusio)",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "commonjs",
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@stryker-mutator/core": "^9.5.0",
+    "@stryker-mutator/mocha-runner": "^9.5.0",
+    "@stryker-mutator/typescript-checker": "^9.5.0",
+    "@types/mocha": "10.0.10",
+    "@types/node": "25.1.0",
+    "cross-env": "10.1.0",
+    "esbuild": "0.27.2",
+    "eslint": "9.39.2",
+    "mocha": "11.7.5",
+    "nyc": "17.1.0",
+    "ts-node": "10.9.2",
+    "typescript": "5.9.3",
+    "typescript-eslint": "8.54.0"
+  },
+  "keywords": [
+    "parser",
+    "combinator",
+    "parser-combinator",
+    "parsing",
+    "combining",
+    "functional"
+  ],
+  "prettier": {
+    "tabWidth": 4,
+    "useTabs": false
+  }
+}