@vinicunca/perkakas 1.8.0 → 1.12.0

package/dist/take-while.d.ts

@@ -1,3 +1,34 @@
-import "./iterable-container-wtkYslN_.js";
-import { takeWhile } from "./take-while-e4aa4Rzo.js";
-export { takeWhile };
+import { t as IterableContainer } from "./iterable-container-BdjPuIjL.js";
+
+//#region src/take-while.d.ts
+
+/**
+ * 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 extends IterableContainer, S extends T[number]>(data: T, predicate: (item: T[number], index: number, data: T) => item is S): Array<S>;
+declare function takeWhile<T extends IterableContainer>(data: T, predicate: (item: T[number], index: number, data: T) => boolean): Array<T[number]>;
+/**
+ * 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 extends IterableContainer, S extends T[number]>(predicate: (item: T[number], index: number, data: T) => item is S): (array: T) => Array<S>;
+declare function takeWhile<T extends IterableContainer>(predicate: (item: T[number], index: number, data: T) => boolean): (array: T) => Array<T[number]>;
+//#endregion
+export { takeWhile };
+//# sourceMappingURL=take-while.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"take-while.d.ts","names":[],"sources":["../src/take-while.ts"],"sourcesContent":[],"mappings":";;;;;;AAgBA;;;;;;;;;;AAIgB,iBAJA,SAIS,CAAA,UAJW,iBAIX,EAAA,UAJwC,CAIxC,CAAA,MAAA,CAAA,CAAA,CAAA,IAAA,EAHjB,CAGiB,EAAA,SAAA,EAAA,CAAA,IAAA,EAFL,CAEK,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAF2B,CAE3B,EAAA,GAAA,IAAA,IAFyC,CAEzC,CAAA,EADtB,KACsB,CADhB,CACgB,CAAA;AAAW,iBAApB,SAAoB,CAAA,UAAA,iBAAA,CAAA,CAAA,IAAA,EAC5B,CAD4B,EAAA,SAAA,EAAA,CAAA,IAAA,EAEhB,CAFgB,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAEgB,CAFhB,EAAA,GAAA,OAAA,CAAA,EAGjC,KAHiC,CAG3B,CAH2B,CAAA,MAAA,CAAA,CAAA;;;;;;;AAgBpC;;;;;AACkE,iBADlD,SACkD,CAAA,UAD9B,iBAC8B,EAAA,UADD,CACC,CAAA,MAAA,CAAA,CAAA,CAAA,SAAA,EAAA,CAAA,IAAA,EAA9C,CAA8C,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAAd,CAAc,EAAA,GAAA,IAAA,IAAA,CAAA,CAAA,EAAA,CAAA,KAAA,EACvD,CADuD,EAAA,GACjD,KADiD,CAC3C,CAD2C,CAAA;AACvD,iBACK,SADL,CAAA,UACyB,iBADzB,CAAA,CAAA,SAAA,EAAA,CAAA,IAAA,EAES,CAFT,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAEyC,CAFzC,EAAA,GAAA,OAAA,CAAA,EAAA,CAAA,KAAA,EAGA,CAHA,EAAA,GAGM,KAHN,CAGY,CAHZ,CAAA,MAAA,CAAA,CAAA"}

package/dist/take-while.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{takeWhile as e}from"./take-while-D7M5vbwg.js";export{e as takeWhile};
+import{t as e}from"./curry-BcQ8Up1_.js";function t(...t){return e(n,t)}function n(e,t){let n=[];for(let[r,i]of e.entries()){if(!t(i,r,e))break;n.push(i)}return n}export{t as takeWhile};
+//# sourceMappingURL=take-while.js.map

package/dist/take-while.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"take-while.js","names":["ret: Array<T[number]>"],"sources":["../src/take-while.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\n\nimport { curry } from './curry';\n\n/**\n * Returns elements from the array until predicate returns false.\n *\n * @param data - The array.\n * @param predicate - The predicate.\n * @signature\n *    P.takeWhile(data, predicate)\n * @example\n *    P.takeWhile([1, 2, 3, 4, 3, 2, 1], x => x !== 4) // => [1, 2, 3]\n * @dataFirst\n * @category Array\n */\nexport function takeWhile<T extends IterableContainer, S extends T[number]>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => item is S,\n): Array<S>;\nexport function takeWhile<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): Array<T[number]>;\n\n/**\n * Returns elements from the array until predicate returns false.\n *\n * @param predicate - The predicate.\n * @signature\n *    P.takeWhile(predicate)(data)\n * @example\n *    P.pipe([1, 2, 3, 4, 3, 2, 1], P.takeWhile(x => x !== 4))  // => [1, 2, 3]\n * @dataLast\n * @category Array\n */\nexport function takeWhile<T extends IterableContainer, S extends T[number]>(\n  predicate: (item: T[number], index: number, data: T) => item is S,\n): (array: T) => Array<S>;\nexport function takeWhile<T extends IterableContainer>(\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): (array: T) => Array<T[number]>;\n\nexport function takeWhile(...args: ReadonlyArray<unknown>): unknown {\n  return curry(takeWhileImplementation, args);\n}\n\nfunction takeWhileImplementation<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): Array<T[number]> {\n  const ret: Array<T[number]> = [];\n  for (const [index, item] of data.entries()) {\n    if (!predicate(item, index, data)) {\n      break;\n    }\n    ret.push(item);\n  }\n  return ret;\n}\n"],"mappings":"wCA2CA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAO,EAAM,EAAyB,EAAK,CAG7C,SAAS,EACP,EACA,EACkB,CAClB,IAAMA,EAAwB,EAAE,CAChC,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,SAAS,CAAE,CAC1C,GAAI,CAAC,EAAU,EAAM,EAAO,EAAK,CAC/B,MAEF,EAAI,KAAK,EAAK,CAEhB,OAAO"}

package/dist/take.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`),require(`./utility-evaluators-DqJcWENu.cjs`);const e=require(`./take-DwT7ymnA.cjs`);exports.take=e.take;
+const e=require(`./curry-BsY0Z8jH.cjs`),t=require(`./utility-evaluators-CAbODbuk.cjs`);function n(...t){return e.t(r,t,i)}function r(e,t){return t<0?[]:e.slice(0,t)}function i(e){if(e<=0)return t.n;let n=e;return e=>(--n,{done:n<=0,hasNext:!0,next:e})}exports.take=n;

package/dist/take.d.cts

@@ -1,3 +1,34 @@
-import "./iterable-container-V5sa0V_H.cjs";
-import { take } from "./take-BV-ctBqK.cjs";
-export { take };
+import { t as IterableContainer } from "./iterable-container-OFsaw8WL.cjs";
+
+//#region src/take.d.ts
+
+/**
+ * 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 extends IterableContainer>(array: T, n: number): Array<T[number]>;
+/**
+ * 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(n: number): <T extends IterableContainer>(array: T) => Array<T[number]>;
+//#endregion
+export { take };
+//# sourceMappingURL=take.d.cts.map

package/dist/take.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"take.d.cts","names":[],"sources":["../src/take.ts"],"sourcesContent":[],"mappings":";;;;;;AAmBA;;;;;;AAiBA;;;;;AAEmD,iBAnBnC,IAmBmC,CAAA,UAnBpB,iBAmBoB,CAAA,CAAA,KAAA,EAlB1C,CAkB0C,EAAA,CAAA,EAAA,MAAA,CAAA,EAhBhD,KAgBgD,CAhB1C,CAgB0C,CAAA,MAAA,CAAA,CAAA;;;;;;;;;;;;;iBAFnC,IAAA,wBAEF,0BAA0B,MAAM,MAAM"}

package/dist/take.d.ts

@@ -1,3 +1,34 @@
-import "./iterable-container-wtkYslN_.js";
-import { take } from "./take-CnVckkWV.js";
-export { take };
+import { t as IterableContainer } from "./iterable-container-BdjPuIjL.js";
+
+//#region src/take.d.ts
+
+/**
+ * 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 extends IterableContainer>(array: T, n: number): Array<T[number]>;
+/**
+ * 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(n: number): <T extends IterableContainer>(array: T) => Array<T[number]>;
+//#endregion
+export { take };
+//# sourceMappingURL=take.d.ts.map

package/dist/take.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"take.d.ts","names":[],"sources":["../src/take.ts"],"sourcesContent":[],"mappings":";;;;;;AAmBA;;;;;;AAiBA;;;;;AAEmD,iBAnBnC,IAmBmC,CAAA,UAnBpB,iBAmBoB,CAAA,CAAA,KAAA,EAlB1C,CAkB0C,EAAA,CAAA,EAAA,MAAA,CAAA,EAhBhD,KAgBgD,CAhB1C,CAgB0C,CAAA,MAAA,CAAA,CAAA;;;;;;;;;;;;;iBAFnC,IAAA,wBAEF,0BAA0B,MAAM,MAAM"}

package/dist/take.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import"./utility-evaluators-CnQVdcZv.js";import{take as e}from"./take-Cn0xLGe4.js";export{e as take};
+import{t as e}from"./curry-BcQ8Up1_.js";import{n as t}from"./utility-evaluators-BwYLtB8b.js";function n(...t){return e(r,t,i)}function r(e,t){return t<0?[]:e.slice(0,t)}function i(e){if(e<=0)return t;let n=e;return e=>(--n,{done:n<=0,hasNext:!0,next:e})}export{n as take};
+//# sourceMappingURL=take.js.map

package/dist/take.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"take.js","names":[],"sources":["../src/take.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\n\nimport { curry } from './curry';\nimport { lazyEmptyEvaluator } from './internal/utility-evaluators';\n\n/**\n * Returns the first `n` elements of `array`.\n *\n * @param array - The array.\n * @param n - The number of elements to take.\n * @signature\n *    P.take(array, n)\n * @example\n *    P.take([1, 2, 3, 4, 3, 2, 1], 3) // => [1, 2, 3]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function take<T extends IterableContainer>(\n  array: T,\n  n: number,\n): Array<T[number]>;\n\n/**\n * Returns the first `n` elements of `array`.\n *\n * @param n - The number of elements to take.\n * @signature\n *    P.take(n)(array)\n * @example\n *    P.pipe([1, 2, 3, 4, 3, 2, 1], P.take(n)) // => [1, 2, 3]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function take(\n  n: number,\n): <T extends IterableContainer>(array: T) => Array<T[number]>;\n\nexport function take(...args: ReadonlyArray<unknown>): unknown {\n  return curry(takeImplementation, args, lazyImplementation);\n}\n\nfunction takeImplementation<T extends IterableContainer>(\n  array: T,\n  n: number,\n): Array<T[number]> {\n  return n < 0 ? [] : array.slice(0, n);\n}\n\nfunction lazyImplementation<T>(n: number): LazyEvaluator<T> {\n  if (n <= 0) {\n    return lazyEmptyEvaluator;\n  }\n\n  let remaining = n;\n  return (value) => {\n    remaining -= 1;\n    return { done: remaining <= 0, hasNext: true, next: value };\n  };\n}\n"],"mappings":"6FAwCA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAoB,EAAM,EAAmB,CAG5D,SAAS,EACP,EACA,EACkB,CAClB,OAAO,EAAI,EAAI,EAAE,CAAG,EAAM,MAAM,EAAG,EAAE,CAGvC,SAAS,EAAsB,EAA6B,CAC1D,GAAI,GAAK,EACP,OAAO,EAGT,IAAI,EAAY,EAChB,MAAQ,KACN,IACO,CAAE,KAAM,GAAa,EAAG,QAAS,GAAM,KAAM,EAAO"}

package/dist/tap.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./tap-2SHLmCBm.cjs`);exports.tap=e.tap;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){return t(e),e}exports.tap=t;

package/dist/tap.d.cts

@@ -1,2 +1,42 @@
-import { tap } from "./tap-gF124Yhn.cjs";
-export { tap };
+//#region src/tap.d.ts
+/**
+ * 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;
+//#endregion
+export { tap };
+//# sourceMappingURL=tap.d.cts.map

package/dist/tap.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tap.d.cts","names":[],"sources":["../src/tap.ts"],"sourcesContent":[],"mappings":";;AAkBA;;;;;AAsBA;;;;;;;;;;iBAtBgB,cAAc,eAAe,aAAa;;;;;;;;;;;;;;;;;;;;;iBAsB1C,yBAAyB,mBAAmB,YAAY,MAAM"}

package/dist/tap.d.ts

@@ -1,2 +1,42 @@
-import { tap } from "./tap-BjWhN6y_.js";
-export { tap };
+//#region src/tap.d.ts
+/**
+ * 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;
+//#endregion
+export { tap };
+//# sourceMappingURL=tap.d.ts.map

package/dist/tap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tap.d.ts","names":[],"sources":["../src/tap.ts"],"sourcesContent":[],"mappings":";;AAkBA;;;;;AAsBA;;;;;;;;;;iBAtBgB,cAAc,eAAe,aAAa;;;;;;;;;;;;;;;;;;;;;iBAsB1C,yBAAyB,mBAAmB,YAAY,MAAM"}

package/dist/tap.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{tap as e}from"./tap-GLPlAKCD.js";export{e as tap};
+import{t as e}from"./curry-BcQ8Up1_.js";function t(...t){return e(n,t)}function n(e,t){return t(e),e}export{t as tap};
+//# sourceMappingURL=tap.js.map

package/dist/tap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tap.js","names":[],"sources":["../src/tap.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Calls the given function with the given value, then returns the given value.\n * The return value of the provided function is ignored.\n *\n * This allows \"tapping into\" a function sequence in a pipe, to perform side\n * effects on intermediate results.\n *\n * @param value - The value to pass into the function.\n * @param fn - The function to call.\n * @signature\n *    P.tap(value, fn)\n * @example\n *    P.tap(\"foo\", console.log) // => \"foo\"\n * @dataFirst\n * @category Other\n */\nexport function tap<T>(value: T, fn: (value: T) => void): T;\n\n/**\n * Calls the given function with the given value, then returns the given value.\n * The return value of the provided function is ignored.\n *\n * This allows \"tapping into\" a function sequence in a pipe, to perform side\n * effects on intermediate results.\n *\n * @param fn - The function to call.\n * @signature\n *    P.tap(fn)(value)\n * @example\n *    P.pipe(\n *      [-5, -1, 2, 3],\n *      P.filter(n => n > 0),\n *      P.tap(console.log), // prints [2, 3]\n *      P.map(n => n * 2)\n *    ) // => [4, 6]\n * @dataLast\n * @category Other\n */\nexport function tap<T, F extends (value: T) => unknown>(fn: F): (value: T) => T;\n\nexport function tap(...args: ReadonlyArray<unknown>): unknown {\n  return curry(tapImplementation, args);\n}\n\nfunction tapImplementation<T>(value: T, fn: (value: T) => void): T {\n  fn(value);\n  return value;\n}\n"],"mappings":"wCA0CA,SAAgB,EAAI,GAAG,EAAuC,CAC5D,OAAO,EAAM,EAAmB,EAAK,CAGvC,SAAS,EAAqB,EAAU,EAA2B,CAEjE,OADA,EAAG,EAAM,CACF"}

package/dist/times.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./times-ChlK_wAM.cjs`);exports.times=e.times;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){if(e<1)return[];let n=Number.isInteger(e)?e:Math.floor(e),r=Array(n);for(let e=0;e<n;e++)r[e]=t(e);return r}exports.times=t;

package/dist/times.d.cts

@@ -1,2 +1,48 @@
-import { times } from "./times-BoE5WrNr.cjs";
-export { times };
+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.cts.map

package/dist/times.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"times.d.cts","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/times.d.ts

@@ -1,2 +1,48 @@
-import { times } from "./times-CzRXDAnV.js";
-export { times };
+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

@@ -0,0 +1 @@
+{"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/times.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{times as e}from"./times-C4txaWWG.js";export{e as times};
+import{t as e}from"./curry-BcQ8Up1_.js";function t(...t){return e(n,t)}function n(e,t){if(e<1)return[];let n=Number.isInteger(e)?e:Math.floor(e),r=Array(n);for(let e=0;e<n;e++)r[e]=t(e);return r}export{t as times};
+//# sourceMappingURL=times.js.map

package/dist/times.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"times.js","names":[],"sources":["../src/times.ts"],"sourcesContent":["import type { GreaterThan } from 'type-fest';\n\nimport { curry } from './curry';\n\n// This number was picked by trial-and-error until typescript stops failing with\n// \"Type instantiation is excessively deep and possibly infinite. (ts2589)\".\n// See the type tests for more information.\ntype MAX_LITERAL_SIZE = 46;\n\ntype TimesArray<\n  T,\n  N extends number,\n  Iteration extends ReadonlyArray<unknown> = [],\n> = number extends N\n  // N is not a literal number, we can't deduce the type\n  ? Array<T>\n  : `${N}` extends `-${number}`\n    // N is non-positive, the mapper will never run\n    ? []\n    : `${N}` extends `${infer K extends number}.${number}`\n      // N is not an integer, we \"floor\" the number.\n      ? TimesArray<T, K, Iteration>\n      : GreaterThan<N, MAX_LITERAL_SIZE> extends true\n        // We can't build a literal tuple beyond this size, after that we\n        // can't add more items to the tuple so we add a rest element instead.\n        ? [...TimesArray<T, MAX_LITERAL_SIZE, Iteration>, ...Array<T>]\n        : N extends Iteration['length']\n          // We finished building the output tuple\n          ? []\n          // Add another item to the tuple and recurse.\n          : [T, ...TimesArray<T, N, [unknown, ...Iteration]>];\n\n/**\n * Calls an input function `n` times, returning an array containing the results\n * of those function calls.\n *\n * `fn` is passed one argument: The current value of `n`, which begins at `0`\n * and is gradually incremented to `n - 1`.\n *\n * @param count - A value between `0` and `n - 1`. Increments after each\n * function call.\n * @param fn - The function to invoke. Passed one argument, the current value of\n * `n`.\n * @signature\n *   P.times(count, fn)\n * @example\n *   P.times(5, identity()); //=> [0, 1, 2, 3, 4]\n *\n * @dataFirst\n * @category Array\n */\nexport function times<T, N extends number>(\n  count: N,\n  fn: (index: number) => T,\n): TimesArray<T, N>;\n\n/**\n * Calls an input function `n` times, returning an array containing the results\n * of those function calls.\n *\n * `fn` is passed one argument: The current value of `n`, which begins at `0`\n * and is gradually incremented to `n - 1`.\n *\n * @param fn - The function to invoke. Passed one argument, the current value of\n * `n`.\n * @returns An array containing the return values of all calls to `fn`.\n *\n * @signature\n *   P.times(count, fn)\n * @example\n *   P.times(identity())(5); //=> [0, 1, 2, 3, 4]\n *\n * @dataLast\n * @category Array\n */\nexport function times<T>(\n  fn: (index: number) => T,\n): <N extends number>(count: N) => TimesArray<T, N>;\n\nexport function times(...args: ReadonlyArray<unknown>): unknown {\n  return curry(timesImplementation, args);\n}\n\nfunction timesImplementation<T>(\n  count: number,\n  fn: (index: number) => T,\n): Array<T> {\n  if (count < 1) {\n    // We prefer to return trivial results on trivial inputs vs throwing errors.\n    return [];\n  }\n\n  // Non-integer numbers would cause `new Array` to throw, but it makes more\n  // sense to simply round them down to the nearest integer instead; but\n  // rounding has some performance implications so we only do it when we have to\n  const length = Number.isInteger(count) ? count : Math.floor(count);\n\n  // eslint-disable-next-line unicorn/no-new-array -- This is the most efficient way to create the array, check out the benchmarks in the PR that added this comment.\n  const res = new Array<T>(length);\n\n  for (let i = 0; i < length; i++) {\n    res[i] = fn(i);\n  }\n\n  return res;\n}\n"],"mappings":"wCA+EA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAqB,EAAK,CAGzC,SAAS,EACP,EACA,EACU,CACV,GAAI,EAAQ,EAEV,MAAO,EAAE,CAMX,IAAM,EAAS,OAAO,UAAU,EAAM,CAAG,EAAQ,KAAK,MAAM,EAAM,CAG5D,EAAU,MAAS,EAAO,CAEhC,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IAC1B,EAAI,GAAK,EAAG,EAAE,CAGhB,OAAO"}

package/dist/to-camel-case.cjs

@@ -1 +1 @@
-require(`./case.transform-UvmY1E5L.cjs`);const e=require(`./to-camel-case-MCv0xSE_.cjs`);exports.toCamelCase=e.toCamelCase;
+const e=require(`./case.transform-FNx2XsC3.cjs`);function t(t,n){let[r,i,a]=e.r(t,n),o=n?.mergeAmbiguousCharacters?e.t():e.n();return r+i.map((e,t)=>t===0?e.toLowerCase():o(e,t)).join(n?.delimiter??``)+a}exports.toCamelCase=t;

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

@@ -1,3 +1,32 @@
-import "./case.types-C4kGtbSS.cjs";
-import { toCamelCase } from "./to-camel-case-5ZN25UuZ.cjs";
-export { toCamelCase };
+import { t as ChangeCaseOptions } from "./case.types-BxuWJgN1.cjs";
+
+//#region src/to-camel-case.d.ts
+
+/**
+ * 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;
+//#endregion
+export { toCamelCase };
+//# sourceMappingURL=to-camel-case.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"to-camel-case.d.cts","names":[],"sources":["../src/to-camel-case.ts"],"sourcesContent":[],"mappings":";;;;;;AA4BA;;;;;;;;;;;;;;;;;;;;;;iBAAgB,WAAA,0BAAqC"}

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

@@ -1,3 +1,32 @@
-import "./case.types-DegX_-fY.js";
-import { toCamelCase } from "./to-camel-case-DJ5dmboH.js";
-export { toCamelCase };
+import { t as ChangeCaseOptions } from "./case.types-CVfGg990.js";
+
+//#region src/to-camel-case.d.ts
+
+/**
+ * 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;
+//#endregion
+export { toCamelCase };
+//# sourceMappingURL=to-camel-case.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"to-camel-case.d.ts","names":[],"sources":["../src/to-camel-case.ts"],"sourcesContent":[],"mappings":";;;;;;AA4BA;;;;;;;;;;;;;;;;;;;;;;iBAAgB,WAAA,0BAAqC"}

package/dist/to-camel-case.js

@@ -1 +1,2 @@
-import"./case.transform-0QyAGkjI.js";import{toCamelCase as e}from"./to-camel-case-JdiHeuUd.js";export{e as toCamelCase};
+import{n as e,r as t,t as n}from"./case.transform-CCMWrBmz.js";function r(r,i){let[a,o,s]=t(r,i),c=i?.mergeAmbiguousCharacters?n():e();return a+o.map((e,t)=>t===0?e.toLowerCase():c(e,t)).join(i?.delimiter??``)+s}export{r as toCamelCase};
+//# sourceMappingURL=to-camel-case.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"to-camel-case.js","names":[],"sources":["../src/to-camel-case.ts"],"sourcesContent":["import type { ChangeCaseOptions } from './internal/case.types';\n\nimport { capitalCaseTransformFactory, pascalCaseTransformFactory, splitPrefixSuffix } from './internal/case.transform';\n\n/**\n * Convert a string to camel case.\n *\n * @param input the string to convert\n * @param options - Optional configuration for the conversion.\n * @param options.delimiter - The delimiter to use between words.\n * @param options.separateNumbers - If true, an underscore will be injected before the numbers.\n * @param options.prefixCharacters - The prefix characters that we want to ignore.\n * @param options.suffixCharacters - The suffix characters that we want to ignore.\n * @param options.splitFn - A custom split function to separated the words.\n * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.\n *\n * @signature\n *   toCamelCase(str)\n * @example\n *   toCamelCase('test'); // => 'test'\n *   toCamelCase('test string'); // => 'testSTring'\n *   toCamelCase('test string', { delimiter: '$' }); // => 'test$string'\n *   toCamelCase('TestV2', { separateNumbers: true }); // => 'testV_2'\n *   toCamelCase('__typename', { prefixCharacters: '_' }); // => '__typename'\n *   toCamelCase('type__', { suffixCharacters: '_' }); // => 'type__'\n *   toCamelCase('version 1.2.10', { mergeAmbiguousCharacters: true }); // => 'version1210'\n * @category String\n */\nexport function toCamelCase(input: string, options?: ChangeCaseOptions): string {\n  const [prefix, words, suffix] = splitPrefixSuffix(input, options);\n\n  const transform = options?.mergeAmbiguousCharacters\n    ? capitalCaseTransformFactory()\n    : pascalCaseTransformFactory();\n\n  return (\n    prefix\n    + words\n      .map((word, index) => {\n        if (index === 0) {\n          return word.toLowerCase();\n        }\n\n        return transform(word, index);\n      })\n      .join(options?.delimiter ?? '')\n      + suffix\n  );\n}\n"],"mappings":"+DA4BA,SAAgB,EAAY,EAAe,EAAqC,CAC9E,GAAM,CAAC,EAAQ,EAAO,GAAU,EAAkB,EAAO,EAAQ,CAE3D,EAAY,GAAS,yBACvB,GAA6B,CAC7B,GAA4B,CAEhC,OACE,EACE,EACC,KAAK,EAAM,IACN,IAAU,EACL,EAAK,aAAa,CAGpB,EAAU,EAAM,EAAM,CAC7B,CACD,KAAK,GAAS,WAAa,GAAG,CAC7B"}

package/dist/to-capital-case.cjs

@@ -1 +1 @@
-require(`./case.transform-UvmY1E5L.cjs`);const e=require(`./to-capital-case-BD9MIiKM.cjs`);exports.toCapitalCase=e.toCapitalCase;
+const e=require(`./case.transform-FNx2XsC3.cjs`);function t(t,n){let[r,i,a]=e.r(t,n);return r+i.map(e.t()).join(n?.delimiter??` `)+a}exports.toCapitalCase=t;

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

@@ -1,3 +1,31 @@
-import "./case.types-C4kGtbSS.cjs";
-import { toCapitalCase } from "./to-capital-case-BBTx9xpN.cjs";
-export { toCapitalCase };
+import { t as ChangeCaseOptions } from "./case.types-BxuWJgN1.cjs";
+
+//#region src/to-capital-case.d.ts
+
+/**
+ * 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;
+//#endregion
+export { toCapitalCase };
+//# sourceMappingURL=to-capital-case.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"to-capital-case.d.cts","names":[],"sources":["../src/to-capital-case.ts"],"sourcesContent":[],"mappings":";;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;;iBAAgB,aAAA,0BAAuC"}

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

@@ -1,3 +1,31 @@
-import "./case.types-DegX_-fY.js";
-import { toCapitalCase } from "./to-capital-case-BDs8sikX.js";
-export { toCapitalCase };
+import { t as ChangeCaseOptions } from "./case.types-CVfGg990.js";
+
+//#region src/to-capital-case.d.ts
+
+/**
+ * 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;
+//#endregion
+export { toCapitalCase };
+//# sourceMappingURL=to-capital-case.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"to-capital-case.d.ts","names":[],"sources":["../src/to-capital-case.ts"],"sourcesContent":[],"mappings":";;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;;iBAAgB,aAAA,0BAAuC"}

package/dist/to-capital-case.js

@@ -1 +1,2 @@
-import"./case.transform-0QyAGkjI.js";import{toCapitalCase as e}from"./to-capital-case-DFgHWUP7.js";export{e as toCapitalCase};
+import{r as e,t}from"./case.transform-CCMWrBmz.js";function n(n,r){let[i,a,o]=e(n,r);return i+a.map(t()).join(r?.delimiter??` `)+o}export{n as toCapitalCase};
+//# sourceMappingURL=to-capital-case.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"to-capital-case.js","names":[],"sources":["../src/to-capital-case.ts"],"sourcesContent":["import type { ChangeCaseOptions } from './internal/case.types';\n\nimport { capitalCaseTransformFactory, splitPrefixSuffix } from './internal/case.transform';\n\n/**\n * Convert a string to capital case.\n *\n * @param input the string to convert\n * @param options - Optional configuration for the conversion.\n * @param options.delimiter - The delimiter to use between words.\n * @param options.separateNumbers - If true, numbers will be separated.\n * @param options.prefixCharacters - The prefix characters that we want to ignore.\n * @param options.suffixCharacters - The suffix characters that we want to ignore.\n * @param options.splitFn - A custom split function to separated the words.\n * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.\n *\n * @signature\n *   toCapitalCase(str)\n * @example\n *   toCapitalCase('test'); // => 'Test'\n *   toCapitalCase('test string'); // => 'Test String'\n *   toCapitalCase('test string', { delimiter: '$' }); // => 'Test$String'\n *   toCapitalCase('testV2', { separateNumbers: true }); // => 'TEST V 2'\n *   toCapitalCase('__typename', { prefixCharacters: '_' }); // => '__Typename'\n *   toCapitalCase('type__', { suffixCharacters: '_' }); // => 'Type__'\n * @category String\n */\nexport function toCapitalCase(input: string, options?: ChangeCaseOptions): string {\n  const [prefix, words, suffix] = splitPrefixSuffix(input, options);\n\n  return (\n    prefix\n    + words\n      .map(capitalCaseTransformFactory())\n      .join(options?.delimiter ?? ' ')\n      + suffix\n  );\n}\n"],"mappings":"mDA2BA,SAAgB,EAAc,EAAe,EAAqC,CAChF,GAAM,CAAC,EAAQ,EAAO,GAAU,EAAkB,EAAO,EAAQ,CAEjE,OACE,EACE,EACC,IAAI,GAA6B,CAAC,CAClC,KAAK,GAAS,WAAa,IAAI,CAC9B"}

package/dist/to-constant-case.cjs

@@ -1 +1 @@
-require(`./case.transform-UvmY1E5L.cjs`);const e=require(`./to-constant-case-C6XG49MZ.cjs`);exports.toConstantCase=e.toConstantCase;
+const e=require(`./case.transform-FNx2XsC3.cjs`);function t(t,n){let[r,i,a]=e.r(t,n);return r+i.map(e=>e.toUpperCase()).join(n?.delimiter??`_`)+a}exports.toConstantCase=t;