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

package/dist/{chunk-5IKVJGHO.mjs → chunk-RTFTLCF3.mjs}

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

package/dist/chunk-SXFMQQ6F.mjs

@@ -0,0 +1,9 @@
+// src/predicate/isTypedArray.ts
+function isTypedArray(x) {
+  return x instanceof Uint8Array || x instanceof Uint8ClampedArray || x instanceof Uint16Array || x instanceof Uint32Array || x instanceof BigUint64Array || x instanceof Int8Array || x instanceof Int16Array || x instanceof Int32Array || x instanceof BigInt64Array || x instanceof Float32Array || x instanceof Float64Array;
+}
+
+export {
+  isTypedArray
+};
+//# sourceMappingURL=chunk-SXFMQQ6F.mjs.map

package/dist/chunk-SXFMQQ6F.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/predicate/isTypedArray.ts"],"sourcesContent":["/**\n * Checks if a value is a TypedArray.\n * @param {unknown} x The value to check.\n * @returns {x is\n *   | Uint8Array\n *   | Uint8ClampedArray\n *   | Uint16Array\n *   | Uint32Array\n *   | BigUint64Array\n *   | Int8Array\n *   | Int16Array\n *   | Int32Array\n *   | BigInt64Array\n *   | Float32Array\n *   | Float64Array} Returns true if `x` is a TypedArray, false otherwise.\n */\nexport function isTypedArray(\n  x: unknown\n): x is\n  | Uint8Array\n  | Uint8ClampedArray\n  | Uint16Array\n  | Uint32Array\n  | BigUint64Array\n  | Int8Array\n  | Int16Array\n  | Int32Array\n  | BigInt64Array\n  | Float32Array\n  | Float64Array {\n  return (\n    x instanceof Uint8Array ||\n    x instanceof Uint8ClampedArray ||\n    x instanceof Uint16Array ||\n    x instanceof Uint32Array ||\n    x instanceof BigUint64Array ||\n    x instanceof Int8Array ||\n    x instanceof Int16Array ||\n    x instanceof Int32Array ||\n    x instanceof BigInt64Array ||\n    x instanceof Float32Array ||\n    x instanceof Float64Array\n  );\n}\n"],"mappings":";AAgBO,SAAS,aACd,GAYe;AACf,SACE,aAAa,cACb,aAAa,qBACb,aAAa,eACb,aAAa,eACb,aAAa,kBACb,aAAa,aACb,aAAa,cACb,aAAa,cACb,aAAa,iBACb,aAAa,gBACb,aAAa;AAEjB;","names":[]}

package/dist/{chunk-WFZXCGEG.mjs → chunk-YOPFSFTD.mjs}

@@ -1,10 +1,6 @@
-import {
-  __spreadValues
-} from "./chunk-24FKGR6U.mjs";
-
 // src/object/omit.ts
 function omit(obj, keys) {
-  const result = __spreadValues({}, obj);
+  const result = { ...obj };
   for (const key of keys) {
     delete result[key];
   }
@@ -14,4 +10,4 @@ function omit(obj, keys) {
 export {
   omit
 };
-//# sourceMappingURL=chunk-WFZXCGEG.mjs.map
+//# sourceMappingURL=chunk-YOPFSFTD.mjs.map

package/dist/{chunk-WFZXCGEG.mjs.map → chunk-YOPFSFTD.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/object/omit.ts"],"sourcesContent":["/**\n * Creates a new object with specified keys omitted.\n *\n * This function takes an object and an array of keys, and returns a new object that\n * excludes the properties corresponding to the specified keys.\n *\n * @template T - The type of object.\n * @template K - The type of keys in object.\n * @param {T} obj - The object to omit keys from.\n * @param {K[]} keys - An array of keys to be omitted from the object.\n * @returns {Omit<T, K>} A new object with the specified keys omitted.\n *\n * @example\n * const obj = { a: 1, b: 2, c: 3 };\n * const result = omit(obj, ['b', 'c']);\n * // result will be { a: 1 }\n */\nexport function omit<T extends Record<string, any>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K> {\n  const result = { ...obj };\n\n  for (const key of keys) {\n    delete result[key];\n  }\n\n  return result as Omit<T, K>;\n}\n"],"mappings":";;;;;AAiBO,SAAS,KAAuD,KAAQ,MAAuB;AACpG,QAAM,SAAS,mBAAK;AAEpB,aAAW,OAAO,MAAM;AACtB,WAAO,OAAO,GAAG;AAAA,EACnB;AAEA,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../src/object/omit.ts"],"sourcesContent":["/**\n * Creates a new object with specified keys omitted.\n *\n * This function takes an object and an array of keys, and returns a new object that\n * excludes the properties corresponding to the specified keys.\n *\n * @template T - The type of object.\n * @template K - The type of keys in object.\n * @param {T} obj - The object to omit keys from.\n * @param {K[]} keys - An array of keys to be omitted from the object.\n * @returns {Omit<T, K>} A new object with the specified keys omitted.\n *\n * @example\n * const obj = { a: 1, b: 2, c: 3 };\n * const result = omit(obj, ['b', 'c']);\n * // result will be { a: 1 }\n */\nexport function omit<T extends Record<string, any>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K> {\n  const result = { ...obj };\n\n  for (const key of keys) {\n    delete result[key];\n  }\n\n  return result as Omit<T, K>;\n}\n"],"mappings":";AAiBO,SAAS,KAAuD,KAAQ,MAAuB;AACpG,QAAM,SAAS,EAAE,GAAG,IAAI;AAExB,aAAW,OAAO,MAAM;AACtB,WAAO,OAAO,GAAG;AAAA,EACnB;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-YXD3AQAK.mjs

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

package/dist/{chunk-CRSKT4WW.mjs → chunk-Z7HWEOQX.mjs}

@@ -1,10 +1,9 @@
 // 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;
+    result[key] = (result[key] ?? 0) + 1;
   }
   return result;
 }
@@ -12,4 +11,4 @@ function countBy(arr, mapper) {
 export {
   countBy
 };
-//# sourceMappingURL=chunk-CRSKT4WW.mjs.map
+//# sourceMappingURL=chunk-Z7HWEOQX.mjs.map

package/dist/{chunk-CRSKT4WW.mjs.map → chunk-Z7HWEOQX.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/array/countBy.ts"],"sourcesContent":["/**\n * Count the occurrences of each item in an array\n * based on a transformation function.\n *\n * This function takes an array and a transformation function\n * that converts each item in the array to a string. It then\n * counts the occurrences of each transformed item and returns\n * an object with the transformed items as keys and the counts\n * as values.\n *\n * @template T - The type of the items in the input array.\n *\n * @param {T[]} arr - The input array to count occurrences.\n * @param {(item: T) => string} mapper - The transformation function that maps each item to a string key.\n * @returns {Record<string, number>} An object containing the transformed items as keys and the\n * counts as values.\n */\nexport function countBy<T>(arr: T[], mapper: (item: T) => string): Record<string, number> {\n  const result: Record<string, number> = {};\n  \n  for (const item of arr) {\n    const key = mapper(item);\n    \n    result[key] = (result[key] ?? 0) + 1;\n  }\n  \n  return result;\n}\n"],"mappings":";AAiBO,SAAS,QAAW,KAAU,QAAqD;AAjB1F;AAkBE,QAAM,SAAiC,CAAC;AAExC,aAAW,QAAQ,KAAK;AACtB,UAAM,MAAM,OAAO,IAAI;AAEvB,WAAO,GAAG,MAAK,YAAO,GAAG,MAAV,YAAe,KAAK;AAAA,EACrC;AAEA,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../src/array/countBy.ts"],"sourcesContent":["/**\n * Count the occurrences of each item in an array\n * based on a transformation function.\n *\n * This function takes an array and a transformation function\n * that converts each item in the array to a string. It then\n * counts the occurrences of each transformed item and returns\n * an object with the transformed items as keys and the counts\n * as values.\n *\n * @template T - The type of the items in the input array.\n *\n * @param {T[]} arr - The input array to count occurrences.\n * @param {(item: T) => string} mapper - The transformation function that maps each item to a string key.\n * @returns {Record<string, number>} An object containing the transformed items as keys and the\n * counts as values.\n */\nexport function countBy<T>(arr: T[], mapper: (item: T) => string): Record<string, number> {\n  const result: Record<string, number> = {};\n  \n  for (const item of arr) {\n    const key = mapper(item);\n    \n    result[key] = (result[key] ?? 0) + 1;\n  }\n  \n  return result;\n}\n"],"mappings":";AAiBO,SAAS,QAAW,KAAU,QAAqD;AACxF,QAAM,SAAiC,CAAC;AAExC,aAAW,QAAQ,KAAK;AACtB,UAAM,MAAM,OAAO,IAAI;AAEvB,WAAO,GAAG,KAAK,OAAO,GAAG,KAAK,KAAK;AAAA,EACrC;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-ZPNX2QDE.mjs

@@ -0,0 +1,13 @@
+import {
+  timeout
+} from "./chunk-EZYYB34V.mjs";
+
+// src/promise/withTimeout.ts
+async function withTimeout(run, ms) {
+  return Promise.race([run(), timeout(ms)]);
+}
+
+export {
+  withTimeout
+};
+//# sourceMappingURL=chunk-ZPNX2QDE.mjs.map

package/dist/{chunk-IIDZ3KAJ.mjs.map → chunk-ZPNX2QDE.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/promise/withTimeout.ts"],"sourcesContent":["import { timeout } from './timeout.ts';\n\n/**\n * Executes an async function and enforces a timeout. \n * \n * If the promise does not resolve within the specified time,\n * the timeout will trigger and the returned promise will be rejected.\n *\n *\n * @template T \n * @param {() => Promise<T>} run - A function that returns a promise to be executed.\n * @param {number} ms - The timeout duration in milliseconds.\n * @returns {Promise<T>} A promise that resolves with the result of the `run` function or rejects if the timeout is reached.\n *\n * @example\n * try {\n *   await withTimeout(() => {}, 1000); // Timeout exception after 1 second\n * } catch (error) {\n *   console.error(error); // Will log 'TimeoutError'\n * }\n */\nexport async function withTimeout<T>(run: () => Promise<T>, ms: number): Promise<T> {\n  return Promise.race([run(), timeout(ms) as T]);\n}\n"],"mappings":";;;;;;;;AAqBA,SAAsB,YAAe,KAAuB,IAAwB;AAAA;AAClF,WAAO,QAAQ,KAAK,CAAC,IAAI,GAAG,QAAQ,EAAE,CAAM,CAAC;AAAA,EAC/C;AAAA;","names":[]}
+{"version":3,"sources":["../src/promise/withTimeout.ts"],"sourcesContent":["import { timeout } from './timeout.ts';\n\n/**\n * Executes an async function and enforces a timeout. \n * \n * If the promise does not resolve within the specified time,\n * the timeout will trigger and the returned promise will be rejected.\n *\n *\n * @template T \n * @param {() => Promise<T>} run - A function that returns a promise to be executed.\n * @param {number} ms - The timeout duration in milliseconds.\n * @returns {Promise<T>} A promise that resolves with the result of the `run` function or rejects if the timeout is reached.\n *\n * @example\n * try {\n *   await withTimeout(() => {}, 1000); // Timeout exception after 1 second\n * } catch (error) {\n *   console.error(error); // Will log 'TimeoutError'\n * }\n */\nexport async function withTimeout<T>(run: () => Promise<T>, ms: number): Promise<T> {\n  return Promise.race([run(), timeout(ms) as T]);\n}\n"],"mappings":";;;;;AAqBA,eAAsB,YAAe,KAAuB,IAAwB;AAClF,SAAO,QAAQ,KAAK,CAAC,IAAI,GAAG,QAAQ,EAAE,CAAM,CAAC;AAC/C;","names":[]}

package/dist/compat/index.d.mts

@@ -80,6 +80,7 @@ export { isUndefined } from '../predicate/isUndefined.mjs';
 export { isLength } from '../predicate/isLength.mjs';
 export { isFunction } from '../predicate/isFunction.mjs';
 export { isArrayLike } from '../predicate/isArrayLike.mjs';
+export { isPrimitive } from '../predicate/isPrimitive.mjs';
 export { delay } from '../promise/delay.mjs';
 export { withTimeout } from '../promise/withTimeout.mjs';
 export { camelCase } from '../string/camelCase.mjs';
@@ -540,6 +541,24 @@ declare function isPlainObject(object?: unknown): boolean;
  */
 declare function isArray<T>(value?: T): value is Extract<T, readonly unknown[]>;
 
+/**
+ * Checks if a value is a TypedArray.
+ * @param {unknown} x The value to check.
+ * @returns {x is
+ *   | Uint8Array
+ *   | Uint8ClampedArray
+ *   | Uint16Array
+ *   | Uint32Array
+ *   | BigUint64Array
+ *   | Int8Array
+ *   | Int16Array
+ *   | Int32Array
+ *   | BigInt64Array
+ *   | Float32Array
+ *   | Float64Array} Returns true if `x` is a TypedArray, false otherwise.
+ */
+declare function isTypedArray(x?: unknown): x is Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | BigUint64Array | Int8Array | Int16Array | Int32Array | BigInt64Array | Float32Array | Float64Array;
+
 /**
  * Checks if a string contains another string at the beginning of the string.
  *
@@ -614,4 +633,4 @@ declare function min<T>(items: readonly [T, ...T[]]): T;
 declare function min(): undefined;
 declare function min<T>(items?: readonly T[]): T | undefined;
 
-export { chunk, concat, difference, endsWith, fill, get, isArray, isPlainObject, max, min, set, startsWith, zipObjectDeep };
+export { chunk, concat, difference, endsWith, fill, get, isArray, isPlainObject, isTypedArray, max, min, set, startsWith, zipObjectDeep };

package/dist/compat/index.d.ts

@@ -80,6 +80,7 @@ export { isUndefined } from '../predicate/isUndefined.js';
 export { isLength } from '../predicate/isLength.js';
 export { isFunction } from '../predicate/isFunction.js';
 export { isArrayLike } from '../predicate/isArrayLike.js';
+export { isPrimitive } from '../predicate/isPrimitive.js';
 export { delay } from '../promise/delay.js';
 export { withTimeout } from '../promise/withTimeout.js';
 export { camelCase } from '../string/camelCase.js';
@@ -540,6 +541,24 @@ declare function isPlainObject(object?: unknown): boolean;
  */
 declare function isArray<T>(value?: T): value is Extract<T, readonly unknown[]>;
 
+/**
+ * Checks if a value is a TypedArray.
+ * @param {unknown} x The value to check.
+ * @returns {x is
+ *   | Uint8Array
+ *   | Uint8ClampedArray
+ *   | Uint16Array
+ *   | Uint32Array
+ *   | BigUint64Array
+ *   | Int8Array
+ *   | Int16Array
+ *   | Int32Array
+ *   | BigInt64Array
+ *   | Float32Array
+ *   | Float64Array} Returns true if `x` is a TypedArray, false otherwise.
+ */
+declare function isTypedArray(x?: unknown): x is Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | BigUint64Array | Int8Array | Int16Array | Int32Array | BigInt64Array | Float32Array | Float64Array;
+
 /**
  * Checks if a string contains another string at the beginning of the string.
  *
@@ -614,4 +633,4 @@ declare function min<T>(items: readonly [T, ...T[]]): T;
 declare function min(): undefined;
 declare function min<T>(items?: readonly T[]): T | undefined;
 
-export { chunk, concat, difference, endsWith, fill, get, isArray, isPlainObject, max, min, set, startsWith, zipObjectDeep };
+export { chunk, concat, difference, endsWith, fill, get, isArray, isPlainObject, isTypedArray, max, min, set, startsWith, zipObjectDeep };

package/dist/compat/index.js

@@ -2,21 +2,7 @@
 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 });
@@ -30,26 +16,6 @@ var __copyProps = (to, from, except, desc) => {
   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());
-  });
-};
 
 // src/compat/index.ts
 var compat_exports = {};
@@ -101,6 +67,8 @@ __export(compat_exports, {
   isNotNil: () => isNotNil,
   isNull: () => isNull,
   isPlainObject: () => isPlainObject2,
+  isPrimitive: () => isPrimitive3,
+  isTypedArray: () => isTypedArray3,
   isUndefined: () => isUndefined,
   kebabCase: () => kebabCase,
   keyBy: () => keyBy,
@@ -189,11 +157,10 @@ function compact(arr) {
 
 // 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;
+    result[key] = (result[key] ?? 0) + 1;
   }
   return result;
 }
@@ -724,7 +691,7 @@ function debounce(func, debounceMs, { signal } = {}) {
     if (timeoutId !== null) {
       clearTimeout(timeoutId);
     }
-    if (signal == null ? void 0 : signal.aborted) {
+    if (signal?.aborted) {
       return;
     }
     timeoutId = setTimeout(() => {
@@ -741,7 +708,7 @@ function debounce(func, debounceMs, { signal } = {}) {
       timeoutId = null;
     }
   };
-  signal == null ? void 0 : signal.addEventListener("abort", onAbort, { once: true });
+  signal?.addEventListener("abort", onAbort, { once: true });
   return debounced;
 }
 
@@ -859,7 +826,7 @@ function range(start, end, step) {
 
 // src/object/omit.ts
 function omit(obj, keys) {
-  const result = __spreadValues({}, obj);
+  const result = { ...obj };
   for (const key of keys) {
     delete result[key];
   }
@@ -1029,7 +996,7 @@ function cloneDeepHelper(obj, clonedObj) {
   for (const key in obj) {
     if (Object.prototype.hasOwnProperty.call(obj, key)) {
       const descriptor = Object.getOwnPropertyDescriptor(obj, key);
-      if (((descriptor == null ? void 0 : descriptor.writable) || (descriptor == null ? void 0 : descriptor.set)) && typeof (descriptor == null ? void 0 : descriptor.value) !== "function") {
+      if ((descriptor?.writable || descriptor?.set) && typeof descriptor?.value !== "function") {
         clonedObj[key] = cloneDeep(obj[key]);
       }
     }
@@ -1154,6 +1121,16 @@ function isArrayLike(value) {
   return value != null && typeof value !== "function" && isLength(value.length);
 }
 
+// src/predicate/isTypedArray.ts
+function isTypedArray2(x) {
+  return x instanceof Uint8Array || x instanceof Uint8ClampedArray || x instanceof Uint16Array || x instanceof Uint32Array || x instanceof BigUint64Array || x instanceof Int8Array || x instanceof Int16Array || x instanceof Int32Array || x instanceof BigInt64Array || x instanceof Float32Array || x instanceof Float64Array;
+}
+
+// src/predicate/isPrimitive.ts
+function isPrimitive3(value) {
+  return value == null || typeof value !== "object" && typeof value !== "function";
+}
+
 // src/promise/delay.ts
 function delay(ms, { signal } = {}) {
   return new Promise((resolve, reject) => {
@@ -1164,27 +1141,23 @@ function delay(ms, { signal } = {}) {
       clearTimeout(timeoutId);
       abortError();
     };
-    if (signal == null ? void 0 : signal.aborted) {
+    if (signal?.aborted) {
       return abortError();
     }
     const timeoutId = setTimeout(resolve, ms);
-    signal == null ? void 0 : signal.addEventListener("abort", abortHandler, { once: true });
+    signal?.addEventListener("abort", abortHandler, { once: true });
   });
 }
 
 // src/promise/timeout.ts
-function timeout(ms) {
-  return __async(this, null, function* () {
-    yield delay(ms);
-    throw new TimeoutError();
-  });
+async function timeout(ms) {
+  await delay(ms);
+  throw new TimeoutError();
 }
 
 // src/promise/withTimeout.ts
-function withTimeout(run, ms) {
-  return __async(this, null, function* () {
-    return Promise.race([run(), timeout(ms)]);
-  });
+async function withTimeout(run, ms) {
+  return Promise.race([run(), timeout(ms)]);
 }
 
 // src/string/capitalize.ts
@@ -1195,8 +1168,7 @@ var capitalize = (str) => {
 // src/string/_internal/getWords.ts
 var CASE_SPLIT_PATTERN = /[A-Z]?[a-z]+|[0-9]+|[A-Z]+(?![a-z])/g;
 function getWords(str) {
-  var _a;
-  return Array.from((_a = str.match(CASE_SPLIT_PATTERN)) != null ? _a : []);
+  return Array.from(str.match(CASE_SPLIT_PATTERN) ?? []);
 }
 
 // src/string/camelCase.ts
@@ -1378,7 +1350,7 @@ function get(object, path, defaultValue) {
   let resolvedPath;
   if (Array.isArray(path)) {
     resolvedPath = path;
-  } else if (typeof path === "string" && isDeepKey(path) && (object == null ? void 0 : object[path]) == null) {
+  } else if (typeof path === "string" && isDeepKey(path) && object?.[path] == null) {
     resolvedPath = toPath(path);
   } else {
     resolvedPath = [path];
@@ -1398,12 +1370,11 @@ function get(object, path, defaultValue) {
   if (current === null && index === resolvedPath.length) {
     return current;
   }
-  return current != null ? current : defaultValue;
+  return current ?? defaultValue;
 }
 
 // src/compat/predicate/isPlainObject.ts
 function isPlainObject2(object) {
-  var _a;
   if (typeof object !== "object") {
     return false;
   }
@@ -1418,7 +1389,7 @@ function isPlainObject2(object) {
     if (tag == null) {
       return false;
     }
-    const isTagReadonly = !((_a = Object.getOwnPropertyDescriptor(object, Symbol.toStringTag)) == null ? void 0 : _a.writable);
+    const isTagReadonly = !Object.getOwnPropertyDescriptor(object, Symbol.toStringTag)?.writable;
     if (isTagReadonly) {
       return false;
     }
@@ -1436,6 +1407,11 @@ function isArray(value) {
   return Array.isArray(value);
 }
 
+// src/compat/predicate/isTypedArray.ts
+function isTypedArray3(x) {
+  return isTypedArray2(x);
+}
+
 // src/compat/string/startsWith.ts
 var startsWith = (str, target, position = 0) => {
   return str.startsWith(target, position);
@@ -1520,6 +1496,8 @@ function min(items = []) {
   isNotNil,
   isNull,
   isPlainObject,
+  isPrimitive,
+  isTypedArray,
   isUndefined,
   kebabCase,
   keyBy,