parser-combinators 1.1.2 → 1.2.0

package/{parsers → dist/parsers}/many.js

@@ -1,61 +1,61 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.oneOrManyRed = exports.oneOrMany = exports.zeroOrMany = exports.many = void 0;
-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.
- */
-function many(parser) {
-    return (ctx) => {
-        const results = [];
-        // eslint-disable-next-line no-constant-condition
-        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);
-        }
-    };
-}
-exports.many = many;
-/** 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 !== null && t !== void 0 ? t : []);
-}
-exports.zeroOrMany = zeroOrMany;
-/** 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) {
-    const sequencer = (0, map_1.map)((0, seq_1.seq)(item, many((0, map_1.map)((0, seq_1.seq)(separator, item), ([, t]) => t))), ([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;
-    };
-}
-exports.oneOrMany = oneOrMany;
-/** 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 result;
-    });
-}
-exports.oneOrManyRed = oneOrManyRed;
+"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");
+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.
+ */
+function many(parser) {
+    return (ctx) => {
+        const results = [];
+        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) {
+    return (0, map_1.map)((0, opt_1.opt)(oneOrMany(item, separator)), t => 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.
+ */
+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;
+    };
+}
+/** 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 result;
+    });
+}

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

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

package/{parsers → dist/parsers}/map.js

@@ -1,22 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.map = void 0;
-const types_1 = require("../types");
-/** Parses the input using the given parser, then maps the output.
- * @returns A parser that parses the same input, but has output mapped using the mapping function.
- */
-function map(parser, mapper) {
-    return (ctx) => {
-        const res = parser(ctx);
-        if ((0, types_1.isFailure)(res))
-            return (0, types_1.failure)(res.ctx, res.expected, ['map', ...res.history]);
-        try {
-            const newValue = mapper(res.value);
-            return (0, types_1.success)(res.ctx, newValue);
-        }
-        catch (e) {
-            return (0, types_1.failure)(res.ctx, 'Error while mapping', ['map']);
-        }
-    };
-}
-exports.map = map;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.map = map;
+const types_1 = require("../types");
+/** Parses the input using the given parser, then maps the output.
+ * @returns A parser that parses the same input, but has output mapped using the mapping function.
+ */
+function map(parser, mapper) {
+    return (ctx) => {
+        const res = parser(ctx);
+        if ((0, types_1.isFailure)(res))
+            return (0, types_1.failure)(res.ctx, res.expected, ['map', ...res.history]);
+        try {
+            const newValue = mapper(res.value);
+            return (0, types_1.success)(res.ctx, newValue);
+        }
+        catch {
+            return (0, types_1.failure)(res.ctx, 'Error while mapping', ['map']);
+        }
+    };
+}

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

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

package/{parsers → dist/parsers}/opt.js

@@ -1,17 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.opt = void 0;
-const types_1 = require("../types");
-/** Makes the parser optional.
- * @returns A parser that succeeds with `null` result if the parsing didn't succeed.
- */
-function opt(parser) {
-    return (ctx) => {
-        const parseResult = parser(ctx);
-        if ((0, types_1.isFailure)(parseResult)) {
-            return (0, types_1.success)(ctx, null);
-        }
-        return parseResult;
-    };
-}
-exports.opt = opt;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opt = opt;
+const types_1 = require("../types");
+/** Makes the parser optional.
+ * @returns A parser that succeeds with `null` result if the parsing didn't succeed.
+ */
+function opt(parser) {
+    return (ctx) => {
+        const parseResult = parser(ctx);
+        if ((0, types_1.isFailure)(parseResult)) {
+            return (0, types_1.success)(ctx, null);
+        }
+        return parseResult;
+    };
+}

package/dist/parsers/recovery.d.ts

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

package/dist/parsers/recovery.js

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

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

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

package/{parsers → dist/parsers}/regex.js

@@ -1,21 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.regex = void 0;
-const types_1 = require("../types");
-/** Parses a regex and returns the matched result of the parse.
- * @returns A parser parsing a given regex and returning a match.
- */
-function regex(match, expected) {
-    const regexp = new RegExp(match, typeof match === 'string' ? 'y' : match.flags + 'y');
-    return (ctx) => {
-        regexp.lastIndex = ctx.index;
-        const regexMatch = regexp.exec(ctx.text);
-        if (regexMatch !== null && regexMatch.index === ctx.index) {
-            return (0, types_1.success)({ ...ctx, index: ctx.index + regexMatch[0].length }, regexMatch[0]);
-        }
-        else {
-            return (0, types_1.failure)(ctx, expected, [expected]);
-        }
-    };
-}
-exports.regex = regex;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.regex = regex;
+const types_1 = require("../types");
+/** Parses a regex and returns the matched result of the parse.
+ * @returns A parser parsing a given regex and returning a match.
+ */
+function regex(match, expected) {
+    const regexp = new RegExp(match, typeof match === 'string' ? 'y' : match.flags + 'y');
+    return (ctx) => {
+        regexp.lastIndex = ctx.index;
+        const regexMatch = regexp.exec(ctx.text);
+        if (regexMatch !== null && regexMatch.index === ctx.index) {
+            return (0, types_1.success)({ ...ctx, index: ctx.index + regexMatch[0].length }, regexMatch[0]);
+        }
+        else {
+            return (0, types_1.failure)(ctx, expected, [expected]);
+        }
+    };
+}

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

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

package/{parsers → dist/parsers}/seq.js

@@ -1,18 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.seq = void 0;
-const types_1 = require("../types");
-function seq(...parsers) {
-    return (ctx) => {
-        const values = [];
-        for (const parser of parsers) {
-            const res = parser(ctx);
-            ctx = res.ctx;
-            if ((0, types_1.isFailure)(res))
-                return (0, types_1.failure)(res.ctx, res.expected, ['seq', ...res.history]);
-            values.push(res.value);
-        }
-        return (0, types_1.success)(ctx, values);
-    };
-}
-exports.seq = seq;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.seq = seq;
+const types_1 = require("../types");
+function seq(...parsers) {
+    return (ctx) => {
+        const values = [];
+        for (const parser of parsers) {
+            const res = parser(ctx);
+            ctx = res.ctx;
+            if ((0, types_1.isFailure)(res))
+                return (0, types_1.failure)(res.ctx, res.expected, ['seq', ...res.history]);
+            values.push(res.value);
+        }
+        return (0, types_1.success)(ctx, values);
+    };
+}

package/dist/parsers/str.d.ts

@@ -0,0 +1,17 @@
+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;
+};
+/** 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>>;

package/dist/parsers/str.js

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

package/dist/parsers/utilities.d.ts

@@ -0,0 +1,33 @@
+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.
+ */
+export declare function ref<T>(parser: Parser<T>, check: ((p: T) => boolean), expected?: string): Parser<T>;
+/** Changes the expected value for when the parser fails.
+ * @returns A parser returning the same but with a different expected value.
+ */
+export declare function expect<T>(parser: Parser<T>, expected: string): Parser<T>;
+/** Changes the expected value for when the parser fails. Erases the previous history.
+ * @returns A parser returning the same but with a different expected value.
+ */
+export declare function expectErase<T>(parser: Parser<T>, expected: string): Parser<T>;
+/**
+ * Marks a parser as a branch that has to be executed to the end by the {@link any} parser
+ */
+export declare function surely<T>(parser: Parser<T>): Parser<T>;
+/**
+ * Wraps the value returned by the parser with the token information (the start and end index in the text)
+ * @returns A parser returning the value wrapped in token information.
+ */
+export declare function token<T>(parser: Parser<T>): Parser<Token<T>>;
+/**
+ * Checks whether the parser parses successfully, but doesn't move the cursor forward
+ */
+export declare function lookaround<T>(parser: Parser<T>): Parser<void>;

package/dist/parsers/utilities.js

@@ -0,0 +1,96 @@
+"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;
+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.
+ */
+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'}`]);
+        }
+        return res;
+    };
+}
+/** Changes the expected value for when the parser fails.
+ * @returns A parser returning the same but with a different expected value.
+ */
+function expect(parser, expected) {
+    return (ctx) => {
+        const res = parser(ctx);
+        if ((0, types_1.isFailure)(res)) {
+            return (0, types_1.failure)(res.ctx, expected, [expected, ...res.history]);
+        }
+        return res;
+    };
+}
+/** Changes the expected value for when the parser fails. Erases the previous history.
+ * @returns A parser returning the same but with a different expected value.
+ */
+function expectErase(parser, expected) {
+    return (ctx) => {
+        const res = parser(ctx);
+        if ((0, types_1.isFailure)(res)) {
+            return (0, types_1.failure)(res.ctx, expected, [expected]);
+        }
+        return res;
+    };
+}
+/**
+ * Marks a parser as a branch that has to be executed to the end by the {@link any} parser
+ */
+function surely(parser) {
+    return expect(parser, 'surely');
+}
+/**
+ * Wraps the value returned by the parser with the token information (the start and end index in the text)
+ * @returns A parser returning the value wrapped in token information.
+ */
+function token(parser) {
+    return (ctx) => {
+        const result = parser(ctx);
+        if (result.success) {
+            return {
+                ...result,
+                value: {
+                    value: result.value,
+                    start: ctx.index,
+                    end: result.ctx.index
+                }
+            };
+        }
+        return result;
+    };
+}
+/**
+ * Checks whether the parser parses successfully, but doesn't move the cursor forward
+ */
+function lookaround(parser) {
+    return (ctx) => {
+        const result = parser(ctx);
+        if (result.success) {
+            return (0, types_1.success)(ctx, void 0);
+        }
+        return (0, types_1.failure)(ctx, result.expected, ['lookaround', ...result.history]);
+    };
+}