es-toolkit 1.13.0-dev.293 → 1.13.0-dev.294

package/dist/browser.mjs

@@ -1,6 +1,7 @@
 import {
-  src_exports
-} from "./chunk-MJ77KX4L.mjs";
+  compat_exports
+} from "./chunk-BJWAMCFH.mjs";
+import "./chunk-NKLIE2OI.mjs";
 import "./chunk-XT74R35S.mjs";
 import "./chunk-EYYZQFOP.mjs";
 import "./chunk-5IKVJGHO.mjs";
@@ -38,33 +39,23 @@ import "./chunk-MY4G7R3I.mjs";
 import "./chunk-5ASRKEB4.mjs";
 import "./chunk-2SLTL4KL.mjs";
 import "./chunk-DPH2KE6O.mjs";
-import "./chunk-236H5JZJ.mjs";
-import "./chunk-3IP4JVLL.mjs";
-import "./chunk-BOOQBJN2.mjs";
-import "./chunk-LKXCOLNY.mjs";
-import "./chunk-CMBC4MXG.mjs";
-import "./chunk-QOJGMVVR.mjs";
 import "./chunk-DDH7K4QM.mjs";
-import "./chunk-6GWEY5EL.mjs";
-import "./chunk-4KYXHZ4R.mjs";
-import "./chunk-UYZKMBDO.mjs";
 import "./chunk-IFNXROZR.mjs";
 import "./chunk-PYEYV7BY.mjs";
 import "./chunk-L7FQX5MN.mjs";
 import "./chunk-Q47NGNXT.mjs";
 import "./chunk-QRSJBBFY.mjs";
 import "./chunk-IDCUZVJL.mjs";
-import "./chunk-NTLX2MPV.mjs";
-import "./chunk-2IXFGSUA.mjs";
+import "./chunk-6GWEY5EL.mjs";
+import "./chunk-4KYXHZ4R.mjs";
 import "./chunk-OP4OAKQJ.mjs";
 import "./chunk-R6QA7PLZ.mjs";
 import "./chunk-NFS7RWWE.mjs";
 import "./chunk-2ZCITDMK.mjs";
-import "./chunk-237HGSZS.mjs";
 import "./chunk-DVK2N4KC.mjs";
 import "./chunk-B4COTK4K.mjs";
-import "./chunk-7B7W36UP.mjs";
-import "./chunk-DN3NOZ3H.mjs";
+import "./chunk-237HGSZS.mjs";
+import "./chunk-UYZKMBDO.mjs";
 import "./chunk-2KNLZB7V.mjs";
 import "./chunk-EHSKB6DF.mjs";
 import "./chunk-GIWAOOFY.mjs";
@@ -73,36 +64,46 @@ import "./chunk-G7UQ5PUR.mjs";
 import "./chunk-TJ4Z5I7M.mjs";
 import "./chunk-ME352XO7.mjs";
 import "./chunk-IQLKIDXF.mjs";
-import "./chunk-XPSOKBRZ.mjs";
-import "./chunk-FVVSE2F2.mjs";
+import "./chunk-NTLX2MPV.mjs";
+import "./chunk-2IXFGSUA.mjs";
 import "./chunk-O6UXZR3U.mjs";
 import "./chunk-XI7KRD2C.mjs";
 import "./chunk-AJKZMN2V.mjs";
 import "./chunk-KPBQ7OUY.mjs";
 import "./chunk-OOKNBU4V.mjs";
 import "./chunk-IJD7FE2Z.mjs";
-import "./chunk-YFN6KOC4.mjs";
-import "./chunk-UY76KTPE.mjs";
+import "./chunk-7B7W36UP.mjs";
+import "./chunk-DN3NOZ3H.mjs";
 import "./chunk-ML727RRJ.mjs";
-import "./chunk-33MSBDC6.mjs";
 import "./chunk-IEA53J7P.mjs";
 import "./chunk-E6E4RZLN.mjs";
 import "./chunk-HM2JT2RX.mjs";
-import "./chunk-CRSKT4WW.mjs";
-import "./chunk-JPUKH67K.mjs";
+import "./chunk-XPSOKBRZ.mjs";
+import "./chunk-FVVSE2F2.mjs";
 import "./chunk-LVWX5B43.mjs";
 import "./chunk-6NVQAHXP.mjs";
 import "./chunk-3EZAFZG3.mjs";
 import "./chunk-OXZCMC5I.mjs";
 import "./chunk-M7SBBYV2.mjs";
 import "./chunk-LJ2C6MVP.mjs";
+import "./chunk-YFN6KOC4.mjs";
+import "./chunk-UY76KTPE.mjs";
+import "./chunk-33MSBDC6.mjs";
+import "./chunk-E6C5EZQA.mjs";
+import "./chunk-DTJJIMKJ.mjs";
+import "./chunk-CRSKT4WW.mjs";
+import "./chunk-JPUKH67K.mjs";
 import "./chunk-F47GLYUU.mjs";
 import "./chunk-DXB7EZUQ.mjs";
 import "./chunk-KIOYQRMQ.mjs";
-import "./chunk-E6C5EZQA.mjs";
-import "./chunk-DTJJIMKJ.mjs";
+import "./chunk-236H5JZJ.mjs";
+import "./chunk-BOOQBJN2.mjs";
+import "./chunk-LKXCOLNY.mjs";
+import "./chunk-CMBC4MXG.mjs";
+import "./chunk-QOJGMVVR.mjs";
+import "./chunk-3IP4JVLL.mjs";
 import "./chunk-24FKGR6U.mjs";
 
 // src/browser.ts
-window._ = src_exports;
+window._ = compat_exports;
 //# sourceMappingURL=browser.mjs.map

package/dist/browser.mjs.map

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

package/dist/{chunk-MJ77KX4L.mjs → chunk-BJWAMCFH.mjs}

@@ -55,9 +55,6 @@ import {
 import {
   flattenObject
 } from "./chunk-XGQWTHW6.mjs";
-import {
-  isPlainObject
-} from "./chunk-MIGAC7F4.mjs";
 import {
   invert
 } from "./chunk-OLX53VEF.mjs";
@@ -88,30 +85,6 @@ import {
 import {
   range
 } from "./chunk-DPH2KE6O.mjs";
-import {
-  debounce
-} from "./chunk-3IP4JVLL.mjs";
-import {
-  negate
-} from "./chunk-BOOQBJN2.mjs";
-import {
-  noop
-} from "./chunk-LKXCOLNY.mjs";
-import {
-  once
-} from "./chunk-CMBC4MXG.mjs";
-import {
-  throttle
-} from "./chunk-QOJGMVVR.mjs";
-import {
-  zipObject
-} from "./chunk-6GWEY5EL.mjs";
-import {
-  zipWith
-} from "./chunk-4KYXHZ4R.mjs";
-import {
-  unzip
-} from "./chunk-UYZKMBDO.mjs";
 import {
   unzipWith
 } from "./chunk-IFNXROZR.mjs";
@@ -131,11 +104,11 @@ import {
   zip
 } from "./chunk-IDCUZVJL.mjs";
 import {
-  takeRightWhile
-} from "./chunk-NTLX2MPV.mjs";
+  zipObject
+} from "./chunk-6GWEY5EL.mjs";
 import {
-  takeWhile
-} from "./chunk-2IXFGSUA.mjs";
+  zipWith
+} from "./chunk-4KYXHZ4R.mjs";
 import {
   toFilled
 } from "./chunk-OP4OAKQJ.mjs";
@@ -148,9 +121,6 @@ import {
 import {
   unionWith
 } from "./chunk-2ZCITDMK.mjs";
-import {
-  uniqWith
-} from "./chunk-237HGSZS.mjs";
 import {
   uniq
 } from "./chunk-DVK2N4KC.mjs";
@@ -158,11 +128,11 @@ import {
   uniqBy
 } from "./chunk-B4COTK4K.mjs";
 import {
-  orderBy
-} from "./chunk-7B7W36UP.mjs";
+  uniqWith
+} from "./chunk-237HGSZS.mjs";
 import {
-  partition
-} from "./chunk-DN3NOZ3H.mjs";
+  unzip
+} from "./chunk-UYZKMBDO.mjs";
 import {
   sample
 } from "./chunk-2KNLZB7V.mjs";
@@ -188,11 +158,11 @@ import {
   takeRight
 } from "./chunk-IQLKIDXF.mjs";
 import {
-  initial
-} from "./chunk-XPSOKBRZ.mjs";
+  takeRightWhile
+} from "./chunk-NTLX2MPV.mjs";
 import {
-  intersection
-} from "./chunk-FVVSE2F2.mjs";
+  takeWhile
+} from "./chunk-2IXFGSUA.mjs";
 import {
   intersectionBy
 } from "./chunk-O6UXZR3U.mjs";
@@ -212,17 +182,14 @@ import {
   minBy
 } from "./chunk-IJD7FE2Z.mjs";
 import {
-  fill
-} from "./chunk-YFN6KOC4.mjs";
+  orderBy
+} from "./chunk-7B7W36UP.mjs";
 import {
-  flatMap
-} from "./chunk-UY76KTPE.mjs";
+  partition
+} from "./chunk-DN3NOZ3H.mjs";
 import {
   flattenDeep
 } from "./chunk-ML727RRJ.mjs";
-import {
-  flatten
-} from "./chunk-33MSBDC6.mjs";
 import {
   forEachRight
 } from "./chunk-IEA53J7P.mjs";
@@ -233,11 +200,11 @@ import {
   head
 } from "./chunk-HM2JT2RX.mjs";
 import {
-  countBy
-} from "./chunk-CRSKT4WW.mjs";
+  initial
+} from "./chunk-XPSOKBRZ.mjs";
 import {
-  difference
-} from "./chunk-JPUKH67K.mjs";
+  intersection
+} from "./chunk-FVVSE2F2.mjs";
 import {
   differenceBy
 } from "./chunk-LVWX5B43.mjs";
@@ -257,48 +224,82 @@ import {
   dropWhile
 } from "./chunk-LJ2C6MVP.mjs";
 import {
-  AbortError
-} from "./chunk-DXB7EZUQ.mjs";
+  fill
+} from "./chunk-YFN6KOC4.mjs";
 import {
-  TimeoutError
-} from "./chunk-KIOYQRMQ.mjs";
+  flatMap
+} from "./chunk-UY76KTPE.mjs";
+import {
+  flatten
+} from "./chunk-33MSBDC6.mjs";
 import {
   chunk
 } from "./chunk-E6C5EZQA.mjs";
 import {
   compact
 } from "./chunk-DTJJIMKJ.mjs";
+import {
+  countBy
+} from "./chunk-CRSKT4WW.mjs";
+import {
+  difference
+} from "./chunk-JPUKH67K.mjs";
+import {
+  AbortError
+} from "./chunk-DXB7EZUQ.mjs";
+import {
+  TimeoutError
+} from "./chunk-KIOYQRMQ.mjs";
+import {
+  negate
+} from "./chunk-BOOQBJN2.mjs";
+import {
+  noop
+} from "./chunk-LKXCOLNY.mjs";
+import {
+  once
+} from "./chunk-CMBC4MXG.mjs";
+import {
+  throttle
+} from "./chunk-QOJGMVVR.mjs";
+import {
+  debounce
+} from "./chunk-3IP4JVLL.mjs";
 import {
   __export
 } from "./chunk-24FKGR6U.mjs";
 
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
+// src/compat/index.ts
+var compat_exports = {};
+__export(compat_exports, {
   AbortError: () => AbortError,
   TimeoutError: () => TimeoutError,
   camelCase: () => camelCase,
   capitalize: () => capitalize,
-  chunk: () => chunk,
+  chunk: () => chunk2,
   clamp: () => clamp,
   clone: () => clone,
   compact: () => compact,
+  concat: () => concat,
   countBy: () => countBy,
   debounce: () => debounce,
   delay: () => delay,
-  difference: () => difference,
+  difference: () => difference2,
   differenceBy: () => differenceBy,
   differenceWith: () => differenceWith,
   drop: () => drop,
   dropRight: () => dropRight,
   dropRightWhile: () => dropRightWhile,
   dropWhile: () => dropWhile,
+  endsWith: () => endsWith,
   fill: () => fill,
+  first: () => head,
   flatMap: () => flatMap,
   flatten: () => flatten,
   flattenDeep: () => flattenDeep,
   flattenObject: () => flattenObject,
   forEachRight: () => forEachRight,
+  get: () => get,
   groupBy: () => groupBy,
   head: () => head,
   inRange: () => inRange,
@@ -318,9 +319,11 @@ __export(src_exports, {
   keyBy: () => keyBy,
   last: () => last,
   lowerCase: () => lowerCase,
+  max: () => max,
   maxBy: () => maxBy,
   mean: () => mean,
   meanBy: () => meanBy,
+  min: () => min,
   minBy: () => minBy,
   negate: () => negate,
   noop: () => noop,
@@ -337,9 +340,11 @@ __export(src_exports, {
   round: () => round,
   sample: () => sample,
   sampleSize: () => sampleSize,
+  set: () => set,
   shuffle: () => shuffle,
   snakeCase: () => snakeCase,
   startCase: () => startCase,
+  startsWith: () => startsWith,
   sum: () => sum,
   sumBy: () => sumBy,
   tail: () => tail,
@@ -364,10 +369,230 @@ __export(src_exports, {
   xorWith: () => xorWith,
   zip: () => zip,
   zipObject: () => zipObject,
+  zipObjectDeep: () => zipObjectDeep,
   zipWith: () => zipWith
 });
 
+// src/compat/array/chunk.ts
+function chunk2(arr, size = 1) {
+  size = Math.max(Math.floor(size), 0);
+  if (size === 0) {
+    return [];
+  }
+  return chunk(arr, size);
+}
+
+// src/compat/array/concat.ts
+function concat(...values) {
+  return flatten(values);
+}
+
+// src/compat/array/difference.ts
+function difference2(arr, ...values) {
+  const arr1 = arr;
+  const arr2 = flatten(values);
+  return difference(arr1, arr2);
+}
+
+// src/compat/_internal/isIndex.ts
+var 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);
+    }
+  }
+}
+
+// src/compat/_internal/toPath.ts
+function toPath(deepKey) {
+  const ESCAPE_REGEXP = /\\(\\)?/g;
+  const PROPERTY_REGEXP = RegExp(
+    // Match anything that isn't a dot or bracket.
+    `[^.[\\]]+|\\[(?:([^"'][^[]*)|(["'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))`,
+    "g"
+  );
+  const result = [];
+  if (deepKey[0] === ".") {
+    result.push("");
+  }
+  let match;
+  let lastIndex = 0;
+  let count = 0;
+  while ((match = PROPERTY_REGEXP.exec(deepKey)) !== null) {
+    let [key, expr, quote, substr] = match;
+    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;
+}
+
+// src/compat/object/set.ts
+function set(obj, path, value) {
+  const resolvedPath = Array.isArray(path) ? path : typeof path === "string" ? toPath(path) : [path];
+  let current = obj;
+  for (let i = 0; i < resolvedPath.length - 1; i++) {
+    const key = resolvedPath[i];
+    const nextKey = resolvedPath[i + 1];
+    if (current[key] == null) {
+      current[key] = isIndex(nextKey) ? [] : {};
+    }
+    current = current[key];
+  }
+  const lastKey = resolvedPath[resolvedPath.length - 1];
+  current[lastKey] = value;
+  return obj;
+}
+
+// src/compat/array/zipObjectDeep.ts
+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;
+}
+
+// src/compat/_internal/isDeepKey.ts
+var IS_PLAIN = /^\w*$/;
+var 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);
+    }
+  }
+}
+
+// src/compat/object/get.ts
+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) {
+    resolvedPath = toPath(path);
+  } else {
+    resolvedPath = [path];
+  }
+  if (resolvedPath.length === 0) {
+    return defaultValue;
+  }
+  let current = object;
+  let index;
+  for (index = 0; index < resolvedPath.length && current != null; index++) {
+    let key = resolvedPath[index];
+    if (Object.is(key.valueOf(), -0)) {
+      key = "-0";
+    }
+    current = current[key];
+  }
+  if (current === null && index === resolvedPath.length) {
+    return current;
+  }
+  return current != null ? current : defaultValue;
+}
+
+// src/compat/predicate/isPlainObject.ts
+function isPlainObject(object) {
+  var _a;
+  if (typeof object !== "object") {
+    return false;
+  }
+  if (object == null) {
+    return false;
+  }
+  if (Object.getPrototypeOf(object) === null) {
+    return true;
+  }
+  if (object.toString() !== "[object Object]") {
+    const tag = object[Symbol.toStringTag];
+    if (tag == null) {
+      return false;
+    }
+    const isTagReadonly = !((_a = Object.getOwnPropertyDescriptor(object, Symbol.toStringTag)) == null ? void 0 : _a.writable);
+    if (isTagReadonly) {
+      return false;
+    }
+    return object.toString() === `[object ${tag}]`;
+  }
+  let proto = object;
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
+  }
+  return Object.getPrototypeOf(object) === proto;
+}
+
+// src/compat/string/startsWith.ts
+var startsWith = (str, target, position = 0) => {
+  return str.startsWith(target, position);
+};
+
+// src/compat/string/endsWith.ts
+var endsWith = (str, target, position = str.length) => {
+  return str.endsWith(target, position);
+};
+
+// src/compat/math/max.ts
+function max(items = []) {
+  let maxElement = items[0];
+  let max2 = void 0;
+  for (const element of items) {
+    if (max2 == null || element > max2) {
+      max2 = element;
+      maxElement = element;
+    }
+  }
+  return maxElement;
+}
+
+// src/compat/math/min.ts
+function min(items = []) {
+  let minElement = items[0];
+  let min2 = void 0;
+  for (const element of items) {
+    if (min2 == null || element < min2) {
+      min2 = element;
+      minElement = element;
+    }
+  }
+  return minElement;
+}
+
 export {
-  src_exports
+  chunk2 as chunk,
+  concat,
+  difference2 as difference,
+  set,
+  zipObjectDeep,
+  get,
+  isPlainObject,
+  startsWith,
+  endsWith,
+  max,
+  min,
+  compat_exports
 };
-//# sourceMappingURL=chunk-MJ77KX4L.mjs.map
+//# sourceMappingURL=chunk-BJWAMCFH.mjs.map

package/dist/chunk-BJWAMCFH.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/_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/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 { 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';\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: number = 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}","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  let count = 0;\n\n  while ((match = PROPERTY_REGEXP.exec(deepKey)) !== null) {\n    let [key, expr, quote, substr] = match;\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    // @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 * 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: number = 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} 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 {\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} 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 {\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}"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,eAAAA;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAAC;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACyBO,SAASC,OAAS,KAAmB,OAAe,GAAU;AACnE,SAAO,KAAK,IAAI,KAAK,MAAM,IAAI,GAAG,CAAC;AAEnC,MAAI,SAAS,GAAG;AACd,WAAO,CAAC;AAAA,EACV;AAEA,SAAO,MAAa,KAAK,IAAI;AAC/B;;;ACJO,SAAS,UAAa,QAAsC;AACjE,SAAO,QAAQ,MAAM;AACvB;;;AC5BO,SAASC,YAAc,QAAsB,QAAkC;AACpF,QAAM,OAAO;AACb,QAAM,OAAO,QAAQ,MAAM;AAE3B,SAAO,WAAkB,MAAM,IAAI;AACrC;;;ACRA,IAAM,sBAAsB;AAErB,SAAS,QAAQ,OAAoB;AAC1C,UAAQ,OAAO,OAAO;AAAA,IACpB,KAAK,UAAU;AACb,aAAO,OAAO,UAAU,KAAK,KAAK,SAAS,KAAK,QAAQ,OAAO;AAAA,IACjE;AAAA,IACA,KAAK,UAAU;AACb,aAAO;AAAA,IACT;AAAA,IACA,KAAK,UAAU;AACb,aAAO,oBAAoB,KAAK,KAAK;AAAA,IACvC;AAAA,EACF;AACF;;;ACGO,SAAS,OAAO,SAA2B;AAChD,QAAM,gBAAgB;AACtB,QAAM,kBAAkB;AAAA;AAAA,IAEtB;AAAA,IAaA;AAAA,EACF;AAEA,QAAM,SAAmB,CAAC;AAE1B,MAAI,QAAQ,CAAC,MAAM,KAAK;AACtB,WAAO,KAAK,EAAE;AAAA,EAChB;AAEA,MAAI;AACJ,MAAI,YAAY;AAChB,MAAI,QAAQ;AAEZ,UAAQ,QAAQ,gBAAgB,KAAK,OAAO,OAAO,MAAM;AACvD,QAAI,CAAC,KAAK,MAAM,OAAO,MAAM,IAAI;AAEjC,QAAI,OAAO;AACT,YAAM,OAAO,QAAQ,eAAe,IAAI;AAAA,IAC1C,WAAW,MAAM;AACf,YAAM;AAAA,IACR;AAEA,WAAO,KAAK,GAAG;AAEf,QAAI,gBAAgB,cAAc,WAAW;AAC3C,sBAAgB;AAAA,IAClB,OAAO;AACL,kBAAY,gBAAgB;AAAA,IAC9B;AAAA,EACF;AAEA,SAAO;AACT;;;ACnCO,SAAS,IAAsB,KAAQ,MAA4C,OAAmB;AAC3G,QAAM,eAAe,MAAM,QAAQ,IAAI,IACnC,OACA,OAAO,SAAS,WACd,OAAO,IAAI,IACX,CAAC,IAAI;AAEX,MAAI,UAAe;AAEnB,WAAS,IAAI,GAAG,IAAI,aAAa,SAAS,GAAG,KAAK;AAChD,UAAM,MAAM,aAAa,CAAC;AAC1B,UAAM,UAAU,aAAa,IAAI,CAAC;AAElC,QAAI,QAAQ,GAAG,KAAK,MAAM;AACxB,cAAQ,GAAG,IAAI,QAAQ,OAAO,IAAI,CAAC,IAAI,CAAC;AAAA,IAC1C;AAEA,cAAU,QAAQ,GAAG;AAAA,EACvB;AAEA,QAAM,UAAU,aAAa,aAAa,SAAS,CAAC;AACpD,UAAQ,OAAO,IAAI;AAEnB,SAAO;AACT;;;ACpBO,SAAS,cAAqD,MAAW,QAA8B;AAC5G,QAAM,SAAS,CAAC;AAChB,QAAM,SAAS,IAAI,MAAM,MAAM;AAE/B,WAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACtC,UAAM,CAAC,KAAK,KAAK,IAAI,OAAO,CAAC;AAE7B,QAAI,OAAO,MAAM;AACf,UAAI,QAAQ,KAAK,KAAK;AAAA,IACxB;AAAA,EACF;AAEA,SAAO;AACT;;;AChDA,IAAM,WAAW;AACjB,IAAM,UAAU;AAmBT,SAAS,UAAU,KAA2B;AACnD,UAAQ,OAAO,KAAK;AAAA,IAClB,KAAK;AAAA,IACL,KAAK,UAAU;AACb,aAAO;AAAA,IACT;AAAA,IACA,KAAK,UAAU;AACb,aAAO,CAAC,SAAS,KAAK,GAAG,KAAK,QAAQ,KAAK,GAAG;AAAA,IAChD;AAAA,EACF;AACF;;;ACyNO,SAAS,IAAI,QAAa,MAA4C,cAAyB;AACpG,MAAI;AAEJ,MAAI,MAAM,QAAQ,IAAI,GAAG;AACvB,mBAAe;AAAA,EACjB,WAAW,OAAO,SAAS,YAAY,UAAU,IAAI,MAAK,iCAAS,UAAS,MAAM;AAChF,mBAAe,OAAO,IAAI;AAAA,EAC5B,OAAO;AACL,mBAAe,CAAC,IAAI;AAAA,EACtB;AAEA,MAAI,aAAa,WAAW,GAAG;AAC7B,WAAO;AAAA,EACT;AAEA,MAAI,UAAU;AACd,MAAI;AAEJ,OAAK,QAAQ,GAAG,QAAQ,aAAa,UAAU,WAAW,MAAM,SAAS;AACvE,QAAI,MAAM,aAAa,KAAK;AAE5B,QAAI,OAAO,GAAG,IAAI,QAAQ,GAAG,EAAE,GAAG;AAChC,YAAM;AAAA,IACR;AAEA,cAAU,QAAQ,GAAG;AAAA,EACvB;AAEA,MAAI,YAAY,QAAQ,UAAU,aAAa,QAAQ;AACrD,WAAO;AAAA,EACT;AAEA,SAAO,4BAAW;AACpB;;;AClQO,SAAS,cAAc,QAA2B;AAtBzD;AAuBE,MAAI,OAAO,WAAW,UAAU;AAC9B,WAAO;AAAA,EACT;AAEA,MAAI,UAAU,MAAM;AAClB,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,eAAe,MAAM,MAAM,MAAM;AAC1C,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,SAAS,MAAM,mBAAmB;AAE3C,UAAM,MAAM,OAAO,OAAO,WAAW;AAErC,QAAI,OAAO,MAAM;AACf,aAAO;AAAA,IACT;AAEA,UAAM,gBAAgB,GAAC,YAAO,yBAAyB,QAAQ,OAAO,WAAW,MAA1D,mBAA6D;AAEpF,QAAI,eAAe;AACjB,aAAO;AAAA,IACT;AAEA,WAAO,OAAO,SAAS,MAAM,WAAW,GAAG;AAAA,EAC7C;AAEA,MAAI,QAAQ;AAEZ,SAAO,OAAO,eAAe,KAAK,MAAM,MAAM;AAC5C,YAAQ,OAAO,eAAe,KAAK;AAAA,EACrC;AAEA,SAAO,OAAO,eAAe,MAAM,MAAM;AAC3C;;;AC1CO,IAAM,aAAa,CAAC,KAAa,QAAgB,WAAmB,MAAe;AACxF,SAAO,IAAI,WAAW,QAAQ,QAAQ;AACxC;;;ACFO,IAAM,WAAW,CAAC,KAAa,QAAgB,WAAmB,IAAI,WAAoB;AAC/F,SAAO,IAAI,SAAS,QAAQ,QAAQ;AACtC;;;ACLO,SAAS,IAAO,QAAsB,CAAC,GAAM;AAClD,MAAI,aAAa,MAAM,CAAC;AACxB,MAAIC,OAAM;AAEV,aAAW,WAAW,OAAO;AAC3B,QAAIA,QAAO,QAAQ,UAAUA,MAAK;AAChC,MAAAA,OAAM;AACN,mBAAa;AAAA,IACf;AAAA,EACF;AAEA,SAAO;AACT;;;ACZO,SAAS,IAAO,QAAsB,CAAC,GAAM;AAClD,MAAI,aAAa,MAAM,CAAC;AACxB,MAAIC,OAAM;AAEV,aAAW,WAAW,OAAO;AAC3B,QAAIA,QAAO,QAAQ,UAAUA,MAAK;AAChC,MAAAA,OAAM;AACN,mBAAa;AAAA,IACf;AAAA,EACF;AAEA,SAAO;AACT;","names":["chunk","difference","chunk","difference","max","min"]}

package/dist/chunk-NKLIE2OI.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-NKLIE2OI.mjs.map

package/dist/chunk-NKLIE2OI.mjs.map

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