es-toolkit 1.13.1-dev.329 → 1.13.1-dev.333

package/dist/array/zipObject.mjs

@@ -1,8 +1,10 @@
-import {
-  zipObject
-} from "../chunk-BGWHVWY4.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  zipObject
-};
-//# sourceMappingURL=zipObject.mjs.map
+function zipObject(keys, values) {
+    const result = {};
+    for (let i = 0; i < keys.length; i++) {
+        result[keys[i]] = values[i];
+    }
+    return result;
+}
+
+export { zipObject };
+//# sourceMappingURL=zipObject.mjs.map

package/dist/array/zipObject.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"zipObject.mjs","sources":["../../src/array/zipObject.ts"],"sourcesContent":["/**\n * Combines two arrays, one of property names and one of corresponding values, into a single object.\n *\n * This function takes two arrays: one containing property names and another containing corresponding values.\n * It returns a new object where the property names from the first array are keys, and the corresponding elements\n * from the second array are values. If the `keys` array is longer than the `values` array, the remaining keys will\n * have `undefined` as their values.\n *\n * @template P - The type of elements in the array.\n * @template V - The type of elements in the array.\n * @param {P[]} keys - An array of property names.\n * @param {V[]} values - An array of values corresponding to the property names.\n * @returns {{ [K in P]: V }} A new object composed of the given property names and values.\n *\n * @example\n * const keys = ['a', 'b', 'c'];\n * const values = [1, 2, 3];\n * const result = zipObject(keys, values);\n * // result will be { a: 1, b: 2, c: 3 }\n *\n * const keys2 = ['a', 'b', 'c'];\n * const values2 = [1, 2];\n * const result2 = zipObject(keys2, values2);\n * // result2 will be { a: 1, b: 2, c: undefined }\n *\n * const keys2 = ['a', 'b'];\n * const values2 = [1, 2, 3];\n * const result2 = zipObject(keys2, values2);\n * // result2 will be { a: 1, b: 2 }\n */\nexport function zipObject<P extends PropertyKey, V>(keys: P[], values: V[]): { [K in P]: V } {\n  const result = {} as { [K in P]: V };\n\n  for (let i = 0; i < keys.length; i++) {\n    result[keys[i]] = values[i];\n  }\n\n  return result;\n}\n"],"names":[],"mappings":"AA8BgB,SAAA,SAAS,CAA2B,IAAS,EAAE,MAAW,EAAA;IACxE,MAAM,MAAM,GAAG,EAAqB,CAAC;AAErC,IAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACpC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;KAC7B;AAED,IAAA,OAAO,MAAM,CAAC;AAChB;;;;"}

package/dist/array/zipWith.mjs

@@ -1,8 +1,14 @@
-import {
-  zipWith
-} from "../chunk-MJ7LNBI6.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  zipWith
-};
-//# sourceMappingURL=zipWith.mjs.map
+function zipWith(arr1, ...rest) {
+    const arrs = [arr1, ...rest.slice(0, -1)];
+    const combine = rest[rest.length - 1];
+    const result = [];
+    const maxIndex = Math.max(...arrs.map(arr => arr.length));
+    for (let i = 0; i < maxIndex; i++) {
+        const elements = arrs.map(arr => arr[i]);
+        result.push(combine(...elements));
+    }
+    return result;
+}
+
+export { zipWith };
+//# sourceMappingURL=zipWith.mjs.map

package/dist/array/zipWith.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"zipWith.mjs","sources":["../../src/array/zipWith.ts"],"sourcesContent":["/**\n * Combines multiple arrays into a single array using a custom combiner function.\n *\n * This function takes multiple arrays and a combiner function, and returns a new array where each element\n * is the result of applying the combiner function to the corresponding elements of the input arrays.\n *\n * @template T - The type of elements in the first array.\n * @template U - The type of elements in the second array (optional).\n * @template V - The type of elements in the third array (optional).\n * @template W - The type of elements in the fourth array (optional).\n * @template R - The type of elements in the resulting array.\n * @param {T[]} arr1 - The first array to zip.\n * @param {U[]} [arr2] - The second array to zip (optional).\n * @param {V[]} [arr3] - The third array to zip (optional).\n * @param {W[]} [arr4] - The fourth array to zip (optional).\n * @param {(...items: T[]) => R} combine - The combiner function that takes corresponding elements from each array and returns a single value.\n * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays.\n *\n * @example\n * // Example usage with two arrays:\n * const arr1 = [1, 2, 3];\n * const arr2 = [4, 5, 6];\n * const result = zipWith(arr1, arr2, (a, b) => a + b);\n * // result will be [5, 7, 9]\n *\n * @example\n * // Example usage with three arrays:\n * const arr1 = [1, 2];\n * const arr2 = [3, 4];\n * const arr3 = [5, 6];\n * const result = zipWith(arr1, arr2, arr3, (a, b, c) => `${a}${b}${c}`);\n * // result will be [`135`, `246`]\n */\nexport function zipWith<T, R>(arr1: readonly T[], combine: (item: T) => R): R[];\nexport function zipWith<T, U, R>(arr1: readonly T[], arr2: readonly U[], combine: (item1: T, item2: U) => R): R[];\nexport function zipWith<T, U, V, R>(\n  arr1: readonly T[],\n  arr2: readonly U[],\n  arr3: readonly V[],\n  combine: (item1: T, item2: U, item3: V) => R\n): R[];\nexport function zipWith<T, U, V, W, R>(\n  arr1: readonly T[],\n  arr2: readonly U[],\n  arr3: readonly V[],\n  arr4: readonly W[],\n  combine: (item1: T, item2: U, item3: V, item4: W) => R\n): R[];\nexport function zipWith<T, R>(arr1: readonly T[], ...rest: any[]): R[] {\n  const arrs = [arr1, ...rest.slice(0, -1)];\n  const combine = rest[rest.length - 1] as (...items: T[]) => R;\n\n  const result: R[] = [];\n  const maxIndex = Math.max(...arrs.map(arr => arr.length));\n\n  for (let i = 0; i < maxIndex; i++) {\n    const elements: T[] = arrs.map(arr => arr[i]);\n    result.push(combine(...elements));\n  }\n\n  return result;\n}\n"],"names":[],"mappings":"SAgDgB,OAAO,CAAO,IAAkB,EAAE,GAAG,IAAW,EAAA;AAC9D,IAAA,MAAM,IAAI,GAAG,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1C,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAyB,CAAC;IAE9D,MAAM,MAAM,GAAQ,EAAE,CAAC;IACvB,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;AAE1D,IAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,EAAE,CAAC,EAAE,EAAE;AACjC,QAAA,MAAM,QAAQ,GAAQ,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAC9C,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC;KACnC;AAED,IAAA,OAAO,MAAM,CAAC;AAChB;;;;"}

package/dist/compat/_internal/isDeepKey.mjs

@@ -0,0 +1,16 @@
+const IS_PLAIN = /^\w*$/;
+const IS_DEEP = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
+function isDeepKey(key) {
+    switch (typeof key) {
+        case 'number':
+        case 'symbol': {
+            return false;
+        }
+        case 'string': {
+            return !IS_PLAIN.test(key) && IS_DEEP.test(key);
+        }
+    }
+}
+
+export { isDeepKey };
+//# sourceMappingURL=isDeepKey.mjs.map

package/dist/compat/_internal/isDeepKey.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"isDeepKey.mjs","sources":["../../../src/compat/_internal/isDeepKey.ts"],"sourcesContent":["const IS_PLAIN = /^\\w*$/;\nconst IS_DEEP = /\\.|\\[(?:[^[\\]]*|([\"'])(?:(?!\\1)[^\\\\]|\\\\.)*?\\1)\\]/;\n\n/**\n * Checks if a given key is a deep key.\n *\n * A deep key is a string that contains a dot (.) or square brackets with a property accessor.\n *\n * @param {PropertyKey} key - The key to check.\n * @returns {boolean} - Returns true if the key is a deep key, otherwise false.\n *\n * Examples:\n *\n * isDeepKey('a.b') // true\n * isDeepKey('a[b]') // true\n * isDeepKey('a') // false\n * isDeepKey(123) // false\n * isDeepKey('a.b.c') // true\n * isDeepKey('a[b][c]') // true\n */\nexport function isDeepKey(key: PropertyKey): boolean {\n  switch (typeof key) {\n    case 'number':\n    case 'symbol': {\n      return false;\n    }\n    case 'string': {\n      return !IS_PLAIN.test(key) && IS_DEEP.test(key);\n    }\n  }\n}\n"],"names":[],"mappings":"AAAA,MAAM,QAAQ,GAAG,OAAO,CAAC;AACzB,MAAM,OAAO,GAAG,kDAAkD,CAAC;AAmB7D,SAAU,SAAS,CAAC,GAAgB,EAAA;IACxC,QAAQ,OAAO,GAAG;AAChB,QAAA,KAAK,QAAQ,CAAC;QACd,KAAK,QAAQ,EAAE;AACb,YAAA,OAAO,KAAK,CAAC;SACd;QACD,KAAK,QAAQ,EAAE;AACb,YAAA,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;SACjD;KACF;AACH;;;;"}

package/dist/compat/_internal/isIndex.mjs

@@ -0,0 +1,17 @@
+const IS_UNSIGNED_INTEGER = /^(?:0|[1-9]\d*)$/;
+function isIndex(value) {
+    switch (typeof value) {
+        case 'number': {
+            return Number.isInteger(value) && value >= 0 && value < Number.MAX_SAFE_INTEGER;
+        }
+        case 'symbol': {
+            return false;
+        }
+        case 'string': {
+            return IS_UNSIGNED_INTEGER.test(value);
+        }
+    }
+}
+
+export { isIndex };
+//# sourceMappingURL=isIndex.mjs.map

package/dist/compat/_internal/isIndex.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"isIndex.mjs","sources":["../../../src/compat/_internal/isIndex.ts"],"sourcesContent":["const IS_UNSIGNED_INTEGER = /^(?:0|[1-9]\\d*)$/\n\nexport function isIndex(value: PropertyKey) {\n  switch (typeof value) {\n    case 'number': {\n      return Number.isInteger(value) && value >= 0 && value < Number.MAX_SAFE_INTEGER;\n    }\n    case 'symbol': {\n      return false;\n    }\n    case 'string': {\n      return IS_UNSIGNED_INTEGER.test(value);\n    }\n  }\n}"],"names":[],"mappings":"AAAA,MAAM,mBAAmB,GAAG,kBAAkB,CAAA;AAExC,SAAU,OAAO,CAAC,KAAkB,EAAA;IACxC,QAAQ,OAAO,KAAK;QAClB,KAAK,QAAQ,EAAE;AACb,YAAA,OAAO,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,KAAK,GAAG,MAAM,CAAC,gBAAgB,CAAC;SACjF;QACD,KAAK,QAAQ,EAAE;AACb,YAAA,OAAO,KAAK,CAAC;SACd;QACD,KAAK,QAAQ,EAAE;AACb,YAAA,OAAO,mBAAmB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SACxC;KACF;AACH;;;;"}

package/dist/compat/_internal/toPath.mjs

@@ -0,0 +1,41 @@
+function toPath(deepKey) {
+    const ESCAPE_REGEXP = /\\(\\)?/g;
+    const PROPERTY_REGEXP = RegExp('[^.[\\]]+' +
+        '|' +
+        '\\[(?:' +
+        '([^"\'][^[]*)' +
+        '|' +
+        '(["\'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2' +
+        ')\\]' +
+        '|' +
+        '(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))', 'g');
+    const result = [];
+    if (deepKey[0] === '.') {
+        result.push('');
+    }
+    let match;
+    let lastIndex = 0;
+    while ((match = PROPERTY_REGEXP.exec(deepKey)) !== null) {
+        let key = match[0];
+        const expr = match[1];
+        const quote = match[2];
+        const substr = match[3];
+        if (quote) {
+            key = substr.replace(ESCAPE_REGEXP, '$1');
+        }
+        else if (expr) {
+            key = expr;
+        }
+        result.push(key);
+        if (PROPERTY_REGEXP.lastIndex === lastIndex) {
+            PROPERTY_REGEXP.lastIndex++;
+        }
+        else {
+            lastIndex = PROPERTY_REGEXP.lastIndex;
+        }
+    }
+    return result;
+}
+
+export { toPath };
+//# sourceMappingURL=toPath.mjs.map

package/dist/compat/_internal/toPath.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"toPath.mjs","sources":["../../../src/compat/_internal/toPath.ts"],"sourcesContent":["/**\n * Converts a deep key string into an array of path segments.\n *\n * This function takes a string representing a deep key (e.g., 'a.b.c' or 'a[b][c]') and breaks it down into an array of strings, each representing a segment of the path.\n *\n * @param {string} deepKey - The deep key string to convert.\n * @returns {string[]} An array of strings, each representing a segment of the path.\n *\n * Examples:\n *\n * toPath('a.b.c') // Returns ['a', 'b', 'c']\n * toPath('a[b][c]') // Returns ['a', 'b', 'c']\n * toPath('.a.b.c') // Returns ['', 'a', 'b', 'c']\n * toPath('a[\"b.c\"].d') // Returns ['a', 'b.c', 'd']\n * toPath('') // Returns []\n * toPath('.a[b].c.d[e][\"f.g\"].h') // Returns ['', 'a', 'b', 'c', 'd', 'e', 'f.g', 'h']\n */\nexport function toPath(deepKey: string): string[] {\n  const ESCAPE_REGEXP = /\\\\(\\\\)?/g;\n  const PROPERTY_REGEXP = RegExp(\n    // Match anything that isn't a dot or bracket.\n    '[^.[\\\\]]+' +\n      '|' +\n      // Or match property names within brackets.\n      '\\\\[(?:' +\n      // Match a non-string expression.\n      '([^\"\\'][^[]*)' +\n      '|' +\n      // Or match strings (supports escaping characters).\n      '([\"\\'])((?:(?!\\\\2)[^\\\\\\\\]|\\\\\\\\.)*?)\\\\2' +\n      ')\\\\]' +\n      '|' +\n      // Or match \"\" as the space between consecutive dots or empty brackets.\n      '(?=(?:\\\\.|\\\\[\\\\])(?:\\\\.|\\\\[\\\\]|$))',\n    'g'\n  );\n\n  const result: string[] = [];\n\n  if (deepKey[0] === '.') {\n    result.push('');\n  }\n\n  let match: RegExpExecArray | null;\n  let lastIndex = 0;\n\n  while ((match = PROPERTY_REGEXP.exec(deepKey)) !== null) {\n    let key = match[0];\n    const expr = match[1];\n    const quote = match[2];\n    const substr = match[3];\n\n    if (quote) {\n      key = substr.replace(ESCAPE_REGEXP, '$1');\n    } else if (expr) {\n      key = expr;\n    }\n\n    result.push(key);\n\n    if (PROPERTY_REGEXP.lastIndex === lastIndex) {\n      PROPERTY_REGEXP.lastIndex++;\n    } else {\n      lastIndex = PROPERTY_REGEXP.lastIndex;\n    }\n  }\n\n  return result;\n}\n"],"names":[],"mappings":"AAiBM,SAAU,MAAM,CAAC,OAAe,EAAA;IACpC,MAAM,aAAa,GAAG,UAAU,CAAC;AACjC,IAAA,MAAM,eAAe,GAAG,MAAM,CAE5B,WAAW;QACT,GAAG;QAEH,QAAQ;QAER,eAAe;QACf,GAAG;QAEH,wCAAwC;QACxC,MAAM;QACN,GAAG;QAEH,oCAAoC,EACtC,GAAG,CACJ,CAAC;IAEF,MAAM,MAAM,GAAa,EAAE,CAAC;AAE5B,IAAA,IAAI,OAAO,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE;AACtB,QAAA,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;KACjB;AAED,IAAA,IAAI,KAA6B,CAAC;IAClC,IAAI,SAAS,GAAG,CAAC,CAAC;AAElB,IAAA,OAAO,CAAC,KAAK,GAAG,eAAe,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,IAAI,EAAE;AACvD,QAAA,IAAI,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AACnB,QAAA,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AACtB,QAAA,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AACvB,QAAA,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QAExB,IAAI,KAAK,EAAE;YACT,GAAG,GAAG,MAAM,CAAC,OAAO,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC;SAC3C;aAAM,IAAI,IAAI,EAAE;YACf,GAAG,GAAG,IAAI,CAAC;SACZ;AAED,QAAA,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAEjB,QAAA,IAAI,eAAe,CAAC,SAAS,KAAK,SAAS,EAAE;YAC3C,eAAe,CAAC,SAAS,EAAE,CAAC;SAC7B;aAAM;AACL,YAAA,SAAS,GAAG,eAAe,CAAC,SAAS,CAAC;SACvC;KACF;AAED,IAAA,OAAO,MAAM,CAAC;AAChB;;;;"}

package/dist/compat/array/chunk.d.mts

@@ -0,0 +1,26 @@
+/**
+ * Splits an array into smaller arrays of a specified length.
+ *
+ * This function takes an input array and divides it into multiple smaller arrays,
+ * each of a specified length. If the input array cannot be evenly divided,
+ * the final sub-array will contain the remaining elements.
+ *
+ * @template T The type of elements in the array.
+ * @param {T[]} arr - The array to be chunked into smaller arrays.
+ * @param {number} size - The size of each smaller array. Must be a positive integer.
+ * @returns {T[][]} A two-dimensional array where each sub-array has a maximum length of `size`.
+ * @throws {Error} Throws an error if `size` is not a positive integer.
+ *
+ * @example
+ * // Splits an array of numbers into sub-arrays of length 2
+ * chunk([1, 2, 3, 4, 5], 2);
+ * // Returns: [[1, 2], [3, 4], [5]]
+ *
+ * @example
+ * // Splits an array of strings into sub-arrays of length 3
+ * chunk(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3);
+ * // Returns: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g']]
+ */
+declare function chunk<T>(arr: readonly T[], size?: number): T[][];
+
+export { chunk };

package/dist/compat/array/chunk.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Splits an array into smaller arrays of a specified length.
+ *
+ * This function takes an input array and divides it into multiple smaller arrays,
+ * each of a specified length. If the input array cannot be evenly divided,
+ * the final sub-array will contain the remaining elements.
+ *
+ * @template T The type of elements in the array.
+ * @param {T[]} arr - The array to be chunked into smaller arrays.
+ * @param {number} size - The size of each smaller array. Must be a positive integer.
+ * @returns {T[][]} A two-dimensional array where each sub-array has a maximum length of `size`.
+ * @throws {Error} Throws an error if `size` is not a positive integer.
+ *
+ * @example
+ * // Splits an array of numbers into sub-arrays of length 2
+ * chunk([1, 2, 3, 4, 5], 2);
+ * // Returns: [[1, 2], [3, 4], [5]]
+ *
+ * @example
+ * // Splits an array of strings into sub-arrays of length 3
+ * chunk(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3);
+ * // Returns: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g']]
+ */
+declare function chunk<T>(arr: readonly T[], size?: number): T[][];
+
+export { chunk };

package/dist/compat/array/chunk.mjs

@@ -0,0 +1,12 @@
+import { chunk as chunk$1 } from '../../array/chunk.mjs';
+
+function chunk(arr, size = 1) {
+    size = Math.max(Math.floor(size), 0);
+    if (size === 0) {
+        return [];
+    }
+    return chunk$1(arr, size);
+}
+
+export { chunk };
+//# sourceMappingURL=chunk.mjs.map

package/dist/compat/array/chunk.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.mjs","sources":["../../../src/compat/array/chunk.ts"],"sourcesContent":["import { chunk as chunkToolkit } from '../../array/chunk.ts';\n\n/**\n * Splits an array into smaller arrays of a specified length.\n *\n * This function takes an input array and divides it into multiple smaller arrays,\n * each of a specified length. If the input array cannot be evenly divided,\n * the final sub-array will contain the remaining elements.\n *\n * @template T The type of elements in the array.\n * @param {T[]} arr - The array to be chunked into smaller arrays.\n * @param {number} size - The size of each smaller array. Must be a positive integer.\n * @returns {T[][]} A two-dimensional array where each sub-array has a maximum length of `size`.\n * @throws {Error} Throws an error if `size` is not a positive integer.\n *\n * @example\n * // Splits an array of numbers into sub-arrays of length 2\n * chunk([1, 2, 3, 4, 5], 2);\n * // Returns: [[1, 2], [3, 4], [5]]\n *\n * @example\n * // Splits an array of strings into sub-arrays of length 3\n * chunk(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3);\n * // Returns: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g']]\n */\nexport function chunk<T>(arr: readonly T[], size = 1): T[][] {\n  size = Math.max(Math.floor(size), 0);\n\n  if (size === 0) {\n    return [];\n  }\n\n  return chunkToolkit(arr, size);\n}\n"],"names":["chunkToolkit"],"mappings":";;SAyBgB,KAAK,CAAI,GAAiB,EAAE,IAAI,GAAG,CAAC,EAAA;AAClD,IAAA,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;AAErC,IAAA,IAAI,IAAI,KAAK,CAAC,EAAE;AACd,QAAA,OAAO,EAAE,CAAC;KACX;AAED,IAAA,OAAOA,OAAY,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;AACjC;;;;"}

package/dist/compat/array/concat.d.mts

@@ -0,0 +1,30 @@
+/**
+ * Concatenates multiple arrays and values into a single array.
+ *
+ * @template T The type of elements in the array.
+ * @param {...(T | T[])} values - The values and/or arrays to concatenate.
+ * @returns {T[]} A new array containing all the input values.
+ *
+ * @example
+ * // Concatenate individual values
+ * concat(1, 2, 3);
+ * // returns [1, 2, 3]
+ *
+ * @example
+ * // Concatenate arrays of values
+ * concat([1, 2], [3, 4]);
+ * // returns [1, 2, 3, 4]
+ *
+ * @example
+ * // Concatenate a mix of individual values and arrays
+ * concat(1, [2, 3], 4);
+ * // returns [1, 2, 3, 4]
+ *
+ * @example
+ * // Concatenate nested arrays
+ * concat([1, [2, 3]], 4);
+ * // returns [1, [2, 3], 4]
+ */
+declare function concat<T>(...values: Array<T | readonly T[]>): T[];
+
+export { concat };

package/dist/compat/array/concat.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Concatenates multiple arrays and values into a single array.
+ *
+ * @template T The type of elements in the array.
+ * @param {...(T | T[])} values - The values and/or arrays to concatenate.
+ * @returns {T[]} A new array containing all the input values.
+ *
+ * @example
+ * // Concatenate individual values
+ * concat(1, 2, 3);
+ * // returns [1, 2, 3]
+ *
+ * @example
+ * // Concatenate arrays of values
+ * concat([1, 2], [3, 4]);
+ * // returns [1, 2, 3, 4]
+ *
+ * @example
+ * // Concatenate a mix of individual values and arrays
+ * concat(1, [2, 3], 4);
+ * // returns [1, 2, 3, 4]
+ *
+ * @example
+ * // Concatenate nested arrays
+ * concat([1, [2, 3]], 4);
+ * // returns [1, [2, 3], 4]
+ */
+declare function concat<T>(...values: Array<T | readonly T[]>): T[];
+
+export { concat };

package/dist/compat/array/concat.mjs

@@ -0,0 +1,8 @@
+import { flatten } from '../../array/flatten.mjs';
+
+function concat(...values) {
+    return flatten(values);
+}
+
+export { concat };
+//# sourceMappingURL=concat.mjs.map

package/dist/compat/array/concat.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"concat.mjs","sources":["../../../src/compat/array/concat.ts"],"sourcesContent":["import { flatten } from '../../array/flatten.ts';\n\n/**\n * Concatenates multiple arrays and values into a single array.\n *\n * @template T The type of elements in the array.\n * @param {...(T | T[])} values - The values and/or arrays to concatenate.\n * @returns {T[]} A new array containing all the input values.\n *\n * @example\n * // Concatenate individual values\n * concat(1, 2, 3);\n * // returns [1, 2, 3]\n *\n * @example\n * // Concatenate arrays of values\n * concat([1, 2], [3, 4]);\n * // returns [1, 2, 3, 4]\n *\n * @example\n * // Concatenate a mix of individual values and arrays\n * concat(1, [2, 3], 4);\n * // returns [1, 2, 3, 4]\n *\n * @example\n * // Concatenate nested arrays\n * concat([1, [2, 3]], 4);\n * // returns [1, [2, 3], 4]\n */\nexport function concat<T>(...values: Array<T | readonly T[]>): T[] {\n  return flatten(values) as T[];\n}\n"],"names":[],"mappings":";;AA6BgB,SAAA,MAAM,CAAI,GAAG,MAA+B,EAAA;AAC1D,IAAA,OAAO,OAAO,CAAC,MAAM,CAAQ,CAAC;AAChC;;;;"}

package/dist/compat/array/difference.d.mts

@@ -0,0 +1,3 @@
+declare function difference<T>(arr: readonly T[], ...values: Array<readonly T[]>): T[];
+
+export { difference };

package/dist/compat/array/difference.d.ts

@@ -0,0 +1,3 @@
+declare function difference<T>(arr: readonly T[], ...values: Array<readonly T[]>): T[];
+
+export { difference };

package/dist/compat/array/difference.mjs

@@ -0,0 +1,11 @@
+import { difference as difference$1 } from '../../array/difference.mjs';
+import { flatten } from '../../array/flatten.mjs';
+
+function difference(arr, ...values) {
+    const arr1 = arr;
+    const arr2 = flatten(values);
+    return difference$1(arr1, arr2);
+}
+
+export { difference };
+//# sourceMappingURL=difference.mjs.map

package/dist/compat/array/difference.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"difference.mjs","sources":["../../../src/compat/array/difference.ts"],"sourcesContent":["import { difference as differenceToolkit } from '../../array/difference.ts';\nimport { flatten } from '../../array/flatten.ts';\n\nexport function difference<T>(arr: readonly T[], ...values: Array<readonly T[]>): T[] {\n  const arr1 = arr;\n  const arr2 = flatten(values);\n\n  return differenceToolkit(arr1, arr2);\n}"],"names":["differenceToolkit"],"mappings":";;;SAGgB,UAAU,CAAI,GAAiB,EAAE,GAAG,MAA2B,EAAA;IAC7E,MAAM,IAAI,GAAG,GAAG,CAAC;AACjB,IAAA,MAAM,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;AAE7B,IAAA,OAAOA,YAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AACvC;;;;"}

package/dist/compat/array/fill.d.mts

@@ -0,0 +1,33 @@
+/**
+ * Fills elements of an array with a specified value from the start position up to, but not including, the end position.
+ *
+ * This function mutates the original array and replaces its elements with the provided value, starting from the specified
+ * start index up to the end index (non-inclusive). If the start or end indices are not provided, it defaults to filling the
+ * entire array.
+ *
+ * @template T, U, S, V
+ * @param {Array<T | U>} array - The array to fill.
+ * @param {U} value - The value to fill the array with.
+ * @param {S} [start=0] - The start position. Defaults to 0.
+ * @param {V} [end=arr.length] - The end position. Defaults to the array's length.
+ * @returns {Array<T | U>} The array with the filled values.
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * const result = fill(array, 'a');
+ * // => ['a', 'a', 'a']
+ *
+ * const result = fill(Array(3), 2);
+ * // => [2, 2, 2]
+ *
+ * const result = fill([4, 6, 8, 10], '*', 1, 3);
+ * // => [4, '*', '*', 10]
+ *
+ * const result = fill(array, '*', -2, -1);
+ * // => [1, '*', 3]
+ */
+declare function fill<T>(array: unknown[], value?: T): T[];
+declare function fill<T, U, S>(array: Array<T | U>, value: U, start: S): Array<T | U>;
+declare function fill<T, U, S, V>(array: Array<T | U>, value: U, start: S, end: V): Array<T | U>;
+
+export { fill };

package/dist/compat/array/fill.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Fills elements of an array with a specified value from the start position up to, but not including, the end position.
+ *
+ * This function mutates the original array and replaces its elements with the provided value, starting from the specified
+ * start index up to the end index (non-inclusive). If the start or end indices are not provided, it defaults to filling the
+ * entire array.
+ *
+ * @template T, U, S, V
+ * @param {Array<T | U>} array - The array to fill.
+ * @param {U} value - The value to fill the array with.
+ * @param {S} [start=0] - The start position. Defaults to 0.
+ * @param {V} [end=arr.length] - The end position. Defaults to the array's length.
+ * @returns {Array<T | U>} The array with the filled values.
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * const result = fill(array, 'a');
+ * // => ['a', 'a', 'a']
+ *
+ * const result = fill(Array(3), 2);
+ * // => [2, 2, 2]
+ *
+ * const result = fill([4, 6, 8, 10], '*', 1, 3);
+ * // => [4, '*', '*', 10]
+ *
+ * const result = fill(array, '*', -2, -1);
+ * // => [1, '*', 3]
+ */
+declare function fill<T>(array: unknown[], value?: T): T[];
+declare function fill<T, U, S>(array: Array<T | U>, value: U, start: S): Array<T | U>;
+declare function fill<T, U, S, V>(array: Array<T | U>, value: U, start: S, end: V): Array<T | U>;
+
+export { fill };

package/dist/compat/array/fill.mjs

@@ -0,0 +1,16 @@
+import { fill as fill$1 } from '../../array/fill.mjs';
+
+function fill(array, value, start = 0, end = array.length) {
+    start = Math.floor(start);
+    end = Math.floor(end);
+    if (!start) {
+        start = 0;
+    }
+    if (!end) {
+        end = 0;
+    }
+    return fill$1(array, value, start, end);
+}
+
+export { fill };
+//# sourceMappingURL=fill.mjs.map

package/dist/compat/array/fill.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fill.mjs","sources":["../../../src/compat/array/fill.ts"],"sourcesContent":["import { fill as fillToolkit } from '../../array/fill.ts';\n\n/**\n * Fills elements of an array with a specified value from the start position up to, but not including, the end position.\n *\n * This function mutates the original array and replaces its elements with the provided value, starting from the specified\n * start index up to the end index (non-inclusive). If the start or end indices are not provided, it defaults to filling the\n * entire array.\n *\n * @template T, U, S, V\n * @param {Array<T | U>} array - The array to fill.\n * @param {U} value - The value to fill the array with.\n * @param {S} [start=0] - The start position. Defaults to 0.\n * @param {V} [end=arr.length] - The end position. Defaults to the array's length.\n * @returns {Array<T | U>} The array with the filled values.\n *\n * @example\n * const array = [1, 2, 3];\n * const result = fill(array, 'a');\n * // => ['a', 'a', 'a']\n *\n * const result = fill(Array(3), 2);\n * // => [2, 2, 2]\n *\n * const result = fill([4, 6, 8, 10], '*', 1, 3);\n * // => [4, '*', '*', 10]\n *\n * const result = fill(array, '*', -2, -1);\n * // => [1, '*', 3]\n */\nexport function fill<T>(array: unknown[], value?: T): T[];\nexport function fill<T, U, S>(array: Array<T | U>, value: U, start: S): Array<T | U>;\nexport function fill<T, U, S, V>(array: Array<T | U>, value: U, start: S, end: V): Array<T | U>;\nexport function fill<T, U>(array: Array<T | U>, value: U, start = 0, end = array.length): Array<T | U> {\n  start = Math.floor(start);\n  end = Math.floor(end);\n\n  if (!start) {\n    start = 0;\n  }\n  if (!end) {\n    end = 0;\n  }\n\n  return fillToolkit(array, value, start, end);\n}\n"],"names":["fillToolkit"],"mappings":";;AAiCgB,SAAA,IAAI,CAAO,KAAmB,EAAE,KAAQ,EAAE,KAAK,GAAG,CAAC,EAAE,GAAG,GAAG,KAAK,CAAC,MAAM,EAAA;AACrF,IAAA,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;AAC1B,IAAA,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAEtB,IAAI,CAAC,KAAK,EAAE;QACV,KAAK,GAAG,CAAC,CAAC;KACX;IACD,IAAI,CAAC,GAAG,EAAE;QACR,GAAG,GAAG,CAAC,CAAC;KACT;IAED,OAAOA,MAAW,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC;AAC/C;;;;"}

package/dist/compat/array/zipObjectDeep.d.mts

@@ -0,0 +1,37 @@
+/**
+ * Creates a deeply nested object given arrays of paths and values.
+ *
+ * This function takes two arrays: one containing arrays of property paths, and the other containing corresponding values.
+ * It returns a new object where paths from the first array are used as key paths to set values, with corresponding elements from the second array as values.
+ * Paths can be dot-separated strings or arrays of property names.
+ *
+ * If the `keys` array is longer than the `values` array, the remaining keys will have `undefined` as their values.
+ *
+ * @template V - The type of elements in the array.
+ * @param {P[] | P[][]} keys - An array of property paths, each path can be a dot-separated string or an array of property names.
+ * @param {V[]} values - An array of values corresponding to the property paths.
+ * @returns {object} A new object composed of the given property paths and values.
+ *
+ * @example
+ * const paths = ['a.b.c', 'd.e.f'];
+ * const values = [1, 2];
+ * const result = zipObjectDeep(paths, values);
+ * // result will be { a: { b: { c: 1 } }, d: { e: { f: 2 } } }
+ *
+ * @example
+ * const paths = [['a', 'b', 'c'], ['d', 'e', 'f']];
+ * const values = [1, 2];
+ * const result = zipObjectDeep(paths, values);
+ * // result will be { a: { b: { c: 1 } }, d: { e: { f: 2 } } }
+ *
+ * @example
+ * const paths = ['a.b[0].c', 'a.b[1].d'];
+ * const values = [1, 2];
+ * const result = zipObjectDeep(paths, values);
+ * // result will be { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }
+ */
+declare function zipObjectDeep<P extends PropertyKey, V>(keys: P[] | P[][], values: V[]): {
+    [K in P]: V;
+};
+
+export { zipObjectDeep };

package/dist/compat/array/zipObjectDeep.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Creates a deeply nested object given arrays of paths and values.
+ *
+ * This function takes two arrays: one containing arrays of property paths, and the other containing corresponding values.
+ * It returns a new object where paths from the first array are used as key paths to set values, with corresponding elements from the second array as values.
+ * Paths can be dot-separated strings or arrays of property names.
+ *
+ * If the `keys` array is longer than the `values` array, the remaining keys will have `undefined` as their values.
+ *
+ * @template V - The type of elements in the array.
+ * @param {P[] | P[][]} keys - An array of property paths, each path can be a dot-separated string or an array of property names.
+ * @param {V[]} values - An array of values corresponding to the property paths.
+ * @returns {object} A new object composed of the given property paths and values.
+ *
+ * @example
+ * const paths = ['a.b.c', 'd.e.f'];
+ * const values = [1, 2];
+ * const result = zipObjectDeep(paths, values);
+ * // result will be { a: { b: { c: 1 } }, d: { e: { f: 2 } } }
+ *
+ * @example
+ * const paths = [['a', 'b', 'c'], ['d', 'e', 'f']];
+ * const values = [1, 2];
+ * const result = zipObjectDeep(paths, values);
+ * // result will be { a: { b: { c: 1 } }, d: { e: { f: 2 } } }
+ *
+ * @example
+ * const paths = ['a.b[0].c', 'a.b[1].d'];
+ * const values = [1, 2];
+ * const result = zipObjectDeep(paths, values);
+ * // result will be { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }
+ */
+declare function zipObjectDeep<P extends PropertyKey, V>(keys: P[] | P[][], values: V[]): {
+    [K in P]: V;
+};
+
+export { zipObjectDeep };

package/dist/compat/array/zipObjectDeep.mjs

@@ -0,0 +1,17 @@
+import { zip } from '../../array/zip.mjs';
+import { set } from '../object/set.mjs';
+
+function zipObjectDeep(keys, values) {
+    const result = {};
+    const zipped = zip(keys, values);
+    for (let i = 0; i < zipped.length; i++) {
+        const [key, value] = zipped[i];
+        if (key != null) {
+            set(result, key, value);
+        }
+    }
+    return result;
+}
+
+export { zipObjectDeep };
+//# sourceMappingURL=zipObjectDeep.mjs.map

package/dist/compat/array/zipObjectDeep.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"zipObjectDeep.mjs","sources":["../../../src/compat/array/zipObjectDeep.ts"],"sourcesContent":["import { zip } from \"../../array/zip.ts\";\nimport { set } from \"../object/set.ts\";\n\n/**\n * Creates a deeply nested object given arrays of paths and values.\n *\n * This function takes two arrays: one containing arrays of property paths, and the other containing corresponding values.\n * It returns a new object where paths from the first array are used as key paths to set values, with corresponding elements from the second array as values.\n * Paths can be dot-separated strings or arrays of property names.\n * \n * If the `keys` array is longer than the `values` array, the remaining keys will have `undefined` as their values.\n *\n * @template V - The type of elements in the array.\n * @param {P[] | P[][]} keys - An array of property paths, each path can be a dot-separated string or an array of property names.\n * @param {V[]} values - An array of values corresponding to the property paths.\n * @returns {object} A new object composed of the given property paths and values.\n *\n * @example\n * const paths = ['a.b.c', 'd.e.f'];\n * const values = [1, 2];\n * const result = zipObjectDeep(paths, values);\n * // result will be { a: { b: { c: 1 } }, d: { e: { f: 2 } } }\n *\n * @example\n * const paths = [['a', 'b', 'c'], ['d', 'e', 'f']];\n * const values = [1, 2];\n * const result = zipObjectDeep(paths, values);\n * // result will be { a: { b: { c: 1 } }, d: { e: { f: 2 } } }\n * \n * @example\n * const paths = ['a.b[0].c', 'a.b[1].d'];\n * const values = [1, 2];\n * const result = zipObjectDeep(paths, values);\n * // result will be { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }\n */\nexport function zipObjectDeep<P extends PropertyKey, V>(keys: P[] | P[][], values: V[]): { [K in P]: V } {\n  const result = {} as { [K in P]: V };\n  const zipped = zip<P | P[], V>(keys, values);\n\n  for (let i = 0; i < zipped.length; i++) {\n    const [key, value] = zipped[i];\n\n    if (key != null) {\n      set(result, key, value);\n    }\n  }\n\n  return result;\n}\n"],"names":[],"mappings":";;;AAmCgB,SAAA,aAAa,CAA2B,IAAiB,EAAE,MAAW,EAAA;IACpF,MAAM,MAAM,GAAG,EAAqB,CAAC;IACrC,MAAM,MAAM,GAAG,GAAG,CAAa,IAAI,EAAE,MAAM,CAAC,CAAC;AAE7C,IAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACtC,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;AAE/B,QAAA,IAAI,GAAG,IAAI,IAAI,EAAE;AACf,YAAA,GAAG,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;SACzB;KACF;AAED,IAAA,OAAO,MAAM,CAAC;AAChB;;;;"}