semantic-typescript 0.5.3 → 0.7.0

package/dist/{semantic.js → synchronous/semantic.js}

@@ -1,50 +1,60 @@
-import { useAnyMatch, useAllMatch, Collector, useCollect, useCount, useError, useFindAny, useFindAt, useFindFirst, useFindLast, useFindMaximum, useFindMinimum, useForEach, useGroup, useGroupBy, useJoin, useLog, useNoneMatch, usePartition, usePartitionBy, useReduce, useToArray, useToMap, useToSet, useWrite, useFrequency, useNumericAverage, useNumericVariance, useNumericStandardDeviation, useNumericMedian, useNumericMode, useNumericSummate, useBigIntAverage, useBigIntVariance, useBigIntMedian, useBigIntMode, useBigIntSummate } from "./collector";
-import { isBigInt, isCollectable, isCollector, isFunction, isIterable, isNumber, isObject, isSemantic, isString } from "./guard";
-import { useHash } from "./hash";
-import { useCompare, useToBigInt, useToNumber } from "./hook";
-import { AsyncCollectableSymbol, BigIntStatisticsSymbol, CollectableSymbol, NumericStatisticsSymbol, OrderedCollectableSymbol, SemanticSymbol, StatisticsSymbol, UnorderedCollectableSymbol, WindowCollectableSymbol } from "./symbol";
-import { invalidate, validate } from "./utility";
-export class Semantic {
+import { useSynchronousAnyMatch, useSynchronousAllMatch, useSynchronousCollect, useSynchronousCount, useSynchronousError, useSynchronousFindAny, useSynchronousFindAt, useSynchronousFindFirst, useSynchronousFindLast, useSynchronousFindMaximum, useSynchronousFindMinimum, useSynchronousForEach, useSynchronousGroup, useSynchronousGroupBy, useSynchronousJoin, useSynchronousLog, useSynchronousNoneMatch, useSynchronousPartition, useSynchronousPartitionBy, useSynchronousReduce, useSynchronousToArray, useSynchronousToMap, useSynchronousToSet, useSynchronousWrite, useSynchronousFrequency, useSynchronousBigIntAverage, useSynchronousBigIntMedian, useSynchronousBigIntMode, useSynchronousBigIntSummate, useSynchronousBigIntVariance, useSynchronousNumericAverage, useSynchronousNumericMedian, useSynchronousNumericMode, useSynchronousNumericStandardDeviation, useSynchronousNumericSummate, useSynchronousNumericVariance } from "./collector";
+import { isFunction, isSynchronousSemantic, isIterable, isNumber, isBigInt, isObject, isString, isSynchronousCollectable, isSynchronousCollector } from "../guard";
+import { useHash } from "../hash";
+import { useCompare, useToBigInt, useToNumber } from "../hook";
+import { SynchronousOrderedCollectableSymbol, SynchronousBigIntStatisticsSymbol, SynchronousCollectableSymbol, SynchronousNumericStatisticsSymbol, SynchronousSemanticSymbol, SynchronousWindowCollectableSymbol, SynchronousUnorderedCollectableSymbol, SynchronousStatisticsSymbol } from "../symbol";
+import { invalidate, validate } from "../utility";
+import { SynchronousCollector } from "./collector";
+export class SynchronousSemantic {
     generator;
-    Semantic = SemanticSymbol;
+    SynchronousSemantic = SynchronousSemanticSymbol;
+    [Symbol.toStringTag] = "SynchronousSemantic";
     constructor(generator) {
-        this.generator = generator;
-        Object.defineProperties(this, {
-            "Semantic": {
-                value: SemanticSymbol,
-                writable: false,
-                enumerable: false,
-                configurable: false
-            },
-            "generator": {
-                value: generator,
-                writable: false,
-                enumerable: false,
-                configurable: false
-            }
-        });
+        if (isFunction(generator)) {
+            this.generator = generator;
+            Object.defineProperties(this, {
+                "SynchronousSemantic": {
+                    value: SynchronousSemanticSymbol,
+                    writable: false,
+                    enumerable: false,
+                    configurable: false
+                },
+                "generator": {
+                    value: generator,
+                    writable: false,
+                    enumerable: false,
+                    configurable: false
+                }
+            });
+        }
+        else {
+            throw new TypeError("Invalid arguments.");
+        }
     }
-    concat(other) {
-        if (isSemantic(other)) {
-            return new Semantic((accept, interrupt) => {
+    concat(argument) {
+        if (isSynchronousSemantic(argument)) {
+            return new SynchronousSemantic((accept, interrupt) => {
                 try {
+                    let other = argument;
+                    let generator = other.source();
                     let count = 0n;
-                    this.generator((element, index) => {
-                        accept(element, index);
+                    this.generator((element) => {
+                        accept(element, count);
                         count++;
                     }, interrupt);
-                    let otherGenerator = Reflect.has(other, "generator") ? Reflect.get(other, "generator") : () => { };
-                    otherGenerator((element, index) => {
-                        accept(element, index + count);
+                    generator((element) => {
+                        accept(element, count);
+                        count++;
                     }, interrupt);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on concatenation.");
+                    throw error;
                 }
             });
         }
-        if (isIterable(other)) {
-            return new Semantic((accept, interrupt) => {
+        if (isIterable(argument)) {
+            let other = argument;
+            return new SynchronousSemantic((accept, interrupt) => {
                 try {
                     let count = 0n;
                     this.generator((element, index) => {
@@ -57,7 +67,7 @@ export class Semantic {
                     }
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on concatenation.");
+                    throw error;
                 }
             });
         }
@@ -65,7 +75,7 @@ export class Semantic {
     }
     distinct(argument1) {
         let keyExtractor = validate(argument1) ? argument1 : (element) => element;
-        return new Semantic((accept, interrupt) => {
+        return new SynchronousSemantic((accept, interrupt) => {
             try {
                 let set = new Set();
                 this.generator((element, index) => {
@@ -77,28 +87,29 @@ export class Semantic {
                 }, interrupt);
             }
             catch (error) {
-                throw new Error("Uncaught error on distinct.");
+                throw error;
             }
         });
     }
     dropWhile(predicate) {
         if (isFunction(predicate)) {
-            return new Semantic((accept, interrupt) => {
+            return new SynchronousSemantic((accept, interrupt) => {
                 try {
-                    let dropping = true;
+                    let count = -1n;
                     this.generator((element, index) => {
-                        if (dropping) {
+                        if (count === -1n) {
                             if (!predicate(element, index)) {
-                                dropping = false;
-                                accept(element, index);
+                                count++;
                             }
-                            return;
                         }
-                        accept(element, index);
+                        else {
+                            accept(element, count);
+                            count++;
+                        }
                     }, interrupt);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on dropWhile.");
+                    throw error;
                 }
             });
         }
@@ -106,7 +117,7 @@ export class Semantic {
     }
     filter(predicate) {
         if (isFunction(predicate)) {
-            return new Semantic((accept, interrupt) => {
+            return new SynchronousSemantic((accept, interrupt) => {
                 try {
                     this.generator((element, index) => {
                         if (predicate(element, index)) {
@@ -115,7 +126,7 @@ export class Semantic {
                     }, interrupt);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on filter.");
+                    throw error;
                 }
             });
         }
@@ -123,7 +134,7 @@ export class Semantic {
     }
     flat(mapper) {
         if (isFunction(mapper)) {
-            return new Semantic((accept, interrupt) => {
+            return new SynchronousSemantic((accept, interrupt) => {
                 try {
                     let count = 0n;
                     let stop = false;
@@ -136,7 +147,7 @@ export class Semantic {
                                 count++;
                             }
                         }
-                        else if (isSemantic(result)) {
+                        else if (isSynchronousSemantic(result)) {
                             result.generator((subElement) => {
                                 accept(subElement, count);
                                 stop = stop || interrupt(subElement, count);
@@ -146,7 +157,7 @@ export class Semantic {
                     }, (element) => interrupt(element, count) || stop);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on flat.");
+                    throw error;
                 }
             });
         }
@@ -154,21 +165,21 @@ export class Semantic {
     }
     flatMap(mapper) {
         if (isFunction(mapper)) {
-            return new Semantic((accept, interrupt) => {
+            return new SynchronousSemantic((accept, interrupt) => {
                 try {
                     let count = 0n;
                     let stop = false;
                     this.generator((element, index) => {
-                        let result = mapper(element, index);
-                        if (isIterable(result)) {
-                            for (let subElement of result) {
+                        let transform = mapper(element, index);
+                        if (isIterable(transform)) {
+                            for (let subElement of transform) {
                                 accept(subElement, count);
                                 stop = stop || interrupt(subElement, count);
                                 count++;
                             }
                         }
-                        else if (isSemantic(result)) {
-                            result.generator((subElement) => {
+                        else if (isSynchronousSemantic(transform)) {
+                            transform.source()((subElement) => {
                                 accept(subElement, count);
                                 stop = stop || interrupt(subElement, count);
                                 count++;
@@ -177,44 +188,44 @@ export class Semantic {
                     }, () => stop);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on flatMap.");
+                    throw error;
                 }
             });
         }
         throw new TypeError("Invalid arguments.");
     }
-    limit(n) {
-        if (isNumber(n)) {
-            let limit = BigInt(n);
-            return new Semantic((accept, interrupt) => {
+    limit(argument) {
+        if (isNumber(argument)) {
+            let limit = BigInt(argument);
+            return new SynchronousSemantic((accept, interrupt) => {
                 try {
                     let count = 0n;
-                    this.generator((element, index) => {
+                    this.generator((element) => {
                         if (count < limit) {
-                            accept(element, index);
+                            accept(element, count);
                             count++;
                         }
-                    }, (element) => interrupt(element, count) || count >= limit);
+                    }, (element, index) => interrupt(element, index) || count >= limit);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on limit.");
+                    throw error;
                 }
             });
         }
-        if (isBigInt(n)) {
-            let limit = n;
-            return new Semantic((accept, interrupt) => {
+        if (isBigInt(argument)) {
+            let limit = argument;
+            return new SynchronousSemantic((accept, interrupt) => {
                 try {
                     let count = 0n;
-                    this.generator((element, index) => {
+                    this.generator((element) => {
                         if (count < limit) {
-                            accept(element, index);
+                            accept(element, count);
                             count++;
                         }
-                    }, (element) => interrupt(element, count) || count >= limit);
+                    }, (element, index) => interrupt(element, index) || count >= limit);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on limit.");
+                    throw error;
                 }
             });
         }
@@ -222,7 +233,7 @@ export class Semantic {
     }
     map(mapper) {
         if (isFunction(mapper)) {
-            return new Semantic((accept, interrupt) => {
+            return new SynchronousSemantic((accept, interrupt) => {
                 try {
                     let stop = false;
                     this.generator((element, index) => {
@@ -232,7 +243,7 @@ export class Semantic {
                     }, () => stop);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on map.");
+                    throw error;
                 }
             });
         }
@@ -240,7 +251,7 @@ export class Semantic {
     }
     peek(consumer) {
         if (isFunction(consumer)) {
-            return new Semantic((accept, interrupt) => {
+            return new SynchronousSemantic((accept, interrupt) => {
                 try {
                     this.generator((element, index) => {
                         accept(element, index);
@@ -248,7 +259,7 @@ export class Semantic {
                     }, interrupt);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on peek.");
+                    throw error;
                 }
             });
         }
@@ -256,58 +267,59 @@ export class Semantic {
     }
     redirect(redirector) {
         if (isFunction(redirector)) {
-            return new Semantic((accept, interrupt) => {
+            return new SynchronousSemantic((accept, interrupt) => {
                 try {
                     this.generator((element, index) => {
                         accept(element, redirector(element, index));
                     }, interrupt);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on redirect.");
+                    throw error;
                 }
             });
         }
         throw new TypeError("Invalid arguments.");
     }
     reverse() {
-        return new Semantic((accept, interrupt) => {
+        return new SynchronousSemantic((accept, interrupt) => {
             try {
                 this.generator((element, index) => {
                     accept(element, -index);
                 }, interrupt);
             }
             catch (error) {
-                throw new Error("Uncaught error on reverse.");
+                throw error;
             }
         });
     }
     shuffle(mapper) {
         if (isFunction(mapper)) {
-            try {
-                return new Semantic((accept, interrupt) => {
+            return new SynchronousSemantic((accept, interrupt) => {
+                try {
                     this.generator((element, index) => {
                         accept(element, mapper(element, index));
                     }, interrupt);
-                });
-            }
-            catch (error) {
-                throw new Error("Uncaught error on shuffle.");
-            }
+                }
+                catch (error) {
+                    throw error;
+                }
+            });
         }
-        return new Semantic((accept, interrupt) => {
+        return new SynchronousSemantic((accept, interrupt) => {
             try {
                 this.generator((element, index) => {
                     accept(element, useHash(element, index));
                 }, interrupt);
             }
             catch (error) {
-                throw new Error("Uncaught error on shuffle.");
+                throw error;
             }
         });
     }
-    skip(n) {
-        if (isNumber(n)) {
-            return new Semantic((accept, interrupt) => {
+    skip(argument) {
+        if (isNumber(argument)) {
+            let n = argument;
+            return new SynchronousSemantic((accept, interrupt) => {
                 try {
                     let count = 0n;
                     let limit = BigInt(n);
@@ -321,12 +333,13 @@ export class Semantic {
                     }, interrupt);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on skip.");
+                    throw error;
                 }
             });
         }
-        if (isBigInt(n)) {
-            return new Semantic((accept, interrupt) => {
+        if (isBigInt(argument)) {
+            let n = argument;
+            return new SynchronousSemantic((accept, interrupt) => {
                 try {
                     let count = 0n;
                     this.generator((element, index) => {
@@ -339,166 +352,152 @@ export class Semantic {
                     }, interrupt);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on skip.");
+                    throw error;
                 }
             });
         }
         throw new TypeError("Invalid arguments.");
     }
-    sorted(comparator) {
-        if (isFunction(comparator)) {
-            try {
-                return new OrderedCollectable(this.generator, comparator);
-            }
-            catch (error) {
-                throw new Error("Uncaught error on sorted.");
-            }
-        }
-        try {
-            return new OrderedCollectable(this.generator, (a, b) => useCompare(a, b));
-        }
-        catch (error) {
-            throw new Error("Uncaught error on sorted.");
-        }
+    source() {
+        return this.generator;
     }
     sub(start, end) {
-        return new Semantic((accept, interrupt) => {
-            try {
-                let count = 0n;
-                this.generator((element, index) => {
-                    if (count < end) {
-                        count++;
-                        if (count >= start) {
+        if ((isNumber(start) && isNumber(end)) || (isBigInt(start) && isBigInt(end))) {
+            return new SynchronousSemantic((accept, interrupt) => {
+                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++;
                         }
-                    }
-                }, interrupt);
-            }
-            catch (error) {
-                throw new Error("Uncaught error on sub.");
-            }
-        });
+                    }, (element, index) => count >= maximum || interrupt(element, index));
+                }
+                catch (error) {
+                    throw error;
+                }
+            });
+        }
+        throw new TypeError("Invalid arguments.");
     }
     takeWhile(predicate) {
-        return new Semantic((accept, interrupt) => {
+        return new SynchronousSemantic((accept, interrupt) => {
             try {
+                let stop = false;
                 this.generator((element, index) => {
-                    if (!predicate(element, index)) {
-                        interrupt(element, index);
-                        return;
+                    if (predicate(element, index) && stop === false) {
+                        accept(element, index);
                     }
-                    accept(element, index);
-                }, interrupt);
+                    else {
+                        stop = true;
+                    }
+                }, (element, index) => stop || interrupt(element, index));
             }
             catch (error) {
-                throw new Error("Uncaught error on takeWhile.");
+                throw error;
             }
         });
     }
     toCollectable(mapper) {
         if (isFunction(mapper)) {
             try {
-                let collectable = mapper(this.generator);
-                if (isCollectable(collectable)) {
-                    return collectable;
+                let SynchronousCollectable = mapper(this.generator);
+                if (isSynchronousCollectable(SynchronousCollectable)) {
+                    return SynchronousCollectable;
                 }
             }
             catch (error) {
-                throw new Error("Uncaught error on toCollectable.");
+                throw error;
             }
         }
         try {
-            return new UnorderedCollectable(this.generator);
+            return new SynchronousUnorderedCollectable(this.generator);
         }
         catch (error) {
-            throw new Error("Uncaught error on toCollectable.");
+            throw error;
         }
     }
     toBigintStatistics() {
         try {
-            return new BigIntStatistics(this.generator);
-        }
-        catch (error) {
-            throw new Error("Uncaught error on toBigintStatistics.");
-        }
-    }
-    toEvent() {
-        try {
-            return new EventCollectable(this.generator);
+            return new SynchronousBigIntStatistics(this.generator);
         }
         catch (error) {
-            throw new Error("Uncaught error on toEvent.");
+            throw error;
         }
     }
     toNumericStatistics() {
         try {
-            return new NumericStatistics(this.generator);
+            return new SynchronousNumericStatistics(this.generator);
         }
         catch (error) {
-            throw new Error("Uncaught error on toNumericStatistics.");
+            throw error;
         }
     }
     toOrdered() {
         try {
-            return new OrderedCollectable(this.generator);
+            return new SynchronousOrderedCollectable(this.generator);
         }
         catch (error) {
-            throw new Error("Uncaught error on toOrdered.");
+            throw error;
         }
     }
     toUnordered() {
         try {
-            return new UnorderedCollectable(this.generator);
+            return new SynchronousUnorderedCollectable(this.generator);
         }
         catch (error) {
-            throw new Error(String(error));
+            throw error;
         }
     }
     toWindow() {
         try {
-            return new WindowCollectable(this.generator);
+            return new SynchronousWindowCollectable(this.generator);
         }
         catch (error) {
-            throw new Error("Uncaught error on toWindow.");
+            throw error;
         }
     }
     translate(argument1) {
         if (isNumber(argument1)) {
             let offset = argument1;
-            return new Semantic((accept, interrupt) => {
+            return new SynchronousSemantic((accept, interrupt) => {
                 try {
                     this.generator((element, index) => {
                         accept(element, index + BigInt(offset));
                     }, interrupt);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on translate.");
+                    throw error;
                 }
             });
         }
         else if (isBigInt(argument1)) {
             let offset = argument1;
-            return new Semantic((accept, interrupt) => {
+            return new SynchronousSemantic((accept, interrupt) => {
                 try {
                     this.generator((element, index) => {
                         accept(element, index + offset);
                     }, interrupt);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on translate.");
+                    throw error;
                 }
             });
         }
         else if (isFunction(argument1)) {
             let translator = argument1;
-            return new Semantic((accept, interrupt) => {
+            return new SynchronousSemantic((accept, interrupt) => {
                 try {
                     this.generator((element, index) => {
                         accept(element, index + translator(element, index));
                     }, interrupt);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on translate.");
+                    throw error;
                 }
             });
         }
@@ -506,74 +505,80 @@ export class Semantic {
     }
 }
 ;
-export class Collectable {
-    Collectable = CollectableSymbol;
+export class SynchronousCollectable {
+    SynchronousCollectable = SynchronousCollectableSymbol;
+    [Symbol.toStringTag] = "SynchronousCollectable";
     constructor() {
-        Object.defineProperty(this, "Collectable", {
-            value: CollectableSymbol,
+        Object.defineProperty(this, "SynchronousCollectable", {
+            value: SynchronousCollectableSymbol,
             enumerable: false,
             writable: false,
             configurable: false
         });
     }
+    *[Symbol.iterator]() {
+        for (let element of this.toArray()) {
+            yield element;
+        }
+    }
     anyMatch(predicate) {
         if (isFunction(predicate)) {
             try {
-                return useAnyMatch(predicate).collect(this);
+                return useSynchronousAnyMatch(predicate).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on anyMatch.");
+                throw error;
             }
         }
         throw new TypeError("Predicate must be a function.");
     }
     allMatch(predicate) {
-        return useAllMatch(predicate).collect(this);
+        return useSynchronousAllMatch(predicate).collect(this.source());
     }
     collect(argument1, argument2, argument3, argument4) {
         try {
-            if (isCollector(argument1)) {
+            if (isSynchronousCollector(argument1)) {
                 let collector = argument1;
-                return collector.collect(this);
+                return collector.collect(this.source());
             }
             if (isFunction(argument1) && isFunction(argument2) && isFunction(argument3)) {
                 let identity = argument1;
                 let accumulator = argument2;
                 let finisher = argument3;
-                return useCollect(identity, accumulator, finisher).collect(this);
+                return useSynchronousCollect(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 useCollect(identity, interrupt, accumulator, finisher).collect(this);
+                return useSynchronousCollect(identity, interrupt, accumulator, finisher).collect(this.source());
             }
         }
         catch (error) {
-            throw new Error("Uncaught error on collect.");
+            throw error;
         }
         throw new TypeError("Invalid arguments.");
     }
     count() {
-        return useCount().collect(this.source());
+        return useSynchronousCount().collect(this.source());
     }
     error(argument1, argument2, argument3) {
         if (invalidate(argument1) && invalidate(argument2) && invalidate(argument3)) {
             try {
-                useError().collect(this.source());
+                useSynchronousError().collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on error.");
+                throw error;
             }
         }
         else if (isFunction(argument1) && invalidate(argument2) && invalidate(argument3)) {
             try {
                 let accumulator = argument1;
-                useError(accumulator).collect(this.source());
+                useSynchronousError(accumulator).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on error.");
+                throw error;
             }
         }
         else if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
@@ -581,10 +586,10 @@ export class Collectable {
                 let prefix = argument1;
                 let accumulator = argument2;
                 let suffix = argument3;
-                useError(prefix, accumulator, suffix).collect(this.source());
+                useSynchronousError(prefix, accumulator, suffix).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on error.");
+                throw error;
             }
         }
         else {
@@ -596,72 +601,72 @@ export class Collectable {
     }
     findAny() {
         try {
-            return useFindAny().collect(this.source());
+            return useSynchronousFindAny().collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on findAny.");
+            throw error;
         }
     }
     findAt(index) {
         if (isBigInt(index)) {
             try {
-                return useFindAt(index).collect(this.source());
+                return useSynchronousFindAt(index).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on findAt.");
+                throw error;
             }
         }
         else if (isNumber(index)) {
             try {
-                return useFindAt(index).collect(this.source());
+                return useSynchronousFindAt(index).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on findAt.");
+                throw error;
             }
         }
         throw new TypeError("Index must be a bigint.");
     }
     findFirst() {
         try {
-            return useFindFirst().collect(this.source());
+            return useSynchronousFindFirst().collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on findFirst.");
+            throw error;
         }
     }
     findLast() {
         try {
-            return useFindLast().collect(this.source());
+            return useSynchronousFindLast().collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on findLast.");
+            throw error;
         }
     }
     findMaximum(argument1) {
         try {
             let comparator = isFunction(argument1) ? argument1 : useCompare;
-            return useFindMaximum(comparator).collect(this.source());
+            return useSynchronousFindMaximum(comparator).collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on findMaximum.");
+            throw error;
         }
     }
     findMinimum(argument1) {
         try {
             let comparator = isFunction(argument1) ? argument1 : useCompare;
-            return useFindMinimum(comparator).collect(this.source());
+            return useSynchronousFindMinimum(comparator).collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on findMinimum.");
+            throw error;
         }
     }
     forEach(action) {
         if (isFunction(action)) {
             try {
-                useForEach(action).collect(this);
+                useSynchronousForEach(action).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on forEach.");
+                throw error;
             }
         }
         else {
@@ -671,10 +676,10 @@ export class Collectable {
     group(classifier) {
         if (isFunction(classifier)) {
             try {
-                return useGroup(classifier).collect(this.source());
+                return useSynchronousGroup(classifier).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on group.");
+                throw error;
             }
         }
         throw new TypeError("Classifier must be a function.");
@@ -682,10 +687,10 @@ export class Collectable {
     groupBy(keyExtractor, valueExtractor) {
         if (isFunction(keyExtractor) && isFunction(valueExtractor)) {
             try {
-                return useGroupBy(keyExtractor, valueExtractor).collect(this.source());
+                return useSynchronousGroupBy(keyExtractor, valueExtractor).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on groupBy.");
+                throw error;
             }
         }
         throw new TypeError("Key and value extractors must be functions.");
@@ -693,19 +698,19 @@ export class Collectable {
     join(argument1, argument2, argument3) {
         if (invalidate(argument1) && invalidate(argument2) && invalidate(argument3)) {
             try {
-                return useJoin().collect(this.source());
+                return useSynchronousJoin().collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on join.");
+                throw error;
             }
         }
         else if (isString(argument1) && invalidate(argument2) && invalidate(argument3)) {
             try {
                 let delimiter = argument1;
-                return useJoin(delimiter).collect(this.source());
+                return useSynchronousJoin(delimiter).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on join.");
+                throw error;
             }
         }
         else if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
@@ -713,10 +718,10 @@ export class Collectable {
                 let prefix = argument1;
                 let accumulator = argument2;
                 let suffix = argument3;
-                return useJoin(prefix, accumulator, suffix).collect(this.source());
+                return useSynchronousJoin(prefix, accumulator, suffix).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on join.");
+                throw error;
             }
         }
         else if (isString(argument1) && isString(argument2) && isString(argument3)) {
@@ -724,10 +729,10 @@ export class Collectable {
                 let prefix = argument1;
                 let delimiter = argument2;
                 let suffix = argument3;
-                return useJoin(prefix, delimiter, suffix).collect(this.source());
+                return useSynchronousJoin(prefix, delimiter, suffix).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on join.");
+                throw error;
             }
         }
         throw new TypeError("Invalid arguments.");
@@ -736,10 +741,10 @@ export class Collectable {
         if (isFunction(argument1) && invalidate(argument2) && invalidate(argument3)) {
             try {
                 let accumulator = argument1;
-                useLog(accumulator).collect(this.source());
+                useSynchronousLog(accumulator).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on log.");
+                throw error;
             }
         }
         else if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
@@ -747,28 +752,28 @@ export class Collectable {
                 let prefix = argument1;
                 let accumulator = argument2;
                 let suffix = argument3;
-                useLog(prefix, accumulator, suffix).collect(this.source());
+                useSynchronousLog(prefix, accumulator, suffix).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on log.");
+                throw error;
             }
         }
         else {
             try {
-                useLog().collect(this.source());
+                useSynchronousLog().collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on log.");
+                throw error;
             }
         }
     }
     nonMatch(predicate) {
         if (isFunction(predicate)) {
             try {
-                return useNoneMatch(predicate).collect(this.source());
+                return useSynchronousNoneMatch(predicate).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on nonMatch.");
+                throw error;
             }
         }
         throw new TypeError("Predicate must be a function.");
@@ -776,10 +781,10 @@ export class Collectable {
     partition(count) {
         if (isBigInt(count)) {
             try {
-                return usePartition(count).collect(this.source());
+                return useSynchronousPartition(count).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on partition.");
+                throw error;
             }
         }
         throw new TypeError("Count must be a BigInt.");
@@ -787,11 +792,11 @@ export class Collectable {
     partitionBy(classifier) {
         if (isFunction(classifier)) {
             try {
-                let collector = usePartitionBy(classifier);
+                let collector = useSynchronousPartitionBy(classifier);
                 return collector.collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on partitionBy.");
+                throw error;
             }
         }
         throw new TypeError("Classifier must be a function.");
@@ -800,20 +805,20 @@ export class Collectable {
         if (isFunction(argument1) && invalidate(argument2) && invalidate(argument3)) {
             try {
                 let accumulator = argument1;
-                return useReduce(accumulator).collect(this.source());
+                return useSynchronousReduce(accumulator).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on reduce.");
+                throw error;
             }
         }
         else if (validate(argument1) && isFunction(argument2) && invalidate(argument3)) {
             try {
                 let identity = argument1;
                 let accumulator = argument2;
-                return useReduce(identity, accumulator).collect(this.source());
+                return useSynchronousReduce(identity, accumulator).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on reduce.");
+                throw error;
             }
         }
         else if (validate(argument1) && isFunction(argument2) && isFunction(argument3)) {
@@ -821,10 +826,10 @@ export class Collectable {
                 let identity = argument1;
                 let accumulator = argument2;
                 let finisher = argument3;
-                return useReduce(identity, accumulator, finisher).collect(this.source());
+                return useSynchronousReduce(identity, accumulator, finisher).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on reduce.");
+                throw error;
             }
         }
         else {
@@ -835,10 +840,10 @@ export class Collectable {
         let source = this.source();
         if (isFunction(source)) {
             try {
-                return new Semantic(source);
+                return new SynchronousSemantic(source);
             }
             catch (error) {
-                throw new Error("Uncaught error on semantic.");
+                throw error;
             }
         }
         else {
@@ -847,26 +852,26 @@ export class Collectable {
     }
     toArray() {
         try {
-            return useToArray().collect(this.source());
+            return useSynchronousToArray().collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on toArray.");
+            throw error;
         }
     }
     toMap(keyExtractor, valueExtractor = (element) => element) {
         try {
-            return useToMap(keyExtractor, valueExtractor).collect(this.source());
+            return useSynchronousToMap(keyExtractor, valueExtractor).collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on toMap.");
+            throw error;
         }
     }
     toSet() {
         try {
-            return useToSet().collect(this.source());
+            return useSynchronousToSet().collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on toSet.");
+            throw error;
         }
     }
     write(argument1, argument2) {
@@ -875,146 +880,56 @@ export class Collectable {
                 let stream = argument1;
                 if (isFunction(argument2)) {
                     let accumulator = argument2;
-                    return useWrite(stream, accumulator).collect(this.source());
+                    return useSynchronousWrite(stream, accumulator).collect(this.source());
                 }
                 else {
-                    return useWrite(stream).collect(this.source());
+                    return useSynchronousWrite(stream).collect(this.source());
                 }
             }
             catch (error) {
-                throw new Error("Uncaught error on write.");
+                throw error;
             }
         }
         throw new TypeError("Invalid arguments.");
     }
 }
 ;
-export class EventCollectable extends Collectable {
-    AsyncCollectable = AsyncCollectableSymbol;
-    generator;
-    constructor(argument1) {
-        super();
-        if (isFunction(argument1)) {
-            let generator = argument1;
-            this.generator = generator;
-            Object.defineProperty(this, "AsyncCollectable", {
-                value: AsyncCollectableSymbol,
-                writable: false,
-                enumerable: false,
-                configurable: false
-            });
-        }
-        else {
-            throw new TypeError("Source must be an iterable or a generator function.");
-        }
-    }
-    source() {
-        return this.generator;
-    }
-    *[Symbol.iterator]() {
-        try {
-            let collector = useToArray();
-            yield* collector.collect(this.generator);
-        }
-        catch (error) {
-            throw new Error("Uncaught error on Generator.");
-        }
-    }
-    async *[Symbol.asyncIterator]() {
-        try {
-            let collector = useToArray();
-            yield* collector.collect(this.generator);
-        }
-        catch (error) {
-            throw new Error("Uncaught error on Generator.");
-        }
-    }
-}
-export class UnorderedCollectable extends Collectable {
-    UnorderedCollectable = UnorderedCollectableSymbol;
-    buffer = new Map();
-    constructor(argument1) {
-        super();
-        if (isFunction(argument1)) {
-            let generator = argument1;
-            generator((element, index) => {
-                this.buffer.set(index, element);
-            }, () => false);
-            Object.defineProperties(this, {
-                "UnorderedCollectable": {
-                    value: UnorderedCollectableSymbol,
-                    writable: false,
-                    enumerable: false,
-                    configurable: false
-                }
-            });
-        }
-        else {
-            throw new TypeError("Source must be an iterable or a generator function.");
-        }
-    }
-    source() {
-        return (accept, interrupt) => {
-            for (let [index, element] of this.buffer) {
-                if (interrupt(element, index)) {
-                    break;
-                }
-                accept(element, index);
-            }
-        };
-    }
-    *[Symbol.iterator]() {
-        try {
-            for (let [_index, element] of this.buffer) {
-                yield element;
-            }
-        }
-        catch (error) {
-            throw new Error("Uncaught error on Generator.");
-        }
-    }
-    async *[Symbol.asyncIterator]() {
-        try {
-            for (let [_index, element] of this.buffer) {
-                yield element;
-            }
-        }
-        catch (error) {
-            throw new Error("Uncaught error on AsyncGenerator.");
-        }
-    }
-}
-;
-export class OrderedCollectable extends Collectable {
-    OrderedCollectable = OrderedCollectableSymbol;
-    buffer;
+export class SynchronousOrderedCollectable extends SynchronousCollectable {
+    OrderedCollectable = SynchronousOrderedCollectableSymbol;
+    buffer = [];
+    [Symbol.toStringTag] = "SynchronousOrderedCollectable";
     constructor(argument1, argument2) {
         super();
         if (isFunction(argument1)) {
             try {
                 if (isFunction(argument2)) {
-                    let collector = useToArray();
-                    this.buffer = collector.collect(argument1).sort(argument2).map((element, index) => {
+                    let collector = useSynchronousToArray();
+                    let generator = argument1;
+                    let comparator = argument2;
+                    this.buffer = collector.collect(generator).sort(comparator).map((element, index) => {
                         return {
                             element: element,
                             index: BigInt(index)
                         };
                     });
+                    Object.freeze(this.buffer);
                 }
                 else {
-                    let collector = useToArray();
-                    this.buffer = collector.collect(argument1).map((element, index) => {
+                    let collector = useSynchronousToArray();
+                    let generator = argument1;
+                    this.buffer = collector.collect(generator).map((element, index, array) => {
                         return {
                             element: element,
-                            index: BigInt(index)
+                            index: BigInt(((index % array.length) + array.length) % array.length)
                         };
                     }).sort((a, b) => {
                         return Number(a.index - b.index);
                     });
+                    Object.freeze(this.buffer);
                 }
                 Object.defineProperties(this, {
-                    "OrderedCollectable": {
-                        value: OrderedCollectableSymbol,
+                    "SynchronousOrderedCollectable": {
+                        value: SynchronousOrderedCollectableSymbol,
                         writable: false,
                         enumerable: false,
                         configurable: false
@@ -1036,52 +951,82 @@ export class OrderedCollectable extends Collectable {
         }
     }
     *[Symbol.iterator]() {
-        try {
-            for (let indexed of this.buffer) {
-                yield indexed.element;
-            }
-        }
-        catch (error) {
-            throw new Error("Uncaught error on Generator.");
+        for (let { element } of this.buffer) {
+            yield element;
         }
     }
-    async *[Symbol.asyncIterator]() {
-        try {
-            for (let indexed of this.buffer) {
-                yield indexed.element;
-            }
-        }
-        catch (error) {
-            throw new Error("Uncaught error on AsyncGenerator.");
-        }
+    allMatch(predicate) {
+        let collector = SynchronousCollector.shortable(() => false, (element, index, accumulator) => predicate(element.element, index) && accumulator, (accumulator, element, index) => predicate(element.element, index) && accumulator, (result) => result);
+        return collector.collect(this.buffer);
     }
     source() {
-        try {
-            return (accept, interrupt) => {
-                for (let indexed of this.buffer) {
-                    if (interrupt(indexed.element, indexed.index)) {
-                        break;
-                    }
-                    accept(indexed.element, indexed.index);
+        return (accept, interrupt) => {
+            for (let { element, index } of this.buffer) {
+                if (interrupt(element, index)) {
+                    break;
                 }
-            };
-        }
-        catch (error) {
-            throw new Error("Uncaught error on creating source.");
-        }
+                accept(element, index);
+            }
+        };
     }
     isEmpty() {
         return this.buffer.length === 0;
     }
+    count() {
+        return BigInt(this.buffer.length);
+    }
 }
 ;
-export class Statistics extends OrderedCollectable {
-    Statistics = StatisticsSymbol;
+export class SynchronousUnorderedCollectable extends SynchronousCollectable {
+    SynchronousUnorderedCollectable = SynchronousUnorderedCollectableSymbol;
+    [Symbol.toStringTag] = "SynchronousUnorderedCollectable";
+    buffer = new Map();
+    constructor(argument1) {
+        super();
+        if (isFunction(argument1)) {
+            let generator = argument1;
+            generator((element, index) => {
+                this.buffer.set(index, element);
+            }, () => false);
+            Object.freeze(this.buffer);
+            Object.defineProperties(this, {
+                "SynchronousUnorderedCollectable": {
+                    value: SynchronousUnorderedCollectableSymbol,
+                    writable: false,
+                    enumerable: false,
+                    configurable: false
+                }
+            });
+        }
+        else {
+            throw new TypeError("Source must be an iterable or a generator function.");
+        }
+    }
+    *[Symbol.iterator]() {
+        for (let [_index, element] of this.buffer) {
+            yield element;
+        }
+    }
+    source() {
+        return (accept, interrupt) => {
+            for (let [_index, element] of this.buffer) {
+                if (interrupt(element, _index)) {
+                    break;
+                }
+                accept(element, _index);
+            }
+        };
+    }
+}
+;
+export class SynchronousStatistics extends SynchronousOrderedCollectable {
+    SynchronousStatistics = SynchronousStatisticsSymbol;
+    [Symbol.toStringTag] = "SynchronousStatistics";
     constructor(parameter, comparator) {
-        super(parameter, comparator || useCompare);
+        super(parameter, validate(comparator) ? comparator : useCompare);
         Object.defineProperties(this, {
-            "Statistics": {
-                value: StatisticsSymbol,
+            "SynchronousStatistics": {
+                value: SynchronousStatisticsSymbol,
                 enumerable: false,
                 writable: false,
                 configurable: false
@@ -1089,40 +1034,23 @@ export class Statistics extends OrderedCollectable {
         });
     }
     *[Symbol.iterator]() {
-        try {
-            for (let indexed of this.buffer) {
-                yield indexed.element;
-            }
-        }
-        catch (error) {
-            throw new Error("Uncaught error on Generator.");
+        for (let { element } of this.buffer) {
+            yield element;
         }
     }
-    async *[Symbol.asyncIterator]() {
-        try {
-            for (let indexed of this.buffer) {
-                yield indexed.element;
-            }
-        }
-        catch (error) {
-            throw new Error("Uncaught error on AsyncGenerator.");
-        }
-    }
-    count() {
-        return BigInt(this.buffer.length);
-    }
     frequency() {
-        return useFrequency().collect(this.source());
+        return useSynchronousFrequency().collect(this.source());
     }
 }
 ;
-export class NumericStatistics extends Statistics {
-    NumericStatistics = NumericStatisticsSymbol;
+export class SynchronousBigIntStatistics extends SynchronousStatistics {
+    BigIntStatistics = SynchronousBigIntStatisticsSymbol;
+    [Symbol.toStringTag] = "SynchronousBigIntStatistics";
     constructor(parameter, comparator) {
         super(parameter, comparator || useCompare);
         Object.defineProperties(this, {
-            "NumericStatistics": {
-                value: NumericStatisticsSymbol,
+            "SynchronousBigIntStatistics": {
+                value: SynchronousBigIntStatisticsSymbol,
                 enumerable: false,
                 writable: false,
                 configurable: false
@@ -1130,34 +1058,17 @@ export class NumericStatistics extends Statistics {
         });
     }
     *[Symbol.iterator]() {
-        try {
-            for (let indexed of this.buffer) {
-                yield indexed.element;
-            }
-        }
-        catch (error) {
-            throw new Error("Uncaught error on Generator.");
+        for (let { element } of this.buffer) {
+            yield element;
         }
     }
-    async *[Symbol.asyncIterator]() {
-        try {
-            for (let indexed of this.buffer) {
-                yield indexed.element;
-            }
-        }
-        catch (error) {
-            throw new Error("Uncaught error on AsyncGenerator.");
-        }
-    }
-    average(mapper) {
+    average(argument1) {
         if (this.isEmpty()) {
-            return 0;
+            return 0n;
         }
         try {
-            if (isFunction(mapper)) {
-                return useNumericAverage(mapper).collect(this.source());
-            }
-            return useNumericAverage().collect(this.source());
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            return useSynchronousBigIntAverage(mapper).collect(this.source());
         }
         catch (error) {
             throw new Error("Uncaught error on average.");
@@ -1165,17 +1076,18 @@ export class NumericStatistics extends Statistics {
     }
     range(argument1) {
         if (this.isEmpty()) {
-            return 0;
+            return 0n;
         }
         try {
-            if (this.count() === 1n) {
-                return 0;
-            }
-            let mapper = isFunction(argument1) ? argument1 : useToNumber;
-            let count = this.buffer.length;
-            let minimum = this.buffer[0].element;
-            let maximum = this.buffer[count - 1].element;
-            return mapper(maximum) - mapper(minimum);
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            let minimum = this.findFirst();
+            let maximum = this.findLast();
+            return minimum.flatMap((minimum) => {
+                return maximum.map((maximum) => {
+                    let difference = mapper(maximum) - mapper(minimum);
+                    return difference < 0n ? -difference : difference;
+                });
+            }).get(0n);
         }
         catch (error) {
             throw new Error("Uncaught error on range.");
@@ -1183,11 +1095,11 @@ export class NumericStatistics extends Statistics {
     }
     variance(argument1) {
         if (this.isEmpty() || this.count() === 1n) {
-            return 0;
+            return 0n;
         }
         try {
-            let mapper = isFunction(argument1) ? argument1 : useToNumber;
-            return useNumericVariance(mapper).collect(this.source());
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            return useSynchronousBigIntVariance(mapper).collect(this.source());
         }
         catch (error) {
             throw new Error("Uncaught error on variance.");
@@ -1195,8 +1107,9 @@ export class NumericStatistics extends Statistics {
     }
     standardDeviation(argument1) {
         try {
-            let mapper = isFunction(argument1) ? argument1 : useToNumber;
-            return useNumericStandardDeviation(mapper).collect(this.source());
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            let variance = this.variance(mapper);
+            return BigInt(Math.sqrt(Number(variance)));
         }
         catch (error) {
             throw new Error("Uncaught error on standardDeviation.");
@@ -1204,11 +1117,11 @@ export class NumericStatistics extends Statistics {
     }
     mean(argument1) {
         if (this.isEmpty()) {
-            return 0;
+            return 0n;
         }
         try {
-            let mapper = isFunction(argument1) ? argument1 : useToNumber;
-            return useNumericAverage(mapper).collect(this.source());
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            return useSynchronousBigIntAverage(mapper).collect(this.source());
         }
         catch (error) {
             throw new Error("Uncaught error on mean.");
@@ -1216,11 +1129,11 @@ export class NumericStatistics extends Statistics {
     }
     median(argument1) {
         if (this.isEmpty()) {
-            return 0;
+            return 0n;
         }
         try {
-            let mapper = isFunction(argument1) ? argument1 : useToNumber;
-            return useNumericMedian(mapper).collect(this.source());
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            return useSynchronousBigIntMedian(mapper).collect(this.source());
         }
         catch (error) {
             throw new Error("Uncaught error on median.");
@@ -1228,11 +1141,11 @@ export class NumericStatistics extends Statistics {
     }
     mode(argument1) {
         if (this.isEmpty()) {
-            return 0;
+            return 0n;
         }
         try {
-            let mapper = isFunction(argument1) ? argument1 : useToNumber;
-            return useNumericMode(mapper).collect(this.source());
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            return useSynchronousBigIntMode(mapper).collect(this.source());
         }
         catch (error) {
             throw new Error("Uncaught error on mode.");
@@ -1240,11 +1153,11 @@ export class NumericStatistics extends Statistics {
     }
     summate(argument1) {
         if (this.isEmpty()) {
-            return 0;
+            return 0n;
         }
         try {
-            let mapper = isFunction(argument1) ? argument1 : useToNumber;
-            return useNumericSummate(mapper).collect(this.source());
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            return useSynchronousBigIntSummate(mapper).collect(this.source());
         }
         catch (error) {
             throw new Error("Uncaught error on summate.");
@@ -1252,20 +1165,19 @@ export class NumericStatistics extends Statistics {
     }
     quantile(quantile, argument1) {
         if (this.isEmpty()) {
-            return 0;
+            return 0n;
         }
-        if (quantile < 0 || quantile > 1) {
+        if (!isNumber(quantile) || quantile < 0 || quantile > 1) {
             throw new RangeError("Invalid quantile.");
         }
         try {
-            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
             let count = Number(this.count());
             let index = Math.floor(quantile * count);
             if (index === count) {
                 index--;
             }
-            let value = mapper(this.buffer[index].element);
-            return value;
+            return this.findAt(index).map(mapper).get(0n);
         }
         catch (error) {
             throw new Error("Uncaught error on quantile.");
@@ -1273,10 +1185,10 @@ export class NumericStatistics extends Statistics {
     }
     interquartileRange(argument1) {
         if (this.isEmpty()) {
-            return 0;
+            return 0n;
         }
         try {
-            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
             let lower = this.quantile(0.25, mapper);
             let upper = this.quantile(0.75, mapper);
             return upper - lower;
@@ -1287,22 +1199,22 @@ export class NumericStatistics extends Statistics {
     }
     skewness(argument1) {
         if (this.isEmpty()) {
-            return 0;
+            return 0n;
         }
         try {
-            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
             let mean = this.mean(mapper);
             let standardDeviation = this.standardDeviation(mapper);
-            if (standardDeviation === 0) {
-                return 0;
+            if (standardDeviation === 0n) {
+                return 0n;
             }
-            let data = this.toArray().map(item => mapper(item));
-            let summate = 0;
+            let data = (this.toArray()).map((element) => mapper(element));
+            let summate = 0n;
             for (let value of data) {
-                let z = (value - mean) / standardDeviation;
-                summate += Math.pow(z, 3);
+                let z = value - mean;
+                summate += z * z * z;
             }
-            return summate / data.length;
+            return summate / BigInt(data.length);
         }
         catch (error) {
             throw new Error("Uncaught error on skewness.");
@@ -1310,22 +1222,23 @@ export class NumericStatistics extends Statistics {
     }
     kurtosis(argument1) {
         if (this.isEmpty()) {
-            return 0;
+            return 0n;
         }
         try {
-            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
             let mean = this.mean(mapper);
             let standardDeviation = this.standardDeviation(mapper);
-            if (standardDeviation === 0) {
-                return 0;
+            if (standardDeviation === 0n) {
+                return 0n;
             }
-            let data = this.toArray().map(item => mapper(item));
-            let summate = 0;
+            let data = (this.toArray()).map((element) => mapper(element));
+            let summate = 0n;
+            let count = data.length;
             for (let value of data) {
-                let z = (value - mean) / standardDeviation;
-                summate += Math.pow(z, 4);
+                let z = value - mean;
+                summate += z * z * z * z;
             }
-            return summate / (data.length * data.length) - 3;
+            return summate / BigInt(count * count) - 3n;
         }
         catch (error) {
             throw new Error("Uncaught error on kurtosis.");
@@ -1333,13 +1246,14 @@ export class NumericStatistics extends Statistics {
     }
 }
 ;
-export class BigIntStatistics extends Statistics {
-    BigIntStatistics = BigIntStatisticsSymbol;
+export class SynchronousNumericStatistics extends SynchronousStatistics {
+    SynchronousNumericStatistics = SynchronousNumericStatisticsSymbol;
+    [Symbol.toStringTag] = "SynchronousNumericStatistics";
     constructor(parameter, comparator) {
         super(parameter, comparator || useCompare);
         Object.defineProperties(this, {
-            "BigIntStatistics": {
-                value: BigIntStatisticsSymbol,
+            "SynchronousNumericStatistics": {
+                value: SynchronousNumericStatisticsSymbol,
                 enumerable: false,
                 writable: false,
                 configurable: false
@@ -1347,32 +1261,19 @@ export class BigIntStatistics extends Statistics {
         });
     }
     *[Symbol.iterator]() {
-        try {
-            for (let indexed of this.buffer) {
-                yield indexed.element;
-            }
-        }
-        catch (error) {
-            throw new Error("Uncaught error on Generator.");
+        for (let { element } of this.buffer) {
+            yield element;
         }
     }
-    async *[Symbol.asyncIterator]() {
-        try {
-            for (let indexed of this.buffer) {
-                yield indexed.element;
-            }
-        }
-        catch (error) {
-            throw new Error("Uncaught error on AsyncGenerator.");
-        }
-    }
-    average(argument1) {
+    average(mapper) {
         if (this.isEmpty()) {
-            return 0n;
+            return 0;
         }
         try {
-            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
-            return useBigIntAverage(mapper).collect(this.source());
+            if (isFunction(mapper)) {
+                return useSynchronousNumericAverage(mapper).collect(this.source());
+            }
+            return useSynchronousNumericAverage().collect(this.source());
         }
         catch (error) {
             throw new Error("Uncaught error on average.");
@@ -1380,14 +1281,21 @@ export class BigIntStatistics extends Statistics {
     }
     range(argument1) {
         if (this.isEmpty()) {
-            return 0n;
+            return 0;
         }
         try {
-            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
-            let count = this.buffer.length;
-            let minimum = this.buffer[0].element;
-            let maximum = this.buffer[count - 1].element;
-            return mapper(maximum) - mapper(minimum);
+            if (this.count() === 1n) {
+                return 0;
+            }
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            let minimum = this.findFirst();
+            let maximum = this.findLast();
+            return minimum.flatMap((minimum) => {
+                return maximum.map((maximum) => {
+                    let difference = mapper(maximum) - mapper(minimum);
+                    return difference < 0 ? -difference : difference;
+                });
+            }).get(0);
         }
         catch (error) {
             throw new Error("Uncaught error on range.");
@@ -1395,11 +1303,11 @@ export class BigIntStatistics extends Statistics {
     }
     variance(argument1) {
         if (this.isEmpty() || this.count() === 1n) {
-            return 0n;
+            return 0;
         }
         try {
-            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
-            return useBigIntVariance(mapper).collect(this.source());
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            return useSynchronousNumericVariance(mapper).collect(this.source());
         }
         catch (error) {
             throw new Error("Uncaught error on variance.");
@@ -1407,9 +1315,8 @@ export class BigIntStatistics extends Statistics {
     }
     standardDeviation(argument1) {
         try {
-            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
-            let variance = this.variance(mapper);
-            return BigInt(Math.sqrt(Number(variance)));
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            return useSynchronousNumericStandardDeviation(mapper).collect(this.source());
         }
         catch (error) {
             throw new Error("Uncaught error on standardDeviation.");
@@ -1417,11 +1324,11 @@ export class BigIntStatistics extends Statistics {
     }
     mean(argument1) {
         if (this.isEmpty()) {
-            return 0n;
+            return 0;
         }
         try {
-            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
-            return useBigIntAverage(mapper).collect(this.source());
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            return useSynchronousNumericAverage(mapper).collect(this.source());
         }
         catch (error) {
             throw new Error("Uncaught error on mean.");
@@ -1429,11 +1336,11 @@ export class BigIntStatistics extends Statistics {
     }
     median(argument1) {
         if (this.isEmpty()) {
-            return 0n;
+            return 0;
         }
         try {
-            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
-            return useBigIntMedian(mapper).collect(this.source());
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            return useSynchronousNumericMedian(mapper).collect(this.source());
         }
         catch (error) {
             throw new Error("Uncaught error on median.");
@@ -1441,11 +1348,11 @@ export class BigIntStatistics extends Statistics {
     }
     mode(argument1) {
         if (this.isEmpty()) {
-            return 0n;
+            return 0;
         }
         try {
-            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
-            return useBigIntMode(mapper).collect(this.source());
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            return useSynchronousNumericMode(mapper).collect(this.source());
         }
         catch (error) {
             throw new Error("Uncaught error on mode.");
@@ -1453,11 +1360,11 @@ export class BigIntStatistics extends Statistics {
     }
     summate(argument1) {
         if (this.isEmpty()) {
-            return 0n;
+            return 0;
         }
         try {
-            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
-            return useBigIntSummate(mapper).collect(this.source());
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            return useSynchronousNumericSummate(mapper).collect(this.source());
         }
         catch (error) {
             throw new Error("Uncaught error on summate.");
@@ -1465,20 +1372,19 @@ export class BigIntStatistics extends Statistics {
     }
     quantile(quantile, argument1) {
         if (this.isEmpty()) {
-            return 0n;
+            return 0;
         }
-        if (typeof quantile !== "number" || quantile < 0 || quantile > 1) {
+        if (quantile < 0 || quantile > 1) {
             throw new RangeError("Invalid quantile.");
         }
         try {
-            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
             let count = Number(this.count());
             let index = Math.floor(quantile * count);
             if (index === count) {
                 index--;
             }
-            let value = mapper(this.buffer[index].element);
-            return value;
+            return this.findAt(index).map(mapper).get(0);
         }
         catch (error) {
             throw new Error("Uncaught error on quantile.");
@@ -1486,10 +1392,10 @@ export class BigIntStatistics extends Statistics {
     }
     interquartileRange(argument1) {
         if (this.isEmpty()) {
-            return 0n;
+            return 0;
         }
         try {
-            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
             let lower = this.quantile(0.25, mapper);
             let upper = this.quantile(0.75, mapper);
             return upper - lower;
@@ -1500,22 +1406,22 @@ export class BigIntStatistics extends Statistics {
     }
     skewness(argument1) {
         if (this.isEmpty()) {
-            return 0n;
+            return 0;
         }
         try {
-            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
             let mean = this.mean(mapper);
             let standardDeviation = this.standardDeviation(mapper);
-            if (standardDeviation === 0n) {
-                return 0n;
+            if (standardDeviation === 0) {
+                return 0;
             }
-            let data = this.toArray().map(item => mapper(item));
-            let summate = 0n;
+            let data = (this.toArray()).map((element) => mapper(element));
+            let summate = 0;
             for (let value of data) {
-                let z = value - mean;
-                summate += z * z * z;
+                let z = (value - mean) / standardDeviation;
+                summate += Math.pow(z, 3);
             }
-            return summate / BigInt(data.length);
+            return summate / data.length;
         }
         catch (error) {
             throw new Error("Uncaught error on skewness.");
@@ -1523,23 +1429,22 @@ export class BigIntStatistics extends Statistics {
     }
     kurtosis(argument1) {
         if (this.isEmpty()) {
-            return 0n;
+            return 0;
         }
         try {
-            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
             let mean = this.mean(mapper);
             let standardDeviation = this.standardDeviation(mapper);
-            if (standardDeviation === 0n) {
-                return 0n;
+            if (standardDeviation === 0) {
+                return 0;
             }
-            let data = this.toArray().map(item => mapper(item));
-            let summate = 0n;
-            let count = data.length;
+            let data = (this.toArray()).map((element) => mapper(element));
+            let summate = 0;
             for (let value of data) {
-                let z = value - mean;
-                summate += z * z * z * z;
+                let z = (value - mean) / standardDeviation;
+                summate += Math.pow(z, 4);
             }
-            return summate / BigInt(count * count) - 3n;
+            return summate / (data.length * data.length) - 3;
         }
         catch (error) {
             throw new Error("Uncaught error on kurtosis.");
@@ -1547,13 +1452,14 @@ export class BigIntStatistics extends Statistics {
     }
 }
 ;
-export class WindowCollectable extends OrderedCollectable {
-    WindowCollectable = WindowCollectableSymbol;
+export class SynchronousWindowCollectable extends SynchronousOrderedCollectable {
+    WindowCollectable = SynchronousWindowCollectableSymbol;
+    [Symbol.toStringTag] = "SynchronousWindowCollectable";
     constructor(parameter, comparator = useCompare) {
         super(parameter, comparator);
         Object.defineProperties(this, {
-            "WindowCollectable": {
-                value: WindowCollectableSymbol,
+            "SynchronousWindowCollectable": {
+                value: SynchronousWindowCollectableSymbol,
                 writable: false,
                 enumerable: false,
                 configurable: false
@@ -1561,33 +1467,18 @@ export class WindowCollectable extends OrderedCollectable {
         });
     }
     *[Symbol.iterator]() {
-        try {
-            for (let indexed of this.buffer) {
-                yield indexed.element;
-            }
-        }
-        catch (error) {
-            throw new Error("Uncaught error on Generator.");
-        }
-    }
-    async *[Symbol.asyncIterator]() {
-        try {
-            for (let indexed of this.buffer) {
-                yield indexed.element;
-            }
-        }
-        catch (error) {
-            throw new Error("Uncaught error on AsyncGenerator.");
+        for (let { element } of this.buffer) {
+            yield element;
         }
     }
     slide(size, step = 1n) {
         if (size > 0n && step > 0n) {
-            return new Semantic((accepet, interrupt) => {
+            return new SynchronousSemantic((accepet, interrupt) => {
                 try {
                     let index = 0n;
                     for (let start = 0n; start < BigInt(this.buffer.length); start += step) {
                         let end = start + size;
-                        let inner = new Semantic((accept, interrupt) => {
+                        let inner = new SynchronousSemantic((accept, interrupt) => {
                             for (let index = start; index < end && index < BigInt(this.buffer.length); index++) {
                                 let indexed = this.buffer[Number(index)];
                                 if (invalidate(indexed)) {