semantic-typescript 0.7.0 → 0.7.1

package/dist/factory.js

@@ -1,39 +1,9 @@
 import { AsynchronousSemantic } from "./asynchronous/semantic";
-import { isBigInt, isFunction, isIterable, isNumber, isObject, isPromise, isAsyncIterable, isString, isHTMLElemet } from "./guard";
+import { isBigInt, isFunction, isIterable, isNumber, isObject, isPromise, isAsyncIterable, isString } 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 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 SynchronousSemantic((accept, interrupt) => {
-        try {
-            let start = performance.now();
-            let index = 0n;
-            let animate = () => {
-                if (performance.now() - start >= delay) {
-                    requestAnimationFrame(animate);
-                }
-                else if (performance.now() - start < period) {
-                    requestAnimationFrame(animate);
-                }
-                else {
-                    if (interrupt(start, index)) {
-                        return;
-                    }
-                    accept(performance.now(), index);
-                }
-            };
-        }
-        catch (error) {
-            throw error;
-        }
-    });
-};
-;
 export let useAttribute = (target) => {
     if (isObject(target)) {
         return new SynchronousSemantic((accept, interrupt) => {
@@ -130,376 +100,6 @@ export let useBlob = (blob, chunk = 64n * 1024n) => {
         }
     });
 };
-;
-;
-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);
-                        }
-                        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;
-                        }
-                        lastEmitTime = now;
-                        if (interrupt(event, index)) {
-                            window.document.removeEventListener(key, listener);
-                            resolve();
-                            return;
-                        }
-                        accept(event, index);
-                        index++;
-                        return;
-                    }
-                    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 listeners = new Map();
-            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);
-                            for (let [k, l] of listeners) {
-                                window.document.removeEventListener(k, l);
-                            }
-                            listeners.clear();
-                            if (--activeCount === 0) {
-                                resolve();
-                            }
-                            return;
-                        }
-                        accept(event, index);
-                        index++;
-                    };
-                    window.document.addEventListener(key, listener);
-                    listeners.set(key, listener);
-                }
-            });
-            await until;
-        });
-    }
-    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 AsynchronousSemantic(async (accept, interrupt) => {
-                let timeOut = null;
-                let lastEmit = 0;
-                let index = 0n;
-                let until = new Promise((resolve) => {
-                    let listener = (event) => {
-                        if (debounce > 0) {
-                            if (timeOut) {
-                                clearTimeout(timeOut);
-                            }
-                            timeOut = setTimeout(() => handle(event), debounce);
-                            return;
-                        }
-                        if (throttle > 0) {
-                            let now = performance.now();
-                            if (now - lastEmit < throttle)
-                                return;
-                            lastEmit = now;
-                        }
-                        handle(event);
-                    };
-                    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 = [...new Set(argument2)];
-            return new AsynchronousSemantic(async (accept, interrupt) => {
-                let index = 0n;
-                let listeners = new Map();
-                let until = new Promise((resolve) => {
-                    for (let key of keys) {
-                        let listener = (event) => {
-                            if (interrupt(event, index)) {
-                                element.removeEventListener(key, listener);
-                                for (let [k, l] of listeners) {
-                                    element.removeEventListener(k, l);
-                                }
-                                listeners.clear();
-                                resolve();
-                                return;
-                            }
-                            accept(event, index);
-                            index++;
-                        };
-                        element.addEventListener(key, listener);
-                        listeners.set(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 index = 0n;
-                let listeners = new WeakMap();
-                let until = new Promise((resolve) => {
-                    for (let element of elements) {
-                        if (validate(element)) {
-                            let listener = (event) => {
-                                if (interrupt(event, index)) {
-                                    element.removeEventListener(key, listener);
-                                    let map = listeners.get(element);
-                                    if (validate(map)) {
-                                        for (let [k, l] of map) {
-                                            element.removeEventListener(k, l);
-                                        }
-                                        map.clear();
-                                    }
-                                    resolve();
-                                    return;
-                                }
-                                accept(event, index);
-                                index++;
-                            };
-                            element.addEventListener(key, listener);
-                            let map = new Map() || new Map();
-                            map.set(key, listener);
-                            listeners.set(element, map);
-                        }
-                    }
-                });
-                await until;
-            });
-        }
-        if (isIterable(argument2)) {
-            let keys = new Set(argument2);
-            return new AsynchronousSemantic(async (accept, interrupt) => {
-                let index = 0n;
-                let listeners = new Map();
-                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);
-                                        for (let [k, l] of listeners) {
-                                            element.removeEventListener(k, l);
-                                        }
-                                        listeners.clear();
-                                        resolve();
-                                        return;
-                                    }
-                                    accept(event, index);
-                                    index++;
-                                };
-                                element.addEventListener(key, listener);
-                                listeners.set(key, listener);
-                            }
-                        }
-                    }
-                });
-                await until;
-            });
-        }
-    }
-    if (isIterable(argument1)) {
-        let elementsOrSelectors = new Set(argument1);
-        if (isString(argument2)) {
-            let key = argument2;
-            return new AsynchronousSemantic(async (accept, interrupt) => {
-                let listeners = new Map();
-                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);
-                                        for (let [k, l] of listeners) {
-                                            element.removeEventListener(k, l);
-                                        }
-                                        listeners.clear();
-                                        resolve();
-                                        return;
-                                    }
-                                    accept(event, 0n);
-                                };
-                                element.addEventListener(key, listener);
-                                listeners.set(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);
-                                                for (let [k, l] of listeners) {
-                                                    element.removeEventListener(k, l);
-                                                }
-                                                listeners.clear();
-                                                resolve();
-                                                return;
-                                            }
-                                            accept(event, 0n);
-                                        };
-                                        element.addEventListener(key, listener);
-                                        listeners.set(key, listener);
-                                    }
-                                }
-                            }
-                        }
-                    }
-                });
-                await until;
-            });
-        }
-        if (isIterable(argument2)) {
-            let keys = new Set(argument2);
-            return new AsynchronousSemantic(async (accept, interrupt) => {
-                let listeners = new Map();
-                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, 0n)) {
-                                            element.removeEventListener(key, listener);
-                                            for (let [k, l] of listeners) {
-                                                element.removeEventListener(k, l);
-                                            }
-                                            listeners.clear();
-                                            resolve();
-                                            return;
-                                        }
-                                        accept(event, 0n);
-                                    };
-                                    element.addEventListener(key, listener);
-                                    listeners.set(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);
-                                            for (let [k, l] of listeners) {
-                                                element.removeEventListener(k, l);
-                                            }
-                                            listeners.clear();
-                                            resolve();
-                                            return;
-                                        }
-                                        accept(event, 0n);
-                                    };
-                                    element.addEventListener(key, listener);
-                                    listeners.set(key, listener);
-                                }
-                            }
-                        }
-                    }
-                });
-                await until;
-            });
-        }
-    }
-    throw new TypeError("Invalid arguments.");
-};
 export let useEmpty = () => {
     return new SynchronousSemantic(() => { });
 };
@@ -622,38 +222,159 @@ export let useInterval = (period, delay = 0) => {
     }
     throw new TypeError("Invalid arguments.");
 };
-export let useIterate = (generator) => {
-    if (isFunction(generator)) {
-        try {
-            return new SynchronousSemantic(generator);
-        }
-        catch (error) {
-            throw error;
-        }
+;
+export let useIterate = ((iterable) => {
+    if (isIterable(iterable)) {
+        return new SynchronousSemantic((accept, interrupt) => {
+            try {
+                let index = 0n;
+                for (let element of iterable) {
+                    if (interrupt(element, index)) {
+                        break;
+                    }
+                    accept(element, index);
+                    index++;
+                }
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    if (isAsyncIterable(iterable)) {
+        return new AsynchronousSemantic(async (accept, interrupt) => {
+            return await new Promise(async (resolve, reject) => {
+                try {
+                    let index = 0n;
+                    for await (let element of iterable) {
+                        if (interrupt(element, index)) {
+                            break;
+                        }
+                        accept(element, index);
+                        break;
+                    }
+                    resolve();
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
     }
     throw new TypeError("Invalid arguments.");
-};
+});
+;
 export let usePromise = (promise) => {
     if (isPromise(promise)) {
-        return new SynchronousSemantic((accept, interrupt) => {
-            try {
+        return new AsynchronousSemantic(async (accept, interrupt) => {
+            return new Promise(async (resolve, reject) => {
                 promise.then((value) => {
                     if (interrupt(value, 0n)) {
-                        return;
+                        reject(new Error("Promise was interrupted."));
+                    }
+                    else {
+                        accept(value, 0n);
+                        resolve();
                     }
-                    accept(value, 0n);
-                }).catch((error) => {
-                    throw error;
                 });
-            }
-            catch (error) {
-                throw error;
-            }
+            });
         });
     }
-    else {
-        throw new TypeError("Invalid arguments.");
+    throw new TypeError("Invalid arguments.");
+};
+;
+;
+export let useSubscription = (argument1, argument2, argument3) => {
+    if (isObject(argument1) && isFunction(argument2)) {
+        let target = argument1;
+        try {
+            let subscriber = argument2();
+            if (isString(argument3)) {
+                let subscription = argument3;
+                return new AsynchronousSemantic(async (accept, interrupt) => {
+                    try {
+                        subscriber.mount(target);
+                        let index = 0n;
+                        let unsubscriptions = new Map();
+                        return new Promise(async (resolve, reject) => {
+                            try {
+                                let handler = (event) => {
+                                    if (interrupt(event, index)) {
+                                        for (let [unsubscriptionKey, unsubscriptionValue] of unsubscriptions) {
+                                            subscriber.unsubscribe(unsubscriptionKey, unsubscriptionValue);
+                                        }
+                                        subscriber.unmount();
+                                        resolve();
+                                    }
+                                    else {
+                                        accept(event, index);
+                                        index++;
+                                    }
+                                };
+                                subscriber.subscribe(subscription, handler);
+                                unsubscriptions.set(subscription, handler);
+                            }
+                            catch (error) {
+                                for (let [unsubscriptionKey, unsubscriptionValue] of unsubscriptions) {
+                                    subscriber.unsubscribe(unsubscriptionKey, unsubscriptionValue);
+                                }
+                                subscriber.unmount();
+                                reject(error);
+                            }
+                        });
+                    }
+                    catch (error) {
+                        throw error;
+                    }
+                });
+            }
+            if (isIterable(argument3)) {
+                let subscriptions = argument3;
+                return new AsynchronousSemantic(async (accept, interrupt) => {
+                    try {
+                        subscriber.mount(target);
+                        let index = 0n;
+                        let unsubscriptions = new Map();
+                        return new Promise(async (resolve, reject) => {
+                            try {
+                                for (let subscription of subscriptions) {
+                                    let handler = (event) => {
+                                        if (interrupt(event, index)) {
+                                            for (let [unsubscriptionKey, unsubscriptionValue] of unsubscriptions) {
+                                                subscriber.unsubscribe(unsubscriptionKey, unsubscriptionValue);
+                                            }
+                                            subscriber.unmount();
+                                            resolve();
+                                        }
+                                        else {
+                                            accept(event, index);
+                                            index++;
+                                        }
+                                    };
+                                    subscriber.subscribe(subscription, handler);
+                                    unsubscriptions.set(subscription, handler);
+                                }
+                            }
+                            catch (error) {
+                                for (let [unsubscriptionKey, unsubscriptionValue] of unsubscriptions) {
+                                    subscriber.unsubscribe(unsubscriptionKey, unsubscriptionValue);
+                                }
+                                subscriber.unmount();
+                                reject(error);
+                            }
+                        });
+                    }
+                    catch (error) {
+                        throw error;
+                    }
+                });
+            }
+        }
+        catch (error) {
+            throw error;
+        }
     }
+    throw new TypeError("Invalid arguments.");
 };
 ;
 export let useOf = (...target) => {
@@ -722,11 +443,27 @@ export let useRange = (start, end, step = (isNumber(start) && isNumber(end) ? 1
 ;
 export let useText = (argument1, argument2, argument3) => {
     if (isString(argument1)) {
+        let text = argument1;
+        if (isString(argument2)) {
+            let delimeter = argument2;
+            return new SynchronousSemantic((accept, interrupt) => {
+                if (text.length > 0 && delimeter.length > 0) {
+                    let splited = text.split(delimeter);
+                    let index = 0n;
+                    for (let split of splited) {
+                        if (interrupt(split, index)) {
+                            break;
+                        }
+                        accept(split, index);
+                    }
+                }
+            });
+        }
         if (isNumber(argument2) || isBigInt(argument2)) {
             let start = useToNumber(argument2);
             if (isNumber(argument3) || isBigInt(argument3)) {
                 let end = useToNumber(argument3);
-                let characters = [...(argument1.substring(start, end))];
+                let characters = Array.from(argument1.substring(start, end));
                 return new SynchronousSemantic((accept, interrupt) => {
                     let index = 0n;
                     for (let character of characters) {
@@ -739,7 +476,7 @@ export let useText = (argument1, argument2, argument3) => {
                 });
             }
             else {
-                let characters = [...(argument1.substring(start))];
+                let characters = Array.from(argument1.substring(start));
                 return new SynchronousSemantic((accept, interrupt) => {
                     let index = 0n;
                     for (let character of characters) {
@@ -755,227 +492,3 @@ export let useText = (argument1, argument2, argument3) => {
     }
     throw new TypeError("Invalid arguments.");
 };
-;
-;
-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;
-    }
-    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;
-            });
-        }
-        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;
-            });
-        }
-    }
-    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);
-            });
-            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 listeners = new Map();
-            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);
-                            for (let [k, l] of listeners) {
-                                window.removeEventListener(k, l);
-                            }
-                            listeners.clear();
-                            if (--activeCount === 0) {
-                                resolve();
-                            }
-                            return;
-                        }
-                        accept(event, index);
-                        index++;
-                    };
-                    window.addEventListener(key, listener);
-                    listeners.set(key, listener);
-                }
-            });
-            await until;
-        });
-    }
-    throw new TypeError("Invalid arguments.");
-};
-export let useNullable = (target) => Optional.ofNullable(target);
-export let useNonNull = (target) => Optional.ofNonNull(target);