@elyukai/utils 0.2.8 → 0.3.0

package/dist/{reader.js → src/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 → src/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/src/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/src/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/src/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/src/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 → src/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 → src/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);
     });
 };