@vinicunca/perkakas 1.12.0 → 1.13.0

package/dist/{conditional-F_nq8vtA.d.ts.map → conditional-CDez6uXp.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"conditional-F_nq8vtA.d.ts","names":[],"sources":["../src/internal/types/guard-type.ts","../src/conditional.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"conditional-CDez6uXp.d.ts","names":[],"sources":["../src/internal/types/guard-type.ts","../src/conditional.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/{conditional-lp8ZHACd.js → conditional-WbmvQs8H.js}

@@ -1,2 +1,2 @@
 function e(e,t,n){return e(n[0])?e=>t(e,...n):t(...n)}const t=Object.assign(n,{defaultCase:a});function n(...t){return e(i,r,t)}function r(e,...t){for(let n of t){if(typeof n==`function`)return n(e);let[t,r]=n;if(t(e))return r(e)}throw Error(`conditional: data failed for all cases`)}function i(e){if(!Array.isArray(e))return!1;let[t,n,...r]=e;return typeof t==`function`&&t.length<=1&&typeof n==`function`&&n.length<=1&&r.length===0}function a(e=s){return[o,e]}function o(){return!0}function s(){}export{t};
-//# sourceMappingURL=conditional-lp8ZHACd.js.map
+//# sourceMappingURL=conditional-WbmvQs8H.js.map

package/dist/{conditional-lp8ZHACd.js.map → conditional-WbmvQs8H.js.map}

@@ -1 +1 @@
-{"version":3,"file":"conditional-lp8ZHACd.js","names":["conditionalPlus: WithUtils<typeof conditional>"],"sources":["../src/internal/curry-on.ts","../src/conditional.ts"],"sourcesContent":["/**\n * Utility for currying functions based on a predicate for the first argument.\n *\n * This is useful for currying functions with a variadic argument list.\n */\nexport function curryOn<T>(\n  isArg: (firstArg: unknown) => firstArg is T,\n  implementation: (\n    data: unknown,\n    firstArg: T,\n    // eslint-disable-next-line ts/no-explicit-any -- Function inference in typescript relies on `any` to work, it doesn't work with `unknown`\n    ...args: any\n  ) => unknown,\n  args: ReadonlyArray<unknown>,\n): unknown {\n  return isArg(args[0])\n    // @ts-expect-error [ts2556] - This is a low-level function that assumes the function declaration and setup is correct and won't result in typing issues when called dynamically.\n    ? (data: unknown) => implementation(data, ...args)\n    // @ts-expect-error [ts2556] - This is a low-level function that assumes the function declaration and setup is correct and won't result in typing issues when called dynamically.\n    : implementation(...args);\n}\n","/* eslint-disable jsdoc/check-param-names -- we don't document the case params, it'd be redundant */\n\nimport type { GuardType } from './internal/types/guard-type';\nimport { curryOn } from './internal/curry-on';\n\ntype Case<\n  In,\n  Out,\n  When extends (x: In) => boolean = (x: In) => boolean,\n> = readonly [when: When, then: (x: GuardType<When, In> & In) => Out];\n\ntype DefaultCase<In, Out> = (x: In) => Out;\n\n// For easier discovery and to allow us to have a single exported function we\n// merge a set of utilities with the function itself. This provides a namespace-\n// like structure where the function could be used directly by calling it, but\n// also as the container of additional utilities.\ninterface Utilities {\n  readonly defaultCase: typeof defaultCase;\n}\ntype WithUtils<T> = T & Utilities;\n\nconst conditionalPlus: WithUtils<typeof conditional> = Object.assign(\n  conditional,\n  { defaultCase } satisfies Utilities,\n);\nexport { conditionalPlus as conditional };\n\n/**\n * Executes a transformer function based on the first matching predicate,\n * functioning like a series of `if...else if...` statements. It sequentially\n * evaluates each case and, upon finding a truthy predicate, runs the\n * corresponding transformer, and returns, ignoring any further cases, even if\n * they would match.\n *\n * NOTE*: Some type-predicates may fail to narrow the param type of their\n * transformer; in such cases wrap your type-predicate in an anonymous arrow\n * function: e.g., instead of\n * `conditional(..., [myTypePredicate, myTransformer], ...)`, use\n * `conditional(..., [($) => myTypePredicate($), myTransformer], ...)`.\n *\n * To add a a default, catch-all, case you can provide a single callback\n * function (instead of a 2-tuple) as the last case. This is equivalent to\n * adding a case with a trivial always-true predicate as it's condition (see\n * example).\n *\n * For simpler cases you should also consider using `when` instead.\n *\n * Due to TypeScript's inability to infer the result of negating a type-\n * predicate we can't refine the types used in subsequent cases based on\n * previous conditions. Using a `switch (true)` statement or ternary operators\n * is recommended for more precise type control when such type narrowing is\n * needed.\n *\n * !IMPORTANT! - Unlike similar implementations in Lodash and Ramda, this\n * implementation **doesn't** implicitly return `undefined` as a fallback when\n * when none of the cases match; and instead **throws** an exception in those\n * cases! You have to explicitly provide a default case, and can use\n * `constant(undefined)` as your last case to replicate that behavior.\n *\n * @param cases - A list of (up to 10) cases. Each case can be either:\n * - A 2-tuple consisting of a predicate (or type-predicate) and a transformer\n *   function that processes the data if the predicate matches.\n * - A single callback function that acts as a default fallback case.\n * @returns The output of the matched transformer. If no cases match, an\n * exception is thrown. The return type is a union of the return types of all\n * provided transformers.\n * @signature\n *   P.conditional(...cases)(data);\n * @example\n *   const nameOrId = 3 as string | number | boolean;\n *\n *   P.pipe(\n *     nameOrId,\n *     P.conditional(\n *       [P.isString, (name) => `Hello ${name}`],\n *       [P.isNumber, (id) => `Hello ID: ${id}`],\n *     ),\n *   ); //=> 'Hello ID: 3' (typed as `string`), can throw!.\n *\n *   P.pipe(\n *     nameOrId,\n *     P.conditional(\n *       [P.isString, (name) => `Hello ${name}`],\n *       [P.isNumber, (id) => `Hello ID: ${id}`],\n *       P.constant(undefined),\n *     ),\n *   ); //=> 'Hello ID: 3' (typed as `string | undefined`), won't throw.\n *\n *   P.pipe(\n *     nameOrId,\n *     P.conditional(\n *       [P.isString, (name) => `Hello ${name}`],\n *       [P.isNumber, (id) => `Hello ID: ${id}`],\n *       (something) => `Hello something (${JSON.stringify(something)})`,\n *     ),\n *   ); //=> 'Hello ID: 3' (typed as `string`), won't throw.\n * @dataLast\n * @category Function\n */\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Return0,\n  Fallback = never,\n>(\n  // TODO [>2]: TypeScript has problems inferring narrowed types within the case tuples, making it hard to work with this utility. Removing the tuple wrappers solves these issues without impacting the API too much.\n  case0: Case<T, Return0, Fn0>,\n  fallback?: DefaultCase<T, Fallback>,\n): (data: T) => Return0 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  // TODO [>2]: Exclude previous guarded types from the next functions in the chain. Although this isn't a prefect solution, it's the common approach to compute the \"negation\" of a type-predicate, and would provide a more comfortable API for bigger chains for cases like discriminated unions. This TODO is at the first occurrence where it is relevant, but it should be applied to **all** subsequent overloads. p.s. don't forget to update the docs too!\n  Fn1 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Fallback = never,\n>(\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  fallback?: DefaultCase<T, Fallback>,\n): (data: T) => Return0 | Return1 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Fallback = never,\n>(\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  fallback?: DefaultCase<T, Fallback>,\n): (data: T) => Return0 | Return1 | Return2 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Fallback = never,\n>(\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  fallback?: DefaultCase<T, Fallback>,\n): (data: T) => Return0 | Return1 | Return2 | Return3 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Fallback = never,\n>(\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  fallback?: DefaultCase<T, Fallback>,\n): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Fallback = never,\n>(\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  fallback?: DefaultCase<T, Fallback>,\n): (\n  data: T,\n) => Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Fn6 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Return6,\n  Fallback = never,\n>(\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  case6: Case<T, Return6, Fn6>,\n  fallback?: DefaultCase<T, Fallback>,\n): (\n  data: T,\n) =>\n  | Return0\n  | Return1\n  | Return2\n  | Return3\n  | Return4\n  | Return5\n  | Return6\n  | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Fn6 extends (x: T) => boolean,\n  Fn7 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Return6,\n  Return7,\n  Fallback = never,\n>(\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  case6: Case<T, Return6, Fn6>,\n  case7: Case<T, Return7, Fn7>,\n  fallback?: DefaultCase<T, Fallback>,\n): (\n  data: T,\n) =>\n  | Return0\n  | Return1\n  | Return2\n  | Return3\n  | Return4\n  | Return5\n  | Return6\n  | Return7\n  | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Fn6 extends (x: T) => boolean,\n  Fn7 extends (x: T) => boolean,\n  Fn8 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Return6,\n  Return7,\n  Return8,\n  Fallback = never,\n>(\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  case6: Case<T, Return6, Fn6>,\n  case7: Case<T, Return7, Fn7>,\n  case8: Case<T, Return8, Fn8>,\n  fallback?: DefaultCase<T, Fallback>,\n): (\n  data: T,\n) =>\n  | Return0\n  | Return1\n  | Return2\n  | Return3\n  | Return4\n  | Return5\n  | Return6\n  | Return7\n  | Return8\n  | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Fn6 extends (x: T) => boolean,\n  Fn7 extends (x: T) => boolean,\n  Fn8 extends (x: T) => boolean,\n  Fn9 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Return6,\n  Return7,\n  Return8,\n  Return9,\n  Fallback = never,\n>(\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  case6: Case<T, Return6, Fn6>,\n  case7: Case<T, Return7, Fn7>,\n  case8: Case<T, Return8, Fn8>,\n  case9: Case<T, Return9, Fn9>,\n  fallback?: DefaultCase<T, Fallback>,\n): (\n  data: T,\n) =>\n  | Return0\n  | Return1\n  | Return2\n  | Return3\n  | Return4\n  | Return5\n  | Return6\n  | Return7\n  | Return8\n  | Return9\n  | Fallback;\n\n/**\n * Executes a transformer function based on the first matching predicate,\n * functioning like a series of `if...else if...` statements. It sequentially\n * evaluates each case and, upon finding a truthy predicate, runs the\n * corresponding transformer, and returns, ignoring any further cases, even if\n * they would match.\n *\n * NOTE*: Some type-predicates may fail to narrow the param type of their\n * transformer; in such cases wrap your type-predicate in an anonymous arrow\n * function: e.g., instead of\n * `conditional(..., [myTypePredicate, myTransformer], ...)`, use\n * `conditional(..., [($) => myTypePredicate($), myTransformer], ...)`.\n *\n * To add a a default, catch-all, case you can provide a single callback\n * function (instead of a 2-tuple) as the last case. This is equivalent to\n * adding a case with a trivial always-true predicate as it's condition (see\n * example).\n *\n * For simpler cases you should also consider using `when` instead.\n *\n * Due to TypeScript's inability to infer the result of negating a type-\n * predicate we can't refine the types used in subsequent cases based on\n * previous conditions. Using a `switch (true)` statement or ternary operators\n * is recommended for more precise type control when such type narrowing is\n * needed.\n *\n * !IMPORTANT! - Unlike similar implementations in Lodash and Ramda, this\n * implementation **doesn't** implicitly return `undefined` as a fallback when\n * when none of the cases match; and instead **throws** an exception in those\n * cases! You have to explicitly provide a default case, and can use\n * `constant(undefined)` as your last case to replicate that behavior.\n *\n * @param data - The input data to be evaluated against the provided cases.\n * @param cases - A list of (up to 10) cases. Each case can be either:\n * - A 2-tuple consisting of a predicate (or type-predicate) and a transformer\n *   function that processes the data if the predicate matches.\n * - A single callback function that acts as a default fallback case.\n * @returns The output of the matched transformer. If no cases match, an\n * exception is thrown. The return type is a union of the return types of all\n * provided transformers.\n * @signature\n *   P.conditional(data, ...cases);\n * @example\n *   const nameOrId = 3 as string | number | boolean;\n *\n *   P.conditional(\n *     nameOrId,\n *     [P.isString, (name) => `Hello ${name}`],\n *     [P.isNumber, (id) => `Hello ID: ${id}`],\n *   ); //=> 'Hello ID: 3' (typed as `string`), can throw!.\n *\n *   P.conditional(\n *     nameOrId,\n *     [P.isString, (name) => `Hello ${name}`],\n *     [P.isNumber, (id) => `Hello ID: ${id}`],\n *     P.constant(undefined),\n *   ); //=> 'Hello ID: 3' (typed as `string | undefined`), won't throw.\n *\n *   P.conditional(\n *     nameOrId,\n *     [P.isString, (name) => `Hello ${name}`],\n *     [P.isNumber, (id) => `Hello ID: ${id}`],\n *     (something) => `Hello something (${JSON.stringify(something)})`,\n *   ); //=> 'Hello ID: 3' (typed as `string`), won't throw.\n * @dataFirst\n * @category Function\n */\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Return0,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  fallback?: DefaultCase<T, Fallback>,\n): Return0 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  fallback?: DefaultCase<T, Fallback>,\n): Return0 | Return1 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  fallback?: DefaultCase<T, Fallback>,\n): Return0 | Return1 | Return2 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  fallback?: DefaultCase<T, Fallback>,\n): Return0 | Return1 | Return2 | Return3 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  fallback?: DefaultCase<T, Fallback>,\n): Return0 | Return1 | Return2 | Return3 | Return4 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  fallback?: DefaultCase<T, Fallback>,\n): Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Fn6 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Return6,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  case6: Case<T, Return6, Fn6>,\n  fallback?: DefaultCase<T, Fallback>,\n):\n  | Return0\n  | Return1\n  | Return2\n  | Return3\n  | Return4\n  | Return5\n  | Return6\n  | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Fn6 extends (x: T) => boolean,\n  Fn7 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Return6,\n  Return7,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  case6: Case<T, Return6, Fn6>,\n  case7: Case<T, Return7, Fn7>,\n  fallback?: DefaultCase<T, Fallback>,\n):\n  | Return0\n  | Return1\n  | Return2\n  | Return3\n  | Return4\n  | Return5\n  | Return6\n  | Return7\n  | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Fn6 extends (x: T) => boolean,\n  Fn7 extends (x: T) => boolean,\n  Fn8 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Return6,\n  Return7,\n  Return8,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  case6: Case<T, Return6, Fn6>,\n  case7: Case<T, Return7, Fn7>,\n  case8: Case<T, Return8, Fn8>,\n  fallback?: DefaultCase<T, Fallback>,\n):\n  | Return0\n  | Return1\n  | Return2\n  | Return3\n  | Return4\n  | Return5\n  | Return6\n  | Return7\n  | Return8\n  | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Fn6 extends (x: T) => boolean,\n  Fn7 extends (x: T) => boolean,\n  Fn8 extends (x: T) => boolean,\n  Fn9 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Return6,\n  Return7,\n  Return8,\n  Return9,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  case6: Case<T, Return6, Fn6>,\n  case7: Case<T, Return7, Fn7>,\n  case8: Case<T, Return8, Fn8>,\n  case9: Case<T, Return9, Fn9>,\n  fallback?: DefaultCase<T, Fallback>,\n):\n  | Return0\n  | Return1\n  | Return2\n  | Return3\n  | Return4\n  | Return5\n  | Return6\n  | Return7\n  | Return8\n  | Return9\n  | Fallback;\n\nfunction conditional(...args: ReadonlyArray<unknown>): unknown {\n  return curryOn(isCase, conditionalImplementation, args);\n}\n\nfunction conditionalImplementation<In, Out>(\n  data: In,\n  ...cases: ReadonlyArray<Case<In, Out> | DefaultCase<In, Out>>\n): Out {\n  for (const current of cases) {\n    if (typeof current === 'function') {\n      return current(data);\n    }\n\n    const [when, then] = current;\n    if (when(data)) {\n      return then(data);\n    }\n  }\n\n  // TODO [>2]: When we built this function originally we didn't want to have to always return `undefined` and force users to always have to handle that case even when they knew it would never happen. In hindsight that was wrong and we can support this at the type-level without throwing. If users want to throw they can always have an explicit fallback that does that (and we might add a throw utility in v3 too!).\n  throw new Error('conditional: data failed for all cases');\n}\n\nfunction isCase(maybeCase: unknown): maybeCase is Case<unknown, unknown> {\n  if (!Array.isArray(maybeCase)) {\n    return false;\n  }\n\n  const [when, then, ...rest] = maybeCase as ReadonlyArray<unknown>;\n  return (\n    typeof when === 'function'\n    && when.length <= 1\n    && typeof then === 'function'\n    && then.length <= 1\n    && rest.length === 0\n  );\n}\n\n// TODO [2025-09-04]: Remove the deprecated `defaultCase` utility.\n/**\n *! **DEPRECATED**: `conditional` now accepts a default, catch-all, callback directly and no longer needs this utility wrapper. Use `constant(undefined)` as your last case instead (see example).\n *\n * @example\n *   const nameOrId = 3 as string | number;\n *   P.conditional(\n *     nameOrId,\n *     [P.isString, (name) => `Hello ${name}`],\n *     [P.isNumber, (id) => `Hello ID: ${id}`],\n *     // Was: `P.conditional.defaultCase(),`, Now:\n *     constant(undefined),\n *   ); //=> 'Hello ID: 3'\n * @deprecated `conditional` now accepts a default, catch-all, callback\n * directly and no longer needs this utility wrapper. Use `constant(undefined)`\n * as your last case instead (see example).\n */\nfunction defaultCase(): Case<unknown, undefined>;\n\n/**\n *! **DEPRECATED**: `conditional` now accepts a default, catch-all, callback directly and no longer needs this utility wrapper. Simply put your `then` callback as the last case (see example).\n *\n * @param then - You only need to provide the transformer, the predicate is\n * implicit. @default () => undefined, which is how Lodash and Ramda handle\n * the final fallback case.\n * @example\n *   const nameOrId = 3 as string | number;\n *   P.conditional(\n *     nameOrId,\n *     [P.isString, (name) => `Hello ${name}`],\n *     [P.isNumber, (id) => `Hello ID: ${id}`],\n *     // Was: `P.conditional.defaultCase(\n *     //  (something) => `Hello something (${JSON.stringify(something)})`,\n *     //),`, Now:\n *     (something) => `Hello something (${JSON.stringify(something)})`\n *   ); //=> 'Hello ID: 3'\n * @deprecated `conditional` now accepts a default, catch-all, callback\n * directly and no longer needs this utility wrapper. Simply put your `then`\n * callback as the last case.\n */\nfunction defaultCase<In, Then extends (param: In) => unknown>(\n  then: Then,\n): Case<In, ReturnType<Then>>;\nfunction defaultCase(\n  then: (data: unknown) => unknown = trivialDefaultCase,\n): Case<unknown, unknown> {\n  return [acceptAnything, then];\n}\n\n// We memoize this so it isn't recreated on every invocation of `defaultCase`.\nfunction acceptAnything(): boolean {\n  return true as const;\n}\n\n// Lodash and Ramda return `undefined` as the default case.\nfunction trivialDefaultCase(): undefined {\n  return undefined;\n}\n"],"mappings":"AAKA,SAAgB,EACd,EACA,EAMA,EACS,CACT,OAAO,EAAM,EAAK,GAAG,CAEhB,GAAkB,EAAe,EAAM,GAAG,EAAK,CAEhD,EAAe,GAAG,EAAK,CCG7B,MAAMA,EAAiD,OAAO,OAC5D,EACA,CAAE,cAAa,CAChB,CAssBD,SAAS,EAAY,GAAG,EAAuC,CAC7D,OAAO,EAAQ,EAAQ,EAA2B,EAAK,CAGzD,SAAS,EACP,EACA,GAAG,EACE,CACL,IAAK,IAAM,KAAW,EAAO,CAC3B,GAAI,OAAO,GAAY,WACrB,OAAO,EAAQ,EAAK,CAGtB,GAAM,CAAC,EAAM,GAAQ,EACrB,GAAI,EAAK,EAAK,CACZ,OAAO,EAAK,EAAK,CAKrB,MAAU,MAAM,yCAAyC,CAG3D,SAAS,EAAO,EAAyD,CACvE,GAAI,CAAC,MAAM,QAAQ,EAAU,CAC3B,MAAO,GAGT,GAAM,CAAC,EAAM,EAAM,GAAG,GAAQ,EAC9B,OACE,OAAO,GAAS,YACb,EAAK,QAAU,GACf,OAAO,GAAS,YAChB,EAAK,QAAU,GACf,EAAK,SAAW,EA+CvB,SAAS,EACP,EAAmC,EACX,CACxB,MAAO,CAAC,EAAgB,EAAK,CAI/B,SAAS,GAA0B,CACjC,MAAO,GAIT,SAAS,GAAgC"}
+{"version":3,"file":"conditional-WbmvQs8H.js","names":["conditionalPlus: WithUtils<typeof conditional>"],"sources":["../src/internal/curry-on.ts","../src/conditional.ts"],"sourcesContent":["/**\n * Utility for currying functions based on a predicate for the first argument.\n *\n * This is useful for currying functions with a variadic argument list.\n */\nexport function curryOn<T>(\n  isArg: (firstArg: unknown) => firstArg is T,\n  implementation: (\n    data: unknown,\n    firstArg: T,\n    // eslint-disable-next-line ts/no-explicit-any -- Function inference in typescript relies on `any` to work, it doesn't work with `unknown`\n    ...args: any\n  ) => unknown,\n  args: ReadonlyArray<unknown>,\n): unknown {\n  return isArg(args[0])\n    // @ts-expect-error [ts2556] - This is a low-level function that assumes the function declaration and setup is correct and won't result in typing issues when called dynamically.\n    ? (data: unknown) => implementation(data, ...args)\n    // @ts-expect-error [ts2556] - This is a low-level function that assumes the function declaration and setup is correct and won't result in typing issues when called dynamically.\n    : implementation(...args);\n}\n","/* eslint-disable jsdoc/check-param-names -- we don't document the case params, it'd be redundant */\n\nimport type { GuardType } from './internal/types/guard-type';\nimport { curryOn } from './internal/curry-on';\n\ntype Case<\n  In,\n  Out,\n  When extends (x: In) => boolean = (x: In) => boolean,\n> = readonly [when: When, then: (x: GuardType<When, In> & In) => Out];\n\ntype DefaultCase<In, Out> = (x: In) => Out;\n\n// For easier discovery and to allow us to have a single exported function we\n// merge a set of utilities with the function itself. This provides a namespace-\n// like structure where the function could be used directly by calling it, but\n// also as the container of additional utilities.\ninterface Utilities {\n  readonly defaultCase: typeof defaultCase;\n}\ntype WithUtils<T> = T & Utilities;\n\nconst conditionalPlus: WithUtils<typeof conditional> = Object.assign(\n  conditional,\n  { defaultCase } satisfies Utilities,\n);\nexport { conditionalPlus as conditional };\n\n/**\n * Executes a transformer function based on the first matching predicate,\n * functioning like a series of `if...else if...` statements. It sequentially\n * evaluates each case and, upon finding a truthy predicate, runs the\n * corresponding transformer, and returns, ignoring any further cases, even if\n * they would match.\n *\n * NOTE*: Some type-predicates may fail to narrow the param type of their\n * transformer; in such cases wrap your type-predicate in an anonymous arrow\n * function: e.g., instead of\n * `conditional(..., [myTypePredicate, myTransformer], ...)`, use\n * `conditional(..., [($) => myTypePredicate($), myTransformer], ...)`.\n *\n * To add a a default, catch-all, case you can provide a single callback\n * function (instead of a 2-tuple) as the last case. This is equivalent to\n * adding a case with a trivial always-true predicate as it's condition (see\n * example).\n *\n * For simpler cases you should also consider using `when` instead.\n *\n * Due to TypeScript's inability to infer the result of negating a type-\n * predicate we can't refine the types used in subsequent cases based on\n * previous conditions. Using a `switch (true)` statement or ternary operators\n * is recommended for more precise type control when such type narrowing is\n * needed.\n *\n * !IMPORTANT! - Unlike similar implementations in Lodash and Ramda, this\n * implementation **doesn't** implicitly return `undefined` as a fallback when\n * when none of the cases match; and instead **throws** an exception in those\n * cases! You have to explicitly provide a default case, and can use\n * `constant(undefined)` as your last case to replicate that behavior.\n *\n * @param cases - A list of (up to 10) cases. Each case can be either:\n * - A 2-tuple consisting of a predicate (or type-predicate) and a transformer\n *   function that processes the data if the predicate matches.\n * - A single callback function that acts as a default fallback case.\n * @returns The output of the matched transformer. If no cases match, an\n * exception is thrown. The return type is a union of the return types of all\n * provided transformers.\n * @signature\n *   P.conditional(...cases)(data);\n * @example\n *   const nameOrId = 3 as string | number | boolean;\n *\n *   P.pipe(\n *     nameOrId,\n *     P.conditional(\n *       [P.isString, (name) => `Hello ${name}`],\n *       [P.isNumber, (id) => `Hello ID: ${id}`],\n *     ),\n *   ); //=> 'Hello ID: 3' (typed as `string`), can throw!.\n *\n *   P.pipe(\n *     nameOrId,\n *     P.conditional(\n *       [P.isString, (name) => `Hello ${name}`],\n *       [P.isNumber, (id) => `Hello ID: ${id}`],\n *       P.constant(undefined),\n *     ),\n *   ); //=> 'Hello ID: 3' (typed as `string | undefined`), won't throw.\n *\n *   P.pipe(\n *     nameOrId,\n *     P.conditional(\n *       [P.isString, (name) => `Hello ${name}`],\n *       [P.isNumber, (id) => `Hello ID: ${id}`],\n *       (something) => `Hello something (${JSON.stringify(something)})`,\n *     ),\n *   ); //=> 'Hello ID: 3' (typed as `string`), won't throw.\n * @dataLast\n * @category Function\n */\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Return0,\n  Fallback = never,\n>(\n  // TODO [>2]: TypeScript has problems inferring narrowed types within the case tuples, making it hard to work with this utility. Removing the tuple wrappers solves these issues without impacting the API too much.\n  case0: Case<T, Return0, Fn0>,\n  fallback?: DefaultCase<T, Fallback>,\n): (data: T) => Return0 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  // TODO [>2]: Exclude previous guarded types from the next functions in the chain. Although this isn't a prefect solution, it's the common approach to compute the \"negation\" of a type-predicate, and would provide a more comfortable API for bigger chains for cases like discriminated unions. This TODO is at the first occurrence where it is relevant, but it should be applied to **all** subsequent overloads. p.s. don't forget to update the docs too!\n  Fn1 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Fallback = never,\n>(\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  fallback?: DefaultCase<T, Fallback>,\n): (data: T) => Return0 | Return1 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Fallback = never,\n>(\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  fallback?: DefaultCase<T, Fallback>,\n): (data: T) => Return0 | Return1 | Return2 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Fallback = never,\n>(\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  fallback?: DefaultCase<T, Fallback>,\n): (data: T) => Return0 | Return1 | Return2 | Return3 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Fallback = never,\n>(\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  fallback?: DefaultCase<T, Fallback>,\n): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Fallback = never,\n>(\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  fallback?: DefaultCase<T, Fallback>,\n): (\n  data: T,\n) => Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Fn6 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Return6,\n  Fallback = never,\n>(\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  case6: Case<T, Return6, Fn6>,\n  fallback?: DefaultCase<T, Fallback>,\n): (\n  data: T,\n) =>\n  | Return0\n  | Return1\n  | Return2\n  | Return3\n  | Return4\n  | Return5\n  | Return6\n  | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Fn6 extends (x: T) => boolean,\n  Fn7 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Return6,\n  Return7,\n  Fallback = never,\n>(\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  case6: Case<T, Return6, Fn6>,\n  case7: Case<T, Return7, Fn7>,\n  fallback?: DefaultCase<T, Fallback>,\n): (\n  data: T,\n) =>\n  | Return0\n  | Return1\n  | Return2\n  | Return3\n  | Return4\n  | Return5\n  | Return6\n  | Return7\n  | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Fn6 extends (x: T) => boolean,\n  Fn7 extends (x: T) => boolean,\n  Fn8 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Return6,\n  Return7,\n  Return8,\n  Fallback = never,\n>(\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  case6: Case<T, Return6, Fn6>,\n  case7: Case<T, Return7, Fn7>,\n  case8: Case<T, Return8, Fn8>,\n  fallback?: DefaultCase<T, Fallback>,\n): (\n  data: T,\n) =>\n  | Return0\n  | Return1\n  | Return2\n  | Return3\n  | Return4\n  | Return5\n  | Return6\n  | Return7\n  | Return8\n  | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Fn6 extends (x: T) => boolean,\n  Fn7 extends (x: T) => boolean,\n  Fn8 extends (x: T) => boolean,\n  Fn9 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Return6,\n  Return7,\n  Return8,\n  Return9,\n  Fallback = never,\n>(\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  case6: Case<T, Return6, Fn6>,\n  case7: Case<T, Return7, Fn7>,\n  case8: Case<T, Return8, Fn8>,\n  case9: Case<T, Return9, Fn9>,\n  fallback?: DefaultCase<T, Fallback>,\n): (\n  data: T,\n) =>\n  | Return0\n  | Return1\n  | Return2\n  | Return3\n  | Return4\n  | Return5\n  | Return6\n  | Return7\n  | Return8\n  | Return9\n  | Fallback;\n\n/**\n * Executes a transformer function based on the first matching predicate,\n * functioning like a series of `if...else if...` statements. It sequentially\n * evaluates each case and, upon finding a truthy predicate, runs the\n * corresponding transformer, and returns, ignoring any further cases, even if\n * they would match.\n *\n * NOTE*: Some type-predicates may fail to narrow the param type of their\n * transformer; in such cases wrap your type-predicate in an anonymous arrow\n * function: e.g., instead of\n * `conditional(..., [myTypePredicate, myTransformer], ...)`, use\n * `conditional(..., [($) => myTypePredicate($), myTransformer], ...)`.\n *\n * To add a a default, catch-all, case you can provide a single callback\n * function (instead of a 2-tuple) as the last case. This is equivalent to\n * adding a case with a trivial always-true predicate as it's condition (see\n * example).\n *\n * For simpler cases you should also consider using `when` instead.\n *\n * Due to TypeScript's inability to infer the result of negating a type-\n * predicate we can't refine the types used in subsequent cases based on\n * previous conditions. Using a `switch (true)` statement or ternary operators\n * is recommended for more precise type control when such type narrowing is\n * needed.\n *\n * !IMPORTANT! - Unlike similar implementations in Lodash and Ramda, this\n * implementation **doesn't** implicitly return `undefined` as a fallback when\n * when none of the cases match; and instead **throws** an exception in those\n * cases! You have to explicitly provide a default case, and can use\n * `constant(undefined)` as your last case to replicate that behavior.\n *\n * @param data - The input data to be evaluated against the provided cases.\n * @param cases - A list of (up to 10) cases. Each case can be either:\n * - A 2-tuple consisting of a predicate (or type-predicate) and a transformer\n *   function that processes the data if the predicate matches.\n * - A single callback function that acts as a default fallback case.\n * @returns The output of the matched transformer. If no cases match, an\n * exception is thrown. The return type is a union of the return types of all\n * provided transformers.\n * @signature\n *   P.conditional(data, ...cases);\n * @example\n *   const nameOrId = 3 as string | number | boolean;\n *\n *   P.conditional(\n *     nameOrId,\n *     [P.isString, (name) => `Hello ${name}`],\n *     [P.isNumber, (id) => `Hello ID: ${id}`],\n *   ); //=> 'Hello ID: 3' (typed as `string`), can throw!.\n *\n *   P.conditional(\n *     nameOrId,\n *     [P.isString, (name) => `Hello ${name}`],\n *     [P.isNumber, (id) => `Hello ID: ${id}`],\n *     P.constant(undefined),\n *   ); //=> 'Hello ID: 3' (typed as `string | undefined`), won't throw.\n *\n *   P.conditional(\n *     nameOrId,\n *     [P.isString, (name) => `Hello ${name}`],\n *     [P.isNumber, (id) => `Hello ID: ${id}`],\n *     (something) => `Hello something (${JSON.stringify(something)})`,\n *   ); //=> 'Hello ID: 3' (typed as `string`), won't throw.\n * @dataFirst\n * @category Function\n */\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Return0,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  fallback?: DefaultCase<T, Fallback>,\n): Return0 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  fallback?: DefaultCase<T, Fallback>,\n): Return0 | Return1 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  fallback?: DefaultCase<T, Fallback>,\n): Return0 | Return1 | Return2 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  fallback?: DefaultCase<T, Fallback>,\n): Return0 | Return1 | Return2 | Return3 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  fallback?: DefaultCase<T, Fallback>,\n): Return0 | Return1 | Return2 | Return3 | Return4 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  fallback?: DefaultCase<T, Fallback>,\n): Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Fn6 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Return6,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  case6: Case<T, Return6, Fn6>,\n  fallback?: DefaultCase<T, Fallback>,\n):\n  | Return0\n  | Return1\n  | Return2\n  | Return3\n  | Return4\n  | Return5\n  | Return6\n  | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Fn6 extends (x: T) => boolean,\n  Fn7 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Return6,\n  Return7,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  case6: Case<T, Return6, Fn6>,\n  case7: Case<T, Return7, Fn7>,\n  fallback?: DefaultCase<T, Fallback>,\n):\n  | Return0\n  | Return1\n  | Return2\n  | Return3\n  | Return4\n  | Return5\n  | Return6\n  | Return7\n  | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Fn6 extends (x: T) => boolean,\n  Fn7 extends (x: T) => boolean,\n  Fn8 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Return6,\n  Return7,\n  Return8,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  case6: Case<T, Return6, Fn6>,\n  case7: Case<T, Return7, Fn7>,\n  case8: Case<T, Return8, Fn8>,\n  fallback?: DefaultCase<T, Fallback>,\n):\n  | Return0\n  | Return1\n  | Return2\n  | Return3\n  | Return4\n  | Return5\n  | Return6\n  | Return7\n  | Return8\n  | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Fn6 extends (x: T) => boolean,\n  Fn7 extends (x: T) => boolean,\n  Fn8 extends (x: T) => boolean,\n  Fn9 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Return6,\n  Return7,\n  Return8,\n  Return9,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  case6: Case<T, Return6, Fn6>,\n  case7: Case<T, Return7, Fn7>,\n  case8: Case<T, Return8, Fn8>,\n  case9: Case<T, Return9, Fn9>,\n  fallback?: DefaultCase<T, Fallback>,\n):\n  | Return0\n  | Return1\n  | Return2\n  | Return3\n  | Return4\n  | Return5\n  | Return6\n  | Return7\n  | Return8\n  | Return9\n  | Fallback;\n\nfunction conditional(...args: ReadonlyArray<unknown>): unknown {\n  return curryOn(isCase, conditionalImplementation, args);\n}\n\nfunction conditionalImplementation<In, Out>(\n  data: In,\n  ...cases: ReadonlyArray<Case<In, Out> | DefaultCase<In, Out>>\n): Out {\n  for (const current of cases) {\n    if (typeof current === 'function') {\n      return current(data);\n    }\n\n    const [when, then] = current;\n    if (when(data)) {\n      return then(data);\n    }\n  }\n\n  // TODO [>2]: When we built this function originally we didn't want to have to always return `undefined` and force users to always have to handle that case even when they knew it would never happen. In hindsight that was wrong and we can support this at the type-level without throwing. If users want to throw they can always have an explicit fallback that does that (and we might add a throw utility in v3 too!).\n  throw new Error('conditional: data failed for all cases');\n}\n\nfunction isCase(maybeCase: unknown): maybeCase is Case<unknown, unknown> {\n  if (!Array.isArray(maybeCase)) {\n    return false;\n  }\n\n  const [when, then, ...rest] = maybeCase as ReadonlyArray<unknown>;\n  return (\n    typeof when === 'function'\n    && when.length <= 1\n    && typeof then === 'function'\n    && then.length <= 1\n    && rest.length === 0\n  );\n}\n\n// TODO [2025-09-04]: Remove the deprecated `defaultCase` utility.\n/**\n *! **DEPRECATED**: `conditional` now accepts a default, catch-all, callback directly and no longer needs this utility wrapper. Use `constant(undefined)` as your last case instead (see example).\n *\n * @example\n *   const nameOrId = 3 as string | number;\n *   P.conditional(\n *     nameOrId,\n *     [P.isString, (name) => `Hello ${name}`],\n *     [P.isNumber, (id) => `Hello ID: ${id}`],\n *     // Was: `P.conditional.defaultCase(),`, Now:\n *     constant(undefined),\n *   ); //=> 'Hello ID: 3'\n * @deprecated `conditional` now accepts a default, catch-all, callback\n * directly and no longer needs this utility wrapper. Use `constant(undefined)`\n * as your last case instead (see example).\n */\nfunction defaultCase(): Case<unknown, undefined>;\n\n/**\n *! **DEPRECATED**: `conditional` now accepts a default, catch-all, callback directly and no longer needs this utility wrapper. Simply put your `then` callback as the last case (see example).\n *\n * @param then - You only need to provide the transformer, the predicate is\n * implicit. @default () => undefined, which is how Lodash and Ramda handle\n * the final fallback case.\n * @example\n *   const nameOrId = 3 as string | number;\n *   P.conditional(\n *     nameOrId,\n *     [P.isString, (name) => `Hello ${name}`],\n *     [P.isNumber, (id) => `Hello ID: ${id}`],\n *     // Was: `P.conditional.defaultCase(\n *     //  (something) => `Hello something (${JSON.stringify(something)})`,\n *     //),`, Now:\n *     (something) => `Hello something (${JSON.stringify(something)})`\n *   ); //=> 'Hello ID: 3'\n * @deprecated `conditional` now accepts a default, catch-all, callback\n * directly and no longer needs this utility wrapper. Simply put your `then`\n * callback as the last case.\n */\nfunction defaultCase<In, Then extends (param: In) => unknown>(\n  then: Then,\n): Case<In, ReturnType<Then>>;\nfunction defaultCase(\n  then: (data: unknown) => unknown = trivialDefaultCase,\n): Case<unknown, unknown> {\n  return [acceptAnything, then];\n}\n\n// We memoize this so it isn't recreated on every invocation of `defaultCase`.\nfunction acceptAnything(): boolean {\n  return true as const;\n}\n\n// Lodash and Ramda return `undefined` as the default case.\nfunction trivialDefaultCase(): undefined {\n  return undefined;\n}\n"],"mappings":"AAKA,SAAgB,EACd,EACA,EAMA,EACS,CACT,OAAO,EAAM,EAAK,GAAG,CAEhB,GAAkB,EAAe,EAAM,GAAG,EAAK,CAEhD,EAAe,GAAG,EAAK,CCG7B,MAAMA,EAAiD,OAAO,OAC5D,EACA,CAAE,cAAa,CAChB,CAssBD,SAAS,EAAY,GAAG,EAAuC,CAC7D,OAAO,EAAQ,EAAQ,EAA2B,EAAK,CAGzD,SAAS,EACP,EACA,GAAG,EACE,CACL,IAAK,IAAM,KAAW,EAAO,CAC3B,GAAI,OAAO,GAAY,WACrB,OAAO,EAAQ,EAAK,CAGtB,GAAM,CAAC,EAAM,GAAQ,EACrB,GAAI,EAAK,EAAK,CACZ,OAAO,EAAK,EAAK,CAKrB,MAAU,MAAM,yCAAyC,CAG3D,SAAS,EAAO,EAAyD,CACvE,GAAI,CAAC,MAAM,QAAQ,EAAU,CAC3B,MAAO,GAGT,GAAM,CAAC,EAAM,EAAM,GAAG,GAAQ,EAC9B,OACE,OAAO,GAAS,YACb,EAAK,QAAU,GACf,OAAO,GAAS,YAChB,EAAK,QAAU,GACf,EAAK,SAAW,EA+CvB,SAAS,EACP,EAAmC,EACX,CACxB,MAAO,CAAC,EAAgB,EAAK,CAI/B,SAAS,GAA0B,CACjC,MAAO,GAIT,SAAS,GAAgC"}

package/dist/conditional.d.cts

@@ -1,2 +1,2 @@
-import { t as conditionalPlus } from "./conditional-tssGt6Vy.cjs";
+import { t as conditionalPlus } from "./conditional-Br0uqqc9.cjs";
 export { conditionalPlus as conditional };

package/dist/conditional.d.ts

@@ -1,2 +1,2 @@
-import { t as conditionalPlus } from "./conditional-F_nq8vtA.js";
+import { t as conditionalPlus } from "./conditional-CDez6uXp.js";
 export { conditionalPlus as conditional };

package/dist/conditional.js

@@ -1 +1 @@
-import{t as e}from"./conditional-lp8ZHACd.js";export{e as conditional};
+import{t as e}from"./conditional-WbmvQs8H.js";export{e as conditional};

package/dist/count-by.d.cts

@@ -1,4 +1,4 @@
-import { t as BoundedPartial } from "./bounded-partial-D6ouPlXl.cjs";
+import { t as BoundedPartial } from "./bounded-partial-CtOsGqxa.cjs";
 
 //#region src/count-by.d.ts
 

package/dist/count-by.d.ts

@@ -1,4 +1,4 @@
-import { t as BoundedPartial } from "./bounded-partial-DBIIClPU.js";
+import { t as BoundedPartial } from "./bounded-partial-CPc1XU57.js";
 
 //#region src/count-by.d.ts
 

package/dist/count-by.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-BcQ8Up1_.js";function t(...t){return e(n,t)}function n(e,t){let n=new Map;for(let[r,i]of e.entries()){let a=t(i,r,e);if(a!==void 0){let e=n.get(a);e===void 0?n.set(a,1):n.set(a,e+1)}}return Object.fromEntries(n)}export{t as countBy};
+import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){let n=new Map;for(let[r,i]of e.entries()){let a=t(i,r,e);if(a!==void 0){let e=n.get(a);e===void 0?n.set(a,1):n.set(a,e+1)}}return Object.fromEntries(n)}export{t as countBy};
 //# sourceMappingURL=count-by.js.map

package/dist/{curry-d8_p_Jzt.d.ts → curry-CKDQ1osk.d.ts}

@@ -1,3 +1,5 @@
+import { t as StrictFunction } from "./strict-function-BBgKFNUw.js";
+
 //#region src/internal/types/lazy-result.d.ts
 type LazyResult<T> = LazyEmpty | LazyMany<T> | LazyNext<T>;
 interface LazyEmpty {
@@ -62,7 +64,7 @@ type LazyEvaluator<T = unknown, R = T> = (item: T, index: number, data: Readonly
  *    }
  * @category Function
  */
-declare function curry(fn: (...args: any) => unknown, args: ReadonlyArray<unknown>, lazy?: (...args: any) => LazyEvaluator): unknown;
+declare function curry(fn: StrictFunction, args: ReadonlyArray<unknown>, lazy?: (...args: any) => LazyEvaluator): unknown;
 //#endregion
 export { curry as t };
-//# sourceMappingURL=curry-d8_p_Jzt.d.ts.map
+//# sourceMappingURL=curry-CKDQ1osk.d.ts.map

package/dist/curry-CKDQ1osk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curry-CKDQ1osk.d.ts","names":[],"sources":["../src/internal/types/lazy-result.ts","../src/internal/types/lazy-evaluator.ts","../src/curry.ts"],"sourcesContent":[],"mappings":";;;KAAY,gBAAgB,YAAY,SAAS,KAAK,SAAS;UAErD,SAAA;;EAFE,OAAA,EAAA,KAAU;EAAM,OAAA,CAAA,EAAA,KAAA,GAAA,SAAA;EAAqB,IAAA,CAAA,EAAA,SAAA;;UASvC,QATqD,CAAA,CAAA,CAAA,CAAA;EAAT,IAAA,EAAA,OAAA;EAAQ,OAAA,EAAA,IAAA;EAEpD,OAAA,CAAA,EAAA,KAAS,GAAA,SAAA;EAOT,IAAA,EAIF,CAJE;AAID;UAGC;;;ECdE,OAAA,EAAA,IAAA;EAA+B,IAAA,EDkBnC,aClBmC,CDkBrB,CClBqB,CAAA;;;;KAA/B,+BAA+B,YACnC,wBAEA,cAAc,OACjB,WAAW;;;;ADNhB;;;;;;;AAAkE;AAE/C;AAWV;;;;ACXT;;;;;;;;;;;AC2CA;;;;;;;;;;;;;;iBAAgB,KAAA,KACV,sBACE,iDACmB"}

package/dist/{curry-BcQ8Up1_.js → curry-NmniqyJ0.js}

@@ -1,2 +1,2 @@
-import{t as e}from"./lazy-data-last-impl-DW5TXWv8.js";function t(t,n,r){let i=t.length-n.length;if(i===0)return t(...n);if(i===1)return e(t,n,r);throw Error(`Wrong number of arguments`)}export{t};
-//# sourceMappingURL=curry-BcQ8Up1_.js.map
+import{t as e}from"./lazy-data-last-impl-R05wr4K6.js";function t(t,n,r){let i=t.length-n.length;if(i===0)return t(...n);if(i===1)return e(t,n,r);throw Error(`Wrong number of arguments`)}export{t};
+//# sourceMappingURL=curry-NmniqyJ0.js.map

package/dist/curry-NmniqyJ0.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"curry-NmniqyJ0.js","names":[],"sources":["../src/curry.ts"],"sourcesContent":["/* eslint-disable ts/no-explicit-any */\n\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport type { StrictFunction } from './internal/types/strict-function';\nimport { lazyDataLastImpl } from './internal/lazy-data-last-impl';\n\n/**\n * Creates a function with `dataFirst` and `dataLast` signatures.\n *\n * `curry` is a dynamic function and it's not type safe. It should be wrapped by\n * a function that have proper typings. Refer to the example below for correct\n * usage.\n *\n * !IMPORTANT: functions that simply call `curry` and return the result (like\n * almost all functions in this library) should return `unknown` themselves if\n * an explicit return type is required. This is because we currently don't\n * provide a generic return type that is built from the input function, and\n * crafting one manually isn't worthwhile as we rely on function declaration\n * overloading to combine the types for dataFirst and dataLast invocations!\n *\n * @param fn - The function to curry.\n * @param args - The arguments.\n * @param lazy - A lazy version of the function to curry.\n * @signature P.curry(fn, args);\n * @example\n *    function _findIndex(array, fn) {\n *      for (let i = 0; i < array.length; i++) {\n *        if (fn(array[i])) {\n *          return i;\n *        }\n *      }\n *      return -1;\n *    }\n *\n *    // data-first\n *    function findIndex<T>(array: T[], fn: (item: T) => boolean): number;\n *\n *    // data-last\n *    function findIndex<T>(fn: (item: T) => boolean): (array: T[]) => number;\n *\n *    function findIndex(...args: unknown[]) {\n *      return P.curry(_findIndex, args);\n *    }\n * @category Function\n */\nexport function curry(\n  fn: StrictFunction,\n  args: ReadonlyArray<unknown>,\n  lazy?: (...args: any) => LazyEvaluator,\n): unknown {\n  const diff = fn.length - args.length;\n  if (diff === 0) {\n    // @ts-expect-error [ts2345] -- This error is accurate because we don't know\n    // anything about `fn` so can't ensure that we are passing the correct\n    // arguments to it, we just have to trust that the caller knows what they\n    // are doing.\n    return fn(...args);\n  }\n\n  if (diff === 1) {\n    return lazyDataLastImpl(fn, args, lazy);\n  }\n\n  throw new Error('Wrong number of arguments');\n}\n"],"mappings":"sDA6CA,SAAgB,EACd,EACA,EACA,EACS,CACT,IAAM,EAAO,EAAG,OAAS,EAAK,OAC9B,GAAI,IAAS,EAKX,OAAO,EAAG,GAAG,EAAK,CAGpB,GAAI,IAAS,EACX,OAAO,EAAiB,EAAI,EAAM,EAAK,CAGzC,MAAU,MAAM,4BAA4B"}

package/dist/{curry-from-lazy-CYtJvyas.js → curry-from-lazy-PQ0BbG-7.js}

@@ -1,2 +1,2 @@
-import{t as e}from"./pipe-BGazHnZ_.js";function t(t,n){let r=n.length-t.length;if(r===1){let[r,...i]=n;return e(r,{lazy:t,lazyArgs:i})}if(r===0){let r={lazy:t,lazyArgs:n};return Object.assign(t=>e(t,r),r)}throw Error(`Wrong number of arguments`)}export{t};
-//# sourceMappingURL=curry-from-lazy-CYtJvyas.js.map
+import{t as e}from"./pipe-CZKusDA-.js";function t(t,n){let r=n.length-t.length;if(r===1){let[r,...i]=n;return e(r,{lazy:t,lazyArgs:i})}if(r===0){let r={lazy:t,lazyArgs:n};return Object.assign(t=>e(t,r),r)}throw Error(`Wrong number of arguments`)}export{t};
+//# sourceMappingURL=curry-from-lazy-PQ0BbG-7.js.map

package/dist/{curry-from-lazy-CYtJvyas.js.map → curry-from-lazy-PQ0BbG-7.js.map}

@@ -1 +1 @@
-{"version":3,"file":"curry-from-lazy-CYtJvyas.js","names":[],"sources":["../src/internal/curry-from-lazy.ts"],"sourcesContent":["import type { LazyDefinition } from './types/lazy-definition';\nimport type { LazyEvaluator } from './types/lazy-evaluator';\nimport { pipe } from '../pipe';\n\n/**\n * A version of `curry` for cases where the only meaningful implementation is a\n * lazy one. This is useful for functions that don't have a built-in\n * implementation already, and that can't be optimized to take advantage of\n * having the complete array upfront.\n *\n * Under the hood the function uses `pipe` to utilize it's built-in lazy logic\n * and wraps the pipe with the required invocations to allow using the function\n * outside of pipes too.\n *\n * @param lazy - The main lazy implementation, it assumes that data is an\n * iterable (array-like).\n * @param args - The arguments passed to the overloaded invocation.\n * @see curry\n * @see pipe\n */\nexport function curryFromLazy(\n  // eslint-disable-next-line ts/no-explicit-any\n  lazy: (...args: any) => LazyEvaluator,\n  args: ReadonlyArray<unknown>,\n): unknown {\n  const diff = args.length - lazy.length;\n\n  if (diff === 1) {\n    // dataFirst\n    const [data, ...rest] = args;\n    const lazyDefinition = { lazy, lazyArgs: rest } satisfies LazyDefinition;\n\n    // @ts-expect-error [ts2353] - Pipe expects a function which *might* also have a lazy definition. We are tricking pipe here to take our lazyDefinition without any function attached to it.\n    return pipe(data, lazyDefinition);\n  }\n\n  if (diff === 0) {\n    const lazyDefinition = { lazy, lazyArgs: args } satisfies LazyDefinition;\n\n    // @ts-expect-error [ts2353] - Pipe expects a function which *might* also have a lazy definition. We are tricking pipe here to take our lazyDefinition without any function attached to it.\n    const dataLast = (data: unknown): unknown => pipe(data, lazyDefinition);\n    return Object.assign(dataLast, lazyDefinition);\n  }\n\n  throw new Error('Wrong number of arguments');\n}\n"],"mappings":"uCAoBA,SAAgB,EAEd,EACA,EACS,CACT,IAAM,EAAO,EAAK,OAAS,EAAK,OAEhC,GAAI,IAAS,EAAG,CAEd,GAAM,CAAC,EAAM,GAAG,GAAQ,EAIxB,OAAO,EAAK,EAHW,CAAE,OAAM,SAAU,EAAM,CAGd,CAGnC,GAAI,IAAS,EAAG,CACd,IAAM,EAAiB,CAAE,OAAM,SAAU,EAAM,CAI/C,OAAO,OAAO,OADI,GAA2B,EAAK,EAAM,EAAe,CACxC,EAAe,CAGhD,MAAU,MAAM,4BAA4B"}
+{"version":3,"file":"curry-from-lazy-PQ0BbG-7.js","names":[],"sources":["../src/internal/curry-from-lazy.ts"],"sourcesContent":["import type { LazyDefinition } from './types/lazy-definition';\nimport type { LazyEvaluator } from './types/lazy-evaluator';\nimport { pipe } from '../pipe';\n\n/**\n * A version of `curry` for cases where the only meaningful implementation is a\n * lazy one. This is useful for functions that don't have a built-in\n * implementation already, and that can't be optimized to take advantage of\n * having the complete array upfront.\n *\n * Under the hood the function uses `pipe` to utilize it's built-in lazy logic\n * and wraps the pipe with the required invocations to allow using the function\n * outside of pipes too.\n *\n * @param lazy - The main lazy implementation, it assumes that data is an\n * iterable (array-like).\n * @param args - The arguments passed to the overloaded invocation.\n * @see curry\n * @see pipe\n */\nexport function curryFromLazy(\n  // eslint-disable-next-line ts/no-explicit-any\n  lazy: (...args: any) => LazyEvaluator,\n  args: ReadonlyArray<unknown>,\n): unknown {\n  const diff = args.length - lazy.length;\n\n  if (diff === 1) {\n    // dataFirst\n    const [data, ...rest] = args;\n    const lazyDefinition = { lazy, lazyArgs: rest } satisfies LazyDefinition;\n\n    // @ts-expect-error [ts2353] - Pipe expects a function which *might* also have a lazy definition. We are tricking pipe here to take our lazyDefinition without any function attached to it.\n    return pipe(data, lazyDefinition);\n  }\n\n  if (diff === 0) {\n    const lazyDefinition = { lazy, lazyArgs: args } satisfies LazyDefinition;\n\n    // @ts-expect-error [ts2353] - Pipe expects a function which *might* also have a lazy definition. We are tricking pipe here to take our lazyDefinition without any function attached to it.\n    const dataLast = (data: unknown): unknown => pipe(data, lazyDefinition);\n    return Object.assign(dataLast, lazyDefinition);\n  }\n\n  throw new Error('Wrong number of arguments');\n}\n"],"mappings":"uCAoBA,SAAgB,EAEd,EACA,EACS,CACT,IAAM,EAAO,EAAK,OAAS,EAAK,OAEhC,GAAI,IAAS,EAAG,CAEd,GAAM,CAAC,EAAM,GAAG,GAAQ,EAIxB,OAAO,EAAK,EAHW,CAAE,OAAM,SAAU,EAAM,CAGd,CAGnC,GAAI,IAAS,EAAG,CACd,IAAM,EAAiB,CAAE,OAAM,SAAU,EAAM,CAI/C,OAAO,OAAO,OADI,GAA2B,EAAK,EAAM,EAAe,CACxC,EAAe,CAGhD,MAAU,MAAM,4BAA4B"}

package/dist/{curry-B20xQM_9.d.cts → curry-mh6BKSIA.d.cts}

@@ -1,3 +1,5 @@
+import { t as StrictFunction } from "./strict-function-CPTwDgnZ.cjs";
+
 //#region src/internal/types/lazy-result.d.ts
 type LazyResult<T> = LazyEmpty | LazyMany<T> | LazyNext<T>;
 interface LazyEmpty {
@@ -62,7 +64,7 @@ type LazyEvaluator<T = unknown, R = T> = (item: T, index: number, data: Readonly
  *    }
  * @category Function
  */
-declare function curry(fn: (...args: any) => unknown, args: ReadonlyArray<unknown>, lazy?: (...args: any) => LazyEvaluator): unknown;
+declare function curry(fn: StrictFunction, args: ReadonlyArray<unknown>, lazy?: (...args: any) => LazyEvaluator): unknown;
 //#endregion
 export { curry as t };
-//# sourceMappingURL=curry-B20xQM_9.d.cts.map
+//# sourceMappingURL=curry-mh6BKSIA.d.cts.map

package/dist/curry-mh6BKSIA.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curry-mh6BKSIA.d.cts","names":[],"sources":["../src/internal/types/lazy-result.ts","../src/internal/types/lazy-evaluator.ts","../src/curry.ts"],"sourcesContent":[],"mappings":";;;KAAY,gBAAgB,YAAY,SAAS,KAAK,SAAS;UAErD,SAAA;;EAFE,OAAA,EAAA,KAAU;EAAM,OAAA,CAAA,EAAA,KAAA,GAAA,SAAA;EAAqB,IAAA,CAAA,EAAA,SAAA;;UASvC,QATqD,CAAA,CAAA,CAAA,CAAA;EAAT,IAAA,EAAA,OAAA;EAAQ,OAAA,EAAA,IAAA;EAEpD,OAAA,CAAA,EAAA,KAAS,GAAA,SAAA;EAOT,IAAA,EAIF,CAJE;AAID;UAGC;;;ECdE,OAAA,EAAA,IAAA;EAA+B,IAAA,EDkBnC,aClBmC,CDkBrB,CClBqB,CAAA;;;;KAA/B,+BAA+B,YACnC,wBAEA,cAAc,OACjB,WAAW;;;;ADNhB;;;;;;;AAAkE;AAE/C;AAWV;;;;ACXT;;;;;;;;;;;AC2CA;;;;;;;;;;;;;;iBAAgB,KAAA,KACV,sBACE,iDACmB"}

package/dist/{curry-order-rules-cezUWcSx.d.cts → curry-order-rules-BoF09Dq2.d.cts}

@@ -45,4 +45,4 @@ type ComparablePrimitive = bigint | boolean | number | string;
  */
 //#endregion
 export { OrderRule as t };
-//# sourceMappingURL=curry-order-rules-cezUWcSx.d.cts.map
+//# sourceMappingURL=curry-order-rules-BoF09Dq2.d.cts.map

package/dist/{curry-order-rules-cezUWcSx.d.cts.map → curry-order-rules-BoF09Dq2.d.cts.map}

@@ -1 +1 @@
-{"version":3,"file":"curry-order-rules-cezUWcSx.d.cts","names":[],"sources":["../src/internal/curry-order-rules.ts"],"sourcesContent":[],"mappings":";AAAgE,cAM1D,WAGI,EAAA;EAFI,SAAA,GAAA,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAM,CAAN,EAAA,GAAA,OAAA;EAAM,SAAA,IAAA,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EACL,CADK,EAAA,CAAA,EACC,CADD,EAAA,GAAA,OAAA;CACL;;;AAwBf;;;;;;;AAEgF;AAEvC;;;;;;AASC;;;;;KAb9B,eACN,WAAW,2BACW,WAAW,4BAA4B;KAE9D,oBAAoB,MAAM;KAK1B,UAAA,GACC;GACG,MAAA,CAAO,WAAA,qBAAgC;;;;iBAEzB;;KAIlB,mBAAA"}
+{"version":3,"file":"curry-order-rules-BoF09Dq2.d.cts","names":[],"sources":["../src/internal/curry-order-rules.ts"],"sourcesContent":[],"mappings":";AAAgE,cAM1D,WAGI,EAAA;EAFI,SAAA,GAAA,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAM,CAAN,EAAA,GAAA,OAAA;EAAM,SAAA,IAAA,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EACL,CADK,EAAA,CAAA,EACC,CADD,EAAA,GAAA,OAAA;CACL;;;AAwBf;;;;;;;AAEgF;AAEvC;;;;;;AASC;;;;;KAb9B,eACN,WAAW,2BACW,WAAW,4BAA4B;KAE9D,oBAAoB,MAAM;KAK1B,UAAA,GACC;GACG,MAAA,CAAO,WAAA,qBAAgC;;;;iBAEzB;;KAIlB,mBAAA"}

package/dist/{curry-order-rules-BCcwbNxd.d.ts → curry-order-rules-CoO4bk5I.d.ts}

@@ -45,4 +45,4 @@ type ComparablePrimitive = bigint | boolean | number | string;
  */
 //#endregion
 export { OrderRule as t };
-//# sourceMappingURL=curry-order-rules-BCcwbNxd.d.ts.map
+//# sourceMappingURL=curry-order-rules-CoO4bk5I.d.ts.map

package/dist/{curry-order-rules-BCcwbNxd.d.ts.map → curry-order-rules-CoO4bk5I.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"curry-order-rules-BCcwbNxd.d.ts","names":[],"sources":["../src/internal/curry-order-rules.ts"],"sourcesContent":[],"mappings":";AAAgE,cAM1D,WAGI,EAAA;EAFI,SAAA,GAAA,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAM,CAAN,EAAA,GAAA,OAAA;EAAM,SAAA,IAAA,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EACL,CADK,EAAA,CAAA,EACC,CADD,EAAA,GAAA,OAAA;CACL;;;AAwBf;;;;;;;AAEgF;AAEvC;;;;;;AASC;;;;;KAb9B,eACN,WAAW,2BACW,WAAW,4BAA4B;KAE9D,oBAAoB,MAAM;KAK1B,UAAA,GACC;GACG,MAAA,CAAO,WAAA,qBAAgC;;;;iBAEzB;;KAIlB,mBAAA"}
+{"version":3,"file":"curry-order-rules-CoO4bk5I.d.ts","names":[],"sources":["../src/internal/curry-order-rules.ts"],"sourcesContent":[],"mappings":";AAAgE,cAM1D,WAGI,EAAA;EAFI,SAAA,GAAA,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAM,CAAN,EAAA,GAAA,OAAA;EAAM,SAAA,IAAA,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EACL,CADK,EAAA,CAAA,EACC,CADD,EAAA,GAAA,OAAA;CACL;;;AAwBf;;;;;;;AAEgF;AAEvC;;;;;;AASC;;;;;KAb9B,eACN,WAAW,2BACW,WAAW,4BAA4B;KAE9D,oBAAoB,MAAM;KAK1B,UAAA,GACC;GACG,MAAA,CAAO,WAAA,qBAAgC;;;;iBAEzB;;KAIlB,mBAAA"}

package/dist/{curry-order-rules-C6bwcUwC.js → curry-order-rules-DwrF-_P1.js}

@@ -1,2 +1,2 @@
 const e={asc:(e,t)=>e>t,desc:(e,t)=>e<t};function t(e,t){let[n,...a]=t;if(!i(n))return e(n,r(...a));let o=r(n,...a);return t=>e(t,o)}function n(e,[n,r,...a]){let o,s;return i(r)?(o=n,s=[r,...a]):(o=r,s=[n,...a]),t((...t)=>e(...t,o),s)}function r(t,n,...i){let a=typeof t==`function`?t:t[0],o=typeof t==`function`?`asc`:t[1],{[o]:s}=e,c=n===void 0?void 0:r(n,...i);return(e,t)=>{let n=a(e),r=a(t);return s(n,r)?1:s(r,n)?-1:c?.(e,t)??0}}function i(t){if(a(t))return!0;if(typeof t!=`object`||!Array.isArray(t))return!1;let[n,r,...i]=t;return a(n)&&typeof r==`string`&&r in e&&i.length===0}function a(e){return typeof e==`function`&&e.length===1}export{n,t};
-//# sourceMappingURL=curry-order-rules-C6bwcUwC.js.map
+//# sourceMappingURL=curry-order-rules-DwrF-_P1.js.map

package/dist/{curry-order-rules-C6bwcUwC.js.map → curry-order-rules-DwrF-_P1.js.map}

@@ -1 +1 @@
-{"version":3,"file":"curry-order-rules-C6bwcUwC.js","names":["arg: unknown","argRemoved: ReadonlyArray<unknown>"],"sources":["../src/internal/curry-order-rules.ts"],"sourcesContent":["import type { CompareFunction } from './types/compare-function';\nimport type { NonEmptyArray } from './types/non-empty-array';\n\n// We define the comparators in a global const so that they are only\n// instantiated once, and so we can couple a label (string) for them that could\n// be used in runtime to refer to them (e.g. \"asc\", \"desc\").\nconst COMPARATORS = {\n  asc: <T>(x: T, y: T) => x > y,\n  desc: <T>(x: T, y: T) => x < y,\n} as const;\n\n/**\n * An order rule defines a projection/extractor that returns a comparable from\n * the data being compared. It would be run on each item being compared, and a\n * comparator would then be used on the results to determine the order.\n *\n * There are 2 forms of the order rule, a simple one which only provides the\n * projection function and assumes ordering is ascending, and a 2-tuple where\n * the first element is the projection function and the second is the direction;\n * this allows changing the direction without defining a more complex projection\n * to simply negate the value (e.g. `(x) => -x`).\n *\n * We rely on the javascript implementation of `<` and `>` for comparison, which\n * will attempt to transform both operands into a primitive comparable value via\n * the built in `valueOf` function (and then `toString`). It's up to the caller\n * to make sure that the projection is returning a value that makes sense for\n * this logic.\n *\n * It's important to note that there is no built-in caching/memoization of\n * projection function and therefore no guarantee that it would only be called\n * once.\n */\nexport type OrderRule<T>\n  = | Projection<T>\n    | readonly [projection: Projection<T>, direction: keyof typeof COMPARATORS];\n\ntype Projection<T> = (x: T) => Comparable;\n\n// We define the Comparable based on how JS coerces values into primitives when\n// used with the `<` and `>` operators.\n// @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#type_coercion\ntype Comparable\n  = | ComparablePrimitive\n    | { [Symbol.toPrimitive]: (hint: string) => ComparablePrimitive }\n    | { toString: () => string }\n    | { valueOf: () => ComparablePrimitive };\n\n//  Notice that `boolean` is special in that it is coerced as a number (0 for\n// `false`, 1 for `true`) implicitly.\ntype ComparablePrimitive = bigint | boolean | number | string;\n\n/**\n * Allows functions that want to handle a variadic number of order rules a\n * a simplified API that hides most of the implementation details. The only\n * thing users of this function need to do is provide a function that would take\n * the data, and a compare function that can be used to determine the order\n * between the items of the array.\n * This functions takes care of the rest; it will parse rules, built the\n * comparer, and manage the currying of the input arguments.\n */\nexport function curryOrderRules<T>(\n  func: (data: ReadonlyArray<T>, compareFn: CompareFunction<T>) => unknown,\n  inputArgs: ReadonlyArray<unknown>,\n): unknown {\n  // We rely on casting blindly here, but we rely on casting blindly everywhere\n  // else when we call curry so it's fine...\n  const [dataOrRule, ...rules] = inputArgs as\n    | [\n        data: OrderRule<T> | ReadonlyArray<T>,\n        ...rules: Readonly<NonEmptyArray<OrderRule<T>>>,\n    ]\n    | Readonly<NonEmptyArray<OrderRule<T>>>;\n\n  if (!isOrderRule<T>(dataOrRule)) {\n    // dataFirst!\n\n    // @ts-expect-error [ts2556]: Typescript is failing to infer the type of rules\n    // correctly here after the type refinement above, rules should be non-empty\n    // when we get here.\n    const compareFn = orderRuleComparer(...rules);\n    return func(dataOrRule, compareFn);\n  }\n\n  // dataLast!\n\n  // Important: initialize the comparer outside of the returned function so it\n  // it's constructed and shared everywhere (it's stateless so should be safe\n  // if used multiple times).\n  const compareFn = orderRuleComparer(dataOrRule, ...rules);\n  return (data: ReadonlyArray<T>) => func(data, compareFn);\n}\n\n/**\n * Some functions need an extra number argument, this helps facilitate that.\n */\nexport function curryOrderRulesWithArgument(\n  func: <T>(\n    data: ReadonlyArray<T>,\n    compareFn: CompareFunction<T>,\n    // eslint-disable-next-line ts/no-explicit-any -- Function inference in typescript relies on `any` to work, it doesn't work with `unknown`\n    arg: any,\n  ) => unknown,\n  [first, second, ...rest]: ReadonlyArray<unknown>,\n): unknown {\n  // We need to pull the `n` argument out to make it work with curryOrderRules.\n  let arg: unknown;\n  let argRemoved: ReadonlyArray<unknown>;\n  if (isOrderRule(second)) {\n    // dataLast!\n    arg = first;\n    argRemoved = [second, ...rest];\n  } else {\n    // dataFirst!\n    arg = second;\n    argRemoved = [first, ...rest];\n  }\n\n  return curryOrderRules((...args) => func(...args, arg), argRemoved);\n}\n\nfunction orderRuleComparer<T>(\n  primaryRule: OrderRule<T>,\n  secondaryRule?: OrderRule<T>,\n  ...otherRules: ReadonlyArray<OrderRule<T>>\n): (a: T, b: T) => number {\n  const projector\n    = typeof primaryRule === 'function' ? primaryRule : primaryRule[0];\n\n  const direction = typeof primaryRule === 'function' ? 'asc' : primaryRule[1];\n  const { [direction]: comparator } = COMPARATORS;\n\n  const nextComparer\n    = secondaryRule === undefined\n      ? undefined\n      : orderRuleComparer(secondaryRule, ...otherRules);\n\n  return (a, b) => {\n    const projectedA = projector(a);\n    const projectedB = projector(b);\n\n    if (comparator(projectedA, projectedB)) {\n      return 1;\n    }\n\n    if (comparator(projectedB, projectedA)) {\n      return -1;\n    }\n\n    // The elements are equal base on the current comparator and projection. So\n    // we need to check the elements using the next comparer, if one exists,\n    // otherwise we consider them as true equal (returning 0).\n    return nextComparer?.(a, b) ?? 0;\n  };\n}\n\nfunction isOrderRule<T>(x: unknown): x is OrderRule<T> {\n  if (isProjection(x)) {\n    return true;\n  }\n\n  if (typeof x !== 'object' || !Array.isArray(x)) {\n    return false;\n  }\n\n  const [maybeProjection, maybeDirection, ...rest]\n    = x as ReadonlyArray<unknown>;\n\n  return (\n    isProjection(maybeProjection)\n    && typeof maybeDirection === 'string'\n    && maybeDirection in COMPARATORS\n    // Has to be a 2-tuple\n    && rest.length === 0\n  );\n}\n\nfunction isProjection<T>(x: unknown): x is Projection<T> {\n  return typeof x === 'function' && x.length === 1;\n}\n"],"mappings":"AAMA,MAAM,EAAc,CAClB,KAAS,EAAM,IAAS,EAAI,EAC5B,MAAU,EAAM,IAAS,EAAI,EAC9B,CAmDD,SAAgB,EACd,EACA,EACS,CAGT,GAAM,CAAC,EAAY,GAAG,GAAS,EAO/B,GAAI,CAAC,EAAe,EAAW,CAO7B,OAAO,EAAK,EADM,EAAkB,GAAG,EAAM,CACX,CAQpC,IAAM,EAAY,EAAkB,EAAY,GAAG,EAAM,CACzD,MAAQ,IAA2B,EAAK,EAAM,EAAU,CAM1D,SAAgB,EACd,EAMA,CAAC,EAAO,EAAQ,GAAG,GACV,CAET,IAAIA,EACAC,EAWJ,OAVI,EAAY,EAAO,EAErB,EAAM,EACN,EAAa,CAAC,EAAQ,GAAG,EAAK,GAG9B,EAAM,EACN,EAAa,CAAC,EAAO,GAAG,EAAK,EAGxB,GAAiB,GAAG,IAAS,EAAK,GAAG,EAAM,EAAI,CAAE,EAAW,CAGrE,SAAS,EACP,EACA,EACA,GAAG,EACqB,CACxB,IAAM,EACF,OAAO,GAAgB,WAAa,EAAc,EAAY,GAE5D,EAAY,OAAO,GAAgB,WAAa,MAAQ,EAAY,GACpE,EAAG,GAAY,GAAe,EAE9B,EACF,IAAkB,IAAA,GAChB,IAAA,GACA,EAAkB,EAAe,GAAG,EAAW,CAErD,OAAQ,EAAG,IAAM,CACf,IAAM,EAAa,EAAU,EAAE,CACzB,EAAa,EAAU,EAAE,CAa/B,OAXI,EAAW,EAAY,EAAW,CAC7B,EAGL,EAAW,EAAY,EAAW,CAC7B,GAMF,IAAe,EAAG,EAAE,EAAI,GAInC,SAAS,EAAe,EAA+B,CACrD,GAAI,EAAa,EAAE,CACjB,MAAO,GAGT,GAAI,OAAO,GAAM,UAAY,CAAC,MAAM,QAAQ,EAAE,CAC5C,MAAO,GAGT,GAAM,CAAC,EAAiB,EAAgB,GAAG,GACvC,EAEJ,OACE,EAAa,EAAgB,EAC1B,OAAO,GAAmB,UAC1B,KAAkB,GAElB,EAAK,SAAW,EAIvB,SAAS,EAAgB,EAAgC,CACvD,OAAO,OAAO,GAAM,YAAc,EAAE,SAAW"}
+{"version":3,"file":"curry-order-rules-DwrF-_P1.js","names":["arg: unknown","argRemoved: ReadonlyArray<unknown>"],"sources":["../src/internal/curry-order-rules.ts"],"sourcesContent":["import type { CompareFunction } from './types/compare-function';\nimport type { NonEmptyArray } from './types/non-empty-array';\n\n// We define the comparators in a global const so that they are only\n// instantiated once, and so we can couple a label (string) for them that could\n// be used in runtime to refer to them (e.g. \"asc\", \"desc\").\nconst COMPARATORS = {\n  asc: <T>(x: T, y: T) => x > y,\n  desc: <T>(x: T, y: T) => x < y,\n} as const;\n\n/**\n * An order rule defines a projection/extractor that returns a comparable from\n * the data being compared. It would be run on each item being compared, and a\n * comparator would then be used on the results to determine the order.\n *\n * There are 2 forms of the order rule, a simple one which only provides the\n * projection function and assumes ordering is ascending, and a 2-tuple where\n * the first element is the projection function and the second is the direction;\n * this allows changing the direction without defining a more complex projection\n * to simply negate the value (e.g. `(x) => -x`).\n *\n * We rely on the javascript implementation of `<` and `>` for comparison, which\n * will attempt to transform both operands into a primitive comparable value via\n * the built in `valueOf` function (and then `toString`). It's up to the caller\n * to make sure that the projection is returning a value that makes sense for\n * this logic.\n *\n * It's important to note that there is no built-in caching/memoization of\n * projection function and therefore no guarantee that it would only be called\n * once.\n */\nexport type OrderRule<T>\n  = | Projection<T>\n    | readonly [projection: Projection<T>, direction: keyof typeof COMPARATORS];\n\ntype Projection<T> = (x: T) => Comparable;\n\n// We define the Comparable based on how JS coerces values into primitives when\n// used with the `<` and `>` operators.\n// @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#type_coercion\ntype Comparable\n  = | ComparablePrimitive\n    | { [Symbol.toPrimitive]: (hint: string) => ComparablePrimitive }\n    | { toString: () => string }\n    | { valueOf: () => ComparablePrimitive };\n\n//  Notice that `boolean` is special in that it is coerced as a number (0 for\n// `false`, 1 for `true`) implicitly.\ntype ComparablePrimitive = bigint | boolean | number | string;\n\n/**\n * Allows functions that want to handle a variadic number of order rules a\n * a simplified API that hides most of the implementation details. The only\n * thing users of this function need to do is provide a function that would take\n * the data, and a compare function that can be used to determine the order\n * between the items of the array.\n * This functions takes care of the rest; it will parse rules, built the\n * comparer, and manage the currying of the input arguments.\n */\nexport function curryOrderRules<T>(\n  func: (data: ReadonlyArray<T>, compareFn: CompareFunction<T>) => unknown,\n  inputArgs: ReadonlyArray<unknown>,\n): unknown {\n  // We rely on casting blindly here, but we rely on casting blindly everywhere\n  // else when we call curry so it's fine...\n  const [dataOrRule, ...rules] = inputArgs as\n    | [\n        data: OrderRule<T> | ReadonlyArray<T>,\n        ...rules: Readonly<NonEmptyArray<OrderRule<T>>>,\n    ]\n    | Readonly<NonEmptyArray<OrderRule<T>>>;\n\n  if (!isOrderRule<T>(dataOrRule)) {\n    // dataFirst!\n\n    // @ts-expect-error [ts2556]: Typescript is failing to infer the type of rules\n    // correctly here after the type refinement above, rules should be non-empty\n    // when we get here.\n    const compareFn = orderRuleComparer(...rules);\n    return func(dataOrRule, compareFn);\n  }\n\n  // dataLast!\n\n  // Important: initialize the comparer outside of the returned function so it\n  // it's constructed and shared everywhere (it's stateless so should be safe\n  // if used multiple times).\n  const compareFn = orderRuleComparer(dataOrRule, ...rules);\n  return (data: ReadonlyArray<T>) => func(data, compareFn);\n}\n\n/**\n * Some functions need an extra number argument, this helps facilitate that.\n */\nexport function curryOrderRulesWithArgument(\n  func: <T>(\n    data: ReadonlyArray<T>,\n    compareFn: CompareFunction<T>,\n    // eslint-disable-next-line ts/no-explicit-any -- Function inference in typescript relies on `any` to work, it doesn't work with `unknown`\n    arg: any,\n  ) => unknown,\n  [first, second, ...rest]: ReadonlyArray<unknown>,\n): unknown {\n  // We need to pull the `n` argument out to make it work with curryOrderRules.\n  let arg: unknown;\n  let argRemoved: ReadonlyArray<unknown>;\n  if (isOrderRule(second)) {\n    // dataLast!\n    arg = first;\n    argRemoved = [second, ...rest];\n  } else {\n    // dataFirst!\n    arg = second;\n    argRemoved = [first, ...rest];\n  }\n\n  return curryOrderRules((...args) => func(...args, arg), argRemoved);\n}\n\nfunction orderRuleComparer<T>(\n  primaryRule: OrderRule<T>,\n  secondaryRule?: OrderRule<T>,\n  ...otherRules: ReadonlyArray<OrderRule<T>>\n): (a: T, b: T) => number {\n  const projector\n    = typeof primaryRule === 'function' ? primaryRule : primaryRule[0];\n\n  const direction = typeof primaryRule === 'function' ? 'asc' : primaryRule[1];\n  const { [direction]: comparator } = COMPARATORS;\n\n  const nextComparer\n    = secondaryRule === undefined\n      ? undefined\n      : orderRuleComparer(secondaryRule, ...otherRules);\n\n  return (a, b) => {\n    const projectedA = projector(a);\n    const projectedB = projector(b);\n\n    if (comparator(projectedA, projectedB)) {\n      return 1;\n    }\n\n    if (comparator(projectedB, projectedA)) {\n      return -1;\n    }\n\n    // The elements are equal base on the current comparator and projection. So\n    // we need to check the elements using the next comparer, if one exists,\n    // otherwise we consider them as true equal (returning 0).\n    return nextComparer?.(a, b) ?? 0;\n  };\n}\n\nfunction isOrderRule<T>(x: unknown): x is OrderRule<T> {\n  if (isProjection(x)) {\n    return true;\n  }\n\n  if (typeof x !== 'object' || !Array.isArray(x)) {\n    return false;\n  }\n\n  const [maybeProjection, maybeDirection, ...rest]\n    = x as ReadonlyArray<unknown>;\n\n  return (\n    isProjection(maybeProjection)\n    && typeof maybeDirection === 'string'\n    && maybeDirection in COMPARATORS\n    // Has to be a 2-tuple\n    && rest.length === 0\n  );\n}\n\nfunction isProjection<T>(x: unknown): x is Projection<T> {\n  return typeof x === 'function' && x.length === 1;\n}\n"],"mappings":"AAMA,MAAM,EAAc,CAClB,KAAS,EAAM,IAAS,EAAI,EAC5B,MAAU,EAAM,IAAS,EAAI,EAC9B,CAmDD,SAAgB,EACd,EACA,EACS,CAGT,GAAM,CAAC,EAAY,GAAG,GAAS,EAO/B,GAAI,CAAC,EAAe,EAAW,CAO7B,OAAO,EAAK,EADM,EAAkB,GAAG,EAAM,CACX,CAQpC,IAAM,EAAY,EAAkB,EAAY,GAAG,EAAM,CACzD,MAAQ,IAA2B,EAAK,EAAM,EAAU,CAM1D,SAAgB,EACd,EAMA,CAAC,EAAO,EAAQ,GAAG,GACV,CAET,IAAIA,EACAC,EAWJ,OAVI,EAAY,EAAO,EAErB,EAAM,EACN,EAAa,CAAC,EAAQ,GAAG,EAAK,GAG9B,EAAM,EACN,EAAa,CAAC,EAAO,GAAG,EAAK,EAGxB,GAAiB,GAAG,IAAS,EAAK,GAAG,EAAM,EAAI,CAAE,EAAW,CAGrE,SAAS,EACP,EACA,EACA,GAAG,EACqB,CACxB,IAAM,EACF,OAAO,GAAgB,WAAa,EAAc,EAAY,GAE5D,EAAY,OAAO,GAAgB,WAAa,MAAQ,EAAY,GACpE,EAAG,GAAY,GAAe,EAE9B,EACF,IAAkB,IAAA,GAChB,IAAA,GACA,EAAkB,EAAe,GAAG,EAAW,CAErD,OAAQ,EAAG,IAAM,CACf,IAAM,EAAa,EAAU,EAAE,CACzB,EAAa,EAAU,EAAE,CAa/B,OAXI,EAAW,EAAY,EAAW,CAC7B,EAGL,EAAW,EAAY,EAAW,CAC7B,GAMF,IAAe,EAAG,EAAE,EAAI,GAInC,SAAS,EAAe,EAA+B,CACrD,GAAI,EAAa,EAAE,CACjB,MAAO,GAGT,GAAI,OAAO,GAAM,UAAY,CAAC,MAAM,QAAQ,EAAE,CAC5C,MAAO,GAGT,GAAM,CAAC,EAAiB,EAAgB,GAAG,GACvC,EAEJ,OACE,EAAa,EAAgB,EAC1B,OAAO,GAAmB,UAC1B,KAAkB,GAElB,EAAK,SAAW,EAIvB,SAAS,EAAgB,EAAgC,CACvD,OAAO,OAAO,GAAM,YAAc,EAAE,SAAW"}

package/dist/curry.d.cts

@@ -1,2 +1,2 @@
-import { t as curry } from "./curry-B20xQM_9.cjs";
+import { t as curry } from "./curry-mh6BKSIA.cjs";
 export { curry };

package/dist/curry.d.ts

@@ -1,2 +1,2 @@
-import { t as curry } from "./curry-d8_p_Jzt.js";
+import { t as curry } from "./curry-CKDQ1osk.js";
 export { curry };

package/dist/curry.js

@@ -1 +1 @@
-import{t as e}from"./curry-BcQ8Up1_.js";export{e as curry};
+import{t as e}from"./curry-NmniqyJ0.js";export{e as curry};

package/dist/debounce.d.cts

@@ -1,5 +1,7 @@
+import { t as StrictFunction } from "./strict-function-CPTwDgnZ.cjs";
+
 //#region src/debounce.d.ts
-type Debouncer<F extends (...args: any) => unknown, IsNullable extends boolean = true> = {
+type Debouncer<F extends StrictFunction, IsNullable extends boolean = true> = {
   /**
    * Invoke the debounced function.
    *
@@ -83,10 +85,10 @@ type DebounceOptions = {
  * @category Function
  * @see https://css-tricks.com/debouncing-throttling-explained-examples/
  */
-declare function debounce<F extends (...args: any) => any>(func: F, options: DebounceOptions & {
+declare function debounce<F extends StrictFunction>(func: F, options: DebounceOptions & {
   readonly timing?: 'trailing';
 }): Debouncer<F>;
-declare function debounce<F extends (...args: any) => any>(func: F, options: (DebounceOptions & {
+declare function debounce<F extends StrictFunction>(func: F, options: (DebounceOptions & {
   readonly timing: 'both';
 }) | (Omit<DebounceOptions, 'maxWaitMs'> & {
   readonly timing: 'leading';

package/dist/debounce.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"debounce.d.cts","names":[],"sources":["../src/debounce.ts"],"sourcesContent":[],"mappings":";KAKK;EAAA;;;;;;;;;;EAuC6B,SAAA,IAAA,EAAA,CAAA,GAAA,IAAA,EAxBrB,UAwBqB,CAxBV,CAwBU,CAAA,EAAA,GAvB3B,UAuB2B,CAvBhB,CAuBgB,CAAA,GAAA,CAAA,IAAA,SAvBG,UAuBH,GAAA,SAAA,GAAA,KAAA,CAAA;EAG7B;AAqDL;;;EAGa,SAAA,MAAA,EAAA,GAAA,GAAA,IAAA;EAAV;;AACH;;EAGO,SAAA,KAAA,EAAA,GAAA,GA1EiB,UA0EjB,CA1E4B,CA0E5B,CAAA,GAAA,SAAA;EACK;;;;EACA,SAAA,SAAA,EAAA,OAAA;;;;wBAjEY,WAAW;;KAG9B,eAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqDW,gDACR,YACG;;IACR,UAAU;iBACG,gDACR,aAED;;MACA,KAAK;;KACT,UAAU"}
+{"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,5 +1,7 @@
+import { t as StrictFunction } from "./strict-function-BBgKFNUw.js";
+
 //#region src/debounce.d.ts
-type Debouncer<F extends (...args: any) => unknown, IsNullable extends boolean = true> = {
+type Debouncer<F extends StrictFunction, IsNullable extends boolean = true> = {
   /**
    * Invoke the debounced function.
    *
@@ -83,10 +85,10 @@ type DebounceOptions = {
  * @category Function
  * @see https://css-tricks.com/debouncing-throttling-explained-examples/
  */
-declare function debounce<F extends (...args: any) => any>(func: F, options: DebounceOptions & {
+declare function debounce<F extends StrictFunction>(func: F, options: DebounceOptions & {
   readonly timing?: 'trailing';
 }): Debouncer<F>;
-declare function debounce<F extends (...args: any) => any>(func: F, options: (DebounceOptions & {
+declare function debounce<F extends StrictFunction>(func: F, options: (DebounceOptions & {
   readonly timing: 'both';
 }) | (Omit<DebounceOptions, 'maxWaitMs'> & {
   readonly timing: 'leading';

package/dist/debounce.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"debounce.d.ts","names":[],"sources":["../src/debounce.ts"],"sourcesContent":[],"mappings":";KAKK;EAAA;;;;;;;;;;EAuC6B,SAAA,IAAA,EAAA,CAAA,GAAA,IAAA,EAxBrB,UAwBqB,CAxBV,CAwBU,CAAA,EAAA,GAvB3B,UAuB2B,CAvBhB,CAuBgB,CAAA,GAAA,CAAA,IAAA,SAvBG,UAuBH,GAAA,SAAA,GAAA,KAAA,CAAA;EAG7B;AAqDL;;;EAGa,SAAA,MAAA,EAAA,GAAA,GAAA,IAAA;EAAV;;AACH;;EAGO,SAAA,KAAA,EAAA,GAAA,GA1EiB,UA0EjB,CA1E4B,CA0E5B,CAAA,GAAA,SAAA;EACK;;;;EACA,SAAA,SAAA,EAAA,OAAA;;;;wBAjEY,WAAW;;KAG9B,eAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqDW,gDACR,YACG;;IACR,UAAU;iBACG,gDACR,aAED;;MACA,KAAK;;KACT,UAAU"}
+{"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/debounce.js.map

@@ -1 +1 @@
-{"version":3,"file":"debounce.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"}
+{"version":3,"file":"debounce.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/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\nimport type { StrictFunction } from './internal/types/strict-function';\n\ntype Debouncer<F extends StrictFunction, IsNullable extends boolean = true> = {\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 StrictFunction>(\n  func: F,\n  options: DebounceOptions & { readonly timing?: 'trailing' },\n): Debouncer<F>;\nexport function debounce<F extends StrictFunction>(\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 StrictFunction>(\n  func: F,\n\n  {\n    waitMs,\n    timing = 'trailing',\n    maxWaitMs,\n  }: DebounceOptions & {\n    readonly timing?: 'both' | 'leading' | 'trailing';\n  },\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    // @ts-expect-error [ts2345, ts2322] -- TypeScript infers the generic sub-\n    // types too eagerly, making itself blind to the fact that the types match\n    // here.\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          // @ts-expect-error [ts2345, ts2322] -- TypeScript infers the generic sub-\n          // types too eagerly, making itself blind to the fact that the types match\n          // here.\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":"AA8GA,SAAgB,EACd,EAEA,CACE,SACA,SAAS,WACT,aAIY,CACd,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,GAMjB,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,CAOzB,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/{deduped-CXeQa-0F.d.cts → deduped-DdwAYzXs.d.cts}

@@ -1,5 +1,5 @@
-import { t as IterableContainer } from "./iterable-container-OFsaw8WL.cjs";
-import { t as NonEmptyArray } from "./non-empty-array-CFG7wGD-.cjs";
+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
 
@@ -20,4 +20,4 @@ import { t as NonEmptyArray } from "./non-empty-array-CFG7wGD-.cjs";
 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-CXeQa-0F.d.cts.map
+//# sourceMappingURL=deduped-DdwAYzXs.d.cts.map