@vinicunca/perkakas 0.5.4 → 1.0.0

package/dist/curry.d.cts

@@ -0,0 +1,44 @@
+import { LazyEvaluator } from './pipe.cjs';
+
+/**
+ * Creates a function with `dataFirst` and `dataLast` signatures.
+ *
+ * `curry` is a dynamic function and it's not type safe. It should be wrapped by
+ * a function that have proper typings. Refer to the example below for correct
+ * usage.
+ *
+ * !IMPORTANT: functions that simply call `curry` and return the result (like
+ * almost all functions in this library) should return `unknown` themselves if
+ * an explicit return type is required. This is because we currently don't
+ * provide a generic return type that is built from the input function, and
+ * crafting one manually isn't worthwhile as we rely on function declaration
+ * overloading to combine the types for dataFirst and dataLast invocations!
+ *
+ * @param fn - The function to curry.
+ * @param args - The arguments.
+ * @param lazy - A lazy version of the function to curry.
+ * @signature P.curry(fn, args);
+ * @example
+ *    function _findIndex(array, fn) {
+ *      for (let i = 0; i < array.length; i++) {
+ *        if (fn(array[i])) {
+ *          return i;
+ *        }
+ *      }
+ *      return -1;
+ *    }
+ *
+ *    // data-first
+ *    function findIndex<T>(array: T[], fn: (item: T) => boolean): number;
+ *
+ *    // data-last
+ *    function findIndex<T>(fn: (item: T) => boolean): (array: T[]) => number;
+ *
+ *    function findIndex(...args: unknown[]) {
+ *      return P.curry(_findIndex, args);
+ *    }
+ * @category Function
+ */
+declare function curry(fn: (...args: any) => unknown, args: ReadonlyArray<unknown>, lazy?: (...args: any) => LazyEvaluator): unknown;
+
+export { curry };

package/dist/curry.d.ts

@@ -0,0 +1,44 @@
+import { LazyEvaluator } from './pipe.js';
+
+/**
+ * Creates a function with `dataFirst` and `dataLast` signatures.
+ *
+ * `curry` is a dynamic function and it's not type safe. It should be wrapped by
+ * a function that have proper typings. Refer to the example below for correct
+ * usage.
+ *
+ * !IMPORTANT: functions that simply call `curry` and return the result (like
+ * almost all functions in this library) should return `unknown` themselves if
+ * an explicit return type is required. This is because we currently don't
+ * provide a generic return type that is built from the input function, and
+ * crafting one manually isn't worthwhile as we rely on function declaration
+ * overloading to combine the types for dataFirst and dataLast invocations!
+ *
+ * @param fn - The function to curry.
+ * @param args - The arguments.
+ * @param lazy - A lazy version of the function to curry.
+ * @signature P.curry(fn, args);
+ * @example
+ *    function _findIndex(array, fn) {
+ *      for (let i = 0; i < array.length; i++) {
+ *        if (fn(array[i])) {
+ *          return i;
+ *        }
+ *      }
+ *      return -1;
+ *    }
+ *
+ *    // data-first
+ *    function findIndex<T>(array: T[], fn: (item: T) => boolean): number;
+ *
+ *    // data-last
+ *    function findIndex<T>(fn: (item: T) => boolean): (array: T[]) => number;
+ *
+ *    function findIndex(...args: unknown[]) {
+ *      return P.curry(_findIndex, args);
+ *    }
+ * @category Function
+ */
+declare function curry(fn: (...args: any) => unknown, args: ReadonlyArray<unknown>, lazy?: (...args: any) => LazyEvaluator): unknown;
+
+export { curry };

package/dist/curry.js

@@ -0,0 +1 @@
+import{a}from"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as curry};

package/dist/debounce.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkOLZEQGPJcjs = require('./chunk-OLZEQGPJ.cjs');exports.debounce = _chunkOLZEQGPJcjs.a;

package/dist/debounce.d.cts

@@ -0,0 +1,94 @@
+type Debouncer<F extends (...args: any) => unknown, IsNullable extends boolean = true> = {
+    /**
+     * Invoke the debounced function.
+     *
+     * @param args - Same as the args for the debounced function.
+     * @returns The last computed value of the debounced function with the
+     * latest args provided to it. If `timing` does not include `leading` then the
+     * the function would return `undefined` until the first cool-down period is
+     * over, otherwise the function would always return the return type of the
+     * debounced function.
+     */
+    readonly call: (...args: Parameters<F>) => ReturnType<F> | (true extends IsNullable ? undefined : never);
+    /**
+     * Cancels any debounced functions without calling them, effectively resetting
+     * the debouncer to the same state it is when initially created.
+     */
+    readonly cancel: () => void;
+    /**
+     * Similar to `cancel`, but would also trigger the `trailing` invocation if
+     * the debouncer would run one at the end of the cool-down period.
+     */
+    readonly flush: () => ReturnType<F> | undefined;
+    /**
+     * Is `true` when there is an active cool-down period currently debouncing
+     * invocations.
+     */
+    readonly isPending: boolean;
+    /**
+     * The last computed value of the debounced function.
+     */
+    readonly cachedValue: ReturnType<F> | undefined;
+};
+type DebounceOptions = {
+    readonly waitMs?: number;
+    readonly maxWaitMs?: number;
+};
+/**
+ * Wraps `func` with a debouncer object that "debounces" (delays) invocations of the function during a defined cool-down period (`waitMs`). It can be configured to invoke the function either at the start of the cool-down period, the end of it, or at both ends (`timing`).
+ * It can also be configured to allow invocations during the cool-down period (`maxWaitMs`).
+ * It stores the latest call's arguments so they could be used at the end of the cool-down period when invoking `func` (if configured to invoke the function at the end of the cool-down period).
+ * It stores the value returned by `func` whenever its invoked. This value is returned on every call, and is accessible via the `cachedValue` property of the debouncer. Its important to note that the value might be different from the value that would be returned from running `func` with the current arguments as it is a cached value from a previous invocation.
+ * **Important**: The cool-down period defines the minimum between two invocations, and not the maximum. The period will be **extended** each time a call is made until a full cool-down period has elapsed without any additional calls.
+ *
+ * @param func - The function to debounce, the returned `call` function will have
+ * the exact same signature.
+ * @param options - An object allowing further customization of the debouncer:
+ * - `timing?: 'leading' | 'trailing' |'both'`. The default is `'trailing'`.
+ *   `leading` would result in the function being invoked at the start of the
+ *   cool-down period; `trailing` would result in the function being invoked at
+ *   the end of the cool-down period (using the args from the last call to the
+ *   debouncer). When `both` is selected the `trailing` invocation would only
+ *   take place if there were more than one call to the debouncer during the
+ *   cool-down period. **DEFAULT: 'trailing'**
+ * - `waitMs?: number`. The length of the cool-down period in milliseconds. The
+ *   debouncer would wait until this amount of time has passed without **any**
+ *   additional calls to the debouncer before triggering the end-of-cool-down-
+ *   period event. When this happens, the function would be invoked (if `timing`
+ *   isn't `'leading'`) and the debouncer state would be reset. **DEFAULT: 0**
+ * - `maxWaitMs?: number`. The length of time since a debounced call (a call
+ *   that the debouncer prevented from being invoked) was made until it would be
+ *   invoked. Because the debouncer can be continually triggered and thus never
+ *   reach the end of the cool-down period, this allows the function to still
+ *   be invoked occasionally. IMPORTANT: This param is ignored when `timing` is
+ *   `'leading'`.
+ * @returns A debouncer object. The main function is `call`. In addition to it
+ * the debouncer comes with the following additional functions and properties:
+ * - `cancel` method to cancel delayed `func` invocations
+ * - `flush` method to end the cool-down period immediately.
+ * - `cachedValue` the latest return value of an invocation (if one occurred).
+ * - `isPending` flag to check if there is an inflight cool-down window.
+ * @signature
+ *   P.debounce(func, options);
+ * @example
+ *   const debouncer = debounce(identity(), { timing: 'trailing', waitMs: 1000 });
+ *   const result1 = debouncer.call(1); // => undefined
+ *   const result2 = debouncer.call(2); // => undefined
+ *   // after 1 second
+ *   const result3 = debouncer.call(3); // => 2
+ *   // after 1 second
+ *   debouncer.cachedValue; // => 3
+ * @dataFirst
+ * @category Function
+ * @see https://css-tricks.com/debouncing-throttling-explained-examples/
+ */
+declare function debounce<F extends (...args: any) => any>(func: F, options: DebounceOptions & {
+    readonly timing?: 'trailing';
+}): Debouncer<F>;
+declare function debounce<F extends (...args: any) => any>(func: F, options: (DebounceOptions & {
+    readonly timing: 'both';
+}) | (Omit<DebounceOptions, 'maxWaitMs'> & {
+    readonly timing: 'leading';
+})): Debouncer<F, false>;
+
+export { debounce };

package/dist/debounce.d.ts

@@ -0,0 +1,94 @@
+type Debouncer<F extends (...args: any) => unknown, IsNullable extends boolean = true> = {
+    /**
+     * Invoke the debounced function.
+     *
+     * @param args - Same as the args for the debounced function.
+     * @returns The last computed value of the debounced function with the
+     * latest args provided to it. If `timing` does not include `leading` then the
+     * the function would return `undefined` until the first cool-down period is
+     * over, otherwise the function would always return the return type of the
+     * debounced function.
+     */
+    readonly call: (...args: Parameters<F>) => ReturnType<F> | (true extends IsNullable ? undefined : never);
+    /**
+     * Cancels any debounced functions without calling them, effectively resetting
+     * the debouncer to the same state it is when initially created.
+     */
+    readonly cancel: () => void;
+    /**
+     * Similar to `cancel`, but would also trigger the `trailing` invocation if
+     * the debouncer would run one at the end of the cool-down period.
+     */
+    readonly flush: () => ReturnType<F> | undefined;
+    /**
+     * Is `true` when there is an active cool-down period currently debouncing
+     * invocations.
+     */
+    readonly isPending: boolean;
+    /**
+     * The last computed value of the debounced function.
+     */
+    readonly cachedValue: ReturnType<F> | undefined;
+};
+type DebounceOptions = {
+    readonly waitMs?: number;
+    readonly maxWaitMs?: number;
+};
+/**
+ * Wraps `func` with a debouncer object that "debounces" (delays) invocations of the function during a defined cool-down period (`waitMs`). It can be configured to invoke the function either at the start of the cool-down period, the end of it, or at both ends (`timing`).
+ * It can also be configured to allow invocations during the cool-down period (`maxWaitMs`).
+ * It stores the latest call's arguments so they could be used at the end of the cool-down period when invoking `func` (if configured to invoke the function at the end of the cool-down period).
+ * It stores the value returned by `func` whenever its invoked. This value is returned on every call, and is accessible via the `cachedValue` property of the debouncer. Its important to note that the value might be different from the value that would be returned from running `func` with the current arguments as it is a cached value from a previous invocation.
+ * **Important**: The cool-down period defines the minimum between two invocations, and not the maximum. The period will be **extended** each time a call is made until a full cool-down period has elapsed without any additional calls.
+ *
+ * @param func - The function to debounce, the returned `call` function will have
+ * the exact same signature.
+ * @param options - An object allowing further customization of the debouncer:
+ * - `timing?: 'leading' | 'trailing' |'both'`. The default is `'trailing'`.
+ *   `leading` would result in the function being invoked at the start of the
+ *   cool-down period; `trailing` would result in the function being invoked at
+ *   the end of the cool-down period (using the args from the last call to the
+ *   debouncer). When `both` is selected the `trailing` invocation would only
+ *   take place if there were more than one call to the debouncer during the
+ *   cool-down period. **DEFAULT: 'trailing'**
+ * - `waitMs?: number`. The length of the cool-down period in milliseconds. The
+ *   debouncer would wait until this amount of time has passed without **any**
+ *   additional calls to the debouncer before triggering the end-of-cool-down-
+ *   period event. When this happens, the function would be invoked (if `timing`
+ *   isn't `'leading'`) and the debouncer state would be reset. **DEFAULT: 0**
+ * - `maxWaitMs?: number`. The length of time since a debounced call (a call
+ *   that the debouncer prevented from being invoked) was made until it would be
+ *   invoked. Because the debouncer can be continually triggered and thus never
+ *   reach the end of the cool-down period, this allows the function to still
+ *   be invoked occasionally. IMPORTANT: This param is ignored when `timing` is
+ *   `'leading'`.
+ * @returns A debouncer object. The main function is `call`. In addition to it
+ * the debouncer comes with the following additional functions and properties:
+ * - `cancel` method to cancel delayed `func` invocations
+ * - `flush` method to end the cool-down period immediately.
+ * - `cachedValue` the latest return value of an invocation (if one occurred).
+ * - `isPending` flag to check if there is an inflight cool-down window.
+ * @signature
+ *   P.debounce(func, options);
+ * @example
+ *   const debouncer = debounce(identity(), { timing: 'trailing', waitMs: 1000 });
+ *   const result1 = debouncer.call(1); // => undefined
+ *   const result2 = debouncer.call(2); // => undefined
+ *   // after 1 second
+ *   const result3 = debouncer.call(3); // => 2
+ *   // after 1 second
+ *   debouncer.cachedValue; // => 3
+ * @dataFirst
+ * @category Function
+ * @see https://css-tricks.com/debouncing-throttling-explained-examples/
+ */
+declare function debounce<F extends (...args: any) => any>(func: F, options: DebounceOptions & {
+    readonly timing?: 'trailing';
+}): Debouncer<F>;
+declare function debounce<F extends (...args: any) => any>(func: F, options: (DebounceOptions & {
+    readonly timing: 'both';
+}) | (Omit<DebounceOptions, 'maxWaitMs'> & {
+    readonly timing: 'leading';
+})): Debouncer<F, false>;
+
+export { debounce };

package/dist/debounce.js

@@ -0,0 +1 @@
+import{a}from"./chunk-ENPSKQUH.js";export{a as debounce};

package/dist/difference-with.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkKITVKWLPcjs = require('./chunk-KITVKWLP.cjs');require('./chunk-NLX7PGPI.cjs');require('./chunk-I6VXEY44.cjs');require('./chunk-3X6SAJDQ.cjs');exports.differenceWith = _chunkKITVKWLPcjs.a;

package/dist/difference-with.d.cts

@@ -0,0 +1,46 @@
+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.equals,
+ *    ) // => [{a: 1}, {a: 4}]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+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.equals,
+ *    )([{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.equals),
+ *      P.take(2),
+ *    ) // => [{a: 1}, {a: 4}]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function differenceWith<TFirst, TSecond>(other: ReadonlyArray<TSecond>, isEquals: IsEquals<TFirst, TSecond>): (array: ReadonlyArray<TFirst>) => Array<TFirst>;
+
+export { differenceWith };

package/dist/difference-with.d.ts

@@ -0,0 +1,46 @@
+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.equals,
+ *    ) // => [{a: 1}, {a: 4}]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+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.equals,
+ *    )([{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.equals),
+ *      P.take(2),
+ *    ) // => [{a: 1}, {a: 4}]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function differenceWith<TFirst, TSecond>(other: ReadonlyArray<TSecond>, isEquals: IsEquals<TFirst, TSecond>): (array: ReadonlyArray<TFirst>) => Array<TFirst>;
+
+export { differenceWith };

package/dist/difference-with.js

@@ -0,0 +1 @@
+import{a}from"./chunk-UNKQWZT6.js";import"./chunk-C6L5NLLB.js";import"./chunk-6ALZHU2N.js";import"./chunk-MYLYERXO.js";export{a as differenceWith};

package/dist/difference.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkA535Z4LWcjs = require('./chunk-A535Z4LW.cjs');require('./chunk-NLX7PGPI.cjs');require('./chunk-I6VXEY44.cjs');require('./chunk-3X6SAJDQ.cjs');exports.difference = _chunkA535Z4LWcjs.a;

package/dist/difference.d.cts

@@ -0,0 +1,35 @@
+/**
+ * Excludes the values from `other` array. The output maintains the same order
+ * as the input. The inputs are treated as multi-sets/bags (multiple copies of
+ * items are treated as unique items).
+ *
+ * @param data - The input items.
+ * @param other - The values to exclude.
+ * @signature
+ *    P.difference(data, other)
+ * @example
+ *    P.difference([1, 2, 3, 4], [2, 5, 3]); // => [1, 4]
+ *    P.difference([1, 1, 2, 2], [1]); // => [1, 2, 2]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function difference<T>(data: ReadonlyArray<T>, other: ReadonlyArray<T>): Array<T>;
+/**
+ * Excludes the values from `other` array. The output maintains the same order
+ * as the input. The inputs are treated as multi-sets/bags (multiple copies of
+ * items are treated as unique items).
+ *
+ * @param other - The values to exclude.
+ * @signature
+ *    P.difference(other)(data)
+ * @example
+ *    P.pipe([1, 2, 3, 4], P.difference([2, 5, 3])); // => [1, 4]
+ *    P.pipe([1, 1, 2, 2], P.difference([1])); // => [1, 2, 2]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function difference<T>(other: ReadonlyArray<T>): (data: ReadonlyArray<T>) => Array<T>;
+
+export { difference };

package/dist/difference.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Excludes the values from `other` array. The output maintains the same order
+ * as the input. The inputs are treated as multi-sets/bags (multiple copies of
+ * items are treated as unique items).
+ *
+ * @param data - The input items.
+ * @param other - The values to exclude.
+ * @signature
+ *    P.difference(data, other)
+ * @example
+ *    P.difference([1, 2, 3, 4], [2, 5, 3]); // => [1, 4]
+ *    P.difference([1, 1, 2, 2], [1]); // => [1, 2, 2]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function difference<T>(data: ReadonlyArray<T>, other: ReadonlyArray<T>): Array<T>;
+/**
+ * Excludes the values from `other` array. The output maintains the same order
+ * as the input. The inputs are treated as multi-sets/bags (multiple copies of
+ * items are treated as unique items).
+ *
+ * @param other - The values to exclude.
+ * @signature
+ *    P.difference(other)(data)
+ * @example
+ *    P.pipe([1, 2, 3, 4], P.difference([2, 5, 3])); // => [1, 4]
+ *    P.pipe([1, 1, 2, 2], P.difference([1])); // => [1, 2, 2]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function difference<T>(other: ReadonlyArray<T>): (data: ReadonlyArray<T>) => Array<T>;
+
+export { difference };

package/dist/difference.js

@@ -0,0 +1 @@
+import{a}from"./chunk-LG37S75J.js";import"./chunk-C6L5NLLB.js";import"./chunk-6ALZHU2N.js";import"./chunk-MYLYERXO.js";export{a as difference};

package/dist/divide.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkHBZ5F2DDcjs = require('./chunk-HBZ5F2DD.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.divide = _chunkHBZ5F2DDcjs.a;

package/dist/divide.d.cts

@@ -0,0 +1,31 @@
+/**
+ * Divides two numbers.
+ *
+ * @param value - The number.
+ * @param divisor - The number to divide the value by.
+ * @signature
+ *    P.divide(value, divisor);
+ * @example
+ *    P.divide(12, 3) // => 4
+ *    P.reduce([1, 2, 3, 4], P.divide, 24) // => 1
+ * @dataFirst
+ * @category Number
+ */
+declare function divide(value: bigint, divisor: bigint): bigint;
+declare function divide(value: number, divisor: number): number;
+/**
+ * Divides two numbers.
+ *
+ * @param divisor - The number to divide the value by.
+ * @signature
+ *    P.divide(divisor)(value);
+ * @example
+ *    P.divide(3)(12) // => 4
+ *    P.map([2, 4, 6, 8], P.divide(2)) // => [1, 2, 3, 4]
+ * @dataLast
+ * @category Number
+ */
+declare function divide(divisor: bigint): (value: bigint) => bigint;
+declare function divide(divisor: number): (value: number) => number;
+
+export { divide };

package/dist/divide.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Divides two numbers.
+ *
+ * @param value - The number.
+ * @param divisor - The number to divide the value by.
+ * @signature
+ *    P.divide(value, divisor);
+ * @example
+ *    P.divide(12, 3) // => 4
+ *    P.reduce([1, 2, 3, 4], P.divide, 24) // => 1
+ * @dataFirst
+ * @category Number
+ */
+declare function divide(value: bigint, divisor: bigint): bigint;
+declare function divide(value: number, divisor: number): number;
+/**
+ * Divides two numbers.
+ *
+ * @param divisor - The number to divide the value by.
+ * @signature
+ *    P.divide(divisor)(value);
+ * @example
+ *    P.divide(3)(12) // => 4
+ *    P.map([2, 4, 6, 8], P.divide(2)) // => [1, 2, 3, 4]
+ * @dataLast
+ * @category Number
+ */
+declare function divide(divisor: bigint): (value: bigint) => bigint;
+declare function divide(divisor: number): (value: number) => number;
+
+export { divide };

package/dist/divide.js

@@ -0,0 +1 @@
+import{a}from"./chunk-P3LGW6WA.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as divide};

package/dist/do-nothing.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkNULDWRPDcjs = require('./chunk-NULDWRPD.cjs');exports.doNothing = _chunkNULDWRPDcjs.a;

package/dist/do-nothing.d.cts

@@ -0,0 +1,26 @@
+/**
+ * A function that takes any arguments and does nothing with them. This is
+ * useful as a placeholder for any function or API that requires a **void**
+ * function (a function that doesn't return a value). This could also be used in
+ * combination with a ternary or other conditional execution to allow disabling
+ * a function call for a specific case.
+ *
+ * Notice that this is a dataLast impl where the function needs to be invoked
+ * to get the "do nothing" function.
+ *
+ * See also:
+ * `constant` - A function that ignores it's arguments and returns the same value on every invocation.
+ * `identity` - A function that returns the first argument it receives.
+ *
+ * @signature
+ *   P.doNothing();
+ * @example
+ *   myApi({ onSuccess: handleSuccess, onError: P.doNothing() });
+ *   myApi({ onSuccess: isDemoMode ? P.doNothing(): handleSuccess });
+ * @dataLast
+ * @category Function
+ */
+declare const doNothing: () => typeof doesNothing;
+declare function doesNothing<Args extends ReadonlyArray<unknown>>(..._args: Args): void;
+
+export { doNothing };

package/dist/do-nothing.d.ts

@@ -0,0 +1,26 @@
+/**
+ * A function that takes any arguments and does nothing with them. This is
+ * useful as a placeholder for any function or API that requires a **void**
+ * function (a function that doesn't return a value). This could also be used in
+ * combination with a ternary or other conditional execution to allow disabling
+ * a function call for a specific case.
+ *
+ * Notice that this is a dataLast impl where the function needs to be invoked
+ * to get the "do nothing" function.
+ *
+ * See also:
+ * `constant` - A function that ignores it's arguments and returns the same value on every invocation.
+ * `identity` - A function that returns the first argument it receives.
+ *
+ * @signature
+ *   P.doNothing();
+ * @example
+ *   myApi({ onSuccess: handleSuccess, onError: P.doNothing() });
+ *   myApi({ onSuccess: isDemoMode ? P.doNothing(): handleSuccess });
+ * @dataLast
+ * @category Function
+ */
+declare const doNothing: () => typeof doesNothing;
+declare function doesNothing<Args extends ReadonlyArray<unknown>>(..._args: Args): void;
+
+export { doNothing };

package/dist/do-nothing.js

@@ -0,0 +1 @@
+import{a}from"./chunk-PHKKU45J.js";export{a as doNothing};

package/dist/drop-first-by.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkBIAJ5KWRcjs = require('./chunk-BIAJ5KWR.cjs');require('./chunk-BWJDD26T.cjs');require('./chunk-5KO77UXQ.cjs');require('./chunk-FWQYL4Y4.cjs');require('./chunk-G66EZBJS.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.dropFirstBy = _chunkBIAJ5KWRcjs.a;

package/dist/drop-first-by.d.cts

@@ -0,0 +1,39 @@
+import { N as NonEmptyArray } from './types-DCY4LHuA.cjs';
+import { O as OrderRule } from './curry-order-rules-BOMf1JS7.cjs';
+import 'type-fest';
+
+/**
+ * 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`.
+ *
+ * @param data - The input array.
+ * @param 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
+ */
+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`.
+ *
+ * @param 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
+ */
+declare function dropFirstBy<T>(n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): (data: ReadonlyArray<T>) => Array<T>;
+
+export { dropFirstBy };