es-toolkit 1.13.1 → 1.14.0-dev.397

package/dist/compat/index.js

@@ -1,1436 +1,616 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
+'use strict';
 
-// src/compat/index.ts
-var compat_exports = {};
-__export(compat_exports, {
-  AbortError: () => AbortError,
-  TimeoutError: () => TimeoutError,
-  camelCase: () => camelCase,
-  capitalize: () => capitalize,
-  chunk: () => chunk2,
-  clamp: () => clamp,
-  clone: () => clone,
-  compact: () => compact,
-  concat: () => concat,
-  countBy: () => countBy,
-  debounce: () => debounce,
-  delay: () => delay,
-  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,
-  initial: () => initial,
-  intersection: () => intersection,
-  intersectionBy: () => intersectionBy,
-  intersectionWith: () => intersectionWith,
-  invert: () => invert,
-  isEqual: () => isEqual,
-  isLength: () => isLength,
-  isNil: () => isNil,
-  isNotNil: () => isNotNil,
-  isNull: () => isNull,
-  isPlainObject: () => isPlainObject2,
-  isUndefined: () => isUndefined,
-  kebabCase: () => kebabCase,
-  keyBy: () => keyBy,
-  last: () => last,
-  lowerCase: () => lowerCase,
-  max: () => max,
-  maxBy: () => maxBy,
-  mean: () => mean,
-  meanBy: () => meanBy,
-  min: () => min,
-  minBy: () => minBy,
-  negate: () => negate,
-  noop: () => noop,
-  omit: () => omit,
-  omitBy: () => omitBy,
-  once: () => once,
-  orderBy: () => orderBy,
-  partition: () => partition,
-  pick: () => pick,
-  pickBy: () => pickBy,
-  random: () => random,
-  randomInt: () => randomInt,
-  range: () => range,
-  round: () => round,
-  sample: () => sample,
-  sampleSize: () => sampleSize,
-  set: () => set,
-  shuffle: () => shuffle,
-  snakeCase: () => snakeCase,
-  startCase: () => startCase,
-  startsWith: () => startsWith,
-  sum: () => sum,
-  sumBy: () => sumBy,
-  tail: () => tail,
-  take: () => take,
-  takeRight: () => takeRight,
-  takeRightWhile: () => takeRightWhile,
-  takeWhile: () => takeWhile,
-  throttle: () => throttle,
-  toFilled: () => toFilled,
-  union: () => union,
-  unionBy: () => unionBy,
-  unionWith: () => unionWith,
-  uniq: () => uniq,
-  uniqBy: () => uniqBy,
-  uniqWith: () => uniqWith,
-  unzip: () => unzip,
-  unzipWith: () => unzipWith,
-  withTimeout: () => withTimeout,
-  without: () => without,
-  xor: () => xor,
-  xorBy: () => xorBy,
-  xorWith: () => xorWith,
-  zip: () => zip,
-  zipObject: () => zipObject,
-  zipObjectDeep: () => zipObjectDeep,
-  zipWith: () => zipWith
-});
-module.exports = __toCommonJS(compat_exports);
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-// src/array/chunk.ts
-function chunk(arr, size) {
-  if (!Number.isInteger(size) || size <= 0) {
-    throw new Error("Size must be an integer greater than zero.");
-  }
-  const chunkLength = Math.ceil(arr.length / size);
-  const result = Array(chunkLength);
-  for (let index = 0; index < chunkLength; index++) {
-    const start = index * size;
-    const end = start + size;
-    result[index] = arr.slice(start, end);
-  }
-  return result;
-}
+const initial = require('../_chunk/initial-BTrQy1.js');
+const promise_index = require('../_chunk/index-CwRt_M.js');
+const function_index = require('../function/index.js');
+const math_index = require('../math/index.js');
+const randomInt = require('../_chunk/randomInt-CF7bZK.js');
+const object_index = require('../object/index.js');
+const isFunction = require('../_chunk/isFunction-Cw_tLG.js');
+const isTypedArray$1 = require('../_chunk/isTypedArray-BBEkFl.js');
+const string_index = require('../string/index.js');
 
-// src/array/compact.ts
-function compact(arr) {
-  const result = [];
-  for (const item of arr) {
-    if (item) {
-      result.push(item);
+function chunk(arr, size = 1) {
+    size = Math.max(Math.floor(size), 0);
+    if (size === 0) {
+        return [];
     }
-  }
-  return result;
-}
-
-// src/array/countBy.ts
-function countBy(arr, mapper) {
-  var _a;
-  const result = {};
-  for (const item of arr) {
-    const key = mapper(item);
-    result[key] = ((_a = result[key]) != null ? _a : 0) + 1;
-  }
-  return result;
-}
-
-// src/array/difference.ts
-function difference(firstArr, secondArr) {
-  const secondSet = new Set(secondArr);
-  return firstArr.filter((item) => !secondSet.has(item));
-}
-
-// src/array/differenceBy.ts
-function differenceBy(firstArr, secondArr, mapper) {
-  const mappedSecondSet = new Set(secondArr.map((item) => mapper(item)));
-  return firstArr.filter((item) => {
-    return !mappedSecondSet.has(mapper(item));
-  });
+    return initial.chunk(arr, size);
 }
 
-// src/array/differenceWith.ts
-function differenceWith(firstArr, secondArr, areItemsEqual) {
-  return firstArr.filter((firstItem) => {
-    return secondArr.every((secondItem) => {
-      return !areItemsEqual(firstItem, secondItem);
-    });
-  });
-}
-
-// src/array/drop.ts
-function drop(arr, itemsCount) {
-  itemsCount = Math.max(itemsCount, 0);
-  return arr.slice(itemsCount);
-}
-
-// src/array/dropRight.ts
-function dropRight(arr, itemsCount) {
-  itemsCount = Math.min(-itemsCount, 0);
-  if (itemsCount === 0) {
-    return arr.slice();
-  }
-  return arr.slice(0, itemsCount);
-}
-
-// src/array/dropRightWhile.ts
-function dropRightWhile(arr, canContinueDropping) {
-  for (let i = arr.length - 1; i >= 0; i--) {
-    if (!canContinueDropping(arr[i])) {
-      return arr.slice(0, i + 1);
-    }
-  }
-  return [];
+function concat(...values) {
+    return initial.flatten(values);
 }
 
-// src/array/dropWhile.ts
-function dropWhile(arr, canContinueDropping) {
-  const dropEndIndex = arr.findIndex((item) => !canContinueDropping(item));
-  if (dropEndIndex === -1) {
-    return [];
-  }
-  return arr.slice(dropEndIndex);
+function difference(arr, ...values) {
+    const arr1 = arr;
+    const arr2 = initial.flatten(values);
+    return initial.difference(arr1, arr2);
 }
 
-// src/array/fill.ts
 function fill(array, value, start = 0, end = array.length) {
-  const length = array.length;
-  const finalStart = Math.max(start >= 0 ? start : length + start, 0);
-  const finalEnd = Math.min(end >= 0 ? end : length + end, length);
-  for (let i = finalStart; i < finalEnd; i++) {
-    array[i] = value;
-  }
-  return array;
-}
-
-// src/array/flatten.ts
-function flatten(arr, depth = 1) {
-  const result = [];
-  const flooredDepth = Math.floor(depth);
-  const recursive = (arr2, currentDepth) => {
-    for (const item of arr2) {
-      if (Array.isArray(item) && currentDepth < flooredDepth) {
-        recursive(item, currentDepth + 1);
-      } else {
-        result.push(item);
-      }
+    start = Math.floor(start);
+    end = Math.floor(end);
+    if (!start) {
+        start = 0;
     }
-  };
-  recursive(arr, 0);
-  return result;
-}
-
-// src/array/flatMap.ts
-function flatMap(arr, iteratee, depth = 1) {
-  return flatten(arr.map((item) => iteratee(item)), depth);
-}
-
-// src/array/flattenDeep.ts
-function flattenDeep(arr) {
-  return flatten(arr, Infinity);
-}
-
-// src/array/forEachRight.ts
-function forEachRight(arr, callback) {
-  for (let i = arr.length - 1; i >= 0; i--) {
-    const element = arr[i];
-    callback(element, i, arr);
-  }
-}
-
-// src/array/groupBy.ts
-function groupBy(arr, getKeyFromItem) {
-  const result = {};
-  for (const item of arr) {
-    const key = getKeyFromItem(item);
-    if (result[key] == null) {
-      result[key] = [];
+    if (!end) {
+        end = 0;
     }
-    result[key].push(item);
-  }
-  return result;
-}
-
-// src/array/intersection.ts
-function intersection(firstArr, secondArr) {
-  const secondSet = new Set(secondArr);
-  return firstArr.filter((item) => {
-    return secondSet.has(item);
-  });
-}
-
-// src/array/intersectionBy.ts
-function intersectionBy(firstArr, secondArr, mapper) {
-  const mappedSecondSet = new Set(secondArr.map(mapper));
-  return firstArr.filter((item) => mappedSecondSet.has(mapper(item)));
-}
-
-// src/array/intersectionWith.ts
-function intersectionWith(firstArr, secondArr, areItemsEqual) {
-  return firstArr.filter((firstItem) => {
-    return secondArr.some((secondItem) => {
-      return areItemsEqual(firstItem, secondItem);
-    });
-  });
+    return initial.fill(array, value, start, end);
 }
 
-// src/array/keyBy.ts
-function keyBy(arr, getKeyFromItem) {
-  const result = {};
-  for (const item of arr) {
-    const key = getKeyFromItem(item);
-    result[key] = item;
-  }
-  return result;
-}
-
-// src/array/maxBy.ts
-function maxBy(items, getValue) {
-  let maxElement = items[0];
-  let max2 = -Infinity;
-  for (const element of items) {
-    const value = getValue(element);
-    if (value > max2) {
-      max2 = value;
-      maxElement = element;
-    }
-  }
-  return maxElement;
-}
-
-// src/array/minBy.ts
-function minBy(items, getValue) {
-  let minElement = items[0];
-  let min2 = Infinity;
-  for (const element of items) {
-    const value = getValue(element);
-    if (value < min2) {
-      min2 = value;
-      minElement = element;
-    }
-  }
-  return minElement;
-}
-
-// src/array/orderBy.ts
-function orderBy(collection, keys, orders) {
-  const compareValues = (a, b, order) => {
-    if (a < b) {
-      return order === "asc" ? -1 : 1;
-    }
-    if (a > b) {
-      return order === "asc" ? 1 : -1;
-    }
-    return 0;
-  };
-  const effectiveOrders = keys.map((_, index) => orders[index] || orders[orders.length - 1]);
-  return collection.slice().sort((a, b) => {
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i];
-      const order = effectiveOrders[i];
-      const result = compareValues(a[key], b[key], order);
-      if (result !== 0) {
+function flatten(value, depth = 1) {
+    const result = [];
+    const flooredDepth = Math.floor(depth);
+    if (!Array.isArray(value)) {
         return result;
-      }
     }
-    return 0;
-  });
-}
-
-// src/array/partition.ts
-function partition(arr, isInTruthy) {
-  const truthy = [];
-  const falsy = [];
-  for (const item of arr) {
-    if (isInTruthy(item)) {
-      truthy.push(item);
-    } else {
-      falsy.push(item);
-    }
-  }
-  return [truthy, falsy];
-}
-
-// src/array/sample.ts
-function sample(arr) {
-  const randomIndex = Math.floor(Math.random() * arr.length);
-  return arr[randomIndex];
-}
-
-// src/math/random.ts
-function random(minimum, maximum) {
-  if (maximum == null) {
-    maximum = minimum;
-    minimum = 0;
-  }
-  if (minimum >= maximum) {
-    throw new Error("Invalid input: The maximum value must be greater than the minimum value.");
-  }
-  return Math.random() * (maximum - minimum) + minimum;
-}
-
-// src/math/randomInt.ts
-function randomInt(minimum, maximum) {
-  return Math.floor(random(minimum, maximum));
-}
-
-// src/array/sampleSize.ts
-function sampleSize(array, size) {
-  if (size > array.length) {
-    throw new Error("Size must be less than or equal to the length of array.");
-  }
-  const result = new Array(size);
-  const selected = /* @__PURE__ */ new Set();
-  for (let step = array.length - size, resultIndex = 0; step < array.length; step++, resultIndex++) {
-    let index = randomInt(0, step + 1);
-    if (selected.has(index)) {
-      index = step;
-    }
-    selected.add(index);
-    result[resultIndex] = array[index];
-  }
-  return result;
-}
-
-// src/array/shuffle.ts
-function shuffle(arr) {
-  const result = arr.slice();
-  for (let i = result.length - 1; i >= 1; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
-    [result[i], result[j]] = [result[j], result[i]];
-  }
-  return result;
+    const recursive = (arr, currentDepth) => {
+        for (const item of arr) {
+            if (currentDepth < flooredDepth &&
+                (Array.isArray(item) ||
+                    Boolean(item?.[Symbol.isConcatSpreadable]) ||
+                    (item !== null && typeof item === 'object' && Object.prototype.toString.call(item) === '[object Arguments]'))) {
+                if (Array.isArray(item)) {
+                    recursive(item, currentDepth + 1);
+                }
+                else {
+                    recursive(Array.from(item), currentDepth + 1);
+                }
+            }
+            else {
+                result.push(item);
+            }
+        }
+    };
+    recursive(value, 0);
+    return result;
 }
 
-// src/array/take.ts
-function take(arr, count) {
-  return arr.slice(0, count);
+function flattenDeep(value) {
+    return flatten(value, Infinity);
 }
 
-// src/array/takeRight.ts
-function takeRight(arr, count) {
-  if (count === 0) {
-    return [];
-  }
-  return arr.slice(-count);
+function flattenDepth(value, depth = 1) {
+    return flatten(value, depth);
 }
 
-// src/array/takeRightWhile.ts
-function takeRightWhile(arr, shouldContinueTaking) {
-  for (let i = arr.length - 1; i >= 0; i--) {
-    if (!shouldContinueTaking(arr[i])) {
-      return arr.slice(i + 1);
+function size(target) {
+    if (isFunction.isNil(target)) {
+        return 0;
     }
-  }
-  return arr.slice();
-}
-
-// src/array/takeWhile.ts
-function takeWhile(arr, shouldContinueTaking) {
-  const result = [];
-  for (const item of arr) {
-    if (!shouldContinueTaking(item)) {
-      break;
+    if (target instanceof Map || target instanceof Set) {
+        return target.size;
     }
-    result.push(item);
-  }
-  return result;
+    return Object.keys(target).length;
 }
 
-// src/array/uniq.ts
-function uniq(arr) {
-  return Array.from(new Set(arr));
-}
-
-// src/array/union.ts
-function union(arr1, arr2) {
-  return uniq(arr1.concat(arr2));
-}
-
-// src/array/unionBy.ts
-function unionBy(arr1, arr2, mapper) {
-  const map = /* @__PURE__ */ new Map();
-  for (const item of [...arr1, ...arr2]) {
-    const key = mapper(item);
-    if (!map.has(key)) {
-      map.set(key, item);
+const IS_UNSIGNED_INTEGER = /^(?:0|[1-9]\d*)$/;
+function isIndex(value) {
+    switch (typeof value) {
+        case 'number': {
+            return Number.isInteger(value) && value >= 0 && value < Number.MAX_SAFE_INTEGER;
+        }
+        case 'symbol': {
+            return false;
+        }
+        case 'string': {
+            return IS_UNSIGNED_INTEGER.test(value);
+        }
     }
-  }
-  return Array.from(map.values());
 }
 
-// src/array/uniqWith.ts
-function uniqWith(arr, areItemsEqual) {
-  const result = [];
-  for (const item of arr) {
-    const isUniq = result.every((v) => !areItemsEqual(v, item));
-    if (isUniq) {
-      result.push(item);
+function toPath(deepKey) {
+    const ESCAPE_REGEXP = /\\(\\)?/g;
+    const PROPERTY_REGEXP = RegExp('[^.[\\]]+' +
+        '|' +
+        '\\[(?:' +
+        '([^"\'][^[]*)' +
+        '|' +
+        '(["\'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2' +
+        ')\\]' +
+        '|' +
+        '(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))', 'g');
+    const result = [];
+    if (deepKey[0] === '.') {
+        result.push('');
+    }
+    let match;
+    let lastIndex = 0;
+    while ((match = PROPERTY_REGEXP.exec(deepKey)) !== null) {
+        let key = match[0];
+        const expr = match[1];
+        const quote = match[2];
+        const substr = match[3];
+        if (quote) {
+            key = substr.replace(ESCAPE_REGEXP, '$1');
+        }
+        else if (expr) {
+            key = expr;
+        }
+        result.push(key);
+        if (PROPERTY_REGEXP.lastIndex === lastIndex) {
+            PROPERTY_REGEXP.lastIndex++;
+        }
+        else {
+            lastIndex = PROPERTY_REGEXP.lastIndex;
+        }
     }
-  }
-  return result;
+    return result;
 }
 
-// src/array/unionWith.ts
-function unionWith(arr1, arr2, areItemsEqual) {
-  return uniqWith(arr1.concat(arr2), areItemsEqual);
+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/array/uniqBy.ts
-function uniqBy(arr, mapper) {
-  const map = /* @__PURE__ */ new Map();
-  for (const item of arr) {
-    const key = mapper(item);
-    if (!map.has(key)) {
-      map.set(key, item);
+function zipObjectDeep(keys, values) {
+    const result = {};
+    const zipped = initial.zip(keys, values);
+    for (let i = 0; i < zipped.length; i++) {
+        const [key, value] = zipped[i];
+        if (key != null) {
+            set(result, key, value);
+        }
     }
-  }
-  return Array.from(map.values());
+    return result;
 }
 
-// src/array/unzip.ts
-function unzip(zipped) {
-  let maxLen = 0;
-  for (let i = 0; i < zipped.length; i++) {
-    if (zipped[i].length > maxLen) {
-      maxLen = zipped[i].length;
-    }
-  }
-  const result = new Array(maxLen);
-  for (let i = 0; i < maxLen; i++) {
-    result[i] = new Array(zipped.length);
-    for (let j = 0; j < zipped.length; j++) {
-      result[i][j] = zipped[j][i];
-    }
-  }
-  return result;
+function ary(func, n = func.length, guard) {
+    if (guard) {
+        n = func.length;
+    }
+    if (Number.isNaN(n) || n < 0) {
+        n = 0;
+    }
+    return function_index.ary(func, n);
+}
+
+function bind(func, thisObj, ...partialArgs) {
+    const binded = function (...providedArgs) {
+        const args = [];
+        let startIndex = 0;
+        for (let i = 0; i < partialArgs.length; i++) {
+            const arg = partialArgs[i];
+            if (arg === bind.placeholder) {
+                args.push(providedArgs[startIndex++]);
+            }
+            else {
+                args.push(arg);
+            }
+        }
+        for (let i = startIndex; i < providedArgs.length; i++) {
+            args.push(providedArgs[i]);
+        }
+        if (this instanceof binded) {
+            return new func(...args);
+        }
+        return func.apply(thisObj, args);
+    };
+    return binded;
 }
+const bindPlaceholder = Symbol('bind.placeholder');
+bind.placeholder = bindPlaceholder;
 
-// src/array/unzipWith.ts
-function unzipWith(target, iteratee) {
-  const maxLength = Math.max(...target.map((innerArray) => innerArray.length));
-  const result = new Array(maxLength);
-  for (let i = 0; i < maxLength; i++) {
-    const group = new Array(target.length);
-    for (let j = 0; j < target.length; j++) {
-      group[j] = target[j][i];
+const IS_PLAIN = /^\w*$/;
+const IS_DEEP = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
+function isDeepKey(key) {
+    switch (typeof key) {
+        case 'number':
+        case 'symbol': {
+            return false;
+        }
+        case 'string': {
+            return !IS_PLAIN.test(key) && IS_DEEP.test(key);
+        }
     }
-    result[i] = iteratee(...group);
-  }
-  return result;
-}
-
-// src/array/xor.ts
-function xor(arr1, arr2) {
-  return difference(union(arr1, arr2), intersection(arr1, arr2));
-}
-
-// src/array/xorBy.ts
-function xorBy(arr1, arr2, mapper) {
-  const union2 = unionBy(arr1, arr2, mapper);
-  const intersection2 = intersectionBy(arr1, arr2, mapper);
-  return differenceBy(union2, intersection2, mapper);
 }
 
-// src/array/xorWith.ts
-function xorWith(arr1, arr2, areElementsEqual) {
-  const union2 = unionWith(arr1, arr2, areElementsEqual);
-  const intersection2 = intersectionWith(arr1, arr2, areElementsEqual);
-  return differenceWith(union2, intersection2, areElementsEqual);
-}
-
-// src/array/zip.ts
-function zip(...arrs) {
-  const result = [];
-  const maxIndex = Math.max(...arrs.map((x) => x.length));
-  for (let i = 0; i < maxIndex; i++) {
-    const element = [];
-    for (const arr of arrs) {
-      element.push(arr[i]);
+function get(object, path, defaultValue) {
+    let resolvedPath;
+    if (Array.isArray(path)) {
+        resolvedPath = path;
     }
-    result.push(element);
-  }
-  return result;
-}
-
-// src/array/zipObject.ts
-function zipObject(keys, values) {
-  const result = {};
-  for (let i = 0; i < keys.length; i++) {
-    result[keys[i]] = values[i];
-  }
-  return result;
-}
-
-// src/array/zipWith.ts
-function zipWith(arr1, ...rest) {
-  const arrs = [arr1, ...rest.slice(0, -1)];
-  const combine = rest[rest.length - 1];
-  const result = [];
-  const maxIndex = Math.max(...arrs.map((arr) => arr.length));
-  for (let i = 0; i < maxIndex; i++) {
-    const elements = arrs.map((arr) => arr[i]);
-    result.push(combine(...elements));
-  }
-  return result;
-}
-
-// src/array/without.ts
-function without(array, ...values) {
-  const valuesSet = new Set(values);
-  return array.filter((item) => !valuesSet.has(item));
-}
-
-// src/array/head.ts
-function head(arr) {
-  return arr[0];
-}
-
-// src/array/tail.ts
-function tail(arr) {
-  const len = arr.length;
-  if (len <= 1) {
-    return [];
-  }
-  const result = new Array(len - 1);
-  for (let i = 1; i < len; i++) {
-    result[i - 1] = arr[i];
-  }
-  return result;
-}
-
-// src/array/toFilled.ts
-function toFilled(arr, value, start = 0, end = arr.length) {
-  const length = arr.length;
-  const finalStart = Math.max(start >= 0 ? start : length + start, 0);
-  const finalEnd = Math.min(end >= 0 ? end : length + end, length);
-  const newArr = arr.slice();
-  for (let i = finalStart; i < finalEnd; i++) {
-    newArr[i] = value;
-  }
-  return newArr;
-}
-
-// src/array/last.ts
-function last(arr) {
-  return arr[arr.length - 1];
-}
-
-// src/array/initial.ts
-function initial(arr) {
-  if (arr.length <= 1) {
-    return [];
-  }
-  return arr.slice(0, -1);
-}
-
-// src/error/AbortError.ts
-var AbortError = class extends Error {
-  constructor(message = "The operation was aborted") {
-    super(message);
-    this.name = "AbortError";
-  }
-};
-
-// src/error/TimeoutError.ts
-var TimeoutError = class extends Error {
-  constructor(message = "The operation was timed out") {
-    super(message);
-    this.name = "TimeoutError";
-  }
-};
-
-// src/function/debounce.ts
-function debounce(func, debounceMs, { signal } = {}) {
-  let timeoutId = null;
-  const debounced = function(...args) {
-    if (timeoutId !== null) {
-      clearTimeout(timeoutId);
+    else if (typeof path === 'string' && isDeepKey(path) && object?.[path] == null) {
+        resolvedPath = toPath(path);
     }
-    if (signal == null ? void 0 : signal.aborted) {
-      return;
+    else {
+        resolvedPath = [path];
     }
-    timeoutId = setTimeout(() => {
-      func(...args);
-      timeoutId = null;
-    }, debounceMs);
-  };
-  const onAbort = function() {
-    debounced.cancel();
-  };
-  debounced.cancel = function() {
-    if (timeoutId !== null) {
-      clearTimeout(timeoutId);
-      timeoutId = null;
+    if (resolvedPath.length === 0) {
+        return defaultValue;
     }
-  };
-  signal == null ? void 0 : signal.addEventListener("abort", onAbort, { once: true });
-  return debounced;
-}
-
-// src/function/noop.ts
-function noop() {
-}
-
-// src/function/once.ts
-function once(func) {
-  let called = false;
-  let cache;
-  return function() {
-    if (called) {
-      return cache;
+    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];
     }
-    const result = func();
-    called = true;
-    cache = result;
-    return result;
-  };
-}
-
-// src/function/throttle.ts
-function throttle(func, throttleMs) {
-  let lastCallTime;
-  const throttledFunction = function(...args) {
-    const now = Date.now();
-    if (lastCallTime == null || now - lastCallTime >= throttleMs) {
-      lastCallTime = now;
-      func(...args);
+    if (current === null && index === resolvedPath.length) {
+        return current;
     }
-  };
-  return throttledFunction;
-}
-
-// src/function/negate.ts
-function negate(func) {
-  return (...args) => !func(...args);
-}
-
-// src/math/clamp.ts
-function clamp(value, bound1, bound2) {
-  if (bound2 == null) {
-    return Math.min(value, bound1);
-  }
-  return Math.min(Math.max(value, bound1), bound2);
-}
-
-// src/math/inRange.ts
-function inRange(value, minimum, maximum) {
-  if (maximum == null) {
-    maximum = minimum;
-    minimum = 0;
-  }
-  if (minimum >= maximum) {
-    throw new Error("The maximum value must be greater than the minimum value.");
-  }
-  return minimum <= value && value < maximum;
-}
-
-// src/math/sum.ts
-function sum(nums) {
-  let result = 0;
-  for (let i = 0; i < nums.length; i++) {
-    result += nums[i];
-  }
-  return result;
-}
-
-// src/math/mean.ts
-function mean(nums) {
-  return sum(nums) / nums.length;
-}
-
-// src/math/meanBy.ts
-function meanBy(items, getValue) {
-  const nums = items.map((x) => getValue(x));
-  return mean(nums);
-}
-
-// src/math/round.ts
-function round(value, precision = 0) {
-  if (!Number.isInteger(precision)) {
-    throw new Error("Precision must be an integer.");
-  }
-  const multiplier = Math.pow(10, precision);
-  return Math.round(value * multiplier) / multiplier;
-}
-
-// src/math/sumBy.ts
-function sumBy(items, getValue) {
-  const nums = items.map((x) => getValue(x));
-  return sum(nums);
-}
-
-// src/math/range.ts
-function range(start, end, step) {
-  if (end == null) {
-    end = start;
-    start = 0;
-  }
-  if (step == null) {
-    step = 1;
-  }
-  if (!Number.isInteger(step) || step === 0) {
-    throw new Error(`The step value must be a non-zero integer.`);
-  }
-  const length = Math.max(Math.ceil((end - start) / step), 0);
-  const result = new Array(length);
-  for (let i = 0; i < length; i++) {
-    result[i] = start + i * step;
-  }
-  return result;
-}
-
-// src/object/omit.ts
-function omit(obj, keys) {
-  const result = __spreadValues({}, obj);
-  for (const key of keys) {
-    delete result[key];
-  }
-  return result;
+    return current ?? defaultValue;
 }
 
-// src/object/omitBy.ts
-function omitBy(obj, shouldOmit) {
-  const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    if (shouldOmit(value, key)) {
-      continue;
-    }
-    result[key] = value;
-  }
-  return result;
+function property(path) {
+    return function (object) {
+        return get(object, path);
+    };
 }
 
-// src/object/pick.ts
-function pick(obj, keys) {
-  const result = {};
-  for (const key of keys) {
-    result[key] = obj[key];
-  }
-  return result;
+function identity(x) {
+    return x;
 }
 
-// src/object/pickBy.ts
-function pickBy(obj, shouldPick) {
-  const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    if (!shouldPick(value, key)) {
-      continue;
+function mapKeys(object, getNewKey) {
+    getNewKey = getNewKey ?? identity;
+    switch (typeof getNewKey) {
+        case 'string':
+        case 'symbol':
+        case 'number':
+        case 'object': {
+            return object_index.mapKeys(object, property(getNewKey));
+        }
+        case 'function': {
+            return object_index.mapKeys(object, getNewKey);
+        }
     }
-    result[key] = value;
-  }
-  return result;
-}
-
-// src/object/invert.ts
-function invert(obj) {
-  const result = {};
-  const keys = Object.keys(obj);
-  for (let i = 0; i < keys.length; i++) {
-    const key = keys[i];
-    const value = obj[key];
-    result[value] = key;
-  }
-  return result;
 }
 
-// src/object/clone.ts
-function clone(obj) {
-  if (isPrimitive(obj)) {
-    return obj;
-  }
-  if (Array.isArray(obj)) {
-    return obj.slice();
-  }
-  if (obj instanceof Date) {
-    return new Date(obj.getTime());
-  }
-  if (obj instanceof RegExp) {
-    return new RegExp(obj.source, obj.flags);
-  }
-  if (obj instanceof Map) {
-    const result = /* @__PURE__ */ new Map();
-    for (const [key, value] of obj) {
-      result.set(key, value);
-    }
-    return result;
-  }
-  if (obj instanceof Set) {
-    const result = /* @__PURE__ */ new Set();
-    for (const value of obj) {
-      result.add(value);
+function mapValues(object, getNewValue) {
+    getNewValue = getNewValue ?? identity;
+    switch (typeof getNewValue) {
+        case 'string':
+        case 'symbol':
+        case 'number':
+        case 'object': {
+            return object_index.mapValues(object, property(getNewValue));
+        }
+        case 'function': {
+            return object_index.mapValues(object, getNewValue);
+        }
     }
-    return result;
-  }
-  if (typeof obj === "object") {
-    return Object.assign({}, obj);
-  }
-  return obj;
-}
-function isPrimitive(value) {
-  return value == null || typeof value !== "object" && typeof value !== "function";
 }
 
-// src/predicate/isPlainObject.ts
 function isPlainObject(object) {
-  if (typeof object !== "object") {
-    return false;
-  }
-  if (object == null) {
-    return false;
-  }
-  if (Object.getPrototypeOf(object) === null) {
-    return true;
-  }
-  if (object.toString() !== "[object Object]") {
-    return false;
-  }
-  let proto = object;
-  while (Object.getPrototypeOf(proto) !== null) {
-    proto = Object.getPrototypeOf(proto);
-  }
-  return Object.getPrototypeOf(object) === proto;
-}
-
-// src/object/flattenObject.ts
-function flattenObject(object) {
-  return flattenObjectImpl(object);
-}
-function flattenObjectImpl(object, prefix = "") {
-  const result = {};
-  const keys = Object.keys(object);
-  for (let i = 0; i < keys.length; i++) {
-    const key = keys[i];
-    const value = object[key];
-    const prefixedKey = prefix ? `${prefix}.${key}` : key;
-    if (isPlainObject(value) && Object.keys(value).length > 0) {
-      Object.assign(result, flattenObjectImpl(value, prefixedKey));
-      continue;
+    if (typeof object !== 'object') {
+        return false;
     }
-    if (Array.isArray(value)) {
-      for (let index = 0; index < value.length; index++) {
-        result[`${prefixedKey}.${index}`] = value[index];
-      }
-      continue;
+    if (object == null) {
+        return false;
     }
-    result[prefixedKey] = value;
-  }
-  return result;
-}
-
-// src/predicate/isEqual.ts
-function isEqual(a, b) {
-  if (Object.is(a, b)) {
-    return true;
-  }
-  if (a instanceof Date && b instanceof Date) {
-    return a.getTime() === b.getTime();
-  }
-  if (a instanceof RegExp && b instanceof RegExp) {
-    return a.source === b.source && a.flags === b.flags;
-  }
-  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) {
-    return false;
-  }
-  const aKeys = Object.keys(a);
-  const bKeys = Object.keys(b);
-  if (aKeys.length !== bKeys.length) {
-    return false;
-  }
-  if (union(aKeys, bKeys).length !== aKeys.length) {
-    return false;
-  }
-  for (let i = 0; i < aKeys.length; i++) {
-    const propKey = aKeys[i];
-    const aProp = a[propKey];
-    const bProp = b[propKey];
-    if (!isEqual(aProp, bProp)) {
-      return false;
+    if (Object.getPrototypeOf(object) === null) {
+        return true;
     }
-  }
-  return true;
-}
-
-// src/predicate/isNil.ts
-function isNil(x) {
-  return x == null;
-}
-
-// src/predicate/isNotNil.ts
-function isNotNil(x) {
-  return x !== null && x !== void 0;
-}
-
-// src/predicate/isNull.ts
-function isNull(x) {
-  return x === null;
-}
-
-// src/predicate/isUndefined.ts
-function isUndefined(x) {
-  return x === void 0;
-}
-
-// src/predicate/isLength.ts
-function isLength(value) {
-  return typeof value === "number" && value > -1 && value % 1 === 0 && value <= Number.MAX_SAFE_INTEGER;
-}
-
-// src/promise/delay.ts
-function delay(ms, { signal } = {}) {
-  return new Promise((resolve, reject) => {
-    const abortError = () => {
-      reject(new AbortError());
-    };
-    const abortHandler = () => {
-      clearTimeout(timeoutId);
-      abortError();
-    };
-    if (signal == null ? void 0 : signal.aborted) {
-      return abortError();
+    if (object.toString() !== '[object Object]') {
+        const tag = object[Symbol.toStringTag];
+        if (tag == null) {
+            return false;
+        }
+        const isTagReadonly = !Object.getOwnPropertyDescriptor(object, Symbol.toStringTag)?.writable;
+        if (isTagReadonly) {
+            return false;
+        }
+        return object.toString() === `[object ${tag}]`;
     }
-    const timeoutId = setTimeout(resolve, ms);
-    signal == null ? void 0 : signal.addEventListener("abort", abortHandler, { once: true });
-  });
+    let proto = object;
+    while (Object.getPrototypeOf(proto) !== null) {
+        proto = Object.getPrototypeOf(proto);
+    }
+    return Object.getPrototypeOf(object) === proto;
 }
 
-// src/promise/timeout.ts
-function timeout(ms) {
-  return __async(this, null, function* () {
-    yield delay(ms);
-    throw new TimeoutError();
-  });
+function isArray(value) {
+    return Array.isArray(value);
 }
 
-// src/promise/withTimeout.ts
-function withTimeout(run, ms) {
-  return __async(this, null, function* () {
-    return Promise.race([run(), timeout(ms)]);
-  });
+function isArguments(value) {
+    return value !== null && typeof value === 'object' && isFunction.getTag(value) === '[object Arguments]';
 }
 
-// src/string/capitalize.ts
-var capitalize = (str) => {
-  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
-};
-
-// 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 : []);
+function isArrayLike(value) {
+    return value != null && typeof value !== "function" &&
+        isFunction.isLength(value.length);
 }
 
-// src/string/camelCase.ts
-function camelCase(str) {
-  const words = getWords(str);
-  if (words.length === 0) {
-    return "";
-  }
-  const [first, ...rest] = words;
-  return `${first.toLowerCase()}${rest.map((word) => capitalize(word)).join("")}`;
+function isObjectLike(value) {
+    return typeof value === 'object' && value !== null;
 }
 
-// src/string/snakeCase.ts
-var snakeCase = (str) => {
-  const words = getWords(str);
-  return words.map((word) => word.toLowerCase()).join("_");
-};
-
-// src/string/kebabCase.ts
-var kebabCase = (str) => {
-  const words = getWords(str);
-  return words.map((word) => word.toLowerCase()).join("-");
-};
-
-// src/string/lowerCase.ts
-var lowerCase = (str) => {
-  const words = getWords(str);
-  return words.map((word) => word.toLowerCase()).join(" ");
-};
-
-// src/string/startCase.ts
-function startCase(str) {
-  const words = getWords(str.trim());
-  let result = "";
-  for (const word of words) {
-    if (result) {
-      result += " ";
+function isBoolean(x) {
+    if (x === true || x === false) {
+        return true;
     }
-    if (word === word.toUpperCase()) {
-      result += word;
-    } else {
-      result += word[0].toUpperCase() + word.slice(1).toLowerCase();
+    if (typeof x === 'object' && x != null && isFunction.getTag(x) === '[object Boolean]') {
+        return true;
     }
-  }
-  return result;
-}
-
-// 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);
+    return false;
 }
 
-// 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);
-    }
-  }
+function isTypedArray(x) {
+    return isTypedArray$1.isTypedArray(x);
 }
 
-// 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;
+function isArrayMatch(target, source) {
+    if (source.length === 0) {
+        return true;
     }
-    result.push(key);
-    if (PROPERTY_REGEXP.lastIndex === lastIndex) {
-      PROPERTY_REGEXP.lastIndex++;
-    } else {
-      lastIndex = PROPERTY_REGEXP.lastIndex;
+    if (!Array.isArray(target)) {
+        return false;
     }
-  }
-  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) ? [] : {};
+    const countedIndex = new Set();
+    for (let i = 0; i < source.length; i++) {
+        const sourceItem = source[i];
+        const index = target.findIndex((targetItem, index) => {
+            return isMatch(targetItem, sourceItem) && !countedIndex.has(index);
+        });
+        if (index === -1) {
+            return false;
+        }
+        countedIndex.add(index);
     }
-    current = current[key];
-  }
-  const lastKey = resolvedPath[resolvedPath.length - 1];
-  current[lastKey] = value;
-  return obj;
+    return true;
 }
 
-// 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);
+function isMapMatch(target, source) {
+    if (source.size === 0) {
+        return true;
     }
-  }
-  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;
+    if (!(target instanceof Map)) {
+        return false;
     }
-    case "string": {
-      return !IS_PLAIN.test(key) && IS_DEEP.test(key);
+    for (const [key, value] of source.entries()) {
+        if (!isMatch(target.get(key), value)) {
+            return false;
+        }
     }
-  }
-}
-
-// 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;
+    return true;
 }
 
-// src/compat/predicate/isPlainObject.ts
-function isPlainObject2(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;
+function isSetMatch(target, source) {
+    if (source.size === 0) {
+        return true;
+    }
+    if (!(target instanceof Set)) {
+        return false;
+    }
+    return isArrayMatch([...target], [...source]);
+}
+
+function isMatch(target, source) {
+    if (source === target) {
+        return true;
+    }
+    switch (typeof source) {
+        case 'object': {
+            if (source == null) {
+                return true;
+            }
+            const keys = Object.keys(source);
+            if (target == null) {
+                if (keys.length === 0) {
+                    return true;
+                }
+                return false;
+            }
+            if (Array.isArray(source)) {
+                return isArrayMatch(target, source);
+            }
+            if (source instanceof Map) {
+                return isMapMatch(target, source);
+            }
+            if (source instanceof Set) {
+                return isSetMatch(target, source);
+            }
+            for (let i = 0; i < keys.length; i++) {
+                const key = keys[i];
+                if (!isTypedArray$1.isPrimitive(target) && !(key in target)) {
+                    return false;
+                }
+                if (source[key] === undefined && target[key] !== undefined) {
+                    return false;
+                }
+                if (!isMatch(target[key], source[key])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        case 'function': {
+            if (Object.keys(source).length > 0) {
+                return isMatch(target, { ...source });
+            }
+            return false;
+        }
+        default: {
+            return !source;
+        }
+    }
+}
+
+function matches(source) {
+    source = object_index.cloneDeep(source);
+    return (target) => {
+        return isMatch(target, source);
+    };
 }
 
-// src/compat/string/startsWith.ts
-var startsWith = (str, target, position = 0) => {
-  return str.startsWith(target, position);
+const 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);
+const endsWith = (str, target, position = str.length) => {
+    return str.endsWith(target, position);
 };
 
-// src/compat/math/max.ts
+function padStart(str, length = 0, chars = ' ') {
+    return str.padStart(length, chars);
+}
+
 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;
+    let maxElement = items[0];
+    let max = undefined;
+    for (const element of items) {
+        if (max == null || element > max) {
+            max = element;
+            maxElement = element;
+        }
     }
-  }
-  return maxElement;
+    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;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AbortError,
-  TimeoutError,
-  camelCase,
-  capitalize,
-  chunk,
-  clamp,
-  clone,
-  compact,
-  concat,
-  countBy,
-  debounce,
-  delay,
-  difference,
-  differenceBy,
-  differenceWith,
-  drop,
-  dropRight,
-  dropRightWhile,
-  dropWhile,
-  endsWith,
-  fill,
-  first,
-  flatMap,
-  flatten,
-  flattenDeep,
-  flattenObject,
-  forEachRight,
-  get,
-  groupBy,
-  head,
-  inRange,
-  initial,
-  intersection,
-  intersectionBy,
-  intersectionWith,
-  invert,
-  isEqual,
-  isLength,
-  isNil,
-  isNotNil,
-  isNull,
-  isPlainObject,
-  isUndefined,
-  kebabCase,
-  keyBy,
-  last,
-  lowerCase,
-  max,
-  maxBy,
-  mean,
-  meanBy,
-  min,
-  minBy,
-  negate,
-  noop,
-  omit,
-  omitBy,
-  once,
-  orderBy,
-  partition,
-  pick,
-  pickBy,
-  random,
-  randomInt,
-  range,
-  round,
-  sample,
-  sampleSize,
-  set,
-  shuffle,
-  snakeCase,
-  startCase,
-  startsWith,
-  sum,
-  sumBy,
-  tail,
-  take,
-  takeRight,
-  takeRightWhile,
-  takeWhile,
-  throttle,
-  toFilled,
-  union,
-  unionBy,
-  unionWith,
-  uniq,
-  uniqBy,
-  uniqWith,
-  unzip,
-  unzipWith,
-  withTimeout,
-  without,
-  xor,
-  xorBy,
-  xorWith,
-  zip,
-  zipObject,
-  zipObjectDeep,
-  zipWith
-});
-//# sourceMappingURL=index.js.map
+    let minElement = items[0];
+    let min = undefined;
+    for (const element of items) {
+        if (min == null || element < min) {
+            min = element;
+            minElement = element;
+        }
+    }
+    return minElement;
+}
+
+exports.compact = initial.compact;
+exports.countBy = initial.countBy;
+exports.differenceBy = initial.differenceBy;
+exports.differenceWith = initial.differenceWith;
+exports.drop = initial.drop;
+exports.dropRight = initial.dropRight;
+exports.dropRightWhile = initial.dropRightWhile;
+exports.dropWhile = initial.dropWhile;
+exports.first = initial.head;
+exports.flatMap = initial.flatMap;
+exports.forEachRight = initial.forEachRight;
+exports.groupBy = initial.groupBy;
+exports.head = initial.head;
+exports.initial = initial.initial;
+exports.intersection = initial.intersection;
+exports.intersectionBy = initial.intersectionBy;
+exports.intersectionWith = initial.intersectionWith;
+exports.isSubset = initial.isSubset;
+exports.keyBy = initial.keyBy;
+exports.last = initial.last;
+exports.maxBy = initial.maxBy;
+exports.minBy = initial.minBy;
+exports.orderBy = initial.orderBy;
+exports.partition = initial.partition;
+exports.sample = initial.sample;
+exports.sampleSize = initial.sampleSize;
+exports.shuffle = initial.shuffle;
+exports.tail = initial.tail;
+exports.take = initial.take;
+exports.takeRight = initial.takeRight;
+exports.takeRightWhile = initial.takeRightWhile;
+exports.takeWhile = initial.takeWhile;
+exports.toFilled = initial.toFilled;
+exports.union = initial.union;
+exports.unionBy = initial.unionBy;
+exports.unionWith = initial.unionWith;
+exports.uniq = initial.uniq;
+exports.uniqBy = initial.uniqBy;
+exports.uniqWith = initial.uniqWith;
+exports.unzip = initial.unzip;
+exports.unzipWith = initial.unzipWith;
+exports.without = initial.without;
+exports.xor = initial.xor;
+exports.xorBy = initial.xorBy;
+exports.xorWith = initial.xorWith;
+exports.zip = initial.zip;
+exports.zipObject = initial.zipObject;
+exports.zipWith = initial.zipWith;
+exports.AbortError = promise_index.AbortError;
+exports.TimeoutError = promise_index.TimeoutError;
+exports.delay = promise_index.delay;
+exports.withTimeout = promise_index.withTimeout;
+exports.after = function_index.after;
+exports.before = function_index.before;
+exports.debounce = function_index.debounce;
+exports.negate = function_index.negate;
+exports.noop = function_index.noop;
+exports.once = function_index.once;
+exports.throttle = function_index.throttle;
+exports.unary = function_index.unary;
+exports.clamp = math_index.clamp;
+exports.inRange = math_index.inRange;
+exports.mean = math_index.mean;
+exports.meanBy = math_index.meanBy;
+exports.range = math_index.range;
+exports.round = math_index.round;
+exports.sum = math_index.sum;
+exports.sumBy = math_index.sumBy;
+exports.random = randomInt.random;
+exports.randomInt = randomInt.randomInt;
+exports.clone = object_index.clone;
+exports.cloneDeep = object_index.cloneDeep;
+exports.flattenObject = object_index.flattenObject;
+exports.invert = object_index.invert;
+exports.omit = object_index.omit;
+exports.omitBy = object_index.omitBy;
+exports.pick = object_index.pick;
+exports.pickBy = object_index.pickBy;
+exports.isEqual = isFunction.isEqual;
+exports.isFunction = isFunction.isFunction;
+exports.isLength = isFunction.isLength;
+exports.isNil = isFunction.isNil;
+exports.isNotNil = isFunction.isNotNil;
+exports.isNull = isFunction.isNull;
+exports.isUndefined = isFunction.isUndefined;
+exports.isPrimitive = isTypedArray$1.isPrimitive;
+exports.camelCase = string_index.camelCase;
+exports.capitalize = string_index.capitalize;
+exports.kebabCase = string_index.kebabCase;
+exports.lowerCase = string_index.lowerCase;
+exports.snakeCase = string_index.snakeCase;
+exports.startCase = string_index.startCase;
+exports.ary = ary;
+exports.bind = bind;
+exports.chunk = chunk;
+exports.concat = concat;
+exports.difference = difference;
+exports.endsWith = endsWith;
+exports.fill = fill;
+exports.flatten = flatten;
+exports.flattenDeep = flattenDeep;
+exports.flattenDepth = flattenDepth;
+exports.get = get;
+exports.isArguments = isArguments;
+exports.isArray = isArray;
+exports.isArrayLike = isArrayLike;
+exports.isBoolean = isBoolean;
+exports.isMatch = isMatch;
+exports.isObjectLike = isObjectLike;
+exports.isPlainObject = isPlainObject;
+exports.isTypedArray = isTypedArray;
+exports.mapKeys = mapKeys;
+exports.mapValues = mapValues;
+exports.matches = matches;
+exports.max = max;
+exports.min = min;
+exports.padStart = padStart;
+exports.property = property;
+exports.set = set;
+exports.size = size;
+exports.startsWith = startsWith;
+exports.zipObjectDeep = zipObjectDeep;