semantic-typescript 0.8.0 → 1.0.0

package/dist/asynchronous/collector.d.ts

@@ -1,3 +1,4 @@
+import { Optional } from "../optional";
 import type { BiFunctional, BiPredicate, Functional, Predicate, Supplier, TriFunctional, TriPredicate, Consumer, BiConsumer, Comparator, AsynchronousGenerator } from "../utility";
 export declare class AsynchronousCollector<E, A, R> {
     protected identity: Supplier<A>;
@@ -58,10 +59,15 @@ interface UseAsynchronousError {
 }
 export declare let useAsynchronousError: UseAsynchronousError;
 interface UseAsynchronousFindAt {
+    <E>(index: number): AsynchronousCollector<E, Optional<E>, Promise<E>>;
+    <E>(index: bigint): AsynchronousCollector<E, Optional<E>, Promise<E>>;
+}
+export declare let useAsynchronousFindAt: UseAsynchronousFindAt;
+interface UseAsynchronousFindNegativeAt {
     <E>(index: number): AsynchronousCollector<E, Array<E>, Promise<E>>;
     <E>(index: bigint): AsynchronousCollector<E, Array<E>, Promise<E>>;
 }
-export declare let useAsynchronousFindAt: UseAsynchronousFindAt;
+export declare let useAsynchronousFindNegativeAt: UseAsynchronousFindNegativeAt;
 export declare let useAsynchronousFindFirst: <E>() => AsynchronousCollector<E, Array<E>, Promise<E>>;
 export declare let useAsynchronousFindAny: <E>() => AsynchronousCollector<E, Array<E>, Promise<E>>;
 export declare let useAsynchronousFindLast: <E>() => AsynchronousCollector<E, Array<E>, Promise<E>>;

package/dist/asynchronous/collector.js

@@ -1,5 +1,6 @@
 import { isFunction, isNumber, isBigInt, isBoolean, isString, isObject, isAsyncIterable, isAsyncFunction } from "../guard";
 import { useCompare, useToBigInt, useToNumber } from "../hook";
+import { Optional } from "../optional";
 import { AsynchronousCollectorSymbol } from "../symbol";
 import { invalidate, validate } from "../utility";
 export class AsynchronousCollector {
@@ -229,25 +230,45 @@ export let useAsynchronousError = (argument1, argument2, argument3) => {
 export let useAsynchronousFindAt = (index) => {
     let target = useToBigInt(index);
     if (target < 0n) {
-        return AsynchronousCollector.full(() => [], (accumulator, element) => {
-            accumulator.push(element);
-            return accumulator;
-        }, (accumulator) => {
-            if (accumulator.length === 0) {
-                return Promise.reject(new Error("No element found."));
-            }
-            let limited = (((BigInt(accumulator.length)) % target) + target) % target;
-            return Promise.resolve(accumulator[Number(limited)]);
+        throw new Error("Use \"useAsynchronousFindNegativeAt\" for negative index.");
+    }
+    return AsynchronousCollector.shortable(Optional.empty, (_element, _index, accumulator) => accumulator.isPresent(), (accumulator, element, index) => {
+        if (target === index) {
+            return Optional.of(element);
+        }
+        return accumulator;
+    }, (a) => {
+        return new Promise((resolve, reject) => {
+            a.ifPresent(resolve, reject);
         });
+    });
+};
+;
+export let useAsynchronousFindNegativeAt = (index) => {
+    let target = useToBigInt(index);
+    if (target > -1n) {
+        throw new Error("Use \"useAsynchronousFindAt\" for none-negative index.");
     }
-    return AsynchronousCollector.shortable(() => [], (_element, _index, accumulator) => BigInt(accumulator.length) - 1n === target, (accumulator, element) => {
+    return AsynchronousCollector.full(() => [], (accumulator, element) => {
         accumulator.push(element);
         return accumulator;
     }, (accumulator) => {
-        if (accumulator.length === 0) {
-            return Promise.reject(new Error("No element found."));
-        }
-        return Promise.resolve(accumulator[Number(target)]);
+        return new Promise((resolve, reject) => {
+            if (accumulator.length > 0) {
+                let count = BigInt(accumulator.length);
+                let limit = (((target) % count) + count) % count;
+                let element = accumulator.at(Number(limit));
+                if (validate(element)) {
+                    resolve(element);
+                }
+                else {
+                    reject("Element could not be found with given index.");
+                }
+            }
+            else {
+                reject("Not element to be found.");
+            }
+        });
     });
 };
 export let useAsynchronousFindFirst = () => {

package/dist/asynchronous/semantic.d.ts

@@ -80,6 +80,8 @@ export declare abstract class AsynchronousCollectable<E> implements AsyncIterabl
     findAny(): Promise<E>;
     findAt(index: number): Promise<E>;
     findAt(index: bigint): Promise<E>;
+    findNegativeAt(index: number): Promise<E>;
+    findNegativeAt(index: bigint): Promise<E>;
     findFirst(): Promise<E>;
     findLast(): Promise<E>;
     findMaximum(): Promise<E>;

package/dist/asynchronous/semantic.js

@@ -1,4 +1,4 @@
-import { useAsynchronousAnyMatch, useAsynchronousAllMatch, useAsynchronousCollect, useAsynchronousCount, useAsynchronousError, useAsynchronousFindAny, useAsynchronousFindAt, useAsynchronousFindFirst, useAsynchronousFindLast, useAsynchronousFindMaximum, useAsynchronousFindMinimum, useAsynchronousForEach, useAsynchronousGroup, useAsynchronousGroupBy, useAsynchronousJoin, useAsynchronousLog, useAsynchronousNoneMatch, useAsynchronousPartition, useAsynchronousPartitionBy, useAsynchronousReduce, useAsynchronousToArray, useAsynchronousToMap, useAsynchronousToSet, useAsynchronousWrite, useAsynchronousFrequency, useAsynchronousBigIntAverage, useAsynchronousBigIntMedian, useAsynchronousBigIntMode, useAsynchronousBigIntSummate, useAsynchronousBigIntVariance, useAsynchronousNumericAverage, useAsynchronousNumericMedian, useAsynchronousNumericMode, useAsynchronousNumericStandardDeviation, useAsynchronousNumericSummate, useAsynchronousNumericVariance } from "./collector";
+import { useAsynchronousAnyMatch, useAsynchronousAllMatch, useAsynchronousCollect, useAsynchronousCount, useAsynchronousError, useAsynchronousFindAny, useAsynchronousFindAt, useAsynchronousFindFirst, useAsynchronousFindLast, useAsynchronousFindMaximum, useAsynchronousFindMinimum, useAsynchronousForEach, useAsynchronousGroup, useAsynchronousGroupBy, useAsynchronousJoin, useAsynchronousLog, useAsynchronousNoneMatch, useAsynchronousPartition, useAsynchronousPartitionBy, useAsynchronousReduce, useAsynchronousToArray, useAsynchronousToMap, useAsynchronousToSet, useAsynchronousWrite, useAsynchronousFrequency, useAsynchronousBigIntAverage, useAsynchronousBigIntMedian, useAsynchronousBigIntMode, useAsynchronousBigIntSummate, useAsynchronousBigIntVariance, useAsynchronousNumericAverage, useAsynchronousNumericMedian, useAsynchronousNumericMode, useAsynchronousNumericStandardDeviation, useAsynchronousNumericSummate, useAsynchronousNumericVariance, useAsynchronousFindNegativeAt } from "./collector";
 import { isFunction, isAsynchronousSemantic, isIterable, isNumber, isBigInt, isObject, isString, isAsynchronousCollectable, isAsyncIterable, isAsynchronousCollector } from "../guard";
 import { useHash } from "../hash";
 import { useCompare, useToBigInt, useToNumber } from "../hook";
@@ -450,14 +450,14 @@ export class AsynchronousSemantic {
                 }
             }
             catch (error) {
-                throw new Error("Uncaught error on toAsynchronousCollectable.");
+                throw error;
             }
         }
         try {
             return new AsynchronousUnorderedCollectable(this.generator);
         }
         catch (error) {
-            throw new Error("Uncaught error on toAsynchronousCollectable.");
+            throw error;
         }
     }
     toBigintStatistics() {
@@ -465,7 +465,7 @@ export class AsynchronousSemantic {
             return new AsynchronousBigIntStatistics(this.generator);
         }
         catch (error) {
-            throw new Error("Uncaught error on toBigintStatistics.");
+            throw error;
         }
     }
     toNumericStatistics() {
@@ -473,7 +473,7 @@ export class AsynchronousSemantic {
             return new AsynchronousNumericStatistics(this.generator);
         }
         catch (error) {
-            throw new Error("Uncaught error on toNumericStatistics.");
+            throw error;
         }
     }
     toOrdered() {
@@ -481,7 +481,7 @@ export class AsynchronousSemantic {
             return new AsynchronousOrderedCollectable(this.generator);
         }
         catch (error) {
-            throw new Error("Uncaught error on toOrdered.");
+            throw error;
         }
     }
     toUnordered() {
@@ -497,7 +497,7 @@ export class AsynchronousSemantic {
             return new AsynchronousWindowCollectable(this.generator);
         }
         catch (error) {
-            throw new Error("Uncaught error on toWindow.");
+            throw error;
         }
     }
     translate(argument1) {
@@ -510,7 +510,7 @@ export class AsynchronousSemantic {
                     }, interrupt);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on translate.");
+                    throw error;
                 }
             });
         }
@@ -523,7 +523,7 @@ export class AsynchronousSemantic {
                     }, interrupt);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on translate.");
+                    throw error;
                 }
             });
         }
@@ -536,7 +536,7 @@ export class AsynchronousSemantic {
                     }, interrupt);
                 }
                 catch (error) {
-                    throw new Error("Uncaught error on translate.");
+                    throw error;
                 }
             });
         }
@@ -566,7 +566,7 @@ export class AsynchronousCollectable {
                 return await useAsynchronousAnyMatch(predicate).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on anyMatch.");
+                throw error;
             }
         }
         throw new TypeError("Predicate must be a function.");
@@ -595,7 +595,7 @@ export class AsynchronousCollectable {
             }
         }
         catch (error) {
-            throw new Error("Uncaught error on collect.");
+            throw error;
         }
         throw new TypeError("Invalid arguments.");
     }
@@ -608,7 +608,7 @@ export class AsynchronousCollectable {
                 await useAsynchronousError().collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on error.");
+                throw error;
             }
         }
         else if (isFunction(argument1) && invalidate(argument2) && invalidate(argument3)) {
@@ -617,7 +617,7 @@ export class AsynchronousCollectable {
                 await useAsynchronousError(accumulator).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on error.");
+                throw error;
             }
         }
         else if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
@@ -628,7 +628,7 @@ export class AsynchronousCollectable {
                 await useAsynchronousError(prefix, accumulator, suffix).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on error.");
+                throw error;
             }
         }
         else {
@@ -643,7 +643,7 @@ export class AsynchronousCollectable {
             return await useAsynchronousFindAny().collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on findAny.");
+            throw error;
         }
     }
     async findAt(index) {
@@ -652,7 +652,7 @@ export class AsynchronousCollectable {
                 return await useAsynchronousFindAt(index).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on findAt.");
+                throw error;
             }
         }
         else if (isNumber(index)) {
@@ -660,17 +660,36 @@ export class AsynchronousCollectable {
                 return await useAsynchronousFindAt(index).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on findAt.");
+                throw error;
             }
         }
         throw new TypeError("Index must be a bigint.");
     }
+    async findNegativeAt(index) {
+        if (isBigInt(index)) {
+            try {
+                return await useAsynchronousFindNegativeAt(index).collect(this.source());
+            }
+            catch (error) {
+                throw error;
+            }
+        }
+        else if (isNumber(index)) {
+            try {
+                return await useAsynchronousFindNegativeAt(index).collect(this.source());
+            }
+            catch (error) {
+                throw error;
+            }
+        }
+        throw new TypeError("Index must be a bigint or a number.");
+    }
     async findFirst() {
         try {
             return await useAsynchronousFindFirst().collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on findFirst.");
+            throw error;
         }
     }
     async findLast() {
@@ -678,7 +697,7 @@ export class AsynchronousCollectable {
             return await useAsynchronousFindLast().collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on findLast.");
+            throw error;
         }
     }
     async findMaximum(argument1) {
@@ -687,7 +706,7 @@ export class AsynchronousCollectable {
             return await useAsynchronousFindMaximum(comparator).collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on findMaximum.");
+            throw error;
         }
     }
     async findMinimum(argument1) {
@@ -696,7 +715,7 @@ export class AsynchronousCollectable {
             return await useAsynchronousFindMinimum(comparator).collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on findMinimum.");
+            throw error;
         }
     }
     async forEach(action) {
@@ -705,7 +724,7 @@ export class AsynchronousCollectable {
                 await useAsynchronousForEach(action).collect(this);
             }
             catch (error) {
-                throw new Error("Uncaught error on forEach.");
+                throw error;
             }
         }
         else {
@@ -718,7 +737,7 @@ export class AsynchronousCollectable {
                 return await useAsynchronousGroup(classifier).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on group.");
+                throw error;
             }
         }
         throw new TypeError("Classifier must be a function.");
@@ -729,7 +748,7 @@ export class AsynchronousCollectable {
                 return await useAsynchronousGroupBy(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.");
@@ -740,7 +759,7 @@ export class AsynchronousCollectable {
                 return await useAsynchronousJoin().collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on join.");
+                throw error;
             }
         }
         else if (isString(argument1) && invalidate(argument2) && invalidate(argument3)) {
@@ -749,7 +768,7 @@ export class AsynchronousCollectable {
                 return await useAsynchronousJoin(delimiter).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on join.");
+                throw error;
             }
         }
         else if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
@@ -760,7 +779,7 @@ export class AsynchronousCollectable {
                 return await useAsynchronousJoin(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)) {
@@ -771,7 +790,7 @@ export class AsynchronousCollectable {
                 return await useAsynchronousJoin(prefix, delimiter, suffix).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on join.");
+                throw error;
             }
         }
         throw new TypeError("Invalid arguments.");
@@ -783,7 +802,7 @@ export class AsynchronousCollectable {
                 await useAsynchronousLog(accumulator).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on log.");
+                throw error;
             }
         }
         else if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
@@ -794,7 +813,7 @@ export class AsynchronousCollectable {
                 await useAsynchronousLog(prefix, accumulator, suffix).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on log.");
+                throw error;
             }
         }
         else {
@@ -802,7 +821,7 @@ export class AsynchronousCollectable {
                 useAsynchronousLog().collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on log.");
+                throw error;
             }
         }
     }
@@ -812,7 +831,7 @@ export class AsynchronousCollectable {
                 return await useAsynchronousNoneMatch(predicate).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on nonMatch.");
+                throw error;
             }
         }
         throw new TypeError("Predicate must be a function.");
@@ -823,7 +842,7 @@ export class AsynchronousCollectable {
                 return await useAsynchronousPartition(count).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on partition.");
+                throw error;
             }
         }
         throw new TypeError("Count must be a BigInt.");
@@ -835,7 +854,7 @@ export class AsynchronousCollectable {
                 return await collector.collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on partitionBy.");
+                throw error;
             }
         }
         throw new TypeError("Classifier must be a function.");
@@ -847,7 +866,7 @@ export class AsynchronousCollectable {
                 return await useAsynchronousReduce(accumulator).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on reduce.");
+                throw error;
             }
         }
         else if (validate(argument1) && isFunction(argument2) && invalidate(argument3)) {
@@ -857,7 +876,7 @@ export class AsynchronousCollectable {
                 return await useAsynchronousReduce(identity, accumulator).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on reduce.");
+                throw error;
             }
         }
         else if (validate(argument1) && isFunction(argument2) && isFunction(argument3)) {
@@ -868,7 +887,7 @@ export class AsynchronousCollectable {
                 return await useAsynchronousReduce(identity, accumulator, finisher).collect(this.source());
             }
             catch (error) {
-                throw new Error("Uncaught error on reduce.");
+                throw error;
             }
         }
         else {
@@ -882,7 +901,7 @@ export class AsynchronousCollectable {
                 return new AsynchronousSemantic(source);
             }
             catch (error) {
-                throw new Error("Uncaught error on semantic.");
+                throw error;
             }
         }
         else {
@@ -894,7 +913,7 @@ export class AsynchronousCollectable {
             return useAsynchronousToArray().collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on toArray.");
+            throw error;
         }
     }
     async toMap(keyExtractor, valueExtractor = (element) => element) {
@@ -902,7 +921,7 @@ export class AsynchronousCollectable {
             return await useAsynchronousToMap(keyExtractor, valueExtractor).collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on toMap.");
+            throw error;
         }
     }
     async toSet() {
@@ -910,7 +929,7 @@ export class AsynchronousCollectable {
             return await useAsynchronousToSet().collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on toSet.");
+            throw error;
         }
     }
     async write(argument1, argument2) {
@@ -926,7 +945,7 @@ export class AsynchronousCollectable {
                 }
             }
             catch (error) {
-                throw new Error("Uncaught error on write.");
+                throw error;
             }
         }
         throw new TypeError("Invalid arguments.");
@@ -993,7 +1012,7 @@ export class AsynchronousOrderedCollectable extends AsynchronousCollectable {
                 });
             }
             catch (error) {
-                throw new Error("Uncaught error on creating buffer.");
+                throw error;
             }
         }
         else {
@@ -1417,7 +1436,7 @@ export class AsynchronousBigIntStatistics extends AsynchronousStatistics {
             return await useAsynchronousBigIntAverage(mapper).collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on average.");
+            throw error;
         }
     }
     async range(argument1) {
@@ -1432,7 +1451,7 @@ export class AsynchronousBigIntStatistics extends AsynchronousStatistics {
             return difference < 0 ? -difference : difference;
         }
         catch (error) {
-            throw new Error("Uncaught error on range.");
+            throw error;
         }
     }
     async variance(argument1) {
@@ -1444,7 +1463,7 @@ export class AsynchronousBigIntStatistics extends AsynchronousStatistics {
             return await useAsynchronousBigIntVariance(mapper).collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on variance.");
+            throw error;
         }
     }
     async standardDeviation(argument1) {
@@ -1454,7 +1473,7 @@ export class AsynchronousBigIntStatistics extends AsynchronousStatistics {
             return BigInt(Math.sqrt(Number(variance)));
         }
         catch (error) {
-            throw new Error("Uncaught error on standardDeviation.");
+            throw error;
         }
     }
     async mean(argument1) {
@@ -1466,7 +1485,7 @@ export class AsynchronousBigIntStatistics extends AsynchronousStatistics {
             return await useAsynchronousBigIntAverage(mapper).collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on mean.");
+            throw error;
         }
     }
     async median(argument1) {
@@ -1478,7 +1497,7 @@ export class AsynchronousBigIntStatistics extends AsynchronousStatistics {
             return useAsynchronousBigIntMedian(mapper).collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on median.");
+            throw error;
         }
     }
     async mode(argument1) {
@@ -1490,7 +1509,7 @@ export class AsynchronousBigIntStatistics extends AsynchronousStatistics {
             return useAsynchronousBigIntMode(mapper).collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on mode.");
+            throw error;
         }
     }
     async summate(argument1) {
@@ -1502,7 +1521,7 @@ export class AsynchronousBigIntStatistics extends AsynchronousStatistics {
             return await useAsynchronousBigIntSummate(mapper).collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on summate.");
+            throw error;
         }
     }
     async quantile(quantile, argument1) {
@@ -1523,7 +1542,7 @@ export class AsynchronousBigIntStatistics extends AsynchronousStatistics {
             return value;
         }
         catch (error) {
-            throw new Error("Uncaught error on quantile.");
+            throw error;
         }
     }
     async interquartileRange(argument1) {
@@ -1537,7 +1556,7 @@ export class AsynchronousBigIntStatistics extends AsynchronousStatistics {
             return upper - lower;
         }
         catch (error) {
-            throw new Error("Uncaught error on interquartileRange.");
+            throw error;
         }
     }
     async skewness(argument1) {
@@ -1560,7 +1579,7 @@ export class AsynchronousBigIntStatistics extends AsynchronousStatistics {
             return summate / BigInt(data.length);
         }
         catch (error) {
-            throw new Error("Uncaught error on skewness.");
+            throw error;
         }
     }
     async kurtosis(argument1) {
@@ -1584,7 +1603,7 @@ export class AsynchronousBigIntStatistics extends AsynchronousStatistics {
             return summate / BigInt(count * count) - 3n;
         }
         catch (error) {
-            throw new Error("Uncaught error on kurtosis.");
+            throw error;
         }
     }
 }
@@ -1619,7 +1638,7 @@ export class AsynchronousNumericStatistics extends AsynchronousStatistics {
             return useAsynchronousNumericAverage().collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on average.");
+            throw error;
         }
     }
     async range(argument1) {
@@ -1636,7 +1655,7 @@ export class AsynchronousNumericStatistics extends AsynchronousStatistics {
             return mapper(maximum) - mapper(minimum);
         }
         catch (error) {
-            throw new Error("Uncaught error on range.");
+            throw error;
         }
     }
     async variance(argument1) {
@@ -1648,7 +1667,7 @@ export class AsynchronousNumericStatistics extends AsynchronousStatistics {
             return await useAsynchronousNumericVariance(mapper).collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on variance.");
+            throw error;
         }
     }
     async standardDeviation(argument1) {
@@ -1657,7 +1676,7 @@ export class AsynchronousNumericStatistics extends AsynchronousStatistics {
             return await useAsynchronousNumericStandardDeviation(mapper).collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on standardDeviation.");
+            throw error;
         }
     }
     async mean(argument1) {
@@ -1669,7 +1688,7 @@ export class AsynchronousNumericStatistics extends AsynchronousStatistics {
             return useAsynchronousNumericAverage(mapper).collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on mean.");
+            throw error;
         }
     }
     async median(argument1) {
@@ -1681,7 +1700,7 @@ export class AsynchronousNumericStatistics extends AsynchronousStatistics {
             return await useAsynchronousNumericMedian(mapper).collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on median.");
+            throw error;
         }
     }
     async mode(argument1) {
@@ -1693,7 +1712,7 @@ export class AsynchronousNumericStatistics extends AsynchronousStatistics {
             return await useAsynchronousNumericMode(mapper).collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on mode.");
+            throw error;
         }
     }
     async summate(argument1) {
@@ -1705,7 +1724,7 @@ export class AsynchronousNumericStatistics extends AsynchronousStatistics {
             return useAsynchronousNumericSummate(mapper).collect(this.source());
         }
         catch (error) {
-            throw new Error("Uncaught error on summate.");
+            throw error;
         }
     }
     async quantile(quantile, argument1) {
@@ -1726,7 +1745,7 @@ export class AsynchronousNumericStatistics extends AsynchronousStatistics {
             return value;
         }
         catch (error) {
-            throw new Error("Uncaught error on quantile.");
+            throw error;
         }
     }
     async interquartileRange(argument1) {
@@ -1740,7 +1759,7 @@ export class AsynchronousNumericStatistics extends AsynchronousStatistics {
             return upper - lower;
         }
         catch (error) {
-            throw new Error("Uncaught error on interquartileRange.");
+            throw error;
         }
     }
     async skewness(argument1) {
@@ -1763,7 +1782,7 @@ export class AsynchronousNumericStatistics extends AsynchronousStatistics {
             return summate / data.length;
         }
         catch (error) {
-            throw new Error("Uncaught error on skewness.");
+            throw error;
         }
     }
     async kurtosis(argument1) {
@@ -1786,7 +1805,7 @@ export class AsynchronousNumericStatistics extends AsynchronousStatistics {
             return summate / (data.length * data.length) - 3;
         }
         catch (error) {
-            throw new Error("Uncaught error on kurtosis.");
+            throw error;
         }
     }
 }
@@ -1844,7 +1863,7 @@ export class AsynchronousWindowCollectable extends AsynchronousOrderedCollectabl
                         resolve();
                     }
                     catch (error) {
-                        throw new Error("Uncaught error on slide.");
+                        throw error;
                     }
                 });
             });
@@ -1857,7 +1876,7 @@ export class AsynchronousWindowCollectable extends AsynchronousOrderedCollectabl
                 return this.slide(size, size);
             }
             catch (error) {
-                throw new Error("Uncaught error on tumble.");
+                throw error;
             }
         }
         throw new RangeError("Invalid arguments.");

package/dist/synchronous/collector.d.ts

@@ -59,10 +59,15 @@ interface UseSynchronousError {
 }
 export declare let useSynchronousError: UseSynchronousError;
 interface UseSynchronousFindAt {
+    <E>(index: number): SynchronousCollector<E, Optional<E>, Optional<E>>;
+    <E>(index: bigint): SynchronousCollector<E, Optional<E>, Optional<E>>;
+}
+export declare let useSynchronousFindAt: UseSynchronousFindAt;
+interface UseSynchronousFindNegativeAt {
     <E>(index: number): SynchronousCollector<E, Array<E>, Optional<E>>;
     <E>(index: bigint): SynchronousCollector<E, Array<E>, Optional<E>>;
 }
-export declare let useSynchronousFindAt: UseSynchronousFindAt;
+export declare let useSynchronousFindNegativeAt: UseSynchronousFindNegativeAt;
 export declare let useSynchronousFindFirst: <E>() => SynchronousCollector<E, Optional<E>, Optional<E>>;
 export declare let useSynchronousFindAny: <E>() => SynchronousCollector<E, Optional<E>, Optional<E>>;
 export declare let useSynchronousFindLast: <E>() => SynchronousCollector<E, Optional<E>, Optional<E>>;

package/dist/synchronous/collector.js

@@ -220,26 +220,30 @@ export let useSynchronousError = (argument1, argument2, argument3) => {
 export let useSynchronousFindAt = (index) => {
     let target = useToBigInt(index);
     if (target < 0n) {
-        return SynchronousCollector.full(() => [], (accumulator, element) => {
-            let accumulated = Array.isArray(accumulator) ? accumulator : [];
-            accumulated.push(element);
-            return accumulated;
-        }, (result) => {
-            if (Array.isArray(result) && result.length > 0) {
-                let index = ((Number(target) % result.length) + result.length) % result.length;
-                return Optional.of(result[index]);
-            }
-            return Optional.empty();
-        });
+        throw new Error("use \"useSynchronousFindNegativeAt\" for negative index.");
     }
-    return SynchronousCollector.shortable(() => [], (_element, _index, accumulator) => BigInt(accumulator.length) - 1n === target, (accumulator, element) => {
-        let accumulated = Array.isArray(accumulator) ? accumulator : [];
-        accumulated.push(element);
-        return accumulated;
-    }, (result) => {
-        let index = ((Number(target) % result.length) + result.length) % result.length;
-        if (Array.isArray(result) && result.length > 0) {
-            return Optional.of(result[index]);
+    return SynchronousCollector.shortable(Optional.empty, (_element, _index, accumulator) => accumulator.isPresent(), (accumulator, element, index) => {
+        if (index === target) {
+            return Optional.of(element);
+        }
+        return accumulator;
+    }, (accumulator) => accumulator);
+};
+;
+export let useSynchronousFindNegativeAt = (index) => {
+    let target = useToBigInt(index);
+    if (target > -1n) {
+        throw new Error("use \"useSynchronousFindAt\" for none-negative index.");
+    }
+    return SynchronousCollector.full(() => [], (accumulator, element) => {
+        accumulator.push(element);
+        return accumulator;
+    }, (accumulator) => {
+        if (accumulator.length > 0) {
+            let count = BigInt(accumulator.length);
+            let limit = ((target % count) + count) % count;
+            let element = accumulator.at(Number(limit));
+            return Optional.of(element);
         }
         return Optional.empty();
     });

package/dist/synchronous/semantic.d.ts

@@ -81,6 +81,8 @@ export declare abstract class SynchronousCollectable<E> implements Iterable<E> {
     findAny(): Optional<E>;
     findAt(index: number): Optional<E>;
     findAt(index: bigint): Optional<E>;
+    findNegativeAt(index: number): Optional<E>;
+    findNegativeAt(index: bigint): Optional<E>;
     findFirst(): Optional<E>;
     findLast(): Optional<E>;
     findMaximum(): Optional<E>;

package/dist/synchronous/semantic.js

@@ -1,4 +1,4 @@
-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 { 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, useSynchronousFindNegativeAt } from "./collector";
 import { isFunction, isSynchronousSemantic, isIterable, isNumber, isBigInt, isObject, isString, isSynchronousCollectable, isSynchronousCollector } from "../guard";
 import { useHash } from "../hash";
 import { useCompare, useToBigInt, useToNumber } from "../hook";
@@ -99,7 +99,6 @@ export class SynchronousSemantic {
                     this.generator((element, index) => {
                         if (count === -1n) {
                             if (!predicate(element, index)) {
-                                accept(element, count);
                                 count++;
                             }
                         }
@@ -270,14 +269,9 @@ export class SynchronousSemantic {
         if (isFunction(redirector)) {
             return new SynchronousSemantic((accept, interrupt) => {
                 try {
-                    let stop = false;
                     this.generator((element, index) => {
-                        let redirected = redirector(element, index);
-                        stop = stop || interrupt(element, redirected);
-                        accept(element, redirected);
-                    }, () => {
-                        return stop;
-                    });
+                        accept(element, redirector(element, index));
+                    }, interrupt);
                 }
                 catch (error) {
                     throw error;
@@ -289,14 +283,9 @@ export class SynchronousSemantic {
     reverse() {
         return new SynchronousSemantic((accept, interrupt) => {
             try {
-                let stop = false;
                 this.generator((element, index) => {
-                    let redirected = -index;
-                    stop = stop || interrupt(element, redirected);
-                    accept(element, redirected);
-                }, () => {
-                    return stop;
-                });
+                    accept(element, -index);
+                }, interrupt);
             }
             catch (error) {
                 throw error;
@@ -307,14 +296,9 @@ export class SynchronousSemantic {
         if (isFunction(mapper)) {
             return new SynchronousSemantic((accept, interrupt) => {
                 try {
-                    let stop = false;
                     this.generator((element, index) => {
-                        let redirected = mapper(element, index);
-                        stop = stop || interrupt(element, redirected);
-                        accept(element, redirected);
-                    }, () => {
-                        return stop;
-                    });
+                        accept(element, mapper(element, index));
+                    }, interrupt);
                 }
                 catch (error) {
                     throw error;
@@ -405,7 +389,7 @@ export class SynchronousSemantic {
             try {
                 let stop = false;
                 this.generator((element, index) => {
-                    if (predicate(element, index) && (!stop)) {
+                    if (predicate(element, index) && !stop) {
                         accept(element, index);
                     }
                     else {
@@ -642,6 +626,25 @@ export class SynchronousCollectable {
         }
         throw new TypeError("Index must be a bigint.");
     }
+    findNegativeAt(index) {
+        if (isBigInt(index)) {
+            try {
+                return useSynchronousFindNegativeAt(index).collect(this.source());
+            }
+            catch (error) {
+                throw error;
+            }
+        }
+        else if (isNumber(index)) {
+            try {
+                return useSynchronousFindNegativeAt(index).collect(this.source());
+            }
+            catch (error) {
+                throw error;
+            }
+        }
+        throw new TypeError("Index must be a bigint.");
+    }
     findFirst() {
         try {
             return useSynchronousFindFirst().collect(this.source());

package/package.json

@@ -6,7 +6,7 @@
     "url": "https://github.com/eloyhere"
   },
   "description": "A modern type-safe stream processing library inspired by JavaScript Generator, Java Stream, and MySQL Index. Supports lazy evaluation, async streams, statistics, and IO-like operations.",
-  "version": "0.8.0",
+  "version": "1.0.0",
   "type": "module",
   "readme": "readme.md",
   "main": "dist/index.js",
@@ -55,4 +55,4 @@
     "build": "tsc",
     "prepublishOnly": "npm run build"
   }
-}
+}