@vinicunca/perkakas 1.9.0 → 1.13.0

package/dist/any-pass-BUlFAsyd.d.cts

@@ -1,37 +0,0 @@
-//#region src/any-pass.d.ts
-/**
- * Determines whether any predicate returns true for the input data.
- *
- * @param data - The input data for predicates.
- * @param fns - The list of predicates.
- * @signature
- *    P.anyPass(data, fns)
- * @example
- *    const isDivisibleBy3 = (x: number) => x % 3 === 0
- *    const isDivisibleBy4 = (x: number) => x % 4 === 0
- *    const fns = [isDivisibleBy3, isDivisibleBy4]
- *    P.anyPass(8, fns) // => true
- *    P.anyPass(11, fns) // => false
- * @dataFirst
- * @category Array
- */
-declare function anyPass<T>(data: T, fns: ReadonlyArray<(data: T) => boolean>): boolean;
-/**
- * Determines whether any predicate returns true for the input data.
- *
- * @param fns - The list of predicates.
- * @signature
- *    P.anyPass(fns)(data)
- * @example
- *    const isDivisibleBy3 = (x: number) => x % 3 === 0
- *    const isDivisibleBy4 = (x: number) => x % 4 === 0
- *    const fns = [isDivisibleBy3, isDivisibleBy4]
- *    P.anyPass(fns)(8) // => true
- *    P.anyPass(fns)(11) // => false
- * @dataLast
- * @category Array
- */
-declare function anyPass<T>(fns: ReadonlyArray<(data: T) => boolean>): (data: T) => boolean;
-//#endregion
-export { anyPass };
-//# sourceMappingURL=any-pass-BUlFAsyd.d.cts.map

package/dist/any-pass-BUlFAsyd.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"any-pass-BUlFAsyd.d.cts","names":[],"sources":["../src/any-pass.ts"],"sourcesContent":[],"mappings":";;AAkBA;;;;;;AAoBA;;;;;;;;;iBApBgB,iBACR,QACD,qBAAqB;;;;;;;;;;;;;;;;iBAkBZ,gBACT,qBAAqB,wBAClB"}

package/dist/any-pass-UiZWZkzr.cjs

@@ -1 +0,0 @@
-const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){return t.some(t=>t(e))}Object.defineProperty(exports,`anyPass`,{enumerable:!0,get:function(){return t}});

package/dist/array-required-prefix-BHFg-BKr.d.ts

@@ -1,26 +0,0 @@
-import { IterableContainer } from "./iterable-container-F9CDF7ym.js";
-import { PerkakasTypeError } from "./perkakas-type-error-2yBU0Drj.js";
-import { TupleParts } from "./tuple-parts-Du2iVN8H.js";
-import { ClampedIntegerSubtract } from "./clamped-integer-subtract-Dh3vTnRH.js";
-import { CoercedArray } from "./coerced-array-Fezc8pIu.js";
-import { And, GreaterThan, IsEqual, IsLiteral, IsNever, ReadonlyTuple } from "type-fest";
-
-//#region src/internal/types/array-required-prefix.d.ts
-type ArrayRequiredPrefix<T extends IterableContainer, N extends number> = IsLiteral<N> extends true ? T extends unknown ? ClampedIntegerSubtract<N, [...TupleParts<T>['required'], ...TupleParts<T>['suffix']]['length']> extends infer Remainder extends number ? Remainder extends 0 ? T : And<GreaterThan<Remainder, TupleParts<T>['optional']['length']>, IsNever<TupleParts<T>['item']>> extends true ? PerkakasTypeError<'ArrayRequiredPrefix', 'The input tuple cannot satisfy the minimum', {
-  type: never;
-  metadata: [T, N];
-}> : WithSameReadonly<T, [...TupleParts<T>['required'], ...OptionalTupleRequiredPrefix<TupleParts<T>['optional'], Remainder>, ...ReadonlyTuple<TupleParts<T>['item'], ClampedIntegerSubtract<Remainder, TupleParts<T>['optional']['length']>>, ...CoercedArray<TupleParts<T>['item']>, ...TupleParts<T>['suffix']]> : PerkakasTypeError<'ArrayRequiredPrefix', 'Remainder didn\'t compute to a number?!', {
-  type: never;
-  metadata: [T, N];
-}> : PerkakasTypeError<'ArrayRequiredPrefix', 'Failed to distribute union?!', {
-  type: never;
-  metadata: T;
-}> : PerkakasTypeError<'ArrayRequiredPrefix', 'Only literal minimums are supported!', {
-  type: never;
-  metadata: N;
-}>;
-type WithSameReadonly<Source, Destination> = IsEqual<Source, Readonly<Source>> extends true ? Readonly<Destination> : Destination;
-type OptionalTupleRequiredPrefix<T extends Array<unknown>, N, Prefix extends Array<unknown> = []> = Prefix['length'] extends N ? [...Prefix, ...Partial<T>] : T extends readonly [infer Head, ...infer Rest] ? OptionalTupleRequiredPrefix<Rest, N, [...Prefix, Head]> : Prefix;
-//#endregion
-export { ArrayRequiredPrefix };
-//# sourceMappingURL=array-required-prefix-BHFg-BKr.d.ts.map

package/dist/array-required-prefix-BHFg-BKr.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"array-required-prefix-BHFg-BKr.d.ts","names":[],"sources":["../src/internal/types/array-required-prefix.ts"],"sourcesContent":[],"mappings":";;;;;;;;KAcY,8BAA8B,uCACtC,UAAU,kBAER,oBACE,uBACA,OACI,WAAW,gBANX,GAM8B,UAN9B,CAMyC,CANzC,CAAA,CAAA,QAAmB,CAAA,CAAA,CAAA,QAAA,CAAA,CAAA,SAAA,KAAA,mBAAA,MAAA,GAQrB,SARqB,SAAA,CAAA,GAWnB,CAXmB,GAYnB,GAZmB,CAenB,WAfmB,CAeP,SAfO,EAeI,UAfJ,CAee,CAff,CAAA,CAAA,UAAA,CAAA,CAAA,QAAA,CAAA,CAAA,EAiBnB,OAjBmB,CAiBX,UAjBW,CAiBA,CAjBA,CAAA,CAAA,MAAA,CAAA,CAAA,CAAA,SAAA,IAAA,GAmBjB,iBAnBiB,CAAA,qBAAA,EAAA,4CAAA,EAAA;MAAW,EAAA,KAAA;UAC5B,EAAA,CAuBa,CAvBb,EAuBgB,CAvBhB,CAAA;KA8BA,gBA9BV,CA+BU,CA/BV,EAAA,IAmCe,UAjCb,CAiCwB,CAjCxB,CAAA,CAAA,UAAA,CAAA,KAuCa,2BArCX,CAsCU,UAtCV,CAsCqB,CAtCrB,CAAA,CAAA,UAAA,CAAA,EAuCU,SAvCV,CAAA,KA6CW,aA5CI,CA6CL,UA7CK,CA6CM,CA7CN,CAAA,CAAA,MAAA,CAAA,EA8CL,sBA9CK,CA+CH,SA/CG,EAgDH,UAhDG,CAgDQ,CAhDR,CAAA,CAAA,UAAA,CAAA,CAAA,QAAA,CAAA,CAAA,CAAA,KAsDJ,YAtDP,CAsDoB,UAtDpB,CAsD+B,CAtD/B,CAAA,CAAA,MAAA,CAAA,CAAA,KAuDO,UAvDkC,CAuDvB,CAvDuB,CAAA,CAAA,QAAA,CAAA,KA0D3C,iBA1DgC,CAAA,qBAAA,EAAA,yCAAA,EAAA;MAFlC,EAAA,KAAA;UAIE,EAAA,CA6Da,CA7Db,EA6DgB,CA7DhB,CAAA;KAgEF,iBA7DI,CAAA,qBAAA,EAAA,8BAAA,EAAA;MAIY,EAAA,KAAA;UAAsB,EA8D1B,CA9D0B;KAiExC,iBAjE6B,CAAA,qBAAA,EAAA,sCAAA,EAAA;MAAvB,EAAA,KAAA;UAEmB,EAoEb,CApEa;;KA0E1B,gBA1EO,CAAA,MAAA,EAAA,WAAA,CAAA,GA2ER,OA3EQ,CA2EA,MA3EA,EA2EQ,QA3ER,CA2EiB,MA3EjB,CAAA,CAAA,SAAA,IAAA,GA4EN,QA5EM,CA4EG,WA5EH,CAAA,GA6EN,WA7EM;KAmFP,2BAxFO,CAAA,UAyFA,KAzFA,CAAA,OAAA,CAAA,EAAA,CAAA,EAAA,eA2FK,KA3FL,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GA4FR,MA5FQ,CAAA,QAAA,CAAA,SA4FiB,CA5FjB,GAAA,CAAA,GAiGJ,MAjGI,EAAA,GAiGO,OAjGP,CAiGe,CAjGf,CAAA,CAAA,GAkGR,CAlGQ,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAmGN,2BAnGM,CAmGsB,IAnGtB,EAmG4B,CAnG5B,EAAA,CAAA,GAmGmC,MAnGnC,EAmG2C,IAnG3C,CAAA,CAAA,GAuGN,MAvGM"}

package/dist/array-required-prefix-FSH3Acx8.d.cts

@@ -1,26 +0,0 @@
-import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
-import { PerkakasTypeError } from "./perkakas-type-error-0tHtaPbi.cjs";
-import { TupleParts } from "./tuple-parts-BIyABPYv.cjs";
-import { ClampedIntegerSubtract } from "./clamped-integer-subtract-DId0tRjp.cjs";
-import { CoercedArray } from "./coerced-array-kVJtBrMl.cjs";
-import { And, GreaterThan, IsEqual, IsLiteral, IsNever, ReadonlyTuple } from "type-fest";
-
-//#region src/internal/types/array-required-prefix.d.ts
-type ArrayRequiredPrefix<T extends IterableContainer, N extends number> = IsLiteral<N> extends true ? T extends unknown ? ClampedIntegerSubtract<N, [...TupleParts<T>['required'], ...TupleParts<T>['suffix']]['length']> extends infer Remainder extends number ? Remainder extends 0 ? T : And<GreaterThan<Remainder, TupleParts<T>['optional']['length']>, IsNever<TupleParts<T>['item']>> extends true ? PerkakasTypeError<'ArrayRequiredPrefix', 'The input tuple cannot satisfy the minimum', {
-  type: never;
-  metadata: [T, N];
-}> : WithSameReadonly<T, [...TupleParts<T>['required'], ...OptionalTupleRequiredPrefix<TupleParts<T>['optional'], Remainder>, ...ReadonlyTuple<TupleParts<T>['item'], ClampedIntegerSubtract<Remainder, TupleParts<T>['optional']['length']>>, ...CoercedArray<TupleParts<T>['item']>, ...TupleParts<T>['suffix']]> : PerkakasTypeError<'ArrayRequiredPrefix', 'Remainder didn\'t compute to a number?!', {
-  type: never;
-  metadata: [T, N];
-}> : PerkakasTypeError<'ArrayRequiredPrefix', 'Failed to distribute union?!', {
-  type: never;
-  metadata: T;
-}> : PerkakasTypeError<'ArrayRequiredPrefix', 'Only literal minimums are supported!', {
-  type: never;
-  metadata: N;
-}>;
-type WithSameReadonly<Source, Destination> = IsEqual<Source, Readonly<Source>> extends true ? Readonly<Destination> : Destination;
-type OptionalTupleRequiredPrefix<T extends Array<unknown>, N, Prefix extends Array<unknown> = []> = Prefix['length'] extends N ? [...Prefix, ...Partial<T>] : T extends readonly [infer Head, ...infer Rest] ? OptionalTupleRequiredPrefix<Rest, N, [...Prefix, Head]> : Prefix;
-//#endregion
-export { ArrayRequiredPrefix };
-//# sourceMappingURL=array-required-prefix-FSH3Acx8.d.cts.map

package/dist/array-required-prefix-FSH3Acx8.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"array-required-prefix-FSH3Acx8.d.cts","names":[],"sources":["../src/internal/types/array-required-prefix.ts"],"sourcesContent":[],"mappings":";;;;;;;;KAcY,8BAA8B,uCACtC,UAAU,kBAER,oBACE,uBACA,OACI,WAAW,gBANX,GAM8B,UAN9B,CAMyC,CANzC,CAAA,CAAA,QAAmB,CAAA,CAAA,CAAA,QAAA,CAAA,CAAA,SAAA,KAAA,mBAAA,MAAA,GAQrB,SARqB,SAAA,CAAA,GAWnB,CAXmB,GAYnB,GAZmB,CAenB,WAfmB,CAeP,SAfO,EAeI,UAfJ,CAee,CAff,CAAA,CAAA,UAAA,CAAA,CAAA,QAAA,CAAA,CAAA,EAiBnB,OAjBmB,CAiBX,UAjBW,CAiBA,CAjBA,CAAA,CAAA,MAAA,CAAA,CAAA,CAAA,SAAA,IAAA,GAmBjB,iBAnBiB,CAAA,qBAAA,EAAA,4CAAA,EAAA;MAAW,EAAA,KAAA;UAC5B,EAAA,CAuBa,CAvBb,EAuBgB,CAvBhB,CAAA;KA8BA,gBA9BV,CA+BU,CA/BV,EAAA,IAmCe,UAjCb,CAiCwB,CAjCxB,CAAA,CAAA,UAAA,CAAA,KAuCa,2BArCX,CAsCU,UAtCV,CAsCqB,CAtCrB,CAAA,CAAA,UAAA,CAAA,EAuCU,SAvCV,CAAA,KA6CW,aA5CI,CA6CL,UA7CK,CA6CM,CA7CN,CAAA,CAAA,MAAA,CAAA,EA8CL,sBA9CK,CA+CH,SA/CG,EAgDH,UAhDG,CAgDQ,CAhDR,CAAA,CAAA,UAAA,CAAA,CAAA,QAAA,CAAA,CAAA,CAAA,KAsDJ,YAtDP,CAsDoB,UAtDpB,CAsD+B,CAtD/B,CAAA,CAAA,MAAA,CAAA,CAAA,KAuDO,UAvDkC,CAuDvB,CAvDuB,CAAA,CAAA,QAAA,CAAA,KA0D3C,iBA1DgC,CAAA,qBAAA,EAAA,yCAAA,EAAA;MAFlC,EAAA,KAAA;UAIE,EAAA,CA6Da,CA7Db,EA6DgB,CA7DhB,CAAA;KAgEF,iBA7DI,CAAA,qBAAA,EAAA,8BAAA,EAAA;MAIY,EAAA,KAAA;UAAsB,EA8D1B,CA9D0B;KAiExC,iBAjE6B,CAAA,qBAAA,EAAA,sCAAA,EAAA;MAAvB,EAAA,KAAA;UAEmB,EAoEb,CApEa;;KA0E1B,gBA1EO,CAAA,MAAA,EAAA,WAAA,CAAA,GA2ER,OA3EQ,CA2EA,MA3EA,EA2EQ,QA3ER,CA2EiB,MA3EjB,CAAA,CAAA,SAAA,IAAA,GA4EN,QA5EM,CA4EG,WA5EH,CAAA,GA6EN,WA7EM;KAmFP,2BAxFO,CAAA,UAyFA,KAzFA,CAAA,OAAA,CAAA,EAAA,CAAA,EAAA,eA2FK,KA3FL,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GA4FR,MA5FQ,CAAA,QAAA,CAAA,SA4FiB,CA5FjB,GAAA,CAAA,GAiGJ,MAjGI,EAAA,GAiGO,OAjGP,CAiGe,CAjGf,CAAA,CAAA,GAkGR,CAlGQ,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAmGN,2BAnGM,CAmGsB,IAnGtB,EAmG4B,CAnG5B,EAAA,CAAA,GAmGmC,MAnGnC,EAmG2C,IAnG3C,CAAA,CAAA,GAuGN,MAvGM"}

package/dist/binary-search-cutoff-index-BZF3GL7H.cjs

@@ -1 +0,0 @@
-function e(e,t){let n=0,r=e.length;for(;n<r;){let i=n+r>>>1,a=e[i];t(a,i,e)?n=i+1:r=i}return r}Object.defineProperty(exports,`binarySearchCutoffIndex`,{enumerable:!0,get:function(){return e}});

package/dist/binary-search-cutoff-index-YVs_m4IY.js

@@ -1,2 +0,0 @@
-function e(e,t){let n=0,r=e.length;for(;n<r;){let i=n+r>>>1,a=e[i];t(a,i,e)?n=i+1:r=i}return r}export{e as binarySearchCutoffIndex};
-//# sourceMappingURL=binary-search-cutoff-index-YVs_m4IY.js.map

package/dist/binary-search-cutoff-index-YVs_m4IY.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"binary-search-cutoff-index-YVs_m4IY.js","names":[],"sources":["../src/internal/binary-search-cutoff-index.ts"],"sourcesContent":["/**\n * A binary search implementation that finds the index at which `predicate`\n * stops returning `true` and starts returning `false` (consistently) when run\n * on the items of the array. It **assumes** that mapping the array via the\n * predicate results in the shape `[...true[], ...false[]]`. *For any other case\n * the result is unpredictable*.\n *\n * This is the base implementation of the `sortedIndex` functions which define\n * the predicate for the user, for common use-cases.\n *\n * It is similar to `findIndex`, but runs at O(logN), whereas the latter is\n * general purpose function which runs on any array and predicate, but runs at\n * O(N) time.\n */\nexport function binarySearchCutoffIndex<T>(\n  array: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): number {\n  let lowIndex = 0;\n  let highIndex = array.length;\n\n  while (lowIndex < highIndex) {\n    const pivotIndex = (lowIndex + highIndex) >>> 1;\n    const pivot = array[pivotIndex]!;\n\n    if (predicate(pivot, pivotIndex, array)) {\n      lowIndex = pivotIndex + 1;\n    } else {\n      highIndex = pivotIndex;\n    }\n  }\n\n  return highIndex;\n}\n"],"mappings":"AAcA,SAAgB,EACd,EACA,EACQ,CACR,IAAI,EAAW,EACX,EAAY,EAAM,OAEtB,KAAO,EAAW,GAAW,CAC3B,IAAM,EAAc,EAAW,IAAe,EACxC,EAAQ,EAAM,GAEhB,EAAU,EAAO,EAAY,EAAM,CACrC,EAAW,EAAa,EAExB,EAAY,EAIhB,OAAO"}

package/dist/bounded-partial-A89bt7Kj.d.cts

@@ -1,17 +0,0 @@
-import { IsBoundedRecord } from "./is-bounded-record-kpsb1wQA.cjs";
-
-//#region src/internal/types/bounded-partial.d.ts
-
-/**
- * Records with an unbounded set of keys have different semantics to those with
- * a bounded set of keys when using 'noUncheckedIndexedAccess', the former
- * being implicitly `Partial` whereas the latter are implicitly `Required`.
- *
- * @example
- *    BoundedPartial<{ a: number }>; //=> { a?: number }
- *    BoundedPartial<Record<string, number>>; //=> Record<string, number>
- */
-type BoundedPartial<T> = IsBoundedRecord<T> extends true ? Partial<T> : T;
-//#endregion
-export { BoundedPartial };
-//# sourceMappingURL=bounded-partial-A89bt7Kj.d.cts.map

package/dist/bounded-partial-A89bt7Kj.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bounded-partial-A89bt7Kj.d.cts","names":[],"sources":["../src/internal/types/bounded-partial.ts"],"sourcesContent":[],"mappings":";;;;;;AAWA;;;;;;;AAAgF,KAApE,cAAoE,CAAA,CAAA,CAAA,GAAhD,eAAgD,CAAhC,CAAgC,CAAA,SAAA,IAAA,GAAd,OAAc,CAAN,CAAM,CAAA,GAAD,CAAC"}

package/dist/bounded-partial-DfemQln9.d.ts

@@ -1,17 +0,0 @@
-import { IsBoundedRecord } from "./is-bounded-record-DEQ2a3_Y.js";
-
-//#region src/internal/types/bounded-partial.d.ts
-
-/**
- * Records with an unbounded set of keys have different semantics to those with
- * a bounded set of keys when using 'noUncheckedIndexedAccess', the former
- * being implicitly `Partial` whereas the latter are implicitly `Required`.
- *
- * @example
- *    BoundedPartial<{ a: number }>; //=> { a?: number }
- *    BoundedPartial<Record<string, number>>; //=> Record<string, number>
- */
-type BoundedPartial<T> = IsBoundedRecord<T> extends true ? Partial<T> : T;
-//#endregion
-export { BoundedPartial };
-//# sourceMappingURL=bounded-partial-DfemQln9.d.ts.map

package/dist/bounded-partial-DfemQln9.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bounded-partial-DfemQln9.d.ts","names":[],"sources":["../src/internal/types/bounded-partial.ts"],"sourcesContent":[],"mappings":";;;;;;AAWA;;;;;;;AAAgF,KAApE,cAAoE,CAAA,CAAA,CAAA,GAAhD,eAAgD,CAAhC,CAAgC,CAAA,SAAA,IAAA,GAAd,OAAc,CAAN,CAAM,CAAA,GAAD,CAAC"}

package/dist/case.transform-BXzx2bAJ.cjs

@@ -1 +0,0 @@
-const e=/([\p{Ll}\d])(\p{Lu})/gu,t=/(\p{Lu})(\p{Lu}\p{Ll})/gu,n=/(\d)\p{Ll}|(\p{L})\d/u,r=/[^\p{L}\d]+/giu,i=`$1\0$2`,a=``;function o(e,t={}){let n=t.splitFn??(t.separateNumbers?u:s),r=t.prefixCharacters??``,i=t.suffixCharacters??``,a=0,o=e.length;for(;a<e.length;){let t=e.charAt(a);if(!r.includes(t))break;a++}for(;o>a;){let t=o-1,n=e.charAt(t);if(!i.includes(n))break;o=t}return[e.slice(0,a),n(e.slice(a,o)),e.slice(o)]}function s(n){let a=n.trim();a=a.replace(e,i).replace(t,i),a=a.replace(r,`\0`);let o=0,s=a.length;for(;a.charAt(o)===`\0`;)o++;if(o===s)return[];for(;a.charAt(s-1)===`\0`;)s--;return a.slice(o,s).split(/\0/)}function c(){return e=>e[0].toUpperCase()+e.slice(1).toLowerCase()}function l(){return(e,t)=>{let n=e[0];return(t>0&&n>=`0`&&n<=`9`?`_${n}`:n.toUpperCase())+e.slice(1).toLowerCase()}}function u(e){let t=s(e);for(let e=0;e<t.length;e++){let r=t[e],i=n.exec(r);if(i){let n=i.index+(i[1]??i[2]).length;t.splice(e,1,r.slice(0,n),r.slice(n))}}return t}Object.defineProperty(exports,`capitalCaseTransformFactory`,{enumerable:!0,get:function(){return c}}),Object.defineProperty(exports,`pascalCaseTransformFactory`,{enumerable:!0,get:function(){return l}}),Object.defineProperty(exports,`splitPrefixSuffix`,{enumerable:!0,get:function(){return o}});

package/dist/case.transform-DJYiGJG0.js

@@ -1,2 +0,0 @@
-const e=/([\p{Ll}\d])(\p{Lu})/gu,t=/(\p{Lu})(\p{Lu}\p{Ll})/gu,n=/(\d)\p{Ll}|(\p{L})\d/u,r=/[^\p{L}\d]+/giu,i=`$1\0$2`;function a(e,t={}){let n=t.splitFn??(t.separateNumbers?l:o),r=t.prefixCharacters??``,i=t.suffixCharacters??``,a=0,s=e.length;for(;a<e.length;){let t=e.charAt(a);if(!r.includes(t))break;a++}for(;s>a;){let t=s-1,n=e.charAt(t);if(!i.includes(n))break;s=t}return[e.slice(0,a),n(e.slice(a,s)),e.slice(s)]}function o(n){let a=n.trim();a=a.replace(e,i).replace(t,i),a=a.replace(r,`\0`);let o=0,s=a.length;for(;a.charAt(o)===`\0`;)o++;if(o===s)return[];for(;a.charAt(s-1)===`\0`;)s--;return a.slice(o,s).split(/\0/)}function s(){return e=>e[0].toUpperCase()+e.slice(1).toLowerCase()}function c(){return(e,t)=>{let n=e[0];return(t>0&&n>=`0`&&n<=`9`?`_${n}`:n.toUpperCase())+e.slice(1).toLowerCase()}}function l(e){let t=o(e);for(let e=0;e<t.length;e++){let r=t[e],i=n.exec(r);if(i){let n=i.index+(i[1]??i[2]).length;t.splice(e,1,r.slice(0,n),r.slice(n))}}return t}export{s as capitalCaseTransformFactory,c as pascalCaseTransformFactory,a as splitPrefixSuffix};
-//# sourceMappingURL=case.transform-DJYiGJG0.js.map

package/dist/case.transform-DJYiGJG0.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"case.transform-DJYiGJG0.js","names":[],"sources":["../src/internal/case.transform.ts"],"sourcesContent":["import type { ChangeCaseOptions } from './case.types';\n\n// Regexps involved with splitting words in various case formats.\nconst SPLIT_LOWER_UPPER_RE = /([\\p{Ll}\\d])(\\p{Lu})/gu;\nconst SPLIT_UPPER_UPPER_RE = /(\\p{Lu})(\\p{Lu}\\p{Ll})/gu;\n\n// Used to iterate over the initial split result and separate numbers.\nconst SPLIT_SEPARATE_NUMBER_RE = /(\\d)\\p{Ll}|(\\p{L})\\d/u;\n\n// Regexp involved with stripping non-word characters from the result.\nconst DEFAULT_STRIP_REGEXP = /[^\\p{L}\\d]+/giu;\n\n// The replacement value for splits.\nconst SPLIT_REPLACE_VALUE = '$1\\0$2';\n\n// The default characters to keep after transforming case.\nconst DEFAULT_PREFIX_SUFFIX_CHARACTERS = '';\n\nexport function splitPrefixSuffix(\n  input: string,\n  options: ChangeCaseOptions = {},\n): [string, Array<string>, string] {\n  const splitFn = options.splitFn ?? (\n    options.separateNumbers\n      ? splitSeparateNumbers\n      : splitImplementation\n  );\n  const prefixCharacters\n    = options.prefixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;\n  const suffixCharacters\n    = options.suffixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;\n  let prefixIndex = 0;\n  let suffixIndex = input.length;\n\n  while (prefixIndex < input.length) {\n    const char = input.charAt(prefixIndex);\n    if (!prefixCharacters.includes(char)) {\n      break;\n    }\n    prefixIndex++;\n  }\n\n  while (suffixIndex > prefixIndex) {\n    const index = suffixIndex - 1;\n    const char = input.charAt(index);\n    if (!suffixCharacters.includes(char)) {\n      break;\n    }\n    suffixIndex = index;\n  }\n\n  return [\n    input.slice(0, prefixIndex),\n    splitFn(input.slice(prefixIndex, suffixIndex)),\n    input.slice(suffixIndex),\n  ];\n}\n\n/**\n * Split any cased input strings into an array of words.\n */\nexport function splitImplementation(value: string): Array<string> {\n  let result = value.trim();\n\n  result = result\n    .replace(SPLIT_LOWER_UPPER_RE, SPLIT_REPLACE_VALUE)\n    .replace(SPLIT_UPPER_UPPER_RE, SPLIT_REPLACE_VALUE);\n\n  result = result.replace(DEFAULT_STRIP_REGEXP, '\\0');\n\n  let start = 0;\n  let end = result.length;\n\n  // Trim the delimiter from around the output string.\n  while (result.charAt(start) === '\\0') {\n    start++;\n  }\n\n  if (start === end) {\n    return [];\n  }\n\n  while (result.charAt(end - 1) === '\\0') {\n    end--;\n  }\n\n  return result.slice(start, end).split(/\\0/);\n}\n\nexport function capitalCaseTransformFactory() {\n  return (word: string): string => word[0]!.toUpperCase() + word.slice(1).toLowerCase();\n}\n\nexport function pascalCaseTransformFactory() {\n  return (word: string, index: number): string => {\n    const char0 = word[0]!;\n    const initial = index > 0 && char0 >= '0' && char0 <= '9'\n      ? `_${char0}`\n      : char0.toUpperCase();\n    return initial + word.slice(1).toLowerCase();\n  };\n}\n\n/**\n * Split the input string into an array of words, separating numbers.\n */\nexport function splitSeparateNumbers(value: string): Array<string> {\n  const words = splitImplementation(value);\n  for (let i = 0; i < words.length; i++) {\n    const word = words[i]!;\n    const match = SPLIT_SEPARATE_NUMBER_RE.exec(word);\n    if (match) {\n      const offset = match.index + (match[1] ?? match[2])!.length;\n      words.splice(i, 1, word.slice(0, offset), word.slice(offset));\n    }\n  }\n  return words;\n}\n"],"mappings":"AAGA,MAAM,EAAuB,yBACvB,EAAuB,2BAGvB,EAA2B,wBAG3B,EAAuB,iBAGvB,EAAsB,SAK5B,SAAgB,EACd,EACA,EAA6B,EAAE,CACE,CACjC,IAAM,EAAU,EAAQ,UACtB,EAAQ,gBACJ,EACA,GAEA,EACF,EAAQ,kBAAoB,GAC1B,EACF,EAAQ,kBAAoB,GAC5B,EAAc,EACd,EAAc,EAAM,OAExB,KAAO,EAAc,EAAM,QAAQ,CACjC,IAAM,EAAO,EAAM,OAAO,EAAY,CACtC,GAAI,CAAC,EAAiB,SAAS,EAAK,CAClC,MAEF,IAGF,KAAO,EAAc,GAAa,CAChC,IAAM,EAAQ,EAAc,EACtB,EAAO,EAAM,OAAO,EAAM,CAChC,GAAI,CAAC,EAAiB,SAAS,EAAK,CAClC,MAEF,EAAc,EAGhB,MAAO,CACL,EAAM,MAAM,EAAG,EAAY,CAC3B,EAAQ,EAAM,MAAM,EAAa,EAAY,CAAC,CAC9C,EAAM,MAAM,EAAY,CACzB,CAMH,SAAgB,EAAoB,EAA8B,CAChE,IAAI,EAAS,EAAM,MAAM,CAEzB,EAAS,EACN,QAAQ,EAAsB,EAAoB,CAClD,QAAQ,EAAsB,EAAoB,CAErD,EAAS,EAAO,QAAQ,EAAsB,KAAK,CAEnD,IAAI,EAAQ,EACR,EAAM,EAAO,OAGjB,KAAO,EAAO,OAAO,EAAM,GAAK,MAC9B,IAGF,GAAI,IAAU,EACZ,MAAO,EAAE,CAGX,KAAO,EAAO,OAAO,EAAM,EAAE,GAAK,MAChC,IAGF,OAAO,EAAO,MAAM,EAAO,EAAI,CAAC,MAAM,KAAK,CAG7C,SAAgB,GAA8B,CAC5C,MAAQ,IAAyB,EAAK,GAAI,aAAa,CAAG,EAAK,MAAM,EAAE,CAAC,aAAa,CAGvF,SAAgB,GAA6B,CAC3C,OAAQ,EAAc,IAA0B,CAC9C,IAAM,EAAQ,EAAK,GAInB,OAHgB,EAAQ,GAAK,GAAS,KAAO,GAAS,IAClD,IAAI,IACJ,EAAM,aAAa,EACN,EAAK,MAAM,EAAE,CAAC,aAAa,EAOhD,SAAgB,EAAqB,EAA8B,CACjE,IAAM,EAAQ,EAAoB,EAAM,CACxC,IAAK,IAAI,EAAI,EAAG,EAAI,EAAM,OAAQ,IAAK,CACrC,IAAM,EAAO,EAAM,GACb,EAAQ,EAAyB,KAAK,EAAK,CACjD,GAAI,EAAO,CACT,IAAM,EAAS,EAAM,OAAS,EAAM,IAAM,EAAM,IAAK,OACrD,EAAM,OAAO,EAAG,EAAG,EAAK,MAAM,EAAG,EAAO,CAAE,EAAK,MAAM,EAAO,CAAC,EAGjE,OAAO"}

package/dist/case.types-D-4qwVN-.d.cts

@@ -1,19 +0,0 @@
-//#region src/internal/case.types.d.ts
-
-/**
- * Options used for converting strings to any case.
- */
-interface ChangeCaseOptions {
-  delimiter?: string;
-  /**
-   * Options used for converting strings to pascal/camel case.
-   */
-  mergeAmbiguousCharacters?: boolean;
-  prefixCharacters?: string;
-  separateNumbers?: boolean;
-  splitFn?: (value: string) => Array<string>;
-  suffixCharacters?: string;
-}
-//#endregion
-export { ChangeCaseOptions };
-//# sourceMappingURL=case.types-D-4qwVN-.d.cts.map

package/dist/case.types-D-4qwVN-.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"case.types-D-4qwVN-.d.cts","names":[],"sources":["../src/internal/case.types.ts"],"sourcesContent":[],"mappings":";;;;;UAUiB,iBAAA;;;;;;;;+BAQc"}

package/dist/case.types-D5NB5m6p.d.ts

@@ -1,19 +0,0 @@
-//#region src/internal/case.types.d.ts
-
-/**
- * Options used for converting strings to any case.
- */
-interface ChangeCaseOptions {
-  delimiter?: string;
-  /**
-   * Options used for converting strings to pascal/camel case.
-   */
-  mergeAmbiguousCharacters?: boolean;
-  prefixCharacters?: string;
-  separateNumbers?: boolean;
-  splitFn?: (value: string) => Array<string>;
-  suffixCharacters?: string;
-}
-//#endregion
-export { ChangeCaseOptions };
-//# sourceMappingURL=case.types-D5NB5m6p.d.ts.map

package/dist/case.types-D5NB5m6p.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"case.types-D5NB5m6p.d.ts","names":[],"sources":["../src/internal/case.types.ts"],"sourcesContent":[],"mappings":";;;;;UAUiB,iBAAA;;;;;;;;+BAQc"}

package/dist/ceil--cMT2iUp.js

@@ -1,2 +0,0 @@
-import{curry as e}from"./curry-CzZjDrpv.js";import{withPrecision as t}from"./with-precision-BoiuafbM.js";function n(...n){return e(t(Math.ceil),n)}export{n as ceil};
-//# sourceMappingURL=ceil--cMT2iUp.js.map

package/dist/ceil--cMT2iUp.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ceil--cMT2iUp.js","names":[],"sources":["../src/ceil.ts"],"sourcesContent":["import { curry } from './curry';\nimport { withPrecision } from './internal/with-precision';\n\n/**\n * Rounds up a given number to a specific precision.\n * If you'd like to round up to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.ceil` instead, as it won't incur the additional library overhead.\n *\n * @param value - The number to round up.\n * @param precision - The precision to round up to. Must be an integer between -15 and 15.\n * @signature\n *    P.ceil(value, precision);\n * @example\n *    P.ceil(123.9876, 3) // => 123.988\n *    P.ceil(483.22243, 1) // => 483.3\n *    P.ceil(8541, -1) // => 8550\n *    P.ceil(456789, -3) // => 457000\n * @dataFirst\n * @category Number\n */\nexport function ceil(value: number, precision: number): number;\n\n/**\n * Rounds up a given number to a specific precision.\n * If you'd like to round up to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.ceil` instead, as it won't incur the additional library overhead.\n *\n * @param precision - The precision to round up to. Must be an integer between -15 and 15.\n * @signature\n *    P.ceil(precision)(value);\n * @example\n *    P.ceil(3)(123.9876) // => 123.988\n *    P.ceil(1)(483.22243) // => 483.3\n *    P.ceil(-1)(8541) // => 8550\n *    P.ceil(-3)(456789) // => 457000\n * @dataLast\n * @category Number\n */\nexport function ceil(precision: number): (value: number) => number;\n\nexport function ceil(...args: ReadonlyArray<unknown>): unknown {\n  return curry(withPrecision(Math.ceil), args);\n}\n"],"mappings":"yGAwCA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAc,KAAK,KAAK,CAAE,EAAK"}

package/dist/ceil-BfPd1zim.d.cts

@@ -1,39 +0,0 @@
-//#region src/ceil.d.ts
-/**
- * Rounds up a given number to a specific precision.
- * If you'd like to round up to an integer (i.e. use this function with constant `precision === 0`),
- * use `Math.ceil` instead, as it won't incur the additional library overhead.
- *
- * @param value - The number to round up.
- * @param precision - The precision to round up to. Must be an integer between -15 and 15.
- * @signature
- *    P.ceil(value, precision);
- * @example
- *    P.ceil(123.9876, 3) // => 123.988
- *    P.ceil(483.22243, 1) // => 483.3
- *    P.ceil(8541, -1) // => 8550
- *    P.ceil(456789, -3) // => 457000
- * @dataFirst
- * @category Number
- */
-declare function ceil(value: number, precision: number): number;
-/**
- * Rounds up a given number to a specific precision.
- * If you'd like to round up to an integer (i.e. use this function with constant `precision === 0`),
- * use `Math.ceil` instead, as it won't incur the additional library overhead.
- *
- * @param precision - The precision to round up to. Must be an integer between -15 and 15.
- * @signature
- *    P.ceil(precision)(value);
- * @example
- *    P.ceil(3)(123.9876) // => 123.988
- *    P.ceil(1)(483.22243) // => 483.3
- *    P.ceil(-1)(8541) // => 8550
- *    P.ceil(-3)(456789) // => 457000
- * @dataLast
- * @category Number
- */
-declare function ceil(precision: number): (value: number) => number;
-//#endregion
-export { ceil };
-//# sourceMappingURL=ceil-BfPd1zim.d.cts.map

package/dist/ceil-BfPd1zim.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ceil-BfPd1zim.d.cts","names":[],"sources":["../src/ceil.ts"],"sourcesContent":[],"mappings":";;AAoBA;AAkBA;;;;;;;;;;;;;;;iBAlBgB,IAAA;;;;;;;;;;;;;;;;;iBAkBA,IAAA"}

package/dist/ceil-CgjlA1iG.cjs

@@ -1 +0,0 @@
-const e=require(`./curry-BPVIsvo3.cjs`),t=require(`./with-precision-BgF-Y_mF.cjs`);function n(...n){return e.curry(t.withPrecision(Math.ceil),n)}Object.defineProperty(exports,`ceil`,{enumerable:!0,get:function(){return n}});

package/dist/ceil-t6jtFzmr.d.ts

@@ -1,39 +0,0 @@
-//#region src/ceil.d.ts
-/**
- * Rounds up a given number to a specific precision.
- * If you'd like to round up to an integer (i.e. use this function with constant `precision === 0`),
- * use `Math.ceil` instead, as it won't incur the additional library overhead.
- *
- * @param value - The number to round up.
- * @param precision - The precision to round up to. Must be an integer between -15 and 15.
- * @signature
- *    P.ceil(value, precision);
- * @example
- *    P.ceil(123.9876, 3) // => 123.988
- *    P.ceil(483.22243, 1) // => 483.3
- *    P.ceil(8541, -1) // => 8550
- *    P.ceil(456789, -3) // => 457000
- * @dataFirst
- * @category Number
- */
-declare function ceil(value: number, precision: number): number;
-/**
- * Rounds up a given number to a specific precision.
- * If you'd like to round up to an integer (i.e. use this function with constant `precision === 0`),
- * use `Math.ceil` instead, as it won't incur the additional library overhead.
- *
- * @param precision - The precision to round up to. Must be an integer between -15 and 15.
- * @signature
- *    P.ceil(precision)(value);
- * @example
- *    P.ceil(3)(123.9876) // => 123.988
- *    P.ceil(1)(483.22243) // => 483.3
- *    P.ceil(-1)(8541) // => 8550
- *    P.ceil(-3)(456789) // => 457000
- * @dataLast
- * @category Number
- */
-declare function ceil(precision: number): (value: number) => number;
-//#endregion
-export { ceil };
-//# sourceMappingURL=ceil-t6jtFzmr.d.ts.map

package/dist/ceil-t6jtFzmr.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ceil-t6jtFzmr.d.ts","names":[],"sources":["../src/ceil.ts"],"sourcesContent":[],"mappings":";;AAoBA;AAkBA;;;;;;;;;;;;;;;iBAlBgB,IAAA;;;;;;;;;;;;;;;;;iBAkBA,IAAA"}

package/dist/chunk-C__yw06N.d.cts

@@ -1,76 +0,0 @@
-import { IntRangeInclusive } from "./int-range-inclusive-DZG3R2Xl.cjs";
-import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
-import { NTuple } from "./n-tuple-Co_jgwEn.cjs";
-import { NonEmptyArray } from "./non-empty-array-D3ZRHApS.cjs";
-import { PartialArray } from "./partial-array-CzOnr197.cjs";
-import { TupleParts } from "./tuple-parts-BIyABPYv.cjs";
-import { IntRange, IsNever, IsNumericLiteral, LessThan, Subtract, ValueOf } from "type-fest";
-
-//#region src/chunk.d.ts
-
-/**
- * This prevents typescript from failing on complex arrays and large chunks.
- * It allows the typing to remain useful even when very large chunks are needed,
- * without loosing fidelity on smaller ones. It was chosen by trial-and-error,
- * and given some more wiggle room because the complexity of the array also
- * plays a role in when typescript fails to recurse.
- * See the type tests for an example.
- */
-type MAX_LITERAL_SIZE = 350;
-type Chunk<T extends IterableContainer, N extends number> = T extends readonly [] ? [] : IsNumericLiteral<N> extends true ? LessThan<N, 1> extends true ? never : LessThan<N, MAX_LITERAL_SIZE> extends true ? [...LiteralChunk<T, N>] : GenericChunk<T> : GenericChunk<T>;
-type LiteralChunk<T extends IterableContainer, N extends number> = ChunkRestElement<ChunkFixedTuple<TuplePrefix<T>, N>, TupleParts<T>['item'], TupleParts<T>['suffix'], N> | ([...TuplePrefix<T>, ...TupleParts<T>['suffix']] extends readonly [] ? [] : never);
-/**
- * This type **only** works if the input array `T` is a fixed tuple. For these
- * inputs the chunked output could be computed as literal finite tuples too.
- */
-type ChunkFixedTuple<T, N extends number, Result = []> = T extends readonly [infer Head, ...infer Rest] ? ChunkFixedTuple<Rest, N, Result extends [...infer Previous extends Array<Array<unknown>>, infer Current extends Array<unknown>] ? Current['length'] extends N ? [...Previous, Current, [Head]] : [...Previous, [...Current, Head]] : [[Head]]> : Result;
-/**
- * Here lies the main complexity of building the chunk type. It takes the prefix
- * chunks, the rest param item type, and the suffix (not chunked!) and it
- * creates all possible combinations of adding items to the prefix and suffix
- * for all possible scenarios for how many items the rest param "represents".
- */
-type ChunkRestElement<PrefixChunks, Item, Suffix extends Array<unknown>, N extends number> = IsNever<Item> extends true ? PrefixChunks : PrefixChunks extends [...infer PrefixFullChunks extends Array<Array<unknown>>, infer LastPrefixChunk extends Array<unknown>] ? ValueOf<{ [Padding in IntRangeInclusive<0, Subtract<N, LastPrefixChunk['length']>>]: [...PrefixFullChunks, ...ChunkFixedTuple<[...LastPrefixChunk, ...NTuple<Item, Padding>, ...Suffix], N>] }> | [...PrefixFullChunks, [...LastPrefixChunk, ...NTuple<Item, Subtract<N, LastPrefixChunk['length']>>], ...Array<NTuple<Item, N>>, ...SuffixChunk<Suffix, Item, N>] : [...Array<NTuple<Item, N>>, ...SuffixChunk<Suffix, Item, N>];
-/**
- * This type assumes it takes a finite tuple that represents the suffix of our
- * input array. It builds all possible combinations of adding items to the
- * **head** of the suffix in order to pad the suffix until the last chunk is
- * full.
- */
-type SuffixChunk<T extends Array<unknown>, Item, N extends number> = T extends readonly [] ? [ValueOf<{ [K in IntRangeInclusive<1, N>]: NTuple<Item, K> }>] : ValueOf<{ [Padding in IntRange<0, N>]: ChunkFixedTuple<[...NTuple<Item, Padding>, ...T], N> }>;
-/**
- * This is the legacy type used when we don't know what N is. We can only adjust
- * our output based on if we know for sure that the array is empty or not.
- */
-type GenericChunk<T extends IterableContainer> = T extends readonly [...Array<unknown>, unknown] | readonly [unknown, ...Array<unknown>] ? NonEmptyArray<NonEmptyArray<T[number]>> : Array<NonEmptyArray<T[number]>>;
-type TuplePrefix<T extends IterableContainer> = [...TupleParts<T>['required'], ...PartialArray<TupleParts<T>['optional']>];
-/**
- * Split an array into groups the length of `size`. If `array` can't be split evenly, the final chunk will be the remaining elements.
- *
- * @param array - The array.
- * @param size - The length of the chunk.
- * @signature
- *    P.chunk(array, size)
- * @example
- *    P.chunk(['a', 'b', 'c', 'd'], 2) // => [['a', 'b'], ['c', 'd']]
- *    P.chunk(['a', 'b', 'c', 'd'], 3) // => [['a', 'b', 'c'], ['d']]
- * @dataFirst
- * @category Array
- */
-declare function chunk<T extends IterableContainer, N extends number>(array: T, size: N): Chunk<T, N>;
-/**
- * Split an array into groups the length of `size`. If `array` can't be split evenly, the final chunk will be the remaining elements.
- *
- * @param size - The length of the chunk.
- * @signature
- *    P.chunk(size)(array)
- * @example
- *    P.chunk(2)(['a', 'b', 'c', 'd']) // => [['a', 'b'], ['c', 'd']]
- *    P.chunk(3)(['a', 'b', 'c', 'd']) // => [['a', 'b', 'c'], ['d']]
- * @dataLast
- * @category Array
- */
-declare function chunk<N extends number>(size: N): <T extends IterableContainer>(array: T) => Chunk<T, N>;
-//#endregion
-export { chunk };
-//# sourceMappingURL=chunk-C__yw06N.d.cts.map

package/dist/chunk-C__yw06N.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk-C__yw06N.d.cts","names":[],"sources":["../src/chunk.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/chunk-Hsv7c06B.d.ts

@@ -1,76 +0,0 @@
-import { IntRangeInclusive } from "./int-range-inclusive-DzLDwln0.js";
-import { IterableContainer } from "./iterable-container-F9CDF7ym.js";
-import { NTuple } from "./n-tuple-CU6777y4.js";
-import { NonEmptyArray } from "./non-empty-array-BfTfvDYg.js";
-import { PartialArray } from "./partial-array-DSctnYXY.js";
-import { TupleParts } from "./tuple-parts-Du2iVN8H.js";
-import { IntRange, IsNever, IsNumericLiteral, LessThan, Subtract, ValueOf } from "type-fest";
-
-//#region src/chunk.d.ts
-
-/**
- * This prevents typescript from failing on complex arrays and large chunks.
- * It allows the typing to remain useful even when very large chunks are needed,
- * without loosing fidelity on smaller ones. It was chosen by trial-and-error,
- * and given some more wiggle room because the complexity of the array also
- * plays a role in when typescript fails to recurse.
- * See the type tests for an example.
- */
-type MAX_LITERAL_SIZE = 350;
-type Chunk<T extends IterableContainer, N extends number> = T extends readonly [] ? [] : IsNumericLiteral<N> extends true ? LessThan<N, 1> extends true ? never : LessThan<N, MAX_LITERAL_SIZE> extends true ? [...LiteralChunk<T, N>] : GenericChunk<T> : GenericChunk<T>;
-type LiteralChunk<T extends IterableContainer, N extends number> = ChunkRestElement<ChunkFixedTuple<TuplePrefix<T>, N>, TupleParts<T>['item'], TupleParts<T>['suffix'], N> | ([...TuplePrefix<T>, ...TupleParts<T>['suffix']] extends readonly [] ? [] : never);
-/**
- * This type **only** works if the input array `T` is a fixed tuple. For these
- * inputs the chunked output could be computed as literal finite tuples too.
- */
-type ChunkFixedTuple<T, N extends number, Result = []> = T extends readonly [infer Head, ...infer Rest] ? ChunkFixedTuple<Rest, N, Result extends [...infer Previous extends Array<Array<unknown>>, infer Current extends Array<unknown>] ? Current['length'] extends N ? [...Previous, Current, [Head]] : [...Previous, [...Current, Head]] : [[Head]]> : Result;
-/**
- * Here lies the main complexity of building the chunk type. It takes the prefix
- * chunks, the rest param item type, and the suffix (not chunked!) and it
- * creates all possible combinations of adding items to the prefix and suffix
- * for all possible scenarios for how many items the rest param "represents".
- */
-type ChunkRestElement<PrefixChunks, Item, Suffix extends Array<unknown>, N extends number> = IsNever<Item> extends true ? PrefixChunks : PrefixChunks extends [...infer PrefixFullChunks extends Array<Array<unknown>>, infer LastPrefixChunk extends Array<unknown>] ? ValueOf<{ [Padding in IntRangeInclusive<0, Subtract<N, LastPrefixChunk['length']>>]: [...PrefixFullChunks, ...ChunkFixedTuple<[...LastPrefixChunk, ...NTuple<Item, Padding>, ...Suffix], N>] }> | [...PrefixFullChunks, [...LastPrefixChunk, ...NTuple<Item, Subtract<N, LastPrefixChunk['length']>>], ...Array<NTuple<Item, N>>, ...SuffixChunk<Suffix, Item, N>] : [...Array<NTuple<Item, N>>, ...SuffixChunk<Suffix, Item, N>];
-/**
- * This type assumes it takes a finite tuple that represents the suffix of our
- * input array. It builds all possible combinations of adding items to the
- * **head** of the suffix in order to pad the suffix until the last chunk is
- * full.
- */
-type SuffixChunk<T extends Array<unknown>, Item, N extends number> = T extends readonly [] ? [ValueOf<{ [K in IntRangeInclusive<1, N>]: NTuple<Item, K> }>] : ValueOf<{ [Padding in IntRange<0, N>]: ChunkFixedTuple<[...NTuple<Item, Padding>, ...T], N> }>;
-/**
- * This is the legacy type used when we don't know what N is. We can only adjust
- * our output based on if we know for sure that the array is empty or not.
- */
-type GenericChunk<T extends IterableContainer> = T extends readonly [...Array<unknown>, unknown] | readonly [unknown, ...Array<unknown>] ? NonEmptyArray<NonEmptyArray<T[number]>> : Array<NonEmptyArray<T[number]>>;
-type TuplePrefix<T extends IterableContainer> = [...TupleParts<T>['required'], ...PartialArray<TupleParts<T>['optional']>];
-/**
- * Split an array into groups the length of `size`. If `array` can't be split evenly, the final chunk will be the remaining elements.
- *
- * @param array - The array.
- * @param size - The length of the chunk.
- * @signature
- *    P.chunk(array, size)
- * @example
- *    P.chunk(['a', 'b', 'c', 'd'], 2) // => [['a', 'b'], ['c', 'd']]
- *    P.chunk(['a', 'b', 'c', 'd'], 3) // => [['a', 'b', 'c'], ['d']]
- * @dataFirst
- * @category Array
- */
-declare function chunk<T extends IterableContainer, N extends number>(array: T, size: N): Chunk<T, N>;
-/**
- * Split an array into groups the length of `size`. If `array` can't be split evenly, the final chunk will be the remaining elements.
- *
- * @param size - The length of the chunk.
- * @signature
- *    P.chunk(size)(array)
- * @example
- *    P.chunk(2)(['a', 'b', 'c', 'd']) // => [['a', 'b'], ['c', 'd']]
- *    P.chunk(3)(['a', 'b', 'c', 'd']) // => [['a', 'b', 'c'], ['d']]
- * @dataLast
- * @category Array
- */
-declare function chunk<N extends number>(size: N): <T extends IterableContainer>(array: T) => Chunk<T, N>;
-//#endregion
-export { chunk };
-//# sourceMappingURL=chunk-Hsv7c06B.d.ts.map

package/dist/chunk-Hsv7c06B.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk-Hsv7c06B.d.ts","names":[],"sources":["../src/chunk.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;AAa+D;AAW1C;;;;;KAAhB,gBAAA,GAOD,GAAA;KALC,KAMU,CAAA,UALH,iBAKG,EAAA,UAAA,MAAA,CAAA,GAHX,CAGW,SAAA,SAAA,EAAA,GAAA,EAAA,GADX,gBACW,CADM,CACN,CAAA,SAAA,IAAA,GAAT,QAAS,CAAA,CAAA,EAAA,CAAA,CAAA,SAAA,IAAA,GAAA,KAAA,GAEP,QAFO,CAEE,CAFF,EAEK,gBAFL,CAAA,SAAA,IAAA,GAAA,CAAA,GAKD,YALC,CAKY,CALZ,EAKe,CALf,CAAA,CAAA,GAML,YANK,CAMQ,CANR,CAAA,GAOT,YAPS,CAOI,CAPJ,CAAA;KASV,YATC,CAAA,UASsB,iBATtB,EAAA,UAAA,MAAA,CAAA,GAUA,gBAVA,CAaA,eAbA,CAagB,WAbhB,CAa4B,CAb5B,CAAA,EAagC,CAbhC,CAAA,EAcA,UAdA,CAcW,CAdX,CAAA,CAAA,MAAA,CAAA,EAeA,UAfA,CAeW,CAfX,CAAA,CAAA,QAAA,CAAA,EAgBA,CAhBA,CAAA,GAAA,CAAA,CAAA,GAqBK,WArBL,CAqBiB,CArBjB,CAAA,EAAA,GAqBwB,UArBxB,CAqBmC,CArBnC,CAAA,CAAA,QAAA,CAAA,CAAA,SAAA,SAAA,EAAA,GAAA,EAAA,GAAA,KAAA,CAAA;;;;;KA6BD,eAxByB,CAAA,CAAA,EAAA,UAAA,MAAA,EAAA,SAAA,EAAA,CAAA,GA8B1B,CA9B0B,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAgC1B,eAhC0B,CAiCxB,IAjCwB,EAkCxB,CAlCwB,EAmCxB,MAnCwB,SAAA,IAAhB,KAAA,kBAoCoB,KApCpB,CAoC0B,KApC1B,CAAA,OAAA,CAAA,CAAA,OACS,iBAoCO,KApCP,CAAA,OAAA,CAAA,IAyCb,OAzCA,CAAA,QAAA,CAAA,SAyC0B,CAzC1B,GAAA,CAAA,GA2CM,QA3CN,EA2CgB,OA3ChB,EAAA,CA2C0B,IA3C1B,CAAA,CAAA,GAAA,CAAA,GA6CM,QA7CN,EAAA,CAAA,GA6CoB,OA7CpB,EA6C6B,IA7C7B,CAAA,CAAA,GAAA,CAAA,CAiDE,IAjDF,CAAA,CAAA,CAAA,GAsDN,MAtDM;;;;AACQ;;;KA6Db,gBAvD6B,CAAA,YAAA,EAAA,IAAA,EAAA,eA0DjB,KA1DiB,CAAA,OAAA,CAAA,EAAA,UAAA,MAAA,CAAA,GA6D9B,OA7D8B,CA6DtB,IA7DsB,CAAA,SAAA,IAAA,GAiE5B,YAjE4B,GAkE5B,YAlE4B,SAAA,IAAZ,KAAA,0BAmEkB,KAnElB,CAmEwB,KAnExB,CAAA,OAAA,CAAA,CAAA,OAAgB,yBAoEF,KApEE,CAAA,OAAA,CAAA,IAyE5B,OAzEJ,CAAA,cA+Ec,iBA9EH,CAAA,CAAA,EAgFD,QAhFC,CAgFQ,CAhFR,EAgFW,eAhFX,CAAA,QAAA,CAAA,CAAA,CAAA,GAAA,CAAX,GAkFO,gBAlFP,EACW,GAkFJ,eAlFI,CAAA,CAAX,GAsFgB,eAtFhB,EACA,GAqFoC,MArFpC,CAqF2C,IArF3C,EAqFiD,OArFjD,CAAA,EANA,GA2F8D,MA3F9D,CAWiB,EAiFL,CAjFK,CAAA,WA0FZ,gBA1FmB,EAAU,CAQnC,GAqFQ,eArFO,EAAA,GAsFP,MAtFO,CAsFA,IAtFA,EAsFM,QAtFN,CAsFe,CAtFf,EAsFkB,eAtFlB,CAAA,QAAA,CAAA,CAAA,CAAA,MAwFT,KA/EL,CA+EW,MA/EX,CA+EkB,IA/ElB,EA+EwB,CA/ExB,CAAA,CAAA,KAgFK,WA/EL,CA+EiB,MA/EjB,EA+EyB,IA/EzB,EA+E+B,CA/E/B,CAAA,QAkFM,KAjFN,CAiFY,MAjFZ,CAiFmB,IAjFnB,EAiFyB,CAjFzB,CAAA,CAAA,EAAA,GAiFiC,WAjFjC,CAiF6C,MAjF7C,EAiFqD,IAjFrD,EAiF2D,CAjF3D,CAAA,CAAA;;;;;;;KAyFD,WAhFqB,CAAA,UAiFd,KAjFc,CAAA,OAAA,CAAA,EAAA,IAAA,EAAA,UAAA,MAAA,CAAA,GAoFtB,CApFsB,SAAA,SAAA,EAAA,GAAA,CAuFrB,OAvFqB,CAAA,QAuFL,iBAvFe,CAAA,CAAA,EAuFM,CAvFN,CAAA,GAuFW,MAvFX,CAuFkB,IAvFlB,EAuFwB,CAvFxB,CAAA,OAwFhC,OAtFY,CAAA,cAyFA,QAzFc,CAAA,CAAA,EAyFF,CAzFE,CAAA,GAyFG,eAzFH,CAAA,CAAS,GA0F7B,MA1F6B,CA0FtB,IA1FsB,EA0FhB,OA1FgB,CAAA,EAI3B,GAsFwB,CAtFxB,GAuFN,CAzGF,CAAA;;AAuBM;;;KA0FL,YA5EO,CAAA,UA4EgB,iBA5EhB,CAAA,GA4EqC,CA5ErC,SAAA,SAAA,CAAA,GA6EK,KA7EL,CAAA,OAAA,CAAA,EAAA,OAAA,CAAA,GAAA,SAAA,CAAA,OAAA,EAAA,GA8Ec,KA9Ed,CAAA,OAAA,CAAA,CAAA,GA+ER,aA/EQ,CA+EM,aA/EN,CA+EoB,CA/EpB,CAAA,MAAA,CAAA,CAAA,CAAA,GAgFR,KAhFQ,CAgFF,aAhFE,CAgFY,CAhFZ,CAAA,MAAA,CAAA,CAAA,CAAA;KAmFP,WAnFD,CAAA,UAmFuB,iBAnFvB,CAAA,GAAA,IAoFC,UAhFC,CAgFU,CAhFV,CAAA,CAAA,UAAA,CAAA,KAiFD,YAhFC,CAgFY,UAhFZ,CAgFuB,CAhFvB,CAAA,CAAA,UAAA,CAAA,CAAA;;;;;;;;;;;;;;AAkBO,iBA8EG,KA9EH,CAAA,UA8EmB,iBA9EnB,EAAA,UAAA,MAAA,CAAA,CAAA,KAAA,EA+EJ,CA/EI,EAAA,IAAA,EAgFL,CAhFK,CAAA,EAiFV,KAjFU,CAiFJ,CAjFI,EAiFD,CAjFC,CAAA;;;;;;;;;;;;;AAqBU,iBA0EP,KA1EO,CAAA,UAAA,MAAA,CAAA,CAAA,IAAA,EA2Ef,CA3Ee,CAAA,EAAA,CAAA,UA4ET,iBA5ES,CAAA,CAAA,KAAA,EA4EiB,CA5EjB,EAAA,GA4EuB,KA5EvB,CA4E6B,CA5E7B,EA4EgC,CA5EhC,CAAA"}

package/dist/chunk-_kldYmb1.cjs

@@ -1 +0,0 @@
-const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){if(t<1)throw RangeError(`chunk: A chunk size of '${t}' would result in an infinite array`);if(e.length===0)return[];if(t>=e.length)return[[...e]];let n=Math.ceil(e.length/t),r=Array(n);if(t===1)for(let[t,n]of e.entries())r[t]=[n];else for(let i=0;i<n;i+=1){let n=i*t;r[i]=e.slice(n,n+t)}return r}Object.defineProperty(exports,`chunk`,{enumerable:!0,get:function(){return t}});

package/dist/chunk-dIPp871Q.js

@@ -1,2 +0,0 @@
-import{curry as e}from"./curry-CzZjDrpv.js";function t(...t){return e(n,t)}function n(e,t){if(t<1)throw RangeError(`chunk: A chunk size of '${t}' would result in an infinite array`);if(e.length===0)return[];if(t>=e.length)return[[...e]];let n=Math.ceil(e.length/t),r=Array(n);if(t===1)for(let[t,n]of e.entries())r[t]=[n];else for(let i=0;i<n;i+=1){let n=i*t;r[i]=e.slice(n,n+t)}return r}export{t as chunk};
-//# sourceMappingURL=chunk-dIPp871Q.js.map

package/dist/chunk-dIPp871Q.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk-dIPp871Q.js","names":[],"sources":["../src/chunk.ts"],"sourcesContent":["import type {\n  IntRange,\n  IsNever,\n  IsNumericLiteral,\n  LessThan,\n  Subtract,\n  ValueOf,\n} from 'type-fest';\nimport type { IntRangeInclusive } from './internal/types/int-range-inclusive';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { NTuple } from './internal/types/n-tuple';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport type { PartialArray } from './internal/types/partial-array';\nimport type { TupleParts } from './internal/types/tuple-parts';\nimport { curry } from './curry';\n\n/**\n * This prevents typescript from failing on complex arrays and large chunks.\n * It allows the typing to remain useful even when very large chunks are needed,\n * without loosing fidelity on smaller ones. It was chosen by trial-and-error,\n * and given some more wiggle room because the complexity of the array also\n * plays a role in when typescript fails to recurse.\n * See the type tests for an example.\n */\ntype MAX_LITERAL_SIZE = 350;\n\ntype Chunk<\n  T extends IterableContainer,\n  N extends number,\n> = T extends readonly []\n  ? []\n  : IsNumericLiteral<N> extends true\n    ? LessThan<N, 1> extends true\n      ? never\n      : LessThan<N, MAX_LITERAL_SIZE> extends true\n        // The spread here is used as a form of \"Simplify\" for arrays; without\n        // it our return type isn't useful.\n        ? [...LiteralChunk<T, N>]\n        : GenericChunk<T>\n    : GenericChunk<T>;\n\ntype LiteralChunk<T extends IterableContainer, N extends number>\n  = | ChunkRestElement<\n      // Our result will always have the prefix tuple chunked the same way, so\n      // we compute it once here and send it to the main logic below\n      ChunkFixedTuple<TuplePrefix<T>, N>,\n      TupleParts<T>['item'],\n      TupleParts<T>['suffix'],\n      N\n    >\n    // If both the prefix and suffix tuples are empty then our input is a simple\n    // array of the form `Array<Item>`. This means it could also be empty, so we\n    // need to add the empty output to our return type.\n    | ([...TuplePrefix<T>, ...TupleParts<T>['suffix']] extends readonly []\n      ? []\n      : never);\n\n/**\n * This type **only** works if the input array `T` is a fixed tuple. For these\n * inputs the chunked output could be computed as literal finite tuples too.\n */\ntype ChunkFixedTuple<\n  T,\n  N extends number,\n  // Important! Result is initialized with an empty array (and not `[[]]`)\n  // because the result of `chunk` on an empty array is `[]` and not `[[]]`.\n  Result = [],\n> = T extends readonly [infer Head, ...infer Rest]\n  // We continue consuming the input tuple recursively item by item.\n  ? ChunkFixedTuple<\n      Rest,\n      N,\n      Result extends [\n        ...infer Previous extends Array<Array<unknown>>,\n        infer Current extends Array<unknown>,\n      ]\n        // We take a look at the last chunk in the result, this is the\n        // \"current\" chunk where new items would be added, all chunks before\n        // it are already full.\n        ? Current['length'] extends N\n          // The current chunk is full, create a new chunk and put Head in it.\n          ? [...Previous, Current, [Head]]\n          // The current chunk is not full yet, so we add Head to it.\n          : [...Previous, [...Current, Head]]\n        // This would only happen on the first iteration, when result is\n        // still empty. In this case we create the first chunk and put Head\n        // in it.\n        : [[Head]]\n    >\n  // We know T is a finite tuple, so the only case where we would reach this\n  // is when T is empty, and in that case our results array contains the whole\n  // input chunked by N.\n  : Result;\n\n/**\n * Here lies the main complexity of building the chunk type. It takes the prefix\n * chunks, the rest param item type, and the suffix (not chunked!) and it\n * creates all possible combinations of adding items to the prefix and suffix\n * for all possible scenarios for how many items the rest param \"represents\".\n */\ntype ChunkRestElement<\n  PrefixChunks,\n  Item,\n  Suffix extends Array<unknown>,\n  N extends number,\n>\n  = IsNever<Item> extends true\n    // The rest param is never when there is no rest param, the whole array is\n    // a finite tuple and is represented already by the prefix chunks. Suffix\n    // is assumed to be empty in this case.\n    ? PrefixChunks\n    : PrefixChunks extends [\n      ...infer PrefixFullChunks extends Array<Array<unknown>>,\n      infer LastPrefixChunk extends Array<unknown>,\n    ]\n      // When our prefix chunks are not empty it means we need to look at all\n      // combinations of mixing the prefix, the suffix, and different counts\n      // of the rest param until we cover all possible scenarios.\n      ? | ValueOf<{\n        // We want to iterate over all possible padding sizes we can add\n        // to the last prefix chunk until we reach N\n        // (`0..N-LastPrefixChunk.length`). We need to do this because\n        // until the last prefix chunk is full, we need to consider the\n        // suffix being part of it too...\n        [Padding in IntRangeInclusive<\n                0,\n                Subtract<N, LastPrefixChunk['length']>\n              >]: [\n          ...PrefixFullChunks,\n          ...ChunkFixedTuple<\n                  // Create a new array that would **not** contain a rest param\n                  // (so it's finite) made of the last prefix chunk, padding\n                  // from the rest param, and the suffix.\n                  [...LastPrefixChunk, ...NTuple<Item, Padding>, ...Suffix],\n                  N\n                >,\n        ];\n      }>\n          // Additionally, we need to consider the case where the last prefix\n          // chunk **is** full, and follow it with an array of chunks of the\n          // rest param (and only them), and then followed by all possible\n          // variations of the suffix chunks.\n      | [\n        ...PrefixFullChunks,\n        [\n          // Fully padded last prefix chunk\n          ...LastPrefixChunk,\n          ...NTuple<Item, Subtract<N, LastPrefixChunk['length']>>,\n        ],\n        ...Array<NTuple<Item, N>>,\n        ...SuffixChunk<Suffix, Item, N>,\n      ]\n      // When our prefix chunks are empty we only need to handle the suffix\n      : [...Array<NTuple<Item, N>>, ...SuffixChunk<Suffix, Item, N>];\n\n/**\n * This type assumes it takes a finite tuple that represents the suffix of our\n * input array. It builds all possible combinations of adding items to the\n * **head** of the suffix in order to pad the suffix until the last chunk is\n * full.\n */\ntype SuffixChunk<\n  T extends Array<unknown>,\n  Item,\n  N extends number,\n> = T extends readonly []\n  // If we don't have a suffix we simply create a single chunk with all\n  // possible non-empty sub-arrays of `Item` up to size `N`.\n  ? [ValueOf<{ [K in IntRangeInclusive<1, N>]: NTuple<Item, K> }>]\n  : ValueOf<{\n    // When suffix isn't empty we pad the head of the suffix and compute it's\n    // chunks for all possible padding sizes.\n    [Padding in IntRange<0, N>]: ChunkFixedTuple<\n      [...NTuple<Item, Padding>, ...T],\n      N\n    >;\n  }>;\n\n/**\n * This is the legacy type used when we don't know what N is. We can only adjust\n * our output based on if we know for sure that the array is empty or not.\n */\ntype GenericChunk<T extends IterableContainer> = T extends\n  | readonly [...Array<unknown>, unknown]\n  | readonly [unknown, ...Array<unknown>]\n  ? NonEmptyArray<NonEmptyArray<T[number]>>\n  : Array<NonEmptyArray<T[number]>>;\n\n// TODO: Chunk was built before we handled optional elements correctly. It needs to be fixed to handle these correctly, specifically in regard to optional elements creating whole chunks that themselves need to be optional, but that their items themselves should not be optional, except the last chunk...\ntype TuplePrefix<T extends IterableContainer> = [\n  ...TupleParts<T>['required'],\n  ...PartialArray<TupleParts<T>['optional']>,\n];\n\n/**\n * Split an array into groups the length of `size`. If `array` can't be split evenly, the final chunk will be the remaining elements.\n *\n * @param array - The array.\n * @param size - The length of the chunk.\n * @signature\n *    P.chunk(array, size)\n * @example\n *    P.chunk(['a', 'b', 'c', 'd'], 2) // => [['a', 'b'], ['c', 'd']]\n *    P.chunk(['a', 'b', 'c', 'd'], 3) // => [['a', 'b', 'c'], ['d']]\n * @dataFirst\n * @category Array\n */\nexport function chunk<T extends IterableContainer, N extends number>(\n  array: T,\n  size: N,\n): Chunk<T, N>;\n\n/**\n * Split an array into groups the length of `size`. If `array` can't be split evenly, the final chunk will be the remaining elements.\n *\n * @param size - The length of the chunk.\n * @signature\n *    P.chunk(size)(array)\n * @example\n *    P.chunk(2)(['a', 'b', 'c', 'd']) // => [['a', 'b'], ['c', 'd']]\n *    P.chunk(3)(['a', 'b', 'c', 'd']) // => [['a', 'b', 'c'], ['d']]\n * @dataLast\n * @category Array\n */\nexport function chunk<N extends number>(\n  size: N,\n): <T extends IterableContainer>(array: T) => Chunk<T, N>;\n\nexport function chunk(...args: ReadonlyArray<unknown>): unknown {\n  return curry(chunkImplementation, args);\n}\n\nfunction chunkImplementation<T>(\n  data: ReadonlyArray<T>,\n  size: number,\n): Array<Array<T>> {\n  if (size < 1) {\n    throw new RangeError(\n      `chunk: A chunk size of '${size}' would result in an infinite array`,\n    );\n  }\n\n  if (data.length === 0) {\n    return [];\n  }\n\n  if (size >= data.length) {\n    // Optimized for when there is only one chunk.\n    return [[...data]];\n  }\n\n  const chunks = Math.ceil(data.length / size);\n\n  // eslint-disable-next-line unicorn/no-new-array -- This is OK, a sparse array allows us to handle very large arrays more efficiently.\n  const result = new Array<Array<T>>(chunks);\n\n  if (size === 1) {\n    // Optimized for when we don't need slice.\n    for (const [index, item] of data.entries()) {\n      result[index] = [item];\n    }\n  } else {\n    for (let index = 0; index < chunks; index += 1) {\n      const start = index * size;\n      result[index] = data.slice(start, start + size);\n    }\n  }\n\n  return result;\n}\n"],"mappings":"4CAoOA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAqB,EAAK,CAGzC,SAAS,EACP,EACA,EACiB,CACjB,GAAI,EAAO,EACT,MAAU,WACR,2BAA2B,EAAK,qCACjC,CAGH,GAAI,EAAK,SAAW,EAClB,MAAO,EAAE,CAGX,GAAI,GAAQ,EAAK,OAEf,MAAO,CAAC,CAAC,GAAG,EAAK,CAAC,CAGpB,IAAM,EAAS,KAAK,KAAK,EAAK,OAAS,EAAK,CAGtC,EAAa,MAAgB,EAAO,CAE1C,GAAI,IAAS,EAEX,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,SAAS,CACxC,EAAO,GAAS,CAAC,EAAK,MAGxB,IAAK,IAAI,EAAQ,EAAG,EAAQ,EAAQ,GAAS,EAAG,CAC9C,IAAM,EAAQ,EAAQ,EACtB,EAAO,GAAS,EAAK,MAAM,EAAO,EAAQ,EAAK,CAInD,OAAO"}

package/dist/clamp-Cnh0Qg03.cjs

@@ -1 +0,0 @@
-const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(n,t)}function n(e,{max:t,min:n}){return n!==void 0&&e<n?n:t!==void 0&&e>t?t:e}Object.defineProperty(exports,`clamp`,{enumerable:!0,get:function(){return t}});

package/dist/clamp-DMX7Ua7I.d.cts

@@ -1,37 +0,0 @@
-//#region src/clamp.d.ts
-interface Limits {
-  readonly max?: number;
-  readonly min?: number;
-}
-/**
- * Clamp the given value within the inclusive min and max bounds.
- *
- * @param value - The number.
- * @param limits - The bounds limits.
- * @signature
- *    P.clamp(value, { min, max });
- * @example
- *    clamp(10, { min: 20 }) // => 20
- *    clamp(10, { max: 5 }) // => 5
- *    clamp(10, { max: 20, min: 5 }) // => 10
- * @dataFirst
- * @category Number
- */
-declare function clamp(value: number, limits: Limits): number;
-/**
- * Clamp the given value within the inclusive min and max bounds.
- *
- * @param limits - The bounds limits.
- * @signature
- *    P.clamp({ min, max })(value);
- * @example
- *    clamp({ min: 20 })(10) // => 20
- *    clamp({ max: 5 })(10) // => 5
- *    clamp({ max: 20, min: 5 })(10) // => 10
- * @dataLast
- * @category Number
- */
-declare function clamp(limits: Limits): (value: number) => number;
-//#endregion
-export { clamp };
-//# sourceMappingURL=clamp-DMX7Ua7I.d.cts.map

package/dist/clamp-DMX7Ua7I.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"clamp-DMX7Ua7I.d.cts","names":[],"sources":["../src/clamp.ts"],"sourcesContent":[],"mappings":";UAEU,MAAA;EAAA,SAAM,GAAA,CAAA,EAAA,MAAA;EAmBA,SAAK,GAAA,CAAA,EAAA,MAAwB;AAe7C;;;;;;;;;;;;;;;iBAfgB,KAAA,wBAA6B;;;;;;;;;;;;;;iBAe7B,KAAA,SAAc"}