semantic-typescript 0.5.3 → 0.6.0

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

@@ -1,32 +1,38 @@
-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, SynchronousCollector } from "./collector";
+import { isFunction, isSynchronousSemantic, isIterable, isNumber, isBigInt, isObject, isString, isSynchronousCollectable, isAsynchronousCollector } from "../guard";
+import { useHash } from "../hash";
+import { useCompare, useToBigInt, useToNumber } from "../hook";
+import { SynchronousBigIntStatisticsSymbol, SynchronousCollectableSymbol, SynchronousNumericStatisticsSymbol, SynchronousOrderedCollectableSymbol, SynchronousSemanticSymbol, SynchronousStatisticsSymbol, SynchronousUnorderedCollectableSymbol, SynchronousWindowCollectableSymbol } from "../symbol";
+import { invalidate, validate, } from "../utility";
+export class SynchronousSemantic {
     generator;
-    Semantic = SemanticSymbol;
+    SynchronousSemantic = SynchronousSemanticSymbol;
     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)) {
+            let other = argument;
+            return new SynchronousSemantic((accept, interrupt) => {
                 try {
                     let count = 0n;
                     this.generator((element, index) => {
@@ -43,8 +49,9 @@ export class Semantic {
                 }
             });
         }
-        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) => {
@@ -65,7 +72,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) => {
@@ -83,18 +90,19 @@ export class Semantic {
     }
     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) {
@@ -106,7 +114,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)) {
@@ -123,7 +131,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 +144,7 @@ export class Semantic {
                                 count++;
                             }
                         }
-                        else if (isSemantic(result)) {
+                        else if (isSynchronousSemantic(result)) {
                             result.generator((subElement) => {
                                 accept(subElement, count);
                                 stop = stop || interrupt(subElement, count);
@@ -154,7 +162,7 @@ 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;
@@ -167,7 +175,7 @@ export class Semantic {
                                 count++;
                             }
                         }
-                        else if (isSemantic(result)) {
+                        else if (isSynchronousSemantic(result)) {
                             result.generator((subElement) => {
                                 accept(subElement, count);
                                 stop = stop || interrupt(subElement, count);
@@ -186,7 +194,7 @@ export class Semantic {
     limit(n) {
         if (isNumber(n)) {
             let limit = BigInt(n);
-            return new Semantic((accept, interrupt) => {
+            return new SynchronousSemantic((accept, interrupt) => {
                 try {
                     let count = 0n;
                     this.generator((element, index) => {
@@ -203,7 +211,7 @@ export class Semantic {
         }
         if (isBigInt(n)) {
             let limit = n;
-            return new Semantic((accept, interrupt) => {
+            return new SynchronousSemantic((accept, interrupt) => {
                 try {
                     let count = 0n;
                     this.generator((element, index) => {
@@ -222,7 +230,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) => {
@@ -240,7 +248,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);
@@ -256,7 +264,7 @@ 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));
@@ -270,7 +278,7 @@ export class Semantic {
         throw new TypeError("Invalid arguments.");
     }
     reverse() {
-        return new Semantic((accept, interrupt) => {
+        return new SynchronousSemantic((accept, interrupt) => {
             try {
                 this.generator((element, index) => {
                     accept(element, -index);
@@ -284,7 +292,7 @@ export class Semantic {
     shuffle(mapper) {
         if (isFunction(mapper)) {
             try {
-                return new Semantic((accept, interrupt) => {
+                return new SynchronousSemantic((accept, interrupt) => {
                     this.generator((element, index) => {
                         accept(element, mapper(element, index));
                     }, interrupt);
@@ -294,7 +302,7 @@ export class Semantic {
                 throw new Error("Uncaught error on shuffle.");
             }
         }
-        return new Semantic((accept, interrupt) => {
+        return new SynchronousSemantic((accept, interrupt) => {
             try {
                 this.generator((element, index) => {
                     accept(element, useHash(element, index));
@@ -307,7 +315,7 @@ export class Semantic {
     }
     skip(n) {
         if (isNumber(n)) {
-            return new Semantic((accept, interrupt) => {
+            return new SynchronousSemantic((accept, interrupt) => {
                 try {
                     let count = 0n;
                     let limit = BigInt(n);
@@ -326,7 +334,7 @@ export class Semantic {
             });
         }
         if (isBigInt(n)) {
-            return new Semantic((accept, interrupt) => {
+            return new SynchronousSemantic((accept, interrupt) => {
                 try {
                     let count = 0n;
                     this.generator((element, index) => {
@@ -345,24 +353,27 @@ export class Semantic {
         }
         throw new TypeError("Invalid arguments.");
     }
+    source() {
+        return this.generator;
+    }
     sorted(comparator) {
         if (isFunction(comparator)) {
             try {
-                return new OrderedCollectable(this.generator, comparator);
+                return new SynchronousOrderedCollectable(this.generator, comparator);
             }
             catch (error) {
                 throw new Error("Uncaught error on sorted.");
             }
         }
         try {
-            return new OrderedCollectable(this.generator, (a, b) => useCompare(a, b));
+            return new SynchronousOrderedCollectable(this.generator, (a, b) => useCompare(a, b));
         }
         catch (error) {
             throw new Error("Uncaught error on sorted.");
         }
     }
     sub(start, end) {
-        return new Semantic((accept, interrupt) => {
+        return new SynchronousSemantic((accept, interrupt) => {
             try {
                 let count = 0n;
                 this.generator((element, index) => {
@@ -380,7 +391,7 @@ export class Semantic {
         });
     }
     takeWhile(predicate) {
-        return new Semantic((accept, interrupt) => {
+        return new SynchronousSemantic((accept, interrupt) => {
             try {
                 this.generator((element, index) => {
                     if (!predicate(element, index)) {
@@ -395,44 +406,36 @@ export class Semantic {
             }
         });
     }
-    toCollectable(mapper) {
+    toSynchronousCollectable(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 new Error("Uncaught error on toSynchronousCollectable.");
             }
         }
         try {
-            return new UnorderedCollectable(this.generator);
+            return new SynchronousUnorderedCollectable(this.generator);
         }
         catch (error) {
-            throw new Error("Uncaught error on toCollectable.");
+            throw new Error("Uncaught error on toSynchronousCollectable.");
         }
     }
     toBigintStatistics() {
         try {
-            return new BigIntStatistics(this.generator);
+            return new SynchronousBigIntStatistics(this.generator);
         }
         catch (error) {
             throw new Error("Uncaught error on toBigintStatistics.");
         }
     }
-    toEvent() {
-        try {
-            return new EventCollectable(this.generator);
-        }
-        catch (error) {
-            throw new Error("Uncaught error on toEvent.");
-        }
-    }
     toNumericStatistics() {
         try {
-            return new NumericStatistics(this.generator);
+            return new SynchronousNumericStatistics(this.generator);
         }
         catch (error) {
             throw new Error("Uncaught error on toNumericStatistics.");
@@ -440,7 +443,7 @@ export class Semantic {
     }
     toOrdered() {
         try {
-            return new OrderedCollectable(this.generator);
+            return new SynchronousOrderedCollectable(this.generator);
         }
         catch (error) {
             throw new Error("Uncaught error on toOrdered.");
@@ -448,7 +451,7 @@ export class Semantic {
     }
     toUnordered() {
         try {
-            return new UnorderedCollectable(this.generator);
+            return new SynchronousUnorderedCollectable(this.generator);
         }
         catch (error) {
             throw new Error(String(error));
@@ -456,7 +459,7 @@ export class Semantic {
     }
     toWindow() {
         try {
-            return new WindowCollectable(this.generator);
+            return new SynchronousWindowCollectable(this.generator);
         }
         catch (error) {
             throw new Error("Uncaught error on toWindow.");
@@ -465,7 +468,7 @@ export class Semantic {
     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));
@@ -478,7 +481,7 @@ export class Semantic {
         }
         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);
@@ -491,7 +494,7 @@ export class Semantic {
         }
         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));
@@ -506,11 +509,11 @@ export class Semantic {
     }
 }
 ;
-export class Collectable {
-    Collectable = CollectableSymbol;
+export class SynchronousCollectable {
+    SynchronousCollectable = SynchronousCollectableSymbol;
     constructor() {
-        Object.defineProperty(this, "Collectable", {
-            value: CollectableSymbol,
+        Object.defineProperty(this, "SynchronousCollectable", {
+            value: SynchronousCollectableSymbol,
             enumerable: false,
             writable: false,
             configurable: false
@@ -519,7 +522,7 @@ export class Collectable {
     anyMatch(predicate) {
         if (isFunction(predicate)) {
             try {
-                return useAnyMatch(predicate).collect(this);
+                return useSynchronousAnyMatch(predicate).collect(this);
             }
             catch (error) {
                 throw new Error("Uncaught error on anyMatch.");
@@ -528,11 +531,11 @@ export class Collectable {
         throw new TypeError("Predicate must be a function.");
     }
     allMatch(predicate) {
-        return useAllMatch(predicate).collect(this);
+        return useSynchronousAllMatch(predicate).collect(this);
     }
     collect(argument1, argument2, argument3, argument4) {
         try {
-            if (isCollector(argument1)) {
+            if (isAsynchronousCollector(argument1)) {
                 let collector = argument1;
                 return collector.collect(this);
             }
@@ -540,14 +543,14 @@ export class Collectable {
                 let identity = argument1;
                 let accumulator = argument2;
                 let finisher = argument3;
-                return useCollect(identity, accumulator, finisher).collect(this);
+                return useSynchronousCollect(identity, accumulator, finisher).collect(this);
             }
             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);
             }
         }
         catch (error) {
@@ -556,12 +559,12 @@ export class Collectable {
         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.");
@@ -570,7 +573,7 @@ export class Collectable {
         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.");
@@ -581,7 +584,7 @@ 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.");
@@ -596,7 +599,7 @@ export class Collectable {
     }
     findAny() {
         try {
-            return useFindAny().collect(this.source());
+            return useSynchronousFindAny().collect(this.source());
         }
         catch (error) {
             throw new Error("Uncaught error on findAny.");
@@ -605,7 +608,7 @@ export class Collectable {
     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.");
@@ -613,7 +616,7 @@ export class Collectable {
         }
         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.");
@@ -623,7 +626,7 @@ export class Collectable {
     }
     findFirst() {
         try {
-            return useFindFirst().collect(this.source());
+            return useSynchronousFindFirst().collect(this.source());
         }
         catch (error) {
             throw new Error("Uncaught error on findFirst.");
@@ -631,7 +634,7 @@ export class Collectable {
     }
     findLast() {
         try {
-            return useFindLast().collect(this.source());
+            return useSynchronousFindLast().collect(this.source());
         }
         catch (error) {
             throw new Error("Uncaught error on findLast.");
@@ -640,7 +643,7 @@ export class Collectable {
     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.");
@@ -649,7 +652,7 @@ export class Collectable {
     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.");
@@ -658,7 +661,7 @@ export class Collectable {
     forEach(action) {
         if (isFunction(action)) {
             try {
-                useForEach(action).collect(this);
+                useSynchronousForEach(action).collect(this);
             }
             catch (error) {
                 throw new Error("Uncaught error on forEach.");
@@ -671,7 +674,7 @@ 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.");
@@ -682,7 +685,7 @@ 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.");
@@ -693,7 +696,7 @@ 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.");
@@ -702,7 +705,7 @@ export class Collectable {
         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.");
@@ -713,7 +716,7 @@ 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.");
@@ -724,7 +727,7 @@ 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.");
@@ -736,7 +739,7 @@ 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.");
@@ -747,7 +750,7 @@ 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.");
@@ -755,7 +758,7 @@ export class Collectable {
         }
         else {
             try {
-                useLog().collect(this.source());
+                useSynchronousLog().collect(this.source());
             }
             catch (error) {
                 throw new Error("Uncaught error on log.");
@@ -765,7 +768,7 @@ export class Collectable {
     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.");
@@ -776,7 +779,7 @@ 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.");
@@ -787,7 +790,7 @@ export class Collectable {
     partitionBy(classifier) {
         if (isFunction(classifier)) {
             try {
-                let collector = usePartitionBy(classifier);
+                let collector = useSynchronousPartitionBy(classifier);
                 return collector.collect(this.source());
             }
             catch (error) {
@@ -800,7 +803,7 @@ 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.");
@@ -810,7 +813,7 @@ export class Collectable {
             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.");
@@ -821,7 +824,7 @@ 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.");
@@ -835,7 +838,7 @@ 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.");
@@ -847,7 +850,7 @@ export class Collectable {
     }
     toArray() {
         try {
-            return useToArray().collect(this.source());
+            return useSynchronousToArray().collect(this.source());
         }
         catch (error) {
             throw new Error("Uncaught error on toArray.");
@@ -855,7 +858,7 @@ export class Collectable {
     }
     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.");
@@ -863,7 +866,7 @@ export class Collectable {
     }
     toSet() {
         try {
-            return useToSet().collect(this.source());
+            return useSynchronousToSet().collect(this.source());
         }
         catch (error) {
             throw new Error("Uncaught error on toSet.");
@@ -875,10 +878,10 @@ 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) {
@@ -889,111 +892,15 @@ export class Collectable {
     }
 }
 ;
-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;
+export class SynchronousOrderedCollectable extends SynchronousCollectable {
+    SynchronousOrderedCollectable = SynchronousOrderedCollectableSymbol;
     buffer;
     constructor(argument1, argument2) {
         super();
         if (isFunction(argument1)) {
             try {
                 if (isFunction(argument2)) {
-                    let collector = useToArray();
+                    let collector = useSynchronousToArray();
                     this.buffer = collector.collect(argument1).sort(argument2).map((element, index) => {
                         return {
                             element: element,
@@ -1002,7 +909,7 @@ export class OrderedCollectable extends Collectable {
                     });
                 }
                 else {
-                    let collector = useToArray();
+                    let collector = useSynchronousToArray();
                     this.buffer = collector.collect(argument1).map((element, index) => {
                         return {
                             element: element,
@@ -1013,8 +920,8 @@ export class OrderedCollectable extends Collectable {
                     });
                 }
                 Object.defineProperties(this, {
-                    "OrderedCollectable": {
-                        value: OrderedCollectableSymbol,
+                    "SynchronousOrderedCollectable": {
+                        value: SynchronousOrderedCollectableSymbol,
                         writable: false,
                         enumerable: false,
                         configurable: false
@@ -1075,13 +982,68 @@ export class OrderedCollectable extends Collectable {
     }
 }
 ;
-export class Statistics extends OrderedCollectable {
-    Statistics = StatisticsSymbol;
+export class SynchronousUnorderedCollectable extends SynchronousCollectable {
+    SynchronousUnorderedCollectable = SynchronousUnorderedCollectableSymbol;
+    buffer = new Map();
+    constructor(argument1) {
+        super();
+        if (isFunction(argument1)) {
+            let generator = argument1;
+            generator((element, index) => {
+                this.buffer.set(index, element);
+            }, () => false);
+            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.");
+        }
+    }
+    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 SynchronousStatistics extends SynchronousOrderedCollectable {
+    SynchronousStatistics = SynchronousStatisticsSymbol;
     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
@@ -1112,17 +1074,17 @@ export class Statistics extends OrderedCollectable {
         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;
     constructor(parameter, comparator) {
         super(parameter, comparator || useCompare);
         Object.defineProperties(this, {
-            "NumericStatistics": {
-                value: NumericStatisticsSymbol,
+            "SynchronousBigIntStatistics": {
+                value: SynchronousBigIntStatisticsSymbol,
                 enumerable: false,
                 writable: false,
                 configurable: false
@@ -1149,15 +1111,13 @@ export class NumericStatistics extends Statistics {
             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,13 +1125,10 @@ 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 mapper = isFunction(argument1) ? argument1 : useToBigInt;
             let count = this.buffer.length;
             let minimum = this.buffer[0].element;
             let maximum = this.buffer[count - 1].element;
@@ -1183,11 +1140,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 +1152,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 +1162,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 +1174,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 +1186,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 +1198,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,13 +1210,13 @@ export class NumericStatistics extends Statistics {
     }
     quantile(quantile, argument1) {
         if (this.isEmpty()) {
-            return 0;
+            return 0n;
         }
-        if (quantile < 0 || quantile > 1) {
+        if (typeof quantile !== "number" || 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) {
@@ -1273,10 +1231,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 +1245,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 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 +1268,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 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 +1292,13 @@ export class NumericStatistics extends Statistics {
     }
 }
 ;
-export class BigIntStatistics extends Statistics {
-    BigIntStatistics = BigIntStatisticsSymbol;
+export class SynchronousNumericStatistics extends SynchronousStatistics {
+    SynchronousNumericStatistics = SynchronousNumericStatisticsSymbol;
     constructor(parameter, comparator) {
         super(parameter, comparator || useCompare);
         Object.defineProperties(this, {
-            "BigIntStatistics": {
-                value: BigIntStatisticsSymbol,
+            "SynchronousNumericStatistics": {
+                value: SynchronousNumericStatisticsSymbol,
                 enumerable: false,
                 writable: false,
                 configurable: false
@@ -1366,13 +1325,15 @@ export class BigIntStatistics extends Statistics {
             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,10 +1341,13 @@ export class BigIntStatistics extends Statistics {
     }
     range(argument1) {
         if (this.isEmpty()) {
-            return 0n;
+            return 0;
         }
         try {
-            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            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;
@@ -1395,11 +1359,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 +1371,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 +1380,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 +1392,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 +1404,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 +1416,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,13 +1428,13 @@ 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) {
@@ -1486,10 +1449,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 +1463,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 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 +1486,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 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 +1509,13 @@ export class BigIntStatistics extends Statistics {
     }
 }
 ;
-export class WindowCollectable extends OrderedCollectable {
-    WindowCollectable = WindowCollectableSymbol;
+export class SynchronousWindowCollectable extends SynchronousOrderedCollectable {
+    WindowCollectable = SynchronousWindowCollectableSymbol;
     constructor(parameter, comparator = useCompare) {
         super(parameter, comparator);
         Object.defineProperties(this, {
-            "WindowCollectable": {
-                value: WindowCollectableSymbol,
+            "SynchronousWindowCollectable": {
+                value: SynchronousWindowCollectableSymbol,
                 writable: false,
                 enumerable: false,
                 configurable: false
@@ -1582,12 +1544,12 @@ export class WindowCollectable extends OrderedCollectable {
     }
     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)) {