@vinicunca/perkakas 1.9.0 → 1.13.0

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

@@ -0,0 +1,86 @@
+import { t as OptionalOptionsWithDefaults } from "./optional-options-with-defaults-BFaBSKkF.js";
+import { IsEqual, IsLiteral, Join, Words } from "type-fest";
+
+//#region src/to-title-case.d.ts
+declare const DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE = true;
+interface TitleCaseOptions {
+  readonly preserveConsecutiveUppercase?: boolean;
+}
+type TitleCaseOptionsWithDefaults<Options extends TitleCaseOptions> = OptionalOptionsWithDefaults<TitleCaseOptions, Options, {
+  preserveConsecutiveUppercase: typeof DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE;
+}>;
+type TitleCase<S extends string, Options extends TitleCaseOptions> = IsLiteral<S> extends true ? Join<TitleCasedArray<Words<IsEqual<S, Uppercase<S>> extends true ? Lowercase<S> : S>, TitleCaseOptionsWithDefaults<Options>>, ' '> : string;
+type TitleCasedArray<T extends ReadonlyArray<string>, Options extends TitleCaseOptions> = { [I in keyof T]: Capitalize<Options['preserveConsecutiveUppercase'] extends true ? T[I] : Lowercase<T[I]>> };
+/**
+ * Converts text to **Title Case** by splitting it into words, capitalizing the
+ * first letter of each word, then joining them back together with spaces.
+ *
+ * Because it uses the built-in case conversion methods, the function shares
+ * their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_,
+ * making it best suited for simple strings like identifiers and internal keys.
+ * For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)
+ * with [`granularity: "word"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters),
+ * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),
+ * and [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase)
+ * which are purpose-built to handle nuances in languages and locales.
+ *
+ * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,
+ * `uncapitalize`, `toCamelCase`, `toKebabCase`, and `toSnakeCase`.
+ *
+ * @param data - A string.
+ * @param options - An _optional_ object with the _optional_ property
+ * `preserveConsecutiveUppercase` that can be used to change the way consecutive
+ * uppercase characters are handled. Defaults to `true`.
+ * @signature
+ *   R.toTitleCase(data);
+ *   R.toTitleCase(data, { preserveConsecutiveUppercase });
+ * @example
+ *   R.toTitleCase("hello world"); // "Hello World"
+ *   R.toTitleCase("--foo-bar--"); // "Foo Bar"
+ *   R.toTitleCase("fooBar"); // "Foo Bar"
+ *   R.toTitleCase("__FOO_BAR__"); // "Foo Bar"
+ *   R.toTitleCase("XMLHttpRequest"); // "XML Http Request"
+ *   R.toTitleCase("XMLHttpRequest", { preserveConsecutiveUppercase: false }); // "Xml Http Request"
+ * @dataFirst
+ * @category String
+ */
+declare function toTitleCase<S extends string, Options extends TitleCaseOptions>(data: S, options?: Options): TitleCase<S, Options>;
+/**
+ * Converts text to **Title Case** by splitting it into words, capitalizing the
+ * first letter of each word, then joining them back together with spaces.
+ *
+ * Because it uses the built-in case conversion methods, the function shares
+ * their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_,
+ * making it best suited for simple strings like identifiers and internal keys.
+ * For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)
+ * with [`granularity: "word"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters),
+ * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),
+ * and [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase)
+ * which are purpose-built to handle nuances in languages and locales.
+ *
+ * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,
+ * `uncapitalize`, `toCamelCase`, `toKebabCase`, and `toSnakeCase`.
+ *
+ * @param options - An _optional_ object with the _optional_ property
+ * `preserveConsecutiveUppercase` that can be used to change the way consecutive
+ * uppercase characters are handled. Defaults to `true`.
+ * @signature
+ *   R.toTitleCase()(data);
+ *   R.toTitleCase({ preserveConsecutiveUppercase })(data);
+ * @example
+ *   R.pipe("hello world", R.toTitleCase()); // "Hello World"
+ *   R.pipe("--foo-bar--", R.toTitleCase()); // "Foo Bar"
+ *   R.pipe("fooBar", R.toTitleCase()); // "Foo Bar"
+ *   R.pipe("__FOO_BAR__", R.toTitleCase()); // "Foo Bar"
+ *   R.pipe("XMLHttpRequest", R.toTitleCase()); // "XML Http Request"
+ *   R.pipe(
+ *     "XMLHttpRequest",
+ *     R.toTitleCase({ preserveConsecutiveUppercase: false }),
+ *   ); // "Xml Http Request"
+ * @dataLast
+ * @category String
+ */
+declare function toTitleCase<Options extends TitleCaseOptions>(options?: Options): <S extends string>(data: S) => TitleCase<S, Options>;
+//#endregion
+export { toTitleCase };
+//# sourceMappingURL=to-title-case.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"to-title-case.d.ts","names":[],"sources":["../src/to-title-case.ts"],"sourcesContent":[],"mappings":";;;;cAMM,sCAAA;UAEI,gBAAA;EAFJ,SAAA,4BAAA,CAAA,EAAA,OAAsC;AAAA;AAElB,KAIrB,4BAAA,CAAA,gBAA6C,gBAAjB,CAAA,GAC7B,2BAD6B,CAE7B,gBAF6B,EAG7B,OAH6B,EAAA;EAAiB,4BAAA,EAAA,OAMP,sCANO;CAE9C,CAAA;KAQC,SAPD,CAAA,UAAA,MAAA,EAAA,gBAO6C,gBAP7C,CAAA,GAQA,SARA,CAQU,CARV,CAAA,SAAA,IAAA,GASE,IATF,CAUE,eAVF,CAWI,KAXJ,CAWU,OAXV,CAWkB,CAXlB,EAWqB,SAXrB,CAW+B,CAX/B,CAAA,CAAA,SAAA,IAAA,GAWkD,SAXlD,CAW4D,CAX5D,CAAA,GAWiE,CAXjE,CAAA,EAYI,4BAZJ,CAYiC,OAZjC,CAAA,CAAA,EAAA,GAAA,CAAA,GAAA,MAAA;KAkBC,eAfsC,CAAA,UAgB/B,aAhB+B,CAAA,MAAA,CAAA,EAAA,gBAiBzB,gBAjByB,CAAA,GAAA,QALvC,MAwBU,CAxBV,GAwBc,UAxBd,CAyBA,OAzBA,CAAA,8BAAA,CAAA,SAAA,IAAA,GA0BI,CA1BJ,CA0BM,CA1BN,CAAA,GA2BI,SA3BJ,CA2Bc,CA3Bd,CA2BgB,CA3BhB,CAAA,CAAA,CAAA,EAA2B;AAAA;;;;;;;;;;;;;;;;;AAWrB;;;;;;;;;;;;AAqDV;;;;AAGa,iBAHG,WAGH,CAAA,UAAA,MAAA,EAAA,gBAHiD,gBAGjD,CAAA,CAAA,IAAA,EAFL,CAEK,EAAA,OAAA,CAAA,EADD,OACC,CAAA,EAAV,SAAU,CAAA,CAAA,EAAG,OAAH,CAAA;;;;AAqCb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,4BAA4B,4BAChC,mCACgB,MAAM,UAAU,GAAG"}

package/dist/to-title-case.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"to-title-case.js","names":[],"sources":["../src/to-title-case.ts"],"sourcesContent":["import type { IsEqual, IsLiteral, Join, Words } from 'type-fest';\nimport type { OptionalOptionsWithDefaults } from './internal/types/optional-options-with-defaults';\nimport { words } from './internal/words';\n\nconst LOWER_CASE_CHARACTER_RE = /[a-z]/u;\n\nconst DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE = true;\n\ninterface TitleCaseOptions {\n  readonly preserveConsecutiveUppercase?: boolean;\n}\n\ntype TitleCaseOptionsWithDefaults<Options extends TitleCaseOptions>\n  = OptionalOptionsWithDefaults<\n    TitleCaseOptions,\n    Options,\n    {\n      // We use the runtime const for the default type so they stay coupled.\n      preserveConsecutiveUppercase: typeof DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE;\n    }\n  >;\n\ntype TitleCase<S extends string, Options extends TitleCaseOptions>\n  = IsLiteral<S> extends true\n    ? Join<\n      TitleCasedArray<\n        Words<IsEqual<S, Uppercase<S>> extends true ? Lowercase<S> : S>,\n        TitleCaseOptionsWithDefaults<Options>\n      >,\n      ' '\n    >\n    : string;\n\ntype TitleCasedArray<\n  T extends ReadonlyArray<string>,\n  Options extends TitleCaseOptions,\n> = {\n  [I in keyof T]: Capitalize<\n    Options['preserveConsecutiveUppercase'] extends true\n      ? T[I]\n      : Lowercase<T[I]>\n  >;\n};\n\n/**\n * Converts text to **Title Case** by splitting it into words, capitalizing the\n * first letter of each word, then joining them back together with spaces.\n *\n * Because it uses the built-in case conversion methods, the function shares\n * their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_,\n * making it best suited for simple strings like identifiers and internal keys.\n * For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters),\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * and [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase)\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, and `toSnakeCase`.\n *\n * @param data - A string.\n * @param options - An _optional_ object with the _optional_ property\n * `preserveConsecutiveUppercase` that can be used to change the way consecutive\n * uppercase characters are handled. Defaults to `true`.\n * @signature\n *   R.toTitleCase(data);\n *   R.toTitleCase(data, { preserveConsecutiveUppercase });\n * @example\n *   R.toTitleCase(\"hello world\"); // \"Hello World\"\n *   R.toTitleCase(\"--foo-bar--\"); // \"Foo Bar\"\n *   R.toTitleCase(\"fooBar\"); // \"Foo Bar\"\n *   R.toTitleCase(\"__FOO_BAR__\"); // \"Foo Bar\"\n *   R.toTitleCase(\"XMLHttpRequest\"); // \"XML Http Request\"\n *   R.toTitleCase(\"XMLHttpRequest\", { preserveConsecutiveUppercase: false }); // \"Xml Http Request\"\n * @dataFirst\n * @category String\n */\nexport function toTitleCase<S extends string, Options extends TitleCaseOptions>(\n  data: S,\n  options?: Options,\n): TitleCase<S, Options>;\n\n/**\n * Converts text to **Title Case** by splitting it into words, capitalizing the\n * first letter of each word, then joining them back together with spaces.\n *\n * Because it uses the built-in case conversion methods, the function shares\n * their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_,\n * making it best suited for simple strings like identifiers and internal keys.\n * For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters),\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * and [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase)\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, and `toSnakeCase`.\n *\n * @param options - An _optional_ object with the _optional_ property\n * `preserveConsecutiveUppercase` that can be used to change the way consecutive\n * uppercase characters are handled. Defaults to `true`.\n * @signature\n *   R.toTitleCase()(data);\n *   R.toTitleCase({ preserveConsecutiveUppercase })(data);\n * @example\n *   R.pipe(\"hello world\", R.toTitleCase()); // \"Hello World\"\n *   R.pipe(\"--foo-bar--\", R.toTitleCase()); // \"Foo Bar\"\n *   R.pipe(\"fooBar\", R.toTitleCase()); // \"Foo Bar\"\n *   R.pipe(\"__FOO_BAR__\", R.toTitleCase()); // \"Foo Bar\"\n *   R.pipe(\"XMLHttpRequest\", R.toTitleCase()); // \"XML Http Request\"\n *   R.pipe(\n *     \"XMLHttpRequest\",\n *     R.toTitleCase({ preserveConsecutiveUppercase: false }),\n *   ); // \"Xml Http Request\"\n * @dataLast\n * @category String\n */\nexport function toTitleCase<Options extends TitleCaseOptions>(\n  options?: Options,\n): <S extends string>(data: S) => TitleCase<S, Options>;\n\nexport function toTitleCase(\n  dataOrOptions?: TitleCaseOptions | string,\n  options?: TitleCaseOptions,\n): unknown {\n  return typeof dataOrOptions === 'string'\n    ? toTitleCaseImplementation(dataOrOptions, options)\n    : (data: string) => toTitleCaseImplementation(data, dataOrOptions);\n}\n\n// Similar to the implementation used in toCamelCase\nfunction toTitleCaseImplementation(data: string, {\n  preserveConsecutiveUppercase = DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE,\n}: TitleCaseOptions = {}): string {\n  return words(\n    LOWER_CASE_CHARACTER_RE.test(data)\n      ? data\n      // If the text doesn't have **any** lowercase characters, we lowercase\n      // everything; otherwise we maintain existing case as it affects word\n      // boundaries.\n      : data.toLowerCase(),\n  )\n    .map(\n      (word) =>\n        `${word[0]!.toUpperCase()}${\n          preserveConsecutiveUppercase\n            ? word.slice(1)\n            : word.slice(1).toLowerCase()\n        }`,\n    )\n    .join(' ');\n}\n"],"mappings":"wCAIA,MAAM,EAA0B,SAqHhC,SAAgB,EACd,EACA,EACS,CACT,OAAO,OAAO,GAAkB,SAC5B,EAA0B,EAAe,EAAQ,CAChD,GAAiB,EAA0B,EAAM,EAAc,CAItE,SAAS,EAA0B,EAAc,CAC/C,+BAA+B,IACX,EAAE,CAAU,CAChC,OAAO,EACL,EAAwB,KAAK,EAAK,CAC9B,EAIA,EAAK,aAAa,CACvB,CACE,IACE,GACC,GAAG,EAAK,GAAI,aAAa,GACvB,EACI,EAAK,MAAM,EAAE,CACb,EAAK,MAAM,EAAE,CAAC,aAAa,GAEpC,CACA,KAAK,IAAI"}

package/dist/to-upper-case.cjs

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

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

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

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

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

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

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

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

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

package/dist/to-upper-case.js

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

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

@@ -0,0 +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 *   P.toUpperCase(data);\n * @example\n *   P.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 *   P.toUpperCase()(data);\n * @example\n *   P.pipe(\"Hello World\", P.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  // @ts-expect-error [ts2322] -- TypeScript can't infer this from the code...\n  return data.toUpperCase();\n}\n"],"mappings":"wCAmDA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,EAA2B,EAAK,CAG/C,SAAS,EAA4C,EAAuB,CAE1E,OAAO,EAAK,aAAa"}

package/dist/tuple-parts-BYI4o8Vk.d.ts

@@ -0,0 +1,89 @@
+import { t as IterableContainer } from "./iterable-container-Dv5vSKht.js";
+import { t as PerkakasTypeError } from "./perkakas-type-error-B9ULNhW0.js";
+import { Or, Simplify } from "type-fest";
+
+//#region src/internal/types/tuple-parts.d.ts
+
+/**
+ * Takes a tuple and returns the types that make up its parts. These parts
+ * follow TypeScript's only supported format for arrays/tuples:
+ * [<required>, <optional>, ...<rest>[], <suffix>].
+ *
+ * There are some limitations to what shapes TypeScript supports:
+ * tuples can only have a suffix if they also have a non-never rest element,
+ * **and** tuples cannot have both an optional part and a suffix; this means
+ * there are only 10 possible shapes for tuples:
+ *   1.  Empty Tuples: `[]`.
+ *   2.  Fixed Tuples: `[string, number]`.
+ *   3.  Optional Tuples: `[string?, number?]`.
+ *   4.  Mixed Tuples: `[string, number?]`.
+ *   5.  Arrays: `Array<string>`.
+ *   6.  Fixed-Prefix Arrays: `[string, ...Array<string>]`.
+ *   7.  Optional-Prefix Arrays: `[number?, ...Array<boolean>]`.
+ *   8.  Mixed-Prefix Arrays: `[string, number?, ...Array<boolean>]`.
+ *   9.  Fixed-Suffix Arrays: `[...Array<string>, string]`.
+ *   10. Fixed-Elements Arrays: `[string, ...Array<string>, string]`.
+ *
+ * @example [
+ *   ...TupleParts<T>["required"],
+ *   ...PartialArray<TupleParts<T>["optional"]>,
+ *   ...CoercedArray<TupleParts<T>["item"]>,
+ *   ...TupleParts<T>["suffix"],
+ * ].
+ */
+type TupleParts<T extends IterableContainer, Prefix extends Array<unknown> = []> = T extends readonly [infer Head, ...infer Tail] ? TupleParts<Tail, [...Prefix, Head]> : Simplify<{
+  /**
+   * A fixed tuple that defines the part of the tuple where all its
+   * elements are required. This will always be the first part of the
+   * tuple and will never contain any optional or rest elements. When the
+   * array doesn't have a required part this will be an empty tuple
+   * (`[]`).
+   */
+  required: Prefix;
+} & TuplePartsWithoutRequired<T>>;
+type TuplePartsWithoutRequired<T extends IterableContainer, Suffix extends Array<unknown> = []> = T extends readonly [...infer Head, infer Tail] ? TuplePartsWithoutRequired<Head, [Tail, ...Suffix]> : (Suffix extends readonly [] ? TuplePartsWithoutFixed<T> : {
+  optional: [];
+} & TuplePartsRest<T>) & {
+  /**
+   * A *fixed* tuple that defines the part of a tuple **after** a non-never
+   * rest parameter. These could never be optional elements, and could
+   * never contain another rest element. When the array doesn't have a
+   * required part this will be an empty tuple (`[]`).
+   */
+  suffix: Suffix;
+};
+type TuplePartsWithoutFixed<T extends IterableContainer, Optional extends Array<unknown> = []> = T extends readonly [(infer Head)?, ...infer Tail] ? Or<T extends readonly [] ? true : false, Array<T[number]> extends Tail ? true : false> extends true ? {
+  /**
+   * A *fixed* tuple that defines the part of a tuple where all its
+   * elements are suffixed with the optional operator (`?`); but with
+   * the optional operator removed (e.g. `[string?]` would be
+   * represented as `[string]`). These elements can only follow the
+   * `required` part (which could be empty).
+   * To add the optional operator back, wrap the result with the
+   * `PartialArray` type.
+   * When the array doesn't have a required part this will be an empty
+   * tuple (`[]`).
+   *
+   * @example PartialArray<TupleParts<T>["optional"]>
+   */
+  optional: Optional;
+} & TuplePartsRest<T> : TuplePartsWithoutFixed<Tail, [...Optional, Head]> : PerkakasTypeError<'TupleParts', 'Unexpected tuple shape', {
+  type: never;
+  metadata: T;
+}>;
+interface TuplePartsRest<T extends IterableContainer> {
+  /**
+   * The type for the rest parameter of the tuple, if any. Unlike the
+   * other parts of the tuple, this is a single type and not
+   * represented as an array/tuple. When a tuple doesn't have a rest
+   * element, this will be `never`. To convert this to a matching array
+   * type that could be spread into a new type use the `CoercedArray`
+   * type which handles the `never` case correctly.
+   *
+   * @example CoercedArray<TupleParts<T>["item"]>
+   */
+  item: T extends readonly [] ? never : T[number];
+}
+//#endregion
+export { TupleParts as t };
+//# sourceMappingURL=tuple-parts-BYI4o8Vk.d.ts.map

package/dist/tuple-parts-BYI4o8Vk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tuple-parts-BYI4o8Vk.d.ts","names":[],"sources":["../src/internal/types/tuple-parts.ts"],"sourcesContent":[],"mappings":";;;;;;;;AA+BA;;;;;;;;;;;;;AAoBI;;;;;;;;;;;;AAgBqB,KApCb,UAoCa,CAAA,UAnCb,iBAmCa,EAAA,eAlCR,KAkCQ,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GAjCrB,CAiCqB,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GA9BrB,UA8BqB,CA9BV,IA8BU,EAAA,CAAA,GA9BA,MA8BA,EA9BQ,IA8BR,CAAA,CAAA,GA3BrB,QA2BqB,CAAA;EAOX;;AAAM;;;;;EAmBV,QAAA,EA5CM,MA4CN;CAAN,GA3CI,yBA2CJ,CA3C8B,CA2C9B,CAAA,CAAA;KAvCC,yBAiCD,CAAA,UAhCQ,iBAgCR,EAAA,eA/Ba,KA+Bb,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GA9BA,CA8BA,SAAA,SAAA,CAAA,GAAA,KAAA,KAAA,EAAA,KAAA,KAAA,CAAA,GA3BA,yBA2BA,CA3B0B,IA2B1B,EAAA,CA3BiC,IA2BjC,EAAA,GA3B0C,MA2B1C,CAAA,CAAA,GAAA,CA1BC,MA0BD,SAAA,SAAA,EAAA,GAvBE,sBAuBF,CAvByB,CAuBzB,CAAA,GAAA;EAqBU,QAAA,EAAA,EAAA;CACO,GA1CI,cA0CJ,CA1CmB,CA0CnB,CAAA,CAAA,GAAA;EAAf;;;;;;EAEF,MAAA,EArCU,MAqCV;CAAiB;AAAA,KAhChB,sBA4CmB,CAAA,UA3CZ,iBA2CY,EAAA,iBA1CL,KA0CK,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GAzCpB,CAyCoB,SAAA,SAAA,CAAA,CAAA,KAAA,KAAA,CAAA,CAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GApCpB,EAoCoB,CAjCpB,CAiCoB,SAAA,SAAA,EAAA,GAAA,IAAA,GAAA,KAAA,EA9BpB,KA8BoB,CA9Bd,CA8Bc,CAAA,MAAA,CAAA,CAAA,SAAA,IAAA,GAAA,IAAA,GAAA,KAAA,CAAA,SAAA,IAAA,GAAA;EAAW;;;;;;;;;;;;;YAfrB;IACR,eAAe,KACf,uBAAuB,UAAU,UAAU,SAC7C;;YAKY;;UAON,yBAAyB;;;;;;;;;;;QAW3B,gCAAgC"}

package/dist/tuple-parts-CzQQupgi.d.cts

@@ -0,0 +1,89 @@
+import { t as IterableContainer } from "./iterable-container-1TN3AJ3s.cjs";
+import { t as PerkakasTypeError } from "./perkakas-type-error-ClCCHBW1.cjs";
+import { Or, Simplify } from "type-fest";
+
+//#region src/internal/types/tuple-parts.d.ts
+
+/**
+ * Takes a tuple and returns the types that make up its parts. These parts
+ * follow TypeScript's only supported format for arrays/tuples:
+ * [<required>, <optional>, ...<rest>[], <suffix>].
+ *
+ * There are some limitations to what shapes TypeScript supports:
+ * tuples can only have a suffix if they also have a non-never rest element,
+ * **and** tuples cannot have both an optional part and a suffix; this means
+ * there are only 10 possible shapes for tuples:
+ *   1.  Empty Tuples: `[]`.
+ *   2.  Fixed Tuples: `[string, number]`.
+ *   3.  Optional Tuples: `[string?, number?]`.
+ *   4.  Mixed Tuples: `[string, number?]`.
+ *   5.  Arrays: `Array<string>`.
+ *   6.  Fixed-Prefix Arrays: `[string, ...Array<string>]`.
+ *   7.  Optional-Prefix Arrays: `[number?, ...Array<boolean>]`.
+ *   8.  Mixed-Prefix Arrays: `[string, number?, ...Array<boolean>]`.
+ *   9.  Fixed-Suffix Arrays: `[...Array<string>, string]`.
+ *   10. Fixed-Elements Arrays: `[string, ...Array<string>, string]`.
+ *
+ * @example [
+ *   ...TupleParts<T>["required"],
+ *   ...PartialArray<TupleParts<T>["optional"]>,
+ *   ...CoercedArray<TupleParts<T>["item"]>,
+ *   ...TupleParts<T>["suffix"],
+ * ].
+ */
+type TupleParts<T extends IterableContainer, Prefix extends Array<unknown> = []> = T extends readonly [infer Head, ...infer Tail] ? TupleParts<Tail, [...Prefix, Head]> : Simplify<{
+  /**
+   * A fixed tuple that defines the part of the tuple where all its
+   * elements are required. This will always be the first part of the
+   * tuple and will never contain any optional or rest elements. When the
+   * array doesn't have a required part this will be an empty tuple
+   * (`[]`).
+   */
+  required: Prefix;
+} & TuplePartsWithoutRequired<T>>;
+type TuplePartsWithoutRequired<T extends IterableContainer, Suffix extends Array<unknown> = []> = T extends readonly [...infer Head, infer Tail] ? TuplePartsWithoutRequired<Head, [Tail, ...Suffix]> : (Suffix extends readonly [] ? TuplePartsWithoutFixed<T> : {
+  optional: [];
+} & TuplePartsRest<T>) & {
+  /**
+   * A *fixed* tuple that defines the part of a tuple **after** a non-never
+   * rest parameter. These could never be optional elements, and could
+   * never contain another rest element. When the array doesn't have a
+   * required part this will be an empty tuple (`[]`).
+   */
+  suffix: Suffix;
+};
+type TuplePartsWithoutFixed<T extends IterableContainer, Optional extends Array<unknown> = []> = T extends readonly [(infer Head)?, ...infer Tail] ? Or<T extends readonly [] ? true : false, Array<T[number]> extends Tail ? true : false> extends true ? {
+  /**
+   * A *fixed* tuple that defines the part of a tuple where all its
+   * elements are suffixed with the optional operator (`?`); but with
+   * the optional operator removed (e.g. `[string?]` would be
+   * represented as `[string]`). These elements can only follow the
+   * `required` part (which could be empty).
+   * To add the optional operator back, wrap the result with the
+   * `PartialArray` type.
+   * When the array doesn't have a required part this will be an empty
+   * tuple (`[]`).
+   *
+   * @example PartialArray<TupleParts<T>["optional"]>
+   */
+  optional: Optional;
+} & TuplePartsRest<T> : TuplePartsWithoutFixed<Tail, [...Optional, Head]> : PerkakasTypeError<'TupleParts', 'Unexpected tuple shape', {
+  type: never;
+  metadata: T;
+}>;
+interface TuplePartsRest<T extends IterableContainer> {
+  /**
+   * The type for the rest parameter of the tuple, if any. Unlike the
+   * other parts of the tuple, this is a single type and not
+   * represented as an array/tuple. When a tuple doesn't have a rest
+   * element, this will be `never`. To convert this to a matching array
+   * type that could be spread into a new type use the `CoercedArray`
+   * type which handles the `never` case correctly.
+   *
+   * @example CoercedArray<TupleParts<T>["item"]>
+   */
+  item: T extends readonly [] ? never : T[number];
+}
+//#endregion
+export { TupleParts as t };
+//# sourceMappingURL=tuple-parts-CzQQupgi.d.cts.map

package/dist/tuple-parts-CzQQupgi.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tuple-parts-CzQQupgi.d.cts","names":[],"sources":["../src/internal/types/tuple-parts.ts"],"sourcesContent":[],"mappings":";;;;;;;;AA+BA;;;;;;;;;;;;;AAoBI;;;;;;;;;;;;AAgBqB,KApCb,UAoCa,CAAA,UAnCb,iBAmCa,EAAA,eAlCR,KAkCQ,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GAjCrB,CAiCqB,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GA9BrB,UA8BqB,CA9BV,IA8BU,EAAA,CAAA,GA9BA,MA8BA,EA9BQ,IA8BR,CAAA,CAAA,GA3BrB,QA2BqB,CAAA;EAOX;;AAAM;;;;;EAmBV,QAAA,EA5CM,MA4CN;CAAN,GA3CI,yBA2CJ,CA3C8B,CA2C9B,CAAA,CAAA;KAvCC,yBAiCD,CAAA,UAhCQ,iBAgCR,EAAA,eA/Ba,KA+Bb,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GA9BA,CA8BA,SAAA,SAAA,CAAA,GAAA,KAAA,KAAA,EAAA,KAAA,KAAA,CAAA,GA3BA,yBA2BA,CA3B0B,IA2B1B,EAAA,CA3BiC,IA2BjC,EAAA,GA3B0C,MA2B1C,CAAA,CAAA,GAAA,CA1BC,MA0BD,SAAA,SAAA,EAAA,GAvBE,sBAuBF,CAvByB,CAuBzB,CAAA,GAAA;EAqBU,QAAA,EAAA,EAAA;CACO,GA1CI,cA0CJ,CA1CmB,CA0CnB,CAAA,CAAA,GAAA;EAAf;;;;;;EAEF,MAAA,EArCU,MAqCV;CAAiB;AAAA,KAhChB,sBA4CmB,CAAA,UA3CZ,iBA2CY,EAAA,iBA1CL,KA0CK,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GAzCpB,CAyCoB,SAAA,SAAA,CAAA,CAAA,KAAA,KAAA,CAAA,CAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GApCpB,EAoCoB,CAjCpB,CAiCoB,SAAA,SAAA,EAAA,GAAA,IAAA,GAAA,KAAA,EA9BpB,KA8BoB,CA9Bd,CA8Bc,CAAA,MAAA,CAAA,CAAA,SAAA,IAAA,GAAA,IAAA,GAAA,KAAA,CAAA,SAAA,IAAA,GAAA;EAAW;;;;;;;;;;;;;YAfrB;IACR,eAAe,KACf,uBAAuB,UAAU,UAAU,SAC7C;;YAKY;;UAON,yBAAyB;;;;;;;;;;;QAW3B,gCAAgC"}

package/dist/type.helpers.cjs

@@ -1 +0,0 @@
-require(`./type.helpers-DRN0iRW5.cjs`);

package/dist/type.helpers.d.cts

@@ -1,2 +1,5 @@
-import { DeepPartial } from "./type.helpers-Dmf6ppyq.cjs";
-export { DeepPartial };
+//#region src/type.helpers.d.ts
+type DeepPartial<T> = T extends object ? { [P in keyof T]?: DeepPartial<T[P]> } : T;
+//#endregion
+export { DeepPartial };
+//# sourceMappingURL=type.helpers.d.cts.map

package/dist/type.helpers.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type.helpers.d.cts","names":[],"sources":["../src/type.helpers.ts"],"sourcesContent":[],"mappings":";KAAY,iBAAiB,2BAAjB,MAEM,CAFN,IAEW,WAFA,CAEY,CAFZ,CAEc,CAFd,CAAA,CAAA,EAAM,GAIzB,CAJyB"}

package/dist/type.helpers.d.ts

@@ -1,2 +1,5 @@
-import { DeepPartial } from "./type.helpers-1V2lXyqJ.js";
-export { DeepPartial };
+//#region src/type.helpers.d.ts
+type DeepPartial<T> = T extends object ? { [P in keyof T]?: DeepPartial<T[P]> } : T;
+//#endregion
+export { DeepPartial };
+//# sourceMappingURL=type.helpers.d.ts.map

package/dist/type.helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type.helpers.d.ts","names":[],"sources":["../src/type.helpers.ts"],"sourcesContent":[],"mappings":";KAAY,iBAAiB,2BAAjB,MAEM,CAFN,IAEW,WAFA,CAEY,CAFZ,CAEc,CAFd,CAAA,CAAA,EAAM,GAIzB,CAJyB"}

package/dist/type.helpers.js

@@ -1 +0,0 @@
-import"./type.helpers-eVB6l9f9.js";

package/dist/uncapitalize.cjs

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

package/dist/uncapitalize.d.cts

@@ -0,0 +1,51 @@
+//#region src/uncapitalize.d.ts
+/**
+ * Makes the first character of a string lowercase while leaving the rest
+ * unchanged.
+ *
+ * It uses the built-in [`String.prototype.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)
+ * for the runtime and the built-in [`Uncapitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#Uncapitalizestringtype)
+ * 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)_.
+ *
+ * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target
+ * just the first letter of the word, and [`text-transform: lowercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#lowercase)
+ * to lowercase it. This transformation **is** locale-aware.
+ *
+ * For other case manipulations see: `toUpperCase`, `toLowerCase`, `capitalize`,
+ * `toCamelCase`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.
+ *
+ * @param data - A string.
+ * @signature
+ *   P.uncapitalize(data);
+ * @example
+ *   P.uncapitalize("HELLO WORLD"); // "hELLO WORLD"
+ * @dataFirst
+ * @category String
+ */
+declare function uncapitalize<T extends string>(data: T): Uncapitalize<T>;
+/**
+ * Makes the first character of a string lowercase while leaving the rest
+ * unchanged.
+ *
+ * It uses the built-in [`String.prototype.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)
+ * for the runtime and the built-in [`Uncapitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#Uncapitalizestringtype)
+ * 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)_.
+ *
+ * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target
+ * just the first letter of the word, and [`text-transform: lowercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#lowercase)
+ * to lowercase it. This transformation **is** locale-aware.
+ *
+ * For other case manipulations see: `toUpperCase`, `toLowerCase`, `capitalize`,
+ * `toCamelCase`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.
+ *
+ * @signature
+ *   P.uncapitalize()(data);
+ * @example
+ *   P.pipe("HELLO WORLD", P.uncapitalize()); // "hELLO WORLD"
+ * @dataLast
+ * @category String
+ */
+declare function uncapitalize(): <T extends string>(data: T) => Uncapitalize<T>;
+//#endregion
+export { uncapitalize };
+//# sourceMappingURL=uncapitalize.d.cts.map

package/dist/uncapitalize.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uncapitalize.d.cts","names":[],"sources":["../src/uncapitalize.ts"],"sourcesContent":[],"mappings":";;AAyBA;;;;;AAwBA;;;;;;;;;;;;;;;;;iBAxBgB,qCAAqC,IAAI,aAAa;;;;;;;;;;;;;;;;;;;;;;;iBAwBtD,YAAA,CAAA,4BAAyC,MAAM,aAAa"}

package/dist/uncapitalize.d.ts

@@ -0,0 +1,51 @@
+//#region src/uncapitalize.d.ts
+/**
+ * Makes the first character of a string lowercase while leaving the rest
+ * unchanged.
+ *
+ * It uses the built-in [`String.prototype.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)
+ * for the runtime and the built-in [`Uncapitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#Uncapitalizestringtype)
+ * 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)_.
+ *
+ * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target
+ * just the first letter of the word, and [`text-transform: lowercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#lowercase)
+ * to lowercase it. This transformation **is** locale-aware.
+ *
+ * For other case manipulations see: `toUpperCase`, `toLowerCase`, `capitalize`,
+ * `toCamelCase`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.
+ *
+ * @param data - A string.
+ * @signature
+ *   P.uncapitalize(data);
+ * @example
+ *   P.uncapitalize("HELLO WORLD"); // "hELLO WORLD"
+ * @dataFirst
+ * @category String
+ */
+declare function uncapitalize<T extends string>(data: T): Uncapitalize<T>;
+/**
+ * Makes the first character of a string lowercase while leaving the rest
+ * unchanged.
+ *
+ * It uses the built-in [`String.prototype.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)
+ * for the runtime and the built-in [`Uncapitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#Uncapitalizestringtype)
+ * 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)_.
+ *
+ * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target
+ * just the first letter of the word, and [`text-transform: lowercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#lowercase)
+ * to lowercase it. This transformation **is** locale-aware.
+ *
+ * For other case manipulations see: `toUpperCase`, `toLowerCase`, `capitalize`,
+ * `toCamelCase`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.
+ *
+ * @signature
+ *   P.uncapitalize()(data);
+ * @example
+ *   P.pipe("HELLO WORLD", P.uncapitalize()); // "hELLO WORLD"
+ * @dataLast
+ * @category String
+ */
+declare function uncapitalize(): <T extends string>(data: T) => Uncapitalize<T>;
+//#endregion
+export { uncapitalize };
+//# sourceMappingURL=uncapitalize.d.ts.map

package/dist/uncapitalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uncapitalize.d.ts","names":[],"sources":["../src/uncapitalize.ts"],"sourcesContent":[],"mappings":";;AAyBA;;;;;AAwBA;;;;;;;;;;;;;;;;;iBAxBgB,qCAAqC,IAAI,aAAa;;;;;;;;;;;;;;;;;;;;;;;iBAwBtD,YAAA,CAAA,4BAAyC,MAAM,aAAa"}

package/dist/uncapitalize.js

@@ -0,0 +1,2 @@
+import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e){return`${e[0]?.toLowerCase()??``}${e.slice(1)}`}export{t as uncapitalize};
+//# sourceMappingURL=uncapitalize.js.map

package/dist/uncapitalize.js.map

@@ -0,0 +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 *   P.uncapitalize(data);\n * @example\n *   P.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 *   P.uncapitalize()(data);\n * @example\n *   P.pipe(\"HELLO WORLD\", P.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":"wCAmDA,SAAgB,EAAa,GAAG,EAAuC,CACrE,OAAO,EAAM,EAA4B,EAAK,CAGhD,SAAS,EAA6C,EAA0B,CAC9E,MAAO,GAAG,EAAK,IAAI,aAAa,EAAI,KAAK,EAAK,MAAM,EAAE"}

package/dist/unique-by.cjs

@@ -1 +1 @@
-require(`./utility-evaluators-DqJcWENu.cjs`),require(`./pipe-DlFjc4Wf.cjs`),require(`./curry-from-lazy-BDH06qZ-.cjs`);const e=require(`./unique-by-Ds6Uwfxl.cjs`);exports.uniqueBy=e.uniqueBy;
+const e=require(`./utility-evaluators-CAbODbuk.cjs`),t=require(`./curry-from-lazy-BCGvmhyS.cjs`);function n(...e){return t.t(r,e)}function r(t){let n=new Set;return(r,i,a)=>{let o=t(r,i,a);return n.has(o)?e.t:(n.add(o),{done:!1,hasNext:!0,next:r})}}exports.uniqueBy=n;