@vinicunca/perkakas 1.14.0 → 1.16.0

package/dist/keys.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"keys.cjs","names":["curry"],"sources":["../src/keys.ts"],"sourcesContent":["import type { EnumerableStringKeyOf } from './internal/types/enumerable-string-key-of';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { ToString } from './internal/types/to-string';\nimport { curry } from './curry';\n\ntype Keys<T> = T extends IterableContainer ? ArrayKeys<T> : ObjectKeys<T>;\n\n// The keys output can mirror the input when it is an array/tuple. We do this by\n// \"mapping\" each item \"key\" (which is actually an index) as its own value. This\n// would maintain the shape, even including labels.\ntype ArrayKeys<T extends IterableContainer> = {\n  -readonly [Index in keyof T]: Index extends number | string\n    ? // Notice that we coalesce the values as strings, this is because in JS,\n  // Object.keys always returns strings, even for arrays.\n    ToString<IsIndexAfterSpread<T, Index> extends true ? number : Index>\n    : // Index is typed as a symbol, this can't happen, but we need to guard\n  // against it for typescript.\n    never;\n};\n\ntype IsIndexAfterSpread<\n  T extends IterableContainer,\n  Index extends number | string,\n>\n  = IndicesAfterSpread<T> extends never\n    ? false\n    : Index extends `${IndicesAfterSpread<T>}`\n      ? true\n      : false;\n\n// Find the index of the tuple where a spread item is located, and return all\n// indices in the tuple which are located after it. The tuple could be prefixed\n// by any number of literal items. If the input is a simple array it would\n// return 0 (as expected), and if the tuple doesn't contain a spread element it\n// would return never.\ntype IndicesAfterSpread<\n  T extends ReadonlyArray<unknown> | [],\n  // We use this type to count how many items we consumed, it's just a pseudo-\n  // element that is used for its length.\n  Iterations extends ReadonlyArray<unknown> = [],\n> = T[number] extends never\n  ? never\n  : T extends readonly [unknown, ...infer Tail]\n    ? IndicesAfterSpread<Tail, [unknown, ...Iterations]>\n    : T extends readonly [...infer Head, unknown]\n      ?\n      | IndicesAfterSpread<Head, [unknown, ...Iterations]>\n      | Iterations['length']\n      : Iterations['length'];\n\ntype ObjectKeys<T>\n  = T extends Record<PropertyKey, never> ? [] : Array<EnumerableStringKeyOf<T>>;\n\n/**\n * Returns a new array containing the keys of the array or object.\n *\n * @param data - Either an array or an object.\n * @signature\n *    keys(source)\n * @example\n *    keys(['x', 'y', 'z']); // => ['0', '1', '2']\n *    keys({ a: 'x', b: 'y', 5: 'z' }); // => ['a', 'b', '5']\n * @dataFirst\n * @category Object\n */\nexport function keys<T extends object>(data: T): Keys<T>;\n\n/**\n * Returns a new array containing the keys of the array or object.\n *\n * @signature\n *    keys()(source)\n * @example\n *    pipe(['x', 'y', 'z'], keys()); // => ['0', '1', '2']\n *    pipe({ a: 'x', b: 'y', 5: 'z' } as const, keys()) // => ['a', 'b', '5']\n * @dataLast\n * @category Object\n */\nexport function keys(): <T extends object>(data: T) => Keys<T>;\n\nexport function keys(...args: ReadonlyArray<unknown>): unknown {\n  return curry(Object.keys, args);\n}\n"],"mappings":"kGAgFA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAOA,EAAAA,MAAM,OAAO,KAAM,EAAK"}
+{"version":3,"file":"keys.cjs","names":["curry"],"sources":["../src/keys.ts"],"sourcesContent":["import type { IsNever } from 'type-fest';\nimport type { EnumerableStringKeyOf } from './internal/types/enumerable-string-key-of';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { ToString } from './internal/types/to-string';\nimport { curry } from './curry';\n\ntype Keys<T> = T extends IterableContainer ? ArrayKeys<T> : ObjectKeys<T>;\n\n// The keys output can mirror the input when it is an array/tuple. We do this by\n// \"mapping\" each item \"key\" (which is actually an index) as its own value. This\n// would maintain the shape, even including labels.\ntype ArrayKeys<T extends IterableContainer> = {\n  -readonly [Index in keyof T]: Index extends number | string\n    ? // Notice that we coalesce the values as strings, this is because in JS,\n  // Object.keys always returns strings, even for arrays.\n    ToString<IsIndexAfterSpread<T, Index> extends true ? number : Index>\n    : // Index is typed as a symbol, this can't happen, but we need to guard\n  // against it for typescript.\n    never;\n};\n\ntype IsIndexAfterSpread<\n  T extends IterableContainer,\n  Index extends number | string,\n>\n  = IsNever<IndicesAfterSpread<T>> extends true\n    ? false\n    : Index extends `${IndicesAfterSpread<T>}`\n      ? true\n      : false;\n\n// Find the index of the tuple where a spread item is located, and return all\n// indices in the tuple which are located after it. The tuple could be prefixed\n// by any number of literal items. If the input is a simple array it would\n// return 0 (as expected), and if the tuple doesn't contain a spread element it\n// would return never.\ntype IndicesAfterSpread<\n  T extends ReadonlyArray<unknown> | [],\n  // We use this type to count how many items we consumed, it's just a pseudo-\n  // element that is used for its length.\n  Iterations extends ReadonlyArray<unknown> = [],\n>\n  = IsNever<T[number]> extends true\n    ? never\n    : T extends readonly [unknown, ...infer Tail]\n      ? IndicesAfterSpread<Tail, [unknown, ...Iterations]>\n      : T extends readonly [...infer Head, unknown]\n        ?\n        | IndicesAfterSpread<Head, [unknown, ...Iterations]>\n        | Iterations['length']\n        : Iterations['length'];\n\ntype ObjectKeys<T>\n  = T extends Record<PropertyKey, never> ? [] : Array<EnumerableStringKeyOf<T>>;\n\n/**\n * Returns a new array containing the keys of the array or object.\n *\n * @param data - Either an array or an object.\n * @signature\n *    keys(source)\n * @example\n *    keys(['x', 'y', 'z']); // => ['0', '1', '2']\n *    keys({ a: 'x', b: 'y', 5: 'z' }); // => ['a', 'b', '5']\n * @dataFirst\n * @category Object\n */\nexport function keys<T extends object>(data: T): Keys<T>;\n\n/**\n * Returns a new array containing the keys of the array or object.\n *\n * @signature\n *    keys()(source)\n * @example\n *    pipe(['x', 'y', 'z'], keys()); // => ['0', '1', '2']\n *    pipe({ a: 'x', b: 'y', 5: 'z' } as const, keys()) // => ['a', 'b', '5']\n * @dataLast\n * @category Object\n */\nexport function keys(): <T extends object>(data: T) => Keys<T>;\n\nexport function keys(...args: ReadonlyArray<unknown>): unknown {\n  return curry(Object.keys, args);\n}\n"],"mappings":"kGAkFA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAOA,EAAAA,MAAM,OAAO,KAAM,CAAI,CAChC"}

package/dist/keys.js.map

@@ -1 +1 @@
-{"version":3,"file":"keys.js","names":[],"sources":["../src/keys.ts"],"sourcesContent":["import type { EnumerableStringKeyOf } from './internal/types/enumerable-string-key-of';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { ToString } from './internal/types/to-string';\nimport { curry } from './curry';\n\ntype Keys<T> = T extends IterableContainer ? ArrayKeys<T> : ObjectKeys<T>;\n\n// The keys output can mirror the input when it is an array/tuple. We do this by\n// \"mapping\" each item \"key\" (which is actually an index) as its own value. This\n// would maintain the shape, even including labels.\ntype ArrayKeys<T extends IterableContainer> = {\n  -readonly [Index in keyof T]: Index extends number | string\n    ? // Notice that we coalesce the values as strings, this is because in JS,\n  // Object.keys always returns strings, even for arrays.\n    ToString<IsIndexAfterSpread<T, Index> extends true ? number : Index>\n    : // Index is typed as a symbol, this can't happen, but we need to guard\n  // against it for typescript.\n    never;\n};\n\ntype IsIndexAfterSpread<\n  T extends IterableContainer,\n  Index extends number | string,\n>\n  = IndicesAfterSpread<T> extends never\n    ? false\n    : Index extends `${IndicesAfterSpread<T>}`\n      ? true\n      : false;\n\n// Find the index of the tuple where a spread item is located, and return all\n// indices in the tuple which are located after it. The tuple could be prefixed\n// by any number of literal items. If the input is a simple array it would\n// return 0 (as expected), and if the tuple doesn't contain a spread element it\n// would return never.\ntype IndicesAfterSpread<\n  T extends ReadonlyArray<unknown> | [],\n  // We use this type to count how many items we consumed, it's just a pseudo-\n  // element that is used for its length.\n  Iterations extends ReadonlyArray<unknown> = [],\n> = T[number] extends never\n  ? never\n  : T extends readonly [unknown, ...infer Tail]\n    ? IndicesAfterSpread<Tail, [unknown, ...Iterations]>\n    : T extends readonly [...infer Head, unknown]\n      ?\n      | IndicesAfterSpread<Head, [unknown, ...Iterations]>\n      | Iterations['length']\n      : Iterations['length'];\n\ntype ObjectKeys<T>\n  = T extends Record<PropertyKey, never> ? [] : Array<EnumerableStringKeyOf<T>>;\n\n/**\n * Returns a new array containing the keys of the array or object.\n *\n * @param data - Either an array or an object.\n * @signature\n *    keys(source)\n * @example\n *    keys(['x', 'y', 'z']); // => ['0', '1', '2']\n *    keys({ a: 'x', b: 'y', 5: 'z' }); // => ['a', 'b', '5']\n * @dataFirst\n * @category Object\n */\nexport function keys<T extends object>(data: T): Keys<T>;\n\n/**\n * Returns a new array containing the keys of the array or object.\n *\n * @signature\n *    keys()(source)\n * @example\n *    pipe(['x', 'y', 'z'], keys()); // => ['0', '1', '2']\n *    pipe({ a: 'x', b: 'y', 5: 'z' } as const, keys()) // => ['a', 'b', '5']\n * @dataLast\n * @category Object\n */\nexport function keys(): <T extends object>(data: T) => Keys<T>;\n\nexport function keys(...args: ReadonlyArray<unknown>): unknown {\n  return curry(Object.keys, args);\n}\n"],"mappings":"mCAgFA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,OAAO,KAAM,EAAK"}
+{"version":3,"file":"keys.js","names":[],"sources":["../src/keys.ts"],"sourcesContent":["import type { IsNever } from 'type-fest';\nimport type { EnumerableStringKeyOf } from './internal/types/enumerable-string-key-of';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { ToString } from './internal/types/to-string';\nimport { curry } from './curry';\n\ntype Keys<T> = T extends IterableContainer ? ArrayKeys<T> : ObjectKeys<T>;\n\n// The keys output can mirror the input when it is an array/tuple. We do this by\n// \"mapping\" each item \"key\" (which is actually an index) as its own value. This\n// would maintain the shape, even including labels.\ntype ArrayKeys<T extends IterableContainer> = {\n  -readonly [Index in keyof T]: Index extends number | string\n    ? // Notice that we coalesce the values as strings, this is because in JS,\n  // Object.keys always returns strings, even for arrays.\n    ToString<IsIndexAfterSpread<T, Index> extends true ? number : Index>\n    : // Index is typed as a symbol, this can't happen, but we need to guard\n  // against it for typescript.\n    never;\n};\n\ntype IsIndexAfterSpread<\n  T extends IterableContainer,\n  Index extends number | string,\n>\n  = IsNever<IndicesAfterSpread<T>> extends true\n    ? false\n    : Index extends `${IndicesAfterSpread<T>}`\n      ? true\n      : false;\n\n// Find the index of the tuple where a spread item is located, and return all\n// indices in the tuple which are located after it. The tuple could be prefixed\n// by any number of literal items. If the input is a simple array it would\n// return 0 (as expected), and if the tuple doesn't contain a spread element it\n// would return never.\ntype IndicesAfterSpread<\n  T extends ReadonlyArray<unknown> | [],\n  // We use this type to count how many items we consumed, it's just a pseudo-\n  // element that is used for its length.\n  Iterations extends ReadonlyArray<unknown> = [],\n>\n  = IsNever<T[number]> extends true\n    ? never\n    : T extends readonly [unknown, ...infer Tail]\n      ? IndicesAfterSpread<Tail, [unknown, ...Iterations]>\n      : T extends readonly [...infer Head, unknown]\n        ?\n        | IndicesAfterSpread<Head, [unknown, ...Iterations]>\n        | Iterations['length']\n        : Iterations['length'];\n\ntype ObjectKeys<T>\n  = T extends Record<PropertyKey, never> ? [] : Array<EnumerableStringKeyOf<T>>;\n\n/**\n * Returns a new array containing the keys of the array or object.\n *\n * @param data - Either an array or an object.\n * @signature\n *    keys(source)\n * @example\n *    keys(['x', 'y', 'z']); // => ['0', '1', '2']\n *    keys({ a: 'x', b: 'y', 5: 'z' }); // => ['a', 'b', '5']\n * @dataFirst\n * @category Object\n */\nexport function keys<T extends object>(data: T): Keys<T>;\n\n/**\n * Returns a new array containing the keys of the array or object.\n *\n * @signature\n *    keys()(source)\n * @example\n *    pipe(['x', 'y', 'z'], keys()); // => ['0', '1', '2']\n *    pipe({ a: 'x', b: 'y', 5: 'z' } as const, keys()) // => ['a', 'b', '5']\n * @dataLast\n * @category Object\n */\nexport function keys(): <T extends object>(data: T) => Keys<T>;\n\nexport function keys(...args: ReadonlyArray<unknown>): unknown {\n  return curry(Object.keys, args);\n}\n"],"mappings":"mCAkFA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,OAAO,KAAM,CAAI,CAChC"}

package/dist/last.cjs

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

package/dist/last.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"last.cjs","names":["curry"],"sources":["../src/last.ts"],"sourcesContent":["import type { LastArrayElement } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\ntype Last<T extends IterableContainer> = LastArrayElement<\n  T,\n  // Type-fest's LastArrayElement assumes a looser typescript configuration\n  // where `noUncheckedIndexedAccess` is disabled. To support the stricter\n  // configuration we assume we need to assign the \"LastArrayElement\" param to\n  // `undefined`, but only if the array isn't empty.\n  T extends readonly [] ? never : undefined\n>;\n\n/**\n * Gets the last element of `array`.\n *\n * @param data - The array.\n * @signature\n *    last(array)\n * @example\n *    last([1, 2, 3]) // => 3\n *    last([]) // => undefined\n * @dataFirst\n * @category Array\n */\nexport function last<T extends IterableContainer>(data: T): Last<T>;\n\n/**\n * Gets the last element of `array`.\n *\n * @signature\n *    last()(array)\n * @example\n *    pipe(\n *      [1, 2, 4, 8, 16],\n *      filter(x => x > 3),\n *      last(),\n *      x => x + 1\n *    ); // => 17\n * @dataLast\n * @category Array\n */\nexport function last(): <T extends IterableContainer>(data: T) => Last<T>;\n\nexport function last(...args: ReadonlyArray<unknown>): unknown {\n  return curry(lastImplementation, args);\n}\n\nfunction lastImplementation<T>(array: ReadonlyArray<T>): T | undefined {\n  return array.at(-1);\n}\n"],"mappings":"kGA4CA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAOA,EAAAA,MAAM,EAAoB,EAAK,CAGxC,SAAS,EAAsB,EAAwC,CACrE,OAAO,EAAM,GAAG,GAAG"}
+{"version":3,"file":"last.cjs","names":["curry"],"sources":["../src/last.ts"],"sourcesContent":["import type { LastArrayElement } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\ntype Last<T extends IterableContainer> = LastArrayElement<\n  T,\n  // Type-fest's LastArrayElement assumes a looser typescript configuration\n  // where `noUncheckedIndexedAccess` is disabled. To support the stricter\n  // configuration we assume we need to assign the \"LastArrayElement\" param to\n  // `undefined`, but only if the array isn't empty.\n  T extends readonly [] ? never : undefined\n>;\n\n/**\n * Gets the last element of `array`.\n *\n * @param data - The array.\n * @signature\n *    last(array)\n * @example\n *    last([1, 2, 3]) // => 3\n *    last([]) // => undefined\n * @dataFirst\n * @category Array\n */\nexport function last<T extends IterableContainer>(data: T): Last<T>;\n\n/**\n * Gets the last element of `array`.\n *\n * @signature\n *    last()(array)\n * @example\n *    pipe(\n *      [1, 2, 4, 8, 16],\n *      filter(x => x > 3),\n *      last(),\n *      x => x + 1\n *    ); // => 17\n * @dataLast\n * @category Array\n */\nexport function last(): <T extends IterableContainer>(data: T) => Last<T>;\n\nexport function last(...args: ReadonlyArray<unknown>): unknown {\n  return curry(lastImplementation, args);\n}\n\nfunction lastImplementation<T>(array: ReadonlyArray<T>): T | undefined {\n  return array.at(-1);\n}\n"],"mappings":"kGA4CA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAOA,EAAAA,MAAM,EAAoB,CAAI,CACvC,CAEA,SAAS,EAAsB,EAAwC,CACrE,OAAO,EAAM,GAAG,EAAE,CACpB"}

package/dist/last.js.map

@@ -1 +1 @@
-{"version":3,"file":"last.js","names":[],"sources":["../src/last.ts"],"sourcesContent":["import type { LastArrayElement } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\ntype Last<T extends IterableContainer> = LastArrayElement<\n  T,\n  // Type-fest's LastArrayElement assumes a looser typescript configuration\n  // where `noUncheckedIndexedAccess` is disabled. To support the stricter\n  // configuration we assume we need to assign the \"LastArrayElement\" param to\n  // `undefined`, but only if the array isn't empty.\n  T extends readonly [] ? never : undefined\n>;\n\n/**\n * Gets the last element of `array`.\n *\n * @param data - The array.\n * @signature\n *    last(array)\n * @example\n *    last([1, 2, 3]) // => 3\n *    last([]) // => undefined\n * @dataFirst\n * @category Array\n */\nexport function last<T extends IterableContainer>(data: T): Last<T>;\n\n/**\n * Gets the last element of `array`.\n *\n * @signature\n *    last()(array)\n * @example\n *    pipe(\n *      [1, 2, 4, 8, 16],\n *      filter(x => x > 3),\n *      last(),\n *      x => x + 1\n *    ); // => 17\n * @dataLast\n * @category Array\n */\nexport function last(): <T extends IterableContainer>(data: T) => Last<T>;\n\nexport function last(...args: ReadonlyArray<unknown>): unknown {\n  return curry(lastImplementation, args);\n}\n\nfunction lastImplementation<T>(array: ReadonlyArray<T>): T | undefined {\n  return array.at(-1);\n}\n"],"mappings":"mCA4CA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAoB,EAAK,CAGxC,SAAS,EAAsB,EAAwC,CACrE,OAAO,EAAM,GAAG,GAAG"}
+{"version":3,"file":"last.js","names":[],"sources":["../src/last.ts"],"sourcesContent":["import type { LastArrayElement } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\ntype Last<T extends IterableContainer> = LastArrayElement<\n  T,\n  // Type-fest's LastArrayElement assumes a looser typescript configuration\n  // where `noUncheckedIndexedAccess` is disabled. To support the stricter\n  // configuration we assume we need to assign the \"LastArrayElement\" param to\n  // `undefined`, but only if the array isn't empty.\n  T extends readonly [] ? never : undefined\n>;\n\n/**\n * Gets the last element of `array`.\n *\n * @param data - The array.\n * @signature\n *    last(array)\n * @example\n *    last([1, 2, 3]) // => 3\n *    last([]) // => undefined\n * @dataFirst\n * @category Array\n */\nexport function last<T extends IterableContainer>(data: T): Last<T>;\n\n/**\n * Gets the last element of `array`.\n *\n * @signature\n *    last()(array)\n * @example\n *    pipe(\n *      [1, 2, 4, 8, 16],\n *      filter(x => x > 3),\n *      last(),\n *      x => x + 1\n *    ); // => 17\n * @dataLast\n * @category Array\n */\nexport function last(): <T extends IterableContainer>(data: T) => Last<T>;\n\nexport function last(...args: ReadonlyArray<unknown>): unknown {\n  return curry(lastImplementation, args);\n}\n\nfunction lastImplementation<T>(array: ReadonlyArray<T>): T | undefined {\n  return array.at(-1);\n}\n"],"mappings":"mCA4CA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAoB,CAAI,CACvC,CAEA,SAAS,EAAsB,EAAwC,CACrE,OAAO,EAAM,GAAG,EAAE,CACpB"}

package/dist/{lazy-data-last-impl-Vt_M0l7X.js → lazy-data-last-impl--3B10z3s.js}

@@ -1,2 +1,2 @@
 function e(e,t,n){let r=n=>e(n,...t);return n===void 0?r:Object.assign(r,{lazy:n,lazyArgs:t})}export{e as t};
-//# sourceMappingURL=lazy-data-last-impl-Vt_M0l7X.js.map
+//# sourceMappingURL=lazy-data-last-impl--3B10z3s.js.map

package/dist/{lazy-data-last-impl-Vt_M0l7X.js.map → lazy-data-last-impl--3B10z3s.js.map}

@@ -1 +1 @@
-{"version":3,"file":"lazy-data-last-impl-Vt_M0l7X.js","names":[],"sources":["../src/internal/lazy-data-last-impl.ts"],"sourcesContent":["/* eslint-disable ts/no-explicit-any */\n\nimport type { LazyEvaluator } from './types/lazy-evaluator';\nimport type { StrictFunction } from './types/strict-function';\n\n/**\n * Use this helper function to build the data last implementation together with\n * a lazy implementation. Use this when you need to build your own currying\n * logic when you want to decide between dataFirst and dataLast on something\n * that isn't the number of arguments provided. This is useful for implementing\n * functions with optional or variadic arguments.\n */\nexport function lazyDataLastImpl(\n  fn: StrictFunction,\n  args: ReadonlyArray<unknown>,\n  lazy?: (...args: any) => LazyEvaluator,\n  // TODO: We can probably provide better typing to the return type...\n): unknown {\n  // @ts-expect-error [ts2345] -- This error is accurate because we don't know\n  // anything about `fn` so can't ensure that we are passing the correct\n  // arguments to it, we just have to trust that the caller knows what they are\n  // doing.\n  const dataLast = (data: unknown): unknown => fn(data, ...args);\n\n  return lazy === undefined\n    ? dataLast\n    : Object.assign(dataLast, { lazy, lazyArgs: args });\n}\n"],"mappings":"AAYA,SAAgB,EACd,EACA,EACA,EAES,CAKT,IAAM,EAAY,GAA2B,EAAG,EAAM,GAAG,EAAK,CAE9D,OAAO,IAAS,IAAA,GACZ,EACA,OAAO,OAAO,EAAU,CAAE,OAAM,SAAU,EAAM,CAAC"}
+{"version":3,"file":"lazy-data-last-impl--3B10z3s.js","names":[],"sources":["../src/internal/lazy-data-last-impl.ts"],"sourcesContent":["/* eslint-disable ts/no-explicit-any */\n\nimport type { LazyEvaluator } from './types/lazy-evaluator';\nimport type { StrictFunction } from './types/strict-function';\n\n/**\n * Use this helper function to build the data last implementation together with\n * a lazy implementation. Use this when you need to build your own currying\n * logic when you want to decide between dataFirst and dataLast on something\n * that isn't the number of arguments provided. This is useful for implementing\n * functions with optional or variadic arguments.\n */\nexport function lazyDataLastImpl(\n  fn: StrictFunction,\n  args: ReadonlyArray<unknown>,\n  lazy?: (...args: any) => LazyEvaluator,\n  // TODO: We can probably provide better typing to the return type...\n): unknown {\n  // @ts-expect-error [ts2345] -- This error is accurate because we don't know\n  // anything about `fn` so can't ensure that we are passing the correct\n  // arguments to it, we just have to trust that the caller knows what they are\n  // doing.\n  const dataLast = (data: unknown): unknown => fn(data, ...args);\n\n  return lazy === undefined\n    ? dataLast\n    : Object.assign(dataLast, { lazy, lazyArgs: args });\n}\n"],"mappings":"AAYA,SAAgB,EACd,EACA,EACA,EAES,CAKT,IAAM,EAAY,GAA2B,EAAG,EAAM,GAAG,CAAI,EAE7D,OAAO,IAAS,IAAA,GACZ,EACA,OAAO,OAAO,EAAU,CAAE,OAAM,SAAU,CAAK,CAAC,CACtD"}

package/dist/lazy-data-last-impl-Dd5zjCfU.cjs

@@ -0,0 +1,2 @@
+function e(e,t,n){let r=n=>e(n,...t);return n===void 0?r:Object.assign(r,{lazy:n,lazyArgs:t})}Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return e}});
+//# sourceMappingURL=lazy-data-last-impl-Dd5zjCfU.cjs.map

package/dist/{lazy-data-last-impl-B05ZpguF.cjs.map → lazy-data-last-impl-Dd5zjCfU.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"lazy-data-last-impl-B05ZpguF.cjs","names":[],"sources":["../src/internal/lazy-data-last-impl.ts"],"sourcesContent":["/* eslint-disable ts/no-explicit-any */\n\nimport type { LazyEvaluator } from './types/lazy-evaluator';\nimport type { StrictFunction } from './types/strict-function';\n\n/**\n * Use this helper function to build the data last implementation together with\n * a lazy implementation. Use this when you need to build your own currying\n * logic when you want to decide between dataFirst and dataLast on something\n * that isn't the number of arguments provided. This is useful for implementing\n * functions with optional or variadic arguments.\n */\nexport function lazyDataLastImpl(\n  fn: StrictFunction,\n  args: ReadonlyArray<unknown>,\n  lazy?: (...args: any) => LazyEvaluator,\n  // TODO: We can probably provide better typing to the return type...\n): unknown {\n  // @ts-expect-error [ts2345] -- This error is accurate because we don't know\n  // anything about `fn` so can't ensure that we are passing the correct\n  // arguments to it, we just have to trust that the caller knows what they are\n  // doing.\n  const dataLast = (data: unknown): unknown => fn(data, ...args);\n\n  return lazy === undefined\n    ? dataLast\n    : Object.assign(dataLast, { lazy, lazyArgs: args });\n}\n"],"mappings":"AAYA,SAAgB,EACd,EACA,EACA,EAES,CAKT,IAAM,EAAY,GAA2B,EAAG,EAAM,GAAG,EAAK,CAE9D,OAAO,IAAS,IAAA,GACZ,EACA,OAAO,OAAO,EAAU,CAAE,OAAM,SAAU,EAAM,CAAC"}
+{"version":3,"file":"lazy-data-last-impl-Dd5zjCfU.cjs","names":[],"sources":["../src/internal/lazy-data-last-impl.ts"],"sourcesContent":["/* eslint-disable ts/no-explicit-any */\n\nimport type { LazyEvaluator } from './types/lazy-evaluator';\nimport type { StrictFunction } from './types/strict-function';\n\n/**\n * Use this helper function to build the data last implementation together with\n * a lazy implementation. Use this when you need to build your own currying\n * logic when you want to decide between dataFirst and dataLast on something\n * that isn't the number of arguments provided. This is useful for implementing\n * functions with optional or variadic arguments.\n */\nexport function lazyDataLastImpl(\n  fn: StrictFunction,\n  args: ReadonlyArray<unknown>,\n  lazy?: (...args: any) => LazyEvaluator,\n  // TODO: We can probably provide better typing to the return type...\n): unknown {\n  // @ts-expect-error [ts2345] -- This error is accurate because we don't know\n  // anything about `fn` so can't ensure that we are passing the correct\n  // arguments to it, we just have to trust that the caller knows what they are\n  // doing.\n  const dataLast = (data: unknown): unknown => fn(data, ...args);\n\n  return lazy === undefined\n    ? dataLast\n    : Object.assign(dataLast, { lazy, lazyArgs: args });\n}\n"],"mappings":"AAYA,SAAgB,EACd,EACA,EACA,EAES,CAKT,IAAM,EAAY,GAA2B,EAAG,EAAM,GAAG,CAAI,EAE7D,OAAO,IAAS,IAAA,GACZ,EACA,OAAO,OAAO,EAAU,CAAE,OAAM,SAAU,CAAK,CAAC,CACtD"}

package/dist/length.cjs

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

package/dist/length.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"length.cjs","names":["curry"],"sources":["../src/length.ts"],"sourcesContent":["import { curry } from './curry';\n\ntype Enumerable<T> = ArrayLike<T> | Iterable<T>;\n\n/**\n * Counts values of the collection or iterable.\n *\n * @param items - The input data.\n * @signature\n *    length(array)\n * @example\n *    length([1, 2, 3]) // => 3\n * @dataFirst\n * @category Array\n */\nexport function length<T>(items: Enumerable<T>): number;\n\n/**\n * Counts values of the collection or iterable.\n *\n * @signature\n *    length()(array)\n * @example\n *    pipe([1, 2, 3], length()) // => 3\n * @dataLast\n * @category Array\n */\nexport function length<T>(): (items: Enumerable<T>) => number;\n\nexport function length(...args: ReadonlyArray<unknown>): unknown {\n  return curry(lengthImplementation, args);\n}\n\nfunction lengthImplementation<T>(items: Enumerable<T>): number {\n  return 'length' in items ? items.length : [...items].length;\n}\n"],"mappings":"kGA6BA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAOA,EAAAA,MAAM,EAAsB,EAAK,CAG1C,SAAS,EAAwB,EAA8B,CAC7D,MAAO,WAAY,EAAQ,EAAM,OAAS,CAAC,GAAG,EAAM,CAAC"}
+{"version":3,"file":"length.cjs","names":["curry"],"sources":["../src/length.ts"],"sourcesContent":["import { curry } from './curry';\n\ntype Enumerable<T> = ArrayLike<T> | Iterable<T>;\n\n/**\n * Counts values of the collection or iterable.\n *\n * @param items - The input data.\n * @signature\n *    length(array)\n * @example\n *    length([1, 2, 3]) // => 3\n * @dataFirst\n * @category Array\n */\nexport function length<T>(items: Enumerable<T>): number;\n\n/**\n * Counts values of the collection or iterable.\n *\n * @signature\n *    length()(array)\n * @example\n *    pipe([1, 2, 3], length()) // => 3\n * @dataLast\n * @category Array\n */\nexport function length<T>(): (items: Enumerable<T>) => number;\n\nexport function length(...args: ReadonlyArray<unknown>): unknown {\n  return curry(lengthImplementation, args);\n}\n\nfunction lengthImplementation<T>(items: Enumerable<T>): number {\n  return 'length' in items ? items.length : [...items].length;\n}\n"],"mappings":"kGA6BA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAOA,EAAAA,MAAM,EAAsB,CAAI,CACzC,CAEA,SAAS,EAAwB,EAA8B,CAC7D,MAAO,WAAY,EAAQ,EAAM,OAAS,CAAC,GAAG,CAAK,CAAC,CAAC,MACvD"}

package/dist/length.js.map

@@ -1 +1 @@
-{"version":3,"file":"length.js","names":[],"sources":["../src/length.ts"],"sourcesContent":["import { curry } from './curry';\n\ntype Enumerable<T> = ArrayLike<T> | Iterable<T>;\n\n/**\n * Counts values of the collection or iterable.\n *\n * @param items - The input data.\n * @signature\n *    length(array)\n * @example\n *    length([1, 2, 3]) // => 3\n * @dataFirst\n * @category Array\n */\nexport function length<T>(items: Enumerable<T>): number;\n\n/**\n * Counts values of the collection or iterable.\n *\n * @signature\n *    length()(array)\n * @example\n *    pipe([1, 2, 3], length()) // => 3\n * @dataLast\n * @category Array\n */\nexport function length<T>(): (items: Enumerable<T>) => number;\n\nexport function length(...args: ReadonlyArray<unknown>): unknown {\n  return curry(lengthImplementation, args);\n}\n\nfunction lengthImplementation<T>(items: Enumerable<T>): number {\n  return 'length' in items ? items.length : [...items].length;\n}\n"],"mappings":"mCA6BA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EAAwB,EAA8B,CAC7D,MAAO,WAAY,EAAQ,EAAM,OAAS,CAAC,GAAG,EAAM,CAAC"}
+{"version":3,"file":"length.js","names":[],"sources":["../src/length.ts"],"sourcesContent":["import { curry } from './curry';\n\ntype Enumerable<T> = ArrayLike<T> | Iterable<T>;\n\n/**\n * Counts values of the collection or iterable.\n *\n * @param items - The input data.\n * @signature\n *    length(array)\n * @example\n *    length([1, 2, 3]) // => 3\n * @dataFirst\n * @category Array\n */\nexport function length<T>(items: Enumerable<T>): number;\n\n/**\n * Counts values of the collection or iterable.\n *\n * @signature\n *    length()(array)\n * @example\n *    pipe([1, 2, 3], length()) // => 3\n * @dataLast\n * @category Array\n */\nexport function length<T>(): (items: Enumerable<T>) => number;\n\nexport function length(...args: ReadonlyArray<unknown>): unknown {\n  return curry(lengthImplementation, args);\n}\n\nfunction lengthImplementation<T>(items: Enumerable<T>): number {\n  return 'length' in items ? items.length : [...items].length;\n}\n"],"mappings":"mCA6BA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,CAAI,CACzC,CAEA,SAAS,EAAwB,EAA8B,CAC7D,MAAO,WAAY,EAAQ,EAAM,OAAS,CAAC,GAAG,CAAK,CAAC,CAAC,MACvD"}

package/dist/map-keys.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){let n={};for(let[r,i]of Object.entries(e)){let a=t(r,i,e);n[a]=i}return n}exports.mapKeys=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={};for(let[r,i]of Object.entries(e)){let a=t(r,i,e);n[a]=i}return n}exports.mapKeys=t;
 //# sourceMappingURL=map-keys.cjs.map

package/dist/map-keys.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"map-keys.cjs","names":["curry"],"sources":["../src/map-keys.ts"],"sourcesContent":["/* eslint-disable ts/no-empty-object-type --\n * We want to match the typing of the built-in Object.entries as much as\n * possible!\n */\n\nimport type { And, IsUnion, Or } 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 { IsBounded } from './internal/types/is-bounded';\nimport { curry } from './curry';\n\ntype MappedKeys<T, Key extends PropertyKey> = MaybePartial<\n  T,\n  Key,\n  // We re-key `T` using `Key`, but because we can't infer at the type level\n  // how the mapper would map each specific input key we assign all props the\n  // same value, made of all possible values of `T`.\n  Record<Key, EnumerableStringKeyedValueOf<T>>\n>;\n\n/**\n * This type is very similar to `BoundedPartial` simplified to the case where\n * we reconstruct the Record using a known `Key` type.\n *\n * @see BoundedPartial\n */\ntype MaybePartial<T, Key extends PropertyKey, Output>\n  = And<IsBounded<Key>, Or<IsUnion<Key>, CouldBeEmpty<T>>> extends true\n    ? // When keys are bounded we need to consider what assurances we can make\n  // about the presence of keys in the output; mainly if there is more than\n  // one possible result from the mapper (so we can't know what it would\n  // return for a specific input, at the type level), or if object itself\n  // might be empty and thus also the output object.\n    Partial<Output>\n    : // If keys are not bounded TypeScript treats the Record as implicitly\n  // Partial so we don't need to do that here.\n    Output;\n\n/**\n * Types that are extendable by `{}` are also satisfied by an empty object and\n * thus _could be empty_.\n */\ntype CouldBeEmpty<T> = {} extends T ? true : false;\n\n/**\n * Maps keys of `object` and keeps the same values.\n *\n * @param data - The object to map.\n * @param keyMapper - The mapping function.\n * @signature\n *    mapKeys(object, fn)\n * @example\n *    mapKeys({a: 1, b: 2}, (key, value) => key + value) // => { a1: 1, b2: 2 }\n * @dataFirst\n * @category Object\n */\nexport function mapKeys<T extends {}, Key extends PropertyKey>(\n  data: T,\n  keyMapper: (\n    key: EnumerableStringKeyOf<T>,\n    value: EnumerableStringKeyedValueOf<T>,\n    data: T,\n  ) => Key,\n): MappedKeys<T, Key>;\n\n/**\n * Maps keys of `object` and keeps the same values.\n *\n * @param keyMapper - The mapping function.\n * @signature\n *    mapKeys(fn)(object)\n * @example\n *    pipe({a: 1, b: 2}, mapKeys((key, value) => key + value)) // => { a1: 1, b2: 2 }\n * @dataLast\n * @category Object\n */\nexport function mapKeys<T extends {}, Key extends PropertyKey>(\n  keyMapper: (\n    key: EnumerableStringKeyOf<T>,\n    value: EnumerableStringKeyedValueOf<T>,\n    data: T,\n  ) => Key,\n): (data: T) => MappedKeys<T, Key>;\n\nexport function mapKeys(...args: ReadonlyArray<unknown>): unknown {\n  return curry(mapKeysImplementation, args);\n}\n\nfunction mapKeysImplementation<T extends {}, Key extends PropertyKey>(\n  data: T,\n  keyMapper: (key: string, value: unknown, data: T) => Key,\n): Partial<Record<Key, unknown>> {\n  const out: Partial<Record<Key, unknown>> = {};\n\n  for (const [key, value] of Object.entries(data)) {\n    const mappedKey = keyMapper(key, value, data);\n    out[mappedKey] = value;\n  }\n\n  return out;\n}\n"],"mappings":"kGAoFA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAOA,EAAAA,MAAM,EAAuB,EAAK,CAG3C,SAAS,EACP,EACA,EAC+B,CAC/B,IAAM,EAAqC,EAAE,CAE7C,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAK,CAAE,CAC/C,IAAM,EAAY,EAAU,EAAK,EAAO,EAAK,CAC7C,EAAI,GAAa,EAGnB,OAAO"}
+{"version":3,"file":"map-keys.cjs","names":["curry"],"sources":["../src/map-keys.ts"],"sourcesContent":["/* eslint-disable ts/no-empty-object-type --\n * We want to match the typing of the built-in Object.entries as much as\n * possible!\n */\n\nimport type { IsUnion } 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 { IsBounded } from './internal/types/is-bounded';\nimport { curry } from './curry';\n\ntype MappedKeys<T, Key extends PropertyKey> = MaybePartial<\n  T,\n  Key,\n  // We re-key `T` using `Key`, but because we can't infer at the type level\n  // how the mapper would map each specific input key we assign all props the\n  // same value, made of all possible values of `T`.\n  Record<Key, EnumerableStringKeyedValueOf<T>>\n>;\n\n/**\n * This type is very similar to `BoundedPartial` simplified to the case where\n * we reconstruct the Record using a known `Key` type.\n *\n * @see BoundedPartial\n */\ntype MaybePartial<T, Key extends PropertyKey, Output>\n  = IsBounded<Key> extends true\n    ? // When keys are bounded we need to consider what assurances we can make\n    // about the presence of keys in the output; mainly if there is more than\n    // one possible result from the mapper (so we can't know what it would\n    // return for a specific input, at the type level), or if object itself\n    // might be empty and thus also the output object.\n    IsUnion<Key> extends true\n      ? Partial<Output>\n      : CouldBeEmpty<T> extends true\n        ? Partial<Output>\n        : Output\n    : // If keys are not bounded TypeScript treats the Record as implicitly\n  // Partial so we don't need to do that here.\n    Output;\n\n/**\n * Types that are extendable by `{}` are also satisfied by an empty object and\n * thus _could be empty_.\n */\ntype CouldBeEmpty<T> = {} extends T ? true : false;\n\n/**\n * Maps keys of `object` and keeps the same values.\n *\n * @param data - The object to map.\n * @param keyMapper - The mapping function.\n * @signature\n *    mapKeys(object, fn)\n * @example\n *    mapKeys({a: 1, b: 2}, (key, value) => key + value) // => { a1: 1, b2: 2 }\n * @dataFirst\n * @category Object\n */\nexport function mapKeys<T extends {}, Key extends PropertyKey>(\n  data: T,\n  keyMapper: (\n    key: EnumerableStringKeyOf<T>,\n    value: EnumerableStringKeyedValueOf<T>,\n    data: T,\n  ) => Key,\n): MappedKeys<T, Key>;\n\n/**\n * Maps keys of `object` and keeps the same values.\n *\n * @param keyMapper - The mapping function.\n * @signature\n *    mapKeys(fn)(object)\n * @example\n *    pipe({a: 1, b: 2}, mapKeys((key, value) => key + value)) // => { a1: 1, b2: 2 }\n * @dataLast\n * @category Object\n */\nexport function mapKeys<T extends {}, Key extends PropertyKey>(\n  keyMapper: (\n    key: EnumerableStringKeyOf<T>,\n    value: EnumerableStringKeyedValueOf<T>,\n    data: T,\n  ) => Key,\n): (data: T) => MappedKeys<T, Key>;\n\nexport function mapKeys(...args: ReadonlyArray<unknown>): unknown {\n  return curry(mapKeysImplementation, args);\n}\n\nfunction mapKeysImplementation<T extends {}, Key extends PropertyKey>(\n  data: T,\n  keyMapper: (key: string, value: unknown, data: T) => Key,\n): Partial<Record<Key, unknown>> {\n  const out: Partial<Record<Key, unknown>> = {};\n\n  for (const [key, value] of Object.entries(data)) {\n    const mappedKey = keyMapper(key, value, data);\n    out[mappedKey] = value;\n  }\n\n  return out;\n}\n"],"mappings":"kGAwFA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAOA,EAAAA,MAAM,EAAuB,CAAI,CAC1C,CAEA,SAAS,EACP,EACA,EAC+B,CAC/B,IAAM,EAAqC,CAAC,EAE5C,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,CAAI,EAAG,CAC/C,IAAM,EAAY,EAAU,EAAK,EAAO,CAAI,EAC5C,EAAI,GAAa,CACnB,CAEA,OAAO,CACT"}

package/dist/map-keys.js.map

@@ -1 +1 @@
-{"version":3,"file":"map-keys.js","names":[],"sources":["../src/map-keys.ts"],"sourcesContent":["/* eslint-disable ts/no-empty-object-type --\n * We want to match the typing of the built-in Object.entries as much as\n * possible!\n */\n\nimport type { And, IsUnion, Or } 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 { IsBounded } from './internal/types/is-bounded';\nimport { curry } from './curry';\n\ntype MappedKeys<T, Key extends PropertyKey> = MaybePartial<\n  T,\n  Key,\n  // We re-key `T` using `Key`, but because we can't infer at the type level\n  // how the mapper would map each specific input key we assign all props the\n  // same value, made of all possible values of `T`.\n  Record<Key, EnumerableStringKeyedValueOf<T>>\n>;\n\n/**\n * This type is very similar to `BoundedPartial` simplified to the case where\n * we reconstruct the Record using a known `Key` type.\n *\n * @see BoundedPartial\n */\ntype MaybePartial<T, Key extends PropertyKey, Output>\n  = And<IsBounded<Key>, Or<IsUnion<Key>, CouldBeEmpty<T>>> extends true\n    ? // When keys are bounded we need to consider what assurances we can make\n  // about the presence of keys in the output; mainly if there is more than\n  // one possible result from the mapper (so we can't know what it would\n  // return for a specific input, at the type level), or if object itself\n  // might be empty and thus also the output object.\n    Partial<Output>\n    : // If keys are not bounded TypeScript treats the Record as implicitly\n  // Partial so we don't need to do that here.\n    Output;\n\n/**\n * Types that are extendable by `{}` are also satisfied by an empty object and\n * thus _could be empty_.\n */\ntype CouldBeEmpty<T> = {} extends T ? true : false;\n\n/**\n * Maps keys of `object` and keeps the same values.\n *\n * @param data - The object to map.\n * @param keyMapper - The mapping function.\n * @signature\n *    mapKeys(object, fn)\n * @example\n *    mapKeys({a: 1, b: 2}, (key, value) => key + value) // => { a1: 1, b2: 2 }\n * @dataFirst\n * @category Object\n */\nexport function mapKeys<T extends {}, Key extends PropertyKey>(\n  data: T,\n  keyMapper: (\n    key: EnumerableStringKeyOf<T>,\n    value: EnumerableStringKeyedValueOf<T>,\n    data: T,\n  ) => Key,\n): MappedKeys<T, Key>;\n\n/**\n * Maps keys of `object` and keeps the same values.\n *\n * @param keyMapper - The mapping function.\n * @signature\n *    mapKeys(fn)(object)\n * @example\n *    pipe({a: 1, b: 2}, mapKeys((key, value) => key + value)) // => { a1: 1, b2: 2 }\n * @dataLast\n * @category Object\n */\nexport function mapKeys<T extends {}, Key extends PropertyKey>(\n  keyMapper: (\n    key: EnumerableStringKeyOf<T>,\n    value: EnumerableStringKeyedValueOf<T>,\n    data: T,\n  ) => Key,\n): (data: T) => MappedKeys<T, Key>;\n\nexport function mapKeys(...args: ReadonlyArray<unknown>): unknown {\n  return curry(mapKeysImplementation, args);\n}\n\nfunction mapKeysImplementation<T extends {}, Key extends PropertyKey>(\n  data: T,\n  keyMapper: (key: string, value: unknown, data: T) => Key,\n): Partial<Record<Key, unknown>> {\n  const out: Partial<Record<Key, unknown>> = {};\n\n  for (const [key, value] of Object.entries(data)) {\n    const mappedKey = keyMapper(key, value, data);\n    out[mappedKey] = value;\n  }\n\n  return out;\n}\n"],"mappings":"mCAoFA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAK,CAG3C,SAAS,EACP,EACA,EAC+B,CAC/B,IAAM,EAAqC,EAAE,CAE7C,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAK,CAAE,CAC/C,IAAM,EAAY,EAAU,EAAK,EAAO,EAAK,CAC7C,EAAI,GAAa,EAGnB,OAAO"}
+{"version":3,"file":"map-keys.js","names":[],"sources":["../src/map-keys.ts"],"sourcesContent":["/* eslint-disable ts/no-empty-object-type --\n * We want to match the typing of the built-in Object.entries as much as\n * possible!\n */\n\nimport type { IsUnion } 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 { IsBounded } from './internal/types/is-bounded';\nimport { curry } from './curry';\n\ntype MappedKeys<T, Key extends PropertyKey> = MaybePartial<\n  T,\n  Key,\n  // We re-key `T` using `Key`, but because we can't infer at the type level\n  // how the mapper would map each specific input key we assign all props the\n  // same value, made of all possible values of `T`.\n  Record<Key, EnumerableStringKeyedValueOf<T>>\n>;\n\n/**\n * This type is very similar to `BoundedPartial` simplified to the case where\n * we reconstruct the Record using a known `Key` type.\n *\n * @see BoundedPartial\n */\ntype MaybePartial<T, Key extends PropertyKey, Output>\n  = IsBounded<Key> extends true\n    ? // When keys are bounded we need to consider what assurances we can make\n    // about the presence of keys in the output; mainly if there is more than\n    // one possible result from the mapper (so we can't know what it would\n    // return for a specific input, at the type level), or if object itself\n    // might be empty and thus also the output object.\n    IsUnion<Key> extends true\n      ? Partial<Output>\n      : CouldBeEmpty<T> extends true\n        ? Partial<Output>\n        : Output\n    : // If keys are not bounded TypeScript treats the Record as implicitly\n  // Partial so we don't need to do that here.\n    Output;\n\n/**\n * Types that are extendable by `{}` are also satisfied by an empty object and\n * thus _could be empty_.\n */\ntype CouldBeEmpty<T> = {} extends T ? true : false;\n\n/**\n * Maps keys of `object` and keeps the same values.\n *\n * @param data - The object to map.\n * @param keyMapper - The mapping function.\n * @signature\n *    mapKeys(object, fn)\n * @example\n *    mapKeys({a: 1, b: 2}, (key, value) => key + value) // => { a1: 1, b2: 2 }\n * @dataFirst\n * @category Object\n */\nexport function mapKeys<T extends {}, Key extends PropertyKey>(\n  data: T,\n  keyMapper: (\n    key: EnumerableStringKeyOf<T>,\n    value: EnumerableStringKeyedValueOf<T>,\n    data: T,\n  ) => Key,\n): MappedKeys<T, Key>;\n\n/**\n * Maps keys of `object` and keeps the same values.\n *\n * @param keyMapper - The mapping function.\n * @signature\n *    mapKeys(fn)(object)\n * @example\n *    pipe({a: 1, b: 2}, mapKeys((key, value) => key + value)) // => { a1: 1, b2: 2 }\n * @dataLast\n * @category Object\n */\nexport function mapKeys<T extends {}, Key extends PropertyKey>(\n  keyMapper: (\n    key: EnumerableStringKeyOf<T>,\n    value: EnumerableStringKeyedValueOf<T>,\n    data: T,\n  ) => Key,\n): (data: T) => MappedKeys<T, Key>;\n\nexport function mapKeys(...args: ReadonlyArray<unknown>): unknown {\n  return curry(mapKeysImplementation, args);\n}\n\nfunction mapKeysImplementation<T extends {}, Key extends PropertyKey>(\n  data: T,\n  keyMapper: (key: string, value: unknown, data: T) => Key,\n): Partial<Record<Key, unknown>> {\n  const out: Partial<Record<Key, unknown>> = {};\n\n  for (const [key, value] of Object.entries(data)) {\n    const mappedKey = keyMapper(key, value, data);\n    out[mappedKey] = value;\n  }\n\n  return out;\n}\n"],"mappings":"mCAwFA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,CAAI,CAC1C,CAEA,SAAS,EACP,EACA,EAC+B,CAC/B,IAAM,EAAqC,CAAC,EAE5C,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,CAAI,EAAG,CAC/C,IAAM,EAAY,EAAU,EAAK,EAAO,CAAI,EAC5C,EAAI,GAAa,CACnB,CAEA,OAAO,CACT"}

package/dist/map-to-obj.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){let n={};for(let[r,i]of e.entries()){let[a,o]=t(i,r,e);n[a]=o}return n}exports.mapToObj=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={};for(let[r,i]of e.entries()){let[a,o]=t(i,r,e);n[a]=o}return n}exports.mapToObj=t;
 //# sourceMappingURL=map-to-obj.cjs.map

package/dist/map-to-obj.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"map-to-obj.cjs","names":["curry"],"sources":["../src/map-to-obj.ts"],"sourcesContent":["import { curry } from './curry';\n\n// TODO [>2]: Once we allow fromEntries to run lazily on iterables we need to remove this utility as it's completely replaceable by `fromEntries(map(...))`.\n/**\n * Map each element of an array into an object using a defined mapper that\n * converts each item into an object entry (a tuple of `[<key>, <value>]`).\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * - `fromKeys` - Builds an object from an array of *keys* and a mapper for\n * values.\n * - `indexBy` - Builds an object from an array of *values* and a mapper for\n * keys.\n * - `pullObject` - Builds an object from an array of items with a mapper for\n * values and another mapper for keys.\n * - `fromEntries` - Builds an object from an array of key-value pairs.\n *\n * **Warning**: We strongly advise against using this function unless it is\n * used with a huge input array and your app has stringent memory/gc\n * constraints. We recommend that in most cases you should use `pullObject`,\n * or the composition `fromEntries(map(array, fn))`. This function will be\n * deprecated and **removed** in future versions of the library!\n *\n * @param array - The array to map.\n * @param fn - The mapping function, which should return a tuple of [key, value], similar to Object.fromEntries.\n * @returns The new mapped object.\n * @signature\n *    mapToObj(array, fn)\n * @example\n *    mapToObj([1, 2, 3], x => [String(x), x * 2]) // => {1: 2, 2: 4, 3: 6}\n * @dataFirst\n * @category Array\n */\nexport function mapToObj<T, K extends PropertyKey, V>(\n  array: ReadonlyArray<T>,\n  fn: (value: T, index: number, data: ReadonlyArray<T>) => [K, V],\n): Record<K, V>;\n\n// TODO [>2]: Once we allow fromEntries to run lazily on iterables we need to remove this utility as it's completely replaceable by `fromEntries(map(...))`.\n/**\n * Map each element of an array into an object using a defined mapper that\n * converts each item into an object entry (a tuple of `[<key>, <value>]`).\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * - `fromKeys` - Builds an object from an array of *keys* and a mapper for\n * values.\n * - `indexBy` - Builds an object from an array of *values* and a mapper for\n * keys.\n * - `pullObject` - Builds an object from an array of items with a mapper for\n * values and another mapper for keys.\n * - `fromEntries` - Builds an object from an array of key-value pairs.\n *\n * **Warning**: We strongly advise against using this function unless it is\n * used with a huge input array and your app has stringent memory/gc\n * constraints. We recommend that in most cases you should use `pullObject`,\n * or the composition `fromEntries(map(array, fn))`. This function will be\n * deprecated and **removed** in future versions of the library!\n *\n * @param fn - The mapping function, which should return a tuple of [key, value], similar to Object.fromEntries.\n * @returns The new mapped object.\n * @signature\n *    mapToObj(fn)(array)\n * @example\n *    pipe(\n *      [1, 2, 3],\n *      mapToObj(x => [String(x), x * 2])\n *    ) // => {1: 2, 2: 4, 3: 6}\n * @dataLast\n * @category Array\n */\nexport function mapToObj<T, K extends PropertyKey, V>(\n  fn: (value: T, index: number, data: ReadonlyArray<T>) => [K, V],\n): (array: ReadonlyArray<T>) => Record<K, V>;\n\nexport function mapToObj(...args: ReadonlyArray<unknown>): unknown {\n  return curry(mapToObjImplementation, args);\n}\n\nfunction mapToObjImplementation(\n  array: ReadonlyArray<unknown>,\n  fn: (\n    value: unknown,\n    index: number,\n    data: ReadonlyArray<unknown>,\n  ) => [PropertyKey, unknown],\n): Record<PropertyKey, unknown> {\n  const out: Record<PropertyKey, unknown> = {};\n\n  for (const [index, element] of array.entries()) {\n    const [key, value] = fn(element, index, array);\n    out[key] = value;\n  }\n\n  return out;\n}\n"],"mappings":"kGA2EA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAOA,EAAAA,MAAM,EAAwB,EAAK,CAG5C,SAAS,EACP,EACA,EAK8B,CAC9B,IAAM,EAAoC,EAAE,CAE5C,IAAK,GAAM,CAAC,EAAO,KAAY,EAAM,SAAS,CAAE,CAC9C,GAAM,CAAC,EAAK,GAAS,EAAG,EAAS,EAAO,EAAM,CAC9C,EAAI,GAAO,EAGb,OAAO"}
+{"version":3,"file":"map-to-obj.cjs","names":["curry"],"sources":["../src/map-to-obj.ts"],"sourcesContent":["import { curry } from './curry';\n\n// TODO [>2]: Once we allow fromEntries to run lazily on iterables we need to remove this utility as it's completely replaceable by `fromEntries(map(...))`.\n/**\n * Map each element of an array into an object using a defined mapper that\n * converts each item into an object entry (a tuple of `[<key>, <value>]`).\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * - `fromKeys` - Builds an object from an array of *keys* and a mapper for\n * values.\n * - `indexBy` - Builds an object from an array of *values* and a mapper for\n * keys.\n * - `pullObject` - Builds an object from an array of items with a mapper for\n * values and another mapper for keys.\n * - `fromEntries` - Builds an object from an array of key-value pairs.\n *\n * **Warning**: We strongly advise against using this function unless it is\n * used with a huge input array and your app has stringent memory/gc\n * constraints. We recommend that in most cases you should use `pullObject`,\n * or the composition `fromEntries(map(array, fn))`. This function will be\n * deprecated and **removed** in future versions of the library!\n *\n * @param array - The array to map.\n * @param fn - The mapping function, which should return a tuple of [key, value], similar to Object.fromEntries.\n * @returns The new mapped object.\n * @signature\n *    mapToObj(array, fn)\n * @example\n *    mapToObj([1, 2, 3], x => [String(x), x * 2]) // => {1: 2, 2: 4, 3: 6}\n * @dataFirst\n * @category Array\n */\nexport function mapToObj<T, K extends PropertyKey, V>(\n  array: ReadonlyArray<T>,\n  fn: (value: T, index: number, data: ReadonlyArray<T>) => [K, V],\n): Record<K, V>;\n\n// TODO [>2]: Once we allow fromEntries to run lazily on iterables we need to remove this utility as it's completely replaceable by `fromEntries(map(...))`.\n/**\n * Map each element of an array into an object using a defined mapper that\n * converts each item into an object entry (a tuple of `[<key>, <value>]`).\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * - `fromKeys` - Builds an object from an array of *keys* and a mapper for\n * values.\n * - `indexBy` - Builds an object from an array of *values* and a mapper for\n * keys.\n * - `pullObject` - Builds an object from an array of items with a mapper for\n * values and another mapper for keys.\n * - `fromEntries` - Builds an object from an array of key-value pairs.\n *\n * **Warning**: We strongly advise against using this function unless it is\n * used with a huge input array and your app has stringent memory/gc\n * constraints. We recommend that in most cases you should use `pullObject`,\n * or the composition `fromEntries(map(array, fn))`. This function will be\n * deprecated and **removed** in future versions of the library!\n *\n * @param fn - The mapping function, which should return a tuple of [key, value], similar to Object.fromEntries.\n * @returns The new mapped object.\n * @signature\n *    mapToObj(fn)(array)\n * @example\n *    pipe(\n *      [1, 2, 3],\n *      mapToObj(x => [String(x), x * 2])\n *    ) // => {1: 2, 2: 4, 3: 6}\n * @dataLast\n * @category Array\n */\nexport function mapToObj<T, K extends PropertyKey, V>(\n  fn: (value: T, index: number, data: ReadonlyArray<T>) => [K, V],\n): (array: ReadonlyArray<T>) => Record<K, V>;\n\nexport function mapToObj(...args: ReadonlyArray<unknown>): unknown {\n  return curry(mapToObjImplementation, args);\n}\n\nfunction mapToObjImplementation(\n  array: ReadonlyArray<unknown>,\n  fn: (\n    value: unknown,\n    index: number,\n    data: ReadonlyArray<unknown>,\n  ) => [PropertyKey, unknown],\n): Record<PropertyKey, unknown> {\n  const out: Record<PropertyKey, unknown> = {};\n\n  for (const [index, element] of array.entries()) {\n    const [key, value] = fn(element, index, array);\n    out[key] = value;\n  }\n\n  return out;\n}\n"],"mappings":"kGA2EA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAOA,EAAAA,MAAM,EAAwB,CAAI,CAC3C,CAEA,SAAS,EACP,EACA,EAK8B,CAC9B,IAAM,EAAoC,CAAC,EAE3C,IAAK,GAAM,CAAC,EAAO,KAAY,EAAM,QAAQ,EAAG,CAC9C,GAAM,CAAC,EAAK,GAAS,EAAG,EAAS,EAAO,CAAK,EAC7C,EAAI,GAAO,CACb,CAEA,OAAO,CACT"}

package/dist/map-to-obj.js.map

@@ -1 +1 @@
-{"version":3,"file":"map-to-obj.js","names":[],"sources":["../src/map-to-obj.ts"],"sourcesContent":["import { curry } from './curry';\n\n// TODO [>2]: Once we allow fromEntries to run lazily on iterables we need to remove this utility as it's completely replaceable by `fromEntries(map(...))`.\n/**\n * Map each element of an array into an object using a defined mapper that\n * converts each item into an object entry (a tuple of `[<key>, <value>]`).\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * - `fromKeys` - Builds an object from an array of *keys* and a mapper for\n * values.\n * - `indexBy` - Builds an object from an array of *values* and a mapper for\n * keys.\n * - `pullObject` - Builds an object from an array of items with a mapper for\n * values and another mapper for keys.\n * - `fromEntries` - Builds an object from an array of key-value pairs.\n *\n * **Warning**: We strongly advise against using this function unless it is\n * used with a huge input array and your app has stringent memory/gc\n * constraints. We recommend that in most cases you should use `pullObject`,\n * or the composition `fromEntries(map(array, fn))`. This function will be\n * deprecated and **removed** in future versions of the library!\n *\n * @param array - The array to map.\n * @param fn - The mapping function, which should return a tuple of [key, value], similar to Object.fromEntries.\n * @returns The new mapped object.\n * @signature\n *    mapToObj(array, fn)\n * @example\n *    mapToObj([1, 2, 3], x => [String(x), x * 2]) // => {1: 2, 2: 4, 3: 6}\n * @dataFirst\n * @category Array\n */\nexport function mapToObj<T, K extends PropertyKey, V>(\n  array: ReadonlyArray<T>,\n  fn: (value: T, index: number, data: ReadonlyArray<T>) => [K, V],\n): Record<K, V>;\n\n// TODO [>2]: Once we allow fromEntries to run lazily on iterables we need to remove this utility as it's completely replaceable by `fromEntries(map(...))`.\n/**\n * Map each element of an array into an object using a defined mapper that\n * converts each item into an object entry (a tuple of `[<key>, <value>]`).\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * - `fromKeys` - Builds an object from an array of *keys* and a mapper for\n * values.\n * - `indexBy` - Builds an object from an array of *values* and a mapper for\n * keys.\n * - `pullObject` - Builds an object from an array of items with a mapper for\n * values and another mapper for keys.\n * - `fromEntries` - Builds an object from an array of key-value pairs.\n *\n * **Warning**: We strongly advise against using this function unless it is\n * used with a huge input array and your app has stringent memory/gc\n * constraints. We recommend that in most cases you should use `pullObject`,\n * or the composition `fromEntries(map(array, fn))`. This function will be\n * deprecated and **removed** in future versions of the library!\n *\n * @param fn - The mapping function, which should return a tuple of [key, value], similar to Object.fromEntries.\n * @returns The new mapped object.\n * @signature\n *    mapToObj(fn)(array)\n * @example\n *    pipe(\n *      [1, 2, 3],\n *      mapToObj(x => [String(x), x * 2])\n *    ) // => {1: 2, 2: 4, 3: 6}\n * @dataLast\n * @category Array\n */\nexport function mapToObj<T, K extends PropertyKey, V>(\n  fn: (value: T, index: number, data: ReadonlyArray<T>) => [K, V],\n): (array: ReadonlyArray<T>) => Record<K, V>;\n\nexport function mapToObj(...args: ReadonlyArray<unknown>): unknown {\n  return curry(mapToObjImplementation, args);\n}\n\nfunction mapToObjImplementation(\n  array: ReadonlyArray<unknown>,\n  fn: (\n    value: unknown,\n    index: number,\n    data: ReadonlyArray<unknown>,\n  ) => [PropertyKey, unknown],\n): Record<PropertyKey, unknown> {\n  const out: Record<PropertyKey, unknown> = {};\n\n  for (const [index, element] of array.entries()) {\n    const [key, value] = fn(element, index, array);\n    out[key] = value;\n  }\n\n  return out;\n}\n"],"mappings":"mCA2EA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAM,EAAwB,EAAK,CAG5C,SAAS,EACP,EACA,EAK8B,CAC9B,IAAM,EAAoC,EAAE,CAE5C,IAAK,GAAM,CAAC,EAAO,KAAY,EAAM,SAAS,CAAE,CAC9C,GAAM,CAAC,EAAK,GAAS,EAAG,EAAS,EAAO,EAAM,CAC9C,EAAI,GAAO,EAGb,OAAO"}
+{"version":3,"file":"map-to-obj.js","names":[],"sources":["../src/map-to-obj.ts"],"sourcesContent":["import { curry } from './curry';\n\n// TODO [>2]: Once we allow fromEntries to run lazily on iterables we need to remove this utility as it's completely replaceable by `fromEntries(map(...))`.\n/**\n * Map each element of an array into an object using a defined mapper that\n * converts each item into an object entry (a tuple of `[<key>, <value>]`).\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * - `fromKeys` - Builds an object from an array of *keys* and a mapper for\n * values.\n * - `indexBy` - Builds an object from an array of *values* and a mapper for\n * keys.\n * - `pullObject` - Builds an object from an array of items with a mapper for\n * values and another mapper for keys.\n * - `fromEntries` - Builds an object from an array of key-value pairs.\n *\n * **Warning**: We strongly advise against using this function unless it is\n * used with a huge input array and your app has stringent memory/gc\n * constraints. We recommend that in most cases you should use `pullObject`,\n * or the composition `fromEntries(map(array, fn))`. This function will be\n * deprecated and **removed** in future versions of the library!\n *\n * @param array - The array to map.\n * @param fn - The mapping function, which should return a tuple of [key, value], similar to Object.fromEntries.\n * @returns The new mapped object.\n * @signature\n *    mapToObj(array, fn)\n * @example\n *    mapToObj([1, 2, 3], x => [String(x), x * 2]) // => {1: 2, 2: 4, 3: 6}\n * @dataFirst\n * @category Array\n */\nexport function mapToObj<T, K extends PropertyKey, V>(\n  array: ReadonlyArray<T>,\n  fn: (value: T, index: number, data: ReadonlyArray<T>) => [K, V],\n): Record<K, V>;\n\n// TODO [>2]: Once we allow fromEntries to run lazily on iterables we need to remove this utility as it's completely replaceable by `fromEntries(map(...))`.\n/**\n * Map each element of an array into an object using a defined mapper that\n * converts each item into an object entry (a tuple of `[<key>, <value>]`).\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * - `fromKeys` - Builds an object from an array of *keys* and a mapper for\n * values.\n * - `indexBy` - Builds an object from an array of *values* and a mapper for\n * keys.\n * - `pullObject` - Builds an object from an array of items with a mapper for\n * values and another mapper for keys.\n * - `fromEntries` - Builds an object from an array of key-value pairs.\n *\n * **Warning**: We strongly advise against using this function unless it is\n * used with a huge input array and your app has stringent memory/gc\n * constraints. We recommend that in most cases you should use `pullObject`,\n * or the composition `fromEntries(map(array, fn))`. This function will be\n * deprecated and **removed** in future versions of the library!\n *\n * @param fn - The mapping function, which should return a tuple of [key, value], similar to Object.fromEntries.\n * @returns The new mapped object.\n * @signature\n *    mapToObj(fn)(array)\n * @example\n *    pipe(\n *      [1, 2, 3],\n *      mapToObj(x => [String(x), x * 2])\n *    ) // => {1: 2, 2: 4, 3: 6}\n * @dataLast\n * @category Array\n */\nexport function mapToObj<T, K extends PropertyKey, V>(\n  fn: (value: T, index: number, data: ReadonlyArray<T>) => [K, V],\n): (array: ReadonlyArray<T>) => Record<K, V>;\n\nexport function mapToObj(...args: ReadonlyArray<unknown>): unknown {\n  return curry(mapToObjImplementation, args);\n}\n\nfunction mapToObjImplementation(\n  array: ReadonlyArray<unknown>,\n  fn: (\n    value: unknown,\n    index: number,\n    data: ReadonlyArray<unknown>,\n  ) => [PropertyKey, unknown],\n): Record<PropertyKey, unknown> {\n  const out: Record<PropertyKey, unknown> = {};\n\n  for (const [index, element] of array.entries()) {\n    const [key, value] = fn(element, index, array);\n    out[key] = value;\n  }\n\n  return out;\n}\n"],"mappings":"mCA2EA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAM,EAAwB,CAAI,CAC3C,CAEA,SAAS,EACP,EACA,EAK8B,CAC9B,IAAM,EAAoC,CAAC,EAE3C,IAAK,GAAM,CAAC,EAAO,KAAY,EAAM,QAAQ,EAAG,CAC9C,GAAM,CAAC,EAAK,GAAS,EAAG,EAAS,EAAO,CAAK,EAC7C,EAAI,GAAO,CACb,CAEA,OAAO,CACT"}

package/dist/map-values.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){let n={};for(let[r,i]of Object.entries(e))n[r]=t(i,r,e);return n}exports.mapValues=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={};for(let[r,i]of Object.entries(e))n[r]=t(i,r,e);return n}exports.mapValues=t;
 //# sourceMappingURL=map-values.cjs.map

package/dist/map-values.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"map-values.cjs","names":["curry"],"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":"kGAyDA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAOA,EAAAA,MAAM,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"}
+{"version":3,"file":"map-values.cjs","names":["curry"],"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":"kGAyDA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAOA,EAAAA,MAAM,EAAyB,CAAI,CAC5C,CAEA,SAAS,EACP,EACA,EACuB,CACvB,IAAM,EAA6B,CAAC,EAEpC,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,CAAI,EAE5C,EAAI,GADgB,EAAY,EAAO,EAAK,CACvB,EAGvB,OAAO,CACT"}

package/dist/map-values.js.map

@@ -1 +1 @@
-{"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"}
+{"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,CAAI,CAC5C,CAEA,SAAS,EACP,EACA,EACuB,CACvB,IAAM,EAA6B,CAAC,EAEpC,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,CAAI,EAE5C,EAAI,GADgB,EAAY,EAAO,EAAK,CACvB,EAGvB,OAAO,CACT"}

package/dist/map-with-feedback.cjs

@@ -1,2 +1,2 @@
-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;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry-from-lazy-mdjeRP1g.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

@@ -1 +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"}
+{"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,CAAI,CAC/C,CAEA,SAAS,EAAyB,EAK1B,EAAsC,CAC5C,IAAI,EAAgB,EACpB,OAAQ,EAAc,EAAO,KAC3B,EAAgB,EAAQ,EAAe,EAAc,EAAO,CAAI,EACzD,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,CAAc,EAE7D"}

package/dist/map-with-feedback.js

@@ -1,2 +1,2 @@
-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};
+import{t as e}from"./curry-from-lazy-BoPMn2L_.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';\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"}
+{"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,CAAI,CAC/C,CAEA,SAAS,EAAyB,EAK1B,EAAsC,CAC5C,IAAI,EAAgB,EACpB,OAAQ,EAAc,EAAO,KAC3B,EAAgB,EAAQ,EAAe,EAAc,EAAO,CAAI,EACzD,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,CAAc,EAE7D"}

package/dist/map.cjs

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

@@ -1 +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"}
+{"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,CAAkB,CAC1D,CAEA,SAAS,EAAwB,EAAwB,EAA8E,CACrI,OAAO,EAAK,IAAI,CAAU,CAC5B,CAEA,SAAS,EAAyB,EAAyF,CACzH,OAAQ,EAAO,EAAO,KAAU,CAC9B,KAAM,GACN,QAAS,GACT,KAAM,EAAW,EAAO,EAAO,CAAI,CACrC,EACF"}

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';\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"}
+{"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,CAAkB,CAC1D,CAEA,SAAS,EAAwB,EAAwB,EAA8E,CACrI,OAAO,EAAK,IAAI,CAAU,CAC5B,CAEA,SAAS,EAAyB,EAAyF,CACzH,OAAQ,EAAO,EAAO,KAAU,CAC9B,KAAM,GACN,QAAS,GACT,KAAM,EAAW,EAAO,EAAO,CAAI,CACrC,EACF"}

package/dist/mean-by.cjs

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

@@ -1 +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"}
+{"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,CAAI,CACzC,CAEA,SAAS,EAAwB,EAAyB,EAAyE,CACjI,GAAI,EAAM,SAAW,EACnB,MAAO,KAGT,IAAI,EAAM,EAEV,IAAK,GAAM,CAAC,EAAO,KAAS,EAAM,QAAQ,EACxC,GAAO,EAAG,EAAM,EAAO,CAAK,EAG9B,OAAO,EAAM,EAAM,MACrB"}

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 *   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"}
+{"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,CAAI,CACzC,CAEA,SAAS,EAAwB,EAAyB,EAAyE,CACjI,GAAI,EAAM,SAAW,EACnB,MAAO,KAGT,IAAI,EAAM,EAEV,IAAK,GAAM,CAAC,EAAO,KAAS,EAAM,QAAQ,EACxC,GAAO,EAAG,EAAM,EAAO,CAAK,EAG9B,OAAO,EAAM,EAAM,MACrB"}

package/dist/mean.cjs

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

@@ -1 +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"}
+{"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,CAAI,CACvC,CAEA,SAAS,EACP,EACuB,CACnB,KAAK,SAAW,EAIpB,OAAOC,EAAAA,IAAI,CAAI,EAAI,EAAK,MAC1B"}

package/dist/mean.js.map

@@ -1 +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"}
+{"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,CAAI,CACvC,CAEA,SAAS,EACP,EACuB,CACnB,KAAK,SAAW,EAIpB,OAAO,EAAI,CAAI,EAAI,EAAK,MAC1B"}

package/dist/median.cjs

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

@@ -1 +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"}
+{"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,CAAI,CACzC,CAEA,MAAM,GAAoB,EAAW,IAAsB,EAAI,EAE/D,SAAS,EACP,EACuB,CACvB,GAAI,EAAK,SAAW,EAClB,OAIF,IAAM,EAAa,CAAC,GAAG,CAAI,CAAC,CAAC,KAAK,CAAgB,EAGlD,GAAI,EAAW,OAAS,GAAM,EAC5B,OAAO,GAAY,EAAW,OAAS,GAAK,GAI9C,IAAM,EAAc,EAAW,OAAS,EAExC,OAAQ,EAAW,GAAgB,EAAW,EAAc,IAAO,CACrE"}

package/dist/median.js.map

@@ -1 +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"}
+{"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,CAAI,CACzC,CAEA,MAAM,GAAoB,EAAW,IAAsB,EAAI,EAE/D,SAAS,EACP,EACuB,CACvB,GAAI,EAAK,SAAW,EAClB,OAIF,IAAM,EAAa,CAAC,GAAG,CAAI,CAAC,CAAC,KAAK,CAAgB,EAGlD,GAAI,EAAW,OAAS,GAAM,EAC5B,OAAO,GAAY,EAAW,OAAS,GAAK,GAI9C,IAAM,EAAc,EAAW,OAAS,EAExC,OAAQ,EAAW,GAAgB,EAAW,EAAc,IAAO,CACrE"}

package/dist/merge-all.cjs.map

@@ -1 +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"}
+{"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,CAAC,EAEX,IAAK,IAAM,KAAQ,EACjB,EAAM,CAAE,GAAG,EAAK,GAAG,CAAK,EAG1B,OAAO,CACT"}

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 *    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"}
+{"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,CAAC,EAEX,IAAK,IAAM,KAAQ,EACjB,EAAM,CAAE,GAAG,EAAK,GAAG,CAAK,EAG1B,OAAO,CACT"}

package/dist/merge-deep.cjs

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