es-toolkit 1.9.0-dev.186 → 1.9.0-dev.188

package/dist/index.mjs

@@ -3,38 +3,33 @@ import {
   delay
 } from "./chunk-O64NE2P4.mjs";
 import "./chunk-HXGADE4C.mjs";
-import {
-  snakeCase
-} from "./chunk-47QP3LTV.mjs";
 import {
   capitalize
 } from "./chunk-U56ZOM7L.mjs";
 import {
   kebabCase
-} from "./chunk-XWJ7NQF4.mjs";
+} from "./chunk-TOORJ7XR.mjs";
 import {
   lowerCase
-} from "./chunk-KPFMOZXV.mjs";
-import "./chunk-MAJSPFA6.mjs";
-import {
-  isNull
-} from "./chunk-AIRSKN47.mjs";
+} from "./chunk-55NY5XRN.mjs";
 import {
-  isUndefined
-} from "./chunk-VH2PV426.mjs";
+  snakeCase
+} from "./chunk-R7WI75UB.mjs";
+import "./chunk-SG4W5PWM.mjs";
+import "./chunk-MAJSPFA6.mjs";
 import {
   isNil
 } from "./chunk-OHQAR5AU.mjs";
 import {
   isNotNil
 } from "./chunk-BMRTZMRE.mjs";
-import "./chunk-PMHULJNL.mjs";
 import {
-  invert
-} from "./chunk-74WWMNZS.mjs";
+  isNull
+} from "./chunk-AIRSKN47.mjs";
 import {
-  omit
-} from "./chunk-QZITBKWX.mjs";
+  isUndefined
+} from "./chunk-VH2PV426.mjs";
+import "./chunk-PMHULJNL.mjs";
 import {
   omitBy
 } from "./chunk-BCTYOXT7.mjs";
@@ -44,35 +39,35 @@ import {
 import {
   pickBy
 } from "./chunk-6CLH5YZ2.mjs";
-import "./chunk-TLVQSNOE.mjs";
 import {
-  meanBy
-} from "./chunk-IZAD2S7R.mjs";
+  invert
+} from "./chunk-74WWMNZS.mjs";
 import {
-  mean
-} from "./chunk-GDC64SYJ.mjs";
+  omit
+} from "./chunk-QZITBKWX.mjs";
+import "./chunk-TLVQSNOE.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 "./chunk-2MRZANXZ.mjs";
 import {
-  xorBy
-} from "./chunk-Q47NGNXT.mjs";
+  meanBy
+} from "./chunk-IZAD2S7R.mjs";
 import {
-  xorWith
-} from "./chunk-QRSJBBFY.mjs";
+  mean
+} from "./chunk-GDC64SYJ.mjs";
+import {
+  sum
+} from "./chunk-2SLTL4KL.mjs";
+import "./chunk-2MRZANXZ.mjs";
 import {
   zip
 } from "./chunk-IDCUZVJL.mjs";
@@ -82,15 +77,9 @@ import {
 import {
   zipWith
 } from "./chunk-4KYXHZ4R.mjs";
-import {
-  unionWith
-} from "./chunk-2ZCITDMK.mjs";
 import {
   uniqBy
 } from "./chunk-OXAZEEGP.mjs";
-import {
-  uniqWith
-} from "./chunk-237HGSZS.mjs";
 import {
   unzip
 } from "./chunk-UYZKMBDO.mjs";
@@ -104,11 +93,11 @@ import {
   xor
 } from "./chunk-L7FQX5MN.mjs";
 import {
-  tail
-} from "./chunk-OF6NM4G7.mjs";
+  xorBy
+} from "./chunk-Q47NGNXT.mjs";
 import {
-  take
-} from "./chunk-ME352XO7.mjs";
+  xorWith
+} from "./chunk-QRSJBBFY.mjs";
 import {
   takeRight
 } from "./chunk-IQLKIDXF.mjs";
@@ -124,18 +113,18 @@ import {
 import {
   union
 } from "./chunk-R6QA7PLZ.mjs";
-import {
-  uniq
-} from "./chunk-DVK2N4KC.mjs";
 import {
   unionBy
 } from "./chunk-NFS7RWWE.mjs";
 import {
-  last
-} from "./chunk-KPBQ7OUY.mjs";
+  unionWith
+} from "./chunk-2ZCITDMK.mjs";
 import {
-  maxBy
-} from "./chunk-OOKNBU4V.mjs";
+  uniqWith
+} from "./chunk-237HGSZS.mjs";
+import {
+  uniq
+} from "./chunk-DVK2N4KC.mjs";
 import {
   minBy
 } from "./chunk-IJD7FE2Z.mjs";
@@ -161,11 +150,11 @@ import {
   shuffle
 } from "./chunk-G7UQ5PUR.mjs";
 import {
-  groupBy
-} from "./chunk-E6E4RZLN.mjs";
+  tail
+} from "./chunk-OF6NM4G7.mjs";
 import {
-  head
-} from "./chunk-HM2JT2RX.mjs";
+  take
+} from "./chunk-ME352XO7.mjs";
 import {
   initial
 } from "./chunk-XPSOKBRZ.mjs";
@@ -182,11 +171,11 @@ import {
   keyBy
 } from "./chunk-AJKZMN2V.mjs";
 import {
-  drop
-} from "./chunk-S3CORED5.mjs";
+  last
+} from "./chunk-KPBQ7OUY.mjs";
 import {
-  dropRight
-} from "./chunk-JEKUA56R.mjs";
+  maxBy
+} from "./chunk-OOKNBU4V.mjs";
 import {
   dropRightWhile
 } from "./chunk-JE6JKZU3.mjs";
@@ -198,13 +187,19 @@ import {
 } from "./chunk-C4WE4GLC.mjs";
 import {
   flattenDeep
-} from "./chunk-HJPB4KC3.mjs";
+} from "./chunk-ML727RRJ.mjs";
 import {
   flatten
 } from "./chunk-33MSBDC6.mjs";
 import {
   forEachRight
 } from "./chunk-IEA53J7P.mjs";
+import {
+  groupBy
+} from "./chunk-E6E4RZLN.mjs";
+import {
+  head
+} from "./chunk-HM2JT2RX.mjs";
 import {
   chunk
 } from "./chunk-E6C5EZQA.mjs";
@@ -223,25 +218,29 @@ import {
 import {
   differenceWith
 } from "./chunk-6NVQAHXP.mjs";
-import "./chunk-2M3YVRFS.mjs";
-import "./chunk-IJJCMZIV.mjs";
+import {
+  drop
+} from "./chunk-S3CORED5.mjs";
+import {
+  dropRight
+} from "./chunk-JEKUA56R.mjs";
 import "./chunk-FZEZH22H.mjs";
 import {
   AbortError
 } from "./chunk-DXB7EZUQ.mjs";
 import "./chunk-N6EM6ETS.mjs";
-import {
-  once
-} from "./chunk-CMBC4MXG.mjs";
-import {
-  throttle
-} from "./chunk-QOJGMVVR.mjs";
 import {
   debounce
 } from "./chunk-3IP4JVLL.mjs";
 import {
   noop
 } from "./chunk-LKXCOLNY.mjs";
+import {
+  once
+} from "./chunk-CMBC4MXG.mjs";
+import {
+  throttle
+} from "./chunk-QOJGMVVR.mjs";
 import "./chunk-2MM5EJJX.mjs";
 export {
   AbortError,

package/dist/math/index.mjs

@@ -1,25 +1,25 @@
 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 {
+  meanBy
+} from "../chunk-IZAD2S7R.mjs";
+import {
+  mean
+} from "../chunk-GDC64SYJ.mjs";
+import {
+  sum
+} from "../chunk-2SLTL4KL.mjs";
 import {
   randomInt
 } from "../chunk-GIWAOOFY.mjs";

package/dist/object/index.mjs

@@ -1,10 +1,4 @@
 import "../chunk-PMHULJNL.mjs";
-import {
-  invert
-} from "../chunk-74WWMNZS.mjs";
-import {
-  omit
-} from "../chunk-QZITBKWX.mjs";
 import {
   omitBy
 } from "../chunk-BCTYOXT7.mjs";
@@ -14,6 +8,12 @@ import {
 import {
   pickBy
 } from "../chunk-6CLH5YZ2.mjs";
+import {
+  invert
+} from "../chunk-74WWMNZS.mjs";
+import {
+  omit
+} from "../chunk-QZITBKWX.mjs";
 import "../chunk-2MM5EJJX.mjs";
 export {
   invert,

package/dist/predicate/index.mjs

@@ -1,16 +1,16 @@
 import "../chunk-MAJSPFA6.mjs";
-import {
-  isNull
-} from "../chunk-AIRSKN47.mjs";
-import {
-  isUndefined
-} from "../chunk-VH2PV426.mjs";
 import {
   isNil
 } from "../chunk-OHQAR5AU.mjs";
 import {
   isNotNil
 } from "../chunk-BMRTZMRE.mjs";
+import {
+  isNull
+} from "../chunk-AIRSKN47.mjs";
+import {
+  isUndefined
+} from "../chunk-VH2PV426.mjs";
 import "../chunk-2MM5EJJX.mjs";
 export {
   isNil,

package/dist/string/index.js

@@ -27,25 +27,29 @@ __export(string_exports, {
 });
 module.exports = __toCommonJS(string_exports);
 
-// src/constants/caseSplitPattern.ts
+// src/string/_internal/getWords.ts
 var CASE_SPLIT_PATTERN = /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]+|[0-9]+/g;
+function getWords(str) {
+  var _a;
+  return Array.from((_a = str.match(CASE_SPLIT_PATTERN)) != null ? _a : []);
+}
 
 // src/string/snakeCase.ts
 var snakeCase = (str) => {
-  const splitWords = str.match(CASE_SPLIT_PATTERN) || [];
-  return splitWords.map((word) => word.toLowerCase()).join("_");
+  const words = getWords(str);
+  return words.map((word) => word.toLowerCase()).join("_");
 };
 
 // src/string/kebabCase.ts
 var kebabCase = (str) => {
-  const splitWords = str.match(CASE_SPLIT_PATTERN) || [];
-  return splitWords.map((word) => word.toLowerCase()).join("-");
+  const words = getWords(str);
+  return words.map((word) => word.toLowerCase()).join("-");
 };
 
 // src/string/lowerCase.ts
 var lowerCase = (str) => {
-  const splitWords = str.match(CASE_SPLIT_PATTERN) || [];
-  return splitWords.map((word) => word.toLowerCase()).join(" ");
+  const words = getWords(str);
+  return words.map((word) => word.toLowerCase()).join(" ");
 };
 
 // src/string/capitalize.ts

package/dist/string/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/string/index.ts","../../src/constants/caseSplitPattern.ts","../../src/string/snakeCase.ts","../../src/string/kebabCase.ts","../../src/string/lowerCase.ts","../../src/string/capitalize.ts"],"sourcesContent":["export { snakeCase } from './snakeCase.ts';\nexport { kebabCase } from './kebabCase.ts';\nexport { lowerCase } from './lowerCase.ts';\nexport { capitalize } from './capitalize.ts';\n","/**\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 */\n\nexport const CASE_SPLIT_PATTERN = /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]+|[0-9]+/g;\n","import { CASE_SPLIT_PATTERN } from '../constants';\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 splitWords = str.match(CASE_SPLIT_PATTERN) || [];\n  return splitWords.map(word => word.toLowerCase()).join('_');\n};\n","import { CASE_SPLIT_PATTERN } from '../constants';\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 splitWords = str.match(CASE_SPLIT_PATTERN) || [];\n  return splitWords.map(word => word.toLowerCase()).join('-');\n};\n","import { CASE_SPLIT_PATTERN } from '../constants';\n\n/**\n * Converts a string to lower case.\n *\n * Lower case is the naming convention in which each word is written in lowercase and separated by an space ( ) character.\n *\n * @param {string} str - The string that is to be changed to lower case.\n * @returns {string} - The converted string to lower case.\n *\n * @example\n * const convertedStr1 = lowerCase('camelCase') // returns 'camel case'\n * const convertedStr2 = lowerCase('some whitespace') // returns 'some whitespace'\n * const convertedStr3 = lowerCase('hyphen-text') // returns 'hyphen text'\n * const convertedStr4 = lowerCase('HTTPRequest') // returns 'http request'\n */\n\nexport const lowerCase = (str: string): string => {\n  const splitWords = str.match(CASE_SPLIT_PATTERN) || [];\n  return splitWords.map(word => word.toLowerCase()).join(' ');\n};\n","/**\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":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACiBO,IAAM,qBAAqB;;;ACA3B,IAAM,YAAY,CAAC,QAAwB;AAChD,QAAM,aAAa,IAAI,MAAM,kBAAkB,KAAK,CAAC;AACrD,SAAO,WAAW,IAAI,UAAQ,KAAK,YAAY,CAAC,EAAE,KAAK,GAAG;AAC5D;;;ACHO,IAAM,YAAY,CAAC,QAAwB;AAChD,QAAM,aAAa,IAAI,MAAM,kBAAkB,KAAK,CAAC;AACrD,SAAO,WAAW,IAAI,UAAQ,KAAK,YAAY,CAAC,EAAE,KAAK,GAAG;AAC5D;;;ACHO,IAAM,YAAY,CAAC,QAAwB;AAChD,QAAM,aAAa,IAAI,MAAM,kBAAkB,KAAK,CAAC;AACrD,SAAO,WAAW,IAAI,UAAQ,KAAK,YAAY,CAAC,EAAE,KAAK,GAAG;AAC5D;;;ACRO,IAAM,aAAa,CAAmB,QAA0B;AACrE,SAAQ,IAAI,OAAO,CAAC,EAAE,YAAY,IAAI,IAAI,MAAM,CAAC,EAAE,YAAY;AACjE;","names":[]}
+{"version":3,"sources":["../../src/string/index.ts","../../src/string/_internal/getWords.ts","../../src/string/snakeCase.ts","../../src/string/kebabCase.ts","../../src/string/lowerCase.ts","../../src/string/capitalize.ts"],"sourcesContent":["export { snakeCase } from './snakeCase.ts';\nexport { kebabCase } from './kebabCase.ts';\nexport { lowerCase } from './lowerCase.ts';\nexport { capitalize } from './capitalize.ts';\n","/**\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]{2,}(?=[A-Z][a-z]+[0-9]*|\\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]+|[0-9]+/g;\n\nexport function getWords(str: string): string[] {\n  return Array.from(str.match(CASE_SPLIT_PATTERN) ?? []);\n}\n","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","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","import { getWords } from './_internal/getWords.ts';\n\n/**\n * Converts a string to lower case.\n *\n * Lower case is the naming convention in which each word is written in lowercase and separated by an space ( ) character.\n *\n * @param {string} str - The string that is to be changed to lower case.\n * @returns {string} - The converted string to lower case.\n *\n * @example\n * const convertedStr1 = lowerCase('camelCase') // returns 'camel case'\n * const convertedStr2 = lowerCase('some whitespace') // returns 'some whitespace'\n * const convertedStr3 = lowerCase('hyphen-text') // returns 'hyphen text'\n * const convertedStr4 = lowerCase('HTTPRequest') // returns 'http request'\n */\nexport const lowerCase = (str: string): string => {\n  const words = getWords(str);\n  return words.map(word => word.toLowerCase()).join(' ');\n};\n","/**\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":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACgBA,IAAM,qBAAqB;AAEpB,SAAS,SAAS,KAAuB;AAlBhD;AAmBE,SAAO,MAAM,MAAK,SAAI,MAAM,kBAAkB,MAA5B,YAAiC,CAAC,CAAC;AACvD;;;ACHO,IAAM,YAAY,CAAC,QAAwB;AAChD,QAAM,QAAQ,SAAS,GAAG;AAC1B,SAAO,MAAM,IAAI,UAAQ,KAAK,YAAY,CAAC,EAAE,KAAK,GAAG;AACvD;;;ACHO,IAAM,YAAY,CAAC,QAAwB;AAChD,QAAM,QAAQ,SAAS,GAAG;AAC1B,SAAO,MAAM,IAAI,UAAQ,KAAK,YAAY,CAAC,EAAE,KAAK,GAAG;AACvD;;;ACJO,IAAM,YAAY,CAAC,QAAwB;AAChD,QAAM,QAAQ,SAAS,GAAG;AAC1B,SAAO,MAAM,IAAI,UAAQ,KAAK,YAAY,CAAC,EAAE,KAAK,GAAG;AACvD;;;ACPO,IAAM,aAAa,CAAmB,QAA0B;AACrE,SAAQ,IAAI,OAAO,CAAC,EAAE,YAAY,IAAI,IAAI,MAAM,CAAC,EAAE,YAAY;AACjE;","names":[]}

package/dist/string/index.mjs

@@ -1,18 +1,17 @@
 import "../chunk-HXGADE4C.mjs";
-import {
-  snakeCase
-} from "../chunk-47QP3LTV.mjs";
 import {
   capitalize
 } from "../chunk-U56ZOM7L.mjs";
 import {
   kebabCase
-} from "../chunk-XWJ7NQF4.mjs";
+} from "../chunk-TOORJ7XR.mjs";
 import {
   lowerCase
-} from "../chunk-KPFMOZXV.mjs";
-import "../chunk-2M3YVRFS.mjs";
-import "../chunk-IJJCMZIV.mjs";
+} from "../chunk-55NY5XRN.mjs";
+import {
+  snakeCase
+} from "../chunk-R7WI75UB.mjs";
+import "../chunk-SG4W5PWM.mjs";
 import "../chunk-2MM5EJJX.mjs";
 export {
   capitalize,

package/dist/string/kebabCase.js

@@ -24,13 +24,17 @@ __export(kebabCase_exports, {
 });
 module.exports = __toCommonJS(kebabCase_exports);
 
-// src/constants/caseSplitPattern.ts
+// src/string/_internal/getWords.ts
 var CASE_SPLIT_PATTERN = /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]+|[0-9]+/g;
+function getWords(str) {
+  var _a;
+  return Array.from((_a = str.match(CASE_SPLIT_PATTERN)) != null ? _a : []);
+}
 
 // src/string/kebabCase.ts
 var kebabCase = (str) => {
-  const splitWords = str.match(CASE_SPLIT_PATTERN) || [];
-  return splitWords.map((word) => word.toLowerCase()).join("-");
+  const words = getWords(str);
+  return words.map((word) => word.toLowerCase()).join("-");
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/string/kebabCase.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/string/kebabCase.ts","../../src/constants/caseSplitPattern.ts"],"sourcesContent":["import { CASE_SPLIT_PATTERN } from '../constants';\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 splitWords = str.match(CASE_SPLIT_PATTERN) || [];\n  return splitWords.map(word => word.toLowerCase()).join('-');\n};\n","/**\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 */\n\nexport const CASE_SPLIT_PATTERN = /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]+|[0-9]+/g;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACiBO,IAAM,qBAAqB;;;ADA3B,IAAM,YAAY,CAAC,QAAwB;AAChD,QAAM,aAAa,IAAI,MAAM,kBAAkB,KAAK,CAAC;AACrD,SAAO,WAAW,IAAI,UAAQ,KAAK,YAAY,CAAC,EAAE,KAAK,GAAG;AAC5D;","names":[]}
+{"version":3,"sources":["../../src/string/kebabCase.ts","../../src/string/_internal/getWords.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","/**\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]{2,}(?=[A-Z][a-z]+[0-9]*|\\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]+|[0-9]+/g;\n\nexport function getWords(str: string): string[] {\n  return Array.from(str.match(CASE_SPLIT_PATTERN) ?? []);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACgBA,IAAM,qBAAqB;AAEpB,SAAS,SAAS,KAAuB;AAlBhD;AAmBE,SAAO,MAAM,MAAK,SAAI,MAAM,kBAAkB,MAA5B,YAAiC,CAAC,CAAC;AACvD;;;ADHO,IAAM,YAAY,CAAC,QAAwB;AAChD,QAAM,QAAQ,SAAS,GAAG;AAC1B,SAAO,MAAM,IAAI,UAAQ,KAAK,YAAY,CAAC,EAAE,KAAK,GAAG;AACvD;","names":[]}

package/dist/string/kebabCase.mjs

@@ -1,8 +1,7 @@
 import {
   kebabCase
-} from "../chunk-XWJ7NQF4.mjs";
-import "../chunk-2M3YVRFS.mjs";
-import "../chunk-IJJCMZIV.mjs";
+} from "../chunk-TOORJ7XR.mjs";
+import "../chunk-SG4W5PWM.mjs";
 import "../chunk-2MM5EJJX.mjs";
 export {
   kebabCase

package/dist/string/lowerCase.js

@@ -24,13 +24,17 @@ __export(lowerCase_exports, {
 });
 module.exports = __toCommonJS(lowerCase_exports);
 
-// src/constants/caseSplitPattern.ts
+// src/string/_internal/getWords.ts
 var CASE_SPLIT_PATTERN = /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]+|[0-9]+/g;
+function getWords(str) {
+  var _a;
+  return Array.from((_a = str.match(CASE_SPLIT_PATTERN)) != null ? _a : []);
+}
 
 // src/string/lowerCase.ts
 var lowerCase = (str) => {
-  const splitWords = str.match(CASE_SPLIT_PATTERN) || [];
-  return splitWords.map((word) => word.toLowerCase()).join(" ");
+  const words = getWords(str);
+  return words.map((word) => word.toLowerCase()).join(" ");
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/string/lowerCase.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/string/lowerCase.ts","../../src/constants/caseSplitPattern.ts"],"sourcesContent":["import { CASE_SPLIT_PATTERN } from '../constants';\n\n/**\n * Converts a string to lower case.\n *\n * Lower case is the naming convention in which each word is written in lowercase and separated by an space ( ) character.\n *\n * @param {string} str - The string that is to be changed to lower case.\n * @returns {string} - The converted string to lower case.\n *\n * @example\n * const convertedStr1 = lowerCase('camelCase') // returns 'camel case'\n * const convertedStr2 = lowerCase('some whitespace') // returns 'some whitespace'\n * const convertedStr3 = lowerCase('hyphen-text') // returns 'hyphen text'\n * const convertedStr4 = lowerCase('HTTPRequest') // returns 'http request'\n */\n\nexport const lowerCase = (str: string): string => {\n  const splitWords = str.match(CASE_SPLIT_PATTERN) || [];\n  return splitWords.map(word => word.toLowerCase()).join(' ');\n};\n","/**\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 */\n\nexport const CASE_SPLIT_PATTERN = /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]+|[0-9]+/g;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACiBO,IAAM,qBAAqB;;;ADA3B,IAAM,YAAY,CAAC,QAAwB;AAChD,QAAM,aAAa,IAAI,MAAM,kBAAkB,KAAK,CAAC;AACrD,SAAO,WAAW,IAAI,UAAQ,KAAK,YAAY,CAAC,EAAE,KAAK,GAAG;AAC5D;","names":[]}
+{"version":3,"sources":["../../src/string/lowerCase.ts","../../src/string/_internal/getWords.ts"],"sourcesContent":["import { getWords } from './_internal/getWords.ts';\n\n/**\n * Converts a string to lower case.\n *\n * Lower case is the naming convention in which each word is written in lowercase and separated by an space ( ) character.\n *\n * @param {string} str - The string that is to be changed to lower case.\n * @returns {string} - The converted string to lower case.\n *\n * @example\n * const convertedStr1 = lowerCase('camelCase') // returns 'camel case'\n * const convertedStr2 = lowerCase('some whitespace') // returns 'some whitespace'\n * const convertedStr3 = lowerCase('hyphen-text') // returns 'hyphen text'\n * const convertedStr4 = lowerCase('HTTPRequest') // returns 'http request'\n */\nexport const lowerCase = (str: string): string => {\n  const words = getWords(str);\n  return words.map(word => word.toLowerCase()).join(' ');\n};\n","/**\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]{2,}(?=[A-Z][a-z]+[0-9]*|\\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]+|[0-9]+/g;\n\nexport function getWords(str: string): string[] {\n  return Array.from(str.match(CASE_SPLIT_PATTERN) ?? []);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACgBA,IAAM,qBAAqB;AAEpB,SAAS,SAAS,KAAuB;AAlBhD;AAmBE,SAAO,MAAM,MAAK,SAAI,MAAM,kBAAkB,MAA5B,YAAiC,CAAC,CAAC;AACvD;;;ADJO,IAAM,YAAY,CAAC,QAAwB;AAChD,QAAM,QAAQ,SAAS,GAAG;AAC1B,SAAO,MAAM,IAAI,UAAQ,KAAK,YAAY,CAAC,EAAE,KAAK,GAAG;AACvD;","names":[]}

package/dist/string/lowerCase.mjs

@@ -1,8 +1,7 @@
 import {
   lowerCase
-} from "../chunk-KPFMOZXV.mjs";
-import "../chunk-2M3YVRFS.mjs";
-import "../chunk-IJJCMZIV.mjs";
+} from "../chunk-55NY5XRN.mjs";
+import "../chunk-SG4W5PWM.mjs";
 import "../chunk-2MM5EJJX.mjs";
 export {
   lowerCase

package/dist/string/snakeCase.js

@@ -24,13 +24,17 @@ __export(snakeCase_exports, {
 });
 module.exports = __toCommonJS(snakeCase_exports);
 
-// src/constants/caseSplitPattern.ts
+// src/string/_internal/getWords.ts
 var CASE_SPLIT_PATTERN = /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]+|[0-9]+/g;
+function getWords(str) {
+  var _a;
+  return Array.from((_a = str.match(CASE_SPLIT_PATTERN)) != null ? _a : []);
+}
 
 // src/string/snakeCase.ts
 var snakeCase = (str) => {
-  const splitWords = str.match(CASE_SPLIT_PATTERN) || [];
-  return splitWords.map((word) => word.toLowerCase()).join("_");
+  const words = getWords(str);
+  return words.map((word) => word.toLowerCase()).join("_");
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/string/snakeCase.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/string/snakeCase.ts","../../src/constants/caseSplitPattern.ts"],"sourcesContent":["import { CASE_SPLIT_PATTERN } from '../constants';\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 splitWords = str.match(CASE_SPLIT_PATTERN) || [];\n  return splitWords.map(word => word.toLowerCase()).join('_');\n};\n","/**\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 */\n\nexport const CASE_SPLIT_PATTERN = /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]+|[0-9]+/g;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACiBO,IAAM,qBAAqB;;;ADA3B,IAAM,YAAY,CAAC,QAAwB;AAChD,QAAM,aAAa,IAAI,MAAM,kBAAkB,KAAK,CAAC;AACrD,SAAO,WAAW,IAAI,UAAQ,KAAK,YAAY,CAAC,EAAE,KAAK,GAAG;AAC5D;","names":[]}
+{"version":3,"sources":["../../src/string/snakeCase.ts","../../src/string/_internal/getWords.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","/**\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]{2,}(?=[A-Z][a-z]+[0-9]*|\\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]+|[0-9]+/g;\n\nexport function getWords(str: string): string[] {\n  return Array.from(str.match(CASE_SPLIT_PATTERN) ?? []);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACgBA,IAAM,qBAAqB;AAEpB,SAAS,SAAS,KAAuB;AAlBhD;AAmBE,SAAO,MAAM,MAAK,SAAI,MAAM,kBAAkB,MAA5B,YAAiC,CAAC,CAAC;AACvD;;;ADHO,IAAM,YAAY,CAAC,QAAwB;AAChD,QAAM,QAAQ,SAAS,GAAG;AAC1B,SAAO,MAAM,IAAI,UAAQ,KAAK,YAAY,CAAC,EAAE,KAAK,GAAG;AACvD;","names":[]}

package/dist/string/snakeCase.mjs

@@ -1,8 +1,7 @@
 import {
   snakeCase
-} from "../chunk-47QP3LTV.mjs";
-import "../chunk-2M3YVRFS.mjs";
-import "../chunk-IJJCMZIV.mjs";
+} from "../chunk-R7WI75UB.mjs";
+import "../chunk-SG4W5PWM.mjs";
 import "../chunk-2MM5EJJX.mjs";
 export {
   snakeCase

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "es-toolkit",
   "description": "A state-of-the-art, high-performance JavaScript utility library with a small bundle size and strong type annotations.",
-  "version": "1.9.0-dev.186+a8398d29",
+  "version": "1.9.0-dev.188+f44a7768",
   "homepage": "https://es-toolkit.slash.page",
   "bugs": "https://github.com/toss/es-toolkit/issues",
   "repository": {

package/dist/chunk-2M3YVRFS.mjs

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

package/dist/chunk-2M3YVRFS.mjs.map

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

package/dist/chunk-47QP3LTV.mjs

@@ -1,14 +0,0 @@
-import {
-  CASE_SPLIT_PATTERN
-} from "./chunk-IJJCMZIV.mjs";
-
-// src/string/snakeCase.ts
-var snakeCase = (str) => {
-  const splitWords = str.match(CASE_SPLIT_PATTERN) || [];
-  return splitWords.map((word) => word.toLowerCase()).join("_");
-};
-
-export {
-  snakeCase
-};
-//# sourceMappingURL=chunk-47QP3LTV.mjs.map

package/dist/chunk-47QP3LTV.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/string/snakeCase.ts"],"sourcesContent":["import { CASE_SPLIT_PATTERN } from '../constants';\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 splitWords = str.match(CASE_SPLIT_PATTERN) || [];\n  return splitWords.map(word => word.toLowerCase()).join('_');\n};\n"],"mappings":";;;;;AAiBO,IAAM,YAAY,CAAC,QAAwB;AAChD,QAAM,aAAa,IAAI,MAAM,kBAAkB,KAAK,CAAC;AACrD,SAAO,WAAW,IAAI,UAAQ,KAAK,YAAY,CAAC,EAAE,KAAK,GAAG;AAC5D;","names":[]}

package/dist/chunk-HJPB4KC3.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/array/flattenDeep.ts"],"sourcesContent":["import { flatten } from './flatten';\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-IJJCMZIV.mjs

@@ -1,7 +0,0 @@
-// src/constants/caseSplitPattern.ts
-var CASE_SPLIT_PATTERN = /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]+|[0-9]+/g;
-
-export {
-  CASE_SPLIT_PATTERN
-};
-//# sourceMappingURL=chunk-IJJCMZIV.mjs.map

package/dist/chunk-IJJCMZIV.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/constants/caseSplitPattern.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 */\n\nexport const CASE_SPLIT_PATTERN = /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]+|[0-9]+/g;\n"],"mappings":";AAiBO,IAAM,qBAAqB;","names":[]}

package/dist/chunk-KPFMOZXV.mjs

@@ -1,14 +0,0 @@
-import {
-  CASE_SPLIT_PATTERN
-} from "./chunk-IJJCMZIV.mjs";
-
-// src/string/lowerCase.ts
-var lowerCase = (str) => {
-  const splitWords = str.match(CASE_SPLIT_PATTERN) || [];
-  return splitWords.map((word) => word.toLowerCase()).join(" ");
-};
-
-export {
-  lowerCase
-};
-//# sourceMappingURL=chunk-KPFMOZXV.mjs.map

package/dist/chunk-KPFMOZXV.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/string/lowerCase.ts"],"sourcesContent":["import { CASE_SPLIT_PATTERN } from '../constants';\n\n/**\n * Converts a string to lower case.\n *\n * Lower case is the naming convention in which each word is written in lowercase and separated by an space ( ) character.\n *\n * @param {string} str - The string that is to be changed to lower case.\n * @returns {string} - The converted string to lower case.\n *\n * @example\n * const convertedStr1 = lowerCase('camelCase') // returns 'camel case'\n * const convertedStr2 = lowerCase('some whitespace') // returns 'some whitespace'\n * const convertedStr3 = lowerCase('hyphen-text') // returns 'hyphen text'\n * const convertedStr4 = lowerCase('HTTPRequest') // returns 'http request'\n */\n\nexport const lowerCase = (str: string): string => {\n  const splitWords = str.match(CASE_SPLIT_PATTERN) || [];\n  return splitWords.map(word => word.toLowerCase()).join(' ');\n};\n"],"mappings":";;;;;AAiBO,IAAM,YAAY,CAAC,QAAwB;AAChD,QAAM,aAAa,IAAI,MAAM,kBAAkB,KAAK,CAAC;AACrD,SAAO,WAAW,IAAI,UAAQ,KAAK,YAAY,CAAC,EAAE,KAAK,GAAG;AAC5D;","names":[]}