{"version":3,"file":"setters-CyO2VUT6.cjs","sources":["../../soby/dist/symbols.js","../../soby/dist/methods/debugger.js","../../soby/dist/utils.js","../../soby/dist/objects/callable.js","../../soby/dist/constants.js","../../soby/dist/lazy.js","../../soby/dist/objects/owner.js","../../soby/dist/objects/superroot.js","../../soby/dist/context.js","../../soby/dist/objects/scheduler.sync.js","../../soby/dist/objects/observable.js","../../soby/dist/objects/observables.js","../../soby/dist/objects/observer.js","../../soby/dist/methods/cleanup.js","../../soby/dist/objects/context.js","../../soby/dist/methods/context.js","../../soby/dist/objects/scheduler.async.js","../../soby/dist/objects/effect.js","../../soby/dist/methods/effect.js","../../soby/dist/methods/is_observable.js","../../soby/dist/methods/get.js","../../soby/dist/methods/is_store.js","../../soby/dist/methods/untrack.js","../../soby/dist/methods/is_batching.js","../../soby/dist/methods/store.js","../../soby/dist/methods/with.js","../src/constants.ts","../src/utils/creators.ts","../src/utils/lang.ts","../src/hooks/use_render_effect.ts","../src/hooks/use_cheap_disposed.ts","../src/hooks/use_microtask.ts","../src/utils/classlist.ts","../src/utils/diff.ts","../src/utils/fragment.ts","../src/utils/resolvers.ts","../src/utils/setters.ts"],"sourcesContent":["/* MAIN */\nconst SYMBOL_CACHED = Symbol('Cached');\nconst SYMBOL_OBSERVABLE = Symbol('Observable');\nconst SYMBOL_OBSERVABLE_BOOLEAN = Symbol('Observable.Boolean');\nconst SYMBOL_OBSERVABLE_FROZEN = Symbol('Observable.Frozen');\nconst SYMBOL_OBSERVABLE_READABLE = Symbol('Observable.Readable');\nconst SYMBOL_OBSERVABLE_WRITABLE = Symbol('Observable.Writable');\nconst SYMBOL_STORE = Symbol('Store');\nconst SYMBOL_STORE_KEYS = Symbol('Store.Keys');\nconst SYMBOL_STORE_OBSERVABLE = Symbol('Store.Observable');\nconst SYMBOL_STORE_TARGET = Symbol('Store.Target');\nconst SYMBOL_STORE_VALUES = Symbol('Store.Values');\nconst SYMBOL_STORE_UNTRACKED = Symbol('Store.Untracked');\nconst SYMBOL_SUSPENSE = Symbol('Suspense');\nconst SYMBOL_UNCACHED = Symbol('Uncached');\nconst SYMBOL_UNTRACKED = Symbol('Untracked');\nconst SYMBOL_UNTRACKED_UNWRAPPED = Symbol('Untracked.Unwrapped');\n/* EXPORT */\nexport { SYMBOL_CACHED, SYMBOL_OBSERVABLE, SYMBOL_OBSERVABLE_BOOLEAN, SYMBOL_OBSERVABLE_FROZEN, SYMBOL_OBSERVABLE_READABLE, SYMBOL_OBSERVABLE_WRITABLE, SYMBOL_STORE, SYMBOL_STORE_KEYS, SYMBOL_STORE_OBSERVABLE, SYMBOL_STORE_TARGET, SYMBOL_STORE_VALUES, SYMBOL_STORE_UNTRACKED, SYMBOL_SUSPENSE, SYMBOL_UNCACHED, SYMBOL_UNTRACKED, SYMBOL_UNTRACKED_UNWRAPPED };\n","export const DEBUGGER = { debug: false, test: false };\nexport class Stack extends Error {\n    constructor(message = '', startIndex = 0) {\n        super(message);\n        this.name = \"Stack\"; // Change the error class name\n        Object.setPrototypeOf(this, Stack.prototype); // Ensure correct prototype chain\n        if (this.stack) {\n            const stackLines = this.stack.split('\\n');\n            const header = stackLines[0]; // usually \"Stack: message\"\n            const body = stackLines.slice(1 + startIndex); // drop frames before `startIndex`\n            this.stack = [header, ...body].join('\\n');\n        }\n    }\n}\nexport const callStack = (msg) => {\n    if (!DEBUGGER.debug)\n        return undefined;\n    return new Stack(msg ?? 'Call Stack');\n};\n","/* MAIN */\nimport { Stack } from './methods/debugger.js';\nconst castArray = (value) => {\n    return isArray(value) ? value : [value];\n};\nconst castError = (error) => {\n    if (error instanceof Error)\n        return error;\n    if (typeof error === 'string')\n        return new Error(error);\n    return new Error('Unknown error');\n};\nconst { is } = Object;\nconst { isArray } = Array;\nconst isEqual = (a, b) => {\n    if (a.length !== b.length)\n        return false;\n    for (let i = 0, l = a.length; i < l; i++) {\n        const valueA = a[i];\n        const valueB = b[i];\n        if (!is(valueA, valueB))\n            return false;\n    }\n    return true;\n};\nconst isFunction = (value) => {\n    return typeof value === 'function';\n};\nconst isObject = (value) => {\n    return (value !== null) && (typeof value === 'object');\n};\nconst isSymbol = (value) => {\n    return typeof value === 'symbol';\n};\nconst noop = (stack, dispose) => {\n    return;\n};\nconst nope = () => {\n    return false;\n};\n/* EXPORT */\nexport { castArray, castError, is, isArray, isEqual, isFunction, isObject, isSymbol, noop, nope };\n","/* IMPORT */\nimport { SYMBOL_OBSERVABLE, SYMBOL_OBSERVABLE_FROZEN, SYMBOL_OBSERVABLE_READABLE, SYMBOL_OBSERVABLE_WRITABLE } from '../symbols.js';\nimport { isFunction } from '../utils.js';\n/* MAIN - FUNCTIONS */\nfunction frozenFunction() {\n    if (arguments.length) {\n        throw new Error('A readonly Observable can not be updated');\n    }\n    else {\n        return this;\n    }\n}\nfunction readableFunction() {\n    if (arguments.length) {\n        throw new Error('A readonly Observable can not be updated');\n    }\n    else {\n        return this.get();\n    }\n}\nfunction writableFunction(fn) {\n    if (arguments.length) {\n        if (isFunction(fn)) {\n            return this.update(fn);\n        }\n        else {\n            return this.set(fn); //TSC\n        }\n    }\n    else {\n        return this.get();\n    }\n}\n/* MAIN - GENERATORS */\nconst frozen = (value) => {\n    // value.stack = stack\n    const fn = frozenFunction.bind(value); //TSC\n    fn[SYMBOL_OBSERVABLE] = true;\n    fn[SYMBOL_OBSERVABLE_FROZEN] = true;\n    return fn;\n};\nconst readable = (value, stack) => {\n    //TODO: Make a frozen one instead if disposed\n    value.stack = stack;\n    const fn = readableFunction.bind(value); //TSC\n    fn[SYMBOL_OBSERVABLE] = true;\n    fn[SYMBOL_OBSERVABLE_READABLE] = value;\n    return fn;\n};\nconst writable = (value, stack) => {\n    value.stack = stack;\n    const fn = writableFunction.bind(value); //TSC\n    fn[SYMBOL_OBSERVABLE] = true;\n    fn[SYMBOL_OBSERVABLE_WRITABLE] = value;\n    return fn;\n};\n/* EXPORT */\nexport { frozen, readable, writable };\n","/* IMPORT */\nimport { frozen } from './objects/callable.js';\n/* MAIN */\nconst DIRTY_NO = 0; // The observer is not dirty, for sure\nconst DIRTY_MAYBE_NO = 1; // The observer is not dirty, possibly\nconst DIRTY_MAYBE_YES = 2; // The observer is dirty, possibly\nconst DIRTY_YES = 3; // The observer is dirty, for sure\nconst OBSERVABLE_FALSE = frozen(false);\nconst OBSERVABLE_TRUE = frozen(true);\nconst UNAVAILABLE = new Proxy({}, new Proxy({}, { get() { throw new Error('Unavailable value'); } })); //TSC\nconst UNINITIALIZED = function () { }; //TSC\n/* EXPORT */\nexport { DIRTY_NO, DIRTY_MAYBE_NO, DIRTY_MAYBE_YES, DIRTY_YES };\nexport { OBSERVABLE_FALSE, OBSERVABLE_TRUE };\nexport { UNAVAILABLE, UNINITIALIZED };\n","/* IMPORT */\n/* MAIN */\nconst lazyArrayEach = (arr, fn) => {\n    if (arr instanceof Array) {\n        for (let i = 0, l = arr.length; i < l; i++) {\n            fn(arr[i]);\n        }\n    }\n    else if (arr) {\n        fn(arr);\n    }\n};\nconst lazyArrayEachRight = (arr, fn) => {\n    if (arr instanceof Array) {\n        for (let i = arr.length - 1; i >= 0; i--) {\n            fn(arr[i]);\n        }\n    }\n    else if (arr) {\n        fn(arr);\n    }\n};\nconst lazyArrayPush = (obj, key, value) => {\n    const arr = obj[key];\n    if (arr instanceof Array) {\n        arr.push(value);\n    }\n    else if (arr) {\n        obj[key] = [arr, value];\n    }\n    else {\n        obj[key] = value;\n    }\n};\nconst lazySetAdd = (obj, key, value) => {\n    const set = obj[key];\n    if (set instanceof Set) {\n        set.add(value);\n    }\n    else if (set) {\n        if (value !== set) {\n            const s = new Set();\n            s.add(set);\n            s.add(value);\n            obj[key] = s;\n        }\n    }\n    else {\n        obj[key] = value;\n    }\n};\nconst lazySetDelete = (obj, key, value) => {\n    const set = obj[key];\n    if (set instanceof Set) {\n        set.delete(value);\n    }\n    else if (set === value) {\n        obj[key] = undefined;\n    }\n};\nconst lazySetEach = (set, fn) => {\n    if (set instanceof Set) {\n        for (const value of set) {\n            fn(value);\n        }\n    }\n    else if (set) {\n        fn(set);\n    }\n};\n/* EXPORT */\nexport { lazyArrayEach, lazyArrayEachRight, lazyArrayPush };\nexport { lazySetAdd, lazySetDelete, lazySetEach };\n","/* IMPORT */\nimport { UNAVAILABLE } from '../constants.js';\nimport { OBSERVER, OWNER, setObserver, setOwner } from '../context.js';\nimport { lazyArrayEachRight } from '../lazy.js';\nimport { castError } from '../utils.js';\nimport { callStack, Stack } from '../methods/debugger.js';\n/* HELPERS */\nconst onCleanup = (cleanup) => cleanup.call(cleanup, callStack());\nconst onDispose = (owner) => owner.dispose(true);\n/* MAIN */\n//TODO: Throw when registering stuff after disposing, maybe\nclass Owner {\n    constructor() {\n        /* VARIABLES */\n        this.disposed = false;\n        this.cleanups = undefined;\n        this.errorHandler = undefined;\n        this.contexts = undefined;\n        this.observers = undefined;\n        this.roots = undefined;\n        this.suspenses = undefined;\n    }\n    /* API */\n    catch(error, silent) {\n        const { errorHandler } = this;\n        if (errorHandler) {\n            errorHandler(error); //TODO: This assumes that the error handler won't throw immediately, which we know, but Owner shouldn't know\n            return true;\n        }\n        else {\n            if (this.parent?.catch(error, true))\n                return true;\n            if (silent)\n                return false;\n            // console.error ( error.stack ); // <-- Log \"error.stack\" to better understand where the error happened\n            throw error;\n        }\n    }\n    dispose(deep) {\n        lazyArrayEachRight(this.contexts, onDispose);\n        lazyArrayEachRight(this.observers, onDispose);\n        lazyArrayEachRight(this.suspenses, onDispose);\n        lazyArrayEachRight(this.cleanups, onCleanup);\n        this.cleanups = undefined;\n        this.disposed = deep;\n        this.errorHandler = undefined;\n        this.observers = undefined;\n        this.suspenses = undefined;\n    }\n    get(symbol) {\n        return this.context?.[symbol];\n    }\n    wrap(fn, owner, observer, stack) {\n        const ownerPrev = OWNER;\n        const observerPrev = OBSERVER;\n        setOwner(owner);\n        setObserver(observer);\n        try {\n            return fn(stack);\n        }\n        catch (error) {\n            this.catch(castError(error), false); // Bubbling the error up\n            return UNAVAILABLE; // Returning a value that is the least likely to cause bugs\n        }\n        finally {\n            setOwner(ownerPrev);\n            setObserver(observerPrev);\n        }\n    }\n}\n/* EXPORT */\nexport default Owner;\n","/* IMPORT */\nimport Owner from './owner.js';\n/* MAIN */\nclass SuperRoot extends Owner {\n    constructor() {\n        /* VARIABLES */\n        super(...arguments);\n        this.context = {};\n    }\n}\n/* EXPORT */\nexport default SuperRoot;\n","/* IMPORT */\nimport SuperRoot from './objects/superroot.js';\nimport { Stack } from './methods/debugger.js';\n/* MAIN - READ */\n// This module relies on live-binding of exported variables to avoid a bunch of property accesses\nlet BATCH;\nlet SUPER_OWNER = new SuperRoot();\nlet OBSERVER;\nlet OWNER = SUPER_OWNER;\n/* MAIN - WRITE */\n// Unfortunately live-bounded exports can't just be overridden, so we need these functions\nconst setBatch = (value) => BATCH = value;\nconst setObserver = (value) => OBSERVER = value;\nconst setOwner = (value) => OWNER = value;\n/* EXPORT */\nexport { BATCH, OBSERVER, OWNER, SUPER_OWNER };\nexport { setBatch, setObserver, setOwner };\n","/* IMPORT */\nimport { Stack } from '../methods/debugger.js';\n/* MAIN */\n// This ensures that there's only one flushing of the queue happening at the same time\nclass Scheduler {\n    constructor() {\n        /* VARIABLES */\n        this.waiting = [];\n        this.counter = 0;\n        this.locked = false;\n        /* QUEING API */\n        this.flush = () => {\n            if (this.locked)\n                return;\n            if (this.counter)\n                return;\n            if (!this.waiting.length)\n                return;\n            try {\n                this.locked = true;\n                while (true) {\n                    const queue = this.waiting;\n                    if (!queue.length)\n                        break;\n                    this.waiting = [];\n                    for (let i = 0, l = queue.length; i < l; i++) {\n                        queue[i][0].update(queue[i][1]);\n                    }\n                }\n            }\n            finally {\n                this.locked = false;\n            }\n        };\n        this.wrap = (fn) => {\n            this.counter += 1;\n            fn();\n            this.counter -= 1;\n            this.flush();\n        };\n        /* SCHEDULING API */\n        this.schedule = (observer, stack) => {\n            this.waiting.push([observer, stack]);\n        };\n    }\n}\n/* EXPORT */\nexport default new Scheduler();\n","/* IMPORT */\nimport { DIRTY_MAYBE_NO, DIRTY_YES, UNINITIALIZED } from '../constants.js';\nimport { OBSERVER } from '../context.js';\nimport Scheduler from './scheduler.sync.js';\nimport { is, nope } from '../utils.js';\nimport { callStack, Stack } from '../methods/debugger.js';\n/* MAIN */\nclass Observable {\n    /* CONSTRUCTOR */\n    constructor(value, options, parent) {\n        this.observers = new Set();\n        this.value = value;\n        if (parent) {\n            this.parent = parent;\n        }\n        if (options?.equals !== undefined) {\n            this.equals = options.equals || nope;\n        }\n    }\n    /* API */\n    get() {\n        if (!this.parent?.disposed) {\n            this.parent?.update(this.stack);\n            OBSERVER?.observables.link(this);\n        }\n        return this.value;\n    }\n    set(value) {\n        const equals = this.equals || is;\n        const fresh = (this.value === UNINITIALIZED) || !equals(value, this.value);\n        if (!fresh)\n            return value;\n        this.value = value;\n        this.stack = callStack();\n        Scheduler.counter += 1;\n        this.stale(DIRTY_YES, this.stack);\n        Scheduler.counter -= 1;\n        Scheduler.flush();\n        return value;\n    }\n    stale(status, stack) {\n        for (const observer of this.observers) {\n            if (observer.status !== DIRTY_MAYBE_NO || observer.observables.has(this)) { // Maybe this is a potential future dependency we haven't re-read yet\n                if (observer.sync) {\n                    observer.status = Math.max(observer.status, status);\n                    Scheduler.schedule(observer, stack);\n                }\n                else {\n                    observer.stale(status, stack);\n                }\n            }\n        }\n    }\n    update(fn, stack) {\n        const value = fn(this.value);\n        return this.set(value);\n    }\n}\n/* EXPORT */\nexport default Observable;\n","/* IMPORT */\nimport { Stack } from '../methods/debugger.js';\n/* MAIN */\n// Dedicated data structures for managing observables efficiently\n// We use an array if the list is small enough, as that's faster than a Set, and only switch to Sets after that\nclass ObservablesArray {\n    /* CONSTRUCTOR */\n    constructor(observer) {\n        this.observer = observer;\n        this.observables = [];\n        this.observablesIndex = 0;\n    }\n    /* API */\n    dispose(deep) {\n        if (deep) {\n            const { observer, observables } = this;\n            for (let i = 0; i < observables.length; i++) {\n                observables[i].observers.delete(observer);\n            }\n        }\n        this.observablesIndex = 0;\n    }\n    postdispose() {\n        const { observer, observables, observablesIndex } = this;\n        const observablesLength = observables.length;\n        if (observablesIndex < observablesLength) {\n            for (let i = observablesIndex; i < observablesLength; i++) {\n                observables[i].observers.delete(observer);\n            }\n            observables.length = observablesIndex;\n        }\n    }\n    empty() {\n        return !this.observables.length;\n    }\n    has(observable) {\n        const index = this.observables.indexOf(observable);\n        return index >= 0 && index < this.observablesIndex;\n    }\n    link(observable) {\n        const { observer, observables, observablesIndex } = this;\n        const observablesLength = observables.length;\n        if (observablesLength > 0) {\n            if (observables[observablesIndex] === observable) {\n                this.observablesIndex += 1;\n                return;\n            }\n            const index = observables.indexOf(observable);\n            if (index >= 0 && index < observablesIndex) {\n                return;\n            }\n            if (observablesIndex < observablesLength - 1) {\n                this.postdispose();\n            }\n            else if (observablesIndex === observablesLength - 1) {\n                observables[observablesIndex].observers.delete(observer);\n            }\n        }\n        observable.observers.add(observer);\n        observables[this.observablesIndex++] = observable;\n        if (observablesIndex === 128) { // Switching to a Set, as indexOf checks may get artbirarily expensive otherwise\n            observer.observables = new ObservablesSet(observer, observables);\n        }\n    }\n    update(stack) {\n        const { observables } = this;\n        for (let i = 0, l = observables.length; i < l; i++) {\n            observables[i].parent?.update(stack);\n        }\n    }\n}\nclass ObservablesSet {\n    /* CONSTRUCTOR */\n    constructor(observer, observables) {\n        this.observer = observer;\n        this.observables = new Set(observables);\n    }\n    /* API */\n    dispose(deep) {\n        for (const observable of this.observables) {\n            observable.observers.delete(this.observer);\n        }\n    }\n    postdispose() {\n        return;\n    }\n    empty() {\n        return !this.observables.size;\n    }\n    has(observable) {\n        return this.observables.has(observable);\n    }\n    link(observable) {\n        const { observer, observables } = this;\n        const sizePrev = observables.size;\n        observable.observers.add(observer);\n        const sizeNext = observables.size;\n        if (sizePrev === sizeNext)\n            return; // Cheaper than Set.has+Set.add\n        observables.add(observable);\n    }\n    update(stack) {\n        for (const observable of this.observables) {\n            observable.parent?.update(stack);\n        }\n    }\n}\n/* EXPORT */\nexport { ObservablesArray, ObservablesSet };\n","/* IMPORT */\nimport { DIRTY_NO, DIRTY_MAYBE_NO, DIRTY_MAYBE_YES, DIRTY_YES } from '../constants.js';\nimport { OWNER, SUPER_OWNER } from '../context.js';\nimport { lazyArrayPush } from '../lazy.js';\nimport { ObservablesArray, ObservablesSet } from './observables.js';\nimport Owner from './owner.js';\nimport { Stack } from '../methods/debugger.js';\n/* MAIN */\nclass Observer extends Owner {\n    /* CONSTRUCTOR */\n    constructor() {\n        super();\n        /* VARIABLES */\n        this.parent = OWNER;\n        this.context = OWNER.context;\n        this.status = DIRTY_YES;\n        this.observables = new ObservablesArray(this);\n        if (OWNER !== SUPER_OWNER) {\n            lazyArrayPush(this.parent, 'observers', this);\n        }\n    }\n    /* API */\n    dispose(deep) {\n        this.observables.dispose(deep);\n        super.dispose(deep);\n    }\n    refresh(fn, stack) {\n        this.dispose(false);\n        this.status = DIRTY_MAYBE_NO; // Resetting the trip flag, we didn't re-execute just yet\n        try {\n            return this.wrap(fn, this, this, stack);\n        }\n        finally {\n            this.observables.postdispose();\n        }\n    }\n    run(stack) {\n        throw new Error('Abstract method');\n    }\n    stale(status, stack) {\n        throw new Error('Abstract method');\n    }\n    update(stack) {\n        if (this.disposed)\n            return; // Disposed, it shouldn't be updated again\n        if (this.status === DIRTY_MAYBE_YES) { // Maybe we are dirty, let's check with our observables, to be sure\n            this.observables.update(stack);\n        }\n        if (this.status === DIRTY_YES) { // We are dirty, let's refresh\n            this.status = DIRTY_MAYBE_NO; // Trip flag, to be able to tell if we caused ourselves to be dirty again\n            this.run(stack);\n            if (this.status === DIRTY_MAYBE_NO) { // Not dirty anymore\n                this.status = DIRTY_NO;\n            }\n            else { // Maybe we are still dirty, let's check again\n                this.update(stack);\n            }\n        }\n        else { // Not dirty\n            this.status = DIRTY_NO;\n        }\n    }\n}\n/* EXPORT */\nexport default Observer;\n","/* IMPORT */\nimport { OWNER } from '../context.js';\nimport { lazyArrayPush } from '../lazy.js';\n/* MAIN */\nconst cleanup = (fn) => {\n    lazyArrayPush(OWNER, 'cleanups', fn);\n};\n/* EXPORT */\nexport default cleanup;\n","/* IMPORT */\nimport { OWNER } from '../context.js';\nimport { lazyArrayPush } from '../lazy.js';\nimport Owner from './owner.js';\nimport { Stack } from '../methods/debugger.js';\n/* MAIN */\nclass Context extends Owner {\n    /* CONSTRUCTOR */\n    constructor(context) {\n        super();\n        /* VARIABLES */\n        this.parent = OWNER;\n        this.context = { ...OWNER.context, ...context };\n        lazyArrayPush(this.parent, 'contexts', this);\n    }\n    /* API */\n    wrap(fn, owner, observer, stack) {\n        return super.wrap(fn, this, undefined, stack);\n    }\n}\n/* EXPORT */\nexport default Context;\n","/* IMPORT */\nimport { OWNER } from '../context.js';\nimport Context from '../objects/context.js';\nimport { isSymbol, noop } from '../utils.js';\nimport { callStack } from './debugger.js';\nfunction context(symbolOrContext, fn) {\n    if (isSymbol(symbolOrContext)) {\n        return OWNER.context[symbolOrContext];\n    }\n    else {\n        const stack = callStack();\n        return new Context(symbolOrContext).wrap(fn || noop, undefined, undefined, stack);\n    }\n}\n/* EXPORT */\nexport default context;\n","/* IMPORT */\nimport { BATCH } from '../context.js';\nimport { Stack } from '../methods/debugger.js';\n/* MAIN */\n// Using 2 microtasks to give a chance to things using 1 microtask (like refs in Voby) to run first\nclass Scheduler {\n    constructor() {\n        /* VARIABLES */\n        this.waiting = [];\n        this.locked = false;\n        this.queued = false;\n        /* QUEUING API */\n        this.flush = (stack) => {\n            if (this.locked)\n                return;\n            if (!this.waiting.length)\n                return;\n            try {\n                this.locked = true;\n                while (true) {\n                    const queue = this.waiting;\n                    if (!queue.length)\n                        break;\n                    this.waiting = [];\n                    for (let i = 0, l = queue.length; i < l; i++) {\n                        queue[i][0].update(queue[i][1]);\n                    }\n                }\n            }\n            finally {\n                this.locked = false;\n            }\n        };\n        this.queue = (stack) => {\n            if (this.queued)\n                return;\n            this.queued = true;\n            this.resolve(stack);\n        };\n        this.resolve = (stack) => {\n            queueMicrotask(() => {\n                queueMicrotask(() => {\n                    if (BATCH) {\n                        BATCH.finally(() => this.resolve(stack));\n                    }\n                    else {\n                        this.queued = false;\n                        this.flush(stack);\n                    }\n                });\n            });\n        };\n        /* SCHEDULING API */\n        this.schedule = (effect, stack) => {\n            this.waiting.push([effect, stack]);\n            this.queue(stack);\n        };\n    }\n}\n/* EXPORT */\nexport default new Scheduler();\n","/* IMPORT */\nimport { lazyArrayPush } from '../lazy.js';\nimport Observer from './observer.js';\nimport Scheduler from './scheduler.async.js';\nimport { SYMBOL_SUSPENSE } from '../symbols.js';\nimport { isFunction } from '../utils.js';\nimport { callStack, Stack } from '../methods/debugger.js';\n/* MAIN */\nclass Effect extends Observer {\n    /* CONSTRUCTOR */\n    constructor(fn, options) {\n        super();\n        this.fn = fn;\n        if (options?.suspense !== false) {\n            const suspense = this.get(SYMBOL_SUSPENSE);\n            if (suspense) {\n                this.suspense = suspense;\n            }\n        }\n        if (options?.sync === true) {\n            this.sync = true;\n        }\n        const { stack } = options ?? { stack: callStack('Effect init') };\n        if (options?.sync === 'init') {\n            this.init = true;\n            this.update(stack);\n        }\n        else {\n            this.schedule(stack);\n        }\n    }\n    /* API */\n    run(stack) {\n        const result = super.refresh(this.fn, stack);\n        if (isFunction(result)) {\n            lazyArrayPush(this, 'cleanups', result);\n        }\n    }\n    schedule(stack) {\n        if (this.suspense?.suspended)\n            return;\n        if (this.sync) {\n            this.update(stack);\n        }\n        else {\n            Scheduler.schedule(this, stack);\n        }\n    }\n    stale(status, stack) {\n        const statusPrev = this.status;\n        if (statusPrev >= status)\n            return;\n        this.status = status;\n        if (!this.sync || (statusPrev !== 2 && statusPrev !== 3)) { // It isn't currently executing, so let's schedule it\n            this.schedule(stack);\n        }\n    }\n    update(stack) {\n        if (this.suspense?.suspended)\n            return;\n        super.update(stack);\n    }\n}\n/* EXPORT */\nexport default Effect;\n","/* IMPORT */\nimport Effect from '../objects/effect.js';\nimport { Stack } from './debugger.js';\n/* MAIN */\nconst effect = (fn, options) => {\n    const effect = new Effect(fn, options);\n    const dispose = (stack) => effect.dispose(true);\n    return dispose;\n};\n/* EXPORT */\nexport default effect;\n","/* IMPORT */\nimport { SYMBOL_OBSERVABLE } from '../symbols.js';\nimport { isFunction } from '../utils.js';\n/* MAIN */\nconst isObservable = (value) => {\n    return isFunction(value) && (SYMBOL_OBSERVABLE in value);\n};\n/* EXPORT */\nexport default isObservable;\n","/* IMPORT */\nimport isObservable from './is_observable.js';\nimport { isFunction } from '../utils.js';\nfunction get(value, getFunction = true) {\n    const is = getFunction ? isFunction : isObservable;\n    if (is(value)) {\n        return value();\n    }\n    else {\n        return value;\n    }\n}\n/* EXPORT */\nexport default get;\n","/* IMPORT */\nimport { SYMBOL_STORE } from '../symbols.js';\nimport { isObject } from '../utils.js';\n/* MAIN */\nconst isStore = (value) => {\n    return isObject(value) && (SYMBOL_STORE in value);\n};\n/* EXPORT */\nexport default isStore;\n","/* IMPORT */\nimport { OBSERVER, setObserver } from '../context.js';\nimport { isFunction } from '../utils.js';\nfunction untrack(fn) {\n    if (isFunction(fn)) {\n        const observerPrev = OBSERVER;\n        if (observerPrev) {\n            try {\n                setObserver(undefined);\n                return fn();\n            }\n            finally {\n                setObserver(observerPrev);\n            }\n        }\n        else {\n            return fn();\n        }\n    }\n    else {\n        return fn;\n    }\n}\n/* EXPORT */\nexport default untrack;\n","/* IMPORT */\nimport { BATCH } from '../context.js';\nimport SchedulerAsync from '../objects/scheduler.async.js';\nimport SchedulerSync from '../objects/scheduler.sync.js';\n/* MAIN */\nconst isBatching = () => {\n    return !!BATCH || SchedulerAsync.queued || SchedulerAsync.locked || SchedulerSync.locked;\n};\n/* EXPORT */\nexport default isBatching;\n","/* IMPORT */\nimport { BATCH, OBSERVER } from '../context.js';\nimport { lazySetAdd, lazySetDelete, lazySetEach } from '../lazy.js';\nimport cleanup from './cleanup.js';\nimport effect from './effect.js';\nimport isBatching from './is_batching.js';\nimport isStore from './is_store.js';\nimport untrack from './untrack.js';\nimport { readable } from '../objects/callable.js';\nimport ObservableClass from '../objects/observable.js';\nimport { SYMBOL_STORE, SYMBOL_STORE_KEYS, SYMBOL_STORE_OBSERVABLE, SYMBOL_STORE_TARGET, SYMBOL_STORE_VALUES, SYMBOL_STORE_UNTRACKED } from '../symbols.js';\nimport { castArray, is, isArray, isFunction, isObject, noop, nope } from '../utils.js';\nimport { callStack, Stack } from './debugger.js';\n/* CLASSES */\nclass StoreMap extends Map {\n    insert(key, value) {\n        super.set(key, value);\n        return value;\n    }\n}\nclass StoreCleanable {\n    constructor() {\n        this.count = 0;\n    }\n    listen() {\n        this.count += 1;\n        cleanup(this);\n    }\n    call() {\n        this.count -= 1;\n        if (this.count)\n            return;\n        this.dispose();\n    }\n    dispose() { }\n}\nclass StoreKeys extends StoreCleanable {\n    constructor(parent, observable) {\n        super();\n        this.parent = parent;\n        this.observable = observable;\n    }\n    dispose() {\n        this.parent.keys = undefined;\n    }\n}\nclass StoreValues extends StoreCleanable {\n    constructor(parent, observable) {\n        super();\n        this.parent = parent;\n        this.observable = observable;\n    }\n    dispose() {\n        this.parent.values = undefined;\n    }\n}\nclass StoreHas extends StoreCleanable {\n    constructor(parent, key, observable) {\n        super();\n        this.parent = parent;\n        this.key = key;\n        this.observable = observable;\n    }\n    dispose() {\n        this.parent.has?.delete(this.key);\n    }\n}\nclass StoreProperty extends StoreCleanable {\n    constructor(parent, key, observable, node) {\n        super();\n        this.parent = parent;\n        this.key = key;\n        this.observable = observable;\n        this.node = node;\n    }\n    dispose() {\n        this.parent.properties?.delete(this.key);\n    }\n}\nconst StoreListenersRegular = {\n    /* VARIABLES */\n    active: 0,\n    listeners: new Set(),\n    nodes: new Set(),\n    /* API */\n    prepare: (stack) => {\n        const { listeners, nodes } = StoreListenersRegular;\n        const traversed = new Set();\n        const traverse = (node) => {\n            if (traversed.has(node))\n                return;\n            traversed.add(node);\n            lazySetEach(node.parents, traverse);\n            lazySetEach(node.listenersRegular, listener => {\n                listeners.add(listener);\n            });\n        };\n        nodes.forEach(traverse);\n        return () => {\n            listeners.forEach(listener => {\n                listener(stack);\n            });\n        };\n    },\n    register: (node, stack) => {\n        StoreListenersRegular.nodes.add(node);\n        StoreScheduler.schedule(stack);\n    },\n    reset: () => {\n        StoreListenersRegular.listeners = new Set();\n        StoreListenersRegular.nodes = new Set();\n    }\n};\nconst StoreListenersRoots = {\n    /* VARIABLES */\n    active: 0,\n    nodes: new Map(),\n    /* API */\n    prepare: () => {\n        const { nodes } = StoreListenersRoots;\n        return () => {\n            nodes.forEach((rootsSet, store) => {\n                const roots = Array.from(rootsSet);\n                lazySetEach(store.listenersRoots, listener => {\n                    listener(roots);\n                });\n            });\n        };\n    },\n    register: (store, root, stack) => {\n        const roots = StoreListenersRoots.nodes.get(store) || new Set();\n        roots.add(root);\n        StoreListenersRoots.nodes.set(store, roots);\n        StoreScheduler.schedule(stack);\n    },\n    registerWith: (current, parent, key, stack) => {\n        if (!parent.parents) {\n            const root = current?.store || untrack(() => parent.store[key]);\n            StoreListenersRoots.register(parent, root, stack);\n        }\n        else {\n            const traversed = new Set();\n            const traverse = (node) => {\n                if (traversed.has(node))\n                    return;\n                traversed.add(node);\n                lazySetEach(node.parents, parent => {\n                    if (!parent.parents) {\n                        StoreListenersRoots.register(parent, node.store, stack);\n                    }\n                    traverse(parent);\n                });\n            };\n            traverse(current || parent);\n        }\n    },\n    reset: () => {\n        StoreListenersRoots.nodes = new Map();\n    }\n};\nconst StoreScheduler = {\n    /* VARIABLES */\n    active: false,\n    /* API */\n    flush: (stack) => {\n        const flushRegular = StoreListenersRegular.prepare(stack);\n        const flushRoots = StoreListenersRoots.prepare();\n        StoreScheduler.reset();\n        flushRegular(stack);\n        flushRoots(stack);\n    },\n    flushIfNotBatching: (stack) => {\n        if (isBatching()) {\n            if (BATCH) {\n                BATCH.finally(() => StoreScheduler.flushIfNotBatching(stack));\n            }\n            else {\n                setTimeout(StoreScheduler.flushIfNotBatching, 0);\n            }\n        }\n        else {\n            StoreScheduler.flush(stack);\n        }\n    },\n    reset: () => {\n        StoreScheduler.active = false;\n        StoreListenersRegular.reset();\n        StoreListenersRoots.reset();\n    },\n    schedule: (stack) => {\n        if (StoreScheduler.active)\n            return;\n        StoreScheduler.active = true;\n        queueMicrotask(() => StoreScheduler.flushIfNotBatching(stack));\n    }\n};\n/* CONSTANTS */\nconst NODES = new WeakMap();\nconst SPECIAL_SYMBOLS = new Set([SYMBOL_STORE, SYMBOL_STORE_KEYS, SYMBOL_STORE_OBSERVABLE, SYMBOL_STORE_TARGET, SYMBOL_STORE_VALUES]);\nconst UNREACTIVE_KEYS = new Set(['__proto__', '__defineGetter__', '__defineSetter__', '__lookupGetter__', '__lookupSetter__', 'prototype', 'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toSource', 'toString', 'valueOf']);\nconst STORE_TRAPS = {\n    /* API */\n    get: (target, key) => {\n        const stack = callStack('store.get');\n        if (SPECIAL_SYMBOLS.has(key)) {\n            if (key === SYMBOL_STORE)\n                return true;\n            if (key === SYMBOL_STORE_TARGET)\n                return target;\n            if (key === SYMBOL_STORE_KEYS) {\n                if (isListenable()) {\n                    const node = getNodeExisting(target);\n                    node.keys || (node.keys = getNodeKeys(node));\n                    node.keys.listen();\n                    node.keys.observable.stack = stack;\n                    node.keys.observable.get();\n                }\n                return;\n            }\n            if (key === SYMBOL_STORE_VALUES) {\n                if (isListenable()) {\n                    const node = getNodeExisting(target);\n                    node.values || (node.values = getNodeValues(node));\n                    node.values.listen();\n                    node.values.observable.stack = stack;\n                    node.values.observable.get();\n                }\n                return;\n            }\n            if (key === SYMBOL_STORE_OBSERVABLE) {\n                return (key) => {\n                    key = (typeof key === 'number') ? String(key) : key;\n                    const node = getNodeExisting(target);\n                    const getter = node.getters?.get(key);\n                    if (getter)\n                        return getter.bind(node.store);\n                    node.properties || (node.properties = new StoreMap());\n                    const value = target[key];\n                    const property = node.properties.get(key) || node.properties.insert(key, getNodeProperty(node, key, value));\n                    const options = node.equals ? { equals: node.equals } : undefined;\n                    property.observable || (property.observable = getNodeObservable(node, value, options));\n                    const observable = readable(property.observable, stack);\n                    return observable;\n                };\n            }\n        }\n        if (UNREACTIVE_KEYS.has(key))\n            return target[key];\n        const node = getNodeExisting(target);\n        const getter = node.getters?.get(key);\n        const value = getter || target[key];\n        node.properties || (node.properties = new StoreMap());\n        const listenable = isListenable();\n        const proxiable = isProxiable(value);\n        const property = listenable || proxiable ? node.properties.get(key) || node.properties.insert(key, getNodeProperty(node, key, value)) : undefined;\n        if (property?.node) {\n            lazySetAdd(property.node, 'parents', node);\n        }\n        if (property && listenable) {\n            const options = node.equals ? { equals: node.equals } : undefined;\n            property.listen();\n            property.observable || (property.observable = getNodeObservable(node, value, options));\n            property.observable.stack = stack;\n            property.observable.get();\n        }\n        if (getter) {\n            return getter.call(node.store);\n        }\n        else {\n            if (typeof value === 'function' && value === Array.prototype[key]) {\n                return function () {\n                    return value.apply(node.store, arguments);\n                };\n            }\n            return property?.node?.store || value;\n        }\n    },\n    set: (target, key, value, stack) => {\n        value = getTarget(value);\n        const node = getNodeExisting(target);\n        const setter = node.setters?.get(key);\n        if (setter) {\n            setter.call(node.store, value);\n        }\n        else {\n            const targetIsArray = isArray(target);\n            const valuePrev = target[key];\n            const hadProperty = !!valuePrev || (key in target);\n            const equals = node.equals || is;\n            if (hadProperty && equals(value, valuePrev) && (key !== 'length' || !targetIsArray))\n                return true; // Array.prototype.length is special, it gets updated before this trap is called, we need to special-case it...\n            const lengthPrev = targetIsArray && target['length'];\n            target[key] = value;\n            const lengthNext = targetIsArray && target['length'];\n            if (targetIsArray && key !== 'length' && lengthPrev !== lengthNext) { // Inferring updating the length property, since it happens implicitly\n                node.properties?.get('length')?.observable?.set(lengthNext);\n            }\n            node.values?.observable.set(0);\n            if (!hadProperty) {\n                node.keys?.observable.set(0);\n                node.has?.get(key)?.observable.set(true);\n            }\n            const property = node.properties?.get(key);\n            if (property?.node) {\n                lazySetDelete(property.node, 'parents', node);\n            }\n            if (property) {\n                property.observable?.set(value);\n                property.node = isProxiable(value) ? NODES.get(value) || getNode(value, key, node) : undefined;\n            }\n            if (property?.node) {\n                lazySetAdd(property.node, 'parents', node);\n            }\n            if (StoreListenersRoots.active) {\n                StoreListenersRoots.registerWith(property?.node, node, key, stack);\n            }\n            if (StoreListenersRegular.active) {\n                StoreListenersRegular.register(node, stack);\n            }\n            if (targetIsArray && key === 'length') { // Inferring deleting keys, since it happens implicitly\n                const lengthPrev = Number(valuePrev);\n                const lengthNext = Number(value);\n                for (let i = lengthNext; i < lengthPrev; i++) {\n                    if (i in target)\n                        continue;\n                    STORE_TRAPS.deleteProperty(target, `${i}`, true);\n                }\n            }\n        }\n        return true;\n    },\n    deleteProperty: (target, key, _force) => {\n        const hasProperty = (key in target);\n        if (!_force && !hasProperty)\n            return true;\n        const deleted = Reflect.deleteProperty(target, key);\n        if (!deleted)\n            return false;\n        const node = getNodeExisting(target);\n        const stack = callStack();\n        node.getters?.delete(key);\n        node.setters?.delete(key);\n        node.keys?.observable.set(0);\n        node.values?.observable.set(0);\n        node.has?.get(key)?.observable.set(false);\n        const property = node.properties?.get(key);\n        if (StoreListenersRoots.active) {\n            StoreListenersRoots.registerWith(property?.node, node, key, stack);\n        }\n        if (property?.node) {\n            lazySetDelete(property.node, 'parents', node);\n        }\n        if (property) {\n            property.observable?.set(undefined);\n            property.node = undefined;\n        }\n        if (StoreListenersRegular.active) {\n            StoreListenersRegular.register(node, stack);\n        }\n        return true;\n    },\n    defineProperty: (target, key, descriptor) => {\n        const node = getNodeExisting(target);\n        const equals = node.equals || is;\n        const hadProperty = (key in target);\n        const descriptorPrev = Reflect.getOwnPropertyDescriptor(target, key);\n        const stack = callStack();\n        if ('value' in descriptor && isStore(descriptor.value)) {\n            descriptor = { ...descriptor, value: getTarget(descriptor.value) };\n        }\n        if (descriptorPrev && isEqualDescriptor(descriptorPrev, descriptor, equals))\n            return true;\n        const defined = Reflect.defineProperty(target, key, descriptor);\n        if (!defined)\n            return false;\n        if (!descriptor.get) {\n            node.getters?.delete(key);\n        }\n        else if (descriptor.get) {\n            node.getters || (node.getters = new StoreMap());\n            node.getters.set(key, descriptor.get);\n        }\n        if (!descriptor.set) {\n            node.setters?.delete(key);\n        }\n        else if (descriptor.set) {\n            node.setters || (node.setters = new StoreMap());\n            node.setters.set(key, descriptor.set);\n        }\n        if (hadProperty !== !!descriptor.enumerable) {\n            node.keys?.observable.set(0);\n        }\n        node.has?.get(key)?.observable.set(true);\n        const property = node.properties?.get(key);\n        if (StoreListenersRoots.active) {\n            StoreListenersRoots.registerWith(property?.node, node, key, stack);\n        }\n        if (property?.node) {\n            lazySetDelete(property.node, 'parents', node);\n        }\n        if (property) {\n            if ('get' in descriptor) {\n                property.observable?.set(descriptor.get);\n                property.node = undefined;\n            }\n            else {\n                const value = descriptor.value;\n                property.observable?.set(value);\n                property.node = isProxiable(value) ? NODES.get(value) || getNode(value, key, node) : undefined;\n            }\n        }\n        if (property?.node) {\n            lazySetAdd(property.node, 'parents', node);\n        }\n        if (StoreListenersRoots.active) {\n            StoreListenersRoots.registerWith(property?.node, node, key, stack);\n        }\n        if (StoreListenersRegular.active) {\n            StoreListenersRegular.register(node, stack);\n        }\n        return true;\n    },\n    has: (target, key) => {\n        if (key === SYMBOL_STORE)\n            return true;\n        if (key === SYMBOL_STORE_TARGET)\n            return true;\n        const value = (key in target);\n        if (isListenable()) {\n            const node = getNodeExisting(target);\n            node.has || (node.has = new StoreMap());\n            const has = node.has.get(key) || node.has.insert(key, getNodeHas(node, key, value));\n            has.listen();\n            has.observable.stack = callStack('store.has');\n            has.observable.get();\n        }\n        return value;\n    },\n    ownKeys: (target) => {\n        const keys = Reflect.ownKeys(target);\n        if (isListenable()) {\n            const node = getNodeExisting(target);\n            node.keys || (node.keys = getNodeKeys(node));\n            node.keys.listen();\n            node.keys.observable.stack = callStack('store.ownKeys');\n            node.keys.observable.get();\n        }\n        return keys;\n    }\n};\nconst STORE_UNTRACK_TRAPS = {\n    /* API */\n    has: (target, key) => {\n        if (key === SYMBOL_STORE_UNTRACKED)\n            return true;\n        return (key in target);\n    }\n};\n/* HELPERS */\nconst getNode = (value, key, parent, equals) => {\n    if (isStore(value))\n        return getNodeExisting(getTarget(value));\n    const store = isFrozenLike(value, key, parent) ? value : new Proxy(value, STORE_TRAPS);\n    const gettersAndSetters = getGettersAndSetters(value);\n    const node = { parents: parent, store };\n    if (gettersAndSetters) {\n        const { getters, setters } = gettersAndSetters;\n        if (getters)\n            node.getters = getters;\n        if (setters)\n            node.setters = setters;\n    }\n    if (equals === false) {\n        node.equals = nope;\n    }\n    else if (equals) {\n        node.equals = equals;\n    }\n    else if (parent?.equals) {\n        node.equals = parent.equals;\n    }\n    NODES.set(value, node);\n    return node;\n};\nconst getNodeExisting = (value) => {\n    const node = NODES.get(value);\n    if (!node)\n        throw new Error('Impossible');\n    return node;\n};\nconst getNodeFromStore = (store) => {\n    return getNodeExisting(getTarget(store));\n};\nconst getNodeKeys = (node) => {\n    const observable = getNodeObservable(node, 0, { equals: false });\n    const keys = new StoreKeys(node, observable);\n    return keys;\n};\nconst getNodeValues = (node) => {\n    const observable = getNodeObservable(node, 0, { equals: false });\n    const values = new StoreValues(node, observable);\n    return values;\n};\nconst getNodeHas = (node, key, value) => {\n    const observable = getNodeObservable(node, value);\n    const has = new StoreHas(node, key, observable);\n    return has;\n};\nconst getNodeObservable = (node, value, options) => {\n    return new ObservableClass(value, options);\n};\nconst getNodeProperty = (node, key, value) => {\n    const observable = undefined;\n    const propertyNode = isProxiable(value) ? NODES.get(value) || getNode(value, key, node) : undefined;\n    const property = new StoreProperty(node, key, observable, propertyNode);\n    node.properties || (node.properties = new StoreMap());\n    node.properties.set(key, property);\n    return property;\n};\nconst getGettersAndSetters = (value) => {\n    if (isArray(value))\n        return;\n    let getters;\n    let setters;\n    const keys = Object.keys(value);\n    for (let i = 0, l = keys.length; i < l; i++) {\n        const key = keys[i];\n        const descriptor = Object.getOwnPropertyDescriptor(value, key);\n        if (!descriptor)\n            continue;\n        const { get, set } = descriptor;\n        if (get) {\n            getters || (getters = new StoreMap());\n            getters.set(key, get);\n        }\n        if (set) {\n            setters || (setters = new StoreMap());\n            setters.set(key, set);\n        }\n        if (get && !set) { // This ensures that settings throws without first reading the getter, very cheaply\n            setters || (setters = new StoreMap());\n            setters.set(key, throwNoSetterError);\n        }\n    }\n    if (!getters && !setters)\n        return;\n    return { getters, setters };\n};\nconst getStore = (value, options) => {\n    if (isStore(value))\n        return value;\n    const node = NODES.get(value) || getNode(value, undefined, undefined, options?.equals);\n    return node.store;\n};\nconst getTarget = (value) => {\n    if (isStore(value))\n        return value[SYMBOL_STORE_TARGET];\n    return value;\n};\nconst getUntracked = (value) => {\n    if (!isObject(value))\n        return value;\n    if (isUntracked(value))\n        return value;\n    return new Proxy(value, STORE_UNTRACK_TRAPS);\n};\nconst isEqualDescriptor = (a, b, equals) => {\n    return (!!a.configurable === !!b.configurable && !!a.enumerable === !!b.enumerable && !!a.writable === !!b.writable && equals(a.value, b.value) && a.get === b.get && a.set === b.set);\n};\nconst isFrozenLike = (value, key, parent) => {\n    if (Object.isFrozen(value))\n        return true;\n    if (!parent || key === undefined)\n        return false;\n    const target = store.unwrap(parent.store);\n    const descriptor = Reflect.getOwnPropertyDescriptor(target, key);\n    if (descriptor?.configurable || descriptor?.writable)\n        return false;\n    return true;\n};\nconst isListenable = () => {\n    return !!OBSERVER;\n};\nconst isProxiable = (value) => {\n    if (value === null || typeof value !== 'object')\n        return false;\n    if (SYMBOL_STORE in value)\n        return true;\n    if (SYMBOL_STORE_UNTRACKED in value)\n        return false;\n    if (isArray(value))\n        return true;\n    const prototype = Object.getPrototypeOf(value);\n    if (prototype === null)\n        return true;\n    return (Object.getPrototypeOf(prototype) === null);\n};\nconst isUntracked = (value) => {\n    if (value === null || typeof value !== 'object')\n        return false;\n    return (SYMBOL_STORE_UNTRACKED in value);\n};\nconst throwNoSetterError = () => {\n    throw new TypeError('Cannot set property value of #<Object> which has only a getter');\n};\n/* MAIN */\n//TODO: Maybe have the \"on\" method trigger immediately too like \"$.on\", or maybe the other way around, which seems more flexible\n//TODO: Explore converting target values back to numbers (the Proxy always receives strings) whenever possible, to save memory\n//TODO: Implement \"_onRoots\" better, perhaps provding string paths instead, which should be more powerful\nconst store = (value, options) => {\n    if (!isObject(value))\n        return value;\n    if (isUntracked(value))\n        return value;\n    return getStore(value, options);\n};\n/* UTILITIES */\nstore.on = (target, listener) => {\n    /* VARIABLES */\n    const targets = isStore(target) ? [target] : castArray(target);\n    const selectors = targets.filter(isFunction);\n    const nodes = targets.filter(isStore).map(getNodeFromStore);\n    /* ON */\n    StoreListenersRegular.active += 1;\n    const stack = callStack();\n    const disposers = selectors.map(selector => {\n        let inited = false;\n        return effect((stack) => {\n            if (inited) {\n                StoreListenersRegular.listeners.add(listener);\n                StoreScheduler.schedule(stack);\n            }\n            inited = true;\n            selector();\n        }, { suspense: false, sync: true, stack });\n    });\n    nodes.forEach(node => {\n        lazySetAdd(node, 'listenersRegular', listener);\n    });\n    /* OFF */\n    return (stack) => {\n        StoreListenersRegular.active -= 1;\n        disposers.forEach(disposer => {\n            disposer(stack);\n        });\n        nodes.forEach(node => {\n            lazySetDelete(node, 'listenersRegular', listener);\n        });\n    };\n};\nstore._onRoots = (target, listener) => {\n    if (!isStore(target))\n        return noop;\n    const node = getNodeFromStore(target);\n    if (node.parents)\n        throw new Error('Only top-level stores are supported');\n    /* ON */\n    StoreListenersRoots.active += 1;\n    lazySetAdd(node, 'listenersRoots', listener);\n    /* OFF */\n    return () => {\n        StoreListenersRoots.active -= 1;\n        lazySetDelete(node, 'listenersRoots', listener);\n    };\n};\nstore.reconcile = (() => {\n    //TODO: Support getters, setters and symbols (symbols could be supported with Reflect.ownKeys, but that's like 2x slower)\n    const getType = (value) => {\n        if (isArray(value))\n            return 1;\n        if (isProxiable(value))\n            return 2;\n        return 0;\n    };\n    const reconcileOuter = (prev, next) => {\n        const uprev = getTarget(prev);\n        const unext = getTarget(next);\n        reconcileInner(prev, next);\n        const prevType = getType(uprev);\n        const nextType = getType(unext);\n        if (prevType === 1 || nextType === 1) {\n            prev.length = next.length;\n        }\n        return prev;\n    };\n    const reconcileInner = (prev, next) => {\n        const uprev = getTarget(prev);\n        const unext = getTarget(next);\n        const prevKeys = Object.keys(uprev);\n        const nextKeys = Object.keys(unext);\n        for (let i = 0, l = nextKeys.length; i < l; i++) {\n            const key = nextKeys[i];\n            const prevValue = uprev[key];\n            const nextValue = unext[key];\n            if (!is(prevValue, nextValue)) {\n                const prevType = getType(prevValue);\n                const nextType = getType(nextValue);\n                if (prevType && prevType === nextType) {\n                    reconcileInner(prev[key], nextValue);\n                    if (prevType === 1) {\n                        prev[key].length = nextValue.length;\n                    }\n                }\n                else {\n                    prev[key] = nextValue;\n                }\n            }\n            else if (prevValue === undefined && !(key in uprev)) {\n                prev[key] = undefined;\n            }\n        }\n        for (let i = 0, l = prevKeys.length; i < l; i++) {\n            const key = prevKeys[i];\n            if (!(key in unext)) {\n                delete prev[key];\n            }\n        }\n        return prev;\n    };\n    const reconcile = (prev, next) => {\n        return untrack(() => {\n            return reconcileOuter(prev, next);\n        });\n    };\n    return reconcile;\n})();\nstore.untrack = (value) => {\n    return getUntracked(value);\n};\nstore.unwrap = (value) => {\n    return getTarget(value);\n};\n/* EXPORT */\nexport default store;\n","/* IMPORT */\nimport { OBSERVER, OWNER } from '../context.js';\n/* MAIN */\nconst _with = () => {\n    const owner = OWNER;\n    const observer = OBSERVER;\n    return (fn, stack) => {\n        return owner.wrap(() => fn(stack), owner, observer, stack);\n    };\n};\n/* EXPORT */\nexport default _with;\n","\r\n/* IMPORT */\r\n\r\nimport { SYMBOL_OBSERVABLE, SYMBOL_OBSERVABLE_FROZEN, SYMBOL_OBSERVABLE_READABLE, SYMBOL_OBSERVABLE_WRITABLE, SYMBOL_UNCACHED, SYMBOL_UNTRACKED, SYMBOL_UNTRACKED_UNWRAPPED } from 'soby'\r\nimport type { ContextData, Context, DirectiveData } from './types'\r\n\r\n/* MAIN */\r\n\r\nconst CONTEXTS_DATA = new WeakMap<Context<any>, ContextData<any>>()\r\n\r\nconst DIRECTIVES: Record<symbol, DirectiveData<any>> = {}\r\n\r\nconst SYMBOL_SUSPENSE = Symbol('Suspense')\r\n\r\nconst SYMBOL_SUSPENSE_COLLECTOR = Symbol('Suspense.Collector')\r\n\r\nconst SYMBOL_TEMPLATE_ACCESSOR = Symbol('Template.Accessor')\r\n\r\nconst SYMBOLS_DIRECTIVES: Record<string, symbol> = {}\r\n\r\nexport const SYMBOL_CLONE = Symbol('CloneElement')\r\n\r\n/* EXPORT */\r\n\r\nexport { SYMBOL_OBSERVABLE, SYMBOL_OBSERVABLE_FROZEN, SYMBOL_OBSERVABLE_READABLE, SYMBOL_UNCACHED, SYMBOL_UNTRACKED, SYMBOL_UNTRACKED_UNWRAPPED, SYMBOL_OBSERVABLE_WRITABLE }\r\nexport { CONTEXTS_DATA, DIRECTIVES, SYMBOL_SUSPENSE, SYMBOL_SUSPENSE_COLLECTOR, SYMBOL_TEMPLATE_ACCESSOR, SYMBOLS_DIRECTIVES }\r\n","\r\n/* IMPORT */\r\n\r\nimport type { ComponentIntrinsicElement, FN } from '../types'\r\ndeclare const via\r\n\r\n/* MAIN */\r\n\r\nconst { createComment, createHTMLNode, createSVGNode, createText, createDocumentFragment, } = (() => {\r\n    if (typeof via !== 'undefined') {\r\n        const document = via.document\r\n\r\n        const createComment = document.createComment as any as FN<[any], Comment>\r\n        const createHTMLNode = document.createElement as any as FN<[ComponentIntrinsicElement], HTMLElement>\r\n        const createSVGNode = (name: string) => document.createElementNS('http://www.w3.org/2000/svg', name) as any as FN<[ComponentIntrinsicElement], SVGElement>\r\n        const createText = document.createTextNode as any as FN<[any], Text>\r\n        const createDocumentFragment = document.createDocumentFragment as any as FN<[], DocumentFragment>\r\n        return { createComment, createHTMLNode, createSVGNode, createText, createDocumentFragment, }\r\n    }\r\n    else {\r\n        const createComment = document.createComment.bind(document, '') as FN<[any], Comment>\r\n        const createHTMLNode = document.createElement.bind(document) as FN<[ComponentIntrinsicElement], HTMLElement>\r\n        const createSVGNode = document.createElementNS.bind(document, 'http://www.w3.org/2000/svg') as FN<[ComponentIntrinsicElement], Element>\r\n        const createText = document.createTextNode.bind(document) as FN<[any], Text>\r\n        const createDocumentFragment = document.createDocumentFragment.bind(document) as FN<[], DocumentFragment>\r\n        return { createComment, createHTMLNode, createSVGNode, createText, createDocumentFragment }\r\n    }\r\n})()\r\n/* EXPORT */\r\n\r\nexport { createComment, createHTMLNode, createSVGNode, createText, createDocumentFragment }\r\n","\r\n/* IMPORT */\r\n\r\nimport {SYMBOL_OBSERVABLE_FROZEN, SYMBOL_OBSERVABLE_READABLE, SYMBOL_TEMPLATE_ACCESSOR, SYMBOL_UNTRACKED, SYMBOL_UNTRACKED_UNWRAPPED} from '../constants';\r\nimport type {ComponentFunction, Falsy, TemplateActionProxy, Truthy} from '../types';\r\n\r\n/* MAIN */\r\n\r\nconst {assign} = Object;\r\n\r\nconst castArray = <T> ( value: T[] | T ): T[] => {\r\n\r\n  return isArray ( value ) ? value : [value];\r\n\r\n};\r\n\r\nconst castError = ( exception: unknown ): Error => {\r\n\r\n  if ( isError ( exception ) ) return exception;\r\n\r\n  if ( isString ( exception ) ) return new Error ( exception );\r\n\r\n  return new Error ( 'Unknown error' );\r\n\r\n};\r\n\r\nconst flatten = <T> ( arr: T[] ) => {\r\n\r\n  for ( let i = 0, l = arr.length; i < l; i++ ) {\r\n\r\n    if ( !isArray ( arr[i] ) ) continue;\r\n\r\n    return arr.flat ( Infinity );\r\n\r\n  }\r\n\r\n  return arr;\r\n\r\n};\r\n\r\nconst indexOf = (() => {\r\n\r\n  const _indexOf = Array.prototype.indexOf;\r\n\r\n  return <T> ( arr: ArrayLike<unknown>, value: T ): number => {\r\n\r\n    return _indexOf.call ( arr, value );\r\n\r\n  };\r\n\r\n})();\r\n\r\nconst {isArray} = Array;\r\n\r\nconst isBoolean = ( value: unknown ): value is boolean => {\r\n\r\n  return typeof value === 'boolean';\r\n\r\n};\r\n\r\nconst isComponent = ( value: unknown ): value is ComponentFunction => {\r\n\r\n  return isFunction ( value ) && ( SYMBOL_UNTRACKED_UNWRAPPED in value );\r\n\r\n};\r\n\r\nconst isError = ( value: unknown ): value is Error => {\r\n\r\n  return value instanceof Error;\r\n\r\n};\r\n\r\nconst isFalsy = <T> ( value: T ): value is Falsy<T> => {\r\n\r\n  return !value;\r\n\r\n};\r\n\r\nconst isFunction = ( value: unknown ): value is (( ...args: any[] ) => any) => {\r\n\r\n  return typeof value === 'function';\r\n\r\n};\r\n\r\nconst isFunctionReactive = ( value: Function ): boolean => {\r\n\r\n  return !( SYMBOL_UNTRACKED in value || SYMBOL_UNTRACKED_UNWRAPPED in value || SYMBOL_OBSERVABLE_FROZEN in value || value[ SYMBOL_OBSERVABLE_READABLE ]?.parent?.disposed );\r\n\r\n};\r\n\r\nconst isNil = ( value: unknown ): value is null | undefined => {\r\n\r\n  return value === null || value === undefined;\r\n\r\n};\r\n\r\nconst isNode = ( value: unknown ): value is Node => {\r\n\r\n  return value instanceof Node;\r\n\r\n};\r\n\r\nconst isObject = ( value: unknown ): value is object => {\r\n\r\n  return typeof value === 'object' && value !== null;\r\n\r\n};\r\n\r\nconst isPrimitive = (value: unknown): value is string | number | boolean | symbol | null | undefined | bigint => {\r\n  const t = typeof value;\r\n  return !(t === 'object' || t === 'function');\r\n};\r\n\r\nconst isPromise = ( value: unknown ): value is Promise<unknown> => {\r\n\r\n  return value instanceof Promise;\r\n\r\n};\r\n\r\nconst isString = ( value: unknown ): value is string => {\r\n\r\n  return typeof value === 'string';\r\n\r\n};\r\n\r\nconst isSVG = ( value: Element ): value is SVGElement => {\r\n\r\n  return !!value['isSVG'];\r\n\r\n};\r\n\r\nconst isSVGElement = (() => {\r\n\r\n  const svgRe = /^(t(ext$|s)|s[vwy]|g)|^set|tad|ker|p(at|s)|s(to|c$|ca|k)|r(ec|cl)|ew|us|f($|e|s)|cu|n[ei]|l[ty]|[GOP]/; //URL: https://regex101.com/r/Ck4kFp/1\r\n  const svgCache = {};\r\n\r\n  return ( element: string ): boolean => {\r\n\r\n    const cached = svgCache[element];\r\n\r\n    return ( cached !== undefined ) ? cached : ( svgCache[element] = !element.includes ( '-' ) && svgRe.test ( element ) );\r\n\r\n  };\r\n\r\n})();\r\n\r\nconst isTemplateAccessor = ( value: unknown ): value is TemplateActionProxy => {\r\n\r\n  return isFunction ( value ) && ( SYMBOL_TEMPLATE_ACCESSOR in value );\r\n\r\n};\r\n\r\nconst isTruthy = <T> ( value: T ): value is Truthy<T> => {\r\n\r\n  return !!value;\r\n\r\n};\r\n\r\nconst isVoidChild = ( value: unknown ): value is null | undefined | symbol | boolean => {\r\n\r\n  return value === null || value === undefined || typeof value === 'boolean' || typeof value === 'symbol';\r\n\r\n};\r\n\r\nconst noop = (): void => {\r\n\r\n  return;\r\n\r\n};\r\n\r\nconst once = <T> ( fn: () => T ): (() => T) => {\r\n\r\n  let called = false;\r\n  let result: T;\r\n\r\n  return (): T => {\r\n\r\n    if ( !called ) {\r\n\r\n      called = true;\r\n      result = fn ();\r\n\r\n    }\r\n\r\n    return result;\r\n\r\n  };\r\n\r\n};\r\n\r\nexport const isProxy = ( proxy ): proxy is typeof Proxy => {\r\n  return proxy == null ? false : !!proxy[ Symbol.for( \"__isProxy\" ) ];\r\n};\r\n\r\nexport const fixBigInt = ( v: any | bigint ) => typeof v === 'bigint' ? v + 'n' : v;\r\n\r\nexport const toArray = <T,> ( v: T | T[] ) => [ ...[ v ].flat( Infinity ) ] as T[];\r\n\r\n/* EXPORT */\r\n\r\nexport {assign, castArray, castError, flatten, indexOf, isArray, isBoolean, isComponent, isError, isFalsy, isFunction, isFunctionReactive, isNil, isNode, isObject, isPrimitive, isPromise, isString, isSVG, isSVGElement, isTemplateAccessor, isTruthy, isVoidChild, noop, once};","\r\n/* IMPORT */\r\n\r\nimport useEffect from '../hooks/use_effect'\r\nimport type { Disposer, EffectFunction, EffectOptions } from '../types'\r\nimport { Stack } from '../soby'\r\n\r\n/* HELPERS */\r\n\r\nconst options: EffectOptions = {\r\n  sync: 'init',\r\n  stack: undefined\r\n}\r\n\r\n/* MAIN */\r\n\r\n// This function exists for convenience, and to avoid creating unnecessary options objects\r\n\r\nconst useRenderEffect = (fn: EffectFunction, stack: Stack): Disposer => {\r\n\r\n  return useEffect(fn, { ...options, stack })\r\n\r\n}\r\n\r\n/* EXPORT */\r\n\r\nexport default useRenderEffect","\r\n/* IMPORT */\r\n\r\nimport {useCleanup} from '../hooks';\r\n\r\n/* MAIN */\r\n\r\nconst useCheapDisposed = (): (() => boolean) => {\r\n\r\n  let disposed = false;\r\n\r\n  const get = (): boolean => disposed;\r\n  const set = (): boolean => disposed = true;\r\n\r\n  useCleanup ( set );\r\n\r\n  return get;\r\n\r\n};\r\n\r\n/* EXPORT */\r\n\r\nexport default useCheapDisposed;","\r\n/* IMPORT */\r\n\r\nimport useCheapDisposed from '../hooks/use_cheap_disposed'\r\nimport { with as _with, Stack } from '../soby'\r\nimport type { Callback } from '../types'\r\n\r\n/* MAIN */\r\n\r\n//TODO: Maybe port this to soby\r\n//TODO: Maybe special-case this to use one shared mirotask per microtask\r\n\r\nconst useMicrotask = (fn: Callback, stack: Stack): void => {\r\n\r\n  const disposed = useCheapDisposed()\r\n  const runWithOwner = _with()\r\n\r\n  queueMicrotask(() => {\r\n\r\n    if (disposed()) return\r\n\r\n    runWithOwner(fn, stack)\r\n\r\n  })\r\n\r\n}\r\n\r\n/* EXPORT */\r\n\r\nexport default useMicrotask","\r\n/* IMPORT */\r\n\r\nimport {isString} from '../utils/lang';\r\n\r\n/* MAIN */\r\n\r\n// This function exists to optimize memory usage in some cases, where the classList API won't be touched without sacrificing performance\r\n\r\nconst classesToggle = ( element: HTMLElement, classes: string, force: null | undefined | boolean ): void => {\r\n\r\n  const {className} = element;\r\n\r\n  /* OPTIMIZED PATH */\r\n\r\n  if ( isString ( className ) ) {\r\n\r\n    if ( !className ) { // Optimized addition/deletion\r\n\r\n      if ( force ) { // Optimized addition\r\n\r\n        element.className = classes;\r\n\r\n        return;\r\n\r\n      } else { // Optimized deletion, nothing to do really\r\n\r\n        return;\r\n\r\n      }\r\n\r\n    } else if ( !force && className === classes ) { // Optimized deletion\r\n\r\n      element.className = '';\r\n\r\n      return;\r\n\r\n    }\r\n\r\n  }\r\n\r\n  /* REGULAR PATH */\r\n\r\n  if ( classes.includes ( ' ' ) ) {\r\n\r\n    classes.split ( ' ' ).forEach ( cls => {\r\n\r\n      if ( !cls.length ) return;\r\n\r\n      element.classList.toggle ( cls, !!force );\r\n\r\n    });\r\n\r\n  } else {\r\n\r\n    element.classList.toggle ( classes, !!force );\r\n\r\n  }\r\n\r\n};\r\n\r\n/* EXPORT */\r\n\r\nexport {classesToggle};","/**\r\n * ISC License\r\n *\r\n * Copyright (c) 2020, Andrea Giammarchi, @WebReflection\r\n *\r\n * Permission to use, copy, modify, and/or distribute this software for any\r\n * purpose with or without fee is hereby granted, provided that the above\r\n * copyright notice and this permission notice appear in all copies.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\n * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\n * AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\n * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\n * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE\r\n * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\n * PERFORMANCE OF THIS SOFTWARE.\r\n */\r\n\r\nimport { createComment } from \"./creators\"\r\n\r\n/* MAIN */\r\n\r\n// This is just a slightly customized version of udomdiff: with types, no accessor function and support for diffing unwrapped nodes\r\n\r\nconst dummyNode = createComment('')\r\nconst beforeDummyWrapper: [Node] = [dummyNode]\r\nconst afterDummyWrapper: [Node] = [dummyNode]\r\n\r\nconst diff = ( parent: Node, before: Node | Node[], after: Node | Node[], nextSibling: Node | null ): void => {\r\n  if ( before === after ) return;\r\n  if ( before instanceof Node ) {\r\n    if ( after instanceof Node ) {\r\n      if ( before.parentNode === parent ) { // Safety check, since setChildStatic may trigger this\r\n        parent.replaceChild ( after, before );\r\n        return;\r\n      } else {\r\n        //TODO: Optimize this branch too\r\n      }\r\n    }\r\n    beforeDummyWrapper[0] = before;\r\n    before = beforeDummyWrapper;\r\n  }\r\n  if ( after instanceof Node ) {\r\n    afterDummyWrapper[0] = after;\r\n    after = afterDummyWrapper;\r\n  }\r\n  const bLength = after.length;\r\n  let aEnd = before.length;\r\n  let bEnd = bLength;\r\n  let aStart = 0;\r\n  let bStart = 0;\r\n  let map: Map<any, any> | null = null;\r\n  let removable: Node | undefined;\r\n  while (aStart < aEnd || bStart < bEnd) {\r\n    // append head, tail, or nodes in between: fast path\r\n    if (aEnd === aStart) {\r\n      // we could be in a situation where the rest of nodes that\r\n      // need to be added are not at the end, and in such case\r\n      // the node to `insertBefore`, if the index is more than 0\r\n      // must be retrieved, otherwise it's gonna be the first item.\r\n      const node = bEnd < bLength ?\r\n        (bStart ?\r\n          (after[bStart - 1].nextSibling) :\r\n          after[bEnd - bStart]) :\r\n        nextSibling;\r\n      if (bStart < bEnd) {\r\n        // parent.insertBefore(after[bStart++], node);\r\n        if ( node ) {\r\n          ( node as ChildNode ).before.apply ( node, after.slice ( bStart, bEnd ) );\r\n        } else {\r\n          ( parent as ParentNode ).append.apply ( parent, after.slice ( bStart, bEnd ) );\r\n        }\r\n        bStart = bEnd;\r\n      }\r\n    }\r\n    // remove head or tail: fast path\r\n    else if (bEnd === bStart) {\r\n      while (aStart < aEnd) {\r\n        // remove the node only if it's unknown or not live\r\n        if (!map || !map.has(before[aStart])) {\r\n          removable = before[aStart];\r\n          if ( removable.parentNode === parent ) { // Safety check, since setChildStatic may trigger this\r\n            parent.removeChild(removable);\r\n          }\r\n        }\r\n        aStart++;\r\n      }\r\n    }\r\n    // same node: fast path\r\n    else if (before[aStart] === after[bStart]) {\r\n      aStart++;\r\n      bStart++;\r\n    }\r\n    // same tail: fast path\r\n    else if (before[aEnd - 1] === after[bEnd - 1]) {\r\n      aEnd--;\r\n      bEnd--;\r\n    }\r\n    // The once here single last swap \"fast path\" has been removed in v1.1.0\r\n    // https://github.com/WebReflection/udomdiff/blob/single-final-swap/esm/index.js#L69-L85\r\n    // reverse swap: also fast path\r\n    else if (\r\n      before[aStart] === after[bEnd - 1] &&\r\n      after[bStart] === before[aEnd - 1]\r\n    ) {\r\n      // this is a \"shrink\" operation that could happen in these cases:\r\n      // [1, 2, 3, 4, 5]\r\n      // [1, 4, 3, 2, 5]\r\n      // or asymmetric too\r\n      // [1, 2, 3, 4, 5]\r\n      // [1, 2, 3, 5, 6, 4]\r\n      const node = before[--aEnd].nextSibling;\r\n      parent.insertBefore(\r\n        after[bStart++],\r\n        before[aStart++].nextSibling\r\n      );\r\n      parent.insertBefore(after[--bEnd], node);\r\n      // mark the future index as identical (yeah, it's dirty, but cheap 👍)\r\n      // The main reason to do this, is that when a[aEnd] will be reached,\r\n      // the loop will likely be on the fast path, as identical to b[bEnd].\r\n      // In the best case scenario, the next loop will skip the tail,\r\n      // but in the worst one, this node will be considered as already\r\n      // processed, bailing out pretty quickly from the map index check\r\n      before[aEnd] = after[bEnd];\r\n    }\r\n    // map based fallback, \"slow\" path\r\n    else {\r\n      // the map requires an O(bEnd - bStart) operation once\r\n      // to store all future nodes indexes for later purposes.\r\n      // In the worst case scenario, this is a full O(N) cost,\r\n      // and such scenario happens at least when all nodes are different,\r\n      // but also if both first and last items of the lists are different\r\n      if (!map) {\r\n        map = new Map;\r\n        let i = bStart;\r\n        while (i < bEnd)\r\n          map.set(after[i], i++);\r\n      }\r\n      // if it's a future node, hence it needs some handling\r\n      if (map.has(before[aStart])) {\r\n        // grab the index of such node, 'cause it might have been processed\r\n        const index = map.get(before[aStart]);\r\n        // if it's not already processed, look on demand for the next LCS\r\n        if (bStart < index && index < bEnd) {\r\n          let i = aStart;\r\n          // counts the amount of nodes that are the same in the future\r\n          let sequence = 1;\r\n          while (++i < aEnd && i < bEnd && map.get(before[i]) === (index + sequence))\r\n            sequence++;\r\n          // effort decision here: if the sequence is longer than replaces\r\n          // needed to reach such sequence, which would brings again this loop\r\n          // to the fast path, prepend the difference before a sequence,\r\n          // and move only the future list index forward, so that aStart\r\n          // and bStart will be aligned again, hence on the fast path.\r\n          // An example considering aStart and bStart are both 0:\r\n          // a: [1, 2, 3, 4]\r\n          // b: [7, 1, 2, 3, 6]\r\n          // this would place 7 before 1 and, from that time on, 1, 2, and 3\r\n          // will be processed at zero cost\r\n          if (sequence > (index - bStart)) {\r\n            const node = before[aStart];\r\n            if (bStart < index) {\r\n              // parent.insertBefore(after[bStart++], node);\r\n              if ( node ) {\r\n                ( node as ChildNode ).before.apply ( node, after.slice ( bStart, index ) );\r\n              } else {\r\n                ( parent as ParentNode ).append.apply ( parent, after.slice ( bStart, index ) );\r\n              }\r\n              bStart = index;\r\n            }\r\n          }\r\n          // if the effort wasn't good enough, fallback to a replace,\r\n          // moving both source and target indexes forward, hoping that some\r\n          // similar node will be found later on, to go back to the fast path\r\n          else {\r\n            parent.replaceChild(\r\n              after[bStart++],\r\n              before[aStart++]\r\n            );\r\n          }\r\n        }\r\n        // otherwise move the source forward, 'cause there's nothing to do\r\n        else\r\n          aStart++;\r\n      }\r\n      // this node has no meaning in the future list, so it's more than safe\r\n      // to remove it, and check the next live node out instead, meaning\r\n      // that only the live list index should be forwarded\r\n      else {\r\n        removable = before[aStart++];\r\n        if ( removable.parentNode === parent ) { // Safety check, since setChildStatic may trigger this\r\n          parent.removeChild(removable);\r\n        }\r\n      }\r\n    }\r\n  }\r\n  beforeDummyWrapper[0] = dummyNode;\r\n  afterDummyWrapper[0] = dummyNode;\r\n};\r\n\r\n/* EXPORT */\r\n\r\nexport default diff;","\r\n/* IMPORT */\r\n\r\nimport type { FragmentNode, FragmentFragment, Fragment } from '../types'\r\n\r\n/* HELPERS */\r\n\r\nconst NOOP_CHILDREN: Node[] = []\r\n\r\n/* MAIN */\r\n\r\nexport const FragmentUtils = {\r\n\r\n  make: (): Fragment => {\r\n\r\n    return {\r\n      values: undefined,\r\n      length: 0\r\n    }\r\n\r\n  },\r\n\r\n  makeWithNode: (node: Node): FragmentNode => {\r\n\r\n    return {\r\n      values: node,\r\n      length: 1\r\n    }\r\n\r\n  },\r\n\r\n  makeWithFragment: (fragment: Fragment): FragmentFragment => {\r\n\r\n    return {\r\n      values: fragment,\r\n      fragmented: true,\r\n      length: 1\r\n    }\r\n\r\n  },\r\n\r\n  getChildrenFragmented: (thiz: Fragment, children: Node[] = []): Node[] => {\r\n\r\n    const { values, length } = thiz\r\n\r\n    if (!length) return children\r\n\r\n    if (values instanceof Array) {\r\n\r\n      for (let i = 0, l = values.length; i < l; i++) {\r\n\r\n        const value = values[i]\r\n\r\n        if (value instanceof Node) {\r\n\r\n          children.push(value)\r\n\r\n        } else {\r\n\r\n          FragmentUtils.getChildrenFragmented(value, children)\r\n\r\n        }\r\n\r\n      }\r\n\r\n    } else {\r\n\r\n      if (values instanceof Node) {\r\n\r\n        children.push(values)\r\n\r\n      } else {\r\n\r\n        FragmentUtils.getChildrenFragmented(values, children)\r\n\r\n      }\r\n\r\n    }\r\n\r\n    return children\r\n\r\n  },\r\n\r\n  getChildren: (thiz: Fragment): Node | Node[] => {\r\n\r\n    if (!thiz.length) return NOOP_CHILDREN\r\n\r\n    if (!thiz.fragmented) return thiz.values as any\r\n\r\n    if (thiz.length === 1) return FragmentUtils.getChildren(thiz.values)\r\n\r\n    return FragmentUtils.getChildrenFragmented(thiz)\r\n\r\n  },\r\n\r\n  pushFragment: (thiz: Fragment, fragment: Fragment): void => {\r\n\r\n    FragmentUtils.pushValue(thiz, fragment)\r\n\r\n    thiz.fragmented = true\r\n\r\n  },\r\n\r\n  pushNode: (thiz: Fragment, node: Node): void => {\r\n\r\n    FragmentUtils.pushValue(thiz, node)\r\n\r\n  },\r\n\r\n  pushValue: (thiz: Fragment, value: Node | Fragment): void => {\r\n\r\n    const { values, length } = thiz as any //TSC\r\n\r\n    if (length === 0) {\r\n\r\n      thiz.values = value\r\n\r\n    } else if (length === 1) {\r\n\r\n      thiz.values = [values, value]\r\n\r\n    } else {\r\n\r\n      values.push(value)\r\n\r\n    }\r\n\r\n    thiz.length += 1\r\n\r\n  },\r\n\r\n  replaceWithNode: (thiz: Fragment, node: Node): void => {\r\n\r\n    thiz.values = node\r\n    delete thiz.fragmented\r\n    thiz.length = 1\r\n\r\n  },\r\n\r\n  replaceWithFragment: (thiz: Fragment, fragment: Fragment): void => {\r\n\r\n    thiz.values = fragment.values\r\n    thiz.fragmented = fragment.fragmented\r\n    thiz.length = fragment.length\r\n\r\n  }\r\n\r\n}\r\n\r\n","\r\n/* IMPORT */\r\n\r\nimport { SYMBOL_OBSERVABLE_READABLE, SYMBOL_UNCACHED, SYMBOL_OBSERVABLE_WRITABLE } from '../constants'\r\nimport isObservable from '../methods/is_observable'\r\nimport useRenderEffect from '../hooks/use_render_effect'\r\nimport $$ from '../methods/SS'\r\nimport { createText } from '../utils/creators'\r\nimport { isArray, isFunction, isFunctionReactive, isString } from '../utils/lang'\r\nimport type { Classes, ObservableMaybe, Styles } from '../types'\r\nimport { Stack } from '../soby'\r\n\r\n/* MAIN */\r\n\r\nconst resolveChild = <T>(value: ObservableMaybe<T>, setter: ((value: T | T[], dynamic: boolean, stack: Stack) => void), _dynamic: boolean = false, stack: Stack): void => {\r\n\r\n  if (isFunction(value)) {\r\n\r\n    if (!isFunctionReactive(value)) {\r\n\r\n      if (value[SYMBOL_OBSERVABLE_READABLE] ?? value[SYMBOL_OBSERVABLE_WRITABLE])\r\n        (value[SYMBOL_OBSERVABLE_READABLE] ?? value[SYMBOL_OBSERVABLE_WRITABLE]).stack = stack\r\n\r\n      resolveChild(value(), setter, _dynamic, stack)\r\n\r\n    } else {\r\n\r\n      useRenderEffect((stack) => {\r\n\r\n        if (value[SYMBOL_OBSERVABLE_READABLE] ?? value[SYMBOL_OBSERVABLE_WRITABLE])\r\n          (value[SYMBOL_OBSERVABLE_READABLE] ?? value[SYMBOL_OBSERVABLE_WRITABLE]).stack = stack\r\n\r\n        resolveChild(value(), setter, true, stack)\r\n\r\n      }, stack)\r\n\r\n    }\r\n\r\n  } else if (isArray(value)) {\r\n\r\n    const [values, hasObservables] = resolveArraysAndStatics(value)\r\n\r\n    values[SYMBOL_UNCACHED] = value[SYMBOL_UNCACHED] // Preserving this special symbol\r\n\r\n    setter(values, hasObservables || _dynamic, stack)\r\n\r\n  } else {\r\n\r\n    setter(value, _dynamic, stack)\r\n\r\n  }\r\n\r\n}\r\n\r\nconst resolveClass = (classes: Classes, resolved: Record<string, true> = {}): Record<string, true> => {\r\n\r\n  if (isString(classes)) {\r\n\r\n    classes.split(/\\s+/g).filter(Boolean).filter(cls => {\r\n\r\n      resolved[cls] = true\r\n\r\n    })\r\n\r\n  } else if (isFunction(classes)) {\r\n\r\n    resolveClass(classes(), resolved)\r\n\r\n  } else if (isArray(classes)) {\r\n\r\n    classes.forEach(cls => {\r\n\r\n      resolveClass(cls as Classes, resolved) //TSC\r\n\r\n    })\r\n\r\n  } else if (classes) {\r\n\r\n    for (const key in classes) {\r\n\r\n      const value = classes[key]\r\n      const isActive = !!$$(value)\r\n\r\n      if (!isActive) continue\r\n\r\n      resolved[key] = true\r\n\r\n    }\r\n\r\n  }\r\n\r\n  return resolved\r\n\r\n}\r\n\r\nconst resolveStyle = (styles: Styles, resolved: Record<string, null | undefined | number | string> | string = {}): Record<string, null | undefined | number | string> | string => {\r\n\r\n  if (isString(styles)) { //TODO: split into the individual styles, to be able to merge them with other styles\r\n\r\n    return styles\r\n\r\n  } else if (isFunction(styles)) {\r\n\r\n    return resolveStyle(styles(), resolved)\r\n\r\n  } else if (isArray(styles)) {\r\n\r\n    styles.forEach(style => {\r\n\r\n      resolveStyle(style as Styles, resolved) //TSC\r\n\r\n    })\r\n\r\n  } else if (styles) {\r\n\r\n    for (const key in styles) {\r\n\r\n      const value = styles[key]\r\n\r\n      resolved[key] = $$(value)\r\n\r\n    }\r\n\r\n  }\r\n\r\n  return resolved\r\n\r\n}\r\n\r\nconst resolveArraysAndStatics = (() => {\r\n\r\n  // This function does 3 things:\r\n  // 1. It deeply flattens the array, only if actually needed though (!)\r\n  // 2. It resolves statics, it's important to resolve them soon enough or they will be re-created multiple times (!)\r\n  // 3. It checks if we found any Observables along the way, avoiding looping over the array another time in the future\r\n\r\n  const DUMMY_RESOLVED = []\r\n\r\n  const resolveArraysAndStaticsInner = (values: any[], resolved: any[], hasObservables: boolean): [any[], boolean] => {\r\n\r\n    for (let i = 0, l = values.length; i < l; i++) {\r\n\r\n      const value = values[i]\r\n      const type = typeof value\r\n\r\n      if (type === 'string' || type === 'number' || type === 'bigint') { // Static\r\n\r\n        if (resolved === DUMMY_RESOLVED) resolved = values.slice(0, i)\r\n\r\n        resolved.push(createText(value))\r\n\r\n      } else if (type === 'object' && isArray(value)) { // Array\r\n\r\n        if (resolved === DUMMY_RESOLVED) resolved = values.slice(0, i)\r\n\r\n        hasObservables = resolveArraysAndStaticsInner(value, resolved, hasObservables)[1]\r\n\r\n      } else if (type === 'function' && isObservable(value)) { // Observable\r\n\r\n        if (resolved !== DUMMY_RESOLVED) resolved.push(value)\r\n\r\n        hasObservables = true\r\n\r\n      } else { // Something else\r\n\r\n        if (resolved !== DUMMY_RESOLVED) resolved.push(value)\r\n\r\n      }\r\n\r\n    }\r\n\r\n    if (resolved === DUMMY_RESOLVED) resolved = values\r\n\r\n    return [resolved, hasObservables]\r\n\r\n  }\r\n\r\n  return (values: any[]): [any[], boolean] => {\r\n\r\n    return resolveArraysAndStaticsInner(values, DUMMY_RESOLVED, false)\r\n\r\n  }\r\n\r\n})()\r\n\r\n/* EXPORT */\r\n\r\nexport { resolveChild, resolveClass, resolveArraysAndStatics, resolveStyle }","\r\n/* IMPORT */\r\n\r\nimport { DIRECTIVES, SYMBOLS_DIRECTIVES, SYMBOL_UNCACHED } from '../constants'\r\nimport useMicrotask from '../hooks/use_microtask'\r\nimport useRenderEffect from '../hooks/use_render_effect'\r\nimport isStore from '../methods/is_store'\r\nimport $$ from '../methods/SS'\r\nimport store from '../methods/store'\r\nimport untrack from '../methods/untrack'\r\nimport { context, with as _with } from '../soby'\r\nimport { SYMBOL_STORE_OBSERVABLE } from '../soby'\r\nimport { classesToggle } from '../utils/classlist'\r\nimport { createText, createComment } from '../utils/creators'\r\nimport diff from '../utils/diff'\r\nimport { FragmentUtils } from '../utils/fragment'\r\nimport { castArray, flatten, isArray, isBoolean, isFunction, isFunctionReactive, isNil, isString, isSVG, isTemplateAccessor, isVoidChild } from '../utils/lang'\r\nimport { resolveChild, resolveClass, resolveStyle } from '../utils/resolvers'\r\nimport type { Child, Classes, DirectiveData, EventListener, Fragment, FunctionMaybe, ObservableMaybe, Ref, TemplateActionProxy } from '../types'\r\nimport { Stack } from '../soby'\r\n\r\n/* MAIN */\r\n\r\nconst setAttributeStatic = (() => {\r\n\r\n    const attributesBoolean = new Set(['allowfullscreen', 'async', 'autofocus', 'autoplay', 'checked', 'controls', 'default', 'disabled', 'formnovalidate', 'hidden', 'indeterminate', 'ismap', 'loop', 'multiple', 'muted', 'nomodule', 'novalidate', 'open', 'playsinline', 'readonly', 'required', 'reversed', 'seamless', 'selected'])\r\n    const attributeCamelCasedRe = /e(r[HRWrv]|[Vawy])|Con|l(e[Tcs]|c)|s(eP|y)|a(t[rt]|u|v)|Of|Ex|f[XYa]|gt|hR|d[Pg]|t[TXYd]|[UZq]/ //URL: https://regex101.com/r/I8Wm4S/1\r\n    const attributesCache: Record<string, string> = {}\r\n    const uppercaseRe = /[A-Z]/g\r\n\r\n    const normalizeKeySvg = (key: string): string => {\r\n\r\n        return attributesCache[key] || (attributesCache[key] = attributeCamelCasedRe.test(key) ? key : key.replace(uppercaseRe, char => `-${char.toLowerCase()}`))\r\n\r\n    }\r\n\r\n    return (element: HTMLElement, key: string, value: null | undefined | boolean | number | string): void => {\r\n\r\n        if (isSVG(element)) {\r\n\r\n            key = (key === 'xlinkHref' || key === 'xlink:href') ? 'href' : normalizeKeySvg(key)\r\n\r\n            if (isNil(value) || (value === false && attributesBoolean.has(key))) {\r\n\r\n                element.removeAttribute(key)\r\n\r\n            } else {\r\n\r\n                element.setAttribute(key, String(value))\r\n\r\n            }\r\n\r\n        } else {\r\n\r\n            if (isNil(value) || (value === false && attributesBoolean.has(key))) {\r\n\r\n                element.removeAttribute(key)\r\n\r\n            } else {\r\n\r\n                value = (value === true) ? '' : String(value)\r\n\r\n                element.setAttribute(key, value)\r\n\r\n            }\r\n\r\n        }\r\n\r\n    }\r\n\r\n})()\r\n\r\nconst setAttribute = (element: HTMLElement, key: string, value: FunctionMaybe<null | undefined | boolean | number | string>, stack: Stack): void => {\r\n\r\n    if (isFunction(value) && isFunctionReactive(value)) {\r\n\r\n        useRenderEffect(() => {\r\n\r\n            setAttributeStatic(element, key, value())\r\n\r\n        }, stack)\r\n\r\n    } else {\r\n\r\n        setAttributeStatic(element, key, $$(value))\r\n\r\n    }\r\n\r\n}\r\n\r\nconst setChildReplacementFunction = (parent: HTMLElement, fragment: Fragment, child: (() => Child), stack: Stack): void => {\r\n\r\n    useRenderEffect((stack) => {\r\n\r\n        let valueNext = child()\r\n\r\n        while (isFunction(valueNext)) {\r\n\r\n            valueNext = valueNext()\r\n\r\n        }\r\n\r\n        setChildStatic(parent, fragment, false, valueNext, true, stack)\r\n\r\n    }, stack)\r\n\r\n}\r\n\r\nconst setChildReplacementText = (child: string, childPrev: Node): Node => {\r\n\r\n    if (childPrev.nodeType === 3) {\r\n\r\n        childPrev.nodeValue = child\r\n\r\n        return childPrev\r\n\r\n    } else {\r\n\r\n        const parent = childPrev.parentElement\r\n\r\n        if (!parent) throw new Error('Invalid child replacement')\r\n\r\n        const textNode = createText(child)\r\n\r\n        parent.replaceChild(textNode, childPrev)\r\n\r\n        return textNode\r\n\r\n    }\r\n\r\n}\r\n\r\nconst setChildReplacement = (child: Child, childPrev: Node, stack: Stack): void => {\r\n\r\n    const type = typeof child\r\n\r\n    if (type === 'string' || type === 'number' || type === 'bigint') {\r\n\r\n        setChildReplacementText(String(child), childPrev)\r\n\r\n    } else {\r\n\r\n        const parent = childPrev.parentElement\r\n\r\n        if (!parent) throw new Error('Invalid child replacement')\r\n\r\n        const fragment = FragmentUtils.makeWithNode(childPrev)\r\n\r\n        if (type === 'function') {\r\n\r\n            setChildReplacementFunction(parent, fragment, child as (() => Child), stack) //TSC\r\n\r\n        } else {\r\n\r\n            setChild(parent, child, fragment, stack)\r\n\r\n        }\r\n\r\n    }\r\n\r\n}\r\n\r\nconst setChildStatic = (parent: HTMLElement, fragment: Fragment, fragmentOnly: boolean, child: Child, dynamic: boolean, stack: Stack): void => {\r\n\r\n    if (!dynamic && isVoidChild(child)) return // Ignoring static undefined children, avoiding inserting some useless placeholder nodes\r\n\r\n    const prev = FragmentUtils.getChildren(fragment)\r\n    const prevIsArray = (prev instanceof Array)\r\n    const prevLength = prevIsArray ? prev.length : 1\r\n    const prevFirst = prevIsArray ? prev[0] : prev\r\n    const prevLast = prevIsArray ? prev[prevLength - 1] : prev\r\n    const prevSibling = prevLast?.nextSibling || null\r\n\r\n    if (prevLength === 0) { // Fast path for appending a node the first time\r\n\r\n        const type = typeof child\r\n\r\n        if (type === 'string' || type === 'number' || type === 'bigint') {\r\n\r\n            const textNode = createText(child)\r\n\r\n            if (!fragmentOnly) {\r\n\r\n                parent.appendChild(textNode)\r\n\r\n            }\r\n\r\n            FragmentUtils.replaceWithNode(fragment, textNode)\r\n\r\n            return\r\n\r\n        } else if (type === 'object' && child !== null && typeof (child as Node).nodeType === 'number') { //TSC\r\n\r\n            const node = child as Node\r\n\r\n            if (!fragmentOnly) {\r\n\r\n                parent.insertBefore(node, null)\r\n\r\n            }\r\n\r\n            FragmentUtils.replaceWithNode(fragment, node)\r\n\r\n            return\r\n\r\n        }\r\n\r\n    }\r\n\r\n    if (prevLength === 1) { // Fast path for single text child\r\n\r\n        const type = typeof child\r\n\r\n        if (type === 'string' || type === 'number' || type === 'bigint') {\r\n\r\n            const node = setChildReplacementText(String(child), prevFirst) //TODO: maybe \"fragmentOnly\" should be passed on here, but it seems unnecessary\r\n\r\n            FragmentUtils.replaceWithNode(fragment, node)\r\n\r\n            return\r\n\r\n        }\r\n\r\n    }\r\n\r\n    const fragmentNext = FragmentUtils.make()\r\n\r\n    const children = (Array.isArray(child) ? child : [child]) as Node[] //TSC\r\n\r\n    for (let i = 0, l = children.length; i < l; i++) {\r\n\r\n        const child = children[i]\r\n        const type = typeof child\r\n\r\n        if (type === 'string' || type === 'number' || type === 'bigint') {\r\n\r\n            FragmentUtils.pushNode(fragmentNext, createText(child))\r\n\r\n        } else if (type === 'object' && child !== null && typeof child.nodeType === 'number') {\r\n\r\n            FragmentUtils.pushNode(fragmentNext, child)\r\n\r\n        } else if (type === 'function') {\r\n\r\n            const fragment = FragmentUtils.make()\r\n\r\n            let childFragmentOnly = !fragmentOnly // Avoiding mutating the DOM immediately, letting the parent handle it\r\n\r\n            FragmentUtils.pushFragment(fragmentNext, fragment)\r\n\r\n            resolveChild(child, (child, dynamic, stack) => {\r\n\r\n                const fragmentOnly = childFragmentOnly\r\n\r\n                childFragmentOnly = false\r\n\r\n                setChildStatic(parent, fragment, fragmentOnly, child, dynamic, stack)\r\n\r\n            }, false, stack)\r\n\r\n        }\r\n\r\n    }\r\n\r\n    let next = FragmentUtils.getChildren(fragmentNext)\r\n    let nextLength = fragmentNext.length\r\n\r\n    if (nextLength === 0 && prevLength === 1 && prevFirst.nodeType === 8) { // It's a placeholder already, no need to replace it\r\n\r\n        return\r\n\r\n    }\r\n\r\n    if (!fragmentOnly && (nextLength === 0 || (prevLength === 1 && prevFirst.nodeType === 8) || children[SYMBOL_UNCACHED])) { // Fast path for removing all children and/or replacing the placeholder\r\n\r\n        const { childNodes } = parent\r\n\r\n        if (childNodes.length === prevLength) { // Maybe this fragment doesn't handle all children but only a range of them, checking for that here\r\n\r\n            parent.textContent = ''\r\n\r\n            if (nextLength === 0) { // Placeholder, to keep the right spot in the array of children\r\n\r\n                const placeholder = createComment('')\r\n\r\n                FragmentUtils.pushNode(fragmentNext, placeholder)\r\n\r\n                if (next !== fragmentNext.values) {\r\n\r\n                    next = placeholder\r\n                    nextLength += 1\r\n\r\n                }\r\n\r\n            }\r\n\r\n            if (prevSibling) {\r\n\r\n                if (next instanceof Array) {\r\n\r\n                    prevSibling.before.apply(prevSibling, next)\r\n\r\n                } else {\r\n\r\n                    parent.insertBefore(next, prevSibling)\r\n\r\n                }\r\n\r\n            } else {\r\n\r\n                if (next instanceof Array) {\r\n\r\n                    parent.append.apply(parent, next)\r\n\r\n                } else {\r\n\r\n                    parent.append(next)\r\n\r\n                }\r\n\r\n            }\r\n\r\n            FragmentUtils.replaceWithFragment(fragment, fragmentNext)\r\n\r\n            return\r\n\r\n        }\r\n\r\n    }\r\n\r\n    if (nextLength === 0) { // Placeholder, to keep the right spot in the array of children\r\n\r\n        const placeholder = createComment('')\r\n\r\n        FragmentUtils.pushNode(fragmentNext, placeholder)\r\n\r\n        if (next !== fragmentNext.values) {\r\n\r\n            next = placeholder\r\n            nextLength += 1\r\n\r\n        }\r\n\r\n    }\r\n\r\n    if (!fragmentOnly) {\r\n\r\n        diff(parent, prev, next, prevSibling)\r\n\r\n    }\r\n\r\n    FragmentUtils.replaceWithFragment(fragment, fragmentNext)\r\n\r\n}\r\n\r\nconst setChild = (parent: HTMLElement, child: Child, fragment: Fragment = FragmentUtils.make(), stack: Stack): void => {\r\n\r\n    resolveChild(child, setChildStatic.bind(undefined, parent, fragment, false), false, stack)\r\n\r\n}\r\n\r\nconst setClassStatic = classesToggle\r\n\r\nconst setClass = (element: HTMLElement, key: string, value: FunctionMaybe<null | undefined | boolean>, stack: Stack): void => {\r\n\r\n    if (isFunction(value) && isFunctionReactive(value)) {\r\n\r\n        useRenderEffect(() => {\r\n\r\n            setClassStatic(element, key, value())\r\n\r\n        }, stack)\r\n\r\n    } else {\r\n\r\n        setClassStatic(element, key, $$(value))\r\n\r\n    }\r\n\r\n}\r\n\r\nconst setClassBooleanStatic = (element: HTMLElement, value: boolean, key: null | undefined | boolean | string, keyPrev?: null | undefined | boolean | string): void => {\r\n\r\n    if (keyPrev && keyPrev !== true) {\r\n\r\n        setClassStatic(element, keyPrev, false)\r\n\r\n    }\r\n\r\n    if (key && key !== true) {\r\n\r\n        setClassStatic(element, key, value)\r\n\r\n    }\r\n\r\n}\r\n\r\nconst setClassBoolean = (element: HTMLElement, value: boolean, key: FunctionMaybe<null | undefined | boolean | string>, stack: Stack): void => {\r\n\r\n    if (isFunction(key) && isFunctionReactive(key)) {\r\n\r\n        let keyPrev: null | undefined | boolean | string\r\n\r\n        useRenderEffect(() => {\r\n\r\n            const keyNext = key()\r\n\r\n            setClassBooleanStatic(element, value, keyNext, keyPrev)\r\n\r\n            keyPrev = keyNext\r\n\r\n        }, stack)\r\n\r\n    } else {\r\n\r\n        setClassBooleanStatic(element, value, $$(key))\r\n\r\n    }\r\n\r\n}\r\n\r\nconst setClassesStatic = (element: HTMLElement, object: null | undefined | string | FunctionMaybe<null | undefined | boolean | string>[] | Record<string, FunctionMaybe<null | undefined | boolean>>, objectPrev: null | undefined | string | FunctionMaybe<null | undefined | boolean | string>[] | Record<string, FunctionMaybe<null | undefined | boolean>>, stack: Stack): void => {\r\n\r\n    if (isString(object)) {\r\n\r\n        if (isSVG(element)) {\r\n\r\n            element.setAttribute('class', object)\r\n\r\n        } else {\r\n\r\n            element.className = object\r\n\r\n        }\r\n\r\n    } else {\r\n\r\n        if (objectPrev) {\r\n\r\n            if (isString(objectPrev)) {\r\n\r\n                if (objectPrev) {\r\n\r\n                    if (isSVG(element)) {\r\n\r\n                        element.setAttribute('class', '')\r\n\r\n                    } else {\r\n\r\n                        element.className = ''\r\n\r\n                    }\r\n\r\n                }\r\n\r\n            } else if (isArray(objectPrev)) {\r\n\r\n                objectPrev = store.unwrap(objectPrev)\r\n\r\n                for (let i = 0, l = objectPrev.length; i < l; i++) {\r\n\r\n                    if (!objectPrev[i]) continue\r\n\r\n                    setClassBoolean(element, false, objectPrev[i], stack)\r\n\r\n                }\r\n\r\n            } else {\r\n\r\n                objectPrev = store.unwrap(objectPrev)\r\n\r\n                for (const key in objectPrev) {\r\n\r\n                    if (object && key in object) continue\r\n\r\n                    setClass(element, key, false, stack)\r\n\r\n                }\r\n\r\n            }\r\n\r\n        }\r\n\r\n        if (isArray(object)) {\r\n\r\n            if (isStore(object)) {\r\n\r\n                for (let i = 0, l = object.length; i < l; i++) {\r\n\r\n                    const fn = untrack(() => isFunction(object[i]) ? object[i] : object[SYMBOL_STORE_OBSERVABLE](String(i))) as (() => string | boolean | null | undefined) //TSC\r\n\r\n                    setClassBoolean(element, true, fn, stack)\r\n\r\n                }\r\n\r\n            } else {\r\n                //@ts-ignore\r\n                for (let i = 0, l = object.length; i < l; i++) {\r\n\r\n                    if (!object[i]) continue\r\n\r\n                    setClassBoolean(element, true, object[i], stack)\r\n\r\n                }\r\n\r\n            }\r\n\r\n        } else {\r\n\r\n            if (isStore(object)) {\r\n\r\n                for (const key in object) {\r\n\r\n                    const fn = untrack(() => isFunction(object[key]) ? object[key] : (object as any)[SYMBOL_STORE_OBSERVABLE](key)) as (() => boolean | null | undefined) //TSC\r\n\r\n                    setClass(element, key, fn, stack)\r\n\r\n                }\r\n\r\n            } else {\r\n                //@ts-ignore\r\n                for (const key in object) {\r\n\r\n                    setClass(element, key, object[key], stack)\r\n\r\n                }\r\n\r\n            }\r\n\r\n        }\r\n\r\n    }\r\n\r\n}\r\n\r\nconst setClasses = (element: HTMLElement, object: Classes, stack: Stack): void => {\r\n\r\n    if (isFunction(object) || isArray(object)) {\r\n\r\n        let objectPrev: Record<string, boolean> | undefined\r\n\r\n        useRenderEffect(() => {\r\n\r\n            const objectNext = resolveClass(object)\r\n\r\n            setClassesStatic(element, objectNext, objectPrev, stack)\r\n\r\n            objectPrev = objectNext\r\n\r\n        }, stack)\r\n\r\n    } else {\r\n\r\n        setClassesStatic(element, object, null, stack)\r\n\r\n    }\r\n\r\n}\r\n\r\nconst setDirective = <T extends unknown[]>(element: HTMLElement, directive: string, args: T): void => {\r\n\r\n    const symbol = SYMBOLS_DIRECTIVES[directive] || Symbol()\r\n    const data = context<DirectiveData<T>>(symbol) || DIRECTIVES[symbol]\r\n\r\n    if (!data) throw new Error(`Directive \"${directive}\" not found`)\r\n\r\n    const call = () => data.fn(element, ...castArray(args) as any) //TSC\r\n\r\n    const stack = new Error()\r\n\r\n    if (data.immediate) {\r\n\r\n        call()\r\n\r\n    } else {\r\n\r\n        useMicrotask(call, stack)\r\n\r\n    }\r\n\r\n}\r\n\r\nconst setEventStatic = (() => {\r\n\r\n    //TODO: Maybe delete event delegation\r\n    //TODO: Maybe delegate more events: [onmousemove, onmouseout, onmouseover, onpointerdown, onpointermove, onpointerout, onpointerover, onpointerup, ontouchend, ontouchmove, ontouchstart]\r\n\r\n    const delegatedEvents = <const>{\r\n        onauxclick: ['_onauxclick', false],\r\n        onbeforeinput: ['_onbeforeinput', false],\r\n        onclick: ['_onclick', false],\r\n        ondblclick: ['_ondblclick', false],\r\n        onfocusin: ['_onfocusin', false],\r\n        onfocusout: ['_onfocusout', false],\r\n        oninput: ['_oninput', false],\r\n        onkeydown: ['_onkeydown', false],\r\n        onkeyup: ['_onkeyup', false],\r\n        onmousedown: ['_onmousedown', false],\r\n        onmouseup: ['_onmouseup', false]\r\n    }\r\n\r\n    const delegate = (event: string): void => {\r\n\r\n        const key = `_${event}`\r\n\r\n        document.addEventListener(event.slice(2), event => {\r\n\r\n            const targets = event.composedPath()\r\n\r\n            let target: EventTarget | null = null\r\n\r\n            Object.defineProperty(event, 'currentTarget', {\r\n                configurable: true,\r\n                get() {\r\n                    return target\r\n                }\r\n            })\r\n\r\n            for (let i = 0, l = targets.length; i < l; i++) {\r\n\r\n                target = targets[i]\r\n\r\n                const handler = target[key]\r\n\r\n                if (!handler) continue\r\n\r\n                handler(event)\r\n\r\n                if (event.cancelBubble) break\r\n\r\n            }\r\n\r\n            target = null\r\n\r\n        })\r\n\r\n    }\r\n\r\n    return (element: HTMLElement, event: string, value: null | undefined | EventListener): void => {\r\n\r\n        if (event.startsWith('onmiddleclick')) { // Special-cased synthetic event, somewhat ugly but very convenient\r\n\r\n            const _value = value\r\n\r\n            event = `onauxclick${event.slice(13)}`\r\n            value = _value && ((event: Event) => event['button'] === 1 && _value(event))\r\n\r\n        }\r\n\r\n        const delegated = delegatedEvents[event]\r\n\r\n        if (delegated) {\r\n\r\n            if (!delegated[1]) { // Not actually delegating yet\r\n\r\n                delegated[1] = true\r\n\r\n                delegate(event)\r\n\r\n            }\r\n\r\n            element[delegated[0]] = value\r\n\r\n        } else if (event.endsWith('passive')) {\r\n\r\n            const isCapture = event.endsWith('capturepassive')\r\n            const type = event.slice(2, -7 - (isCapture ? 7 : 0))\r\n            const key = `_${event}`\r\n\r\n            const valuePrev = element[key]\r\n\r\n            if (valuePrev) element.removeEventListener(type, valuePrev, { capture: isCapture })\r\n\r\n            if (value) element.addEventListener(type, value, { passive: true, capture: isCapture })\r\n\r\n            element[key] = value\r\n\r\n        } else if (event.endsWith('capture')) {\r\n\r\n            const type = event.slice(2, -7)\r\n            const key = `_${event}`\r\n\r\n            const valuePrev = element[key]\r\n\r\n            if (valuePrev) element.removeEventListener(type, valuePrev, { capture: true })\r\n\r\n            if (value) element.addEventListener(type, value, { capture: true })\r\n\r\n            element[key] = value\r\n\r\n        } else {\r\n\r\n            element[event] = value\r\n\r\n        }\r\n\r\n    }\r\n\r\n})()\r\n\r\nconst setEvent = (element: HTMLElement, event: string, value: ObservableMaybe<null | undefined | EventListener>): void => {\r\n\r\n    setEventStatic(element, event, value)\r\n\r\n}\r\n\r\nconst setHTMLStatic = (element: HTMLElement, value: null | undefined | number | string): void => {\r\n\r\n    element.innerHTML = String(isNil(value) ? '' : value)\r\n\r\n}\r\n\r\nconst setHTML = (element: HTMLElement, value: FunctionMaybe<{ __html: FunctionMaybe<null | undefined | number | string> }>, stack: Stack): void => {\r\n\r\n    useRenderEffect(() => {\r\n\r\n        setHTMLStatic(element, $$($$(value).__html))\r\n\r\n    }, stack)\r\n\r\n}\r\n\r\nconst setPropertyStatic = (element: HTMLElement, key: string, value: null | undefined | boolean | number | string): void => {\r\n\r\n    if (key === 'tabIndex' && isBoolean(value)) {\r\n\r\n        value = value ? 0 : undefined\r\n\r\n    }\r\n\r\n    if (key === 'value') {\r\n\r\n        if (element.tagName === 'PROGRESS') {\r\n\r\n            value ??= null\r\n\r\n        } else if (element.tagName === 'SELECT' && !element['_$inited']) {\r\n\r\n            element['_$inited'] = true\r\n\r\n            queueMicrotask(() => element[key] = value)\r\n\r\n        }\r\n\r\n    }\r\n\r\n    try { // Trying setting the property\r\n\r\n        element[key] = value\r\n\r\n        if (isNil(value)) {\r\n\r\n            setAttributeStatic(element, key, null)\r\n\r\n        }\r\n\r\n    } catch { // If it fails, maybe because like HTMLInputElement.form there's only a getter, we try as an attribute instead //TODO: Figure out something better than this\r\n\r\n        setAttributeStatic(element, key, value)\r\n\r\n    }\r\n\r\n}\r\n\r\nconst setProperty = (element: HTMLElement, key: string, value: FunctionMaybe<null | undefined | boolean | number | string>, stack: Stack): void => {\r\n\r\n    if (isFunction(value) && isFunctionReactive(value)) {\r\n\r\n        useRenderEffect(() => {\r\n\r\n            setPropertyStatic(element, key, value())\r\n\r\n        }, stack)\r\n\r\n    } else {\r\n\r\n        setPropertyStatic(element, key, $$(value))\r\n\r\n    }\r\n\r\n}\r\n\r\nconst setRef = <T>(element: T, value: null | undefined | Ref<T> | (null | undefined | Ref<T>)[]): void => { // Scheduling a microtask to dramatically increase the probability that the element will get connected to the DOM in the meantime, which would be more convenient\r\n\r\n    if (isNil(value)) return\r\n\r\n    const values = flatten(castArray(value)).filter(Boolean)\r\n\r\n    if (!values.length) return\r\n\r\n    const stack = new Error()\r\n    useMicrotask(() => untrack(() => values.forEach(value => value?.(element))), stack)\r\n\r\n}\r\n\r\nconst setStyleStatic = (() => {\r\n\r\n    // From Preact: https://github.com/preactjs/preact/blob/e703a62b77c9de45e886d8a7f59bd0db658318f9/src/constants.js#L3\r\n    // const propertyNonDimensionalRe = /acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i;\r\n    // From this Preact issue: https://github.com/preactjs/preact/issues/2607\r\n    const propertyNonDimensionalRe = /^(-|f[lo].*[^se]$|g.{5,}[^ps]$|z|o[pr]|(W.{5})?[lL]i.*(t|mp)$|an|(bo|s).{4}Im|sca|m.{6}[ds]|ta|c.*[st]$|wido|ini)/i\r\n    const propertyNonDimensionalCache: Partial<Record<string, boolean>> = {}\r\n\r\n    return (element: HTMLElement, key: string, value: null | undefined | number | string): void => {\r\n\r\n        if (key.charCodeAt(0) === 45) { // /^-/\r\n\r\n            if (isNil(value)) {\r\n\r\n                element.style.removeProperty(key)\r\n\r\n            } else {\r\n\r\n                element.style.setProperty(key, String(value))\r\n\r\n            }\r\n\r\n        } else if (isNil(value)) {\r\n\r\n            element.style[key] = null\r\n\r\n        } else {\r\n\r\n            element.style[key] = (isString(value) || (propertyNonDimensionalCache[key] ||= propertyNonDimensionalRe.test(key)) ? value : `${value}px`)\r\n\r\n        }\r\n\r\n    }\r\n\r\n})()\r\n\r\nconst setStyle = (element: HTMLElement, key: string, value: FunctionMaybe<null | undefined | number | string>, stack: Stack): void => {\r\n\r\n    if (isFunction(value) && isFunctionReactive(value)) {\r\n\r\n        useRenderEffect(() => {\r\n\r\n            setStyleStatic(element, key, value())\r\n\r\n        }, stack)\r\n\r\n    } else {\r\n\r\n        setStyleStatic(element, key, $$(value))\r\n\r\n    }\r\n\r\n}\r\n\r\nconst setStylesStatic = (element: HTMLElement, object: null | undefined | string | Record<string, FunctionMaybe<null | undefined | number | string>>, objectPrev: null | undefined | string | Record<string, FunctionMaybe<null | undefined | number | string>>, stack: Stack): void => {\r\n\r\n    if (isString(object)) {\r\n\r\n        element.setAttribute('style', object)\r\n\r\n    } else {\r\n\r\n        if (objectPrev) {\r\n\r\n            if (isString(objectPrev)) {\r\n\r\n                if (objectPrev) {\r\n\r\n                    element.style.cssText = ''\r\n\r\n                }\r\n\r\n            } else {\r\n\r\n                objectPrev = store.unwrap(objectPrev)\r\n\r\n                for (const key in objectPrev) {\r\n\r\n                    if (object && key in object) continue\r\n\r\n                    setStyleStatic(element, key, null)\r\n\r\n                }\r\n\r\n            }\r\n\r\n        }\r\n\r\n        if (isStore(object)) {\r\n\r\n            for (const key in object) {\r\n\r\n                const fn = untrack(() => isFunction(object[key]) ? object[key] : (object as any)[SYMBOL_STORE_OBSERVABLE](key)) as (() => number | string | null | undefined) //TSC\r\n\r\n                setStyle(element, key, fn, stack)\r\n\r\n            }\r\n\r\n        } else {\r\n            //@ts-ignore\r\n            for (const key in object) {\r\n\r\n                setStyle(element, key, object[key], stack)\r\n\r\n            }\r\n\r\n        }\r\n\r\n    }\r\n\r\n}\r\n\r\nconst setStyles = (element: HTMLElement, object: FunctionMaybe<null | undefined | string | Record<string, FunctionMaybe<null | undefined | number | string>>>, stack: Stack): void => {\r\n\r\n    if (isFunction(object) || isArray(object)) {\r\n\r\n        let objectPrev: null | undefined | string | Record<string, null | undefined | number | string>\r\n\r\n        useRenderEffect((stack) => {\r\n\r\n            const objectNext = resolveStyle(object)\r\n\r\n            setStylesStatic(element, objectNext, objectPrev, stack)\r\n\r\n            objectPrev = objectNext\r\n\r\n        }, stack)\r\n\r\n    } else {\r\n\r\n        setStylesStatic(element, $$(object), null, stack)\r\n\r\n    }\r\n\r\n}\r\n\r\nconst setTemplateAccessor = (element: HTMLElement, key: string, value: TemplateActionProxy): void => {\r\n\r\n    if (key === 'children') {\r\n\r\n        const placeholder = createText('') // Using a Text node rather than a Comment as the former may be what we actually want ultimately\r\n\r\n        element.insertBefore(placeholder, null)\r\n\r\n        value(element, 'setChildReplacement', undefined, placeholder)\r\n\r\n    } else if (key === 'ref') {\r\n\r\n        value(element, 'setRef')\r\n\r\n    } else if (key === 'style') {\r\n\r\n        value(element, 'setStyles')\r\n\r\n    } else if (key === 'class' || key === 'className') {\r\n\r\n        if (!isSVG(element)) {\r\n\r\n            element.className = '' // Ensuring the attribute is present\r\n\r\n        }\r\n\r\n        value(element, 'setClasses')\r\n\r\n    } else if (key === 'dangerouslySetInnerHTML') {\r\n\r\n        value(element, 'setHTML')\r\n\r\n    } else if (key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110) { // /^on/\r\n\r\n        value(element, 'setEvent', key.toLowerCase())\r\n\r\n    } else if (key.charCodeAt(0) === 117 && key.charCodeAt(3) === 58) { // /^u..:/\r\n\r\n        value(element, 'setDirective', key.slice(4))\r\n\r\n    } else if (key === 'innerHTML' || key === 'outerHTML' || key === 'textContent' || key === 'className') {\r\n\r\n        // Forbidden props\r\n\r\n    } else if (key in element && !isSVG(element)) {\r\n\r\n        value(element, 'setProperty', key)\r\n\r\n    } else {\r\n\r\n        element.setAttribute(key, '') // Ensuring the attribute is present\r\n\r\n        value(element, 'setAttribute', key)\r\n\r\n    }\r\n\r\n}\r\n\r\nconst setProp = (element: HTMLElement, key: string, value: any, stack: Stack): void => {\r\n\r\n    if (value === undefined) return // Ignoring undefined props, for performance\r\n\r\n    if (isTemplateAccessor(value)) {\r\n\r\n        setTemplateAccessor(element, key, value)\r\n\r\n    } else if (key === 'children') {\r\n\r\n        setChild(element, value, FragmentUtils.make(), stack)\r\n\r\n    } else if (key === 'ref') {\r\n\r\n        setRef(element, value)\r\n\r\n    } else if (key === 'style') {\r\n\r\n        setStyles(element, value, stack)\r\n\r\n    } else if (key === 'class' || key === 'className') {\r\n\r\n        setClasses(element, value, stack)\r\n\r\n    } else if (key === 'dangerouslySetInnerHTML') {\r\n\r\n        setHTML(element, value, stack)\r\n\r\n    } else if (key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110) { // /^on/\r\n\r\n        setEvent(element, key.toLowerCase(), value)\r\n\r\n    } else if (key.charCodeAt(0) === 117 && key.charCodeAt(3) === 58) { // /^u..:/\r\n\r\n        setDirective(element, key.slice(4), value)\r\n\r\n    } else if (key === 'innerHTML' || key === 'outerHTML' || key === 'textContent' || key === 'className') {\r\n\r\n        // Forbidden props\r\n\r\n    } else if (key in element && !isSVG(element)) {\r\n\r\n        setProperty(element, key, value, stack)\r\n\r\n    } else {\r\n\r\n        setAttribute(element, key, value, stack)\r\n\r\n    }\r\n\r\n}\r\n\r\nconst setProps = (element: HTMLElement, object: Record<string, unknown>, stack: Stack): void => {\r\n\r\n    for (const key in object) {\r\n\r\n        setProp(element, key, object[key], stack)\r\n\r\n    }\r\n\r\n}\r\n\r\n/* EXPORT */\r\n\r\nexport { setAttributeStatic, setAttribute, setChildReplacementFunction, setChildReplacementText, setChildReplacement, setChildStatic, setChild, setClassStatic, setClass, setClassBooleanStatic, setClassesStatic, setClasses, setEventStatic, setEvent, setHTMLStatic, setHTML, setPropertyStatic, setProperty, setRef, setStyleStatic, setStyle, setStylesStatic, setStyles, setTemplateAccessor, setProp, setProps }"],"names":["SYMBOL_SUSPENSE","castArray","isArray","castError","isFunction","isObject","noop","cleanup","OWNER","Scheduler","options","context","effect","is","SchedulerAsync","store","parent","node","key","getter","_a","value","property","lengthPrev","lengthNext","ObservableClass","get","stack","document","createComment","createHTMLNode","createSVGNode","createText","createDocumentFragment","useEffect","useCleanup","$$","child","fragment","dynamic","fragmentOnly","event"],"mappings":"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"}