woby/dist/merge_style-DkxC2kon.cjs.map

A high-performance framework with fine-grained observable/signal-based reactivity for building rich applications.

{"version":3,"file":"merge_style-DkxC2kon.cjs","sources":["../../soby/dist/methods/batch.js","../../soby/dist/methods/is_observable_boolean.js","../../soby/dist/methods/is_observable_frozen.js","../../soby/dist/methods/is_untracked.js","../../soby/dist/objects/memo.js","../../soby/dist/methods/memo.js","../../soby/dist/methods/boolean.js","../../soby/dist/methods/disposed.js","../../soby/dist/methods/resolve.js","../../soby/dist/methods/for.cache.keyed.js","../../soby/dist/objects/suspense.js","../../soby/dist/methods/suspense.js","../../soby/dist/methods/for.cache.unkeyed.js","../../soby/dist/methods/for.js","../../soby/dist/methods/warmup.js","../../soby/dist/methods/switch.js","../../soby/dist/methods/ternary.js","../../soby/dist/methods/observable.js","../../soby/dist/methods/is_observable_writable.js","../../soby/dist/methods/target.js","../../soby/dist/methods/readonly.js","../../soby/dist/methods/selector.js","../../soby/dist/methods/suspended.js","../../soby/dist/methods/tick.js","../../soby/dist/methods/try_catch.js","../../soby/dist/methods/untracked.js","../src/hooks/use_resolved.ts","../src/hooks/use_event_listener.ts","../src/hooks/use_abort_controller.ts","../src/hooks/use_abort_signal.ts","../src/hooks/use_scheduler.ts","../src/hooks/use_animation_frame.ts","../src/hooks/use_animation_loop.ts","../src/hooks/use_context.ts","../src/components/suspense.context.ts","../src/components/suspense.manager.ts","../src/hooks/use_resource.ts","../src/hooks/use_fetch.ts","../src/hooks/use_idle_callback.ts","../src/hooks/use_idle_loop.ts","../src/hooks/use_interval.ts","../src/hooks/use_promise.ts","../src/hooks/use_timeout.ts","../src/components/error_boundary.ts","../src/components/for.ts","../src/hooks/use_guarded.ts","../src/components/if.ts","../src/components/suspense.ts","../src/components/switch.ts","../src/components/ternary.ts","../src/methods/create_context.ts","../src/methods/create_directive.ts","../src/methods/hmr.ts","../../wxt/node_modules/.pnpm/htm@3.1.1/node_modules/htm/dist/htm.module.js","../src/methods/merge_style.ts"],"sourcesContent":["/* IMPORT */\nimport { setBatch } from '../context.js';\nimport { noop } from '../utils.js';\n/* HELPERS */\nlet counter = 0;\nlet resolve = noop;\n/* MAIN */\nconst batch = async (fn, stack) => {\n    if (!counter) {\n        setBatch(new Promise(r => resolve = r));\n    }\n    try {\n        counter += 1;\n        return await fn();\n    }\n    finally {\n        counter -= 1;\n        if (!counter) {\n            setBatch(undefined);\n            resolve(stack);\n        }\n    }\n};\n/* MAIN */\nexport default batch;\n","/* IMPORT */\nimport { SYMBOL_OBSERVABLE_BOOLEAN } from '../symbols.js';\nimport { isFunction } from '../utils.js';\n/* MAIN */\nconst isObservableBoolean = (value) => {\n    return isFunction(value) && (SYMBOL_OBSERVABLE_BOOLEAN in value);\n};\n/* EXPORT */\nexport default isObservableBoolean;\n","/* IMPORT */\nimport { SYMBOL_OBSERVABLE_FROZEN, SYMBOL_OBSERVABLE_READABLE } from '../symbols.js';\nimport { isFunction } from '../utils.js';\n/* MAIN */\nconst isObservableFrozen = (value) => {\n    return isFunction(value) && ((SYMBOL_OBSERVABLE_FROZEN in value) || !!value[SYMBOL_OBSERVABLE_READABLE]?.parent?.disposed);\n};\n/* EXPORT */\nexport default isObservableFrozen;\n","/* IMPORT */\nimport { SYMBOL_UNTRACKED, SYMBOL_UNTRACKED_UNWRAPPED } from '../symbols.js';\nimport { isFunction } from '../utils.js';\n/* MAIN */\nconst isUntracked = (value) => {\n    return isFunction(value) && ((SYMBOL_UNTRACKED in value) || (SYMBOL_UNTRACKED_UNWRAPPED in value));\n};\n/* EXPORT */\nexport default isUntracked;\n","/* IMPORT */\nimport { DIRTY_MAYBE_YES, UNAVAILABLE, UNINITIALIZED } from '../constants.js';\nimport Observable from './observable.js';\nimport Observer from './observer.js';\nimport { callStack, Stack } from '../methods/debugger.js';\n/* MAIN */\nclass Memo extends Observer {\n    /* CONSTRUCTOR */\n    constructor(fn, options) {\n        super();\n        this.fn = fn;\n        this.observable = new Observable(UNINITIALIZED, options, this);\n        const { stack } = options ?? { stack: callStack('Memo init') };\n        if (options?.sync === true) {\n            this.sync = true;\n            this.update(stack);\n        }\n    }\n    /* API */\n    run(stack) {\n        const result = super.refresh(this.fn, stack);\n        if (!this.disposed && this.observables.empty()) {\n            this.disposed = true;\n        }\n        if (result !== UNAVAILABLE) {\n            this.observable.set(result);\n        }\n    }\n    stale(status, stack) {\n        const statusPrev = this.status;\n        if (statusPrev >= status)\n            return;\n        this.status = status;\n        if (statusPrev === DIRTY_MAYBE_YES)\n            return;\n        this.observable.stale(DIRTY_MAYBE_YES, stack);\n    }\n}\n/* EXPORT */\nexport default Memo;\n","/* IMPORT */\nimport isObservableFrozen from './is_observable_frozen.js';\nimport isUntracked from './is_untracked.js';\nimport { frozen, readable } from '../objects/callable.js';\nimport Memo from '../objects/memo.js';\nimport { callStack } from './debugger.js';\n/* MAIN */\nconst memo = (fn, options) => {\n    const stack = options?.stack ?? callStack();\n    if (isObservableFrozen(fn)) {\n        return fn;\n    }\n    else if (isUntracked(fn)) {\n        return frozen(fn(stack));\n    }\n    else {\n        const memo = new Memo(fn, options);\n        const observable = readable(memo.observable, stack);\n        return observable;\n    }\n};\n/* EXPORT */\nexport default memo;\n","/* IMPORT */\nimport isObservableBoolean from './is_observable_boolean.js';\nimport isObservableFrozen from './is_observable_frozen.js';\nimport isUntracked from './is_untracked.js';\nimport memo from './memo.js';\nimport { SYMBOL_OBSERVABLE_BOOLEAN } from '../symbols.js';\nimport { isFunction } from '../utils.js';\n/* MAIN */\nconst boolean = (value) => {\n    if (isFunction(value)) {\n        if (isObservableFrozen(value) || isUntracked(value)) {\n            return !!value();\n        }\n        else if (isObservableBoolean(value)) {\n            return value;\n        }\n        else {\n            const boolean = memo(() => !!value());\n            boolean[SYMBOL_OBSERVABLE_BOOLEAN] = true;\n            return boolean;\n        }\n    }\n    else {\n        return !!value;\n    }\n};\n/* EXPORT */\nexport default boolean;\n","/* IMPORT */\nimport cleanup from './cleanup.js';\nimport { readable } from '../objects/callable.js';\nimport Observable from '../objects/observable.js';\n/* MAIN */\nconst disposed = (stack) => {\n    const observable = new Observable(false);\n    const toggle = () => observable.set(true);\n    cleanup(toggle);\n    return readable(observable);\n};\n/* EXPORT */\nexport default disposed;\n","/* IMPORT */\nimport memo from './memo.js';\nimport { frozen } from '../objects/callable.js';\nimport { SYMBOL_OBSERVABLE, SYMBOL_UNTRACKED, SYMBOL_UNTRACKED_UNWRAPPED } from '../symbols.js';\nimport { isFunction } from '../utils.js';\nfunction resolve(value) {\n    if (isFunction(value)) {\n        if (SYMBOL_UNTRACKED_UNWRAPPED in value) {\n            return resolve(value());\n        }\n        else if (SYMBOL_UNTRACKED in value) {\n            return frozen(resolve(value()));\n        }\n        else if (SYMBOL_OBSERVABLE in value) {\n            return value;\n        }\n        else {\n            return memo(() => resolve(value()));\n        }\n    }\n    if (value instanceof Array) {\n        const resolved = new Array(value.length);\n        for (let i = 0, l = resolved.length; i < l; i++) {\n            resolved[i] = resolve(value[i]);\n        }\n        return resolved;\n    }\n    else {\n        return value;\n    }\n}\n/* EXPORT */\nexport default resolve;\n","/* IMPORT */\nimport { OWNER } from '../context.js';\nimport { lazySetAdd, lazySetDelete } from '../lazy.js';\nimport cleanup from './cleanup.js';\nimport resolve from './resolve.js';\nimport { frozen, readable } from '../objects/callable.js';\nimport Observable from '../objects/observable.js';\nimport Root from '../objects/root.js';\nimport { SYMBOL_CACHED, SYMBOL_SUSPENSE, SYMBOL_UNCACHED } from '../symbols.js';\nimport { callStack } from './debugger.js';\n/* HELPERS */\nconst DUMMY_INDEX = frozen(-1);\nclass MappedRoot extends Root {\n}\n/* MAIN */\nclass CacheKeyed {\n    /* CONSTRUCTOR */\n    constructor(fn) {\n        /* VARIABLES */\n        this.parent = OWNER;\n        this.suspense = OWNER.get(SYMBOL_SUSPENSE);\n        this.cache = new Map();\n        this.bool = false; // The bool is flipped with each iteration, the roots that don't have the updated one are disposed, it's like a cheap counter basically\n        this.prevCount = 0; // Number of previous items\n        this.reuseCount = 0; // Number of previous items that got reused\n        this.nextCount = 0; // Number of next items\n        /* API */\n        this.cleanup = () => {\n            if (!this.prevCount)\n                return; // There was nothing before, no need to cleanup\n            if (this.prevCount === this.reuseCount)\n                return; // All the previous items were reused, no need to cleanup\n            const { cache, bool } = this;\n            if (!cache.size)\n                return; // Nothing to dispose of\n            if (this.nextCount) { // Regular cleanup\n                cache.forEach((mapped, value) => {\n                    if (mapped.bool === bool)\n                        return;\n                    mapped.dispose(true);\n                    cache.delete(value);\n                });\n            }\n            else { // There is nothing after, disposing quickly\n                this.cache.forEach(mapped => {\n                    mapped.dispose(true);\n                });\n                this.cache = new Map();\n            }\n        };\n        this.dispose = () => {\n            if (this.suspense) {\n                lazySetDelete(this.parent, 'roots', this.roots);\n            }\n            this.prevCount = this.cache.size;\n            this.reuseCount = 0;\n            this.nextCount = 0;\n            this.cleanup();\n        };\n        this.before = () => {\n            this.bool = !this.bool;\n            this.reuseCount = 0;\n            this.nextCount = 0;\n        };\n        this.after = (values) => {\n            this.nextCount = values.length;\n            this.cleanup();\n            this.prevCount = this.nextCount;\n            this.reuseCount = 0;\n        };\n        this.map = (values) => {\n            this.before();\n            const { cache, bool, fn, fnWithIndex } = this;\n            const results = new Array(values.length);\n            let resultsCached = true; // Whether all results are cached, if so this enables an optimization\n            let resultsUncached = true; // Whether all results are anew, if so this enables an optimization in Voby\n            let reuseCount = 0;\n            const stack = callStack();\n            for (let i = 0, l = values.length; i < l; i++) {\n                const value = values[i];\n                const cached = cache.get(value);\n                if (cached && cached.bool !== bool) {\n                    resultsUncached = false;\n                    reuseCount += 1;\n                    cached.bool = bool;\n                    cached.index?.set(i);\n                    results[i] = cached.result; //TSC\n                }\n                else {\n                    resultsCached = false;\n                    const mapped = new MappedRoot(false);\n                    if (cached) {\n                        cleanup(() => mapped.dispose(true));\n                    }\n                    mapped.wrap(() => {\n                        let index = DUMMY_INDEX;\n                        if (fnWithIndex) {\n                            mapped.index = new Observable(i);\n                            index = readable(mapped.index, stack);\n                        }\n                        const result = results[i] = resolve(fn(value, index));\n                        mapped.bool = bool;\n                        mapped.result = result;\n                        if (!cached) {\n                            cache.set(value, mapped);\n                        }\n                    }, undefined, undefined, stack);\n                }\n            }\n            this.reuseCount = reuseCount;\n            this.after(values);\n            if (resultsCached) {\n                results[SYMBOL_CACHED] = true;\n            }\n            if (resultsUncached) {\n                results[SYMBOL_UNCACHED] = true;\n            }\n            return results;\n        };\n        this.roots = () => {\n            return Array.from(this.cache.values());\n        };\n        this.fn = fn;\n        this.fnWithIndex = (fn.length > 1);\n        if (this.suspense) {\n            lazySetAdd(this.parent, 'roots', this.roots);\n        }\n    }\n}\n/* EXPORT */\nexport default CacheKeyed;\n","/* IMPORT */\nimport { DIRTY_MAYBE_YES, DIRTY_YES } from '../constants.js';\nimport { OWNER } from '../context.js';\nimport { lazyArrayEach, lazyArrayPush, lazySetEach } from '../lazy.js';\nimport Effect from './effect.js';\nimport Owner from './owner.js';\nimport { SYMBOL_SUSPENSE } from '../symbols.js';\nimport { isFunction } from '../utils.js';\nimport { callStack, Stack } from '../methods/debugger.js';\n/* MAIN */\nclass Suspense extends Owner {\n    /* CONSTRUCTOR */\n    constructor() {\n        super();\n        /* VARIABLES */\n        this.parent = OWNER;\n        this.context = { ...OWNER.context, [SYMBOL_SUSPENSE]: this };\n        lazyArrayPush(this.parent, 'suspenses', this);\n        this.suspended = (OWNER.get(SYMBOL_SUSPENSE)?.suspended || 0);\n    }\n    /* API */\n    toggle(force) {\n        if (!this.suspended && !force)\n            return; // Already suspended, this can happen at instantion time\n        const suspendedPrev = this.suspended;\n        const suspendedNext = suspendedPrev + (force ? 1 : -1);\n        this.suspended = suspendedNext;\n        if (!!suspendedPrev === !!suspendedNext)\n            return; // Same state, nothing to pause or resume\n        /* NOTIFYING OBSERVERS, ROOTS AND SUSPENSES */\n        const stack = callStack();\n        this.observable?.set(!!suspendedNext);\n        const notifyOwner = (owner) => {\n            lazyArrayEach(owner.contexts, notifyOwner);\n            lazyArrayEach(owner.observers, notifyObserver);\n            lazyArrayEach(owner.suspenses, notifySuspense);\n            lazySetEach(owner.roots, notifyRoot);\n        };\n        const notifyObserver = (observer) => {\n            if (observer instanceof Effect) {\n                if (observer.status === DIRTY_MAYBE_YES || observer.status === DIRTY_YES) {\n                    if (observer.init) {\n                        observer.update(stack);\n                    }\n                    else {\n                        observer.schedule(stack);\n                    }\n                }\n            }\n            notifyOwner(observer);\n        };\n        const notifyRoot = (root) => {\n            if (isFunction(root)) {\n                root().forEach(notifyOwner);\n            }\n            else {\n                notifyOwner(root);\n            }\n        };\n        const notifySuspense = (suspense) => {\n            suspense.toggle(force);\n        };\n        notifyOwner(this);\n    }\n    wrap(fn, owner, observer, stack) {\n        return super.wrap(fn, this, undefined, stack);\n    }\n}\n/* EXPORT */\nexport default Suspense;\n","/* IMPORT */\nimport boolean from './boolean.js';\nimport effect from './effect.js';\nimport get from './get.js';\nimport Suspense from '../objects/suspense.js';\nimport { Stack } from './debugger.js';\n/* MAIN */\nconst suspense = (when, fn, stack) => {\n    const suspense = new Suspense();\n    const condition = boolean(when);\n    const toggle = () => suspense.toggle(get(condition));\n    effect(toggle, { sync: true, stack: stack });\n    return suspense.wrap(fn, undefined, undefined, stack);\n};\n/* EXPORT */\nexport default suspense;\n","/* IMPORT */\nimport { OWNER } from '../context.js';\nimport { lazySetAdd, lazySetDelete } from '../lazy.js';\nimport cleanup from './cleanup.js';\nimport get from './get.js';\nimport memo from './memo.js';\nimport resolve from './resolve.js';\nimport suspense from './suspense.js';\nimport { frozen, readable } from '../objects/callable.js';\nimport Observable from '../objects/observable.js';\nimport Root from '../objects/root.js';\nimport { SYMBOL_CACHED, SYMBOL_SUSPENSE, SYMBOL_UNCACHED } from '../symbols.js';\nimport { callStack } from './debugger.js';\n/* HELPERS */\nconst DUMMY_INDEX = frozen(-1);\nclass MappedRoot extends Root {\n}\n/* MAIN */\n//TODO: Optimize this more\nclass CacheUnkeyed {\n    /* CONSTRUCTOR */\n    constructor(fn, pooled) {\n        /* VARIABLES */\n        this.parent = OWNER;\n        this.suspense = OWNER.get(SYMBOL_SUSPENSE);\n        this.cache = new Map();\n        this.pool = [];\n        this.poolMaxSize = 0;\n        /* API */\n        this.cleanup = () => {\n            let pooled = 0;\n            let poolable = Math.max(0, this.pooled ? this.poolMaxSize - this.pool.length : 0);\n            // const stack = callStack()\n            this.cache.forEach(mapped => {\n                if (poolable > 0 && pooled++ < poolable) {\n                    mapped.suspended?.set(true);\n                    this.pool.push(mapped);\n                }\n                else {\n                    mapped.dispose(true);\n                }\n            });\n        };\n        this.dispose = () => {\n            if (this.suspense) {\n                lazySetDelete(this.parent, 'roots', this.roots);\n            }\n            this.cache.forEach(mapped => {\n                mapped.dispose(true);\n            });\n            this.pool.forEach(mapped => {\n                mapped.dispose(true);\n            });\n        };\n        this.map = (values) => {\n            const { cache, fn, fnWithIndex } = this;\n            const cacheNext = new Map();\n            const results = new Array(values.length);\n            const pool = this.pool;\n            const pooled = this.pooled;\n            let resultsCached = true; // Whether all results are cached, if so this enables an optimization\n            let resultsUncached = true; // Whether all results are anew, if so this enables an optimization in Voby\n            let leftovers = [];\n            const stack = callStack();\n            if (cache.size) {\n                for (let i = 0, l = values.length; i < l; i++) {\n                    const value = values[i];\n                    const cached = cache.get(value);\n                    if (cached) {\n                        resultsUncached = false;\n                        cache.delete(value);\n                        cacheNext.set(value, cached);\n                        cached.index?.set(i);\n                        results[i] = cached.result; //TSC\n                    }\n                    else {\n                        leftovers.push(i);\n                    }\n                }\n            }\n            else {\n                leftovers = new Array(results.length);\n            }\n            outer: for (let i = 0, l = leftovers.length; i < l; i++) {\n                const index = leftovers[i] || i;\n                const value = values[index];\n                const isDuplicate = cacheNext.has(value);\n                if (!isDuplicate) {\n                    for (const [key, mapped] of cache.entries()) {\n                        cache.delete(key);\n                        cacheNext.set(value, mapped);\n                        mapped.index?.set(index);\n                        mapped.value?.set(value);\n                        results[index] = mapped.result; //TSC\n                        continue outer;\n                    }\n                }\n                resultsCached = false;\n                let mapped;\n                if (pooled && pool.length) {\n                    mapped = pool.pop(); //TSC\n                    mapped.index?.set(index);\n                    mapped.value?.set(value);\n                    mapped.suspended?.set(false);\n                    results[index] = mapped.result; //TSC\n                }\n                else {\n                    mapped = new MappedRoot(false);\n                    mapped.wrap(() => {\n                        let $index = DUMMY_INDEX;\n                        if (fnWithIndex) {\n                            mapped.index = new Observable(index);\n                            $index = readable(mapped.index, stack);\n                        }\n                        const observable = mapped.value = new Observable(value);\n                        const suspended = pooled ? new Observable(false) : undefined;\n                        if (suspended)\n                            suspended.stack = stack;\n                        const $value = memo(() => get(observable.get())); //TSC\n                        const result = results[index] = suspended ? suspense(() => suspended.get(), () => resolve(fn($value, $index)), stack) : resolve(fn($value, $index));\n                        mapped.value = observable;\n                        mapped.result = result;\n                        mapped.suspended = suspended;\n                    }, undefined, undefined, stack);\n                }\n                if (isDuplicate) { // Expensive, not reusable\n                    cleanup(() => mapped.dispose(true));\n                }\n                else { // Cheap, reusable\n                    cacheNext.set(value, mapped);\n                }\n            }\n            this.poolMaxSize = Math.max(this.poolMaxSize, results.length);\n            this.cleanup();\n            this.cache = cacheNext;\n            if (resultsCached) {\n                results[SYMBOL_CACHED] = true;\n            }\n            if (resultsUncached) {\n                results[SYMBOL_UNCACHED] = true;\n            }\n            return results;\n        };\n        this.roots = () => {\n            return [...this.cache.values(), ...this.pool.values()];\n        };\n        this.fn = fn;\n        this.fnWithIndex = (fn.length > 1);\n        this.pooled = pooled;\n        if (this.suspense) {\n            lazySetAdd(this.parent, 'roots', this.roots);\n        }\n    }\n}\n/* EXPORT */\nexport default CacheUnkeyed;\n","/* IMPORT */\nimport cleanup from './cleanup.js';\nimport CacheKeyed from './for.cache.keyed.js';\nimport CacheUnkeyed from './for.cache.unkeyed.js';\nimport get from './get.js';\nimport isObservable from './is_observable.js';\nimport isStore from './is_store.js';\nimport memo from './memo.js';\nimport resolve from './resolve.js';\nimport untrack from './untrack.js';\nimport { frozen } from '../objects/callable.js';\nimport { SYMBOL_CACHED, SYMBOL_STORE_VALUES } from '../symbols.js';\nimport { isArray, isEqual } from '../utils.js';\nimport { callStack } from './debugger.js';\nfunction _for(values, fn, fallback = [], options) {\n    const stack = callStack();\n    if (isArray(values) && !isStore(values)) { // Fast path for plain arrays\n        const isUnkeyed = !!options?.unkeyed;\n        return frozen(untrack(() => {\n            if (values.length) {\n                return values.map((value, index) => {\n                    return resolve(fn(isUnkeyed && !isObservable(value) ? frozen(value) : value, index));\n                });\n            }\n            else {\n                return resolve(fallback);\n            }\n        }));\n    }\n    else { // Regular path\n        const { dispose, map } = options?.unkeyed ? new CacheUnkeyed(fn, !!options.pooled) : new CacheKeyed(fn); //TSC\n        cleanup(dispose);\n        const value = memo(() => {\n            return get(values) ?? [];\n        }, {\n            equals: (next, prev) => {\n                return !!next && !!prev && !next.length && !prev.length && !isStore(next) && !isStore(prev);\n            },\n            stack\n        });\n        return memo(() => {\n            const array = value();\n            if (isStore(array)) {\n                array[SYMBOL_STORE_VALUES];\n            }\n            return untrack(() => {\n                const results = map(array);\n                return results?.length ? results : resolve(fallback);\n            });\n        }, {\n            equals: (next, prev) => {\n                return isArray(next) && !!next[SYMBOL_CACHED] && isArray(prev) && isEqual(next, prev);\n            },\n            stack\n        });\n    }\n}\n/* EXPORT */\nexport default _for;\n","/* IMPORT */\nimport untrack from './untrack.js';\n/* MAIN */\n// This function ensures an Observable contains a fresh value, mainly to try to push it into a frozen state, if possible\nconst warmup = (value) => {\n    untrack(value);\n    return value;\n};\n/* EXPORT */\nexport default warmup;\n","/* IMPORT */\nimport get from './get.js';\nimport isObservableBoolean from './is_observable_boolean.js';\nimport isObservableFrozen from './is_observable_frozen.js';\nimport isUntracked from './is_untracked.js';\nimport memo from './memo.js';\nimport resolve from './resolve.js';\nimport warmup from './warmup.js';\nimport { frozen } from '../objects/callable.js';\nimport { is, isFunction } from '../utils.js';\n/* HELPERS */\nconst match = (condition, values, fallback) => {\n    for (let i = 0, l = values.length; i < l; i++) {\n        const value = values[i];\n        if (value.length === 1)\n            return value[0];\n        if (is(value[0], condition))\n            return value[1];\n    }\n    return fallback;\n};\nfunction _switch(when, values, fallback) {\n    const isDynamic = isFunction(when) && !isObservableFrozen(when) && !isUntracked(when);\n    if (isDynamic) {\n        if (isObservableBoolean(when)) {\n            return memo(() => resolve(match(when(), values, fallback)));\n        }\n        const value = warmup(memo(() => match(when(), values, fallback)));\n        if (isObservableFrozen(value)) {\n            return frozen(resolve(value()));\n        }\n        else {\n            return memo(() => resolve(get(value)));\n        }\n    }\n    else {\n        const value = match(get(when), values, fallback);\n        return frozen(resolve(value));\n    }\n}\n/* EXPORT */\nexport default _switch;\n","/* IMPORT */\nimport boolean from './boolean.js';\nimport _switch from './switch.js';\n/* MAIN */\nconst ternary = (when, valueTrue, valueFalse) => {\n    const condition = boolean(when);\n    return _switch(condition, [[true, valueTrue], [valueFalse]]);\n};\n/* EXPORT */\nexport default ternary;\n","/* IMPORT */\nimport { writable } from '../objects/callable.js';\nimport ObservableClass from '../objects/observable.js';\nimport { callStack } from './debugger.js';\nfunction observable(value, options) {\n    const stack = callStack();\n    return writable(new ObservableClass(value, options), stack);\n}\n/* EXPORT */\nexport default observable;\n","/* IMPORT */\nimport { SYMBOL_OBSERVABLE_WRITABLE } from '../symbols.js';\nimport { isFunction } from '../utils.js';\n/* MAIN */\nconst isObservableWritable = (value) => {\n    return isFunction(value) && (SYMBOL_OBSERVABLE_WRITABLE in value);\n};\n/* EXPORT */\nexport default isObservableWritable;\n","/* IMPORT */\nimport { UNAVAILABLE } from '../constants.js';\nimport { SYMBOL_OBSERVABLE_READABLE, SYMBOL_OBSERVABLE_WRITABLE } from '../symbols.js';\nimport { isFunction } from '../utils.js';\n/* MAIN */\nconst target = (observable) => {\n    if (isFunction(observable)) {\n        return observable[SYMBOL_OBSERVABLE_READABLE] || observable[SYMBOL_OBSERVABLE_WRITABLE] || UNAVAILABLE;\n    }\n    else {\n        return observable;\n    }\n};\n/* EXPORT */\nexport default target;\n","/* IMPORT */\nimport isObservableWritable from './is_observable_writable.js';\nimport target from './target.js';\nimport { readable } from '../objects/callable.js';\n/* MAIN */\nconst readonly = (observable, stack) => {\n    if (isObservableWritable(observable)) {\n        return readable(target(observable), stack);\n    }\n    else {\n        return observable;\n    }\n};\n/* EXPORT */\nexport default readonly;\n","/* IMPORT */\nimport { OBSERVABLE_FALSE, OBSERVABLE_TRUE } from '../constants.js';\nimport cleanup from './cleanup.js';\nimport effect from './effect.js';\nimport isObservableFrozen from './is_observable_frozen.js';\nimport memo from './memo.js';\nimport untrack from './untrack.js';\nimport warmup from './warmup.js';\nimport { readable } from '../objects/callable.js';\nimport Observable from '../objects/observable.js';\nimport { is } from '../utils.js';\nimport { callStack, Stack } from './debugger.js';\n/* HELPERS */\nclass DisposableMap extends Map {\n    constructor() {\n        super(...arguments);\n        this.disposed = false;\n    }\n}\nclass SelectedObservable extends Observable {\n    constructor() {\n        super(...arguments);\n        this.count = 1;\n    }\n    /* API */\n    call() {\n        if (this.selecteds.disposed)\n            return;\n        this.count -= 1;\n        if (this.count)\n            return;\n        this.selecteds.delete(this.source);\n    }\n}\n/* MAIN */\nconst selector = (source) => {\n    /* NORMALIZING SOURCE */\n    source = warmup(memo(source));\n    /* FROZEN SOURCE */\n    if (isObservableFrozen(source)) {\n        const sourceValue = untrack(source);\n        return (value) => {\n            return (value === sourceValue) ? OBSERVABLE_TRUE : OBSERVABLE_FALSE;\n        };\n    }\n    /* SELECTEDS */\n    let selecteds = new DisposableMap();\n    let selectedValue = untrack(source);\n    const stack = callStack();\n    effect((stack) => {\n        const valuePrev = selectedValue;\n        const valueNext = source();\n        if (is(valuePrev, valueNext))\n            return;\n        selectedValue = valueNext;\n        selecteds.get(valuePrev)?.set(false);\n        selecteds.get(valueNext)?.set(true);\n    }, { suspense: false, sync: true, stack });\n    /* CLEANUP ALL */\n    const cleanupAll = () => {\n        selecteds.disposed = true;\n    };\n    cleanup(cleanupAll);\n    /* SELECTOR */\n    return (value) => {\n        /* INIT */\n        let selected = selecteds.get(value);\n        if (selected) {\n            selected.count += 1;\n        }\n        else {\n            selected = new SelectedObservable(value === selectedValue);\n            selected.selecteds = selecteds;\n            selected.source = value;\n            selecteds.set(value, selected);\n        }\n        /* CLEANUP */\n        cleanup(selected);\n        /* RETURN */\n        return readable(selected);\n    };\n};\n/* EXPORT */\nexport default selector;\n","/* IMPORT */\nimport { OBSERVABLE_FALSE } from '../constants.js';\nimport { OWNER } from '../context.js';\nimport { readable } from '../objects/callable.js';\nimport Observable from '../objects/observable.js';\nimport { SYMBOL_SUSPENSE } from '../symbols.js';\n/* MAIN */\nconst suspended = (stack) => {\n    const suspense = OWNER.get(SYMBOL_SUSPENSE);\n    if (!suspense)\n        return OBSERVABLE_FALSE;\n    const observable = (suspense.observable || (suspense.observable = new Observable(!!suspense.suspended)));\n    return readable(observable, stack);\n};\n/* EXPORT */\nexport default suspended;\n","/* IMPORT */\nimport Scheduler from '../objects/scheduler.async.js';\nimport { Stack } from './debugger.js';\n/* MAIN */\nconst tick = (stack) => {\n    Scheduler.flush(stack);\n};\n/* EXPORT */\nexport default tick;\n","/* IMPORT */\nimport { OWNER } from '../context.js';\nimport memo from './memo.js';\nimport $ from './observable.js';\nimport resolve from './resolve.js';\n/* MAIN */\nconst tryCatch = (value, fn) => {\n    const observable = $();\n    return memo((stack) => {\n        const error = observable();\n        if (error) {\n            const reset = () => observable(undefined);\n            const options = { error, reset };\n            return resolve(fn(options));\n        }\n        else {\n            OWNER.errorHandler = observable;\n            return resolve(value);\n        }\n    });\n};\n/* EXPORT */\nexport default tryCatch;\n","/* IMPORT */\nimport untrack from './untrack.js';\nimport { SYMBOL_UNTRACKED } from '../symbols.js';\nimport { isFunction } from '../utils.js';\nfunction untracked(fn) {\n    const untracked = isFunction(fn) ? (...args) => untrack(() => fn(...args)) : () => fn;\n    untracked[SYMBOL_UNTRACKED] = true;\n    return untracked;\n}\n/* EXPORT */\nexport default untracked;\n","\r\n/* IMPORT */\r\n\r\nimport isObservable from '../methods/is_observable'\r\nimport { isArray, isFunction } from '../utils/lang'\r\nimport type { FN, ObservableReadonly } from '../types'\r\n\r\n/* HELPERS */\r\n\r\ntype F<T> = T extends () => infer U ? U : T\r\ntype O<T> = T extends ObservableReadonly<infer U> ? U : T\r\n\r\n/* MAIN */\r\n\r\n//TODO: Maybe port this to soby, as \"resolved\"\r\n\r\nfunction useResolved<T1, T2, T3, T4, T5, T6, T7, T8, T9>(value: readonly [T1, T2, T3, T4, T5, T6, T7, T8, T9], resolveFunction?: true): [F<T1>, F<T2>, F<T3>, F<T4>, F<T5>, F<T6>, F<T7>, F<T8>, F<T9>]\r\nfunction useResolved<T1, T2, T3, T4, T5, T6, T7, T8>(value: readonly [T1, T2, T3, T4, T5, T6, T7, T8], resolveFunction?: true): [F<T1>, F<T2>, F<T3>, F<T4>, F<T5>, F<T6>, F<T7>, F<T8>]\r\nfunction useResolved<T1, T2, T3, T4, T5, T6, T7>(value: readonly [T1, T2, T3, T4, T5, T6, T7], resolveFunction?: true): [F<T1>, F<T2>, F<T3>, F<T4>, F<T5>, F<T6>, F<T7>]\r\nfunction useResolved<T1, T2, T3, T4, T5, T6>(value: readonly [T1, T2, T3, T4, T5, T6], resolveFunction?: true): [F<T1>, F<T2>, F<T3>, F<T4>, F<T5>, F<T6>]\r\nfunction useResolved<T1, T2, T3, T4, T5>(value: readonly [T1, T2, T3, T4, T5], resolveFunction?: true): [F<T1>, F<T2>, F<T3>, F<T4>, F<T5>]\r\nfunction useResolved<T1, T2, T3, T4>(value: readonly [T1, T2, T3, T4], resolveFunction?: true): [F<T1>, F<T2>, F<T3>, F<T4>]\r\nfunction useResolved<T1, T2, T3>(value: readonly [T1, T2, T3], resolveFunction?: true): [F<T1>, F<T2>, F<T3>]\r\nfunction useResolved<T1, T2>(value: readonly [T1, T2], resolveFunction?: true): [F<T1>, F<T2>]\r\nfunction useResolved<T1>(value: readonly [T1], resolveFunction?: true): [F<T1>]\r\nfunction useResolved(value: readonly [], resolveFunction?: true): []\r\n\r\nfunction useResolved<T1, T2, T3, T4, T5, T6, T7, T8, T9>(value: readonly [T1, T2, T3, T4, T5, T6, T7, T8, T9], resolveFunction: false): [O<T1>, O<T2>, O<T3>, O<T4>, O<T5>, O<T6>, O<T7>, O<T8>, O<T9>]\r\nfunction useResolved<T1, T2, T3, T4, T5, T6, T7, T8>(value: readonly [T1, T2, T3, T4, T5, T6, T7, T8], resolveFunction: false): [O<T1>, O<T2>, O<T3>, O<T4>, O<T5>, O<T6>, O<T7>, O<T8>]\r\nfunction useResolved<T1, T2, T3, T4, T5, T6, T7>(value: readonly [T1, T2, T3, T4, T5, T6, T7], resolveFunction: false): [O<T1>, O<T2>, O<T3>, O<T4>, O<T5>, O<T6>, O<T7>]\r\nfunction useResolved<T1, T2, T3, T4, T5, T6>(value: readonly [T1, T2, T3, T4, T5, T6], resolveFunction: false): [O<T1>, O<T2>, O<T3>, O<T4>, O<T5>, O<T6>]\r\nfunction useResolved<T1, T2, T3, T4, T5>(value: readonly [T1, T2, T3, T4, T5], resolveFunction: false): [O<T1>, O<T2>, O<T3>, O<T4>, O<T5>]\r\nfunction useResolved<T1, T2, T3, T4>(value: readonly [T1, T2, T3, T4], resolveFunction: false): [O<T1>, O<T2>, O<T3>, O<T4>]\r\nfunction useResolved<T1, T2, T3>(value: readonly [T1, T2, T3], resolveFunction: false): [O<T1>, O<T2>, O<T3>]\r\nfunction useResolved<T1, T2>(value: readonly [T1, T2], resolveFunction: false): [O<T1>, O<T2>]\r\nfunction useResolved<T1>(value: readonly [T1], resolveFunction: false): [O<T1>]\r\nfunction useResolved(value: readonly [], resolveFunction: false): []\r\n\r\nfunction useResolved<T1, T2, T3, T4, T5, T6, T7, T8, T9, R>(value: readonly [T1, T2, T3, T4, T5, T6, T7, T8, T9], callback: FN<[F<T1>, F<T2>, F<T3>, F<T4>, F<T5>, F<T6>, F<T7>, F<T8>, F<T9>], R>, resolveFunction?: true): R\r\nfunction useResolved<T1, T2, T3, T4, T5, T6, T7, T8, R>(value: readonly [T1, T2, T3, T4, T5, T6, T7, T8], callback: FN<[F<T1>, F<T2>, F<T3>, F<T4>, F<T5>, F<T6>, F<T7>, F<T8>], R>, resolveFunction?: true): R\r\nfunction useResolved<T1, T2, T3, T4, T5, T6, T7, R>(value: readonly [T1, T2, T3, T4, T5, T6, T7], callback: FN<[F<T1>, F<T2>, F<T3>, F<T4>, F<T5>, F<T6>, F<T7>], R>, resolveFunction?: true): R\r\nfunction useResolved<T1, T2, T3, T4, T5, T6, R>(value: readonly [T1, T2, T3, T4, T5, T6], callback: FN<[F<T1>, F<T2>, F<T3>, F<T4>, F<T5>, F<T6>], R>, resolveFunction?: true): R\r\nfunction useResolved<T1, T2, T3, T4, T5, R>(value: readonly [T1, T2, T3, T4, T5], callback: FN<[F<T1>, F<T2>, F<T3>, F<T4>, F<T5>], R>, resolveFunction?: true): R\r\nfunction useResolved<T1, T2, T3, T4, R>(value: readonly [T1, T2, T3, T4], callback: FN<[F<T1>, F<T2>, F<T3>, F<T4>], R>, resolveFunction?: true): R\r\nfunction useResolved<T1, T2, T3, R>(value: readonly [T1, T2, T3], callback: FN<[F<T1>, F<T2>, F<T3>], R>, resolveFunction?: true): R\r\nfunction useResolved<T1, T2, R>(value: readonly [T1, T2], callback: FN<[F<T1>, F<T2>], R>, resolveFunction?: true): R\r\nfunction useResolved<T1, R>(value: readonly [T1], callback: FN<[F<T1>], R>, resolveFunction?: true): R\r\nfunction useResolved<R>(value: readonly [], callback: FN<[], R>, resolveFunction?: true): R\r\n\r\nfunction useResolved<T1, T2, T3, T4, T5, T6, T7, T8, T9, R>(value: readonly [T1, T2, T3, T4, T5, T6, T7, T8, T9], callback: FN<[O<T1>, O<T2>, O<T3>, O<T4>, O<T5>, O<T6>, O<T7>, O<T8>, O<T9>], R>, resolveFunction: false): R\r\nfunction useResolved<T1, T2, T3, T4, T5, T6, T7, T8, R>(value: readonly [T1, T2, T3, T4, T5, T6, T7, T8], callback: FN<[O<T1>, O<T2>, O<T3>, O<T4>, O<T5>, O<T6>, O<T7>, O<T8>], R>, resolveFunction: false): R\r\nfunction useResolved<T1, T2, T3, T4, T5, T6, T7, R>(value: readonly [T1, T2, T3, T4, T5, T6, T7], callback: FN<[O<T1>, O<T2>, O<T3>, O<T4>, O<T5>, O<T6>, O<T7>], R>, resolveFunction: false): R\r\nfunction useResolved<T1, T2, T3, T4, T5, T6, R>(value: readonly [T1, T2, T3, T4, T5, T6], callback: FN<[O<T1>, O<T2>, O<T3>, O<T4>, O<T5>, O<T6>], R>, resolveFunction: false): R\r\nfunction useResolved<T1, T2, T3, T4, T5, R>(value: readonly [T1, T2, T3, T4, T5], callback: FN<[O<T1>, O<T2>, O<T3>, O<T4>, O<T5>], R>, resolveFunction: false): R\r\nfunction useResolved<T1, T2, T3, T4, R>(value: readonly [T1, T2, T3, T4], callback: FN<[O<T1>, O<T2>, O<T3>, O<T4>], R>, resolveFunction: false): R\r\nfunction useResolved<T1, T2, T3, R>(value: readonly [T1, T2, T3], callback: FN<[O<T1>, O<T2>, O<T3>], R>, resolveFunction: false): R\r\nfunction useResolved<T1, T2, R>(value: readonly [T1, T2], callback: FN<[O<T1>, O<T2>], R>, resolveFunction: false): R\r\nfunction useResolved<T1, R>(value: readonly [T1], callback: FN<[O<T1>], R>, resolveFunction: false): R\r\nfunction useResolved<R>(value: readonly [], callback: FN<[], R>, resolveFunction: false): R\r\n\r\nfunction useResolved<T>(value: T, resolveFunction?: true): F<T>\r\nfunction useResolved<T>(value: T, resolveFunction: false): O<T>\r\n\r\nfunction useResolved<T, R>(value: T, callback: FN<[F<T>], R>, resolveFunction?: true): R\r\nfunction useResolved<T, R>(value: T, callback: FN<[O<T>], R>, resolveFunction: false): R\r\n\r\nfunction useResolved(values: any, callback: any, resolveFunction?: boolean) {\r\n\r\n  const isResolvable = (resolveFunction !== false && callback !== false) ? isFunction : isObservable\r\n  const resolve = (value: any) => isResolvable(value) ? value() : value\r\n\r\n  if (isArray(values)) {\r\n\r\n    const resolved = values.map(resolve)\r\n\r\n    if (isFunction(callback)) {\r\n\r\n      return callback.apply(undefined, resolved)\r\n\r\n    } else {\r\n\r\n      return resolved\r\n\r\n    }\r\n\r\n  } else {\r\n\r\n    const resolved = resolve(values)\r\n\r\n    if (isFunction(callback)) {\r\n\r\n      return callback(resolved)\r\n\r\n    } else {\r\n\r\n      return resolved\r\n\r\n    }\r\n\r\n  }\r\n\r\n}\r\n\r\n/* EXPORT */\r\n\r\nexport default useResolved","\r\n/* IMPORT */\r\n\r\nimport useEffect from '../hooks/use_effect'\r\nimport useResolved from '../hooks/use_resolved'\r\nimport $$ from '../methods/SS'\r\nimport { castArray } from '../utils/lang'\r\nimport type { ArrayMaybe, Disposer, FN, FunctionMaybe, ObservableMaybe } from '../types'\r\n\r\n/* MAIN */\r\n\r\nfunction useEventListener<T extends Window, U extends keyof WindowEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[WindowEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends Document, U extends keyof DocumentEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[DocumentEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends HTMLBodyElement, U extends keyof HTMLBodyElementEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[HTMLBodyElementEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends HTMLFrameSetElement, U extends keyof HTMLFrameSetElementEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[HTMLFrameSetElementEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends HTMLMediaElement, U extends keyof HTMLMediaElementEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[HTMLMediaElementEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends HTMLVideoElement, U extends keyof HTMLVideoElementEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[HTMLVideoElementEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends HTMLElement, U extends keyof HTMLElementEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[HTMLElementEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends SVGSVGElement, U extends keyof SVGSVGElementEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[SVGSVGElementEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends SVGElement, U extends keyof SVGElementEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[SVGElementEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends MathMLElement, U extends keyof MathMLElementEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[MathMLElementEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends Element, U extends keyof ElementEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[ElementEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends AbortSignal, U extends keyof AbortSignalEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[AbortSignalEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends AbstractWorker, U extends keyof AbstractWorkerEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[AbstractWorkerEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends Animation, U extends keyof AnimationEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[AnimationEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends BroadcastChannel, U extends keyof BroadcastChannelEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[BroadcastChannelEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends CSSAnimation, U extends keyof AnimationEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[AnimationEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends CSSTransition, U extends keyof AnimationEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[AnimationEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends FileReader, U extends keyof FileReaderEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[FileReaderEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends IDBDatabase, U extends keyof IDBDatabaseEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[IDBDatabaseEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends IDBOpenDBRequest, U extends keyof IDBOpenDBRequestEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[IDBOpenDBRequestEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends IDBRequest, U extends keyof IDBRequestEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[IDBRequestEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends IDBTransaction, U extends keyof IDBTransactionEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[IDBTransactionEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends MediaDevices, U extends keyof MediaDevicesEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[MediaDevicesEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends MediaKeySession, U extends keyof MediaKeySessionEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[MediaKeySessionEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends MediaQueryList, U extends keyof MediaQueryListEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[MediaQueryListEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends MediaRecorder, U extends keyof MediaRecorderEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[MediaRecorderEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends MediaSource, U extends keyof MediaSourceEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[MediaSourceEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends MediaStream, U extends keyof MediaStreamEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[MediaStreamEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends MediaStreamTrack, U extends keyof MediaStreamTrackEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[MediaStreamTrackEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends MessagePort, U extends keyof MessagePortEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[MessagePortEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends Notification, U extends keyof NotificationEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[NotificationEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunction useEventListener<T extends PaymentRequest, U extends keyof PaymentRequestEventMap>(target: FunctionMaybe<ArrayMaybe<T | undefined>>, event: FunctionMaybe<U>, handler: ObservableMaybe<FN<[PaymentRequestEventMap[U]], void>>, options?: FunctionMaybe<true | AddEventListenerOptions>): Disposer\r\nfunctio