@vinicunca/perkakas 1.13.2 → 1.15.0

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

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

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

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

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

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

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

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

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

@@ -1,86 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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-upper-case.d.cts

@@ -1,51 +0,0 @@
-//#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

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

@@ -1,51 +0,0 @@
-//#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

@@ -1 +0,0 @@
-{"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/tuple-parts-BYI4o8Vk.d.ts

@@ -1,89 +0,0 @@
-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

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

@@ -1,89 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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.d.cts

@@ -1,5 +0,0 @@
-//#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

@@ -1 +0,0 @@
-{"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,5 +0,0 @@
-//#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

@@ -1 +0,0 @@
-{"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/uncapitalize.d.cts

@@ -1,51 +0,0 @@
-//#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

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

@@ -1,51 +0,0 @@
-//#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

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