semantic-typescript 0.6.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) {
-            console.error(error);
-        }
-    });
-};
-;
 export let useAttribute = (target) => {
     if (isObject(target)) {
         return new SynchronousSemantic((accept, interrupt) => {
@@ -53,7 +23,7 @@ export let useAttribute = (target) => {
                 });
             }
             catch (error) {
-                console.error(error);
+                throw error;
             }
         });
     }
@@ -115,7 +85,7 @@ export let useBlob = (blob, chunk = 64n * 1024n) => {
                     }
                 }
                 catch (error) {
-                    console.error(error);
+                    throw error;
                 }
                 finally {
                     if (stoppable) {
@@ -126,346 +96,10 @@ export let useBlob = (blob, chunk = 64n * 1024n) => {
             })();
         }
         catch (error) {
-            console.error(error);
+            throw error;
         }
     });
 };
-;
-;
-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 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;
-        });
-    }
-    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 active = keys.length;
-                let index = 0n;
-                let until = new Promise((resolve) => {
-                    for (let key of keys) {
-                        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)) {
-                                    element.removeEventListener(key, listener);
-                                    if (--active === 0) {
-                                        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 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++;
-                                };
-                                element.addEventListener(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 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);
-                                    }
-                                }
-                            }
-                        }
-                    }
-                });
-                await until;
-            });
-        }
-        if (isIterable(argument2)) {
-            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, 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) {
-                                for (let key of keys) {
-                                    let listener = (event) => {
-                                        if (interrupt(event, 0n)) {
-                                            element.removeEventListener(key, listener);
-                                            if (--active === 0) {
-                                                resolve();
-                                            }
-                                            return;
-                                        }
-                                        accept(event, 0n);
-                                    };
-                                    element.addEventListener(key, listener);
-                                }
-                            }
-                        }
-                    }
-                });
-                await until;
-            });
-        }
-    }
-    throw new TypeError("Invalid arguments.");
-};
 export let useEmpty = () => {
     return new SynchronousSemantic(() => { });
 };
@@ -483,7 +117,7 @@ export let useFill = (element, count) => {
                 }
             }
             catch (error) {
-                console.error(error);
+                throw error;
             }
         });
     }
@@ -504,7 +138,7 @@ export let useFrom = (iterable) => {
                 }
             }
             catch (error) {
-                console.error(error);
+                throw error;
             }
         });
     }
@@ -521,7 +155,7 @@ export let useFrom = (iterable) => {
                 }
             }
             catch (error) {
-                console.error(error);
+                throw error;
             }
         });
     }
@@ -543,7 +177,7 @@ export let useGenerate = (supplier, interrupt) => {
                 }
             }
             catch (error) {
-                console.error(error);
+                throw error;
             }
         });
     }
@@ -582,44 +216,165 @@ export let useInterval = (period, delay = 0) => {
                 }
             }
             catch (error) {
-                console.error(error);
+                throw error;
             }
         });
     }
     throw new TypeError("Invalid arguments.");
 };
-export let useIterate = (generator) => {
-    if (isFunction(generator)) {
-        try {
-            return new SynchronousSemantic(generator);
-        }
-        catch (error) {
-            console.error(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) => {
-                    console.error(error);
                 });
-            }
-            catch (error) {
-                console.error(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) => {
@@ -636,7 +391,7 @@ export let useOf = (...target) => {
                 }
             }
             catch (error) {
-                console.error(error);
+                throw error;
             }
         });
     }
@@ -661,7 +416,7 @@ export let useRange = (start, end, step = (isNumber(start) && isNumber(end) ? 1
                 }
             }
             catch (error) {
-                console.error(error);
+                throw error;
             }
         });
     }
@@ -679,227 +434,61 @@ export let useRange = (start, end, step = (isNumber(start) && isNumber(end) ? 1
                 }
             }
             catch (error) {
-                console.error(error);
+                throw error;
             }
         });
     }
     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;
+export let useText = (argument1, argument2, argument3) => {
+    if (isString(argument1)) {
+        let text = 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;
+            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(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);
+                        accept(split, index);
                     }
-                });
-                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;
+        if (isNumber(argument2) || isBigInt(argument2)) {
+            let start = useToNumber(argument2);
+            if (isNumber(argument3) || isBigInt(argument3)) {
+                let end = useToNumber(argument3);
+                let characters = Array.from(argument1.substring(start, end));
+                return new SynchronousSemantic((accept, interrupt) => {
+                    let index = 0n;
+                    for (let character of characters) {
+                        if (interrupt(character, index)) {
+                            break;
                         }
-                        accept(event, index);
+                        accept(character, 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 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;
+                });
+            }
+            else {
+                let characters = Array.from(argument1.substring(start));
+                return new SynchronousSemantic((accept, interrupt) => {
+                    let index = 0n;
+                    for (let character of characters) {
+                        if (interrupt(character, index)) {
+                            break;
                         }
-                        accept(event, index);
+                        accept(character, index);
                         index++;
-                    };
-                    window.addEventListener(key, listener);
-                }
-            });
-            await until;
-        });
+                    }
+                });
+            }
+        }
     }
     throw new TypeError("Invalid arguments.");
 };
-export let useNullable = (target) => Optional.ofNullable(target);
-export let useNonNull = (target) => Optional.ofNonNull(target);