@vinicunca/perkakas 1.9.0 → 1.13.0

package/dist/group-by.d.ts

@@ -1,5 +1,69 @@
-import "./non-empty-array-BfTfvDYg.js";
-import "./is-bounded-record-DEQ2a3_Y.js";
-import "./bounded-partial-DfemQln9.js";
-import { groupBy } from "./group-by-DXW8niUS.js";
-export { groupBy };
+import { t as NonEmptyArray } from "./non-empty-array-DHAKSw6t.js";
+import { t as BoundedPartial } from "./bounded-partial-CPc1XU57.js";
+
+//#region src/group-by.d.ts
+
+/**
+ * Groups the elements of a given iterable according to the string values
+ * returned by a provided callback function. The returned object has separate
+ * properties for each group, containing arrays with the elements in the group.
+ * Unlike the built in `Object.groupBy` this function also allows the callback to
+ * return `undefined` in order to exclude the item from being added to any
+ * group.
+ *
+ * If you are grouping objects by a property of theirs (e.g.
+ * `groupBy(data, ({ myProp }) => myProp)` or `groupBy(data, prop('myProp'))`)
+ * consider using `groupByProp` (e.g. `groupByProp(data, 'myProp')`) instead,
+ * as it would provide better typing.
+ *
+ * @param data - The items to group.
+ * @param callbackfn - A function to execute for each element in the iterable.
+ * It should return a value indicating the group of the current element, or
+ * `undefined` when the item should be excluded from any group.
+ * @returns An object with properties for all groups, each assigned to an array
+ * containing the elements of the associated group.
+ * @signature
+ *    P.groupBy(data, callbackfn)
+ * @example
+ *    P.groupBy([{a: 'cat'}, {a: 'dog'}] as const, P.prop('a')) // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]}
+ *    P.groupBy([0, 1], x => x % 2 === 0 ? 'even' : undefined) // => {even: [0]}
+ * @dataFirst
+ * @category Array
+ */
+declare function groupBy<T, Key extends PropertyKey = PropertyKey>(data: ReadonlyArray<T>, callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined): BoundedPartial<Record<Key, NonEmptyArray<T>>>;
+/**
+ * Groups the elements of a given iterable according to the string values
+ * returned by a provided callback function. The returned object has separate
+ * properties for each group, containing arrays with the elements in the group.
+ * Unlike the built in `Object.groupBy` this function also allows the callback to
+ * return `undefined` in order to exclude the item from being added to any
+ * group.
+ *
+ *  If you are grouping objects by a property of theirs (e.g.
+ * `groupBy(data, ({ myProp }) => myProp)` or `groupBy(data, prop('myProp'))`)
+ * consider using `groupByProp` (e.g. `groupByProp(data, 'myProp')`) instead,
+ * as it would provide better typing.
+ *
+ * @param callbackfn - A function to execute for each element in the iterable.
+ * It should return a value indicating the group of the current element, or
+ * `undefined` when the item should be excluded from any group.
+ * @returns An object with properties for all groups, each assigned to an array
+ * containing the elements of the associated group.
+ * @signature
+ *    P.groupBy(callbackfn)(data);
+ * @example
+ *    P.pipe(
+ *      [{a: 'cat'}, {a: 'dog'}] as const,
+ *      P.groupBy(P.prop('a')),
+ *    ); // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]}
+ *    P.pipe(
+ *      [0, 1],
+ *      P.groupBy(x => x % 2 === 0 ? 'even' : undefined),
+ *    ); // => {even: [0]}
+ * @dataLast
+ * @category Array
+ */
+declare function groupBy<T, Key extends PropertyKey = PropertyKey>(callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined): (items: ReadonlyArray<T>) => BoundedPartial<Record<Key, NonEmptyArray<T>>>;
+//#endregion
+export { groupBy };
+//# sourceMappingURL=group-by.d.ts.map

package/dist/group-by.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group-by.d.ts","names":[],"sources":["../src/group-by.ts"],"sourcesContent":[],"mappings":";;;;;;;AAgCA;;;;;;;;;;;;;;;AAyCA;;;;;;;;;;AAMyE,iBA/CzD,OA+CyD,CAAA,CAAA,EAAA,YA/ClC,WA+CkC,GA/CpB,WA+CoB,CAAA,CAAA,IAAA,EA9CjE,aA8CiE,CA9CnD,CA8CmD,CAAA,EAAA,UAAA,EAAA,CAAA,KAAA,EA5C9D,CA4C8D,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EA1C/D,aA0C+D,CA1CjD,CA0CiD,CAAA,EAAA,GAzClE,GAyCkE,GAAA,SAAA,CAAA,EAxCtE,cAwCsE,CAxCvD,MAwCuD,CAxChD,GAwCgD,EAxC3C,aAwC2C,CAxC7B,CAwC6B,CAAA,CAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBANzD,uBAAuB,cAAc,iCAE1C,wBAED,cAAc,OACjB,0BACI,cAAc,OAAO,eAAe,OAAO,KAAK,cAAc"}

package/dist/group-by.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{groupBy as e}from"./group-by-8exEDbij.js";export{e as groupBy};
+import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){let n=Object.create(null);for(let r=0;r<e.length;r++){let i=e[r],a=t(i,r,e);if(a!==void 0){let e=n[a];e===void 0?n[a]=[i]:e.push(i)}}return Object.setPrototypeOf(n,Object.prototype),n}export{t as groupBy};
+//# sourceMappingURL=group-by.js.map

package/dist/group-by.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"group-by.js","names":["output: BoundedPartial<Record<Key, NonEmptyArray<T>>>"],"sources":["../src/group-by.ts"],"sourcesContent":["import type { BoundedPartial } from './internal/types/bounded-partial';\n\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport { curry } from './curry';\n\n/**\n * Groups the elements of a given iterable according to the string values\n * returned by a provided callback function. The returned object has separate\n * properties for each group, containing arrays with the elements in the group.\n * Unlike the built in `Object.groupBy` this function also allows the callback to\n * return `undefined` in order to exclude the item from being added to any\n * group.\n *\n * If you are grouping objects by a property of theirs (e.g.\n * `groupBy(data, ({ myProp }) => myProp)` or `groupBy(data, prop('myProp'))`)\n * consider using `groupByProp` (e.g. `groupByProp(data, 'myProp')`) instead,\n * as it would provide better typing.\n *\n * @param data - The items to group.\n * @param callbackfn - A function to execute for each element in the iterable.\n * It should return a value indicating the group of the current element, or\n * `undefined` when the item should be excluded from any group.\n * @returns An object with properties for all groups, each assigned to an array\n * containing the elements of the associated group.\n * @signature\n *    P.groupBy(data, callbackfn)\n * @example\n *    P.groupBy([{a: 'cat'}, {a: 'dog'}] as const, P.prop('a')) // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]}\n *    P.groupBy([0, 1], x => x % 2 === 0 ? 'even' : undefined) // => {even: [0]}\n * @dataFirst\n * @category Array\n */\nexport function groupBy<T, Key extends PropertyKey = PropertyKey>(\n  data: ReadonlyArray<T>,\n  callbackfn: (\n    value: T,\n    index: number,\n    data: ReadonlyArray<T>,\n  ) => Key | undefined,\n): BoundedPartial<Record<Key, NonEmptyArray<T>>>;\n\n/**\n * Groups the elements of a given iterable according to the string values\n * returned by a provided callback function. The returned object has separate\n * properties for each group, containing arrays with the elements in the group.\n * Unlike the built in `Object.groupBy` this function also allows the callback to\n * return `undefined` in order to exclude the item from being added to any\n * group.\n *\n *  If you are grouping objects by a property of theirs (e.g.\n * `groupBy(data, ({ myProp }) => myProp)` or `groupBy(data, prop('myProp'))`)\n * consider using `groupByProp` (e.g. `groupByProp(data, 'myProp')`) instead,\n * as it would provide better typing.\n *\n * @param callbackfn - A function to execute for each element in the iterable.\n * It should return a value indicating the group of the current element, or\n * `undefined` when the item should be excluded from any group.\n * @returns An object with properties for all groups, each assigned to an array\n * containing the elements of the associated group.\n * @signature\n *    P.groupBy(callbackfn)(data);\n * @example\n *    P.pipe(\n *      [{a: 'cat'}, {a: 'dog'}] as const,\n *      P.groupBy(P.prop('a')),\n *    ); // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]}\n *    P.pipe(\n *      [0, 1],\n *      P.groupBy(x => x % 2 === 0 ? 'even' : undefined),\n *    ); // => {even: [0]}\n * @dataLast\n * @category Array\n */\nexport function groupBy<T, Key extends PropertyKey = PropertyKey>(\n  callbackfn: (\n    value: T,\n    index: number,\n    data: ReadonlyArray<T>,\n  ) => Key | undefined,\n): (items: ReadonlyArray<T>) => BoundedPartial<Record<Key, NonEmptyArray<T>>>;\n\nexport function groupBy(...args: ReadonlyArray<unknown>): unknown {\n  return curry(groupByImplementation, args);\n}\n\nfunction groupByImplementation<T, Key extends PropertyKey = PropertyKey>(\n  data: ReadonlyArray<T>,\n  callbackfn: (\n    value: T,\n    index: number,\n    data: ReadonlyArray<T>,\n  ) => Key | undefined,\n): BoundedPartial<Record<Key, NonEmptyArray<T>>> {\n  const output: BoundedPartial<Record<Key, NonEmptyArray<T>>> = Object.create(null);\n\n  for (let index = 0; index < data.length; index++) {\n    // Accessing the object directly instead of via an iterator on the `entries` showed significant performance benefits while benchmarking.\n    const item = data[index];\n\n    // @ts-expect-error [ts2345] -- TypeScript is not able to infer that the index wouldn't overflow the array and that it shouldn't add `undefined` to the type. We don't want to use the `!` operator here because it's semantics are different because it changes the type of `item` to `NonNullable<T>` which is inaccurate because T itself could have `undefined` as a valid value.\n    const key = callbackfn(item, index, data);\n    if (key !== undefined) {\n      // Once the prototype chain is fixed, it is safe to access the prop directly without needing to check existence or types.\n      const items = output[key];\n\n      if (items === undefined) {\n        // It is more performant to create a 1-element array over creating an empty array and falling through to a unified the push. It is also more performant to mutate the existing object over using spread to continually create new objects on every unique key.\n        // @ts-expect-error [ts2322] -- In addition to the typing issue we have for `item`, this line also creates a typing issue for the whole object, as TypeScript is having a hard time inferring what values could be adding to the object.\n        output[key] = [item];\n      } else {\n        // It is more performant to add the items to an existing array over continually creating a new array every time we add an item to it.\n        // @ts-expect-error [ts2345] -- See comment above about the effective typing for `item` here.\n        items.push(item);\n      }\n    }\n  }\n\n  // Set the prototype as if we initialized our object as a normal object (e.g. `{}`). Without this none of the built-in object methods like `toString` would work on this object and it would act differently than expected.\n  Object.setPrototypeOf(output, Object.prototype);\n\n  return output;\n};\n"],"mappings":"wCAiFA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAK,CAG3C,SAAS,EACP,EACA,EAK+C,CAC/C,IAAMA,EAAwD,OAAO,OAAO,KAAK,CAEjF,IAAK,IAAI,EAAQ,EAAG,EAAQ,EAAK,OAAQ,IAAS,CAEhD,IAAM,EAAO,EAAK,GAGZ,EAAM,EAAW,EAAM,EAAO,EAAK,CACzC,GAAI,IAAQ,IAAA,GAAW,CAErB,IAAM,EAAQ,EAAO,GAEjB,IAAU,IAAA,GAGZ,EAAO,GAAO,CAAC,EAAK,CAIpB,EAAM,KAAK,EAAK,EAQtB,OAFA,OAAO,eAAe,EAAQ,OAAO,UAAU,CAExC"}

package/dist/has-at-least-BXwOPLQK.cjs

@@ -0,0 +1 @@
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){return e.length>=t}Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});

package/dist/has-at-least-Coy9sM-B.js

@@ -0,0 +1,2 @@
+import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){return e.length>=t}export{t};
+//# sourceMappingURL=has-at-least-Coy9sM-B.js.map

package/dist/has-at-least-Coy9sM-B.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-at-least-Coy9sM-B.js","names":[],"sources":["../src/has-at-least.ts"],"sourcesContent":["import type { IsNumericLiteral } from 'type-fest';\nimport type { ArrayRequiredPrefix } from './internal/types/array-required-prefix';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Checks if the given array has at least the defined number of elements. When\n * the minimum used is a literal (e.g. `3`) the output is refined accordingly so\n * that those indices are defined when accessing the array even when using\n * typescript's 'noUncheckedIndexAccess'.\n *\n * @param data - The input array.\n * @param minimum - The minimum number of elements the array must have.\n * @returns True if the array's length is *at least* `minimum`. When `minimum`\n * is a literal value, the output is narrowed to ensure the first items are\n * guaranteed.\n * @signature\n *   P.hasAtLeast(data, minimum)\n * @example\n *   P.hasAtLeast([], 4); // => false\n *\n *   const data: number[] = [1,2,3,4];\n *   P.hasAtLeast(data, 1); // => true\n *   data[0]; // 1, with type `number`\n * @dataFirst\n * @category Array\n */\nexport function hasAtLeast<T extends IterableContainer, N extends number>(\n  data: IterableContainer | T,\n  minimum: IsNumericLiteral<N> extends true ? N : never,\n): data is ArrayRequiredPrefix<T, N>;\nexport function hasAtLeast(data: IterableContainer, minimum: number): boolean;\n\n/**\n * Checks if the given array has at least the defined number of elements. When\n * the minimum used is a literal (e.g. `3`) the output is refined accordingly so\n * that those indices are defined when accessing the array even when using\n * typescript's 'noUncheckedIndexAccess'.\n *\n * @param minimum - The minimum number of elements the array must have.\n * @returns True if the array's length is *at least* `minimum`. When `minimum`\n * is a literal value, the output is narrowed to ensure the first items are\n * guaranteed.\n * @signature\n *   P.hasAtLeast(minimum)(data)\n * @example\n *   P.pipe([], P.hasAtLeast(4)); // => false\n *\n *   const data = [[1,2], [3], [4,5]];\n *   P.pipe(\n *     data,\n *     P.filter(P.hasAtLeast(2)),\n *     P.map(([, second]) => second),\n *   ); // => [2,5], with type `number[]`\n * @dataLast\n * @category Array\n */\nexport function hasAtLeast<N extends number>(\n  minimum: IsNumericLiteral<N> extends true ? N : never,\n): <T extends IterableContainer>(\n  data: IterableContainer | T,\n) => data is ArrayRequiredPrefix<T, N>;\nexport function hasAtLeast(\n  minimum: number,\n): (data: IterableContainer) => boolean;\n\nexport function hasAtLeast(...args: ReadonlyArray<unknown>): unknown {\n  return curry(hasAtLeastImplementation, args);\n}\n\nfunction hasAtLeastImplementation(\n  data: IterableContainer,\n  minimum: number,\n): boolean {\n  return data.length >= minimum;\n}\n"],"mappings":"wCAkEA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAO,EAAM,EAA0B,EAAK,CAG9C,SAAS,EACP,EACA,EACS,CACT,OAAO,EAAK,QAAU"}

package/dist/has-at-least.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./has-at-least-D-ahiJB6.cjs`);exports.hasAtLeast=e.hasAtLeast;
+const e=require(`./has-at-least-BXwOPLQK.cjs`);exports.hasAtLeast=e.t;

package/dist/has-at-least.d.cts

@@ -1,8 +1,59 @@
-import "./iterable-container-V5sa0V_H.cjs";
-import "./perkakas-type-error-0tHtaPbi.cjs";
-import "./tuple-parts-BIyABPYv.cjs";
-import "./clamped-integer-subtract-DId0tRjp.cjs";
-import "./coerced-array-kVJtBrMl.cjs";
-import "./array-required-prefix-FSH3Acx8.cjs";
-import { hasAtLeast } from "./has-at-least-BbYfXc8L.cjs";
-export { hasAtLeast };
+import { t as IterableContainer } from "./iterable-container-1TN3AJ3s.cjs";
+import { t as ArrayRequiredPrefix } from "./array-required-prefix-BFDM7eSS.cjs";
+import { IsNumericLiteral } from "type-fest";
+
+//#region src/has-at-least.d.ts
+
+/**
+ * Checks if the given array has at least the defined number of elements. When
+ * the minimum used is a literal (e.g. `3`) the output is refined accordingly so
+ * that those indices are defined when accessing the array even when using
+ * typescript's 'noUncheckedIndexAccess'.
+ *
+ * @param data - The input array.
+ * @param minimum - The minimum number of elements the array must have.
+ * @returns True if the array's length is *at least* `minimum`. When `minimum`
+ * is a literal value, the output is narrowed to ensure the first items are
+ * guaranteed.
+ * @signature
+ *   P.hasAtLeast(data, minimum)
+ * @example
+ *   P.hasAtLeast([], 4); // => false
+ *
+ *   const data: number[] = [1,2,3,4];
+ *   P.hasAtLeast(data, 1); // => true
+ *   data[0]; // 1, with type `number`
+ * @dataFirst
+ * @category Array
+ */
+declare function hasAtLeast<T extends IterableContainer, N extends number>(data: IterableContainer | T, minimum: IsNumericLiteral<N> extends true ? N : never): data is ArrayRequiredPrefix<T, N>;
+declare function hasAtLeast(data: IterableContainer, minimum: number): boolean;
+/**
+ * Checks if the given array has at least the defined number of elements. When
+ * the minimum used is a literal (e.g. `3`) the output is refined accordingly so
+ * that those indices are defined when accessing the array even when using
+ * typescript's 'noUncheckedIndexAccess'.
+ *
+ * @param minimum - The minimum number of elements the array must have.
+ * @returns True if the array's length is *at least* `minimum`. When `minimum`
+ * is a literal value, the output is narrowed to ensure the first items are
+ * guaranteed.
+ * @signature
+ *   P.hasAtLeast(minimum)(data)
+ * @example
+ *   P.pipe([], P.hasAtLeast(4)); // => false
+ *
+ *   const data = [[1,2], [3], [4,5]];
+ *   P.pipe(
+ *     data,
+ *     P.filter(P.hasAtLeast(2)),
+ *     P.map(([, second]) => second),
+ *   ); // => [2,5], with type `number[]`
+ * @dataLast
+ * @category Array
+ */
+declare function hasAtLeast<N extends number>(minimum: IsNumericLiteral<N> extends true ? N : never): <T extends IterableContainer>(data: IterableContainer | T) => data is ArrayRequiredPrefix<T, N>;
+declare function hasAtLeast(minimum: number): (data: IterableContainer) => boolean;
+//#endregion
+export { hasAtLeast };
+//# sourceMappingURL=has-at-least.d.cts.map

package/dist/has-at-least.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-at-least.d.cts","names":[],"sources":["../src/has-at-least.ts"],"sourcesContent":[],"mappings":";;;;;;;;AA2BA;;;;;;;;;;;AAIA;AA0BA;;;;;;;;AAIoC,iBAlCpB,UAkCoB,CAAA,UAlCC,iBAkCD,EAAA,UAAA,MAAA,CAAA,CAAA,IAAA,EAjC5B,iBAiC4B,GAjCR,CAiCQ,EAAA,OAAA,EAhCzB,gBAgCyB,CAhCR,CAgCQ,CAAA,SAAA,IAAA,GAhCU,CAgCV,GAAA,KAAA,CAAA,EAAA,IAAA,IA/BzB,mBA+ByB,CA/BL,CA+BK,EA/BF,CA+BE,CAAA;AAAvB,iBA9BG,UAAA,CA8BH,IAAA,EA9BoB,iBA8BpB,EAAA,OAAA,EAAA,MAAA,CAAA,EAAA,OAAA;;AACb;;;;;;;;;;;;;;;;;;;;;;;iBALgB,sCACL,iBAAiB,kBAAkB,uBAChC,yBACN,oBAAoB,cACf,oBAAoB,GAAG;iBACpB,UAAA,0BAEN"}

package/dist/has-at-least.d.ts

@@ -1,8 +1,59 @@
-import "./iterable-container-F9CDF7ym.js";
-import "./perkakas-type-error-2yBU0Drj.js";
-import "./tuple-parts-Du2iVN8H.js";
-import "./clamped-integer-subtract-Dh3vTnRH.js";
-import "./coerced-array-Fezc8pIu.js";
-import "./array-required-prefix-BHFg-BKr.js";
-import { hasAtLeast } from "./has-at-least-QYnhvh7S.js";
-export { hasAtLeast };
+import { t as IterableContainer } from "./iterable-container-Dv5vSKht.js";
+import { t as ArrayRequiredPrefix } from "./array-required-prefix-DwpaLy0D.js";
+import { IsNumericLiteral } from "type-fest";
+
+//#region src/has-at-least.d.ts
+
+/**
+ * Checks if the given array has at least the defined number of elements. When
+ * the minimum used is a literal (e.g. `3`) the output is refined accordingly so
+ * that those indices are defined when accessing the array even when using
+ * typescript's 'noUncheckedIndexAccess'.
+ *
+ * @param data - The input array.
+ * @param minimum - The minimum number of elements the array must have.
+ * @returns True if the array's length is *at least* `minimum`. When `minimum`
+ * is a literal value, the output is narrowed to ensure the first items are
+ * guaranteed.
+ * @signature
+ *   P.hasAtLeast(data, minimum)
+ * @example
+ *   P.hasAtLeast([], 4); // => false
+ *
+ *   const data: number[] = [1,2,3,4];
+ *   P.hasAtLeast(data, 1); // => true
+ *   data[0]; // 1, with type `number`
+ * @dataFirst
+ * @category Array
+ */
+declare function hasAtLeast<T extends IterableContainer, N extends number>(data: IterableContainer | T, minimum: IsNumericLiteral<N> extends true ? N : never): data is ArrayRequiredPrefix<T, N>;
+declare function hasAtLeast(data: IterableContainer, minimum: number): boolean;
+/**
+ * Checks if the given array has at least the defined number of elements. When
+ * the minimum used is a literal (e.g. `3`) the output is refined accordingly so
+ * that those indices are defined when accessing the array even when using
+ * typescript's 'noUncheckedIndexAccess'.
+ *
+ * @param minimum - The minimum number of elements the array must have.
+ * @returns True if the array's length is *at least* `minimum`. When `minimum`
+ * is a literal value, the output is narrowed to ensure the first items are
+ * guaranteed.
+ * @signature
+ *   P.hasAtLeast(minimum)(data)
+ * @example
+ *   P.pipe([], P.hasAtLeast(4)); // => false
+ *
+ *   const data = [[1,2], [3], [4,5]];
+ *   P.pipe(
+ *     data,
+ *     P.filter(P.hasAtLeast(2)),
+ *     P.map(([, second]) => second),
+ *   ); // => [2,5], with type `number[]`
+ * @dataLast
+ * @category Array
+ */
+declare function hasAtLeast<N extends number>(minimum: IsNumericLiteral<N> extends true ? N : never): <T extends IterableContainer>(data: IterableContainer | T) => data is ArrayRequiredPrefix<T, N>;
+declare function hasAtLeast(minimum: number): (data: IterableContainer) => boolean;
+//#endregion
+export { hasAtLeast };
+//# sourceMappingURL=has-at-least.d.ts.map

package/dist/has-at-least.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-at-least.d.ts","names":[],"sources":["../src/has-at-least.ts"],"sourcesContent":[],"mappings":";;;;;;;;AA2BA;;;;;;;;;;;AAIA;AA0BA;;;;;;;;AAIoC,iBAlCpB,UAkCoB,CAAA,UAlCC,iBAkCD,EAAA,UAAA,MAAA,CAAA,CAAA,IAAA,EAjC5B,iBAiC4B,GAjCR,CAiCQ,EAAA,OAAA,EAhCzB,gBAgCyB,CAhCR,CAgCQ,CAAA,SAAA,IAAA,GAhCU,CAgCV,GAAA,KAAA,CAAA,EAAA,IAAA,IA/BzB,mBA+ByB,CA/BL,CA+BK,EA/BF,CA+BE,CAAA;AAAvB,iBA9BG,UAAA,CA8BH,IAAA,EA9BoB,iBA8BpB,EAAA,OAAA,EAAA,MAAA,CAAA,EAAA,OAAA;;AACb;;;;;;;;;;;;;;;;;;;;;;;iBALgB,sCACL,iBAAiB,kBAAkB,uBAChC,yBACN,oBAAoB,cACf,oBAAoB,GAAG;iBACpB,UAAA,0BAEN"}

package/dist/has-at-least.js

@@ -1 +1 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{hasAtLeast as e}from"./has-at-least-6iRvhsST.js";export{e as hasAtLeast};
+import{t as e}from"./has-at-least-Coy9sM-B.js";export{e as hasAtLeast};

package/dist/has-sub-object.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`),require(`./is-deep-equal-DR9xJg8D.cjs`);const e=require(`./has-sub-object-DjlCWSUi.cjs`);exports.hasSubObject=e.hasSubObject;
+const e=require(`./curry-BsY0Z8jH.cjs`),t=require(`./is-deep-equal.cjs`);function n(...t){return e.t(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;

package/dist/has-sub-object.d.cts

@@ -1,2 +1,44 @@
-import { hasSubObject } from "./has-sub-object-oUnH6b7a.cjs";
-export { hasSubObject };
+import { Simplify, Tagged } from "type-fest";
+
+//#region src/has-sub-object.d.ts
+declare const HAS_SUB_OBJECT_BRAND: unique symbol;
+type HasSubObjectGuard<T, S> = Simplify<Tagged<S & T, typeof HAS_SUB_OBJECT_BRAND>>;
+type HasSubObjectObjectValue<A, B> = Partial<{ [Key in keyof A & keyof B]: A[Key] & B[Key] extends never ? B[Key] : A[Key] | B[Key] extends object ? HasSubObjectObjectValue<A[Key], B[Key]> : A[Key] & B[Key] extends object ? B[Key] : A[Key] }> & { [Key in Exclude<keyof A, keyof B> | Exclude<keyof B, keyof A>]: Key extends keyof B ? B[Key] : never };
+type HasSubObjectData<Data, SubObject, RData = Required<Data>, RSubObject = Required<SubObject>> = Partial<{ [Key in keyof RData & keyof RSubObject]: RData[Key] & RSubObject[Key] extends never ? RSubObject[Key] : RData[Key] | RSubObject[Key] extends object ? HasSubObjectObjectValue<RData[Key], RSubObject[Key]> : RData[Key] & RSubObject[Key] extends object ? RSubObject[Key] : RData[Key] }> & { [Key in Exclude<keyof SubObject, keyof Data>]: SubObject[Key] };
+type HasSubObjectSubObject<SubObject, Data, RSubObject = Required<SubObject>, RData = Required<Data>> = Partial<{ [Key in keyof RData & keyof RSubObject]: RData[Key] & RSubObject[Key] extends never ? RData[Key] : RData[Key] | RSubObject[Key] extends object ? HasSubObjectObjectValue<RSubObject[Key], RData[Key]> : RData[Key] & RSubObject[Key] extends object ? RData[Key] : RSubObject[Key] }> & Record<Exclude<keyof SubObject, keyof Data>, never>;
+/**
+ * Checks if `subObject` is a sub-object of `object`, which means for every
+ * property and value in `subObject`, there's the same property in `object`
+ * with an equal value. Equality is checked with `isDeepEqual`.
+ *
+ * @param data - The object to test.
+ * @param subObject - The sub-object to test against.
+ * @signature
+ *    P.hasSubObject(data, subObject)
+ * @example
+ *    P.hasSubObject({ a: 1, b: 2, c: 3 }, { a: 1, c: 3 }) //=> true
+ *    P.hasSubObject({ a: 1, b: 2, c: 3 }, { b: 4 }) //=> false
+ *    P.hasSubObject({ a: 1, b: 2, c: 3 }, {}) //=> true
+ * @dataFirst
+ * @category Guard
+ */
+declare function hasSubObject<T extends object, S extends HasSubObjectSubObject<S, T>>(data: T, subObject: S): data is HasSubObjectGuard<T, S>;
+/**
+ * Checks if `subObject` is a sub-object of `object`, which means for every
+ * property and value in `subObject`, there's the same property in `object`
+ * with an equal value. Equality is checked with `isDeepEqual`.
+ *
+ * @param subObject - The sub-object to test against.
+ * @signature
+ *    P.hasSubObject(subObject)(data)
+ * @example
+ *    P.hasSubObject({ a: 1, c: 3 })({ a: 1, b: 2, c: 3 }) //=> true
+ *    P.hasSubObject({ b: 4 })({ a: 1, b: 2, c: 3 }) //=> false
+ *    P.hasSubObject({})({ a: 1, b: 2, c: 3 }) //=> true
+ * @dataLast
+ * @category Guard
+ */
+declare function hasSubObject<S extends object>(subObject: S): <T extends HasSubObjectData<T, S>>(data: T) => data is HasSubObjectGuard<T, S>;
+//#endregion
+export { hasSubObject };
+//# sourceMappingURL=has-sub-object.d.cts.map

package/dist/has-sub-object.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-sub-object.d.cts","names":[],"sources":["../src/has-sub-object.ts"],"sourcesContent":[],"mappings":";;;cAKc;KAET,0BAA0B,SAC7B,OAAO,IAAI,UAAU;AAR2B,KAW7C,uBAN4C,CAAA,CAAA,EAAA,CAAA,CAAA,GAMZ,OANY,CAAA,UAE5C,MAKW,CALX,GAAA,MAKqB,CALJ,GAKQ,CALR,CAKU,GALV,CAAA,GAKiB,CALjB,CAKmB,GALnB,CAAA,SAAA,KAAA,GAMhB,CANgB,CAMd,GANc,CAAA,GAOhB,CAPgB,CAOd,GAPc,CAAA,GAOP,CAPO,CAOL,GAPK,CAAA,SAAA,MAAA,GAQd,uBARc,CAQU,CARV,CAQY,GARZ,CAAA,EAQkB,CARlB,CAQoB,GARpB,CAAA,CAAA,GASd,CATc,CASZ,GATY,CAAA,GASL,CATK,CASH,GATG,CAAA,SAAA,MAAA,GAUZ,CAVY,CAUV,GAVU,CAAA,GAWZ,CAXY,CAWV,GAXU,CAAA,EACb,CAAA,GAAA,UAaL,OAbS,CAAA,MAaK,CAbL,EAAA,MAac,CAbd,CAAA,GAcT,OAdS,CAAA,MAcK,CAdL,EAAA,MAcc,CAdd,CAAA,GAcmB,GAdnB,SAAA,MAcqC,CAdrC,GAcyC,CAdzC,CAc2C,GAd3C,CAAA,GAAA,KAAA,EAAU;KAiBlB,gBAjBH,CAAA,IAAA,EAAA,SAAA,EAAA,QAoBQ,QApBR,CAoBiB,IApBjB,CAAA,EAAA,aAqBa,QArBb,CAqBsB,SArBtB,CAAA,CAAA,GAsBE,OAtBF,CAAA,UAD6B,MAwBf,KAxBe,GAAA,MAwBD,UAxBC,GAwBY,KAxBZ,CAwBkB,GAxBlB,CAAA,GAyBzB,UAzByB,CAyBd,GAzBc,CAAA,SAAA,KAAA,GA0BzB,UA1ByB,CA0Bd,GA1Bc,CAAA,GA2BzB,KA3ByB,CA2BnB,GA3BmB,CAAA,GA2BZ,UA3BY,CA2BD,GA3BC,CAAA,SAAA,MAAA,GA4BvB,uBA5BuB,CA4BC,KA5BD,CA4BO,GA5BP,CAAA,EA4Ba,UA5Bb,CA4BwB,GA5BxB,CAAA,CAAA,GA6BvB,KA7BuB,CA6BjB,GA7BiB,CAAA,GA6BV,UA7BU,CA6BC,GA7BD,CAAA,SAAA,MAAA,GA8BrB,UA9BqB,CA8BV,GA9BU,CAAA,GA+BrB,KA/BqB,CA+Bf,GA/Be,CAAA,EAAQ,CAAA,GAAA,UAiC7B,OA7BL,CAAA,MA6BmB,SA7BI,EAAA,MA6Ba,IA7Bb,CAAA,GA6BqB,SA7BrB,CA6B+B,GA7B/B,CAAA,EACZ;KA+BX,qBA/BqB,CAAA,SAAA,EAAA,IAAA,EAAA,aAkCX,QAlCW,CAkCF,SAlCE,CAAA,EAAA,QAmChB,QAnCgB,CAmCP,IAnCO,CAAA,CAAA,GAoCtB,OApCsB,CAAA,UAAI,MAqCd,KArCc,GAAA,MAqCA,UArCA,GAqCa,KArCb,CAqCmB,GArCnB,CAAA,GAsCxB,UAtCwB,CAsCb,GAtCa,CAAA,SAAA,KAAA,GAuCxB,KAvCwB,CAuClB,GAvCkB,CAAA,GAwCxB,KAxCwB,CAwClB,GAxCkB,CAAA,GAwCX,UAxCW,CAwCA,GAxCA,CAAA,SAAA,MAAA,GAyCtB,uBAzCsB,CAyCE,UAzCF,CAyCa,GAzCb,CAAA,EAyCmB,KAzCnB,CAyCyB,GAzCzB,CAAA,CAAA,GA0CtB,KA1CsB,CA0ChB,GA1CgB,CAAA,GA0CT,UA1CS,CA0CE,GA1CF,CAAA,SAAA,MAAA,GA2CpB,KA3CoB,CA2Cd,GA3Cc,CAAA,GA4CpB,UA5CoB,CA4CT,GA5CS,CAAA,EAAE,CAAA,GA8C9B,MA9C8B,CA8CvB,OA9CuB,CAAA,MA8CT,SA9CS,EAAA,MA8CQ,IA9CR,CAAA,EAAA,KAAA,CAAA;;;;;;;;;;;;;;;;;AAIb,iBA4DH,YA5DG,CAAA,UAAA,MAAA,EAAA,UA8DP,qBA9DO,CA8De,CA9Df,EA8DkB,CA9DlB,CAAA,CAAA,CAAA,IAAA,EA+DX,CA/DW,EAAA,SAAA,EA+DG,CA/DH,CAAA,EAAA,IAAA,IA+De,iBA/Df,CA+DiC,CA/DjC,EA+DoC,CA/DpC,CAAA;;;;;;;;;;;;;;;;AAMwC,iBA0E3C,YA1E2C,CAAA,UAAA,MAAA,CAAA,CAAA,SAAA,EA2E9C,CA3E8C,CAAA,EAAA,CAAA,UA4E7C,gBA5E6C,CA4E5B,CA5E4B,EA4EzB,CA5EyB,CAAA,CAAA,CAAA,IAAA,EA6EnD,CA7EmD,EAAA,GAAA,IAAA,IA8E9C,iBA9E8C,CA8E5B,CA9E4B,EA8EzB,CA9EyB,CAAA"}

package/dist/has-sub-object.d.ts

@@ -1,2 +1,44 @@
-import { hasSubObject } from "./has-sub-object-tnHnkr8o.js";
-export { hasSubObject };
+import { Simplify, Tagged } from "type-fest";
+
+//#region src/has-sub-object.d.ts
+declare const HAS_SUB_OBJECT_BRAND: unique symbol;
+type HasSubObjectGuard<T, S> = Simplify<Tagged<S & T, typeof HAS_SUB_OBJECT_BRAND>>;
+type HasSubObjectObjectValue<A, B> = Partial<{ [Key in keyof A & keyof B]: A[Key] & B[Key] extends never ? B[Key] : A[Key] | B[Key] extends object ? HasSubObjectObjectValue<A[Key], B[Key]> : A[Key] & B[Key] extends object ? B[Key] : A[Key] }> & { [Key in Exclude<keyof A, keyof B> | Exclude<keyof B, keyof A>]: Key extends keyof B ? B[Key] : never };
+type HasSubObjectData<Data, SubObject, RData = Required<Data>, RSubObject = Required<SubObject>> = Partial<{ [Key in keyof RData & keyof RSubObject]: RData[Key] & RSubObject[Key] extends never ? RSubObject[Key] : RData[Key] | RSubObject[Key] extends object ? HasSubObjectObjectValue<RData[Key], RSubObject[Key]> : RData[Key] & RSubObject[Key] extends object ? RSubObject[Key] : RData[Key] }> & { [Key in Exclude<keyof SubObject, keyof Data>]: SubObject[Key] };
+type HasSubObjectSubObject<SubObject, Data, RSubObject = Required<SubObject>, RData = Required<Data>> = Partial<{ [Key in keyof RData & keyof RSubObject]: RData[Key] & RSubObject[Key] extends never ? RData[Key] : RData[Key] | RSubObject[Key] extends object ? HasSubObjectObjectValue<RSubObject[Key], RData[Key]> : RData[Key] & RSubObject[Key] extends object ? RData[Key] : RSubObject[Key] }> & Record<Exclude<keyof SubObject, keyof Data>, never>;
+/**
+ * Checks if `subObject` is a sub-object of `object`, which means for every
+ * property and value in `subObject`, there's the same property in `object`
+ * with an equal value. Equality is checked with `isDeepEqual`.
+ *
+ * @param data - The object to test.
+ * @param subObject - The sub-object to test against.
+ * @signature
+ *    P.hasSubObject(data, subObject)
+ * @example
+ *    P.hasSubObject({ a: 1, b: 2, c: 3 }, { a: 1, c: 3 }) //=> true
+ *    P.hasSubObject({ a: 1, b: 2, c: 3 }, { b: 4 }) //=> false
+ *    P.hasSubObject({ a: 1, b: 2, c: 3 }, {}) //=> true
+ * @dataFirst
+ * @category Guard
+ */
+declare function hasSubObject<T extends object, S extends HasSubObjectSubObject<S, T>>(data: T, subObject: S): data is HasSubObjectGuard<T, S>;
+/**
+ * Checks if `subObject` is a sub-object of `object`, which means for every
+ * property and value in `subObject`, there's the same property in `object`
+ * with an equal value. Equality is checked with `isDeepEqual`.
+ *
+ * @param subObject - The sub-object to test against.
+ * @signature
+ *    P.hasSubObject(subObject)(data)
+ * @example
+ *    P.hasSubObject({ a: 1, c: 3 })({ a: 1, b: 2, c: 3 }) //=> true
+ *    P.hasSubObject({ b: 4 })({ a: 1, b: 2, c: 3 }) //=> false
+ *    P.hasSubObject({})({ a: 1, b: 2, c: 3 }) //=> true
+ * @dataLast
+ * @category Guard
+ */
+declare function hasSubObject<S extends object>(subObject: S): <T extends HasSubObjectData<T, S>>(data: T) => data is HasSubObjectGuard<T, S>;
+//#endregion
+export { hasSubObject };
+//# sourceMappingURL=has-sub-object.d.ts.map

package/dist/has-sub-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-sub-object.d.ts","names":[],"sources":["../src/has-sub-object.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/has-sub-object.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import"./is-deep-equal-D7dqs3e2.js";import{hasSubObject as e}from"./has-sub-object-C7LwzJ88.js";export{e as hasSubObject};
+import{t as e}from"./curry-NmniqyJ0.js";import{isDeepEqual as t}from"./is-deep-equal.js";function n(...t){return e(r,t)}function r(e,n){for(let[r,i]of Object.entries(n))if(!Object.hasOwn(e,r)||!t(i,e[r]))return!1;return!0}export{n as hasSubObject};
+//# sourceMappingURL=has-sub-object.js.map

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

@@ -0,0 +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 *    P.hasSubObject(data, subObject)\n * @example\n *    P.hasSubObject({ a: 1, b: 2, c: 3 }, { a: 1, c: 3 }) //=> true\n *    P.hasSubObject({ a: 1, b: 2, c: 3 }, { b: 4 }) //=> false\n *    P.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 *    P.hasSubObject(subObject)(data)\n * @example\n *    P.hasSubObject({ a: 1, c: 3 })({ a: 1, b: 2, c: 3 }) //=> true\n *    P.hasSubObject({ b: 4 })({ a: 1, b: 2, c: 3 }) //=> false\n *    P.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":"yFAsGA,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"}

package/dist/heap-BhpfhYWj.js

@@ -0,0 +1,2 @@
+import{t as e}from"./has-at-least-Coy9sM-B.js";import{t}from"./swap-in-place-C_jXKHuD.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-BhpfhYWj.js.map

package/dist/heap-BhpfhYWj.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"heap-BhpfhYWj.js","names":[],"sources":["../src/internal/heap.ts"],"sourcesContent":["/**\n * Heap related utilities.\n */\n\nimport type { CompareFunction } from './types/compare-function';\n\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\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\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\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":"0FAiBA,SAAgB,EAEd,EACA,EACM,CACN,IAAK,IAAI,EAAI,KAAK,MAAM,EAAK,OAAS,EAAE,CAAG,EAAG,GAAK,EAAG,IACpD,EAAa,EAAM,EAAG,EAAU,CAgBpC,SAAgB,EAEd,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,EAEP,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,EAEvD,EACA,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"}

package/dist/heap-DWDhbxfx.cjs

@@ -0,0 +1 @@
+const e=require(`./has-at-least-BXwOPLQK.cjs`),t=require(`./swap-in-place-BHkB_mvV.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.t(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}});

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

@@ -1 +1 @@
-const e=require(`./human-readable-file-size-BtprvwQj.cjs`);exports.humanReadableFileSize=e.humanReadableFileSize;
+function e(e,t=1e3){if(e<t)return`${e} B`;let n=t===1024?[`Ki`,`Mi`,`Gi`]:[`k`,`M`,`G`],r=-1;for(;Math.abs(e)>=t&&r<n.length-1;)e/=t,++r;return`${e.toFixed(1)} ${n[r]}B`}exports.humanReadableFileSize=e;

package/dist/human-readable-file-size.d.cts

@@ -1,2 +1,17 @@
-import { humanReadableFileSize } from "./human-readable-file-size-DtwHNZes.cjs";
-export { humanReadableFileSize };
+//#region src/human-readable-file-size.d.ts
+/**
+ * Returns human readable file size.
+ *
+ * @param bytes the file size in bytes
+ * @param base the base (1000 or 1024)
+ * @signature
+ *  P.humanReadableFileSize(bytes, base)
+ * @example
+ *  P.humanReadableFileSize(1000); // => '1.0 kB'
+ *  P.humanReadableFileSize(2097152, 1024); // => '2.0 Mib'
+ * @category String
+ */
+declare function humanReadableFileSize(bytes: number, base?: 1000 | 1024): string;
+//#endregion
+export { humanReadableFileSize };
+//# sourceMappingURL=human-readable-file-size.d.cts.map

package/dist/human-readable-file-size.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"human-readable-file-size.d.cts","names":[],"sources":["../src/human-readable-file-size.ts"],"sourcesContent":[],"mappings":";;AAYA;;;;;;;;;;;iBAAgB,qBAAA"}

package/dist/human-readable-file-size.d.ts

@@ -1,2 +1,17 @@
-import { humanReadableFileSize } from "./human-readable-file-size-D5VzlCuv.js";
-export { humanReadableFileSize };
+//#region src/human-readable-file-size.d.ts
+/**
+ * Returns human readable file size.
+ *
+ * @param bytes the file size in bytes
+ * @param base the base (1000 or 1024)
+ * @signature
+ *  P.humanReadableFileSize(bytes, base)
+ * @example
+ *  P.humanReadableFileSize(1000); // => '1.0 kB'
+ *  P.humanReadableFileSize(2097152, 1024); // => '2.0 Mib'
+ * @category String
+ */
+declare function humanReadableFileSize(bytes: number, base?: 1000 | 1024): string;
+//#endregion
+export { humanReadableFileSize };
+//# sourceMappingURL=human-readable-file-size.d.ts.map

package/dist/human-readable-file-size.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"human-readable-file-size.d.ts","names":[],"sources":["../src/human-readable-file-size.ts"],"sourcesContent":[],"mappings":";;AAYA;;;;;;;;;;;iBAAgB,qBAAA"}

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

@@ -1 +1,2 @@
-import{humanReadableFileSize as e}from"./human-readable-file-size-CPeHO1Te.js";export{e as humanReadableFileSize};
+function e(e,t=1e3){if(e<t)return`${e} B`;let n=t===1024?[`Ki`,`Mi`,`Gi`]:[`k`,`M`,`G`],r=-1;for(;Math.abs(e)>=t&&r<n.length-1;)e/=t,++r;return`${e.toFixed(1)} ${n[r]}B`}export{e as humanReadableFileSize};
+//# sourceMappingURL=human-readable-file-size.js.map

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

@@ -0,0 +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"}

package/dist/identity.cjs

@@ -1 +1 @@
-const e=require(`./identity-BAryUWbs.cjs`);exports.identity=e.identity;
+function e(){return t}function t(e,...t){return e}exports.identity=e;

package/dist/identity.d.cts

@@ -1,2 +1,22 @@
-import { identity } from "./identity-CPDLj9Cq.cjs";
-export { identity };
+//#region src/identity.d.ts
+/**
+ * A function that returns the first argument passed to it.
+ *
+ * Notice that this is a dataLast impl where the function needs to be invoked
+ * to get the "do nothing" function.
+ *
+ * See also:
+ * `doNothing` - A function that doesn't return anything.
+ * `constant` - A function that ignores the input arguments and returns the same value on every invocation.
+ *
+ * @signature
+ *    P.identity();
+ * @example
+ *    P.map([1,2,3], P.identity()); // => [1,2,3]
+ * @category Function
+ */
+declare function identity(): typeof identityImplementation;
+declare function identityImplementation<T, Args extends ReadonlyArray<unknown>>(value: T, ..._args: Args): T;
+//#endregion
+export { identity };
+//# sourceMappingURL=identity.d.cts.map

package/dist/identity.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.d.cts","names":[],"sources":["../src/identity.ts"],"sourcesContent":[],"mappings":";;AAgBA;AAQC;;;;;;;;;;;;;;iBARe,QAAA,CAAA,UAAmB;iBAU1B,uCAAuC,+BACvC,aAEG,OACT"}

package/dist/identity.d.ts

@@ -1,2 +1,22 @@
-import { identity } from "./identity-D3aX0VUB.js";
-export { identity };
+//#region src/identity.d.ts
+/**
+ * A function that returns the first argument passed to it.
+ *
+ * Notice that this is a dataLast impl where the function needs to be invoked
+ * to get the "do nothing" function.
+ *
+ * See also:
+ * `doNothing` - A function that doesn't return anything.
+ * `constant` - A function that ignores the input arguments and returns the same value on every invocation.
+ *
+ * @signature
+ *    P.identity();
+ * @example
+ *    P.map([1,2,3], P.identity()); // => [1,2,3]
+ * @category Function
+ */
+declare function identity(): typeof identityImplementation;
+declare function identityImplementation<T, Args extends ReadonlyArray<unknown>>(value: T, ..._args: Args): T;
+//#endregion
+export { identity };
+//# sourceMappingURL=identity.d.ts.map

package/dist/identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.d.ts","names":[],"sources":["../src/identity.ts"],"sourcesContent":[],"mappings":";;AAgBA;AAQC;;;;;;;;;;;;;;iBARe,QAAA,CAAA,UAAmB;iBAU1B,uCAAuC,+BACvC,aAEG,OACT"}

package/dist/identity.js

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

package/dist/identity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.js","names":[],"sources":["../src/identity.ts"],"sourcesContent":["/**\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 *    P.identity();\n * @example\n *    P.map([1,2,3], P.identity()); // => [1,2,3]\n * @category Function\n */\nexport function identity(): typeof identityImplementation {\n  /**\n   * Notice that the exported identity function is just the \"factory\" for the\n   * function. We do it this way so that all \"Function\" utilities have a similar\n   * API where the function is called, and not just used \"headless\". e.g.\n   * `doNothing()` and not `doNothing`, just like the API for `constant(1)`.\n   */\n  return identityImplementation;\n}\n\nfunction identityImplementation<T, Args extends ReadonlyArray<unknown>>(\n  value: T,\n  // Ignore any extra arguments provided to the function call\n  ..._args: Args\n): T {\n  return value;\n};\n"],"mappings":"AAgBA,SAAgB,GAA0C,CAOxD,OAAO,EAGT,SAAS,EACP,EAEA,GAAG,EACA,CACH,OAAO"}

package/dist/index-by.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./index-by-BJH9P6kU.cjs`);exports.indexBy=e.indexBy;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(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;