semantic-typescript 0.6.0 → 0.7.1

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

@@ -24,10 +24,14 @@ export declare class AsynchronousSemantic<E> {
     flatMap<R>(mapper: BiFunctional<E, bigint, AsynchronousSemantic<R>>): AsynchronousSemantic<R>;
     limit(count: number): AsynchronousSemantic<E>;
     limit(count: bigint): AsynchronousSemantic<E>;
+    map(mapper: Functional<E, E>): AsynchronousSemantic<E>;
+    map(mapper: BiFunctional<E, bigint, E>): AsynchronousSemantic<E>;
     map<R>(mapper: Functional<E, R>): AsynchronousSemantic<R>;
     map<R>(mapper: BiFunctional<E, bigint, R>): AsynchronousSemantic<R>;
     peek(consumer: Consumer<E>): AsynchronousSemantic<E>;
     peek(consumer: BiConsumer<E, bigint>): AsynchronousSemantic<E>;
+    pipe(conversion: Functional<AsynchronousGenerator<E>, AsynchronousSemantic<E>>): AsynchronousSemantic<E>;
+    pipe<R>(conversion: Functional<AsynchronousGenerator<E>, AsynchronousSemantic<R>>): AsynchronousSemantic<R>;
     redirect(redirector: BiFunctional<E, bigint, bigint>): AsynchronousSemantic<E>;
     reverse(): AsynchronousSemantic<E>;
     shuffle(): AsynchronousSemantic<E>;
@@ -39,8 +43,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

@@ -285,6 +285,9 @@ export class AsynchronousSemantic {
         }
         throw new TypeError("Invalid arguments.");
     }
+    pipe(conversion) {
+        return conversion(this.source());
+    }
     redirect(redirector) {
         if (isFunction(redirector)) {
             return new AsynchronousSemantic(async (accept, interrupt) => {
@@ -438,7 +441,7 @@ export class AsynchronousSemantic {
             });
         });
     }
-    toAsynchronousCollectable(mapper) {
+    toCollectable(mapper) {
         if (isFunction(mapper)) {
             try {
                 let AsynchronousCollectable = mapper(this.generator);
@@ -483,7 +486,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 +963,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 +1338,8 @@ export class AsynchronousUnorderedCollectable extends AsynchronousCollectable {
                                 }
                                 accept(element, index);
                             }
+                            resolve();
                         });
-                        resolve();
                     }
                 }
                 catch (error) {
@@ -1346,7 +1349,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

@@ -1,12 +1,6 @@
 import { AsynchronousSemantic } from "./asynchronous/semantic";
-import { Optional } from "./optional";
 import { SynchronousSemantic } from "./synchronous/semantic";
-import type { BiPredicate, Predicate, Supplier, MaybeInvalid, SynchronousGenerator } from "./utility";
-interface UseAnimationFrame {
-    (period: number): SynchronousSemantic<number>;
-    (period: number, delay: number): SynchronousSemantic<number>;
-}
-export declare let useAnimationFrame: UseAnimationFrame;
+import type { BiPredicate, Predicate, Supplier, Consumer } from "./utility";
 interface Attribute<T> {
     key: keyof T;
     value: T[keyof T];
@@ -17,42 +11,6 @@ interface UseBlob {
     (blob: Blob, chunk: bigint): SynchronousSemantic<Uint8Array>;
 }
 export declare let useBlob: UseBlob;
-interface UseDocument {
-    <K extends keyof DocumentEventMap, V extends DocumentEventMap[K]>(key: K): AsynchronousSemantic<V>;
-    <K extends keyof DocumentEventMap, V extends DocumentEventMap[K]>(key: Iterable<K>): AsynchronousSemantic<V>;
-}
-export declare let useDocument: UseDocument;
-interface UseHTMLElementOptions {
-    throttle?: number;
-    debounce?: number;
-}
-interface UseHTMLElement {
-    <E extends HTMLElement, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(element: E, key: K): AsynchronousSemantic<V>;
-    <E extends HTMLElement, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(element: E, key: K, options: UseHTMLElementOptions): AsynchronousSemantic<V>;
-    <E extends HTMLElement, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(element: E, keys: Iterable<K>): AsynchronousSemantic<V>;
-    <E extends HTMLElement, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(element: E, keys: Iterable<K>, options: UseHTMLElementOptions): AsynchronousSemantic<V>;
-    <E extends HTMLElement, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(elements: Iterable<E>, key: K): AsynchronousSemantic<V>;
-    <E extends HTMLElement, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(elements: Iterable<E>, key: K, options: UseHTMLElementOptions): AsynchronousSemantic<V>;
-    <E extends HTMLElement, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(elements: Iterable<E>, keys: Iterable<K>): AsynchronousSemantic<V>;
-    <E extends HTMLElement, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(elements: Iterable<E>, keys: Iterable<K>, options: UseHTMLElementOptions): AsynchronousSemantic<V>;
-    <K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selector: string, key: K): AsynchronousSemantic<V>;
-    <K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selector: string, key: K, options: UseHTMLElementOptions): AsynchronousSemantic<V>;
-    <S extends keyof HTMLElementTagNameMap, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selector: S, key: K): AsynchronousSemantic<V>;
-    <S extends keyof HTMLElementTagNameMap, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selector: S, key: K, options: UseHTMLElementOptions): AsynchronousSemantic<V>;
-    <K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selector: string, keys: Iterable<K>): AsynchronousSemantic<V>;
-    <K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selector: string, keys: Iterable<K>, options: UseHTMLElementOptions): AsynchronousSemantic<V>;
-    <S extends keyof HTMLElementTagNameMap, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selector: S, keys: Iterable<K>): AsynchronousSemantic<V>;
-    <S extends keyof HTMLElementTagNameMap, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selector: S, keys: Iterable<K>, options: UseHTMLElementOptions): AsynchronousSemantic<V>;
-    <K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selectors: Iterable<string>, key: K): AsynchronousSemantic<V>;
-    <K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selectors: Iterable<string>, key: K, options: UseHTMLElementOptions): AsynchronousSemantic<V>;
-    <S extends keyof HTMLElementTagNameMap, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selectors: Iterable<S>, key: K): AsynchronousSemantic<V>;
-    <S extends keyof HTMLElementTagNameMap, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selectors: Iterable<S>, key: K, options: UseHTMLElementOptions): AsynchronousSemantic<V>;
-    <K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selectors: Iterable<string>, keys: Iterable<K>): AsynchronousSemantic<V>;
-    <K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selectors: Iterable<string>, keys: Iterable<K>, options: UseHTMLElementOptions): AsynchronousSemantic<V>;
-    <S extends keyof HTMLElementTagNameMap, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selectors: Iterable<S>, keys: Iterable<K>): AsynchronousSemantic<V>;
-    <S extends keyof HTMLElementTagNameMap, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selectors: Iterable<S>, keys: Iterable<K>, options: UseHTMLElementOptions): AsynchronousSemantic<V>;
-}
-export declare let useHTMLElement: UseHTMLElement;
 export declare let useEmpty: <E>() => SynchronousSemantic<E>;
 interface UseFill {
     <E>(element: E, count: bigint): SynchronousSemantic<E>;
@@ -74,8 +32,28 @@ interface UseInterval {
     (period: number, delay: number): SynchronousSemantic<number>;
 }
 export declare let useInterval: UseInterval;
-export declare let useIterate: <E>(generator: SynchronousGenerator<E>) => SynchronousSemantic<E>;
-export declare let usePromise: (<T>(promise: Promise<T>) => SynchronousSemantic<T>);
+interface UseIterate {
+    <E>(iterable: Iterable<E>): SynchronousSemantic<E>;
+    <E>(iterable: AsyncIterable<E>): AsynchronousSemantic<E>;
+}
+export declare let useIterate: UseIterate;
+interface UsePromise {
+    <T>(promise: Promise<T>): AsynchronousSemantic<T>;
+}
+export declare let usePromise: UsePromise;
+export type KeyOfEventMap<EventMap> = keyof EventMap;
+export type EventOfEventMap<EventMap, K extends KeyOfEventMap<EventMap> = KeyOfEventMap<EventMap>> = EventMap[K];
+export interface Subscriber<T, EventMap> {
+    mount(target: T): void;
+    subscribe<K extends KeyOfEventMap<EventMap>>(key: K, accept: Consumer<EventOfEventMap<EventMap, K>>): void;
+    unsubscribe<K extends KeyOfEventMap<EventMap>>(key: K, accept: Consumer<EventOfEventMap<EventMap, K>>): void;
+    unmount(): void;
+}
+interface UseSubscription {
+    <T, EventMap, K extends KeyOfEventMap<EventMap> = KeyOfEventMap<EventMap>>(target: T, subscriber: Supplier<Subscriber<T, EventMap>>, subscription: K): AsynchronousSemantic<EventOfEventMap<EventMap, K>>;
+    <T, EventMap, K extends KeyOfEventMap<EventMap> = KeyOfEventMap<EventMap>>(target: T, subscriber: Supplier<Subscriber<T, EventMap>>, subscription: Iterable<K>): AsynchronousSemantic<EventOfEventMap<EventMap, K>>;
+}
+export declare let useSubscription: UseSubscription;
 interface UseOf {
     <E>(target: E): SynchronousSemantic<E>;
     <E>(target: Iterable<E>): SynchronousSemantic<E>;
@@ -86,30 +64,13 @@ 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 UseWebSocketOptions {
-    throttle?: number;
-    debounce?: number;
-}
-interface UseWebSocket {
-    (websocket: WebSocket): AsynchronousSemantic<WebSocketEventMap[keyof WebSocketEventMap]>;
-    (websocket: WebSocket, options: UseWebSocketOptions): AsynchronousSemantic<WebSocketEventMap[keyof WebSocketEventMap]>;
-    <K extends keyof WebSocketEventMap, V extends WebSocketEventMap[K]>(websocket: WebSocket, key: K): AsynchronousSemantic<V>;
-    <K extends keyof WebSocketEventMap, V extends WebSocketEventMap[K]>(websocket: WebSocket, key: K, options: UseWebSocketOptions): AsynchronousSemantic<V>;
-    <K extends keyof WebSocketEventMap, V extends WebSocketEventMap[K]>(websocket: WebSocket, keys: Iterable<K>): AsynchronousSemantic<V>;
-    <K extends keyof WebSocketEventMap, V extends WebSocketEventMap[K]>(websocket: WebSocket, keys: Iterable<K>, options: UseWebSocketOptions): AsynchronousSemantic<V>;
-}
-export declare let useWebSocket: UseWebSocket;
-interface UseWindowOptions {
-    throttle?: number;
-    debounce?: number;
-}
-interface UseWindow {
-    <K extends keyof WindowEventMap, V extends WindowEventMap[K]>(key: K): AsynchronousSemantic<V>;
-    <K extends keyof WindowEventMap, V extends WindowEventMap[K]>(key: K, options: UseWindowOptions): AsynchronousSemantic<V>;
-    <K extends keyof WindowEventMap, V extends WindowEventMap[K]>(keys: Iterable<K>): AsynchronousSemantic<V>;
-    <K extends keyof WindowEventMap, V extends WindowEventMap[K]>(keys: Iterable<K>, options: UseWindowOptions): AsynchronousSemantic<V>;
-}
-export declare let useWindow: UseWindow;
-export declare let useNullable: <T>(target: MaybeInvalid<T>) => Optional<T>;
-export declare let useNonNull: <T>(target: T) => Optional<T>;
+interface UseText {
+    (text: string): SynchronousSemantic<string>;
+    (text: string, delimeter: 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;
 export {};