@lytjs/reactivity 5.0.0 → 6.0.0

package/dist/index.mjs

@@ -1 +1,1543 @@
-var u=null,g=[],ae=0,K=new WeakMap,b=class{constructor(t,n={}){this.active=!0;this.deps=new Set;this.fn=t,this.scheduler=n.scheduler,this.beforeRun=n.beforeRun,this.afterRun=n.afterRun,this.lazy=n.lazy,this.id=ae++}run(){var t,n;if(!this.active)return this.fn();if(g.includes(this))return this.fn();try{return(t=this.beforeRun)==null||t.call(this),g.push(this),u=this,Y(this),this.fn()}finally{(n=this.afterRun)==null||n.call(this),g.pop(),u=g[g.length-1]||null}}stop(){this.active&&(Y(this),this.onStop&&this.onStop(),this.active=!1)}},P=!0,J=[];function A(){J.push(P),P=!1}function M(){let e=J.pop();P=e===void 0?!0:e}function Y(e){let{deps:t}=e;for(let n of t)n.delete(e);t.clear()}function c(e,t){if(!P||!u)return;let n=K.get(e);n||(n=new Map,K.set(e,n));let r=n.get(t);r||(r=new Set,n.set(t,r)),r.has(u)||(r.add(u),u.deps.add(r))}function l(e,t,n,r){let o=K.get(e);if(!o)return;let i=new Set,s=f=>{if(f)for(let p of f)(p!==u||p.allowRecurse)&&i.add(p)};if(s(o.get(t)),(n==="add"||n==="delete")&&s(o.get(m)),n==="set"&&Array.isArray(e)){let f=o.get("length");f&&typeof t=="number"&&t<e.length&&s(f)}for(let f of i)f.scheduler?f.scheduler(f):f.run()}var m=Symbol("iterate");function ue(e,t={}){let n=new b(e,t);t.lazy||n.run();let r=n.run.bind(n);return r.effect=n,r.stop=()=>n.stop(),r}function le(e){var t;(t=e==null?void 0:e.effect)==null||t.stop()}var y=Symbol("readonly"),R=Symbol("raw"),x=Symbol("reactive"),$=Symbol("skip"),U=new WeakMap,q=new WeakMap,L=new WeakMap;function C(e){return e!==null&&typeof e=="object"}function Q(e,t){return!Object.is(e,t)}function V(e,t){return Object.prototype.hasOwnProperty.call(e,t)}var F={};["includes","indexOf","lastIndexOf"].forEach(e=>{F[e]=function(...t){let n=h(this);for(let r=0;r<n.length;r++)c(n,String(r));return c(n,"length"),n[e](...t)}});["push","pop","shift","unshift","splice","sort","reverse"].forEach(e=>{F[e]=function(...t){A();let n=Array.prototype[e].apply(this,t);return M(),l(h(this),"length","set",h(this).length),n}});var pe={get(e,t,n){if(t===R)return e;if(t===x)return!0;if(Array.isArray(e)&&F.hasOwnProperty(t))return F[t];c(e,t);let r=Reflect.get(e,t,n);return t===y?e[y]===!0:!C(r)||e[$]?r:I(r)},set(e,t,n,r){let o=e[t],i=Array.isArray(e)&&B(t)?Number(t)<e.length:V(e,t),s=Reflect.set(e,t,n,r);return(e===(r==null?void 0:r[R])||e===h(r))&&(i?Q(n,o)&&l(e,t,"set",n):l(e,t,"add",n)),s},deleteProperty(e,t){let n=V(e,t),r=Reflect.deleteProperty(e,t);return r&&n&&l(e,t,"delete"),r},has(e,t){return c(e,t),Reflect.has(e,t)},ownKeys(e){return c(e,m),Reflect.ownKeys(e)}},de={get(e,t,n){if(t===R)return e;if(t===x||t===y)return!0;c(e,t);let r=Reflect.get(e,t,n);return C(r)?D(r):r},set(e,t,n,r){return!1},deleteProperty(e,t){return!1},has(e,t){return c(e,t),Reflect.has(e,t)},ownKeys(e){return c(e,m),Reflect.ownKeys(e)}},be={get(e,t,n){return t===R?e:t===x?!0:(c(e,t),Reflect.get(e,t,n))},set(e,t,n,r){let o=e[t],i=Array.isArray(e)&&B(t)?Number(t)<e.length:V(e,t),s=Reflect.set(e,t,n,r);return(e===(r==null?void 0:r[R])||e===h(r))&&(i?Q(n,o)&&l(e,t,"set",n):l(e,t,"add",n)),s},deleteProperty(e,t){let n=V(e,t),r=Reflect.deleteProperty(e,t);return r&&n&&l(e,t,"delete"),r},has(e,t){return c(e,t),Reflect.has(e,t)},ownKeys(e){return c(e,m),Reflect.ownKeys(e)}};function B(e){return typeof e=="string"&&e!=="NaN"&&e[0]!=="-"&&""+parseInt(e,10)===e}function I(e,t={}){if(!C(e)||e[x])return e;if(e[y])return D(e);let n=U.get(e);if(n)return n;let r=new Proxy(e,pe);return U.set(e,r),r}function D(e){if(!C(e))return e;let t=q.get(e);if(t)return t;e[y]=!0;let n=new Proxy(e,de);return q.set(e,n),n}function ye(e){if(!C(e))return e;let t=L.get(e);if(t)return t;let n=new Proxy(e,be);return L.set(e,n),n}function h(e){let t=e&&e[R];return t?h(t):e}function E(e){return X(e)?E(e[R]):!!(e&&e[x])}function X(e){return!!(e&&e[y])}function Re(e){return e[y]=!0,e}function Te(e){return e[$]=!0,e}import{isObject as he}from"@lytjs/common";var j=Symbol("ref"),Z=Symbol("shallowRef"),H=new WeakMap;function me(e){return H.get(e)||e}function xe(e){if(T(e))return e;let t={_value:ee(e),_rawValue:e,__v_isRef:!0,[j]:!0},n=new Proxy(t,Se);return H.set(n,t),n}function ee(e){return he(e)?I(e):e}var Se={get(e,t,n){return t==="value"?(c(e,"value"),e._value):t===j||t==="__v_isRef"?!0:t==="_rawValue"?e._rawValue:Reflect.get(e,t,n)},set(e,t,n,r){if(t==="value"){let o=e._rawValue;return Object.is(o,n)||(e._rawValue=n,e._value=ee(n),l(e,"value","set",n)),!0}return Reflect.set(e,t,n,r)}};function ve(e){if(T(e))return e;let t={_value:e,_rawValue:e,__v_isRef:!0,__v_isShallow:!0,[j]:!0,[Z]:!0},n=new Proxy(t,we);return H.set(n,t),n}var we={get(e,t,n){return t==="value"?(c(e,"value"),e._value):t===j||t==="__v_isRef"||t==="__v_isShallow"?!0:t==="_rawValue"?e._rawValue:Reflect.get(e,t,n)},set(e,t,n,r){if(t==="value"){let o=e._rawValue;return Object.is(o,n)||(e._rawValue=n,e._value=n,l(e,"value","set",n)),!0}return Reflect.set(e,t,n,r)}};function T(e){return!!(e&&e.__v_isRef===!0)}function _e(e){return T(e)?e.value:e}function te(e,t){let n=e[t];return T(n)?n:new Proxy({_obj:e,_key:t,__v_isRef:!0},{get(r,o,i){return o==="value"?r._obj[r._key]:o==="__v_isRef"?!0:Reflect.get(r,o,i)},set(r,o,i,s){return o==="value"?(r._obj[r._key]=i,!0):Reflect.set(r,o,i,s)}})}function ge(e){let t={};for(let n in e)Object.prototype.hasOwnProperty.call(e,n)&&(t[n]=te(e,n));return t}function Ce(e){let t=me(e);l(t,"value","set",t._rawValue)}var z=class{constructor(t,n){this._dirty=!0;this.__v_isRef=!0;this.deps=new Set;this._setter=n,this._effect=new b(t,{scheduler:()=>{this._dirty||(this._dirty=!0,this.triggerDep())},lazy:!0}),this._value=void 0}get value(){return c(this,"value"),u&&!this.deps.has(u)&&(this.deps.add(u),u.deps.add(this.deps)),this._dirty&&(this._value=this._effect.run(),this._dirty=!1),this._value}set value(t){this._setter&&this._setter(t)}triggerDep(){for(let t of this.deps)t.scheduler?t.scheduler(t):t.run()}};function Ee(e){let t,n;return typeof e=="function"?(t=e,n=void 0):(t=e.get,n=e.set),new z(t,n)}import{queueJob as re,nextTick as je,isObject as oe}from"@lytjs/common";function O(e,t=1/0,n){if(!oe(e)||t<=0||(n||(n=new Set),n.has(e)))return e;if(n.add(e),T(e))O(e.value,t-1,n);else if(Array.isArray(e))for(let r=0;r<e.length;r++)O(e[r],t-1,n);else for(let r of Object.keys(e))O(e[r],t-1,n);return e}function ne(e){return T(e)?()=>e.value:E(e)?()=>O(e):typeof e=="function"?e:()=>O(e)}function Oe(e,t,n={}){let r,o=!1;if(Array.isArray(e)){o=!0;let a=e.map(_=>ne(_));r=()=>a.map(_=>_())}else r=ne(e);E(e)&&n.deep!==!1&&(n.deep=!0);let i=o?[]:void 0,s,f=a=>{s=a},p=()=>{s&&(s(),s=void 0);let a=w.run();(o?a.some((_,ce)=>!Object.is(_,i[ce])):!Object.is(a,i)||n.deep&&oe(a))&&(t(a,o?[...i]:i,f),i=o?[...a]:a)},w=new b(r,{lazy:!0,scheduler:()=>{n.flush==="sync"?p():re(p)}});return n.immediate?p():i=w.run(),()=>{w.stop()}}function We(e,t={}){let n,r=()=>{n&&(n(),n=void 0),e(i=>{n=i})},o=new b(r,{scheduler:()=>{t.flush==="sync"?r():re(r)}});return o.run(),()=>{o.stop(),n&&(n(),n=void 0)}}import{queueJob as vt,queuePostFlushCb as wt,hasPendingJob as _t,clearQueue as gt}from"@lytjs/common";import{LytError as ke}from"@lytjs/common";var d=null,W=!1,k=0,S=new Set,G=!1;function N(e){let t=e,n=new Set,r=function(){return d&&!W&&n.add(d),t};return r.set=function(o){Object.is(t,o)||(t=o,se(n))},r.update=function(o){r.set(o(t))},r._subscribe=function(o){n.add(o)},r._unsubscribe=function(o){n.delete(o)},r.dispose=function(){n.clear()},r}function Pe(e){let t,n=!0,r=!1,o=new Set,i=new Set,s=function(){if(d&&!W&&i.add(d),n){if(r)throw new ke("LYT_REACTIVITY_CIRCULAR_DEPENDENCY","computed \u5728\u5176\u81EA\u8EAB\u7684\u8BA1\u7B97\u56FE\u4E2D");r=!0;for(let a of o)a._unsubscribe(s);o.clear();let w=d;d=s;try{t=e()}finally{d=w,r=!1}n=!1}return t},f={_dirty:!1,notify(){n=!0,se(i)}};return s.notify=f.notify.bind(f),s._dirty=!1,s._subscribe=function(p){i.add(p)},s._unsubscribe=function(p){i.delete(p)},s}function Ve(e){let t=null,n=!1,r=new Set,o=()=>{if(n)return;t&&(t(),t=null);for(let f of r)f._unsubscribe(i);r.clear();let s=d;d=i;try{e(f=>{t=f})}finally{d=s}},i={_dirty:!1,notify(){k>0?S.add(i):o()}};return o(),()=>{n=!0,t&&(t(),t=null);for(let s of r)s._unsubscribe(i);r.clear(),S.delete(i)}}function Fe(e){k++;try{e()}finally{k--,k===0&&ie()}}function ie(){if(!G){G=!0;try{let e=new Set(S);S.clear();for(let t of e)t.notify();S.size>0&&ie()}finally{G=!1}}}function Ie(e){let t=W;W=!0;try{return e()}finally{W=t}}function se(e){if(k>0)for(let t of e)S.add(t);else for(let t of e)t.notify()}var v=[];function fe(){return v.length>0?v[v.length-1]:null}function Ke(e){return e()}function Ae(e){let t=N(e),n=o=>t.set(o),r=fe();return[t,n]}function Me(){let e={_cleanupFns:[]};return v.push(e),()=>{for(let n of e._cleanupFns)n();e._cleanupFns.length=0;let t=v.indexOf(e);t!==-1&&v.splice(t,1)}}function De(e){let t=fe();t&&t._cleanupFns.push(e)}export{m as ITERATE_KEY,b as ReactiveEffect,u as activeEffect,Fe as batch,gt as clearQueue,Ee as computed,Pe as computedSignal,ue as effect,Me as enterSignalComponentContext,_t as hasPendingJob,E as isReactive,X as isReadonly,T as isRef,Re as markReadOnly,Te as markSkip,je as nextTick,De as onSignalCleanup,A as pauseTracking,vt as queueJob,wt as queuePostFlushCb,R as rawSymbol,I as reactive,x as reactiveFlag,D as readonly,y as readonlyFlag,xe as ref,j as refSymbol,M as resetTracking,ye as shallowReactive,ve as shallowRef,Z as shallowRefSymbol,N as signal,Ve as signalEffect,le as stop,h as toRaw,te as toRef,ge as toRefs,c as track,l as trigger,Ce as triggerRef,_e as unref,Ie as untrack,Ke as useSignal,Ae as useSignalState,Oe as watch,We as watchEffect};
+import { isSymbol, isFunction, isArray, isObject, hasChanged, NOOP, isMap, isSet, hasOwn } from '@lytjs/common-is';
+import { error } from '@lytjs/common-error';
+import { unsafeCast } from '@lytjs/common-assertions';
+import { REACTIVITY_MAX_TRIGGER_DEPTH } from '@lytjs/common-constants';
+import { queuePostFlushCb, queuePreFlushCb } from '@lytjs/common-scheduler';
+
+// src/reactive.ts
+var RefSymbol = /* @__PURE__ */ Symbol(void 0);
+var ShallowRefSymbol = /* @__PURE__ */ Symbol(void 0);
+var ComputedRefSymbol = /* @__PURE__ */ Symbol(void 0);
+var ReactiveSymbol = /* @__PURE__ */ Symbol(void 0);
+var ReadonlySymbol = /* @__PURE__ */ Symbol(void 0);
+var SignalSymbol = /* @__PURE__ */ Symbol(void 0);
+var ComputedSignalSymbol = /* @__PURE__ */ Symbol(void 0);
+var ReactiveFlags = {
+  IS_REACTIVE: "__v_isReactive",
+  IS_READONLY: "__v_isReadonly",
+  IS_SHALLOW: "__v_isShallow",
+  IS_REF: "__v_isRef",
+  RAW: "__v_raw",
+  SKIP: "__v_skip"
+};
+var TrackOpTypes = {
+  GET: "get",
+  HAS: "has",
+  ITERATE: "iterate"
+};
+var TriggerOpTypes = {
+  SET: "set",
+  ADD: "add",
+  DELETE: "delete",
+  CLEAR: "clear"
+};
+var ITERATE_KEY = /* @__PURE__ */ Symbol("iterate");
+var activeSubscriber = null;
+var isUntracked = false;
+var trackDependency = null;
+var batchDepth = 0;
+var MAX_BATCH_DEPTH = 100;
+var pendingNotifications = /* @__PURE__ */ new Set();
+var pendingTriggerOps = /* @__PURE__ */ new Map();
+var isNotifying = false;
+function signal(initialValue) {
+  let value = initialValue;
+  const subscribers = /* @__PURE__ */ new Set();
+  let disposed = false;
+  const store = {};
+  const SIGNAL_KEY = /* @__PURE__ */ Symbol("signal_value");
+  store[SIGNAL_KEY] = initialValue;
+  const signalFn = function signalFn2() {
+    const currentSubscriber = activeSubscriber;
+    if (currentSubscriber && !isUntracked && !disposed) {
+      if (!subscribers.has(currentSubscriber)) {
+        subscribers.add(currentSubscriber);
+        if (trackDependency) {
+          trackDependency(signalFn2, () => {
+            subscribers.delete(currentSubscriber);
+          });
+        }
+      }
+    }
+    if (!disposed) {
+      track(store, TrackOpTypes.GET, SIGNAL_KEY);
+    }
+    return value;
+  };
+  Object.defineProperty(signalFn, SignalSymbol, { value: true });
+  signalFn.set = (newValue) => {
+    if (disposed) return;
+    if (Object.is(newValue, value)) return;
+    value = newValue;
+    store[SIGNAL_KEY] = newValue;
+    notifySubscribers(subscribers, store, SIGNAL_KEY, newValue);
+  };
+  signalFn.update = (updater) => {
+    if (disposed) return;
+    const newValue = updater(value);
+    if (Object.is(newValue, value)) return;
+    value = newValue;
+    store[SIGNAL_KEY] = newValue;
+    notifySubscribers(subscribers, store, SIGNAL_KEY, newValue);
+  };
+  signalFn.dispose = () => {
+    disposed = true;
+    subscribers.clear();
+  };
+  signalFn.cleanup = () => {
+    subscribers.clear();
+    trigger(store, TriggerOpTypes.SET, SIGNAL_KEY);
+  };
+  signalFn._subscribe = (subscriber) => {
+    if (disposed) return () => {
+    };
+    subscribers.add(subscriber);
+    return () => subscribers.delete(subscriber);
+  };
+  return signalFn;
+}
+function createComputedSignalInternal(getter, typeName) {
+  let value;
+  let dirty = true;
+  let isComputing = false;
+  const dependencies = /* @__PURE__ */ new Map();
+  const subscribers = /* @__PURE__ */ new Set();
+  let disposed = false;
+  const store = {};
+  const COMPUTED_SIGNAL_KEY = /* @__PURE__ */ Symbol("computed_signal_value");
+  const invalidate = () => {
+    if (disposed) return;
+    dirty = true;
+    trigger(store, TriggerOpTypes.SET, COMPUTED_SIGNAL_KEY);
+    const subs = Array.from(subscribers);
+    for (const sub of subs) {
+      sub();
+    }
+  };
+  const computedFn = function computedFn2() {
+    if (disposed) return value;
+    track(store, TrackOpTypes.GET, COMPUTED_SIGNAL_KEY);
+    if (activeSubscriber && !isUntracked) {
+      subscribers.add(activeSubscriber);
+    }
+    if (dirty) {
+      if (isComputing) {
+        throw new Error(`[lytjs/signal] Circular dependency detected in ${typeName}.`);
+      }
+      isComputing = true;
+      try {
+        for (const unsubscribe of dependencies.values()) {
+          unsubscribe();
+        }
+        dependencies.clear();
+        const prevSubscriber = activeSubscriber;
+        const prevTrackDependency = trackDependency;
+        activeSubscriber = invalidate;
+        trackDependency = (dep, unsubscribe) => {
+          dependencies.set(dep, unsubscribe);
+        };
+        try {
+          value = getter();
+          dirty = false;
+        } finally {
+          activeSubscriber = prevSubscriber;
+          trackDependency = prevTrackDependency;
+        }
+      } finally {
+        isComputing = false;
+      }
+    }
+    return value;
+  };
+  Object.defineProperty(computedFn, ComputedSignalSymbol, { value: true });
+  const dispose = () => {
+    disposed = true;
+    for (const unsubscribe of dependencies.values()) {
+      unsubscribe();
+    }
+    dependencies.clear();
+    subscribers.clear();
+  };
+  return { computedFn, invalidate, dispose };
+}
+function computed(fn) {
+  const { computedFn, dispose } = createComputedSignalInternal(fn, "computed signal");
+  computedFn.dispose = dispose;
+  computedFn.stop = dispose;
+  return computedFn;
+}
+function writableComputedSignal(getter, setter) {
+  const { computedFn, dispose } = createComputedSignalInternal(getter, "writable computed signal");
+  computedFn.set = (newValue) => {
+    setter(newValue);
+  };
+  computedFn.dispose = dispose;
+  computedFn.stop = dispose;
+  return computedFn;
+}
+function signalBatch(fn) {
+  if (batchDepth >= MAX_BATCH_DEPTH) {
+    fn();
+    return;
+  }
+  batchDepth++;
+  try {
+    fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0) {
+      flushPendingNotifications();
+    }
+  }
+}
+function signalUntrack(fn) {
+  const prevIsUntracked = isUntracked;
+  isUntracked = true;
+  try {
+    return fn();
+  } finally {
+    isUntracked = prevIsUntracked;
+  }
+}
+function _isSignalUntracked() {
+  return isUntracked;
+}
+function notifySubscribers(subscribers, store, signalKey, newValue) {
+  if (batchDepth > 0 || isNotifying) {
+    const it2 = subscribers.values();
+    let next2 = it2.next();
+    while (!next2.done) {
+      pendingNotifications.add(next2.value);
+      next2 = it2.next();
+    }
+    if (store && signalKey !== void 0) {
+      pendingTriggerOps.set(signalKey, { store, signalKey, newValue });
+    }
+    return;
+  }
+  const it = subscribers.values();
+  let next = it.next();
+  while (!next.done) {
+    next.value();
+    next = it.next();
+  }
+  if (store && signalKey !== void 0) {
+    trigger(store, TriggerOpTypes.SET, signalKey);
+  }
+}
+function flushPendingNotifications() {
+  if (isNotifying) return;
+  isNotifying = true;
+  try {
+    let iterations = 0;
+    while ((pendingNotifications.size > 0 || pendingTriggerOps.size > 0) && iterations < REACTIVITY_MAX_TRIGGER_DEPTH) {
+      const notifications = new Set(pendingNotifications);
+      const triggers = new Set(pendingTriggerOps.values());
+      pendingNotifications.clear();
+      pendingTriggerOps.clear();
+      const notifIt = notifications.values();
+      let notifNext = notifIt.next();
+      while (!notifNext.done) {
+        notifNext.value();
+        notifNext = notifIt.next();
+      }
+      const triggerIt = triggers.values();
+      let triggerNext = triggerIt.next();
+      while (!triggerNext.done) {
+        const { store, signalKey, newValue } = triggerNext.value;
+        trigger(store, TriggerOpTypes.SET, signalKey, newValue);
+        triggerNext = triggerIt.next();
+      }
+      iterations++;
+    }
+  } finally {
+    isNotifying = false;
+  }
+}
+function computedSignal(fn) {
+  return computed(fn);
+}
+function valueOf(sig) {
+  return sig();
+}
+function set(sig, newValue) {
+  if (isWritableSignal(sig)) {
+    sig.set(newValue);
+  }
+}
+function isWritableSignal(sig) {
+  return typeof sig === "function" && "set" in sig;
+}
+function update(sig, updater) {
+  sig.update(updater);
+}
+function readonlySignal(sig) {
+  const readonlyFn = function readonlyFn2() {
+    return sig();
+  };
+  Object.defineProperty(readonlyFn, SignalSymbol, { value: true });
+  return readonlyFn;
+}
+var activeEffect;
+var _trackDepth = 0;
+var targetMap = /* @__PURE__ */ new WeakMap();
+var shouldTrack = true;
+var trackStack = [];
+var isFirstRenderPass = false;
+var skippedTrackingCount = 0;
+function withFirstRenderOptimization(fn) {
+  const wasFirstRender = isFirstRenderPass;
+  isFirstRenderPass = true;
+  try {
+    return fn();
+  } finally {
+    if (!wasFirstRender) {
+      isFirstRenderPass = false;
+    }
+  }
+}
+function shouldSkipTracking() {
+  return isFirstRenderPass;
+}
+function getSkippedTrackingCount() {
+  return skippedTrackingCount;
+}
+function resetSkippedTrackingCount() {
+  skippedTrackingCount = 0;
+}
+function getActiveEffect() {
+  return activeEffect;
+}
+function getShouldTrack() {
+  return shouldTrack;
+}
+var createDep = () => {
+  return /* @__PURE__ */ new Set();
+};
+var triggerDepth = 0;
+function track(target, _type, key) {
+  if (!shouldTrack || activeEffect === void 0) return;
+  if (_isSignalUntracked()) return;
+  let depsMap = targetMap.get(target);
+  if (!depsMap) {
+    targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
+  }
+  let dep = depsMap.get(key);
+  if (!dep) {
+    depsMap.set(key, dep = createDep());
+  }
+  trackEffect(dep);
+}
+function trackEffect(dep) {
+  if (shouldSkipTracking()) {
+    skippedTrackingCount++;
+    return;
+  }
+  if (activeEffect && !dep.has(activeEffect)) {
+    dep.add(activeEffect);
+    activeEffect.deps.push(dep);
+  }
+}
+function trigger(target, type, key, _newValue, _oldValue) {
+  const depsMap = targetMap.get(target);
+  if (!depsMap) return;
+  const deps = [];
+  if (type === "clear") {
+    deps.push(...depsMap.values());
+  } else {
+    if (key !== void 0) {
+      deps.push(depsMap.get(key));
+    }
+    if (type === "add") {
+      if (Array.isArray(target)) {
+        deps.push(depsMap.get("length"));
+      } else {
+        deps.push(depsMap.get(ITERATE_KEY));
+      }
+    } else if (type === "delete") {
+      if (!Array.isArray(target)) {
+        deps.push(depsMap.get(ITERATE_KEY));
+      }
+    } else if (type === "set") {
+      if (Array.isArray(target) && isIntegerKey(key)) {
+        deps.push(depsMap.get("length"));
+      }
+    }
+  }
+  const effects = [];
+  for (const dep of deps) {
+    if (dep) {
+      for (const effect2 of dep) {
+        effects.push(effect2);
+      }
+    }
+  }
+  triggerEffects([...new Set(effects)]);
+}
+function triggerEffects(effects) {
+  if (triggerDepth > REACTIVITY_MAX_TRIGGER_DEPTH) {
+    return;
+  }
+  triggerDepth++;
+  try {
+    for (const effect2 of effects) {
+      if (effect2.computed) {
+        triggerEffect(effect2);
+      }
+    }
+    for (const effect2 of effects) {
+      if (!effect2.computed) {
+        triggerEffect(effect2);
+      }
+    }
+  } finally {
+    triggerDepth--;
+  }
+}
+function triggerEffect(effect2) {
+  if (effect2 !== activeEffect || effect2.allowRecurse) {
+    if (effect2.scheduler) {
+      effect2.scheduler();
+    } else {
+      effect2.run();
+    }
+  }
+}
+var ReactiveEffect = class {
+  constructor(fn, scheduler) {
+    this.fn = fn;
+    this.scheduler = scheduler;
+    this.active = true;
+    this.deps = [];
+    this.parent = void 0;
+    // 运行前清理（onEffectCleanup 注册的）
+    this._cleanups = [];
+  }
+  run() {
+    if (!this.active) {
+      return void 0;
+    }
+    if (this._cleanups.length > 0) {
+      for (let i = 0; i < this._cleanups.length; i++) {
+        this._cleanups[i]();
+      }
+      this._cleanups.length = 0;
+    }
+    const prevShouldTrack = shouldTrack;
+    try {
+      this.parent = activeEffect;
+      activeEffect = this;
+      shouldTrack = true;
+      _trackDepth++;
+      return this.fn();
+    } catch (error3) {
+      if (this.onError) {
+        this.onError(error3);
+        return void 0;
+      }
+      throw error3;
+    } finally {
+      _trackDepth--;
+      activeEffect = this.parent;
+      shouldTrack = prevShouldTrack;
+      this.parent = void 0;
+    }
+  }
+  stop() {
+    if (this.active) {
+      cleanupEffect(this);
+      if (this._cleanups.length > 0) {
+        for (let i = 0; i < this._cleanups.length; i++) {
+          this._cleanups[i]();
+        }
+        this._cleanups.length = 0;
+      }
+      if (this.onStop) {
+        this.onStop();
+      }
+      this.active = false;
+      this.scheduler = void 0;
+    }
+  }
+};
+function cleanupEffect(effect2) {
+  const { deps } = effect2;
+  for (let i = 0; i < deps.length; i++) {
+    deps[i].delete(effect2);
+  }
+  deps.length = 0;
+}
+function effect(fn, options) {
+  const _effect = new ReactiveEffect(fn);
+  if (options) {
+    _effect.scheduler = options.scheduler;
+    _effect.allowRecurse = options.allowRecurse;
+    _effect.onStop = options.onStop;
+    _effect.onTrack = options.onTrack;
+    _effect.onTrigger = options.onTrigger;
+    _effect.onError = options.onError;
+  }
+  if (!options || !options.lazy) {
+    _effect.run();
+  }
+  const runner = _effect.run.bind(_effect);
+  runner.effect = _effect;
+  return runner;
+}
+function stop(runner) {
+  runner.effect.stop();
+}
+function pauseTracking() {
+  trackStack.push(shouldTrack);
+  shouldTrack = false;
+}
+function enableTracking() {
+  trackStack.push(shouldTrack);
+  shouldTrack = true;
+}
+function resetTracking() {
+  const last = trackStack.pop();
+  shouldTrack = last === void 0 ? true : last;
+}
+function batch(fn) {
+  const stackLength = trackStack.length;
+  pauseTracking();
+  try {
+    fn();
+  } finally {
+    while (trackStack.length > stackLength) {
+      trackStack.pop();
+    }
+    shouldTrack = trackStack.length > 0 ? trackStack[trackStack.length - 1] : true;
+  }
+}
+function batchAsync(fn) {
+  const stackLength = trackStack.length;
+  pauseTracking();
+  const restoreTracking = () => {
+    while (trackStack.length > stackLength) {
+      trackStack.pop();
+    }
+    shouldTrack = trackStack.length > 0 ? trackStack[trackStack.length - 1] : true;
+  };
+  try {
+    const result = fn();
+    if (result && typeof result === "object" && "then" in result) {
+      return result.finally(restoreTracking);
+    }
+    restoreTracking();
+    return Promise.resolve();
+  } catch (e) {
+    restoreTracking();
+    return Promise.reject(e);
+  }
+}
+function untrack(fn) {
+  const stackLength = trackStack.length;
+  pauseTracking();
+  try {
+    return fn();
+  } finally {
+    while (trackStack.length > stackLength) {
+      trackStack.pop();
+    }
+    shouldTrack = trackStack.length > 0 ? trackStack[trackStack.length - 1] : true;
+  }
+}
+function onEffectCleanup(fn, failSilently = false) {
+  if (activeEffect === void 0) {
+    return;
+  }
+  activeEffect._cleanups.push(fn);
+}
+function isIntegerKey(key) {
+  return typeof key === "string" && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key && Number.isSafeInteger(Number(key));
+}
+var MAX_RAW_DEPTH = 100;
+var _rawSeenSet = /* @__PURE__ */ new Set();
+var _rawDepth = 0;
+function toRaw(observed) {
+  _rawDepth++;
+  if (_rawDepth === 1) {
+    _rawSeenSet.clear();
+  }
+  try {
+    let current = observed;
+    let depth = 0;
+    while (current && current[ReactiveFlags.RAW]) {
+      if (_rawSeenSet.has(current) || depth >= MAX_RAW_DEPTH) return current;
+      _rawSeenSet.add(current);
+      current = current[ReactiveFlags.RAW];
+      depth++;
+    }
+    return current;
+  } finally {
+    _rawDepth--;
+    if (_rawDepth === 0) {
+      _rawSeenSet.clear();
+    }
+  }
+}
+function isRef(r) {
+  return !!(r && typeof r === "object" && r.__v_isRef === true);
+}
+
+// src/reactive.ts
+var MUTATING_METHODS = /* @__PURE__ */ new Set(["set", "add", "delete", "clear"]);
+var collectionMethodCache = /* @__PURE__ */ new WeakMap();
+var arrayInstrumentations = {};
+["includes", "indexOf", "lastIndexOf"].forEach((method) => {
+  const originMethod = Array.prototype[method];
+  arrayInstrumentations[method] = function(...args) {
+    const arr = toRaw(this);
+    track(arr, TrackOpTypes.HAS, "length");
+    const result = originMethod.apply(arr, args);
+    if (result === -1 || result === false) {
+      return originMethod.apply(
+        arr,
+        args.map((a) => toRaw(a))
+      );
+    }
+    return result;
+  };
+});
+["push", "pop", "shift", "unshift", "splice"].forEach((method) => {
+  const originMethod = Array.prototype[method];
+  arrayInstrumentations[method] = function(...args) {
+    pauseTracking();
+    try {
+      const result = originMethod.apply(this, args);
+      return result;
+    } finally {
+      resetTracking();
+    }
+  };
+});
+["sort", "reverse", "fill", "copyWithin"].forEach((method) => {
+  const originMethod = Array.prototype[method];
+  arrayInstrumentations[method] = function(...args) {
+    const arr = toRaw(this);
+    pauseTracking();
+    try {
+      const result = originMethod.apply(arr, args);
+      trigger(arr, TriggerOpTypes.SET, "length");
+      return result;
+    } finally {
+      resetTracking();
+    }
+  };
+});
+var builtInSymbols = new Set(
+  Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => {
+    const value = unsafeCast(Symbol[key]);
+    return isSymbol(value) ? value : void 0;
+  }).filter((sym) => sym !== void 0)
+);
+function isNonTrackableKey(key) {
+  return key === "__proto__" || key === "__v_isRef";
+}
+function toTriggerKey(value) {
+  if (typeof value === "string" || typeof value === "symbol") {
+    return value;
+  }
+  return void 0;
+}
+function createReactiveObject(target, isReadonlyFlag, _isShallow, baseHandlers, collectionHandlers, proxyMap) {
+  if (!isObject(target)) {
+    return target;
+  }
+  if (target[ReactiveFlags.SKIP]) {
+    return target;
+  }
+  if (target[ReactiveFlags.RAW] && !(isReadonlyFlag && target[ReactiveFlags.IS_REACTIVE])) {
+    return target;
+  }
+  const existingProxy = proxyMap.get(target);
+  if (existingProxy) {
+    return existingProxy;
+  }
+  const handlers = isMap(target) || isSet(target) ? collectionHandlers : baseHandlers;
+  const proxy = new Proxy(target, handlers);
+  proxyMap.set(target, proxy);
+  return proxy;
+}
+function createMutableHandler(isReadonly2, isShallow) {
+  return {
+    get(target, key, _receiver) {
+      if (key === ReactiveFlags.IS_REACTIVE) return !isReadonly2;
+      if (key === ReactiveFlags.IS_READONLY) return isReadonly2;
+      if (key === ReactiveFlags.IS_SHALLOW) return isShallow;
+      if (key === ReactiveFlags.RAW) return target;
+      const targetIsArray = Array.isArray(target);
+      if (!isReadonly2 && targetIsArray && hasOwn(arrayInstrumentations, key)) {
+        return Reflect.get(arrayInstrumentations, key, _receiver);
+      }
+      const res = Reflect.get(target, key, _receiver);
+      if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKey(key)) {
+        return res;
+      }
+      if (!isReadonly2) {
+        track(target, TrackOpTypes.GET, key);
+      }
+      if (isShallow) {
+        return res;
+      }
+      if (isRef(res)) {
+        return targetIsArray && isIntegerKey(key) ? res : res.value;
+      }
+      if (isObject(res)) {
+        return isReadonly2 ? readonly(res) : reactive(res);
+      }
+      return res;
+    },
+    set(target, key, value, receiver) {
+      if (isReadonly2) {
+        return true;
+      }
+      let oldValue = Reflect.get(target, key);
+      if (!isShallow) {
+        value = toRaw(value);
+        oldValue = toRaw(oldValue);
+        if (!Array.isArray(target) && isRef(oldValue) && !isRef(value)) {
+          oldValue.value = value;
+          return true;
+        }
+      }
+      const hadKey = Array.isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
+      const result = Reflect.set(target, key, value, receiver);
+      if (target === toRaw(receiver)) {
+        if (!hadKey) {
+          trigger(target, TriggerOpTypes.ADD, key);
+        } else if (hasChanged(value, oldValue)) {
+          trigger(target, TriggerOpTypes.SET, key);
+        }
+      }
+      return result;
+    },
+    deleteProperty(target, key) {
+      if (isReadonly2) {
+        return true;
+      }
+      const hadKey = hasOwn(target, key);
+      Reflect.get(target, key);
+      const result = Reflect.deleteProperty(target, key);
+      if (result && hadKey) {
+        trigger(target, TriggerOpTypes.DELETE, key);
+      }
+      return result;
+    },
+    has(target, key) {
+      const result = Reflect.has(target, key);
+      if (!isSymbol(key) || !builtInSymbols.has(key)) {
+        if (!isReadonly2) {
+          track(target, TrackOpTypes.HAS, key);
+        }
+      }
+      return result;
+    },
+    // FIX: P2-08 ownKeys 属性枚举顺序一致：
+    // 返回 Reflect.ownKeys 结果，确保与原生 Object.keys() 枚举顺序一致
+    ownKeys(target) {
+      if (!isReadonly2) {
+        track(target, TrackOpTypes.ITERATE, Array.isArray(target) ? "length" : ITERATE_KEY);
+      }
+      return Reflect.ownKeys(target);
+    }
+  };
+}
+function createCollectionHandler(isReadonly2, isShallow) {
+  return {
+    get(target, key, _receiver) {
+      if (key === ReactiveFlags.IS_REACTIVE) return !isReadonly2;
+      if (key === ReactiveFlags.IS_READONLY) return isReadonly2;
+      if (key === ReactiveFlags.IS_SHALLOW) return isShallow;
+      if (key === ReactiveFlags.RAW) return target;
+      if (key === "size" || key === "has" || key === "forEach" || key === "entries" || key === "keys" || key === "values" || key === Symbol.iterator) {
+        track(target, TrackOpTypes.GET, ITERATE_KEY);
+      }
+      const res = Reflect.get(target, key, target);
+      if (typeof res === "function") {
+        if (!isReadonly2 && (key === "entries" || key === "keys" || key === "values" || key === Symbol.iterator)) {
+          let methodCache = collectionMethodCache.get(target);
+          if (!methodCache) {
+            methodCache = /* @__PURE__ */ new Map();
+            collectionMethodCache.set(target, methodCache);
+          }
+          let cachedFn = methodCache.get(key);
+          if (!cachedFn) {
+            cachedFn = (...args) => {
+              track(target, TrackOpTypes.GET, ITERATE_KEY);
+              return res.apply(target, args);
+            };
+            methodCache.set(key, cachedFn);
+          }
+          return cachedFn;
+        }
+        if (!isReadonly2) {
+          if (MUTATING_METHODS.has(key)) {
+            return (...args) => {
+              const rawTarget = toRaw(target);
+              if (key === "set") {
+                const oldValue = rawTarget.get(args[0]);
+                const hadKey = rawTarget.has(args[0]);
+                const result2 = res.apply(target, args);
+                if (!hadKey || !Object.is(toRaw(oldValue), toRaw(args[1]))) {
+                  const triggerKey = toTriggerKey(args[0]);
+                  if (triggerKey !== void 0) {
+                    trigger(target, TriggerOpTypes.SET, triggerKey, args[1]);
+                  }
+                }
+                return result2;
+              } else if (key === "add") {
+                const had = rawTarget.has(args[0]);
+                const result2 = res.apply(target, args);
+                if (!had) {
+                  const triggerKey = toTriggerKey(args[0]);
+                  if (triggerKey !== void 0) {
+                    trigger(target, TriggerOpTypes.ADD, triggerKey, args[0]);
+                  }
+                  trigger(target, TriggerOpTypes.ADD, ITERATE_KEY);
+                }
+                return result2;
+              } else if (key === "delete") {
+                const hadKey = rawTarget.has(args[0]);
+                const result2 = res.apply(target, args);
+                if (hadKey) {
+                  const triggerKey = toTriggerKey(args[0]);
+                  if (triggerKey !== void 0) {
+                    trigger(target, TriggerOpTypes.DELETE, triggerKey);
+                  }
+                  trigger(target, TriggerOpTypes.DELETE, ITERATE_KEY);
+                }
+                return result2;
+              } else if (key === "clear") {
+                const hadItems = rawTarget.size > 0;
+                const result2 = res.apply(target, args);
+                if (hadItems) {
+                  trigger(target, TriggerOpTypes.CLEAR, void 0);
+                }
+                return result2;
+              }
+              const result = res.apply(target, args);
+              trigger(target, TriggerOpTypes.ADD, ITERATE_KEY);
+              return result;
+            };
+          }
+          if (key === "get") {
+            return (...args) => {
+              track(target, TrackOpTypes.GET, args[0]);
+              return res.apply(target, args);
+            };
+          }
+        } else {
+          if (MUTATING_METHODS.has(key)) {
+            return (..._args) => {
+              if (key === "delete") return false;
+              return void 0;
+            };
+          }
+        }
+        return res.bind(target);
+      }
+      return res;
+    }
+  };
+}
+var mutableHandlers = createMutableHandler(false, false);
+var readonlyHandlers = createMutableHandler(true, false);
+var shallowReactiveHandlers = createMutableHandler(false, true);
+var shallowReadonlyHandlers = createMutableHandler(true, true);
+var mutableCollectionHandlers = createCollectionHandler(false, false);
+var readonlyCollectionHandlers = createCollectionHandler(true, false);
+var shallowCollectionHandlers = createCollectionHandler(false, true);
+var shallowReadonlyCollectionHandlers = createCollectionHandler(true, true);
+var reactiveMap = /* @__PURE__ */ new WeakMap();
+var shallowReactiveMap = /* @__PURE__ */ new WeakMap();
+var readonlyMap = /* @__PURE__ */ new WeakMap();
+var shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
+function reactive(target) {
+  if (isReadonly(target)) return target;
+  return createReactiveObject(
+    target,
+    false,
+    false,
+    mutableHandlers,
+    mutableCollectionHandlers,
+    reactiveMap
+  );
+}
+function shallowReactive(target) {
+  return createReactiveObject(
+    target,
+    false,
+    true,
+    shallowReactiveHandlers,
+    shallowCollectionHandlers,
+    shallowReactiveMap
+  );
+}
+function readonly(target) {
+  return createReactiveObject(
+    target,
+    true,
+    false,
+    readonlyHandlers,
+    readonlyCollectionHandlers,
+    readonlyMap
+  );
+}
+function shallowReadonly(target) {
+  return createReactiveObject(
+    target,
+    true,
+    true,
+    shallowReadonlyHandlers,
+    shallowReadonlyCollectionHandlers,
+    shallowReadonlyMap
+  );
+}
+function isReactive(value) {
+  if (isReadonly(value)) {
+    return isReactive(value[ReactiveFlags.RAW]);
+  }
+  return !!(value && value[ReactiveFlags.IS_REACTIVE]);
+}
+function isReadonly(value) {
+  return !!(value && value[ReactiveFlags.IS_READONLY]);
+}
+function isProxy(value) {
+  return isReactive(value) || isReadonly(value);
+}
+function markRaw(value) {
+  if (Object.isFrozen(value) || Object.isSealed(value)) {
+    return value;
+  }
+  Object.defineProperty(value, ReactiveFlags.SKIP, { value: true });
+  return value;
+}
+var RefImpl = class {
+  constructor(value, isShallow) {
+    // 使用 Dep 类型替代 Set<any>，提供更精确的类型约束
+    this.dep = createDep();
+    this.__v_isRef = true;
+    this.__v_isShallow = isShallow || void 0;
+    this._rawValue = isShallow ? value : toRaw(value);
+    this._value = isShallow ? value : toReactive(value);
+  }
+  get value() {
+    trackRefValue(this);
+    return this._value;
+  }
+  set value(newVal) {
+    const useDirectValue = this.__v_isShallow;
+    newVal = useDirectValue ? newVal : toRaw(newVal);
+    if (hasChanged(newVal, this._rawValue)) {
+      this._rawValue;
+      this._rawValue = newVal;
+      this._value = useDirectValue ? newVal : toReactive(newVal);
+      triggerRefValue(this);
+    }
+  }
+};
+var ShallowRefImpl = class {
+  constructor(value) {
+    // 使用 Dep 类型替代 Set<any>，提供更精确的类型约束
+    this.dep = createDep();
+    this.__v_isRef = true;
+    this.__v_isShallow = true;
+    this._rawValue = value;
+    this._value = value;
+  }
+  get value() {
+    trackRefValue(this);
+    return this._value;
+  }
+  set value(newVal) {
+    if (hasChanged(newVal, this._rawValue)) {
+      this._rawValue;
+      this._rawValue = newVal;
+      this._value = newVal;
+      triggerRefValue(this);
+    }
+  }
+};
+function trackRefValue(ref2) {
+  if (getShouldTrack() && getActiveEffect()) {
+    track(ref2, TrackOpTypes.GET, "value");
+  }
+}
+function triggerRefValue(ref2, newVal, oldVal) {
+  trigger(ref2, TriggerOpTypes.SET, "value");
+}
+function ref(value) {
+  if (isRef(value)) {
+    return value;
+  }
+  return unsafeCast(new RefImpl(value, false));
+}
+function shallowRef(value) {
+  if (isRef(value)) return unsafeCast(value);
+  return unsafeCast(new ShallowRefImpl(value));
+}
+function triggerRef(ref2) {
+  triggerRefValue(unsafeCast(ref2), ref2.value);
+}
+function isShallowRef(r) {
+  return isRef(r) && !!r.__v_isShallow;
+}
+function isComputedRef(r) {
+  return isRef(r) && !!r.__v_isComputed;
+}
+function unref(r) {
+  return isRef(r) ? r.value : r;
+}
+function toRef(object, key) {
+  if (isRef(object[key])) return unsafeCast(object[key]);
+  return unsafeCast(new ObjectRefImpl(object, key));
+}
+function toRefs(object) {
+  const result = {};
+  for (const key in object) {
+    result[key] = toRef(object, key);
+  }
+  return result;
+}
+function customRef(factory) {
+  return unsafeCast(new CustomRefImpl(factory));
+}
+function toValue(source) {
+  if (isRef(source)) return source.value;
+  if (typeof source === "function") {
+    return source();
+  }
+  return source;
+}
+var ObjectRefImpl = class {
+  constructor(_object, _key) {
+    this._object = _object;
+    this._key = _key;
+    this.__v_isRef = true;
+  }
+  get value() {
+    return this._object[this._key];
+  }
+  set value(newVal) {
+    this._object[this._key] = newVal;
+  }
+};
+var CustomRefImpl = class {
+  constructor(factory) {
+    this.__v_isRef = true;
+    this.dep = createDep();
+    const { get, set: set2 } = factory(
+      () => trackRefValue(this),
+      () => triggerRefValue(this)
+    );
+    this._getter = get;
+    this._setter = set2;
+  }
+  get value() {
+    return this._getter();
+  }
+  set value(newVal) {
+    this._setter(newVal);
+  }
+};
+function toReactive(value) {
+  return isObject(value) ? reactive(value) : value;
+}
+var MAX_COMPUTED_DEPTH = 100;
+var computedDepth = 0;
+var computedStack = /* @__PURE__ */ new Set();
+var _a;
+_a = ComputedRefSymbol;
+var _ComputedRefImpl = class _ComputedRefImpl {
+  // 60秒后清理缓存
+  constructor(getter, _setter, isSSR) {
+    this._setter = _setter;
+    // 使用 Dep 类型替代 Set<any>，提供更精确的类型约束
+    this.dep = createDep();
+    this._dirty = true;
+    this._initialized = false;
+    this[_a] = true;
+    this.__v_isRef = true;
+    this.__v_isComputed = true;
+    // FIX: P2-6 计算属性缓存清理相关属性
+    this._cacheCleanupTimer = null;
+    this.effect = new ReactiveEffect(getter, () => {
+      if (!this._dirty) {
+        this._dirty = true;
+        triggerRefValue(this);
+      }
+      this._resetCacheCleanupTimer();
+    });
+    this.effect.computed = true;
+    const effect2 = this.effect;
+    effect2.onStop = () => {
+      this._cleanupCache();
+    };
+    if (isSSR) {
+      try {
+        this._value = getter();
+        this._dirty = false;
+      } catch (e) {
+        this._dirty = true;
+      }
+    }
+  }
+  // FIX: P2-6 重置缓存清理定时器
+  _resetCacheCleanupTimer() {
+    if (this._cacheCleanupTimer) {
+      clearTimeout(this._cacheCleanupTimer);
+    }
+    this._cacheCleanupTimer = setTimeout(() => {
+      if (!this.effect.active) {
+        this._cleanupCache();
+      }
+    }, _ComputedRefImpl.CACHE_CLEANUP_DELAY);
+  }
+  // FIX: P2-6 清理缓存值
+  _cleanupCache() {
+    if (!this.effect.active) {
+      if (this._cacheCleanupTimer) {
+        clearTimeout(this._cacheCleanupTimer);
+        this._cacheCleanupTimer = null;
+      }
+      this._value = unsafeCast(void 0);
+      this._initialized = false;
+      this._dirty = true;
+    }
+  }
+  // FIX: P2-6 手动清理缓存的公共方法
+  /**
+   * 手动清理计算属性的缓存值。
+   * 在组件卸载时调用此方法可以释放内存。
+   */
+  cleanupCache() {
+    if (this._cacheCleanupTimer) {
+      clearTimeout(this._cacheCleanupTimer);
+      this._cacheCleanupTimer = null;
+    }
+    this._cleanupCache();
+  }
+  get value() {
+    trackRefValue(this);
+    if (this._dirty) {
+      if (this.effect.active) {
+        if (computedStack.has(this)) {
+          throw new Error(
+            `[LytJS/reactivity] Circular dependency detected in computed property. A computed property is indirectly referencing itself, causing an infinite loop.
+  Error Code: CIRCULAR_REFERENCE (4008) 
+  Suggestion: Check your computed property dependencies and avoid referencing the computed itself or other computeds that depend on it.`
+          );
+        }
+        computedDepth++;
+        if (computedDepth > MAX_COMPUTED_DEPTH) {
+          computedDepth--;
+          throw new Error(
+            `[LytJS/reactivity] Maximum computed depth exceeded (${MAX_COMPUTED_DEPTH}). Possible infinite loop in computed properties.
+  Error Code: CIRCULAR_REFERENCE (4008) 
+  Suggestion: Check for circular dependencies in your computed properties.`
+          );
+        }
+        computedStack.add(this);
+        try {
+          const value = this.effect.run();
+          if (value !== void 0) {
+            this._value = value;
+            this._initialized = true;
+          }
+          this._dirty = false;
+        } catch (e) {
+          if (this._initialized) {
+            this._dirty = false;
+          }
+          throw e;
+        } finally {
+          computedStack.delete(this);
+          computedDepth--;
+        }
+      }
+    }
+    return this._value;
+  }
+  set value(newValue) {
+    if (this._setter) {
+      this._setter(newValue);
+    }
+  }
+};
+_ComputedRefImpl.CACHE_CLEANUP_DELAY = 6e4;
+var ComputedRefImpl = _ComputedRefImpl;
+var _isSSR = false;
+function setSSRMode(isSSR) {
+  _isSSR = isSSR;
+}
+function computed2(getterOrOptions) {
+  let getter;
+  let setter;
+  if (isFunction(getterOrOptions)) {
+    getter = getterOrOptions;
+    setter = void 0;
+  } else {
+    getter = getterOrOptions.get;
+    setter = getterOrOptions.set;
+  }
+  return new ComputedRefImpl(getter, setter, _isSSR);
+}
+function getSource(source) {
+  if (isRef(source)) return () => source.value;
+  if (isObject(source) && isReactive(source)) return () => traverse(source);
+  if (typeof source === "function") return source;
+  return NOOP;
+}
+var MAX_TRAVERSE_DEPTH = 100;
+function traverse(value, seen, depth = 0) {
+  const _seen = /* @__PURE__ */ new Set();
+  if (!isObject(value) || _seen.has(value)) return value;
+  const stack = [{ value, depth }];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    const { value: val, depth: d } = current;
+    if (!isObject(val) || _seen.has(val)) continue;
+    if (d > MAX_TRAVERSE_DEPTH) {
+      continue;
+    }
+    _seen.add(val);
+    if (isArray(val)) {
+      for (let i = val.length - 1; i >= 0; i--) {
+        stack.push({ value: val[i], depth: d + 1 });
+      }
+    } else if (val instanceof Map) {
+      val.forEach((v, key) => {
+        stack.push({ value: v, depth: d + 1 });
+        if (isObject(key)) {
+          stack.push({ value: key, depth: d + 1 });
+        }
+      });
+    } else if (val instanceof Set) {
+      val.forEach((v) => {
+        stack.push({ value: v, depth: d + 1 });
+      });
+    } else {
+      const keys = Object.keys(val);
+      for (let i = keys.length - 1; i >= 0; i--) {
+        stack.push({
+          value: val[keys[i]],
+          depth: d + 1
+        });
+      }
+    }
+  }
+  return value;
+}
+function watch(source, cb, options) {
+  const {
+    immediate,
+    deep,
+    flush = "pre",
+    once,
+    onTrack,
+    onTrigger,
+    scheduler: userScheduler
+  } = options || {};
+  let getter;
+  let forceTrigger = false;
+  let isMultiSource = false;
+  if (isArray(source)) {
+    isMultiSource = true;
+    forceTrigger = source.some((s) => isObject(s) && isReactive(s));
+    getter = () => source.map((s) => {
+      if (isRef(s)) return s.value;
+      if (isObject(s) && isReactive(s)) return traverse(s);
+      if (isFunction(s)) return s();
+      return void 0;
+    });
+  } else {
+    getter = getSource(source);
+    if (isObject(source) && isReactive(source)) {
+      forceTrigger = true;
+    }
+  }
+  if (deep) {
+    const baseGetter = getter;
+    getter = () => traverse(baseGetter());
+  }
+  let oldValue = isMultiSource ? new Array(source.length).fill(void 0) : void 0;
+  const cleanupFns = [];
+  let isStopped = false;
+  let consecutiveErrors = 0;
+  const MAX_CONSECUTIVE_ERRORS = 3;
+  const onCleanup = (fn) => {
+    cleanupFns.push(fn);
+  };
+  const job = () => {
+    if (!watcher.active || isStopped) return;
+    if (cb) {
+      let newValue;
+      try {
+        newValue = watcher.run();
+        consecutiveErrors = 0;
+      } catch (e) {
+        consecutiveErrors++;
+        if (consecutiveErrors <= MAX_CONSECUTIVE_ERRORS) {
+          error(`Error in watch getter: ${e}`);
+        }
+        throw e;
+      }
+      if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue))) {
+        if (cleanupFns.length > 0) {
+          cleanupFns.forEach((f) => f());
+          cleanupFns.length = 0;
+        }
+        try {
+          cb(
+            newValue,
+            oldValue,
+            onCleanup
+          );
+          consecutiveErrors = 0;
+        } catch (e) {
+          consecutiveErrors++;
+          if (consecutiveErrors <= MAX_CONSECUTIVE_ERRORS) {
+            error(`Error in watch callback: ${e}`);
+          }
+        }
+        oldValue = newValue;
+        if (once) {
+          isStopped = true;
+          watcher.stop();
+        }
+      }
+    } else {
+      try {
+        watcher.run();
+        consecutiveErrors = 0;
+      } catch (e) {
+        consecutiveErrors++;
+        if (consecutiveErrors <= MAX_CONSECUTIVE_ERRORS) {
+          error(`Error in watch effect run: ${e}`);
+        }
+        throw e;
+      }
+    }
+  };
+  const rawScheduler = userScheduler || (flush === "sync" ? job : () => {
+    if (flush === "post") {
+      queuePostFlushCb(job);
+    } else {
+      queuePreFlushCb(job);
+    }
+  });
+  const scheduler = userScheduler ? (...args) => rawScheduler(job, ...args) : rawScheduler;
+  const watcher = new ReactiveEffect(getter, scheduler);
+  watcher.onStop = () => {
+    if (cleanupFns.length > 0) {
+      for (let i = cleanupFns.length - 1; i >= 0; i--) {
+        cleanupFns[i]();
+      }
+      cleanupFns.length = 0;
+    }
+  };
+  if (immediate) {
+    job();
+  } else {
+    oldValue = watcher.run();
+  }
+  return () => {
+    if (isStopped) return;
+    isStopped = true;
+    watcher.stop();
+    getter = () => {
+    };
+    cleanupFns.length = 0;
+    cb = NOOP;
+    oldValue = void 0;
+    consecutiveErrors = 0;
+  };
+}
+function watchEffect(effectFn, options) {
+  return doWatchEffect(effectFn, options);
+}
+function watchPostEffect(effectFn, options) {
+  return doWatchEffect(effectFn, { ...options, flush: "post" });
+}
+function watchSyncEffect(effectFn, options) {
+  return doWatchEffect(effectFn, { ...options, flush: "sync" });
+}
+function doWatchEffect(source, options = {}) {
+  const { flush = "pre", onTrack, onTrigger } = options;
+  const cleanupFns = [];
+  let isStopped = false;
+  const onCleanup = (fn) => {
+    cleanupFns.push(fn);
+  };
+  const getter = () => {
+    if (cleanupFns.length > 0) {
+      cleanupFns.forEach((f) => f());
+      cleanupFns.length = 0;
+    }
+    source(onCleanup);
+  };
+  let effectRef;
+  const schedulerFn = flush === "sync" ? () => effectRef?.run() : () => {
+    if (flush === "post") {
+      queuePostFlushCb(() => effectRef?.run());
+    } else {
+      queuePreFlushCb(() => effectRef?.run());
+    }
+  };
+  const currentEffect = new ReactiveEffect(getter, schedulerFn);
+  effectRef = currentEffect;
+  currentEffect.onStop = () => {
+    if (cleanupFns.length > 0) {
+      for (let i = cleanupFns.length - 1; i >= 0; i--) {
+        cleanupFns[i]();
+      }
+      cleanupFns.length = 0;
+    }
+  };
+  currentEffect.run();
+  return () => {
+    if (isStopped) return;
+    isStopped = true;
+    currentEffect.stop();
+    cleanupFns.length = 0;
+    source = NOOP;
+    effectRef = void 0;
+  };
+}
+
+// src/batch.ts
+var scopeStack = [];
+var globalBatchDepth = 0;
+var MAX_NESTING_DEPTH = 100;
+function batchScope(callback, options = {}) {
+  const { async = false, name = "batchScope", onError } = options;
+  if (globalBatchDepth >= MAX_NESTING_DEPTH) {
+    const error3 = new Error(
+      `[lytjs/reactivity] Maximum batchScope nesting depth (${MAX_NESTING_DEPTH}) exceeded. This may indicate an infinite loop.`
+    );
+    if (onError) {
+      onError(error3);
+      throw error3;
+    }
+    throw error3;
+  }
+  const ctx = {
+    depth: globalBatchDepth,
+    name,
+    committed: false,
+    cancelled: false
+  };
+  scopeStack.push(ctx);
+  globalBatchDepth++;
+  try {
+    if (async) {
+      let result;
+      const promise = batchAsync(() => {
+        result = callback(ctx);
+      });
+      promise.then(() => {
+        ctx.committed = true;
+        scopeStack.pop();
+        globalBatchDepth--;
+      }).catch((error3) => {
+        scopeStack.pop();
+        globalBatchDepth--;
+        if (onError) {
+          onError(error3);
+        } else {
+          throw error3;
+        }
+      });
+      return result;
+    } else {
+      let result;
+      batch(() => {
+        result = callback(ctx);
+      });
+      ctx.committed = true;
+      if (result === void 0) {
+        throw new Error(
+          "[lytjs/reactivity] batchScope sync mode: callback returned undefined."
+        );
+      }
+      return result;
+    }
+  } catch (error3) {
+    if (onError) {
+      onError(error3);
+      throw error3;
+    }
+    throw error3;
+  } finally {
+    if (!async) {
+      scopeStack.pop();
+      globalBatchDepth--;
+    }
+  }
+}
+async function batchScopeAsync(callback, options = {}) {
+  const { name = "batchScopeAsync", onError } = options;
+  if (globalBatchDepth >= MAX_NESTING_DEPTH) {
+    const error3 = new Error(
+      `[lytjs/reactivity] Maximum batchScope nesting depth (${MAX_NESTING_DEPTH}) exceeded.`
+    );
+    if (onError) {
+      onError(error3);
+      return Promise.reject(error3);
+    }
+    return Promise.reject(error3);
+  }
+  const ctx = {
+    depth: globalBatchDepth,
+    name,
+    committed: false,
+    cancelled: false
+  };
+  scopeStack.push(ctx);
+  globalBatchDepth++;
+  try {
+    let result;
+    await batchAsync(async () => {
+      result = await callback(ctx);
+    });
+    ctx.committed = true;
+    return result;
+  } catch (error3) {
+    if (onError) {
+      onError(error3);
+      throw error3;
+    }
+    throw error3;
+  } finally {
+    scopeStack.pop();
+    globalBatchDepth--;
+  }
+}
+function batchScopeUntrack(fn) {
+  return untrack(fn);
+}
+function getBatchScopeDepth() {
+  return globalBatchDepth;
+}
+function getCurrentBatchScopeStack() {
+  return [...scopeStack];
+}
+function isInBatchScope() {
+  return globalBatchDepth > 0;
+}
+function flushBatchScopes() {
+  return Promise.resolve();
+}
+function _notifyDevToolsSignalChange(signalId, value) {
+  return;
+}
+function _notifyDevToolsEffectRun(effectId) {
+  return;
+}
+
+export { ComputedRefSymbol, ReactiveSymbol, ReadonlySymbol, RefSymbol, ShallowRefSymbol, _notifyDevToolsEffectRun, _notifyDevToolsSignalChange, batch, batchAsync, batchScope, batchScopeAsync, batchScopeUntrack, computed2 as computed, computedSignal, customRef, effect, enableTracking, flushBatchScopes, getBatchScopeDepth, getCurrentBatchScopeStack, getSkippedTrackingCount, isComputedRef, isInBatchScope, isProxy, isReactive, isReadonly, isRef, isShallowRef, markRaw, onEffectCleanup, pauseTracking, reactive, readonly, readonlySignal, ref, resetSkippedTrackingCount, resetTracking, set, setSSRMode, shallowReactive, shallowReadonly, shallowRef, shouldSkipTracking, signal, signalBatch, computed as signalComputed, signalUntrack, stop, toRaw, toRef, toRefs, toValue, triggerRef, unref, untrack, update, valueOf, watch, watchEffect, watchPostEffect, watchSyncEffect, withFirstRenderOptimization, writableComputedSignal };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map