@vinicunca/perkakas 1.13.2 → 1.14.0

package/dist/group-by.d.cts

@@ -1,69 +0,0 @@
-import { t as NonEmptyArray } from "./non-empty-array-NDjbHRjk.cjs";
-import { t as BoundedPartial } from "./bounded-partial-CtOsGqxa.cjs";
-
-//#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.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"group-by.d.cts","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.d.ts

@@ -1,69 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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/has-at-least-BXwOPLQK.cjs

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

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

@@ -1 +0,0 @@
-{"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.d.cts

@@ -1,59 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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,59 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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-sub-object.d.cts

@@ -1,44 +0,0 @@
-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

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

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

@@ -1,44 +0,0 @@
-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

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

package/dist/heap-BhpfhYWj.js

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

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

@@ -1 +0,0 @@
-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.d.cts

@@ -1,17 +0,0 @@
-//#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

@@ -1 +0,0 @@
-{"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,17 +0,0 @@
-//#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

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

package/dist/identity.d.cts

@@ -1,22 +0,0 @@
-//#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

@@ -1 +0,0 @@
-{"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,22 +0,0 @@
-//#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

@@ -1 +0,0 @@
-{"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/index-by.d.cts

@@ -1,53 +0,0 @@
-import { t as BoundedPartial } from "./bounded-partial-CtOsGqxa.cjs";
-
-//#region src/index-by.d.ts
-
-/**
- * Converts a list of objects into an object indexing the objects by the given
- * key.
- *
- * There are several other functions that could be used to build an object from
- * an array:
- * `fromKeys` - Builds an object from an array of *keys* and a mapper for values.
- * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.
- * `fromEntries` - Builds an object from an array of key-value pairs.
- * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.
- * Refer to the docs for more details.
- *
- * @param data - The array.
- * @param mapper - The indexing function.
- * @signature
- *    P.indexBy(array, fn)
- * @example
- *    P.indexBy(['one', 'two', 'three'], x => x.length) // => {3: 'two', 5: 'three'}
- * @dataFirst
- * @category Array
- */
-declare function indexBy<T, K extends PropertyKey>(data: ReadonlyArray<T>, mapper: (item: T, index: number, data: ReadonlyArray<T>) => K): BoundedPartial<Record<K, T>>;
-/**
- * Converts a list of objects into an object indexing the objects by the given
- * key.
- *
- * There are several other functions that could be used to build an object from
- * an array:
- * `fromKeys` - Builds an object from an array of *keys* and a mapper for values.
- * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.
- * `fromEntries` - Builds an object from an array of key-value pairs.
- * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.
- * Refer to the docs for more details.
- *
- * @param mapper - The indexing function.
- * @signature
- *    P.indexBy(fn)(array)
- * @example
- *    P.pipe(
- *      ['one', 'two', 'three'],
- *      P.indexBy(x => x.length)
- *    ) // => {3: 'two', 5: 'three'}
- * @dataLast
- * @category Array
- */
-declare function indexBy<T, K extends PropertyKey>(mapper: (item: T, index: number, data: ReadonlyArray<T>) => K): (data: ReadonlyArray<T>) => BoundedPartial<Record<K, T>>;
-//#endregion
-export { indexBy };
-//# sourceMappingURL=index-by.d.cts.map

package/dist/index-by.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-by.d.cts","names":[],"sources":["../src/index-by.ts"],"sourcesContent":[],"mappings":";;;;;;AAwBA;;;;;;;;;;;;;AA4BA;;;;;;AAEwB,iBA9BR,OA8BQ,CAAA,CAAA,EAAA,UA9Ba,WA8Bb,CAAA,CAAA,IAAA,EA7BhB,aA6BgB,CA7BF,CA6BE,CAAA,EAAA,MAAA,EAAA,CAAA,IAAA,EA5BP,CA4BO,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EA5BiB,aA4BjB,CA5B+B,CA4B/B,CAAA,EAAA,GA5BsC,CA4BtC,CAAA,EA3BrB,cA2BqB,CA3BN,MA2BM,CA3BC,CA2BD,EA3BI,CA2BJ,CAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;iBAFR,qBAAqB,4BACpB,wBAAwB,cAAc,OAAO,WACpD,cAAc,OAAO,eAAe,OAAO,GAAG"}

package/dist/index-by.d.ts

@@ -1,53 +0,0 @@
-import { t as BoundedPartial } from "./bounded-partial-CPc1XU57.js";
-
-//#region src/index-by.d.ts
-
-/**
- * Converts a list of objects into an object indexing the objects by the given
- * key.
- *
- * There are several other functions that could be used to build an object from
- * an array:
- * `fromKeys` - Builds an object from an array of *keys* and a mapper for values.
- * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.
- * `fromEntries` - Builds an object from an array of key-value pairs.
- * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.
- * Refer to the docs for more details.
- *
- * @param data - The array.
- * @param mapper - The indexing function.
- * @signature
- *    P.indexBy(array, fn)
- * @example
- *    P.indexBy(['one', 'two', 'three'], x => x.length) // => {3: 'two', 5: 'three'}
- * @dataFirst
- * @category Array
- */
-declare function indexBy<T, K extends PropertyKey>(data: ReadonlyArray<T>, mapper: (item: T, index: number, data: ReadonlyArray<T>) => K): BoundedPartial<Record<K, T>>;
-/**
- * Converts a list of objects into an object indexing the objects by the given
- * key.
- *
- * There are several other functions that could be used to build an object from
- * an array:
- * `fromKeys` - Builds an object from an array of *keys* and a mapper for values.
- * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.
- * `fromEntries` - Builds an object from an array of key-value pairs.
- * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.
- * Refer to the docs for more details.
- *
- * @param mapper - The indexing function.
- * @signature
- *    P.indexBy(fn)(array)
- * @example
- *    P.pipe(
- *      ['one', 'two', 'three'],
- *      P.indexBy(x => x.length)
- *    ) // => {3: 'two', 5: 'three'}
- * @dataLast
- * @category Array
- */
-declare function indexBy<T, K extends PropertyKey>(mapper: (item: T, index: number, data: ReadonlyArray<T>) => K): (data: ReadonlyArray<T>) => BoundedPartial<Record<K, T>>;
-//#endregion
-export { indexBy };
-//# sourceMappingURL=index-by.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index-by.d.ts","names":[],"sources":["../src/index-by.ts"],"sourcesContent":[],"mappings":";;;;;;AAwBA;;;;;;;;;;;;;AA4BA;;;;;;AAEwB,iBA9BR,OA8BQ,CAAA,CAAA,EAAA,UA9Ba,WA8Bb,CAAA,CAAA,IAAA,EA7BhB,aA6BgB,CA7BF,CA6BE,CAAA,EAAA,MAAA,EAAA,CAAA,IAAA,EA5BP,CA4BO,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EA5BiB,aA4BjB,CA5B+B,CA4B/B,CAAA,EAAA,GA5BsC,CA4BtC,CAAA,EA3BrB,cA2BqB,CA3BN,MA2BM,CA3BC,CA2BD,EA3BI,CA2BJ,CAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;iBAFR,qBAAqB,4BACpB,wBAAwB,cAAc,OAAO,WACpD,cAAc,OAAO,eAAe,OAAO,GAAG"}