@vinicunca/perkakas 1.13.2 → 1.14.0

package/dist/debounce.d.cts

@@ -1,98 +0,0 @@
-import { t as StrictFunction } from "./strict-function-CPTwDgnZ.cjs";
-
-//#region src/debounce.d.ts
-type Debouncer<F extends StrictFunction, 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 StrictFunction>(func: F, options: DebounceOptions & {
-  readonly timing?: 'trailing';
-}): Debouncer<F>;
-declare function debounce<F extends StrictFunction>(func: F, options: (DebounceOptions & {
-  readonly timing: 'both';
-}) | (Omit<DebounceOptions, 'maxWaitMs'> & {
-  readonly timing: 'leading';
-})): Debouncer<F, false>;
-//#endregion
-export { debounce };
-//# sourceMappingURL=debounce.d.cts.map

package/dist/debounce.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"debounce.d.cts","names":[],"sources":["../src/debounce.ts"],"sourcesContent":[],"mappings":";;;KAOK,oBAAoB;;AAF8C;;;;;;;;;EAsCpC,SAAA,IAAA,EAAA,CAAA,GAAA,IAAA,EAxBtB,UAwBsB,CAxBX,CAwBW,CAAA,EAAA,GAvB5B,UAuB4B,CAvBjB,CAuBiB,CAAA,GAAA,CAAA,IAAA,SAvBE,UAuBF,GAAA,SAAA,GAAA,KAAA,CAAA;EAAX;;AAAU;AAwDlC;EAAmC,SAAA,MAAA,EAAA,GAAA,GAAA,IAAA;EAC3B;;;;EAEI,SAAA,KAAA,EAAA,GAAA,GAtEY,UAsEZ,CAtEuB,CAsEvB,CAAA,GAAA,SAAA;EACI;;;;EAIJ,SAAA,SAAA,EAAA,OAAA;EAAL;;;EACK,SAAA,WAAA,EAjEY,UAiEZ,CAjEuB,CAiEvB,CAAA,GAAA,SAAA;;KA9DP,eAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqDW,mBAAmB,sBAC3B,YACG;;IACR,UAAU;iBACG,mBAAmB,sBAC3B,aAED;;MACA,KAAK;;KACT,UAAU"}

package/dist/debounce.d.ts

@@ -1,98 +0,0 @@
-import { t as StrictFunction } from "./strict-function-BBgKFNUw.js";
-
-//#region src/debounce.d.ts
-type Debouncer<F extends StrictFunction, 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 StrictFunction>(func: F, options: DebounceOptions & {
-  readonly timing?: 'trailing';
-}): Debouncer<F>;
-declare function debounce<F extends StrictFunction>(func: F, options: (DebounceOptions & {
-  readonly timing: 'both';
-}) | (Omit<DebounceOptions, 'maxWaitMs'> & {
-  readonly timing: 'leading';
-})): Debouncer<F, false>;
-//#endregion
-export { debounce };
-//# sourceMappingURL=debounce.d.ts.map

package/dist/debounce.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"debounce.d.ts","names":[],"sources":["../src/debounce.ts"],"sourcesContent":[],"mappings":";;;KAOK,oBAAoB;;AAF8C;;;;;;;;;EAsCpC,SAAA,IAAA,EAAA,CAAA,GAAA,IAAA,EAxBtB,UAwBsB,CAxBX,CAwBW,CAAA,EAAA,GAvB5B,UAuB4B,CAvBjB,CAuBiB,CAAA,GAAA,CAAA,IAAA,SAvBE,UAuBF,GAAA,SAAA,GAAA,KAAA,CAAA;EAAX;;AAAU;AAwDlC;EAAmC,SAAA,MAAA,EAAA,GAAA,GAAA,IAAA;EAC3B;;;;EAEI,SAAA,KAAA,EAAA,GAAA,GAtEY,UAsEZ,CAtEuB,CAsEvB,CAAA,GAAA,SAAA;EACI;;;;EAIJ,SAAA,SAAA,EAAA,OAAA;EAAL;;;EACK,SAAA,WAAA,EAjEY,UAiEZ,CAjEuB,CAiEvB,CAAA,GAAA,SAAA;;KA9DP,eAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqDW,mBAAmB,sBAC3B,YACG;;IACR,UAAU;iBACG,mBAAmB,sBAC3B,aAED;;MACA,KAAK;;KACT,UAAU"}

package/dist/deduped-DdwAYzXs.d.cts

@@ -1,23 +0,0 @@
-import { t as IterableContainer } from "./iterable-container-1TN3AJ3s.cjs";
-import { t as NonEmptyArray } from "./non-empty-array-NDjbHRjk.cjs";
-
-//#region src/internal/types/deduped.d.ts
-
-/**
- * The result of running a function that would dedupe an array (`unique`,
- * `uniqueBy`, and `uniqueWith`).
- *
- * There are certain traits of the output which are unique to a deduped array
- * that allow us to create a better type; see comments inline.
- *
- * !Note: We can build better types for each of the unique functions
- * _separately_ by taking advantage of _other_ characteristics that are unique
- * to each one (e.g. in `unique` we know that each item that has a disjoint type
- * to all previous items would be part of the output, even when it isn't the
- * first), but to make this utility the most useful we kept it simple and
- * generic for now.
- */
-type Deduped<T extends IterableContainer> = T extends readonly [] ? [] : T extends readonly [infer Head, ...infer Rest] ? [Head, ...Array<Rest[number]>] : T extends readonly [...Array<unknown>, unknown] ? NonEmptyArray<T[number]> : Array<T[number]>;
-//#endregion
-export { Deduped as t };
-//# sourceMappingURL=deduped-DdwAYzXs.d.cts.map

package/dist/deduped-DdwAYzXs.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deduped-DdwAYzXs.d.cts","names":[],"sources":["../src/internal/types/deduped.ts"],"sourcesContent":[],"mappings":";;;;;;;AAiBA;;;;;;;;;;;;AAUQ,KAVI,OAUJ,CAAA,UAVsB,iBAUtB,CAAA,GAV2C,CAU3C,SAAA,SAAA,EAAA,GAAA,EAAA,GARJ,CAQI,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAAA,CALD,IAKM,KALG,MAAM,iBAChB,uBAAuB,2BAGvB,cAAc,aACZ,MAAM"}

package/dist/deduped-RY-1u-ns.d.ts

@@ -1,23 +0,0 @@
-import { t as IterableContainer } from "./iterable-container-Dv5vSKht.js";
-import { t as NonEmptyArray } from "./non-empty-array-DHAKSw6t.js";
-
-//#region src/internal/types/deduped.d.ts
-
-/**
- * The result of running a function that would dedupe an array (`unique`,
- * `uniqueBy`, and `uniqueWith`).
- *
- * There are certain traits of the output which are unique to a deduped array
- * that allow us to create a better type; see comments inline.
- *
- * !Note: We can build better types for each of the unique functions
- * _separately_ by taking advantage of _other_ characteristics that are unique
- * to each one (e.g. in `unique` we know that each item that has a disjoint type
- * to all previous items would be part of the output, even when it isn't the
- * first), but to make this utility the most useful we kept it simple and
- * generic for now.
- */
-type Deduped<T extends IterableContainer> = T extends readonly [] ? [] : T extends readonly [infer Head, ...infer Rest] ? [Head, ...Array<Rest[number]>] : T extends readonly [...Array<unknown>, unknown] ? NonEmptyArray<T[number]> : Array<T[number]>;
-//#endregion
-export { Deduped as t };
-//# sourceMappingURL=deduped-RY-1u-ns.d.ts.map

package/dist/deduped-RY-1u-ns.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deduped-RY-1u-ns.d.ts","names":[],"sources":["../src/internal/types/deduped.ts"],"sourcesContent":[],"mappings":";;;;;;;AAiBA;;;;;;;;;;;;AAUQ,KAVI,OAUJ,CAAA,UAVsB,iBAUtB,CAAA,GAV2C,CAU3C,SAAA,SAAA,EAAA,GAAA,EAAA,GARJ,CAQI,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAAA,CALD,IAKM,KALG,MAAM,iBAChB,uBAAuB,2BAGvB,cAAc,aACZ,MAAM"}

package/dist/difference-with.d.cts

@@ -1,48 +0,0 @@
-//#region src/difference-with.d.ts
-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>;
-//#endregion
-export { differenceWith };
-//# sourceMappingURL=difference-with.d.cts.map

package/dist/difference-with.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"difference-with.d.cts","names":[],"sources":["../src/difference-with.ts"],"sourcesContent":[],"mappings":";KAKK,gCAAgC,WAAW;;AAqBhD;;;;;;;;;;;AA4BA;;;;;;;AAGW,iBA/BK,cA+BL,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,KAAA,EA9BF,aA8BE,CA9BY,MA8BZ,CAAA,EAAA,KAAA,EA7BF,aA6BE,CA7BY,OA6BZ,CAAA,EAAA,QAAA,EA5BC,QA4BD,CA5BU,MA4BV,EA5BkB,OA4BlB,CAAA,CAAA,EA3BR,KA2BQ,CA3BF,MA2BE,CAAA;;;;;;;;;;;;;;;;;;;;;;;iBAHK,uCACP,cAAc,oBACX,SAAS,QAAQ,mBAClB,cAAc,YAAY,MAAM"}

package/dist/difference-with.d.ts

@@ -1,48 +0,0 @@
-//#region src/difference-with.d.ts
-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>;
-//#endregion
-export { differenceWith };
-//# sourceMappingURL=difference-with.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"difference-with.d.ts","names":[],"sources":["../src/difference-with.ts"],"sourcesContent":[],"mappings":";KAKK,gCAAgC,WAAW;;AAqBhD;;;;;;;;;;;AA4BA;;;;;;;AAGW,iBA/BK,cA+BL,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,KAAA,EA9BF,aA8BE,CA9BY,MA8BZ,CAAA,EAAA,KAAA,EA7BF,aA6BE,CA7BY,OA6BZ,CAAA,EAAA,QAAA,EA5BC,QA4BD,CA5BU,MA4BV,EA5BkB,OA4BlB,CAAA,CAAA,EA3BR,KA2BQ,CA3BF,MA2BE,CAAA;;;;;;;;;;;;;;;;;;;;;;;iBAHK,uCACP,cAAc,oBACX,SAAS,QAAQ,mBAClB,cAAc,YAAY,MAAM"}

package/dist/difference.d.cts

@@ -1,37 +0,0 @@
-//#region src/difference.d.ts
-/**
- * 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>;
-//#endregion
-export { difference };
-//# sourceMappingURL=difference.d.cts.map

package/dist/difference.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"difference.d.cts","names":[],"sources":["../src/difference.ts"],"sourcesContent":[],"mappings":";;AAqBA;;;;;;;;AAoBA;;;;;;;AAEoC,iBAtBpB,UAsBoB,CAAA,CAAA,CAAA,CAAA,IAAA,EArB5B,aAqB4B,CArBd,CAqBc,CAAA,EAAA,KAAA,EApB3B,aAoB2B,CApBb,CAoBa,CAAA,CAAA,EAnBjC,KAmBiC,CAnB3B,CAmB2B,CAAA;;;;;;;;;;;;;;;;iBAFpB,qBACP,cAAc,YACb,cAAc,OAAO,MAAM"}

package/dist/difference.d.ts

@@ -1,37 +0,0 @@
-//#region src/difference.d.ts
-/**
- * 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>;
-//#endregion
-export { difference };
-//# sourceMappingURL=difference.d.ts.map

package/dist/difference.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"difference.d.ts","names":[],"sources":["../src/difference.ts"],"sourcesContent":[],"mappings":";;AAqBA;;;;;;;;AAoBA;;;;;;;AAEoC,iBAtBpB,UAsBoB,CAAA,CAAA,CAAA,CAAA,IAAA,EArB5B,aAqB4B,CArBd,CAqBc,CAAA,EAAA,KAAA,EApB3B,aAoB2B,CApBb,CAoBa,CAAA,CAAA,EAnBjC,KAmBiC,CAnB3B,CAmB2B,CAAA;;;;;;;;;;;;;;;;iBAFpB,qBACP,cAAc,YACb,cAAc,OAAO,MAAM"}