@vinicunca/perkakas 1.12.0 → 1.13.0

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-vYpRavjM.js → to-single-BKYbBic-.js}

@@ -1,2 +1,2 @@
 function e(e){return Object.assign(e,{single:!0})}export{e as t};
-//# sourceMappingURL=to-single-vYpRavjM.js.map
+//# 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-snake-case.cjs

@@ -1 +1 @@
-const e=require(`./to-no-case.cjs`);function t(t,n){return e.toNoCase(t,{delimiter:`_`,...n})}exports.toSnakeCase=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.toSnakeCase=n;

package/dist/to-snake-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-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>;
 /**
- * Convert a string to sentence case.
+ * 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`.
  *
- * @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 *CONSTANT_CASE* use `toUpperCase(toSnakeCase(data))`.
  *
  * @signature
- *   toSnakeCase(str)
+ *   P.toSnakeCase()(data);
  * @example
- *   toSnakeCase('test'); // => 'test'
- *   toSnakeCase('test string'); // => 'test_string'
- *   toSnakeCase('test string', { delimiter: '$' }); // => 'test$string'
- *   toSnakeCase('testV2', { separateNumbers: true }); // => 'test_v_2'
- *   toSnakeCase('__typename', { prefixCharacters: '_' }); // => '__typename'
- *   toSnakeCase('type__', { suffixCharacters: '_' }); // => 'type__'
+ *   P.pipe("hello world", P.toSnakeCase()); // "hello_world"
+ *   P.pipe("__HELLO_WORLD__", P.toSnakeCase()); // "hello_world"
+ * @dataLast
  * @category String
  */
-declare function toSnakeCase(input: string, options?: ChangeCaseOptions): 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

@@ -1 +1 @@
-{"version":3,"file":"to-snake-case.d.cts","names":[],"sources":["../src/to-snake-case.ts"],"sourcesContent":[],"mappings":";;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;;iBAAgB,WAAA,0BAAqC"}
+{"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,31 +1,60 @@
-import { t as ChangeCaseOptions } from "./case.types-CVfGg990.js";
+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>;
 /**
- * Convert a string to sentence case.
+ * 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`.
  *
- * @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 *CONSTANT_CASE* use `toUpperCase(toSnakeCase(data))`.
  *
  * @signature
- *   toSnakeCase(str)
+ *   P.toSnakeCase()(data);
  * @example
- *   toSnakeCase('test'); // => 'test'
- *   toSnakeCase('test string'); // => 'test_string'
- *   toSnakeCase('test string', { delimiter: '$' }); // => 'test$string'
- *   toSnakeCase('testV2', { separateNumbers: true }); // => 'test_v_2'
- *   toSnakeCase('__typename', { prefixCharacters: '_' }); // => '__typename'
- *   toSnakeCase('type__', { suffixCharacters: '_' }); // => 'type__'
+ *   P.pipe("hello world", P.toSnakeCase()); // "hello_world"
+ *   P.pipe("__HELLO_WORLD__", P.toSnakeCase()); // "hello_world"
+ * @dataLast
  * @category String
  */
-declare function toSnakeCase(input: string, options?: ChangeCaseOptions): 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

@@ -1 +1 @@
-{"version":3,"file":"to-snake-case.d.ts","names":[],"sources":["../src/to-snake-case.ts"],"sourcesContent":[],"mappings":";;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;;iBAAgB,WAAA,0BAAqC"}
+{"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,2 +1,2 @@
-import{toNoCase as e}from"./to-no-case.js";function t(t,n){return e(t,{delimiter:`_`,...n})}export{t 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

@@ -1 +1 @@
-{"version":3,"file":"to-snake-case.js","names":[],"sources":["../src/to-snake-case.ts"],"sourcesContent":["import type { ChangeCaseOptions } from './internal/case.types';\n\nimport { toNoCase } from './to-no-case';\n\n/**\n * Convert a string to sentence 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 *   toSnakeCase(str)\n * @example\n *   toSnakeCase('test'); // => 'test'\n *   toSnakeCase('test string'); // => 'test_string'\n *   toSnakeCase('test string', { delimiter: '$' }); // => 'test$string'\n *   toSnakeCase('testV2', { separateNumbers: true }); // => 'test_v_2'\n *   toSnakeCase('__typename', { prefixCharacters: '_' }); // => '__typename'\n *   toSnakeCase('type__', { suffixCharacters: '_' }); // => 'type__'\n * @category String\n */\nexport function toSnakeCase(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-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-Se4KcQka.d.cts → to-string-DkC3zRUJ.d.cts}

@@ -10,4 +10,4 @@
 type ToString<T> = T extends unknown ? T extends number ? `${T}` : T extends string ? T : never : never;
 //#endregion
 export { ToString as t };
-//# sourceMappingURL=to-string-Se4KcQka.d.cts.map
+//# 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-C6_OnZ6e.d.ts → to-string-YIFx2KS6.d.ts}

@@ -10,4 +10,4 @@
 type ToString<T> = T extends unknown ? T extends number ? `${T}` : T extends string ? T : never : never;
 //#endregion
 export { ToString as t };
-//# sourceMappingURL=to-string-C6_OnZ6e.d.ts.map
+//# 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"}

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

@@ -0,0 +1,86 @@
+import { t as OptionalOptionsWithDefaults } from "./optional-options-with-defaults-BFaBSKkF.js";
+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.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"to-title-case.d.ts","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"}

package/dist/to-title-case.js

@@ -0,0 +1,2 @@
+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=>`${e[0].toUpperCase()}${r?e.slice(1):e.slice(1).toLowerCase()}`).join(` `)}export{n as toTitleCase};
+//# sourceMappingURL=to-title-case.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"to-title-case.js","names":[],"sources":["../src/to-title-case.ts"],"sourcesContent":["import type { IsEqual, IsLiteral, Join, Words } 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 TitleCaseOptions {\n  readonly preserveConsecutiveUppercase?: boolean;\n}\n\ntype TitleCaseOptionsWithDefaults<Options extends TitleCaseOptions>\n  = OptionalOptionsWithDefaults<\n    TitleCaseOptions,\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\ntype TitleCase<S extends string, Options extends TitleCaseOptions>\n  = IsLiteral<S> extends true\n    ? Join<\n      TitleCasedArray<\n        Words<IsEqual<S, Uppercase<S>> extends true ? Lowercase<S> : S>,\n        TitleCaseOptionsWithDefaults<Options>\n      >,\n      ' '\n    >\n    : string;\n\ntype TitleCasedArray<\n  T extends ReadonlyArray<string>,\n  Options extends TitleCaseOptions,\n> = {\n  [I in keyof T]: Capitalize<\n    Options['preserveConsecutiveUppercase'] extends true\n      ? T[I]\n      : Lowercase<T[I]>\n  >;\n};\n\n/**\n * Converts text to **Title Case** by splitting it into words, capitalizing the\n * first letter of each word, then joining them back together with spaces.\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 * making it best suited for simple strings like identifiers and internal keys.\n * 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`, `toCamelCase`, `toKebabCase`, and `toSnakeCase`.\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 *   R.toTitleCase(data);\n *   R.toTitleCase(data, { preserveConsecutiveUppercase });\n * @example\n *   R.toTitleCase(\"hello world\"); // \"Hello World\"\n *   R.toTitleCase(\"--foo-bar--\"); // \"Foo Bar\"\n *   R.toTitleCase(\"fooBar\"); // \"Foo Bar\"\n *   R.toTitleCase(\"__FOO_BAR__\"); // \"Foo Bar\"\n *   R.toTitleCase(\"XMLHttpRequest\"); // \"XML Http Request\"\n *   R.toTitleCase(\"XMLHttpRequest\", { preserveConsecutiveUppercase: false }); // \"Xml Http Request\"\n * @dataFirst\n * @category String\n */\nexport function toTitleCase<S extends string, Options extends TitleCaseOptions>(\n  data: S,\n  options?: Options,\n): TitleCase<S, Options>;\n\n/**\n * Converts text to **Title Case** by splitting it into words, capitalizing the\n * first letter of each word, then joining them back together with spaces.\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 * making it best suited for simple strings like identifiers and internal keys.\n * 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`, `toCamelCase`, `toKebabCase`, and `toSnakeCase`.\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 *   R.toTitleCase()(data);\n *   R.toTitleCase({ preserveConsecutiveUppercase })(data);\n * @example\n *   R.pipe(\"hello world\", R.toTitleCase()); // \"Hello World\"\n *   R.pipe(\"--foo-bar--\", R.toTitleCase()); // \"Foo Bar\"\n *   R.pipe(\"fooBar\", R.toTitleCase()); // \"Foo Bar\"\n *   R.pipe(\"__FOO_BAR__\", R.toTitleCase()); // \"Foo Bar\"\n *   R.pipe(\"XMLHttpRequest\", R.toTitleCase()); // \"XML Http Request\"\n *   R.pipe(\n *     \"XMLHttpRequest\",\n *     R.toTitleCase({ preserveConsecutiveUppercase: false }),\n *   ); // \"Xml Http Request\"\n * @dataLast\n * @category String\n */\nexport function toTitleCase<Options extends TitleCaseOptions>(\n  options?: Options,\n): <S extends string>(data: S) => TitleCase<S, Options>;\n\nexport function toTitleCase(\n  dataOrOptions?: TitleCaseOptions | string,\n  options?: TitleCaseOptions,\n): unknown {\n  return typeof dataOrOptions === 'string'\n    ? toTitleCaseImplementation(dataOrOptions, options)\n    : (data: string) => toTitleCaseImplementation(data, dataOrOptions);\n}\n\n// Similar to the implementation used in toCamelCase\nfunction toTitleCaseImplementation(data: string, {\n  preserveConsecutiveUppercase = DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE,\n}: TitleCaseOptions = {}): string {\n  return words(\n    LOWER_CASE_CHARACTER_RE.test(data)\n      ? data\n      // If the text doesn't have **any** lowercase characters, we lowercase\n      // everything; otherwise we maintain existing case as it affects word\n      // boundaries.\n      : data.toLowerCase(),\n  )\n    .map(\n      (word) =>\n        `${word[0]!.toUpperCase()}${\n          preserveConsecutiveUppercase\n            ? word.slice(1)\n            : word.slice(1).toLowerCase()\n        }`,\n    )\n    .join(' ');\n}\n"],"mappings":"wCAIA,MAAM,EAA0B,SAqHhC,SAAgB,EACd,EACA,EACS,CACT,OAAO,OAAO,GAAkB,SAC5B,EAA0B,EAAe,EAAQ,CAChD,GAAiB,EAA0B,EAAM,EAAc,CAItE,SAAS,EAA0B,EAAc,CAC/C,+BAA+B,IACX,EAAE,CAAU,CAChC,OAAO,EACL,EAAwB,KAAK,EAAK,CAC9B,EAIA,EAAK,aAAa,CACvB,CACE,IACE,GACC,GAAG,EAAK,GAAI,aAAa,GACvB,EACI,EAAK,MAAM,EAAE,CACb,EAAK,MAAM,EAAE,CAAC,aAAa,GAEpC,CACA,KAAK,IAAI"}

package/dist/to-upper-case.cjs

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

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

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

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

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