@elyukai/utils 0.2.8 → 0.3.0

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 All notable changes to this project will be documented in this file. See [commit-and-tag-version](https://github.com/absolute-version/commit-and-tag-version) for commit guidelines.
 
+## [0.3.0](https://github.com/elyukai/ts-utils/compare/v0.2.9...v0.3.0) (2026-03-06)
+
+
+### ⚠ BREAKING CHANGES
+
+* intersperse as old intercalate
+* add array intercalate and rename module
+
+### Features
+
+* add array intercalate and rename module ([2495638](https://github.com/elyukai/ts-utils/commit/24956389cb0fe6e867a985ab760d295cced4ba6b))
+* intersperse as old intercalate ([2d39540](https://github.com/elyukai/ts-utils/commit/2d39540f502415f7db4d5e9227aaab4802e16148))
+
+## [0.2.9](https://github.com/elyukai/ts-utils/compare/v0.2.8...v0.2.9) (2026-03-02)
+
+
+### Features
+
+* add simple parser combinator class ([33ead55](https://github.com/elyukai/ts-utils/commit/33ead55758fb5cb8dc20de2d53a69f1973ec3c3e))
+* extend parser, add state and combine both ([dd9a3f6](https://github.com/elyukai/ts-utils/commit/dd9a3f680c2b80658aff19103ecbfa3a4d81bdaf))
+
+
+### Bug Fixes
+
+* slow type ([e8d6fb6](https://github.com/elyukai/ts-utils/commit/e8d6fb63e79937a01b8f15441147bc2b72686e97))
+
 ## [0.2.8](https://github.com/elyukai/ts-utils/compare/v0.2.7...v0.2.8) (2026-02-24)
 
 ## [0.2.7](https://github.com/elyukai/ts-utils/compare/v0.2.6...v0.2.7) (2026-02-24)

package/dist/{array → src/array}/filters.js

@@ -11,17 +11,17 @@ export const unique = (arr) => Array.from(new Set(arr));
 /**
  * Checks if there are any duplicate elements in the array.
  */
-export const anySame = (arr, equalityCheck = (a, b) => a === b) => arr.some((item, index) => arr.findIndex((other) => equalityCheck(item, other)) !== index);
+export const anySame = (arr, equalityCheck = (a, b) => a === b) => arr.some((item, index) => arr.findIndex(other => equalityCheck(item, other)) !== index);
 /**
  * Checks if there are any duplicate elements in the array and returns an array
  * of found duplicates where the values are the indices of these values.
  */
 export const anySameIndices = (arr, equalityCheck = (a, b) => a === b) => arr.reduce((acc, item, index) => {
-    const firstIndex = arr.findIndex((other) => equalityCheck(item, other));
+    const firstIndex = arr.findIndex(other => equalityCheck(item, other));
     if (firstIndex === index) {
         return acc;
     }
-    const accIndex = acc.findIndex((accElem) => accElem[0] === firstIndex);
+    const accIndex = acc.findIndex(accElem => accElem[0] === firstIndex);
     return accIndex === -1
         ? [...acc, [firstIndex, index]]
         : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- The index must exist according to the findIndex above
@@ -34,4 +34,4 @@ export const anySameIndices = (arr, equalityCheck = (a, b) => a === b) => arr.re
  * @param equalityCheck An optional function to determine if two elements are considered the same. Defaults to strict shallow equality.
  * @returns `true` if all elements in the array are the same, otherwise `false`.
  */
-export const allSame = (arr, equalityCheck = (a, b) => a === b) => isNotEmpty(arr) ? arr.every((item) => equalityCheck(item, arr[0])) : true;
+export const allSame = (arr, equalityCheck = (a, b) => a === b) => (isNotEmpty(arr) ? arr.every(item => equalityCheck(item, arr[0])) : true);

package/dist/{array → src/array}/reductions.js

@@ -50,7 +50,7 @@ export const countBy = (arr, fn) => arr.reduce((acc, value, index) => {
  */
 export const countByMany = (arr, fn) => arr.reduce((acc, value, index) => {
     const keys = fn(value, index);
-    unique(keys).forEach((key) => {
+    unique(keys).forEach(key => {
         acc[key] = (acc[key] ?? 0) + 1;
     });
     return acc;
@@ -59,4 +59,4 @@ export const countByMany = (arr, fn) => arr.reduce((acc, value, index) => {
  * Returns `true` if the array contains at least `minCount` elements that
  * satisfy the given predicate, `false` otherwise.
  */
-export const someCount = (arr, predicate, minCount) => reduceWhile(arr, (acc, value) => (predicate(value) ? acc + 1 : acc), (acc) => acc >= minCount, 0) >= minCount;
+export const someCount = (arr, predicate, minCount) => reduceWhile(arr, (acc, value) => (predicate(value) ? acc + 1 : acc), acc => acc >= minCount, 0) >= minCount;

package/dist/src/array/transformations.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Utility functions for transforming arrays.
+ * @module
+ */
+/**
+ * Returns a new array with the given value interspersed between each element of the given array. An empty array is returned if the given array is empty.
+ * @param arr The array to intersperse.
+ * @param value The value to intersperse between each element of the array.
+ * @returns A new array with the given value interspersed between each element of the given array.
+ */
+export declare const intersperse: <T>(arr: T[], value: T) => T[];
+/**
+ * Returns a new array with the given values intercalated between each element of the given array. An empty array is returned if the given array is empty.
+ * @param arr The array to intercalate.
+ * @param values The values to intercalate between each element of the array.
+ * @returns A new array with the given values intercalated between each element of the given array.
+ */
+export declare const intercalate: <T>(arr: T[][], values: T[]) => T[];
+/**
+ * Returns the possibilities of all the combinations of nested array values.
+ *
+ * @example
+ *
+ * flatCombine([["a", "b"], ["c"]]) // [["a", "c"], ["b", "c"]]
+ * flatCombine([["a", "b"], ["c", "d"]]) // [["a", "c"], ["b", "c"], ["a", "d"], ["b", "d"]]
+ */
+export declare const flatCombine: <T>(arr: T[][]) => T[][];

package/dist/src/array/transformations.js

@@ -0,0 +1,34 @@
+/**
+ * Utility functions for transforming arrays.
+ * @module
+ */
+import { isNotEmpty } from "./nonEmpty.js";
+/**
+ * Returns a new array with the given value interspersed between each element of the given array. An empty array is returned if the given array is empty.
+ * @param arr The array to intersperse.
+ * @param value The value to intersperse between each element of the array.
+ * @returns A new array with the given value interspersed between each element of the given array.
+ */
+export const intersperse = (arr, value) => !isNotEmpty(arr) ? [] : arr.slice(1).reduce((acc, elem) => [...acc, value, elem], [arr[0]]);
+/**
+ * Returns a new array with the given values intercalated between each element of the given array. An empty array is returned if the given array is empty.
+ * @param arr The array to intercalate.
+ * @param values The values to intercalate between each element of the array.
+ * @returns A new array with the given values intercalated between each element of the given array.
+ */
+export const intercalate = (arr, values) => !isNotEmpty(arr)
+    ? []
+    : arr.slice(1).reduce((acc, elem) => [...acc, ...values, ...elem], arr[0]);
+/**
+ * Returns the possibilities of all the combinations of nested array values.
+ *
+ * @example
+ *
+ * flatCombine([["a", "b"], ["c"]]) // [["a", "c"], ["b", "c"]]
+ * flatCombine([["a", "b"], ["c", "d"]]) // [["a", "c"], ["b", "c"], ["a", "d"], ["b", "d"]]
+ */
+export const flatCombine = (arr) => arr.length === 0
+    ? []
+    : arr.slice(1).reduce((acc, elem) => elem.flatMap(elemInner => acc.map(accElem => [...accElem, elemInner])), 
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- it is checked before if the array is empty
+    arr[0].map(elem => [elem]));

package/dist/{async.js → src/async.js}

@@ -12,7 +12,7 @@
  * await wait(1000); // Waits for 1 second
  * ```
  */
-export const wait = (delay) => new Promise((resolve) => setTimeout(resolve, delay));
+export const wait = (delay) => new Promise(resolve => setTimeout(resolve, delay));
 /**
  * A simple async map to process tasks with a concurrency limit.
  * @param tasks The list of tasks to process.
@@ -36,7 +36,7 @@ export const mapAsync = (tasks, worker, concurrency) => new Promise((resolve, re
                 const task = tasks[currentIndex];
                 activeCount++;
                 worker(task)
-                    .then((result) => {
+                    .then(result => {
                     results[currentIndex] = result;
                     resolvedCount++;
                     activeCount--;

package/dist/{classList.js → src/classList.js}

@@ -7,7 +7,7 @@
  * nullable values and keys with falsey values.
  */
 export const classList = (...cls) => cls
-    .flatMap((cl) => {
+    .flatMap(cl => {
     if (cl === null || cl === undefined) {
         return [];
     }

package/dist/{equality.js → src/equality.js}

@@ -31,8 +31,7 @@ export const notEqual = (a, b) => !Object.is(a, b);
  *
  * Use {@link deepEqual} for a deep equality check.
  */
-export const arrayEqual = (arr1, arr2) => arr1.length === arr2.length &&
-    arr1.every((value, index) => equal(value, arr2[index]));
+export const arrayEqual = (arr1, arr2) => arr1.length === arr2.length && arr1.every((value, index) => equal(value, arr2[index]));
 /**
  * Checks two values for value equality. This is a deep equality check that
  * works for all types, including objects and arrays. For objects, it only
@@ -42,16 +41,12 @@ export const deepEqual = (a, b) => {
     if (equal(a, b)) {
         return true;
     }
-    if (typeof a === "object" &&
-        typeof b === "object" &&
-        a !== null &&
-        b !== null) {
+    if (typeof a === "object" && typeof b === "object" && a !== null && b !== null) {
         const keys = Object.keys(a);
         if (keys.length !== Object.keys(b).length) {
             return false;
         }
-        return keys.every((key) => key in b &&
-            deepEqual(a[key], b[key]));
+        return keys.every(key => key in b && deepEqual(a[key], b[key]));
     }
     return false;
 };

package/dist/{function.js → src/function.js}

@@ -16,12 +16,12 @@ export const constant = (value) => () => value;
  * Returns a function that applies the given predicates to the given value and
  * returns `true` if all predicates return `true`.
  */
-export const andEvery = (...predicates) => (value) => predicates.every((predicate) => predicate(value));
+export const andEvery = (...predicates) => (value) => predicates.every(predicate => predicate(value));
 /**
  * Returns a function that combines predicate functions disjunctionally.
  */
 export function orSome(...predicates) {
-    return (value) => predicates.some((predicate) => predicate(value));
+    return value => predicates.some(predicate => predicate(value));
 }
 /**
  * Returns a function that applies the given predicate to the given value and

package/dist/{maybe.js → src/maybe.js}

@@ -33,12 +33,10 @@ export const map = (maybe, f) => isJust(maybe) ? Just(f(maybe.value)) : Nothing;
 /**
  * Chains a result to a new result.
  */
-export const then = (maybe, f) => (isJust(maybe) ? f(maybe.value) : maybe);
+export const then = (maybe, f) => isJust(maybe) ? f(maybe.value) : maybe;
 /**
  * Combines two maybes into one maybe. If both maybes contain a value, the
  * values are combined using the provided function. If at least one maybe
  * contains nothing, nothing is returned.
  */
-export const combine = (maybe1, maybe2, f) => isJust(maybe1) && isJust(maybe2)
-    ? Just(f(maybe1.value, maybe2.value))
-    : Nothing;
+export const combine = (maybe1, maybe2, f) => (isJust(maybe1) && isJust(maybe2) ? Just(f(maybe1.value, maybe2.value)) : Nothing);

package/dist/{nullable.js → src/nullable.js}

@@ -13,7 +13,7 @@ export const isNotNullish = (value) => !isNullish(value);
 /**
  * Maps a value to another value if it is not `null` or `undefined`.
  */
-export const mapNullable = (value, map) => (isNotNullish(value) ? map(value) : value);
+export const mapNullable = (value, map) => isNotNullish(value) ? map(value) : value;
 /**
  * Maps a value to another value if it is not `null` or `undefined`, otherwise
  * returns a default value.

package/dist/{object.js → src/object.js}

@@ -24,7 +24,7 @@ export const mapObject = (object, map) => {
  * Keys not present in the keys array will be placed at the end in their original order.
  */
 export const sortObjectKeysByIndex = (obj, keys) => Object.fromEntries([
-    ...keys.flatMap((key) => obj[key] === undefined ? [] : [[key, obj[key]]]),
+    ...keys.flatMap(key => (obj[key] === undefined ? [] : [[key, obj[key]]])),
     ...Object.entries(obj).filter(([key]) => !keys.includes(key)),
 ]);
 /**

package/dist/src/parser.d.ts

@@ -0,0 +1,146 @@
+/**
+ * A simple parser combinator.
+ * @module
+ */
+/**
+ * The type `ParserResult<T>` represents the result of parsing a string using a parser. It is an array of tuples, where each tuple contains a parsed element of type T and the remaining unparsed string. If the parser fails to parse the input according to the defined rules, it returns an empty array.
+ */
+export type ParserResult<T> = [parsed: T, remaining: string][];
+/**
+ * A class that serves as a parser combinator, allowing you to build complex parsers by combining simpler ones. The parser takes a string input and produces an array of tuples, where each tuple contains a parsed element of type T and the remaining unparsed string. If the parser fails to parse the input according to the defined rules, it returns an empty array.
+ */
+export declare class Parser<T> {
+    #private;
+    /**
+     * Returns a parser that applies the given function to the syntax string if it is not empty.
+     */
+    constructor(fn: (syntax: string) => ParserResult<T>);
+    /**
+     * Parses a single character.
+     */
+    static item: Parser<string>;
+    /**
+     * Returns a parser that always succeeds with the given element, without consuming any input.
+     */
+    static of<T>(element: T): Parser<T>;
+    /**
+     * Transforms the result of this parser using the given function, without consuming any additional input.
+     */
+    map<U>(f: (result: T) => U): Parser<U>;
+    /**
+     * Chains this parser with another parser that depends on the result of this parser.
+     */
+    then<U>(f: (result: T) => Parser<U>): Parser<U>;
+    /**
+     * A parser that always fails.
+     */
+    static zero: Parser<never>;
+    /**
+     * Combines this parser with another parser, trying this parser first and then the other parser.
+     */
+    or(other: Parser<T>): Parser<T>;
+    /**
+     * Combines this parser with another parser, trying this parser first and then the other parser only if the first parser fails. It only returns the first successful result.
+     */
+    orFirst(other: Parser<T>): Parser<T>;
+    /**
+     * Combines this parser with another parser, trying this parser first and then the other parser only if the first parser fails. It only returns the first successful result.
+     *
+     * The suffix ‘W’ stands for ‘widening’, as this method allows you to combine parsers with different result types.
+     */
+    orFirstW<U>(other: Parser<U>): Parser<T | U>;
+    /**
+     * Returns a parser that tries this parser and returns its result if it succeeds, but if this parser fails, it returns a parser that always succeeds with `undefined` without consuming any input.
+     */
+    optional(): Parser<T | undefined>;
+    /**
+     * Returns a parser that parses a character that satisfies the given predicate function.
+     */
+    static satisfy<C extends string>(predicate: (character: string) => character is C): Parser<C>;
+    static satisfy(predicate: (character: string) => boolean): Parser<string>;
+    /**
+     * Returns a parser that parses a specific string.
+     */
+    static string<T extends string>(string: T): Parser<T>;
+    /**
+     * Returns a parser that parses zero or more occurrences of this parser, returning an array of the parsed results.
+     */
+    many(): Parser<T[]>;
+    /**
+     * Returns a parser that parses one or more occurrences of this parser, returning an array of the parsed results.
+     *
+     * It fails if this parser does not succeed at least once.
+     */
+    many1(): Parser<T[]>;
+    /**
+     * Returns a parser that parses zero or more occurrences of this parser, separated by another parser, returning an array of the parsed results.
+     */
+    separatedBy(separator: Parser<unknown>): Parser<T[]>;
+    /**
+     * Returns a parser that parses one or more occurrences of this parser, separated by another parser, returning an array of the parsed results.
+     *
+     * It fails if this parser does not succeed at least once.
+     */
+    separatedBy1(separator: Parser<unknown>): Parser<T[]>;
+    /**
+     * Returns a parser that parses a string that matches the given regular expression pattern.
+     *
+     * The pattern must match at the beginning of the string (patterns that are designed like this might perform better), and the parser will return the matched substring as the parsed result.
+     */
+    static regex(pattern: RegExp): Parser<string>;
+    /**
+     * A parser that parses whitepace characters.
+     */
+    static space: Parser<string>;
+    /**
+     * A parser that parses horizontal whitepace characters.
+     *
+     * This can be useful for parsing a language where newlines are significant.
+     */
+    static hspace: Parser<string>;
+    /**
+     * Throws away trailing whitespace characters before applying the given parser.
+     */
+    token(): Parser<T>;
+    /**
+     * Throws away trailing horizontal whitespace characters before applying the given parser.
+     *
+     * This can be useful for parsing a language where newlines are significant.
+     */
+    htoken(): Parser<T>;
+    /**
+     * Returns a parser that parses a specific string, ignoring trailing whitespace characters.
+     */
+    static symb<T extends string>(symbol: T): Parser<T>;
+    /**
+     * Returns a parser that parses a specific string, ignoring trailing horizontal whitespace characters.
+     *
+     * This can be useful for parsing a language where newlines are significant.
+     */
+    static hsymb<T extends string>(symbol: T): Parser<T>;
+    /**
+     * Creates a parser that parses a value using the given parser, surrounded by the given left and right parsers, and returns the parsed value.
+     */
+    between<L, R>(left: Parser<L>, right: Parser<R>): Parser<T>;
+    /**
+     * Returns a parser that applies the given parser to the input string without consuming any input, returning the result of the parser if it succeeds. If the parser fails, this lookahead parser also fails.
+     */
+    static lookahead<T>(parser: Parser<T>): Parser<T>;
+    /**
+     * Returns a parser that applies the given parser to the input string without consuming any input, returning `undefined` if it fails. If the parser succeeds, this fails instead.
+     */
+    static negativeLookahead(parser: Parser<unknown>): Parser<undefined>;
+    /**
+     * Runs the parser on the given syntax string, ignoring any leading whitespace.
+     *
+     * A complete parse is one where the remaining unparsed string is empty. However, this method does not enforce that, and it will return all possible parses, including those that do not consume the entire input.
+     */
+    apply(syntax: string): ParserResult<T>;
+    /**
+     * Runs the parser on the given syntax string.
+     *
+     * A complete parse is one where the remaining unparsed string is empty. However, this method does not enforce that, and it will return all possible parses, including those that do not consume the entire input.
+     */
+    parse(syntax: string): ParserResult<T>;
+    static debugLog<T>(parser: Parser<T>): Parser<T>;
+}

package/dist/src/parser.js

@@ -0,0 +1,219 @@
+/**
+ * A simple parser combinator.
+ * @module
+ */
+/**
+ * A class that serves as a parser combinator, allowing you to build complex parsers by combining simpler ones. The parser takes a string input and produces an array of tuples, where each tuple contains a parsed element of type T and the remaining unparsed string. If the parser fails to parse the input according to the defined rules, it returns an empty array.
+ */
+export class Parser {
+    /**
+     * The function takes a syntax string and returns an array of tuples, where each tuple contains a parsed element of type T and the remaining unparsed string. An empty array is returned if the syntax string cannot be parsed according to the defined rules.
+     */
+    #fn;
+    /**
+     * Returns a parser that applies the given function to the syntax string if it is not empty.
+     */
+    constructor(fn) {
+        this.#fn = fn;
+    }
+    /**
+     * Parses a single character.
+     */
+    static item = new Parser(syntax => 
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- we check for empty string before accessing the first character
+    syntax.length === 0 ? [] : [[syntax[0], syntax.slice(1)]]);
+    /**
+     * Returns a parser that always succeeds with the given element, without consuming any input.
+     */
+    static of(element) {
+        return new Parser(syntax => [[element, syntax]]);
+    }
+    /**
+     * Transforms the result of this parser using the given function, without consuming any additional input.
+     */
+    map(f) {
+        return new Parser(syntax => this.#fn(syntax).map(([result, remaining]) => [f(result), remaining]));
+    }
+    /**
+     * Chains this parser with another parser that depends on the result of this parser.
+     */
+    then(f) {
+        return new Parser(syntax => this.#fn(syntax).flatMap(([result, remaining]) => f(result).#fn(remaining)));
+    }
+    /**
+     * A parser that always fails.
+     */
+    static zero = new Parser(() => []);
+    /**
+     * Combines this parser with another parser, trying this parser first and then the other parser.
+     */
+    or(other) {
+        return new Parser(syntax => [...this.#fn(syntax), ...other.#fn(syntax)]);
+    }
+    /**
+     * Combines this parser with another parser, trying this parser first and then the other parser only if the first parser fails. It only returns the first successful result.
+     */
+    orFirst(other) {
+        return new Parser(syntax => {
+            const result = this.#fn(syntax);
+            return result.length > 0 ? result.slice(0, 1) : other.#fn(syntax).slice(0, 1);
+        });
+    }
+    /**
+     * Combines this parser with another parser, trying this parser first and then the other parser only if the first parser fails. It only returns the first successful result.
+     *
+     * The suffix ‘W’ stands for ‘widening’, as this method allows you to combine parsers with different result types.
+     */
+    orFirstW(other) {
+        return new Parser((syntax) => {
+            const result = this.#fn(syntax);
+            return result.length > 0 ? result.slice(0, 1) : other.#fn(syntax).slice(0, 1);
+        });
+    }
+    /**
+     * Returns a parser that tries this parser and returns its result if it succeeds, but if this parser fails, it returns a parser that always succeeds with `undefined` without consuming any input.
+     */
+    optional() {
+        return this.orFirstW(Parser.of(undefined));
+    }
+    static satisfy(predicate) {
+        return Parser.item.then(char => (predicate(char) ? Parser.of(char) : Parser.zero));
+    }
+    /**
+     * Returns a parser that parses a specific string.
+     */
+    static string(string) {
+        return new Parser(syntax => syntax.startsWith(string)
+            ? [[syntax.slice(0, string.length), syntax.slice(string.length)]]
+            : []);
+    }
+    /**
+     * Returns a parser that parses zero or more occurrences of this parser, returning an array of the parsed results.
+     */
+    many() {
+        return this.many1().orFirst(Parser.of([]));
+    }
+    /**
+     * Returns a parser that parses one or more occurrences of this parser, returning an array of the parsed results.
+     *
+     * It fails if this parser does not succeed at least once.
+     */
+    many1() {
+        return this.then(result => this.many().then(results => Parser.of([result, ...results])));
+    }
+    /**
+     * Returns a parser that parses zero or more occurrences of this parser, separated by another parser, returning an array of the parsed results.
+     */
+    separatedBy(separator) {
+        return this.separatedBy1(separator).orFirst(Parser.of([]));
+    }
+    /**
+     * Returns a parser that parses one or more occurrences of this parser, separated by another parser, returning an array of the parsed results.
+     *
+     * It fails if this parser does not succeed at least once.
+     */
+    separatedBy1(separator) {
+        return this.then(result => separator
+            .then(() => this)
+            .many()
+            .then(results => Parser.of([result, ...results])));
+    }
+    /**
+     * Returns a parser that parses a string that matches the given regular expression pattern.
+     *
+     * The pattern must match at the beginning of the string (patterns that are designed like this might perform better), and the parser will return the matched substring as the parsed result.
+     */
+    static regex(pattern) {
+        return new Parser(syntax => {
+            const result = pattern.exec(syntax);
+            // checks for no match and not a match at the beginning of the string at the same time
+            return result?.index !== 0 ? [] : [[result[0], syntax.slice(result[0].length)]];
+        });
+    }
+    /**
+     * A parser that parses whitepace characters.
+     */
+    static space = Parser.regex(/^\s*/);
+    /**
+     * A parser that parses horizontal whitepace characters.
+     *
+     * This can be useful for parsing a language where newlines are significant.
+     */
+    static hspace = Parser.regex(/^[^\S\r\n]*/);
+    /**
+     * Throws away trailing whitespace characters before applying the given parser.
+     */
+    token() {
+        return this.then(result => Parser.space.then(() => Parser.of(result)));
+    }
+    /**
+     * Throws away trailing horizontal whitespace characters before applying the given parser.
+     *
+     * This can be useful for parsing a language where newlines are significant.
+     */
+    htoken() {
+        return this.then(result => Parser.hspace.then(() => Parser.of(result)));
+    }
+    /**
+     * Returns a parser that parses a specific string, ignoring trailing whitespace characters.
+     */
+    static symb(symbol) {
+        return Parser.string(symbol).token();
+    }
+    /**
+     * Returns a parser that parses a specific string, ignoring trailing horizontal whitespace characters.
+     *
+     * This can be useful for parsing a language where newlines are significant.
+     */
+    static hsymb(symbol) {
+        return Parser.string(symbol).htoken();
+    }
+    /**
+     * Creates a parser that parses a value using the given parser, surrounded by the given left and right parsers, and returns the parsed value.
+     */
+    between(left, right) {
+        return left.then(() => this).then(result => right.then(() => Parser.of(result)));
+    }
+    /**
+     * Returns a parser that applies the given parser to the input string without consuming any input, returning the result of the parser if it succeeds. If the parser fails, this lookahead parser also fails.
+     */
+    static lookahead(parser) {
+        return new Parser(syntax => {
+            const result = parser.parse(syntax)[0];
+            return result !== undefined ? [[result[0], syntax]] : [];
+        });
+    }
+    /**
+     * Returns a parser that applies the given parser to the input string without consuming any input, returning `undefined` if it fails. If the parser succeeds, this fails instead.
+     */
+    static negativeLookahead(parser) {
+        return new Parser(syntax => {
+            const result = parser.parse(syntax)[0];
+            return result === undefined ? [[undefined, syntax]] : [];
+        });
+    }
+    /**
+     * Runs the parser on the given syntax string, ignoring any leading whitespace.
+     *
+     * A complete parse is one where the remaining unparsed string is empty. However, this method does not enforce that, and it will return all possible parses, including those that do not consume the entire input.
+     */
+    apply(syntax) {
+        return Parser.space.then(() => this).parse(syntax);
+    }
+    /**
+     * Runs the parser on the given syntax string.
+     *
+     * A complete parse is one where the remaining unparsed string is empty. However, this method does not enforce that, and it will return all possible parses, including those that do not consume the entire input.
+     */
+    parse(syntax) {
+        return this.#fn(syntax);
+    }
+    static debugLog(parser) {
+        return new Parser(syntax => {
+            console.log("Parsing:", syntax);
+            const results = parser.parse(syntax);
+            console.log(results);
+            return results;
+        });
+    }
+}