@vinicunca/perkakas 1.13.2 → 1.14.0

package/dist/add-prop.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t,n){return{...e,[t]:n}}exports.addProp=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t,n){return{...e,[t]:n}}exports.addProp=t;
+//# sourceMappingURL=add-prop.cjs.map

package/dist/add-prop.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-prop.cjs","names":["curry"],"sources":["../src/add-prop.ts"],"sourcesContent":["import type { UpsertProp } from './internal/types/upsert-prop';\nimport { curry } from './curry';\n\n/**\n * Add a new property to an object.\n *\n * The function doesn't do any checks on the input object. If the property\n * already exists it will be overwritten, and the type of the new value is not\n * checked against the previous type.\n *\n * Use `set` to override values explicitly with better protections.\n *\n * @param obj - The target object.\n * @param prop - The property name.\n * @param value - The property value.\n * @signature\n *    addProp(obj, prop, value)\n * @example\n *    addProp({firstName: 'john'}, 'lastName', 'doe') // => {firstName: 'john', lastName: 'doe'}\n * @dataFirst\n * @category Object\n */\nexport function addProp<T, K extends PropertyKey, V>(\n  obj: T,\n  prop: K,\n  value: V,\n): UpsertProp<T, K, V>;\n\n/**\n * Add a new property to an object.\n *\n * The function doesn't do any checks on the input object. If the property\n * already exists it will be overwritten, and the type of the new value is not\n * checked against the previous type.\n *\n * Use `set` to override values explicitly with better protections.\n *\n * @param prop - The property name.\n * @param value - The property value.\n * @signature\n *    addProp(prop, value)(obj)\n * @example\n *    addProp('lastName', 'doe')({firstName: 'john'}) // => {firstName: 'john', lastName: 'doe'}\n * @dataLast\n * @category Object\n */\nexport function addProp<T, K extends PropertyKey, V>(\n  prop: K,\n  value: V,\n): (obj: T) => UpsertProp<T, K, V>;\n\nexport function addProp(...args: ReadonlyArray<unknown>): unknown {\n  return curry(addPropImplementation, args);\n}\n\nfunction addPropImplementation<T, K extends PropertyKey, V>(\n  obj: T,\n  prop: K,\n  value: V,\n): UpsertProp<T, K, V> {\n  // @ts-expect-error [ts2322] - Hard to type...\n  return { ...obj, [prop]: value };\n}\n"],"mappings":"kGAmDA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAOA,EAAAA,MAAM,EAAuB,EAAK,CAG3C,SAAS,EACP,EACA,EACA,EACqB,CAErB,MAAO,CAAE,GAAG,GAAM,GAAO,EAAO"}

package/dist/add-prop.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t,n){return{...e,[t]:n}}export{t as addProp};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t,n){return{...e,[t]:n}}export{t as addProp};
 //# sourceMappingURL=add-prop.js.map

package/dist/add-prop.js.map

@@ -1 +1 @@
-{"version":3,"file":"add-prop.js","names":[],"sources":["../src/add-prop.ts"],"sourcesContent":["import type { UpsertProp } from './internal/types/upsert-prop';\nimport { curry } from './curry';\n\n/**\n * Add a new property to an object.\n *\n * The function doesn't do any checks on the input object. If the property\n * already exists it will be overwritten, and the type of the new value is not\n * checked against the previous type.\n *\n * Use `set` to override values explicitly with better protections.\n *\n * @param obj the target object\n * @param prop the property name\n * @param value the property value\n * @signature\n *  P.addProp(obj, prop, value)\n * @example\n *  P.addProp({ firstName: 'john' }, 'lastName', 'doe'); // => {firstName: 'john', lastName: 'doe'}\n * @dataFirst\n * @category Object\n */\nexport function addProp<T, K extends PropertyKey, V>(\n  obj: T,\n  prop: K,\n  value: V,\n): UpsertProp<T, K, V>;\n\n/**\n * Add a new property to an object.\n *\n * The function doesn't do any checks on the input object. If the property\n * already exists it will be overwritten, and the type of the new value is not\n * checked against the previous type.\n *\n * Use `set` to override values explicitly with better protections.\n *\n * @param prop the property name\n * @param value the property value\n * @signature\n *  P.addProp(prop, value)(obj)\n * @example\n *  P.addProp('lastName', 'doe')({ firstName: 'john' }); // => {firstName: 'john', lastName: 'doe'}\n * @dataLast\n * @category Object\n */\nexport function addProp<T, K extends PropertyKey, V>(\n  prop: K,\n  value: V,\n): (obj: T) => UpsertProp<T, K, V>;\n\nexport function addProp(...args: ReadonlyArray<unknown>): unknown {\n  return curry(addPropImplementation, args);\n}\n\nfunction addPropImplementation<T, K extends PropertyKey, V>(\n  obj: T,\n  prop: K,\n  value: V,\n): UpsertProp<T, K, V> {\n  // @ts-expect-error [ts2322] TODO: [LOW] - Improve typing\n  return {\n    ...obj,\n    [prop]: value,\n  };\n}\n"],"mappings":"wCAmDA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAK,CAG3C,SAAS,EACP,EACA,EACA,EACqB,CAErB,MAAO,CACL,GAAG,GACF,GAAO,EACT"}
+{"version":3,"file":"add-prop.js","names":[],"sources":["../src/add-prop.ts"],"sourcesContent":["import type { UpsertProp } from './internal/types/upsert-prop';\nimport { curry } from './curry';\n\n/**\n * Add a new property to an object.\n *\n * The function doesn't do any checks on the input object. If the property\n * already exists it will be overwritten, and the type of the new value is not\n * checked against the previous type.\n *\n * Use `set` to override values explicitly with better protections.\n *\n * @param obj - The target object.\n * @param prop - The property name.\n * @param value - The property value.\n * @signature\n *    addProp(obj, prop, value)\n * @example\n *    addProp({firstName: 'john'}, 'lastName', 'doe') // => {firstName: 'john', lastName: 'doe'}\n * @dataFirst\n * @category Object\n */\nexport function addProp<T, K extends PropertyKey, V>(\n  obj: T,\n  prop: K,\n  value: V,\n): UpsertProp<T, K, V>;\n\n/**\n * Add a new property to an object.\n *\n * The function doesn't do any checks on the input object. If the property\n * already exists it will be overwritten, and the type of the new value is not\n * checked against the previous type.\n *\n * Use `set` to override values explicitly with better protections.\n *\n * @param prop - The property name.\n * @param value - The property value.\n * @signature\n *    addProp(prop, value)(obj)\n * @example\n *    addProp('lastName', 'doe')({firstName: 'john'}) // => {firstName: 'john', lastName: 'doe'}\n * @dataLast\n * @category Object\n */\nexport function addProp<T, K extends PropertyKey, V>(\n  prop: K,\n  value: V,\n): (obj: T) => UpsertProp<T, K, V>;\n\nexport function addProp(...args: ReadonlyArray<unknown>): unknown {\n  return curry(addPropImplementation, args);\n}\n\nfunction addPropImplementation<T, K extends PropertyKey, V>(\n  obj: T,\n  prop: K,\n  value: V,\n): UpsertProp<T, K, V> {\n  // @ts-expect-error [ts2322] - Hard to type...\n  return { ...obj, [prop]: value };\n}\n"],"mappings":"mCAmDA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAK,CAG3C,SAAS,EACP,EACA,EACA,EACqB,CAErB,MAAO,CAAE,GAAG,GAAM,GAAO,EAAO"}

package/dist/add.cjs

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

package/dist/add.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"add.cjs","names":["curry"],"sources":["../src/add.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Adds two numbers.\n *\n * @param value - The number.\n * @param addend - The number to add to the value.\n * @signature\n *    add(value, addend);\n * @example\n *    add(10, 5) // => 15\n *    add(10, -5) // => 5\n * @dataFirst\n * @category Number\n */\nexport function add(value: bigint, addend: bigint): bigint;\nexport function add(value: number, addend: number): number;\n\n/**\n * Adds two numbers.\n *\n * @param addend - The number to add to the value.\n * @signature\n *    add(addend)(value);\n * @example\n *    add(5)(10) // => 15\n *    add(-5)(10) // => 5\n *    map([1, 2, 3, 4], add(1)) // => [2, 3, 4, 5]\n * @dataLast\n * @category Number\n */\nexport function add(addend: bigint): (value: bigint) => bigint;\nexport function add(addend: number): (value: number) => number;\n\nexport function add(...args: ReadonlyArray<unknown>): unknown {\n  return curry(addImplementation, args);\n}\n\n// The implementation only uses `number` types, but that's just because it's\n// hard to tell typescript that both value and addend would be of the same type.\nfunction addImplementation(value: number, addend: number): number {\n  return value + addend;\n}\n"],"mappings":"kGAkCA,SAAgB,EAAI,GAAG,EAAuC,CAC5D,OAAOA,EAAAA,MAAM,EAAmB,EAAK,CAKvC,SAAS,EAAkB,EAAe,EAAwB,CAChE,OAAO,EAAQ"}

package/dist/add.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){return e+t}export{t as add};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t){return e+t}export{t as add};
 //# sourceMappingURL=add.js.map

package/dist/add.js.map

@@ -1 +1 @@
-{"version":3,"file":"add.js","names":[],"sources":["../src/add.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Adds two numbers.\n *\n * @param value - The number.\n * @param addend - The number to add to the value.\n * @signature\n *    P.add(value, addend);\n * @example\n *    P.add(10, 5) // => 15\n *    P.add(10, -5) // => 5\n * @dataFirst\n * @category Number\n */\nexport function add(value: bigint, addend: bigint): bigint;\nexport function add(value: number, addend: number): number;\n\n/**\n * Adds two numbers.\n *\n * @param addend - The number to add to the value.\n * @signature\n *    P.add(addend)(value);\n * @example\n *    P.add(5)(10) // => 15\n *    P.add(-5)(10) // => 5\n *    P.map([1, 2, 3, 4], P.add(1)) // => [2, 3, 4, 5]\n * @dataLast\n * @category Number\n */\nexport function add(addend: bigint): (value: bigint) => bigint;\nexport function add(addend: number): (value: number) => number;\n\nexport function add(...args: ReadonlyArray<unknown>): unknown {\n  return curry(addImplementation, args);\n}\n\nfunction addImplementation(value: number, addend: number): number {\n  return value + addend;\n}\n"],"mappings":"wCAkCA,SAAgB,EAAI,GAAG,EAAuC,CAC5D,OAAO,EAAM,EAAmB,EAAK,CAGvC,SAAS,EAAkB,EAAe,EAAwB,CAChE,OAAO,EAAQ"}
+{"version":3,"file":"add.js","names":[],"sources":["../src/add.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Adds two numbers.\n *\n * @param value - The number.\n * @param addend - The number to add to the value.\n * @signature\n *    add(value, addend);\n * @example\n *    add(10, 5) // => 15\n *    add(10, -5) // => 5\n * @dataFirst\n * @category Number\n */\nexport function add(value: bigint, addend: bigint): bigint;\nexport function add(value: number, addend: number): number;\n\n/**\n * Adds two numbers.\n *\n * @param addend - The number to add to the value.\n * @signature\n *    add(addend)(value);\n * @example\n *    add(5)(10) // => 15\n *    add(-5)(10) // => 5\n *    map([1, 2, 3, 4], add(1)) // => [2, 3, 4, 5]\n * @dataLast\n * @category Number\n */\nexport function add(addend: bigint): (value: bigint) => bigint;\nexport function add(addend: number): (value: number) => number;\n\nexport function add(...args: ReadonlyArray<unknown>): unknown {\n  return curry(addImplementation, args);\n}\n\n// The implementation only uses `number` types, but that's just because it's\n// hard to tell typescript that both value and addend would be of the same type.\nfunction addImplementation(value: number, addend: number): number {\n  return value + addend;\n}\n"],"mappings":"mCAkCA,SAAgB,EAAI,GAAG,EAAuC,CAC5D,OAAO,EAAM,EAAmB,EAAK,CAKvC,SAAS,EAAkB,EAAe,EAAwB,CAChE,OAAO,EAAQ"}

package/dist/all-pass.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){return t.every(t=>t(e))}exports.allPass=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){return t.every(t=>t(e))}exports.allPass=t;
+//# sourceMappingURL=all-pass.cjs.map

package/dist/all-pass.cjs.map

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

package/dist/all-pass.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){return t.every(t=>t(e))}export{t as allPass};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t){return t.every(t=>t(e))}export{t as allPass};
 //# sourceMappingURL=all-pass.js.map

package/dist/all-pass.js.map

@@ -1 +1 @@
-{"version":3,"file":"all-pass.js","names":[],"sources":["../src/all-pass.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Determines whether all predicates returns true for the input data.\n *\n * @param data - The input data for predicates.\n * @param fns - The list of predicates.\n * @signature\n *    P.allPass(data, fns)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    P.allPass(12, fns) // => true\n *    P.allPass(8, fns) // => false\n * @dataFirst\n * @category Array\n */\nexport function allPass<T>(\n  data: T,\n  fns: ReadonlyArray<(data: T) => boolean>,\n): boolean;\n\n/**\n * Determines whether all predicates returns true for the input data.\n *\n * @param fns - The list of predicates.\n * @signature\n *    P.allPass(fns)(data)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    P.allPass(fns)(12) // => true\n *    P.allPass(fns)(8) // => false\n * @dataLast\n * @category Array\n */\nexport function allPass<T>(\n  fns: ReadonlyArray<(data: T) => boolean>,\n): (data: T) => boolean;\n\nexport function allPass(...args: ReadonlyArray<unknown>): unknown {\n  return curry(allPassImplementation, args);\n}\n\nfunction allPassImplementation<T>(\n  data: T,\n  fns: ReadonlyArray<(data: T) => boolean>,\n): boolean {\n  return fns.every((fn) => fn(data));\n}\n"],"mappings":"wCA0CA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAK,CAG3C,SAAS,EACP,EACA,EACS,CACT,OAAO,EAAI,MAAO,GAAO,EAAG,EAAK,CAAC"}
+{"version":3,"file":"all-pass.js","names":[],"sources":["../src/all-pass.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Determines whether all predicates return true for the input data.\n *\n * @param data - The input data for predicates.\n * @param fns - The list of predicates.\n * @signature\n *    allPass(data, fns)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    allPass(12, fns) // => true\n *    allPass(8, fns) // => false\n * @dataFirst\n * @category Array\n */\nexport function allPass<T>(\n  data: T,\n  fns: ReadonlyArray<(data: T) => boolean>,\n): boolean;\n\n/**\n * Determines whether all predicates return true for the input data.\n *\n * @param fns - The list of predicates.\n * @signature\n *    allPass(fns)(data)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    allPass(fns)(12) // => true\n *    allPass(fns)(8) // => false\n * @dataLast\n * @category Array\n */\nexport function allPass<T>(\n  fns: ReadonlyArray<(data: T) => boolean>,\n): (data: T) => boolean;\n\nexport function allPass(...args: ReadonlyArray<unknown>): unknown {\n  return curry(allPassImplementation, args);\n}\n\nfunction allPassImplementation<T>(data: T, fns: ReadonlyArray<(data: T) => boolean>): boolean {\n  return fns.every((fn) => fn(data));\n}\n"],"mappings":"mCA0CA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAK,CAG3C,SAAS,EAAyB,EAAS,EAAmD,CAC5F,OAAO,EAAI,MAAO,GAAO,EAAG,EAAK,CAAC"}

package/dist/any-pass.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){return t.some(t=>t(e))}exports.anyPass=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){return t.some(t=>t(e))}exports.anyPass=t;
+//# sourceMappingURL=any-pass.cjs.map

package/dist/any-pass.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"any-pass.cjs","names":["curry"],"sources":["../src/any-pass.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Determines whether any predicate returns true for the input data.\n *\n * @param data - The input data for predicates.\n * @param fns - The list of predicates.\n * @signature\n *    anyPass(data, fns)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    anyPass(8, fns) // => true\n *    anyPass(11, fns) // => false\n * @dataFirst\n * @category Array\n */\nexport function anyPass<T>(\n  data: T,\n  fns: ReadonlyArray<(data: T) => boolean>,\n): boolean;\n\n/**\n * Determines whether any predicate returns true for the input data.\n *\n * @param fns - The list of predicates.\n * @signature\n *    anyPass(fns)(data)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    anyPass(fns)(8) // => true\n *    anyPass(fns)(11) // => false\n * @dataLast\n * @category Array\n */\nexport function anyPass<T>(\n  fns: ReadonlyArray<(data: T) => boolean>,\n): (data: T) => boolean;\n\nexport function anyPass(...args: ReadonlyArray<unknown>): unknown {\n  return curry(anyPassImplementation, args);\n}\n\nfunction anyPassImplementation<T>(data: T, fns: ReadonlyArray<(data: T) => boolean>): boolean {\n  return fns.some((fn) => fn(data));\n}\n"],"mappings":"kGA0CA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAOA,EAAAA,MAAM,EAAuB,EAAK,CAG3C,SAAS,EAAyB,EAAS,EAAmD,CAC5F,OAAO,EAAI,KAAM,GAAO,EAAG,EAAK,CAAC"}

package/dist/any-pass.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){return t.some(t=>t(e))}export{t as anyPass};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t){return t.some(t=>t(e))}export{t as anyPass};
 //# sourceMappingURL=any-pass.js.map

package/dist/any-pass.js.map

@@ -1 +1 @@
-{"version":3,"file":"any-pass.js","names":[],"sources":["../src/any-pass.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Determines whether any predicate returns true for the input data.\n *\n * @param data - The input data for predicates.\n * @param fns - The list of predicates.\n * @signature\n *    P.anyPass(data, fns)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    P.anyPass(8, fns) // => true\n *    P.anyPass(11, fns) // => false\n * @dataFirst\n * @category Array\n */\nexport function anyPass<T>(\n  data: T,\n  fns: ReadonlyArray<(data: T) => boolean>,\n): boolean;\n\n/**\n * Determines whether any predicate returns true for the input data.\n *\n * @param fns - The list of predicates.\n * @signature\n *    P.anyPass(fns)(data)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    P.anyPass(fns)(8) // => true\n *    P.anyPass(fns)(11) // => false\n * @dataLast\n * @category Array\n */\nexport function anyPass<T>(\n  fns: ReadonlyArray<(data: T) => boolean>,\n): (data: T) => boolean;\n\nexport function anyPass(...args: ReadonlyArray<unknown>): unknown {\n  return curry(anyPassImplementation, args);\n}\n\nfunction anyPassImplementation<T>(\n  data: T,\n  fns: ReadonlyArray<(data: T) => boolean>,\n): boolean {\n  return fns.some((fn) => fn(data));\n}\n"],"mappings":"wCA0CA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAK,CAG3C,SAAS,EACP,EACA,EACS,CACT,OAAO,EAAI,KAAM,GAAO,EAAG,EAAK,CAAC"}
+{"version":3,"file":"any-pass.js","names":[],"sources":["../src/any-pass.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Determines whether any predicate returns true for the input data.\n *\n * @param data - The input data for predicates.\n * @param fns - The list of predicates.\n * @signature\n *    anyPass(data, fns)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    anyPass(8, fns) // => true\n *    anyPass(11, fns) // => false\n * @dataFirst\n * @category Array\n */\nexport function anyPass<T>(\n  data: T,\n  fns: ReadonlyArray<(data: T) => boolean>,\n): boolean;\n\n/**\n * Determines whether any predicate returns true for the input data.\n *\n * @param fns - The list of predicates.\n * @signature\n *    anyPass(fns)(data)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    anyPass(fns)(8) // => true\n *    anyPass(fns)(11) // => false\n * @dataLast\n * @category Array\n */\nexport function anyPass<T>(\n  fns: ReadonlyArray<(data: T) => boolean>,\n): (data: T) => boolean;\n\nexport function anyPass(...args: ReadonlyArray<unknown>): unknown {\n  return curry(anyPassImplementation, args);\n}\n\nfunction anyPassImplementation<T>(data: T, fns: ReadonlyArray<(data: T) => boolean>): boolean {\n  return fns.some((fn) => fn(data));\n}\n"],"mappings":"mCA0CA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAK,CAG3C,SAAS,EAAyB,EAAS,EAAmD,CAC5F,OAAO,EAAI,KAAM,GAAO,EAAG,EAAK,CAAC"}

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

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

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

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

package/dist/binary-search-cutoff-index-TJlnoie4.js

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

package/dist/binary-search-cutoff-index-TJlnoie4.js.map

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

package/dist/capitalize.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e){return`${e[0]?.toUpperCase()??``}${e.slice(1)}`}exports.capitalize=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e){return`${e[0]?.toUpperCase()??``}${e.slice(1)}`}exports.capitalize=t;
+//# sourceMappingURL=capitalize.cjs.map

package/dist/capitalize.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"capitalize.cjs","names":["curry"],"sources":["../src/capitalize.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Makes the first character of a string uppercase while leaving the rest\n * unchanged.\n *\n * It uses the built-in [`String.prototype.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)\n * for the runtime and the built-in [`Capitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#capitalizestringtype)\n * utility type for typing and thus shares their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase#description)_.\n *\n * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target\n * just the first letter of the word, and [`text-transform: uppercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#uppercase)\n * to capitalize it. This transformation **is** locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `toLowerCase`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @param data - A string.\n * @signature\n *   capitalize(data);\n * @example\n *   capitalize(\"hello world\"); // \"Hello world\"\n * @dataFirst\n * @category String\n */\nexport function capitalize<T extends string>(data: T): Capitalize<T>;\n\n/**\n * Makes the first character of a string uppercase while leaving the rest\n * unchanged.\n *\n * It uses the built-in [`String.prototype.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)\n * for the runtime and the built-in [`Capitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#capitalizestringtype)\n * utility type for typing and thus shares their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase#description)_.\n *\n * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target\n * just the first letter of the word, and [`text-transform: uppercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#uppercase)\n * to capitalize it. This transformation **is** locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `toLowerCase`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @signature\n *   capitalize()(data);\n * @example\n *   pipe(\"hello world\", capitalize()); // \"Hello world\"\n * @dataLast\n * @category String\n */\nexport function capitalize(): <T extends string>(data: T) => Capitalize<T>;\n\nexport function capitalize(...args: ReadonlyArray<unknown>): unknown {\n  return curry(capitalizeImplementation, args);\n}\n\nfunction capitalizeImplementation<T extends string>(data: T): Capitalize<T> {\n  return `${data[0]?.toUpperCase() ?? ''}${data.slice(1)}` as Capitalize<T>;\n}\n"],"mappings":"kGAqDA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAOA,EAAAA,MAAM,EAA0B,EAAK,CAG9C,SAAS,EAA2C,EAAwB,CAC1E,MAAO,GAAG,EAAK,IAAI,aAAa,EAAI,KAAK,EAAK,MAAM,EAAE"}

package/dist/capitalize.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e){return`${e[0]?.toUpperCase()??``}${e.slice(1)}`}export{t as capitalize};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e){return`${e[0]?.toUpperCase()??``}${e.slice(1)}`}export{t as capitalize};
 //# sourceMappingURL=capitalize.js.map

package/dist/capitalize.js.map

@@ -1 +1 @@
-{"version":3,"file":"capitalize.js","names":[],"sources":["../src/capitalize.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Makes the first character of a string uppercase while leaving the rest\n * unchanged.\n *\n * It uses the built-in [`String.prototype.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)\n * for the runtime and the built-in [`Capitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#capitalizestringtype)\n * utility type for typing and thus shares their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase#description)_.\n *\n * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target\n * just the first letter of the word, and [`text-transform: uppercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#uppercase)\n * to capitalize it. This transformation **is** locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `toLowerCase`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @param data - A string.\n * @signature\n *   P.capitalize(data);\n * @example\n *   P.capitalize(\"hello world\"); // \"Hello world\"\n * @dataFirst\n * @category String\n */\nexport function capitalize<T extends string>(data: T): Capitalize<T>;\n\n/**\n * Makes the first character of a string uppercase while leaving the rest\n * unchanged.\n *\n * It uses the built-in [`String.prototype.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)\n * for the runtime and the built-in [`Capitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#capitalizestringtype)\n * utility type for typing and thus shares their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase#description)_.\n *\n * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target\n * just the first letter of the word, and [`text-transform: uppercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#uppercase)\n * to capitalize it. This transformation **is** locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `toLowerCase`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @signature\n *   P.capitalize()(data);\n * @example\n *   P.pipe(\"hello world\", P.capitalize()); // \"Hello world\"\n * @dataLast\n * @category String\n */\nexport function capitalize(): <T extends string>(data: T) => Capitalize<T>;\n\nexport function capitalize(...args: ReadonlyArray<unknown>): unknown {\n  return curry(capitalizeImplementation, args);\n}\n\nfunction capitalizeImplementation<T extends string>(data: T): Capitalize<T> {\n  return `${data[0]?.toUpperCase() ?? ''}${data.slice(1)}` as Capitalize<T>;\n}\n"],"mappings":"wCAqDA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAO,EAAM,EAA0B,EAAK,CAG9C,SAAS,EAA2C,EAAwB,CAC1E,MAAO,GAAG,EAAK,IAAI,aAAa,EAAI,KAAK,EAAK,MAAM,EAAE"}
+{"version":3,"file":"capitalize.js","names":[],"sources":["../src/capitalize.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Makes the first character of a string uppercase while leaving the rest\n * unchanged.\n *\n * It uses the built-in [`String.prototype.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)\n * for the runtime and the built-in [`Capitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#capitalizestringtype)\n * utility type for typing and thus shares their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase#description)_.\n *\n * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target\n * just the first letter of the word, and [`text-transform: uppercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#uppercase)\n * to capitalize it. This transformation **is** locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `toLowerCase`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @param data - A string.\n * @signature\n *   capitalize(data);\n * @example\n *   capitalize(\"hello world\"); // \"Hello world\"\n * @dataFirst\n * @category String\n */\nexport function capitalize<T extends string>(data: T): Capitalize<T>;\n\n/**\n * Makes the first character of a string uppercase while leaving the rest\n * unchanged.\n *\n * It uses the built-in [`String.prototype.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)\n * for the runtime and the built-in [`Capitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#capitalizestringtype)\n * utility type for typing and thus shares their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase#description)_.\n *\n * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target\n * just the first letter of the word, and [`text-transform: uppercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#uppercase)\n * to capitalize it. This transformation **is** locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `toLowerCase`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @signature\n *   capitalize()(data);\n * @example\n *   pipe(\"hello world\", capitalize()); // \"Hello world\"\n * @dataLast\n * @category String\n */\nexport function capitalize(): <T extends string>(data: T) => Capitalize<T>;\n\nexport function capitalize(...args: ReadonlyArray<unknown>): unknown {\n  return curry(capitalizeImplementation, args);\n}\n\nfunction capitalizeImplementation<T extends string>(data: T): Capitalize<T> {\n  return `${data[0]?.toUpperCase() ?? ''}${data.slice(1)}` as Capitalize<T>;\n}\n"],"mappings":"mCAqDA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAO,EAAM,EAA0B,EAAK,CAG9C,SAAS,EAA2C,EAAwB,CAC1E,MAAO,GAAG,EAAK,IAAI,aAAa,EAAI,KAAK,EAAK,MAAM,EAAE"}

package/dist/ceil.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`),t=require(`./with-precision-dQAYLrgr.cjs`);function n(...n){return e.t(t.t(Math.ceil),n)}exports.ceil=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`),t=require(`./with-precision-DVi9325n.cjs`);function n(...n){return e.curry(t.t(Math.ceil),n)}exports.ceil=n;
+//# sourceMappingURL=ceil.cjs.map

package/dist/ceil.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ceil.cjs","names":["curry","withPrecision"],"sources":["../src/ceil.ts"],"sourcesContent":["import { curry } from './curry';\nimport { withPrecision } from './internal/with-precision';\n\n/**\n * Rounds up a given number to a specific precision.\n * If you'd like to round up to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.ceil` instead, as it won't incur the additional library overhead.\n *\n * @param value - The number to round up.\n * @param precision - The precision to round up to. Must be an integer between -15 and 15.\n * @signature\n *    ceil(value, precision);\n * @example\n *    ceil(123.9876, 3) // => 123.988\n *    ceil(483.22243, 1) // => 483.3\n *    ceil(8541, -1) // => 8550\n *    ceil(456789, -3) // => 457000\n * @dataFirst\n * @category Number\n */\nexport function ceil(value: number, precision: number): number;\n\n/**\n * Rounds up a given number to a specific precision.\n * If you'd like to round up to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.ceil` instead, as it won't incur the additional library overhead.\n *\n * @param precision - The precision to round up to. Must be an integer between -15 and 15.\n * @signature\n *    ceil(precision)(value);\n * @example\n *    ceil(3)(123.9876) // => 123.988\n *    ceil(1)(483.22243) // => 483.3\n *    ceil(-1)(8541) // => 8550\n *    ceil(-3)(456789) // => 457000\n * @dataLast\n * @category Number\n */\nexport function ceil(precision: number): (value: number) => number;\n\nexport function ceil(...args: ReadonlyArray<unknown>): unknown {\n  return curry(withPrecision(Math.ceil), args);\n}\n"],"mappings":"6IAwCA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAOA,EAAAA,MAAMC,EAAAA,EAAc,KAAK,KAAK,CAAE,EAAK"}

package/dist/ceil.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";import{t}from"./with-precision-CQ90Walk.js";function n(...n){return e(t(Math.ceil),n)}export{n as ceil};
+import{curry as e}from"./curry.js";import{t}from"./with-precision-CgRuf7Wl.js";function n(...n){return e(t(Math.ceil),n)}export{n as ceil};
 //# sourceMappingURL=ceil.js.map

package/dist/ceil.js.map

@@ -1 +1 @@
-{"version":3,"file":"ceil.js","names":[],"sources":["../src/ceil.ts"],"sourcesContent":["import { curry } from './curry';\nimport { withPrecision } from './internal/with-precision';\n\n/**\n * Rounds up a given number to a specific precision.\n * If you'd like to round up to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.ceil` instead, as it won't incur the additional library overhead.\n *\n * @param value - The number to round up.\n * @param precision - The precision to round up to. Must be an integer between -15 and 15.\n * @signature\n *    P.ceil(value, precision);\n * @example\n *    P.ceil(123.9876, 3) // => 123.988\n *    P.ceil(483.22243, 1) // => 483.3\n *    P.ceil(8541, -1) // => 8550\n *    P.ceil(456789, -3) // => 457000\n * @dataFirst\n * @category Number\n */\nexport function ceil(value: number, precision: number): number;\n\n/**\n * Rounds up a given number to a specific precision.\n * If you'd like to round up to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.ceil` instead, as it won't incur the additional library overhead.\n *\n * @param precision - The precision to round up to. Must be an integer between -15 and 15.\n * @signature\n *    P.ceil(precision)(value);\n * @example\n *    P.ceil(3)(123.9876) // => 123.988\n *    P.ceil(1)(483.22243) // => 483.3\n *    P.ceil(-1)(8541) // => 8550\n *    P.ceil(-3)(456789) // => 457000\n * @dataLast\n * @category Number\n */\nexport function ceil(precision: number): (value: number) => number;\n\nexport function ceil(...args: ReadonlyArray<unknown>): unknown {\n  return curry(withPrecision(Math.ceil), args);\n}\n"],"mappings":"oFAwCA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAc,KAAK,KAAK,CAAE,EAAK"}
+{"version":3,"file":"ceil.js","names":[],"sources":["../src/ceil.ts"],"sourcesContent":["import { curry } from './curry';\nimport { withPrecision } from './internal/with-precision';\n\n/**\n * Rounds up a given number to a specific precision.\n * If you'd like to round up to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.ceil` instead, as it won't incur the additional library overhead.\n *\n * @param value - The number to round up.\n * @param precision - The precision to round up to. Must be an integer between -15 and 15.\n * @signature\n *    ceil(value, precision);\n * @example\n *    ceil(123.9876, 3) // => 123.988\n *    ceil(483.22243, 1) // => 483.3\n *    ceil(8541, -1) // => 8550\n *    ceil(456789, -3) // => 457000\n * @dataFirst\n * @category Number\n */\nexport function ceil(value: number, precision: number): number;\n\n/**\n * Rounds up a given number to a specific precision.\n * If you'd like to round up to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.ceil` instead, as it won't incur the additional library overhead.\n *\n * @param precision - The precision to round up to. Must be an integer between -15 and 15.\n * @signature\n *    ceil(precision)(value);\n * @example\n *    ceil(3)(123.9876) // => 123.988\n *    ceil(1)(483.22243) // => 483.3\n *    ceil(-1)(8541) // => 8550\n *    ceil(-3)(456789) // => 457000\n * @dataLast\n * @category Number\n */\nexport function ceil(precision: number): (value: number) => number;\n\nexport function ceil(...args: ReadonlyArray<unknown>): unknown {\n  return curry(withPrecision(Math.ceil), args);\n}\n"],"mappings":"+EAwCA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAc,KAAK,KAAK,CAAE,EAAK"}

package/dist/chunk.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){if(t<1)throw RangeError(`chunk: A chunk size of '${t}' would result in an infinite array`);if(e.length===0)return[];if(t>=e.length)return[[...e]];let n=Math.ceil(e.length/t),r=Array(n);if(t===1)for(let[t,n]of e.entries())r[t]=[n];else for(let i=0;i<n;i+=1){let n=i*t;r[i]=e.slice(n,n+t)}return r}exports.chunk=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){if(t<1)throw RangeError(`chunk: A chunk size of '${t.toString()}' would result in an infinite array`);if(e.length===0)return[];if(t>=e.length)return[[...e]];let n=Math.ceil(e.length/t),r=Array(n);if(t===1)for(let[t,n]of e.entries())r[t]=[n];else for(let i=0;i<n;i+=1){let n=i*t;r[i]=e.slice(n,n+t)}return r}exports.chunk=t;
+//# sourceMappingURL=chunk.cjs.map

package/dist/chunk.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.cjs","names":["curry"],"sources":["../src/chunk.ts"],"sourcesContent":["import type {\n  IntRange,\n  IsNever,\n  IsNumericLiteral,\n  LessThan,\n  Subtract,\n  ValueOf,\n} from 'type-fest';\nimport type { IntRangeInclusive } from './internal/types/int-range-inclusive';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { NTuple } from './internal/types/n-tuple';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport type { PartialArray } from './internal/types/partial-array';\nimport type { TupleParts } from './internal/types/tuple-parts';\nimport { curry } from './curry';\n\n// This prevents typescript from failing on complex arrays and large chunks. It\n// allows the typing to remain useful even when very large chunks are needed,\n// without loosing fidelity on smaller ones. It was chosen by trial-and-error,\n// and given some more wiggle room because the complexity of the array also\n// plays a role in when typescript fails to recurse.\n// See the type tests for an example.\ntype MAX_LITERAL_SIZE = 350;\n\ntype Chunk<\n  T extends IterableContainer,\n  N extends number,\n> = T extends readonly []\n  ? []\n  : IsNumericLiteral<N> extends true\n    ? LessThan<N, 1> extends true\n      ? never\n      : LessThan<N, MAX_LITERAL_SIZE> extends true\n        ? // The spread here is used as a form of \"Simplify\" for arrays; without\n          // it our return type isn't useful.\n          [...LiteralChunk<T, N>]\n        : GenericChunk<T>\n    : GenericChunk<T>;\n\ntype LiteralChunk<T extends IterableContainer, N extends number>\n  = | ChunkRestElement<\n    // Our result will always have the prefix tuple chunked the same way, so\n    // we compute it once here and send it to the main logic below\n    ChunkFixedTuple<TuplePrefix<T>, N>,\n    TupleParts<T>['item'],\n    TupleParts<T>['suffix'],\n    N\n  >\n  // If both the prefix and suffix tuples are empty then our input is a simple\n  // array of the form `Item[]`. This means it could also be empty, so we\n  // need to add the empty output to our return type.\n  | ([...TuplePrefix<T>, ...TupleParts<T>['suffix']] extends readonly []\n    ? []\n    : never);\n\n/**\n * This type **only** works if the input array `T` is a fixed tuple. For these\n * inputs the chunked output could be computed as literal finite tuples too.\n */\ntype ChunkFixedTuple<\n  T,\n  N extends number,\n  // Important! Result is initialized with an empty array (and not `[[]]`)\n  // because the result of `chunk` on an empty array is `[]` and not `[[]]`.\n  Result = [],\n> = T extends readonly [infer Head, ...infer Rest]\n  ? // We continue consuming the input tuple recursively item by item.\n  ChunkFixedTuple<\n    Rest,\n    N,\n    Result extends [\n      ...infer Previous extends Array<Array<unknown>>,\n      infer Current extends Array<unknown>,\n    ]\n      ? // We take a look at the last chunk in the result, this is the\n    // \"current\" chunk where new items would be added, all chunks before\n    // it are already full.\n      Current['length'] extends N\n        ? // The current chunk is full, create a new chunk and put Head in it.\n          [...Previous, Current, [Head]]\n        : // The current chunk is not full yet, so we add Head to it.\n          [...Previous, [...Current, Head]]\n      : // This would only happen on the first iteration, when result is\n    // still empty. In this case we create the first chunk and put Head\n    // in it.\n        [[Head]]\n  >\n  : // We know T is a finite tuple, so the only case where we would reach this\n// is when T is empty, and in that case our results array contains the whole\n// input chunked by N.\n  Result;\n\n/**\n * Here lies the main complexity of building the chunk type. It takes the prefix\n * chunks, the rest param item type, and the suffix (not chunked!) and it\n * creates all possible combinations of adding items to the prefix and suffix\n * for all possible scenarios for how many items the rest param \"represents\".\n */\ntype ChunkRestElement<\n  PrefixChunks,\n  Item,\n  Suffix extends Array<unknown>,\n  N extends number,\n>\n  = IsNever<Item> extends true\n    ? // The rest param is never when there is no rest param, the whole array is\n  // a finite tuple and is represented already by the prefix chunks. Suffix\n  // is assumed to be empty in this case.\n    PrefixChunks\n    : PrefixChunks extends [\n      ...infer PrefixFullChunks extends Array<Array<unknown>>,\n      infer LastPrefixChunk extends Array<unknown>,\n    ]\n      ? // When our prefix chunks are not empty it means we need to look at all\n    // combinations of mixing the prefix, the suffix, and different counts\n    // of the rest param until we cover all possible scenarios.\n      | ValueOf<{\n        // We want to iterate over all possible padding sizes we can add\n        // to the last prefix chunk until we reach N\n        // (`0..N-LastPrefixChunk.length`). We need to do this because\n        // until the last prefix chunk is full, we need to consider the\n        // suffix being part of it too...\n        [Padding in IntRangeInclusive<\n          0,\n          Subtract<N, LastPrefixChunk['length']>\n        >]: [\n          ...PrefixFullChunks,\n          ...ChunkFixedTuple<\n            // Create a new array that would **not** contain a rest param\n            // (so it's finite) made of the last prefix chunk, padding\n            // from the rest param, and the suffix.\n            [...LastPrefixChunk, ...NTuple<Item, Padding>, ...Suffix],\n            N\n          >,\n        ];\n      }>\n          // Additionally, we need to consider the case where the last prefix\n          // chunk **is** full, and follow it with an array of chunks of the\n          // rest param (and only them), and then followed by all possible\n          // variations of the suffix chunks.\n      | [\n        ...PrefixFullChunks,\n        [\n          // Fully padded last prefix chunk\n          ...LastPrefixChunk,\n          ...NTuple<Item, Subtract<N, LastPrefixChunk['length']>>,\n        ],\n        ...Array<NTuple<Item, N>>,\n        ...SuffixChunk<Suffix, Item, N>,\n      ]\n      : // When our prefix chunks are empty we only need to handle the suffix\n        [...Array<NTuple<Item, N>>, ...SuffixChunk<Suffix, Item, N>];\n\n/**\n * This type assumes it takes a finite tuple that represents the suffix of our\n * input array. It builds all possible combinations of adding items to the\n * **head** of the suffix in order to pad the suffix until the last chunk is\n * full.\n */\ntype SuffixChunk<\n  T extends Array<unknown>,\n  Item,\n  N extends number,\n> = T extends readonly []\n  ? // If we don't have a suffix we simply create a single chunk with all\n    // possible non-empty sub-arrays of `Item` up to size `N`.\n    [ValueOf<{ [K in IntRangeInclusive<1, N>]: NTuple<Item, K> }>]\n  : ValueOf<{\n    // When suffix isn't empty we pad the head of the suffix and compute it's\n    // chunks for all possible padding sizes.\n    [Padding in IntRange<0, N>]: ChunkFixedTuple<\n      [...NTuple<Item, Padding>, ...T],\n      N\n    >;\n  }>;\n\n/**\n * This is the legacy type used when we don't know what N is. We can only adjust\n * our output based on if we know for sure that the array is empty or not.\n */\ntype GenericChunk<T extends IterableContainer> = T extends\n  | readonly [...Array<unknown>, unknown]\n  | readonly [unknown, ...Array<unknown>]\n  ? NonEmptyArray<NonEmptyArray<T[number]>>\n  : Array<NonEmptyArray<T[number]>>;\n\n// TODO: Chunk was built before we handled optional elements correctly. It needs to be fixed to handle these correctly, specifically in regard to optional elements creating whole chunks that themselves need to be optional, but that their items themselves should not be optional, except the last chunk...\ntype TuplePrefix<T extends IterableContainer> = [\n  ...TupleParts<T>['required'],\n  ...PartialArray<TupleParts<T>['optional']>,\n];\n\n/**\n * Split an array into groups the length of `size`. If `array` can't be split evenly, the final chunk will be the remaining elements.\n *\n * @param array - The array.\n * @param size - The length of the chunk.\n * @signature\n *    chunk(array, size)\n * @example\n *    chunk(['a', 'b', 'c', 'd'], 2) // => [['a', 'b'], ['c', 'd']]\n *    chunk(['a', 'b', 'c', 'd'], 3) // => [['a', 'b', 'c'], ['d']]\n * @dataFirst\n * @category Array\n */\nexport function chunk<T extends IterableContainer, N extends number>(\n  array: T,\n  size: N,\n): Chunk<T, N>;\n\n/**\n * Split an array into groups the length of `size`. If `array` can't be split evenly, the final chunk will be the remaining elements.\n *\n * @param size - The length of the chunk.\n * @signature\n *    chunk(size)(array)\n * @example\n *    chunk(2)(['a', 'b', 'c', 'd']) // => [['a', 'b'], ['c', 'd']]\n *    chunk(3)(['a', 'b', 'c', 'd']) // => [['a', 'b', 'c'], ['d']]\n * @dataLast\n * @category Array\n */\nexport function chunk<N extends number>(\n  size: N,\n): <T extends IterableContainer>(array: T) => Chunk<T, N>;\n\nexport function chunk(...args: ReadonlyArray<unknown>): unknown {\n  return curry(chunkImplementation, args);\n}\n\nfunction chunkImplementation<T>(data: ReadonlyArray<T>, size: number): Array<Array<T>> {\n  if (size < 1) {\n    throw new RangeError(\n      `chunk: A chunk size of '${size.toString()}' would result in an infinite array`,\n    );\n  }\n\n  if (data.length === 0) {\n    return [];\n  }\n\n  if (size >= data.length) {\n    // Optimized for when there is only one chunk.\n    return [[...data]];\n  }\n\n  const chunks = Math.ceil(data.length / size);\n\n  // eslint-disable-next-line unicorn/no-new-array -- This is OK, a sparse array allows us to handle very large arrays more efficiently.\n  const result = new Array<Array<T>>(chunks);\n\n  if (size === 1) {\n    // Optimized for when we don't need slice.\n    for (const [index, item] of data.entries()) {\n      result[index] = [item];\n    }\n  } else {\n    for (let index = 0; index < chunks; index += 1) {\n      const start = index * size;\n      result[index] = data.slice(start, start + size);\n    }\n  }\n\n  return result;\n}\n"],"mappings":"kGAkOA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAOA,EAAAA,MAAM,EAAqB,EAAK,CAGzC,SAAS,EAAuB,EAAwB,EAA+B,CACrF,GAAI,EAAO,EACT,MAAU,WACR,2BAA2B,EAAK,UAAU,CAAC,qCAC5C,CAGH,GAAI,EAAK,SAAW,EAClB,MAAO,EAAE,CAGX,GAAI,GAAQ,EAAK,OAEf,MAAO,CAAC,CAAC,GAAG,EAAK,CAAC,CAGpB,IAAM,EAAS,KAAK,KAAK,EAAK,OAAS,EAAK,CAGtC,EAAa,MAAgB,EAAO,CAE1C,GAAI,IAAS,EAEX,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,SAAS,CACxC,EAAO,GAAS,CAAC,EAAK,MAGxB,IAAK,IAAI,EAAQ,EAAG,EAAQ,EAAQ,GAAS,EAAG,CAC9C,IAAM,EAAQ,EAAQ,EACtB,EAAO,GAAS,EAAK,MAAM,EAAO,EAAQ,EAAK,CAInD,OAAO"}

package/dist/chunk.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){if(t<1)throw RangeError(`chunk: A chunk size of '${t}' would result in an infinite array`);if(e.length===0)return[];if(t>=e.length)return[[...e]];let n=Math.ceil(e.length/t),r=Array(n);if(t===1)for(let[t,n]of e.entries())r[t]=[n];else for(let i=0;i<n;i+=1){let n=i*t;r[i]=e.slice(n,n+t)}return r}export{t as chunk};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t){if(t<1)throw RangeError(`chunk: A chunk size of '${t.toString()}' would result in an infinite array`);if(e.length===0)return[];if(t>=e.length)return[[...e]];let n=Math.ceil(e.length/t),r=Array(n);if(t===1)for(let[t,n]of e.entries())r[t]=[n];else for(let i=0;i<n;i+=1){let n=i*t;r[i]=e.slice(n,n+t)}return r}export{t as chunk};
 //# sourceMappingURL=chunk.js.map

package/dist/chunk.js.map

@@ -1 +1 @@
-{"version":3,"file":"chunk.js","names":[],"sources":["../src/chunk.ts"],"sourcesContent":["import type {\n  IntRange,\n  IsNever,\n  IsNumericLiteral,\n  LessThan,\n  Subtract,\n  ValueOf,\n} from 'type-fest';\nimport type { IntRangeInclusive } from './internal/types/int-range-inclusive';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { NTuple } from './internal/types/n-tuple';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport type { PartialArray } from './internal/types/partial-array';\nimport type { TupleParts } from './internal/types/tuple-parts';\nimport { curry } from './curry';\n\n/**\n * This prevents typescript from failing on complex arrays and large chunks.\n * It allows the typing to remain useful even when very large chunks are needed,\n * without loosing fidelity on smaller ones. It was chosen by trial-and-error,\n * and given some more wiggle room because the complexity of the array also\n * plays a role in when typescript fails to recurse.\n * See the type tests for an example.\n */\ntype MAX_LITERAL_SIZE = 350;\n\ntype Chunk<\n  T extends IterableContainer,\n  N extends number,\n> = T extends readonly []\n  ? []\n  : IsNumericLiteral<N> extends true\n    ? LessThan<N, 1> extends true\n      ? never\n      : LessThan<N, MAX_LITERAL_SIZE> extends true\n        // The spread here is used as a form of \"Simplify\" for arrays; without\n        // it our return type isn't useful.\n        ? [...LiteralChunk<T, N>]\n        : GenericChunk<T>\n    : GenericChunk<T>;\n\ntype LiteralChunk<T extends IterableContainer, N extends number>\n  = | ChunkRestElement<\n    // Our result will always have the prefix tuple chunked the same way, so\n    // we compute it once here and send it to the main logic below\n    ChunkFixedTuple<TuplePrefix<T>, N>,\n    TupleParts<T>['item'],\n    TupleParts<T>['suffix'],\n    N\n  >\n  // If both the prefix and suffix tuples are empty then our input is a simple\n  // array of the form `Item[]`. This means it could also be empty, so we\n  // need to add the empty output to our return type.\n  | ([...TuplePrefix<T>, ...TupleParts<T>['suffix']] extends readonly []\n    ? []\n    : never);\n\n/**\n * This type **only** works if the input array `T` is a fixed tuple. For these\n * inputs the chunked output could be computed as literal finite tuples too.\n */\ntype ChunkFixedTuple<\n  T,\n  N extends number,\n  // Important! Result is initialized with an empty array (and not `[[]]`)\n  // because the result of `chunk` on an empty array is `[]` and not `[[]]`.\n  Result = [],\n> = T extends readonly [infer Head, ...infer Rest]\n  // We continue consuming the input tuple recursively item by item.\n  ? ChunkFixedTuple<\n    Rest,\n    N,\n    Result extends [\n      ...infer Previous extends Array<Array<unknown>>,\n      infer Current extends Array<unknown>,\n    ]\n      // We take a look at the last chunk in the result, this is the\n      // \"current\" chunk where new items would be added, all chunks before\n      // it are already full.\n      ? Current['length'] extends N\n        // The current chunk is full, create a new chunk and put Head in it.\n        ? [...Previous, Current, [Head]]\n        // The current chunk is not full yet, so we add Head to it.\n        : [...Previous, [...Current, Head]]\n      // This would only happen on the first iteration, when result is\n      // still empty. In this case we create the first chunk and put Head\n      // in it.\n      : [[Head]]\n  >\n  // We know T is a finite tuple, so the only case where we would reach this\n  // is when T is empty, and in that case our results array contains the whole\n  // input chunked by N.\n  : Result;\n\n/**\n * Here lies the main complexity of building the chunk type. It takes the prefix\n * chunks, the rest param item type, and the suffix (not chunked!) and it\n * creates all possible combinations of adding items to the prefix and suffix\n * for all possible scenarios for how many items the rest param \"represents\".\n */\ntype ChunkRestElement<\n  PrefixChunks,\n  Item,\n  Suffix extends Array<unknown>,\n  N extends number,\n>\n  = IsNever<Item> extends true\n    // The rest param is never when there is no rest param, the whole array is\n    // a finite tuple and is represented already by the prefix chunks. Suffix\n    // is assumed to be empty in this case.\n    ? PrefixChunks\n    : PrefixChunks extends [\n      ...infer PrefixFullChunks extends Array<Array<unknown>>,\n      infer LastPrefixChunk extends Array<unknown>,\n    ]\n      // When our prefix chunks are not empty it means we need to look at all\n      // combinations of mixing the prefix, the suffix, and different counts\n      // of the rest param until we cover all possible scenarios.\n      ? | ValueOf<{\n        // We want to iterate over all possible padding sizes we can add\n        // to the last prefix chunk until we reach N\n        // (`0..N-LastPrefixChunk.length`). We need to do this because\n        // until the last prefix chunk is full, we need to consider the\n        // suffix being part of it too...\n        [Padding in IntRangeInclusive<\n          0,\n          Subtract<N, LastPrefixChunk['length']>\n        >]: [\n          ...PrefixFullChunks,\n          ...ChunkFixedTuple<\n            // Create a new array that would **not** contain a rest param\n            // (so it's finite) made of the last prefix chunk, padding\n            // from the rest param, and the suffix.\n            [...LastPrefixChunk, ...NTuple<Item, Padding>, ...Suffix],\n            N\n          >,\n        ];\n      }>\n          // Additionally, we need to consider the case where the last prefix\n          // chunk **is** full, and follow it with an array of chunks of the\n          // rest param (and only them), and then followed by all possible\n          // variations of the suffix chunks.\n      | [\n        ...PrefixFullChunks,\n        [\n          // Fully padded last prefix chunk\n          ...LastPrefixChunk,\n          ...NTuple<Item, Subtract<N, LastPrefixChunk['length']>>,\n        ],\n        ...Array<NTuple<Item, N>>,\n        ...SuffixChunk<Suffix, Item, N>,\n      ]\n      // When our prefix chunks are empty we only need to handle the suffix\n      : [...Array<NTuple<Item, N>>, ...SuffixChunk<Suffix, Item, N>];\n\n/**\n * This type assumes it takes a finite tuple that represents the suffix of our\n * input array. It builds all possible combinations of adding items to the\n * **head** of the suffix in order to pad the suffix until the last chunk is\n * full.\n */\ntype SuffixChunk<\n  T extends Array<unknown>,\n  Item,\n  N extends number,\n> = T extends readonly []\n  // If we don't have a suffix we simply create a single chunk with all\n  // possible non-empty sub-arrays of `Item` up to size `N`.\n  ? [ValueOf<{ [K in IntRangeInclusive<1, N>]: NTuple<Item, K> }>]\n  : ValueOf<{\n    // When suffix isn't empty we pad the head of the suffix and compute it's\n    // chunks for all possible padding sizes.\n    [Padding in IntRange<0, N>]: ChunkFixedTuple<\n      [...NTuple<Item, Padding>, ...T],\n      N\n    >;\n  }>;\n\n/**\n * This is the legacy type used when we don't know what N is. We can only adjust\n * our output based on if we know for sure that the array is empty or not.\n */\ntype GenericChunk<T extends IterableContainer> = T extends\n  | readonly [...Array<unknown>, unknown]\n  | readonly [unknown, ...Array<unknown>]\n  ? NonEmptyArray<NonEmptyArray<T[number]>>\n  : Array<NonEmptyArray<T[number]>>;\n\n// TODO: Chunk was built before we handled optional elements correctly. It needs to be fixed to handle these correctly, specifically in regard to optional elements creating whole chunks that themselves need to be optional, but that their items themselves should not be optional, except the last chunk...\ntype TuplePrefix<T extends IterableContainer> = [\n  ...TupleParts<T>['required'],\n  ...PartialArray<TupleParts<T>['optional']>,\n];\n\n/**\n * Split an array into groups the length of `size`. If `array` can't be split evenly, the final chunk will be the remaining elements.\n *\n * @param array - The array.\n * @param size - The length of the chunk.\n * @signature\n *    P.chunk(array, size)\n * @example\n *    P.chunk(['a', 'b', 'c', 'd'], 2) // => [['a', 'b'], ['c', 'd']]\n *    P.chunk(['a', 'b', 'c', 'd'], 3) // => [['a', 'b', 'c'], ['d']]\n * @dataFirst\n * @category Array\n */\nexport function chunk<T extends IterableContainer, N extends number>(\n  array: T,\n  size: N,\n): Chunk<T, N>;\n\n/**\n * Split an array into groups the length of `size`. If `array` can't be split evenly, the final chunk will be the remaining elements.\n *\n * @param size - The length of the chunk.\n * @signature\n *    P.chunk(size)(array)\n * @example\n *    P.chunk(2)(['a', 'b', 'c', 'd']) // => [['a', 'b'], ['c', 'd']]\n *    P.chunk(3)(['a', 'b', 'c', 'd']) // => [['a', 'b', 'c'], ['d']]\n * @dataLast\n * @category Array\n */\nexport function chunk<N extends number>(\n  size: N,\n): <T extends IterableContainer>(array: T) => Chunk<T, N>;\n\nexport function chunk(...args: ReadonlyArray<unknown>): unknown {\n  return curry(chunkImplementation, args);\n}\n\nfunction chunkImplementation<T>(\n  data: ReadonlyArray<T>,\n  size: number,\n): Array<Array<T>> {\n  if (size < 1) {\n    throw new RangeError(\n      `chunk: A chunk size of '${size}' would result in an infinite array`,\n    );\n  }\n\n  if (data.length === 0) {\n    return [];\n  }\n\n  if (size >= data.length) {\n    // Optimized for when there is only one chunk.\n    return [[...data]];\n  }\n\n  const chunks = Math.ceil(data.length / size);\n\n  // eslint-disable-next-line unicorn/no-new-array -- This is OK, a sparse array allows us to handle very large arrays more efficiently.\n  const result = new Array<Array<T>>(chunks);\n\n  if (size === 1) {\n    // Optimized for when we don't need slice.\n    for (const [index, item] of data.entries()) {\n      result[index] = [item];\n    }\n  } else {\n    for (let index = 0; index < chunks; index += 1) {\n      const start = index * size;\n      result[index] = data.slice(start, start + size);\n    }\n  }\n\n  return result;\n}\n"],"mappings":"wCAoOA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAqB,EAAK,CAGzC,SAAS,EACP,EACA,EACiB,CACjB,GAAI,EAAO,EACT,MAAU,WACR,2BAA2B,EAAK,qCACjC,CAGH,GAAI,EAAK,SAAW,EAClB,MAAO,EAAE,CAGX,GAAI,GAAQ,EAAK,OAEf,MAAO,CAAC,CAAC,GAAG,EAAK,CAAC,CAGpB,IAAM,EAAS,KAAK,KAAK,EAAK,OAAS,EAAK,CAGtC,EAAa,MAAgB,EAAO,CAE1C,GAAI,IAAS,EAEX,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,SAAS,CACxC,EAAO,GAAS,CAAC,EAAK,MAGxB,IAAK,IAAI,EAAQ,EAAG,EAAQ,EAAQ,GAAS,EAAG,CAC9C,IAAM,EAAQ,EAAQ,EACtB,EAAO,GAAS,EAAK,MAAM,EAAO,EAAQ,EAAK,CAInD,OAAO"}
+{"version":3,"file":"chunk.js","names":[],"sources":["../src/chunk.ts"],"sourcesContent":["import type {\n  IntRange,\n  IsNever,\n  IsNumericLiteral,\n  LessThan,\n  Subtract,\n  ValueOf,\n} from 'type-fest';\nimport type { IntRangeInclusive } from './internal/types/int-range-inclusive';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { NTuple } from './internal/types/n-tuple';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport type { PartialArray } from './internal/types/partial-array';\nimport type { TupleParts } from './internal/types/tuple-parts';\nimport { curry } from './curry';\n\n// This prevents typescript from failing on complex arrays and large chunks. It\n// allows the typing to remain useful even when very large chunks are needed,\n// without loosing fidelity on smaller ones. It was chosen by trial-and-error,\n// and given some more wiggle room because the complexity of the array also\n// plays a role in when typescript fails to recurse.\n// See the type tests for an example.\ntype MAX_LITERAL_SIZE = 350;\n\ntype Chunk<\n  T extends IterableContainer,\n  N extends number,\n> = T extends readonly []\n  ? []\n  : IsNumericLiteral<N> extends true\n    ? LessThan<N, 1> extends true\n      ? never\n      : LessThan<N, MAX_LITERAL_SIZE> extends true\n        ? // The spread here is used as a form of \"Simplify\" for arrays; without\n          // it our return type isn't useful.\n          [...LiteralChunk<T, N>]\n        : GenericChunk<T>\n    : GenericChunk<T>;\n\ntype LiteralChunk<T extends IterableContainer, N extends number>\n  = | ChunkRestElement<\n    // Our result will always have the prefix tuple chunked the same way, so\n    // we compute it once here and send it to the main logic below\n    ChunkFixedTuple<TuplePrefix<T>, N>,\n    TupleParts<T>['item'],\n    TupleParts<T>['suffix'],\n    N\n  >\n  // If both the prefix and suffix tuples are empty then our input is a simple\n  // array of the form `Item[]`. This means it could also be empty, so we\n  // need to add the empty output to our return type.\n  | ([...TuplePrefix<T>, ...TupleParts<T>['suffix']] extends readonly []\n    ? []\n    : never);\n\n/**\n * This type **only** works if the input array `T` is a fixed tuple. For these\n * inputs the chunked output could be computed as literal finite tuples too.\n */\ntype ChunkFixedTuple<\n  T,\n  N extends number,\n  // Important! Result is initialized with an empty array (and not `[[]]`)\n  // because the result of `chunk` on an empty array is `[]` and not `[[]]`.\n  Result = [],\n> = T extends readonly [infer Head, ...infer Rest]\n  ? // We continue consuming the input tuple recursively item by item.\n  ChunkFixedTuple<\n    Rest,\n    N,\n    Result extends [\n      ...infer Previous extends Array<Array<unknown>>,\n      infer Current extends Array<unknown>,\n    ]\n      ? // We take a look at the last chunk in the result, this is the\n    // \"current\" chunk where new items would be added, all chunks before\n    // it are already full.\n      Current['length'] extends N\n        ? // The current chunk is full, create a new chunk and put Head in it.\n          [...Previous, Current, [Head]]\n        : // The current chunk is not full yet, so we add Head to it.\n          [...Previous, [...Current, Head]]\n      : // This would only happen on the first iteration, when result is\n    // still empty. In this case we create the first chunk and put Head\n    // in it.\n        [[Head]]\n  >\n  : // We know T is a finite tuple, so the only case where we would reach this\n// is when T is empty, and in that case our results array contains the whole\n// input chunked by N.\n  Result;\n\n/**\n * Here lies the main complexity of building the chunk type. It takes the prefix\n * chunks, the rest param item type, and the suffix (not chunked!) and it\n * creates all possible combinations of adding items to the prefix and suffix\n * for all possible scenarios for how many items the rest param \"represents\".\n */\ntype ChunkRestElement<\n  PrefixChunks,\n  Item,\n  Suffix extends Array<unknown>,\n  N extends number,\n>\n  = IsNever<Item> extends true\n    ? // The rest param is never when there is no rest param, the whole array is\n  // a finite tuple and is represented already by the prefix chunks. Suffix\n  // is assumed to be empty in this case.\n    PrefixChunks\n    : PrefixChunks extends [\n      ...infer PrefixFullChunks extends Array<Array<unknown>>,\n      infer LastPrefixChunk extends Array<unknown>,\n    ]\n      ? // When our prefix chunks are not empty it means we need to look at all\n    // combinations of mixing the prefix, the suffix, and different counts\n    // of the rest param until we cover all possible scenarios.\n      | ValueOf<{\n        // We want to iterate over all possible padding sizes we can add\n        // to the last prefix chunk until we reach N\n        // (`0..N-LastPrefixChunk.length`). We need to do this because\n        // until the last prefix chunk is full, we need to consider the\n        // suffix being part of it too...\n        [Padding in IntRangeInclusive<\n          0,\n          Subtract<N, LastPrefixChunk['length']>\n        >]: [\n          ...PrefixFullChunks,\n          ...ChunkFixedTuple<\n            // Create a new array that would **not** contain a rest param\n            // (so it's finite) made of the last prefix chunk, padding\n            // from the rest param, and the suffix.\n            [...LastPrefixChunk, ...NTuple<Item, Padding>, ...Suffix],\n            N\n          >,\n        ];\n      }>\n          // Additionally, we need to consider the case where the last prefix\n          // chunk **is** full, and follow it with an array of chunks of the\n          // rest param (and only them), and then followed by all possible\n          // variations of the suffix chunks.\n      | [\n        ...PrefixFullChunks,\n        [\n          // Fully padded last prefix chunk\n          ...LastPrefixChunk,\n          ...NTuple<Item, Subtract<N, LastPrefixChunk['length']>>,\n        ],\n        ...Array<NTuple<Item, N>>,\n        ...SuffixChunk<Suffix, Item, N>,\n      ]\n      : // When our prefix chunks are empty we only need to handle the suffix\n        [...Array<NTuple<Item, N>>, ...SuffixChunk<Suffix, Item, N>];\n\n/**\n * This type assumes it takes a finite tuple that represents the suffix of our\n * input array. It builds all possible combinations of adding items to the\n * **head** of the suffix in order to pad the suffix until the last chunk is\n * full.\n */\ntype SuffixChunk<\n  T extends Array<unknown>,\n  Item,\n  N extends number,\n> = T extends readonly []\n  ? // If we don't have a suffix we simply create a single chunk with all\n    // possible non-empty sub-arrays of `Item` up to size `N`.\n    [ValueOf<{ [K in IntRangeInclusive<1, N>]: NTuple<Item, K> }>]\n  : ValueOf<{\n    // When suffix isn't empty we pad the head of the suffix and compute it's\n    // chunks for all possible padding sizes.\n    [Padding in IntRange<0, N>]: ChunkFixedTuple<\n      [...NTuple<Item, Padding>, ...T],\n      N\n    >;\n  }>;\n\n/**\n * This is the legacy type used when we don't know what N is. We can only adjust\n * our output based on if we know for sure that the array is empty or not.\n */\ntype GenericChunk<T extends IterableContainer> = T extends\n  | readonly [...Array<unknown>, unknown]\n  | readonly [unknown, ...Array<unknown>]\n  ? NonEmptyArray<NonEmptyArray<T[number]>>\n  : Array<NonEmptyArray<T[number]>>;\n\n// TODO: Chunk was built before we handled optional elements correctly. It needs to be fixed to handle these correctly, specifically in regard to optional elements creating whole chunks that themselves need to be optional, but that their items themselves should not be optional, except the last chunk...\ntype TuplePrefix<T extends IterableContainer> = [\n  ...TupleParts<T>['required'],\n  ...PartialArray<TupleParts<T>['optional']>,\n];\n\n/**\n * Split an array into groups the length of `size`. If `array` can't be split evenly, the final chunk will be the remaining elements.\n *\n * @param array - The array.\n * @param size - The length of the chunk.\n * @signature\n *    chunk(array, size)\n * @example\n *    chunk(['a', 'b', 'c', 'd'], 2) // => [['a', 'b'], ['c', 'd']]\n *    chunk(['a', 'b', 'c', 'd'], 3) // => [['a', 'b', 'c'], ['d']]\n * @dataFirst\n * @category Array\n */\nexport function chunk<T extends IterableContainer, N extends number>(\n  array: T,\n  size: N,\n): Chunk<T, N>;\n\n/**\n * Split an array into groups the length of `size`. If `array` can't be split evenly, the final chunk will be the remaining elements.\n *\n * @param size - The length of the chunk.\n * @signature\n *    chunk(size)(array)\n * @example\n *    chunk(2)(['a', 'b', 'c', 'd']) // => [['a', 'b'], ['c', 'd']]\n *    chunk(3)(['a', 'b', 'c', 'd']) // => [['a', 'b', 'c'], ['d']]\n * @dataLast\n * @category Array\n */\nexport function chunk<N extends number>(\n  size: N,\n): <T extends IterableContainer>(array: T) => Chunk<T, N>;\n\nexport function chunk(...args: ReadonlyArray<unknown>): unknown {\n  return curry(chunkImplementation, args);\n}\n\nfunction chunkImplementation<T>(data: ReadonlyArray<T>, size: number): Array<Array<T>> {\n  if (size < 1) {\n    throw new RangeError(\n      `chunk: A chunk size of '${size.toString()}' would result in an infinite array`,\n    );\n  }\n\n  if (data.length === 0) {\n    return [];\n  }\n\n  if (size >= data.length) {\n    // Optimized for when there is only one chunk.\n    return [[...data]];\n  }\n\n  const chunks = Math.ceil(data.length / size);\n\n  // eslint-disable-next-line unicorn/no-new-array -- This is OK, a sparse array allows us to handle very large arrays more efficiently.\n  const result = new Array<Array<T>>(chunks);\n\n  if (size === 1) {\n    // Optimized for when we don't need slice.\n    for (const [index, item] of data.entries()) {\n      result[index] = [item];\n    }\n  } else {\n    for (let index = 0; index < chunks; index += 1) {\n      const start = index * size;\n      result[index] = data.slice(start, start + size);\n    }\n  }\n\n  return result;\n}\n"],"mappings":"mCAkOA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAqB,EAAK,CAGzC,SAAS,EAAuB,EAAwB,EAA+B,CACrF,GAAI,EAAO,EACT,MAAU,WACR,2BAA2B,EAAK,UAAU,CAAC,qCAC5C,CAGH,GAAI,EAAK,SAAW,EAClB,MAAO,EAAE,CAGX,GAAI,GAAQ,EAAK,OAEf,MAAO,CAAC,CAAC,GAAG,EAAK,CAAC,CAGpB,IAAM,EAAS,KAAK,KAAK,EAAK,OAAS,EAAK,CAGtC,EAAa,MAAgB,EAAO,CAE1C,GAAI,IAAS,EAEX,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,SAAS,CACxC,EAAO,GAAS,CAAC,EAAK,MAGxB,IAAK,IAAI,EAAQ,EAAG,EAAQ,EAAQ,GAAS,EAAG,CAC9C,IAAM,EAAQ,EAAQ,EACtB,EAAO,GAAS,EAAK,MAAM,EAAO,EAAQ,EAAK,CAInD,OAAO"}

package/dist/clamp.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,{max:t,min:n}){return n!==void 0&&e<n?n:t!==void 0&&e>t?t:e}exports.clamp=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,{max:t,min:n}){return n!==void 0&&e<n?n:t!==void 0&&e>t?t:e}exports.clamp=t;
+//# sourceMappingURL=clamp.cjs.map

package/dist/clamp.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"clamp.cjs","names":["curry"],"sources":["../src/clamp.ts"],"sourcesContent":["import { curry } from './curry';\n\ninterface Limits {\n  readonly min?: number;\n  readonly max?: number;\n}\n\n/**\n * Clamp the given value within the inclusive min and max bounds.\n *\n * @param value - The number.\n * @param limits - The bounds limits.\n * @signature\n *    clamp(value, { min, max });\n * @example\n *    clamp(10, { min: 20 }) // => 20\n *    clamp(10, { max: 5 }) // => 5\n *    clamp(10, { max: 20, min: 5 }) // => 10\n * @dataFirst\n * @category Number\n */\nexport function clamp(value: number, limits: Limits): number;\n\n/**\n * Clamp the given value within the inclusive min and max bounds.\n *\n * @param limits - The bounds limits.\n * @signature\n *    clamp({ min, max })(value);\n * @example\n *    clamp({ min: 20 })(10) // => 20\n *    clamp({ max: 5 })(10) // => 5\n *    clamp({ max: 20, min: 5 })(10) // => 10\n * @dataLast\n * @category Number\n */\nexport function clamp(limits: Limits): (value: number) => number;\n\nexport function clamp(...args: ReadonlyArray<unknown>): unknown {\n  return curry(clampImplementation, args);\n}\n\nfunction clampImplementation(value: number, { max, min }: Limits): number {\n  if (min !== undefined && value < min) {\n    return min;\n  }\n\n  if (max !== undefined && value > max) {\n    return max;\n  }\n\n  return value;\n}\n"],"mappings":"kGAsCA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAOA,EAAAA,MAAM,EAAqB,EAAK,CAGzC,SAAS,EAAoB,EAAe,CAAE,MAAK,OAAuB,CASxE,OARI,IAAQ,IAAA,IAAa,EAAQ,EACxB,EAGL,IAAQ,IAAA,IAAa,EAAQ,EACxB,EAGF"}

package/dist/clamp.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,{max:t,min:n}){return n!==void 0&&e<n?n:t!==void 0&&e>t?t:e}export{t as clamp};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,{max:t,min:n}){return n!==void 0&&e<n?n:t!==void 0&&e>t?t:e}export{t as clamp};
 //# sourceMappingURL=clamp.js.map

package/dist/clamp.js.map

@@ -1 +1 @@
-{"version":3,"file":"clamp.js","names":[],"sources":["../src/clamp.ts"],"sourcesContent":["import { curry } from './curry';\n\ninterface Limits {\n  readonly max?: number;\n  readonly min?: number;\n}\n\n/**\n * Clamp the given value within the inclusive min and max bounds.\n *\n * @param value - The number.\n * @param limits - The bounds limits.\n * @signature\n *    P.clamp(value, { min, max });\n * @example\n *    clamp(10, { min: 20 }) // => 20\n *    clamp(10, { max: 5 }) // => 5\n *    clamp(10, { max: 20, min: 5 }) // => 10\n * @dataFirst\n * @category Number\n */\nexport function clamp(value: number, limits: Limits): number;\n\n/**\n * Clamp the given value within the inclusive min and max bounds.\n *\n * @param limits - The bounds limits.\n * @signature\n *    P.clamp({ min, max })(value);\n * @example\n *    clamp({ min: 20 })(10) // => 20\n *    clamp({ max: 5 })(10) // => 5\n *    clamp({ max: 20, min: 5 })(10) // => 10\n * @dataLast\n * @category Number\n */\nexport function clamp(limits: Limits): (value: number) => number;\n\nexport function clamp(...args: ReadonlyArray<unknown>): unknown {\n  return curry(clampImplementation, args);\n}\n\nfunction clampImplementation(value: number, { max, min }: Limits): number {\n  if (min !== undefined && value < min) {\n    return min;\n  }\n\n  if (max !== undefined && value > max) {\n    return max;\n  }\n\n  return value;\n}\n"],"mappings":"wCAsCA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAqB,EAAK,CAGzC,SAAS,EAAoB,EAAe,CAAE,MAAK,OAAuB,CASxE,OARI,IAAQ,IAAA,IAAa,EAAQ,EACxB,EAGL,IAAQ,IAAA,IAAa,EAAQ,EACxB,EAGF"}
+{"version":3,"file":"clamp.js","names":[],"sources":["../src/clamp.ts"],"sourcesContent":["import { curry } from './curry';\n\ninterface Limits {\n  readonly min?: number;\n  readonly max?: number;\n}\n\n/**\n * Clamp the given value within the inclusive min and max bounds.\n *\n * @param value - The number.\n * @param limits - The bounds limits.\n * @signature\n *    clamp(value, { min, max });\n * @example\n *    clamp(10, { min: 20 }) // => 20\n *    clamp(10, { max: 5 }) // => 5\n *    clamp(10, { max: 20, min: 5 }) // => 10\n * @dataFirst\n * @category Number\n */\nexport function clamp(value: number, limits: Limits): number;\n\n/**\n * Clamp the given value within the inclusive min and max bounds.\n *\n * @param limits - The bounds limits.\n * @signature\n *    clamp({ min, max })(value);\n * @example\n *    clamp({ min: 20 })(10) // => 20\n *    clamp({ max: 5 })(10) // => 5\n *    clamp({ max: 20, min: 5 })(10) // => 10\n * @dataLast\n * @category Number\n */\nexport function clamp(limits: Limits): (value: number) => number;\n\nexport function clamp(...args: ReadonlyArray<unknown>): unknown {\n  return curry(clampImplementation, args);\n}\n\nfunction clampImplementation(value: number, { max, min }: Limits): number {\n  if (min !== undefined && value < min) {\n    return min;\n  }\n\n  if (max !== undefined && value > max) {\n    return max;\n  }\n\n  return value;\n}\n"],"mappings":"mCAsCA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAqB,EAAK,CAGzC,SAAS,EAAoB,EAAe,CAAE,MAAK,OAAuB,CASxE,OARI,IAAQ,IAAA,IAAa,EAAQ,EACxB,EAGL,IAAQ,IAAA,IAAa,EAAQ,EACxB,EAGF"}

package/dist/clone.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t=[],n=[]){if(typeof e==`function`)return e;if(typeof e!=`object`||!e)return structuredClone(e);let a=Object.getPrototypeOf(e);if(!Array.isArray(e)&&a!==null&&a!==Object.prototype)return structuredClone(e);let o=t.indexOf(e);return o>=0?n[o]:(t.push(e),Array.isArray(e)?i(e,t,n):r(e,t,n))}function r(e,t,r){let i={};r.push(i);for(let[a,o]of Object.entries(e))i[a]=n(o,t,r);return i}function i(e,t,r){let i=[];r.push(i);for(let[a,o]of e.entries())i[a]=n(o,t,r);return i}exports.clone=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t=[],n=[]){if(typeof e==`function`)return e;if(typeof e!=`object`||!e)return structuredClone(e);let a=Object.getPrototypeOf(e);if(!Array.isArray(e)&&a!==null&&a!==Object.prototype)return structuredClone(e);let o=t.indexOf(e);return o===-1?(t.push(e),Array.isArray(e)?i(e,t,n):r(e,t,n)):n[o]}function r(e,t,r){let i={};r.push(i);for(let[a,o]of Object.entries(e))i[a]=n(o,t,r);return i}function i(e,t,r){let i=[];r.push(i);for(let[a,o]of e.entries())i[a]=n(o,t,r);return i}exports.clone=t;
+//# sourceMappingURL=clone.cjs.map

package/dist/clone.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone.cjs","names":["curry"],"sources":["../src/clone.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Creates a deep copy of the value. Supported types: [plain objects](#isPlainObject),\n * `Array`, `number`, `string`, `boolean`, `Date`, and `RegExp`. Functions are\n * assigned by reference rather than copied. Class instances or any other\n * built-in type that isn't mentioned above are not supported (but might\n * work).\n *\n * @param data - The object to clone.\n * @signature\n *   clone(data)\n * @example\n *   clone({foo: 'bar'}) // {foo: 'bar'}\n * @dataFirst\n * @category Object\n */\nexport function clone<T>(data: T): T;\n\n/**\n * Creates a deep copy of the value. Supported types: [plain objects](#isPlainObject),\n * `Array`, `number`, `string`, `boolean`, `Date`, and `RegExp`. Functions are\n * assigned by reference rather than copied. Class instances or any other\n * built-in type that isn't mentioned above are not supported (but might\n * work).\n *\n * @signature\n *   clone()(data)\n * @example\n *   pipe({foo: 'bar'}, clone()) // {foo: 'bar'}\n * @dataLast\n * @category Object\n */\nexport function clone(): <T>(data: T) => T;\n\nexport function clone(...args: ReadonlyArray<unknown>): unknown {\n  return curry(cloneImplementation, args);\n}\n\nfunction cloneImplementation<T>(\n  value: T,\n  refFrom: Array<unknown> = [],\n  refTo: Array<unknown> = [],\n): T {\n  if (typeof value === 'function') {\n    // Functions aren't cloned, we return the same instance.\n    return value;\n  }\n\n  if (typeof value !== 'object' || value === null) {\n    // Only objects are interesting when cloning, everything else can use\n    // whatever JS does by default.\n    return structuredClone(value);\n  }\n\n  const prototype = Object.getPrototypeOf(value);\n  if (\n    !Array.isArray(value)\n    // Keep this check in sync with the same check in the impl of\n    // `isPlainObject`.\n    && prototype !== null\n    && prototype !== Object.prototype\n  ) {\n    // Our cloning logic is only designed for plain objects and arrays; other\n    // object types (like `Date`, `RegExp`, `File`, and user-defined classes)\n    // wouldn't clone properly. We fallback to the native cloning for them.\n    return structuredClone(value);\n  }\n\n  // In order to support cyclic/self-referential structures, and to support\n  // functions _within_ objects, we need to have our own cloning logic.\n\n  // First we check if we've already cloned this value.\n  const idx = refFrom.indexOf(value);\n  if (idx !== -1) {\n    return refTo[idx] as T;\n  }\n  // And if we haven't, we add it to our list of seen values so that it is kept\n  // and clone the deep structure.\n  refFrom.push(value);\n  return Array.isArray(value)\n    ? deepCloneArray(value, refFrom, refTo)\n    : deepCloneObject(value, refFrom, refTo);\n}\n\nfunction deepCloneObject<T extends object>(\n  value: T,\n  refFrom: Array<unknown>,\n  refTo: Array<unknown>,\n): T {\n  const copiedValue: Record<PropertyKey, unknown> = {};\n\n  // It's important to first push the cloned ref so that it's index is kept in\n  // sync with the ref to the original value in refFrom.\n  refTo.push(copiedValue);\n\n  for (const [k, v] of Object.entries(value)) {\n    copiedValue[k] = cloneImplementation(v, refFrom, refTo);\n  }\n\n  return copiedValue as T;\n}\n\nfunction deepCloneArray<T extends ReadonlyArray<unknown>>(\n  value: T,\n  refFrom: Array<unknown>,\n  refTo: Array<unknown>,\n): T {\n  const copiedValue: Array<unknown> = [];\n\n  // It's important to first push the cloned ref so that it's index is kept in\n  // sync with the ref to the original value in refFrom.\n  refTo.push(copiedValue);\n\n  for (const [index, item] of value.entries()) {\n    copiedValue[index] = cloneImplementation(item, refFrom, refTo);\n  }\n\n  return copiedValue as unknown as T;\n}\n"],"mappings":"kGAmCA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAOA,EAAAA,MAAM,EAAqB,EAAK,CAGzC,SAAS,EACP,EACA,EAA0B,EAAE,CAC5B,EAAwB,EAAE,CACvB,CACH,GAAI,OAAO,GAAU,WAEnB,OAAO,EAGT,GAAI,OAAO,GAAU,WAAY,EAG/B,OAAO,gBAAgB,EAAM,CAG/B,IAAM,EAAY,OAAO,eAAe,EAAM,CAC9C,GACE,CAAC,MAAM,QAAQ,EAAM,EAGlB,IAAc,MACd,IAAc,OAAO,UAKxB,OAAO,gBAAgB,EAAM,CAO/B,IAAM,EAAM,EAAQ,QAAQ,EAAM,CAOlC,OANI,IAAQ,IAKZ,EAAQ,KAAK,EAAM,CACZ,MAAM,QAAQ,EAAM,CACvB,EAAe,EAAO,EAAS,EAAM,CACrC,EAAgB,EAAO,EAAS,EAAM,EAPjC,EAAM,GAUjB,SAAS,EACP,EACA,EACA,EACG,CACH,IAAM,EAA4C,EAAE,CAIpD,EAAM,KAAK,EAAY,CAEvB,IAAK,GAAM,CAAC,EAAG,KAAM,OAAO,QAAQ,EAAM,CACxC,EAAY,GAAK,EAAoB,EAAG,EAAS,EAAM,CAGzD,OAAO,EAGT,SAAS,EACP,EACA,EACA,EACG,CACH,IAAM,EAA8B,EAAE,CAItC,EAAM,KAAK,EAAY,CAEvB,IAAK,GAAM,CAAC,EAAO,KAAS,EAAM,SAAS,CACzC,EAAY,GAAS,EAAoB,EAAM,EAAS,EAAM,CAGhE,OAAO"}

package/dist/clone.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t=[],n=[]){if(typeof e==`function`)return e;if(typeof e!=`object`||!e)return structuredClone(e);let a=Object.getPrototypeOf(e);if(!Array.isArray(e)&&a!==null&&a!==Object.prototype)return structuredClone(e);let o=t.indexOf(e);return o>=0?n[o]:(t.push(e),Array.isArray(e)?i(e,t,n):r(e,t,n))}function r(e,t,r){let i={};r.push(i);for(let[a,o]of Object.entries(e))i[a]=n(o,t,r);return i}function i(e,t,r){let i=[];r.push(i);for(let[a,o]of e.entries())i[a]=n(o,t,r);return i}export{t as clone};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t=[],n=[]){if(typeof e==`function`)return e;if(typeof e!=`object`||!e)return structuredClone(e);let a=Object.getPrototypeOf(e);if(!Array.isArray(e)&&a!==null&&a!==Object.prototype)return structuredClone(e);let o=t.indexOf(e);return o===-1?(t.push(e),Array.isArray(e)?i(e,t,n):r(e,t,n)):n[o]}function r(e,t,r){let i={};r.push(i);for(let[a,o]of Object.entries(e))i[a]=n(o,t,r);return i}function i(e,t,r){let i=[];r.push(i);for(let[a,o]of e.entries())i[a]=n(o,t,r);return i}export{t as clone};
 //# sourceMappingURL=clone.js.map

package/dist/clone.js.map

@@ -1 +1 @@
-{"version":3,"file":"clone.js","names":["copiedValue: Record<PropertyKey, unknown>","copiedValue: Array<unknown>"],"sources":["../src/clone.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Creates a deep copy of the value. Supported types: [plain objects](#isPlainObject),\n * `Array`, `number`, `string`, `boolean`, `Date`, and `RegExp`. Functions are\n * assigned by reference rather than copied. Class instances or any other\n * built-in type that isn't mentioned above are not supported (but might\n * work).\n *\n * @param data - The object to clone.\n * @signature\n *   P.clone(data)\n * @example\n *   P.clone({foo: 'bar'}) // {foo: 'bar'}\n * @dataFirst\n * @category Object\n */\nexport function clone<T>(data: T): T;\n\n/**\n * Creates a deep copy of the value. Supported types: [plain objects](#isPlainObject),\n * `Array`, `number`, `string`, `boolean`, `Date`, and `RegExp`. Functions are\n * assigned by reference rather than copied. Class instances or any other\n * built-in type that isn't mentioned above are not supported (but might\n * work).\n *\n * @signature\n *   P.clone()(data)\n * @example\n *   P.pipe({foo: 'bar'}, P.clone()) // {foo: 'bar'}\n * @dataLast\n * @category Object\n */\nexport function clone(): <T>(data: T) => T;\n\nexport function clone(...args: ReadonlyArray<unknown>): unknown {\n  return curry(cloneImplementation, args);\n}\n\nfunction cloneImplementation<T>(\n  value: T,\n  refFrom: Array<unknown> = [],\n  refTo: Array<unknown> = [],\n): T {\n  if (typeof value === 'function') {\n    // Functions aren't cloned, we return the same instance.\n    return value;\n  }\n\n  if (typeof value !== 'object' || value === null) {\n    // Only objects are interesting when cloning, everything else can use\n    // whatever JS does by default.\n    return structuredClone(value);\n  }\n\n  const prototype = Object.getPrototypeOf(value);\n  if (\n    !Array.isArray(value)\n    // Keep this check in sync with the same check in the impl of\n    // `isPlainObject`.\n    && prototype !== null\n    && prototype !== Object.prototype\n  ) {\n    // Our cloning logic is only designed for plain objects and arrays; other\n    // object types (like `Date`, `RegExp`, `File`, and user-defined classes)\n    // wouldn't clone properly. We fallback to the native cloning for them.\n    return structuredClone(value);\n  }\n\n  /**\n   * In order to support cyclic/self-referential structures,\n   * and to support functions _within_ objects,\n   * we need to have our own cloning logic.\n   */\n\n  // First we check if we've already cloned this value.\n  const idx = refFrom.indexOf(value);\n  if (idx >= 0) {\n    return refTo[idx] as T;\n  }\n  /**\n   * And if we haven't, we add it to our list of seen values so that it is kept\n   * and clone the deep structure.\n   */\n  refFrom.push(value);\n  return Array.isArray(value)\n    ? deepCloneArray(value, refFrom, refTo)\n    : deepCloneObject(value, refFrom, refTo);\n}\n\nfunction deepCloneObject<T extends object>(\n  value: T,\n  refFrom: Array<unknown>,\n  refTo: Array<unknown>,\n): T {\n  const copiedValue: Record<PropertyKey, unknown> = {};\n\n  /**\n   * It's important to first push the cloned ref so that it's index is kept in\n   * sync with the ref to the original value in refFrom.\n   */\n  refTo.push(copiedValue);\n\n  for (const [k, v] of Object.entries(value)) {\n    copiedValue[k] = cloneImplementation(v, refFrom, refTo);\n  }\n\n  return copiedValue as T;\n}\n\nfunction deepCloneArray<T extends ReadonlyArray<unknown>>(\n  value: T,\n  refFrom: Array<unknown>,\n  refTo: Array<unknown>,\n): T {\n  const copiedValue: Array<unknown> = [];\n\n  /**\n   * It's important to first push the cloned ref so that it's index is kept in\n   * sync with the ref to the original value in refFrom.\n   */\n  refTo.push(copiedValue);\n\n  for (const [index, item] of value.entries()) {\n    copiedValue[index] = cloneImplementation(item, refFrom, refTo);\n  }\n\n  return copiedValue as unknown as T;\n}\n"],"mappings":"wCAmCA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAqB,EAAK,CAGzC,SAAS,EACP,EACA,EAA0B,EAAE,CAC5B,EAAwB,EAAE,CACvB,CACH,GAAI,OAAO,GAAU,WAEnB,OAAO,EAGT,GAAI,OAAO,GAAU,WAAY,EAG/B,OAAO,gBAAgB,EAAM,CAG/B,IAAM,EAAY,OAAO,eAAe,EAAM,CAC9C,GACE,CAAC,MAAM,QAAQ,EAAM,EAGlB,IAAc,MACd,IAAc,OAAO,UAKxB,OAAO,gBAAgB,EAAM,CAU/B,IAAM,EAAM,EAAQ,QAAQ,EAAM,CASlC,OARI,GAAO,EACF,EAAM,IAMf,EAAQ,KAAK,EAAM,CACZ,MAAM,QAAQ,EAAM,CACvB,EAAe,EAAO,EAAS,EAAM,CACrC,EAAgB,EAAO,EAAS,EAAM,EAG5C,SAAS,EACP,EACA,EACA,EACG,CACH,IAAMA,EAA4C,EAAE,CAMpD,EAAM,KAAK,EAAY,CAEvB,IAAK,GAAM,CAAC,EAAG,KAAM,OAAO,QAAQ,EAAM,CACxC,EAAY,GAAK,EAAoB,EAAG,EAAS,EAAM,CAGzD,OAAO,EAGT,SAAS,EACP,EACA,EACA,EACG,CACH,IAAMC,EAA8B,EAAE,CAMtC,EAAM,KAAK,EAAY,CAEvB,IAAK,GAAM,CAAC,EAAO,KAAS,EAAM,SAAS,CACzC,EAAY,GAAS,EAAoB,EAAM,EAAS,EAAM,CAGhE,OAAO"}
+{"version":3,"file":"clone.js","names":[],"sources":["../src/clone.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Creates a deep copy of the value. Supported types: [plain objects](#isPlainObject),\n * `Array`, `number`, `string`, `boolean`, `Date`, and `RegExp`. Functions are\n * assigned by reference rather than copied. Class instances or any other\n * built-in type that isn't mentioned above are not supported (but might\n * work).\n *\n * @param data - The object to clone.\n * @signature\n *   clone(data)\n * @example\n *   clone({foo: 'bar'}) // {foo: 'bar'}\n * @dataFirst\n * @category Object\n */\nexport function clone<T>(data: T): T;\n\n/**\n * Creates a deep copy of the value. Supported types: [plain objects](#isPlainObject),\n * `Array`, `number`, `string`, `boolean`, `Date`, and `RegExp`. Functions are\n * assigned by reference rather than copied. Class instances or any other\n * built-in type that isn't mentioned above are not supported (but might\n * work).\n *\n * @signature\n *   clone()(data)\n * @example\n *   pipe({foo: 'bar'}, clone()) // {foo: 'bar'}\n * @dataLast\n * @category Object\n */\nexport function clone(): <T>(data: T) => T;\n\nexport function clone(...args: ReadonlyArray<unknown>): unknown {\n  return curry(cloneImplementation, args);\n}\n\nfunction cloneImplementation<T>(\n  value: T,\n  refFrom: Array<unknown> = [],\n  refTo: Array<unknown> = [],\n): T {\n  if (typeof value === 'function') {\n    // Functions aren't cloned, we return the same instance.\n    return value;\n  }\n\n  if (typeof value !== 'object' || value === null) {\n    // Only objects are interesting when cloning, everything else can use\n    // whatever JS does by default.\n    return structuredClone(value);\n  }\n\n  const prototype = Object.getPrototypeOf(value);\n  if (\n    !Array.isArray(value)\n    // Keep this check in sync with the same check in the impl of\n    // `isPlainObject`.\n    && prototype !== null\n    && prototype !== Object.prototype\n  ) {\n    // Our cloning logic is only designed for plain objects and arrays; other\n    // object types (like `Date`, `RegExp`, `File`, and user-defined classes)\n    // wouldn't clone properly. We fallback to the native cloning for them.\n    return structuredClone(value);\n  }\n\n  // In order to support cyclic/self-referential structures, and to support\n  // functions _within_ objects, we need to have our own cloning logic.\n\n  // First we check if we've already cloned this value.\n  const idx = refFrom.indexOf(value);\n  if (idx !== -1) {\n    return refTo[idx] as T;\n  }\n  // And if we haven't, we add it to our list of seen values so that it is kept\n  // and clone the deep structure.\n  refFrom.push(value);\n  return Array.isArray(value)\n    ? deepCloneArray(value, refFrom, refTo)\n    : deepCloneObject(value, refFrom, refTo);\n}\n\nfunction deepCloneObject<T extends object>(\n  value: T,\n  refFrom: Array<unknown>,\n  refTo: Array<unknown>,\n): T {\n  const copiedValue: Record<PropertyKey, unknown> = {};\n\n  // It's important to first push the cloned ref so that it's index is kept in\n  // sync with the ref to the original value in refFrom.\n  refTo.push(copiedValue);\n\n  for (const [k, v] of Object.entries(value)) {\n    copiedValue[k] = cloneImplementation(v, refFrom, refTo);\n  }\n\n  return copiedValue as T;\n}\n\nfunction deepCloneArray<T extends ReadonlyArray<unknown>>(\n  value: T,\n  refFrom: Array<unknown>,\n  refTo: Array<unknown>,\n): T {\n  const copiedValue: Array<unknown> = [];\n\n  // It's important to first push the cloned ref so that it's index is kept in\n  // sync with the ref to the original value in refFrom.\n  refTo.push(copiedValue);\n\n  for (const [index, item] of value.entries()) {\n    copiedValue[index] = cloneImplementation(item, refFrom, refTo);\n  }\n\n  return copiedValue as unknown as T;\n}\n"],"mappings":"mCAmCA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAqB,EAAK,CAGzC,SAAS,EACP,EACA,EAA0B,EAAE,CAC5B,EAAwB,EAAE,CACvB,CACH,GAAI,OAAO,GAAU,WAEnB,OAAO,EAGT,GAAI,OAAO,GAAU,WAAY,EAG/B,OAAO,gBAAgB,EAAM,CAG/B,IAAM,EAAY,OAAO,eAAe,EAAM,CAC9C,GACE,CAAC,MAAM,QAAQ,EAAM,EAGlB,IAAc,MACd,IAAc,OAAO,UAKxB,OAAO,gBAAgB,EAAM,CAO/B,IAAM,EAAM,EAAQ,QAAQ,EAAM,CAOlC,OANI,IAAQ,IAKZ,EAAQ,KAAK,EAAM,CACZ,MAAM,QAAQ,EAAM,CACvB,EAAe,EAAO,EAAS,EAAM,CACrC,EAAgB,EAAO,EAAS,EAAM,EAPjC,EAAM,GAUjB,SAAS,EACP,EACA,EACA,EACG,CACH,IAAM,EAA4C,EAAE,CAIpD,EAAM,KAAK,EAAY,CAEvB,IAAK,GAAM,CAAC,EAAG,KAAM,OAAO,QAAQ,EAAM,CACxC,EAAY,GAAK,EAAoB,EAAG,EAAS,EAAM,CAGzD,OAAO,EAGT,SAAS,EACP,EACA,EACA,EACG,CACH,IAAM,EAA8B,EAAE,CAItC,EAAM,KAAK,EAAY,CAEvB,IAAK,GAAM,CAAC,EAAO,KAAS,EAAM,SAAS,CACzC,EAAY,GAAS,EAAoB,EAAM,EAAS,EAAM,CAGhE,OAAO"}

package/dist/concat.cjs

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

package/dist/concat.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"concat.cjs","names":["curry"],"sources":["../src/concat.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Merge two or more arrays. This method does not change the existing arrays,\n * but instead returns a new array, even if the other array is empty.\n *\n * @param data - The first items, these would be at the beginning of the new\n * array.\n * @param other - The remaining items, these would be at the end of the new\n * array.\n * @returns A new array with the items of the first array followed by the items\n * of the second array.\n * @signature\n *    concat(data, other);\n * @example\n *    concat([1, 2, 3], ['a']) // [1, 2, 3, 'a']\n * @dataFirst\n * @category Array\n */\nexport function concat<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n>(data: T1, other: T2): [...T1, ...T2];\n\n/**\n * Merge two or more arrays. This method does not change the existing arrays,\n * but instead returns a new array, even if the other array is empty.\n *\n * @param other - The remaining items, these would be at the end of the new\n * array.\n * @returns A new array with the items of the first array followed by the items\n * of the second array.\n * @signature\n *    concat(arr2)(arr1);\n * @example\n *    concat(['a'])([1, 2, 3]) // [1, 2, 3, 'a']\n * @dataLast\n * @category Array\n */\nexport function concat<T2 extends IterableContainer>(\n  other: T2,\n): <T1 extends IterableContainer>(data: T1) => [...T1, ...T2];\n\nexport function concat(...args: ReadonlyArray<unknown>): unknown {\n  return curry(concatImplementation, args);\n}\n\nfunction concatImplementation<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n>(arr1: T1, arr2: T2): [...T1, ...T2] {\n  return [...arr1, ...arr2];\n}\n"],"mappings":"kGA4CA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAOA,EAAAA,MAAM,EAAsB,EAAK,CAG1C,SAAS,EAGP,EAAU,EAA0B,CACpC,MAAO,CAAC,GAAG,EAAM,GAAG,EAAK"}

package/dist/concat.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){return[...e,...t]}export{t as concat};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t){return[...e,...t]}export{t as concat};
 //# sourceMappingURL=concat.js.map

package/dist/concat.js.map

@@ -1 +1 @@
-{"version":3,"file":"concat.js","names":[],"sources":["../src/concat.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Merge two or more arrays. This method does not change the existing arrays,\n * but instead returns a new array, even if the other array is empty.\n *\n * @param data - The first items, these would be at the beginning of the new\n * array.\n * @param other - The remaining items, these would be at the end of the new\n * array.\n * @returns A new array with the items of the first array followed by the items\n * of the second array.\n * @signature\n *    P.concat(data, other);\n * @example\n *    P.concat([1, 2, 3], ['a']) // [1, 2, 3, 'a']\n * @dataFirst\n * @category Array\n */\nexport function concat<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n>(data: T1, other: T2): [...T1, ...T2];\n\n/**\n * Merge two or more arrays. This method does not change the existing arrays,\n * but instead returns a new array, even if the other array is empty.\n *\n * @param other - The remaining items, these would be at the end of the new\n * array.\n * @returns A new array with the items of the first array followed by the items\n * of the second array.\n * @signature\n *    P.concat(arr2)(arr1);\n * @example\n *    P.concat(['a'])([1, 2, 3]) // [1, 2, 3, 'a']\n * @dataLast\n * @category Array\n */\nexport function concat<T2 extends IterableContainer>(\n  other: T2,\n): <T1 extends IterableContainer>(data: T1) => [...T1, ...T2];\n\nexport function concat(...args: ReadonlyArray<unknown>): unknown {\n  return curry(concatImplementation, args);\n}\n\nfunction concatImplementation<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n>(\n  arr1: T1,\n  arr2: T2,\n): [...T1, ...T2] {\n  return [...arr1, ...arr2];\n};\n"],"mappings":"wCA4CA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EAIP,EACA,EACgB,CAChB,MAAO,CAAC,GAAG,EAAM,GAAG,EAAK"}
+{"version":3,"file":"concat.js","names":[],"sources":["../src/concat.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Merge two or more arrays. This method does not change the existing arrays,\n * but instead returns a new array, even if the other array is empty.\n *\n * @param data - The first items, these would be at the beginning of the new\n * array.\n * @param other - The remaining items, these would be at the end of the new\n * array.\n * @returns A new array with the items of the first array followed by the items\n * of the second array.\n * @signature\n *    concat(data, other);\n * @example\n *    concat([1, 2, 3], ['a']) // [1, 2, 3, 'a']\n * @dataFirst\n * @category Array\n */\nexport function concat<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n>(data: T1, other: T2): [...T1, ...T2];\n\n/**\n * Merge two or more arrays. This method does not change the existing arrays,\n * but instead returns a new array, even if the other array is empty.\n *\n * @param other - The remaining items, these would be at the end of the new\n * array.\n * @returns A new array with the items of the first array followed by the items\n * of the second array.\n * @signature\n *    concat(arr2)(arr1);\n * @example\n *    concat(['a'])([1, 2, 3]) // [1, 2, 3, 'a']\n * @dataLast\n * @category Array\n */\nexport function concat<T2 extends IterableContainer>(\n  other: T2,\n): <T1 extends IterableContainer>(data: T1) => [...T1, ...T2];\n\nexport function concat(...args: ReadonlyArray<unknown>): unknown {\n  return curry(concatImplementation, args);\n}\n\nfunction concatImplementation<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n>(arr1: T1, arr2: T2): [...T1, ...T2] {\n  return [...arr1, ...arr2];\n}\n"],"mappings":"mCA4CA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EAGP,EAAU,EAA0B,CACpC,MAAO,CAAC,GAAG,EAAM,GAAG,EAAK"}

package/dist/conditional-3wcaMG9k.cjs

@@ -0,0 +1,2 @@
+function e(e,t,n){return e(n[0])?e=>t(e,...n):t(...n)}function t(...t){return e(r,n,t)}function n(e,...t){for(let n of t){if(typeof n==`function`)return n(e);let[t,r]=n;if(t(e))return r(e)}throw Error(`conditional: data failed for all cases`)}function r(e){if(!Array.isArray(e))return!1;let[t,n,...r]=e;return typeof t==`function`&&t.length<=1&&typeof n==`function`&&n.length<=1&&r.length===0}Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=conditional-3wcaMG9k.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"conditional-3wcaMG9k.cjs","names":[],"sources":["../src/internal/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

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