@vinicunca/perkakas 0.4.0 → 0.4.3

package/dist/es/string/random-string.js

@@ -1,12 +0,0 @@
-import { purry } from '../function/purry';
-import { times } from '../function/times';
-const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-export function randomString(...args) {
-    return purry(randomStringImplementation, args);
-}
-function randomStringImplementation(length) {
-    return times(length, randomChar).join('');
-}
-function randomChar() {
-    return ALPHABET[Math.floor(Math.random() * ALPHABET.length)];
-}

package/dist/es/string/slugify.js

@@ -1,9 +0,0 @@
-export function slugify(str) {
-    return str
-        .normalize('NFD')
-        .replace(/[\u0300-\u036F]/g, '')
-        .toLowerCase()
-        .replace(/[^a-z0-9]/g, ' ')
-        .trim()
-        .replace(/\s+/g, '-');
-}

package/dist/es/string/string-to-path.js

@@ -1,14 +0,0 @@
-export function stringToPath(path) {
-    return stringToPath_(path);
-}
-function stringToPath_(path) {
-    if (path.length === 0) {
-        return [];
-    }
-    const match = /^\[(.+?)\](.*)$/u.exec(path) ?? /^\.?([^.[\]]+)(.*)$/u.exec(path);
-    if (match !== null) {
-        const [, key, rest] = match;
-        return [key, ...stringToPath_(rest)];
-    }
-    return [path];
-}

package/dist/es/type/index.js

@@ -1 +0,0 @@
-export * from './type';

package/dist/es/type/type.js

@@ -1,9 +0,0 @@
-export function type(val) {
-    if (val === null) {
-        return 'Null';
-    }
-    if (val === undefined) {
-        return 'Undefined';
-    }
-    return Object.prototype.toString.call(val).slice(8, -1);
-}

package/dist/es/utils/binary-search-cutoff-index.js

@@ -1,15 +0,0 @@
-export function binarySearchCutoffIndex(array, predicate) {
-    let lowIndex = 0;
-    let highIndex = array.length;
-    while (lowIndex < highIndex) {
-        const pivotIndex = (lowIndex + highIndex) >>> 1;
-        const pivot = array[pivotIndex];
-        if (predicate(pivot, pivotIndex)) {
-            lowIndex = pivotIndex + 1;
-        }
-        else {
-            highIndex = pivotIndex;
-        }
-    }
-    return highIndex;
-}

package/dist/es/utils/heap.js

@@ -1,38 +0,0 @@
-import { hasAtLeast } from '../array/has-at-least';
-import { swapInPlace } from './swap-in-place';
-export function heapify(heap, compareFn) {
-    for (let i = Math.floor(heap.length / 2) - 1; i >= 0; i--) {
-        heapSiftDown(heap, i, compareFn);
-    }
-}
-export function heapMaybeInsert(heap, compareFn, item) {
-    if (!hasAtLeast(heap, 1)) {
-        return;
-    }
-    const [head] = heap;
-    if (compareFn(item, head) >= 0) {
-        return;
-    }
-    heap[0] = item;
-    heapSiftDown(heap, 0, compareFn);
-    return head;
-}
-function heapSiftDown(heap, index, compareFn) {
-    let currentIndex = index;
-    while (currentIndex * 2 + 1 < heap.length) {
-        const firstChildIndex = currentIndex * 2 + 1;
-        let swapIndex = compareFn(heap[currentIndex], heap[firstChildIndex]) < 0
-            ? firstChildIndex
-            : currentIndex;
-        const secondChildIndex = firstChildIndex + 1;
-        if (secondChildIndex < heap.length
-            && compareFn(heap[swapIndex], heap[secondChildIndex]) < 0) {
-            swapIndex = secondChildIndex;
-        }
-        if (swapIndex === currentIndex) {
-            return;
-        }
-        swapInPlace(heap, currentIndex, swapIndex);
-        currentIndex = swapIndex;
-    }
-}

package/dist/es/utils/narrow.js

@@ -1 +0,0 @@
-export {};

package/dist/es/utils/paths.js

@@ -1 +0,0 @@
-export {};

package/dist/es/utils/purry-on.js

@@ -1,6 +0,0 @@
-export function purryOn(isArg, implementation, args) {
-    const callArgs = Array.from(args);
-    return isArg(args[0])
-        ? (data) => implementation(data, ...callArgs)
-        : implementation(...callArgs);
-}

package/dist/es/utils/purry-order-rules.js

@@ -1,61 +0,0 @@
-const COMPARATORS = {
-    asc: (x, y) => x > y,
-    desc: (x, y) => x < y,
-};
-export function purryOrderRules(func, inputArgs) {
-    const [dataOrRule, ...rules] = (Array.isArray(inputArgs) ? inputArgs : Array.from(inputArgs));
-    if (!isOrderRule(dataOrRule)) {
-        const compareFn = orderRuleComparer(...rules);
-        return func(dataOrRule, compareFn);
-    }
-    const compareFn = orderRuleComparer(dataOrRule, ...rules);
-    return (data) => func(data, compareFn);
-}
-export function purryOrderRulesWithArgument(func, inputArgs) {
-    const [first, second, ...rest] = Array.from(inputArgs);
-    let arg;
-    let argRemoved;
-    if (isOrderRule(second)) {
-        arg = first;
-        argRemoved = [second, ...rest];
-    }
-    else {
-        arg = second;
-        argRemoved = [first, ...rest];
-    }
-    return purryOrderRules((...args) => func(...args, arg), argRemoved);
-}
-function orderRuleComparer(primaryRule, secondaryRule, ...otherRules) {
-    const projector = typeof primaryRule === 'function' ? primaryRule : primaryRule[0];
-    const direction = typeof primaryRule === 'function' ? 'asc' : primaryRule[1];
-    const { [direction]: comparator } = COMPARATORS;
-    const nextComparer = secondaryRule === undefined
-        ? undefined
-        : orderRuleComparer(secondaryRule, ...otherRules);
-    return (a, b) => {
-        const projectedA = projector(a);
-        const projectedB = projector(b);
-        if (comparator(projectedA, projectedB)) {
-            return 1;
-        }
-        if (comparator(projectedB, projectedA)) {
-            return -1;
-        }
-        return nextComparer?.(a, b) ?? 0;
-    };
-}
-function isOrderRule(x) {
-    if (isProjection(x)) {
-        return true;
-    }
-    if (typeof x !== 'object' || !Array.isArray(x)) {
-        return false;
-    }
-    const [maybeProjection, maybeDirection, ...rest] = x;
-    return (isProjection(maybeProjection)
-        && maybeDirection in COMPARATORS
-        && rest.length === 0);
-}
-function isProjection(x) {
-    return typeof x === 'function' && x.length === 1;
-}

package/dist/es/utils/quick-select.js

@@ -1,27 +0,0 @@
-import { swapInPlace } from './swap-in-place';
-export function quickSelect(data, index, compareFn) {
-    return index < 0 || index >= data.length
-        ? undefined
-        : quickSelectImplementation(data.slice(), 0, data.length - 1, index, compareFn);
-}
-function quickSelectImplementation(data, left, right, index, compareFn) {
-    if (left === right) {
-        return data[left];
-    }
-    const pivotIndex = partition(data, left, right, compareFn);
-    return index === pivotIndex
-        ? data[index]
-        : quickSelectImplementation(data, index < pivotIndex ? left : pivotIndex + 1, index < pivotIndex ? pivotIndex - 1 : right, index, compareFn);
-}
-function partition(data, left, right, compareFn) {
-    const pivot = data[right];
-    let i = left;
-    for (let j = left; j < right; j++) {
-        if (compareFn(data[j], pivot) < 0) {
-            swapInPlace(data, i, j);
-            i += 1;
-        }
-    }
-    swapInPlace(data, i, right);
-    return i;
-}

package/dist/es/utils/reduce-lazy.js

@@ -1,17 +0,0 @@
-export function reduceLazy(array, lazy, isIndexed = false) {
-    const out = [];
-    for (let index = 0; index < array.length; index++) {
-        const item = array[index];
-        const result = isIndexed ? lazy(item, index, array) : lazy(item);
-        if (result.hasMany === true) {
-            out.push(...result.next);
-        }
-        else if (result.hasNext) {
-            out.push(result.next);
-        }
-        if (result.done) {
-            break;
-        }
-    }
-    return out;
-}

package/dist/es/utils/swap-in-place.js

@@ -1,3 +0,0 @@
-export function swapInPlace(data, i, j) {
-    [data[i], data[j]] = [data[j], data[i]];
-}

package/dist/es/utils/to-lazy-indexed.js

@@ -1,3 +0,0 @@
-export function toLazyIndexed(fn) {
-    return Object.assign(fn, { indexed: true });
-}

package/dist/es/utils/to-single.js

@@ -1,3 +0,0 @@
-export function toSingle(fn) {
-    return Object.assign(fn, { single: true });
-}

package/dist/es/utils/types.js

@@ -1 +0,0 @@
-export {};

package/dist/es/utils/with-precision.js

@@ -1,19 +0,0 @@
-const MAX_PRECISION = 15;
-export function withPrecision(roundingFn) {
-    return (value, precision) => {
-        if (precision === 0) {
-            return roundingFn(value);
-        }
-        if (!Number.isInteger(precision)) {
-            throw new TypeError(`precision must be an integer: ${precision}`);
-        }
-        if (precision > MAX_PRECISION || precision < -MAX_PRECISION) {
-            throw new RangeError(`precision must be between ${-MAX_PRECISION} and ${MAX_PRECISION}`);
-        }
-        if (Number.isNaN(value) || !Number.isFinite(value)) {
-            return roundingFn(value);
-        }
-        const multiplier = 10 ** precision;
-        return roundingFn(value * multiplier) / multiplier;
-    };
-}

package/dist/types/aria/index.d.ts

@@ -1,2 +0,0 @@
-export * from './key-codes';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/aria/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/aria/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}

package/dist/types/aria/key-codes.d.ts

@@ -1,26 +0,0 @@
-/**
- * Using event.code is not predictable since each machine may have different output
- */
-export declare const KEY_CODES: {
-    readonly ALT: "Alt";
-    readonly ARROW_DOWN: "ArrowDown";
-    readonly ARROW_LEFT: "ArrowLeft";
-    readonly ARROW_RIGHT: "ArrowRight";
-    readonly ARROW_UP: "ArrowUp";
-    readonly AT: "@";
-    readonly BACKSPACE: "Backspace";
-    readonly CTRL: "Control";
-    readonly DELETE: "Delete";
-    readonly END: "End";
-    readonly ENTER: "Enter";
-    readonly ESC: "Escape";
-    readonly HOME: "Home";
-    readonly KEY_F: "KEY_F";
-    readonly META: "Meta";
-    readonly PAGE_DOWN: "PageDown";
-    readonly PAGE_UP: "PageUp";
-    readonly SHIFT: "Shift";
-    readonly SPACE: "Space";
-    readonly TAB: "Tab";
-};
-//# sourceMappingURL=key-codes.d.ts.map

package/dist/types/aria/key-codes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"key-codes.d.ts","sourceRoot":"","sources":["../../../src/aria/key-codes.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;CAqBZ,CAAC"}

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

@@ -1,32 +0,0 @@
-/**
- * Determines whether all predicates returns true for the input data.
- * @param data The input data for predicates.
- * @param fns The list of predicates.
- * @signature
- *    P.allPass(data, fns)
- * @example
- *    const isDivisibleBy3 = (x: number) => x % 3 === 0
- *    const isDivisibleBy4 = (x: number) => x % 4 === 0
- *    const fns = [isDivisibleBy3, isDivisibleBy4]
- *    P.allPass(12, fns) // => true
- *    P.allPass(8, fns) // => false
- * @dataFirst
- * @category Array
- */
-export declare function allPass<T>(data: T, fns: ReadonlyArray<(data: T) => boolean>): boolean;
-/**
- * Determines whether all predicates returns true for the input data.
- * @param fns The list of predicates.
- * @signature
- *    P.allPass(fns)(data)
- * @example
- *    const isDivisibleBy3 = (x: number) => x % 3 === 0
- *    const isDivisibleBy4 = (x: number) => x % 4 === 0
- *    const fns = [isDivisibleBy3, isDivisibleBy4]
- *    P.allPass(fns)(12) // => true
- *    P.allPass(fns)(8) // => false
- * @dataLast
- * @category Array
- */
-export declare function allPass<T>(fns: ReadonlyArray<(data: T) => boolean>): (data: T) => boolean;
-//# sourceMappingURL=all-pass.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"all-pass.d.ts","sourceRoot":"","sources":["../../../src/array/all-pass.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,IAAI,EAAE,CAAC,EACP,GAAG,EAAE,aAAa,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,GACvC,OAAO,CAAC;AAEX;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,GAAG,EAAE,aAAa,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,GACvC,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC"}

package/dist/types/array/any-pass.d.ts

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

package/dist/types/array/any-pass.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"any-pass.d.ts","sourceRoot":"","sources":["../../../src/array/any-pass.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,IAAI,EAAE,CAAC,EACP,GAAG,EAAE,aAAa,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,GACvC,OAAO,CAAC;AAEX;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,GAAG,EAAE,aAAa,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,GACvC,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC"}

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

@@ -1,29 +0,0 @@
-import type { IterableContainer, NonEmptyArray } from '../utils/types';
-type Chunked<T extends IterableContainer> = T[number] extends never ? [] : T extends readonly [...Array<unknown>, unknown] | readonly [unknown, ...Array<unknown>] ? NonEmptyArray<NonEmptyArray<T[number]>> : Array<NonEmptyArray<T[number]>>;
-/**
- * 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
- */
-export declare function chunk<T extends IterableContainer>(array: T, size: number): Chunked<T>;
-/**
- * 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
- */
-export declare function chunk<T extends IterableContainer>(size: number): (array: T) => Chunked<T>;
-export {};
-//# sourceMappingURL=chunk.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"chunk.d.ts","sourceRoot":"","sources":["../../../src/array/chunk.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAIvE,KAAK,OAAO,CAAC,CAAC,SAAS,iBAAiB,IAAI,CAAC,CAAC,MAAM,CAAC,SAAS,KAAK,GAC/D,EAAE,GACF,CAAC,SACD,SAAS,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,GACrC,SAAS,CAAC,OAAO,EAAE,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,GACnC,aAAa,CAAC,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GACvC,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;AAEtC;;;;;;;;;;;GAWG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,iBAAiB,EAC/C,KAAK,EAAE,CAAC,EACR,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,CAAC,CAAC,CAAC;AAEd;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,iBAAiB,EAC/C,IAAI,EAAE,MAAM,GACX,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC"}

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

@@ -1,24 +0,0 @@
-/**
- * Combines two arrays.
- * @param arr1 the first array
- * @param arr2 the second array
- * @signature
- *    P.concat(arr1, arr2);
- * @example
- *    P.concat([1, 2, 3], ['a']) // [1, 2, 3, 'a']
- * @dataFirst
- * @category Array
- */
-export declare function concat<T, K>(arr1: ReadonlyArray<T>, arr2: ReadonlyArray<K>): Array<K | T>;
-/**
- * Combines two arrays.
- * @param arr2 the second array
- * @signature
- *    P.concat(arr2)(arr1);
- * @example
- *    P.concat(['a'])([1, 2, 3]) // [1, 2, 3, 'a']
- * @dataLast
- * @category Array
- */
-export declare function concat<T, K>(arr2: ReadonlyArray<K>): (arr1: ReadonlyArray<T>) => Array<K | T>;
-//# sourceMappingURL=concat.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"concat.d.ts","sourceRoot":"","sources":["../../../src/array/concat.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EACzB,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EACtB,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,GACrB,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAEhB;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EACzB,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,GACrB,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC"}

package/dist/types/array/difference-with.d.ts

@@ -1,48 +0,0 @@
-import type { LazyEvaluator } from '../function/pipe';
-type IsEquals<TFirst, TSecond> = (a: TFirst, b: TSecond) => boolean;
-/**
- * Excludes the values from `other` array.
- * Elements are compared by custom comparator isEquals.
- * @param array the source array
- * @param other the values to exclude
- * @param isEquals the comparator
- * @signature
- *    P.differenceWith(array, other, isEquals)
- * @example
- *    P.differenceWith(
- *      [{a: 1}, {a: 2}, {a: 3}, {a: 4}],
- *      [{a: 2}, {a: 5}, {a: 3}],
- *      P.isDeepEqual,
- *    ) // => [{a: 1}, {a: 4}]
- * @dataFirst
- * @category Array
- * @pipeable
- */
-export declare function differenceWith<TFirst, TSecond>(array: ReadonlyArray<TFirst>, other: ReadonlyArray<TSecond>, isEquals: IsEquals<TFirst, TSecond>): Array<TFirst>;
-/**
- * Excludes the values from `other` array.
- * Elements are compared by custom comparator isEquals.
- * @param other the values to exclude
- * @param isEquals the comparator
- * @signature
- *    P.differenceWith(other, isEquals)(array)
- * @example
- *    P.differenceWith(
- *      [{a: 2}, {a: 5}, {a: 3}],
- *      P.isDeepEqual,
- *    )([{a: 1}, {a: 2}, {a: 3}, {a: 4}]) // => [{a: 1}, {a: 4}]
- *    P.pipe(
- *      [{a: 1}, {a: 2}, {a: 3}, {a: 4}, {a: 5}, {a: 6}], // only 4 iterations
- *      P.differenceWith([{a: 2}, {a: 3}], P.isDeepEqual),
- *      P.take(2),
- *    ) // => [{a: 1}, {a: 4}]
- * @dataLast
- * @category Array
- * @pipeable
- */
-export declare function differenceWith<TFirst, TSecond>(other: ReadonlyArray<TSecond>, isEquals: IsEquals<TFirst, TSecond>): (array: ReadonlyArray<TFirst>) => Array<TFirst>;
-export declare namespace differenceWith {
-    function lazy<TFirst, TSecond>(other: ReadonlyArray<TSecond>, isEquals: IsEquals<TFirst, TSecond>): LazyEvaluator<TFirst>;
-}
-export {};
-//# sourceMappingURL=difference-with.d.ts.map

package/dist/types/array/difference-with.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"difference-with.d.ts","sourceRoot":"","sources":["../../../src/array/difference-with.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAKtD,KAAK,QAAQ,CAAC,MAAM,EAAE,OAAO,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC;AAEpE;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,EAC5C,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,EAC5B,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,EAC7B,QAAQ,EAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,GAClC,KAAK,CAAC,MAAM,CAAC,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,EAC5C,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,EAC7B,QAAQ,EAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,GAClC,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,KAAK,KAAK,CAAC,MAAM,CAAC,CAAC;AAenD,yBAAiB,cAAc,CAAC;IAC9B,SAAgB,IAAI,CAAC,MAAM,EAAE,OAAO,EAClC,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,EAC7B,QAAQ,EAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,GAClC,aAAa,CAAC,MAAM,CAAC,CAKvB;CACF"}

package/dist/types/array/drop-first-by.d.ts

@@ -1,38 +0,0 @@
-import type { NonEmptyArray } from '../utils/types';
-import { type OrderRule } from '../utils/purry-order-rules';
-/**
- * Drop the first `n` items from `data` based on the provided ordering criteria.
- * This allows you to avoid sorting the array before dropping the items.
- * The complexity of this function is *O(Nlogn)* where `N` is the length of the array.
- *
- * For the opposite operation (to keep `n` elements) see `takeFirstBy`.
- *
- * @params data - the input array
- * @params n - the number of items to drop. If `n` is non-positive no items would be dropped and a *clone* of the input would be returned, if `n` is bigger then data.length no items would be returned.
- * @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 a subset of the input array.
- * @signature
- *   P.dropFirstBy(data, n, ...rules);
- * @example
- *   P.dropFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['aaa', 'aaaa']
- * @dataFirst
- * @category Array
- */
-export declare function dropFirstBy<T>(data: ReadonlyArray<T>, n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): Array<T>;
-/**
- * Drop the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before dropping the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.
- *
- * For the opposite operation (to keep `n` elements) see `takeFirstBy`.
- *
- * @params n - the number of items to drop. If `n` is non-positive no items would be dropped and a *clone* of the input would be returned, if `n` is bigger then data.length no items would be returned.
- * @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 a subset of the input array.
- * @signature
- *   P.dropFirstBy(n, ...rules)(data);
- * @example
- *   P.pipe(['aa', 'aaaa', 'a', 'aaa'], P.dropFirstBy(2, x => x.length)); // => ['aaa', 'aaaa']
- * @dataLast
- * @category Array
- */
-export declare function dropFirstBy<T>(n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): (data: ReadonlyArray<T>) => Array<T>;
-//# sourceMappingURL=drop-first-by.d.ts.map

package/dist/types/array/drop-first-by.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"drop-first-by.d.ts","sourceRoot":"","sources":["../../../src/array/drop-first-by.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAGrE,OAAO,EAAE,KAAK,SAAS,EAA+B,MAAM,4BAA4B,CAAC;AAEzF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC3B,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EACtB,CAAC,EAAE,MAAM,EACT,GAAG,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,GAC9C,KAAK,CAAC,CAAC,CAAC,CAAC;AAEZ;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC3B,CAAC,EAAE,MAAM,EACT,GAAG,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,GAC9C,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC"}

package/dist/types/array/drop-last-while.d.ts

@@ -1,30 +0,0 @@
-/**
- * Removes elements from the end of the array until the predicate returns false.
- *
- * The predicate is applied to each element in the array starting from the end and moving towards the beginning, until the predicate returns false. The returned array includes elements from the beginning of the array, up to and including the element that produced false for the predicate.
- *
- * @param data the array
- * @param predicate the predicate
- * @signature
- *    P.dropLastWhile(data, predicate)
- * @example
- *    P.dropLastWhile([1, 2, 10, 3, 4], x => x < 10) // => [1, 2, 10]
- * @dataFirst
- * @category Array
- */
-export declare function dropLastWhile<T>(data: ReadonlyArray<T>, predicate: (item: T) => boolean): Array<T>;
-/**
- * Removes elements from the end of the array until the predicate returns false.
- *
- * The predicate is applied to each element in the array starting from the end and moving towards the beginning, until the predicate returns false. The returned array includes elements from the beginning of the array, up to and including the element that produced false for the predicate.
- *
- * @param predicate the predicate
- * @signature
- *    P.dropLastWhile(predicate)(data)
- * @example
- *    P.pipe([1, 2, 10, 3, 4], P.dropLastWhile(x => x < 10))  // => [1, 2, 10]
- * @dataLast
- * @category Array
- */
-export declare function dropLastWhile<T>(predicate: (item: T) => boolean): (data: ReadonlyArray<T>) => Array<T>;
-//# sourceMappingURL=drop-last-while.d.ts.map

package/dist/types/array/drop-last-while.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"drop-last-while.d.ts","sourceRoot":"","sources":["../../../src/array/drop-last-while.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC7B,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EACtB,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAC9B,KAAK,CAAC,CAAC,CAAC,CAAC;AAEZ;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC7B,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAC9B,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC"}

package/dist/types/array/drop-last.d.ts

@@ -1,26 +0,0 @@
-/**
- * Removes last `n` elements from the `array`.
- *
- * @param array the target array
- * @param n the number of elements to skip
- * @signature
- *    P.dropLast(array, n)
- * @example
- *    P.dropLast([1, 2, 3, 4, 5], 2) // => [1, 2, 3]
- * @dataFirst
- * @category Array
- */
-export declare function dropLast<T>(array: ReadonlyArray<T>, n: number): Array<T>;
-/**
- * Removes last `n` elements from the `array`.
- *
- * @param n the number of elements to skip
- * @signature
- *    P.dropLast(n)(array)
- * @example
- *    P.dropLast(2)([1, 2, 3, 4, 5]) // => [1, 2, 3]
- * @dataLast
- * @category Array
- */
-export declare function dropLast<T>(n: number): (array: ReadonlyArray<T>) => Array<T>;
-//# sourceMappingURL=drop-last.d.ts.map

package/dist/types/array/drop-last.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"drop-last.d.ts","sourceRoot":"","sources":["../../../src/array/drop-last.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AAE1E;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC"}

package/dist/types/array/drop-while.d.ts

@@ -1,33 +0,0 @@
-/**
- * Removes elements from the beginning of the array until the predicate returns false.
- *
- * The predicate is applied to each element in the array,
- * until the predicate returns false.
- * The returned array includes the rest of the elements,
- * starting with the element that produced false for the predicate.
- *
- * @param data the array
- * @param predicate the predicate
- * @signature
- *    P.dropWhile(data, predicate)
- * @example
- *    P.dropWhile([1, 2, 10, 3, 4], x => x < 10) // => [10, 3, 4]
- * @dataFirst
- * @category Array
- */
-export declare function dropWhile<T>(data: ReadonlyArray<T>, predicate: (item: T) => boolean): Array<T>;
-/**
- * Removes elements from the beginning of the array until the predicate returns false.
- *
- * The predicate is applied to each element in the array, until the predicate returns false. The returned array includes the rest of the elements, starting with the element that produced false for the predicate.
- *
- * @param predicate the predicate
- * @signature
- *    P.dropWhile(predicate)(data)
- * @example
- *    P.pipe([1, 2, 10, 3, 4], P.dropWhile(x => x < 10))  // => [10, 3, 4]
- * @dataLast
- * @category Array
- */
-export declare function dropWhile<T>(predicate: (item: T) => boolean): (data: ReadonlyArray<T>) => Array<T>;
-//# sourceMappingURL=drop-while.d.ts.map