mutts 1.0.1 → 1.0.2

package/dist/reactive.js

@@ -1,1477 +1,35 @@
 'use strict';
 
-var decorator = require('./chunks/decorator-8qjFb7dw.js');
-var indexable = require('./indexable.js');
+var reactive = require('./chunks/index-DOTmXL89.js');
+require('./chunks/decorator-D4DU97Zg.js');
+require('./chunks/_tslib-C-cuVLvZ.js');
+require('./indexable.js');
 
-// biome-ignore-all lint/suspicious/noConfusingVoidType: Type 'void' is not assignable to type 'ScopedCallback | undefined'.
-// Argument of type '() => void' is not assignable to parameter of type '(dep: DependencyFunction) => ScopedCallback | undefined'.
-// Track which effects are watching which reactive objects for cleanup
-const effectToReactiveObjects = new WeakMap();
-// Track object -> proxy and proxy -> object relationships
-const objectToProxy = new WeakMap();
-const proxyToObject = new WeakMap();
-// Deep watching data structures
-// Track which objects contain which other objects (back-references)
-const objectParents = new WeakMap();
-// Track which objects have deep watchers
-const objectsWithDeepWatchers = new WeakSet();
-// Track deep watchers per object
-const deepWatchers = new WeakMap();
-// Track which effects are doing deep watching
-const effectToDeepWatchedObjects = new WeakMap();
-// Track objects that should never be reactive and cannot be modified
-const nonReactiveObjects = new WeakSet();
-const absent = Symbol('absent');
-/**
- * Converts an iterator to a generator that yields reactive values
- */
-function* makeReactiveIterator(iterator) {
-    let result = iterator.next();
-    while (!result.done) {
-        yield reactive(result.value);
-        result = iterator.next();
-    }
-}
-/**
- * Converts an iterator of key-value pairs to a generator that yields reactive key-value pairs
- */
-function* makeReactiveEntriesIterator(iterator) {
-    let result = iterator.next();
-    while (!result.done) {
-        const [key, value] = result.value;
-        yield [reactive(key), reactive(value)];
-        result = iterator.next();
-    }
-}
-// Track effects per reactive object and property
-const watchers = new WeakMap();
-const profileInfo = {
-    objectToProxy,
-    proxyToObject,
-    effectToReactiveObjects,
-    watchers,
-    objectParents,
-    objectsWithDeepWatchers,
-    deepWatchers,
-    effectToDeepWatchedObjects,
-    nonReactiveObjects,
-};
-// Track native reactivity
-const nativeReactive = Symbol('native-reactive');
-// Symbol to mark individual objects as non-reactive
-const nonReactiveMark = Symbol('non-reactive');
-// Symbol to mark class properties as non-reactive
-const unreactiveProperties = Symbol('unreactive-properties');
-const prototypeForwarding = Symbol('prototype-forwarding');
-const allProps = Symbol('all-props');
-// Symbol to mark functions with their root function
-const rootFunction = Symbol('root-function');
-/**
- * Mark a function with its root function. If the function already has a root,
- * the root becomes the root of the new root (transitive root tracking).
- * @param fn - The function to mark
- * @param root - The root function to associate with fn
- */
-function markWithRoot(fn, root) {
-    // Mark fn with the new root
-    return Object.defineProperty(fn, rootFunction, {
-        value: getRoot(root),
-        writable: false,
-    });
-}
-/**
- * Retrieve the root function from a callback. Returns the function itself if it has no root.
- * @param fn - The function to get the root from
- * @returns The root function, or the function itself if no root exists
- */
-function getRoot(fn) {
-    return fn?.[rootFunction] || fn;
-}
-class ReactiveError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'ReactiveError';
-    }
-}
-// biome-ignore-start lint/correctness/noUnusedFunctionParameters: Interface declaration with empty defaults
-/**
- * Options for the reactive system, can be configured at runtime
- */
-const options = {
-    /**
-     * Debug purpose: called when an effect is entered
-     * @param effect - The effect that is entered
-     */
-    enter: (effect) => { },
-    /**
-     * Debug purpose: called when an effect is left
-     * @param effect - The effect that is left
-     */
-    leave: (effect) => { },
-    /**
-     * Debug purpose: called when an effect is chained
-     * @param target - The effect that is being triggered
-     * @param caller - The effect that is calling the target
-     */
-    chain: (target, caller) => { },
-    /**
-     * Debug purpose: maximum effect chain (like call stack max depth)
-     * Used to prevent infinite loops
-     * @default 100
-     */
-    maxEffectChain: 100,
-    /**
-     * Maximum depth for deep watching traversal
-     * Used to prevent infinite recursion in circular references
-     * @default 100
-     */
-    maxDeepWatchDepth: 100,
-    /**
-     * Only react on instance members modification (not inherited properties)
-     * For instance, do not track class methods
-     * @default true
-     */
-    instanceMembers: true,
-    // biome-ignore lint/suspicious/noConsole: This is the whole point here
-    warn: (...args) => console.warn(...args),
-};
-// biome-ignore-end lint/correctness/noUnusedFunctionParameters: Interface declaration with empty defaults
-//#region evolution
-function raiseDeps(objectWatchers, ...keyChains) {
-    for (const keys of keyChains)
-        for (const key of keys) {
-            const deps = objectWatchers.get(key);
-            if (deps)
-                for (const effect of Array.from(deps))
-                    atomicEffect(effect);
-        }
-}
-function touched1(obj, evolution, prop) {
-    touched(obj, evolution, [prop]);
-}
-function touched(obj, evolution, props) {
-    obj = unwrap(obj);
-    addState(obj, evolution);
-    const objectWatchers = watchers.get(obj);
-    if (objectWatchers) {
-        if (props)
-            raiseDeps(objectWatchers, [allProps], props);
-        else
-            raiseDeps(objectWatchers, objectWatchers.keys());
-    }
-    // Bubble up changes if this object has deep watchers
-    if (objectsWithDeepWatchers.has(obj)) {
-        bubbleUpChange(obj);
-    }
-}
-const states = new WeakMap();
-function addState(obj, evolution) {
-    obj = unwrap(obj);
-    const next = {};
-    const state = getState(obj);
-    if (state)
-        Object.assign(state, { evolution, next });
-    states.set(obj, next);
-}
-function getState(obj) {
-    obj = unwrap(obj);
-    let state = states.get(obj);
-    if (!state) {
-        state = {};
-        states.set(obj, state);
-    }
-    return state;
-}
-function dependant(obj, prop = allProps) {
-    obj = unwrap(obj);
-    if (activeEffect && (typeof prop !== 'symbol' || prop === allProps)) {
-        let objectWatchers = watchers.get(obj);
-        if (!objectWatchers) {
-            objectWatchers = new Map();
-            watchers.set(obj, objectWatchers);
-        }
-        let deps = objectWatchers.get(prop);
-        if (!deps) {
-            deps = new Set();
-            objectWatchers.set(prop, deps);
-        }
-        deps.add(activeEffect);
-        // Track which reactive objects this effect is watching
-        let effectObjects = effectToReactiveObjects.get(activeEffect);
-        if (!effectObjects) {
-            effectObjects = new Set();
-            effectToReactiveObjects.set(activeEffect, effectObjects);
-        }
-        effectObjects.add(obj);
-    }
-}
-// Stack of active effects to handle nested effects
-let activeEffect;
-// Parent effect used for lifecycle/cleanup relationships (can diverge later)
-let parentEffect;
-// Track currently executing effects to prevent re-execution
-// These are all the effects triggered under `activeEffect`
-let batchedEffects;
-// Track which sub-effects have been executed to prevent infinite loops
-// These are all the effects triggered under `activeEffect` and all their sub-effects
-function atomicEffect(effect, immediate) {
-    const root = getRoot(effect);
-    options?.chain(getRoot(effect), getRoot(activeEffect));
-    if (batchedEffects) {
-        batchedEffects.set(root, effect);
-        if (immediate)
-            try {
-                return effect();
-            }
-            finally {
-                batchedEffects.delete(root);
-            }
-    }
-    else {
-        const runEffects = [];
-        batchedEffects = new Map([[root, effect]]);
-        const firstReturn = {};
-        try {
-            while (batchedEffects.size) {
-                if (runEffects.length > options.maxEffectChain)
-                    throw new ReactiveError('[reactive] Max effect chain reached');
-                const [root, effect] = batchedEffects.entries().next().value;
-                runEffects.push(root);
-                const rv = effect();
-                if (!('value' in firstReturn))
-                    firstReturn.value = rv;
-                batchedEffects.delete(root);
-            }
-            return firstReturn.value;
-        }
-        finally {
-            batchedEffects = undefined;
-        }
-    }
-}
-const atomic = decorator.decorator({
-    method(original) {
-        return function (...args) {
-            return atomicEffect(markWithRoot(() => original.apply(this, args), original), 'immediate');
-        };
-    },
-    default(original) {
-        return function (...args) {
-            return atomicEffect(markWithRoot(() => original.apply(this, args), original), 'immediate');
-        };
-    },
-});
-function withEffect(effect, fn, keepParent) {
-    if (getRoot(effect) === getRoot(activeEffect))
-        return fn();
-    const oldActiveEffect = activeEffect;
-    const oldParentEffect = parentEffect;
-    activeEffect = effect;
-    if (!keepParent)
-        parentEffect = effect;
-    try {
-        return fn();
-    }
-    finally {
-        activeEffect = oldActiveEffect;
-        parentEffect = oldParentEffect;
-    }
-}
-//#endregion
-//#region deep watching
-/**
- * Add a back-reference from child to parent
- */
-function addBackReference(child, parent, prop) {
-    let parents = objectParents.get(child);
-    if (!parents) {
-        parents = new Set();
-        objectParents.set(child, parents);
-    }
-    parents.add({ parent, prop });
-}
-/**
- * Remove a back-reference from child to parent
- */
-function removeBackReference(child, parent, prop) {
-    const parents = objectParents.get(child);
-    if (parents) {
-        parents.delete({ parent, prop });
-        if (parents.size === 0) {
-            objectParents.delete(child);
-        }
-    }
-}
-/**
- * Check if an object needs back-references (has deep watchers or parents with deep watchers)
- */
-function needsBackReferences(obj) {
-    return objectsWithDeepWatchers.has(obj) || hasParentWithDeepWatchers(obj);
-}
-/**
- * Check if an object has any parent with deep watchers
- */
-function hasParentWithDeepWatchers(obj) {
-    const parents = objectParents.get(obj);
-    if (!parents)
-        return false;
-    for (const { parent } of parents) {
-        if (objectsWithDeepWatchers.has(parent))
-            return true;
-        if (hasParentWithDeepWatchers(parent))
-            return true;
-    }
-    return false;
-}
-/**
- * Bubble up changes through the back-reference chain
- */
-function bubbleUpChange(changedObject, evolution) {
-    const parents = objectParents.get(changedObject);
-    if (!parents)
-        return;
-    for (const { parent } of parents) {
-        // Trigger deep watchers on parent
-        const parentDeepWatchers = deepWatchers.get(parent);
-        if (parentDeepWatchers)
-            for (const watcher of parentDeepWatchers)
-                atomicEffect(watcher);
-        // Continue bubbling up
-        bubbleUpChange(parent);
-    }
-}
-function track1(obj, prop, oldVal, newValue) {
-    // Manage back-references if this object has deep watchers
-    if (objectsWithDeepWatchers.has(obj)) {
-        // Remove old back-references
-        if (typeof oldVal === 'object' && oldVal !== null) {
-            removeBackReference(oldVal, obj, prop);
-        }
-        // Add new back-references
-        if (typeof newValue === 'object' && newValue !== null) {
-            const reactiveValue = reactive(newValue);
-            addBackReference(reactiveValue, obj, prop);
-        }
-    }
-    return newValue;
-}
-//#endregion
-const reactiveHandlers = {
-    [Symbol.toStringTag]: 'MutTs Reactive',
-    get(obj, prop, receiver) {
-        if (prop === nonReactiveMark)
-            return false;
-        // Check if this property is marked as unreactive
-        if (obj[unreactiveProperties]?.has(prop) || typeof prop === 'symbol')
-            return Reflect.get(obj, prop, receiver);
-        // Depend if...
-        if (!options.instanceMembers || Object.hasOwn(receiver, prop) || !Reflect.has(receiver, prop))
-            dependant(obj, prop);
-        const value = Reflect.get(obj, prop, receiver);
-        if (typeof value === 'object' && value !== null) {
-            const reactiveValue = reactive(value);
-            // Only create back-references if this object needs them
-            if (needsBackReferences(obj)) {
-                addBackReference(reactiveValue, obj, prop);
-            }
-            return reactiveValue;
-        }
-        return value;
-    },
-    set(obj, prop, value, receiver) {
-        // Check if this property is marked as unreactive
-        if (obj[unreactiveProperties]?.has(prop))
-            return Reflect.set(obj, prop, value, receiver);
-        // Really specific case for when Array is forwarder, in order to let it manage the reactivity
-        const isArrayCase = prototypeForwarding in obj &&
-            // biome-ignore lint/suspicious/useIsArray: This is the whole point here
-            obj[prototypeForwarding] instanceof Array &&
-            (!Number.isNaN(Number(prop)) || prop === 'length');
-        const newValue = unwrap(value);
-        if (isArrayCase) {
-            obj[prop] = newValue;
-            return true;
-        }
-        const oldVal = Reflect.has(receiver, prop) ? Reflect.get(obj, prop, receiver) : absent;
-        track1(obj, prop, oldVal, newValue);
-        if (oldVal !== newValue) {
-            Reflect.set(obj, prop, newValue, receiver);
-            // try to find a "generic" way to express that
-            touched1(obj, { type: oldVal !== absent ? 'set' : 'add', prop }, prop);
-        }
-        return true;
-    },
-    deleteProperty(obj, prop) {
-        if (!Object.hasOwn(obj, prop))
-            return false;
-        const oldVal = obj[prop];
-        // Remove back-references if this object has deep watchers
-        if (objectsWithDeepWatchers.has(obj) && typeof oldVal === 'object' && oldVal !== null) {
-            removeBackReference(oldVal, obj, prop);
-        }
-        delete obj[prop];
-        touched1(obj, { type: 'del', prop }, prop);
-        // Bubble up changes if this object has deep watchers
-        if (objectsWithDeepWatchers.has(obj)) {
-            bubbleUpChange(obj);
-        }
-        return true;
-    },
-    getPrototypeOf(obj) {
-        if (prototypeForwarding in obj)
-            return obj[prototypeForwarding];
-        return Object.getPrototypeOf(obj);
-    },
-    setPrototypeOf(obj, proto) {
-        if (prototypeForwarding in obj)
-            return false;
-        Object.setPrototypeOf(obj, proto);
-        return true;
-    },
-    ownKeys(obj) {
-        dependant(obj, allProps);
-        return Reflect.ownKeys(obj);
-    },
-};
-const reactiveClasses = new WeakSet();
-class ReactiveBase {
-    constructor() {
-        // biome-ignore lint/correctness/noConstructorReturn: This is the whole point here
-        return reactiveClasses.has(new.target) ? reactive(this) : this;
-    }
-}
-function reactiveObject(anyTarget) {
-    if (!anyTarget || typeof anyTarget !== 'object')
-        return anyTarget;
-    const target = anyTarget;
-    // If target is already a proxy, return it
-    if (proxyToObject.has(target) || isNonReactive(target))
-        return target;
-    // If we already have a proxy for this object, return it
-    if (objectToProxy.has(target))
-        return objectToProxy.get(target);
-    const proxied = nativeReactive in target && !(target instanceof target[nativeReactive])
-        ? new target[nativeReactive](target)
-        : target;
-    if (proxied !== target)
-        proxyToObject.set(proxied, target);
-    const proxy = new Proxy(proxied, reactiveHandlers);
-    // Store the relationships
-    objectToProxy.set(target, proxy);
-    proxyToObject.set(proxy, target);
-    return proxy;
-}
-const reactive = decorator.decorator({
-    class(original) {
-        if (original.prototype instanceof ReactiveBase) {
-            reactiveClasses.add(original);
-            return original;
-        }
-        class Reactive extends original {
-            constructor(...args) {
-                super(...args);
-                if (new.target !== Reactive && !reactiveClasses.has(new.target))
-                    options.warn(`${original.name} has been inherited by ${this.constructor.name} that is not reactive.
-@reactive decorator must be applied to the leaf class OR classes have to extend ReactiveBase.`);
-                // biome-ignore lint/correctness/noConstructorReturn: This is the whole point here
-                return reactive(this);
-            }
-        }
-        Object.defineProperty(Reactive, 'name', {
-            value: `Reactive<${original.name}>`,
-        });
-        return Reactive;
-    },
-    get(original) {
-        return reactiveObject(original);
-    },
-    default: reactiveObject,
-});
-function unwrap(proxy) {
-    // Return the original object
-    return proxyToObject.get(proxy) ?? proxy;
-}
-function isReactive(obj) {
-    return proxyToObject.has(obj);
-}
-function untracked(fn) {
-    withEffect(undefined, fn, true);
-}
-// runEffect -> set<cleanup>
-const effectChildren = new WeakMap();
-const fr = new FinalizationRegistry((f) => f());
-/**
- * @param fn - The effect function to run - provides the cleaner
- * @returns The cleanup function
- */
-function effect(fn, ...args) {
-    let cleanup = null;
-    const dep = markWithRoot((cb) => withEffect(runEffect, cb), fn);
-    let effectStopped = false;
-    function runEffect() {
-        // Clear previous dependencies
-        cleanup?.();
-        options.enter(fn);
-        const reactionCleanup = withEffect(effectStopped ? undefined : runEffect, () => fn(dep, ...args));
-        options.leave(fn);
-        // Create cleanup function for next run
-        cleanup = () => {
-            cleanup = null;
-            reactionCleanup?.();
-            // Remove this effect from all reactive objects it's watching
-            const effectObjects = effectToReactiveObjects.get(runEffect);
-            if (effectObjects) {
-                for (const reactiveObj of effectObjects) {
-                    const objectWatchers = watchers.get(reactiveObj);
-                    if (objectWatchers) {
-                        for (const [prop, deps] of objectWatchers.entries()) {
-                            deps.delete(runEffect);
-                            if (deps.size === 0) {
-                                objectWatchers.delete(prop);
-                            }
-                        }
-                        if (objectWatchers.size === 0) {
-                            watchers.delete(reactiveObj);
-                        }
-                    }
-                }
-                effectToReactiveObjects.delete(runEffect);
-            }
-        };
-    }
-    // Mark the runEffect callback with the original function as its root
-    markWithRoot(runEffect, fn);
-    atomicEffect(runEffect, 'immediate');
-    const mainCleanup = () => {
-        if (effectStopped)
-            return;
-        effectStopped = true;
-        cleanup?.();
-        // Invoke all child cleanups (recursive via subEffectCleanup calling its own mainCleanup)
-        const children = effectChildren.get(runEffect);
-        if (children) {
-            for (const childCleanup of children)
-                childCleanup();
-            effectChildren.delete(runEffect);
-        }
-        fr.unregister(mainCleanup);
-    };
-    // Only ROOT effects are registered for GC cleanup
-    if (!parentEffect) {
-        const callIfCollected = () => mainCleanup();
-        fr.register(callIfCollected, mainCleanup, callIfCollected);
-        return callIfCollected;
-    }
-    // Register this effect to be cleaned up with the parent effect
-    let children = effectChildren.get(parentEffect);
-    if (!children) {
-        children = new Set();
-        effectChildren.set(parentEffect, children);
-    }
-    const parent = parentEffect;
-    const subEffectCleanup = () => {
-        children.delete(subEffectCleanup);
-        if (children.size === 0) {
-            effectChildren.delete(parent);
-        }
-        // Execute this child effect cleanup (which triggers its own mainCleanup)
-        mainCleanup();
-    };
-    children.add(subEffectCleanup);
-    return subEffectCleanup;
-}
-/**
- * Mark an object as non-reactive. This object and all its properties will never be made reactive.
- * @param obj - The object to mark as non-reactive
- */
-function nonReactive(...obj) {
-    for (const o of obj) {
-        try {
-            Object.defineProperty(o, nonReactiveMark, {
-                value: true,
-                writable: false,
-                enumerable: false,
-                configurable: false,
-            });
-        }
-        catch { }
-        if (!(nonReactiveMark in o))
-            nonReactiveObjects.add(o);
-    }
-    return obj[0];
-}
-/**
- * Set of functions to test if an object is immutable
- */
-const immutables = new Set();
-/**
- * Check if an object is marked as non-reactive (for testing purposes)
- * @param obj - The object to check
- * @returns true if the object is marked as non-reactive
- */
-function isNonReactive(obj) {
-    // Don't make primitives reactive
-    if (obj === null || typeof obj !== 'object')
-        return true;
-    // Check if the object itself is marked as non-reactive
-    if (nonReactiveObjects.has(obj))
-        return true;
-    // Check if the object has the non-reactive symbol
-    if (obj[nonReactiveMark])
-        return true;
-    // Check if the object is immutable
-    if (Array.from(immutables).some((fn) => fn(obj)))
-        return true;
-    return false;
-}
-/**
- * Mark a class as non-reactive. All instances of this class will automatically be non-reactive.
- * @param cls - The class constructor to mark as non-reactive
- */
-function nonReactiveClass(...cls) {
-    for (const c of cls)
-        if (c)
-            c.prototype[nonReactiveMark] = true;
-    return cls[0];
-}
-nonReactiveClass(Date, RegExp, Error, Promise, Function);
-if (typeof window !== 'undefined')
-    nonReactive(window, document);
-if (typeof Element !== 'undefined')
-    nonReactiveClass(Element, Node);
-function registerNativeReactivity(originalClass, reactiveClass) {
-    originalClass.prototype[nativeReactive] = reactiveClass;
-    nonReactiveClass(reactiveClass);
-}
-/**
- * Deep watch an object and all its nested properties
- * @param target - The object to watch deeply
- * @param callback - The callback to call when any nested property changes
- * @param options - Options for the deep watch
- * @returns A cleanup function to stop watching
- */
-function deepWatch(target, callback, { immediate = false } = {}) {
-    if (target === null || target === undefined)
-        return undefined;
-    if (typeof target !== 'object')
-        throw new Error('Target of deep watching must be an object');
-    // Create a wrapper callback that matches ScopedCallback signature
-    const wrappedCallback = markWithRoot(() => callback(target), callback);
-    // Use the existing effect system to register dependencies
-    return effect(() => {
-        // Mark the target object as having deep watchers
-        objectsWithDeepWatchers.add(target);
-        // Track which objects this effect is watching for cleanup
-        let effectObjects = effectToDeepWatchedObjects.get(wrappedCallback);
-        if (!effectObjects) {
-            effectObjects = new Set();
-            effectToDeepWatchedObjects.set(wrappedCallback, effectObjects);
-        }
-        effectObjects.add(target);
-        // Traverse the object graph and register dependencies
-        // This will re-run every time the effect runs, ensuring we catch all changes
-        const visited = new WeakSet();
-        function traverseAndTrack(obj, depth = 0) {
-            // Prevent infinite recursion and excessive depth
-            if (visited.has(obj) || !isObject(obj) || depth > options.maxDeepWatchDepth)
-                return;
-            // Do not traverse into unreactive objects
-            if (isNonReactive(obj))
-                return;
-            visited.add(obj);
-            // Mark this object as having deep watchers
-            objectsWithDeepWatchers.add(obj);
-            effectObjects.add(obj);
-            // Traverse all properties to register dependencies
-            // unwrap to avoid kicking dependency
-            for (const key in unwrap(obj)) {
-                if (Object.hasOwn(obj, key)) {
-                    // Access the property to register dependency
-                    const value = obj[key];
-                    // Make the value reactive if it's an object
-                    const reactiveValue = typeof value === 'object' && value !== null ? reactive(value) : value;
-                    traverseAndTrack(reactiveValue, depth + 1);
-                }
-            }
-            // Also handle array indices and length
-            // biome-ignore lint/suspicious/useIsArray: Check for both native arrays and reactive arrays
-            if (Array.isArray(obj) || obj instanceof Array) {
-                // Access array length to register dependency on length changes
-                const length = obj.length;
-                // Access all current array elements to register dependencies
-                for (let i = 0; i < length; i++) {
-                    // Access the array element to register dependency
-                    const value = obj[i];
-                    // Make the value reactive if it's an object
-                    const reactiveValue = typeof value === 'object' && value !== null ? reactive(value) : value;
-                    traverseAndTrack(reactiveValue, depth + 1);
-                }
-            }
-            // Handle Set values (deep watch values only, not keys since Sets don't have separate keys)
-            else if (obj instanceof Set) {
-                // Access all Set values to register dependencies
-                for (const value of obj) {
-                    // Make the value reactive if it's an object
-                    const reactiveValue = typeof value === 'object' && value !== null ? reactive(value) : value;
-                    traverseAndTrack(reactiveValue, depth + 1);
-                }
-            }
-            // Handle Map values (deep watch values only, not keys)
-            else if (obj instanceof Map) {
-                // Access all Map values to register dependencies
-                for (const [_key, value] of obj) {
-                    // Make the value reactive if it's an object
-                    const reactiveValue = typeof value === 'object' && value !== null ? reactive(value) : value;
-                    traverseAndTrack(reactiveValue, depth + 1);
-                }
-            }
-            // Note: WeakSet and WeakMap cannot be iterated, so we can't deep watch their contents
-            // They will only trigger when the collection itself is replaced
-        }
-        // Traverse the target object to register all dependencies
-        // This will register dependencies on all current properties and array elements
-        traverseAndTrack(target);
-        // Only call the callback if immediate is true or if it's not the first run
-        if (immediate)
-            callback(target);
-        immediate = true;
-        // Return a cleanup function that properly removes deep watcher tracking
-        return () => {
-            // Get the objects this effect was watching
-            const effectObjects = effectToDeepWatchedObjects.get(wrappedCallback);
-            if (effectObjects) {
-                // Remove deep watcher tracking from all objects this effect was watching
-                for (const obj of effectObjects) {
-                    // Check if this object still has other deep watchers
-                    const watchers = deepWatchers.get(obj);
-                    if (watchers) {
-                        // Remove this effect's callback from the watchers
-                        watchers.delete(wrappedCallback);
-                        // If no more watchers, remove the object from deep watchers tracking
-                        if (watchers.size === 0) {
-                            deepWatchers.delete(obj);
-                            objectsWithDeepWatchers.delete(obj);
-                        }
-                    }
-                    else {
-                        // No watchers found, remove from deep watchers tracking
-                        objectsWithDeepWatchers.delete(obj);
-                    }
-                }
-                // Clean up the tracking data
-                effectToDeepWatchedObjects.delete(wrappedCallback);
-            }
-        };
-    });
-}
-/**
- * Check if an object is an object (not null, not primitive)
- */
-function isObject(obj) {
-    return obj !== null && typeof obj === 'object';
-}
-
-//#region computed
-let computedInvalidations;
-/**
- * When used in a computed property computation, it will register the callback to be called when the computed property is invalidated
- * @param cb - The callback to register
- * @param warn - Whether to warn if used outside of a computed property
- */
-function invalidateComputed(cb, warn = true) {
-    if (computedInvalidations)
-        computedInvalidations.push(cb);
-    else if (warn)
-        options.warn('Using `invalidateComputed` outside of a computed property');
-}
-const computedCache = new WeakMap();
-function computedFunction(getter) {
-    const key = getRoot(getter);
-    let invalidations = [];
-    dependant(computedCache, key);
-    if (computedCache.has(key))
-        return computedCache.get(key);
-    let stopped = false;
-    const stop = effect(markWithRoot((dep) => {
-        if (stopped)
-            return;
-        const oldCI = computedInvalidations;
-        if (computedCache.has(key)) {
-            // This should *not* be called in the cleanup chain, as its effects would be lost and cleaned-up
-            for (const cb of invalidations)
-                cb();
-            invalidations = [];
-            computedCache.delete(key);
-            touched1(computedCache, { type: 'invalidate', prop: key }, key);
-            stop();
-            stopped = true;
-        }
-        else
-            try {
-                computedInvalidations = invalidations;
-                computedCache.set(key, getter(dep));
-            }
-            finally {
-                computedInvalidations = oldCI;
-            }
-    }, getter));
-    return computedCache.get(key);
-}
-/**
- * Get the cached value of a computed function - cache is invalidated when the dependencies change
- */
-const computed = decorator.decorator({
-    getter(original, propertyKey) {
-        const computers = new WeakMap();
-        return function () {
-            if (!computers.has(this)) {
-                computers.set(this, decorator.renamed(() => original.call(this), `${String(this.constructor.name)}.${String(propertyKey)}`));
-            }
-            return computedFunction(computers.get(this));
-        };
-    },
-    default(getter) {
-        return computedFunction(getter);
-    },
-});
-//#endregion
-//#region watch
-const unsetYet = Symbol('unset-yet');
-function watch(value, //object | ((dep: DependencyFunction) => object),
-changed, options = {}) {
-    return typeof value === 'function'
-        ? watchCallBack(value, changed, options)
-        : typeof value === 'object'
-            ? watchObject(value, changed, options)
-            : (() => {
-                throw new Error('watch: value must be a function or an object');
-            })();
-}
-function watchObject(value, changed, { immediate = false, deep = false } = {}) {
-    if (deep)
-        return deepWatch(value, changed, { immediate });
-    return effect(markWithRoot(() => {
-        dependant(value);
-        if (immediate)
-            untracked(() => changed(value));
-        immediate = true;
-    }, changed));
-}
-function watchCallBack(value, changed, { immediate = false, deep = false } = {}) {
-    let oldValue = unsetYet;
-    let deepCleanup;
-    const cbCleanup = effect(markWithRoot((dep) => {
-        const newValue = value(dep);
-        if (oldValue !== newValue)
-            untracked(markWithRoot(() => {
-                if (oldValue === unsetYet) {
-                    if (immediate)
-                        changed(newValue);
-                }
-                else
-                    changed(newValue, oldValue);
-                oldValue = newValue;
-                if (deep) {
-                    if (deepCleanup)
-                        deepCleanup();
-                    deepCleanup = deepWatch(newValue, markWithRoot((value) => changed(value, value), changed));
-                }
-            }, changed));
-    }, value));
-    return () => {
-        cbCleanup();
-        if (deepCleanup)
-            deepCleanup();
-    };
-}
-//#endregion
-//#region nonReactive
-/**
- * Mark an object as non-reactive. This object and all its properties will never be made reactive.
- * @param obj - The object to mark as non-reactive
- */
-function deepNonReactive(obj) {
-    obj = unwrap(obj);
-    if (isNonReactive(obj))
-        return obj;
-    try {
-        Object.defineProperty(obj, nonReactiveMark, {
-            value: true,
-            writable: false,
-            enumerable: false,
-            configurable: true,
-        });
-    }
-    catch { }
-    if (!(nonReactiveMark in obj))
-        nonReactiveObjects.add(obj);
-    for (const key in obj)
-        deepNonReactive(obj[key]);
-    return obj;
-}
-function unreactiveApplication(arg1, ...args) {
-    return typeof arg1 === 'object'
-        ? deepNonReactive(arg1)
-        : ((original) => {
-            // Copy the parent's unreactive properties if they exist
-            original.prototype[unreactiveProperties] = new Set(original.prototype[unreactiveProperties] || []);
-            // Add all arguments (including the first one)
-            original.prototype[unreactiveProperties].add(arg1);
-            for (const arg of args)
-                original.prototype[unreactiveProperties].add(arg);
-            return original; // Return the class
-        });
-}
-const unreactive = decorator.decorator({
-    class(original) {
-        // Called without arguments, mark entire class as non-reactive
-        nonReactiveClass(original);
-    },
-    default: unreactiveApplication,
-});
-Object.assign(profileInfo, { computedCache });
 
-const native$2 = Symbol('native');
-const isArray = Array.isArray;
-Array.isArray = ((value) => 
-// biome-ignore lint/suspicious/useIsArray: We are defining it
-isArray(value) || (value instanceof Array && native$2 in value));
-class ReactiveBaseArray {
-}
-function* index(i, { length = true } = {}) {
-    yield i;
-    if (length)
-        yield 'length';
-}
-function* range(a, b, { length = false } = {}) {
-    const start = Math.min(a, b);
-    const end = Math.max(a, b);
-    for (let i = start; i <= end; i++)
-        yield i;
-    if (length)
-        yield 'length';
-}
-class ReactiveArray extends indexable.Indexable(ReactiveBaseArray, {
-    get(i) {
-        dependant(this[native$2], i);
-        return reactive(this[native$2][i]);
-    },
-    set(i, value) {
-        const added = i >= this[native$2].length;
-        this[native$2][i] = value;
-        touched(this[native$2], { type: 'bunch', method: 'set' }, index(i, { length: added }));
-    },
-    getLength() {
-        dependant(this[native$2], 'length');
-        return this[native$2].length;
-    },
-    setLength(value) {
-        const oldLength = this[native$2].length;
-        try {
-            this[native$2].length = value;
-        }
-        finally {
-            touched(this[native$2], { type: 'set', prop: 'length' }, range(oldLength, value, { length: true }));
-        }
-    },
-}) {
-    constructor(original) {
-        super();
-        Object.defineProperties(this, {
-            // We have to make it double, as [native] must be `unique symbol` - impossible through import
-            [native$2]: { value: original },
-            [prototypeForwarding]: { value: original },
-        });
-    }
-    // Safe array access with negative indices
-    at(index) {
-        const actualIndex = index < 0 ? this[native$2].length + index : index;
-        dependant(this, actualIndex);
-        if (actualIndex < 0 || actualIndex >= this[native$2].length)
-            return undefined;
-        return reactive(this[native$2][actualIndex]);
-    }
-    push(...items) {
-        const oldLength = this[native$2].length;
-        try {
-            return this[native$2].push(...items);
-        }
-        finally {
-            touched(this, { type: 'bunch', method: 'push' }, range(oldLength, oldLength + items.length - 1, { length: true }));
-        }
-    }
-    pop() {
-        if (this[native$2].length === 0)
-            return undefined;
-        try {
-            return reactive(this[native$2].pop());
-        }
-        finally {
-            touched(this, { type: 'bunch', method: 'pop' }, index(this[native$2].length));
-        }
-    }
-    shift() {
-        if (this[native$2].length === 0)
-            return undefined;
-        try {
-            return reactive(this[native$2].shift());
-        }
-        finally {
-            touched(this, { type: 'bunch', method: 'shift' }, range(0, this[native$2].length + 1, { length: true }));
-        }
-    }
-    unshift(...items) {
-        try {
-            return this[native$2].unshift(...items);
-        }
-        finally {
-            touched(this, { type: 'bunch', method: 'unshift' }, range(0, this[native$2].length - items.length, { length: true }));
-        }
-    }
-    splice(start, deleteCount, ...items) {
-        const oldLength = this[native$2].length;
-        if (deleteCount === undefined)
-            deleteCount = oldLength - start;
-        try {
-            if (deleteCount === undefined)
-                return reactive(this[native$2].splice(start));
-            return reactive(this[native$2].splice(start, deleteCount, ...items));
-        }
-        finally {
-            touched(this, { type: 'bunch', method: 'splice' }, 
-            // TODO: edge cases
-            deleteCount === items.length
-                ? range(start, start + deleteCount)
-                : range(start, oldLength + Math.max(items.length - deleteCount, 0), {
-                    length: true,
-                }));
-        }
-    }
-    reverse() {
-        try {
-            return this[native$2].reverse();
-        }
-        finally {
-            touched(this, { type: 'bunch', method: 'reverse' }, range(0, this[native$2].length - 1));
-        }
-    }
-    sort(compareFn) {
-        try {
-            return this[native$2].sort(compareFn);
-        }
-        finally {
-            touched(this, { type: 'bunch', method: 'sort' }, range(0, this[native$2].length - 1));
-        }
-    }
-    fill(value, start, end) {
-        try {
-            if (start === undefined)
-                return this[native$2].fill(value);
-            if (end === undefined)
-                return this[native$2].fill(value, start);
-            return this[native$2].fill(value, start, end);
-        }
-        finally {
-            touched(this, { type: 'bunch', method: 'fill' }, range(0, this[native$2].length - 1));
-        }
-    }
-    copyWithin(target, start, end) {
-        try {
-            if (end === undefined)
-                return this[native$2].copyWithin(target, start);
-            return this[native$2].copyWithin(target, start, end);
-        }
-        finally {
-            touched(this, { type: 'bunch', method: 'copyWithin' }, 
-            // TODO: calculate the range properly
-            range(0, this[native$2].length - 1));
-        }
-        // Touch all affected indices with a single allProps call
-    }
-    // Immutable versions of mutator methods
-    toReversed() {
-        dependant(this);
-        return reactive(this[native$2].toReversed());
-    }
-    toSorted(compareFn) {
-        dependant(this);
-        return reactive(this[native$2].toSorted(compareFn));
-    }
-    toSpliced(start, deleteCount, ...items) {
-        dependant(this);
-        return deleteCount === undefined
-            ? this[native$2].toSpliced(start)
-            : this[native$2].toSpliced(start, deleteCount, ...items);
-    }
-    with(index, value) {
-        dependant(this);
-        return reactive(this[native$2].with(index, value));
-    }
-    // Iterator methods with reactivity tracking
-    entries() {
-        dependant(this);
-        return makeReactiveEntriesIterator(this[native$2].entries());
-    }
-    keys() {
-        dependant(this);
-        return this[native$2].keys();
-    }
-    values() {
-        dependant(this);
-        return makeReactiveIterator(this[native$2].values());
-    }
-    [Symbol.iterator]() {
-        dependant(this);
-        const nativeIterator = this[native$2][Symbol.iterator]();
-        return {
-            next() {
-                const result = nativeIterator.next();
-                if (result.done) {
-                    return result;
-                }
-                return { value: reactive(result.value), done: false };
-            },
-        };
-    }
-    indexOf(searchElement, fromIndex) {
-        dependant(this);
-        return this[native$2].indexOf(searchElement, fromIndex);
-    }
-    lastIndexOf(searchElement, fromIndex) {
-        dependant(this);
-        return this[native$2].lastIndexOf(searchElement, fromIndex);
-    }
-    includes(searchElement, fromIndex) {
-        dependant(this);
-        return this[native$2].includes(searchElement, fromIndex);
-    }
-    find(predicate, thisArg) {
-        dependant(this);
-        return reactive(this[native$2].find(predicate, thisArg));
-    }
-    findIndex(predicate, thisArg) {
-        dependant(this);
-        return this[native$2].findIndex(predicate, thisArg);
-    }
-    flat() {
-        dependant(this);
-        return reactive(this[native$2].flat());
-    }
-    flatMap(callbackfn, thisArg) {
-        dependant(this);
-        return reactive(this[native$2].flatMap(callbackfn, thisArg));
-    }
-    filter(callbackfn, thisArg) {
-        dependant(this);
-        return reactive(this[native$2].filter(callbackfn, thisArg));
-    }
-    map(callbackfn, thisArg) {
-        dependant(this);
-        return reactive(this[native$2].map(callbackfn, thisArg));
-    }
-    reduce(callbackfn, initialValue) {
-        dependant(this);
-        const result = initialValue === undefined
-            ? this[native$2].reduce(callbackfn)
-            : this[native$2].reduce(callbackfn, initialValue);
-        return reactive(result);
-    }
-    reduceRight(callbackfn, initialValue) {
-        dependant(this);
-        const result = initialValue !== undefined
-            ? this[native$2].reduceRight(callbackfn, initialValue)
-            : this[native$2].reduceRight(callbackfn);
-        return reactive(result);
-    }
-    slice(start, end) {
-        for (const i of range(start || 0, end || this[native$2].length - 1))
-            dependant(this, i);
-        return start === undefined
-            ? this[native$2].slice()
-            : end === undefined
-                ? this[native$2].slice(start)
-                : this[native$2].slice(start, end);
-    }
-    concat(...items) {
-        dependant(this);
-        return reactive(this[native$2].concat(...items));
-    }
-    join(separator) {
-        dependant(this);
-        return this[native$2].join(separator);
-    }
-    forEach(callbackfn, thisArg) {
-        dependant(this);
-        this[native$2].forEach(callbackfn, thisArg);
-    }
-    // TODO: re-implement for fun dependencies? (eg - every only check the first ones until it find some),
-    // no need to make it dependant on indexes after the found one
-    every(callbackfn, thisArg) {
-        dependant(this);
-        return this[native$2].every(callbackfn, thisArg);
-    }
-    some(callbackfn, thisArg) {
-        dependant(this);
-        return this[native$2].some(callbackfn, thisArg);
-    }
-}
 
-const native$1 = Symbol('native');
-class ReactiveWeakMap {
-    constructor(original) {
-        Object.defineProperties(this, {
-            [native$1]: { value: original },
-            [prototypeForwarding]: { value: original },
-            content: { value: Symbol('content') },
-            [Symbol.toStringTag]: { value: 'ReactiveWeakMap' },
-        });
-    }
-    // Implement WeakMap interface methods with reactivity
-    delete(key) {
-        const hadKey = this[native$1].has(key);
-        const result = this[native$1].delete(key);
-        if (hadKey)
-            touched1(this.content, { type: 'del', prop: key }, key);
-        return result;
-    }
-    get(key) {
-        dependant(this.content, key);
-        return reactive(this[native$1].get(key));
-    }
-    has(key) {
-        dependant(this.content, key);
-        return this[native$1].has(key);
-    }
-    set(key, value) {
-        // Trigger effects for the specific key
-        touched1(this.content, { type: this[native$1].has(key) ? 'set' : 'add', prop: key }, key);
-        this[native$1].set(key, value);
-        return this;
-    }
-}
-class ReactiveMap {
-    constructor(original) {
-        Object.defineProperties(this, {
-            [native$1]: { value: original },
-            [prototypeForwarding]: { value: original },
-            content: { value: Symbol('content') },
-            [Symbol.toStringTag]: { value: 'ReactiveMap' },
-        });
-    }
-    // Implement Map interface methods with reactivity
-    get size() {
-        dependant(this, 'size'); // The ReactiveMap instance still goes through proxy
-        return this[native$1].size;
-    }
-    clear() {
-        const hadEntries = this[native$1].size > 0;
-        this[native$1].clear();
-        if (hadEntries) {
-            const evolution = { type: 'bunch', method: 'clear' };
-            // Clear triggers all effects since all keys are affected
-            touched1(this, evolution, 'size');
-            touched(this.content, evolution);
-        }
-    }
-    entries() {
-        dependant(this.content);
-        return makeReactiveEntriesIterator(this[native$1].entries());
-    }
-    forEach(callbackfn, thisArg) {
-        dependant(this.content);
-        this[native$1].forEach(callbackfn, thisArg);
-    }
-    keys() {
-        dependant(this.content);
-        return this[native$1].keys();
-    }
-    values() {
-        dependant(this.content);
-        return makeReactiveIterator(this[native$1].values());
-    }
-    [Symbol.iterator]() {
-        dependant(this.content);
-        const nativeIterator = this[native$1][Symbol.iterator]();
-        return {
-            next() {
-                const result = nativeIterator.next();
-                if (result.done) {
-                    return result;
-                }
-                return {
-                    value: [result.value[0], reactive(result.value[1])],
-                    done: false,
-                };
-            },
-        };
-    }
-    // Implement Map methods with reactivity
-    delete(key) {
-        const hadKey = this[native$1].has(key);
-        const result = this[native$1].delete(key);
-        if (hadKey) {
-            const evolution = { type: 'del', prop: key };
-            touched1(this.content, evolution, key);
-            touched1(this, evolution, 'size');
-        }
-        return result;
-    }
-    get(key) {
-        dependant(this.content, key);
-        return reactive(this[native$1].get(key));
-    }
-    has(key) {
-        dependant(this.content, key);
-        return this[native$1].has(key);
-    }
-    set(key, value) {
-        const hadKey = this[native$1].has(key);
-        const oldValue = this[native$1].get(key);
-        const reactiveValue = reactive(value);
-        this[native$1].set(key, reactiveValue);
-        if (!hadKey || oldValue !== reactiveValue) {
-            const evolution = { type: hadKey ? 'set' : 'add', prop: key };
-            touched1(this.content, evolution, key);
-            touched1(this, evolution, 'size');
-        }
-        return this;
-    }
-}
-
-const native = Symbol('native');
-class ReactiveWeakSet {
-    constructor(original) {
-        Object.defineProperties(this, {
-            [native]: { value: original },
-            [prototypeForwarding]: { value: original },
-            content: { value: Symbol('content') },
-            [Symbol.toStringTag]: { value: 'ReactiveWeakSet' },
-        });
-    }
-    add(value) {
-        const had = this[native].has(value);
-        this[native].add(value);
-        if (!had) {
-            // touch the specific value and the collection view
-            touched1(this.content, { type: 'add', prop: value }, value);
-            // no size/allProps for WeakSet
-        }
-        return this;
-    }
-    delete(value) {
-        const had = this[native].has(value);
-        const res = this[native].delete(value);
-        if (had)
-            touched1(this.content, { type: 'del', prop: value }, value);
-        return res;
-    }
-    has(value) {
-        dependant(this.content, value);
-        return this[native].has(value);
-    }
-}
-class ReactiveSet {
-    constructor(original) {
-        Object.defineProperties(this, {
-            [native]: { value: original },
-            [prototypeForwarding]: { value: original },
-            content: { value: Symbol('content') },
-            [Symbol.toStringTag]: { value: 'ReactiveSet' },
-        });
-    }
-    get size() {
-        // size depends on the wrapper instance, like Map counterpart
-        dependant(this, 'size');
-        return this[native].size;
-    }
-    add(value) {
-        const had = this[native].has(value);
-        const reactiveValue = reactive(value);
-        this[native].add(reactiveValue);
-        if (!had) {
-            const evolution = { type: 'add', prop: reactiveValue };
-            // touch for value-specific and aggregate dependencies
-            touched1(this.content, evolution, reactiveValue);
-            touched1(this, evolution, 'size');
-        }
-        return this;
-    }
-    clear() {
-        const hadEntries = this[native].size > 0;
-        this[native].clear();
-        if (hadEntries) {
-            const evolution = { type: 'bunch', method: 'clear' };
-            touched1(this, evolution, 'size');
-            touched(this.content, evolution);
-        }
-    }
-    delete(value) {
-        const had = this[native].has(value);
-        const res = this[native].delete(value);
-        if (had) {
-            const evolution = { type: 'del', prop: value };
-            touched1(this.content, evolution, value);
-            touched1(this, evolution, 'size');
-        }
-        return res;
-    }
-    has(value) {
-        dependant(this.content, value);
-        return this[native].has(value);
-    }
-    entries() {
-        dependant(this.content);
-        return makeReactiveEntriesIterator(this[native].entries());
-    }
-    forEach(callbackfn, thisArg) {
-        dependant(this.content);
-        this[native].forEach(callbackfn, thisArg);
-    }
-    keys() {
-        dependant(this.content);
-        return makeReactiveIterator(this[native].keys());
-    }
-    values() {
-        dependant(this.content);
-        return makeReactiveIterator(this[native].values());
-    }
-    [Symbol.iterator]() {
-        dependant(this.content);
-        const nativeIterator = this[native][Symbol.iterator]();
-        return {
-            next() {
-                const result = nativeIterator.next();
-                if (result.done) {
-                    return result;
-                }
-                return { value: reactive(result.value), done: false };
-            },
-        };
-    }
-}
-
-// Register native collection types to use specialized reactive wrappers
-registerNativeReactivity(WeakMap, ReactiveWeakMap);
-registerNativeReactivity(Map, ReactiveMap);
-registerNativeReactivity(WeakSet, ReactiveWeakSet);
-registerNativeReactivity(Set, ReactiveSet);
-registerNativeReactivity(Array, ReactiveArray);
-
-exports.ReactiveBase = ReactiveBase;
-exports.ReactiveError = ReactiveError;
-exports.atomic = atomic;
-exports.computed = computed;
-exports.effect = effect;
-exports.getState = getState;
-exports.immutables = immutables;
-exports.invalidateComputed = invalidateComputed;
-exports.isNonReactive = isNonReactive;
-exports.isReactive = isReactive;
-exports.profileInfo = profileInfo;
-exports.reactive = reactive;
-exports.reactiveOptions = options;
-exports.unreactive = unreactive;
-exports.untracked = untracked;
-exports.unwrap = unwrap;
-exports.watch = watch;
+exports.Reactive = reactive.Reactive;
+exports.ReactiveBase = reactive.ReactiveBase;
+exports.ReactiveError = reactive.ReactiveError;
+Object.defineProperty(exports, "activeEffect", {
+	enumerable: true,
+	get: function () { return reactive.activeEffect; }
+});
+exports.addBatchCleanup = reactive.addBatchCleanup;
+exports.atomic = reactive.atomic;
+exports.cleanedBy = reactive.cleanedBy;
+exports.computed = reactive.computed;
+exports.effect = reactive.effect;
+exports.getState = reactive.getState;
+exports.immutables = reactive.immutables;
+exports.invalidateComputed = reactive.invalidateComputed;
+exports.isNonReactive = reactive.isNonReactive;
+exports.isReactive = reactive.isReactive;
+exports.profileInfo = reactive.profileInfo;
+exports.reactive = reactive.reactive;
+exports.reactiveOptions = reactive.options;
+exports.trackEffect = reactive.trackEffect;
+exports.unreactive = reactive.unreactive;
+exports.untracked = reactive.untracked;
+exports.unwrap = reactive.unwrap;
+exports.watch = reactive.watch;
 //# sourceMappingURL=reactive.js.map