@vinicunca/perkakas 1.15.0 → 1.16.0

package/dist/unique-with.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"unique-with.cjs","names":["curryFromLazy","SKIP_ITEM"],"sources":["../src/unique-with.ts"],"sourcesContent":["import type { Deduped } from './internal/types/deduped';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\ntype IsEquals<T> = (a: T, b: T) => boolean;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by custom comparator isEquals.\n *\n * @param data - The array to filter.\n * @param isEquals - The comparator.\n * @signature\n *    uniqueWith(array, isEquals)\n * @example\n *    uniqueWith(\n *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}],\n *      equals,\n *    ) // => [{a: 1}, {a: 2}, {a: 5}, {a: 6}, {a: 7}]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function uniqueWith<T extends IterableContainer>(\n  data: T,\n  isEquals: IsEquals<T[number]>,\n): Deduped<T>;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by custom comparator isEquals.\n *\n * @param isEquals - The comparator.\n * @signature uniqueWith(isEquals)(array)\n * @example\n *    uniqueWith(equals)(\n *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}],\n *    ) // => [{a: 1}, {a: 2}, {a: 5}, {a: 6}, {a: 7}]\n *    pipe(\n *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}], // only 4 iterations\n *      uniqueWith(equals),\n *      take(3)\n *    ) // => [{a: 1}, {a: 2}, {a: 5}]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function uniqueWith<T extends IterableContainer>(\n  isEquals: IsEquals<T[number]>,\n): (data: T) => Deduped<T>;\n\nexport function uniqueWith(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(isEquals: IsEquals<T>): LazyEvaluator<T> {\n  return (value, index, data) => {\n    const firstEqualIndex = data.findIndex(\n      (otherValue, otherIndex) =>\n        index === otherIndex || isEquals(value, otherValue),\n    );\n\n    // skip items that aren't at the first equal index.\n    return firstEqualIndex === index\n      ? { done: false, hasNext: true, next: value }\n      : SKIP_ITEM;\n  };\n}\n"],"mappings":"oKAqDA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAOA,EAAAA,EAAc,EAAoB,EAAK,CAGhD,SAAS,EAAsB,EAAyC,CACtE,OAAQ,EAAO,EAAO,IACI,EAAK,WAC1B,EAAY,IACX,IAAU,GAAc,EAAS,EAAO,EAAW,CACtD,GAG0B,EACvB,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO,CAC3CC,EAAAA"}
+{"version":3,"file":"unique-with.cjs","names":["curryFromLazy","SKIP_ITEM"],"sources":["../src/unique-with.ts"],"sourcesContent":["import type { Deduped } from './internal/types/deduped';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\ntype IsEquals<T> = (a: T, b: T) => boolean;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by custom comparator isEquals.\n *\n * @param data - The array to filter.\n * @param isEquals - The comparator.\n * @signature\n *    uniqueWith(array, isEquals)\n * @example\n *    uniqueWith(\n *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}],\n *      equals,\n *    ) // => [{a: 1}, {a: 2}, {a: 5}, {a: 6}, {a: 7}]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function uniqueWith<T extends IterableContainer>(\n  data: T,\n  isEquals: IsEquals<T[number]>,\n): Deduped<T>;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by custom comparator isEquals.\n *\n * @param isEquals - The comparator.\n * @signature uniqueWith(isEquals)(array)\n * @example\n *    uniqueWith(equals)(\n *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}],\n *    ) // => [{a: 1}, {a: 2}, {a: 5}, {a: 6}, {a: 7}]\n *    pipe(\n *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}], // only 4 iterations\n *      uniqueWith(equals),\n *      take(3)\n *    ) // => [{a: 1}, {a: 2}, {a: 5}]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function uniqueWith<T extends IterableContainer>(\n  isEquals: IsEquals<T[number]>,\n): (data: T) => Deduped<T>;\n\nexport function uniqueWith(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(isEquals: IsEquals<T>): LazyEvaluator<T> {\n  return (value, index, data) => {\n    const firstEqualIndex = data.findIndex(\n      (otherValue, otherIndex) =>\n        index === otherIndex || isEquals(value, otherValue),\n    );\n\n    // skip items that aren't at the first equal index.\n    return firstEqualIndex === index\n      ? { done: false, hasNext: true, next: value }\n      : SKIP_ITEM;\n  };\n}\n"],"mappings":"oKAqDA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAOA,EAAAA,EAAc,EAAoB,CAAI,CAC/C,CAEA,SAAS,EAAsB,EAAyC,CACtE,OAAQ,EAAO,EAAO,IACI,EAAK,WAC1B,EAAY,IACX,IAAU,GAAc,EAAS,EAAO,CAAU,CAIjC,IAAM,EACvB,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,CAAM,EAC1CC,EAAAA,CAER"}

package/dist/unique-with.js

@@ -1,2 +1,2 @@
-import{t as e}from"./utility-evaluators-ZAaUtL2Z.js";import{t}from"./curry-from-lazy-CtH1dp14.js";function n(...e){return t(r,e)}function r(t){return(n,r,i)=>i.findIndex((e,i)=>r===i||t(n,e))===r?{done:!1,hasNext:!0,next:n}:e}export{n as uniqueWith};
+import{t as e}from"./utility-evaluators-DDW55xeL.js";import{t}from"./curry-from-lazy-BoPMn2L_.js";function n(...e){return t(r,e)}function r(t){return(n,r,i)=>i.findIndex((e,i)=>r===i||t(n,e))===r?{done:!1,hasNext:!0,next:n}:e}export{n as uniqueWith};
 //# sourceMappingURL=unique-with.js.map

package/dist/unique-with.js.map

@@ -1 +1 @@
-{"version":3,"file":"unique-with.js","names":[],"sources":["../src/unique-with.ts"],"sourcesContent":["import type { Deduped } from './internal/types/deduped';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\ntype IsEquals<T> = (a: T, b: T) => boolean;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by custom comparator isEquals.\n *\n * @param data - The array to filter.\n * @param isEquals - The comparator.\n * @signature\n *    uniqueWith(array, isEquals)\n * @example\n *    uniqueWith(\n *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}],\n *      equals,\n *    ) // => [{a: 1}, {a: 2}, {a: 5}, {a: 6}, {a: 7}]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function uniqueWith<T extends IterableContainer>(\n  data: T,\n  isEquals: IsEquals<T[number]>,\n): Deduped<T>;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by custom comparator isEquals.\n *\n * @param isEquals - The comparator.\n * @signature uniqueWith(isEquals)(array)\n * @example\n *    uniqueWith(equals)(\n *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}],\n *    ) // => [{a: 1}, {a: 2}, {a: 5}, {a: 6}, {a: 7}]\n *    pipe(\n *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}], // only 4 iterations\n *      uniqueWith(equals),\n *      take(3)\n *    ) // => [{a: 1}, {a: 2}, {a: 5}]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function uniqueWith<T extends IterableContainer>(\n  isEquals: IsEquals<T[number]>,\n): (data: T) => Deduped<T>;\n\nexport function uniqueWith(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(isEquals: IsEquals<T>): LazyEvaluator<T> {\n  return (value, index, data) => {\n    const firstEqualIndex = data.findIndex(\n      (otherValue, otherIndex) =>\n        index === otherIndex || isEquals(value, otherValue),\n    );\n\n    // skip items that aren't at the first equal index.\n    return firstEqualIndex === index\n      ? { done: false, hasNext: true, next: value }\n      : SKIP_ITEM;\n  };\n}\n"],"mappings":"kGAqDA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAO,EAAc,EAAoB,EAAK,CAGhD,SAAS,EAAsB,EAAyC,CACtE,OAAQ,EAAO,EAAO,IACI,EAAK,WAC1B,EAAY,IACX,IAAU,GAAc,EAAS,EAAO,EAAW,CACtD,GAG0B,EACvB,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO,CAC3C"}
+{"version":3,"file":"unique-with.js","names":[],"sources":["../src/unique-with.ts"],"sourcesContent":["import type { Deduped } from './internal/types/deduped';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\ntype IsEquals<T> = (a: T, b: T) => boolean;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by custom comparator isEquals.\n *\n * @param data - The array to filter.\n * @param isEquals - The comparator.\n * @signature\n *    uniqueWith(array, isEquals)\n * @example\n *    uniqueWith(\n *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}],\n *      equals,\n *    ) // => [{a: 1}, {a: 2}, {a: 5}, {a: 6}, {a: 7}]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function uniqueWith<T extends IterableContainer>(\n  data: T,\n  isEquals: IsEquals<T[number]>,\n): Deduped<T>;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by custom comparator isEquals.\n *\n * @param isEquals - The comparator.\n * @signature uniqueWith(isEquals)(array)\n * @example\n *    uniqueWith(equals)(\n *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}],\n *    ) // => [{a: 1}, {a: 2}, {a: 5}, {a: 6}, {a: 7}]\n *    pipe(\n *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}], // only 4 iterations\n *      uniqueWith(equals),\n *      take(3)\n *    ) // => [{a: 1}, {a: 2}, {a: 5}]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function uniqueWith<T extends IterableContainer>(\n  isEquals: IsEquals<T[number]>,\n): (data: T) => Deduped<T>;\n\nexport function uniqueWith(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(isEquals: IsEquals<T>): LazyEvaluator<T> {\n  return (value, index, data) => {\n    const firstEqualIndex = data.findIndex(\n      (otherValue, otherIndex) =>\n        index === otherIndex || isEquals(value, otherValue),\n    );\n\n    // skip items that aren't at the first equal index.\n    return firstEqualIndex === index\n      ? { done: false, hasNext: true, next: value }\n      : SKIP_ITEM;\n  };\n}\n"],"mappings":"kGAqDA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAO,EAAc,EAAoB,CAAI,CAC/C,CAEA,SAAS,EAAsB,EAAyC,CACtE,OAAQ,EAAO,EAAO,IACI,EAAK,WAC1B,EAAY,IACX,IAAU,GAAc,EAAS,EAAO,CAAU,CAIjC,IAAM,EACvB,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,CAAM,EAC1C,CAER"}

package/dist/unique.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./utility-evaluators-C8koSp9T.cjs`),t=require(`./curry-from-lazy-BvN_VKlH.cjs`);function n(...e){return t.t(r,e)}function r(){let t=new Set;return n=>t.has(n)?e.t:(t.add(n),{done:!1,hasNext:!0,next:n})}exports.unique=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./utility-evaluators-BGM19SpK.cjs"),t=require("./curry-from-lazy-mdjeRP1g.cjs");function n(...e){return t.t(r,e)}function r(){let t=new Set;return n=>t.has(n)?e.t:(t.add(n),{done:!1,hasNext:!0,next:n})}exports.unique=n;
 //# sourceMappingURL=unique.cjs.map

package/dist/unique.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"unique.cjs","names":["curryFromLazy","SKIP_ITEM"],"sources":["../src/unique.ts"],"sourcesContent":["import type { Deduped } from './internal/types/deduped';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by reference using Set.\n *\n * @param data - The array to filter.\n * @signature\n *    unique(array)\n * @example\n *    unique([1, 2, 2, 5, 1, 6, 7]) // => [1, 2, 5, 6, 7]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function unique<T extends IterableContainer>(data: T): Deduped<T>;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by reference using Set.\n *\n * @signature\n *    unique()(array)\n * @example\n *    pipe(\n *      [1, 2, 2, 5, 1, 6, 7], // only 4 iterations\n *      unique(),\n *      take(3)\n *    ) // => [1, 2, 5]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function unique(): <T extends IterableContainer>(data: T) => Deduped<T>;\n\nexport function unique(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(): LazyEvaluator<T> {\n  const set = new Set<T>();\n  return (value) => {\n    if (set.has(value)) {\n      return SKIP_ITEM;\n    }\n    set.add(value);\n    return { done: false, hasNext: true, next: value };\n  };\n}\n"],"mappings":"oKAuCA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAOA,EAAAA,EAAc,EAAoB,EAAK,CAGhD,SAAS,GAA0C,CACjD,IAAM,EAAM,IAAI,IAChB,MAAQ,IACF,EAAI,IAAI,EAAM,CACTC,EAAAA,GAET,EAAI,IAAI,EAAM,CACP,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO"}
+{"version":3,"file":"unique.cjs","names":["curryFromLazy","SKIP_ITEM"],"sources":["../src/unique.ts"],"sourcesContent":["import type { Deduped } from './internal/types/deduped';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by reference using Set.\n *\n * @param data - The array to filter.\n * @signature\n *    unique(array)\n * @example\n *    unique([1, 2, 2, 5, 1, 6, 7]) // => [1, 2, 5, 6, 7]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function unique<T extends IterableContainer>(data: T): Deduped<T>;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by reference using Set.\n *\n * @signature\n *    unique()(array)\n * @example\n *    pipe(\n *      [1, 2, 2, 5, 1, 6, 7], // only 4 iterations\n *      unique(),\n *      take(3)\n *    ) // => [1, 2, 5]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function unique(): <T extends IterableContainer>(data: T) => Deduped<T>;\n\nexport function unique(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(): LazyEvaluator<T> {\n  const set = new Set<T>();\n  return (value) => {\n    if (set.has(value)) {\n      return SKIP_ITEM;\n    }\n    set.add(value);\n    return { done: false, hasNext: true, next: value };\n  };\n}\n"],"mappings":"oKAuCA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAOA,EAAAA,EAAc,EAAoB,CAAI,CAC/C,CAEA,SAAS,GAA0C,CACjD,IAAM,EAAM,IAAI,IAChB,MAAQ,IACF,EAAI,IAAI,CAAK,EACRC,EAAAA,GAET,EAAI,IAAI,CAAK,EACN,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,CAAM,EAErD"}

package/dist/unique.js

@@ -1,2 +1,2 @@
-import{t as e}from"./utility-evaluators-ZAaUtL2Z.js";import{t}from"./curry-from-lazy-CtH1dp14.js";function n(...e){return t(r,e)}function r(){let t=new Set;return n=>t.has(n)?e:(t.add(n),{done:!1,hasNext:!0,next:n})}export{n as unique};
+import{t as e}from"./utility-evaluators-DDW55xeL.js";import{t}from"./curry-from-lazy-BoPMn2L_.js";function n(...e){return t(r,e)}function r(){let t=new Set;return n=>t.has(n)?e:(t.add(n),{done:!1,hasNext:!0,next:n})}export{n as unique};
 //# sourceMappingURL=unique.js.map

package/dist/unique.js.map

@@ -1 +1 @@
-{"version":3,"file":"unique.js","names":[],"sources":["../src/unique.ts"],"sourcesContent":["import type { Deduped } from './internal/types/deduped';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by reference using Set.\n *\n * @param data - The array to filter.\n * @signature\n *    unique(array)\n * @example\n *    unique([1, 2, 2, 5, 1, 6, 7]) // => [1, 2, 5, 6, 7]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function unique<T extends IterableContainer>(data: T): Deduped<T>;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by reference using Set.\n *\n * @signature\n *    unique()(array)\n * @example\n *    pipe(\n *      [1, 2, 2, 5, 1, 6, 7], // only 4 iterations\n *      unique(),\n *      take(3)\n *    ) // => [1, 2, 5]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function unique(): <T extends IterableContainer>(data: T) => Deduped<T>;\n\nexport function unique(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(): LazyEvaluator<T> {\n  const set = new Set<T>();\n  return (value) => {\n    if (set.has(value)) {\n      return SKIP_ITEM;\n    }\n    set.add(value);\n    return { done: false, hasNext: true, next: value };\n  };\n}\n"],"mappings":"kGAuCA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAc,EAAoB,EAAK,CAGhD,SAAS,GAA0C,CACjD,IAAM,EAAM,IAAI,IAChB,MAAQ,IACF,EAAI,IAAI,EAAM,CACT,GAET,EAAI,IAAI,EAAM,CACP,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO"}
+{"version":3,"file":"unique.js","names":[],"sources":["../src/unique.ts"],"sourcesContent":["import type { Deduped } from './internal/types/deduped';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by reference using Set.\n *\n * @param data - The array to filter.\n * @signature\n *    unique(array)\n * @example\n *    unique([1, 2, 2, 5, 1, 6, 7]) // => [1, 2, 5, 6, 7]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function unique<T extends IterableContainer>(data: T): Deduped<T>;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by reference using Set.\n *\n * @signature\n *    unique()(array)\n * @example\n *    pipe(\n *      [1, 2, 2, 5, 1, 6, 7], // only 4 iterations\n *      unique(),\n *      take(3)\n *    ) // => [1, 2, 5]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function unique(): <T extends IterableContainer>(data: T) => Deduped<T>;\n\nexport function unique(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(): LazyEvaluator<T> {\n  const set = new Set<T>();\n  return (value) => {\n    if (set.has(value)) {\n      return SKIP_ITEM;\n    }\n    set.add(value);\n    return { done: false, hasNext: true, next: value };\n  };\n}\n"],"mappings":"kGAuCA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAc,EAAoB,CAAI,CAC/C,CAEA,SAAS,GAA0C,CACjD,IAAM,EAAM,IAAI,IAChB,MAAQ,IACF,EAAI,IAAI,CAAK,EACR,GAET,EAAI,IAAI,CAAK,EACN,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,CAAM,EAErD"}

package/dist/utility-evaluators-BGM19SpK.cjs

@@ -0,0 +1,2 @@
+const e={done:!0,hasNext:!1},t={done:!1,hasNext:!1},n=()=>e;function r(e){return{hasNext:!0,next:e,done:!1}}Object.defineProperty(exports,"n",{enumerable:!0,get:function(){return n}}),Object.defineProperty(exports,"r",{enumerable:!0,get:function(){return r}}),Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=utility-evaluators-BGM19SpK.cjs.map

package/dist/{utility-evaluators-C8koSp9T.cjs.map → utility-evaluators-BGM19SpK.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"utility-evaluators-C8koSp9T.cjs","names":[],"sources":["../src/internal/utility-evaluators.ts"],"sourcesContent":["import type { LazyResult } from './types/lazy-result';\n\nconst EMPTY_PIPE = { done: true, hasNext: false } as const;\n\n/**\n * A singleton value for skipping an item in a lazy evaluator.\n */\nexport const SKIP_ITEM = { done: false, hasNext: false } as const;\n\n/**\n * A helper evaluator when we want to return an empty result. It memoizes both\n * the result and the evaluator itself to reduce memory usage.\n */\nexport const lazyEmptyEvaluator = <T>(): LazyResult<T> => EMPTY_PIPE;\n\n/**\n * A helper evaluator when we want to return a shallow clone of the input. It\n * memoizes both the evaluator itself to reduce memory usage.\n */\n// eslint-disable-next-line ts/explicit-function-return-type\nexport function lazyIdentityEvaluator<T>(value: T) {\n  return ({\n    hasNext: true,\n    next: value,\n    done: false,\n  }) as const;\n}\n"],"mappings":"AAEA,MAAM,EAAa,CAAE,KAAM,GAAM,QAAS,GAAO,CAKpC,EAAY,CAAE,KAAM,GAAO,QAAS,GAAO,CAM3C,MAA6C,EAO1D,SAAgB,EAAyB,EAAU,CACjD,MAAQ,CACN,QAAS,GACT,KAAM,EACN,KAAM,GACP"}
+{"version":3,"file":"utility-evaluators-BGM19SpK.cjs","names":[],"sources":["../src/internal/utility-evaluators.ts"],"sourcesContent":["import type { LazyResult } from './types/lazy-result';\n\nconst EMPTY_PIPE = { done: true, hasNext: false } as const;\n\n/**\n * A singleton value for skipping an item in a lazy evaluator.\n */\nexport const SKIP_ITEM = { done: false, hasNext: false } as const;\n\n/**\n * A helper evaluator when we want to return an empty result. It memoizes both\n * the result and the evaluator itself to reduce memory usage.\n */\nexport const lazyEmptyEvaluator = <T>(): LazyResult<T> => EMPTY_PIPE;\n\n/**\n * A helper evaluator when we want to return a shallow clone of the input. It\n * memoizes both the evaluator itself to reduce memory usage.\n */\n// eslint-disable-next-line ts/explicit-function-return-type\nexport function lazyIdentityEvaluator<T>(value: T) {\n  return ({\n    hasNext: true,\n    next: value,\n    done: false,\n  }) as const;\n}\n"],"mappings":"AAEA,MAAM,EAAa,CAAE,KAAM,GAAM,QAAS,EAAM,EAKnC,EAAY,CAAE,KAAM,GAAO,QAAS,EAAM,EAM1C,MAA6C,EAO1D,SAAgB,EAAyB,EAAU,CACjD,MAAQ,CACN,QAAS,GACT,KAAM,EACN,KAAM,EACR,CACF"}

package/dist/{utility-evaluators-ZAaUtL2Z.js → utility-evaluators-DDW55xeL.js}

@@ -1,2 +1,2 @@
 const e={done:!0,hasNext:!1},t={done:!1,hasNext:!1},n=()=>e;function r(e){return{hasNext:!0,next:e,done:!1}}export{n,r,t};
-//# sourceMappingURL=utility-evaluators-ZAaUtL2Z.js.map
+//# sourceMappingURL=utility-evaluators-DDW55xeL.js.map

package/dist/{utility-evaluators-ZAaUtL2Z.js.map → utility-evaluators-DDW55xeL.js.map}

@@ -1 +1 @@
-{"version":3,"file":"utility-evaluators-ZAaUtL2Z.js","names":[],"sources":["../src/internal/utility-evaluators.ts"],"sourcesContent":["import type { LazyResult } from './types/lazy-result';\n\nconst EMPTY_PIPE = { done: true, hasNext: false } as const;\n\n/**\n * A singleton value for skipping an item in a lazy evaluator.\n */\nexport const SKIP_ITEM = { done: false, hasNext: false } as const;\n\n/**\n * A helper evaluator when we want to return an empty result. It memoizes both\n * the result and the evaluator itself to reduce memory usage.\n */\nexport const lazyEmptyEvaluator = <T>(): LazyResult<T> => EMPTY_PIPE;\n\n/**\n * A helper evaluator when we want to return a shallow clone of the input. It\n * memoizes both the evaluator itself to reduce memory usage.\n */\n// eslint-disable-next-line ts/explicit-function-return-type\nexport function lazyIdentityEvaluator<T>(value: T) {\n  return ({\n    hasNext: true,\n    next: value,\n    done: false,\n  }) as const;\n}\n"],"mappings":"AAEA,MAAM,EAAa,CAAE,KAAM,GAAM,QAAS,GAAO,CAKpC,EAAY,CAAE,KAAM,GAAO,QAAS,GAAO,CAM3C,MAA6C,EAO1D,SAAgB,EAAyB,EAAU,CACjD,MAAQ,CACN,QAAS,GACT,KAAM,EACN,KAAM,GACP"}
+{"version":3,"file":"utility-evaluators-DDW55xeL.js","names":[],"sources":["../src/internal/utility-evaluators.ts"],"sourcesContent":["import type { LazyResult } from './types/lazy-result';\n\nconst EMPTY_PIPE = { done: true, hasNext: false } as const;\n\n/**\n * A singleton value for skipping an item in a lazy evaluator.\n */\nexport const SKIP_ITEM = { done: false, hasNext: false } as const;\n\n/**\n * A helper evaluator when we want to return an empty result. It memoizes both\n * the result and the evaluator itself to reduce memory usage.\n */\nexport const lazyEmptyEvaluator = <T>(): LazyResult<T> => EMPTY_PIPE;\n\n/**\n * A helper evaluator when we want to return a shallow clone of the input. It\n * memoizes both the evaluator itself to reduce memory usage.\n */\n// eslint-disable-next-line ts/explicit-function-return-type\nexport function lazyIdentityEvaluator<T>(value: T) {\n  return ({\n    hasNext: true,\n    next: value,\n    done: false,\n  }) as const;\n}\n"],"mappings":"AAEA,MAAM,EAAa,CAAE,KAAM,GAAM,QAAS,EAAM,EAKnC,EAAY,CAAE,KAAM,GAAO,QAAS,EAAM,EAM1C,MAA6C,EAO1D,SAAgB,EAAyB,EAAU,CACjD,MAAQ,CACN,QAAS,GACT,KAAM,EACN,KAAM,EACR,CACF"}

package/dist/values.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(Object.values,t)}exports.values=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs");function t(...t){return e.curry(Object.values,t)}exports.values=t;
 //# sourceMappingURL=values.cjs.map

package/dist/values.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"values.cjs","names":["curry"],"sources":["../src/values.ts"],"sourcesContent":["import type { EnumerableStringKeyedValueOf } from './internal/types/enumerable-string-keyed-value-of';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\ntype Values<T extends object> = T extends IterableContainer\n  ? Array<T[number]>\n  : Array<EnumerableStringKeyedValueOf<T>>;\n\n/**\n * Returns a new array containing the values of the array or object.\n *\n * @param data - Either an array or an object.\n * @signature\n *    values(source)\n * @example\n *    values(['x', 'y', 'z']) // => ['x', 'y', 'z']\n *    values({ a: 'x', b: 'y', c: 'z' }) // => ['x', 'y', 'z']\n * @dataFirst\n * @category Object\n */\nexport function values<T extends object>(data: T): Values<T>;\n\n/**\n * Returns a new array containing the values of the array or object.\n *\n * @signature\n *    values()(source)\n * @example\n *    pipe(['x', 'y', 'z'], values()) // => ['x', 'y', 'z']\n *    pipe({ a: 'x', b: 'y', c: 'z' }, values()) // => ['x', 'y', 'z']\n *    pipe(\n *      { a: 'x', b: 'y', c: 'z' },\n *      values(),\n *      first(),\n *    ) // => 'x'\n * @dataLast\n * @category Object\n */\nexport function values(): <T extends object>(data: T) => Values<T>;\n\nexport function values(...args: ReadonlyArray<unknown>): unknown {\n  return curry(Object.values, args);\n}\n"],"mappings":"kGAwCA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAOA,EAAAA,MAAM,OAAO,OAAQ,EAAK"}
+{"version":3,"file":"values.cjs","names":["curry"],"sources":["../src/values.ts"],"sourcesContent":["import type { EnumerableStringKeyedValueOf } from './internal/types/enumerable-string-keyed-value-of';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\ntype Values<T extends object> = T extends IterableContainer\n  ? Array<T[number]>\n  : Array<EnumerableStringKeyedValueOf<T>>;\n\n/**\n * Returns a new array containing the values of the array or object.\n *\n * @param data - Either an array or an object.\n * @signature\n *    values(source)\n * @example\n *    values(['x', 'y', 'z']) // => ['x', 'y', 'z']\n *    values({ a: 'x', b: 'y', c: 'z' }) // => ['x', 'y', 'z']\n * @dataFirst\n * @category Object\n */\nexport function values<T extends object>(data: T): Values<T>;\n\n/**\n * Returns a new array containing the values of the array or object.\n *\n * @signature\n *    values()(source)\n * @example\n *    pipe(['x', 'y', 'z'], values()) // => ['x', 'y', 'z']\n *    pipe({ a: 'x', b: 'y', c: 'z' }, values()) // => ['x', 'y', 'z']\n *    pipe(\n *      { a: 'x', b: 'y', c: 'z' },\n *      values(),\n *      first(),\n *    ) // => 'x'\n * @dataLast\n * @category Object\n */\nexport function values(): <T extends object>(data: T) => Values<T>;\n\nexport function values(...args: ReadonlyArray<unknown>): unknown {\n  return curry(Object.values, args);\n}\n"],"mappings":"kGAwCA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAOA,EAAAA,MAAM,OAAO,OAAQ,CAAI,CAClC"}

package/dist/values.js.map

@@ -1 +1 @@
-{"version":3,"file":"values.js","names":[],"sources":["../src/values.ts"],"sourcesContent":["import type { EnumerableStringKeyedValueOf } from './internal/types/enumerable-string-keyed-value-of';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\ntype Values<T extends object> = T extends IterableContainer\n  ? Array<T[number]>\n  : Array<EnumerableStringKeyedValueOf<T>>;\n\n/**\n * Returns a new array containing the values of the array or object.\n *\n * @param data - Either an array or an object.\n * @signature\n *    values(source)\n * @example\n *    values(['x', 'y', 'z']) // => ['x', 'y', 'z']\n *    values({ a: 'x', b: 'y', c: 'z' }) // => ['x', 'y', 'z']\n * @dataFirst\n * @category Object\n */\nexport function values<T extends object>(data: T): Values<T>;\n\n/**\n * Returns a new array containing the values of the array or object.\n *\n * @signature\n *    values()(source)\n * @example\n *    pipe(['x', 'y', 'z'], values()) // => ['x', 'y', 'z']\n *    pipe({ a: 'x', b: 'y', c: 'z' }, values()) // => ['x', 'y', 'z']\n *    pipe(\n *      { a: 'x', b: 'y', c: 'z' },\n *      values(),\n *      first(),\n *    ) // => 'x'\n * @dataLast\n * @category Object\n */\nexport function values(): <T extends object>(data: T) => Values<T>;\n\nexport function values(...args: ReadonlyArray<unknown>): unknown {\n  return curry(Object.values, args);\n}\n"],"mappings":"mCAwCA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,OAAO,OAAQ,EAAK"}
+{"version":3,"file":"values.js","names":[],"sources":["../src/values.ts"],"sourcesContent":["import type { EnumerableStringKeyedValueOf } from './internal/types/enumerable-string-keyed-value-of';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\ntype Values<T extends object> = T extends IterableContainer\n  ? Array<T[number]>\n  : Array<EnumerableStringKeyedValueOf<T>>;\n\n/**\n * Returns a new array containing the values of the array or object.\n *\n * @param data - Either an array or an object.\n * @signature\n *    values(source)\n * @example\n *    values(['x', 'y', 'z']) // => ['x', 'y', 'z']\n *    values({ a: 'x', b: 'y', c: 'z' }) // => ['x', 'y', 'z']\n * @dataFirst\n * @category Object\n */\nexport function values<T extends object>(data: T): Values<T>;\n\n/**\n * Returns a new array containing the values of the array or object.\n *\n * @signature\n *    values()(source)\n * @example\n *    pipe(['x', 'y', 'z'], values()) // => ['x', 'y', 'z']\n *    pipe({ a: 'x', b: 'y', c: 'z' }, values()) // => ['x', 'y', 'z']\n *    pipe(\n *      { a: 'x', b: 'y', c: 'z' },\n *      values(),\n *      first(),\n *    ) // => 'x'\n * @dataLast\n * @category Object\n */\nexport function values(): <T extends object>(data: T) => Values<T>;\n\nexport function values(...args: ReadonlyArray<unknown>): unknown {\n  return curry(Object.values, args);\n}\n"],"mappings":"mCAwCA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,OAAO,OAAQ,CAAI,CAClC"}

package/dist/when.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"when.cjs","names":[],"sources":["../src/when.ts"],"sourcesContent":["/* eslint-disable ts/no-explicit-any --\n * function inference is stricter and doesn't work well when the arguments\n * aren't typed as `any` in the generic type declaration.\n */\n\nimport type { GuardType } from './internal/types/guard-type';\n\n/**\n * Conditionally run a function based on a predicate, returning its result (similar to\n * the [`?:` (ternary) operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_operator).)\n * If the optional `onFalse` function is not provided, the data will be passed\n * through in those cases.\n *\n * Supports type predicates to refine the types for both branches and the return\n * value.\n *\n * Additional arguments are passed to all functions. In data-first calls, they\n * are taken as variadic arguments; but in data-last calls, they are when the\n * curried function itself is called.\n *\n * For more complex cases check out `conditional`.\n *\n * @param predicate - Decides if the `onTrue` mapper should run or not. If it's\n * a type predicate it also narrows types for the mappers and the return value.\n * @param onTrue - Function to run when the predicate returns `true`.\n * @signature\n *   when(predicate, onTrue)(data, ...extraArgs)\n *   when(predicate, { onTrue, onFalse })(data, ...extraArgs)\n * @example\n *   pipe(data, when(isNullish, constant(42)));\n *   pipe(data, when((x) => x > 3, { onTrue: add(1), onFalse: multiply(2) }));\n *   map(data, when(isNullish, (x, index) => x + index));\n * @dataLast\n * @category Function\n */\nexport function when<\n  T,\n  ExtraArgs extends Array<any>,\n  Predicate extends (data: T, ...extraArgs: ExtraArgs) => boolean,\n  OnTrue extends (\n    data: GuardType<Predicate, T>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n>(\n  predicate: Predicate,\n  onTrue: OnTrue,\n): (\n  data: T,\n  ...extraArgs: ExtraArgs\n) => Exclude<T, GuardType<Predicate>> | ReturnType<OnTrue>;\nexport function when<\n  T,\n  ExtraArgs extends Array<any>,\n  Predicate extends (data: T, ...extraArgs: ExtraArgs) => boolean,\n  OnTrue extends (\n    data: GuardType<Predicate, T>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n  OnFalse extends (\n    data: Exclude<T, GuardType<Predicate>>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n>(\n  predicate: Predicate,\n  branches: {\n    readonly onTrue: OnTrue;\n    readonly onFalse: OnFalse;\n  },\n): (\n  data: T,\n  ...extraArgs: ExtraArgs\n) => ReturnType<OnFalse> | ReturnType<OnTrue>;\n\n/**\n * Conditionally run a function based on a predicate, returning its result (similar to\n * the [`?:` (ternary) operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_operator).)\n * If the optional `onFalse` function is not provided, the data will be passed\n * through in those cases.\n *\n * Supports type predicates to refine the types for both branches and the return\n * value.\n *\n * Additional arguments are passed to all functions. In data-first calls, they\n * are taken as variadic arguments; but in data-last calls, they are when the\n * curried function itself is called.\n *\n * For more complex cases check out `conditional`.\n *\n * @param data - The data to be passed to all functions, as the first param.\n * @param predicate - Decides if the `onTrue` mapper should run or not. If it's\n * a type predicate it also narrows types for the mappers and the return value.\n * @param onTrue - The function that would run when the predicate returns\n * `true`.\n * @param extraArgs - Additional arguments. These would be passed as is to the\n * `predicate`, `onTrue`, and `onFalse` functions.\n * @signature\n *   when(data, predicate, onTrue, ...extraArgs)\n *   when(data, predicate, { onTrue, onFalse }, ...extraArgs)\n * @example\n *   when(data, isNullish, constant(42));\n *   when(data, (x) => x > 3, { onTrue: add(1), onFalse: multiply(2) });\n *   when(data, isString, (x, radix) => parseInt(x, radix), 10);\n * @dataFirst\n * @category Function\n */\nexport function when<\n  T,\n  ExtraArgs extends Array<any>,\n  Predicate extends (data: T, ...extraArgs: ExtraArgs) => boolean,\n  OnTrue extends (\n    data: GuardType<Predicate, T>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n>(\n  data: T,\n  predicate: Predicate,\n  onTrue: OnTrue,\n  ...extraArgs: ExtraArgs\n): Exclude<T, GuardType<Predicate>> | ReturnType<OnTrue>;\nexport function when<\n  T,\n  ExtraArgs extends Array<any>,\n  Predicate extends (data: T, ...extraArgs: ExtraArgs) => boolean,\n  OnTrue extends (\n    data: GuardType<Predicate, T>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n  OnFalse extends (\n    data: Exclude<T, GuardType<Predicate>>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n>(\n  data: T,\n  predicate: Predicate,\n  branches: {\n    readonly onTrue: OnTrue;\n    readonly onFalse: OnFalse;\n  },\n  ...extraArgs: ExtraArgs\n): ReturnType<OnFalse> | ReturnType<OnTrue>;\n\nexport function when(...args: ReadonlyArray<unknown>): unknown {\n  return args.length === 2\n    ? (data: unknown, ...extraArgs: ReadonlyArray<unknown>) =>\n        // @ts-expect-error [ts2556] -- This is OK, we trust our typing of the overloaded functions\n        whenImplementation(data, ...args, ...extraArgs)\n    : // @ts-expect-error [ts2556] -- This is OK, we trust our typing of the overloaded functions\n      whenImplementation(...args);\n}\n\nfunction whenImplementation<T, ExtraArgs extends Array<any>, WhenTrue, WhenFalse>(data: T, predicate: (data: T, ...extraArgs: ExtraArgs) => boolean, onTrueOrBranches:\n    | ((data: T, ...extraArgs: ExtraArgs) => WhenTrue)\n    | {\n      readonly onTrue: (data: T, ...extraArgs: ExtraArgs) => WhenTrue;\n      readonly onFalse: (data: T, ...extraArgs: ExtraArgs) => WhenFalse;\n    }, ...extraArgs: ExtraArgs): T | WhenFalse | WhenTrue {\n  // eslint-disable-next-line no-nested-ternary\n  return predicate(data, ...extraArgs)\n    ? typeof onTrueOrBranches === 'function'\n      ? onTrueOrBranches(data, ...extraArgs)\n      : onTrueOrBranches.onTrue(data, ...extraArgs)\n    : typeof onTrueOrBranches === 'function'\n      ? data\n      : onTrueOrBranches.onFalse(data, ...extraArgs);\n}\n"],"mappings":"mEA6IA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAK,SAAW,GAClB,EAAe,GAAG,IAEjB,EAAmB,EAAM,GAAG,EAAM,GAAG,EAAU,CAEjD,EAAmB,GAAG,EAAK,CAGjC,SAAS,EAAyE,EAAS,EAA0D,EAK9I,GAAG,EAAgD,CAExD,OAAO,EAAU,EAAM,GAAG,EAAU,CAChC,OAAO,GAAqB,WAC1B,EAAiB,EAAM,GAAG,EAAU,CACpC,EAAiB,OAAO,EAAM,GAAG,EAAU,CAC7C,OAAO,GAAqB,WAC1B,EACA,EAAiB,QAAQ,EAAM,GAAG,EAAU"}
+{"version":3,"file":"when.cjs","names":[],"sources":["../src/when.ts"],"sourcesContent":["/* eslint-disable ts/no-explicit-any --\n * function inference is stricter and doesn't work well when the arguments\n * aren't typed as `any` in the generic type declaration.\n */\n\nimport type { GuardType } from './internal/types/guard-type';\n\n/**\n * Conditionally run a function based on a predicate, returning its result (similar to\n * the [`?:` (ternary) operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_operator).)\n * If the optional `onFalse` function is not provided, the data will be passed\n * through in those cases.\n *\n * Supports type predicates to refine the types for both branches and the return\n * value.\n *\n * Additional arguments are passed to all functions. In data-first calls, they\n * are taken as variadic arguments; but in data-last calls, they are when the\n * curried function itself is called.\n *\n * For more complex cases check out `conditional`.\n *\n * @param predicate - Decides if the `onTrue` mapper should run or not. If it's\n * a type predicate it also narrows types for the mappers and the return value.\n * @param onTrue - Function to run when the predicate returns `true`.\n * @signature\n *   when(predicate, onTrue)(data, ...extraArgs)\n *   when(predicate, { onTrue, onFalse })(data, ...extraArgs)\n * @example\n *   pipe(data, when(isNullish, constant(42)));\n *   pipe(data, when((x) => x > 3, { onTrue: add(1), onFalse: multiply(2) }));\n *   map(data, when(isNullish, (x, index) => x + index));\n * @dataLast\n * @category Function\n */\nexport function when<\n  T,\n  ExtraArgs extends Array<any>,\n  Predicate extends (data: T, ...extraArgs: ExtraArgs) => boolean,\n  OnTrue extends (\n    data: GuardType<Predicate, T>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n>(\n  predicate: Predicate,\n  onTrue: OnTrue,\n): (\n  data: T,\n  ...extraArgs: ExtraArgs\n) => Exclude<T, GuardType<Predicate>> | ReturnType<OnTrue>;\nexport function when<\n  T,\n  ExtraArgs extends Array<any>,\n  Predicate extends (data: T, ...extraArgs: ExtraArgs) => boolean,\n  OnTrue extends (\n    data: GuardType<Predicate, T>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n  OnFalse extends (\n    data: Exclude<T, GuardType<Predicate>>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n>(\n  predicate: Predicate,\n  branches: {\n    readonly onTrue: OnTrue;\n    readonly onFalse: OnFalse;\n  },\n): (\n  data: T,\n  ...extraArgs: ExtraArgs\n) => ReturnType<OnFalse> | ReturnType<OnTrue>;\n\n/**\n * Conditionally run a function based on a predicate, returning its result (similar to\n * the [`?:` (ternary) operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_operator).)\n * If the optional `onFalse` function is not provided, the data will be passed\n * through in those cases.\n *\n * Supports type predicates to refine the types for both branches and the return\n * value.\n *\n * Additional arguments are passed to all functions. In data-first calls, they\n * are taken as variadic arguments; but in data-last calls, they are when the\n * curried function itself is called.\n *\n * For more complex cases check out `conditional`.\n *\n * @param data - The data to be passed to all functions, as the first param.\n * @param predicate - Decides if the `onTrue` mapper should run or not. If it's\n * a type predicate it also narrows types for the mappers and the return value.\n * @param onTrue - The function that would run when the predicate returns\n * `true`.\n * @param extraArgs - Additional arguments. These would be passed as is to the\n * `predicate`, `onTrue`, and `onFalse` functions.\n * @signature\n *   when(data, predicate, onTrue, ...extraArgs)\n *   when(data, predicate, { onTrue, onFalse }, ...extraArgs)\n * @example\n *   when(data, isNullish, constant(42));\n *   when(data, (x) => x > 3, { onTrue: add(1), onFalse: multiply(2) });\n *   when(data, isString, (x, radix) => parseInt(x, radix), 10);\n * @dataFirst\n * @category Function\n */\nexport function when<\n  T,\n  ExtraArgs extends Array<any>,\n  Predicate extends (data: T, ...extraArgs: ExtraArgs) => boolean,\n  OnTrue extends (\n    data: GuardType<Predicate, T>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n>(\n  data: T,\n  predicate: Predicate,\n  onTrue: OnTrue,\n  ...extraArgs: ExtraArgs\n): Exclude<T, GuardType<Predicate>> | ReturnType<OnTrue>;\nexport function when<\n  T,\n  ExtraArgs extends Array<any>,\n  Predicate extends (data: T, ...extraArgs: ExtraArgs) => boolean,\n  OnTrue extends (\n    data: GuardType<Predicate, T>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n  OnFalse extends (\n    data: Exclude<T, GuardType<Predicate>>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n>(\n  data: T,\n  predicate: Predicate,\n  branches: {\n    readonly onTrue: OnTrue;\n    readonly onFalse: OnFalse;\n  },\n  ...extraArgs: ExtraArgs\n): ReturnType<OnFalse> | ReturnType<OnTrue>;\n\nexport function when(...args: ReadonlyArray<unknown>): unknown {\n  return args.length === 2\n    ? (data: unknown, ...extraArgs: ReadonlyArray<unknown>) =>\n        // @ts-expect-error [ts2556] -- This is OK, we trust our typing of the overloaded functions\n        whenImplementation(data, ...args, ...extraArgs)\n    : // @ts-expect-error [ts2556] -- This is OK, we trust our typing of the overloaded functions\n      whenImplementation(...args);\n}\n\nfunction whenImplementation<T, ExtraArgs extends Array<any>, WhenTrue, WhenFalse>(data: T, predicate: (data: T, ...extraArgs: ExtraArgs) => boolean, onTrueOrBranches:\n    | ((data: T, ...extraArgs: ExtraArgs) => WhenTrue)\n    | {\n      readonly onTrue: (data: T, ...extraArgs: ExtraArgs) => WhenTrue;\n      readonly onFalse: (data: T, ...extraArgs: ExtraArgs) => WhenFalse;\n    }, ...extraArgs: ExtraArgs): T | WhenFalse | WhenTrue {\n  // eslint-disable-next-line no-nested-ternary\n  return predicate(data, ...extraArgs)\n    ? typeof onTrueOrBranches === 'function'\n      ? onTrueOrBranches(data, ...extraArgs)\n      : onTrueOrBranches.onTrue(data, ...extraArgs)\n    : typeof onTrueOrBranches === 'function'\n      ? data\n      : onTrueOrBranches.onFalse(data, ...extraArgs);\n}\n"],"mappings":"mEA6IA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAK,SAAW,GAClB,EAAe,GAAG,IAEjB,EAAmB,EAAM,GAAG,EAAM,GAAG,CAAS,EAEhD,EAAmB,GAAG,CAAI,CAChC,CAEA,SAAS,EAAyE,EAAS,EAA0D,EAK9I,GAAG,EAAgD,CAExD,OAAO,EAAU,EAAM,GAAG,CAAS,EAC/B,OAAO,GAAqB,WAC1B,EAAiB,EAAM,GAAG,CAAS,EACnC,EAAiB,OAAO,EAAM,GAAG,CAAS,EAC5C,OAAO,GAAqB,WAC1B,EACA,EAAiB,QAAQ,EAAM,GAAG,CAAS,CACnD"}

package/dist/when.js.map

@@ -1 +1 @@
-{"version":3,"file":"when.js","names":[],"sources":["../src/when.ts"],"sourcesContent":["/* eslint-disable ts/no-explicit-any --\n * function inference is stricter and doesn't work well when the arguments\n * aren't typed as `any` in the generic type declaration.\n */\n\nimport type { GuardType } from './internal/types/guard-type';\n\n/**\n * Conditionally run a function based on a predicate, returning its result (similar to\n * the [`?:` (ternary) operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_operator).)\n * If the optional `onFalse` function is not provided, the data will be passed\n * through in those cases.\n *\n * Supports type predicates to refine the types for both branches and the return\n * value.\n *\n * Additional arguments are passed to all functions. In data-first calls, they\n * are taken as variadic arguments; but in data-last calls, they are when the\n * curried function itself is called.\n *\n * For more complex cases check out `conditional`.\n *\n * @param predicate - Decides if the `onTrue` mapper should run or not. If it's\n * a type predicate it also narrows types for the mappers and the return value.\n * @param onTrue - Function to run when the predicate returns `true`.\n * @signature\n *   when(predicate, onTrue)(data, ...extraArgs)\n *   when(predicate, { onTrue, onFalse })(data, ...extraArgs)\n * @example\n *   pipe(data, when(isNullish, constant(42)));\n *   pipe(data, when((x) => x > 3, { onTrue: add(1), onFalse: multiply(2) }));\n *   map(data, when(isNullish, (x, index) => x + index));\n * @dataLast\n * @category Function\n */\nexport function when<\n  T,\n  ExtraArgs extends Array<any>,\n  Predicate extends (data: T, ...extraArgs: ExtraArgs) => boolean,\n  OnTrue extends (\n    data: GuardType<Predicate, T>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n>(\n  predicate: Predicate,\n  onTrue: OnTrue,\n): (\n  data: T,\n  ...extraArgs: ExtraArgs\n) => Exclude<T, GuardType<Predicate>> | ReturnType<OnTrue>;\nexport function when<\n  T,\n  ExtraArgs extends Array<any>,\n  Predicate extends (data: T, ...extraArgs: ExtraArgs) => boolean,\n  OnTrue extends (\n    data: GuardType<Predicate, T>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n  OnFalse extends (\n    data: Exclude<T, GuardType<Predicate>>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n>(\n  predicate: Predicate,\n  branches: {\n    readonly onTrue: OnTrue;\n    readonly onFalse: OnFalse;\n  },\n): (\n  data: T,\n  ...extraArgs: ExtraArgs\n) => ReturnType<OnFalse> | ReturnType<OnTrue>;\n\n/**\n * Conditionally run a function based on a predicate, returning its result (similar to\n * the [`?:` (ternary) operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_operator).)\n * If the optional `onFalse` function is not provided, the data will be passed\n * through in those cases.\n *\n * Supports type predicates to refine the types for both branches and the return\n * value.\n *\n * Additional arguments are passed to all functions. In data-first calls, they\n * are taken as variadic arguments; but in data-last calls, they are when the\n * curried function itself is called.\n *\n * For more complex cases check out `conditional`.\n *\n * @param data - The data to be passed to all functions, as the first param.\n * @param predicate - Decides if the `onTrue` mapper should run or not. If it's\n * a type predicate it also narrows types for the mappers and the return value.\n * @param onTrue - The function that would run when the predicate returns\n * `true`.\n * @param extraArgs - Additional arguments. These would be passed as is to the\n * `predicate`, `onTrue`, and `onFalse` functions.\n * @signature\n *   when(data, predicate, onTrue, ...extraArgs)\n *   when(data, predicate, { onTrue, onFalse }, ...extraArgs)\n * @example\n *   when(data, isNullish, constant(42));\n *   when(data, (x) => x > 3, { onTrue: add(1), onFalse: multiply(2) });\n *   when(data, isString, (x, radix) => parseInt(x, radix), 10);\n * @dataFirst\n * @category Function\n */\nexport function when<\n  T,\n  ExtraArgs extends Array<any>,\n  Predicate extends (data: T, ...extraArgs: ExtraArgs) => boolean,\n  OnTrue extends (\n    data: GuardType<Predicate, T>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n>(\n  data: T,\n  predicate: Predicate,\n  onTrue: OnTrue,\n  ...extraArgs: ExtraArgs\n): Exclude<T, GuardType<Predicate>> | ReturnType<OnTrue>;\nexport function when<\n  T,\n  ExtraArgs extends Array<any>,\n  Predicate extends (data: T, ...extraArgs: ExtraArgs) => boolean,\n  OnTrue extends (\n    data: GuardType<Predicate, T>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n  OnFalse extends (\n    data: Exclude<T, GuardType<Predicate>>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n>(\n  data: T,\n  predicate: Predicate,\n  branches: {\n    readonly onTrue: OnTrue;\n    readonly onFalse: OnFalse;\n  },\n  ...extraArgs: ExtraArgs\n): ReturnType<OnFalse> | ReturnType<OnTrue>;\n\nexport function when(...args: ReadonlyArray<unknown>): unknown {\n  return args.length === 2\n    ? (data: unknown, ...extraArgs: ReadonlyArray<unknown>) =>\n        // @ts-expect-error [ts2556] -- This is OK, we trust our typing of the overloaded functions\n        whenImplementation(data, ...args, ...extraArgs)\n    : // @ts-expect-error [ts2556] -- This is OK, we trust our typing of the overloaded functions\n      whenImplementation(...args);\n}\n\nfunction whenImplementation<T, ExtraArgs extends Array<any>, WhenTrue, WhenFalse>(data: T, predicate: (data: T, ...extraArgs: ExtraArgs) => boolean, onTrueOrBranches:\n    | ((data: T, ...extraArgs: ExtraArgs) => WhenTrue)\n    | {\n      readonly onTrue: (data: T, ...extraArgs: ExtraArgs) => WhenTrue;\n      readonly onFalse: (data: T, ...extraArgs: ExtraArgs) => WhenFalse;\n    }, ...extraArgs: ExtraArgs): T | WhenFalse | WhenTrue {\n  // eslint-disable-next-line no-nested-ternary\n  return predicate(data, ...extraArgs)\n    ? typeof onTrueOrBranches === 'function'\n      ? onTrueOrBranches(data, ...extraArgs)\n      : onTrueOrBranches.onTrue(data, ...extraArgs)\n    : typeof onTrueOrBranches === 'function'\n      ? data\n      : onTrueOrBranches.onFalse(data, ...extraArgs);\n}\n"],"mappings":"AA6IA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAK,SAAW,GAClB,EAAe,GAAG,IAEjB,EAAmB,EAAM,GAAG,EAAM,GAAG,EAAU,CAEjD,EAAmB,GAAG,EAAK,CAGjC,SAAS,EAAyE,EAAS,EAA0D,EAK9I,GAAG,EAAgD,CAExD,OAAO,EAAU,EAAM,GAAG,EAAU,CAChC,OAAO,GAAqB,WAC1B,EAAiB,EAAM,GAAG,EAAU,CACpC,EAAiB,OAAO,EAAM,GAAG,EAAU,CAC7C,OAAO,GAAqB,WAC1B,EACA,EAAiB,QAAQ,EAAM,GAAG,EAAU"}
+{"version":3,"file":"when.js","names":[],"sources":["../src/when.ts"],"sourcesContent":["/* eslint-disable ts/no-explicit-any --\n * function inference is stricter and doesn't work well when the arguments\n * aren't typed as `any` in the generic type declaration.\n */\n\nimport type { GuardType } from './internal/types/guard-type';\n\n/**\n * Conditionally run a function based on a predicate, returning its result (similar to\n * the [`?:` (ternary) operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_operator).)\n * If the optional `onFalse` function is not provided, the data will be passed\n * through in those cases.\n *\n * Supports type predicates to refine the types for both branches and the return\n * value.\n *\n * Additional arguments are passed to all functions. In data-first calls, they\n * are taken as variadic arguments; but in data-last calls, they are when the\n * curried function itself is called.\n *\n * For more complex cases check out `conditional`.\n *\n * @param predicate - Decides if the `onTrue` mapper should run or not. If it's\n * a type predicate it also narrows types for the mappers and the return value.\n * @param onTrue - Function to run when the predicate returns `true`.\n * @signature\n *   when(predicate, onTrue)(data, ...extraArgs)\n *   when(predicate, { onTrue, onFalse })(data, ...extraArgs)\n * @example\n *   pipe(data, when(isNullish, constant(42)));\n *   pipe(data, when((x) => x > 3, { onTrue: add(1), onFalse: multiply(2) }));\n *   map(data, when(isNullish, (x, index) => x + index));\n * @dataLast\n * @category Function\n */\nexport function when<\n  T,\n  ExtraArgs extends Array<any>,\n  Predicate extends (data: T, ...extraArgs: ExtraArgs) => boolean,\n  OnTrue extends (\n    data: GuardType<Predicate, T>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n>(\n  predicate: Predicate,\n  onTrue: OnTrue,\n): (\n  data: T,\n  ...extraArgs: ExtraArgs\n) => Exclude<T, GuardType<Predicate>> | ReturnType<OnTrue>;\nexport function when<\n  T,\n  ExtraArgs extends Array<any>,\n  Predicate extends (data: T, ...extraArgs: ExtraArgs) => boolean,\n  OnTrue extends (\n    data: GuardType<Predicate, T>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n  OnFalse extends (\n    data: Exclude<T, GuardType<Predicate>>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n>(\n  predicate: Predicate,\n  branches: {\n    readonly onTrue: OnTrue;\n    readonly onFalse: OnFalse;\n  },\n): (\n  data: T,\n  ...extraArgs: ExtraArgs\n) => ReturnType<OnFalse> | ReturnType<OnTrue>;\n\n/**\n * Conditionally run a function based on a predicate, returning its result (similar to\n * the [`?:` (ternary) operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_operator).)\n * If the optional `onFalse` function is not provided, the data will be passed\n * through in those cases.\n *\n * Supports type predicates to refine the types for both branches and the return\n * value.\n *\n * Additional arguments are passed to all functions. In data-first calls, they\n * are taken as variadic arguments; but in data-last calls, they are when the\n * curried function itself is called.\n *\n * For more complex cases check out `conditional`.\n *\n * @param data - The data to be passed to all functions, as the first param.\n * @param predicate - Decides if the `onTrue` mapper should run or not. If it's\n * a type predicate it also narrows types for the mappers and the return value.\n * @param onTrue - The function that would run when the predicate returns\n * `true`.\n * @param extraArgs - Additional arguments. These would be passed as is to the\n * `predicate`, `onTrue`, and `onFalse` functions.\n * @signature\n *   when(data, predicate, onTrue, ...extraArgs)\n *   when(data, predicate, { onTrue, onFalse }, ...extraArgs)\n * @example\n *   when(data, isNullish, constant(42));\n *   when(data, (x) => x > 3, { onTrue: add(1), onFalse: multiply(2) });\n *   when(data, isString, (x, radix) => parseInt(x, radix), 10);\n * @dataFirst\n * @category Function\n */\nexport function when<\n  T,\n  ExtraArgs extends Array<any>,\n  Predicate extends (data: T, ...extraArgs: ExtraArgs) => boolean,\n  OnTrue extends (\n    data: GuardType<Predicate, T>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n>(\n  data: T,\n  predicate: Predicate,\n  onTrue: OnTrue,\n  ...extraArgs: ExtraArgs\n): Exclude<T, GuardType<Predicate>> | ReturnType<OnTrue>;\nexport function when<\n  T,\n  ExtraArgs extends Array<any>,\n  Predicate extends (data: T, ...extraArgs: ExtraArgs) => boolean,\n  OnTrue extends (\n    data: GuardType<Predicate, T>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n  OnFalse extends (\n    data: Exclude<T, GuardType<Predicate>>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n>(\n  data: T,\n  predicate: Predicate,\n  branches: {\n    readonly onTrue: OnTrue;\n    readonly onFalse: OnFalse;\n  },\n  ...extraArgs: ExtraArgs\n): ReturnType<OnFalse> | ReturnType<OnTrue>;\n\nexport function when(...args: ReadonlyArray<unknown>): unknown {\n  return args.length === 2\n    ? (data: unknown, ...extraArgs: ReadonlyArray<unknown>) =>\n        // @ts-expect-error [ts2556] -- This is OK, we trust our typing of the overloaded functions\n        whenImplementation(data, ...args, ...extraArgs)\n    : // @ts-expect-error [ts2556] -- This is OK, we trust our typing of the overloaded functions\n      whenImplementation(...args);\n}\n\nfunction whenImplementation<T, ExtraArgs extends Array<any>, WhenTrue, WhenFalse>(data: T, predicate: (data: T, ...extraArgs: ExtraArgs) => boolean, onTrueOrBranches:\n    | ((data: T, ...extraArgs: ExtraArgs) => WhenTrue)\n    | {\n      readonly onTrue: (data: T, ...extraArgs: ExtraArgs) => WhenTrue;\n      readonly onFalse: (data: T, ...extraArgs: ExtraArgs) => WhenFalse;\n    }, ...extraArgs: ExtraArgs): T | WhenFalse | WhenTrue {\n  // eslint-disable-next-line no-nested-ternary\n  return predicate(data, ...extraArgs)\n    ? typeof onTrueOrBranches === 'function'\n      ? onTrueOrBranches(data, ...extraArgs)\n      : onTrueOrBranches.onTrue(data, ...extraArgs)\n    : typeof onTrueOrBranches === 'function'\n      ? data\n      : onTrueOrBranches.onFalse(data, ...extraArgs);\n}\n"],"mappings":"AA6IA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAK,SAAW,GAClB,EAAe,GAAG,IAEjB,EAAmB,EAAM,GAAG,EAAM,GAAG,CAAS,EAEhD,EAAmB,GAAG,CAAI,CAChC,CAEA,SAAS,EAAyE,EAAS,EAA0D,EAK9I,GAAG,EAAgD,CAExD,OAAO,EAAU,EAAM,GAAG,CAAS,EAC/B,OAAO,GAAqB,WAC1B,EAAiB,EAAM,GAAG,CAAS,EACnC,EAAiB,OAAO,EAAM,GAAG,CAAS,EAC5C,OAAO,GAAqB,WAC1B,EACA,EAAiB,QAAQ,EAAM,GAAG,CAAS,CACnD"}

package/dist/{with-precision-CgRuf7Wl.js → with-precision-D-84B_By.js}

@@ -1,2 +1,2 @@
 function e(e){return(n,r)=>{if(r===0)return e(n);if(!Number.isInteger(r))throw TypeError(`precision must be an integer: ${r.toString()}`);if(r>15||r<-15)throw RangeError(`precision must be between -15 and 15`);return Number.isNaN(n)||!Number.isFinite(n)?e(n):t(e(t(n,r)),-r)}}function t(e,t){let[n,r]=e.toString().split(`e`),i=`${n}e${((r===void 0?0:Number.parseInt(r,10))+t).toString()}`;return Number.parseFloat(i)}export{e as t};
-//# sourceMappingURL=with-precision-CgRuf7Wl.js.map
+//# sourceMappingURL=with-precision-D-84B_By.js.map

package/dist/{with-precision-CgRuf7Wl.js.map → with-precision-D-84B_By.js.map}

@@ -1 +1 @@
-{"version":3,"file":"with-precision-CgRuf7Wl.js","names":[],"sources":["../src/internal/with-precision.ts"],"sourcesContent":["// ECMAScript doesn't support more decimal places than 15 anyways,\n// so supporting higher values doesn't make a lot of sense,\n// Considering Number.MAX_SAFE_INTEGER < 10**16, we can use -15\n// for the negative precision limit, too.\nconst MAX_PRECISION = 15;\n\nconst RADIX = 10;\n\nexport function withPrecision(roundingFn: (value: number) => number) {\n  return (value: number, precision: number): number => {\n    if (precision === 0) {\n      return roundingFn(value);\n    }\n\n    if (!Number.isInteger(precision)) {\n      throw new TypeError(\n        `precision must be an integer: ${precision.toString()}`,\n      );\n    }\n\n    if (precision > MAX_PRECISION || precision < -MAX_PRECISION) {\n      throw new RangeError('precision must be between -15 and 15');\n    }\n\n    if (Number.isNaN(value) || !Number.isFinite(value)) {\n      return roundingFn(value);\n    }\n\n    const shiftedValue = shiftDecimalPoint(value, precision);\n    const rounded = roundingFn(shiftedValue);\n    return shiftDecimalPoint(rounded, -precision);\n  };\n}\n\n/**\n * Shift a number's decimal point via scientific notation.\n *\n * This takes advantage of the fact that `Number` methods support scientific\n * (e-notation) string natively and avoids working with double-precision\n * floating-point numbers directly, working around their limitations\n * with representing decimal numbers.\n */\nfunction shiftDecimalPoint(value: number, shift: number): number {\n  const asString = value.toString();\n  const [n, exponent] = asString.split('e');\n\n  const shiftedExponent\n    = (exponent === undefined ? 0 : Number.parseInt(exponent, RADIX)) + shift;\n\n  const shiftedValueAsString = `${n!}e${shiftedExponent.toString()}`;\n\n  return Number.parseFloat(shiftedValueAsString);\n}\n"],"mappings":"AAQA,SAAgB,EAAc,EAAuC,CACnE,OAAQ,EAAe,IAA8B,CACnD,GAAI,IAAc,EAChB,OAAO,EAAW,EAAM,CAG1B,GAAI,CAAC,OAAO,UAAU,EAAU,CAC9B,MAAU,UACR,iCAAiC,EAAU,UAAU,GACtD,CAGH,GAAI,EAAY,IAAiB,EAAY,IAC3C,MAAU,WAAW,uCAAuC,CAS9D,OANI,OAAO,MAAM,EAAM,EAAI,CAAC,OAAO,SAAS,EAAM,CACzC,EAAW,EAAM,CAKnB,EADS,EADK,EAAkB,EAAO,EAAU,CAChB,CACN,CAAC,EAAU,EAYjD,SAAS,EAAkB,EAAe,EAAuB,CAE/D,GAAM,CAAC,EAAG,GADO,EAAM,UAAU,CACF,MAAM,IAAI,CAKnC,EAAuB,GAAG,EAAG,KAF9B,IAAa,IAAA,GAAY,EAAI,OAAO,SAAS,EAAU,GAAM,EAAI,GAEhB,UAAU,GAEhE,OAAO,OAAO,WAAW,EAAqB"}
+{"version":3,"file":"with-precision-D-84B_By.js","names":[],"sources":["../src/internal/with-precision.ts"],"sourcesContent":["// ECMAScript doesn't support more decimal places than 15 anyways,\n// so supporting higher values doesn't make a lot of sense,\n// Considering Number.MAX_SAFE_INTEGER < 10**16, we can use -15\n// for the negative precision limit, too.\nconst MAX_PRECISION = 15;\n\nconst RADIX = 10;\n\nexport function withPrecision(roundingFn: (value: number) => number) {\n  return (value: number, precision: number): number => {\n    if (precision === 0) {\n      return roundingFn(value);\n    }\n\n    if (!Number.isInteger(precision)) {\n      throw new TypeError(\n        `precision must be an integer: ${precision.toString()}`,\n      );\n    }\n\n    if (precision > MAX_PRECISION || precision < -MAX_PRECISION) {\n      throw new RangeError('precision must be between -15 and 15');\n    }\n\n    if (Number.isNaN(value) || !Number.isFinite(value)) {\n      return roundingFn(value);\n    }\n\n    const shiftedValue = shiftDecimalPoint(value, precision);\n    const rounded = roundingFn(shiftedValue);\n    return shiftDecimalPoint(rounded, -precision);\n  };\n}\n\n/**\n * Shift a number's decimal point via scientific notation.\n *\n * This takes advantage of the fact that `Number` methods support scientific\n * (e-notation) string natively and avoids working with double-precision\n * floating-point numbers directly, working around their limitations\n * with representing decimal numbers.\n */\nfunction shiftDecimalPoint(value: number, shift: number): number {\n  const asString = value.toString();\n  const [n, exponent] = asString.split('e');\n\n  const shiftedExponent\n    = (exponent === undefined ? 0 : Number.parseInt(exponent, RADIX)) + shift;\n\n  const shiftedValueAsString = `${n!}e${shiftedExponent.toString()}`;\n\n  return Number.parseFloat(shiftedValueAsString);\n}\n"],"mappings":"AAQA,SAAgB,EAAc,EAAuC,CACnE,OAAQ,EAAe,IAA8B,CACnD,GAAI,IAAc,EAChB,OAAO,EAAW,CAAK,EAGzB,GAAI,CAAC,OAAO,UAAU,CAAS,EAC7B,MAAU,UACR,iCAAiC,EAAU,SAAS,GACtD,EAGF,GAAI,EAAY,IAAiB,EAAY,IAC3C,MAAU,WAAW,sCAAsC,EAS7D,OANI,OAAO,MAAM,CAAK,GAAK,CAAC,OAAO,SAAS,CAAK,EACxC,EAAW,CAAK,EAKlB,EADS,EADK,EAAkB,EAAO,CACR,CACP,EAAG,CAAC,CAAS,CAC9C,CACF,CAUA,SAAS,EAAkB,EAAe,EAAuB,CAE/D,GAAM,CAAC,EAAG,GADO,EAAM,SACM,CAAC,CAAC,MAAM,GAAG,EAKlC,EAAuB,GAAG,EAAG,KAF9B,IAAa,IAAA,GAAY,EAAI,OAAO,SAAS,EAAU,EAAK,GAAK,EAAA,CAEhB,SAAS,IAE/D,OAAO,OAAO,WAAW,CAAoB,CAC/C"}

package/dist/{with-precision-DVi9325n.cjs → with-precision-Dy5W6bdk.cjs}

@@ -1,2 +1,2 @@
-function e(e){return(n,r)=>{if(r===0)return e(n);if(!Number.isInteger(r))throw TypeError(`precision must be an integer: ${r.toString()}`);if(r>15||r<-15)throw RangeError(`precision must be between -15 and 15`);return Number.isNaN(n)||!Number.isFinite(n)?e(n):t(e(t(n,r)),-r)}}function t(e,t){let[n,r]=e.toString().split(`e`),i=`${n}e${((r===void 0?0:Number.parseInt(r,10))+t).toString()}`;return Number.parseFloat(i)}Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return e}});
-//# sourceMappingURL=with-precision-DVi9325n.cjs.map
+function e(e){return(n,r)=>{if(r===0)return e(n);if(!Number.isInteger(r))throw TypeError(`precision must be an integer: ${r.toString()}`);if(r>15||r<-15)throw RangeError(`precision must be between -15 and 15`);return Number.isNaN(n)||!Number.isFinite(n)?e(n):t(e(t(n,r)),-r)}}function t(e,t){let[n,r]=e.toString().split(`e`),i=`${n}e${((r===void 0?0:Number.parseInt(r,10))+t).toString()}`;return Number.parseFloat(i)}Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return e}});
+//# sourceMappingURL=with-precision-Dy5W6bdk.cjs.map

package/dist/{with-precision-DVi9325n.cjs.map → with-precision-Dy5W6bdk.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"with-precision-DVi9325n.cjs","names":[],"sources":["../src/internal/with-precision.ts"],"sourcesContent":["// ECMAScript doesn't support more decimal places than 15 anyways,\n// so supporting higher values doesn't make a lot of sense,\n// Considering Number.MAX_SAFE_INTEGER < 10**16, we can use -15\n// for the negative precision limit, too.\nconst MAX_PRECISION = 15;\n\nconst RADIX = 10;\n\nexport function withPrecision(roundingFn: (value: number) => number) {\n  return (value: number, precision: number): number => {\n    if (precision === 0) {\n      return roundingFn(value);\n    }\n\n    if (!Number.isInteger(precision)) {\n      throw new TypeError(\n        `precision must be an integer: ${precision.toString()}`,\n      );\n    }\n\n    if (precision > MAX_PRECISION || precision < -MAX_PRECISION) {\n      throw new RangeError('precision must be between -15 and 15');\n    }\n\n    if (Number.isNaN(value) || !Number.isFinite(value)) {\n      return roundingFn(value);\n    }\n\n    const shiftedValue = shiftDecimalPoint(value, precision);\n    const rounded = roundingFn(shiftedValue);\n    return shiftDecimalPoint(rounded, -precision);\n  };\n}\n\n/**\n * Shift a number's decimal point via scientific notation.\n *\n * This takes advantage of the fact that `Number` methods support scientific\n * (e-notation) string natively and avoids working with double-precision\n * floating-point numbers directly, working around their limitations\n * with representing decimal numbers.\n */\nfunction shiftDecimalPoint(value: number, shift: number): number {\n  const asString = value.toString();\n  const [n, exponent] = asString.split('e');\n\n  const shiftedExponent\n    = (exponent === undefined ? 0 : Number.parseInt(exponent, RADIX)) + shift;\n\n  const shiftedValueAsString = `${n!}e${shiftedExponent.toString()}`;\n\n  return Number.parseFloat(shiftedValueAsString);\n}\n"],"mappings":"AAQA,SAAgB,EAAc,EAAuC,CACnE,OAAQ,EAAe,IAA8B,CACnD,GAAI,IAAc,EAChB,OAAO,EAAW,EAAM,CAG1B,GAAI,CAAC,OAAO,UAAU,EAAU,CAC9B,MAAU,UACR,iCAAiC,EAAU,UAAU,GACtD,CAGH,GAAI,EAAY,IAAiB,EAAY,IAC3C,MAAU,WAAW,uCAAuC,CAS9D,OANI,OAAO,MAAM,EAAM,EAAI,CAAC,OAAO,SAAS,EAAM,CACzC,EAAW,EAAM,CAKnB,EADS,EADK,EAAkB,EAAO,EAAU,CAChB,CACN,CAAC,EAAU,EAYjD,SAAS,EAAkB,EAAe,EAAuB,CAE/D,GAAM,CAAC,EAAG,GADO,EAAM,UAAU,CACF,MAAM,IAAI,CAKnC,EAAuB,GAAG,EAAG,KAF9B,IAAa,IAAA,GAAY,EAAI,OAAO,SAAS,EAAU,GAAM,EAAI,GAEhB,UAAU,GAEhE,OAAO,OAAO,WAAW,EAAqB"}
+{"version":3,"file":"with-precision-Dy5W6bdk.cjs","names":[],"sources":["../src/internal/with-precision.ts"],"sourcesContent":["// ECMAScript doesn't support more decimal places than 15 anyways,\n// so supporting higher values doesn't make a lot of sense,\n// Considering Number.MAX_SAFE_INTEGER < 10**16, we can use -15\n// for the negative precision limit, too.\nconst MAX_PRECISION = 15;\n\nconst RADIX = 10;\n\nexport function withPrecision(roundingFn: (value: number) => number) {\n  return (value: number, precision: number): number => {\n    if (precision === 0) {\n      return roundingFn(value);\n    }\n\n    if (!Number.isInteger(precision)) {\n      throw new TypeError(\n        `precision must be an integer: ${precision.toString()}`,\n      );\n    }\n\n    if (precision > MAX_PRECISION || precision < -MAX_PRECISION) {\n      throw new RangeError('precision must be between -15 and 15');\n    }\n\n    if (Number.isNaN(value) || !Number.isFinite(value)) {\n      return roundingFn(value);\n    }\n\n    const shiftedValue = shiftDecimalPoint(value, precision);\n    const rounded = roundingFn(shiftedValue);\n    return shiftDecimalPoint(rounded, -precision);\n  };\n}\n\n/**\n * Shift a number's decimal point via scientific notation.\n *\n * This takes advantage of the fact that `Number` methods support scientific\n * (e-notation) string natively and avoids working with double-precision\n * floating-point numbers directly, working around their limitations\n * with representing decimal numbers.\n */\nfunction shiftDecimalPoint(value: number, shift: number): number {\n  const asString = value.toString();\n  const [n, exponent] = asString.split('e');\n\n  const shiftedExponent\n    = (exponent === undefined ? 0 : Number.parseInt(exponent, RADIX)) + shift;\n\n  const shiftedValueAsString = `${n!}e${shiftedExponent.toString()}`;\n\n  return Number.parseFloat(shiftedValueAsString);\n}\n"],"mappings":"AAQA,SAAgB,EAAc,EAAuC,CACnE,OAAQ,EAAe,IAA8B,CACnD,GAAI,IAAc,EAChB,OAAO,EAAW,CAAK,EAGzB,GAAI,CAAC,OAAO,UAAU,CAAS,EAC7B,MAAU,UACR,iCAAiC,EAAU,SAAS,GACtD,EAGF,GAAI,EAAY,IAAiB,EAAY,IAC3C,MAAU,WAAW,sCAAsC,EAS7D,OANI,OAAO,MAAM,CAAK,GAAK,CAAC,OAAO,SAAS,CAAK,EACxC,EAAW,CAAK,EAKlB,EADS,EADK,EAAkB,EAAO,CACR,CACP,EAAG,CAAC,CAAS,CAC9C,CACF,CAUA,SAAS,EAAkB,EAAe,EAAuB,CAE/D,GAAM,CAAC,EAAG,GADO,EAAM,SACM,CAAC,CAAC,MAAM,GAAG,EAKlC,EAAuB,GAAG,EAAG,KAF9B,IAAa,IAAA,GAAY,EAAI,OAAO,SAAS,EAAU,EAAK,GAAK,EAAA,CAEhB,SAAS,IAE/D,OAAO,OAAO,WAAW,CAAoB,CAC/C"}

package/dist/{words-_h74qi45.cjs → words-B-9EXtsW.cjs}

@@ -1,3 +1,3 @@
 const e=new Set([`-`,`_`,...`	.
-.\v.\f.\r. .….\xA0. . . . . . . . . . . . .\u2028.\u2029. . .　.`.split(`.`)]);function t(t){let n=[],r=``,i=()=>{r.length>0&&(n.push(r),r=``)};for(let n of t){if(e.has(n)){i();continue}if(/[a-z]$/u.test(r)&&/[A-Z]/u.test(n))i();else if(/[A-Z][A-Z]$/u.test(r)&&/[a-z]/u.test(n)){let e=r.slice(-1);r=r.slice(0,-1),i(),r=e}r+=n}return i(),n}Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
-//# sourceMappingURL=words-_h74qi45.cjs.map
+.\v.\f.\r. .….\xA0. . . . . . . . . . . . .\u2028.\u2029. . .　.`.split(`.`)]);function t(t){let n=[],r=``,i=()=>{r.length>0&&(n.push(r),r=``)};for(let n of t){if(e.has(n)){i();continue}if(/[a-z]$/u.test(r)&&/[A-Z]/u.test(n))i();else if(/[A-Z][A-Z]$/u.test(r)&&/[a-z]/u.test(n)){let e=r.slice(-1);r=r.slice(0,-1),i(),r=e}r+=n}return i(),n}Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=words-B-9EXtsW.cjs.map

package/dist/{words-_h74qi45.cjs.map → words-B-9EXtsW.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"words-_h74qi45.cjs","names":[],"sources":["../src/internal/words.ts"],"sourcesContent":["import type { Words } from 'type-fest';\n\n// @see https://github.com/sindresorhus/type-fest/blob/main/source/internal/characters.d.ts#L5-L31\nconst WHITESPACE = [\n  '\\u{9}', // '\\t'\n  '\\u{A}', // '\\n'\n  '\\u{B}', // '\\v'\n  '\\u{C}', // '\\f'\n  '\\u{D}', // '\\r'\n  '\\u{20}', // ' '\n  '\\u{85}',\n  '\\u{A0}',\n  '\\u{1680}',\n  '\\u{2000}',\n  '\\u{2001}',\n  '\\u{2002}',\n  '\\u{2003}',\n  '\\u{2004}',\n  '\\u{2005}',\n  '\\u{2006}',\n  '\\u{2007}',\n  '\\u{2008}',\n  '\\u{2009}',\n  '\\u{200A}',\n  '\\u{2028}',\n  '\\u{2029}',\n  '\\u{202F}',\n  '\\u{205F}',\n  '\\u{3000}',\n  '\\u{FEFF}',\n] as const;\n\n// @see https://github.com/sindresorhus/type-fest/blob/main/source/internal/characters.d.ts#L33\nconst WORD_SEPARATORS = new Set(['-', '_', ...WHITESPACE]);\n\nexport function words<S extends string>(data: S): string extends S ? Array<string> : Words<S> {\n  const results: Array<string> = [];\n  let word = '';\n\n  const flush = (): void => {\n    if (word.length > 0) {\n      results.push(word);\n      word = '';\n    }\n  };\n\n  for (const character of data) {\n    if (WORD_SEPARATORS.has(character)) {\n      // Separator encountered; flush the current word & exclude the separator.\n      flush();\n      continue;\n    }\n\n    // Detect transitions:\n    // 1. Lowercase to uppercase (e.g., \"helloWorld\")\n    if (/[a-z]$/u.test(word) && /[A-Z]/u.test(character)) {\n      flush();\n    } else if (/[A-Z][A-Z]$/u.test(word) && /[a-z]/u.test(character)) {\n      // 2. Uppercase to lowercase following multiple uppercase letters (e.g., \"HELLOWorld\")\n      // When the text transitions from 2 upper case letters to a lower case\n      // letter. (one upper case letter is considered part of the word, e.g.\n      // \"Dog\").\n      const lastCharacter = word.slice(-1);\n      word = word.slice(0, -1);\n      flush();\n      word = lastCharacter;\n    }\n\n    // Add the current character to the current word.\n    word += character;\n  }\n\n  // Flush any remaining word.\n  flush();\n\n  // @ts-expect-error [ts2322] -- TypeScript can't infer this type...\n  return results;\n}\n"],"mappings":"AAiCA,MAAM,EAAkB,IAAI,IAAI,CAAC,IAAK,IAAK,GA9BxB;4EA2BlB,CAGwD,CAAC,CAE1D,SAAgB,EAAwB,EAAsD,CAC5F,IAAM,EAAyB,EAAE,CAC7B,EAAO,GAEL,MAAoB,CACpB,EAAK,OAAS,IAChB,EAAQ,KAAK,EAAK,CAClB,EAAO,KAIX,IAAK,IAAM,KAAa,EAAM,CAC5B,GAAI,EAAgB,IAAI,EAAU,CAAE,CAElC,GAAO,CACP,SAKF,GAAI,UAAU,KAAK,EAAK,EAAI,SAAS,KAAK,EAAU,CAClD,GAAO,SACE,eAAe,KAAK,EAAK,EAAI,SAAS,KAAK,EAAU,CAAE,CAKhE,IAAM,EAAgB,EAAK,MAAM,GAAG,CACpC,EAAO,EAAK,MAAM,EAAG,GAAG,CACxB,GAAO,CACP,EAAO,EAIT,GAAQ,EAOV,OAHA,GAAO,CAGA"}
+{"version":3,"file":"words-B-9EXtsW.cjs","names":[],"sources":["../src/internal/words.ts"],"sourcesContent":["import type { Words } from 'type-fest';\n\n// @see https://github.com/sindresorhus/type-fest/blob/main/source/internal/characters.d.ts#L5-L31\nconst WHITESPACE = [\n  '\\u{9}', // '\\t'\n  '\\u{A}', // '\\n'\n  '\\u{B}', // '\\v'\n  '\\u{C}', // '\\f'\n  '\\u{D}', // '\\r'\n  '\\u{20}', // ' '\n  '\\u{85}',\n  '\\u{A0}',\n  '\\u{1680}',\n  '\\u{2000}',\n  '\\u{2001}',\n  '\\u{2002}',\n  '\\u{2003}',\n  '\\u{2004}',\n  '\\u{2005}',\n  '\\u{2006}',\n  '\\u{2007}',\n  '\\u{2008}',\n  '\\u{2009}',\n  '\\u{200A}',\n  '\\u{2028}',\n  '\\u{2029}',\n  '\\u{202F}',\n  '\\u{205F}',\n  '\\u{3000}',\n  '\\u{FEFF}',\n] as const;\n\n// @see https://github.com/sindresorhus/type-fest/blob/main/source/internal/characters.d.ts#L33\nconst WORD_SEPARATORS = new Set(['-', '_', ...WHITESPACE]);\n\nexport function words<S extends string>(data: S): string extends S ? Array<string> : Words<S> {\n  const results: Array<string> = [];\n  let word = '';\n\n  const flush = (): void => {\n    if (word.length > 0) {\n      results.push(word);\n      word = '';\n    }\n  };\n\n  for (const character of data) {\n    if (WORD_SEPARATORS.has(character)) {\n      // Separator encountered; flush the current word & exclude the separator.\n      flush();\n      continue;\n    }\n\n    // Detect transitions:\n    // 1. Lowercase to uppercase (e.g., \"helloWorld\")\n    if (/[a-z]$/u.test(word) && /[A-Z]/u.test(character)) {\n      flush();\n    } else if (/[A-Z][A-Z]$/u.test(word) && /[a-z]/u.test(character)) {\n      // 2. Uppercase to lowercase following multiple uppercase letters (e.g., \"HELLOWorld\")\n      // When the text transitions from 2 upper case letters to a lower case\n      // letter. (one upper case letter is considered part of the word, e.g.\n      // \"Dog\").\n      const lastCharacter = word.slice(-1);\n      word = word.slice(0, -1);\n      flush();\n      word = lastCharacter;\n    }\n\n    // Add the current character to the current word.\n    word += character;\n  }\n\n  // Flush any remaining word.\n  flush();\n\n  // @ts-expect-error [ts2322] -- TypeScript can't infer this type...\n  return results;\n}\n"],"mappings":"AAiCA,MAAM,EAAkB,IAAI,IAAI,CAAC,IAAK,IAAK,GAAG;2EAAS,CAAC,CAAC,EAEzD,SAAgB,EAAwB,EAAsD,CAC5F,IAAM,EAAyB,CAAC,EAC5B,EAAO,GAEL,MAAoB,CACpB,EAAK,OAAS,IAChB,EAAQ,KAAK,CAAI,EACjB,EAAO,GAEX,EAEA,IAAK,IAAM,KAAa,EAAM,CAC5B,GAAI,EAAgB,IAAI,CAAS,EAAG,CAElC,EAAM,EACN,QACF,CAIA,GAAI,UAAU,KAAK,CAAI,GAAK,SAAS,KAAK,CAAS,EACjD,EAAM,OACD,GAAI,eAAe,KAAK,CAAI,GAAK,SAAS,KAAK,CAAS,EAAG,CAKhE,IAAM,EAAgB,EAAK,MAAM,EAAE,EACnC,EAAO,EAAK,MAAM,EAAG,EAAE,EACvB,EAAM,EACN,EAAO,CACT,CAGA,GAAQ,CACV,CAMA,OAHA,EAAM,EAGC,CACT"}

package/dist/{words-B9lX8euz.js → words-CN1Qil5U.js}

@@ -1,3 +1,3 @@
 const e=new Set([`-`,`_`,...`	.
 .\v.\f.\r. .….\xA0. . . . . . . . . . . . .\u2028.\u2029. . .　.`.split(`.`)]);function t(t){let n=[],r=``,i=()=>{r.length>0&&(n.push(r),r=``)};for(let n of t){if(e.has(n)){i();continue}if(/[a-z]$/u.test(r)&&/[A-Z]/u.test(n))i();else if(/[A-Z][A-Z]$/u.test(r)&&/[a-z]/u.test(n)){let e=r.slice(-1);r=r.slice(0,-1),i(),r=e}r+=n}return i(),n}export{t};
-//# sourceMappingURL=words-B9lX8euz.js.map
+//# sourceMappingURL=words-CN1Qil5U.js.map

package/dist/{words-B9lX8euz.js.map → words-CN1Qil5U.js.map}

@@ -1 +1 @@
-{"version":3,"file":"words-B9lX8euz.js","names":[],"sources":["../src/internal/words.ts"],"sourcesContent":["import type { Words } from 'type-fest';\n\n// @see https://github.com/sindresorhus/type-fest/blob/main/source/internal/characters.d.ts#L5-L31\nconst WHITESPACE = [\n  '\\u{9}', // '\\t'\n  '\\u{A}', // '\\n'\n  '\\u{B}', // '\\v'\n  '\\u{C}', // '\\f'\n  '\\u{D}', // '\\r'\n  '\\u{20}', // ' '\n  '\\u{85}',\n  '\\u{A0}',\n  '\\u{1680}',\n  '\\u{2000}',\n  '\\u{2001}',\n  '\\u{2002}',\n  '\\u{2003}',\n  '\\u{2004}',\n  '\\u{2005}',\n  '\\u{2006}',\n  '\\u{2007}',\n  '\\u{2008}',\n  '\\u{2009}',\n  '\\u{200A}',\n  '\\u{2028}',\n  '\\u{2029}',\n  '\\u{202F}',\n  '\\u{205F}',\n  '\\u{3000}',\n  '\\u{FEFF}',\n] as const;\n\n// @see https://github.com/sindresorhus/type-fest/blob/main/source/internal/characters.d.ts#L33\nconst WORD_SEPARATORS = new Set(['-', '_', ...WHITESPACE]);\n\nexport function words<S extends string>(data: S): string extends S ? Array<string> : Words<S> {\n  const results: Array<string> = [];\n  let word = '';\n\n  const flush = (): void => {\n    if (word.length > 0) {\n      results.push(word);\n      word = '';\n    }\n  };\n\n  for (const character of data) {\n    if (WORD_SEPARATORS.has(character)) {\n      // Separator encountered; flush the current word & exclude the separator.\n      flush();\n      continue;\n    }\n\n    // Detect transitions:\n    // 1. Lowercase to uppercase (e.g., \"helloWorld\")\n    if (/[a-z]$/u.test(word) && /[A-Z]/u.test(character)) {\n      flush();\n    } else if (/[A-Z][A-Z]$/u.test(word) && /[a-z]/u.test(character)) {\n      // 2. Uppercase to lowercase following multiple uppercase letters (e.g., \"HELLOWorld\")\n      // When the text transitions from 2 upper case letters to a lower case\n      // letter. (one upper case letter is considered part of the word, e.g.\n      // \"Dog\").\n      const lastCharacter = word.slice(-1);\n      word = word.slice(0, -1);\n      flush();\n      word = lastCharacter;\n    }\n\n    // Add the current character to the current word.\n    word += character;\n  }\n\n  // Flush any remaining word.\n  flush();\n\n  // @ts-expect-error [ts2322] -- TypeScript can't infer this type...\n  return results;\n}\n"],"mappings":"AAiCA,MAAM,EAAkB,IAAI,IAAI,CAAC,IAAK,IAAK,GA9BxB;4EA2BlB,CAGwD,CAAC,CAE1D,SAAgB,EAAwB,EAAsD,CAC5F,IAAM,EAAyB,EAAE,CAC7B,EAAO,GAEL,MAAoB,CACpB,EAAK,OAAS,IAChB,EAAQ,KAAK,EAAK,CAClB,EAAO,KAIX,IAAK,IAAM,KAAa,EAAM,CAC5B,GAAI,EAAgB,IAAI,EAAU,CAAE,CAElC,GAAO,CACP,SAKF,GAAI,UAAU,KAAK,EAAK,EAAI,SAAS,KAAK,EAAU,CAClD,GAAO,SACE,eAAe,KAAK,EAAK,EAAI,SAAS,KAAK,EAAU,CAAE,CAKhE,IAAM,EAAgB,EAAK,MAAM,GAAG,CACpC,EAAO,EAAK,MAAM,EAAG,GAAG,CACxB,GAAO,CACP,EAAO,EAIT,GAAQ,EAOV,OAHA,GAAO,CAGA"}
+{"version":3,"file":"words-CN1Qil5U.js","names":[],"sources":["../src/internal/words.ts"],"sourcesContent":["import type { Words } from 'type-fest';\n\n// @see https://github.com/sindresorhus/type-fest/blob/main/source/internal/characters.d.ts#L5-L31\nconst WHITESPACE = [\n  '\\u{9}', // '\\t'\n  '\\u{A}', // '\\n'\n  '\\u{B}', // '\\v'\n  '\\u{C}', // '\\f'\n  '\\u{D}', // '\\r'\n  '\\u{20}', // ' '\n  '\\u{85}',\n  '\\u{A0}',\n  '\\u{1680}',\n  '\\u{2000}',\n  '\\u{2001}',\n  '\\u{2002}',\n  '\\u{2003}',\n  '\\u{2004}',\n  '\\u{2005}',\n  '\\u{2006}',\n  '\\u{2007}',\n  '\\u{2008}',\n  '\\u{2009}',\n  '\\u{200A}',\n  '\\u{2028}',\n  '\\u{2029}',\n  '\\u{202F}',\n  '\\u{205F}',\n  '\\u{3000}',\n  '\\u{FEFF}',\n] as const;\n\n// @see https://github.com/sindresorhus/type-fest/blob/main/source/internal/characters.d.ts#L33\nconst WORD_SEPARATORS = new Set(['-', '_', ...WHITESPACE]);\n\nexport function words<S extends string>(data: S): string extends S ? Array<string> : Words<S> {\n  const results: Array<string> = [];\n  let word = '';\n\n  const flush = (): void => {\n    if (word.length > 0) {\n      results.push(word);\n      word = '';\n    }\n  };\n\n  for (const character of data) {\n    if (WORD_SEPARATORS.has(character)) {\n      // Separator encountered; flush the current word & exclude the separator.\n      flush();\n      continue;\n    }\n\n    // Detect transitions:\n    // 1. Lowercase to uppercase (e.g., \"helloWorld\")\n    if (/[a-z]$/u.test(word) && /[A-Z]/u.test(character)) {\n      flush();\n    } else if (/[A-Z][A-Z]$/u.test(word) && /[a-z]/u.test(character)) {\n      // 2. Uppercase to lowercase following multiple uppercase letters (e.g., \"HELLOWorld\")\n      // When the text transitions from 2 upper case letters to a lower case\n      // letter. (one upper case letter is considered part of the word, e.g.\n      // \"Dog\").\n      const lastCharacter = word.slice(-1);\n      word = word.slice(0, -1);\n      flush();\n      word = lastCharacter;\n    }\n\n    // Add the current character to the current word.\n    word += character;\n  }\n\n  // Flush any remaining word.\n  flush();\n\n  // @ts-expect-error [ts2322] -- TypeScript can't infer this type...\n  return results;\n}\n"],"mappings":"AAiCA,MAAM,EAAkB,IAAI,IAAI,CAAC,IAAK,IAAK,GAAG;2EAAS,CAAC,CAAC,EAEzD,SAAgB,EAAwB,EAAsD,CAC5F,IAAM,EAAyB,CAAC,EAC5B,EAAO,GAEL,MAAoB,CACpB,EAAK,OAAS,IAChB,EAAQ,KAAK,CAAI,EACjB,EAAO,GAEX,EAEA,IAAK,IAAM,KAAa,EAAM,CAC5B,GAAI,EAAgB,IAAI,CAAS,EAAG,CAElC,EAAM,EACN,QACF,CAIA,GAAI,UAAU,KAAK,CAAI,GAAK,SAAS,KAAK,CAAS,EACjD,EAAM,OACD,GAAI,eAAe,KAAK,CAAI,GAAK,SAAS,KAAK,CAAS,EAAG,CAKhE,IAAM,EAAgB,EAAK,MAAM,EAAE,EACnC,EAAO,EAAK,MAAM,EAAG,EAAE,EACvB,EAAM,EACN,EAAO,CACT,CAGA,GAAQ,CACV,CAMA,OAHA,EAAM,EAGC,CACT"}

package/dist/zip-with.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./lazy-data-last-impl-B05ZpguF.cjs`);function t(t,i,a){return typeof t==`function`?(e,r)=>n(e,r,t):typeof i==`function`?e.t(n,[t,i],r):n(t,i,a)}function n(e,t,n){let r=[e,t];return e.length<t.length?e.map((e,i)=>n(e,t[i],i,r)):t.map((t,i)=>n(e[i],t,i,r))}function r(e,t){return(n,r,i)=>({next:t(n,e[r],r,[i,e]),hasNext:!0,done:r>=e.length-1})}exports.zipWith=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./lazy-data-last-impl-Dd5zjCfU.cjs");function t(t,i,a){return typeof t==`function`?(e,r)=>n(e,r,t):typeof i==`function`?e.t(n,[t,i],r):n(t,i,a)}function n(e,t,n){let r=[e,t];return e.length<t.length?e.map((e,i)=>n(e,t[i],i,r)):t.map((t,i)=>n(e[i],t,i,r))}function r(e,t){return(n,r,i)=>({next:t(n,e[r],r,[i,e]),hasNext:!0,done:r>=e.length-1})}exports.zipWith=t;
 //# sourceMappingURL=zip-with.cjs.map

package/dist/zip-with.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"zip-with.cjs","names":["lazyDataLastImpl"],"sources":["../src/zip-with.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { lazyDataLastImpl } from './internal/lazy-data-last-impl';\n\ntype ZippingFunction<\n  T1 extends IterableContainer = IterableContainer,\n  T2 extends IterableContainer = IterableContainer,\n  Value = unknown,\n> = (\n  first: T1[number],\n  second: T2[number],\n  index: number,\n  data: readonly [first: T1, second: T2],\n) => Value;\n\n/**\n * Creates a new list from two supplied lists by calling the supplied function\n * with the same-positioned element from each list.\n *\n * @param fn - The function applied to each position of the list.\n * @signature\n *   zipWith(fn)(first, second)\n * @example\n *   zipWith((a: string, b: string) => a + b)(['1', '2', '3'], ['a', 'b', 'c']) // => ['1a', '2b', '3c']\n * @category Array\n */\nexport function zipWith<TItem1, TItem2, Value>(\n  fn: ZippingFunction<ReadonlyArray<TItem1>, ReadonlyArray<TItem2>, Value>,\n): (first: ReadonlyArray<TItem1>, second: ReadonlyArray<TItem2>) => Array<Value>;\n\n/**\n * Creates a new list from two supplied lists by calling the supplied function\n * with the same-positioned element from each list.\n *\n * @param second - The second input list.\n * @param fn - The function applied to each position of the list.\n * @signature\n *   zipWith(second, fn)(first)\n * @example\n *   pipe(['1', '2', '3'], zipWith(['a', 'b', 'c'], (a, b) => a + b)) // => ['1a', '2b', '3c']\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function zipWith<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n  Value,\n>(second: T2, fn: ZippingFunction<T1, T2, Value>): (first: T1) => Array<Value>;\n\n/**\n * Creates a new list from two supplied lists by calling the supplied function\n * with the same-positioned element from each list.\n *\n * @param first - The first input list.\n * @param second - The second input list.\n * @param fn - The function applied to each position of the list.\n * @signature\n *   zipWith(first, second, fn)\n * @example\n *   zipWith(['1', '2', '3'], ['a', 'b', 'c'], (a, b) => a + b) // => ['1a', '2b', '3c']\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function zipWith<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n  Value,\n>(first: T1, second: T2, fn: ZippingFunction<T1, T2, Value>): Array<Value>;\n\nexport function zipWith(\n  arg0: IterableContainer | ZippingFunction,\n  arg1?: IterableContainer | ZippingFunction,\n  arg2?: ZippingFunction,\n): unknown {\n  if (typeof arg0 === 'function') {\n    // Both datum's last\n    return (data1: IterableContainer, data2: IterableContainer) =>\n      zipWithImplementation(data1, data2, arg0);\n  }\n\n  if (typeof arg1 === 'function') {\n    // dataLast\n    return lazyDataLastImpl(\n      zipWithImplementation,\n      [arg0, arg1],\n      lazyImplementation,\n    );\n  }\n\n  // dataFirst. Notice that we assert that the arguments are defined to reduce\n  // the number of runtime checks that would otherwise be needed to make\n  // TypeScript happy here. Because this is an internal implementation and we\n  // are protected by the function typing itself this is fine!\n  return zipWithImplementation(arg0, arg1!, arg2!);\n}\n\nfunction zipWithImplementation<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n  Value,\n>(first: T1, second: T2, fn: ZippingFunction<T1, T2, Value>): Array<Value> {\n  const datum = [first, second] as const;\n  return first.length < second.length\n    ? first.map((item, index) => fn(item, second[index], index, datum))\n    : second.map((item, index) => fn(first[index], item, index, datum));\n}\n\nfunction lazyImplementation<T1, T2 extends IterableContainer, Value>(second: T2, fn: ZippingFunction<ReadonlyArray<T1>, T2, Value>): LazyEvaluator<T1, Value> {\n  return (value, index, data) => ({\n    next: fn(value, second[index], index, [data, second]),\n    hasNext: true,\n    done: index >= second.length - 1,\n  });\n}\n"],"mappings":"yHAuEA,SAAgB,EACd,EACA,EACA,EACS,CAoBT,OAnBI,OAAO,GAAS,YAEV,EAA0B,IAChC,EAAsB,EAAO,EAAO,EAAK,CAGzC,OAAO,GAAS,WAEXA,EAAAA,EACL,EACA,CAAC,EAAM,EAAK,CACZ,EACD,CAOI,EAAsB,EAAM,EAAO,EAAM,CAGlD,SAAS,EAIP,EAAW,EAAY,EAAkD,CACzE,IAAM,EAAQ,CAAC,EAAO,EAAO,CAC7B,OAAO,EAAM,OAAS,EAAO,OACzB,EAAM,KAAK,EAAM,IAAU,EAAG,EAAM,EAAO,GAAQ,EAAO,EAAM,CAAC,CACjE,EAAO,KAAK,EAAM,IAAU,EAAG,EAAM,GAAQ,EAAM,EAAO,EAAM,CAAC,CAGvE,SAAS,EAA4D,EAAY,EAA6E,CAC5J,OAAQ,EAAO,EAAO,KAAU,CAC9B,KAAM,EAAG,EAAO,EAAO,GAAQ,EAAO,CAAC,EAAM,EAAO,CAAC,CACrD,QAAS,GACT,KAAM,GAAS,EAAO,OAAS,EAChC"}
+{"version":3,"file":"zip-with.cjs","names":["lazyDataLastImpl"],"sources":["../src/zip-with.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { lazyDataLastImpl } from './internal/lazy-data-last-impl';\n\ntype ZippingFunction<\n  T1 extends IterableContainer = IterableContainer,\n  T2 extends IterableContainer = IterableContainer,\n  Value = unknown,\n> = (\n  first: T1[number],\n  second: T2[number],\n  index: number,\n  data: readonly [first: T1, second: T2],\n) => Value;\n\n/**\n * Creates a new list from two supplied lists by calling the supplied function\n * with the same-positioned element from each list.\n *\n * @param fn - The function applied to each position of the list.\n * @signature\n *   zipWith(fn)(first, second)\n * @example\n *   zipWith((a: string, b: string) => a + b)(['1', '2', '3'], ['a', 'b', 'c']) // => ['1a', '2b', '3c']\n * @category Array\n */\nexport function zipWith<TItem1, TItem2, Value>(\n  fn: ZippingFunction<ReadonlyArray<TItem1>, ReadonlyArray<TItem2>, Value>,\n): (first: ReadonlyArray<TItem1>, second: ReadonlyArray<TItem2>) => Array<Value>;\n\n/**\n * Creates a new list from two supplied lists by calling the supplied function\n * with the same-positioned element from each list.\n *\n * @param second - The second input list.\n * @param fn - The function applied to each position of the list.\n * @signature\n *   zipWith(second, fn)(first)\n * @example\n *   pipe(['1', '2', '3'], zipWith(['a', 'b', 'c'], (a, b) => a + b)) // => ['1a', '2b', '3c']\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function zipWith<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n  Value,\n>(second: T2, fn: ZippingFunction<T1, T2, Value>): (first: T1) => Array<Value>;\n\n/**\n * Creates a new list from two supplied lists by calling the supplied function\n * with the same-positioned element from each list.\n *\n * @param first - The first input list.\n * @param second - The second input list.\n * @param fn - The function applied to each position of the list.\n * @signature\n *   zipWith(first, second, fn)\n * @example\n *   zipWith(['1', '2', '3'], ['a', 'b', 'c'], (a, b) => a + b) // => ['1a', '2b', '3c']\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function zipWith<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n  Value,\n>(first: T1, second: T2, fn: ZippingFunction<T1, T2, Value>): Array<Value>;\n\nexport function zipWith(\n  arg0: IterableContainer | ZippingFunction,\n  arg1?: IterableContainer | ZippingFunction,\n  arg2?: ZippingFunction,\n): unknown {\n  if (typeof arg0 === 'function') {\n    // Both datum's last\n    return (data1: IterableContainer, data2: IterableContainer) =>\n      zipWithImplementation(data1, data2, arg0);\n  }\n\n  if (typeof arg1 === 'function') {\n    // dataLast\n    return lazyDataLastImpl(\n      zipWithImplementation,\n      [arg0, arg1],\n      lazyImplementation,\n    );\n  }\n\n  // dataFirst. Notice that we assert that the arguments are defined to reduce\n  // the number of runtime checks that would otherwise be needed to make\n  // TypeScript happy here. Because this is an internal implementation and we\n  // are protected by the function typing itself this is fine!\n  return zipWithImplementation(arg0, arg1!, arg2!);\n}\n\nfunction zipWithImplementation<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n  Value,\n>(first: T1, second: T2, fn: ZippingFunction<T1, T2, Value>): Array<Value> {\n  const datum = [first, second] as const;\n  return first.length < second.length\n    ? first.map((item, index) => fn(item, second[index], index, datum))\n    : second.map((item, index) => fn(first[index], item, index, datum));\n}\n\nfunction lazyImplementation<T1, T2 extends IterableContainer, Value>(second: T2, fn: ZippingFunction<ReadonlyArray<T1>, T2, Value>): LazyEvaluator<T1, Value> {\n  return (value, index, data) => ({\n    next: fn(value, second[index], index, [data, second]),\n    hasNext: true,\n    done: index >= second.length - 1,\n  });\n}\n"],"mappings":"yHAuEA,SAAgB,EACd,EACA,EACA,EACS,CAoBT,OAnBI,OAAO,GAAS,YAEV,EAA0B,IAChC,EAAsB,EAAO,EAAO,CAAI,EAGxC,OAAO,GAAS,WAEXA,EAAAA,EACL,EACA,CAAC,EAAM,CAAI,EACX,CACF,EAOK,EAAsB,EAAM,EAAO,CAAK,CACjD,CAEA,SAAS,EAIP,EAAW,EAAY,EAAkD,CACzE,IAAM,EAAQ,CAAC,EAAO,CAAM,EAC5B,OAAO,EAAM,OAAS,EAAO,OACzB,EAAM,KAAK,EAAM,IAAU,EAAG,EAAM,EAAO,GAAQ,EAAO,CAAK,CAAC,EAChE,EAAO,KAAK,EAAM,IAAU,EAAG,EAAM,GAAQ,EAAM,EAAO,CAAK,CAAC,CACtE,CAEA,SAAS,EAA4D,EAAY,EAA6E,CAC5J,OAAQ,EAAO,EAAO,KAAU,CAC9B,KAAM,EAAG,EAAO,EAAO,GAAQ,EAAO,CAAC,EAAM,CAAM,CAAC,EACpD,QAAS,GACT,KAAM,GAAS,EAAO,OAAS,CACjC,EACF"}

package/dist/zip-with.js

@@ -1,2 +1,2 @@
-import{t as e}from"./lazy-data-last-impl-Vt_M0l7X.js";function t(t,i,a){return typeof t==`function`?(e,r)=>n(e,r,t):typeof i==`function`?e(n,[t,i],r):n(t,i,a)}function n(e,t,n){let r=[e,t];return e.length<t.length?e.map((e,i)=>n(e,t[i],i,r)):t.map((t,i)=>n(e[i],t,i,r))}function r(e,t){return(n,r,i)=>({next:t(n,e[r],r,[i,e]),hasNext:!0,done:r>=e.length-1})}export{t as zipWith};
+import{t as e}from"./lazy-data-last-impl--3B10z3s.js";function t(t,i,a){return typeof t==`function`?(e,r)=>n(e,r,t):typeof i==`function`?e(n,[t,i],r):n(t,i,a)}function n(e,t,n){let r=[e,t];return e.length<t.length?e.map((e,i)=>n(e,t[i],i,r)):t.map((t,i)=>n(e[i],t,i,r))}function r(e,t){return(n,r,i)=>({next:t(n,e[r],r,[i,e]),hasNext:!0,done:r>=e.length-1})}export{t as zipWith};
 //# sourceMappingURL=zip-with.js.map

package/dist/zip-with.js.map

@@ -1 +1 @@
-{"version":3,"file":"zip-with.js","names":[],"sources":["../src/zip-with.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { lazyDataLastImpl } from './internal/lazy-data-last-impl';\n\ntype ZippingFunction<\n  T1 extends IterableContainer = IterableContainer,\n  T2 extends IterableContainer = IterableContainer,\n  Value = unknown,\n> = (\n  first: T1[number],\n  second: T2[number],\n  index: number,\n  data: readonly [first: T1, second: T2],\n) => Value;\n\n/**\n * Creates a new list from two supplied lists by calling the supplied function\n * with the same-positioned element from each list.\n *\n * @param fn - The function applied to each position of the list.\n * @signature\n *   zipWith(fn)(first, second)\n * @example\n *   zipWith((a: string, b: string) => a + b)(['1', '2', '3'], ['a', 'b', 'c']) // => ['1a', '2b', '3c']\n * @category Array\n */\nexport function zipWith<TItem1, TItem2, Value>(\n  fn: ZippingFunction<ReadonlyArray<TItem1>, ReadonlyArray<TItem2>, Value>,\n): (first: ReadonlyArray<TItem1>, second: ReadonlyArray<TItem2>) => Array<Value>;\n\n/**\n * Creates a new list from two supplied lists by calling the supplied function\n * with the same-positioned element from each list.\n *\n * @param second - The second input list.\n * @param fn - The function applied to each position of the list.\n * @signature\n *   zipWith(second, fn)(first)\n * @example\n *   pipe(['1', '2', '3'], zipWith(['a', 'b', 'c'], (a, b) => a + b)) // => ['1a', '2b', '3c']\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function zipWith<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n  Value,\n>(second: T2, fn: ZippingFunction<T1, T2, Value>): (first: T1) => Array<Value>;\n\n/**\n * Creates a new list from two supplied lists by calling the supplied function\n * with the same-positioned element from each list.\n *\n * @param first - The first input list.\n * @param second - The second input list.\n * @param fn - The function applied to each position of the list.\n * @signature\n *   zipWith(first, second, fn)\n * @example\n *   zipWith(['1', '2', '3'], ['a', 'b', 'c'], (a, b) => a + b) // => ['1a', '2b', '3c']\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function zipWith<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n  Value,\n>(first: T1, second: T2, fn: ZippingFunction<T1, T2, Value>): Array<Value>;\n\nexport function zipWith(\n  arg0: IterableContainer | ZippingFunction,\n  arg1?: IterableContainer | ZippingFunction,\n  arg2?: ZippingFunction,\n): unknown {\n  if (typeof arg0 === 'function') {\n    // Both datum's last\n    return (data1: IterableContainer, data2: IterableContainer) =>\n      zipWithImplementation(data1, data2, arg0);\n  }\n\n  if (typeof arg1 === 'function') {\n    // dataLast\n    return lazyDataLastImpl(\n      zipWithImplementation,\n      [arg0, arg1],\n      lazyImplementation,\n    );\n  }\n\n  // dataFirst. Notice that we assert that the arguments are defined to reduce\n  // the number of runtime checks that would otherwise be needed to make\n  // TypeScript happy here. Because this is an internal implementation and we\n  // are protected by the function typing itself this is fine!\n  return zipWithImplementation(arg0, arg1!, arg2!);\n}\n\nfunction zipWithImplementation<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n  Value,\n>(first: T1, second: T2, fn: ZippingFunction<T1, T2, Value>): Array<Value> {\n  const datum = [first, second] as const;\n  return first.length < second.length\n    ? first.map((item, index) => fn(item, second[index], index, datum))\n    : second.map((item, index) => fn(first[index], item, index, datum));\n}\n\nfunction lazyImplementation<T1, T2 extends IterableContainer, Value>(second: T2, fn: ZippingFunction<ReadonlyArray<T1>, T2, Value>): LazyEvaluator<T1, Value> {\n  return (value, index, data) => ({\n    next: fn(value, second[index], index, [data, second]),\n    hasNext: true,\n    done: index >= second.length - 1,\n  });\n}\n"],"mappings":"sDAuEA,SAAgB,EACd,EACA,EACA,EACS,CAoBT,OAnBI,OAAO,GAAS,YAEV,EAA0B,IAChC,EAAsB,EAAO,EAAO,EAAK,CAGzC,OAAO,GAAS,WAEX,EACL,EACA,CAAC,EAAM,EAAK,CACZ,EACD,CAOI,EAAsB,EAAM,EAAO,EAAM,CAGlD,SAAS,EAIP,EAAW,EAAY,EAAkD,CACzE,IAAM,EAAQ,CAAC,EAAO,EAAO,CAC7B,OAAO,EAAM,OAAS,EAAO,OACzB,EAAM,KAAK,EAAM,IAAU,EAAG,EAAM,EAAO,GAAQ,EAAO,EAAM,CAAC,CACjE,EAAO,KAAK,EAAM,IAAU,EAAG,EAAM,GAAQ,EAAM,EAAO,EAAM,CAAC,CAGvE,SAAS,EAA4D,EAAY,EAA6E,CAC5J,OAAQ,EAAO,EAAO,KAAU,CAC9B,KAAM,EAAG,EAAO,EAAO,GAAQ,EAAO,CAAC,EAAM,EAAO,CAAC,CACrD,QAAS,GACT,KAAM,GAAS,EAAO,OAAS,EAChC"}
+{"version":3,"file":"zip-with.js","names":[],"sources":["../src/zip-with.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { lazyDataLastImpl } from './internal/lazy-data-last-impl';\n\ntype ZippingFunction<\n  T1 extends IterableContainer = IterableContainer,\n  T2 extends IterableContainer = IterableContainer,\n  Value = unknown,\n> = (\n  first: T1[number],\n  second: T2[number],\n  index: number,\n  data: readonly [first: T1, second: T2],\n) => Value;\n\n/**\n * Creates a new list from two supplied lists by calling the supplied function\n * with the same-positioned element from each list.\n *\n * @param fn - The function applied to each position of the list.\n * @signature\n *   zipWith(fn)(first, second)\n * @example\n *   zipWith((a: string, b: string) => a + b)(['1', '2', '3'], ['a', 'b', 'c']) // => ['1a', '2b', '3c']\n * @category Array\n */\nexport function zipWith<TItem1, TItem2, Value>(\n  fn: ZippingFunction<ReadonlyArray<TItem1>, ReadonlyArray<TItem2>, Value>,\n): (first: ReadonlyArray<TItem1>, second: ReadonlyArray<TItem2>) => Array<Value>;\n\n/**\n * Creates a new list from two supplied lists by calling the supplied function\n * with the same-positioned element from each list.\n *\n * @param second - The second input list.\n * @param fn - The function applied to each position of the list.\n * @signature\n *   zipWith(second, fn)(first)\n * @example\n *   pipe(['1', '2', '3'], zipWith(['a', 'b', 'c'], (a, b) => a + b)) // => ['1a', '2b', '3c']\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function zipWith<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n  Value,\n>(second: T2, fn: ZippingFunction<T1, T2, Value>): (first: T1) => Array<Value>;\n\n/**\n * Creates a new list from two supplied lists by calling the supplied function\n * with the same-positioned element from each list.\n *\n * @param first - The first input list.\n * @param second - The second input list.\n * @param fn - The function applied to each position of the list.\n * @signature\n *   zipWith(first, second, fn)\n * @example\n *   zipWith(['1', '2', '3'], ['a', 'b', 'c'], (a, b) => a + b) // => ['1a', '2b', '3c']\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function zipWith<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n  Value,\n>(first: T1, second: T2, fn: ZippingFunction<T1, T2, Value>): Array<Value>;\n\nexport function zipWith(\n  arg0: IterableContainer | ZippingFunction,\n  arg1?: IterableContainer | ZippingFunction,\n  arg2?: ZippingFunction,\n): unknown {\n  if (typeof arg0 === 'function') {\n    // Both datum's last\n    return (data1: IterableContainer, data2: IterableContainer) =>\n      zipWithImplementation(data1, data2, arg0);\n  }\n\n  if (typeof arg1 === 'function') {\n    // dataLast\n    return lazyDataLastImpl(\n      zipWithImplementation,\n      [arg0, arg1],\n      lazyImplementation,\n    );\n  }\n\n  // dataFirst. Notice that we assert that the arguments are defined to reduce\n  // the number of runtime checks that would otherwise be needed to make\n  // TypeScript happy here. Because this is an internal implementation and we\n  // are protected by the function typing itself this is fine!\n  return zipWithImplementation(arg0, arg1!, arg2!);\n}\n\nfunction zipWithImplementation<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n  Value,\n>(first: T1, second: T2, fn: ZippingFunction<T1, T2, Value>): Array<Value> {\n  const datum = [first, second] as const;\n  return first.length < second.length\n    ? first.map((item, index) => fn(item, second[index], index, datum))\n    : second.map((item, index) => fn(first[index], item, index, datum));\n}\n\nfunction lazyImplementation<T1, T2 extends IterableContainer, Value>(second: T2, fn: ZippingFunction<ReadonlyArray<T1>, T2, Value>): LazyEvaluator<T1, Value> {\n  return (value, index, data) => ({\n    next: fn(value, second[index], index, [data, second]),\n    hasNext: true,\n    done: index >= second.length - 1,\n  });\n}\n"],"mappings":"sDAuEA,SAAgB,EACd,EACA,EACA,EACS,CAoBT,OAnBI,OAAO,GAAS,YAEV,EAA0B,IAChC,EAAsB,EAAO,EAAO,CAAI,EAGxC,OAAO,GAAS,WAEX,EACL,EACA,CAAC,EAAM,CAAI,EACX,CACF,EAOK,EAAsB,EAAM,EAAO,CAAK,CACjD,CAEA,SAAS,EAIP,EAAW,EAAY,EAAkD,CACzE,IAAM,EAAQ,CAAC,EAAO,CAAM,EAC5B,OAAO,EAAM,OAAS,EAAO,OACzB,EAAM,KAAK,EAAM,IAAU,EAAG,EAAM,EAAO,GAAQ,EAAO,CAAK,CAAC,EAChE,EAAO,KAAK,EAAM,IAAU,EAAG,EAAM,GAAQ,EAAM,EAAO,CAAK,CAAC,CACtE,CAEA,SAAS,EAA4D,EAAY,EAA6E,CAC5J,OAAQ,EAAO,EAAO,KAAU,CAC9B,KAAM,EAAG,EAAO,EAAO,GAAQ,EAAO,CAAC,EAAM,CAAM,CAAC,EACpD,QAAS,GACT,KAAM,GAAS,EAAO,OAAS,CACjC,EACF"}

package/dist/zip.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t,r)}function n(e,t){return e.length<t.length?e.map((e,n)=>[e,t[n]]):t.map((t,n)=>[e[n],t])}function r(e){return(t,n)=>({hasNext:!0,next:[t,e[n]],done:n>=e.length-1})}exports.zip=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs");function t(...t){return e.curry(n,t,r)}function n(e,t){return e.length<t.length?e.map((e,n)=>[e,t[n]]):t.map((t,n)=>[e[n],t])}function r(e){return(t,n)=>({hasNext:!0,next:[t,e[n]],done:n>=e.length-1})}exports.zip=t;
 //# sourceMappingURL=zip.cjs.map

package/dist/zip.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"zip.cjs","names":["curry"],"sources":["../src/zip.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\n\ntype Zipped<Left extends IterableContainer, Right extends IterableContainer>\n  // If the array is empty the output is empty, no surprises\n  = Left extends readonly []\n    ? []\n    : Right extends readonly []\n      ? []\n      : // Are the two inputs both tuples with a non-rest first item?\n      Left extends readonly [infer LeftHead, ...infer LeftRest]\n        ? Right extends readonly [infer RightHead, ...infer RightRest]\n          ? // ...Then take that first item from both and recurse\n            [[LeftHead, RightHead], ...Zipped<LeftRest, RightRest>]\n          : // Is only one of the inputs a tuple (with a non-rest first item)?\n            // Then take that item, and match it with whatever the type of the other *array's* items are.\n            [[LeftHead, Right[number]], ...Zipped<LeftRest, Right>]\n        : Right extends readonly [infer RightHead, ...infer RightRest]\n          ? [[Left[number], RightHead], ...Zipped<Left, RightRest>]\n          : // Both inputs are not tuples (with a non-rest first item, they might be tuples with non-rest last item(s))\n        // So the output is just the \"trivial\" zip result.\n          Array<[Left[number], Right[number]]>;\n\n/**\n * Creates a new list from two supplied lists by pairing up equally-positioned\n * items. The length of the returned list will match the shortest of the two\n * inputs.\n *\n * @param first - The first input list.\n * @param second - The second input list.\n * @signature\n *   zip(first, second)\n * @example\n *   zip([1, 2], ['a', 'b']) // => [[1, 'a'], [2, 'b']]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function zip<F extends IterableContainer, S extends IterableContainer>(\n  first: F,\n  second: S,\n): Zipped<F, S>;\n\n/**\n * Creates a new list from two supplied lists by pairing up equally-positioned\n * items. The length of the returned list will match the shortest of the two\n * inputs.\n *\n * @param second - The second input list.\n * @signature\n *   zip(second)(first)\n * @example\n *   zip(['a', 'b'])([1, 2]) // => [[1, 'a'], [2, 'b']]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function zip<S extends IterableContainer>(\n  second: S,\n): <F extends IterableContainer>(first: F) => Zipped<F, S>;\n\nexport function zip(...args: ReadonlyArray<unknown>): unknown {\n  return curry(zipImplementation, args, lazyImplementation);\n}\n\nfunction zipImplementation<\n  F extends IterableContainer,\n  S extends IterableContainer,\n>(first: F, second: S): Zipped<F, S> {\n  return (first.length < second.length\n    ? first.map((item, index) => [item, second[index]])\n    : second.map((item, index) => [first[index], item])) as Zipped<F, S>;\n}\n\nfunction lazyImplementation<F extends IterableContainer, S extends IterableContainer>(second: S): LazyEvaluator<F[number], [F[number], S[number]]> {\n  return (value, index) => ({\n    hasNext: true,\n    next: [value, second[index]],\n    done: index >= second.length - 1,\n  });\n}\n"],"mappings":"kGA8DA,SAAgB,EAAI,GAAG,EAAuC,CAC5D,OAAOA,EAAAA,MAAM,EAAmB,EAAM,EAAmB,CAG3D,SAAS,EAGP,EAAU,EAAyB,CACnC,OAAQ,EAAM,OAAS,EAAO,OAC1B,EAAM,KAAK,EAAM,IAAU,CAAC,EAAM,EAAO,GAAO,CAAC,CACjD,EAAO,KAAK,EAAM,IAAU,CAAC,EAAM,GAAQ,EAAK,CAAC,CAGvD,SAAS,EAA6E,EAA6D,CACjJ,OAAQ,EAAO,KAAW,CACxB,QAAS,GACT,KAAM,CAAC,EAAO,EAAO,GAAO,CAC5B,KAAM,GAAS,EAAO,OAAS,EAChC"}
+{"version":3,"file":"zip.cjs","names":["curry"],"sources":["../src/zip.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\n\ntype Zipped<Left extends IterableContainer, Right extends IterableContainer>\n  // If the array is empty the output is empty, no surprises\n  = Left extends readonly []\n    ? []\n    : Right extends readonly []\n      ? []\n      : // Are the two inputs both tuples with a non-rest first item?\n      Left extends readonly [infer LeftHead, ...infer LeftRest]\n        ? Right extends readonly [infer RightHead, ...infer RightRest]\n          ? // ...Then take that first item from both and recurse\n            [[LeftHead, RightHead], ...Zipped<LeftRest, RightRest>]\n          : // Is only one of the inputs a tuple (with a non-rest first item)?\n            // Then take that item, and match it with whatever the type of the other *array's* items are.\n            [[LeftHead, Right[number]], ...Zipped<LeftRest, Right>]\n        : Right extends readonly [infer RightHead, ...infer RightRest]\n          ? [[Left[number], RightHead], ...Zipped<Left, RightRest>]\n          : // Both inputs are not tuples (with a non-rest first item, they might be tuples with non-rest last item(s))\n        // So the output is just the \"trivial\" zip result.\n          Array<[Left[number], Right[number]]>;\n\n/**\n * Creates a new list from two supplied lists by pairing up equally-positioned\n * items. The length of the returned list will match the shortest of the two\n * inputs.\n *\n * @param first - The first input list.\n * @param second - The second input list.\n * @signature\n *   zip(first, second)\n * @example\n *   zip([1, 2], ['a', 'b']) // => [[1, 'a'], [2, 'b']]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function zip<F extends IterableContainer, S extends IterableContainer>(\n  first: F,\n  second: S,\n): Zipped<F, S>;\n\n/**\n * Creates a new list from two supplied lists by pairing up equally-positioned\n * items. The length of the returned list will match the shortest of the two\n * inputs.\n *\n * @param second - The second input list.\n * @signature\n *   zip(second)(first)\n * @example\n *   zip(['a', 'b'])([1, 2]) // => [[1, 'a'], [2, 'b']]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function zip<S extends IterableContainer>(\n  second: S,\n): <F extends IterableContainer>(first: F) => Zipped<F, S>;\n\nexport function zip(...args: ReadonlyArray<unknown>): unknown {\n  return curry(zipImplementation, args, lazyImplementation);\n}\n\nfunction zipImplementation<\n  F extends IterableContainer,\n  S extends IterableContainer,\n>(first: F, second: S): Zipped<F, S> {\n  return (first.length < second.length\n    ? first.map((item, index) => [item, second[index]])\n    : second.map((item, index) => [first[index], item])) as Zipped<F, S>;\n}\n\nfunction lazyImplementation<F extends IterableContainer, S extends IterableContainer>(second: S): LazyEvaluator<F[number], [F[number], S[number]]> {\n  return (value, index) => ({\n    hasNext: true,\n    next: [value, second[index]],\n    done: index >= second.length - 1,\n  });\n}\n"],"mappings":"kGA8DA,SAAgB,EAAI,GAAG,EAAuC,CAC5D,OAAOA,EAAAA,MAAM,EAAmB,EAAM,CAAkB,CAC1D,CAEA,SAAS,EAGP,EAAU,EAAyB,CACnC,OAAQ,EAAM,OAAS,EAAO,OAC1B,EAAM,KAAK,EAAM,IAAU,CAAC,EAAM,EAAO,EAAM,CAAC,EAChD,EAAO,KAAK,EAAM,IAAU,CAAC,EAAM,GAAQ,CAAI,CAAC,CACtD,CAEA,SAAS,EAA6E,EAA6D,CACjJ,OAAQ,EAAO,KAAW,CACxB,QAAS,GACT,KAAM,CAAC,EAAO,EAAO,EAAM,EAC3B,KAAM,GAAS,EAAO,OAAS,CACjC,EACF"}

package/dist/zip.js.map

@@ -1 +1 @@
-{"version":3,"file":"zip.js","names":[],"sources":["../src/zip.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\n\ntype Zipped<Left extends IterableContainer, Right extends IterableContainer>\n  // If the array is empty the output is empty, no surprises\n  = Left extends readonly []\n    ? []\n    : Right extends readonly []\n      ? []\n      : // Are the two inputs both tuples with a non-rest first item?\n      Left extends readonly [infer LeftHead, ...infer LeftRest]\n        ? Right extends readonly [infer RightHead, ...infer RightRest]\n          ? // ...Then take that first item from both and recurse\n            [[LeftHead, RightHead], ...Zipped<LeftRest, RightRest>]\n          : // Is only one of the inputs a tuple (with a non-rest first item)?\n            // Then take that item, and match it with whatever the type of the other *array's* items are.\n            [[LeftHead, Right[number]], ...Zipped<LeftRest, Right>]\n        : Right extends readonly [infer RightHead, ...infer RightRest]\n          ? [[Left[number], RightHead], ...Zipped<Left, RightRest>]\n          : // Both inputs are not tuples (with a non-rest first item, they might be tuples with non-rest last item(s))\n        // So the output is just the \"trivial\" zip result.\n          Array<[Left[number], Right[number]]>;\n\n/**\n * Creates a new list from two supplied lists by pairing up equally-positioned\n * items. The length of the returned list will match the shortest of the two\n * inputs.\n *\n * @param first - The first input list.\n * @param second - The second input list.\n * @signature\n *   zip(first, second)\n * @example\n *   zip([1, 2], ['a', 'b']) // => [[1, 'a'], [2, 'b']]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function zip<F extends IterableContainer, S extends IterableContainer>(\n  first: F,\n  second: S,\n): Zipped<F, S>;\n\n/**\n * Creates a new list from two supplied lists by pairing up equally-positioned\n * items. The length of the returned list will match the shortest of the two\n * inputs.\n *\n * @param second - The second input list.\n * @signature\n *   zip(second)(first)\n * @example\n *   zip(['a', 'b'])([1, 2]) // => [[1, 'a'], [2, 'b']]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function zip<S extends IterableContainer>(\n  second: S,\n): <F extends IterableContainer>(first: F) => Zipped<F, S>;\n\nexport function zip(...args: ReadonlyArray<unknown>): unknown {\n  return curry(zipImplementation, args, lazyImplementation);\n}\n\nfunction zipImplementation<\n  F extends IterableContainer,\n  S extends IterableContainer,\n>(first: F, second: S): Zipped<F, S> {\n  return (first.length < second.length\n    ? first.map((item, index) => [item, second[index]])\n    : second.map((item, index) => [first[index], item])) as Zipped<F, S>;\n}\n\nfunction lazyImplementation<F extends IterableContainer, S extends IterableContainer>(second: S): LazyEvaluator<F[number], [F[number], S[number]]> {\n  return (value, index) => ({\n    hasNext: true,\n    next: [value, second[index]],\n    done: index >= second.length - 1,\n  });\n}\n"],"mappings":"mCA8DA,SAAgB,EAAI,GAAG,EAAuC,CAC5D,OAAO,EAAM,EAAmB,EAAM,EAAmB,CAG3D,SAAS,EAGP,EAAU,EAAyB,CACnC,OAAQ,EAAM,OAAS,EAAO,OAC1B,EAAM,KAAK,EAAM,IAAU,CAAC,EAAM,EAAO,GAAO,CAAC,CACjD,EAAO,KAAK,EAAM,IAAU,CAAC,EAAM,GAAQ,EAAK,CAAC,CAGvD,SAAS,EAA6E,EAA6D,CACjJ,OAAQ,EAAO,KAAW,CACxB,QAAS,GACT,KAAM,CAAC,EAAO,EAAO,GAAO,CAC5B,KAAM,GAAS,EAAO,OAAS,EAChC"}
+{"version":3,"file":"zip.js","names":[],"sources":["../src/zip.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\n\ntype Zipped<Left extends IterableContainer, Right extends IterableContainer>\n  // If the array is empty the output is empty, no surprises\n  = Left extends readonly []\n    ? []\n    : Right extends readonly []\n      ? []\n      : // Are the two inputs both tuples with a non-rest first item?\n      Left extends readonly [infer LeftHead, ...infer LeftRest]\n        ? Right extends readonly [infer RightHead, ...infer RightRest]\n          ? // ...Then take that first item from both and recurse\n            [[LeftHead, RightHead], ...Zipped<LeftRest, RightRest>]\n          : // Is only one of the inputs a tuple (with a non-rest first item)?\n            // Then take that item, and match it with whatever the type of the other *array's* items are.\n            [[LeftHead, Right[number]], ...Zipped<LeftRest, Right>]\n        : Right extends readonly [infer RightHead, ...infer RightRest]\n          ? [[Left[number], RightHead], ...Zipped<Left, RightRest>]\n          : // Both inputs are not tuples (with a non-rest first item, they might be tuples with non-rest last item(s))\n        // So the output is just the \"trivial\" zip result.\n          Array<[Left[number], Right[number]]>;\n\n/**\n * Creates a new list from two supplied lists by pairing up equally-positioned\n * items. The length of the returned list will match the shortest of the two\n * inputs.\n *\n * @param first - The first input list.\n * @param second - The second input list.\n * @signature\n *   zip(first, second)\n * @example\n *   zip([1, 2], ['a', 'b']) // => [[1, 'a'], [2, 'b']]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function zip<F extends IterableContainer, S extends IterableContainer>(\n  first: F,\n  second: S,\n): Zipped<F, S>;\n\n/**\n * Creates a new list from two supplied lists by pairing up equally-positioned\n * items. The length of the returned list will match the shortest of the two\n * inputs.\n *\n * @param second - The second input list.\n * @signature\n *   zip(second)(first)\n * @example\n *   zip(['a', 'b'])([1, 2]) // => [[1, 'a'], [2, 'b']]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function zip<S extends IterableContainer>(\n  second: S,\n): <F extends IterableContainer>(first: F) => Zipped<F, S>;\n\nexport function zip(...args: ReadonlyArray<unknown>): unknown {\n  return curry(zipImplementation, args, lazyImplementation);\n}\n\nfunction zipImplementation<\n  F extends IterableContainer,\n  S extends IterableContainer,\n>(first: F, second: S): Zipped<F, S> {\n  return (first.length < second.length\n    ? first.map((item, index) => [item, second[index]])\n    : second.map((item, index) => [first[index], item])) as Zipped<F, S>;\n}\n\nfunction lazyImplementation<F extends IterableContainer, S extends IterableContainer>(second: S): LazyEvaluator<F[number], [F[number], S[number]]> {\n  return (value, index) => ({\n    hasNext: true,\n    next: [value, second[index]],\n    done: index >= second.length - 1,\n  });\n}\n"],"mappings":"mCA8DA,SAAgB,EAAI,GAAG,EAAuC,CAC5D,OAAO,EAAM,EAAmB,EAAM,CAAkB,CAC1D,CAEA,SAAS,EAGP,EAAU,EAAyB,CACnC,OAAQ,EAAM,OAAS,EAAO,OAC1B,EAAM,KAAK,EAAM,IAAU,CAAC,EAAM,EAAO,EAAM,CAAC,EAChD,EAAO,KAAK,EAAM,IAAU,CAAC,EAAM,GAAQ,CAAI,CAAC,CACtD,CAEA,SAAS,EAA6E,EAA6D,CACjJ,OAAQ,EAAO,KAAW,CACxB,QAAS,GACT,KAAM,CAAC,EAAO,EAAO,EAAM,EAC3B,KAAM,GAAS,EAAO,OAAS,CACjC,EACF"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vinicunca/perkakas",
   "type": "module",
-  "version": "1.15.0",
+  "version": "1.16.0",
   "description": "Utility for JavaScript and Typescript.",
   "author": "praburangki<https://github.com/praburangki>",
   "license": "MIT",
@@ -37,19 +37,19 @@
     "node": ">=20.0.0"
   },
   "devDependencies": {
-    "@arethetypeswrong/core": "^0.18.2",
-    "@fast-check/vitest": "^0.4.0",
-    "@types/node": "^25.5.2",
-    "@vinicunca/eslint-config": "5.0.0",
-    "@vitest/coverage-v8": "^4.1.2",
-    "bumpp": "^10.3.2",
-    "eslint": "^10.2.0",
+    "@arethetypeswrong/core": "^0.18.3",
+    "@fast-check/vitest": "^0.4.1",
+    "@types/node": "^25.9.2",
+    "@vinicunca/eslint-config": "5.2.0",
+    "@vitest/coverage-v8": "^4.1.8",
+    "bumpp": "^11.1.0",
+    "eslint": "^10.4.1",
     "fast-check": "^4.7.0",
-    "publint": "^0.3.14",
-    "tsdown": "^0.21.7",
+    "publint": "^0.3.21",
+    "tsdown": "^0.22.2",
     "type-fest": "^5.5.0",
     "typescript": "^6.0.2",
-    "vitest": "^4.1.2"
+    "vitest": "^4.1.8"
   },
   "scripts": {
     "build": "tsdown",

package/dist/binary-search-cutoff-index-CLFtXYPc.cjs

@@ -1,2 +0,0 @@
-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=binary-search-cutoff-index-CLFtXYPc.cjs.map

package/dist/conditional-3wcaMG9k.cjs

@@ -1,2 +0,0 @@
-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

@@ -1 +0,0 @@
-{"version":3,"file":"conditional-3wcaMG9k.cjs","names":[],"sources":["../src/internal/curry-on.ts","../src/conditional.ts"],"sourcesContent":["/**\n * Utility for currying functions based on a predicate for the first argument.\n *\n * This is useful for currying functions with a variadic argument list.\n */\nexport function curryOn<T>(\n  isArg: (firstArg: unknown) => firstArg is T,\n  implementation: (\n    data: unknown,\n    firstArg: T,\n    // eslint-disable-next-line ts/no-explicit-any -- Function inference in typescript relies on `any` to work, it doesn't work with `unknown`\n    ...args: any\n  ) => unknown,\n  args: ReadonlyArray<unknown>,\n): unknown {\n  return isArg(args[0])\n    ? // @ts-expect-error [ts2556] - This is a low-level function that assumes the function declaration and setup is correct and won't result in typing issues when called dynamically.\n      (data: unknown) => implementation(data, ...args)\n    : // @ts-expect-error [ts2556] - This is a low-level function that assumes the function declaration and setup is correct and won't result in typing issues when called dynamically.\n      implementation(...args);\n}\n","/* eslint-disable jsdoc/check-param-names --\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 type { GuardType } from './internal/types/guard-type';\nimport { curryOn } from './internal/curry-on';\n\ntype Case<\n  In,\n  Out,\n  When extends (x: In) => boolean = (x: In) => boolean,\n> = readonly [when: When, then: (x: GuardType<When, In> & In) => Out];\n\ntype DefaultCase<In, Out> = (x: In) => Out;\n\n/**\n * Executes a transformer function based on the first matching predicate,\n * functioning like a series of `if...else if...` statements. It sequentially\n * evaluates each case and, upon finding a truthy predicate, runs the\n * corresponding transformer, and returns, ignoring any further cases, even if\n * they would match.\n *\n * NOTE*: Some type-predicates may fail to narrow the param type of their\n * transformer; in such cases wrap your type-predicate in an anonymous arrow\n * function: e.g., instead of\n * `conditional(..., [myTypePredicate, myTransformer], ...)`, use\n * `conditional(..., [($) => myTypePredicate($), myTransformer], ...)`.\n *\n * To add a a default, catch-all, case you can provide a single callback\n * function (instead of a 2-tuple) as the last case. This is equivalent to\n * adding a case with a trivial always-true predicate as it's condition (see\n * example).\n *\n * For simpler cases you should also consider using `when` instead.\n *\n * Due to TypeScript's inability to infer the result of negating a type-\n * predicate we can't refine the types used in subsequent cases based on\n * previous conditions. Using a `switch (true)` statement or ternary operators\n * is recommended for more precise type control when such type narrowing is\n * needed.\n *\n * !IMPORTANT! - Unlike similar implementations in Lodash and Ramda, this\n * implementation **doesn't** implicitly return `undefined` as a fallback when\n * when none of the cases match; and instead **throws** an exception in those\n * cases! You have to explicitly provide a default case, and can use\n * `constant(undefined)` as your last case to replicate that behavior.\n *\n * @param cases - A list of (up to 10) cases. Each case can be either:\n * - A 2-tuple consisting of a predicate (or type-predicate) and a transformer\n *   function that processes the data if the predicate matches.\n * - A single callback function that acts as a default fallback case.\n * @returns The output of the matched transformer. If no cases match, an\n * exception is thrown. The return type is a union of the return types of all\n * provided transformers.\n * @signature\n *   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.\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, this\n * implementation **doesn't** implicitly return `undefined` as a fallback when\n * when none of the cases match; and instead **throws** an exception in those\n * cases! You have to explicitly provide a default case, and can use\n * `constant(undefined)` as your last case to replicate that behavior.\n *\n * @param data - The input data to be evaluated against the provided cases.\n * @param cases - A list of (up to 10) cases. Each case can be either:\n * - A 2-tuple consisting of a predicate (or type-predicate) and a transformer\n *   function that processes the data if the predicate matches.\n * - A single callback function that acts as a default fallback case.\n * @returns The output of the matched transformer. If no cases match, an\n * exception is thrown. The return type is a union of the return types of all\n * provided transformers.\n * @signature\n *   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: ReadonlyArray<unknown>): unknown {\n  return curryOn(isCase, conditionalImplementation, args);\n}\n\nfunction conditionalImplementation<In, Out>(\n  data: In,\n  ...cases: ReadonlyArray<Case<In, Out> | DefaultCase<In, Out>>\n): Out {\n  for (const current of cases) {\n    if (typeof current === 'function') {\n      return current(data);\n    }\n\n    const [when, then] = current;\n    if (when(data)) {\n      return then(data);\n    }\n  }\n\n  // TODO [>2]: When we built this function originally we didn't want to have to always return `undefined` and force users to always have to handle that case even when they knew it would never happen. In hindsight that was wrong and we can support this at the type-level without throwing. If users want to throw they can always have an explicit fallback that does that (and we might add a throw utility in v3 too!).\n  throw new Error('conditional: data failed for all cases');\n}\n\nfunction isCase(maybeCase: unknown): maybeCase is Case<unknown, unknown> {\n  if (!Array.isArray(maybeCase)) {\n    return false;\n  }\n\n  const [when, then, ...rest] = maybeCase as ReadonlyArray<unknown>;\n  return (\n    typeof when === 'function'\n    && when.length <= 1\n    && typeof then === 'function'\n    && then.length <= 1\n    && rest.length === 0\n  );\n}\n"],"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,EAAuC,CACpE,OAAO,EAAQ,EAAQ,EAA2B,EAAK,CAGzD,SAAS,EACP,EACA,GAAG,EACE,CACL,IAAK,IAAM,KAAW,EAAO,CAC3B,GAAI,OAAO,GAAY,WACrB,OAAO,EAAQ,EAAK,CAGtB,GAAM,CAAC,EAAM,GAAQ,EACrB,GAAI,EAAK,EAAK,CACZ,OAAO,EAAK,EAAK,CAKrB,MAAU,MAAM,yCAAyC,CAG3D,SAAS,EAAO,EAAyD,CACvE,GAAI,CAAC,MAAM,QAAQ,EAAU,CAC3B,MAAO,GAGT,GAAM,CAAC,EAAM,EAAM,GAAG,GAAQ,EAC9B,OACE,OAAO,GAAS,YACb,EAAK,QAAU,GACf,OAAO,GAAS,YAChB,EAAK,QAAU,GACf,EAAK,SAAW"}

package/dist/conditional-CTEJD5TX.js

@@ -1,2 +0,0 @@
-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