semantic-typescript 0.5.3 → 0.6.0

package/dist/asynchronous/collector.js

@@ -0,0 +1,800 @@
+import { isFunction, isNumber, isBigInt, isBoolean, isString, isObject, isAsyncIterable, isAsyncFunction } from "../guard";
+import { useCompare, useToBigInt, useToNumber } from "../hook";
+import { AsynchronousCollectorSymbol } from "../symbol";
+import { invalidate, validate } from "../utility";
+export class AsynchronousCollector {
+    identity;
+    interrupt;
+    accumulator;
+    finisher;
+    AsynchronousCollector = AsynchronousCollectorSymbol;
+    constructor(identity, interrupt, accumulator, finisher) {
+        if (isFunction(identity) && isFunction(interrupt) && isFunction(accumulator) && isFunction(finisher)) {
+            this.identity = identity;
+            this.interrupt = interrupt;
+            this.accumulator = accumulator;
+            this.finisher = finisher;
+            Object.defineProperties(this, {
+                "identity": {
+                    value: identity,
+                    writable: false,
+                    enumerable: true,
+                    configurable: false
+                },
+                "interrupt": {
+                    value: interrupt,
+                    writable: false,
+                    enumerable: true,
+                    configurable: false
+                },
+                "accumulator": {
+                    value: accumulator,
+                    writable: false,
+                    enumerable: true,
+                    configurable: false
+                },
+                "finisher": {
+                    value: finisher,
+                    writable: false,
+                    enumerable: true,
+                    configurable: false
+                },
+                "AsynchronousCollector": {
+                    value: AsynchronousCollectorSymbol,
+                    writable: false,
+                    enumerable: false,
+                    configurable: false
+                }
+            });
+            Object.freeze(this);
+        }
+        else {
+            throw new TypeError("Invalid arguments");
+        }
+    }
+    async collect(argument1, argument2) {
+        if (isAsyncFunction(argument1) || isFunction(argument1)) {
+            console.log("Function");
+            return await new Promise(async (resolve, reject) => {
+                try {
+                    let generator = argument1;
+                    let accumulator = this.identity();
+                    let count = 0n;
+                    await generator((element, index) => {
+                        accumulator = this.accumulator(accumulator, element, index);
+                        console.log(accumulator);
+                        count++;
+                    }, (element, index) => this.interrupt(element, index, accumulator));
+                    resolve(this.finisher(accumulator));
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        }
+        else if (isAsyncIterable(argument1)) {
+            return new Promise(async (resolve, reject) => {
+                try {
+                    let iterable = argument1;
+                    let accumulator = this.identity();
+                    let count = 0n;
+                    for await (let element of iterable) {
+                        if (this.interrupt(element, count, accumulator)) {
+                            break;
+                        }
+                        accumulator = this.accumulator(accumulator, element, count);
+                        count++;
+                    }
+                    resolve(this.finisher(accumulator));
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        }
+        else if (isNumber(argument1) && isNumber(argument2)) {
+            return new Promise(async (resolve, reject) => {
+                try {
+                    let start = argument1 < argument2 ? argument1 : argument2;
+                    let end = argument1 > argument2 ? argument1 : argument2;
+                    let accumulator = this.identity();
+                    let count = 0n;
+                    for (let i = start; i < end; i++) {
+                        if (this.interrupt(i, count, accumulator)) {
+                            break;
+                        }
+                        accumulator = this.accumulator(accumulator, i, count);
+                        count++;
+                    }
+                    resolve(this.finisher(accumulator));
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        }
+        else if (isBigInt(argument1) && isBigInt(argument2)) {
+            return new Promise(async (resolve, reject) => {
+                try {
+                    let start = argument1 < argument2 ? argument1 : argument2;
+                    let end = argument1 > argument2 ? argument1 : argument2;
+                    let accumulator = this.identity();
+                    let count = 0n;
+                    for (let i = start; i < end; i++) {
+                        if (this.interrupt(i, count, accumulator)) {
+                            break;
+                        }
+                        accumulator = this.accumulator(accumulator, i, count);
+                        count++;
+                    }
+                    resolve(this.finisher(accumulator));
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        }
+        throw new Error("Invalid arguments.");
+    }
+    static full(identity, accumulator, finisher) {
+        return new AsynchronousCollector(identity, () => false, accumulator, finisher);
+    }
+    static shortable(identity, interrupt, accumulator, finisher) {
+        return new AsynchronousCollector(identity, interrupt, accumulator, finisher);
+    }
+}
+;
+;
+export let useAsynchronousAnyMatch = (predicate) => {
+    if (isFunction(predicate)) {
+        return AsynchronousCollector.shortable(() => false, (_element, _index, accumulator) => isBoolean(accumulator) && accumulator, (accumulator, element, index) => accumulator || predicate(element, index), (accumulator) => accumulator);
+    }
+    throw new TypeError("Predicate must be a function.");
+};
+;
+export let useAsynchronousAllMatch = (predicate) => {
+    if (isFunction(predicate)) {
+        return AsynchronousCollector.shortable(() => true, (_element, _index, accumulator) => isBoolean(accumulator) && !accumulator, (accumulator, element, index) => accumulator && predicate(element, index), (accumulator) => accumulator);
+    }
+    throw new TypeError("Predicate must be a function.");
+};
+;
+export let useAsynchronousCollect = (argument1, argument2, argument3, argument4) => {
+    if (isFunction(argument1) && isFunction(argument2) && isFunction(argument3) && isFunction(argument4)) {
+        let identity = argument1;
+        let interrupt = argument2;
+        let accumulator = argument3;
+        let finisher = argument4;
+        return AsynchronousCollector.shortable(identity, interrupt, accumulator, finisher);
+    }
+    if (isFunction(argument1) && isFunction(argument2) && isFunction(argument3)) {
+        let identity = argument1;
+        let accumulator = argument2;
+        let finisher = argument3;
+        return AsynchronousCollector.full(identity, accumulator, finisher);
+    }
+    throw new TypeError("Identity, accumulator, and finisher must be functions.");
+};
+export let useAsynchronousCount = () => {
+    return AsynchronousCollector.full(() => 0n, (count) => count + 1n, (count) => count);
+};
+;
+export let useAsynchronousError = (argument1, argument2, argument3) => {
+    if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
+        let prefix = argument1;
+        let accumulator = argument2;
+        let suffix = argument3;
+        return AsynchronousCollector.full(() => prefix, accumulator, (text) => {
+            let result = text + suffix;
+            console.error(result);
+            return result;
+        });
+    }
+    else if (isFunction(argument1)) {
+        let prefix = "[";
+        let accumulator = argument2;
+        let suffix = "]";
+        return AsynchronousCollector.full(() => prefix, accumulator, (text) => {
+            let result = text + suffix;
+            console.error(result);
+            return result;
+        });
+    }
+    else {
+        return AsynchronousCollector.full(() => "[", (accumulator, element) => {
+            if (isString(accumulator) && isString(element)) {
+                return accumulator + element + ",";
+            }
+            return String(accumulator) + String(element) + ",";
+        }, (text) => {
+            let result = text.substring(0, Math.max(1, text.length - 1)) + "]";
+            console.error(result);
+            return result;
+        });
+    }
+};
+;
+export let useAsynchronousFindAt = (index) => {
+    let target = useToBigInt(index);
+    if (target < 0n) {
+        return AsynchronousCollector.full(() => [], (accumulator, element) => {
+            accumulator.push(element);
+            return accumulator;
+        }, (accumulator) => {
+            if (accumulator.length === 0) {
+                return Promise.reject(new Error("No element found."));
+            }
+            let limited = (((BigInt(accumulator.length)) % target) + target) % target;
+            return Promise.resolve(accumulator[Number(limited)]);
+        });
+    }
+    return AsynchronousCollector.shortable(() => [], (_element, _index, accumulator) => BigInt(accumulator.length) - 1n === target, (accumulator, element) => {
+        accumulator.push(element);
+        return accumulator;
+    }, (accumulator) => {
+        if (accumulator.length === 0) {
+            return Promise.reject(new Error("No element found."));
+        }
+        return Promise.resolve(accumulator[Number(target)]);
+    });
+};
+export let useAsynchronousFindFirst = () => {
+    return AsynchronousCollector.shortable(() => [], (_element, _index, accumulator) => validate(accumulator) && accumulator.length === 1, (accumulator, element) => {
+        if (validate(accumulator) && accumulator.length === 0) {
+            accumulator.push(element);
+            return accumulator;
+        }
+        return accumulator;
+    }, (accumulator) => {
+        if (validate(accumulator) && accumulator.length > 0) {
+            return Promise.resolve(accumulator[0]);
+        }
+        return Promise.reject(new Error("No element found."));
+    });
+};
+export let useAsynchronousFindAny = () => {
+    return AsynchronousCollector.shortable(() => [], (_element, _index, accumulator) => validate(accumulator) && accumulator.length == 1, (accumulator, element) => {
+        if (validate(accumulator) && accumulator.length === 0 && Math.random() < 0.5) {
+            accumulator.push(element);
+            return accumulator;
+        }
+        return accumulator;
+    }, (accumulator) => Promise.resolve(accumulator[0]));
+};
+export let useAsynchronousFindLast = () => {
+    return AsynchronousCollector.full(() => [], (accumulator, element) => {
+        if (validate(accumulator)) {
+            accumulator.push(element);
+        }
+        return accumulator;
+    }, (accumulator) => Promise.resolve(accumulator[accumulator.length - 1]));
+};
+export let useAsynchronousFindMaximum = (comparator = (useCompare)) => {
+    if (isFunction(comparator)) {
+        return AsynchronousCollector.full(() => Promise.reject(new Error("No element found.")), async (accumulator, element) => {
+            if (validate(accumulator)) {
+                return accumulator.then((accumulator) => {
+                    if (comparator(accumulator, element) < 0) {
+                        return element;
+                    }
+                    else {
+                        return accumulator;
+                    }
+                });
+            }
+            return Promise.reject(new Error("No element found."));
+        }, (result) => result);
+    }
+    throw new TypeError("Invalid argument.");
+};
+export let useAsynchronousFindMinimum = (comparator = (useCompare)) => {
+    if (isFunction(comparator)) {
+        return AsynchronousCollector.full(() => Promise.reject(new Error("No element found.")), async (accumulator, element) => {
+            if (validate(accumulator)) {
+                return accumulator.then((accumulator) => {
+                    if (comparator(accumulator, element) > 0) {
+                        return element;
+                    }
+                    else {
+                        return accumulator;
+                    }
+                });
+            }
+            return Promise.reject(new Error("No element found."));
+        }, (result) => result);
+    }
+    throw new TypeError("Invalid argument.");
+};
+;
+export let useAsynchronousForEach = (action) => {
+    if (isFunction(action)) {
+        return AsynchronousCollector.full(() => 0n, (accumulator, element, index) => {
+            action(element, index);
+            return accumulator + 1n;
+        }, (accumulator) => accumulator);
+    }
+    throw new TypeError("Action must be a function.");
+};
+;
+export let useAsynchronousNoneMatch = (predicate) => {
+    if (isFunction(predicate)) {
+        return AsynchronousCollector.shortable(() => true, (_element, _index, accumulator) => !accumulator, (accumulator, element, index) => accumulator && !predicate(element, index), (accumulator) => !accumulator);
+    }
+    throw new TypeError("Predicate must be a function.");
+};
+;
+export let useAsynchronousGroup = (classifier) => {
+    if (isFunction(classifier)) {
+        return AsynchronousCollector.full(() => new Map(), (accumulator, element, index) => {
+            let key = classifier(element, index);
+            let group = accumulator.get(key) || [];
+            group.push(element);
+            accumulator.set(key, group);
+            return accumulator;
+        }, (accumulator) => accumulator);
+    }
+    throw new TypeError("Classifier must be a function.");
+};
+export let useAsynchronousGroupBy = (keyExtractor, valueExtractor = (element) => element) => {
+    if (isFunction(keyExtractor) && isFunction(valueExtractor)) {
+        return AsynchronousCollector.full(() => new Map(), (accumulator, element, index) => {
+            let key = keyExtractor(element, index);
+            let group = accumulator.get(key) || [];
+            group.push(valueExtractor(element, index));
+            accumulator.set(key, group);
+            return accumulator;
+        }, (accumulator) => accumulator);
+    }
+    throw new TypeError("Key extractor and value extractor must be functions.");
+};
+;
+export let useAsynchronousJoin = (argument1, argument2, argument3) => {
+    if (invalidate(argument1) && invalidate(argument2) && invalidate(argument3)) {
+        return AsynchronousCollector.full(() => "[", (text, element) => text + element + ",", (text) => text.substring(0, text.length - 1) + "]");
+    }
+    if (isString(argument1) && invalidate(argument2) && invalidate(argument3)) {
+        let delimiter = argument1;
+        return AsynchronousCollector.full(() => "[", (text, element) => text + element + delimiter, (text) => text.substring(0, text.length - delimiter.length) + "]");
+    }
+    if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
+        let prefix = argument1;
+        let accumulator = argument2;
+        let suffix = argument3;
+        return AsynchronousCollector.full(() => prefix, accumulator, (text) => text + suffix);
+    }
+    if (isString(argument1) && isString(argument2) && isString(argument3)) {
+        let prefix = argument1;
+        let delimiter = argument2;
+        let suffix = argument3;
+        return AsynchronousCollector.full(() => prefix, (text, element) => text + element + delimiter, (text) => text + suffix);
+    }
+    throw new TypeError("Invalid arguments.");
+};
+;
+export let useAsynchronousLog = (argument1, argument2, argument3) => {
+    if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
+        let prefix = argument1;
+        let accumulator = argument2;
+        let suffix = argument3;
+        return AsynchronousCollector.full(() => prefix, accumulator, (text) => {
+            let result = text + suffix;
+            console.log(result);
+            return result;
+        });
+    }
+    else if (isFunction(argument1)) {
+        let prefix = "[";
+        let accumulator = argument2;
+        let suffix = "]";
+        return AsynchronousCollector.full(() => prefix, accumulator, (text) => {
+            let result = text + suffix;
+            console.log(result);
+            return result;
+        });
+    }
+    else {
+        return AsynchronousCollector.full(() => "[", (accumulator, element) => {
+            console.log(element);
+            if (isString(accumulator) && isString(element)) {
+                return accumulator + element + ",";
+            }
+            return String(accumulator) + String(element) + ",";
+        }, (text) => {
+            let result = text.substring(0, Math.max(1, text.length - 1)) + "]";
+            console.log(result);
+            return result;
+        });
+    }
+};
+export let useAsynchronousPartition = (count) => {
+    if (isBigInt(count)) {
+        let limited = count > 1n ? count : 1n;
+        return AsynchronousCollector.full(() => {
+            return [];
+        }, (array, element) => {
+            let index = limited % BigInt(array.length);
+            if (index === 0n) {
+                array.push([]);
+            }
+            array[Number(index)].push(element);
+            return array;
+        }, (result) => {
+            return result;
+        });
+    }
+    throw new TypeError("Count must be a BigInt.");
+};
+;
+export let useAsynchronousPartitionBy = (classifier) => {
+    if (isFunction(classifier)) {
+        return AsynchronousCollector.full(() => {
+            return [];
+        }, (array, element, index) => {
+            let resolved = classifier(element, index);
+            while (resolved > BigInt(array.length) - 1n) {
+                array.push([]);
+            }
+            array[Number(index)].push(element);
+            return array;
+        }, (result) => {
+            return result;
+        });
+    }
+    throw new TypeError("Classifier must be a function.");
+};
+;
+export let useAsynchronousReduce = (argument1, argument2, argument3) => {
+    if (isFunction(argument1) && invalidate(argument2) && invalidate(argument3)) {
+        let accumulator = argument1;
+        return AsynchronousCollector.full(() => Promise.reject(), async (result, element, index) => {
+            if (validate(result)) {
+                return result.then((result) => {
+                    return accumulator(result, element, index);
+                });
+            }
+            return Promise.reject();
+        }, (result) => result);
+    }
+    else if (validate(argument1) && isFunction(argument2) && invalidate(argument3)) {
+        let identity = argument1;
+        let accumulator = argument2;
+        return AsynchronousCollector.full(() => identity, accumulator, (result) => result);
+    }
+    else if (validate(argument1) && isFunction(argument2) && isFunction(argument3)) {
+        let identity = argument1;
+        let accumulator = argument2;
+        let finisher = argument3;
+        return AsynchronousCollector.full(() => identity, accumulator, finisher);
+    }
+    else {
+        throw new TypeError("Invalid arguments.");
+    }
+};
+export let useAsynchronousToArray = () => {
+    return AsynchronousCollector.full(() => [], (array, element) => {
+        array.push(element);
+        return array;
+    }, (array) => array);
+};
+;
+export let useAsynchronousToMap = (keyExtractor, valueExtractor = (element) => element) => {
+    if (isFunction(keyExtractor) && isFunction(valueExtractor)) {
+        return AsynchronousCollector.full(() => new Map(), (map, element, index) => {
+            let key = keyExtractor(element, index);
+            let value = valueExtractor(element, index);
+            map.set(key, value);
+            return map;
+        }, (map) => map);
+    }
+    throw new TypeError("Key extractor and value extractor must be functions.");
+};
+export let useAsynchronousToSet = () => {
+    return AsynchronousCollector.full(() => new Set(), (set, element) => {
+        set.add(element);
+        return set;
+    }, (set) => set);
+};
+;
+export let useAsynchronousWrite = (argument1, argument2) => {
+    if (isObject(argument1)) {
+        if (isFunction(argument2)) {
+            let stream = argument1;
+            let accumulator = argument2;
+            return AsynchronousCollector.full(() => Promise.resolve(stream), (promise, element, index) => {
+                return new Promise((resolve, reject) => {
+                    promise.then((stream) => {
+                        try {
+                            resolve(accumulator(stream, element, index));
+                        }
+                        catch (error) {
+                            reject(error);
+                        }
+                    }).catch(reject);
+                });
+            }, (promise) => promise);
+        }
+        else {
+            let stream = argument1;
+            return AsynchronousCollector.full(() => Promise.resolve(stream), (promise, element) => {
+                return new Promise((resolve, reject) => {
+                    promise.then((stream) => {
+                        try {
+                            let writer = stream.getWriter();
+                            writer.write(String(element));
+                            resolve(stream);
+                        }
+                        catch (error) {
+                            reject(error);
+                        }
+                    }).catch(reject);
+                });
+            }, (promise) => promise);
+        }
+    }
+    throw new TypeError("Invalid arguments.");
+};
+;
+export let useAsynchronousNumericSummate = (mapper = useToNumber) => {
+    return AsynchronousCollector.full(() => 0, (accumulator, element) => {
+        let resolved = isNumber(element) ? element : mapper(element);
+        return accumulator + (isNumber(resolved) ? resolved : 0);
+    }, (result) => result);
+};
+;
+export let useAsynchronousBigIntSummate = (mapper = useToBigInt) => {
+    return AsynchronousCollector.full(() => 0n, (accumulator, element) => {
+        let resolved = isBigInt(element) ? element : mapper(element);
+        return accumulator + (isBigInt(resolved) ? resolved : 0n);
+    }, (result) => result);
+};
+;
+;
+export let useAsynchronousNumericAverage = (mapper = useToNumber) => {
+    return AsynchronousCollector.full(() => {
+        return {
+            summate: 0,
+            count: 0
+        };
+    }, (accumulator, element) => {
+        let resolved = isNumber(element) ? element : mapper(element);
+        return {
+            summate: accumulator.summate + (isNumber(resolved) ? resolved : 0),
+            count: accumulator.count + 1
+        };
+    }, (result) => {
+        if (result.count === 0) {
+            return 0;
+        }
+        return result.summate / result.count;
+    });
+};
+;
+;
+export let useAsynchronousBigIntAverage = (mapper = useToBigInt) => {
+    return AsynchronousCollector.full(() => {
+        return {
+            summate: 0n,
+            count: 0n
+        };
+    }, (accumulator, element) => {
+        let resolved = isBigInt(element) ? element : mapper(element);
+        return {
+            summate: accumulator.summate + (isBigInt(resolved) ? resolved : 0n),
+            count: accumulator.count + 1n
+        };
+    }, (result) => {
+        if (result.count === 0n) {
+            return 0n;
+        }
+        return result.summate / result.count;
+    });
+};
+export let useAsynchronousFrequency = () => {
+    return AsynchronousCollector.full(() => new Map(), (map, element) => {
+        let count = map.get(element) || 0n;
+        map.set(element, count + 1n);
+        return map;
+    }, (map) => map);
+};
+;
+export let useAsynchronousNumericMode = (mapper = useToNumber) => {
+    return AsynchronousCollector.full(() => new Map(), (map, element) => {
+        let resolved = isNumber(element) ? element : mapper(element);
+        let count = map.get(resolved) || 0n;
+        map.set(resolved, count + 1n);
+        return map;
+    }, (map) => {
+        let maxCount = 0n;
+        let mode = 0;
+        for (let [key, value] of map) {
+            if (value > maxCount) {
+                maxCount = value;
+                mode = key;
+            }
+        }
+        return mode;
+    });
+};
+;
+export let useAsynchronousBigIntMode = (mapper = useToBigInt) => {
+    return AsynchronousCollector.full(() => new Map(), (map, element) => {
+        let resolved = isBigInt(element) ? element : mapper(element);
+        let count = map.get(resolved) || 0n;
+        map.set(resolved, count + 1n);
+        return map;
+    }, (map) => {
+        let maxCount = 0n;
+        let mode = 0n;
+        for (let [key, value] of map) {
+            if (value > maxCount) {
+                maxCount = value;
+                mode = key;
+            }
+        }
+        return mode;
+    });
+};
+;
+;
+export let useAsynchronousNumericVariance = (mapper = useToNumber) => {
+    return AsynchronousCollector.full(() => {
+        return {
+            summate: 0,
+            summateOfSquares: 0,
+            count: 0
+        };
+    }, (accumulator, element) => {
+        let resolved = isNumber(element) ? element : mapper(element);
+        return {
+            summate: accumulator.summate + (isNumber(resolved) ? resolved : 0),
+            summateOfSquares: accumulator.summateOfSquares + (isNumber(resolved) ? Math.pow(resolved, 2) : 0),
+            count: accumulator.count + 1
+        };
+    }, (result) => {
+        if (result.count < 2) {
+            return 0;
+        }
+        let mean = result.summate / result.count;
+        let variance = (result.summateOfSquares / result.count) - Math.pow(mean, 2);
+        return variance;
+    });
+};
+;
+;
+export let useAsynchronousBigIntVariance = (mapper = useToBigInt) => {
+    return AsynchronousCollector.full(() => {
+        return {
+            summate: 0n,
+            summateOfSquares: 0n,
+            count: 0n
+        };
+    }, (accumulator, element) => {
+        let resolved = isBigInt(element) ? element : mapper(element);
+        return {
+            summate: accumulator.summate + (isBigInt(resolved) ? resolved : 0n),
+            summateOfSquares: accumulator.summateOfSquares + (isBigInt(resolved) ? resolved * resolved : 0n),
+            count: accumulator.count + 1n
+        };
+    }, (result) => {
+        if (result.count < 2n) {
+            return 0n;
+        }
+        let mean = result.summate / result.count;
+        let variance = (result.summateOfSquares / result.count) - (mean * mean);
+        return variance;
+    });
+};
+;
+;
+export let useAsynchronousNumericStandardDeviation = (mapper = useToNumber) => {
+    return AsynchronousCollector.full(() => {
+        return {
+            summate: 0,
+            summateOfSquares: 0,
+            count: 0
+        };
+    }, (accumulator, element) => {
+        let resolved = isNumber(element) ? element : mapper(element);
+        return {
+            summate: accumulator.summate + (isNumber(resolved) ? resolved : 0),
+            summateOfSquares: accumulator.summateOfSquares + (isNumber(resolved) ? Math.pow(resolved, 2) : 0),
+            count: accumulator.count + 1
+        };
+    }, (result) => {
+        if (result.count < 2) {
+            return 0;
+        }
+        let mean = result.summate / result.count;
+        let variance = (result.summateOfSquares / result.count) - Math.pow(mean, 2);
+        let standardDeviation = Math.sqrt(variance);
+        return standardDeviation;
+    });
+};
+;
+;
+export let useAsynchronousBigIntStandardDeviation = (mapper = useToBigInt) => {
+    return AsynchronousCollector.full(() => {
+        return {
+            summate: 0n,
+            summateOfSquares: 0n,
+            count: 0n
+        };
+    }, (accumulator, element) => {
+        let resolved = isBigInt(element) ? element : mapper(element);
+        return {
+            summate: accumulator.summate + (isBigInt(resolved) ? resolved : 0n),
+            summateOfSquares: accumulator.summateOfSquares + (isBigInt(resolved) ? resolved * resolved : 0n),
+            count: accumulator.count + 1n
+        };
+    }, (result) => {
+        if (result.count < 2n) {
+            return 0n;
+        }
+        let mean = result.summate / result.count;
+        let variance = (result.summateOfSquares / result.count) - (mean * mean);
+        let standardDeviation = BigInt(Math.sqrt(Number(variance)));
+        return standardDeviation;
+    });
+};
+;
+export let useAsynchronousNumericMedian = (mapper = useToNumber) => {
+    return AsynchronousCollector.full(() => [], (array, element) => {
+        let resolved = isNumber(element) ? element : mapper(element);
+        array.push(resolved);
+        array.sort((a, b) => a - b);
+        return array;
+    }, (array) => {
+        let length = array.length;
+        if (length % 2 === 0) {
+            let mid = length / 2;
+            return (array[mid - 1] + array[mid]) / 2;
+        }
+        else {
+            let mid = Math.floor(length / 2);
+            return array[mid];
+        }
+    });
+};
+;
+export let useAsynchronousBigIntMedian = (mapper = useToBigInt) => {
+    return AsynchronousCollector.full(() => [], (array, element) => {
+        let resolved = isBigInt(element) ? element : mapper(element);
+        array.push(resolved);
+        array.sort((a, b) => Number(a - b));
+        return array;
+    }, (array) => {
+        let length = array.length;
+        if (length % 2 === 0) {
+            let mid = length / 2;
+            return (array[Number(mid - 1)] + array[mid]) / 2n;
+        }
+        else {
+            let mid = Math.floor(length / 2);
+            return array[mid];
+        }
+    });
+};
+export let useAsynchronousToGeneratorFunction = () => {
+    return AsynchronousCollector.full(() => [], (array, element) => {
+        array.push(element);
+        return array;
+    }, (array) => {
+        return (function* () {
+            for (let element of array) {
+                yield element;
+            }
+        })();
+    });
+};
+export let useAsynchronousToAsyncGeneratorFunction = () => {
+    return AsynchronousCollector.full(() => [], (array, element) => {
+        array.push(element);
+        return array;
+    }, (array) => {
+        return (async function* () {
+            for (let element of array) {
+                yield element;
+            }
+        })();
+    });
+};