@mdigitalcn/utils 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ulukbek Dzhunusov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,228 @@
+# @mdigitalcn/utils
+
+Production-grade TypeScript utilities and React hooks. Zero dependencies (except optional React peer).
+
+Tree-shakeable, ESM-only, with full type inference.
+
+## Install
+
+```bash
+pnpm add @mdigitalcn/utils
+# or
+npm install @mdigitalcn/utils
+```
+
+## Usage
+
+```ts
+// Import everything
+import { pipe, pick, isNil, chunk } from '@mdigitalcn/utils';
+
+// Or use subpath imports for smaller bundles
+import { chunk, groupBy, zip } from '@mdigitalcn/utils/array';
+import { pick, omit, set, get } from '@mdigitalcn/utils/object';
+import { pipe, compose, debounce } from '@mdigitalcn/utils/function';
+import { isNil, isEqual, isDate } from '@mdigitalcn/utils/predicate';
+import { clamp, range, sum } from '@mdigitalcn/utils/math';
+import { camelCase, kebabCase, words } from '@mdigitalcn/utils/string';
+import { retry, timeout, delay } from '@mdigitalcn/utils/promise';
+import { useDebounce, useToggle } from '@mdigitalcn/utils/react';
+import { downloadFile, getBase64 } from '@mdigitalcn/utils/file';
+import { validateFileSize } from '@mdigitalcn/utils/validation';
+```
+
+## API Overview
+
+### Array
+
+| Function | Description |
+|----------|-------------|
+| `chunk(arr, size)` | Split array into groups of `size` |
+| `compact(arr)` | Remove falsy values |
+| `difference(a, b)` | Elements in `a` not in `b` |
+| `drop(arr, n)` | Remove first `n` elements |
+| `first(arr)` | First element or `undefined` |
+| `flatten(arr)` | Flatten one level |
+| `groupBy(arr, fn)` | Group by function result |
+| `intersection(a, b)` | Elements in both arrays |
+| `keyBy(arr, fn)` | Index array into object by key |
+| `last(arr)` | Last element or `undefined` |
+| `partition(arr, fn)` | Split into `[pass, fail]` |
+| `shuffle(arr)` | Random order (Fisher-Yates) |
+| `sortBy(arr, fn)` | Sort by function result |
+| `take(arr, n)` | First `n` elements |
+| `uniq(arr)` | Remove duplicates |
+| `uniqBy(arr, fn)` | Remove duplicates by function |
+| `zip(a, b)` | Pair elements into tuples |
+| `collectBy(arr, fn)` | Group into sub-arrays by key |
+| `checkValueInArray(arr, key, val)` | Check if value exists for key |
+| `sameElementsInArrays(...arrs)` | First element common to all |
+
+### Object
+
+| Function | Description |
+|----------|-------------|
+| `pick(obj, keys)` | Keep only specified keys |
+| `pickBy(obj, fn)` | Keep properties passing predicate |
+| `omit(obj, keys)` | Remove specified keys |
+| `omitBy(obj, fn)` | Remove properties passing predicate |
+| `get(obj, path, default?)` | Safe deep access by string/array path |
+| `set(obj, path, value)` | Immutable deep setter |
+| `has(obj, path)` | Check if deep path exists |
+| `path(obj, pathArr)` | Access by array path |
+| `pathOr(default, obj, pathArr)` | Access with fallback |
+| `prop(key)` / `prop(key, obj)` | Property accessor (curried) |
+| `propOr(default, key)` | Property accessor with fallback |
+| `mergeDeep(a, b)` | Deep merge (b wins) |
+| `cloneDeep(obj)` | Deep clone (handles circular refs) |
+| `invert(obj)` | Swap keys ↔ values |
+| `mapKeys(obj, fn)` | Transform keys |
+| `mapValues(obj, fn)` | Transform values |
+| `isEmpty(value)` | Check if empty (works with obj/arr/string/Map/Set) |
+| `getTrues(obj)` | Keep only truthy values |
+| `jsonParse(str, fallback?)` | Safe JSON.parse |
+
+### Function
+
+| Function | Description |
+|----------|-------------|
+| `pipe(f1, f2, ...)` | Left-to-right composition (type-safe up to 9 fns) |
+| `compose(f1, f2, ...)` | Right-to-left composition (type-safe up to 9 fns) |
+| `curry2(fn)` / `curry3` / `curry4` | Curry with 2–4 params |
+| `partial(fn, ...args)` | Partial application (type-safe) |
+| `memoize(fn, maxSize?)` | LRU memoization (default 500) |
+| `debounce(fn, wait)` | Debounce with `.cancel()` / `.flush()` |
+| `throttle(fn, interval)` | Throttle with `.cancel()` |
+| `once(fn)` | Execute only once |
+| `identity(x)` | Returns `x` |
+| `noop()` / `asyncNoop()` | No-op functions |
+| `hexToRgba(hex, opacity?)` | HEX → RGBA hex string |
+| `convertToFormData(obj)` | Object → FormData |
+| `createQueryString(params)` | Object → URL query string |
+
+### Predicate
+
+| Function | Description |
+|----------|-------------|
+| `isNil(v)` | `null \| undefined` guard |
+| `isNotNil(v)` | Exclude `null \| undefined` |
+| `isString(v)` | String primitive guard |
+| `isNumber(v)` | Finite number guard (excludes NaN/Infinity) |
+| `isBoolean(v)` | Boolean guard |
+| `isArray(v)` | Array guard |
+| `isFunction(v)` | Function guard |
+| `isDate(v)` | Valid Date guard (excludes invalid dates) |
+| `isPlainObject(v)` | Plain object guard (excludes arrays, class instances) |
+| `isEqual(a, b)` | Deep equality (handles Date/RegExp/Map/Set) |
+
+### Math
+
+| Function | Description |
+|----------|-------------|
+| `clamp(min, max, value)` | Clamp number to range |
+| `sum(numbers)` | Sum array |
+| `mean(numbers)` | Arithmetic mean |
+| `median(numbers)` | Median value |
+| `round(value, precision?)` | Round to decimal places |
+| `random(min, max?)` | Random float |
+| `randomInt(min, max?)` | Random integer |
+| `range(start, end?, step?)` | Generate number array |
+| `inRange(value, start, end?)` | Check if in range |
+
+### String
+
+| Function | Description |
+|----------|-------------|
+| `capitalize(str)` | Capitalize first letter |
+| `camelCase(str)` | Convert to camelCase |
+| `kebabCase(str)` | Convert to kebab-case |
+| `snakeCase(str)` | Convert to snake_case |
+| `words(str)` | Split into word array |
+| `escapeHtml(str)` | Escape HTML entities |
+| `formatNumber(num, locale?)` | Format with thousands separators |
+| `truncateString(str, max)` | Truncate with ellipsis |
+| `htmlToText(html)` | Strip HTML tags |
+
+### Promise
+
+| Function | Description |
+|----------|-------------|
+| `delay(ms)` | Promise-based delay |
+| `retry(fn, options?)` | Retry with exponential backoff |
+| `timeout(promise, ms, msg?)` | Timeout wrapper |
+
+### React Hooks
+
+> Requires `react >= 19.0.0` as peer dependency.
+
+| Hook | Description |
+|------|-------------|
+| `useDebounce(value, delay)` | Debounce a value |
+| `useThrottle(callback, delay)` | Throttle a callback |
+| `useLocalStorage(key, initial)` | Persistent state in localStorage |
+| `useSessionStorage(key, initial)` | Persistent state in sessionStorage |
+| `useToggle(initial?)` | Boolean toggle `[state, toggle, set]` |
+| `usePrevious(value)` | Previous render's value |
+| `useClickOutside(callback)` | Detect clicks outside element |
+| `useMediaQuery(query)` | CSS media query match |
+| `useIntersectionObserver(opts?)` | Viewport intersection detection |
+| `useMountEffect(effect)` | Run once on mount |
+| `useUpdateEffect(effect, deps)` | Run on updates only (skip mount) |
+| `useScreenSize(threshold?)` | Check if below width threshold |
+| `useIsMounted()` | Check if component is mounted |
+| `useCopyToClipboard(resetDelay?)` | Copy text to clipboard |
+
+### React Utilities
+
+| Utility | Description |
+|---------|-------------|
+| `clsx(...args)` | Conditional class name builder |
+| `createContext(name)` | Type-safe context + hook factory |
+| `displayField(value, placeholder?)` | Display-safe value with fallback |
+
+### File
+
+| Function | Description |
+|----------|-------------|
+| `anyToString(value)` | File → object URL, string → string |
+| `downloadFile(getData, name)` | Download blob as file |
+| `getBase64(file)` | File → base64 string |
+| `isFileArray(value)` | Check if array of File/Blob |
+| `decodeURIValue(uri)` | Extract filename from URI |
+
+### Validation
+
+| Function | Description |
+|----------|-------------|
+| `validateFileSize(file, limits, resolver?)` | Validate file size by category |
+
+### Types
+
+```ts
+import type {
+  Predicate,
+  Transformer,
+  Comparator,
+  Reducer,
+  Curried2, Curried3, Curried4,
+  DeepReadonly,
+  DeepPartial,
+  Nullish,
+  RequireKeys,
+  OptionalKeys,
+} from '@mdigitalcn/utils';
+```
+
+## Convention
+
+All functions use **data-first** argument order:
+
+```ts
+pick(object, keys)      // ✅ data first
+groupBy(array, fn)      // ✅ data first
+partition(array, fn)    // ✅ data first
+```
+
+## License
+
+MIT

package/dist/esm/array/checkValueInArray.js

@@ -0,0 +1,2 @@
+function r(r,t,o){for(const e of r)if(Object.prototype.hasOwnProperty.call(e,t)&&e[t]===o)return!0;return!1}export{r as checkValueInArray};
+//# sourceMappingURL=checkValueInArray.js.map

package/dist/esm/array/checkValueInArray.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkValueInArray.js","sources":["../../../src/array/checkValueInArray.ts"],"sourcesContent":["/**\n * Checks if a value exists for a given key in any object within an array.\n *\n * Iterates over the array of objects and returns `true` if **any** object\n * has the specified key and its value strictly equals the provided value.\n *\n * @example\n * const users = [\n *   { id: '1', name: 'Alice' },\n *   { id: '2', name: 'Bob' }\n * ];\n *\n * checkValueInArray(users, 'name', 'Alice') // true\n * checkValueInArray(users, 'id', '3') // false\n *\n * @template T - The type of objects in the array\n * @param {T[]} array - Array of objects to check\n * @param {keyof T} key - Key to check in each object\n * @param {T[keyof T]} value - Value to compare against\n * @returns {boolean} `true` if at least one object has the key with the given value, otherwise `false`\n */\nexport function checkValueInArray<T>(\n  array: T[],\n  key: keyof T,\n  value: T[keyof T]\n): boolean {\n  for (const obj of array) {\n    if (Object.prototype.hasOwnProperty.call(obj, key) && obj[key] === value) {\n      return true;\n    }\n  }\n  return false;\n}\n"],"names":["checkValueInArray","array","key","value","obj","Object","prototype","hasOwnProperty","call"],"mappings":"SAqBgBA,EACdC,EACAC,EACAC,GAEA,IAAK,MAAMC,KAAOH,EAChB,GAAII,OAAOC,UAAUC,eAAeC,KAAKJ,EAAKF,IAAQE,EAAIF,KAASC,EACjE,OAAO,EAGX,OAAO,CACT"}

package/dist/esm/array/chunk.js

@@ -0,0 +1,2 @@
+function t(t,e){if(e<1)throw new Error("chunk: size must be at least 1");const r=[];for(let n=0;n<t.length;n+=e)r.push(t.slice(n,n+e));return r}export{t as chunk};
+//# sourceMappingURL=chunk.js.map

package/dist/esm/array/chunk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.js","sources":["../../../src/array/chunk.ts"],"sourcesContent":["/**\n * Splits an array into groups of the specified size.\n *\n * @example\n * chunk([1, 2, 3, 4, 5], 2) // [[1, 2], [3, 4], [5]]\n * chunk([1, 2, 3], 1) // [[1], [2], [3]]\n * chunk([], 3) // []\n *\n * @param arr - Array to split\n * @param size - Size of each chunk (must be > 0)\n * @returns Array of chunks\n * @throws {Error} If size is less than 1\n */\nexport function chunk<T>(arr: readonly T[], size: number): T[][] {\n  if (size < 1) {\n    throw new Error('chunk: size must be at least 1');\n  }\n\n  const result: T[][] = [];\n  for (let i = 0; i < arr.length; i += size) {\n    result.push(arr.slice(i, i + size));\n  }\n  return result;\n}\n"],"names":["chunk","arr","size","Error","result","i","length","push","slice"],"mappings":"AAaM,SAAUA,EAASC,EAAmBC,GAC1C,GAAIA,EAAO,EACT,MAAM,IAAIC,MAAM,kCAGlB,MAAMC,EAAgB,GACtB,IAAK,IAAIC,EAAI,EAAGA,EAAIJ,EAAIK,OAAQD,GAAKH,EACnCE,EAAOG,KAAKN,EAAIO,MAAMH,EAAGA,EAAIH,IAE/B,OAAOE,CACT"}

package/dist/esm/array/collectBy.js

@@ -0,0 +1,2 @@
+function o(o,t){const n={};for(const c of o){const o=t(c);n[o]||(n[o]=[]),n[o].push(c)}return Object.values(n)}export{o as collectBy};
+//# sourceMappingURL=collectBy.js.map

package/dist/esm/array/collectBy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collectBy.js","sources":["../../../src/array/collectBy.ts"],"sourcesContent":["/**\n * Splits a list into sub-lists based on a key returned from each item.\n *\n * @example\n * const result = collectBy(\n *   [\n *     { type: 'breakfast', item: '☕️' },\n *     { type: 'lunch', item: '🌯' },\n *     { type: 'dinner', item: '🍝' },\n *     { type: 'breakfast', item: '🥐' },\n *     { type: 'lunch', item: '🍕' }\n *   ],\n *   (item) => item.type\n * );\n *\n * @param list Array of items\n * @param fn Function that extracts a key from each item\n * @returns Array of groups, each group containing items with same key\n */\nexport function collectBy<T, K extends string | number | symbol>(\n  list: T[],\n  fn: (item: T) => K\n): T[][] {\n  const groups: Record<K, T[]> = {} as Record<K, T[]>;\n\n  for (const item of list) {\n    const key = fn(item);\n\n    if (!groups[key]) {\n      groups[key] = [];\n    }\n\n    groups[key].push(item);\n  }\n\n  return Object.values(groups);\n}\n"],"names":["collectBy","list","fn","groups","item","key","push","Object","values"],"mappings":"AAmBM,SAAUA,EACdC,EACAC,GAEA,MAAMC,EAAyB,CAAA,EAE/B,IAAK,MAAMC,KAAQH,EAAM,CACvB,MAAMI,EAAMH,EAAGE,GAEVD,EAAOE,KACVF,EAAOE,GAAO,IAGhBF,EAAOE,GAAKC,KAAKF,EACnB,CAEA,OAAOG,OAAOC,OAAOL,EACvB"}

package/dist/esm/array/compact.js

@@ -0,0 +1,2 @@
+function e(e){return e.filter(Boolean)}export{e as compact};
+//# sourceMappingURL=compact.js.map

package/dist/esm/array/compact.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compact.js","sources":["../../../src/array/compact.ts"],"sourcesContent":["/**\n * Removes all falsy values (false, null, 0, '', undefined, NaN) from an array.\n * Returns a properly narrowed type excluding falsy values.\n *\n * @example\n * compact([0, 1, false, 2, '', 3, null, undefined, NaN])\n * // [1, 2, 3]\n *\n * @example\n * compact(['hello', '', 'world', null])\n * // ['hello', 'world']\n *\n * @param arr - Array to compact\n * @returns New array without falsy values\n */\ntype Falsy = false | null | undefined | 0 | '' | 0n;\n\nexport function compact<T>(arr: readonly (T | Falsy)[]): Exclude<T, Falsy>[] {\n  return arr.filter(Boolean) as Exclude<T, Falsy>[];\n}\n"],"names":["compact","arr","filter","Boolean"],"mappings":"AAiBM,SAAUA,EAAWC,GACzB,OAAOA,EAAIC,OAAOC,QACpB"}

package/dist/esm/array/countBy.js

@@ -0,0 +1,2 @@
+function n(n,o){const t={};for(const r of n){const n=String(o(r));t[n]=(t[n]||0)+1}return t}export{n as countBy};
+//# sourceMappingURL=countBy.js.map

package/dist/esm/array/countBy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"countBy.js","sources":["../../../src/array/countBy.ts"],"sourcesContent":["/**\n * Counts occurrences of each item based on a transformation function.\n *\n * @example\n * countBy(['a', 'b', 'a', 'c', 'b', 'a'], x => x) // { a: 3, b: 2, c: 1 }\n * countBy([1, 2, 3, 4, 5], x => x % 2 === 0 ? 'even' : 'odd') // { odd: 3, even: 2 }\n *\n * @param arr - Array to count\n * @param fn - Function that returns the group key for each item\n * @returns Object with keys and their counts\n */\nexport function countBy<T>(\n  arr: readonly T[],\n  fn: (item: T) => string | number\n): Record<string, number> {\n  const result: Record<string, number> = {};\n  for (const item of arr) {\n    const key = String(fn(item));\n    result[key] = (result[key] || 0) + 1;\n  }\n  return result;\n}\n"],"names":["countBy","arr","fn","result","item","key","String"],"mappings":"AAWM,SAAUA,EACdC,EACAC,GAEA,MAAMC,EAAiC,CAAA,EACvC,IAAK,MAAMC,KAAQH,EAAK,CACtB,MAAMI,EAAMC,OAAOJ,EAAGE,IACtBD,EAAOE,IAAQF,EAAOE,IAAQ,GAAK,CACrC,CACA,OAAOF,CACT"}

package/dist/esm/array/difference.js

@@ -0,0 +1,2 @@
+function t(t,e){const n=new Set(e);return t.filter(t=>!n.has(t))}export{t as difference};
+//# sourceMappingURL=difference.js.map

package/dist/esm/array/difference.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"difference.js","sources":["../../../src/array/difference.ts"],"sourcesContent":["/**\n * Returns elements from the first array that are not in the second array.\n *\n * @example\n * difference([1, 2, 3, 4], [2, 4]) // [1, 3]\n * difference(['a', 'b', 'c'], ['b']) // ['a', 'c']\n * difference([1, 2], [1, 2]) // []\n *\n * @param arr1 - Source array\n * @param arr2 - Array of elements to exclude\n * @returns Array of elements only in arr1\n */\nexport function difference<T>(arr1: readonly T[], arr2: readonly T[]): T[] {\n  const set = new Set(arr2);\n  return arr1.filter((item) => !set.has(item));\n}\n"],"names":["difference","arr1","arr2","set","Set","filter","item","has"],"mappings":"AAYM,SAAUA,EAAcC,EAAoBC,GAChD,MAAMC,EAAM,IAAIC,IAAIF,GACpB,OAAOD,EAAKI,OAAQC,IAAUH,EAAII,IAAID,GACxC"}

package/dist/esm/array/drop.js

@@ -0,0 +1,2 @@
+function t(t,e){return t.slice(Math.max(0,e))}export{t as drop};
+//# sourceMappingURL=drop.js.map

package/dist/esm/array/drop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"drop.js","sources":["../../../src/array/drop.ts"],"sourcesContent":["/**\n * Returns all but the first n elements of an array.\n *\n * @example\n * drop([1, 2, 3, 4, 5], 2) // [3, 4, 5]\n * drop([1, 2], 5) // []\n * drop([], 3) // []\n *\n * @param arr - Source array\n * @param n - Number of elements to drop\n * @returns New array without the first n elements\n */\nexport function drop<T>(arr: readonly T[], n: number): T[] {\n  return arr.slice(Math.max(0, n));\n}\n"],"names":["drop","arr","n","slice","Math","max"],"mappings":"AAYM,SAAUA,EAAQC,EAAmBC,GACzC,OAAOD,EAAIE,MAAMC,KAAKC,IAAI,EAAGH,GAC/B"}

package/dist/esm/array/dropWhile.js

@@ -0,0 +1,2 @@
+function n(n,e){const t=n.findIndex((n,t)=>!e(n,t));return-1===t?[]:n.slice(t)}export{n as dropWhile};
+//# sourceMappingURL=dropWhile.js.map

package/dist/esm/array/dropWhile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dropWhile.js","sources":["../../../src/array/dropWhile.ts"],"sourcesContent":["/**\n * Drops leading elements while predicate returns true, returns the rest.\n *\n * @example\n * dropWhile([1, 2, 3, 4, 1], x => x < 3) // [3, 4, 1]\n * dropWhile([5, 4, 3], x => x > 3) // [3]\n *\n * @param arr - Source array\n * @param fn - Predicate function\n * @returns New array without leading elements that pass the predicate\n */\nexport function dropWhile<T>(arr: readonly T[], fn: (item: T, index: number) => boolean): T[] {\n  const idx = arr.findIndex((item, i) => !fn(item, i));\n  return idx === -1 ? [] : arr.slice(idx);\n}\n"],"names":["dropWhile","arr","fn","idx","findIndex","item","i","slice"],"mappings":"AAWM,SAAUA,EAAaC,EAAmBC,GAC9C,MAAMC,EAAMF,EAAIG,UAAU,CAACC,EAAMC,KAAOJ,EAAGG,EAAMC,IACjD,OAAe,IAARH,EAAa,GAAKF,EAAIM,MAAMJ,EACrC"}

package/dist/esm/array/first.js

@@ -0,0 +1,2 @@
+function n(n){return n[0]}export{n as first};
+//# sourceMappingURL=first.js.map

package/dist/esm/array/first.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"first.js","sources":["../../../src/array/first.ts"],"sourcesContent":["/**\n * Returns the first element of an array, or undefined if empty.\n *\n * @example\n * first([1, 2, 3]) // 1\n * first([]) // undefined\n * first(['a', 'b']) // 'a'\n *\n * @param arr - Source array\n * @returns First element or undefined\n */\nexport function first<T>(arr: readonly T[]): T | undefined {\n  return arr[0];\n}\n"],"names":["first","arr"],"mappings":"AAWM,SAAUA,EAASC,GACvB,OAAOA,EAAI,EACb"}

package/dist/esm/array/flatten.js

@@ -0,0 +1,2 @@
+function t(t){return t.flat()}export{t as flatten};
+//# sourceMappingURL=flatten.js.map

package/dist/esm/array/flatten.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatten.js","sources":["../../../src/array/flatten.ts"],"sourcesContent":["/**\n * Flattens a nested array by one level.\n *\n * @example\n * flatten([[1, 2], [3, 4], [5]]) // [1, 2, 3, 4, 5]\n * flatten([[1, [2]], [3]]) // [1, [2], 3]\n * flatten([]) // []\n *\n * @param arr - Nested array to flatten\n * @returns Flattened array (one level)\n */\nexport function flatten<T>(arr: readonly (T | readonly T[])[]): T[] {\n  return arr.flat() as T[];\n}\n"],"names":["flatten","arr","flat"],"mappings":"AAWM,SAAUA,EAAWC,GACzB,OAAOA,EAAIC,MACb"}

package/dist/esm/array/groupBy.js

@@ -0,0 +1,2 @@
+function r(r,e){return r.reduce((r,n)=>{const t=e(n);return r[t]||(r[t]=[]),r[t].push(n),r},{})}export{r as groupBy};
+//# sourceMappingURL=groupBy.js.map

package/dist/esm/array/groupBy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"groupBy.js","sources":["../../../src/array/groupBy.ts"],"sourcesContent":["/**\n * Groups array elements by the result of a function.\n *\n * @example\n * groupBy([1, 2, 3, 4], x => x % 2 === 0 ? 'even' : 'odd')\n * // { odd: [1, 3], even: [2, 4] }\n *\n * @example\n * groupBy([{ type: 'a' }, { type: 'b' }, { type: 'a' }], x => x.type)\n * // { a: [{ type: 'a' }, { type: 'a' }], b: [{ type: 'b' }] }\n *\n * @param list - Array to group\n * @param fn - Function to determine group key\n * @returns Object with grouped arrays\n */\nexport function groupBy<T>(\n  list: T[],\n  fn: (item: T) => string\n): Record<string, T[]> {\n  return list.reduce(\n    (acc, item) => {\n      const key = fn(item);\n      if (!acc[key]) {\n        acc[key] = [];\n      }\n      acc[key].push(item);\n      return acc;\n    },\n    {} as Record<string, T[]>\n  );\n}\n"],"names":["groupBy","list","fn","reduce","acc","item","key","push"],"mappings":"AAeM,SAAUA,EACdC,EACAC,GAEA,OAAOD,EAAKE,OACV,CAACC,EAAKC,KACJ,MAAMC,EAAMJ,EAAGG,GAKf,OAJKD,EAAIE,KACPF,EAAIE,GAAO,IAEbF,EAAIE,GAAKC,KAAKF,GACPD,GAET,CAAA,EAEJ"}

package/dist/esm/array/index.js

@@ -0,0 +1,2 @@
+export{chunk}from"./chunk.js";export{compact}from"./compact.js";export{countBy}from"./countBy.js";export{difference}from"./difference.js";export{drop}from"./drop.js";export{dropWhile}from"./dropWhile.js";export{first}from"./first.js";export{flatten}from"./flatten.js";export{groupBy}from"./groupBy.js";export{intersection}from"./intersection.js";export{keyBy}from"./keyBy.js";export{last}from"./last.js";export{maxBy}from"./maxBy.js";export{minBy}from"./minBy.js";export{partition}from"./partition.js";export{sample}from"./sample.js";export{shuffle}from"./shuffle.js";export{sortBy}from"./sortBy.js";export{take}from"./take.js";export{takeWhile}from"./takeWhile.js";export{union}from"./union.js";export{uniq}from"./uniq.js";export{uniqBy}from"./uniqBy.js";export{without}from"./without.js";export{xor}from"./xor.js";export{zip}from"./zip.js";export{zipObject}from"./zipObject.js";export{collectBy}from"./collectBy.js";export{checkValueInArray}from"./checkValueInArray.js";export{sameElementsInArrays}from"./sameElementsInArrays.js";
+//# sourceMappingURL=index.js.map

package/dist/esm/array/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/esm/array/intersection.js

@@ -0,0 +1,2 @@
+function t(t,e){const n=new Set(e);return t.filter(t=>n.has(t))}export{t as intersection};
+//# sourceMappingURL=intersection.js.map

package/dist/esm/array/intersection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"intersection.js","sources":["../../../src/array/intersection.ts"],"sourcesContent":["/**\n * Returns elements that exist in both arrays.\n *\n * @example\n * intersection([1, 2, 3], [2, 3, 4]) // [2, 3]\n * intersection(['a', 'b'], ['b', 'c']) // ['b']\n * intersection([1, 2], [3, 4]) // []\n *\n * @param arr1 - First array\n * @param arr2 - Second array\n * @returns Array of common elements\n */\nexport function intersection<T>(arr1: readonly T[], arr2: readonly T[]): T[] {\n  const set = new Set(arr2);\n  return arr1.filter((item) => set.has(item));\n}\n"],"names":["intersection","arr1","arr2","set","Set","filter","item","has"],"mappings":"AAYM,SAAUA,EAAgBC,EAAoBC,GAClD,MAAMC,EAAM,IAAIC,IAAIF,GACpB,OAAOD,EAAKI,OAAQC,GAASH,EAAII,IAAID,GACvC"}

package/dist/esm/array/keyBy.js

@@ -0,0 +1,2 @@
+function o(o,n){const t={};for(const r of o)t[n(r)]=r;return t}export{o as keyBy};
+//# sourceMappingURL=keyBy.js.map

package/dist/esm/array/keyBy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyBy.js","sources":["../../../src/array/keyBy.ts"],"sourcesContent":["/**\n * Creates an object composed of keys generated from the results of running\n * each element through the iteratee. The value of each key is the last\n * element responsible for generating the key.\n *\n * @example\n * keyBy([{ id: 'a1', name: 'Alice' }, { id: 'b2', name: 'Bob' }], item => item.id)\n * // { a1: { id: 'a1', name: 'Alice' }, b2: { id: 'b2', name: 'Bob' } }\n *\n * @param arr - Array to index\n * @param fn - Function that returns the key for each element\n * @returns Object indexed by the generated keys\n */\nexport function keyBy<T>(\n  arr: readonly T[],\n  fn: (item: T) => string | number\n): Record<string | number, T> {\n  const result: Record<string | number, T> = {};\n  for (const item of arr) {\n    result[fn(item)] = item;\n  }\n  return result;\n}\n"],"names":["keyBy","arr","fn","result","item"],"mappings":"AAaM,SAAUA,EACdC,EACAC,GAEA,MAAMC,EAAqC,CAAA,EAC3C,IAAK,MAAMC,KAAQH,EACjBE,EAAOD,EAAGE,IAASA,EAErB,OAAOD,CACT"}

package/dist/esm/array/last.js

@@ -0,0 +1,2 @@
+function n(n){return n[n.length-1]}export{n as last};
+//# sourceMappingURL=last.js.map

package/dist/esm/array/last.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"last.js","sources":["../../../src/array/last.ts"],"sourcesContent":["/**\n * Returns the last element of an array, or undefined if empty.\n *\n * @example\n * last([1, 2, 3]) // 3\n * last([]) // undefined\n * last(['a', 'b']) // 'b'\n *\n * @param arr - Source array\n * @returns Last element or undefined\n */\nexport function last<T>(arr: readonly T[]): T | undefined {\n  return arr[arr.length - 1];\n}\n"],"names":["last","arr","length"],"mappings":"AAWM,SAAUA,EAAQC,GACtB,OAAOA,EAAIA,EAAIC,OAAS,EAC1B"}

package/dist/esm/array/maxBy.js

@@ -0,0 +1,2 @@
+function t(t,e){if(0===t.length)return;let n=t[0],r=e(t[0]);for(let l=1;l<t.length;l++){const o=e(t[l]);o>r&&(n=t[l],r=o)}return n}export{t as maxBy};
+//# sourceMappingURL=maxBy.js.map

package/dist/esm/array/maxBy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"maxBy.js","sources":["../../../src/array/maxBy.ts"],"sourcesContent":["/**\n * Returns the element with the maximum value as determined by a function.\n *\n * @example\n * maxBy([{ age: 30 }, { age: 20 }, { age: 25 }], x => x.age) // { age: 30 }\n * maxBy([], x => x) // undefined\n *\n * @param arr - Array to search\n * @param fn - Function that returns a numeric value for comparison\n * @returns Element with the maximum value, or undefined if empty\n */\nexport function maxBy<T>(arr: readonly T[], fn: (item: T) => number): T | undefined {\n  if (arr.length === 0) return undefined;\n  let max = arr[0];\n  let maxVal = fn(arr[0]);\n  for (let i = 1; i < arr.length; i++) {\n    const val = fn(arr[i]);\n    if (val > maxVal) {\n      max = arr[i];\n      maxVal = val;\n    }\n  }\n  return max;\n}\n"],"names":["maxBy","arr","fn","length","max","maxVal","i","val"],"mappings":"AAWM,SAAUA,EAASC,EAAmBC,GAC1C,GAAmB,IAAfD,EAAIE,OAAc,OACtB,IAAIC,EAAMH,EAAI,GACVI,EAASH,EAAGD,EAAI,IACpB,IAAK,IAAIK,EAAI,EAAGA,EAAIL,EAAIE,OAAQG,IAAK,CACnC,MAAMC,EAAML,EAAGD,EAAIK,IACfC,EAAMF,IACRD,EAAMH,EAAIK,GACVD,EAASE,EAEb,CACA,OAAOH,CACT"}

package/dist/esm/array/minBy.js

@@ -0,0 +1,2 @@
+function t(t,e){if(0===t.length)return;let n=t[0],r=e(t[0]);for(let l=1;l<t.length;l++){const o=e(t[l]);o<r&&(n=t[l],r=o)}return n}export{t as minBy};
+//# sourceMappingURL=minBy.js.map

package/dist/esm/array/minBy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"minBy.js","sources":["../../../src/array/minBy.ts"],"sourcesContent":["/**\n * Returns the element with the minimum value as determined by a function.\n *\n * @example\n * minBy([{ age: 30 }, { age: 20 }, { age: 25 }], x => x.age) // { age: 20 }\n * minBy([], x => x) // undefined\n *\n * @param arr - Array to search\n * @param fn - Function that returns a numeric value for comparison\n * @returns Element with the minimum value, or undefined if empty\n */\nexport function minBy<T>(arr: readonly T[], fn: (item: T) => number): T | undefined {\n  if (arr.length === 0) return undefined;\n  let min = arr[0];\n  let minVal = fn(arr[0]);\n  for (let i = 1; i < arr.length; i++) {\n    const val = fn(arr[i]);\n    if (val < minVal) {\n      min = arr[i];\n      minVal = val;\n    }\n  }\n  return min;\n}\n"],"names":["minBy","arr","fn","length","min","minVal","i","val"],"mappings":"AAWM,SAAUA,EAASC,EAAmBC,GAC1C,GAAmB,IAAfD,EAAIE,OAAc,OACtB,IAAIC,EAAMH,EAAI,GACVI,EAASH,EAAGD,EAAI,IACpB,IAAK,IAAIK,EAAI,EAAGA,EAAIL,EAAIE,OAAQG,IAAK,CACnC,MAAMC,EAAML,EAAGD,EAAIK,IACfC,EAAMF,IACRD,EAAMH,EAAIK,GACVD,EAASE,EAEb,CACA,OAAOH,CACT"}

package/dist/esm/array/partition.js

@@ -0,0 +1,2 @@
+function o(o,n){const t=[],r=[];for(const s of o)n(s)?t.push(s):r.push(s);return[t,r]}export{o as partition};
+//# sourceMappingURL=partition.js.map

package/dist/esm/array/partition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition.js","sources":["../../../src/array/partition.ts"],"sourcesContent":["import type { Predicate } from '../types/index.js';\n\n/**\n * Partitions an array into two arrays based on a predicate.\n *\n * @example\n * partition([1, 2, 3, 4], x => x > 2) // [[3, 4], [1, 2]]\n *\n * @param list - Array to partition\n * @param predicate - Function to test each element\n * @returns Tuple of [passed, failed] arrays\n */\nexport function partition<T>(list: T[], predicate: Predicate<T>): [T[], T[]] {\n  const passed: T[] = [];\n  const failed: T[] = [];\n\n  for (const item of list) {\n    if (predicate(item)) {\n      passed.push(item);\n    } else {\n      failed.push(item);\n    }\n  }\n\n  return [passed, failed];\n}\n"],"names":["partition","list","predicate","passed","failed","item","push"],"mappings":"AAYM,SAAUA,EAAaC,EAAWC,GACtC,MAAMC,EAAc,GACdC,EAAc,GAEpB,IAAK,MAAMC,KAAQJ,EACbC,EAAUG,GACZF,EAAOG,KAAKD,GAEZD,EAAOE,KAAKD,GAIhB,MAAO,CAACF,EAAQC,EAClB"}

package/dist/esm/array/sameElementsInArrays.js

@@ -0,0 +1,2 @@
+const n=(...n)=>{if(0===n.length)return null;const[e,...l]=n;return e.find(n=>l.every(e=>e.includes(n)))||null};export{n as sameElementsInArrays};
+//# sourceMappingURL=sameElementsInArrays.js.map

package/dist/esm/array/sameElementsInArrays.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sameElementsInArrays.js","sources":["../../../src/array/sameElementsInArrays.ts"],"sourcesContent":["/**\n * Finds the first element that exists in all provided arrays.\n *\n * Works with any type (numbers, strings, booleans, etc.).\n *\n * @example\n * sameElementInMultipleArrays([1, 2, 3], [3, 4, 5], [3, 6]) // 3\n * sameElementInMultipleArrays(['a', 'b'], ['b', 'c'], ['b', 'd']) // 'b'\n * sameElementInMultipleArrays([1, 2], [3, 4]) // null\n *\n * @param {...T[][]} arrays - Two or more arrays to check\n * @returns {T | null} The first element found in all arrays, or `null` if none found\n */\nexport const sameElementsInArrays = <T>(...arrays: T[][]): T | null => {\n  if (arrays.length === 0) return null;\n  const [first, ...rest] = arrays;\n\n  return first.find((item) => rest.every((arr) => arr.includes(item))) || null;\n};\n"],"names":["sameElementsInArrays","arrays","length","first","rest","find","item","every","arr","includes"],"mappings":"MAaaA,EAAuB,IAAOC,KACzC,GAAsB,IAAlBA,EAAOC,OAAc,OAAO,KAChC,MAAOC,KAAUC,GAAQH,EAEzB,OAAOE,EAAME,KAAMC,GAASF,EAAKG,MAAOC,GAAQA,EAAIC,SAASH,MAAW"}

package/dist/esm/array/sample.js

@@ -0,0 +1,2 @@
+function t(t){if(0!==t.length)return t[Math.floor(Math.random()*t.length)]}export{t as sample};
+//# sourceMappingURL=sample.js.map

package/dist/esm/array/sample.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sample.js","sources":["../../../src/array/sample.ts"],"sourcesContent":["/**\n * Returns a random element from an array.\n *\n * @example\n * sample([1, 2, 3, 4, 5]) // random element\n * sample(['a', 'b', 'c']) // random element\n *\n * @param arr - Source array\n * @returns Random element, or undefined if empty\n */\nexport function sample<T>(arr: readonly T[]): T | undefined {\n  if (arr.length === 0) return undefined;\n  return arr[Math.floor(Math.random() * arr.length)];\n}\n"],"names":["sample","arr","length","Math","floor","random"],"mappings":"AAUM,SAAUA,EAAUC,GACxB,GAAmB,IAAfA,EAAIC,OACR,OAAOD,EAAIE,KAAKC,MAAMD,KAAKE,SAAWJ,EAAIC,QAC5C"}

package/dist/esm/array/shuffle.js

@@ -0,0 +1,2 @@
+function t(t){const o=[...t];for(let t=o.length-1;t>0;t--){const n=Math.floor(Math.random()*(t+1));[o[t],o[n]]=[o[n],o[t]]}return o}export{t as shuffle};
+//# sourceMappingURL=shuffle.js.map

package/dist/esm/array/shuffle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shuffle.js","sources":["../../../src/array/shuffle.ts"],"sourcesContent":["/**\n * Returns a new array with elements in random order using Fisher-Yates algorithm.\n * Does not mutate the original array.\n *\n * @example\n * shuffle([1, 2, 3, 4, 5]) // [3, 1, 5, 2, 4] (random)\n *\n * @param arr - Array to shuffle\n * @returns New shuffled array\n */\nexport function shuffle<T>(arr: readonly T[]): T[] {\n  const result = [...arr];\n  for (let i = result.length - 1; i > 0; i--) {\n    const j = Math.floor(Math.random() * (i + 1));\n    [result[i], result[j]] = [result[j], result[i]];\n  }\n  return result;\n}\n"],"names":["shuffle","arr","result","i","length","j","Math","floor","random"],"mappings":"AAUM,SAAUA,EAAWC,GACzB,MAAMC,EAAS,IAAID,GACnB,IAAK,IAAIE,EAAID,EAAOE,OAAS,EAAGD,EAAI,EAAGA,IAAK,CAC1C,MAAME,EAAIC,KAAKC,MAAMD,KAAKE,UAAYL,EAAI,KACzCD,EAAOC,GAAID,EAAOG,IAAM,CAACH,EAAOG,GAAIH,EAAOC,GAC9C,CACA,OAAOD,CACT"}

package/dist/esm/array/sortBy.js

@@ -0,0 +1,2 @@
+function r(r,t){return[...r].sort((r,n)=>{const o=t(r),e=t(n);return o<e?-1:o>e?1:0})}export{r as sortBy};
+//# sourceMappingURL=sortBy.js.map

package/dist/esm/array/sortBy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortBy.js","sources":["../../../src/array/sortBy.ts"],"sourcesContent":["/**\n * Returns a new array sorted by the result of a function applied to each element.\n * Supports multiple sort keys with optional direction.\n * Does not mutate the original array.\n *\n * @example\n * sortBy([{ age: 30 }, { age: 20 }, { age: 25 }], item => item.age)\n * // [{ age: 20 }, { age: 25 }, { age: 30 }]\n *\n * @example\n * // Descending order\n * sortBy([3, 1, 2], x => -x)\n * // [3, 2, 1]\n *\n * @param arr - Array to sort\n * @param fn - Function that returns the value to sort by\n * @returns New sorted array\n */\nexport function sortBy<T>(\n  arr: readonly T[],\n  fn: (item: T) => number | string\n): T[] {\n  return [...arr].sort((a, b) => {\n    const va = fn(a);\n    const vb = fn(b);\n    if (va < vb) return -1;\n    if (va > vb) return 1;\n    return 0;\n  });\n}\n"],"names":["sortBy","arr","fn","sort","a","b","va","vb"],"mappings":"AAkBM,SAAUA,EACdC,EACAC,GAEA,MAAO,IAAID,GAAKE,KAAK,CAACC,EAAGC,KACvB,MAAMC,EAAKJ,EAAGE,GACRG,EAAKL,EAAGG,GACd,OAAIC,EAAKC,GAAW,EAChBD,EAAKC,EAAW,EACb,GAEX"}

package/dist/esm/array/take.js

@@ -0,0 +1,2 @@
+function t(t,e){return t.slice(0,Math.max(0,e))}export{t as take};
+//# sourceMappingURL=take.js.map

package/dist/esm/array/take.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"take.js","sources":["../../../src/array/take.ts"],"sourcesContent":["/**\n * Returns the first n elements of an array.\n *\n * @example\n * take([1, 2, 3, 4, 5], 3) // [1, 2, 3]\n * take([1, 2], 5) // [1, 2]\n * take([], 3) // []\n *\n * @param arr - Source array\n * @param n - Number of elements to take\n * @returns New array with first n elements\n */\nexport function take<T>(arr: readonly T[], n: number): T[] {\n  return arr.slice(0, Math.max(0, n));\n}\n"],"names":["take","arr","n","slice","Math","max"],"mappings":"AAYM,SAAUA,EAAQC,EAAmBC,GACzC,OAAOD,EAAIE,MAAM,EAAGC,KAAKC,IAAI,EAAGH,GAClC"}

package/dist/esm/array/takeWhile.js

@@ -0,0 +1,2 @@
+function t(t,n){const e=[];for(let o=0;o<t.length&&n(t[o],o);o++)e.push(t[o]);return e}export{t as takeWhile};
+//# sourceMappingURL=takeWhile.js.map

package/dist/esm/array/takeWhile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"takeWhile.js","sources":["../../../src/array/takeWhile.ts"],"sourcesContent":["/**\n * Returns leading elements while predicate returns true.\n *\n * @example\n * takeWhile([1, 2, 3, 4, 1], x => x < 3) // [1, 2]\n * takeWhile([5, 4, 3], x => x > 3) // [5, 4]\n *\n * @param arr - Source array\n * @param fn - Predicate function\n * @returns New array of leading elements passing the predicate\n */\nexport function takeWhile<T>(arr: readonly T[], fn: (item: T, index: number) => boolean): T[] {\n  const result: T[] = [];\n  for (let i = 0; i < arr.length; i++) {\n    if (!fn(arr[i], i)) break;\n    result.push(arr[i]);\n  }\n  return result;\n}\n"],"names":["takeWhile","arr","fn","result","i","length","push"],"mappings":"AAWM,SAAUA,EAAaC,EAAmBC,GAC9C,MAAMC,EAAc,GACpB,IAAK,IAAIC,EAAI,EAAGA,EAAIH,EAAII,QACjBH,EAAGD,EAAIG,GAAIA,GADcA,IAE9BD,EAAOG,KAAKL,EAAIG,IAElB,OAAOD,CACT"}

package/dist/esm/array/union.js

@@ -0,0 +1,2 @@
+function e(e,n){return[...new Set([...e,...n])]}export{e as union};
+//# sourceMappingURL=union.js.map

package/dist/esm/array/union.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"union.js","sources":["../../../src/array/union.ts"],"sourcesContent":["/**\n * Creates an array of unique values from two arrays.\n *\n * @example\n * union([1, 2, 3], [3, 4, 5]) // [1, 2, 3, 4, 5]\n * union(['a'], ['a', 'b']) // ['a', 'b']\n *\n * @param arr1 - First array\n * @param arr2 - Second array\n * @returns Array of unique values from both\n */\nexport function union<T>(arr1: readonly T[], arr2: readonly T[]): T[] {\n  return [...new Set([...arr1, ...arr2])];\n}\n"],"names":["union","arr1","arr2","Set"],"mappings":"AAWM,SAAUA,EAASC,EAAoBC,GAC3C,MAAO,IAAI,IAAIC,IAAI,IAAIF,KAASC,IAClC"}

package/dist/esm/array/uniq.js

@@ -0,0 +1,2 @@
+function e(e){return[...new Set(e)]}export{e as uniq};
+//# sourceMappingURL=uniq.js.map

package/dist/esm/array/uniq.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uniq.js","sources":["../../../src/array/uniq.ts"],"sourcesContent":["/**\n * Returns a new array with duplicate values removed.\n * Optimized: Uses spread operator instead of Array.from to avoid extra iteration.\n *\n * @example\n * uniq([1, 2, 2, 3, 3, 4]) // [1, 2, 3, 4]\n *\n * @param list - Array to deduplicate\n * @returns New array with unique values\n */\nexport function uniq<T>(list: T[]): T[] {\n  return [...new Set(list)];\n}\n"],"names":["uniq","list","Set"],"mappings":"AAUM,SAAUA,EAAQC,GACtB,MAAO,IAAI,IAAIC,IAAID,GACrB"}

package/dist/esm/array/uniqBy.js

@@ -0,0 +1,2 @@
+function t(t,n){const e=new Set;return t.filter(t=>{const r=n(t);return!e.has(r)&&(e.add(r),!0)})}export{t as uniqBy};
+//# sourceMappingURL=uniqBy.js.map

package/dist/esm/array/uniqBy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uniqBy.js","sources":["../../../src/array/uniqBy.ts"],"sourcesContent":["/**\n * Returns a new array with duplicate values removed based on a function.\n *\n * @example\n * uniqBy([{id: 1}, {id: 1}, {id: 2}], x => x.id) // [{id: 1}, {id: 2}]\n *\n * @param list - Array to deduplicate\n * @param fn - Function to determine uniqueness\n * @returns New array with unique values\n */\nexport function uniqBy<T>(list: T[], fn: (item: T) => unknown): T[] {\n  const seen = new Set();\n  return list.filter((item) => {\n    const key = fn(item);\n    if (seen.has(key)) {\n      return false;\n    }\n    seen.add(key);\n    return true;\n  });\n}\n"],"names":["uniqBy","list","fn","seen","Set","filter","item","key","has","add"],"mappings":"AAUM,SAAUA,EAAUC,EAAWC,GACnC,MAAMC,EAAO,IAAIC,IACjB,OAAOH,EAAKI,OAAQC,IAClB,MAAMC,EAAML,EAAGI,GACf,OAAIH,EAAKK,IAAID,KAGbJ,EAAKM,IAAIF,IACF,IAEX"}

package/dist/esm/array/without.js

@@ -0,0 +1,2 @@
+function t(t,...e){const n=new Set(e);return t.filter(t=>!n.has(t))}export{t as without};
+//# sourceMappingURL=without.js.map

package/dist/esm/array/without.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"without.js","sources":["../../../src/array/without.ts"],"sourcesContent":["/**\n * Returns a new array with specified values removed.\n *\n * @example\n * without([1, 2, 3, 4, 5], 2, 4) // [1, 3, 5]\n * without(['a', 'b', 'c'], 'b') // ['a', 'c']\n *\n * @param arr - Source array\n * @param values - Values to exclude\n * @returns New array without the specified values\n */\nexport function without<T>(arr: readonly T[], ...values: T[]): T[] {\n  const set = new Set(values);\n  return arr.filter(x => !set.has(x));\n}\n"],"names":["without","arr","values","set","Set","filter","x","has"],"mappings":"SAWgBA,EAAWC,KAAsBC,GAC/C,MAAMC,EAAM,IAAIC,IAAIF,GACpB,OAAOD,EAAII,OAAOC,IAAMH,EAAII,IAAID,GAClC"}

package/dist/esm/array/xor.js

@@ -0,0 +1,2 @@
+function e(e,t){const n=new Set(e),r=new Set(t);return[...e.filter(e=>!r.has(e)),...t.filter(e=>!n.has(e))]}export{e as xor};
+//# sourceMappingURL=xor.js.map

package/dist/esm/array/xor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"xor.js","sources":["../../../src/array/xor.ts"],"sourcesContent":["/**\n * Computes the symmetric difference — elements in either array but not both.\n *\n * @example\n * xor([1, 2, 3, 4], [3, 4, 5, 6]) // [1, 2, 5, 6]\n * xor(['a', 'b'], ['b', 'c']) // ['a', 'c']\n *\n * @param arr1 - First array\n * @param arr2 - Second array\n * @returns Elements present in one array but not both\n */\nexport function xor<T>(arr1: readonly T[], arr2: readonly T[]): T[] {\n  const set1 = new Set(arr1);\n  const set2 = new Set(arr2);\n  return [\n    ...arr1.filter(x => !set2.has(x)),\n    ...arr2.filter(x => !set1.has(x)),\n  ];\n}\n"],"names":["xor","arr1","arr2","set1","Set","set2","filter","x","has"],"mappings":"AAWM,SAAUA,EAAOC,EAAoBC,GACzC,MAAMC,EAAO,IAAIC,IAAIH,GACfI,EAAO,IAAID,IAAIF,GACrB,MAAO,IACFD,EAAKK,OAAOC,IAAMF,EAAKG,IAAID,OAC3BL,EAAKI,OAAOC,IAAMJ,EAAKK,IAAID,IAElC"}

package/dist/esm/array/zip.js

@@ -0,0 +1,2 @@
+function t(t,n){const e=Math.min(t.length,n.length),h=[];for(let o=0;o<e;o++)h.push([t[o],n[o]]);return h}export{t as zip};
+//# sourceMappingURL=zip.js.map

package/dist/esm/array/zip.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip.js","sources":["../../../src/array/zip.ts"],"sourcesContent":["/**\n * Combines two arrays into an array of tuples, pairing elements by index.\n * The result length is the shorter of the two arrays.\n *\n * @example\n * zip([1, 2, 3], ['a', 'b', 'c']) // [[1, 'a'], [2, 'b'], [3, 'c']]\n * zip([1, 2], ['a']) // [[1, 'a']]\n * zip([], [1, 2]) // []\n *\n * @param a - First array\n * @param b - Second array\n * @returns Array of tuples\n */\nexport function zip<A, B>(a: readonly A[], b: readonly B[]): [A, B][] {\n  const length = Math.min(a.length, b.length);\n  const result: [A, B][] = [];\n  for (let i = 0; i < length; i++) {\n    result.push([a[i], b[i]]);\n  }\n  return result;\n}\n"],"names":["zip","a","b","length","Math","min","result","i","push"],"mappings":"AAaM,SAAUA,EAAUC,EAAiBC,GACzC,MAAMC,EAASC,KAAKC,IAAIJ,EAAEE,OAAQD,EAAEC,QAC9BG,EAAmB,GACzB,IAAK,IAAIC,EAAI,EAAGA,EAAIJ,EAAQI,IAC1BD,EAAOE,KAAK,CAACP,EAAEM,GAAIL,EAAEK,KAEvB,OAAOD,CACT"}

package/dist/esm/array/zipObject.js

@@ -0,0 +1,2 @@
+function t(t,n){const e={};for(let o=0;o<t.length;o++)e[t[o]]=n[o];return e}export{t as zipObject};
+//# sourceMappingURL=zipObject.js.map

package/dist/esm/array/zipObject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zipObject.js","sources":["../../../src/array/zipObject.ts"],"sourcesContent":["/**\n * Creates an object from arrays of keys and values.\n *\n * @example\n * zipObject(['a', 'b', 'c'], [1, 2, 3]) // { a: 1, b: 2, c: 3 }\n * zipObject(['x', 'y'], [10]) // { x: 10, y: undefined }\n *\n * @param keys - Array of keys\n * @param values - Array of values\n * @returns Object with keys mapped to values\n */\nexport function zipObject<K extends string | number, V>(\n  keys: readonly K[],\n  values: readonly V[]\n): Record<K, V | undefined> {\n  const result = {} as Record<K, V | undefined>;\n  for (let i = 0; i < keys.length; i++) {\n    result[keys[i]] = values[i];\n  }\n  return result;\n}\n"],"names":["zipObject","keys","values","result","i","length"],"mappings":"AAWM,SAAUA,EACdC,EACAC,GAEA,MAAMC,EAAS,CAAA,EACf,IAAK,IAAIC,EAAI,EAAGA,EAAIH,EAAKI,OAAQD,IAC/BD,EAAOF,EAAKG,IAAMF,EAAOE,GAE3B,OAAOD,CACT"}

package/dist/esm/file/anyToString.js

@@ -0,0 +1,2 @@
+const e=e=>e instanceof File?URL.createObjectURL(e):e;export{e as anyToString};
+//# sourceMappingURL=anyToString.js.map

package/dist/esm/file/anyToString.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anyToString.js","sources":["../../../src/file/anyToString.ts"],"sourcesContent":["/**\n * Converts a File or string value to a string suitable for usage in `src` or `href`.\n *\n * - If a `File` object is passed, it creates a temporary object URL using `URL.createObjectURL`.\n * - If a string is passed, it returns the value as-is.\n *\n * @example\n * // With a File object\n * const file = new File([\"Hello\"], \"hello.txt\");\n * const url = anyToString(file);\n * console.log(url);\n * // -> \"blob:http://localhost/...\" (temporary URL)\n *\n * @example\n * // With a string URL\n * const imageUrl = \"https://example.com/image.png\";\n * console.log(anyToString(imageUrl));\n * // -> \"https://example.com/image.png\"\n *\n * @param {File | string} value - The File or string to convert\n * @returns {string} A string representation or object URL for the file\n */\nexport const anyToString = (value: File | string): string => {\n  if (value instanceof File) {\n    return URL.createObjectURL(value);\n  }\n  return value;\n};\n"],"names":["anyToString","value","File","URL","createObjectURL"],"mappings":"AAsBO,MAAMA,EAAeC,GACtBA,aAAiBC,KACZC,IAAIC,gBAAgBH,GAEtBA"}

package/dist/esm/file/convertToFormData.js

@@ -0,0 +1,2 @@
+import{isFileArray as n}from"./isFileArray.js";const o=o=>{const r=new FormData;for(const t in o){const a=o[t];null!=a&&(n(a)?a.forEach(n=>{r.append(t,n)}):r.append(t,a))}return r};export{o as convertToFormData};
+//# sourceMappingURL=convertToFormData.js.map

package/dist/esm/file/convertToFormData.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertToFormData.js","sources":["../../../src/file/convertToFormData.ts"],"sourcesContent":["import { isFileArray } from './isFileArray.js';\n\n/**\n * Converts a plain object to FormData.\n * Supports string, number, boolean, File, Blob, or arrays of File/Blob.\n *\n * NOTE: Browser-only — requires FormData, File, Blob APIs.\n *\n * @example\n * const data = {\n *   name: \"John\",\n *   avatar: file,           // single File\n *   gallery: [file1, file2] // array of Files\n * };\n * const formData = convertToFormData(data);\n *\n * @param {Record<string, any>} data - The object to convert\n * @returns {FormData} FormData object ready for submission\n */\nexport const convertToFormData = <T extends Record<string, any>>(\n  data: T\n): FormData => {\n  const formData = new FormData();\n\n  for (const key in data) {\n    const value = data[key];\n\n    if (value !== undefined && value !== null) {\n      if (isFileArray(value)) {\n        value.forEach((file: File | Blob) => {\n          formData.append(key, file);\n        });\n      } else {\n        formData.append(key, value as string | Blob);\n      }\n    }\n  }\n\n  return formData;\n};\n"],"names":["convertToFormData","data","formData","FormData","key","value","isFileArray","forEach","file","append"],"mappings":"+CAmBO,MAAMA,EACXC,IAEA,MAAMC,EAAW,IAAIC,SAErB,IAAK,MAAMC,KAAOH,EAAM,CACtB,MAAMI,EAAQJ,EAAKG,GAEfC,UACEC,EAAYD,GACdA,EAAME,QAASC,IACbN,EAASO,OAAOL,EAAKI,KAGvBN,EAASO,OAAOL,EAAKC,GAG3B,CAEA,OAAOH"}

package/dist/esm/file/decodeURIValue.js

@@ -0,0 +1,2 @@
+const t=t=>{try{return decodeURI(t).split("/").pop()||""}catch{return""}};export{t as decodeURIValue};
+//# sourceMappingURL=decodeURIValue.js.map

package/dist/esm/file/decodeURIValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decodeURIValue.js","sources":["../../../src/file/decodeURIValue.ts"],"sourcesContent":["/**\n * Extracts the file name from a URI or URL string.\n * Decodes the URI first, so escape sequences like `%20` become normal characters.\n * Returns an empty string if decoding fails or the path is invalid.\n *\n * @example\n * decodeURIValue('https://example.com/files/%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80.pdf')\n * // → 'пример.pdf'\n *\n * @example\n * decodeURIValue('file:///C:/Users/John/Documents/file.txt')\n * // → 'file.txt'\n *\n * @example\n * decodeURIValue('invalid%URI')\n * // → ''\n *\n * @param {string} file - The URI or URL string to decode and extract the file name from\n * @returns {string} The decoded file name, or an empty string if decoding fails\n */\nexport const decodeURIValue = (file: string): string => {\n  try {\n    return decodeURI(file).split(\"/\").pop() || \"\";\n  } catch {\n    return \"\";\n  }\n};\n"],"names":["decodeURIValue","file","decodeURI","split","pop"],"mappings":"AAoBO,MAAMA,EAAkBC,IAC7B,IACE,OAAOC,UAAUD,GAAME,MAAM,KAAKC,OAAS,EAC7C,CAAE,MACA,MAAO,EACT"}

package/dist/esm/file/downloadFile.js

@@ -0,0 +1,2 @@
+const e=async(e,o)=>{try{const c=await e(),n=document.createElement("a"),l=window.URL.createObjectURL(c);n.href=l,n.download=o,n.click(),window.URL.revokeObjectURL(l),console.log("File downloaded successfully!")}catch(e){console.error("Error downloading file!",e)}};export{e as downloadFile};
+//# sourceMappingURL=downloadFile.js.map

package/dist/esm/file/downloadFile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"downloadFile.js","sources":["../../../src/file/downloadFile.ts"],"sourcesContent":["/**\n * Asynchronous utility to download a file in the browser.\n *\n * @param getData A function that returns a Promise resolving to a Blob object.\n *                For example, this can be an API call using fetch or RTK Query.\n * @param fileName The name of the file that will be suggested to the user when downloading.\n *\n * @example\n * // Downloading a file from a server\n * downloadFile(() => fetch('/api/report').then(res => res.blob()), 'report.xlsx');\n *\n * @example\n * // Using with RTK Query\n * downloadFile(() => api.endpoints.getReport.initiate(params).unwrap(), 'report.xlsx');\n *\n * @example\n * // Generating a text file on the fly\n * downloadFile(\n *   () => Promise.resolve(new Blob(['Hello World!'], { type: 'text/plain' })),\n *   'hello.txt'\n * );\n *\n * @remarks\n * The object URL is automatically revoked after downloading.\n * In case of an error, an error message is logged to the console.\n */\n\nexport const downloadFile = async (\n  getData: () => Promise<Blob>,\n  fileName: string\n) => {\n  try {\n    const blob = await getData();\n\n    const anchor = document.createElement(\"a\");\n    const objectUrl = window.URL.createObjectURL(blob);\n\n    anchor.href = objectUrl;\n    anchor.download = fileName;\n    anchor.click();\n\n    window.URL.revokeObjectURL(objectUrl);\n    console.log(\"File downloaded successfully!\");\n  } catch (err) {\n    console.error(\"Error downloading file!\", err);\n  }\n};\n"],"names":["downloadFile","async","getData","fileName","blob","anchor","document","createElement","objectUrl","window","URL","createObjectURL","href","download","click","revokeObjectURL","console","log","err","error"],"mappings":"AA2BO,MAAMA,EAAeC,MAC1BC,EACAC,KAEA,IACE,MAAMC,QAAaF,IAEbG,EAASC,SAASC,cAAc,KAChCC,EAAYC,OAAOC,IAAIC,gBAAgBP,GAE7CC,EAAOO,KAAOJ,EACdH,EAAOQ,SAAWV,EAClBE,EAAOS,QAEPL,OAAOC,IAAIK,gBAAgBP,GAC3BQ,QAAQC,IAAI,gCACd,CAAE,MAAOC,GACPF,QAAQG,MAAM,0BAA2BD,EAC3C"}

package/dist/esm/file/getBase64.js

@@ -0,0 +1,2 @@
+const e=e=>new Promise((o,r)=>{const n=new FileReader;n.readAsDataURL(e),n.onload=()=>o(n.result),n.onerror=e=>r(e)});export{e as getBase64};
+//# sourceMappingURL=getBase64.js.map