semantic-typescript 0.5.0 → 0.6.0

package/dist/asynchronous/semantic.js

@@ -0,0 +1,1853 @@
+import { useAsynchronousAnyMatch, useAsynchronousAllMatch, useAsynchronousCollect, useAsynchronousCount, useAsynchronousError, useAsynchronousFindAny, useAsynchronousFindAt, useAsynchronousFindFirst, useAsynchronousFindLast, useAsynchronousFindMaximum, useAsynchronousFindMinimum, useAsynchronousForEach, useAsynchronousGroup, useAsynchronousGroupBy, useAsynchronousJoin, useAsynchronousLog, useAsynchronousNoneMatch, useAsynchronousPartition, useAsynchronousPartitionBy, useAsynchronousReduce, useAsynchronousToArray, useAsynchronousToMap, useAsynchronousToSet, useAsynchronousWrite, useAsynchronousFrequency, useAsynchronousBigIntAverage, useAsynchronousBigIntMedian, useAsynchronousBigIntMode, useAsynchronousBigIntSummate, useAsynchronousBigIntVariance, useAsynchronousNumericAverage, useAsynchronousNumericMedian, useAsynchronousNumericMode, useAsynchronousNumericStandardDeviation, useAsynchronousNumericSummate, useAsynchronousNumericVariance } from "./collector";
+import { isFunction, isAsynchronousSemantic, isIterable, isNumber, isBigInt, isObject, isString, isAsynchronousCollectable, isAsyncIterable, isAsynchronousCollector } from "../guard";
+import { useHash } from "../hash";
+import { useCompare, useToBigInt, useToNumber } from "../hook";
+import { AsynchronousOrderedCollectableSymbol, AsynchronousBigIntStatisticsSymbol, AsynchronousCollectableSymbol, AsynchronousNumericStatisticsSymbol, AsynchronousSemanticSymbol, AsynchronousWindowCollectableSymbol, AsynchronousUnorderedCollectableSymbol, AsynchronousStatisticsSymbol } from "../symbol";
+import { invalidate, validate } from "../utility";
+export class AsynchronousSemantic {
+    generator;
+    AsynchronousSemantic = AsynchronousSemanticSymbol;
+    [Symbol.toStringTag] = "AsynchronousSemantic";
+    constructor(generator) {
+        if (isFunction(generator)) {
+            this.generator = generator;
+            Object.defineProperties(this, {
+                "AsynchronousSemantic": {
+                    value: AsynchronousSemanticSymbol,
+                    writable: false,
+                    enumerable: false,
+                    configurable: false
+                },
+                "generator": {
+                    value: generator,
+                    writable: false,
+                    enumerable: false,
+                    configurable: false
+                }
+            });
+        }
+        else {
+            throw new TypeError("Invalid arguments.");
+        }
+    }
+    concat(argument) {
+        if (isAsynchronousSemantic(argument)) {
+            let other = argument;
+            let generator = Reflect.get(other, "generator");
+            return new AsynchronousSemantic(async (accept, interrupt) => {
+                let count = 0n;
+                return new Promise((resolve, reject) => {
+                    this.generator((element) => {
+                        accept(element, count);
+                        count++;
+                    }, interrupt).then(() => {
+                        generator((element) => {
+                            accept(element, count);
+                            count++;
+                        }, interrupt);
+                    }).then(resolve, reject);
+                });
+            });
+        }
+        if (isAsyncIterable(argument)) {
+            let other = argument;
+            return new AsynchronousSemantic(async (accept, interrupt) => {
+                return new Promise((resolve, reject) => {
+                    try {
+                        let count = 0n;
+                        this.generator((element, index) => {
+                            accept(element, index);
+                            count++;
+                        }, interrupt).then(async () => {
+                            for await (let element of other) {
+                                accept(element, count);
+                                count++;
+                            }
+                            resolve();
+                        }).catch(reject);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+            });
+        }
+        throw new TypeError("Invalid arguments.");
+    }
+    distinct(argument1) {
+        let keyExtractor = validate(argument1) ? argument1 : (element) => element;
+        return new AsynchronousSemantic(async (accept, interrupt) => {
+            return new Promise((resolve, reject) => {
+                try {
+                    let set = new Set();
+                    this.generator((element, index) => {
+                        let key = keyExtractor(element, index);
+                        if (!set.has(key)) {
+                            set.add(key);
+                            accept(element, index);
+                        }
+                    }, interrupt).then(resolve).catch(reject);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+    }
+    dropWhile(predicate) {
+        if (isFunction(predicate)) {
+            return new AsynchronousSemantic(async (accept, interrupt) => {
+                return new Promise((resolve, reject) => {
+                    try {
+                        let count = -1n;
+                        this.generator((element, index) => {
+                            if (count === -1n) {
+                                if (!predicate(element, index)) {
+                                    count++;
+                                }
+                            }
+                            else {
+                                accept(element, count);
+                                count++;
+                            }
+                        }, interrupt).then(resolve).catch(reject);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+            });
+        }
+        throw new TypeError("Invalid arguments.");
+    }
+    filter(predicate) {
+        if (isFunction(predicate)) {
+            return new AsynchronousSemantic(async (accept, interrupt) => {
+                return new Promise((resolve, reject) => {
+                    try {
+                        this.generator((element, index) => {
+                            if (predicate(element, index)) {
+                                accept(element, index);
+                            }
+                        }, interrupt).then(resolve).catch(reject);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+            });
+        }
+        throw new TypeError("Invalid arguments.");
+    }
+    flat(mapper) {
+        if (isFunction(mapper)) {
+            return new AsynchronousSemantic(async (accept, interrupt) => {
+                return new Promise((resolve, reject) => {
+                    try {
+                        let count = 0n;
+                        let stop = false;
+                        this.generator((element, index) => {
+                            let result = mapper(element, index);
+                            if (isIterable(result)) {
+                                for (let subElement of result) {
+                                    accept(subElement, count);
+                                    stop = stop || interrupt(subElement, count);
+                                    count++;
+                                }
+                            }
+                            else if (isAsynchronousSemantic(result)) {
+                                result.generator((subElement) => {
+                                    accept(subElement, count);
+                                    stop = stop || interrupt(subElement, count);
+                                    count++;
+                                }, (element) => interrupt(element, count) || stop);
+                            }
+                        }, (element) => interrupt(element, count) || stop).then(resolve, reject);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+            });
+        }
+        throw new TypeError("Invalid arguments.");
+    }
+    flatMap(mapper) {
+        if (isFunction(mapper)) {
+            return new AsynchronousSemantic(async (accept, interrupt) => {
+                return new Promise((resolve, reject) => {
+                    try {
+                        let count = 0n;
+                        let stop = false;
+                        this.generator((element, index) => {
+                            let result = mapper(element, index);
+                            if (isIterable(result)) {
+                                for (let subElement of result) {
+                                    accept(subElement, count);
+                                    stop = stop || interrupt(subElement, count);
+                                    count++;
+                                }
+                                resolve();
+                            }
+                            else if (isAsynchronousSemantic(result)) {
+                                result.generator((subElement) => {
+                                    accept(subElement, count);
+                                    stop = stop || interrupt(subElement, count);
+                                    count++;
+                                }, (element) => interrupt(element, count) || stop).then(resolve, reject);
+                            }
+                        }, () => stop);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+            });
+        }
+        throw new TypeError("Invalid arguments.");
+    }
+    limit(argument) {
+        if (isNumber(argument)) {
+            let limit = BigInt(argument);
+            return new AsynchronousSemantic(async (accept, interrupt) => {
+                return new Promise((resolve, reject) => {
+                    try {
+                        let count = 0n;
+                        this.generator((element) => {
+                            if (count < limit) {
+                                accept(element, count);
+                                count++;
+                            }
+                        }, (element, index) => interrupt(element, index) || count >= limit).then(resolve, reject);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+            });
+        }
+        if (isBigInt(argument)) {
+            let limit = argument;
+            return new AsynchronousSemantic(async (accept, interrupt) => {
+                return new Promise((resolve, reject) => {
+                    try {
+                        let count = 0n;
+                        this.generator((element) => {
+                            if (count < limit) {
+                                accept(element, count);
+                                count++;
+                            }
+                        }, (element, index) => interrupt(element, index) || count >= limit).then(resolve, reject);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+            });
+        }
+        throw new TypeError("Invalid arguments.");
+    }
+    map(mapper) {
+        if (isFunction(mapper)) {
+            return new AsynchronousSemantic(async (accept, interrupt) => {
+                return new Promise((resolve, reject) => {
+                    try {
+                        let stop = false;
+                        this.generator((element, index) => {
+                            let resolved = mapper(element, index);
+                            accept(resolved, index);
+                            stop = stop || interrupt(resolved, index);
+                        }, () => stop).then(resolve, reject);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+            });
+        }
+        throw new TypeError("Invalid arguments.");
+    }
+    peek(consumer) {
+        if (isFunction(consumer)) {
+            return new AsynchronousSemantic(async (accept, interrupt) => {
+                return new Promise((resolve, reject) => {
+                    try {
+                        this.generator((element, index) => {
+                            accept(element, index);
+                            consumer(element, index);
+                        }, interrupt).then(resolve, reject);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+            });
+        }
+        throw new TypeError("Invalid arguments.");
+    }
+    redirect(redirector) {
+        if (isFunction(redirector)) {
+            return new AsynchronousSemantic(async (accept, interrupt) => {
+                return new Promise((resolve, reject) => {
+                    try {
+                        this.generator((element, index) => {
+                            accept(element, redirector(element, index));
+                        }, interrupt).then(resolve, reject);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+            });
+        }
+        throw new TypeError("Invalid arguments.");
+    }
+    reverse() {
+        return new AsynchronousSemantic(async (accept, interrupt) => {
+            return new Promise((resolve, reject) => {
+                try {
+                    this.generator((element, index) => {
+                        accept(element, -index);
+                    }, interrupt).then(resolve, reject);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+    }
+    shuffle(mapper) {
+        if (isFunction(mapper)) {
+            return new AsynchronousSemantic(async (accept, interrupt) => {
+                return new Promise((resolve, reject) => {
+                    try {
+                        this.generator((element, index) => {
+                            accept(element, mapper(element, index));
+                        }, interrupt).then(resolve, reject);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+            });
+        }
+        return new AsynchronousSemantic(async (accept, interrupt) => {
+            return new Promise((resolve, reject) => {
+                try {
+                    this.generator((element, index) => {
+                        accept(element, useHash(element, index));
+                    }, interrupt).then(resolve, reject);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+    }
+    skip(argument) {
+        if (isNumber(argument)) {
+            let n = argument;
+            return new AsynchronousSemantic(async (accept, interrupt) => {
+                return new Promise((resolve, reject) => {
+                    try {
+                        let count = 0n;
+                        let limit = BigInt(n);
+                        this.generator((element, index) => {
+                            if (count < limit) {
+                                count++;
+                            }
+                            else {
+                                accept(element, index);
+                            }
+                        }, interrupt).then(resolve, reject);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+            });
+        }
+        if (isBigInt(argument)) {
+            let n = argument;
+            return new AsynchronousSemantic(async (accept, interrupt) => {
+                return new Promise((resolve, reject) => {
+                    try {
+                        let count = 0n;
+                        this.generator((element, index) => {
+                            if (count < n) {
+                                count++;
+                            }
+                            else {
+                                accept(element, index);
+                            }
+                        }, interrupt).then(resolve, reject);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+            });
+        }
+        throw new TypeError("Invalid arguments.");
+    }
+    source() {
+        return this.generator;
+    }
+    sub(start, end) {
+        if ((isNumber(start) && isNumber(end)) || (isBigInt(start) && isBigInt(end))) {
+            return new AsynchronousSemantic(async (accept, interrupt) => {
+                return new Promise((resolve, reject) => {
+                    try {
+                        let count = 0n;
+                        let resolvedStart = useToBigInt(start);
+                        let resolvedEnd = useToBigInt(end);
+                        let minimum = resolvedStart < resolvedEnd ? resolvedStart : resolvedEnd;
+                        let maximum = resolvedStart < resolvedEnd ? resolvedEnd : resolvedStart;
+                        this.generator((element, index) => {
+                            if (minimum <= count && count < maximum) {
+                                accept(element, index);
+                                count++;
+                            }
+                        }, (element, index) => count >= maximum || interrupt(element, index)).then(resolve, reject);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+            });
+        }
+        throw new TypeError("Invalid arguments.");
+    }
+    takeWhile(predicate) {
+        return new AsynchronousSemantic(async (accept, interrupt) => {
+            return new Promise((resolve, reject) => {
+                try {
+                    let stop = false;
+                    this.generator((element, index) => {
+                        if (predicate(element, index) && stop === false) {
+                            accept(element, index);
+                        }
+                        else {
+                            stop = true;
+                        }
+                    }, (element, index) => stop || interrupt(element, index)).then(resolve, reject);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+    }
+    toAsynchronousCollectable(mapper) {
+        if (isFunction(mapper)) {
+            try {
+                let AsynchronousCollectable = mapper(this.generator);
+                if (isAsynchronousCollectable(AsynchronousCollectable)) {
+                    return AsynchronousCollectable;
+                }
+            }
+            catch (error) {
+                throw new Error("Uncaught error on toAsynchronousCollectable.");
+            }
+        }
+        try {
+            return new AsynchronousUnorderedCollectable(this.generator);
+        }
+        catch (error) {
+            throw new Error("Uncaught error on toAsynchronousCollectable.");
+        }
+    }
+    toBigintStatistics() {
+        try {
+            return new AsynchronousBigIntStatistics(this.generator);
+        }
+        catch (error) {
+            throw new Error("Uncaught error on toBigintStatistics.");
+        }
+    }
+    toNumericStatistics() {
+        try {
+            return new AsynchronousNumericStatistics(this.generator);
+        }
+        catch (error) {
+            throw new Error("Uncaught error on toNumericStatistics.");
+        }
+    }
+    toOrdered() {
+        try {
+            return new AsynchronousOrderedCollectable(this.generator);
+        }
+        catch (error) {
+            throw new Error("Uncaught error on toOrdered.");
+        }
+    }
+    toUnordered() {
+        try {
+            return new AsynchronousUnorderedCollectable(this.generator);
+        }
+        catch (error) {
+            throw new Error(String(error));
+        }
+    }
+    toWindow() {
+        try {
+            return new AsynchronousWindowCollectable(this.generator);
+        }
+        catch (error) {
+            throw new Error("Uncaught error on toWindow.");
+        }
+    }
+    translate(argument1) {
+        if (isNumber(argument1)) {
+            let offset = argument1;
+            return new AsynchronousSemantic(async (accept, interrupt) => {
+                try {
+                    this.generator((element, index) => {
+                        accept(element, index + BigInt(offset));
+                    }, interrupt);
+                }
+                catch (error) {
+                    throw new Error("Uncaught error on translate.");
+                }
+            });
+        }
+        else if (isBigInt(argument1)) {
+            let offset = argument1;
+            return new AsynchronousSemantic(async (accept, interrupt) => {
+                try {
+                    this.generator((element, index) => {
+                        accept(element, index + offset);
+                    }, interrupt);
+                }
+                catch (error) {
+                    throw new Error("Uncaught error on translate.");
+                }
+            });
+        }
+        else if (isFunction(argument1)) {
+            let translator = argument1;
+            return new AsynchronousSemantic(async (accept, interrupt) => {
+                try {
+                    this.generator((element, index) => {
+                        accept(element, index + translator(element, index));
+                    }, interrupt);
+                }
+                catch (error) {
+                    throw new Error("Uncaught error on translate.");
+                }
+            });
+        }
+        throw new TypeError("Invalid arguments.");
+    }
+}
+;
+export class AsynchronousCollectable {
+    AsynchronousCollectable = AsynchronousCollectableSymbol;
+    [Symbol.toStringTag] = "AsynchronousCollectable";
+    constructor() {
+        Object.defineProperty(this, "AsynchronousCollectable", {
+            value: AsynchronousCollectableSymbol,
+            enumerable: false,
+            writable: false,
+            configurable: false
+        });
+    }
+    async *[Symbol.asyncIterator]() {
+        for await (let element of await this.toArray()) {
+            yield element;
+        }
+    }
+    async anyMatch(predicate) {
+        if (isFunction(predicate)) {
+            try {
+                return await useAsynchronousAnyMatch(predicate).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on anyMatch.");
+            }
+        }
+        throw new TypeError("Predicate must be a function.");
+    }
+    async allMatch(predicate) {
+        return useAsynchronousAllMatch(predicate).collect(this.source());
+    }
+    async collect(argument1, argument2, argument3, argument4) {
+        try {
+            if (isAsynchronousCollector(argument1)) {
+                let collector = argument1;
+                return await collector.collect(this.source());
+            }
+            if (isFunction(argument1) && isFunction(argument2) && isFunction(argument3)) {
+                let identity = argument1;
+                let accumulator = argument2;
+                let finisher = argument3;
+                return await useAsynchronousCollect(identity, accumulator, finisher).collect(this.source());
+            }
+            if (isFunction(argument1) && isFunction(argument2) && isFunction(argument3) && isFunction(argument4)) {
+                let identity = argument1;
+                let interrupt = argument2;
+                let accumulator = argument3;
+                let finisher = argument4;
+                return await useAsynchronousCollect(identity, interrupt, accumulator, finisher).collect(this.source());
+            }
+        }
+        catch (error) {
+            throw new Error("Uncaught error on collect.");
+        }
+        throw new TypeError("Invalid arguments.");
+    }
+    async count() {
+        return await useAsynchronousCount().collect(this.source());
+    }
+    async error(argument1, argument2, argument3) {
+        if (invalidate(argument1) && invalidate(argument2) && invalidate(argument3)) {
+            try {
+                await useAsynchronousError().collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on error.");
+            }
+        }
+        else if (isFunction(argument1) && invalidate(argument2) && invalidate(argument3)) {
+            try {
+                let accumulator = argument1;
+                await useAsynchronousError(accumulator).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on error.");
+            }
+        }
+        else if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
+            try {
+                let prefix = argument1;
+                let accumulator = argument2;
+                let suffix = argument3;
+                await useAsynchronousError(prefix, accumulator, suffix).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on error.");
+            }
+        }
+        else {
+            throw new TypeError("Invalid arguments.");
+        }
+    }
+    async isEmpty() {
+        return await this.count() === 0n;
+    }
+    async findAny() {
+        try {
+            return await useAsynchronousFindAny().collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on findAny.");
+        }
+    }
+    async findAt(index) {
+        if (isBigInt(index)) {
+            try {
+                return await useAsynchronousFindAt(index).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on findAt.");
+            }
+        }
+        else if (isNumber(index)) {
+            try {
+                return await useAsynchronousFindAt(index).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on findAt.");
+            }
+        }
+        throw new TypeError("Index must be a bigint.");
+    }
+    async findFirst() {
+        try {
+            return await useAsynchronousFindFirst().collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on findFirst.");
+        }
+    }
+    async findLast() {
+        try {
+            return await useAsynchronousFindLast().collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on findLast.");
+        }
+    }
+    async findMaximum(argument1) {
+        try {
+            let comparator = isFunction(argument1) ? argument1 : useCompare;
+            return await useAsynchronousFindMaximum(comparator).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on findMaximum.");
+        }
+    }
+    async findMinimum(argument1) {
+        try {
+            let comparator = isFunction(argument1) ? argument1 : useCompare;
+            return await useAsynchronousFindMinimum(comparator).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on findMinimum.");
+        }
+    }
+    async forEach(action) {
+        if (isFunction(action)) {
+            try {
+                await useAsynchronousForEach(action).collect(this);
+            }
+            catch (error) {
+                throw new Error("Uncaught error on forEach.");
+            }
+        }
+        else {
+            throw new TypeError("Action must be a function.");
+        }
+    }
+    async group(classifier) {
+        if (isFunction(classifier)) {
+            try {
+                return await useAsynchronousGroup(classifier).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on group.");
+            }
+        }
+        throw new TypeError("Classifier must be a function.");
+    }
+    async groupBy(keyExtractor, valueExtractor) {
+        if (isFunction(keyExtractor) && isFunction(valueExtractor)) {
+            try {
+                return await useAsynchronousGroupBy(keyExtractor, valueExtractor).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on groupBy.");
+            }
+        }
+        throw new TypeError("Key and value extractors must be functions.");
+    }
+    async join(argument1, argument2, argument3) {
+        if (invalidate(argument1) && invalidate(argument2) && invalidate(argument3)) {
+            try {
+                return await useAsynchronousJoin().collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on join.");
+            }
+        }
+        else if (isString(argument1) && invalidate(argument2) && invalidate(argument3)) {
+            try {
+                let delimiter = argument1;
+                return await useAsynchronousJoin(delimiter).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on join.");
+            }
+        }
+        else if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
+            try {
+                let prefix = argument1;
+                let accumulator = argument2;
+                let suffix = argument3;
+                return await useAsynchronousJoin(prefix, accumulator, suffix).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on join.");
+            }
+        }
+        else if (isString(argument1) && isString(argument2) && isString(argument3)) {
+            try {
+                let prefix = argument1;
+                let delimiter = argument2;
+                let suffix = argument3;
+                return await useAsynchronousJoin(prefix, delimiter, suffix).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on join.");
+            }
+        }
+        throw new TypeError("Invalid arguments.");
+    }
+    async log(argument1, argument2, argument3) {
+        if (isFunction(argument1) && invalidate(argument2) && invalidate(argument3)) {
+            try {
+                let accumulator = argument1;
+                await useAsynchronousLog(accumulator).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on log.");
+            }
+        }
+        else if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
+            try {
+                let prefix = argument1;
+                let accumulator = argument2;
+                let suffix = argument3;
+                await useAsynchronousLog(prefix, accumulator, suffix).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on log.");
+            }
+        }
+        else {
+            try {
+                useAsynchronousLog().collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on log.");
+            }
+        }
+    }
+    async nonMatch(predicate) {
+        if (isFunction(predicate)) {
+            try {
+                return await useAsynchronousNoneMatch(predicate).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on nonMatch.");
+            }
+        }
+        throw new TypeError("Predicate must be a function.");
+    }
+    async partition(count) {
+        if (isBigInt(count)) {
+            try {
+                return await useAsynchronousPartition(count).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on partition.");
+            }
+        }
+        throw new TypeError("Count must be a BigInt.");
+    }
+    async partitionBy(classifier) {
+        if (isFunction(classifier)) {
+            try {
+                let collector = useAsynchronousPartitionBy(classifier);
+                return await collector.collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on partitionBy.");
+            }
+        }
+        throw new TypeError("Classifier must be a function.");
+    }
+    async reduce(argument1, argument2, argument3) {
+        if (isFunction(argument1) && invalidate(argument2) && invalidate(argument3)) {
+            try {
+                let accumulator = argument1;
+                return await useAsynchronousReduce(accumulator).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on reduce.");
+            }
+        }
+        else if (validate(argument1) && isFunction(argument2) && invalidate(argument3)) {
+            try {
+                let identity = argument1;
+                let accumulator = argument2;
+                return await useAsynchronousReduce(identity, accumulator).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on reduce.");
+            }
+        }
+        else if (validate(argument1) && isFunction(argument2) && isFunction(argument3)) {
+            try {
+                let identity = argument1;
+                let accumulator = argument2;
+                let finisher = argument3;
+                return await useAsynchronousReduce(identity, accumulator, finisher).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on reduce.");
+            }
+        }
+        else {
+            throw new TypeError("Invalid arguments.");
+        }
+    }
+    semantic() {
+        let source = this.source();
+        if (isFunction(source)) {
+            try {
+                return new AsynchronousSemantic(source);
+            }
+            catch (error) {
+                throw new Error("Uncaught error on semantic.");
+            }
+        }
+        else {
+            throw new TypeError("Invalid source.");
+        }
+    }
+    async toArray() {
+        try {
+            return useAsynchronousToArray().collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on toArray.");
+        }
+    }
+    async toMap(keyExtractor, valueExtractor = (element) => element) {
+        try {
+            return await useAsynchronousToMap(keyExtractor, valueExtractor).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on toMap.");
+        }
+    }
+    async toSet() {
+        try {
+            return await useAsynchronousToSet().collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on toSet.");
+        }
+    }
+    async write(argument1, argument2) {
+        if (isObject(argument1)) {
+            try {
+                let stream = argument1;
+                if (isFunction(argument2)) {
+                    let accumulator = argument2;
+                    return await useAsynchronousWrite(stream, accumulator).collect(this.source());
+                }
+                else {
+                    return await useAsynchronousWrite(stream).collect(this.source());
+                }
+            }
+            catch (error) {
+                throw new Error("Uncaught error on write.");
+            }
+        }
+        throw new TypeError("Invalid arguments.");
+    }
+}
+;
+export class AsynchronousOrderedCollectable extends AsynchronousCollectable {
+    OrderedCollectable = AsynchronousOrderedCollectableSymbol;
+    buffer = [];
+    listeners = [];
+    complete = false;
+    [Symbol.toStringTag] = "AsynchronousOrderedCollectable";
+    constructor(argument1, argument2) {
+        super();
+        if (isFunction(argument1)) {
+            try {
+                if (isFunction(argument2)) {
+                    let collector = useAsynchronousToArray();
+                    collector.collect(argument1).then((elements) => {
+                        this.buffer = elements.sort(argument2).map((element, index) => {
+                            return {
+                                element: element,
+                                index: BigInt(index)
+                            };
+                        });
+                        for (let listener of this.listeners) {
+                            listener(this.buffer);
+                        }
+                        this.complete = true;
+                        Object.freeze(this.complete);
+                        Object.freeze(this.buffer);
+                    });
+                }
+                else {
+                    let collector = useAsynchronousToArray();
+                    collector.collect(argument1).then((elements) => {
+                        this.buffer = elements.sort(useCompare).map((element, index) => {
+                            return {
+                                element: element,
+                                index: BigInt(index)
+                            };
+                        });
+                        for (let listener of this.listeners) {
+                            listener(this.buffer);
+                        }
+                        this.complete = true;
+                        Object.freeze(this.complete);
+                        Object.freeze(this.buffer);
+                    });
+                }
+                Object.defineProperties(this, {
+                    "AsynchronousOrderedCollectable": {
+                        value: AsynchronousOrderedCollectableSymbol,
+                        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.");
+            }
+        }
+        else {
+            throw new TypeError("Source must be an iterable or a generator function.");
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        for await (let element of await this.toArray()) {
+            yield element;
+        }
+    }
+    async findAny() {
+        if (this.complete === true) {
+            return await new Promise((resolve, reject) => {
+                try {
+                    if (this.buffer.length > 0) {
+                        for (let { element } of this.buffer) {
+                            if (Math.random() < 0.5) {
+                                resolve(element);
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        }
+        return await new Promise((resolve, reject) => {
+            try {
+                this.listeners.push((buffer) => {
+                    if (this.buffer.length > 0) {
+                        for (let { element } of buffer) {
+                            if (Math.random() < 0.5) {
+                                resolve(element);
+                            }
+                        }
+                    }
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    async findAt(target) {
+        if (isBigInt(target)) {
+            return await new Promise((resolve, reject) => {
+                try {
+                    if (this.complete === true) {
+                        if (this.buffer.length > 0) {
+                            for (let { element, index } of this.buffer) {
+                                if (index === target) {
+                                    resolve(element);
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        this.listeners.push((buffer) => {
+                            if (this.buffer.length > 0) {
+                                for (let { element, index } of buffer) {
+                                    if (index === target) {
+                                        resolve(element);
+                                    }
+                                }
+                            }
+                        });
+                    }
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        }
+        else if (isNumber(target)) {
+            return await new Promise((resolve, reject) => {
+                try {
+                    if (this.complete === true) {
+                        if (this.buffer.length > 0) {
+                            for (let { element, index } of this.buffer) {
+                                if (Number(index) === target) {
+                                    resolve(element);
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        this.listeners.push((buffer) => {
+                            if (this.buffer.length > 0) {
+                                for (let { element, index } of buffer) {
+                                    if (Number(index) === target) {
+                                        resolve(element);
+                                    }
+                                }
+                            }
+                        });
+                    }
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        }
+        throw new TypeError("Invalid arguments.");
+    }
+    async findFirst() {
+        return await new Promise((resolve, reject) => {
+            try {
+                if (this.complete === true) {
+                    if (this.buffer.length > 0) {
+                        resolve(this.buffer[0].element);
+                    }
+                }
+                else {
+                    this.listeners.push((buffer) => {
+                        if (buffer.length > 0) {
+                            resolve(buffer[0].element);
+                        }
+                    });
+                }
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    async findLast() {
+        return await new Promise((resolve, reject) => {
+            try {
+                if (this.complete === true) {
+                    if (this.buffer.length > 0) {
+                        resolve(this.buffer[this.buffer.length - 1].element);
+                    }
+                }
+                else {
+                    this.listeners.push((buffer) => {
+                        if (buffer.length > 0) {
+                            resolve(buffer[this.buffer.length - 1].element);
+                        }
+                    });
+                }
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    async findMaximum(argument1) {
+        if (isFunction(argument1)) {
+            let comparator = argument1;
+            return await new Promise((resolve, reject) => {
+                try {
+                    if (this.complete === true) {
+                        if (this.buffer.length > 0) {
+                            resolve(this.buffer.map((indexed) => indexed.element).sort(comparator)[this.buffer.length - 1]);
+                        }
+                    }
+                    else {
+                        this.listeners.push((buffer) => {
+                            if (buffer.length > 0) {
+                                resolve(this.buffer.map((indexed) => indexed.element).sort(comparator)[this.buffer.length - 1]);
+                            }
+                        });
+                    }
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        }
+        else {
+            let comparator = (a, b) => Number(a.index - b.index);
+            return await new Promise((resolve, reject) => {
+                try {
+                    if (this.complete === true) {
+                        if (this.buffer.length > 0) {
+                            resolve(this.buffer.sort(comparator).map((indexed) => indexed.element)[this.buffer.length - 1]);
+                        }
+                    }
+                    else {
+                        this.listeners.push((buffer) => {
+                            if (buffer.length > 0) {
+                                resolve(this.buffer.sort(comparator).map((indexed) => indexed.element)[this.buffer.length - 1]);
+                            }
+                        });
+                    }
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        }
+    }
+    async findMinimum(argument1) {
+        if (isFunction(argument1)) {
+            let comparator = argument1;
+            return await new Promise((resolve, reject) => {
+                try {
+                    if (this.complete === true) {
+                        if (this.buffer.length > 0) {
+                            resolve(this.buffer.map((indexed) => indexed.element).sort(comparator)[0]);
+                        }
+                    }
+                    else {
+                        this.listeners.push((buffer) => {
+                            if (buffer.length > 0) {
+                                resolve(this.buffer.map((indexed) => indexed.element).sort(comparator)[0]);
+                            }
+                        });
+                    }
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        }
+        else {
+            let comparator = (a, b) => Number(a.index - b.index);
+            return await new Promise((resolve, reject) => {
+                try {
+                    if (this.complete === true) {
+                        if (this.buffer.length > 0) {
+                            resolve(this.buffer.sort(comparator).map((indexed) => indexed.element)[0]);
+                        }
+                    }
+                    else {
+                        this.listeners.push((buffer) => {
+                            if (buffer.length > 0) {
+                                resolve(this.buffer.sort(comparator).map((indexed) => indexed.element)[0]);
+                            }
+                        });
+                    }
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        }
+    }
+    source() {
+        return async (accept, interrupt) => {
+            return await new Promise((resolve, reject) => {
+                try {
+                    if (this.complete === true) {
+                        for (let { index, element } of this.buffer) {
+                            if (interrupt(element, index)) {
+                                break;
+                            }
+                            accept(element, index);
+                        }
+                        resolve();
+                    }
+                    else {
+                        this.listeners.push((buffer) => {
+                            for (let { index, element } of buffer) {
+                                if (interrupt(element, index)) {
+                                    break;
+                                }
+                                accept(element, index);
+                            }
+                        });
+                        resolve();
+                    }
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        };
+    }
+    async isEmpty() {
+        return new Promise((resolve) => {
+            this.listeners.push((buffer) => {
+                resolve(buffer.length === 0);
+            });
+        });
+    }
+    async count() {
+        if (this.complete === true) {
+            return BigInt(this.buffer.length);
+        }
+        return await new Promise((resolve) => {
+            this.listeners.push((buffer) => {
+                resolve(BigInt(buffer.length));
+            });
+        });
+    }
+}
+;
+export class AsynchronousUnorderedCollectable extends AsynchronousCollectable {
+    AsynchronousUnorderedCollectable = AsynchronousUnorderedCollectableSymbol;
+    [Symbol.toStringTag] = "AsynchronousUnorderedCollectable";
+    buffer = new Map();
+    complete = false;
+    listeners = [];
+    constructor(argument1) {
+        super();
+        if (isFunction(argument1)) {
+            let generator = argument1;
+            generator((element, index) => {
+                this.buffer.set(index, element);
+            }, () => false).then(() => {
+                for (let listener of this.listeners) {
+                    listener(this.buffer);
+                }
+                this.complete = true;
+                Object.freeze(this.complete);
+                Object.freeze(this.buffer);
+            });
+            Object.defineProperties(this, {
+                "AsynchronousUnorderedCollectable": {
+                    value: AsynchronousUnorderedCollectableSymbol,
+                    writable: false,
+                    enumerable: false,
+                    configurable: false
+                }
+            });
+        }
+        else {
+            throw new TypeError("Source must be an iterable or a generator function.");
+        }
+    }
+    source() {
+        return async (accept, interrupt) => {
+            return await new Promise((resolve, reject) => {
+                try {
+                    if (this.complete === true) {
+                        for (let [index, element] of this.buffer) {
+                            if (interrupt(element, index)) {
+                                break;
+                            }
+                            accept(element, index);
+                        }
+                        resolve();
+                    }
+                    else {
+                        this.listeners.push((buffer) => {
+                            for (let [index, element] of buffer) {
+                                if (interrupt(element, index)) {
+                                    break;
+                                }
+                                accept(element, index);
+                            }
+                        });
+                        resolve();
+                    }
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        };
+    }
+    async *[Symbol.asyncIterator]() {
+        for await (let element of await this.toArray()) {
+            yield element;
+        }
+    }
+}
+;
+export class AsynchronousStatistics extends AsynchronousOrderedCollectable {
+    AsynchronousStatistics = AsynchronousStatisticsSymbol;
+    [Symbol.toStringTag] = "AsynchronousStatistics";
+    constructor(parameter, comparator) {
+        super(parameter, validate(comparator) ? comparator : useCompare);
+        Object.defineProperties(this, {
+            "AsynchronousStatistics": {
+                value: AsynchronousStatisticsSymbol,
+                enumerable: false,
+                writable: false,
+                configurable: false
+            }
+        });
+    }
+    async *[Symbol.asyncIterator]() {
+        for await (let element of await this.toArray()) {
+            yield element;
+        }
+    }
+    async frequency() {
+        return await useAsynchronousFrequency().collect(this.source());
+    }
+}
+;
+export class AsynchronousBigIntStatistics extends AsynchronousStatistics {
+    BigIntStatistics = AsynchronousBigIntStatisticsSymbol;
+    [Symbol.toStringTag] = "AsynchronousBigIntStatistics";
+    constructor(parameter, comparator) {
+        super(parameter, comparator || useCompare);
+        Object.defineProperties(this, {
+            "AsynchronousBigIntStatistics": {
+                value: AsynchronousBigIntStatisticsSymbol,
+                enumerable: false,
+                writable: false,
+                configurable: false
+            }
+        });
+    }
+    async *[Symbol.asyncIterator]() {
+        for await (let element of await this.toArray()) {
+            yield element;
+        }
+    }
+    async average(argument1) {
+        if (await this.isEmpty()) {
+            return 0n;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            return await useAsynchronousBigIntAverage(mapper).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on average.");
+        }
+    }
+    async range(argument1) {
+        if (await this.isEmpty()) {
+            return 0n;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            let minimum = await this.findFirst();
+            let maximum = await this.findLast();
+            let difference = mapper(maximum) - mapper(minimum);
+            return difference < 0 ? -difference : difference;
+        }
+        catch (error) {
+            throw new Error("Uncaught error on range.");
+        }
+    }
+    async variance(argument1) {
+        if (await this.isEmpty() || await this.count() === 1n) {
+            return 0n;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            return await useAsynchronousBigIntVariance(mapper).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on variance.");
+        }
+    }
+    async standardDeviation(argument1) {
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            let variance = await this.variance(mapper);
+            return BigInt(Math.sqrt(Number(variance)));
+        }
+        catch (error) {
+            throw new Error("Uncaught error on standardDeviation.");
+        }
+    }
+    async mean(argument1) {
+        if (await this.isEmpty()) {
+            return 0n;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            return await useAsynchronousBigIntAverage(mapper).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on mean.");
+        }
+    }
+    async median(argument1) {
+        if (await this.isEmpty()) {
+            return 0n;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            return useAsynchronousBigIntMedian(mapper).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on median.");
+        }
+    }
+    async mode(argument1) {
+        if (await this.isEmpty()) {
+            return 0n;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            return useAsynchronousBigIntMode(mapper).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on mode.");
+        }
+    }
+    async summate(argument1) {
+        if (await this.isEmpty()) {
+            return 0n;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            return await useAsynchronousBigIntSummate(mapper).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on summate.");
+        }
+    }
+    async quantile(quantile, argument1) {
+        if (await this.isEmpty()) {
+            return 0n;
+        }
+        if (!isNumber(quantile) || quantile < 0 || quantile > 1) {
+            throw new RangeError("Invalid quantile.");
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            let count = Number(this.count());
+            let index = Math.floor(quantile * count);
+            if (index === count) {
+                index--;
+            }
+            let value = mapper(await this.findAt(index));
+            return value;
+        }
+        catch (error) {
+            throw new Error("Uncaught error on quantile.");
+        }
+    }
+    async interquartileRange(argument1) {
+        if (await this.isEmpty()) {
+            return 0n;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            let lower = await this.quantile(0.25, mapper);
+            let upper = await this.quantile(0.75, mapper);
+            return upper - lower;
+        }
+        catch (error) {
+            throw new Error("Uncaught error on interquartileRange.");
+        }
+    }
+    async skewness(argument1) {
+        if (await this.isEmpty()) {
+            return 0n;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            let mean = await this.mean(mapper);
+            let standardDeviation = await this.standardDeviation(mapper);
+            if (standardDeviation === 0n) {
+                return 0n;
+            }
+            let data = (await this.toArray()).map((element) => mapper(element));
+            let summate = 0n;
+            for (let value of data) {
+                let z = value - mean;
+                summate += z * z * z;
+            }
+            return summate / BigInt(data.length);
+        }
+        catch (error) {
+            throw new Error("Uncaught error on skewness.");
+        }
+    }
+    async kurtosis(argument1) {
+        if (await this.isEmpty()) {
+            return 0n;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            let mean = await this.mean(mapper);
+            let standardDeviation = await this.standardDeviation(mapper);
+            if (standardDeviation === 0n) {
+                return 0n;
+            }
+            let data = (await this.toArray()).map((element) => mapper(element));
+            let summate = 0n;
+            let count = data.length;
+            for (let value of data) {
+                let z = value - mean;
+                summate += z * z * z * z;
+            }
+            return summate / BigInt(count * count) - 3n;
+        }
+        catch (error) {
+            throw new Error("Uncaught error on kurtosis.");
+        }
+    }
+}
+;
+export class AsynchronousNumericStatistics extends AsynchronousStatistics {
+    AsynchronousNumericStatistics = AsynchronousNumericStatisticsSymbol;
+    [Symbol.toStringTag] = "AsynchronousNumericStatistics";
+    constructor(parameter, comparator) {
+        super(parameter, comparator || useCompare);
+        Object.defineProperties(this, {
+            "AsynchronousNumericStatistics": {
+                value: AsynchronousNumericStatisticsSymbol,
+                enumerable: false,
+                writable: false,
+                configurable: false
+            }
+        });
+    }
+    async *[Symbol.asyncIterator]() {
+        for await (let element of await this.toArray()) {
+            yield element;
+        }
+    }
+    async average(mapper) {
+        if (await this.isEmpty()) {
+            return 0;
+        }
+        try {
+            if (isFunction(mapper)) {
+                return useAsynchronousNumericAverage(mapper).collect(this.source());
+            }
+            return useAsynchronousNumericAverage().collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on average.");
+        }
+    }
+    async range(argument1) {
+        if (await this.isEmpty()) {
+            return 0;
+        }
+        try {
+            if (await this.count() === 1n) {
+                return 0;
+            }
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            let minimum = await this.findFirst();
+            let maximum = await this.findLast();
+            return mapper(maximum) - mapper(minimum);
+        }
+        catch (error) {
+            throw new Error("Uncaught error on range.");
+        }
+    }
+    async variance(argument1) {
+        if (await this.isEmpty() || await this.count() === 1n) {
+            return 0;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            return await useAsynchronousNumericVariance(mapper).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on variance.");
+        }
+    }
+    async standardDeviation(argument1) {
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            return await useAsynchronousNumericStandardDeviation(mapper).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on standardDeviation.");
+        }
+    }
+    async mean(argument1) {
+        if (await this.isEmpty()) {
+            return 0;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            return useAsynchronousNumericAverage(mapper).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on mean.");
+        }
+    }
+    async median(argument1) {
+        if (await this.isEmpty()) {
+            return 0;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            return await useAsynchronousNumericMedian(mapper).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on median.");
+        }
+    }
+    async mode(argument1) {
+        if (await this.isEmpty()) {
+            return 0;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            return await useAsynchronousNumericMode(mapper).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on mode.");
+        }
+    }
+    async summate(argument1) {
+        if (await this.isEmpty()) {
+            return 0;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            return useAsynchronousNumericSummate(mapper).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on summate.");
+        }
+    }
+    async quantile(quantile, argument1) {
+        if (await this.isEmpty()) {
+            return 0;
+        }
+        if (quantile < 0 || quantile > 1) {
+            throw new RangeError("Invalid quantile.");
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            let count = Number(await this.count());
+            let index = Math.floor(quantile * count);
+            if (index === count) {
+                index--;
+            }
+            let value = mapper(await this.findAt(index));
+            return value;
+        }
+        catch (error) {
+            throw new Error("Uncaught error on quantile.");
+        }
+    }
+    async interquartileRange(argument1) {
+        if (await this.isEmpty()) {
+            return 0;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            let lower = await this.quantile(0.25, mapper);
+            let upper = await this.quantile(0.75, mapper);
+            return upper - lower;
+        }
+        catch (error) {
+            throw new Error("Uncaught error on interquartileRange.");
+        }
+    }
+    async skewness(argument1) {
+        if (await this.isEmpty()) {
+            return 0;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            let mean = await this.mean(mapper);
+            let standardDeviation = await this.standardDeviation(mapper);
+            if (standardDeviation === 0) {
+                return 0;
+            }
+            let data = (await this.toArray()).map((element) => mapper(element));
+            let summate = 0;
+            for (let value of data) {
+                let z = (value - mean) / standardDeviation;
+                summate += Math.pow(z, 3);
+            }
+            return summate / data.length;
+        }
+        catch (error) {
+            throw new Error("Uncaught error on skewness.");
+        }
+    }
+    async kurtosis(argument1) {
+        if (await this.isEmpty()) {
+            return 0;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            let mean = await this.mean(mapper);
+            let standardDeviation = await this.standardDeviation(mapper);
+            if (standardDeviation === 0) {
+                return 0;
+            }
+            let data = (await this.toArray()).map((element) => mapper(element));
+            let summate = 0;
+            for (let value of data) {
+                let z = (value - mean) / standardDeviation;
+                summate += Math.pow(z, 4);
+            }
+            return summate / (data.length * data.length) - 3;
+        }
+        catch (error) {
+            throw new Error("Uncaught error on kurtosis.");
+        }
+    }
+}
+;
+export class AsynchronousWindowCollectable extends AsynchronousOrderedCollectable {
+    WindowCollectable = AsynchronousWindowCollectableSymbol;
+    [Symbol.toStringTag] = "AsynchronousWindowCollectable";
+    constructor(parameter, comparator = useCompare) {
+        super(parameter, comparator);
+        Object.defineProperties(this, {
+            "AsynchronousWindowCollectable": {
+                value: AsynchronousWindowCollectableSymbol,
+                writable: false,
+                enumerable: false,
+                configurable: false
+            }
+        });
+    }
+    async *[Symbol.asyncIterator]() {
+        for await (let element of await this.toArray()) {
+            yield element;
+        }
+    }
+    slide(size, step = 1n) {
+        if (size > 0n && step > 0n) {
+            return new AsynchronousSemantic(async (accepet, interrupt) => {
+                return await new Promise((resolve, reject) => {
+                    try {
+                        let index = 0n;
+                        for (let start = 0n; start < BigInt(this.buffer.length); start += step) {
+                            let end = start + size;
+                            let inner = new AsynchronousSemantic(async (accept, interrupt) => {
+                                return await new Promise((resolve, reject) => {
+                                    for (let index = start; index < end && index < BigInt(this.buffer.length); index++) {
+                                        let indexed = this.buffer[Number(index)];
+                                        if (invalidate(indexed)) {
+                                            continue;
+                                        }
+                                        if (interrupt(indexed.element, index)) {
+                                            reject(new Error("Interrupted."));
+                                            break;
+                                        }
+                                        accept(indexed.element, index);
+                                    }
+                                    resolve();
+                                });
+                            });
+                            if (interrupt(inner, index)) {
+                                reject(new Error("Interrupted."));
+                                break;
+                            }
+                            accepet(inner, index);
+                            index++;
+                        }
+                        resolve();
+                    }
+                    catch (error) {
+                        throw new Error("Uncaught error on slide.");
+                    }
+                });
+            });
+        }
+        throw new RangeError("Invalid arguments.");
+    }
+    tumble(size) {
+        if (isBigInt(size) && size > 0n) {
+            try {
+                return this.slide(size, size);
+            }
+            catch (error) {
+                throw new Error("Uncaught error on tumble.");
+            }
+        }
+        throw new RangeError("Invalid arguments.");
+    }
+}
+;