@vinicunca/perkakas 1.7.1 → 1.9.0

package/dist/curry.d.ts

@@ -1,64 +1,2 @@
-type LazyResult<T> = LazyEmpty | LazyMany<T> | LazyNext<T>;
-interface LazyEmpty {
-    done: boolean;
-    hasNext: false;
-    hasMany?: false | undefined;
-    next?: undefined;
-}
-interface LazyNext<T> {
-    done: boolean;
-    hasNext: true;
-    hasMany?: false | undefined;
-    next: T;
-}
-interface LazyMany<T> {
-    done: boolean;
-    hasNext: true;
-    hasMany: true;
-    next: ReadonlyArray<T>;
-}
-
-type LazyEvaluator<T = unknown, R = T> = (item: T, index: number, data: ReadonlyArray<T>) => LazyResult<R>;
-
-/**
- * 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 };
+import { curry } from "./curry-2mBj-wsI.js";
+export { curry };

package/dist/curry.js

@@ -1 +1 @@
-import{a}from"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";import"./chunk-EK7ODJWE.js";export{a as curry};
+import"./lazy-data-last-impl-7QfM1xXg.js";import{curry as e}from"./curry-CzZjDrpv.js";export{e as curry};

package/dist/debounce-6x-eQzOn.cjs

@@ -0,0 +1 @@
+function e(e,{waitMs:t,timing:n=`trailing`,maxWaitMs:r}){if(r!==void 0&&t!==void 0&&r<t)throw Error(`debounce: maxWaitMs (${r}) cannot be less than waitMs (${t})`);let i,a,o,s;function c(){if(a!==void 0){let e=a;a=void 0,clearTimeout(e)}if(o===void 0)throw Error(`PERKAKAS[debounce]: latestCallArgs was unexpectedly undefined.`);let t=o;o=void 0,s=e(...t)}function l(){if(i===void 0)return;let e=i;i=void 0,clearTimeout(e),o!==void 0&&c()}function u(e){o=e,r!==void 0&&a===void 0&&(a=setTimeout(c,r))}return{call:(...a)=>{if(i===void 0)n===`trailing`?u(a):s=e(...a);else{n!==`leading`&&u(a);let e=i;i=void 0,clearTimeout(e)}return i=setTimeout(l,t??r??0),s},cancel:()=>{if(i!==void 0){let e=i;i=void 0,clearTimeout(e)}if(a!==void 0){let e=a;a=void 0,clearTimeout(e)}o=void 0},flush:()=>(l(),s),get isPending(){return i!==void 0},get cachedValue(){return s}}}Object.defineProperty(exports,`debounce`,{enumerable:!0,get:function(){return e}});

package/dist/debounce-BNkJBFrQ.d.cts

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

package/dist/debounce-BNkJBFrQ.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce-BNkJBFrQ.d.cts","names":[],"sources":["../src/debounce.ts"],"sourcesContent":[],"mappings":";KAKK;EAAA;;;;;;;;;;WAuCmB,IAAA,EAAA,CAAA,GAAA,IAAA,EAxBX,UAwBW,CAxBA,CAwBA,CAAA,EAAA,GAvBjB,UAuBiB,CAvBN,CAuBM,CAAA,GAAA,CAAA,IAAA,SAvBa,UAuBb,GAAA,SAAA,GAAA,KAAA,CAAA;EAAU;AAAA;AAwDlC;;WACQ,MAAA,EAAA,GAAA,GAAA,IAAA;;;;;EAGQ,SAAA,KAAQ,EAAA,GAAA,GAvEA,UAuEA,CAvEW,CAuEX,CAAA,GAAA,SAAA;EAAA;;;;WAIjB,SAAA,EAAA,OAAA;;;;wBAhEiB,WAAW;;KAG9B,eAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqDW,gDACR,YACG;;IACR,UAAU;iBACG,gDACR,aAED;;MACA,KAAK;;KACT,UAAU"}

package/dist/debounce-BzjeDvY7.d.ts

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

package/dist/debounce-BzjeDvY7.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce-BzjeDvY7.d.ts","names":[],"sources":["../src/debounce.ts"],"sourcesContent":[],"mappings":";KAKK;EAAA;;;;;;;;;;WAuCmB,IAAA,EAAA,CAAA,GAAA,IAAA,EAxBX,UAwBW,CAxBA,CAwBA,CAAA,EAAA,GAvBjB,UAuBiB,CAvBN,CAuBM,CAAA,GAAA,CAAA,IAAA,SAvBa,UAuBb,GAAA,SAAA,GAAA,KAAA,CAAA;EAAU;AAAA;AAwDlC;;WACQ,MAAA,EAAA,GAAA,GAAA,IAAA;;;;;EAGQ,SAAA,KAAQ,EAAA,GAAA,GAvEA,UAuEA,CAvEW,CAuEX,CAAA,GAAA,SAAA;EAAA;;;;WAIjB,SAAA,EAAA,OAAA;;;;wBAhEiB,WAAW;;KAG9B,eAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqDW,gDACR,YACG;;IACR,UAAU;iBACG,gDACR,aAED;;MACA,KAAK;;KACT,UAAU"}

package/dist/debounce-C9xIAomT.js

@@ -0,0 +1,2 @@
+function e(e,{waitMs:t,timing:n=`trailing`,maxWaitMs:r}){if(r!==void 0&&t!==void 0&&r<t)throw Error(`debounce: maxWaitMs (${r}) cannot be less than waitMs (${t})`);let i,a,o,s;function c(){if(a!==void 0){let e=a;a=void 0,clearTimeout(e)}if(o===void 0)throw Error(`PERKAKAS[debounce]: latestCallArgs was unexpectedly undefined.`);let t=o;o=void 0,s=e(...t)}function l(){if(i===void 0)return;let e=i;i=void 0,clearTimeout(e),o!==void 0&&c()}function u(e){o=e,r!==void 0&&a===void 0&&(a=setTimeout(c,r))}return{call:(...a)=>{if(i===void 0)n===`trailing`?u(a):s=e(...a);else{n!==`leading`&&u(a);let e=i;i=void 0,clearTimeout(e)}return i=setTimeout(l,t??r??0),s},cancel:()=>{if(i!==void 0){let e=i;i=void 0,clearTimeout(e)}if(a!==void 0){let e=a;a=void 0,clearTimeout(e)}o=void 0},flush:()=>(l(),s),get isPending(){return i!==void 0},get cachedValue(){return s}}}export{e as debounce};
+//# sourceMappingURL=debounce-C9xIAomT.js.map

package/dist/debounce-C9xIAomT.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce-C9xIAomT.js","names":["coolDownTimeoutId: ReturnType<typeof setTimeout> | undefined","maxWaitTimeoutId: ReturnType<typeof setTimeout> | undefined","latestCallArgs: Parameters<F> | undefined","result: ReturnType<F> | undefined"],"sources":["../src/debounce.ts"],"sourcesContent":["/* eslint-disable ts/no-explicit-any, ts/consistent-type-definitions --\n * Function inference doesn't work when `unknown` is used as the parameters\n * generic type, it **has** to be `any`.\n */\n\ntype Debouncer<\n  F extends (...args: any) => unknown,\n  IsNullable extends boolean = true,\n> = {\n  /**\n   * Invoke the debounced function.\n   *\n   * @param args - Same as the args for the debounced function.\n   * @returns The last computed value of the debounced function with the\n   * latest args provided to it. If `timing` does not include `leading` then the\n   * the function would return `undefined` until the first cool-down period is\n   * over, otherwise the function would always return the return type of the\n   * debounced function.\n   */\n  readonly call: (\n    ...args: Parameters<F>\n  ) => ReturnType<F> | (true extends IsNullable ? undefined : never);\n\n  /**\n   * Cancels any debounced functions without calling them, effectively resetting\n   * the debouncer to the same state it is when initially created.\n   */\n  readonly cancel: () => void;\n\n  /**\n   * Similar to `cancel`, but would also trigger the `trailing` invocation if\n   * the debouncer would run one at the end of the cool-down period.\n   */\n  readonly flush: () => ReturnType<F> | undefined;\n\n  /**\n   * Is `true` when there is an active cool-down period currently debouncing\n   * invocations.\n   */\n  readonly isPending: boolean;\n\n  /**\n   * The last computed value of the debounced function.\n   */\n  readonly cachedValue: ReturnType<F> | undefined;\n};\n\ntype DebounceOptions = {\n  readonly waitMs?: number;\n  readonly maxWaitMs?: number;\n};\n\n/**\n * 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`).\n * It can also be configured to allow invocations during the cool-down period (`maxWaitMs`).\n * 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).\n * 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.\n * **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.\n *\n * @param func - The function to debounce, the returned `call` function will have\n * the exact same signature.\n * @param options - An object allowing further customization of the debouncer:\n * - `timing?: 'leading' | 'trailing' |'both'`. The default is `'trailing'`.\n *   `leading` would result in the function being invoked at the start of the\n *   cool-down period; `trailing` would result in the function being invoked at\n *   the end of the cool-down period (using the args from the last call to the\n *   debouncer). When `both` is selected the `trailing` invocation would only\n *   take place if there were more than one call to the debouncer during the\n *   cool-down period. **DEFAULT: 'trailing'**\n * - `waitMs?: number`. The length of the cool-down period in milliseconds. The\n *   debouncer would wait until this amount of time has passed without **any**\n *   additional calls to the debouncer before triggering the end-of-cool-down-\n *   period event. When this happens, the function would be invoked (if `timing`\n *   isn't `'leading'`) and the debouncer state would be reset. **DEFAULT: 0**\n * - `maxWaitMs?: number`. The length of time since a debounced call (a call\n *   that the debouncer prevented from being invoked) was made until it would be\n *   invoked. Because the debouncer can be continually triggered and thus never\n *   reach the end of the cool-down period, this allows the function to still\n *   be invoked occasionally. IMPORTANT: This param is ignored when `timing` is\n *   `'leading'`.\n * @returns A debouncer object. The main function is `call`. In addition to it\n * the debouncer comes with the following additional functions and properties:\n * - `cancel` method to cancel delayed `func` invocations\n * - `flush` method to end the cool-down period immediately.\n * - `cachedValue` the latest return value of an invocation (if one occurred).\n * - `isPending` flag to check if there is an inflight cool-down window.\n * @signature\n *   P.debounce(func, options);\n * @example\n *   const debouncer = debounce(identity(), { timing: 'trailing', waitMs: 1000 });\n *   const result1 = debouncer.call(1); // => undefined\n *   const result2 = debouncer.call(2); // => undefined\n *   // after 1 second\n *   const result3 = debouncer.call(3); // => 2\n *   // after 1 second\n *   debouncer.cachedValue; // => 3\n * @dataFirst\n * @category Function\n * @see https://css-tricks.com/debouncing-throttling-explained-examples/\n */\nexport function debounce<F extends (...args: any) => any>(\n  func: F,\n  options: DebounceOptions & { readonly timing?: 'trailing' },\n): Debouncer<F>;\nexport function debounce<F extends (...args: any) => any>(\n  func: F,\n  options:\n    | (DebounceOptions & { readonly timing: 'both' })\n    | (Omit<DebounceOptions, 'maxWaitMs'> & { readonly timing: 'leading' }),\n): Debouncer<F, false>;\n\nexport function debounce<F extends (...args: any) => any>(\n  func: F,\n  // eslint-disable-next-line antfu/consistent-list-newline\n  {\n    waitMs,\n    timing = 'trailing',\n    maxWaitMs,\n  }: DebounceOptions & {\n    readonly timing?: 'both' | 'leading' | 'trailing';\n  }): Debouncer<F> {\n  if (maxWaitMs !== undefined && waitMs !== undefined && maxWaitMs < waitMs) {\n    throw new Error(\n      `debounce: maxWaitMs (${maxWaitMs}) cannot be less than waitMs (${waitMs})`,\n    );\n  }\n\n  // All these are part of the debouncer runtime state:\n\n  // The timeout is the main object we use to tell if there's an active cool-\n  // down period or not.\n  let coolDownTimeoutId: ReturnType<typeof setTimeout> | undefined;\n\n  // We use an additional timeout to track how long the last debounced call is\n  // waiting.\n  let maxWaitTimeoutId: ReturnType<typeof setTimeout> | undefined;\n\n  // For 'trailing' invocations we need to keep the args around until we\n  // actually invoke the function.\n  let latestCallArgs: Parameters<F> | undefined;\n\n  // To make any value of the debounced function we need to be able to return a\n  // value. For any invocation except the first one when 'leading' is enabled we\n  // will return this cached value.\n  let result: ReturnType<F> | undefined;\n\n  function handleInvoke(): void {\n    if (maxWaitTimeoutId !== undefined) {\n      // We are invoking the function so the wait is over...\n      const timeoutId = maxWaitTimeoutId;\n      maxWaitTimeoutId = undefined;\n      clearTimeout(timeoutId);\n    }\n\n    /* v8 ignore next 7 -- This protects us against changes to the logic, there is no known flow we can simulate to reach this condition. It can only happen if a previous timeout isn't cleared (or faces a race condition clearing). */\n    if (latestCallArgs === undefined) {\n      throw new Error(\n        'PERKAKAS[debounce]: latestCallArgs was unexpectedly undefined.',\n      );\n    }\n\n    const args = latestCallArgs;\n    // Make sure the args aren't accidentally used again, this is mainly\n    // relevant for the check above where we'll fail a subsequent call to\n    // 'trailingEdge'.\n    latestCallArgs = undefined;\n\n    // Invoke the function and store the results locally.\n    result = func(...args);\n  };\n\n  function handleCoolDownEnd(): void {\n    if (coolDownTimeoutId === undefined) {\n      // It's rare to get here, it should only happen when `flush` is called\n      // when the cool-down window isn't active.\n      return;\n    }\n\n    // Make sure there are no more timers running.\n    const timeoutId = coolDownTimeoutId;\n    coolDownTimeoutId = undefined;\n    clearTimeout(timeoutId);\n    // Then reset state so a new cool-down window can begin on the next call.\n\n    if (latestCallArgs !== undefined) {\n      // If we have a debounced call waiting to be invoked at the end of the\n      // cool-down period we need to invoke it now.\n      handleInvoke();\n    }\n  };\n\n  function handleDebouncedCall(args: Parameters<F>): void {\n    // We save the latest call args so that (if and) when we invoke the function\n    // in the future, we have args to invoke it with.\n    latestCallArgs = args;\n\n    if (maxWaitMs !== undefined && maxWaitTimeoutId === undefined) {\n      // We only need to start the maxWait timeout once, on the first debounced\n      // call that is now being delayed.\n      maxWaitTimeoutId = setTimeout(handleInvoke, maxWaitMs);\n    }\n  };\n\n  return {\n    call: (...args) => {\n      if (coolDownTimeoutId === undefined) {\n        // This call is starting a new cool-down window!\n\n        if (timing === 'trailing') {\n          // Only when the timing is \"trailing\" is the first call \"debounced\".\n          handleDebouncedCall(args);\n        } else {\n          // Otherwise for \"leading\" and \"both\" the first call is actually\n          // called directly and not via a timeout.\n          result = func(...args);\n        }\n      } else {\n        // There's an inflight cool-down window.\n\n        if (timing !== 'leading') {\n          // When the timing is 'leading' all following calls are just ignored\n          // until the cool-down period ends. But for the other timings the call\n          // is \"debounced\".\n          handleDebouncedCall(args);\n        }\n\n        // The current timeout is no longer relevant because we need to wait the\n        // full `waitMs` time from this call.\n        const timeoutId = coolDownTimeoutId;\n        coolDownTimeoutId = undefined;\n        clearTimeout(timeoutId);\n      }\n\n      coolDownTimeoutId = setTimeout(\n        handleCoolDownEnd,\n        // If waitMs is not defined but maxWaitMs *is* it means the user is only\n        // interested in the leaky-bucket nature of the debouncer which is\n        // achieved by setting waitMs === maxWaitMs. If both are not defined we\n        // default to 0 which would wait until the end of the execution frame.\n        waitMs ?? maxWaitMs ?? 0,\n      );\n\n      // Return the last computed result while we \"debounce\" further calls.\n      return result;\n    },\n\n    cancel: () => {\n      // Reset all \"in-flight\" state of the debouncer. Notice that we keep the\n      // cached value!\n\n      if (coolDownTimeoutId !== undefined) {\n        const timeoutId = coolDownTimeoutId;\n        coolDownTimeoutId = undefined;\n        clearTimeout(timeoutId);\n      }\n\n      if (maxWaitTimeoutId !== undefined) {\n        const timeoutId = maxWaitTimeoutId;\n        maxWaitTimeoutId = undefined;\n        clearTimeout(timeoutId);\n      }\n\n      latestCallArgs = undefined;\n    },\n\n    flush: () => {\n      // Flush is just a manual way to trigger the end of the cool-down window.\n      handleCoolDownEnd();\n      return result;\n    },\n\n    get isPending() {\n      return coolDownTimeoutId !== undefined;\n    },\n\n    get cachedValue() {\n      return result;\n    },\n  };\n}\n"],"mappings":"AA+GA,SAAgB,EACd,EAEA,CACE,SACA,SAAS,WACT,aAGe,CACjB,GAAI,IAAc,IAAA,IAAa,IAAW,IAAA,IAAa,EAAY,EACjE,MAAU,MACR,wBAAwB,EAAU,gCAAgC,EAAO,GAC1E,CAOH,IAAIA,EAIAC,EAIAC,EAKAC,EAEJ,SAAS,GAAqB,CAC5B,GAAI,IAAqB,IAAA,GAAW,CAElC,IAAM,EAAY,EAClB,EAAmB,IAAA,GACnB,aAAa,EAAU,CAIzB,GAAI,IAAmB,IAAA,GACrB,MAAU,MACR,iEACD,CAGH,IAAM,EAAO,EAIb,EAAiB,IAAA,GAGjB,EAAS,EAAK,GAAG,EAAK,CAGxB,SAAS,GAA0B,CACjC,GAAI,IAAsB,IAAA,GAGxB,OAIF,IAAM,EAAY,EAClB,EAAoB,IAAA,GACpB,aAAa,EAAU,CAGnB,IAAmB,IAAA,IAGrB,GAAc,CAIlB,SAAS,EAAoB,EAA2B,CAGtD,EAAiB,EAEb,IAAc,IAAA,IAAa,IAAqB,IAAA,KAGlD,EAAmB,WAAW,EAAc,EAAU,EAI1D,MAAO,CACL,MAAO,GAAG,IAAS,CACjB,GAAI,IAAsB,IAAA,GAGpB,IAAW,WAEb,EAAoB,EAAK,CAIzB,EAAS,EAAK,GAAG,EAAK,KAEnB,CAGD,IAAW,WAIb,EAAoB,EAAK,CAK3B,IAAM,EAAY,EAClB,EAAoB,IAAA,GACpB,aAAa,EAAU,CAazB,MAVA,GAAoB,WAClB,EAKA,GAAU,GAAa,EACxB,CAGM,GAGT,WAAc,CAIZ,GAAI,IAAsB,IAAA,GAAW,CACnC,IAAM,EAAY,EAClB,EAAoB,IAAA,GACpB,aAAa,EAAU,CAGzB,GAAI,IAAqB,IAAA,GAAW,CAClC,IAAM,EAAY,EAClB,EAAmB,IAAA,GACnB,aAAa,EAAU,CAGzB,EAAiB,IAAA,IAGnB,WAEE,GAAmB,CACZ,GAGT,IAAI,WAAY,CACd,OAAO,IAAsB,IAAA,IAG/B,IAAI,aAAc,CAChB,OAAO,GAEV"}

package/dist/debounce.cjs

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

package/dist/debounce.d.cts

@@ -1,94 +1,2 @@
-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 };
+import { debounce } from "./debounce-BNkJBFrQ.cjs";
+export { debounce };

package/dist/debounce.d.ts

@@ -1,94 +1,2 @@
-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 };
+import { debounce } from "./debounce-BzjeDvY7.js";
+export { debounce };

package/dist/debounce.js

@@ -1 +1 @@
-import{a}from"./chunk-ENPSKQUH.js";import"./chunk-EK7ODJWE.js";export{a as debounce};
+import{debounce as e}from"./debounce-C9xIAomT.js";export{e as debounce};

package/dist/deduped-CAglY8bF.d.cts

@@ -0,0 +1,23 @@
+import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
+import { NonEmptyArray } from "./non-empty-array-D3ZRHApS.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 };
+//# sourceMappingURL=deduped-CAglY8bF.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deduped-CAglY8bF.d.cts","names":[],"sources":["../src/internal/types/deduped.ts"],"sourcesContent":[],"mappings":";;;;;;;AAiBA;;;;;;;;;;;;AAUc,KAVF,OAUE,CAAA,UAVgB,iBAUhB,CAAA,GAVqC,CAUrC,SAAA,SAAA,EAAA,GAAA,EAAA,GARV,CAQU,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAAA,CALP,IAKC,EAAK,GALG,KAKH,CALS,IAKT,CAAA,MAAA,CAAA,CAAA,IAJP,uBAAuB,2BAGvB,cAAc,aACZ,MAAM"}

package/dist/deduped-Dru_XVLX.d.ts

@@ -0,0 +1,23 @@
+import { IterableContainer } from "./iterable-container-F9CDF7ym.js";
+import { NonEmptyArray } from "./non-empty-array-BfTfvDYg.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 };
+//# sourceMappingURL=deduped-Dru_XVLX.d.ts.map

package/dist/deduped-Dru_XVLX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deduped-Dru_XVLX.d.ts","names":[],"sources":["../src/internal/types/deduped.ts"],"sourcesContent":[],"mappings":";;;;;;;AAiBA;;;;;;;;;;;;AAUc,KAVF,OAUE,CAAA,UAVgB,iBAUhB,CAAA,GAVqC,CAUrC,SAAA,SAAA,EAAA,GAAA,EAAA,GARV,CAQU,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAAA,CALP,IAKC,EAAK,GALG,KAKH,CALS,IAKT,CAAA,MAAA,CAAA,CAAA,IAJP,uBAAuB,2BAGvB,cAAc,aACZ,MAAM"}

package/dist/difference-B5WQzd-Z.cjs

@@ -0,0 +1 @@
+const e=require(`./utility-evaluators-DqJcWENu.cjs`),t=require(`./curry-from-lazy-BDH06qZ-.cjs`);function n(...e){return t.curryFromLazy(r,e)}function r(t){if(t.length===0)return e.lazyIdentityEvaluator;let n=new Map;for(let e of t)n.set(e,(n.get(e)??0)+1);return t=>{let r=n.get(t);return r===void 0||r===0?{done:!1,hasNext:!0,next:t}:(n.set(t,r-1),e.SKIP_ITEM)}}Object.defineProperty(exports,`difference`,{enumerable:!0,get:function(){return n}});

package/dist/difference-C1tclXTn.d.cts

@@ -0,0 +1,37 @@
+//#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-C1tclXTn.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"difference-C1tclXTn.d.cts","names":[],"sources":["../src/difference.ts"],"sourcesContent":[],"mappings":";;AAqBA;;;;;;;;;AAoBA;;;;;;AAEqC,iBAtBrB,UAsBqB,CAAA,CAAA,CAAA,CAAA,IAAA,EArB7B,aAqB6B,CArBf,CAqBe,CAAA,EAAA,KAAA,EApB5B,aAoB4B,CApBd,CAoBc,CAAA,CAAA,EAnBlC,KAmBkC,CAnB5B,CAmB4B,CAAA;;;;;;;;;;;;;;;;iBAFrB,qBACP,cAAc,YACb,cAAc,OAAO,MAAM"}

package/dist/difference-Dgeqsjn_.js

@@ -0,0 +1,2 @@
+import{SKIP_ITEM as e,lazyIdentityEvaluator as t}from"./utility-evaluators-CnQVdcZv.js";import{curryFromLazy as n}from"./curry-from-lazy-BR-hoRDR.js";function r(...e){return n(i,e)}function i(n){if(n.length===0)return t;let r=new Map;for(let e of n)r.set(e,(r.get(e)??0)+1);return t=>{let n=r.get(t);return n===void 0||n===0?{done:!1,hasNext:!0,next:t}:(r.set(t,n-1),e)}}export{r as difference};
+//# sourceMappingURL=difference-Dgeqsjn_.js.map

package/dist/difference-Dgeqsjn_.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"difference-Dgeqsjn_.js","names":[],"sources":["../src/difference.ts"],"sourcesContent":["import type { LazyEvaluator } from './internal/types/lazy-evaluator';\n\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { lazyIdentityEvaluator, SKIP_ITEM } from './internal/utility-evaluators';\n\n/**\n * Excludes the values from `other` array. The output maintains the same order\n * as the input. The inputs are treated as multi-sets/bags (multiple copies of\n * items are treated as unique items).\n *\n * @param data - The input items.\n * @param other - The values to exclude.\n * @signature\n *    P.difference(data, other)\n * @example\n *    P.difference([1, 2, 3, 4], [2, 5, 3]); // => [1, 4]\n *    P.difference([1, 1, 2, 2], [1]); // => [1, 2, 2]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function difference<T>(\n  data: ReadonlyArray<T>,\n  other: ReadonlyArray<T>,\n): Array<T>;\n\n/**\n * Excludes the values from `other` array. The output maintains the same order\n * as the input. The inputs are treated as multi-sets/bags (multiple copies of\n * items are treated as unique items).\n *\n * @param other - The values to exclude.\n * @signature\n *    P.difference(other)(data)\n * @example\n *    P.pipe([1, 2, 3, 4], P.difference([2, 5, 3])); // => [1, 4]\n *    P.pipe([1, 1, 2, 2], P.difference([1])); // => [1, 2, 2]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function difference<T>(\n  other: ReadonlyArray<T>,\n): (data: ReadonlyArray<T>) => Array<T>;\n\nexport function difference(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(other: ReadonlyArray<T>): LazyEvaluator<T> {\n  if (other.length === 0) {\n    return lazyIdentityEvaluator;\n  }\n\n  // We need to build a more efficient data structure that would allow us to\n  // keep track of the number of times we've seen a value in the other array.\n  const remaining = new Map<T, number>();\n  for (const value of other) {\n    remaining.set(value, (remaining.get(value) ?? 0) + 1);\n  }\n\n  return (value) => {\n    const copies = remaining.get(value);\n\n    if (copies === undefined || copies === 0) {\n      // The item is either not part of the other array or we've dropped enough\n      // copies of it so we return it.\n      return { done: false, hasNext: true, next: value };\n    }\n\n    // The item is equal to an item in the other array and there are still\n    // copies of it to \"account\" for so we skip this one and remove it from our\n    // ongoing tally.\n    remaining.set(value, copies - 1);\n    return SKIP_ITEM;\n  };\n}\n"],"mappings":"sJA6CA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAO,EAAc,EAAoB,EAAK,CAGhD,SAAS,EAAsB,EAA2C,CACxE,GAAI,EAAM,SAAW,EACnB,OAAO,EAKT,IAAM,EAAY,IAAI,IACtB,IAAK,IAAM,KAAS,EAClB,EAAU,IAAI,GAAQ,EAAU,IAAI,EAAM,EAAI,GAAK,EAAE,CAGvD,MAAQ,IAAU,CAChB,IAAM,EAAS,EAAU,IAAI,EAAM,CAYnC,OAVI,IAAW,IAAA,IAAa,IAAW,EAG9B,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO,EAMpD,EAAU,IAAI,EAAO,EAAS,EAAE,CACzB"}