semantic-typescript 0.3.7 → 0.4.1

package/dist/collectable.d.ts

@@ -1,6 +1,8 @@
 import { Collector } from "./collector";
+import type { HashMap } from "./map";
 import { Optional } from "./optional";
 import { Semantic } from "./semantic";
+import type { HashSet } from "./set";
 import type { BiConsumer, BiFunctional, Comparator, Consumer, Functional, Predicate, Supplier, TriFunctional, Generator, BiPredicate, TriPredicate, Indexed } from "./utility";
 export declare abstract class Collectable<E> implements Iterable<E>, AsyncIterable<E> {
     protected readonly Collectable: symbol;
@@ -26,6 +28,8 @@ export declare abstract class Collectable<E> implements Iterable<E>, AsyncIterab
     error(prefix: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): void;
     isEmpty(): boolean;
     findAny(): Optional<E>;
+    findAt(index: number): Optional<E>;
+    findAt(index: bigint): Optional<E>;
     findFirst(): Optional<E>;
     findLast(): Optional<E>;
     findMaximum(): Optional<E>;
@@ -35,7 +39,9 @@ export declare abstract class Collectable<E> implements Iterable<E>, AsyncIterab
     forEach(action: Consumer<E>): void;
     forEach(action: BiConsumer<E, bigint>): void;
     group<K>(classifier: Functional<E, K>): Map<K, Array<E>>;
+    group<K>(classifier: BiFunctional<E, bigint, K>): Map<K, Array<E>>;
     groupBy<K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): Map<K, Array<V>>;
+    groupBy<K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, K>): Map<K, Array<V>>;
     join(): string;
     join(delimiter: string): string;
     join(prefix: string, delimiter: string, suffix: string): string;
@@ -47,8 +53,10 @@ export declare abstract class Collectable<E> implements Iterable<E>, AsyncIterab
     log(prefix: string, accumulator: BiFunctional<string, E, string>, suffix: string): void;
     log(prefix: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): void;
     nonMatch(predicate: Predicate<E>): boolean;
+    nonMatch(predicate: BiPredicate<E, bigint>): boolean;
     partition(count: bigint): Array<Array<E>>;
     partitionBy(classifier: Functional<E, bigint>): Array<Array<E>>;
+    partitionBy(classifier: BiFunctional<E, bigint, bigint>): Array<Array<E>>;
     reduce(accumulator: BiFunctional<E, E, E>): Optional<E>;
     reduce(accumulator: TriFunctional<E, E, bigint, E>): Optional<E>;
     reduce(identity: E, accumulator: BiFunctional<E, E, E>): E;
@@ -59,7 +67,11 @@ export declare abstract class Collectable<E> implements Iterable<E>, AsyncIterab
     abstract source(): Generator<E>;
     toArray(): Array<E>;
     toMap<K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): Map<K, V>;
+    toMap<K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, V>): Map<K, V>;
+    toHashMap<K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): HashMap<K, V>;
+    toHashMap<K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, V>): HashMap<K, V>;
     toSet(): Set<E>;
+    toHashSet(): HashSet<E>;
     write<S = string>(stream: WritableStream<S>): Promise<WritableStream<S>>;
     write<S = string>(stream: WritableStream<S>, accumulator: BiFunctional<WritableStream<S>, E, WritableStream<S>>): Promise<WritableStream<S>>;
     write<S = string>(stream: WritableStream<S>, accumulator: TriFunctional<WritableStream<S>, E, bigint, WritableStream<S>>): Promise<WritableStream<S>>;

package/dist/collectable.js

@@ -1,5 +1,5 @@
-import { Collector, useAllMatch, useAnyMatch, useCollect, useCount, useError, useFindAny, useFindFirst, useFindLast, useFindMaximum, useFindMinimum, useForEach, useGroup, useGroupBy, useJoin, useLog, useNoneMatch, usePartition, usePartitionBy, useReduce, useToArray, useToAsyncGeneratorFunction, useToGeneratorFunction, useToMap, useToSet, useWrite } from "./collector";
-import { isBigInt, isCollector, isFunction, isObject, isString } from "./guard";
+import { Collector, useAllMatch, useAnyMatch, useCollect, useCount, useError, useFindAny, useFindAt, useFindFirst, useFindLast, useFindMaximum, useFindMinimum, useForEach, useGroup, useGroupBy, useJoin, useLog, useNoneMatch, usePartition, usePartitionBy, useReduce, useToArray, useToAsyncGeneratorFunction, useToGeneratorFunction, useToHashMap, useToHashSet, useToMap, useToSet, useWrite } from "./collector";
+import { isBigInt, isCollector, isFunction, isNumber, isObject, isString } from "./guard";
 import { useCompare } from "./hook";
 import { Optional } from "./optional";
 import { Semantic } from "./semantic";
@@ -8,6 +8,13 @@ import { invalidate, validate } from "./utility";
 export class Collectable {
     Collectable = CollectableSymbol;
     constructor() {
+        Object.defineProperty(this, "Collectable", {
+            value: CollectableSymbol,
+            enumerable: false,
+            writable: false,
+            configurable: false
+        });
+        Object.freeze(this);
     }
     anyMatch(predicate) {
         if (isFunction(predicate)) {
@@ -95,6 +102,25 @@ export class Collectable {
             throw new Error("Uncaught error on findAny.");
         }
     }
+    findAt(index) {
+        if (isBigInt(index)) {
+            try {
+                return useFindAt(index).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on findAt.");
+            }
+        }
+        else if (isNumber(index)) {
+            try {
+                return useFindAt(index).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on findAt.");
+            }
+        }
+        throw new TypeError("Index must be a bigint.");
+    }
     findFirst() {
         try {
             return useFindFirst().collect(this.source());
@@ -335,6 +361,14 @@ export class Collectable {
             throw new Error("Uncaught error on toMap.");
         }
     }
+    toHashMap(keyExtractor, valueExtractor) {
+        try {
+            return useToHashMap(keyExtractor, valueExtractor).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on toHashMap.");
+        }
+    }
     toSet() {
         try {
             return useToSet().collect(this.source());
@@ -343,6 +377,14 @@ export class Collectable {
             throw new Error("Uncaught error on toSet.");
         }
     }
+    toHashSet() {
+        try {
+            return useToHashSet().collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on toHashSet.");
+        }
+    }
     write(argument1, argument2) {
         if (isObject(argument1)) {
             try {
@@ -363,6 +405,9 @@ export class Collectable {
     }
 }
 ;
+Object.freeze(Collectable);
+Object.freeze(Collectable.prototype);
+Object.freeze(Object.getPrototypeOf(Collectable));
 export class UnorderedCollectable extends Collectable {
     UnorderedCollectable = UnorderedCollectableSymbol;
     generator;
@@ -370,6 +415,21 @@ export class UnorderedCollectable extends Collectable {
         super();
         if (isFunction(argument1)) {
             this.generator = argument1;
+            Object.defineProperties(this, {
+                "UnorderedCollectable": {
+                    value: UnorderedCollectableSymbol,
+                    writable: false,
+                    enumerable: false,
+                    configurable: false
+                },
+                "generator": {
+                    value: argument1,
+                    writable: false,
+                    enumerable: false,
+                    configurable: false
+                }
+            });
+            Object.freeze(this);
         }
         else {
             throw new TypeError("Source must be an iterable or a generator function.");
@@ -398,6 +458,9 @@ export class UnorderedCollectable extends Collectable {
     }
 }
 ;
+Object.freeze(UnorderedCollectable);
+Object.freeze(UnorderedCollectable.prototype);
+Object.freeze(Object.getPrototypeOf(UnorderedCollectable));
 export class OrderedCollectable extends Collectable {
     OrderedCollectable = OrderedCollectableSymbol;
     buffer;
@@ -425,6 +488,20 @@ export class OrderedCollectable extends Collectable {
                         return Number(a.index - b.index);
                     });
                 }
+                Object.defineProperties(this, {
+                    "OrderedCollectable": {
+                        value: OrderedCollectableSymbol,
+                        writable: false,
+                        enumerable: false,
+                        configurable: false
+                    },
+                    "buffer": {
+                        value: this.buffer,
+                        writable: false,
+                        enumerable: false,
+                        configurable: false
+                    }
+                });
             }
             catch (error) {
                 throw new Error("Uncaught error on creating buffer.");
@@ -472,3 +549,6 @@ export class OrderedCollectable extends Collectable {
     }
 }
 ;
+Object.freeze(OrderedCollectable);
+Object.freeze(OrderedCollectable.prototype);
+Object.freeze(Object.getPrototypeOf(OrderedCollectable));

package/dist/collector.d.ts

@@ -1,6 +1,8 @@
 import type { Collectable } from "./collectable";
+import { HashMap } from "./map";
 import { Optional } from "./optional";
 import type { Semantic } from "./semantic";
+import { HashSet } from "./set";
 import { type BiFunctional, type BiPredicate, type Functional, type Predicate, type Supplier, type TriFunctional, type Generator, type TriPredicate, type Consumer, type BiConsumer, type Comparator } from "./utility";
 export declare class Collector<E, A, R> {
     protected identity: Supplier<A>;
@@ -8,10 +10,10 @@ export declare class Collector<E, A, R> {
     protected accumulator: BiFunctional<A, E, A> | TriFunctional<A, E, bigint, A>;
     protected finisher: Functional<A, R>;
     protected readonly Collector: symbol;
-    protected constructor(identity: Supplier<A>, interruptor: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>);
-    protected constructor(identity: Supplier<A>, interruptor: BiPredicate<E, bigint>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>);
-    protected constructor(identity: Supplier<A>, interruptor: Predicate<E>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>);
-    protected constructor(identity: Supplier<A>, interruptor: BiPredicate<E, bigint>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>);
+    protected constructor(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>);
+    protected constructor(identity: Supplier<A>, interrupt: BiPredicate<E, bigint>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>);
+    protected constructor(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>);
+    protected constructor(identity: Supplier<A>, interrupt: BiPredicate<E, bigint>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>);
     collect(generator: Generator<E>): R;
     collect(iterable: Iterable<E>): R;
     collect(semantic: Semantic<E>): R;
@@ -20,29 +22,37 @@ export declare class Collector<E, A, R> {
     collect(start: bigint, end: bigint): R;
     static full<E, A, R>(identity: Supplier<A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
     static full<E, A, R>(identity: Supplier<A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
-    static shortable<E, A, R>(identity: Supplier<A>, interruptor: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
-    static shortable<E, A, R>(identity: Supplier<A>, interruptor: Predicate<E>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
-    static shortable<E, A, R>(identity: Supplier<A>, interruptor: BiPredicate<E, bigint>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
-    static shortable<E, A, R>(identity: Supplier<A>, interruptor: BiPredicate<E, bigint>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
-    static shortable<E, A, R>(identity: Supplier<A>, interruptor: TriPredicate<E, bigint, A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
-    static shortable<E, A, R>(identity: Supplier<A>, interruptor: TriPredicate<E, bigint, A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
-}
-export declare let useAnyMatch: <E>(predicate: Predicate<E>) => Collector<E, boolean, boolean>;
-export declare let useAllMatch: <E>(predicate: Predicate<E>) => Collector<E, boolean, boolean>;
+    static shortable<E, A, R>(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interrupt: BiPredicate<E, bigint>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interrupt: BiPredicate<E, bigint>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interrupt: TriPredicate<E, bigint, A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interrupt: TriPredicate<E, bigint, A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+}
+interface UseAnyMatch {
+    <E>(predicate: Predicate<E>): Collector<E, boolean, boolean>;
+    <E>(predicate: BiPredicate<E, bigint>): Collector<E, boolean, boolean>;
+}
+export declare let useAnyMatch: UseAnyMatch;
+interface UseAllMatch {
+    <E>(predicate: Predicate<E>): Collector<E, boolean, boolean>;
+    <E>(predicate: BiPredicate<E, bigint>): Collector<E, boolean, boolean>;
+}
+export declare let useAllMatch: UseAllMatch;
 interface UseCollect {
     <E, A, R>(identity: Supplier<A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
     <E, A, R>(identity: Supplier<A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
     <E, A, R>(identity: Supplier<A>, accumulator: BiFunctional<A, E, A> | TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
-    <E, A, R>(identity: Supplier<A>, interruptor: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
-    <E, A, R>(identity: Supplier<A>, interruptor: Predicate<E>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
-    <E, A, R>(identity: Supplier<A>, interruptor: BiPredicate<E, bigint>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
-    <E, A, R>(identity: Supplier<A>, interruptor: BiPredicate<E, bigint>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
-    <E, A, R>(identity: Supplier<A>, interruptor: TriPredicate<E, bigint, A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
-    <E, A, R>(identity: Supplier<A>, interruptor: TriPredicate<E, bigint, A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: BiPredicate<E, bigint>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: BiPredicate<E, bigint>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: TriPredicate<E, bigint, A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: TriPredicate<E, bigint, A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
 }
 export declare let useCollect: UseCollect;
 export declare let useCount: <E = unknown>() => Collector<E, bigint, bigint>;
-export interface UseError {
+interface UseError {
     <E = unknown>(): Collector<E, string, string>;
     <E = unknown>(accumulator: BiFunctional<string, E, string>): Collector<E, string, string>;
     <E = unknown>(accumulator: TriFunctional<string, E, bigint, string>): Collector<E, string, string>;
@@ -50,28 +60,45 @@ export interface UseError {
     <E = unknown>(prefix: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): Collector<E, string, string>;
 }
 export declare let useError: UseError;
+interface UseFindAt {
+    <E>(index: number): Collector<E, Array<E>, Optional<E>>;
+    <E>(index: bigint): Collector<E, Array<E>, Optional<E>>;
+}
+export declare let useFindAt: UseFindAt;
 export declare let useFindFirst: <E>() => Collector<E, Optional<E>, Optional<E>>;
 export declare let useFindAny: <E>() => Collector<E, Optional<E>, Optional<E>>;
 export declare let useFindLast: <E>() => Collector<E, Optional<E>, Optional<E>>;
-export interface UseFindMaximum {
+interface UseFindMaximum {
     <E>(): Collector<E, Optional<E>, Optional<E>>;
     <E>(comparator: Comparator<E>): Collector<E, Optional<E>, Optional<E>>;
 }
 export declare let useFindMaximum: UseFindMaximum;
-export interface UseFindMinimum {
+interface UseFindMinimum {
     <E>(): Collector<E, Optional<E>, Optional<E>>;
     <E>(comparator: Comparator<E>): Collector<E, Optional<E>, Optional<E>>;
 }
 export declare let useFindMinimum: UseFindMinimum;
-export interface UseForEach {
+interface UseForEach {
     <E>(action: Consumer<E>): Collector<E, bigint, bigint>;
     <E>(action: BiConsumer<E, bigint>): Collector<E, bigint, bigint>;
 }
 export declare let useForEach: UseForEach;
-export declare let useNoneMatch: <E>(predicate: Predicate<E>) => Collector<E, boolean, boolean>;
-export declare let useGroup: <E, K>(classifier: Functional<E, K>) => Collector<E, Map<K, E[]>, Map<K, E[]>>;
-export declare let useGroupBy: <E, K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>) => Collector<E, Map<K, V[]>, Map<K, V[]>>;
-export interface UseJoin {
+interface UseNonMatch {
+    <E>(predicate: Predicate<E>): Collector<E, boolean, boolean>;
+    <E>(predicate: BiPredicate<E, bigint>): Collector<E, boolean, boolean>;
+}
+export declare let useNoneMatch: UseNonMatch;
+interface UseGroup {
+    <E, K>(classifier: Functional<E, K>): Collector<E, Map<K, E[]>, Map<K, E[]>>;
+    <E, K>(classifier: BiFunctional<E, bigint, K>): Collector<E, Map<K, E[]>, Map<K, E[]>>;
+}
+export declare let useGroup: UseGroup;
+interface UseGroupBy {
+    <E, K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): Collector<E, Map<K, V[]>, Map<K, V[]>>;
+    <E, K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, V>): Collector<E, Map<K, V[]>, Map<K, V[]>>;
+}
+export declare let useGroupBy: UseGroupBy;
+interface UseJoin {
     <E = unknown>(): Collector<E, string, string>;
     <E = unknown>(delimiter: string): Collector<E, string, string>;
     <E = unknown>(prefix: string, delimiter: string, suffix: string): Collector<E, string, string>;
@@ -79,7 +106,7 @@ export interface UseJoin {
     <E = unknown>(prefiex: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): Collector<E, string, string>;
 }
 export declare let useJoin: UseJoin;
-export interface UseLog {
+interface UseLog {
     <E = unknown>(): Collector<E, string, string>;
     <E = unknown>(accumulator: BiFunctional<string, E, string>): Collector<E, string, string>;
     <E = unknown>(accumulator: TriFunctional<string, E, bigint, string>): Collector<E, string, string>;
@@ -88,8 +115,12 @@ export interface UseLog {
 }
 export declare let useLog: UseLog;
 export declare let usePartition: <E>(count: bigint) => Collector<E, Array<Array<E>>, Array<Array<E>>>;
-export declare let usePartitionBy: <E>(classifier: Functional<E, bigint>) => Collector<E, Array<E[]>, Array<E[]>>;
-export interface UseReduce {
+interface UsePartitionBy {
+    <E>(classifier: Functional<E, bigint>): Collector<E, Array<E[]>, Array<E[]>>;
+    <E>(classifier: BiFunctional<E, bigint, bigint>): Collector<E, Array<E[]>, Array<E[]>>;
+}
+export declare let usePartitionBy: UsePartitionBy;
+interface UseReduce {
     <E>(accumulator: BiFunctional<E, E, E>): Collector<E, Optional<E>, Optional<E>>;
     <E>(accumulator: TriFunctional<E, E, bigint, E>): Collector<E, Optional<E>, Optional<E>>;
     <E>(identity: E, accumulator: BiFunctional<E, E, E>): Collector<E, E, E>;
@@ -99,99 +130,109 @@ export interface UseReduce {
 }
 export declare let useReduce: UseReduce;
 export declare let useToArray: <E>() => Collector<E, E[], E[]>;
-export declare let useToMap: <E, K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>) => Collector<E, Map<K, V>, Map<K, V>>;
+interface UseToMap {
+    <E, K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): Collector<E, Map<K, V>, Map<K, V>>;
+    <E, K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, V>): Collector<E, Map<K, V>, Map<K, V>>;
+}
+export declare let useToMap: UseToMap;
+interface UseToHashMap {
+    <E, K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): Collector<E, HashMap<K, V>, HashMap<K, V>>;
+    <E, K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, V>): Collector<E, HashMap<K, V>, HashMap<K, V>>;
+}
+export declare let useToHashMap: UseToHashMap;
 export declare let useToSet: <E>() => Collector<E, Set<E>, Set<E>>;
-export interface UseWrite {
+export declare let useToHashSet: <E>() => Collector<E, HashSet<E>, HashSet<E>>;
+interface UseWrite {
     <E, S = string>(stream: WritableStream<S>): Collector<E, Promise<WritableStream<S>>, Promise<WritableStream<S>>>;
     <E, S = string>(stream: WritableStream<S>, accumulator: BiFunctional<WritableStream<S>, E, WritableStream<S>>): Collector<E, Promise<WritableStream<S>>, Promise<WritableStream<S>>>;
     <E, S = string>(stream: WritableStream<S>, accumulator: TriFunctional<WritableStream<S>, E, bigint, WritableStream<S>>): Collector<E, Promise<WritableStream<S>>, Promise<WritableStream<S>>>;
 }
 export declare let useWrite: UseWrite;
-export interface UseNumericSummate {
+interface UseNumericSummate {
     <E>(): Collector<E, number, number>;
     <E>(mapper: Functional<E, number>): Collector<E, number, number>;
 }
 export declare let useNumericSummate: UseNumericSummate;
-export interface UseBigIntSummate {
+interface UseBigIntSummate {
     <E>(): Collector<E, bigint, bigint>;
     <E>(mapper: Functional<E, bigint>): Collector<E, bigint, bigint>;
 }
 export declare let useBigIntSummate: UseBigIntSummate;
-export interface UseNumericAverage {
+interface UseNumericAverage {
     <E>(): Collector<E, NumericAverageAccumulator, number>;
     <E>(mapper: Functional<E, number>): Collector<E, NumericAverageAccumulator, number>;
 }
-export interface NumericAverageAccumulator {
+interface NumericAverageAccumulator {
     summate: number;
     count: number;
 }
 export declare let useNumericAverage: UseNumericAverage;
-export interface UseBigIntAverage {
+interface UseBigIntAverage {
     <E>(): Collector<E, BigIntAverageAccumulator, bigint>;
     <E>(mapper: Functional<E, bigint>): Collector<E, BigIntAverageAccumulator, bigint>;
 }
-export interface BigIntAverageAccumulator {
+interface BigIntAverageAccumulator {
     summate: bigint;
     count: bigint;
 }
 export declare let useBigIntAverage: UseBigIntAverage;
 export declare let useFrequency: <E>() => Collector<E, Map<E, bigint>, Map<E, bigint>>;
-export interface UseNumericMode {
+interface UseNumericMode {
     <E>(): Collector<E, Map<number, bigint>, number>;
     <E>(mapper: Functional<E, number>): Collector<E, Map<number, bigint>, number>;
 }
 export declare let useNumericMode: UseNumericMode;
-export interface UseBigIntMode {
+interface UseBigIntMode {
     <E>(): Collector<E, Map<bigint, bigint>, bigint>;
     <E>(mapper: Functional<E, bigint>): Collector<E, Map<bigint, bigint>, bigint>;
 }
 export declare let useBigIntMode: UseBigIntMode;
-export interface UseNumericVariance {
+interface UseNumericVariance {
     <E>(): Collector<E, VarianceAccumulator, number>;
     <E>(mapper: Functional<E, number>): Collector<E, VarianceAccumulator, number>;
 }
-export interface VarianceAccumulator {
+interface VarianceAccumulator {
     summate: number;
     summateOfSquares: number;
     count: number;
 }
 export declare let useNumericVariance: UseNumericVariance;
-export interface UseBigIntVariance {
+interface UseBigIntVariance {
     <E>(): Collector<E, BigIntVarianceAccumulator, bigint>;
     <E>(mapper: Functional<E, bigint>): Collector<E, BigIntVarianceAccumulator, bigint>;
 }
-export interface BigIntVarianceAccumulator {
+interface BigIntVarianceAccumulator {
     summate: bigint;
     summateOfSquares: bigint;
     count: bigint;
 }
 export declare let useBigIntVariance: UseBigIntVariance;
-export interface UseNumericStandardDeviation {
+interface UseNumericStandardDeviation {
     <E>(): Collector<E, StandardDeviationAccumulator, number>;
     <E>(mapper: Functional<E, number>): Collector<E, StandardDeviationAccumulator, number>;
 }
-export interface StandardDeviationAccumulator {
+interface StandardDeviationAccumulator {
     summate: number;
     summateOfSquares: number;
     count: number;
 }
 export declare let useNumericStandardDeviation: UseNumericStandardDeviation;
-export interface UseBigIntStandardDeviation {
+interface UseBigIntStandardDeviation {
     <E>(): Collector<E, BigIntStandardDeviationAccumulator, bigint>;
     <E>(mapper: Functional<E, bigint>): Collector<E, BigIntStandardDeviationAccumulator, bigint>;
 }
-export interface BigIntStandardDeviationAccumulator {
+interface BigIntStandardDeviationAccumulator {
     summate: bigint;
     summateOfSquares: bigint;
     count: bigint;
 }
 export declare let useBigIntStandardDeviation: UseBigIntStandardDeviation;
-export interface UseNumericMedian {
+interface UseNumericMedian {
     <E>(): Collector<E, number[], number>;
     <E>(mapper: Functional<E, number>): Collector<E, number[], number>;
 }
 export declare let useNumericMedian: UseNumericMedian;
-export interface UseBigIntMedian {
+interface UseBigIntMedian {
     <E>(): Collector<E, bigint[], bigint>;
     <E>(mapper: Functional<E, bigint>): Collector<E, bigint[], bigint>;
 }