@vinicunca/perkakas 1.13.2 → 1.15.0

package/dist/ceil.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.d.ts.map

package/dist/ceil.d.ts.map

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

package/dist/chunk.d.cts

@@ -1,76 +0,0 @@
-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

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

package/dist/chunk.d.ts

@@ -1,76 +0,0 @@
-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

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

package/dist/clamp.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.d.cts.map

package/dist/clamp.d.cts.map

@@ -1 +0,0 @@
-{"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,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.d.ts.map

package/dist/clamp.d.ts.map

@@ -1 +0,0 @@
-{"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/clamped-integer-subtract-C-AIuFhk.d.ts

@@ -1,11 +0,0 @@
-//#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

@@ -1 +0,0 @@
-{"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

@@ -1,11 +0,0 @@
-//#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

@@ -1 +0,0 @@
-{"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.d.cts

@@ -1,35 +0,0 @@
-//#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

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

package/dist/clone.d.ts

@@ -1,35 +0,0 @@
-//#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.ts.map

package/dist/clone.d.ts.map

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

package/dist/coerced-array-BKR9Bvsl.d.cts

@@ -1,17 +0,0 @@
-import { IsNever } from "type-fest";
-
-//#region src/internal/types/coerced-array.d.ts
-
-/**
- * `never[]` and `[]` are not the same type, and in some cases they aren't
- * interchangeable.
- *
- * This type makes it easier to use the result of TupleParts when the input is a
- * fixed-length tuple but we still want to spread the rest of the array. e.g.
- * `[...CoercedArray<TupleParts<T>["item"]>, ...TupleParts<T>["suffix"]]`.
- *
- */
-type CoercedArray<T> = IsNever<T> extends true ? [] : Array<T>;
-//#endregion
-export { CoercedArray as t };
-//# sourceMappingURL=coerced-array-BKR9Bvsl.d.cts.map

package/dist/coerced-array-BKR9Bvsl.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"coerced-array-BKR9Bvsl.d.cts","names":[],"sources":["../src/internal/types/coerced-array.ts"],"sourcesContent":[],"mappings":";;;;;;AAWA;;;;;;;KAAY,kBAAkB,QAAQ,uBAAuB,MAAM"}

package/dist/coerced-array-BfTLxqLo.d.ts

@@ -1,17 +0,0 @@
-import { IsNever } from "type-fest";
-
-//#region src/internal/types/coerced-array.d.ts
-
-/**
- * `never[]` and `[]` are not the same type, and in some cases they aren't
- * interchangeable.
- *
- * This type makes it easier to use the result of TupleParts when the input is a
- * fixed-length tuple but we still want to spread the rest of the array. e.g.
- * `[...CoercedArray<TupleParts<T>["item"]>, ...TupleParts<T>["suffix"]]`.
- *
- */
-type CoercedArray<T> = IsNever<T> extends true ? [] : Array<T>;
-//#endregion
-export { CoercedArray as t };
-//# sourceMappingURL=coerced-array-BfTLxqLo.d.ts.map

package/dist/coerced-array-BfTLxqLo.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"coerced-array-BfTLxqLo.d.ts","names":[],"sources":["../src/internal/types/coerced-array.ts"],"sourcesContent":[],"mappings":";;;;;;AAWA;;;;;;;KAAY,kBAAkB,QAAQ,uBAAuB,MAAM"}

package/dist/concat.d.cts

@@ -1,41 +0,0 @@
-import { t as IterableContainer } from "./iterable-container-1TN3AJ3s.cjs";
-
-//#region src/concat.d.ts
-
-/**
- * Merge two or more arrays. This method does not change the existing arrays,
- * but instead returns a new array, even if the other array is empty.
- *
- * @param data - The first items, these would be at the beginning of the new
- * array.
- * @param other - The remaining items, these would be at the end of the new
- * array.
- * @returns A new array with the items of the first array followed by the items
- * of the second array.
- * @signature
- *    P.concat(data, other);
- * @example
- *    P.concat([1, 2, 3], ['a']) // [1, 2, 3, 'a']
- * @dataFirst
- * @category Array
- */
-declare function concat<T1 extends IterableContainer, T2 extends IterableContainer>(data: T1, other: T2): [...T1, ...T2];
-/**
- * Merge two or more arrays. This method does not change the existing arrays,
- * but instead returns a new array, even if the other array is empty.
- *
- * @param other - The remaining items, these would be at the end of the new
- * array.
- * @returns A new array with the items of the first array followed by the items
- * of the second array.
- * @signature
- *    P.concat(arr2)(arr1);
- * @example
- *    P.concat(['a'])([1, 2, 3]) // [1, 2, 3, 'a']
- * @dataLast
- * @category Array
- */
-declare function concat<T2 extends IterableContainer>(other: T2): <T1 extends IterableContainer>(data: T1) => [...T1, ...T2];
-//#endregion
-export { concat };
-//# sourceMappingURL=concat.d.cts.map

package/dist/concat.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"concat.d.cts","names":[],"sources":["../src/concat.ts"],"sourcesContent":[],"mappings":";;;;;;AAoBA;;;;;;;;AAoBA;;;;;;;AAE4D,iBAtB5C,MAsB4C,CAAA,WArB/C,iBAqB+C,EAAA,WApB/C,iBAoB+C,CAAA,CAAA,IAAA,EAnBpD,EAmBoD,EAAA,KAAA,EAnBzC,EAmByC,CAAA,EAAA,CAAA,GAnBhC,EAmBgC,EAAA,GAnBzB,EAmByB,CAAA;;;;;;;;;;;;;;;;iBAF5C,kBAAkB,0BACzB,iBACM,yBAAyB,WAAW,OAAO"}

package/dist/concat.d.ts

@@ -1,41 +0,0 @@
-import { t as IterableContainer } from "./iterable-container-Dv5vSKht.js";
-
-//#region src/concat.d.ts
-
-/**
- * Merge two or more arrays. This method does not change the existing arrays,
- * but instead returns a new array, even if the other array is empty.
- *
- * @param data - The first items, these would be at the beginning of the new
- * array.
- * @param other - The remaining items, these would be at the end of the new
- * array.
- * @returns A new array with the items of the first array followed by the items
- * of the second array.
- * @signature
- *    P.concat(data, other);
- * @example
- *    P.concat([1, 2, 3], ['a']) // [1, 2, 3, 'a']
- * @dataFirst
- * @category Array
- */
-declare function concat<T1 extends IterableContainer, T2 extends IterableContainer>(data: T1, other: T2): [...T1, ...T2];
-/**
- * Merge two or more arrays. This method does not change the existing arrays,
- * but instead returns a new array, even if the other array is empty.
- *
- * @param other - The remaining items, these would be at the end of the new
- * array.
- * @returns A new array with the items of the first array followed by the items
- * of the second array.
- * @signature
- *    P.concat(arr2)(arr1);
- * @example
- *    P.concat(['a'])([1, 2, 3]) // [1, 2, 3, 'a']
- * @dataLast
- * @category Array
- */
-declare function concat<T2 extends IterableContainer>(other: T2): <T1 extends IterableContainer>(data: T1) => [...T1, ...T2];
-//#endregion
-export { concat };
-//# sourceMappingURL=concat.d.ts.map

package/dist/concat.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"concat.d.ts","names":[],"sources":["../src/concat.ts"],"sourcesContent":[],"mappings":";;;;;;AAoBA;;;;;;;;AAoBA;;;;;;;AAE4D,iBAtB5C,MAsB4C,CAAA,WArB/C,iBAqB+C,EAAA,WApB/C,iBAoB+C,CAAA,CAAA,IAAA,EAnBpD,EAmBoD,EAAA,KAAA,EAnBzC,EAmByC,CAAA,EAAA,CAAA,GAnBhC,EAmBgC,EAAA,GAnBzB,EAmByB,CAAA;;;;;;;;;;;;;;;;iBAF5C,kBAAkB,0BACzB,iBACM,yBAAyB,WAAW,OAAO"}

package/dist/conditional-6ff4g8Sy.cjs

@@ -1 +0,0 @@
-function e(e,t,n){return e(n[0])?e=>t(e,...n):t(...n)}const t=Object.assign(n,{defaultCase:a});function n(...t){return e(i,r,t)}function r(e,...t){for(let n of t){if(typeof n==`function`)return n(e);let[t,r]=n;if(t(e))return r(e)}throw Error(`conditional: data failed for all cases`)}function i(e){if(!Array.isArray(e))return!1;let[t,n,...r]=e;return typeof t==`function`&&t.length<=1&&typeof n==`function`&&n.length<=1&&r.length===0}function a(e=s){return[o,e]}function o(){return!0}function s(){}Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});