mutts 1.0.2 → 1.0.3

package/dist/chunks/index-DOTmXL89.js

@@ -1,1983 +0,0 @@
-'use strict';
-
-var decorator = require('./decorator-D4DU97Zg.js');
-var _tslib = require('./_tslib-C-cuVLvZ.js');
-var indexable = require('../indexable.js');
-
-/**
- * Creates a mixin that can be used both as a class (extends) and as a function (mixin)
- *
- * This function supports:
- * - Using mixins as base classes: `class MyClass extends MyMixin`
- * - Using mixins as functions: `class MyClass extends MyMixin(SomeBase)`
- * - Composing mixins: `const Composed = MixinA(MixinB)`
- * - Type-safe property inference for all patterns
- *
- * @param mixinFunction - The function that creates the mixin
- * @param unwrapFunction - Optional function to unwrap reactive objects for method calls
- * @returns A mixin that can be used both as a class and as a function
- */
-function mixin(mixinFunction, unwrapFunction) {
-    /**
-     * Cache for mixin results to ensure the same base class always returns the same mixed class
-     */
-    const mixinCache = new WeakMap();
-    // Apply the mixin to Object as the base class
-    const MixedBase = mixinFunction(Object);
-    mixinCache.set(Object, MixedBase);
-    // Create the proxy that handles both constructor and function calls
-    return new Proxy(MixedBase, {
-        // Handle `MixinClass(SomeBase)` - use as mixin function
-        apply(_target, _thisArg, args) {
-            if (args.length === 0) {
-                throw new Error('Mixin requires a base class');
-            }
-            const baseClass = args[0];
-            if (typeof baseClass !== 'function') {
-                throw new Error('Mixin requires a constructor function');
-            }
-            // Check if it's a valid constructor or a mixin
-            if (!decorator.isConstructor(baseClass) &&
-                !(baseClass && typeof baseClass === 'function' && baseClass.prototype)) {
-                throw new Error('Mixin requires a valid constructor');
-            }
-            // Check cache first
-            const cached = mixinCache.get(baseClass);
-            if (cached) {
-                return cached;
-            }
-            let usedBase = baseClass;
-            if (unwrapFunction) {
-                // Create a proxied base class that handles method unwrapping
-                const ProxiedBaseClass = class extends baseClass {
-                };
-                // Proxy the prototype methods to handle unwrapping
-                const originalPrototype = baseClass.prototype;
-                const proxiedPrototype = new Proxy(originalPrototype, {
-                    get(target, prop, receiver) {
-                        const value = decorator.ReflectGet(target, prop, receiver);
-                        // Only wrap methods that are likely to access private fields
-                        // Skip symbols and special properties that the reactive system needs
-                        if (typeof value === 'function' &&
-                            typeof prop === 'string' &&
-                            !['constructor', 'toString', 'valueOf'].includes(prop)) {
-                            // Return a wrapped version that uses unwrapped context
-                            return function (...args) {
-                                // Use the unwrapping function if provided, otherwise use this
-                                const context = unwrapFunction(this);
-                                return value.apply(context, args);
-                            };
-                        }
-                        return value;
-                    },
-                });
-                // Set the proxied prototype
-                Object.setPrototypeOf(ProxiedBaseClass.prototype, proxiedPrototype);
-                usedBase = ProxiedBaseClass;
-            }
-            // Create the mixed class using the proxied base class
-            const mixedClass = mixinFunction(usedBase);
-            // Cache the result
-            mixinCache.set(baseClass, mixedClass);
-            return mixedClass;
-        },
-    });
-}
-
-// 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
-/**
- * WeakSet containing objects that should never be made reactive
- */
-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();
-/**
- * Object containing internal reactive system state for debugging and profiling
- */
-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');
-/**
- * Symbol for prototype forwarding in reactive objects
- */
-const prototypeForwarding = Symbol('prototype-forwarding');
-/**
- * Symbol representing all properties in reactive tracking
- */
-const allProps = Symbol('all-props');
-// Symbol to mark functions with their root function
-const rootFunction = Symbol('root-function');
-/**
- * Marks a function with its root function for effect tracking
- * @param fn - The function to mark
- * @param root - The root function
- * @returns The marked function
- */
-function markWithRoot(fn, root) {
-    // Mark fn with the new root
-    return Object.defineProperty(fn, rootFunction, {
-        value: getRoot(root),
-        writable: false,
-    });
-}
-/**
- * Gets the root function of a function for effect tracking
- * @param fn - The function to get the root of
- * @returns The root function
- */
-function getRoot(fn) {
-    return fn?.[rootFunction] || fn;
-}
-/**
- * Error class for reactive system errors
- */
-class ReactiveError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'ReactiveError';
-    }
-}
-// biome-ignore-start lint/correctness/noUnusedFunctionParameters: Interface declaration with empty defaults
-/**
- * Global options for the reactive system
- */
-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: (targets, caller) => { },
-    /**
-     * Debug purpose: called when an effect chain is started
-     * @param target - The effect that is being triggered
-     */
-    beginChain: (targets) => { },
-    /**
-     * Debug purpose: called when an effect chain is ended
-     */
-    endChain: () => { },
-    /**
-     * Debug purpose: called when an object is touched
-     * @param obj - The object that is touched
-     * @param evolution - The type of change
-     * @param props - The properties that changed
-     * @param deps - The dependencies that changed
-     */
-    touched: (obj, evolution, props, deps) => { },
-    /**
-     * Debug purpose: maximum effect chain (like call stack max depth)
-     * Used to prevent infinite loops
-     * @default 100
-     */
-    maxEffectChain: 100,
-    /**
-     * Debug purpose: maximum effect reaction (like call stack max depth)
-     * Used to prevent infinite loops
-     * @default 'throw'
-     */
-    maxEffectReaction: 'throw',
-    /**
-     * 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,
-    /**
-     * Ignore accessors (getters and setters) and only track direct properties
-     * @default true
-     */
-    ignoreAccessors: true,
-    // biome-ignore lint/suspicious/noConsole: This is the whole point here
-    warn: (...args) => console.warn(...args),
-};
-/**
- * Registers a debug callback that is called when the current effect is triggered by a dependency change
- *
- * This function is useful for debugging purposes as it pin-points exactly which reactive property
- * change triggered the effect. The callback receives information about:
- * - The object that changed
- * - The type of change (evolution)
- * - The specific property that changed
- *
- * **Note:** The tracker callback is automatically removed after being called once. If you need
- * to track multiple triggers, call `trackEffect` again within the effect.
- *
- * @param onTouch - Callback function that receives (obj, evolution, prop) when the effect is triggered
- * @throws {Error} If called outside of an effect context
- *
- * @example
- * ```typescript
- * const state = reactive({ count: 0, name: 'John' })
- *
- * effect(() => {
- *   // Register a tracker to see what triggers this effect
- *   trackEffect((obj, evolution, prop) => {
- *     console.log(`Effect triggered by:`, {
- *       object: obj,
- *       change: evolution.type,
- *       property: prop
- *     })
- *   })
- *
- *   // Access reactive properties
- *   console.log(state.count, state.name)
- * })
- *
- * state.count = 5
- * // Logs: Effect triggered by: { object: state, change: 'set', property: 'count' }
- * ```
- */
-function trackEffect(onTouch) {
-    if (!exports.activeEffect)
-        throw new Error('Not in an effect');
-    if (!effectTrackers.has(exports.activeEffect))
-        effectTrackers.set(exports.activeEffect, new Set([onTouch]));
-    else
-        effectTrackers.get(exports.activeEffect).add(onTouch);
-}
-const effectTrackers = new WeakMap();
-function collectEffects(obj, evolution, effects, 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)) {
-                    effects.add(effect);
-                    const trackers = effectTrackers.get(effect);
-                    if (trackers) {
-                        for (const tracker of trackers)
-                            tracker(obj, evolution, key);
-                        trackers.delete(effect);
-                    }
-                }
-        }
-}
-/**
- * Triggers effects for a single property change
- * @param obj - The object that changed
- * @param evolution - The type of change
- * @param prop - The property that changed
- */
-function touched1(obj, evolution, prop) {
-    touched(obj, evolution, [prop]);
-}
-/**
- * Triggers effects for property changes
- * @param obj - The object that changed
- * @param evolution - The type of change
- * @param props - The properties that changed
- */
-function touched(obj, evolution, props) {
-    obj = unwrap(obj);
-    addState(obj, evolution);
-    const objectWatchers = watchers.get(obj);
-    if (objectWatchers) {
-        // Note: we have to collect effects to remove duplicates in the specific case when no batch is running
-        const effects = new Set();
-        if (props) {
-            props = Array.from(props); // For debug purposes only
-            collectEffects(obj, evolution, effects, objectWatchers, [allProps], props);
-        }
-        else
-            collectEffects(obj, evolution, effects, objectWatchers, objectWatchers.keys());
-        options.touched(obj, evolution, props, effects);
-        batch(Array.from(effects));
-    }
-    // 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);
-}
-/**
- * Gets the current state of a reactive object for evolution tracking
- * @param obj - The reactive object
- * @returns The current state object
- */
-function getState(obj) {
-    obj = unwrap(obj);
-    let state = states.get(obj);
-    if (!state) {
-        state = {};
-        states.set(obj, state);
-    }
-    return state;
-}
-/**
- * Marks a property as a dependency of the current effect
- * @param obj - The object containing the property
- * @param prop - The property name (defaults to allProps)
- */
-function dependant(obj, prop = allProps) {
-    obj = unwrap(obj);
-    if (exports.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(exports.activeEffect);
-        // Track which reactive objects this effect is watching
-        let effectObjects = effectToReactiveObjects.get(exports.activeEffect);
-        if (!effectObjects) {
-            effectObjects = new Set();
-            effectToReactiveObjects.set(exports.activeEffect, effectObjects);
-        }
-        effectObjects.add(obj);
-    }
-}
-// Active effects to handle nested effects
-exports.activeEffect = void 0;
-// 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;
-const batchCleanups = new Set();
-/**
- * Adds a cleanup function to be called when the current batch of effects completes
- * @param cleanup - The cleanup function to add
- */
-function addBatchCleanup(cleanup) {
-    if (!batchedEffects)
-        cleanup();
-    else
-        batchCleanups.add(cleanup);
-}
-// 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 batch(effect, immediate) {
-    if (!Array.isArray(effect))
-        effect = [effect];
-    const roots = effect.map(getRoot);
-    if (batchedEffects) {
-        options?.chain(roots, getRoot(exports.activeEffect));
-        for (let i = 0; i < effect.length; i++)
-            batchedEffects.set(roots[i], effect[i]);
-        if (immediate)
-            for (let i = 0; i < effect.length; i++)
-                try {
-                    return effect[i]();
-                }
-                finally {
-                    batchedEffects.delete(roots[i]);
-                }
-    }
-    else {
-        options.beginChain(roots);
-        const runEffects = [];
-        batchedEffects = new Map(roots.map((root, i) => [root, effect[i]]));
-        const firstReturn = {};
-        try {
-            while (batchedEffects.size) {
-                if (runEffects.length > options.maxEffectChain) {
-                    switch (options.maxEffectReaction) {
-                        case 'throw':
-                            throw new ReactiveError('[reactive] Max effect chain reached');
-                        case 'debug':
-                            // biome-ignore lint/suspicious/noDebugger: This is the whole point here
-                            debugger;
-                            break;
-                        case 'warn':
-                            options.warn('[reactive] Max effect chain reached');
-                            break;
-                    }
-                }
-                const [root, effect] = batchedEffects.entries().next().value;
-                runEffects.push(root);
-                const rv = effect();
-                if (!('value' in firstReturn))
-                    firstReturn.value = rv;
-                batchedEffects.delete(root);
-            }
-            const cleanups = Array.from(batchCleanups);
-            batchCleanups.clear();
-            for (const cleanup of cleanups)
-                cleanup();
-            return firstReturn.value;
-        }
-        finally {
-            batchedEffects = undefined;
-            options.endChain();
-        }
-    }
-}
-/**
- * Decorator that makes methods atomic - batches all effects triggered within the method
- */
-const atomic = decorator.decorator({
-    method(original) {
-        return function (...args) {
-            return batch(markWithRoot(() => original.apply(this, args), original), 'immediate');
-        };
-    },
-    default(original) {
-        return function (...args) {
-            return batch(markWithRoot(() => original.apply(this, args), original), 'immediate');
-        };
-    },
-});
-/**
- * Executes a function with a specific effect context
- * @param effect - The effect to use as context
- * @param fn - The function to execute
- * @param keepParent - Whether to keep the parent effect context
- * @returns The result of the function
- */
-function withEffect(effect, fn, keepParent) {
-    if (getRoot(effect) === getRoot(exports.activeEffect))
-        return fn();
-    const oldActiveEffect = exports.activeEffect;
-    const oldParentEffect = parentEffect;
-    exports.activeEffect = effect;
-    parentEffect = effect;
-    try {
-        return fn();
-    }
-    finally {
-        exports.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)
-                batch(watcher);
-        // Continue bubbling up
-        bubbleUpChange(parent);
-    }
-}
-/**
- * Tracks property changes and manages back-references for deep watching
- * @param obj - The object that changed
- * @param prop - The property that changed
- * @param oldVal - The old value
- * @param newValue - The new value
- */
-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 (unwrap(obj)[unreactiveProperties]?.has(prop) || typeof prop === 'symbol')
-            return decorator.ReflectGet(obj, prop, receiver);
-        // Depend if...
-        if (!Reflect.has(receiver, prop) ||
-            (!(options.instanceMembers && !Object.hasOwn(receiver, prop)) &&
-                !(options.ignoreAccessors && decorator.isOwnAccessor(receiver, prop))))
-            dependant(obj, prop);
-        const value = decorator.ReflectGet(Object.hasOwn(obj, prop) ? obj : Object.getPrototypeOf(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 (unwrap(obj)[unreactiveProperties]?.has(prop))
-            return decorator.ReflectSet(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) ? unwrap(decorator.ReflectGet(obj, prop, receiver)) : absent;
-        track1(obj, prop, oldVal, newValue);
-        if (oldVal !== newValue) {
-            decorator.ReflectSet(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();
-// Create the ReactiveBase mixin
-/**
- * Base mixin for reactive classes that provides proper constructor reactivity
- * Solves constructor reactivity issues in complex inheritance trees
- */
-const ReactiveBase = mixin((base) => {
-    class ReactiveMixin extends base {
-        constructor(...args) {
-            super(...args);
-            // Only apply reactive transformation if the class is marked with @reactive
-            // This allows the mixin to work properly with method inheritance
-            // biome-ignore lint/correctness/noConstructorReturn: This is the whole point here
-            return reactiveClasses.has(new.target) ? reactive(this) : this;
-        }
-    }
-    return ReactiveMixin;
-});
-/**
- * Always-reactive mixin that makes classes inherently reactive
- * Can be used as both a base class and a mixin function
- */
-const Reactive = mixin((base) => {
-    class ReactiveMixin extends base {
-        constructor(...args) {
-            super(...args);
-            // Only apply reactive transformation if the class is marked with @reactive
-            // This allows the mixin to work properly with method inheritance
-            // biome-ignore lint/correctness/noConstructorReturn: This is the whole point here
-            return reactive(this);
-        }
-    }
-    ReactiveMixin.__isReactiveMixin = true;
-    return ReactiveMixin;
-}, unwrap);
-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;
-}
-/**
- * Main decorator for making classes reactive
- * Automatically makes class instances reactive when created
- */
-const reactive = decorator.decorator({
-    class(original) {
-        if (original.prototype instanceof ReactiveBase) {
-            reactiveClasses.add(original);
-            return original;
-        }
-        // Check if the class extends the Reactive mixin (not ReactiveBase) by checking the prototype chain
-        let current = original.prototype;
-        while (current && current !== Object.prototype) {
-            // Check if this is the Reactive mixin specifically (not ReactiveBase)
-            if (current.constructor && current.constructor.__isReactiveMixin) {
-                throw new Error('@reactive decorator cannot be used with Reactive mixin. Reactive mixin already provides reactivity.');
-            }
-            current = Object.getPrototypeOf(current);
-        }
-        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,
-});
-/**
- * Gets the original, non-reactive object from a reactive proxy
- * @param proxy - The reactive proxy
- * @returns The original object
- */
-function unwrap(proxy) {
-    // Return the original object
-    return proxyToObject.get(proxy) ?? proxy;
-}
-/**
- * Checks if an object is a reactive proxy
- * @param obj - The object to check
- * @returns True if the object is reactive
- */
-function isReactive(obj) {
-    return proxyToObject.has(obj);
-}
-/**
- * Executes a function without tracking dependencies
- * @param fn - The function to execute
- */
-function untracked(fn) {
-    let rv;
-    withEffect(undefined, () => {
-        rv = fn();
-    } /*,
-    true*/);
-    return rv;
-}
-// runEffect -> set<stop>
-const effectChildren = new WeakMap();
-const fr = new FinalizationRegistry((f) => f());
-/**
- * @param fn - The effect function to run - provides the cleaner
- * @returns The cleanup function
- */
-/**
- * Creates a reactive effect that automatically re-runs when dependencies change
- * @param fn - The effect function that provides dependencies and may return a cleanup function
- * @param args - Additional arguments that are forwarded to the effect function
- * @returns A cleanup function to stop the effect
- */
-function effect(fn, ...args) {
-    let cleanup = null;
-    // capture the parent effect at creation time for ascend
-    const parentForAscend = parentEffect;
-    const tracked = markWithRoot((cb) => withEffect(runEffect, cb), fn);
-    const ascend = markWithRoot((cb) => withEffect(parentForAscend, cb), getRoot(parentForAscend));
-    let effectStopped = false;
-    let init = true;
-    function runEffect() {
-        // The effect has been stopped after having been planned
-        if (effectStopped)
-            return;
-        // Clear previous dependencies
-        cleanup?.();
-        options.enter(getRoot(fn));
-        let reactionCleanup;
-        try {
-            reactionCleanup = withEffect(runEffect, () => fn({ tracked, ascend, init }, ...args));
-        }
-        finally {
-            init = false;
-            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);
-            }
-            // Invoke all child stops (recursive via subEffectCleanup calling its own mainCleanup)
-            const children = effectChildren.get(runEffect);
-            if (children) {
-                for (const childCleanup of children)
-                    childCleanup();
-                effectChildren.delete(runEffect);
-            }
-        };
-    }
-    // Mark the runEffect callback with the original function as its root
-    markWithRoot(runEffect, fn);
-    batch(runEffect, 'immediate');
-    const stopEffect = () => {
-        if (effectStopped)
-            return;
-        effectStopped = true;
-        cleanup?.();
-        fr.unregister(stopEffect);
-    };
-    const parent = parentEffect;
-    // Only ROOT effects are registered for GC cleanup
-    if (!parent) {
-        const callIfCollected = () => stopEffect();
-        fr.register(callIfCollected, stopEffect, stopEffect);
-        return callIfCollected;
-    }
-    // Register this effect to be stopped when the parent effect is cleaned up
-    let children = effectChildren.get(parent);
-    if (!children) {
-        children = new Set();
-        effectChildren.set(parent, children);
-    }
-    const subEffectCleanup = () => {
-        children.delete(subEffectCleanup);
-        if (children.size === 0) {
-            effectChildren.delete(parent);
-        }
-        // Execute this child effect cleanup (which triggers its own mainCleanup)
-        stopEffect();
-    };
-    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 that test if objects are immutable
- * Objects that pass these tests will not be made reactive
- */
-const immutables = new Set();
-/**
- * Checks if an object is marked as non-reactive
- * @param obj - The object to check
- * @returns True if the object is 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;
-}
-/**
- * Marks classes as non-reactive
- * @param cls - Classes to mark as non-reactive
- * @returns The first class (for chaining)
- */
-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)
-/**
- * Registers a native class to use a specialized reactive wrapper
- * @param originalClass - The original class to register
- * @param reactiveClass - The reactive wrapper class
- */
-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
- */
-/**
- * Sets up deep watching for an object, tracking all nested property changes
- * @param target - The object to watch
- * @param callback - The callback to call when changes occur
- * @param options - Options for deep watching
- * @returns A cleanup function to stop deep 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) || !decorator.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);
-            }
-        };
-    });
-}
-
-//#region computed
-let computedInvalidations;
-/**
- * Registers a callback to be called when a 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 once = effect(markWithRoot((access) => {
-        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);
-            once();
-            stopped = true;
-        }
-        else
-            try {
-                computedInvalidations = invalidations;
-                computedCache.set(key, getter(access));
-            }
-            finally {
-                computedInvalidations = oldCI;
-            }
-    }, getter));
-    return computedCache.get(key);
-}
-/**
- * Decorator and function for creating computed properties that cache their values
- * Only recomputes when dependencies change
- */
-const computed = Object.assign(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: computedFunction,
-}), {
-    map: computedMap,
-    memo: computedMapMemo,
-    self: selfReferencing,
-});
-//#endregion
-//#region watch
-const unsetYet = Symbol('unset-yet');
-function watch(value, //object | ((dep: DependencyAccess) => 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 } = {}) {
-    const myParentEffect = exports.activeEffect;
-    if (deep)
-        return deepWatch(value, changed, { immediate });
-    return effect(markWithRoot(function watchObjectEffect() {
-        dependant(value);
-        if (immediate)
-            withEffect(myParentEffect, () => changed(value));
-        immediate = true;
-    }, changed));
-}
-function watchCallBack(value, changed, { immediate = false, deep = false } = {}) {
-    const myParentEffect = exports.activeEffect;
-    let oldValue = unsetYet;
-    let deepCleanup;
-    const cbCleanup = effect(markWithRoot(function watchCallBackEffect(access) {
-        const newValue = value(access);
-        if (oldValue !== newValue)
-            withEffect(myParentEffect, 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
-        });
-}
-/**
- * Decorator that marks classes or properties as non-reactive
- * Prevents objects from being made reactive
- */
-const unreactive = decorator.decorator({
-    class(original) {
-        // Called without arguments, mark entire class as non-reactive
-        nonReactiveClass(original);
-    },
-    default: unreactiveApplication,
-});
-Object.assign(profileInfo, { computedCache });
-function cleanedBy(obj, cleanup) {
-    return Object.defineProperty(obj, 'cleanup', {
-        value: cleanup,
-        writable: false,
-        enumerable: false,
-        configurable: true,
-    });
-}
-function computedMap(inputs, compute, resize) {
-    const result = reactive([]);
-    const cleanups = [];
-    function input(index) {
-        return effect(function computedIndexedMapInputEffect() {
-            result[index] = compute(inputs[index], index, result[index]);
-        });
-    }
-    effect(function computedMapLengthEffect({ ascend }) {
-        const length = inputs.length;
-        const resultLength = untracked(() => result.length);
-        resize?.(length, resultLength);
-        if (length < resultLength) {
-            const toCleanup = cleanups.splice(length);
-            for (const cleanup of toCleanup)
-                cleanup();
-            result.length = length;
-        }
-        else if (length > resultLength)
-            // the input effects will be registered as the call's children, so they will remain not cleaned with this effect on length
-            ascend(function computedMapNewElements() {
-                for (let i = resultLength; i < length; i++)
-                    cleanups.push(input(i));
-            });
-    });
-    return cleanedBy(result, () => {
-        for (const cleanup of cleanups)
-            cleanup();
-        cleanups.length = 0;
-    });
-}
-let Memoized = (() => {
-    let _classDecorators = [unreactive];
-    let _classDescriptor;
-    let _classExtraInitializers = [];
-    let _classThis;
-    _classThis = class {
-        constructor(compute) {
-            this.compute = compute;
-            this.cache = new Map();
-            this.keepCleanups = effect(({ ascend }) => {
-                this.inEffect = ascend;
-                return () => {
-                    this.cleanup();
-                };
-            });
-        }
-        cleanup() {
-            for (const { cleanup } of this.cache.values())
-                cleanup();
-            this.cache.clear();
-        }
-        get(input) {
-            dependant(this, input);
-            let cached;
-            if (this.cache.has(input)) {
-                cached = this.cache.get(input);
-            }
-            else {
-                cached = {};
-                cached.cleanup = this.inEffect(() => effect(Object.defineProperties(() => {
-                    if ('value' in cached) {
-                        this.cache.delete(input);
-                        touched1(this, { type: 'invalidate', prop: input }, input);
-                    }
-                    else {
-                        cached.value = this.compute(input);
-                    }
-                }, { name: { value: 'Memoize' } })));
-                this.cache.set(input, cached);
-            }
-            return cached.value;
-        }
-        reduceInputs(inputs) {
-            for (const input of this.cache.keys()) {
-                if (typeof inputs === 'function' ? !inputs(input) : !inputs.has(input)) {
-                    const entry = this.cache.get(input);
-                    entry.cleanup();
-                    this.cache.delete(input);
-                }
-            }
-        }
-    };
-    _tslib.__setFunctionName(_classThis, "Memoized");
-    (() => {
-        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-        _tslib.__esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
-        _classThis = _classDescriptor.value;
-        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        _tslib.__runInitializers(_classThis, _classExtraInitializers);
-    })();
-    return _classThis;
-})();
-function computedMapMemo(inputs, compute) {
-    const memo = new Memoized(compute);
-    const result = reactive([]);
-    return cleanedBy(result, effect(() => {
-        const inputArray = typeof inputs === 'function' ? inputs() : inputs;
-        function reduceKeys() {
-            untracked(() => {
-                memo.reduceInputs(new Set(inputArray));
-            });
-        }
-        const map = computedMap(inputArray, (input) => {
-            addBatchCleanup(reduceKeys);
-            return memo.get(input);
-        }, () => addBatchCleanup(reduceKeys));
-        effect(() => {
-            result.length = 0;
-            result.push(...map);
-        });
-    }));
-}
-function selfReferencing(compute) {
-    let rv;
-    const cleanup = effect((access) => {
-        rv = compute(access);
-    });
-    return cleanedBy(rv, cleanup);
-}
-
-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 } = {}) {
-    if (length)
-        yield 'length';
-    yield i;
-}
-function* range(a, b, { length = false } = {}) {
-    const start = Math.min(a, b);
-    const end = Math.max(a, b);
-    if (length)
-        yield 'length';
-    for (let i = start; i <= end; i++)
-        yield i;
-}
-/**
- * Reactive wrapper around JavaScript's Array class with full array method support
- * Tracks length changes, individual index operations, and collection-wide operations
- */
-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: 'set', prop: i }, 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) {
-        compareFn = compareFn || ((a, b) => a.toString().localeCompare(b.toString()));
-        try {
-            return this[native$2].sort((a, b) => compareFn(reactive(a), reactive(b)));
-        }
-        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, 'length');
-        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((item, index, array) => callbackfn(reactive(item), index, array), thisArg));
-    }
-    map(callbackfn, thisArg) {
-        dependant(this);
-        return reactive(this[native$2].map((item, index, array) => callbackfn(reactive(item), index, array), 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');
-/**
- * Reactive wrapper around JavaScript's WeakMap class
- * Only tracks individual key operations, no size tracking (WeakMap limitation)
- */
-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;
-    }
-}
-/**
- * Reactive wrapper around JavaScript's Map class
- * Tracks size changes, individual key operations, and collection-wide operations
- */
-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');
-/**
- * Reactive wrapper around JavaScript's WeakSet class
- * Only tracks individual value operations, no size tracking (WeakSet limitation)
- */
-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);
-    }
-}
-/**
- * Reactive wrapper around JavaScript's Set class
- * Tracks size changes, individual value operations, and collection-wide operations
- */
-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.Reactive = Reactive;
-exports.ReactiveBase = ReactiveBase;
-exports.ReactiveError = ReactiveError;
-exports.addBatchCleanup = addBatchCleanup;
-exports.atomic = atomic;
-exports.cleanedBy = cleanedBy;
-exports.computed = computed;
-exports.effect = effect;
-exports.getState = getState;
-exports.immutables = immutables;
-exports.invalidateComputed = invalidateComputed;
-exports.isNonReactive = isNonReactive;
-exports.isReactive = isReactive;
-exports.mixin = mixin;
-exports.options = options;
-exports.profileInfo = profileInfo;
-exports.reactive = reactive;
-exports.trackEffect = trackEffect;
-exports.unreactive = unreactive;
-exports.untracked = untracked;
-exports.unwrap = unwrap;
-exports.watch = watch;
-//# sourceMappingURL=index-DOTmXL89.js.map