@catstral/levy-utils 1.1.0 → 2.0.0

package/dist/number/index.d.ts

@@ -1,2 +1,13 @@
-export * from './utils/toFloat';
-export * from './utils/toInt';
+export * from "./math";
+export * from "./types";
+export * from "./utils/clamp";
+export * from "./utils/isDecimal";
+export * from "./utils/isEven";
+export * from "./utils/isInteger";
+export * from "./utils/isOdd";
+export * from "./utils/negative";
+export * from "./utils/positive";
+export * from "./utils/sign";
+export * from "./utils/toFloat";
+export * from "./utils/toInt";
+export * from "./utils/trunc";

package/dist/number/math/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./utils/isPrime";
+export * from "./utils/mod";

package/dist/number/math/utils/isPrime/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Checks if the given value is a prime number.
+ *
+ * The time complexity for this is `O(√n)` where `n` is the given number.
+ *
+ * @param {number} value The value to check if it is a prime number
+ * @returns {boolean} A boolean that signals if the given number is a prime number
+ */
+export declare function isPrime(value: number): boolean;

package/dist/number/math/utils/mod/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Returns the modulo of a dividend and a divisor.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @param {number} dividend The number to be divided
+ * @param {number} divisor The number to divide by
+ * @returns {number} The modulo of the division
+ */
+export declare function mod(dividend: number, divisor: number): number;

package/dist/number/types.d.ts

@@ -0,0 +1,11 @@
+export type Zero = 0 | -0;
+export type Integer<T extends number> = `${T}` extends `${infer V extends number}.${number}` ? V : T;
+export type IsInteger<T extends number> = number extends T ? boolean : T extends Integer<T> ? true : false;
+export type Positive<T extends number> = T extends Zero ? 0 : `${T}` extends `-${infer V extends number}` ? V : T;
+export type IsPositive<T extends number> = number extends T ? boolean : T extends Positive<T> ? true : false;
+export type Negative<T extends number> = T extends Zero ? -0 : `-${T}` extends `${infer N extends number}` ? N : T;
+export type IsNegative<T extends number> = number extends T ? boolean : T extends Negative<T> ? true : false;
+export type PositiveInteger<T extends number> = Integer<Positive<T>>;
+export type NegativeInteger<T extends number> = Integer<Negative<T>>;
+export type NonZero<T extends number> = Exclude<T, Zero>;
+export type IsNonZero<T extends number> = number extends T ? boolean : T extends NonZero<T> ? true : false;

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

@@ -0,0 +1,13 @@
+/**
+ * Clamps a number between a minimum and maximum value.
+ *
+ * Returns `NaN` if the minimum and maximum contradict each other.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @param {number} min The minimum value
+ * @param {number} value The value to be clamped between `min` and `max`
+ * @param {number} max The maximum value
+ * @returns {number} The clamped number
+ */
+export declare function clamp(min: number, value: number, max: number): number;

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

@@ -0,0 +1,11 @@
+export type IsDecimal<T extends number> = number extends T ? boolean : `${T}` extends `${number}.${number}` ? true : false;
+/**
+ * Checks if the given value is a number with decimals.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @template {number} T
+ * @param {T} value The number to check if it has decimals
+ * @returns {IsDecimal<T>} A boolean that signals if the given number has decimals
+ */
+export declare function isDecimal<const T extends number>(value: T): IsDecimal<T>;

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

@@ -0,0 +1,9 @@
+/**
+ * Checks if the given value is an even number.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @param {number} value The value to check if it is an even number
+ * @returns {boolean} A boolean that signals if the given number is even
+ */
+export declare function isEven(value: number): boolean;

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

@@ -0,0 +1,11 @@
+import type { IsInteger } from "~/number";
+/**
+ * Checks if the given value is an integer.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @template {number} T
+ * @param {T} value The number to check if it is an integer
+ * @returns {IsInteger<T>} A boolean that signals if the given number is an integer
+ */
+export declare function isInteger<const T extends number>(value: T): IsInteger<T>;

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

@@ -0,0 +1,9 @@
+/**
+ * Checks if the given value is an odd number.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @param {number} value The value to check if it is an odd number
+ * @returns {boolean} A boolean that signals if the given number is odd
+ */
+export declare function isOdd(value: number): boolean;

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

@@ -0,0 +1,21 @@
+import type { IsNegative, Negative } from "~/number";
+/**
+ * Converts a number into a negative number.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @template {number} T
+ * @param {Negative<T>} value The value to convert into a negative number
+ * @returns {Negative<T>} A negative number
+ */
+export declare function negative<const T extends number>(value: T): Negative<T>;
+/**
+ * Checks if the given value is a negative number.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @template {number} T
+ * @param {T} value The value to check if it is a negative number
+ * @returns {IsNegative<T>} A boolean that signals if the given number is negative
+ */
+export declare function isNegative<const T extends number>(value: T): IsNegative<T>;

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

@@ -0,0 +1,21 @@
+import type { IsPositive, Positive } from "~/number";
+/**
+ * Converts a number into a positive number.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @template {number} T
+ * @param {Positive<T>} value The value to convert into a positive number
+ * @returns {Positive<T>} A positive number
+ */
+export declare function positive<const T extends number>(value: T): Positive<T>;
+/**
+ * Checks if the given value is a positive number.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @template {number} T
+ * @param {T} value The value to check if it is a positive number
+ * @returns {IsPositive<T>} A boolean that signals if the given number is positive
+ */
+export declare function isPositive<const T extends number>(value: T): IsPositive<T>;

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

@@ -0,0 +1,14 @@
+import type { IsNegative, Zero } from "~/number";
+export type Sign<T extends number> = number extends T ? -1 | 0 | 1 : T extends Zero ? 0 : IsNegative<T> extends true ? -1 : 1;
+/**
+ * Returns the sign of the given number.
+ *
+ * `NaN` is converted into zero.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @template {number} T
+ * @param {T} value The number to return the sign of
+ * @returns {Sign<T>} A number indicating whether the given number is positive, negative or zero
+ */
+export declare function sign<const T extends number>(value: T): Sign<T>;

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

@@ -1,4 +1,4 @@
-export type Integer<T extends number> = `${T}` extends `${string}.${string}` ? never : T;
+import type { Integer } from "~/number";
 /**
  * Turns a value into an integer where invalid values, `NaN` or `Infinity` will return a fallback.
  *

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

@@ -0,0 +1,16 @@
+import type { PositiveInteger } from "~/number/types";
+/**
+ * Truncates a number to the specified number of fraction digits.
+ *
+ * If no fraction digits are specified, the value is truncated to an integer.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @template {number} T
+ * @param {number} value The number to truncate
+ * @param {PositiveInteger<T>} [fractionDigits=0]  The number of digits to preserve after the decimal point
+ * @returns {number} The truncated number
+ * @throws {RangeError} If `fractionDigits` is less than `0` or greater than `100`
+ */
+export declare function trunc(value: number): number;
+export declare function trunc<const T extends number>(value: number, fractionDigits: PositiveInteger<T>): number;

package/dist/object/index.d.ts

@@ -1,6 +1,6 @@
-export * from './utils/entries';
-export * from './utils/extend';
-export * from './utils/isObject';
-export * from './utils/keys';
-export * from './utils/omit';
-export * from './utils/pick';
+export * from "./utils/entries";
+export * from "./utils/extend";
+export * from "./utils/isObject";
+export * from "./utils/keys";
+export * from "./utils/omit";
+export * from "./utils/pick";

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

@@ -1,9 +1,15 @@
-import { Key } from '../../../types';
-export type Extend<T extends Record<Key, unknown>, U extends Partial<T> | Record<Key, unknown>> = Omit<T, keyof U> & U;
+import type { Key } from "~/types";
+/**
+ * @private
+ */
+type Mask<T extends Record<Key, unknown>> = (Partial<T> & Record<Key, unknown>) | Record<Key, unknown>;
+export type Extend<T extends Record<Key, unknown>, U extends Mask<T>> = Omit<T, keyof U> & U;
 /**
  * Extends an object with another object.
  *
- * The time complexity for this is `O(n * m)` where `n` is the amount of keys in `other`.
+ * The time complexity for this is `O(n + m)` where:
+ * - `n` is the amount of keys in `value`.
+ * - `m` is the amount of keys in `other`.
  *
  * @template {Record<Key, unknown>} T
  * @template {Partial<T> & Record<Key, unknown>} U
@@ -11,4 +17,5 @@ export type Extend<T extends Record<Key, unknown>, U extends Partial<T> | Record
  * @param {U} other The object to override or extend properties of `value` with
  * @returns {Extend<T, U>} An object where `value` is extended by `other`
  */
-export declare function extend<const T extends Record<Key, unknown>, const U extends Partial<T> | Record<Key, unknown>>(value: T, other: U): Extend<T, U>;
+export declare function extend<const T extends Record<Key, unknown>, const U extends Mask<T>>(value: T, other: U): Extend<T, U>;
+export {};

package/dist/random/helper.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns a random value less then max.
+ *
+ * NOTE: This is meant for getting an array index as the max number here is equal to the max array length.
+ */
+export declare function getCryptoSecureRandomNumber(max: number): number;

package/dist/random/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./utils/draw";
+export * from "./utils/maybe";
+export * from "./utils/random";
+export * from "./utils/shuffle";
+export * from "./utils/uid";
+export * from "./uuid";

package/dist/random/utils/chance/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Returns a boolean based on the given chance percentage.
+ *
+ * The percentage specified should be on a scale of 0 - 1, meaning if you want a 50% chance
+ * the percentage should be specified to be 0.5.
+ *
+ * If the percentage is more than or equal to 1, the returned value will always be true.
+ * If the percentage is less than or equal to 0, the returned value will always be false.
+ *
+ * @param {number} percentage The percentage chance it has of being true (scale: 0 - 1)
+ * @returns {boolean} The random boolean based on the specified chance
+ */
+export declare function chance(percentage: number): boolean;

package/dist/random/utils/draw/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Returns a random item from a given array or `undefined` if the array length is 0.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @template T
+ * @param {T[]} list The array to pick a random item from
+ * @returns {T | undefined} The random item
+ */
+export declare function draw<T>(list: [T, ...T[]]): T;
+export declare function draw<T>(list: T[]): T | undefined;
+export declare function draw<T>(list: readonly [T, ...T[]]): T;
+export declare function draw<T>(list: readonly T[]): T | undefined;

package/dist/random/utils/maybe/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns a random boolean.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @returns {boolean} A random boolean
+ */
+export declare function maybe(): boolean;

package/dist/random/utils/random/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns a random number between a given minimum and maximum value.
+ *
+ * Returns `NaN` if the minimum and maximum contradict each other.
+ *
+ * NOTE: this utility is **NOT** cryptographically secure.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @param {number} [min=0] The minimum random value (default = `0`)
+ * @param {number} [max=1] The maximum random value (default = `1`)
+ * @returns {number} A random number between the min and max value
+ */
+export declare function random(min?: number, max?: number): number;

package/dist/random/utils/scatter/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @typedef {Object} ScatterOptions
+ * @prop {"FLOOR" | "ROUND" | "CEIL"} [bias="ROUND"] The bias of the split
+ */
+export interface ScatterOptions {
+    /**
+     * The bias of the split.
+     *
+     * @default `"ROUND"`
+     */
+    bias?: "FLOOR" | "ROUND" | "CEILING";
+}
+/**
+ * Returns an array split into a specified percentage of the original length with the original values
+ * assigned to either side at random.
+ *
+ * *NOTE: The first array of the returned tuple will be in a random order, while the second array will have the order preserved.*
+ *
+ * The time complexity of this is `O(n + n**2)` where `n` is the amount of items in the list.
+ *
+ * *NOTE: The time complexity of this is `O(n)` if the split is outside the specified range.*
+ *
+ * @template T
+ * @param {T[]} list The list to scatter
+ * @param {number} [split=0.5] The percentage to split the array into (scale: 0 - 1) (default = `0.5`)
+ * @param {ScatterOptions} [options] The options given to scatter the array
+ * @returns {[T[], T[]]} A split of the original array
+ */
+export declare function scatter<const T>(list: T[], split?: number, options?: ScatterOptions): [T[], T[]];
+export declare function scatter<const T>(list: readonly T[], split?: number, options?: ScatterOptions): [T[], T[]];

package/dist/random/utils/shuffle/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Returns a new Array from a given array, with every item moved to a random position.
+ *
+ * The time complexity for this is `O(2n)` where `n` is the amount of values in the list.
+ *
+ * @template T
+ * @param {T[]} list The array to shuffle
+ * @returns {T[]} The shuffled array
+ */
+export declare function shuffle<const T>(list: T[]): T[];
+export declare function shuffle<const T>(list: readonly T[]): T[];

package/dist/random/utils/uid/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Returns a cryptographically secure random string of characters, based on a given charset, grown to a specified length.
+ *
+ * The time complexity for this is `O(n log8(m))` where:
+ * - `n` is the length of the uid.
+ * - `m` is the length of the charset.
+ *
+ * @param {number} [length=8] The length of de uid (default = `8`)
+ * @param {string} [charset="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"] The characters used for generation (default = `"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"`)
+ * @returns {string} A random string of characters from the charset, with the specified length
+ */
+export declare function uid(length?: number, charset?: string): string;

package/dist/random/uuid/helpers.d.ts

@@ -0,0 +1,4 @@
+import type { UuidRNGOptions } from "./types";
+export declare function rng(): Uint8Array;
+export declare function getRNG(options?: UuidRNGOptions): Uint8Array | null;
+export declare function stringifyBytes(bytes: Uint8Array): string;

package/dist/random/uuid/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./utils/max";
+export * from "./utils/nil";
+export * from "./utils/v1";
+export * from "./utils/v4";
+export * from "./utils/v7";

package/dist/random/uuid/types.d.ts

@@ -0,0 +1,16 @@
+export type UuidRNG = () => Uint8Array;
+/**
+ * @typedef {Object} UuidRNGOptions
+ * @prop {UuidRNG} [rng] A function that returns a list of randomly generated bytes
+ * @prop {Uint8Array} [random] A list of randomly generated bytes
+ */
+export interface UuidRNGOptions {
+    /**
+     * A function that returns a list of randomly generated bytes.
+     */
+    rng?: UuidRNG;
+    /**
+     * A list of randomly generated bytes.
+     */
+    random?: Uint8Array;
+}

package/dist/random/uuid/utils/max/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns a max UUID string that is all 'f' (or ones in bit form).
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @returns {string} The max UUID string
+ */
+export declare function uuidMax(): string;

package/dist/random/uuid/utils/nil/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns a nil UUID string that is all zero's.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @returns {string} The nil UUID string
+ */
+export declare function uuidNil(): string;

package/dist/random/uuid/utils/v1/index.d.ts

@@ -0,0 +1,46 @@
+import { UtilError } from "~/error";
+import type { UuidRNGOptions } from "../../types";
+export declare class UuidV1UtilError extends UtilError {
+    readonly util = "uuidV1";
+}
+/**
+ * @typedef {Object} UuidV1Options
+ * @extends UuidRNGOptions
+ * @prop {number} [milliseconds=Date.now()] The amount of milliseconds that have past since the EPOCH (01-01-1970)
+ * @prop {number} [nanoseconds=0] The amount of nanoseconds that have elapsed in the current millisecond
+ * @prop {number} [clockSequence] The clock sequence used for generation
+ * @prop {Uint8Array} [node] A list of random bytes used to complete the UUID
+ */
+export interface UuidV1Options extends UuidRNGOptions {
+    /**
+     * The amount of milliseconds that have past since the EPOCH (01-01-1970).
+     *
+     * @default `Date.now()`
+     */
+    milliseconds?: number;
+    /**
+     * The amount of nanoseconds that have elapsed in the current millisecond.
+     *
+     * @default `0`
+     */
+    nanoseconds?: number;
+    /**
+     * The clock sequence used for generation.
+     */
+    clockSequence?: number;
+    /**
+     * A list of random bytes used to complete the UUID.
+     */
+    node?: Uint8Array;
+}
+/**
+ * Returns a Cryptographically secure random V1 UUID string.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @param {UuidV1Options} [options] The options to decide how to generate the UUID
+ * @returns {string} A V1 UUID string
+ * @throws {UuidV1UtilError} If the length of the specified random bytes is less then 16
+ */
+export declare function uuidV1(options?: UuidV1Options): string;
+export { uuidV1 as v1 };

package/dist/random/uuid/utils/v4/index.d.ts

@@ -0,0 +1,22 @@
+import { UtilError } from "~/error";
+import type { UuidRNGOptions } from "../../types";
+export declare class UuidV4UtilError extends UtilError {
+    readonly util = "uuidV4";
+}
+/**
+ * @typedef {Object} UuidV4Options
+ * @extends UuidRNGOptions
+ */
+export interface UuidV4Options extends UuidRNGOptions {
+}
+/**
+ * Returns a Cryptographically secure random V4 UUID string.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @param {UuidV1Options} [options] The options to decide how to generate the UUID
+ * @returns {string} A V4 UUID string
+ * @throws {UuidV4UtilError} If the length of the specified random bytes is less then 16
+ */
+export declare function uuidV4(options?: UuidV4Options): string;
+export { uuidV4 as v4, uuidV4 as uuid };

package/dist/random/uuid/utils/v7/index.d.ts

@@ -0,0 +1,34 @@
+import { UtilError } from "~/error";
+import type { UuidRNGOptions } from "../../types";
+export declare class UuidV7UtilError extends UtilError {
+    readonly util = "uuidV7";
+}
+/**
+ * @typedef {Object} UuidV7Options
+ * @extends UuidRNGOptions
+ * @prop {number} [milliseconds=Date.now()] The amount of milliseconds that have past since the EPOCH (01-01-1970)
+ * @prop {number} [clockSequence] The clock sequence used for generation
+ */
+export interface UuidV7Options extends UuidRNGOptions {
+    /**
+     * The amount of milliseconds that have past since the EPOCH (01-01-1970).
+     *
+     * @default `Date.now()`
+     */
+    milliseconds?: number;
+    /**
+     * The clock sequence used for generation.
+     */
+    sequence?: number;
+}
+/**
+ * Returns a Cryptographically secure random V7 UUID string.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @param {UuidV7Options} [options] The options to decide how to generate the UUID
+ * @returns {string} A V7 UUID string
+ * @throws {UuidV7UtilError} If the length of the specified random bytes is less then 16
+ */
+export declare function uuidV7(options?: UuidV7Options): string;
+export { uuidV7 as v7 };

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

@@ -1,11 +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';
+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/utils/camel/index.d.ts

@@ -1,4 +1,4 @@
-import { SplitCasingOptions } from '../../internal/splitCasing';
+import type { SplitCasingOptions } from "../../internal/splitCasing";
 /**
  * @typedef {Object} CamelCaseOptions
  */

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

@@ -1,4 +1,4 @@
-import { SplitCasingOptions } from '../../internal/splitCasing';
+import { type SplitCasingOptions } from "../../internal/splitCasing";
 /**
  * @typedef {Object} CustomCaseOptions
  * @prop {string} seperator The separator to place between each transformed word

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

@@ -1,4 +1,4 @@
-import { SplitCasingOptions } from '../../internal/splitCasing';
+import type { SplitCasingOptions } from "../../internal/splitCasing";
 /**
  * @typedef {Object} HttpHeaderCaseOptions
  */

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

@@ -1,4 +1,4 @@
-import { SplitCasingOptions } from '../../internal/splitCasing';
+import type { SplitCasingOptions } from "../../internal/splitCasing";
 /**
  * @typedef {Object} KebabCaseOptions
  * @prop {boolean} [screaming] Whether to uppercase every word instead of lowercasing them (SCREAMING-KEBAB-CASE)

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

@@ -1,4 +1,4 @@
-import { SplitCasingOptions } from '../../internal/splitCasing';
+import type { SplitCasingOptions } from "../../internal/splitCasing";
 /**
  * @typedef {Object} PascalCaseOptions
  */

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

@@ -1,4 +1,4 @@
-import { SplitCasingOptions } from '../../internal/splitCasing';
+import type { SplitCasingOptions } from "../../internal/splitCasing";
 /**
  * @typedef {Object} SnakeCaseOptions
  * @prop {boolean} [screaming] Whether to uppercase every word instead of lowercasing them (SCREAMING_SNAKE_CASE)

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

@@ -1,4 +1,4 @@
-import { SplitCasingOptions } from '../../internal/splitCasing';
+import type { SplitCasingOptions } from "../../internal/splitCasing";
 /**
  * @typedef {Object} TitleCaseOptions
  */

package/dist/string/index.d.ts

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

package/dist/types.d.ts

@@ -1,3 +1,5 @@
 export type Key = string | number | symbol;
 export type Falsy = false | 0 | 0n | "" | null | undefined;
 export type Promisable<T> = T | Promise<T>;
+export type AnyRecord = Record<Key, any>;
+export type RecordOf<T> = Record<Key, T>;