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

package/README.md

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

package/changes.json

@@ -1,5 +1,5 @@
 {
   "bumped": {},
-  "timestamp": "2026-03-31T12:26:29.375Z",
+  "timestamp": "2026-08-16T00:27:39.570Z",
   "totalUpdated": 0
 }

package/dist/add.cjs

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

package/dist/add.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"add.cjs","names":["purry"],"sources":["../src/add.ts"],"sourcesContent":["import { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(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.\nconst addImplementation = (value: number, addend: number): number =>\n  value + addend;\n"],"mappings":"kGAkCA,SAAgB,EAAI,GAAG,EAAmC,CACxD,OAAOA,EAAAA,MAAM,EAAmB,EAAK,CAKvC,MAAM,GAAqB,EAAe,IACxC,EAAQ"}
+{"version":3,"file":"add.cjs","names":["purry"],"sources":["../src/add.ts"],"sourcesContent":["import { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(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.\nconst addImplementation = (value: number, addend: number): number =>\n  value + addend;\n"],"mappings":"kGAkCA,SAAgB,EAAI,GAAG,EAAmC,CACxD,OAAOA,EAAAA,MAAM,EAAmB,CAAI,CACtC,CAIA,MAAM,GAAqB,EAAe,IACxC,EAAQ"}

package/dist/add.js.map

@@ -1 +1 @@
-{"version":3,"file":"add.js","names":[],"sources":["../src/add.ts"],"sourcesContent":["import { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(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.\nconst addImplementation = (value: number, addend: number): number =>\n  value + addend;\n"],"mappings":"mCAkCA,SAAgB,EAAI,GAAG,EAAmC,CACxD,OAAO,EAAM,EAAmB,EAAK,CAKvC,MAAM,GAAqB,EAAe,IACxC,EAAQ"}
+{"version":3,"file":"add.js","names":[],"sources":["../src/add.ts"],"sourcesContent":["import { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(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.\nconst addImplementation = (value: number, addend: number): number =>\n  value + addend;\n"],"mappings":"mCAkCA,SAAgB,EAAI,GAAG,EAAmC,CACxD,OAAO,EAAM,EAAmB,CAAI,CACtC,CAIA,MAAM,GAAqB,EAAe,IACxC,EAAQ"}

package/dist/addProp.cjs

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

package/dist/addProp.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"addProp.cjs","names":["purry"],"sources":["../src/addProp.ts"],"sourcesContent":["import type { UpsertProp } from \"./internal/types/UpsertProp\";\nimport { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(addPropImplementation, args);\n}\n\nconst 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  ({ ...obj, [prop]: value });\n"],"mappings":"kGAmDA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,OAAOA,EAAAA,MAAM,EAAuB,EAAK,CAG3C,MAAM,GACJ,EACA,EACA,KAGC,CAAE,GAAG,GAAM,GAAO,EAAO"}
+{"version":3,"file":"addProp.cjs","names":["purry"],"sources":["../src/addProp.ts"],"sourcesContent":["import type { UpsertProp } from \"./internal/types/UpsertProp\";\nimport { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(addPropImplementation, args);\n}\n\nconst 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  ({ ...obj, [prop]: value });\n"],"mappings":"kGAmDA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,OAAOA,EAAAA,MAAM,EAAuB,CAAI,CAC1C,CAEA,MAAM,GACJ,EACA,EACA,KAGC,CAAE,GAAG,GAAM,GAAO,CAAM"}

package/dist/addProp.js.map

@@ -1 +1 @@
-{"version":3,"file":"addProp.js","names":[],"sources":["../src/addProp.ts"],"sourcesContent":["import type { UpsertProp } from \"./internal/types/UpsertProp\";\nimport { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(addPropImplementation, args);\n}\n\nconst 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  ({ ...obj, [prop]: value });\n"],"mappings":"mCAmDA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,OAAO,EAAM,EAAuB,EAAK,CAG3C,MAAM,GACJ,EACA,EACA,KAGC,CAAE,GAAG,GAAM,GAAO,EAAO"}
+{"version":3,"file":"addProp.js","names":[],"sources":["../src/addProp.ts"],"sourcesContent":["import type { UpsertProp } from \"./internal/types/UpsertProp\";\nimport { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(addPropImplementation, args);\n}\n\nconst 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  ({ ...obj, [prop]: value });\n"],"mappings":"mCAmDA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,OAAO,EAAM,EAAuB,CAAI,CAC1C,CAEA,MAAM,GACJ,EACA,EACA,KAGC,CAAE,GAAG,GAAM,GAAO,CAAM"}

package/dist/allPass.cjs

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

package/dist/allPass.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"allPass.cjs","names":["purry"],"sources":["../src/allPass.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\n/**\n * Determines whether all predicates return true for the input data.\n *\n * @param data - The input data for predicates.\n * @param fns - The list of predicates.\n * @signature\n *    allPass(data, fns)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    allPass(12, fns) // => true\n *    allPass(8, fns) // => false\n * @dataFirst\n * @category Array\n */\nexport function allPass<T>(\n  data: T,\n  fns: readonly ((data: T) => boolean)[],\n): boolean;\n\n/**\n * Determines whether all predicates return true for the input data.\n *\n * @param fns - The list of predicates.\n * @signature\n *    allPass(fns)(data)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    allPass(fns)(12) // => true\n *    allPass(fns)(8) // => false\n * @dataLast\n * @category Array\n */\nexport function allPass<T>(\n  fns: readonly ((data: T) => boolean)[],\n): (data: T) => boolean;\n\nexport function allPass(...args: readonly unknown[]): unknown {\n  return purry(allPassImplementation, args);\n}\n\nconst allPassImplementation = <T>(\n  data: T,\n  fns: readonly ((data: T) => boolean)[],\n): boolean => fns.every((fn) => fn(data));\n"],"mappings":"kGA0CA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,OAAOA,EAAAA,MAAM,EAAuB,EAAK,CAG3C,MAAM,GACJ,EACA,IACY,EAAI,MAAO,GAAO,EAAG,EAAK,CAAC"}
+{"version":3,"file":"allPass.cjs","names":["purry"],"sources":["../src/allPass.ts"],"sourcesContent":["/* eslint-disable unicorn/consistent-boolean-name --\n * TODO [>2] -- This rule is on-point! The function's name should communicate\n * more clearly that it returns a boolean value.\n */\n\nimport { purry } from \"./purry\";\n\n/**\n * Determines whether all predicates return true for the input data.\n *\n * @param data - The input data for predicates.\n * @param fns - The list of predicates.\n * @signature\n *    allPass(data, fns)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    allPass(12, fns) // => true\n *    allPass(8, fns) // => false\n * @dataFirst\n * @category Array\n */\nexport function allPass<T>(\n  data: T,\n  fns: readonly ((data: T) => boolean)[],\n): boolean;\n\n/**\n * Determines whether all predicates return true for the input data.\n *\n * @param fns - The list of predicates.\n * @signature\n *    allPass(fns)(data)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    allPass(fns)(12) // => true\n *    allPass(fns)(8) // => false\n * @dataLast\n * @category Array\n */\nexport function allPass<T>(\n  fns: readonly ((data: T) => boolean)[],\n): (data: T) => boolean;\n\nexport function allPass(...args: readonly unknown[]): unknown {\n  return purry(allPassImplementation, args);\n}\n\nconst allPassImplementation = <T>(\n  data: T,\n  fns: readonly ((data: T) => boolean)[],\n): boolean => fns.every((fn) => fn(data));\n"],"mappings":"kGA+CA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,OAAOA,EAAAA,MAAM,EAAuB,CAAI,CAC1C,CAEA,MAAM,GACJ,EACA,IACY,EAAI,MAAO,GAAO,EAAG,CAAI,CAAC"}

package/dist/allPass.js.map

@@ -1 +1 @@
-{"version":3,"file":"allPass.js","names":[],"sources":["../src/allPass.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\n/**\n * Determines whether all predicates return true for the input data.\n *\n * @param data - The input data for predicates.\n * @param fns - The list of predicates.\n * @signature\n *    allPass(data, fns)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    allPass(12, fns) // => true\n *    allPass(8, fns) // => false\n * @dataFirst\n * @category Array\n */\nexport function allPass<T>(\n  data: T,\n  fns: readonly ((data: T) => boolean)[],\n): boolean;\n\n/**\n * Determines whether all predicates return true for the input data.\n *\n * @param fns - The list of predicates.\n * @signature\n *    allPass(fns)(data)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    allPass(fns)(12) // => true\n *    allPass(fns)(8) // => false\n * @dataLast\n * @category Array\n */\nexport function allPass<T>(\n  fns: readonly ((data: T) => boolean)[],\n): (data: T) => boolean;\n\nexport function allPass(...args: readonly unknown[]): unknown {\n  return purry(allPassImplementation, args);\n}\n\nconst allPassImplementation = <T>(\n  data: T,\n  fns: readonly ((data: T) => boolean)[],\n): boolean => fns.every((fn) => fn(data));\n"],"mappings":"mCA0CA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,OAAO,EAAM,EAAuB,EAAK,CAG3C,MAAM,GACJ,EACA,IACY,EAAI,MAAO,GAAO,EAAG,EAAK,CAAC"}
+{"version":3,"file":"allPass.js","names":[],"sources":["../src/allPass.ts"],"sourcesContent":["/* eslint-disable unicorn/consistent-boolean-name --\n * TODO [>2] -- This rule is on-point! The function's name should communicate\n * more clearly that it returns a boolean value.\n */\n\nimport { purry } from \"./purry\";\n\n/**\n * Determines whether all predicates return true for the input data.\n *\n * @param data - The input data for predicates.\n * @param fns - The list of predicates.\n * @signature\n *    allPass(data, fns)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    allPass(12, fns) // => true\n *    allPass(8, fns) // => false\n * @dataFirst\n * @category Array\n */\nexport function allPass<T>(\n  data: T,\n  fns: readonly ((data: T) => boolean)[],\n): boolean;\n\n/**\n * Determines whether all predicates return true for the input data.\n *\n * @param fns - The list of predicates.\n * @signature\n *    allPass(fns)(data)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    allPass(fns)(12) // => true\n *    allPass(fns)(8) // => false\n * @dataLast\n * @category Array\n */\nexport function allPass<T>(\n  fns: readonly ((data: T) => boolean)[],\n): (data: T) => boolean;\n\nexport function allPass(...args: readonly unknown[]): unknown {\n  return purry(allPassImplementation, args);\n}\n\nconst allPassImplementation = <T>(\n  data: T,\n  fns: readonly ((data: T) => boolean)[],\n): boolean => fns.every((fn) => fn(data));\n"],"mappings":"mCA+CA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,OAAO,EAAM,EAAuB,CAAI,CAC1C,CAEA,MAAM,GACJ,EACA,IACY,EAAI,MAAO,GAAO,EAAG,CAAI,CAAC"}

package/dist/anyPass.cjs

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

package/dist/anyPass.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"anyPass.cjs","names":["purry"],"sources":["../src/anyPass.ts"],"sourcesContent":["import { purry } from \"./purry\";\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: readonly ((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: readonly ((data: T) => boolean)[],\n): (data: T) => boolean;\n\nexport function anyPass(...args: readonly unknown[]): unknown {\n  return purry(anyPassImplementation, args);\n}\n\nconst anyPassImplementation = <T>(\n  data: T,\n  fns: readonly ((data: T) => boolean)[],\n): boolean => fns.some((fn) => fn(data));\n"],"mappings":"kGA0CA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,OAAOA,EAAAA,MAAM,EAAuB,EAAK,CAG3C,MAAM,GACJ,EACA,IACY,EAAI,KAAM,GAAO,EAAG,EAAK,CAAC"}
+{"version":3,"file":"anyPass.cjs","names":["purry"],"sources":["../src/anyPass.ts"],"sourcesContent":["/* eslint-disable unicorn/consistent-boolean-name --\n * TODO [>2] -- This rule is on-point! The function's name should communicate\n * more clearly that it returns a boolean value.\n */\n\nimport { purry } from \"./purry\";\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: readonly ((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: readonly ((data: T) => boolean)[],\n): (data: T) => boolean;\n\nexport function anyPass(...args: readonly unknown[]): unknown {\n  return purry(anyPassImplementation, args);\n}\n\nconst anyPassImplementation = <T>(\n  data: T,\n  fns: readonly ((data: T) => boolean)[],\n): boolean => fns.some((fn) => fn(data));\n"],"mappings":"kGA+CA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,OAAOA,EAAAA,MAAM,EAAuB,CAAI,CAC1C,CAEA,MAAM,GACJ,EACA,IACY,EAAI,KAAM,GAAO,EAAG,CAAI,CAAC"}

package/dist/anyPass.js.map

@@ -1 +1 @@
-{"version":3,"file":"anyPass.js","names":[],"sources":["../src/anyPass.ts"],"sourcesContent":["import { purry } from \"./purry\";\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: readonly ((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: readonly ((data: T) => boolean)[],\n): (data: T) => boolean;\n\nexport function anyPass(...args: readonly unknown[]): unknown {\n  return purry(anyPassImplementation, args);\n}\n\nconst anyPassImplementation = <T>(\n  data: T,\n  fns: readonly ((data: T) => boolean)[],\n): boolean => fns.some((fn) => fn(data));\n"],"mappings":"mCA0CA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,OAAO,EAAM,EAAuB,EAAK,CAG3C,MAAM,GACJ,EACA,IACY,EAAI,KAAM,GAAO,EAAG,EAAK,CAAC"}
+{"version":3,"file":"anyPass.js","names":[],"sources":["../src/anyPass.ts"],"sourcesContent":["/* eslint-disable unicorn/consistent-boolean-name --\n * TODO [>2] -- This rule is on-point! The function's name should communicate\n * more clearly that it returns a boolean value.\n */\n\nimport { purry } from \"./purry\";\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: readonly ((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: readonly ((data: T) => boolean)[],\n): (data: T) => boolean;\n\nexport function anyPass(...args: readonly unknown[]): unknown {\n  return purry(anyPassImplementation, args);\n}\n\nconst anyPassImplementation = <T>(\n  data: T,\n  fns: readonly ((data: T) => boolean)[],\n): boolean => fns.some((fn) => fn(data));\n"],"mappings":"mCA+CA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,OAAO,EAAM,EAAuB,CAAI,CAC1C,CAEA,MAAM,GACJ,EACA,IACY,EAAI,KAAM,GAAO,EAAG,CAAI,CAAC"}

package/dist/{binarySearchCutoffIndex-CalebGhL.js → binarySearchCutoffIndex-CRPy-dOJ.js}

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

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

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

package/dist/binarySearchCutoffIndex-CdUUMUB1.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=binarySearchCutoffIndex-CdUUMUB1.cjs.map

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

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

package/dist/capitalize.cjs

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

package/dist/capitalize.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"capitalize.cjs","names":["purry"],"sources":["../src/capitalize.ts"],"sourcesContent":["import { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(capitalizeImplementation, args);\n}\n\nconst capitalizeImplementation = <T extends string>(data: T): Capitalize<T> =>\n  `${data[0]?.toUpperCase() ?? \"\"}${data.slice(1)}` as Capitalize<T>;\n"],"mappings":"kGAqDA,SAAgB,EAAW,GAAG,EAAmC,CAC/D,OAAOA,EAAAA,MAAM,EAA0B,EAAK,CAG9C,MAAM,EAA8C,GAClD,GAAG,EAAK,IAAI,aAAa,EAAI,KAAK,EAAK,MAAM,EAAE"}
+{"version":3,"file":"capitalize.cjs","names":["purry"],"sources":["../src/capitalize.ts"],"sourcesContent":["import { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(capitalizeImplementation, args);\n}\n\nconst capitalizeImplementation = <T extends string>(data: T): Capitalize<T> =>\n  `${data[0]?.toUpperCase() ?? \"\"}${data.slice(1)}` as Capitalize<T>;\n"],"mappings":"kGAqDA,SAAgB,EAAW,GAAG,EAAmC,CAC/D,OAAOA,EAAAA,MAAM,EAA0B,CAAI,CAC7C,CAEA,MAAM,EAA8C,GAClD,GAAG,EAAK,EAAE,EAAE,YAAY,GAAK,KAAK,EAAK,MAAM,CAAC"}

package/dist/capitalize.js.map

@@ -1 +1 @@
-{"version":3,"file":"capitalize.js","names":[],"sources":["../src/capitalize.ts"],"sourcesContent":["import { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(capitalizeImplementation, args);\n}\n\nconst capitalizeImplementation = <T extends string>(data: T): Capitalize<T> =>\n  `${data[0]?.toUpperCase() ?? \"\"}${data.slice(1)}` as Capitalize<T>;\n"],"mappings":"mCAqDA,SAAgB,EAAW,GAAG,EAAmC,CAC/D,OAAO,EAAM,EAA0B,EAAK,CAG9C,MAAM,EAA8C,GAClD,GAAG,EAAK,IAAI,aAAa,EAAI,KAAK,EAAK,MAAM,EAAE"}
+{"version":3,"file":"capitalize.js","names":[],"sources":["../src/capitalize.ts"],"sourcesContent":["import { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(capitalizeImplementation, args);\n}\n\nconst capitalizeImplementation = <T extends string>(data: T): Capitalize<T> =>\n  `${data[0]?.toUpperCase() ?? \"\"}${data.slice(1)}` as Capitalize<T>;\n"],"mappings":"mCAqDA,SAAgB,EAAW,GAAG,EAAmC,CAC/D,OAAO,EAAM,EAA0B,CAAI,CAC7C,CAEA,MAAM,EAA8C,GAClD,GAAG,EAAK,EAAE,EAAE,YAAY,GAAK,KAAK,EAAK,MAAM,CAAC"}

package/dist/ceil.cjs

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

package/dist/ceil.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"ceil.cjs","names":["purry","withPrecision"],"sources":["../src/ceil.ts"],"sourcesContent":["import { withPrecision } from \"./internal/withPrecision\";\nimport { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(withPrecision(Math.ceil), args);\n}\n"],"mappings":"4IAwCA,SAAgB,EAAK,GAAG,EAAmC,CACzD,OAAOA,EAAAA,MAAMC,EAAAA,EAAc,KAAK,KAAK,CAAE,EAAK"}
+{"version":3,"file":"ceil.cjs","names":["purry","withPrecision"],"sources":["../src/ceil.ts"],"sourcesContent":["import { withPrecision } from \"./internal/withPrecision\";\nimport { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(withPrecision(Math.ceil), args);\n}\n"],"mappings":"4IAwCA,SAAgB,EAAK,GAAG,EAAmC,CACzD,OAAOA,EAAAA,MAAMC,EAAAA,EAAc,KAAK,IAAI,EAAG,CAAI,CAC7C"}

package/dist/ceil.js

@@ -1,2 +1,2 @@
-import{purry as e}from"./purry.js";import{t}from"./withPrecision-7nvi8hnb.js";function n(...n){return e(t(Math.ceil),n)}export{n as ceil};
+import{purry as e}from"./purry.js";import{t}from"./withPrecision-DXRugSn5.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 { withPrecision } from \"./internal/withPrecision\";\nimport { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(withPrecision(Math.ceil), args);\n}\n"],"mappings":"8EAwCA,SAAgB,EAAK,GAAG,EAAmC,CACzD,OAAO,EAAM,EAAc,KAAK,KAAK,CAAE,EAAK"}
+{"version":3,"file":"ceil.js","names":[],"sources":["../src/ceil.ts"],"sourcesContent":["import { withPrecision } from \"./internal/withPrecision\";\nimport { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(withPrecision(Math.ceil), args);\n}\n"],"mappings":"8EAwCA,SAAgB,EAAK,GAAG,EAAmC,CACzD,OAAO,EAAM,EAAc,KAAK,IAAI,EAAG,CAAI,CAC7C"}

package/dist/chunk.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`);function t(...t){return e.purry(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;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./purry.cjs");function t(...t){return e.purry(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

@@ -1 +1 @@
-{"version":3,"file":"chunk.cjs","names":["purry"],"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/IntRangeInclusive\";\nimport type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport type { NTuple } from \"./internal/types/NTuple\";\nimport type { NonEmptyArray } from \"./internal/types/NonEmptyArray\";\nimport type { PartialArray } from \"./internal/types/PartialArray\";\nimport type { TupleParts } from \"./internal/types/TupleParts\";\nimport { purry } from \"./purry\";\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 unknown[][],\n        infer Current extends 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 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 unknown[][],\n          infer LastPrefixChunk extends 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              ...NTuple<Item, N>[],\n              ...SuffixChunk<Suffix, Item, N>,\n            ]\n      : // When our prefix chunks are empty we only need to handle the suffix\n        [...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 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 [...unknown[], unknown]\n  | readonly [unknown, ...unknown[]]\n  ? NonEmptyArray<NonEmptyArray<T[number]>>\n  : 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: readonly unknown[]): unknown {\n  return purry(chunkImplementation, args);\n}\n\nfunction chunkImplementation<T>(data: readonly T[], size: number): 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<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,EAAmC,CAC1D,OAAOA,EAAAA,MAAM,EAAqB,EAAK,CAGzC,SAAS,EAAuB,EAAoB,EAAqB,CACvE,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,MAAW,EAAO,CAErC,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.cjs","names":["purry"],"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/IntRangeInclusive\";\nimport type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport type { NTuple } from \"./internal/types/NTuple\";\nimport type { NonEmptyArray } from \"./internal/types/NonEmptyArray\";\nimport type { PartialArray } from \"./internal/types/PartialArray\";\nimport type { TupleParts } from \"./internal/types/TupleParts\";\nimport { purry } from \"./purry\";\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 unknown[][],\n        infer Current extends 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 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 unknown[][],\n          infer LastPrefixChunk extends 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              ...NTuple<Item, N>[],\n              ...SuffixChunk<Suffix, Item, N>,\n            ]\n      : // When our prefix chunks are empty we only need to handle the suffix\n        [...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 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 [...unknown[], unknown]\n  | readonly [unknown, ...unknown[]]\n  ? NonEmptyArray<NonEmptyArray<T[number]>>\n  : 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: readonly unknown[]): unknown {\n  return purry(chunkImplementation, args);\n}\n\nfunction chunkImplementation<T>(data: readonly T[], size: number): 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<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,EAAmC,CAC1D,OAAOA,EAAAA,MAAM,EAAqB,CAAI,CACxC,CAEA,SAAS,EAAuB,EAAoB,EAAqB,CACvE,GAAI,EAAO,EACT,MAAU,WACR,2BAA2B,EAAK,SAAS,EAAE,oCAC7C,EAGF,GAAI,EAAK,SAAW,EAClB,MAAO,CAAC,EAGV,GAAI,GAAQ,EAAK,OAEf,MAAO,CAAC,CAAC,GAAG,CAAI,CAAC,EAGnB,IAAM,EAAS,KAAK,KAAK,EAAK,OAAS,CAAI,EAGrC,EAAa,MAAW,CAAM,EAEpC,GAAI,IAAS,EAEX,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,QAAQ,EACvC,EAAO,GAAS,CAAC,CAAI,OAGvB,IAAK,IAAI,EAAQ,EAAG,EAAQ,EAAQ,GAAS,EAAG,CAC9C,IAAM,EAAQ,EAAQ,EACtB,EAAO,GAAS,EAAK,MAAM,EAAO,EAAQ,CAAI,CAChD,CAGF,OAAO,CACT"}

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/IntRangeInclusive\";\nimport type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport type { NTuple } from \"./internal/types/NTuple\";\nimport type { NonEmptyArray } from \"./internal/types/NonEmptyArray\";\nimport type { PartialArray } from \"./internal/types/PartialArray\";\nimport type { TupleParts } from \"./internal/types/TupleParts\";\nimport { purry } from \"./purry\";\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 unknown[][],\n        infer Current extends 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 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 unknown[][],\n          infer LastPrefixChunk extends 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              ...NTuple<Item, N>[],\n              ...SuffixChunk<Suffix, Item, N>,\n            ]\n      : // When our prefix chunks are empty we only need to handle the suffix\n        [...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 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 [...unknown[], unknown]\n  | readonly [unknown, ...unknown[]]\n  ? NonEmptyArray<NonEmptyArray<T[number]>>\n  : 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: readonly unknown[]): unknown {\n  return purry(chunkImplementation, args);\n}\n\nfunction chunkImplementation<T>(data: readonly T[], size: number): 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<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,EAAmC,CAC1D,OAAO,EAAM,EAAqB,EAAK,CAGzC,SAAS,EAAuB,EAAoB,EAAqB,CACvE,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,MAAW,EAAO,CAErC,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/IntRangeInclusive\";\nimport type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport type { NTuple } from \"./internal/types/NTuple\";\nimport type { NonEmptyArray } from \"./internal/types/NonEmptyArray\";\nimport type { PartialArray } from \"./internal/types/PartialArray\";\nimport type { TupleParts } from \"./internal/types/TupleParts\";\nimport { purry } from \"./purry\";\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 unknown[][],\n        infer Current extends 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 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 unknown[][],\n          infer LastPrefixChunk extends 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              ...NTuple<Item, N>[],\n              ...SuffixChunk<Suffix, Item, N>,\n            ]\n      : // When our prefix chunks are empty we only need to handle the suffix\n        [...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 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 [...unknown[], unknown]\n  | readonly [unknown, ...unknown[]]\n  ? NonEmptyArray<NonEmptyArray<T[number]>>\n  : 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: readonly unknown[]): unknown {\n  return purry(chunkImplementation, args);\n}\n\nfunction chunkImplementation<T>(data: readonly T[], size: number): 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<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,EAAmC,CAC1D,OAAO,EAAM,EAAqB,CAAI,CACxC,CAEA,SAAS,EAAuB,EAAoB,EAAqB,CACvE,GAAI,EAAO,EACT,MAAU,WACR,2BAA2B,EAAK,SAAS,EAAE,oCAC7C,EAGF,GAAI,EAAK,SAAW,EAClB,MAAO,CAAC,EAGV,GAAI,GAAQ,EAAK,OAEf,MAAO,CAAC,CAAC,GAAG,CAAI,CAAC,EAGnB,IAAM,EAAS,KAAK,KAAK,EAAK,OAAS,CAAI,EAGrC,EAAa,MAAW,CAAM,EAEpC,GAAI,IAAS,EAEX,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,QAAQ,EACvC,EAAO,GAAS,CAAC,CAAI,OAGvB,IAAK,IAAI,EAAQ,EAAG,EAAQ,EAAQ,GAAS,EAAG,CAC9C,IAAM,EAAQ,EAAQ,EACtB,EAAO,GAAS,EAAK,MAAM,EAAO,EAAQ,CAAI,CAChD,CAGF,OAAO,CACT"}

package/dist/clamp.cjs

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

package/dist/clamp.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"clamp.cjs","names":["purry"],"sources":["../src/clamp.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\ntype 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: readonly unknown[]): unknown {\n  return purry(clampImplementation, args);\n}\n\nconst clampImplementation = (value: number, { min, max }: Limits): number =>\n  min !== undefined && value < min\n    ? min\n    : max !== undefined && value > max\n      ? max\n      : value;\n"],"mappings":"kGAsCA,SAAgB,EAAM,GAAG,EAAmC,CAC1D,OAAOA,EAAAA,MAAM,EAAqB,EAAK,CAGzC,MAAM,GAAuB,EAAe,CAAE,MAAK,SACjD,IAAQ,IAAA,IAAa,EAAQ,EACzB,EACA,IAAQ,IAAA,IAAa,EAAQ,EAC3B,EACA"}
+{"version":3,"file":"clamp.cjs","names":["purry"],"sources":["../src/clamp.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\ntype 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: readonly unknown[]): unknown {\n  return purry(clampImplementation, args);\n}\n\nconst clampImplementation = (value: number, { min, max }: Limits): number =>\n  min !== undefined && value < min\n    ? min\n    : max !== undefined && value > max\n      ? max\n      : value;\n"],"mappings":"kGAsCA,SAAgB,EAAM,GAAG,EAAmC,CAC1D,OAAOA,EAAAA,MAAM,EAAqB,CAAI,CACxC,CAEA,MAAM,GAAuB,EAAe,CAAE,MAAK,SACjD,IAAQ,IAAA,IAAa,EAAQ,EACzB,EACA,IAAQ,IAAA,IAAa,EAAQ,EAC3B,EACA"}

package/dist/clamp.js.map

@@ -1 +1 @@
-{"version":3,"file":"clamp.js","names":[],"sources":["../src/clamp.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\ntype 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: readonly unknown[]): unknown {\n  return purry(clampImplementation, args);\n}\n\nconst clampImplementation = (value: number, { min, max }: Limits): number =>\n  min !== undefined && value < min\n    ? min\n    : max !== undefined && value > max\n      ? max\n      : value;\n"],"mappings":"mCAsCA,SAAgB,EAAM,GAAG,EAAmC,CAC1D,OAAO,EAAM,EAAqB,EAAK,CAGzC,MAAM,GAAuB,EAAe,CAAE,MAAK,SACjD,IAAQ,IAAA,IAAa,EAAQ,EACzB,EACA,IAAQ,IAAA,IAAa,EAAQ,EAC3B,EACA"}
+{"version":3,"file":"clamp.js","names":[],"sources":["../src/clamp.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\ntype 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: readonly unknown[]): unknown {\n  return purry(clampImplementation, args);\n}\n\nconst clampImplementation = (value: number, { min, max }: Limits): number =>\n  min !== undefined && value < min\n    ? min\n    : max !== undefined && value > max\n      ? max\n      : value;\n"],"mappings":"mCAsCA,SAAgB,EAAM,GAAG,EAAmC,CAC1D,OAAO,EAAM,EAAqB,CAAI,CACxC,CAEA,MAAM,GAAuB,EAAe,CAAE,MAAK,SACjD,IAAQ,IAAA,IAAa,EAAQ,EACzB,EACA,IAAQ,IAAA,IAAa,EAAQ,EAC3B,EACA"}

package/dist/clone.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`);function t(...t){return e.purry(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;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./purry.cjs");function t(...t){return e.purry(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(a!==null&&a!==Object.prototype&&!Array.isArray(e))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

@@ -1 +1 @@
-{"version":3,"file":"clone.cjs","names":["purry"],"sources":["../src/clone.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types --\n * The state needed to compute the clone is passed by reference via mutable\n * arrays.\n */\n\nimport { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(cloneImplementation, args);\n}\n\nfunction cloneImplementation<T>(\n  value: T,\n  refFrom: unknown[] = [],\n  refTo: 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  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\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: unknown[],\n  refTo: 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 readonly unknown[]>(\n  value: T,\n  refFrom: unknown[],\n  refTo: unknown[],\n): T {\n  const copiedValue: 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":"kGAwCA,SAAgB,EAAM,GAAG,EAAmC,CAC1D,OAAOA,EAAAA,MAAM,EAAqB,EAAK,CAGzC,SAAS,EACP,EACA,EAAqB,EAAE,CACvB,EAAmB,EAAE,CAClB,CACH,GAAI,OAAO,GAAU,WAEnB,OAAO,EAGT,GAAI,OAAO,GAAU,WAAY,EAG/B,OAAO,gBAAgB,EAAM,CAI/B,IAAM,EAAY,OAAO,eAAe,EAAM,CAC9C,GACE,CAAC,MAAM,QAAQ,EAAM,EAGrB,IAAc,MACd,IAAc,OAAO,UAKrB,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,EAAyB,EAAE,CAIjC,EAAM,KAAK,EAAY,CAEvB,IAAK,GAAM,CAAC,EAAO,KAAS,EAAM,SAAS,CACzC,EAAY,GAAS,EAAoB,EAAM,EAAS,EAAM,CAGhE,OAAO"}
+{"version":3,"file":"clone.cjs","names":["purry"],"sources":["../src/clone.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types --\n * The state needed to compute the clone is passed by reference via mutable\n * arrays.\n */\n\nimport { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(cloneImplementation, args);\n}\n\nfunction cloneImplementation<T>(\n  value: T,\n  refFrom: unknown[] = [],\n  refTo: 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  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n  const prototype = Object.getPrototypeOf(value);\n  if (\n    // Keep this check in sync with the same check in the impl of\n    // `isPlainObject`.\n    prototype !== null &&\n    prototype !== Object.prototype &&\n    !Array.isArray(value)\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: unknown[],\n  refTo: 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 readonly unknown[]>(\n  value: T,\n  refFrom: unknown[],\n  refTo: unknown[],\n): T {\n  const copiedValue: 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":"kGAwCA,SAAgB,EAAM,GAAG,EAAmC,CAC1D,OAAOA,EAAAA,MAAM,EAAqB,CAAI,CACxC,CAEA,SAAS,EACP,EACA,EAAqB,CAAC,EACtB,EAAmB,CAAC,EACjB,CACH,GAAI,OAAO,GAAU,WAEnB,OAAO,EAGT,GAAI,OAAO,GAAU,WAAY,EAG/B,OAAO,gBAAgB,CAAK,EAI9B,IAAM,EAAY,OAAO,eAAe,CAAK,EAC7C,GAGE,IAAc,MACd,IAAc,OAAO,WACrB,CAAC,MAAM,QAAQ,CAAK,EAKpB,OAAO,gBAAgB,CAAK,EAO9B,IAAM,EAAM,EAAQ,QAAQ,CAAK,EAOjC,OANI,IAAQ,IAKZ,EAAQ,KAAK,CAAK,EACX,MAAM,QAAQ,CAAK,EACtB,EAAe,EAAO,EAAS,CAAK,EACpC,EAAgB,EAAO,EAAS,CAAK,GAPhC,EAAM,EAQjB,CAEA,SAAS,EACP,EACA,EACA,EACG,CACH,IAAM,EAA4C,CAAC,EAInD,EAAM,KAAK,CAAW,EAEtB,IAAK,GAAM,CAAC,EAAG,KAAM,OAAO,QAAQ,CAAK,EACvC,EAAY,GAAK,EAAoB,EAAG,EAAS,CAAK,EAGxD,OAAO,CACT,CAEA,SAAS,EACP,EACA,EACA,EACG,CACH,IAAM,EAAyB,CAAC,EAIhC,EAAM,KAAK,CAAW,EAEtB,IAAK,GAAM,CAAC,EAAO,KAAS,EAAM,QAAQ,EACxC,EAAY,GAAS,EAAoB,EAAM,EAAS,CAAK,EAG/D,OAAO,CACT"}

package/dist/clone.js

@@ -1,2 +1,2 @@
-import{purry as e}from"./purry.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};
+import{purry as e}from"./purry.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(a!==null&&a!==Object.prototype&&!Array.isArray(e))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":[],"sources":["../src/clone.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types --\n * The state needed to compute the clone is passed by reference via mutable\n * arrays.\n */\n\nimport { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(cloneImplementation, args);\n}\n\nfunction cloneImplementation<T>(\n  value: T,\n  refFrom: unknown[] = [],\n  refTo: 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  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\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: unknown[],\n  refTo: 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 readonly unknown[]>(\n  value: T,\n  refFrom: unknown[],\n  refTo: unknown[],\n): T {\n  const copiedValue: 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":"mCAwCA,SAAgB,EAAM,GAAG,EAAmC,CAC1D,OAAO,EAAM,EAAqB,EAAK,CAGzC,SAAS,EACP,EACA,EAAqB,EAAE,CACvB,EAAmB,EAAE,CAClB,CACH,GAAI,OAAO,GAAU,WAEnB,OAAO,EAGT,GAAI,OAAO,GAAU,WAAY,EAG/B,OAAO,gBAAgB,EAAM,CAI/B,IAAM,EAAY,OAAO,eAAe,EAAM,CAC9C,GACE,CAAC,MAAM,QAAQ,EAAM,EAGrB,IAAc,MACd,IAAc,OAAO,UAKrB,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,EAAyB,EAAE,CAIjC,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":["/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types --\n * The state needed to compute the clone is passed by reference via mutable\n * arrays.\n */\n\nimport { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(cloneImplementation, args);\n}\n\nfunction cloneImplementation<T>(\n  value: T,\n  refFrom: unknown[] = [],\n  refTo: 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  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n  const prototype = Object.getPrototypeOf(value);\n  if (\n    // Keep this check in sync with the same check in the impl of\n    // `isPlainObject`.\n    prototype !== null &&\n    prototype !== Object.prototype &&\n    !Array.isArray(value)\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: unknown[],\n  refTo: 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 readonly unknown[]>(\n  value: T,\n  refFrom: unknown[],\n  refTo: unknown[],\n): T {\n  const copiedValue: 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":"mCAwCA,SAAgB,EAAM,GAAG,EAAmC,CAC1D,OAAO,EAAM,EAAqB,CAAI,CACxC,CAEA,SAAS,EACP,EACA,EAAqB,CAAC,EACtB,EAAmB,CAAC,EACjB,CACH,GAAI,OAAO,GAAU,WAEnB,OAAO,EAGT,GAAI,OAAO,GAAU,WAAY,EAG/B,OAAO,gBAAgB,CAAK,EAI9B,IAAM,EAAY,OAAO,eAAe,CAAK,EAC7C,GAGE,IAAc,MACd,IAAc,OAAO,WACrB,CAAC,MAAM,QAAQ,CAAK,EAKpB,OAAO,gBAAgB,CAAK,EAO9B,IAAM,EAAM,EAAQ,QAAQ,CAAK,EAOjC,OANI,IAAQ,IAKZ,EAAQ,KAAK,CAAK,EACX,MAAM,QAAQ,CAAK,EACtB,EAAe,EAAO,EAAS,CAAK,EACpC,EAAgB,EAAO,EAAS,CAAK,GAPhC,EAAM,EAQjB,CAEA,SAAS,EACP,EACA,EACA,EACG,CACH,IAAM,EAA4C,CAAC,EAInD,EAAM,KAAK,CAAW,EAEtB,IAAK,GAAM,CAAC,EAAG,KAAM,OAAO,QAAQ,CAAK,EACvC,EAAY,GAAK,EAAoB,EAAG,EAAS,CAAK,EAGxD,OAAO,CACT,CAEA,SAAS,EACP,EACA,EACA,EACG,CACH,IAAM,EAAyB,CAAC,EAIhC,EAAM,KAAK,CAAW,EAEtB,IAAK,GAAM,CAAC,EAAO,KAAS,EAAM,QAAQ,EACxC,EAAY,GAAS,EAAoB,EAAM,EAAS,CAAK,EAG/D,OAAO,CACT"}

package/dist/concat.cjs

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

package/dist/concat.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"concat.cjs","names":["purry"],"sources":["../src/concat.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(concatImplementation, args);\n}\n\nconst concatImplementation = <\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n>(\n  arr1: T1,\n  arr2: T2,\n): [...T1, ...T2] => [...arr1, ...arr2];\n"],"mappings":"kGA4CA,SAAgB,EAAO,GAAG,EAAmC,CAC3D,OAAOA,EAAAA,MAAM,EAAsB,EAAK,CAG1C,MAAM,GAIJ,EACA,IACmB,CAAC,GAAG,EAAM,GAAG,EAAK"}
+{"version":3,"file":"concat.cjs","names":["purry"],"sources":["../src/concat.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(concatImplementation, args);\n}\n\nconst concatImplementation = <\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n>(\n  arr1: T1,\n  arr2: T2,\n): [...T1, ...T2] => [...arr1, ...arr2];\n"],"mappings":"kGA4CA,SAAgB,EAAO,GAAG,EAAmC,CAC3D,OAAOA,EAAAA,MAAM,EAAsB,CAAI,CACzC,CAEA,MAAM,GAIJ,EACA,IACmB,CAAC,GAAG,EAAM,GAAG,CAAI"}

package/dist/concat.js.map

@@ -1 +1 @@
-{"version":3,"file":"concat.js","names":[],"sources":["../src/concat.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(concatImplementation, args);\n}\n\nconst concatImplementation = <\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n>(\n  arr1: T1,\n  arr2: T2,\n): [...T1, ...T2] => [...arr1, ...arr2];\n"],"mappings":"mCA4CA,SAAgB,EAAO,GAAG,EAAmC,CAC3D,OAAO,EAAM,EAAsB,EAAK,CAG1C,MAAM,GAIJ,EACA,IACmB,CAAC,GAAG,EAAM,GAAG,EAAK"}
+{"version":3,"file":"concat.js","names":[],"sources":["../src/concat.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(concatImplementation, args);\n}\n\nconst concatImplementation = <\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n>(\n  arr1: T1,\n  arr2: T2,\n): [...T1, ...T2] => [...arr1, ...arr2];\n"],"mappings":"mCA4CA,SAAgB,EAAO,GAAG,EAAmC,CAC3D,OAAO,EAAM,EAAsB,CAAI,CACzC,CAEA,MAAM,GAIJ,EACA,IACmB,CAAC,GAAG,EAAM,GAAG,CAAI"}

package/dist/conditional.cjs

@@ -1 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./conditional-3wcaMG9k.cjs`);exports.conditional=e.t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./purryOn-wBH_q-mO.cjs");function t(...t){return e.t(r,n,t)}function n(e,...t){for(let n of t){if(typeof n==`function`)return n(e);let[t,r]=n;if(t(e))return r(e)}throw Error(`conditional: data failed for all cases`)}function r(e){if(!Array.isArray(e))return!1;let[t,n,...r]=e;return typeof t==`function`&&t.length<=1&&typeof n==`function`&&n.length<=1&&r.length===0}exports.conditional=t;
+//# sourceMappingURL=conditional.cjs.map