@vinicunca/perkakas 0.4.1 → 0.4.4

package/dist/types/array/mean-by.d.ts

@@ -1,39 +0,0 @@
-import type { PredIndexed } from '../utils/types';
-/**
- * Returns the mean of the elements of an array using the provided predicate.
- * @param fn predicate function
- * @signature
- *   P.meanBy(fn)(array)
- *   P.meanBy.indexed(fn)(array)
- * @example
- *    P.pipe(
- *      [{a: 5}, {a: 1}, {a: 3}],
- *      P.meanBy(x => x.a)
- *    ) // 3
- * @dataLast
- * @indexed
- * @category Array
- */
-export declare function meanBy<T>(fn: (item: T) => number): (items: ReadonlyArray<T>) => number;
-/**
- * Returns the mean of the elements of an array using the provided predicate.
- * @param items the array
- * @param fn predicate function
- * @signature
- *   P.meanBy(array, fn)
- *   P.meanBy.indexed(array, fn)
- * @example
- *    P.meanBy(
- *      [{a: 5}, {a: 1}, {a: 3}],
- *      x => x.a
- *    ) // 3
- * @dataFirst
- * @indexed
- * @category Array
- */
-export declare function meanBy<T>(items: ReadonlyArray<T>, fn: (item: T) => number): number;
-export declare namespace meanBy {
-    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, number>): number;
-    function indexed<T>(fn: PredIndexed<T, number>): (array: ReadonlyArray<T>) => number;
-}
-//# sourceMappingURL=mean-by.d.ts.map

package/dist/types/array/mean-by.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mean-by.d.ts","sourceRoot":"","sources":["../../../src/array/mean-by.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAuB,MAAM,gBAAgB,CAAC;AAoBvE;;;;;;;;;;;;;;GAcG;AAEH,wBAAgB,MAAM,CAAC,CAAC,EACtB,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GACtB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC;AAEvC;;;;;;;;;;;;;;;GAeG;AAEH,wBAAgB,MAAM,CAAC,CAAC,EACtB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GACtB,MAAM,CAAC;AAMV,yBAAiB,MAAM,CAAC;IACtB,SAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC,GACzB,MAAM,CAAC;IAEV,SAAgB,OAAO,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC,GACzB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC;CAKxC"}

package/dist/types/array/merge-all.d.ts

@@ -1,16 +0,0 @@
-/**
- * Merges a list of objects into a single object.
- * @param array the array of objects
- * @signature
- *    P.mergeAll(objects)
- * @example
- *    P.mergeAll([{ a: 1, b: 1 }, { b: 2, c: 3 }, { d: 10 }]) // => { a: 1, b: 2, c: 3, d: 10 }
- * @category Array
- */
-export declare function mergeAll<A>(array: readonly [A]): A;
-export declare function mergeAll<A, B>(array: readonly [A, B]): A & B;
-export declare function mergeAll<A, B, C>(array: readonly [A, B, C]): A & B & C;
-export declare function mergeAll<A, B, C, D>(array: readonly [A, B, C, D]): A & B & C & D;
-export declare function mergeAll<A, B, C, D, E>(array: readonly [A, B, C, D, E]): A & B & C & D & E;
-export declare function mergeAll(array: ReadonlyArray<object>): object;
-//# sourceMappingURL=merge-all.d.ts.map

package/dist/types/array/merge-all.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"merge-all.d.ts","sourceRoot":"","sources":["../../../src/array/merge-all.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AACpD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAC9D,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AACxE,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EACjC,KAAK,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAC3B,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AACjB,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EACpC,KAAK,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAC9B,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AACrB,wBAAgB,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC"}

package/dist/types/array/min-by.d.ts

@@ -1,39 +0,0 @@
-import type { PredIndexed } from '../utils/types';
-/**
- * Returns the min element using the provided predicate.
- * @param fn the predicate
- * @signature
- *    P.minBy(fn)(array)
- *    P.minBy.indexed(fn)(array)
- * @example
- *    P.pipe(
- *      [{a: 5}, {a: 1}, {a: 3}],
- *      P.minBy(x => x.a)
- *    ) // { a: 1 }
- * @dataLast
- * @indexed
- * @category Array
- */
-export declare function minBy<T>(fn: (item: T) => number): (items: ReadonlyArray<T>) => T | undefined;
-/**
- * Returns the min element using the provided predicate.
- * @param items the array
- * @param fn the predicate
- * @signature
- *    P.minBy(array, fn)
- *    P.minBy.indexed(array, fn)
- * @example
- *    P.minBy(
- *      [{a: 5}, {a: 1}, {a: 3}],
- *      x => x.a
- *    ) // { a: 1 }
- * @dataFirst
- * @indexed
- * @category Array
- */
-export declare function minBy<T>(items: ReadonlyArray<T>, fn: (item: T) => number): T | undefined;
-export declare namespace minBy {
-    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, number>): T | undefined;
-    function indexed<T>(fn: PredIndexed<T, number>): (array: ReadonlyArray<T>) => T | undefined;
-}
-//# sourceMappingURL=min-by.d.ts.map

package/dist/types/array/min-by.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"min-by.d.ts","sourceRoot":"","sources":["../../../src/array/min-by.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAuB,MAAM,gBAAgB,CAAC;AAqBvE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,CAAC,EACrB,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GACtB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;AAE9C;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,KAAK,CAAC,CAAC,EACrB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GACtB,CAAC,GAAG,SAAS,CAAC;AAMjB,yBAAiB,KAAK,CAAC;IACrB,SAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC,GACzB,CAAC,GAAG,SAAS,CAAC;IACjB,SAAgB,OAAO,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC,GACzB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;CAI/C"}

package/dist/types/array/nth-by.d.ts

@@ -1,44 +0,0 @@
-import type { IterableContainer, NonEmptyArray } from '../utils/types';
-import { type OrderRule } from '../utils/purry-order-rules';
-/**
- * Retrieves the element that would be at the given index if the array were sorted according to specified rules.
- * This function uses the *QuickSelect* algorithm running at an average complexity of *O(n)*.
- * Semantically it is equivalent to `sortBy(data, ...rules).at(index)` which would run at *O(nlogn)*.
- *
- * See also `firstBy` which provides an even more efficient algorithm and a stricter return type,
- * but only for `index === 0`.
- * See `takeFirstBy` to get all the elements up to and including `index`.
- *
- * @param data - The input array.
- * @param index - The zero-based index for selecting the element in the sorted order. Negative indices count backwards from the end.
- * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
- * @returns The element at the specified index in the sorted order, or `undefined` if the index is out of bounds.
- * @signature
- *   P.nthBy(data, index, ...rules);
- * @example
- *   P.nthBy([2,1,4,5,3,], 2, identity); // => 3
- * @dataFirst
- * @category Array
- */
-export declare function nthBy<T extends IterableContainer>(data: T, index: number, ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): T[number] | undefined;
-/**
- * Retrieves the element that would be at the given index if the array were sorted according to specified rules.
- * This function uses the *QuickSelect* algorithm running at an average complexity of *O(n)*.
- * Semantically it is equivalent to `sortBy(data, ...rules)[index]` which would run at *O(nlogn)*.
- *
- * See also `firstBy` which provides an even more efficient algorithm and a stricter return type,
- * but only for `index === 0`.
- * See `takeFirstBy` to get all the elements up to and including `index`.
- *
- * @param index - The zero-based index for selecting the element in the sorted order. Negative indices count backwards from the end.
- * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
- * @returns The element at the specified index in the sorted order, or `undefined` if the index is out of bounds.
- * @signature
- *   P.nthBy(index, ...rules)(data);
- * @example
- *   P.pipe([2,1,4,5,3,], P.nthBy(2, identity)); // => 3
- * @dataLast
- * @category Array
- */
-export declare function nthBy<T extends IterableContainer>(index: number, ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): (data: T) => T[number] | undefined;
-//# sourceMappingURL=nth-by.d.ts.map

package/dist/types/array/nth-by.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"nth-by.d.ts","sourceRoot":"","sources":["../../../src/array/nth-by.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,iBAAiB,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAExF,OAAO,EAAE,KAAK,SAAS,EAA+B,MAAM,4BAA4B,CAAC;AAGzF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,iBAAiB,EAC/C,IAAI,EAAE,CAAC,EACP,KAAK,EAAE,MAAM,EACb,GAAG,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GACtD,CAAC,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC;AAEzB;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,iBAAiB,EAC/C,KAAK,EAAE,MAAM,EACb,GAAG,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GACtD,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC"}

package/dist/types/array/only.d.ts

@@ -1,37 +0,0 @@
-import type { IterableContainer } from '../utils/types';
-type Only<T extends IterableContainer> = T extends readonly [...Array<unknown>, unknown, unknown] | readonly [] | readonly [unknown, ...Array<unknown>, unknown] | readonly [unknown, unknown, ...Array<unknown>] ? undefined : T extends readonly [unknown] ? T[number] : T[number] | undefined;
-/**
- * Returns the first and only element of `array`, or undefined otherwise.
- * Note: In `pipe`, use `only()` form instead of `only`. Otherwise, the
- * inferred type is lost.
- *
- * @param array the target array
- * @signature
- *    P.only(array)
- * @example
- *    P.only([]) // => undefined
- *    P.only([1]) // => 1
- *    P.only([1, 2]) // => undefined
- * @pipeable
- * @category Array
- * @dataFirst
- */
-export declare function only<T extends IterableContainer>(array: Readonly<T>): Only<T>;
-/**
- * Returns the first and only element of `array`, or undefined otherwise.
- * Note: In `pipe`, use `only()` form instead of `only`. Otherwise, the
- * inferred type is lost.
- *
- * @signature
- *    P.only(array)
- * @example
- *    P.only([]) // => undefined
- *    P.only([1]) // => 1
- *    P.only([1, 2]) // => undefined
- * @pipeable
- * @category Array
- * @dataLast
- */
-export declare function only<T extends IterableContainer>(): (array: Readonly<T>) => Only<T>;
-export {};
-//# sourceMappingURL=only.d.ts.map

package/dist/types/array/only.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"only.d.ts","sourceRoot":"","sources":["../../../src/array/only.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAIxD,KAAK,IAAI,CAAC,CAAC,SAAS,iBAAiB,IAAI,CAAC,SACtC,SAAS,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,GAC9C,SAAS,EAAE,GACX,SAAS,CAAC,OAAO,EAAE,GAAG,KAAK,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,GAC9C,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,GAC9C,SAAS,GACT,CAAC,SAAS,SAAS,CAAC,OAAO,CAAC,GAC1B,CAAC,CAAC,MAAM,CAAC,GACT,CAAC,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC;AAE5B;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,iBAAiB,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;AAE/E;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,iBAAiB,KAAK,CACnD,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,KACf,IAAI,CAAC,CAAC,CAAC,CAAC"}

package/dist/types/array/partition.d.ts

@@ -1,60 +0,0 @@
-import type { PredIndexed } from '../utils/types';
-/**
- * Splits a collection into two groups, the first of which contains elements the `predicate` type guard passes, and the second one containing the rest.
- * @param items the items to split
- * @param predicate a type guard function to invoke on every item
- * @returns the array of grouped elements.
- * @signature
- *    P.partition(array, fn)
- * @example
- *    P.partition(['one', 'two', 'forty two'], x => x.length === 3) // => [['one', 'two'], ['forty two']]
- * @dataFirst
- * @indexed
- * @category Array
- */
-export declare function partition<T, S extends T>(items: ReadonlyArray<T>, predicate: (item: T) => item is S): [Array<S>, Array<Exclude<T, S>>];
-/**
- * Splits a collection into two groups, the first of which contains elements the `predicate` function matches, and the second one containing the rest.
- * @param items the items to split
- * @param predicate the function invoked per iteration
- * @returns the array of grouped elements.
- * @signature
- *    P.partition(array, fn)
- * @example
- *    P.partition(['one', 'two', 'forty two'], x => x.length === 3) // => [['one', 'two'], ['forty two']]
- * @dataFirst
- * @indexed
- * @category Array
- */
-export declare function partition<T>(items: ReadonlyArray<T>, predicate: (item: T) => boolean): [Array<T>, Array<T>];
-/**
- * Splits a collection into two groups, the first of which contains elements the `predicate` type guard passes, and the second one containing the rest.
- * @param predicate the grouping function
- * @returns the array of grouped elements.
- * @signature
- *    P.partition(fn)(array)
- * @example
- *    P.pipe(['one', 'two', 'forty two'], P.partition(x => x.length === 3)) // => [['one', 'two'], ['forty two']]
- * @dataLast
- * @indexed
- * @category Array
- */
-export declare function partition<T, S extends T>(predicate: (item: T) => item is S): (array: ReadonlyArray<T>) => [Array<S>, Array<Exclude<T, S>>];
-/**
- * Splits a collection into two groups, the first of which contains elements the `predicate` function matches, and the second one containing the rest.
- * @param predicate the grouping function
- * @returns the array of grouped elements.
- * @signature
- *    P.partition(fn)(array)
- * @example
- *    P.pipe(['one', 'two', 'forty two'], P.partition(x => x.length === 3)) // => [['one', 'two'], ['forty two']]
- * @dataLast
- * @indexed
- * @category Array
- */
-export declare function partition<T>(predicate: (item: T) => boolean): (array: ReadonlyArray<T>) => [Array<T>, Array<T>];
-export declare namespace partition {
-    function indexed<T>(array: ReadonlyArray<T>, predicate: PredIndexed<T, boolean>): [Array<T>, Array<T>];
-    function indexed<T>(predicate: PredIndexed<T, boolean>): (array: ReadonlyArray<T>) => [Array<T>, Array<T>];
-}
-//# sourceMappingURL=partition.d.ts.map

package/dist/types/array/partition.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"partition.d.ts","sourceRoot":"","sources":["../../../src/array/partition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAuB,MAAM,gBAAgB,CAAC;AAIvE;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,EACtC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,IAAI,CAAC,GAChC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;AAEpC;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAC9B,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AAExB;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,EACtC,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,IAAI,CAAC,GAChC,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;AAEjE;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAC9B,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AAiBrD,yBAAiB,SAAS,CAAC;IACzB,SAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,SAAS,EAAE,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,GACjC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACxB,SAAgB,OAAO,CAAC,CAAC,EACvB,SAAS,EAAE,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,GACjC,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;CAItD"}

package/dist/types/array/range.d.ts

@@ -1,22 +0,0 @@
-/**
- * Returns a list of numbers from `start` (inclusive) to `end` (exclusive).
- * @param start the start number
- * @param end the end number
- * @signature range(start, end)
- * @example
- *    P.range(1, 5) // => [1, 2, 3, 4]
- * @dataFirst
- * @category Array
- */
-export declare function range(start: number, end: number): Array<number>;
-/**
- * Returns a list of numbers from `start` (inclusive) to `end` (exclusive).
- * @param end the end number
- * @signature range(end)(start)
- * @example
- *    P.range(5)(1) // => [1, 2, 3, 4]
- * @dataFirst
- * @category Array
- */
-export declare function range(end: number): (start: number) => Array<number>;
-//# sourceMappingURL=range.d.ts.map

package/dist/types/array/range.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"range.d.ts","sourceRoot":"","sources":["../../../src/array/range.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;AAEjE;;;;;;;;GAQG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,KAAK,CAAC,MAAM,CAAC,CAAC"}

package/dist/types/array/rank-by.d.ts

@@ -1,40 +0,0 @@
-import type { NonEmptyArray } from '../utils/types';
-import { type OrderRule } from '../utils/purry-order-rules';
-/**
- * Calculates the rank of an item in an array based on `rules`. The rank is the position where the item would appear in the sorted array. This function provides an efficient way to determine the rank in *O(n)* time, compared to *O(nlogn)* for the equivalent `sortedIndex(sortBy(data, ...rules), item)`.
- *
- * @param data - The input array.
- * @param item - The item whose rank is to be determined.
- * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
- * @returns - The rank of the item in the sorted array in the range [0..data.length]
- * @signature
- *   P.rankBy(data, item, ...rules)
- * @example
- *   const DATA = [{ a: 5 }, { a: 1 }, { a: 3 }] as const;
- *   P.rankBy(DATA, 0, P.prop('a')) // => 0
- *   P.rankBy(DATA, 1, P.prop('a')) // => 1
- *   P.rankBy(DATA, 2, P.prop('a')) // => 1
- *   P.rankBy(DATA, 3, P.prop('a')) // => 2
- * @dataFirst
- * @category Array
- */
-export declare function rankBy<T>(data: ReadonlyArray<T>, item: T, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): number;
-/**
- * Calculates the rank of an item in an array based on `rules`. The rank is the position where the item would appear in the sorted array. This function provides an efficient way to determine the rank in *O(n)* time, compared to *O(nlogn)* for the equivalent `sortedIndex(sortBy(data, ...rules), item)`.
- *
- * @param item - The item whose rank is to be determined.
- * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
- * @returns - The rank of the item in the sorted array in the range [0..data.length]
- * @signature
- *   P.rankBy(item, ...rules)(data)
- * @example
- *   const DATA = [{ a: 5 }, { a: 1 }, { a: 3 }] as const;
- *   P.pipe(DATA, P.rankBy(0, P.prop('a'))) // => 0
- *   P.pipe(DATA, P.rankBy(1, P.prop('a'))) // => 1
- *   P.pipe(DATA, P.rankBy(2, P.prop('a'))) // => 1
- *   P.pipe(DATA, P.rankBy(3, P.prop('a'))) // => 2
- * @dataLast
- * @category Array
- */
-export declare function rankBy<T>(item: T, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): (data: ReadonlyArray<T>) => number;
-//# sourceMappingURL=rank-by.d.ts.map

package/dist/types/array/rank-by.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rank-by.d.ts","sourceRoot":"","sources":["../../../src/array/rank-by.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAErE,OAAO,EAAE,KAAK,SAAS,EAA+B,MAAM,4BAA4B,CAAC;AAEzF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACtB,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EACtB,IAAI,EAAE,CAAC,EACP,GAAG,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,GAC9C,MAAM,CAAC;AAEV;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACtB,IAAI,EAAE,CAAC,EACP,GAAG,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,GAC9C,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC"}

package/dist/types/array/reduce.d.ts

@@ -1,37 +0,0 @@
-/**
- * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
- *
- * @param items the array to reduce
- * @param fn the callback function
- * @param initialValue the initial value to use as an accumulator value in the callback function
- * @signature
- *    P.reduce(items, fn, initialValue)
- *    P.reduce.indexed(items, fn, initialValue)
- * @example
- *    P.reduce([1, 2, 3, 4, 5], (acc, x) => acc + x, 100) // => 115
- *    P.reduce.indexed([1, 2, 3, 4, 5], (acc, x, i, array) => acc + x, 100) // => 115
- * @dataFirst
- * @indexed
- * @category Array
- */
-export declare function reduce<T, K>(items: ReadonlyArray<T>, fn: (acc: K, item: T) => K, initialValue: K): K;
-/**
- * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
- *
- * @param fn the callback function
- * @param initialValue the initial value to use as an accumulator value in the callback function
- * @signature
- *    P.reduce(fn, initialValue)(array)
- * @example
- *    P.pipe([1, 2, 3, 4, 5], P.reduce((acc, x) => acc + x, 100)) // => 115
- *    P.pipe([1, 2, 3, 4, 5], P.reduce.indexed((acc, x, i, array) => acc + x, 100)) // => 115
- * @dataLast
- * @indexed
- * @category Array
- */
-export declare function reduce<T, K>(fn: (acc: K, item: T) => K, initialValue: K): (items: ReadonlyArray<T>) => K;
-export declare namespace reduce {
-    function indexed<T, K>(array: ReadonlyArray<T>, fn: (acc: K, item: T, index: number, items: ReadonlyArray<T>) => K, initialValue: K): K;
-    function indexed<T, K>(fn: (acc: K, item: T, index: number, items: ReadonlyArray<T>) => K, initialValue: K): (array: ReadonlyArray<T>) => K;
-}
-//# sourceMappingURL=reduce.d.ts.map

package/dist/types/array/reduce.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reduce.d.ts","sourceRoot":"","sources":["../../../src/array/reduce.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EACzB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,EAC1B,YAAY,EAAE,CAAC,GACd,CAAC,CAAC;AAEL;;;;;;;;;;;;;GAaG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EACzB,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,EAC1B,YAAY,EAAE,CAAC,GACd,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;AAmBlC,yBAAiB,MAAM,CAAC;IACtB,SAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAC1B,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,EAClE,YAAY,EAAE,CAAC,GACd,CAAC,CAAC;IACL,SAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAC1B,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,EAClE,YAAY,EAAE,CAAC,GACd,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;CAInC"}

package/dist/types/array/reject.d.ts

@@ -1,42 +0,0 @@
-import type { LazyEvaluator } from '../function/pipe';
-import type { Pred, PredIndexed, PredIndexedOptional } from '../utils/types';
-/**
- * Reject the elements of an array that meet the condition specified in a callback function.
- * @param items The array to reject.
- * @param fn the callback function.
- * @signature
- *    P.reject(array, fn)
- *    P.reject.indexed(array, fn)
- * @example
- *    P.reject([1, 2, 3], x => x % 2 === 0) // => [1, 3]
- *    P.reject.indexed([1, 2, 3], (x, i, array) => x % 2 === 0) // => [1, 3]
- * @dataFirst
- * @indexed
- * @pipeable
- * @category Array
- */
-export declare function reject<T>(items: ReadonlyArray<T>, fn: Pred<T, boolean>): Array<T>;
-/**
- * Reject the elements of an array that meet the condition specified in a callback function.
- * @param fn the callback function.
- * @signature
- *    P.reject(array, fn)
- *    P.reject.indexed(array, fn)
- * @example
- *    P.reject([1, 2, 3], x => x % 2 === 0) // => [1, 3]
- *    P.reject.indexed([1, 2, 3], (x, i, array) => x % 2 === 0) // => [1, 3]
- * @dataFirst
- * @indexed
- * @pipeable
- * @category Array
- */
-export declare function reject<T>(fn: Pred<T, boolean>): (items: ReadonlyArray<T>) => Array<T>;
-export declare namespace reject {
-    function indexed<T, K>(array: ReadonlyArray<T>, fn: PredIndexed<T, boolean>): Array<K>;
-    function indexed<T, K>(fn: PredIndexed<T, boolean>): (array: ReadonlyArray<T>) => Array<K>;
-    const lazy: <T>(fn: PredIndexedOptional<T, boolean>) => LazyEvaluator<T>;
-    const lazyIndexed: (<T>(fn: PredIndexedOptional<T, boolean>) => LazyEvaluator<T>) & {
-        readonly indexed: true;
-    };
-}
-//# sourceMappingURL=reject.d.ts.map

package/dist/types/array/reject.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reject.d.ts","sourceRoot":"","sources":["../../../src/array/reject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAM7E;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACtB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,GACnB,KAAK,CAAC,CAAC,CAAC,CAAC;AAEZ;;;;;;;;;;;;;GAaG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACtB,EAAE,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,GACnB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;AAwBzC,yBAAiB,MAAM,CAAC;IACtB,SAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAC1B,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,GAC1B,KAAK,CAAC,CAAC,CAAC,CAAC;IACZ,SAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAC1B,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,GAC1B,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;IAKlC,MAAM,IAAI,8DAAe,CAAC;IAC1B,MAAM,WAAW;;KAA6B,CAAC;CACvD"}

package/dist/types/array/reverse.d.ts

@@ -1,27 +0,0 @@
-type Reverse<T extends ReadonlyArray<unknown>, R extends ReadonlyArray<unknown> = []> = ReturnType<T extends IsNoTuple<T> ? () => [...T, ...R] : T extends readonly [infer F, ...infer L] ? () => Reverse<L, [F, ...R]> : () => R>;
-type IsNoTuple<T> = T extends readonly [unknown, ...Array<unknown>] ? never : T;
-/**
- * Reverses an array.
- *
- * @param array the array
- * @signature
- *    P.reverse(arr);
- * @example
- *    P.reverse([1, 2, 3]) // [3, 2, 1]
- * @dataFirst
- * @category Array
- */
-export declare function reverse<T extends ReadonlyArray<unknown>>(array: T): Reverse<T>;
-/**
- * Reverses an array.
- *
- * @signature
- *    P.reverse()(array);
- * @example
- *    P.reverse()([1, 2, 3]) // [3, 2, 1]
- * @dataLast
- * @category Array
- */
-export declare function reverse<T extends ReadonlyArray<unknown>>(): (array: T) => Reverse<T>;
-export {};
-//# sourceMappingURL=reverse.d.ts.map

package/dist/types/array/reverse.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reverse.d.ts","sourceRoot":"","sources":["../../../src/array/reverse.ts"],"names":[],"mappings":"AAEA,KAAK,OAAO,CACV,CAAC,SAAS,aAAa,CAAC,OAAO,CAAC,EAChC,CAAC,SAAS,aAAa,CAAC,OAAO,CAAC,GAAG,EAAE,IACnC,UAAU,CACd,CAAC,SAAS,SAAS,CAAC,CAAC,CAAC,GAClB,MAAM,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC,GAClB,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,GACtC,MAAM,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,GAC3B,MAAM,CAAC,CACZ,CAAC;AAEF,KAAK,SAAS,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,CAAC,OAAO,EAAE,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC;AAEhF;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,aAAa,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAEhF;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,aAAa,CAAC,OAAO,CAAC,KAAK,CAC3D,KAAK,EAAE,CAAC,KACL,OAAO,CAAC,CAAC,CAAC,CAAC"}

package/dist/types/array/sample.d.ts

@@ -1,54 +0,0 @@
-import type { IterableContainer } from '../utils/types';
-type Sampled<T extends IterableContainer, N extends number> = number extends N ? SampledGeneric<T> : undefined extends T[N] ? T : SampledLiteral<T, N>;
-type SampledGeneric<T extends IterableContainer> = T[number] extends never ? T : T extends readonly [infer First, ...infer Rest] ? [First, ...SampledGeneric<Rest>] | SampledGeneric<Rest> : Array<T[number]>;
-type SampledLiteral<T extends IterableContainer, N extends number, Iteration extends Array<unknown> = []> = Iteration['length'] extends N ? [] : T extends readonly [infer First, ...infer Tail] ? [
-    First | Tail[number],
-    ...SampledLiteral<Tail, N, [unknown, ...Iteration]>
-] : T extends readonly [...infer Head, infer Last] ? [...SampledLiteral<Head, N, [unknown, ...Iteration]>, Last] : [T[number], ...SampledLiteral<T, N, [unknown, ...Iteration]>] | SampledLiteral<T, N, [unknown, ...Iteration]>;
-/**
- * Returns a random subset of size `sampleSize` from `array`.
- *
- * Maintains and infers most of the typing information that could be passed
- * along to the output. This means that when using tuples, the output will be
- * a tuple too, and when using literals, those literals would be preserved.
- *
- * The items in the result are kept in the same order as they are in the input.
- * If you need to get a shuffled response you can pipe the shuffle function
- * after this one.
- *
- * @param data the array
- * @param sampleSize the number of elements to take
- * @signature
- *    P.sample(array, sampleSize)
- * @example
- *    P.sample(["hello", "world"], 1); // => ["hello"] // typed string[]
- *    P.sample(["hello", "world"] as const, 1); // => ["world"] // typed ["hello" | "world"]
- * @dataFirst
- * @pipeable
- * @category Array
- */
-export declare function sample<T extends IterableContainer, N extends number = number>(data: T, sampleSize: N): Sampled<T, N>;
-/**
- * Returns a random subset of size `sampleSize` from `array`.
- *
- * Maintains and infers most of the typing information that could be passed
- * along to the output. This means that when using tuples, the output will be
- * a tuple too, and when using literals, those literals would be preserved.
- *
- * The items in the result are kept in the same order as they are in the input.
- * If you need to get a shuffled response you can pipe the shuffle function
- * after this one.
- *
- * @param sampleSize the number of elements to take
- * @signature
- *    P.sample(sampleSize)(array)
- * @example
- *    P.sample(1)(["hello", "world"]); // => ["hello"] // typed string[]
- *    P.sample(1)(["hello", "world"] as const); // => ["world"] // typed ["hello" | "world"]
- * @dataLast
- * @pipeable
- * @category Array
- */
-export declare function sample<T extends IterableContainer, N extends number = number>(sampleSize: N): (data: T) => Sampled<T, N>;
-export {};
-//# sourceMappingURL=sample.d.ts.map

package/dist/types/array/sample.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sample.d.ts","sourceRoot":"","sources":["../../../src/array/sample.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAIxD,KAAK,OAAO,CAAC,CAAC,SAAS,iBAAiB,EAAE,CAAC,SAAS,MAAM,IAExD,MAAM,SAAS,CAAC,GACZ,cAAc,CAAC,CAAC,CAAC,GAGnB,SAAS,SAAS,CAAC,CAAC,CAAC,CAAC,GAClB,CAAC,GACD,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAE7B,KAAK,cAAc,CAAC,CAAC,SAAS,iBAAiB,IAE7C,CAAC,CAAC,MAAM,CAAC,SAAS,KAAK,GACnB,CAAC,GAGH,CAAC,SAAS,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GAC3C,CAAC,KAAK,EAAE,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC,GAAG,cAAc,CAAC,IAAI,CAAC,GAGzD,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AAEvB,KAAK,cAAc,CACjB,CAAC,SAAS,iBAAiB,EAC3B,CAAC,SAAS,MAAM,EAChB,SAAS,SAAS,KAAK,CAAC,OAAO,CAAC,GAAG,EAAE,IAGrC,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,GACzB,EAAE,GAGJ,CAAC,SAAS,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GAC3C;IACE,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC;IACpB,GAAG,cAAc,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,SAAS,CAAC,CAAC;CACpD,GACD,CAAC,SAAS,SAAS,CAAC,GAAG,MAAM,IAAI,EAAE,MAAM,IAAI,CAAC,GAC5C,CAAC,GAAG,cAAc,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,SAAS,CAAC,CAAC,EAAE,IAAI,CAAC,GAI3D,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,GAAG,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,SAAS,CAAC,CAAC,CAAC,GAC7D,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,SAAS,CAAC,CAAC,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,iBAAiB,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,EAC3E,IAAI,EAAE,CAAC,EACP,UAAU,EAAE,CAAC,GACZ,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,iBAAiB,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,EAC3E,UAAU,EAAE,CAAC,GACZ,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

package/dist/types/array/shuffle.d.ts

@@ -1,22 +0,0 @@
-/**
- * Shuffles the input array, returning a new array with the same elements in a random order.
- * @param items the array to shuffle
- * @signature
- *    P.shuffle(array)
- * @example
- *    P.shuffle([4, 2, 7, 5]) // => [7, 5, 4, 2]
- * @category Array
- * @dataFirst
- */
-export declare function shuffle<T>(items: ReadonlyArray<T>): Array<T>;
-/**
- * Shuffles the input array, returning a new array with the same elements in a random order.
- * @signature
- *    P.shuffle()(array)
- * @example
- *    P.pipe([4, 2, 7, 5], P.shuffle()) // => [7, 5, 4, 2]
- * @category Array
- * @dataLast
- */
-export declare function shuffle<T>(): (items: ReadonlyArray<T>) => Array<T>;
-//# sourceMappingURL=shuffle.d.ts.map

package/dist/types/array/shuffle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shuffle.d.ts","sourceRoot":"","sources":["../../../src/array/shuffle.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AAE9D;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,CAAC,KAAK,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC"}