mutts 1.0.2 → 1.0.4

package/dist/chunks/index-DBScoeCX.esm.js

@@ -1,1960 +0,0 @@
-import { i as isConstructor, R as ReflectGet, d as decorator, c as isObject, a as ReflectSet, b as isOwnAccessor, r as renamed } from './decorator-GnHw1Az7.esm.js';
-import { a as __setFunctionName, b as __esDecorate, c as __runInitializers } from './_tslib-CMEnd0VE.esm.js';
-import { Indexable } from '../indexable.esm.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 (!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 = 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 (!activeEffect)
-        throw new Error('Not in an effect');
-    if (!effectTrackers.has(activeEffect))
-        effectTrackers.set(activeEffect, new Set([onTouch]));
-    else
-        effectTrackers.get(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 (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);
-    }
-}
-// 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;
-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(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({
-    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(activeEffect))
-        return fn();
-    const oldActiveEffect = activeEffect;
-    const oldParentEffect = parentEffect;
-    activeEffect = effect;
-    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)
-                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 ReflectGet(obj, prop, receiver);
-        // Depend if...
-        if (!Reflect.has(receiver, prop) ||
-            (!(options.instanceMembers && !Object.hasOwn(receiver, prop)) &&
-                !(options.ignoreAccessors && isOwnAccessor(receiver, prop))))
-            dependant(obj, prop);
-        const value = 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 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(ReflectGet(obj, prop, receiver)) : absent;
-        track1(obj, prop, oldVal, newValue);
-        if (oldVal !== newValue) {
-            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({
-    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) || !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({
-    getter(original, propertyKey) {
-        const computers = new WeakMap();
-        return function () {
-            if (!computers.has(this)) {
-                computers.set(this, 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 = 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 = 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({
-    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);
-                }
-            }
-        }
-    };
-    __setFunctionName(_classThis, "Memoized");
-    (() => {
-        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-        __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 });
-        __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(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);
-
-export { Reactive as R, activeEffect as a, addBatchCleanup as b, atomic as c, isNonReactive as d, effect as e, isReactive as f, getState as g, ReactiveBase as h, immutables as i, ReactiveError as j, unwrap as k, cleanedBy as l, mixin as m, computed as n, options as o, profileInfo as p, invalidateComputed as q, reactive as r, unreactive as s, trackEffect as t, untracked as u, watch as w };
-//# sourceMappingURL=index-DBScoeCX.esm.js.map