es-toolkit 1.13.1-dev.318 → 1.13.1-dev.321

package/dist/browser.mjs

@@ -1,36 +1,38 @@
 import {
   compat_exports
-} from "./chunk-36ZJSTNA.mjs";
+} from "./chunk-IGM5IABU.mjs";
 import "./chunk-NKLIE2OI.mjs";
 import "./chunk-4OIZM4HS.mjs";
-import "./chunk-IIDZ3KAJ.mjs";
-import "./chunk-CVVZHOJX.mjs";
+import "./chunk-ZPNX2QDE.mjs";
+import "./chunk-EZYYB34V.mjs";
+import "./chunk-4DFAGGIM.mjs";
 import "./chunk-XT74R35S.mjs";
-import "./chunk-F3WCQQET.mjs";
-import "./chunk-QXTNZR7B.mjs";
-import "./chunk-Y5V7UAZZ.mjs";
+import "./chunk-ET33L3MQ.mjs";
+import "./chunk-RTFTLCF3.mjs";
+import "./chunk-IWXZI3QT.mjs";
+import "./chunk-3SBT6WDU.mjs";
+import "./chunk-4ZES5T6V.mjs";
+import "./chunk-OG2RLT5U.mjs";
 import "./chunk-U56ZOM7L.mjs";
-import "./chunk-EYYZQFOP.mjs";
-import "./chunk-5IKVJGHO.mjs";
-import "./chunk-WVQ7YVRK.mjs";
-import "./chunk-O64NE2P4.mjs";
-import "./chunk-U4JWMVQK.mjs";
+import "./chunk-YXD3AQAK.mjs";
+import "./chunk-VH2PV426.mjs";
 import "./chunk-74CREQXW.mjs";
 import "./chunk-WMM7TZLG.mjs";
 import "./chunk-BMRTZMRE.mjs";
 import "./chunk-AIRSKN47.mjs";
-import "./chunk-VH2PV426.mjs";
+import "./chunk-R6GLTTAB.mjs";
+import "./chunk-SXFMQQ6F.mjs";
 import "./chunk-LPZZIY5Z.mjs";
 import "./chunk-27QMXBLJ.mjs";
 import "./chunk-JYSV56US.mjs";
 import "./chunk-YXAOYIRV.mjs";
 import "./chunk-OLX53VEF.mjs";
-import "./chunk-WFZXCGEG.mjs";
+import "./chunk-YOPFSFTD.mjs";
 import "./chunk-BCTYOXT7.mjs";
 import "./chunk-HPFDYUGP.mjs";
 import "./chunk-6CLH5YZ2.mjs";
 import "./chunk-VRUTBJYS.mjs";
-import "./chunk-5CPXZFCB.mjs";
+import "./chunk-K5WL54BY.mjs";
 import "./chunk-XGQWTHW6.mjs";
 import "./chunk-MIGAC7F4.mjs";
 import "./chunk-FUS75PJ7.mjs";
@@ -45,7 +47,7 @@ import "./chunk-2SLTL4KL.mjs";
 import "./chunk-ZA2XI3OV.mjs";
 import "./chunk-QOJGMVVR.mjs";
 import "./chunk-OGZMEWPR.mjs";
-import "./chunk-3IP4JVLL.mjs";
+import "./chunk-MSHSKENG.mjs";
 import "./chunk-BOOQBJN2.mjs";
 import "./chunk-LKXCOLNY.mjs";
 import "./chunk-CMBC4MXG.mjs";
@@ -93,7 +95,7 @@ import "./chunk-33MSBDC6.mjs";
 import "./chunk-IEA53J7P.mjs";
 import "./chunk-E6E4RZLN.mjs";
 import "./chunk-HM2JT2RX.mjs";
-import "./chunk-CRSKT4WW.mjs";
+import "./chunk-Z7HWEOQX.mjs";
 import "./chunk-JPUKH67K.mjs";
 import "./chunk-LVWX5B43.mjs";
 import "./chunk-6NVQAHXP.mjs";
@@ -106,7 +108,7 @@ import "./chunk-DXB7EZUQ.mjs";
 import "./chunk-KIOYQRMQ.mjs";
 import "./chunk-E6C5EZQA.mjs";
 import "./chunk-DTJJIMKJ.mjs";
-import "./chunk-24FKGR6U.mjs";
+import "./chunk-J5LGTIGS.mjs";
 
 // src/browser.ts
 window._ = compat_exports;

package/dist/browser.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/browser.ts"],"sourcesContent":["import * as toolkit from './compat/index.ts';\n\ninterface Window {\n  _: typeof toolkit;\n}\n\ndeclare let window: Window;\nwindow._ = toolkit;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOA,OAAO,IAAI;","names":[]}
+{"version":3,"sources":["../src/browser.ts"],"sourcesContent":["import * as toolkit from './compat/index.ts';\n\ninterface Window {\n  _: typeof toolkit;\n}\n\ndeclare let window: Window;\nwindow._ = toolkit;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOA,OAAO,IAAI;","names":[]}

package/dist/{chunk-QXTNZR7B.mjs → chunk-3SBT6WDU.mjs}

@@ -1,6 +1,6 @@
 import {
   getWords
-} from "./chunk-WVQ7YVRK.mjs";
+} from "./chunk-OG2RLT5U.mjs";
 
 // src/string/startCase.ts
 function startCase(str) {
@@ -22,4 +22,4 @@ function startCase(str) {
 export {
   startCase
 };
-//# sourceMappingURL=chunk-QXTNZR7B.mjs.map
+//# sourceMappingURL=chunk-3SBT6WDU.mjs.map

package/dist/{chunk-O64NE2P4.mjs → chunk-4DFAGGIM.mjs}

@@ -12,15 +12,15 @@ function delay(ms, { signal } = {}) {
       clearTimeout(timeoutId);
       abortError();
     };
-    if (signal == null ? void 0 : signal.aborted) {
+    if (signal?.aborted) {
       return abortError();
     }
     const timeoutId = setTimeout(resolve, ms);
-    signal == null ? void 0 : signal.addEventListener("abort", abortHandler, { once: true });
+    signal?.addEventListener("abort", abortHandler, { once: true });
   });
 }
 
 export {
   delay
 };
-//# sourceMappingURL=chunk-O64NE2P4.mjs.map
+//# sourceMappingURL=chunk-4DFAGGIM.mjs.map

package/dist/{chunk-O64NE2P4.mjs.map → chunk-4DFAGGIM.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/promise/delay.ts"],"sourcesContent":["import { AbortError } from '../error/AbortError.ts';\n\ninterface DelayOptions {\n  signal?: AbortSignal;\n}\n\n/**\n * Delays the execution of code for a specified number of milliseconds.\n *\n * This function returns a Promise that resolves after the specified delay, allowing you to use it\n * with async/await to pause execution.\n *\n * @param {number} ms - The number of milliseconds to delay.\n * @param {DelayOptions} options - The options object.\n * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the delay.\n * @returns {Promise<void>} A Promise that resolves after the specified delay.\n *\n * @example\n * async function foo() {\n *   console.log('Start');\n *   await delay(1000); // Delays execution for 1 second\n *   console.log('End');\n * }\n *\n * foo();\n *\n * // With AbortSignal\n * const controller = new AbortController();\n * const { signal } = controller;\n *\n * setTimeout(() => controller.abort(), 50); // Will cancel the delay after 50ms\n * try {\n *   await delay(100, { signal });\n *  } catch (error) {\n *   console.error(error); // Will log 'AbortError'\n *  }\n * }\n */\nexport function delay(ms: number, { signal }: DelayOptions = {}): Promise<void> {\n  return new Promise((resolve, reject) => {\n    const abortError = () => {\n      reject(new AbortError());\n    };\n\n    const abortHandler = () => {\n      clearTimeout(timeoutId);\n      abortError();\n    };\n\n    if (signal?.aborted) {\n      return abortError();\n    }\n\n    const timeoutId = setTimeout(resolve, ms);\n\n    signal?.addEventListener('abort', abortHandler, { once: true });\n  });\n}\n"],"mappings":";;;;;AAsCO,SAAS,MAAM,IAAY,EAAE,OAAO,IAAkB,CAAC,GAAkB;AAC9E,SAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,UAAM,aAAa,MAAM;AACvB,aAAO,IAAI,WAAW,CAAC;AAAA,IACzB;AAEA,UAAM,eAAe,MAAM;AACzB,mBAAa,SAAS;AACtB,iBAAW;AAAA,IACb;AAEA,QAAI,iCAAQ,SAAS;AACnB,aAAO,WAAW;AAAA,IACpB;AAEA,UAAM,YAAY,WAAW,SAAS,EAAE;AAExC,qCAAQ,iBAAiB,SAAS,cAAc,EAAE,MAAM,KAAK;AAAA,EAC/D,CAAC;AACH;","names":[]}
+{"version":3,"sources":["../src/promise/delay.ts"],"sourcesContent":["import { AbortError } from '../error/AbortError.ts';\n\ninterface DelayOptions {\n  signal?: AbortSignal;\n}\n\n/**\n * Delays the execution of code for a specified number of milliseconds.\n *\n * This function returns a Promise that resolves after the specified delay, allowing you to use it\n * with async/await to pause execution.\n *\n * @param {number} ms - The number of milliseconds to delay.\n * @param {DelayOptions} options - The options object.\n * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the delay.\n * @returns {Promise<void>} A Promise that resolves after the specified delay.\n *\n * @example\n * async function foo() {\n *   console.log('Start');\n *   await delay(1000); // Delays execution for 1 second\n *   console.log('End');\n * }\n *\n * foo();\n *\n * // With AbortSignal\n * const controller = new AbortController();\n * const { signal } = controller;\n *\n * setTimeout(() => controller.abort(), 50); // Will cancel the delay after 50ms\n * try {\n *   await delay(100, { signal });\n *  } catch (error) {\n *   console.error(error); // Will log 'AbortError'\n *  }\n * }\n */\nexport function delay(ms: number, { signal }: DelayOptions = {}): Promise<void> {\n  return new Promise((resolve, reject) => {\n    const abortError = () => {\n      reject(new AbortError());\n    };\n\n    const abortHandler = () => {\n      clearTimeout(timeoutId);\n      abortError();\n    };\n\n    if (signal?.aborted) {\n      return abortError();\n    }\n\n    const timeoutId = setTimeout(resolve, ms);\n\n    signal?.addEventListener('abort', abortHandler, { once: true });\n  });\n}\n"],"mappings":";;;;;AAsCO,SAAS,MAAM,IAAY,EAAE,OAAO,IAAkB,CAAC,GAAkB;AAC9E,SAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,UAAM,aAAa,MAAM;AACvB,aAAO,IAAI,WAAW,CAAC;AAAA,IACzB;AAEA,UAAM,eAAe,MAAM;AACzB,mBAAa,SAAS;AACtB,iBAAW;AAAA,IACb;AAEA,QAAI,QAAQ,SAAS;AACnB,aAAO,WAAW;AAAA,IACpB;AAEA,UAAM,YAAY,WAAW,SAAS,EAAE;AAExC,YAAQ,iBAAiB,SAAS,cAAc,EAAE,MAAM,KAAK,CAAC;AAAA,EAChE,CAAC;AACH;","names":[]}

package/dist/{chunk-Y5V7UAZZ.mjs → chunk-4ZES5T6V.mjs}

@@ -1,9 +1,9 @@
+import {
+  getWords
+} from "./chunk-OG2RLT5U.mjs";
 import {
   capitalize
 } from "./chunk-U56ZOM7L.mjs";
-import {
-  getWords
-} from "./chunk-WVQ7YVRK.mjs";
 
 // src/string/camelCase.ts
 function camelCase(str) {
@@ -18,4 +18,4 @@ function camelCase(str) {
 export {
   camelCase
 };
-//# sourceMappingURL=chunk-Y5V7UAZZ.mjs.map
+//# sourceMappingURL=chunk-4ZES5T6V.mjs.map

package/dist/{chunk-EYYZQFOP.mjs → chunk-ET33L3MQ.mjs}

@@ -1,6 +1,6 @@
 import {
   getWords
-} from "./chunk-WVQ7YVRK.mjs";
+} from "./chunk-OG2RLT5U.mjs";
 
 // src/string/kebabCase.ts
 var kebabCase = (str) => {
@@ -11,4 +11,4 @@ var kebabCase = (str) => {
 export {
   kebabCase
 };
-//# sourceMappingURL=chunk-EYYZQFOP.mjs.map
+//# sourceMappingURL=chunk-ET33L3MQ.mjs.map

package/dist/chunk-EZYYB34V.mjs

@@ -0,0 +1,17 @@
+import {
+  delay
+} from "./chunk-4DFAGGIM.mjs";
+import {
+  TimeoutError
+} from "./chunk-KIOYQRMQ.mjs";
+
+// src/promise/timeout.ts
+async function timeout(ms) {
+  await delay(ms);
+  throw new TimeoutError();
+}
+
+export {
+  timeout
+};
+//# sourceMappingURL=chunk-EZYYB34V.mjs.map

package/dist/{chunk-CVVZHOJX.mjs.map → chunk-EZYYB34V.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/promise/timeout.ts"],"sourcesContent":["import { delay } from './delay.ts';\nimport { TimeoutError } from '../error/TimeoutError.ts';\n\n/**\n * Returns a promise that rejects with a `TimeoutError` after a specified delay.\n *\n * @param {number} ms - The delay duration in milliseconds.\n * @returns {Promise<void>} A promise that rejects with a `TimeoutError` after the specified delay.\n * @throws {TimeoutError} Throws a `TimeoutError` after the specified delay.\n */\nexport async function timeout(ms: number): Promise<never> {\n  await delay(ms);\n  throw new TimeoutError();\n}\n"],"mappings":";;;;;;;;;;;AAUA,SAAsB,QAAQ,IAA4B;AAAA;AACxD,UAAM,MAAM,EAAE;AACd,UAAM,IAAI,aAAa;AAAA,EACzB;AAAA;","names":[]}
+{"version":3,"sources":["../src/promise/timeout.ts"],"sourcesContent":["import { delay } from './delay.ts';\nimport { TimeoutError } from '../error/TimeoutError.ts';\n\n/**\n * Returns a promise that rejects with a `TimeoutError` after a specified delay.\n *\n * @param {number} ms - The delay duration in milliseconds.\n * @returns {Promise<void>} A promise that rejects with a `TimeoutError` after the specified delay.\n * @throws {TimeoutError} Throws a `TimeoutError` after the specified delay.\n */\nexport async function timeout(ms: number): Promise<never> {\n  await delay(ms);\n  throw new TimeoutError();\n}\n"],"mappings":";;;;;;;;AAUA,eAAsB,QAAQ,IAA4B;AACxD,QAAM,MAAM,EAAE;AACd,QAAM,IAAI,aAAa;AACzB;","names":[]}

package/dist/{chunk-36ZJSTNA.mjs → chunk-IGM5IABU.mjs}

@@ -1,27 +1,30 @@
 import {
   withTimeout
-} from "./chunk-IIDZ3KAJ.mjs";
+} from "./chunk-ZPNX2QDE.mjs";
+import {
+  delay
+} from "./chunk-4DFAGGIM.mjs";
+import {
+  kebabCase
+} from "./chunk-ET33L3MQ.mjs";
+import {
+  lowerCase
+} from "./chunk-RTFTLCF3.mjs";
 import {
   snakeCase
-} from "./chunk-F3WCQQET.mjs";
+} from "./chunk-IWXZI3QT.mjs";
 import {
   startCase
-} from "./chunk-QXTNZR7B.mjs";
+} from "./chunk-3SBT6WDU.mjs";
 import {
   camelCase
-} from "./chunk-Y5V7UAZZ.mjs";
+} from "./chunk-4ZES5T6V.mjs";
 import {
   capitalize
 } from "./chunk-U56ZOM7L.mjs";
 import {
-  kebabCase
-} from "./chunk-EYYZQFOP.mjs";
-import {
-  lowerCase
-} from "./chunk-5IKVJGHO.mjs";
-import {
-  delay
-} from "./chunk-O64NE2P4.mjs";
+  isUndefined
+} from "./chunk-VH2PV426.mjs";
 import {
   isFunction
 } from "./chunk-74CREQXW.mjs";
@@ -35,8 +38,11 @@ import {
   isNull
 } from "./chunk-AIRSKN47.mjs";
 import {
-  isUndefined
-} from "./chunk-VH2PV426.mjs";
+  isPrimitive
+} from "./chunk-R6GLTTAB.mjs";
+import {
+  isTypedArray
+} from "./chunk-SXFMQQ6F.mjs";
 import {
   isArrayLike
 } from "./chunk-LPZZIY5Z.mjs";
@@ -51,7 +57,7 @@ import {
 } from "./chunk-OLX53VEF.mjs";
 import {
   omit
-} from "./chunk-WFZXCGEG.mjs";
+} from "./chunk-YOPFSFTD.mjs";
 import {
   omitBy
 } from "./chunk-BCTYOXT7.mjs";
@@ -66,7 +72,7 @@ import {
 } from "./chunk-VRUTBJYS.mjs";
 import {
   cloneDeep
-} from "./chunk-5CPXZFCB.mjs";
+} from "./chunk-K5WL54BY.mjs";
 import {
   flattenObject
 } from "./chunk-XGQWTHW6.mjs";
@@ -102,7 +108,7 @@ import {
 } from "./chunk-OGZMEWPR.mjs";
 import {
   debounce
-} from "./chunk-3IP4JVLL.mjs";
+} from "./chunk-MSHSKENG.mjs";
 import {
   negate
 } from "./chunk-BOOQBJN2.mjs";
@@ -243,7 +249,7 @@ import {
 } from "./chunk-HM2JT2RX.mjs";
 import {
   countBy
-} from "./chunk-CRSKT4WW.mjs";
+} from "./chunk-Z7HWEOQX.mjs";
 import {
   difference
 } from "./chunk-JPUKH67K.mjs";
@@ -279,7 +285,7 @@ import {
 } from "./chunk-DTJJIMKJ.mjs";
 import {
   __export
-} from "./chunk-24FKGR6U.mjs";
+} from "./chunk-J5LGTIGS.mjs";
 
 // src/compat/index.ts
 var compat_exports = {};
@@ -331,6 +337,8 @@ __export(compat_exports, {
   isNotNil: () => isNotNil,
   isNull: () => isNull,
   isPlainObject: () => isPlainObject,
+  isPrimitive: () => isPrimitive,
+  isTypedArray: () => isTypedArray2,
   isUndefined: () => isUndefined,
   kebabCase: () => kebabCase,
   keyBy: () => keyBy,
@@ -524,7 +532,7 @@ function get(object, path, defaultValue) {
   let resolvedPath;
   if (Array.isArray(path)) {
     resolvedPath = path;
-  } else if (typeof path === "string" && isDeepKey(path) && (object == null ? void 0 : object[path]) == null) {
+  } else if (typeof path === "string" && isDeepKey(path) && object?.[path] == null) {
     resolvedPath = toPath(path);
   } else {
     resolvedPath = [path];
@@ -544,12 +552,11 @@ function get(object, path, defaultValue) {
   if (current === null && index === resolvedPath.length) {
     return current;
   }
-  return current != null ? current : defaultValue;
+  return current ?? defaultValue;
 }
 
 // src/compat/predicate/isPlainObject.ts
 function isPlainObject(object) {
-  var _a;
   if (typeof object !== "object") {
     return false;
   }
@@ -564,7 +571,7 @@ function isPlainObject(object) {
     if (tag == null) {
       return false;
     }
-    const isTagReadonly = !((_a = Object.getOwnPropertyDescriptor(object, Symbol.toStringTag)) == null ? void 0 : _a.writable);
+    const isTagReadonly = !Object.getOwnPropertyDescriptor(object, Symbol.toStringTag)?.writable;
     if (isTagReadonly) {
       return false;
     }
@@ -582,6 +589,11 @@ function isArray(value) {
   return Array.isArray(value);
 }
 
+// src/compat/predicate/isTypedArray.ts
+function isTypedArray2(x) {
+  return isTypedArray(x);
+}
+
 // src/compat/string/startsWith.ts
 var startsWith = (str, target, position = 0) => {
   return str.startsWith(target, position);
@@ -628,10 +640,11 @@ export {
   get,
   isPlainObject,
   isArray,
+  isTypedArray2 as isTypedArray,
   startsWith,
   endsWith,
   max,
   min,
   compat_exports
 };
-//# sourceMappingURL=chunk-36ZJSTNA.mjs.map
+//# sourceMappingURL=chunk-IGM5IABU.mjs.map

package/dist/chunk-IGM5IABU.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/compat/index.ts","../src/compat/array/chunk.ts","../src/compat/array/concat.ts","../src/compat/array/difference.ts","../src/compat/array/fill.ts","../src/compat/_internal/isIndex.ts","../src/compat/_internal/toPath.ts","../src/compat/object/set.ts","../src/compat/array/zipObjectDeep.ts","../src/compat/_internal/isDeepKey.ts","../src/compat/object/get.ts","../src/compat/predicate/isPlainObject.ts","../src/compat/predicate/isArray.ts","../src/compat/predicate/isTypedArray.ts","../src/compat/string/startsWith.ts","../src/compat/string/endsWith.ts","../src/compat/math/max.ts","../src/compat/math/min.ts"],"sourcesContent":["/**\n * es-toolkit compatibility layer with lodash (WIP)\n * ====================================\n * ```tsx\n * // es-toolkit/compat aims to provide 100% feature parity with lodash\n * import { chunk } from 'es-toolkit/compat';\n *\n * chunk([1, 2, 3, 4], 0);\n * // Returns [], which is identical to lodash\n * ```\n *\n * `es-toolkit/compat` will offer complete compatibility with lodash, ensuring a seamless transition.\n *\n * To guarantee identical behavior, `es-toolkit/compat` will be thoroughly tested using actual lodash test cases.\n *\n * The primary goal of `es-toolkit/compat` is to serve as a drop-in replacement for lodash.\n *\n * It's important to note that while `es-toolkit/compat` will mirror the behavior of lodash functions with 100% accuracy,\n * it will deliberately omit unsafe features, such as:\n *\n * - Implicit type casting from an empty string `''` to 0 or false, and similar cases.\n *\n * @module\n */\nexport * from '../index.ts';\n\nexport { chunk } from './array/chunk.ts';\nexport { concat } from './array/concat.ts';\nexport { difference } from './array/difference.ts';\nexport { fill } from './array/fill.ts';\nexport { zipObjectDeep } from './array/zipObjectDeep.ts';\nexport { head as first } from '../index.ts';\n\nexport { get } from './object/get.ts';\nexport { set } from './object/set.ts';\n\nexport { isPlainObject } from './predicate/isPlainObject.ts';\nexport { isArray } from './predicate/isArray.ts';\nexport { isTypedArray } from './predicate/isTypedArray.ts';\n\nexport { startsWith } from './string/startsWith.ts';\nexport { endsWith } from './string/endsWith.ts';\n\nexport { max } from './math/max.ts';\nexport { min } from './math/min.ts';\n","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","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 | readonly 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","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}","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 * @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","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}","/**\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 deepKey - The deep key string to convert.\n * @returns 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","import { isIndex } from \"../_internal/isIndex.ts\";\nimport { toPath } from \"../_internal/toPath.ts\";\n\n/**\n * Sets the value at the specified path of the given object. If any part of the path does not exist, it will be created.\n *\n * @template T - The type of the object.\n * @param {Settable} obj - The object to modify.\n * @param {Path} path - The path of the property to set.\n * @param {any} value - The value to set.\n * @returns {T} - The modified object.\n *\n * @example\n * // Set a value in a nested object\n * const obj = { a: { b: { c: 3 } } };\n * set(obj, 'a.b.c', 4);\n * console.log(obj.a.b.c); // 4\n *\n * @example\n * // Set a value in an array\n * const arr = [1, 2, 3];\n * set(arr, 1, 4);\n * console.log(arr[1]); // 4\n *\n * @example\n * // Create non-existent path and set value\n * const obj = {};\n * set(obj, 'a.b.c', 4);\n * console.log(obj); // { a: { b: { c: 4 } } }\n */\nexport function set<T>(obj: object, path: PropertyKey | readonly PropertyKey[], value: unknown): T;\nexport function set<T extends object>(obj: T, path: PropertyKey | readonly PropertyKey[], value: unknown): T {\n  const resolvedPath = Array.isArray(path)\n    ? path\n    : typeof path === 'string'\n      ? toPath(path)\n      : [path];\n\n  let current: any = obj;\n\n  for (let i = 0; i < resolvedPath.length - 1; i++) {\n    const key = resolvedPath[i];\n    const nextKey = resolvedPath[i + 1];\n\n    if (current[key] == null) {\n      current[key] = isIndex(nextKey) ? [] : {};\n    }\n\n    current = current[key];\n  }\n\n  const lastKey = resolvedPath[resolvedPath.length - 1];\n  current[lastKey] = value;\n\n  return obj;\n}\n","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 {string[] | string[][]} 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 string | number | symbol, V>(keys: P[], values: V[]): { [K in P]: V } {\n  const result = {} as { [K in P]: V };\n  const zipped = zip(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","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 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","import { isDeepKey } from \"../_internal/isDeepKey.ts\";\nimport { toPath } from \"../_internal/toPath.ts\";\nimport type { Get } from \"./get.types.ts\";\n\n/**\n * Retrieves the value at a given path from an object. If the resolved value is undefined, the defaultValue is returned instead.\n * \n * @template T - The type of the object.\n * @template K - The type of the key in the object.\n * @template D - The type of the default value.\n * \n * @param {T} object - The object to query.\n * @param {K | [K]} path - The path of the property to get.\n * @returns {T[K]} - Returns the resolved value.\n */\nexport function get<T extends object, K extends keyof T>(object: T, path: K | [K]): T[K];\n/**\n * Retrieves the value at a given path from an object. If the resolved value is undefined, the defaultValue is returned instead.\n * \n * @template T - The type of the object.\n * @template K - The type of the key in the object.\n * \n * @param {T | null | undefined} object - The object to query.\n * @param {K | [K]} path - The path of the property to get.\n * @returns {T[K] | undefined} - Returns the resolved value.\n */\nexport function get<T extends object, K extends keyof T>(object: T | null | undefined, path: K | [K]): T[K] | undefined;\n/**\n * Retrieves the value at a given path from an object. If the resolved value is undefined, the defaultValue is returned instead.\n * \n * @template T - The type of the object.\n * @template K - The type of the key in the object.\n * @template D - The type of the default value.\n * \n * @param {T | null | undefined} object - The object to query.\n * @param {K | [K]} path - The path of the property to get.\n * @param {D} defaultValue - The value returned if the resolved value is undefined.\n * @returns {Exclude<T[K], undefined> | D} - Returns the resolved value.\n */\nexport function get<T extends object, K extends keyof T, D>(object: T | null | undefined, path: K | [K], defaultValue: D): Exclude<T[K], undefined> | D;\n/**\n * Retrieves the value at a given path from an object. If the resolved value is undefined, the defaultValue is returned instead.\n * \n * @template T - The type of the object.\n * @template K1 - The type of the first key in the object.\n * @template K2 - The type of the second key in the object.\n * \n * @param {T} object - The object to query.\n * @param {[K1, K2]} path - The path of the property to get.\n * @returns {T[K1][K2]} - Returns the resolved value.\n */\nexport function get<T extends object, K1 extends keyof T, K2 extends keyof T[K1]>(object: T, path: [K1, K2]): T[K1][K2];\n/**\n * Retrieves the value at a given path from an object. If the resolved value is undefined, the defaultValue is returned instead.\n * \n * @template T - The type of the object.\n * @template K1 - The type of the first key in the object.\n * @template K2 - The type of the second key in the object.\n * \n * @param {T | null | undefined} object - The object to query.\n * @param {[K1, K2]} path - The path of the property to get.\n * @returns {T[K1][K2] | undefined} - Returns the resolved value.\n */\nexport function get<T extends object, K1 extends keyof T, K2 extends keyof T[K1]>(object: T | null | undefined, path: [K1, K2]): T[K1][K2] | undefined;\n/**\n * Retrieves the value at a given path from an object. If the resolved value is undefined, the defaultValue is returned instead.\n * \n * @template T - The type of the object.\n * @template K1 - The type of the first key in the object.\n * @template K2 - The type of the second key in the object.\n * @template D - The type of the default value.\n * \n * @param {T | null | undefined} object - The object to query.\n * @param {[K1, K2]} path - The path of the property to get.\n * @param {D} defaultValue - The value returned if the resolved value is undefined.\n * @returns {Exclude<T[K1][K2], undefined> | D} - Returns the resolved value.\n */\nexport function get<T extends object, K1 extends keyof T, K2 extends keyof T[K1], D>(object: T | null | undefined, path: [K1, K2], defaultValue: D): Exclude<T[K1][K2], undefined> | D;\n/**\n * Retrieves the value at a given path from an object. If the resolved value is undefined, the defaultValue is returned instead.\n * \n * @template T - The type of the object.\n * @template K1 - The type of the first key in the object.\n * @template K2 - The type of the second key in the object.\n * @template K3 - The type of the third key in the object.\n * \n * @param {T} object - The object to query.\n * @param {[K1, K2, K3]} path - The path of the property to get.\n * @returns {T[K1][K2][K3]} - Returns the resolved value.\n */\nexport function get<T extends object, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2]>(object: T, path: [K1, K2, K3]): T[K1][K2][K3];\n/**\n * Retrieves the value at a given path from an object. If the resolved value is undefined, the defaultValue is returned instead.\n * \n * @template T - The type of the object.\n * @template K1 - The type of the first key in the object.\n * @template K2 - The type of the second key in the object.\n * @template K3 - The type of the third key in the object.\n * \n * @param {T | null | undefined} object - The object to query.\n * @param {[K1, K2, K3]} path - The path of the property to get.\n * @returns {T[K1][K2][K3] | undefined} - Returns the resolved value.\n */\nexport function get<T extends object, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2]>(object: T | null | undefined, path: [K1, K2, K3]): T[K1][K2][K3] | undefined;\n/**\n * Retrieves the value at a given path from an object. If the resolved value is undefined, the defaultValue is returned instead.\n * \n * @template T - The type of the object.\n * @template K1 - The type of the first key in the object.\n * @template K2 - The type of the second key in the object.\n * @template K3 - The type of the third key in the object.\n * @template D - The type of the default value.\n * \n * @param {T | null | undefined} object - The object to query.\n * @param {[K1, K2, K3]} path - The path of the property to get.\n * @param {D} defaultValue - The value returned if the resolved value is undefined.\n * @returns {Exclude<T[K1][K2][K3], undefined> | D} - Returns the resolved value.\n */\nexport function get<T extends object, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], D>(object: T | null | undefined, path: [K1, K2, K3], defaultValue: D): Exclude<T[K1][K2][K3], undefined> | D;\n/**\n * Retrieves the value at a given path from an object. If the resolved value is undefined, the defaultValue is returned instead.\n * \n * @template T - The type of the object.\n * @template K1 - The type of the first key in the object.\n * @template K2 - The type of the second key in the object.\n * @template K3 - The type of the third key in the object.\n * @template K4 - The type of the fourth key in the object.\n * \n * @param {T} object - The object to query.\n * @param {[K1, K2, K3, K4]} path - The path of the property to get.\n * @returns {T[K1][K2][K3][K4]} - Returns the resolved value.\n */\nexport function get<T extends object, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3]>(object: T, path: [K1, K2, K3, K4]): T[K1][K2][K3][K4];\n/**\n * Retrieves the value at a given path from an object. If the resolved value is undefined, the defaultValue is returned instead.\n * \n * @template T - The type of the object.\n * @template K1 - The type of the first key in the object.\n * @template K2 - The type of the second key in the object.\n * @template K3 - The type of the third key in the object.\n * @template K4 - The type of the fourth key in the object.\n * \n * @param {T | null | undefined} object - The object to query.\n * @param {[K1, K2, K3, K4]} path - The path of the property to get.\n * @returns {T[K1][K2][K3][K4] | undefined} - Returns the resolved value.\n */\nexport function get<T extends object, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3]>(object: T | null | undefined, path: [K1, K2, K3, K4]): T[K1][K2][K3][K4] | undefined;\n/**\n * Retrieves the value at a given path from an object. If the resolved value is undefined, the defaultValue is returned instead.\n * \n * @template T - The type of the object.\n * @template K1 - The type of the first key in the object.\n * @template K2 - The type of the second key in the object.\n * @template K3 - The type of the third key in the object.\n * @template K4 - The type of the fourth key in the object.\n * @template D - The type of the default value.\n * \n * @param {T | null | undefined} object - The object to query.\n * @param {[K1, K2, K3, K4]} path - The path of the property to get.\n * @param {D} defaultValue - The value returned if the resolved value is undefined.\n * @returns {Exclude<T[K1][K2][K3][K4], undefined> | D} - Returns the resolved value.\n */\nexport function get<T extends object, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3], D>(object: T | null | undefined, path: [K1, K2, K3, K4], defaultValue: D): Exclude<T[K1][K2][K3][K4], undefined> | D;\n/**\n * Retrieves the value at a given path from an object with numeric keys. If the resolved value is undefined, the defaultValue is returned instead.\n * \n * @template T - The type of the value.\n * \n * @param {Record<number, T>} object - The object to query.\n * @param {number} path - The path of the property to get.\n * @returns {T} - Returns the resolved value.\n */\nexport function get<T>(object: Record<number, T>, path: number): T;\n/**\n * Retrieves the value at a given path from an object with numeric keys. If the resolved value is undefined, the defaultValue is returned instead.\n * \n * @template T - The type of the value.\n * \n * @param {Record<number, T> | null | undefined} object - The object to query.\n * @param {number} path - The path of the property to get.\n * @returns {T | undefined} - Returns the resolved value.\n */\nexport function get<T>(object: Record<number, T> | null | undefined, path: number): T | undefined;\n/**\n * Retrieves the value at a given path from an object with numeric keys. If the resolved value is undefined, the defaultValue is returned instead.\n * \n * @template T - The type of the value.\n * @template D - The type of the default value.\n * \n * @param {Record<number, T> | null | undefined} object - The object to query.\n * @param {number} path - The path of the property to get.\n * @param {D} defaultValue - The value returned if the resolved value is undefined.\n * @returns {T | D} - Returns the resolved value.\n */\nexport function get<T, D>(object: Record<number, T> | null | undefined, path: number, defaultValue: D): T | D;\n/**\n * Retrieves the value at a given path from a null or undefined object, returning the default value.\n * \n * @template D - The type of the default value.\n * \n * @param {null | undefined} object - The object to query.\n * @param {PropertyKey} path - The path of the property to get.\n * @param {D} defaultValue - The value returned if the resolved value is undefined.\n * @returns {D} - Returns the default value.\n */\nexport function get<D>(object: null | undefined, path: PropertyKey, defaultValue: D): D;\n/**\n * Retrieves the value at a given path from a null or undefined object, returning undefined.\n * \n * @param {null | undefined} object - The object to query.\n * @param {PropertyKey} path - The path of the property to get.\n * @returns {undefined} - Returns undefined.\n */\nexport function get(object: null | undefined, path: PropertyKey): undefined;\n/**\n * Retrieves the value at a given path from a string-keyed object. If the resolved value is undefined, the defaultValue is returned instead.\n * \n * @template T - The type of the object.\n * @template P - The type of the path.\n * \n * @param {T} data - The object to query.\n * @param {P} path - The path of the property to get.\n * @returns {string extends P ? any : Get<T, P>} - Returns the resolved value.\n */\nexport function get<T, P extends string>(data: T, path: P): string extends P ? any : Get<T, P>;\n/**\n * Retrieves the value at a given path from a string-keyed object. If the resolved value is undefined, the defaultValue is returned instead.\n * \n * @template T - The type of the object.\n * @template P - The type of the path.\n * @template D - The type of the default value.\n * \n * @param {T} data - The object to query.\n * @param {P} path - The path of the property to get.\n * @param {D} defaultValue - The value returned if the resolved value is undefined.\n * @returns {Exclude<Get<T, P>, null | undefined> | D} - Returns the resolved value.\n */\nexport function get<T, P extends string, D = Get<T, P>>(data: T, path: P, defaultValue: D): Exclude<Get<T, P>, null | undefined> | D;\n/**\n * Retrieves the value at a given path from an object. If the resolved value is undefined, the defaultValue is returned instead.\n * \n * @param {unknown} object - The object to query.\n * @param {PropertyKey | readonly PropertyKey[]} path - The path of the property to get.\n * @param {unknown} [defaultValue] - The value returned if the resolved value is undefined.\n * @returns {any} - Returns the resolved value.\n */\nexport function get(object: unknown, path: PropertyKey | readonly PropertyKey[], defaultValue?: unknown): any;\nexport function get(object: any, path: PropertyKey | readonly PropertyKey[], defaultValue?: any): any {\n  let resolvedPath;\n\n  if (Array.isArray(path)) {\n    resolvedPath = path;\n  } else if (typeof path === 'string' && isDeepKey(path) && object?.[path] == null) {\n    resolvedPath = toPath(path);\n  } else {\n    resolvedPath = [path];\n  }\n\n  if (resolvedPath.length === 0) {\n    return defaultValue;\n  }\n\n  let current = object;\n  let index;\n\n  for (index = 0; index < resolvedPath.length && current != null; index++) {\n    let key = resolvedPath[index];\n\n    if (Object.is(key.valueOf(), -0)) {\n      key = '-0';\n    }\n\n    current = current[key];\n  }\n\n  if (current === null && index === resolvedPath.length) {\n    return current;\n  }\n\n  return current ?? defaultValue;\n}","/**\n * Checks if a given value is a plain object.\n *\n * A plain object is an object created by the `{}` literal, `new Object()`, or\n * `Object.create(null)`.\n *\n * This function also handles objects with custom\n * `Symbol.toStringTag` properties.\n *\n * `Symbol.toStringTag` is a built-in symbol that a constructor can use to customize the\n * default string description of objects.\n *\n * @param {unknown} [object] - The value to check.\n * @returns {boolean} - True if the value is a plain object, otherwise false.\n *\n * @example\n * console.log(isPlainObject({})); // true\n * console.log(isPlainObject([])); // false\n * console.log(isPlainObject(null)); // false\n * console.log(isPlainObject(Object.create(null))); // true\n * console.log(isPlainObject(new Map())); // false\n */\nexport function isPlainObject(object?: unknown): boolean {\n  if (typeof object !== 'object') {\n    return false;\n  }\n\n  if (object == null) {\n    return false;\n  }\n\n  if (Object.getPrototypeOf(object) === null) {\n    return true;\n  }\n\n  if (object.toString() !== '[object Object]') {\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore\n    const tag = object[Symbol.toStringTag];\n\n    if (tag == null) {\n      return false;\n    }\n\n    const isTagReadonly = !Object.getOwnPropertyDescriptor(object, Symbol.toStringTag)?.writable;\n\n    if (isTagReadonly) {\n      return false;\n    }\n\n    return object.toString() === `[object ${tag}]`;\n  }\n\n  let proto = object;\n\n  while (Object.getPrototypeOf(proto) !== null) {\n    proto = Object.getPrototypeOf(proto);\n  }\n\n  return Object.getPrototypeOf(object) === proto;\n}\n","/**\n * Checks if the given value is an array.\n *\n * This function tests whether the provided value is an array or not.\n * It returns `true` if the value is an array, and `false` otherwise.\n *\n * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to an array.\n *\n * @template T - The type of value.\n * @param {T} value - The value to test if it is an array.\n * @returns {value is Extract<T, unknown[]>} `true` if the value is an array, `false` otherwise.\n *\n * @example\n * const value1 = [1, 2, 3];\n * const value2 = 'abc';\n * const value3 = () => {};\n *\n * console.log(isArray(value1)); // true\n * console.log(isArray(value2)); // false\n * console.log(isArray(value3)); // false\n */\nexport function isArray<T>(value?: T): value is Extract<T, readonly unknown[]> {\n  return Array.isArray(value);\n}\n","import { isTypedArray as isTypedArrayToolkit } from '../../predicate/isTypedArray.ts';\n\n/**\n * Checks if a value is a TypedArray.\n * @param {unknown} x The value to check.\n * @returns {x is\n *   | Uint8Array\n *   | Uint8ClampedArray\n *   | Uint16Array\n *   | Uint32Array\n *   | BigUint64Array\n *   | Int8Array\n *   | Int16Array\n *   | Int32Array\n *   | BigInt64Array\n *   | Float32Array\n *   | Float64Array} Returns true if `x` is a TypedArray, false otherwise.\n */\nexport function isTypedArray(\n  x?: unknown\n): x is\n  | Uint8Array\n  | Uint8ClampedArray\n  | Uint16Array\n  | Uint32Array\n  | BigUint64Array\n  | Int8Array\n  | Int16Array\n  | Int32Array\n  | BigInt64Array\n  | Float32Array\n  | Float64Array {\n  return isTypedArrayToolkit(x);\n}\n","/**\n * Checks if a string contains another string at the beginning of the string.\n *\n * Checks if one string startsWith another string. Optional position parameter to start searching from a certain index.\n *\n * @param {string} str - The string that might contain the target string.\n * @param {string} target - The string to search for.\n * @param {number} position - An optional offset to start searching in the str string\n * @returns {boolean} - True if the str string starts with the target string.\n *\n * @example\n * const isPrefix = startsWith('fooBar', 'foo') // returns true\n * const isPrefix = startsWith('fooBar', 'bar') // returns false\n * const isPrefix = startsWith('fooBar', 'abc') // returns false\n * const isPrefix = startsWith('fooBar', 'Bar', 2) // returns true\n * const isPrefix = startsWith('fooBar', 'Bar', 5) // returns false\n */\nexport const startsWith = (str: string, target: string, position = 0): boolean => {\n  return str.startsWith(target, position);\n};\n","/**\n * Checks if a string contains another string at the end of the string.\n *\n * Checks if one string endsWith another string. Optional position parameter to offset searching before a certain index.\n *\n * @param {string} str - The string that might contain the target string.\n * @param {string} target - The string to search for.\n * @param {number} position - An optional position from the start to search up to this index\n * @returns {boolean} - True if the str string ends with the target string.\n *\n * @example\n * const isPrefix = endsWith('fooBar', 'foo') // returns true\n * const isPrefix = endsWith('fooBar', 'bar') // returns false\n * const isPrefix = endsWith('fooBar', 'abc') // returns false\n * const isPrefix = endsWith('fooBar', 'foo', 3) // returns true\n * const isPrefix = endsWith('fooBar', 'abc', 5) // returns false\n */\nexport const endsWith = (str: string, target: string, position: number = str.length): boolean => {\n  return str.endsWith(target, position);\n};\n","/**\n * Finds the element in an array that has the maximum value.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} items The array of elements to search.\n * @returns {T | undefined} The element with the maximum value.\n * @example\n * // Returns 9\n * max([3, 1, 4, 1, 5, 9])\n *\n * @example\n * // Returns 8\n * max([0, -3, 2, 8, 7])\n */\nexport function max<T>(items: readonly [T, ...T[]]): T;\nexport function max(): undefined;\nexport function max<T>(items?: readonly T[]): T | undefined;\nexport function max<T>(items: readonly T[] = []): T | undefined {\n  let maxElement = items[0];\n  let max = undefined;\n\n  for (const element of items) {\n    if (max == null || element > max) {\n      max = element;\n      maxElement = element;\n    }\n  }\n\n  return maxElement;\n}\n","/**\n * Finds the element in an array that has the minimum value.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} items The array of elements to search.\n * @returns {T | undefined} The element with the minimum value.\n * @example\n * // Returns 1\n * min([3, 1, 4, 1, 5, 9])\n *\n * @example\n * // Returns -3\n * min([0, -3, 2, 8, 7])\n */\nexport function min<T>(items: readonly [T, ...T[]]): T;\nexport function min(): undefined;\nexport function min<T>(items?: readonly T[]): T | undefined;\nexport function min<T>(items: readonly T[] = []): T {\n  let minElement = items[0];\n  let min = undefined;\n\n  for (const element of items) {\n    if (min == null || element < min) {\n      min = element;\n      minElement = element;\n    }\n  }\n\n  return minElement;\n}\n"],"mappings":"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","names":["chunk","difference","fill","isTypedArray","chunk","difference","fill","isTypedArray","max","min"]}

package/dist/{chunk-F3WCQQET.mjs → chunk-IWXZI3QT.mjs}

@@ -1,6 +1,6 @@
 import {
   getWords
-} from "./chunk-WVQ7YVRK.mjs";
+} from "./chunk-OG2RLT5U.mjs";
 
 // src/string/snakeCase.ts
 var snakeCase = (str) => {
@@ -11,4 +11,4 @@ var snakeCase = (str) => {
 export {
   snakeCase
 };
-//# sourceMappingURL=chunk-F3WCQQET.mjs.map
+//# sourceMappingURL=chunk-IWXZI3QT.mjs.map

package/dist/chunk-J5LGTIGS.mjs

@@ -0,0 +1,10 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};
+//# sourceMappingURL=chunk-J5LGTIGS.mjs.map

package/dist/{chunk-5CPXZFCB.mjs → chunk-K5WL54BY.mjs}

@@ -77,7 +77,7 @@ function cloneDeepHelper(obj, clonedObj) {
   for (const key in obj) {
     if (Object.prototype.hasOwnProperty.call(obj, key)) {
       const descriptor = Object.getOwnPropertyDescriptor(obj, key);
-      if (((descriptor == null ? void 0 : descriptor.writable) || (descriptor == null ? void 0 : descriptor.set)) && typeof (descriptor == null ? void 0 : descriptor.value) !== "function") {
+      if ((descriptor?.writable || descriptor?.set) && typeof descriptor?.value !== "function") {
         clonedObj[key] = cloneDeep(obj[key]);
       }
     }
@@ -90,4 +90,4 @@ function isTypedArray(obj) {
 export {
   cloneDeep
 };
-//# sourceMappingURL=chunk-5CPXZFCB.mjs.map
+//# sourceMappingURL=chunk-K5WL54BY.mjs.map

package/dist/{chunk-5CPXZFCB.mjs.map → chunk-K5WL54BY.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/object/cloneDeep.ts"],"sourcesContent":["/**\n * Creates a deep clone of the given object.\n *\n * @template T - The type of the object.\n * @param {T} obj - The object to clone.\n * @returns {T} - A deep clone of the given object.\n *\n * @example\n * // Clone a primitive values\n * const num = 29;\n * const clonedNum = clone(num);\n * console.log(clonedNum); // 29\n * console.log(clonedNum === num) ; // true\n *\n * @example\n * // Clone an array\n * const arr = [1, 2, 3];\n * const clonedArr = clone(arr);\n * console.log(clonedArr); // [1, 2, 3]\n * console.log(clonedArr === arr); // false\n *\n * @example\n * // Clone an array with nested objects\n * const arr = [1, { a: 1 }, [1, 2, 3]];\n * const clonedArr = clone(arr);\n * arr[1].a = 2;\n * console.log(arr); // [2, { a: 2 }, [1, 2, 3]]\n * console.log(clonedArr); // [1, { a: 1 }, [1, 2, 3]]\n * console.log(clonedArr === arr); // false\n *\n * @example\n * // Clone an object\n * const obj = { a: 1, b: 'es-toolkit', c: [1, 2, 3] };\n * const clonedObj = clone(obj);\n * console.log(clonedObj); // { a: 1, b: 'es-toolkit', c: [1, 2, 3] }\n * console.log(clonedObj === obj); // false\n *\n * @example\n * // Clone an object with nested objects\n * const obj = { a: 1, b: { c: 1 } };\n * const clonedObj = clone(obj);\n * obj.b.c = 2;\n * console.log(obj); // { a: 1, b: { c: 2 } }\n * console.log(clonedObj); // { a: 1, b: { c: 1 } }\n * console.log(clonedObj === obj); // false\n */\nexport function cloneDeep<T>(obj: T): Resolved<T> {\n  if (isPrimitive(obj)) {\n    return obj as Resolved<T>;\n  }\n\n  if (Array.isArray(obj)) {\n    return obj.map(item => cloneDeep(item)) as Resolved<T>;\n  }\n\n  if (obj instanceof Date) {\n    return new Date(obj.getTime()) as Resolved<T>;\n  }\n\n  if (obj instanceof RegExp) {\n    return new RegExp(obj.source, obj.flags) as Resolved<T>;\n  }\n\n  if (obj instanceof Map) {\n    const result = new Map();\n    for (const [key, value] of obj.entries()) {\n      result.set(key, cloneDeep(value));\n    }\n    return result as Resolved<T>;\n  }\n\n  if (obj instanceof Set) {\n    const result = new Set();\n    for (const value of obj.values()) {\n      result.add(cloneDeep(value));\n    }\n    return result as Resolved<T>;\n  }\n\n  if (isTypedArray(obj)) {\n    const result = new (Object.getPrototypeOf(obj).constructor)(obj.length);\n    for (let i = 0; i < obj.length; i++) {\n      result[i] = cloneDeep(obj[i]);\n    }\n    return result as Resolved<T>;\n  }\n\n  if (obj instanceof ArrayBuffer || obj instanceof SharedArrayBuffer) {\n    return obj.slice(0) as Resolved<T>;\n  }\n\n  if (obj instanceof DataView) {\n    const result = new DataView(obj.buffer.slice(0));\n    cloneDeepHelper(obj, result);\n    return result as Resolved<T>;\n  }\n\n  // For legacy NodeJS support\n  if (typeof File !== 'undefined' && obj instanceof File) {\n    const result = new File([obj], obj.name, { type: obj.type });\n    cloneDeepHelper(obj, result);\n    return result as Resolved<T>;\n  }\n\n  if (obj instanceof Blob) {\n    const result = new Blob([obj], { type: obj.type });\n    cloneDeepHelper(obj, result);\n    return result as Resolved<T>;\n  }\n\n  if (obj instanceof Error) {\n    const result = new (obj.constructor as { new (): Error })();\n    result.message = obj.message;\n    result.name = obj.name;\n    result.stack = obj.stack;\n    result.cause = obj.cause;\n    cloneDeepHelper(obj, result);\n    return result as Resolved<T>;\n  }\n\n  if (typeof obj === 'object' && obj !== null) {\n    const result = {};\n    cloneDeepHelper(obj, result);\n    return result as Resolved<T>;\n  }\n\n  if (typeof obj === 'function') {\n    return void 0 as Resolved<T>;\n  }\n\n  return obj as Resolved<T>;\n}\n\ntype Primitive = null | undefined | string | number | boolean | symbol | bigint;\nfunction isPrimitive(value: unknown): value is Primitive {\n  return value == null || (typeof value !== 'object' && typeof value !== 'function');\n}\n\n// eslint-disable-next-line\nfunction cloneDeepHelper(obj: any, clonedObj: any): void {\n  for (const key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key)) {\n      const descriptor = Object.getOwnPropertyDescriptor(obj, key);\n      if ((descriptor?.writable || descriptor?.set) && typeof descriptor?.value !== 'function') {\n        clonedObj[key] = cloneDeep(obj[key]);\n      }\n    }\n  }\n}\n\nfunction isTypedArray(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  obj: any\n): obj is\n  | Uint8Array\n  | Uint8ClampedArray\n  | Uint16Array\n  | Uint32Array\n  | BigUint64Array\n  | Int8Array\n  | Int16Array\n  | Int32Array\n  | BigInt64Array\n  | Float32Array\n  | Float64Array {\n  return (\n    obj instanceof Uint8Array ||\n    obj instanceof Uint8ClampedArray ||\n    obj instanceof Uint16Array ||\n    obj instanceof Uint32Array ||\n    obj instanceof BigUint64Array ||\n    obj instanceof Int8Array ||\n    obj instanceof Int16Array ||\n    obj instanceof Int32Array ||\n    obj instanceof BigInt64Array ||\n    obj instanceof Float32Array ||\n    obj instanceof Float64Array\n  );\n}\n\nexport type Resolved<T> = Equal<T, ResolvedMain<T>> extends true ? T : ResolvedMain<T>;\n\ntype Equal<X, Y> = X extends Y ? (Y extends X ? true : false) : false;\n\ntype ResolvedMain<T> = T extends [never]\n  ? never // (special trick for jsonable | null) type\n  : ValueOf<T> extends boolean | number | bigint | string\n    ? ValueOf<T>\n    : T extends (...args: any[]) => any\n      ? never\n      : T extends object\n        ? ResolvedObject<T>\n        : ValueOf<T>;\n\ntype ResolvedObject<T extends object> =\n  T extends Array<infer U>\n    ? IsTuple<T> extends true\n      ? ResolvedTuple<T>\n      : Array<ResolvedMain<U>>\n    : T extends Set<infer U>\n      ? Set<ResolvedMain<U>>\n      : T extends Map<infer K, infer V>\n        ? Map<ResolvedMain<K>, ResolvedMain<V>>\n        : T extends WeakSet<any> | WeakMap<any, any>\n          ? never\n          : T extends\n                | Date\n                | Uint8Array\n                | Uint8ClampedArray\n                | Uint16Array\n                | Uint32Array\n                | BigUint64Array\n                | Int8Array\n                | Int16Array\n                | Int32Array\n                | BigInt64Array\n                | Float32Array\n                | Float64Array\n                | ArrayBuffer\n                | SharedArrayBuffer\n                | DataView\n                | Blob\n                | File\n            ? T\n            : {\n                [P in keyof T]: ResolvedMain<T[P]>;\n              };\n\ntype ResolvedTuple<T extends readonly any[]> = T extends []\n  ? []\n  : T extends [infer F]\n    ? [ResolvedMain<F>]\n    : T extends [infer F, ...infer Rest extends readonly any[]]\n      ? [ResolvedMain<F>, ...ResolvedTuple<Rest>]\n      : T extends [(infer F)?]\n        ? [ResolvedMain<F>?]\n        : T extends [(infer F)?, ...infer Rest extends readonly any[]]\n          ? [ResolvedMain<F>?, ...ResolvedTuple<Rest>]\n          : [];\n\ntype IsTuple<T extends readonly any[] | { length: number }> = [T] extends [never]\n  ? false\n  : T extends readonly any[]\n    ? number extends T['length']\n      ? false\n      : true\n    : false;\n\ntype ValueOf<Instance> =\n  IsValueOf<Instance, boolean> extends true\n    ? boolean\n    : IsValueOf<Instance, number> extends true\n      ? number\n      : IsValueOf<Instance, string> extends true\n        ? string\n        : Instance;\n\ntype IsValueOf<Instance, O extends IValueOf<any>> = Instance extends O\n  ? O extends IValueOf<infer Primitive>\n    ? Instance extends Primitive\n      ? false\n      : true // not Primitive, but Object\n    : false // cannot be\n  : false;\n\ninterface IValueOf<T> {\n  valueOf(): T;\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/object/cloneDeep.ts"],"sourcesContent":["/**\n * Creates a deep clone of the given object.\n *\n * @template T - The type of the object.\n * @param {T} obj - The object to clone.\n * @returns {T} - A deep clone of the given object.\n *\n * @example\n * // Clone a primitive values\n * const num = 29;\n * const clonedNum = clone(num);\n * console.log(clonedNum); // 29\n * console.log(clonedNum === num) ; // true\n *\n * @example\n * // Clone an array\n * const arr = [1, 2, 3];\n * const clonedArr = clone(arr);\n * console.log(clonedArr); // [1, 2, 3]\n * console.log(clonedArr === arr); // false\n *\n * @example\n * // Clone an array with nested objects\n * const arr = [1, { a: 1 }, [1, 2, 3]];\n * const clonedArr = clone(arr);\n * arr[1].a = 2;\n * console.log(arr); // [2, { a: 2 }, [1, 2, 3]]\n * console.log(clonedArr); // [1, { a: 1 }, [1, 2, 3]]\n * console.log(clonedArr === arr); // false\n *\n * @example\n * // Clone an object\n * const obj = { a: 1, b: 'es-toolkit', c: [1, 2, 3] };\n * const clonedObj = clone(obj);\n * console.log(clonedObj); // { a: 1, b: 'es-toolkit', c: [1, 2, 3] }\n * console.log(clonedObj === obj); // false\n *\n * @example\n * // Clone an object with nested objects\n * const obj = { a: 1, b: { c: 1 } };\n * const clonedObj = clone(obj);\n * obj.b.c = 2;\n * console.log(obj); // { a: 1, b: { c: 2 } }\n * console.log(clonedObj); // { a: 1, b: { c: 1 } }\n * console.log(clonedObj === obj); // false\n */\nexport function cloneDeep<T>(obj: T): Resolved<T> {\n  if (isPrimitive(obj)) {\n    return obj as Resolved<T>;\n  }\n\n  if (Array.isArray(obj)) {\n    return obj.map(item => cloneDeep(item)) as Resolved<T>;\n  }\n\n  if (obj instanceof Date) {\n    return new Date(obj.getTime()) as Resolved<T>;\n  }\n\n  if (obj instanceof RegExp) {\n    return new RegExp(obj.source, obj.flags) as Resolved<T>;\n  }\n\n  if (obj instanceof Map) {\n    const result = new Map();\n    for (const [key, value] of obj.entries()) {\n      result.set(key, cloneDeep(value));\n    }\n    return result as Resolved<T>;\n  }\n\n  if (obj instanceof Set) {\n    const result = new Set();\n    for (const value of obj.values()) {\n      result.add(cloneDeep(value));\n    }\n    return result as Resolved<T>;\n  }\n\n  if (isTypedArray(obj)) {\n    const result = new (Object.getPrototypeOf(obj).constructor)(obj.length);\n    for (let i = 0; i < obj.length; i++) {\n      result[i] = cloneDeep(obj[i]);\n    }\n    return result as Resolved<T>;\n  }\n\n  if (obj instanceof ArrayBuffer || obj instanceof SharedArrayBuffer) {\n    return obj.slice(0) as Resolved<T>;\n  }\n\n  if (obj instanceof DataView) {\n    const result = new DataView(obj.buffer.slice(0));\n    cloneDeepHelper(obj, result);\n    return result as Resolved<T>;\n  }\n\n  // For legacy NodeJS support\n  if (typeof File !== 'undefined' && obj instanceof File) {\n    const result = new File([obj], obj.name, { type: obj.type });\n    cloneDeepHelper(obj, result);\n    return result as Resolved<T>;\n  }\n\n  if (obj instanceof Blob) {\n    const result = new Blob([obj], { type: obj.type });\n    cloneDeepHelper(obj, result);\n    return result as Resolved<T>;\n  }\n\n  if (obj instanceof Error) {\n    const result = new (obj.constructor as { new (): Error })();\n    result.message = obj.message;\n    result.name = obj.name;\n    result.stack = obj.stack;\n    result.cause = obj.cause;\n    cloneDeepHelper(obj, result);\n    return result as Resolved<T>;\n  }\n\n  if (typeof obj === 'object' && obj !== null) {\n    const result = {};\n    cloneDeepHelper(obj, result);\n    return result as Resolved<T>;\n  }\n\n  if (typeof obj === 'function') {\n    return void 0 as Resolved<T>;\n  }\n\n  return obj as Resolved<T>;\n}\n\ntype Primitive = null | undefined | string | number | boolean | symbol | bigint;\nfunction isPrimitive(value: unknown): value is Primitive {\n  return value == null || (typeof value !== 'object' && typeof value !== 'function');\n}\n\n// eslint-disable-next-line\nfunction cloneDeepHelper(obj: any, clonedObj: any): void {\n  for (const key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key)) {\n      const descriptor = Object.getOwnPropertyDescriptor(obj, key);\n      if ((descriptor?.writable || descriptor?.set) && typeof descriptor?.value !== 'function') {\n        clonedObj[key] = cloneDeep(obj[key]);\n      }\n    }\n  }\n}\n\nfunction isTypedArray(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  obj: any\n): obj is\n  | Uint8Array\n  | Uint8ClampedArray\n  | Uint16Array\n  | Uint32Array\n  | BigUint64Array\n  | Int8Array\n  | Int16Array\n  | Int32Array\n  | BigInt64Array\n  | Float32Array\n  | Float64Array {\n  return (\n    obj instanceof Uint8Array ||\n    obj instanceof Uint8ClampedArray ||\n    obj instanceof Uint16Array ||\n    obj instanceof Uint32Array ||\n    obj instanceof BigUint64Array ||\n    obj instanceof Int8Array ||\n    obj instanceof Int16Array ||\n    obj instanceof Int32Array ||\n    obj instanceof BigInt64Array ||\n    obj instanceof Float32Array ||\n    obj instanceof Float64Array\n  );\n}\n\nexport type Resolved<T> = Equal<T, ResolvedMain<T>> extends true ? T : ResolvedMain<T>;\n\ntype Equal<X, Y> = X extends Y ? (Y extends X ? true : false) : false;\n\ntype ResolvedMain<T> = T extends [never]\n  ? never // (special trick for jsonable | null) type\n  : ValueOf<T> extends boolean | number | bigint | string\n    ? ValueOf<T>\n    : T extends (...args: any[]) => any\n      ? never\n      : T extends object\n        ? ResolvedObject<T>\n        : ValueOf<T>;\n\ntype ResolvedObject<T extends object> =\n  T extends Array<infer U>\n    ? IsTuple<T> extends true\n      ? ResolvedTuple<T>\n      : Array<ResolvedMain<U>>\n    : T extends Set<infer U>\n      ? Set<ResolvedMain<U>>\n      : T extends Map<infer K, infer V>\n        ? Map<ResolvedMain<K>, ResolvedMain<V>>\n        : T extends WeakSet<any> | WeakMap<any, any>\n          ? never\n          : T extends\n                | Date\n                | Uint8Array\n                | Uint8ClampedArray\n                | Uint16Array\n                | Uint32Array\n                | BigUint64Array\n                | Int8Array\n                | Int16Array\n                | Int32Array\n                | BigInt64Array\n                | Float32Array\n                | Float64Array\n                | ArrayBuffer\n                | SharedArrayBuffer\n                | DataView\n                | Blob\n                | File\n            ? T\n            : {\n                [P in keyof T]: ResolvedMain<T[P]>;\n              };\n\ntype ResolvedTuple<T extends readonly any[]> = T extends []\n  ? []\n  : T extends [infer F]\n    ? [ResolvedMain<F>]\n    : T extends [infer F, ...infer Rest extends readonly any[]]\n      ? [ResolvedMain<F>, ...ResolvedTuple<Rest>]\n      : T extends [(infer F)?]\n        ? [ResolvedMain<F>?]\n        : T extends [(infer F)?, ...infer Rest extends readonly any[]]\n          ? [ResolvedMain<F>?, ...ResolvedTuple<Rest>]\n          : [];\n\ntype IsTuple<T extends readonly any[] | { length: number }> = [T] extends [never]\n  ? false\n  : T extends readonly any[]\n    ? number extends T['length']\n      ? false\n      : true\n    : false;\n\ntype ValueOf<Instance> =\n  IsValueOf<Instance, boolean> extends true\n    ? boolean\n    : IsValueOf<Instance, number> extends true\n      ? number\n      : IsValueOf<Instance, string> extends true\n        ? string\n        : Instance;\n\ntype IsValueOf<Instance, O extends IValueOf<any>> = Instance extends O\n  ? O extends IValueOf<infer Primitive>\n    ? Instance extends Primitive\n      ? false\n      : true // not Primitive, but Object\n    : false // cannot be\n  : false;\n\ninterface IValueOf<T> {\n  valueOf(): T;\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-3IP4JVLL.mjs → chunk-MSHSKENG.mjs}

@@ -5,7 +5,7 @@ function debounce(func, debounceMs, { signal } = {}) {
     if (timeoutId !== null) {
       clearTimeout(timeoutId);
     }
-    if (signal == null ? void 0 : signal.aborted) {
+    if (signal?.aborted) {
       return;
     }
     timeoutId = setTimeout(() => {
@@ -22,11 +22,11 @@ function debounce(func, debounceMs, { signal } = {}) {
       timeoutId = null;
     }
   };
-  signal == null ? void 0 : signal.addEventListener("abort", onAbort, { once: true });
+  signal?.addEventListener("abort", onAbort, { once: true });
   return debounced;
 }
 
 export {
   debounce
 };
-//# sourceMappingURL=chunk-3IP4JVLL.mjs.map
+//# sourceMappingURL=chunk-MSHSKENG.mjs.map

package/dist/{chunk-3IP4JVLL.mjs.map → chunk-MSHSKENG.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/function/debounce.ts"],"sourcesContent":["interface DebounceOptions {\n  signal?: AbortSignal;\n}\n\n/**\n * Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds\n * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`\n * method to cancel any pending execution.\n *\n * @template F - The type of function.\n * @param {F} func - The function to debounce.\n * @param {number} debounceMs - The number of milliseconds to delay.\n * @param {DebounceOptions} options - The options object.\n * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the debounced function.\n * @returns {F & { cancel: () => void }} A new debounced function with a `cancel` method.\n *\n * @example\n * const debouncedFunction = debounce(() => {\n *   console.log('Function executed');\n * }, 1000);\n *\n * // Will log 'Function executed' after 1 second if not called again in that time\n * debouncedFunction();\n *\n * // Will not log anything as the previous call is canceled\n * debouncedFunction.cancel();\n *\n * // With AbortSignal\n * const controller = new AbortController();\n * const signal = controller.signal;\n * const debouncedWithSignal = debounce(() => {\n *  console.log('Function executed');\n * }, 1000, { signal });\n *\n * debouncedWithSignal();\n *\n * // Will cancel the debounced function call\n * controller.abort();\n */\nexport function debounce<F extends (...args: any[]) => void>(\n  func: F,\n  debounceMs: number,\n  { signal }: DebounceOptions = {}\n): F & { cancel: () => void } {\n  let timeoutId: number | null = null;\n\n  const debounced = function (...args: Parameters<F>) {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n    }\n\n    if (signal?.aborted) {\n      return;\n    }\n\n    timeoutId = setTimeout(() => {\n      func(...args);\n      timeoutId = null;\n    }, debounceMs) as any;\n  } as F & { cancel: () => void };\n\n  const onAbort = function () {\n    debounced.cancel();\n  };\n\n  debounced.cancel = function () {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n      timeoutId = null;\n    }\n  };\n\n  signal?.addEventListener('abort', onAbort, { once: true });\n\n  return debounced;\n}\n"],"mappings":";AAuCO,SAAS,SACd,MACA,YACA,EAAE,OAAO,IAAqB,CAAC,GACH;AAC5B,MAAI,YAA2B;AAE/B,QAAM,YAAY,YAAa,MAAqB;AAClD,QAAI,cAAc,MAAM;AACtB,mBAAa,SAAS;AAAA,IACxB;AAEA,QAAI,iCAAQ,SAAS;AACnB;AAAA,IACF;AAEA,gBAAY,WAAW,MAAM;AAC3B,WAAK,GAAG,IAAI;AACZ,kBAAY;AAAA,IACd,GAAG,UAAU;AAAA,EACf;AAEA,QAAM,UAAU,WAAY;AAC1B,cAAU,OAAO;AAAA,EACnB;AAEA,YAAU,SAAS,WAAY;AAC7B,QAAI,cAAc,MAAM;AACtB,mBAAa,SAAS;AACtB,kBAAY;AAAA,IACd;AAAA,EACF;AAEA,mCAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK;AAExD,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../src/function/debounce.ts"],"sourcesContent":["interface DebounceOptions {\n  signal?: AbortSignal;\n}\n\n/**\n * Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds\n * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`\n * method to cancel any pending execution.\n *\n * @template F - The type of function.\n * @param {F} func - The function to debounce.\n * @param {number} debounceMs - The number of milliseconds to delay.\n * @param {DebounceOptions} options - The options object.\n * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the debounced function.\n * @returns {F & { cancel: () => void }} A new debounced function with a `cancel` method.\n *\n * @example\n * const debouncedFunction = debounce(() => {\n *   console.log('Function executed');\n * }, 1000);\n *\n * // Will log 'Function executed' after 1 second if not called again in that time\n * debouncedFunction();\n *\n * // Will not log anything as the previous call is canceled\n * debouncedFunction.cancel();\n *\n * // With AbortSignal\n * const controller = new AbortController();\n * const signal = controller.signal;\n * const debouncedWithSignal = debounce(() => {\n *  console.log('Function executed');\n * }, 1000, { signal });\n *\n * debouncedWithSignal();\n *\n * // Will cancel the debounced function call\n * controller.abort();\n */\nexport function debounce<F extends (...args: any[]) => void>(\n  func: F,\n  debounceMs: number,\n  { signal }: DebounceOptions = {}\n): F & { cancel: () => void } {\n  let timeoutId: number | null = null;\n\n  const debounced = function (...args: Parameters<F>) {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n    }\n\n    if (signal?.aborted) {\n      return;\n    }\n\n    timeoutId = setTimeout(() => {\n      func(...args);\n      timeoutId = null;\n    }, debounceMs) as any;\n  } as F & { cancel: () => void };\n\n  const onAbort = function () {\n    debounced.cancel();\n  };\n\n  debounced.cancel = function () {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n      timeoutId = null;\n    }\n  };\n\n  signal?.addEventListener('abort', onAbort, { once: true });\n\n  return debounced;\n}\n"],"mappings":";AAuCO,SAAS,SACd,MACA,YACA,EAAE,OAAO,IAAqB,CAAC,GACH;AAC5B,MAAI,YAA2B;AAE/B,QAAM,YAAY,YAAa,MAAqB;AAClD,QAAI,cAAc,MAAM;AACtB,mBAAa,SAAS;AAAA,IACxB;AAEA,QAAI,QAAQ,SAAS;AACnB;AAAA,IACF;AAEA,gBAAY,WAAW,MAAM;AAC3B,WAAK,GAAG,IAAI;AACZ,kBAAY;AAAA,IACd,GAAG,UAAU;AAAA,EACf;AAEA,QAAM,UAAU,WAAY;AAC1B,cAAU,OAAO;AAAA,EACnB;AAEA,YAAU,SAAS,WAAY;AAC7B,QAAI,cAAc,MAAM;AACtB,mBAAa,SAAS;AACtB,kBAAY;AAAA,IACd;AAAA,EACF;AAEA,UAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;AAEzD,SAAO;AACT;","names":[]}

package/dist/{chunk-WVQ7YVRK.mjs → chunk-OG2RLT5U.mjs}

@@ -1,11 +1,10 @@
 // src/string/_internal/getWords.ts
 var CASE_SPLIT_PATTERN = /[A-Z]?[a-z]+|[0-9]+|[A-Z]+(?![a-z])/g;
 function getWords(str) {
-  var _a;
-  return Array.from((_a = str.match(CASE_SPLIT_PATTERN)) != null ? _a : []);
+  return Array.from(str.match(CASE_SPLIT_PATTERN) ?? []);
 }
 
 export {
   getWords
 };
-//# sourceMappingURL=chunk-WVQ7YVRK.mjs.map
+//# sourceMappingURL=chunk-OG2RLT5U.mjs.map

package/dist/{chunk-WVQ7YVRK.mjs.map → chunk-OG2RLT5U.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/string/_internal/getWords.ts"],"sourcesContent":["/**\n * Regular expression pattern to split strings into words for various case conversions\n *\n * This pattern matchs sequences of characters in a string, considering the following case:\n * - Sequences of two or more uppercase letters followed by an uppercase letter and lowercase letters or digits (for acronyms)\n * - Sequences of one uppercase letter optionally followed by lowercase letters and digits\n * - Single uppercase letters\n * - Sequences of digis\n *\n * The resulting match can be used to convert camelCase, snake_case, kebab-case, and other mixed formats into\n * a consistent format like snake case.\n *\n * @example\n * const matches = 'camelCaseHTTPRequest'.match(CASE_SPLIT_PATTERN);\n * // matchs: ['camel', 'Case', 'HTTP', 'Request']\n */\nconst CASE_SPLIT_PATTERN = /[A-Z]?[a-z]+|[0-9]+|[A-Z]+(?![a-z])/g;\n\nexport function getWords(str: string): string[] {\n  return Array.from(str.match(CASE_SPLIT_PATTERN) ?? []);\n}\n"],"mappings":";AAgBA,IAAM,qBAAqB;AAEpB,SAAS,SAAS,KAAuB;AAlBhD;AAmBE,SAAO,MAAM,MAAK,SAAI,MAAM,kBAAkB,MAA5B,YAAiC,CAAC,CAAC;AACvD;","names":[]}
+{"version":3,"sources":["../src/string/_internal/getWords.ts"],"sourcesContent":["/**\n * Regular expression pattern to split strings into words for various case conversions\n *\n * This pattern matchs sequences of characters in a string, considering the following case:\n * - Sequences of two or more uppercase letters followed by an uppercase letter and lowercase letters or digits (for acronyms)\n * - Sequences of one uppercase letter optionally followed by lowercase letters and digits\n * - Single uppercase letters\n * - Sequences of digis\n *\n * The resulting match can be used to convert camelCase, snake_case, kebab-case, and other mixed formats into\n * a consistent format like snake case.\n *\n * @example\n * const matches = 'camelCaseHTTPRequest'.match(CASE_SPLIT_PATTERN);\n * // matchs: ['camel', 'Case', 'HTTP', 'Request']\n */\nconst CASE_SPLIT_PATTERN = /[A-Z]?[a-z]+|[0-9]+|[A-Z]+(?![a-z])/g;\n\nexport function getWords(str: string): string[] {\n  return Array.from(str.match(CASE_SPLIT_PATTERN) ?? []);\n}\n"],"mappings":";AAgBA,IAAM,qBAAqB;AAEpB,SAAS,SAAS,KAAuB;AAC9C,SAAO,MAAM,KAAK,IAAI,MAAM,kBAAkB,KAAK,CAAC,CAAC;AACvD;","names":[]}

package/dist/chunk-R6GLTTAB.mjs

@@ -0,0 +1,9 @@
+// src/predicate/isPrimitive.ts
+function isPrimitive(value) {
+  return value == null || typeof value !== "object" && typeof value !== "function";
+}
+
+export {
+  isPrimitive
+};
+//# sourceMappingURL=chunk-R6GLTTAB.mjs.map

package/dist/chunk-R6GLTTAB.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/predicate/isPrimitive.ts"],"sourcesContent":["/**\n * Checks whether a value is a JavaScript primitive.\n * JavaScript primitives include null, undefined, strings, numbers, booleans, symbols, and bigints.\n *\n * @param {unknown} x The value to check.\n * @returns {x is\n *   | null\n *   | undefined\n *   | string\n *   | number\n *   | boolean\n *   | symbol\n *   | bigint} Returns true if `x` is a primitive, false otherwise.\n */\nexport function isPrimitive(value: unknown): value is null | undefined | string | number | boolean | symbol | bigint {\n  return value == null || (typeof value !== 'object' && typeof value !== 'function');\n}\n"],"mappings":";AAcO,SAAS,YAAY,OAAyF;AACnH,SAAO,SAAS,QAAS,OAAO,UAAU,YAAY,OAAO,UAAU;AACzE;","names":[]}