@vinicunca/perkakas 1.14.0 → 1.16.0

package/dist/has-prop.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-prop.cjs","names":["curry"],"sources":["../src/has-prop.ts"],"sourcesContent":["import type { KeysOfUnion, Simplify } from 'type-fest';\nimport type { IsBounded } from './internal/types/is-bounded';\nimport { curry } from './curry';\n\n// Arrays route to the `boolean`-returning overload below: their `keyof`\n// includes prototype methods (`push`, `pop`, …) that aren't own properties\n// at runtime, which would otherwise collapse the predicate's else branch to\n// `never`. The leading `extends readonly unknown[]` filter is mirrored on\n// both the predicate type and the parameter type so the type-predicate\n// assignability check stays satisfied.\ntype NonArray<T> = T extends ReadonlyArray<unknown> ? never : T;\n\ntype HasProp<T, Key extends PropertyKey> = T extends ReadonlyArray<unknown>\n  ? never\n  : // Distribute over `T`'s union members so members that don't have `Key`\n// drop out of the narrowed type.\n  T extends unknown\n    ? Key extends keyof T\n      ? // `T &` makes the result structurally a subtype of `T`, satisfying\n    // the type-predicate assignability check.\n      Simplify<T & Required<Pick<T, Key>>>\n      : never\n    : never;\n\n/**\n * Checks if `data` has a prop `key`.\n *\n * Uses [`Object.hasOwn`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwn)\n * which only checks own properties, skipping properties inherited through the\n * prototype chain.\n *\n * - Use `prop` to read the value.\n *\n * @param data - The object to test.\n * @param key - The key to look up.\n * @signature\n *   hasProp(data, key)\n * @example\n *   hasProp({ a: 1 }, \"a\"); //=> true\n * @dataFirst\n * @category Guard\n */\nexport function hasProp<T extends object, Key extends KeysOfUnion<T>>(\n  // Arrays route to the `boolean`-returning overload below: their `keyof`\n  // includes prototype methods (`push`, `pop`, …) that aren't own properties\n  // at runtime, which would otherwise collapse the predicate's else branch\n  // to `never`. Use `hasAtLeast` to narrow array indices and `isArray` to\n  // discriminate array vs. object unions.\n  data: NonArray<T>,\n  // Bounded literal keys narrow; unbounded keys (`string`, template\n  // literals, etc.) route to the `boolean`-returning overload below so the\n  // predicate doesn't collapse the else-branch to `never`.\n  key: IsBounded<Key> extends true ? Key : never,\n): data is HasProp<T, Key>;\nexport function hasProp<T extends object>(\n  data: T,\n  key: KeysOfUnion<T>,\n): boolean;\n\n/**\n * Checks if `data` has a prop `key`.\n *\n * Uses [`Object.hasOwn`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwn)\n * which only checks own properties, skipping properties inherited through the\n * prototype chain.\n *\n * - Use `prop` to read the value.\n *\n * @param key - The key to look up.\n * @signature\n *   hasProp(key)(data)\n * @example\n *   pipe({ a: 1 }, hasProp(\"a\")); //=> true\n *   filter([] as { a?: number }[], hasProp(\"a\")); //=> typed as { a: number }[]\n * @dataLast\n * @category Guard\n */\nexport function hasProp<T extends object, Key extends KeysOfUnion<T>>(\n  key: IsBounded<Key> extends true ? Key : never,\n): (data: NonArray<T>) => data is HasProp<T, Key>;\nexport function hasProp<T extends object>(\n  key: KeysOfUnion<T>,\n): (data: T) => boolean;\n\nexport function hasProp(...args: ReadonlyArray<unknown>): unknown {\n  return curry(hasPropImplementation, args);\n}\n\nfunction hasPropImplementation<T extends object, Key extends KeysOfUnion<T>>(\n  data: T,\n  key: Key,\n): data is HasProp<T, Key> {\n  return Object.hasOwn(data, key);\n}\n"],"mappings":"kGAoFA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAOA,EAAAA,MAAM,EAAuB,CAAI,CAC1C,CAEA,SAAS,EACP,EACA,EACyB,CACzB,OAAO,OAAO,OAAO,EAAM,CAAG,CAChC"}

package/dist/has-prop.js

@@ -0,0 +1,2 @@
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t){return Object.hasOwn(e,t)}export{t as hasProp};
+//# sourceMappingURL=has-prop.js.map

package/dist/has-prop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-prop.js","names":[],"sources":["../src/has-prop.ts"],"sourcesContent":["import type { KeysOfUnion, Simplify } from 'type-fest';\nimport type { IsBounded } from './internal/types/is-bounded';\nimport { curry } from './curry';\n\n// Arrays route to the `boolean`-returning overload below: their `keyof`\n// includes prototype methods (`push`, `pop`, …) that aren't own properties\n// at runtime, which would otherwise collapse the predicate's else branch to\n// `never`. The leading `extends readonly unknown[]` filter is mirrored on\n// both the predicate type and the parameter type so the type-predicate\n// assignability check stays satisfied.\ntype NonArray<T> = T extends ReadonlyArray<unknown> ? never : T;\n\ntype HasProp<T, Key extends PropertyKey> = T extends ReadonlyArray<unknown>\n  ? never\n  : // Distribute over `T`'s union members so members that don't have `Key`\n// drop out of the narrowed type.\n  T extends unknown\n    ? Key extends keyof T\n      ? // `T &` makes the result structurally a subtype of `T`, satisfying\n    // the type-predicate assignability check.\n      Simplify<T & Required<Pick<T, Key>>>\n      : never\n    : never;\n\n/**\n * Checks if `data` has a prop `key`.\n *\n * Uses [`Object.hasOwn`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwn)\n * which only checks own properties, skipping properties inherited through the\n * prototype chain.\n *\n * - Use `prop` to read the value.\n *\n * @param data - The object to test.\n * @param key - The key to look up.\n * @signature\n *   hasProp(data, key)\n * @example\n *   hasProp({ a: 1 }, \"a\"); //=> true\n * @dataFirst\n * @category Guard\n */\nexport function hasProp<T extends object, Key extends KeysOfUnion<T>>(\n  // Arrays route to the `boolean`-returning overload below: their `keyof`\n  // includes prototype methods (`push`, `pop`, …) that aren't own properties\n  // at runtime, which would otherwise collapse the predicate's else branch\n  // to `never`. Use `hasAtLeast` to narrow array indices and `isArray` to\n  // discriminate array vs. object unions.\n  data: NonArray<T>,\n  // Bounded literal keys narrow; unbounded keys (`string`, template\n  // literals, etc.) route to the `boolean`-returning overload below so the\n  // predicate doesn't collapse the else-branch to `never`.\n  key: IsBounded<Key> extends true ? Key : never,\n): data is HasProp<T, Key>;\nexport function hasProp<T extends object>(\n  data: T,\n  key: KeysOfUnion<T>,\n): boolean;\n\n/**\n * Checks if `data` has a prop `key`.\n *\n * Uses [`Object.hasOwn`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwn)\n * which only checks own properties, skipping properties inherited through the\n * prototype chain.\n *\n * - Use `prop` to read the value.\n *\n * @param key - The key to look up.\n * @signature\n *   hasProp(key)(data)\n * @example\n *   pipe({ a: 1 }, hasProp(\"a\")); //=> true\n *   filter([] as { a?: number }[], hasProp(\"a\")); //=> typed as { a: number }[]\n * @dataLast\n * @category Guard\n */\nexport function hasProp<T extends object, Key extends KeysOfUnion<T>>(\n  key: IsBounded<Key> extends true ? Key : never,\n): (data: NonArray<T>) => data is HasProp<T, Key>;\nexport function hasProp<T extends object>(\n  key: KeysOfUnion<T>,\n): (data: T) => boolean;\n\nexport function hasProp(...args: ReadonlyArray<unknown>): unknown {\n  return curry(hasPropImplementation, args);\n}\n\nfunction hasPropImplementation<T extends object, Key extends KeysOfUnion<T>>(\n  data: T,\n  key: Key,\n): data is HasProp<T, Key> {\n  return Object.hasOwn(data, key);\n}\n"],"mappings":"mCAoFA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,CAAI,CAC1C,CAEA,SAAS,EACP,EACA,EACyB,CACzB,OAAO,OAAO,OAAO,EAAM,CAAG,CAChC"}

package/dist/has-sub-object.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`),t=require(`./is-deep-equal.cjs`);function n(...t){return e.curry(r,t)}function r(e,n){for(let[r,i]of Object.entries(n))if(!Object.hasOwn(e,r)||!t.isDeepEqual(i,e[r]))return!1;return!0}exports.hasSubObject=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs"),t=require("./is-deep-equal.cjs");function n(...t){return e.curry(r,t)}function r(e,n){for(let[r,i]of Object.entries(n))if(!Object.hasOwn(e,r)||!t.isDeepEqual(i,e[r]))return!1;return!0}exports.hasSubObject=n;
 //# sourceMappingURL=has-sub-object.cjs.map

package/dist/has-sub-object.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"has-sub-object.cjs","names":["curry","isDeepEqual"],"sources":["../src/has-sub-object.ts"],"sourcesContent":["import type { Simplify, Tagged } from 'type-fest';\nimport { curry } from './curry';\nimport { isDeepEqual } from './is-deep-equal';\n\n// eslint-disable-next-line ts/no-unused-vars -- We want to confine the typing to a specific symbol\ndeclare const HAS_SUB_OBJECT_BRAND: unique symbol;\n\ntype HasSubObjectGuard<T, S> = Simplify<\n  Tagged<S & T, typeof HAS_SUB_OBJECT_BRAND>\n>;\n\ntype HasSubObjectObjectValue<A, B> = Partial<{\n  [Key in keyof A & keyof B]: A[Key] & B[Key] extends never\n    ? B[Key]\n    : A[Key] | B[Key] extends object\n      ? HasSubObjectObjectValue<A[Key], B[Key]>\n      : A[Key] & B[Key] extends object\n        ? B[Key]\n        : A[Key];\n}> & {\n  [Key in\n  | Exclude<keyof A, keyof B>\n  | Exclude<keyof B, keyof A>]: Key extends keyof B ? B[Key] : never;\n};\n\ntype HasSubObjectData<\n  Data,\n  SubObject,\n  RData = Required<Data>,\n  RSubObject = Required<SubObject>,\n> = Partial<{\n  [Key in keyof RData & keyof RSubObject]: RData[Key]\n    & RSubObject[Key] extends never\n    ? RSubObject[Key]\n    : RData[Key] | RSubObject[Key] extends object\n      ? HasSubObjectObjectValue<RData[Key], RSubObject[Key]>\n      : RData[Key] & RSubObject[Key] extends object\n        ? RSubObject[Key]\n        : RData[Key];\n}> & {\n  [Key in Exclude<keyof SubObject, keyof Data>]: SubObject[Key];\n};\n\ntype HasSubObjectSubObject<\n  SubObject,\n  Data,\n  RSubObject = Required<SubObject>,\n  RData = Required<Data>,\n> = Partial<{\n  [Key in keyof RData & keyof RSubObject]: RData[Key]\n    & RSubObject[Key] extends never\n    ? RData[Key]\n    : RData[Key] | RSubObject[Key] extends object\n      ? HasSubObjectObjectValue<RSubObject[Key], RData[Key]>\n      : RData[Key] & RSubObject[Key] extends object\n        ? RData[Key]\n        : RSubObject[Key];\n}>\n& Record<Exclude<keyof SubObject, keyof Data>, never>;\n\n/**\n * Checks if `subObject` is a sub-object of `object`, which means for every\n * property and value in `subObject`, there's the same property in `object`\n * with an equal value. Equality is checked with `isDeepEqual`.\n *\n * @param data - The object to test.\n * @param subObject - The sub-object to test against.\n * @signature\n *    hasSubObject(data, subObject)\n * @example\n *    hasSubObject({ a: 1, b: 2, c: 3 }, { a: 1, c: 3 }) //=> true\n *    hasSubObject({ a: 1, b: 2, c: 3 }, { b: 4 }) //=> false\n *    hasSubObject({ a: 1, b: 2, c: 3 }, {}) //=> true\n * @dataFirst\n * @category Guard\n */\nexport function hasSubObject<\n  T extends object,\n  S extends HasSubObjectSubObject<S, T>,\n>(data: T, subObject: S): data is HasSubObjectGuard<T, S>;\n\n/**\n * Checks if `subObject` is a sub-object of `object`, which means for every\n * property and value in `subObject`, there's the same property in `object`\n * with an equal value. Equality is checked with `isDeepEqual`.\n *\n * @param subObject - The sub-object to test against.\n * @signature\n *    hasSubObject(subObject)(data)\n * @example\n *    hasSubObject({ a: 1, c: 3 })({ a: 1, b: 2, c: 3 }) //=> true\n *    hasSubObject({ b: 4 })({ a: 1, b: 2, c: 3 }) //=> false\n *    hasSubObject({})({ a: 1, b: 2, c: 3 }) //=> true\n * @dataLast\n * @category Guard\n */\nexport function hasSubObject<S extends object>(\n  subObject: S,\n): <T extends HasSubObjectData<T, S>>(\n  data: T,\n) => data is HasSubObjectGuard<T, S>;\n\nexport function hasSubObject(...args: ReadonlyArray<unknown>): unknown {\n  return curry(hasSubObjectImplementation, args);\n}\n\nfunction hasSubObjectImplementation<\n  T extends Record<PropertyKey, unknown>,\n  S extends Record<PropertyKey, unknown>,\n>(data: T, subObject: S): data is HasSubObjectGuard<T, S> {\n  for (const [key, value] of Object.entries(subObject)) {\n    if (!Object.hasOwn(data, key)) {\n      return false;\n    }\n\n    if (!isDeepEqual(value, data[key])) {\n      return false;\n    }\n  }\n\n  return true;\n}\n"],"mappings":"mIAsGA,SAAgB,EAAa,GAAG,EAAuC,CACrE,OAAOA,EAAAA,MAAM,EAA4B,EAAK,CAGhD,SAAS,EAGP,EAAS,EAA+C,CACxD,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAU,CAKlD,GAJI,CAAC,OAAO,OAAO,EAAM,EAAI,EAIzB,CAACC,EAAAA,YAAY,EAAO,EAAK,GAAK,CAChC,MAAO,GAIX,MAAO"}
+{"version":3,"file":"has-sub-object.cjs","names":["curry","isDeepEqual"],"sources":["../src/has-sub-object.ts"],"sourcesContent":["import type { IsNever, Simplify, Tagged } from 'type-fest';\nimport { curry } from './curry';\nimport { isDeepEqual } from './is-deep-equal';\n\n// eslint-disable-next-line ts/no-unused-vars -- We want to confine the typing to a specific symbol\ndeclare const HAS_SUB_OBJECT_BRAND: unique symbol;\n\ntype HasSubObjectGuard<T, S> = Simplify<\n  Tagged<S & T, typeof HAS_SUB_OBJECT_BRAND>\n>;\n\ntype HasSubObjectObjectValue<A, B> = Partial<{\n  [Key in keyof A & keyof B]: IsNever<A[Key] & B[Key]> extends true\n    ? B[Key]\n    : A[Key] | B[Key] extends object\n      ? HasSubObjectObjectValue<A[Key], B[Key]>\n      : A[Key] & B[Key] extends object\n        ? B[Key]\n        : A[Key];\n}> & {\n  [Key in\n  | Exclude<keyof A, keyof B>\n  | Exclude<keyof B, keyof A>]: Key extends keyof B ? B[Key] : never;\n};\n\ntype HasSubObjectData<\n  Data,\n  SubObject,\n  RData = Required<Data>,\n  RSubObject = Required<SubObject>,\n> = Partial<{\n  [Key in keyof RData & keyof RSubObject]: IsNever<\n    RData[Key] & RSubObject[Key]\n  > extends true\n    ? RSubObject[Key]\n    : RData[Key] | RSubObject[Key] extends object\n      ? HasSubObjectObjectValue<RData[Key], RSubObject[Key]>\n      : RData[Key] & RSubObject[Key] extends object\n        ? RSubObject[Key]\n        : RData[Key];\n}> & {\n  [Key in Exclude<keyof SubObject, keyof Data>]: SubObject[Key];\n};\n\ntype HasSubObjectSubObject<\n  SubObject,\n  Data,\n  RSubObject = Required<SubObject>,\n  RData = Required<Data>,\n> = Partial<{\n  [Key in keyof RData & keyof RSubObject]: IsNever<\n    RData[Key] & RSubObject[Key]\n  > extends true\n    ? RData[Key]\n    : RData[Key] | RSubObject[Key] extends object\n      ? HasSubObjectObjectValue<RSubObject[Key], RData[Key]>\n      : RData[Key] & RSubObject[Key] extends object\n        ? RData[Key]\n        : RSubObject[Key];\n}>\n& Record<Exclude<keyof SubObject, keyof Data>, never>;\n\n/**\n * Checks if `subObject` is a sub-object of `object`, which means for every\n * property and value in `subObject`, there's the same property in `object`\n * with an equal value. Equality is checked with `isDeepEqual`.\n *\n * @param data - The object to test.\n * @param subObject - The sub-object to test against.\n * @signature\n *    hasSubObject(data, subObject)\n * @example\n *    hasSubObject({ a: 1, b: 2, c: 3 }, { a: 1, c: 3 }) //=> true\n *    hasSubObject({ a: 1, b: 2, c: 3 }, { b: 4 }) //=> false\n *    hasSubObject({ a: 1, b: 2, c: 3 }, {}) //=> true\n * @dataFirst\n * @category Guard\n */\nexport function hasSubObject<\n  T extends object,\n  S extends HasSubObjectSubObject<S, T>,\n>(data: T, subObject: S): data is HasSubObjectGuard<T, S>;\n\n/**\n * Checks if `subObject` is a sub-object of `object`, which means for every\n * property and value in `subObject`, there's the same property in `object`\n * with an equal value. Equality is checked with `isDeepEqual`.\n *\n * @param subObject - The sub-object to test against.\n * @signature\n *    hasSubObject(subObject)(data)\n * @example\n *    hasSubObject({ a: 1, c: 3 })({ a: 1, b: 2, c: 3 }) //=> true\n *    hasSubObject({ b: 4 })({ a: 1, b: 2, c: 3 }) //=> false\n *    hasSubObject({})({ a: 1, b: 2, c: 3 }) //=> true\n * @dataLast\n * @category Guard\n */\nexport function hasSubObject<S extends object>(\n  subObject: S,\n): <T extends HasSubObjectData<T, S>>(\n  data: T,\n) => data is HasSubObjectGuard<T, S>;\n\nexport function hasSubObject(...args: ReadonlyArray<unknown>): unknown {\n  return curry(hasSubObjectImplementation, args);\n}\n\nfunction hasSubObjectImplementation<\n  T extends Record<PropertyKey, unknown>,\n  S extends Record<PropertyKey, unknown>,\n>(data: T, subObject: S): data is HasSubObjectGuard<T, S> {\n  for (const [key, value] of Object.entries(subObject)) {\n    if (!Object.hasOwn(data, key)) {\n      return false;\n    }\n\n    if (!isDeepEqual(value, data[key])) {\n      return false;\n    }\n  }\n\n  return true;\n}\n"],"mappings":"mIAwGA,SAAgB,EAAa,GAAG,EAAuC,CACrE,OAAOA,EAAAA,MAAM,EAA4B,CAAI,CAC/C,CAEA,SAAS,EAGP,EAAS,EAA+C,CACxD,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,CAAS,EAKjD,GAJI,CAAC,OAAO,OAAO,EAAM,CAAG,GAIxB,CAACC,EAAAA,YAAY,EAAO,EAAK,EAAI,EAC/B,MAAO,GAIX,MAAO,EACT"}

package/dist/has-sub-object.js.map

@@ -1 +1 @@
-{"version":3,"file":"has-sub-object.js","names":[],"sources":["../src/has-sub-object.ts"],"sourcesContent":["import type { Simplify, Tagged } from 'type-fest';\nimport { curry } from './curry';\nimport { isDeepEqual } from './is-deep-equal';\n\n// eslint-disable-next-line ts/no-unused-vars -- We want to confine the typing to a specific symbol\ndeclare const HAS_SUB_OBJECT_BRAND: unique symbol;\n\ntype HasSubObjectGuard<T, S> = Simplify<\n  Tagged<S & T, typeof HAS_SUB_OBJECT_BRAND>\n>;\n\ntype HasSubObjectObjectValue<A, B> = Partial<{\n  [Key in keyof A & keyof B]: A[Key] & B[Key] extends never\n    ? B[Key]\n    : A[Key] | B[Key] extends object\n      ? HasSubObjectObjectValue<A[Key], B[Key]>\n      : A[Key] & B[Key] extends object\n        ? B[Key]\n        : A[Key];\n}> & {\n  [Key in\n  | Exclude<keyof A, keyof B>\n  | Exclude<keyof B, keyof A>]: Key extends keyof B ? B[Key] : never;\n};\n\ntype HasSubObjectData<\n  Data,\n  SubObject,\n  RData = Required<Data>,\n  RSubObject = Required<SubObject>,\n> = Partial<{\n  [Key in keyof RData & keyof RSubObject]: RData[Key]\n    & RSubObject[Key] extends never\n    ? RSubObject[Key]\n    : RData[Key] | RSubObject[Key] extends object\n      ? HasSubObjectObjectValue<RData[Key], RSubObject[Key]>\n      : RData[Key] & RSubObject[Key] extends object\n        ? RSubObject[Key]\n        : RData[Key];\n}> & {\n  [Key in Exclude<keyof SubObject, keyof Data>]: SubObject[Key];\n};\n\ntype HasSubObjectSubObject<\n  SubObject,\n  Data,\n  RSubObject = Required<SubObject>,\n  RData = Required<Data>,\n> = Partial<{\n  [Key in keyof RData & keyof RSubObject]: RData[Key]\n    & RSubObject[Key] extends never\n    ? RData[Key]\n    : RData[Key] | RSubObject[Key] extends object\n      ? HasSubObjectObjectValue<RSubObject[Key], RData[Key]>\n      : RData[Key] & RSubObject[Key] extends object\n        ? RData[Key]\n        : RSubObject[Key];\n}>\n& Record<Exclude<keyof SubObject, keyof Data>, never>;\n\n/**\n * Checks if `subObject` is a sub-object of `object`, which means for every\n * property and value in `subObject`, there's the same property in `object`\n * with an equal value. Equality is checked with `isDeepEqual`.\n *\n * @param data - The object to test.\n * @param subObject - The sub-object to test against.\n * @signature\n *    hasSubObject(data, subObject)\n * @example\n *    hasSubObject({ a: 1, b: 2, c: 3 }, { a: 1, c: 3 }) //=> true\n *    hasSubObject({ a: 1, b: 2, c: 3 }, { b: 4 }) //=> false\n *    hasSubObject({ a: 1, b: 2, c: 3 }, {}) //=> true\n * @dataFirst\n * @category Guard\n */\nexport function hasSubObject<\n  T extends object,\n  S extends HasSubObjectSubObject<S, T>,\n>(data: T, subObject: S): data is HasSubObjectGuard<T, S>;\n\n/**\n * Checks if `subObject` is a sub-object of `object`, which means for every\n * property and value in `subObject`, there's the same property in `object`\n * with an equal value. Equality is checked with `isDeepEqual`.\n *\n * @param subObject - The sub-object to test against.\n * @signature\n *    hasSubObject(subObject)(data)\n * @example\n *    hasSubObject({ a: 1, c: 3 })({ a: 1, b: 2, c: 3 }) //=> true\n *    hasSubObject({ b: 4 })({ a: 1, b: 2, c: 3 }) //=> false\n *    hasSubObject({})({ a: 1, b: 2, c: 3 }) //=> true\n * @dataLast\n * @category Guard\n */\nexport function hasSubObject<S extends object>(\n  subObject: S,\n): <T extends HasSubObjectData<T, S>>(\n  data: T,\n) => data is HasSubObjectGuard<T, S>;\n\nexport function hasSubObject(...args: ReadonlyArray<unknown>): unknown {\n  return curry(hasSubObjectImplementation, args);\n}\n\nfunction hasSubObjectImplementation<\n  T extends Record<PropertyKey, unknown>,\n  S extends Record<PropertyKey, unknown>,\n>(data: T, subObject: S): data is HasSubObjectGuard<T, S> {\n  for (const [key, value] of Object.entries(subObject)) {\n    if (!Object.hasOwn(data, key)) {\n      return false;\n    }\n\n    if (!isDeepEqual(value, data[key])) {\n      return false;\n    }\n  }\n\n  return true;\n}\n"],"mappings":"oFAsGA,SAAgB,EAAa,GAAG,EAAuC,CACrE,OAAO,EAAM,EAA4B,EAAK,CAGhD,SAAS,EAGP,EAAS,EAA+C,CACxD,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAU,CAKlD,GAJI,CAAC,OAAO,OAAO,EAAM,EAAI,EAIzB,CAAC,EAAY,EAAO,EAAK,GAAK,CAChC,MAAO,GAIX,MAAO"}
+{"version":3,"file":"has-sub-object.js","names":[],"sources":["../src/has-sub-object.ts"],"sourcesContent":["import type { IsNever, Simplify, Tagged } from 'type-fest';\nimport { curry } from './curry';\nimport { isDeepEqual } from './is-deep-equal';\n\n// eslint-disable-next-line ts/no-unused-vars -- We want to confine the typing to a specific symbol\ndeclare const HAS_SUB_OBJECT_BRAND: unique symbol;\n\ntype HasSubObjectGuard<T, S> = Simplify<\n  Tagged<S & T, typeof HAS_SUB_OBJECT_BRAND>\n>;\n\ntype HasSubObjectObjectValue<A, B> = Partial<{\n  [Key in keyof A & keyof B]: IsNever<A[Key] & B[Key]> extends true\n    ? B[Key]\n    : A[Key] | B[Key] extends object\n      ? HasSubObjectObjectValue<A[Key], B[Key]>\n      : A[Key] & B[Key] extends object\n        ? B[Key]\n        : A[Key];\n}> & {\n  [Key in\n  | Exclude<keyof A, keyof B>\n  | Exclude<keyof B, keyof A>]: Key extends keyof B ? B[Key] : never;\n};\n\ntype HasSubObjectData<\n  Data,\n  SubObject,\n  RData = Required<Data>,\n  RSubObject = Required<SubObject>,\n> = Partial<{\n  [Key in keyof RData & keyof RSubObject]: IsNever<\n    RData[Key] & RSubObject[Key]\n  > extends true\n    ? RSubObject[Key]\n    : RData[Key] | RSubObject[Key] extends object\n      ? HasSubObjectObjectValue<RData[Key], RSubObject[Key]>\n      : RData[Key] & RSubObject[Key] extends object\n        ? RSubObject[Key]\n        : RData[Key];\n}> & {\n  [Key in Exclude<keyof SubObject, keyof Data>]: SubObject[Key];\n};\n\ntype HasSubObjectSubObject<\n  SubObject,\n  Data,\n  RSubObject = Required<SubObject>,\n  RData = Required<Data>,\n> = Partial<{\n  [Key in keyof RData & keyof RSubObject]: IsNever<\n    RData[Key] & RSubObject[Key]\n  > extends true\n    ? RData[Key]\n    : RData[Key] | RSubObject[Key] extends object\n      ? HasSubObjectObjectValue<RSubObject[Key], RData[Key]>\n      : RData[Key] & RSubObject[Key] extends object\n        ? RData[Key]\n        : RSubObject[Key];\n}>\n& Record<Exclude<keyof SubObject, keyof Data>, never>;\n\n/**\n * Checks if `subObject` is a sub-object of `object`, which means for every\n * property and value in `subObject`, there's the same property in `object`\n * with an equal value. Equality is checked with `isDeepEqual`.\n *\n * @param data - The object to test.\n * @param subObject - The sub-object to test against.\n * @signature\n *    hasSubObject(data, subObject)\n * @example\n *    hasSubObject({ a: 1, b: 2, c: 3 }, { a: 1, c: 3 }) //=> true\n *    hasSubObject({ a: 1, b: 2, c: 3 }, { b: 4 }) //=> false\n *    hasSubObject({ a: 1, b: 2, c: 3 }, {}) //=> true\n * @dataFirst\n * @category Guard\n */\nexport function hasSubObject<\n  T extends object,\n  S extends HasSubObjectSubObject<S, T>,\n>(data: T, subObject: S): data is HasSubObjectGuard<T, S>;\n\n/**\n * Checks if `subObject` is a sub-object of `object`, which means for every\n * property and value in `subObject`, there's the same property in `object`\n * with an equal value. Equality is checked with `isDeepEqual`.\n *\n * @param subObject - The sub-object to test against.\n * @signature\n *    hasSubObject(subObject)(data)\n * @example\n *    hasSubObject({ a: 1, c: 3 })({ a: 1, b: 2, c: 3 }) //=> true\n *    hasSubObject({ b: 4 })({ a: 1, b: 2, c: 3 }) //=> false\n *    hasSubObject({})({ a: 1, b: 2, c: 3 }) //=> true\n * @dataLast\n * @category Guard\n */\nexport function hasSubObject<S extends object>(\n  subObject: S,\n): <T extends HasSubObjectData<T, S>>(\n  data: T,\n) => data is HasSubObjectGuard<T, S>;\n\nexport function hasSubObject(...args: ReadonlyArray<unknown>): unknown {\n  return curry(hasSubObjectImplementation, args);\n}\n\nfunction hasSubObjectImplementation<\n  T extends Record<PropertyKey, unknown>,\n  S extends Record<PropertyKey, unknown>,\n>(data: T, subObject: S): data is HasSubObjectGuard<T, S> {\n  for (const [key, value] of Object.entries(subObject)) {\n    if (!Object.hasOwn(data, key)) {\n      return false;\n    }\n\n    if (!isDeepEqual(value, data[key])) {\n      return false;\n    }\n  }\n\n  return true;\n}\n"],"mappings":"oFAwGA,SAAgB,EAAa,GAAG,EAAuC,CACrE,OAAO,EAAM,EAA4B,CAAI,CAC/C,CAEA,SAAS,EAGP,EAAS,EAA+C,CACxD,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,CAAS,EAKjD,GAJI,CAAC,OAAO,OAAO,EAAM,CAAG,GAIxB,CAAC,EAAY,EAAO,EAAK,EAAI,EAC/B,MAAO,GAIX,MAAO,EACT"}

package/dist/heap-BK0Y5t1Y.cjs

@@ -0,0 +1,2 @@
+const e=require("./has-at-least.cjs"),t=require("./swap-in-place-CllcD0HG.cjs");function n(e,t){for(let n=Math.floor(e.length/2)-1;n>=0;n--)i(e,n,t)}function r(t,n,r){if(!e.hasAtLeast(t,1))return;let[a]=t;if(!(n(r,a)>=0))return t[0]=r,i(t,0,n),a}function i(e,n,r){let i=n;for(;i*2+1<e.length;){let n=i*2+1,a=r(e[i],e[n])<0?n:i,o=n+1;if(o<e.length&&r(e[a],e[o])<0&&(a=o),a===i)return;t.t(e,i,a),i=a}}Object.defineProperty(exports,"n",{enumerable:!0,get:function(){return n}}),Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return r}});
+//# sourceMappingURL=heap-BK0Y5t1Y.cjs.map

package/dist/{heap-C0zPQGC0.cjs.map → heap-BK0Y5t1Y.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"heap-C0zPQGC0.cjs","names":["hasAtLeast"],"sources":["../src/internal/heap.ts"],"sourcesContent":["/**\n * Heap related utilities.\n */\n\nimport type { CompareFunction } from './types/compare-function';\nimport { hasAtLeast } from '../has-at-least';\nimport { swapInPlace } from './swap-in-place';\n\n/**\n * Mutates an array into a \"max\"-heap based on `compareFn` so that for any `item` in the heap, `compareFn(heap[0], item) > 0`.\n *\n * @param heap - The array to be heapified. The array would be mutated!\n * @param compareFn - The comparator used to order items in the heap. Use the\n * same function in all calls mutating the same heap otherwise you'd get\n * unexpected results.\n */\nexport function heapify<T>(\n  heap: Array<T>,\n  compareFn: CompareFunction<T>,\n): void {\n  for (let i = Math.floor(heap.length / 2) - 1; i >= 0; i--) {\n    heapSiftDown(heap, i, compareFn);\n  }\n}\n\n/**\n * Insert an item into a heap if it's \"smaller\" (in regards to `compareFn`) than\n * the current head of the heap (which is the \"largest\" value in the heap). If\n * the item is inserted, the previous head of the heap is returned, otherwise\n * `undefined` is returned and the heap is unchanged.\n *\n * @param heap - A *mutable* array representing a heap (see `heapify`).\n * @param compareFn - The comparator used to order items in the heap. Use the.\n * @param item - The item to be inserted into the heap.\n * @returns `undefined` if the heap is unchanged, or the previous head of the\n * heap if the item was inserted.\n */\nexport function heapMaybeInsert<T>(\n  heap: Array<T>,\n  compareFn: CompareFunction<T>,\n  item: T,\n): T | undefined {\n  if (!hasAtLeast(heap, 1)) {\n    return undefined;\n  }\n\n  const [head] = heap;\n\n  if (compareFn(item, head) >= 0) {\n    // The item shouldn't be inserted into the heap, the heap is unchanged.\n    return undefined;\n  }\n\n  heap[0] = item;\n  heapSiftDown(heap, 0, compareFn);\n  return head;\n}\n\n/**\n * The main heap operation. Takes a `heap` and an `index` and sifts the item\n * down the heap until it reaches the correct position based on `compareFn`,\n * swapping other items in the process.\n */\nfunction heapSiftDown<T>(\n  heap: Array<T>,\n  index: number,\n  compareFn: CompareFunction<T>,\n): void {\n  let currentIndex = index;\n\n  // The loop continues while the currentIndex has children in the heap.\n  while (currentIndex * 2 + 1 < heap.length) {\n    const firstChildIndex = currentIndex * 2 + 1;\n\n    let swapIndex\n      = compareFn(heap[currentIndex]!, heap[firstChildIndex]!) < 0\n        ? // Is the parent \"smaller\" (in regards to `compareFn`) to its child?\n        firstChildIndex\n        : currentIndex;\n\n    const secondChildIndex = firstChildIndex + 1;\n    if (\n      secondChildIndex < heap.length\n      && compareFn(heap[swapIndex]!, heap[secondChildIndex]!) < 0\n    ) {\n      // Is there a second child? Is it the smallest of the three?\n      swapIndex = secondChildIndex;\n    }\n\n    if (swapIndex === currentIndex) {\n      // We assume the array is a heap and the existing order of items satisfies\n      // the compareFn so we can stop here.\n      return;\n    }\n\n    swapInPlace(heap, currentIndex, swapIndex);\n\n    currentIndex = swapIndex;\n  }\n}\n"],"mappings":"gFAgBA,SAAgB,EACd,EACA,EACM,CACN,IAAK,IAAI,EAAI,KAAK,MAAM,EAAK,OAAS,EAAE,CAAG,EAAG,GAAK,EAAG,IACpD,EAAa,EAAM,EAAG,EAAU,CAgBpC,SAAgB,EACd,EACA,EACA,EACe,CACf,GAAI,CAACA,EAAAA,WAAW,EAAM,EAAE,CACtB,OAGF,GAAM,CAAC,GAAQ,EAEX,OAAU,EAAM,EAAK,EAAI,GAO7B,MAFA,GAAK,GAAK,EACV,EAAa,EAAM,EAAG,EAAU,CACzB,EAQT,SAAS,EACP,EACA,EACA,EACM,CACN,IAAI,EAAe,EAGnB,KAAO,EAAe,EAAI,EAAI,EAAK,QAAQ,CACzC,IAAM,EAAkB,EAAe,EAAI,EAEvC,EACA,EAAU,EAAK,GAAgB,EAAK,GAAkB,CAAG,EAEzD,EACE,EAEA,EAAmB,EAAkB,EAS3C,GAPE,EAAmB,EAAK,QACrB,EAAU,EAAK,GAAa,EAAK,GAAmB,CAAG,IAG1D,EAAY,GAGV,IAAc,EAGhB,OAGF,EAAA,EAAY,EAAM,EAAc,EAAU,CAE1C,EAAe"}
+{"version":3,"file":"heap-BK0Y5t1Y.cjs","names":["hasAtLeast"],"sources":["../src/internal/heap.ts"],"sourcesContent":["/**\n * Heap related utilities.\n */\n\nimport type { CompareFunction } from './types/compare-function';\nimport { hasAtLeast } from '../has-at-least';\nimport { swapInPlace } from './swap-in-place';\n\n/**\n * Mutates an array into a \"max\"-heap based on `compareFn` so that for any `item` in the heap, `compareFn(heap[0], item) > 0`.\n *\n * @param heap - The array to be heapified. The array would be mutated!\n * @param compareFn - The comparator used to order items in the heap. Use the\n * same function in all calls mutating the same heap otherwise you'd get\n * unexpected results.\n */\nexport function heapify<T>(\n  heap: Array<T>,\n  compareFn: CompareFunction<T>,\n): void {\n  for (let i = Math.floor(heap.length / 2) - 1; i >= 0; i--) {\n    heapSiftDown(heap, i, compareFn);\n  }\n}\n\n/**\n * Insert an item into a heap if it's \"smaller\" (in regards to `compareFn`) than\n * the current head of the heap (which is the \"largest\" value in the heap). If\n * the item is inserted, the previous head of the heap is returned, otherwise\n * `undefined` is returned and the heap is unchanged.\n *\n * @param heap - A *mutable* array representing a heap (see `heapify`).\n * @param compareFn - The comparator used to order items in the heap. Use the.\n * @param item - The item to be inserted into the heap.\n * @returns `undefined` if the heap is unchanged, or the previous head of the\n * heap if the item was inserted.\n */\nexport function heapMaybeInsert<T>(\n  heap: Array<T>,\n  compareFn: CompareFunction<T>,\n  item: T,\n): T | undefined {\n  if (!hasAtLeast(heap, 1)) {\n    return undefined;\n  }\n\n  const [head] = heap;\n\n  if (compareFn(item, head) >= 0) {\n    // The item shouldn't be inserted into the heap, the heap is unchanged.\n    return undefined;\n  }\n\n  heap[0] = item;\n  heapSiftDown(heap, 0, compareFn);\n  return head;\n}\n\n/**\n * The main heap operation. Takes a `heap` and an `index` and sifts the item\n * down the heap until it reaches the correct position based on `compareFn`,\n * swapping other items in the process.\n */\nfunction heapSiftDown<T>(\n  heap: Array<T>,\n  index: number,\n  compareFn: CompareFunction<T>,\n): void {\n  let currentIndex = index;\n\n  // The loop continues while the currentIndex has children in the heap.\n  while (currentIndex * 2 + 1 < heap.length) {\n    const firstChildIndex = currentIndex * 2 + 1;\n\n    let swapIndex\n      = compareFn(heap[currentIndex]!, heap[firstChildIndex]!) < 0\n        ? // Is the parent \"smaller\" (in regards to `compareFn`) to its child?\n        firstChildIndex\n        : currentIndex;\n\n    const secondChildIndex = firstChildIndex + 1;\n    if (\n      secondChildIndex < heap.length\n      && compareFn(heap[swapIndex]!, heap[secondChildIndex]!) < 0\n    ) {\n      // Is there a second child? Is it the smallest of the three?\n      swapIndex = secondChildIndex;\n    }\n\n    if (swapIndex === currentIndex) {\n      // We assume the array is a heap and the existing order of items satisfies\n      // the compareFn so we can stop here.\n      return;\n    }\n\n    swapInPlace(heap, currentIndex, swapIndex);\n\n    currentIndex = swapIndex;\n  }\n}\n"],"mappings":"gFAgBA,SAAgB,EACd,EACA,EACM,CACN,IAAK,IAAI,EAAI,KAAK,MAAM,EAAK,OAAS,CAAC,EAAI,EAAG,GAAK,EAAG,IACpD,EAAa,EAAM,EAAG,CAAS,CAEnC,CAcA,SAAgB,EACd,EACA,EACA,EACe,CACf,GAAI,CAACA,EAAAA,WAAW,EAAM,CAAC,EACrB,OAGF,GAAM,CAAC,GAAQ,EAEX,OAAU,EAAM,CAAI,GAAK,GAO7B,MAFA,GAAK,GAAK,EACV,EAAa,EAAM,EAAG,CAAS,EACxB,CACT,CAOA,SAAS,EACP,EACA,EACA,EACM,CACN,IAAI,EAAe,EAGnB,KAAO,EAAe,EAAI,EAAI,EAAK,QAAQ,CACzC,IAAM,EAAkB,EAAe,EAAI,EAEvC,EACA,EAAU,EAAK,GAAgB,EAAK,EAAiB,EAAI,EAEzD,EACE,EAEA,EAAmB,EAAkB,EAS3C,GAPE,EAAmB,EAAK,QACrB,EAAU,EAAK,GAAa,EAAK,EAAkB,EAAI,IAG1D,EAAY,GAGV,IAAc,EAGhB,OAGF,EAAA,EAAY,EAAM,EAAc,CAAS,EAEzC,EAAe,CACjB,CACF"}

package/dist/{heap-M6D40vkc.js → heap-CL5ahv5n.js}

@@ -1,2 +1,2 @@
-import{hasAtLeast as e}from"./has-at-least.js";import{t}from"./swap-in-place-BzNaxwB3.js";function n(e,t){for(let n=Math.floor(e.length/2)-1;n>=0;n--)i(e,n,t)}function r(t,n,r){if(!e(t,1))return;let[a]=t;if(!(n(r,a)>=0))return t[0]=r,i(t,0,n),a}function i(e,n,r){let i=n;for(;i*2+1<e.length;){let n=i*2+1,a=r(e[i],e[n])<0?n:i,o=n+1;if(o<e.length&&r(e[a],e[o])<0&&(a=o),a===i)return;t(e,i,a),i=a}}export{n,r as t};
-//# sourceMappingURL=heap-M6D40vkc.js.map
+import{hasAtLeast as e}from"./has-at-least.js";import{t}from"./swap-in-place-ubtnp8en.js";function n(e,t){for(let n=Math.floor(e.length/2)-1;n>=0;n--)i(e,n,t)}function r(t,n,r){if(!e(t,1))return;let[a]=t;if(!(n(r,a)>=0))return t[0]=r,i(t,0,n),a}function i(e,n,r){let i=n;for(;i*2+1<e.length;){let n=i*2+1,a=r(e[i],e[n])<0?n:i,o=n+1;if(o<e.length&&r(e[a],e[o])<0&&(a=o),a===i)return;t(e,i,a),i=a}}export{n,r as t};
+//# sourceMappingURL=heap-CL5ahv5n.js.map

package/dist/{heap-M6D40vkc.js.map → heap-CL5ahv5n.js.map}

@@ -1 +1 @@
-{"version":3,"file":"heap-M6D40vkc.js","names":[],"sources":["../src/internal/heap.ts"],"sourcesContent":["/**\n * Heap related utilities.\n */\n\nimport type { CompareFunction } from './types/compare-function';\nimport { hasAtLeast } from '../has-at-least';\nimport { swapInPlace } from './swap-in-place';\n\n/**\n * Mutates an array into a \"max\"-heap based on `compareFn` so that for any `item` in the heap, `compareFn(heap[0], item) > 0`.\n *\n * @param heap - The array to be heapified. The array would be mutated!\n * @param compareFn - The comparator used to order items in the heap. Use the\n * same function in all calls mutating the same heap otherwise you'd get\n * unexpected results.\n */\nexport function heapify<T>(\n  heap: Array<T>,\n  compareFn: CompareFunction<T>,\n): void {\n  for (let i = Math.floor(heap.length / 2) - 1; i >= 0; i--) {\n    heapSiftDown(heap, i, compareFn);\n  }\n}\n\n/**\n * Insert an item into a heap if it's \"smaller\" (in regards to `compareFn`) than\n * the current head of the heap (which is the \"largest\" value in the heap). If\n * the item is inserted, the previous head of the heap is returned, otherwise\n * `undefined` is returned and the heap is unchanged.\n *\n * @param heap - A *mutable* array representing a heap (see `heapify`).\n * @param compareFn - The comparator used to order items in the heap. Use the.\n * @param item - The item to be inserted into the heap.\n * @returns `undefined` if the heap is unchanged, or the previous head of the\n * heap if the item was inserted.\n */\nexport function heapMaybeInsert<T>(\n  heap: Array<T>,\n  compareFn: CompareFunction<T>,\n  item: T,\n): T | undefined {\n  if (!hasAtLeast(heap, 1)) {\n    return undefined;\n  }\n\n  const [head] = heap;\n\n  if (compareFn(item, head) >= 0) {\n    // The item shouldn't be inserted into the heap, the heap is unchanged.\n    return undefined;\n  }\n\n  heap[0] = item;\n  heapSiftDown(heap, 0, compareFn);\n  return head;\n}\n\n/**\n * The main heap operation. Takes a `heap` and an `index` and sifts the item\n * down the heap until it reaches the correct position based on `compareFn`,\n * swapping other items in the process.\n */\nfunction heapSiftDown<T>(\n  heap: Array<T>,\n  index: number,\n  compareFn: CompareFunction<T>,\n): void {\n  let currentIndex = index;\n\n  // The loop continues while the currentIndex has children in the heap.\n  while (currentIndex * 2 + 1 < heap.length) {\n    const firstChildIndex = currentIndex * 2 + 1;\n\n    let swapIndex\n      = compareFn(heap[currentIndex]!, heap[firstChildIndex]!) < 0\n        ? // Is the parent \"smaller\" (in regards to `compareFn`) to its child?\n        firstChildIndex\n        : currentIndex;\n\n    const secondChildIndex = firstChildIndex + 1;\n    if (\n      secondChildIndex < heap.length\n      && compareFn(heap[swapIndex]!, heap[secondChildIndex]!) < 0\n    ) {\n      // Is there a second child? Is it the smallest of the three?\n      swapIndex = secondChildIndex;\n    }\n\n    if (swapIndex === currentIndex) {\n      // We assume the array is a heap and the existing order of items satisfies\n      // the compareFn so we can stop here.\n      return;\n    }\n\n    swapInPlace(heap, currentIndex, swapIndex);\n\n    currentIndex = swapIndex;\n  }\n}\n"],"mappings":"0FAgBA,SAAgB,EACd,EACA,EACM,CACN,IAAK,IAAI,EAAI,KAAK,MAAM,EAAK,OAAS,EAAE,CAAG,EAAG,GAAK,EAAG,IACpD,EAAa,EAAM,EAAG,EAAU,CAgBpC,SAAgB,EACd,EACA,EACA,EACe,CACf,GAAI,CAAC,EAAW,EAAM,EAAE,CACtB,OAGF,GAAM,CAAC,GAAQ,EAEX,OAAU,EAAM,EAAK,EAAI,GAO7B,MAFA,GAAK,GAAK,EACV,EAAa,EAAM,EAAG,EAAU,CACzB,EAQT,SAAS,EACP,EACA,EACA,EACM,CACN,IAAI,EAAe,EAGnB,KAAO,EAAe,EAAI,EAAI,EAAK,QAAQ,CACzC,IAAM,EAAkB,EAAe,EAAI,EAEvC,EACA,EAAU,EAAK,GAAgB,EAAK,GAAkB,CAAG,EAEzD,EACE,EAEA,EAAmB,EAAkB,EAS3C,GAPE,EAAmB,EAAK,QACrB,EAAU,EAAK,GAAa,EAAK,GAAmB,CAAG,IAG1D,EAAY,GAGV,IAAc,EAGhB,OAGF,EAAY,EAAM,EAAc,EAAU,CAE1C,EAAe"}
+{"version":3,"file":"heap-CL5ahv5n.js","names":[],"sources":["../src/internal/heap.ts"],"sourcesContent":["/**\n * Heap related utilities.\n */\n\nimport type { CompareFunction } from './types/compare-function';\nimport { hasAtLeast } from '../has-at-least';\nimport { swapInPlace } from './swap-in-place';\n\n/**\n * Mutates an array into a \"max\"-heap based on `compareFn` so that for any `item` in the heap, `compareFn(heap[0], item) > 0`.\n *\n * @param heap - The array to be heapified. The array would be mutated!\n * @param compareFn - The comparator used to order items in the heap. Use the\n * same function in all calls mutating the same heap otherwise you'd get\n * unexpected results.\n */\nexport function heapify<T>(\n  heap: Array<T>,\n  compareFn: CompareFunction<T>,\n): void {\n  for (let i = Math.floor(heap.length / 2) - 1; i >= 0; i--) {\n    heapSiftDown(heap, i, compareFn);\n  }\n}\n\n/**\n * Insert an item into a heap if it's \"smaller\" (in regards to `compareFn`) than\n * the current head of the heap (which is the \"largest\" value in the heap). If\n * the item is inserted, the previous head of the heap is returned, otherwise\n * `undefined` is returned and the heap is unchanged.\n *\n * @param heap - A *mutable* array representing a heap (see `heapify`).\n * @param compareFn - The comparator used to order items in the heap. Use the.\n * @param item - The item to be inserted into the heap.\n * @returns `undefined` if the heap is unchanged, or the previous head of the\n * heap if the item was inserted.\n */\nexport function heapMaybeInsert<T>(\n  heap: Array<T>,\n  compareFn: CompareFunction<T>,\n  item: T,\n): T | undefined {\n  if (!hasAtLeast(heap, 1)) {\n    return undefined;\n  }\n\n  const [head] = heap;\n\n  if (compareFn(item, head) >= 0) {\n    // The item shouldn't be inserted into the heap, the heap is unchanged.\n    return undefined;\n  }\n\n  heap[0] = item;\n  heapSiftDown(heap, 0, compareFn);\n  return head;\n}\n\n/**\n * The main heap operation. Takes a `heap` and an `index` and sifts the item\n * down the heap until it reaches the correct position based on `compareFn`,\n * swapping other items in the process.\n */\nfunction heapSiftDown<T>(\n  heap: Array<T>,\n  index: number,\n  compareFn: CompareFunction<T>,\n): void {\n  let currentIndex = index;\n\n  // The loop continues while the currentIndex has children in the heap.\n  while (currentIndex * 2 + 1 < heap.length) {\n    const firstChildIndex = currentIndex * 2 + 1;\n\n    let swapIndex\n      = compareFn(heap[currentIndex]!, heap[firstChildIndex]!) < 0\n        ? // Is the parent \"smaller\" (in regards to `compareFn`) to its child?\n        firstChildIndex\n        : currentIndex;\n\n    const secondChildIndex = firstChildIndex + 1;\n    if (\n      secondChildIndex < heap.length\n      && compareFn(heap[swapIndex]!, heap[secondChildIndex]!) < 0\n    ) {\n      // Is there a second child? Is it the smallest of the three?\n      swapIndex = secondChildIndex;\n    }\n\n    if (swapIndex === currentIndex) {\n      // We assume the array is a heap and the existing order of items satisfies\n      // the compareFn so we can stop here.\n      return;\n    }\n\n    swapInPlace(heap, currentIndex, swapIndex);\n\n    currentIndex = swapIndex;\n  }\n}\n"],"mappings":"0FAgBA,SAAgB,EACd,EACA,EACM,CACN,IAAK,IAAI,EAAI,KAAK,MAAM,EAAK,OAAS,CAAC,EAAI,EAAG,GAAK,EAAG,IACpD,EAAa,EAAM,EAAG,CAAS,CAEnC,CAcA,SAAgB,EACd,EACA,EACA,EACe,CACf,GAAI,CAAC,EAAW,EAAM,CAAC,EACrB,OAGF,GAAM,CAAC,GAAQ,EAEX,OAAU,EAAM,CAAI,GAAK,GAO7B,MAFA,GAAK,GAAK,EACV,EAAa,EAAM,EAAG,CAAS,EACxB,CACT,CAOA,SAAS,EACP,EACA,EACA,EACM,CACN,IAAI,EAAe,EAGnB,KAAO,EAAe,EAAI,EAAI,EAAK,QAAQ,CACzC,IAAM,EAAkB,EAAe,EAAI,EAEvC,EACA,EAAU,EAAK,GAAgB,EAAK,EAAiB,EAAI,EAEzD,EACE,EAEA,EAAmB,EAAkB,EAS3C,GAPE,EAAmB,EAAK,QACrB,EAAU,EAAK,GAAa,EAAK,EAAkB,EAAI,IAG1D,EAAY,GAGV,IAAc,EAGhB,OAGF,EAAY,EAAM,EAAc,CAAS,EAEzC,EAAe,CACjB,CACF"}

package/dist/human-readable-file-size.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"human-readable-file-size.cjs","names":[],"sources":["../src/human-readable-file-size.ts"],"sourcesContent":["/**\n * Returns human readable file size.\n *\n * @param bytes the file size in bytes\n * @param base the base (1000 or 1024)\n * @signature\n *  P.humanReadableFileSize(bytes, base)\n * @example\n *  P.humanReadableFileSize(1000); // => '1.0 kB'\n *  P.humanReadableFileSize(2097152, 1024); // => '2.0 Mib'\n * @category String\n */\nexport function humanReadableFileSize(bytes: number, base: 1000 | 1024 = 1000): string {\n  if (bytes < base) {\n    return `${bytes} B`;\n  }\n\n  const prefix = base === 1024 ? ['Ki', 'Mi', 'Gi'] : ['k', 'M', 'G'];\n  let unit = -1;\n\n  while (Math.abs(bytes) >= base && unit < prefix.length - 1) {\n    bytes /= base;\n    ++unit;\n  }\n\n  return `${bytes.toFixed(1)} ${prefix[unit]}B`;\n}\n"],"mappings":"mEAYA,SAAgB,EAAsB,EAAe,EAAoB,IAAc,CACrF,GAAI,EAAQ,EACV,MAAO,GAAG,EAAM,IAGlB,IAAM,EAAS,IAAS,KAAO,CAAC,KAAM,KAAM,KAAK,CAAG,CAAC,IAAK,IAAK,IAAI,CAC/D,EAAO,GAEX,KAAO,KAAK,IAAI,EAAM,EAAI,GAAQ,EAAO,EAAO,OAAS,GACvD,GAAS,EACT,EAAE,EAGJ,MAAO,GAAG,EAAM,QAAQ,EAAE,CAAC,GAAG,EAAO,GAAM"}
+{"version":3,"file":"human-readable-file-size.cjs","names":[],"sources":["../src/human-readable-file-size.ts"],"sourcesContent":["/**\n * Returns human readable file size.\n *\n * @param bytes the file size in bytes\n * @param base the base (1000 or 1024)\n * @signature\n *  P.humanReadableFileSize(bytes, base)\n * @example\n *  P.humanReadableFileSize(1000); // => '1.0 kB'\n *  P.humanReadableFileSize(2097152, 1024); // => '2.0 Mib'\n * @category String\n */\nexport function humanReadableFileSize(bytes: number, base: 1000 | 1024 = 1000): string {\n  if (bytes < base) {\n    return `${bytes} B`;\n  }\n\n  const prefix = base === 1024 ? ['Ki', 'Mi', 'Gi'] : ['k', 'M', 'G'];\n  let unit = -1;\n\n  while (Math.abs(bytes) >= base && unit < prefix.length - 1) {\n    bytes /= base;\n    ++unit;\n  }\n\n  return `${bytes.toFixed(1)} ${prefix[unit]}B`;\n}\n"],"mappings":"mEAYA,SAAgB,EAAsB,EAAe,EAAoB,IAAc,CACrF,GAAI,EAAQ,EACV,MAAO,GAAG,EAAM,IAGlB,IAAM,EAAS,IAAS,KAAO,CAAC,KAAM,KAAM,IAAI,EAAI,CAAC,IAAK,IAAK,GAAG,EAC9D,EAAO,GAEX,KAAO,KAAK,IAAI,CAAK,GAAK,GAAQ,EAAO,EAAO,OAAS,GACvD,GAAS,EACT,EAAE,EAGJ,MAAO,GAAG,EAAM,QAAQ,CAAC,EAAE,GAAG,EAAO,GAAM,EAC7C"}

package/dist/human-readable-file-size.js.map

@@ -1 +1 @@
-{"version":3,"file":"human-readable-file-size.js","names":[],"sources":["../src/human-readable-file-size.ts"],"sourcesContent":["/**\n * Returns human readable file size.\n *\n * @param bytes the file size in bytes\n * @param base the base (1000 or 1024)\n * @signature\n *  P.humanReadableFileSize(bytes, base)\n * @example\n *  P.humanReadableFileSize(1000); // => '1.0 kB'\n *  P.humanReadableFileSize(2097152, 1024); // => '2.0 Mib'\n * @category String\n */\nexport function humanReadableFileSize(bytes: number, base: 1000 | 1024 = 1000): string {\n  if (bytes < base) {\n    return `${bytes} B`;\n  }\n\n  const prefix = base === 1024 ? ['Ki', 'Mi', 'Gi'] : ['k', 'M', 'G'];\n  let unit = -1;\n\n  while (Math.abs(bytes) >= base && unit < prefix.length - 1) {\n    bytes /= base;\n    ++unit;\n  }\n\n  return `${bytes.toFixed(1)} ${prefix[unit]}B`;\n}\n"],"mappings":"AAYA,SAAgB,EAAsB,EAAe,EAAoB,IAAc,CACrF,GAAI,EAAQ,EACV,MAAO,GAAG,EAAM,IAGlB,IAAM,EAAS,IAAS,KAAO,CAAC,KAAM,KAAM,KAAK,CAAG,CAAC,IAAK,IAAK,IAAI,CAC/D,EAAO,GAEX,KAAO,KAAK,IAAI,EAAM,EAAI,GAAQ,EAAO,EAAO,OAAS,GACvD,GAAS,EACT,EAAE,EAGJ,MAAO,GAAG,EAAM,QAAQ,EAAE,CAAC,GAAG,EAAO,GAAM"}
+{"version":3,"file":"human-readable-file-size.js","names":[],"sources":["../src/human-readable-file-size.ts"],"sourcesContent":["/**\n * Returns human readable file size.\n *\n * @param bytes the file size in bytes\n * @param base the base (1000 or 1024)\n * @signature\n *  P.humanReadableFileSize(bytes, base)\n * @example\n *  P.humanReadableFileSize(1000); // => '1.0 kB'\n *  P.humanReadableFileSize(2097152, 1024); // => '2.0 Mib'\n * @category String\n */\nexport function humanReadableFileSize(bytes: number, base: 1000 | 1024 = 1000): string {\n  if (bytes < base) {\n    return `${bytes} B`;\n  }\n\n  const prefix = base === 1024 ? ['Ki', 'Mi', 'Gi'] : ['k', 'M', 'G'];\n  let unit = -1;\n\n  while (Math.abs(bytes) >= base && unit < prefix.length - 1) {\n    bytes /= base;\n    ++unit;\n  }\n\n  return `${bytes.toFixed(1)} ${prefix[unit]}B`;\n}\n"],"mappings":"AAYA,SAAgB,EAAsB,EAAe,EAAoB,IAAc,CACrF,GAAI,EAAQ,EACV,MAAO,GAAG,EAAM,IAGlB,IAAM,EAAS,IAAS,KAAO,CAAC,KAAM,KAAM,IAAI,EAAI,CAAC,IAAK,IAAK,GAAG,EAC9D,EAAO,GAEX,KAAO,KAAK,IAAI,CAAK,GAAK,GAAQ,EAAO,EAAO,OAAS,GACvD,GAAS,EACT,EAAE,EAGJ,MAAO,GAAG,EAAM,QAAQ,CAAC,EAAE,GAAG,EAAO,GAAM,EAC7C"}

package/dist/identity.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"identity.cjs","names":[],"sources":["../src/identity.ts"],"sourcesContent":["// eslint-disable-next-line ts/no-explicit-any -- Accept functions with more than a single parameter too, we use `any` because that catches all possible cases.\ntype IdentityFunction = <T>(firstParameter: T, ...rest: any) => T;\n\nconst identityImplementation: IdentityFunction = (firstParameter) =>\n  firstParameter;\n\n/**\n * A function that returns the first argument passed to it.\n *\n * Notice that this is a dataLast impl where the function needs to be invoked\n * to get the \"do nothing\" function.\n *\n * See also:\n * `doNothing` - A function that doesn't return anything.\n * `constant` - A function that ignores the input arguments and returns the same value on every invocation.\n *\n * @signature\n *    identity();\n * @example\n *    map([1,2,3], identity()); // => [1,2,3]\n * @category Function\n */\nexport function identity(): IdentityFunction {\n  // Notice that the exported identity function is just the \"factory\" for the\n  // identity function. We do it this way so that all \"Function\" utilities have\n  // a similar API where the function is called, and not just used \"headless\".\n  // e.g. `identity()` and not `identity`, just like the API for `constant(1)`.\n  return identityImplementation;\n}\n"],"mappings":"mEAGA,MAAM,EAA4C,GAChD,EAkBF,SAAgB,GAA6B,CAK3C,OAAO"}
+{"version":3,"file":"identity.cjs","names":[],"sources":["../src/identity.ts"],"sourcesContent":["// eslint-disable-next-line ts/no-explicit-any -- Accept functions with more than a single parameter too, we use `any` because that catches all possible cases.\ntype IdentityFunction = <T>(firstParameter: T, ...rest: any) => T;\n\nconst identityImplementation: IdentityFunction = (firstParameter) =>\n  firstParameter;\n\n/**\n * A function that returns the first argument passed to it.\n *\n * Notice that this is a dataLast impl where the function needs to be invoked\n * to get the \"do nothing\" function.\n *\n * See also:\n * `doNothing` - A function that doesn't return anything.\n * `constant` - A function that ignores the input arguments and returns the same value on every invocation.\n *\n * @signature\n *    identity();\n * @example\n *    map([1,2,3], identity()); // => [1,2,3]\n * @category Function\n */\nexport function identity(): IdentityFunction {\n  // Notice that the exported identity function is just the \"factory\" for the\n  // identity function. We do it this way so that all \"Function\" utilities have\n  // a similar API where the function is called, and not just used \"headless\".\n  // e.g. `identity()` and not `identity`, just like the API for `constant(1)`.\n  return identityImplementation;\n}\n"],"mappings":"mEAGA,MAAM,EAA4C,GAChD,EAkBF,SAAgB,GAA6B,CAK3C,OAAO,CACT"}

package/dist/identity.js.map

@@ -1 +1 @@
-{"version":3,"file":"identity.js","names":[],"sources":["../src/identity.ts"],"sourcesContent":["// eslint-disable-next-line ts/no-explicit-any -- Accept functions with more than a single parameter too, we use `any` because that catches all possible cases.\ntype IdentityFunction = <T>(firstParameter: T, ...rest: any) => T;\n\nconst identityImplementation: IdentityFunction = (firstParameter) =>\n  firstParameter;\n\n/**\n * A function that returns the first argument passed to it.\n *\n * Notice that this is a dataLast impl where the function needs to be invoked\n * to get the \"do nothing\" function.\n *\n * See also:\n * `doNothing` - A function that doesn't return anything.\n * `constant` - A function that ignores the input arguments and returns the same value on every invocation.\n *\n * @signature\n *    identity();\n * @example\n *    map([1,2,3], identity()); // => [1,2,3]\n * @category Function\n */\nexport function identity(): IdentityFunction {\n  // Notice that the exported identity function is just the \"factory\" for the\n  // identity function. We do it this way so that all \"Function\" utilities have\n  // a similar API where the function is called, and not just used \"headless\".\n  // e.g. `identity()` and not `identity`, just like the API for `constant(1)`.\n  return identityImplementation;\n}\n"],"mappings":"AAGA,MAAM,EAA4C,GAChD,EAkBF,SAAgB,GAA6B,CAK3C,OAAO"}
+{"version":3,"file":"identity.js","names":[],"sources":["../src/identity.ts"],"sourcesContent":["// eslint-disable-next-line ts/no-explicit-any -- Accept functions with more than a single parameter too, we use `any` because that catches all possible cases.\ntype IdentityFunction = <T>(firstParameter: T, ...rest: any) => T;\n\nconst identityImplementation: IdentityFunction = (firstParameter) =>\n  firstParameter;\n\n/**\n * A function that returns the first argument passed to it.\n *\n * Notice that this is a dataLast impl where the function needs to be invoked\n * to get the \"do nothing\" function.\n *\n * See also:\n * `doNothing` - A function that doesn't return anything.\n * `constant` - A function that ignores the input arguments and returns the same value on every invocation.\n *\n * @signature\n *    identity();\n * @example\n *    map([1,2,3], identity()); // => [1,2,3]\n * @category Function\n */\nexport function identity(): IdentityFunction {\n  // Notice that the exported identity function is just the \"factory\" for the\n  // identity function. We do it this way so that all \"Function\" utilities have\n  // a similar API where the function is called, and not just used \"headless\".\n  // e.g. `identity()` and not `identity`, just like the API for `constant(1)`.\n  return identityImplementation;\n}\n"],"mappings":"AAGA,MAAM,EAA4C,GAChD,EAkBF,SAAgB,GAA6B,CAK3C,OAAO,CACT"}

package/dist/index-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){let n={};for(let[r,i]of e.entries()){let a=t(i,r,e);n[a]=i}return n}exports.indexBy=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=t(i,r,e);n[a]=i}return n}exports.indexBy=t;
 //# sourceMappingURL=index-by.cjs.map

package/dist/index-by.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index-by.cjs","names":["curry"],"sources":["../src/index-by.ts"],"sourcesContent":["import type { BoundedPartial } from './internal/types/bounded-partial';\nimport { curry } from './curry';\n\n/**\n * Converts a list of objects into an object indexing the objects by the given\n * key.\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 values.\n * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.\n * `fromEntries` - Builds an object from an array of key-value pairs.\n * Refer to the docs for more details.\n *\n * @param data - The array.\n * @param mapper - The indexing function.\n * @signature\n *    indexBy(array, fn)\n * @example\n *    indexBy(['one', 'two', 'three'], x => x.length) // => {3: 'two', 5: 'three'}\n * @dataFirst\n * @category Array\n */\nexport function indexBy<T, K extends PropertyKey>(\n  data: ReadonlyArray<T>,\n  mapper: (item: T, index: number, data: ReadonlyArray<T>) => K,\n): BoundedPartial<Record<K, T>>;\n\n/**\n * Converts a list of objects into an object indexing the objects by the given\n * key.\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 values.\n * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.\n * `fromEntries` - Builds an object from an array of key-value pairs.\n * Refer to the docs for more details.\n *\n * @param mapper - The indexing function.\n * @signature\n *    indexBy(fn)(array)\n * @example\n *    pipe(\n *      ['one', 'two', 'three'],\n *      indexBy(x => x.length)\n *    ) // => {3: 'two', 5: 'three'}\n * @dataLast\n * @category Array\n */\nexport function indexBy<T, K extends PropertyKey>(\n  mapper: (item: T, index: number, data: ReadonlyArray<T>) => K,\n): (data: ReadonlyArray<T>) => BoundedPartial<Record<K, T>>;\n\nexport function indexBy(...args: ReadonlyArray<unknown>): unknown {\n  return curry(indexByImplementation, args);\n}\n\nfunction indexByImplementation<T, K extends PropertyKey>(\n  data: ReadonlyArray<T>,\n  mapper: (item: T, index: number, data: ReadonlyArray<T>) => K,\n): BoundedPartial<Record<K, T>> {\n  const out: Partial<Record<K, T>> = {};\n\n  for (const [index, item] of data.entries()) {\n    const key = mapper(item, index, data);\n    out[key] = item;\n  }\n\n  return out as BoundedPartial<Record<K, T>>;\n}\n"],"mappings":"kGAsDA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAOA,EAAAA,MAAM,EAAuB,EAAK,CAG3C,SAAS,EACP,EACA,EAC8B,CAC9B,IAAM,EAA6B,EAAE,CAErC,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,SAAS,CAAE,CAC1C,IAAM,EAAM,EAAO,EAAM,EAAO,EAAK,CACrC,EAAI,GAAO,EAGb,OAAO"}
+{"version":3,"file":"index-by.cjs","names":["curry"],"sources":["../src/index-by.ts"],"sourcesContent":["import type { BoundedPartial } from './internal/types/bounded-partial';\nimport { curry } from './curry';\n\n/**\n * Converts a list of objects into an object indexing the objects by the given\n * key.\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 values.\n * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.\n * `fromEntries` - Builds an object from an array of key-value pairs.\n * Refer to the docs for more details.\n *\n * @param data - The array.\n * @param mapper - The indexing function.\n * @signature\n *    indexBy(array, fn)\n * @example\n *    indexBy(['one', 'two', 'three'], x => x.length) // => {3: 'two', 5: 'three'}\n * @dataFirst\n * @category Array\n */\nexport function indexBy<T, K extends PropertyKey>(\n  data: ReadonlyArray<T>,\n  mapper: (item: T, index: number, data: ReadonlyArray<T>) => K,\n): BoundedPartial<Record<K, T>>;\n\n/**\n * Converts a list of objects into an object indexing the objects by the given\n * key.\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 values.\n * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.\n * `fromEntries` - Builds an object from an array of key-value pairs.\n * Refer to the docs for more details.\n *\n * @param mapper - The indexing function.\n * @signature\n *    indexBy(fn)(array)\n * @example\n *    pipe(\n *      ['one', 'two', 'three'],\n *      indexBy(x => x.length)\n *    ) // => {3: 'two', 5: 'three'}\n * @dataLast\n * @category Array\n */\nexport function indexBy<T, K extends PropertyKey>(\n  mapper: (item: T, index: number, data: ReadonlyArray<T>) => K,\n): (data: ReadonlyArray<T>) => BoundedPartial<Record<K, T>>;\n\nexport function indexBy(...args: ReadonlyArray<unknown>): unknown {\n  return curry(indexByImplementation, args);\n}\n\nfunction indexByImplementation<T, K extends PropertyKey>(\n  data: ReadonlyArray<T>,\n  mapper: (item: T, index: number, data: ReadonlyArray<T>) => K,\n): BoundedPartial<Record<K, T>> {\n  const out: Partial<Record<K, T>> = {};\n\n  for (const [index, item] of data.entries()) {\n    const key = mapper(item, index, data);\n    out[key] = item;\n  }\n\n  return out as BoundedPartial<Record<K, T>>;\n}\n"],"mappings":"kGAsDA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAOA,EAAAA,MAAM,EAAuB,CAAI,CAC1C,CAEA,SAAS,EACP,EACA,EAC8B,CAC9B,IAAM,EAA6B,CAAC,EAEpC,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,QAAQ,EAAG,CAC1C,IAAM,EAAM,EAAO,EAAM,EAAO,CAAI,EACpC,EAAI,GAAO,CACb,CAEA,OAAO,CACT"}

package/dist/index-by.js.map

@@ -1 +1 @@
-{"version":3,"file":"index-by.js","names":[],"sources":["../src/index-by.ts"],"sourcesContent":["import type { BoundedPartial } from './internal/types/bounded-partial';\nimport { curry } from './curry';\n\n/**\n * Converts a list of objects into an object indexing the objects by the given\n * key.\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 values.\n * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.\n * `fromEntries` - Builds an object from an array of key-value pairs.\n * Refer to the docs for more details.\n *\n * @param data - The array.\n * @param mapper - The indexing function.\n * @signature\n *    indexBy(array, fn)\n * @example\n *    indexBy(['one', 'two', 'three'], x => x.length) // => {3: 'two', 5: 'three'}\n * @dataFirst\n * @category Array\n */\nexport function indexBy<T, K extends PropertyKey>(\n  data: ReadonlyArray<T>,\n  mapper: (item: T, index: number, data: ReadonlyArray<T>) => K,\n): BoundedPartial<Record<K, T>>;\n\n/**\n * Converts a list of objects into an object indexing the objects by the given\n * key.\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 values.\n * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.\n * `fromEntries` - Builds an object from an array of key-value pairs.\n * Refer to the docs for more details.\n *\n * @param mapper - The indexing function.\n * @signature\n *    indexBy(fn)(array)\n * @example\n *    pipe(\n *      ['one', 'two', 'three'],\n *      indexBy(x => x.length)\n *    ) // => {3: 'two', 5: 'three'}\n * @dataLast\n * @category Array\n */\nexport function indexBy<T, K extends PropertyKey>(\n  mapper: (item: T, index: number, data: ReadonlyArray<T>) => K,\n): (data: ReadonlyArray<T>) => BoundedPartial<Record<K, T>>;\n\nexport function indexBy(...args: ReadonlyArray<unknown>): unknown {\n  return curry(indexByImplementation, args);\n}\n\nfunction indexByImplementation<T, K extends PropertyKey>(\n  data: ReadonlyArray<T>,\n  mapper: (item: T, index: number, data: ReadonlyArray<T>) => K,\n): BoundedPartial<Record<K, T>> {\n  const out: Partial<Record<K, T>> = {};\n\n  for (const [index, item] of data.entries()) {\n    const key = mapper(item, index, data);\n    out[key] = item;\n  }\n\n  return out as BoundedPartial<Record<K, T>>;\n}\n"],"mappings":"mCAsDA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAK,CAG3C,SAAS,EACP,EACA,EAC8B,CAC9B,IAAM,EAA6B,EAAE,CAErC,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,SAAS,CAAE,CAC1C,IAAM,EAAM,EAAO,EAAM,EAAO,EAAK,CACrC,EAAI,GAAO,EAGb,OAAO"}
+{"version":3,"file":"index-by.js","names":[],"sources":["../src/index-by.ts"],"sourcesContent":["import type { BoundedPartial } from './internal/types/bounded-partial';\nimport { curry } from './curry';\n\n/**\n * Converts a list of objects into an object indexing the objects by the given\n * key.\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 values.\n * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.\n * `fromEntries` - Builds an object from an array of key-value pairs.\n * Refer to the docs for more details.\n *\n * @param data - The array.\n * @param mapper - The indexing function.\n * @signature\n *    indexBy(array, fn)\n * @example\n *    indexBy(['one', 'two', 'three'], x => x.length) // => {3: 'two', 5: 'three'}\n * @dataFirst\n * @category Array\n */\nexport function indexBy<T, K extends PropertyKey>(\n  data: ReadonlyArray<T>,\n  mapper: (item: T, index: number, data: ReadonlyArray<T>) => K,\n): BoundedPartial<Record<K, T>>;\n\n/**\n * Converts a list of objects into an object indexing the objects by the given\n * key.\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 values.\n * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.\n * `fromEntries` - Builds an object from an array of key-value pairs.\n * Refer to the docs for more details.\n *\n * @param mapper - The indexing function.\n * @signature\n *    indexBy(fn)(array)\n * @example\n *    pipe(\n *      ['one', 'two', 'three'],\n *      indexBy(x => x.length)\n *    ) // => {3: 'two', 5: 'three'}\n * @dataLast\n * @category Array\n */\nexport function indexBy<T, K extends PropertyKey>(\n  mapper: (item: T, index: number, data: ReadonlyArray<T>) => K,\n): (data: ReadonlyArray<T>) => BoundedPartial<Record<K, T>>;\n\nexport function indexBy(...args: ReadonlyArray<unknown>): unknown {\n  return curry(indexByImplementation, args);\n}\n\nfunction indexByImplementation<T, K extends PropertyKey>(\n  data: ReadonlyArray<T>,\n  mapper: (item: T, index: number, data: ReadonlyArray<T>) => K,\n): BoundedPartial<Record<K, T>> {\n  const out: Partial<Record<K, T>> = {};\n\n  for (const [index, item] of data.entries()) {\n    const key = mapper(item, index, data);\n    out[key] = item;\n  }\n\n  return out as BoundedPartial<Record<K, T>>;\n}\n"],"mappings":"mCAsDA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,CAAI,CAC1C,CAEA,SAAS,EACP,EACA,EAC8B,CAC9B,IAAM,EAA6B,CAAC,EAEpC,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,QAAQ,EAAG,CAC1C,IAAM,EAAM,EAAO,EAAM,EAAO,CAAI,EACpC,EAAI,GAAO,CACb,CAEA,OAAO,CACT"}

package/dist/index.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`),t=require(`./add-prop.cjs`),n=require(`./add.cjs`),r=require(`./all-pass.cjs`),i=require(`./any-pass.cjs`),a=require(`./capitalize.cjs`),o=require(`./ceil.cjs`),s=require(`./chunk.cjs`),c=require(`./clamp.cjs`),l=require(`./clone.cjs`),u=require(`./concat.cjs`),d=require(`./conditional-3wcaMG9k.cjs`),f=require(`./constant.cjs`),p=require(`./count-by.cjs`),m=require(`./debounce.cjs`),h=require(`./default-to.cjs`),g=require(`./pipe.cjs`),_=require(`./difference-with.cjs`),v=require(`./difference.cjs`),y=require(`./divide.cjs`),b=require(`./do-nothing.cjs`),x=require(`./has-at-least.cjs`),S=require(`./drop-first-by.cjs`),C=require(`./drop-last-while.cjs`),w=require(`./drop-last.cjs`),T=require(`./drop-while.cjs`),E=require(`./drop.cjs`),D=require(`./ends-with.cjs`),O=require(`./entries.cjs`),k=require(`./evolve.cjs`),A=require(`./filter.cjs`),j=require(`./find-index.cjs`),M=require(`./find-last-index.cjs`),N=require(`./find-last.cjs`),P=require(`./find.cjs`),F=require(`./first-by.cjs`),I=require(`./first.cjs`),L=require(`./flat-map.cjs`),R=require(`./flat.cjs`),z=require(`./floor.cjs`),B=require(`./for-each-obj.cjs`),V=require(`./for-each.cjs`),H=require(`./from-entries.cjs`),U=require(`./from-keys.cjs`),W=require(`./funnel.cjs`),G=require(`./group-by-prop.cjs`),K=require(`./group-by.cjs`),q=require(`./is-deep-equal.cjs`),J=require(`./has-sub-object.cjs`),Y=require(`./human-readable-file-size.cjs`),X=require(`./identity.cjs`),Z=require(`./index-by.cjs`),Q=require(`./intersection.cjs`),$=require(`./intersection-with.cjs`),ee=require(`./invert.cjs`),te=require(`./is-array.cjs`),ne=require(`./is-big-int.cjs`),re=require(`./is-boolean.cjs`),ie=require(`./is-date.cjs`),ae=require(`./is-defined.cjs`),oe=require(`./is-empty.cjs`),se=require(`./is-emptyish.cjs`),ce=require(`./is-error.cjs`),le=require(`./is-function.cjs`),ue=require(`./is-included-in.cjs`),de=require(`./is-non-null.cjs`),fe=require(`./is-non-nullish.cjs`),pe=require(`./is-not.cjs`),me=require(`./is-nullish.cjs`),he=require(`./is-number.cjs`),ge=require(`./is-object-type.cjs`),_e=require(`./is-plain-object.cjs`),ve=require(`./is-promise.cjs`),ye=require(`./is-shallow-equal.cjs`),be=require(`./is-strict-equal.cjs`),xe=require(`./is-string.cjs`),Se=require(`./is-symbol.cjs`),Ce=require(`./is-truthy.cjs`),we=require(`./join.cjs`),Te=require(`./key-codes.cjs`),Ee=require(`./keys.cjs`),De=require(`./last.cjs`),Oe=require(`./length.cjs`),ke=require(`./map.cjs`),Ae=require(`./map-keys.cjs`),je=require(`./map-to-obj.cjs`),Me=require(`./map-values.cjs`),Ne=require(`./map-with-feedback.cjs`),Pe=require(`./sum.cjs`),Fe=require(`./mean.cjs`),Ie=require(`./mean-by.cjs`),Le=require(`./median.cjs`),Re=require(`./merge.cjs`),ze=require(`./merge-all.cjs`),Be=require(`./merge-deep.cjs`),Ve=require(`./multiply.cjs`),He=require(`./nth-by-zZ3RM-mR.cjs`),Ue=require(`./obj-of.cjs`),We=require(`./omit.cjs`),Ge=require(`./omit-by.cjs`),Ke=require(`./once.cjs`),qe=require(`./only.cjs`),Je=require(`./partial-bind.cjs`),Ye=require(`./partial-last-bind.cjs`),Xe=require(`./partition.cjs`),Ze=require(`./path-or.cjs`),Qe=require(`./pick.cjs`),$e=require(`./pick-by.cjs`),et=require(`./piped.cjs`),tt=require(`./product.cjs`),nt=require(`./prop.cjs`),rt=require(`./pull-object.cjs`),it=require(`./random-big-int.cjs`),at=require(`./random-integer.cjs`),ot=require(`./random-string.cjs`),st=require(`./range.cjs`),ct=require(`./rank-by.cjs`),lt=require(`./reduce.cjs`),ut=require(`./reverse.cjs`),dt=require(`./round.cjs`),ft=require(`./sample.cjs`),pt=require(`./set.cjs`),mt=require(`./set-path.cjs`),ht=require(`./shuffle.cjs`),gt=require(`./sleep.cjs`),_t=require(`./slice-string.cjs`),vt=require(`./slugify.cjs`),yt=require(`./sort.cjs`),bt=require(`./sort-by.cjs`),xt=require(`./sorted-index.cjs`),St=require(`./sorted-index-by.cjs`),Ct=require(`./sorted-index-with.cjs`),wt=require(`./sorted-last-index.cjs`),Tt=require(`./sorted-last-index-by.cjs`),Et=require(`./splice.cjs`),Dt=require(`./split.cjs`),Ot=require(`./split-at.cjs`),kt=require(`./split-when.cjs`),At=require(`./starts-with.cjs`),jt=require(`./string-to-path.cjs`),Mt=require(`./subtract.cjs`),Nt=require(`./sum-by.cjs`),Pt=require(`./swap-indices.cjs`),Ft=require(`./swap-props.cjs`),It=require(`./take.cjs`),Lt=require(`./take-first-by.cjs`),Rt=require(`./take-last.cjs`),zt=require(`./take-last-while.cjs`),Bt=require(`./take-while.cjs`),Vt=require(`./tap.cjs`),Ht=require(`./times.cjs`),Ut=require(`./to-camel-case.cjs`),Wt=require(`./to-kebab-case.cjs`),Gt=require(`./to-lower-case.cjs`),Kt=require(`./to-snake-case.cjs`),qt=require(`./to-title-case.cjs`),Jt=require(`./to-upper-case.cjs`),Yt=require(`./truncate.cjs`);require(`./type.helpers.cjs`);const Xt=require(`./uncapitalize.cjs`),Zt=require(`./unique.cjs`),Qt=require(`./unique-by.cjs`),$t=require(`./unique-with.cjs`),en=require(`./values.cjs`),tn=require(`./when.cjs`),nn=require(`./zip.cjs`),rn=require(`./zip-with.cjs`),an=typeof window<`u`;exports.KEY_CODES=Te.KEY_CODES,exports.add=n.add,exports.addProp=t.addProp,exports.allPass=r.allPass,exports.anyPass=i.anyPass,exports.capitalize=a.capitalize,exports.ceil=o.ceil,exports.chunk=s.chunk,exports.clamp=c.clamp,exports.clone=l.clone,exports.concat=u.concat,exports.conditional=d.t,exports.constant=f.constant,exports.countBy=p.countBy,exports.curry=e.curry,exports.debounce=m.debounce,exports.defaultTo=h.defaultTo,exports.difference=v.difference,exports.differenceWith=_.differenceWith,exports.divide=y.divide,exports.doNothing=b.doNothing,exports.drop=E.drop,exports.dropFirstBy=S.dropFirstBy,exports.dropLast=w.dropLast,exports.dropLastWhile=C.dropLastWhile,exports.dropWhile=T.dropWhile,exports.endsWith=D.endsWith,exports.entries=O.entries,exports.evolve=k.evolve,exports.filter=A.filter,exports.find=P.find,exports.findIndex=j.findIndex,exports.findLast=N.findLast,exports.findLastIndex=M.findLastIndex,exports.first=I.first,exports.firstBy=F.firstBy,exports.flat=R.flat,exports.flatMap=L.flatMap,exports.floor=z.floor,exports.forEach=V.forEach,exports.forEachObj=B.forEachObj,exports.fromEntries=H.fromEntries,exports.fromKeys=U.fromKeys,exports.funnel=W.funnel,exports.groupBy=K.groupBy,exports.groupByProp=G.groupByProp,exports.hasAtLeast=x.hasAtLeast,exports.hasSubObject=J.hasSubObject,exports.humanReadableFileSize=Y.humanReadableFileSize,exports.identity=X.identity,exports.indexBy=Z.indexBy,exports.intersection=Q.intersection,exports.intersectionWith=$.intersectionWith,exports.invert=ee.invert,exports.isArray=te.isArray,exports.isBigInt=ne.isBigInt,exports.isBoolean=re.isBoolean,exports.isBrowser=an,exports.isDate=ie.isDate,exports.isDeepEqual=q.isDeepEqual,exports.isDefined=ae.isDefined,exports.isEmpty=oe.isEmpty,exports.isEmptyish=se.isEmptyish,exports.isError=ce.isError,exports.isFunction=le.isFunction,exports.isIncludedIn=ue.isIncludedIn,exports.isNonNull=de.isNonNull,exports.isNonNullish=fe.isNonNullish,exports.isNot=pe.isNot,exports.isNullish=me.isNullish,exports.isNumber=he.isNumber,exports.isObjectType=ge.isObjectType,exports.isPlainObject=_e.isPlainObject,exports.isPromise=ve.isPromise,exports.isShallowEqual=ye.isShallowEqual,exports.isStrictEqual=be.isStrictEqual,exports.isString=xe.isString,exports.isSymbol=Se.isSymbol,exports.isTruthy=Ce.isTruthy,exports.join=we.join,exports.keys=Ee.keys,exports.last=De.last,exports.length=Oe.length,exports.map=ke.map,exports.mapKeys=Ae.mapKeys,exports.mapToObj=je.mapToObj,exports.mapValues=Me.mapValues,exports.mapWithFeedback=Ne.mapWithFeedback,exports.mean=Fe.mean,exports.meanBy=Ie.meanBy,exports.median=Le.median,exports.merge=Re.merge,exports.mergeAll=ze.mergeAll,exports.mergeDeep=Be.mergeDeep,exports.multiply=Ve.multiply,exports.nthBy=He.t,exports.objOf=Ue.objOf,exports.omit=We.omit,exports.omitBy=Ge.omitBy,exports.once=Ke.once,exports.only=qe.only,exports.partialBind=Je.partialBind,exports.partialLastBind=Ye.partialLastBind,exports.partition=Xe.partition,exports.pathOr=Ze.pathOr,exports.pick=Qe.pick,exports.pickBy=$e.pickBy,exports.pipe=g.pipe,exports.piped=et.piped,exports.product=tt.product,exports.prop=nt.prop,exports.pullObject=rt.pullObject,exports.randomBigInt=it.randomBigInt,exports.randomInteger=at.randomInteger,exports.randomString=ot.randomString,exports.range=st.range,exports.rankBy=ct.rankBy,exports.reduce=lt.reduce,exports.reverse=ut.reverse,exports.round=dt.round,exports.sample=ft.sample,exports.set=pt.set,exports.setPath=mt.setPath,exports.shuffle=ht.shuffle,exports.sleep=gt.sleep,exports.sliceString=_t.sliceString,exports.slugify=vt.slugify,exports.sort=yt.sort,exports.sortBy=bt.sortBy,exports.sortedIndex=xt.sortedIndex,exports.sortedIndexBy=St.sortedIndexBy,exports.sortedIndexWith=Ct.sortedIndexWith,exports.sortedLastIndex=wt.sortedLastIndex,exports.sortedLastIndexBy=Tt.sortedLastIndexBy,exports.splice=Et.splice,exports.split=Dt.split,exports.splitAt=Ot.splitAt,exports.splitWhen=kt.splitWhen,exports.startsWith=At.startsWith,exports.stringToPath=jt.stringToPath,exports.subtract=Mt.subtract,exports.sum=Pe.sum,exports.sumBy=Nt.sumBy,exports.swapIndices=Pt.swapIndices,exports.swapProps=Ft.swapProps,exports.take=It.take,exports.takeFirstBy=Lt.takeFirstBy,exports.takeLast=Rt.takeLast,exports.takeLastWhile=zt.takeLastWhile,exports.takeWhile=Bt.takeWhile,exports.tap=Vt.tap,exports.times=Ht.times,exports.toCamelCase=Ut.toCamelCase,exports.toKebabCase=Wt.toKebabCase,exports.toLowerCase=Gt.toLowerCase,exports.toSnakeCase=Kt.toSnakeCase,exports.toTitleCase=qt.toTitleCase,exports.toUpperCase=Jt.toUpperCase,exports.truncate=Yt.truncate,exports.uncapitalize=Xt.uncapitalize,exports.unique=Zt.unique,exports.uniqueBy=Qt.uniqueBy,exports.uniqueWith=$t.uniqueWith,exports.values=en.values,exports.when=tn.when,exports.zip=nn.zip,exports.zipWith=rn.zipWith;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs"),t=require("./add-prop.cjs"),n=require("./add.cjs"),r=require("./all-pass.cjs"),i=require("./any-pass.cjs"),a=require("./capitalize.cjs"),o=require("./ceil.cjs"),s=require("./chunk.cjs"),c=require("./clamp.cjs"),l=require("./clone.cjs"),u=require("./concat.cjs"),d=require("./conditional.cjs"),f=require("./constant.cjs"),p=require("./count-by.cjs"),m=require("./debounce.cjs"),h=require("./default-to.cjs"),g=require("./pipe.cjs"),_=require("./difference-with.cjs"),v=require("./difference.cjs"),y=require("./divide.cjs"),b=require("./do-nothing.cjs"),x=require("./has-at-least.cjs"),S=require("./drop-first-by.cjs"),C=require("./drop-last-while.cjs"),w=require("./drop-last.cjs"),T=require("./drop-while.cjs"),E=require("./drop.cjs"),D=require("./ends-with.cjs"),O=require("./entries.cjs"),k=require("./evolve.cjs"),A=require("./filter.cjs"),j=require("./find-index.cjs"),M=require("./find-last-index.cjs"),N=require("./find-last.cjs"),P=require("./find.cjs"),F=require("./first-by.cjs"),I=require("./first.cjs"),L=require("./flat-map.cjs"),R=require("./flat.cjs"),z=require("./floor.cjs"),B=require("./for-each-obj.cjs"),V=require("./for-each.cjs"),H=require("./from-entries.cjs"),U=require("./from-keys.cjs"),W=require("./funnel.cjs"),G=require("./group-by-prop.cjs"),K=require("./group-by.cjs"),q=require("./has-prop.cjs"),J=require("./is-deep-equal.cjs"),Y=require("./has-sub-object.cjs"),X=require("./human-readable-file-size.cjs"),Z=require("./identity.cjs"),Q=require("./index-by.cjs"),$=require("./intersection.cjs"),ee=require("./intersection-with.cjs"),te=require("./invert.cjs"),ne=require("./is-array.cjs"),re=require("./is-big-int.cjs"),ie=require("./is-boolean.cjs"),ae=require("./is-date.cjs"),oe=require("./is-defined.cjs"),se=require("./is-empty.cjs"),ce=require("./is-emptyish.cjs"),le=require("./is-error.cjs"),ue=require("./is-function.cjs"),de=require("./is-included-in.cjs"),fe=require("./is-non-null.cjs"),pe=require("./is-non-nullish.cjs"),me=require("./is-not.cjs"),he=require("./is-nullish.cjs"),ge=require("./is-number.cjs"),_e=require("./is-object-type.cjs"),ve=require("./is-plain-object.cjs"),ye=require("./is-promise.cjs"),be=require("./is-shallow-equal.cjs"),xe=require("./is-strict-equal.cjs"),Se=require("./is-string.cjs"),Ce=require("./is-symbol.cjs"),we=require("./is-truthy.cjs"),Te=require("./join.cjs"),Ee=require("./key-codes.cjs"),De=require("./keys.cjs"),Oe=require("./last.cjs"),ke=require("./length.cjs"),Ae=require("./map.cjs"),je=require("./map-keys.cjs"),Me=require("./map-to-obj.cjs"),Ne=require("./map-values.cjs"),Pe=require("./map-with-feedback.cjs"),Fe=require("./sum.cjs"),Ie=require("./mean.cjs"),Le=require("./mean-by.cjs"),Re=require("./median.cjs"),ze=require("./merge.cjs"),Be=require("./merge-all.cjs"),Ve=require("./merge-deep.cjs"),He=require("./multiply.cjs"),Ue=require("./nth-by-BrkoqeV2.cjs"),We=require("./obj-of.cjs"),Ge=require("./omit.cjs"),Ke=require("./omit-by.cjs"),qe=require("./once.cjs"),Je=require("./only.cjs"),Ye=require("./partial-bind.cjs"),Xe=require("./partial-last-bind.cjs"),Ze=require("./partition.cjs"),Qe=require("./path-or.cjs"),$e=require("./pick.cjs"),et=require("./pick-by.cjs"),tt=require("./piped.cjs"),nt=require("./product.cjs"),rt=require("./prop.cjs"),it=require("./pull-object.cjs"),at=require("./random-big-int.cjs"),ot=require("./random-integer.cjs"),st=require("./random-string.cjs"),ct=require("./range.cjs"),lt=require("./rank-by.cjs"),ut=require("./reduce.cjs"),dt=require("./reverse.cjs"),ft=require("./round.cjs"),pt=require("./sample.cjs"),mt=require("./set.cjs"),ht=require("./set-path.cjs"),gt=require("./shuffle.cjs"),_t=require("./sleep.cjs"),vt=require("./slice-string.cjs"),yt=require("./slugify.cjs"),bt=require("./sort.cjs"),xt=require("./sort-by.cjs"),St=require("./sorted-index.cjs"),Ct=require("./sorted-index-by.cjs"),wt=require("./sorted-index-with.cjs"),Tt=require("./sorted-last-index.cjs"),Et=require("./sorted-last-index-by.cjs"),Dt=require("./splice.cjs"),Ot=require("./split.cjs"),kt=require("./split-at.cjs"),At=require("./split-when.cjs"),jt=require("./starts-with.cjs"),Mt=require("./string-to-path.cjs"),Nt=require("./subtract.cjs"),Pt=require("./sum-by.cjs"),Ft=require("./swap-indices.cjs"),It=require("./swap-props.cjs"),Lt=require("./take.cjs"),Rt=require("./take-first-by.cjs"),zt=require("./take-last.cjs"),Bt=require("./take-last-while.cjs"),Vt=require("./take-while.cjs"),Ht=require("./tap.cjs"),Ut=require("./times.cjs"),Wt=require("./to-camel-case.cjs"),Gt=require("./to-kebab-case.cjs"),Kt=require("./to-lower-case.cjs"),qt=require("./to-snake-case.cjs"),Jt=require("./to-title-case.cjs"),Yt=require("./to-upper-case.cjs"),Xt=require("./truncate.cjs");require("./type.helpers.cjs");const Zt=require("./uncapitalize.cjs"),Qt=require("./unique.cjs"),$t=require("./unique-by.cjs"),en=require("./unique-with.cjs"),tn=require("./values.cjs"),nn=require("./when.cjs"),rn=require("./zip.cjs"),an=require("./zip-with.cjs"),on=typeof window<`u`;exports.KEY_CODES=Ee.KEY_CODES,exports.add=n.add,exports.addProp=t.addProp,exports.allPass=r.allPass,exports.anyPass=i.anyPass,exports.capitalize=a.capitalize,exports.ceil=o.ceil,exports.chunk=s.chunk,exports.clamp=c.clamp,exports.clone=l.clone,exports.concat=u.concat,exports.conditional=d.conditional,exports.constant=f.constant,exports.countBy=p.countBy,exports.curry=e.curry,exports.debounce=m.debounce,exports.defaultTo=h.defaultTo,exports.difference=v.difference,exports.differenceWith=_.differenceWith,exports.divide=y.divide,exports.doNothing=b.doNothing,exports.drop=E.drop,exports.dropFirstBy=S.dropFirstBy,exports.dropLast=w.dropLast,exports.dropLastWhile=C.dropLastWhile,exports.dropWhile=T.dropWhile,exports.endsWith=D.endsWith,exports.entries=O.entries,exports.evolve=k.evolve,exports.filter=A.filter,exports.find=P.find,exports.findIndex=j.findIndex,exports.findLast=N.findLast,exports.findLastIndex=M.findLastIndex,exports.first=I.first,exports.firstBy=F.firstBy,exports.flat=R.flat,exports.flatMap=L.flatMap,exports.floor=z.floor,exports.forEach=V.forEach,exports.forEachObj=B.forEachObj,exports.fromEntries=H.fromEntries,exports.fromKeys=U.fromKeys,exports.funnel=W.funnel,exports.groupBy=K.groupBy,exports.groupByProp=G.groupByProp,exports.hasAtLeast=x.hasAtLeast,exports.hasProp=q.hasProp,exports.hasSubObject=Y.hasSubObject,exports.humanReadableFileSize=X.humanReadableFileSize,exports.identity=Z.identity,exports.indexBy=Q.indexBy,exports.intersection=$.intersection,exports.intersectionWith=ee.intersectionWith,exports.invert=te.invert,exports.isArray=ne.isArray,exports.isBigInt=re.isBigInt,exports.isBoolean=ie.isBoolean,exports.isBrowser=on,exports.isDate=ae.isDate,exports.isDeepEqual=J.isDeepEqual,exports.isDefined=oe.isDefined,exports.isEmpty=se.isEmpty,exports.isEmptyish=ce.isEmptyish,exports.isError=le.isError,exports.isFunction=ue.isFunction,exports.isIncludedIn=de.isIncludedIn,exports.isNonNull=fe.isNonNull,exports.isNonNullish=pe.isNonNullish,exports.isNot=me.isNot,exports.isNullish=he.isNullish,exports.isNumber=ge.isNumber,exports.isObjectType=_e.isObjectType,exports.isPlainObject=ve.isPlainObject,exports.isPromise=ye.isPromise,exports.isShallowEqual=be.isShallowEqual,exports.isStrictEqual=xe.isStrictEqual,exports.isString=Se.isString,exports.isSymbol=Ce.isSymbol,exports.isTruthy=we.isTruthy,exports.join=Te.join,exports.keys=De.keys,exports.last=Oe.last,exports.length=ke.length,exports.map=Ae.map,exports.mapKeys=je.mapKeys,exports.mapToObj=Me.mapToObj,exports.mapValues=Ne.mapValues,exports.mapWithFeedback=Pe.mapWithFeedback,exports.mean=Ie.mean,exports.meanBy=Le.meanBy,exports.median=Re.median,exports.merge=ze.merge,exports.mergeAll=Be.mergeAll,exports.mergeDeep=Ve.mergeDeep,exports.multiply=He.multiply,exports.nthBy=Ue.t,exports.objOf=We.objOf,exports.omit=Ge.omit,exports.omitBy=Ke.omitBy,exports.once=qe.once,exports.only=Je.only,exports.partialBind=Ye.partialBind,exports.partialLastBind=Xe.partialLastBind,exports.partition=Ze.partition,exports.pathOr=Qe.pathOr,exports.pick=$e.pick,exports.pickBy=et.pickBy,exports.pipe=g.pipe,exports.piped=tt.piped,exports.product=nt.product,exports.prop=rt.prop,exports.pullObject=it.pullObject,exports.randomBigInt=at.randomBigInt,exports.randomInteger=ot.randomInteger,exports.randomString=st.randomString,exports.range=ct.range,exports.rankBy=lt.rankBy,exports.reduce=ut.reduce,exports.reverse=dt.reverse,exports.round=ft.round,exports.sample=pt.sample,exports.set=mt.set,exports.setPath=ht.setPath,exports.shuffle=gt.shuffle,exports.sleep=_t.sleep,exports.sliceString=vt.sliceString,exports.slugify=yt.slugify,exports.sort=bt.sort,exports.sortBy=xt.sortBy,exports.sortedIndex=St.sortedIndex,exports.sortedIndexBy=Ct.sortedIndexBy,exports.sortedIndexWith=wt.sortedIndexWith,exports.sortedLastIndex=Tt.sortedLastIndex,exports.sortedLastIndexBy=Et.sortedLastIndexBy,exports.splice=Dt.splice,exports.split=Ot.split,exports.splitAt=kt.splitAt,exports.splitWhen=At.splitWhen,exports.startsWith=jt.startsWith,exports.stringToPath=Mt.stringToPath,exports.subtract=Nt.subtract,exports.sum=Fe.sum,exports.sumBy=Pt.sumBy,exports.swapIndices=Ft.swapIndices,exports.swapProps=It.swapProps,exports.take=Lt.take,exports.takeFirstBy=Rt.takeFirstBy,exports.takeLast=zt.takeLast,exports.takeLastWhile=Bt.takeLastWhile,exports.takeWhile=Vt.takeWhile,exports.tap=Ht.tap,exports.times=Ut.times,exports.toCamelCase=Wt.toCamelCase,exports.toKebabCase=Gt.toKebabCase,exports.toLowerCase=Kt.toLowerCase,exports.toSnakeCase=qt.toSnakeCase,exports.toTitleCase=Jt.toTitleCase,exports.toUpperCase=Yt.toUpperCase,exports.truncate=Xt.truncate,exports.uncapitalize=Zt.uncapitalize,exports.unique=Qt.unique,exports.uniqueBy=$t.uniqueBy,exports.uniqueWith=en.uniqueWith,exports.values=tn.values,exports.when=nn.when,exports.zip=rn.zip,exports.zipWith=an.zipWith;
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["export * from './add';\nexport * from './add-prop';\nexport * from './all-pass';\nexport * from './any-pass';\nexport * from './capitalize';\nexport * from './ceil';\nexport * from './chunk';\nexport * from './clamp';\nexport * from './clone';\nexport * from './concat';\nexport * from './conditional';\nexport * from './constant';\nexport * from './count-by';\nexport * from './curry';\nexport * from './debounce';\nexport * from './default-to';\nexport * from './difference';\nexport * from './difference-with';\nexport * from './divide';\nexport * from './do-nothing';\nexport * from './drop';\nexport * from './drop-first-by';\nexport * from './drop-last';\nexport * from './drop-last-while';\nexport * from './drop-while';\nexport * from './ends-with';\nexport * from './entries';\nexport * from './evolve';\nexport * from './filter';\nexport * from './find';\nexport * from './find-index';\nexport * from './find-last';\nexport * from './find-last-index';\nexport * from './first';\nexport * from './first-by';\nexport * from './flat';\nexport * from './flat-map';\nexport * from './floor';\nexport * from './for-each';\nexport * from './for-each-obj';\nexport * from './from-entries';\nexport * from './from-keys';\nexport * from './funnel';\nexport * from './group-by';\nexport * from './group-by-prop';\nexport * from './has-at-least';\nexport * from './has-sub-object';\nexport * from './human-readable-file-size';\nexport * from './identity';\nexport * from './index-by';\nexport * from './intersection';\nexport * from './intersection-with';\nexport * from './invert';\nexport * from './is-array';\nexport * from './is-big-int';\nexport * from './is-boolean';\nexport * from './is-date';\nexport * from './is-deep-equal';\nexport * from './is-defined';\nexport * from './is-empty';\nexport * from './is-emptyish';\nexport * from './is-error';\nexport * from './is-function';\nexport * from './is-included-in';\nexport * from './is-non-null';\nexport * from './is-non-nullish';\nexport * from './is-not';\nexport * from './is-nullish';\nexport * from './is-number';\nexport * from './is-object-type';\nexport * from './is-plain-object';\nexport * from './is-promise';\nexport * from './is-shallow-equal';\nexport * from './is-strict-equal';\nexport * from './is-string';\nexport * from './is-symbol';\nexport * from './is-truthy';\nexport * from './join';\nexport * from './key-codes';\nexport * from './keys';\nexport * from './last';\nexport * from './length';\nexport * from './map';\nexport * from './map-keys';\nexport * from './map-to-obj';\nexport * from './map-values';\nexport * from './map-with-feedback';\nexport * from './mean';\nexport * from './mean-by';\nexport * from './median';\nexport * from './merge';\nexport * from './merge-all';\nexport * from './merge-deep';\nexport * from './multiply';\nexport * from './nth-by';\nexport * from './obj-of';\nexport * from './omit';\nexport * from './omit-by';\nexport * from './once';\nexport * from './only';\nexport * from './partial-bind';\nexport * from './partial-last-bind';\nexport * from './partition';\nexport * from './path-or';\nexport * from './pick';\nexport * from './pick-by';\nexport * from './pipe';\nexport * from './piped';\nexport * from './product';\nexport * from './prop';\nexport * from './pull-object';\nexport * from './random-big-int';\nexport * from './random-integer';\nexport * from './random-string';\nexport * from './range';\nexport * from './rank-by';\nexport * from './reduce';\nexport * from './reverse';\nexport * from './round';\nexport * from './sample';\nexport * from './set';\nexport * from './set-path';\nexport * from './shuffle';\nexport * from './sleep';\nexport * from './slice-string';\nexport * from './slugify';\nexport * from './sort';\nexport * from './sort-by';\nexport * from './sorted-index';\nexport * from './sorted-index-by';\nexport * from './sorted-index-with';\nexport * from './sorted-last-index';\nexport * from './sorted-last-index-by';\nexport * from './splice';\nexport * from './split';\nexport * from './split-at';\nexport * from './split-when';\nexport * from './starts-with';\nexport * from './string-to-path';\nexport * from './subtract';\nexport * from './sum';\nexport * from './sum-by';\nexport * from './swap-indices';\nexport * from './swap-props';\nexport * from './take';\nexport * from './take-first-by';\nexport * from './take-last';\nexport * from './take-last-while';\nexport * from './take-while';\nexport * from './tap';\nexport * from './times';\nexport * from './to-camel-case';\nexport * from './to-kebab-case';\nexport * from './to-lower-case';\nexport * from './to-snake-case';\nexport * from './to-title-case';\nexport * from './to-upper-case';\nexport * from './truncate';\nexport * from './type.helpers';\nexport * from './uncapitalize';\nexport * from './unique';\nexport * from './unique-by';\nexport * from './unique-with';\nexport * from './values';\nexport * from './when';\nexport * from './zip';\nexport * from './zip-with';\n\nexport const isBrowser = typeof window !== 'undefined';\n"],"mappings":"26JAwKa,GAAY,OAAO,OAAW"}
+{"version":3,"file":"index.cjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["export * from './add';\nexport * from './add-prop';\nexport * from './all-pass';\nexport * from './any-pass';\nexport * from './capitalize';\nexport * from './ceil';\nexport * from './chunk';\nexport * from './clamp';\nexport * from './clone';\nexport * from './concat';\nexport * from './conditional';\nexport * from './constant';\nexport * from './count-by';\nexport * from './curry';\nexport * from './debounce';\nexport * from './default-to';\nexport * from './difference';\nexport * from './difference-with';\nexport * from './divide';\nexport * from './do-nothing';\nexport * from './drop';\nexport * from './drop-first-by';\nexport * from './drop-last';\nexport * from './drop-last-while';\nexport * from './drop-while';\nexport * from './ends-with';\nexport * from './entries';\nexport * from './evolve';\nexport * from './filter';\nexport * from './find';\nexport * from './find-index';\nexport * from './find-last';\nexport * from './find-last-index';\nexport * from './first';\nexport * from './first-by';\nexport * from './flat';\nexport * from './flat-map';\nexport * from './floor';\nexport * from './for-each';\nexport * from './for-each-obj';\nexport * from './from-entries';\nexport * from './from-keys';\nexport * from './funnel';\nexport * from './group-by';\nexport * from './group-by-prop';\nexport * from './has-at-least';\nexport * from './has-prop';\nexport * from './has-sub-object';\nexport * from './human-readable-file-size';\nexport * from './identity';\nexport * from './index-by';\nexport * from './intersection';\nexport * from './intersection-with';\nexport * from './invert';\nexport * from './is-array';\nexport * from './is-big-int';\nexport * from './is-boolean';\nexport * from './is-date';\nexport * from './is-deep-equal';\nexport * from './is-defined';\nexport * from './is-empty';\nexport * from './is-emptyish';\nexport * from './is-error';\nexport * from './is-function';\nexport * from './is-included-in';\nexport * from './is-non-null';\nexport * from './is-non-nullish';\nexport * from './is-not';\nexport * from './is-nullish';\nexport * from './is-number';\nexport * from './is-object-type';\nexport * from './is-plain-object';\nexport * from './is-promise';\nexport * from './is-shallow-equal';\nexport * from './is-strict-equal';\nexport * from './is-string';\nexport * from './is-symbol';\nexport * from './is-truthy';\nexport * from './join';\nexport * from './key-codes';\nexport * from './keys';\nexport * from './last';\nexport * from './length';\nexport * from './map';\nexport * from './map-keys';\nexport * from './map-to-obj';\nexport * from './map-values';\nexport * from './map-with-feedback';\nexport * from './mean';\nexport * from './mean-by';\nexport * from './median';\nexport * from './merge';\nexport * from './merge-all';\nexport * from './merge-deep';\nexport * from './multiply';\nexport * from './nth-by';\nexport * from './obj-of';\nexport * from './omit';\nexport * from './omit-by';\nexport * from './once';\nexport * from './only';\nexport * from './partial-bind';\nexport * from './partial-last-bind';\nexport * from './partition';\nexport * from './path-or';\nexport * from './pick';\nexport * from './pick-by';\nexport * from './pipe';\nexport * from './piped';\nexport * from './product';\nexport * from './prop';\nexport * from './pull-object';\nexport * from './random-big-int';\nexport * from './random-integer';\nexport * from './random-string';\nexport * from './range';\nexport * from './rank-by';\nexport * from './reduce';\nexport * from './reverse';\nexport * from './round';\nexport * from './sample';\nexport * from './set';\nexport * from './set-path';\nexport * from './shuffle';\nexport * from './sleep';\nexport * from './slice-string';\nexport * from './slugify';\nexport * from './sort';\nexport * from './sort-by';\nexport * from './sorted-index';\nexport * from './sorted-index-by';\nexport * from './sorted-index-with';\nexport * from './sorted-last-index';\nexport * from './sorted-last-index-by';\nexport * from './splice';\nexport * from './split';\nexport * from './split-at';\nexport * from './split-when';\nexport * from './starts-with';\nexport * from './string-to-path';\nexport * from './subtract';\nexport * from './sum';\nexport * from './sum-by';\nexport * from './swap-indices';\nexport * from './swap-props';\nexport * from './take';\nexport * from './take-first-by';\nexport * from './take-last';\nexport * from './take-last-while';\nexport * from './take-while';\nexport * from './tap';\nexport * from './times';\nexport * from './to-camel-case';\nexport * from './to-kebab-case';\nexport * from './to-lower-case';\nexport * from './to-snake-case';\nexport * from './to-title-case';\nexport * from './to-upper-case';\nexport * from './truncate';\nexport * from './type.helpers';\nexport * from './uncapitalize';\nexport * from './unique';\nexport * from './unique-by';\nexport * from './unique-with';\nexport * from './values';\nexport * from './when';\nexport * from './zip';\nexport * from './zip-with';\n\nexport const isBrowser = typeof window !== 'undefined';\n"],"mappings":"+7JAyKa,GAAY,OAAO,OAAW"}