semantic-typescript 0.5.0 → 0.6.0

package/dist/factory.js

@@ -1,12 +1,15 @@
-import { isBigInt, isFunction, isIterable, isNumber, isObject, isPromise, isAsyncIterable, isWindow, isString, isDocument } from "./guard";
-import { useCompare, useTraverse } from "./hook";
-import { Semantic } from "./semantic";
+import { AsynchronousSemantic } from "./asynchronous/semantic";
+import { isBigInt, isFunction, isIterable, isNumber, isObject, isPromise, isAsyncIterable, isString, isHTMLElemet } from "./guard";
+import { useCompare, useToBigInt, useToNumber, useTraverse } from "./hook";
+import { Optional } from "./optional";
+import { SynchronousSemantic } from "./synchronous/semantic";
 import { invalidate, validate } from "./utility";
-export let animationFrame = (period, delay = 0) => {
+;
+export let useAnimationFrame = (period, delay = 0) => {
     if (period <= 0 || !Number.isFinite(period) || delay < 0 || !Number.isFinite(delay)) {
         throw new TypeError("Period must be positive finite number and delay must be non-negative finite number.");
     }
-    return new Semantic((accept, interrupt) => {
+    return new SynchronousSemantic((accept, interrupt) => {
         try {
             let start = performance.now();
             let index = 0n;
@@ -26,14 +29,14 @@ export let animationFrame = (period, delay = 0) => {
             };
         }
         catch (error) {
-            throw new Error("Uncaught error as creating animation frame semantic.");
+            console.error(error);
         }
     });
 };
 ;
-export let attribute = (target) => {
+export let useAttribute = (target) => {
     if (isObject(target)) {
-        return new Semantic((accept, interrupt) => {
+        return new SynchronousSemantic((accept, interrupt) => {
             try {
                 let index = 0n;
                 useTraverse(target, (key, value) => {
@@ -50,13 +53,14 @@ export let attribute = (target) => {
                 });
             }
             catch (error) {
-                throw new Error("Uncaught error as creating attribute semantic.");
+                console.error(error);
             }
         });
     }
     throw new TypeError("Target must be an object.");
 };
-export let blob = (blob, chunk = 64n * 1024n) => {
+;
+export let useBlob = (blob, chunk = 64n * 1024n) => {
     let size = Number(chunk);
     if (size <= 0 || !Number.isSafeInteger(size)) {
         throw new RangeError("Chunk size must be a safe positive integer.");
@@ -64,7 +68,7 @@ export let blob = (blob, chunk = 64n * 1024n) => {
     if (invalidate(blob)) {
         throw new TypeError("Blob is invalid.");
     }
-    return new Semantic((accept, interrupt) => {
+    return new SynchronousSemantic((accept, interrupt) => {
         try {
             let index = 0n;
             let stoppable = false;
@@ -122,174 +126,353 @@ export let blob = (blob, chunk = 64n * 1024n) => {
             })();
         }
         catch (error) {
-            throw new Error("Uncaught error as creating blob semantic.");
+            console.error(error);
         }
     });
 };
-export let empty = () => {
-    return new Semantic(() => { });
-};
 ;
-export let event = (argument1, argument2) => {
-    if (isWindow(argument1)) {
-        let target = argument1;
-        if (isString(argument2)) {
-            let key = argument2;
-            return new Semantic((accept, interrupt) => {
-                try {
-                    let index = 0n;
-                    let listener = (event) => {
-                        if (interrupt(event, index)) {
-                            target.removeEventListener(key, listener);
+;
+export let useDocument = (argument1, argument2 = {}) => {
+    let options = argument2;
+    let debounce = isObject(options) && isNumber(options.debounce) ? options.debounce : 0;
+    let throttle = isObject(options) && isNumber(options.throttle) ? options.throttle : 0;
+    if (isString(argument1)) {
+        let key = argument1;
+        return new AsynchronousSemantic(async (accept, interrupt) => {
+            let timeOut = null;
+            let lastEmitTime = 0;
+            let index = 0n;
+            let until = new Promise(resolve => {
+                let listener = (event) => {
+                    if (debounce > 0) {
+                        if (timeOut) {
+                            clearTimeout(timeOut);
                         }
-                        else {
+                        timeOut = setTimeout(() => {
+                            if (interrupt(event, index)) {
+                                window.document.removeEventListener(key, listener);
+                                resolve();
+                                return;
+                            }
                             accept(event, index);
                             index++;
+                        }, debounce);
+                        return;
+                    }
+                    if (throttle > 0) {
+                        let now = performance.now();
+                        if (now - lastEmitTime < throttle) {
+                            return;
                         }
-                    };
-                    target.addEventListener(key, listener);
-                }
-                catch (error) {
-                    throw new Error("Uncaught error as creating event semantic.");
-                }
-            });
-        }
-        if (isIterable(argument2)) {
-            let keys = argument2;
-            return new Semantic((accept, interrupt) => {
-                try {
-                    let index = 0n;
-                    for (let key of keys) {
-                        if (isString(key)) {
-                            let listener = (event) => {
-                                if (interrupt(event, index)) {
-                                    target.removeEventListener(key, listener);
-                                }
-                                else {
-                                    accept(event, index);
-                                    index++;
-                                }
-                            };
-                            target.addEventListener(key, listener);
+                        lastEmitTime = now;
+                        if (interrupt(event, index)) {
+                            window.document.removeEventListener(key, listener);
+                            resolve();
+                            return;
                         }
+                        accept(event, index);
+                        index++;
+                        return;
                     }
-                }
-                catch (error) {
-                    throw new Error("Uncaught error as creating event semantic.");
+                    if (interrupt(event, index)) {
+                        window.document.removeEventListener(key, listener);
+                        resolve();
+                        accept(event, -1n);
+                        return;
+                    }
+                    accept(event, index);
+                    index++;
+                };
+                window.document.addEventListener(key, listener);
+            });
+            await until;
+        });
+    }
+    if (isIterable(argument1)) {
+        let keys = new Set(...argument1);
+        return new AsynchronousSemantic(async (accept, interrupt) => {
+            let lastEmitTime = 0;
+            let timeOut = null;
+            let index = 0n;
+            let activeCount = keys.size;
+            let until = new Promise(resolve => {
+                for (let key of keys) {
+                    if (!isString(key))
+                        continue;
+                    let listener = (event) => {
+                        if (debounce > 0) {
+                            if (timeOut) {
+                                clearTimeout(timeOut);
+                            }
+                            timeOut = setTimeout(() => handleEvent(event, key), debounce);
+                            return;
+                        }
+                        if (throttle > 0) {
+                            let now = performance.now();
+                            if (now - lastEmitTime < throttle)
+                                return;
+                            lastEmitTime = now;
+                        }
+                        handleEvent(event, key);
+                    };
+                    let handleEvent = (event, currentKey) => {
+                        if (interrupt(event, index)) {
+                            window.document.removeEventListener(currentKey, listener);
+                            if (--activeCount === 0) {
+                                resolve();
+                            }
+                            return;
+                        }
+                        accept(event, index);
+                        index++;
+                    };
+                    window.document.addEventListener(key, listener);
                 }
             });
-        }
+            await until;
+        });
     }
-    if (isDocument(argument1)) {
-        let target = argument1;
+    throw new TypeError("Invalid arguments.");
+};
+;
+export let useHTMLElement = (argument1, argument2, argument3 = {}) => {
+    let throttle = isObject(argument3) && isNumber(argument3.throttle) ? argument3.throttle : 0;
+    let debounce = isObject(argument3) && isNumber(argument3.debounce) ? argument3.debounce : 0;
+    if (debounce > 0 && throttle > 0) {
+        throw new TypeError("throttle and debounce cannot be used together");
+    }
+    if (debounce < 0 || throttle < 0) {
+        throw new TypeError("throttle/debounce must be non-negative");
+    }
+    if (isHTMLElemet(argument1)) {
+        let element = argument1;
         if (isString(argument2)) {
             let key = argument2;
-            return new Semantic((accept, interrupt) => {
-                try {
-                    let index = 0n;
+            return new AsynchronousSemantic(async (accept, interrupt) => {
+                let timeOut = null;
+                let lastEmit = 0;
+                let index = 0n;
+                let until = new Promise((resolve) => {
                     let listener = (event) => {
-                        if (interrupt(event, index)) {
-                            target.removeEventListener(key, listener);
+                        if (debounce > 0) {
+                            if (timeOut)
+                                clearTimeout(timeOut);
+                            timeOut = setTimeout(() => handle(event), debounce);
+                            return;
                         }
-                        else {
-                            accept(event, index);
-                            index++;
+                        if (throttle > 0) {
+                            let now = performance.now();
+                            if (now - lastEmit < throttle)
+                                return;
+                            lastEmit = now;
                         }
+                        handle(event);
                     };
-                    target.addEventListener(key, listener);
-                }
-                catch (error) {
-                    throw new Error("Uncaught error as creating event semantic.");
-                }
+                    let handle = (event) => {
+                        if (interrupt(event, index)) {
+                            element.removeEventListener(key, listener);
+                            if (timeOut)
+                                clearTimeout(timeOut);
+                            resolve();
+                            return;
+                        }
+                        accept(event, index);
+                        index++;
+                    };
+                    element.addEventListener(key, listener);
+                });
+                await until;
             });
         }
         if (isIterable(argument2)) {
-            let keys = argument2;
-            return new Semantic((accept, interrupt) => {
-                try {
-                    let index = 0n;
+            let keys = [...new Set(argument2)];
+            return new AsynchronousSemantic(async (accept, interrupt) => {
+                let active = keys.length;
+                let index = 0n;
+                let until = new Promise((resolve) => {
                     for (let key of keys) {
-                        if (isString(key)) {
+                        let listener = (event) => {
+                            if (interrupt(event, index)) {
+                                element.removeEventListener(key, listener);
+                                if (--active === 0) {
+                                    resolve();
+                                }
+                                return;
+                            }
+                            accept(event, index);
+                            index++;
+                        };
+                        element.addEventListener(key, listener);
+                    }
+                });
+                await until;
+            });
+        }
+    }
+    if (isString(argument1)) {
+        let selector = argument1;
+        let elements = [...document.querySelectorAll(selector)];
+        if (isString(argument2)) {
+            let key = argument2;
+            return new AsynchronousSemantic(async (accept, interrupt) => {
+                let active = elements.length;
+                let index = 0n;
+                let until = new Promise((resolve) => {
+                    for (let element of elements) {
+                        if (validate(element)) {
                             let listener = (event) => {
                                 if (interrupt(event, index)) {
-                                    target.removeEventListener(key, listener);
+                                    element.removeEventListener(key, listener);
+                                    if (--active === 0) {
+                                        resolve();
+                                    }
+                                    return;
                                 }
-                                else {
+                                accept(event, index);
+                                index++;
+                            };
+                            element.addEventListener(key, listener);
+                        }
+                    }
+                });
+                await until;
+            });
+        }
+        if (isIterable(argument2)) {
+            let keys = new Set(argument2);
+            return new AsynchronousSemantic(async (accept, interrupt) => {
+                let active = elements.length * keys.size;
+                let index = 0n;
+                let until = new Promise((resolve) => {
+                    for (let element of elements) {
+                        for (let key of keys) {
+                            if (validate(element) && isString(key)) {
+                                let listener = (event) => {
+                                    if (interrupt(event, index)) {
+                                        element.removeEventListener(key, listener);
+                                        if (--active === 0) {
+                                            resolve();
+                                        }
+                                        return;
+                                    }
                                     accept(event, index);
                                     index++;
-                                }
-                            };
-                            target.addEventListener(key, listener);
+                                };
+                                element.addEventListener(key, listener);
+                            }
                         }
                     }
-                }
-                catch (error) {
-                    throw new Error("Uncaught error as creating event semantic.");
-                }
+                });
+                await until;
             });
         }
     }
     if (isIterable(argument1)) {
-        let targets = argument1;
+        let elementsOrSelectors = new Set(argument1);
         if (isString(argument2)) {
             let key = argument2;
-            return new Semantic((accept, interrupt) => {
-                try {
-                    let index = 0n;
-                    for (let target of targets) {
-                        if (isObject(target) && isFunction(Reflect.get(target, "addEventListener"))) {
-                            let listener = (event) => {
-                                if (interrupt(event, index)) {
-                                    target.removeEventListener(key, listener);
-                                }
-                                else {
-                                    accept(event, index);
+            return new AsynchronousSemantic(async (accept, interrupt) => {
+                let active = elementsOrSelectors.size;
+                let until = new Promise((resolve) => {
+                    for (let elementOrSelector of elementsOrSelectors) {
+                        if (validate(elementOrSelector)) {
+                            if (isHTMLElemet(elementOrSelector)) {
+                                let element = elementOrSelector;
+                                let listener = (event) => {
+                                    if (interrupt(event, 0n)) {
+                                        element.removeEventListener(key, listener);
+                                        if (--active === 0) {
+                                            resolve();
+                                        }
+                                        return;
+                                    }
+                                    accept(event, 0n);
+                                };
+                                element.addEventListener(key, listener);
+                            }
+                            else if (isString(elementOrSelector)) {
+                                let selector = elementOrSelector;
+                                let elements = [...document.querySelectorAll(selector)].filter((item) => isHTMLElemet(item));
+                                for (let element of elements) {
+                                    if (validate(element)) {
+                                        let listener = (event) => {
+                                            if (interrupt(event, 0n)) {
+                                                element.removeEventListener(key, listener);
+                                                if (--active === 0) {
+                                                    resolve();
+                                                }
+                                                return;
+                                            }
+                                            accept(event, 0n);
+                                        };
+                                        element.addEventListener(key, listener);
+                                    }
                                 }
-                            };
-                            target.addEventListener(key, listener);
+                            }
                         }
                     }
-                }
-                catch (error) {
-                    throw new Error("Uncaught error as creating event semantic.");
-                }
+                });
+                await until;
             });
         }
         if (isIterable(argument2)) {
-            let keys = argument2;
-            return new Semantic((accept, interrupt) => {
-                try {
-                    let index = 0n;
-                    for (let target of targets) {
-                        if (isObject(target) && isFunction(Reflect.get(target, "addEventListener"))) {
+            let keys = new Set(argument2);
+            return new AsynchronousSemantic(async (accept, interrupt) => {
+                let active = elementsOrSelectors.size * keys.size;
+                let until = new Promise((resolve) => {
+                    for (let elementOrSelector of elementsOrSelectors) {
+                        if (isHTMLElemet(elementOrSelector)) {
+                            let element = elementOrSelector;
                             for (let key of keys) {
                                 if (isString(key)) {
                                     let listener = (event) => {
-                                        if (interrupt(event, index)) {
-                                            target.removeEventListener(key, listener);
+                                        if (interrupt(event, 0n)) {
+                                            element.removeEventListener(key, listener);
+                                            if (--active === 0) {
+                                                resolve();
+                                            }
+                                            return;
                                         }
-                                        else {
-                                            accept(event, index);
-                                            index++;
+                                        accept(event, 0n);
+                                    };
+                                    element.addEventListener(key, listener);
+                                }
+                            }
+                        }
+                        else if (isString(elementOrSelector)) {
+                            let selector = elementOrSelector;
+                            let elements = [...document.querySelectorAll(selector)].filter((item) => isHTMLElemet(item));
+                            for (let element of elements) {
+                                for (let key of keys) {
+                                    let listener = (event) => {
+                                        if (interrupt(event, 0n)) {
+                                            element.removeEventListener(key, listener);
+                                            if (--active === 0) {
+                                                resolve();
+                                            }
+                                            return;
                                         }
+                                        accept(event, 0n);
                                     };
-                                    target.addEventListener(key, listener);
+                                    element.addEventListener(key, listener);
                                 }
                             }
                         }
                     }
-                }
-                catch (error) {
-                    throw new Error("Uncaught error as creating event semantic.");
-                }
+                });
+                await until;
             });
         }
     }
     throw new TypeError("Invalid arguments.");
 };
-export let fill = (element, count) => {
+export let useEmpty = () => {
+    return new SynchronousSemantic(() => { });
+};
+;
+export let useFill = (element, count) => {
     if (validate(element) && count > 0n) {
-        return new Semantic((accept, interrupt) => {
+        return new SynchronousSemantic((accept, interrupt) => {
             try {
                 for (let i = 0n; i < count; i++) {
                     let item = isFunction(element) ? element() : element;
@@ -300,16 +483,16 @@ export let fill = (element, count) => {
                 }
             }
             catch (error) {
-                throw new Error("Uncaught error as creating fill semantic.");
+                console.error(error);
             }
         });
     }
     throw new TypeError("Invalid arguments.");
 };
 ;
-export let from = (iterable) => {
+export let useFrom = (iterable) => {
     if (isIterable(iterable)) {
-        return new Semantic((accept, interrupt) => {
+        return new SynchronousSemantic((accept, interrupt) => {
             try {
                 let index = 0n;
                 for (let element of iterable) {
@@ -321,12 +504,12 @@ export let from = (iterable) => {
                 }
             }
             catch (error) {
-                throw new Error("Uncaught error as creating from semantic.");
+                console.error(error);
             }
         });
     }
     else if (isAsyncIterable(iterable)) {
-        return new Semantic(async (accept, interrupt) => {
+        return new SynchronousSemantic(async (accept, interrupt) => {
             try {
                 let index = 0n;
                 for await (let element of iterable) {
@@ -338,15 +521,16 @@ export let from = (iterable) => {
                 }
             }
             catch (error) {
-                throw new Error("Uncaught error as creating from semantic.");
+                console.error(error);
             }
         });
     }
     throw new TypeError("Invalid arguments");
 };
-export let generate = (supplier, interrupt) => {
+;
+export let useGenerate = (supplier, interrupt) => {
     if (isFunction(supplier) && isFunction(interrupt)) {
-        return new Semantic((accept, interrupt) => {
+        return new SynchronousSemantic((accept, interrupt) => {
             try {
                 let index = 0n;
                 while (true) {
@@ -359,15 +543,16 @@ export let generate = (supplier, interrupt) => {
                 }
             }
             catch (error) {
-                throw new Error("Uncaught error as creating generate semantic.");
+                console.error(error);
             }
         });
     }
     throw new TypeError("Invalid arguments");
 };
-export let interval = (period, delay = 0) => {
+;
+export let useInterval = (period, delay = 0) => {
     if (period > 0 && delay >= 0) {
-        return new Semantic((accept, interrupt) => {
+        return new SynchronousSemantic((accept, interrupt) => {
             try {
                 if (delay > 0) {
                     setTimeout(() => {
@@ -397,26 +582,26 @@ export let interval = (period, delay = 0) => {
                 }
             }
             catch (error) {
-                throw new Error("Uncaught error as creating interval semantic.");
+                console.error(error);
             }
         });
     }
     throw new TypeError("Invalid arguments.");
 };
-export let iterate = (generator) => {
+export let useIterate = (generator) => {
     if (isFunction(generator)) {
         try {
-            return new Semantic(generator);
+            return new SynchronousSemantic(generator);
         }
         catch (error) {
-            throw new Error("Uncaught error as creating iterate semantic.");
+            console.error(error);
         }
     }
     throw new TypeError("Invalid arguments.");
 };
-export let promise = (promise) => {
+export let usePromise = (promise) => {
     if (isPromise(promise)) {
-        return new Semantic((accept, interrupt) => {
+        return new SynchronousSemantic((accept, interrupt) => {
             try {
                 promise.then((value) => {
                     if (interrupt(value, 0n)) {
@@ -428,7 +613,7 @@ export let promise = (promise) => {
                 });
             }
             catch (error) {
-                throw new Error("Uncaught error as creating promise semantic.");
+                console.error(error);
             }
         });
     }
@@ -436,77 +621,285 @@ export let promise = (promise) => {
         throw new TypeError("Invalid arguments.");
     }
 };
-export let range = (start, end, step = 1) => {
+;
+export let useOf = (...target) => {
+    if (Array.isArray(target)) {
+        return new SynchronousSemantic((accept, interrupt) => {
+            try {
+                let index = 0n;
+                for (let element of target) {
+                    if (interrupt(element, index)) {
+                        break;
+                    }
+                    accept(element, index);
+                    index++;
+                }
+            }
+            catch (error) {
+                console.error(error);
+            }
+        });
+    }
+    throw new TypeError("Invalid arguments.");
+};
+;
+export let useRange = (start, end, step = (isNumber(start) && isNumber(end) ? 1 : 1n)) => {
     if ((!isNumber(step) && !isBigInt(step)) || (isNumber(step) && useCompare(step, 0) === 0) || (isBigInt(step) && useCompare(step, 0n) === 0)) {
         throw new TypeError("Step must be numeric and cannot be zero.");
     }
     if (isNumber(start) && isNumber(end)) {
-        let minimum = start, maximum = end, limit = Number(step);
-        let condition = limit > 0 ? (i) => i < maximum : (i) => i > maximum;
-        return new Semantic((accept, interrupt) => {
+        let trusted = useToNumber(step);
+        return new SynchronousSemantic((accept, interrupt) => {
+            try {
+                let index = 0n;
+                for (let i = start; i < end; i += trusted) {
+                    if (interrupt(i, index)) {
+                        break;
+                    }
+                    accept(i, index);
+                    index++;
+                }
+            }
+            catch (error) {
+                console.error(error);
+            }
+        });
+    }
+    else if (isBigInt(start) && isBigInt(end)) {
+        let trusted = useToBigInt(step);
+        return new SynchronousSemantic((accept, interrupt) => {
             try {
-                for (let i = minimum; condition(i); i += limit) {
-                    let value = i;
-                    if (interrupt(value, BigInt(i))) {
+                let index = 0n;
+                for (let i = start; i < end; i += trusted) {
+                    if (interrupt(i, index)) {
                         break;
                     }
-                    accept(value, BigInt(i));
+                    accept(i, index);
+                    index++;
                 }
             }
             catch (error) {
-                throw new Error("Uncaught error as creating range semantic.");
+                console.error(error);
             }
         });
     }
     throw new TypeError("Invalid arguments.");
 };
-export let websocket = (websocket) => {
-    if (invalidate(websocket)) {
-        throw new TypeError("WebSocket is invalid.");
+;
+;
+export let useWebSocket = (argument1, argument2, argument3) => {
+    let debounce = 0;
+    let throttle = 0;
+    if (isObject(argument2)) {
+        debounce = Reflect.has(argument2, "debounce") ? Reflect.get(argument2, "debounce") : 0;
+        throttle = Reflect.has(argument2, "throttle") ? Reflect.get(argument2, "throttle") : 0;
     }
-    return new Semantic((accept, interrupt) => {
-        try {
-            let index = 0n;
-            let stop = false;
-            websocket.addEventListener("open", (event) => {
-                if (stop || interrupt(event, index)) {
-                    stop = true;
-                }
-                else {
-                    accept(event, index);
-                    index++;
-                }
+    else {
+        debounce = validate(argument3) && isNumber(argument3.debounce) ? argument3.debounce : 0;
+        throttle = validate(argument3) && isNumber(argument3.throttle) ? argument3.throttle : 0;
+    }
+    if (validate(argument1)) {
+        let websocket = argument1;
+        if (isString(argument2)) {
+            let key = argument1;
+            return new AsynchronousSemantic(async (accept, interrupt) => {
+                let timeOut = null;
+                let lastEmitTime = 0;
+                let index = 0n;
+                let until = new Promise(resolve => {
+                    let listener = (event) => {
+                        if (debounce > 0) {
+                            if (timeOut) {
+                                clearTimeout(timeOut);
+                            }
+                            timeOut = setTimeout(() => {
+                                if (interrupt(event, index)) {
+                                    websocket.removeEventListener(key, listener);
+                                    resolve();
+                                    return;
+                                }
+                                accept(event, index);
+                                index++;
+                            }, debounce);
+                            return;
+                        }
+                        if (throttle > 0) {
+                            let now = performance.now();
+                            if (now - lastEmitTime < throttle) {
+                                return;
+                            }
+                            lastEmitTime = now;
+                            if (interrupt(event, index)) {
+                                websocket.removeEventListener(key, listener);
+                                resolve();
+                                return;
+                            }
+                            accept(event, index);
+                            index++;
+                            return;
+                        }
+                        if (interrupt(event, index)) {
+                            websocket.removeEventListener(key, listener);
+                            resolve();
+                            accept(event, -1n);
+                            return;
+                        }
+                        accept(event, index);
+                        index++;
+                    };
+                    websocket.addEventListener(key, listener);
+                });
+                await until;
             });
-            websocket.addEventListener("message", (event) => {
-                if (stop || interrupt(event, index)) {
-                    stop = true;
-                }
-                else {
-                    accept(event, index);
-                    index++;
-                }
+        }
+        if (isIterable(argument2)) {
+            let keys = new Set(...argument1);
+            return new AsynchronousSemantic(async (accept, interrupt) => {
+                let lastEmitTime = 0;
+                let timeOut = null;
+                let index = 0n;
+                let activeCount = keys.size;
+                let until = new Promise(resolve => {
+                    for (let key of keys) {
+                        if (!isString(key))
+                            continue;
+                        let listener = (event) => {
+                            if (debounce > 0) {
+                                if (timeOut) {
+                                    clearTimeout(timeOut);
+                                }
+                                timeOut = setTimeout(() => handleEvent(event, key), debounce);
+                                return;
+                            }
+                            if (throttle > 0) {
+                                let now = performance.now();
+                                if (now - lastEmitTime < throttle)
+                                    return;
+                                lastEmitTime = now;
+                            }
+                            handleEvent(event, key);
+                        };
+                        let handleEvent = (event, currentKey) => {
+                            if (interrupt(event, index)) {
+                                websocket.removeEventListener(currentKey, listener);
+                                if (--activeCount === 0) {
+                                    resolve();
+                                }
+                                return;
+                            }
+                            accept(event, index);
+                            index++;
+                        };
+                        websocket.addEventListener(key, listener);
+                    }
+                });
+                await until;
             });
-            websocket.addEventListener("error", (event) => {
-                if (stop || interrupt(event, index)) {
-                    stop = true;
-                }
-                else {
+        }
+    }
+    throw new TypeError("Invalid arguments.");
+};
+export let useWindow = (argument1, argument2 = {}) => {
+    let options = argument2;
+    let debounce = isObject(options) && isNumber(options.debounce) ? options.debounce : 0;
+    let throttle = isObject(options) && isNumber(options.throttle) ? options.throttle : 0;
+    if (isString(argument1)) {
+        let key = argument1;
+        return new AsynchronousSemantic(async (accept, interrupt) => {
+            let timeOut = null;
+            let lastEmitTime = 0;
+            let index = 0n;
+            let until = new Promise(resolve => {
+                let listener = (event) => {
+                    if (debounce > 0) {
+                        if (timeOut) {
+                            clearTimeout(timeOut);
+                        }
+                        timeOut = setTimeout(() => {
+                            if (interrupt(event, index)) {
+                                window.removeEventListener(key, listener);
+                                resolve();
+                                return;
+                            }
+                            accept(event, index);
+                            index++;
+                        }, debounce);
+                        return;
+                    }
+                    if (throttle > 0) {
+                        let now = performance.now();
+                        if (now - lastEmitTime < throttle) {
+                            return;
+                        }
+                        lastEmitTime = now;
+                        if (interrupt(event, index)) {
+                            window.removeEventListener(key, listener);
+                            resolve();
+                            return;
+                        }
+                        accept(event, index);
+                        index++;
+                        return;
+                    }
+                    if (interrupt(event, index)) {
+                        window.removeEventListener(key, listener);
+                        resolve();
+                        accept(event, -1n);
+                        return;
+                    }
                     accept(event, index);
                     index++;
-                }
+                };
+                window.addEventListener(key, listener);
             });
-            websocket.addEventListener("close", (event) => {
-                if (stop || interrupt(event, index)) {
-                    stop = true;
-                }
-                else {
-                    accept(event, index);
-                    index++;
+            await until;
+        });
+    }
+    if (isIterable(argument1)) {
+        let keys = new Set(...argument1);
+        return new AsynchronousSemantic(async (accept, interrupt) => {
+            let lastEmitTime = 0;
+            let timeOut = null;
+            let index = 0n;
+            let activeCount = keys.size;
+            let until = new Promise(resolve => {
+                for (let key of keys) {
+                    if (!isString(key))
+                        continue;
+                    let listener = (event) => {
+                        if (debounce > 0) {
+                            if (timeOut) {
+                                clearTimeout(timeOut);
+                            }
+                            timeOut = setTimeout(() => handleEvent(event, key), debounce);
+                            return;
+                        }
+                        if (throttle > 0) {
+                            let now = performance.now();
+                            if (now - lastEmitTime < throttle)
+                                return;
+                            lastEmitTime = now;
+                        }
+                        handleEvent(event, key);
+                    };
+                    let handleEvent = (event, currentKey) => {
+                        if (interrupt(event, index)) {
+                            window.removeEventListener(currentKey, listener);
+                            if (--activeCount === 0) {
+                                resolve();
+                            }
+                            return;
+                        }
+                        accept(event, index);
+                        index++;
+                    };
+                    window.addEventListener(key, listener);
                 }
             });
-        }
-        catch (error) {
-            throw new Error("Uncaught error as creating websocket semantic.");
-        }
-    });
+            await until;
+        });
+    }
+    throw new TypeError("Invalid arguments.");
 };
+export let useNullable = (target) => Optional.ofNullable(target);
+export let useNonNull = (target) => Optional.ofNonNull(target);