@vinicunca/perkakas 1.14.0 → 1.16.0

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

@@ -1 +1 @@
-{"version":3,"file":"to-kebab-case.cjs","names":["curry","words"],"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 *   toKebabCase(data);\n * @example\n *   toKebabCase(\"hello world\"); // \"hello-world\"\n *   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 *   toKebabCase()(data);\n * @example\n *   pipe(\"hello world\", toKebabCase()); // \"hello-world\"\n *   pipe(\"__HELLO_WORLD__\", 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  return words(data).join('-').toLowerCase();\n}\n"],"mappings":"oIA+DA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAOA,EAAAA,MAAM,EAA2B,EAAK,CAG/C,SAAS,EAA4C,EAAuB,CAC1E,OAAOC,EAAAA,EAAM,EAAK,CAAC,KAAK,IAAI,CAAC,aAAa"}
+{"version":3,"file":"to-kebab-case.cjs","names":["curry","words"],"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 *   toKebabCase(data);\n * @example\n *   toKebabCase(\"hello world\"); // \"hello-world\"\n *   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 *   toKebabCase()(data);\n * @example\n *   pipe(\"hello world\", toKebabCase()); // \"hello-world\"\n *   pipe(\"__HELLO_WORLD__\", 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":"oIA+DA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAOA,EAAAA,MAAM,EAA2B,CAAI,CAC9C,CAEA,SAAS,EAA4C,EAAuB,CAK1E,OAAOC,EAAAA,EAAM,CAAI,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,YAAY,CAC3C"}

package/dist/to-kebab-case.js

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

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

@@ -1 +1 @@
-{"version":3,"file":"to-kebab-case.js","names":[],"sources":["../src/to-kebab-case.ts"],"sourcesContent":["import type { 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 *   toKebabCase(data);\n * @example\n *   toKebabCase(\"hello world\"); // \"hello-world\"\n *   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 *   toKebabCase()(data);\n * @example\n *   pipe(\"hello world\", toKebabCase()); // \"hello-world\"\n *   pipe(\"__HELLO_WORLD__\", 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  return words(data).join('-').toLowerCase();\n}\n"],"mappings":"sEA+DA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,EAA2B,EAAK,CAG/C,SAAS,EAA4C,EAAuB,CAC1E,OAAO,EAAM,EAAK,CAAC,KAAK,IAAI,CAAC,aAAa"}
+{"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 *   toKebabCase(data);\n * @example\n *   toKebabCase(\"hello world\"); // \"hello-world\"\n *   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 *   toKebabCase()(data);\n * @example\n *   pipe(\"hello world\", toKebabCase()); // \"hello-world\"\n *   pipe(\"__HELLO_WORLD__\", 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":"sEA+DA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,EAA2B,CAAI,CAC9C,CAEA,SAAS,EAA4C,EAAuB,CAK1E,OAAO,EAAM,CAAI,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,YAAY,CAC3C"}

package/dist/to-lower-case.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e){return e.toLowerCase()}exports.toLowerCase=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs");function t(...t){return e.curry(n,t)}function n(e){return e.toLowerCase()}exports.toLowerCase=t;
 //# sourceMappingURL=to-lower-case.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"to-lower-case.cjs","names":["curry"],"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 *   toLowerCase(data);\n * @example\n *   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 *   toLowerCase()(data);\n * @example\n *   pipe(\"Hello World\", 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  return data.toLowerCase();\n}\n"],"mappings":"kGAmDA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAOA,EAAAA,MAAM,EAA2B,EAAK,CAG/C,SAAS,EAA4C,EAAuB,CAC1E,OAAO,EAAK,aAAa"}
+{"version":3,"file":"to-lower-case.cjs","names":["curry"],"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 *   toLowerCase(data);\n * @example\n *   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 *   toLowerCase()(data);\n * @example\n *   pipe(\"Hello World\", 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  return data.toLowerCase();\n}\n"],"mappings":"kGAmDA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAOA,EAAAA,MAAM,EAA2B,CAAI,CAC9C,CAEA,SAAS,EAA4C,EAAuB,CAC1E,OAAO,EAAK,YAAY,CAC1B"}

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

@@ -1 +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 *   toLowerCase(data);\n * @example\n *   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 *   toLowerCase()(data);\n * @example\n *   pipe(\"Hello World\", 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  return data.toLowerCase();\n}\n"],"mappings":"mCAmDA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,EAA2B,EAAK,CAG/C,SAAS,EAA4C,EAAuB,CAC1E,OAAO,EAAK,aAAa"}
+{"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 *   toLowerCase(data);\n * @example\n *   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 *   toLowerCase()(data);\n * @example\n *   pipe(\"Hello World\", 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  return data.toLowerCase();\n}\n"],"mappings":"mCAmDA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,EAA2B,CAAI,CAC9C,CAEA,SAAS,EAA4C,EAAuB,CAC1E,OAAO,EAAK,YAAY,CAC1B"}

package/dist/to-single-BOkjnmkm.cjs

@@ -0,0 +1,2 @@
+function e(e){return Object.assign(e,{single:!0})}Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return e}});
+//# sourceMappingURL=to-single-BOkjnmkm.cjs.map

package/dist/{to-single-BunGuk7o.cjs.map → to-single-BOkjnmkm.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"to-single-BunGuk7o.cjs","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"}
+{"version":3,"file":"to-single-BOkjnmkm.cjs","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,EAAc,CAAC,CACpD"}

package/dist/{to-single-XEXXW73e.js → to-single-D6t2BxVq.js}

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

package/dist/{to-single-XEXXW73e.js.map → to-single-D6t2BxVq.js.map}

@@ -1 +1 @@
-{"version":3,"file":"to-single-XEXXW73e.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"}
+{"version":3,"file":"to-single-D6t2BxVq.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,EAAc,CAAC,CACpD"}

package/dist/to-snake-case.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`),t=require(`./words-C8Rd_80F.cjs`);function n(...t){return e.curry(r,t)}function r(e){return t.t(e).join(`_`).toLowerCase()}exports.toSnakeCase=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs"),t=require("./words-B-9EXtsW.cjs");function n(...t){return e.curry(r,t)}function r(e){return t.t(e).join(`_`).toLowerCase()}exports.toSnakeCase=n;
 //# sourceMappingURL=to-snake-case.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"to-snake-case.cjs","names":["curry","words"],"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 *   toSnakeCase(data);\n * @example\n *   toSnakeCase(\"hello world\"); // \"hello_world\"\n *   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 *   toSnakeCase()(data);\n * @example\n *   pipe(\"hello world\", toSnakeCase()); // \"hello_world\"\n *   pipe(\"__HELLO_WORLD__\", 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  return words(data).join('_').toLowerCase();\n}\n"],"mappings":"oIA+DA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAOA,EAAAA,MAAM,EAA2B,EAAK,CAG/C,SAAS,EAA4C,EAAuB,CAC1E,OAAOC,EAAAA,EAAM,EAAK,CAAC,KAAK,IAAI,CAAC,aAAa"}
+{"version":3,"file":"to-snake-case.cjs","names":["curry","words"],"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 *   toSnakeCase(data);\n * @example\n *   toSnakeCase(\"hello world\"); // \"hello_world\"\n *   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 *   toSnakeCase()(data);\n * @example\n *   pipe(\"hello world\", toSnakeCase()); // \"hello_world\"\n *   pipe(\"__HELLO_WORLD__\", 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  return words(data).join('_').toLowerCase();\n}\n"],"mappings":"oIA+DA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAOA,EAAAA,MAAM,EAA2B,CAAI,CAC9C,CAEA,SAAS,EAA4C,EAAuB,CAC1E,OAAOC,EAAAA,EAAM,CAAI,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,YAAY,CAC3C"}

package/dist/to-snake-case.js

@@ -1,2 +1,2 @@
-import{curry as e}from"./curry.js";import{t}from"./words-CYZ0Lyko.js";function n(...t){return e(r,t)}function r(e){return t(e).join(`_`).toLowerCase()}export{n as toSnakeCase};
+import{curry as e}from"./curry.js";import{t}from"./words-CN1Qil5U.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 { 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 *   toSnakeCase(data);\n * @example\n *   toSnakeCase(\"hello world\"); // \"hello_world\"\n *   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 *   toSnakeCase()(data);\n * @example\n *   pipe(\"hello world\", toSnakeCase()); // \"hello_world\"\n *   pipe(\"__HELLO_WORLD__\", 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  return words(data).join('_').toLowerCase();\n}\n"],"mappings":"sEA+DA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,EAA2B,EAAK,CAG/C,SAAS,EAA4C,EAAuB,CAC1E,OAAO,EAAM,EAAK,CAAC,KAAK,IAAI,CAAC,aAAa"}
+{"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 *   toSnakeCase(data);\n * @example\n *   toSnakeCase(\"hello world\"); // \"hello_world\"\n *   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 *   toSnakeCase()(data);\n * @example\n *   pipe(\"hello world\", toSnakeCase()); // \"hello_world\"\n *   pipe(\"__HELLO_WORLD__\", 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  return words(data).join('_').toLowerCase();\n}\n"],"mappings":"sEA+DA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,EAA2B,CAAI,CAC9C,CAEA,SAAS,EAA4C,EAAuB,CAC1E,OAAO,EAAM,CAAI,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,YAAY,CAC3C"}

package/dist/to-title-case.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./words-C8Rd_80F.cjs`),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(t.test(n)?n:n.toLowerCase()).map(e=>`${e[0].toUpperCase()}${r?e.slice(1):e.slice(1).toLowerCase()}`).join(` `)}exports.toTitleCase=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./words-B-9EXtsW.cjs"),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(t.test(n)?n:n.toLowerCase()).map(e=>`${e[0].toUpperCase()}${r?e.slice(1):e.slice(1).toLowerCase()}`).join(` `)}exports.toTitleCase=n;
 //# sourceMappingURL=to-title-case.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"to-title-case.cjs","names":["words"],"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 *   toTitleCase(data);\n *   toTitleCase(data, { preserveConsecutiveUppercase });\n * @example\n *   toTitleCase(\"hello world\"); // \"Hello World\"\n *   toTitleCase(\"--foo-bar--\"); // \"Foo Bar\"\n *   toTitleCase(\"fooBar\"); // \"Foo Bar\"\n *   toTitleCase(\"__FOO_BAR__\"); // \"Foo Bar\"\n *   toTitleCase(\"XMLHttpRequest\"); // \"XML Http Request\"\n *   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 *   toTitleCase()(data);\n *   toTitleCase({ preserveConsecutiveUppercase })(data);\n * @example\n *   pipe(\"hello world\", toTitleCase()); // \"Hello World\"\n *   pipe(\"--foo-bar--\", toTitleCase()); // \"Foo Bar\"\n *   pipe(\"fooBar\", toTitleCase()); // \"Foo Bar\"\n *   pipe(\"__FOO_BAR__\", toTitleCase()); // \"Foo Bar\"\n *   pipe(\"XMLHttpRequest\", toTitleCase()); // \"XML Http Request\"\n *   pipe(\n *     \"XMLHttpRequest\",\n *     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":"2GAIM,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,OAAOA,EAAAA,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"}
+{"version":3,"file":"to-title-case.cjs","names":["words"],"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 *   toTitleCase(data);\n *   toTitleCase(data, { preserveConsecutiveUppercase });\n * @example\n *   toTitleCase(\"hello world\"); // \"Hello World\"\n *   toTitleCase(\"--foo-bar--\"); // \"Foo Bar\"\n *   toTitleCase(\"fooBar\"); // \"Foo Bar\"\n *   toTitleCase(\"__FOO_BAR__\"); // \"Foo Bar\"\n *   toTitleCase(\"XMLHttpRequest\"); // \"XML Http Request\"\n *   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 *   toTitleCase()(data);\n *   toTitleCase({ preserveConsecutiveUppercase })(data);\n * @example\n *   pipe(\"hello world\", toTitleCase()); // \"Hello World\"\n *   pipe(\"--foo-bar--\", toTitleCase()); // \"Foo Bar\"\n *   pipe(\"fooBar\", toTitleCase()); // \"Foo Bar\"\n *   pipe(\"__FOO_BAR__\", toTitleCase()); // \"Foo Bar\"\n *   pipe(\"XMLHttpRequest\", toTitleCase()); // \"XML Http Request\"\n *   pipe(\n *     \"XMLHttpRequest\",\n *     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":"2GAIM,EAA0B,SAqHhC,SAAgB,EACd,EACA,EACS,CACT,OAAO,OAAO,GAAkB,SAC5B,EAA0B,EAAe,CAAO,EAC/C,GAAiB,EAA0B,EAAM,CAAa,CACrE,CAGA,SAAS,EAA0B,EAAc,CAC/C,+BAA+B,IACX,CAAC,EAAW,CAChC,OAAOA,EAAAA,EACL,EAAwB,KAAK,CAAI,EAC7B,EAIA,EAAK,YAAY,CACvB,CAAC,CACE,IACE,GACC,GAAG,EAAK,EAAE,CAAE,YAAY,IACtB,EACI,EAAK,MAAM,CAAC,EACZ,EAAK,MAAM,CAAC,CAAC,CAAC,YAAY,GAEpC,CAAC,CACA,KAAK,GAAG,CACb"}

package/dist/to-title-case.js

@@ -1,2 +1,2 @@
-import{t as e}from"./words-CYZ0Lyko.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};
+import{t as e}from"./words-CN1Qil5U.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

@@ -1 +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 *   toTitleCase(data);\n *   toTitleCase(data, { preserveConsecutiveUppercase });\n * @example\n *   toTitleCase(\"hello world\"); // \"Hello World\"\n *   toTitleCase(\"--foo-bar--\"); // \"Foo Bar\"\n *   toTitleCase(\"fooBar\"); // \"Foo Bar\"\n *   toTitleCase(\"__FOO_BAR__\"); // \"Foo Bar\"\n *   toTitleCase(\"XMLHttpRequest\"); // \"XML Http Request\"\n *   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 *   toTitleCase()(data);\n *   toTitleCase({ preserveConsecutiveUppercase })(data);\n * @example\n *   pipe(\"hello world\", toTitleCase()); // \"Hello World\"\n *   pipe(\"--foo-bar--\", toTitleCase()); // \"Foo Bar\"\n *   pipe(\"fooBar\", toTitleCase()); // \"Foo Bar\"\n *   pipe(\"__FOO_BAR__\", toTitleCase()); // \"Foo Bar\"\n *   pipe(\"XMLHttpRequest\", toTitleCase()); // \"XML Http Request\"\n *   pipe(\n *     \"XMLHttpRequest\",\n *     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"}
+{"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 *   toTitleCase(data);\n *   toTitleCase(data, { preserveConsecutiveUppercase });\n * @example\n *   toTitleCase(\"hello world\"); // \"Hello World\"\n *   toTitleCase(\"--foo-bar--\"); // \"Foo Bar\"\n *   toTitleCase(\"fooBar\"); // \"Foo Bar\"\n *   toTitleCase(\"__FOO_BAR__\"); // \"Foo Bar\"\n *   toTitleCase(\"XMLHttpRequest\"); // \"XML Http Request\"\n *   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 *   toTitleCase()(data);\n *   toTitleCase({ preserveConsecutiveUppercase })(data);\n * @example\n *   pipe(\"hello world\", toTitleCase()); // \"Hello World\"\n *   pipe(\"--foo-bar--\", toTitleCase()); // \"Foo Bar\"\n *   pipe(\"fooBar\", toTitleCase()); // \"Foo Bar\"\n *   pipe(\"__FOO_BAR__\", toTitleCase()); // \"Foo Bar\"\n *   pipe(\"XMLHttpRequest\", toTitleCase()); // \"XML Http Request\"\n *   pipe(\n *     \"XMLHttpRequest\",\n *     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,CAAO,EAC/C,GAAiB,EAA0B,EAAM,CAAa,CACrE,CAGA,SAAS,EAA0B,EAAc,CAC/C,+BAA+B,IACX,CAAC,EAAW,CAChC,OAAO,EACL,EAAwB,KAAK,CAAI,EAC7B,EAIA,EAAK,YAAY,CACvB,CAAC,CACE,IACE,GACC,GAAG,EAAK,EAAE,CAAE,YAAY,IACtB,EACI,EAAK,MAAM,CAAC,EACZ,EAAK,MAAM,CAAC,CAAC,CAAC,YAAY,GAEpC,CAAC,CACA,KAAK,GAAG,CACb"}

package/dist/to-upper-case.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e){return e.toUpperCase()}exports.toUpperCase=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs");function t(...t){return e.curry(n,t)}function n(e){return e.toUpperCase()}exports.toUpperCase=t;
 //# sourceMappingURL=to-upper-case.cjs.map

package/dist/to-upper-case.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"to-upper-case.cjs","names":["curry"],"sources":["../src/to-upper-case.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Replaces all lowercase characters with their uppercase equivalents.\n *\n * This function is a wrapper around the built-in\n * [`String.prototype.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)\n * method and shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase#description)_.\n *\n * For a more linguistically accurate transformation use [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase),\n * and for display purposes use CSS [`text-transform: uppercase;`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform)\n * which *is* locale-aware.\n *\n * For other case manipulations see: `toLowerCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @param data - A string.\n * @signature\n *   toUpperCase(data);\n * @example\n *   toUpperCase(\"Hello World\"); // \"HELLO WORLD\"\n * @dataFirst\n * @category String\n */\nexport function toUpperCase<T extends string>(data: T): Uppercase<T>;\n\n/**\n * Replaces all lowercase characters with their uppercase equivalents.\n *\n * This function is a wrapper around the built-in\n * [`String.prototype.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)\n * method and shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase#description)_.\n *\n * For a more linguistically accurate transformation use [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase),\n * and for display purposes use CSS [`text-transform: uppercase;`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform)\n * which *is* locale-aware.\n *\n * For other case manipulations see: `toLowerCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @signature\n *   toUpperCase()(data);\n * @example\n *   pipe(\"Hello World\", toUpperCase()); // \"HELLO WORLD\"\n * @dataLast\n * @category String\n */\nexport function toUpperCase(): <T extends string>(data: T) => Uppercase<T>;\n\nexport function toUpperCase(...args: ReadonlyArray<unknown>): unknown {\n  return curry(toUpperCaseImplementation, args);\n}\n\nfunction toUpperCaseImplementation<T extends string>(data: T): Uppercase<T> {\n  return data.toUpperCase();\n}\n"],"mappings":"kGAmDA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAOA,EAAAA,MAAM,EAA2B,EAAK,CAG/C,SAAS,EAA4C,EAAuB,CAC1E,OAAO,EAAK,aAAa"}
+{"version":3,"file":"to-upper-case.cjs","names":["curry"],"sources":["../src/to-upper-case.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Replaces all lowercase characters with their uppercase equivalents.\n *\n * This function is a wrapper around the built-in\n * [`String.prototype.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)\n * method and shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase#description)_.\n *\n * For a more linguistically accurate transformation use [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase),\n * and for display purposes use CSS [`text-transform: uppercase;`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform)\n * which *is* locale-aware.\n *\n * For other case manipulations see: `toLowerCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @param data - A string.\n * @signature\n *   toUpperCase(data);\n * @example\n *   toUpperCase(\"Hello World\"); // \"HELLO WORLD\"\n * @dataFirst\n * @category String\n */\nexport function toUpperCase<T extends string>(data: T): Uppercase<T>;\n\n/**\n * Replaces all lowercase characters with their uppercase equivalents.\n *\n * This function is a wrapper around the built-in\n * [`String.prototype.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)\n * method and shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase#description)_.\n *\n * For a more linguistically accurate transformation use [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase),\n * and for display purposes use CSS [`text-transform: uppercase;`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform)\n * which *is* locale-aware.\n *\n * For other case manipulations see: `toLowerCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @signature\n *   toUpperCase()(data);\n * @example\n *   pipe(\"Hello World\", toUpperCase()); // \"HELLO WORLD\"\n * @dataLast\n * @category String\n */\nexport function toUpperCase(): <T extends string>(data: T) => Uppercase<T>;\n\nexport function toUpperCase(...args: ReadonlyArray<unknown>): unknown {\n  return curry(toUpperCaseImplementation, args);\n}\n\nfunction toUpperCaseImplementation<T extends string>(data: T): Uppercase<T> {\n  return data.toUpperCase();\n}\n"],"mappings":"kGAmDA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAOA,EAAAA,MAAM,EAA2B,CAAI,CAC9C,CAEA,SAAS,EAA4C,EAAuB,CAC1E,OAAO,EAAK,YAAY,CAC1B"}

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

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

package/dist/truncate.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"truncate.cjs","names":[],"sources":["../src/truncate.ts"],"sourcesContent":["import type {\n  And,\n  IsEqual,\n  IsNever,\n  IsStringLiteral,\n  NonNegativeInteger,\n} from 'type-fest';\nimport type { ClampedIntegerSubtract } from './internal/types/clamped-integer-subtract';\nimport type { StringLength } from './internal/types/string-length';\n\ninterface TruncateOptions {\n  readonly omission?: string;\n  readonly separator?: string | RegExp;\n}\n\nconst DEFAULT_OMISSION = '...';\n\ntype Truncate<\n  S extends string,\n  N extends number,\n  Options extends TruncateOptions,\n>\n  = IsNever<NonNegativeInteger<N>> extends true\n    ? // There's nothing we can say about the output without a literal, valid,\n  // truncation length `N`.\n    string\n    : IsStringLiteral<S> extends true\n      ? TruncateWithOptions<\n        S,\n        N,\n        // TODO: I don't like how I handled the default options object; I want to have everything coupled between the runtime and the type system, but this feels both brittle to changes, and over-verbose.\n        Options extends Pick<Required<TruncateOptions>, 'omission'>\n          ? Options['omission']\n          : typeof DEFAULT_OMISSION,\n        Options extends Pick<Required<TruncateOptions>, 'separator'>\n          ? Options['separator']\n          : undefined\n      >\n      : // There's nothing we can say about the output without a literal input\n    // string `S`, the result would always be, at best, just a `string`.\n      string;\n\ntype TruncateWithOptions<\n  S extends string,\n  N extends number,\n  Omission extends string,\n  Separator extends string | RegExp | undefined,\n>\n  // Distribute the result over unions.\n  = N extends unknown\n    ? // We can short-circuit most of our logic when N is a literal 0.\n    IsEqual<N, 0> extends true\n      ? ''\n      : // Distribute the result over unions.\n      Omission extends unknown\n        ? // When Omission isn't literal we don't know how long it is.\n        IsStringLiteral<Omission> extends true\n          ? // This mirrors the runtime logic where if `n - omission.length`\n        // is not positive then what we end up truncating is Omission\n        // itself and not S.\n          IsEqual<\n            ClampedIntegerSubtract<N, StringLength<Omission>>,\n            0\n          > extends true\n            ? TruncateLiterals<Omission, N, ''>\n            : And<\n              // When S isn't literal the output wouldn't be literal\n              // either.\n              IsStringLiteral<S>,\n              // TODO: Handling non-trivial separators would add a ton of complexity to this type! It's possible (but hard!) to support string literals so I'm leaving this as a TODO; regular expressions are impossible because we can't get the type checker to run them.\n              IsEqual<Separator, undefined>\n            > extends true\n              ? TruncateLiterals<S, N, Omission>\n              : string\n          : string\n        : never\n    : never;\n\n/**\n * This is the actual implementation of the truncation logic. It assumes all\n * its params are literals and valid.\n */\ntype TruncateLiterals<\n  S extends string,\n  N extends number,\n  Omission extends string,\n  Iteration extends ReadonlyArray<unknown> = [],\n> = S extends `${infer Character}${infer Rest}`\n  ? // The cutoff point N - omission.length leaves room for the omission.\n  Iteration['length'] extends ClampedIntegerSubtract<\n    N,\n    StringLength<Omission>\n  >\n    ? // The string is only truncated if its total length is longer than N; at\n  // the cutoff point this is simplified to comparing the remaining suffix\n  // length to the omission length.\n    IsLongerThan<S, Omission> extends true\n      ? Omission\n      : S\n    : // Reconstruct string character by character until cutoff.\n      `${Character}${TruncateLiterals<Rest, N, Omission, [...Iteration, unknown]>}`\n  : // Empty input string results in empty output.\n  '';\n\n/**\n * An optimized check that efficiently checks if the string A is longer than B.\n */\ntype IsLongerThan<\n  A extends string,\n  B extends string,\n> = A extends `${string}${infer RestA}`\n  ? B extends `${string}${infer RestB}`\n    ? IsLongerThan<RestA, RestB>\n    : // B is empty and A isn't!\n    true\n  : // A is empty, even if B is empty, A wouldn't be (strictly) longer.\n  false;\n\n/**\n * Truncates strings to a maximum length, adding an ellipsis when truncated.\n *\n * Shorter strings are returned unchanged. If the omission marker is longer than\n * the maximum length, it will be truncated as well.\n *\n * The `separator` argument provides more control by optimistically searching\n * for a matching cutoff point, which could be used to avoid truncating in the\n * middle of a word or other semantic boundary.\n *\n * If you just need to limit the total length of the string, without adding an\n * `omission` or optimizing the cutoff point via `separator`, prefer\n * `sliceString` instead, which runs more efficiently.\n *\n * The function counts Unicode characters, not visual graphemes, and may split\n * emojis, denormalized diacritics, or combining characters, in the middle. For\n * display purposes, prefer CSS [`text-overflow: ellipsis`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-overflow#ellipsis)\n * which is locale-aware and purpose-built for this task.\n *\n * @param data - The input string.\n * @param n - The maximum length of the output string. The output will **never**\n * exceed this length.\n * @param options - An optional options object.\n * @param options.omission - The string that is appended to the end of the\n * output *whenever the input string is truncated*. Default: '...'.\n * @param options.separator - A string or regular expression that defines a\n * cutoff point for the truncation. If multiple cutoff points are found, the one\n * closest to `n` will be used, and if no cutoff point is found then the\n * function will fallback to the trivial cutoff point. Regular expressions are\n * also supported. Default: <none> (which is equivalent to `\"\"` or the regular\n * expression `/./`).\n * @signature\n *   truncate(data, n, { omission, separator });\n * @example\n *   truncate(\"Hello, world!\", 8); //=> \"Hello...\"\n *   truncate(\n *     \"cat, dog, mouse\",\n *     12,\n *     { omission: \"__\", separator: \",\"},\n *   ); //=> \"cat, dog__\"\n * @dataFirst\n * @category String\n */\nexport function truncate<\n  S extends string,\n  N extends number,\n  const Options extends TruncateOptions,\n>(data: S, n: N, options?: Options): Truncate<S, N, Options>;\n\n/**\n * Truncates strings to a maximum length, adding an ellipsis when truncated.\n *\n * Shorter strings are returned unchanged. If the omission marker is longer than\n * the maximum length, it will be truncated as well.\n *\n * The `separator` argument provides more control by optimistically searching\n * for a matching cutoff point, which could be used to avoid truncating in the\n * middle of a word or other semantic boundary.\n *\n * If you just need to limit the total length of the string, without adding an\n * `omission` or optimizing the cutoff point via `separator`, prefer\n * `sliceString` instead, which runs more efficiently.\n *\n * The function counts Unicode characters, not visual graphemes, and may split\n * emojis, denormalized diacritics, or combining characters, in the middle. For\n * display purposes, prefer CSS [`text-overflow: ellipsis`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-overflow#ellipsis)\n * which is locale-aware and purpose-built for this task.\n *\n * @param n - The maximum length of the output string. The output will **never**\n * exceed this length.\n * @param options - An optional options object.\n * @param options.omission - The string that is appended to the end of the\n * output *whenever the input string is truncated*. Default: '...'.\n * @param options.separator - A string or regular expression that defines a\n * cutoff point for the truncation. If multiple cutoff points are found, the one\n * closest to `n` will be used, and if no cutoff point is found then the\n * function will fallback to the trivial cutoff point. Regular expressions are\n * also supported. Default: <none> (which is equivalent to `\"\"` or the regular\n * expression `/./`).\n * @signature\n *   truncate(n, { omission, separator })(data);\n * @example\n *   pipe(\"Hello, world!\" as const, truncate(8)); //=> \"Hello...\"\n *   pipe(\n *     \"cat, dog, mouse\" as const,\n *     truncate(12, { omission: \"__\", separator: \",\"}),\n *   ); //=> \"cat, dog__\"\n * @dataLast\n * @category String\n */\nexport function truncate<\n  N extends number,\n  const Options extends TruncateOptions,\n>(\n  n: N,\n  options?: Options,\n): <S extends string>(data: S) => Truncate<S, N, Options>;\n\nexport function truncate(\n  dataOrN: string | number,\n  nOrOptions?: number | TruncateOptions,\n  options?: TruncateOptions,\n): unknown {\n  return typeof dataOrN === 'string'\n    ? truncateImplementation(\n        dataOrN,\n        // @ts-expect-error [ts2345] -- We want to reduce runtime checks to a\n        // minimum, and there's no (easy) way to couple params so that when we\n        // check one, the others are inferred accordingly.\n        nOrOptions,\n        options,\n      )\n    : (data: string) =>\n        truncateImplementation(\n          data,\n          dataOrN,\n          // @ts-expect-error [ts2345] -- We want to reduce runtime checks to a\n          // minimum, and there's no (easy) way to couple params so that when we\n          // check one, the others are inferred accordingly.\n          nOrOptions,\n        );\n}\n\nfunction truncateImplementation(\n  data: string,\n  n: number,\n  { omission = DEFAULT_OMISSION, separator }: TruncateOptions = {},\n): string {\n  if (data.length <= n) {\n    // No truncation needed.\n    return data;\n  }\n\n  if (n <= 0) {\n    // Avoid weirdness when n isn't positive.\n    return '';\n  }\n\n  if (n < omission.length) {\n    // TODO [>3]: This was an oversight, there's no value in returning just parts of the omission string itself, with no actual content. Instead, we should truncate the input without adding the omission at all in cases where the omission would completely eclipse the content.\n    // Handle cases where the omission itself is too long.\n    return omission.slice(0, n);\n  }\n\n  // Our trivial cutoff is the point where we can add the omission and reach\n  // n exactly, this is what we'll use when no separator is provided.\n  let cutoff = n - omission.length;\n\n  if (typeof separator === 'string') {\n    const lastSeparator = data.lastIndexOf(separator, cutoff);\n    if (lastSeparator !== -1) {\n      // If we find the separator within the part of the string that would be\n      // returned we move the cutoff further so that we also remove it.\n      cutoff = lastSeparator;\n    }\n  } else if (separator !== undefined) {\n    const globalSeparator = separator.flags.includes('g')\n      ? separator\n      : new RegExp(separator.source, `${separator.flags}g`);\n\n    let lastSeparator;\n    for (const { index } of data.matchAll(globalSeparator)) {\n      if (index > cutoff) {\n        // We only care about separators within the part of the string that\n        // would be returned anyway, once we are past that point we don't care\n        // about any further separators.\n        break;\n      }\n      lastSeparator = index;\n    }\n    if (lastSeparator !== undefined) {\n      cutoff = lastSeparator;\n    }\n  }\n\n  // Build the output.\n  return `${data.slice(0, cutoff)}${omission}`;\n}\n"],"mappings":"mEAwNA,SAAgB,EACd,EACA,EACA,EACS,CACT,OAAO,OAAO,GAAY,SACtB,EACE,EAIA,EACA,EACD,CACA,GACC,EACE,EACA,EAIA,EACD,CAGT,SAAS,EACP,EACA,EACA,CAAE,WAAW,MAAkB,aAA+B,EAAE,CACxD,CACR,GAAI,EAAK,QAAU,EAEjB,OAAO,EAGT,GAAI,GAAK,EAEP,MAAO,GAGT,GAAI,EAAI,EAAS,OAGf,OAAO,EAAS,MAAM,EAAG,EAAE,CAK7B,IAAI,EAAS,EAAI,EAAS,OAE1B,GAAI,OAAO,GAAc,SAAU,CACjC,IAAM,EAAgB,EAAK,YAAY,EAAW,EAAO,CACrD,IAAkB,KAGpB,EAAS,WAEF,IAAc,IAAA,GAAW,CAClC,IAAM,EAAkB,EAAU,MAAM,SAAS,IAAI,CACjD,EACA,IAAI,OAAO,EAAU,OAAQ,GAAG,EAAU,MAAM,GAAG,CAEnD,EACJ,IAAK,GAAM,CAAE,WAAW,EAAK,SAAS,EAAgB,CAAE,CACtD,GAAI,EAAQ,EAIV,MAEF,EAAgB,EAEd,IAAkB,IAAA,KACpB,EAAS,GAKb,MAAO,GAAG,EAAK,MAAM,EAAG,EAAO,GAAG"}
+{"version":3,"file":"truncate.cjs","names":[],"sources":["../src/truncate.ts"],"sourcesContent":["import type { IsNever, IsStringLiteral, NonNegativeInteger } from 'type-fest';\nimport type { ClampedIntegerSubtract } from './internal/types/clamped-integer-subtract';\nimport type { StringLength } from './internal/types/string-length';\n\ninterface TruncateOptions {\n  readonly omission?: string;\n  readonly separator?: string | RegExp;\n}\n\nconst DEFAULT_OMISSION = '...';\n\ntype Truncate<\n  S extends string,\n  N extends number,\n  Options extends TruncateOptions,\n>\n  = IsNever<NonNegativeInteger<N>> extends true\n    ? // There's nothing we can say about the output without a literal, valid,\n  // truncation length `N`.\n    string\n    : IsStringLiteral<S> extends true\n      ? TruncateWithOptions<\n        S,\n        N,\n        // TODO: I don't like how I handled the default options object; I want to have everything coupled between the runtime and the type system, but this feels both brittle to changes, and over-verbose.\n        Options extends Pick<Required<TruncateOptions>, 'omission'>\n          ? Options['omission']\n          : typeof DEFAULT_OMISSION,\n        Options extends Pick<Required<TruncateOptions>, 'separator'>\n          ? Options['separator']\n          : undefined\n      >\n      : // There's nothing we can say about the output without a literal input\n    // string `S`, the result would always be, at best, just a `string`.\n      string;\n\ntype TruncateWithOptions<\n  S extends string,\n  N extends number,\n  Omission extends string,\n  Separator extends string | RegExp | undefined,\n>\n  // Distribute the result over unions.\n  = N extends unknown\n    ? // We can short-circuit most of our logic when N is a literal 0.\n      [N] extends [0]\n        ? ''\n        : // Distribute the result over unions.\n        Omission extends unknown\n          ? // When Omission isn't literal we don't know how long it is.\n          IsStringLiteral<Omission> extends true\n            ? // This mirrors the runtime logic where if `n - omission.length`\n            // is not positive then what we end up truncating is Omission\n            // itself and not S.\n              [ClampedIntegerSubtract<N, StringLength<Omission>>] extends [0]\n                ? TruncateLiterals<Omission, N, ''>\n                : // When S isn't literal the output wouldn't be literal either.\n                IsStringLiteral<S> extends true\n                  ? // TODO: Handling non-trivial separators would add a ton of complexity to this type! It's possible (but hard!) to support string literals so I'm leaving this as a TODO; regular expressions are impossible because we can't get the type checker to run them.\n                    [Separator] extends [undefined]\n                      ? TruncateLiterals<S, N, Omission>\n                      : string\n                  : string\n            : string\n          : never\n    : never;\n\n/**\n * This is the actual implementation of the truncation logic. It assumes all\n * its params are literals and valid.\n */\ntype TruncateLiterals<\n  S extends string,\n  N extends number,\n  Omission extends string,\n  Iteration extends ReadonlyArray<unknown> = [],\n> = S extends `${infer Character}${infer Rest}`\n  ? // The cutoff point N - omission.length leaves room for the omission.\n  Iteration['length'] extends ClampedIntegerSubtract<\n    N,\n    StringLength<Omission>\n  >\n    ? // The string is only truncated if its total length is longer than N; at\n  // the cutoff point this is simplified to comparing the remaining suffix\n  // length to the omission length.\n    IsLongerThan<S, Omission> extends true\n      ? Omission\n      : S\n    : // Reconstruct string character by character until cutoff.\n      `${Character}${TruncateLiterals<Rest, N, Omission, [...Iteration, unknown]>}`\n  : // Empty input string results in empty output.\n  '';\n\n/**\n * An optimized check that efficiently checks if the string A is longer than B.\n */\ntype IsLongerThan<\n  A extends string,\n  B extends string,\n> = A extends `${string}${infer RestA}`\n  ? B extends `${string}${infer RestB}`\n    ? IsLongerThan<RestA, RestB>\n    : // B is empty and A isn't!\n    true\n  : // A is empty, even if B is empty, A wouldn't be (strictly) longer.\n  false;\n\n/**\n * Truncates strings to a maximum length, adding an ellipsis when truncated.\n *\n * Shorter strings are returned unchanged. If the omission marker is longer than\n * the maximum length, it will be truncated as well.\n *\n * The `separator` argument provides more control by optimistically searching\n * for a matching cutoff point, which could be used to avoid truncating in the\n * middle of a word or other semantic boundary.\n *\n * If you just need to limit the total length of the string, without adding an\n * `omission` or optimizing the cutoff point via `separator`, prefer\n * `sliceString` instead, which runs more efficiently.\n *\n * The function counts Unicode characters, not visual graphemes, and may split\n * emojis, denormalized diacritics, or combining characters, in the middle. For\n * display purposes, prefer CSS [`text-overflow: ellipsis`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-overflow#ellipsis)\n * which is locale-aware and purpose-built for this task.\n *\n * @param data - The input string.\n * @param n - The maximum length of the output string. The output will **never**\n * exceed this length.\n * @param options - An optional options object.\n * @param options.omission - The string that is appended to the end of the\n * output *whenever the input string is truncated*. Default: '...'.\n * @param options.separator - A string or regular expression that defines a\n * cutoff point for the truncation. If multiple cutoff points are found, the one\n * closest to `n` will be used, and if no cutoff point is found then the\n * function will fallback to the trivial cutoff point. Regular expressions are\n * also supported. Default: <none> (which is equivalent to `\"\"` or the regular\n * expression `/./`).\n * @signature\n *   truncate(data, n, { omission, separator });\n * @example\n *   truncate(\"Hello, world!\", 8); //=> \"Hello...\"\n *   truncate(\n *     \"cat, dog, mouse\",\n *     12,\n *     { omission: \"__\", separator: \",\"},\n *   ); //=> \"cat, dog__\"\n * @dataFirst\n * @category String\n */\nexport function truncate<\n  S extends string,\n  N extends number,\n  const Options extends TruncateOptions,\n>(data: S, n: N, options?: Options): Truncate<S, N, Options>;\n\n/**\n * Truncates strings to a maximum length, adding an ellipsis when truncated.\n *\n * Shorter strings are returned unchanged. If the omission marker is longer than\n * the maximum length, it will be truncated as well.\n *\n * The `separator` argument provides more control by optimistically searching\n * for a matching cutoff point, which could be used to avoid truncating in the\n * middle of a word or other semantic boundary.\n *\n * If you just need to limit the total length of the string, without adding an\n * `omission` or optimizing the cutoff point via `separator`, prefer\n * `sliceString` instead, which runs more efficiently.\n *\n * The function counts Unicode characters, not visual graphemes, and may split\n * emojis, denormalized diacritics, or combining characters, in the middle. For\n * display purposes, prefer CSS [`text-overflow: ellipsis`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-overflow#ellipsis)\n * which is locale-aware and purpose-built for this task.\n *\n * @param n - The maximum length of the output string. The output will **never**\n * exceed this length.\n * @param options - An optional options object.\n * @param options.omission - The string that is appended to the end of the\n * output *whenever the input string is truncated*. Default: '...'.\n * @param options.separator - A string or regular expression that defines a\n * cutoff point for the truncation. If multiple cutoff points are found, the one\n * closest to `n` will be used, and if no cutoff point is found then the\n * function will fallback to the trivial cutoff point. Regular expressions are\n * also supported. Default: <none> (which is equivalent to `\"\"` or the regular\n * expression `/./`).\n * @signature\n *   truncate(n, { omission, separator })(data);\n * @example\n *   pipe(\"Hello, world!\" as const, truncate(8)); //=> \"Hello...\"\n *   pipe(\n *     \"cat, dog, mouse\" as const,\n *     truncate(12, { omission: \"__\", separator: \",\"}),\n *   ); //=> \"cat, dog__\"\n * @dataLast\n * @category String\n */\nexport function truncate<\n  N extends number,\n  const Options extends TruncateOptions,\n>(\n  n: N,\n  options?: Options,\n): <S extends string>(data: S) => Truncate<S, N, Options>;\n\nexport function truncate(\n  dataOrN: string | number,\n  nOrOptions?: number | TruncateOptions,\n  options?: TruncateOptions,\n): unknown {\n  return typeof dataOrN === 'string'\n    ? truncateImplementation(\n        dataOrN,\n        // @ts-expect-error [ts2345] -- We want to reduce runtime checks to a\n        // minimum, and there's no (easy) way to couple params so that when we\n        // check one, the others are inferred accordingly.\n        nOrOptions,\n        options,\n      )\n    : (data: string) =>\n        truncateImplementation(\n          data,\n          dataOrN,\n          // @ts-expect-error [ts2345] -- We want to reduce runtime checks to a\n          // minimum, and there's no (easy) way to couple params so that when we\n          // check one, the others are inferred accordingly.\n          nOrOptions,\n        );\n}\n\nfunction truncateImplementation(\n  data: string,\n  n: number,\n  { omission = DEFAULT_OMISSION, separator }: TruncateOptions = {},\n): string {\n  if (data.length <= n) {\n    // No truncation needed.\n    return data;\n  }\n\n  if (n <= 0) {\n    // Avoid weirdness when n isn't positive.\n    return '';\n  }\n\n  if (n < omission.length) {\n    // TODO [>3]: This was an oversight, there's no value in returning just parts of the omission string itself, with no actual content. Instead, we should truncate the input without adding the omission at all in cases where the omission would completely eclipse the content.\n    // Handle cases where the omission itself is too long.\n    return omission.slice(0, n);\n  }\n\n  // Our trivial cutoff is the point where we can add the omission and reach\n  // n exactly, this is what we'll use when no separator is provided.\n  let cutoff = n - omission.length;\n\n  if (typeof separator === 'string') {\n    const lastSeparator = data.lastIndexOf(separator, cutoff);\n    if (lastSeparator !== -1) {\n      // If we find the separator within the part of the string that would be\n      // returned we move the cutoff further so that we also remove it.\n      cutoff = lastSeparator;\n    }\n  } else if (separator !== undefined) {\n    const globalSeparator = separator.flags.includes('g')\n      ? separator\n      : new RegExp(separator.source, `${separator.flags}g`);\n\n    let lastSeparator;\n    for (const { index } of data.matchAll(globalSeparator)) {\n      if (index > cutoff) {\n        // We only care about separators within the part of the string that\n        // would be returned anyway, once we are past that point we don't care\n        // about any further separators.\n        break;\n      }\n      lastSeparator = index;\n    }\n    if (lastSeparator !== undefined) {\n      cutoff = lastSeparator;\n    }\n  }\n\n  // Build the output.\n  return `${data.slice(0, cutoff)}${omission}`;\n}\n"],"mappings":"mEA6MA,SAAgB,EACd,EACA,EACA,EACS,CACT,OAAO,OAAO,GAAY,SACtB,EACE,EAIA,EACA,CACF,EACC,GACC,EACE,EACA,EAIA,CACF,CACR,CAEA,SAAS,EACP,EACA,EACA,CAAE,WAAW,MAAkB,aAA+B,CAAC,EACvD,CACR,GAAI,EAAK,QAAU,EAEjB,OAAO,EAGT,GAAI,GAAK,EAEP,MAAO,GAGT,GAAI,EAAI,EAAS,OAGf,OAAO,EAAS,MAAM,EAAG,CAAC,EAK5B,IAAI,EAAS,EAAI,EAAS,OAE1B,GAAI,OAAO,GAAc,SAAU,CACjC,IAAM,EAAgB,EAAK,YAAY,EAAW,CAAM,EACpD,IAAkB,KAGpB,EAAS,EAEb,MAAO,GAAI,IAAc,IAAA,GAAW,CAClC,IAAM,EAAkB,EAAU,MAAM,SAAS,GAAG,EAChD,EACA,IAAI,OAAO,EAAU,OAAQ,GAAG,EAAU,MAAM,EAAE,EAElD,EACJ,IAAK,GAAM,CAAE,WAAW,EAAK,SAAS,CAAe,EAAG,CACtD,GAAI,EAAQ,EAIV,MAEF,EAAgB,CAClB,CACI,IAAkB,IAAA,KACpB,EAAS,EAEb,CAGA,MAAO,GAAG,EAAK,MAAM,EAAG,CAAM,IAAI,GACpC"}

package/dist/truncate.js.map

@@ -1 +1 @@
-{"version":3,"file":"truncate.js","names":[],"sources":["../src/truncate.ts"],"sourcesContent":["import type {\n  And,\n  IsEqual,\n  IsNever,\n  IsStringLiteral,\n  NonNegativeInteger,\n} from 'type-fest';\nimport type { ClampedIntegerSubtract } from './internal/types/clamped-integer-subtract';\nimport type { StringLength } from './internal/types/string-length';\n\ninterface TruncateOptions {\n  readonly omission?: string;\n  readonly separator?: string | RegExp;\n}\n\nconst DEFAULT_OMISSION = '...';\n\ntype Truncate<\n  S extends string,\n  N extends number,\n  Options extends TruncateOptions,\n>\n  = IsNever<NonNegativeInteger<N>> extends true\n    ? // There's nothing we can say about the output without a literal, valid,\n  // truncation length `N`.\n    string\n    : IsStringLiteral<S> extends true\n      ? TruncateWithOptions<\n        S,\n        N,\n        // TODO: I don't like how I handled the default options object; I want to have everything coupled between the runtime and the type system, but this feels both brittle to changes, and over-verbose.\n        Options extends Pick<Required<TruncateOptions>, 'omission'>\n          ? Options['omission']\n          : typeof DEFAULT_OMISSION,\n        Options extends Pick<Required<TruncateOptions>, 'separator'>\n          ? Options['separator']\n          : undefined\n      >\n      : // There's nothing we can say about the output without a literal input\n    // string `S`, the result would always be, at best, just a `string`.\n      string;\n\ntype TruncateWithOptions<\n  S extends string,\n  N extends number,\n  Omission extends string,\n  Separator extends string | RegExp | undefined,\n>\n  // Distribute the result over unions.\n  = N extends unknown\n    ? // We can short-circuit most of our logic when N is a literal 0.\n    IsEqual<N, 0> extends true\n      ? ''\n      : // Distribute the result over unions.\n      Omission extends unknown\n        ? // When Omission isn't literal we don't know how long it is.\n        IsStringLiteral<Omission> extends true\n          ? // This mirrors the runtime logic where if `n - omission.length`\n        // is not positive then what we end up truncating is Omission\n        // itself and not S.\n          IsEqual<\n            ClampedIntegerSubtract<N, StringLength<Omission>>,\n            0\n          > extends true\n            ? TruncateLiterals<Omission, N, ''>\n            : And<\n              // When S isn't literal the output wouldn't be literal\n              // either.\n              IsStringLiteral<S>,\n              // TODO: Handling non-trivial separators would add a ton of complexity to this type! It's possible (but hard!) to support string literals so I'm leaving this as a TODO; regular expressions are impossible because we can't get the type checker to run them.\n              IsEqual<Separator, undefined>\n            > extends true\n              ? TruncateLiterals<S, N, Omission>\n              : string\n          : string\n        : never\n    : never;\n\n/**\n * This is the actual implementation of the truncation logic. It assumes all\n * its params are literals and valid.\n */\ntype TruncateLiterals<\n  S extends string,\n  N extends number,\n  Omission extends string,\n  Iteration extends ReadonlyArray<unknown> = [],\n> = S extends `${infer Character}${infer Rest}`\n  ? // The cutoff point N - omission.length leaves room for the omission.\n  Iteration['length'] extends ClampedIntegerSubtract<\n    N,\n    StringLength<Omission>\n  >\n    ? // The string is only truncated if its total length is longer than N; at\n  // the cutoff point this is simplified to comparing the remaining suffix\n  // length to the omission length.\n    IsLongerThan<S, Omission> extends true\n      ? Omission\n      : S\n    : // Reconstruct string character by character until cutoff.\n      `${Character}${TruncateLiterals<Rest, N, Omission, [...Iteration, unknown]>}`\n  : // Empty input string results in empty output.\n  '';\n\n/**\n * An optimized check that efficiently checks if the string A is longer than B.\n */\ntype IsLongerThan<\n  A extends string,\n  B extends string,\n> = A extends `${string}${infer RestA}`\n  ? B extends `${string}${infer RestB}`\n    ? IsLongerThan<RestA, RestB>\n    : // B is empty and A isn't!\n    true\n  : // A is empty, even if B is empty, A wouldn't be (strictly) longer.\n  false;\n\n/**\n * Truncates strings to a maximum length, adding an ellipsis when truncated.\n *\n * Shorter strings are returned unchanged. If the omission marker is longer than\n * the maximum length, it will be truncated as well.\n *\n * The `separator` argument provides more control by optimistically searching\n * for a matching cutoff point, which could be used to avoid truncating in the\n * middle of a word or other semantic boundary.\n *\n * If you just need to limit the total length of the string, without adding an\n * `omission` or optimizing the cutoff point via `separator`, prefer\n * `sliceString` instead, which runs more efficiently.\n *\n * The function counts Unicode characters, not visual graphemes, and may split\n * emojis, denormalized diacritics, or combining characters, in the middle. For\n * display purposes, prefer CSS [`text-overflow: ellipsis`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-overflow#ellipsis)\n * which is locale-aware and purpose-built for this task.\n *\n * @param data - The input string.\n * @param n - The maximum length of the output string. The output will **never**\n * exceed this length.\n * @param options - An optional options object.\n * @param options.omission - The string that is appended to the end of the\n * output *whenever the input string is truncated*. Default: '...'.\n * @param options.separator - A string or regular expression that defines a\n * cutoff point for the truncation. If multiple cutoff points are found, the one\n * closest to `n` will be used, and if no cutoff point is found then the\n * function will fallback to the trivial cutoff point. Regular expressions are\n * also supported. Default: <none> (which is equivalent to `\"\"` or the regular\n * expression `/./`).\n * @signature\n *   truncate(data, n, { omission, separator });\n * @example\n *   truncate(\"Hello, world!\", 8); //=> \"Hello...\"\n *   truncate(\n *     \"cat, dog, mouse\",\n *     12,\n *     { omission: \"__\", separator: \",\"},\n *   ); //=> \"cat, dog__\"\n * @dataFirst\n * @category String\n */\nexport function truncate<\n  S extends string,\n  N extends number,\n  const Options extends TruncateOptions,\n>(data: S, n: N, options?: Options): Truncate<S, N, Options>;\n\n/**\n * Truncates strings to a maximum length, adding an ellipsis when truncated.\n *\n * Shorter strings are returned unchanged. If the omission marker is longer than\n * the maximum length, it will be truncated as well.\n *\n * The `separator` argument provides more control by optimistically searching\n * for a matching cutoff point, which could be used to avoid truncating in the\n * middle of a word or other semantic boundary.\n *\n * If you just need to limit the total length of the string, without adding an\n * `omission` or optimizing the cutoff point via `separator`, prefer\n * `sliceString` instead, which runs more efficiently.\n *\n * The function counts Unicode characters, not visual graphemes, and may split\n * emojis, denormalized diacritics, or combining characters, in the middle. For\n * display purposes, prefer CSS [`text-overflow: ellipsis`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-overflow#ellipsis)\n * which is locale-aware and purpose-built for this task.\n *\n * @param n - The maximum length of the output string. The output will **never**\n * exceed this length.\n * @param options - An optional options object.\n * @param options.omission - The string that is appended to the end of the\n * output *whenever the input string is truncated*. Default: '...'.\n * @param options.separator - A string or regular expression that defines a\n * cutoff point for the truncation. If multiple cutoff points are found, the one\n * closest to `n` will be used, and if no cutoff point is found then the\n * function will fallback to the trivial cutoff point. Regular expressions are\n * also supported. Default: <none> (which is equivalent to `\"\"` or the regular\n * expression `/./`).\n * @signature\n *   truncate(n, { omission, separator })(data);\n * @example\n *   pipe(\"Hello, world!\" as const, truncate(8)); //=> \"Hello...\"\n *   pipe(\n *     \"cat, dog, mouse\" as const,\n *     truncate(12, { omission: \"__\", separator: \",\"}),\n *   ); //=> \"cat, dog__\"\n * @dataLast\n * @category String\n */\nexport function truncate<\n  N extends number,\n  const Options extends TruncateOptions,\n>(\n  n: N,\n  options?: Options,\n): <S extends string>(data: S) => Truncate<S, N, Options>;\n\nexport function truncate(\n  dataOrN: string | number,\n  nOrOptions?: number | TruncateOptions,\n  options?: TruncateOptions,\n): unknown {\n  return typeof dataOrN === 'string'\n    ? truncateImplementation(\n        dataOrN,\n        // @ts-expect-error [ts2345] -- We want to reduce runtime checks to a\n        // minimum, and there's no (easy) way to couple params so that when we\n        // check one, the others are inferred accordingly.\n        nOrOptions,\n        options,\n      )\n    : (data: string) =>\n        truncateImplementation(\n          data,\n          dataOrN,\n          // @ts-expect-error [ts2345] -- We want to reduce runtime checks to a\n          // minimum, and there's no (easy) way to couple params so that when we\n          // check one, the others are inferred accordingly.\n          nOrOptions,\n        );\n}\n\nfunction truncateImplementation(\n  data: string,\n  n: number,\n  { omission = DEFAULT_OMISSION, separator }: TruncateOptions = {},\n): string {\n  if (data.length <= n) {\n    // No truncation needed.\n    return data;\n  }\n\n  if (n <= 0) {\n    // Avoid weirdness when n isn't positive.\n    return '';\n  }\n\n  if (n < omission.length) {\n    // TODO [>3]: This was an oversight, there's no value in returning just parts of the omission string itself, with no actual content. Instead, we should truncate the input without adding the omission at all in cases where the omission would completely eclipse the content.\n    // Handle cases where the omission itself is too long.\n    return omission.slice(0, n);\n  }\n\n  // Our trivial cutoff is the point where we can add the omission and reach\n  // n exactly, this is what we'll use when no separator is provided.\n  let cutoff = n - omission.length;\n\n  if (typeof separator === 'string') {\n    const lastSeparator = data.lastIndexOf(separator, cutoff);\n    if (lastSeparator !== -1) {\n      // If we find the separator within the part of the string that would be\n      // returned we move the cutoff further so that we also remove it.\n      cutoff = lastSeparator;\n    }\n  } else if (separator !== undefined) {\n    const globalSeparator = separator.flags.includes('g')\n      ? separator\n      : new RegExp(separator.source, `${separator.flags}g`);\n\n    let lastSeparator;\n    for (const { index } of data.matchAll(globalSeparator)) {\n      if (index > cutoff) {\n        // We only care about separators within the part of the string that\n        // would be returned anyway, once we are past that point we don't care\n        // about any further separators.\n        break;\n      }\n      lastSeparator = index;\n    }\n    if (lastSeparator !== undefined) {\n      cutoff = lastSeparator;\n    }\n  }\n\n  // Build the output.\n  return `${data.slice(0, cutoff)}${omission}`;\n}\n"],"mappings":"AAwNA,SAAgB,EACd,EACA,EACA,EACS,CACT,OAAO,OAAO,GAAY,SACtB,EACE,EAIA,EACA,EACD,CACA,GACC,EACE,EACA,EAIA,EACD,CAGT,SAAS,EACP,EACA,EACA,CAAE,WAAW,MAAkB,aAA+B,EAAE,CACxD,CACR,GAAI,EAAK,QAAU,EAEjB,OAAO,EAGT,GAAI,GAAK,EAEP,MAAO,GAGT,GAAI,EAAI,EAAS,OAGf,OAAO,EAAS,MAAM,EAAG,EAAE,CAK7B,IAAI,EAAS,EAAI,EAAS,OAE1B,GAAI,OAAO,GAAc,SAAU,CACjC,IAAM,EAAgB,EAAK,YAAY,EAAW,EAAO,CACrD,IAAkB,KAGpB,EAAS,WAEF,IAAc,IAAA,GAAW,CAClC,IAAM,EAAkB,EAAU,MAAM,SAAS,IAAI,CACjD,EACA,IAAI,OAAO,EAAU,OAAQ,GAAG,EAAU,MAAM,GAAG,CAEnD,EACJ,IAAK,GAAM,CAAE,WAAW,EAAK,SAAS,EAAgB,CAAE,CACtD,GAAI,EAAQ,EAIV,MAEF,EAAgB,EAEd,IAAkB,IAAA,KACpB,EAAS,GAKb,MAAO,GAAG,EAAK,MAAM,EAAG,EAAO,GAAG"}
+{"version":3,"file":"truncate.js","names":[],"sources":["../src/truncate.ts"],"sourcesContent":["import type { IsNever, IsStringLiteral, NonNegativeInteger } from 'type-fest';\nimport type { ClampedIntegerSubtract } from './internal/types/clamped-integer-subtract';\nimport type { StringLength } from './internal/types/string-length';\n\ninterface TruncateOptions {\n  readonly omission?: string;\n  readonly separator?: string | RegExp;\n}\n\nconst DEFAULT_OMISSION = '...';\n\ntype Truncate<\n  S extends string,\n  N extends number,\n  Options extends TruncateOptions,\n>\n  = IsNever<NonNegativeInteger<N>> extends true\n    ? // There's nothing we can say about the output without a literal, valid,\n  // truncation length `N`.\n    string\n    : IsStringLiteral<S> extends true\n      ? TruncateWithOptions<\n        S,\n        N,\n        // TODO: I don't like how I handled the default options object; I want to have everything coupled between the runtime and the type system, but this feels both brittle to changes, and over-verbose.\n        Options extends Pick<Required<TruncateOptions>, 'omission'>\n          ? Options['omission']\n          : typeof DEFAULT_OMISSION,\n        Options extends Pick<Required<TruncateOptions>, 'separator'>\n          ? Options['separator']\n          : undefined\n      >\n      : // There's nothing we can say about the output without a literal input\n    // string `S`, the result would always be, at best, just a `string`.\n      string;\n\ntype TruncateWithOptions<\n  S extends string,\n  N extends number,\n  Omission extends string,\n  Separator extends string | RegExp | undefined,\n>\n  // Distribute the result over unions.\n  = N extends unknown\n    ? // We can short-circuit most of our logic when N is a literal 0.\n      [N] extends [0]\n        ? ''\n        : // Distribute the result over unions.\n        Omission extends unknown\n          ? // When Omission isn't literal we don't know how long it is.\n          IsStringLiteral<Omission> extends true\n            ? // This mirrors the runtime logic where if `n - omission.length`\n            // is not positive then what we end up truncating is Omission\n            // itself and not S.\n              [ClampedIntegerSubtract<N, StringLength<Omission>>] extends [0]\n                ? TruncateLiterals<Omission, N, ''>\n                : // When S isn't literal the output wouldn't be literal either.\n                IsStringLiteral<S> extends true\n                  ? // TODO: Handling non-trivial separators would add a ton of complexity to this type! It's possible (but hard!) to support string literals so I'm leaving this as a TODO; regular expressions are impossible because we can't get the type checker to run them.\n                    [Separator] extends [undefined]\n                      ? TruncateLiterals<S, N, Omission>\n                      : string\n                  : string\n            : string\n          : never\n    : never;\n\n/**\n * This is the actual implementation of the truncation logic. It assumes all\n * its params are literals and valid.\n */\ntype TruncateLiterals<\n  S extends string,\n  N extends number,\n  Omission extends string,\n  Iteration extends ReadonlyArray<unknown> = [],\n> = S extends `${infer Character}${infer Rest}`\n  ? // The cutoff point N - omission.length leaves room for the omission.\n  Iteration['length'] extends ClampedIntegerSubtract<\n    N,\n    StringLength<Omission>\n  >\n    ? // The string is only truncated if its total length is longer than N; at\n  // the cutoff point this is simplified to comparing the remaining suffix\n  // length to the omission length.\n    IsLongerThan<S, Omission> extends true\n      ? Omission\n      : S\n    : // Reconstruct string character by character until cutoff.\n      `${Character}${TruncateLiterals<Rest, N, Omission, [...Iteration, unknown]>}`\n  : // Empty input string results in empty output.\n  '';\n\n/**\n * An optimized check that efficiently checks if the string A is longer than B.\n */\ntype IsLongerThan<\n  A extends string,\n  B extends string,\n> = A extends `${string}${infer RestA}`\n  ? B extends `${string}${infer RestB}`\n    ? IsLongerThan<RestA, RestB>\n    : // B is empty and A isn't!\n    true\n  : // A is empty, even if B is empty, A wouldn't be (strictly) longer.\n  false;\n\n/**\n * Truncates strings to a maximum length, adding an ellipsis when truncated.\n *\n * Shorter strings are returned unchanged. If the omission marker is longer than\n * the maximum length, it will be truncated as well.\n *\n * The `separator` argument provides more control by optimistically searching\n * for a matching cutoff point, which could be used to avoid truncating in the\n * middle of a word or other semantic boundary.\n *\n * If you just need to limit the total length of the string, without adding an\n * `omission` or optimizing the cutoff point via `separator`, prefer\n * `sliceString` instead, which runs more efficiently.\n *\n * The function counts Unicode characters, not visual graphemes, and may split\n * emojis, denormalized diacritics, or combining characters, in the middle. For\n * display purposes, prefer CSS [`text-overflow: ellipsis`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-overflow#ellipsis)\n * which is locale-aware and purpose-built for this task.\n *\n * @param data - The input string.\n * @param n - The maximum length of the output string. The output will **never**\n * exceed this length.\n * @param options - An optional options object.\n * @param options.omission - The string that is appended to the end of the\n * output *whenever the input string is truncated*. Default: '...'.\n * @param options.separator - A string or regular expression that defines a\n * cutoff point for the truncation. If multiple cutoff points are found, the one\n * closest to `n` will be used, and if no cutoff point is found then the\n * function will fallback to the trivial cutoff point. Regular expressions are\n * also supported. Default: <none> (which is equivalent to `\"\"` or the regular\n * expression `/./`).\n * @signature\n *   truncate(data, n, { omission, separator });\n * @example\n *   truncate(\"Hello, world!\", 8); //=> \"Hello...\"\n *   truncate(\n *     \"cat, dog, mouse\",\n *     12,\n *     { omission: \"__\", separator: \",\"},\n *   ); //=> \"cat, dog__\"\n * @dataFirst\n * @category String\n */\nexport function truncate<\n  S extends string,\n  N extends number,\n  const Options extends TruncateOptions,\n>(data: S, n: N, options?: Options): Truncate<S, N, Options>;\n\n/**\n * Truncates strings to a maximum length, adding an ellipsis when truncated.\n *\n * Shorter strings are returned unchanged. If the omission marker is longer than\n * the maximum length, it will be truncated as well.\n *\n * The `separator` argument provides more control by optimistically searching\n * for a matching cutoff point, which could be used to avoid truncating in the\n * middle of a word or other semantic boundary.\n *\n * If you just need to limit the total length of the string, without adding an\n * `omission` or optimizing the cutoff point via `separator`, prefer\n * `sliceString` instead, which runs more efficiently.\n *\n * The function counts Unicode characters, not visual graphemes, and may split\n * emojis, denormalized diacritics, or combining characters, in the middle. For\n * display purposes, prefer CSS [`text-overflow: ellipsis`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-overflow#ellipsis)\n * which is locale-aware and purpose-built for this task.\n *\n * @param n - The maximum length of the output string. The output will **never**\n * exceed this length.\n * @param options - An optional options object.\n * @param options.omission - The string that is appended to the end of the\n * output *whenever the input string is truncated*. Default: '...'.\n * @param options.separator - A string or regular expression that defines a\n * cutoff point for the truncation. If multiple cutoff points are found, the one\n * closest to `n` will be used, and if no cutoff point is found then the\n * function will fallback to the trivial cutoff point. Regular expressions are\n * also supported. Default: <none> (which is equivalent to `\"\"` or the regular\n * expression `/./`).\n * @signature\n *   truncate(n, { omission, separator })(data);\n * @example\n *   pipe(\"Hello, world!\" as const, truncate(8)); //=> \"Hello...\"\n *   pipe(\n *     \"cat, dog, mouse\" as const,\n *     truncate(12, { omission: \"__\", separator: \",\"}),\n *   ); //=> \"cat, dog__\"\n * @dataLast\n * @category String\n */\nexport function truncate<\n  N extends number,\n  const Options extends TruncateOptions,\n>(\n  n: N,\n  options?: Options,\n): <S extends string>(data: S) => Truncate<S, N, Options>;\n\nexport function truncate(\n  dataOrN: string | number,\n  nOrOptions?: number | TruncateOptions,\n  options?: TruncateOptions,\n): unknown {\n  return typeof dataOrN === 'string'\n    ? truncateImplementation(\n        dataOrN,\n        // @ts-expect-error [ts2345] -- We want to reduce runtime checks to a\n        // minimum, and there's no (easy) way to couple params so that when we\n        // check one, the others are inferred accordingly.\n        nOrOptions,\n        options,\n      )\n    : (data: string) =>\n        truncateImplementation(\n          data,\n          dataOrN,\n          // @ts-expect-error [ts2345] -- We want to reduce runtime checks to a\n          // minimum, and there's no (easy) way to couple params so that when we\n          // check one, the others are inferred accordingly.\n          nOrOptions,\n        );\n}\n\nfunction truncateImplementation(\n  data: string,\n  n: number,\n  { omission = DEFAULT_OMISSION, separator }: TruncateOptions = {},\n): string {\n  if (data.length <= n) {\n    // No truncation needed.\n    return data;\n  }\n\n  if (n <= 0) {\n    // Avoid weirdness when n isn't positive.\n    return '';\n  }\n\n  if (n < omission.length) {\n    // TODO [>3]: This was an oversight, there's no value in returning just parts of the omission string itself, with no actual content. Instead, we should truncate the input without adding the omission at all in cases where the omission would completely eclipse the content.\n    // Handle cases where the omission itself is too long.\n    return omission.slice(0, n);\n  }\n\n  // Our trivial cutoff is the point where we can add the omission and reach\n  // n exactly, this is what we'll use when no separator is provided.\n  let cutoff = n - omission.length;\n\n  if (typeof separator === 'string') {\n    const lastSeparator = data.lastIndexOf(separator, cutoff);\n    if (lastSeparator !== -1) {\n      // If we find the separator within the part of the string that would be\n      // returned we move the cutoff further so that we also remove it.\n      cutoff = lastSeparator;\n    }\n  } else if (separator !== undefined) {\n    const globalSeparator = separator.flags.includes('g')\n      ? separator\n      : new RegExp(separator.source, `${separator.flags}g`);\n\n    let lastSeparator;\n    for (const { index } of data.matchAll(globalSeparator)) {\n      if (index > cutoff) {\n        // We only care about separators within the part of the string that\n        // would be returned anyway, once we are past that point we don't care\n        // about any further separators.\n        break;\n      }\n      lastSeparator = index;\n    }\n    if (lastSeparator !== undefined) {\n      cutoff = lastSeparator;\n    }\n  }\n\n  // Build the output.\n  return `${data.slice(0, cutoff)}${omission}`;\n}\n"],"mappings":"AA6MA,SAAgB,EACd,EACA,EACA,EACS,CACT,OAAO,OAAO,GAAY,SACtB,EACE,EAIA,EACA,CACF,EACC,GACC,EACE,EACA,EAIA,CACF,CACR,CAEA,SAAS,EACP,EACA,EACA,CAAE,WAAW,MAAkB,aAA+B,CAAC,EACvD,CACR,GAAI,EAAK,QAAU,EAEjB,OAAO,EAGT,GAAI,GAAK,EAEP,MAAO,GAGT,GAAI,EAAI,EAAS,OAGf,OAAO,EAAS,MAAM,EAAG,CAAC,EAK5B,IAAI,EAAS,EAAI,EAAS,OAE1B,GAAI,OAAO,GAAc,SAAU,CACjC,IAAM,EAAgB,EAAK,YAAY,EAAW,CAAM,EACpD,IAAkB,KAGpB,EAAS,EAEb,MAAO,GAAI,IAAc,IAAA,GAAW,CAClC,IAAM,EAAkB,EAAU,MAAM,SAAS,GAAG,EAChD,EACA,IAAI,OAAO,EAAU,OAAQ,GAAG,EAAU,MAAM,EAAE,EAElD,EACJ,IAAK,GAAM,CAAE,WAAW,EAAK,SAAS,CAAe,EAAG,CACtD,GAAI,EAAQ,EAIV,MAEF,EAAgB,CAClB,CACI,IAAkB,IAAA,KACpB,EAAS,EAEb,CAGA,MAAO,GAAG,EAAK,MAAM,EAAG,CAAM,IAAI,GACpC"}

package/dist/uncapitalize.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e){return`${e[0]?.toLowerCase()??``}${e.slice(1)}`}exports.uncapitalize=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs");function t(...t){return e.curry(n,t)}function n(e){return`${e[0]?.toLowerCase()??``}${e.slice(1)}`}exports.uncapitalize=t;
 //# sourceMappingURL=uncapitalize.cjs.map

package/dist/uncapitalize.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"uncapitalize.cjs","names":["curry"],"sources":["../src/uncapitalize.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Makes the first character of a string lowercase while leaving the rest\n * unchanged.\n *\n * It uses the built-in [`String.prototype.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)\n * for the runtime and the built-in [`Uncapitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#Uncapitalizestringtype)\n * utility type for typing and thus shares their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_.\n *\n * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target\n * just the first letter of the word, and [`text-transform: lowercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#lowercase)\n * to lowercase it. This transformation **is** locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `toLowerCase`, `capitalize`,\n * `toCamelCase`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * @param data - A string.\n * @signature\n *   uncapitalize(data);\n * @example\n *   uncapitalize(\"HELLO WORLD\"); // \"hELLO WORLD\"\n * @dataFirst\n * @category String\n */\nexport function uncapitalize<T extends string>(data: T): Uncapitalize<T>;\n\n/**\n * Makes the first character of a string lowercase while leaving the rest\n * unchanged.\n *\n * It uses the built-in [`String.prototype.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)\n * for the runtime and the built-in [`Uncapitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#Uncapitalizestringtype)\n * utility type for typing and thus shares their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_.\n *\n * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target\n * just the first letter of the word, and [`text-transform: lowercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#lowercase)\n * to lowercase it. This transformation **is** locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `toLowerCase`, `capitalize`,\n * `toCamelCase`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * @signature\n *   uncapitalize()(data);\n * @example\n *   pipe(\"HELLO WORLD\", uncapitalize()); // \"hELLO WORLD\"\n * @dataLast\n * @category String\n */\nexport function uncapitalize(): <T extends string>(data: T) => Uncapitalize<T>;\n\nexport function uncapitalize(...args: ReadonlyArray<unknown>): unknown {\n  return curry(uncapitalizeImplementation, args);\n}\n\nfunction uncapitalizeImplementation<T extends string>(data: T): Uncapitalize<T> {\n  return `${data[0]?.toLowerCase() ?? ''}${data.slice(1)}` as Uncapitalize<T>;\n}\n"],"mappings":"kGAmDA,SAAgB,EAAa,GAAG,EAAuC,CACrE,OAAOA,EAAAA,MAAM,EAA4B,EAAK,CAGhD,SAAS,EAA6C,EAA0B,CAC9E,MAAO,GAAG,EAAK,IAAI,aAAa,EAAI,KAAK,EAAK,MAAM,EAAE"}
+{"version":3,"file":"uncapitalize.cjs","names":["curry"],"sources":["../src/uncapitalize.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Makes the first character of a string lowercase while leaving the rest\n * unchanged.\n *\n * It uses the built-in [`String.prototype.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)\n * for the runtime and the built-in [`Uncapitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#Uncapitalizestringtype)\n * utility type for typing and thus shares their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_.\n *\n * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target\n * just the first letter of the word, and [`text-transform: lowercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#lowercase)\n * to lowercase it. This transformation **is** locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `toLowerCase`, `capitalize`,\n * `toCamelCase`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * @param data - A string.\n * @signature\n *   uncapitalize(data);\n * @example\n *   uncapitalize(\"HELLO WORLD\"); // \"hELLO WORLD\"\n * @dataFirst\n * @category String\n */\nexport function uncapitalize<T extends string>(data: T): Uncapitalize<T>;\n\n/**\n * Makes the first character of a string lowercase while leaving the rest\n * unchanged.\n *\n * It uses the built-in [`String.prototype.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)\n * for the runtime and the built-in [`Uncapitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#Uncapitalizestringtype)\n * utility type for typing and thus shares their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_.\n *\n * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target\n * just the first letter of the word, and [`text-transform: lowercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#lowercase)\n * to lowercase it. This transformation **is** locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `toLowerCase`, `capitalize`,\n * `toCamelCase`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * @signature\n *   uncapitalize()(data);\n * @example\n *   pipe(\"HELLO WORLD\", uncapitalize()); // \"hELLO WORLD\"\n * @dataLast\n * @category String\n */\nexport function uncapitalize(): <T extends string>(data: T) => Uncapitalize<T>;\n\nexport function uncapitalize(...args: ReadonlyArray<unknown>): unknown {\n  return curry(uncapitalizeImplementation, args);\n}\n\nfunction uncapitalizeImplementation<T extends string>(data: T): Uncapitalize<T> {\n  return `${data[0]?.toLowerCase() ?? ''}${data.slice(1)}` as Uncapitalize<T>;\n}\n"],"mappings":"kGAmDA,SAAgB,EAAa,GAAG,EAAuC,CACrE,OAAOA,EAAAA,MAAM,EAA4B,CAAI,CAC/C,CAEA,SAAS,EAA6C,EAA0B,CAC9E,MAAO,GAAG,EAAK,EAAE,EAAE,YAAY,GAAK,KAAK,EAAK,MAAM,CAAC,GACvD"}

package/dist/uncapitalize.js.map

@@ -1 +1 @@
-{"version":3,"file":"uncapitalize.js","names":[],"sources":["../src/uncapitalize.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Makes the first character of a string lowercase while leaving the rest\n * unchanged.\n *\n * It uses the built-in [`String.prototype.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)\n * for the runtime and the built-in [`Uncapitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#Uncapitalizestringtype)\n * utility type for typing and thus shares their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_.\n *\n * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target\n * just the first letter of the word, and [`text-transform: lowercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#lowercase)\n * to lowercase it. This transformation **is** locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `toLowerCase`, `capitalize`,\n * `toCamelCase`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * @param data - A string.\n * @signature\n *   uncapitalize(data);\n * @example\n *   uncapitalize(\"HELLO WORLD\"); // \"hELLO WORLD\"\n * @dataFirst\n * @category String\n */\nexport function uncapitalize<T extends string>(data: T): Uncapitalize<T>;\n\n/**\n * Makes the first character of a string lowercase while leaving the rest\n * unchanged.\n *\n * It uses the built-in [`String.prototype.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)\n * for the runtime and the built-in [`Uncapitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#Uncapitalizestringtype)\n * utility type for typing and thus shares their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_.\n *\n * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target\n * just the first letter of the word, and [`text-transform: lowercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#lowercase)\n * to lowercase it. This transformation **is** locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `toLowerCase`, `capitalize`,\n * `toCamelCase`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * @signature\n *   uncapitalize()(data);\n * @example\n *   pipe(\"HELLO WORLD\", uncapitalize()); // \"hELLO WORLD\"\n * @dataLast\n * @category String\n */\nexport function uncapitalize(): <T extends string>(data: T) => Uncapitalize<T>;\n\nexport function uncapitalize(...args: ReadonlyArray<unknown>): unknown {\n  return curry(uncapitalizeImplementation, args);\n}\n\nfunction uncapitalizeImplementation<T extends string>(data: T): Uncapitalize<T> {\n  return `${data[0]?.toLowerCase() ?? ''}${data.slice(1)}` as Uncapitalize<T>;\n}\n"],"mappings":"mCAmDA,SAAgB,EAAa,GAAG,EAAuC,CACrE,OAAO,EAAM,EAA4B,EAAK,CAGhD,SAAS,EAA6C,EAA0B,CAC9E,MAAO,GAAG,EAAK,IAAI,aAAa,EAAI,KAAK,EAAK,MAAM,EAAE"}
+{"version":3,"file":"uncapitalize.js","names":[],"sources":["../src/uncapitalize.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Makes the first character of a string lowercase while leaving the rest\n * unchanged.\n *\n * It uses the built-in [`String.prototype.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)\n * for the runtime and the built-in [`Uncapitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#Uncapitalizestringtype)\n * utility type for typing and thus shares their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_.\n *\n * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target\n * just the first letter of the word, and [`text-transform: lowercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#lowercase)\n * to lowercase it. This transformation **is** locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `toLowerCase`, `capitalize`,\n * `toCamelCase`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * @param data - A string.\n * @signature\n *   uncapitalize(data);\n * @example\n *   uncapitalize(\"HELLO WORLD\"); // \"hELLO WORLD\"\n * @dataFirst\n * @category String\n */\nexport function uncapitalize<T extends string>(data: T): Uncapitalize<T>;\n\n/**\n * Makes the first character of a string lowercase while leaving the rest\n * unchanged.\n *\n * It uses the built-in [`String.prototype.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)\n * for the runtime and the built-in [`Uncapitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#Uncapitalizestringtype)\n * utility type for typing and thus shares their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_.\n *\n * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target\n * just the first letter of the word, and [`text-transform: lowercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#lowercase)\n * to lowercase it. This transformation **is** locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `toLowerCase`, `capitalize`,\n * `toCamelCase`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * @signature\n *   uncapitalize()(data);\n * @example\n *   pipe(\"HELLO WORLD\", uncapitalize()); // \"hELLO WORLD\"\n * @dataLast\n * @category String\n */\nexport function uncapitalize(): <T extends string>(data: T) => Uncapitalize<T>;\n\nexport function uncapitalize(...args: ReadonlyArray<unknown>): unknown {\n  return curry(uncapitalizeImplementation, args);\n}\n\nfunction uncapitalizeImplementation<T extends string>(data: T): Uncapitalize<T> {\n  return `${data[0]?.toLowerCase() ?? ''}${data.slice(1)}` as Uncapitalize<T>;\n}\n"],"mappings":"mCAmDA,SAAgB,EAAa,GAAG,EAAuC,CACrE,OAAO,EAAM,EAA4B,CAAI,CAC/C,CAEA,SAAS,EAA6C,EAA0B,CAC9E,MAAO,GAAG,EAAK,EAAE,EAAE,YAAY,GAAK,KAAK,EAAK,MAAM,CAAC,GACvD"}

package/dist/unique-by.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./utility-evaluators-C8koSp9T.cjs`),t=require(`./curry-from-lazy-BvN_VKlH.cjs`);function n(...e){return t.t(r,e)}function r(t){let n=t,r=new Set;return(t,i,a)=>{let o=n(t,i,a);return r.has(o)?e.t:(r.add(o),{done:!1,hasNext:!0,next:t})}}exports.uniqueBy=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./utility-evaluators-BGM19SpK.cjs"),t=require("./curry-from-lazy-mdjeRP1g.cjs");function n(...e){return t.t(r,e)}function r(t){let n=t,r=new Set;return(t,i,a)=>{let o=n(t,i,a);return r.has(o)?e.t:(r.add(o),{done:!1,hasNext:!0,next:t})}}exports.uniqueBy=n;
 //# sourceMappingURL=unique-by.cjs.map

package/dist/unique-by.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"unique-by.cjs","names":["curryFromLazy","SKIP_ITEM"],"sources":["../src/unique-by.ts"],"sourcesContent":["import type { BrandedReturn } from './internal/types/branded-return';\nimport type { Deduped } from './internal/types/deduped';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list transformed by a function. Elements are compared by reference using Set.\n *\n * @param data - The array to filter.\n * @param keyFunction - Extracts a value that would be used to compare elements.\n * @signature\n *    uniqueBy(data, keyFunction)\n * @example\n *    uniqueBy(\n *     [{ n: 1 }, { n: 2 }, { n: 2 }, { n: 5 }, { n: 1 }, { n: 6 }, { n: 7 }],\n *     (obj) => obj.n,\n *    ) // => [{n: 1}, {n: 2}, {n: 5}, {n: 6}, {n: 7}]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function uniqueBy<T extends IterableContainer>(\n  data: T,\n  keyFunction: (item: T[number], index: number, data: T) => unknown,\n): Deduped<T>;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list transformed by a function. Elements are compared by reference using Set.\n *\n * @param keyFunction - Extracts a value that would be used to compare elements.\n * @signature\n *    uniqueBy(keyFunction)(data)\n * @example\n *    pipe(\n *      [{n: 1}, {n: 2}, {n: 2}, {n: 5}, {n: 1}, {n: 6}, {n: 7}], // only 4 iterations\n *      uniqueBy(obj => obj.n),\n *      take(3)\n *    ) // => [{n: 1}, {n: 2}, {n: 5}]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function uniqueBy<T extends IterableContainer>(\n  keyFunction: (item: T[number], index: number, data: T) => unknown,\n): (data: T) => Deduped<T>;\n\nexport function uniqueBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(\n  keyFunction: (item: T, index: number, data: ReadonlyArray<T>) => unknown,\n): LazyEvaluator<T> {\n  // @see https://github.com/typescript-eslint/typescript-eslint/issues/9885\n  const brandedKeyFunction = keyFunction as BrandedReturn<typeof keyFunction>;\n\n  const set = new Set<ReturnType<typeof brandedKeyFunction>>();\n  return (value, index, data) => {\n    const key = brandedKeyFunction(value, index, data);\n    if (set.has(key)) {\n      return SKIP_ITEM;\n    }\n\n    set.add(key);\n    return { done: false, hasNext: true, next: value };\n  };\n}\n"],"mappings":"oKAkDA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAOA,EAAAA,EAAc,EAAoB,EAAK,CAGhD,SAAS,EACP,EACkB,CAElB,IAAM,EAAqB,EAErB,EAAM,IAAI,IAChB,OAAQ,EAAO,EAAO,IAAS,CAC7B,IAAM,EAAM,EAAmB,EAAO,EAAO,EAAK,CAMlD,OALI,EAAI,IAAI,EAAI,CACPC,EAAAA,GAGT,EAAI,IAAI,EAAI,CACL,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO"}
+{"version":3,"file":"unique-by.cjs","names":["curryFromLazy","SKIP_ITEM"],"sources":["../src/unique-by.ts"],"sourcesContent":["import type { BrandedReturn } from './internal/types/branded-return';\nimport type { Deduped } from './internal/types/deduped';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list transformed by a function. Elements are compared by reference using Set.\n *\n * @param data - The array to filter.\n * @param keyFunction - Extracts a value that would be used to compare elements.\n * @signature\n *    uniqueBy(data, keyFunction)\n * @example\n *    uniqueBy(\n *     [{ n: 1 }, { n: 2 }, { n: 2 }, { n: 5 }, { n: 1 }, { n: 6 }, { n: 7 }],\n *     (obj) => obj.n,\n *    ) // => [{n: 1}, {n: 2}, {n: 5}, {n: 6}, {n: 7}]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function uniqueBy<T extends IterableContainer>(\n  data: T,\n  keyFunction: (item: T[number], index: number, data: T) => unknown,\n): Deduped<T>;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list transformed by a function. Elements are compared by reference using Set.\n *\n * @param keyFunction - Extracts a value that would be used to compare elements.\n * @signature\n *    uniqueBy(keyFunction)(data)\n * @example\n *    pipe(\n *      [{n: 1}, {n: 2}, {n: 2}, {n: 5}, {n: 1}, {n: 6}, {n: 7}], // only 4 iterations\n *      uniqueBy(obj => obj.n),\n *      take(3)\n *    ) // => [{n: 1}, {n: 2}, {n: 5}]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function uniqueBy<T extends IterableContainer>(\n  keyFunction: (item: T[number], index: number, data: T) => unknown,\n): (data: T) => Deduped<T>;\n\nexport function uniqueBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(\n  keyFunction: (item: T, index: number, data: ReadonlyArray<T>) => unknown,\n): LazyEvaluator<T> {\n  // @see https://github.com/typescript-eslint/typescript-eslint/issues/9885\n  const brandedKeyFunction = keyFunction as BrandedReturn<typeof keyFunction>;\n\n  const set = new Set<ReturnType<typeof brandedKeyFunction>>();\n  return (value, index, data) => {\n    const key = brandedKeyFunction(value, index, data);\n    if (set.has(key)) {\n      return SKIP_ITEM;\n    }\n\n    set.add(key);\n    return { done: false, hasNext: true, next: value };\n  };\n}\n"],"mappings":"oKAkDA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAOA,EAAAA,EAAc,EAAoB,CAAI,CAC/C,CAEA,SAAS,EACP,EACkB,CAElB,IAAM,EAAqB,EAErB,EAAM,IAAI,IAChB,OAAQ,EAAO,EAAO,IAAS,CAC7B,IAAM,EAAM,EAAmB,EAAO,EAAO,CAAI,EAMjD,OALI,EAAI,IAAI,CAAG,EACNC,EAAAA,GAGT,EAAI,IAAI,CAAG,EACJ,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,CAAM,EACnD,CACF"}

package/dist/unique-by.js

@@ -1,2 +1,2 @@
-import{t as e}from"./utility-evaluators-ZAaUtL2Z.js";import{t}from"./curry-from-lazy-CtH1dp14.js";function n(...e){return t(r,e)}function r(t){let n=t,r=new Set;return(t,i,a)=>{let o=n(t,i,a);return r.has(o)?e:(r.add(o),{done:!1,hasNext:!0,next:t})}}export{n as uniqueBy};
+import{t as e}from"./utility-evaluators-DDW55xeL.js";import{t}from"./curry-from-lazy-BoPMn2L_.js";function n(...e){return t(r,e)}function r(t){let n=t,r=new Set;return(t,i,a)=>{let o=n(t,i,a);return r.has(o)?e:(r.add(o),{done:!1,hasNext:!0,next:t})}}export{n as uniqueBy};
 //# sourceMappingURL=unique-by.js.map

package/dist/unique-by.js.map

@@ -1 +1 @@
-{"version":3,"file":"unique-by.js","names":[],"sources":["../src/unique-by.ts"],"sourcesContent":["import type { BrandedReturn } from './internal/types/branded-return';\nimport type { Deduped } from './internal/types/deduped';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list transformed by a function. Elements are compared by reference using Set.\n *\n * @param data - The array to filter.\n * @param keyFunction - Extracts a value that would be used to compare elements.\n * @signature\n *    uniqueBy(data, keyFunction)\n * @example\n *    uniqueBy(\n *     [{ n: 1 }, { n: 2 }, { n: 2 }, { n: 5 }, { n: 1 }, { n: 6 }, { n: 7 }],\n *     (obj) => obj.n,\n *    ) // => [{n: 1}, {n: 2}, {n: 5}, {n: 6}, {n: 7}]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function uniqueBy<T extends IterableContainer>(\n  data: T,\n  keyFunction: (item: T[number], index: number, data: T) => unknown,\n): Deduped<T>;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list transformed by a function. Elements are compared by reference using Set.\n *\n * @param keyFunction - Extracts a value that would be used to compare elements.\n * @signature\n *    uniqueBy(keyFunction)(data)\n * @example\n *    pipe(\n *      [{n: 1}, {n: 2}, {n: 2}, {n: 5}, {n: 1}, {n: 6}, {n: 7}], // only 4 iterations\n *      uniqueBy(obj => obj.n),\n *      take(3)\n *    ) // => [{n: 1}, {n: 2}, {n: 5}]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function uniqueBy<T extends IterableContainer>(\n  keyFunction: (item: T[number], index: number, data: T) => unknown,\n): (data: T) => Deduped<T>;\n\nexport function uniqueBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(\n  keyFunction: (item: T, index: number, data: ReadonlyArray<T>) => unknown,\n): LazyEvaluator<T> {\n  // @see https://github.com/typescript-eslint/typescript-eslint/issues/9885\n  const brandedKeyFunction = keyFunction as BrandedReturn<typeof keyFunction>;\n\n  const set = new Set<ReturnType<typeof brandedKeyFunction>>();\n  return (value, index, data) => {\n    const key = brandedKeyFunction(value, index, data);\n    if (set.has(key)) {\n      return SKIP_ITEM;\n    }\n\n    set.add(key);\n    return { done: false, hasNext: true, next: value };\n  };\n}\n"],"mappings":"kGAkDA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAc,EAAoB,EAAK,CAGhD,SAAS,EACP,EACkB,CAElB,IAAM,EAAqB,EAErB,EAAM,IAAI,IAChB,OAAQ,EAAO,EAAO,IAAS,CAC7B,IAAM,EAAM,EAAmB,EAAO,EAAO,EAAK,CAMlD,OALI,EAAI,IAAI,EAAI,CACP,GAGT,EAAI,IAAI,EAAI,CACL,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO"}
+{"version":3,"file":"unique-by.js","names":[],"sources":["../src/unique-by.ts"],"sourcesContent":["import type { BrandedReturn } from './internal/types/branded-return';\nimport type { Deduped } from './internal/types/deduped';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list transformed by a function. Elements are compared by reference using Set.\n *\n * @param data - The array to filter.\n * @param keyFunction - Extracts a value that would be used to compare elements.\n * @signature\n *    uniqueBy(data, keyFunction)\n * @example\n *    uniqueBy(\n *     [{ n: 1 }, { n: 2 }, { n: 2 }, { n: 5 }, { n: 1 }, { n: 6 }, { n: 7 }],\n *     (obj) => obj.n,\n *    ) // => [{n: 1}, {n: 2}, {n: 5}, {n: 6}, {n: 7}]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function uniqueBy<T extends IterableContainer>(\n  data: T,\n  keyFunction: (item: T[number], index: number, data: T) => unknown,\n): Deduped<T>;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list transformed by a function. Elements are compared by reference using Set.\n *\n * @param keyFunction - Extracts a value that would be used to compare elements.\n * @signature\n *    uniqueBy(keyFunction)(data)\n * @example\n *    pipe(\n *      [{n: 1}, {n: 2}, {n: 2}, {n: 5}, {n: 1}, {n: 6}, {n: 7}], // only 4 iterations\n *      uniqueBy(obj => obj.n),\n *      take(3)\n *    ) // => [{n: 1}, {n: 2}, {n: 5}]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function uniqueBy<T extends IterableContainer>(\n  keyFunction: (item: T[number], index: number, data: T) => unknown,\n): (data: T) => Deduped<T>;\n\nexport function uniqueBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(\n  keyFunction: (item: T, index: number, data: ReadonlyArray<T>) => unknown,\n): LazyEvaluator<T> {\n  // @see https://github.com/typescript-eslint/typescript-eslint/issues/9885\n  const brandedKeyFunction = keyFunction as BrandedReturn<typeof keyFunction>;\n\n  const set = new Set<ReturnType<typeof brandedKeyFunction>>();\n  return (value, index, data) => {\n    const key = brandedKeyFunction(value, index, data);\n    if (set.has(key)) {\n      return SKIP_ITEM;\n    }\n\n    set.add(key);\n    return { done: false, hasNext: true, next: value };\n  };\n}\n"],"mappings":"kGAkDA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAc,EAAoB,CAAI,CAC/C,CAEA,SAAS,EACP,EACkB,CAElB,IAAM,EAAqB,EAErB,EAAM,IAAI,IAChB,OAAQ,EAAO,EAAO,IAAS,CAC7B,IAAM,EAAM,EAAmB,EAAO,EAAO,CAAI,EAMjD,OALI,EAAI,IAAI,CAAG,EACN,GAGT,EAAI,IAAI,CAAG,EACJ,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,CAAM,EACnD,CACF"}

package/dist/unique-with.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./utility-evaluators-C8koSp9T.cjs`),t=require(`./curry-from-lazy-BvN_VKlH.cjs`);function n(...e){return t.t(r,e)}function r(t){return(n,r,i)=>i.findIndex((e,i)=>r===i||t(n,e))===r?{done:!1,hasNext:!0,next:n}:e.t}exports.uniqueWith=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./utility-evaluators-BGM19SpK.cjs"),t=require("./curry-from-lazy-mdjeRP1g.cjs");function n(...e){return t.t(r,e)}function r(t){return(n,r,i)=>i.findIndex((e,i)=>r===i||t(n,e))===r?{done:!1,hasNext:!0,next:n}:e.t}exports.uniqueWith=n;
 //# sourceMappingURL=unique-with.cjs.map