parser-combinators 1.2.2 → 1.2.5

package/README.md

@@ -1,7 +1,6 @@
 ## Parser Combinators
 
 [![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://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)

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

@@ -3,22 +3,11 @@ 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'];
+const optimizations_1 = require("./optimizations");
 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]];
-            }
-        });
+    if ((0, optimizations_1.shouldPerformFusions)() && (0, optimizations_1.allStringParsers)(parsers)) {
+        const matches = parsers.flatMap(p => p.matches);
         // 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) {
@@ -33,8 +22,9 @@ 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');
+                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.d.ts

@@ -1,15 +1,12 @@
 import { Parser } from "../types";
-import { StrIParser, StrParser } from "./str";
-type AnyStringParser<T> = Parser<T> & {
+export type AnyStringParser<T> = Parser<T> & {
     parserType: 'anyString';
     /**
      * if flag is true, match case-insensitive
      */
-    matches: (readonly [string, boolean])[];
+    matches: (readonly [string, boolean, (v: string) => unknown])[];
 };
-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 {};
+export declare function anyString<T>(matches: (readonly [string, boolean, (v: string) => unknown])[]): AnyStringParser<T>;

package/dist/parsers/anyString.js

@@ -12,7 +12,7 @@ function anyString(matches) {
         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]);
+            return (0, types_1.success)({ ...ctx, index: result.end }, matches[result.matchIndex][2](matches[result.matchIndex][0]));
         }
         else {
             return (0, types_1.failure)(ctx, lastMatchInQuotes, ['any', lastMatchInQuotes]);
@@ -27,7 +27,9 @@ function createSearchTree(matches) {
 function addMatchToTree(node, match, idIndex, charIndex = 0) {
     if (charIndex >= match[0].length) {
         if (node.matchIndex != undefined) {
-            node.matchIndex = Math.min(node.matchIndex, idIndex);
+            if (node.matchIndex > idIndex) {
+                node.matchIndex = idIndex;
+            }
         }
         else {
             node.matchIndex = idIndex;

package/dist/parsers/between.js

@@ -2,19 +2,23 @@
 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]);
+        const resLeft = left(ctx);
+        if ((0, types_1.isFailure)(resLeft)) {
+            return resLeft;
         }
-        return { ...res, value: res.value[1] };
+        const resParse = parser(resLeft.ctx);
+        if ((0, types_1.isFailure)(resParse)) {
+            return resParse;
+        }
+        const resRight = right(resParse.ctx);
+        if ((0, types_1.isFailure)(resRight)) {
+            return resRight;
+        }
+        return (0, types_1.success)(resRight.ctx, resParse.value);
     };
 }

package/dist/parsers/many.d.ts

@@ -1,4 +1,4 @@
-import { Parser } from '../types';
+import { Parser } from "../types";
 /** Parses zero or more occurences of the given parser.
  * @returns A parser returning an array of many parses.
  */
@@ -6,7 +6,7 @@ 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[]>;
+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.
  */

package/dist/parsers/many.js

@@ -5,9 +5,6 @@ exports.zeroOrMany = zeroOrMany;
 exports.oneOrMany = oneOrMany;
 exports.oneOrManyRed = oneOrManyRed;
 const types_1 = require("../types");
-const map_1 = require("./map");
-const opt_1 = require("./opt");
-const seq_1 = require("./seq");
 /** Parses zero or more occurences of the given parser.
  * @returns A parser returning an array of many parses.
  */
@@ -17,6 +14,10 @@ function many(parser) {
         while (true) {
             const res = parser(ctx);
             if ((0, types_1.isFailure)(res)) {
+                const surelyIndex = res.history.findIndex(h => h === 'surely');
+                if (surelyIndex >= 0) {
+                    return (0, types_1.failure)(res.ctx, res.expected, ['many', ...res.history.slice(0, surelyIndex), ...res.history.slice(surelyIndex + 1)]);
+                }
                 return (0, types_1.success)(ctx, results);
             }
             ctx = res.ctx;
@@ -27,35 +28,136 @@ function many(parser) {
 /** 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) {
-    return (0, map_1.map)((0, opt_1.opt)(oneOrMany(item, separator)), t => t ?? []);
+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');
+                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');
+                    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');
+                    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 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) {
-    const sequencer = (0, map_1.map)((0, seq_1.seq)(item, many(separator
-        ? (0, map_1.map)((0, seq_1.seq)(separator, item), ([, t]) => t)
-        : item)), ([t, ts]) => ([t, ...ts]));
-    return (ctx) => {
-        const res = sequencer(ctx);
-        if ((0, types_1.isFailure)(res)) {
-            const newHistory = [...res.history];
-            newHistory.splice(0, 2);
-            return (0, types_1.failure)(res.ctx, res.expected, ['oneOrMany', ...newHistory]);
-        }
-        return res;
-    };
+    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)) {
+                    const surelyIndex = resSep.history.findIndex(h => h === 'surely');
+                    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');
+                    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 res;
+            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');
+                    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);
+            }
+        };
+    }
 }
 /** 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 (0, map_1.map)((0, map_1.map)((0, seq_1.seq)((0, map_1.map)(item, (x) => [null, x]), many((0, seq_1.seq)(separator, item))), ([t, ts]) => ([t, ...ts])), ts => {
-        let result = ts[0][1];
-        for (let i = 1; i < ts.length; i++) {
-            result = reducer(result, ts[i][1], ts[i][0]);
+    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)) {
+                const surelyIndex = resSep.history.findIndex(h => h === 'surely');
+                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');
+                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']);
+            }
         }
-        return result;
-    });
+    };
 }

package/dist/parsers/map.js

@@ -2,11 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.map = map;
 const types_1 = require("../types");
+const optimizations_1 = require("./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.
  */
 function map(parser, mapper) {
-    return (ctx) => {
+    let marker = {};
+    if ((0, optimizations_1.shouldPerformFusions)() && (0, optimizations_1.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 ((0, types_1.isFailure)(res))
             return (0, types_1.failure)(res.ctx, res.expected, ['map', ...res.history]);
@@ -17,5 +22,5 @@ function map(parser, mapper) {
         catch {
             return (0, types_1.failure)(res.ctx, 'Error while mapping', ['map']);
         }
-    };
+    }, marker);
 }

package/dist/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/parsers/optimizations.js

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

package/dist/parsers/str.d.ts

@@ -1,17 +1,9 @@
 import { Parser } from '../types';
-export type StrParser<T> = Parser<T> & {
-    parserType: 'str';
-    match: T;
-};
 /** 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): StrParser<T>;
-export type StrIParser<T> = Parser<T> & {
-    parserType: 'stri';
-    match: T;
-};
+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): StrIParser<Lowercase<T>>;
+export declare function stri<T extends string>(match: T): Parser<Lowercase<T>>;

package/dist/parsers/str.js

@@ -15,7 +15,7 @@ function str(match) {
         else {
             return (0, types_1.failure)(ctx, inQuotes, [inQuotes]);
         }
-    }, { parserType: 'str', match });
+    }, { 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.
@@ -32,5 +32,5 @@ function stri(match) {
         else {
             return (0, types_1.failure)(ctx, inQuotes, [inQuotes]);
         }
-    }, { parserType: 'stri', match: lowercase });
+    }, { parserType: 'anyString', matches: [[lowercase, true, (v) => v]] });
 }

package/dist/parsers/utilities.d.ts

@@ -1,11 +1,4 @@
 import { Parser, Token } from '../types';
-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;
 /** 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.
  */
@@ -31,3 +24,7 @@ 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>;

package/dist/parsers/utilities.js

@@ -1,25 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toggleFusions = exports.shouldPerformFusions = void 0;
 exports.ref = ref;
 exports.expect = expect;
 exports.expectErase = expectErase;
 exports.surely = surely;
 exports.token = token;
 exports.lookaround = lookaround;
+exports.lazy = lazy;
 const types_1 = require("../types");
-const shouldPerformFusions = () => performFusions;
-exports.shouldPerformFusions = shouldPerformFusions;
-let performFusions = true;
-/**
- * Disables all parser combinator fusions.
- *
- * Should probably be used only for testing performance.
- */
-const toggleFusions = (value) => {
-    performFusions = value;
-};
-exports.toggleFusions = toggleFusions;
 /** 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.
  */
@@ -94,3 +82,13 @@ function lookaround(parser) {
         return (0, types_1.failure)(ctx, result.expected, ['lookaround', ...result.history]);
     };
 }
+/**
+ * Turns a function creating a parser into a parser. Useful for recursive grammars.
+ */
+function lazy(parserGetter) {
+    let parser;
+    return (ctx) => {
+        parser ??= parserGetter();
+        return parser(ctx);
+    };
+}

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

@@ -1,21 +1,10 @@
 import { failure, isFailure } from '../types';
 import { anyString } from './anyString';
-import { shouldPerformFusions } from './utilities';
-const optimizableTypes = ['str', 'stri', 'anyString'];
+import { shouldPerformFusions, allStringParsers } from './optimizations';
 export function any(...parsers) {
     let marker = {};
-    if (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]];
-            }
-        });
+    if (shouldPerformFusions() && allStringParsers(parsers)) {
+        const matches = parsers.flatMap(p => p.matches);
         // 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) {
@@ -30,8 +19,9 @@ 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');
+                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.d.ts

@@ -1,15 +1,12 @@
 import { Parser } from "../types";
-import { StrIParser, StrParser } from "./str";
-type AnyStringParser<T> = Parser<T> & {
+export type AnyStringParser<T> = Parser<T> & {
     parserType: 'anyString';
     /**
      * if flag is true, match case-insensitive
      */
-    matches: (readonly [string, boolean])[];
+    matches: (readonly [string, boolean, (v: string) => unknown])[];
 };
-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 {};
+export declare function anyString<T>(matches: (readonly [string, boolean, (v: string) => unknown])[]): AnyStringParser<T>;

package/dist-esm/parsers/anyString.js

@@ -9,7 +9,7 @@ export function anyString(matches) {
         tree ??= createSearchTree(matches);
         const result = searchThroughTree(tree, ctx.text, ctx.index);
         if (result) {
-            return success({ ...ctx, index: result.end }, matches[result.matchIndex][0]);
+            return success({ ...ctx, index: result.end }, matches[result.matchIndex][2](matches[result.matchIndex][0]));
         }
         else {
             return failure(ctx, lastMatchInQuotes, ['any', lastMatchInQuotes]);
@@ -24,7 +24,9 @@ function createSearchTree(matches) {
 function addMatchToTree(node, match, idIndex, charIndex = 0) {
     if (charIndex >= match[0].length) {
         if (node.matchIndex != undefined) {
-            node.matchIndex = Math.min(node.matchIndex, idIndex);
+            if (node.matchIndex > idIndex) {
+                node.matchIndex = idIndex;
+            }
         }
         else {
             node.matchIndex = idIndex;

package/dist-esm/parsers/between.js

@@ -1,17 +1,21 @@
-import { failure, isFailure } from '../types';
-import { seq } from './seq';
+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) {
-    const sequence = seq(left, parser, right);
     return (ctx) => {
-        const res = sequence(ctx);
-        if (isFailure(res)) {
-            const newHistory = [...res.history];
-            newHistory.splice(0, 1);
-            return failure(res.ctx, res.expected, ['between', ...newHistory]);
+        const resLeft = left(ctx);
+        if (isFailure(resLeft)) {
+            return resLeft;
         }
-        return { ...res, value: res.value[1] };
+        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/many.d.ts

@@ -1,4 +1,4 @@
-import { Parser } from '../types';
+import { Parser } from "../types";
 /** Parses zero or more occurences of the given parser.
  * @returns A parser returning an array of many parses.
  */
@@ -6,7 +6,7 @@ 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[]>;
+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.
  */

package/dist-esm/parsers/many.js

@@ -1,7 +1,4 @@
-import { failure, isFailure, success } from '../types';
-import { map } from './map';
-import { opt } from './opt';
-import { seq } from './seq';
+import { failure, isFailure, success } from "../types";
 /** Parses zero or more occurences of the given parser.
  * @returns A parser returning an array of many parses.
  */
@@ -11,6 +8,10 @@ export function many(parser) {
         while (true) {
             const res = parser(ctx);
             if (isFailure(res)) {
+                const surelyIndex = res.history.findIndex(h => h === 'surely');
+                if (surelyIndex >= 0) {
+                    return failure(res.ctx, res.expected, ['many', ...res.history.slice(0, surelyIndex), ...res.history.slice(surelyIndex + 1)]);
+                }
                 return success(ctx, results);
             }
             ctx = res.ctx;
@@ -21,35 +22,136 @@ export function many(parser) {
 /** 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) {
-    return map(opt(oneOrMany(item, separator)), t => t ?? []);
+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');
+                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');
+                    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');
+                    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 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) {
-    const sequencer = map(seq(item, many(separator
-        ? map(seq(separator, item), ([, t]) => t)
-        : item)), ([t, ts]) => ([t, ...ts]));
-    return (ctx) => {
-        const res = sequencer(ctx);
-        if (isFailure(res)) {
-            const newHistory = [...res.history];
-            newHistory.splice(0, 2);
-            return failure(res.ctx, res.expected, ['oneOrMany', ...newHistory]);
-        }
-        return res;
-    };
+    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)) {
+                    const surelyIndex = resSep.history.findIndex(h => h === 'surely');
+                    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');
+                    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 res;
+            ctx = res.ctx;
+            results.push(res.value);
+            while (true) {
+                const res = item(ctx);
+                if (isFailure(res)) {
+                    const surelyIndex = res.history.findIndex(h => h === 'surely');
+                    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);
+            }
+        };
+    }
 }
 /** 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 map(map(seq(map(item, (x) => [null, x]), many(seq(separator, item))), ([t, ts]) => ([t, ...ts])), ts => {
-        let result = ts[0][1];
-        for (let i = 1; i < ts.length; i++) {
-            result = reducer(result, ts[i][1], ts[i][0]);
+    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)) {
+                const surelyIndex = resSep.history.findIndex(h => h === 'surely');
+                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');
+                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']);
+            }
         }
-        return result;
-    });
+    };
 }

package/dist-esm/parsers/map.js

@@ -1,9 +1,14 @@
 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) {
-    return (ctx) => {
+    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]);
@@ -14,5 +19,5 @@ export function map(parser, mapper) {
         catch {
             return failure(res.ctx, 'Error while mapping', ['map']);
         }
-    };
+    }, marker);
 }

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/str.d.ts

@@ -1,17 +1,9 @@
 import { Parser } from '../types';
-export type StrParser<T> = Parser<T> & {
-    parserType: 'str';
-    match: T;
-};
 /** 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): StrParser<T>;
-export type StrIParser<T> = Parser<T> & {
-    parserType: 'stri';
-    match: T;
-};
+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): StrIParser<Lowercase<T>>;
+export declare function stri<T extends string>(match: T): Parser<Lowercase<T>>;

package/dist-esm/parsers/str.js

@@ -11,7 +11,7 @@ export function str(match) {
         else {
             return failure(ctx, inQuotes, [inQuotes]);
         }
-    }, { parserType: 'str', match });
+    }, { 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.
@@ -28,5 +28,5 @@ export function stri(match) {
         else {
             return failure(ctx, inQuotes, [inQuotes]);
         }
-    }, { parserType: 'stri', match: lowercase });
+    }, { parserType: 'anyString', matches: [[lowercase, true, (v) => v]] });
 }

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

@@ -1,11 +1,4 @@
 import { Parser, Token } from '../types';
-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;
 /** 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.
  */
@@ -31,3 +24,7 @@ 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>;

package/dist-esm/parsers/utilities.js

@@ -1,14 +1,4 @@
 import { failure, isFailure, success } from '../types';
-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;
-};
 /** 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.
  */
@@ -83,3 +73,13 @@ export function lookaround(parser) {
         return failure(ctx, result.expected, ['lookaround', ...result.history]);
     };
 }
+/**
+ * Turns a function creating a parser into a parser. Useful for recursive grammars.
+ */
+export function lazy(parserGetter) {
+    let parser;
+    return (ctx) => {
+        parser ??= parserGetter();
+        return parser(ctx);
+    };
+}

package/package.json

@@ -1,57 +1,61 @@
-{
-  "name": "parser-combinators",
-  "version": "1.2.2",
-  "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"
-  ]
-}
+{
+  "name": "parser-combinators",
+  "version": "1.2.5",
+  "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
+  }
+}