@vinicunca/perkakas 1.9.0 → 1.13.0

package/dist/capitalize.d.ts

@@ -0,0 +1,53 @@
+//#region src/capitalize.d.ts
+/**
+ * Makes the first character of a string uppercase while leaving the rest
+ * unchanged.
+ *
+ * It uses the built-in [`String.prototype.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)
+ * for the runtime and the built-in [`Capitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#capitalizestringtype)
+ * utility type for typing and thus shares their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase#description)_.
+ *
+ * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target
+ * just the first letter of the word, and [`text-transform: uppercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#uppercase)
+ * to capitalize it. This transformation **is** locale-aware.
+ *
+ * For other case manipulations see: `toUpperCase`, `toLowerCase`,
+ * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and
+ * `toTitleCase`.
+ *
+ * @param data - A string.
+ * @signature
+ *   P.capitalize(data);
+ * @example
+ *   P.capitalize("hello world"); // "Hello world"
+ * @dataFirst
+ * @category String
+ */
+declare function capitalize<T extends string>(data: T): Capitalize<T>;
+/**
+ * Makes the first character of a string uppercase while leaving the rest
+ * unchanged.
+ *
+ * It uses the built-in [`String.prototype.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)
+ * for the runtime and the built-in [`Capitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#capitalizestringtype)
+ * utility type for typing and thus shares their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase#description)_.
+ *
+ * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target
+ * just the first letter of the word, and [`text-transform: uppercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#uppercase)
+ * to capitalize it. This transformation **is** locale-aware.
+ *
+ * For other case manipulations see: `toUpperCase`, `toLowerCase`,
+ * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and
+ * `toTitleCase`.
+ *
+ * @signature
+ *   P.capitalize()(data);
+ * @example
+ *   P.pipe("hello world", P.capitalize()); // "Hello world"
+ * @dataLast
+ * @category String
+ */
+declare function capitalize(): <T extends string>(data: T) => Capitalize<T>;
+//#endregion
+export { capitalize };
+//# sourceMappingURL=capitalize.d.ts.map

package/dist/capitalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capitalize.d.ts","names":[],"sources":["../src/capitalize.ts"],"sourcesContent":[],"mappings":";;AA0BA;;;;;AAyBA;;;;;;;;;;;;;;;;;;iBAzBgB,mCAAmC,IAAI,WAAW;;;;;;;;;;;;;;;;;;;;;;;;iBAyBlD,UAAA,CAAA,4BAAuC,MAAM,WAAW"}

package/dist/capitalize.js

@@ -0,0 +1,2 @@
+import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e){return`${e[0]?.toUpperCase()??``}${e.slice(1)}`}export{t as capitalize};
+//# sourceMappingURL=capitalize.js.map

package/dist/capitalize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capitalize.js","names":[],"sources":["../src/capitalize.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Makes the first character of a string uppercase while leaving the rest\n * unchanged.\n *\n * It uses the built-in [`String.prototype.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)\n * for the runtime and the built-in [`Capitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#capitalizestringtype)\n * utility type for typing and thus shares their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase#description)_.\n *\n * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target\n * just the first letter of the word, and [`text-transform: uppercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#uppercase)\n * to capitalize it. This transformation **is** locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `toLowerCase`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @param data - A string.\n * @signature\n *   P.capitalize(data);\n * @example\n *   P.capitalize(\"hello world\"); // \"Hello world\"\n * @dataFirst\n * @category String\n */\nexport function capitalize<T extends string>(data: T): Capitalize<T>;\n\n/**\n * Makes the first character of a string uppercase while leaving the rest\n * unchanged.\n *\n * It uses the built-in [`String.prototype.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)\n * for the runtime and the built-in [`Capitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#capitalizestringtype)\n * utility type for typing and thus shares their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase#description)_.\n *\n * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target\n * just the first letter of the word, and [`text-transform: uppercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#uppercase)\n * to capitalize it. This transformation **is** locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `toLowerCase`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @signature\n *   P.capitalize()(data);\n * @example\n *   P.pipe(\"hello world\", P.capitalize()); // \"Hello world\"\n * @dataLast\n * @category String\n */\nexport function capitalize(): <T extends string>(data: T) => Capitalize<T>;\n\nexport function capitalize(...args: ReadonlyArray<unknown>): unknown {\n  return curry(capitalizeImplementation, args);\n}\n\nfunction capitalizeImplementation<T extends string>(data: T): Capitalize<T> {\n  return `${data[0]?.toUpperCase() ?? ''}${data.slice(1)}` as Capitalize<T>;\n}\n"],"mappings":"wCAqDA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAO,EAAM,EAA0B,EAAK,CAG9C,SAAS,EAA2C,EAAwB,CAC1E,MAAO,GAAG,EAAK,IAAI,aAAa,EAAI,KAAK,EAAK,MAAM,EAAE"}

package/dist/ceil.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`),require(`./with-precision-BgF-Y_mF.cjs`);const e=require(`./ceil-CgjlA1iG.cjs`);exports.ceil=e.ceil;
+const e=require(`./curry-BsY0Z8jH.cjs`),t=require(`./with-precision-dQAYLrgr.cjs`);function n(...n){return e.t(t.t(Math.ceil),n)}exports.ceil=n;

package/dist/ceil.d.cts

@@ -1,2 +1,39 @@
-import { ceil } from "./ceil-BfPd1zim.cjs";
-export { ceil };
+//#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.d.cts.map

package/dist/ceil.d.cts.map

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

package/dist/ceil.d.ts

@@ -1,2 +1,39 @@
-import { ceil } from "./ceil-t6jtFzmr.js";
-export { ceil };
+//#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.d.ts.map

package/dist/ceil.d.ts.map

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

package/dist/ceil.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import"./with-precision-BoiuafbM.js";import{ceil as e}from"./ceil--cMT2iUp.js";export{e as ceil};
+import{t as e}from"./curry-NmniqyJ0.js";import{t}from"./with-precision-CQ90Walk.js";function n(...n){return e(t(Math.ceil),n)}export{n as ceil};
+//# sourceMappingURL=ceil.js.map

package/dist/ceil.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ceil.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":"oFAwCA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAc,KAAK,KAAK,CAAE,EAAK"}

package/dist/chunk.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./chunk-_kldYmb1.cjs`);exports.chunk=e.chunk;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(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}exports.chunk=t;

package/dist/chunk.d.cts

@@ -1,9 +1,76 @@
-import "./int-range-inclusive-DZG3R2Xl.cjs";
-import "./iterable-container-V5sa0V_H.cjs";
-import "./n-tuple-Co_jgwEn.cjs";
-import "./non-empty-array-D3ZRHApS.cjs";
-import "./partial-array-CzOnr197.cjs";
-import "./perkakas-type-error-0tHtaPbi.cjs";
-import "./tuple-parts-BIyABPYv.cjs";
-import { chunk } from "./chunk-C__yw06N.cjs";
-export { chunk };
+import { t as IntRangeInclusive } from "./int-range-inclusive-KocNpK0p.cjs";
+import { t as IterableContainer } from "./iterable-container-1TN3AJ3s.cjs";
+import { t as NTuple } from "./n-tuple-BkMobYQ9.cjs";
+import { t as NonEmptyArray } from "./non-empty-array-NDjbHRjk.cjs";
+import { t as PartialArray } from "./partial-array-CQF5oggb.cjs";
+import { t as TupleParts } from "./tuple-parts-CzQQupgi.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.d.cts.map

package/dist/chunk.d.cts.map

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

package/dist/chunk.d.ts

@@ -1,9 +1,76 @@
-import "./int-range-inclusive-DzLDwln0.js";
-import "./iterable-container-F9CDF7ym.js";
-import "./n-tuple-CU6777y4.js";
-import "./non-empty-array-BfTfvDYg.js";
-import "./partial-array-DSctnYXY.js";
-import "./perkakas-type-error-2yBU0Drj.js";
-import "./tuple-parts-Du2iVN8H.js";
-import { chunk } from "./chunk-Hsv7c06B.js";
-export { chunk };
+import { t as IntRangeInclusive } from "./int-range-inclusive-BlGXX6Cz.js";
+import { t as IterableContainer } from "./iterable-container-Dv5vSKht.js";
+import { t as NTuple } from "./n-tuple-zo5g_mSL.js";
+import { t as NonEmptyArray } from "./non-empty-array-DHAKSw6t.js";
+import { t as PartialArray } from "./partial-array-DU-2Vkyx.js";
+import { t as TupleParts } from "./tuple-parts-BYI4o8Vk.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.d.ts.map

package/dist/chunk.d.ts.map

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

package/dist/chunk.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{chunk as e}from"./chunk-dIPp871Q.js";export{e as chunk};
+import{t as e}from"./curry-NmniqyJ0.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.js.map

package/dist/chunk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.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":"wCAoOA,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.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./clamp-Cnh0Qg03.cjs`);exports.clamp=e.clamp;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,{max:t,min:n}){return n!==void 0&&e<n?n:t!==void 0&&e>t?t:e}exports.clamp=t;

package/dist/clamp.d.cts

@@ -1,2 +1,37 @@
-import { clamp } from "./clamp-DMX7Ua7I.cjs";
-export { clamp };
+//#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.d.cts.map

package/dist/clamp.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clamp.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"}

package/dist/clamp.d.ts

@@ -1,2 +1,37 @@
-import { clamp } from "./clamp-D_5sgYkv.js";
-export { clamp };
+//#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.d.ts.map

package/dist/clamp.d.ts.map

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

package/dist/clamp.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{clamp as e}from"./clamp-zR5XX002.js";export{e as clamp};
+import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,{max:t,min:n}){return n!==void 0&&e<n?n:t!==void 0&&e>t?t:e}export{t as clamp};
+//# sourceMappingURL=clamp.js.map

package/dist/clamp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clamp.js","names":[],"sources":["../src/clamp.ts"],"sourcesContent":["import { curry } from './curry';\n\ninterface Limits {\n  readonly max?: number;\n  readonly min?: number;\n}\n\n/**\n * Clamp the given value within the inclusive min and max bounds.\n *\n * @param value - The number.\n * @param limits - The bounds limits.\n * @signature\n *    P.clamp(value, { min, max });\n * @example\n *    clamp(10, { min: 20 }) // => 20\n *    clamp(10, { max: 5 }) // => 5\n *    clamp(10, { max: 20, min: 5 }) // => 10\n * @dataFirst\n * @category Number\n */\nexport function clamp(value: number, limits: Limits): number;\n\n/**\n * Clamp the given value within the inclusive min and max bounds.\n *\n * @param limits - The bounds limits.\n * @signature\n *    P.clamp({ min, max })(value);\n * @example\n *    clamp({ min: 20 })(10) // => 20\n *    clamp({ max: 5 })(10) // => 5\n *    clamp({ max: 20, min: 5 })(10) // => 10\n * @dataLast\n * @category Number\n */\nexport function clamp(limits: Limits): (value: number) => number;\n\nexport function clamp(...args: ReadonlyArray<unknown>): unknown {\n  return curry(clampImplementation, args);\n}\n\nfunction clampImplementation(value: number, { max, min }: Limits): number {\n  if (min !== undefined && value < min) {\n    return min;\n  }\n\n  if (max !== undefined && value > max) {\n    return max;\n  }\n\n  return value;\n}\n"],"mappings":"wCAsCA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAqB,EAAK,CAGzC,SAAS,EAAoB,EAAe,CAAE,MAAK,OAAuB,CASxE,OARI,IAAQ,IAAA,IAAa,EAAQ,EACxB,EAGL,IAAQ,IAAA,IAAa,EAAQ,EACxB,EAGF"}

package/dist/clamped-integer-subtract-C-AIuFhk.d.ts

@@ -0,0 +1,11 @@
+//#region src/internal/types/clamped-integer-subtract.d.ts
+/**
+ * We built our own version of Subtract instead of using type-fest's one
+ * because we needed a simpler implementation that isn't as prone to excessive
+ * recursion issues and that is clamped at 0 so that we don't need to handle
+ * negative values using even more utilities.
+ */
+type ClampedIntegerSubtract<Minuend, Subtrahend, SubtrahendBag extends Array<unknown> = [], ResultBag extends Array<unknown> = []> = [...SubtrahendBag, ...ResultBag]['length'] extends Minuend ? ResultBag['length'] : SubtrahendBag['length'] extends Subtrahend ? ClampedIntegerSubtract<Minuend, Subtrahend, SubtrahendBag, [...ResultBag, unknown]> : ClampedIntegerSubtract<Minuend, Subtrahend, [...SubtrahendBag, unknown], ResultBag>;
+//#endregion
+export { ClampedIntegerSubtract as t };
+//# sourceMappingURL=clamped-integer-subtract-C-AIuFhk.d.ts.map

package/dist/clamped-integer-subtract-C-AIuFhk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clamped-integer-subtract-C-AIuFhk.d.ts","names":[],"sources":["../src/internal/types/clamped-integer-subtract.ts"],"sourcesContent":[],"mappings":";;AAMA;;;;;AAKuD,KAL3C,sBAK2C,CAAA,OAAA,EAAA,UAAA,EAAA,sBAF/B,KAE+B,CAAA,OAAA,CAAA,GAAA,EAAA,EAAA,kBADnC,KACmC,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GAAA,CAAA,GAA/C,aAA+C,EAAA,GAA7B,SAA6B,CAAA,CAAA,QAAA,CAAA,SAAA,OAAA,GAEnD,SAFmD,CAAA,QAAA,CAAA,GAGnD,aAHmD,CAAA,QAAA,CAAA,SAGnB,UAHmB,GAMjD,sBANiD,CAOjD,OAPiD,EAQjD,UARiD,EASjD,aATiD,EAAA,CAEnD,GAQM,SARN,EACA,OAAA,CAAgC,CAAA,GAU9B,sBAV8B,CAW9B,OAX8B,EAY9B,UAZ8B,EAAA,CAI9B,GASI,aATJ,EACA,OAAA,CACA,EAQA,SARA,CAAA"}

package/dist/clamped-integer-subtract-DueGS_u_.d.cts

@@ -0,0 +1,11 @@
+//#region src/internal/types/clamped-integer-subtract.d.ts
+/**
+ * We built our own version of Subtract instead of using type-fest's one
+ * because we needed a simpler implementation that isn't as prone to excessive
+ * recursion issues and that is clamped at 0 so that we don't need to handle
+ * negative values using even more utilities.
+ */
+type ClampedIntegerSubtract<Minuend, Subtrahend, SubtrahendBag extends Array<unknown> = [], ResultBag extends Array<unknown> = []> = [...SubtrahendBag, ...ResultBag]['length'] extends Minuend ? ResultBag['length'] : SubtrahendBag['length'] extends Subtrahend ? ClampedIntegerSubtract<Minuend, Subtrahend, SubtrahendBag, [...ResultBag, unknown]> : ClampedIntegerSubtract<Minuend, Subtrahend, [...SubtrahendBag, unknown], ResultBag>;
+//#endregion
+export { ClampedIntegerSubtract as t };
+//# sourceMappingURL=clamped-integer-subtract-DueGS_u_.d.cts.map

package/dist/clamped-integer-subtract-DueGS_u_.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clamped-integer-subtract-DueGS_u_.d.cts","names":[],"sources":["../src/internal/types/clamped-integer-subtract.ts"],"sourcesContent":[],"mappings":";;AAMA;;;;;AAKuD,KAL3C,sBAK2C,CAAA,OAAA,EAAA,UAAA,EAAA,sBAF/B,KAE+B,CAAA,OAAA,CAAA,GAAA,EAAA,EAAA,kBADnC,KACmC,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GAAA,CAAA,GAA/C,aAA+C,EAAA,GAA7B,SAA6B,CAAA,CAAA,QAAA,CAAA,SAAA,OAAA,GAEnD,SAFmD,CAAA,QAAA,CAAA,GAGnD,aAHmD,CAAA,QAAA,CAAA,SAGnB,UAHmB,GAMjD,sBANiD,CAOjD,OAPiD,EAQjD,UARiD,EASjD,aATiD,EAAA,CAEnD,GAQM,SARN,EACA,OAAA,CAAgC,CAAA,GAU9B,sBAV8B,CAW9B,OAX8B,EAY9B,UAZ8B,EAAA,CAI9B,GASI,aATJ,EACA,OAAA,CACA,EAQA,SARA,CAAA"}

package/dist/clone.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./clone-DyRAAJkh.cjs`);exports.clone=e.clone;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t=[],n=[]){if(typeof e==`function`)return e;if(typeof e!=`object`||!e)return structuredClone(e);let a=Object.getPrototypeOf(e);if(!Array.isArray(e)&&a!==null&&a!==Object.prototype)return structuredClone(e);let o=t.indexOf(e);return o>=0?n[o]:(t.push(e),Array.isArray(e)?i(e,t,n):r(e,t,n))}function r(e,t,r){let i={};r.push(i);for(let[a,o]of Object.entries(e))i[a]=n(o,t,r);return i}function i(e,t,r){let i=[];r.push(i);for(let[a,o]of e.entries())i[a]=n(o,t,r);return i}exports.clone=t;

package/dist/clone.d.cts

@@ -1,2 +1,35 @@
-import { clone } from "./clone-1QjPrzdD.cjs";
-export { clone };
+//#region src/clone.d.ts
+/**
+ * Creates a deep copy of the value. Supported types: [plain objects](#isPlainObject),
+ * `Array`, `number`, `string`, `boolean`, `Date`, and `RegExp`. Functions are
+ * assigned by reference rather than copied. Class instances or any other
+ * built-in type that isn't mentioned above are not supported (but might
+ * work).
+ *
+ * @param data - The object to clone.
+ * @signature
+ *   P.clone(data)
+ * @example
+ *   P.clone({foo: 'bar'}) // {foo: 'bar'}
+ * @dataFirst
+ * @category Object
+ */
+declare function clone<T>(data: T): T;
+/**
+ * Creates a deep copy of the value. Supported types: [plain objects](#isPlainObject),
+ * `Array`, `number`, `string`, `boolean`, `Date`, and `RegExp`. Functions are
+ * assigned by reference rather than copied. Class instances or any other
+ * built-in type that isn't mentioned above are not supported (but might
+ * work).
+ *
+ * @signature
+ *   P.clone()(data)
+ * @example
+ *   P.pipe({foo: 'bar'}, P.clone()) // {foo: 'bar'}
+ * @dataLast
+ * @category Object
+ */
+declare function clone(): <T>(data: T) => T;
+//#endregion
+export { clone };
+//# sourceMappingURL=clone.d.cts.map

package/dist/clone.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone.d.cts","names":[],"sources":["../src/clone.ts"],"sourcesContent":[],"mappings":";;AAiBA;AAgBA;;;;;;;;;;;;;iBAhBgB,eAAe,IAAI;;;;;;;;;;;;;;;iBAgBnB,KAAA,CAAA,aAAmB,MAAM"}