@catstral/levy-utils 1.0.0

package/dist/misc/index.d.ts

@@ -0,0 +1,5 @@
+export * from './utils/compute';
+export * from './utils/isEmpty';
+export * from './utils/isPrimitive';
+export * from './utils/range';
+export * from './utils/sleep';

package/dist/misc/utils/compute/index.d.ts

@@ -0,0 +1,24 @@
+export type Computable<T, Args extends unknown[] = never[]> = T | ((...args: Args) => T);
+/**
+ * Check if a given value can be executed/computed.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @template T
+ * @template {?[]} Args
+ * @param {Computable<T, Args>} value The values to check if it can be computed
+ * @returns {boolean} A boolean to signal if the value can be computed
+ */
+export declare function isComputation<const T, const Args extends unknown[]>(value: Computable<T, Args>): value is (...args: Args) => T;
+/**
+ * Computes a computable value.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @template T
+ * @template {unknown[]} [Args=never[]]
+ * @param {Computable<T, Args>} value The value to compute
+ * @param {Args} args The arguments needed to compute the value
+ * @returns {T} A computed value
+ */
+export declare function compute<const T, const Args extends unknown[] = never[]>(value: Computable<T, Args>, ...args: Args): T;

package/dist/misc/utils/isEmpty/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Checks if the given value is considered empty.
+ *
+ * Empty values include:
+ * - Empty arrays (`[]`)
+ * - Empty objects (`{}`) (Do note that this checks keys, if a key exists without a value it not considered empty)
+ * - Empty strings (`""`)
+ * - `null`
+ * - `undefined`
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @param {?} value The value to check if it is empty
+ * @returns {boolean} A boolean to signal if the given value is empty
+ */
+export declare function isEmpty(value: string | null | undefined): value is "" | null | undefined;
+export declare function isEmpty(value: unknown[] | null | undefined): value is [] | null | undefined;
+export declare function isEmpty(value: Record<string, unknown> | null | undefined): value is Record<string, never> | null | undefined;
+export declare function isEmpty(value: unknown): value is "" | [] | Record<string, never> | null | undefined;

package/dist/misc/utils/isPrimitive/index.d.ts

@@ -0,0 +1,18 @@
+export type Primitive = string | number | boolean | symbol | null | undefined;
+/**
+ * Checks if the given value is a primitve value.
+ *
+ * The following types are considered primitive:
+ * - string
+ * - number
+ * - boolean
+ * - null
+ * - undefined
+ * - symbol
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @param {?} value The value to check if it is primitive
+ * @returns {boolean} A boolean that signals if the given value is a primitive
+ */
+export declare function isPrimitive(value: unknown): value is Primitive;

package/dist/misc/utils/range/index.d.ts

@@ -0,0 +1,89 @@
+import { UtilError } from '../../../error';
+import { Computable } from '../compute';
+export declare class RangeUtilError extends UtilError {
+    readonly util = "range";
+}
+/**
+ * @typedef {Object} RangeOptions
+ * @template T
+ * @prop {T | ((step: number) => T)} [valueMapper] A mapper to map the current step of the range to a given value that will be returned by the generator
+ * @prop {number} [step] A number to define the steps that should be used by the range generator
+ */
+export interface RangeOptions<T> {
+    /**
+     * A mapper to map the current step of the range to a given value that will be returned by the generator.
+     *
+     * @default undefined
+     */
+    valueMapper?: Computable<T, [step: number]> | undefined;
+    /**
+     * A number to define the steps that should be used by the range generator.
+     *
+     * @default 1
+     */
+    step?: number;
+}
+/**
+ * Returns a generator that returns values from a specified range.
+ *
+ * If `start` is greater than `end`, the range will traverse negatively (counting down) instead of positively.
+ *
+ * The time complexity for this is `O(n)` where `n` is the amount of steps needed to generate the result.
+ *
+ * @example
+ * // This will log the following numbers: 0, 1, 2, 3
+ * for (const value of range(3)) {
+ * 	console.log(value);
+ * }
+ *
+ * @example
+ * // This will log the following: 0, 1, 2, 3
+ * for (const value of range(0, 3)) {
+ * 	console.log(value);
+ * }
+ *
+ * @example
+ * // This will log the following: 3, 2, 1, 0
+ * for (const value of range(3, 0)) {
+ * 	console.log(value);
+ * }
+ *
+ * @example
+ * // This will log the following: 0, 2, 4, 6
+ * for (const value of range(0, 6, { step: 2 })) {
+ * 	console.log(value);
+ * }
+ *
+ * @example
+ * // This will log the following: 6, 4, 2, 0
+ * for (const value of range(6, 0, { step: -2 })) {
+ * 	console.log(value);
+ * }
+ *
+ * @example
+ * // This will log the following: "foo", "foo", "foo", "foo"
+ * for (const value of range(0, 3, { valueMapper: "foo" })) {
+ * 	console.log(value);
+ * }
+ *
+ * @example
+ * // This will log the following: "foo-0", "foo-1", "foo-2", "foo-3"
+ * for (const value of range(0, 3, { valueMapper: (currentStep) => `foo-${currentStep}` })) {
+ * 	console.log(value);
+ * }
+ *
+ * @example
+ * // This will log the following: "foo-0", "foo-2", "foo-4", "foo-6"
+ * for (const value of range(0, 6, { step: 2, valueMapper: (currentStep) => `foo-${currentStep}` })) {
+ * 	console.log(value);
+ * }
+ *
+ * @template [T=number]
+ * @param {number} startOrLength The start of the range, or if this is the only parameter given, the length of the range (inclusive)
+ * @param {number | undefined} [end] The end of the range (inclusive), if this value is not given, the `startOrLength` will be used to determine the end
+ * @param {RangeOptions<T>} [options] The options used to generate the range (see {@link RangeOptions} for more details)
+ * @returns {Generator<T>} A generator of a specified range (optionally mapped to a specified value)
+ * @throws {RangeUtilError} If `options.step` is `0`
+ * @throws {RangeUtilError} If `options.step` is positive while the range traverses negatively (`start` > `end`), or negative while the range traverses positively
+ */
+export declare function range<const T = number>(startOrLength: number, end?: number, options?: RangeOptions<T>): Generator<T>;

package/dist/misc/utils/sleep/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Returns a promise that will resolve after the specified delay has elapsed.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @param {number} delay The delay to wait to resolve the returned promise
+ * @returns {Promise<void>} A Promise that resolved after the specified delay has elapsed
+ */
+export declare function sleep(delay: number): Promise<void>;

package/dist/number/index.d.ts

@@ -0,0 +1,2 @@
+export * from './utils/toFloat';
+export * from './utils/toInt';

package/dist/number/utils/toFloat/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Turns a value into an float where invalid values, `NaN` or `Infinity` will return a fallback.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @param {?} value The value to convert
+ * @param {number} [fallback = 0] A float number to fallback on when the value is invalid
+ * @returns {number} A float number parsed from the value or a fallback
+ */
+export declare function toFloat(value: unknown, fallback?: number): number;

package/dist/number/utils/toInt/index.d.ts

@@ -0,0 +1,12 @@
+export type Integer<T extends number> = `${T}` extends `${string}.${string}` ? never : T;
+/**
+ * Turns a value into an integer where invalid values, `NaN` or `Infinity` will return a fallback.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @template {number} T
+ * @param {?} value The value to convert
+ * @param {Integer<T>} [fallback = 0] An integer to fallback on when the value is invalid
+ * @returns {number} An integer number parsed from the value or a fallback
+ */
+export declare function toInt<const T extends number>(value: unknown, fallback?: Integer<T>): number;

package/dist/object/index.d.ts

@@ -0,0 +1,5 @@
+export * from './utils/entries';
+export * from './utils/isObject';
+export * from './utils/keys';
+export * from './utils/omit';
+export * from './utils/pick';

package/dist/object/utils/entries/index.d.ts

@@ -0,0 +1,7 @@
+export type Entries<T extends object> = {
+    [K in keyof T]: [K, T[K]];
+}[keyof T][];
+/**
+ * Converts an object into a types version of `Object.entries`.
+ */
+export declare function entries<const T extends Record<string, unknown>>(value: T): Entries<T>;

package/dist/object/utils/isObject/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Checks if the given item is an object (This does not include arrays).
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @param {?} item - The item to check
+ * @returns {boolean} A boolean to signal if the given item is an object
+ */
+export declare function isObject(item: unknown): item is object;

package/dist/object/utils/keys/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Converts an object into a types version of `Object.keys`.
+ */
+export declare function keys<const T extends Record<string, unknown>>(value: T): (keyof T)[];

package/dist/object/utils/omit/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Omits certain keys off of an object and returns a new object without those keys.
+ *
+ * The time complexity for this is `O(n)` where `n` is the amount of keys to omit.
+ *
+ * @template {Record<string, unknown>} T
+ * @template {keyof T} K
+ * @param {T} object The objects to omit the keys off of
+ * @param {K | K[]} keys The keys to omit off of the object
+ * @returns {Omit<T, K>} A new object without the omitted keys
+ */
+export declare function omit<const T extends Record<string, unknown>, const K extends keyof T>(object: T, keys: K | K[]): Omit<T, K>;

package/dist/object/utils/pick/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Picks certain keys off of an object and returns a new object with only those keys (and values)
+ *
+ * The time complexity for this is `O(n)` where `n` is the amount of keys to pick.
+ *
+ * @template {Record<string, unknown>} T
+ * @template {keyof T} K
+ * @param {T} object The objects to pick the keys off of
+ * @param {K | K[]} keys The keys to pick off of the object
+ * @returns {Pick<T, K>} A new object with the picked keys
+ */
+export declare function pick<const T extends Record<string, unknown>, const K extends keyof T>(object: T, keys: K | K[]): Pick<T, K>;

package/dist/string/casing/index.d.ts

@@ -0,0 +1,11 @@
+export * from './utils/camel';
+export * from './utils/capitalize';
+export * from './utils/custom';
+export * from './utils/http';
+export * from './utils/kebab';
+export * from './utils/lower';
+export * from './utils/pascal';
+export * from './utils/snake';
+export * from './utils/title';
+export * from './utils/uncapitalize';
+export * from './utils/upper';

package/dist/string/casing/internal/splitCasing/index.d.ts

@@ -0,0 +1,59 @@
+export type splitCasingParser = (str: string) => string[];
+/**
+ * @typedef {Object} SplitCasingOptions
+ * @prop {boolean} [splitOnNumbers] Whether a run of digits should be split off into its own word, or seen as normal characters of the same word
+ * @prop {boolean} [groupUppercaseLetters] Whether consecutive uppercase letters should be grouped into a single word instead of being split one letter at a time
+ * @prop {splitCasingParser} [parser] A custom parser to parse a given string into word that are then used for changing the casing of words
+ */
+export interface SplitCasingOptions {
+    /**
+     * Whether a run of digits should be split off into its own word, or seen as normal characters of the same word.
+     *
+     * @default false
+     */
+    groupNumbers?: boolean;
+    /**
+     * Whether consecutive uppercase letters should be grouped into a single word instead of being split one letter at a time.
+     *
+     * @default true
+     */
+    groupUppercaseLetters?: boolean;
+    /**
+     * A custom parser to parse a given string into word that are then used for changing the casing of words.
+     *
+     * If this is defined, all other options are ignored.
+     */
+    parser?: splitCasingParser;
+}
+/**
+ * Splits a string into its constituent words, based on whitespace, hyphens, underscores, casing changes, and
+ * (optionally) runs of digits. The original casing of each word is preserved as-is.
+ *
+ * This is an internal building block used by the casing utilities in this directory (see {@link CustomCaseOptions})
+ * and is not intended to be used directly.
+ *
+ * The time complexity for this is `O(n)` where `n` is the length of the given string.
+ *
+ * @example
+ * const words = splitCasing("helloWorld", undefined); // -> ["hello", "World"]
+ *
+ * @example
+ * const words = splitCasing("HTTPServer", undefined); // -> ["HTTP", "Server"]
+ *
+ * @example
+ * const words = splitCasing("HTTPServer", { groupUppercaseLetters: false }); // -> ["H", "T", "T", "P", "Server"]
+ *
+ * @example
+ * const words = splitCasing("HTTP_server", undefined); // -> ["HTTP", "server"]
+ *
+ * @example
+ * const words = splitCasing("foo123bar", { groupNumbers: true }); // -> ["foo", "123", "bar"]
+ *
+ * @example
+ * const words = splitCasing("foo_bar-baz qux", undefined); // -> ["foo", "bar", "baz", "qux"]
+ *
+ * @param {string} str The string to split into words
+ * @param {SplitCasingOptions | undefined} options The options used to split the string (see {@link SplitCasingOptions} for more details)
+ * @returns {string[]} The words found in the given string, with their original casing preserved
+ */
+export declare function splitCasing(str: string, options?: SplitCasingOptions): string[];

package/dist/string/casing/utils/camel/index.d.ts

@@ -0,0 +1,27 @@
+import { SplitCasingOptions } from '../../internal/splitCasing';
+/**
+ * @typedef {Object} CamelCaseOptions
+ */
+export interface CamelCaseOptions extends SplitCasingOptions {
+}
+/**
+ * Converts a string to camelCase.
+ *
+ * The first word is lowercased, every following word has its first letter uppercased with the rest lowercased, and
+ * words are joined together with no separator.
+ *
+ * The time complexity for this is `O(n + m)` where:
+ * - `n` is the length of the given string.
+ * - `m` is the amount of words in `n`.
+ *
+ * @example
+ * const str = camelCase("hello world"); // -> "helloWorld"
+ *
+ * @example
+ * const str = camelCase("Hello-World_foo"); // -> "helloWorldFoo"
+ *
+ * @param {string} str The string to convert
+ * @param {CamelCaseOptions} [options] The options used to convert the string (see {@link CamelCaseOptions} for more details)
+ * @returns {string} The camelCased string
+ */
+export declare function camelCase(str: string, options?: CamelCaseOptions): string;

package/dist/string/casing/utils/capitalize/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Converts the first character of string to uppercase.
+ *
+ * The time complexity for this is `O(n)` where `n` is the length of the given string.
+ *
+ * @example
+ * const str = capitalize("hello world"); // -> "Hello world"
+ *
+ * @template {string} T
+ * @param {T} str
+ * @returns {Capitalize<T>}
+ */
+export declare function capitalize<const T extends string>(str: T): Capitalize<T>;

package/dist/string/casing/utils/custom/index.d.ts

@@ -0,0 +1,42 @@
+import { SplitCasingOptions } from '../../internal/splitCasing';
+/**
+ * @typedef {Object} CustomCaseOptions
+ * @prop {string} seperator The separator to place between each transformed word
+ * @prop {(word: string, index: number) => string} transform A function used to transform each word found in the string
+ */
+export interface CustomCaseOptions extends SplitCasingOptions {
+    /**
+     * The separator to place between each transformed word.
+     */
+    seperator: string;
+    /**
+     * A function used to transform each word found in the string. The word retains whatever casing it had in the
+     * original string.
+     *
+     * @param word The word to transform
+     * @param index The index of the word within the string
+     */
+    transform: (word: string, index: number) => string;
+}
+/**
+ * Splits a string into words (see {@link SplitCasingOptions}) and joins them back together using a custom separator,
+ * transforming each word along the way.
+ *
+ * This is the building block used by the other casing utilities (`camelCase`, `kebabCase`, `pascalCase`, `snakeCase`,
+ * `titleCase`, `httpHeaderCase`, etc.), That also means that those casing options should be used instead most of the time.
+ *
+ * The time complexity for this is `O(n + m)` where:
+ * - `n` is the length of the given string.
+ * - `m` is the amount of words in `n`.
+ *
+ * @example
+ * const str = customCase("hello world", { seperator: "-", transform: (word) => word.toUpperCase() }); // -> "HELLO-WORLD"
+ *
+ * @example
+ * const str = customCase("hello world", { seperator: "_", transform: (word, index) => (index === 0 ? word : word.toUpperCase()) }); // -> "hello_WORLD"
+ *
+ * @param {string} str The string to transform
+ * @param {CustomCaseOptions} options The options used to split and join the string (see {@link CustomCaseOptions} for more details)
+ * @returns {string} The transformed string
+ */
+export declare function customCase(str: string, options: CustomCaseOptions): string;

package/dist/string/casing/utils/http/index.d.ts

@@ -0,0 +1,27 @@
+import { SplitCasingOptions } from '../../internal/splitCasing';
+/**
+ * @typedef {Object} HttpHeaderCaseOptions
+ */
+export interface HttpHeaderCaseOptions extends SplitCasingOptions {
+}
+/**
+ * Converts a string to HTTP-Header-Case (also known as Train-Case).
+ *
+ * Every word has its first letter uppercased with the rest lowercased, and words are joined together using a `-`.
+ *
+ * The time complexity for this is `O(n + m)` where:
+ * - `n` is the length of the given string.
+ * - `m` is the amount of words in `n`.
+ *
+ * @example
+ * const str = httpHeaderCase("content type"); // -> "Content-Type"
+ *
+ * @example
+ * const str = httpHeaderCase("x_forwarded_for"); // -> "X-Forwarded-For"
+ *
+ * @param {string} str The string to convert
+ * @param {HttpHeaderCaseOptions} [options] The options used to convert the string (see {@link HttpHeaderCaseOptions} for more details)
+ * @returns {string} The HTTP-Header-Cased string
+ */
+export declare function httpHeaderCase(str: string, options?: HttpHeaderCaseOptions): string;
+export { type HttpHeaderCaseOptions as TrainCaseOptions, httpHeaderCase as trainCase };

package/dist/string/casing/utils/kebab/index.d.ts

@@ -0,0 +1,48 @@
+import { SplitCasingOptions } from '../../internal/splitCasing';
+/**
+ * @typedef {Object} KebabCaseOptions
+ * @prop {boolean} [screaming] Whether to uppercase every word instead of lowercasing them (SCREAMING-KEBAB-CASE)
+ */
+export interface KebabCaseOptions extends SplitCasingOptions {
+    /**
+     * Whether to uppercase every word instead of lowercasing them (SCREAMING-KEBAB-CASE).
+     *
+     * @default false
+     */
+    screaming?: boolean;
+}
+/**
+ * Converts a string to kebab-case.
+ *
+ * Every word is lowercased (or uppercased if `options.screaming` is `true`) and joined together using a `-`.
+ *
+ * The time complexity for this is `O(n + m)` where:
+ * - `n` is the length of the given string.
+ * - `m` is the amount of words in `n`.
+ *
+ * @example
+ * const str = kebabCase("hello world"); // -> "hello-world"
+ *
+ * @example
+ * const str = kebabCase("helloWorld", { screaming: true }); // -> "HELLO-WORLD"
+ *
+ * @param {string} str The string to convert
+ * @param {KebabCaseOptions} [options] The options used to convert the string (see {@link KebabCaseOptions} for more details)
+ * @returns {string} The kebab-cased string
+ */
+export declare function kebabCase(str: string, options?: KebabCaseOptions): string;
+/**
+ * Converts a string to SCREAMING-KEBAB-CASE.
+ *
+ * Equivalent to calling {@link kebabCase} with `options.screaming` set to `true`.
+ *
+ * The time complexity for this is `O(n)` where `n` is the length of the given string.
+ *
+ * @example
+ * const str = screamingKebabCase("hello world"); // -> "HELLO-WORLD"
+ *
+ * @param {string} str The string to convert
+ * @param {Omit<KebabCaseOptions, "screaming">} [options] The options used to convert the string (see {@link KebabCaseOptions} for more details)
+ * @returns {string} The SCREAMING-KEBAB-CASEd string
+ */
+export declare function screamingKebabCase(str: string, options?: Omit<KebabCaseOptions, "screaming">): string;

package/dist/string/casing/utils/lower/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Converts a string to lowercase.
+ *
+ * The time complexity for this is `O(n)` where `n` is the length of the given string.
+ *
+ * @example
+ * const str = lowerCase("Hello World"); // -> "hello world"
+ *
+ * @template {string} T
+ * @param {T} str
+ * @returns {Lowercase<T>}
+ */
+export declare function lowerCase<const T extends string>(str: T): Lowercase<T>;

package/dist/string/casing/utils/pascal/index.d.ts

@@ -0,0 +1,31 @@
+import { SplitCasingOptions } from '../../internal/splitCasing';
+/**
+ * @typedef {Object} PascalCaseOptions
+ */
+export interface PascalCaseOptions extends SplitCasingOptions {
+}
+/**
+ * Converts a string to PascalCase.
+ *
+ * Every word has its first letter uppercased, with the rest of the word left untouched, and words are joined together
+ * with no separator.
+ *
+ * The time complexity for this is `O(n + m)` where:
+ * - `n` is the length of the given string.
+ * - `m` is the amount of words in `n`.
+ *
+ * @example
+ * const str = pascalCase("hello world"); // -> "HelloWorld"
+ *
+ * @example
+ * const str = pascalCase("hello-world_foo"); // -> "HelloWorldFoo"
+ *
+ * @example
+ * // Acronyms keep their original casing, only their first letter is (re-)uppercased
+ * const str = pascalCase("HTTP_server"); // -> "HTTPServer"
+ *
+ * @param {string} str The string to convert
+ * @param {PascalCaseOptions} [options] The options used to convert the string (see {@link PascalCaseOptions} for more details)
+ * @returns {string} The PascalCased string
+ */
+export declare function pascalCase(str: string, options?: PascalCaseOptions): string;

package/dist/string/casing/utils/snake/index.d.ts

@@ -0,0 +1,48 @@
+import { SplitCasingOptions } from '../../internal/splitCasing';
+/**
+ * @typedef {Object} SnakeCaseOptions
+ * @prop {boolean} [screaming] Whether to uppercase every word instead of lowercasing them (SCREAMING_SNAKE_CASE)
+ */
+export interface SnakeCaseOptions extends SplitCasingOptions {
+    /**
+     * Whether to uppercase every word instead of lowercasing them (SCREAMING_SNAKE_CASE).
+     *
+     * @default false
+     */
+    screaming?: boolean;
+}
+/**
+ * Converts a string to snake_case.
+ *
+ * Every word is lowercased (or uppercased if `options.screaming` is `true`) and joined together using a `_`.
+ *
+ * The time complexity for this is `O(n + m)` where:
+ * - `n` is the length of the given string.
+ * - `m` is the amount of words in `n`.
+ *
+ * @example
+ * const str = snakeCase("hello world"); // -> "hello_world"
+ *
+ * @example
+ * const str = snakeCase("helloWorld", { screaming: true }); // -> "HELLO_WORLD"
+ *
+ * @param {string} str The string to convert
+ * @param {SnakeCaseOptions} [options] The options used to convert the string (see {@link SnakeCaseOptions} for more details)
+ * @returns {string} The snake_cased string
+ */
+export declare function snakeCase(str: string, options?: SnakeCaseOptions): string;
+/**
+ * Converts a string to SCREAMING_SNAKE_CASE.
+ *
+ * Equivalent to calling {@link snakeCase} with `options.screaming` set to `true`.
+ *
+ * The time complexity for this is `O(n)` where `n` is the length of the given string.
+ *
+ * @example
+ * const str = screamingSnakeCase("hello world"); // -> "HELLO_WORLD"
+ *
+ * @param {string} str The string to convert
+ * @param {Omit<SnakeCaseOptions, "screaming">} [options] The options used to convert the string (see {@link SnakeCaseOptions} for more details)
+ * @returns {string} The SCREAMING_SNAKE_CASEd string
+ */
+export declare function screamingSnakeCase(str: string, options?: Omit<SnakeCaseOptions, "screaming">): string;

package/dist/string/casing/utils/title/index.d.ts

@@ -0,0 +1,27 @@
+import { SplitCasingOptions } from '../../internal/splitCasing';
+/**
+ * @typedef {Object} TitleCaseOptions
+ */
+export interface TitleCaseOptions extends SplitCasingOptions {
+}
+/**
+ * Converts a string to Title Case.
+ *
+ * Every word has its first letter uppercased, with the rest of the word left untouched, and words are joined together
+ * using a single space.
+ *
+ * The time complexity for this is `O(n + m)` where:
+ * - `n` is the length of the given string.
+ * - `m` is the amount of words in `n`.
+ *
+ * @example
+ * const str = titleCase("hello world"); // -> "Hello World"
+ *
+ * @example
+ * const str = titleCase("hello-world_foo"); // -> "Hello World Foo"
+ *
+ * @param {string} str The string to convert
+ * @param {TitleCaseOptions} [options] The options used to convert the string (see {@link TitleCaseOptions} for more details)
+ * @returns {string} The Title Cased string
+ */
+export declare function titleCase(str: string, options?: TitleCaseOptions): string;

package/dist/string/casing/utils/uncapitalize/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Converts the first character of string to lowercase.
+ *
+ * The time complexity for this is `O(n)` where `n` is the length of the given string.
+ *
+ * @example
+ * const str = uncapitalize("Hello world"); // -> "hello world"
+ *
+ * @template {string} T
+ * @param {T} str
+ * @returns {Uncapitalize<T>}
+ */
+export declare function uncapitalize<const T extends string>(str: T): Uncapitalize<T>;

package/dist/string/casing/utils/upper/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Converts a string to UPPERCASE.
+ *
+ * The time complexity for this is `O(n)` where `n` is the length of the given string.
+ *
+ * @example
+ * const str = upperCase("Hello World"); // -> "HELLO WORLD"
+ *
+ * @template {string} T
+ * @param {T} str
+ * @returns {Uppercase<T>}
+ */
+export declare function upperCase<const T extends string>(str: T): Uppercase<T>;

package/dist/string/index.d.ts

@@ -0,0 +1,4 @@
+export * from './casing';
+export * from './utils/parseUrlParams';
+export * from './utils/slug';
+export * from './utils/textDifference';