@rlabs-inc/signals 0.2.0 → 1.0.0

package/dist/index.mjs

@@ -1,431 +1,926 @@
-// src/index.ts
-var activeReaction = null;
-var reactionStack = [];
-var batchDepth = 0;
-var pendingReactions = new Set;
-var untracking = false;
-var proxyToSignal = new WeakMap;
-var rawToProxy = new WeakMap;
-var defaultEquals = (a, b) => Object.is(a, b);
-var shallowEquals = (a, b) => {
-  if (Object.is(a, b))
+// src/reactivity/equality.ts
+var equals = (oldValue, newValue) => Object.is(oldValue, newValue);
+function safeNotEqual(a, b) {
+  return a != a ? b == b : a !== b || a !== null && typeof a === "object" || typeof a === "function";
+}
+var safeEquals = (oldValue, newValue) => !safeNotEqual(oldValue, newValue);
+var shallowEquals = (oldValue, newValue) => {
+  if (Object.is(oldValue, newValue)) {
     return true;
-  if (typeof a !== "object" || typeof b !== "object")
-    return false;
-  if (a === null || b === null)
+  }
+  if (typeof oldValue !== "object" || oldValue === null || typeof newValue !== "object" || newValue === null) {
     return false;
-  const keysA = Object.keys(a);
-  const keysB = Object.keys(b);
-  if (keysA.length !== keysB.length)
+  }
+  if (Array.isArray(oldValue) && Array.isArray(newValue)) {
+    if (oldValue.length !== newValue.length) {
+      return false;
+    }
+    for (let i = 0;i < oldValue.length; i++) {
+      if (!Object.is(oldValue[i], newValue[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  const oldKeys = Object.keys(oldValue);
+  const newKeys = Object.keys(newValue);
+  if (oldKeys.length !== newKeys.length) {
     return false;
-  for (const key of keysA) {
-    if (!Object.is(a[key], b[key]))
+  }
+  for (const key of oldKeys) {
+    if (!Object.prototype.hasOwnProperty.call(newValue, key) || !Object.is(oldValue[key], newValue[key])) {
       return false;
+    }
   }
   return true;
 };
-function signal(initial, options) {
-  const internal = {
-    v: initial,
-    reactions: new Set,
-    equals: options?.equals ?? defaultEquals
-  };
-  let proxyCache = null;
-  return {
-    get value() {
-      track(internal);
-      if (internal.v !== null && typeof internal.v === "object") {
-        if (!proxyCache) {
-          proxyCache = createDeepReactiveForSignal(internal.v, internal);
+function createEquals(fn) {
+  return (oldValue, newValue) => fn(oldValue, newValue);
+}
+var neverEquals = () => false;
+var alwaysEquals = () => true;
+
+// src/core/constants.ts
+var DERIVED = 1 << 1;
+var EFFECT = 1 << 2;
+var RENDER_EFFECT = 1 << 3;
+var ROOT_EFFECT = 1 << 4;
+var BRANCH_EFFECT = 1 << 5;
+var USER_EFFECT = 1 << 6;
+var BLOCK_EFFECT = 1 << 7;
+var CLEAN = 1 << 10;
+var DIRTY = 1 << 11;
+var MAYBE_DIRTY = 1 << 12;
+var REACTION_IS_UPDATING = 1 << 13;
+var DESTROYED = 1 << 14;
+var INERT = 1 << 15;
+var EFFECT_RAN = 1 << 16;
+var EFFECT_PRESERVED = 1 << 17;
+var UNOWNED = 1 << 8;
+var DISCONNECTED = 1 << 9;
+var INSPECT_EFFECT = 1 << 18;
+var UNINITIALIZED = Symbol.for("rlabs.signals.uninitialized");
+var STALE_REACTION = Symbol.for("rlabs.signals.stale_reaction");
+var STATE_SYMBOL = Symbol.for("rlabs.signals.state");
+var REACTIVE_MARKER = Symbol.for("rlabs.signals.reactive");
+var STATUS_MASK = ~(DIRTY | MAYBE_DIRTY | CLEAN);
+
+// src/core/globals.ts
+var activeReaction = null;
+var activeEffect = null;
+var untracking = false;
+var writeVersion = 1;
+var readVersion = 0;
+var newDeps = null;
+var skippedDeps = 0;
+var untrackedWrites = null;
+var batchDepth = 0;
+var pendingReactions = new Set;
+var queuedRootEffects = [];
+var isFlushingSync = false;
+function setActiveReaction(reaction) {
+  const prev = activeReaction;
+  activeReaction = reaction;
+  return prev;
+}
+function setActiveEffect(effect) {
+  const prev = activeEffect;
+  activeEffect = effect;
+  return prev;
+}
+function setUntracking(value) {
+  const prev = untracking;
+  untracking = value;
+  return prev;
+}
+function incrementWriteVersion() {
+  return ++writeVersion;
+}
+function incrementReadVersion() {
+  return ++readVersion;
+}
+function setNewDeps(deps) {
+  const prev = newDeps;
+  newDeps = deps;
+  return prev;
+}
+function setSkippedDeps(count) {
+  const prev = skippedDeps;
+  skippedDeps = count;
+  return prev;
+}
+function setUntrackedWrites(writes) {
+  const prev = untrackedWrites;
+  untrackedWrites = writes;
+  return prev;
+}
+function addUntrackedWrite(signal) {
+  if (untrackedWrites === null) {
+    untrackedWrites = [signal];
+  } else {
+    untrackedWrites.push(signal);
+  }
+}
+function incrementBatchDepth() {
+  return ++batchDepth;
+}
+function decrementBatchDepth() {
+  return --batchDepth;
+}
+function setIsFlushingSync(value) {
+  const prev = isFlushingSync;
+  isFlushingSync = value;
+  return prev;
+}
+function clearPendingReactions() {
+  pendingReactions = new Set;
+}
+function addPendingReaction(reaction) {
+  pendingReactions.add(reaction);
+}
+function clearQueuedRootEffects() {
+  const prev = queuedRootEffects;
+  queuedRootEffects = [];
+  return prev;
+}
+function addQueuedRootEffect(effect) {
+  queuedRootEffects.push(effect);
+}
+function getReadVersion() {
+  return readVersion;
+}
+function getWriteVersion() {
+  return writeVersion;
+}
+function getBatchDepth() {
+  return batchDepth;
+}
+
+// src/reactivity/scheduling.ts
+function scheduleEffect(reaction) {
+  addPendingReaction(reaction);
+  if (batchDepth > 0) {
+    return;
+  }
+  let effect = reaction;
+  while (effect.parent !== null) {
+    effect = effect.parent;
+    const flags = effect.f;
+    if ((flags & (ROOT_EFFECT | BRANCH_EFFECT)) !== 0) {
+      if ((flags & CLEAN) === 0) {
+        return;
+      }
+      effect.f ^= CLEAN;
+    }
+  }
+  addQueuedRootEffect(effect);
+  if (!isFlushingSync) {
+    queueMicrotask(flushEffects);
+  }
+}
+var updateEffectImpl = () => {
+  throw new Error("updateEffect not initialized - import effect.ts first");
+};
+function setUpdateEffectImpl(impl) {
+  updateEffectImpl = impl;
+}
+function flushEffects() {
+  const roots = clearQueuedRootEffects();
+  for (const root of roots) {
+    if (isDirty(root)) {
+      updateEffectImpl(root);
+    }
+    processEffectTree(root);
+  }
+}
+function processEffectTree(effect) {
+  let child = effect.first;
+  while (child !== null) {
+    const next = child.next;
+    if (isDirty(child)) {
+      updateEffectImpl(child);
+    }
+    if (child.first !== null) {
+      processEffectTree(child);
+    }
+    child = next;
+  }
+}
+function flushPendingReactions() {
+  const reactions = [...pendingReactions];
+  clearPendingReactions();
+  for (const reaction of reactions) {
+    if (isDirty(reaction)) {
+      if ("parent" in reaction) {
+        updateEffectImpl(reaction);
+      }
+    }
+  }
+}
+var MAX_FLUSH_COUNT = 1000;
+function flushSync(fn) {
+  const wasFlushingSync = isFlushingSync;
+  setIsFlushingSync(true);
+  try {
+    let result;
+    let flushCount = 0;
+    if (fn) {
+      flushEffects();
+      result = fn();
+    }
+    while (true) {
+      if (++flushCount > MAX_FLUSH_COUNT) {
+        throw new Error("Maximum update depth exceeded. This can happen when an effect " + "continuously triggers itself. Check for effects that write to " + "signals they depend on without proper guards.");
+      }
+      const roots = clearQueuedRootEffects();
+      if (roots.length === 0) {
+        if (pendingReactions.size === 0) {
+          return result;
         }
-        return proxyCache;
+        flushPendingReactions();
+        continue;
       }
-      return internal.v;
-    },
-    set value(newValue) {
-      if (!internal.equals(internal.v, newValue)) {
-        internal.v = newValue;
-        proxyCache = null;
-        trigger(internal);
+      for (const root of roots) {
+        if (isDirty(root)) {
+          updateEffectImpl(root);
+        }
+        processEffectTree(root);
       }
     }
-  };
+  } finally {
+    setIsFlushingSync(wasFlushingSync);
+  }
 }
-function effect(fn) {
-  const reaction = {
-    execute: () => {
-      if (reaction.cleanup) {
-        reaction.cleanup();
-        reaction.cleanup = undefined;
-      }
-      for (const dep of reaction.deps) {
-        dep.reactions.delete(reaction);
-      }
-      reaction.deps.clear();
-      reactionStack.push(reaction);
-      const prevReaction = activeReaction;
-      activeReaction = reaction;
-      try {
-        const cleanup = fn();
-        if (typeof cleanup === "function") {
-          reaction.cleanup = cleanup;
+async function tick() {
+  await Promise.resolve();
+  flushSync();
+}
+
+// src/reactivity/tracking.ts
+function get(signal) {
+  if (activeReaction !== null && !untracking) {
+    if ((activeReaction.f & REACTION_IS_UPDATING) !== 0) {
+      if (signal.rv < readVersion) {
+        signal.rv = readVersion;
+        const deps = activeReaction.deps;
+        if (newDeps === null && deps !== null && deps[skippedDeps] === signal) {
+          setSkippedDeps(skippedDeps + 1);
+        } else {
+          if (newDeps === null) {
+            setNewDeps([signal]);
+          } else {
+            newDeps.push(signal);
+          }
         }
-      } finally {
-        activeReaction = prevReaction;
-        reactionStack.pop();
       }
-    },
-    deps: new Set,
-    active: true
-  };
-  reaction.execute();
-  return () => {
-    if (!reaction.active)
-      return;
-    reaction.active = false;
-    if (reaction.cleanup) {
-      reaction.cleanup();
+    } else {
+      if (activeReaction.deps === null) {
+        activeReaction.deps = [signal];
+      } else if (!activeReaction.deps.includes(signal)) {
+        activeReaction.deps.push(signal);
+      }
+      if (signal.reactions === null) {
+        signal.reactions = [activeReaction];
+      } else if (!signal.reactions.includes(activeReaction)) {
+        signal.reactions.push(activeReaction);
+      }
     }
-    for (const dep of reaction.deps) {
-      dep.reactions.delete(reaction);
+  }
+  if ((signal.f & DERIVED) !== 0) {
+    const derived = signal;
+    if (isDirty(derived)) {
+      updateDerived(derived);
     }
-    reaction.deps.clear();
-  };
+  }
+  return signal.v;
 }
-function derived(fn, options) {
-  const internal = {
-    v: undefined,
-    reactions: new Set,
-    equals: options?.equals ?? defaultEquals,
-    fn,
-    dirty: true
-  };
-  const deps = new Set;
-  const markDirty = () => {
-    if (!internal.dirty) {
-      internal.dirty = true;
-      trigger(internal);
-    }
-  };
-  const recompute = () => {
-    for (const dep of deps) {
-      dep.reactions.delete(derivedReaction);
+function set(signal, value) {
+  if (activeReaction !== null && (activeReaction.f & DERIVED) !== 0) {
+    throw new Error("Cannot write to signals inside a derived. " + "Deriveds should be pure computations with no side effects.");
+  }
+  if (!signal.equals(signal.v, value)) {
+    signal.v = value;
+    signal.wv = incrementWriteVersion();
+    markReactions(signal, DIRTY);
+    if (activeEffect !== null && (activeEffect.f & CLEAN) !== 0 && (activeEffect.f & (ROOT_EFFECT | BRANCH_EFFECT)) === 0) {
+      addUntrackedWrite(signal);
     }
-    deps.clear();
-    const prevReaction = activeReaction;
-    activeReaction = derivedReaction;
-    try {
-      const newValue = fn();
-      internal.v = newValue;
-    } finally {
-      activeReaction = prevReaction;
+  }
+  return value;
+}
+function markReactions(signal, status) {
+  const reactions = signal.reactions;
+  if (reactions === null)
+    return;
+  for (let i = 0;i < reactions.length; i++) {
+    const reaction = reactions[i];
+    const flags = reaction.f;
+    const notDirty = (flags & DIRTY) === 0;
+    if (notDirty) {
+      setSignalStatus(reaction, status);
     }
-    internal.dirty = false;
-  };
-  const derivedReaction = {
-    execute: markDirty,
-    deps,
-    active: true
-  };
-  return {
-    get value() {
-      track(internal);
-      if (internal.dirty) {
-        recompute();
-      }
-      return internal.v;
+    if ((flags & DERIVED) !== 0) {
+      markReactions(reaction, MAYBE_DIRTY);
+    } else if (notDirty) {
+      scheduleEffect(reaction);
     }
-  };
+  }
 }
-derived.by = derived;
-function batch(fn) {
-  batchDepth++;
-  try {
-    return fn();
-  } finally {
-    batchDepth--;
-    if (batchDepth === 0) {
-      flushPending();
+function setSignalStatus(signal, status) {
+  signal.f = signal.f & STATUS_MASK | status;
+}
+function isDirty(reaction) {
+  if ((reaction.f & DIRTY) !== 0) {
+    return true;
+  }
+  if ((reaction.f & MAYBE_DIRTY) !== 0) {
+    const deps = reaction.deps;
+    if (deps !== null) {
+      for (let i = 0;i < deps.length; i++) {
+        const dep = deps[i];
+        if ((dep.f & DERIVED) !== 0) {
+          if (isDirty(dep)) {
+            updateDerived(dep);
+          }
+        }
+        if (dep.wv > reaction.wv) {
+          return true;
+        }
+      }
     }
+    setSignalStatus(reaction, CLEAN);
   }
+  return false;
 }
-function untrack(fn) {
-  const prev = untracking;
-  untracking = true;
-  try {
-    return fn();
-  } finally {
-    untracking = prev;
+var updateDerivedImpl = () => {
+  throw new Error("updateDerived not initialized - import derived.ts first");
+};
+function updateDerived(derived) {
+  updateDerivedImpl(derived);
+}
+function setUpdateDerivedImpl(impl) {
+  updateDerivedImpl = impl;
+}
+function removeReactions(reaction, start) {
+  const deps = reaction.deps;
+  if (deps === null)
+    return;
+  for (let i = start;i < deps.length; i++) {
+    removeReaction(reaction, deps[i]);
   }
 }
-function track(signal2) {
-  if (activeReaction && !untracking) {
-    activeReaction.deps.add(signal2);
-    signal2.reactions.add(activeReaction);
+function removeReaction(reaction, dep) {
+  const reactions = dep.reactions;
+  if (reactions === null)
+    return;
+  const index = reactions.indexOf(reaction);
+  if (index !== -1) {
+    const last = reactions.length - 1;
+    if (index !== last) {
+      reactions[index] = reactions[last];
+    }
+    reactions.pop();
+    if (reactions.length === 0) {
+      dep.reactions = null;
+    }
   }
 }
-function trigger(signal2) {
-  const reactions = [...signal2.reactions];
-  for (const reaction of reactions) {
-    if (!reaction.active)
-      continue;
-    if ("dirty" in reaction) {
-      reaction.dirty = true;
+function updateReaction(reaction) {
+  const prevNewDeps = newDeps;
+  const prevSkippedDeps = skippedDeps;
+  const prevReaction = activeReaction;
+  const prevUntrackedWrites = untrackedWrites;
+  setNewDeps(null);
+  setSkippedDeps(0);
+  setActiveReaction(reaction);
+  setUntrackedWrites(null);
+  const prevReadVersion = readVersion;
+  incrementReadVersion();
+  reaction.f |= REACTION_IS_UPDATING;
+  try {
+    const result = reaction.fn();
+    const deps = reaction.deps;
+    if (newDeps !== null) {
+      removeReactions(reaction, skippedDeps);
+      if (deps !== null && skippedDeps > 0) {
+        deps.length = skippedDeps + newDeps.length;
+        for (let i = 0;i < newDeps.length; i++) {
+          deps[skippedDeps + i] = newDeps[i];
+        }
+      } else {
+        reaction.deps = newDeps;
+      }
+      const finalDeps = reaction.deps;
+      for (let i = skippedDeps;i < finalDeps.length; i++) {
+        const dep = finalDeps[i];
+        if (dep.reactions === null) {
+          dep.reactions = [reaction];
+        } else {
+          dep.reactions.push(reaction);
+        }
+      }
+    } else if (deps !== null && skippedDeps < deps.length) {
+      removeReactions(reaction, skippedDeps);
+      deps.length = skippedDeps;
     }
-    if (batchDepth > 0) {
-      pendingReactions.add(reaction);
+    if (untrackedWrites !== null && reaction.deps !== null && (reaction.f & EFFECT) !== 0 && (reaction.f & DERIVED) === 0) {
+      for (const signal of untrackedWrites) {
+        if (reaction.deps.includes(signal)) {
+          setSignalStatus(reaction, DIRTY);
+          scheduleEffect(reaction);
+          break;
+        }
+      }
+    }
+    return result;
+  } finally {
+    reaction.f &= ~REACTION_IS_UPDATING;
+    setNewDeps(prevNewDeps);
+    setSkippedDeps(prevSkippedDeps);
+    setActiveReaction(prevReaction);
+    if (untrackedWrites !== null) {
+      if (prevUntrackedWrites === null) {
+        setUntrackedWrites(untrackedWrites);
+      } else {
+        prevUntrackedWrites.push(...untrackedWrites);
+        setUntrackedWrites(prevUntrackedWrites);
+      }
     } else {
-      reaction.execute();
+      setUntrackedWrites(prevUntrackedWrites);
     }
   }
 }
-function flushPending() {
-  const reactions = [...pendingReactions];
-  pendingReactions.clear();
-  for (const reaction of reactions) {
-    if (reaction.active) {
-      reaction.execute();
+
+// src/primitives/signal.ts
+function source(initialValue, options) {
+  return {
+    f: 0,
+    v: initialValue,
+    equals: options?.equals ?? equals,
+    reactions: null,
+    rv: 0,
+    wv: 0
+  };
+}
+function mutableSource(initialValue) {
+  return source(initialValue, { equals: safeEquals });
+}
+function signal(initialValue, options) {
+  const src = source(initialValue, options);
+  return {
+    get value() {
+      return get(src);
+    },
+    set value(newValue) {
+      set(src, newValue);
     }
+  };
+}
+var proxyFn = null;
+function setProxyFn(fn) {
+  proxyFn = fn;
+}
+function state(initialValue) {
+  if (proxyFn === null) {
+    throw new Error("state() requires proxy to be initialized. Import from index.ts.");
   }
+  return proxyFn(initialValue);
 }
-var REACTIVE_MARKER = Symbol("reactive");
-function state(initial) {
-  return createDeepReactive(initial);
+function stateRaw(initialValue) {
+  return signal(initialValue);
 }
+
+// src/deep/proxy.ts
 function shouldProxy(value) {
-  if (value === null || typeof value !== "object")
-    return false;
-  if (value[REACTIVE_MARKER])
+  if (value === null || typeof value !== "object") {
     return false;
+  }
   const proto = Object.getPrototypeOf(value);
   return proto === Object.prototype || proto === Array.prototype || proto === null;
 }
-function createDeepReactive(target) {
-  const existing = rawToProxy.get(target);
-  if (existing)
-    return existing;
-  const internal = {
-    v: target,
-    reactions: new Set,
-    equals: defaultEquals
+function isProxy(value) {
+  return value !== null && typeof value === "object" && STATE_SYMBOL in value;
+}
+function isWritable(target, prop) {
+  const descriptor = Object.getOwnPropertyDescriptor(target, prop);
+  return descriptor === undefined || descriptor.writable === true;
+}
+function proxy(value) {
+  if (!shouldProxy(value) || isProxy(value)) {
+    return value;
+  }
+  const sources = new Map;
+  const version = source(0);
+  const isArray = Array.isArray(value);
+  if (isArray) {
+    sources.set("length", source(value.length));
+  }
+  const parentReadVersion = readVersion;
+  const withParent = (fn) => {
+    if (readVersion === parentReadVersion) {
+      return fn();
+    }
+    const prevReaction = activeReaction;
+    setActiveReaction(null);
+    try {
+      return fn();
+    } finally {
+      setActiveReaction(prevReaction);
+    }
   };
-  const propSignals = new Map;
-  const getPropSignal = (prop) => {
-    let sig = propSignals.get(prop);
-    if (!sig) {
-      sig = {
-        v: target[prop],
-        reactions: new Set,
-        equals: defaultEquals
-      };
-      propSignals.set(prop, sig);
+  const getSource = (prop, initialValue) => {
+    let s = sources.get(prop);
+    if (s === undefined) {
+      s = withParent(() => {
+        const proxied = shouldProxy(initialValue) ? proxy(initialValue) : initialValue;
+        return source(proxied);
+      });
+      sources.set(prop, s);
     }
-    return sig;
+    return s;
   };
-  const proxy = new Proxy(target, {
-    get(target2, prop, receiver) {
-      if (prop === REACTIVE_MARKER)
-        return true;
-      const value = Reflect.get(target2, prop, receiver);
-      if (Array.isArray(target2) && typeof value === "function") {
-        track(internal);
-        return value.bind(proxy);
-      }
-      const sig = getPropSignal(prop);
-      track(sig);
-      if (shouldProxy(value)) {
-        const existingProxy = rawToProxy.get(value);
-        if (existingProxy)
-          return existingProxy;
-        return createDeepReactive(value);
-      }
-      return value;
-    },
-    set(target2, prop, value, receiver) {
-      const oldValue = target2[prop];
-      const rawValue = value?.[REACTIVE_MARKER] ? proxyToRaw.get(value) ?? value : value;
-      if (Object.is(oldValue, rawValue))
-        return true;
-      const result = Reflect.set(target2, prop, rawValue, receiver);
-      if (result) {
-        const sig = getPropSignal(prop);
-        sig.v = rawValue;
-        trigger(sig);
-        if (Array.isArray(target2)) {
-          internal.v = target2;
-          trigger(internal);
+  const proxyObj = new Proxy(value, {
+    get(target, prop, receiver) {
+      if (prop === STATE_SYMBOL) {
+        return value;
+      }
+      const exists = prop in target;
+      const currentValue = Reflect.get(target, prop, receiver);
+      if (isArray && typeof currentValue === "function") {
+        get(version);
+        return currentValue.bind(proxyObj);
+      }
+      if (exists || isWritable(target, prop)) {
+        const s = getSource(prop, currentValue);
+        const val = get(s);
+        if (val === UNINITIALIZED) {
+          return;
         }
+        return val;
       }
-      return result;
+      return currentValue;
     },
-    deleteProperty(target2, prop) {
-      const hadKey = prop in target2;
-      const result = Reflect.deleteProperty(target2, prop);
-      if (result && hadKey) {
-        const sig = propSignals.get(prop);
-        if (sig) {
-          sig.v = undefined;
-          trigger(sig);
+    set(target, prop, newValue, receiver) {
+      const exists = prop in target;
+      let s = sources.get(prop);
+      if (s === undefined) {
+        if (!exists && !isWritable(target, prop)) {
+          return false;
         }
-        trigger(internal);
+        s = withParent(() => source(undefined));
+        sources.set(prop, s);
       }
-      return result;
-    },
-    has(target2, prop) {
-      if (prop === REACTIVE_MARKER)
-        return true;
-      track(internal);
-      return Reflect.has(target2, prop);
-    },
-    ownKeys(target2) {
-      track(internal);
-      return Reflect.ownKeys(target2);
-    }
-  });
-  rawToProxy.set(target, proxy);
-  proxyToRaw.set(proxy, target);
-  proxyToSignal.set(proxy, internal);
-  return proxy;
-}
-var proxyToRaw = new WeakMap;
-var signalProxyCache = new WeakMap;
-function createDeepReactiveForSignal(target, parentSignal) {
-  const existingProxy = signalProxyCache.get(target);
-  if (existingProxy)
-    return existingProxy;
-  const propSignals = new Map;
-  const getPropSignal = (prop) => {
-    let sig = propSignals.get(prop);
-    if (!sig) {
-      sig = {
-        v: target[prop],
-        reactions: new Set,
-        equals: defaultEquals
-      };
-      propSignals.set(prop, sig);
-    }
-    return sig;
-  };
-  const internal = {
-    v: target,
-    reactions: new Set,
-    equals: defaultEquals
-  };
-  const proxy = new Proxy(target, {
-    get(target2, prop, receiver) {
-      if (prop === REACTIVE_MARKER)
-        return true;
-      const value = Reflect.get(target2, prop, receiver);
-      if (Array.isArray(target2) && typeof value === "function") {
-        track(internal);
-        return value.bind(proxy);
-      }
-      const sig = getPropSignal(prop);
-      track(sig);
-      if (value !== null && typeof value === "object") {
-        const proto = Object.getPrototypeOf(value);
-        if (proto === Object.prototype || proto === Array.prototype || proto === null) {
-          if (!value[REACTIVE_MARKER]) {
-            return createDeepReactiveForSignal(value, parentSignal);
+      const proxied = withParent(() => shouldProxy(newValue) ? proxy(newValue) : newValue);
+      set(s, proxied);
+      Reflect.set(target, prop, newValue, receiver);
+      if (isArray && prop === "length") {
+        const oldLength = s.v;
+        const newLength = newValue;
+        for (let i = newLength;i < oldLength; i++) {
+          const indexKey = String(i);
+          const indexSource = sources.get(indexKey);
+          if (indexSource !== undefined) {
+            set(indexSource, UNINITIALIZED);
+          } else if (i in target) {
+            const deletedSource = withParent(() => source(UNINITIALIZED));
+            sources.set(indexKey, deletedSource);
           }
         }
       }
-      return value;
-    },
-    set(target2, prop, value, receiver) {
-      const oldValue = target2[prop];
-      const rawValue = value?.[REACTIVE_MARKER] ? proxyToRaw.get(value) ?? value : value;
-      if (Object.is(oldValue, rawValue))
-        return true;
-      const result = Reflect.set(target2, prop, rawValue, receiver);
-      if (result) {
-        batch(() => {
-          const sig = getPropSignal(prop);
-          sig.v = rawValue;
-          trigger(sig);
-          trigger(parentSignal);
-          if (Array.isArray(target2)) {
-            internal.v = target2;
-            trigger(internal);
+      if (isArray && typeof prop === "string") {
+        const index = Number(prop);
+        if (Number.isInteger(index) && index >= 0) {
+          const lengthSource = sources.get("length");
+          if (lengthSource !== undefined && index >= lengthSource.v) {
+            set(lengthSource, index + 1);
           }
-        });
+        }
+      }
+      if (!exists) {
+        set(version, get(version) + 1);
       }
-      return result;
+      return true;
     },
-    deleteProperty(target2, prop) {
-      const hadKey = prop in target2;
-      const result = Reflect.deleteProperty(target2, prop);
-      if (result && hadKey) {
-        batch(() => {
-          const sig = propSignals.get(prop);
-          if (sig) {
-            sig.v = undefined;
-            trigger(sig);
-          }
-          trigger(parentSignal);
-          trigger(internal);
-        });
+    deleteProperty(target, prop) {
+      const exists = prop in target;
+      if (exists) {
+        let s = sources.get(prop);
+        if (s === undefined) {
+          s = withParent(() => source(UNINITIALIZED));
+          sources.set(prop, s);
+        } else {
+          set(s, UNINITIALIZED);
+        }
+        set(version, get(version) + 1);
       }
-      return result;
+      return Reflect.deleteProperty(target, prop);
     },
-    has(target2, prop) {
-      if (prop === REACTIVE_MARKER)
+    has(target, prop) {
+      if (prop === STATE_SYMBOL) {
         return true;
-      track(internal);
-      return Reflect.has(target2, prop);
+      }
+      get(version);
+      const s = sources.get(prop);
+      if (s !== undefined) {
+        const val = get(s);
+        if (val === UNINITIALIZED) {
+          return false;
+        }
+      }
+      return Reflect.has(target, prop);
+    },
+    ownKeys(target) {
+      get(version);
+      const keys = Reflect.ownKeys(target).filter((key) => {
+        const s = sources.get(key);
+        return s === undefined || s.v !== UNINITIALIZED;
+      });
+      for (const [key, s] of sources) {
+        const k = key;
+        if (s.v !== UNINITIALIZED && !(key in target) && !keys.includes(k)) {
+          keys.push(k);
+        }
+      }
+      return keys;
     },
-    ownKeys(target2) {
-      track(internal);
-      return Reflect.ownKeys(target2);
+    getOwnPropertyDescriptor(target, prop) {
+      const s = sources.get(prop);
+      if (s !== undefined && s.v === UNINITIALIZED) {
+        return;
+      }
+      return Reflect.getOwnPropertyDescriptor(target, prop);
     }
   });
-  signalProxyCache.set(target, proxy);
-  proxyToRaw.set(proxy, target);
-  return proxy;
+  return proxyObj;
 }
-function toRaw(proxy) {
-  if (proxy && typeof proxy === "object" && proxy[REACTIVE_MARKER]) {
-    return proxyToRaw.get(proxy) ?? proxy;
+function toRaw(value) {
+  if (value !== null && typeof value === "object" && STATE_SYMBOL in value) {
+    return value[STATE_SYMBOL];
   }
-  return proxy;
+  return value;
 }
 function isReactive(value) {
-  return value !== null && typeof value === "object" && value[REACTIVE_MARKER] === true;
+  return isProxy(value);
 }
-
+// src/primitives/derived.ts
+function createDerived(fn, options) {
+  let flags = DERIVED | DIRTY;
+  const parentDerived = activeReaction !== null && (activeReaction.f & DERIVED) !== 0 ? activeReaction : null;
+  if (activeEffect === null || parentDerived !== null && (parentDerived.f & UNOWNED) !== 0) {
+    flags |= UNOWNED;
+  }
+  const derived = {
+    f: flags,
+    fn,
+    v: UNINITIALIZED,
+    equals: options?.equals ?? equals,
+    reactions: null,
+    deps: null,
+    effects: null,
+    parent: parentDerived ?? activeEffect,
+    rv: 0,
+    wv: 0
+  };
+  return derived;
+}
+function executeDerived(derived) {
+  destroyDerivedEffects(derived);
+  const value = updateReaction(derived);
+  return value;
+}
+function updateDerived2(derived) {
+  const value = executeDerived(derived);
+  if (!derived.equals(derived.v, value)) {
+    derived.v = value;
+    derived.wv = incrementWriteVersion();
+  }
+  const status = (derived.f & UNOWNED) !== 0 && derived.deps !== null ? MAYBE_DIRTY : CLEAN;
+  setSignalStatus(derived, status);
+}
+setUpdateDerivedImpl(updateDerived2);
+var destroyEffectImpl = () => {};
+function setDestroyEffectImpl(impl) {
+  destroyEffectImpl = impl;
+}
+function destroyDerivedEffects(derived) {
+  const effects = derived.effects;
+  if (effects !== null) {
+    derived.effects = null;
+    for (let i = 0;i < effects.length; i++) {
+      destroyEffectImpl(effects[i]);
+    }
+  }
+}
+function derived(fn, options) {
+  const d = createDerived(fn, options);
+  return {
+    get value() {
+      return get(d);
+    }
+  };
+}
+derived.by = derived;
+function disconnectDerived(derived2) {
+  removeReactions(derived2, 0);
+  derived2.deps = null;
+  derived2.reactions = null;
+  destroyDerivedEffects(derived2);
+}
+// src/primitives/effect.ts
+function createEffect(type, fn, sync, push = true) {
+  const parent = activeEffect;
+  const effect = {
+    f: type | DIRTY,
+    fn,
+    deps: null,
+    teardown: null,
+    parent,
+    first: null,
+    last: null,
+    prev: null,
+    next: null,
+    wv: 0
+  };
+  if (sync) {
+    updateEffect(effect);
+    effect.f |= EFFECT_RAN;
+  } else if (fn !== null) {
+    scheduleEffect(effect);
+  }
+  if (push && parent !== null) {
+    pushEffect(effect, parent);
+  }
+  return effect;
+}
+function pushEffect(effect, parent) {
+  const parentLast = parent.last;
+  if (parentLast === null) {
+    parent.first = parent.last = effect;
+  } else {
+    parentLast.next = effect;
+    effect.prev = parentLast;
+    parent.last = effect;
+  }
+}
+function updateEffect(effect) {
+  if ((effect.f & DESTROYED) !== 0)
+    return;
+  setSignalStatus(effect, CLEAN);
+  const prevEffect = activeEffect;
+  setActiveEffect(effect);
+  try {
+    destroyEffectChildren(effect);
+    executeTeardown(effect);
+    const teardown = updateReaction(effect);
+    effect.teardown = typeof teardown === "function" ? teardown : null;
+    effect.wv = incrementWriteVersion();
+  } finally {
+    setActiveEffect(prevEffect);
+  }
+}
+setUpdateEffectImpl(updateEffect);
+function destroyEffect(effect, removeFromParent = true) {
+  destroyEffectChildren(effect);
+  removeReactions(effect, 0);
+  setSignalStatus(effect, DESTROYED);
+  executeTeardown(effect);
+  if (removeFromParent && effect.parent !== null) {
+    unlinkEffect(effect);
+  }
+  effect.fn = null;
+  effect.teardown = null;
+  effect.deps = null;
+  effect.first = null;
+  effect.last = null;
+  effect.prev = null;
+  effect.next = null;
+}
+setDestroyEffectImpl(destroyEffect);
+function destroyEffectChildren(effect) {
+  let child = effect.first;
+  effect.first = null;
+  effect.last = null;
+  while (child !== null) {
+    const next = child.next;
+    if ((child.f & (EFFECT_PRESERVED | ROOT_EFFECT)) === 0) {
+      destroyEffect(child, false);
+    }
+    child = next;
+  }
+}
+function executeTeardown(effect) {
+  const teardown = effect.teardown;
+  if (teardown !== null) {
+    effect.teardown = null;
+    teardown();
+  }
+}
+function unlinkEffect(effect) {
+  const { parent, prev, next } = effect;
+  if (prev !== null) {
+    prev.next = next;
+  }
+  if (next !== null) {
+    next.prev = prev;
+  }
+  if (parent !== null) {
+    if (parent.first === effect) {
+      parent.first = next;
+    }
+    if (parent.last === effect) {
+      parent.last = prev;
+    }
+  }
+  effect.prev = null;
+  effect.next = null;
+}
+function effect(fn) {
+  const eff = createEffect(EFFECT | USER_EFFECT, fn, false);
+  return () => destroyEffect(eff);
+}
+effect.pre = function effectPre(fn) {
+  const eff = createEffect(RENDER_EFFECT | USER_EFFECT, fn, true);
+  return () => destroyEffect(eff);
+};
+effect.root = function effectRoot(fn) {
+  const eff = createEffect(ROOT_EFFECT | EFFECT_PRESERVED, fn, true);
+  return () => destroyEffect(eff);
+};
+effect.tracking = function effectTracking() {
+  return activeEffect !== null;
+};
+// src/reactivity/batching.ts
+function batch(fn) {
+  incrementBatchDepth();
+  try {
+    return fn();
+  } finally {
+    const depth = decrementBatchDepth();
+    if (depth === 0) {
+      flushPendingReactions();
+    }
+  }
+}
+function untrack(fn) {
+  const prev = setUntracking(true);
+  try {
+    return fn();
+  } finally {
+    setUntracking(prev);
+  }
+}
+var peek = untrack;
+// src/collections/map.ts
 class ReactiveMap extends Map {
   #keySignals = new Map;
-  #version = { v: 0, reactions: new Set, equals: defaultEquals };
-  #size = { v: 0, reactions: new Set, equals: defaultEquals };
+  #version = source(0);
+  #size;
   constructor(entries) {
-    super();
-    if (entries) {
-      for (const [key, value] of entries) {
-        super.set(key, value);
-      }
-      this.#size.v = super.size;
-    }
+    super(entries);
+    this.#size = source(super.size);
   }
   #getKeySignal(key) {
     let sig = this.#keySignals.get(key);
-    if (!sig) {
-      sig = { v: 0, reactions: new Set, equals: defaultEquals };
+    if (sig === undefined) {
+      sig = source(0);
       this.#keySignals.set(key, sig);
     }
     return sig;
   }
+  #increment(sig) {
+    set(sig, sig.v + 1);
+  }
   get size() {
-    track(this.#size);
+    get(this.#size);
     return super.size;
   }
   has(key) {
-    const sig = this.#getKeySignal(key);
-    track(sig);
+    const sig = this.#keySignals.get(key);
+    if (sig === undefined) {
+      if (!super.has(key)) {
+        get(this.#version);
+        return false;
+      }
+      const newSig = this.#getKeySignal(key);
+      get(newSig);
+      return true;
+    }
+    get(sig);
     return super.has(key);
   }
   get(key) {
-    const sig = this.#getKeySignal(key);
-    track(sig);
+    const sig = this.#keySignals.get(key);
+    if (sig === undefined) {
+      const val = super.get(key);
+      if (val !== undefined) {
+        const newSig = this.#getKeySignal(key);
+        get(newSig);
+        return val;
+      }
+      get(this.#version);
+      return;
+    }
+    get(sig);
     return super.get(key);
   }
   set(key, value) {
@@ -434,347 +929,476 @@ class ReactiveMap extends Map {
     super.set(key, value);
     const sig = this.#getKeySignal(key);
     if (isNew) {
-      this.#size.v = super.size;
-      trigger(this.#size);
-      this.#version.v++;
-      trigger(this.#version);
-      sig.v++;
-      trigger(sig);
+      set(this.#size, super.size);
+      this.#increment(this.#version);
+      this.#increment(sig);
     } else if (!Object.is(oldValue, value)) {
-      sig.v++;
-      trigger(sig);
+      this.#increment(sig);
+      const versionReactions = this.#version.reactions;
+      const keyReactions = sig.reactions;
+      if (keyReactions !== null && (versionReactions === null || !keyReactions.every((r) => versionReactions.includes(r)))) {
+        this.#increment(this.#version);
+      }
     }
     return this;
   }
   delete(key) {
-    const had = super.has(key);
-    const result = super.delete(key);
-    if (had) {
+    const existed = super.has(key);
+    if (existed) {
+      super.delete(key);
       const sig = this.#keySignals.get(key);
-      if (sig) {
-        sig.v = -1;
-        trigger(sig);
+      if (sig !== undefined) {
+        set(sig, -1);
         this.#keySignals.delete(key);
       }
-      this.#size.v = super.size;
-      trigger(this.#size);
-      this.#version.v++;
-      trigger(this.#version);
+      set(this.#size, super.size);
+      this.#increment(this.#version);
     }
-    return result;
+    return existed;
   }
   clear() {
-    if (super.size === 0)
-      return;
-    for (const sig of this.#keySignals.values()) {
-      sig.v = -1;
-      trigger(sig);
+    if (super.size > 0) {
+      for (const [key, sig] of this.#keySignals) {
+        set(sig, -1);
+      }
+      this.#keySignals.clear();
+      super.clear();
+      set(this.#size, 0);
+      this.#increment(this.#version);
     }
-    super.clear();
-    this.#keySignals.clear();
-    this.#size.v = 0;
-    trigger(this.#size);
-    this.#version.v++;
-    trigger(this.#version);
-  }
-  forEach(callbackfn, thisArg) {
-    track(this.#version);
-    super.forEach(callbackfn, thisArg);
   }
   keys() {
-    track(this.#version);
+    get(this.#version);
     return super.keys();
   }
   values() {
-    track(this.#version);
+    get(this.#version);
     return super.values();
   }
   entries() {
-    track(this.#version);
+    get(this.#version);
     return super.entries();
   }
+  forEach(callbackfn, thisArg) {
+    get(this.#version);
+    super.forEach(callbackfn, thisArg);
+  }
   [Symbol.iterator]() {
     return this.entries();
   }
 }
-
+// src/collections/set.ts
 class ReactiveSet extends Set {
   #itemSignals = new Map;
-  #version = { v: 0, reactions: new Set, equals: defaultEquals };
-  #size = { v: 0, reactions: new Set, equals: defaultEquals };
+  #version = source(0);
+  #size;
   constructor(values) {
-    super();
-    if (values) {
-      for (const value of values) {
-        super.add(value);
-      }
-      this.#size.v = super.size;
-    }
+    super(values);
+    this.#size = source(super.size);
   }
   #getItemSignal(item) {
     let sig = this.#itemSignals.get(item);
-    if (!sig) {
-      sig = { v: super.has(item), reactions: new Set, equals: defaultEquals };
+    if (sig === undefined) {
+      sig = source(super.has(item));
       this.#itemSignals.set(item, sig);
     }
     return sig;
   }
+  #incrementVersion() {
+    set(this.#version, this.#version.v + 1);
+  }
   get size() {
-    track(this.#size);
+    get(this.#size);
     return super.size;
   }
-  has(value) {
-    const sig = this.#getItemSignal(value);
-    track(sig);
-    return super.has(value);
-  }
-  add(value) {
-    if (!super.has(value)) {
-      super.add(value);
-      const sig = this.#getItemSignal(value);
-      sig.v = true;
-      trigger(sig);
-      this.#size.v = super.size;
-      trigger(this.#size);
-      this.#version.v++;
-      trigger(this.#version);
+  has(item) {
+    const sig = this.#itemSignals.get(item);
+    if (sig === undefined) {
+      const exists = super.has(item);
+      if (exists) {
+        const newSig = this.#getItemSignal(item);
+        get(newSig);
+        return true;
+      }
+      get(this.#version);
+      return false;
+    }
+    get(sig);
+    return super.has(item);
+  }
+  add(item) {
+    const isNew = !super.has(item);
+    super.add(item);
+    if (isNew) {
+      const sig = this.#getItemSignal(item);
+      set(sig, true);
+      set(this.#size, super.size);
+      this.#incrementVersion();
     }
     return this;
   }
-  delete(value) {
-    const had = super.has(value);
-    const result = super.delete(value);
-    if (had) {
-      const sig = this.#itemSignals.get(value);
-      if (sig) {
-        sig.v = false;
-        trigger(sig);
-        this.#itemSignals.delete(value);
-      }
-      this.#size.v = super.size;
-      trigger(this.#size);
-      this.#version.v++;
-      trigger(this.#version);
+  delete(item) {
+    const existed = super.has(item);
+    if (existed) {
+      super.delete(item);
+      const sig = this.#itemSignals.get(item);
+      if (sig !== undefined) {
+        set(sig, false);
+        this.#itemSignals.delete(item);
+      }
+      set(this.#size, super.size);
+      this.#incrementVersion();
     }
-    return result;
+    return existed;
   }
   clear() {
-    if (super.size === 0)
-      return;
-    for (const sig of this.#itemSignals.values()) {
-      sig.v = false;
-      trigger(sig);
+    if (super.size > 0) {
+      for (const [item, sig] of this.#itemSignals) {
+        set(sig, false);
+      }
+      this.#itemSignals.clear();
+      super.clear();
+      set(this.#size, 0);
+      this.#incrementVersion();
     }
-    super.clear();
-    this.#itemSignals.clear();
-    this.#size.v = 0;
-    trigger(this.#size);
-    this.#version.v++;
-    trigger(this.#version);
-  }
-  forEach(callbackfn, thisArg) {
-    track(this.#version);
-    super.forEach(callbackfn, thisArg);
   }
   keys() {
-    track(this.#version);
+    get(this.#version);
     return super.keys();
   }
   values() {
-    track(this.#version);
+    get(this.#version);
     return super.values();
   }
   entries() {
-    track(this.#version);
+    get(this.#version);
     return super.entries();
   }
+  forEach(callbackfn, thisArg) {
+    get(this.#version);
+    super.forEach(callbackfn, thisArg);
+  }
   [Symbol.iterator]() {
     return this.values();
   }
 }
-function reactiveArray(initial = []) {
-  const internal = {
-    v: 0,
-    reactions: new Set,
-    equals: defaultEquals
-  };
-  const indexSignals = new Map;
-  const lengthSignal = {
-    v: initial.length,
-    reactions: new Set,
-    equals: defaultEquals
-  };
-  const getIndexSignal = (index) => {
-    let sig = indexSignals.get(index);
-    if (!sig) {
-      sig = { v: initial[index], reactions: new Set, equals: defaultEquals };
-      indexSignals.set(index, sig);
+// src/collections/date.ts
+class ReactiveDate extends Date {
+  #time;
+  constructor(...args) {
+    super(...args);
+    this.#time = source(super.getTime());
+  }
+  #update() {
+    const time = super.getTime();
+    set(this.#time, time);
+    return time;
+  }
+  getTime() {
+    get(this.#time);
+    return super.getTime();
+  }
+  getFullYear() {
+    get(this.#time);
+    return super.getFullYear();
+  }
+  getMonth() {
+    get(this.#time);
+    return super.getMonth();
+  }
+  getDate() {
+    get(this.#time);
+    return super.getDate();
+  }
+  getDay() {
+    get(this.#time);
+    return super.getDay();
+  }
+  getHours() {
+    get(this.#time);
+    return super.getHours();
+  }
+  getMinutes() {
+    get(this.#time);
+    return super.getMinutes();
+  }
+  getSeconds() {
+    get(this.#time);
+    return super.getSeconds();
+  }
+  getMilliseconds() {
+    get(this.#time);
+    return super.getMilliseconds();
+  }
+  getUTCFullYear() {
+    get(this.#time);
+    return super.getUTCFullYear();
+  }
+  getUTCMonth() {
+    get(this.#time);
+    return super.getUTCMonth();
+  }
+  getUTCDate() {
+    get(this.#time);
+    return super.getUTCDate();
+  }
+  getUTCDay() {
+    get(this.#time);
+    return super.getUTCDay();
+  }
+  getUTCHours() {
+    get(this.#time);
+    return super.getUTCHours();
+  }
+  getUTCMinutes() {
+    get(this.#time);
+    return super.getUTCMinutes();
+  }
+  getUTCSeconds() {
+    get(this.#time);
+    return super.getUTCSeconds();
+  }
+  getUTCMilliseconds() {
+    get(this.#time);
+    return super.getUTCMilliseconds();
+  }
+  getTimezoneOffset() {
+    get(this.#time);
+    return super.getTimezoneOffset();
+  }
+  setTime(time) {
+    super.setTime(time);
+    return this.#update();
+  }
+  setFullYear(year, month, date) {
+    if (date !== undefined) {
+      super.setFullYear(year, month, date);
+    } else if (month !== undefined) {
+      super.setFullYear(year, month);
+    } else {
+      super.setFullYear(year);
     }
-    return sig;
-  };
-  const array = [...initial];
-  const proxy = new Proxy(array, {
-    get(target, prop, receiver) {
-      if (prop === "length") {
-        track(lengthSignal);
-        return target.length;
-      }
-      const index = typeof prop === "string" ? parseInt(prop, 10) : NaN;
-      if (!isNaN(index)) {
-        const sig = getIndexSignal(index);
-        track(sig);
-        return target[index];
-      }
-      const value = Reflect.get(target, prop, receiver);
-      if (typeof value === "function") {
-        return function(...args) {
-          const method = prop;
-          if (["indexOf", "includes", "find", "findIndex", "some", "every", "forEach", "map", "filter", "reduce", "reduceRight", "join", "toString"].includes(method)) {
-            track(internal);
-            return value.apply(target, args);
-          }
-          const prevLength = target.length;
-          const result = value.apply(target, args);
-          const newLength = target.length;
-          if (newLength !== prevLength) {
-            lengthSignal.v = newLength;
-            trigger(lengthSignal);
-          }
-          if (["push", "pop", "shift", "unshift", "splice", "sort", "reverse", "fill", "copyWithin"].includes(method)) {
-            internal.v++;
-            trigger(internal);
-            for (let i = 0;i < Math.max(prevLength, newLength); i++) {
-              const sig = indexSignals.get(i);
-              if (sig && !Object.is(sig.v, target[i])) {
-                sig.v = target[i];
-                trigger(sig);
-              }
-            }
-          }
-          return result;
-        };
-      }
-      return value;
-    },
-    set(target, prop, value, receiver) {
-      if (prop === "length") {
-        const oldLength = target.length;
-        target.length = value;
-        if (oldLength !== value) {
-          lengthSignal.v = value;
-          trigger(lengthSignal);
-          internal.v++;
-          trigger(internal);
-        }
-        return true;
-      }
-      const index = typeof prop === "string" ? parseInt(prop, 10) : NaN;
-      if (!isNaN(index)) {
-        const oldValue = target[index];
-        if (!Object.is(oldValue, value)) {
-          target[index] = value;
-          const sig = getIndexSignal(index);
-          sig.v = value;
-          trigger(sig);
-          if (index >= lengthSignal.v) {
-            lengthSignal.v = target.length;
-            trigger(lengthSignal);
-          }
-          internal.v++;
-          trigger(internal);
-        }
-        return true;
-      }
-      return Reflect.set(target, prop, value, receiver);
+    return this.#update();
+  }
+  setMonth(month, date) {
+    if (date !== undefined) {
+      super.setMonth(month, date);
+    } else {
+      super.setMonth(month);
     }
-  });
-  return proxy;
-}
-function effectScope() {
-  const disposers = [];
-  let active = true;
-  return {
-    run(fn) {
-      if (!active)
-        return;
-      const originalEffect = effect;
-      globalThis.__signalEffect = effect;
-      const wrappedEffect = (effectFn) => {
-        const dispose = originalEffect(effectFn);
-        disposers.push(dispose);
-        return dispose;
-      };
-      const prevEffect = globalThis.__effectOverride;
-      globalThis.__effectOverride = wrappedEffect;
-      try {
-        return fn();
-      } finally {
-        globalThis.__effectOverride = prevEffect;
-      }
-    },
-    stop() {
-      if (!active)
-        return;
-      active = false;
-      for (const dispose of disposers) {
-        dispose();
-      }
-      disposers.length = 0;
-    },
-    get active() {
-      return active;
+    return this.#update();
+  }
+  setDate(date) {
+    super.setDate(date);
+    return this.#update();
+  }
+  setHours(hours, min, sec, ms) {
+    if (ms !== undefined) {
+      super.setHours(hours, min, sec, ms);
+    } else if (sec !== undefined) {
+      super.setHours(hours, min, sec);
+    } else if (min !== undefined) {
+      super.setHours(hours, min);
+    } else {
+      super.setHours(hours);
     }
-  };
-}
-function watch(source, callback, options) {
-  let oldValue;
-  let cleanup;
-  let first = true;
-  return effect(() => {
-    const newValue = source();
-    if (first) {
-      first = false;
-      oldValue = newValue;
-      if (options?.immediate) {
-        cleanup = callback(newValue, undefined);
-      }
-      return;
+    return this.#update();
+  }
+  setMinutes(min, sec, ms) {
+    if (ms !== undefined) {
+      super.setMinutes(min, sec, ms);
+    } else if (sec !== undefined) {
+      super.setMinutes(min, sec);
+    } else {
+      super.setMinutes(min);
     }
-    if (!Object.is(newValue, oldValue)) {
-      if (typeof cleanup === "function") {
-        cleanup();
-      }
-      cleanup = callback(newValue, oldValue);
-      oldValue = newValue;
+    return this.#update();
+  }
+  setSeconds(sec, ms) {
+    if (ms !== undefined) {
+      super.setSeconds(sec, ms);
+    } else {
+      super.setSeconds(sec);
     }
-  });
-}
-function readonly(sig) {
-  return {
-    get value() {
-      return sig.value;
+    return this.#update();
+  }
+  setMilliseconds(ms) {
+    super.setMilliseconds(ms);
+    return this.#update();
+  }
+  setUTCFullYear(year, month, date) {
+    if (date !== undefined) {
+      super.setUTCFullYear(year, month, date);
+    } else if (month !== undefined) {
+      super.setUTCFullYear(year, month);
+    } else {
+      super.setUTCFullYear(year);
     }
-  };
-}
-function peek(fn) {
-  return untrack(fn);
+    return this.#update();
+  }
+  setUTCMonth(month, date) {
+    if (date !== undefined) {
+      super.setUTCMonth(month, date);
+    } else {
+      super.setUTCMonth(month);
+    }
+    return this.#update();
+  }
+  setUTCDate(date) {
+    super.setUTCDate(date);
+    return this.#update();
+  }
+  setUTCHours(hours, min, sec, ms) {
+    if (ms !== undefined) {
+      super.setUTCHours(hours, min, sec, ms);
+    } else if (sec !== undefined) {
+      super.setUTCHours(hours, min, sec);
+    } else if (min !== undefined) {
+      super.setUTCHours(hours, min);
+    } else {
+      super.setUTCHours(hours);
+    }
+    return this.#update();
+  }
+  setUTCMinutes(min, sec, ms) {
+    if (ms !== undefined) {
+      super.setUTCMinutes(min, sec, ms);
+    } else if (sec !== undefined) {
+      super.setUTCMinutes(min, sec);
+    } else {
+      super.setUTCMinutes(min);
+    }
+    return this.#update();
+  }
+  setUTCSeconds(sec, ms) {
+    if (ms !== undefined) {
+      super.setUTCSeconds(sec, ms);
+    } else {
+      super.setUTCSeconds(sec);
+    }
+    return this.#update();
+  }
+  setUTCMilliseconds(ms) {
+    super.setUTCMilliseconds(ms);
+    return this.#update();
+  }
+  toString() {
+    get(this.#time);
+    return super.toString();
+  }
+  toDateString() {
+    get(this.#time);
+    return super.toDateString();
+  }
+  toTimeString() {
+    get(this.#time);
+    return super.toTimeString();
+  }
+  toISOString() {
+    get(this.#time);
+    return super.toISOString();
+  }
+  toUTCString() {
+    get(this.#time);
+    return super.toUTCString();
+  }
+  toLocaleString(locales, options) {
+    get(this.#time);
+    return super.toLocaleString(locales, options);
+  }
+  toLocaleDateString(locales, options) {
+    get(this.#time);
+    return super.toLocaleDateString(locales, options);
+  }
+  toLocaleTimeString(locales, options) {
+    get(this.#time);
+    return super.toLocaleTimeString(locales, options);
+  }
+  toJSON() {
+    get(this.#time);
+    return super.toJSON();
+  }
+  valueOf() {
+    get(this.#time);
+    return super.valueOf();
+  }
 }
+
+// src/index.ts
+setProxyFn(proxy);
 export {
-  watch,
+  writeVersion,
+  updateReaction,
+  updateEffect,
+  untracking,
   untrack,
   toRaw,
+  tick,
+  stateRaw,
   state,
+  source,
   signal,
   shallowEquals,
-  readonly,
-  reactiveArray,
+  setUntracking,
+  setSignalStatus,
+  setActiveReaction,
+  setActiveEffect,
+  set,
+  safeNotEqual,
+  safeEquals,
+  removeReactions,
+  readVersion,
+  proxy,
   peek,
+  neverEquals,
+  mutableSource,
+  markReactions,
   isReactive,
-  effectScope,
+  isDirty,
+  incrementWriteVersion,
+  incrementReadVersion,
+  incrementBatchDepth,
+  getWriteVersion,
+  getReadVersion,
+  getBatchDepth,
+  get,
+  flushSync,
+  equals,
   effect,
+  disconnectDerived,
+  destroyEffect,
   derived,
-  defaultEquals,
+  decrementBatchDepth,
+  createEquals,
+  createEffect,
+  createDerived,
+  batchDepth,
   batch,
+  alwaysEquals,
+  activeReaction,
+  activeEffect,
+  USER_EFFECT,
+  UNOWNED,
+  UNINITIALIZED,
+  STATE_SYMBOL,
+  STALE_REACTION,
   ReactiveSet,
-  ReactiveMap
+  ReactiveMap,
+  ReactiveDate,
+  ROOT_EFFECT,
+  RENDER_EFFECT,
+  REACTIVE_MARKER,
+  REACTION_IS_UPDATING,
+  MAYBE_DIRTY,
+  INERT,
+  EFFECT_RAN,
+  EFFECT_PRESERVED,
+  EFFECT,
+  DISCONNECTED,
+  DIRTY,
+  DESTROYED,
+  DERIVED,
+  CLEAN,
+  BRANCH_EFFECT,
+  BLOCK_EFFECT
 };