litus 1.3.1 → 1.5.0

package/dist/index.cjs.js

@@ -0,0 +1,1206 @@
+'use strict';
+
+/**
+ * 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
+ */
+const binSearch = (arr, target, getVal, start = 0, end = arr.length) => {
+    if (start < 0 || end > arr.length || start > end) {
+        throw new Error("Invalid start or end of search");
+    }
+    let a = start;
+    let b = end;
+    while (a < b) {
+        const mid = Math.floor((a + b) / 2);
+        const midVal = getVal(arr[mid]);
+        if (midVal < target) {
+            a = mid + 1;
+        }
+        else {
+            b = mid;
+        }
+    }
+    return 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
+ */
+const from = (n, mapFn) => {
+    const res = Array(n);
+    let i = n;
+    while (--i >= 0) {
+        res[i] = mapFn(i);
+    }
+    return res;
+};
+
+/**
+ * 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 is 1)
+ * @returns Array of numbers in the specified range
+ */
+const range = (a, b, step = 1) => {
+    if (step === 0) {
+        throw new Error("Step cannot be 0");
+    }
+    const n = Math.ceil((b - a) / step);
+    return from(n, (i) => a + step * i);
+};
+
+/**
+ * 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
+ */
+const chunk = (arr, size) => {
+    if (!Number.isInteger(size)) {
+        throw new Error("Chunk size must be an integer");
+    }
+    return range(0, arr.length, size).map((i) => arr.slice(i, i + size));
+};
+
+/**
+ * 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
+ */
+const fill = (n, val) => {
+    return from(n, () => val);
+};
+
+/**
+ * Finds the index of the first element that matches the given predicate
+ * @param arr Array to search
+ * @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
+ */
+const findIdx = (arr, predicate, from = 0, to = arr.length) => {
+    for (let i = from; i < to; i++) {
+        if (predicate(arr[i], i, arr)) {
+            return i;
+        }
+    }
+    return -1;
+};
+
+/**
+ * Finds the first element that matches the given predicate
+ * @param arr Array to search
+ * @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
+ */
+const find = (arr, predicate, from = 0, to = arr.length) => {
+    return arr[findIdx(arr, predicate, from, to)];
+};
+
+/**
+ * Finds indices of all elements that match the given predicate
+ * @param arr Array to search
+ * @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
+ */
+const findAllIdx = (arr, predicate, from = 0, to = arr.length, limit = arr.length) => {
+    const res = [];
+    for (let i = from; i < to; i++) {
+        if (predicate(arr[i], i, arr)) {
+            res.push(i);
+            if (res.length >= limit) {
+                break;
+            }
+        }
+    }
+    return res;
+};
+
+/**
+ * Finds all elements that match the given predicate
+ * @param arr Array to search
+ * @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
+ */
+const findAll = (arr, predicate, from = 0, to = arr.length, limit = arr.length) => {
+    return findAllIdx(arr, predicate, from, to, limit).map((i) => arr[i]);
+};
+
+/**
+ * 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
+ */
+const group = (arr, getKey) => {
+    const res = {};
+    arr.forEach((el) => {
+        const val = getKey(el);
+        if (res[val] === undefined) {
+            res[val] = [];
+        }
+        res[val].push(el);
+    });
+    return res;
+};
+
+/**
+ * @deprecated Use `group` instead
+ */
+const groupBy = (arr, key) => {
+    return group(arr, (obj) => obj[key]);
+};
+
+/**
+ * Returns the element with the maximum value based on the provided map function
+ * @param arr Array to search
+ * @param fn Function to extract the value for comparison
+ * @returns Element with the maximum value
+ */
+const max = (arr, fn) => {
+    const scores = arr.map(fn);
+    let maxIdx = 0;
+    for (let i = 1; i < scores.length; i++) {
+        if (scores[i] > scores[maxIdx]) {
+            maxIdx = i;
+        }
+    }
+    return arr[maxIdx];
+};
+
+/**
+ * Returns the element with the minimum value based on the provided map function
+ * @param arr Array to search
+ * @param fn Function to extract the value for comparison
+ * @returns Element with the minimum value
+ */
+const min = (arr, fn) => {
+    return max(arr, (val) => -fn(val));
+};
+
+/**
+ * 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
+ */
+const sort = (arr, mapFn) => {
+    const mapped = arr.map((el) => [mapFn(el), el]);
+    mapped.sort(([a], [b]) => {
+        if (a < b) {
+            return -1;
+        }
+        if (a > b) {
+            return 1;
+        }
+        return 0;
+    });
+    mapped.forEach(([, el], i) => {
+        arr[i] = el;
+    });
+    return arr;
+};
+
+/**
+ * Transposes a 2D array (matrix), switching its rows and columns
+ * @param matrix The 2D array to transpose
+ * @returns Transposed matrix
+ */
+const transpose = (matrix) => {
+    const rows = matrix.length;
+    const cols = matrix[0].length;
+    if (matrix.some((row) => row.length !== cols)) {
+        throw new Error("Invalid matrix. Rows have different size");
+    }
+    const res = from(cols, (i) => from(rows, (j) => matrix[j][i]));
+    return res;
+};
+
+/**
+ * Creates a set containing unique values from all provided arrays
+ * @param arrs Arrays to union
+ * @returns Set of unique values
+ */
+const union = (...arrs) => {
+    return new Set(arrs.flat(1));
+};
+
+/**
+ * Creates array of unique values from the input array, preserving their order
+ * @param arr Array of primitive values
+ * @returns Array of unique values
+ */
+const unique = (arr) => {
+    const set = Array.from(new Set(arr));
+    return sort(set, (el) => arr.indexOf(el));
+};
+
+/**
+ * Transforms a function with array argument into one with spread arguments
+ * @param fn Function accepting an array of arguments
+ * @returns Function accepting spread arguments
+ */
+const unapply = (fn) => {
+    return (...args) => fn(args);
+};
+
+/**
+ * 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
+ */
+const zip = unapply(transpose);
+
+const index$5 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    binSearch: binSearch,
+    chunk: chunk,
+    fill: fill,
+    find: find,
+    findAll: findAll,
+    findAllIdx: findAllIdx,
+    findIdx: findIdx,
+    from: from,
+    group: group,
+    groupBy: groupBy,
+    max: max,
+    min: min,
+    range: range,
+    sort: sort,
+    transpose: transpose,
+    union: union,
+    unique: unique,
+    zip: zip
+});
+
+/**
+ * Transforms a function with spread arguments into one with array argument
+ * @param fn Function accepting spread arguments
+ * @returns Function accepting an array of arguments
+ */
+const apply = (fn) => {
+    return (arg) => fn.apply(undefined, arg);
+};
+
+/**
+ * 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
+ */
+const curry = (fn, arity = fn.length) => {
+    return (...args) => {
+        const missing = arity - args.length;
+        if (missing <= 0) {
+            return fn.apply(undefined, args);
+        }
+        return curry((...rArgs) => {
+            return fn.apply(undefined, args.concat(rArgs));
+        }, missing);
+    };
+};
+
+/**
+ * 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
+ */
+const debounce = (fn, delay = 100) => {
+    let timer;
+    return (...args) => {
+        clearTimeout(timer);
+        timer = setTimeout(() => {
+            fn.apply(undefined, args);
+        }, delay);
+    };
+};
+
+/**
+ * Returns the input value unchanged
+ * @param value Value to return
+ * @returns Same value provided as input
+ */
+const identity = (x) => x;
+
+/**
+ * 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
+ */
+const memo = (fn, idFn = JSON.stringify, ttl = 0) => {
+    const cache = new Map();
+    return (...args) => {
+        const key = idFn(args);
+        const cached = cache.get(key);
+        if (cached !== undefined) {
+            if (cached.exp === undefined || Date.now() < cached.exp) {
+                return cached.val;
+            }
+        }
+        const val = fn.apply(undefined, args);
+        const exp = ttl <= 0 ? undefined : Date.now() + ttl;
+        cache.set(key, { exp, val });
+        return val;
+    };
+};
+
+/**
+ * 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
+ */
+const once = (fn) => {
+    let call = true;
+    let res;
+    return () => {
+        if (call) {
+            res = fn();
+            call = false;
+        }
+        return res;
+    };
+};
+
+/**
+ * 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
+ */
+const pipe = (...fns) => {
+    return ((input) => {
+        return fns.reduce((acc, fn) => fn(acc), input);
+    });
+};
+
+/**
+ * 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
+ */
+const throttle = (fn, interval = 100) => {
+    let wait = false;
+    return (...args) => {
+        if (wait) {
+            return;
+        }
+        wait = true;
+        fn.apply(undefined, args);
+        setTimeout(() => {
+            wait = false;
+        }, interval);
+    };
+};
+
+const index$4 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    apply: apply,
+    curry: curry,
+    debounce: debounce,
+    identity: identity,
+    memo: memo,
+    once: once,
+    pipe: pipe,
+    throttle: throttle,
+    unapply: unapply
+});
+
+/**
+ * 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]
+ */
+const calc = (opFn) => {
+    return (...arr) => {
+        const vectors = arr.filter((el) => typeof el !== "number");
+        if (vectors.length === 0) {
+            return opFn.apply(undefined, arr);
+        }
+        const size = vectors[0].length;
+        if (vectors.some((v) => v.length !== size)) {
+            throw new Error("All vectors must have same length");
+        }
+        return from(size, (i) => {
+            const input = arr.map((el) => (typeof el === "number" ? el : el[i]));
+            return opFn.apply(undefined, input);
+        });
+    };
+};
+
+/**
+ * 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]
+ */
+const add = calc((...arr) => arr.reduce((acc, el) => acc + el, 0));
+
+const _round = (n, p) => {
+    const k = Math.pow(10, p);
+    return Math.round(n * k) / k;
+};
+/**
+ * Rounds a quantity (vector or scalar) to the specified number of decimal places
+ * @param q Quantity to round
+ * @param precision Number of decimal places to round to. Default: 0
+ * @returns Rounded quantity
+ */
+const round = (q, precision = 0) => {
+    if (typeof q === "number") {
+        return _round(q, precision);
+    }
+    return q.map((el) => _round(el, precision));
+};
+
+/**
+ * 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
+ */
+const aprox = (a, b, precision = 4) => {
+    return round(a, precision) === round(b, precision);
+};
+
+/**
+ * Calculates the cumulative sum of an array of numbers
+ * @param arr Array of numbers to sum
+ * @returns Array of cumulative sums
+ */
+const cumsum = (arr) => {
+    const res = Array(arr.length);
+    res[0] = arr[0];
+    for (let i = 1; i < arr.length; i++) {
+        res[i] = res[i - 1] + arr[i];
+    }
+    return res;
+};
+
+/**
+ * Calculates the division of two quantities (vectors or scalars)
+ * @param a Dividend(s)
+ * @param b Divisor(s)
+ * @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]
+ */
+const divide = calc((a, b) => a / b);
+
+/**
+ * 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 length as xp)
+ * @returns Interpolated values at each x
+ */
+const interp = (x, xp, fp) => {
+    if (xp.length !== fp.length) {
+        throw new Error("xp and fp must have the same length");
+    }
+    return x.map((xi) => {
+        if (xi >= xp[xp.length - 1]) {
+            return fp[fp.length - 1];
+        }
+        const i = binSearch(xp, xi, (el) => el);
+        if (i === 0) {
+            return fp[0];
+        }
+        const slope = (fp[i] - fp[i - 1]) / (xp[i] - xp[i - 1]);
+        return fp[i - 1] + slope * (xi - xp[i - 1]);
+    });
+};
+
+/**
+ * Checks if a number is within a half-open range [a, b)
+ * @param n The number to check
+ * @param a Start of the range
+ * @param b End of the range. Default: 0
+ * @returns True if n is in [a, b), false otherwise
+ */
+const inRange = (n, a, b = 0) => {
+    if (a > b) {
+        return inRange(n, b, a);
+    }
+    return n >= a && n < b;
+};
+
+/**
+ * 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]
+ */
+const multiply = calc((...arr) => arr.reduce((acc, el) => acc * el, 1));
+
+/**
+ * Calculates the sum of an array of numbers
+ * @param arr Numbers to sum
+ * @returns Sum of all numbers in the array
+ */
+const sum = (arr) => {
+    return arr.reduce((acc, el) => acc + el, 0);
+};
+
+/**
+ * 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 numbers
+ */
+const mean = (arr, weights) => {
+    if (weights === undefined) {
+        return sum(arr) / arr.length;
+    }
+    if (arr.length !== weights.length) {
+        throw new Error("Nums and weights must have the same length");
+    }
+    return sum(multiply(arr, weights)) / sum(weights);
+};
+
+const _linear = (x, p) => {
+    const Pnorm = divide(p, 100);
+    const step = 1 / (x.length - 1);
+    const xp = range(0, 1 + step, step);
+    return interp(Pnorm, xp, x.sort());
+};
+const _weighted = (x, p, w) => {
+    if (w.length !== x.length) {
+        throw new Error("Weights must be the same length as the array");
+    }
+    else if (w.some((v) => v < 0)) {
+        throw new Error("Weights must be non-negative");
+    }
+    const X = sort(transpose([x, w]), (el) => el[0]);
+    const [Xsorted, Wsorted] = transpose(X);
+    const Wcum = cumsum(Wsorted);
+    const Wtotal = Wcum[Wcum.length - 1];
+    const Wnorm = divide(Wcum, Wtotal);
+    const Pnorm = divide(p, 100);
+    let i = 0;
+    return Pnorm.map((pi) => {
+        i = binSearch(Wnorm, pi, (el) => el, i);
+        return Xsorted[i];
+    });
+};
+/**
+ * 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(s) to compute (number or array of numbers, 0–100)
+ * @param weights Optional array of weights (same length as x)
+ * @returns Computed percentile value(s)
+ */
+const percentile = (x, p, weights) => {
+    if (typeof p === "number") {
+        return percentile(x, [p], weights)[0];
+    }
+    if (p.some((v) => v < 0 || v > 100)) {
+        throw new Error("Percentiles must be between 0 and 100");
+    }
+    if (weights === undefined) {
+        return _linear(x, p);
+    }
+    return _weighted(x, p, weights);
+};
+
+/**
+ * Calculates the median of an array of numbers
+ * @param arr Array of numbers
+ * @param weights Optional array of weights
+ * @returns Median value
+ */
+const median = (arr, weights) => {
+    return percentile(arr, 50, weights);
+};
+
+/**
+ * Calculates the modulo of two quantities (vectors or scalars)
+ * @param x Dividend(s)
+ * @param modulo Divisor(s)
+ * @returns Modulo, matching the input shape
+ * @example
+ * mod(5, 3); // 2
+ * mod([2, 3, 4], 3); // [2, 0, 1]
+ * mod([4, 5], [2, 3]); // [0, 2]
+ */
+const mod = calc((x, modulo) => {
+    const m = Math.abs(modulo);
+    return ((x % m) + m) % m;
+});
+
+/**
+ * Calculates the exponentiation of two quantities (vectors or scalars)
+ * @param base Base quantity
+ * @param exp Exponent quantity
+ * @returns base raised to the power of exp
+ */
+const pow = calc((base, exp) => Math.pow(base, exp));
+
+/**
+ * Calculates the subtraction of two quantities (vectors or scalars)
+ * @param a Minuend quantity
+ * @param b Subtrahend quantity
+ * @returns Subtraction of `b` from `a`
+ */
+const subtract = calc((a, b) => a - b);
+
+const index$3 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    add: add,
+    aprox: aprox,
+    calc: calc,
+    cumsum: cumsum,
+    divide: divide,
+    inRange: inRange,
+    interp: interp,
+    mean: mean,
+    median: median,
+    mod: mod,
+    multiply: multiply,
+    percentile: percentile,
+    pow: pow,
+    round: round,
+    subtract: subtract,
+    sum: sum
+});
+
+/**
+ * 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
+ */
+const entries = Object.entries;
+
+/**
+ * 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
+ */
+const isObj = (el) => {
+    return typeof el === "object" && el !== null;
+};
+
+/**
+ * Creates a deep copy of the provided object or array
+ * @param obj Object or array to copy
+ * @returns Deep copy of the input
+ */
+const copy = (obj) => {
+    if (!isObj(obj)) {
+        return obj;
+    }
+    const res = (Array.isArray(obj) ? [] : {});
+    entries(obj).forEach(([key, val]) => {
+        res[key] = copy(val);
+    });
+    return res;
+};
+
+/**
+ * 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
+ */
+const keys = Object.keys;
+
+const deepEqual = (args) => {
+    if (args.every((arg) => arg === args[0])) {
+        return true;
+    }
+    if (!args.every(isObj)) {
+        return false;
+    }
+    const objs = args;
+    const objsKeys = objs.map(keys);
+    if (!deepEqual(objsKeys.map((key) => key.length))) {
+        return false;
+    }
+    const keysUnion = union.apply(undefined, objsKeys);
+    if (keysUnion.size !== objsKeys[0].length) {
+        return false;
+    }
+    return objsKeys[0].every((key) => {
+        const vals = objs.map((obj) => obj[key]);
+        return deepEqual(vals);
+    });
+};
+/**
+ * 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
+ */
+const equal = unapply(deepEqual);
+
+/**
+ * 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
+ */
+const has = (obj, ...keys) => {
+    return keys.every((key) => Object.prototype.hasOwnProperty.call(obj, key));
+};
+
+/**
+ * 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
+ */
+const get = (obj, path, fallback) => {
+    let val = obj;
+    for (const key of path.split(".")) {
+        if (isObj(val) && has(val, key)) {
+            val = val[key];
+        }
+        else {
+            return fallback;
+        }
+    }
+    return val;
+};
+
+/**
+ * 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
+ */
+const merge = (a, b) => {
+    return Object.assign(copy(a), copy(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
+ */
+const omit = (obj, keys) => {
+    const newObj = copy(obj);
+    for (const key of keys) {
+        delete newObj[key];
+    }
+    return newObj;
+};
+
+/**
+ * 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
+ */
+const pick = (obj, keys) => {
+    const res = {};
+    for (const key of keys) {
+        res[key] = copy(obj[key]);
+    }
+    return res;
+};
+
+/**
+ * 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
+ */
+const set = (obj, path, value) => {
+    let val = obj;
+    const keys = path.split(".");
+    const end = keys.length - 1;
+    for (let i = 0; i < end; i++) {
+        const key = keys[i];
+        if (!isObj(val[key])) {
+            val[key] = {};
+        }
+        val = val[key];
+    }
+    val[keys[end]] = value;
+    return obj;
+};
+
+/**
+ * Retrieves a strongly-typed array of the values of an object
+ * @param obj Source object
+ * @returns Array of the object's values
+ */
+const vals = Object.values;
+
+const index$2 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    copy: copy,
+    entries: entries,
+    equal: equal,
+    get: get,
+    has: has,
+    isObj: isObj,
+    keys: keys,
+    merge: merge,
+    omit: omit,
+    pick: pick,
+    set: set,
+    vals: vals
+});
+
+/**
+ * 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
+ */
+const randInt = (a, b = 0) => {
+    if (!Number.isInteger(a) || !Number.isInteger(b)) {
+        throw Error("a and b must be integers");
+    }
+    return Math.floor(Math.random() * (b - a) + a);
+};
+
+/**
+ * Selects a random index based on the provided weights
+ * @param weights Array of non-negative weights
+ * @returns Selected index
+ */
+const randWeight = (weights) => {
+    if (weights.length === 0) {
+        throw new Error("Weights array cannot be empty");
+    }
+    if (weights.some((w) => w < 0)) {
+        throw new Error("Weights array cannot contain negative values");
+    }
+    const wAccum = cumsum(weights);
+    const wTotal = wAccum[wAccum.length - 1];
+    if (wTotal === 0) {
+        throw new Error("Total weight must be greater than zero");
+    }
+    const r = Math.random() * wTotal;
+    return binSearch(wAccum, r, (el) => el);
+};
+
+const op = (arr, size, pick) => {
+    const n = Math.min(size, arr.length);
+    const res = arr.slice();
+    const end = res.length - n;
+    for (let i = res.length - 1; i > end; i--) {
+        const idx = pick(i + 1);
+        [res[i], res[idx]] = [res[idx], res[i]];
+    }
+    return n === arr.length ? res : res.slice(0, n);
+};
+const fisherYates = (data, size, weights) => {
+    if (size <= 0) {
+        return [];
+    }
+    if (weights === undefined) {
+        return op(data, size, (n) => Math.floor(Math.random() * n));
+    }
+    if (weights.length !== data.length) {
+        throw new Error("Weights must have the same length as the data array");
+    }
+    if (weights.some((w) => w < 0)) {
+        throw new Error("Weights cannot contain negative values.");
+    }
+    const w = weights.slice();
+    return op(data, size, () => {
+        const idx = randWeight(w);
+        w[idx] = 0;
+        return idx;
+    });
+};
+
+/**
+ * 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
+ */
+const sample = fisherYates;
+
+/**
+ * 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
+ */
+const shuffle = (data, weights) => {
+    return fisherYates(data, data.length, weights);
+};
+
+const index$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    randInt: randInt,
+    randWeight: randWeight,
+    sample: sample,
+    shuffle: shuffle
+});
+
+const words = (str) => {
+    return str
+        .replace(/([a-z])([A-Z])/g, "$1 $2") // Split camelCase and PascalCase
+        .replace(/([A-Z])([A-Z][a-z])/g, "$1 $2") // Split UPPERPascal > UPPER Pascal
+        .replace(/([0-9]+)/g, " $1 ")
+        .split(/[_-\s]+/)
+        .filter(Boolean);
+};
+
+/**
+ * Capitalizes the first letter of a string and converts the rest to lowercase
+ * @param str String to capitalize
+ * @returns Capitalized string
+ */
+const capitalize = (str) => {
+    return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+};
+
+/**
+ * Converts a string to camelCase
+ * @param str String to convert
+ * @returns camelCase version of the input string
+ */
+const camel = (str) => {
+    const w = words(str).map(capitalize);
+    if (w.length === 0) {
+        return "";
+    }
+    w[0] = w[0].toLowerCase();
+    return w.join("");
+};
+
+/**
+ * Converts a string to kebab-case
+ * @param str String to convert
+ * @returns kebab-case version of the input string
+ */
+const kebab = (str) => {
+    return words(str)
+        .map((str) => str.toLowerCase())
+        .join("-");
+};
+
+/**
+ * Converts a string to PascalCase
+ * @param str String to convert
+ * @returns PascalCase version of the input string
+ */
+const pascal = (str) => {
+    return words(str).map(capitalize).join("");
+};
+
+/**
+ * Converts a string to snake_case
+ * @param str String to convert
+ * @returns snake_case version of the input string
+ */
+const snake = (str) => {
+    return words(str)
+        .map((str) => str.toLowerCase())
+        .join("_");
+};
+
+/**
+ * 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
+ */
+const template = (str, data) => {
+    return str.replace(/\{\{([a-zA-Z0-9._]+)\}\}/g, (_, path) => {
+        return get(data, path, "");
+    });
+};
+
+/**
+ * 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
+ */
+const trim = (str, chars = " ") => {
+    const reg = new RegExp(`^[${chars}]+|[${chars}]+$`, "g");
+    return str.replace(reg, "");
+};
+
+const index = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    camel: camel,
+    capitalize: capitalize,
+    kebab: kebab,
+    pascal: pascal,
+    snake: snake,
+    template: template,
+    trim: trim
+});
+
+/**
+ * @deprecated Time module is deprecated and may be removed in future releases
+ */
+class Time {
+    constructor(val, unit = "ms") {
+        this.date = new Date();
+        if (val !== undefined) {
+            this.set(val, unit);
+        }
+    }
+    static convert(val, from, to = "ms") {
+        const ms = Math.round(Time.UNITS[from] * val);
+        return ms / Time.UNITS[to];
+    }
+    add(val, unit = "ms") {
+        return this.set(this.get(unit) + val, unit);
+    }
+    format(mode = "full", local = Time.locales, opts = {}) {
+        const options = merge(Time.formatOptions[mode], opts);
+        return this.date.toLocaleString(local, options);
+    }
+    get(unit = "ms") {
+        return Time.convert(this.date.getTime(), "ms", unit);
+    }
+    getDayTime(unit = "ms") {
+        return Time.convert(this.get("d") % 1, "d", unit);
+    }
+    set(val, unit = "ms") {
+        return this.date.setTime(Time.convert(val, unit));
+    }
+    setDayTime(val, unit = "ms") {
+        return this.add(val - this.getDayTime(unit), unit);
+    }
+    toDate() {
+        return new Date(this.date);
+    }
+}
+Time.UNITS = {
+    d: 864e5,
+    h: 36e5,
+    m: 6e4,
+    ms: 1,
+    s: 1e3
+};
+Time.formatOptions = {
+    date: {
+        dateStyle: "medium"
+    },
+    full: {
+        dateStyle: "short",
+        timeStyle: "short"
+    },
+    time: {
+        timeStyle: "medium"
+    }
+};
+
+exports.Time = Time;
+exports.add = add;
+exports.apply = apply;
+exports.aprox = aprox;
+exports.arr = index$5;
+exports.binSearch = binSearch;
+exports.calc = calc;
+exports.camel = camel;
+exports.capitalize = capitalize;
+exports.chunk = chunk;
+exports.copy = copy;
+exports.cumsum = cumsum;
+exports.curry = curry;
+exports.debounce = debounce;
+exports.divide = divide;
+exports.entries = entries;
+exports.equal = equal;
+exports.fill = fill;
+exports.find = find;
+exports.findAll = findAll;
+exports.findAllIdx = findAllIdx;
+exports.findIdx = findIdx;
+exports.from = from;
+exports.func = index$4;
+exports.get = get;
+exports.group = group;
+exports.groupBy = groupBy;
+exports.has = has;
+exports.identity = identity;
+exports.inRange = inRange;
+exports.interp = interp;
+exports.isObj = isObj;
+exports.kebab = kebab;
+exports.keys = keys;
+exports.math = index$3;
+exports.max = max;
+exports.mean = mean;
+exports.median = median;
+exports.memo = memo;
+exports.merge = merge;
+exports.min = min;
+exports.mod = mod;
+exports.multiply = multiply;
+exports.obj = index$2;
+exports.omit = omit;
+exports.once = once;
+exports.pascal = pascal;
+exports.percentile = percentile;
+exports.pick = pick;
+exports.pipe = pipe;
+exports.pow = pow;
+exports.rand = index$1;
+exports.randInt = randInt;
+exports.randWeight = randWeight;
+exports.range = range;
+exports.round = round;
+exports.sample = sample;
+exports.set = set;
+exports.shuffle = shuffle;
+exports.snake = snake;
+exports.sort = sort;
+exports.str = index;
+exports.subtract = subtract;
+exports.sum = sum;
+exports.template = template;
+exports.throttle = throttle;
+exports.transpose = transpose;
+exports.trim = trim;
+exports.unapply = unapply;
+exports.union = union;
+exports.unique = unique;
+exports.vals = vals;
+exports.zip = zip;
+//# sourceMappingURL=index.cjs.js.map