@yiin/reactive-proxy-state 1.0.43 → 2.0.0

package/dist/index.js

@@ -3,29 +3,15 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toESMCache_node;
-var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
-  var canCache = mod != null && typeof mod === "object";
-  if (canCache) {
-    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
-    var cached = cache.get(mod);
-    if (cached)
-      return cached;
-  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
+        get: () => mod[key],
         enumerable: true
       });
-  if (canCache)
-    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
@@ -54,7 +40,7 @@ var require_shared_cjs = __commonJS((exports) => {
     }
   };
   var hasOwnProperty = Object.prototype.hasOwnProperty;
-  var hasOwn = (val, key) => hasOwnProperty.call(val, key);
+  var hasOwn2 = (val, key) => hasOwnProperty.call(val, key);
   var isArray = Array.isArray;
   var isMap = (val) => toTypeString(val) === "[object Map]";
   var isSet = (val) => toTypeString(val) === "[object Set]";
@@ -63,9 +49,9 @@ var require_shared_cjs = __commonJS((exports) => {
   var isFunction = (val) => typeof val === "function";
   var isString = (val) => typeof val === "string";
   var isSymbol = (val) => typeof val === "symbol";
-  var isObject4 = (val) => val !== null && typeof val === "object";
+  var isObject7 = (val) => val !== null && typeof val === "object";
   var isPromise = (val) => {
-    return (isObject4(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch);
+    return (isObject7(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch);
   };
   var objectToString = Object.prototype.toString;
   var toTypeString = (value) => objectToString.call(value);
@@ -267,7 +253,7 @@ var require_shared_cjs = __commonJS((exports) => {
         }
       }
       return res;
-    } else if (isString(value) || isObject4(value)) {
+    } else if (isString(value) || isObject7(value)) {
       return value;
     }
   }
@@ -310,7 +296,7 @@ var require_shared_cjs = __commonJS((exports) => {
           res += normalized + " ";
         }
       }
-    } else if (isObject4(value)) {
+    } else if (isObject7(value)) {
       for (const name in value) {
         if (value[name]) {
           res += name + " ";
@@ -447,8 +433,8 @@ var require_shared_cjs = __commonJS((exports) => {
     if (aValidType || bValidType) {
       return aValidType && bValidType ? looseCompareArrays(a, b) : false;
     }
-    aValidType = isObject4(a);
-    bValidType = isObject4(b);
+    aValidType = isObject7(a);
+    bValidType = isObject7(b);
     if (aValidType || bValidType) {
       if (!aValidType || !bValidType) {
         return false;
@@ -475,7 +461,7 @@ var require_shared_cjs = __commonJS((exports) => {
     return !!(val && val["__v_isRef"] === true);
   };
   var toDisplayString = (val) => {
-    return isString(val) ? val : val == null ? "" : isArray(val) || isObject4(val) && (val.toString === objectToString || !isFunction(val.toString)) ? isRef3(val) ? toDisplayString(val.value) : JSON.stringify(val, replacer, 2) : String(val);
+    return isString(val) ? val : val == null ? "" : isArray(val) || isObject7(val) && (val.toString === objectToString || !isFunction(val.toString)) ? isRef3(val) ? toDisplayString(val.value) : JSON.stringify(val, replacer, 2) : String(val);
   };
   var replacer = (_key, val) => {
     if (isRef3(val)) {
@@ -493,7 +479,7 @@ var require_shared_cjs = __commonJS((exports) => {
       };
     } else if (isSymbol(val)) {
       return stringifySymbol(val);
-    } else if (isObject4(val) && !isArray(val) && !isPlainObject(val)) {
+    } else if (isObject7(val) && !isArray(val) && !isPlainObject(val)) {
       return String(val);
     }
     return val;
@@ -523,7 +509,7 @@ var require_shared_cjs = __commonJS((exports) => {
   exports.getEscapedCssVarName = getEscapedCssVarName;
   exports.getGlobalThis = getGlobalThis;
   exports.hasChanged = hasChanged;
-  exports.hasOwn = hasOwn;
+  exports.hasOwn = hasOwn2;
   exports.hyphenate = hyphenate;
   exports.includeBooleanAttr = includeBooleanAttr;
   exports.invokeArrayFns = invokeArrayFns;
@@ -542,7 +528,7 @@ var require_shared_cjs = __commonJS((exports) => {
   exports.isMap = isMap;
   exports.isMathMLTag = isMathMLTag;
   exports.isModelListener = isModelListener;
-  exports.isObject = isObject4;
+  exports.isObject = isObject7;
   exports.isOn = isOn;
   exports.isPlainObject = isPlainObject;
   exports.isPromise = isPromise;
@@ -2327,40 +2313,50 @@ function unwrapForStore(value) {
   if (Array.isArray(value)) {
     for (let i = 0;i < value.length; i++) {
       const child = value[i];
-      if (child != null && typeof child === "object" && child["__v_isReactive" /* IS_REACTIVE */]) {
-        value[i] = toRaw(child);
-      }
+      if (child != null && typeof child === "object" && child["__v_isReactive" /* IS_REACTIVE */])
+        storeRawChild(value, i, child);
     }
   } else if (!(value instanceof Map) && !(value instanceof Set) && !(value instanceof Date)) {
     for (const key in value) {
       if (!Object.prototype.hasOwnProperty.call(value, key))
         continue;
       const child = value[key];
-      if (child != null && typeof child === "object" && child["__v_isReactive" /* IS_REACTIVE */]) {
-        value[key] = toRaw(child);
-      }
+      if (child != null && typeof child === "object" && child["__v_isReactive" /* IS_REACTIVE */])
+        storeRawChild(value, key, child);
     }
   }
   return value;
 }
-var deepEqualCache = new WeakMap;
+var lookupSetter = Object.prototype.__lookupSetter__;
+function storeRawChild(value, key, child) {
+  if (lookupSetter === undefined) {
+    if (Reflect.getOwnPropertyDescriptor(value, key)?.value === child)
+      Reflect.set(value, key, toRaw(child));
+    return;
+  }
+  if (lookupSetter.call(value, key) !== undefined)
+    return;
+  try {
+    value[key] = toRaw(child);
+  } catch {}
+}
 var MAX_CACHE_SIZE = 1000;
 var pathCache = new WeakMap;
 var pathCacheSize = new WeakMap;
-var pathConcatCache = new Map;
-var MAX_PATH_CACHE_SIZE = 1000;
 var globalSeen = new WeakMap;
 var wrapperCache = new WeakMap;
+var locationNodes = new WeakMap;
 var proxyStats = {
   created: 0,
   arrays: 0,
   maps: 0,
   sets: 0,
   objects: 0,
-  staleEvicted: 0
+  staleEvicted: 0,
+  detachedWrites: 0
 };
 function getProxyStats() {
-  return { ...proxyStats, pathConcatCacheSize: pathConcatCache.size };
+  return { ...proxyStats, pathConcatCacheSize: 0 };
 }
 function resetProxyStats() {
   proxyStats.created = 0;
@@ -2369,41 +2365,7 @@ function resetProxyStats() {
   proxyStats.sets = 0;
   proxyStats.objects = 0;
   proxyStats.staleEvicted = 0;
-}
-function evictDeep(value) {
-  if (value == null || typeof value !== "object")
-    return;
-  value = toRaw(value);
-  if (!globalSeen.has(value))
-    return;
-  globalSeen.delete(value);
-  wrapperCache.delete(value);
-  proxyStats.staleEvicted++;
-  if (Array.isArray(value)) {
-    for (let i = 0;i < value.length; i++) {
-      if (value[i] != null && typeof value[i] === "object") {
-        evictDeep(value[i]);
-      }
-    }
-  } else if (value instanceof Map) {
-    for (const v of value.values()) {
-      if (v != null && typeof v === "object")
-        evictDeep(v);
-    }
-  } else if (value instanceof Set) {
-    for (const v of value) {
-      if (v != null && typeof v === "object")
-        evictDeep(v);
-    }
-  } else {
-    const keys = Object.keys(value);
-    for (let i = 0;i < keys.length; i++) {
-      const child = value[keys[i]];
-      if (child != null && typeof child === "object") {
-        evictDeep(child);
-      }
-    }
-  }
+  proxyStats.detachedWrites = 0;
 }
 function cleanupPathCache(root) {
   const cache = pathCache.get(root);
@@ -2419,23 +2381,11 @@ function cleanupPathCache(root) {
     pathCacheSize.set(root, MAX_CACHE_SIZE - entriesToRemove);
   }
 }
-function cleanupPathConcatCache() {
-  if (pathConcatCache.size > MAX_PATH_CACHE_SIZE) {
-    const entriesToRemove = Math.floor(MAX_PATH_CACHE_SIZE * 0.2);
-    let count = 0;
-    for (const key of pathConcatCache.keys()) {
-      if (count >= entriesToRemove)
-        break;
-      pathConcatCache.delete(key);
-      count++;
-    }
-  }
-}
-function deepEqual(a, b, seen = globalSeen) {
+function deepEqual(a, b, seen) {
   if (a === b)
     return true;
   if (a == null || b == null)
-    return a === b;
+    return false;
   if (typeof a !== typeof b)
     return false;
   if (a instanceof Date && b instanceof Date)
@@ -2444,45 +2394,75 @@ function deepEqual(a, b, seen = globalSeen) {
     return false;
   if (Array.isArray(a) !== Array.isArray(b))
     return false;
-  if (seen.has(a))
-    return seen.get(a) === b;
-  seen.set(a, b);
-  if (deepEqualCache.has(a) && deepEqualCache.get(a)?.has(b)) {
-    return deepEqualCache.get(a).get(b);
+  if (seen !== undefined) {
+    if (seen.has(a))
+      return seen.get(a) === b;
+    seen.set(a, b);
   }
-  if (!deepEqualCache.has(a)) {
-    deepEqualCache.set(a, new WeakMap);
-  }
-  let result;
   if (Array.isArray(a)) {
-    result = a.length === b.length && a.every((val, idx) => deepEqual(val, b[idx], seen));
-  } else if (a instanceof Map && b instanceof Map) {
-    result = a.size === b.size;
-    if (result) {
-      for (const [key, value] of a) {
-        if (!b.has(key) || !deepEqual(value, b.get(key), seen)) {
-          result = false;
-          break;
-        }
-      }
+    if (a.length !== b.length)
+      return false;
+    for (let i = 0;i < a.length; i++) {
+      const left = a[i];
+      if (left === undefined && !(i in a))
+        continue;
+      const right = b[i];
+      if (left === right)
+        continue;
+      if (isObject(left) && isObject(right))
+        seen ??= startSeen(a, b);
+      if (!deepEqual(left, right, seen))
+        return false;
     }
-  } else if (a instanceof Set && b instanceof Set) {
-    result = a.size === b.size;
-    if (result) {
-      for (const value of a) {
-        if (!b.has(value)) {
-          result = false;
-          break;
-        }
-      }
+    return true;
+  }
+  if (a instanceof Map && b instanceof Map) {
+    if (a.size !== b.size)
+      return false;
+    for (const [key, left] of a) {
+      if (!b.has(key))
+        return false;
+      const right = b.get(key);
+      if (left === right)
+        continue;
+      if (isObject(left) && isObject(right))
+        seen ??= startSeen(a, b);
+      if (!deepEqual(left, right, seen))
+        return false;
     }
-  } else {
-    const keysA = Object.keys(a);
-    const keysB = Object.keys(b);
-    result = keysA.length === keysB.length && keysA.every((key) => Object.prototype.hasOwnProperty.call(b, key) && deepEqual(a[key], b[key], seen));
+    return true;
   }
-  deepEqualCache.get(a).set(b, result);
-  return result;
+  if (a instanceof Set && b instanceof Set) {
+    if (a.size !== b.size)
+      return false;
+    for (const value of a) {
+      if (!b.has(value))
+        return false;
+    }
+    return true;
+  }
+  const keysA = Object.keys(a);
+  if (keysA.length !== Object.keys(b).length)
+    return false;
+  for (let i = 0;i < keysA.length; i++) {
+    const key = keysA[i];
+    if (!hasOwn.call(b, key))
+      return false;
+    const left = a[key];
+    const right = b[key];
+    if (left === right)
+      continue;
+    if (isObject(left) && isObject(right))
+      seen ??= startSeen(a, b);
+    if (!deepEqual(left, right, seen))
+      return false;
+  }
+  return true;
+}
+function startSeen(a, b) {
+  const seen = new WeakMap;
+  seen.set(a, b);
+  return seen;
 }
 function setInPathCache(root, pathKey, value) {
   if (!pathCache.has(root)) {
@@ -2518,21 +2498,6 @@ function evictDescendantsFromPathCache(root, pathKey) {
     pathCacheSize.set(root, (pathCacheSize.get(root) ?? cache.size) - evicted);
   }
 }
-function getPathConcat(path) {
-  const result = pathConcatCache.get(path);
-  if (result !== undefined) {
-    pathConcatCache.delete(path);
-    pathConcatCache.set(path, result);
-  }
-  return result;
-}
-function setPathConcat(path, value) {
-  if (pathConcatCache.has(path)) {
-    pathConcatCache.delete(path);
-  }
-  pathConcatCache.set(path, value);
-  cleanupPathConcatCache();
-}
 function isObject(val) {
   return val !== null && typeof val === "object";
 }
@@ -2566,298 +2531,2095 @@ function traverse(value, seen = new Set) {
   }
   return value;
 }
-function deepClone(value, seen = new WeakMap) {
+var SNAPSHOT_SHARED_COPY_LIMIT = 1e5;
+
+class SnapshotLimitError extends RangeError {
+  constructor(extraCopies) {
+    super(`reactive-proxy-state: a snapshot would copy shared objects more than ` + `${SNAPSHOT_SHARED_COPY_LIMIT} extra times (counted ${extraCopies} before stopping; ` + `an object is copied once per place it holds). Nothing was changed. To remove such a ` + `graph, see "Shared graphs have a copy limit" under "Synchronization Limits" in the README`);
+    this.name = "SnapshotLimitError";
+  }
+}
+
+class UnsupportedStateError extends TypeError {
+  constructor(problem) {
+    super(`reactive-proxy-state: ${problem}. Nothing was changed. See "Supported inputs" under ` + `"Synchronization Limits" in the README`);
+    this.name = "UnsupportedStateError";
+  }
+}
+var SNAPSHOT_CHECK_AFTER = SNAPSHOT_SHARED_COPY_LIMIT + 1;
+function cloneTree(value, named) {
+  return copyTree(value, undefined, undefined, false, named);
+}
+var REACHES = Symbol("reaches");
+function cloneTreeUnless(value, container, named) {
+  return copyUnless(value, container, false, named);
+}
+function cloneStored(value, container, named) {
+  return copyUnless(value, container, true, named);
+}
+var copiedFresh = false;
+function copyUnless(value, container, checkFresh, named) {
+  try {
+    return copyTree(value, container, undefined, checkFresh, named);
+  } catch (error) {
+    if (error === reachedContainer) {
+      copiedFresh = false;
+      return REACHES;
+    }
+    throw error;
+  }
+}
+function cloneTreeAfter(value, container, contents, named) {
+  return copyTree(value, container, contents, false, named);
+}
+var reachedContainer = new Error("reactive-proxy-state: internal, a copy reached its container");
+function copyTree(value, container, contents, checkFresh, named) {
   if (value === null || typeof value !== "object") {
+    if (checkFresh)
+      copiedFresh = true;
     return value;
   }
-  if (value instanceof Date) {
-    return new Date(value.getTime());
+  const top = toRaw(value);
+  if (top === value && top !== container) {
+    const small = copySmall(value, container, checkFresh, named);
+    if (small !== undefined)
+      return small;
+  }
+  const base = cloneAncestors.length;
+  const workBase = cloneWork.length;
+  const outerTop = cloneTop;
+  const outerCountdown = cloneCountdown;
+  const outerContainer = cloneContainer;
+  const outerContents = cloneContents;
+  const outerFresh = cloneFresh;
+  const outerFirst = cloneFirst;
+  const outerSeen = cloneSeen;
+  const outerBase = cloneBase;
+  const outerIndex = cloneIndex;
+  const outerNamed = cloneNamed;
+  cloneTop = top;
+  cloneCountdown = SNAPSHOT_CHECK_AFTER;
+  cloneContainer = container;
+  cloneContents = contents;
+  cloneFresh = checkFresh && locationNodes.get(top) === undefined;
+  cloneFirst = undefined;
+  cloneSeen = undefined;
+  cloneBase = base;
+  cloneIndex = undefined;
+  cloneNamed = named;
+  try {
+    const copy = cloneEntry(value, 0, named);
+    if (checkFresh)
+      copiedFresh = cloneFresh;
+    return copy;
+  } finally {
+    cloneAncestors.length = base;
+    cloneCopies.length = base;
+    cloneWork.length = workBase;
+    cloneTop = outerTop;
+    cloneCountdown = outerCountdown;
+    cloneContainer = outerContainer;
+    cloneContents = outerContents;
+    cloneFresh = outerFresh;
+    cloneFirst = outerFirst;
+    cloneSeen = outerSeen;
+    cloneBase = outerBase;
+    cloneIndex = outerIndex;
+    cloneNamed = outerNamed;
+  }
+}
+var cloneTop;
+var cloneCountdown = 0;
+var cloneContainer;
+var cloneContents;
+var cloneFresh = false;
+var cloneFirst;
+var cloneSeen;
+var cloneNamed = 0 /* None */;
+function copySmall(value, container, checkFresh, named) {
+  if (!Array.isArray(value)) {
+    const copy2 = copyLeaf(value);
+    if (copy2 !== undefined && checkFresh)
+      copiedFresh = locationNodes.get(value) === undefined;
+    return copy2;
+  }
+  const length = value.length;
+  if (length > 8)
+    return;
+  if (named === 2 /* All */ && namedKeys(value) !== undefined)
+    return;
+  const copy = new Array(length);
+  let fresh = checkFresh && locationNodes.get(value) === undefined;
+  for (let i = 0;i < length; i++) {
+    const item = value[i];
+    if (item === null || typeof item !== "object") {
+      if (item !== undefined || i in value)
+        copy[i] = item;
+      continue;
+    }
+    if (item === container || toRaw(item) !== item)
+      return;
+    const leaf = copyLeaf(item);
+    if (leaf === undefined)
+      return;
+    copy[i] = leaf;
+    if (fresh)
+      fresh = locationNodes.get(item) === undefined && value.indexOf(item) === i;
   }
+  if (checkFresh)
+    copiedFresh = fresh;
+  return copy;
+}
+function copyLeaf(value) {
+  if (Object.getPrototypeOf(value) !== Object.prototype)
+    return;
+  const copy = {};
+  for (const key in value) {
+    if (!hasOwn.call(value, key))
+      continue;
+    const entry = value[key];
+    if (entry !== null && typeof entry === "object")
+      return;
+    if (key === "__proto__")
+      setData(copy, key, entry);
+    else
+      copy[key] = entry;
+  }
+  if (Object.getOwnPropertySymbols(value).length !== 0)
+    return;
+  return copy;
+}
+function readsOf(identity) {
+  if (identity !== cloneContainer)
+    return identity;
+  if (cloneContents === undefined)
+    throw reachedContainer;
+  return cloneContents;
+}
+function countCopy() {
+  if (--cloneCountdown === 0) {
+    if (cloneFresh)
+      cloneCountdown = SNAPSHOT_CHECK_AFTER;
+    else
+      checkSharedCopies(cloneTop);
+  }
+}
+function noteFresh(value) {
   const identity = toRaw(value);
-  if (seen.has(identity)) {
-    return seen.get(identity);
+  if (identity !== value || identity === cloneTop || locationNodes.get(identity) !== undefined) {
+    cloneFresh = false;
+    return;
   }
-  if (Array.isArray(value)) {
-    const newArray = [];
-    seen.set(identity, newArray);
-    for (let i = 0;i < value.length; i++) {
-      newArray[i] = deepClone(value[i], seen);
+  const first = cloneFirst;
+  if (first === undefined) {
+    cloneFirst = identity;
+    return;
+  }
+  if (identity === first) {
+    cloneFresh = false;
+    return;
+  }
+  let seen = cloneSeen;
+  if (seen === undefined) {
+    seen = cloneSeen = new Set;
+    seen.add(first);
+  }
+  const size = seen.size;
+  seen.add(identity);
+  if (seen.size === size)
+    cloneFresh = false;
+}
+function namedKeys(array) {
+  const keys = Object.keys(array);
+  let start = keys.length;
+  while (start > 0 && !isIndexKey(keys[start - 1]))
+    start--;
+  const symbols = Object.getOwnPropertySymbols(array);
+  let names = start === keys.length ? undefined : keys.slice(start);
+  for (let i = 0;i < symbols.length; i++) {
+    if (isEnumerable.call(array, symbols[i]))
+      (names ??= []).push(symbols[i]);
+  }
+  return names;
+}
+function isIndexKey(key) {
+  const length = key.length;
+  if (length === 0 || length > 10)
+    return false;
+  const first = key.charCodeAt(0);
+  if (first < 48 || first > 57 || first === 48 && length > 1)
+    return false;
+  for (let i = 1;i < length; i++) {
+    const code = key.charCodeAt(i);
+    if (code < 48 || code > 57)
+      return false;
+  }
+  return length < 10 || Number(key) < 4294967295;
+}
+function setData(object, key, value) {
+  Object.defineProperty(object, key, { value, writable: true, enumerable: true, configurable: true });
+}
+function checkSharedCopies(value) {
+  const walk = { extra: 0, low: Infinity, marks: new Map };
+  walkCopies(value, walk);
+  if (walk.extra > SNAPSHOT_SHARED_COPY_LIMIT)
+    throw new SnapshotLimitError(walk.extra);
+}
+function walkCopies(top, walk) {
+  const frames = [];
+  enterCopies(top, 0, walk, frames);
+  while (frames.length > 0) {
+    const frame = frames[frames.length - 1];
+    if (frame.next < frame.entries.length && walk.extra <= SNAPSHOT_SHARED_COPY_LIMIT) {
+      const entry = frame.entries[frame.next++];
+      if (entry === null || typeof entry !== "object") {
+        walk.low = Infinity;
+        continue;
+      }
+      const size = enterCopies(entry, frame.depth + 1, walk, frames);
+      if (frames[frames.length - 1] !== frame)
+        continue;
+      frame.size += size;
+      if (walk.low < frame.low)
+        frame.low = walk.low;
+      continue;
+    }
+    frames.pop();
+    walk.marks.set(frame.identity, frame.low > frame.depth ? frame.size : -1);
+    walk.low = frame.low;
+    const below = frames[frames.length - 1];
+    if (below !== undefined) {
+      below.size += frame.size;
+      if (frame.low < below.low)
+        below.low = frame.low;
     }
-    return newArray;
   }
-  if (value instanceof Map) {
-    const newMap = new Map;
-    seen.set(identity, newMap);
-    value.forEach((val, key) => {
-      newMap.set(deepClone(key, seen), deepClone(val, seen));
-    });
-    return newMap;
+}
+function enterCopies(value, depth, walk, frames) {
+  const identity = toRaw(value);
+  const source = identity === cloneContainer ? readsOf(identity) : identity;
+  const marks = walk.marks;
+  const mark = marks.get(identity);
+  if (mark !== undefined) {
+    if (mark <= -2) {
+      walk.low = -mark - 2;
+      return 0;
+    }
+    walk.low = Infinity;
+    if (mark > 0) {
+      walk.extra += mark;
+      return mark;
+    }
+    walk.extra++;
+  }
+  if (walk.extra > SNAPSHOT_SHARED_COPY_LIMIT) {
+    if (mark === undefined)
+      marks.set(identity, 1);
+    walk.low = Infinity;
+    return 1;
+  }
+  marks.set(identity, -(depth + 2));
+  frames.push({ identity, depth, entries: entriesOf(source, identity), next: 0, size: 1, low: Infinity });
+  return 0;
+}
+function entriesOf(source, identity) {
+  if (Array.isArray(source)) {
+    const names = keepsNamed(cloneNamed, identity === cloneTop ? 0 : 1) ? namedKeys(source) : undefined;
+    if (names === undefined)
+      return source;
+    const entries2 = source.slice();
+    for (let i = 0;i < names.length; i++)
+      entries2.push(source[names[i]]);
+    return entries2;
+  }
+  const entries = [];
+  if (source instanceof Map) {
+    for (const [key, entry] of Map.prototype.entries.call(source))
+      entries.push(key, entry);
+  } else if (source instanceof Set) {
+    for (const entry of Set.prototype.values.call(source))
+      entries.push(entry);
+  }
+  for (const key in source)
+    if (hasOwn.call(source, key))
+      entries.push(source[key]);
+  const symbolKeys = Object.getOwnPropertySymbols(source);
+  for (let i = 0;i < symbolKeys.length; i++) {
+    if (isEnumerable.call(source, symbolKeys[i]))
+      entries.push(source[symbolKeys[i]]);
+  }
+  return entries;
+}
+var cloneAncestors = [];
+var cloneCopies = [];
+var cloneBase = 0;
+var cloneIndex;
+var DEEP_PATH = 64;
+var cloneWork = [];
+var FILL_DEPTH = 256;
+var hasOwn = Object.prototype.hasOwnProperty;
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+function enterPath(identity, copy, depth) {
+  cloneAncestors.push(identity);
+  cloneCopies.push(copy);
+  if (depth < DEEP_PATH)
+    return;
+  if (cloneIndex !== undefined) {
+    cloneIndex.set(identity, copy);
+    return;
   }
-  if (value instanceof Set) {
-    const newSet = new Set;
-    seen.set(identity, newSet);
-    value.forEach((val) => {
-      newSet.add(deepClone(val, seen));
-    });
-    return newSet;
+  cloneIndex = new Map;
+  for (let i = cloneBase;i < cloneAncestors.length; i++)
+    cloneIndex.set(cloneAncestors[i], cloneCopies[i]);
+}
+function leavePath(length) {
+  const ancestors = cloneAncestors;
+  const index = cloneIndex;
+  while (ancestors.length > length) {
+    const identity = ancestors.pop();
+    cloneCopies.pop();
+    if (index !== undefined)
+      index.delete(identity);
+  }
+  if (index !== undefined && length - cloneBase <= DEEP_PATH)
+    cloneIndex = undefined;
+}
+function cloneValue(value, depth, named) {
+  if (value === null || typeof value !== "object")
+    return value;
+  if (cloneFresh)
+    noteFresh(value);
+  return cloneEntry(value, depth, named);
+}
+function keepsNamed(named, depth) {
+  return named === 2 /* All */ || named === 1 /* Below */ && depth > 0;
+}
+function cloneEntry(value, depth, named) {
+  const identity = toRaw(value);
+  if (identity === cloneContainer)
+    value = readsOf(identity);
+  if (depth > DEEP_PATH) {
+    const ancestor = cloneIndex.get(identity);
+    if (ancestor !== undefined)
+      return ancestor;
+  } else {
+    const ancestors = cloneAncestors;
+    for (let i = ancestors.length - 1, stop = ancestors.length - depth;i >= stop; i--) {
+      if (ancestors[i] === identity)
+        return cloneCopies[i];
+    }
   }
-  const newObject = Object.create(Object.getPrototypeOf(value));
-  seen.set(identity, newObject);
-  for (const key in value) {
-    if (Object.prototype.hasOwnProperty.call(value, key)) {
-      newObject[key] = deepClone(value[key], seen);
+  countCopy();
+  let copy;
+  let kind;
+  if (Array.isArray(value)) {
+    copy = new Array(value.length);
+    kind = 1 /* Array */;
+  } else {
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype === Object.prototype) {
+      copy = {};
+      kind = 0 /* Object */;
+    } else if (value instanceof Date) {
+      copy = new Date(value.getTime());
+      kind = 0 /* Object */;
+    } else if (value instanceof Map) {
+      copy = new Map;
+      kind = 2 /* Map */;
+    } else if (value instanceof Set) {
+      copy = new Set;
+      kind = 3 /* Set */;
+    } else {
+      copy = Object.create(prototype);
+      kind = 0 /* Object */;
     }
   }
-  const symbolKeys = Object.getOwnPropertySymbols(value);
-  for (const symbolKey of symbolKeys) {
-    const descriptor = Object.getOwnPropertyDescriptor(value, symbolKey);
-    if (descriptor && Object.prototype.propertyIsEnumerable.call(value, symbolKey)) {
-      newObject[symbolKey] = deepClone(value[symbolKey], seen);
+  if (depth >= FILL_DEPTH - 1) {
+    cloneDeep(kind, value, identity, copy, depth, named);
+    return copy;
+  }
+  const below = depth + 1;
+  let pushed = false;
+  if (kind === 0 /* Object */) {
+    for (const key in value) {
+      if (!hasOwn.call(value, key))
+        continue;
+      let child = value[key];
+      if (child !== null && typeof child === "object") {
+        if (!pushed) {
+          pushed = true;
+          enterPath(identity, copy, depth);
+        }
+        if (cloneFresh)
+          noteFresh(child);
+        child = cloneEntry(child, below, named);
+      }
+      if (key === "__proto__")
+        setData(copy, key, child);
+      else
+        copy[key] = child;
+    }
+    const symbolKeys = Object.getOwnPropertySymbols(value);
+    if (symbolKeys.length !== 0)
+      pushed = fillSymbols(value, identity, copy, depth, named, symbolKeys, pushed);
+  } else if (kind === 1 /* Array */) {
+    const length = copy.length;
+    for (let i = 0;i < length; i++) {
+      const child = value[i];
+      if (child === null || typeof child !== "object") {
+        if (child !== undefined || i in value)
+          copy[i] = child;
+        continue;
+      }
+      if (!pushed) {
+        pushed = true;
+        enterPath(identity, copy, depth);
+      }
+      if (cloneFresh)
+        noteFresh(child);
+      copy[i] = cloneEntry(child, below, named);
     }
+    if (keepsNamed(named, depth))
+      pushed = fillNamed(value, identity, copy, depth, named, pushed);
+  } else {
+    pushed = kind === 2 /* Map */ ? fillMap(value, identity, copy, depth, named) : fillSet(value, identity, copy, depth, named);
   }
-  return newObject;
-}
-// src/state.ts
-function getValue(obj, key) {
-  if (obj instanceof Map)
-    return obj.get(key);
-  return obj[key];
+  if (pushed) {
+    if (depth < DEEP_PATH) {
+      cloneAncestors.pop();
+      cloneCopies.pop();
+    } else {
+      leavePath(cloneAncestors.length - 1);
+    }
+  }
+  return copy;
 }
-function setValue(obj, key, value) {
-  if (obj instanceof Map)
-    obj.set(key, value);
-  else
-    obj[key] = value;
+function cloneDeep(kind, value, identity, copy, depth, named) {
+  const pathLength = cloneAncestors.length;
+  if (depth >= FILL_DEPTH) {
+    cloneWork.push(kind, value, identity, copy, pathLength);
+    return;
+  }
+  const workBase = cloneWork.length;
+  fill(kind, value, identity, copy, depth, named);
+  fillWaiting(workBase);
+  leavePath(pathLength);
 }
-function deleteValue(obj, key) {
-  if (obj instanceof Map)
-    obj.delete(key);
+function fill(kind, value, identity, copy, depth, named) {
+  if (kind === 0 /* Object */)
+    fillObject(value, identity, copy, depth, named);
+  else if (kind === 1 /* Array */)
+    fillArray(value, identity, copy, depth, named);
+  else if (kind === 2 /* Map */)
+    fillMap(value, identity, copy, depth, named);
   else
-    delete obj[key];
+    fillSet(value, identity, copy, depth, named);
 }
-function validateCachedPath(root, fullPath, pathKey, cached) {
-  if (fullPath.length === 0)
-    return cached;
-  const lastKey = fullPath[fullPath.length - 1];
-  let grandparent = root;
-  for (let i = 0;i < fullPath.length - 1; i++) {
-    grandparent = grandparent ? getValue(grandparent, fullPath[i]) : undefined;
-    if (grandparent === undefined)
-      break;
+function fillWaiting(workBase) {
+  const work = cloneWork;
+  while (work.length > workBase) {
+    const at = work.length - 5;
+    const kind = work[at];
+    const value = work[at + 1];
+    const identity = work[at + 2];
+    const copy = work[at + 3];
+    const pathLength = work[at + 4];
+    work.length = at;
+    if (cloneAncestors.length !== pathLength)
+      leavePath(pathLength);
+    fill(kind, value, identity, copy, FILL_DEPTH, cloneNamed);
   }
-  if (grandparent === undefined) {
-    evictDescendantsFromPathCache(root, pathKey);
-    return;
+}
+function fillObject(value, identity, copy, depth, named) {
+  const below = depth + 1;
+  let pushed = false;
+  for (const key in value) {
+    if (!hasOwn.call(value, key))
+      continue;
+    let child = value[key];
+    if (child !== null && typeof child === "object") {
+      if (!pushed) {
+        pushed = true;
+        enterPath(identity, copy, depth);
+      }
+      if (cloneFresh)
+        noteFresh(child);
+      child = cloneEntry(child, below, named);
+    }
+    if (key === "__proto__")
+      setData(copy, key, child);
+    else
+      copy[key] = child;
   }
-  const actual = getValue(grandparent, lastKey);
-  if (actual === cached)
-    return cached;
-  evictDescendantsFromPathCache(root, pathKey);
-  return;
+  const symbolKeys = Object.getOwnPropertySymbols(value);
+  return symbolKeys.length === 0 ? pushed : fillSymbols(value, identity, copy, depth, named, symbolKeys, pushed);
 }
-var actionHandlers = {
-  set: function(parent, key, event) {
-    if (Array.isArray(parent) && key === "length" && Number(event.newValue) > parent.length) {
-      console.warn(`refusing to grow array length via bare set at path ${event.path.join(".")}`);
-      return;
-    }
-    setValue(parent, key, event.newValue);
-  },
-  delete: function(parent, key) {
-    deleteValue(parent, key);
-  },
-  "array-push": function(targetArray, _keyIgnored, event) {
-    if (!Array.isArray(targetArray)) {
-      console.warn(`expected array at path ${event.path.join(".")}`);
+function fillSymbols(value, identity, copy, depth, named, symbolKeys, pushed) {
+  const below = depth + 1;
+  for (let i = 0;i < symbolKeys.length; i++) {
+    const symbolKey = symbolKeys[i];
+    if (!isEnumerable.call(value, symbolKey))
+      continue;
+    const child = value[symbolKey];
+    if (child !== null && typeof child === "object" && !pushed) {
+      pushed = true;
+      enterPath(identity, copy, depth);
+    }
+    copy[symbolKey] = cloneValue(child, below, named);
+  }
+  return pushed;
+}
+function fillArray(value, identity, copy, depth, named) {
+  const below = depth + 1;
+  let pushed = false;
+  const length = copy.length;
+  for (let i = 0;i < length; i++) {
+    const child = value[i];
+    if (child === null || typeof child !== "object") {
+      if (child !== undefined || i in value)
+        copy[i] = child;
+      continue;
+    }
+    if (!pushed) {
+      pushed = true;
+      enterPath(identity, copy, depth);
+    }
+    if (cloneFresh)
+      noteFresh(child);
+    copy[i] = cloneEntry(child, below, named);
+  }
+  return keepsNamed(named, depth) ? fillNamed(value, identity, copy, depth, named, pushed) : pushed;
+}
+function fillNamed(value, identity, copy, depth, named, pushed) {
+  const names = namedKeys(value);
+  if (names === undefined)
+    return pushed;
+  const below = depth + 1;
+  for (let i = 0;i < names.length; i++) {
+    const child = value[names[i]];
+    if (child !== null && typeof child === "object" && !pushed) {
+      pushed = true;
+      enterPath(identity, copy, depth);
+    }
+    setData(copy, names[i], cloneValue(child, below, named));
+  }
+  return pushed;
+}
+function fillMap(value, identity, copy, depth, named) {
+  const below = depth + 1;
+  enterPath(identity, copy, depth);
+  const entries = toRaw(value);
+  Map.prototype.forEach.call(entries, (entry, key) => {
+    const keyCopy = cloneValue(key, below, named);
+    copy.set(nameMember(key, keyCopy, entries, false), cloneValue(entry, below, named));
+  });
+  fillCollectionProperties(entries, copy, below, named);
+  return true;
+}
+function fillSet(value, identity, copy, depth, named) {
+  const below = depth + 1;
+  enterPath(identity, copy, depth);
+  const members = toRaw(value);
+  let later;
+  Set.prototype.forEach.call(members, (entry) => {
+    if (entry === null || typeof entry !== "object") {
+      copy.add(entry);
       return;
     }
-    if (!event.items) {
-      console.warn("array-push event missing items");
+    const raw = toRaw(entry);
+    if (raw !== entry && later === undefined && Set.prototype.has.call(members, raw))
+      later = laterTwins(members);
+    if (later !== undefined && later.has(entry))
       return;
-    }
-    targetArray.push(...event.items);
-  },
-  "array-pop": function(targetArray, _keyIgnored, event) {
-    if (!Array.isArray(targetArray)) {
-      console.warn(`expected array at path ${event.path.join(".")}`);
+    const entryCopy = cloneValue(entry, below, named);
+    if (copyingPayload)
+      nameCopyOfCopy(entry, entryCopy);
+    else
+      nameRaw(raw, collectionIdentities.members.get(raw), entry, entryCopy, members, false);
+    copy.add(entryCopy);
+  });
+  fillCollectionProperties(members, copy, below, named);
+  return true;
+}
+function laterTwins(set) {
+  const seen = new Set;
+  const later = new Set;
+  Set.prototype.forEach.call(set, (member) => {
+    if (member === null || typeof member !== "object")
       return;
+    const raw = toRaw(member);
+    if (seen.has(raw))
+      later.add(member);
+    else
+      seen.add(raw);
+  });
+  return later;
+}
+function fillCollectionProperties(value, copy, depth, named) {
+  for (const key in value) {
+    if (hasOwn.call(value, key))
+      setData(copy, key, cloneValue(value[key], depth, named));
+  }
+  const symbols = Object.getOwnPropertySymbols(value);
+  for (let i = 0;i < symbols.length; i++) {
+    if (isEnumerable.call(value, symbols[i]))
+      setData(copy, symbols[i], cloneValue(value[symbols[i]], depth, named));
+  }
+}
+var collectionIdentityKey = Symbol.for("@yiin/reactive-proxy-state.collection-identities.v4");
+var collectionIdentities = Reflect.get(globalThis, collectionIdentityKey) ?? { members: new WeakMap, copies: new WeakMap, indexes: new WeakMap, overrides: new WeakMap, watches: new WeakMap };
+if (!Reflect.has(globalThis, collectionIdentityKey)) {
+  Object.defineProperty(globalThis, collectionIdentityKey, { value: collectionIdentities });
+}
+function ownToken(member) {
+  const token = { shared: false };
+  collectionIdentities.members.set(member, token);
+  return token;
+}
+function nameMember(member, copy, collection, entering) {
+  if (member === null || typeof member !== "object" || copy === null || typeof copy !== "object")
+    return copy;
+  if (copyingPayload) {
+    nameCopyOfCopy(member, copy);
+    return copy;
+  }
+  const raw = toRaw(member);
+  const own = collectionIdentities.members.get(raw);
+  if (own === undefined || own.shared)
+    return nameRaw(raw, own, member, copy, collection, entering);
+  if (copy !== member)
+    collectionIdentities.copies.set(copy, own);
+  return copy;
+}
+function nameKey(event, key, collection, entering) {
+  const raw = toRaw(key);
+  const own = collectionIdentities.members.get(raw);
+  if (own === undefined) {
+    if (entering)
+      ownToken(raw);
+    else
+      namedInPlace(raw, collection);
+    return;
+  }
+  if (!own.shared)
+    return;
+  event.key = nameRaw(raw, own, key, key, collection, entering);
+}
+function nameRaw(raw, own, member, copy, collection, entering) {
+  let token;
+  if (own === undefined)
+    token = entering ? ownToken(raw) : namedInPlace(raw, collection);
+  else if (!own.shared)
+    token = own;
+  else
+    token = sharedTokenIn(raw, own, collection, entering);
+  if (copy !== member) {
+    collectionIdentities.copies.set(copy, token);
+    return copy;
+  }
+  return own === undefined || token === own ? copy : carrier(raw, token);
+}
+function namedInPlace(member, collection) {
+  const origin = collectionIdentities.copies.get(member);
+  if (origin === undefined)
+    return ownToken(member);
+  const index = replicaIndex(collection, true);
+  const held = heldMember(collection, index, origin);
+  if (held !== undefined && held !== member) {
+    const token = ownToken(member);
+    index.byToken.set(token, member);
+    return token;
+  }
+  origin.shared = true;
+  collectionIdentities.members.set(member, origin);
+  index.byToken.set(origin, member);
+  return origin;
+}
+function sharedTokenIn(member, token, collection, entering) {
+  let inCollection = collectionIdentities.overrides.get(collection);
+  const current = inCollection?.get(member) ?? token;
+  if (!entering)
+    return current;
+  const index = replicaIndex(collection, true);
+  const held = heldMember(collection, index, current);
+  if (held === undefined || held === member)
+    return current;
+  const other = { shared: false };
+  if (inCollection === undefined)
+    collectionIdentities.overrides.set(collection, inCollection = new WeakMap);
+  inCollection.set(member, other);
+  index.byToken.set(other, member);
+  return other;
+}
+function carrier(member, token) {
+  const copy = cloneTree(member, 2 /* All */);
+  collectionIdentities.copies.set(copy, token);
+  return copy;
+}
+function nameCopyOfCopy(source, copy) {
+  if (source === null || typeof source !== "object" || copy === null || typeof copy !== "object")
+    return;
+  const token = collectionIdentities.copies.get(source) ?? collectionIdentities.members.get(source);
+  if (token !== undefined)
+    collectionIdentities.copies.set(copy, token);
+}
+var copyingPayload = false;
+function copyingPayloads(run) {
+  const outer = copyingPayload;
+  copyingPayload = true;
+  try {
+    return run();
+  } finally {
+    copyingPayload = outer;
+  }
+}
+function eventToken(member) {
+  const raw = toRaw(member);
+  return collectionIdentities.members.get(raw) ?? collectionIdentities.copies.get(raw);
+}
+function replicaIndex(collection, member) {
+  let index = collectionIdentities.indexes.get(collection);
+  const size = collection.size;
+  if (index === undefined || index.size !== size || index.member !== member) {
+    const byToken = new Map;
+    const overrides = member ? collectionIdentities.overrides.get(collection) : undefined;
+    const members = collection instanceof Map ? Map.prototype.keys.call(collection) : Set.prototype.values.call(collection);
+    for (const held of members) {
+      if (held === null || typeof held !== "object")
+        continue;
+      const raw = toRaw(held);
+      if (member) {
+        const own = overrides?.get(raw) ?? collectionIdentities.members.get(raw);
+        if (own !== undefined) {
+          byToken.set(own, held);
+          continue;
+        }
+        const origin = collectionIdentities.copies.get(raw);
+        if (origin !== undefined && !byToken.has(origin))
+          byToken.set(origin, held);
+      } else {
+        const token = collectionIdentities.copies.get(raw) ?? collectionIdentities.members.get(raw);
+        if (token !== undefined && !byToken.has(token))
+          byToken.set(token, held);
+      }
     }
-    if (targetArray.length > 0) {
-      targetArray.pop();
-    }
-  },
-  "array-splice": function(targetArray, _keyIgnored, event) {
-    if (!Array.isArray(targetArray)) {
-      console.warn(`expected array at path ${event.path.join(".")}`);
-      return;
+    index = { byToken, size, member };
+    collectionIdentities.indexes.set(collection, index);
+    const watch = indexWatches.get(collection);
+    if (watch !== undefined)
+      watch.indexed = true;
+  }
+  return index;
+}
+var indexWatches = collectionIdentities.watches;
+function watchIndex(collection) {
+  const watch = { indexed: collectionIdentities.indexes.has(collection) };
+  indexWatches.set(collection, watch);
+  return watch;
+}
+function heldToken(collection, member) {
+  return collectionIdentities.overrides.get(collection)?.get(member) ?? collectionIdentities.members.get(member);
+}
+function indexAdded(collection, member) {
+  const index = collectionIdentities.indexes.get(collection);
+  if (index === undefined)
+    return;
+  if (!index.member || index.size !== collection.size - 1) {
+    collectionIdentities.indexes.delete(collection);
+    return;
+  }
+  index.size = collection.size;
+  if (member === null || typeof member !== "object")
+    return;
+  const raw = toRaw(member);
+  const own = heldToken(collection, raw);
+  if (own !== undefined) {
+    index.byToken.set(own, member);
+    return;
+  }
+  const origin = collectionIdentities.copies.get(raw);
+  if (origin !== undefined && !index.byToken.has(origin))
+    index.byToken.set(origin, member);
+}
+function indexRemoved(collection, member) {
+  const index = collectionIdentities.indexes.get(collection);
+  if (index === undefined)
+    return;
+  if (!index.member || index.size !== collection.size + 1) {
+    collectionIdentities.indexes.delete(collection);
+    return;
+  }
+  index.size = collection.size;
+  if (member === null || typeof member !== "object")
+    return;
+  const raw = toRaw(member);
+  const token = heldToken(collection, raw) ?? collectionIdentities.copies.get(raw);
+  if (token !== undefined && index.byToken.get(token) === member)
+    index.byToken.delete(token);
+}
+function keepIndexSize(collection) {
+  const index = collectionIdentities.indexes.get(collection);
+  if (index !== undefined)
+    index.size = collection.size;
+}
+function heldMember(raw, index, token) {
+  const held = index.byToken.get(token);
+  return held !== undefined && raw.has(held) ? held : undefined;
+}
+function newMember(raw, member, token, reactive) {
+  let added = member;
+  if (raw.has(member)) {
+    added = cloneTree(member, 2 /* All */);
+    collectionIdentities.copies.set(added, token);
+  }
+  if (reactive && !collectionIdentities.members.has(added)) {
+    token.shared = true;
+    collectionIdentities.members.set(added, token);
+  }
+  return added;
+}
+function objectToken(value) {
+  return value !== null && typeof value === "object" ? eventToken(value) : undefined;
+}
+function replicaAdd(set, value) {
+  const raw = toRaw(set);
+  const token = objectToken(value);
+  if (token === undefined) {
+    set.add(value);
+    keepIndexSize(raw);
+    return;
+  }
+  const index = replicaIndex(raw, raw !== set);
+  if (heldMember(raw, index, token) !== undefined)
+    return;
+  const member = newMember(raw, toRaw(value), token, set !== raw);
+  set.add(member);
+  index.byToken.set(token, member);
+  index.size = raw.size;
+}
+function replicaDelete(set, value) {
+  const raw = toRaw(set);
+  const token = objectToken(value);
+  if (token === undefined) {
+    set.delete(value);
+    keepIndexSize(raw);
+    return;
+  }
+  const index = replicaIndex(raw, raw !== set);
+  const held = heldMember(raw, index, token);
+  set.delete(held === undefined ? value : held);
+  index.byToken.delete(token);
+  index.size = raw.size;
+}
+function replicaMapSet(map, key, value) {
+  const raw = toRaw(map);
+  const token = objectToken(key);
+  if (token === undefined) {
+    map.set(key, value);
+    keepIndexSize(raw);
+    return;
+  }
+  const index = replicaIndex(raw, raw !== map);
+  const held = heldMember(raw, index, token);
+  if (held !== undefined) {
+    map.set(held, value);
+    return;
+  }
+  const member = newMember(raw, toRaw(key), token, map !== raw);
+  map.set(member, value);
+  index.byToken.set(token, member);
+  index.size = raw.size;
+}
+function replicaMapDelete(map, key) {
+  const raw = toRaw(map);
+  const token = objectToken(key);
+  if (token === undefined) {
+    map.delete(key);
+    keepIndexSize(raw);
+    return;
+  }
+  const index = replicaIndex(raw, raw !== map);
+  const held = heldMember(raw, index, token);
+  map.delete(held === undefined ? key : held);
+  index.byToken.delete(token);
+  index.size = raw.size;
+}
+function forgetReplicaIndex(collection) {
+  collectionIdentities.indexes.delete(toRaw(collection));
+}
+function deepClone(value, seen = new WeakMap) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (value instanceof Date) {
+    return new Date(value.getTime());
+  }
+  const identity = toRaw(value);
+  if (seen.has(identity)) {
+    return seen.get(identity);
+  }
+  if (Array.isArray(value)) {
+    const newArray = [];
+    seen.set(identity, newArray);
+    for (let i = 0;i < value.length; i++) {
+      newArray[i] = deepClone(value[i], seen);
     }
-    if (event.key === undefined || event.deleteCount === undefined) {
-      console.warn("array-splice event missing key or deletecount");
-      return;
+    return newArray;
+  }
+  if (value instanceof Map) {
+    const newMap = new Map;
+    seen.set(identity, newMap);
+    value.forEach((val, key) => {
+      newMap.set(deepClone(key, seen), deepClone(val, seen));
+    });
+    return newMap;
+  }
+  if (value instanceof Set) {
+    const newSet = new Set;
+    seen.set(identity, newSet);
+    value.forEach((val) => {
+      newSet.add(deepClone(val, seen));
+    });
+    return newSet;
+  }
+  const newObject = Object.create(Object.getPrototypeOf(value));
+  seen.set(identity, newObject);
+  for (const key in value) {
+    if (Object.prototype.hasOwnProperty.call(value, key)) {
+      newObject[key] = deepClone(value[key], seen);
     }
-    if (event.items && event.items.length > 0) {
-      targetArray.splice(event.key, event.deleteCount, ...event.items);
-    } else {
-      targetArray.splice(event.key, event.deleteCount);
+  }
+  const symbolKeys = Object.getOwnPropertySymbols(value);
+  for (const symbolKey of symbolKeys) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, symbolKey);
+    if (descriptor && Object.prototype.propertyIsEnumerable.call(value, symbolKey)) {
+      newObject[symbolKey] = deepClone(value[symbolKey], seen);
     }
-  },
-  "array-shift": function(targetArray, _keyIgnored, event) {
-    if (!Array.isArray(targetArray)) {
-      console.warn(`expected array at path ${event.path.join(".")}`);
-      return;
+  }
+  return newObject;
+}
+// src/location.ts
+class Place {
+  parentRef;
+  parentId;
+  key;
+  constructor(parent, key) {
+    this.parentRef = new WeakRef(parent);
+    this.parentId = parent.id;
+    this.key = key;
+    parent.childPlaces++;
+  }
+  get parent() {
+    return this.parentRef.deref();
+  }
+}
+function dropped(place) {
+  const parent = place.parent;
+  if (parent !== undefined)
+    parent.childPlaces--;
+}
+var WIDE = 8;
+var nodes = locationNodes;
+var nodeCount = 0;
+var FAST_CHAIN_LIMIT = 256;
+function isObject2(value) {
+  return value !== null && typeof value === "object";
+}
+function getLocationNode(raw) {
+  return nodes.get(raw);
+}
+function ensureLocationNode(raw) {
+  let node = nodes.get(raw);
+  if (node === undefined) {
+    node = {
+      id: ++nodeCount,
+      raw,
+      kind: raw instanceof Map ? 1 /* Map */ : raw instanceof Set ? 2 /* Set */ : 0 /* Plain */,
+      places: [],
+      root: undefined,
+      scope: undefined,
+      proxy: undefined,
+      evicted: undefined,
+      relinked: 0,
+      relinkedPlaces: 0,
+      lostLink: false,
+      dataOnly: undefined,
+      childPlaces: 0,
+      walk: 0,
+      touched: 0,
+      pruned: 0,
+      index: undefined
+    };
+    nodes.set(raw, node);
+  }
+  return node;
+}
+function writesThroughSetter(target, prop, node) {
+  let dataOnly = node.dataOnly;
+  if (dataOnly === undefined)
+    dataOnly = node.dataOnly = hasNoOwnAccessor(target);
+  if (dataOnly)
+    return false;
+  const descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+  return descriptor !== undefined && descriptor.set !== undefined;
+}
+function hasNoOwnAccessor(target) {
+  const keys = Reflect.ownKeys(target);
+  if (keys.length > 64)
+    return false;
+  for (let i = 0;i < keys.length; i++) {
+    const descriptor = Reflect.getOwnPropertyDescriptor(target, keys[i]);
+    if (descriptor.get !== undefined || descriptor.set !== undefined)
+      return false;
+  }
+  return true;
+}
+function holdsIn(parent, key, raw) {
+  if (parent === undefined)
+    return false;
+  const container = parent.raw;
+  switch (parent.kind) {
+    case 1 /* Map */: {
+      const held = container.get(key);
+      return held === raw || proxyOf(held, raw);
     }
-    if (targetArray.length > 0) {
-      targetArray.shift();
+    case 2 /* Set */:
+      return container.has(raw);
+    default: {
+      const held = container[key];
+      return held === raw || proxyOf(held, raw);
     }
-  },
-  "array-unshift": function(targetArray, _keyIgnored, event) {
-    if (!Array.isArray(targetArray)) {
-      console.warn(`expected array at path ${event.path.join(".")}`);
-      return;
+  }
+}
+function proxyOf(held, raw) {
+  return isObject2(held) && held["__v_raw" /* RAW */] !== undefined && toRaw(held) === raw;
+}
+function holds(place, raw) {
+  return holdsIn(place.parent, place.key, raw);
+}
+function segment(parent, key, raw) {
+  if (parent.kind === 2 /* Set */) {
+    let index = 0;
+    for (const member of parent.raw) {
+      if (member === raw)
+        break;
+      index++;
     }
-    if (!event.items) {
-      console.warn("array-unshift event missing items");
-      return;
+    return String(index);
+  }
+  return String(key);
+}
+function samePlace(place, parent, key) {
+  return place.parentId === parent.id && (parent.kind === 2 /* Set */ || place.key === key);
+}
+function chain(node, tail) {
+  let reversed;
+  let current = node;
+  for (let steps = 0;steps < FAST_CHAIN_LIMIT; steps++) {
+    const places = current.places;
+    const root = current.root;
+    if (root !== undefined) {
+      if (places.length !== 0)
+        return;
+      return { root, paths: [buildPath(root.path, reversed, tail)] };
+    }
+    if (places.length !== 1)
+      return places.length === 0 ? null : undefined;
+    const place = places[0];
+    const parent = place.parent;
+    if (!holdsIn(parent, place.key, current.raw)) {
+      dropped(place);
+      current.places = [];
+      return null;
     }
-    targetArray.unshift(...event.items);
-  },
-  "map-set": function(targetMap, _parentKeyIgnored, event) {
-    if (!(targetMap instanceof Map)) {
-      console.warn(`expected map at path ${event.path.join(".")}`);
+    (reversed ??= []).push(segment(parent, place.key, current.raw));
+    current = parent;
+  }
+  return;
+}
+function findAll(node, tail, firstOnly) {
+  const out = [];
+  const segments = [];
+  const visiting = new Set;
+  const frames = [];
+  const enter = (entered) => {
+    visiting.add(entered);
+    const root = entered.root;
+    if (root !== undefined)
+      out.push({ root, path: buildPath(root.path, segments, tail) });
+    frames.push({ node: entered, places: entered.places, next: 0, stale: false });
+  };
+  enter(node);
+  while (frames.length > 0) {
+    const frame = frames[frames.length - 1];
+    const current = frame.node;
+    if (frame.next < frame.places.length && !(firstOnly && out.length > 0)) {
+      const place = frame.places[frame.next++];
+      const parent = place.parent;
+      if (!holdsIn(parent, place.key, current.raw)) {
+        frame.stale = true;
+        continue;
+      }
+      if (visiting.has(parent))
+        continue;
+      segments.push(segment(parent, place.key, current.raw));
+      enter(parent);
+      continue;
+    }
+    frames.pop();
+    if (frame.stale)
+      current.places = keepPlaces(frame.places, (place) => holds(place, current.raw));
+    visiting.delete(current);
+    if (frames.length > 0)
+      segments.pop();
+  }
+  return out;
+}
+function buildPath(base, reversed, tail) {
+  const middle = reversed === undefined ? 0 : reversed.length;
+  const path = new Array(base.length + middle + (tail === undefined ? 0 : 1));
+  let index = 0;
+  for (let i = 0;i < base.length; i++)
+    path[index++] = base[i];
+  for (let i = middle - 1;i >= 0; i--)
+    path[index++] = reversed[i];
+  if (tail !== undefined)
+    path[index] = String(tail);
+  return path;
+}
+function locate(node, tail) {
+  const single = chain(node, tail);
+  if (single !== undefined) {
+    if (single === null) {
+      proxyStats.detachedWrites++;
       return;
     }
-    targetMap.set(event.key, event.newValue);
-  },
-  "map-delete": function(targetMap, _parentKeyIgnored, event) {
-    if (!(targetMap instanceof Map)) {
-      console.warn(`expected map at path ${event.path.join(".")}`);
-      return;
+    return single.root.emit === undefined ? undefined : single;
+  }
+  const found = findAll(node, tail, false);
+  if (found.length === 0) {
+    proxyStats.detachedWrites++;
+    return;
+  }
+  let root = found[0].root;
+  for (let i = 1;i < found.length; i++) {
+    if (found[i].root !== root) {
+      if (node.scope !== undefined && found.some((entry) => entry.root === node.scope)) {
+        root = node.scope;
+      }
+      break;
     }
-    targetMap.delete(event.key);
-  },
-  "map-clear": function(targetMap, _parentKeyIgnored, event) {
-    if (!(targetMap instanceof Map)) {
-      console.warn(`expected map at path ${event.path.join(".")}`);
+  }
+  if (root.emit === undefined)
+    return;
+  const paths = [];
+  for (let i = 0;i < found.length; i++) {
+    if (found[i].root === root)
+      paths.push(found[i].path);
+  }
+  return { root, paths };
+}
+function isAttached(node) {
+  const single = chain(node, undefined);
+  if (single !== undefined)
+    return single !== null;
+  return findAll(node, undefined, true).length > 0;
+}
+function attachedBefore(node, former) {
+  let current = node;
+  for (let steps = 0;steps < FAST_CHAIN_LIMIT; steps++) {
+    if (current.root !== undefined || current === former)
+      return true;
+    const places = current.places;
+    if (places.length !== 1)
+      break;
+    const place = places[0];
+    const parent = place.parent;
+    if (!holdsIn(parent, place.key, current.raw))
+      return false;
+    current = parent;
+  }
+  if (current.root !== undefined || current === former)
+    return true;
+  const visited = new Set;
+  visited.add(current);
+  const stack = [current];
+  const next = [0];
+  while (stack.length > 0) {
+    const top = stack.length - 1;
+    const at = stack[top];
+    const places = at.places;
+    if (next[top] >= places.length) {
+      stack.pop();
+      next.pop();
+      continue;
+    }
+    const place = places[next[top]++];
+    const parent = place.parent;
+    if (!holdsIn(parent, place.key, at.raw))
+      continue;
+    if (parent.root !== undefined || parent === former)
+      return true;
+    if (visited.has(parent))
+      continue;
+    visited.add(parent);
+    stack.push(parent);
+    next.push(0);
+  }
+  return false;
+}
+function dispatch(target, event) {
+  const { root, paths } = target;
+  if (paths.length === 1) {
+    if (root.undelivered === undefined)
+      root.emit(event);
+    else
+      deliver(root, [event]);
+    return;
+  }
+  deliver(root, copyingPayloads(() => copiesPerPath(event, paths, root.async)));
+}
+function copiesPerPath(event, paths, async) {
+  const removesValue = event.action === "set-delete";
+  const events = [event];
+  for (let i = 1;i < paths.length; i++) {
+    const copy = { ...event, path: paths[i] };
+    if (isObject2(event.newValue))
+      copy.newValue = cloneTree(event.newValue, event.action === "replace" ? 1 /* Below */ : 0 /* None */);
+    if (isObject2(event.value) && !removesValue) {
+      copy.value = cloneTree(event.value, 2 /* All */);
+      nameCopyOfCopy(event.value, copy.value);
+    }
+    if (event.items !== undefined)
+      copy.items = cloneTree(event.items, 1 /* Below */);
+    if (async) {
+      if (isObject2(event.oldValue))
+        copy.oldValue = cloneTree(event.oldValue, 2 /* All */);
+      if (event.oldValues !== undefined)
+        copy.oldValues = cloneTree(event.oldValues, 1 /* Below */);
+      if (removesValue) {
+        copy.value = copy.oldValue;
+        nameCopyOfCopy(event.value, copy.value);
+      }
+    }
+    events.push(copy);
+  }
+  return events;
+}
+function deliver(root, events) {
+  const emit = root.emit;
+  let queue = root.undelivered;
+  if (queue === undefined) {
+    if (events.length === 1) {
+      emit(events[0]);
       return;
     }
-    targetMap.clear();
-  },
-  "set-add": function(targetSet, _keyIgnored, event) {
-    if (!(targetSet instanceof Set)) {
-      console.warn(`expected set at path ${event.path.join(".")}`);
-      return;
+    queue = root.undelivered = { events, next: 0 };
+  } else {
+    for (let i = 0;i < events.length; i++)
+      queue.events.push(events[i]);
+  }
+  let failed = false;
+  let failure;
+  while (queue.next < queue.events.length) {
+    try {
+      emit(queue.events[queue.next++]);
+    } catch (error) {
+      if (!failed) {
+        failed = true;
+        failure = error;
+      }
     }
-    targetSet.add(event.value);
-  },
-  "set-delete": function(targetSet, _keyIgnored, event) {
-    if (!(targetSet instanceof Set)) {
-      console.warn(`expected set at path ${event.path.join(".")}`);
+  }
+  if (root.undelivered === queue)
+    root.undelivered = undefined;
+  if (failed)
+    throw failure;
+}
+function copyPayload(event, target, container, held) {
+  if (event === undefined)
+    return 1 /* Done */;
+  const removed = target.root.async;
+  const { newValue, oldValue, value, items, oldValues } = event;
+  const stored = event.action !== "set-delete";
+  let fresh = true;
+  let newCopy = newValue;
+  if (isObject2(newValue)) {
+    newCopy = held === undefined ? cloneStored(newValue, container, event.action === "replace" ? 1 /* Below */ : 0 /* None */) : cloneTreeUnless(newValue, container, event.action === "replace" ? 1 /* Below */ : 0 /* None */);
+    if (newCopy === REACHES)
+      return 0 /* Reaches */;
+    fresh = held === undefined && copiedFresh;
+  }
+  let valueCopy = value;
+  if (isObject2(value) && stored) {
+    valueCopy = cloneStored(value, container, 2 /* All */);
+    if (valueCopy === REACHES)
+      return 0 /* Reaches */;
+    fresh &&= copiedFresh;
+  }
+  let itemsCopy = items;
+  if (items !== undefined && holdsObject(items)) {
+    itemsCopy = cloneStored(items, container, 1 /* Below */);
+    if (itemsCopy === REACHES)
+      return 0 /* Reaches */;
+    fresh &&= copiedFresh;
+  }
+  if (removed) {
+    const oldCopy = isObject2(oldValue) ? cloneTreeUnless(oldValue, container, 2 /* All */) : oldValue;
+    if (oldCopy === REACHES)
+      return 0 /* Reaches */;
+    const oldValuesCopy = oldValues !== undefined && holdsObject(oldValues) ? cloneTreeUnless(oldValues, container, 1 /* Below */) : oldValues;
+    if (oldValuesCopy === REACHES)
+      return 0 /* Reaches */;
+    if (isObject2(oldValue))
+      event.oldValue = oldCopy;
+    if (oldValues !== undefined)
+      event.oldValues = oldValuesCopy;
+    if (!stored)
+      valueCopy = event.oldValue;
+  }
+  if (isObject2(newValue))
+    event.newValue = newCopy;
+  if (isObject2(value))
+    event.value = nameMember(value, valueCopy, container, stored);
+  if (items !== undefined)
+    event.items = itemsCopy;
+  return fresh ? 2 /* Fresh */ : 1 /* Done */;
+}
+function copyPayloadReaching(event, target, container, after) {
+  refuseAccessors(event, target.root.async, container, after);
+  copyPayloadAfter(event, target, container, after);
+}
+function copyPayloadAfter(event, target, container, after) {
+  const { newValue, oldValue, value, items, oldValues } = event;
+  const removed = target.root.async;
+  const stored = event.action !== "set-delete";
+  const newCopy = isObject2(newValue) ? cloneTreeAfter(newValue, container, after, event.action === "replace" ? 1 /* Below */ : 0 /* None */) : newValue;
+  const oldCopy = removed && isObject2(oldValue) ? cloneTreeAfter(oldValue, container, after, 2 /* All */) : oldValue;
+  const valueCopy = !isObject2(value) ? value : stored ? cloneTreeAfter(value, container, after, 2 /* All */) : oldCopy;
+  const itemsCopy = items !== undefined && holdsObject(items) ? cloneTreeAfter(items, container, after, 1 /* Below */) : items;
+  const oldValuesCopy = removed && oldValues !== undefined && holdsObject(oldValues) ? cloneTreeAfter(oldValues, container, after, 1 /* Below */) : oldValues;
+  if (isObject2(newValue))
+    event.newValue = newCopy;
+  if (isObject2(oldValue))
+    event.oldValue = oldCopy;
+  if (isObject2(value))
+    event.value = nameMember(value, valueCopy, container, stored);
+  if (items !== undefined)
+    event.items = itemsCopy;
+  if (oldValues !== undefined)
+    event.oldValues = oldValuesCopy;
+}
+function holdsObject(values) {
+  for (let i = 0;i < values.length; i++)
+    if (isObject2(values[i]))
+      return true;
+  return false;
+}
+function shallowCopy(container) {
+  const copy = Array.isArray(container) ? container.slice() : container instanceof Map ? new Map(Map.prototype.entries.call(container)) : container instanceof Set ? new Set(Set.prototype.values.call(container)) : Object.create(Object.getPrototypeOf(container));
+  const keys = Reflect.ownKeys(container);
+  for (let i = 0;i < keys.length; i++) {
+    const value = enumerableData(container, keys[i]);
+    if (value !== NOT_ENUMERABLE)
+      setData(copy, keys[i], value);
+  }
+  return copy;
+}
+var NOT_ENUMERABLE = Symbol("not enumerable");
+function enumerableData(object, key) {
+  const descriptor = Reflect.getOwnPropertyDescriptor(object, key);
+  if (!descriptor.enumerable)
+    return NOT_ENUMERABLE;
+  if (descriptor.get !== undefined || descriptor.set !== undefined) {
+    throw new UnsupportedStateError(`the accessor property '${String(key)}' sits in a payload that reaches back into the ` + `object it is written to, and a getter cannot be read as it will be after the write`);
+  }
+  return descriptor.value;
+}
+function refuseAccessors(event, removed, container, after) {
+  const pending = [event.newValue];
+  if (event.action !== "set-delete")
+    pending.push(event.value);
+  if (event.items !== undefined)
+    pending.push(event.items);
+  if (removed) {
+    pending.push(event.oldValue);
+    if (event.oldValues !== undefined)
+      pending.push(event.oldValues);
+  }
+  const seen = new Set;
+  while (pending.length > 0) {
+    const entry = pending.pop();
+    if (!isObject2(entry))
+      continue;
+    let value = toRaw(entry);
+    if (value === container)
+      value = after;
+    if (seen.has(value))
+      continue;
+    seen.add(value);
+    if (Array.isArray(value)) {
+      for (let i = 0;i < value.length; i++)
+        pending.push(value[i]);
+    } else if (value instanceof Map) {
+      for (const [key, item] of Map.prototype.entries.call(value))
+        pending.push(key, item);
+    } else if (value instanceof Set) {
+      for (const item of Set.prototype.values.call(value))
+        pending.push(item);
+    }
+    const keys = Reflect.ownKeys(value);
+    for (let i = 0;i < keys.length; i++) {
+      const item = enumerableData(value, keys[i]);
+      if (item !== NOT_ENUMERABLE)
+        pending.push(item);
+    }
+  }
+}
+function addPlace(node, parent, key) {
+  if (findPlace(node, parent, key) !== undefined)
+    return false;
+  pushPlace(node, new Place(parent, key));
+  return true;
+}
+function findPlace(node, parent, key) {
+  const places = node.places;
+  if (places.length <= WIDE) {
+    for (let i = 0;i < places.length; i++) {
+      if (samePlace(places[i], parent, key))
+        return places[i];
+    }
+    return;
+  }
+  let index = node.index;
+  if (index === undefined || index.places !== places || index.length !== places.length) {
+    index = node.index = { places, length: places.length, byParent: new Map };
+    for (let i = 0;i < places.length; i++)
+      indexPlace(index.byParent, places[i]);
+  }
+  const entry = index.byParent.get(parent.id);
+  if (entry === undefined)
+    return;
+  if (entry instanceof Place)
+    return parent.kind === 2 /* Set */ || entry.key === key ? entry : undefined;
+  return entry.get(key);
+}
+function indexPlace(byParent, place) {
+  const entry = byParent.get(place.parentId);
+  if (entry === undefined)
+    byParent.set(place.parentId, place);
+  else if (entry instanceof Place) {
+    if (entry.key !== place.key)
+      byParent.set(place.parentId, new Map([[entry.key, entry], [place.key, place]]));
+  } else if (!entry.has(place.key))
+    entry.set(place.key, place);
+}
+function pushPlace(node, place) {
+  const places = node.places;
+  places.push(place);
+  const index = node.index;
+  if (index !== undefined && index.places === places && index.length === places.length - 1) {
+    index.length++;
+    indexPlace(index.byParent, place);
+  }
+}
+function prunePlaces(node) {
+  const count = node.places.length;
+  if (count > WIDE && count < 2 * node.pruned)
+    return;
+  let places = keepPlaces(node.places, (place) => holds(place, node.raw));
+  if (places.length > 1) {
+    const live = pruneScratch;
+    live.length = places.length;
+    let attached = 0;
+    let parent;
+    let parentAttached = false;
+    for (let i = 0;i < places.length; i++) {
+      const next = places[i].parent;
+      if (next !== parent) {
+        parent = next;
+        parentAttached = isAttached(next);
+      }
+      live[i] = parentAttached;
+      if (parentAttached)
+        attached++;
+    }
+    if (attached > 0 && attached < places.length) {
+      const kept = [];
+      for (let i = 0;i < places.length; i++) {
+        if (live[i])
+          kept.push(places[i]);
+        else {
+          markLostLink(places[i].parent);
+          dropped(places[i]);
+        }
+      }
+      places = kept;
+    }
+  }
+  pruneScratch.length = 0;
+  node.places = places;
+  node.pruned = places.length;
+}
+var pruneScratch = [];
+function keepPlaces(places, keep) {
+  const kept = [];
+  for (let i = 0;i < places.length; i++) {
+    if (keep(places[i]))
+      kept.push(places[i]);
+    else
+      dropped(places[i]);
+  }
+  return kept;
+}
+function markLostLink(node) {
+  if (node.lostLink)
+    return;
+  node.lostLink = true;
+  const pending = [node];
+  while (pending.length > 0) {
+    const places = pending.pop().places;
+    for (let i = 0;i < places.length; i++) {
+      const parent = places[i].parent;
+      if (parent !== undefined && !parent.lostLink) {
+        parent.lostLink = true;
+        pending.push(parent);
+      }
+    }
+  }
+}
+function notePlace(node, parent, key) {
+  const places = node.places;
+  if (places.length === 1 && samePlace(places[0], parent, key))
+    return;
+  if (addPlace(node, parent, key) && node.places.length > 1)
+    prunePlaces(node);
+}
+function detachPlace(value, parent, key) {
+  const node = nodes.get(value);
+  if (node !== undefined)
+    removePlace(node, parent, key);
+}
+function removePlace(node, parent, key) {
+  const places = node.places;
+  if (places.length <= WIDE) {
+    for (let i = 0;i < places.length; i++) {
+      if (samePlace(places[i], parent, key)) {
+        dropped(places[i]);
+        places.splice(i, 1);
+        node.index = undefined;
+        return true;
+      }
+    }
+    return false;
+  }
+  const place = findPlace(node, parent, key);
+  if (place === undefined)
+    return false;
+  const at = places.indexOf(place);
+  if (at < 0) {
+    node.index = undefined;
+    return false;
+  }
+  dropped(place);
+  places.splice(at, 1);
+  const index = node.index;
+  index.length--;
+  const entry = index.byParent.get(place.parentId);
+  if (entry === place)
+    index.byParent.delete(place.parentId);
+  else if (entry instanceof Map && entry.get(place.key) === place)
+    entry.delete(place.key);
+  return true;
+}
+function newWalk(touched, store, former, held, first) {
+  return {
+    id: ++stamps,
+    store,
+    firstId: nodeCount + 1,
+    touched,
+    seen: new Set,
+    repeated: undefined,
+    aliases: first?.repeated,
+    created: undefined,
+    revisit: first?.created,
+    relinked: [],
+    former,
+    held
+  };
+}
+function adoptFrame(raw, node, unknown, key) {
+  let kind = 3 /* Object */;
+  let keys;
+  let entries;
+  if (Array.isArray(raw))
+    kind = 0 /* Array */;
+  else if (raw instanceof Map) {
+    kind = 1 /* Map */;
+    entries = Map.prototype.entries.call(raw);
+  } else if (raw instanceof Set) {
+    kind = 2 /* Set */;
+    entries = Set.prototype.values.call(raw);
+  } else if (raw instanceof Date || ArrayBuffer.isView(raw))
+    kind = 4 /* None */;
+  else
+    keys = Object.keys(raw);
+  return { raw, node, unknown, key, kind, next: 0, keys, entries, childKey: undefined, swaps: undefined };
+}
+function nextChild(frame) {
+  const raw = frame.raw;
+  switch (frame.kind) {
+    case 0 /* Array */:
+      while (frame.next < raw.length) {
+        const index = frame.next++;
+        const child = raw[index];
+        if (isObject2(child)) {
+          frame.childKey = index;
+          return child;
+        }
+      }
+      return;
+    case 1 /* Map */:
+      for (;; ) {
+        const step = frame.entries.next();
+        if (step.done)
+          return;
+        const child = step.value[1];
+        if (isObject2(child)) {
+          frame.childKey = step.value[0];
+          return child;
+        }
+      }
+    case 2 /* Set */:
+      for (;; ) {
+        const step = frame.entries.next();
+        if (step.done)
+          return;
+        if (isObject2(step.value)) {
+          frame.childKey = undefined;
+          return step.value;
+        }
+      }
+    case 3 /* Object */: {
+      const keys = frame.keys;
+      while (frame.next < keys.length) {
+        const key = keys[frame.next++];
+        const child = raw[key];
+        if (isObject2(child)) {
+          frame.childKey = key;
+          return child;
+        }
+      }
       return;
     }
-    targetSet.delete(event.value);
-  },
-  "set-clear": function(targetSet, _keyIgnored, event) {
-    if (!(targetSet instanceof Set)) {
-      console.warn(`expected set at path ${event.path.join(".")}`);
+    default:
+      return;
+  }
+}
+function enterAdopt(raw, key, walk, frames) {
+  let node = nodes.get(raw);
+  if (node !== undefined) {
+    if (node.walk === walk.id)
+      return node;
+    node.walk = walk.id;
+    if (!node.lostLink && walk.revisit?.has(raw) !== true) {
+      if (attachedBefore(node, walk.former))
+        return node;
+      if (walk.aliases === undefined)
+        (walk.created ??= new Set).add(raw);
+    }
+    if (node.lostLink)
+      walk.relinked.push(node);
+    frames.push(adoptFrame(raw, node, false, key));
+    return node;
+  }
+  if (raw["__v_skip" /* SKIP */])
+    return;
+  if (raw["__v_isReactive" /* IS_REACTIVE */]) {
+    const target = toRaw(raw);
+    if (frames.length > 0)
+      storeRaw(frames[frames.length - 1], key, raw, target);
+    return enterAdopt(target, key, walk, frames);
+  }
+  const seen = walk.seen;
+  const size = seen.size;
+  seen.add(raw);
+  if (seen.size === size) {
+    (walk.repeated ??= new Set).add(raw);
+    return;
+  }
+  if (walk.aliases?.has(raw))
+    node = walkNode(raw, walk);
+  if (walk.held?.has(raw))
+    return node;
+  frames.push(adoptFrame(raw, node, true, key));
+  return node;
+}
+function walkNode(raw, walk) {
+  const node = ensureLocationNode(raw);
+  node.walk = walk.id;
+  return node;
+}
+function storeRaw(frame, key, proxy, target) {
+  const container = frame.raw;
+  switch (frame.kind) {
+    case 1 /* Map */:
+      Map.prototype.set.call(container, key, target);
       return;
+    case 2 /* Set */:
+      (frame.swaps ??= new Map).set(proxy, target);
+      return;
+    default: {
+      const descriptor = Reflect.getOwnPropertyDescriptor(container, key);
+      if (descriptor !== undefined && descriptor.value === proxy)
+        Reflect.set(container, key, target);
     }
-    targetSet.clear();
-  },
-  replace: function(target, _keyIgnored, event) {
-    const newValue = event.newValue;
-    if (newValue === undefined || newValue === null) {
-      console.warn("replace action requires newValue");
+  }
+}
+function swapMembers(set, swaps) {
+  const members = Array.from(Set.prototype.values.call(set));
+  Set.prototype.clear.call(set);
+  for (let i = 0;i < members.length; i++) {
+    const member = members[i];
+    Set.prototype.add.call(set, isObject2(member) && swaps.get(member) || member);
+  }
+}
+function placeChild(frame, key, childNode, walk) {
+  if (childNode === undefined)
+    return;
+  const parent = frame.node ??= walkNode(frame.raw, walk);
+  if (parent.id < walk.firstId && childNode.id < walk.firstId) {
+    if (walk.aliases !== undefined && !walk.aliases.has(childNode.raw))
+      return;
+    if (!addPlace(childNode, parent, key))
       return;
+  } else {
+    pushPlace(childNode, new Place(parent, key));
+  }
+  touch(childNode, walk.store, walk.touched);
+}
+function touch(node, store, touched) {
+  if (node.touched === store)
+    return;
+  node.touched = store;
+  touched.push(node);
+}
+var stamps = 0;
+function walkFrames(frames, walk) {
+  for (;; ) {
+    const frame = frames[frames.length - 1];
+    const child = nextChild(frame);
+    if (child !== undefined) {
+      const depth = frames.length;
+      const childNode = enterAdopt(child, frame.childKey, walk, frames);
+      if (frames.length === depth)
+        placeChild(frame, frame.childKey, childNode, walk);
+      continue;
+    }
+    frames.pop();
+    if (frame.swaps !== undefined)
+      swapMembers(frame.raw, frame.swaps);
+    const node = frame.node;
+    if (frame.unknown && node !== undefined && walk.aliases === undefined)
+      (walk.created ??= new Set).add(frame.raw);
+    if (frames.length === 0)
+      return node;
+    placeChild(frames[frames.length - 1], frame.key, node, walk);
+  }
+}
+function adopt(raw, walk) {
+  const frames = [];
+  const node = enterAdopt(raw, undefined, walk, frames);
+  return frames.length === 0 ? node : walkFrames(frames, walk);
+}
+function adoptAll(touched, store, former, held, visit) {
+  let walk = newWalk(touched, store, former, held);
+  visit(walk);
+  if (walk.repeated !== undefined) {
+    const first = walk;
+    walk = newWalk(touched, store, former, held, first);
+    visit(walk);
+    for (let i = 0;i < first.relinked.length; i++)
+      first.relinked[i].lostLink = false;
+  }
+  for (let i = 0;i < walk.relinked.length; i++)
+    walk.relinked[i].lostLink = false;
+}
+function pruneTouched(touched) {
+  for (let i = 0;i < touched.length; i++) {
+    if (touched[i].places.length > 1)
+      prunePlaces(touched[i]);
+  }
+}
+function hasObjectChild(raw) {
+  if (Array.isArray(raw)) {
+    for (let i = 0;i < raw.length; i++)
+      if (isObject2(raw[i]))
+        return true;
+    return false;
+  }
+  if (Object.getPrototypeOf(raw) !== Object.prototype) {
+    if (raw instanceof Map || raw instanceof Set) {
+      const entries = raw instanceof Map ? Map.prototype.values.call(raw) : Set.prototype.values.call(raw);
+      for (const child of entries)
+        if (isObject2(child))
+          return true;
+      return false;
     }
-    if (Array.isArray(target) && Array.isArray(newValue)) {
-      target.splice(0, target.length, ...newValue);
-    } else if (target instanceof Map && newValue instanceof Map) {
-      const newValueEntries = [...newValue.entries()];
-      target.clear();
-      for (const [key, value] of newValueEntries) {
-        target.set(key, value);
-      }
-    } else if (target instanceof Set && newValue instanceof Set) {
-      const newValueEntries = [...newValue.values()];
-      target.clear();
-      for (const value of newValueEntries) {
-        target.add(value);
-      }
-    } else if (typeof target === "object" && target !== null && typeof newValue === "object" && newValue !== null) {
-      Object.keys(target).forEach((key) => delete target[key]);
-      Object.assign(target, newValue);
-    } else {
-      console.warn(`Type mismatch or unsupported type for 'replace' action at path ${event.path.join(".")}. Target type: ${typeof target} ${target.constructor.name}, New value type: ${typeof newValue} ${newValue.constructor.name}`);
+    if (raw instanceof Date || ArrayBuffer.isView(raw))
+      return false;
+  }
+  for (const key in raw) {
+    if (Object.prototype.hasOwnProperty.call(raw, key) && isObject2(raw[key]))
+      return true;
+  }
+  return false;
+}
+function insertedNeedWalk(inserted) {
+  let fresh;
+  for (let i = 0;i < inserted.length; i++) {
+    const value = inserted[i];
+    if (!isObject2(value))
+      continue;
+    const node = nodes.get(value);
+    if (node !== undefined) {
+      if (node.lostLink || !attachedBefore(node, undefined))
+        return true;
+      continue;
+    }
+    if (hasObjectChild(value))
+      return true;
+    if (inserted.length > 1) {
+      if (fresh === undefined)
+        fresh = new Set;
+      else if (fresh.has(value))
+        return true;
+      fresh.add(value);
     }
   }
-};
-function updateState(root, event) {
-  const { action, path } = event;
-  if (!path || path.length === 0 && action !== "replace") {
-    console.warn("event path is invalid for action", event);
+  return false;
+}
+function heldBefore(value, replaced) {
+  if (!Array.isArray(value) || !Array.isArray(replaced))
     return;
+  let before;
+  for (let i = 0;i < value.length; i++) {
+    const item = value[i];
+    if (!isObject2(item) || nodes.get(item) !== undefined)
+      continue;
+    if (before === undefined) {
+      if (replaced.indexOf(item) === -1)
+        return;
+      before = new Set;
+      for (let j = 0;j < replaced.length; j++)
+        if (isObject2(replaced[j]))
+          before.add(replaced[j]);
+    }
+    if (!before.has(item))
+      return;
   }
-  const handler = actionHandlers[action];
-  if (!handler) {
-    console.error(`unhandled action type: ${action}`, event);
+  return before;
+}
+function heldItems(value, replaced) {
+  if (!isObject2(value) || !isObject2(replaced) || nodes.get(replaced) === undefined)
+    return;
+  return heldBefore(value, replaced);
+}
+function attachValue(value, parent, key, fresh, replaced, held) {
+  if (fresh)
+    return;
+  const former = isObject2(replaced) ? nodes.get(replaced) : undefined;
+  const existing = nodes.get(value);
+  if (existing !== undefined && !existing.lostLink && attachedBefore(existing, former)) {
+    if (addPlace(existing, parent, key) && existing.places.length > 1)
+      prunePlaces(existing);
     return;
   }
-  let targetForHandler;
-  let keyForHandler = null;
-  if (action === "set" || action === "delete") {
-    if (path.length === 1) {
-      targetForHandler = root;
-      keyForHandler = path[0];
-    } else {
-      const parentPath = path.slice(0, -1);
-      const parentPathKey = parentPath.join(".");
-      let parent = pathCache.get(root)?.get(parentPathKey);
-      if (parent !== undefined) {
-        parent = validateCachedPath(root, parentPath, parentPathKey, parent);
-      }
-      if (parent === undefined) {
-        parent = parentPath.reduce((acc, key) => acc ? getValue(acc, key) : undefined, root);
-        if (parent !== undefined)
-          setInPathCache(root, parentPathKey, parent);
+  if (existing === undefined && !hasObjectChild(value))
+    return;
+  const touched = [];
+  const store = ++stamps;
+  adoptAll(touched, store, former, held, (walk) => {
+    const node = adopt(value, walk);
+    if (node !== undefined && addPlace(node, parent, key))
+      touch(node, store, touched);
+  });
+  pruneTouched(touched);
+}
+function adoptRoot(node) {
+  const touched = [];
+  adoptAll(touched, ++stamps, undefined, undefined, (walk) => {
+    node.walk = walk.id;
+    walkFrames([adoptFrame(node.raw, node, false, undefined)], walk);
+  });
+  pruneTouched(touched);
+}
+function relinkArray(arrayNode, array, from, removed, inserted, insertedFresh = false) {
+  if (insertedFresh)
+    inserted = undefined;
+  relink(arrayNode, array, from, removed, inserted, false);
+}
+function relinkReorder(arrayNode, array, removed, inserted) {
+  relink(arrayNode, array, 0, removed, inserted, true);
+}
+function relink(arrayNode, array, from, removed, inserted, findAliases) {
+  const touched = [];
+  const store = ++stamps;
+  if (inserted !== undefined && insertedNeedWalk(inserted)) {
+    adoptAll(touched, store, undefined, undefined, (walk) => {
+      for (let i = 0;i < inserted.length; i++) {
+        const value = inserted[i];
+        if (isObject2(value))
+          adopt(value, walk);
       }
-      if (parent === undefined) {
-        console.warn(`parent path ${parentPathKey} not found for action ${action}`);
-        return;
+    });
+  }
+  let removedNode = false;
+  if (removed !== undefined) {
+    for (let i = 0;i < removed.length; i++) {
+      const value = removed[i];
+      if (isObject2(value)) {
+        const node = nodes.get(value);
+        if (node !== undefined) {
+          stripIndexes(node, arrayNode, from);
+          removedNode = true;
+        }
       }
-      targetForHandler = parent;
-      keyForHandler = path[path.length - 1];
     }
-  } else if (action.startsWith("array-") || action.startsWith("map-") || action.startsWith("set-") || action === "replace") {
-    if (path.length === 0 && action === "replace") {
-      targetForHandler = root;
-    } else {
-      const targetPath = path;
-      const targetPathKey = targetPath.join(".");
-      let targetCollection = pathCache.get(root)?.get(targetPathKey);
-      if (targetCollection !== undefined) {
-        targetCollection = validateCachedPath(root, targetPath, targetPathKey, targetCollection);
-      }
-      if (targetCollection === undefined) {
-        targetCollection = targetPath.reduce((acc, key) => acc ? getValue(acc, key) : undefined, root);
-        if (targetCollection !== undefined)
-          setInPathCache(root, targetPathKey, targetCollection);
+  }
+  const call = ++relinkCalls;
+  let firstIndex;
+  let left = findAliases || removedNode || holdsNode(inserted) ? Infinity : arrayNode.childPlaces;
+  for (let i = from;i < array.length && left > 0; i++) {
+    const value = array[i];
+    if (!isObject2(value))
+      continue;
+    let node = nodes.get(value);
+    if (node === undefined) {
+      if (!findAliases)
+        continue;
+      const first = (firstIndex ??= new Map).get(value);
+      if (first === undefined) {
+        firstIndex.set(value, i);
+        continue;
       }
-      if (targetCollection === undefined) {
-        console.warn(`target at path ${targetPathKey} not found for action ${action}`);
-        return;
+      if (value["__v_skip" /* SKIP */])
+        continue;
+      node = ensureLocationNode(value);
+      node.relinked = call;
+      node.relinkedPlaces = 0;
+      node.places.push(new Place(arrayNode, first));
+    } else if (node.relinked !== call) {
+      node.relinked = call;
+      const places = node.places;
+      if (places.length === 1 && places[0].parentId === arrayNode.id && typeof places[0].key === "number" && places[0].key >= from) {
+        places[0].key = i;
+        node.relinkedPlaces = 0;
+        left--;
+        continue;
       }
-      targetForHandler = targetCollection;
+      node.relinkedPlaces = stripIndexes(node, arrayNode, from);
     }
-  } else {
-    console.error(`unexpected action type passed checks: ${action}`);
-    return;
+    if (node.relinkedPlaces > 0) {
+      node.relinkedPlaces--;
+      left--;
+    }
+    node.places.push(new Place(arrayNode, i));
+    if (node.places.length > 1)
+      touch(node, store, touched);
   }
-  handler(targetForHandler, keyForHandler, event);
-  if (action === "set" && event.newValue != null && typeof event.newValue === "object") {
-    const fullPathKey = path.join(".");
-    evictDescendantsFromPathCache(root, fullPathKey);
+  pruneTouched(touched);
+}
+var relinkCalls = 0;
+function holdsNode(values) {
+  if (values === undefined)
+    return false;
+  for (let i = 0;i < values.length; i++) {
+    const value = values[i];
+    if (isObject2(value) && nodes.get(value) !== undefined)
+      return true;
+  }
+  return false;
+}
+function stripIndexes(node, arrayNode, from) {
+  const places = node.places;
+  let count = 0;
+  for (let i = places.length - 1;i >= 0; i--) {
+    const place = places[i];
+    if (place.parentId === arrayNode.id && typeof place.key === "number" && place.key >= from) {
+      arrayNode.childPlaces--;
+      places.splice(i, 1);
+      count++;
+    }
+  }
+  if (count > 0)
+    node.index = undefined;
+  return count;
+}
+function evictDeep(value, parent) {
+  if (value == null || typeof value !== "object")
+    return;
+  const top = toRaw(value);
+  if (globalSeen.get(top) === undefined)
+    return;
+  const pending = [parent, undefined, top];
+  while (pending.length > 0) {
+    const raw = pending.pop();
+    const key = pending.pop();
+    const container = pending.pop();
+    const proxy = globalSeen.get(raw);
+    if (proxy === undefined)
+      continue;
+    const node = nodes.get(raw);
+    if (node !== undefined) {
+      const places = node.places;
+      const onlyUnderParent = container !== undefined && node.root === undefined && places.length === 1 && places[0].parentId === container.id;
+      if (!onlyUnderParent) {
+        if (container !== undefined && places.length > 1 && removePlace(node, container, key))
+          markLostLink(container);
+        if (isAttached(node))
+          continue;
+      }
+      node.proxy = undefined;
+      node.evicted = new WeakRef(proxy);
+    }
+    globalSeen.delete(raw);
+    wrapperCache.delete(raw);
+    proxyStats.staleEvicted++;
+    if (Array.isArray(raw)) {
+      for (let i = 0;i < raw.length; i++)
+        pushProxied(raw[i], node, i, pending);
+    } else if (raw instanceof Map) {
+      Map.prototype.forEach.call(raw, (child, key2) => pushProxied(child, node, key2, pending));
+    } else if (raw instanceof Set) {
+      for (const child of Set.prototype.values.call(raw))
+        pushProxied(child, node, undefined, pending);
+    } else {
+      const keys = Object.keys(raw);
+      for (let i = 0;i < keys.length; i++)
+        pushProxied(raw[keys[i]], node, keys[i], pending);
+    }
   }
 }
+function pushProxied(value, container, key, pending) {
+  if (value === null || typeof value !== "object")
+    return;
+  const raw = toRaw(value);
+  if (globalSeen.get(raw) !== undefined)
+    pending.push(container, key, raw);
+}
+function restoreEvicted(node) {
+  const proxy = node.evicted?.deref();
+  node.evicted = undefined;
+  if (proxy === undefined)
+    return;
+  node.proxy = proxy;
+  globalSeen.set(node.raw, proxy);
+  wrapperCache.set(node.raw, proxy);
+  proxyStats.staleEvicted--;
+  return proxy;
+}
+
 // src/watch-effect.ts
 var activeEffect = null;
 var queuedEffects = new Map;
@@ -2969,70 +4731,583 @@ function trigger(target, key) {
               queuedEffects.set(effect, triggerLevel);
             }
           }
-        });
-      }
-    };
-    addEffects(key);
-    if (queuedEffects.size > 0) {
-      flushEffects();
-    }
-  } finally {
-    currentTriggerDepth--;
-  }
-}
-function watchEffect(effectCallback, options = {}) {
-  const run = () => {
-    if (!effectFn.active) {
-      throw new Error("Trying to run a stopped effect");
-    }
-    const previousEffect = activeEffect;
-    try {
-      runCleanupFunctions(effectFn);
-      cleanupEffect(effectFn);
-      setActiveEffect(effectFn);
-      const onCleanup = (cleanupFn) => {
-        if (!effectFn.cleanupFns) {
-          effectFn.cleanupFns = [];
+        });
+      }
+    };
+    addEffects(key);
+    if (queuedEffects.size > 0) {
+      flushEffects();
+    }
+  } finally {
+    currentTriggerDepth--;
+  }
+}
+function watchEffect(effectCallback, options = {}) {
+  const run = () => {
+    if (!effectFn.active) {
+      throw new Error("Trying to run a stopped effect");
+    }
+    const previousEffect = activeEffect;
+    try {
+      runCleanupFunctions(effectFn);
+      cleanupEffect(effectFn);
+      setActiveEffect(effectFn);
+      const onCleanup = (cleanupFn) => {
+        if (!effectFn.cleanupFns) {
+          effectFn.cleanupFns = [];
+        }
+        effectFn.cleanupFns.push(cleanupFn);
+      };
+      return effectCallback(onCleanup);
+    } finally {
+      setActiveEffect(previousEffect);
+    }
+  };
+  const effectFn = {
+    run,
+    dependencies: new Set,
+    options,
+    active: true,
+    _rawCallback: effectCallback,
+    cleanupFns: []
+  };
+  if (!options.lazy) {
+    effectFn.run();
+  }
+  const stopHandle = () => {
+    if (effectFn.active) {
+      runCleanupFunctions(effectFn);
+      cleanupEffect(effectFn);
+      effectFn.active = false;
+      queuedEffects.delete(effectFn);
+    }
+  };
+  stopHandle.effect = effectFn;
+  return stopHandle;
+}
+
+// src/wrap-array.ts
+function isObject3(v) {
+  return v && typeof v === "object";
+}
+function arrayIndex(prop) {
+  if (typeof prop !== "string" || prop.length === 0 || prop.length > 10)
+    return -1;
+  const first = prop.charCodeAt(0);
+  if (first < 48 || first > 57 || first === 48 && prop.length > 1)
+    return -1;
+  for (let i = 1;i < prop.length; i++) {
+    const code = prop.charCodeAt(i);
+    if (code < 48 || code > 57)
+      return -1;
+  }
+  const index = Number(prop);
+  return index < 4294967295 ? index : -1;
+}
+function placeKey(prop) {
+  const index = arrayIndex(prop);
+  return index >= 0 ? index : prop;
+}
+function toIntegerOrInfinity(value) {
+  const number = +value;
+  if (number !== number || number === 0)
+    return 0;
+  return Math.trunc(number);
+}
+function clampIndex(relative, length) {
+  return relative < 0 ? Math.max(length + relative, 0) : Math.min(relative, length);
+}
+function unwrapItems(items) {
+  for (let i = 0;i < items.length; i++) {
+    if (isObject3(items[i]))
+      items[i] = unwrapForStore(items[i]);
+  }
+}
+function planReorder(target, prop, method, args) {
+  const length = target.length;
+  if (prop === "fill" || prop === "copyWithin") {
+    const fill2 = prop === "fill";
+    const to = fill2 ? 0 : clampIndex(toIntegerOrInfinity(args[0]), length);
+    const start = clampIndex(toIntegerOrInfinity(args[1]), length);
+    const end = args[2] === undefined ? length : clampIndex(toIntegerOrInfinity(args[2]), length);
+    const after2 = target.slice();
+    method.call(after2, fill2 ? args[0] : to, start, end);
+    const size = after2.length;
+    if (fill2)
+      return { after: after2, first: Math.min(start, size), last: Math.min(end, size), skip: -1 };
+    const from = Math.min(to, size);
+    const count = Math.min(Math.min(end, size) - Math.min(start, size), size - from);
+    return { after: after2, first: from, last: from + Math.max(count, 0), skip: -1 };
+  }
+  const after = target.slice();
+  method.apply(after, args);
+  if (prop === "reverse") {
+    return { after, first: 0, last: length, skip: length % 2 === 1 ? (length - 1) / 2 : -1 };
+  }
+  const sorted = length < 2 ? 0 : length;
+  for (let i = length;i < target.length; i++) {
+    if (i in target)
+      after[i] = target[i];
+    else
+      after.length = i + 1;
+  }
+  return { after, first: 0, last: sorted, skip: -1 };
+}
+var strictWrites = function() {
+  return this === undefined;
+}();
+function checkReorder(target, reorder) {
+  const { after, first, last, skip } = reorder;
+  let extensible;
+  for (let i = first;i < last; i++) {
+    if (i === skip)
+      continue;
+    if (i in after) {
+      if (i in target) {
+        if (strictWrites)
+          target[i] = target[i];
+        else if (!Reflect.set(target, i, target[i]))
+          throw new TypeError(`Cannot assign to read only property '${i}' of array`);
+      } else if (!(extensible ??= Object.isExtensible(target))) {
+        throw new TypeError(`Cannot add property ${i}, array is not extensible`);
+      }
+    } else if (i in target && !Reflect.getOwnPropertyDescriptor(target, i).configurable) {
+      throw new TypeError(`Cannot delete property '${i}' of array`);
+    }
+  }
+}
+function reorderChanges(target, after) {
+  if (after.length !== target.length)
+    return true;
+  for (let i = 0;i < after.length; i++) {
+    const value = after[i];
+    const current = target[i];
+    if (value !== current) {
+      if (value === value || current === current)
+        return true;
+    } else if (value === 0) {
+      if (1 / value !== 1 / current)
+        return true;
+    } else if (value === undefined && i in after !== i in target) {
+      return true;
+    }
+  }
+  return false;
+}
+function writeReorder(target, reorder) {
+  const { after, first, last, skip } = reorder;
+  for (let i = first;i < last; i++) {
+    if (i === skip)
+      continue;
+    if (i in after)
+      target[i] = after[i];
+    else
+      delete target[i];
+  }
+}
+function evictRemoved(removed) {
+  for (let i = 0;i < removed.length; i++) {
+    if (isObject3(removed[i]))
+      evictDeep(removed[i]);
+  }
+}
+function wrapArray(arr, node) {
+  const cachedProxy = wrapperCache.get(arr);
+  if (cachedProxy)
+    return cachedProxy;
+  if (globalSeen.has(arr))
+    return globalSeen.get(arr);
+  const methodCache = {};
+  const proxy = new Proxy(arr, {
+    get(target, prop, receiver) {
+      if (prop === "__v_raw" /* RAW */)
+        return target;
+      if (prop === "__v_isReactive" /* IS_REACTIVE */)
+        return true;
+      track(target, prop);
+      if (methodCache[prop]) {
+        return methodCache[prop];
+      }
+      switch (prop) {
+        case "sort":
+        case "reverse":
+        case "fill":
+        case "copyWithin": {
+          track(target, "length");
+          const method = Array.prototype[prop];
+          methodCache[prop] = function(...args) {
+            if (prop === "fill" && isObject3(args[0]))
+              args[0] = unwrapForStore(args[0]);
+            const reorder = planReorder(target, prop, method, args);
+            const before = target.slice();
+            checkReorder(target, reorder);
+            const after = reorder.after;
+            if (!reorderChanges(target, after))
+              return proxy;
+            const located = locate(node);
+            const event = located && {
+              action: "replace",
+              path: located.paths[0],
+              oldValue: before,
+              newValue: target
+            };
+            if (event !== undefined)
+              copyPayloadAfter(event, located, target, after);
+            writeReorder(target, reorder);
+            relinkReorder(node, target, before, prop === "fill" ? [args[0]] : undefined);
+            if (event !== undefined)
+              dispatch(located, event);
+            trigger(target, Symbol.iterator);
+            evictRemoved(before);
+            return proxy;
+          };
+          return methodCache[prop];
+        }
+        case "push":
+          track(target, "length");
+          methodCache[prop] = function(...items) {
+            unwrapItems(items);
+            const oldLength = target.length;
+            const located = items.length > 0 ? locate(node) : undefined;
+            const event = located && {
+              action: "array-push",
+              path: located.paths[0],
+              key: oldLength,
+              items
+            };
+            const copied = copyPayload(event, located, target);
+            if (copied === 0 /* Reaches */) {
+              const after = target.slice();
+              after.push(...items);
+              copyPayloadReaching(event, located, target, after);
+            }
+            const result = target.push(...items);
+            const newLength = target.length;
+            if (items.length > 0) {
+              relinkArray(node, target, oldLength, undefined, items, copied === 2 /* Fresh */);
+              if (event !== undefined)
+                dispatch(located, event);
+              trigger(target, Symbol.iterator);
+              if (oldLength !== newLength) {
+                trigger(target, "length");
+              }
+            }
+            return result;
+          };
+          return methodCache[prop];
+        case "pop":
+          track(target, "length");
+          methodCache[prop] = function() {
+            if (target.length === 0)
+              return;
+            const oldLength = target.length;
+            const poppedIndex = oldLength - 1;
+            const oldValue = target[poppedIndex];
+            const located = locate(node);
+            const event = located && {
+              action: "array-pop",
+              path: located.paths[0],
+              key: poppedIndex,
+              oldValue
+            };
+            if (copyPayload(event, located, target) === 0 /* Reaches */) {
+              const after = target.slice();
+              after.pop();
+              copyPayloadReaching(event, located, target, after);
+            }
+            const result = target.pop();
+            const newLength = target.length;
+            if (isObject3(oldValue))
+              detachPlace(oldValue, node, poppedIndex);
+            if (event !== undefined)
+              dispatch(located, event);
+            if (isObject3(oldValue))
+              evictDeep(oldValue);
+            trigger(target, Symbol.iterator);
+            if (oldLength !== newLength) {
+              trigger(target, "length");
+            }
+            return result;
+          };
+          return methodCache[prop];
+        case "shift":
+          track(target, "length");
+          methodCache[prop] = function() {
+            if (target.length === 0)
+              return;
+            const oldLength = target.length;
+            const oldValue = target[0];
+            const located = locate(node);
+            const event = located && {
+              action: "array-shift",
+              path: located.paths[0],
+              key: 0,
+              oldValue
+            };
+            if (copyPayload(event, located, target) === 0 /* Reaches */) {
+              const after = target.slice();
+              after.shift();
+              copyPayloadReaching(event, located, target, after);
+            }
+            const result = target.shift();
+            const newLength = target.length;
+            relinkArray(node, target, 0, [oldValue]);
+            if (event !== undefined)
+              dispatch(located, event);
+            if (isObject3(oldValue))
+              evictDeep(oldValue);
+            trigger(target, Symbol.iterator);
+            if (oldLength !== newLength) {
+              trigger(target, "length");
+            }
+            return result;
+          };
+          return methodCache[prop];
+        case "unshift":
+          track(target, "length");
+          methodCache[prop] = function(...items) {
+            unwrapItems(items);
+            const oldLength = target.length;
+            const located = items.length > 0 ? locate(node) : undefined;
+            const event = located && {
+              action: "array-unshift",
+              path: located.paths[0],
+              key: 0,
+              items
+            };
+            const copied = copyPayload(event, located, target);
+            if (copied === 0 /* Reaches */) {
+              const after = target.slice();
+              after.unshift(...items);
+              copyPayloadReaching(event, located, target, after);
+            }
+            const result = target.unshift(...items);
+            const newLength = target.length;
+            if (items.length > 0) {
+              relinkArray(node, target, 0, undefined, items, copied === 2 /* Fresh */);
+              if (event !== undefined)
+                dispatch(located, event);
+              trigger(target, Symbol.iterator);
+              if (oldLength !== newLength) {
+                trigger(target, "length");
+              }
+            }
+            return result;
+          };
+          return methodCache[prop];
+        case "splice":
+          track(target, "length");
+          methodCache[prop] = function(...args) {
+            const oldLength = target.length;
+            const actualStart = args.length === 0 ? 0 : clampIndex(toIntegerOrInfinity(args[0]), oldLength);
+            const actualDeleteCount = args.length === 0 ? 0 : args.length === 1 ? oldLength - actualStart : Math.min(Math.max(toIntegerOrInfinity(args[1]), 0), oldLength - actualStart);
+            const items = args.length > 2 ? args.slice(2) : [];
+            unwrapItems(items);
+            const changes = actualDeleteCount > 0 || items.length > 0;
+            const located = changes ? locate(node) : undefined;
+            const event = located && {
+              action: "array-splice",
+              path: located.paths[0],
+              key: actualStart,
+              deleteCount: actualDeleteCount,
+              items: items.length > 0 ? items : undefined,
+              oldValues: actualDeleteCount > 0 ? target.slice(actualStart, actualStart + actualDeleteCount) : undefined
+            };
+            const copied = copyPayload(event, located, target);
+            if (copied === 0 /* Reaches */) {
+              const after = target.slice();
+              after.splice(actualStart, actualDeleteCount, ...items);
+              copyPayloadReaching(event, located, target, after);
+            }
+            const deletedItems = target.splice(actualStart, actualDeleteCount, ...items);
+            const newLength = target.length;
+            if (changes) {
+              relinkArray(node, target, actualStart, deletedItems, items, copied === 2 /* Fresh */);
+              if (event !== undefined)
+                dispatch(located, event);
+              evictRemoved(deletedItems);
+              trigger(target, Symbol.iterator);
+              if (oldLength !== newLength) {
+                trigger(target, "length");
+              }
+            }
+            return deletedItems;
+          };
+          return methodCache[prop];
+        case "find": {
+          track(target, Symbol.iterator);
+          if (!methodCache[prop]) {
+            methodCache[prop] = function(predicate, thisArg) {
+              const idx = Array.prototype.findIndex.call(target, predicate, thisArg);
+              if (idx === -1)
+                return;
+              const value2 = target[idx];
+              if (!isObject3(value2))
+                return value2;
+              return wrapChild(value2, node, idx);
+            };
+          }
+          return methodCache[prop];
+        }
+        case "at": {
+          track(target, Symbol.iterator);
+          if (!methodCache[prop]) {
+            methodCache[prop] = function(index2) {
+              let idx = Number(index2);
+              if (!Number.isInteger(idx))
+                idx = Math.trunc(idx);
+              if (idx < 0)
+                idx = target.length + idx;
+              if (idx < 0 || idx >= target.length)
+                return;
+              const value2 = target[idx];
+              if (!isObject3(value2))
+                return value2;
+              return wrapChild(value2, node, idx);
+            };
+          }
+          return methodCache[prop];
+        }
+        case Symbol.iterator:
+        case "values":
+        case "keys":
+        case "entries":
+        case "forEach":
+        case "map":
+        case "filter":
+        case "reduce":
+        case "reduceRight":
+        case "findIndex":
+        case "every":
+        case "some":
+        case "join":
+          track(target, Symbol.iterator);
+          break;
+        case "length":
+          track(target, "length");
+          return Reflect.get(target, prop, receiver);
+      }
+      const value = Reflect.get(target, prop, receiver);
+      const index = arrayIndex(prop);
+      if (index >= 0) {
+        track(target, prop);
+        if (!isObject3(value))
+          return value;
+        return wrapChild(value, node, index);
+      }
+      const isNumericIndex = typeof prop === "string" && !isNaN(parseInt(prop, 10));
+      if (isNumericIndex) {
+        track(target, prop);
+        if (!isObject3(value))
+          return value;
+        return wrapChild(value, node, placeKey(prop));
+      }
+      if (typeof value === "function") {
+        return value.bind(target);
+      }
+      return value;
+    },
+    set(target, prop, value, receiver) {
+      if (isObject3(value))
+        value = unwrapForStore(value);
+      const oldValue = target[prop];
+      if (oldValue === value && Reflect.has(target, prop))
+        return true;
+      if (isObject3(oldValue) && isObject3(value) && deepEqual(oldValue, value))
+        return true;
+      const truncated = prop === "length" && Number(value) < target.length ? target.slice(Number(value)) : undefined;
+      const isNumericIndex = typeof prop === "number" || arrayIndex(prop) >= 0 || typeof prop === "string" && !isNaN(parseInt(prop));
+      const emits = isNumericIndex || prop === "length" || !writesThroughSetter(target, prop, node);
+      const grows = prop === "length" && Number(value) > Number(oldValue);
+      const located = emits ? grows ? locate(node) : locate(node, prop) : undefined;
+      const event = located === undefined || grows ? undefined : { action: "set", path: located.paths[0], oldValue, newValue: value };
+      const held = event !== undefined ? heldItems(value, oldValue) : undefined;
+      const copied = copyPayload(event, located, target, held);
+      if (copied === 0 /* Reaches */) {
+        const after = target.slice();
+        Reflect.set(after, prop, value);
+        copyPayloadReaching(event, located, target, after);
+      }
+      const result = Reflect.set(target, prop, value, receiver);
+      if (result && emits) {
+        if (truncated !== undefined) {
+          relinkArray(node, target, target.length, truncated);
+        } else if (prop !== "length") {
+          const key = placeKey(prop);
+          if (isObject3(oldValue))
+            detachPlace(oldValue, node, key);
+          if (isObject3(value))
+            attachValue(value, node, key, copied === 2 /* Fresh */, located && oldValue, held);
+        }
+        if (grows) {
+          if (located !== undefined) {
+            const oldLength = Number(oldValue);
+            const newLength = Number(value);
+            const events = [];
+            for (let i = oldLength;i < newLength; i++) {
+              const index = String(i);
+              for (let j = 0;j < located.paths.length; j++) {
+                events.push({ action: "set", path: [...located.paths[j], index], newValue: undefined });
+              }
+            }
+            if (events.length > 0)
+              deliver(located.root, events);
+          }
+        } else if (event !== undefined) {
+          dispatch(located, event);
         }
-        effectFn.cleanupFns.push(cleanupFn);
-      };
-      return effectCallback(onCleanup);
-    } finally {
-      setActiveEffect(previousEffect);
-    }
-  };
-  const effectFn = {
-    run,
-    dependencies: new Set,
-    options,
-    active: true,
-    _rawCallback: effectCallback,
-    cleanupFns: []
-  };
-  if (!options.lazy) {
-    effectFn.run();
-  }
-  const stopHandle = () => {
-    if (effectFn.active) {
-      runCleanupFunctions(effectFn);
-      cleanupEffect(effectFn);
-      effectFn.active = false;
-      queuedEffects.delete(effectFn);
+        if (isObject3(oldValue) && oldValue !== value) {
+          evictDeep(oldValue);
+        }
+        if (truncated !== undefined)
+          evictRemoved(truncated);
+        trigger(target, prop);
+      }
+      return result;
+    },
+    deleteProperty(target, prop) {
+      const oldValue = target[prop];
+      const hadProperty = Object.prototype.hasOwnProperty.call(target, prop);
+      const located = hadProperty ? locate(node, prop) : undefined;
+      const event = located && { action: "delete", path: located.paths[0], oldValue };
+      if (copyPayload(event, located, target) === 0 /* Reaches */) {
+        const after = target.slice();
+        Reflect.deleteProperty(after, prop);
+        copyPayloadReaching(event, located, target, after);
+      }
+      const result = Reflect.deleteProperty(target, prop);
+      if (hadProperty && result) {
+        if (isObject3(oldValue))
+          detachPlace(oldValue, node, placeKey(prop));
+        if (event !== undefined)
+          dispatch(located, event);
+        trigger(target, prop);
+        if (isObject3(oldValue))
+          evictDeep(oldValue);
+      }
+      return result;
     }
-  };
-  stopHandle.effect = effectFn;
-  return stopHandle;
+  });
+  globalSeen.set(arr, proxy);
+  wrapperCache.set(arr, proxy);
+  proxyStats.created++;
+  proxyStats.arrays++;
+  return proxy;
 }
 
-// src/wrap-set.ts
-function wrapSet(set, emit, path = []) {
-  const cachedProxy = wrapperCache.get(set);
+// src/wrap-map.ts
+function isObject4(value) {
+  return value !== null && typeof value === "object";
+}
+function wrapMap(map, node) {
+  const cachedProxy = wrapperCache.get(map);
   if (cachedProxy)
     return cachedProxy;
-  if (globalSeen.has(set))
-    return globalSeen.get(set);
+  if (globalSeen.has(map))
+    return globalSeen.get(map);
   const methodCache = {};
-  const proxy = new Proxy(set, {
+  const watch = watchIndex(map);
+  const proxy = new Proxy(map, {
     get(target, prop, receiver) {
       if (prop === "__v_raw" /* RAW */)
         return target;
@@ -3045,54 +5320,95 @@ function wrapSet(set, emit, path = []) {
       if (methodCache[prop]) {
         return methodCache[prop];
       }
-      if (prop === "add") {
-        methodCache[prop] = function(value2) {
+      if (prop === "set") {
+        methodCache[prop] = function(key, value2) {
           if (value2 != null && typeof value2 === "object")
             value2 = unwrapForStore(value2);
-          const existed = target.has(value2);
+          const existed = target.has(key);
+          const oldValue = target.get(key);
           const oldSize = target.size;
+          if (oldValue === value2)
+            return receiver;
+          if (oldValue && typeof oldValue === "object" && value2 && typeof value2 === "object" && deepEqual(oldValue, value2))
+            return receiver;
+          const located = locate(node);
+          const event = located && {
+            action: "map-set",
+            path: located.paths[0],
+            key,
+            oldValue,
+            newValue: value2
+          };
+          const held = located && heldItems(value2, oldValue);
+          if (event !== undefined && isObject4(key))
+            nameKey(event, key, target, !existed);
+          const copied = copyPayload(event, located, target, held);
+          if (copied === 0 /* Reaches */) {
+            copyPayloadReaching(event, located, target, shallowCopy(target).set(key, value2));
+          }
+          target.set(key, value2);
+          const newSize = target.size;
+          if (!existed && watch.indexed)
+            indexAdded(target, key);
+          if (isObject4(oldValue))
+            detachPlace(oldValue, node, key);
+          if (isObject4(value2))
+            attachValue(value2, node, key, copied === 2 /* Fresh */, located && oldValue, held);
+          if (event !== undefined)
+            dispatch(located, event);
           if (!existed) {
-            target.add(value2);
-            const newSize = target.size;
-            const event = {
-              action: "set-add",
-              path,
-              value: value2
-            };
-            emit?.(event);
             trigger(target, Symbol.iterator);
             if (oldSize !== newSize) {
               trigger(target, "size");
             }
+          } else {
+            trigger(target, String(key));
           }
+          if (isObject4(oldValue))
+            evictDeep(oldValue);
           return receiver;
         };
         return methodCache[prop];
       }
       if (prop === "delete") {
-        methodCache[prop] = function(value2) {
-          const existed = target.has(value2);
+        methodCache[prop] = function(key) {
+          const existed = target.has(key);
+          if (!existed)
+            return false;
+          const oldValue = target.get(key);
           const oldSize = target.size;
-          if (existed) {
-            const oldValue = value2;
-            const result = target.delete(value2);
-            const newSize = target.size;
-            if (result) {
-              const event = {
-                action: "set-delete",
-                path,
-                value: value2,
-                oldValue
-              };
-              emit?.(event);
-              trigger(target, Symbol.iterator);
-              if (oldSize !== newSize) {
-                trigger(target, "size");
-              }
+          const located = locate(node);
+          const event = located && {
+            action: "map-delete",
+            path: located.paths[0],
+            key,
+            oldValue
+          };
+          if (event !== undefined && isObject4(key))
+            nameKey(event, key, target, false);
+          if (copyPayload(event, located, target) === 0 /* Reaches */) {
+            const after = shallowCopy(target);
+            after.delete(key);
+            copyPayloadReaching(event, located, target, after);
+          }
+          const result = target.delete(key);
+          const newSize = target.size;
+          if (result) {
+            if (watch.indexed)
+              indexRemoved(target, key);
+            if (isObject4(oldValue))
+              detachPlace(oldValue, node, key);
+            if (event !== undefined)
+              dispatch(located, event);
+            trigger(target, Symbol.iterator);
+            if (oldSize !== newSize) {
+              trigger(target, "size");
             }
-            return result;
+            trigger(target, String(key));
+            if (isObject4(oldValue))
+              evictDeep(oldValue);
           }
-          return false;
+          return result;
         };
         return methodCache[prop];
       }
@@ -3101,87 +5417,75 @@ function wrapSet(set, emit, path = []) {
           const oldSize = target.size;
           if (oldSize === 0)
             return;
+          const removed = [...target];
           target.clear();
           const newSize = target.size;
-          const event = {
-            action: "set-clear",
-            path,
-            value: null
-          };
-          emit?.(event);
+          if (watch.indexed)
+            forgetReplicaIndex(target);
+          for (const [key, value2] of removed) {
+            if (isObject4(value2))
+              detachPlace(value2, node, key);
+          }
+          const located = locate(node);
+          if (located !== undefined) {
+            dispatch(located, {
+              action: "map-clear",
+              path: located.paths[0],
+              key: null
+            });
+          }
           trigger(target, Symbol.iterator);
           if (oldSize !== newSize) {
             trigger(target, "size");
           }
+          for (const [, value2] of removed) {
+            if (isObject4(value2))
+              evictDeep(value2);
+          }
+        };
+        return methodCache[prop];
+      }
+      if (prop === "get") {
+        methodCache[prop] = function(key) {
+          track(target, String(key));
+          const value2 = target.get(key);
+          if (!value2 || typeof value2 !== "object")
+            return value2;
+          return wrapChild(value2, node, key);
         };
         return methodCache[prop];
       }
       if (prop === "has") {
         track(target, Symbol.iterator);
-        methodCache[prop] = function(value2) {
-          if (typeof value2 === "string" || typeof value2 === "number" || typeof value2 === "symbol") {
-            track(target, String(value2));
-          }
-          return target.has(value2);
+        methodCache[prop] = function(key) {
+          track(target, String(key));
+          return target.has(key);
         }.bind(target);
         return methodCache[prop];
       }
-      if (prop === "values" || prop === Symbol.iterator || prop === "entries" || prop === "keys" || prop === "forEach") {
+      if (prop === Symbol.iterator || prop === "entries" || prop === "values" || prop === "keys" || prop === "forEach") {
         track(target, Symbol.iterator);
-        const originalMethod = Reflect.get(target, prop, receiver);
         if (prop === "forEach") {
           methodCache[prop] = (callbackfn, thisArg) => {
-            const valuesIterator = proxy.values();
-            for (const value2 of valuesIterator) {
-              callbackfn.call(thisArg, value2, value2, proxy);
+            const entriesIterator = proxy.entries();
+            for (const [key, value2] of entriesIterator) {
+              callbackfn.call(thisArg, value2, key, proxy);
             }
           };
           return methodCache[prop];
         }
-        methodCache[prop] = function* (...args) {
-          let index = 0;
-          const iterator = originalMethod.apply(target, args);
-          for (const entry of iterator) {
-            let valueToWrap = entry;
-            if (prop === "entries") {
-              valueToWrap = entry[1];
-            }
-            track(target, String(index));
-            let wrappedValue = valueToWrap;
-            if (valueToWrap && typeof valueToWrap === "object") {
-              if (globalSeen.has(valueToWrap)) {
-                wrappedValue = globalSeen.get(valueToWrap);
-              } else {
-                const cachedValueProxy = wrapperCache.get(valueToWrap);
-                if (cachedValueProxy) {
-                  wrappedValue = cachedValueProxy;
-                } else {
-                  const keyForPath = String(index);
-                  const pathKey = path.length > 0 ? `${path.join(".")}.${keyForPath}` : keyForPath;
-                  let newPath = getPathConcat(pathKey);
-                  if (newPath === undefined) {
-                    newPath = path.concat(keyForPath);
-                    setPathConcat(pathKey, newPath);
-                  }
-                  if (valueToWrap instanceof Map)
-                    wrappedValue = wrapMap(valueToWrap, emit, newPath);
-                  else if (valueToWrap instanceof Set)
-                    wrappedValue = wrapSet(valueToWrap, emit, newPath);
-                  else if (Array.isArray(valueToWrap))
-                    wrappedValue = wrapArray(valueToWrap, emit, newPath);
-                  else if (valueToWrap instanceof Date)
-                    wrappedValue = new Date(valueToWrap.getTime());
-                  else
-                    wrappedValue = reactive(valueToWrap, emit, newPath);
-                }
-              }
+        methodCache[prop] = function* () {
+          for (const [key, value2] of target.entries()) {
+            if (prop === "keys") {
+              yield key;
+              continue;
             }
-            if (prop === "entries") {
-              yield [wrappedValue, wrappedValue];
-            } else {
+            const wrappedValue = isObject4(value2) ? wrapChild(value2, node, key) : value2;
+            if (prop === "values") {
               yield wrappedValue;
+              continue;
             }
-            index++;
+            yield [isObject4(key) ? wrapUnplaced(key) : key, wrappedValue];
           }
         };
         return methodCache[prop];
@@ -3191,7 +5495,7 @@ function wrapSet(set, emit, path = []) {
         return target.size;
       }
       if (prop === "constructor") {
-        return Set;
+        return Map;
       }
       const value = Reflect.get(target, prop, receiver);
       if (typeof value === "function") {
@@ -3200,22 +5504,26 @@ function wrapSet(set, emit, path = []) {
       return value;
     }
   });
-  globalSeen.set(set, proxy);
-  wrapperCache.set(set, proxy);
+  globalSeen.set(map, proxy);
+  wrapperCache.set(map, proxy);
   proxyStats.created++;
-  proxyStats.sets++;
+  proxyStats.maps++;
   return proxy;
 }
 
-// src/wrap-map.ts
-function wrapMap(map, emit, path = []) {
-  const cachedProxy = wrapperCache.get(map);
+// src/wrap-set.ts
+function isObject5(value) {
+  return value !== null && typeof value === "object";
+}
+function wrapSet(set, node) {
+  const cachedProxy = wrapperCache.get(set);
   if (cachedProxy)
     return cachedProxy;
-  if (globalSeen.has(map))
-    return globalSeen.get(map);
+  if (globalSeen.has(set))
+    return globalSeen.get(set);
   const methodCache = {};
-  const proxy = new Proxy(map, {
+  const watch = watchIndex(set);
+  const proxy = new Proxy(set, {
     get(target, prop, receiver) {
       if (prop === "__v_raw" /* RAW */)
         return target;
@@ -3228,75 +5536,77 @@ function wrapMap(map, emit, path = []) {
       if (methodCache[prop]) {
         return methodCache[prop];
       }
-      if (prop === "set") {
-        methodCache[prop] = function(key, value2) {
+      if (prop === "add") {
+        methodCache[prop] = function(value2) {
           if (value2 != null && typeof value2 === "object")
             value2 = unwrapForStore(value2);
-          const existed = target.has(key);
-          const oldValue = target.get(key);
+          const existed = target.has(value2);
           const oldSize = target.size;
-          if (oldValue === value2)
-            return receiver;
-          if (oldValue && typeof oldValue === "object" && value2 && typeof value2 === "object" && deepEqual(oldValue, value2, new WeakMap))
-            return receiver;
-          target.set(key, value2);
-          const newSize = target.size;
-          const pathKey = path.join(".");
-          let cachedPath = getPathConcat(pathKey);
-          if (cachedPath === undefined) {
-            cachedPath = path;
-            setPathConcat(pathKey, cachedPath);
-          }
-          const event = {
-            action: "map-set",
-            path: cachedPath,
-            key,
-            oldValue,
-            newValue: value2 !== null && typeof value2 === "object" ? deepClone(value2) : value2
-          };
-          emit?.(event);
           if (!existed) {
+            const located = locate(node);
+            const event = located && {
+              action: "set-add",
+              path: located.paths[0],
+              value: value2
+            };
+            const copied = copyPayload(event, located, target);
+            if (copied === 0 /* Reaches */) {
+              copyPayloadReaching(event, located, target, shallowCopy(target).add(value2));
+            }
+            target.add(value2);
+            const newSize = target.size;
+            if (watch.indexed)
+              indexAdded(target, value2);
+            if (isObject5(value2))
+              attachValue(value2, node, undefined, copied === 2 /* Fresh */);
+            if (event !== undefined)
+              dispatch(located, event);
             trigger(target, Symbol.iterator);
             if (oldSize !== newSize) {
               trigger(target, "size");
             }
-          } else {
-            trigger(target, String(key));
           }
           return receiver;
         };
         return methodCache[prop];
       }
       if (prop === "delete") {
-        methodCache[prop] = function(key) {
-          const existed = target.has(key);
-          if (!existed)
-            return false;
-          const oldValue = target.get(key);
+        methodCache[prop] = function(value2) {
+          const existed = target.has(value2);
           const oldSize = target.size;
-          const result = target.delete(key);
-          const newSize = target.size;
-          if (result) {
-            const pathKey = path.join(".");
-            let cachedPath = getPathConcat(pathKey);
-            if (cachedPath === undefined) {
-              cachedPath = path;
-              setPathConcat(pathKey, cachedPath);
-            }
-            const event = {
-              action: "map-delete",
-              path: cachedPath,
-              key,
+          if (existed) {
+            const oldValue = value2;
+            const located = locate(node);
+            const event = located && {
+              action: "set-delete",
+              path: located.paths[0],
+              value: value2,
               oldValue
             };
-            emit?.(event);
-            trigger(target, Symbol.iterator);
-            if (oldSize !== newSize) {
-              trigger(target, "size");
+            if (copyPayload(event, located, target) === 0 /* Reaches */) {
+              const after = shallowCopy(target);
+              after.delete(value2);
+              copyPayloadReaching(event, located, target, after);
             }
-            trigger(target, String(key));
+            const result = target.delete(value2);
+            const newSize = target.size;
+            if (result) {
+              if (watch.indexed)
+                indexRemoved(target, value2);
+              if (isObject5(value2))
+                detachPlace(value2, node, undefined);
+              if (event !== undefined)
+                dispatch(located, event);
+              trigger(target, Symbol.iterator);
+              if (oldSize !== newSize) {
+                trigger(target, "size");
+              }
+              if (isObject5(value2))
+                evictDeep(value2);
+            }
+            return result;
           }
-          return result;
+          return false;
         };
         return methodCache[prop];
       }
@@ -3305,132 +5615,72 @@ function wrapMap(map, emit, path = []) {
           const oldSize = target.size;
           if (oldSize === 0)
             return;
+          const removed = [...target];
           target.clear();
           const newSize = target.size;
-          const event = {
-            action: "map-clear",
-            path,
-            key: null
-          };
-          emit?.(event);
+          if (watch.indexed)
+            forgetReplicaIndex(target);
+          for (const member of removed) {
+            if (isObject5(member))
+              detachPlace(member, node, undefined);
+          }
+          const located = locate(node);
+          if (located !== undefined) {
+            dispatch(located, {
+              action: "set-clear",
+              path: located.paths[0],
+              value: null
+            });
+          }
           trigger(target, Symbol.iterator);
           if (oldSize !== newSize) {
             trigger(target, "size");
           }
-        };
-        return methodCache[prop];
-      }
-      if (prop === "get") {
-        methodCache[prop] = function(key) {
-          track(target, String(key));
-          const value2 = target.get(key);
-          if (!value2 || typeof value2 !== "object")
-            return value2;
-          if (globalSeen.has(value2))
-            return globalSeen.get(value2);
-          const cachedValueProxy = wrapperCache.get(value2);
-          if (cachedValueProxy)
-            return cachedValueProxy;
-          const keyString = String(key);
-          const pathKey = path.length > 0 ? `${path.join(".")}.${keyString}` : keyString;
-          let newPath = getPathConcat(pathKey);
-          if (newPath === undefined) {
-            newPath = path.concat(keyString);
-            setPathConcat(pathKey, newPath);
+          for (const member of removed) {
+            if (isObject5(member))
+              evictDeep(member);
           }
-          if (value2 instanceof Map)
-            return wrapMap(value2, emit, newPath);
-          if (value2 instanceof Set)
-            return wrapSet(value2, emit, newPath);
-          if (Array.isArray(value2))
-            return wrapArray(value2, emit, newPath);
-          if (value2 instanceof Date)
-            return new Date(value2.getTime());
-          return reactive(value2, emit, newPath);
         };
         return methodCache[prop];
       }
       if (prop === "has") {
         track(target, Symbol.iterator);
-        methodCache[prop] = function(key) {
-          track(target, String(key));
-          return target.has(key);
+        methodCache[prop] = function(value2) {
+          if (typeof value2 === "string" || typeof value2 === "number" || typeof value2 === "symbol") {
+            track(target, String(value2));
+          }
+          return target.has(value2);
         }.bind(target);
         return methodCache[prop];
       }
-      if (prop === Symbol.iterator || prop === "entries" || prop === "values" || prop === "keys" || prop === "forEach") {
+      if (prop === "values" || prop === Symbol.iterator || prop === "entries" || prop === "keys" || prop === "forEach") {
         track(target, Symbol.iterator);
         const originalMethod = Reflect.get(target, prop, receiver);
         if (prop === "forEach") {
           methodCache[prop] = (callbackfn, thisArg) => {
-            const entriesIterator = proxy.entries();
-            for (const [key, value2] of entriesIterator) {
-              callbackfn.call(thisArg, value2, key, proxy);
+            const valuesIterator = proxy.values();
+            for (const value2 of valuesIterator) {
+              callbackfn.call(thisArg, value2, value2, proxy);
             }
           };
           return methodCache[prop];
         }
         methodCache[prop] = function* (...args) {
+          let index = 0;
           const iterator = originalMethod.apply(target, args);
           for (const entry of iterator) {
-            let keyToWrap = entry;
             let valueToWrap = entry;
-            let isEntry = false;
-            if (prop === "entries" || prop === Symbol.iterator) {
-              keyToWrap = entry[0];
+            if (prop === "entries") {
               valueToWrap = entry[1];
-              isEntry = true;
-            }
-            let wrappedKey = keyToWrap;
-            if (isEntry && keyToWrap && typeof keyToWrap === "object") {
-              if (globalSeen.has(keyToWrap)) {
-                wrappedKey = globalSeen.get(keyToWrap);
-              } else {
-                const pathKey = path.length > 0 ? `${path.join(".")}.${String(keyToWrap)}` : String(keyToWrap);
-                let keyPath = getPathConcat(pathKey);
-                if (keyPath === undefined) {
-                  keyPath = path.concat(String(keyToWrap));
-                  setPathConcat(pathKey, keyPath);
-                }
-                wrappedKey = reactive(keyToWrap, emit, keyPath);
-              }
-            }
-            let wrappedValue = valueToWrap;
-            if (valueToWrap && typeof valueToWrap === "object") {
-              if (globalSeen.has(valueToWrap)) {
-                wrappedValue = globalSeen.get(valueToWrap);
-              } else {
-                const cachedValueProxy = wrapperCache.get(valueToWrap);
-                if (cachedValueProxy) {
-                  wrappedValue = cachedValueProxy;
-                } else {
-                  const keyString = String(keyToWrap);
-                  const pathKey = path.length > 0 ? `${path.join(".")}.${keyString}` : keyString;
-                  let newPath = getPathConcat(pathKey);
-                  if (newPath === undefined) {
-                    newPath = path.concat(keyString);
-                    setPathConcat(pathKey, newPath);
-                  }
-                  if (valueToWrap instanceof Map)
-                    wrappedValue = wrapMap(valueToWrap, emit, newPath);
-                  else if (valueToWrap instanceof Set)
-                    wrappedValue = wrapSet(valueToWrap, emit, newPath);
-                  else if (Array.isArray(valueToWrap))
-                    wrappedValue = wrapArray(valueToWrap, emit, newPath);
-                  else if (valueToWrap instanceof Date)
-                    wrappedValue = new Date(valueToWrap.getTime());
-                  else
-                    wrappedValue = reactive(valueToWrap, emit, newPath);
-                }
-              }
             }
-            if (prop === "entries" || prop === Symbol.iterator) {
-              yield [wrappedKey, wrappedValue];
-            } else if (prop === "values") {
-              yield wrappedValue;
+            track(target, String(index));
+            const wrappedValue = isObject5(valueToWrap) ? wrapChild(valueToWrap, node, undefined) : valueToWrap;
+            if (prop === "entries") {
+              yield [wrappedValue, wrappedValue];
             } else {
-              yield wrappedKey;
+              yield wrappedValue;
             }
+            index++;
           }
         };
         return methodCache[prop];
@@ -3440,350 +5690,24 @@ function wrapMap(map, emit, path = []) {
         return target.size;
       }
       if (prop === "constructor") {
-        return Map;
-      }
-      const value = Reflect.get(target, prop, receiver);
-      if (typeof value === "function") {
-        return value.bind(target);
-      }
-      return value;
-    }
-  });
-  globalSeen.set(map, proxy);
-  wrapperCache.set(map, proxy);
-  proxyStats.created++;
-  proxyStats.maps++;
-  return proxy;
-}
-
-// src/wrap-array.ts
-function isObject2(v) {
-  return v && typeof v === "object";
-}
-function wrapArray(arr, emit, path = []) {
-  const cachedProxy = wrapperCache.get(arr);
-  if (cachedProxy)
-    return cachedProxy;
-  if (globalSeen.has(arr))
-    return globalSeen.get(arr);
-  const methodCache = {};
-  const proxy = new Proxy(arr, {
-    get(target, prop, receiver) {
-      if (prop === "__v_raw" /* RAW */)
-        return target;
-      if (prop === "__v_isReactive" /* IS_REACTIVE */)
-        return true;
-      track(target, prop);
-      if (methodCache[prop]) {
-        return methodCache[prop];
-      }
-      switch (prop) {
-        case "push":
-          track(target, "length");
-          methodCache[prop] = function(...items) {
-            const oldLength = target.length;
-            const result = target.push(...items);
-            const newLength = target.length;
-            if (items.length > 0) {
-              const event = {
-                action: "array-push",
-                path,
-                key: oldLength,
-                items
-              };
-              emit?.(event);
-              trigger(target, Symbol.iterator);
-              if (oldLength !== newLength) {
-                trigger(target, "length");
-              }
-            }
-            return result;
-          };
-          return methodCache[prop];
-        case "pop":
-          track(target, "length");
-          methodCache[prop] = function() {
-            if (target.length === 0)
-              return;
-            const oldLength = target.length;
-            const poppedIndex = oldLength - 1;
-            const oldValue = target[poppedIndex];
-            const result = target.pop();
-            const newLength = target.length;
-            const event = {
-              action: "array-pop",
-              path,
-              key: poppedIndex,
-              oldValue
-            };
-            emit?.(event);
-            if (isObject2(oldValue))
-              evictDeep(oldValue);
-            trigger(target, Symbol.iterator);
-            if (oldLength !== newLength) {
-              trigger(target, "length");
-            }
-            return result;
-          };
-          return methodCache[prop];
-        case "shift":
-          track(target, "length");
-          methodCache[prop] = function() {
-            if (target.length === 0)
-              return;
-            const oldLength = target.length;
-            const oldValue = target[0];
-            const result = target.shift();
-            const newLength = target.length;
-            const event = {
-              action: "array-shift",
-              path,
-              key: 0,
-              oldValue
-            };
-            emit?.(event);
-            if (isObject2(oldValue))
-              evictDeep(oldValue);
-            trigger(target, Symbol.iterator);
-            if (oldLength !== newLength) {
-              trigger(target, "length");
-            }
-            return result;
-          };
-          return methodCache[prop];
-        case "unshift":
-          track(target, "length");
-          methodCache[prop] = function(...items) {
-            const oldLength = target.length;
-            const result = target.unshift(...items);
-            const newLength = target.length;
-            if (items.length > 0) {
-              const event = {
-                action: "array-unshift",
-                path,
-                key: 0,
-                items
-              };
-              emit?.(event);
-              trigger(target, Symbol.iterator);
-              if (oldLength !== newLength) {
-                trigger(target, "length");
-              }
-            }
-            return result;
-          };
-          return methodCache[prop];
-        case "splice":
-          track(target, "length");
-          methodCache[prop] = function(start, deleteCount, ...items) {
-            const oldLength = target.length;
-            const actualStart = start < 0 ? Math.max(target.length + start, 0) : Math.min(start, target.length);
-            const deleteCountNum = deleteCount === undefined ? target.length - actualStart : Number(deleteCount);
-            const actualDeleteCount = Math.min(deleteCountNum, target.length - actualStart);
-            const deletedItems = target.slice(actualStart, actualStart + actualDeleteCount);
-            const result = target.splice(start, deleteCountNum, ...items);
-            const newLength = target.length;
-            if (actualDeleteCount > 0 || items.length > 0) {
-              const event = {
-                action: "array-splice",
-                path,
-                key: actualStart,
-                deleteCount: actualDeleteCount,
-                items: items.length > 0 ? items : undefined,
-                oldValues: deletedItems.length > 0 ? deletedItems : undefined
-              };
-              emit?.(event);
-              for (let i = 0;i < deletedItems.length; i++) {
-                if (isObject2(deletedItems[i]))
-                  evictDeep(deletedItems[i]);
-              }
-              trigger(target, Symbol.iterator);
-              if (oldLength !== newLength) {
-                trigger(target, "length");
-              }
-            }
-            return result;
-          };
-          return methodCache[prop];
-        case "find": {
-          track(target, Symbol.iterator);
-          if (!methodCache[prop]) {
-            methodCache[prop] = function(predicate, thisArg) {
-              const idx = Array.prototype.findIndex.call(target, predicate, thisArg);
-              if (idx === -1)
-                return;
-              const value2 = target[idx];
-              if (!isObject2(value2))
-                return value2;
-              const propKey = String(idx);
-              const pathKey = path.length > 0 ? `${path.join(".")}.${propKey}` : propKey;
-              let newPath = getPathConcat(pathKey);
-              if (newPath === undefined) {
-                newPath = path.concat(propKey);
-                setPathConcat(pathKey, newPath);
-              }
-              if (globalSeen.has(value2))
-                return globalSeen.get(value2);
-              const cachedValueProxy = wrapperCache.get(value2);
-              if (cachedValueProxy)
-                return cachedValueProxy;
-              if (Array.isArray(value2))
-                return wrapArray(value2, emit, newPath);
-              if (value2 instanceof Map)
-                return wrapMap(value2, emit, newPath);
-              if (value2 instanceof Set)
-                return wrapSet(value2, emit, newPath);
-              if (value2 instanceof Date)
-                return new Date(value2.getTime());
-              return reactive(value2, emit, newPath);
-            };
-          }
-          return methodCache[prop];
-        }
-        case "at": {
-          track(target, Symbol.iterator);
-          if (!methodCache[prop]) {
-            methodCache[prop] = function(index) {
-              let idx = Number(index);
-              if (!Number.isInteger(idx))
-                idx = Math.trunc(idx);
-              if (idx < 0)
-                idx = target.length + idx;
-              if (idx < 0 || idx >= target.length)
-                return;
-              const value2 = target[idx];
-              if (!isObject2(value2))
-                return value2;
-              const propKey = String(idx);
-              const pathKey = path.length > 0 ? `${path.join(".")}.${propKey}` : propKey;
-              let newPath = getPathConcat(pathKey);
-              if (newPath === undefined) {
-                newPath = path.concat(propKey);
-                setPathConcat(pathKey, newPath);
-              }
-              if (globalSeen.has(value2))
-                return globalSeen.get(value2);
-              const cachedValueProxy = wrapperCache.get(value2);
-              if (cachedValueProxy)
-                return cachedValueProxy;
-              if (Array.isArray(value2))
-                return wrapArray(value2, emit, newPath);
-              if (value2 instanceof Map)
-                return wrapMap(value2, emit, newPath);
-              if (value2 instanceof Set)
-                return wrapSet(value2, emit, newPath);
-              if (value2 instanceof Date)
-                return new Date(value2.getTime());
-              return reactive(value2, emit, newPath);
-            };
-          }
-          return methodCache[prop];
-        }
-        case Symbol.iterator:
-        case "values":
-        case "keys":
-        case "entries":
-        case "forEach":
-        case "map":
-        case "filter":
-        case "reduce":
-        case "reduceRight":
-        case "findIndex":
-        case "every":
-        case "some":
-        case "join":
-          track(target, Symbol.iterator);
-          break;
-        case "length":
-          track(target, "length");
-          return Reflect.get(target, prop, receiver);
+        return Set;
       }
       const value = Reflect.get(target, prop, receiver);
-      const isNumericIndex = typeof prop === "number" || typeof prop === "string" && !isNaN(parseInt(prop, 10));
-      if (isNumericIndex) {
-        track(target, String(prop));
-        if (!isObject2(value))
-          return value;
-        if (globalSeen.has(value))
-          return globalSeen.get(value);
-        const cachedValueProxy = wrapperCache.get(value);
-        if (cachedValueProxy)
-          return cachedValueProxy;
-        const propKey = String(prop);
-        const pathKey = path.length > 0 ? `${path.join(".")}.${propKey}` : propKey;
-        let newPath = getPathConcat(pathKey);
-        if (newPath === undefined) {
-          newPath = path.concat(propKey);
-          setPathConcat(pathKey, newPath);
-        }
-        if (Array.isArray(value))
-          return wrapArray(value, emit, newPath);
-        if (value instanceof Map)
-          return wrapMap(value, emit, newPath);
-        if (value instanceof Set)
-          return wrapSet(value, emit, newPath);
-        if (value instanceof Date)
-          return new Date(value.getTime());
-        return reactive(value, emit, newPath);
-      }
       if (typeof value === "function") {
         return value.bind(target);
       }
       return value;
-    },
-    set(target, prop, value, receiver) {
-      if (isObject2(value))
-        value = unwrapForStore(value);
-      const oldValue = target[prop];
-      if (oldValue === value && Reflect.has(target, prop))
-        return true;
-      if (isObject2(oldValue) && isObject2(value) && deepEqual(oldValue, value, new WeakMap))
-        return true;
-      const descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
-      const result = Reflect.set(target, prop, value, receiver);
-      const isNumericIndex = typeof prop === "number" || typeof prop === "string" && !isNaN(parseInt(String(prop)));
-      if (result && (!descriptor || !descriptor.set || isNumericIndex)) {
-        const resolvePath = (key) => {
-          const pathKey = path.length > 0 ? `${path.join(".")}.${key}` : key;
-          let newPath = getPathConcat(pathKey);
-          if (newPath === undefined) {
-            newPath = path.concat(key);
-            setPathConcat(pathKey, newPath);
-          }
-          return newPath;
-        };
-        if (Array.isArray(target) && prop === "length" && Number(value) > Number(oldValue)) {
-          const oldLength = Number(oldValue);
-          const newLength = Number(value);
-          for (let i = oldLength;i < newLength; i++) {
-            emit?.({ action: "set", path: resolvePath(String(i)), newValue: undefined });
-          }
-        } else {
-          const event = {
-            action: "set",
-            path: resolvePath(String(prop)),
-            oldValue,
-            newValue: isObject2(value) ? deepClone(value) : value
-          };
-          emit?.(event);
-        }
-        if (isObject2(oldValue) && oldValue !== value) {
-          evictDeep(oldValue);
-        }
-        trigger(target, prop);
-      }
-      return result;
     }
   });
-  globalSeen.set(arr, proxy);
-  wrapperCache.set(arr, proxy);
+  globalSeen.set(set, proxy);
+  wrapperCache.set(set, proxy);
   proxyStats.created++;
-  proxyStats.arrays++;
+  proxyStats.sets++;
   return proxy;
 }
 
 // src/reactive.ts
-function isObject3(v) {
+function isObject6(v) {
   return v && typeof v === "object";
 }
 function isReactive(value) {
@@ -3797,60 +5721,98 @@ function createAsyncEmit(emit) {
     if (!flushScheduled) {
       flushScheduled = true;
       queueMicrotask(() => {
-        flushScheduled = false;
-        const batch = queue.splice(0);
-        for (const queuedEvent of batch) {
-          emit(queuedEvent);
+        let failed = false;
+        let failure;
+        let next = 0;
+        while (next < queue.length) {
+          try {
+            emit(queue[next++]);
+          } catch (error) {
+            if (!failed) {
+              failed = true;
+              failure = error;
+            }
+          }
+          if (next === FLUSH_CHUNK) {
+            queue.splice(0, next);
+            next = 0;
+          }
         }
+        queue.length = 0;
+        flushScheduled = false;
+        if (failed)
+          throw failure;
       });
     }
   };
 }
+var FLUSH_CHUNK = 1024;
 function reactive(obj, emit, path = [], options) {
   if (obj["__v_skip" /* SKIP */]) {
     return obj;
   }
-  if (globalSeen.has(obj))
-    return globalSeen.get(obj);
+  const existing = globalSeen.get(obj);
+  if (existing !== undefined)
+    return existing;
+  if (obj["__v_isReactive" /* IS_REACTIVE */])
+    return obj;
   if (emit && path.length === 0 && options?.async) {
     emit = createAsyncEmit(emit);
   }
+  let fresh = false;
   if (emit && path.length === 0) {
     try {
-      const initialEvent = {
-        action: "replace",
-        path: [],
-        newValue: obj
-      };
-      emit(initialEvent);
+      const newValue = cloneStored(obj, undefined, 2 /* All */);
+      fresh = copiedFresh;
+      emit({ action: "replace", path: [], newValue });
     } catch (error) {
+      if (error instanceof SnapshotLimitError)
+        throw error;
       console.error("Failed to emit initial reactive state:", error);
     }
   }
-  if (Array.isArray(obj)) {
-    return wrapArray(obj, emit, path);
-  }
-  if (obj instanceof Map) {
-    return wrapMap(obj, emit, path);
-  }
-  if (obj instanceof Set) {
-    return wrapSet(obj, emit, path);
-  }
-  function wrapValue(val, subPath) {
-    if (!isObject3(val))
-      return val;
-    if (globalSeen.has(val))
-      return globalSeen.get(val);
-    if (Array.isArray(val))
-      return wrapArray(val, emit, subPath);
-    if (val instanceof Map)
-      return wrapMap(val, emit, subPath);
-    if (val instanceof Set)
-      return wrapSet(val, emit, subPath);
-    if (val instanceof Date)
-      return new Date(val.getTime());
-    return reactive(val, emit, subPath, options);
-  }
+  const node = ensureLocationNode(obj);
+  node.root = { emit, path, async: emit !== undefined && options?.async === true, undelivered: undefined };
+  node.scope = node.root;
+  if (emit && !fresh)
+    adoptRoot(node);
+  return createProxy(obj, node, options);
+}
+function wrapChild(raw, parent, key, options) {
+  let node = getLocationNode(raw);
+  if (node !== undefined && node.proxy !== undefined) {
+    notePlace(node, parent, key);
+    node.scope ??= parent.scope;
+    return node.proxy;
+  }
+  if (raw["__v_skip" /* SKIP */])
+    return raw;
+  if (raw["__v_isReactive" /* IS_REACTIVE */])
+    return wrapChild(toRaw(raw), parent, key, options);
+  if (raw instanceof Date)
+    return new Date(raw.getTime());
+  node ??= ensureLocationNode(raw);
+  notePlace(node, parent, key);
+  node.scope ??= parent.scope;
+  return restoreEvicted(node) ?? createProxy(raw, node, options);
+}
+function wrapUnplaced(raw) {
+  if (raw["__v_skip" /* SKIP */])
+    return raw;
+  const existing = globalSeen.get(raw);
+  if (existing !== undefined)
+    return existing;
+  if (raw["__v_isReactive" /* IS_REACTIVE */])
+    return wrapUnplaced(toRaw(raw));
+  const node = ensureLocationNode(raw);
+  return restoreEvicted(node) ?? createProxy(raw, node);
+}
+function createProxy(raw, node, options) {
+  const proxy = Array.isArray(raw) ? wrapArray(raw, node) : raw instanceof Map ? wrapMap(raw, node) : raw instanceof Set ? wrapSet(raw, node) : wrapObject(raw, node, options);
+  node.proxy = proxy;
+  return proxy;
+}
+function wrapObject(obj, node, options) {
   const proxy = new Proxy(obj, {
     get(target, prop, receiver) {
       if (prop === "__v_raw" /* RAW */) {
@@ -3861,44 +5823,45 @@ function reactive(obj, emit, path = [], options) {
       }
       const value = Reflect.get(target, prop, receiver);
       track(target, prop);
-      if (!isObject3(value))
+      if (!isObject6(value))
         return value;
-      const propKey = String(prop);
-      const pathKey = path.length > 0 ? `${path.join(".")}.${propKey}` : propKey;
-      let newPath = getPathConcat(pathKey);
-      if (newPath === undefined) {
-        newPath = path.concat(propKey);
-        setPathConcat(pathKey, newPath);
-      }
-      return wrapValue(value, newPath);
+      return wrapChild(value, node, prop, options);
     },
     set(target, prop, value, receiver) {
-      if (isObject3(value))
+      if (isObject6(value))
         value = unwrapForStore(value);
       const oldValue = target[prop];
       if (oldValue === value)
         return true;
-      if (!options?.async && isObject3(oldValue) && isObject3(value) && deepEqual(oldValue, value, new WeakMap))
+      if (!options?.async && isObject6(oldValue) && isObject6(value) && deepEqual(oldValue, value))
         return true;
-      const descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+      const emits = !writesThroughSetter(target, prop, node);
+      const located = emits ? locate(node, prop) : undefined;
+      const event = located && {
+        action: "set",
+        path: located.paths[0],
+        oldValue,
+        newValue: value
+      };
+      const held = located && heldItems(value, oldValue);
+      const copied = copyPayload(event, located, target, held);
+      if (copied === 0 /* Reaches */) {
+        const after = shallowCopy(target);
+        const descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+        if (descriptor === undefined || descriptor.enumerable)
+          setData(after, prop, value);
+        copyPayloadReaching(event, located, target, after);
+      }
       const result = Reflect.set(target, prop, value, receiver);
-      if (result && (!descriptor || !descriptor.set)) {
-        const propKey = String(prop);
-        const pathKey = path.length > 0 ? `${path.join(".")}.${propKey}` : propKey;
-        let newPath = getPathConcat(pathKey);
-        if (newPath === undefined) {
-          newPath = path.concat(propKey);
-          setPathConcat(pathKey, newPath);
-        }
-        const event = {
-          action: "set",
-          path: newPath,
-          oldValue,
-          newValue: isObject3(value) ? deepClone(value) : value
-        };
-        emit?.(event);
+      if (result && emits) {
+        if (isObject6(oldValue))
+          detachPlace(oldValue, node, prop);
+        if (isObject6(value))
+          attachValue(value, node, prop, copied === 2 /* Fresh */, located && oldValue, held);
+        if (event !== undefined)
+          dispatch(located, event);
         trigger(target, prop);
-        if (isObject3(oldValue) && oldValue !== value) {
+        if (isObject6(oldValue)) {
           evictDeep(oldValue);
         }
       }
@@ -3907,23 +5870,25 @@ function reactive(obj, emit, path = [], options) {
     deleteProperty(target, prop) {
       const oldValue = target[prop];
       const hadProperty = Object.prototype.hasOwnProperty.call(target, prop);
+      const located = hadProperty ? locate(node, prop) : undefined;
+      const event = located && {
+        action: "delete",
+        path: located.paths[0],
+        oldValue
+      };
+      if (copyPayload(event, located, target) === 0 /* Reaches */) {
+        const after = shallowCopy(target);
+        delete after[prop];
+        copyPayloadReaching(event, located, target, after);
+      }
       const result = Reflect.deleteProperty(target, prop);
       if (hadProperty && result) {
-        const propKey = String(prop);
-        const pathKey = path.length > 0 ? `${path.join(".")}.${propKey}` : propKey;
-        let newPath = getPathConcat(pathKey);
-        if (newPath === undefined) {
-          newPath = path.concat(propKey);
-          setPathConcat(pathKey, newPath);
-        }
-        const event = {
-          action: "delete",
-          path: newPath,
-          oldValue
-        };
-        emit?.(event);
+        if (isObject6(oldValue))
+          detachPlace(oldValue, node, prop);
+        if (event !== undefined)
+          dispatch(located, event);
         trigger(target, prop);
-        if (isObject3(oldValue)) {
+        if (isObject6(oldValue)) {
           evictDeep(oldValue);
         }
       }
@@ -3935,6 +5900,260 @@ function reactive(obj, emit, path = [], options) {
   proxyStats.objects++;
   return proxy;
 }
+
+// src/state.ts
+function getValue(obj, key) {
+  if (obj instanceof Map)
+    return obj.get(key);
+  return obj[key];
+}
+function setValue(obj, key, value) {
+  if (obj instanceof Map)
+    obj.set(key, value);
+  else
+    obj[key] = value;
+}
+function deleteValue(obj, key) {
+  if (obj instanceof Map)
+    obj.delete(key);
+  else
+    delete obj[key];
+}
+function validateCachedPath(root, fullPath, pathKey, cached) {
+  if (fullPath.length === 0)
+    return cached;
+  const lastKey = fullPath[fullPath.length - 1];
+  let grandparent = root;
+  for (let i = 0;i < fullPath.length - 1; i++) {
+    grandparent = grandparent ? getValue(grandparent, fullPath[i]) : undefined;
+    if (grandparent === undefined)
+      break;
+  }
+  if (grandparent === undefined) {
+    evictDescendantsFromPathCache(root, pathKey);
+    return;
+  }
+  const actual = getValue(grandparent, lastKey);
+  if (actual === cached)
+    return cached;
+  evictDescendantsFromPathCache(root, pathKey);
+  return;
+}
+var actionHandlers = {
+  set: function(parent, key, event) {
+    if (Array.isArray(parent) && key === "length" && Number(event.newValue) > parent.length) {
+      console.warn(`refusing to grow array length via bare set at path ${event.path.join(".")}`);
+      return;
+    }
+    setValue(parent, key, event.newValue);
+  },
+  delete: function(parent, key) {
+    deleteValue(parent, key);
+  },
+  "array-push": function(targetArray, _keyIgnored, event) {
+    if (!Array.isArray(targetArray)) {
+      console.warn(`expected array at path ${event.path.join(".")}`);
+      return;
+    }
+    if (!event.items) {
+      console.warn("array-push event missing items");
+      return;
+    }
+    targetArray.push(...event.items);
+  },
+  "array-pop": function(targetArray, _keyIgnored, event) {
+    if (!Array.isArray(targetArray)) {
+      console.warn(`expected array at path ${event.path.join(".")}`);
+      return;
+    }
+    if (targetArray.length > 0) {
+      targetArray.pop();
+    }
+  },
+  "array-splice": function(targetArray, _keyIgnored, event) {
+    if (!Array.isArray(targetArray)) {
+      console.warn(`expected array at path ${event.path.join(".")}`);
+      return;
+    }
+    if (event.key === undefined || event.deleteCount === undefined) {
+      console.warn("array-splice event missing key or deletecount");
+      return;
+    }
+    if (event.items && event.items.length > 0) {
+      targetArray.splice(event.key, event.deleteCount, ...event.items);
+    } else {
+      targetArray.splice(event.key, event.deleteCount);
+    }
+  },
+  "array-shift": function(targetArray, _keyIgnored, event) {
+    if (!Array.isArray(targetArray)) {
+      console.warn(`expected array at path ${event.path.join(".")}`);
+      return;
+    }
+    if (targetArray.length > 0) {
+      targetArray.shift();
+    }
+  },
+  "array-unshift": function(targetArray, _keyIgnored, event) {
+    if (!Array.isArray(targetArray)) {
+      console.warn(`expected array at path ${event.path.join(".")}`);
+      return;
+    }
+    if (!event.items) {
+      console.warn("array-unshift event missing items");
+      return;
+    }
+    targetArray.unshift(...event.items);
+  },
+  "map-set": function(targetMap2, _parentKeyIgnored, event) {
+    if (!(targetMap2 instanceof Map)) {
+      console.warn(`expected map at path ${event.path.join(".")}`);
+      return;
+    }
+    replicaMapSet(targetMap2, event.key, event.newValue);
+  },
+  "map-delete": function(targetMap2, _parentKeyIgnored, event) {
+    if (!(targetMap2 instanceof Map)) {
+      console.warn(`expected map at path ${event.path.join(".")}`);
+      return;
+    }
+    replicaMapDelete(targetMap2, event.key);
+  },
+  "map-clear": function(targetMap2, _parentKeyIgnored, event) {
+    if (!(targetMap2 instanceof Map)) {
+      console.warn(`expected map at path ${event.path.join(".")}`);
+      return;
+    }
+    targetMap2.clear();
+    forgetReplicaIndex(targetMap2);
+  },
+  "set-add": function(targetSet, _keyIgnored, event) {
+    if (!(targetSet instanceof Set)) {
+      console.warn(`expected set at path ${event.path.join(".")}`);
+      return;
+    }
+    replicaAdd(targetSet, event.value);
+  },
+  "set-delete": function(targetSet, _keyIgnored, event) {
+    if (!(targetSet instanceof Set)) {
+      console.warn(`expected set at path ${event.path.join(".")}`);
+      return;
+    }
+    replicaDelete(targetSet, event.value);
+  },
+  "set-clear": function(targetSet, _keyIgnored, event) {
+    if (!(targetSet instanceof Set)) {
+      console.warn(`expected set at path ${event.path.join(".")}`);
+      return;
+    }
+    targetSet.clear();
+    forgetReplicaIndex(targetSet);
+  },
+  replace: function(target, _keyIgnored, event) {
+    const newValue = event.newValue;
+    if (newValue === undefined || newValue === null) {
+      console.warn("replace action requires newValue");
+      return;
+    }
+    if (Array.isArray(target) && Array.isArray(newValue)) {
+      target.splice(0, target.length, ...newValue);
+    } else if (target instanceof Map && newValue instanceof Map) {
+      const newValueEntries = [...newValue.entries()];
+      target.clear();
+      forgetReplicaIndex(target);
+      const reactiveTarget = isReactive(target);
+      for (const [key, value] of newValueEntries) {
+        if (reactiveTarget)
+          replicaMapSet(target, key, value);
+        else
+          target.set(key, value);
+      }
+    } else if (target instanceof Set && newValue instanceof Set) {
+      const newValueEntries = [...newValue.values()];
+      target.clear();
+      forgetReplicaIndex(target);
+      const reactiveTarget = isReactive(target);
+      for (const value of newValueEntries) {
+        if (reactiveTarget)
+          replicaAdd(target, value);
+        else
+          target.add(value);
+      }
+    } else if (typeof target === "object" && target !== null && typeof newValue === "object" && newValue !== null) {
+      Object.keys(target).forEach((key) => delete target[key]);
+      Object.assign(target, newValue);
+    } else {
+      console.warn(`Type mismatch or unsupported type for 'replace' action at path ${event.path.join(".")}. Target type: ${typeof target} ${target.constructor.name}, New value type: ${typeof newValue} ${newValue.constructor.name}`);
+    }
+  }
+};
+function updateState(root, event) {
+  const { action, path } = event;
+  if (!path || path.length === 0 && action !== "replace") {
+    console.warn("event path is invalid for action", event);
+    return;
+  }
+  const handler = actionHandlers[action];
+  if (!handler) {
+    console.error(`unhandled action type: ${action}`, event);
+    return;
+  }
+  let targetForHandler;
+  let keyForHandler = null;
+  if (action === "set" || action === "delete") {
+    if (path.length === 1) {
+      targetForHandler = root;
+      keyForHandler = path[0];
+    } else {
+      const parentPath = path.slice(0, -1);
+      const parentPathKey = parentPath.join(".");
+      let parent = pathCache.get(root)?.get(parentPathKey);
+      if (parent !== undefined) {
+        parent = validateCachedPath(root, parentPath, parentPathKey, parent);
+      }
+      if (parent === undefined) {
+        parent = parentPath.reduce((acc, key) => acc ? getValue(acc, key) : undefined, root);
+        if (parent !== undefined)
+          setInPathCache(root, parentPathKey, parent);
+      }
+      if (parent === undefined) {
+        console.warn(`parent path ${parentPathKey} not found for action ${action}`);
+        return;
+      }
+      targetForHandler = parent;
+      keyForHandler = path[path.length - 1];
+    }
+  } else if (action.startsWith("array-") || action.startsWith("map-") || action.startsWith("set-") || action === "replace") {
+    if (path.length === 0 && action === "replace") {
+      targetForHandler = root;
+    } else {
+      const targetPath = path;
+      const targetPathKey = targetPath.join(".");
+      let targetCollection = pathCache.get(root)?.get(targetPathKey);
+      if (targetCollection !== undefined) {
+        targetCollection = validateCachedPath(root, targetPath, targetPathKey, targetCollection);
+      }
+      if (targetCollection === undefined) {
+        targetCollection = targetPath.reduce((acc, key) => acc ? getValue(acc, key) : undefined, root);
+        if (targetCollection !== undefined)
+          setInPathCache(root, targetPathKey, targetCollection);
+      }
+      if (targetCollection === undefined) {
+        console.warn(`target at path ${targetPathKey} not found for action ${action}`);
+        return;
+      }
+      targetForHandler = targetCollection;
+    }
+  } else {
+    console.error(`unexpected action type passed checks: ${action}`);
+    return;
+  }
+  handler(targetForHandler, keyForHandler, event);
+  if (action === "set" && event.newValue != null && typeof event.newValue === "object") {
+    const fullPathKey = path.join(".");
+    evictDescendantsFromPathCache(root, fullPathKey);
+  }
+}
 // src/ref.ts
 var isRefSymbol = Symbol("isRef");
 function ref(value) {
@@ -4580,5 +6799,8 @@ export {
   createBridgeEmitter,
   computed,
   cleanupEffect,
-  activeEffect
+  activeEffect,
+  UnsupportedStateError,
+  SnapshotLimitError,
+  SNAPSHOT_SHARED_COPY_LIMIT
 };