es-toolkit 1.12.0 → 1.13.0-dev.292

package/dist/chunk-SPKLWVNJ.mjs

@@ -0,0 +1,373 @@
+import {
+  kebabCase
+} from "./chunk-EYYZQFOP.mjs";
+import {
+  lowerCase
+} from "./chunk-5IKVJGHO.mjs";
+import {
+  snakeCase
+} from "./chunk-F3WCQQET.mjs";
+import {
+  startCase
+} from "./chunk-QXTNZR7B.mjs";
+import {
+  withTimeout
+} from "./chunk-IIDZ3KAJ.mjs";
+import {
+  delay
+} from "./chunk-O64NE2P4.mjs";
+import {
+  camelCase
+} from "./chunk-Y5V7UAZZ.mjs";
+import {
+  capitalize
+} from "./chunk-U56ZOM7L.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 {
+  omitBy
+} from "./chunk-BCTYOXT7.mjs";
+import {
+  pick
+} from "./chunk-HPFDYUGP.mjs";
+import {
+  pickBy
+} from "./chunk-6CLH5YZ2.mjs";
+import {
+  clone
+} from "./chunk-U4JGKZ56.mjs";
+import {
+  flattenObject
+} from "./chunk-XGQWTHW6.mjs";
+import {
+  isPlainObject
+} from "./chunk-MIGAC7F4.mjs";
+import {
+  invert
+} from "./chunk-OLX53VEF.mjs";
+import {
+  omit
+} from "./chunk-WFZXCGEG.mjs";
+import {
+  round
+} from "./chunk-5PMKOZ2F.mjs";
+import {
+  sumBy
+} from "./chunk-5L4VWRFX.mjs";
+import {
+  clamp
+} from "./chunk-MLCL773E.mjs";
+import {
+  inRange
+} from "./chunk-BH6HLGBA.mjs";
+import {
+  meanBy
+} from "./chunk-MY4G7R3I.mjs";
+import {
+  mean
+} from "./chunk-5ASRKEB4.mjs";
+import {
+  sum
+} from "./chunk-2SLTL4KL.mjs";
+import {
+  range
+} from "./chunk-DPH2KE6O.mjs";
+import {
+  unzipWith
+} from "./chunk-IFNXROZR.mjs";
+import {
+  without
+} from "./chunk-PYEYV7BY.mjs";
+import {
+  xor
+} from "./chunk-L7FQX5MN.mjs";
+import {
+  xorBy
+} from "./chunk-Q47NGNXT.mjs";
+import {
+  xorWith
+} from "./chunk-QRSJBBFY.mjs";
+import {
+  zip
+} from "./chunk-IDCUZVJL.mjs";
+import {
+  zipObject
+} from "./chunk-6GWEY5EL.mjs";
+import {
+  zipWith
+} from "./chunk-4KYXHZ4R.mjs";
+import {
+  toFilled
+} from "./chunk-OP4OAKQJ.mjs";
+import {
+  union
+} from "./chunk-R6QA7PLZ.mjs";
+import {
+  unionBy
+} from "./chunk-NFS7RWWE.mjs";
+import {
+  unionWith
+} from "./chunk-2ZCITDMK.mjs";
+import {
+  uniq
+} from "./chunk-DVK2N4KC.mjs";
+import {
+  uniqBy
+} from "./chunk-B4COTK4K.mjs";
+import {
+  uniqWith
+} from "./chunk-237HGSZS.mjs";
+import {
+  unzip
+} from "./chunk-UYZKMBDO.mjs";
+import {
+  sample
+} from "./chunk-2KNLZB7V.mjs";
+import {
+  sampleSize
+} from "./chunk-EHSKB6DF.mjs";
+import {
+  randomInt
+} from "./chunk-GIWAOOFY.mjs";
+import {
+  random
+} from "./chunk-SYWMYQYJ.mjs";
+import {
+  shuffle
+} from "./chunk-G7UQ5PUR.mjs";
+import {
+  tail
+} from "./chunk-TJ4Z5I7M.mjs";
+import {
+  take
+} from "./chunk-ME352XO7.mjs";
+import {
+  takeRight
+} from "./chunk-IQLKIDXF.mjs";
+import {
+  takeRightWhile
+} from "./chunk-NTLX2MPV.mjs";
+import {
+  takeWhile
+} from "./chunk-2IXFGSUA.mjs";
+import {
+  intersectionBy
+} from "./chunk-O6UXZR3U.mjs";
+import {
+  intersectionWith
+} from "./chunk-XI7KRD2C.mjs";
+import {
+  keyBy
+} from "./chunk-AJKZMN2V.mjs";
+import {
+  last
+} from "./chunk-KPBQ7OUY.mjs";
+import {
+  maxBy
+} from "./chunk-OOKNBU4V.mjs";
+import {
+  minBy
+} from "./chunk-IJD7FE2Z.mjs";
+import {
+  orderBy
+} from "./chunk-7B7W36UP.mjs";
+import {
+  partition
+} from "./chunk-DN3NOZ3H.mjs";
+import {
+  flattenDeep
+} from "./chunk-ML727RRJ.mjs";
+import {
+  forEachRight
+} from "./chunk-IEA53J7P.mjs";
+import {
+  groupBy
+} from "./chunk-E6E4RZLN.mjs";
+import {
+  head
+} from "./chunk-HM2JT2RX.mjs";
+import {
+  initial
+} from "./chunk-XPSOKBRZ.mjs";
+import {
+  intersection
+} from "./chunk-FVVSE2F2.mjs";
+import {
+  differenceBy
+} from "./chunk-LVWX5B43.mjs";
+import {
+  differenceWith
+} from "./chunk-6NVQAHXP.mjs";
+import {
+  drop
+} from "./chunk-3EZAFZG3.mjs";
+import {
+  dropRight
+} from "./chunk-OXZCMC5I.mjs";
+import {
+  dropRightWhile
+} from "./chunk-M7SBBYV2.mjs";
+import {
+  dropWhile
+} from "./chunk-LJ2C6MVP.mjs";
+import {
+  fill
+} from "./chunk-YFN6KOC4.mjs";
+import {
+  flatMap
+} from "./chunk-UY76KTPE.mjs";
+import {
+  flatten
+} from "./chunk-33MSBDC6.mjs";
+import {
+  chunk
+} from "./chunk-E6C5EZQA.mjs";
+import {
+  compact
+} from "./chunk-DTJJIMKJ.mjs";
+import {
+  countBy
+} from "./chunk-CRSKT4WW.mjs";
+import {
+  difference
+} from "./chunk-JPUKH67K.mjs";
+import {
+  AbortError
+} from "./chunk-DXB7EZUQ.mjs";
+import {
+  TimeoutError
+} from "./chunk-KIOYQRMQ.mjs";
+import {
+  negate
+} from "./chunk-BOOQBJN2.mjs";
+import {
+  noop
+} from "./chunk-LKXCOLNY.mjs";
+import {
+  once
+} from "./chunk-CMBC4MXG.mjs";
+import {
+  throttle
+} from "./chunk-QOJGMVVR.mjs";
+import {
+  debounce
+} from "./chunk-3IP4JVLL.mjs";
+import {
+  __export
+} from "./chunk-24FKGR6U.mjs";
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AbortError: () => AbortError,
+  TimeoutError: () => TimeoutError,
+  camelCase: () => camelCase,
+  capitalize: () => capitalize,
+  chunk: () => chunk,
+  clamp: () => clamp,
+  clone: () => clone,
+  compact: () => compact,
+  countBy: () => countBy,
+  debounce: () => debounce,
+  delay: () => delay,
+  difference: () => difference,
+  differenceBy: () => differenceBy,
+  differenceWith: () => differenceWith,
+  drop: () => drop,
+  dropRight: () => dropRight,
+  dropRightWhile: () => dropRightWhile,
+  dropWhile: () => dropWhile,
+  fill: () => fill,
+  flatMap: () => flatMap,
+  flatten: () => flatten,
+  flattenDeep: () => flattenDeep,
+  flattenObject: () => flattenObject,
+  forEachRight: () => forEachRight,
+  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: () => isPlainObject,
+  isUndefined: () => isUndefined,
+  kebabCase: () => kebabCase,
+  keyBy: () => keyBy,
+  last: () => last,
+  lowerCase: () => lowerCase,
+  maxBy: () => maxBy,
+  mean: () => mean,
+  meanBy: () => meanBy,
+  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,
+  shuffle: () => shuffle,
+  snakeCase: () => snakeCase,
+  startCase: () => startCase,
+  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,
+  zipWith: () => zipWith
+});
+
+export {
+  src_exports
+};
+//# sourceMappingURL=chunk-SPKLWVNJ.mjs.map

package/dist/chunk-SPKLWVNJ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * es-toolkit\n * ====================================\n * A modern JavaScript utility library that's 2-3 times faster and up to 97% smaller—a major upgrade to lodash.\n *\n * es-toolkit is a state-of-the-art, high-performance JavaScript utility library\n * with a small bundle size and strong type annotations.\n *\n * - es-toolkit offers a variety of everyday utility functions with modern implementations, such as [debounce](https://es-toolkit.slash.page/reference/function/debounce.html), [delay](https://es-toolkit.slash.page/reference/promise/delay.html), [chunk](https://es-toolkit.slash.page/reference/array/chunk.html), [sum](https://es-toolkit.slash.page/reference/math/sum.html), and [pick](https://es-toolkit.slash.page/reference/object/pick.html).\n * - Designed with performance in mind, es-toolkit achieves [2-3× better performance](https://es-toolkit.slash.page/performance.html) in modern JavaScript environments.\n * - es-toolkit supports tree shaking out of the box, and [reduces JavaScript code by up to 97%](https://es-toolkit.slash.page/bundle-size.html) compared to other libraries.\n * - es-toolkit includes built-in TypeScript support, with straightforward yet robust types. It also provides useful type guards such as [isNotNil](https://es-toolkit.slash.page/reference/predicate/isNotNil.html).\n * - es-toolkit is battle-tested with 100% test coverage, ensuring reliability and robustness.\n *\n * ## Features\n *\n * Here are some of the features es-toolkit offers:\n *\n * - **Array**: Utilities for array manipulation, such as [uniq](https://es-toolkit.slash.page/reference/array/uniq.html) and [difference](https://es-toolkit.slash.page/reference/array/difference.html).\n * - **Function**: Tools for controlling function execution, including [debounce](https://es-toolkit.slash.page/reference/function/debounce.html) and [throttle](https://es-toolkit.slash.page/reference/function/throttle.html).\n * - **Math**: Numerical utilities like [sum](https://es-toolkit.slash.page/reference/math/sum.html) and [round](https://es-toolkit.slash.page/reference/math/round.html).\n * - **Object**: Tools for manipulating JavaScript objects, such as [pick](https://es-toolkit.slash.page/reference/object/pick.html) and [omit](https://es-toolkit.slash.page/reference/object/omit.html).\n * - **Predicate**: Type guard functions like [isNotNil](https://es-toolkit.slash.page/reference/predicate/isNotNil.html).\n * - **Promise**: Asynchronous utilities like [delay](https://es-toolkit.slash.page/reference/promise/delay.html).\n * - **String**: Utilities for string manipulation, such as [snakeCase](https://es-toolkit.slash.page/reference/string/snakeCase.html)\n *\n * ## Examples\n *\n * ```typescript\n * // import from '@es-toolkit/es-toolkit' in jsr.\n * import { debounce, chunk } from 'es-toolkit';\n *\n * const debouncedLog = debounce(message => {\n *   console.log(message);\n * }, 300);\n *\n * // This call will be debounced\n * debouncedLog('Hello, world!');\n *\n * const array = [1, 2, 3, 4, 5, 6];\n * const chunkedArray = chunk(array, 2);\n *\n * console.log(chunkedArray);\n * // Output: [[1, 2], [3, 4], [5, 6]]\n * ```\n *\n * ## Resources\n *\n * If you want to know more about the project, please take a look at the\n * following resources:\n *\n * - [GitHub](https://github.com/toss/es-toolkit)\n * - [Documentation](https://es-toolkit.slash.page)\n *\n * @module\n */\nexport * from './array/index.ts';\nexport * from './error/index.ts';\nexport * from './function/index.ts';\nexport * from './math/index.ts';\nexport * from './object/index.ts';\nexport * from './predicate/index.ts';\nexport * from './promise/index.ts';\nexport * from './string/index.ts';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;","names":[]}

package/dist/{chunk-OF6NM4G7.mjs → chunk-TJ4Z5I7M.mjs}

@@ -14,4 +14,4 @@ function tail(arr) {
 export {
   tail
 };
-//# sourceMappingURL=chunk-OF6NM4G7.mjs.map
+//# sourceMappingURL=chunk-TJ4Z5I7M.mjs.map

package/dist/{chunk-OF6NM4G7.mjs.map → chunk-TJ4Z5I7M.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/array/tail.ts"],"sourcesContent":["/**\n * Returns an empty array when the input is a single-element array.\n *\n * @param {readonly [T]} arr - The single-element array to process.\n * @returns {[]} An empty array.\n *\n * @example\n * const arr = [1];\n * const result = tail(arr);\n * // result will be []\n */\nexport function tail<T>(arr: readonly [T]): [];\n\n/**\n * Returns an empty array when the input is an empty array.\n *\n * @param {readonly []} arr - The empty array to process.\n * @returns {[]} An empty array.\n *\n * @example\n * const arr = [];\n * const result = tail(arr);\n * // result will be []\n */\nexport function tail(arr: readonly []): [];\n\n/**\n * Returns a new array with all elements except for the first when the input is a tuple array.\n *\n * @param {readonly [T, ...U[]]} arr - The tuple array to process.\n * @returns {U[]} A new array containing all elements of the input array except for the first one.\n *\n * @example\n * const arr = [1, 2, 3];\n * const result = tail(arr);\n * // result will be [2, 3]\n */\nexport function tail<T, U>(arr: readonly [T, ...U[]]): U[];\n\n/**\n * Returns a new array with all elements except for the first.\n *\n * This function takes an array and returns a new array containing all the elements\n * except for the first one. If the input array is empty or has only one element,\n * an empty array is returned.\n *\n * @param {readonly T[]} arr - The array to get the tail of.\n * @returns {T[]} A new array containing all elements of the input array except for the first one.\n *\n * @example\n * const arr1 = [1, 2, 3];\n * const result = tail(arr1);\n * // result will be [2, 3]\n *\n * const arr2 = [1];\n * const result2 = tail(arr2);\n * // result2 will be []\n *\n * const arr3 = [];\n * const result3 = tail(arr3);\n * // result3 will be []\n */\nexport function tail<T>(arr: readonly T[]): T[] {\n  const len = arr.length;\n  if (len <= 1) {\n    return [];\n  }\n  const result = new Array(len - 1);\n  for (let i = 1; i < len; i++) {\n    result[i - 1] = arr[i];\n  }\n  return result;\n}\n"],"mappings":";AA8DO,SAAS,KAAQ,KAAwB;AAC9C,QAAM,MAAM,IAAI;AAChB,MAAI,OAAO,GAAG;AACZ,WAAO,CAAC;AAAA,EACV;AACA,QAAM,SAAS,IAAI,MAAM,MAAM,CAAC;AAChC,WAAS,IAAI,GAAG,IAAI,KAAK,KAAK;AAC5B,WAAO,IAAI,CAAC,IAAI,IAAI,CAAC;AAAA,EACvB;AACA,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../src/array/tail.ts"],"sourcesContent":["/**\n * Returns an empty array when the input is a single-element array.\n *\n * @param {readonly [T]} arr - The single-element array to process.\n * @returns {[]} An empty array.\n *\n * @example\n * const arr = [1];\n * const result = tail(arr);\n * // result will be []\n */\nexport function tail<T>(arr: readonly [T]): [];\n\n/**\n * Returns an empty array when the input is an empty array.\n *\n * @param {readonly []} arr - The empty array to process.\n * @returns {[]} An empty array.\n *\n * @example\n * const arr = [];\n * const result = tail(arr);\n * // result will be []\n */\nexport function tail(arr: readonly []): [];\n\n/**\n * Returns a new array with all elements except for the first when the input is a tuple array.\n *\n * @param {readonly [T, ...U[]]} arr - The tuple array to process.\n * @returns {U[]} A new array containing all elements of the input array except for the first one.\n *\n * @example\n * const arr = [1, 2, 3];\n * const result = tail(arr);\n * // result will be [2, 3]\n */\nexport function tail<T, U>(arr: readonly [T, ...U[]]): U[];\n\n/**\n * Returns a new array with all elements except for the first.\n *\n * This function takes an array and returns a new array containing all the elements\n * except for the first one. If the input array is empty or has only one element,\n * an empty array is returned.\n *\n * @param {readonly T[]} arr - The array to get the tail of.\n * @returns {T[]} A new array containing all elements of the input array except for the first one.\n *\n * @example\n * const arr1 = [1, 2, 3];\n * const result = tail(arr1);\n * // result will be [2, 3]\n *\n * const arr2 = [1];\n * const result2 = tail(arr2);\n * // result2 will be []\n *\n * const arr3 = [];\n * const result3 = tail(arr3);\n * // result3 will be []\n */\nexport function tail<T>(arr: readonly T[]): T[];\n\nexport function tail<T>(arr: readonly T[]): T[] {\n  const len = arr.length;\n  if (len <= 1) {\n    return [];\n  }\n  const result = new Array(len - 1);\n  for (let i = 1; i < len; i++) {\n    result[i - 1] = arr[i];\n  }\n  return result;\n}\n"],"mappings":";AAgEO,SAAS,KAAQ,KAAwB;AAC9C,QAAM,MAAM,IAAI;AAChB,MAAI,OAAO,GAAG;AACZ,WAAO,CAAC;AAAA,EACV;AACA,QAAM,SAAS,IAAI,MAAM,MAAM,CAAC;AAChC,WAAS,IAAI,GAAG,IAAI,KAAK,KAAK;AAC5B,WAAO,IAAI,CAAC,IAAI,IAAI,CAAC;AAAA,EACvB;AACA,SAAO;AACT;","names":[]}

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

@@ -1,6 +1,6 @@
 import {
   __spreadValues
-} from "./chunk-424M7IR7.mjs";
+} from "./chunk-24FKGR6U.mjs";
 
 // src/object/omit.ts
 function omit(obj, keys) {
@@ -14,4 +14,4 @@ function omit(obj, keys) {
 export {
   omit
 };
-//# sourceMappingURL=chunk-U7V3G7CR.mjs.map
+//# sourceMappingURL=chunk-WFZXCGEG.mjs.map

package/dist/chunk-XGQWTHW6.mjs

@@ -0,0 +1,34 @@
+import {
+  isPlainObject
+} from "./chunk-MIGAC7F4.mjs";
+
+// 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 (Array.isArray(value)) {
+      for (let index = 0; index < value.length; index++) {
+        result[`${prefixedKey}.${index}`] = value[index];
+      }
+      continue;
+    }
+    result[prefixedKey] = value;
+  }
+  return result;
+}
+
+export {
+  flattenObject
+};
+//# sourceMappingURL=chunk-XGQWTHW6.mjs.map

package/dist/chunk-XGQWTHW6.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/object/flattenObject.ts"],"sourcesContent":["import { isPlainObject } from \"../predicate/isPlainObject.ts\";\n\n/**\n * Flattens a nested object into a single level object with dot-separated keys.\n * \n * @param {object} object - The object to flatten.\n * @returns {Record<string, any>} - The flattened object.\n * \n * @example\n * const nestedObject = {\n *   a: {\n *     b: {\n *       c: 1\n *     }\n *   },\n *   d: [2, 3]\n * };\n * \n * const flattened = flattenObject(nestedObject);\n * console.log(flattened); \n * // Output:\n * // {\n * //   'a.b.c': 1,\n * //   'd.0': 2,\n * //   'd.1': 3\n * // }\n */\nexport function flattenObject(object: object): Record<string, any> {\n  return flattenObjectImpl(object);\n}\n\nfunction flattenObjectImpl(object: object, prefix = ''): Record<string, any> {\n  const result: Record<string, any> = {};\n  const keys = Object.keys(object);\n\n  for (let i = 0; i < keys.length; i++) {\n    const key = keys[i];\n    const value = (object as any)[key];\n\n    const prefixedKey = prefix ? `${prefix}.${key}` : key;\n\n    if (isPlainObject(value) && Object.keys(value).length > 0) {\n      Object.assign(result, flattenObjectImpl(value, prefixedKey));\n      continue;\n    }\n\n    if (Array.isArray(value)) {\n      for (let index = 0; index < value.length; index++) {\n        result[`${prefixedKey}.${index}`] = value[index];\n      }\n      continue;\n    }\n\n    result[prefixedKey] = value;\n  }\n\n  return result;\n}"],"mappings":";;;;;AA2BO,SAAS,cAAc,QAAqC;AACjE,SAAO,kBAAkB,MAAM;AACjC;AAEA,SAAS,kBAAkB,QAAgB,SAAS,IAAyB;AAC3E,QAAM,SAA8B,CAAC;AACrC,QAAM,OAAO,OAAO,KAAK,MAAM;AAE/B,WAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,UAAM,MAAM,KAAK,CAAC;AAClB,UAAM,QAAS,OAAe,GAAG;AAEjC,UAAM,cAAc,SAAS,GAAG,MAAM,IAAI,GAAG,KAAK;AAElD,QAAI,cAAc,KAAK,KAAK,OAAO,KAAK,KAAK,EAAE,SAAS,GAAG;AACzD,aAAO,OAAO,QAAQ,kBAAkB,OAAO,WAAW,CAAC;AAC3D;AAAA,IACF;AAEA,QAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,eAAS,QAAQ,GAAG,QAAQ,MAAM,QAAQ,SAAS;AACjD,eAAO,GAAG,WAAW,IAAI,KAAK,EAAE,IAAI,MAAM,KAAK;AAAA,MACjD;AACA;AAAA,IACF;AAEA,WAAO,WAAW,IAAI;AAAA,EACxB;AAEA,SAAO;AACT;","names":[]}

package/dist/compat/index.d.mts

@@ -1,6 +1,5 @@
 export { compact } from '../array/compact.mjs';
 export { countBy } from '../array/countBy.mjs';
-export { difference } from '../array/difference.mjs';
 export { differenceBy } from '../array/differenceBy.mjs';
 export { differenceWith } from '../array/differenceWith.mjs';
 export { drop } from '../array/drop.mjs';
@@ -43,7 +42,7 @@ export { zip } from '../array/zip.mjs';
 export { zipObject } from '../array/zipObject.mjs';
 export { zipWith } from '../array/zipWith.mjs';
 export { without } from '../array/without.mjs';
-export { head } from '../array/head.mjs';
+export { head as first, head } from '../array/head.mjs';
 export { tail } from '../array/tail.mjs';
 export { toFilled } from '../array/toFilled.mjs';
 export { last } from '../array/last.mjs';
@@ -71,11 +70,13 @@ export { pick } from '../object/pick.mjs';
 export { pickBy } from '../object/pickBy.mjs';
 export { invert } from '../object/invert.mjs';
 export { clone } from '../object/clone.mjs';
+export { flattenObject } from '../object/flattenObject.mjs';
 export { isEqual } from '../predicate/isEqual.mjs';
 export { isNil } from '../predicate/isNil.mjs';
 export { isNotNil } from '../predicate/isNotNil.mjs';
 export { isNull } from '../predicate/isNull.mjs';
 export { isUndefined } from '../predicate/isUndefined.mjs';
+export { isLength } from '../predicate/isLength.mjs';
 export { delay } from '../promise/delay.mjs';
 export { withTimeout } from '../promise/withTimeout.mjs';
 export { camelCase } from '../string/camelCase.mjs';
@@ -110,6 +111,37 @@ export { capitalize } from '../string/capitalize.mjs';
  */
 declare function chunk<T>(arr: readonly T[], size?: number): T[][];
 
+/**
+ * Concatenates multiple arrays and values into a single array.
+ *
+ * @template T The type of elements in the array.
+ * @param {...(T | readonly T[])} values - The values and/or arrays to concatenate.
+ * @returns {T[]} A new array containing all the input values.
+ *
+ * @example
+ * // Concatenate individual values
+ * concat(1, 2, 3);
+ * // returns [1, 2, 3]
+ *
+ * @example
+ * // Concatenate arrays of values
+ * concat([1, 2], [3, 4]);
+ * // returns [1, 2, 3, 4]
+ *
+ * @example
+ * // Concatenate a mix of individual values and arrays
+ * concat(1, [2, 3], 4);
+ * // returns [1, 2, 3, 4]
+ *
+ * @example
+ * // Concatenate nested arrays
+ * concat([1, [2, 3]], 4);
+ * // returns [1, [2, 3], 4]
+ */
+declare function concat<T>(...values: Array<T | readonly T[]>): T[];
+
+declare function difference<T>(arr: readonly T[], ...values: Array<readonly T[]>): T[];
+
 /**
  * Creates a deeply nested object given arrays of paths and values.
  *
@@ -427,6 +459,30 @@ declare function get(object: unknown, path: PropertyKey | readonly PropertyKey[]
  */
 declare function set<T>(obj: object, path: PropertyKey | readonly PropertyKey[], value: unknown): T;
 
+/**
+ * Checks if a given value is a plain object.
+ *
+ * A plain object is an object created by the `{}` literal, `new Object()`, or
+ * `Object.create(null)`.
+ *
+ * This function also handles objects with custom
+ * `Symbol.toStringTag` properties.
+ *
+ * `Symbol.toStringTag` is a built-in symbol that a constructor can use to customize the
+ * default string description of objects.
+ *
+ * @param {unknown} [object] - The value to check.
+ * @returns {boolean} - True if the value is a plain object, otherwise false.
+ *
+ * @example
+ * console.log(isPlainObject({})); // true
+ * console.log(isPlainObject([])); // false
+ * console.log(isPlainObject(null)); // false
+ * console.log(isPlainObject(Object.create(null))); // true
+ * console.log(isPlainObject(new Map())); // false
+ */
+declare function isPlainObject(object?: unknown): boolean;
+
 /**
  * Checks if a string contains another string at the beginning of the string.
  *
@@ -497,4 +553,4 @@ declare function max<T>(items?: readonly T[]): T;
  */
 declare function min<T>(items?: readonly T[]): T;
 
-export { chunk, endsWith, get, max, min, set, startsWith, zipObjectDeep };
+export { chunk, concat, difference, endsWith, get, isPlainObject, max, min, set, startsWith, zipObjectDeep };

package/dist/compat/index.d.ts

@@ -1,6 +1,5 @@
 export { compact } from '../array/compact.js';
 export { countBy } from '../array/countBy.js';
-export { difference } from '../array/difference.js';
 export { differenceBy } from '../array/differenceBy.js';
 export { differenceWith } from '../array/differenceWith.js';
 export { drop } from '../array/drop.js';
@@ -43,7 +42,7 @@ export { zip } from '../array/zip.js';
 export { zipObject } from '../array/zipObject.js';
 export { zipWith } from '../array/zipWith.js';
 export { without } from '../array/without.js';
-export { head } from '../array/head.js';
+export { head as first, head } from '../array/head.js';
 export { tail } from '../array/tail.js';
 export { toFilled } from '../array/toFilled.js';
 export { last } from '../array/last.js';
@@ -71,11 +70,13 @@ export { pick } from '../object/pick.js';
 export { pickBy } from '../object/pickBy.js';
 export { invert } from '../object/invert.js';
 export { clone } from '../object/clone.js';
+export { flattenObject } from '../object/flattenObject.js';
 export { isEqual } from '../predicate/isEqual.js';
 export { isNil } from '../predicate/isNil.js';
 export { isNotNil } from '../predicate/isNotNil.js';
 export { isNull } from '../predicate/isNull.js';
 export { isUndefined } from '../predicate/isUndefined.js';
+export { isLength } from '../predicate/isLength.js';
 export { delay } from '../promise/delay.js';
 export { withTimeout } from '../promise/withTimeout.js';
 export { camelCase } from '../string/camelCase.js';
@@ -110,6 +111,37 @@ export { capitalize } from '../string/capitalize.js';
  */
 declare function chunk<T>(arr: readonly T[], size?: number): T[][];
 
+/**
+ * Concatenates multiple arrays and values into a single array.
+ *
+ * @template T The type of elements in the array.
+ * @param {...(T | readonly T[])} values - The values and/or arrays to concatenate.
+ * @returns {T[]} A new array containing all the input values.
+ *
+ * @example
+ * // Concatenate individual values
+ * concat(1, 2, 3);
+ * // returns [1, 2, 3]
+ *
+ * @example
+ * // Concatenate arrays of values
+ * concat([1, 2], [3, 4]);
+ * // returns [1, 2, 3, 4]
+ *
+ * @example
+ * // Concatenate a mix of individual values and arrays
+ * concat(1, [2, 3], 4);
+ * // returns [1, 2, 3, 4]
+ *
+ * @example
+ * // Concatenate nested arrays
+ * concat([1, [2, 3]], 4);
+ * // returns [1, [2, 3], 4]
+ */
+declare function concat<T>(...values: Array<T | readonly T[]>): T[];
+
+declare function difference<T>(arr: readonly T[], ...values: Array<readonly T[]>): T[];
+
 /**
  * Creates a deeply nested object given arrays of paths and values.
  *
@@ -427,6 +459,30 @@ declare function get(object: unknown, path: PropertyKey | readonly PropertyKey[]
  */
 declare function set<T>(obj: object, path: PropertyKey | readonly PropertyKey[], value: unknown): T;
 
+/**
+ * Checks if a given value is a plain object.
+ *
+ * A plain object is an object created by the `{}` literal, `new Object()`, or
+ * `Object.create(null)`.
+ *
+ * This function also handles objects with custom
+ * `Symbol.toStringTag` properties.
+ *
+ * `Symbol.toStringTag` is a built-in symbol that a constructor can use to customize the
+ * default string description of objects.
+ *
+ * @param {unknown} [object] - The value to check.
+ * @returns {boolean} - True if the value is a plain object, otherwise false.
+ *
+ * @example
+ * console.log(isPlainObject({})); // true
+ * console.log(isPlainObject([])); // false
+ * console.log(isPlainObject(null)); // false
+ * console.log(isPlainObject(Object.create(null))); // true
+ * console.log(isPlainObject(new Map())); // false
+ */
+declare function isPlainObject(object?: unknown): boolean;
+
 /**
  * Checks if a string contains another string at the beginning of the string.
  *
@@ -497,4 +553,4 @@ declare function max<T>(items?: readonly T[]): T;
  */
 declare function min<T>(items?: readonly T[]): T;
 
-export { chunk, endsWith, get, max, min, set, startsWith, zipObjectDeep };
+export { chunk, concat, difference, endsWith, get, isPlainObject, max, min, set, startsWith, zipObjectDeep };