@vinicunca/perkakas 1.13.2 → 1.14.0

package/dist/times.d.ts

@@ -1,48 +0,0 @@
-import { GreaterThan } from "type-fest";
-
-//#region src/times.d.ts
-type MAX_LITERAL_SIZE = 46;
-type TimesArray<T, N extends number, Iteration extends ReadonlyArray<unknown> = []> = number extends N ? Array<T> : `${N}` extends `-${number}` ? [] : `${N}` extends `${infer K extends number}.${number}` ? TimesArray<T, K, Iteration> : GreaterThan<N, MAX_LITERAL_SIZE> extends true ? [...TimesArray<T, MAX_LITERAL_SIZE, Iteration>, ...Array<T>] : N extends Iteration['length'] ? [] : [T, ...TimesArray<T, N, [unknown, ...Iteration]>];
-/**
- * Calls an input function `n` times, returning an array containing the results
- * of those function calls.
- *
- * `fn` is passed one argument: The current value of `n`, which begins at `0`
- * and is gradually incremented to `n - 1`.
- *
- * @param count - A value between `0` and `n - 1`. Increments after each
- * function call.
- * @param fn - The function to invoke. Passed one argument, the current value of
- * `n`.
- * @signature
- *   P.times(count, fn)
- * @example
- *   P.times(5, identity()); //=> [0, 1, 2, 3, 4]
- *
- * @dataFirst
- * @category Array
- */
-declare function times<T, N extends number>(count: N, fn: (index: number) => T): TimesArray<T, N>;
-/**
- * Calls an input function `n` times, returning an array containing the results
- * of those function calls.
- *
- * `fn` is passed one argument: The current value of `n`, which begins at `0`
- * and is gradually incremented to `n - 1`.
- *
- * @param fn - The function to invoke. Passed one argument, the current value of
- * `n`.
- * @returns An array containing the return values of all calls to `fn`.
- *
- * @signature
- *   P.times(count, fn)
- * @example
- *   P.times(identity())(5); //=> [0, 1, 2, 3, 4]
- *
- * @dataLast
- * @category Array
- */
-declare function times<T>(fn: (index: number) => T): <N extends number>(count: N) => TimesArray<T, N>;
-//#endregion
-export { times };
-//# sourceMappingURL=times.d.ts.map

package/dist/times.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"times.d.ts","names":[],"sources":["../src/times.ts"],"sourcesContent":[],"mappings":";;;KAOK,gBAAA;KAEA,kDAGe,8CACD,IAEf,MAAM,QACH,mCAGE,oDAED,WAAW,GAAG,GAAG,aACjB,YAAY,GAAG,qCAGT,WAAW,GAAG,kBAAkB,eAAe,MAAM,MACzD,UAAU,4BAIP,MAAM,WAAW,GAAG,gBAAgB;AA9BJ;AAOxB;;;;;;;;;;;;;;;;;;AAkB8C,iBA0BnD,KA1BmD,CAAA,CAAA,EAAA,UAAA,MAAA,CAAA,CAAA,KAAA,EA2B1D,CA3B0D,EAAA,EAAA,EAAA,CAAA,KAAA,EAAA,MAAA,EAAA,GA4B1C,CA5B0C,CAAA,EA6BhE,UA7BgE,CA6BrD,CA7BqD,EA6BlD,CA7BkD,CAAA;;;;;;;;;;AA0BnE;;;;;;;AAwBA;;;AAE8C,iBAF9B,KAE8B,CAAA,CAAA,CAAA,CAAA,EAAA,EAAA,CAAA,KAAA,EAAA,MAAA,EAAA,GADrB,CACqB,CAAA,EAAA,CAAA,UAAA,MAAA,CAAA,CAAA,KAAA,EAAjB,CAAiB,EAAA,GAAX,UAAW,CAAA,CAAA,EAAG,CAAH,CAAA"}

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

@@ -1,84 +0,0 @@
-import { t as OptionalOptionsWithDefaults } from "./optional-options-with-defaults-BZVW8GfC.cjs";
-import { CamelCase } from "type-fest";
-
-//#region src/to-camel-case.d.ts
-declare const DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE = true;
-interface CamelCaseOptions {
-  readonly preserveConsecutiveUppercase?: boolean;
-}
-type CamelCaseOptionsWithDefaults<Options extends CamelCaseOptions> = OptionalOptionsWithDefaults<CamelCaseOptions, Options, {
-  preserveConsecutiveUppercase: typeof DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE;
-}>;
-/**
- * Converts text to **camelCase** by splitting it into words, lowercasing the
- * first word, capitalizing the rest, then joining them back together.
- *
- * 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)_
- * too, making it best suited for simple strings like identifiers and internal
- * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)
- * with [`granularity: "word"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters),
- * [`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`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.
- *
- * For *PascalCase* use `capitalize(toCamelCase(data))`.
- *
- * @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
- *   P.toCamelCase(data);
- *   P.toCamelCase(data, { preserveConsecutiveUppercase });
- * @example
- *   P.toCamelCase("hello world"); // "helloWorld"
- *   P.toCamelCase("__HELLO_WORLD__"); // "helloWorld"
- *   P.toCamelCase("HasHTML"); // "hasHTML"
- *   P.toCamelCase("HasHTML", { preserveConsecutiveUppercase: false }); // "hasHtml"
- * @dataFirst
- * @category String
- */
-declare function toCamelCase<T extends string, Options extends CamelCaseOptions>(data: T, options?: Options): CamelCase<T, CamelCaseOptionsWithDefaults<Options>>;
-/**
- * Converts text to **camelCase** by splitting it into words, lowercasing the
- * first word, capitalizing the rest, then joining them back together.
- *
- * 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)_
- * too, making it best suited for simple strings like identifiers and internal
- * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)
- * with [`granularity: "word"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters),
- * [`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`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.
- *
- * For *PascalCase* use `capitalize(toCamelCase(data))`.
- *
- * @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
- *   P.toCamelCase()(data);
- *   P.toCamelCase({ preserveConsecutiveUppercase })(data);
- * @example
- *   P.pipe("hello world", P.toCamelCase()); // "helloWorld"
- *   P.pipe("__HELLO_WORLD__", P.toCamelCase()); // "helloWorld"
- *   P.pipe("HasHTML", P.toCamelCase()); // "hasHTML"
- *   P.pipe(
- *     "HasHTML",
- *     P.toCamelCase({ preserveConsecutiveUppercase: false }),
- *   ); // "hasHtml"
- * @dataLast
- * @category String
- */
-declare function toCamelCase<Options extends CamelCaseOptions>(options?: Options): <T extends string>(data: T) => CamelCase<T, CamelCaseOptionsWithDefaults<Options>>;
-//#endregion
-export { toCamelCase };
-//# sourceMappingURL=to-camel-case.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"to-camel-case.d.cts","names":[],"sources":["../src/to-camel-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;;;;;AAyCJ;;;;;;;;;AAwCA;;;;;;;;;;;;;;;;;;;;iBAxCgB,8CAA8C,wBACtD,aACI,UACT,UAAU,GAAG,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqC7B,4BAA4B,4BAChC,mCAEJ,MACH,UAAU,GAAG,6BAA6B"}

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

@@ -1,84 +0,0 @@
-import { t as OptionalOptionsWithDefaults } from "./optional-options-with-defaults-BFaBSKkF.js";
-import { CamelCase } from "type-fest";
-
-//#region src/to-camel-case.d.ts
-declare const DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE = true;
-interface CamelCaseOptions {
-  readonly preserveConsecutiveUppercase?: boolean;
-}
-type CamelCaseOptionsWithDefaults<Options extends CamelCaseOptions> = OptionalOptionsWithDefaults<CamelCaseOptions, Options, {
-  preserveConsecutiveUppercase: typeof DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE;
-}>;
-/**
- * Converts text to **camelCase** by splitting it into words, lowercasing the
- * first word, capitalizing the rest, then joining them back together.
- *
- * 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)_
- * too, making it best suited for simple strings like identifiers and internal
- * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)
- * with [`granularity: "word"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters),
- * [`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`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.
- *
- * For *PascalCase* use `capitalize(toCamelCase(data))`.
- *
- * @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
- *   P.toCamelCase(data);
- *   P.toCamelCase(data, { preserveConsecutiveUppercase });
- * @example
- *   P.toCamelCase("hello world"); // "helloWorld"
- *   P.toCamelCase("__HELLO_WORLD__"); // "helloWorld"
- *   P.toCamelCase("HasHTML"); // "hasHTML"
- *   P.toCamelCase("HasHTML", { preserveConsecutiveUppercase: false }); // "hasHtml"
- * @dataFirst
- * @category String
- */
-declare function toCamelCase<T extends string, Options extends CamelCaseOptions>(data: T, options?: Options): CamelCase<T, CamelCaseOptionsWithDefaults<Options>>;
-/**
- * Converts text to **camelCase** by splitting it into words, lowercasing the
- * first word, capitalizing the rest, then joining them back together.
- *
- * 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)_
- * too, making it best suited for simple strings like identifiers and internal
- * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)
- * with [`granularity: "word"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters),
- * [`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`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.
- *
- * For *PascalCase* use `capitalize(toCamelCase(data))`.
- *
- * @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
- *   P.toCamelCase()(data);
- *   P.toCamelCase({ preserveConsecutiveUppercase })(data);
- * @example
- *   P.pipe("hello world", P.toCamelCase()); // "helloWorld"
- *   P.pipe("__HELLO_WORLD__", P.toCamelCase()); // "helloWorld"
- *   P.pipe("HasHTML", P.toCamelCase()); // "hasHTML"
- *   P.pipe(
- *     "HasHTML",
- *     P.toCamelCase({ preserveConsecutiveUppercase: false }),
- *   ); // "hasHtml"
- * @dataLast
- * @category String
- */
-declare function toCamelCase<Options extends CamelCaseOptions>(options?: Options): <T extends string>(data: T) => CamelCase<T, CamelCaseOptionsWithDefaults<Options>>;
-//#endregion
-export { toCamelCase };
-//# sourceMappingURL=to-camel-case.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"to-camel-case.d.ts","names":[],"sources":["../src/to-camel-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;;;;;AAyCJ;;;;;;;;;AAwCA;;;;;;;;;;;;;;;;;;;;iBAxCgB,8CAA8C,wBACtD,aACI,UACT,UAAU,GAAG,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqC7B,4BAA4B,4BAChC,mCAEJ,MACH,UAAU,GAAG,6BAA6B"}

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

@@ -1,60 +0,0 @@
-import { Join, Words } from "type-fest";
-
-//#region src/to-kebab-case.d.ts
-type KebabCase<S extends string> = string extends S ? string : Lowercase<Join<Words<S>, '-'>>;
-/**
- * Converts text to **kebab-case** by splitting it into words and joining them
- * back together with hyphens (`-`), then lowercasing the result.
- *
- * Because it uses [`toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase),
- * the function shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_
- * too, making it best suited for simple strings like identifiers and internal
- * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)
- * with [`granularity: "word"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters), and
- * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),
- * which are purpose-built to handle nuances in languages and locales.
- *
- * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,
- * `uncapitalize`, `toCamelCase`, `toSnakeCase`, and `toTitleCase`.
- *
- * For *COBOL-CASE* use `toUpperCase(toKebabCase(data))`.
- *
- * @param data - A string.
- * @signature
- *   P.toKebabCase(data);
- * @example
- *   P.toKebabCase("hello world"); // "hello-world"
- *   P.toKebabCase("__HELLO_WORLD__"); // "hello-world"
- * @dataFirst
- * @category String
- */
-declare function toKebabCase<S extends string>(data: S): KebabCase<S>;
-/**
- * Converts text to **kebab-case** by splitting it into words and joining them
- * back together with hyphens (`-`), then lowercasing the result.
- *
- * Because it uses [`toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase),
- * the function shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_
- * too, making it best suited for simple strings like identifiers and internal
- * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)
- * with [`granularity: "word"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters), and
- * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),
- * which are purpose-built to handle nuances in languages and locales.
- *
- * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,
- * `uncapitalize`, `toCamelCase`, `toSnakeCase`, and `toTitleCase`.
- *
- * For *COBOL-CASE* use `toUpperCase(toKebabCase(data))`.
- *
- * @signature
- *   P.toKebabCase()(data);
- * @example
- *   P.pipe("hello world", P.toKebabCase()); // "hello-world"
- *   P.pipe("__HELLO_WORLD__", P.toKebabCase()); // "hello-world"
- * @dataLast
- * @category String
- */
-declare function toKebabCase(): <S extends string>(data: S) => KebabCase<S>;
-//#endregion
-export { toKebabCase };
-//# sourceMappingURL=to-kebab-case.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"to-kebab-case.d.cts","names":[],"sources":["../src/to-kebab-case.ts"],"sourcesContent":[],"mappings":";;;KAIK,6CAA6C,aAE9C,UAAU,KAAK,MAAM;;AANoB;;;;;;;AAkC7C;;;;;AA2BA;;;;;;;;;;;;;iBA3BgB,oCAAoC,IAAI,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2BlD,WAAA,CAAA,4BAAwC,MAAM,UAAU"}

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

@@ -1,60 +0,0 @@
-import { Join, Words } from "type-fest";
-
-//#region src/to-kebab-case.d.ts
-type KebabCase<S extends string> = string extends S ? string : Lowercase<Join<Words<S>, '-'>>;
-/**
- * Converts text to **kebab-case** by splitting it into words and joining them
- * back together with hyphens (`-`), then lowercasing the result.
- *
- * Because it uses [`toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase),
- * the function shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_
- * too, making it best suited for simple strings like identifiers and internal
- * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)
- * with [`granularity: "word"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters), and
- * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),
- * which are purpose-built to handle nuances in languages and locales.
- *
- * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,
- * `uncapitalize`, `toCamelCase`, `toSnakeCase`, and `toTitleCase`.
- *
- * For *COBOL-CASE* use `toUpperCase(toKebabCase(data))`.
- *
- * @param data - A string.
- * @signature
- *   P.toKebabCase(data);
- * @example
- *   P.toKebabCase("hello world"); // "hello-world"
- *   P.toKebabCase("__HELLO_WORLD__"); // "hello-world"
- * @dataFirst
- * @category String
- */
-declare function toKebabCase<S extends string>(data: S): KebabCase<S>;
-/**
- * Converts text to **kebab-case** by splitting it into words and joining them
- * back together with hyphens (`-`), then lowercasing the result.
- *
- * Because it uses [`toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase),
- * the function shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_
- * too, making it best suited for simple strings like identifiers and internal
- * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)
- * with [`granularity: "word"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters), and
- * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),
- * which are purpose-built to handle nuances in languages and locales.
- *
- * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,
- * `uncapitalize`, `toCamelCase`, `toSnakeCase`, and `toTitleCase`.
- *
- * For *COBOL-CASE* use `toUpperCase(toKebabCase(data))`.
- *
- * @signature
- *   P.toKebabCase()(data);
- * @example
- *   P.pipe("hello world", P.toKebabCase()); // "hello-world"
- *   P.pipe("__HELLO_WORLD__", P.toKebabCase()); // "hello-world"
- * @dataLast
- * @category String
- */
-declare function toKebabCase(): <S extends string>(data: S) => KebabCase<S>;
-//#endregion
-export { toKebabCase };
-//# sourceMappingURL=to-kebab-case.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"to-kebab-case.d.ts","names":[],"sources":["../src/to-kebab-case.ts"],"sourcesContent":[],"mappings":";;;KAIK,6CAA6C,aAE9C,UAAU,KAAK,MAAM;;AANoB;;;;;;;AAkC7C;;;;;AA2BA;;;;;;;;;;;;;iBA3BgB,oCAAoC,IAAI,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2BlD,WAAA,CAAA,4BAAwC,MAAM,UAAU"}

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/to-single-Chq_hKEk.cjs

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

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

@@ -1,60 +0,0 @@
-import { Join, Words } from "type-fest";
-
-//#region src/to-snake-case.d.ts
-type SnakeCase<S extends string> = string extends S ? string : Lowercase<Join<Words<S>, '_'>>;
-/**
- * Converts text to **snake_case** by splitting it into words and joining them
- * back together with underscores (`_`), then lowercasing the result.
- *
- * Because it uses [`toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase),
- * the function shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_
- * too, making it best suited for simple strings like identifiers and internal
- * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)
- * with [`granularity: "word"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters), and
- * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),
- * which are purpose-built to handle nuances in languages and locales.
- *
- * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,
- * `uncapitalize`, `toCamelCase`, `toKebabCase`, and `toTitleCase`.
- *
- * For *CONSTANT_CASE* use `toUpperCase(toSnakeCase(data))`.
- *
- * @param data - A string.
- * @signature
- *   P.toSnakeCase(data);
- * @example
- *   P.toSnakeCase("hello world"); // "hello_world"
- *   P.toSnakeCase("__HELLO_WORLD__"); // "hello_world"
- * @dataFirst
- * @category String
- */
-declare function toSnakeCase<S extends string>(data: S): SnakeCase<S>;
-/**
- * Converts text to **snake_case** by splitting it into words and joining them
- * back together with underscores (`_`), then lowercasing the result.
- *
- * Because it uses [`toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase),
- * the function shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_
- * too, making it best suited for simple strings like identifiers and internal
- * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)
- * with [`granularity: "word"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters), and
- * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),
- * which are purpose-built to handle nuances in languages and locales.
- *
- * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,
- * `uncapitalize`, `toCamelCase`, `toKebabCase`, and `toTitleCase`.
- *
- * For *CONSTANT_CASE* use `toUpperCase(toSnakeCase(data))`.
- *
- * @signature
- *   P.toSnakeCase()(data);
- * @example
- *   P.pipe("hello world", P.toSnakeCase()); // "hello_world"
- *   P.pipe("__HELLO_WORLD__", P.toSnakeCase()); // "hello_world"
- * @dataLast
- * @category String
- */
-declare function toSnakeCase(): <S extends string>(data: S) => SnakeCase<S>;
-//#endregion
-export { toSnakeCase };
-//# sourceMappingURL=to-snake-case.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"to-snake-case.d.cts","names":[],"sources":["../src/to-snake-case.ts"],"sourcesContent":[],"mappings":";;;KAIK,6CAA6C,aAE9C,UAAU,KAAK,MAAM;;AANoB;;;;;;;AAkC7C;;;;;AA2BA;;;;;;;;;;;;;iBA3BgB,oCAAoC,IAAI,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2BlD,WAAA,CAAA,4BAAwC,MAAM,UAAU"}

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

@@ -1,60 +0,0 @@
-import { Join, Words } from "type-fest";
-
-//#region src/to-snake-case.d.ts
-type SnakeCase<S extends string> = string extends S ? string : Lowercase<Join<Words<S>, '_'>>;
-/**
- * Converts text to **snake_case** by splitting it into words and joining them
- * back together with underscores (`_`), then lowercasing the result.
- *
- * Because it uses [`toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase),
- * the function shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_
- * too, making it best suited for simple strings like identifiers and internal
- * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)
- * with [`granularity: "word"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters), and
- * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),
- * which are purpose-built to handle nuances in languages and locales.
- *
- * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,
- * `uncapitalize`, `toCamelCase`, `toKebabCase`, and `toTitleCase`.
- *
- * For *CONSTANT_CASE* use `toUpperCase(toSnakeCase(data))`.
- *
- * @param data - A string.
- * @signature
- *   P.toSnakeCase(data);
- * @example
- *   P.toSnakeCase("hello world"); // "hello_world"
- *   P.toSnakeCase("__HELLO_WORLD__"); // "hello_world"
- * @dataFirst
- * @category String
- */
-declare function toSnakeCase<S extends string>(data: S): SnakeCase<S>;
-/**
- * Converts text to **snake_case** by splitting it into words and joining them
- * back together with underscores (`_`), then lowercasing the result.
- *
- * Because it uses [`toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase),
- * the function shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_
- * too, making it best suited for simple strings like identifiers and internal
- * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)
- * with [`granularity: "word"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters), and
- * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),
- * which are purpose-built to handle nuances in languages and locales.
- *
- * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,
- * `uncapitalize`, `toCamelCase`, `toKebabCase`, and `toTitleCase`.
- *
- * For *CONSTANT_CASE* use `toUpperCase(toSnakeCase(data))`.
- *
- * @signature
- *   P.toSnakeCase()(data);
- * @example
- *   P.pipe("hello world", P.toSnakeCase()); // "hello_world"
- *   P.pipe("__HELLO_WORLD__", P.toSnakeCase()); // "hello_world"
- * @dataLast
- * @category String
- */
-declare function toSnakeCase(): <S extends string>(data: S) => SnakeCase<S>;
-//#endregion
-export { toSnakeCase };
-//# sourceMappingURL=to-snake-case.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"to-snake-case.d.ts","names":[],"sources":["../src/to-snake-case.ts"],"sourcesContent":[],"mappings":";;;KAIK,6CAA6C,aAE9C,UAAU,KAAK,MAAM;;AANoB;;;;;;;AAkC7C;;;;;AA2BA;;;;;;;;;;;;;iBA3BgB,oCAAoC,IAAI,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2BlD,WAAA,CAAA,4BAAwC,MAAM,UAAU"}

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

@@ -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-DkC3zRUJ.d.cts.map

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

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