es-toolkit 1.9.0 → 1.10.0-dev.204

package/dist/compat/index.mjs

@@ -0,0 +1,351 @@
+import "../chunk-NKLIE2OI.mjs";
+import "../chunk-QKYYOLJ6.mjs";
+import {
+  kebabCase
+} from "../chunk-EYYZQFOP.mjs";
+import {
+  lowerCase
+} from "../chunk-5IKVJGHO.mjs";
+import {
+  snakeCase
+} from "../chunk-F3WCQQET.mjs";
+import "../chunk-ARZ5BDR6.mjs";
+import {
+  delay
+} from "../chunk-O64NE2P4.mjs";
+import {
+  camelCase
+} from "../chunk-XGCYC4YA.mjs";
+import "../chunk-WVQ7YVRK.mjs";
+import {
+  capitalize
+} from "../chunk-U56ZOM7L.mjs";
+import "../chunk-OSOLEQLZ.mjs";
+import {
+  invert
+} from "../chunk-74WWMNZS.mjs";
+import {
+  omit
+} from "../chunk-4E4D3BMI.mjs";
+import {
+  omitBy
+} from "../chunk-BCTYOXT7.mjs";
+import {
+  pick
+} from "../chunk-HPFDYUGP.mjs";
+import {
+  pickBy
+} from "../chunk-6CLH5YZ2.mjs";
+import "../chunk-ASJF5D6C.mjs";
+import {
+  isNil
+} from "../chunk-WMM7TZLG.mjs";
+import {
+  isNotNil
+} from "../chunk-BMRTZMRE.mjs";
+import {
+  isNull
+} from "../chunk-AIRSKN47.mjs";
+import {
+  isUndefined
+} from "../chunk-VH2PV426.mjs";
+import {
+  isEqual
+} from "../chunk-JYSV56US.mjs";
+import {
+  clone
+} from "../chunk-U4JGKZ56.mjs";
+import "../chunk-236H5JZJ.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 "../chunk-TLVQSNOE.mjs";
+import {
+  meanBy
+} from "../chunk-IZAD2S7R.mjs";
+import {
+  mean
+} from "../chunk-GDC64SYJ.mjs";
+import {
+  range
+} from "../chunk-DPH2KE6O.mjs";
+import {
+  round
+} from "../chunk-5PMKOZ2F.mjs";
+import {
+  sum
+} from "../chunk-2SLTL4KL.mjs";
+import {
+  clamp
+} from "../chunk-MLCL773E.mjs";
+import {
+  inRange
+} from "../chunk-BH6HLGBA.mjs";
+import {
+  debounce
+} from "../chunk-3IP4JVLL.mjs";
+import "../chunk-2MRZANXZ.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 {
+  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-OXAZEEGP.mjs";
+import {
+  uniqWith
+} from "../chunk-237HGSZS.mjs";
+import {
+  unzip
+} from "../chunk-UYZKMBDO.mjs";
+import {
+  unzipWith
+} from "../chunk-IFNXROZR.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-OF6NM4G7.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 {
+  toFilled
+} from "../chunk-OP4OAKQJ.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 {
+  sample
+} from "../chunk-2KNLZB7V.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 {
+  intersectionBy
+} from "../chunk-O6UXZR3U.mjs";
+import {
+  differenceBy
+} from "../chunk-LVWX5B43.mjs";
+import {
+  differenceWith
+} from "../chunk-6NVQAHXP.mjs";
+import {
+  drop
+} from "../chunk-S3CORED5.mjs";
+import {
+  dropRight
+} from "../chunk-JEKUA56R.mjs";
+import {
+  dropRightWhile
+} from "../chunk-JE6JKZU3.mjs";
+import {
+  dropWhile
+} from "../chunk-LJ2C6MVP.mjs";
+import {
+  fill
+} from "../chunk-C4WE4GLC.mjs";
+import {
+  flatten
+} from "../chunk-33MSBDC6.mjs";
+import "../chunk-FZEZH22H.mjs";
+import {
+  AbortError
+} from "../chunk-DXB7EZUQ.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 "../chunk-2HIMLZE3.mjs";
+
+// 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);
+}
+export {
+  AbortError,
+  camelCase,
+  capitalize,
+  chunk2 as chunk,
+  clamp,
+  clone,
+  compact,
+  countBy,
+  debounce,
+  delay,
+  difference,
+  differenceBy,
+  differenceWith,
+  drop,
+  dropRight,
+  dropRightWhile,
+  dropWhile,
+  fill,
+  flatten,
+  flattenDeep,
+  forEachRight,
+  groupBy,
+  head,
+  inRange,
+  initial,
+  intersection,
+  intersectionBy,
+  intersectionWith,
+  invert,
+  isEqual,
+  isNil,
+  isNotNil,
+  isNull,
+  isUndefined,
+  kebabCase,
+  keyBy,
+  last,
+  lowerCase,
+  maxBy,
+  mean,
+  meanBy,
+  minBy,
+  negate,
+  noop,
+  omit,
+  omitBy,
+  once,
+  orderBy,
+  partition,
+  pick,
+  pickBy,
+  random,
+  randomInt,
+  range,
+  round,
+  sample,
+  sampleSize,
+  shuffle,
+  snakeCase,
+  sum,
+  tail,
+  take,
+  takeRight,
+  takeRightWhile,
+  takeWhile,
+  throttle,
+  toFilled,
+  union,
+  unionBy,
+  unionWith,
+  uniq,
+  uniqBy,
+  uniqWith,
+  unzip,
+  unzipWith,
+  without,
+  xor,
+  xorBy,
+  xorWith,
+  zip,
+  zipObject,
+  zipWith
+};
+//# sourceMappingURL=index.mjs.map

package/dist/compat/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/compat/array/chunk.ts"],"sourcesContent":["import { chunk as chunkToolkit } from '../../array/chunk.ts';\n\n/**\n * Splits an array into smaller arrays of a specified length.\n *\n * This function takes an input array and divides it into multiple smaller arrays,\n * each of a specified length. If the input array cannot be evenly divided,\n * the final sub-array will contain the remaining elements.\n *\n * @template T The type of elements in the array.\n * @param {T[]} arr - The array to be chunked into smaller arrays.\n * @param {number} size - The size of each smaller array. Must be a positive integer.\n * @returns {T[][]} A two-dimensional array where each sub-array has a maximum length of `size`.\n * @throws {Error} Throws an error if `size` is not a positive integer.\n *\n * @example\n * // Splits an array of numbers into sub-arrays of length 2\n * chunk([1, 2, 3, 4, 5], 2);\n * // Returns: [[1, 2], [3, 4], [5]]\n *\n * @example\n * // Splits an array of strings into sub-arrays of length 3\n * chunk(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3);\n * // Returns: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g']]\n */\nexport function chunk<T>(arr: readonly T[], size: number = 1): T[][] {\n  size = Math.max(Math.floor(size), 0);\n\n  if (size === 0) {\n    return [];\n  }\n\n  return chunkToolkit(arr, size);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyBO,SAASA,OAAS,KAAmB,OAAe,GAAU;AACnE,SAAO,KAAK,IAAI,KAAK,MAAM,IAAI,GAAG,CAAC;AAEnC,MAAI,SAAS,GAAG;AACd,WAAO,CAAC;AAAA,EACV;AAEA,SAAO,MAAa,KAAK,IAAI;AAC/B;","names":["chunk"]}

package/dist/error/AbortError.mjs

@@ -1,7 +1,7 @@
 import {
   AbortError
 } from "../chunk-DXB7EZUQ.mjs";
-import "../chunk-2MM5EJJX.mjs";
+import "../chunk-2HIMLZE3.mjs";
 export {
   AbortError
 };

package/dist/error/index.mjs

@@ -2,7 +2,7 @@ import "../chunk-FZEZH22H.mjs";
 import {
   AbortError
 } from "../chunk-DXB7EZUQ.mjs";
-import "../chunk-2MM5EJJX.mjs";
+import "../chunk-2HIMLZE3.mjs";
 export {
   AbortError
 };

package/dist/function/debounce.mjs

@@ -1,7 +1,7 @@
 import {
   debounce
 } from "../chunk-3IP4JVLL.mjs";
-import "../chunk-2MM5EJJX.mjs";
+import "../chunk-2HIMLZE3.mjs";
 export {
   debounce
 };

package/dist/function/index.d.mts

@@ -2,3 +2,4 @@ export { debounce } from './debounce.mjs';
 export { noop } from './noop.mjs';
 export { once } from './once.mjs';
 export { throttle } from './throttle.mjs';
+export { negate } from './negate.mjs';

package/dist/function/index.d.ts

@@ -2,3 +2,4 @@ export { debounce } from './debounce.js';
 export { noop } from './noop.js';
 export { once } from './once.js';
 export { throttle } from './throttle.js';
+export { negate } from './negate.js';

package/dist/function/index.js

@@ -21,6 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var function_exports = {};
 __export(function_exports, {
   debounce: () => debounce,
+  negate: () => negate,
   noop: () => noop,
   once: () => once,
   throttle: () => throttle
@@ -86,9 +87,15 @@ function throttle(func, throttleMs) {
   };
   return throttledFunction;
 }
+
+// src/function/negate.ts
+function negate(func) {
+  return (...args) => !func(...args);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   debounce,
+  negate,
   noop,
   once,
   throttle

package/dist/function/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/function/index.ts","../../src/function/debounce.ts","../../src/function/noop.ts","../../src/function/once.ts","../../src/function/throttle.ts"],"sourcesContent":["export { debounce } from './debounce.ts';\nexport { noop } from './noop.ts';\nexport { once } from './once.ts';\nexport { throttle } from './throttle.ts';\n","interface DebounceOptions {\n  signal?: AbortSignal;\n}\n\n/**\n * Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds\n * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`\n * method to cancel any pending execution.\n *\n * @template F - The type of function.\n * @param {F} func - The function to debounce.\n * @param {number} debounceMs - The number of milliseconds to delay.\n * @param {DebounceOptions} options - The options object.\n * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the debounced function.\n * @returns {F & { cancel: () => void }} A new debounced function with a `cancel` method.\n *\n * @example\n * const debouncedFunction = debounce(() => {\n *   console.log('Function executed');\n * }, 1000);\n *\n * // Will log 'Function executed' after 1 second if not called again in that time\n * debouncedFunction();\n *\n * // Will not log anything as the previous call is canceled\n * debouncedFunction.cancel();\n *\n * // With AbortSignal\n * const controller = new AbortController();\n * const signal = controller.signal;\n * const debouncedWithSignal = debounce(() => {\n *  console.log('Function executed');\n * }, 1000, { signal });\n *\n * debouncedWithSignal();\n *\n * // Will cancel the debounced function call\n * controller.abort();\n */\nexport function debounce<F extends (...args: any[]) => void>(\n  func: F,\n  debounceMs: number,\n  { signal }: DebounceOptions = {}\n): F & { cancel: () => void } {\n  let timeoutId: number | null = null;\n\n  const debounced = function (...args: Parameters<F>) {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n    }\n\n    if (signal?.aborted) {\n      return;\n    }\n\n    timeoutId = setTimeout(() => {\n      func(...args);\n      timeoutId = null;\n    }, debounceMs) as any;\n  } as F & { cancel: () => void };\n\n  const onAbort = function () {\n    debounced.cancel();\n  };\n\n  debounced.cancel = function () {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n      timeoutId = null;\n    }\n  };\n\n  signal?.addEventListener('abort', onAbort, { once: true });\n\n  return debounced;\n}\n","/**\n * A no-operation function that does nothing.\n * This can be used as a placeholder or default function.\n *\n * @example\n * noop(); // Does nothing\n *\n * @returns {void} This function does not return anything.\n */\nexport function noop(): void {}\n","/**\n * Creates a function that is restricted to invoking the provided function `func` once.\n * Repeated calls to the function will return the value from the first invocation.\n *\n * @template F - The type of function.\n * @param {F} func - The function to restrict.\n * @returns {F} A new function that invokes `func` once and caches the result.\n *\n * @example\n * const initialize = once(() => {\n *   console.log('Initialized!');\n *   return true;\n * });\n *\n * initialize(); // Logs: 'Initialized!' and returns true\n * initialize(); // Returns true without logging\n */\nexport function once<F extends () => any>(func: F): F {\n  let called = false;\n  let cache: ReturnType<F> | undefined;\n\n  return function () {\n    if (called) {\n      return cache;\n    }\n\n    const result = func();\n\n    called = true;\n    cache = result;\n\n    return result;\n  } as F;\n}\n","/**\n * Creates a throttled function that only invokes the provided function at most once\n * per every `throttleMs` milliseconds. Subsequent calls to the throttled function\n * within the wait time will not trigger the execution of the original function.\n *\n * @template F - The type of function.\n * @param {F} func - The function to throttle.\n * @param {number} throttleMs - The number of milliseconds to throttle executions to.\n * @returns {F} A new throttled function that accepts the same parameters as the original function.\n *\n * @example\n * const throttledFunction = throttle(() => {\n *   console.log('Function executed');\n * }, 1000);\n *\n * // Will log 'Function executed' immediately\n * throttledFunction();\n *\n * // Will not log anything as it is within the throttle time\n * throttledFunction();\n *\n * // After 1 second\n * setTimeout(() => {\n *   throttledFunction(); // Will log 'Function executed'\n * }, 1000);\n */\nexport function throttle<F extends (...args: any[]) => void>(func: F, throttleMs: number): F {\n  let lastCallTime: number | null;\n\n  const throttledFunction = function (...args: Parameters<F>) {\n    const now = Date.now();\n\n    if (lastCallTime == null || now - lastCallTime >= throttleMs) {\n      lastCallTime = now;\n      func(...args);\n    }\n  } as F;\n\n  return throttledFunction;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACuCO,SAAS,SACd,MACA,YACA,EAAE,OAAO,IAAqB,CAAC,GACH;AAC5B,MAAI,YAA2B;AAE/B,QAAM,YAAY,YAAa,MAAqB;AAClD,QAAI,cAAc,MAAM;AACtB,mBAAa,SAAS;AAAA,IACxB;AAEA,QAAI,iCAAQ,SAAS;AACnB;AAAA,IACF;AAEA,gBAAY,WAAW,MAAM;AAC3B,WAAK,GAAG,IAAI;AACZ,kBAAY;AAAA,IACd,GAAG,UAAU;AAAA,EACf;AAEA,QAAM,UAAU,WAAY;AAC1B,cAAU,OAAO;AAAA,EACnB;AAEA,YAAU,SAAS,WAAY;AAC7B,QAAI,cAAc,MAAM;AACtB,mBAAa,SAAS;AACtB,kBAAY;AAAA,IACd;AAAA,EACF;AAEA,mCAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK;AAExD,SAAO;AACT;;;AClEO,SAAS,OAAa;AAAC;;;ACQvB,SAAS,KAA0B,MAAY;AACpD,MAAI,SAAS;AACb,MAAI;AAEJ,SAAO,WAAY;AACjB,QAAI,QAAQ;AACV,aAAO;AAAA,IACT;AAEA,UAAM,SAAS,KAAK;AAEpB,aAAS;AACT,YAAQ;AAER,WAAO;AAAA,EACT;AACF;;;ACPO,SAAS,SAA6C,MAAS,YAAuB;AAC3F,MAAI;AAEJ,QAAM,oBAAoB,YAAa,MAAqB;AAC1D,UAAM,MAAM,KAAK,IAAI;AAErB,QAAI,gBAAgB,QAAQ,MAAM,gBAAgB,YAAY;AAC5D,qBAAe;AACf,WAAK,GAAG,IAAI;AAAA,IACd;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../../src/function/index.ts","../../src/function/debounce.ts","../../src/function/noop.ts","../../src/function/once.ts","../../src/function/throttle.ts","../../src/function/negate.ts"],"sourcesContent":["export { debounce } from './debounce.ts';\nexport { noop } from './noop.ts';\nexport { once } from './once.ts';\nexport { throttle } from './throttle.ts';\nexport { negate } from './negate.ts';\n","interface DebounceOptions {\n  signal?: AbortSignal;\n}\n\n/**\n * Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds\n * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`\n * method to cancel any pending execution.\n *\n * @template F - The type of function.\n * @param {F} func - The function to debounce.\n * @param {number} debounceMs - The number of milliseconds to delay.\n * @param {DebounceOptions} options - The options object.\n * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the debounced function.\n * @returns {F & { cancel: () => void }} A new debounced function with a `cancel` method.\n *\n * @example\n * const debouncedFunction = debounce(() => {\n *   console.log('Function executed');\n * }, 1000);\n *\n * // Will log 'Function executed' after 1 second if not called again in that time\n * debouncedFunction();\n *\n * // Will not log anything as the previous call is canceled\n * debouncedFunction.cancel();\n *\n * // With AbortSignal\n * const controller = new AbortController();\n * const signal = controller.signal;\n * const debouncedWithSignal = debounce(() => {\n *  console.log('Function executed');\n * }, 1000, { signal });\n *\n * debouncedWithSignal();\n *\n * // Will cancel the debounced function call\n * controller.abort();\n */\nexport function debounce<F extends (...args: any[]) => void>(\n  func: F,\n  debounceMs: number,\n  { signal }: DebounceOptions = {}\n): F & { cancel: () => void } {\n  let timeoutId: number | null = null;\n\n  const debounced = function (...args: Parameters<F>) {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n    }\n\n    if (signal?.aborted) {\n      return;\n    }\n\n    timeoutId = setTimeout(() => {\n      func(...args);\n      timeoutId = null;\n    }, debounceMs) as any;\n  } as F & { cancel: () => void };\n\n  const onAbort = function () {\n    debounced.cancel();\n  };\n\n  debounced.cancel = function () {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n      timeoutId = null;\n    }\n  };\n\n  signal?.addEventListener('abort', onAbort, { once: true });\n\n  return debounced;\n}\n","/**\n * A no-operation function that does nothing.\n * This can be used as a placeholder or default function.\n *\n * @example\n * noop(); // Does nothing\n *\n * @returns {void} This function does not return anything.\n */\nexport function noop(): void {}\n","/**\n * Creates a function that is restricted to invoking the provided function `func` once.\n * Repeated calls to the function will return the value from the first invocation.\n *\n * @template F - The type of function.\n * @param {F} func - The function to restrict.\n * @returns {F} A new function that invokes `func` once and caches the result.\n *\n * @example\n * const initialize = once(() => {\n *   console.log('Initialized!');\n *   return true;\n * });\n *\n * initialize(); // Logs: 'Initialized!' and returns true\n * initialize(); // Returns true without logging\n */\nexport function once<F extends () => any>(func: F): F {\n  let called = false;\n  let cache: ReturnType<F> | undefined;\n\n  return function () {\n    if (called) {\n      return cache;\n    }\n\n    const result = func();\n\n    called = true;\n    cache = result;\n\n    return result;\n  } as F;\n}\n","/**\n * Creates a throttled function that only invokes the provided function at most once\n * per every `throttleMs` milliseconds. Subsequent calls to the throttled function\n * within the wait time will not trigger the execution of the original function.\n *\n * @template F - The type of function.\n * @param {F} func - The function to throttle.\n * @param {number} throttleMs - The number of milliseconds to throttle executions to.\n * @returns {F} A new throttled function that accepts the same parameters as the original function.\n *\n * @example\n * const throttledFunction = throttle(() => {\n *   console.log('Function executed');\n * }, 1000);\n *\n * // Will log 'Function executed' immediately\n * throttledFunction();\n *\n * // Will not log anything as it is within the throttle time\n * throttledFunction();\n *\n * // After 1 second\n * setTimeout(() => {\n *   throttledFunction(); // Will log 'Function executed'\n * }, 1000);\n */\nexport function throttle<F extends (...args: any[]) => void>(func: F, throttleMs: number): F {\n  let lastCallTime: number | null;\n\n  const throttledFunction = function (...args: Parameters<F>) {\n    const now = Date.now();\n\n    if (lastCallTime == null || now - lastCallTime >= throttleMs) {\n      lastCallTime = now;\n      func(...args);\n    }\n  } as F;\n\n  return throttledFunction;\n}\n","/**\n * Creates a function that negates the result of the predicate function.\n *\n * @template F - The type of the function to negate.\n * @param {F} func - The function to negate.\n * @returns {F} The new negated function, which negates the boolean result of `func`.\n */\nexport function negate<F extends (...args: unknown[]) => boolean>(func: F): F {\n    return ((...args: any[]) => !func(...args)) as F;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACuCO,SAAS,SACd,MACA,YACA,EAAE,OAAO,IAAqB,CAAC,GACH;AAC5B,MAAI,YAA2B;AAE/B,QAAM,YAAY,YAAa,MAAqB;AAClD,QAAI,cAAc,MAAM;AACtB,mBAAa,SAAS;AAAA,IACxB;AAEA,QAAI,iCAAQ,SAAS;AACnB;AAAA,IACF;AAEA,gBAAY,WAAW,MAAM;AAC3B,WAAK,GAAG,IAAI;AACZ,kBAAY;AAAA,IACd,GAAG,UAAU;AAAA,EACf;AAEA,QAAM,UAAU,WAAY;AAC1B,cAAU,OAAO;AAAA,EACnB;AAEA,YAAU,SAAS,WAAY;AAC7B,QAAI,cAAc,MAAM;AACtB,mBAAa,SAAS;AACtB,kBAAY;AAAA,IACd;AAAA,EACF;AAEA,mCAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK;AAExD,SAAO;AACT;;;AClEO,SAAS,OAAa;AAAC;;;ACQvB,SAAS,KAA0B,MAAY;AACpD,MAAI,SAAS;AACb,MAAI;AAEJ,SAAO,WAAY;AACjB,QAAI,QAAQ;AACV,aAAO;AAAA,IACT;AAEA,UAAM,SAAS,KAAK;AAEpB,aAAS;AACT,YAAQ;AAER,WAAO;AAAA,EACT;AACF;;;ACPO,SAAS,SAA6C,MAAS,YAAuB;AAC3F,MAAI;AAEJ,QAAM,oBAAoB,YAAa,MAAqB;AAC1D,UAAM,MAAM,KAAK,IAAI;AAErB,QAAI,gBAAgB,QAAQ,MAAM,gBAAgB,YAAY;AAC5D,qBAAe;AACf,WAAK,GAAG,IAAI;AAAA,IACd;AAAA,EACF;AAEA,SAAO;AACT;;;AChCO,SAAS,OAAkD,MAAY;AAC1E,SAAQ,IAAI,SAAgB,CAAC,KAAK,GAAG,IAAI;AAC7C;","names":[]}

package/dist/function/index.mjs

@@ -1,7 +1,7 @@
-import "../chunk-N6EM6ETS.mjs";
+import "../chunk-236H5JZJ.mjs";
 import {
-  debounce
-} from "../chunk-3IP4JVLL.mjs";
+  negate
+} from "../chunk-BOOQBJN2.mjs";
 import {
   noop
 } from "../chunk-LKXCOLNY.mjs";
@@ -11,9 +11,13 @@ import {
 import {
   throttle
 } from "../chunk-QOJGMVVR.mjs";
-import "../chunk-2MM5EJJX.mjs";
+import {
+  debounce
+} from "../chunk-3IP4JVLL.mjs";
+import "../chunk-2HIMLZE3.mjs";
 export {
   debounce,
+  negate,
   noop,
   once,
   throttle

package/dist/function/negate.d.mts

@@ -0,0 +1,10 @@
+/**
+ * Creates a function that negates the result of the predicate function.
+ *
+ * @template F - The type of the function to negate.
+ * @param {F} func - The function to negate.
+ * @returns {F} The new negated function, which negates the boolean result of `func`.
+ */
+declare function negate<F extends (...args: unknown[]) => boolean>(func: F): F;
+
+export { negate };

package/dist/function/negate.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Creates a function that negates the result of the predicate function.
+ *
+ * @template F - The type of the function to negate.
+ * @param {F} func - The function to negate.
+ * @returns {F} The new negated function, which negates the boolean result of `func`.
+ */
+declare function negate<F extends (...args: unknown[]) => boolean>(func: F): F;
+
+export { negate };

package/dist/function/negate.js

@@ -0,0 +1,33 @@
+"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);
+
+// src/function/negate.ts
+var negate_exports = {};
+__export(negate_exports, {
+  negate: () => negate
+});
+module.exports = __toCommonJS(negate_exports);
+function negate(func) {
+  return (...args) => !func(...args);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  negate
+});
+//# sourceMappingURL=negate.js.map

package/dist/function/negate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/function/negate.ts"],"sourcesContent":["/**\n * Creates a function that negates the result of the predicate function.\n *\n * @template F - The type of the function to negate.\n * @param {F} func - The function to negate.\n * @returns {F} The new negated function, which negates the boolean result of `func`.\n */\nexport function negate<F extends (...args: unknown[]) => boolean>(func: F): F {\n    return ((...args: any[]) => !func(...args)) as F;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAOO,SAAS,OAAkD,MAAY;AAC1E,SAAQ,IAAI,SAAgB,CAAC,KAAK,GAAG,IAAI;AAC7C;","names":[]}

package/dist/function/negate.mjs

@@ -0,0 +1,8 @@
+import {
+  negate
+} from "../chunk-BOOQBJN2.mjs";
+import "../chunk-2HIMLZE3.mjs";
+export {
+  negate
+};
+//# sourceMappingURL=negate.mjs.map

package/dist/function/negate.mjs.map

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

package/dist/function/noop.mjs

@@ -1,7 +1,7 @@
 import {
   noop
 } from "../chunk-LKXCOLNY.mjs";
-import "../chunk-2MM5EJJX.mjs";
+import "../chunk-2HIMLZE3.mjs";
 export {
   noop
 };

package/dist/function/once.mjs

@@ -1,7 +1,7 @@
 import {
   once
 } from "../chunk-CMBC4MXG.mjs";
-import "../chunk-2MM5EJJX.mjs";
+import "../chunk-2HIMLZE3.mjs";
 export {
   once
 };

package/dist/function/throttle.mjs

@@ -1,7 +1,7 @@
 import {
   throttle
 } from "../chunk-QOJGMVVR.mjs";
-import "../chunk-2MM5EJJX.mjs";
+import "../chunk-2HIMLZE3.mjs";
 export {
   throttle
 };

package/dist/index.d.mts

@@ -10,6 +10,7 @@ export { dropRightWhile } from './array/dropRightWhile.mjs';
 export { dropWhile } from './array/dropWhile.mjs';
 export { fill } from './array/fill.mjs';
 export { flatten } from './array/flatten.mjs';
+export { flattenDeep } from './array/flattenDeep.mjs';
 export { forEachRight } from './array/forEachRight.mjs';
 export { groupBy } from './array/groupBy.mjs';
 export { intersection } from './array/intersection.mjs';
@@ -44,11 +45,15 @@ export { zipWith } from './array/zipWith.mjs';
 export { without } from './array/without.mjs';
 export { head } from './array/head.mjs';
 export { tail } from './array/tail.mjs';
+export { toFilled } from './array/toFilled.mjs';
+export { last } from './array/last.mjs';
+export { initial } from './array/initial.mjs';
 export { AbortError } from './error/AbortError.mjs';
 export { debounce } from './function/debounce.mjs';
 export { noop } from './function/noop.mjs';
 export { once } from './function/once.mjs';
 export { throttle } from './function/throttle.mjs';
+export { negate } from './function/negate.mjs';
 export { clamp } from './math/clamp.mjs';
 export { inRange } from './math/inRange.mjs';
 export { mean } from './math/mean.mjs';
@@ -63,8 +68,15 @@ export { omitBy } from './object/omitBy.mjs';
 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 { 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 { delay } from './promise/delay.mjs';
+export { camelCase } from './string/camelCase.mjs';
+export { snakeCase } from './string/snakeCase.mjs';
+export { kebabCase } from './string/kebabCase.mjs';
+export { lowerCase } from './string/lowerCase.mjs';
+export { capitalize } from './string/capitalize.mjs';

package/dist/index.d.ts

@@ -10,6 +10,7 @@ export { dropRightWhile } from './array/dropRightWhile.js';
 export { dropWhile } from './array/dropWhile.js';
 export { fill } from './array/fill.js';
 export { flatten } from './array/flatten.js';
+export { flattenDeep } from './array/flattenDeep.js';
 export { forEachRight } from './array/forEachRight.js';
 export { groupBy } from './array/groupBy.js';
 export { intersection } from './array/intersection.js';
@@ -44,11 +45,15 @@ export { zipWith } from './array/zipWith.js';
 export { without } from './array/without.js';
 export { head } from './array/head.js';
 export { tail } from './array/tail.js';
+export { toFilled } from './array/toFilled.js';
+export { last } from './array/last.js';
+export { initial } from './array/initial.js';
 export { AbortError } from './error/AbortError.js';
 export { debounce } from './function/debounce.js';
 export { noop } from './function/noop.js';
 export { once } from './function/once.js';
 export { throttle } from './function/throttle.js';
+export { negate } from './function/negate.js';
 export { clamp } from './math/clamp.js';
 export { inRange } from './math/inRange.js';
 export { mean } from './math/mean.js';
@@ -63,8 +68,15 @@ export { omitBy } from './object/omitBy.js';
 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 { 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 { delay } from './promise/delay.js';
+export { camelCase } from './string/camelCase.js';
+export { snakeCase } from './string/snakeCase.js';
+export { kebabCase } from './string/kebabCase.js';
+export { lowerCase } from './string/lowerCase.js';
+export { capitalize } from './string/capitalize.js';