@elyukai/utils 0.2.8 → 0.2.9

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 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.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/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/generators.js

@@ -12,6 +12,6 @@
  */
 export const flatCombine = (arr) => arr.length === 0
     ? []
-    : arr.slice(1).reduce((acc, elem) => elem.flatMap((elemInner) => acc.map((accElem) => [...accElem, elemInner])), 
+    : 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]));
+    arr[0].map(elem => [elem]));

package/dist/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/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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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/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/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;
+        });
+    }
+}

package/dist/reader.js

@@ -24,31 +24,31 @@ export class Reader {
      * Retrieve the entire environment.
      */
     static ask() {
-        return new Reader((env) => env);
+        return new Reader(env => env);
     }
     /**
      * Retrieve a transformed value of the environment.
      */
     static asks(f) {
-        return new Reader((env) => f(env));
+        return new Reader(env => f(env));
     }
     /**
      * Applies the given function to the value produced by this Reader and returns a new Reader that produces the result.
      */
     map(f) {
-        return new Reader((env) => f(this.#fn(env)));
+        return new Reader(env => f(this.#fn(env)));
     }
     /**
      * Combines this Reader with another Reader by applying a function to both of their results and returning a new Reader that produces the result.
      */
     map2(other, f) {
-        return new Reader((env) => f(this.#fn(env), other.#fn(env)));
+        return new Reader(env => f(this.#fn(env), other.#fn(env)));
     }
     /**
      * Applies the given function to the value produced by this Reader and returns a new Reader that produces the result. The function must return a Reader, which allows you to chain computations that depend on the same environment.
      */
     then(f) {
-        return new Reader((env) => f(this.#fn(env)).#fn(env));
+        return new Reader(env => f(this.#fn(env)).#fn(env));
     }
     /**
      * Applies the given function to the value produced by this Reader and returns a new Reader that produces the result. The function must return a Reader, which allows you to chain computations that depend on a shared environment. The environments do not have to be the same, but will need to be combined.
@@ -56,7 +56,7 @@ export class Reader {
      * The suffix ‘W’ stands for ‘widening’, as this method allows you to widen the environment that the Reader depends on.
      */
     thenW(f) {
-        return new Reader((env) => f(this.#fn(env)).#fn(env));
+        return new Reader(env => f(this.#fn(env)).#fn(env));
     }
     /**
      * Modifies the environment for this Reader by applying the given function to it before running the computation.
@@ -64,7 +64,7 @@ export class Reader {
      * This allows you to adapt the environment for a specific computation without changing the original Reader.
      */
     with(modifyEnv) {
-        return new Reader((env) => this.#fn(modifyEnv(env)));
+        return new Reader(env => this.#fn(modifyEnv(env)));
     }
     /**
      * Computes the result by providing the required environment.
@@ -76,7 +76,7 @@ export class Reader {
      * Apply a function to each value in the array, and return a Reader that produces an array of the results.
      */
     static traverse(values, fn) {
-        return new Reader((env) => values.map((value) => fn(value).run(env)));
+        return new Reader(env => values.map(value => fn(value).run(env)));
     }
     /**
      * Evaluate each reader in the array, and collect the results in a single reader instance.
@@ -90,7 +90,7 @@ export class Reader {
      * This makes functions producing Readers that depend on more arguments sometimes easier to work with.
      */
     static defer(fn) {
-        return new Reader((env) => (...args) => fn(...args).run(env));
+        return new Reader(env => (...args) => fn(...args).run(env));
     }
     /**
      * Transforms a Reader that produces a function into a function that returns a Reader.
@@ -98,7 +98,7 @@ export class Reader {
      * This is the inverse of {@link defer}.
      */
     static undefer(reader) {
-        return (...args) => new Reader((env) => reader.run(env)(...args));
+        return (...args) => new Reader(env => reader.run(env)(...args));
     }
 }
 // type Readable<T> =

package/dist/result.js

@@ -28,15 +28,15 @@ export const reduce = (result, fok, ferror) => (isOk(result) ? fok(result.value)
 /**
  * Maps the value of a result to a new value.
  */
-export const map = (result, f) => (isOk(result) ? ok(f(result.value)) : result);
+export const map = (result, f) => isOk(result) ? ok(f(result.value)) : result;
 /**
  * Maps an error to a new error.
  */
-export const mapError = (result, f) => (isError(result) ? error(f(result.error)) : result);
+export const mapError = (result, f) => isError(result) ? error(f(result.error)) : result;
 /**
  * Chains a result to a new result.
  */
-export const then = (result, f) => (isOk(result) ? f(result.value) : result);
+export const then = (result, f) => isOk(result) ? f(result.value) : result;
 /**
  * Combines two results into one.
  *

package/dist/state.d.ts

@@ -0,0 +1,51 @@
+/**
+ * The {@link State} class representing a state transformation function and includes methods to chain functions effectively.
+ * @module
+ */
+/**
+ * A class representing a state transformation function that takes an initial state and returns a tuple containing a value and a new state.
+ */
+export declare class State<S, T> {
+    #private;
+    private constructor();
+    /**
+     * Returns a new {@link State} instance that returns the state as the resulting value without modifying the state.
+     */
+    static get<S>(): State<S, S>;
+    /**
+     * Applies the state transformation function to the given state and returns a tuple containing the resulting value and the new state.
+     */
+    run(state: S): [T, S];
+    /**
+     * Applies the state transformation function to the given state and returns the resulting value, discarding the new state.
+     */
+    eval(state: S): T;
+    /**
+     * Applies the state transformation function to the given state and returns the new state, discarding the resulting value.
+     */
+    exec(state: S): S;
+    /**
+     * Returns a new {@link State} instance that returns the given value without modifying the state.
+     */
+    static of<S, T>(value: T): State<S, T>;
+    /**
+     * Transforms the value produced by this state transformation function using the given function, while keeping the state unchanged.
+     */
+    map<U>(f: (value: T) => U): State<S, U>;
+    /**
+     * Transforms the value and state produced by this state transformation function using the given function.
+     */
+    mapBoth<U>(f: (result: [T, S]) => [U, S]): State<S, U>;
+    /**
+     * Chains this state transformation function with another function that takes the value produced by this function and returns a new {@link State} instance, allowing for sequential state transformations.
+     */
+    then<U>(f: (value: T) => State<S, U>): State<S, U>;
+    /**
+     * Returns a new {@link State} instance that applies the given function to the state and returns the resulting value without modifying the state.
+     */
+    static gets<S, T>(f: (state: S) => T): State<S, T>;
+    /**
+     * Modifies the state using the given function before applying this state transformation function.
+     */
+    with(f: (state: S) => S): State<S, T>;
+}

package/dist/state.js

@@ -0,0 +1,79 @@
+/**
+ * The {@link State} class representing a state transformation function and includes methods to chain functions effectively.
+ * @module
+ */
+/**
+ * A class representing a state transformation function that takes an initial state and returns a tuple containing a value and a new state.
+ */
+export class State {
+    #fn;
+    constructor(fn) {
+        this.#fn = fn;
+    }
+    /**
+     * Returns a new {@link State} instance that returns the state as the resulting value without modifying the state.
+     */
+    static get() {
+        return new State(state => [state, state]);
+    }
+    /**
+     * Applies the state transformation function to the given state and returns a tuple containing the resulting value and the new state.
+     */
+    run(state) {
+        return this.#fn(state);
+    }
+    /**
+     * Applies the state transformation function to the given state and returns the resulting value, discarding the new state.
+     */
+    eval(state) {
+        return this.run(state)[0];
+    }
+    /**
+     * Applies the state transformation function to the given state and returns the new state, discarding the resulting value.
+     */
+    exec(state) {
+        return this.run(state)[1];
+    }
+    /**
+     * Returns a new {@link State} instance that returns the given value without modifying the state.
+     */
+    static of(value) {
+        return new State(state => [value, state]);
+    }
+    /**
+     * Transforms the value produced by this state transformation function using the given function, while keeping the state unchanged.
+     */
+    map(f) {
+        return new State(state => {
+            const [value, newState] = this.run(state);
+            return [f(value), newState];
+        });
+    }
+    /**
+     * Transforms the value and state produced by this state transformation function using the given function.
+     */
+    mapBoth(f) {
+        return new State(state => f(this.run(state)));
+    }
+    /**
+     * Chains this state transformation function with another function that takes the value produced by this function and returns a new {@link State} instance, allowing for sequential state transformations.
+     */
+    then(f) {
+        return new State(state => {
+            const [value, newState] = this.run(state);
+            return f(value).run(newState);
+        });
+    }
+    /**
+     * Returns a new {@link State} instance that applies the given function to the state and returns the resulting value without modifying the state.
+     */
+    static gets(f) {
+        return new State(state => [f(state), state]);
+    }
+    /**
+     * Modifies the state using the given function before applying this state transformation function.
+     */
+    with(f) {
+        return new State(state => this.run(f(state)));
+    }
+}

package/dist/stateParser.d.ts

@@ -0,0 +1,143 @@
+/**
+ * A simple stateful parser combinator.
+ * @module
+ */
+import { Parser } from "./parser.js";
+/**
+ * A class that combines the functionality of a parser with a state transformation function, allowing for more complex parsing scenarios where the parser can also manipulate some state during the parsing process.
+ */
+export declare class StateTParser<S, T> {
+    #private;
+    private constructor();
+    /**
+     * Returns a new {@link StateTParser} instance that always succeeds with the given value while not modifying the state.
+     */
+    static of<S, T>(value: T): StateTParser<S, T>;
+    /**
+     * Chains the state transformation function and the parser with a function that takes the produced value and reutns a new {@link StateTParser} instance, allowing for sequential state transformations and parsing operations.
+     */
+    then<U>(f: (result: T) => StateTParser<S, U>): StateTParser<S, U>;
+    /**
+     * Wraps a parser into a {@link StateTParser}, allowing the parser to be used in the context of state transformations.
+     */
+    static lift<S, T>(parser: Parser<T>): StateTParser<S, T>;
+    /**
+     * Applies the state transformation function to the given state and returns a tuple containing the resulting value and the new state.
+     */
+    runT(state: S): Parser<[T, S]>;
+    /**
+     * Applies the state transformation function to the given state and returns the resulting value, discarding the new state.
+     */
+    evalT(state: S): Parser<T>;
+    /**
+     * Applies the state transformation function to the given state and returns the new state, discarding the resulting value.
+     */
+    execT(state: S): Parser<S>;
+    /**
+     * Transforms the produced value using the given function, while keeping the state unchanged and not consuming any additional input.
+     */
+    map<U>(f: (value: T) => U): StateTParser<S, U>;
+    /**
+     * Transforms the value and state produced by this state transformation function using the given function.
+     */
+    mapT<U>(f: (result: Parser<[T, S]>) => Parser<[U, S]>): StateTParser<S, U>;
+    /**
+     * Returns a new {@link StateTParser} instance that returns the state as the resulting value without modifying the state.
+     */
+    static getT<S>(): StateTParser<S, S>;
+    /**
+     * Returns a new {@link StateTParser} instance that applies the given function to the state and returns the resulting value without modifying the state.
+     */
+    static getsT<S, T>(f: (state: S) => T): StateTParser<S, T>;
+    /**
+     * Modifies the state using the given function before applying this state transformation function.
+     */
+    withT(f: (state: S) => S): StateTParser<S, 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: StateTParser<S, T>): StateTParser<S, 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: StateTParser<S, U>): StateTParser<S, 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(): StateTParser<S, T | undefined>;
+    /**
+     * Returns a parser that parses a specific string.
+     */
+    static string<S, T extends string = string>(string: T): StateTParser<S, T>;
+    /**
+     * Returns a parser that parses zero or more occurrences of this parser, returning an array of the parsed results.
+     */
+    many(): StateTParser<S, 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(): StateTParser<S, 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: StateTParser<S, unknown>): StateTParser<S, 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: StateTParser<S, unknown>): StateTParser<S, 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<S>(pattern: RegExp): StateTParser<S, string>;
+    /**
+     * A parser that parses whitepace characters.
+     */
+    static space<S>(): StateTParser<S, string>;
+    /**
+     * A parser that parses horizontal whitepace characters.
+     *
+     * This can be useful for parsing a language where newlines are significant.
+     */
+    static hspace<S>(): StateTParser<S, string>;
+    /**
+     * Throws away trailing whitespace characters before applying the given parser.
+     */
+    token(): StateTParser<S, 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(): StateTParser<S, T>;
+    /**
+     * Returns a parser that parses a specific string, ignoring trailing whitespace characters.
+     */
+    static symb<S, T extends string>(symbol: T): StateTParser<S, 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<S, T extends string>(symbol: T): StateTParser<S, 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: StateTParser<S, L>, right: StateTParser<S, R>): StateTParser<S, 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<S, T>(parser: StateTParser<S, T>): StateTParser<S, 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<S>(parser: StateTParser<S, unknown>): StateTParser<S, undefined>;
+    static debugLog<S, T>(stateParser: StateTParser<S, T>): StateTParser<S, T>;
+}

package/dist/stateParser.js

@@ -0,0 +1,219 @@
+/**
+ * A simple stateful parser combinator.
+ * @module
+ */
+import { Parser } from "./parser.js";
+/**
+ * A class that combines the functionality of a parser with a state transformation function, allowing for more complex parsing scenarios where the parser can also manipulate some state during the parsing process.
+ */
+export class StateTParser {
+    #fn;
+    constructor(fn) {
+        this.#fn = fn;
+    }
+    /**
+     * Returns a new {@link StateTParser} instance that always succeeds with the given value while not modifying the state.
+     */
+    static of(value) {
+        return new StateTParser(state => Parser.of([value, state]));
+    }
+    /**
+     * Chains the state transformation function and the parser with a function that takes the produced value and reutns a new {@link StateTParser} instance, allowing for sequential state transformations and parsing operations.
+     */
+    then(f) {
+        return new StateTParser(state => this.#fn(state).then(([result, newState]) => f(result).#fn(newState)));
+    }
+    /**
+     * Wraps a parser into a {@link StateTParser}, allowing the parser to be used in the context of state transformations.
+     */
+    static lift(parser) {
+        return new StateTParser(state => parser.map(result => [result, state]));
+    }
+    /**
+     * Applies the state transformation function to the given state and returns a tuple containing the resulting value and the new state.
+     */
+    runT(state) {
+        return this.#fn(state);
+    }
+    /**
+     * Applies the state transformation function to the given state and returns the resulting value, discarding the new state.
+     */
+    evalT(state) {
+        return this.runT(state).map(result => result[0]);
+    }
+    /**
+     * Applies the state transformation function to the given state and returns the new state, discarding the resulting value.
+     */
+    execT(state) {
+        return this.runT(state).map(result => result[1]);
+    }
+    /**
+     * Transforms the produced value using the given function, while keeping the state unchanged and not consuming any additional input.
+     */
+    map(f) {
+        return new StateTParser(state => this.runT(state).map(([value, newState]) => [f(value), newState]));
+    }
+    /**
+     * Transforms the value and state produced by this state transformation function using the given function.
+     */
+    mapT(f) {
+        return new StateTParser(state => f(this.runT(state)));
+    }
+    /**
+     * Returns a new {@link StateTParser} instance that returns the state as the resulting value without modifying the state.
+     */
+    static getT() {
+        return new StateTParser(state => Parser.of([state, state]));
+    }
+    /**
+     * Returns a new {@link StateTParser} instance that applies the given function to the state and returns the resulting value without modifying the state.
+     */
+    static getsT(f) {
+        return new StateTParser(state => Parser.of([f(state), state]));
+    }
+    /**
+     * Modifies the state using the given function before applying this state transformation function.
+     */
+    withT(f) {
+        return new StateTParser(state => this.runT(f(state)));
+    }
+    /**
+     * 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 StateTParser(state => {
+            const parser = this.#fn(state);
+            const otherParser = other.#fn(state);
+            return parser.orFirst(otherParser);
+        });
+    }
+    /**
+     * 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 StateTParser((state) => {
+            const parser = this.#fn(state);
+            const otherParser = other.#fn(state);
+            return parser.orFirstW(otherParser);
+        });
+    }
+    /**
+     * 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(StateTParser.of(undefined));
+    }
+    /**
+     * Returns a parser that parses a specific string.
+     */
+    static string(string) {
+        return StateTParser.lift(Parser.string(string));
+    }
+    /**
+     * Returns a parser that parses zero or more occurrences of this parser, returning an array of the parsed results.
+     */
+    many() {
+        return this.many1().orFirst(StateTParser.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 => StateTParser.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(StateTParser.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 => StateTParser.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 StateTParser.lift(Parser.regex(pattern));
+    }
+    /**
+     * A parser that parses whitepace characters.
+     */
+    static space() {
+        return StateTParser.lift(Parser.space);
+    }
+    /**
+     * A parser that parses horizontal whitepace characters.
+     *
+     * This can be useful for parsing a language where newlines are significant.
+     */
+    static hspace() {
+        return StateTParser.lift(Parser.hspace);
+    }
+    /**
+     * Throws away trailing whitespace characters before applying the given parser.
+     */
+    token() {
+        return this.then(result => StateTParser.space().then(() => StateTParser.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 => StateTParser.hspace().then(() => StateTParser.of(result)));
+    }
+    /**
+     * Returns a parser that parses a specific string, ignoring trailing whitespace characters.
+     */
+    static symb(symbol) {
+        return StateTParser.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 StateTParser.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(() => StateTParser.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 StateTParser(state => Parser.lookahead(parser.runT(state)));
+    }
+    /**
+     * 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 StateTParser(state => Parser.negativeLookahead(parser.runT(state)).map(() => [undefined, state]));
+    }
+    static debugLog(stateParser) {
+        return new StateTParser(state => {
+            console.log("Parsing with state:", state);
+            return Parser.debugLog(stateParser.runT(state));
+        });
+    }
+}

package/dist/string/number.js

@@ -14,24 +14,16 @@ export const plusMinus = "\xB1";
 /**
  * Forces signing on the given number, returning `undefined` on zero.
  */
-export const signIgnoreZero = (x) => x > 0
-    ? `+${x.toString()}`
-    : x < 0
-        ? `${minus}\u2060${Math.abs(x).toString()}`
-        : undefined;
+export const signIgnoreZero = (x) => x > 0 ? `+${x.toString()}` : x < 0 ? `${minus}\u2060${Math.abs(x).toString()}` : undefined;
 /**
  * Forces signing on the given number.
  */
-export const sign = (x) => x > 0
-    ? `+${x.toString()}`
-    : x < 0
-        ? `${minus}\u2060${Math.abs(x).toString()}`
-        : "0";
+export const sign = (x) => x > 0 ? `+${x.toString()}` : x < 0 ? `${minus}\u2060${Math.abs(x).toString()}` : "0";
 /**
  * Returns the sign of the given number. Returns `undefined` if the number is
  * zero.
  */
-export const signStr = (x) => x > 0 ? "+" : x < 0 ? minus : undefined;
+export const signStr = (x) => (x > 0 ? "+" : x < 0 ? minus : undefined);
 /**
  * Converts a string to an integer. If the string is not a valid integer, it
  * returns `undefined`.

package/dist/string.js

@@ -28,8 +28,7 @@ export const splitStringParts = (str) => [...new Intl.Segmenter().segment(str)].
         const nextSegment = strArr[i + 1];
         const nextChar = nextSegment?.segment;
         if (lastCharOfLastPart === undefined ||
-            (uppercase.test(lastCharOfLastPart) &&
-                (nextChar === undefined || separator.test(nextChar)))) {
+            (uppercase.test(lastCharOfLastPart) && (nextChar === undefined || separator.test(nextChar)))) {
             return [...acc.slice(0, -1), lastPart + char];
         }
         else {
@@ -50,9 +49,7 @@ export const splitStringParts = (str) => [...new Intl.Segmenter().segment(str)].
  * Converts a string to PascalCase.
  */
 export const toPascalCase = (str) => splitStringParts(isAllUppercase(str) ? str.toLowerCase() : str)
-    .map((part) => isAllUppercase(part)
-    ? part
-    : part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+    .map(part => isAllUppercase(part) ? part : part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
     .join("");
 /**
  * Converts a string to camelCase.
@@ -68,21 +65,19 @@ export const toCamelCase = (str) => splitStringParts(isAllUppercase(str) ? str.t
  * Converts a string to kebab-case.
  */
 export const toKebabCase = (str) => splitStringParts(str)
-    .map((part) => part.toLowerCase())
+    .map(part => part.toLowerCase())
     .join("-");
 /**
  * Converts a string to snake_case.
  */
 export const toSnakeCase = (str) => splitStringParts(str)
-    .map((part) => part.toLowerCase())
+    .map(part => part.toLowerCase())
     .join("_");
 /**
  * Converts a string to Title Case.
  */
 export const toTitleCase = (str) => splitStringParts(isAllUppercase(str) ? str.toLowerCase() : str)
-    .map((part) => isAllUppercase(part)
-    ? part
-    : part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+    .map(part => isAllUppercase(part) ? part : part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
     .join(" ");
 /**
  * Finds the longest common prefix among the provided strings.
@@ -93,8 +88,6 @@ export const commonPrefix = (...strs) => {
     }
     return strs.reduce((accPrefix, str) => {
         const indexOfDifference = Array.from(accPrefix).findIndex((char, i) => str[i] !== char);
-        return indexOfDifference === -1
-            ? accPrefix
-            : accPrefix.slice(0, indexOfDifference);
+        return indexOfDifference === -1 ? accPrefix : accPrefix.slice(0, indexOfDifference);
     });
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elyukai/utils",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "A set of JavaScript helper functions.",
   "files": [
     "dist",
@@ -33,14 +33,14 @@
   "homepage": "https://github.com/elyukai/ts-utils#readme",
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@types/node": "^25.3.0",
+    "@types/node": "^25.3.3",
     "commit-and-tag-version": "^12.6.1",
-    "eslint": "^10.0.1",
-    "eslint-plugin-jsdoc": "^62.7.0",
+    "eslint": "^10.0.2",
+    "eslint-plugin-jsdoc": "^62.7.1",
     "prettier": "^3.8.1",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.56.0"
+    "typescript-eslint": "^8.56.1"
   },
   "type": "module"
 }