es-toolkit 1.13.1 → 1.14.0-dev.399

package/dist/object/omit.mjs

@@ -1,8 +1,9 @@
-import {
-  omit
-} from "../chunk-WFZXCGEG.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  omit
-};
-//# sourceMappingURL=omit.mjs.map
+function omit(obj, keys) {
+    const result = { ...obj };
+    for (const key of keys) {
+        delete result[key];
+    }
+    return result;
+}
+
+export { omit };

package/dist/object/omitBy.mjs

@@ -1,8 +1,12 @@
-import {
-  omitBy
-} from "../chunk-BCTYOXT7.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  omitBy
-};
-//# sourceMappingURL=omitBy.mjs.map
+function omitBy(obj, shouldOmit) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (shouldOmit(value, key)) {
+            continue;
+        }
+        result[key] = value;
+    }
+    return result;
+}
+
+export { omitBy };

package/dist/object/pick.mjs

@@ -1,8 +1,9 @@
-import {
-  pick
-} from "../chunk-HPFDYUGP.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  pick
-};
-//# sourceMappingURL=pick.mjs.map
+function pick(obj, keys) {
+    const result = {};
+    for (const key of keys) {
+        result[key] = obj[key];
+    }
+    return result;
+}
+
+export { pick };

package/dist/object/pickBy.mjs

@@ -1,8 +1,12 @@
-import {
-  pickBy
-} from "../chunk-6CLH5YZ2.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  pickBy
-};
-//# sourceMappingURL=pickBy.mjs.map
+function pickBy(obj, shouldPick) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (!shouldPick(value, key)) {
+            continue;
+        }
+        result[key] = value;
+    }
+    return result;
+}
+
+export { pickBy };

package/dist/predicate/index.d.mts

@@ -5,3 +5,7 @@ export { isNull } from './isNull.mjs';
 export { isUndefined } from './isUndefined.mjs';
 export { isLength } from './isLength.mjs';
 export { isPlainObject } from './isPlainObject.mjs';
+export { isFunction } from './isFunction.mjs';
+export { isTypedArray } from './isTypedArray.mjs';
+export { isPrimitive } from './isPrimitive.mjs';
+export { isBoolean } from './isBoolean.mjs';

package/dist/predicate/index.d.ts

@@ -5,3 +5,7 @@ export { isNull } from './isNull.js';
 export { isUndefined } from './isUndefined.js';
 export { isLength } from './isLength.js';
 export { isPlainObject } from './isPlainObject.js';
+export { isFunction } from './isFunction.js';
+export { isTypedArray } from './isTypedArray.js';
+export { isPrimitive } from './isPrimitive.js';
+export { isBoolean } from './isBoolean.js';

package/dist/predicate/index.js

@@ -1,131 +1,22 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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);
+'use strict';
 
-// src/predicate/index.ts
-var predicate_exports = {};
-__export(predicate_exports, {
-  isEqual: () => isEqual,
-  isLength: () => isLength,
-  isNil: () => isNil,
-  isNotNil: () => isNotNil,
-  isNull: () => isNull,
-  isPlainObject: () => isPlainObject,
-  isUndefined: () => isUndefined
-});
-module.exports = __toCommonJS(predicate_exports);
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-// 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/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;
-    }
-  }
-  return true;
-}
-
-// src/predicate/isNil.ts
-function isNil(x) {
-  return x == null;
-}
+const isFunction = require('../_chunk/isFunction-Cw_tLG.js');
+const isTypedArray = require('../_chunk/isTypedArray-BBEkFl.js');
 
-// src/predicate/isNotNil.ts
-function isNotNil(x) {
-  return x !== null && x !== void 0;
+function isBoolean(x) {
+    return typeof x === 'boolean';
 }
 
-// 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/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;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  isEqual,
-  isLength,
-  isNil,
-  isNotNil,
-  isNull,
-  isPlainObject,
-  isUndefined
-});
-//# sourceMappingURL=index.js.map
+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.isPlainObject = isTypedArray.isPlainObject;
+exports.isPrimitive = isTypedArray.isPrimitive;
+exports.isTypedArray = isTypedArray.isTypedArray;
+exports.isBoolean = isBoolean;

package/dist/predicate/index.mjs

@@ -1,35 +1,11 @@
-import "../chunk-B645AYL4.mjs";
-import {
-  isNull
-} from "../chunk-AIRSKN47.mjs";
-import {
-  isUndefined
-} from "../chunk-VH2PV426.mjs";
-import {
-  isEqual
-} from "../chunk-JYSV56US.mjs";
-import {
-  isLength
-} from "../chunk-27QMXBLJ.mjs";
-import {
-  isNil
-} from "../chunk-WMM7TZLG.mjs";
-import {
-  isNotNil
-} from "../chunk-BMRTZMRE.mjs";
-import {
-  isPlainObject
-} from "../chunk-MIGAC7F4.mjs";
-import "../chunk-R6QA7PLZ.mjs";
-import "../chunk-DVK2N4KC.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  isEqual,
-  isLength,
-  isNil,
-  isNotNil,
-  isNull,
-  isPlainObject,
-  isUndefined
-};
-//# sourceMappingURL=index.mjs.map
+export { isEqual } from './isEqual.mjs';
+export { isNil } from './isNil.mjs';
+export { isNotNil } from './isNotNil.mjs';
+export { isNull } from './isNull.mjs';
+export { isUndefined } from './isUndefined.mjs';
+export { isLength } from './isLength.mjs';
+export { isPlainObject } from './isPlainObject.mjs';
+export { isFunction } from './isFunction.mjs';
+export { isTypedArray } from './isTypedArray.mjs';
+export { isPrimitive } from './isPrimitive.mjs';
+export { isBoolean } from './isBoolean.mjs';

package/dist/predicate/isBoolean.d.mts

@@ -0,0 +1,25 @@
+/**
+ * Checks if the given value is boolean.
+ *
+ * This function tests whether the provided value is strictly `boolean`.
+ * It returns `true` if the value is `boolean`, and `false` otherwise.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `boolean`.
+ *
+ * @param {unknown} x - The Value to test if it is boolean.
+ * @returns {x is boolean} True if the value is booelan, false otherwise.
+ *
+ * @example
+ *
+ * const value1 = true;
+ * const value2 = 0;
+ * const value3 = 'abc';
+ *
+ * console.log(isBoolean(value1)); // true
+ * console.log(isBoolean(value2)); // false
+ * console.log(isBoolean(value3)); // false
+ *
+ */
+declare function isBoolean(x: unknown): x is boolean;
+
+export { isBoolean };

package/dist/predicate/isBoolean.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Checks if the given value is boolean.
+ *
+ * This function tests whether the provided value is strictly `boolean`.
+ * It returns `true` if the value is `boolean`, and `false` otherwise.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `boolean`.
+ *
+ * @param {unknown} x - The Value to test if it is boolean.
+ * @returns {x is boolean} True if the value is booelan, false otherwise.
+ *
+ * @example
+ *
+ * const value1 = true;
+ * const value2 = 0;
+ * const value3 = 'abc';
+ *
+ * console.log(isBoolean(value1)); // true
+ * console.log(isBoolean(value2)); // false
+ * console.log(isBoolean(value3)); // false
+ *
+ */
+declare function isBoolean(x: unknown): x is boolean;
+
+export { isBoolean };

package/dist/predicate/isBoolean.mjs

@@ -0,0 +1,5 @@
+function isBoolean(x) {
+    return typeof x === 'boolean';
+}
+
+export { isBoolean };

package/dist/predicate/isEqual.d.mts

@@ -12,6 +12,6 @@
  * isEqual(new Date('2020-01-01'), new Date('2020-01-01')); // true
  * isEqual([1, 2, 3], [1, 2, 3]); // true
  */
-declare function isEqual(a: unknown, b: unknown): boolean;
+declare function isEqual(a: any, b: any): boolean;
 
 export { isEqual };

package/dist/predicate/isEqual.d.ts

@@ -12,6 +12,6 @@
  * isEqual(new Date('2020-01-01'), new Date('2020-01-01')); // true
  * isEqual([1, 2, 3], [1, 2, 3]); // true
  */
-declare function isEqual(a: unknown, b: unknown): boolean;
+declare function isEqual(a: any, b: any): boolean;
 
 export { isEqual };

package/dist/predicate/isEqual.mjs

@@ -1,10 +1,177 @@
-import {
-  isEqual
-} from "../chunk-JYSV56US.mjs";
-import "../chunk-R6QA7PLZ.mjs";
-import "../chunk-DVK2N4KC.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  isEqual
-};
-//# sourceMappingURL=isEqual.mjs.map
+import { functionTag, regexpTag, symbolTag, dateTag, booleanTag, numberTag, stringTag, objectTag, errorTag, dataViewTag, arrayBufferTag, float64ArrayTag, float32ArrayTag, bigInt64ArrayTag, int32ArrayTag, int16ArrayTag, int8ArrayTag, bigUint64ArrayTag, uint32ArrayTag, uint16ArrayTag, uint8ClampedArrayTag, uint8ArrayTag, arrayTag, setTag, mapTag, argumentsTag } from '../compat/_internal/tags.mjs';
+import { getSymbols } from '../compat/_internal/getSymbols.mjs';
+import { getTag } from '../compat/_internal/getTag.mjs';
+import { isPlainObject } from './isPlainObject.mjs';
+
+function isEqual(a, b) {
+    if (typeof a === typeof b) {
+        switch (typeof a) {
+            case 'bigint':
+            case 'string':
+            case 'boolean':
+            case 'symbol':
+            case 'undefined': {
+                return a === b;
+            }
+            case 'number': {
+                return a === b || Object.is(a, b);
+            }
+            case 'function': {
+                return a === b;
+            }
+            case 'object': {
+                return areObjectsEqual(a, b);
+            }
+        }
+    }
+    return areObjectsEqual(a, b);
+}
+function areObjectsEqual(a, b, stack) {
+    if (Object.is(a, b)) {
+        return true;
+    }
+    let aTag = getTag(a);
+    let bTag = getTag(b);
+    if (aTag === argumentsTag) {
+        aTag = objectTag;
+    }
+    if (bTag === argumentsTag) {
+        bTag = objectTag;
+    }
+    if (aTag !== bTag) {
+        return false;
+    }
+    switch (aTag) {
+        case stringTag:
+            return a.toString() === b.toString();
+        case numberTag: {
+            const x = a.valueOf();
+            const y = b.valueOf();
+            return x === y || Number.isNaN(x) && Number.isNaN(y);
+        }
+        case booleanTag:
+        case dateTag:
+        case symbolTag:
+            return Object.is(a.valueOf(), b.valueOf());
+        case regexpTag: {
+            return a.source === b.source && a.flags === b.flags;
+        }
+        case functionTag: {
+            return a == b;
+        }
+    }
+    stack = stack ?? new Map();
+    const aStack = stack.get(a);
+    const bStack = stack.get(b);
+    if (aStack != null && bStack != null) {
+        return aStack === b;
+    }
+    stack.set(a, b);
+    stack.set(b, a);
+    try {
+        switch (aTag) {
+            case mapTag: {
+                if (a.size !== b.size) {
+                    return false;
+                }
+                for (const [key, value] of a.entries()) {
+                    if (!b.has(key) || !areObjectsEqual(value, b.get(key), stack)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            case setTag: {
+                if (a.size !== b.size) {
+                    return false;
+                }
+                const aValues = Array.from(a.values());
+                const bValues = Array.from(b.values());
+                for (let i = 0; i < aValues.length; i++) {
+                    const aValue = aValues[i];
+                    const index = bValues.findIndex(bValue => {
+                        return areObjectsEqual(aValue, bValue, stack);
+                    });
+                    if (index === -1) {
+                        return false;
+                    }
+                    bValues.splice(index, 1);
+                }
+                return true;
+            }
+            case arrayTag:
+            case uint8ArrayTag:
+            case uint8ClampedArrayTag:
+            case uint16ArrayTag:
+            case uint32ArrayTag:
+            case bigUint64ArrayTag:
+            case int8ArrayTag:
+            case int16ArrayTag:
+            case int32ArrayTag:
+            case bigInt64ArrayTag:
+            case float32ArrayTag:
+            case float64ArrayTag: {
+                if (typeof Buffer !== 'undefined' && Buffer.isBuffer(a) !== Buffer.isBuffer(b)) {
+                    return false;
+                }
+                if (a.length !== b.length) {
+                    return false;
+                }
+                for (let i = 0; i < a.length; i++) {
+                    if (!areObjectsEqual(a[i], b[i], stack)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            case arrayBufferTag: {
+                if (a.byteLength !== b.byteLength) {
+                    return false;
+                }
+                return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack);
+            }
+            case dataViewTag: {
+                if (a.byteLength !== b.byteLength || a.byteOffset !== b.byteOffset) {
+                    return false;
+                }
+                return areObjectsEqual(a.buffer, b.buffer, stack);
+            }
+            case errorTag: {
+                return a.name === b.name && a.message === b.message;
+            }
+            case objectTag: {
+                const areEqualInstances = areObjectsEqual(a.constructor, b.constructor, stack) ||
+                    (isPlainObject(a) && isPlainObject(b));
+                if (!areEqualInstances) {
+                    return false;
+                }
+                const aKeys = [...Object.keys(a), ...getSymbols(a)];
+                const bKeys = [...Object.keys(b), ...getSymbols(b)];
+                if (aKeys.length !== bKeys.length) {
+                    return false;
+                }
+                for (let i = 0; i < aKeys.length; i++) {
+                    const propKey = aKeys[i];
+                    const aProp = a[propKey];
+                    if (!b.hasOwnProperty(propKey)) {
+                        return false;
+                    }
+                    const bProp = b[propKey];
+                    if (!areObjectsEqual(aProp, bProp, stack)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            default: {
+                return false;
+            }
+        }
+    }
+    finally {
+        stack.delete(a);
+        stack.delete(b);
+    }
+}
+
+export { isEqual };

package/dist/predicate/isFunction.d.mts

@@ -0,0 +1,16 @@
+/**
+ * Checks if `value` is a function.
+ *
+ * @param {unknown} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+ *
+ * @example
+ * isFunction(Array.prototype.slice); // true
+ * isFunction(async function () {}); // true
+ * isFunction(function* () {}); // true
+ * isFunction(Proxy); // true
+ * isFunction(Int8Array); // true
+ */
+declare function isFunction(value: unknown): value is (...args: unknown[]) => unknown;
+
+export { isFunction };

package/dist/predicate/isFunction.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Checks if `value` is a function.
+ *
+ * @param {unknown} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+ *
+ * @example
+ * isFunction(Array.prototype.slice); // true
+ * isFunction(async function () {}); // true
+ * isFunction(function* () {}); // true
+ * isFunction(Proxy); // true
+ * isFunction(Int8Array); // true
+ */
+declare function isFunction(value: unknown): value is (...args: unknown[]) => unknown;
+
+export { isFunction };

package/dist/predicate/isFunction.mjs

@@ -0,0 +1,5 @@
+function isFunction(value) {
+    return typeof value === 'function';
+}
+
+export { isFunction };

package/dist/predicate/isLength.d.mts

@@ -1,3 +1,24 @@
+/**
+ * Checks if a given value is a valid length.
+ *
+ * A valid length is of type `number`, is a non-negative integer, and is less than or equal to
+ * JavaScript's maximum safe integer (`Number.MAX_SAFE_INTEGER`).
+ * It returns `true` if the value is a valid length, and `false` otherwise.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the
+ * argument to a valid length (`number`).
+ *
+ * @param {unknown} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+ *
+ * @example
+ * isLength(0); // true
+ * isLength(42); // true
+ * isLength(-1); // false
+ * isLength(1.5); // false
+ * isLength(Number.MAX_SAFE_INTEGER); // true
+ * isLength(Number.MAX_SAFE_INTEGER + 1); // false
+ */
 declare function isLength(value: unknown): value is number;
 
 export { isLength };

package/dist/predicate/isLength.d.ts

@@ -1,3 +1,24 @@
+/**
+ * Checks if a given value is a valid length.
+ *
+ * A valid length is of type `number`, is a non-negative integer, and is less than or equal to
+ * JavaScript's maximum safe integer (`Number.MAX_SAFE_INTEGER`).
+ * It returns `true` if the value is a valid length, and `false` otherwise.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the
+ * argument to a valid length (`number`).
+ *
+ * @param {unknown} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+ *
+ * @example
+ * isLength(0); // true
+ * isLength(42); // true
+ * isLength(-1); // false
+ * isLength(1.5); // false
+ * isLength(Number.MAX_SAFE_INTEGER); // true
+ * isLength(Number.MAX_SAFE_INTEGER + 1); // false
+ */
 declare function isLength(value: unknown): value is number;
 
 export { isLength };

package/dist/predicate/isLength.mjs

@@ -1,8 +1,5 @@
-import {
-  isLength
-} from "../chunk-27QMXBLJ.mjs";
-import "../chunk-24FKGR6U.mjs";
-export {
-  isLength
-};
-//# sourceMappingURL=isLength.mjs.map
+function isLength(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
+
+export { isLength };