semantic-typescript 0.6.0 → 0.7.0

package/dist/synchronous/semantic.js

@@ -1,12 +1,14 @@
-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 { 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 { SynchronousBigIntStatisticsSymbol, SynchronousCollectableSymbol, SynchronousNumericStatisticsSymbol, SynchronousOrderedCollectableSymbol, SynchronousSemanticSymbol, SynchronousStatisticsSymbol, SynchronousUnorderedCollectableSymbol, SynchronousWindowCollectableSymbol } from "../symbol";
-import { invalidate, validate, } from "../utility";
+import { SynchronousOrderedCollectableSymbol, SynchronousBigIntStatisticsSymbol, SynchronousCollectableSymbol, SynchronousNumericStatisticsSymbol, SynchronousSemanticSymbol, SynchronousWindowCollectableSymbol, SynchronousUnorderedCollectableSymbol, SynchronousStatisticsSymbol } from "../symbol";
+import { invalidate, validate } from "../utility";
+import { SynchronousCollector } from "./collector";
 export class SynchronousSemantic {
     generator;
     SynchronousSemantic = SynchronousSemanticSymbol;
+    [Symbol.toStringTag] = "SynchronousSemantic";
     constructor(generator) {
         if (isFunction(generator)) {
             this.generator = generator;
@@ -31,21 +33,22 @@ export class SynchronousSemantic {
     }
     concat(argument) {
         if (isSynchronousSemantic(argument)) {
-            let other = 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;
                 }
             });
         }
@@ -64,7 +67,7 @@ export class SynchronousSemantic {
                     }
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on concatenation.");
+                    throw error;
                 }
             });
         }
@@ -84,7 +87,7 @@ export class SynchronousSemantic {
                 }, interrupt);
             }
             catch (error) {
-                throw new Error("Uncaught error on distinct.");
+                throw error;
             }
         });
     }
@@ -106,7 +109,7 @@ export class SynchronousSemantic {
                     }, interrupt);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on dropWhile.");
+                    throw error;
                 }
             });
         }
@@ -123,7 +126,7 @@ export class SynchronousSemantic {
                     }, interrupt);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on filter.");
+                    throw error;
                 }
             });
         }
@@ -154,7 +157,7 @@ export class SynchronousSemantic {
                     }, (element) => interrupt(element, count) || stop);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on flat.");
+                    throw error;
                 }
             });
         }
@@ -167,16 +170,16 @@ export class SynchronousSemantic {
                     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 (isSynchronousSemantic(result)) {
-                            result.generator((subElement) => {
+                        else if (isSynchronousSemantic(transform)) {
+                            transform.source()((subElement) => {
                                 accept(subElement, count);
                                 stop = stop || interrupt(subElement, count);
                                 count++;
@@ -185,44 +188,44 @@ export class SynchronousSemantic {
                     }, () => 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);
+    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;
+        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;
                 }
             });
         }
@@ -240,7 +243,7 @@ export class SynchronousSemantic {
                     }, () => stop);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on map.");
+                    throw error;
                 }
             });
         }
@@ -256,7 +259,7 @@ export class SynchronousSemantic {
                     }, interrupt);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on peek.");
+                    throw error;
                 }
             });
         }
@@ -271,7 +274,7 @@ export class SynchronousSemantic {
                     }, interrupt);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on redirect.");
+                    throw error;
                 }
             });
         }
@@ -285,22 +288,22 @@ export class SynchronousSemantic {
                 }, interrupt);
             }
             catch (error) {
-                throw new Error("Uncaught error on reverse.");
+                throw error;
             }
         });
     }
     shuffle(mapper) {
         if (isFunction(mapper)) {
-            try {
-                return new SynchronousSemantic((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 SynchronousSemantic((accept, interrupt) => {
             try {
@@ -309,12 +312,13 @@ export class SynchronousSemantic {
                 }, interrupt);
             }
             catch (error) {
-                throw new Error("Uncaught error on shuffle.");
+                throw error;
             }
         });
     }
-    skip(n) {
-        if (isNumber(n)) {
+    skip(argument) {
+        if (isNumber(argument)) {
+            let n = argument;
             return new SynchronousSemantic((accept, interrupt) => {
                 try {
                     let count = 0n;
@@ -329,11 +333,12 @@ export class SynchronousSemantic {
                     }, interrupt);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on skip.");
+                    throw error;
                 }
             });
         }
-        if (isBigInt(n)) {
+        if (isBigInt(argument)) {
+            let n = argument;
             return new SynchronousSemantic((accept, interrupt) => {
                 try {
                     let count = 0n;
@@ -347,7 +352,7 @@ export class SynchronousSemantic {
                     }, interrupt);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on skip.");
+                    throw error;
                 }
             });
         }
@@ -356,73 +361,64 @@ export class SynchronousSemantic {
     source() {
         return this.generator;
     }
-    sorted(comparator) {
-        if (isFunction(comparator)) {
-            try {
-                return new SynchronousOrderedCollectable(this.generator, comparator);
-            }
-            catch (error) {
-                throw new Error("Uncaught error on sorted.");
-            }
-        }
-        try {
-            return new SynchronousOrderedCollectable(this.generator, (a, b) => useCompare(a, b));
-        }
-        catch (error) {
-            throw new Error("Uncaught error on sorted.");
-        }
-    }
     sub(start, end) {
-        return new SynchronousSemantic((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 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;
             }
         });
     }
-    toSynchronousCollectable(mapper) {
+    toCollectable(mapper) {
         if (isFunction(mapper)) {
             try {
-                let synchronousCollectable = mapper(this.generator);
-                if (isSynchronousCollectable(synchronousCollectable)) {
-                    return synchronousCollectable;
+                let SynchronousCollectable = mapper(this.generator);
+                if (isSynchronousCollectable(SynchronousCollectable)) {
+                    return SynchronousCollectable;
                 }
             }
             catch (error) {
-                throw new Error("Uncaught error on toSynchronousCollectable.");
+                throw error;
             }
         }
         try {
             return new SynchronousUnorderedCollectable(this.generator);
         }
         catch (error) {
-            throw new Error("Uncaught error on toSynchronousCollectable.");
+            throw error;
         }
     }
     toBigintStatistics() {
@@ -430,7 +426,7 @@ export class SynchronousSemantic {
             return new SynchronousBigIntStatistics(this.generator);
         }
         catch (error) {
-            throw new Error("Uncaught error on toBigintStatistics.");
+            throw error;
         }
     }
     toNumericStatistics() {
@@ -438,7 +434,7 @@ export class SynchronousSemantic {
             return new SynchronousNumericStatistics(this.generator);
         }
         catch (error) {
-            throw new Error("Uncaught error on toNumericStatistics.");
+            throw error;
         }
     }
     toOrdered() {
@@ -446,7 +442,7 @@ export class SynchronousSemantic {
             return new SynchronousOrderedCollectable(this.generator);
         }
         catch (error) {
-            throw new Error("Uncaught error on toOrdered.");
+            throw error;
         }
     }
     toUnordered() {
@@ -454,7 +450,7 @@ export class SynchronousSemantic {
             return new SynchronousUnorderedCollectable(this.generator);
         }
         catch (error) {
-            throw new Error(String(error));
+            throw error;
         }
     }
     toWindow() {
@@ -462,7 +458,7 @@ export class SynchronousSemantic {
             return new SynchronousWindowCollectable(this.generator);
         }
         catch (error) {
-            throw new Error("Uncaught error on toWindow.");
+            throw error;
         }
     }
     translate(argument1) {
@@ -475,7 +471,7 @@ export class SynchronousSemantic {
                     }, interrupt);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on translate.");
+                    throw error;
                 }
             });
         }
@@ -488,7 +484,7 @@ export class SynchronousSemantic {
                     }, interrupt);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on translate.");
+                    throw error;
                 }
             });
         }
@@ -501,7 +497,7 @@ export class SynchronousSemantic {
                     }, interrupt);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on translate.");
+                    throw error;
                 }
             });
         }
@@ -511,6 +507,7 @@ export class SynchronousSemantic {
 ;
 export class SynchronousCollectable {
     SynchronousCollectable = SynchronousCollectableSymbol;
+    [Symbol.toStringTag] = "SynchronousCollectable";
     constructor() {
         Object.defineProperty(this, "SynchronousCollectable", {
             value: SynchronousCollectableSymbol,
@@ -519,42 +516,47 @@ export class SynchronousCollectable {
             configurable: false
         });
     }
+    *[Symbol.iterator]() {
+        for (let element of this.toArray()) {
+            yield element;
+        }
+    }
     anyMatch(predicate) {
         if (isFunction(predicate)) {
             try {
-                return useSynchronousAnyMatch(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 useSynchronousAllMatch(predicate).collect(this);
+        return useSynchronousAllMatch(predicate).collect(this.source());
     }
     collect(argument1, argument2, argument3, argument4) {
         try {
-            if (isAsynchronousCollector(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 useSynchronousCollect(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 useSynchronousCollect(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.");
     }
@@ -567,7 +569,7 @@ export class SynchronousCollectable {
                 useSynchronousError().collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on error.");
+                throw error;
             }
         }
         else if (isFunction(argument1) && invalidate(argument2) && invalidate(argument3)) {
@@ -576,7 +578,7 @@ export class SynchronousCollectable {
                 useSynchronousError(accumulator).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on error.");
+                throw error;
             }
         }
         else if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
@@ -587,7 +589,7 @@ export class SynchronousCollectable {
                 useSynchronousError(prefix, accumulator, suffix).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on error.");
+                throw error;
             }
         }
         else {
@@ -602,7 +604,7 @@ export class SynchronousCollectable {
             return useSynchronousFindAny().collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on findAny.");
+            throw error;
         }
     }
     findAt(index) {
@@ -611,7 +613,7 @@ export class SynchronousCollectable {
                 return useSynchronousFindAt(index).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on findAt.");
+                throw error;
             }
         }
         else if (isNumber(index)) {
@@ -619,7 +621,7 @@ export class SynchronousCollectable {
                 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.");
@@ -629,7 +631,7 @@ export class SynchronousCollectable {
             return useSynchronousFindFirst().collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on findFirst.");
+            throw error;
         }
     }
     findLast() {
@@ -637,7 +639,7 @@ export class SynchronousCollectable {
             return useSynchronousFindLast().collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on findLast.");
+            throw error;
         }
     }
     findMaximum(argument1) {
@@ -646,7 +648,7 @@ export class SynchronousCollectable {
             return useSynchronousFindMaximum(comparator).collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on findMaximum.");
+            throw error;
         }
     }
     findMinimum(argument1) {
@@ -655,16 +657,16 @@ export class SynchronousCollectable {
             return useSynchronousFindMinimum(comparator).collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on findMinimum.");
+            throw error;
         }
     }
     forEach(action) {
         if (isFunction(action)) {
             try {
-                useSynchronousForEach(action).collect(this);
+                useSynchronousForEach(action).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on forEach.");
+                throw error;
             }
         }
         else {
@@ -677,7 +679,7 @@ export class SynchronousCollectable {
                 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.");
@@ -688,7 +690,7 @@ export class SynchronousCollectable {
                 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.");
@@ -699,7 +701,7 @@ export class SynchronousCollectable {
                 return useSynchronousJoin().collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on join.");
+                throw error;
             }
         }
         else if (isString(argument1) && invalidate(argument2) && invalidate(argument3)) {
@@ -708,7 +710,7 @@ export class SynchronousCollectable {
                 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)) {
@@ -719,7 +721,7 @@ export class SynchronousCollectable {
                 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)) {
@@ -730,7 +732,7 @@ export class SynchronousCollectable {
                 return useSynchronousJoin(prefix, delimiter, suffix).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on join.");
+                throw error;
             }
         }
         throw new TypeError("Invalid arguments.");
@@ -742,7 +744,7 @@ export class SynchronousCollectable {
                 useSynchronousLog(accumulator).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on log.");
+                throw error;
             }
         }
         else if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
@@ -753,7 +755,7 @@ export class SynchronousCollectable {
                 useSynchronousLog(prefix, accumulator, suffix).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on log.");
+                throw error;
             }
         }
         else {
@@ -761,7 +763,7 @@ export class SynchronousCollectable {
                 useSynchronousLog().collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on log.");
+                throw error;
             }
         }
     }
@@ -771,7 +773,7 @@ export class SynchronousCollectable {
                 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.");
@@ -782,7 +784,7 @@ export class SynchronousCollectable {
                 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.");
@@ -794,7 +796,7 @@ export class SynchronousCollectable {
                 return collector.collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on partitionBy.");
+                throw error;
             }
         }
         throw new TypeError("Classifier must be a function.");
@@ -806,7 +808,7 @@ export class SynchronousCollectable {
                 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)) {
@@ -816,7 +818,7 @@ export class SynchronousCollectable {
                 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)) {
@@ -827,7 +829,7 @@ export class SynchronousCollectable {
                 return useSynchronousReduce(identity, accumulator, finisher).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on reduce.");
+                throw error;
             }
         }
         else {
@@ -841,7 +843,7 @@ export class SynchronousCollectable {
                 return new SynchronousSemantic(source);
             }
             catch (error) {
-                throw new Error("Uncaught error on semantic.");
+                throw error;
             }
         }
         else {
@@ -853,7 +855,7 @@ export class SynchronousCollectable {
             return useSynchronousToArray().collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on toArray.");
+            throw error;
         }
     }
     toMap(keyExtractor, valueExtractor = (element) => element) {
@@ -861,7 +863,7 @@ export class SynchronousCollectable {
             return useSynchronousToMap(keyExtractor, valueExtractor).collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on toMap.");
+            throw error;
         }
     }
     toSet() {
@@ -869,7 +871,7 @@ export class SynchronousCollectable {
             return useSynchronousToSet().collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on toSet.");
+            throw error;
         }
     }
     write(argument1, argument2) {
@@ -885,7 +887,7 @@ export class SynchronousCollectable {
                 }
             }
             catch (error) {
-                throw new Error("Uncaught error on write.");
+                throw error;
             }
         }
         throw new TypeError("Invalid arguments.");
@@ -893,31 +895,37 @@ export class SynchronousCollectable {
 }
 ;
 export class SynchronousOrderedCollectable extends SynchronousCollectable {
-    SynchronousOrderedCollectable = SynchronousOrderedCollectableSymbol;
-    buffer;
+    OrderedCollectable = SynchronousOrderedCollectableSymbol;
+    buffer = [];
+    [Symbol.toStringTag] = "SynchronousOrderedCollectable";
     constructor(argument1, argument2) {
         super();
         if (isFunction(argument1)) {
             try {
                 if (isFunction(argument2)) {
                     let collector = useSynchronousToArray();
-                    this.buffer = collector.collect(argument1).sort(argument2).map((element, index) => {
+                    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 = useSynchronousToArray();
-                    this.buffer = collector.collect(argument1).map((element, index) => {
+                    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, {
                     "SynchronousOrderedCollectable": {
@@ -943,47 +951,35 @@ export class SynchronousOrderedCollectable extends SynchronousCollectable {
         }
     }
     *[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 SynchronousUnorderedCollectable extends SynchronousCollectable {
     SynchronousUnorderedCollectable = SynchronousUnorderedCollectableSymbol;
+    [Symbol.toStringTag] = "SynchronousUnorderedCollectable";
     buffer = new Map();
     constructor(argument1) {
         super();
@@ -992,6 +988,7 @@ export class SynchronousUnorderedCollectable extends SynchronousCollectable {
             generator((element, index) => {
                 this.buffer.set(index, element);
             }, () => false);
+            Object.freeze(this.buffer);
             Object.defineProperties(this, {
                 "SynchronousUnorderedCollectable": {
                     value: SynchronousUnorderedCollectableSymbol,
@@ -1005,40 +1002,26 @@ export class SynchronousUnorderedCollectable extends SynchronousCollectable {
             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)) {
+            for (let [_index, element] of this.buffer) {
+                if (interrupt(element, _index)) {
                     break;
                 }
-                accept(element, index);
+                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;
+    [Symbol.toStringTag] = "SynchronousStatistics";
     constructor(parameter, comparator) {
         super(parameter, validate(comparator) ? comparator : useCompare);
         Object.defineProperties(this, {
@@ -1051,27 +1034,9 @@ export class SynchronousStatistics extends SynchronousOrderedCollectable {
         });
     }
     *[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;
-            }
+        for (let { element } of this.buffer) {
+            yield element;
         }
-        catch (error) {
-            throw new Error("Uncaught error on AsyncGenerator.");
-        }
-    }
-    count() {
-        return BigInt(this.buffer.length);
     }
     frequency() {
         return useSynchronousFrequency().collect(this.source());
@@ -1080,6 +1045,7 @@ export class SynchronousStatistics extends SynchronousOrderedCollectable {
 ;
 export class SynchronousBigIntStatistics extends SynchronousStatistics {
     BigIntStatistics = SynchronousBigIntStatisticsSymbol;
+    [Symbol.toStringTag] = "SynchronousBigIntStatistics";
     constructor(parameter, comparator) {
         super(parameter, comparator || useCompare);
         Object.defineProperties(this, {
@@ -1092,23 +1058,8 @@ export class SynchronousBigIntStatistics extends SynchronousStatistics {
         });
     }
     *[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;
         }
     }
     average(argument1) {
@@ -1129,10 +1080,14 @@ export class SynchronousBigIntStatistics extends SynchronousStatistics {
         }
         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);
+            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.");
@@ -1212,7 +1167,7 @@ export class SynchronousBigIntStatistics extends SynchronousStatistics {
         if (this.isEmpty()) {
             return 0n;
         }
-        if (typeof quantile !== "number" || quantile < 0 || quantile > 1) {
+        if (!isNumber(quantile) || quantile < 0 || quantile > 1) {
             throw new RangeError("Invalid quantile.");
         }
         try {
@@ -1222,8 +1177,7 @@ export class SynchronousBigIntStatistics extends SynchronousStatistics {
             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.");
@@ -1254,7 +1208,7 @@ export class SynchronousBigIntStatistics extends SynchronousStatistics {
             if (standardDeviation === 0n) {
                 return 0n;
             }
-            let data = this.toArray().map(item => mapper(item));
+            let data = (this.toArray()).map((element) => mapper(element));
             let summate = 0n;
             for (let value of data) {
                 let z = value - mean;
@@ -1277,7 +1231,7 @@ export class SynchronousBigIntStatistics extends SynchronousStatistics {
             if (standardDeviation === 0n) {
                 return 0n;
             }
-            let data = this.toArray().map(item => mapper(item));
+            let data = (this.toArray()).map((element) => mapper(element));
             let summate = 0n;
             let count = data.length;
             for (let value of data) {
@@ -1294,6 +1248,7 @@ export class SynchronousBigIntStatistics extends SynchronousStatistics {
 ;
 export class SynchronousNumericStatistics extends SynchronousStatistics {
     SynchronousNumericStatistics = SynchronousNumericStatisticsSymbol;
+    [Symbol.toStringTag] = "SynchronousNumericStatistics";
     constructor(parameter, comparator) {
         super(parameter, comparator || useCompare);
         Object.defineProperties(this, {
@@ -1306,23 +1261,8 @@ export class SynchronousNumericStatistics extends SynchronousStatistics {
         });
     }
     *[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;
         }
     }
     average(mapper) {
@@ -1348,10 +1288,14 @@ export class SynchronousNumericStatistics extends SynchronousStatistics {
                 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 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.");
@@ -1440,8 +1384,7 @@ export class SynchronousNumericStatistics extends SynchronousStatistics {
             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.");
@@ -1472,7 +1415,7 @@ export class SynchronousNumericStatistics extends SynchronousStatistics {
             if (standardDeviation === 0) {
                 return 0;
             }
-            let data = this.toArray().map(item => mapper(item));
+            let data = (this.toArray()).map((element) => mapper(element));
             let summate = 0;
             for (let value of data) {
                 let z = (value - mean) / standardDeviation;
@@ -1495,7 +1438,7 @@ export class SynchronousNumericStatistics extends SynchronousStatistics {
             if (standardDeviation === 0) {
                 return 0;
             }
-            let data = this.toArray().map(item => mapper(item));
+            let data = (this.toArray()).map((element) => mapper(element));
             let summate = 0;
             for (let value of data) {
                 let z = (value - mean) / standardDeviation;
@@ -1511,6 +1454,7 @@ export class SynchronousNumericStatistics extends SynchronousStatistics {
 ;
 export class SynchronousWindowCollectable extends SynchronousOrderedCollectable {
     WindowCollectable = SynchronousWindowCollectableSymbol;
+    [Symbol.toStringTag] = "SynchronousWindowCollectable";
     constructor(parameter, comparator = useCompare) {
         super(parameter, comparator);
         Object.defineProperties(this, {
@@ -1523,23 +1467,8 @@ export class SynchronousWindowCollectable extends SynchronousOrderedCollectable
         });
     }
     *[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) {