@vinicunca/perkakas 1.12.0 → 1.13.0

package/dist/take.d.cts

@@ -1,4 +1,4 @@
-import { t as IterableContainer } from "./iterable-container-OFsaw8WL.cjs";
+import { t as IterableContainer } from "./iterable-container-1TN3AJ3s.cjs";
 
 //#region src/take.d.ts
 

package/dist/take.d.ts

@@ -1,4 +1,4 @@
-import { t as IterableContainer } from "./iterable-container-BdjPuIjL.js";
+import { t as IterableContainer } from "./iterable-container-Dv5vSKht.js";
 
 //#region src/take.d.ts
 

package/dist/take.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-BcQ8Up1_.js";import{n as t}from"./utility-evaluators-BwYLtB8b.js";function n(...t){return e(r,t,i)}function r(e,t){return t<0?[]:e.slice(0,t)}function i(e){if(e<=0)return t;let n=e;return e=>(--n,{done:n<=0,hasNext:!0,next:e})}export{n as take};
+import{t as e}from"./curry-NmniqyJ0.js";import{n as t}from"./utility-evaluators-Boc-TMbq.js";function n(...t){return e(r,t,i)}function r(e,t){return t<0?[]:e.slice(0,t)}function i(e){if(e<=0)return t;let n=e;return e=>(--n,{done:n<=0,hasNext:!0,next:e})}export{n as take};
 //# sourceMappingURL=take.js.map

package/dist/tap.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-BcQ8Up1_.js";function t(...t){return e(n,t)}function n(e,t){return t(e),e}export{t as tap};
+import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){return t(e),e}export{t as tap};
 //# sourceMappingURL=tap.js.map

package/dist/times.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-BcQ8Up1_.js";function t(...t){return e(n,t)}function n(e,t){if(e<1)return[];let n=Number.isInteger(e)?e:Math.floor(e),r=Array(n);for(let e=0;e<n;e++)r[e]=t(e);return r}export{t as times};
+import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){if(e<1)return[];let n=Number.isInteger(e)?e:Math.floor(e),r=Array(n);for(let e=0;e<n;e++)r[e]=t(e);return r}export{t as times};
 //# sourceMappingURL=times.js.map

package/dist/to-camel-case.cjs

@@ -1 +1 @@
-const e=require(`./case.transform-FNx2XsC3.cjs`);function t(t,n){let[r,i,a]=e.r(t,n),o=n?.mergeAmbiguousCharacters?e.t():e.n();return r+i.map((e,t)=>t===0?e.toLowerCase():o(e,t)).join(n?.delimiter??``)+a}exports.toCamelCase=t;
+const e=require(`./words-DRQKxzLU.cjs`),t=/[a-z]/u,n=!0;function r(e,t){return typeof e==`string`?i(e,t):t=>i(t,e)}function i(n,{preserveConsecutiveUppercase:r=!0}={}){return e.t(t.test(n)?n:n.toLowerCase()).map((e,t)=>`${t===0?e[0].toLowerCase():e[0].toUpperCase()}${r?e.slice(1):e.slice(1).toLowerCase()}`).join(``)}exports.toCamelCase=r;

package/dist/to-camel-case.d.cts

@@ -1,32 +1,84 @@
-import { t as ChangeCaseOptions } from "./case.types-BxuWJgN1.cjs";
+import { t as OptionalOptionsWithDefaults } from "./optional-options-with-defaults-BZVW8GfC.cjs";
+import { CamelCase } from "type-fest";
 
 //#region src/to-camel-case.d.ts
-
+declare const DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE = true;
+interface CamelCaseOptions {
+  readonly preserveConsecutiveUppercase?: boolean;
+}
+type CamelCaseOptionsWithDefaults<Options extends CamelCaseOptions> = OptionalOptionsWithDefaults<CamelCaseOptions, Options, {
+  preserveConsecutiveUppercase: typeof DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE;
+}>;
+/**
+ * Converts text to **camelCase** by splitting it into words, lowercasing the
+ * first word, capitalizing the rest, then joining them back together.
+ *
+ * Because it uses the built-in case conversion methods, the function shares
+ * their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_
+ * too, making it best suited for simple strings like identifiers and internal
+ * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)
+ * with [`granularity: "word"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters),
+ * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),
+ * and [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase)
+ * which are purpose-built to handle nuances in languages and locales.
+ *
+ * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,
+ * `uncapitalize`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.
+ *
+ * For *PascalCase* use `capitalize(toCamelCase(data))`.
+ *
+ * @param data - A string.
+ * @param options - An _optional_ object with the _optional_ property
+ * `preserveConsecutiveUppercase` that can be used to change the way consecutive
+ * uppercase characters are handled. Defaults to `true`.
+ * @signature
+ *   P.toCamelCase(data);
+ *   P.toCamelCase(data, { preserveConsecutiveUppercase });
+ * @example
+ *   P.toCamelCase("hello world"); // "helloWorld"
+ *   P.toCamelCase("__HELLO_WORLD__"); // "helloWorld"
+ *   P.toCamelCase("HasHTML"); // "hasHTML"
+ *   P.toCamelCase("HasHTML", { preserveConsecutiveUppercase: false }); // "hasHtml"
+ * @dataFirst
+ * @category String
+ */
+declare function toCamelCase<T extends string, Options extends CamelCaseOptions>(data: T, options?: Options): CamelCase<T, CamelCaseOptionsWithDefaults<Options>>;
 /**
- * Convert a string to camel case.
+ * Converts text to **camelCase** by splitting it into words, lowercasing the
+ * first word, capitalizing the rest, then joining them back together.
+ *
+ * Because it uses the built-in case conversion methods, the function shares
+ * their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_
+ * too, making it best suited for simple strings like identifiers and internal
+ * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)
+ * with [`granularity: "word"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters),
+ * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),
+ * and [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase)
+ * which are purpose-built to handle nuances in languages and locales.
+ *
+ * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,
+ * `uncapitalize`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.
  *
- * @param input the string to convert
- * @param options - Optional configuration for the conversion.
- * @param options.delimiter - The delimiter to use between words.
- * @param options.separateNumbers - If true, an underscore will be injected before the numbers.
- * @param options.prefixCharacters - The prefix characters that we want to ignore.
- * @param options.suffixCharacters - The suffix characters that we want to ignore.
- * @param options.splitFn - A custom split function to separated the words.
- * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ * For *PascalCase* use `capitalize(toCamelCase(data))`.
  *
+ * @param options - An _optional_ object with the _optional_ property
+ * `preserveConsecutiveUppercase` that can be used to change the way consecutive
+ * uppercase characters are handled. Defaults to `true`.
  * @signature
- *   toCamelCase(str)
+ *   P.toCamelCase()(data);
+ *   P.toCamelCase({ preserveConsecutiveUppercase })(data);
  * @example
- *   toCamelCase('test'); // => 'test'
- *   toCamelCase('test string'); // => 'testSTring'
- *   toCamelCase('test string', { delimiter: '$' }); // => 'test$string'
- *   toCamelCase('TestV2', { separateNumbers: true }); // => 'testV_2'
- *   toCamelCase('__typename', { prefixCharacters: '_' }); // => '__typename'
- *   toCamelCase('type__', { suffixCharacters: '_' }); // => 'type__'
- *   toCamelCase('version 1.2.10', { mergeAmbiguousCharacters: true }); // => 'version1210'
+ *   P.pipe("hello world", P.toCamelCase()); // "helloWorld"
+ *   P.pipe("__HELLO_WORLD__", P.toCamelCase()); // "helloWorld"
+ *   P.pipe("HasHTML", P.toCamelCase()); // "hasHTML"
+ *   P.pipe(
+ *     "HasHTML",
+ *     P.toCamelCase({ preserveConsecutiveUppercase: false }),
+ *   ); // "hasHtml"
+ * @dataLast
  * @category String
  */
-declare function toCamelCase(input: string, options?: ChangeCaseOptions): string;
+declare function toCamelCase<Options extends CamelCaseOptions>(options?: Options): <T extends string>(data: T) => CamelCase<T, CamelCaseOptionsWithDefaults<Options>>;
 //#endregion
 export { toCamelCase };
 //# sourceMappingURL=to-camel-case.d.cts.map

package/dist/to-camel-case.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"to-camel-case.d.cts","names":[],"sources":["../src/to-camel-case.ts"],"sourcesContent":[],"mappings":";;;;;;AA4BA;;;;;;;;;;;;;;;;;;;;;;iBAAgB,WAAA,0BAAqC"}
+{"version":3,"file":"to-camel-case.d.cts","names":[],"sources":["../src/to-camel-case.ts"],"sourcesContent":[],"mappings":";;;;cAMM,sCAAA;UAEI,gBAAA;EAFJ,SAAA,4BAAA,CAAA,EAAA,OAAsC;AAAA;AAElB,KAIrB,4BAAA,CAAA,gBAA6C,gBAAjB,CAAA,GAC7B,2BAD6B,CAE7B,gBAF6B,EAG7B,OAH6B,EAAA;EAAiB,4BAAA,EAAA,OAMP,sCANO;CAE9C,CAAA;;;;;AAyCJ;;;;;;;;;AAwCA;;;;;;;;;;;;;;;;;;;;iBAxCgB,8CAA8C,wBACtD,aACI,UACT,UAAU,GAAG,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqC7B,4BAA4B,4BAChC,mCAEJ,MACH,UAAU,GAAG,6BAA6B"}

package/dist/to-camel-case.d.ts

@@ -1,32 +1,84 @@
-import { t as ChangeCaseOptions } from "./case.types-CVfGg990.js";
+import { t as OptionalOptionsWithDefaults } from "./optional-options-with-defaults-BFaBSKkF.js";
+import { CamelCase } from "type-fest";
 
 //#region src/to-camel-case.d.ts
-
+declare const DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE = true;
+interface CamelCaseOptions {
+  readonly preserveConsecutiveUppercase?: boolean;
+}
+type CamelCaseOptionsWithDefaults<Options extends CamelCaseOptions> = OptionalOptionsWithDefaults<CamelCaseOptions, Options, {
+  preserveConsecutiveUppercase: typeof DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE;
+}>;
+/**
+ * Converts text to **camelCase** by splitting it into words, lowercasing the
+ * first word, capitalizing the rest, then joining them back together.
+ *
+ * Because it uses the built-in case conversion methods, the function shares
+ * their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_
+ * too, making it best suited for simple strings like identifiers and internal
+ * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)
+ * with [`granularity: "word"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters),
+ * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),
+ * and [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase)
+ * which are purpose-built to handle nuances in languages and locales.
+ *
+ * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,
+ * `uncapitalize`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.
+ *
+ * For *PascalCase* use `capitalize(toCamelCase(data))`.
+ *
+ * @param data - A string.
+ * @param options - An _optional_ object with the _optional_ property
+ * `preserveConsecutiveUppercase` that can be used to change the way consecutive
+ * uppercase characters are handled. Defaults to `true`.
+ * @signature
+ *   P.toCamelCase(data);
+ *   P.toCamelCase(data, { preserveConsecutiveUppercase });
+ * @example
+ *   P.toCamelCase("hello world"); // "helloWorld"
+ *   P.toCamelCase("__HELLO_WORLD__"); // "helloWorld"
+ *   P.toCamelCase("HasHTML"); // "hasHTML"
+ *   P.toCamelCase("HasHTML", { preserveConsecutiveUppercase: false }); // "hasHtml"
+ * @dataFirst
+ * @category String
+ */
+declare function toCamelCase<T extends string, Options extends CamelCaseOptions>(data: T, options?: Options): CamelCase<T, CamelCaseOptionsWithDefaults<Options>>;
 /**
- * Convert a string to camel case.
+ * Converts text to **camelCase** by splitting it into words, lowercasing the
+ * first word, capitalizing the rest, then joining them back together.
+ *
+ * Because it uses the built-in case conversion methods, the function shares
+ * their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_
+ * too, making it best suited for simple strings like identifiers and internal
+ * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)
+ * with [`granularity: "word"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters),
+ * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),
+ * and [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase)
+ * which are purpose-built to handle nuances in languages and locales.
+ *
+ * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,
+ * `uncapitalize`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.
  *
- * @param input the string to convert
- * @param options - Optional configuration for the conversion.
- * @param options.delimiter - The delimiter to use between words.
- * @param options.separateNumbers - If true, an underscore will be injected before the numbers.
- * @param options.prefixCharacters - The prefix characters that we want to ignore.
- * @param options.suffixCharacters - The suffix characters that we want to ignore.
- * @param options.splitFn - A custom split function to separated the words.
- * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ * For *PascalCase* use `capitalize(toCamelCase(data))`.
  *
+ * @param options - An _optional_ object with the _optional_ property
+ * `preserveConsecutiveUppercase` that can be used to change the way consecutive
+ * uppercase characters are handled. Defaults to `true`.
  * @signature
- *   toCamelCase(str)
+ *   P.toCamelCase()(data);
+ *   P.toCamelCase({ preserveConsecutiveUppercase })(data);
  * @example
- *   toCamelCase('test'); // => 'test'
- *   toCamelCase('test string'); // => 'testSTring'
- *   toCamelCase('test string', { delimiter: '$' }); // => 'test$string'
- *   toCamelCase('TestV2', { separateNumbers: true }); // => 'testV_2'
- *   toCamelCase('__typename', { prefixCharacters: '_' }); // => '__typename'
- *   toCamelCase('type__', { suffixCharacters: '_' }); // => 'type__'
- *   toCamelCase('version 1.2.10', { mergeAmbiguousCharacters: true }); // => 'version1210'
+ *   P.pipe("hello world", P.toCamelCase()); // "helloWorld"
+ *   P.pipe("__HELLO_WORLD__", P.toCamelCase()); // "helloWorld"
+ *   P.pipe("HasHTML", P.toCamelCase()); // "hasHTML"
+ *   P.pipe(
+ *     "HasHTML",
+ *     P.toCamelCase({ preserveConsecutiveUppercase: false }),
+ *   ); // "hasHtml"
+ * @dataLast
  * @category String
  */
-declare function toCamelCase(input: string, options?: ChangeCaseOptions): string;
+declare function toCamelCase<Options extends CamelCaseOptions>(options?: Options): <T extends string>(data: T) => CamelCase<T, CamelCaseOptionsWithDefaults<Options>>;
 //#endregion
 export { toCamelCase };
 //# sourceMappingURL=to-camel-case.d.ts.map

package/dist/to-camel-case.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"to-camel-case.d.ts","names":[],"sources":["../src/to-camel-case.ts"],"sourcesContent":[],"mappings":";;;;;;AA4BA;;;;;;;;;;;;;;;;;;;;;;iBAAgB,WAAA,0BAAqC"}
+{"version":3,"file":"to-camel-case.d.ts","names":[],"sources":["../src/to-camel-case.ts"],"sourcesContent":[],"mappings":";;;;cAMM,sCAAA;UAEI,gBAAA;EAFJ,SAAA,4BAAA,CAAA,EAAA,OAAsC;AAAA;AAElB,KAIrB,4BAAA,CAAA,gBAA6C,gBAAjB,CAAA,GAC7B,2BAD6B,CAE7B,gBAF6B,EAG7B,OAH6B,EAAA;EAAiB,4BAAA,EAAA,OAMP,sCANO;CAE9C,CAAA;;;;;AAyCJ;;;;;;;;;AAwCA;;;;;;;;;;;;;;;;;;;;iBAxCgB,8CAA8C,wBACtD,aACI,UACT,UAAU,GAAG,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqC7B,4BAA4B,4BAChC,mCAEJ,MACH,UAAU,GAAG,6BAA6B"}

package/dist/to-camel-case.js

@@ -1,2 +1,2 @@
-import{n as e,r as t,t as n}from"./case.transform-CCMWrBmz.js";function r(r,i){let[a,o,s]=t(r,i),c=i?.mergeAmbiguousCharacters?n():e();return a+o.map((e,t)=>t===0?e.toLowerCase():c(e,t)).join(i?.delimiter??``)+s}export{r as toCamelCase};
+import{t as e}from"./words-DQCM5umD.js";const t=/[a-z]/u;function n(e,t){return typeof e==`string`?r(e,t):t=>r(t,e)}function r(n,{preserveConsecutiveUppercase:r=!0}={}){return e(t.test(n)?n:n.toLowerCase()).map((e,t)=>`${t===0?e[0].toLowerCase():e[0].toUpperCase()}${r?e.slice(1):e.slice(1).toLowerCase()}`).join(``)}export{n as toCamelCase};
 //# sourceMappingURL=to-camel-case.js.map

package/dist/to-camel-case.js.map

@@ -1 +1 @@
-{"version":3,"file":"to-camel-case.js","names":[],"sources":["../src/to-camel-case.ts"],"sourcesContent":["import type { ChangeCaseOptions } from './internal/case.types';\n\nimport { capitalCaseTransformFactory, pascalCaseTransformFactory, splitPrefixSuffix } from './internal/case.transform';\n\n/**\n * Convert a string to camel case.\n *\n * @param input the string to convert\n * @param options - Optional configuration for the conversion.\n * @param options.delimiter - The delimiter to use between words.\n * @param options.separateNumbers - If true, an underscore will be injected before the numbers.\n * @param options.prefixCharacters - The prefix characters that we want to ignore.\n * @param options.suffixCharacters - The suffix characters that we want to ignore.\n * @param options.splitFn - A custom split function to separated the words.\n * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.\n *\n * @signature\n *   toCamelCase(str)\n * @example\n *   toCamelCase('test'); // => 'test'\n *   toCamelCase('test string'); // => 'testSTring'\n *   toCamelCase('test string', { delimiter: '$' }); // => 'test$string'\n *   toCamelCase('TestV2', { separateNumbers: true }); // => 'testV_2'\n *   toCamelCase('__typename', { prefixCharacters: '_' }); // => '__typename'\n *   toCamelCase('type__', { suffixCharacters: '_' }); // => 'type__'\n *   toCamelCase('version 1.2.10', { mergeAmbiguousCharacters: true }); // => 'version1210'\n * @category String\n */\nexport function toCamelCase(input: string, options?: ChangeCaseOptions): string {\n  const [prefix, words, suffix] = splitPrefixSuffix(input, options);\n\n  const transform = options?.mergeAmbiguousCharacters\n    ? capitalCaseTransformFactory()\n    : pascalCaseTransformFactory();\n\n  return (\n    prefix\n    + words\n      .map((word, index) => {\n        if (index === 0) {\n          return word.toLowerCase();\n        }\n\n        return transform(word, index);\n      })\n      .join(options?.delimiter ?? '')\n      + suffix\n  );\n}\n"],"mappings":"+DA4BA,SAAgB,EAAY,EAAe,EAAqC,CAC9E,GAAM,CAAC,EAAQ,EAAO,GAAU,EAAkB,EAAO,EAAQ,CAE3D,EAAY,GAAS,yBACvB,GAA6B,CAC7B,GAA4B,CAEhC,OACE,EACE,EACC,KAAK,EAAM,IACN,IAAU,EACL,EAAK,aAAa,CAGpB,EAAU,EAAM,EAAM,CAC7B,CACD,KAAK,GAAS,WAAa,GAAG,CAC7B"}
+{"version":3,"file":"to-camel-case.js","names":[],"sources":["../src/to-camel-case.ts"],"sourcesContent":["import type { CamelCase } from 'type-fest';\nimport type { OptionalOptionsWithDefaults } from './internal/types/optional-options-with-defaults';\nimport { words } from './internal/words';\n\nconst LOWER_CASE_CHARACTER_RE = /[a-z]/u;\n\nconst DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE = true;\n\ninterface CamelCaseOptions {\n  readonly preserveConsecutiveUppercase?: boolean;\n}\n\ntype CamelCaseOptionsWithDefaults<Options extends CamelCaseOptions>\n  = OptionalOptionsWithDefaults<\n    CamelCaseOptions,\n    Options,\n    {\n      // We use the runtime const for the default type so they stay coupled.\n      preserveConsecutiveUppercase: typeof DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE;\n    }\n  >;\n\n/**\n * Converts text to **camelCase** by splitting it into words, lowercasing the\n * first word, capitalizing the rest, then joining them back together.\n *\n * Because it uses the built-in case conversion methods, the function shares\n * their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_\n * too, making it best suited for simple strings like identifiers and internal\n * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters),\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * and [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase)\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * For *PascalCase* use `capitalize(toCamelCase(data))`.\n *\n * @param data - A string.\n * @param options - An _optional_ object with the _optional_ property\n * `preserveConsecutiveUppercase` that can be used to change the way consecutive\n * uppercase characters are handled. Defaults to `true`.\n * @signature\n *   P.toCamelCase(data);\n *   P.toCamelCase(data, { preserveConsecutiveUppercase });\n * @example\n *   P.toCamelCase(\"hello world\"); // \"helloWorld\"\n *   P.toCamelCase(\"__HELLO_WORLD__\"); // \"helloWorld\"\n *   P.toCamelCase(\"HasHTML\"); // \"hasHTML\"\n *   P.toCamelCase(\"HasHTML\", { preserveConsecutiveUppercase: false }); // \"hasHtml\"\n * @dataFirst\n * @category String\n */\nexport function toCamelCase<T extends string, Options extends CamelCaseOptions>(\n  data: T,\n  options?: Options,\n): CamelCase<T, CamelCaseOptionsWithDefaults<Options>>;\n\n/**\n * Converts text to **camelCase** by splitting it into words, lowercasing the\n * first word, capitalizing the rest, then joining them back together.\n *\n * Because it uses the built-in case conversion methods, the function shares\n * their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_\n * too, making it best suited for simple strings like identifiers and internal\n * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters),\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * and [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase)\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * For *PascalCase* use `capitalize(toCamelCase(data))`.\n *\n * @param options - An _optional_ object with the _optional_ property\n * `preserveConsecutiveUppercase` that can be used to change the way consecutive\n * uppercase characters are handled. Defaults to `true`.\n * @signature\n *   P.toCamelCase()(data);\n *   P.toCamelCase({ preserveConsecutiveUppercase })(data);\n * @example\n *   P.pipe(\"hello world\", P.toCamelCase()); // \"helloWorld\"\n *   P.pipe(\"__HELLO_WORLD__\", P.toCamelCase()); // \"helloWorld\"\n *   P.pipe(\"HasHTML\", P.toCamelCase()); // \"hasHTML\"\n *   P.pipe(\n *     \"HasHTML\",\n *     P.toCamelCase({ preserveConsecutiveUppercase: false }),\n *   ); // \"hasHtml\"\n * @dataLast\n * @category String\n */\nexport function toCamelCase<Options extends CamelCaseOptions>(\n  options?: Options,\n): <T extends string>(\n  data: T,\n) => CamelCase<T, CamelCaseOptionsWithDefaults<Options>>;\n\nexport function toCamelCase(\n  dataOrOptions: CamelCaseOptions | string,\n  options?: CamelCaseOptions,\n): unknown {\n  return typeof dataOrOptions === 'string'\n    ? toCamelCaseImplementation(dataOrOptions, options)\n    : (data: string) => toCamelCaseImplementation(data, dataOrOptions);\n}\n\n// Based on the type definition from type-fest.\n// @see https://github.com/sindresorhus/type-fest/blob/main/source/camel-case.d.ts#L76-L80\nfunction toCamelCaseImplementation(data: string, {\n  preserveConsecutiveUppercase = DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE,\n}: CamelCaseOptions = {}): string {\n  return words(\n    LOWER_CASE_CHARACTER_RE.test(data)\n      ? data\n      // If the text doesn't have **any** lower case characters we also lower\n      // case everything, but if it does we need to maintain them as it\n      // affects the word boundaries.\n      : data.toLowerCase(),\n  )\n    .map(\n      (word, index) =>\n        `${\n          // The first word is uncapitalized, the rest are capitalized\n          index === 0 ? word[0]!.toLowerCase() : word[0]!.toUpperCase()\n        }${preserveConsecutiveUppercase ? word.slice(1) : word.slice(1).toLowerCase()}`,\n    )\n    .join('');\n}\n"],"mappings":"wCAIA,MAAM,EAA0B,SAiGhC,SAAgB,EACd,EACA,EACS,CACT,OAAO,OAAO,GAAkB,SAC5B,EAA0B,EAAe,EAAQ,CAChD,GAAiB,EAA0B,EAAM,EAAc,CAKtE,SAAS,EAA0B,EAAc,CAC/C,+BAA+B,IACX,EAAE,CAAU,CAChC,OAAO,EACL,EAAwB,KAAK,EAAK,CAC9B,EAIA,EAAK,aAAa,CACvB,CACE,KACE,EAAM,IACL,GAEE,IAAU,EAAI,EAAK,GAAI,aAAa,CAAG,EAAK,GAAI,aAAa,GAC5D,EAA+B,EAAK,MAAM,EAAE,CAAG,EAAK,MAAM,EAAE,CAAC,aAAa,GAChF,CACA,KAAK,GAAG"}

package/dist/to-kebab-case.cjs

@@ -1 +1 @@
-const e=require(`./to-no-case.cjs`);function t(t,n){return e.toNoCase(t,{delimiter:`-`,...n})}exports.toKebabCase=t;
+const e=require(`./curry-BsY0Z8jH.cjs`),t=require(`./words-DRQKxzLU.cjs`);function n(...t){return e.t(r,t)}function r(e){return t.t(e).join(`-`).toLowerCase()}exports.toKebabCase=n;

package/dist/to-kebab-case.d.cts

@@ -1,31 +1,60 @@
-import { t as ChangeCaseOptions } from "./case.types-BxuWJgN1.cjs";
+import { Join, Words } from "type-fest";
 
 //#region src/to-kebab-case.d.ts
-
+type KebabCase<S extends string> = string extends S ? string : Lowercase<Join<Words<S>, '-'>>;
+/**
+ * Converts text to **kebab-case** by splitting it into words and joining them
+ * back together with hyphens (`-`), then lowercasing the result.
+ *
+ * Because it uses [`toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase),
+ * the function shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_
+ * too, making it best suited for simple strings like identifiers and internal
+ * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)
+ * with [`granularity: "word"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters), and
+ * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),
+ * which are purpose-built to handle nuances in languages and locales.
+ *
+ * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,
+ * `uncapitalize`, `toCamelCase`, `toSnakeCase`, and `toTitleCase`.
+ *
+ * For *COBOL-CASE* use `toUpperCase(toKebabCase(data))`.
+ *
+ * @param data - A string.
+ * @signature
+ *   P.toKebabCase(data);
+ * @example
+ *   P.toKebabCase("hello world"); // "hello-world"
+ *   P.toKebabCase("__HELLO_WORLD__"); // "hello-world"
+ * @dataFirst
+ * @category String
+ */
+declare function toKebabCase<S extends string>(data: S): KebabCase<S>;
 /**
- * Convert a string to kebab case.
+ * Converts text to **kebab-case** by splitting it into words and joining them
+ * back together with hyphens (`-`), then lowercasing the result.
+ *
+ * Because it uses [`toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase),
+ * the function shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_
+ * too, making it best suited for simple strings like identifiers and internal
+ * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)
+ * with [`granularity: "word"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters), and
+ * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),
+ * which are purpose-built to handle nuances in languages and locales.
+ *
+ * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,
+ * `uncapitalize`, `toCamelCase`, `toSnakeCase`, and `toTitleCase`.
  *
- * @param input the string to convert
- * @param options - Optional configuration for the conversion.
- * @param options.delimiter - The delimiter to use between words.
- * @param options.separateNumbers - If true, numbers will be separated.
- * @param options.prefixCharacters - The prefix characters that we want to ignore.
- * @param options.suffixCharacters - The suffix characters that we want to ignore.
- * @param options.splitFn - A custom split function to separated the words.
- * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ * For *COBOL-CASE* use `toUpperCase(toKebabCase(data))`.
  *
  * @signature
- *   toKebabCase(str)
+ *   P.toKebabCase()(data);
  * @example
- *   toKebabCase('test'); // => 'test'
- *   toKebabCase('test string'); // => 'test-string'
- *   toKebabCase('test string', { delimiter: '$' }); // => 'test$string'
- *   toKebabCase('testV2', { separateNumbers: true }); // => 'test-v-2'
- *   toKebabCase('__typename', { prefixCharacters: '_' }); // => '__typename'
- *   toKebabCase('type__', { suffixCharacters: '_' }); // => 'type__'
+ *   P.pipe("hello world", P.toKebabCase()); // "hello-world"
+ *   P.pipe("__HELLO_WORLD__", P.toKebabCase()); // "hello-world"
+ * @dataLast
  * @category String
  */
-declare function toKebabCase(input: string, options?: ChangeCaseOptions): string;
+declare function toKebabCase(): <S extends string>(data: S) => KebabCase<S>;
 //#endregion
 export { toKebabCase };
 //# sourceMappingURL=to-kebab-case.d.cts.map

package/dist/to-kebab-case.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"to-kebab-case.d.cts","names":[],"sources":["../src/to-kebab-case.ts"],"sourcesContent":[],"mappings":";;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;;iBAAgB,WAAA,0BAAqC"}
+{"version":3,"file":"to-kebab-case.d.cts","names":[],"sources":["../src/to-kebab-case.ts"],"sourcesContent":[],"mappings":";;;KAIK,6CAA6C,aAE9C,UAAU,KAAK,MAAM;;AANoB;;;;;;;AAkC7C;;;;;AA2BA;;;;;;;;;;;;;iBA3BgB,oCAAoC,IAAI,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2BlD,WAAA,CAAA,4BAAwC,MAAM,UAAU"}

package/dist/to-kebab-case.d.ts

@@ -1,31 +1,60 @@
-import { t as ChangeCaseOptions } from "./case.types-CVfGg990.js";
+import { Join, Words } from "type-fest";
 
 //#region src/to-kebab-case.d.ts
-
+type KebabCase<S extends string> = string extends S ? string : Lowercase<Join<Words<S>, '-'>>;
+/**
+ * Converts text to **kebab-case** by splitting it into words and joining them
+ * back together with hyphens (`-`), then lowercasing the result.
+ *
+ * Because it uses [`toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase),
+ * the function shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_
+ * too, making it best suited for simple strings like identifiers and internal
+ * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)
+ * with [`granularity: "word"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters), and
+ * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),
+ * which are purpose-built to handle nuances in languages and locales.
+ *
+ * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,
+ * `uncapitalize`, `toCamelCase`, `toSnakeCase`, and `toTitleCase`.
+ *
+ * For *COBOL-CASE* use `toUpperCase(toKebabCase(data))`.
+ *
+ * @param data - A string.
+ * @signature
+ *   P.toKebabCase(data);
+ * @example
+ *   P.toKebabCase("hello world"); // "hello-world"
+ *   P.toKebabCase("__HELLO_WORLD__"); // "hello-world"
+ * @dataFirst
+ * @category String
+ */
+declare function toKebabCase<S extends string>(data: S): KebabCase<S>;
 /**
- * Convert a string to kebab case.
+ * Converts text to **kebab-case** by splitting it into words and joining them
+ * back together with hyphens (`-`), then lowercasing the result.
+ *
+ * Because it uses [`toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase),
+ * the function shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_
+ * too, making it best suited for simple strings like identifiers and internal
+ * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)
+ * with [`granularity: "word"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters), and
+ * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),
+ * which are purpose-built to handle nuances in languages and locales.
+ *
+ * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,
+ * `uncapitalize`, `toCamelCase`, `toSnakeCase`, and `toTitleCase`.
  *
- * @param input the string to convert
- * @param options - Optional configuration for the conversion.
- * @param options.delimiter - The delimiter to use between words.
- * @param options.separateNumbers - If true, numbers will be separated.
- * @param options.prefixCharacters - The prefix characters that we want to ignore.
- * @param options.suffixCharacters - The suffix characters that we want to ignore.
- * @param options.splitFn - A custom split function to separated the words.
- * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ * For *COBOL-CASE* use `toUpperCase(toKebabCase(data))`.
  *
  * @signature
- *   toKebabCase(str)
+ *   P.toKebabCase()(data);
  * @example
- *   toKebabCase('test'); // => 'test'
- *   toKebabCase('test string'); // => 'test-string'
- *   toKebabCase('test string', { delimiter: '$' }); // => 'test$string'
- *   toKebabCase('testV2', { separateNumbers: true }); // => 'test-v-2'
- *   toKebabCase('__typename', { prefixCharacters: '_' }); // => '__typename'
- *   toKebabCase('type__', { suffixCharacters: '_' }); // => 'type__'
+ *   P.pipe("hello world", P.toKebabCase()); // "hello-world"
+ *   P.pipe("__HELLO_WORLD__", P.toKebabCase()); // "hello-world"
+ * @dataLast
  * @category String
  */
-declare function toKebabCase(input: string, options?: ChangeCaseOptions): string;
+declare function toKebabCase(): <S extends string>(data: S) => KebabCase<S>;
 //#endregion
 export { toKebabCase };
 //# sourceMappingURL=to-kebab-case.d.ts.map

package/dist/to-kebab-case.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"to-kebab-case.d.ts","names":[],"sources":["../src/to-kebab-case.ts"],"sourcesContent":[],"mappings":";;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;;iBAAgB,WAAA,0BAAqC"}
+{"version":3,"file":"to-kebab-case.d.ts","names":[],"sources":["../src/to-kebab-case.ts"],"sourcesContent":[],"mappings":";;;KAIK,6CAA6C,aAE9C,UAAU,KAAK,MAAM;;AANoB;;;;;;;AAkC7C;;;;;AA2BA;;;;;;;;;;;;;iBA3BgB,oCAAoC,IAAI,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2BlD,WAAA,CAAA,4BAAwC,MAAM,UAAU"}

package/dist/to-kebab-case.js

@@ -1,2 +1,2 @@
-import{toNoCase as e}from"./to-no-case.js";function t(t,n){return e(t,{delimiter:`-`,...n})}export{t as toKebabCase};
+import{t as e}from"./curry-NmniqyJ0.js";import{t}from"./words-DQCM5umD.js";function n(...t){return e(r,t)}function r(e){return t(e).join(`-`).toLowerCase()}export{n as toKebabCase};
 //# sourceMappingURL=to-kebab-case.js.map

package/dist/to-kebab-case.js.map

@@ -1 +1 @@
-{"version":3,"file":"to-kebab-case.js","names":[],"sources":["../src/to-kebab-case.ts"],"sourcesContent":["import type { ChangeCaseOptions } from './internal/case.types';\n\nimport { toNoCase } from './to-no-case';\n\n/**\n * Convert a string to kebab case.\n *\n * @param input the string to convert\n * @param options - Optional configuration for the conversion.\n * @param options.delimiter - The delimiter to use between words.\n * @param options.separateNumbers - If true, numbers will be separated.\n * @param options.prefixCharacters - The prefix characters that we want to ignore.\n * @param options.suffixCharacters - The suffix characters that we want to ignore.\n * @param options.splitFn - A custom split function to separated the words.\n * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.\n *\n * @signature\n *   toKebabCase(str)\n * @example\n *   toKebabCase('test'); // => 'test'\n *   toKebabCase('test string'); // => 'test-string'\n *   toKebabCase('test string', { delimiter: '$' }); // => 'test$string'\n *   toKebabCase('testV2', { separateNumbers: true }); // => 'test-v-2'\n *   toKebabCase('__typename', { prefixCharacters: '_' }); // => '__typename'\n *   toKebabCase('type__', { suffixCharacters: '_' }); // => 'type__'\n * @category String\n */\nexport function toKebabCase(input: string, options?: ChangeCaseOptions): string {\n  return toNoCase(\n    input,\n    {\n      delimiter: '-',\n      ...options,\n    },\n  );\n}\n"],"mappings":"2CA2BA,SAAgB,EAAY,EAAe,EAAqC,CAC9E,OAAO,EACL,EACA,CACE,UAAW,IACX,GAAG,EACJ,CACF"}
+{"version":3,"file":"to-kebab-case.js","names":[],"sources":["../src/to-kebab-case.ts"],"sourcesContent":["import type { Join, Words } from 'type-fest';\nimport { curry } from './curry';\nimport { words } from './internal/words';\n\ntype KebabCase<S extends string> = string extends S\n  ? string\n  : Lowercase<Join<Words<S>, '-'>>;\n\n/**\n * Converts text to **kebab-case** by splitting it into words and joining them\n * back together with hyphens (`-`), then lowercasing the result.\n *\n * Because it uses [`toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase),\n * the function shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_\n * too, making it best suited for simple strings like identifiers and internal\n * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters), and\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * For *COBOL-CASE* use `toUpperCase(toKebabCase(data))`.\n *\n * @param data - A string.\n * @signature\n *   P.toKebabCase(data);\n * @example\n *   P.toKebabCase(\"hello world\"); // \"hello-world\"\n *   P.toKebabCase(\"__HELLO_WORLD__\"); // \"hello-world\"\n * @dataFirst\n * @category String\n */\nexport function toKebabCase<S extends string>(data: S): KebabCase<S>;\n\n/**\n * Converts text to **kebab-case** by splitting it into words and joining them\n * back together with hyphens (`-`), then lowercasing the result.\n *\n * Because it uses [`toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase),\n * the function shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_\n * too, making it best suited for simple strings like identifiers and internal\n * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters), and\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * For *COBOL-CASE* use `toUpperCase(toKebabCase(data))`.\n *\n * @signature\n *   P.toKebabCase()(data);\n * @example\n *   P.pipe(\"hello world\", P.toKebabCase()); // \"hello-world\"\n *   P.pipe(\"__HELLO_WORLD__\", P.toKebabCase()); // \"hello-world\"\n * @dataLast\n * @category String\n */\nexport function toKebabCase(): <S extends string>(data: S) => KebabCase<S>;\n\nexport function toKebabCase(...args: ReadonlyArray<unknown>): unknown {\n  return curry(toKebabCaseImplementation, args);\n}\n\nfunction toKebabCaseImplementation<S extends string>(data: S): KebabCase<S> {\n  // @ts-expect-error [ts2322] -- To avoid importing our own utilities for this\n  // we are using the built-in `join` and `toLowerCase` functions which aren't\n  // typed as well. This is equivalent to `toLowerCase(join(words(data), \"-\"))`\n  // which TypeScript infers correctly as KebabCase.\n  return words(data).join('-').toLowerCase();\n}\n"],"mappings":"2EA+DA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,EAA2B,EAAK,CAG/C,SAAS,EAA4C,EAAuB,CAK1E,OAAO,EAAM,EAAK,CAAC,KAAK,IAAI,CAAC,aAAa"}

package/dist/to-lower-case.cjs

@@ -0,0 +1 @@
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e){return e.toLowerCase()}exports.toLowerCase=t;

package/dist/to-lower-case.d.cts

@@ -0,0 +1,51 @@
+//#region src/to-lower-case.d.ts
+/**
+ * Replaces all uppercase characters with their lowercase equivalents.
+ *
+ * This function is a wrapper around the built-in
+ * [`String.prototype.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)
+ * method and shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_.
+ *
+ * For a more linguistically accurate transformation use [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),
+ * and for display purposes use CSS [`text-transform: lowercase;`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform)
+ * which *is* locale-aware.
+ *
+ * For other case manipulations see: `toUpperCase`, `capitalize`,
+ * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and
+ * `toTitleCase`.
+ *
+ * @param data - A string.
+ * @signature
+ *   P.toLowerCase(data);
+ * @example
+ *   P.toLowerCase("Hello World"); // "hello world"
+ * @dataFirst
+ * @category String
+ */
+declare function toLowerCase<T extends string>(data: T): Lowercase<T>;
+/**
+ * Replaces all uppercase characters with their lowercase equivalents.
+ *
+ * This function is a wrapper around the built-in
+ * [`String.prototype.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)
+ * method and shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_.
+ *
+ * For a more linguistically accurate transformation use [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),
+ * and for display purposes use CSS [`text-transform: lowercase;`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform)
+ * which *is* locale-aware.
+ *
+ * For other case manipulations see: `toUpperCase`, `capitalize`,
+ * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and
+ * `toTitleCase`.
+ *
+ * @signature
+ *   P.toLowerCase()(data);
+ * @example
+ *   P.pipe("Hello World", P.toLowerCase()); // "hello world"
+ * @dataLast
+ * @category String
+ */
+declare function toLowerCase(): <T extends string>(data: T) => Lowercase<T>;
+//#endregion
+export { toLowerCase };
+//# sourceMappingURL=to-lower-case.d.cts.map

package/dist/to-lower-case.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-lower-case.d.cts","names":[],"sources":["../src/to-lower-case.ts"],"sourcesContent":[],"mappings":";;AAyBA;;;;;AAwBA;;;;;;;;;;;;;;;;;iBAxBgB,oCAAoC,IAAI,UAAU;;;;;;;;;;;;;;;;;;;;;;;iBAwBlD,WAAA,CAAA,4BAAwC,MAAM,UAAU"}