semantic-typescript 0.6.0 → 0.7.0

package/dist/asynchronous/collector.d.ts

@@ -13,6 +13,10 @@ export declare class AsynchronousCollector<E, A, R> {
     collect(iterable: AsyncIterable<E>): Promise<R>;
     collect(start: number, end: number): Promise<R>;
     collect(start: bigint, end: bigint): Promise<R>;
+    getIdentity(): Supplier<A>;
+    getInterrupt(): Predicate<E> | BiPredicate<E, bigint> | TriPredicate<E, bigint, A>;
+    getAccumulator(): BiFunctional<A, E, A> | TriFunctional<A, E, bigint, A>;
+    getFinisher(): Functional<A, R>;
     static full<E, A, R>(identity: Supplier<A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): AsynchronousCollector<E, A, R>;
     static full<E, A, R>(identity: Supplier<A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): AsynchronousCollector<E, A, R>;
     static shortable<E, A, R>(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): AsynchronousCollector<E, A, R>;
@@ -22,17 +26,17 @@ export declare class AsynchronousCollector<E, A, R> {
     static shortable<E, A, R>(identity: Supplier<A>, interrupt: TriPredicate<E, bigint, A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): AsynchronousCollector<E, A, R>;
     static shortable<E, A, R>(identity: Supplier<A>, interrupt: TriPredicate<E, bigint, A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): AsynchronousCollector<E, A, R>;
 }
-interface UseSynchronousAnyMatch {
+interface UseAsynchronousAnyMatch {
     <E>(predicate: Predicate<E>): AsynchronousCollector<E, boolean, boolean>;
     <E>(predicate: BiPredicate<E, bigint>): AsynchronousCollector<E, boolean, boolean>;
 }
-export declare let useAsynchronousAnyMatch: UseSynchronousAnyMatch;
-interface UseSynchronousAllMatch {
+export declare let useAsynchronousAnyMatch: UseAsynchronousAnyMatch;
+interface UseAsynchronousAllMatch {
     <E>(predicate: Predicate<E>): AsynchronousCollector<E, boolean, boolean>;
     <E>(predicate: BiPredicate<E, bigint>): AsynchronousCollector<E, boolean, boolean>;
 }
-export declare let useAsynchronousAllMatch: UseSynchronousAllMatch;
-interface UseSynchronousCollect {
+export declare let useAsynchronousAllMatch: UseAsynchronousAllMatch;
+interface UseAsynchronousCollect {
     <E, A, R>(identity: Supplier<A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): AsynchronousCollector<E, A, R>;
     <E, A, R>(identity: Supplier<A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): AsynchronousCollector<E, A, R>;
     <E, A, R>(identity: Supplier<A>, accumulator: BiFunctional<A, E, A> | TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): AsynchronousCollector<E, A, R>;
@@ -43,78 +47,78 @@ interface UseSynchronousCollect {
     <E, A, R>(identity: Supplier<A>, interrupt: TriPredicate<E, bigint, A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): AsynchronousCollector<E, A, R>;
     <E, A, R>(identity: Supplier<A>, interrupt: TriPredicate<E, bigint, A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): AsynchronousCollector<E, A, R>;
 }
-export declare let useAsynchronousCollect: UseSynchronousCollect;
+export declare let useAsynchronousCollect: UseAsynchronousCollect;
 export declare let useAsynchronousCount: <E = unknown>() => AsynchronousCollector<E, bigint, bigint>;
-interface UseSynchronousError {
+interface UseAsynchronousError {
     <E = unknown>(): AsynchronousCollector<E, string, string>;
     <E = unknown>(accumulator: BiFunctional<string, E, string>): AsynchronousCollector<E, string, string>;
     <E = unknown>(accumulator: TriFunctional<string, E, bigint, string>): AsynchronousCollector<E, string, string>;
     <E = unknown>(prefix: string, accumulator: BiFunctional<string, E, string>, suffix: string): AsynchronousCollector<E, string, string>;
     <E = unknown>(prefix: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): AsynchronousCollector<E, string, string>;
 }
-export declare let useAsynchronousError: UseSynchronousError;
-interface UseSynchronousFindAt {
+export declare let useAsynchronousError: UseAsynchronousError;
+interface UseAsynchronousFindAt {
     <E>(index: number): AsynchronousCollector<E, Array<E>, Promise<E>>;
     <E>(index: bigint): AsynchronousCollector<E, Array<E>, Promise<E>>;
 }
-export declare let useAsynchronousFindAt: UseSynchronousFindAt;
+export declare let useAsynchronousFindAt: UseAsynchronousFindAt;
 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>>;
-interface UseSynchronousFindMaximum {
+interface UseAsynchronousFindMaximum {
     <E>(): AsynchronousCollector<E, Promise<E>, Promise<E>>;
     <E>(comparator: Comparator<E>): AsynchronousCollector<E, Promise<E>, Promise<E>>;
 }
-export declare let useAsynchronousFindMaximum: UseSynchronousFindMaximum;
-interface UseSynchronousFindMinimum {
+export declare let useAsynchronousFindMaximum: UseAsynchronousFindMaximum;
+interface UseAsynchronousFindMinimum {
     <E>(): AsynchronousCollector<E, Promise<E>, Promise<E>>;
     <E>(comparator: Comparator<E>): AsynchronousCollector<E, Promise<E>, Promise<E>>;
 }
-export declare let useAsynchronousFindMinimum: UseSynchronousFindMinimum;
-interface UseSynchronousForEach {
+export declare let useAsynchronousFindMinimum: UseAsynchronousFindMinimum;
+interface UseAsynchronousForEach {
     <E>(action: Consumer<E>): AsynchronousCollector<E, bigint, bigint>;
     <E>(action: BiConsumer<E, bigint>): AsynchronousCollector<E, bigint, bigint>;
 }
-export declare let useAsynchronousForEach: UseSynchronousForEach;
-interface UseSynchronousNonMatch {
+export declare let useAsynchronousForEach: UseAsynchronousForEach;
+interface UseAsynchronousNonMatch {
     <E>(predicate: Predicate<E>): AsynchronousCollector<E, boolean, boolean>;
     <E>(predicate: BiPredicate<E, bigint>): AsynchronousCollector<E, boolean, boolean>;
 }
-export declare let useAsynchronousNoneMatch: UseSynchronousNonMatch;
-interface UseSynchronousGroup {
+export declare let useAsynchronousNoneMatch: UseAsynchronousNonMatch;
+interface UseAsynchronousGroup {
     <E, K>(classifier: Functional<E, K>): AsynchronousCollector<E, Map<K, E[]>, Map<K, E[]>>;
     <E, K>(classifier: BiFunctional<E, bigint, K>): AsynchronousCollector<E, Map<K, E[]>, Map<K, E[]>>;
 }
-export declare let useAsynchronousGroup: UseSynchronousGroup;
-interface UseSynchronousGroupBy {
+export declare let useAsynchronousGroup: UseAsynchronousGroup;
+interface UseAsynchronousGroupBy {
     <E, K>(keyExtractor: Functional<E, K>): AsynchronousCollector<E, Map<K, E[]>, Map<K, E[]>>;
     <E, K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): AsynchronousCollector<E, Map<K, V[]>, Map<K, V[]>>;
     <E, K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, V>): AsynchronousCollector<E, Map<K, V[]>, Map<K, V[]>>;
 }
-export declare let useAsynchronousGroupBy: UseSynchronousGroupBy;
-interface UseSynchronousJoin {
+export declare let useAsynchronousGroupBy: UseAsynchronousGroupBy;
+interface UseAsynchronousJoin {
     <E = unknown>(): AsynchronousCollector<E, string, string>;
     <E = unknown>(delimiter: string): AsynchronousCollector<E, string, string>;
     <E = unknown>(prefix: string, delimiter: string, suffix: string): AsynchronousCollector<E, string, string>;
     <E = unknown>(prefiex: string, accumulator: BiFunctional<string, E, string>, suffix: string): AsynchronousCollector<E, string, string>;
     <E = unknown>(prefiex: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): AsynchronousCollector<E, string, string>;
 }
-export declare let useAsynchronousJoin: UseSynchronousJoin;
-interface UseSynchronousLog {
+export declare let useAsynchronousJoin: UseAsynchronousJoin;
+interface UseAsynchronousLog {
     <E = unknown>(): AsynchronousCollector<E, string, string>;
     <E = unknown>(accumulator: BiFunctional<string, E, string>): AsynchronousCollector<E, string, string>;
     <E = unknown>(accumulator: TriFunctional<string, E, bigint, string>): AsynchronousCollector<E, string, string>;
     <E = unknown>(prefix: string, accumulator: BiFunctional<string, E, string>, suffix: string): AsynchronousCollector<E, string, string>;
     <E = unknown>(prefix: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): AsynchronousCollector<E, string, string>;
 }
-export declare let useAsynchronousLog: UseSynchronousLog;
+export declare let useAsynchronousLog: UseAsynchronousLog;
 export declare let useAsynchronousPartition: <E>(count: bigint) => AsynchronousCollector<E, Array<Array<E>>, Array<Array<E>>>;
-interface UseSynchronousPartitionBy {
+interface UseAsynchronousPartitionBy {
     <E>(classifier: Functional<E, bigint>): AsynchronousCollector<E, Array<E[]>, Array<E[]>>;
     <E>(classifier: BiFunctional<E, bigint, bigint>): AsynchronousCollector<E, Array<E[]>, Array<E[]>>;
 }
-export declare let useAsynchronousPartitionBy: UseSynchronousPartitionBy;
-interface UseSynchronousReduce {
+export declare let useAsynchronousPartitionBy: UseAsynchronousPartitionBy;
+interface UseAsynchronousReduce {
     <E>(accumulator: BiFunctional<E, E, E>): AsynchronousCollector<E, Promise<E>, Promise<E>>;
     <E>(accumulator: TriFunctional<E, E, bigint, E>): AsynchronousCollector<E, Promise<E>, Promise<E>>;
     <E>(identity: E, accumulator: BiFunctional<E, E, E>): AsynchronousCollector<E, E, E>;
@@ -122,32 +126,32 @@ interface UseSynchronousReduce {
     <E, R>(identity: R, accumulator: BiFunctional<R, E, R>, finisher: Functional<R, R>): AsynchronousCollector<E, R, R>;
     <E, R>(identity: R, accumulator: TriFunctional<R, E, bigint, R>, finisher: Functional<R, R>): AsynchronousCollector<E, R, R>;
 }
-export declare let useAsynchronousReduce: UseSynchronousReduce;
+export declare let useAsynchronousReduce: UseAsynchronousReduce;
 export declare let useAsynchronousToArray: <E>() => AsynchronousCollector<E, E[], E[]>;
-interface UseSynchronousToMap {
+interface UseAsynchronousToMap {
     <E, K>(keyExtractor: Functional<E, K>): AsynchronousCollector<E, Map<K, E>, Map<K, E>>;
     <E, K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): AsynchronousCollector<E, Map<K, V>, Map<K, V>>;
     <E, K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, V>): AsynchronousCollector<E, Map<K, V>, Map<K, V>>;
 }
-export declare let useAsynchronousToMap: UseSynchronousToMap;
+export declare let useAsynchronousToMap: UseAsynchronousToMap;
 export declare let useAsynchronousToSet: <E>() => AsynchronousCollector<E, Set<E>, Set<E>>;
-interface UseSynchronousWrite {
+interface UseAsynchronousWrite {
     <E, S = string>(stream: WritableStream<S>): AsynchronousCollector<E, Promise<WritableStream<S>>, Promise<WritableStream<S>>>;
     <E, S = string>(stream: WritableStream<S>, accumulator: BiFunctional<WritableStream<S>, E, WritableStream<S>>): AsynchronousCollector<E, Promise<WritableStream<S>>, Promise<WritableStream<S>>>;
     <E, S = string>(stream: WritableStream<S>, accumulator: TriFunctional<WritableStream<S>, E, bigint, WritableStream<S>>): AsynchronousCollector<E, Promise<WritableStream<S>>, Promise<WritableStream<S>>>;
 }
-export declare let useAsynchronousWrite: UseSynchronousWrite;
-interface UseSynchronousNumericSummate {
+export declare let useAsynchronousWrite: UseAsynchronousWrite;
+interface UseAsynchronousNumericSummate {
     <E>(): AsynchronousCollector<E, number, number>;
     <E>(mapper: Functional<E, number>): AsynchronousCollector<number, number, number>;
 }
-export declare let useAsynchronousNumericSummate: UseSynchronousNumericSummate;
-interface UseSynchronousBigIntSummate {
+export declare let useAsynchronousNumericSummate: UseAsynchronousNumericSummate;
+interface UseAsynchronousBigIntSummate {
     <E>(): AsynchronousCollector<E, bigint, bigint>;
     <E>(mapper: Functional<E, bigint>): AsynchronousCollector<bigint, bigint, bigint>;
 }
-export declare let useAsynchronousBigIntSummate: UseSynchronousBigIntSummate;
-interface UseSynchronousNumericAverage {
+export declare let useAsynchronousBigIntSummate: UseAsynchronousBigIntSummate;
+interface UseAsynchronousNumericAverage {
     <E>(): AsynchronousCollector<E, NumericAverageAccumulator, number>;
     <E>(mapper: Functional<E, number>): AsynchronousCollector<number, NumericAverageAccumulator, number>;
 }
@@ -155,8 +159,8 @@ interface NumericAverageAccumulator {
     summate: number;
     count: number;
 }
-export declare let useAsynchronousNumericAverage: UseSynchronousNumericAverage;
-interface UseSynchronousBigIntAverage {
+export declare let useAsynchronousNumericAverage: UseAsynchronousNumericAverage;
+interface UseAsynchronousBigIntAverage {
     <E>(): AsynchronousCollector<E, BigIntAverageAccumulator, bigint>;
     <E>(mapper: Functional<E, bigint>): AsynchronousCollector<E, BigIntAverageAccumulator, bigint>;
 }
@@ -164,19 +168,19 @@ interface BigIntAverageAccumulator {
     summate: bigint;
     count: bigint;
 }
-export declare let useAsynchronousBigIntAverage: UseSynchronousBigIntAverage;
+export declare let useAsynchronousBigIntAverage: UseAsynchronousBigIntAverage;
 export declare let useAsynchronousFrequency: <E>() => AsynchronousCollector<E, Map<E, bigint>, Map<E, bigint>>;
-interface UseSynchronousNumericMode {
+interface UseAsynchronousNumericMode {
     <E>(): AsynchronousCollector<E, Map<number, bigint>, number>;
     <E>(mapper: Functional<E, number>): AsynchronousCollector<E, Map<number, bigint>, number>;
 }
-export declare let useAsynchronousNumericMode: UseSynchronousNumericMode;
-interface UseSynchronousBigIntMode {
+export declare let useAsynchronousNumericMode: UseAsynchronousNumericMode;
+interface UseAsynchronousBigIntMode {
     <E>(): AsynchronousCollector<E, Map<bigint, bigint>, bigint>;
     <E>(mapper: Functional<E, bigint>): AsynchronousCollector<E, Map<bigint, bigint>, bigint>;
 }
-export declare let useAsynchronousBigIntMode: UseSynchronousBigIntMode;
-interface UseSynchronousNumericVariance {
+export declare let useAsynchronousBigIntMode: UseAsynchronousBigIntMode;
+interface UseAsynchronousNumericVariance {
     <E>(): AsynchronousCollector<E, VarianceAccumulator, number>;
     <E>(mapper: Functional<E, number>): AsynchronousCollector<E, VarianceAccumulator, number>;
 }
@@ -185,8 +189,8 @@ interface VarianceAccumulator {
     summateOfSquares: number;
     count: number;
 }
-export declare let useAsynchronousNumericVariance: UseSynchronousNumericVariance;
-interface UseSynchronousBigIntVariance {
+export declare let useAsynchronousNumericVariance: UseAsynchronousNumericVariance;
+interface UseAsynchronousBigIntVariance {
     <E>(): AsynchronousCollector<E, BigIntVarianceAccumulator, bigint>;
     <E>(mapper: Functional<E, bigint>): AsynchronousCollector<E, BigIntVarianceAccumulator, bigint>;
 }
@@ -195,8 +199,8 @@ interface BigIntVarianceAccumulator {
     summateOfSquares: bigint;
     count: bigint;
 }
-export declare let useAsynchronousBigIntVariance: UseSynchronousBigIntVariance;
-interface UseSynchronousNumericStandardDeviation {
+export declare let useAsynchronousBigIntVariance: UseAsynchronousBigIntVariance;
+interface UseAsynchronousNumericStandardDeviation {
     <E>(): AsynchronousCollector<E, StandardDeviationAccumulator, number>;
     <E>(mapper: Functional<E, number>): AsynchronousCollector<E, StandardDeviationAccumulator, number>;
 }
@@ -205,8 +209,8 @@ interface StandardDeviationAccumulator {
     summateOfSquares: number;
     count: number;
 }
-export declare let useAsynchronousNumericStandardDeviation: UseSynchronousNumericStandardDeviation;
-interface UseSynchronousBigIntStandardDeviation {
+export declare let useAsynchronousNumericStandardDeviation: UseAsynchronousNumericStandardDeviation;
+interface UseAsynchronousBigIntStandardDeviation {
     <E>(): AsynchronousCollector<E, BigIntStandardDeviationAccumulator, bigint>;
     <E>(mapper: Functional<E, bigint>): AsynchronousCollector<E, BigIntStandardDeviationAccumulator, bigint>;
 }
@@ -215,17 +219,17 @@ interface BigIntStandardDeviationAccumulator {
     summateOfSquares: bigint;
     count: bigint;
 }
-export declare let useAsynchronousBigIntStandardDeviation: UseSynchronousBigIntStandardDeviation;
-interface UseSynchronousNumericMedian {
+export declare let useAsynchronousBigIntStandardDeviation: UseAsynchronousBigIntStandardDeviation;
+interface UseAsynchronousNumericMedian {
     <E>(): AsynchronousCollector<E, number[], number>;
     <E>(mapper: Functional<E, number>): AsynchronousCollector<E, number[], number>;
 }
-export declare let useAsynchronousNumericMedian: UseSynchronousNumericMedian;
-interface UseSynchronousBigIntMedian {
+export declare let useAsynchronousNumericMedian: UseAsynchronousNumericMedian;
+interface UseAsynchronousBigIntMedian {
     <E>(): AsynchronousCollector<E, bigint[], bigint>;
     <E>(mapper: Functional<E, bigint>): AsynchronousCollector<E, bigint[], bigint>;
 }
-export declare let useAsynchronousBigIntMedian: UseSynchronousBigIntMedian;
+export declare let useAsynchronousBigIntMedian: UseAsynchronousBigIntMedian;
 export declare let useAsynchronousToGeneratorFunction: <E>() => AsynchronousCollector<E, Array<E>, globalThis.Generator<E, void, undefined>>;
 export declare let useAsynchronousToAsyncGeneratorFunction: <E>() => AsynchronousCollector<E, Array<E>, globalThis.AsyncGenerator<E, void, undefined>>;
 export {};

package/dist/asynchronous/collector.js

@@ -54,7 +54,6 @@ export class AsynchronousCollector {
     }
     async collect(argument1, argument2) {
         if (isAsyncFunction(argument1) || isFunction(argument1)) {
-            console.log("Function");
             return await new Promise(async (resolve, reject) => {
                 try {
                     let generator = argument1;
@@ -62,10 +61,11 @@ export class AsynchronousCollector {
                     let count = 0n;
                     await generator((element, index) => {
                         accumulator = this.accumulator(accumulator, element, index);
-                        console.log(accumulator);
                         count++;
-                    }, (element, index) => this.interrupt(element, index, accumulator));
-                    resolve(this.finisher(accumulator));
+                    }, (element, index) => this.interrupt(element, index, accumulator))
+                        .then(() => {
+                        resolve(this.finisher(accumulator));
+                    }, reject);
                 }
                 catch (error) {
                     reject(error);
@@ -136,6 +136,18 @@ export class AsynchronousCollector {
         }
         throw new Error("Invalid arguments.");
     }
+    getIdentity() {
+        return this.identity;
+    }
+    getInterrupt() {
+        return this.interrupt;
+    }
+    getAccumulator() {
+        return this.accumulator;
+    }
+    getFinisher() {
+        return this.finisher;
+    }
     static full(identity, accumulator, finisher) {
         return new AsynchronousCollector(identity, () => false, accumulator, finisher);
     }
@@ -394,7 +406,6 @@ export let useAsynchronousLog = (argument1, argument2, argument3) => {
     }
     else {
         return AsynchronousCollector.full(() => "[", (accumulator, element) => {
-            console.log(element);
             if (isString(accumulator) && isString(element)) {
                 return accumulator + element + ",";
             }

package/dist/asynchronous/semantic.d.ts

@@ -39,8 +39,8 @@ export declare class AsynchronousSemantic<E> {
     sub(start: bigint, end: bigint): AsynchronousSemantic<E>;
     takeWhile(predicate: Predicate<E>): AsynchronousSemantic<E>;
     takeWhile(predicate: BiPredicate<E, bigint>): AsynchronousSemantic<E>;
-    toAsynchronousCollectable(): AsynchronousCollectable<E>;
-    toAsynchronousCollectable<C extends AsynchronousCollectable<E>>(mapper: Functional<AsynchronousGenerator<E>, C>): C;
+    toCollectable(): AsynchronousCollectable<E>;
+    toCollectable<C extends AsynchronousCollectable<E>>(mapper: Functional<AsynchronousGenerator<E>, C>): C;
     toBigintStatistics(): AsynchronousBigIntStatistics<E>;
     toNumericStatistics(): AsynchronousNumericStatistics<E>;
     toOrdered(): AsynchronousOrderedCollectable<E>;

package/dist/asynchronous/semantic.js

@@ -438,7 +438,7 @@ export class AsynchronousSemantic {
             });
         });
     }
-    toAsynchronousCollectable(mapper) {
+    toCollectable(mapper) {
         if (isFunction(mapper)) {
             try {
                 let AsynchronousCollectable = mapper(this.generator);
@@ -483,7 +483,7 @@ export class AsynchronousSemantic {
     }
     toUnordered() {
         try {
-            return new AsynchronousUnorderedCollectable(this.generator);
+            return new AsynchronousUnorderedCollectable(this.source());
         }
         catch (error) {
             throw new Error(String(error));
@@ -960,10 +960,10 @@ export class AsynchronousOrderedCollectable extends AsynchronousCollectable {
                 else {
                     let collector = useAsynchronousToArray();
                     collector.collect(argument1).then((elements) => {
-                        this.buffer = elements.sort(useCompare).map((element, index) => {
+                        this.buffer = elements.sort(useCompare).map((element, index, array) => {
                             return {
                                 element: element,
-                                index: BigInt(index)
+                                index: BigInt(((index % array.length) + array.length) % array.length)
                             };
                         });
                         for (let listener of this.listeners) {
@@ -1335,8 +1335,8 @@ export class AsynchronousUnorderedCollectable extends AsynchronousCollectable {
                                 }
                                 accept(element, index);
                             }
+                            resolve();
                         });
-                        resolve();
                     }
                 }
                 catch (error) {
@@ -1346,7 +1346,17 @@ export class AsynchronousUnorderedCollectable extends AsynchronousCollectable {
         };
     }
     async *[Symbol.asyncIterator]() {
-        for await (let element of await this.toArray()) {
+        let buffer = await new Promise((resolve, reject) => {
+            if (this.complete === true) {
+                resolve(this.buffer);
+            }
+            else {
+                this.listeners.push((buffer) => {
+                    resolve(buffer);
+                }, reject);
+            }
+        });
+        for await (let [_index, element] of buffer) {
             yield element;
         }
     }

package/dist/factory.d.ts

@@ -86,6 +86,14 @@ interface UseRange {
     <N extends number | bigint>(start: N, end: N, step: N): SynchronousSemantic<N extends number ? number : (N extends bigint ? bigint : never)>;
 }
 export declare let useRange: UseRange;
+interface UseText {
+    (text: string): SynchronousSemantic<string>;
+    (text: string, start: number): SynchronousSemantic<string>;
+    (text: string, start: number, end: number): SynchronousSemantic<string>;
+    (text: string, start: bigint): SynchronousSemantic<string>;
+    (text: string, start: bigint, end: bigint): SynchronousSemantic<string>;
+}
+export declare let useText: UseText;
 interface UseWebSocketOptions {
     throttle?: number;
     debounce?: number;