semantic-typescript 0.5.3 → 0.6.0

package/dist/collector.d.ts

@@ -1,236 +0,0 @@
-import { Collectable } from "./semantic";
-import { Optional } from "./optional";
-import type { Semantic } from "./semantic";
-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>;
-    protected interrupt: Predicate<E> | BiPredicate<E, bigint> | TriPredicate<E, bigint, A>;
-    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>, 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;
-    collect(collectable: Collectable<E>): R;
-    collect(start: number, end: number): 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>, 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>, 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>;
-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>;
-    <E = unknown>(prefix: string, accumulator: BiFunctional<string, E, string>, suffix: string): Collector<E, string, string>;
-    <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>>;
-interface UseFindMaximum {
-    <E>(): Collector<E, Optional<E>, Optional<E>>;
-    <E>(comparator: Comparator<E>): Collector<E, Optional<E>, Optional<E>>;
-}
-export declare let useFindMaximum: UseFindMaximum;
-interface UseFindMinimum {
-    <E>(): Collector<E, Optional<E>, Optional<E>>;
-    <E>(comparator: Comparator<E>): Collector<E, Optional<E>, Optional<E>>;
-}
-export declare let useFindMinimum: UseFindMinimum;
-interface UseForEach {
-    <E>(action: Consumer<E>): Collector<E, bigint, bigint>;
-    <E>(action: BiConsumer<E, bigint>): Collector<E, bigint, bigint>;
-}
-export declare let useForEach: UseForEach;
-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>(keyExtractor: Functional<E, K>): Collector<E, Map<K, E[]>, Map<K, E[]>>;
-    <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>;
-    <E = unknown>(prefiex: string, accumulator: BiFunctional<string, E, string>, suffix: string): Collector<E, string, string>;
-    <E = unknown>(prefiex: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): Collector<E, string, string>;
-}
-export declare let useJoin: UseJoin;
-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>;
-    <E = unknown>(prefix: string, accumulator: BiFunctional<string, E, string>, suffix: string): Collector<E, string, string>;
-    <E = unknown>(prefix: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): Collector<E, string, string>;
-}
-export declare let useLog: UseLog;
-export declare let usePartition: <E>(count: bigint) => Collector<E, Array<Array<E>>, Array<Array<E>>>;
-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>;
-    <E>(identity: E, accumulator: TriFunctional<E, E, bigint, E>): Collector<E, E, E>;
-    <E, R>(identity: R, accumulator: BiFunctional<R, E, R>, finisher: Functional<R, R>): Collector<E, R, R>;
-    <E, R>(identity: R, accumulator: TriFunctional<R, E, bigint, R>, finisher: Functional<R, R>): Collector<E, R, R>;
-}
-export declare let useReduce: UseReduce;
-export declare let useToArray: <E>() => Collector<E, E[], E[]>;
-interface UseToMap {
-    <E, K>(keyExtractor: Functional<E, K>): Collector<E, Map<K, E>, Map<K, E>>;
-    <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;
-export declare let useToSet: <E>() => Collector<E, Set<E>, Set<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;
-interface UseNumericSummate {
-    <E>(): Collector<E, number, number>;
-    <E>(mapper: Functional<E, number>): Collector<E, number, number>;
-}
-export declare let useNumericSummate: UseNumericSummate;
-interface UseBigIntSummate {
-    <E>(): Collector<E, bigint, bigint>;
-    <E>(mapper: Functional<E, bigint>): Collector<E, bigint, bigint>;
-}
-export declare let useBigIntSummate: UseBigIntSummate;
-interface UseNumericAverage {
-    <E>(): Collector<E, NumericAverageAccumulator, number>;
-    <E>(mapper: Functional<E, number>): Collector<E, NumericAverageAccumulator, number>;
-}
-interface NumericAverageAccumulator {
-    summate: number;
-    count: number;
-}
-export declare let useNumericAverage: UseNumericAverage;
-interface UseBigIntAverage {
-    <E>(): Collector<E, BigIntAverageAccumulator, bigint>;
-    <E>(mapper: Functional<E, bigint>): Collector<E, BigIntAverageAccumulator, bigint>;
-}
-interface BigIntAverageAccumulator {
-    summate: bigint;
-    count: bigint;
-}
-export declare let useBigIntAverage: UseBigIntAverage;
-export declare let useFrequency: <E>() => Collector<E, Map<E, bigint>, Map<E, bigint>>;
-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;
-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;
-interface UseNumericVariance {
-    <E>(): Collector<E, VarianceAccumulator, number>;
-    <E>(mapper: Functional<E, number>): Collector<E, VarianceAccumulator, number>;
-}
-interface VarianceAccumulator {
-    summate: number;
-    summateOfSquares: number;
-    count: number;
-}
-export declare let useNumericVariance: UseNumericVariance;
-interface UseBigIntVariance {
-    <E>(): Collector<E, BigIntVarianceAccumulator, bigint>;
-    <E>(mapper: Functional<E, bigint>): Collector<E, BigIntVarianceAccumulator, bigint>;
-}
-interface BigIntVarianceAccumulator {
-    summate: bigint;
-    summateOfSquares: bigint;
-    count: bigint;
-}
-export declare let useBigIntVariance: UseBigIntVariance;
-interface UseNumericStandardDeviation {
-    <E>(): Collector<E, StandardDeviationAccumulator, number>;
-    <E>(mapper: Functional<E, number>): Collector<E, StandardDeviationAccumulator, number>;
-}
-interface StandardDeviationAccumulator {
-    summate: number;
-    summateOfSquares: number;
-    count: number;
-}
-export declare let useNumericStandardDeviation: UseNumericStandardDeviation;
-interface UseBigIntStandardDeviation {
-    <E>(): Collector<E, BigIntStandardDeviationAccumulator, bigint>;
-    <E>(mapper: Functional<E, bigint>): Collector<E, BigIntStandardDeviationAccumulator, bigint>;
-}
-interface BigIntStandardDeviationAccumulator {
-    summate: bigint;
-    summateOfSquares: bigint;
-    count: bigint;
-}
-export declare let useBigIntStandardDeviation: UseBigIntStandardDeviation;
-interface UseNumericMedian {
-    <E>(): Collector<E, number[], number>;
-    <E>(mapper: Functional<E, number>): Collector<E, number[], number>;
-}
-export declare let useNumericMedian: UseNumericMedian;
-interface UseBigIntMedian {
-    <E>(): Collector<E, bigint[], bigint>;
-    <E>(mapper: Functional<E, bigint>): Collector<E, bigint[], bigint>;
-}
-export declare let useBigIntMedian: UseBigIntMedian;
-export declare let useToGeneratorFunction: <E>() => Collector<E, Array<E>, globalThis.Generator<E, void, undefined>>;
-export declare let useToAsyncGeneratorFunction: <E>() => Collector<E, Array<E>, globalThis.AsyncGenerator<E, void, undefined>>;
-export {};

package/dist/main.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/main.js

@@ -1,4 +0,0 @@
-import { useWindow } from 'semantic-typescript';
-useWindow("click").toEvent().forEach((event, index) => {
-    console.log(event.type + `第${index}次触发`);
-});

package/dist/map.d.ts

@@ -1,76 +0,0 @@
-import { type BiConsumer, type BiFunctional, type Comparator, type MaybeInvalid, type MaybeUndefined, type Supplier, type TriConsumer } from "./utility";
-export interface Entry<K, V> {
-    key: K;
-    value: V;
-}
-export interface SemanticMap<K, V> extends globalThis.Map<K, V> {
-    clear(): void;
-    compute(key: K, remapping: BiFunctional<K, MaybeInvalid<V>, MaybeInvalid<V>>): MaybeInvalid<V>;
-    computeIfAbsent(key: K, remapping: Supplier<V>): V;
-    computeIfPresent(key: K, remapping: BiFunctional<K, V, MaybeInvalid<V>>): MaybeInvalid<V>;
-    delete(key: K): boolean;
-    entries(): MapIterator<[K, V]>;
-    forEach(consumer: BiConsumer<V, K>): void;
-    forEach(consumer: TriConsumer<V, K, Map<K, V>>): void;
-    get(key: K): MaybeUndefined<V>;
-    get(key: K, defaultValue: V): V;
-    has(key: K): boolean;
-    replace(key: K, value: V): MaybeInvalid<V>;
-    replace(key: K, oldValue: V, newValue: V): boolean;
-    replaceAll(operator: BiFunctional<K, V, MaybeInvalid<V>>): void;
-    set(key: K, value: V): this;
-    size: number;
-    values(): IterableIterator<V>;
-}
-export declare abstract class AbstractSemanticMap<K, V> implements SemanticMap<K, V> {
-    protected internal: bigint;
-    size: number;
-    protected readonly SemanticMap: symbol;
-    constructor();
-    abstract clear(): void;
-    compute(key: K, remapping: BiFunctional<K, MaybeInvalid<V>, MaybeInvalid<V>>): MaybeInvalid<V>;
-    computeIfAbsent(key: K, remapping: Supplier<V>): V;
-    computeIfPresent(key: K, remapping: BiFunctional<K, V, MaybeInvalid<V>>): MaybeInvalid<V>;
-    abstract delete(key: K): boolean;
-    abstract entries(): MapIterator<[K, V]>;
-    forEach(consumer: BiConsumer<V, K>): void;
-    forEach(consumer: TriConsumer<V, K, Map<K, V>>): void;
-    abstract get(key: K): MaybeUndefined<V>;
-    abstract get(key: K, defaultValue: V): V;
-    abstract keys(): MapIterator<K>;
-    has(key: K): boolean;
-    replace(key: K, value: V): MaybeInvalid<V>;
-    replace(key: K, oldValue: V, newValue: V): boolean;
-    replaceAll(operator: BiFunctional<K, V, MaybeInvalid<V>>): void;
-    abstract set(key: K, value: V): this;
-    [Symbol.iterator](): IterableIterator<[K, V]>;
-    [Symbol.toStringTag]: string;
-    abstract values(): IterableIterator<V>;
-}
-export declare class HashMap<K, V> extends AbstractSemanticMap<K, V> {
-    protected buckets: Map<bigint, Array<Entry<K, V>>>;
-    protected threashold: number;
-    protected comparator: Comparator<K>;
-    protected capacity: number;
-    protected readonly HashMap: symbol;
-    constructor();
-    constructor(comparator: Comparator<K>);
-    constructor(threashold: number, initialCapacity: number);
-    constructor(comparator: Comparator<K>, threashold: number, capacity: number);
-    clear(): void;
-    delete(key: K): boolean;
-    entries(): MapIterator<[K, V]>;
-    has(key: K): boolean;
-    protected hash(key: K): bigint;
-    protected findEntry(key: K, hash: bigint): MaybeInvalid<Entry<K, V>>;
-    get(key: K): MaybeUndefined<V>;
-    get(key: K, defaultValue: V): V;
-    keys(): MapIterator<K>;
-    protected rehash(): void;
-    set(key: K, value: V): this;
-    values(): IterableIterator<V>;
-}
-export declare class TreeMap<K, V> {
-    key: K;
-    value: V;
-}

package/dist/map.js

@@ -1,245 +0,0 @@
-import { isFunction, isNumber } from "./guard";
-import { useHash } from "./hash";
-import { useCompare } from "./hook";
-import { SemanticMapSymbol } from "./symbol";
-import { invalidate, validate } from "./utility";
-;
-;
-export class AbstractSemanticMap {
-    internal = 0n;
-    size = 0;
-    SemanticMap = SemanticMapSymbol;
-    constructor() {
-        Object.defineProperty(this, "SemanticMap", {
-            value: SemanticMapSymbol,
-            enumerable: false,
-            writable: false,
-            configurable: false
-        });
-    }
-    compute(key, remapping) {
-        let value = this.get(key);
-        return remapping(key, value);
-    }
-    computeIfAbsent(key, remapping) {
-        let value = this.get(key);
-        if (invalidate(value)) {
-            return remapping();
-        }
-        return value;
-    }
-    computeIfPresent(key, remapping) {
-        let value = this.get(key);
-        if (validate(value)) {
-            return remapping(key, value);
-        }
-        return value;
-    }
-    forEach(consumer) {
-        for (let entry of this.entries()) {
-            consumer(entry[1], entry[0], this);
-        }
-    }
-    has(key) {
-        return this.get(key) !== undefined;
-    }
-    replace(argument1, argument2, argument3) {
-        if (validate(argument1) && validate(argument2) && validate(argument3)) {
-            let key = argument1;
-            let oldValue = argument2;
-            let newValue = argument3;
-            if (this.get(key) === oldValue) {
-                this.set(key, newValue);
-                return true;
-            }
-            return this.get(key);
-        }
-        if (validate(argument1) && validate(argument2) && invalidate(argument3)) {
-            let key = argument1;
-            let value = argument2;
-            if (this.get(key) === value) {
-                this.delete(key);
-                return true;
-            }
-            return this.get(key);
-        }
-    }
-    replaceAll(operator) {
-        for (let entry of this.entries()) {
-            let key = entry[0];
-            let value = entry[1];
-            let newValue = operator(key, value);
-            if (validate(newValue)) {
-                this.set(key, newValue);
-            }
-            else {
-                this.delete(key);
-            }
-        }
-    }
-    [Symbol.iterator]() {
-        return this.entries();
-    }
-    [Symbol.toStringTag] = "SemanticMap";
-}
-;
-export class HashMap extends AbstractSemanticMap {
-    buckets = new Map();
-    threashold;
-    comparator;
-    capacity;
-    HashMap = SemanticMapSymbol;
-    constructor(argument1, argument2, argument3) {
-        super();
-        if (isFunction(argument1) && isNumber(argument2) && isNumber(argument3)) {
-            this.comparator = argument1;
-            this.threashold = argument2;
-            this.capacity = argument3;
-        }
-        else if (isFunction(argument1) && isNumber(argument2) && invalidate(argument3)) {
-            this.comparator = argument1;
-            this.threashold = argument2;
-            this.capacity = 16;
-        }
-        else if (isFunction(argument1) && invalidate(argument2) && invalidate(argument3)) {
-            this.comparator = argument1;
-            this.threashold = 0.75;
-            this.capacity = 16;
-        }
-        else {
-            this.comparator = useCompare;
-            this.threashold = 0.75;
-            this.capacity = 16;
-        }
-        this.buckets = new Map();
-        Object.defineProperty(this, "size", {
-            get: () => this.internal,
-            set: (value) => this.internal = isNumber(value) ? BigInt(value) : 0n,
-            enumerable: true,
-            configurable: false
-        });
-        Object.defineProperty(this, "HashMap", {
-            value: SemanticMapSymbol,
-            enumerable: false,
-            writable: false,
-            configurable: false
-        });
-    }
-    clear() {
-        this.buckets.clear();
-        this.size = 0;
-    }
-    delete(key) {
-        let hashCode = this.hash(key);
-        let bucket = this.buckets.get(hashCode) || [];
-        if (bucket.length > 0) {
-            for (let index = 0; index < bucket.length; index++) {
-                let entry = bucket[index];
-                if (this.comparator(entry.key, key) === 0) {
-                    bucket.splice(index, 1);
-                    this.size--;
-                    if (bucket.length === 0) {
-                        this.buckets.delete(hashCode);
-                    }
-                    return true;
-                }
-            }
-        }
-        this.buckets.delete(hashCode);
-        return false;
-    }
-    *entries() {
-        for (let bucket of this.buckets.values()) {
-            for (let entry of bucket) {
-                yield [entry.key, entry.value];
-            }
-        }
-    }
-    has(key) {
-        let hashCode = this.hash(key);
-        return validate(this.findEntry(key, hashCode));
-    }
-    hash(key) {
-        return useHash(key);
-    }
-    ;
-    findEntry(key, hash) {
-        let candidates = (this.buckets.get(hash) || []);
-        for (let candidate of candidates) {
-            if (this.comparator(candidate.key, key) === 0) {
-                return candidate;
-            }
-        }
-        return (void 0);
-    }
-    get(argument1, argument2) {
-        if (validate(argument1) && validate(argument2)) {
-            let key = argument1;
-            let defaultValue = argument2;
-            let hashCode = this.hash(key);
-            let entry = this.findEntry(key, hashCode);
-            if (validate(entry)) {
-                return entry.value;
-            }
-            return defaultValue;
-        }
-        let key = argument1;
-        let hashCode = this.hash(key);
-        let entry = this.findEntry(key, hashCode);
-        if (validate(entry)) {
-            return entry.value;
-        }
-        return (void 0);
-    }
-    *keys() {
-        for (let bucket of this.buckets.values()) {
-            for (let entry of bucket) {
-                yield entry.key;
-            }
-        }
-    }
-    rehash() {
-        let oldBuckets = this.buckets;
-        this.buckets = new Map();
-        this.size = 0;
-        for (let bucket of oldBuckets.values()) {
-            for (let entry of bucket) {
-                let hashCode = this.hash(entry.key);
-                let bucket = this.buckets.get(hashCode) || [];
-                bucket.push(entry);
-                this.size++;
-            }
-        }
-    }
-    set(key, value) {
-        let hashCode = this.hash(key);
-        let bucket = this.buckets.get(hashCode) || [];
-        let found = this.findEntry(key, hashCode);
-        if (validate(found)) {
-            found.value = value;
-        }
-        else {
-            bucket.push({
-                key: key,
-                value: value
-            });
-            this.size++;
-            if (this.size > this.capacity * this.threashold) {
-                this.rehash();
-            }
-        }
-        return this;
-    }
-    *values() {
-        for (let bucket of this.buckets.values()) {
-            for (let entry of bucket) {
-                yield entry.value;
-            }
-        }
-    }
-}
-;
-export class TreeMap {
-    key = (void 0);
-    value = (void 0);
-}