@vinicunca/perkakas 1.9.0 → 1.13.0

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

@@ -1,3 +1,60 @@
-import "./case.types-D-4qwVN-.cjs";
-import { toKebabCase } from "./to-kebab-case-B8wAcWY6.cjs";
-export { toKebabCase };
+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>;
+/**
+ * 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))`.
+ *
+ * @signature
+ *   P.toKebabCase()(data);
+ * @example
+ *   P.pipe("hello world", P.toKebabCase()); // "hello-world"
+ *   P.pipe("__HELLO_WORLD__", P.toKebabCase()); // "hello-world"
+ * @dataLast
+ * @category 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

@@ -0,0 +1 @@
+{"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,3 +1,60 @@
-import "./case.types-D5NB5m6p.js";
-import { toKebabCase } from "./to-kebab-case-jT7kXDMG.js";
-export { toKebabCase };
+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>;
+/**
+ * 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))`.
+ *
+ * @signature
+ *   P.toKebabCase()(data);
+ * @example
+ *   P.pipe("hello world", P.toKebabCase()); // "hello-world"
+ *   P.pipe("__HELLO_WORLD__", P.toKebabCase()); // "hello-world"
+ * @dataLast
+ * @category 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

@@ -0,0 +1 @@
+{"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 +1,2 @@
-import"./case.transform-DJYiGJG0.js";import"./to-no-case-DazuTIzG.js";import{toKebabCase as e}from"./to-kebab-case-Da16i23C.js";export{e 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

@@ -0,0 +1 @@
+{"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"}

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

@@ -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.ts.map

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

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

package/dist/to-lower-case.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"to-lower-case.js","names":[],"sources":["../src/to-lower-case.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Replaces all uppercase characters with their lowercase equivalents.\n *\n * This function is a wrapper around the built-in\n * [`String.prototype.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)\n * method and shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_.\n *\n * For a more linguistically accurate transformation use [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * and for display purposes use CSS [`text-transform: lowercase;`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform)\n * which *is* locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @param data - A string.\n * @signature\n *   P.toLowerCase(data);\n * @example\n *   P.toLowerCase(\"Hello World\"); // \"hello world\"\n * @dataFirst\n * @category String\n */\nexport function toLowerCase<T extends string>(data: T): Lowercase<T>;\n\n/**\n * Replaces all uppercase characters with their lowercase equivalents.\n *\n * This function is a wrapper around the built-in\n * [`String.prototype.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)\n * method and shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_.\n *\n * For a more linguistically accurate transformation use [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * and for display purposes use CSS [`text-transform: lowercase;`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform)\n * which *is* locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @signature\n *   P.toLowerCase()(data);\n * @example\n *   P.pipe(\"Hello World\", P.toLowerCase()); // \"hello world\"\n * @dataLast\n * @category String\n */\nexport function toLowerCase(): <T extends string>(data: T) => Lowercase<T>;\n\nexport function toLowerCase(...args: ReadonlyArray<unknown>): unknown {\n  return curry(toLowerCaseImplementation, args);\n}\n\nfunction toLowerCaseImplementation<T extends string>(data: T): Lowercase<T> {\n  // @ts-expect-error [ts2322] -- TypeScript can't infer this from the code...\n  return data.toLowerCase();\n}\n"],"mappings":"wCAmDA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,EAA2B,EAAK,CAG/C,SAAS,EAA4C,EAAuB,CAE1E,OAAO,EAAK,aAAa"}

package/dist/to-single-BKYbBic-.js

@@ -0,0 +1,2 @@
+function e(e){return Object.assign(e,{single:!0})}export{e as t};
+//# sourceMappingURL=to-single-BKYbBic-.js.map

package/dist/to-single-BKYbBic-.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-single-BKYbBic-.js","names":[],"sources":["../src/internal/to-single.ts"],"sourcesContent":["import type { StrictFunction } from './types/strict-function';\n\ntype Single<Func> = Func & { readonly single: true };\n\nexport function toSingle<Func extends StrictFunction>(fn: Func): Single<Func> {\n  return Object.assign(fn, { single: true as const });\n}\n"],"mappings":"AAIA,SAAgB,EAAsC,EAAwB,CAC5E,OAAO,OAAO,OAAO,EAAI,CAAE,OAAQ,GAAe,CAAC"}

package/dist/to-single-Chq_hKEk.cjs

@@ -0,0 +1 @@
+function e(e){return Object.assign(e,{single:!0})}Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return e}});

package/dist/to-snake-case.cjs

@@ -1 +1 @@
-require(`./case.transform-BXzx2bAJ.cjs`),require(`./to-no-case-DZm6y_Cf.cjs`);const e=require(`./to-snake-case-DlYZGTpp.cjs`);exports.toSnakeCase=e.toSnakeCase;
+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.toSnakeCase=n;

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

@@ -1,3 +1,60 @@
-import "./case.types-D-4qwVN-.cjs";
-import { toSnakeCase } from "./to-snake-case-C1HTdh8M.cjs";
-export { toSnakeCase };
+import { Join, Words } from "type-fest";
+
+//#region src/to-snake-case.d.ts
+type SnakeCase<S extends string> = string extends S ? string : Lowercase<Join<Words<S>, '_'>>;
+/**
+ * Converts text to **snake_case** by splitting it into words and joining them
+ * back together with underscores (`_`), 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`, `toKebabCase`, and `toTitleCase`.
+ *
+ * For *CONSTANT_CASE* use `toUpperCase(toSnakeCase(data))`.
+ *
+ * @param data - A string.
+ * @signature
+ *   P.toSnakeCase(data);
+ * @example
+ *   P.toSnakeCase("hello world"); // "hello_world"
+ *   P.toSnakeCase("__HELLO_WORLD__"); // "hello_world"
+ * @dataFirst
+ * @category String
+ */
+declare function toSnakeCase<S extends string>(data: S): SnakeCase<S>;
+/**
+ * Converts text to **snake_case** by splitting it into words and joining them
+ * back together with underscores (`_`), 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`, `toKebabCase`, and `toTitleCase`.
+ *
+ * For *CONSTANT_CASE* use `toUpperCase(toSnakeCase(data))`.
+ *
+ * @signature
+ *   P.toSnakeCase()(data);
+ * @example
+ *   P.pipe("hello world", P.toSnakeCase()); // "hello_world"
+ *   P.pipe("__HELLO_WORLD__", P.toSnakeCase()); // "hello_world"
+ * @dataLast
+ * @category String
+ */
+declare function toSnakeCase(): <S extends string>(data: S) => SnakeCase<S>;
+//#endregion
+export { toSnakeCase };
+//# sourceMappingURL=to-snake-case.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"to-snake-case.d.cts","names":[],"sources":["../src/to-snake-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-snake-case.d.ts

@@ -1,3 +1,60 @@
-import "./case.types-D5NB5m6p.js";
-import { toSnakeCase } from "./to-snake-case-4jsaz20Q.js";
-export { toSnakeCase };
+import { Join, Words } from "type-fest";
+
+//#region src/to-snake-case.d.ts
+type SnakeCase<S extends string> = string extends S ? string : Lowercase<Join<Words<S>, '_'>>;
+/**
+ * Converts text to **snake_case** by splitting it into words and joining them
+ * back together with underscores (`_`), 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`, `toKebabCase`, and `toTitleCase`.
+ *
+ * For *CONSTANT_CASE* use `toUpperCase(toSnakeCase(data))`.
+ *
+ * @param data - A string.
+ * @signature
+ *   P.toSnakeCase(data);
+ * @example
+ *   P.toSnakeCase("hello world"); // "hello_world"
+ *   P.toSnakeCase("__HELLO_WORLD__"); // "hello_world"
+ * @dataFirst
+ * @category String
+ */
+declare function toSnakeCase<S extends string>(data: S): SnakeCase<S>;
+/**
+ * Converts text to **snake_case** by splitting it into words and joining them
+ * back together with underscores (`_`), 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`, `toKebabCase`, and `toTitleCase`.
+ *
+ * For *CONSTANT_CASE* use `toUpperCase(toSnakeCase(data))`.
+ *
+ * @signature
+ *   P.toSnakeCase()(data);
+ * @example
+ *   P.pipe("hello world", P.toSnakeCase()); // "hello_world"
+ *   P.pipe("__HELLO_WORLD__", P.toSnakeCase()); // "hello_world"
+ * @dataLast
+ * @category String
+ */
+declare function toSnakeCase(): <S extends string>(data: S) => SnakeCase<S>;
+//#endregion
+export { toSnakeCase };
+//# sourceMappingURL=to-snake-case.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"to-snake-case.d.ts","names":[],"sources":["../src/to-snake-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-snake-case.js

@@ -1 +1,2 @@
-import"./case.transform-DJYiGJG0.js";import"./to-no-case-DazuTIzG.js";import{toSnakeCase as e}from"./to-snake-case-CYkfkVbX.js";export{e as toSnakeCase};
+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 toSnakeCase};
+//# sourceMappingURL=to-snake-case.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"to-snake-case.js","names":[],"sources":["../src/to-snake-case.ts"],"sourcesContent":["import type { Join, Words } from 'type-fest';\nimport { curry } from './curry';\nimport { words } from './internal/words';\n\ntype SnakeCase<S extends string> = string extends S\n  ? string\n  : Lowercase<Join<Words<S>, '_'>>;\n\n/**\n * Converts text to **snake_case** by splitting it into words and joining them\n * back together with underscores (`_`), 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`, `toKebabCase`, and `toTitleCase`.\n *\n * For *CONSTANT_CASE* use `toUpperCase(toSnakeCase(data))`.\n *\n * @param data - A string.\n * @signature\n *   P.toSnakeCase(data);\n * @example\n *   P.toSnakeCase(\"hello world\"); // \"hello_world\"\n *   P.toSnakeCase(\"__HELLO_WORLD__\"); // \"hello_world\"\n * @dataFirst\n * @category String\n */\nexport function toSnakeCase<S extends string>(data: S): SnakeCase<S>;\n\n/**\n * Converts text to **snake_case** by splitting it into words and joining them\n * back together with underscores (`_`), 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`, `toKebabCase`, and `toTitleCase`.\n *\n * For *CONSTANT_CASE* use `toUpperCase(toSnakeCase(data))`.\n *\n * @signature\n *   P.toSnakeCase()(data);\n * @example\n *   P.pipe(\"hello world\", P.toSnakeCase()); // \"hello_world\"\n *   P.pipe(\"__HELLO_WORLD__\", P.toSnakeCase()); // \"hello_world\"\n * @dataLast\n * @category String\n */\nexport function toSnakeCase(): <S extends string>(data: S) => SnakeCase<S>;\n\nexport function toSnakeCase(...args: ReadonlyArray<unknown>): unknown {\n  return curry(toSnakeCaseImplementation, args);\n}\n\nfunction toSnakeCaseImplementation<S extends string>(data: S): SnakeCase<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 SnakeCase.\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-string-DkC3zRUJ.d.cts

@@ -0,0 +1,13 @@
+//#region src/internal/types/to-string.d.ts
+/**
+ * A utility to preserve strings as-is, convert numbers to strings, and fail on
+ * anything else. This happens a lot in JS when accessing objects or when
+ * enumerating over keys.
+ *
+ * Notice that symbols are not supported, which is consistent with how built-in
+ * functions like `Object.keys` and `Object.entries` behave.
+ */
+type ToString<T> = T extends unknown ? T extends number ? `${T}` : T extends string ? T : never : never;
+//#endregion
+export { ToString as t };
+//# sourceMappingURL=to-string-DkC3zRUJ.d.cts.map

package/dist/to-string-DkC3zRUJ.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-string-DkC3zRUJ.d.cts","names":[],"sources":["../src/internal/types/to-string.ts"],"sourcesContent":[],"mappings":";;AAQA;;;;;;;KAAY,cAAc,oBACtB,sBACK,MACH,mBACE"}

package/dist/to-string-YIFx2KS6.d.ts

@@ -0,0 +1,13 @@
+//#region src/internal/types/to-string.d.ts
+/**
+ * A utility to preserve strings as-is, convert numbers to strings, and fail on
+ * anything else. This happens a lot in JS when accessing objects or when
+ * enumerating over keys.
+ *
+ * Notice that symbols are not supported, which is consistent with how built-in
+ * functions like `Object.keys` and `Object.entries` behave.
+ */
+type ToString<T> = T extends unknown ? T extends number ? `${T}` : T extends string ? T : never : never;
+//#endregion
+export { ToString as t };
+//# sourceMappingURL=to-string-YIFx2KS6.d.ts.map

package/dist/to-string-YIFx2KS6.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-string-YIFx2KS6.d.ts","names":[],"sources":["../src/internal/types/to-string.ts"],"sourcesContent":[],"mappings":";;AAQA;;;;;;;KAAY,cAAc,oBACtB,sBACK,MACH,mBACE"}

package/dist/to-title-case.cjs

@@ -0,0 +1 @@
+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=>`${e[0].toUpperCase()}${r?e.slice(1):e.slice(1).toLowerCase()}`).join(` `)}exports.toTitleCase=r;

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

@@ -0,0 +1,86 @@
+import { t as OptionalOptionsWithDefaults } from "./optional-options-with-defaults-BZVW8GfC.cjs";
+import { IsEqual, IsLiteral, Join, Words } from "type-fest";
+
+//#region src/to-title-case.d.ts
+declare const DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE = true;
+interface TitleCaseOptions {
+  readonly preserveConsecutiveUppercase?: boolean;
+}
+type TitleCaseOptionsWithDefaults<Options extends TitleCaseOptions> = OptionalOptionsWithDefaults<TitleCaseOptions, Options, {
+  preserveConsecutiveUppercase: typeof DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE;
+}>;
+type TitleCase<S extends string, Options extends TitleCaseOptions> = IsLiteral<S> extends true ? Join<TitleCasedArray<Words<IsEqual<S, Uppercase<S>> extends true ? Lowercase<S> : S>, TitleCaseOptionsWithDefaults<Options>>, ' '> : string;
+type TitleCasedArray<T extends ReadonlyArray<string>, Options extends TitleCaseOptions> = { [I in keyof T]: Capitalize<Options['preserveConsecutiveUppercase'] extends true ? T[I] : Lowercase<T[I]>> };
+/**
+ * Converts text to **Title Case** by splitting it into words, capitalizing the
+ * first letter of each word, then joining them back together with spaces.
+ *
+ * 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)_,
+ * 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`, `toCamelCase`, `toKebabCase`, and `toSnakeCase`.
+ *
+ * @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
+ *   R.toTitleCase(data);
+ *   R.toTitleCase(data, { preserveConsecutiveUppercase });
+ * @example
+ *   R.toTitleCase("hello world"); // "Hello World"
+ *   R.toTitleCase("--foo-bar--"); // "Foo Bar"
+ *   R.toTitleCase("fooBar"); // "Foo Bar"
+ *   R.toTitleCase("__FOO_BAR__"); // "Foo Bar"
+ *   R.toTitleCase("XMLHttpRequest"); // "XML Http Request"
+ *   R.toTitleCase("XMLHttpRequest", { preserveConsecutiveUppercase: false }); // "Xml Http Request"
+ * @dataFirst
+ * @category String
+ */
+declare function toTitleCase<S extends string, Options extends TitleCaseOptions>(data: S, options?: Options): TitleCase<S, Options>;
+/**
+ * Converts text to **Title Case** by splitting it into words, capitalizing the
+ * first letter of each word, then joining them back together with spaces.
+ *
+ * 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)_,
+ * 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`, `toCamelCase`, `toKebabCase`, and `toSnakeCase`.
+ *
+ * @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
+ *   R.toTitleCase()(data);
+ *   R.toTitleCase({ preserveConsecutiveUppercase })(data);
+ * @example
+ *   R.pipe("hello world", R.toTitleCase()); // "Hello World"
+ *   R.pipe("--foo-bar--", R.toTitleCase()); // "Foo Bar"
+ *   R.pipe("fooBar", R.toTitleCase()); // "Foo Bar"
+ *   R.pipe("__FOO_BAR__", R.toTitleCase()); // "Foo Bar"
+ *   R.pipe("XMLHttpRequest", R.toTitleCase()); // "XML Http Request"
+ *   R.pipe(
+ *     "XMLHttpRequest",
+ *     R.toTitleCase({ preserveConsecutiveUppercase: false }),
+ *   ); // "Xml Http Request"
+ * @dataLast
+ * @category String
+ */
+declare function toTitleCase<Options extends TitleCaseOptions>(options?: Options): <S extends string>(data: S) => TitleCase<S, Options>;
+//#endregion
+export { toTitleCase };
+//# sourceMappingURL=to-title-case.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"to-title-case.d.cts","names":[],"sources":["../src/to-title-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;KAQC,SAPD,CAAA,UAAA,MAAA,EAAA,gBAO6C,gBAP7C,CAAA,GAQA,SARA,CAQU,CARV,CAAA,SAAA,IAAA,GASE,IATF,CAUE,eAVF,CAWI,KAXJ,CAWU,OAXV,CAWkB,CAXlB,EAWqB,SAXrB,CAW+B,CAX/B,CAAA,CAAA,SAAA,IAAA,GAWkD,SAXlD,CAW4D,CAX5D,CAAA,GAWiE,CAXjE,CAAA,EAYI,4BAZJ,CAYiC,OAZjC,CAAA,CAAA,EAAA,GAAA,CAAA,GAAA,MAAA;KAkBC,eAfsC,CAAA,UAgB/B,aAhB+B,CAAA,MAAA,CAAA,EAAA,gBAiBzB,gBAjByB,CAAA,GAAA,QALvC,MAwBU,CAxBV,GAwBc,UAxBd,CAyBA,OAzBA,CAAA,8BAAA,CAAA,SAAA,IAAA,GA0BI,CA1BJ,CA0BM,CA1BN,CAAA,GA2BI,SA3BJ,CA2Bc,CA3Bd,CA2BgB,CA3BhB,CAAA,CAAA,CAAA,EAA2B;AAAA;;;;;;;;;;;;;;;;;AAWrB;;;;;;;;;;;;AAqDV;;;;AAGa,iBAHG,WAGH,CAAA,UAAA,MAAA,EAAA,gBAHiD,gBAGjD,CAAA,CAAA,IAAA,EAFL,CAEK,EAAA,OAAA,CAAA,EADD,OACC,CAAA,EAAV,SAAU,CAAA,CAAA,EAAG,OAAH,CAAA;;;;AAqCb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,4BAA4B,4BAChC,mCACgB,MAAM,UAAU,GAAG"}