@depup/remeda 2.33.6-depup.0 → 2.33.7-depup.0

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/remeda
 
 | Field | Value |
 |-------|-------|
-| Original | [remeda](https://www.npmjs.com/package/remeda) @ 2.33.6 |
-| Processed | 2026-03-17 |
+| Original | [remeda](https://www.npmjs.com/package/remeda) @ 2.33.7 |
+| Processed | 2026-03-31 |
 | Smoke test | passed |
 | Deps updated | 0 |
 

package/changes.json

@@ -1,5 +1,5 @@
 {
   "bumped": {},
-  "timestamp": "2026-03-17T16:38:56.626Z",
+  "timestamp": "2026-03-31T12:26:29.375Z",
   "totalUpdated": 0
 }

package/dist/allPass.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"allPass.cjs","names":["purry"],"sources":["../src/allPass.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\n/**\n * Determines whether all predicates returns true for the input data.\n *\n * @param data - The input data for predicates.\n * @param fns - The list of predicates.\n * @signature\n *    allPass(data, fns)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    allPass(12, fns) // => true\n *    allPass(8, fns) // => false\n * @dataFirst\n * @category Array\n */\nexport function allPass<T>(\n  data: T,\n  fns: readonly ((data: T) => boolean)[],\n): boolean;\n\n/**\n * Determines whether all predicates returns true for the input data.\n *\n * @param fns - The list of predicates.\n * @signature\n *    allPass(fns)(data)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    allPass(fns)(12) // => true\n *    allPass(fns)(8) // => false\n * @dataLast\n * @category Array\n */\nexport function allPass<T>(\n  fns: readonly ((data: T) => boolean)[],\n): (data: T) => boolean;\n\nexport function allPass(...args: readonly unknown[]): unknown {\n  return purry(allPassImplementation, args);\n}\n\nconst allPassImplementation = <T>(\n  data: T,\n  fns: readonly ((data: T) => boolean)[],\n): boolean => fns.every((fn) => fn(data));\n"],"mappings":"kGA0CA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,OAAOA,EAAAA,MAAM,EAAuB,EAAK,CAG3C,MAAM,GACJ,EACA,IACY,EAAI,MAAO,GAAO,EAAG,EAAK,CAAC"}
+{"version":3,"file":"allPass.cjs","names":["purry"],"sources":["../src/allPass.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\n/**\n * Determines whether all predicates return true for the input data.\n *\n * @param data - The input data for predicates.\n * @param fns - The list of predicates.\n * @signature\n *    allPass(data, fns)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    allPass(12, fns) // => true\n *    allPass(8, fns) // => false\n * @dataFirst\n * @category Array\n */\nexport function allPass<T>(\n  data: T,\n  fns: readonly ((data: T) => boolean)[],\n): boolean;\n\n/**\n * Determines whether all predicates return true for the input data.\n *\n * @param fns - The list of predicates.\n * @signature\n *    allPass(fns)(data)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    allPass(fns)(12) // => true\n *    allPass(fns)(8) // => false\n * @dataLast\n * @category Array\n */\nexport function allPass<T>(\n  fns: readonly ((data: T) => boolean)[],\n): (data: T) => boolean;\n\nexport function allPass(...args: readonly unknown[]): unknown {\n  return purry(allPassImplementation, args);\n}\n\nconst allPassImplementation = <T>(\n  data: T,\n  fns: readonly ((data: T) => boolean)[],\n): boolean => fns.every((fn) => fn(data));\n"],"mappings":"kGA0CA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,OAAOA,EAAAA,MAAM,EAAuB,EAAK,CAG3C,MAAM,GACJ,EACA,IACY,EAAI,MAAO,GAAO,EAAG,EAAK,CAAC"}

package/dist/allPass.js.map

@@ -1 +1 @@
-{"version":3,"file":"allPass.js","names":[],"sources":["../src/allPass.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\n/**\n * Determines whether all predicates returns true for the input data.\n *\n * @param data - The input data for predicates.\n * @param fns - The list of predicates.\n * @signature\n *    allPass(data, fns)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    allPass(12, fns) // => true\n *    allPass(8, fns) // => false\n * @dataFirst\n * @category Array\n */\nexport function allPass<T>(\n  data: T,\n  fns: readonly ((data: T) => boolean)[],\n): boolean;\n\n/**\n * Determines whether all predicates returns true for the input data.\n *\n * @param fns - The list of predicates.\n * @signature\n *    allPass(fns)(data)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    allPass(fns)(12) // => true\n *    allPass(fns)(8) // => false\n * @dataLast\n * @category Array\n */\nexport function allPass<T>(\n  fns: readonly ((data: T) => boolean)[],\n): (data: T) => boolean;\n\nexport function allPass(...args: readonly unknown[]): unknown {\n  return purry(allPassImplementation, args);\n}\n\nconst allPassImplementation = <T>(\n  data: T,\n  fns: readonly ((data: T) => boolean)[],\n): boolean => fns.every((fn) => fn(data));\n"],"mappings":"mCA0CA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,OAAO,EAAM,EAAuB,EAAK,CAG3C,MAAM,GACJ,EACA,IACY,EAAI,MAAO,GAAO,EAAG,EAAK,CAAC"}
+{"version":3,"file":"allPass.js","names":[],"sources":["../src/allPass.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\n/**\n * Determines whether all predicates return true for the input data.\n *\n * @param data - The input data for predicates.\n * @param fns - The list of predicates.\n * @signature\n *    allPass(data, fns)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    allPass(12, fns) // => true\n *    allPass(8, fns) // => false\n * @dataFirst\n * @category Array\n */\nexport function allPass<T>(\n  data: T,\n  fns: readonly ((data: T) => boolean)[],\n): boolean;\n\n/**\n * Determines whether all predicates return true for the input data.\n *\n * @param fns - The list of predicates.\n * @signature\n *    allPass(fns)(data)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    allPass(fns)(12) // => true\n *    allPass(fns)(8) // => false\n * @dataLast\n * @category Array\n */\nexport function allPass<T>(\n  fns: readonly ((data: T) => boolean)[],\n): (data: T) => boolean;\n\nexport function allPass(...args: readonly unknown[]): unknown {\n  return purry(allPassImplementation, args);\n}\n\nconst allPassImplementation = <T>(\n  data: T,\n  fns: readonly ((data: T) => boolean)[],\n): boolean => fns.every((fn) => fn(data));\n"],"mappings":"mCA0CA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,OAAO,EAAM,EAAuB,EAAK,CAG3C,MAAM,GACJ,EACA,IACY,EAAI,MAAO,GAAO,EAAG,EAAK,CAAC"}

package/dist/{binarySearchCutoffIndex-CLQRwIY1.js → binarySearchCutoffIndex-CalebGhL.js}

@@ -1,2 +1,2 @@
 function e(e,t){let n=0,r=e.length;for(;n<r;){let i=n+r>>>1,a=e[i];t(a,i,e)?n=i+1:r=i}return r}export{e as t};
-//# sourceMappingURL=binarySearchCutoffIndex-CLQRwIY1.js.map
+//# sourceMappingURL=binarySearchCutoffIndex-CalebGhL.js.map

package/dist/{binarySearchCutoffIndex-CLQRwIY1.js.map → binarySearchCutoffIndex-CalebGhL.js.map}

@@ -1 +1 @@
-{"version":3,"file":"binarySearchCutoffIndex-CLQRwIY1.js","names":[],"sources":["../src/internal/binarySearchCutoffIndex.ts"],"sourcesContent":["/**\n * A binary search implementation that finds the index at which `predicate`\n * stops returning `true` and starts returning `false` (consistently) when run\n * on the items of the array. It **assumes** that mapping the array via the\n * predicate results in the shape `[...true[], ...false[]]`. *For any other case\n * the result is unpredictable*.\n *\n * This is the base implementation of the `sortedIndex` functions which define\n * the predicate for the user, for common use-cases.\n *\n * It is similar to `findIndex`, but runs at O(logN), whereas the latter is\n * general purpose function which runs on any array and predicate, but runs at\n * O(N) time.\n */\nexport function binarySearchCutoffIndex<T>(\n  array: readonly T[],\n  predicate: (value: T, index: number, data: readonly T[]) => boolean,\n): number {\n  let lowIndex = 0;\n  let highIndex = array.length;\n\n  while (lowIndex < highIndex) {\n    // eslint-disable-next-line no-bitwise -- We use bitwise operator here as a way to find the mid-point and round it down using the same operation.\n    const pivotIndex = (lowIndex + highIndex) >>> 1;\n    const pivot = array[pivotIndex]!;\n\n    if (predicate(pivot, pivotIndex, array)) {\n      lowIndex = pivotIndex + 1;\n    } else {\n      highIndex = pivotIndex;\n    }\n  }\n\n  return highIndex;\n}\n"],"mappings":"AAcA,SAAgB,EACd,EACA,EACQ,CACR,IAAI,EAAW,EACX,EAAY,EAAM,OAEtB,KAAO,EAAW,GAAW,CAE3B,IAAM,EAAc,EAAW,IAAe,EACxC,EAAQ,EAAM,GAEhB,EAAU,EAAO,EAAY,EAAM,CACrC,EAAW,EAAa,EAExB,EAAY,EAIhB,OAAO"}
+{"version":3,"file":"binarySearchCutoffIndex-CalebGhL.js","names":[],"sources":["../src/internal/binarySearchCutoffIndex.ts"],"sourcesContent":["/**\n * A binary search implementation that finds the index at which `predicate`\n * stops returning `true` and starts returning `false` (consistently) when run\n * on the items of the array. It **assumes** that mapping the array via the\n * predicate results in the shape `[...true[], ...false[]]`. *For any other case\n * the result is unpredictable*.\n *\n * This is the base implementation of the `sortedIndex` functions which define\n * the predicate for the user, for common use-cases.\n *\n * It is similar to `findIndex`, but runs at O(logN), whereas the latter is\n * general purpose function which runs on any array and predicate, but runs at\n * O(N) time.\n */\nexport function binarySearchCutoffIndex<T>(\n  array: readonly T[],\n  predicate: (value: T, index: number, data: readonly T[]) => boolean,\n): number {\n  let lowIndex = 0;\n  let highIndex = array.length;\n\n  while (lowIndex < highIndex) {\n    // eslint-disable-next-line no-bitwise -- We use bitwise operator here as a way to find the mid-point and round it down using the same operation.\n    const pivotIndex = (lowIndex + highIndex) >>> 1;\n    const pivot = array[pivotIndex]!;\n\n    if (predicate(pivot, pivotIndex, array)) {\n      lowIndex = pivotIndex + 1;\n    } else {\n      highIndex = pivotIndex;\n    }\n  }\n\n  return highIndex;\n}\n"],"mappings":"AAcA,SAAgB,EACd,EACA,EACQ,CACR,IAAI,EAAW,EACX,EAAY,EAAM,OAEtB,KAAO,EAAW,GAAW,CAE3B,IAAM,EAAc,EAAW,IAAe,EACxC,EAAQ,EAAM,GAEhB,EAAU,EAAO,EAAY,EAAM,CACrC,EAAW,EAAa,EAExB,EAAY,EAIhB,OAAO"}

package/dist/{binarySearchCutoffIndex-DdLPjZiy.cjs → binarySearchCutoffIndex-TBknSzI9.cjs}

@@ -1,2 +1,2 @@
 function e(e,t){let n=0,r=e.length;for(;n<r;){let i=n+r>>>1,a=e[i];t(a,i,e)?n=i+1:r=i}return r}Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return e}});
-//# sourceMappingURL=binarySearchCutoffIndex-DdLPjZiy.cjs.map
+//# sourceMappingURL=binarySearchCutoffIndex-TBknSzI9.cjs.map

package/dist/{binarySearchCutoffIndex-DdLPjZiy.cjs.map → binarySearchCutoffIndex-TBknSzI9.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"binarySearchCutoffIndex-DdLPjZiy.cjs","names":[],"sources":["../src/internal/binarySearchCutoffIndex.ts"],"sourcesContent":["/**\n * A binary search implementation that finds the index at which `predicate`\n * stops returning `true` and starts returning `false` (consistently) when run\n * on the items of the array. It **assumes** that mapping the array via the\n * predicate results in the shape `[...true[], ...false[]]`. *For any other case\n * the result is unpredictable*.\n *\n * This is the base implementation of the `sortedIndex` functions which define\n * the predicate for the user, for common use-cases.\n *\n * It is similar to `findIndex`, but runs at O(logN), whereas the latter is\n * general purpose function which runs on any array and predicate, but runs at\n * O(N) time.\n */\nexport function binarySearchCutoffIndex<T>(\n  array: readonly T[],\n  predicate: (value: T, index: number, data: readonly T[]) => boolean,\n): number {\n  let lowIndex = 0;\n  let highIndex = array.length;\n\n  while (lowIndex < highIndex) {\n    // eslint-disable-next-line no-bitwise -- We use bitwise operator here as a way to find the mid-point and round it down using the same operation.\n    const pivotIndex = (lowIndex + highIndex) >>> 1;\n    const pivot = array[pivotIndex]!;\n\n    if (predicate(pivot, pivotIndex, array)) {\n      lowIndex = pivotIndex + 1;\n    } else {\n      highIndex = pivotIndex;\n    }\n  }\n\n  return highIndex;\n}\n"],"mappings":"AAcA,SAAgB,EACd,EACA,EACQ,CACR,IAAI,EAAW,EACX,EAAY,EAAM,OAEtB,KAAO,EAAW,GAAW,CAE3B,IAAM,EAAc,EAAW,IAAe,EACxC,EAAQ,EAAM,GAEhB,EAAU,EAAO,EAAY,EAAM,CACrC,EAAW,EAAa,EAExB,EAAY,EAIhB,OAAO"}
+{"version":3,"file":"binarySearchCutoffIndex-TBknSzI9.cjs","names":[],"sources":["../src/internal/binarySearchCutoffIndex.ts"],"sourcesContent":["/**\n * A binary search implementation that finds the index at which `predicate`\n * stops returning `true` and starts returning `false` (consistently) when run\n * on the items of the array. It **assumes** that mapping the array via the\n * predicate results in the shape `[...true[], ...false[]]`. *For any other case\n * the result is unpredictable*.\n *\n * This is the base implementation of the `sortedIndex` functions which define\n * the predicate for the user, for common use-cases.\n *\n * It is similar to `findIndex`, but runs at O(logN), whereas the latter is\n * general purpose function which runs on any array and predicate, but runs at\n * O(N) time.\n */\nexport function binarySearchCutoffIndex<T>(\n  array: readonly T[],\n  predicate: (value: T, index: number, data: readonly T[]) => boolean,\n): number {\n  let lowIndex = 0;\n  let highIndex = array.length;\n\n  while (lowIndex < highIndex) {\n    // eslint-disable-next-line no-bitwise -- We use bitwise operator here as a way to find the mid-point and round it down using the same operation.\n    const pivotIndex = (lowIndex + highIndex) >>> 1;\n    const pivot = array[pivotIndex]!;\n\n    if (predicate(pivot, pivotIndex, array)) {\n      lowIndex = pivotIndex + 1;\n    } else {\n      highIndex = pivotIndex;\n    }\n  }\n\n  return highIndex;\n}\n"],"mappings":"AAcA,SAAgB,EACd,EACA,EACQ,CACR,IAAI,EAAW,EACX,EAAY,EAAM,OAEtB,KAAO,EAAW,GAAW,CAE3B,IAAM,EAAc,EAAW,IAAe,EACxC,EAAQ,EAAM,GAEhB,EAAU,EAAO,EAAY,EAAM,CACrC,EAAW,EAAa,EAExB,EAAY,EAIhB,OAAO"}

package/dist/ceil.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`),t=require(`./withPrecision-DED4FjDo.cjs`);function n(...n){return e.purry(t.t(Math.ceil),n)}exports.ceil=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`),t=require(`./withPrecision-L0Ri7wjG.cjs`);function n(...n){return e.purry(t.t(Math.ceil),n)}exports.ceil=n;
 //# sourceMappingURL=ceil.cjs.map

package/dist/ceil.js

@@ -1,2 +1,2 @@
-import{purry as e}from"./purry.js";import{t}from"./withPrecision-CDZ-Oor7.js";function n(...n){return e(t(Math.ceil),n)}export{n as ceil};
+import{purry as e}from"./purry.js";import{t}from"./withPrecision-7nvi8hnb.js";function n(...n){return e(t(Math.ceil),n)}export{n as ceil};
 //# sourceMappingURL=ceil.js.map

package/dist/conditional-3wcaMG9k.cjs

@@ -0,0 +1,2 @@
+function e(e,t,n){return e(n[0])?e=>t(e,...n):t(...n)}function t(...t){return e(r,n,t)}function n(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 r(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}Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=conditional-3wcaMG9k.cjs.map

package/dist/conditional-3wcaMG9k.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditional-3wcaMG9k.cjs","names":[],"sources":["../src/internal/purryOn.ts","../src/conditional.ts"],"sourcesContent":["/**\n * Utility for purrying functions based on a predicate for the first argument.\n *\n * This is useful for purrying functions with a variadic argument list.\n */\nexport function purryOn<T>(\n  isArg: (firstArg: unknown) => firstArg is T,\n  implementation: (\n    data: unknown,\n    firstArg: T,\n    // eslint-disable-next-line @typescript-eslint/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: readonly 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, jsdoc/require-param --\n * We don't document each `case` param, instead we document the concept more\n * generally, but these eslint rules can't detect that.\n */\n\nimport { purryOn } from \"./internal/purryOn\";\nimport type { GuardType } from \"./internal/types/GuardType\";\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/**\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, the Remeda\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 *   conditional(...cases)(data);\n * @example\n *   const nameOrId = 3 as string | number | boolean;\n *\n *   pipe(\n *     nameOrId,\n *     conditional(\n *       [isString, (name) => `Hello ${name}`],\n *       [isNumber, (id) => `Hello ID: ${id}`],\n *     ),\n *   ); //=> 'Hello ID: 3' (typed as `string`), can throw!.\n *\n *   pipe(\n *     nameOrId,\n *     conditional(\n *       [isString, (name) => `Hello ${name}`],\n *       [isNumber, (id) => `Hello ID: ${id}`],\n *       constant(undefined),\n *     ),\n *   ); //=> 'Hello ID: 3' (typed as `string | undefined`), won't throw.\n *\n *   pipe(\n *     nameOrId,\n *     conditional(\n *       [isString, (name) => `Hello ${name}`],\n *       [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 */\nexport function 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. @see https://github.com/remeda/remeda/issues/847#issuecomment-3057371891\n  case0: Case<T, Return0, Fn0>,\n  fallback?: DefaultCase<T, Fallback>,\n): (data: T) => Return0 | Fallback;\n\nexport function 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\nexport function 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\nexport function 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\nexport function 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\nexport function 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\nexport function 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\nexport function 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\nexport function 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\nexport function 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, the Remeda\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 *   conditional(data, ...cases);\n * @example\n *   const nameOrId = 3 as string | number | boolean;\n *\n *   conditional(\n *     nameOrId,\n *     [isString, (name) => `Hello ${name}`],\n *     [isNumber, (id) => `Hello ID: ${id}`],\n *   ); //=> 'Hello ID: 3' (typed as `string`), can throw!.\n *\n *   conditional(\n *     nameOrId,\n *     [isString, (name) => `Hello ${name}`],\n *     [isNumber, (id) => `Hello ID: ${id}`],\n *     constant(undefined),\n *   ); //=> 'Hello ID: 3' (typed as `string | undefined`), won't throw.\n *\n *   conditional(\n *     nameOrId,\n *     [isString, (name) => `Hello ${name}`],\n *     [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 */\nexport function 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\nexport function 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\nexport function 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\nexport function 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\nexport function 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\nexport function 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\nexport function 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\nexport function 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\nexport function 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\nexport function 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\nexport function conditional(...args: readonly unknown[]): unknown {\n  return purryOn(isCase, conditionalImplementation, args);\n}\n\nfunction conditionalImplementation<In, Out>(\n  data: In,\n  ...cases: readonly (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 readonly 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"],"mappings":"AAKA,SAAgB,EACd,EACA,EAMA,EACS,CACT,OAAO,EAAM,EAAK,GAAG,CAEhB,GAAkB,EAAe,EAAM,GAAG,EAAK,CAEhD,EAAe,GAAG,EAAK,CCgsB7B,SAAgB,EAAY,GAAG,EAAmC,CAChE,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,YAChB,EAAK,QAAU,GACf,OAAO,GAAS,YAChB,EAAK,QAAU,GACf,EAAK,SAAW"}

package/dist/conditional-CTEJD5TX.js

@@ -0,0 +1,2 @@
+function e(e,t,n){return e(n[0])?e=>t(e,...n):t(...n)}function t(...t){return e(r,n,t)}function n(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 r(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}export{t};
+//# sourceMappingURL=conditional-CTEJD5TX.js.map

package/dist/conditional-CTEJD5TX.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditional-CTEJD5TX.js","names":[],"sources":["../src/internal/purryOn.ts","../src/conditional.ts"],"sourcesContent":["/**\n * Utility for purrying functions based on a predicate for the first argument.\n *\n * This is useful for purrying functions with a variadic argument list.\n */\nexport function purryOn<T>(\n  isArg: (firstArg: unknown) => firstArg is T,\n  implementation: (\n    data: unknown,\n    firstArg: T,\n    // eslint-disable-next-line @typescript-eslint/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: readonly 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, jsdoc/require-param --\n * We don't document each `case` param, instead we document the concept more\n * generally, but these eslint rules can't detect that.\n */\n\nimport { purryOn } from \"./internal/purryOn\";\nimport type { GuardType } from \"./internal/types/GuardType\";\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/**\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, the Remeda\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 *   conditional(...cases)(data);\n * @example\n *   const nameOrId = 3 as string | number | boolean;\n *\n *   pipe(\n *     nameOrId,\n *     conditional(\n *       [isString, (name) => `Hello ${name}`],\n *       [isNumber, (id) => `Hello ID: ${id}`],\n *     ),\n *   ); //=> 'Hello ID: 3' (typed as `string`), can throw!.\n *\n *   pipe(\n *     nameOrId,\n *     conditional(\n *       [isString, (name) => `Hello ${name}`],\n *       [isNumber, (id) => `Hello ID: ${id}`],\n *       constant(undefined),\n *     ),\n *   ); //=> 'Hello ID: 3' (typed as `string | undefined`), won't throw.\n *\n *   pipe(\n *     nameOrId,\n *     conditional(\n *       [isString, (name) => `Hello ${name}`],\n *       [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 */\nexport function 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. @see https://github.com/remeda/remeda/issues/847#issuecomment-3057371891\n  case0: Case<T, Return0, Fn0>,\n  fallback?: DefaultCase<T, Fallback>,\n): (data: T) => Return0 | Fallback;\n\nexport function 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\nexport function 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\nexport function 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\nexport function 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\nexport function 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\nexport function 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\nexport function 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\nexport function 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\nexport function 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, the Remeda\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 *   conditional(data, ...cases);\n * @example\n *   const nameOrId = 3 as string | number | boolean;\n *\n *   conditional(\n *     nameOrId,\n *     [isString, (name) => `Hello ${name}`],\n *     [isNumber, (id) => `Hello ID: ${id}`],\n *   ); //=> 'Hello ID: 3' (typed as `string`), can throw!.\n *\n *   conditional(\n *     nameOrId,\n *     [isString, (name) => `Hello ${name}`],\n *     [isNumber, (id) => `Hello ID: ${id}`],\n *     constant(undefined),\n *   ); //=> 'Hello ID: 3' (typed as `string | undefined`), won't throw.\n *\n *   conditional(\n *     nameOrId,\n *     [isString, (name) => `Hello ${name}`],\n *     [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 */\nexport function 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\nexport function 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\nexport function 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\nexport function 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\nexport function 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\nexport function 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\nexport function 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\nexport function 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\nexport function 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\nexport function 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\nexport function conditional(...args: readonly unknown[]): unknown {\n  return purryOn(isCase, conditionalImplementation, args);\n}\n\nfunction conditionalImplementation<In, Out>(\n  data: In,\n  ...cases: readonly (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 readonly 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"],"mappings":"AAKA,SAAgB,EACd,EACA,EAMA,EACS,CACT,OAAO,EAAM,EAAK,GAAG,CAEhB,GAAkB,EAAe,EAAM,GAAG,EAAK,CAEhD,EAAe,GAAG,EAAK,CCgsB7B,SAAgB,EAAY,GAAG,EAAmC,CAChE,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,YAChB,EAAK,QAAU,GACf,OAAO,GAAS,YAChB,EAAK,QAAU,GACf,EAAK,SAAW"}

package/dist/conditional.cjs

@@ -1,2 +1 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purryOn-DdnETb-0.cjs`);function t(...t){return e.t(r,n,t)}function n(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 r(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}exports.conditional=t;
-//# sourceMappingURL=conditional.cjs.map
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./conditional-3wcaMG9k.cjs`);exports.conditional=e.t;

package/dist/conditional.js

@@ -1,2 +1 @@
-import{t as e}from"./purryOn-D4wFIFMT.js";function t(...t){return e(r,n,t)}function n(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 r(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}export{t as conditional};
-//# sourceMappingURL=conditional.js.map
+import{t as e}from"./conditional-CTEJD5TX.js";export{e as conditional};

package/dist/difference.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./utilityEvaluators-CW0M8vMV.cjs`),t=require(`./purryFromLazy-CwB5T8yd.cjs`);function n(...e){return t.t(r,e)}function r(t){if(t.length===0)return e.r;let n=new Map;for(let e of t)n.set(e,(n.get(e)??0)+1);return t=>{let r=n.get(t);return r===void 0||r===0?{done:!1,hasNext:!0,next:t}:(n.set(t,r-1),e.t)}}exports.difference=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./utilityEvaluators-1duvUKJ-.cjs`),t=require(`./purryFromLazy-oahp5Ef4.cjs`);function n(...e){return t.t(r,e)}function r(t){if(t.length===0)return e.r;let n=new Map;for(let e of t)n.set(e,(n.get(e)??0)+1);return t=>{let r=n.get(t);return r===void 0||r===0?{done:!1,hasNext:!0,next:t}:(n.set(t,r-1),e.t)}}exports.difference=n;
 //# sourceMappingURL=difference.cjs.map

package/dist/difference.js

@@ -1,2 +1,2 @@
-import{r as e,t}from"./utilityEvaluators-BQqW5Ir5.js";import{t as n}from"./purryFromLazy-B-_oTxzb.js";function r(...e){return n(i,e)}function i(n){if(n.length===0)return e;let r=new Map;for(let e of n)r.set(e,(r.get(e)??0)+1);return e=>{let n=r.get(e);return n===void 0||n===0?{done:!1,hasNext:!0,next:e}:(r.set(e,n-1),t)}}export{r as difference};
+import{r as e,t}from"./utilityEvaluators-Cb8x6-JZ.js";import{t as n}from"./purryFromLazy-DELFL6Wm.js";function r(...e){return n(i,e)}function i(n){if(n.length===0)return e;let r=new Map;for(let e of n)r.set(e,(r.get(e)??0)+1);return e=>{let n=r.get(e);return n===void 0||n===0?{done:!1,hasNext:!0,next:e}:(r.set(e,n-1),t)}}export{r as difference};
 //# sourceMappingURL=difference.js.map

package/dist/differenceWith.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./utilityEvaluators-CW0M8vMV.cjs`),t=require(`./purryFromLazy-CwB5T8yd.cjs`);function n(...e){return t.t(r,e)}const r=(t,n)=>r=>t.every(e=>!n(r,e))?{done:!1,hasNext:!0,next:r}:e.t;exports.differenceWith=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./utilityEvaluators-1duvUKJ-.cjs`),t=require(`./purryFromLazy-oahp5Ef4.cjs`);function n(...e){return t.t(r,e)}const r=(t,n)=>r=>t.every(e=>!n(r,e))?{done:!1,hasNext:!0,next:r}:e.t;exports.differenceWith=n;
 //# sourceMappingURL=differenceWith.cjs.map

package/dist/differenceWith.js

@@ -1,2 +1,2 @@
-import{t as e}from"./utilityEvaluators-BQqW5Ir5.js";import{t}from"./purryFromLazy-B-_oTxzb.js";function n(...e){return t(r,e)}const r=(t,n)=>r=>t.every(e=>!n(r,e))?{done:!1,hasNext:!0,next:r}:e;export{n as differenceWith};
+import{t as e}from"./utilityEvaluators-Cb8x6-JZ.js";import{t}from"./purryFromLazy-DELFL6Wm.js";function n(...e){return t(r,e)}const r=(t,n)=>r=>t.every(e=>!n(r,e))?{done:!1,hasNext:!0,next:r}:e;export{n as differenceWith};
 //# sourceMappingURL=differenceWith.js.map

package/dist/drop.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`),t=require(`./utilityEvaluators-CW0M8vMV.cjs`);function n(...t){return e.purry(r,t,i)}const r=(e,t)=>t<0?[...e]:e.slice(t);function i(e){if(e<=0)return t.r;let n=e;return e=>n>0?(--n,t.t):{done:!1,hasNext:!0,next:e}}exports.drop=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`),t=require(`./utilityEvaluators-1duvUKJ-.cjs`);function n(...t){return e.purry(r,t,i)}const r=(e,t)=>t<0?[...e]:e.slice(t);function i(e){if(e<=0)return t.r;let n=e;return e=>n>0?(--n,t.t):{done:!1,hasNext:!0,next:e}}exports.drop=n;
 //# sourceMappingURL=drop.cjs.map

package/dist/drop.js

@@ -1,2 +1,2 @@
-import{purry as e}from"./purry.js";import{r as t,t as n}from"./utilityEvaluators-BQqW5Ir5.js";function r(...t){return e(i,t,a)}const i=(e,t)=>t<0?[...e]:e.slice(t);function a(e){if(e<=0)return t;let r=e;return e=>r>0?(--r,n):{done:!1,hasNext:!0,next:e}}export{r as drop};
+import{purry as e}from"./purry.js";import{r as t,t as n}from"./utilityEvaluators-Cb8x6-JZ.js";function r(...t){return e(i,t,a)}const i=(e,t)=>t<0?[...e]:e.slice(t);function a(e){if(e<=0)return t;let r=e;return e=>r>0?(--r,n):{done:!1,hasNext:!0,next:e}}export{r as drop};
 //# sourceMappingURL=drop.js.map

package/dist/dropFirstBy.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./heap-14xVkDB1.cjs`),t=require(`./purryOrderRules-B8pzD03D.cjs`);function n(...e){return t.n(r,e)}function r(t,n,r){if(r>=t.length)return[];if(r<=0)return[...t];let i=t.slice(0,r);e.n(i,n);let a=[],o=t.slice(r);for(let t of o){let r=e.t(i,n,t);a.push(r??t)}return a}exports.dropFirstBy=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./heap-Ct9W7Bbi.cjs`),t=require(`./purryOrderRules-cW1I4C_j.cjs`);function n(...e){return t.n(r,e)}function r(t,n,r){if(r>=t.length)return[];if(r<=0)return[...t];let i=t.slice(0,r);e.n(i,n);let a=[],o=t.slice(r);for(let t of o){let r=e.t(i,n,t);a.push(r??t)}return a}exports.dropFirstBy=n;
 //# sourceMappingURL=dropFirstBy.cjs.map

package/dist/dropFirstBy.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"dropFirstBy.cjs","names":["purryOrderRulesWithArgument","heapMaybeInsert"],"sources":["../src/dropFirstBy.ts"],"sourcesContent":["import { heapify, heapMaybeInsert } from \"./internal/heap\";\nimport {\n  purryOrderRulesWithArgument,\n  type OrderRule,\n} from \"./internal/purryOrderRules\";\nimport type { CompareFunction } from \"./internal/types/CompareFunction\";\nimport type { NonEmptyArray } from \"./internal/types/NonEmptyArray\";\n\n/**\n * Drop the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before dropping the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.\n *\n * For the opposite operation (to keep `n` elements) see `takeFirstBy`.\n *\n * @param data - The input array.\n * @param n - The number of items to drop. If `n` is non-positive no items would be dropped and a *clone* of the input would be returned, if `n` is bigger then data.length no items would be returned.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A subset of the input array.\n * @signature\n *   dropFirstBy(data, n, ...rules);\n * @example\n *   dropFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['aaa', 'aaaa']\n * @dataFirst\n * @category Array\n */\nexport function dropFirstBy<T>(\n  data: readonly T[],\n  n: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): T[];\n\n/**\n * Drop the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before dropping the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.\n *\n * For the opposite operation (to keep `n` elements) see `takeFirstBy`.\n *\n * @param n - The number of items to drop. If `n` is non-positive no items would be dropped and a *clone* of the input would be returned, if `n` is bigger then data.length no items would be returned.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A subset of the input array.\n * @signature\n *   dropFirstBy(n, ...rules)(data);\n * @example\n *   pipe(['aa', 'aaaa', 'a', 'aaa'], dropFirstBy(2, x => x.length)); // => ['aaa', 'aaaa']\n * @dataLast\n * @category Array\n */\nexport function dropFirstBy<T>(\n  n: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): (data: readonly T[]) => T[];\n\nexport function dropFirstBy(...args: readonly unknown[]): unknown {\n  return purryOrderRulesWithArgument(dropFirstByImplementation, args);\n}\n\nfunction dropFirstByImplementation<T>(\n  data: readonly T[],\n  compareFn: CompareFunction<T>,\n  n: number,\n): T[] {\n  if (n >= data.length) {\n    return [];\n  }\n\n  if (n <= 0) {\n    return [...data];\n  }\n\n  const heap = data.slice(0, n);\n  heapify(heap, compareFn);\n\n  const out = [];\n\n  const rest = data.slice(n);\n  for (const item of rest) {\n    const previousHead = heapMaybeInsert(heap, compareFn, item);\n    out.push(previousHead ?? item);\n  }\n\n  return out;\n}\n"],"mappings":"sJAkDA,SAAgB,EAAY,GAAG,EAAmC,CAChE,OAAOA,EAAAA,EAA4B,EAA2B,EAAK,CAGrE,SAAS,EACP,EACA,EACA,EACK,CACL,GAAI,GAAK,EAAK,OACZ,MAAO,EAAE,CAGX,GAAI,GAAK,EACP,MAAO,CAAC,GAAG,EAAK,CAGlB,IAAM,EAAO,EAAK,MAAM,EAAG,EAAE,CAC7B,EAAA,EAAQ,EAAM,EAAU,CAExB,IAAM,EAAM,EAAE,CAER,EAAO,EAAK,MAAM,EAAE,CAC1B,IAAK,IAAM,KAAQ,EAAM,CACvB,IAAM,EAAeC,EAAAA,EAAgB,EAAM,EAAW,EAAK,CAC3D,EAAI,KAAK,GAAgB,EAAK,CAGhC,OAAO"}
+{"version":3,"file":"dropFirstBy.cjs","names":["purryOrderRulesWithArgument","heapMaybeInsert"],"sources":["../src/dropFirstBy.ts"],"sourcesContent":["import { heapify, heapMaybeInsert } from \"./internal/heap\";\nimport {\n  purryOrderRulesWithArgument,\n  type OrderRule,\n} from \"./internal/purryOrderRules\";\nimport type { CompareFunction } from \"./internal/types/CompareFunction\";\nimport type { NonEmptyArray } from \"./internal/types/NonEmptyArray\";\n\n/**\n * Drop the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before dropping the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.\n *\n * For the opposite operation (to keep `n` elements) see `takeFirstBy`.\n *\n * @param data - The input array.\n * @param n - The number of items to drop. If `n` is non-positive no items would be dropped and a *clone* of the input would be returned, if `n` is bigger then data.length no items would be returned.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A subset of the input array.\n * @signature\n *   dropFirstBy(data, n, ...rules);\n * @example\n *   dropFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['aaaa', 'aaa']\n * @dataFirst\n * @category Array\n */\nexport function dropFirstBy<T>(\n  data: readonly T[],\n  n: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): T[];\n\n/**\n * Drop the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before dropping the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.\n *\n * For the opposite operation (to keep `n` elements) see `takeFirstBy`.\n *\n * @param n - The number of items to drop. If `n` is non-positive no items would be dropped and a *clone* of the input would be returned, if `n` is bigger then data.length no items would be returned.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A subset of the input array.\n * @signature\n *   dropFirstBy(n, ...rules)(data);\n * @example\n *   pipe(['aa', 'aaaa', 'a', 'aaa'], dropFirstBy(2, x => x.length)); // => ['aaaa', 'aaa']\n * @dataLast\n * @category Array\n */\nexport function dropFirstBy<T>(\n  n: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): (data: readonly T[]) => T[];\n\nexport function dropFirstBy(...args: readonly unknown[]): unknown {\n  return purryOrderRulesWithArgument(dropFirstByImplementation, args);\n}\n\nfunction dropFirstByImplementation<T>(\n  data: readonly T[],\n  compareFn: CompareFunction<T>,\n  n: number,\n): T[] {\n  if (n >= data.length) {\n    return [];\n  }\n\n  if (n <= 0) {\n    return [...data];\n  }\n\n  const heap = data.slice(0, n);\n  heapify(heap, compareFn);\n\n  const out = [];\n\n  const rest = data.slice(n);\n  for (const item of rest) {\n    const previousHead = heapMaybeInsert(heap, compareFn, item);\n    out.push(previousHead ?? item);\n  }\n\n  return out;\n}\n"],"mappings":"sJAkDA,SAAgB,EAAY,GAAG,EAAmC,CAChE,OAAOA,EAAAA,EAA4B,EAA2B,EAAK,CAGrE,SAAS,EACP,EACA,EACA,EACK,CACL,GAAI,GAAK,EAAK,OACZ,MAAO,EAAE,CAGX,GAAI,GAAK,EACP,MAAO,CAAC,GAAG,EAAK,CAGlB,IAAM,EAAO,EAAK,MAAM,EAAG,EAAE,CAC7B,EAAA,EAAQ,EAAM,EAAU,CAExB,IAAM,EAAM,EAAE,CAER,EAAO,EAAK,MAAM,EAAE,CAC1B,IAAK,IAAM,KAAQ,EAAM,CACvB,IAAM,EAAeC,EAAAA,EAAgB,EAAM,EAAW,EAAK,CAC3D,EAAI,KAAK,GAAgB,EAAK,CAGhC,OAAO"}

package/dist/dropFirstBy.js

@@ -1,2 +1,2 @@
-import{n as e,t}from"./heap-OOe_F8_z.js";import{n}from"./purryOrderRules-4JgY6z4X.js";function r(...e){return n(i,e)}function i(n,r,i){if(i>=n.length)return[];if(i<=0)return[...n];let a=n.slice(0,i);e(a,r);let o=[],s=n.slice(i);for(let e of s){let n=t(a,r,e);o.push(n??e)}return o}export{r as dropFirstBy};
+import{n as e,t}from"./heap-C8XIujMa.js";import{n}from"./purryOrderRules-BaB5mcHH.js";function r(...e){return n(i,e)}function i(n,r,i){if(i>=n.length)return[];if(i<=0)return[...n];let a=n.slice(0,i);e(a,r);let o=[],s=n.slice(i);for(let e of s){let n=t(a,r,e);o.push(n??e)}return o}export{r as dropFirstBy};
 //# sourceMappingURL=dropFirstBy.js.map

package/dist/dropFirstBy.js.map

@@ -1 +1 @@
-{"version":3,"file":"dropFirstBy.js","names":[],"sources":["../src/dropFirstBy.ts"],"sourcesContent":["import { heapify, heapMaybeInsert } from \"./internal/heap\";\nimport {\n  purryOrderRulesWithArgument,\n  type OrderRule,\n} from \"./internal/purryOrderRules\";\nimport type { CompareFunction } from \"./internal/types/CompareFunction\";\nimport type { NonEmptyArray } from \"./internal/types/NonEmptyArray\";\n\n/**\n * Drop the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before dropping the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.\n *\n * For the opposite operation (to keep `n` elements) see `takeFirstBy`.\n *\n * @param data - The input array.\n * @param n - The number of items to drop. If `n` is non-positive no items would be dropped and a *clone* of the input would be returned, if `n` is bigger then data.length no items would be returned.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A subset of the input array.\n * @signature\n *   dropFirstBy(data, n, ...rules);\n * @example\n *   dropFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['aaa', 'aaaa']\n * @dataFirst\n * @category Array\n */\nexport function dropFirstBy<T>(\n  data: readonly T[],\n  n: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): T[];\n\n/**\n * Drop the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before dropping the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.\n *\n * For the opposite operation (to keep `n` elements) see `takeFirstBy`.\n *\n * @param n - The number of items to drop. If `n` is non-positive no items would be dropped and a *clone* of the input would be returned, if `n` is bigger then data.length no items would be returned.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A subset of the input array.\n * @signature\n *   dropFirstBy(n, ...rules)(data);\n * @example\n *   pipe(['aa', 'aaaa', 'a', 'aaa'], dropFirstBy(2, x => x.length)); // => ['aaa', 'aaaa']\n * @dataLast\n * @category Array\n */\nexport function dropFirstBy<T>(\n  n: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): (data: readonly T[]) => T[];\n\nexport function dropFirstBy(...args: readonly unknown[]): unknown {\n  return purryOrderRulesWithArgument(dropFirstByImplementation, args);\n}\n\nfunction dropFirstByImplementation<T>(\n  data: readonly T[],\n  compareFn: CompareFunction<T>,\n  n: number,\n): T[] {\n  if (n >= data.length) {\n    return [];\n  }\n\n  if (n <= 0) {\n    return [...data];\n  }\n\n  const heap = data.slice(0, n);\n  heapify(heap, compareFn);\n\n  const out = [];\n\n  const rest = data.slice(n);\n  for (const item of rest) {\n    const previousHead = heapMaybeInsert(heap, compareFn, item);\n    out.push(previousHead ?? item);\n  }\n\n  return out;\n}\n"],"mappings":"sFAkDA,SAAgB,EAAY,GAAG,EAAmC,CAChE,OAAO,EAA4B,EAA2B,EAAK,CAGrE,SAAS,EACP,EACA,EACA,EACK,CACL,GAAI,GAAK,EAAK,OACZ,MAAO,EAAE,CAGX,GAAI,GAAK,EACP,MAAO,CAAC,GAAG,EAAK,CAGlB,IAAM,EAAO,EAAK,MAAM,EAAG,EAAE,CAC7B,EAAQ,EAAM,EAAU,CAExB,IAAM,EAAM,EAAE,CAER,EAAO,EAAK,MAAM,EAAE,CAC1B,IAAK,IAAM,KAAQ,EAAM,CACvB,IAAM,EAAe,EAAgB,EAAM,EAAW,EAAK,CAC3D,EAAI,KAAK,GAAgB,EAAK,CAGhC,OAAO"}
+{"version":3,"file":"dropFirstBy.js","names":[],"sources":["../src/dropFirstBy.ts"],"sourcesContent":["import { heapify, heapMaybeInsert } from \"./internal/heap\";\nimport {\n  purryOrderRulesWithArgument,\n  type OrderRule,\n} from \"./internal/purryOrderRules\";\nimport type { CompareFunction } from \"./internal/types/CompareFunction\";\nimport type { NonEmptyArray } from \"./internal/types/NonEmptyArray\";\n\n/**\n * Drop the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before dropping the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.\n *\n * For the opposite operation (to keep `n` elements) see `takeFirstBy`.\n *\n * @param data - The input array.\n * @param n - The number of items to drop. If `n` is non-positive no items would be dropped and a *clone* of the input would be returned, if `n` is bigger then data.length no items would be returned.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A subset of the input array.\n * @signature\n *   dropFirstBy(data, n, ...rules);\n * @example\n *   dropFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['aaaa', 'aaa']\n * @dataFirst\n * @category Array\n */\nexport function dropFirstBy<T>(\n  data: readonly T[],\n  n: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): T[];\n\n/**\n * Drop the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before dropping the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.\n *\n * For the opposite operation (to keep `n` elements) see `takeFirstBy`.\n *\n * @param n - The number of items to drop. If `n` is non-positive no items would be dropped and a *clone* of the input would be returned, if `n` is bigger then data.length no items would be returned.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A subset of the input array.\n * @signature\n *   dropFirstBy(n, ...rules)(data);\n * @example\n *   pipe(['aa', 'aaaa', 'a', 'aaa'], dropFirstBy(2, x => x.length)); // => ['aaaa', 'aaa']\n * @dataLast\n * @category Array\n */\nexport function dropFirstBy<T>(\n  n: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): (data: readonly T[]) => T[];\n\nexport function dropFirstBy(...args: readonly unknown[]): unknown {\n  return purryOrderRulesWithArgument(dropFirstByImplementation, args);\n}\n\nfunction dropFirstByImplementation<T>(\n  data: readonly T[],\n  compareFn: CompareFunction<T>,\n  n: number,\n): T[] {\n  if (n >= data.length) {\n    return [];\n  }\n\n  if (n <= 0) {\n    return [...data];\n  }\n\n  const heap = data.slice(0, n);\n  heapify(heap, compareFn);\n\n  const out = [];\n\n  const rest = data.slice(n);\n  for (const item of rest) {\n    const previousHead = heapMaybeInsert(heap, compareFn, item);\n    out.push(previousHead ?? item);\n  }\n\n  return out;\n}\n"],"mappings":"sFAkDA,SAAgB,EAAY,GAAG,EAAmC,CAChE,OAAO,EAA4B,EAA2B,EAAK,CAGrE,SAAS,EACP,EACA,EACA,EACK,CACL,GAAI,GAAK,EAAK,OACZ,MAAO,EAAE,CAGX,GAAI,GAAK,EACP,MAAO,CAAC,GAAG,EAAK,CAGlB,IAAM,EAAO,EAAK,MAAM,EAAG,EAAE,CAC7B,EAAQ,EAAM,EAAU,CAExB,IAAM,EAAM,EAAE,CAER,EAAO,EAAK,MAAM,EAAE,CAC1B,IAAK,IAAM,KAAQ,EAAM,CACvB,IAAM,EAAe,EAAgB,EAAM,EAAW,EAAK,CAC3D,EAAI,KAAK,GAAgB,EAAK,CAGhC,OAAO"}

package/dist/filter.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`),t=require(`./utilityEvaluators-CW0M8vMV.cjs`);function n(...t){return e.purry(r,t,i)}const r=(e,t)=>e.filter(t),i=e=>(n,r,i)=>e(n,r,i)?{done:!1,hasNext:!0,next:n}:t.t;exports.filter=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`),t=require(`./utilityEvaluators-1duvUKJ-.cjs`);function n(...t){return e.purry(r,t,i)}const r=(e,t)=>e.filter(t),i=e=>(n,r,i)=>e(n,r,i)?{done:!1,hasNext:!0,next:n}:t.t;exports.filter=n;
 //# sourceMappingURL=filter.cjs.map

package/dist/filter.js

@@ -1,2 +1,2 @@
-import{purry as e}from"./purry.js";import{t}from"./utilityEvaluators-BQqW5Ir5.js";function n(...t){return e(r,t,i)}const r=(e,t)=>e.filter(t),i=e=>(n,r,i)=>e(n,r,i)?{done:!1,hasNext:!0,next:n}:t;export{n as filter};
+import{purry as e}from"./purry.js";import{t}from"./utilityEvaluators-Cb8x6-JZ.js";function n(...t){return e(r,t,i)}const r=(e,t)=>e.filter(t),i=e=>(n,r,i)=>e(n,r,i)?{done:!1,hasNext:!0,next:n}:t;export{n as filter};
 //# sourceMappingURL=filter.js.map

package/dist/find.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`),t=require(`./utilityEvaluators-CW0M8vMV.cjs`),n=require(`./toSingle-z9yHVHGr.cjs`);function r(...t){return e.purry(i,t,n.t(a))}const i=(e,t)=>e.find(t),a=e=>(n,r,i)=>e(n,r,i)?{done:!0,hasNext:!0,next:n}:t.t;exports.find=r;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`),t=require(`./utilityEvaluators-1duvUKJ-.cjs`),n=require(`./toSingle-DMyKrrN-.cjs`);function r(...t){return e.purry(i,t,n.t(a))}const i=(e,t)=>e.find(t),a=e=>(n,r,i)=>e(n,r,i)?{done:!0,hasNext:!0,next:n}:t.t;exports.find=r;
 //# sourceMappingURL=find.cjs.map

package/dist/find.js

@@ -1,2 +1,2 @@
-import{purry as e}from"./purry.js";import{t}from"./utilityEvaluators-BQqW5Ir5.js";import{t as n}from"./toSingle-qs9PC5sP.js";function r(...t){return e(i,t,n(a))}const i=(e,t)=>e.find(t),a=e=>(n,r,i)=>e(n,r,i)?{done:!0,hasNext:!0,next:n}:t;export{r as find};
+import{purry as e}from"./purry.js";import{t}from"./utilityEvaluators-Cb8x6-JZ.js";import{t as n}from"./toSingle-1Si1O88f.js";function r(...t){return e(i,t,n(a))}const i=(e,t)=>e.find(t),a=e=>(n,r,i)=>e(n,r,i)?{done:!0,hasNext:!0,next:n}:t;export{r as find};
 //# sourceMappingURL=find.js.map

package/dist/first.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`),t=require(`./toSingle-z9yHVHGr.cjs`);function n(...n){return e.purry(r,n,t.t(i))}const r=([e])=>e,i=()=>a,a=e=>({hasNext:!0,next:e,done:!0});exports.first=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`),t=require(`./toSingle-DMyKrrN-.cjs`);function n(...n){return e.purry(r,n,t.t(i))}const r=([e])=>e,i=()=>a,a=e=>({hasNext:!0,next:e,done:!0});exports.first=n;
 //# sourceMappingURL=first.cjs.map

package/dist/first.js

@@ -1,2 +1,2 @@
-import{purry as e}from"./purry.js";import{t}from"./toSingle-qs9PC5sP.js";function n(...n){return e(r,n,t(i))}const r=([e])=>e,i=()=>a,a=e=>({hasNext:!0,next:e,done:!0});export{n as first};
+import{purry as e}from"./purry.js";import{t}from"./toSingle-1Si1O88f.js";function n(...n){return e(r,n,t(i))}const r=([e])=>e,i=()=>a,a=e=>({hasNext:!0,next:e,done:!0});export{n as first};
 //# sourceMappingURL=first.js.map

package/dist/firstBy.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./hasAtLeast.cjs`),t=require(`./purryOrderRules-B8pzD03D.cjs`);function n(...e){return t.t(r,e)}function r(t,n){if(!e.hasAtLeast(t,2))return t[0];let[r]=t,[,...i]=t;for(let e of i)n(e,r)<0&&(r=e);return r}exports.firstBy=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./hasAtLeast.cjs`),t=require(`./purryOrderRules-cW1I4C_j.cjs`);function n(...e){return t.t(r,e)}function r(t,n){if(!e.hasAtLeast(t,2))return t[0];let[r]=t,[,...i]=t;for(let e of i)n(e,r)<0&&(r=e);return r}exports.firstBy=n;
 //# sourceMappingURL=firstBy.cjs.map

package/dist/firstBy.js

@@ -1,2 +1,2 @@
-import{hasAtLeast as e}from"./hasAtLeast.js";import{t}from"./purryOrderRules-4JgY6z4X.js";function n(...e){return t(r,e)}function r(t,n){if(!e(t,2))return t[0];let[r]=t,[,...i]=t;for(let e of i)n(e,r)<0&&(r=e);return r}export{n as firstBy};
+import{hasAtLeast as e}from"./hasAtLeast.js";import{t}from"./purryOrderRules-BaB5mcHH.js";function n(...e){return t(r,e)}function r(t,n){if(!e(t,2))return t[0];let[r]=t,[,...i]=t;for(let e of i)n(e,r)<0&&(r=e);return r}export{n as firstBy};
 //# sourceMappingURL=firstBy.js.map

package/dist/flat.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./lazyDataLastImpl-DdpJofHC.cjs`),t=require(`./utilityEvaluators-CW0M8vMV.cjs`);function n(t,n){return typeof t==`object`?r(t,n):e.t(r,t===void 0?[]:[t],i)}const r=(e,t)=>t===void 0?e.flat():e.flat(t),i=e=>e===void 0||e===1?a:e<=0?t.r:t=>Array.isArray(t)?{next:t.flat(e-1),hasNext:!0,hasMany:!0,done:!1}:{next:t,hasNext:!0,done:!1},a=e=>Array.isArray(e)?{next:e,hasNext:!0,hasMany:!0,done:!1}:{next:e,hasNext:!0,done:!1};exports.flat=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./lazyDataLastImpl-DdpJofHC.cjs`),t=require(`./utilityEvaluators-1duvUKJ-.cjs`);function n(t,n){return typeof t==`object`?r(t,n):e.t(r,t===void 0?[]:[t],i)}const r=(e,t)=>t===void 0?e.flat():e.flat(t),i=e=>e===void 0||e===1?a:e<=0?t.r:t=>Array.isArray(t)?{next:t.flat(e-1),hasNext:!0,hasMany:!0,done:!1}:{next:t,hasNext:!0,done:!1},a=e=>Array.isArray(e)?{next:e,hasNext:!0,hasMany:!0,done:!1}:{next:e,hasNext:!0,done:!1};exports.flat=n;
 //# sourceMappingURL=flat.cjs.map

package/dist/flat.js

@@ -1,2 +1,2 @@
-import{t as e}from"./lazyDataLastImpl-DtF3cihj.js";import{r as t}from"./utilityEvaluators-BQqW5Ir5.js";function n(t,n){return typeof t==`object`?r(t,n):e(r,t===void 0?[]:[t],i)}const r=(e,t)=>t===void 0?e.flat():e.flat(t),i=e=>e===void 0||e===1?a:e<=0?t:t=>Array.isArray(t)?{next:t.flat(e-1),hasNext:!0,hasMany:!0,done:!1}:{next:t,hasNext:!0,done:!1},a=e=>Array.isArray(e)?{next:e,hasNext:!0,hasMany:!0,done:!1}:{next:e,hasNext:!0,done:!1};export{n as flat};
+import{t as e}from"./lazyDataLastImpl-DtF3cihj.js";import{r as t}from"./utilityEvaluators-Cb8x6-JZ.js";function n(t,n){return typeof t==`object`?r(t,n):e(r,t===void 0?[]:[t],i)}const r=(e,t)=>t===void 0?e.flat():e.flat(t),i=e=>e===void 0||e===1?a:e<=0?t:t=>Array.isArray(t)?{next:t.flat(e-1),hasNext:!0,hasMany:!0,done:!1}:{next:t,hasNext:!0,done:!1},a=e=>Array.isArray(e)?{next:e,hasNext:!0,hasMany:!0,done:!1}:{next:e,hasNext:!0,done:!1};export{n as flat};
 //# sourceMappingURL=flat.js.map

package/dist/floor.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`),t=require(`./withPrecision-DED4FjDo.cjs`);function n(...n){return e.purry(t.t(Math.floor),n)}exports.floor=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`),t=require(`./withPrecision-L0Ri7wjG.cjs`);function n(...n){return e.purry(t.t(Math.floor),n)}exports.floor=n;
 //# sourceMappingURL=floor.cjs.map

package/dist/floor.js

@@ -1,2 +1,2 @@
-import{purry as e}from"./purry.js";import{t}from"./withPrecision-CDZ-Oor7.js";function n(...n){return e(t(Math.floor),n)}export{n as floor};
+import{purry as e}from"./purry.js";import{t}from"./withPrecision-7nvi8hnb.js";function n(...n){return e(t(Math.floor),n)}export{n as floor};
 //# sourceMappingURL=floor.js.map

package/dist/{heap-OOe_F8_z.js → heap-C8XIujMa.js}

@@ -1,2 +1,2 @@
-import{hasAtLeast as e}from"./hasAtLeast.js";import{t}from"./swapInPlace-BrVgf3c3.js";function n(e,t){for(let n=Math.floor(e.length/2)-1;n>=0;n--)i(e,n,t)}function r(t,n,r){if(!e(t,1))return;let[a]=t;if(!(n(r,a)>=0))return t[0]=r,i(t,0,n),a}function i(e,n,r){let i=n;for(;i*2+1<e.length;){let n=i*2+1,a=r(e[i],e[n])<0?n:i,o=n+1;if(o<e.length&&r(e[a],e[o])<0&&(a=o),a===i)return;t(e,i,a),i=a}}export{n,r as t};
-//# sourceMappingURL=heap-OOe_F8_z.js.map
+import{hasAtLeast as e}from"./hasAtLeast.js";import{t}from"./swapInPlace-Bb1dcddf.js";function n(e,t){for(let n=Math.floor(e.length/2)-1;n>=0;n--)i(e,n,t)}function r(t,n,r){if(!e(t,1))return;let[a]=t;if(!(n(r,a)>=0))return t[0]=r,i(t,0,n),a}function i(e,n,r){let i=n;for(;i*2+1<e.length;){let n=i*2+1,a=r(e[i],e[n])<0?n:i,o=n+1;if(o<e.length&&r(e[a],e[o])<0&&(a=o),a===i)return;t(e,i,a),i=a}}export{n,r as t};
+//# sourceMappingURL=heap-C8XIujMa.js.map

package/dist/{heap-OOe_F8_z.js.map → heap-C8XIujMa.js.map}

@@ -1 +1 @@
-{"version":3,"file":"heap-OOe_F8_z.js","names":[],"sources":["../src/internal/heap.ts"],"sourcesContent":["/**\n * Heap related utilities.\n */\n\nimport { hasAtLeast } from \"../hasAtLeast\";\nimport { swapInPlace } from \"./swapInPlace\";\nimport type { CompareFunction } from \"./types/CompareFunction\";\n\n/**\n * Mutates an array into a \"max\"-heap based on `compareFn` so that for any `item` in the heap, `compareFn(heap[0], item) > 0`.\n *\n * @param heap - The array to be heapified. The array would be mutated!\n * @param compareFn - The comparator used to order items in the heap. Use the\n * same function in all calls mutating the same heap otherwise you'd get\n * unexpected results.\n */\nexport function heapify<T>(\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Intentional!\n  heap: T[],\n  compareFn: CompareFunction<T>,\n): void {\n  for (let i = Math.floor(heap.length / 2) - 1; i >= 0; i--) {\n    heapSiftDown(heap, i, compareFn);\n  }\n}\n\n/**\n * Insert an item into a heap if it's \"smaller\" (in regards to `compareFn`) than\n * the current head of the heap (which is the \"largest\" value in the heap). If\n * the item is inserted, the previous head of the heap is returned, otherwise\n * `undefined` is returned and the heap is unchanged.\n *\n * @param heap - A *mutable* array representing a heap (see `heapify`).\n * @param compareFn - The comparator used to order items in the heap. Use the.\n * @param item - The item to be inserted into the heap.\n * @returns `undefined` if the heap is unchanged, or the previous head of the\n * heap if the item was inserted.\n */\nexport function heapMaybeInsert<T>(\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Intentional!\n  heap: T[],\n  compareFn: CompareFunction<T>,\n  item: T,\n): T | undefined {\n  if (!hasAtLeast(heap, 1)) {\n    return undefined;\n  }\n\n  const [head] = heap;\n\n  if (compareFn(item, head) >= 0) {\n    // The item shouldn't be inserted into the heap, the heap is unchanged.\n    return undefined;\n  }\n\n  heap[0] = item;\n  heapSiftDown(heap, 0, compareFn);\n  return head;\n}\n\n/**\n * The main heap operation. Takes a `heap` and an `index` and sifts the item\n * down the heap until it reaches the correct position based on `compareFn`,\n * swapping other items in the process.\n */\nfunction heapSiftDown<T>(\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Intentional!\n  heap: T[],\n  index: number,\n  compareFn: CompareFunction<T>,\n): void {\n  let currentIndex = index;\n\n  // The loop continues while the currentIndex has children in the heap.\n  while (currentIndex * 2 + 1 < heap.length) {\n    const firstChildIndex = currentIndex * 2 + 1;\n\n    let swapIndex =\n      compareFn(heap[currentIndex]!, heap[firstChildIndex]!) < 0\n        ? // Is the parent \"smaller\" (in regards to `compareFn`) to its child?\n          firstChildIndex\n        : currentIndex;\n\n    const secondChildIndex = firstChildIndex + 1;\n    if (\n      secondChildIndex < heap.length &&\n      compareFn(heap[swapIndex]!, heap[secondChildIndex]!) < 0\n    ) {\n      // Is there a second child? Is it the smallest of the three?\n      swapIndex = secondChildIndex;\n    }\n\n    if (swapIndex === currentIndex) {\n      // We assume the array is a heap and the existing order of items satisfies\n      // the compareFn so we can stop here.\n      return;\n    }\n\n    swapInPlace(heap, currentIndex, swapIndex);\n\n    currentIndex = swapIndex;\n  }\n}\n"],"mappings":"sFAgBA,SAAgB,EAEd,EACA,EACM,CACN,IAAK,IAAI,EAAI,KAAK,MAAM,EAAK,OAAS,EAAE,CAAG,EAAG,GAAK,EAAG,IACpD,EAAa,EAAM,EAAG,EAAU,CAgBpC,SAAgB,EAEd,EACA,EACA,EACe,CACf,GAAI,CAAC,EAAW,EAAM,EAAE,CACtB,OAGF,GAAM,CAAC,GAAQ,EAEX,OAAU,EAAM,EAAK,EAAI,GAO7B,MAFA,GAAK,GAAK,EACV,EAAa,EAAM,EAAG,EAAU,CACzB,EAQT,SAAS,EAEP,EACA,EACA,EACM,CACN,IAAI,EAAe,EAGnB,KAAO,EAAe,EAAI,EAAI,EAAK,QAAQ,CACzC,IAAM,EAAkB,EAAe,EAAI,EAEvC,EACF,EAAU,EAAK,GAAgB,EAAK,GAAkB,CAAG,EAErD,EACA,EAEA,EAAmB,EAAkB,EAS3C,GAPE,EAAmB,EAAK,QACxB,EAAU,EAAK,GAAa,EAAK,GAAmB,CAAG,IAGvD,EAAY,GAGV,IAAc,EAGhB,OAGF,EAAY,EAAM,EAAc,EAAU,CAE1C,EAAe"}
+{"version":3,"file":"heap-C8XIujMa.js","names":[],"sources":["../src/internal/heap.ts"],"sourcesContent":["/**\n * Heap related utilities.\n */\n\nimport { hasAtLeast } from \"../hasAtLeast\";\nimport { swapInPlace } from \"./swapInPlace\";\nimport type { CompareFunction } from \"./types/CompareFunction\";\n\n/**\n * Mutates an array into a \"max\"-heap based on `compareFn` so that for any `item` in the heap, `compareFn(heap[0], item) > 0`.\n *\n * @param heap - The array to be heapified. The array would be mutated!\n * @param compareFn - The comparator used to order items in the heap. Use the\n * same function in all calls mutating the same heap otherwise you'd get\n * unexpected results.\n */\nexport function heapify<T>(\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Intentional!\n  heap: T[],\n  compareFn: CompareFunction<T>,\n): void {\n  for (let i = Math.floor(heap.length / 2) - 1; i >= 0; i--) {\n    heapSiftDown(heap, i, compareFn);\n  }\n}\n\n/**\n * Insert an item into a heap if it's \"smaller\" (in regards to `compareFn`) than\n * the current head of the heap (which is the \"largest\" value in the heap). If\n * the item is inserted, the previous head of the heap is returned, otherwise\n * `undefined` is returned and the heap is unchanged.\n *\n * @param heap - A *mutable* array representing a heap (see `heapify`).\n * @param compareFn - The comparator used to order items in the heap. Use the.\n * @param item - The item to be inserted into the heap.\n * @returns `undefined` if the heap is unchanged, or the previous head of the\n * heap if the item was inserted.\n */\nexport function heapMaybeInsert<T>(\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Intentional!\n  heap: T[],\n  compareFn: CompareFunction<T>,\n  item: T,\n): T | undefined {\n  if (!hasAtLeast(heap, 1)) {\n    return undefined;\n  }\n\n  const [head] = heap;\n\n  if (compareFn(item, head) >= 0) {\n    // The item shouldn't be inserted into the heap, the heap is unchanged.\n    return undefined;\n  }\n\n  heap[0] = item;\n  heapSiftDown(heap, 0, compareFn);\n  return head;\n}\n\n/**\n * The main heap operation. Takes a `heap` and an `index` and sifts the item\n * down the heap until it reaches the correct position based on `compareFn`,\n * swapping other items in the process.\n */\nfunction heapSiftDown<T>(\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Intentional!\n  heap: T[],\n  index: number,\n  compareFn: CompareFunction<T>,\n): void {\n  let currentIndex = index;\n\n  // The loop continues while the currentIndex has children in the heap.\n  while (currentIndex * 2 + 1 < heap.length) {\n    const firstChildIndex = currentIndex * 2 + 1;\n\n    let swapIndex =\n      compareFn(heap[currentIndex]!, heap[firstChildIndex]!) < 0\n        ? // Is the parent \"smaller\" (in regards to `compareFn`) to its child?\n          firstChildIndex\n        : currentIndex;\n\n    const secondChildIndex = firstChildIndex + 1;\n    if (\n      secondChildIndex < heap.length &&\n      compareFn(heap[swapIndex]!, heap[secondChildIndex]!) < 0\n    ) {\n      // Is there a second child? Is it the smallest of the three?\n      swapIndex = secondChildIndex;\n    }\n\n    if (swapIndex === currentIndex) {\n      // We assume the array is a heap and the existing order of items satisfies\n      // the compareFn so we can stop here.\n      return;\n    }\n\n    swapInPlace(heap, currentIndex, swapIndex);\n\n    currentIndex = swapIndex;\n  }\n}\n"],"mappings":"sFAgBA,SAAgB,EAEd,EACA,EACM,CACN,IAAK,IAAI,EAAI,KAAK,MAAM,EAAK,OAAS,EAAE,CAAG,EAAG,GAAK,EAAG,IACpD,EAAa,EAAM,EAAG,EAAU,CAgBpC,SAAgB,EAEd,EACA,EACA,EACe,CACf,GAAI,CAAC,EAAW,EAAM,EAAE,CACtB,OAGF,GAAM,CAAC,GAAQ,EAEX,OAAU,EAAM,EAAK,EAAI,GAO7B,MAFA,GAAK,GAAK,EACV,EAAa,EAAM,EAAG,EAAU,CACzB,EAQT,SAAS,EAEP,EACA,EACA,EACM,CACN,IAAI,EAAe,EAGnB,KAAO,EAAe,EAAI,EAAI,EAAK,QAAQ,CACzC,IAAM,EAAkB,EAAe,EAAI,EAEvC,EACF,EAAU,EAAK,GAAgB,EAAK,GAAkB,CAAG,EAErD,EACA,EAEA,EAAmB,EAAkB,EAS3C,GAPE,EAAmB,EAAK,QACxB,EAAU,EAAK,GAAa,EAAK,GAAmB,CAAG,IAGvD,EAAY,GAGV,IAAc,EAGhB,OAGF,EAAY,EAAM,EAAc,EAAU,CAE1C,EAAe"}

package/dist/{heap-14xVkDB1.cjs → heap-Ct9W7Bbi.cjs}

@@ -1,2 +1,2 @@
-const e=require(`./hasAtLeast.cjs`),t=require(`./swapInPlace-IOnMIay9.cjs`);function n(e,t){for(let n=Math.floor(e.length/2)-1;n>=0;n--)i(e,n,t)}function r(t,n,r){if(!e.hasAtLeast(t,1))return;let[a]=t;if(!(n(r,a)>=0))return t[0]=r,i(t,0,n),a}function i(e,n,r){let i=n;for(;i*2+1<e.length;){let n=i*2+1,a=r(e[i],e[n])<0?n:i,o=n+1;if(o<e.length&&r(e[a],e[o])<0&&(a=o),a===i)return;t.t(e,i,a),i=a}}Object.defineProperty(exports,`n`,{enumerable:!0,get:function(){return n}}),Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return r}});
-//# sourceMappingURL=heap-14xVkDB1.cjs.map
+const e=require(`./hasAtLeast.cjs`),t=require(`./swapInPlace-Wglp6T7K.cjs`);function n(e,t){for(let n=Math.floor(e.length/2)-1;n>=0;n--)i(e,n,t)}function r(t,n,r){if(!e.hasAtLeast(t,1))return;let[a]=t;if(!(n(r,a)>=0))return t[0]=r,i(t,0,n),a}function i(e,n,r){let i=n;for(;i*2+1<e.length;){let n=i*2+1,a=r(e[i],e[n])<0?n:i,o=n+1;if(o<e.length&&r(e[a],e[o])<0&&(a=o),a===i)return;t.t(e,i,a),i=a}}Object.defineProperty(exports,`n`,{enumerable:!0,get:function(){return n}}),Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return r}});
+//# sourceMappingURL=heap-Ct9W7Bbi.cjs.map

package/dist/{heap-14xVkDB1.cjs.map → heap-Ct9W7Bbi.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"heap-14xVkDB1.cjs","names":["hasAtLeast"],"sources":["../src/internal/heap.ts"],"sourcesContent":["/**\n * Heap related utilities.\n */\n\nimport { hasAtLeast } from \"../hasAtLeast\";\nimport { swapInPlace } from \"./swapInPlace\";\nimport type { CompareFunction } from \"./types/CompareFunction\";\n\n/**\n * Mutates an array into a \"max\"-heap based on `compareFn` so that for any `item` in the heap, `compareFn(heap[0], item) > 0`.\n *\n * @param heap - The array to be heapified. The array would be mutated!\n * @param compareFn - The comparator used to order items in the heap. Use the\n * same function in all calls mutating the same heap otherwise you'd get\n * unexpected results.\n */\nexport function heapify<T>(\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Intentional!\n  heap: T[],\n  compareFn: CompareFunction<T>,\n): void {\n  for (let i = Math.floor(heap.length / 2) - 1; i >= 0; i--) {\n    heapSiftDown(heap, i, compareFn);\n  }\n}\n\n/**\n * Insert an item into a heap if it's \"smaller\" (in regards to `compareFn`) than\n * the current head of the heap (which is the \"largest\" value in the heap). If\n * the item is inserted, the previous head of the heap is returned, otherwise\n * `undefined` is returned and the heap is unchanged.\n *\n * @param heap - A *mutable* array representing a heap (see `heapify`).\n * @param compareFn - The comparator used to order items in the heap. Use the.\n * @param item - The item to be inserted into the heap.\n * @returns `undefined` if the heap is unchanged, or the previous head of the\n * heap if the item was inserted.\n */\nexport function heapMaybeInsert<T>(\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Intentional!\n  heap: T[],\n  compareFn: CompareFunction<T>,\n  item: T,\n): T | undefined {\n  if (!hasAtLeast(heap, 1)) {\n    return undefined;\n  }\n\n  const [head] = heap;\n\n  if (compareFn(item, head) >= 0) {\n    // The item shouldn't be inserted into the heap, the heap is unchanged.\n    return undefined;\n  }\n\n  heap[0] = item;\n  heapSiftDown(heap, 0, compareFn);\n  return head;\n}\n\n/**\n * The main heap operation. Takes a `heap` and an `index` and sifts the item\n * down the heap until it reaches the correct position based on `compareFn`,\n * swapping other items in the process.\n */\nfunction heapSiftDown<T>(\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Intentional!\n  heap: T[],\n  index: number,\n  compareFn: CompareFunction<T>,\n): void {\n  let currentIndex = index;\n\n  // The loop continues while the currentIndex has children in the heap.\n  while (currentIndex * 2 + 1 < heap.length) {\n    const firstChildIndex = currentIndex * 2 + 1;\n\n    let swapIndex =\n      compareFn(heap[currentIndex]!, heap[firstChildIndex]!) < 0\n        ? // Is the parent \"smaller\" (in regards to `compareFn`) to its child?\n          firstChildIndex\n        : currentIndex;\n\n    const secondChildIndex = firstChildIndex + 1;\n    if (\n      secondChildIndex < heap.length &&\n      compareFn(heap[swapIndex]!, heap[secondChildIndex]!) < 0\n    ) {\n      // Is there a second child? Is it the smallest of the three?\n      swapIndex = secondChildIndex;\n    }\n\n    if (swapIndex === currentIndex) {\n      // We assume the array is a heap and the existing order of items satisfies\n      // the compareFn so we can stop here.\n      return;\n    }\n\n    swapInPlace(heap, currentIndex, swapIndex);\n\n    currentIndex = swapIndex;\n  }\n}\n"],"mappings":"4EAgBA,SAAgB,EAEd,EACA,EACM,CACN,IAAK,IAAI,EAAI,KAAK,MAAM,EAAK,OAAS,EAAE,CAAG,EAAG,GAAK,EAAG,IACpD,EAAa,EAAM,EAAG,EAAU,CAgBpC,SAAgB,EAEd,EACA,EACA,EACe,CACf,GAAI,CAACA,EAAAA,WAAW,EAAM,EAAE,CACtB,OAGF,GAAM,CAAC,GAAQ,EAEX,OAAU,EAAM,EAAK,EAAI,GAO7B,MAFA,GAAK,GAAK,EACV,EAAa,EAAM,EAAG,EAAU,CACzB,EAQT,SAAS,EAEP,EACA,EACA,EACM,CACN,IAAI,EAAe,EAGnB,KAAO,EAAe,EAAI,EAAI,EAAK,QAAQ,CACzC,IAAM,EAAkB,EAAe,EAAI,EAEvC,EACF,EAAU,EAAK,GAAgB,EAAK,GAAkB,CAAG,EAErD,EACA,EAEA,EAAmB,EAAkB,EAS3C,GAPE,EAAmB,EAAK,QACxB,EAAU,EAAK,GAAa,EAAK,GAAmB,CAAG,IAGvD,EAAY,GAGV,IAAc,EAGhB,OAGF,EAAA,EAAY,EAAM,EAAc,EAAU,CAE1C,EAAe"}
+{"version":3,"file":"heap-Ct9W7Bbi.cjs","names":["hasAtLeast"],"sources":["../src/internal/heap.ts"],"sourcesContent":["/**\n * Heap related utilities.\n */\n\nimport { hasAtLeast } from \"../hasAtLeast\";\nimport { swapInPlace } from \"./swapInPlace\";\nimport type { CompareFunction } from \"./types/CompareFunction\";\n\n/**\n * Mutates an array into a \"max\"-heap based on `compareFn` so that for any `item` in the heap, `compareFn(heap[0], item) > 0`.\n *\n * @param heap - The array to be heapified. The array would be mutated!\n * @param compareFn - The comparator used to order items in the heap. Use the\n * same function in all calls mutating the same heap otherwise you'd get\n * unexpected results.\n */\nexport function heapify<T>(\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Intentional!\n  heap: T[],\n  compareFn: CompareFunction<T>,\n): void {\n  for (let i = Math.floor(heap.length / 2) - 1; i >= 0; i--) {\n    heapSiftDown(heap, i, compareFn);\n  }\n}\n\n/**\n * Insert an item into a heap if it's \"smaller\" (in regards to `compareFn`) than\n * the current head of the heap (which is the \"largest\" value in the heap). If\n * the item is inserted, the previous head of the heap is returned, otherwise\n * `undefined` is returned and the heap is unchanged.\n *\n * @param heap - A *mutable* array representing a heap (see `heapify`).\n * @param compareFn - The comparator used to order items in the heap. Use the.\n * @param item - The item to be inserted into the heap.\n * @returns `undefined` if the heap is unchanged, or the previous head of the\n * heap if the item was inserted.\n */\nexport function heapMaybeInsert<T>(\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Intentional!\n  heap: T[],\n  compareFn: CompareFunction<T>,\n  item: T,\n): T | undefined {\n  if (!hasAtLeast(heap, 1)) {\n    return undefined;\n  }\n\n  const [head] = heap;\n\n  if (compareFn(item, head) >= 0) {\n    // The item shouldn't be inserted into the heap, the heap is unchanged.\n    return undefined;\n  }\n\n  heap[0] = item;\n  heapSiftDown(heap, 0, compareFn);\n  return head;\n}\n\n/**\n * The main heap operation. Takes a `heap` and an `index` and sifts the item\n * down the heap until it reaches the correct position based on `compareFn`,\n * swapping other items in the process.\n */\nfunction heapSiftDown<T>(\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Intentional!\n  heap: T[],\n  index: number,\n  compareFn: CompareFunction<T>,\n): void {\n  let currentIndex = index;\n\n  // The loop continues while the currentIndex has children in the heap.\n  while (currentIndex * 2 + 1 < heap.length) {\n    const firstChildIndex = currentIndex * 2 + 1;\n\n    let swapIndex =\n      compareFn(heap[currentIndex]!, heap[firstChildIndex]!) < 0\n        ? // Is the parent \"smaller\" (in regards to `compareFn`) to its child?\n          firstChildIndex\n        : currentIndex;\n\n    const secondChildIndex = firstChildIndex + 1;\n    if (\n      secondChildIndex < heap.length &&\n      compareFn(heap[swapIndex]!, heap[secondChildIndex]!) < 0\n    ) {\n      // Is there a second child? Is it the smallest of the three?\n      swapIndex = secondChildIndex;\n    }\n\n    if (swapIndex === currentIndex) {\n      // We assume the array is a heap and the existing order of items satisfies\n      // the compareFn so we can stop here.\n      return;\n    }\n\n    swapInPlace(heap, currentIndex, swapIndex);\n\n    currentIndex = swapIndex;\n  }\n}\n"],"mappings":"4EAgBA,SAAgB,EAEd,EACA,EACM,CACN,IAAK,IAAI,EAAI,KAAK,MAAM,EAAK,OAAS,EAAE,CAAG,EAAG,GAAK,EAAG,IACpD,EAAa,EAAM,EAAG,EAAU,CAgBpC,SAAgB,EAEd,EACA,EACA,EACe,CACf,GAAI,CAACA,EAAAA,WAAW,EAAM,EAAE,CACtB,OAGF,GAAM,CAAC,GAAQ,EAEX,OAAU,EAAM,EAAK,EAAI,GAO7B,MAFA,GAAK,GAAK,EACV,EAAa,EAAM,EAAG,EAAU,CACzB,EAQT,SAAS,EAEP,EACA,EACA,EACM,CACN,IAAI,EAAe,EAGnB,KAAO,EAAe,EAAI,EAAI,EAAK,QAAQ,CACzC,IAAM,EAAkB,EAAe,EAAI,EAEvC,EACF,EAAU,EAAK,GAAgB,EAAK,GAAkB,CAAG,EAErD,EACA,EAEA,EAAmB,EAAkB,EAS3C,GAPE,EAAmB,EAAK,QACxB,EAAU,EAAK,GAAa,EAAK,GAAmB,CAAG,IAGvD,EAAY,GAGV,IAAc,EAGhB,OAGF,EAAA,EAAY,EAAM,EAAc,EAAU,CAE1C,EAAe"}

package/dist/index.cjs

@@ -1 +1 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`),t=require(`./add.cjs`),n=require(`./addProp.cjs`),r=require(`./allPass.cjs`),i=require(`./anyPass.cjs`),a=require(`./capitalize.cjs`),o=require(`./ceil.cjs`),s=require(`./chunk.cjs`),c=require(`./clamp.cjs`),l=require(`./clone.cjs`),u=require(`./concat.cjs`),d=require(`./conditional.cjs`),f=require(`./constant.cjs`),p=require(`./countBy.cjs`),m=require(`./debounce.cjs`),h=require(`./defaultTo.cjs`),g=require(`./pipe.cjs`),_=require(`./difference.cjs`),v=require(`./differenceWith.cjs`),y=require(`./divide.cjs`),b=require(`./doNothing.cjs`),x=require(`./drop.cjs`),S=require(`./hasAtLeast.cjs`),C=require(`./dropFirstBy.cjs`),w=require(`./dropLast.cjs`),T=require(`./dropLastWhile.cjs`),E=require(`./dropWhile.cjs`),D=require(`./endsWith.cjs`),O=require(`./entries.cjs`),k=require(`./evolve.cjs`),A=require(`./filter.cjs`),j=require(`./find.cjs`),M=require(`./findIndex.cjs`),N=require(`./findLast.cjs`),P=require(`./findLastIndex.cjs`),F=require(`./first.cjs`),I=require(`./firstBy.cjs`),L=require(`./flat.cjs`),R=require(`./flatMap.cjs`),z=require(`./floor.cjs`),B=require(`./forEach.cjs`),V=require(`./forEachObj.cjs`),H=require(`./fromEntries.cjs`),U=require(`./fromKeys.cjs`),W=require(`./funnel.cjs`),G=require(`./groupBy.cjs`),K=require(`./groupByProp.cjs`),q=require(`./isDeepEqual.cjs`),J=require(`./hasSubObject.cjs`),Y=require(`./identity.cjs`),X=require(`./indexBy.cjs`),Z=require(`./intersection.cjs`),Q=require(`./intersectionWith.cjs`),$=require(`./invert.cjs`),ee=require(`./isArray.cjs`),te=require(`./isBigInt.cjs`),ne=require(`./isBoolean.cjs`),re=require(`./isDate.cjs`),ie=require(`./isDefined.cjs`),ae=require(`./isEmpty.cjs`),oe=require(`./isEmptyish.cjs`),se=require(`./isError.cjs`),ce=require(`./isFunction.cjs`),le=require(`./isIncludedIn.cjs`),ue=require(`./isNonNull.cjs`),de=require(`./isNonNullish.cjs`),fe=require(`./isNot.cjs`),pe=require(`./isNullish.cjs`),me=require(`./isNumber.cjs`),he=require(`./isObjectType.cjs`),ge=require(`./isPlainObject.cjs`),_e=require(`./isPromise.cjs`),ve=require(`./isShallowEqual.cjs`),ye=require(`./isStrictEqual.cjs`),be=require(`./isString.cjs`),xe=require(`./isSymbol.cjs`),Se=require(`./isTruthy.cjs`),Ce=require(`./join.cjs`),we=require(`./keys.cjs`),Te=require(`./last.cjs`),Ee=require(`./length.cjs`),De=require(`./map.cjs`),Oe=require(`./mapKeys.cjs`),ke=require(`./mapToObj.cjs`),Ae=require(`./mapValues.cjs`),je=require(`./mapWithFeedback.cjs`),Me=require(`./sum.cjs`),Ne=require(`./mean.cjs`),Pe=require(`./meanBy.cjs`),Fe=require(`./median.cjs`),Ie=require(`./merge.cjs`),Le=require(`./mergeAll.cjs`),Re=require(`./mergeDeep.cjs`),ze=require(`./multiply.cjs`),Be=require(`./nthBy.cjs`),Ve=require(`./objOf.cjs`),He=require(`./omit.cjs`),Ue=require(`./omitBy.cjs`),We=require(`./once.cjs`),Ge=require(`./only.cjs`),Ke=require(`./partialBind.cjs`),qe=require(`./partialLastBind.cjs`),Je=require(`./partition.cjs`),Ye=require(`./pathOr.cjs`),Xe=require(`./pick.cjs`),Ze=require(`./pickBy.cjs`),Qe=require(`./piped.cjs`),$e=require(`./product.cjs`),et=require(`./prop.cjs`),tt=require(`./pullObject.cjs`),nt=require(`./randomBigInt.cjs`),rt=require(`./randomInteger.cjs`),it=require(`./randomString.cjs`),at=require(`./range.cjs`),ot=require(`./rankBy.cjs`),st=require(`./reduce.cjs`),ct=require(`./reverse.cjs`),lt=require(`./round.cjs`),ut=require(`./sample.cjs`),dt=require(`./set.cjs`),ft=require(`./setPath.cjs`),pt=require(`./shuffle.cjs`),mt=require(`./sliceString.cjs`),ht=require(`./sort.cjs`),gt=require(`./sortBy.cjs`),_t=require(`./sortedIndex.cjs`),vt=require(`./sortedIndexBy.cjs`),yt=require(`./sortedIndexWith.cjs`),bt=require(`./sortedLastIndex.cjs`),xt=require(`./sortedLastIndexBy.cjs`),St=require(`./splice.cjs`),Ct=require(`./split.cjs`),wt=require(`./splitAt.cjs`),Tt=require(`./splitWhen.cjs`),Et=require(`./startsWith.cjs`),Dt=require(`./stringToPath.cjs`),Ot=require(`./subtract.cjs`),kt=require(`./sumBy.cjs`),At=require(`./swapIndices.cjs`),jt=require(`./swapProps.cjs`),Mt=require(`./take.cjs`),Nt=require(`./takeFirstBy.cjs`),Pt=require(`./takeLast.cjs`),Ft=require(`./takeLastWhile.cjs`),It=require(`./takeWhile.cjs`),Lt=require(`./tap.cjs`),Rt=require(`./times.cjs`),zt=require(`./toCamelCase.cjs`),Bt=require(`./toKebabCase.cjs`),Vt=require(`./toLowerCase.cjs`),Ht=require(`./toSnakeCase.cjs`),Ut=require(`./toTitleCase.cjs`),Wt=require(`./toUpperCase.cjs`),Gt=require(`./truncate.cjs`),Kt=require(`./uncapitalize.cjs`),qt=require(`./unique.cjs`),Jt=require(`./uniqueBy.cjs`),Yt=require(`./uniqueWith.cjs`),Xt=require(`./values.cjs`),Zt=require(`./when.cjs`),Qt=require(`./zip.cjs`),$t=require(`./zipWith.cjs`);exports.add=t.add,exports.addProp=n.addProp,exports.allPass=r.allPass,exports.anyPass=i.anyPass,exports.capitalize=a.capitalize,exports.ceil=o.ceil,exports.chunk=s.chunk,exports.clamp=c.clamp,exports.clone=l.clone,exports.concat=u.concat,exports.conditional=d.conditional,exports.constant=f.constant,exports.countBy=p.countBy,exports.debounce=m.debounce,exports.defaultTo=h.defaultTo,exports.difference=_.difference,exports.differenceWith=v.differenceWith,exports.divide=y.divide,exports.doNothing=b.doNothing,exports.drop=x.drop,exports.dropFirstBy=C.dropFirstBy,exports.dropLast=w.dropLast,exports.dropLastWhile=T.dropLastWhile,exports.dropWhile=E.dropWhile,exports.endsWith=D.endsWith,exports.entries=O.entries,exports.evolve=k.evolve,exports.filter=A.filter,exports.find=j.find,exports.findIndex=M.findIndex,exports.findLast=N.findLast,exports.findLastIndex=P.findLastIndex,exports.first=F.first,exports.firstBy=I.firstBy,exports.flat=L.flat,exports.flatMap=R.flatMap,exports.floor=z.floor,exports.forEach=B.forEach,exports.forEachObj=V.forEachObj,exports.fromEntries=H.fromEntries,exports.fromKeys=U.fromKeys,exports.funnel=W.funnel,exports.groupBy=G.groupBy,exports.groupByProp=K.groupByProp,exports.hasAtLeast=S.hasAtLeast,exports.hasSubObject=J.hasSubObject,exports.identity=Y.identity,exports.indexBy=X.indexBy,exports.intersection=Z.intersection,exports.intersectionWith=Q.intersectionWith,exports.invert=$.invert,exports.isArray=ee.isArray,exports.isBigInt=te.isBigInt,exports.isBoolean=ne.isBoolean,exports.isDate=re.isDate,exports.isDeepEqual=q.isDeepEqual,exports.isDefined=ie.isDefined,exports.isEmpty=ae.isEmpty,exports.isEmptyish=oe.isEmptyish,exports.isError=se.isError,exports.isFunction=ce.isFunction,exports.isIncludedIn=le.isIncludedIn,exports.isNonNull=ue.isNonNull,exports.isNonNullish=de.isNonNullish,exports.isNot=fe.isNot,exports.isNullish=pe.isNullish,exports.isNumber=me.isNumber,exports.isObjectType=he.isObjectType,exports.isPlainObject=ge.isPlainObject,exports.isPromise=_e.isPromise,exports.isShallowEqual=ve.isShallowEqual,exports.isStrictEqual=ye.isStrictEqual,exports.isString=be.isString,exports.isSymbol=xe.isSymbol,exports.isTruthy=Se.isTruthy,exports.join=Ce.join,exports.keys=we.keys,exports.last=Te.last,exports.length=Ee.length,exports.map=De.map,exports.mapKeys=Oe.mapKeys,exports.mapToObj=ke.mapToObj,exports.mapValues=Ae.mapValues,exports.mapWithFeedback=je.mapWithFeedback,exports.mean=Ne.mean,exports.meanBy=Pe.meanBy,exports.median=Fe.median,exports.merge=Ie.merge,exports.mergeAll=Le.mergeAll,exports.mergeDeep=Re.mergeDeep,exports.multiply=ze.multiply,exports.nthBy=Be.nthBy,exports.objOf=Ve.objOf,exports.omit=He.omit,exports.omitBy=Ue.omitBy,exports.once=We.once,exports.only=Ge.only,exports.partialBind=Ke.partialBind,exports.partialLastBind=qe.partialLastBind,exports.partition=Je.partition,exports.pathOr=Ye.pathOr,exports.pick=Xe.pick,exports.pickBy=Ze.pickBy,exports.pipe=g.pipe,exports.piped=Qe.piped,exports.product=$e.product,exports.prop=et.prop,exports.pullObject=tt.pullObject,exports.purry=e.purry,exports.randomBigInt=nt.randomBigInt,exports.randomInteger=rt.randomInteger,exports.randomString=it.randomString,exports.range=at.range,exports.rankBy=ot.rankBy,exports.reduce=st.reduce,exports.reverse=ct.reverse,exports.round=lt.round,exports.sample=ut.sample,exports.set=dt.set,exports.setPath=ft.setPath,exports.shuffle=pt.shuffle,exports.sliceString=mt.sliceString,exports.sort=ht.sort,exports.sortBy=gt.sortBy,exports.sortedIndex=_t.sortedIndex,exports.sortedIndexBy=vt.sortedIndexBy,exports.sortedIndexWith=yt.sortedIndexWith,exports.sortedLastIndex=bt.sortedLastIndex,exports.sortedLastIndexBy=xt.sortedLastIndexBy,exports.splice=St.splice,exports.split=Ct.split,exports.splitAt=wt.splitAt,exports.splitWhen=Tt.splitWhen,exports.startsWith=Et.startsWith,exports.stringToPath=Dt.stringToPath,exports.subtract=Ot.subtract,exports.sum=Me.sum,exports.sumBy=kt.sumBy,exports.swapIndices=At.swapIndices,exports.swapProps=jt.swapProps,exports.take=Mt.take,exports.takeFirstBy=Nt.takeFirstBy,exports.takeLast=Pt.takeLast,exports.takeLastWhile=Ft.takeLastWhile,exports.takeWhile=It.takeWhile,exports.tap=Lt.tap,exports.times=Rt.times,exports.toCamelCase=zt.toCamelCase,exports.toKebabCase=Bt.toKebabCase,exports.toLowerCase=Vt.toLowerCase,exports.toSnakeCase=Ht.toSnakeCase,exports.toTitleCase=Ut.toTitleCase,exports.toUpperCase=Wt.toUpperCase,exports.truncate=Gt.truncate,exports.uncapitalize=Kt.uncapitalize,exports.unique=qt.unique,exports.uniqueBy=Jt.uniqueBy,exports.uniqueWith=Yt.uniqueWith,exports.values=Xt.values,exports.when=Zt.when,exports.zip=Qt.zip,exports.zipWith=$t.zipWith;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`),t=require(`./add.cjs`),n=require(`./addProp.cjs`),r=require(`./allPass.cjs`),i=require(`./anyPass.cjs`),a=require(`./capitalize.cjs`),o=require(`./ceil.cjs`),s=require(`./chunk.cjs`),c=require(`./clamp.cjs`),l=require(`./clone.cjs`),u=require(`./concat.cjs`),d=require(`./conditional-3wcaMG9k.cjs`),f=require(`./constant.cjs`),p=require(`./countBy.cjs`),m=require(`./debounce.cjs`),h=require(`./defaultTo.cjs`),g=require(`./pipe.cjs`),_=require(`./difference.cjs`),v=require(`./differenceWith.cjs`),y=require(`./divide.cjs`),b=require(`./doNothing.cjs`),x=require(`./drop.cjs`),S=require(`./hasAtLeast.cjs`),C=require(`./dropFirstBy.cjs`),w=require(`./dropLast.cjs`),T=require(`./dropLastWhile.cjs`),E=require(`./dropWhile.cjs`),D=require(`./endsWith.cjs`),O=require(`./entries.cjs`),k=require(`./evolve.cjs`),A=require(`./filter.cjs`),j=require(`./find.cjs`),M=require(`./findIndex.cjs`),N=require(`./findLast.cjs`),P=require(`./findLastIndex.cjs`),F=require(`./first.cjs`),I=require(`./firstBy.cjs`),L=require(`./flat.cjs`),R=require(`./flatMap.cjs`),z=require(`./floor.cjs`),B=require(`./forEach.cjs`),V=require(`./forEachObj.cjs`),H=require(`./fromEntries.cjs`),U=require(`./fromKeys.cjs`),W=require(`./funnel.cjs`),G=require(`./groupBy.cjs`),K=require(`./groupByProp.cjs`),q=require(`./isDeepEqual.cjs`),J=require(`./hasSubObject.cjs`),Y=require(`./identity.cjs`),X=require(`./indexBy.cjs`),Z=require(`./intersection.cjs`),Q=require(`./intersectionWith.cjs`),$=require(`./invert.cjs`),ee=require(`./isArray.cjs`),te=require(`./isBigInt.cjs`),ne=require(`./isBoolean.cjs`),re=require(`./isDate.cjs`),ie=require(`./isDefined.cjs`),ae=require(`./isEmpty.cjs`),oe=require(`./isEmptyish.cjs`),se=require(`./isError.cjs`),ce=require(`./isFunction.cjs`),le=require(`./isIncludedIn.cjs`),ue=require(`./isNonNull.cjs`),de=require(`./isNonNullish.cjs`),fe=require(`./isNot.cjs`),pe=require(`./isNullish.cjs`),me=require(`./isNumber.cjs`),he=require(`./isObjectType.cjs`),ge=require(`./isPlainObject.cjs`),_e=require(`./isPromise.cjs`),ve=require(`./isShallowEqual.cjs`),ye=require(`./isStrictEqual.cjs`),be=require(`./isString.cjs`),xe=require(`./isSymbol.cjs`),Se=require(`./isTruthy.cjs`),Ce=require(`./join.cjs`),we=require(`./keys.cjs`),Te=require(`./last.cjs`),Ee=require(`./length.cjs`),De=require(`./map.cjs`),Oe=require(`./mapKeys.cjs`),ke=require(`./mapToObj.cjs`),Ae=require(`./mapValues.cjs`),je=require(`./mapWithFeedback.cjs`),Me=require(`./sum.cjs`),Ne=require(`./mean.cjs`),Pe=require(`./meanBy.cjs`),Fe=require(`./median.cjs`),Ie=require(`./merge.cjs`),Le=require(`./mergeAll.cjs`),Re=require(`./mergeDeep.cjs`),ze=require(`./multiply.cjs`),Be=require(`./nthBy-BFUrUEqW.cjs`),Ve=require(`./objOf.cjs`),He=require(`./omit.cjs`),Ue=require(`./omitBy.cjs`),We=require(`./once.cjs`),Ge=require(`./only.cjs`),Ke=require(`./partialBind.cjs`),qe=require(`./partialLastBind.cjs`),Je=require(`./partition.cjs`),Ye=require(`./pathOr.cjs`),Xe=require(`./pick.cjs`),Ze=require(`./pickBy.cjs`),Qe=require(`./piped.cjs`),$e=require(`./product.cjs`),et=require(`./prop.cjs`),tt=require(`./pullObject.cjs`),nt=require(`./randomBigInt.cjs`),rt=require(`./randomInteger.cjs`),it=require(`./randomString.cjs`),at=require(`./range.cjs`),ot=require(`./rankBy.cjs`),st=require(`./reduce.cjs`),ct=require(`./reverse.cjs`),lt=require(`./round.cjs`),ut=require(`./sample.cjs`),dt=require(`./set.cjs`),ft=require(`./setPath.cjs`),pt=require(`./shuffle.cjs`),mt=require(`./sliceString.cjs`),ht=require(`./sort.cjs`),gt=require(`./sortBy.cjs`),_t=require(`./sortedIndex.cjs`),vt=require(`./sortedIndexBy.cjs`),yt=require(`./sortedIndexWith.cjs`),bt=require(`./sortedLastIndex.cjs`),xt=require(`./sortedLastIndexBy.cjs`),St=require(`./splice.cjs`),Ct=require(`./split.cjs`),wt=require(`./splitAt.cjs`),Tt=require(`./splitWhen.cjs`),Et=require(`./startsWith.cjs`),Dt=require(`./stringToPath.cjs`),Ot=require(`./subtract.cjs`),kt=require(`./sumBy.cjs`),At=require(`./swapIndices.cjs`),jt=require(`./swapProps.cjs`),Mt=require(`./take.cjs`),Nt=require(`./takeFirstBy.cjs`),Pt=require(`./takeLast.cjs`),Ft=require(`./takeLastWhile.cjs`),It=require(`./takeWhile.cjs`),Lt=require(`./tap.cjs`),Rt=require(`./times.cjs`),zt=require(`./toCamelCase.cjs`),Bt=require(`./toKebabCase.cjs`),Vt=require(`./toLowerCase.cjs`),Ht=require(`./toSnakeCase.cjs`),Ut=require(`./toTitleCase.cjs`),Wt=require(`./toUpperCase.cjs`),Gt=require(`./truncate.cjs`),Kt=require(`./uncapitalize.cjs`),qt=require(`./unique.cjs`),Jt=require(`./uniqueBy.cjs`),Yt=require(`./uniqueWith.cjs`),Xt=require(`./values.cjs`),Zt=require(`./when.cjs`),Qt=require(`./zip.cjs`),$t=require(`./zipWith.cjs`);exports.add=t.add,exports.addProp=n.addProp,exports.allPass=r.allPass,exports.anyPass=i.anyPass,exports.capitalize=a.capitalize,exports.ceil=o.ceil,exports.chunk=s.chunk,exports.clamp=c.clamp,exports.clone=l.clone,exports.concat=u.concat,exports.conditional=d.t,exports.constant=f.constant,exports.countBy=p.countBy,exports.debounce=m.debounce,exports.defaultTo=h.defaultTo,exports.difference=_.difference,exports.differenceWith=v.differenceWith,exports.divide=y.divide,exports.doNothing=b.doNothing,exports.drop=x.drop,exports.dropFirstBy=C.dropFirstBy,exports.dropLast=w.dropLast,exports.dropLastWhile=T.dropLastWhile,exports.dropWhile=E.dropWhile,exports.endsWith=D.endsWith,exports.entries=O.entries,exports.evolve=k.evolve,exports.filter=A.filter,exports.find=j.find,exports.findIndex=M.findIndex,exports.findLast=N.findLast,exports.findLastIndex=P.findLastIndex,exports.first=F.first,exports.firstBy=I.firstBy,exports.flat=L.flat,exports.flatMap=R.flatMap,exports.floor=z.floor,exports.forEach=B.forEach,exports.forEachObj=V.forEachObj,exports.fromEntries=H.fromEntries,exports.fromKeys=U.fromKeys,exports.funnel=W.funnel,exports.groupBy=G.groupBy,exports.groupByProp=K.groupByProp,exports.hasAtLeast=S.hasAtLeast,exports.hasSubObject=J.hasSubObject,exports.identity=Y.identity,exports.indexBy=X.indexBy,exports.intersection=Z.intersection,exports.intersectionWith=Q.intersectionWith,exports.invert=$.invert,exports.isArray=ee.isArray,exports.isBigInt=te.isBigInt,exports.isBoolean=ne.isBoolean,exports.isDate=re.isDate,exports.isDeepEqual=q.isDeepEqual,exports.isDefined=ie.isDefined,exports.isEmpty=ae.isEmpty,exports.isEmptyish=oe.isEmptyish,exports.isError=se.isError,exports.isFunction=ce.isFunction,exports.isIncludedIn=le.isIncludedIn,exports.isNonNull=ue.isNonNull,exports.isNonNullish=de.isNonNullish,exports.isNot=fe.isNot,exports.isNullish=pe.isNullish,exports.isNumber=me.isNumber,exports.isObjectType=he.isObjectType,exports.isPlainObject=ge.isPlainObject,exports.isPromise=_e.isPromise,exports.isShallowEqual=ve.isShallowEqual,exports.isStrictEqual=ye.isStrictEqual,exports.isString=be.isString,exports.isSymbol=xe.isSymbol,exports.isTruthy=Se.isTruthy,exports.join=Ce.join,exports.keys=we.keys,exports.last=Te.last,exports.length=Ee.length,exports.map=De.map,exports.mapKeys=Oe.mapKeys,exports.mapToObj=ke.mapToObj,exports.mapValues=Ae.mapValues,exports.mapWithFeedback=je.mapWithFeedback,exports.mean=Ne.mean,exports.meanBy=Pe.meanBy,exports.median=Fe.median,exports.merge=Ie.merge,exports.mergeAll=Le.mergeAll,exports.mergeDeep=Re.mergeDeep,exports.multiply=ze.multiply,exports.nthBy=Be.t,exports.objOf=Ve.objOf,exports.omit=He.omit,exports.omitBy=Ue.omitBy,exports.once=We.once,exports.only=Ge.only,exports.partialBind=Ke.partialBind,exports.partialLastBind=qe.partialLastBind,exports.partition=Je.partition,exports.pathOr=Ye.pathOr,exports.pick=Xe.pick,exports.pickBy=Ze.pickBy,exports.pipe=g.pipe,exports.piped=Qe.piped,exports.product=$e.product,exports.prop=et.prop,exports.pullObject=tt.pullObject,exports.purry=e.purry,exports.randomBigInt=nt.randomBigInt,exports.randomInteger=rt.randomInteger,exports.randomString=it.randomString,exports.range=at.range,exports.rankBy=ot.rankBy,exports.reduce=st.reduce,exports.reverse=ct.reverse,exports.round=lt.round,exports.sample=ut.sample,exports.set=dt.set,exports.setPath=ft.setPath,exports.shuffle=pt.shuffle,exports.sliceString=mt.sliceString,exports.sort=ht.sort,exports.sortBy=gt.sortBy,exports.sortedIndex=_t.sortedIndex,exports.sortedIndexBy=vt.sortedIndexBy,exports.sortedIndexWith=yt.sortedIndexWith,exports.sortedLastIndex=bt.sortedLastIndex,exports.sortedLastIndexBy=xt.sortedLastIndexBy,exports.splice=St.splice,exports.split=Ct.split,exports.splitAt=wt.splitAt,exports.splitWhen=Tt.splitWhen,exports.startsWith=Et.startsWith,exports.stringToPath=Dt.stringToPath,exports.subtract=Ot.subtract,exports.sum=Me.sum,exports.sumBy=kt.sumBy,exports.swapIndices=At.swapIndices,exports.swapProps=jt.swapProps,exports.take=Mt.take,exports.takeFirstBy=Nt.takeFirstBy,exports.takeLast=Pt.takeLast,exports.takeLastWhile=Ft.takeLastWhile,exports.takeWhile=It.takeWhile,exports.tap=Lt.tap,exports.times=Rt.times,exports.toCamelCase=zt.toCamelCase,exports.toKebabCase=Bt.toKebabCase,exports.toLowerCase=Vt.toLowerCase,exports.toSnakeCase=Ht.toSnakeCase,exports.toTitleCase=Ut.toTitleCase,exports.toUpperCase=Wt.toUpperCase,exports.truncate=Gt.truncate,exports.uncapitalize=Kt.uncapitalize,exports.unique=qt.unique,exports.uniqueBy=Jt.uniqueBy,exports.uniqueWith=Yt.uniqueWith,exports.values=Xt.values,exports.when=Zt.when,exports.zip=Qt.zip,exports.zipWith=$t.zipWith;