@vinicunca/perkakas 1.4.0 → 1.6.0

package/dist/drop-first-by.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkOL2TQDYMcjs = require('./chunk-OL2TQDYM.cjs');require('./chunk-FLQYTU5W.cjs');require('./chunk-Z6OOXW67.cjs');require('./chunk-EROXO3T4.cjs');require('./chunk-GVYLRJPB.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');exports.dropFirstBy = _chunkOL2TQDYMcjs.a;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkBDBX4ZMWcjs = require('./chunk-BDBX4ZMW.cjs');require('./chunk-JHFSYEXB.cjs');require('./chunk-Z6OOXW67.cjs');require('./chunk-EROXO3T4.cjs');require('./chunk-66JP4PUG.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');exports.dropFirstBy = _chunkBDBX4ZMWcjs.a;

package/dist/drop-first-by.js

@@ -1 +1 @@
-import{a}from"./chunk-22IDCBFS.js";import"./chunk-WCPENZWH.js";import"./chunk-YYEJOSR3.js";import"./chunk-7KBK2RWQ.js";import"./chunk-DLXKXNZT.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";export{a as dropFirstBy};
+import{a}from"./chunk-GFXNX2W7.js";import"./chunk-JI5FJX2E.js";import"./chunk-YYEJOSR3.js";import"./chunk-7KBK2RWQ.js";import"./chunk-ITDJLXHO.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";export{a as dropFirstBy};

package/dist/drop.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkB5QDOWVQcjs = require('./chunk-B5QDOWVQ.cjs');require('./chunk-N5JE6642.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');exports.drop = _chunkB5QDOWVQcjs.a;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkR4O7XE2Fcjs = require('./chunk-R4O7XE2F.cjs');require('./chunk-N5JE6642.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');exports.drop = _chunkR4O7XE2Fcjs.a;

package/dist/drop.d.cts

@@ -1,37 +1,24 @@
-import { IfNever, IsNegative, IsInteger, Subtract } from 'type-fest';
+import { IsNegative, Writable, IsInteger } from 'type-fest';
+import { C as ClampedIntegerSubtract } from './clamped-integer-subtract-DZ7rsJE4.cjs';
+import { C as CoercedArray } from './coerced-array-DRz3tqda.cjs';
 import { I as IterableContainer } from './iterable-container-BTpDVdNc.cjs';
-import { N as NTuple } from './n-tuple-5jljrt4c.cjs';
-import { T as TupleParts } from './tuple-parts-CP0H7BrE.cjs';
+import { P as PartialArray } from './partial-array-Vnf1fBtl.cjs';
+import { T as TupleParts } from './tuple-parts-DAqFAJP8.cjs';
 
-/**
- * `never[]` and `[]` are not the same type, and in some cases they aren't
- * interchangeable.
- *
- * This type makes it easier to use the result of TupleParts when the input is a
- * fixed-length tuple but we still want to spread the rest of the array. e.g.
- * `[...CoercedArray<TupleParts<T>["item"]>, ...TupleParts<T>["suffix"]]`.
- *
- */
-type CoercedArray<T> = IfNever<T, [], Array<T>>;
-
-type Drop<T extends IterableContainer, N extends number> = IsNegative<N> extends true ? T : IsInteger<N> extends false ? Array<T[number]> : TupleParts<T>['prefix'] extends [
-    ...NTuple<unknown, N>,
-    ...infer Remaining
-] ? [
-    ...Remaining,
+type Drop<T extends IterableContainer, N extends number> = IsNegative<N> extends true ? Writable<T> : IsInteger<N> extends false ? Array<T[number]> : ClampedIntegerSubtract<N, TupleParts<T>['required']['length']> extends infer RemainingPrefix extends number ? RemainingPrefix extends 0 ? [
+    ...DropFixedTuple<TupleParts<T>['required'], N>,
+    ...PartialArray<TupleParts<T>['optional']>,
     ...CoercedArray<TupleParts<T>['item']>,
     ...TupleParts<T>['suffix']
-] : 0 extends TupleParts<T>['suffix']['length'] ? CoercedArray<TupleParts<T>['item']> : [...Array<TupleParts<T>['item']>, ...TupleParts<T>['suffix']] | DropUpTo<TupleParts<T>['suffix'], Subtract<N, TupleParts<T>['prefix']['length']>>;
-/**
- * Arrays with a fixed suffix will result in any number of items being dropped,
- * up to N, and not just N itself. This is because we don't know during typing
- * how many items the "rest" part of the tuple will have in runtime.
- *
- * !Important: This is an internal type and assumes that T is a fixed-size
- * tuple! It will not work if T has a rest element.
- */
-type DropUpTo<T, N, Dropped extends ReadonlyArray<unknown> = []> = Dropped['length'] extends N ? T : T extends [unknown, ...infer Rest] ? // Take the current value, and then recurse with the array where it is
-DropUpTo<Rest, N, [...Dropped, unknown]> | T : T;
+] : ClampedIntegerSubtract<RemainingPrefix, TupleParts<T>['optional']['length']> extends infer RemainingOptional extends number ? RemainingOptional extends 0 ? [
+    ...PartialArray<DropFixedTuple<TupleParts<T>['optional'], RemainingPrefix>>,
+    ...CoercedArray<TupleParts<T>['item']>,
+    ...TupleParts<T>['suffix']
+] : [
+    ...CoercedArray<TupleParts<T>['item']>,
+    ...TupleParts<T>['suffix']
+] | Exclude<DropFixedTuple<TupleParts<T>['suffix'], RemainingOptional, true>, TupleParts<T>['suffix']> : never : never;
+type DropFixedTuple<T, N, IncludePrefixes = false, Dropped extends Array<unknown> = []> = Dropped['length'] extends N ? T : T extends readonly [unknown, ...infer Rest] ? DropFixedTuple<Rest, N, IncludePrefixes, [...Dropped, unknown]> | (true extends IncludePrefixes ? T : never) : [];
 /**
  * Removes first `n` elements from the `array`.
  *

package/dist/drop.d.ts

@@ -1,37 +1,24 @@
-import { IfNever, IsNegative, IsInteger, Subtract } from 'type-fest';
+import { IsNegative, Writable, IsInteger } from 'type-fest';
+import { C as ClampedIntegerSubtract } from './clamped-integer-subtract-DZ7rsJE4.js';
+import { C as CoercedArray } from './coerced-array-DRz3tqda.js';
 import { I as IterableContainer } from './iterable-container-BTpDVdNc.js';
-import { N as NTuple } from './n-tuple-5jljrt4c.js';
-import { T as TupleParts } from './tuple-parts-CP0H7BrE.js';
+import { P as PartialArray } from './partial-array-Vnf1fBtl.js';
+import { T as TupleParts } from './tuple-parts-CrwnkDKX.js';
 
-/**
- * `never[]` and `[]` are not the same type, and in some cases they aren't
- * interchangeable.
- *
- * This type makes it easier to use the result of TupleParts when the input is a
- * fixed-length tuple but we still want to spread the rest of the array. e.g.
- * `[...CoercedArray<TupleParts<T>["item"]>, ...TupleParts<T>["suffix"]]`.
- *
- */
-type CoercedArray<T> = IfNever<T, [], Array<T>>;
-
-type Drop<T extends IterableContainer, N extends number> = IsNegative<N> extends true ? T : IsInteger<N> extends false ? Array<T[number]> : TupleParts<T>['prefix'] extends [
-    ...NTuple<unknown, N>,
-    ...infer Remaining
-] ? [
-    ...Remaining,
+type Drop<T extends IterableContainer, N extends number> = IsNegative<N> extends true ? Writable<T> : IsInteger<N> extends false ? Array<T[number]> : ClampedIntegerSubtract<N, TupleParts<T>['required']['length']> extends infer RemainingPrefix extends number ? RemainingPrefix extends 0 ? [
+    ...DropFixedTuple<TupleParts<T>['required'], N>,
+    ...PartialArray<TupleParts<T>['optional']>,
     ...CoercedArray<TupleParts<T>['item']>,
     ...TupleParts<T>['suffix']
-] : 0 extends TupleParts<T>['suffix']['length'] ? CoercedArray<TupleParts<T>['item']> : [...Array<TupleParts<T>['item']>, ...TupleParts<T>['suffix']] | DropUpTo<TupleParts<T>['suffix'], Subtract<N, TupleParts<T>['prefix']['length']>>;
-/**
- * Arrays with a fixed suffix will result in any number of items being dropped,
- * up to N, and not just N itself. This is because we don't know during typing
- * how many items the "rest" part of the tuple will have in runtime.
- *
- * !Important: This is an internal type and assumes that T is a fixed-size
- * tuple! It will not work if T has a rest element.
- */
-type DropUpTo<T, N, Dropped extends ReadonlyArray<unknown> = []> = Dropped['length'] extends N ? T : T extends [unknown, ...infer Rest] ? // Take the current value, and then recurse with the array where it is
-DropUpTo<Rest, N, [...Dropped, unknown]> | T : T;
+] : ClampedIntegerSubtract<RemainingPrefix, TupleParts<T>['optional']['length']> extends infer RemainingOptional extends number ? RemainingOptional extends 0 ? [
+    ...PartialArray<DropFixedTuple<TupleParts<T>['optional'], RemainingPrefix>>,
+    ...CoercedArray<TupleParts<T>['item']>,
+    ...TupleParts<T>['suffix']
+] : [
+    ...CoercedArray<TupleParts<T>['item']>,
+    ...TupleParts<T>['suffix']
+] | Exclude<DropFixedTuple<TupleParts<T>['suffix'], RemainingOptional, true>, TupleParts<T>['suffix']> : never : never;
+type DropFixedTuple<T, N, IncludePrefixes = false, Dropped extends Array<unknown> = []> = Dropped['length'] extends N ? T : T extends readonly [unknown, ...infer Rest] ? DropFixedTuple<Rest, N, IncludePrefixes, [...Dropped, unknown]> | (true extends IncludePrefixes ? T : never) : [];
 /**
  * Removes first `n` elements from the `array`.
  *

package/dist/drop.js

@@ -1 +1 @@
-import{a}from"./chunk-OEJ5J23C.js";import"./chunk-EPU4K3DD.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";export{a as drop};
+import{a}from"./chunk-YCSQX2SY.js";import"./chunk-EPU4K3DD.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";export{a as drop};

package/dist/filter.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunk6ENW2VLCcjs = require('./chunk-6ENW2VLC.cjs');require('./chunk-N5JE6642.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');exports.filter = _chunk6ENW2VLCcjs.a;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunk3LC3CLYEcjs = require('./chunk-3LC3CLYE.cjs');require('./chunk-N5JE6642.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');exports.filter = _chunk3LC3CLYEcjs.a;

package/dist/filter.d.cts

@@ -1,3 +1,11 @@
+import { Writable } from 'type-fest';
+import { F as FilteredArray } from './filtered-array-DX6NNaBq.cjs';
+import { I as IterableContainer } from './iterable-container-BTpDVdNc.cjs';
+import './coerced-array-DRz3tqda.cjs';
+import './tuple-parts-DAqFAJP8.cjs';
+
+type NonRefinedFilteredArray<T extends IterableContainer, IsItemIncluded extends boolean> = boolean extends IsItemIncluded ? Array<T[number]> : IsItemIncluded extends true ? Writable<T> : [
+];
 /**
  * Creates a shallow copy of a portion of a given array, filtered down to just
  * the elements from the given array that pass the test implemented by the
@@ -17,8 +25,8 @@
  * @lazy
  * @category Array
  */
-declare function filter<T, S extends T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): Array<S>;
-declare function filter<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): Array<T>;
+declare function filter<T extends IterableContainer, Condition extends T[number]>(data: T, predicate: (value: T[number], index: number, data: T) => value is Condition): FilteredArray<T, Condition>;
+declare function filter<T extends IterableContainer, IsItemIncluded extends boolean>(data: T, predicate: (value: T[number], index: number, data: T) => IsItemIncluded): NonRefinedFilteredArray<T, IsItemIncluded>;
 /**
  * Creates a shallow copy of a portion of a given array, filtered down to just
  * the elements from the given array that pass the test implemented by the
@@ -37,7 +45,7 @@ declare function filter<T>(data: ReadonlyArray<T>, predicate: (value: T, index:
  * @lazy
  * @category Array
  */
-declare function filter<T, S extends T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): (data: ReadonlyArray<T>) => Array<S>;
-declare function filter<T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => Array<T>;
+declare function filter<T extends IterableContainer, Condition extends T[number]>(predicate: (value: T[number], index: number, data: T) => value is Condition): (data: T) => FilteredArray<T, Condition>;
+declare function filter<T extends IterableContainer, IsItemIncluded extends boolean>(predicate: (value: T[number], index: number, data: T) => IsItemIncluded): (data: T) => NonRefinedFilteredArray<T, IsItemIncluded>;
 
 export { filter };

package/dist/filter.d.ts

@@ -1,3 +1,11 @@
+import { Writable } from 'type-fest';
+import { F as FilteredArray } from './filtered-array-BNHX1Nwj.js';
+import { I as IterableContainer } from './iterable-container-BTpDVdNc.js';
+import './coerced-array-DRz3tqda.js';
+import './tuple-parts-CrwnkDKX.js';
+
+type NonRefinedFilteredArray<T extends IterableContainer, IsItemIncluded extends boolean> = boolean extends IsItemIncluded ? Array<T[number]> : IsItemIncluded extends true ? Writable<T> : [
+];
 /**
  * Creates a shallow copy of a portion of a given array, filtered down to just
  * the elements from the given array that pass the test implemented by the
@@ -17,8 +25,8 @@
  * @lazy
  * @category Array
  */
-declare function filter<T, S extends T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): Array<S>;
-declare function filter<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): Array<T>;
+declare function filter<T extends IterableContainer, Condition extends T[number]>(data: T, predicate: (value: T[number], index: number, data: T) => value is Condition): FilteredArray<T, Condition>;
+declare function filter<T extends IterableContainer, IsItemIncluded extends boolean>(data: T, predicate: (value: T[number], index: number, data: T) => IsItemIncluded): NonRefinedFilteredArray<T, IsItemIncluded>;
 /**
  * Creates a shallow copy of a portion of a given array, filtered down to just
  * the elements from the given array that pass the test implemented by the
@@ -37,7 +45,7 @@ declare function filter<T>(data: ReadonlyArray<T>, predicate: (value: T, index:
  * @lazy
  * @category Array
  */
-declare function filter<T, S extends T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): (data: ReadonlyArray<T>) => Array<S>;
-declare function filter<T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => Array<T>;
+declare function filter<T extends IterableContainer, Condition extends T[number]>(predicate: (value: T[number], index: number, data: T) => value is Condition): (data: T) => FilteredArray<T, Condition>;
+declare function filter<T extends IterableContainer, IsItemIncluded extends boolean>(predicate: (value: T[number], index: number, data: T) => IsItemIncluded): (data: T) => NonRefinedFilteredArray<T, IsItemIncluded>;
 
 export { filter };

package/dist/filter.js

@@ -1 +1 @@
-import{a}from"./chunk-PWHX2554.js";import"./chunk-EPU4K3DD.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";export{a as filter};
+import{a}from"./chunk-ZITGCTSW.js";import"./chunk-EPU4K3DD.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";export{a as filter};

package/dist/filtered-array-BNHX1Nwj.d.ts

@@ -0,0 +1,18 @@
+import { C as CoercedArray } from './coerced-array-DRz3tqda.js';
+import { I as IterableContainer } from './iterable-container-BTpDVdNc.js';
+import { T as TupleParts } from './tuple-parts-CrwnkDKX.js';
+
+type FilteredArray<T extends IterableContainer, Condition> = T extends unknown ? [
+    ...FilteredFixedTuple<TupleParts<T>['required'], Condition>,
+    ...FilteredFixedTuple<TupleParts<T>['optional'], Condition>,
+    ...CoercedArray<SymmetricRefine<TupleParts<T>['item'], Condition>>,
+    ...FilteredFixedTuple<TupleParts<T>['suffix'], Condition>
+] : never;
+type FilteredFixedTuple<T, Condition, Output extends Array<unknown> = []> = T extends readonly [infer Head, ...infer Rest] ? FilteredFixedTuple<Rest, Condition, Head extends Condition ? [
+    ...Output,
+    Head
+] : Head | Condition extends object ? Output : Condition extends Head ? // But for any other type (mostly primitives), if the condition
+Output | [...Output, Condition] : Output> : Output;
+type SymmetricRefine<Item, Condition> = Item extends Condition ? Item : Condition extends Item ? Condition : never;
+
+export type { FilteredArray as F };

package/dist/filtered-array-DX6NNaBq.d.cts

@@ -0,0 +1,18 @@
+import { C as CoercedArray } from './coerced-array-DRz3tqda.cjs';
+import { I as IterableContainer } from './iterable-container-BTpDVdNc.cjs';
+import { T as TupleParts } from './tuple-parts-DAqFAJP8.cjs';
+
+type FilteredArray<T extends IterableContainer, Condition> = T extends unknown ? [
+    ...FilteredFixedTuple<TupleParts<T>['required'], Condition>,
+    ...FilteredFixedTuple<TupleParts<T>['optional'], Condition>,
+    ...CoercedArray<SymmetricRefine<TupleParts<T>['item'], Condition>>,
+    ...FilteredFixedTuple<TupleParts<T>['suffix'], Condition>
+] : never;
+type FilteredFixedTuple<T, Condition, Output extends Array<unknown> = []> = T extends readonly [infer Head, ...infer Rest] ? FilteredFixedTuple<Rest, Condition, Head extends Condition ? [
+    ...Output,
+    Head
+] : Head | Condition extends object ? Output : Condition extends Head ? // But for any other type (mostly primitives), if the condition
+Output | [...Output, Condition] : Output> : Output;
+type SymmetricRefine<Item, Condition> = Item extends Condition ? Item : Condition extends Item ? Condition : never;
+
+export type { FilteredArray as F };

package/dist/first-by.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkQQMFHVPXcjs = require('./chunk-QQMFHVPX.cjs');require('./chunk-EROXO3T4.cjs');require('./chunk-GVYLRJPB.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');exports.firstBy = _chunkQQMFHVPXcjs.a;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkJ3ZXNDMTcjs = require('./chunk-J3ZXNDMT.cjs');require('./chunk-EROXO3T4.cjs');require('./chunk-66JP4PUG.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');exports.firstBy = _chunkJ3ZXNDMTcjs.a;

package/dist/first-by.js

@@ -1 +1 @@
-import{a}from"./chunk-Z46FX2Y4.js";import"./chunk-7KBK2RWQ.js";import"./chunk-DLXKXNZT.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";export{a as firstBy};
+import{a}from"./chunk-FP3LV577.js";import"./chunk-7KBK2RWQ.js";import"./chunk-ITDJLXHO.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";export{a as firstBy};

package/dist/from-keys.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkTHE6MSJOcjs = require('./chunk-THE6MSJO.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');exports.fromKeys = _chunkTHE6MSJOcjs.a;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkBEMQAYI5cjs = require('./chunk-BEMQAYI5.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');exports.fromKeys = _chunkBEMQAYI5cjs.a;

package/dist/from-keys.d.cts

@@ -1,12 +1,12 @@
 import { Simplify } from 'type-fest';
-import { E as ExactRecord } from './exact-record-_isi2JMR.cjs';
+import { B as BoundedPartial } from './bounded-partial-wqR8ceNQ.cjs';
 import { I as IterableContainer } from './iterable-container-BTpDVdNc.cjs';
 import './if-bounded-record-Drd4UbBU.cjs';
 
 type ExactlyOneKey<T, V> = T extends PropertyKey ? {
     [P in T]: V;
 } : never;
-type FromKeys<T extends IterableContainer, V> = T extends readonly [] ? {} : T extends readonly [infer Head, ...infer Rest] ? ExactlyOneKey<Head, V> & FromKeys<Rest, V> : T[number] extends PropertyKey ? ExactRecord<T[number], V> : never;
+type FromKeys<T extends IterableContainer, V> = T extends readonly [] ? {} : T extends readonly [infer Head, ...infer Rest] ? ExactlyOneKey<Head, V> & FromKeys<Rest, V> : T[number] extends PropertyKey ? BoundedPartial<Record<T[number], V>> : never;
 /**
  * Creates an object that maps each key in `data` to the result of `mapper` for
  * that key. Duplicate keys are overwritten, guaranteeing that `mapper` is run

package/dist/from-keys.d.ts

@@ -1,12 +1,12 @@
 import { Simplify } from 'type-fest';
-import { E as ExactRecord } from './exact-record-Dhbe_K-E.js';
+import { B as BoundedPartial } from './bounded-partial-CJjczH6j.js';
 import { I as IterableContainer } from './iterable-container-BTpDVdNc.js';
 import './if-bounded-record-Drd4UbBU.js';
 
 type ExactlyOneKey<T, V> = T extends PropertyKey ? {
     [P in T]: V;
 } : never;
-type FromKeys<T extends IterableContainer, V> = T extends readonly [] ? {} : T extends readonly [infer Head, ...infer Rest] ? ExactlyOneKey<Head, V> & FromKeys<Rest, V> : T[number] extends PropertyKey ? ExactRecord<T[number], V> : never;
+type FromKeys<T extends IterableContainer, V> = T extends readonly [] ? {} : T extends readonly [infer Head, ...infer Rest] ? ExactlyOneKey<Head, V> & FromKeys<Rest, V> : T[number] extends PropertyKey ? BoundedPartial<Record<T[number], V>> : never;
 /**
  * Creates an object that maps each key in `data` to the result of `mapper` for
  * that key. Duplicate keys are overwritten, guaranteeing that `mapper` is run

package/dist/from-keys.js

@@ -1 +1 @@
-import{a}from"./chunk-IJ4I5A3K.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";export{a as fromKeys};
+import{a}from"./chunk-TVMG2NYC.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";export{a as fromKeys};

package/dist/funnel.reference-batch.test.cjs

@@ -1 +1 @@
-"use strict"; function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }var _chunkTHE6MSJOcjs = require('./chunk-THE6MSJO.cjs');var _chunkGOUUMCT7cjs = require('./chunk-GOUUMCT7.cjs');var _chunkWYRK6YJUcjs = require('./chunk-WYRK6YJU.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');function i(e,a,n=0){let l=_chunkGOUUMCT7cjs.a.call(void 0, s=>{e(s.map(({params:t})=>t)).then(t=>{for(let[o,{params:r,promiseCallbacks:[c]}]of s.entries()){let y=a(t,o,...r);c(y)}}).catch(t=>{for(let{promiseCallbacks:[,o]}of s)o(t)})},{reducer:(s,t)=>[..._nullishCoalesce(s, () => ([])),t],maxBurstDurationMs:n,triggerAt:"end"});return{...l,call:async(...s)=>new Promise((...t)=>{l.call({promiseCallbacks:t,params:s})})}}describe("showcase",()=>{it("results as object",async()=>{let e=vi.fn(async o=>_chunkTHE6MSJOcjs.a.call(void 0, o,r=>r.length)),a=i(async o=>await e(o.flat()),(o,r,c)=>o[c]),n=[a.call("short"),a.call("medium"),a.call("loooooooooooooong")];expect(e).toHaveBeenCalledTimes(0);let[l,s,t]=await Promise.all(n);expect(e).toHaveBeenCalledTimes(1),expect(e).toHaveBeenLastCalledWith(["short","medium","loooooooooooooong"]),expect(e).toHaveLastResolvedWith({short:5,medium:6,loooooooooooooong:17}),expect(l).toBe(5),expect(s).toBe(6),expect(t).toBe(17)}),it("results as array",async()=>{let e=vi.fn(async o=>o.map(r=>r.length)),a=i(async o=>await e(o.flat()),(o,r)=>o[r]),n=[a.call("short"),a.call("medium"),a.call("loooooooooooooong")];expect(e).toHaveBeenCalledTimes(0);let[l,s,t]=await Promise.all(n);expect(e).toHaveBeenCalledTimes(1),expect(e).toHaveBeenLastCalledWith(["short","medium","loooooooooooooong"]),expect(e).toHaveLastResolvedWith([5,6,17]),expect(l).toBe(5),expect(s).toBe(6),expect(t).toBe(17)}),it("error handling",async()=>{let e=i(async a=>{if(a.length>1)throw new Error(`Batch too big! ${JSON.stringify(a)}`)},_chunkWYRK6YJUcjs.a.call(void 0, ));await expect(e.call("a")).resolves.toBeUndefined(),await expect(Promise.all([e.call("hello"),e.call("world")])).rejects.toThrow('Batch too big! [["hello"],["world"]]')})});
+"use strict"; function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }var _chunkBEMQAYI5cjs = require('./chunk-BEMQAYI5.cjs');var _chunkGOUUMCT7cjs = require('./chunk-GOUUMCT7.cjs');var _chunkWYRK6YJUcjs = require('./chunk-WYRK6YJU.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');function i(e,a,n=0){let l=_chunkGOUUMCT7cjs.a.call(void 0, s=>{e(s.map(({params:t})=>t)).then(t=>{for(let[o,{params:r,promiseCallbacks:[c]}]of s.entries()){let y=a(t,o,...r);c(y)}}).catch(t=>{for(let{promiseCallbacks:[,o]}of s)o(t)})},{reducer:(s,t)=>[..._nullishCoalesce(s, () => ([])),t],maxBurstDurationMs:n,triggerAt:"end"});return{...l,call:async(...s)=>new Promise((...t)=>{l.call({promiseCallbacks:t,params:s})})}}describe("showcase",()=>{it("results as object",async()=>{let e=vi.fn(async o=>_chunkBEMQAYI5cjs.a.call(void 0, o,r=>r.length)),a=i(async o=>await e(o.flat()),(o,r,c)=>o[c]),n=[a.call("short"),a.call("medium"),a.call("loooooooooooooong")];expect(e).toHaveBeenCalledTimes(0);let[l,s,t]=await Promise.all(n);expect(e).toHaveBeenCalledTimes(1),expect(e).toHaveBeenLastCalledWith(["short","medium","loooooooooooooong"]),expect(e).toHaveLastResolvedWith({short:5,medium:6,loooooooooooooong:17}),expect(l).toBe(5),expect(s).toBe(6),expect(t).toBe(17)}),it("results as array",async()=>{let e=vi.fn(async o=>o.map(r=>r.length)),a=i(async o=>await e(o.flat()),(o,r)=>o[r]),n=[a.call("short"),a.call("medium"),a.call("loooooooooooooong")];expect(e).toHaveBeenCalledTimes(0);let[l,s,t]=await Promise.all(n);expect(e).toHaveBeenCalledTimes(1),expect(e).toHaveBeenLastCalledWith(["short","medium","loooooooooooooong"]),expect(e).toHaveLastResolvedWith([5,6,17]),expect(l).toBe(5),expect(s).toBe(6),expect(t).toBe(17)}),it("error handling",async()=>{let e=i(async a=>{if(a.length>1)throw new Error(`Batch too big! ${JSON.stringify(a)}`)},_chunkWYRK6YJUcjs.a.call(void 0, ));await expect(e.call("a")).resolves.toBeUndefined(),await expect(Promise.all([e.call("hello"),e.call("world")])).rejects.toThrow('Batch too big! [["hello"],["world"]]')})});

package/dist/funnel.reference-batch.test.js

@@ -1 +1 @@
-import{a as d}from"./chunk-IJ4I5A3K.js";import{a as p}from"./chunk-AWXJSK4F.js";import{a as m}from"./chunk-AFO7BV2X.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";function i(e,a,n=0){let l=p(s=>{e(s.map(({params:t})=>t)).then(t=>{for(let[o,{params:r,promiseCallbacks:[c]}]of s.entries()){let y=a(t,o,...r);c(y)}}).catch(t=>{for(let{promiseCallbacks:[,o]}of s)o(t)})},{reducer:(s,t)=>[...s??[],t],maxBurstDurationMs:n,triggerAt:"end"});return{...l,call:async(...s)=>new Promise((...t)=>{l.call({promiseCallbacks:t,params:s})})}}describe("showcase",()=>{it("results as object",async()=>{let e=vi.fn(async o=>d(o,r=>r.length)),a=i(async o=>await e(o.flat()),(o,r,c)=>o[c]),n=[a.call("short"),a.call("medium"),a.call("loooooooooooooong")];expect(e).toHaveBeenCalledTimes(0);let[l,s,t]=await Promise.all(n);expect(e).toHaveBeenCalledTimes(1),expect(e).toHaveBeenLastCalledWith(["short","medium","loooooooooooooong"]),expect(e).toHaveLastResolvedWith({short:5,medium:6,loooooooooooooong:17}),expect(l).toBe(5),expect(s).toBe(6),expect(t).toBe(17)}),it("results as array",async()=>{let e=vi.fn(async o=>o.map(r=>r.length)),a=i(async o=>await e(o.flat()),(o,r)=>o[r]),n=[a.call("short"),a.call("medium"),a.call("loooooooooooooong")];expect(e).toHaveBeenCalledTimes(0);let[l,s,t]=await Promise.all(n);expect(e).toHaveBeenCalledTimes(1),expect(e).toHaveBeenLastCalledWith(["short","medium","loooooooooooooong"]),expect(e).toHaveLastResolvedWith([5,6,17]),expect(l).toBe(5),expect(s).toBe(6),expect(t).toBe(17)}),it("error handling",async()=>{let e=i(async a=>{if(a.length>1)throw new Error(`Batch too big! ${JSON.stringify(a)}`)},m());await expect(e.call("a")).resolves.toBeUndefined(),await expect(Promise.all([e.call("hello"),e.call("world")])).rejects.toThrow('Batch too big! [["hello"],["world"]]')})});
+import{a as d}from"./chunk-TVMG2NYC.js";import{a as p}from"./chunk-AWXJSK4F.js";import{a as m}from"./chunk-AFO7BV2X.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";function i(e,a,n=0){let l=p(s=>{e(s.map(({params:t})=>t)).then(t=>{for(let[o,{params:r,promiseCallbacks:[c]}]of s.entries()){let y=a(t,o,...r);c(y)}}).catch(t=>{for(let{promiseCallbacks:[,o]}of s)o(t)})},{reducer:(s,t)=>[...s??[],t],maxBurstDurationMs:n,triggerAt:"end"});return{...l,call:async(...s)=>new Promise((...t)=>{l.call({promiseCallbacks:t,params:s})})}}describe("showcase",()=>{it("results as object",async()=>{let e=vi.fn(async o=>d(o,r=>r.length)),a=i(async o=>await e(o.flat()),(o,r,c)=>o[c]),n=[a.call("short"),a.call("medium"),a.call("loooooooooooooong")];expect(e).toHaveBeenCalledTimes(0);let[l,s,t]=await Promise.all(n);expect(e).toHaveBeenCalledTimes(1),expect(e).toHaveBeenLastCalledWith(["short","medium","loooooooooooooong"]),expect(e).toHaveLastResolvedWith({short:5,medium:6,loooooooooooooong:17}),expect(l).toBe(5),expect(s).toBe(6),expect(t).toBe(17)}),it("results as array",async()=>{let e=vi.fn(async o=>o.map(r=>r.length)),a=i(async o=>await e(o.flat()),(o,r)=>o[r]),n=[a.call("short"),a.call("medium"),a.call("loooooooooooooong")];expect(e).toHaveBeenCalledTimes(0);let[l,s,t]=await Promise.all(n);expect(e).toHaveBeenCalledTimes(1),expect(e).toHaveBeenLastCalledWith(["short","medium","loooooooooooooong"]),expect(e).toHaveLastResolvedWith([5,6,17]),expect(l).toBe(5),expect(s).toBe(6),expect(t).toBe(17)}),it("error handling",async()=>{let e=i(async a=>{if(a.length>1)throw new Error(`Batch too big! ${JSON.stringify(a)}`)},m());await expect(e.call("a")).resolves.toBeUndefined(),await expect(Promise.all([e.call("hello"),e.call("world")])).rejects.toThrow('Batch too big! [["hello"],["world"]]')})});

package/dist/group-by-prop.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkHSNPZS6Rcjs = require('./chunk-HSNPZS6R.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');exports.groupByProp = _chunkHSNPZS6Rcjs.a;

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

@@ -0,0 +1,91 @@
+import { ConditionalKeys, AllUnionFields, IfNever, Merge, And } from 'type-fest';
+import { A as ArrayRequiredPrefix } from './array-required-prefix-BW08fIbb.cjs';
+import { B as BoundedPartial } from './bounded-partial-wqR8ceNQ.cjs';
+import { F as FilteredArray } from './filtered-array-DX6NNaBq.cjs';
+import { I as IterableContainer } from './iterable-container-BTpDVdNc.cjs';
+import { T as TupleParts } from './tuple-parts-DAqFAJP8.cjs';
+import './clamped-integer-subtract-DZ7rsJE4.cjs';
+import './coerced-array-DRz3tqda.cjs';
+import './if-bounded-record-Drd4UbBU.cjs';
+
+type GroupByProp<T extends IterableContainer, Prop extends GroupableProps<T>> = T extends unknown ? FixEmptyObject<EnsureValuesAreNonEmpty<{
+    [Value in AllPropValues<T, Prop>]: FilteredArray<T, Record<Prop, Value>>;
+}>> : never;
+type GroupableProps<T extends IterableContainer> = ConditionalKeys<ItemsSuperObject<T>, PropertyKey | undefined>;
+type AllPropValues<T extends IterableContainer, Prop extends GroupableProps<T>> = Extract<ItemsSuperObject<T>[Prop], PropertyKey>;
+type ItemsSuperObject<T extends IterableContainer> = AllUnionFields<Exclude<T[number], undefined>>;
+type FixEmptyObject<T> = IfNever<keyof T, Record<PropertyKey, never>, T>;
+type EnsureValuesAreNonEmpty<T extends Record<PropertyKey, IterableContainer>> = Merge<T, BoundedPartial<{
+    [P in keyof T as IsPossiblyEmpty<T[P]> extends true ? P : never]: ArrayRequiredPrefix<T[P], 1>;
+}>>;
+type IsPossiblyEmpty<T extends IterableContainer> = And<IsEmpty<TupleParts<T>['required']>, IsEmpty<TupleParts<T>['suffix']>>;
+type IsEmpty<T> = T extends readonly [] ? true : false;
+/**
+ * Groups the elements of an array of objects based on the values of a
+ * specified property of those objects. The result would contain a property for
+ * each unique value of the specific property, with it's value being the input
+ * array filtered to only items that have that property set to that value.
+ * For any object where the property is missing, or if it's value is
+ * `undefined` the item would be filtered out.
+ *
+ * The grouping property is enforced at the type level to exist in at least one
+ * item and to never have a value that cannot be used as an object key (e.g. it
+ * must be `PropertyKey | undefined`).
+ *
+ * The resulting arrays are filtered with the prop and it's value as a
+ * type-guard, effectively narrowing the items in each output arrays. This
+ * means that when the grouping property is the discriminator of a
+ * discriminated union type each output array would contain just the subtype for
+ * that value.
+ *
+ * If you need more control over the grouping you should use `groupBy` instead.
+ *
+ * @param data - The items to group.
+ * @param prop - The property name to group by.
+ * @signature
+ *    P.groupByProp(data, prop)
+ * @example
+ *    const result = P.groupByProp(
+ *      //  ^? { cat: [{ a: 'cat' }], dog: [{ a: 'dog' }] }
+ *      [{ a: 'cat' }, { a: 'dog' }] as const,
+ *      'a',
+ *    );
+ * @dataFirst
+ * @category Array
+ */
+declare function groupByProp<T extends IterableContainer, Prop extends GroupableProps<T>>(data: T, prop: Prop): GroupByProp<T, Prop>;
+/**
+ * Groups the elements of an array of objects based on the values of a
+ * specified property of those objects. The result would contain a property for
+ * each unique value of the specific property, with it's value being the input
+ * array filtered to only items that have that property set to that value.
+ * For any object where the property is missing, or if it's value is
+ * `undefined` the item would be filtered out.
+ *
+ * The grouping property is enforced at the type level to exist in at least one
+ * item and to never have a value that cannot be used as an object key (e.g. it
+ * must be `PropertyKey | undefined`).
+ *
+ * The resulting arrays are filtered with the prop and it's value as a
+ * type-guard, effectively narrowing the items in each output arrays. This
+ * means that when the grouping property is the discriminator of a
+ * discriminated union type each output array would contain just the subtype for
+ * that value.
+ *
+ * If you need more control over the grouping you should use `groupBy` instead.
+ *
+ * @param prop - The property name to group by.
+ * @signature
+ *    P.groupByProp(prop)(data);
+ * @example
+ *    const result = P.pipe(
+ *      //  ^? { cat: [{ a: 'cat' }], dog: [{ a: 'dog' }] }
+ *      [{ a: 'cat' }, { a: 'dog' }] as const,
+ *      P.groupByProp('a'),
+ *    );
+ * @dataLast
+ * @category Array
+ */
+declare function groupByProp<T extends IterableContainer, Prop extends GroupableProps<T>>(prop: Prop): (data: T) => GroupByProp<T, Prop>;
+
+export { groupByProp };

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

@@ -0,0 +1,91 @@
+import { ConditionalKeys, AllUnionFields, IfNever, Merge, And } from 'type-fest';
+import { A as ArrayRequiredPrefix } from './array-required-prefix-a3sgCkd2.js';
+import { B as BoundedPartial } from './bounded-partial-CJjczH6j.js';
+import { F as FilteredArray } from './filtered-array-BNHX1Nwj.js';
+import { I as IterableContainer } from './iterable-container-BTpDVdNc.js';
+import { T as TupleParts } from './tuple-parts-CrwnkDKX.js';
+import './clamped-integer-subtract-DZ7rsJE4.js';
+import './coerced-array-DRz3tqda.js';
+import './if-bounded-record-Drd4UbBU.js';
+
+type GroupByProp<T extends IterableContainer, Prop extends GroupableProps<T>> = T extends unknown ? FixEmptyObject<EnsureValuesAreNonEmpty<{
+    [Value in AllPropValues<T, Prop>]: FilteredArray<T, Record<Prop, Value>>;
+}>> : never;
+type GroupableProps<T extends IterableContainer> = ConditionalKeys<ItemsSuperObject<T>, PropertyKey | undefined>;
+type AllPropValues<T extends IterableContainer, Prop extends GroupableProps<T>> = Extract<ItemsSuperObject<T>[Prop], PropertyKey>;
+type ItemsSuperObject<T extends IterableContainer> = AllUnionFields<Exclude<T[number], undefined>>;
+type FixEmptyObject<T> = IfNever<keyof T, Record<PropertyKey, never>, T>;
+type EnsureValuesAreNonEmpty<T extends Record<PropertyKey, IterableContainer>> = Merge<T, BoundedPartial<{
+    [P in keyof T as IsPossiblyEmpty<T[P]> extends true ? P : never]: ArrayRequiredPrefix<T[P], 1>;
+}>>;
+type IsPossiblyEmpty<T extends IterableContainer> = And<IsEmpty<TupleParts<T>['required']>, IsEmpty<TupleParts<T>['suffix']>>;
+type IsEmpty<T> = T extends readonly [] ? true : false;
+/**
+ * Groups the elements of an array of objects based on the values of a
+ * specified property of those objects. The result would contain a property for
+ * each unique value of the specific property, with it's value being the input
+ * array filtered to only items that have that property set to that value.
+ * For any object where the property is missing, or if it's value is
+ * `undefined` the item would be filtered out.
+ *
+ * The grouping property is enforced at the type level to exist in at least one
+ * item and to never have a value that cannot be used as an object key (e.g. it
+ * must be `PropertyKey | undefined`).
+ *
+ * The resulting arrays are filtered with the prop and it's value as a
+ * type-guard, effectively narrowing the items in each output arrays. This
+ * means that when the grouping property is the discriminator of a
+ * discriminated union type each output array would contain just the subtype for
+ * that value.
+ *
+ * If you need more control over the grouping you should use `groupBy` instead.
+ *
+ * @param data - The items to group.
+ * @param prop - The property name to group by.
+ * @signature
+ *    P.groupByProp(data, prop)
+ * @example
+ *    const result = P.groupByProp(
+ *      //  ^? { cat: [{ a: 'cat' }], dog: [{ a: 'dog' }] }
+ *      [{ a: 'cat' }, { a: 'dog' }] as const,
+ *      'a',
+ *    );
+ * @dataFirst
+ * @category Array
+ */
+declare function groupByProp<T extends IterableContainer, Prop extends GroupableProps<T>>(data: T, prop: Prop): GroupByProp<T, Prop>;
+/**
+ * Groups the elements of an array of objects based on the values of a
+ * specified property of those objects. The result would contain a property for
+ * each unique value of the specific property, with it's value being the input
+ * array filtered to only items that have that property set to that value.
+ * For any object where the property is missing, or if it's value is
+ * `undefined` the item would be filtered out.
+ *
+ * The grouping property is enforced at the type level to exist in at least one
+ * item and to never have a value that cannot be used as an object key (e.g. it
+ * must be `PropertyKey | undefined`).
+ *
+ * The resulting arrays are filtered with the prop and it's value as a
+ * type-guard, effectively narrowing the items in each output arrays. This
+ * means that when the grouping property is the discriminator of a
+ * discriminated union type each output array would contain just the subtype for
+ * that value.
+ *
+ * If you need more control over the grouping you should use `groupBy` instead.
+ *
+ * @param prop - The property name to group by.
+ * @signature
+ *    P.groupByProp(prop)(data);
+ * @example
+ *    const result = P.pipe(
+ *      //  ^? { cat: [{ a: 'cat' }], dog: [{ a: 'dog' }] }
+ *      [{ a: 'cat' }, { a: 'dog' }] as const,
+ *      P.groupByProp('a'),
+ *    );
+ * @dataLast
+ * @category Array
+ */
+declare function groupByProp<T extends IterableContainer, Prop extends GroupableProps<T>>(prop: Prop): (data: T) => GroupByProp<T, Prop>;
+
+export { groupByProp };

package/dist/group-by-prop.js

@@ -0,0 +1 @@
+import{a}from"./chunk-6M4IYQFZ.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";export{a as groupByProp};

package/dist/group-by.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkAPUBIDDUcjs = require('./chunk-APUBIDDU.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');exports.groupBy = _chunkAPUBIDDUcjs.a;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkGW4KDK3Dcjs = require('./chunk-GW4KDK3D.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');exports.groupBy = _chunkGW4KDK3Dcjs.a;

package/dist/group-by.d.cts

@@ -1,4 +1,4 @@
-import { E as ExactRecord } from './exact-record-_isi2JMR.cjs';
+import { B as BoundedPartial } from './bounded-partial-wqR8ceNQ.cjs';
 import { N as NonEmptyArray } from './non-empty-array-C9Od1wmF.cjs';
 import './if-bounded-record-Drd4UbBU.cjs';
 import 'type-fest';
@@ -11,6 +11,11 @@ import 'type-fest';
  * 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
@@ -25,7 +30,7 @@ import 'type-fest';
  * @dataFirst
  * @category Array
  */
-declare function groupBy<T, Key extends PropertyKey = PropertyKey>(data: ReadonlyArray<T>, callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined): ExactRecord<Key, NonEmptyArray<T>>;
+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
@@ -34,6 +39,11 @@ declare function groupBy<T, Key extends PropertyKey = PropertyKey>(data: Readonl
  * 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.
@@ -53,6 +63,6 @@ declare function groupBy<T, Key extends PropertyKey = PropertyKey>(data: Readonl
  * @dataLast
  * @category Array
  */
-declare function groupBy<T, Key extends PropertyKey = PropertyKey>(callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined): (items: ReadonlyArray<T>) => ExactRecord<Key, NonEmptyArray<T>>;
+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>>>;
 
 export { groupBy };