litus 1.3.1 → 1.5.0

package/dist/index.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.esm.js","sources":["../src/arr/binSearch.ts","../src/arr/from.ts","../src/arr/range.ts","../src/arr/chunk.ts","../src/arr/fill.ts","../src/arr/findIdx.ts","../src/arr/find.ts","../src/arr/findAllIdx.ts","../src/arr/findAll.ts","../src/arr/group.ts","../src/arr/groupBy.ts","../src/arr/max.ts","../src/arr/min.ts","../src/arr/sort.ts","../src/arr/transpose.ts","../src/arr/union.ts","../src/arr/unique.ts","../src/func/unapply.ts","../src/arr/zip.ts","../src/func/apply.ts","../src/func/curry.ts","../src/func/debounce.ts","../src/func/identity.ts","../src/func/memo.ts","../src/func/once.ts","../src/func/pipe.ts","../src/func/throttle.ts","../src/math/calc.ts","../src/math/add.ts","../src/math/round.ts","../src/math/aprox.ts","../src/math/cumsum.ts","../src/math/divide.ts","../src/math/interp.ts","../src/math/inRange.ts","../src/math/multiply.ts","../src/math/sum.ts","../src/math/mean.ts","../src/math/percentile.ts","../src/math/median.ts","../src/math/mod.ts","../src/math/pow.ts","../src/math/subtract.ts","../src/obj/entries.ts","../src/obj/isObj.ts","../src/obj/copy.ts","../src/obj/keys.ts","../src/obj/equal.ts","../src/obj/has.ts","../src/obj/get.ts","../src/obj/merge.ts","../src/obj/omit.ts","../src/obj/pick.ts","../src/obj/set.ts","../src/obj/vals.ts","../src/rand/randInt.ts","../src/rand/randWeight.ts","../src/rand/_fisherYates.ts","../src/rand/sample.ts","../src/rand/shuffle.ts","../src/str/_words.ts","../src/str/capitalize.ts","../src/str/camel.ts","../src/str/kebab.ts","../src/str/pascal.ts","../src/str/snake.ts","../src/str/template.ts","../src/str/trim.ts","../src/time/index.ts"],"sourcesContent":["/**\n * Binary search for insertion index in a sorted array using a custom accessor\n * @param arr Sorted array to search\n * @param target Value to search for\n * @param getVal Function to extract comparison value from each element\n * @param start Start index (inclusive)\n * @param end End index (exclusive)\n * @returns Index to insert target to maintain order\n */\nexport const binSearch = <T>(\n  arr: T[],\n  target: number,\n  getVal: (el: T) => number,\n  start = 0,\n  end = arr.length\n): number => {\n  if (start < 0 || end > arr.length || start > end) {\n    throw new Error(\"Invalid start or end of search\");\n  }\n  let a = start;\n  let b = end;\n  while (a < b) {\n    const mid = Math.floor((a + b) / 2);\n    const midVal = getVal(arr[mid]);\n    if (midVal < target) {\n      a = mid + 1;\n    } else {\n      b = mid;\n    }\n  }\n  return a;\n};\n","/**\n * Creates an array of size `n`, filling each element using the map function\n * @param n Size of the array to create\n * @param mapFn Function that maps each index to an array element\n * @returns Array of mapped values\n */\nexport const from = <T>(n: number, mapFn: (i: number) => T): T[] => {\n  const res = Array<T>(n);\n  let i = n;\n  while (--i >= 0) {\n    res[i] = mapFn(i);\n  }\n  return res;\n};\n","import { from } from \"./from\";\n\n/**\n * Creates an array of numbers from `a` up to `b` incremented by `step`\n * @param a Start of the range (inclusive)\n * @param b End of the range (exclusive)\n * @param step Step between elements (default is 1)\n * @returns Array of numbers in the specified range\n */\nexport const range = (a: number, b: number, step = 1): number[] => {\n  if (step === 0) {\n    throw new Error(\"Step cannot be 0\");\n  }\n  const n = Math.ceil((b - a) / step);\n  return from(n, (i) => a + step * i);\n};\n","import { range } from \"./range\";\n\n/**\n * Splits an array into multiple chunks of a specified size\n * @param arr Array to split\n * @param size Size of each chunk\n * @returns Array of chunks\n */\nexport const chunk = <T>(arr: T[], size: number): T[][] => {\n  if (!Number.isInteger(size)) {\n    throw new Error(\"Chunk size must be an integer\");\n  }\n  return range(0, arr.length, size).map((i) => arr.slice(i, i + size));\n};\n","import { from } from \"./from\";\n\n/**\n * Creates array of size `n` filled with the specified value\n * @param n Array size\n * @param val Value to fill the array with\n * @returns Array containing `val` repeated `n` times\n */\nexport const fill = <T>(n: number, val: T): T[] => {\n  return from(n, () => val);\n};\n","import type { Predicate } from \"./types\";\n\n/**\n * Finds the index of the first element that matches the given predicate\n * @param arr Array to search\n * @param predicate Function to test each element\n * @param from Start index (inclusive). Default: 0\n * @param to End index (exclusive). Default: arr.length\n * @returns Index of the first matching element, or -1 if none found\n */\nexport const findIdx = <T>(\n  arr: T[],\n  predicate: Predicate<T>,\n  from = 0,\n  to = arr.length\n): number => {\n  for (let i = from; i < to; i++) {\n    if (predicate(arr[i], i, arr)) {\n      return i;\n    }\n  }\n  return -1;\n};\n","import { findIdx } from \"./findIdx\";\nimport type { Predicate } from \"./types\";\n\n/**\n * Finds the first element that matches the given predicate\n * @param arr Array to search\n * @param predicate Function to test each element\n * @param from Start index (inclusive). Default: 0\n * @param to End index (exclusive). Default: arr.length\n * @returns First matching element, or undefined if none found\n */\nexport const find = <T>(\n  arr: T[],\n  predicate: Predicate<T>,\n  from = 0,\n  to = arr.length\n): T | undefined => {\n  return arr[findIdx(arr, predicate, from, to)];\n};\n","import type { Predicate } from \"./types\";\n\n/**\n * Finds indices of all elements that match the given predicate\n * @param arr Array to search\n * @param predicate Function to test each element\n * @param from Start index (inclusive). Default: 0\n * @param to End index (exclusive). Default: arr.length\n * @param limit Maximum number of indices to return. Default: arr.length\n * @returns Array of matching indices\n */\nexport const findAllIdx = <T>(\n  arr: T[],\n  predicate: Predicate<T>,\n  from = 0,\n  to = arr.length,\n  limit = arr.length\n): number[] => {\n  const res: number[] = [];\n  for (let i = from; i < to; i++) {\n    if (predicate(arr[i], i, arr)) {\n      res.push(i);\n      if (res.length >= limit) {\n        break;\n      }\n    }\n  }\n  return res;\n};\n","import { findAllIdx } from \"./findAllIdx\";\nimport type { Predicate } from \"./types\";\n\n/**\n * Finds all elements that match the given predicate\n * @param arr Array to search\n * @param predicate Function to test each element\n * @param from Start index (inclusive). Default: 0\n * @param to End index (exclusive). Default: arr.length\n * @param limit Maximum number of matches to return. Default: arr.length\n * @returns Array of matching elements\n */\nexport const findAll = <T>(\n  arr: T[],\n  predicate: Predicate<T>,\n  from = 0,\n  to = arr.length,\n  limit = arr.length\n): T[] => {\n  return findAllIdx(arr, predicate, from, to, limit).map((i) => arr[i]);\n};\n","/**\n * Groups array items into an object by a key\n * @param arr Array to group\n * @param getKey Function to extract the group key from each item\n * @returns Object with keys as group ids and values as arrays of grouped items\n */\nexport const group = <T, K extends PropertyKey>(\n  arr: T[],\n  getKey: (obj: T) => K\n): Record<K, T[]> => {\n  const res = {} as Record<K, T[]>;\n  arr.forEach((el) => {\n    const val = getKey(el);\n    if (res[val] === undefined) {\n      res[val] = [];\n    }\n    res[val].push(el);\n  });\n  return res;\n};\n","import { group } from \"./group\";\n\n/**\n * @deprecated Use `group` instead\n */\nexport const groupBy = <T extends object, K extends keyof T>(\n  arr: T[],\n  key: T[K] extends PropertyKey ? K : never\n): Record<PropertyKey & T[K], T[]> => {\n  return group(arr, (obj) => obj[key] as PropertyKey & T[K]);\n};\n","/**\n * Returns the element with the maximum value based on the provided map function\n * @param arr Array to search\n * @param fn Function to extract the value for comparison\n * @returns Element with the maximum value\n */\nexport const max = <T>(arr: T[], fn: (val: T) => number): T => {\n  const scores = arr.map(fn);\n  let maxIdx = 0;\n  for (let i = 1; i < scores.length; i++) {\n    if (scores[i] > scores[maxIdx]) {\n      maxIdx = i;\n    }\n  }\n  return arr[maxIdx];\n};\n","import { max } from \"./max\";\n\n/**\n * Returns the element with the minimum value based on the provided map function\n * @param arr Array to search\n * @param fn Function to extract the value for comparison\n * @returns Element with the minimum value\n */\nexport const min = <T>(arr: T[], fn: (val: T) => number): T => {\n  return max(arr, (val) => -fn(val));\n};\n","/**\n * Sorts an array in-place based on a mapping function\n * @param arr Array to sort\n * @param mapFn Function to map each element to a sortable value\n * @returns Sorted array in-place\n */\nexport const sort = <T>(arr: T[], mapFn: (el: T) => number | string): T[] => {\n  const mapped = arr.map((el) => [mapFn(el), el] as const);\n  mapped.sort(([a], [b]) => {\n    if (a < b) {\n      return -1;\n    }\n    if (a > b) {\n      return 1;\n    }\n    return 0;\n  });\n  mapped.forEach(([, el], i) => {\n    arr[i] = el;\n  });\n  return arr;\n};\n","import { from } from \"./from\";\nimport type { Transpose } from \"./types\";\n\n/**\n * Transposes a 2D array (matrix), switching its rows and columns\n * @param matrix The 2D array to transpose\n * @returns Transposed matrix\n */\nexport const transpose = <T extends unknown[][]>(matrix: T): Transpose<T> => {\n  const rows = matrix.length;\n  const cols = matrix[0].length;\n  if (matrix.some((row) => row.length !== cols)) {\n    throw new Error(\"Invalid matrix. Rows have different size\");\n  }\n  const res = from(cols, (i) => from(rows, (j) => matrix[j][i]));\n  return res as unknown as Transpose<T>;\n};\n","/**\n * Creates a set containing unique values from all provided arrays\n * @param arrs Arrays to union\n * @returns Set of unique values\n */\nexport const union = <T>(...arrs: T[][]): Set<T> => {\n  return new Set(arrs.flat(1));\n};\n","import type { Primitive } from \"/types\";\n\nimport { sort } from \"./sort\";\n\n/**\n * Creates array of unique values from the input array, preserving their order\n * @param arr Array of primitive values\n * @returns Array of unique values\n */\nexport const unique = <T extends Primitive>(arr: T[]): T[] => {\n  const set = Array.from(new Set(arr));\n  return sort(set, (el) => arr.indexOf(el));\n};\n","/**\n * Transforms a function with array argument into one with spread arguments\n * @param fn Function accepting an array of arguments\n * @returns Function accepting spread arguments\n */\nexport const unapply = <T extends unknown[], R>(\n  fn: (arg: T) => R\n): ((...args: T) => R) => {\n  return (...args: T): R => fn(args);\n};\n","import { unapply } from \"/func/unapply\";\n\nimport { transpose } from \"./transpose\";\n\n/**\n * Creates an array of grouped elements, where each group contains the elements\n * at the corresponding index from the input arrays\n * @param arrays Arrays to process\n * @returns Array of grouped elements\n */\nexport const zip = unapply(transpose);\n","/**\n * Transforms a function with spread arguments into one with array argument\n * @param fn Function accepting spread arguments\n * @returns Function accepting an array of arguments\n */\nexport const apply = <T extends unknown[], R>(\n  fn: (...args: T) => R\n): ((arg: T) => R) => {\n  return (arg: T): R => fn.apply(undefined, arg);\n};\n","import type { CurryArgs, CurryFn, CurryFnRes, CurryRest } from \"./types\";\n\n/**\n * Creates a curried version of a function, allowing partial application of arguments\n * @param fn Function to curry\n * @param arity Number of arguments the function expects. Default: fn.length\n * @returns Curried function\n */\nexport const curry = <R, T extends unknown[]>(\n  fn: (...args: T) => R,\n  arity = fn.length\n): CurryFn<R, T> => {\n  return <A extends CurryArgs<T>>(...args: A): CurryFnRes<R, T, A> => {\n    const missing = arity - args.length;\n    if (missing <= 0) {\n      return fn.apply(undefined, args as unknown as T) as CurryFnRes<R, T, A>;\n    }\n    return curry(<Rest extends CurryRest<T, A>>(...rArgs: Rest): R => {\n      return fn.apply(undefined, (args as unknown[]).concat(rArgs) as T);\n    }, missing) as CurryFnRes<R, T, A>;\n  };\n};\n","/**\n * Creates a debounced version of a function that delays invoking until after the specified delay.\n * Only the last call within the delay period is executed\n * @param fn Function to debounce\n * @param delay Delay in milliseconds. Default: 100\n * @returns Debounced function\n */\nexport const debounce = <A extends unknown[]>(\n  fn: (...args: A) => void,\n  delay = 100\n): ((...args: A) => void) => {\n  let timer: NodeJS.Timeout | undefined;\n  return (...args: A): void => {\n    clearTimeout(timer);\n    timer = setTimeout(() => {\n      fn.apply(undefined, args);\n    }, delay);\n  };\n};\n","/**\n * Returns the input value unchanged\n * @param value Value to return\n * @returns Same value provided as input\n */\nexport const identity = <T>(x: T): T => x;\n","import type { Primitive } from \"/types\";\n\n/**\n * Creates a memoized version of a function, caching its output for faster repeated calls.\n * Optionally accepts a custom cache key generator and a TTL (time-to-live) in milliseconds\n * @param fn Function to memoize\n * @param idFn Function to generate a cache key from arguments. Default: JSON.stringify\n * @param ttl Optional cache expiration time in milliseconds. Default: 0 (no expiration)\n * @returns Memoized function\n */\nexport const memo = <T extends unknown[], R>(\n  fn: (...args: T) => R,\n  idFn: (arg: T) => Primitive = JSON.stringify,\n  ttl = 0\n): ((...args: T) => R) => {\n  const cache = new Map<Primitive, { val: R; exp?: number }>();\n  return (...args: T): R => {\n    const key = idFn(args);\n    const cached = cache.get(key);\n    if (cached !== undefined) {\n      if (cached.exp === undefined || Date.now() < cached.exp) {\n        return cached.val;\n      }\n    }\n    const val = fn.apply(undefined, args);\n    const exp = ttl <= 0 ? undefined : Date.now() + ttl;\n    cache.set(key, { exp, val });\n    return val;\n  };\n};\n","/**\n * Ensures the provided function is executed only once\n * Subsequent calls return the result of the first execution\n * @param fn Function to execute only once\n * @returns Function that invokes `fn` only once\n */\nexport const once = <T>(fn: () => T): (() => T) => {\n  let call = true;\n  let res: T;\n  return (): T => {\n    if (call) {\n      res = fn();\n      call = false;\n    }\n    return res;\n  };\n};\n","import type { PipedFn, PipeOps, UnaryFn } from \"./types\";\n\n/**\n * Creates a function by composing multiple unary functions from left to right.\n * The output of each function is passed as the input to the next\n * @param fns Sequence of unary functions to compose\n * @returns Composed function from left to right\n */\nexport const pipe = <T extends UnaryFn[]>(...fns: PipeOps<T>): PipedFn<T> => {\n  return ((input) => {\n    return fns.reduce((acc: unknown, fn: UnaryFn) => fn(acc), input);\n  }) as PipedFn<T>;\n};\n","/**\n * Creates a throttled version of the given function that only executes once per specified interval\n * @param fn Function to throttle\n * @param interval Minimum time (ms) between calls. Default: 100\n * @returns Throttled function\n */\nexport const throttle = <A extends unknown[]>(\n  fn: (...args: A) => void,\n  interval = 100\n): ((...args: A) => void) => {\n  let wait = false;\n  return (...args) => {\n    if (wait) {\n      return;\n    }\n    wait = true;\n    fn.apply(undefined, args);\n    setTimeout(() => {\n      wait = false;\n    }, interval);\n  };\n};\n","import { from } from \"/arr/from\";\nimport type { ConvertTuple } from \"/arr/types\";\n\nimport type { Calc, Quantity } from \"./types\";\n\n/**\n * Creates a function that applies the given operation to any combination of scalars and vectors\n * @template T Tuple or array of numbers for the operation\n * @param opFn Operation function to apply to the inputs\n * @returns Function that takes quantities (scalars or vectors) and returns the calculated result\n * @example\n * const fn = calc((a, b, c) => a * b + c);\n * fn([1, 2], 3, 4); // [7, 10]\n */\nexport const calc = <T extends number[]>(\n  opFn: (...nums: T) => number\n): (<A extends ConvertTuple<T, Quantity>>(...q: A) => Calc<A>) => {\n  return <A extends ConvertTuple<T, Quantity>>(...arr: A) => {\n    const vectors = arr.filter((el) => typeof el !== \"number\") as number[][];\n    if (vectors.length === 0) {\n      return opFn.apply(undefined, arr as unknown as T) as Calc<A>;\n    }\n    const size = vectors[0].length;\n    if (vectors.some((v) => v.length !== size)) {\n      throw new Error(\"All vectors must have same length\");\n    }\n    return from(size, (i) => {\n      const input = arr.map((el) => (typeof el === \"number\" ? el : el[i]));\n      return opFn.apply(undefined, input as T);\n    }) as Calc<A>;\n  };\n};\n","import { calc } from \"./calc\";\n\n/**\n * Calculates the sum of given quantities (vectors or scalars)\n * @param q Quantities to add\n * @returns Sum of the input quantities\n * @example\n * add([-4, 1, 0, 3], 5); // [1, 6, 5, 8]\n * add([1, 2], [3, 4]); // [4, 6]\n */\nexport const add = calc((...arr) => arr.reduce((acc, el) => acc + el, 0));\n","import type { Quantity } from \"./types\";\n\nconst _round = (n: number, p: number): number => {\n  const k = Math.pow(10, p);\n  return Math.round(n * k) / k;\n};\n\n/**\n * Rounds a quantity (vector or scalar) to the specified number of decimal places\n * @param q Quantity to round\n * @param precision Number of decimal places to round to. Default: 0\n * @returns Rounded quantity\n */\nexport const round = <T extends Quantity>(q: T, precision = 0): T => {\n  if (typeof q === \"number\") {\n    return _round(q, precision) as T;\n  }\n  return q.map((el) => _round(el, precision)) as T;\n};\n","import { round } from \"./round\";\n\n/**\n * Compares if two numbers are approximately equal using a custom precision\n * @param a First number to compare\n * @param b Second number to compare\n * @param precision Number of decimal places to consider. Default: 4\n * @returns True if numbers are approximately equal, false otherwise\n */\nexport const aprox = (a: number, b: number, precision = 4): boolean => {\n  return round(a, precision) === round(b, precision);\n};\n","/**\n * Calculates the cumulative sum of an array of numbers\n * @param arr Array of numbers to sum\n * @returns Array of cumulative sums\n */\nexport const cumsum = (arr: number[]): number[] => {\n  const res = Array<number>(arr.length);\n  res[0] = arr[0];\n  for (let i = 1; i < arr.length; i++) {\n    res[i] = res[i - 1] + arr[i];\n  }\n  return res;\n};\n","import { calc } from \"./calc\";\n\n/**\n * Calculates the division of two quantities (vectors or scalars)\n * @param a Dividend(s)\n * @param b Divisor(s)\n * @returns Division of the input quantities\n * @example\n * divide([-4, 1, 0, 3], 2); // [-2, 0.5, 0, 1.5]\n * divide([1, 2], [3, 4]);   // [1 / 3, 0.5]\n */\nexport const divide = calc((a, b) => a / b);\n","import { binSearch } from \"/arr/binSearch\";\n\n/**\n * Calculates the linear interpolation of monotonic increasing points (xp, fp) at given x values\n * @param x Points to interpolate\n * @param xp Known x-coordinates (must be increasing)\n * @param fp Known y-coordinates (must be increasing, same length as xp)\n * @returns Interpolated values at each x\n */\nexport const interp = (x: number[], xp: number[], fp: number[]): number[] => {\n  if (xp.length !== fp.length) {\n    throw new Error(\"xp and fp must have the same length\");\n  }\n\n  return x.map((xi) => {\n    if (xi >= xp[xp.length - 1]) {\n      return fp[fp.length - 1];\n    }\n    const i = binSearch(xp, xi, (el) => el);\n    if (i === 0) {\n      return fp[0];\n    }\n    const slope = (fp[i] - fp[i - 1]) / (xp[i] - xp[i - 1]);\n    return fp[i - 1] + slope * (xi - xp[i - 1]);\n  });\n};\n","/**\n * Checks if a number is within a half-open range [a, b)\n * @param n The number to check\n * @param a Start of the range\n * @param b End of the range. Default: 0\n * @returns True if n is in [a, b), false otherwise\n */\nexport const inRange = (n: number, a: number, b = 0): boolean => {\n  if (a > b) {\n    return inRange(n, b, a);\n  }\n  return n >= a && n < b;\n};\n","import { calc } from \"./calc\";\n\n/**\n * Calculates the multiplication of given quantities (vectors or scalars)\n * @param q Quantities to multiply\n * @returns Product of the input quantities\n * @example\n * multiply([-4, 1, 0, 3], 3); // => [-12, 3, 0, 9]\n * multiply([1, 2], [3, 4]); // => [3, 8]\n */\nexport const multiply = calc((...arr) => arr.reduce((acc, el) => acc * el, 1));\n","/**\n * Calculates the sum of an array of numbers\n * @param arr Numbers to sum\n * @returns Sum of all numbers in the array\n */\nexport const sum = (arr: number[]): number => {\n  return arr.reduce((acc, el) => acc + el, 0);\n};\n","import { multiply } from \"./multiply\";\nimport { sum } from \"./sum\";\n\n/**\n * Calculates the mean (average) of an array of numbers. Supports optional weighted mean\n * @param arr Array of numbers\n * @param weights Optional array of weights\n * @returns Mean of the numbers\n */\nexport const mean = (arr: number[], weights?: number[]): number => {\n  if (weights === undefined) {\n    return sum(arr) / arr.length;\n  }\n  if (arr.length !== weights.length) {\n    throw new Error(\"Nums and weights must have the same length\");\n  }\n  return sum(multiply(arr, weights)) / sum(weights);\n};\n","import { binSearch } from \"/arr/binSearch\";\nimport { range } from \"/arr/range\";\nimport { sort } from \"/arr/sort\";\nimport { transpose } from \"/arr/transpose\";\n\nimport { cumsum } from \"./cumsum\";\nimport { divide } from \"./divide\";\nimport { interp } from \"./interp\";\nimport type { Quantity, QuantityT } from \"./types\";\n\nconst _linear = (x: number[], p: number[]): number[] => {\n  const Pnorm = divide(p, 100);\n  const step = 1 / (x.length - 1);\n  const xp = range(0, 1 + step, step);\n  return interp(Pnorm, xp, x.sort());\n};\n\nconst _weighted = (x: number[], p: number[], w: number[]): number[] => {\n  if (w.length !== x.length) {\n    throw new Error(\"Weights must be the same length as the array\");\n  } else if (w.some((v) => v < 0)) {\n    throw new Error(\"Weights must be non-negative\");\n  }\n\n  const X = sort(transpose([x, w]), (el) => el[0]);\n  const [Xsorted, Wsorted] = transpose(X);\n  const Wcum = cumsum(Wsorted);\n  const Wtotal = Wcum[Wcum.length - 1];\n  const Wnorm = divide(Wcum, Wtotal);\n  const Pnorm = divide(p, 100);\n\n  let i = 0;\n  return Pnorm.map((pi) => {\n    i = binSearch(Wnorm, pi, (el) => el, i);\n    return Xsorted[i];\n  });\n};\n\n/**\n * Calculates the given percentile(s) of an array of numbers\n * Supports both linear interpolation and weighted percentiles\n * @param x Array of numbers\n * @param p Percentile(s) to compute (number or array of numbers, 0–100)\n * @param weights Optional array of weights (same length as x)\n * @returns Computed percentile value(s)\n */\nexport const percentile = <T extends Quantity>(\n  x: number[],\n  p: T,\n  weights?: number[]\n): QuantityT<T> => {\n  if (typeof p === \"number\") {\n    return percentile(x, [p], weights)[0] as QuantityT<T>;\n  }\n  if (p.some((v) => v < 0 || v > 100)) {\n    throw new Error(\"Percentiles must be between 0 and 100\");\n  }\n  if (weights === undefined) {\n    return _linear(x, p) as QuantityT<T>;\n  }\n  return _weighted(x, p, weights) as QuantityT<T>;\n};\n","import { percentile } from \"./percentile\";\n\n/**\n * Calculates the median of an array of numbers\n * @param arr Array of numbers\n * @param weights Optional array of weights\n * @returns Median value\n */\nexport const median = (arr: number[], weights?: number[]): number => {\n  return percentile(arr, 50, weights);\n};\n","import { calc } from \"./calc\";\n\n/**\n * Calculates the modulo of two quantities (vectors or scalars)\n * @param x Dividend(s)\n * @param modulo Divisor(s)\n * @returns Modulo, matching the input shape\n * @example\n * mod(5, 3); // 2\n * mod([2, 3, 4], 3); // [2, 0, 1]\n * mod([4, 5], [2, 3]); // [0, 2]\n */\nexport const mod = calc((x, modulo) => {\n  const m = Math.abs(modulo);\n  return ((x % m) + m) % m;\n});\n","import { calc } from \"./calc\";\n\n/**\n * Calculates the exponentiation of two quantities (vectors or scalars)\n * @param base Base quantity\n * @param exp Exponent quantity\n * @returns base raised to the power of exp\n */\nexport const pow = calc((base, exp) => Math.pow(base, exp));\n","import { calc } from \"./calc\";\n\n/**\n * Calculates the subtraction of two quantities (vectors or scalars)\n * @param a Minuend quantity\n * @param b Subtrahend quantity\n * @returns Subtraction of `b` from `a`\n */\nexport const subtract = calc((a, b) => a - b);\n","import type { Entry } from \"./types\";\n\n/**\n * Retrieves a strongly-typed array of the entries (key, value) of an object\n * @param obj Object whose entries are to be retrieved\n * @returns Array of key-value pairs from the object\n */\nexport const entries: <T extends object>(obj: T) => Entry<T>[] = Object.entries;\n","/**\n * Checks if the provided value is a non-null object\n * @param el Value to check\n * @returns True if `el` is a non-null object, otherwise false\n */\nexport const isObj = (el: unknown): el is object => {\n  return typeof el === \"object\" && el !== null;\n};\n","import { entries } from \"./entries\";\nimport { isObj } from \"./isObj\";\n\n/**\n * Creates a deep copy of the provided object or array\n * @param obj Object or array to copy\n * @returns Deep copy of the input\n */\nexport const copy = <T>(obj: T): T => {\n  if (!isObj(obj)) {\n    return obj;\n  }\n\n  const res = (Array.isArray(obj) ? [] : {}) as T;\n  entries(obj).forEach(([key, val]) => {\n    res[key] = copy(val);\n  });\n\n  return res;\n};\n","import type { Key } from \"./types\";\n\n/**\n * Retrieves a strongly-typed array of the keys of an object\n * @param obj Object whose keys are to be retrieved\n * @returns Array of the object's keys\n */\nexport const keys: <T extends object>(obj: T) => Key<T>[] = Object.keys;\n","import { union } from \"/arr/union\";\nimport { unapply } from \"/func/unapply\";\n\nimport { isObj } from \"./isObj\";\nimport { keys } from \"./keys\";\n\nconst deepEqual = (args: unknown[]): boolean => {\n  if (args.every((arg) => arg === args[0])) {\n    return true;\n  }\n  if (!args.every(isObj)) {\n    return false;\n  }\n  const objs = args as Record<string, unknown>[];\n  const objsKeys = objs.map(keys);\n  if (!deepEqual(objsKeys.map((key) => key.length))) {\n    return false;\n  }\n  const keysUnion = union.apply(undefined, objsKeys);\n  if (keysUnion.size !== objsKeys[0].length) {\n    return false;\n  }\n  return objsKeys[0].every((key) => {\n    const vals = objs.map((obj) => obj[key]);\n    return deepEqual(vals);\n  });\n};\n\n/**\n * Performs a deep comparison between multiple objects to determine if they are equal\n * @param objs Objects to compare\n * @returns True if all objects are deeply equal, false otherwise\n */\nexport const equal = unapply(deepEqual);\n","/**\n * Checks if an object has all specified properties\n * @param obj Object to check\n * @param keys Property keys to look for\n * @returns True if all keys exist on the object, false otherwise\n */\nexport const has = <K extends PropertyKey>(\n  obj: object,\n  ...keys: K[]\n): obj is Record<K, unknown> => {\n  return keys.every((key) => Object.prototype.hasOwnProperty.call(obj, key));\n};\n","import { has } from \"./has\";\nimport { isObj } from \"./isObj\";\n\n/**\n * Gets a value at a nested path of an object or array\n * @param obj Source object\n * @param path Dot-separated path string\n * @param fallback Value to return if the path is not found\n * @returns Value at the specified path or the fallback\n */\nexport const get = <T>(obj: object, path: string, fallback?: T): T => {\n  let val: unknown = obj;\n  for (const key of path.split(\".\")) {\n    if (isObj(val) && has(val, key)) {\n      val = val[key];\n    } else {\n      return fallback as T;\n    }\n  }\n  return val as T;\n};\n","import { copy } from \"./copy\";\n\n/**\n * Creates a strongly-typed object from the shallow merge of deep copies of two objects\n * If both objects have the same property, the value from the second object overwrites the first\n * @param a First object to merge\n * @param b Second object to merge\n * @returns The merged object with properties from both a and b\n */\nexport const merge = <A extends object, B extends object>(\n  a: A,\n  b: B\n): A & B => {\n  return Object.assign(copy(a), copy(b));\n};\n","import { copy } from \"./copy\";\n\n/**\n * Creates a deep copy of an object without the specified keys\n * @param obj Source object\n * @param keys Array of keys to omit from the result\n * @returns New object without the specified keys\n */\nexport const omit = <T, K extends keyof T>(obj: T, keys: K[]): Omit<T, K> => {\n  const newObj = copy(obj);\n  for (const key of keys) {\n    delete newObj[key];\n  }\n  return newObj;\n};\n","import { copy } from \"./copy\";\n\n/**\n * Creates a deep copy of an object with only the specified keys\n * @param obj Source object\n * @param keys Array of keys to pick from the object\n * @returns New object with only the picked keys\n */\nexport const pick = <T, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> => {\n  const res: Partial<T> = {};\n  for (const key of keys) {\n    res[key] = copy(obj[key]);\n  }\n  return res as Pick<T, K>;\n};\n","import { isObj } from \"./isObj\";\nimport type { SetPath } from \"./types\";\n\n/**\n * Sets a value at a nested path of an object, creating nested objects if needed\n * @param obj Target object to modify\n * @param path Dot-separated string path where the value should be set\n * @param value Value to set at the specified path\n * @returns Modified object with the value set at the given path\n */\nexport const set = <T extends object, P extends string, V>(\n  obj: T,\n  path: P,\n  value: V\n): SetPath<T, P, V> => {\n  let val = obj as Record<string, unknown>;\n  const keys = path.split(\".\");\n  const end = keys.length - 1;\n  for (let i = 0; i < end; i++) {\n    const key = keys[i];\n    if (!isObj(val[key])) {\n      val[key] = {};\n    }\n    val = val[key] as Record<string, unknown>;\n  }\n  val[keys[end]] = value;\n  return obj as SetPath<T, P, V>;\n};\n","import type { Val } from \"./types\";\n\n/**\n * Retrieves a strongly-typed array of the values of an object\n * @param obj Source object\n * @returns Array of the object's values\n */\nexport const vals: <T extends object>(obj: T) => Val<T>[] = Object.values;\n","/**\n * Returns a random integer between two numbers\n * @param a Lower bound (inclusive)\n * @param b Upper bound (exclusive). Default: 0\n * @returns Random integer between a and b\n */\nexport const randInt = (a: number, b = 0): number => {\n  if (!Number.isInteger(a) || !Number.isInteger(b)) {\n    throw Error(\"a and b must be integers\");\n  }\n  return Math.floor(Math.random() * (b - a) + a);\n};\n","import { binSearch } from \"/arr/binSearch\";\nimport { cumsum } from \"/math/cumsum\";\n\n/**\n * Selects a random index based on the provided weights\n * @param weights Array of non-negative weights\n * @returns Selected index\n */\nexport const randWeight = (weights: number[]): number => {\n  if (weights.length === 0) {\n    throw new Error(\"Weights array cannot be empty\");\n  }\n  if (weights.some((w) => w < 0)) {\n    throw new Error(\"Weights array cannot contain negative values\");\n  }\n  const wAccum = cumsum(weights);\n  const wTotal = wAccum[wAccum.length - 1];\n  if (wTotal === 0) {\n    throw new Error(\"Total weight must be greater than zero\");\n  }\n  const r = Math.random() * wTotal;\n  return binSearch(wAccum, r, (el) => el);\n};\n","import { randWeight } from \"./randWeight\";\n\nconst op = <T>(arr: T[], size: number, pick: (n: number) => number): T[] => {\n  const n = Math.min(size, arr.length);\n  const res = arr.slice();\n  const end = res.length - n;\n  for (let i = res.length - 1; i > end; i--) {\n    const idx = pick(i + 1);\n    [res[i], res[idx]] = [res[idx], res[i]];\n  }\n  return n === arr.length ? res : res.slice(0, n);\n};\n\nexport const fisherYates = <T>(\n  data: T[],\n  size: number,\n  weights?: number[]\n): T[] => {\n  if (size <= 0) {\n    return [];\n  }\n  if (weights === undefined) {\n    return op(data, size, (n) => Math.floor(Math.random() * n));\n  }\n  if (weights.length !== data.length) {\n    throw new Error(\"Weights must have the same length as the data array\");\n  }\n  if (weights.some((w) => w < 0)) {\n    throw new Error(\"Weights cannot contain negative values.\");\n  }\n  const w = weights.slice();\n  return op(data, size, () => {\n    const idx = randWeight(w);\n    w[idx] = 0;\n    return idx;\n  });\n};\n","import { fisherYates } from \"./_fisherYates\";\n\n/**\n * Samples elements from an array randomly, optionally using weights to influence selection\n * @param data Array to sample from\n * @param size Number of elements to sample\n * @param weights Optional array of weights for weighted sampling\n * @returns New array containing the sampled elements\n */\nexport const sample = fisherYates;\n","import { fisherYates } from \"./_fisherYates\";\n\n/**\n * Shuffles an array randomly, optionally using weights to influence the\n * likelihood of selecting elements first\n * @param data Array to shuffle\n * @param weights Optional array of weights for weighted shuffling\n * @returns New array with the elements shuffled\n */\nexport const shuffle = <T>(data: T[], weights?: number[]): T[] => {\n  return fisherYates(data, data.length, weights);\n};\n","export const words = (str: string): string[] => {\n  return str\n    .replace(/([a-z])([A-Z])/g, \"$1 $2\") // Split camelCase and PascalCase\n    .replace(/([A-Z])([A-Z][a-z])/g, \"$1 $2\") // Split UPPERPascal > UPPER Pascal\n    .replace(/([0-9]+)/g, \" $1 \")\n    .split(/[_-\\s]+/)\n    .filter(Boolean);\n};\n","/**\n * Capitalizes the first letter of a string and converts the rest to lowercase\n * @param str String to capitalize\n * @returns Capitalized string\n */\nexport const capitalize = (str: string): string => {\n  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();\n};\n","import { words } from \"./_words\";\nimport { capitalize } from \"./capitalize\";\n\n/**\n * Converts a string to camelCase\n * @param str String to convert\n * @returns camelCase version of the input string\n */\nexport const camel = (str: string): string => {\n  const w = words(str).map(capitalize);\n  if (w.length === 0) {\n    return \"\";\n  }\n  w[0] = w[0].toLowerCase();\n  return w.join(\"\");\n};\n","import { words } from \"./_words\";\n\n/**\n * Converts a string to kebab-case\n * @param str String to convert\n * @returns kebab-case version of the input string\n */\nexport const kebab = (str: string): string => {\n  return words(str)\n    .map((str) => str.toLowerCase())\n    .join(\"-\");\n};\n","import { words } from \"./_words\";\nimport { capitalize } from \"./capitalize\";\n\n/**\n * Converts a string to PascalCase\n * @param str String to convert\n * @returns PascalCase version of the input string\n */\nexport const pascal = (str: string): string => {\n  return words(str).map(capitalize).join(\"\");\n};\n","import { words } from \"./_words\";\n\n/**\n * Converts a string to snake_case\n * @param str String to convert\n * @returns snake_case version of the input string\n */\nexport const snake = (str: string): string => {\n  return words(str)\n    .map((str) => str.toLowerCase())\n    .join(\"_\");\n};\n","import { get } from \"/obj/get\";\n\n/**\n * Replaces placeholders in the format `{{path.to.value}}` within a string\n * with corresponding values from the provided data object\n * @param str String containing placeholders to replace\n * @param data Object with values for the placeholders\n * @returns String with placeholders replaced by their values\n */\nexport const template = (str: string, data: object): string => {\n  return str.replace(/\\{\\{([a-zA-Z0-9._]+)\\}\\}/g, (_, path: string) => {\n    return get(data, path, \"\");\n  });\n};\n","/**\n * Removes leading and trailing whitespace or specified characters from a string\n * @param str String to trim\n * @param chars Optional characters to trim from the string. Default: whitespace\n * @returns Trimmed string\n */\nexport const trim = (str: string, chars = \" \"): string => {\n  const reg = new RegExp(`^[${chars}]+|[${chars}]+$`, \"g\");\n  return str.replace(reg, \"\");\n};\n","import { merge } from \"/obj/merge\";\n\nimport type { TimeFormat, TimeFormatOptions, TimeUnit } from \"./types\";\n\n/**\n * @deprecated Time module is deprecated and may be removed in future releases\n */\nexport class Time {\n  public static UNITS: Record<TimeUnit, number> = {\n    d: 864e5,\n    h: 36e5,\n    m: 6e4,\n    ms: 1,\n    s: 1e3\n  };\n\n  public static formatOptions: TimeFormatOptions = {\n    date: {\n      dateStyle: \"medium\"\n    },\n    full: {\n      dateStyle: \"short\",\n      timeStyle: \"short\"\n    },\n    time: {\n      timeStyle: \"medium\"\n    }\n  };\n  public static locales?: Intl.LocalesArgument;\n\n  private readonly date;\n\n  public constructor(val?: number, unit: TimeUnit = \"ms\") {\n    this.date = new Date();\n    if (val !== undefined) {\n      this.set(val, unit);\n    }\n  }\n\n  public static convert(\n    val: number,\n    from: TimeUnit,\n    to: TimeUnit = \"ms\"\n  ): number {\n    const ms = Math.round(Time.UNITS[from] * val);\n    return ms / Time.UNITS[to];\n  }\n\n  public add(val: number, unit: TimeUnit = \"ms\"): number {\n    return this.set(this.get(unit) + val, unit);\n  }\n\n  public format(\n    mode: TimeFormat = \"full\",\n    local: Intl.LocalesArgument = Time.locales,\n    opts: Intl.DateTimeFormatOptions = {}\n  ): string {\n    const options = merge(Time.formatOptions[mode], opts);\n    return this.date.toLocaleString(local, options);\n  }\n\n  public get(unit: TimeUnit = \"ms\"): number {\n    return Time.convert(this.date.getTime(), \"ms\", unit);\n  }\n\n  public getDayTime(unit: TimeUnit = \"ms\"): number {\n    return Time.convert(this.get(\"d\") % 1, \"d\", unit);\n  }\n\n  public set(val: number, unit: TimeUnit = \"ms\"): number {\n    return this.date.setTime(Time.convert(val, unit));\n  }\n\n  public setDayTime(val: number, unit: TimeUnit = \"ms\"): number {\n    return this.add(val - this.getDayTime(unit), unit);\n  }\n\n  public toDate(): Date {\n    return new Date(this.date);\n  }\n}\n"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "litus",
-  "version": "1.3.1",
+  "version": "1.5.0",
   "description": "Commonly used utilities for JS and TS",
   "author": {
     "email": "estidlore@outlook.com",
@@ -16,17 +16,24 @@
   "homepage": "https://github.com/estidlore/litus#readme",
   "keywords": [
     "array",
-    "date",
     "javascript",
+    "js",
     "math",
+    "number",
     "object",
-    "time",
+    "stdlib",
+    "string",
+    "toolkit",
+    "ts",
+    "types",
     "typescript",
+    "utilities",
     "utils"
   ],
   "license": "MIT",
-  "main": "dist/cjs/index.js",
-  "module": "dist/esm/index.js",
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.esm.js",
+  "types": "dist/index.d.ts",
   "publishConfig": {
     "access": "public"
   },
@@ -35,20 +42,21 @@
     "type": "git"
   },
   "scripts": {
-    "build": "rm -rf ./dist && npm run build:cjs && npm run build:esm",
-    "build:cjs": "tsc -p tsconfig.build.cjs.json && tsc-alias -p tsconfig.build.cjs.json",
-    "build:esm": "tsc -p tsconfig.build.esm.json && tsc-alias -p tsconfig.build.esm.json",
+    "build": "rimraf ./dist && rollup -c",
     "format": "prettier --write .",
     "lint": "eslint --ext .ts src test --fix",
     "test": "jest"
   },
   "devDependencies": {
+    "@rollup/plugin-typescript": "^12.1.2",
     "@types/jest": "^29.4.0",
     "@typescript-eslint/parser": "^5.52.0",
     "eslint": "^8.34.0",
     "eslint-config-estidlore": "github:estidlore/eslint-config-estidlore",
     "jest": "^29.4.3",
     "prettier": "^2.8.4",
+    "rollup": "^4.42.0",
+    "rollup-plugin-dts": "^6.2.1",
     "ts-jest": "^29.0.5",
     "typescript": "^4.9.5"
   }

package/dist/cjs/arr/chunk.d.ts

@@ -1 +0,0 @@
-export declare const chunk: <T>(arr: T[], size: number) => T[][];

package/dist/cjs/arr/chunk.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.chunk = void 0;
-const range_1 = require("./range");
-const chunk = (arr, size) => {
-    if (size <= 0) {
-        throw new Error("Size must be greater than 0");
-    }
-    return (0, range_1.range)(0, arr.length, size).map((i) => arr.slice(i, i + size));
-};
-exports.chunk = chunk;
-//# sourceMappingURL=chunk.js.map

package/dist/cjs/arr/chunk.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk.js","sourceRoot":"","sources":["../../../src/arr/chunk.ts"],"names":[],"mappings":";;;AAAA,mCAAgC;AAEzB,MAAM,KAAK,GAAG,CAAI,GAAQ,EAAE,IAAY,EAAS,EAAE;IACxD,IAAI,IAAI,IAAI,CAAC,EAAE;QACb,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC;KAChD;IACD,OAAO,IAAA,aAAK,EAAC,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;AACvE,CAAC,CAAC;AALW,QAAA,KAAK,SAKhB"}

package/dist/cjs/arr/fill.d.ts

@@ -1 +0,0 @@
-export declare const fill: <T>(n: number, val: T) => T[];

package/dist/cjs/arr/fill.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fill = void 0;
-const from_1 = require("./from");
-const fill = (n, val) => {
-    return (0, from_1.from)(n, () => val);
-};
-exports.fill = fill;
-//# sourceMappingURL=fill.js.map

package/dist/cjs/arr/fill.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fill.js","sourceRoot":"","sources":["../../../src/arr/fill.ts"],"names":[],"mappings":";;;AAAA,iCAA8B;AAEvB,MAAM,IAAI,GAAG,CAAI,CAAS,EAAE,GAAM,EAAO,EAAE;IAChD,OAAO,IAAA,WAAI,EAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;AAC5B,CAAC,CAAC;AAFW,QAAA,IAAI,QAEf"}

package/dist/cjs/arr/find.d.ts

@@ -1,2 +0,0 @@
-import type { Predicate } from "./types";
-export declare const find: <T>(arr: T[], predicate: Predicate<T, boolean>, from?: number, to?: number) => T | undefined;

package/dist/cjs/arr/find.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.find = void 0;
-const findIdx_1 = require("./findIdx");
-const find = (arr, predicate, from = 0, to = arr.length) => {
-    return arr[(0, findIdx_1.findIdx)(arr, predicate, from, to)];
-};
-exports.find = find;
-//# sourceMappingURL=find.js.map

package/dist/cjs/arr/find.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"find.js","sourceRoot":"","sources":["../../../src/arr/find.ts"],"names":[],"mappings":";;;AAAA,uCAAoC;AAG7B,MAAM,IAAI,GAAG,CAClB,GAAQ,EACR,SAAuB,EACvB,IAAI,GAAG,CAAC,EACR,EAAE,GAAG,GAAG,CAAC,MAAM,EACA,EAAE;IACjB,OAAO,GAAG,CAAC,IAAA,iBAAO,EAAC,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC;AAChD,CAAC,CAAC;AAPW,QAAA,IAAI,QAOf"}

package/dist/cjs/arr/findAll.d.ts

@@ -1,2 +0,0 @@
-import type { Predicate } from "./types";
-export declare const findAll: <T>(arr: T[], predicate: Predicate<T, boolean>, from?: number, to?: number, limit?: number) => T[];

package/dist/cjs/arr/findAll.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findAll = void 0;
-const findAllIdx_1 = require("./findAllIdx");
-const findAll = (arr, predicate, from = 0, to = arr.length, limit = arr.length) => {
-    return (0, findAllIdx_1.findAllIdx)(arr, predicate, from, to, limit).map((i) => arr[i]);
-};
-exports.findAll = findAll;
-//# sourceMappingURL=findAll.js.map

package/dist/cjs/arr/findAll.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"findAll.js","sourceRoot":"","sources":["../../../src/arr/findAll.ts"],"names":[],"mappings":";;;AAAA,6CAA0C;AAGnC,MAAM,OAAO,GAAG,CACrB,GAAQ,EACR,SAAuB,EACvB,IAAI,GAAG,CAAC,EACR,EAAE,GAAG,GAAG,CAAC,MAAM,EACf,KAAK,GAAG,GAAG,CAAC,MAAM,EACb,EAAE;IACP,OAAO,IAAA,uBAAU,EAAC,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACxE,CAAC,CAAC;AARW,QAAA,OAAO,WAQlB"}

package/dist/cjs/arr/findAllIdx.d.ts

@@ -1,2 +0,0 @@
-import type { Predicate } from "./types";
-export declare const findAllIdx: <T>(arr: T[], predicate: Predicate<T, boolean>, from?: number, to?: number, limit?: number) => number[];

package/dist/cjs/arr/findAllIdx.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findAllIdx = void 0;
-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;
-};
-exports.findAllIdx = findAllIdx;
-//# sourceMappingURL=findAllIdx.js.map

package/dist/cjs/arr/findAllIdx.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"findAllIdx.js","sourceRoot":"","sources":["../../../src/arr/findAllIdx.ts"],"names":[],"mappings":";;;AAEO,MAAM,UAAU,GAAG,CACxB,GAAQ,EACR,SAAuB,EACvB,IAAI,GAAG,CAAC,EACR,EAAE,GAAG,GAAG,CAAC,MAAM,EACf,KAAK,GAAG,GAAG,CAAC,MAAM,EACR,EAAE;IACZ,MAAM,GAAG,GAAa,EAAE,CAAC;IACzB,KAAK,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE;QAC9B,IAAI,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE;YAC7B,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACZ,IAAI,GAAG,CAAC,MAAM,IAAI,KAAK,EAAE;gBACvB,MAAM;aACP;SACF;KACF;IACD,OAAO,GAAG,CAAC;AACb,CAAC,CAAC;AAjBW,QAAA,UAAU,cAiBrB"}

package/dist/cjs/arr/findIdx.d.ts

@@ -1,2 +0,0 @@
-import type { Predicate } from "./types";
-export declare const findIdx: <T>(arr: T[], predicate: Predicate<T, boolean>, from?: number, to?: number) => number;

package/dist/cjs/arr/findIdx.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findIdx = void 0;
-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;
-};
-exports.findIdx = findIdx;
-//# sourceMappingURL=findIdx.js.map

package/dist/cjs/arr/findIdx.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"findIdx.js","sourceRoot":"","sources":["../../../src/arr/findIdx.ts"],"names":[],"mappings":";;;AAEO,MAAM,OAAO,GAAG,CACrB,GAAQ,EACR,SAAuB,EACvB,IAAI,GAAG,CAAC,EACR,EAAE,GAAG,GAAG,CAAC,MAAM,EACP,EAAE;IACV,KAAK,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE;QAC9B,IAAI,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE;YAC7B,OAAO,CAAC,CAAC;SACV;KACF;IACD,OAAO,CAAC,CAAC,CAAC;AACZ,CAAC,CAAC;AAZW,QAAA,OAAO,WAYlB"}

package/dist/cjs/arr/from.d.ts

@@ -1 +0,0 @@
-export declare const from: <T>(n: number, mapFn: (i: number) => T) => T[];

package/dist/cjs/arr/from.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.from = void 0;
-const from = (n, mapFn) => {
-    const res = Array(n);
-    let i = n;
-    while (--i >= 0) {
-        res[i] = mapFn(i);
-    }
-    return res;
-};
-exports.from = from;
-//# sourceMappingURL=from.js.map

package/dist/cjs/arr/from.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"from.js","sourceRoot":"","sources":["../../../src/arr/from.ts"],"names":[],"mappings":";;;AAAO,MAAM,IAAI,GAAG,CAAI,CAAS,EAAE,KAAuB,EAAO,EAAE;IACjE,MAAM,GAAG,GAAG,KAAK,CAAI,CAAC,CAAC,CAAC;IACxB,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,OAAO,EAAE,CAAC,IAAI,CAAC,EAAE;QACf,GAAG,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;KACnB;IACD,OAAO,GAAG,CAAC;AACb,CAAC,CAAC;AAPW,QAAA,IAAI,QAOf"}

package/dist/cjs/arr/group.d.ts

@@ -1 +0,0 @@
-export declare const group: <T, K extends PropertyKey>(arr: T[], getKey: (obj: T) => K) => Record<K, T[]>;

package/dist/cjs/arr/group.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.group = void 0;
-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;
-};
-exports.group = group;
-//# sourceMappingURL=group.js.map

package/dist/cjs/arr/group.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"group.js","sourceRoot":"","sources":["../../../src/arr/group.ts"],"names":[],"mappings":";;;AAAO,MAAM,KAAK,GAAG,CACnB,GAAQ,EACR,MAAqB,EACL,EAAE;IAClB,MAAM,GAAG,GAAG,EAAoB,CAAC;IACjC,GAAG,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE;QACjB,MAAM,GAAG,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC;QACvB,IAAI,GAAG,CAAC,GAAG,CAAC,KAAK,SAAS,EAAE;YAC1B,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;SACf;QACD,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACpB,CAAC,CAAC,CAAC;IACH,OAAO,GAAG,CAAC;AACb,CAAC,CAAC;AAbW,QAAA,KAAK,SAahB"}

package/dist/cjs/arr/groupBy.d.ts

@@ -1 +0,0 @@
-export declare const groupBy: <T extends object, K extends keyof T>(arr: T[], key: T[K] extends PropertyKey ? K : never) => Record<PropertyKey & T[K], T[]>;

package/dist/cjs/arr/groupBy.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.groupBy = void 0;
-const group_1 = require("./group");
-const groupBy = (arr, key) => {
-    return (0, group_1.group)(arr, (obj) => obj[key]);
-};
-exports.groupBy = groupBy;
-//# sourceMappingURL=groupBy.js.map

package/dist/cjs/arr/groupBy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"groupBy.js","sourceRoot":"","sources":["../../../src/arr/groupBy.ts"],"names":[],"mappings":";;;AAAA,mCAAgC;AAEzB,MAAM,OAAO,GAAG,CACrB,GAAQ,EACR,GAAyC,EACR,EAAE;IACnC,OAAO,IAAA,aAAK,EAAC,GAAG,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,CAAuB,CAAC,CAAC;AAC7D,CAAC,CAAC;AALW,QAAA,OAAO,WAKlB"}

package/dist/cjs/arr/index.d.ts

@@ -1,17 +0,0 @@
-export * from "./chunk";
-export * from "./fill";
-export * from "./find";
-export * from "./findIdx";
-export * from "./findAll";
-export * from "./findAllIdx";
-export * from "./from";
-export * from "./group";
-export * from "./groupBy";
-export * from "./max";
-export * from "./min";
-export * from "./range";
-export * from "./sort";
-export * from "./transpose";
-export * from "./union";
-export * from "./unique";
-export * from "./zip";

package/dist/cjs/arr/index.js

@@ -1,34 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./chunk"), exports);
-__exportStar(require("./fill"), exports);
-__exportStar(require("./find"), exports);
-__exportStar(require("./findIdx"), exports);
-__exportStar(require("./findAll"), exports);
-__exportStar(require("./findAllIdx"), exports);
-__exportStar(require("./from"), exports);
-__exportStar(require("./group"), exports);
-__exportStar(require("./groupBy"), exports);
-__exportStar(require("./max"), exports);
-__exportStar(require("./min"), exports);
-__exportStar(require("./range"), exports);
-__exportStar(require("./sort"), exports);
-__exportStar(require("./transpose"), exports);
-__exportStar(require("./union"), exports);
-__exportStar(require("./unique"), exports);
-__exportStar(require("./zip"), exports);
-//# sourceMappingURL=index.js.map

package/dist/cjs/arr/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/arr/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAwB;AACxB,yCAAuB;AACvB,yCAAuB;AACvB,4CAA0B;AAC1B,4CAA0B;AAC1B,+CAA6B;AAC7B,yCAAuB;AACvB,0CAAwB;AACxB,4CAA0B;AAC1B,wCAAsB;AACtB,wCAAsB;AACtB,0CAAwB;AACxB,yCAAuB;AACvB,8CAA4B;AAC5B,0CAAwB;AACxB,2CAAyB;AACzB,wCAAsB"}

package/dist/cjs/arr/max.d.ts

@@ -1 +0,0 @@
-export declare const max: <T>(arr: T[], fn: (val: T) => number) => T;

package/dist/cjs/arr/max.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.max = void 0;
-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];
-};
-exports.max = max;
-//# sourceMappingURL=max.js.map

package/dist/cjs/arr/max.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"max.js","sourceRoot":"","sources":["../../../src/arr/max.ts"],"names":[],"mappings":";;;AAAO,MAAM,GAAG,GAAG,CAAI,GAAQ,EAAE,EAAsB,EAAK,EAAE;IAC5D,MAAM,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAC3B,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACtC,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE;YAC9B,MAAM,GAAG,CAAC,CAAC;SACZ;KACF;IACD,OAAO,GAAG,CAAC,MAAM,CAAC,CAAC;AACrB,CAAC,CAAC;AATW,QAAA,GAAG,OASd"}

package/dist/cjs/arr/min.d.ts

@@ -1 +0,0 @@
-export declare const min: <T>(arr: T[], fn: (val: T) => number) => T;

package/dist/cjs/arr/min.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.min = void 0;
-const max_1 = require("./max");
-const min = (arr, fn) => {
-    return (0, max_1.max)(arr, (val) => -fn(val));
-};
-exports.min = min;
-//# sourceMappingURL=min.js.map

package/dist/cjs/arr/min.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"min.js","sourceRoot":"","sources":["../../../src/arr/min.ts"],"names":[],"mappings":";;;AAAA,+BAA4B;AAErB,MAAM,GAAG,GAAG,CAAI,GAAQ,EAAE,EAAsB,EAAK,EAAE;IAC5D,OAAO,IAAA,SAAG,EAAC,GAAG,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;AACrC,CAAC,CAAC;AAFW,QAAA,GAAG,OAEd"}

package/dist/cjs/arr/range.d.ts

@@ -1 +0,0 @@
-export declare const range: (a: number, b: number, step?: number) => number[];

package/dist/cjs/arr/range.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.range = void 0;
-const from_1 = require("./from");
-const range = (a, b, step = 1) => {
-    const n = Math.ceil((b - a) / step);
-    if (n <= 0) {
-        throw Error("Invalid range");
-    }
-    return (0, from_1.from)(n, (i) => a + step * i);
-};
-exports.range = range;
-//# sourceMappingURL=range.js.map

package/dist/cjs/arr/range.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"range.js","sourceRoot":"","sources":["../../../src/arr/range.ts"],"names":[],"mappings":";;;AAAA,iCAA8B;AAEvB,MAAM,KAAK,GAAG,CAAC,CAAS,EAAE,CAAS,EAAE,IAAI,GAAG,CAAC,EAAY,EAAE;IAChE,MAAM,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IACpC,IAAI,CAAC,IAAI,CAAC,EAAE;QACV,MAAM,KAAK,CAAC,eAAe,CAAC,CAAC;KAC9B;IACD,OAAO,IAAA,WAAI,EAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC;AACtC,CAAC,CAAC;AANW,QAAA,KAAK,SAMhB"}

package/dist/cjs/arr/sort.d.ts

@@ -1 +0,0 @@
-export declare const sort: <T>(arr: T[], mapFn: (el: T) => number | string) => T[];

package/dist/cjs/arr/sort.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sort = void 0;
-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;
-};
-exports.sort = sort;
-//# sourceMappingURL=sort.js.map

package/dist/cjs/arr/sort.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sort.js","sourceRoot":"","sources":["../../../src/arr/sort.ts"],"names":[],"mappings":";;;AAAO,MAAM,IAAI,GAAG,CAAI,GAAQ,EAAE,KAAiC,EAAO,EAAE;IAC1E,MAAM,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,CAAU,CAAC,CAAC;IACzD,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE;QACvB,IAAI,CAAC,GAAG,CAAC,EAAE;YACT,OAAO,CAAC,CAAC,CAAC;SACX;QACD,IAAI,CAAC,GAAG,CAAC,EAAE;YACT,OAAO,CAAC,CAAC;SACV;QACD,OAAO,CAAC,CAAC;IACX,CAAC,CAAC,CAAC;IACH,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;QAC3B,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;IACd,CAAC,CAAC,CAAC;IACH,OAAO,GAAG,CAAC;AACb,CAAC,CAAC;AAfW,QAAA,IAAI,QAef"}

package/dist/cjs/arr/transpose.d.ts

@@ -1,2 +0,0 @@
-import type { Transpose } from "./types";
-export declare const transpose: <T extends unknown[][]>(matrix: T) => Transpose<T>;

package/dist/cjs/arr/transpose.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transpose = void 0;
-const from_1 = require("./from");
-const transpose = (matrix) => {
-    const rows = matrix.length;
-    const cols = matrix[0].length;
-    const res = (0, from_1.from)(cols, (i) => (0, from_1.from)(rows, (j) => matrix[j][i]));
-    return res;
-};
-exports.transpose = transpose;
-//# sourceMappingURL=transpose.js.map

package/dist/cjs/arr/transpose.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"transpose.js","sourceRoot":"","sources":["../../../src/arr/transpose.ts"],"names":[],"mappings":";;;AAAA,iCAA8B;AAGvB,MAAM,SAAS,GAAG,CAAwB,MAAS,EAAgB,EAAE;IAC1E,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC;IAC3B,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;IAC9B,MAAM,GAAG,GAAG,IAAA,WAAI,EAAC,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,IAAA,WAAI,EAAC,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/D,OAAO,GAA8B,CAAC;AACxC,CAAC,CAAC;AALW,QAAA,SAAS,aAKpB"}

package/dist/cjs/arr/types.d.ts

@@ -1,11 +0,0 @@
-type Predicate<T, R = boolean> = (val: T, idx: number, arr: T[]) => R;
-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;
-type Tuple<T, N extends number, R extends T[] = []> = R["length"] extends N ? R : Tuple<T, N, [...R, T]>;
-type ConvertTuple<T, ToType> = {
-    [K in keyof T]: ToType;
-};
-export type { ConvertTuple, Predicate, Transpose, Tuple };

package/dist/cjs/arr/types.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=types.js.map

package/dist/cjs/arr/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/arr/types.ts"],"names":[],"mappings":""}

package/dist/cjs/arr/union.d.ts

@@ -1 +0,0 @@
-export declare const union: <T>(...args: T[][]) => Set<T>;