@vinicunca/perkakas 1.13.2 → 1.15.0

package/dist/map-values.js.map

@@ -1 +1 @@
-{"version":3,"file":"map-values.js","names":["out: Record<string, Value>"],"sources":["../src/map-values.ts"],"sourcesContent":["import type { Simplify } from 'type-fest';\nimport type { EnumerableStringKeyOf } from './internal/types/enumerable-string-key-of';\nimport type { EnumerableStringKeyedValueOf } from './internal/types/enumerable-string-keyed-value-of';\nimport { curry } from './curry';\n\ntype MappedValues<T extends object, Value> = Simplify<{\n  -readonly [P in keyof T as P extends number | string ? P : never]: Value;\n}>;\n\n/**\n * Maps values of `object` and keeps the same keys. Symbol keys are not passed\n * to the mapper and will be removed from the output object.\n *\n * To also copy the symbol keys to the output use merge:\n * `merge(data, mapValues(data, mapper))`).\n *\n * @param data - The object to map.\n * @param valueMapper - The mapping function.\n * @signature\n *    P.mapValues(data, mapper)\n * @example\n *    P.mapValues({a: 1, b: 2}, (value, key) => value + key) // => {a: '1a', b: '2b'}\n * @dataFirst\n * @category Object\n */\nexport function mapValues<T extends object, Value>(\n  data: T,\n  valueMapper: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => Value,\n): MappedValues<T, Value>;\n\n/**\n * Maps values of `object` and keeps the same keys. Symbol keys are not passed\n * to the mapper and will be removed from the output object.\n *\n * To also copy the symbol keys to the output use merge:\n * `merge(data, mapValues(data, mapper))`).\n *\n * @param valueMapper - The mapping function.\n * @signature\n *    P.mapValues(mapper)(data)\n * @example\n *    P.pipe({a: 1, b: 2}, P.mapValues((value, key) => value + key)) // => {a: '1a', b: '2b'}\n * @dataLast\n * @category Object\n */\nexport function mapValues<T extends object, Value>(\n  valueMapper: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => Value,\n): (data: T) => MappedValues<T, Value>;\n\nexport function mapValues(...args: ReadonlyArray<unknown>): unknown {\n  return curry(mapValuesImplementation, args);\n}\n\nfunction mapValuesImplementation<T extends object, Value>(\n  data: T,\n  valueMapper: (value: unknown, key: string, data: T) => Value,\n): Record<string, Value> {\n  const out: Record<string, Value> = {};\n\n  for (const [key, value] of Object.entries(data)) {\n    const mappedValue = valueMapper(value, key, data);\n    out[key] = mappedValue;\n  }\n\n  return out;\n}\n"],"mappings":"wCAyDA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAO,EAAM,EAAyB,EAAK,CAG7C,SAAS,EACP,EACA,EACuB,CACvB,IAAMA,EAA6B,EAAE,CAErC,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAK,CAE7C,EAAI,GADgB,EAAY,EAAO,EAAK,EAAK,CAInD,OAAO"}
+{"version":3,"file":"map-values.js","names":[],"sources":["../src/map-values.ts"],"sourcesContent":["import type { Simplify } from 'type-fest';\nimport type { EnumerableStringKeyOf } from './internal/types/enumerable-string-key-of';\nimport type { EnumerableStringKeyedValueOf } from './internal/types/enumerable-string-keyed-value-of';\nimport { curry } from './curry';\n\ntype MappedValues<T extends object, Value> = Simplify<{\n  -readonly [P in keyof T as P extends number | string ? P : never]: Value;\n}>;\n\n/**\n * Maps values of `object` and keeps the same keys. Symbol keys are not passed\n * to the mapper and will be removed from the output object.\n *\n * To also copy the symbol keys to the output use merge:\n * `merge(data, mapValues(data, mapper))`).\n *\n * @param data - The object to map.\n * @param valueMapper - The mapping function.\n * @signature\n *    mapValues(data, mapper)\n * @example\n *    mapValues({a: 1, b: 2}, (value, key) => value + key) // => {a: '1a', b: '2b'}\n * @dataFirst\n * @category Object\n */\nexport function mapValues<T extends object, Value>(\n  data: T,\n  valueMapper: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => Value,\n): MappedValues<T, Value>;\n\n/**\n * Maps values of `object` and keeps the same keys. Symbol keys are not passed\n * to the mapper and will be removed from the output object.\n *\n * To also copy the symbol keys to the output use merge:\n * `merge(data, mapValues(data, mapper))`).\n *\n * @param valueMapper - The mapping function.\n * @signature\n *    mapValues(mapper)(data)\n * @example\n *    pipe({a: 1, b: 2}, mapValues((value, key) => value + key)) // => {a: '1a', b: '2b'}\n * @dataLast\n * @category Object\n */\nexport function mapValues<T extends object, Value>(\n  valueMapper: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => Value,\n): (data: T) => MappedValues<T, Value>;\n\nexport function mapValues(...args: ReadonlyArray<unknown>): unknown {\n  return curry(mapValuesImplementation, args);\n}\n\nfunction mapValuesImplementation<T extends object, Value>(\n  data: T,\n  valueMapper: (value: unknown, key: string, data: T) => Value,\n): Record<string, Value> {\n  const out: Record<string, Value> = {};\n\n  for (const [key, value] of Object.entries(data)) {\n    const mappedValue = valueMapper(value, key, data);\n    out[key] = mappedValue;\n  }\n\n  return out;\n}\n"],"mappings":"mCAyDA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAO,EAAM,EAAyB,EAAK,CAG7C,SAAS,EACP,EACA,EACuB,CACvB,IAAM,EAA6B,EAAE,CAErC,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAK,CAE7C,EAAI,GADgB,EAAY,EAAO,EAAK,EAAK,CAInD,OAAO"}

package/dist/map-with-feedback.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-from-lazy-BCGvmhyS.cjs`);function t(...t){return e.t(n,t)}function n(e,t){let n=t;return(t,r,i)=>(n=e(n,t,r,i),{done:!1,hasNext:!0,next:n})}exports.mapWithFeedback=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry-from-lazy-BvN_VKlH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){let n=t;return(t,r,i)=>(n=e(n,t,r,i),{done:!1,hasNext:!0,next:n})}exports.mapWithFeedback=t;
+//# sourceMappingURL=map-with-feedback.cjs.map

package/dist/map-with-feedback.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-with-feedback.cjs","names":["curryFromLazy"],"sources":["../src/map-with-feedback.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport type { Mapped } from './internal/types/mapped';\nimport { curryFromLazy } from './internal/curry-from-lazy';\n\n/**\n * Applies a function on each element of the array, using the result of the\n * previous application, and returns an array of the successively computed\n * values.\n *\n * @param data - The array to map over.\n * @param callbackfn - The callback function that receives the previous value,\n * the current element.\n * @param initialValue - The initial value to start the computation with.\n * @returns An array of successively computed values from the left side of the\n * array.\n * @signature\n *    mapWithFeedback(data, callbackfn, initialValue);\n * @example\n *    mapWithFeedback(\n *      [1, 2, 3, 4, 5],\n *      (prev, x) => prev + x,\n *      100,\n *    ); // => [101, 103, 106, 110, 115]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function mapWithFeedback<T extends IterableContainer, U>(\n  data: T,\n  callbackfn: (\n    previousValue: U,\n    currentValue: T[number],\n    currentIndex: number,\n    data: T,\n  ) => U,\n  initialValue: U,\n): Mapped<T, U>;\n\n/**\n * Applies a function on each element of the array, using the result of the\n * previous application, and returns an array of the successively computed\n * values.\n *\n * @param callbackfn - The callback function that receives the previous value,\n * the current element.\n * @param initialValue - The initial value to start the computation with.\n * @returns An array of successively computed values from the left side of the\n * array.\n * @signature\n *    mapWithFeedback(callbackfn, initialValue)(data);\n * @example\n *    pipe(\n *      [1, 2, 3, 4, 5],\n *      mapWithFeedback((prev, x) => prev + x, 100),\n *    ); // => [101, 103, 106, 110, 115]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function mapWithFeedback<T extends IterableContainer, U>(\n  callbackfn: (\n    previousValue: U,\n    currentValue: T[number],\n    currentIndex: number,\n    data: T,\n  ) => U,\n  initialValue: U,\n): (data: T) => Mapped<T, U>;\n\nexport function mapWithFeedback(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T, U>(reducer: (\n  previousValue: U,\n  currentValue: T,\n  index: number,\n  data: ReadonlyArray<T>,\n) => U, initialValue: U): LazyEvaluator<T, U> {\n  let previousValue = initialValue;\n  return (currentValue, index, data) => {\n    previousValue = reducer(previousValue, currentValue, index, data);\n    return { done: false, hasNext: true, next: previousValue };\n  };\n}\n"],"mappings":"qHAsEA,SAAgB,EAAgB,GAAG,EAAuC,CACxE,OAAOA,EAAAA,EAAc,EAAoB,EAAK,CAGhD,SAAS,EAAyB,EAK1B,EAAsC,CAC5C,IAAI,EAAgB,EACpB,OAAQ,EAAc,EAAO,KAC3B,EAAgB,EAAQ,EAAe,EAAc,EAAO,EAAK,CAC1D,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAe"}

package/dist/map-with-feedback.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-from-lazy-PQ0BbG-7.js";function t(...t){return e(n,t)}function n(e,t){let n=t;return(t,r,i)=>(n=e(n,t,r,i),{done:!1,hasNext:!0,next:n})}export{t as mapWithFeedback};
+import{t as e}from"./curry-from-lazy-CtH1dp14.js";function t(...t){return e(n,t)}function n(e,t){let n=t;return(t,r,i)=>(n=e(n,t,r,i),{done:!1,hasNext:!0,next:n})}export{t as mapWithFeedback};
 //# sourceMappingURL=map-with-feedback.js.map

package/dist/map-with-feedback.js.map

@@ -1 +1 @@
-{"version":3,"file":"map-with-feedback.js","names":[],"sources":["../src/map-with-feedback.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport type { Mapped } from './internal/types/mapped';\n\nimport { curryFromLazy } from './internal/curry-from-lazy';\n\n/**\n * Applies a function on each element of the array, using the result of the\n * previous application, and returns an array of the successively computed\n * values.\n *\n * @param data - The array to map over.\n * @param callbackfn - The callback function that receives the previous value,\n * the current element.\n * @param initialValue - The initial value to start the computation with.\n * @returns An array of successively computed values from the left side of the\n * array.\n * @signature\n *    P.mapWithFeedback(data, callbackfn, initialValue);\n * @example\n *    P.mapWithFeedback(\n *      [1, 2, 3, 4, 5],\n *      (prev, x) => prev + x,\n *      100,\n *    ); // => [101, 103, 106, 110, 115]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function mapWithFeedback<T extends IterableContainer, U>(\n  data: T,\n  callbackfn: (\n    previousValue: U,\n    currentValue: T[number],\n    currentIndex: number,\n    data: T,\n  ) => U,\n  initialValue: U,\n): Mapped<T, U>;\n\n/**\n * Applies a function on each element of the array, using the result of the\n * previous application, and returns an array of the successively computed\n * values.\n *\n * @param callbackfn - The callback function that receives the previous value,\n * the current element.\n * @param initialValue - The initial value to start the computation with.\n * @returns An array of successively computed values from the left side of the\n * array.\n * @signature\n *    P.mapWithFeedback(callbackfn, initialValue)(data);\n * @example\n *    P.pipe(\n *      [1, 2, 3, 4, 5],\n *      P.mapWithFeedback((prev, x) => prev + x, 100),\n *    ); // => [101, 103, 106, 110, 115]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function mapWithFeedback<T extends IterableContainer, U>(\n  callbackfn: (\n    previousValue: U,\n    currentValue: T[number],\n    currentIndex: number,\n    data: T,\n  ) => U,\n  initialValue: U,\n): (data: T) => Mapped<T, U>;\n\nexport function mapWithFeedback(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T, U>(\n  reducer: (\n    previousValue: U,\n    currentValue: T,\n    index: number,\n    data: ReadonlyArray<T>,\n  ) => U,\n  initialValue: U,\n): LazyEvaluator<T, U> {\n  let previousValue = initialValue;\n  return (currentValue, index, data) => {\n    previousValue = reducer(previousValue, currentValue, index, data);\n    return { done: false, hasNext: true, next: previousValue };\n  };\n};\n"],"mappings":"kDAuEA,SAAgB,EAAgB,GAAG,EAAuC,CACxE,OAAO,EAAc,EAAoB,EAAK,CAGhD,SAAS,EACP,EAMA,EACqB,CACrB,IAAI,EAAgB,EACpB,OAAQ,EAAc,EAAO,KAC3B,EAAgB,EAAQ,EAAe,EAAc,EAAO,EAAK,CAC1D,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAe"}
+{"version":3,"file":"map-with-feedback.js","names":[],"sources":["../src/map-with-feedback.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport type { Mapped } from './internal/types/mapped';\nimport { curryFromLazy } from './internal/curry-from-lazy';\n\n/**\n * Applies a function on each element of the array, using the result of the\n * previous application, and returns an array of the successively computed\n * values.\n *\n * @param data - The array to map over.\n * @param callbackfn - The callback function that receives the previous value,\n * the current element.\n * @param initialValue - The initial value to start the computation with.\n * @returns An array of successively computed values from the left side of the\n * array.\n * @signature\n *    mapWithFeedback(data, callbackfn, initialValue);\n * @example\n *    mapWithFeedback(\n *      [1, 2, 3, 4, 5],\n *      (prev, x) => prev + x,\n *      100,\n *    ); // => [101, 103, 106, 110, 115]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function mapWithFeedback<T extends IterableContainer, U>(\n  data: T,\n  callbackfn: (\n    previousValue: U,\n    currentValue: T[number],\n    currentIndex: number,\n    data: T,\n  ) => U,\n  initialValue: U,\n): Mapped<T, U>;\n\n/**\n * Applies a function on each element of the array, using the result of the\n * previous application, and returns an array of the successively computed\n * values.\n *\n * @param callbackfn - The callback function that receives the previous value,\n * the current element.\n * @param initialValue - The initial value to start the computation with.\n * @returns An array of successively computed values from the left side of the\n * array.\n * @signature\n *    mapWithFeedback(callbackfn, initialValue)(data);\n * @example\n *    pipe(\n *      [1, 2, 3, 4, 5],\n *      mapWithFeedback((prev, x) => prev + x, 100),\n *    ); // => [101, 103, 106, 110, 115]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function mapWithFeedback<T extends IterableContainer, U>(\n  callbackfn: (\n    previousValue: U,\n    currentValue: T[number],\n    currentIndex: number,\n    data: T,\n  ) => U,\n  initialValue: U,\n): (data: T) => Mapped<T, U>;\n\nexport function mapWithFeedback(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T, U>(reducer: (\n  previousValue: U,\n  currentValue: T,\n  index: number,\n  data: ReadonlyArray<T>,\n) => U, initialValue: U): LazyEvaluator<T, U> {\n  let previousValue = initialValue;\n  return (currentValue, index, data) => {\n    previousValue = reducer(previousValue, currentValue, index, data);\n    return { done: false, hasNext: true, next: previousValue };\n  };\n}\n"],"mappings":"kDAsEA,SAAgB,EAAgB,GAAG,EAAuC,CACxE,OAAO,EAAc,EAAoB,EAAK,CAGhD,SAAS,EAAyB,EAK1B,EAAsC,CAC5C,IAAI,EAAgB,EACpB,OAAQ,EAAc,EAAO,KAC3B,EAAgB,EAAQ,EAAe,EAAc,EAAO,EAAK,CAC1D,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAe"}

package/dist/map.cjs

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

package/dist/map.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.cjs","names":["curry"],"sources":["../src/map.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport type { Mapped } from './internal/types/mapped';\nimport { curry } from './curry';\n\n/**\n * Creates a new array populated with the results of calling a provided function\n * on every element in the calling array. Equivalent to `Array.prototype.map`.\n *\n * @param data - The array to map.\n * @param callbackfn - A function to execute for each element in the array. Its\n * return value is added as a single element in the new array.\n * @returns A new array with each element being the result of the callback\n * function.\n * @signature\n *    map(data, callbackfn)\n * @example\n *    map([1, 2, 3], multiply(2)); // => [2, 4, 6]\n *    map([0, 0], add(1)); // => [1, 1]\n *    map([0, 0], (value, index) => value + index); // => [0, 1]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function map<T extends IterableContainer, U>(\n  data: T,\n  callbackfn: (value: T[number], index: number, data: T) => U,\n): Mapped<T, U>;\n\n/**\n * Creates a new array populated with the results of calling a provided function\n * on every element in the calling array. Equivalent to `Array.prototype.map`.\n *\n * @param callbackfn - A function to execute for each element in the array. Its\n * return value is added as a single element in the new array.\n * @returns A new array with each element being the result of the callback\n * function.\n * @signature\n *    map(callbackfn)(data)\n * @example\n *    pipe([1, 2, 3], map(multiply(2))); // => [2, 4, 6]\n *    pipe([0, 0], map(add(1))); // => [1, 1]\n *    pipe([0, 0], map((value, index) => value + index)); // => [0, 1]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function map<T extends IterableContainer, U>(\n  callbackfn: (value: T[number], index: number, data: T) => U,\n): (data: T) => Mapped<T, U>;\n\nexport function map(...args: ReadonlyArray<unknown>): unknown {\n  return curry(mapImplementation, args, lazyImplementation);\n}\n\nfunction mapImplementation<T, U>(data: ReadonlyArray<T>, callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => U): Array<U> {\n  return data.map(callbackfn);\n}\n\nfunction lazyImplementation<T, U>(callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => U): LazyEvaluator<T, U> {\n  return (value, index, data) => ({\n    done: false,\n    hasNext: true,\n    next: callbackfn(value, index, data),\n  });\n}\n"],"mappings":"kGAmDA,SAAgB,EAAI,GAAG,EAAuC,CAC5D,OAAOA,EAAAA,MAAM,EAAmB,EAAM,EAAmB,CAG3D,SAAS,EAAwB,EAAwB,EAA8E,CACrI,OAAO,EAAK,IAAI,EAAW,CAG7B,SAAS,EAAyB,EAAyF,CACzH,OAAQ,EAAO,EAAO,KAAU,CAC9B,KAAM,GACN,QAAS,GACT,KAAM,EAAW,EAAO,EAAO,EAAK,CACrC"}

package/dist/map.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t,r)}function n(e,t){return e.map(t)}function r(e){return(t,n,r)=>({done:!1,hasNext:!0,next:e(t,n,r)})}export{t as map};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t,r)}function n(e,t){return e.map(t)}function r(e){return(t,n,r)=>({done:!1,hasNext:!0,next:e(t,n,r)})}export{t as map};
 //# sourceMappingURL=map.js.map

package/dist/map.js.map

@@ -1 +1 @@
-{"version":3,"file":"map.js","names":[],"sources":["../src/map.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport type { Mapped } from './internal/types/mapped';\n\nimport { curry } from './curry';\n\n/**\n * Creates a new array populated with the results of calling a provided function\n * on every element in the calling array. Equivalent to `Array.prototype.map`.\n *\n * @param data - The array to map.\n * @param callbackfn - A function to execute for each element in the array. Its\n * return value is added as a single element in the new array.\n * @returns A new array with each element being the result of the callback\n * function.\n * @signature\n *    P.map(data, callbackfn)\n * @example\n *    P.map([1, 2, 3], P.multiply(2)); // => [2, 4, 6]\n *    P.map([0, 0], P.add(1)); // => [1, 1]\n *    P.map([0, 0], (value, index) => value + index); // => [0, 1]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function map<T extends IterableContainer, U>(\n  data: T,\n  callbackfn: (value: T[number], index: number, data: T) => U,\n): Mapped<T, U>;\n\n/**\n * Creates a new array populated with the results of calling a provided function\n * on every element in the calling array. Equivalent to `Array.prototype.map`.\n *\n * @param callbackfn - A function to execute for each element in the array. Its\n * return value is added as a single element in the new array.\n * @returns A new array with each element being the result of the callback\n * function.\n * @signature\n *    P.map(callbackfn)(data)\n * @example\n *    P.pipe([1, 2, 3], P.map(P.multiply(2))); // => [2, 4, 6]\n *    P.pipe([0, 0], P.map(P.add(1))); // => [1, 1]\n *    P.pipe([0, 0], P.map((value, index) => value + index)); // => [0, 1]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function map<T extends IterableContainer, U>(\n  callbackfn: (value: T[number], index: number, data: T) => U,\n): (data: T) => Mapped<T, U>;\n\nexport function map(...args: ReadonlyArray<unknown>): unknown {\n  return curry(mapImplementation, args, lazyImplementation);\n}\n\nfunction mapImplementation<T, U>(\n  data: ReadonlyArray<T>,\n  callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => U,\n): Array<U> {\n  return data.map(callbackfn);\n};\n\nfunction lazyImplementation<T, U>(\n  callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => U,\n): LazyEvaluator<T, U> {\n  return (value, index, data) => ({\n    done: false,\n    hasNext: true,\n    next: callbackfn(value, index, data),\n  });\n}\n"],"mappings":"wCAoDA,SAAgB,EAAI,GAAG,EAAuC,CAC5D,OAAO,EAAM,EAAmB,EAAM,EAAmB,CAG3D,SAAS,EACP,EACA,EACU,CACV,OAAO,EAAK,IAAI,EAAW,CAG7B,SAAS,EACP,EACqB,CACrB,OAAQ,EAAO,EAAO,KAAU,CAC9B,KAAM,GACN,QAAS,GACT,KAAM,EAAW,EAAO,EAAO,EAAK,CACrC"}
+{"version":3,"file":"map.js","names":[],"sources":["../src/map.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport type { Mapped } from './internal/types/mapped';\nimport { curry } from './curry';\n\n/**\n * Creates a new array populated with the results of calling a provided function\n * on every element in the calling array. Equivalent to `Array.prototype.map`.\n *\n * @param data - The array to map.\n * @param callbackfn - A function to execute for each element in the array. Its\n * return value is added as a single element in the new array.\n * @returns A new array with each element being the result of the callback\n * function.\n * @signature\n *    map(data, callbackfn)\n * @example\n *    map([1, 2, 3], multiply(2)); // => [2, 4, 6]\n *    map([0, 0], add(1)); // => [1, 1]\n *    map([0, 0], (value, index) => value + index); // => [0, 1]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function map<T extends IterableContainer, U>(\n  data: T,\n  callbackfn: (value: T[number], index: number, data: T) => U,\n): Mapped<T, U>;\n\n/**\n * Creates a new array populated with the results of calling a provided function\n * on every element in the calling array. Equivalent to `Array.prototype.map`.\n *\n * @param callbackfn - A function to execute for each element in the array. Its\n * return value is added as a single element in the new array.\n * @returns A new array with each element being the result of the callback\n * function.\n * @signature\n *    map(callbackfn)(data)\n * @example\n *    pipe([1, 2, 3], map(multiply(2))); // => [2, 4, 6]\n *    pipe([0, 0], map(add(1))); // => [1, 1]\n *    pipe([0, 0], map((value, index) => value + index)); // => [0, 1]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function map<T extends IterableContainer, U>(\n  callbackfn: (value: T[number], index: number, data: T) => U,\n): (data: T) => Mapped<T, U>;\n\nexport function map(...args: ReadonlyArray<unknown>): unknown {\n  return curry(mapImplementation, args, lazyImplementation);\n}\n\nfunction mapImplementation<T, U>(data: ReadonlyArray<T>, callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => U): Array<U> {\n  return data.map(callbackfn);\n}\n\nfunction lazyImplementation<T, U>(callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => U): LazyEvaluator<T, U> {\n  return (value, index, data) => ({\n    done: false,\n    hasNext: true,\n    next: callbackfn(value, index, data),\n  });\n}\n"],"mappings":"mCAmDA,SAAgB,EAAI,GAAG,EAAuC,CAC5D,OAAO,EAAM,EAAmB,EAAM,EAAmB,CAG3D,SAAS,EAAwB,EAAwB,EAA8E,CACrI,OAAO,EAAK,IAAI,EAAW,CAG7B,SAAS,EAAyB,EAAyF,CACzH,OAAQ,EAAO,EAAO,KAAU,CAC9B,KAAM,GACN,QAAS,GACT,KAAM,EAAW,EAAO,EAAO,EAAK,CACrC"}

package/dist/mean-by.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){if(e.length===0)return NaN;let n=0;for(let[r,i]of e.entries())n+=t(i,r,e);return n/e.length}exports.meanBy=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){if(e.length===0)return NaN;let n=0;for(let[r,i]of e.entries())n+=t(i,r,e);return n/e.length}exports.meanBy=t;
+//# sourceMappingURL=mean-by.cjs.map

package/dist/mean-by.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mean-by.cjs","names":["curry"],"sources":["../src/mean-by.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Returns the mean of the elements of an array using the provided predicate.\n *\n * @param fn - Predicate function.\n * @signature\n *   meanBy(fn)(array)\n * @example\n *    pipe(\n *      [{a: 5}, {a: 1}, {a: 3}],\n *      meanBy(x => x.a)\n *    ) // 3\n * @dataLast\n * @category Array\n */\n\nexport function meanBy<T>(\n  fn: (value: T, index: number, data: ReadonlyArray<T>) => number,\n): (items: ReadonlyArray<T>) => number;\n\n/**\n * Returns the mean of the elements of an array using the provided predicate.\n *\n * @param items - The array.\n * @param fn - Predicate function.\n * @signature\n *   meanBy(array, fn)\n * @example\n *    meanBy(\n *      [{a: 5}, {a: 1}, {a: 3}],\n *      x => x.a\n *    ) // 3\n * @dataFirst\n * @category Array\n */\n\nexport function meanBy<T>(\n  items: ReadonlyArray<T>,\n  fn: (value: T, index: number, data: ReadonlyArray<T>) => number,\n): number;\n\nexport function meanBy(...args: ReadonlyArray<unknown>): unknown {\n  return curry(meanByImplementation, args);\n}\n\nfunction meanByImplementation<T>(array: ReadonlyArray<T>, fn: (value: T, index: number, data: ReadonlyArray<T>) => number): number {\n  if (array.length === 0) {\n    return Number.NaN;\n  }\n\n  let sum = 0;\n\n  for (const [index, item] of array.entries()) {\n    sum += fn(item, index, array);\n  }\n\n  return sum / array.length;\n}\n"],"mappings":"kGA0CA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAOA,EAAAA,MAAM,EAAsB,EAAK,CAG1C,SAAS,EAAwB,EAAyB,EAAyE,CACjI,GAAI,EAAM,SAAW,EACnB,MAAO,KAGT,IAAI,EAAM,EAEV,IAAK,GAAM,CAAC,EAAO,KAAS,EAAM,SAAS,CACzC,GAAO,EAAG,EAAM,EAAO,EAAM,CAG/B,OAAO,EAAM,EAAM"}

package/dist/mean-by.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){if(e.length===0)return NaN;let n=0;for(let[r,i]of e.entries())n+=t(i,r,e);return n/e.length}export{t as meanBy};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t){if(e.length===0)return NaN;let n=0;for(let[r,i]of e.entries())n+=t(i,r,e);return n/e.length}export{t as meanBy};
 //# sourceMappingURL=mean-by.js.map

package/dist/mean-by.js.map

@@ -1 +1 @@
-{"version":3,"file":"mean-by.js","names":[],"sources":["../src/mean-by.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Returns the mean of the elements of an array using the provided predicate.\n *\n * @param fn - Predicate function.\n * @signature\n *   P.meanBy(fn)(array)\n * @example\n *    P.pipe(\n *      [{a: 5}, {a: 1}, {a: 3}],\n *      P.meanBy(x => x.a)\n *    ) // 3\n * @dataLast\n * @category Array\n */\n\nexport function meanBy<T>(\n  fn: (value: T, index: number, data: ReadonlyArray<T>) => number,\n): (items: ReadonlyArray<T>) => number;\n\n/**\n * Returns the mean of the elements of an array using the provided predicate.\n *\n * @param items - The array.\n * @param fn - Predicate function.\n * @signature\n *   P.meanBy(array, fn)\n * @example\n *    P.meanBy(\n *      [{a: 5}, {a: 1}, {a: 3}],\n *      x => x.a\n *    ) // 3\n * @dataFirst\n * @category Array\n */\n\nexport function meanBy<T>(\n  items: ReadonlyArray<T>,\n  fn: (value: T, index: number, data: ReadonlyArray<T>) => number,\n): number;\n\nexport function meanBy(...args: ReadonlyArray<unknown>): unknown {\n  return curry(meanByImplementation, args);\n}\n\nfunction meanByImplementation<T>(\n  array: ReadonlyArray<T>,\n  fn: (value: T, index: number, data: ReadonlyArray<T>) => number,\n): number {\n  if (array.length === 0) {\n    return Number.NaN;\n  }\n\n  let sum = 0;\n\n  for (const [index, item] of array.entries()) {\n    sum += fn(item, index, array);\n  }\n\n  return sum / array.length;\n};\n"],"mappings":"wCA0CA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EACP,EACA,EACQ,CACR,GAAI,EAAM,SAAW,EACnB,MAAO,KAGT,IAAI,EAAM,EAEV,IAAK,GAAM,CAAC,EAAO,KAAS,EAAM,SAAS,CACzC,GAAO,EAAG,EAAM,EAAO,EAAM,CAG/B,OAAO,EAAM,EAAM"}
+{"version":3,"file":"mean-by.js","names":[],"sources":["../src/mean-by.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Returns the mean of the elements of an array using the provided predicate.\n *\n * @param fn - Predicate function.\n * @signature\n *   meanBy(fn)(array)\n * @example\n *    pipe(\n *      [{a: 5}, {a: 1}, {a: 3}],\n *      meanBy(x => x.a)\n *    ) // 3\n * @dataLast\n * @category Array\n */\n\nexport function meanBy<T>(\n  fn: (value: T, index: number, data: ReadonlyArray<T>) => number,\n): (items: ReadonlyArray<T>) => number;\n\n/**\n * Returns the mean of the elements of an array using the provided predicate.\n *\n * @param items - The array.\n * @param fn - Predicate function.\n * @signature\n *   meanBy(array, fn)\n * @example\n *    meanBy(\n *      [{a: 5}, {a: 1}, {a: 3}],\n *      x => x.a\n *    ) // 3\n * @dataFirst\n * @category Array\n */\n\nexport function meanBy<T>(\n  items: ReadonlyArray<T>,\n  fn: (value: T, index: number, data: ReadonlyArray<T>) => number,\n): number;\n\nexport function meanBy(...args: ReadonlyArray<unknown>): unknown {\n  return curry(meanByImplementation, args);\n}\n\nfunction meanByImplementation<T>(array: ReadonlyArray<T>, fn: (value: T, index: number, data: ReadonlyArray<T>) => number): number {\n  if (array.length === 0) {\n    return Number.NaN;\n  }\n\n  let sum = 0;\n\n  for (const [index, item] of array.entries()) {\n    sum += fn(item, index, array);\n  }\n\n  return sum / array.length;\n}\n"],"mappings":"mCA0CA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EAAwB,EAAyB,EAAyE,CACjI,GAAI,EAAM,SAAW,EACnB,MAAO,KAGT,IAAI,EAAM,EAEV,IAAK,GAAM,CAAC,EAAO,KAAS,EAAM,SAAS,CACzC,GAAO,EAAG,EAAM,EAAO,EAAM,CAG/B,OAAO,EAAM,EAAM"}

package/dist/mean.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`),t=require(`./sum.cjs`);function n(...t){return e.curry(r,t)}function r(e){if(e.length!==0)return t.sum(e)/e.length}exports.mean=n;
+//# sourceMappingURL=mean.cjs.map

package/dist/mean.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mean.cjs","names":["curry","sum"],"sources":["../src/mean.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\nimport { sum } from './sum';\n\ntype Mean<T extends IterableContainer<number>>\n  = | (T extends readonly [] ? never : number)\n    | (T extends readonly [unknown, ...Array<unknown>] ? never : undefined);\n\n/**\n * Returns the mean of the elements of an array.\n *\n * Only `number` arrays are supported, as `bigint` is unable to represent fractional values.\n *\n * IMPORTANT: The result for empty arrays would be `undefined`, regardless of\n * the type of the array. This approach improves type-checking and ensures that\n * cases where `NaN` might occur are handled properly. To avoid adding this to\n * the return type for cases where the array is known to be non-empty you can use\n * `hasAtLeast` or `isEmpty` to guard against this case.\n *\n * @param data - The array of numbers.\n * @signature\n *   mean(data);\n * @example\n *   mean([1, 2, 3]); // => 2\n *   mean([]); // => undefined\n * @dataFirst\n * @category Number\n */\nexport function mean<T extends IterableContainer<number>>(data: T): Mean<T>;\n\n/**\n * Returns the mean of the elements of an array.\n *\n * Only `number` arrays are supported, as `bigint` is unable to represent fractional values.\n *\n * IMPORTANT: The result for empty arrays would be `undefined`, regardless of\n * the type of the array. This approach improves type-checking and ensures that\n * cases where `NaN` might occur are handled properly. To avoid adding this to\n * the return type for cases where the array is known to be non-empty you can use\n * `hasAtLeast` or `isEmpty` to guard against this case.\n *\n * @signature\n *   mean()(data);\n * @example\n *   pipe([1, 2, 3], mean()); // => 2\n *   pipe([], mean()); // => undefined\n * @dataLast\n * @category Number\n */\nexport function mean(): <T extends IterableContainer<number>>(\n  data: T,\n) => Mean<T>;\n\nexport function mean(...args: ReadonlyArray<unknown>): unknown {\n  return curry(meanImplementation, args);\n}\n\nfunction meanImplementation<T extends IterableContainer<number>>(\n  data: T,\n): T[number] | undefined {\n  if (data.length === 0) {\n    return undefined;\n  }\n\n  return sum(data) / data.length;\n}\n"],"mappings":"yHAqDA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAOA,EAAAA,MAAM,EAAoB,EAAK,CAGxC,SAAS,EACP,EACuB,CACnB,KAAK,SAAW,EAIpB,OAAOC,EAAAA,IAAI,EAAK,CAAG,EAAK"}

package/dist/mean.js

@@ -0,0 +1,2 @@
+import{curry as e}from"./curry.js";import{sum as t}from"./sum.js";function n(...t){return e(r,t)}function r(e){if(e.length!==0)return t(e)/e.length}export{n as mean};
+//# sourceMappingURL=mean.js.map

package/dist/mean.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mean.js","names":[],"sources":["../src/mean.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\nimport { sum } from './sum';\n\ntype Mean<T extends IterableContainer<number>>\n  = | (T extends readonly [] ? never : number)\n    | (T extends readonly [unknown, ...Array<unknown>] ? never : undefined);\n\n/**\n * Returns the mean of the elements of an array.\n *\n * Only `number` arrays are supported, as `bigint` is unable to represent fractional values.\n *\n * IMPORTANT: The result for empty arrays would be `undefined`, regardless of\n * the type of the array. This approach improves type-checking and ensures that\n * cases where `NaN` might occur are handled properly. To avoid adding this to\n * the return type for cases where the array is known to be non-empty you can use\n * `hasAtLeast` or `isEmpty` to guard against this case.\n *\n * @param data - The array of numbers.\n * @signature\n *   mean(data);\n * @example\n *   mean([1, 2, 3]); // => 2\n *   mean([]); // => undefined\n * @dataFirst\n * @category Number\n */\nexport function mean<T extends IterableContainer<number>>(data: T): Mean<T>;\n\n/**\n * Returns the mean of the elements of an array.\n *\n * Only `number` arrays are supported, as `bigint` is unable to represent fractional values.\n *\n * IMPORTANT: The result for empty arrays would be `undefined`, regardless of\n * the type of the array. This approach improves type-checking and ensures that\n * cases where `NaN` might occur are handled properly. To avoid adding this to\n * the return type for cases where the array is known to be non-empty you can use\n * `hasAtLeast` or `isEmpty` to guard against this case.\n *\n * @signature\n *   mean()(data);\n * @example\n *   pipe([1, 2, 3], mean()); // => 2\n *   pipe([], mean()); // => undefined\n * @dataLast\n * @category Number\n */\nexport function mean(): <T extends IterableContainer<number>>(\n  data: T,\n) => Mean<T>;\n\nexport function mean(...args: ReadonlyArray<unknown>): unknown {\n  return curry(meanImplementation, args);\n}\n\nfunction meanImplementation<T extends IterableContainer<number>>(\n  data: T,\n): T[number] | undefined {\n  if (data.length === 0) {\n    return undefined;\n  }\n\n  return sum(data) / data.length;\n}\n"],"mappings":"kEAqDA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAoB,EAAK,CAGxC,SAAS,EACP,EACuB,CACnB,KAAK,SAAW,EAIpB,OAAO,EAAI,EAAK,CAAG,EAAK"}

package/dist/median.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(r,t)}const n=(e,t)=>e-t;function r(e){if(e.length===0)return;let t=[...e].sort(n);if(t.length%2!=0)return t[(t.length-1)/2];let r=t.length/2;return(t[r]+t[r-1])/2}exports.median=t;
+//# sourceMappingURL=median.cjs.map

package/dist/median.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"median.cjs","names":["curry"],"sources":["../src/median.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\ntype Median<T extends IterableContainer<number>>\n  = | (T extends readonly [] ? never : number)\n    | (T extends readonly [unknown, ...Array<unknown>] ? never : undefined);\n\n/**\n * Returns the median of the elements of an array.\n *\n * Only `number` arrays are supported, as `bigint` is unable to represent fractional values.\n *\n * IMPORTANT: The result for empty arrays would be `undefined`, regardless of\n * the type of the array. This approach improves type-checking and ensures that\n * cases where `NaN` might occur are handled properly. To avoid adding this to\n * the return type for cases where the array is known to be non-empty you can use\n * `hasAtLeast` or `isEmpty` to guard against this case.\n *\n * @param data - The array of numbers.\n * @signature\n *   median(data);\n * @example\n *   pipe([6, 10, 11], median()); // => 10\n *   median([]); // => undefined\n * @dataFirst\n * @category Number\n */\nexport function median<T extends IterableContainer<number>>(data: T): Median<T>;\n\n/**\n * Returns the median of the elements of an array.\n *\n * Only `number` arrays are supported, as `bigint` is unable to represent fractional values.\n *\n * IMPORTANT: The result for empty arrays would be `undefined`, regardless of\n * the type of the array. This approach improves type-checking and ensures that\n * cases where `NaN` might occur are handled properly. To avoid adding this to\n * the return type for cases where the array is known to be non-empty you can use\n * `hasAtLeast` or `isEmpty` to guard against this case.\n *\n * @signature\n *   median()(data);\n * @example\n *   pipe([6, 10, 11], median()); // => 10\n *   pipe([], median()); // => undefined\n * @dataLast\n * @category Number\n */\nexport function median(): <T extends IterableContainer<number>>(\n  data: T,\n) => Median<T>;\n\nexport function median(...args: ReadonlyArray<unknown>): unknown {\n  return curry(medianImplementation, args);\n}\n\nconst numberComparator = (a: number, b: number): number => a - b;\n\nfunction medianImplementation<T extends IterableContainer<number>>(\n  data: T,\n): T[number] | undefined {\n  if (data.length === 0) {\n    return undefined;\n  }\n\n  // TODO [>2]: When node 18 reaches end-of-life bump target lib to ES2023+ and use `Array.prototype.toSorted` here.\n  const sortedData = [...data].sort(numberComparator);\n\n  // For odd length, return the middle element\n  if (sortedData.length % 2 !== 0) {\n    return sortedData[(sortedData.length - 1) / 2];\n  }\n\n  // For even length, return the mean of the two middle elements\n  const middleIndex = sortedData.length / 2;\n\n  return (sortedData[middleIndex]! + sortedData[middleIndex - 1]!) / 2;\n}\n"],"mappings":"kGAoDA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAOA,EAAAA,MAAM,EAAsB,EAAK,CAG1C,MAAM,GAAoB,EAAW,IAAsB,EAAI,EAE/D,SAAS,EACP,EACuB,CACvB,GAAI,EAAK,SAAW,EAClB,OAIF,IAAM,EAAa,CAAC,GAAG,EAAK,CAAC,KAAK,EAAiB,CAGnD,GAAI,EAAW,OAAS,GAAM,EAC5B,OAAO,GAAY,EAAW,OAAS,GAAK,GAI9C,IAAM,EAAc,EAAW,OAAS,EAExC,OAAQ,EAAW,GAAgB,EAAW,EAAc,IAAO"}

package/dist/median.js

@@ -0,0 +1,2 @@
+import{curry as e}from"./curry.js";function t(...t){return e(r,t)}const n=(e,t)=>e-t;function r(e){if(e.length===0)return;let t=[...e].sort(n);if(t.length%2!=0)return t[(t.length-1)/2];let r=t.length/2;return(t[r]+t[r-1])/2}export{t as median};
+//# sourceMappingURL=median.js.map

package/dist/median.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"median.js","names":[],"sources":["../src/median.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\ntype Median<T extends IterableContainer<number>>\n  = | (T extends readonly [] ? never : number)\n    | (T extends readonly [unknown, ...Array<unknown>] ? never : undefined);\n\n/**\n * Returns the median of the elements of an array.\n *\n * Only `number` arrays are supported, as `bigint` is unable to represent fractional values.\n *\n * IMPORTANT: The result for empty arrays would be `undefined`, regardless of\n * the type of the array. This approach improves type-checking and ensures that\n * cases where `NaN` might occur are handled properly. To avoid adding this to\n * the return type for cases where the array is known to be non-empty you can use\n * `hasAtLeast` or `isEmpty` to guard against this case.\n *\n * @param data - The array of numbers.\n * @signature\n *   median(data);\n * @example\n *   pipe([6, 10, 11], median()); // => 10\n *   median([]); // => undefined\n * @dataFirst\n * @category Number\n */\nexport function median<T extends IterableContainer<number>>(data: T): Median<T>;\n\n/**\n * Returns the median of the elements of an array.\n *\n * Only `number` arrays are supported, as `bigint` is unable to represent fractional values.\n *\n * IMPORTANT: The result for empty arrays would be `undefined`, regardless of\n * the type of the array. This approach improves type-checking and ensures that\n * cases where `NaN` might occur are handled properly. To avoid adding this to\n * the return type for cases where the array is known to be non-empty you can use\n * `hasAtLeast` or `isEmpty` to guard against this case.\n *\n * @signature\n *   median()(data);\n * @example\n *   pipe([6, 10, 11], median()); // => 10\n *   pipe([], median()); // => undefined\n * @dataLast\n * @category Number\n */\nexport function median(): <T extends IterableContainer<number>>(\n  data: T,\n) => Median<T>;\n\nexport function median(...args: ReadonlyArray<unknown>): unknown {\n  return curry(medianImplementation, args);\n}\n\nconst numberComparator = (a: number, b: number): number => a - b;\n\nfunction medianImplementation<T extends IterableContainer<number>>(\n  data: T,\n): T[number] | undefined {\n  if (data.length === 0) {\n    return undefined;\n  }\n\n  // TODO [>2]: When node 18 reaches end-of-life bump target lib to ES2023+ and use `Array.prototype.toSorted` here.\n  const sortedData = [...data].sort(numberComparator);\n\n  // For odd length, return the middle element\n  if (sortedData.length % 2 !== 0) {\n    return sortedData[(sortedData.length - 1) / 2];\n  }\n\n  // For even length, return the mean of the two middle elements\n  const middleIndex = sortedData.length / 2;\n\n  return (sortedData[middleIndex]! + sortedData[middleIndex - 1]!) / 2;\n}\n"],"mappings":"mCAoDA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAK,CAG1C,MAAM,GAAoB,EAAW,IAAsB,EAAI,EAE/D,SAAS,EACP,EACuB,CACvB,GAAI,EAAK,SAAW,EAClB,OAIF,IAAM,EAAa,CAAC,GAAG,EAAK,CAAC,KAAK,EAAiB,CAGnD,GAAI,EAAW,OAAS,GAAM,EAC5B,OAAO,GAAY,EAAW,OAAS,GAAK,GAI9C,IAAM,EAAc,EAAW,OAAS,EAExC,OAAQ,EAAW,GAAgB,EAAW,EAAc,IAAO"}

package/dist/merge-all.cjs

@@ -1 +1,2 @@
-function e(e){let t={};for(let n of e)t={...t,...n};return t}exports.mergeAll=e;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});function e(e){let t={};for(let n of e)t={...t,...n};return t}exports.mergeAll=e;
+//# sourceMappingURL=merge-all.cjs.map

package/dist/merge-all.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-all.cjs","names":[],"sources":["../src/merge-all.ts"],"sourcesContent":["import type {\n  EmptyObject,\n  Merge,\n  SharedUnionFields,\n  Simplify,\n} from 'type-fest';\nimport type { DisjointUnionFields } from './internal/types/disjoint-union-fields';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport type { TupleParts } from './internal/types/tuple-parts';\n\n/**\n * Merge a tuple of object types, where props from later objects override earlier props.\n */\ntype MergeTuple<\n  T extends IterableContainer,\n  Result = object, // no-op for the first iteration in the successive merges, also infers object as type by default if an empty tuple is used\n> = T extends readonly [infer Head, ...infer Rest]\n  ? MergeTuple<Rest, Merge<Result, Head>>\n  : Result;\n\n// In the context of a heterogeneous array, the array may not have objects from every type of the union.\n// This means some fields may be missing in the final object, so we make them optional.\n// If there is a non-optional field shared among all members of the union, then we know that if the array is not empty, the field must be present and avoid becoming optional.\n// If the field is already optional, this doesn't really matter.\n// If the array is empty, we know that the loop won't run so we'll just get the empty object.\n// Since we don't know the order of the items in the array, when we merge common fields, we don't know what the final type for the field will be, but we do know that it is one of the many possible types that are available across the members of the union for that field.\n// We represent these possibilities by combining the field's different types across the union members into a union.\ntype MergeUnion<T extends object> = Simplify<\n  SharedUnionFields<T> & Partial<DisjointUnionFields<T>>\n>;\n\ntype MergeAll<T extends IterableContainer<object>>\n  // determine if it's a tuple or array\n  = TupleParts<T> extends { item: never }\n    ? T extends readonly []\n      ? EmptyObject\n      : MergeTuple<T>\n    : MergeUnion<T[number]> | EmptyObject;\n\n/**\n * Merges a list of objects into a single object.\n *\n * @param objects - The array of objects.\n * @returns A new object merged with all of the objects in the list. If the list is empty, an empty object is returned.\n * @signature\n *    mergeAll(objects)\n * @example\n *    mergeAll([{ a: 1, b: 1 }, { b: 2, c: 3 }, { d: 10 }]) // => { a: 1, b: 2, c: 3, d: 10 }\n *    mergeAll([]) // => {}\n * @dataFirst\n * @category Array\n */\nexport function mergeAll<T extends object>(\n  objects: Readonly<NonEmptyArray<T>>,\n): MergeUnion<T>;\nexport function mergeAll<T extends IterableContainer<object>>(\n  objects: T,\n): MergeAll<T>;\nexport function mergeAll(objects: ReadonlyArray<object>): object {\n  let out = {};\n\n  for (const item of objects) {\n    out = { ...out, ...item };\n  }\n\n  return out;\n}\n"],"mappings":"mEA2DA,SAAgB,EAAS,EAAwC,CAC/D,IAAI,EAAM,EAAE,CAEZ,IAAK,IAAM,KAAQ,EACjB,EAAM,CAAE,GAAG,EAAK,GAAG,EAAM,CAG3B,OAAO"}

package/dist/merge-all.js.map

@@ -1 +1 @@
-{"version":3,"file":"merge-all.js","names":[],"sources":["../src/merge-all.ts"],"sourcesContent":["import type {\n  EmptyObject,\n  Merge,\n  SharedUnionFields,\n  Simplify,\n} from 'type-fest';\nimport type { DisjointUnionFields } from './internal/types/disjoint-union-fields';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport type { TupleParts } from './internal/types/tuple-parts';\n\n/**\n * Merge a tuple of object types, where props from later objects override earlier props.\n */\ntype MergeTuple<\n  T extends IterableContainer,\n  Result = object, // no-op for the first iteration in the successive merges, also infers object as type by default if an empty tuple is used\n> = T extends readonly [infer Head, ...infer Rest]\n  ? MergeTuple<Rest, Merge<Result, Head>>\n  : Result;\n\n// In the context of a heterogeneous array, the array may not have objects from every type of the union.\n// This means some fields may be missing in the final object, so we make them optional.\n// If there is a non-optional field shared among all members of the union, then we know that if the array is not empty, the field must be present and avoid becoming optional.\n// If the field is already optional, this doesn't really matter.\n// If the array is empty, we know that the loop won't run so we'll just get the empty object.\n// Since we don't know the order of the items in the array, when we merge common fields, we don't know what the final type for the field will be, but we do know that it is one of the many possible types that are available across the members of the union for that field.\n// We represent these possibilities by combining the field's different types across the union members into a union.\ntype MergeUnion<T extends object> = Simplify<\n  SharedUnionFields<T> & Partial<DisjointUnionFields<T>>\n>;\n\ntype MergeAll<T extends IterableContainer<object>>\n  // determine if it's a tuple or array\n  = TupleParts<T> extends { item: never }\n    ? T extends readonly []\n      ? EmptyObject\n      : MergeTuple<T>\n    : MergeUnion<T[number]> | EmptyObject;\n\n/**\n * Merges a list of objects into a single object.\n *\n * @param objects - The array of objects.\n * @returns A new object merged with all of the objects in the list. If the list is empty, an empty object is returned.\n * @signature\n *    P.mergeAll(objects)\n * @example\n *    P.mergeAll([{ a: 1, b: 1 }, { b: 2, c: 3 }, { d: 10 }]) // => { a: 1, b: 2, c: 3, d: 10 }\n *    P.mergeAll([]) // => {}\n * @dataFirst\n * @category Array\n */\nexport function mergeAll<T extends object>(\n  objects: Readonly<NonEmptyArray<T>>,\n): MergeUnion<T>;\nexport function mergeAll<T extends IterableContainer<object>>(\n  objects: T,\n): MergeAll<T>;\nexport function mergeAll(objects: ReadonlyArray<object>): object {\n  let out = {};\n\n  for (const item of objects) {\n    out = { ...out, ...item };\n  }\n\n  return out;\n}\n"],"mappings":"AA2DA,SAAgB,EAAS,EAAwC,CAC/D,IAAI,EAAM,EAAE,CAEZ,IAAK,IAAM,KAAQ,EACjB,EAAM,CAAE,GAAG,EAAK,GAAG,EAAM,CAG3B,OAAO"}
+{"version":3,"file":"merge-all.js","names":[],"sources":["../src/merge-all.ts"],"sourcesContent":["import type {\n  EmptyObject,\n  Merge,\n  SharedUnionFields,\n  Simplify,\n} from 'type-fest';\nimport type { DisjointUnionFields } from './internal/types/disjoint-union-fields';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport type { TupleParts } from './internal/types/tuple-parts';\n\n/**\n * Merge a tuple of object types, where props from later objects override earlier props.\n */\ntype MergeTuple<\n  T extends IterableContainer,\n  Result = object, // no-op for the first iteration in the successive merges, also infers object as type by default if an empty tuple is used\n> = T extends readonly [infer Head, ...infer Rest]\n  ? MergeTuple<Rest, Merge<Result, Head>>\n  : Result;\n\n// In the context of a heterogeneous array, the array may not have objects from every type of the union.\n// This means some fields may be missing in the final object, so we make them optional.\n// If there is a non-optional field shared among all members of the union, then we know that if the array is not empty, the field must be present and avoid becoming optional.\n// If the field is already optional, this doesn't really matter.\n// If the array is empty, we know that the loop won't run so we'll just get the empty object.\n// Since we don't know the order of the items in the array, when we merge common fields, we don't know what the final type for the field will be, but we do know that it is one of the many possible types that are available across the members of the union for that field.\n// We represent these possibilities by combining the field's different types across the union members into a union.\ntype MergeUnion<T extends object> = Simplify<\n  SharedUnionFields<T> & Partial<DisjointUnionFields<T>>\n>;\n\ntype MergeAll<T extends IterableContainer<object>>\n  // determine if it's a tuple or array\n  = TupleParts<T> extends { item: never }\n    ? T extends readonly []\n      ? EmptyObject\n      : MergeTuple<T>\n    : MergeUnion<T[number]> | EmptyObject;\n\n/**\n * Merges a list of objects into a single object.\n *\n * @param objects - The array of objects.\n * @returns A new object merged with all of the objects in the list. If the list is empty, an empty object is returned.\n * @signature\n *    mergeAll(objects)\n * @example\n *    mergeAll([{ a: 1, b: 1 }, { b: 2, c: 3 }, { d: 10 }]) // => { a: 1, b: 2, c: 3, d: 10 }\n *    mergeAll([]) // => {}\n * @dataFirst\n * @category Array\n */\nexport function mergeAll<T extends object>(\n  objects: Readonly<NonEmptyArray<T>>,\n): MergeUnion<T>;\nexport function mergeAll<T extends IterableContainer<object>>(\n  objects: T,\n): MergeAll<T>;\nexport function mergeAll(objects: ReadonlyArray<object>): object {\n  let out = {};\n\n  for (const item of objects) {\n    out = { ...out, ...item };\n  }\n\n  return out;\n}\n"],"mappings":"AA2DA,SAAgB,EAAS,EAAwC,CAC/D,IAAI,EAAM,EAAE,CAEZ,IAAK,IAAM,KAAQ,EACjB,EAAM,CAAE,GAAG,EAAK,GAAG,EAAM,CAG3B,OAAO"}

package/dist/merge-deep.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`),t=require(`./is-plain-object.cjs`);function n(...t){return e.t(r,t)}function r(e,n){let i={...e,...n};for(let a in n){if(!(a in e))continue;let{[a]:o}=e;if(!t.isPlainObject(o))continue;let{[a]:s}=n;t.isPlainObject(s)&&(i[a]=r(o,s))}return i}exports.mergeDeep=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`),t=require(`./is-plain-object.cjs`);function n(...t){return e.curry(r,t)}function r(e,n){let i={...e,...n};for(let a in n){if(!(a in e))continue;let{[a]:o}=e;if(!t.isPlainObject(o))continue;let{[a]:s}=n;t.isPlainObject(s)&&(i[a]=r(o,s))}return i}exports.mergeDeep=n;
+//# sourceMappingURL=merge-deep.cjs.map

package/dist/merge-deep.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-deep.cjs","names":["curry","isPlainObject"],"sources":["../src/merge-deep.ts"],"sourcesContent":["import type { MergeDeep } from 'type-fest';\nimport { curry } from './curry';\nimport { isPlainObject } from './is-plain-object';\n\n/**\n * Merges the `source` object into the `destination` object. The merge is similar to performing `{ ...destination, ... source }` (where disjoint values from each object would be copied as-is, and for any overlapping props the value from `source` would be used); But for *each prop* (`p`), if **both** `destination` and `source` have a **plain-object** as a value, the value would be taken as the result of recursively deepMerging them (`result.p === deepMerge(destination.p, source.p)`).\n *\n * @param destination - The object to merge into. In general, this object would have it's values overridden.\n * @param source - The object to merge from. In general, shared keys would be taken from this object.\n * @returns The merged object.\n * @signature\n *    mergeDeep(destination, source)\n * @example\n *    mergeDeep({ foo: 'bar', x: 1 }, { foo: 'baz', y: 2 }) // => { foo: 'baz', x: 1, y: 2 }\n * @dataFirst\n * @category Object\n */\nexport function mergeDeep<Destination extends object, Source extends object>(\n  destination: Destination,\n  source: Source,\n): MergeDeep<Destination, Source>;\n\n/**\n * Merges the `source` object into the `destination` object. The merge is similar to performing `{ ...destination, ... source }` (where disjoint values from each object would be copied as-is, and for any overlapping props the value from `source` would be used); But for *each prop* (`p`), if **both** `destination` and `source` have a **plain-object** as a value, the value would be taken as the result of recursively deepMerging them (`result.p === deepMerge(destination.p, source.p)`).\n *\n * @param source - The object to merge from. In general, shared keys would be taken from this object.\n * @returns The merged object.\n * @signature\n *    mergeDeep(source)(destination)\n * @example\n *    pipe(\n *      { foo: 'bar', x: 1 },\n *      mergeDeep({ foo: 'baz', y: 2 }),\n *    );  // => { foo: 'baz', x: 1, y: 2 }\n * @dataLast\n * @category Object\n */\nexport function mergeDeep<Source extends object>(\n  source: Source,\n): <Destination extends object>(\n  target: Destination,\n) => MergeDeep<Destination, Source>;\n\nexport function mergeDeep(...args: ReadonlyArray<unknown>): unknown {\n  return curry(mergeDeepImplementation, args);\n}\n\nfunction mergeDeepImplementation<\n  Destination extends object,\n  Source extends object,\n>(destination: Destination, source: Source): MergeDeep<Destination, Source> {\n  // At this point the output is already merged, simply not deeply merged.\n  const output = { ...destination, ...source } as Record<\n    keyof Destination | keyof Source,\n    unknown\n  >;\n\n  // now just scan the output and look for values that should have been deep-merged\n  // eslint-disable-next-line no-restricted-syntax\n  for (const key in source) {\n    if (!(key in destination)) {\n      // They don't share this key.\n      continue;\n    }\n\n    const { [key]: destinationValue } = destination;\n    if (!isPlainObject(destinationValue)) {\n      // The value in destination is not a mergeable object so the value from\n      // source (which was already copied in the shallow merge) would be used\n      // as-is.\n      continue;\n    }\n\n    const { [key]: sourceValue } = source;\n    if (!isPlainObject(sourceValue)) {\n      // The value in source is not a mergeable object either, so it will\n      // override the object in destination.\n      continue;\n    }\n\n    // Both destination and source have a mergeable object for this key, so we\n    // recursively merge them.\n    // @ts-expect-error [ts2590] - We build the output object iteratively, I don't think it's possible to improve the types here so that typescript infers this correctly.\n    output[key] = mergeDeepImplementation(destinationValue, sourceValue);\n  }\n\n  // @ts-expect-error [ts2322] - We build the output object iteratively, I don't think it's possible to improve the types here so that typescript infers this correctly.\n  return output;\n}\n"],"mappings":"qIA2CA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAOA,EAAAA,MAAM,EAAyB,EAAK,CAG7C,SAAS,EAGP,EAA0B,EAAgD,CAE1E,IAAM,EAAS,CAAE,GAAG,EAAa,GAAG,EAAQ,CAO5C,IAAK,IAAM,KAAO,EAAQ,CACxB,GAAI,EAAE,KAAO,GAEX,SAGF,GAAM,EAAG,GAAM,GAAqB,EACpC,GAAI,CAACC,EAAAA,cAAc,EAAiB,CAIlC,SAGF,GAAM,EAAG,GAAM,GAAgB,EAC1BA,EAAAA,cAAc,EAAY,GAS/B,EAAO,GAAO,EAAwB,EAAkB,EAAY,EAItE,OAAO"}

package/dist/merge-deep.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";import{isPlainObject as t}from"./is-plain-object.js";function n(...t){return e(r,t)}function r(e,n){let i={...e,...n};for(let a in n){if(!(a in e))continue;let{[a]:o}=e;if(!t(o))continue;let{[a]:s}=n;t(s)&&(i[a]=r(o,s))}return i}export{n as mergeDeep};
+import{curry as e}from"./curry.js";import{isPlainObject as t}from"./is-plain-object.js";function n(...t){return e(r,t)}function r(e,n){let i={...e,...n};for(let a in n){if(!(a in e))continue;let{[a]:o}=e;if(!t(o))continue;let{[a]:s}=n;t(s)&&(i[a]=r(o,s))}return i}export{n as mergeDeep};
 //# sourceMappingURL=merge-deep.js.map

package/dist/merge-deep.js.map

@@ -1 +1 @@
-{"version":3,"file":"merge-deep.js","names":[],"sources":["../src/merge-deep.ts"],"sourcesContent":["import type { MergeDeep } from 'type-fest';\n\nimport { curry } from './curry';\nimport { isPlainObject } from './is-plain-object';\n\n/**\n * Merges the `source` object into the `destination` object. The merge is similar to performing `{ ...destination, ... source }` (where disjoint values from each object would be copied as-is, and for any overlapping props the value from `source` would be used); But for *each prop* (`p`), if **both** `destination` and `source` have a **plain-object** as a value, the value would be taken as the result of recursively deepMerging them (`result.p === deepMerge(destination.p, source.p)`).\n *\n * @param destination - The object to merge into. In general, this object would have it's values overridden.\n * @param source - The object to merge from. In general, shared keys would be taken from this object.\n * @returns The merged object.\n * @signature\n *    P.mergeDeep(destination, source)\n * @example\n *    P.mergeDeep({ foo: 'bar', x: 1 }, { foo: 'baz', y: 2 }) // => { foo: 'baz', x: 1, y: 2 }\n * @dataFirst\n * @category Object\n */\nexport function mergeDeep<Destination extends object, Source extends object>(\n  destination: Destination, source: Source\n): MergeDeep<Destination, Source>;\n\n/**\n * Merges the `source` object into the `destination` object. The merge is similar to performing `{ ...destination, ... source }` (where disjoint values from each object would be copied as-is, and for any overlapping props the value from `source` would be used); But for *each prop* (`p`), if **both** `destination` and `source` have a **plain-object** as a value, the value would be taken as the result of recursively deepMerging them (`result.p === deepMerge(destination.p, source.p)`).\n *\n * @param source - The object to merge from. In general, shared keys would be taken from this object.\n * @returns The merged object.\n * @signature\n *    P.mergeDeep(source)(destination)\n * @example\n *    P.pipe(\n *      { foo: 'bar', x: 1 },\n *      P.mergeDeep({ foo: 'baz', y: 2 }),\n *    );  // => { foo: 'baz', x: 1, y: 2 }\n * @dataLast\n * @category Object\n */\nexport function mergeDeep<Source extends object>(\n  source: Source,\n): <Destination extends object>(\n  target: Destination,\n) => MergeDeep<Destination, Source>;\n\nexport function mergeDeep(...args: ReadonlyArray<unknown>): unknown {\n  return curry(mergeDeepImplementation, args);\n}\n\nfunction mergeDeepImplementation<\n  Destination extends object,\n  Source extends object,\n>(destination: Destination, source: Source): MergeDeep<Destination, Source> {\n  // At this point the output is already merged, simply not deeply merged.\n  const output = { ...destination, ...source } as Record<\n    keyof Destination | keyof Source,\n    unknown\n  >;\n\n  // now just scan the output and look for values that should have been deep-merged\n  // eslint-disable-next-line no-restricted-syntax\n  for (const key in source) {\n    if (!(key in destination)) {\n      // They don't share this key.\n      continue;\n    }\n\n    const { [key]: destinationValue } = destination;\n    if (!isPlainObject(destinationValue)) {\n      // The value in destination is not a mergable object so the value from\n      // source (which was already copied in the shallow merge) would be used\n      // as-is.\n      continue;\n    }\n\n    const { [key]: sourceValue } = source;\n    if (!isPlainObject(sourceValue)) {\n      // The value in source is not a mergable object either, so it will\n      // override the object in destination.\n      continue;\n    }\n\n    // Both destination and source have a mergable object for this key, so we\n    // recursively merge them.\n    output[key] = mergeDeepImplementation(destinationValue, sourceValue);\n  }\n\n  // @ts-expect-error [ts2322] - We build the output object iteratively, I don't think it's possible to improve the types here so that typescript infers the right type.\n  return output;\n}\n"],"mappings":"6FA2CA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAO,EAAM,EAAyB,EAAK,CAG7C,SAAS,EAGP,EAA0B,EAAgD,CAE1E,IAAM,EAAS,CAAE,GAAG,EAAa,GAAG,EAAQ,CAO5C,IAAK,IAAM,KAAO,EAAQ,CACxB,GAAI,EAAE,KAAO,GAEX,SAGF,GAAM,EAAG,GAAM,GAAqB,EACpC,GAAI,CAAC,EAAc,EAAiB,CAIlC,SAGF,GAAM,EAAG,GAAM,GAAgB,EAC1B,EAAc,EAAY,GAQ/B,EAAO,GAAO,EAAwB,EAAkB,EAAY,EAItE,OAAO"}
+{"version":3,"file":"merge-deep.js","names":[],"sources":["../src/merge-deep.ts"],"sourcesContent":["import type { MergeDeep } from 'type-fest';\nimport { curry } from './curry';\nimport { isPlainObject } from './is-plain-object';\n\n/**\n * Merges the `source` object into the `destination` object. The merge is similar to performing `{ ...destination, ... source }` (where disjoint values from each object would be copied as-is, and for any overlapping props the value from `source` would be used); But for *each prop* (`p`), if **both** `destination` and `source` have a **plain-object** as a value, the value would be taken as the result of recursively deepMerging them (`result.p === deepMerge(destination.p, source.p)`).\n *\n * @param destination - The object to merge into. In general, this object would have it's values overridden.\n * @param source - The object to merge from. In general, shared keys would be taken from this object.\n * @returns The merged object.\n * @signature\n *    mergeDeep(destination, source)\n * @example\n *    mergeDeep({ foo: 'bar', x: 1 }, { foo: 'baz', y: 2 }) // => { foo: 'baz', x: 1, y: 2 }\n * @dataFirst\n * @category Object\n */\nexport function mergeDeep<Destination extends object, Source extends object>(\n  destination: Destination,\n  source: Source,\n): MergeDeep<Destination, Source>;\n\n/**\n * Merges the `source` object into the `destination` object. The merge is similar to performing `{ ...destination, ... source }` (where disjoint values from each object would be copied as-is, and for any overlapping props the value from `source` would be used); But for *each prop* (`p`), if **both** `destination` and `source` have a **plain-object** as a value, the value would be taken as the result of recursively deepMerging them (`result.p === deepMerge(destination.p, source.p)`).\n *\n * @param source - The object to merge from. In general, shared keys would be taken from this object.\n * @returns The merged object.\n * @signature\n *    mergeDeep(source)(destination)\n * @example\n *    pipe(\n *      { foo: 'bar', x: 1 },\n *      mergeDeep({ foo: 'baz', y: 2 }),\n *    );  // => { foo: 'baz', x: 1, y: 2 }\n * @dataLast\n * @category Object\n */\nexport function mergeDeep<Source extends object>(\n  source: Source,\n): <Destination extends object>(\n  target: Destination,\n) => MergeDeep<Destination, Source>;\n\nexport function mergeDeep(...args: ReadonlyArray<unknown>): unknown {\n  return curry(mergeDeepImplementation, args);\n}\n\nfunction mergeDeepImplementation<\n  Destination extends object,\n  Source extends object,\n>(destination: Destination, source: Source): MergeDeep<Destination, Source> {\n  // At this point the output is already merged, simply not deeply merged.\n  const output = { ...destination, ...source } as Record<\n    keyof Destination | keyof Source,\n    unknown\n  >;\n\n  // now just scan the output and look for values that should have been deep-merged\n  // eslint-disable-next-line no-restricted-syntax\n  for (const key in source) {\n    if (!(key in destination)) {\n      // They don't share this key.\n      continue;\n    }\n\n    const { [key]: destinationValue } = destination;\n    if (!isPlainObject(destinationValue)) {\n      // The value in destination is not a mergeable object so the value from\n      // source (which was already copied in the shallow merge) would be used\n      // as-is.\n      continue;\n    }\n\n    const { [key]: sourceValue } = source;\n    if (!isPlainObject(sourceValue)) {\n      // The value in source is not a mergeable object either, so it will\n      // override the object in destination.\n      continue;\n    }\n\n    // Both destination and source have a mergeable object for this key, so we\n    // recursively merge them.\n    // @ts-expect-error [ts2590] - We build the output object iteratively, I don't think it's possible to improve the types here so that typescript infers this correctly.\n    output[key] = mergeDeepImplementation(destinationValue, sourceValue);\n  }\n\n  // @ts-expect-error [ts2322] - We build the output object iteratively, I don't think it's possible to improve the types here so that typescript infers this correctly.\n  return output;\n}\n"],"mappings":"wFA2CA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAO,EAAM,EAAyB,EAAK,CAG7C,SAAS,EAGP,EAA0B,EAAgD,CAE1E,IAAM,EAAS,CAAE,GAAG,EAAa,GAAG,EAAQ,CAO5C,IAAK,IAAM,KAAO,EAAQ,CACxB,GAAI,EAAE,KAAO,GAEX,SAGF,GAAM,EAAG,GAAM,GAAqB,EACpC,GAAI,CAAC,EAAc,EAAiB,CAIlC,SAGF,GAAM,EAAG,GAAM,GAAgB,EAC1B,EAAc,EAAY,GAS/B,EAAO,GAAO,EAAwB,EAAkB,EAAY,EAItE,OAAO"}

package/dist/merge.cjs

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

package/dist/merge.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.cjs","names":["curry"],"sources":["../src/merge.ts"],"sourcesContent":["import type { Merge } from 'type-fest';\nimport { curry } from './curry';\n\n/**\n * Merges two objects into one by combining their properties, effectively\n * creating a new object that incorporates elements from both. The merge\n * operation prioritizes the second object's properties, allowing them to\n * overwrite those from the first object with the same names.\n *\n * Equivalent to `{ ...data, ...source }`.\n *\n * @param data - The destination object, serving as the basis for the merge.\n * Properties from this object are included in the new object, but will be\n * overwritten by properties from the source object with matching keys.\n * @param source - The source object, whose properties will be included in the\n * new object. If properties in this object share keys with properties in the\n * destination object, the values from the source object will be used in the\n * new object.\n * @returns An object fully containing `source`, and any properties from `data`\n * that don't share a name with any property in `source`.\n * @signature\n *    merge(data, source)\n * @example\n *    merge({ x: 1, y: 2 }, { y: 10, z: 2 }) // => { x: 1, y: 10, z: 2 }\n * @dataFirst\n * @category Object\n */\nexport function merge<T, Source>(data: T, source: Source): Merge<T, Source>;\n\n/**\n * Merges two objects into one by combining their properties, effectively\n * creating a new object that incorporates elements from both. The merge\n * operation prioritizes the second object's properties, allowing them to\n * overwrite those from the first object with the same names.\n *\n * Equivalent to `{ ...data, ...source }`.\n *\n * @param source - The source object, whose properties will be included in the\n * new object. If properties in this object share keys with properties in the\n * destination object, the values from the source object will be used in the\n * new object.\n * @returns An object fully containing `source`, and any properties from `data`\n * that don't share a name with any property in `source`.\n * @signature\n *    merge(source)(data)\n * @example\n *    pipe(\n *      { x: 1, y: 2 },\n *      merge({ y: 10, z: 2 }),\n *    ); // => { x: 1, y: 10, z: 2 }\n * @dataLast\n * @category Object\n */\nexport function merge<Source>(source: Source): <T>(data: T) => Merge<T, Source>;\n\nexport function merge(...args: ReadonlyArray<unknown>): unknown {\n  return curry(mergeImplementation, args);\n}\n\nfunction mergeImplementation<T, Source>(data: T, source: Source): Merge<T, Source> {\n  return { ...data, ...source };\n}\n"],"mappings":"kGAuDA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAOA,EAAAA,MAAM,EAAqB,EAAK,CAGzC,SAAS,EAA+B,EAAS,EAAkC,CACjF,MAAO,CAAE,GAAG,EAAM,GAAG,EAAQ"}

package/dist/merge.js

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

package/dist/merge.js.map

@@ -1 +1 @@
-{"version":3,"file":"merge.js","names":[],"sources":["../src/merge.ts"],"sourcesContent":["import type { Merge } from 'type-fest';\n\nimport { curry } from './curry';\n\n/**\n * Merges two objects into one by combining their properties, effectively\n * creating a new object that incorporates elements from both. The merge\n * operation prioritizes the second object's properties, allowing them to\n * overwrite those from the first object with the same names.\n *\n * Equivalent to `{ ...data, ...source }`.\n *\n * @param data - The destination object, serving as the basis for the merge.\n * Properties from this object are included in the new object, but will be\n * overwritten by properties from the source object with matching keys.\n * @param source - The source object, whose properties will be included in the\n * new object. If properties in this object share keys with properties in the\n * destination object, the values from the source object will be used in the\n * new object.\n * @returns An object fully containing `source`, and any properties from `data`\n * that don't share a name with any property in `source`.\n * @signature\n *    P.merge(data, source)\n * @example\n *    P.merge({ x: 1, y: 2 }, { y: 10, z: 2 }) // => { x: 1, y: 10, z: 2 }\n * @dataFirst\n * @category Object\n */\nexport function merge<T, Source>(data: T, source: Source): Merge<T, Source>;\n\n/**\n * Merges two objects into one by combining their properties, effectively\n * creating a new object that incorporates elements from both. The merge\n * operation prioritizes the second object's properties, allowing them to\n * overwrite those from the first object with the same names.\n *\n * Equivalent to `{ ...data, ...source }`.\n *\n * @param source - The source object, whose properties will be included in the\n * new object. If properties in this object share keys with properties in the\n * destination object, the values from the source object will be used in the\n * new object.\n * @returns An object fully containing `source`, and any properties from `data`\n * that don't share a name with any property in `source`.\n * @signature\n *    P.merge(source)(data)\n * @example\n *    P.pipe(\n *      { x: 1, y: 2 },\n *      P.merge({ y: 10, z: 2 }),\n *    ); // => { x: 1, y: 10, z: 2 }\n * @dataLast\n * @category Object\n */\nexport function merge<Source>(source: Source): <T>(data: T) => Merge<T, Source>;\n\nexport function merge(...args: ReadonlyArray<unknown>): unknown {\n  return curry(mergeImplementation, args);\n}\n\nfunction mergeImplementation<T, Source>(\n  data: T,\n  source: Source,\n): Merge<T, Source> {\n  return ({ ...data, ...source });\n}\n"],"mappings":"wCAwDA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAqB,EAAK,CAGzC,SAAS,EACP,EACA,EACkB,CAClB,MAAQ,CAAE,GAAG,EAAM,GAAG,EAAQ"}
+{"version":3,"file":"merge.js","names":[],"sources":["../src/merge.ts"],"sourcesContent":["import type { Merge } from 'type-fest';\nimport { curry } from './curry';\n\n/**\n * Merges two objects into one by combining their properties, effectively\n * creating a new object that incorporates elements from both. The merge\n * operation prioritizes the second object's properties, allowing them to\n * overwrite those from the first object with the same names.\n *\n * Equivalent to `{ ...data, ...source }`.\n *\n * @param data - The destination object, serving as the basis for the merge.\n * Properties from this object are included in the new object, but will be\n * overwritten by properties from the source object with matching keys.\n * @param source - The source object, whose properties will be included in the\n * new object. If properties in this object share keys with properties in the\n * destination object, the values from the source object will be used in the\n * new object.\n * @returns An object fully containing `source`, and any properties from `data`\n * that don't share a name with any property in `source`.\n * @signature\n *    merge(data, source)\n * @example\n *    merge({ x: 1, y: 2 }, { y: 10, z: 2 }) // => { x: 1, y: 10, z: 2 }\n * @dataFirst\n * @category Object\n */\nexport function merge<T, Source>(data: T, source: Source): Merge<T, Source>;\n\n/**\n * Merges two objects into one by combining their properties, effectively\n * creating a new object that incorporates elements from both. The merge\n * operation prioritizes the second object's properties, allowing them to\n * overwrite those from the first object with the same names.\n *\n * Equivalent to `{ ...data, ...source }`.\n *\n * @param source - The source object, whose properties will be included in the\n * new object. If properties in this object share keys with properties in the\n * destination object, the values from the source object will be used in the\n * new object.\n * @returns An object fully containing `source`, and any properties from `data`\n * that don't share a name with any property in `source`.\n * @signature\n *    merge(source)(data)\n * @example\n *    pipe(\n *      { x: 1, y: 2 },\n *      merge({ y: 10, z: 2 }),\n *    ); // => { x: 1, y: 10, z: 2 }\n * @dataLast\n * @category Object\n */\nexport function merge<Source>(source: Source): <T>(data: T) => Merge<T, Source>;\n\nexport function merge(...args: ReadonlyArray<unknown>): unknown {\n  return curry(mergeImplementation, args);\n}\n\nfunction mergeImplementation<T, Source>(data: T, source: Source): Merge<T, Source> {\n  return { ...data, ...source };\n}\n"],"mappings":"mCAuDA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAqB,EAAK,CAGzC,SAAS,EAA+B,EAAS,EAAkC,CACjF,MAAO,CAAE,GAAG,EAAM,GAAG,EAAQ"}

package/dist/multiply.cjs

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

package/dist/multiply.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"multiply.cjs","names":["curry"],"sources":["../src/multiply.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Multiplies two numbers.\n *\n * @param value - The number.\n * @param multiplicand - The number to multiply the value by.\n * @signature\n *    multiply(value, multiplicand);\n * @example\n *    multiply(3, 4) // => 12\n *    reduce([1, 2, 3, 4], multiply, 1) // => 24\n * @dataFirst\n * @category Number\n */\nexport function multiply(value: bigint, multiplicand: bigint): bigint;\nexport function multiply(value: number, multiplicand: number): number;\n\n/**\n * Multiplies two numbers.\n *\n * @param multiplicand - The number to multiply the value by.\n * @signature\n *    multiply(multiplicand)(value);\n * @example\n *    multiply(4)(3) // => 12\n *    map([1, 2, 3, 4], multiply(2)) // => [2, 4, 6, 8]\n * @dataLast\n * @category Number\n */\nexport function multiply(multiplicand: bigint): (value: bigint) => bigint;\nexport function multiply(multiplicand: number): (value: number) => number;\n\nexport function multiply(...args: ReadonlyArray<unknown>): unknown {\n  return curry(multiplyImplementation, 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 multiplicand would be of the same\n// type.\nfunction multiplyImplementation(value: number, multiplicand: number): number {\n  return value * multiplicand;\n}\n"],"mappings":"kGAiCA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAOA,EAAAA,MAAM,EAAwB,EAAK,CAM5C,SAAS,EAAuB,EAAe,EAA8B,CAC3E,OAAO,EAAQ"}

package/dist/multiply.js

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

package/dist/multiply.js.map

@@ -1 +1 @@
-{"version":3,"file":"multiply.js","names":[],"sources":["../src/multiply.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Multiplies two numbers.\n *\n * @param value - The number.\n * @param multiplicand - The number to multiply the value by.\n * @signature\n *    P.multiply(value, multiplicand);\n * @example\n *    P.multiply(3, 4) // => 12\n *    P.reduce([1, 2, 3, 4], P.multiply, 1) // => 24\n * @dataFirst\n * @category Number\n */\nexport function multiply(value: bigint, multiplicand: bigint): bigint;\nexport function multiply(value: number, multiplicand: number): number;\n\n/**\n * Multiplies two numbers.\n *\n * @param multiplicand - The number to multiply the value by.\n * @signature\n *    P.multiply(multiplicand)(value);\n * @example\n *    P.multiply(4)(3) // => 12\n *    P.map([1, 2, 3, 4], P.multiply(2)) // => [2, 4, 6, 8]\n * @dataLast\n * @category Number\n */\nexport function multiply(multiplicand: bigint): (value: bigint) => bigint;\nexport function multiply(multiplicand: number): (value: number) => number;\n\nexport function multiply(...args: ReadonlyArray<unknown>): unknown {\n  return curry(multiplyImplementation, 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 multiplicand would be of the same\n// type.\nfunction multiplyImplementation(value: number, multiplicand: number): number {\n  return value * multiplicand;\n}\n"],"mappings":"wCAiCA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAM,EAAwB,EAAK,CAM5C,SAAS,EAAuB,EAAe,EAA8B,CAC3E,OAAO,EAAQ"}
+{"version":3,"file":"multiply.js","names":[],"sources":["../src/multiply.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Multiplies two numbers.\n *\n * @param value - The number.\n * @param multiplicand - The number to multiply the value by.\n * @signature\n *    multiply(value, multiplicand);\n * @example\n *    multiply(3, 4) // => 12\n *    reduce([1, 2, 3, 4], multiply, 1) // => 24\n * @dataFirst\n * @category Number\n */\nexport function multiply(value: bigint, multiplicand: bigint): bigint;\nexport function multiply(value: number, multiplicand: number): number;\n\n/**\n * Multiplies two numbers.\n *\n * @param multiplicand - The number to multiply the value by.\n * @signature\n *    multiply(multiplicand)(value);\n * @example\n *    multiply(4)(3) // => 12\n *    map([1, 2, 3, 4], multiply(2)) // => [2, 4, 6, 8]\n * @dataLast\n * @category Number\n */\nexport function multiply(multiplicand: bigint): (value: bigint) => bigint;\nexport function multiply(multiplicand: number): (value: number) => number;\n\nexport function multiply(...args: ReadonlyArray<unknown>): unknown {\n  return curry(multiplyImplementation, 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 multiplicand would be of the same\n// type.\nfunction multiplyImplementation(value: number, multiplicand: number): number {\n  return value * multiplicand;\n}\n"],"mappings":"mCAiCA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAM,EAAwB,EAAK,CAM5C,SAAS,EAAuB,EAAe,EAA8B,CAC3E,OAAO,EAAQ"}

package/dist/nth-by-DhfNV5xd.js

@@ -0,0 +1,2 @@
+import{n as e}from"./curry-order-rules-BLyCSMdZ.js";import{t}from"./swap-in-place-BzNaxwB3.js";function n(e,t,n){return t<0||t>=e.length?void 0:r([...e],0,e.length-1,t,n)}function r(e,t,n,a,o){if(t===n)return e[t];let s=i(e,t,n,o);return a===s?e[a]:r(e,a<s?t:s+1,a<s?s-1:n,a,o)}function i(e,n,r,i){let a=e[r],o=n;for(let s=n;s<r;s++)i(e[s],a)<0&&(t(e,o,s),o+=1);return t(e,o,r),o}function a(...t){return e(o,t)}function o(e,t,r){return n(e,r>=0?r:e.length+r,t)}export{a as t};
+//# sourceMappingURL=nth-by-DhfNV5xd.js.map

package/dist/nth-by-DhfNV5xd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nth-by-DhfNV5xd.js","names":[],"sources":["../src/internal/quick-select.ts","../src/nth-by.ts"],"sourcesContent":["/**\n * A simple implementation of the *QuickSelect* algorithm.\n *\n * @see https://en.wikipedia.org/wiki/Quickselect\n */\n\nimport type { CompareFunction } from './types/compare-function';\nimport { swapInPlace } from './swap-in-place';\n\n/**\n * Perform QuickSelect on the given data. Notice that the data would be cloned\n * shallowly so that it could be mutated in-place, and then discarded once the\n * algorithm is done. This means that running this function multiple times on\n * the same array might be slower then sorting the array before.\n *\n * @param data - The data to perform the selection on.\n * @param index - The index of the item we are looking for.\n * @param compareFn - The compare function to use for sorting.\n * @returns The item at the given index, or `undefined` if the index is out-of-\n * bounds.\n */\nexport function quickSelect<T>(data: ReadonlyArray<T>, index: number, compareFn: CompareFunction<T>): T | undefined {\n  return index < 0 || index >= data.length\n    ? // Quickselect doesn't work with out-of-bound indices\n    undefined\n    : quickSelectImplementation(\n        // We need to clone the array because quickSelect mutates it in-place.\n        [...data],\n        0 /* left */,\n        data.length - 1 /* right */,\n        index,\n        compareFn,\n      );\n}\n\n/**\n * The actual implementation, called recursively.\n */\nfunction quickSelectImplementation<T>(\n  data: Array<T>,\n  left: number,\n  right: number,\n  index: number,\n  compareFn: CompareFunction<T>,\n): T {\n  if (left === right) {\n    return data[left]!;\n  }\n\n  const pivotIndex = partition(data, left, right, compareFn);\n\n  return index === pivotIndex\n    ? // Once a pivot is chosen it's location is final, so if it matches the\n  // index we found out item!\n    data[index]!\n    : quickSelectImplementation(\n        data,\n        // We continue by recursing into the partition where index would be\n        index < pivotIndex ? left : pivotIndex + 1,\n        index < pivotIndex ? pivotIndex - 1 : right,\n        index,\n        compareFn,\n      );\n}\n\nfunction partition<T>(\n  data: Array<T>,\n  left: number,\n  right: number,\n  compareFn: CompareFunction<T>,\n): number {\n  const pivot = data[right]!;\n\n  let i = left;\n  for (let j = left; j < right; j++) {\n    if (compareFn(data[j]!, pivot) < 0) {\n      // Move items smaller then the pivot to the start of the array.\n      swapInPlace(data, i, j);\n      i += 1;\n    }\n  }\n\n  swapInPlace(data, i, right);\n\n  // The location of the pivot by the end of the partition function.\n  return i;\n}\n","import type { OrderRule } from './internal/curry-order-rules';\nimport type { CompareFunction } from './internal/types/compare-function';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport {\n  curryOrderRulesWithArgument,\n\n} from './internal/curry-order-rules';\nimport { quickSelect } from './internal/quick-select';\n\n/**\n * Retrieves the element that would be at the given index if the array were sorted according to specified rules. This function uses the *QuickSelect* algorithm running at an average complexity of *O(n)*. Semantically it is equivalent to `sortBy(data, ...rules).at(index)` which would run at *O(nlogn)*.\n *\n * See also `firstBy` which provides an even more efficient algorithm and a stricter return type, but only for `index === 0`. See `takeFirstBy` to get all the elements up to and including `index`.\n *\n * @param data - The input array.\n * @param index - The zero-based index for selecting the element in the sorted order. Negative indices count backwards from the end.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns The element at the specified index in the sorted order, or `undefined` if the index is out of bounds.\n * @signature\n *   nthBy(data, index, ...rules);\n * @example\n *   nthBy([2,1,4,5,3,], 2, identity()); // => 3\n * @dataFirst\n * @category Array\n */\nexport function nthBy<T extends IterableContainer>(\n  data: T,\n  index: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): T[number] | undefined;\n\n/**\n * Retrieves the element that would be at the given index if the array were sorted according to specified rules. This function uses the *QuickSelect* algorithm running at an average complexity of *O(n)*. Semantically it is equivalent to `sortBy(data, ...rules)[index]` which would run at *O(nlogn)*.\n *\n * See also `firstBy` which provides an even more efficient algorithm and a stricter return type, but only for `index === 0`. See `takeFirstBy` to get all the elements up to and including `index`.\n *\n * @param index - The zero-based index for selecting the element in the sorted order. Negative indices count backwards from the end.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns The element at the specified index in the sorted order, or `undefined` if the index is out of bounds.\n * @signature\n *   nthBy(index, ...rules)(data);\n * @example\n *   pipe([2,1,4,5,3,], nthBy(2, identity())); // => 3\n * @dataLast\n * @category Array\n */\nexport function nthBy<T extends IterableContainer>(\n  index: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): (data: T) => T[number] | undefined;\n\nexport function nthBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryOrderRulesWithArgument(nthByImplementation, args);\n}\n\nfunction nthByImplementation<T>(data: ReadonlyArray<T>, compareFn: CompareFunction<T>, index: number): T | undefined {\n  return quickSelect(\n    data,\n    // Allow negative indices gracefully\n    index >= 0 ? index : data.length + index,\n    compareFn,\n  );\n}\n"],"mappings":"+FAqBA,SAAgB,EAAe,EAAwB,EAAe,EAA8C,CAClH,OAAO,EAAQ,GAAK,GAAS,EAAK,OAEhC,IAAA,GACE,EAEE,CAAC,GAAG,EAAK,CACT,EACA,EAAK,OAAS,EACd,EACA,EACD,CAMP,SAAS,EACP,EACA,EACA,EACA,EACA,EACG,CACH,GAAI,IAAS,EACX,OAAO,EAAK,GAGd,IAAM,EAAa,EAAU,EAAM,EAAM,EAAO,EAAU,CAE1D,OAAO,IAAU,EAGf,EAAK,GACH,EACE,EAEA,EAAQ,EAAa,EAAO,EAAa,EACzC,EAAQ,EAAa,EAAa,EAAI,EACtC,EACA,EACD,CAGP,SAAS,EACP,EACA,EACA,EACA,EACQ,CACR,IAAM,EAAQ,EAAK,GAEf,EAAI,EACR,IAAK,IAAI,EAAI,EAAM,EAAI,EAAO,IACxB,EAAU,EAAK,GAAK,EAAM,CAAG,IAE/B,EAAY,EAAM,EAAG,EAAE,CACvB,GAAK,GAOT,OAHA,EAAY,EAAM,EAAG,EAAM,CAGpB,ECjCT,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAA4B,EAAqB,EAAK,CAG/D,SAAS,EAAuB,EAAwB,EAA+B,EAA8B,CACnH,OAAO,EACL,EAEA,GAAS,EAAI,EAAQ,EAAK,OAAS,EACnC,EACD"}

package/dist/nth-by-zZ3RM-mR.cjs

@@ -0,0 +1,2 @@
+const e=require(`./curry-order-rules-DsJSy3gX.cjs`),t=require(`./swap-in-place-D1vasegg.cjs`);function n(e,t,n){return t<0||t>=e.length?void 0:r([...e],0,e.length-1,t,n)}function r(e,t,n,a,o){if(t===n)return e[t];let s=i(e,t,n,o);return a===s?e[a]:r(e,a<s?t:s+1,a<s?s-1:n,a,o)}function i(e,n,r,i){let a=e[r],o=n;for(let s=n;s<r;s++)i(e[s],a)<0&&(t.t(e,o,s),o+=1);return t.t(e,o,r),o}function a(...t){return e.n(o,t)}function o(e,t,r){return n(e,r>=0?r:e.length+r,t)}Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return a}});
+//# sourceMappingURL=nth-by-zZ3RM-mR.cjs.map

package/dist/nth-by-zZ3RM-mR.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"nth-by-zZ3RM-mR.cjs","names":["curryOrderRulesWithArgument"],"sources":["../src/internal/quick-select.ts","../src/nth-by.ts"],"sourcesContent":["/**\n * A simple implementation of the *QuickSelect* algorithm.\n *\n * @see https://en.wikipedia.org/wiki/Quickselect\n */\n\nimport type { CompareFunction } from './types/compare-function';\nimport { swapInPlace } from './swap-in-place';\n\n/**\n * Perform QuickSelect on the given data. Notice that the data would be cloned\n * shallowly so that it could be mutated in-place, and then discarded once the\n * algorithm is done. This means that running this function multiple times on\n * the same array might be slower then sorting the array before.\n *\n * @param data - The data to perform the selection on.\n * @param index - The index of the item we are looking for.\n * @param compareFn - The compare function to use for sorting.\n * @returns The item at the given index, or `undefined` if the index is out-of-\n * bounds.\n */\nexport function quickSelect<T>(data: ReadonlyArray<T>, index: number, compareFn: CompareFunction<T>): T | undefined {\n  return index < 0 || index >= data.length\n    ? // Quickselect doesn't work with out-of-bound indices\n    undefined\n    : quickSelectImplementation(\n        // We need to clone the array because quickSelect mutates it in-place.\n        [...data],\n        0 /* left */,\n        data.length - 1 /* right */,\n        index,\n        compareFn,\n      );\n}\n\n/**\n * The actual implementation, called recursively.\n */\nfunction quickSelectImplementation<T>(\n  data: Array<T>,\n  left: number,\n  right: number,\n  index: number,\n  compareFn: CompareFunction<T>,\n): T {\n  if (left === right) {\n    return data[left]!;\n  }\n\n  const pivotIndex = partition(data, left, right, compareFn);\n\n  return index === pivotIndex\n    ? // Once a pivot is chosen it's location is final, so if it matches the\n  // index we found out item!\n    data[index]!\n    : quickSelectImplementation(\n        data,\n        // We continue by recursing into the partition where index would be\n        index < pivotIndex ? left : pivotIndex + 1,\n        index < pivotIndex ? pivotIndex - 1 : right,\n        index,\n        compareFn,\n      );\n}\n\nfunction partition<T>(\n  data: Array<T>,\n  left: number,\n  right: number,\n  compareFn: CompareFunction<T>,\n): number {\n  const pivot = data[right]!;\n\n  let i = left;\n  for (let j = left; j < right; j++) {\n    if (compareFn(data[j]!, pivot) < 0) {\n      // Move items smaller then the pivot to the start of the array.\n      swapInPlace(data, i, j);\n      i += 1;\n    }\n  }\n\n  swapInPlace(data, i, right);\n\n  // The location of the pivot by the end of the partition function.\n  return i;\n}\n","import type { OrderRule } from './internal/curry-order-rules';\nimport type { CompareFunction } from './internal/types/compare-function';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport {\n  curryOrderRulesWithArgument,\n\n} from './internal/curry-order-rules';\nimport { quickSelect } from './internal/quick-select';\n\n/**\n * Retrieves the element that would be at the given index if the array were sorted according to specified rules. This function uses the *QuickSelect* algorithm running at an average complexity of *O(n)*. Semantically it is equivalent to `sortBy(data, ...rules).at(index)` which would run at *O(nlogn)*.\n *\n * See also `firstBy` which provides an even more efficient algorithm and a stricter return type, but only for `index === 0`. See `takeFirstBy` to get all the elements up to and including `index`.\n *\n * @param data - The input array.\n * @param index - The zero-based index for selecting the element in the sorted order. Negative indices count backwards from the end.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns The element at the specified index in the sorted order, or `undefined` if the index is out of bounds.\n * @signature\n *   nthBy(data, index, ...rules);\n * @example\n *   nthBy([2,1,4,5,3,], 2, identity()); // => 3\n * @dataFirst\n * @category Array\n */\nexport function nthBy<T extends IterableContainer>(\n  data: T,\n  index: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): T[number] | undefined;\n\n/**\n * Retrieves the element that would be at the given index if the array were sorted according to specified rules. This function uses the *QuickSelect* algorithm running at an average complexity of *O(n)*. Semantically it is equivalent to `sortBy(data, ...rules)[index]` which would run at *O(nlogn)*.\n *\n * See also `firstBy` which provides an even more efficient algorithm and a stricter return type, but only for `index === 0`. See `takeFirstBy` to get all the elements up to and including `index`.\n *\n * @param index - The zero-based index for selecting the element in the sorted order. Negative indices count backwards from the end.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns The element at the specified index in the sorted order, or `undefined` if the index is out of bounds.\n * @signature\n *   nthBy(index, ...rules)(data);\n * @example\n *   pipe([2,1,4,5,3,], nthBy(2, identity())); // => 3\n * @dataLast\n * @category Array\n */\nexport function nthBy<T extends IterableContainer>(\n  index: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): (data: T) => T[number] | undefined;\n\nexport function nthBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryOrderRulesWithArgument(nthByImplementation, args);\n}\n\nfunction nthByImplementation<T>(data: ReadonlyArray<T>, compareFn: CompareFunction<T>, index: number): T | undefined {\n  return quickSelect(\n    data,\n    // Allow negative indices gracefully\n    index >= 0 ? index : data.length + index,\n    compareFn,\n  );\n}\n"],"mappings":"8FAqBA,SAAgB,EAAe,EAAwB,EAAe,EAA8C,CAClH,OAAO,EAAQ,GAAK,GAAS,EAAK,OAEhC,IAAA,GACE,EAEE,CAAC,GAAG,EAAK,CACT,EACA,EAAK,OAAS,EACd,EACA,EACD,CAMP,SAAS,EACP,EACA,EACA,EACA,EACA,EACG,CACH,GAAI,IAAS,EACX,OAAO,EAAK,GAGd,IAAM,EAAa,EAAU,EAAM,EAAM,EAAO,EAAU,CAE1D,OAAO,IAAU,EAGf,EAAK,GACH,EACE,EAEA,EAAQ,EAAa,EAAO,EAAa,EACzC,EAAQ,EAAa,EAAa,EAAI,EACtC,EACA,EACD,CAGP,SAAS,EACP,EACA,EACA,EACA,EACQ,CACR,IAAM,EAAQ,EAAK,GAEf,EAAI,EACR,IAAK,IAAI,EAAI,EAAM,EAAI,EAAO,IACxB,EAAU,EAAK,GAAK,EAAM,CAAG,IAE/B,EAAA,EAAY,EAAM,EAAG,EAAE,CACvB,GAAK,GAOT,OAHA,EAAA,EAAY,EAAM,EAAG,EAAM,CAGpB,ECjCT,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAOA,EAAAA,EAA4B,EAAqB,EAAK,CAG/D,SAAS,EAAuB,EAAwB,EAA+B,EAA8B,CACnH,OAAO,EACL,EAEA,GAAS,EAAI,EAAQ,EAAK,OAAS,EACnC,EACD"}

package/dist/nth-by.cjs

@@ -1 +1 @@
-const e=require(`./nth-by-Bby4vIbZ.cjs`);exports.nthBy=e.t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./nth-by-zZ3RM-mR.cjs`);exports.nthBy=e.t;

package/dist/nth-by.js

@@ -1 +1 @@
-import{t as e}from"./nth-by-JP3-Htbo.js";export{e as nthBy};
+import{t as e}from"./nth-by-DhfNV5xd.js";export{e as nthBy};

package/dist/obj-of.cjs

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

package/dist/obj-of.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"obj-of.cjs","names":["curry"],"sources":["../src/obj-of.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Creates an object containing a single `key:value` pair.\n *\n * @param value - The object value.\n * @param key - The property name.\n * @signature\n *    objOf(value, key)\n * @example\n *    objOf(10, 'a') // => { a: 10 }\n * @category Object\n */\nexport function objOf<T, K extends string>(value: T, key: K): Record<K, T>;\n\n/**\n * Creates an object containing a single `key:value` pair.\n *\n * @param key - The property name.\n * @signature\n *    objOf(key)(value)\n * @example\n *    pipe(10, objOf('a')) // => { a: 10 }\n * @category Object\n */\nexport function objOf<T, K extends string>(key: K): (value: T) => Record<K, T>;\n\nexport function objOf(...args: ReadonlyArray<unknown>): unknown {\n  return curry(objOfImplementation, args);\n}\n\nfunction objOfImplementation<T, K extends string>(value: T, key: K): Record<K, T> {\n  return { [key]: value };\n}\n"],"mappings":"kGA2BA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAOA,EAAAA,MAAM,EAAqB,EAAK,CAGzC,SAAS,EAAyC,EAAU,EAAsB,CAChF,MAAO,EAAG,GAAM,EAAO"}

package/dist/obj-of.js

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

package/dist/obj-of.js.map

@@ -1 +1 @@
-{"version":3,"file":"obj-of.js","names":[],"sources":["../src/obj-of.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Creates an object containing a single `key:value` pair.\n *\n * @param value - The object value.\n * @param key - The property name.\n * @signature\n *    P.objOf(value, key)\n * @example\n *    P.objOf(10, 'a') // => { a: 10 }\n * @category Object\n */\nexport function objOf<T, K extends string>(value: T, key: K): { [x in K]: T };\n\n/**\n * Creates an object containing a single `key:value` pair.\n *\n * @param key - The property name.\n * @signature\n *    P.objOf(key)(value)\n * @example\n *    P.pipe(10, P.objOf('a')) // => { a: 10 }\n * @category Object\n */\nexport function objOf<T, K extends string>(\n  key: K,\n): (value: T) => { [x in K]: T };\n\nexport function objOf(...args: ReadonlyArray<unknown>): unknown {\n  return curry(objOfImplementation, args);\n}\n\nfunction objOfImplementation<T, K extends string>(\n  value: T,\n  key: K,\n): { [x in K]: T } {\n  // @ts-expect-error [ts2322] - I'm not sure how to get the type right here...\n  return ({ [key]: value });\n}\n"],"mappings":"wCA6BA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAqB,EAAK,CAGzC,SAAS,EACP,EACA,EACiB,CAEjB,MAAQ,EAAG,GAAM,EAAO"}
+{"version":3,"file":"obj-of.js","names":[],"sources":["../src/obj-of.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Creates an object containing a single `key:value` pair.\n *\n * @param value - The object value.\n * @param key - The property name.\n * @signature\n *    objOf(value, key)\n * @example\n *    objOf(10, 'a') // => { a: 10 }\n * @category Object\n */\nexport function objOf<T, K extends string>(value: T, key: K): Record<K, T>;\n\n/**\n * Creates an object containing a single `key:value` pair.\n *\n * @param key - The property name.\n * @signature\n *    objOf(key)(value)\n * @example\n *    pipe(10, objOf('a')) // => { a: 10 }\n * @category Object\n */\nexport function objOf<T, K extends string>(key: K): (value: T) => Record<K, T>;\n\nexport function objOf(...args: ReadonlyArray<unknown>): unknown {\n  return curry(objOfImplementation, args);\n}\n\nfunction objOfImplementation<T, K extends string>(value: T, key: K): Record<K, T> {\n  return { [key]: value };\n}\n"],"mappings":"mCA2BA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAqB,EAAK,CAGzC,SAAS,EAAyC,EAAU,EAAsB,CAChF,MAAO,EAAG,GAAM,EAAO"}

package/dist/omit-by.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){let n={...e};for(let[r,i]of Object.entries(n))t(i,r,e)&&delete n[r];return n}exports.omitBy=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){let n={...e};for(let[r,i]of Object.entries(n))t(i,r,e)&&delete n[r];return n}exports.omitBy=t;
+//# sourceMappingURL=omit-by.cjs.map

package/dist/omit-by.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"omit-by.cjs","names":["curry"],"sources":["../src/omit-by.ts"],"sourcesContent":["import type { IsNever, Or, Simplify } from 'type-fest';\nimport type { EnumerableStringKeyOf } from './internal/types/enumerable-string-key-of';\nimport type { EnumerableStringKeyedValueOf } from './internal/types/enumerable-string-keyed-value-of';\nimport type { IsBoundedRecord } from './internal/types/is-bounded-record';\nimport { curry } from './curry';\n\n// Symbols are not passed to the predicate (because they can't be enumerated\n// with the `Object.entries` function) and the output object is built from a\n// shallow copy of the input; meaning symbols would just be passed through as-\n// is.\ntype PickSymbolKeys<T extends object> = {\n  -readonly [P in keyof T as P extends symbol ? P : never]: T[P];\n};\n\n// When we don't use a type-predicate we can't say anything about what props\n// would be omitted from the output, so we need to assume any of them could be\n// filtered out. This means that we effectively make all (enumerable) keys\n// optional.\ntype PartialEnumerableKeys<T extends object>\n  // `extends unknown` is always going to be the case and is used to convert any\n  // union into a [distributive conditional type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).\n  = T extends unknown\n    ? Simplify<\n      IsBoundedRecord<T> extends true ? PickSymbolKeys<T> & {\n        -readonly [P in keyof T as P extends symbol\n          ? never\n          : P]?: Required<T>[P];\n      }\n        : // This is the type you'd get from doing:\n      // `Object.fromEntries(Object.entries(x))`.\n        Record<EnumerableStringKeyOf<T>, EnumerableStringKeyedValueOf<T>>\n    >\n    : never;\n\n// When the predicate is a type-guard we have more information to work with when\n// constructing the type of the output object. We can safely remove any property\n// which value would always be true for the predicate, AND we can also\n// assume that properties that are rejected by the predicate perfectly would\n// **always** show up in the output object. Hence to build the output object we\n// need to build and merge 2 output objects: One for the properties which have a\n// value of at type that would always yield a `false` result from the predicate,\n// these are the \"matches\", which would not change the \"optionality\" of the\n// input object's props, and one for partial matches which would also make the\n// props optional (as they could have a value that would be filtered out).\ntype PartialEnumerableKeysNarrowed<T extends object, S> = Simplify<\n  ExactProps<T, S> & PartialProps<T, S> & PickSymbolKeys<T>\n>;\n\n// The exact case, props here would always be part of the output object\ntype ExactProps<T, S> = {\n  -readonly [P in keyof T as IsExactProp<T, P, S> extends true\n    ? P\n    : never]: Exclude<T[P], S>;\n};\n\n// The partial case, props here might be part of the output object, but might\n// not be, hence they are optional.\ntype PartialProps<T, S> = {\n  -readonly [P in keyof T as IsPartialProp<T, P, S> extends true\n    ? P\n    : never]?: Exclude<T[P], S>;\n};\n\n// If the input object's value type extends itself when the type-guard is\n// excluded from it we can safely assume that the predicate would always return\n// `false` for any value of that property.\ntype IsExactProp<T, P extends keyof T, S> = P extends symbol\n  ? // Symbols are passed through via the PickSymbolKeys type\n  false\n  : T[P] extends Exclude<T[P], S>\n    ? S extends T[P]\n      ? // If S extends the T[P] it means the type the predicate is narrowing to\n    // can't narrow the rejected value any further, so we can't say what\n    // would happen for a concrete value in runtime (e.g. if T[P] is\n    // `number` and S is `1`: `Exclude<number, 1> === number`.\n      false\n      : true\n    : false;\n\n// ...and if the input object's value type isn't an exact match, but still has\n// some partial match (i.g. the extracted type-guard isn't completely disjoint)\n// then we can assume that the property can sometimes return true, and sometimes\n// false when passed to the predicate, hence it should be optional in the\n// output.\ntype IsPartialProp<T, P extends keyof T, S> = P extends symbol\n  ? // Symbols are passed through via the PickSymbolKeys type\n  false\n  : Or<IsExactProp<T, P, S>, IsNever<Exclude<Required<T>[P], S>>> extends true\n    ? false\n    : true;\n\n/**\n * Creates a shallow copy of the data, and then removes any keys that the\n * predicate rejects. Symbol keys are not passed to the predicate and would be\n * passed through to the output as-is.\n *\n * See `pickBy` for a complementary function which starts with an empty object\n * and adds the entries that the predicate accepts. Because it is additive,\n * symbol keys will not be passed through to the output object.\n *\n * @param data - The target object.\n * @param predicate - A function that takes the value, key, and the data itself\n * and returns `true` if the entry shouldn't be part of the output object, or\n * `false` to keep it. If the function is a type-guard on the value the output\n * type would be narrowed accordingly.\n * @returns A shallow copy of the input object with the rejected entries\n * removed.\n * @signature omitBy(data, predicate)\n * @example\n *    omitBy({a: 1, b: 2, A: 3, B: 4}, (val, key) => key.toUpperCase() === key) // => {a: 1, b: 2}\n * @dataFirst\n * @category Object\n */\nexport function omitBy<\n  T extends object,\n  S extends EnumerableStringKeyedValueOf<T>,\n>(\n  data: T,\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => value is S,\n): PartialEnumerableKeysNarrowed<T, S>;\nexport function omitBy<T extends object>(\n  data: T,\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => boolean,\n): PartialEnumerableKeys<T>;\n\n/**\n * Returns a partial copy of an object omitting the keys matching predicate.\n *\n * @param predicate - The predicate.\n * @signature omitBy(fn)(object)\n * @example\n *    omitBy((val, key) => key.toUpperCase() === key)({a: 1, b: 2, A: 3, B: 4}) // => {a: 1, b: 2}\n * @dataLast\n * @category Object\n */\nexport function omitBy<\n  T extends object,\n  S extends EnumerableStringKeyedValueOf<T>,\n>(\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => value is S,\n): (data: T) => PartialEnumerableKeysNarrowed<T, S>;\nexport function omitBy<T extends object>(\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => boolean,\n): (data: T) => PartialEnumerableKeys<T>;\n\nexport function omitBy(...args: ReadonlyArray<unknown>): unknown {\n  return curry(omitByImplementation, args);\n}\n\nfunction omitByImplementation<T extends object>(\n  data: T,\n  predicate: (value: unknown, key: string, data: T) => boolean,\n): Record<string, unknown> {\n  const out: Partial<Record<string, unknown>> = { ...data };\n\n  for (const [key, value] of Object.entries(out)) {\n    if (predicate(value, key, data)) {\n      // eslint-disable-next-line ts/no-dynamic-delete -- This is the best way to do it!\n      delete out[key];\n    }\n  }\n\n  return out;\n}\n"],"mappings":"kGAiKA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAOA,EAAAA,MAAM,EAAsB,EAAK,CAG1C,SAAS,EACP,EACA,EACyB,CACzB,IAAM,EAAwC,CAAE,GAAG,EAAM,CAEzD,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAI,CACxC,EAAU,EAAO,EAAK,EAAK,EAE7B,OAAO,EAAI,GAIf,OAAO"}

package/dist/omit-by.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){let n={...e};for(let[r,i]of Object.entries(n))t(i,r,e)&&delete n[r];return n}export{t as omitBy};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t){let n={...e};for(let[r,i]of Object.entries(n))t(i,r,e)&&delete n[r];return n}export{t as omitBy};
 //# sourceMappingURL=omit-by.js.map

package/dist/omit-by.js.map

@@ -1 +1 @@
-{"version":3,"file":"omit-by.js","names":["out: Partial<Record<string, unknown>>"],"sources":["../src/omit-by.ts"],"sourcesContent":["import type { IsNever, Or, Simplify } from 'type-fest';\nimport type { EnumerableStringKeyOf } from './internal/types/enumerable-string-key-of';\nimport type { EnumerableStringKeyedValueOf } from './internal/types/enumerable-string-keyed-value-of';\nimport type { IsBoundedRecord } from './internal/types/is-bounded-record';\nimport { curry } from './curry';\n\n// Symbols are not passed to the predicate (because they can't be enumerated\n// with the `Object.entries` function) and the output object is built from a\n// shallow copy of the input; meaning symbols would just be passed through as-\n// is.\ntype PickSymbolKeys<T extends object> = {\n  -readonly [P in keyof T as P extends symbol ? P : never]: T[P];\n};\n\n// When we don't use a type-predicate we can't say anything about what props\n// would be omitted from the output, so we need to assume any of them could be\n// filtered out. This means that we effectively make all (enumerable) keys\n// optional.\ntype PartialEnumerableKeys<T extends object>\n  // `extends unknown` is always going to be the case and is used to convert any\n  // union into a [distributive conditional type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).\n  = T extends unknown\n    ? Simplify<\n        IsBoundedRecord<T> extends true ? PickSymbolKeys<T> & {\n          -readonly [P in keyof T as P extends symbol\n            ? never\n            : P]?: Required<T>[P];\n        }\n          // This is the type you'd get from doing:\n          // `Object.fromEntries(Object.entries(x))`.\n          : Record<EnumerableStringKeyOf<T>, EnumerableStringKeyedValueOf<T>>\n      >\n    : never;\n\n// When the predicate is a type-guard we have more information to work with when\n// constructing the type of the output object. We can safely remove any property\n// which value would always be true for the predicate, AND we can also\n// assume that properties that are rejected by the predicate perfectly would\n// **always** show up in the output object. Hence to build the output object we\n// need to build and merge 2 output objects: One for the properties which have a\n// value of at type that would always yield a `false` result from the predicate,\n// these are the \"matches\", which would not change the \"optionality\" of the\n// input object's props, and one for partial matches which would also make the\n// props optional (as they could have a value that would be filtered out).\ntype PartialEnumerableKeysNarrowed<T extends object, S> = Simplify<\n  ExactProps<T, S> & PartialProps<T, S> & PickSymbolKeys<T>\n>;\n\n// The exact case, props here would always be part of the output object\ntype ExactProps<T, S> = {\n  -readonly [P in keyof T as IsExactProp<T, P, S> extends true\n    ? P\n    : never]: Exclude<T[P], S>;\n};\n\n// The partial case, props here might be part of the output object, but might\n// not be, hence they are optional.\ntype PartialProps<T, S> = {\n  -readonly [P in keyof T as IsPartialProp<T, P, S> extends true\n    ? P\n    : never]?: Exclude<T[P], S>;\n};\n\n// If the input object's value type extends itself when the type-guard is\n// excluded from it we can safely assume that the predicate would always return\n// `false` for any value of that property.\ntype IsExactProp<T, P extends keyof T, S> = P extends symbol\n  // Symbols are passed through via the PickSymbolKeys type\n  ? false\n  : T[P] extends Exclude<T[P], S>\n    ? S extends T[P]\n      // If S extends the T[P] it means the type the predicate is narrowing to\n      // can't narrow the rejected value any further, so we can't say what\n      // would happen for a concrete value in runtime (e.g. if T[P] is\n      // `number` and S is `1`: `Exclude<number, 1> === number`.\n      ? false\n      : true\n    : false;\n\n// ...and if the input object's value type isn't an exact match, but still has\n// some partial match (i.g. the extracted type-guard isn't completely disjoint)\n// then we can assume that the property can sometimes return true, and sometimes\n// false when passed to the predicate, hence it should be optional in the\n// output.\ntype IsPartialProp<T, P extends keyof T, S> = P extends symbol\n  // Symbols are passed through via the PickSymbolKeys type\n  ? false\n  : Or<IsExactProp<T, P, S>, IsNever<Exclude<Required<T>[P], S>>> extends true\n    ? false\n    : true;\n\n/**\n * Creates a shallow copy of the data, and then removes any keys that the\n * predicate rejects. Symbol keys are not passed to the predicate and would be\n * passed through to the output as-is.\n *\n * See `pickBy` for a complementary function which starts with an empty object\n * and adds the entries that the predicate accepts. Because it is additive,\n * symbol keys will not be passed through to the output object.\n *\n * @param data - The target object.\n * @param predicate - A function that takes the value, key, and the data itself\n * and returns `true` if the entry shouldn't be part of the output object, or\n * `false` to keep it. If the function is a type-guard on the value the output\n * type would be narrowed accordingly.\n * @returns A shallow copy of the input object with the rejected entries\n * removed.\n * @signature P.omitBy(data, predicate)\n * @example\n *    P.omitBy({a: 1, b: 2, A: 3, B: 4}, (val, key) => key.toUpperCase() === key) // => {a: 1, b: 2}\n * @dataFirst\n * @category Object\n */\nexport function omitBy<\n  T extends object,\n  S extends EnumerableStringKeyedValueOf<T>,\n>(\n  data: T,\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => value is S,\n): PartialEnumerableKeysNarrowed<T, S>;\nexport function omitBy<T extends object>(\n  data: T,\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => boolean,\n): PartialEnumerableKeys<T>;\n\n/**\n * Returns a partial copy of an object omitting the keys matching predicate.\n *\n * @param predicate - The predicate.\n * @signature P.omitBy(fn)(object)\n * @example\n *    P.omitBy((val, key) => key.toUpperCase() === key)({a: 1, b: 2, A: 3, B: 4}) // => {a: 1, b: 2}\n * @dataLast\n * @category Object\n */\nexport function omitBy<\n  T extends object,\n  S extends EnumerableStringKeyedValueOf<T>,\n>(\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => value is S,\n): (data: T) => PartialEnumerableKeysNarrowed<T, S>;\nexport function omitBy<T extends object>(\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => boolean,\n): (data: T) => PartialEnumerableKeys<T>;\n\nexport function omitBy(...args: ReadonlyArray<unknown>): unknown {\n  return curry(omitByImplementation, args);\n}\n\nfunction omitByImplementation<T extends object>(\n  data: T,\n  predicate: (value: unknown, key: string, data: T) => boolean,\n): Record<string, unknown> {\n  const out: Partial<Record<string, unknown>> = { ...data };\n\n  for (const [key, value] of Object.entries(out)) {\n    if (predicate(value, key, data)) {\n      // eslint-disable-next-line ts/no-dynamic-delete -- This is the best way to do it!\n      delete out[key];\n    }\n  }\n\n  return out;\n}\n"],"mappings":"wCAiKA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EACP,EACA,EACyB,CACzB,IAAMA,EAAwC,CAAE,GAAG,EAAM,CAEzD,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAI,CACxC,EAAU,EAAO,EAAK,EAAK,EAE7B,OAAO,EAAI,GAIf,OAAO"}
+{"version":3,"file":"omit-by.js","names":[],"sources":["../src/omit-by.ts"],"sourcesContent":["import type { IsNever, Or, Simplify } from 'type-fest';\nimport type { EnumerableStringKeyOf } from './internal/types/enumerable-string-key-of';\nimport type { EnumerableStringKeyedValueOf } from './internal/types/enumerable-string-keyed-value-of';\nimport type { IsBoundedRecord } from './internal/types/is-bounded-record';\nimport { curry } from './curry';\n\n// Symbols are not passed to the predicate (because they can't be enumerated\n// with the `Object.entries` function) and the output object is built from a\n// shallow copy of the input; meaning symbols would just be passed through as-\n// is.\ntype PickSymbolKeys<T extends object> = {\n  -readonly [P in keyof T as P extends symbol ? P : never]: T[P];\n};\n\n// When we don't use a type-predicate we can't say anything about what props\n// would be omitted from the output, so we need to assume any of them could be\n// filtered out. This means that we effectively make all (enumerable) keys\n// optional.\ntype PartialEnumerableKeys<T extends object>\n  // `extends unknown` is always going to be the case and is used to convert any\n  // union into a [distributive conditional type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).\n  = T extends unknown\n    ? Simplify<\n      IsBoundedRecord<T> extends true ? PickSymbolKeys<T> & {\n        -readonly [P in keyof T as P extends symbol\n          ? never\n          : P]?: Required<T>[P];\n      }\n        : // This is the type you'd get from doing:\n      // `Object.fromEntries(Object.entries(x))`.\n        Record<EnumerableStringKeyOf<T>, EnumerableStringKeyedValueOf<T>>\n    >\n    : never;\n\n// When the predicate is a type-guard we have more information to work with when\n// constructing the type of the output object. We can safely remove any property\n// which value would always be true for the predicate, AND we can also\n// assume that properties that are rejected by the predicate perfectly would\n// **always** show up in the output object. Hence to build the output object we\n// need to build and merge 2 output objects: One for the properties which have a\n// value of at type that would always yield a `false` result from the predicate,\n// these are the \"matches\", which would not change the \"optionality\" of the\n// input object's props, and one for partial matches which would also make the\n// props optional (as they could have a value that would be filtered out).\ntype PartialEnumerableKeysNarrowed<T extends object, S> = Simplify<\n  ExactProps<T, S> & PartialProps<T, S> & PickSymbolKeys<T>\n>;\n\n// The exact case, props here would always be part of the output object\ntype ExactProps<T, S> = {\n  -readonly [P in keyof T as IsExactProp<T, P, S> extends true\n    ? P\n    : never]: Exclude<T[P], S>;\n};\n\n// The partial case, props here might be part of the output object, but might\n// not be, hence they are optional.\ntype PartialProps<T, S> = {\n  -readonly [P in keyof T as IsPartialProp<T, P, S> extends true\n    ? P\n    : never]?: Exclude<T[P], S>;\n};\n\n// If the input object's value type extends itself when the type-guard is\n// excluded from it we can safely assume that the predicate would always return\n// `false` for any value of that property.\ntype IsExactProp<T, P extends keyof T, S> = P extends symbol\n  ? // Symbols are passed through via the PickSymbolKeys type\n  false\n  : T[P] extends Exclude<T[P], S>\n    ? S extends T[P]\n      ? // If S extends the T[P] it means the type the predicate is narrowing to\n    // can't narrow the rejected value any further, so we can't say what\n    // would happen for a concrete value in runtime (e.g. if T[P] is\n    // `number` and S is `1`: `Exclude<number, 1> === number`.\n      false\n      : true\n    : false;\n\n// ...and if the input object's value type isn't an exact match, but still has\n// some partial match (i.g. the extracted type-guard isn't completely disjoint)\n// then we can assume that the property can sometimes return true, and sometimes\n// false when passed to the predicate, hence it should be optional in the\n// output.\ntype IsPartialProp<T, P extends keyof T, S> = P extends symbol\n  ? // Symbols are passed through via the PickSymbolKeys type\n  false\n  : Or<IsExactProp<T, P, S>, IsNever<Exclude<Required<T>[P], S>>> extends true\n    ? false\n    : true;\n\n/**\n * Creates a shallow copy of the data, and then removes any keys that the\n * predicate rejects. Symbol keys are not passed to the predicate and would be\n * passed through to the output as-is.\n *\n * See `pickBy` for a complementary function which starts with an empty object\n * and adds the entries that the predicate accepts. Because it is additive,\n * symbol keys will not be passed through to the output object.\n *\n * @param data - The target object.\n * @param predicate - A function that takes the value, key, and the data itself\n * and returns `true` if the entry shouldn't be part of the output object, or\n * `false` to keep it. If the function is a type-guard on the value the output\n * type would be narrowed accordingly.\n * @returns A shallow copy of the input object with the rejected entries\n * removed.\n * @signature omitBy(data, predicate)\n * @example\n *    omitBy({a: 1, b: 2, A: 3, B: 4}, (val, key) => key.toUpperCase() === key) // => {a: 1, b: 2}\n * @dataFirst\n * @category Object\n */\nexport function omitBy<\n  T extends object,\n  S extends EnumerableStringKeyedValueOf<T>,\n>(\n  data: T,\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => value is S,\n): PartialEnumerableKeysNarrowed<T, S>;\nexport function omitBy<T extends object>(\n  data: T,\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => boolean,\n): PartialEnumerableKeys<T>;\n\n/**\n * Returns a partial copy of an object omitting the keys matching predicate.\n *\n * @param predicate - The predicate.\n * @signature omitBy(fn)(object)\n * @example\n *    omitBy((val, key) => key.toUpperCase() === key)({a: 1, b: 2, A: 3, B: 4}) // => {a: 1, b: 2}\n * @dataLast\n * @category Object\n */\nexport function omitBy<\n  T extends object,\n  S extends EnumerableStringKeyedValueOf<T>,\n>(\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => value is S,\n): (data: T) => PartialEnumerableKeysNarrowed<T, S>;\nexport function omitBy<T extends object>(\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => boolean,\n): (data: T) => PartialEnumerableKeys<T>;\n\nexport function omitBy(...args: ReadonlyArray<unknown>): unknown {\n  return curry(omitByImplementation, args);\n}\n\nfunction omitByImplementation<T extends object>(\n  data: T,\n  predicate: (value: unknown, key: string, data: T) => boolean,\n): Record<string, unknown> {\n  const out: Partial<Record<string, unknown>> = { ...data };\n\n  for (const [key, value] of Object.entries(out)) {\n    if (predicate(value, key, data)) {\n      // eslint-disable-next-line ts/no-dynamic-delete -- This is the best way to do it!\n      delete out[key];\n    }\n  }\n\n  return out;\n}\n"],"mappings":"mCAiKA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EACP,EACA,EACyB,CACzB,IAAM,EAAwC,CAAE,GAAG,EAAM,CAEzD,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAI,CACxC,EAAU,EAAO,EAAK,EAAK,EAE7B,OAAO,EAAI,GAIf,OAAO"}

package/dist/omit.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`),t=require(`./has-at-least-BXwOPLQK.cjs`);function n(...t){return e.t(r,t)}function r(e,n){if(!t.t(n,1))return{...e};if(!t.t(n,2)){let{[n[0]]:t,...r}=e;return r}let r={...e};for(let e of n)delete r[e];return r}exports.omit=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`),t=require(`./has-at-least.cjs`);function n(...t){return e.curry(r,t)}function r(e,n){if(!t.hasAtLeast(n,1))return{...e};if(!t.hasAtLeast(n,2)){let{[n[0]]:t,...r}=e;return r}let r={...e};for(let e of n)delete r[e];return r}exports.omit=n;
+//# sourceMappingURL=omit.cjs.map

package/dist/omit.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"omit.cjs","names":["curry","hasAtLeast"],"sources":["../src/omit.ts"],"sourcesContent":["import type { EmptyObject, IsNever, KeysOfUnion } from 'type-fest';\nimport type { IsBounded } from './internal/types/is-bounded';\nimport type { IsBoundedRecord } from './internal/types/is-bounded-record';\nimport type { PartitionByUnion } from './internal/types/partition-by-union';\nimport type { SimplifiedWritable } from './internal/types/simplified-writable';\nimport type { TupleParts } from './internal/types/tuple-parts';\nimport { curry } from './curry';\nimport { hasAtLeast } from './has-at-least';\n\ntype OmitFromArray<T, Keys extends ReadonlyArray<PropertyKey>>\n  // Distribute unions for both object types and key arrays.\n  = T extends unknown\n    ? Keys extends unknown\n      ? // The output is always writable because we always create a new object!\n      SimplifiedWritable<\n        IsNever<Extract<Keys[number], keyof T>> extends true\n          ? // When none of the keys belong to T we can short-circuit and\n        // simply return T as-is because `omit` would do nothing.\n          T\n          : IsBoundedRecord<T> extends true\n            ? OmitBounded<T, Keys>\n            : OmitUnbounded<T, Keys>\n      >\n      : never\n    : never;\n\ntype OmitBounded<T, Keys extends ReadonlyArray<PropertyKey>>\n  // We build our output by first considering any key present in the keys array\n  // as being omitted. This object would contain all keys that are unaffected at\n  // all by this omit operation.\n  = FixEmpty<Omit<T, Keys[number]>>\n    // But we might be missing keys that are optional in the keys tuple (and\n    // thus might not be removed). Because these keys are optional, their props\n    // in the output also need to be optional.\n    & Partial<\n      Pick<\n        T,\n        Exclude<\n          // Find all keys that can either be omitted or not, these are all keys\n          // in unions in the required parts of the keys tuple (the prefix and\n          // the suffix), as well as all keys in the optional parts and the rest\n          // item.\n          | PartitionByUnion<TupleParts<Keys>['required']>['union']\n          | TupleParts<Keys>['optional'][number]\n          | TupleParts<Keys>['item']\n          | PartitionByUnion<TupleParts<Keys>['suffix']>['union'],\n          // We then need to remove from these any items which *also* are\n          // ensured to always exist in the keys tuple, these are the elements\n          // of the required parts of the tuple which are singular (not unions).\n          | PartitionByUnion<TupleParts<Keys>['required']>['singular']\n          | PartitionByUnion<TupleParts<Keys>['suffix']>['singular']\n        >\n      >\n    >;\n\n/**\n * The built-in `Omit` type doesn't handle unbounded records correctly! When\n * omitting an unbounded key the result should be untouched as we can't tell\n * what got removed, and can't represent an object that had \"something\" removed\n * from it, but instead it returns `{}`(?!) The same thing applies when a key\n * is only optionally omitted for the same reasons. This is why we don't use\n * `Omit` at all for the unbounded case.\n *\n * @see https://www.typescriptlang.org/play/?#code/C4TwDgpgBAqgdgIwPYFc4BMLqgXigeQFsBLYAHgCUIBjJAJ3TIGdg7i4BzAGigCIALCABshSXgD4eLNp3EBuAFAB6JVDUA9APxA\n */\ntype OmitUnbounded<T, Keys extends ReadonlyArray<PropertyKey>> = T\n  // Any key we know for sure is being omitted needs to become \"impossible\" to\n  // access; for an unbounded record this means merging it with a bounded record\n  // with `never` value for these keys.\n  & Record<\n    Bounded<\n      | PartitionByUnion<TupleParts<Keys>['required']>['singular']\n      | PartitionByUnion<TupleParts<Keys>['suffix']>['singular']\n    >,\n    never\n  >;\n\n/**\n * When `Omit` omits **all** keys from a bounded record it results in `{}` which\n * doesn't match what we'd expect to be returned in terms of a useful type as\n * the output of `Omit`.\n */\ntype FixEmpty<T> = IsNever<keyof T> extends true ? EmptyObject : T;\n\n/**\n * Filter a union of types, leaving only those that are bounded. e.g.,\n * `Bounded<\"a\" | number>` results in `\"a\"`.\n */\ntype Bounded<T> = T extends unknown\n  ? IsBounded<T> extends true\n    ? T\n    : never\n  : never;\n\n/**\n * Returns a partial copy of an object omitting the keys specified.\n *\n * @param keys - The property names.\n * @signature\n *    omit(keys)(obj);\n * @example\n *    pipe({ a: 1, b: 2, c: 3, d: 4 }, omit(['a', 'd'])) // => { b: 2, c: 3 }\n * @dataLast\n * @category Object\n */\nexport function omit<T, const Keys extends ReadonlyArray<KeysOfUnion<T>>>(\n  keys: Keys,\n): (data: T) => OmitFromArray<T, Keys>;\n\n/**\n * Returns a partial copy of an object omitting the keys specified.\n *\n * @param data - The object.\n * @param keys - The property names.\n * @signature\n *    omit(obj, keys);\n * @example\n *    omit({ a: 1, b: 2, c: 3, d: 4 }, ['a', 'd']) // => { b: 2, c: 3 }\n * @dataFirst\n * @category Object\n */\nexport function omit<T, const Keys extends ReadonlyArray<KeysOfUnion<T>>>(\n  data: T,\n  keys: Keys,\n): OmitFromArray<T, Keys>;\n\nexport function omit(...args: ReadonlyArray<unknown>): unknown {\n  return curry(omitImplementation, args);\n}\n\nfunction omitImplementation<\n  T extends object,\n  Keys extends ReadonlyArray<keyof T>,\n>(data: T, keys: Keys): OmitFromArray<T, Keys> {\n  if (!hasAtLeast(keys, 1)) {\n    // No props to omit at all!\n    // @ts-expect-error [ts2322] - TypeScript can't connect the fact that the\n    // keys array is empty and infer the expected output, and then infer that we\n    // return it correctly here.\n    return { ...data };\n  }\n\n  if (!hasAtLeast(keys, 2)) {\n    // Only one prop to omit so we can let the runtime engine deal with\n    // removing it efficiently.\n    const { [keys[0]]: _omitted, ...remaining } = data;\n\n    // @ts-expect-error [ts2322] - TypeScript can't compute the expected output\n    // correctly and then infer that we return it correctly here.\n    return remaining;\n  }\n\n  // Multiple props to omit so we have to use a loop to omit all of them.\n  const out = { ...data };\n  for (const key of keys) {\n    // eslint-disable-next-line ts/no-dynamic-delete -- This is intentional! It is the most effective way to allow the runtime engine to optimize the object without creating excessive copies for every omitted key.\n    delete out[key];\n  }\n\n  // @ts-expect-error [ts2322] - The type is too complex and TypeScript can't\n  // \"follow\" the iterative algorithm to ensure the output makes sense.\n  return out;\n}\n"],"mappings":"kIA8HA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAOA,EAAAA,MAAM,EAAoB,EAAK,CAGxC,SAAS,EAGP,EAAS,EAAoC,CAC7C,GAAI,CAACC,EAAAA,WAAW,EAAM,EAAE,CAKtB,MAAO,CAAE,GAAG,EAAM,CAGpB,GAAI,CAACA,EAAAA,WAAW,EAAM,EAAE,CAAE,CAGxB,GAAM,EAAG,EAAK,IAAK,EAAU,GAAG,GAAc,EAI9C,OAAO,EAIT,IAAM,EAAM,CAAE,GAAG,EAAM,CACvB,IAAK,IAAM,KAAO,EAEhB,OAAO,EAAI,GAKb,OAAO"}

package/dist/omit.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";import{t}from"./has-at-least-Coy9sM-B.js";function n(...t){return e(r,t)}function r(e,n){if(!t(n,1))return{...e};if(!t(n,2)){let{[n[0]]:t,...r}=e;return r}let r={...e};for(let e of n)delete r[e];return r}export{n as omit};
+import{curry as e}from"./curry.js";import{hasAtLeast as t}from"./has-at-least.js";function n(...t){return e(r,t)}function r(e,n){if(!t(n,1))return{...e};if(!t(n,2)){let{[n[0]]:t,...r}=e;return r}let r={...e};for(let e of n)delete r[e];return r}export{n as omit};
 //# sourceMappingURL=omit.js.map