@vinicunca/perkakas 0.5.4 → 1.0.1

package/dist/take-first-by.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkBVOCXV26cjs = require('./chunk-BVOCXV26.cjs');require('./chunk-BWJDD26T.cjs');require('./chunk-5KO77UXQ.cjs');require('./chunk-FWQYL4Y4.cjs');require('./chunk-G66EZBJS.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.takeFirstBy = _chunkBVOCXV26cjs.a;

package/dist/take-first-by.d.cts

@@ -0,0 +1,39 @@
+import { N as NonEmptyArray } from './types-BMu1PIvo.cjs';
+import { O as OrderRule } from './curry-order-rules-BOMf1JS7.cjs';
+import 'type-fest';
+
+/**
+ * Take the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before taking the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.
+ *
+ * For the opposite operation (to drop `n` elements) see `dropFirstBy`.
+ *
+ * @param data - The input array.
+ * @param n - The number of items to take. If `n` is non-positive no items would be returned, if `n` is bigger then data.length a *clone* of `data` would be returned.
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns A subset of the input array.
+ * @signature
+ *   P.takeFirstBy(data, n, ...rules);
+ * @example
+ *   P.takeFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['a', 'aa']
+ * @dataFirst
+ * @category Array
+ */
+declare function takeFirstBy<T>(data: ReadonlyArray<T>, n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): Array<T>;
+/**
+ * Take the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before taking the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.
+ *
+ * For the opposite operation (to drop `n` elements) see `dropFirstBy`.
+ *
+ * @param n - The number of items to take. If `n` is non-positive no items would be returned, if `n` is bigger then data.length a *clone* of `data` would be returned.
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns A subset of the input array.
+ * @signature
+ *   P.takeFirstBy(n, ...rules)(data);
+ * @example
+ *   P.pipe(['aa', 'aaaa', 'a', 'aaa'], P.takeFirstBy(2, x => x.length)); // => ['a', 'aa']
+ * @dataLast
+ * @category Array
+ */
+declare function takeFirstBy<T>(n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): (data: ReadonlyArray<T>) => Array<T>;
+
+export { takeFirstBy };

package/dist/take-first-by.d.ts

@@ -0,0 +1,39 @@
+import { N as NonEmptyArray } from './types-BMu1PIvo.js';
+import { O as OrderRule } from './curry-order-rules-BOMf1JS7.js';
+import 'type-fest';
+
+/**
+ * Take the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before taking the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.
+ *
+ * For the opposite operation (to drop `n` elements) see `dropFirstBy`.
+ *
+ * @param data - The input array.
+ * @param n - The number of items to take. If `n` is non-positive no items would be returned, if `n` is bigger then data.length a *clone* of `data` would be returned.
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns A subset of the input array.
+ * @signature
+ *   P.takeFirstBy(data, n, ...rules);
+ * @example
+ *   P.takeFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['a', 'aa']
+ * @dataFirst
+ * @category Array
+ */
+declare function takeFirstBy<T>(data: ReadonlyArray<T>, n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): Array<T>;
+/**
+ * Take the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before taking the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.
+ *
+ * For the opposite operation (to drop `n` elements) see `dropFirstBy`.
+ *
+ * @param n - The number of items to take. If `n` is non-positive no items would be returned, if `n` is bigger then data.length a *clone* of `data` would be returned.
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns A subset of the input array.
+ * @signature
+ *   P.takeFirstBy(n, ...rules)(data);
+ * @example
+ *   P.pipe(['aa', 'aaaa', 'a', 'aaa'], P.takeFirstBy(2, x => x.length)); // => ['a', 'aa']
+ * @dataLast
+ * @category Array
+ */
+declare function takeFirstBy<T>(n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): (data: ReadonlyArray<T>) => Array<T>;
+
+export { takeFirstBy };

package/dist/take-first-by.js

@@ -0,0 +1 @@
+import{a}from"./chunk-KJ42LLSJ.js";import"./chunk-JU4UCCME.js";import"./chunk-UYH64IBH.js";import"./chunk-JXXXUJM5.js";import"./chunk-73BYESBE.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as takeFirstBy};

package/dist/take-last-while.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunk3UUZWCRScjs = require('./chunk-3UUZWCRS.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.takeLastWhile = _chunk3UUZWCRScjs.a;

package/dist/take-last-while.d.cts

@@ -0,0 +1,29 @@
+/**
+ * Returns elements from the end of the array until the predicate returns false.
+ * The returned elements will be in the same order as in the original array.
+ *
+ * @param data - The array.
+ * @param predicate - The predicate.
+ * @signature
+ *    P.takeLastWhile(data, predicate)
+ * @example
+ *    P.takeLastWhile([1, 2, 10, 3, 4, 5], x => x < 10) // => [3, 4, 5]
+ * @dataFirst
+ * @category Array
+ */
+declare function takeLastWhile<T>(data: ReadonlyArray<T>, predicate: (item: T, index: number, data: ReadonlyArray<T>) => boolean): Array<T>;
+/**
+ * Returns elements from the end of the array until the predicate returns false.
+ * The returned elements will be in the same order as in the original array.
+ *
+ * @param predicate - The predicate.
+ * @signature
+ *    P.takeLastWhile(predicate)(data)
+ * @example
+ *    P.pipe([1, 2, 10, 3, 4, 5], P.takeLastWhile(x => x < 10))  // => [3, 4, 5]
+ * @dataLast
+ * @category Array
+ */
+declare function takeLastWhile<T>(predicate: (item: T, index: number, data: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => Array<T>;
+
+export { takeLastWhile };

package/dist/take-last-while.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Returns elements from the end of the array until the predicate returns false.
+ * The returned elements will be in the same order as in the original array.
+ *
+ * @param data - The array.
+ * @param predicate - The predicate.
+ * @signature
+ *    P.takeLastWhile(data, predicate)
+ * @example
+ *    P.takeLastWhile([1, 2, 10, 3, 4, 5], x => x < 10) // => [3, 4, 5]
+ * @dataFirst
+ * @category Array
+ */
+declare function takeLastWhile<T>(data: ReadonlyArray<T>, predicate: (item: T, index: number, data: ReadonlyArray<T>) => boolean): Array<T>;
+/**
+ * Returns elements from the end of the array until the predicate returns false.
+ * The returned elements will be in the same order as in the original array.
+ *
+ * @param predicate - The predicate.
+ * @signature
+ *    P.takeLastWhile(predicate)(data)
+ * @example
+ *    P.pipe([1, 2, 10, 3, 4, 5], P.takeLastWhile(x => x < 10))  // => [3, 4, 5]
+ * @dataLast
+ * @category Array
+ */
+declare function takeLastWhile<T>(predicate: (item: T, index: number, data: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => Array<T>;
+
+export { takeLastWhile };

package/dist/take-last-while.js

@@ -0,0 +1 @@
+import{a}from"./chunk-COBRSP66.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as takeLastWhile};

package/dist/take-last.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkRSJJRJTHcjs = require('./chunk-RSJJRJTH.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.takeLast = _chunkRSJJRJTHcjs.a;

package/dist/take-last.d.cts

@@ -0,0 +1,27 @@
+/**
+ * Takes the last `n` elements from the `array`.
+ *
+ * @param array - The target array.
+ * @param n - The number of elements to take.
+ * @signature
+ *    P.takeLast(array, n)
+ * @example
+ *    P.takeLast([1, 2, 3, 4, 5], 2) // => [4, 5]
+ * @dataFirst
+ * @category Array
+ */
+declare function takeLast<T>(array: ReadonlyArray<T>, n: number): Array<T>;
+/**
+ * Take the last `n` elements from the `array`.
+ *
+ * @param n - The number of elements to take.
+ * @signature
+ *    P.takeLast(n)(array)
+ * @example
+ *    P.takeLast(2)([1, 2, 3, 4, 5]) // => [4, 5]
+ * @dataLast
+ * @category Array
+ */
+declare function takeLast<T>(n: number): (array: ReadonlyArray<T>) => Array<T>;
+
+export { takeLast };

package/dist/take-last.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Takes the last `n` elements from the `array`.
+ *
+ * @param array - The target array.
+ * @param n - The number of elements to take.
+ * @signature
+ *    P.takeLast(array, n)
+ * @example
+ *    P.takeLast([1, 2, 3, 4, 5], 2) // => [4, 5]
+ * @dataFirst
+ * @category Array
+ */
+declare function takeLast<T>(array: ReadonlyArray<T>, n: number): Array<T>;
+/**
+ * Take the last `n` elements from the `array`.
+ *
+ * @param n - The number of elements to take.
+ * @signature
+ *    P.takeLast(n)(array)
+ * @example
+ *    P.takeLast(2)([1, 2, 3, 4, 5]) // => [4, 5]
+ * @dataLast
+ * @category Array
+ */
+declare function takeLast<T>(n: number): (array: ReadonlyArray<T>) => Array<T>;
+
+export { takeLast };

package/dist/take-last.js

@@ -0,0 +1 @@
+import{a}from"./chunk-CIF6WEFP.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as takeLast};

package/dist/take-while.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkAE5HI6VGcjs = require('./chunk-AE5HI6VG.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.takeWhile = _chunkAE5HI6VGcjs.a;

package/dist/take-while.d.cts

@@ -0,0 +1,27 @@
+/**
+ * Returns elements from the array until predicate returns false.
+ *
+ * @param data - The array.
+ * @param predicate - The predicate.
+ * @signature
+ *    P.takeWhile(data, predicate)
+ * @example
+ *    P.takeWhile([1, 2, 3, 4, 3, 2, 1], x => x !== 4) // => [1, 2, 3]
+ * @dataFirst
+ * @category Array
+ */
+declare function takeWhile<T>(data: ReadonlyArray<T>, predicate: (item: T, index: number, data: ReadonlyArray<T>) => boolean): Array<T>;
+/**
+ * Returns elements from the array until predicate returns false.
+ *
+ * @param predicate - The predicate.
+ * @signature
+ *    P.takeWhile(predicate)(data)
+ * @example
+ *    P.pipe([1, 2, 3, 4, 3, 2, 1], P.takeWhile(x => x !== 4))  // => [1, 2, 3]
+ * @dataLast
+ * @category Array
+ */
+declare function takeWhile<T>(predicate: (item: T, index: number, data: ReadonlyArray<T>) => boolean): (array: ReadonlyArray<T>) => Array<T>;
+
+export { takeWhile };

package/dist/take-while.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Returns elements from the array until predicate returns false.
+ *
+ * @param data - The array.
+ * @param predicate - The predicate.
+ * @signature
+ *    P.takeWhile(data, predicate)
+ * @example
+ *    P.takeWhile([1, 2, 3, 4, 3, 2, 1], x => x !== 4) // => [1, 2, 3]
+ * @dataFirst
+ * @category Array
+ */
+declare function takeWhile<T>(data: ReadonlyArray<T>, predicate: (item: T, index: number, data: ReadonlyArray<T>) => boolean): Array<T>;
+/**
+ * Returns elements from the array until predicate returns false.
+ *
+ * @param predicate - The predicate.
+ * @signature
+ *    P.takeWhile(predicate)(data)
+ * @example
+ *    P.pipe([1, 2, 3, 4, 3, 2, 1], P.takeWhile(x => x !== 4))  // => [1, 2, 3]
+ * @dataLast
+ * @category Array
+ */
+declare function takeWhile<T>(predicate: (item: T, index: number, data: ReadonlyArray<T>) => boolean): (array: ReadonlyArray<T>) => Array<T>;
+
+export { takeWhile };

package/dist/take-while.js

@@ -0,0 +1 @@
+import{a}from"./chunk-LOPUNSWJ.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as takeWhile};

package/dist/take.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkX6AB3I7Zcjs = require('./chunk-X6AB3I7Z.cjs');require('./chunk-3X6SAJDQ.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.take = _chunkX6AB3I7Zcjs.a;

package/dist/take.d.cts

@@ -0,0 +1,29 @@
+/**
+ * Returns the first `n` elements of `array`.
+ *
+ * @param array - The array.
+ * @param n - The number of elements to take.
+ * @signature
+ *    P.take(array, n)
+ * @example
+ *    P.take([1, 2, 3, 4, 3, 2, 1], 3) // => [1, 2, 3]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function take<T>(array: ReadonlyArray<T>, n: number): Array<T>;
+/**
+ * Returns the first `n` elements of `array`.
+ *
+ * @param n - The number of elements to take.
+ * @signature
+ *    P.take(n)(array)
+ * @example
+ *    P.pipe([1, 2, 3, 4, 3, 2, 1], P.take(n)) // => [1, 2, 3]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function take<T>(n: number): (array: ReadonlyArray<T>) => Array<T>;
+
+export { take };

package/dist/take.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Returns the first `n` elements of `array`.
+ *
+ * @param array - The array.
+ * @param n - The number of elements to take.
+ * @signature
+ *    P.take(array, n)
+ * @example
+ *    P.take([1, 2, 3, 4, 3, 2, 1], 3) // => [1, 2, 3]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function take<T>(array: ReadonlyArray<T>, n: number): Array<T>;
+/**
+ * Returns the first `n` elements of `array`.
+ *
+ * @param n - The number of elements to take.
+ * @signature
+ *    P.take(n)(array)
+ * @example
+ *    P.pipe([1, 2, 3, 4, 3, 2, 1], P.take(n)) // => [1, 2, 3]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function take<T>(n: number): (array: ReadonlyArray<T>) => Array<T>;
+
+export { take };

package/dist/take.js

@@ -0,0 +1 @@
+import{a}from"./chunk-LIKMH7XD.js";import"./chunk-MYLYERXO.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as take};

package/dist/tap.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkYWO7TFODcjs = require('./chunk-YWO7TFOD.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.tap = _chunkYWO7TFODcjs.a;

package/dist/tap.d.cts

@@ -0,0 +1,40 @@
+/**
+ * Calls the given function with the given value, then returns the given value.
+ * The return value of the provided function is ignored.
+ *
+ * This allows "tapping into" a function sequence in a pipe, to perform side
+ * effects on intermediate results.
+ *
+ * @param value - The value to pass into the function.
+ * @param fn - The function to call.
+ * @signature
+ *    P.tap(value, fn)
+ * @example
+ *    P.tap("foo", console.log) // => "foo"
+ * @dataFirst
+ * @category Other
+ */
+declare function tap<T>(value: T, fn: (value: T) => void): T;
+/**
+ * Calls the given function with the given value, then returns the given value.
+ * The return value of the provided function is ignored.
+ *
+ * This allows "tapping into" a function sequence in a pipe, to perform side
+ * effects on intermediate results.
+ *
+ * @param fn - The function to call.
+ * @signature
+ *    P.tap(fn)(value)
+ * @example
+ *    P.pipe(
+ *      [-5, -1, 2, 3],
+ *      P.filter(n => n > 0),
+ *      P.tap(console.log), // prints [2, 3]
+ *      P.map(n => n * 2)
+ *    ) // => [4, 6]
+ * @dataLast
+ * @category Other
+ */
+declare function tap<T, F extends (value: T) => unknown>(fn: F): (value: T) => T;
+
+export { tap };

package/dist/tap.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Calls the given function with the given value, then returns the given value.
+ * The return value of the provided function is ignored.
+ *
+ * This allows "tapping into" a function sequence in a pipe, to perform side
+ * effects on intermediate results.
+ *
+ * @param value - The value to pass into the function.
+ * @param fn - The function to call.
+ * @signature
+ *    P.tap(value, fn)
+ * @example
+ *    P.tap("foo", console.log) // => "foo"
+ * @dataFirst
+ * @category Other
+ */
+declare function tap<T>(value: T, fn: (value: T) => void): T;
+/**
+ * Calls the given function with the given value, then returns the given value.
+ * The return value of the provided function is ignored.
+ *
+ * This allows "tapping into" a function sequence in a pipe, to perform side
+ * effects on intermediate results.
+ *
+ * @param fn - The function to call.
+ * @signature
+ *    P.tap(fn)(value)
+ * @example
+ *    P.pipe(
+ *      [-5, -1, 2, 3],
+ *      P.filter(n => n > 0),
+ *      P.tap(console.log), // prints [2, 3]
+ *      P.map(n => n * 2)
+ *    ) // => [4, 6]
+ * @dataLast
+ * @category Other
+ */
+declare function tap<T, F extends (value: T) => unknown>(fn: F): (value: T) => T;
+
+export { tap };

package/dist/tap.js

@@ -0,0 +1 @@
+import{a}from"./chunk-ENIRKKU6.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as tap};

package/dist/times.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkUH3TDC4Tcjs = require('./chunk-UH3TDC4T.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.times = _chunkUH3TDC4Tcjs.a;

package/dist/times.d.cts

@@ -0,0 +1,36 @@
+/**
+ * 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
+ */
+declare function times<T>(count: number, fn: (n: number) => T): Array<T>;
+/**
+ * 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`.
+ *
+ * @signature
+ *   P.times(count, fn)
+ * @example
+ *   P.times(identity())(5); //=> [0, 1, 2, 3, 4]
+ *
+ * @dataLast
+ */
+declare function times<T>(fn: (n: number) => T): (count: number) => Array<T>;
+
+export { times };

package/dist/times.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 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
+ */
+declare function times<T>(count: number, fn: (n: number) => T): Array<T>;
+/**
+ * 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`.
+ *
+ * @signature
+ *   P.times(count, fn)
+ * @example
+ *   P.times(identity())(5); //=> [0, 1, 2, 3, 4]
+ *
+ * @dataLast
+ */
+declare function times<T>(fn: (n: number) => T): (count: number) => Array<T>;
+
+export { times };

package/dist/times.js

@@ -0,0 +1 @@
+import{a}from"./chunk-4XRKXTOK.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as times};

package/dist/to-camel-case.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkHJO63NJCcjs = require('./chunk-HJO63NJC.cjs');require('./chunk-WPGWO7LA.cjs');exports.toCamelCase = _chunkHJO63NJCcjs.a;

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

@@ -0,0 +1,29 @@
+import { C as ChangeCaseOptions } from './case.types-C6kHRY4f.cjs';
+
+/**
+ * Convert a string to camel case.
+ *
+ * @param input the string to convert
+ * @param options - Optional configuration for the conversion.
+ * @param options.delimiter - The delimiter to use between words.
+ * @param options.separateNumbers - If true, an underscore will be injected before the numbers.
+ * @param options.prefixCharacters - The prefix characters that we want to ignore.
+ * @param options.suffixCharacters - The suffix characters that we want to ignore.
+ * @param options.splitFn - A custom split function to separated the words.
+ * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ *
+ * @signature
+ *   toCamelCase(str)
+ * @example
+ *   toCamelCase('test'); // => 'test'
+ *   toCamelCase('test string'); // => 'testSTring'
+ *   toCamelCase('test string', { delimiter: '$' }); // => 'test$string'
+ *   toCamelCase('TestV2', { separateNumbers: true }); // => 'testV_2'
+ *   toCamelCase('__typename', { prefixCharacters: '_' }); // => '__typename'
+ *   toCamelCase('type__', { suffixCharacters: '_' }); // => 'type__'
+ *   toCamelCase('version 1.2.10', { mergeAmbiguousCharacters: true }); // => 'version1210'
+ * @category String
+ */
+declare function toCamelCase(input: string, options?: ChangeCaseOptions): string;
+
+export { toCamelCase };

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

@@ -0,0 +1,29 @@
+import { C as ChangeCaseOptions } from './case.types-C6kHRY4f.js';
+
+/**
+ * Convert a string to camel case.
+ *
+ * @param input the string to convert
+ * @param options - Optional configuration for the conversion.
+ * @param options.delimiter - The delimiter to use between words.
+ * @param options.separateNumbers - If true, an underscore will be injected before the numbers.
+ * @param options.prefixCharacters - The prefix characters that we want to ignore.
+ * @param options.suffixCharacters - The suffix characters that we want to ignore.
+ * @param options.splitFn - A custom split function to separated the words.
+ * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ *
+ * @signature
+ *   toCamelCase(str)
+ * @example
+ *   toCamelCase('test'); // => 'test'
+ *   toCamelCase('test string'); // => 'testSTring'
+ *   toCamelCase('test string', { delimiter: '$' }); // => 'test$string'
+ *   toCamelCase('TestV2', { separateNumbers: true }); // => 'testV_2'
+ *   toCamelCase('__typename', { prefixCharacters: '_' }); // => '__typename'
+ *   toCamelCase('type__', { suffixCharacters: '_' }); // => 'type__'
+ *   toCamelCase('version 1.2.10', { mergeAmbiguousCharacters: true }); // => 'version1210'
+ * @category String
+ */
+declare function toCamelCase(input: string, options?: ChangeCaseOptions): string;
+
+export { toCamelCase };

package/dist/to-camel-case.js

@@ -0,0 +1 @@
+import{a}from"./chunk-KDSNKESQ.js";import"./chunk-YD2H56BT.js";export{a as toCamelCase};

package/dist/to-capital-case.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkMQGR4WQQcjs = require('./chunk-MQGR4WQQ.cjs');require('./chunk-WPGWO7LA.cjs');exports.toCapitalCase = _chunkMQGR4WQQcjs.a;

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

@@ -0,0 +1,28 @@
+import { C as ChangeCaseOptions } from './case.types-C6kHRY4f.cjs';
+
+/**
+ * Convert a string to capital case.
+ *
+ * @param input the string to convert
+ * @param options - Optional configuration for the conversion.
+ * @param options.delimiter - The delimiter to use between words.
+ * @param options.separateNumbers - If true, numbers will be separated.
+ * @param options.prefixCharacters - The prefix characters that we want to ignore.
+ * @param options.suffixCharacters - The suffix characters that we want to ignore.
+ * @param options.splitFn - A custom split function to separated the words.
+ * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ *
+ * @signature
+ *   toCapitalCase(str)
+ * @example
+ *   toCapitalCase('test'); // => 'Test'
+ *   toCapitalCase('test string'); // => 'Test String'
+ *   toCapitalCase('test string', { delimiter: '$' }); // => 'Test$String'
+ *   toCapitalCase('testV2', { separateNumbers: true }); // => 'TEST V 2'
+ *   toCapitalCase('__typename', { prefixCharacters: '_' }); // => '__Typename'
+ *   toCapitalCase('type__', { suffixCharacters: '_' }); // => 'Type__'
+ * @category String
+ */
+declare function toCapitalCase(input: string, options?: ChangeCaseOptions): string;
+
+export { toCapitalCase };

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

@@ -0,0 +1,28 @@
+import { C as ChangeCaseOptions } from './case.types-C6kHRY4f.js';
+
+/**
+ * Convert a string to capital case.
+ *
+ * @param input the string to convert
+ * @param options - Optional configuration for the conversion.
+ * @param options.delimiter - The delimiter to use between words.
+ * @param options.separateNumbers - If true, numbers will be separated.
+ * @param options.prefixCharacters - The prefix characters that we want to ignore.
+ * @param options.suffixCharacters - The suffix characters that we want to ignore.
+ * @param options.splitFn - A custom split function to separated the words.
+ * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ *
+ * @signature
+ *   toCapitalCase(str)
+ * @example
+ *   toCapitalCase('test'); // => 'Test'
+ *   toCapitalCase('test string'); // => 'Test String'
+ *   toCapitalCase('test string', { delimiter: '$' }); // => 'Test$String'
+ *   toCapitalCase('testV2', { separateNumbers: true }); // => 'TEST V 2'
+ *   toCapitalCase('__typename', { prefixCharacters: '_' }); // => '__Typename'
+ *   toCapitalCase('type__', { suffixCharacters: '_' }); // => 'Type__'
+ * @category String
+ */
+declare function toCapitalCase(input: string, options?: ChangeCaseOptions): string;
+
+export { toCapitalCase };

package/dist/to-capital-case.js

@@ -0,0 +1 @@
+import{a}from"./chunk-R5K7KY5K.js";import"./chunk-YD2H56BT.js";export{a as toCapitalCase};