es-toolkit 1.9.0 → 1.10.0-dev.204

package/dist/chunk-ASJF5D6C.mjs

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

package/dist/chunk-ASJF5D6C.mjs.map

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

package/dist/chunk-BOOQBJN2.mjs

@@ -0,0 +1,9 @@
+// src/function/negate.ts
+function negate(func) {
+  return (...args) => !func(...args);
+}
+
+export {
+  negate
+};
+//# sourceMappingURL=chunk-BOOQBJN2.mjs.map

package/dist/chunk-BOOQBJN2.mjs.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":";AAOO,SAAS,OAAkD,MAAY;AAC1E,SAAQ,IAAI,SAAgB,CAAC,KAAK,GAAG,IAAI;AAC7C;","names":[]}

package/dist/chunk-EYYZQFOP.mjs

@@ -0,0 +1,14 @@
+import {
+  getWords
+} from "./chunk-WVQ7YVRK.mjs";
+
+// src/string/kebabCase.ts
+var kebabCase = (str) => {
+  const words = getWords(str);
+  return words.map((word) => word.toLowerCase()).join("-");
+};
+
+export {
+  kebabCase
+};
+//# sourceMappingURL=chunk-EYYZQFOP.mjs.map

package/dist/chunk-EYYZQFOP.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/string/kebabCase.ts"],"sourcesContent":["import { getWords } from './_internal/getWords.ts';\n\n/**\n * Converts a string to kebab case.\n *\n * Kebab case is the naming convention in which each word is written in lowercase and separated by a dash (-) character.\n *\n * @param {string} str - The string that is to be changed to kebab case.\n * @returns {string} - The converted string to kebab case.\n *\n * @example\n * const convertedStr1 = kebabCase('camelCase') // returns 'camel-case'\n * const convertedStr2 = kebabCase('some whitespace') // returns 'some-whitespace'\n * const convertedStr3 = kebabCase('hyphen-text') // returns 'hyphen-text'\n * const convertedStr4 = kebabCase('HTTPRequest') // returns 'http-request'\n */\n\nexport const kebabCase = (str: string): string => {\n  const words = getWords(str);\n  return words.map(word => word.toLowerCase()).join('-');\n};\n"],"mappings":";;;;;AAiBO,IAAM,YAAY,CAAC,QAAwB;AAChD,QAAM,QAAQ,SAAS,GAAG;AAC1B,SAAO,MAAM,IAAI,UAAQ,KAAK,YAAY,CAAC,EAAE,KAAK,GAAG;AACvD;","names":[]}

package/dist/chunk-F3WCQQET.mjs

@@ -0,0 +1,14 @@
+import {
+  getWords
+} from "./chunk-WVQ7YVRK.mjs";
+
+// src/string/snakeCase.ts
+var snakeCase = (str) => {
+  const words = getWords(str);
+  return words.map((word) => word.toLowerCase()).join("_");
+};
+
+export {
+  snakeCase
+};
+//# sourceMappingURL=chunk-F3WCQQET.mjs.map

package/dist/chunk-F3WCQQET.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/string/snakeCase.ts"],"sourcesContent":["import { getWords } from './_internal/getWords.ts';\n\n/**\n * Converts a string to snake case.\n *\n * Snake case is the naming convention in which each word is written in lowercase and separated by an underscore (_) character.\n *\n * @param {string} str - The string that is to be changed to snake case.\n * @returns {string} - The converted string to snake case.\n *\n * @example\n * const convertedStr1 = snakeCase('camelCase') // returns 'camel_case'\n * const convertedStr2 = snakeCase('some whitespace') // returns 'some_whitespace'\n * const convertedStr3 = snakeCase('hyphen-text') // returns 'hyphen_text'\n * const convertedStr4 = snakeCase('HTTPRequest') // returns 'http_request'\n */\n\nexport const snakeCase = (str: string): string => {\n  const words = getWords(str);\n  return words.map(word => word.toLowerCase()).join('_');\n};\n"],"mappings":";;;;;AAiBO,IAAM,YAAY,CAAC,QAAwB;AAChD,QAAM,QAAQ,SAAS,GAAG;AAC1B,SAAO,MAAM,IAAI,UAAQ,KAAK,YAAY,CAAC,EAAE,KAAK,GAAG;AACvD;","names":[]}

package/dist/{chunk-LT6E4Y4Z.mjs → chunk-GDC64SYJ.mjs}

@@ -1,6 +1,6 @@
 import {
   sum
-} from "./chunk-NOFHNJ5C.mjs";
+} from "./chunk-2SLTL4KL.mjs";
 
 // src/math/mean.ts
 function mean(nums) {
@@ -10,4 +10,4 @@ function mean(nums) {
 export {
   mean
 };
-//# sourceMappingURL=chunk-LT6E4Y4Z.mjs.map
+//# sourceMappingURL=chunk-GDC64SYJ.mjs.map

package/dist/{chunk-SDIMTYZW.mjs → chunk-IZAD2S7R.mjs}

@@ -1,6 +1,6 @@
 import {
   mean
-} from "./chunk-LT6E4Y4Z.mjs";
+} from "./chunk-GDC64SYJ.mjs";
 
 // src/math/meanBy.ts
 function meanBy(items, getValue) {
@@ -11,4 +11,4 @@ function meanBy(items, getValue) {
 export {
   meanBy
 };
-//# sourceMappingURL=chunk-SDIMTYZW.mjs.map
+//# sourceMappingURL=chunk-IZAD2S7R.mjs.map

package/dist/chunk-JYSV56US.mjs

@@ -0,0 +1,41 @@
+import {
+  union
+} from "./chunk-R6QA7PLZ.mjs";
+
+// 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;
+}
+
+export {
+  isEqual
+};
+//# sourceMappingURL=chunk-JYSV56US.mjs.map

package/dist/chunk-JYSV56US.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/predicate/isEqual.ts"],"sourcesContent":["import { union } from \"../array/union.ts\";\n\n/**\n * Checks if two values are equal, including support for `Date`, `RegExp`, and deep object comparison.\n *\n * @param {unknown} a - The first value to compare.\n * @param {unknown} b - The second value to compare.\n * @returns {boolean} `true` if the values are equal, otherwise `false`.\n *\n * @example\n * isEqual(1, 1); // true\n * isEqual({ a: 1 }, { a: 1 }); // true\n * isEqual(/abc/g, /abc/g); // true\n * isEqual(new Date('2020-01-01'), new Date('2020-01-01')); // true\n * isEqual([1, 2, 3], [1, 2, 3]); // true\n */\nexport function isEqual(a: unknown, b: unknown): boolean {\n  if (Object.is(a, b)) {\n    return true;\n  }\n\n  if (a instanceof Date && b instanceof Date) {\n    return a.getTime() === b.getTime();\n  }\n\n  if (a instanceof RegExp && b instanceof RegExp) {\n    return a.source === b.source && a.flags === b.flags;\n  }\n\n  if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null) {\n    return false;\n  }\n\n  const aKeys = Object.keys(a as object);\n  const bKeys = Object.keys(b as object);\n\n  if (aKeys.length !== bKeys.length) {\n    return false;\n  }\n\n  // check if all keys in both arrays match\n  if (union(aKeys, bKeys).length !== aKeys.length) {\n    return false;\n  }\n\n  for (let i = 0; i < aKeys.length; i++) {\n    const propKey = aKeys[i];\n    const aProp = (a as any)[propKey];\n    const bProp = (b as any)[propKey];\n    \n    if (!isEqual(aProp, bProp)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n"],"mappings":";;;;;AAgBO,SAAS,QAAQ,GAAY,GAAqB;AACvD,MAAI,OAAO,GAAG,GAAG,CAAC,GAAG;AACnB,WAAO;AAAA,EACT;AAEA,MAAI,aAAa,QAAQ,aAAa,MAAM;AAC1C,WAAO,EAAE,QAAQ,MAAM,EAAE,QAAQ;AAAA,EACnC;AAEA,MAAI,aAAa,UAAU,aAAa,QAAQ;AAC9C,WAAO,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,EAAE;AAAA,EAChD;AAEA,MAAI,OAAO,MAAM,YAAY,OAAO,MAAM,YAAY,MAAM,QAAQ,MAAM,MAAM;AAC9E,WAAO;AAAA,EACT;AAEA,QAAM,QAAQ,OAAO,KAAK,CAAW;AACrC,QAAM,QAAQ,OAAO,KAAK,CAAW;AAErC,MAAI,MAAM,WAAW,MAAM,QAAQ;AACjC,WAAO;AAAA,EACT;AAGA,MAAI,MAAM,OAAO,KAAK,EAAE,WAAW,MAAM,QAAQ;AAC/C,WAAO;AAAA,EACT;AAEA,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrC,UAAM,UAAU,MAAM,CAAC;AACvB,UAAM,QAAS,EAAU,OAAO;AAChC,UAAM,QAAS,EAAU,OAAO;AAEhC,QAAI,CAAC,QAAQ,OAAO,KAAK,GAAG;AAC1B,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-KPBQ7OUY.mjs

@@ -0,0 +1,9 @@
+// src/array/last.ts
+function last(arr) {
+  return arr[arr.length - 1];
+}
+
+export {
+  last
+};
+//# sourceMappingURL=chunk-KPBQ7OUY.mjs.map

package/dist/chunk-KPBQ7OUY.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/array/last.ts"],"sourcesContent":["/**\n * Returns the last element of an array.\n *\n * This function takes an array and returns the last element of the array.\n * If the array is empty, the function returns `undefined`.\n *\n * Unlike some implementations, this function is optimized for performance\n * by directly accessing the last index of the array.\n *\n * @param {T[]} arr - The array from which to get the last element.\n * @returns {T | undefined} The last element of the array, or `undefined` if the array is empty.\n *\n * @example\n * const arr = [1, 2, 3];\n * const lastElement = last(arr);\n * // lastElement will be 3\n *\n * const emptyArr: number[] = [];\n * const noElement = last(emptyArr);\n * // noElement will be undefined\n */\n\nexport function last<T>(arr: readonly [...T[], T]): T;\nexport function last<T>(arr: readonly T[]): T | undefined;\nexport function last<T>(arr: readonly T[]): T | undefined {\n  return arr[arr.length - 1];\n}\n"],"mappings":";AAwBO,SAAS,KAAQ,KAAkC;AACxD,SAAO,IAAI,IAAI,SAAS,CAAC;AAC3B;","names":[]}

package/dist/chunk-ML727RRJ.mjs

@@ -0,0 +1,13 @@
+import {
+  flatten
+} from "./chunk-33MSBDC6.mjs";
+
+// src/array/flattenDeep.ts
+function flattenDeep(arr) {
+  return flatten(arr, Infinity);
+}
+
+export {
+  flattenDeep
+};
+//# sourceMappingURL=chunk-ML727RRJ.mjs.map

package/dist/chunk-ML727RRJ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/array/flattenDeep.ts"],"sourcesContent":["import { flatten } from './flatten.ts';\n\n/**\n * Utility type for recursively unpacking nested array types to extract the type of the innermost element\n *\n * @example\n * ExtractNestedArrayType<(number | (number | number[])[])[]>\n * // number\n *\n * ExtractNestedArrayType<(boolean | (string | number[])[])[]>\n * // string | number | boolean\n */\ntype ExtractNestedArrayType<T> = T extends ReadonlyArray<infer U> ? ExtractNestedArrayType<U> : T;\n\n/**\n * Flattens all depths of a nested array.\n *\n * @template T - The type of elements within the array.\n * @param {T[]} arr - The array to flatten.\n * @returns {Array<ExtractNestedArrayType<T>>} A new array that has been flattened.\n *\n * @example\n * const arr = flattenDeep([1, [2, [3]], [4, [5, 6]]]);\n * // Returns: [1, 2, 3, 4, 5, 6]\n */\nexport function flattenDeep<T>(arr: readonly T[]): Array<ExtractNestedArrayType<T>> {\n  return flatten(arr, Infinity) as Array<ExtractNestedArrayType<T>>;\n}\n"],"mappings":";;;;;AAyBO,SAAS,YAAe,KAAqD;AAClF,SAAO,QAAQ,KAAK,QAAQ;AAC9B;","names":[]}

package/dist/chunk-NKLIE2OI.mjs

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

package/dist/chunk-NKLIE2OI.mjs.map

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

package/dist/chunk-OP4OAKQJ.mjs

@@ -0,0 +1,16 @@
+// src/array/toFilled.ts
+function toFilled(arr, value, start = 0, end = arr.length) {
+  const length = arr.length;
+  const finalStart = Math.max(start >= 0 ? start : length + start, 0);
+  const finalEnd = Math.min(end >= 0 ? end : length + end, length);
+  const newArr = arr.slice();
+  for (let i = finalStart; i < finalEnd; i++) {
+    newArr[i] = value;
+  }
+  return newArr;
+}
+
+export {
+  toFilled
+};
+//# sourceMappingURL=chunk-OP4OAKQJ.mjs.map

package/dist/chunk-OP4OAKQJ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/array/toFilled.ts"],"sourcesContent":["/**\n * Creates a new array filled with the specified value from the start position up to, but not including, the end position.\n * This function does not mutate the original array.\n *\n * @param {Array<T>} arr - The array to base the new array on.\n * @param {U} value - The value to fill the new array with.\n * @param {number} [start=0] - The start position. Defaults to 0.\n * @param {number} [end=arr.length] - The end position. Defaults to the array's length.\n * @returns {Array<T | U>} The new array with the filled values.\n *\n * @example\n * const array = [1, 2, 3, 4, 5];\n * let result = toFilled(array, '*', 2);\n * console.log(result); // [1, 2, '*', '*', '*']\n * console.log(array); // [1, 2, 3, 4, 5]\n *\n * result = toFilled(array, '*', 1, 4);\n * console.log(result); // [1, '*', '*', '*', 5]\n * console.log(array); // [1, 2, 3, 4, 5]\n *\n * result = toFilled(array, '*');\n * console.log(result); // ['*', '*', '*', '*', '*']\n * console.log(array); // [1, 2, 3, 4, 5]\n *\n * result = toFilled(array, '*', -4, -1);\n * console.log(result); // [1, '*', '*', '*', 5]\n * console.log(array); // [1, 2, 3, 4, 5]\n */\n\nexport function toFilled<T, U>(arr: T[], value: U): Array<T | U>;\nexport function toFilled<T, U>(arr: T[], value: U, start: number): Array<T | U>;\nexport function toFilled<T, U>(arr: T[], value: U, start: number, end: number): Array<T | U>;\nexport function toFilled<T, U>(arr: T[], value: U, start = 0, end = arr.length): Array<T | U> {\n  const length = arr.length;\n  const finalStart = Math.max(start >= 0 ? start : length + start, 0);\n  const finalEnd = Math.min(end >= 0 ? end : length + end, length);\n\n  const newArr: Array<T | U> = arr.slice();\n\n  for (let i = finalStart; i < finalEnd; i++) {\n    newArr[i] = value;\n  }\n\n  return newArr;\n}\n"],"mappings":";AAgCO,SAAS,SAAe,KAAU,OAAU,QAAQ,GAAG,MAAM,IAAI,QAAsB;AAC5F,QAAM,SAAS,IAAI;AACnB,QAAM,aAAa,KAAK,IAAI,SAAS,IAAI,QAAQ,SAAS,OAAO,CAAC;AAClE,QAAM,WAAW,KAAK,IAAI,OAAO,IAAI,MAAM,SAAS,KAAK,MAAM;AAE/D,QAAM,SAAuB,IAAI,MAAM;AAEvC,WAAS,IAAI,YAAY,IAAI,UAAU,KAAK;AAC1C,WAAO,CAAC,IAAI;AAAA,EACd;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-OSOLEQLZ.mjs

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

package/dist/chunk-OSOLEQLZ.mjs.map

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

package/dist/chunk-QKYYOLJ6.mjs

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

package/dist/chunk-QKYYOLJ6.mjs.map

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

package/dist/chunk-U4JGKZ56.mjs

@@ -0,0 +1,41 @@
+// src/object/clone.ts
+function clone(obj) {
+  if (isPrimitive(obj)) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.slice();
+  }
+  if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+  if (obj instanceof RegExp) {
+    return new RegExp(obj.source, obj.flags);
+  }
+  if (obj instanceof Map) {
+    const result = /* @__PURE__ */ new Map();
+    for (const [key, value] of obj) {
+      result.set(key, value);
+    }
+    return result;
+  }
+  if (obj instanceof Set) {
+    const result = /* @__PURE__ */ new Set();
+    for (const value of obj) {
+      result.add(value);
+    }
+    return result;
+  }
+  if (typeof obj === "object") {
+    return Object.assign({}, obj);
+  }
+  return obj;
+}
+function isPrimitive(value) {
+  return value == null || typeof value !== "object" && typeof value !== "function";
+}
+
+export {
+  clone
+};
+//# sourceMappingURL=chunk-U4JGKZ56.mjs.map

package/dist/chunk-U4JGKZ56.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/object/clone.ts"],"sourcesContent":["/**\n * Creates a shallow clone of the given object.\n *\n * @template T - The type of the object.\n * @param {T} obj - The object to clone.\n * @returns {T} - A shallow clone of the given object.\n *\n * @example\n * // Clone a primitive values\n * const num = 29;\n * const clonedNum = clone(num);\n * console.log(clonedNum); // 29\n * console.log(clonedNum === num) ; // true\n *\n * @example\n * // Clone an array\n * const arr = [1, 2, 3];\n * const clonedArr = clone(arr);\n * console.log(clonedArr); // [1, 2, 3]\n * console.log(clonedArr === arr); // false\n *\n * @example\n * // Clone an object\n * const obj = { a: 1, b: 'es-toolkit', c: [1, 2, 3] };\n * const clonedObj = clone(obj);\n * console.log(clonedObj); // { a: 1, b: 'es-toolkit', c: [1, 2, 3] }\n * console.log(clonedObj === obj); // false\n */\nexport function clone<T>(obj: T): T {\n  if (isPrimitive(obj)) {\n    return obj;\n  }\n\n  if (Array.isArray(obj)) {\n    return obj.slice() as T;\n  }\n\n  if (obj instanceof Date) {\n    return new Date(obj.getTime()) as T;\n  }\n\n  if (obj instanceof RegExp) {\n    return new RegExp(obj.source, obj.flags) as T;\n  }\n\n  if (obj instanceof Map) {\n    const result = new Map();\n    for (const [key, value] of obj) {\n      result.set(key, value);\n    }\n    return result as T;\n  }\n\n  if (obj instanceof Set) {\n    const result = new Set();\n    for (const value of obj) {\n      result.add(value);\n    }\n    return result as T;\n  }\n\n  if (typeof obj === \"object\") {\n    return Object.assign({}, obj) as T;\n  }\n  return obj;\n}\n\ntype Primitive = null | undefined | string | number | boolean | symbol | bigint;\n\nfunction isPrimitive(value: unknown): value is Primitive {\n  return value == null ||\n    (typeof value !== \"object\" && typeof value !== \"function\");\n}\n"],"mappings":";AA4BO,SAAS,MAAS,KAAW;AAClC,MAAI,YAAY,GAAG,GAAG;AACpB,WAAO;AAAA,EACT;AAEA,MAAI,MAAM,QAAQ,GAAG,GAAG;AACtB,WAAO,IAAI,MAAM;AAAA,EACnB;AAEA,MAAI,eAAe,MAAM;AACvB,WAAO,IAAI,KAAK,IAAI,QAAQ,CAAC;AAAA,EAC/B;AAEA,MAAI,eAAe,QAAQ;AACzB,WAAO,IAAI,OAAO,IAAI,QAAQ,IAAI,KAAK;AAAA,EACzC;AAEA,MAAI,eAAe,KAAK;AACtB,UAAM,SAAS,oBAAI,IAAI;AACvB,eAAW,CAAC,KAAK,KAAK,KAAK,KAAK;AAC9B,aAAO,IAAI,KAAK,KAAK;AAAA,IACvB;AACA,WAAO;AAAA,EACT;AAEA,MAAI,eAAe,KAAK;AACtB,UAAM,SAAS,oBAAI,IAAI;AACvB,eAAW,SAAS,KAAK;AACvB,aAAO,IAAI,KAAK;AAAA,IAClB;AACA,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,QAAQ,UAAU;AAC3B,WAAO,OAAO,OAAO,CAAC,GAAG,GAAG;AAAA,EAC9B;AACA,SAAO;AACT;AAIA,SAAS,YAAY,OAAoC;AACvD,SAAO,SAAS,QACb,OAAO,UAAU,YAAY,OAAO,UAAU;AACnD;","names":[]}

package/dist/chunk-U56ZOM7L.mjs

@@ -0,0 +1,9 @@
+// src/string/capitalize.ts
+var capitalize = (str) => {
+  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+};
+
+export {
+  capitalize
+};
+//# sourceMappingURL=chunk-U56ZOM7L.mjs.map

package/dist/chunk-U56ZOM7L.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/string/capitalize.ts"],"sourcesContent":["/**\n * Converts the first character of string to upper case and the remaining to lower case.\n *\n * @template T - Literal type of the string.\n * @param {T} str - The string to be converted to uppercase.\n * @returns {Capitalize<T>} - The capitalized string.\n *\n * @example\n * const result = capitalize('fred') // returns 'Fred'\n * const result2 = capitalize('FRED') // returns 'Fred'\n */\n\nexport const capitalize = <T extends string>(str: T): Capitalize<T> => {\n  return (str.charAt(0).toUpperCase() + str.slice(1).toLowerCase()) as Capitalize<T>;\n};\n"],"mappings":";AAYO,IAAM,aAAa,CAAmB,QAA0B;AACrE,SAAQ,IAAI,OAAO,CAAC,EAAE,YAAY,IAAI,IAAI,MAAM,CAAC,EAAE,YAAY;AACjE;","names":[]}

package/dist/chunk-WMM7TZLG.mjs

@@ -0,0 +1,9 @@
+// src/predicate/isNil.ts
+function isNil(x) {
+  return x == null;
+}
+
+export {
+  isNil
+};
+//# sourceMappingURL=chunk-WMM7TZLG.mjs.map

package/dist/{chunk-OHQAR5AU.mjs.map → chunk-WMM7TZLG.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/predicate/isNil.ts"],"sourcesContent":["/**\n * Checks if a given value is null or undefined.\n *\n * This function tests whether the provided value is either `null` or `undefined`.\n * It returns `true` if the value is `null` or `undefined`, and `false` otherwise.\n *\n * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `null` or `undefined`.\n *\n * @param {unknown} x - The value to test for null or undefined.\n * @returns {boolean} `true` if the value is null or undefined, `false` otherwise.\n *\n * @example\n * const value1 = null;\n * const value2 = undefined;\n * const value3 = 42;\n * const result1 = isNil(value1); // true\n * const result2 = isNil(value2); // true\n * const result3 = isNil(value3); // false\n */\nexport function isNil(x: unknown): x is null | undefined {\n  return x === null || x === undefined;\n}\n"],"mappings":";AAmBO,SAAS,MAAM,GAAmC;AACvD,SAAO,MAAM,QAAQ,MAAM;AAC7B;","names":[]}
+{"version":3,"sources":["../src/predicate/isNil.ts"],"sourcesContent":["/**\n * Checks if a given value is null or undefined.\n *\n * This function tests whether the provided value is either `null` or `undefined`.\n * It returns `true` if the value is `null` or `undefined`, and `false` otherwise.\n *\n * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `null` or `undefined`.\n *\n * @param {unknown} x - The value to test for null or undefined.\n * @returns {boolean} `true` if the value is null or undefined, `false` otherwise.\n *\n * @example\n * const value1 = null;\n * const value2 = undefined;\n * const value3 = 42;\n * const result1 = isNil(value1); // true\n * const result2 = isNil(value2); // true\n * const result3 = isNil(value3); // false\n */\nexport function isNil(x: unknown): x is null | undefined {\n  return x == null;\n}\n"],"mappings":";AAmBO,SAAS,MAAM,GAAmC;AACvD,SAAO,KAAK;AACd;","names":[]}

package/dist/chunk-WVQ7YVRK.mjs

@@ -0,0 +1,11 @@
+// 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 : []);
+}
+
+export {
+  getWords
+};
+//# sourceMappingURL=chunk-WVQ7YVRK.mjs.map

package/dist/chunk-WVQ7YVRK.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/string/_internal/getWords.ts"],"sourcesContent":["/**\n * Regular expression pattern to split strings into words for various case conversions\n *\n * This pattern matchs sequences of characters in a string, considering the following case:\n * - Sequences of two or more uppercase letters followed by an uppercase letter and lowercase letters or digits (for acronyms)\n * - Sequences of one uppercase letter optionally followed by lowercase letters and digits\n * - Single uppercase letters\n * - Sequences of digis\n *\n * The resulting match can be used to convert camelCase, snake_case, kebab-case, and other mixed formats into\n * a consistent format like snake case.\n *\n * @example\n * const matches = 'camelCaseHTTPRequest'.match(CASE_SPLIT_PATTERN);\n * // matchs: ['camel', 'Case', 'HTTP', 'Request']\n */\nconst CASE_SPLIT_PATTERN = /[A-Z]?[a-z]+|[0-9]+|[A-Z]+(?![a-z])/g;\n\nexport function getWords(str: string): string[] {\n  return Array.from(str.match(CASE_SPLIT_PATTERN) ?? []);\n}\n"],"mappings":";AAgBA,IAAM,qBAAqB;AAEpB,SAAS,SAAS,KAAuB;AAlBhD;AAmBE,SAAO,MAAM,MAAK,SAAI,MAAM,kBAAkB,MAA5B,YAAiC,CAAC,CAAC;AACvD;","names":[]}