mutts 1.0.0

package/dist/reactive.js

@@ -0,0 +1,1472 @@
+'use strict';
+
+var decorator = require('./chunks/decorator-BXsign4Z.js');
+var indexable = 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();
+/**
+ * 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))
+                    hasEffect(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) {
+    // TODO: avoid depending on property get?
+    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 hasEffect(effect) {
+    const root = getRoot(effect);
+    options?.chain(getRoot(effect), getRoot(activeEffect));
+    if (batchedEffects)
+        batchedEffects.set(root, effect);
+    else {
+        const runEffects = [];
+        batchedEffects = new Map([[root, effect]]);
+        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);
+                effect();
+                batchedEffects.delete(root);
+            }
+        }
+        finally {
+            batchedEffects = undefined;
+        }
+    }
+}
+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)
+                hasEffect(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);
+        const absent = !(prop in obj);
+        // Depend if...
+        if (!options.instanceMembers || Object.hasOwn(receiver, prop) || absent)
+            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 = obj[prop];
+        const oldPresent = prop in obj;
+        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: oldPresent ? '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);
+    // Run the effect immediately
+    if (!batchedEffects) {
+        hasEffect(runEffect);
+    }
+    else {
+        const oldBatchedEffects = batchedEffects;
+        try {
+            // Simulate a hasEffect who batches, but do not execute the batch, give it back to the parent batch,
+            // Only the immediate effect has to be executed, the sub-effects will be executed by the parent batch
+            batchedEffects = new Map([[fn, runEffect]]);
+            runEffect();
+            batchedEffects.delete(fn);
+            for (const [root, effect] of batchedEffects)
+                oldBatchedEffects.set(root, effect);
+        }
+        finally {
+            batchedEffects = oldBatchedEffects;
+        }
+    }
+    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;
+    }
+    // TODO: parentEffect = last non-undefined activeEffect
+    // 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);
+    withEffect(undefined, () => {
+        const stop = effect(markWithRoot((dep) => {
+            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: 'set', prop: key }, key);
+                stop();
+            }
+            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)
+    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');
+// TODO: [prototypeForwarding]
+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');
+// TODO: [prototypeForwarding]
+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.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;
+//# sourceMappingURL=reactive.js.map