litus 1.4.0 → 1.6.0

package/dist/index.d.ts

@@ -0,0 +1,778 @@
+/**
+ * Binary search for insertion index in a sorted array using a custom accessor
+ * @param arr Sorted array to search
+ * @param target Value to search for
+ * @param getVal Function to extract comparison value from each element
+ * @param start Start index (inclusive)
+ * @param end End index (exclusive)
+ * @returns Index to insert target to maintain order
+ */
+declare const binSearch: <T>(arr: T[], target: number, getVal: (el: T) => number, start?: number, end?: number) => number;
+
+/**
+ * Splits an array into multiple chunks of a specified size
+ * @param arr Array to split
+ * @param size Size of each chunk
+ * @returns Array of chunks
+ */
+declare const chunk: <T>(arr: T[], size: number) => T[][];
+
+/**
+ * Counts occurrences of items in an array, grouped by key
+ * @param arr Array to count occurrences
+ * @param getKey Function to extract group ids
+ * @returns Object mapping each key to its count
+ */
+declare const countBy: <T, K extends PropertyKey>(arr: T[], getKey: (obj: T) => K) => Record<K, number>;
+
+/**
+ * Creates array of size `n` filled with the specified value
+ * @param n Array size
+ * @param val Value to fill the array with
+ * @returns Array containing `val` repeated `n` times
+ */
+declare const fill: <T>(n: number, val: T) => T[];
+
+type Predicate<T, R = boolean> = (val: T, idx: number, arr: T[]) => R;
+type Tuple<T, N extends number, R extends T[] = []> = R["length"] extends N ? R : Tuple<T, N, [...R, T]>;
+type ConvertTuple<T extends unknown[], ToType> = {
+    [K in keyof T]: ToType;
+};
+
+/**
+ * Finds the first element that matches the given predicate
+ * @param arr Array to search in
+ * @param predicate Function to test each element
+ * @param from Start index (inclusive). Default: 0
+ * @param to End index (exclusive). Default: arr.length
+ * @returns First matching element, or undefined if none found
+ */
+declare const find: <T>(arr: T[], predicate: Predicate<T, boolean>, from?: number, to?: number) => T | undefined;
+
+/**
+ * Finds the index of the first element that matches the given predicate
+ * @param arr Array to search in
+ * @param predicate Function to test each element
+ * @param from Start index (inclusive). Default: 0
+ * @param to End index (exclusive). Default: arr.length
+ * @returns Index of the first matching element, or -1 if none found
+ */
+declare const findIdx: <T>(arr: T[], predicate: Predicate<T, boolean>, from?: number, to?: number) => number;
+
+/**
+ * Finds all elements that match the given predicate
+ * @param arr Array to search in
+ * @param predicate Function to test each element
+ * @param from Start index (inclusive). Default: 0
+ * @param to End index (exclusive). Default: arr.length
+ * @param limit Maximum number of matches to return. Default: arr.length
+ * @returns Array of matching elements
+ */
+declare const findAll: <T>(arr: T[], predicate: Predicate<T, boolean>, from?: number, to?: number, limit?: number) => T[];
+
+/**
+ * Finds indices of all elements that match the given predicate
+ * @param arr Array to search in
+ * @param predicate Function to test each element
+ * @param from Start index (inclusive). Default: 0
+ * @param to End index (exclusive). Default: arr.length
+ * @param limit Maximum number of indices to return. Default: arr.length
+ * @returns Array of matching indices
+ */
+declare const findAllIdx: <T>(arr: T[], predicate: Predicate<T, boolean>, from?: number, to?: number, limit?: number) => number[];
+
+type First<A extends readonly [] | readonly unknown[]> = A extends readonly [infer F, ...unknown[]] ? F : A extends readonly [] ? undefined : A extends readonly [...infer F, infer L, unknown] ? First<[...F, L]> : A[number];
+/**
+ * Gets the first element of an array
+ * @param arr The array
+ * @returns The first element
+ */
+declare const first: <A extends readonly [] | readonly unknown[]>(arr: A) => First<A>;
+
+/**
+ * Creates an array of size `n`, filling each element using the map function
+ * @param n Size of the array to create
+ * @param mapFn Function that maps each index to an array element
+ * @returns Array of mapped values
+ */
+declare const from: <T>(n: number, mapFn: (i: number) => T) => T[];
+
+/**
+ * Groups array items into an object by a key
+ * @param arr Array to group
+ * @param getKey Function to extract the group key from each item
+ * @returns Object with keys as group ids and values as arrays of grouped items
+ */
+declare const group: <T, K extends PropertyKey>(arr: T[], getKey: (obj: T) => K) => Record<K, T[]>;
+
+/**
+ * @deprecated Use `group` instead
+ */
+declare const groupBy: <T extends object, K extends keyof T>(arr: T[], key: T[K] extends PropertyKey ? K : never) => Record<PropertyKey & T[K], T[]>;
+
+type Last<A extends readonly [] | readonly unknown[]> = A extends readonly [...unknown[], infer L] ? L : A extends readonly [] ? undefined : A extends readonly [unknown, infer F, ...infer L] ? Last<[F, ...L]> : A[number];
+/**
+ * Gets the last element of an array
+ * @param arr The array
+ * @returns The last element
+ */
+declare const last: <A extends readonly [] | readonly unknown[]>(arr: A) => Last<A>;
+
+/**
+ * Returns the element with the maximum value based on the provided map function
+ * @param arr Array to search in
+ * @param fn Function to extract the value for comparison
+ * @returns Element with the maximum value
+ */
+declare const max: <T>(arr: T[], fn: (val: T) => number) => T;
+
+/**
+ * Returns the element with the minimum value based on the provided map function
+ * @param arr Array to search in
+ * @param fn Function to extract the value for comparison
+ * @returns Element with the minimum value
+ */
+declare const min: <T>(arr: T[], fn: (val: T) => number) => T;
+
+/**
+ * Creates an array of numbers from `a` up to `b` incremented by `step`
+ * @param a Start of the range (inclusive)
+ * @param b End of the range (exclusive)
+ * @param step Step between elements. Default: 1
+ * @returns Array of numbers in the specified range
+ */
+declare const range: (a: number, b: number, step?: number) => number[];
+
+/**
+ * Sorts an array in-place based on a mapping function
+ * @param arr Array to sort
+ * @param mapFn Function to map each element to a sortable value
+ * @returns Sorted array in-place
+ */
+declare const sort: <T>(arr: T[], mapFn: (el: T) => number | string) => T[];
+
+type Transpose<T extends unknown[][]> = T[number] extends infer U ? {
+    [K in keyof U]: {
+        [J in keyof T]: T[J][K & keyof T[J]];
+    };
+} : never;
+/**
+ * Transposes a 2D array (matrix), switching its rows and columns
+ * @param matrix The 2D array to transpose
+ * @returns Transposed matrix
+ */
+declare const transpose: <T extends unknown[][]>(matrix: T) => Transpose<T>;
+
+/**
+ * Creates a set containing unique values from all provided arrays
+ * @param arrs Arrays to union
+ * @returns Set of unique values
+ */
+declare const union: <T>(...arrs: T[][]) => Set<T>;
+
+type Literal = boolean | number | string;
+type Nullish = null | undefined;
+type Primitive = Literal | bigint | symbol;
+
+/**
+ * Creates array of unique values from the input array, preserving their order
+ * @param arr Array of primitive values
+ * @returns Array of unique values
+ */
+declare const unique: <T extends Primitive>(arr: T[]) => T[];
+
+/**
+ * Creates an array of grouped elements, where each group contains the elements
+ * at the corresponding index from the input arrays
+ * @param arrays Arrays to process
+ * @returns Array of grouped elements
+ */
+declare const zip: <T extends unknown[][]>(...args: T) => Transpose<T>;
+
+type index$5_First<A extends readonly [] | readonly unknown[]> = First<A>;
+type index$5_Last<A extends readonly [] | readonly unknown[]> = Last<A>;
+type index$5_Transpose<T extends unknown[][]> = Transpose<T>;
+declare const index$5_binSearch: typeof binSearch;
+declare const index$5_chunk: typeof chunk;
+declare const index$5_countBy: typeof countBy;
+declare const index$5_fill: typeof fill;
+declare const index$5_find: typeof find;
+declare const index$5_findAll: typeof findAll;
+declare const index$5_findAllIdx: typeof findAllIdx;
+declare const index$5_findIdx: typeof findIdx;
+declare const index$5_first: typeof first;
+declare const index$5_from: typeof from;
+declare const index$5_group: typeof group;
+declare const index$5_groupBy: typeof groupBy;
+declare const index$5_last: typeof last;
+declare const index$5_max: typeof max;
+declare const index$5_min: typeof min;
+declare const index$5_range: typeof range;
+declare const index$5_sort: typeof sort;
+declare const index$5_transpose: typeof transpose;
+declare const index$5_union: typeof union;
+declare const index$5_unique: typeof unique;
+declare const index$5_zip: typeof zip;
+declare namespace index$5 {
+  export { index$5_binSearch as binSearch, index$5_chunk as chunk, index$5_countBy as countBy, index$5_fill as fill, index$5_find as find, index$5_findAll as findAll, index$5_findAllIdx as findAllIdx, index$5_findIdx as findIdx, index$5_first as first, index$5_from as from, index$5_group as group, index$5_groupBy as groupBy, index$5_last as last, index$5_max as max, index$5_min as min, index$5_range as range, index$5_sort as sort, index$5_transpose as transpose, index$5_union as union, index$5_unique as unique, index$5_zip as zip };
+  export type { index$5_First as First, index$5_Last as Last, index$5_Transpose as Transpose };
+}
+
+/**
+ * Transforms a function with spread arguments into one with array argument
+ * @param fn Function accepting spread arguments
+ * @returns Function accepting an array of arguments
+ */
+declare const apply: <T extends unknown[], R>(fn: (...args: T) => R) => (arg: T) => R;
+
+type CurryArgs<T extends unknown[]> = T extends [...infer Ti, unknown] ? CurryArgs<Ti> | T : [];
+type CurryRest<T extends unknown[], A extends CurryArgs<T>> = T extends [
+    unknown,
+    ...infer Ti
+] ? A extends [unknown, ...infer Ai extends CurryArgs<Ti>] ? CurryRest<Ti, Ai> : T : [];
+type CurryFnRes<R, T extends unknown[], A extends CurryArgs<T>> = CurryRest<T, A> extends [] ? R : CurryFn<R, CurryRest<T, A>>;
+type CurryFn<R, T extends unknown[]> = <A extends CurryArgs<T>>(...args: A) => CurryFnRes<R, T, A>;
+/**
+ * Creates a curried version of a function, allowing partial application of arguments
+ * @param fn Function to curry
+ * @param arity Number of arguments the function expects. Default: fn.length
+ * @returns Curried function
+ */
+declare const curry: <R, T extends unknown[]>(fn: (...args: T) => R, arity?: number) => CurryFn<R, T>;
+
+/**
+ * Creates a debounced version of a function that delays invoking until after the specified delay.
+ * Only the last call within the delay period is executed
+ * @param fn Function to debounce
+ * @param delay Delay in milliseconds. Default: 100
+ * @returns Debounced function
+ */
+declare const debounce: <A extends unknown[]>(fn: (...args: A) => void, delay?: number) => (...args: A) => void;
+
+/**
+ * Returns the input value unchanged
+ * @param value Value to return
+ * @returns Same value provided as input
+ */
+declare const identity: <T>(x: T) => T;
+
+/**
+ * Creates a memoized version of a function, caching its output for faster repeated calls.
+ * Optionally accepts a custom cache key generator and a TTL (time-to-live) in milliseconds
+ * @param fn Function to memoize
+ * @param idFn Function to generate a cache key from arguments. Default: JSON.stringify
+ * @param ttl Optional cache expiration time in milliseconds. Default: 0 (no expiration)
+ * @returns Memoized function
+ */
+declare const memo: <T extends unknown[], R>(fn: (...args: T) => R, idFn?: (arg: T) => Primitive, ttl?: number) => (...args: T) => R;
+
+/**
+ * Performs no operation
+ */
+declare const noop: () => void;
+
+/**
+ * Ensures the provided function is executed only once
+ * Subsequent calls return the result of the first execution
+ * @param fn Function to execute only once
+ * @returns Function that invokes `fn` only once
+ */
+declare const once: <T>(fn: () => T) => () => T;
+
+type UnaryFn = (arg: any) => unknown;
+
+type FirstFnArg<T> = T extends [(arg: infer A) => unknown, ...unknown[]] ? A : never;
+type LastFnReturn<T> = T extends [...unknown[], (arg: unknown) => infer R] ? R : never;
+type PipeOps<T extends UnaryFn[] = UnaryFn[]> = T extends [
+    infer F1 extends UnaryFn,
+    infer F2 extends UnaryFn,
+    ...infer Rest extends UnaryFn[]
+] ? F2 extends (arg: ReturnType<F1>) => unknown ? [F1, ...PipeOps<[F2, ...Rest]>] : [] : T extends [UnaryFn] ? T : [];
+type PipedFn<T extends UnaryFn[]> = (arg: FirstFnArg<T>) => LastFnReturn<T>;
+/**
+ * Creates a function by composing multiple unary functions from left to right.
+ * The output of each function is passed as the input to the next
+ * @param fns Sequence of unary functions to compose
+ * @returns Composed function from left to right
+ */
+declare const pipe: <T extends UnaryFn[]>(...fns: PipeOps<T>) => PipedFn<T>;
+
+/**
+ * Creates a throttled version of the given function that only executes once per specified interval
+ * @param fn Function to throttle
+ * @param interval Minimum time (ms) between calls. Default: 100
+ * @returns Throttled function
+ */
+declare const throttle: <A extends unknown[]>(fn: (...args: A) => void, interval?: number) => (...args: A) => void;
+
+/**
+ * Transforms a function with array argument into one with spread arguments
+ * @param fn Function accepting an array of arguments
+ * @returns Function accepting spread arguments
+ */
+declare const unapply: <T extends unknown[], R>(fn: (arg: T) => R) => (...args: T) => R;
+
+type index$4_CurryFn<R, T extends unknown[]> = CurryFn<R, T>;
+type index$4_PipedFn<T extends UnaryFn[]> = PipedFn<T>;
+declare const index$4_apply: typeof apply;
+declare const index$4_curry: typeof curry;
+declare const index$4_debounce: typeof debounce;
+declare const index$4_identity: typeof identity;
+declare const index$4_memo: typeof memo;
+declare const index$4_noop: typeof noop;
+declare const index$4_once: typeof once;
+declare const index$4_pipe: typeof pipe;
+declare const index$4_throttle: typeof throttle;
+declare const index$4_unapply: typeof unapply;
+declare namespace index$4 {
+  export { index$4_apply as apply, index$4_curry as curry, index$4_debounce as debounce, index$4_identity as identity, index$4_memo as memo, index$4_noop as noop, index$4_once as once, index$4_pipe as pipe, index$4_throttle as throttle, index$4_unapply as unapply };
+  export type { index$4_CurryFn as CurryFn, index$4_PipedFn as PipedFn };
+}
+
+type Quantity = number[] | number;
+type QuantityT<T extends Quantity> = T extends number ? number : number[];
+
+type Calc<A extends Quantity[]> = A extends number[] ? number : number[];
+/**
+ * Creates a function that applies the given operation to any combination of scalars and vectors
+ * @template T Tuple or array of numbers for the operation
+ * @param opFn Operation function to apply to the inputs
+ * @returns Function that takes quantities (scalars or vectors) and returns the calculated result
+ * @example
+ * const fn = calc((a, b, c) => a * b + c);
+ * fn([1, 2], 3, 4); // [7, 10]
+ */
+declare const calc: <T extends number[]>(opFn: (...nums: T) => number) => <A extends ConvertTuple<T, Quantity>>(...q: A) => Calc<A>;
+
+/**
+ * Calculates the sum of given quantities (vectors or scalars)
+ * @param q Quantities to add
+ * @returns Sum of the input quantities
+ * @example
+ * add([-4, 1, 0, 3], 5); // [1, 6, 5, 8]
+ * add([1, 2], [3, 4]); // [4, 6]
+ */
+declare const add: <A extends Quantity[]>(...q: A) => Calc<A>;
+
+/**
+ * Compares if two numbers are approximately equal using a custom precision
+ * @param a First number to compare
+ * @param b Second number to compare
+ * @param precision Number of decimal places to consider. Default: 4
+ * @returns True if numbers are approximately equal, false otherwise
+ */
+declare const aprox: (a: number, b: number, precision?: number) => boolean;
+
+/**
+ * Clamps a number between a minimum and maximum value
+ *
+ * @param x - The number to clamp
+ * @param min - The lower bound
+ * @param max - The upper bound
+ * @returns The clamped value
+ */
+declare const clamp: (x: number, min: number, max: number) => number;
+
+/**
+ * Calculates the cumulative sum of an array of numbers
+ * @param arr Array of numbers to sum
+ * @returns Array of cumulative sums
+ */
+declare const cumsum: (arr: number[]) => number[];
+
+/**
+ * Calculates the division of two quantities (vectors or scalars)
+ * @param a Dividend number or array
+ * @param b Divisor number or array
+ * @returns Division of the input quantities
+ * @example
+ * divide([-4, 1, 0, 3], 2); // [-2, 0.5, 0, 1.5]
+ * divide([1, 2], [3, 4]);   // [1 / 3, 0.5]
+ */
+declare const divide: <A extends [a: Quantity, b: Quantity]>(...q: A) => Calc<A>;
+
+/**
+ * Calculates the linear interpolation of monotonic increasing points (xp, fp) at given x values
+ * @param x Points to interpolate
+ * @param xp Known x-coordinates (must be increasing)
+ * @param fp Known y-coordinates (must be increasing, same size as xp)
+ * @returns Interpolated values at each x
+ */
+declare const interp: (x: number[], xp: number[], fp: number[]) => number[];
+
+/**
+ * Checks if a number is within a half-open range [a, b)
+ * @param n The number to check
+ * @param a Start of the range (inclusive)
+ * @param b End of the range (exclusive). Default: 0
+ * @returns True if n is in [a, b), false otherwise
+ */
+declare const inRange: (n: number, a: number, b?: number) => boolean;
+
+/**
+ * Calculates the mean (average) of an array of numbers. Supports optional weighted mean
+ * @param arr Array of numbers
+ * @param weights Optional array of weights
+ * @returns Mean of the given numbers
+ */
+declare const mean: (arr: number[], weights?: number[]) => number;
+
+/**
+ * Calculates the median of an array of numbers
+ * @param arr Array of numbers
+ * @param weights Optional array of weights
+ * @returns Median of the given numbers
+ */
+declare const median: (arr: number[], weights?: number[]) => number;
+
+/**
+ * Calculates the modulo of two quantities (vectors or scalars)
+ * @param x Dividend number or array
+ * @param modulo Divisor number or array
+ * @returns Remainder of division
+ * @example
+ * mod(5, 3); // 2
+ * mod([2, 3, 4], 3); // [2, 0, 1]
+ * mod([4, 5], [2, 3]); // [0, 2]
+ */
+declare const mod: <A extends [x: Quantity, modulo: Quantity]>(...q: A) => Calc<A>;
+
+/**
+ * Calculates the multiplication of given quantities (vectors or scalars)
+ * @param q Quantities to multiply
+ * @returns Product of the input quantities
+ * @example
+ * multiply([-4, 1, 0, 3], 3); // => [-12, 3, 0, 9]
+ * multiply([1, 2], [3, 4]); // => [3, 8]
+ */
+declare const multiply: <A extends Quantity[]>(...q: A) => Calc<A>;
+
+/**
+ * Calculates the given percentile(s) of an array of numbers
+ * Supports both linear interpolation and weighted percentiles
+ * @param x Array of numbers
+ * @param p Percentile number or array to compute (0–100)
+ * @param weights Optional array of weights (same size as x)
+ * @returns Computed percentile value(s)
+ */
+declare const percentile: <T extends Quantity>(x: number[], p: T, weights?: number[]) => QuantityT<T>;
+
+/**
+ * Calculates the exponentiation of two quantities (vectors or scalars)
+ * @param base Base number or array
+ * @param exp Exponent number or array
+ * @returns base raised to the power of exp
+ */
+declare const pow: <A extends [base: Quantity, exp: Quantity]>(...q: A) => Calc<A>;
+
+/**
+ * Rounds a quantity (vector or scalar) to the specified number of decimal places
+ * @param q Number or array to round
+ * @param precision Number of decimal places to round to. Default: 0
+ * @returns Rounded quantity
+ */
+declare const round: <T extends Quantity>(q: T, precision?: number) => T;
+
+/**
+ * Calculates the subtraction of two quantities (vectors or scalars)
+ * @param a Minuend number or array
+ * @param b Subtrahend number or array
+ * @returns Subtraction of `b` from `a`
+ */
+declare const subtract: <A extends [a: Quantity, b: Quantity]>(...q: A) => Calc<A>;
+
+/**
+ * Calculates the sum of an array of numbers
+ * @param arr Numbers to sum
+ * @returns Sum of all numbers in the array
+ */
+declare const sum: (arr: number[]) => number;
+
+type index$3_Calc<A extends Quantity[]> = Calc<A>;
+declare const index$3_add: typeof add;
+declare const index$3_aprox: typeof aprox;
+declare const index$3_calc: typeof calc;
+declare const index$3_clamp: typeof clamp;
+declare const index$3_cumsum: typeof cumsum;
+declare const index$3_divide: typeof divide;
+declare const index$3_inRange: typeof inRange;
+declare const index$3_interp: typeof interp;
+declare const index$3_mean: typeof mean;
+declare const index$3_median: typeof median;
+declare const index$3_mod: typeof mod;
+declare const index$3_multiply: typeof multiply;
+declare const index$3_percentile: typeof percentile;
+declare const index$3_pow: typeof pow;
+declare const index$3_round: typeof round;
+declare const index$3_subtract: typeof subtract;
+declare const index$3_sum: typeof sum;
+declare namespace index$3 {
+  export { index$3_add as add, index$3_aprox as aprox, index$3_calc as calc, index$3_clamp as clamp, index$3_cumsum as cumsum, index$3_divide as divide, index$3_inRange as inRange, index$3_interp as interp, index$3_mean as mean, index$3_median as median, index$3_mod as mod, index$3_multiply as multiply, index$3_percentile as percentile, index$3_pow as pow, index$3_round as round, index$3_subtract as subtract, index$3_sum as sum };
+  export type { index$3_Calc as Calc };
+}
+
+/**
+ * Creates a deep copy of the provided object or array
+ * @param obj Object or array to copy
+ * @returns Deep copy of the input
+ */
+declare const copy: <T>(obj: T) => T;
+
+type Entry<T extends object> = [Key<T>, Val<T>];
+type Key<T extends object> = keyof T;
+type Val<T extends object> = T[keyof T];
+
+/**
+ * Retrieves a strongly-typed array of the entries (key, value) of an object
+ * @param obj Object whose entries are to be retrieved
+ * @returns Array of key-value pairs from the object
+ */
+declare const entries: <T extends object>(obj: T) => Entry<T>[];
+
+/**
+ * Performs a deep comparison between multiple objects to determine if they are equal
+ * @param objs Objects to compare
+ * @returns True if all objects are deeply equal, false otherwise
+ */
+declare const equal: (...args: unknown[]) => boolean;
+
+/**
+ * Gets a value at a nested path of an object or array
+ * @param obj Source object
+ * @param path Dot-separated path string
+ * @param fallback Value to return if the path is not found
+ * @returns Value at the specified path or the fallback
+ */
+declare const get: <T>(obj: object, path: string, fallback?: T | undefined) => T;
+
+/**
+ * Checks if an object has all specified properties
+ * @param obj Object to check
+ * @param keys Property keys to look for
+ * @returns True if all keys exist on the object, false otherwise
+ */
+declare const has: <K extends PropertyKey>(obj: object, ...keys: K[]) => obj is Record<K, unknown>;
+
+/**
+ * Checks if the provided value is a non-null object
+ * @param el Value to check
+ * @returns True if `el` is a non-null object, otherwise false
+ */
+declare const isObj: (el: unknown) => el is object;
+
+/**
+ * Retrieves a strongly-typed array of the keys of an object
+ * @param obj Object whose keys are to be retrieved
+ * @returns Array of the object's keys
+ */
+declare const keys: <T extends object>(obj: T) => (keyof T)[];
+
+/**
+ * Creates a strongly-typed object from the shallow merge of deep copies of two objects
+ * If both objects have the same property, the value from the second object overwrites the first
+ * @param a First object to merge
+ * @param b Second object to merge
+ * @returns The merged object with properties from both a and b
+ */
+declare const merge: <A extends object, B extends object>(a: A, b: B) => A & B;
+
+/**
+ * Creates a deep copy of an object without the specified keys
+ * @param obj Source object
+ * @param keys Array of keys to omit from the result
+ * @returns New object without the specified keys
+ */
+declare const omit: <T, K extends keyof T>(obj: T, keys: K[]) => Omit<T, K>;
+
+/**
+ * Creates a deep copy of an object with only the specified keys
+ * @param obj Source object
+ * @param keys Array of keys to pick from the object
+ * @returns New object with only the picked keys
+ */
+declare const pick: <T, K extends keyof T>(obj: T, keys: K[]) => Pick<T, K>;
+
+type SetPath<Obj extends object, P extends string, Val> = P extends `${infer K}.${infer Rest}` ? {
+    [Key in K | keyof Obj]: Key extends K ? Rest extends [] ? Val : SetPath<Key extends keyof Obj ? Obj[Key] extends object ? Obj[Key] : object : object, Rest, Val> : Key extends keyof Obj ? Obj[Key] : never;
+} : Obj;
+/**
+ * Sets a value at a nested path of an object, creating nested objects if needed
+ * @param obj Target object to modify
+ * @param path Dot-separated string path where the value should be set
+ * @param value Value to set at the specified path
+ * @returns Modified object with the value set at the given path
+ */
+declare const set: <T extends object, P extends string, V>(obj: T, path: P, value: V) => SetPath<T, P, V>;
+
+/**
+ * Retrieves a strongly-typed array of the values of an object
+ * @param obj Source object
+ * @returns Array of the object's values
+ */
+declare const vals: <T extends object>(obj: T) => Val<T>[];
+
+type index$2_SetPath<Obj extends object, P extends string, Val> = SetPath<Obj, P, Val>;
+declare const index$2_copy: typeof copy;
+declare const index$2_entries: typeof entries;
+declare const index$2_equal: typeof equal;
+declare const index$2_get: typeof get;
+declare const index$2_has: typeof has;
+declare const index$2_isObj: typeof isObj;
+declare const index$2_keys: typeof keys;
+declare const index$2_merge: typeof merge;
+declare const index$2_omit: typeof omit;
+declare const index$2_pick: typeof pick;
+declare const index$2_set: typeof set;
+declare const index$2_vals: typeof vals;
+declare namespace index$2 {
+  export { index$2_copy as copy, index$2_entries as entries, index$2_equal as equal, index$2_get as get, index$2_has as has, index$2_isObj as isObj, index$2_keys as keys, index$2_merge as merge, index$2_omit as omit, index$2_pick as pick, index$2_set as set, index$2_vals as vals };
+  export type { index$2_SetPath as SetPath };
+}
+
+/**
+ * Returns a random integer between two numbers
+ * @param a Lower bound (inclusive)
+ * @param b Upper bound (exclusive). Default: 0
+ * @returns Random integer between a and b
+ */
+declare const randInt: (a: number, b?: number) => number;
+
+/**
+ * Selects a random index based on the provided weights
+ * @param weights Array of non-negative weights
+ * @returns Selected index
+ */
+declare const randWeight: (weights: number[]) => number;
+
+/**
+ * Samples elements from an array randomly, optionally using weights to influence selection
+ * @param data Array to sample from
+ * @param size Number of elements to sample
+ * @param weights Optional array of weights for weighted sampling
+ * @returns New array containing the sampled elements
+ */
+declare const sample: <T>(data: T[], size: number, weights?: number[] | undefined) => T[];
+
+/**
+ * Shuffles an array randomly, optionally using weights to influence the
+ * likelihood of selecting elements first
+ * @param data Array to shuffle
+ * @param weights Optional array of weights for weighted shuffling
+ * @returns New array with the elements shuffled
+ */
+declare const shuffle: <T>(data: T[], weights?: number[]) => T[];
+
+declare const index$1_randInt: typeof randInt;
+declare const index$1_randWeight: typeof randWeight;
+declare const index$1_sample: typeof sample;
+declare const index$1_shuffle: typeof shuffle;
+declare namespace index$1 {
+  export {
+    index$1_randInt as randInt,
+    index$1_randWeight as randWeight,
+    index$1_sample as sample,
+    index$1_shuffle as shuffle,
+  };
+}
+
+/**
+ * Converts a string to camelCase
+ * @param str String to convert
+ * @returns camelCase version of the input string
+ */
+declare const camel: (str: string) => string;
+
+/**
+ * Capitalizes the first letter of a string and converts the rest to lowercase
+ * @param str String to capitalize
+ * @returns Capitalized string
+ */
+declare const capitalize: (str: string) => string;
+
+/**
+ * Converts a string to kebab-case
+ * @param str String to convert
+ * @returns kebab-case version of the input string
+ */
+declare const kebab: (str: string) => string;
+
+/**
+ * Converts a string to PascalCase
+ * @param str String to convert
+ * @returns PascalCase version of the input string
+ */
+declare const pascal: (str: string) => string;
+
+/**
+ * Converts a string to snake_case
+ * @param str String to convert
+ * @returns snake_case version of the input string
+ */
+declare const snake: (str: string) => string;
+
+type Split<S extends string, D extends string> = S extends `${infer T}${D}${infer U}` ? [T, ...Split<U, D>] : [S];
+/**
+ * Splits a string by the specified delimiter and returns a typed array
+ *
+ * @param str - The string to split
+ * @param delimiter - The delimiter to split by
+ * @returns The array (tuple) of substrings
+ */
+declare const split: <S extends string, D extends string>(str: S, delimiter: D) => Split<S, D>;
+
+/**
+ * Replaces placeholders in the format `{{path.to.value}}` within a string
+ * with corresponding values from the provided data object
+ * @param str String containing placeholders to replace
+ * @param data Object with values for the placeholders
+ * @returns String with placeholders replaced by their values
+ */
+declare const template: (str: string, data: object) => string;
+
+/**
+ * Removes leading and trailing whitespace or specified characters from a string
+ * @param str String to trim
+ * @param chars Optional characters to trim from the string. Default: whitespace
+ * @returns Trimmed string
+ */
+declare const trim: (str: string, chars?: string) => string;
+
+type index_Split<S extends string, D extends string> = Split<S, D>;
+declare const index_camel: typeof camel;
+declare const index_capitalize: typeof capitalize;
+declare const index_kebab: typeof kebab;
+declare const index_pascal: typeof pascal;
+declare const index_snake: typeof snake;
+declare const index_split: typeof split;
+declare const index_template: typeof template;
+declare const index_trim: typeof trim;
+declare namespace index {
+  export { index_camel as camel, index_capitalize as capitalize, index_kebab as kebab, index_pascal as pascal, index_snake as snake, index_split as split, index_template as template, index_trim as trim };
+  export type { index_Split as Split };
+}
+
+type TimeFormat = "date" | "full" | "time";
+type TimeFormatOptions = Record<TimeFormat, Intl.DateTimeFormatOptions>;
+type TimeUnit = "d" | "h" | "m" | "ms" | "s";
+
+/**
+ * @deprecated Time module is deprecated and may be removed in future releases
+ */
+declare class Time {
+    static UNITS: Record<TimeUnit, number>;
+    static formatOptions: TimeFormatOptions;
+    static locales?: Intl.LocalesArgument;
+    private readonly date;
+    constructor(val?: number, unit?: TimeUnit);
+    static convert(val: number, from: TimeUnit, to?: TimeUnit): number;
+    add(val: number, unit?: TimeUnit): number;
+    format(mode?: TimeFormat, local?: Intl.LocalesArgument, opts?: Intl.DateTimeFormatOptions): string;
+    get(unit?: TimeUnit): number;
+    getDayTime(unit?: TimeUnit): number;
+    set(val: number, unit?: TimeUnit): number;
+    setDayTime(val: number, unit?: TimeUnit): number;
+    toDate(): Date;
+}
+
+export { Time, add, apply, aprox, index$5 as arr, binSearch, calc, camel, capitalize, chunk, clamp, copy, countBy, cumsum, curry, debounce, divide, entries, equal, fill, find, findAll, findAllIdx, findIdx, first, from, index$4 as func, get, group, groupBy, has, identity, inRange, interp, isObj, kebab, keys, last, index$3 as math, max, mean, median, memo, merge, min, mod, multiply, noop, index$2 as obj, omit, once, pascal, percentile, pick, pipe, pow, index$1 as rand, randInt, randWeight, range, round, sample, set, shuffle, snake, sort, split, index as str, subtract, sum, template, throttle, transpose, trim, unapply, union, unique, vals, zip };
+export type { Calc, ConvertTuple, CurryFn, Entry, First, Key, Last, Literal, Nullish, PipedFn, Predicate, Primitive, Quantity, QuantityT, SetPath, Split, TimeFormat, TimeFormatOptions, TimeUnit, Transpose, Tuple, Val };