@legendapp/state 3.0.0-alpha.1 → 3.0.0-alpha.2

package/index.js

@@ -1,2456 +1,2296 @@
 'use strict';
 
-const hasOwnProperty = Object.prototype.hasOwnProperty;
+// src/is.ts
+var hasOwnProperty = Object.prototype.hasOwnProperty;
 function isArray(obj) {
-    return Array.isArray(obj);
+  return Array.isArray(obj);
 }
 function isString(obj) {
-    return typeof obj === 'string';
+  return typeof obj === "string";
 }
 function isObject(obj) {
-    return !!obj && typeof obj === 'object' && !(obj instanceof Date) && !isArray(obj);
+  return !!obj && typeof obj === "object" && !(obj instanceof Date) && !isArray(obj);
 }
 function isFunction(obj) {
-    return typeof obj === 'function';
+  return typeof obj === "function";
 }
 function isPrimitive(arg) {
-    const type = typeof arg;
-    return arg !== undefined && (isDate(arg) || (type !== 'object' && type !== 'function'));
+  const type = typeof arg;
+  return arg !== void 0 && (isDate(arg) || type !== "object" && type !== "function");
 }
 function isDate(obj) {
-    return obj instanceof Date;
+  return obj instanceof Date;
 }
 function isSymbol(obj) {
-    return typeof obj === 'symbol';
+  return typeof obj === "symbol";
 }
 function isBoolean(obj) {
-    return typeof obj === 'boolean';
+  return typeof obj === "boolean";
 }
 function isPromise(obj) {
-    return obj instanceof Promise;
+  return obj instanceof Promise;
 }
 function isMap(obj) {
-    return obj instanceof Map;
+  return obj instanceof Map;
 }
 function isNumber(obj) {
-    const n = obj;
-    return n - n < 1;
+  const n = obj;
+  return n - n < 1;
 }
 function isEmpty(obj) {
-    // Looping and returning false on the first property is faster than Object.keys(obj).length === 0
-    // https://jsbench.me/qfkqv692c8
-    if (!obj)
-        return false;
-    if (isArray(obj))
-        return obj.length === 0;
-    for (const key in obj) {
-        if (hasOwnProperty.call(obj, key)) {
-            return false;
-        }
+  if (!obj)
+    return false;
+  if (isArray(obj))
+    return obj.length === 0;
+  for (const key in obj) {
+    if (hasOwnProperty.call(obj, key)) {
+      return false;
     }
-    return true;
+  }
+  return true;
 }
 function isNullOrUndefined(value) {
-    return value === undefined || value === null;
+  return value === void 0 || value === null;
 }
-const setPrimitives = new Set(['boolean', 'string', 'number']);
-/** @internal */
+var setPrimitives = /* @__PURE__ */ new Set(["boolean", "string", "number"]);
 function isActualPrimitive(arg) {
-    return setPrimitives.has(typeof arg);
+  return setPrimitives.has(typeof arg);
 }
-/** @internal */
 function isChildNodeValue(node) {
-    return !!node.parent;
+  return !!node.parent;
 }
 
-const symbolToPrimitive = Symbol.toPrimitive;
-const symbolGetNode = Symbol('getNode');
-const symbolDelete = /* @__PURE__ */ Symbol('delete');
-const symbolOpaque = Symbol('opaque');
-const optimized = Symbol('optimized');
-const symbolLinked = Symbol('linked');
-const globalState = {
-    isLoadingLocal: false,
-    isMerging: false,
-    isLoadingRemote: false,
-    activateSyncedNode: undefined,
-    pendingNodes: new Map(),
-    dirtyNodes: new Set(),
-    replacer: undefined,
-    reviver: undefined,
+// src/globals.ts
+var symbolToPrimitive = Symbol.toPrimitive;
+var symbolGetNode = Symbol("getNode");
+var symbolDelete = /* @__PURE__ */ Symbol("delete");
+var symbolOpaque = Symbol("opaque");
+var optimized = Symbol("optimized");
+var symbolLinked = Symbol("linked");
+var globalState = {
+  isLoadingLocal: false,
+  isMerging: false,
+  isLoadingRemote: false,
+  activateSyncedNode: void 0,
+  pendingNodes: /* @__PURE__ */ new Map(),
+  dirtyNodes: /* @__PURE__ */ new Set(),
+  replacer: void 0,
+  reviver: void 0
 };
 function getPathType(value) {
-    return isArray(value) ? 'array' : isMap(value) ? 'map' : value instanceof Set ? 'set' : 'object';
+  return isArray(value) ? "array" : isMap(value) ? "map" : value instanceof Set ? "set" : "object";
 }
 function replacer(key, value) {
-    if (isMap(value)) {
-        return {
-            __LSType: 'Map',
-            value: Array.from(value.entries()), // or with spread: value: [...value]
-        };
-    }
-    else if (value instanceof Set) {
-        return {
-            __LSType: 'Set',
-            value: Array.from(value), // or with spread: value: [...value]
-        };
-    }
-    else if (globalState.replacer) {
-        value = globalState.replacer(key, value);
-    }
-    return value;
+  if (isMap(value)) {
+    return {
+      __LSType: "Map",
+      value: Array.from(value.entries())
+      // or with spread: value: [...value]
+    };
+  } else if (value instanceof Set) {
+    return {
+      __LSType: "Set",
+      value: Array.from(value)
+      // or with spread: value: [...value]
+    };
+  } else if (globalState.replacer) {
+    value = globalState.replacer(key, value);
+  }
+  return value;
 }
-const ISO8601 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z$/;
+var ISO8601 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z$/;
 function reviver(key, value) {
-    if (value) {
-        if (typeof value === 'string' && ISO8601.test(value)) {
-            return new Date(value);
-        }
-        if (typeof value === 'object') {
-            if (value.__LSType === 'Map') {
-                return new Map(value.value);
-            }
-            else if (value.__LSType === 'Set') {
-                return new Set(value.value);
-            }
-        }
-        if (globalState.reviver) {
-            value = globalState.reviver(key, value);
-        }
+  if (value) {
+    if (typeof value === "string" && ISO8601.test(value)) {
+      return new Date(value);
     }
-    return value;
+    if (typeof value === "object") {
+      if (value.__LSType === "Map") {
+        return new Map(value.value);
+      } else if (value.__LSType === "Set") {
+        return new Set(value.value);
+      }
+    }
+    if (globalState.reviver) {
+      value = globalState.reviver(key, value);
+    }
+  }
+  return value;
 }
 function safeStringify(value) {
-    return JSON.stringify(value, replacer);
+  return JSON.stringify(value, replacer);
 }
 function safeParse(value) {
-    return JSON.parse(value, reviver);
+  return JSON.parse(value, reviver);
 }
 function clone(value) {
-    return safeParse(safeStringify(value));
+  return safeParse(safeStringify(value));
 }
 function isObservable(value$) {
-    return !!value$ && !!value$[symbolGetNode];
+  return !!value$ && !!value$[symbolGetNode];
 }
 function getNode(value$) {
-    return value$ && value$[symbolGetNode];
+  return value$ && value$[symbolGetNode];
 }
 function isEvent(value$) {
-    var _a;
-    return value$ && ((_a = value$[symbolGetNode]) === null || _a === void 0 ? void 0 : _a.isEvent);
+  var _a;
+  return value$ && ((_a = value$[symbolGetNode]) == null ? void 0 : _a.isEvent);
 }
 function setNodeValue(node, newValue) {
-    var _a, _b, _c;
-    const parentNode = (_a = node.parent) !== null && _a !== void 0 ? _a : node;
-    const key = node.parent ? node.key : '_';
-    const isDelete = newValue === symbolDelete;
-    if (isDelete)
-        newValue = undefined;
-    // Get the value of the parent
-    const parentValue = node.parent ? ensureNodeValue(parentNode) : parentNode.root;
-    // Save the previous value first
-    const prevValue = parentValue[key];
-    const isFunc = isFunction(newValue);
-    // Compute newValue if newValue is a function or an observable
-    newValue = !parentNode.isAssigning && isFunc && !isFunction(prevValue) ? newValue(prevValue) : newValue;
-    if (!globalState.isMerging ||
-        isNullOrUndefined(prevValue) ||
-        isFunction(prevValue) ||
-        !((_c = (_b = node.parent) === null || _b === void 0 ? void 0 : _b.functions) === null || _c === void 0 ? void 0 : _c.get(key))) {
-        try {
-            parentNode.isSetting = (parentNode.isSetting || 0) + 1;
-            const useMapFn = isMap(parentValue);
-            // Save the new value
-            if (isDelete) {
-                if (useMapFn) {
-                    parentValue.delete(key);
-                }
-                else {
-                    delete parentValue[key];
-                }
-            }
-            else {
-                const useMapFn = isMap(parentValue);
-                if (useMapFn) {
-                    parentValue.set(key, newValue);
-                }
-                else {
-                    parentValue[key] = newValue;
-                }
-            }
-        }
-        finally {
-            parentNode.isSetting--;
-        }
-    }
-    return { prevValue, newValue };
-}
-const arrNodeKeys = [];
+  var _a, _b, _c;
+  const parentNode = (_a = node.parent) != null ? _a : node;
+  const key = node.parent ? node.key : "_";
+  const isDelete = newValue === symbolDelete;
+  if (isDelete)
+    newValue = void 0;
+  const parentValue = node.parent ? ensureNodeValue(parentNode) : parentNode.root;
+  const prevValue = parentValue[key];
+  const isFunc = isFunction(newValue);
+  newValue = !parentNode.isAssigning && isFunc && !isFunction(prevValue) ? newValue(prevValue) : newValue;
+  if (!globalState.isMerging || isNullOrUndefined(prevValue) || isFunction(prevValue) || !((_c = (_b = node.parent) == null ? void 0 : _b.functions) == null ? void 0 : _c.get(key))) {
+    try {
+      parentNode.isSetting = (parentNode.isSetting || 0) + 1;
+      const useMapFn = isMap(parentValue);
+      if (isDelete) {
+        if (useMapFn) {
+          parentValue.delete(key);
+        } else {
+          delete parentValue[key];
+        }
+      } else {
+        const useMapFn2 = isMap(parentValue);
+        if (useMapFn2) {
+          parentValue.set(key, newValue);
+        } else {
+          parentValue[key] = newValue;
+        }
+      }
+    } finally {
+      parentNode.isSetting--;
+    }
+  }
+  return { prevValue, newValue };
+}
+var arrNodeKeys = [];
 function getNodeValue(node) {
-    let count = 0;
-    let n = node;
-    while (isChildNodeValue(n)) {
-        arrNodeKeys[count++] = n.key;
-        n = n.parent;
-    }
-    let child = node.root._;
-    for (let i = count - 1; child && i >= 0; i--) {
-        const key = arrNodeKeys[i];
-        child = key !== 'size' && (isMap(child) || child instanceof WeakMap) ? child.get(key) : child[key];
-    }
-    return child;
+  let count = 0;
+  let n = node;
+  while (isChildNodeValue(n)) {
+    arrNodeKeys[count++] = n.key;
+    n = n.parent;
+  }
+  let child = node.root._;
+  for (let i = count - 1; child && i >= 0; i--) {
+    const key = arrNodeKeys[i];
+    child = key !== "size" && (isMap(child) || child instanceof WeakMap) ? child.get(key) : child[key];
+  }
+  return child;
 }
 function getChildNode(node, key, asFunction) {
-    var _a, _b;
-    // Get the child by key
-    let child = (_a = node.children) === null || _a === void 0 ? void 0 : _a.get(key);
-    // Create the child node if it doesn't already exist
-    if (!child) {
-        child = {
-            root: node.root,
-            parent: node,
-            key,
-            lazy: true,
-            numListenersRecursive: 0,
-        };
-        // Lookup functions are bound with the child key
-        if (((_b = node.lazyFn) === null || _b === void 0 ? void 0 : _b.length) === 1) {
-            asFunction = node.lazyFn.bind(node, key);
-        }
-        if (isFunction(asFunction)) {
-            child = Object.assign(() => { }, child);
-            child.lazyFn = asFunction;
-        }
-        if (!node.children) {
-            node.children = new Map();
-        }
-        node.children.set(key, child);
+  var _a, _b;
+  let child = (_a = node.children) == null ? void 0 : _a.get(key);
+  if (!child) {
+    child = {
+      root: node.root,
+      parent: node,
+      key,
+      lazy: true,
+      numListenersRecursive: 0
+    };
+    if (((_b = node.lazyFn) == null ? void 0 : _b.length) === 1) {
+      asFunction = node.lazyFn.bind(node, key);
     }
-    return child;
+    if (isFunction(asFunction)) {
+      child = Object.assign(() => {
+      }, child);
+      child.lazyFn = asFunction;
+    }
+    if (!node.children) {
+      node.children = /* @__PURE__ */ new Map();
+    }
+    node.children.set(key, child);
+  }
+  return child;
 }
 function ensureNodeValue(node) {
-    let value = getNodeValue(node);
-    if (!value || isFunction(value)) {
-        if (isChildNodeValue(node)) {
-            const parent = ensureNodeValue(node.parent);
-            value = parent[node.key] = {};
-        }
-        else {
-            value = node.root._ = {};
-        }
+  let value = getNodeValue(node);
+  if (!value || isFunction(value)) {
+    if (isChildNodeValue(node)) {
+      const parent = ensureNodeValue(node.parent);
+      value = parent[node.key] = {};
+    } else {
+      value = node.root._ = {};
     }
-    return value;
+  }
+  return value;
 }
 function findIDKey(obj, node) {
-    var _a, _b;
-    let idKey = isObservable(obj)
-        ? undefined
-        : isObject(obj)
-            ? 'id' in obj
-                ? 'id'
-                : 'key' in obj
-                    ? 'key'
-                    : '_id' in obj
-                        ? '_id'
-                        : '__id' in obj
-                            ? '__id'
-                            : undefined
-            : undefined;
-    if (!idKey && node.parent) {
-        const k = node.key + '_keyExtractor';
-        const keyExtractor = (_b = (_a = node.functions) === null || _a === void 0 ? void 0 : _a.get(k)) !== null && _b !== void 0 ? _b : getNodeValue(node.parent)[node.key + '_keyExtractor'];
-        if (keyExtractor && isFunction(keyExtractor)) {
-            idKey = keyExtractor;
-        }
+  var _a, _b;
+  let idKey = isObservable(obj) ? void 0 : isObject(obj) ? "id" in obj ? "id" : "key" in obj ? "key" : "_id" in obj ? "_id" : "__id" in obj ? "__id" : void 0 : void 0;
+  if (!idKey && node.parent) {
+    const k = node.key + "_keyExtractor";
+    const keyExtractor = (_b = (_a = node.functions) == null ? void 0 : _a.get(k)) != null ? _b : getNodeValue(node.parent)[node.key + "_keyExtractor"];
+    if (keyExtractor && isFunction(keyExtractor)) {
+      idKey = keyExtractor;
     }
-    return idKey;
+  }
+  return idKey;
 }
 function extractFunction(node, key, fnOrComputed) {
-    if (!node.functions) {
-        node.functions = new Map();
-    }
-    node.functions.set(key, fnOrComputed);
+  if (!node.functions) {
+    node.functions = /* @__PURE__ */ new Map();
+  }
+  node.functions.set(key, fnOrComputed);
 }
 function equals(a, b) {
-    return a === b || (isDate(a) && isDate(b) && +a === +b);
+  return a === b || isDate(a) && isDate(b) && +a === +b;
 }
 
+// src/helpers.ts
 function computeSelector(selector, e, retainObservable) {
-    let c = selector;
-    if (!isObservable(c) && isFunction(c)) {
-        c = e ? c(e) : c();
-    }
-    return isObservable(c) && !retainObservable ? c.get() : c;
+  let c = selector;
+  if (!isObservable(c) && isFunction(c)) {
+    c = e ? c(e) : c();
+  }
+  return isObservable(c) && !retainObservable ? c.get() : c;
 }
 function getObservableIndex(value$) {
-    const node = getNode(value$);
-    const n = +node.key;
-    return isNumber(n) ? n : -1;
+  const node = getNode(value$);
+  const n = +node.key;
+  return isNumber(n) ? n : -1;
 }
 function opaqueObject(value) {
-    if (value) {
-        value[symbolOpaque] = true;
-    }
-    return value;
+  if (value) {
+    value[symbolOpaque] = true;
+  }
+  return value;
 }
-const getValueAtPathReducer = (o, p) => o && o[p];
-function getValueAtPath$1(obj, path) {
-    return path.reduce(getValueAtPathReducer, obj);
+var getValueAtPathReducer = (o, p) => o && o[p];
+function getValueAtPath(obj, path) {
+  return path.reduce(getValueAtPathReducer, obj);
 }
 function setAtPath(obj, path, pathTypes, value, mode, fullObj, restore) {
-    let p = undefined;
-    let o = obj;
-    if (path.length > 0) {
-        let oFull = fullObj;
-        for (let i = 0; i < path.length; i++) {
-            p = path[i];
-            if (o[p] === symbolDelete) {
-                // If this was previously deleted, restore it
-                if (oFull) {
-                    o[p] = oFull[p];
-                    restore === null || restore === void 0 ? void 0 : restore(path.slice(0, i + 1), o[p]);
-                }
-                return obj;
-            }
-            else if (o[p] === undefined && value === undefined && i === path.length - 1) {
-                // If setting undefined and the key is undefined, no need to initialize or set it
-                return obj;
-            }
-            else if (o[p] === undefined || o[p] === null) {
-                o[p] = initializePathType(pathTypes[i]);
-            }
-            if (i < path.length - 1) {
-                o = o[p];
-                if (oFull) {
-                    oFull = oFull[p];
-                }
-            }
+  let p = void 0;
+  let o = obj;
+  if (path.length > 0) {
+    let oFull = fullObj;
+    for (let i = 0; i < path.length; i++) {
+      p = path[i];
+      if (o[p] === symbolDelete) {
+        if (oFull) {
+          o[p] = oFull[p];
+          restore == null ? void 0 : restore(path.slice(0, i + 1), o[p]);
+        }
+        return obj;
+      } else if (o[p] === void 0 && value === void 0 && i === path.length - 1) {
+        return obj;
+      } else if (o[p] === void 0 || o[p] === null) {
+        o[p] = initializePathType(pathTypes[i]);
+      }
+      if (i < path.length - 1) {
+        o = o[p];
+        if (oFull) {
+          oFull = oFull[p];
         }
+      }
     }
-    // Don't set if the value is the same. This prevents creating a new key
-    // when setting undefined on an object without this key
-    if (p === undefined) {
-        if (mode === 'merge') {
-            obj = _mergeIntoObservable(obj, value);
-        }
-        else {
-            obj = value;
-        }
+  }
+  if (p === void 0) {
+    if (mode === "merge") {
+      obj = _mergeIntoObservable(obj, value);
+    } else {
+      obj = value;
     }
-    else {
-        if (mode === 'merge') {
-            o[p] = _mergeIntoObservable(o[p], value);
-        }
-        else if (isMap(o)) {
-            o.set(p, value);
-        }
-        else {
-            o[p] = value;
-        }
+  } else {
+    if (mode === "merge") {
+      o[p] = _mergeIntoObservable(o[p], value);
+    } else if (isMap(o)) {
+      o.set(p, value);
+    } else {
+      o[p] = value;
     }
-    return obj;
+  }
+  return obj;
 }
 function setInObservableAtPath(value$, path, pathTypes, value, mode) {
-    let o = value$;
-    let v = value;
-    for (let i = 0; i < path.length; i++) {
-        const p = path[i];
-        if (!o.peek()[p]) {
-            o[p].set(initializePathType(pathTypes[i]));
-        }
-        o = o[p];
-        v = v[p];
-    }
-    if (v === symbolDelete) {
-        o.delete();
-    }
-    // Assign if possible, or set otherwise
-    else if (mode === 'assign' && o.assign && isObject(o.peek())) {
-        o.assign(v);
-    }
-    else if (mode === 'merge') {
-        mergeIntoObservable(o, v);
-    }
-    else {
-        o.set(v);
-    }
+  let o = value$;
+  let v = value;
+  for (let i = 0; i < path.length; i++) {
+    const p = path[i];
+    if (!o.peek()[p]) {
+      o[p].set(initializePathType(pathTypes[i]));
+    }
+    o = o[p];
+    v = v[p];
+  }
+  if (v === symbolDelete) {
+    o.delete();
+  } else if (mode === "assign" && o.assign && isObject(o.peek())) {
+    o.assign(v);
+  } else if (mode === "merge") {
+    mergeIntoObservable(o, v);
+  } else {
+    o.set(v);
+  }
 }
 function mergeIntoObservable(target, ...sources) {
-    beginBatch();
-    globalState.isMerging = true;
-    for (let i = 0; i < sources.length; i++) {
-        target = _mergeIntoObservable(target, sources[i]);
-    }
-    globalState.isMerging = false;
-    endBatch();
-    return target;
+  beginBatch();
+  globalState.isMerging = true;
+  for (let i = 0; i < sources.length; i++) {
+    target = _mergeIntoObservable(target, sources[i]);
+  }
+  globalState.isMerging = false;
+  endBatch();
+  return target;
 }
 function _mergeIntoObservable(target, source) {
-    var _a;
-    if (isObservable(source)) {
-        source = source.peek();
-    }
-    const needsSet = isObservable(target);
-    const targetValue = needsSet ? target.peek() : target;
-    const isTargetArr = isArray(targetValue);
-    const isTargetObj = !isTargetArr && isObject(targetValue);
-    if ((isTargetObj && isObject(source) && !isEmpty(targetValue)) || (isTargetArr && targetValue.length > 0)) {
-        const keys = Object.keys(source);
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            const sourceValue = source[key];
-            if (sourceValue === symbolDelete) {
-                needsSet && ((_a = target[key]) === null || _a === void 0 ? void 0 : _a.delete)
-                    ? target[key].delete()
-                    : delete target[key];
-            }
-            else {
-                const isObj = isObject(sourceValue);
-                const isArr = !isObj && isArray(sourceValue);
-                const targetChild = target[key];
-                if ((isObj || isArr) && targetChild && (needsSet || !isEmpty(targetChild))) {
-                    if (!needsSet && (!targetChild || (isObj ? !isObject(targetChild) : !isArray(targetChild)))) {
-                        target[key] = sourceValue;
-                    }
-                    else {
-                        _mergeIntoObservable(targetChild, sourceValue);
-                    }
-                }
-                else {
-                    needsSet
-                        ? targetChild.set(sourceValue)
-                        : (target[key] = sourceValue);
-                }
-            }
-        }
-    }
-    else if (source !== undefined) {
-        needsSet ? target.set(source) : (target = source);
-    }
-    return target;
+  var _a;
+  if (isObservable(source)) {
+    source = source.peek();
+  }
+  const needsSet = isObservable(target);
+  const targetValue = needsSet ? target.peek() : target;
+  const isTargetArr = isArray(targetValue);
+  const isTargetObj = !isTargetArr && isObject(targetValue);
+  if (isTargetObj && isObject(source) && !isEmpty(targetValue) || isTargetArr && targetValue.length > 0) {
+    const keys = Object.keys(source);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const sourceValue = source[key];
+      if (sourceValue === symbolDelete) {
+        needsSet && ((_a = target[key]) == null ? void 0 : _a.delete) ? target[key].delete() : delete target[key];
+      } else {
+        const isObj = isObject(sourceValue);
+        const isArr = !isObj && isArray(sourceValue);
+        const targetChild = target[key];
+        if ((isObj || isArr) && targetChild && (needsSet || !isEmpty(targetChild))) {
+          if (!needsSet && (!targetChild || (isObj ? !isObject(targetChild) : !isArray(targetChild)))) {
+            target[key] = sourceValue;
+          } else {
+            _mergeIntoObservable(targetChild, sourceValue);
+          }
+        } else {
+          needsSet ? targetChild.set(sourceValue) : target[key] = sourceValue;
+        }
+      }
+    }
+  } else if (source !== void 0) {
+    needsSet ? target.set(source) : target = source;
+  }
+  return target;
 }
 function constructObjectWithPath(path, pathTypes, value) {
-    let out;
-    if (path.length > 0) {
-        let o = (out = {});
-        for (let i = 0; i < path.length; i++) {
-            const p = path[i];
-            o[p] = i === path.length - 1 ? value : initializePathType(pathTypes[i]);
-            o = o[p];
-        }
-    }
-    else {
-        out = value;
+  let out;
+  if (path.length > 0) {
+    let o = out = {};
+    for (let i = 0; i < path.length; i++) {
+      const p = path[i];
+      o[p] = i === path.length - 1 ? value : initializePathType(pathTypes[i]);
+      o = o[p];
     }
-    return out;
+  } else {
+    out = value;
+  }
+  return out;
 }
 function deconstructObjectWithPath(path, pathTypes, value) {
-    let o = value;
-    for (let i = 0; i < path.length; i++) {
-        const p = path[i];
-        o = o ? o[p] : initializePathType(pathTypes[i]);
-    }
-    return o;
+  let o = value;
+  for (let i = 0; i < path.length; i++) {
+    const p = path[i];
+    o = o ? o[p] : initializePathType(pathTypes[i]);
+  }
+  return o;
 }
 function isObservableValueReady(value) {
-    return !!value && ((!isObject(value) && !isArray(value)) || !isEmpty(value));
+  return !!value && (!isObject(value) && !isArray(value) || !isEmpty(value));
 }
 function setSilently(value$, newValue) {
-    const node = getNode(value$);
-    return setNodeValue(node, newValue).newValue;
+  const node = getNode(value$);
+  return setNodeValue(node, newValue).newValue;
 }
 function initializePathType(pathType) {
-    switch (pathType) {
-        case 'array':
-            return [];
-        case 'object':
-            return {};
-        case 'map':
-            return new Map();
-        case 'set':
-            return new Set();
-    }
+  switch (pathType) {
+    case "array":
+      return [];
+    case "object":
+      return {};
+    case "map":
+      return /* @__PURE__ */ new Map();
+    case "set":
+      return /* @__PURE__ */ new Set();
+  }
 }
 function applyChange(value, change, applyPrevious) {
-    const { path, valueAtPath, prevAtPath, pathTypes } = change;
-    return setAtPath(value, path, pathTypes, applyPrevious ? prevAtPath : valueAtPath);
+  const { path, valueAtPath, prevAtPath, pathTypes } = change;
+  return setAtPath(value, path, pathTypes, applyPrevious ? prevAtPath : valueAtPath);
 }
 function applyChanges(value, changes, applyPrevious) {
-    for (let i = 0; i < changes.length; i++) {
-        value = applyChange(value, changes[i], applyPrevious);
-    }
-    return value;
+  for (let i = 0; i < changes.length; i++) {
+    value = applyChange(value, changes[i], applyPrevious);
+  }
+  return value;
 }
 
-let timeout;
-let numInBatch = 0;
-let isRunningBatch = false;
-let didDelayEndBatch = false;
-let _batchMap = new Map();
+// src/batching.ts
+var timeout;
+var numInBatch = 0;
+var isRunningBatch = false;
+var didDelayEndBatch = false;
+var _batchMap = /* @__PURE__ */ new Map();
 function onActionTimeout() {
-    if (_batchMap.size > 0) {
-        if (process.env.NODE_ENV === 'development') {
-            console.error('Forcibly completing observableBatcher because end() was never called. This may be due to an uncaught error between begin() and end().');
-        }
-        endBatch(/*force*/ true);
-    }
+  if (_batchMap.size > 0) {
+    if (process.env.NODE_ENV === "development") {
+      console.error(
+        "Forcibly completing observableBatcher because end() was never called. This may be due to an uncaught error between begin() and end()."
+      );
+    }
+    endBatch(
+      /*force*/
+      true
+    );
+  }
 }
 function isArraySubset(mainArr, subsetArr) {
-    for (let i = 0; i < mainArr.length; i++) {
-        if (mainArr[i] !== subsetArr[i]) {
-            return false;
-        }
+  for (let i = 0; i < mainArr.length; i++) {
+    if (mainArr[i] !== subsetArr[i]) {
+      return false;
     }
-    return true;
+  }
+  return true;
 }
 function createPreviousHandlerInner(value, changes) {
-    try {
-        // Clones the current state and inject the previous data at the changed path
-        return applyChanges(value ? clone(value) : {}, changes, true);
-    }
-    catch (_a) {
-        return undefined;
-    }
+  try {
+    return applyChanges(value ? clone(value) : {}, changes, true);
+  } catch (e) {
+    return void 0;
+  }
 }
 function createPreviousHandler(value, changes) {
-    // Create a function that generates the previous state
-    // We don't want to always do this because cloning is expensive
-    // so it's better to run on demand.
-    return function () {
-        return createPreviousHandlerInner(value, changes);
-    };
+  return function() {
+    return createPreviousHandlerInner(value, changes);
+  };
 }
 function notify(node, value, prev, level, whenOptimizedOnlyIf) {
-    // Run immediate listeners if there are any
-    const changesInBatch = new Map();
-    computeChangesRecursive(changesInBatch, node, 
-    /*loading*/ globalState.isLoadingLocal, 
-    /*remote*/ globalState.isLoadingRemote, value, [], [], value, prev, 
-    /*immediate*/ true, level, whenOptimizedOnlyIf);
-    if (changesInBatch.size) {
-        batchNotifyChanges(changesInBatch, /*immediate*/ true);
-    }
-    // Update the current batch
-    const existing = _batchMap.get(node);
-    if (existing) {
-        existing.value = value;
-        // TODO: level, whenOptimizedOnlyIf
-    }
-    else {
-        _batchMap.set(node, {
-            value,
-            prev,
-            level,
-            whenOptimizedOnlyIf,
-            remote: globalState.isLoadingRemote,
-            loading: globalState.isLoadingLocal,
-        });
-    }
-    // If not in a batch run it immediately
-    if (numInBatch <= 0) {
-        runBatch();
-    }
+  const changesInBatch = /* @__PURE__ */ new Map();
+  computeChangesRecursive(
+    changesInBatch,
+    node,
+    /*loading*/
+    globalState.isLoadingLocal,
+    /*remote*/
+    globalState.isLoadingRemote,
+    value,
+    [],
+    [],
+    value,
+    prev,
+    /*immediate*/
+    true,
+    level,
+    whenOptimizedOnlyIf
+  );
+  if (changesInBatch.size) {
+    batchNotifyChanges(
+      changesInBatch,
+      /*immediate*/
+      true
+    );
+  }
+  const existing = _batchMap.get(node);
+  if (existing) {
+    existing.value = value;
+  } else {
+    _batchMap.set(node, {
+      value,
+      prev,
+      level,
+      whenOptimizedOnlyIf,
+      remote: globalState.isLoadingRemote,
+      loading: globalState.isLoadingLocal
+    });
+  }
+  if (numInBatch <= 0) {
+    runBatch();
+  }
 }
 function computeChangesAtNode(changesInBatch, node, loading, remote, value, path, pathTypes, valueAtPath, prevAtPath, immediate, level, whenOptimizedOnlyIf) {
-    // If there are listeners at this node compute the changes that need to be run
-    if (immediate ? node.listenersImmediate : node.listeners) {
-        const change = {
-            path,
-            pathTypes,
-            valueAtPath,
-            prevAtPath,
-        };
-        const changeInBatch = changesInBatch.get(node);
-        // If the node itself has been changed then we can ignore all the child changes
-        if (changeInBatch && path.length > 0) {
-            const { changes } = changeInBatch;
-            if (!isArraySubset(changes[0].path, change.path)) {
-                changes.push(change);
-            }
-        }
-        else {
-            changesInBatch.set(node, {
-                level,
-                value,
-                remote,
-                loading,
-                whenOptimizedOnlyIf,
-                changes: [change],
-            });
-        }
-    }
+  if (immediate ? node.listenersImmediate : node.listeners) {
+    const change = {
+      path,
+      pathTypes,
+      valueAtPath,
+      prevAtPath
+    };
+    const changeInBatch = changesInBatch.get(node);
+    if (changeInBatch && path.length > 0) {
+      const { changes } = changeInBatch;
+      if (!isArraySubset(changes[0].path, change.path)) {
+        changes.push(change);
+      }
+    } else {
+      changesInBatch.set(node, {
+        level,
+        value,
+        remote,
+        loading,
+        whenOptimizedOnlyIf,
+        changes: [change]
+      });
+    }
+  }
 }
 function computeChangesRecursive(changesInBatch, node, loading, remote, value, path, pathTypes, valueAtPath, prevAtPath, immediate, level, whenOptimizedOnlyIf) {
-    // Do the compute at this node
-    computeChangesAtNode(changesInBatch, node, loading, remote, value, path, pathTypes, valueAtPath, prevAtPath, immediate, level, whenOptimizedOnlyIf);
-    if (node.linkedFromNodes) {
-        for (const linkedFromNode of node.linkedFromNodes) {
-            const childNode = getNodeAtPath(linkedFromNode, path);
-            computeChangesRecursive(changesInBatch, childNode, loading, remote, valueAtPath, [], [], valueAtPath, prevAtPath, immediate, 0, whenOptimizedOnlyIf);
-        }
-    }
-    // If not root notify up through parents
-    if (node.parent) {
-        const parent = node.parent;
-        if (parent) {
-            const parentValue = getNodeValue(parent);
-            computeChangesRecursive(changesInBatch, parent, loading, remote, parentValue, [node.key].concat(path), [getPathType(value)].concat(pathTypes), valueAtPath, prevAtPath, immediate, level + 1, whenOptimizedOnlyIf);
-        }
-    }
+  computeChangesAtNode(
+    changesInBatch,
+    node,
+    loading,
+    remote,
+    value,
+    path,
+    pathTypes,
+    valueAtPath,
+    prevAtPath,
+    immediate,
+    level,
+    whenOptimizedOnlyIf
+  );
+  if (node.linkedFromNodes) {
+    for (const linkedFromNode of node.linkedFromNodes) {
+      const childNode = getNodeAtPath(linkedFromNode, path);
+      computeChangesRecursive(
+        changesInBatch,
+        childNode,
+        loading,
+        remote,
+        valueAtPath,
+        [],
+        [],
+        valueAtPath,
+        prevAtPath,
+        immediate,
+        0,
+        whenOptimizedOnlyIf
+      );
+    }
+  }
+  if (node.parent) {
+    const parent = node.parent;
+    if (parent) {
+      const parentValue = getNodeValue(parent);
+      computeChangesRecursive(
+        changesInBatch,
+        parent,
+        loading,
+        remote,
+        parentValue,
+        [node.key].concat(path),
+        [getPathType(value)].concat(pathTypes),
+        valueAtPath,
+        prevAtPath,
+        immediate,
+        level + 1,
+        whenOptimizedOnlyIf
+      );
+    }
+  }
 }
 function batchNotifyChanges(changesInBatch, immediate) {
-    const listenersNotified = new Set();
-    // For each change in the batch, notify all of the listeners
-    changesInBatch.forEach(({ changes, level, value, loading, remote, whenOptimizedOnlyIf }, node) => {
-        const listeners = immediate ? node.listenersImmediate : node.listeners;
-        if (listeners) {
-            let listenerParams;
-            // Need to convert to an array here instead of using a for...of loop because listeners can change while iterating
-            const arr = Array.from(listeners);
-            for (let i = 0; i < arr.length; i++) {
-                const listenerFn = arr[i];
-                const { track, noArgs, listener } = listenerFn;
-                if (!listenersNotified.has(listener)) {
-                    const ok = track === true ? level <= 0 : track === optimized ? whenOptimizedOnlyIf && level <= 0 : true;
-                    // Notify if listener is not shallow or if this is the first level
-                    if (ok) {
-                        // Create listenerParams if not already created
-                        if (!noArgs && !listenerParams) {
-                            listenerParams = {
-                                value,
-                                loading,
-                                remote,
-                                getPrevious: createPreviousHandler(value, changes),
-                                changes,
-                            };
-                        }
-                        if (!track) {
-                            listenersNotified.add(listener);
-                        }
-                        listener(listenerParams);
-                    }
-                }
+  const listenersNotified = /* @__PURE__ */ new Set();
+  changesInBatch.forEach(({ changes, level, value, loading, remote, whenOptimizedOnlyIf }, node) => {
+    const listeners = immediate ? node.listenersImmediate : node.listeners;
+    if (listeners) {
+      let listenerParams;
+      const arr = Array.from(listeners);
+      for (let i = 0; i < arr.length; i++) {
+        const listenerFn = arr[i];
+        const { track, noArgs, listener } = listenerFn;
+        if (!listenersNotified.has(listener)) {
+          const ok = track === true ? level <= 0 : track === optimized ? whenOptimizedOnlyIf && level <= 0 : true;
+          if (ok) {
+            if (!noArgs && !listenerParams) {
+              listenerParams = {
+                value,
+                loading,
+                remote,
+                getPrevious: createPreviousHandler(value, changes),
+                changes
+              };
             }
+            if (!track) {
+              listenersNotified.add(listener);
+            }
+            listener(listenerParams);
+          }
         }
-    });
+      }
+    }
+  });
 }
 function runBatch() {
-    const dirtyNodes = Array.from(globalState.dirtyNodes);
-    globalState.dirtyNodes.clear();
-    dirtyNodes.forEach((node) => {
-        const dirtyFn = node.dirtyFn;
-        if (dirtyFn) {
-            node.dirtyFn = undefined;
-            dirtyFn();
-        }
-    });
-    // Save batch locally and reset _batchMap first because a new batch could begin while looping over callbacks.
-    // This can happen with computeds for example.
-    const map = _batchMap;
-    _batchMap = new Map();
-    const changesInBatch = new Map();
-    // First compute all of the changes at each node. It's important to do this first before
-    // running all the notifications because createPreviousHandler depends on knowing
-    // all of the changes happening at the node.
-    map.forEach(({ value, prev, level, loading, remote, whenOptimizedOnlyIf }, node) => {
-        computeChangesRecursive(changesInBatch, node, loading, remote, value, [], [], value, prev, false, level, whenOptimizedOnlyIf);
-    });
-    // Once all changes are computed, notify all listeners for each node with the computed changes.
-    if (changesInBatch.size) {
-        batchNotifyChanges(changesInBatch, false);
-    }
+  const dirtyNodes = Array.from(globalState.dirtyNodes);
+  globalState.dirtyNodes.clear();
+  dirtyNodes.forEach((node) => {
+    const dirtyFn = node.dirtyFn;
+    if (dirtyFn) {
+      node.dirtyFn = void 0;
+      dirtyFn();
+    }
+  });
+  const map = _batchMap;
+  _batchMap = /* @__PURE__ */ new Map();
+  const changesInBatch = /* @__PURE__ */ new Map();
+  map.forEach(({ value, prev, level, loading, remote, whenOptimizedOnlyIf }, node) => {
+    computeChangesRecursive(
+      changesInBatch,
+      node,
+      loading,
+      remote,
+      value,
+      [],
+      [],
+      value,
+      prev,
+      false,
+      level,
+      whenOptimizedOnlyIf
+    );
+  });
+  if (changesInBatch.size) {
+    batchNotifyChanges(changesInBatch, false);
+  }
 }
 function batch(fn) {
-    beginBatch();
-    try {
-        fn();
-    }
-    finally {
-        endBatch();
-    }
+  beginBatch();
+  try {
+    fn();
+  } finally {
+    endBatch();
+  }
 }
 function beginBatch() {
-    numInBatch++;
-    if (!timeout) {
-        timeout = setTimeout(onActionTimeout, 0);
-    }
+  numInBatch++;
+  if (!timeout) {
+    timeout = setTimeout(onActionTimeout, 0);
+  }
 }
 function endBatch(force) {
-    numInBatch--;
-    if (numInBatch <= 0 || force) {
-        if (isRunningBatch) {
-            // Don't want to run multiple endBatches recursively, so just note that an endBatch
-            // was delayed so that the top level endBatch will run endBatch again after it's done.
-            didDelayEndBatch = true;
-        }
-        else {
-            if (timeout) {
-                clearTimeout(timeout);
-                timeout = undefined;
-            }
-            numInBatch = 0;
-            isRunningBatch = true;
-            runBatch();
-            isRunningBatch = false;
-            // If an endBatch was delayed run it now
-            if (didDelayEndBatch) {
-                didDelayEndBatch = false;
-                endBatch(true);
-            }
-        }
-    }
+  numInBatch--;
+  if (numInBatch <= 0 || force) {
+    if (isRunningBatch) {
+      didDelayEndBatch = true;
+    } else {
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = void 0;
+      }
+      numInBatch = 0;
+      isRunningBatch = true;
+      runBatch();
+      isRunningBatch = false;
+      if (didDelayEndBatch) {
+        didDelayEndBatch = false;
+        endBatch(true);
+      }
+    }
+  }
 }
 function getNodeAtPath(obj, path) {
-    let o = obj;
-    for (let i = 0; i < path.length; i++) {
-        const p = path[i];
-        o = getChildNode(o, p);
-    }
-    return o;
+  let o = obj;
+  for (let i = 0; i < path.length; i++) {
+    const p = path[i];
+    o = getChildNode(o, p);
+  }
+  return o;
 }
 
+// src/linked.ts
 function linked(params, options) {
-    if (isFunction(params)) {
-        params = { get: params };
-    }
-    if (options) {
-        params = { ...params, ...options };
-    }
-    const ret = function () {
-        return { [symbolLinked]: params };
-    };
-    ret.prototype[symbolLinked] = params;
-    return ret;
+  if (isFunction(params)) {
+    params = { get: params };
+  }
+  if (options) {
+    params = { ...params, ...options };
+  }
+  const ret = function() {
+    return { [symbolLinked]: params };
+  };
+  ret.prototype[symbolLinked] = params;
+  return ret;
 }
 
-function createObservable(value, makePrimitive, extractPromise, createObject, createPrimitive) {
-    if (isObservable(value)) {
-        return value;
-    }
-    const valueIsPromise = isPromise(value);
-    const valueIsFunction = isFunction(value);
-    const root = {
-        _: value,
-    };
-    let node = {
-        root,
-        lazy: true,
-        numListenersRecursive: 0,
-    };
-    if (valueIsFunction) {
-        node = Object.assign(() => { }, node);
-        node.lazyFn = value;
-    }
-    const prim = makePrimitive || isActualPrimitive(value);
-    const obs = prim
-        ? new createPrimitive(node)
-        : createObject(node);
-    if (valueIsPromise) {
-        setNodeValue(node, undefined);
-        extractPromise(node, value);
-    }
-    return obs;
+// src/createObservable.ts
+function createObservable(value, makePrimitive, extractPromise2, createObject, createPrimitive) {
+  if (isObservable(value)) {
+    return value;
+  }
+  const valueIsPromise = isPromise(value);
+  const valueIsFunction = isFunction(value);
+  const root = {
+    _: value
+  };
+  let node = {
+    root,
+    lazy: true,
+    numListenersRecursive: 0
+  };
+  if (valueIsFunction) {
+    node = Object.assign(() => {
+    }, node);
+    node.lazyFn = value;
+  }
+  const prim = makePrimitive || isActualPrimitive(value);
+  const obs = prim ? new createPrimitive(node) : createObject(node);
+  if (valueIsPromise) {
+    setNodeValue(node, void 0);
+    extractPromise2(node, value);
+  }
+  return obs;
 }
 
+// src/onChange.ts
 function onChange(node, callback, options = {}, fromLinks) {
-    var _a;
-    const { initial, immediate, noArgs } = options;
-    const { trackingType } = options;
-    let listeners = immediate ? node.listenersImmediate : node.listeners;
-    if (!listeners) {
-        listeners = new Set();
-        if (immediate) {
-            node.listenersImmediate = listeners;
-        }
-        else {
-            node.listeners = listeners;
-        }
-    }
-    const listener = {
-        listener: callback,
-        track: trackingType,
-        noArgs,
-    };
-    listeners.add(listener);
-    if (initial) {
-        const value = getNodeValue(node);
-        callback({
-            value,
-            loading: true,
-            remote: false,
-            changes: [
-                {
-                    path: [],
-                    pathTypes: [],
-                    prevAtPath: value,
-                    valueAtPath: value,
-                },
-            ],
-            getPrevious: () => undefined,
-        });
-    }
-    let extraDisposes;
-    function addLinkedNodeListeners(childNode, cb = callback, from) {
-        // Don't add listeners for the same node more than once
-        if (!(fromLinks === null || fromLinks === void 0 ? void 0 : fromLinks.has(childNode))) {
-            fromLinks || (fromLinks = new Set());
-            fromLinks.add(from || node);
-            cb || (cb = callback);
-            const childOptions = {
-                trackingType: true,
-                ...options,
-            };
-            // onChange for the linked node
-            extraDisposes = [...(extraDisposes || []), onChange(childNode, cb, childOptions, fromLinks)];
-        }
-    }
-    // Add listeners for linked to nodes
-    if (node.linkedToNode) {
-        addLinkedNodeListeners(node.linkedToNode);
-    }
-    // Add listeners for linked from nodes
-    (_a = node.linkedFromNodes) === null || _a === void 0 ? void 0 : _a.forEach((linkedFromNode) => addLinkedNodeListeners(linkedFromNode));
-    // Go up through the parents and add listeners for linked from nodes
-    node.numListenersRecursive++;
-    let parent = node.parent;
-    let pathParent = [node.key];
-    while (parent) {
-        if (parent.linkedFromNodes) {
-            for (const linkedFromNode of parent.linkedFromNodes) {
-                if (!(fromLinks === null || fromLinks === void 0 ? void 0 : fromLinks.has(linkedFromNode))) {
-                    const cb = createCb(linkedFromNode, pathParent, callback);
-                    addLinkedNodeListeners(linkedFromNode, cb, parent);
-                }
-            }
-        }
-        parent.numListenersRecursive++;
-        pathParent = [parent.key, ...pathParent];
-        parent = parent.parent;
-    }
-    return () => {
-        listeners.delete(listener);
-        extraDisposes === null || extraDisposes === void 0 ? void 0 : extraDisposes.forEach((fn) => fn());
-        let parent = node;
-        while (parent) {
-            parent.numListenersRecursive--;
-            parent = parent.parent;
-        }
-    };
+  var _a;
+  const { initial, immediate, noArgs } = options;
+  const { trackingType } = options;
+  let listeners = immediate ? node.listenersImmediate : node.listeners;
+  if (!listeners) {
+    listeners = /* @__PURE__ */ new Set();
+    if (immediate) {
+      node.listenersImmediate = listeners;
+    } else {
+      node.listeners = listeners;
+    }
+  }
+  const listener = {
+    listener: callback,
+    track: trackingType,
+    noArgs
+  };
+  listeners.add(listener);
+  if (initial) {
+    const value = getNodeValue(node);
+    callback({
+      value,
+      loading: true,
+      remote: false,
+      changes: [
+        {
+          path: [],
+          pathTypes: [],
+          prevAtPath: value,
+          valueAtPath: value
+        }
+      ],
+      getPrevious: () => void 0
+    });
+  }
+  let extraDisposes;
+  function addLinkedNodeListeners(childNode, cb = callback, from) {
+    if (!(fromLinks == null ? void 0 : fromLinks.has(childNode))) {
+      fromLinks || (fromLinks = /* @__PURE__ */ new Set());
+      fromLinks.add(from || node);
+      cb || (cb = callback);
+      const childOptions = {
+        trackingType: true,
+        ...options
+      };
+      extraDisposes = [...extraDisposes || [], onChange(childNode, cb, childOptions, fromLinks)];
+    }
+  }
+  if (node.linkedToNode) {
+    addLinkedNodeListeners(node.linkedToNode);
+  }
+  (_a = node.linkedFromNodes) == null ? void 0 : _a.forEach((linkedFromNode) => addLinkedNodeListeners(linkedFromNode));
+  node.numListenersRecursive++;
+  let parent = node.parent;
+  let pathParent = [node.key];
+  while (parent) {
+    if (parent.linkedFromNodes) {
+      for (const linkedFromNode of parent.linkedFromNodes) {
+        if (!(fromLinks == null ? void 0 : fromLinks.has(linkedFromNode))) {
+          const cb = createCb(linkedFromNode, pathParent, callback);
+          addLinkedNodeListeners(linkedFromNode, cb, parent);
+        }
+      }
+    }
+    parent.numListenersRecursive++;
+    pathParent = [parent.key, ...pathParent];
+    parent = parent.parent;
+  }
+  return () => {
+    listeners.delete(listener);
+    extraDisposes == null ? void 0 : extraDisposes.forEach((fn) => fn());
+    let parent2 = node;
+    while (parent2) {
+      parent2.numListenersRecursive--;
+      parent2 = parent2.parent;
+    }
+  };
 }
 function createCb(linkedFromNode, path, callback) {
-    // Create a callback for a path that calls it with the current value at the path
-    let { valueAtPath: prevAtPath } = getValueAtPath(getNodeValue(linkedFromNode), path);
-    return function ({ value: valueA, loading, remote }) {
-        const { valueAtPath } = getValueAtPath(valueA, path);
-        if (valueAtPath !== prevAtPath) {
-            callback({
-                value: valueAtPath,
-                loading,
-                remote,
-                changes: [
-                    {
-                        path: [],
-                        pathTypes: [],
-                        prevAtPath,
-                        valueAtPath,
-                    },
-                ],
-                getPrevious: () => prevAtPath,
-            });
-        }
-        prevAtPath = valueAtPath;
-    };
-}
-function getValueAtPath(obj, path) {
-    let o = obj;
-    const pathTypes = [];
-    for (let i = 0; o && i < path.length; i++) {
-        pathTypes.push(isArray(o) ? 'array' : 'object');
-        const p = path[i];
-        o = o[p];
-    }
-    return { valueAtPath: o, pathTypes };
+  let { valueAtPath: prevAtPath } = getValueAtPath2(getNodeValue(linkedFromNode), path);
+  return function({ value: valueA, loading, remote }) {
+    const { valueAtPath } = getValueAtPath2(valueA, path);
+    if (valueAtPath !== prevAtPath) {
+      callback({
+        value: valueAtPath,
+        loading,
+        remote,
+        changes: [
+          {
+            path: [],
+            pathTypes: [],
+            prevAtPath,
+            valueAtPath
+          }
+        ],
+        getPrevious: () => prevAtPath
+      });
+    }
+    prevAtPath = valueAtPath;
+  };
+}
+function getValueAtPath2(obj, path) {
+  let o = obj;
+  const pathTypes = [];
+  for (let i = 0; o && i < path.length; i++) {
+    pathTypes.push(isArray(o) ? "array" : "object");
+    const p = path[i];
+    o = o[p];
+  }
+  return { valueAtPath: o, pathTypes };
 }
 
+// src/setupTracking.ts
 function setupTracking(nodes, update, noArgs, immediate) {
-    let listeners = [];
-    // Listen to tracked nodes
-    nodes === null || nodes === void 0 ? void 0 : nodes.forEach((tracked) => {
-        const { node, track } = tracked;
-        listeners.push(onChange(node, update, { trackingType: track, immediate, noArgs }));
-    });
-    return () => {
-        if (listeners) {
-            for (let i = 0; i < listeners.length; i++) {
-                listeners[i]();
-            }
-            listeners = undefined;
-        }
-    };
+  let listeners = [];
+  nodes == null ? void 0 : nodes.forEach((tracked) => {
+    const { node, track } = tracked;
+    listeners.push(onChange(node, update, { trackingType: track, immediate, noArgs }));
+  });
+  return () => {
+    if (listeners) {
+      for (let i = 0; i < listeners.length; i++) {
+        listeners[i]();
+      }
+      listeners = void 0;
+    }
+  };
 }
 
-let trackCount = 0;
-const trackingQueue = [];
-const tracking = {
-    current: undefined,
+// src/tracking.ts
+var trackCount = 0;
+var trackingQueue = [];
+var tracking = {
+  current: void 0
 };
 function beginTracking() {
-    // Keep a copy of the previous tracking context so it can be restored
-    // when this context is complete
-    trackingQueue.push(tracking.current);
-    trackCount++;
-    tracking.current = {};
+  trackingQueue.push(tracking.current);
+  trackCount++;
+  tracking.current = {};
 }
 function endTracking() {
-    // Restore the previous tracking context
-    trackCount--;
-    if (trackCount < 0) {
-        trackCount = 0;
-    }
-    tracking.current = trackingQueue.pop();
+  trackCount--;
+  if (trackCount < 0) {
+    trackCount = 0;
+  }
+  tracking.current = trackingQueue.pop();
 }
 function updateTracking(node, track) {
-    if (trackCount) {
-        const tracker = tracking.current;
-        if (tracker) {
-            if (!tracker.nodes) {
-                tracker.nodes = new Map();
-            }
-            const existing = tracker.nodes.get(node);
-            if (existing) {
-                existing.track = existing.track || track;
-                existing.num++;
-            }
-            else {
-                tracker.nodes.set(node, { node, track, num: 1 });
-            }
-        }
-    }
+  if (trackCount) {
+    const tracker = tracking.current;
+    if (tracker) {
+      if (!tracker.nodes) {
+        tracker.nodes = /* @__PURE__ */ new Map();
+      }
+      const existing = tracker.nodes.get(node);
+      if (existing) {
+        existing.track = existing.track || track;
+        existing.num++;
+      } else {
+        tracker.nodes.set(node, { node, track, num: 1 });
+      }
+    }
+  }
 }
 
+// src/trackSelector.ts
 function trackSelector(selector, update, observeEvent, observeOptions, createResubscribe) {
-    var _a;
-    let dispose;
-    let resubscribe;
-    let updateFn = update;
-    beginTracking();
-    const value = selector ? computeSelector(selector, observeEvent, observeOptions === null || observeOptions === void 0 ? void 0 : observeOptions.fromComputed) : selector;
-    const tracker = tracking.current;
-    const nodes = tracker.nodes;
-    endTracking();
-    if ((process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') && tracker && nodes) {
-        (_a = tracker.traceListeners) === null || _a === void 0 ? void 0 : _a.call(tracker, nodes);
-        if (tracker.traceUpdates) {
-            updateFn = tracker.traceUpdates(update);
-        }
-        // Clear tracing so it doesn't leak to other components
-        tracker.traceListeners = undefined;
-        tracker.traceUpdates = undefined;
-    }
-    if (!(observeEvent === null || observeEvent === void 0 ? void 0 : observeEvent.cancel)) {
-        // Do tracing if it was requested
-        // useSyncExternalStore doesn't subscribe until after the component mount.
-        // We want to subscribe immediately so we don't miss any updates
-        dispose = setupTracking(nodes, updateFn, false, observeOptions === null || observeOptions === void 0 ? void 0 : observeOptions.immediate);
-        if (process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') {
-            resubscribe = createResubscribe
-                ? () => {
-                    dispose === null || dispose === void 0 ? void 0 : dispose();
-                    dispose = setupTracking(nodes, updateFn);
-                    return dispose;
-                }
-                : undefined;
-        }
-    }
-    return { nodes, value, dispose, resubscribe };
+  var _a;
+  let dispose;
+  let resubscribe;
+  let updateFn = update;
+  beginTracking();
+  const value = selector ? computeSelector(selector, observeEvent, observeOptions == null ? void 0 : observeOptions.fromComputed) : selector;
+  const tracker = tracking.current;
+  const nodes = tracker.nodes;
+  endTracking();
+  if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && tracker && nodes) {
+    (_a = tracker.traceListeners) == null ? void 0 : _a.call(tracker, nodes);
+    if (tracker.traceUpdates) {
+      updateFn = tracker.traceUpdates(update);
+    }
+    tracker.traceListeners = void 0;
+    tracker.traceUpdates = void 0;
+  }
+  if (!(observeEvent == null ? void 0 : observeEvent.cancel)) {
+    dispose = setupTracking(nodes, updateFn, false, observeOptions == null ? void 0 : observeOptions.immediate);
+    if (process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") {
+      resubscribe = createResubscribe ? () => {
+        dispose == null ? void 0 : dispose();
+        dispose = setupTracking(nodes, updateFn);
+        return dispose;
+      } : void 0;
+    }
+  }
+  return { nodes, value, dispose, resubscribe };
 }
 
+// src/observe.ts
 function observe(selectorOrRun, reactionOrOptions, options) {
-    let reaction;
-    if (isFunction(reactionOrOptions)) {
-        reaction = reactionOrOptions;
-    }
-    else {
-        options = reactionOrOptions;
-    }
-    let dispose;
-    const e = { num: 0 };
-    // Wrap it in a function so it doesn't pass all the arguments to run()
-    const update = function () {
-        if (e.onCleanup) {
-            e.onCleanup();
-            e.onCleanup = undefined;
-        }
-        // Run in a batch so changes don't happen until we're done tracking here
-        beginBatch();
-        // Run the function/selector
-        delete e.value;
-        // Dispose listeners from previous run
-        dispose === null || dispose === void 0 ? void 0 : dispose();
-        const { dispose: _dispose, value, nodes } = trackSelector(selectorOrRun, update, e, options);
-        dispose = _dispose;
-        e.value = value;
-        e.nodes = nodes;
-        e.refresh = update;
-        if (e.onCleanupReaction) {
-            e.onCleanupReaction();
-            e.onCleanupReaction = undefined;
-        }
-        endBatch();
-        // Call the reaction if there is one and the value changed
-        if (reaction &&
-            ((options === null || options === void 0 ? void 0 : options.fromComputed) ||
-                ((e.num > 0 || !isEvent(selectorOrRun)) &&
-                    (e.previous !== e.value || typeof e.value === 'object')))) {
-            reaction(e);
-        }
-        // Update the previous value
-        e.previous = e.value;
-        // Increment the counter
-        e.num++;
-    };
-    update();
-    // Return function calling dispose because dispose may be changed in update()
-    return () => {
-        var _a, _b;
-        (_a = e.onCleanup) === null || _a === void 0 ? void 0 : _a.call(e);
-        e.onCleanup = undefined;
-        (_b = e.onCleanupReaction) === null || _b === void 0 ? void 0 : _b.call(e);
-        e.onCleanupReaction = undefined;
-        dispose === null || dispose === void 0 ? void 0 : dispose();
-    };
+  let reaction;
+  if (isFunction(reactionOrOptions)) {
+    reaction = reactionOrOptions;
+  } else {
+    options = reactionOrOptions;
+  }
+  let dispose;
+  const e = { num: 0 };
+  const update = function() {
+    if (e.onCleanup) {
+      e.onCleanup();
+      e.onCleanup = void 0;
+    }
+    beginBatch();
+    delete e.value;
+    dispose == null ? void 0 : dispose();
+    const { dispose: _dispose, value, nodes } = trackSelector(selectorOrRun, update, e, options);
+    dispose = _dispose;
+    e.value = value;
+    e.nodes = nodes;
+    e.refresh = update;
+    if (e.onCleanupReaction) {
+      e.onCleanupReaction();
+      e.onCleanupReaction = void 0;
+    }
+    endBatch();
+    if (reaction && ((options == null ? void 0 : options.fromComputed) || (e.num > 0 || !isEvent(selectorOrRun)) && (e.previous !== e.value || typeof e.value === "object"))) {
+      reaction(e);
+    }
+    e.previous = e.value;
+    e.num++;
+  };
+  update();
+  return () => {
+    var _a, _b;
+    (_a = e.onCleanup) == null ? void 0 : _a.call(e);
+    e.onCleanup = void 0;
+    (_b = e.onCleanupReaction) == null ? void 0 : _b.call(e);
+    e.onCleanupReaction = void 0;
+    dispose == null ? void 0 : dispose();
+  };
 }
 
+// src/when.ts
 function _when(predicate, effect, checkReady) {
-    // If predicate is a regular Promise skip all the observable stuff
-    if (isPromise(predicate)) {
-        return effect ? predicate.then(effect) : predicate;
-    }
-    let value;
-    let effectValue;
-    // Create a wrapping fn that calls the effect if predicate returns true
-    function run(e) {
-        const ret = computeSelector(predicate);
-        if (isPromise(ret)) {
-            value = ret;
-            // We want value to be the Promise but return undefined
-            // so it doesn't run the effect with the Promise as the value
-            return undefined;
-        }
-        else if (!isPromise(ret) && (checkReady ? isObservableValueReady(ret) : ret)) {
-            value = ret;
-            // Set cancel so that observe does not track anymore
-            e.cancel = true;
-        }
-        return value;
-    }
-    function doEffect() {
-        // If value is truthy then run the effect
-        effectValue = effect === null || effect === void 0 ? void 0 : effect(value);
-    }
-    // Run in an observe
-    observe(run, doEffect);
-    // If first run resulted in a truthy value just return it.
-    // It will have set e.cancel so no need to dispose
-    if (isPromise(value)) {
-        return effect ? value.then(effect) : value;
-    }
-    else if (value !== undefined) {
-        return effect ? effectValue : Promise.resolve(value);
-    }
-    else {
-        // Wrap it in a promise
-        const promise = new Promise((resolve) => {
-            if (effect) {
-                const originalEffect = effect;
-                effect = ((value) => {
-                    const effectValue = originalEffect(value);
-                    resolve(isPromise(effectValue) ? effectValue.then((value) => value) : effectValue);
-                });
-            }
-            else {
-                effect = resolve;
-            }
-        });
-        return promise;
+  if (isPromise(predicate)) {
+    return effect ? predicate.then(effect) : predicate;
+  }
+  let value;
+  let effectValue;
+  function run(e) {
+    const ret = computeSelector(predicate);
+    if (isPromise(ret)) {
+      value = ret;
+      return void 0;
+    } else if (!isPromise(ret) && (checkReady ? isObservableValueReady(ret) : ret)) {
+      value = ret;
+      e.cancel = true;
     }
+    return value;
+  }
+  function doEffect() {
+    effectValue = effect == null ? void 0 : effect(value);
+  }
+  observe(run, doEffect);
+  if (isPromise(value)) {
+    return effect ? value.then(effect) : value;
+  } else if (value !== void 0) {
+    return effect ? effectValue : Promise.resolve(value);
+  } else {
+    const promise = new Promise((resolve) => {
+      if (effect) {
+        const originalEffect = effect;
+        effect = (value2) => {
+          const effectValue2 = originalEffect(value2);
+          resolve(isPromise(effectValue2) ? effectValue2.then((value3) => value3) : effectValue2);
+        };
+      } else {
+        effect = resolve;
+      }
+    });
+    return promise;
+  }
 }
 function when(predicate, effect) {
-    return _when(predicate, effect, false);
+  return _when(predicate, effect, false);
 }
 function whenReady(predicate, effect) {
-    return _when(predicate, effect, true);
+  return _when(predicate, effect, true);
 }
 
-const ArrayModifiers = new Set([
-    'copyWithin',
-    'fill',
-    'from',
-    'pop',
-    'push',
-    'reverse',
-    'shift',
-    'sort',
-    'splice',
-    'unshift',
+// src/ObservableObject.ts
+var ArrayModifiers = /* @__PURE__ */ new Set([
+  "copyWithin",
+  "fill",
+  "from",
+  "pop",
+  "push",
+  "reverse",
+  "shift",
+  "sort",
+  "splice",
+  "unshift"
 ]);
-const ArrayLoopers = new Set([
-    'every',
-    'filter',
-    'find',
-    'findIndex',
-    'forEach',
-    'join',
-    'map',
-    'reduce',
-    'some',
+var ArrayLoopers = /* @__PURE__ */ new Set([
+  "every",
+  "filter",
+  "find",
+  "findIndex",
+  "forEach",
+  "join",
+  "map",
+  "reduce",
+  "some"
 ]);
-const ArrayLoopersReturn = new Set(['filter', 'find']);
-const observableProperties = new Map();
-const observableFns = new Map([
-    ['get', get],
-    ['set', set],
-    ['peek', peek],
-    ['onChange', onChange],
-    ['assign', assign],
-    ['delete', deleteFn],
-    ['toggle', toggle],
+var ArrayLoopersReturn = /* @__PURE__ */ new Set(["filter", "find"]);
+var observableProperties = /* @__PURE__ */ new Map();
+var observableFns = /* @__PURE__ */ new Map([
+  ["get", get],
+  ["set", set],
+  ["peek", peek],
+  ["onChange", onChange],
+  ["assign", assign],
+  ["delete", deleteFn],
+  ["toggle", toggle]
 ]);
-if (process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') {
-    // eslint-disable-next-line no-var
-    var __devUpdateNodes = new Set();
+if (process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") {
+  __devUpdateNodes = /* @__PURE__ */ new Set();
 }
+var __devUpdateNodes;
 function collectionSetter(node, target, prop, ...args) {
-    var _a;
-    if (prop === 'push' && args.length === 1) {
-        // Fast path for push to just append to the end
-        setKey(node, target.length + '', args[0]);
-    }
-    else {
-        const prevValue = target.slice();
-        const ret = target[prop].apply(target, args);
-        if (node) {
-            const hasParent = isChildNodeValue(node);
-            const key = hasParent ? node.key : '_';
-            const parentValue = hasParent ? getNodeValue(node.parent) : node.root;
-            // Set the object to the previous value first
-            parentValue[key] = prevValue;
-            // Then set with the new value so it notifies with the correct prevValue
-            setKey((_a = node.parent) !== null && _a !== void 0 ? _a : node, key, target);
-        }
-        // Return the original value
-        return ret;
+  var _a;
+  if (prop === "push" && args.length === 1) {
+    setKey(node, target.length + "", args[0]);
+  } else {
+    const prevValue = target.slice();
+    const ret = target[prop].apply(target, args);
+    if (node) {
+      const hasParent = isChildNodeValue(node);
+      const key = hasParent ? node.key : "_";
+      const parentValue = hasParent ? getNodeValue(node.parent) : node.root;
+      parentValue[key] = prevValue;
+      setKey((_a = node.parent) != null ? _a : node, key, target);
     }
+    return ret;
+  }
 }
-function getKeys(obj, isArr, isMap) {
-    return isArr ? undefined : obj ? (isMap ? Array.from(obj.keys()) : Object.keys(obj)) : [];
+function getKeys(obj, isArr, isMap2) {
+  return isArr ? void 0 : obj ? isMap2 ? Array.from(obj.keys()) : Object.keys(obj) : [];
 }
 function updateNodes(parent, obj, prevValue) {
-    var _a, _b, _c;
-    if ((process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') &&
-        typeof __devUpdateNodes !== 'undefined' &&
-        isObject(obj)) {
-        if (__devUpdateNodes.has(obj)) {
-            console.error('[legend-state] Circular reference detected in object. You may want to use opaqueObject to stop traversing child nodes.', obj);
-            return false;
-        }
-        __devUpdateNodes.add(obj);
-    }
-    if ((isObject(obj) && obj[symbolOpaque]) ||
-        (isObject(prevValue) && prevValue[symbolOpaque])) {
-        const isDiff = obj !== prevValue;
-        if (isDiff) {
-            if (parent.listeners || parent.listenersImmediate) {
-                notify(parent, obj, prevValue, 0);
-            }
-        }
-        if ((process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') &&
-            typeof __devUpdateNodes !== 'undefined' &&
-            obj !== undefined) {
-            __devUpdateNodes.delete(obj);
-        }
-        return isDiff;
-    }
-    const isArr = isArray(obj);
-    let prevChildrenById;
-    let moved;
-    const isCurMap = isMap(obj);
-    const isPrevMap = isMap(prevValue);
-    const keys = getKeys(obj, isArr, isCurMap);
-    const keysPrev = getKeys(prevValue, isArr, isPrevMap);
-    const length = ((_a = (keys || obj)) === null || _a === void 0 ? void 0 : _a.length) || 0;
-    const lengthPrev = ((_b = (keysPrev || prevValue)) === null || _b === void 0 ? void 0 : _b.length) || 0;
-    let idField;
-    let isIdFieldFunction;
-    let hasADiff = false;
-    let retValue;
-    if (isArr && isArray(prevValue)) {
-        // Construct a map of previous indices for computing move
-        if (prevValue.length > 0) {
-            const firstPrevValue = prevValue[0];
-            if (firstPrevValue !== undefined) {
-                idField = findIDKey(firstPrevValue, parent);
-                if (idField) {
-                    isIdFieldFunction = isFunction(idField);
-                    prevChildrenById = new Map();
-                    moved = [];
-                }
-                const keysSeen = process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test'
-                    ? new Set()
-                    : undefined;
-                if (parent.children) {
-                    for (let i = 0; i < prevValue.length; i++) {
-                        const p = prevValue[i];
-                        if (p) {
-                            const child = parent.children.get(i + '');
-                            if (child) {
-                                if (!obj[i]) {
-                                    // If the previous value is not in the new array and it
-                                    // is an activated, disable its listeners
-                                    handleDeletedChild(child, p);
-                                }
-                                if (idField) {
-                                    const key = isIdFieldFunction
-                                        ? idField(p)
-                                        : p[idField];
-                                    if (process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') {
-                                        if (keysSeen.has(key)) {
-                                            console.warn(`[legend-state] Warning: Multiple elements in array have the same ID. Key field: ${idField}, Array:`, prevValue);
-                                        }
-                                        keysSeen.add(key);
-                                    }
-                                    prevChildrenById.set(key, child);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-    else if (prevValue && (!obj || isObject(obj))) {
-        // For keys that have been removed from object, notify and update children recursively
-        const lengthPrev = keysPrev.length;
-        for (let i = 0; i < lengthPrev; i++) {
-            const key = keysPrev[i];
-            if (!keys.includes(key)) {
-                hasADiff = true;
-                const child = getChildNode(parent, key);
-                const prev = isPrevMap ? prevValue.get(key) : prevValue[key];
-                if (prev !== undefined) {
-                    handleDeletedChild(child, prev);
-                }
-            }
-        }
-    }
-    if (obj && !isPrimitive(obj)) {
-        hasADiff = hasADiff || length !== lengthPrev;
-        const isArrDiff = hasADiff;
-        let didMove = false;
-        for (let i = 0; i < length; i++) {
-            const key = isArr ? i + '' : keys[i];
-            let value = isCurMap ? obj.get(key) : obj[key];
-            const prev = isPrevMap ? prevValue === null || prevValue === void 0 ? void 0 : prevValue.get(key) : prevValue === null || prevValue === void 0 ? void 0 : prevValue[key];
-            let isDiff = !equals(value, prev);
-            if (isDiff) {
-                const id = idField && value
-                    ? isIdFieldFunction
-                        ? idField(value)
-                        : value[idField]
-                    : undefined;
-                const existingChild = (_c = parent.children) === null || _c === void 0 ? void 0 : _c.get(key);
-                if (isObservable(value)) {
-                    const valueNode = getNode(value);
-                    if ((existingChild === null || existingChild === void 0 ? void 0 : existingChild.linkedToNode) === valueNode) {
-                        const targetValue = getNodeValue(valueNode);
-                        isCurMap ? obj.set(key, targetValue) : (obj[key] = targetValue);
-                        continue;
-                    }
-                    const obs = value;
-                    value = () => obs;
-                }
-                let child = getChildNode(parent, key, value);
-                if (!child.lazy && (isFunction(value) || isObservable(value))) {
-                    reactivateNode(child, value);
-                    peekInternal(child);
-                }
-                // Detect moves within an array. Need to move the original proxy to the new position to keep
-                // the proxy stable, so that listeners to this node will be unaffected by the array shift.
-                if (isArr && id !== undefined) {
-                    // Find the previous position of this element in the array
-                    const prevChild = id !== undefined ? prevChildrenById === null || prevChildrenById === void 0 ? void 0 : prevChildrenById.get(id) : undefined;
-                    if (!prevChild) {
-                        // This id was not in the array before so it does not need to notify children
-                        // It does need to notify itself so isDiff should remain.
-                        hasADiff = true;
-                    }
-                    else if (prevChild !== undefined && prevChild.key !== key) {
-                        const valuePrevChild = prevValue[prevChild.key];
-                        // If array length changed then move the original node to the current position.
-                        // That should be faster than notifying every single element that
-                        // it's in a new position.
-                        if (isArrDiff) {
-                            child = prevChild;
-                            parent.children.delete(child.key);
-                            child.key = key;
-                            moved.push([key, child]);
-                        }
-                        didMove = true;
-                        // And check for diff against the previous value in the previous position
-                        isDiff = valuePrevChild !== value;
-                    }
+  var _a, _b, _c;
+  if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && typeof __devUpdateNodes !== "undefined" && isObject(obj)) {
+    if (__devUpdateNodes.has(obj)) {
+      console.error(
+        "[legend-state] Circular reference detected in object. You may want to use opaqueObject to stop traversing child nodes.",
+        obj
+      );
+      return false;
+    }
+    __devUpdateNodes.add(obj);
+  }
+  if (isObject(obj) && obj[symbolOpaque] || isObject(prevValue) && prevValue[symbolOpaque]) {
+    const isDiff = obj !== prevValue;
+    if (isDiff) {
+      if (parent.listeners || parent.listenersImmediate) {
+        notify(parent, obj, prevValue, 0);
+      }
+    }
+    if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && typeof __devUpdateNodes !== "undefined" && obj !== void 0) {
+      __devUpdateNodes.delete(obj);
+    }
+    return isDiff;
+  }
+  const isArr = isArray(obj);
+  let prevChildrenById;
+  let moved;
+  const isCurMap = isMap(obj);
+  const isPrevMap = isMap(prevValue);
+  const keys = getKeys(obj, isArr, isCurMap);
+  const keysPrev = getKeys(prevValue, isArr, isPrevMap);
+  const length = ((_a = keys || obj) == null ? void 0 : _a.length) || 0;
+  const lengthPrev = ((_b = keysPrev || prevValue) == null ? void 0 : _b.length) || 0;
+  let idField;
+  let isIdFieldFunction;
+  let hasADiff = false;
+  let retValue;
+  if (isArr && isArray(prevValue)) {
+    if (prevValue.length > 0) {
+      const firstPrevValue = prevValue[0];
+      if (firstPrevValue !== void 0) {
+        idField = findIDKey(firstPrevValue, parent);
+        if (idField) {
+          isIdFieldFunction = isFunction(idField);
+          prevChildrenById = /* @__PURE__ */ new Map();
+          moved = [];
+        }
+        const keysSeen = process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test" ? /* @__PURE__ */ new Set() : void 0;
+        if (parent.children) {
+          for (let i = 0; i < prevValue.length; i++) {
+            const p = prevValue[i];
+            if (p) {
+              const child = parent.children.get(i + "");
+              if (child) {
+                if (!obj[i]) {
+                  handleDeletedChild(child, p);
                 }
-                if (isDiff) {
-                    // Array has a new / modified element
-                    // If object iterate through its children
-                    if (isFunction(value) || isObservable(value)) {
-                        extractFunctionOrComputed(parent, key, value);
-                    }
-                    else if (isPrimitive(value)) {
-                        hasADiff = true;
-                    }
-                    else {
-                        // Always need to updateNodes so we notify through all children
-                        const updatedNodes = updateNodes(child, value, prev);
-                        hasADiff = hasADiff || updatedNodes;
-                        isDiff = updatedNodes;
-                    }
-                }
-                if (isDiff || (isArr && !isArrDiff)) {
-                    // Notify for this child if this element is different and it has listeners
-                    // Or if the position changed in an array whose length did not change
-                    // But do not notify child if the parent is an array with changing length -
-                    // the array's listener will cover it
-                    if (child.listeners || child.listenersImmediate) {
-                        notify(child, value, prev, 0, !isArrDiff);
+                if (idField) {
+                  const key = isIdFieldFunction ? idField(p) : p[idField];
+                  if (process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") {
+                    if (keysSeen.has(key)) {
+                      console.warn(
+                        `[legend-state] Warning: Multiple elements in array have the same ID. Key field: ${idField}, Array:`,
+                        prevValue
+                      );
                     }
+                    keysSeen.add(key);
+                  }
+                  prevChildrenById.set(key, child);
                 }
+              }
             }
-        }
-        if (moved) {
-            for (let i = 0; i < moved.length; i++) {
-                const [key, child] = moved[i];
-                parent.children.set(key, child);
+          }
+        }
+      }
+    }
+  } else if (prevValue && (!obj || isObject(obj))) {
+    const lengthPrev2 = keysPrev.length;
+    for (let i = 0; i < lengthPrev2; i++) {
+      const key = keysPrev[i];
+      if (!keys.includes(key)) {
+        hasADiff = true;
+        const child = getChildNode(parent, key);
+        const prev = isPrevMap ? prevValue.get(key) : prevValue[key];
+        if (prev !== void 0) {
+          handleDeletedChild(child, prev);
+        }
+      }
+    }
+  }
+  if (obj && !isPrimitive(obj)) {
+    hasADiff = hasADiff || length !== lengthPrev;
+    const isArrDiff = hasADiff;
+    let didMove = false;
+    for (let i = 0; i < length; i++) {
+      const key = isArr ? i + "" : keys[i];
+      let value = isCurMap ? obj.get(key) : obj[key];
+      const prev = isPrevMap ? prevValue == null ? void 0 : prevValue.get(key) : prevValue == null ? void 0 : prevValue[key];
+      let isDiff = !equals(value, prev);
+      if (isDiff) {
+        const id = idField && value ? isIdFieldFunction ? idField(value) : value[idField] : void 0;
+        const existingChild = (_c = parent.children) == null ? void 0 : _c.get(key);
+        if (isObservable(value)) {
+          const valueNode = getNode(value);
+          if ((existingChild == null ? void 0 : existingChild.linkedToNode) === valueNode) {
+            const targetValue = getNodeValue(valueNode);
+            isCurMap ? obj.set(key, targetValue) : obj[key] = targetValue;
+            continue;
+          }
+          const obs = value;
+          value = () => obs;
+        }
+        let child = getChildNode(parent, key, value);
+        if (!child.lazy && (isFunction(value) || isObservable(value))) {
+          reactivateNode(child, value);
+          peekInternal(child);
+        }
+        if (isArr && id !== void 0) {
+          const prevChild = id !== void 0 ? prevChildrenById == null ? void 0 : prevChildrenById.get(id) : void 0;
+          if (!prevChild) {
+            hasADiff = true;
+          } else if (prevChild !== void 0 && prevChild.key !== key) {
+            const valuePrevChild = prevValue[prevChild.key];
+            if (isArrDiff) {
+              child = prevChild;
+              parent.children.delete(child.key);
+              child.key = key;
+              moved.push([key, child]);
             }
+            didMove = true;
+            isDiff = valuePrevChild !== value;
+          }
         }
-        // The full array does not need to re-render if the length is the same
-        // So don't notify shallow listeners
-        retValue = hasADiff || didMove;
-    }
-    else if (prevValue !== undefined) {
-        // If value got set to undefined, it has a diff
-        retValue = true;
-    }
-    if ((process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') &&
-        typeof __devUpdateNodes !== 'undefined' &&
-        obj !== undefined) {
-        __devUpdateNodes.delete(obj);
-    }
-    return retValue !== null && retValue !== void 0 ? retValue : false;
+        if (isDiff) {
+          if (isFunction(value) || isObservable(value)) {
+            extractFunctionOrComputed(parent, key, value);
+          } else if (isPrimitive(value)) {
+            hasADiff = true;
+          } else {
+            const updatedNodes = updateNodes(child, value, prev);
+            hasADiff = hasADiff || updatedNodes;
+            isDiff = updatedNodes;
+          }
+        }
+        if (isDiff || isArr && !isArrDiff) {
+          if (child.listeners || child.listenersImmediate) {
+            notify(child, value, prev, 0, !isArrDiff);
+          }
+        }
+      }
+    }
+    if (moved) {
+      for (let i = 0; i < moved.length; i++) {
+        const [key, child] = moved[i];
+        parent.children.set(key, child);
+      }
+    }
+    retValue = hasADiff || didMove;
+  } else if (prevValue !== void 0) {
+    retValue = true;
+  }
+  if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && typeof __devUpdateNodes !== "undefined" && obj !== void 0) {
+    __devUpdateNodes.delete(obj);
+  }
+  return retValue != null ? retValue : false;
 }
 function handleDeletedChild(child, p) {
-    var _a, _b;
-    // If the previous value is not in the new array and it
-    // is an activated, disable its listeners
-    (_a = child.linkedToNodeDispose) === null || _a === void 0 ? void 0 : _a.call(child);
-    (_b = child.activatedObserveDispose) === null || _b === void 0 ? void 0 : _b.call(child);
-    if (!isPrimitive(p)) {
-        updateNodes(child, undefined, p);
-    }
-    if (child.listeners || child.listenersImmediate) {
-        notify(child, undefined, p, 0);
-    }
+  var _a, _b;
+  (_a = child.linkedToNodeDispose) == null ? void 0 : _a.call(child);
+  (_b = child.activatedObserveDispose) == null ? void 0 : _b.call(child);
+  if (!isPrimitive(p)) {
+    updateNodes(child, void 0, p);
+  }
+  if (child.listeners || child.listenersImmediate) {
+    notify(child, void 0, p, 0);
+  }
 }
 function getProxy(node, p, asFunction) {
-    // Get the child node if p prop
-    if (p !== undefined)
-        node = getChildNode(node, p, asFunction);
-    // Create a proxy if not already cached and return it
-    return (node.proxy || (node.proxy = new Proxy(node, proxyHandler)));
+  if (p !== void 0)
+    node = getChildNode(node, p, asFunction);
+  return node.proxy || (node.proxy = new Proxy(node, proxyHandler));
 }
 function flushPending() {
-    // Need to short circuit the computed batching because the user called get() or peek()
-    // in which case the set needs to run immediately so that the values are up to date.
-    if (globalState.pendingNodes.size > 0) {
-        const nodes = Array.from(globalState.pendingNodes.values());
-        globalState.pendingNodes.clear();
-        nodes.forEach((fn) => fn());
-    }
-}
-const proxyHandler = {
-    get(node, p, receiver) {
-        var _a, _b;
-        if (p === symbolToPrimitive) {
-            throw new Error(process.env.NODE_ENV === 'development'
-                ? '[legend-state] observable should not be used as a primitive. You may have forgotten to use .get() or .peek() to get the value of the observable.'
-                : '[legend-state] observable is not a primitive.');
-        }
-        if (p === symbolGetNode) {
-            return node;
-        }
-        if (p === 'apply') {
-            const nodeValue = getNodeValue(node);
-            if (isFunction(nodeValue)) {
-                return nodeValue.apply;
-            }
-        }
-        let value = peekInternal(node, /*activateRecursive*/ p === 'get' || p === 'peek');
-        // If this node is linked to another observable then forward to the target's handler.
-        // The exception is onChange because it needs to listen to this node for changes.
-        // This needs to be below peek because it activates there.
-        const targetNode = node.linkedToNode || (value === null || value === void 0 ? void 0 : value[symbolGetNode]);
-        if (targetNode && p !== 'onChange') {
-            return proxyHandler.get(targetNode, p, receiver);
-        }
-        if (isMap(value) || value instanceof WeakMap || value instanceof Set || value instanceof WeakSet) {
-            const ret = handlerMapSet(node, p, value);
-            if (ret !== undefined) {
-                return ret;
-            }
-        }
-        const fn = observableFns.get(p);
-        // If this is an observable function, call it
-        if (fn) {
-            if (p === 'get' || p === 'peek') {
-                flushPending();
-            }
-            return function (a, b, c) {
-                const l = arguments.length;
-                // Array call and apply are slow so micro-optimize this hot path.
-                // The observable functions depends on the number of arguments so we have to
-                // call it with the correct arguments, not just undefined
-                switch (l) {
-                    case 0:
-                        return fn(node);
-                    case 1:
-                        return fn(node, a);
-                    case 2:
-                        return fn(node, a, b);
-                    default:
-                        return fn(node, a, b, c);
-                }
+  if (globalState.pendingNodes.size > 0) {
+    const nodes = Array.from(globalState.pendingNodes.values());
+    globalState.pendingNodes.clear();
+    nodes.forEach((fn) => fn());
+  }
+}
+var proxyHandler = {
+  get(node, p, receiver) {
+    var _a, _b;
+    if (p === symbolToPrimitive) {
+      throw new Error(
+        process.env.NODE_ENV === "development" ? "[legend-state] observable should not be used as a primitive. You may have forgotten to use .get() or .peek() to get the value of the observable." : "[legend-state] observable is not a primitive."
+      );
+    }
+    if (p === symbolGetNode) {
+      return node;
+    }
+    if (p === "apply") {
+      const nodeValue = getNodeValue(node);
+      if (isFunction(nodeValue)) {
+        return nodeValue.apply;
+      }
+    }
+    let value = peekInternal(
+      node,
+      /*activateRecursive*/
+      p === "get" || p === "peek"
+    );
+    const targetNode = node.linkedToNode || (value == null ? void 0 : value[symbolGetNode]);
+    if (targetNode && p !== "onChange") {
+      return proxyHandler.get(targetNode, p, receiver);
+    }
+    if (isMap(value) || value instanceof WeakMap || value instanceof Set || value instanceof WeakSet) {
+      const ret = handlerMapSet(node, p, value);
+      if (ret !== void 0) {
+        return ret;
+      }
+    }
+    const fn = observableFns.get(p);
+    if (fn) {
+      if (p === "get" || p === "peek") {
+        flushPending();
+      }
+      return function(a, b, c) {
+        const l = arguments.length;
+        switch (l) {
+          case 0:
+            return fn(node);
+          case 1:
+            return fn(node, a);
+          case 2:
+            return fn(node, a, b);
+          default:
+            return fn(node, a, b, c);
+        }
+      };
+    }
+    const property = observableProperties.get(p);
+    if (property) {
+      return property.get(node);
+    }
+    let vProp = value == null ? void 0 : value[p];
+    if (isObject(value) && value[symbolOpaque]) {
+      return vProp;
+    }
+    const fnOrComputed = (_a = node.functions) == null ? void 0 : _a.get(p);
+    if (fnOrComputed) {
+      if (isObservable(fnOrComputed)) {
+        return fnOrComputed;
+      } else {
+        return getProxy(node, p, fnOrComputed);
+      }
+    } else {
+      vProp = checkProperty(value, p);
+    }
+    if (isNullOrUndefined(value) && vProp === void 0 && (ArrayModifiers.has(p) || ArrayLoopers.has(p))) {
+      value = [];
+      setNodeValue(node, value);
+      vProp = value[p];
+    }
+    if (isFunction(vProp)) {
+      if (isArray(value)) {
+        if (ArrayModifiers.has(p)) {
+          return (...args) => collectionSetter(node, value, p, ...args);
+        } else if (ArrayLoopers.has(p)) {
+          updateTracking(node, true);
+          return function(cbOrig, thisArg) {
+            const isReduce = p === "reduce";
+            const cbWrapped = isReduce ? (previousValue, currentValue, currentIndex, array) => {
+              return cbOrig(
+                previousValue,
+                getProxy(node, currentIndex + "", currentValue),
+                currentIndex,
+                array
+              );
+            } : (val, index, array) => {
+              return cbOrig(getProxy(node, index + "", val), index, array);
             };
-        }
-        const property = observableProperties.get(p);
-        if (property) {
-            return property.get(node);
-        }
-        let vProp = value === null || value === void 0 ? void 0 : value[p];
-        if (isObject(value) && value[symbolOpaque]) {
-            return vProp;
-        }
-        const fnOrComputed = (_a = node.functions) === null || _a === void 0 ? void 0 : _a.get(p);
-        if (fnOrComputed) {
-            if (isObservable(fnOrComputed)) {
-                return fnOrComputed;
+            if (isReduce || !ArrayLoopersReturn.has(p)) {
+              return value[p](cbWrapped, thisArg);
             }
-            else {
-                return getProxy(node, p, fnOrComputed);
-            }
-        }
-        else {
-            vProp = checkProperty(value, p);
-        }
-        if (isNullOrUndefined(value) && vProp === undefined && (ArrayModifiers.has(p) || ArrayLoopers.has(p))) {
-            value = [];
-            setNodeValue(node, value);
-            vProp = value[p];
-        }
-        // Handle function calls
-        if (isFunction(vProp)) {
-            if (isArray(value)) {
-                if (ArrayModifiers.has(p)) {
-                    // Call the wrapped modifier function
-                    return (...args) => collectionSetter(node, value, p, ...args);
+            const isFind = p === "find";
+            const out = [];
+            for (let i = 0; i < value.length; i++) {
+              if (cbWrapped(value[i], i, value)) {
+                const proxy2 = getProxy(node, i + "");
+                if (isFind) {
+                  return proxy2;
                 }
-                else if (ArrayLoopers.has(p)) {
-                    // Update that this node was accessed for observers
-                    updateTracking(node, true);
-                    return function (cbOrig, thisArg) {
-                        const isReduce = p === 'reduce';
-                        // Callbacks are given the Proxy rather than the underlying data
-                        const cbWrapped = isReduce
-                            ? (previousValue, currentValue, currentIndex, array) => {
-                                return cbOrig(previousValue, getProxy(node, currentIndex + '', currentValue), currentIndex, array);
-                            }
-                            : (val, index, array) => {
-                                return cbOrig(getProxy(node, index + '', val), index, array);
-                            };
-                        if (isReduce || !ArrayLoopersReturn.has(p)) {
-                            return value[p](cbWrapped, thisArg);
-                        }
-                        const isFind = p === 'find';
-                        const out = [];
-                        for (let i = 0; i < value.length; i++) {
-                            if (cbWrapped(value[i], i, value)) {
-                                const proxy = getProxy(node, i + '');
-                                // find returns the first match, otherwise it returns an array
-                                if (isFind) {
-                                    return proxy;
-                                }
-                                out.push(proxy);
-                            }
-                        }
-                        return isFind ? undefined : out;
-                    };
-                }
-            }
-            extractFunctionOrComputed(node, p, vProp);
-            const fnOrComputed2 = (_b = node.functions) === null || _b === void 0 ? void 0 : _b.get(p);
-            if (fnOrComputed2) {
-                return getProxy(node, p, fnOrComputed2);
-            }
-            // Return the function bound to the value
-            return vProp.bind(value);
-        }
-        // Accessing primitive returns the raw value
-        if (isPrimitive(vProp)) {
-            // Update that this primitive node was accessed for observers
-            if (isArray(value) && p === 'length') {
-                updateTracking(node, true);
-                return vProp;
+                out.push(proxy2);
+              }
             }
-        }
-        // Return an observable proxy to the property
-        return getProxy(node, p);
-    },
-    // Forward all proxy properties to the target's value
-    getPrototypeOf(node) {
-        const value = getNodeValue(node);
-        return value !== null && typeof value === 'object' ? Reflect.getPrototypeOf(value) : null;
-    },
-    ownKeys(node) {
-        // TODO: Temporary workaround to fix a bug - the first peek may not return the correct value
-        // if the value is a cached. This fixes the test "cache with initial ownKeys"
-        peekInternal(node);
-        const value = get(node, true);
-        if (isPrimitive(value))
-            return [];
-        const keys = value ? Reflect.ownKeys(value) : [];
-        // This is required to fix this error:
-        // TypeError: 'getOwnPropertyDescriptor' on proxy: trap reported non-configurability for
-        // property 'length' which is either non-existent or configurable in the proxy node
-        if (isArray(value) && keys[keys.length - 1] === 'length') {
-            keys.splice(keys.length - 1, 1);
-        }
-        if (isFunction(node)) {
-            const reflectedKeys = Reflect.ownKeys(node);
-            ['caller', 'arguments', 'prototype'].forEach((key) => reflectedKeys.includes(key) && keys.push(key));
-        }
-        return keys;
-    },
-    getOwnPropertyDescriptor(node, prop) {
-        if (prop === 'caller' || prop === 'arguments' || prop === 'prototype') {
-            return { configurable: false, enumerable: false };
-        }
-        const value = getNodeValue(node);
-        return isPrimitive(value) ? undefined : Reflect.getOwnPropertyDescriptor(value, prop);
-    },
-    set(node, prop, value) {
-        // If this assignment comes from within an observable function it's allowed
-        if (node.isSetting) {
-            return Reflect.set(node, prop, value);
-        }
-        if (node.isAssigning) {
-            setKey(node, prop, value);
-            return true;
-        }
-        const property = observableProperties.get(prop);
-        if (property) {
-            property.set(node, value);
-            return true;
-        }
-        if (process.env.NODE_ENV === 'development') {
-            console.warn('[legend-state]: Error: Cannot set a value directly:', prop, value);
-        }
-        return false;
-    },
-    deleteProperty(node, prop) {
-        // If this delete comes from within an observable function it's allowed
-        if (node.isSetting) {
-            return Reflect.deleteProperty(node, prop);
-        }
-        else {
-            if (process.env.NODE_ENV === 'development') {
-                console.warn('[legend-state]: Error: Cannot delete a value directly:', prop);
-            }
-            return false;
-        }
-    },
-    has(node, prop) {
-        const value = getNodeValue(node);
-        return Reflect.has(value, prop);
-    },
-    apply(target, thisArg, argArray) {
-        // If it's a function call it as a function
-        if (isObservable(thisArg)) {
-            thisArg = thisArg.peek();
-        }
-        return Reflect.apply(target.lazyFn || target, thisArg, argArray);
-    },
+            return isFind ? void 0 : out;
+          };
+        }
+      }
+      extractFunctionOrComputed(node, p, vProp);
+      const fnOrComputed2 = (_b = node.functions) == null ? void 0 : _b.get(p);
+      if (fnOrComputed2) {
+        return getProxy(node, p, fnOrComputed2);
+      }
+      return vProp.bind(value);
+    }
+    if (isPrimitive(vProp)) {
+      if (isArray(value) && p === "length") {
+        updateTracking(node, true);
+        return vProp;
+      }
+    }
+    return getProxy(node, p);
+  },
+  // Forward all proxy properties to the target's value
+  getPrototypeOf(node) {
+    const value = getNodeValue(node);
+    return value !== null && typeof value === "object" ? Reflect.getPrototypeOf(value) : null;
+  },
+  ownKeys(node) {
+    peekInternal(node);
+    const value = get(node, true);
+    if (isPrimitive(value))
+      return [];
+    const keys = value ? Reflect.ownKeys(value) : [];
+    if (isArray(value) && keys[keys.length - 1] === "length") {
+      keys.splice(keys.length - 1, 1);
+    }
+    if (isFunction(node)) {
+      const reflectedKeys = Reflect.ownKeys(node);
+      ["caller", "arguments", "prototype"].forEach((key) => reflectedKeys.includes(key) && keys.push(key));
+    }
+    return keys;
+  },
+  getOwnPropertyDescriptor(node, prop) {
+    if (prop === "caller" || prop === "arguments" || prop === "prototype") {
+      return { configurable: false, enumerable: false };
+    }
+    const value = getNodeValue(node);
+    return isPrimitive(value) ? void 0 : Reflect.getOwnPropertyDescriptor(value, prop);
+  },
+  set(node, prop, value) {
+    if (node.isSetting) {
+      return Reflect.set(node, prop, value);
+    }
+    if (node.isAssigning) {
+      setKey(node, prop, value);
+      return true;
+    }
+    const property = observableProperties.get(prop);
+    if (property) {
+      property.set(node, value);
+      return true;
+    }
+    if (process.env.NODE_ENV === "development") {
+      console.warn("[legend-state]: Error: Cannot set a value directly:", prop, value);
+    }
+    return false;
+  },
+  deleteProperty(node, prop) {
+    if (node.isSetting) {
+      return Reflect.deleteProperty(node, prop);
+    } else {
+      if (process.env.NODE_ENV === "development") {
+        console.warn("[legend-state]: Error: Cannot delete a value directly:", prop);
+      }
+      return false;
+    }
+  },
+  has(node, prop) {
+    const value = getNodeValue(node);
+    return Reflect.has(value, prop);
+  },
+  apply(target, thisArg, argArray) {
+    if (isObservable(thisArg)) {
+      thisArg = thisArg.peek();
+    }
+    return Reflect.apply(target.lazyFn || target, thisArg, argArray);
+  }
 };
 function set(node, newValue) {
-    if (node.parent) {
-        setKey(node.parent, node.key, newValue);
-    }
-    else {
-        setKey(node, '_', newValue);
-    }
+  if (node.parent) {
+    setKey(node.parent, node.key, newValue);
+  } else {
+    setKey(node, "_", newValue);
+  }
 }
 function toggle(node) {
-    const value = getNodeValue(node);
-    if (value === undefined || value === null || isBoolean(value)) {
-        set(node, !value);
-    }
-    else if (process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') {
-        throw new Error('[legend-state] Cannot toggle a non-boolean value');
-    }
+  const value = getNodeValue(node);
+  if (value === void 0 || value === null || isBoolean(value)) {
+    set(node, !value);
+  } else if (process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") {
+    throw new Error("[legend-state] Cannot toggle a non-boolean value");
+  }
 }
 function setKey(node, key, newValue, level) {
-    if (process.env.NODE_ENV === 'development') {
-        if (typeof HTMLElement !== 'undefined' && newValue instanceof HTMLElement) {
-            console.warn(`[legend-state] Set an HTMLElement into state. You probably don't want to do that.`);
-        }
-    }
-    const isRoot = !node.parent && key === '_';
-    if (node.parent && !getNodeValue(node) && !isFunction(newValue)) {
-        set(node, { [key]: newValue });
-    }
-    // Get the child node for updating and notifying
-    const childNode = isRoot ? node : getChildNode(node, key, newValue);
-    if (isObservable(newValue)) {
-        setToObservable(childNode, newValue);
-    }
-    else {
-        // Set the raw value on the parent object
-        const { newValue: savedValue, prevValue } = setNodeValue(childNode, newValue);
-        const isPrim = isPrimitive(savedValue) || savedValue instanceof Date;
-        if (!equals(savedValue, prevValue)) {
-            updateNodesAndNotify(node, savedValue, prevValue, childNode, isPrim, isRoot, level);
-        }
-        if (!isPrim) {
-            childNode.needsExtract = true;
-        }
-        extractFunctionOrComputed(node, key, savedValue);
-    }
+  if (process.env.NODE_ENV === "development") {
+    if (typeof HTMLElement !== "undefined" && newValue instanceof HTMLElement) {
+      console.warn(`[legend-state] Set an HTMLElement into state. You probably don't want to do that.`);
+    }
+  }
+  const isRoot = !node.parent && key === "_";
+  if (node.parent && !getNodeValue(node) && !isFunction(newValue)) {
+    set(node, { [key]: newValue });
+  }
+  const childNode = isRoot ? node : getChildNode(node, key, newValue);
+  if (isObservable(newValue)) {
+    setToObservable(childNode, newValue);
+  } else {
+    const { newValue: savedValue, prevValue } = setNodeValue(childNode, newValue);
+    const isPrim = isPrimitive(savedValue) || savedValue instanceof Date;
+    if (!equals(savedValue, prevValue)) {
+      updateNodesAndNotify(node, savedValue, prevValue, childNode, isPrim, isRoot, level);
+    }
+    if (!isPrim) {
+      childNode.needsExtract = true;
+    }
+    extractFunctionOrComputed(node, key, savedValue);
+  }
 }
 function assign(node, value) {
-    const proxy = getProxy(node);
-    beginBatch();
-    if (isPrimitive(node.root._)) {
-        node.root._ = {};
-    }
-    if (isMap(value)) {
-        const currentValue = getNodeValue(node);
-        if (isMap(currentValue)) {
-            value.forEach((value, key) => currentValue.set(key, value));
-        }
-    }
-    else {
-        // Set inAssign to allow setting on safe observables
-        node.isAssigning = (node.isAssigning || 0) + 1;
-        try {
-            // TODO: If current value is a Map how to assign into the Map?
-            Object.assign(proxy, value);
-        }
-        finally {
-            node.isAssigning--;
-        }
+  const proxy2 = getProxy(node);
+  beginBatch();
+  if (isPrimitive(node.root._)) {
+    node.root._ = {};
+  }
+  if (isMap(value)) {
+    const currentValue = getNodeValue(node);
+    if (isMap(currentValue)) {
+      value.forEach((value2, key) => currentValue.set(key, value2));
+    }
+  } else {
+    node.isAssigning = (node.isAssigning || 0) + 1;
+    try {
+      Object.assign(proxy2, value);
+    } finally {
+      node.isAssigning--;
     }
-    endBatch();
-    return proxy;
+  }
+  endBatch();
+  return proxy2;
 }
 function deleteFn(node, key) {
-    // If called without a key, delete by key from the parent node
-    if (key === undefined && isChildNodeValue(node)) {
-        key = node.key;
-        node = node.parent;
-    }
-    const value = getNodeValue(node);
-    if (isArray(value)) {
-        collectionSetter(node, value, 'splice', key, 1);
-    }
-    else {
-        setKey(node, key !== null && key !== void 0 ? key : '_', symbolDelete, /*level*/ -1);
-    }
+  if (key === void 0 && isChildNodeValue(node)) {
+    key = node.key;
+    node = node.parent;
+  }
+  const value = getNodeValue(node);
+  if (isArray(value)) {
+    collectionSetter(node, value, "splice", key, 1);
+  } else {
+    setKey(
+      node,
+      key != null ? key : "_",
+      symbolDelete,
+      /*level*/
+      -1
+    );
+  }
 }
 function handlerMapSet(node, p, value) {
-    const vProp = value === null || value === void 0 ? void 0 : value[p];
-    if (p === 'size') {
-        return getProxy(node, p);
-    }
-    else if (isFunction(vProp)) {
-        return function (a, b, c) {
-            const l = arguments.length;
-            const valueMap = value;
-            if (p === 'get') {
-                if (l > 0 && typeof a !== 'boolean' && a !== optimized) {
-                    return getProxy(node, a);
-                }
-            }
-            else if (p === 'set') {
-                if (l === 2) {
-                    const prev = valueMap.get(a);
-                    const ret = valueMap.set(a, b);
-                    if (prev !== b) {
-                        updateNodesAndNotify(getChildNode(node, a), b, prev);
-                    }
-                    return ret;
-                }
-                else if (l === 1 && isMap(value)) {
-                    set(node, a);
-                }
-            }
-            else if (p === 'delete') {
-                if (l > 0) {
-                    // Support Set by just returning a if it doesn't have get, meaning it's not a Map
-                    const prev = value.get ? valueMap.get(a) : a;
-                    const ret = value.delete(a);
-                    if (ret) {
-                        updateNodesAndNotify(getChildNode(node, a), undefined, prev);
-                    }
-                    return ret;
-                }
-            }
-            else if (p === 'clear') {
-                const prev = new Map(valueMap);
-                const size = valueMap.size;
-                valueMap.clear();
-                if (size) {
-                    updateNodesAndNotify(node, value, prev);
-                }
-                return;
-            }
-            else if (p === 'add') {
-                const prev = new Set(value);
-                const ret = value.add(a);
-                if (!value.has(p)) {
-                    notify(node, ret, prev, 0);
-                }
-                return ret;
-            }
-            // TODO: This is duplicated from proxy handler, how to dedupe with best performance?
-            const fn = observableFns.get(p);
-            if (fn) {
-                // Array call and apply are slow so micro-optimize this hot path.
-                // The observable functions depends on the number of arguments so we have to
-                // call it with the correct arguments, not just undefined
-                switch (l) {
-                    case 0:
-                        return fn(node);
-                    case 1:
-                        return fn(node, a);
-                    case 2:
-                        return fn(node, a, b);
-                    default:
-                        return fn(node, a, b, c);
-                }
-            }
-            else {
-                return value[p](a, b);
-            }
-        };
-    }
+  const vProp = value == null ? void 0 : value[p];
+  if (p === "size") {
+    return getProxy(node, p);
+  } else if (isFunction(vProp)) {
+    return function(a, b, c) {
+      const l = arguments.length;
+      const valueMap = value;
+      if (p === "get") {
+        if (l > 0 && typeof a !== "boolean" && a !== optimized) {
+          return getProxy(node, a);
+        }
+      } else if (p === "set") {
+        if (l === 2) {
+          const prev = valueMap.get(a);
+          const ret = valueMap.set(a, b);
+          if (prev !== b) {
+            updateNodesAndNotify(getChildNode(node, a), b, prev);
+          }
+          return ret;
+        } else if (l === 1 && isMap(value)) {
+          set(node, a);
+        }
+      } else if (p === "delete") {
+        if (l > 0) {
+          const prev = value.get ? valueMap.get(a) : a;
+          const ret = value.delete(a);
+          if (ret) {
+            updateNodesAndNotify(getChildNode(node, a), void 0, prev);
+          }
+          return ret;
+        }
+      } else if (p === "clear") {
+        const prev = new Map(valueMap);
+        const size = valueMap.size;
+        valueMap.clear();
+        if (size) {
+          updateNodesAndNotify(node, value, prev);
+        }
+        return;
+      } else if (p === "add") {
+        const prev = new Set(value);
+        const ret = value.add(a);
+        if (!value.has(p)) {
+          notify(node, ret, prev, 0);
+        }
+        return ret;
+      }
+      const fn = observableFns.get(p);
+      if (fn) {
+        switch (l) {
+          case 0:
+            return fn(node);
+          case 1:
+            return fn(node, a);
+          case 2:
+            return fn(node, a, b);
+          default:
+            return fn(node, a, b, c);
+        }
+      } else {
+        return value[p](a, b);
+      }
+    };
+  }
 }
 function updateNodesAndNotify(node, newValue, prevValue, childNode, isPrim, isRoot, level) {
-    if (!childNode)
-        childNode = node;
-    // Make sure we don't call too many listeners for every property set
-    beginBatch();
-    if (isPrim === undefined) {
-        isPrim = isPrimitive(newValue);
-    }
-    let hasADiff = isPrim;
-    let whenOptimizedOnlyIf = false;
-    // If new value is an object or array update notify down the tree
-    if (!isPrim || (prevValue && !isPrimitive(prevValue))) {
-        if ((process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') &&
-            typeof __devUpdateNodes !== 'undefined') {
-            __devUpdateNodes.clear();
-        }
-        hasADiff = updateNodes(childNode, newValue, prevValue);
-        if (isArray(newValue)) {
-            whenOptimizedOnlyIf = (newValue === null || newValue === void 0 ? void 0 : newValue.length) !== (prevValue === null || prevValue === void 0 ? void 0 : prevValue.length);
-        }
-    }
-    if (isPrim || !newValue || (isEmpty(newValue) && !isEmpty(prevValue)) ? newValue !== prevValue : hasADiff) {
-        // Notify for this element if something inside it has changed
-        notify(isPrim && isRoot ? node : childNode, newValue, prevValue, (level !== null && level !== void 0 ? level : prevValue === undefined) ? -1 : hasADiff ? 0 : 1, whenOptimizedOnlyIf);
-    }
-    endBatch();
+  if (!childNode)
+    childNode = node;
+  beginBatch();
+  if (isPrim === void 0) {
+    isPrim = isPrimitive(newValue);
+  }
+  let hasADiff = isPrim;
+  let whenOptimizedOnlyIf = false;
+  if (!isPrim || prevValue && !isPrimitive(prevValue)) {
+    if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && typeof __devUpdateNodes !== "undefined") {
+      __devUpdateNodes.clear();
+    }
+    hasADiff = updateNodes(childNode, newValue, prevValue);
+    if (isArray(newValue)) {
+      whenOptimizedOnlyIf = (newValue == null ? void 0 : newValue.length) !== (prevValue == null ? void 0 : prevValue.length);
+    }
+  }
+  if (isPrim || !newValue || isEmpty(newValue) && !isEmpty(prevValue) ? newValue !== prevValue : hasADiff) {
+    notify(
+      isPrim && isRoot ? node : childNode,
+      newValue,
+      prevValue,
+      (level != null ? level : prevValue === void 0) ? -1 : hasADiff ? 0 : 1,
+      whenOptimizedOnlyIf
+    );
+  }
+  endBatch();
 }
 function extractPromise(node, value, setter) {
-    if (!node.state) {
-        node.state = createObservable({
-            isLoaded: false,
-        }, false, extractPromise, getProxy);
-    }
-    value
-        .then((value) => {
-        setter ? setter({ value }) : set(node, value);
-        node.state.assign({
-            isLoaded: true,
-            error: undefined,
-        });
-    })
-        .catch((error) => {
-        node.state.error.set(error);
+  if (!node.state) {
+    node.state = createObservable(
+      {
+        isLoaded: false
+      },
+      false,
+      extractPromise,
+      getProxy
+    );
+  }
+  value.then((value2) => {
+    setter ? setter({ value: value2 }) : set(node, value2);
+    node.state.assign({
+      isLoaded: true,
+      error: void 0
     });
+  }).catch((error) => {
+    node.state.error.set(error);
+  });
 }
 function extractFunctionOrComputed(node, k, v) {
-    // We want to extract these types of values from the observable's raw value so that
-    // the raw value does not contain Promises, Observables or functions
-    if (isPromise(v)) {
-        const childNode = getChildNode(node, k);
-        extractPromise(childNode, v);
-        setNodeValue(childNode, undefined);
-        return undefined;
-    }
-    else if (isObservable(v)) {
-        const fn = () => v;
-        extractFunction(node, k, fn);
-        const childNode = getChildNode(node, k, fn);
-        const targetNode = getNode(v);
-        // Set node to target's value if activating or it's already activated
-        const initialValue = peek(targetNode);
-        setNodeValue(childNode, initialValue);
-        return getNodeValue(childNode);
-    }
-    else if (typeof v === 'function') {
-        extractFunction(node, k, v);
-        return k;
-    }
+  if (isPromise(v)) {
+    const childNode = getChildNode(node, k);
+    extractPromise(childNode, v);
+    setNodeValue(childNode, void 0);
+    return void 0;
+  } else if (isObservable(v)) {
+    const fn = () => v;
+    extractFunction(node, k, fn);
+    const childNode = getChildNode(node, k, fn);
+    const targetNode = getNode(v);
+    const initialValue = peek(targetNode);
+    setNodeValue(childNode, initialValue);
+    return getNodeValue(childNode);
+  } else if (typeof v === "function") {
+    extractFunction(node, k, v);
+    return k;
+  }
 }
 function get(node, options) {
-    const track = options ? (isObject(options) ? options.shallow : options) : undefined;
-    // Track by default
-    updateTracking(node, track);
-    return peek(node);
+  const track = options ? isObject(options) ? options.shallow : options : void 0;
+  updateTracking(node, track);
+  return peek(node);
 }
 function peek(node) {
-    return peekInternal(node, true);
+  return peekInternal(node, true);
 }
-let isFlushing = false;
+var isFlushing = false;
 function peekInternal(node, activateRecursive) {
-    var _a;
-    isFlushing = true;
-    // Need to refresh all dirty children when getting
-    if (activateRecursive && ((_a = node.dirtyChildren) === null || _a === void 0 ? void 0 : _a.size)) {
-        const dirty = Array.from(node.dirtyChildren);
-        node.dirtyChildren.clear();
-        dirty.forEach((node) => node.dirtyFn && peekInternal(node));
-    }
-    if (node.dirtyFn) {
-        const dirtyFn = node.dirtyFn;
-        node.dirtyFn = undefined;
-        globalState.dirtyNodes.delete(node);
-        dirtyFn();
-    }
-    isFlushing = false;
-    let value = getNodeValue(node);
-    value = checkLazy(node, value, !!activateRecursive);
-    return value;
+  var _a;
+  isFlushing = true;
+  if (activateRecursive && ((_a = node.dirtyChildren) == null ? void 0 : _a.size)) {
+    const dirty = Array.from(node.dirtyChildren);
+    node.dirtyChildren.clear();
+    dirty.forEach((node2) => node2.dirtyFn && peekInternal(node2));
+  }
+  if (node.dirtyFn) {
+    const dirtyFn = node.dirtyFn;
+    node.dirtyFn = void 0;
+    globalState.dirtyNodes.delete(node);
+    dirtyFn();
+  }
+  isFlushing = false;
+  let value = getNodeValue(node);
+  value = checkLazy(node, value, !!activateRecursive);
+  return value;
 }
 function checkLazy(node, value, activateRecursive) {
-    const origValue = value;
-    // If node is not yet lazily computed go do that
-    const lazy = node.lazy;
-    if (lazy) {
-        const lazyFn = node.lazyFn;
-        delete node.lazy;
-        if (isFunction(lazyFn)) {
-            if (lazyFn.length === 1) {
-                // This is a lookup function, so return a record object
-                value = {};
-            }
-            else {
-                if (node.parent) {
-                    const parentValue = getNodeValue(node.parent);
-                    if (parentValue) {
-                        delete parentValue[node.key];
-                    }
-                    else {
-                        node.root._ = undefined;
-                    }
-                }
-                value = activateNodeFunction(node, lazyFn);
-            }
-        }
-        else if (isObservable(value)) {
-            value = extractFunctionOrComputed(node.parent, node.key, value);
-        }
-    }
-    if ((lazy || node.needsExtract) && !isObservable(value) && !isPrimitive(value)) {
-        // If this is a purposeful get, check descendants for observable or auto activated linked
-        if (activateRecursive) {
-            recursivelyAutoActivate(value, node);
-        }
-        // If this is an extractable node, extract it from parent before it's accessed
+  const origValue = value;
+  const lazy = node.lazy;
+  if (lazy) {
+    const lazyFn = node.lazyFn;
+    delete node.lazy;
+    if (isFunction(lazyFn)) {
+      if (lazyFn.length === 1) {
+        value = {};
+      } else {
         if (node.parent) {
-            extractFunctionOrComputed(node.parent, node.key, origValue);
-        }
+          const parentValue = getNodeValue(node.parent);
+          if (parentValue) {
+            delete parentValue[node.key];
+          } else {
+            node.root._ = void 0;
+          }
+        }
+        value = activateNodeFunction(node, lazyFn);
+      }
+    } else if (isObservable(value)) {
+      value = extractFunctionOrComputed(node.parent, node.key, value);
+    }
+  }
+  if ((lazy || node.needsExtract) && !isObservable(value) && !isPrimitive(value)) {
+    if (activateRecursive) {
+      recursivelyAutoActivate(value, node);
     }
-    return value;
+    if (node.parent) {
+      extractFunctionOrComputed(node.parent, node.key, origValue);
+    }
+  }
+  return value;
 }
 function checkProperty(value, key) {
-    if (value) {
-        const property = Object.getOwnPropertyDescriptor(value, key);
-        if (property === null || property === void 0 ? void 0 : property.get) {
-            delete value[key];
-            value[key] = property.set
-                ? linked({
-                    get: property.get,
-                    set: ({ value }) => property.set(value),
-                })
-                : property.get;
-        }
-        return value[key];
-    }
+  if (value) {
+    const property = Object.getOwnPropertyDescriptor(value, key);
+    if (property == null ? void 0 : property.get) {
+      delete value[key];
+      value[key] = property.set ? linked({
+        get: property.get,
+        set: ({ value: value2 }) => property.set(value2)
+      }) : property.get;
+    }
+    return value[key];
+  }
 }
 function reactivateNode(node, lazyFn) {
-    var _a, _b;
-    (_a = node.activatedObserveDispose) === null || _a === void 0 ? void 0 : _a.call(node);
-    (_b = node.linkedToNodeDispose) === null || _b === void 0 ? void 0 : _b.call(node);
-    node.activatedObserveDispose = node.linkedToNodeDispose = node.linkedToNode = undefined;
-    node.lazyFn = lazyFn;
-    node.lazy = true;
+  var _a, _b;
+  (_a = node.activatedObserveDispose) == null ? void 0 : _a.call(node);
+  (_b = node.linkedToNodeDispose) == null ? void 0 : _b.call(node);
+  node.activatedObserveDispose = node.linkedToNodeDispose = node.linkedToNode = void 0;
+  node.lazyFn = lazyFn;
+  node.lazy = true;
 }
 function isObserved(node) {
-    var _a, _b;
-    let parent = node;
-    let hasListeners = node.numListenersRecursive > 0;
-    while (parent && !hasListeners) {
-        if (!!((_a = parent.listeners) === null || _a === void 0 ? void 0 : _a.size) || !!((_b = parent.listenersImmediate) === null || _b === void 0 ? void 0 : _b.size)) {
-            hasListeners = true;
-        }
-        parent = parent.parent;
+  var _a, _b;
+  let parent = node;
+  let hasListeners = node.numListenersRecursive > 0;
+  while (parent && !hasListeners) {
+    if (!!((_a = parent.listeners) == null ? void 0 : _a.size) || !!((_b = parent.listenersImmediate) == null ? void 0 : _b.size)) {
+      hasListeners = true;
     }
-    return hasListeners;
+    parent = parent.parent;
+  }
+  return hasListeners;
 }
 function shouldIgnoreUnobserved(node, refreshFn) {
-    if (!isFlushing) {
-        const hasListeners = isObserved(node);
-        if (!hasListeners) {
-            if (refreshFn) {
-                node.dirtyFn = refreshFn;
-            }
-            let parent = node;
-            while (parent) {
-                if (!parent.dirtyChildren) {
-                    parent.dirtyChildren = new Set();
-                }
-                parent.dirtyChildren.add(node);
-                parent = parent.parent;
-            }
-            return true;
+  if (!isFlushing) {
+    const hasListeners = isObserved(node);
+    if (!hasListeners) {
+      if (refreshFn) {
+        node.dirtyFn = refreshFn;
+      }
+      let parent = node;
+      while (parent) {
+        if (!parent.dirtyChildren) {
+          parent.dirtyChildren = /* @__PURE__ */ new Set();
         }
+        parent.dirtyChildren.add(node);
+        parent = parent.parent;
+      }
+      return true;
     }
+  }
 }
 function activateNodeFunction(node, lazyFn) {
-    // let prevTarget$: Observable<any>;
-    // let curTarget$: Observable<any>;
-    let update;
-    let wasPromise;
-    let ignoreThisUpdate;
-    let isFirst = true;
-    const activateFn = lazyFn;
-    let activatedValue;
-    let disposes = [];
-    let refreshFn;
-    function markDirty() {
-        node.dirtyFn = refreshFn;
-        globalState.dirtyNodes.add(node);
-    }
-    node.activatedObserveDispose = observe(() => {
-        var _a, _b, _c, _d;
-        // Set it to undefined so that the activation function gets undefined
-        // if it peeks itself
-        if (isFirst) {
-            isFirst = false;
-            setNodeValue(node, undefined);
-        }
-        else if (!isFlushing && refreshFn) {
-            if (shouldIgnoreUnobserved(node, refreshFn)) {
-                ignoreThisUpdate = true;
-                return;
-            }
-        }
-        // Run the function at this node
-        let value = activateFn();
-        let didSetToObs = false;
-        // If target is an observable, make this node a link to it
-        if (isObservable(value)) {
-            didSetToObs = true;
-            value = setToObservable(node, value);
-        }
-        if (isFunction(value)) {
-            value = value();
-        }
-        const activated = !isObservable(value)
-            ? value === null || value === void 0 ? void 0 : value[symbolLinked]
-            : undefined;
-        if (activated) {
-            node.activationState = activated;
-            value = undefined;
-        }
-        ignoreThisUpdate = false;
-        wasPromise = isPromise(value);
-        // Activate this node if not activated already (may be called recursively)
-        // TODO: Is calling recursively bad? If so can it be fixed?
-        if (!node.activated) {
-            node.activated = true;
-            let activateNodeFn = activateNodeBase;
-            // If this is a Synced then run it through persistence instead of base
-            if (activated === null || activated === void 0 ? void 0 : activated.synced) {
-                activateNodeFn = globalState.activateSyncedNode;
-                ignoreThisUpdate = true;
-            }
-            const result = activateNodeFn(node, value);
-            update = result.update;
-            let newValue = result.value;
-            if (!didSetToObs && isObservable(newValue)) {
-                newValue = setToObservable(node, newValue);
-            }
-            value = newValue !== null && newValue !== void 0 ? newValue : activated === null || activated === void 0 ? void 0 : activated.initial;
-        }
-        else if (node.activationState) {
-            const activated = node.activationState;
-            if ((_b = (_a = node.state) === null || _a === void 0 ? void 0 : _a.peek()) === null || _b === void 0 ? void 0 : _b.sync) {
-                node.state.sync();
-                ignoreThisUpdate = true;
+  let update;
+  let wasPromise;
+  let ignoreThisUpdate;
+  let isFirst = true;
+  const activateFn = lazyFn;
+  let activatedValue;
+  let disposes = [];
+  let refreshFn;
+  function markDirty() {
+    node.dirtyFn = refreshFn;
+    globalState.dirtyNodes.add(node);
+  }
+  node.activatedObserveDispose = observe(
+    () => {
+      var _a, _b, _c, _d;
+      if (isFirst) {
+        isFirst = false;
+        setNodeValue(node, void 0);
+      } else if (!isFlushing && refreshFn) {
+        if (shouldIgnoreUnobserved(node, refreshFn)) {
+          ignoreThisUpdate = true;
+          return;
+        }
+      }
+      let value = activateFn();
+      let didSetToObs = false;
+      if (isObservable(value)) {
+        didSetToObs = true;
+        value = setToObservable(node, value);
+      }
+      if (isFunction(value)) {
+        value = value();
+      }
+      const activated = !isObservable(value) ? value == null ? void 0 : value[symbolLinked] : void 0;
+      if (activated) {
+        node.activationState = activated;
+        value = void 0;
+      }
+      ignoreThisUpdate = false;
+      wasPromise = isPromise(value);
+      if (!node.activated) {
+        node.activated = true;
+        let activateNodeFn = activateNodeBase;
+        if (activated == null ? void 0 : activated.synced) {
+          activateNodeFn = globalState.activateSyncedNode;
+          ignoreThisUpdate = true;
+        }
+        const result = activateNodeFn(node, value);
+        update = result.update;
+        let newValue = result.value;
+        if (!didSetToObs && isObservable(newValue)) {
+          newValue = setToObservable(node, newValue);
+        }
+        value = newValue != null ? newValue : activated == null ? void 0 : activated.initial;
+      } else if (node.activationState) {
+        const activated2 = node.activationState;
+        if ((_b = (_a = node.state) == null ? void 0 : _a.peek()) == null ? void 0 : _b.sync) {
+          node.state.sync();
+          ignoreThisUpdate = true;
+        } else {
+          value = (_d = (_c = activated2.get) == null ? void 0 : _c.call(activated2)) != null ? _d : activated2.initial;
+        }
+      }
+      wasPromise = wasPromise || isPromise(value);
+      return value;
+    },
+    (e) => {
+      const { value, nodes, refresh } = e;
+      refreshFn = refresh;
+      if (!ignoreThisUpdate) {
+        if (!wasPromise || !globalState.isLoadingRemote) {
+          if (wasPromise) {
+            if (node.activationState) {
+              const { initial } = node.activationState;
+              if (value && isPromise(value)) {
+                extractPromise(node, value, update);
+              }
+              if (isFunction(getNodeValue(node))) {
+                setNodeValue(node, initial != null ? initial : void 0);
+              }
+            } else if (node.activated) {
+              extractPromise(node, value, update);
+              if (isFunction(getNodeValue(node))) {
+                setNodeValue(node, void 0);
+              }
             }
-            else {
-                value = (_d = (_c = activated.get) === null || _c === void 0 ? void 0 : _c.call(activated)) !== null && _d !== void 0 ? _d : activated.initial;
+          } else {
+            activatedValue = value;
+            if (node.state.isLoaded.peek()) {
+              node.isComputing = true;
+              set(node, value);
+              node.isComputing = false;
+            } else {
+              setNodeValue(node, value);
+              node.state.assign({
+                isLoaded: true,
+                error: void 0
+              });
             }
+          }
         }
-        // value is undefined if it's in a persisted retry
-        wasPromise = wasPromise || isPromise(value);
-        return value;
-    }, (e) => {
-        const { value, nodes, refresh } = e;
-        refreshFn = refresh;
-        if (!ignoreThisUpdate) {
-            if (!wasPromise || !globalState.isLoadingRemote) {
-                if (wasPromise) {
-                    if (node.activationState) {
-                        const { initial } = node.activationState;
-                        if (value && isPromise(value)) {
-                            // Extract the promise to make it set the value/error when it comes in
-                            extractPromise(node, value, update);
-                        }
-                        // Set this to undefined only if it's replacing the activation function,
-                        // so we don't overwrite it if it already has real data from either local
-                        // cache or a previous run
-                        if (isFunction(getNodeValue(node))) {
-                            setNodeValue(node, initial !== null && initial !== void 0 ? initial : undefined);
-                        }
-                    }
-                    else if (node.activated) {
-                        // Extract the promise to make it set the value/error when it comes in
-                        extractPromise(node, value, update);
-                        // Set this to undefined only if it's replacing the activation function,
-                        // so we don't overwrite it if it already has real data from either local
-                        // cache or a previous run
-                        if (isFunction(getNodeValue(node))) {
-                            setNodeValue(node, undefined);
-                        }
-                    }
-                }
-                else {
-                    activatedValue = value;
-                    if (node.state.isLoaded.peek()) {
-                        node.isComputing = true;
-                        set(node, value);
-                        node.isComputing = false;
-                    }
-                    else {
-                        setNodeValue(node, value);
-                        node.state.assign({
-                            isLoaded: true,
-                            error: undefined,
-                        });
-                    }
-                }
-            }
-            disposes.forEach((fn) => fn());
-            disposes = [];
-            nodes === null || nodes === void 0 ? void 0 : nodes.forEach(({ node, track }) => {
-                disposes.push(onChange(node, markDirty, { immediate: true, trackingType: track }));
-            });
-        }
-        e.cancel = true;
-    }, { fromComputed: true });
-    return activatedValue;
+        disposes.forEach((fn) => fn());
+        disposes = [];
+        nodes == null ? void 0 : nodes.forEach(({ node: node2, track }) => {
+          disposes.push(onChange(node2, markDirty, { immediate: true, trackingType: track }));
+        });
+      }
+      e.cancel = true;
+    },
+    { fromComputed: true }
+  );
+  return activatedValue;
 }
 function activateNodeBase(node, value) {
-    if (!node.state) {
-        node.state = createObservable({
-            isLoaded: false,
-        }, false, extractPromise, getProxy);
-    }
-    if (node.activationState) {
-        const { set: setFn, get: getFn, initial } = node.activationState;
-        value = getFn === null || getFn === void 0 ? void 0 : getFn();
-        if (value == undefined || value === null) {
-            value = initial;
-        }
-        if (setFn) {
-            let allChanges = [];
-            let latestValue = undefined;
-            let runNumber = 0;
-            const runChanges = (listenerParams) => {
-                // Don't call the set if this is the first value coming in
-                if (allChanges.length > 0) {
-                    let changes;
-                    let value;
-                    let loading = false;
-                    let remote = false;
-                    let getPrevious;
-                    if (listenerParams) {
-                        changes = listenerParams.changes;
-                        value = listenerParams.value;
-                        loading = listenerParams.loading;
-                        remote = listenerParams.remote;
-                        getPrevious = listenerParams.getPrevious;
-                    }
-                    else {
-                        // If this is called by flushPending then get the change array
-                        // that we've been building up.
-                        changes = allChanges;
-                        value = latestValue;
-                        getPrevious = createPreviousHandler(value, changes);
-                    }
-                    allChanges = [];
-                    latestValue = undefined;
-                    globalState.pendingNodes.delete(node);
-                    runNumber++;
-                    const thisRunNumber = runNumber;
-                    const run = () => {
-                        if (thisRunNumber !== runNumber) {
-                            // set may get called multiple times before it loads so ignore any previous runs
-                            return;
-                        }
-                        node.isComputing = true;
-                        setFn({
-                            value,
-                            changes,
-                            loading,
-                            remote,
-                            getPrevious,
-                        });
-                        node.isComputing = false;
-                    };
-                    whenReady(node.state.isLoaded, run);
-                }
-            };
-            const onChangeImmediate = ({ value, changes }) => {
-                if (!node.isComputing) {
-                    if (changes.length > 1 || !isFunction(changes[0].prevAtPath)) {
-                        latestValue = value;
-                        if (allChanges.length > 0) {
-                            changes = changes.filter((change) => !isArraySubset(allChanges[0].path, change.path));
-                        }
-                        allChanges.push(...changes);
-                        globalState.pendingNodes.set(node, runChanges);
-                    }
-                }
-            };
-            // Create an immediate listener to mark this node as pending. Then actually run
-            // the changes at the end of the batch so everything is properly batched.
-            // However, this can be short circuited if the user calls get() or peek()
-            // in which case the set needs to run immediately so that the values are up to date.
-            onChange(node, onChangeImmediate, { immediate: true });
-            onChange(node, runChanges);
-        }
-    }
-    const update = ({ value }) => {
-        if (!node.isComputing) {
+  if (!node.state) {
+    node.state = createObservable(
+      {
+        isLoaded: false
+      },
+      false,
+      extractPromise,
+      getProxy
+    );
+  }
+  if (node.activationState) {
+    const { set: setFn, get: getFn, initial } = node.activationState;
+    value = getFn == null ? void 0 : getFn();
+    if (value == void 0 || value === null) {
+      value = initial;
+    }
+    if (setFn) {
+      let allChanges = [];
+      let latestValue = void 0;
+      let runNumber = 0;
+      const runChanges = (listenerParams) => {
+        if (allChanges.length > 0) {
+          let changes;
+          let value2;
+          let loading = false;
+          let remote = false;
+          let getPrevious;
+          if (listenerParams) {
+            changes = listenerParams.changes;
+            value2 = listenerParams.value;
+            loading = listenerParams.loading;
+            remote = listenerParams.remote;
+            getPrevious = listenerParams.getPrevious;
+          } else {
+            changes = allChanges;
+            value2 = latestValue;
+            getPrevious = createPreviousHandler(value2, changes);
+          }
+          allChanges = [];
+          latestValue = void 0;
+          globalState.pendingNodes.delete(node);
+          runNumber++;
+          const thisRunNumber = runNumber;
+          const run = () => {
+            if (thisRunNumber !== runNumber) {
+              return;
+            }
             node.isComputing = true;
-            set(node, value);
+            setFn({
+              value: value2,
+              changes,
+              loading,
+              remote,
+              getPrevious
+            });
             node.isComputing = false;
+          };
+          whenReady(node.state.isLoaded, run);
         }
-    };
-    return { update, value };
+      };
+      const onChangeImmediate = ({ value: value2, changes }) => {
+        if (!node.isComputing) {
+          if (changes.length > 1 || !isFunction(changes[0].prevAtPath)) {
+            latestValue = value2;
+            if (allChanges.length > 0) {
+              changes = changes.filter((change) => !isArraySubset(allChanges[0].path, change.path));
+            }
+            allChanges.push(...changes);
+            globalState.pendingNodes.set(node, runChanges);
+          }
+        }
+      };
+      onChange(node, onChangeImmediate, { immediate: true });
+      onChange(node, runChanges);
+    }
+  }
+  const update = ({ value: value2 }) => {
+    if (!node.isComputing) {
+      node.isComputing = true;
+      set(node, value2);
+      node.isComputing = false;
+    }
+  };
+  return { update, value };
 }
 function setToObservable(node, value) {
-    var _a;
-    // If the computed is a proxy to another observable
-    // link it to the target observable
-    const linkedNode = getNode(value);
-    if (linkedNode !== node && (linkedNode === null || linkedNode === void 0 ? void 0 : linkedNode.linkedToNode) !== node) {
-        node.linkedToNode = linkedNode;
-        linkedNode.linkedFromNodes || (linkedNode.linkedFromNodes = new Set());
-        linkedNode.linkedFromNodes.add(node);
-        (_a = node.linkedToNodeDispose) === null || _a === void 0 ? void 0 : _a.call(node);
-        node.linkedToNodeDispose = onChange(linkedNode, () => {
-            value = peekInternal(linkedNode);
-            set(node, value);
-        }, { initial: true }, new Set([node]));
-    }
-    return value;
+  var _a;
+  const linkedNode = getNode(value);
+  if (linkedNode !== node && (linkedNode == null ? void 0 : linkedNode.linkedToNode) !== node) {
+    node.linkedToNode = linkedNode;
+    linkedNode.linkedFromNodes || (linkedNode.linkedFromNodes = /* @__PURE__ */ new Set());
+    linkedNode.linkedFromNodes.add(node);
+    (_a = node.linkedToNodeDispose) == null ? void 0 : _a.call(node);
+    node.linkedToNodeDispose = onChange(
+      linkedNode,
+      () => {
+        value = peekInternal(linkedNode);
+        set(node, value);
+      },
+      { initial: true },
+      /* @__PURE__ */ new Set([node])
+    );
+  }
+  return value;
 }
 function recursivelyAutoActivate(obj, node) {
-    if (isObject(obj) || isArray(obj)) {
-        const pathStack = []; // Maintain a stack for path tracking
-        const getNodeAtPath = () => {
-            var _a;
-            let childNode = node;
-            for (let i = 0; i < pathStack.length; i++) {
-                const { key } = pathStack[i];
-                const value = (_a = getNodeValue(childNode)) === null || _a === void 0 ? void 0 : _a[key];
-                childNode = getChildNode(childNode, key, isFunction(value) ? value : undefined);
-                peekInternal(childNode);
-            }
-            return childNode;
-        };
-        recursivelyAutoActivateInner(obj, pathStack, getNodeAtPath);
-    }
-}
-function recursivelyAutoActivateInner(obj, pathStack, getNodeAtPath) {
-    var _a;
-    for (const key in obj) {
-        if (hasOwnProperty.call(obj, key)) {
-            const value = obj[key];
-            if (isObservable(value)) {
-                const childNode = getNodeAtPath();
-                extractFunctionOrComputed(childNode, key, value);
-                delete childNode.lazy;
-            }
-            else {
-                const linkedOptions = isFunction(value) && ((_a = value.prototype) === null || _a === void 0 ? void 0 : _a[symbolLinked]);
-                if (linkedOptions) {
-                    const activate = linkedOptions.activate;
-                    if (!activate || activate === 'auto') {
-                        const childNode = getNodeAtPath();
-                        peek(getChildNode(childNode, key, value));
-                    }
-                }
-            }
-            if (typeof value === 'object') {
-                pathStack.push({ key, value });
-                recursivelyAutoActivateInner(value, pathStack, getNodeAtPath); // Recursively traverse
-                pathStack.pop();
-            }
-        }
-    }
+  if (isObject(obj) || isArray(obj)) {
+    const pathStack = [];
+    const getNodeAtPath2 = () => {
+      var _a;
+      let childNode = node;
+      for (let i = 0; i < pathStack.length; i++) {
+        const { key } = pathStack[i];
+        const value = (_a = getNodeValue(childNode)) == null ? void 0 : _a[key];
+        childNode = getChildNode(childNode, key, isFunction(value) ? value : void 0);
+        peekInternal(childNode);
+      }
+      return childNode;
+    };
+    recursivelyAutoActivateInner(obj, pathStack, getNodeAtPath2);
+  }
+}
+function recursivelyAutoActivateInner(obj, pathStack, getNodeAtPath2) {
+  var _a;
+  for (const key in obj) {
+    if (hasOwnProperty.call(obj, key)) {
+      const value = obj[key];
+      if (isObservable(value)) {
+        const childNode = getNodeAtPath2();
+        extractFunctionOrComputed(childNode, key, value);
+        delete childNode.lazy;
+      } else {
+        const linkedOptions = isFunction(value) && ((_a = value.prototype) == null ? void 0 : _a[symbolLinked]);
+        if (linkedOptions) {
+          const activate = linkedOptions.activate;
+          if (!activate || activate === "auto") {
+            const childNode = getNodeAtPath2();
+            peek(getChildNode(childNode, key, value));
+          }
+        }
+      }
+      if (typeof value === "object") {
+        pathStack.push({ key, value });
+        recursivelyAutoActivateInner(value, pathStack, getNodeAtPath2);
+        pathStack.pop();
+      }
+    }
+  }
 }
 
-const fns = ['get', 'set', 'peek', 'onChange', 'toggle'];
+// src/ObservablePrimitive.ts
+var fns = ["get", "set", "peek", "onChange", "toggle"];
 function ObservablePrimitiveClass(node) {
-    this._node = node;
-    // Bind to this
-    for (let i = 0; i < fns.length; i++) {
-        const key = fns[i];
-        this[key] = this[key].bind(this);
-    }
+  this._node = node;
+  for (let i = 0; i < fns.length; i++) {
+    const key = fns[i];
+    this[key] = this[key].bind(this);
+  }
 }
-// Add observable functions to prototype
 function proto(key, fn) {
-    ObservablePrimitiveClass.prototype[key] = function (...args) {
-        return fn.call(this, this._node, ...args);
-    };
+  ObservablePrimitiveClass.prototype[key] = function(...args) {
+    return fn.call(this, this._node, ...args);
+  };
 }
-proto('peek', (node) => {
-    flushPending();
-    return peek(node);
+proto("peek", (node) => {
+  flushPending();
+  return peek(node);
 });
-proto('get', (node, options) => {
-    flushPending();
-    return get(node, options);
+proto("get", (node, options) => {
+  flushPending();
+  return get(node, options);
 });
-proto('set', set);
-proto('onChange', onChange);
-// Getters
+proto("set", set);
+proto("onChange", onChange);
 Object.defineProperty(ObservablePrimitiveClass.prototype, symbolGetNode, {
-    configurable: true,
-    get() {
-        return this._node;
-    },
+  configurable: true,
+  get() {
+    return this._node;
+  }
 });
-ObservablePrimitiveClass.prototype.toggle = function () {
-    const value = this.peek();
-    if (value === undefined || value === null || isBoolean(value)) {
-        this.set(!value);
-    }
-    else if (process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') {
-        throw new Error('[legend-state] Cannot toggle a non-boolean value');
-    }
+ObservablePrimitiveClass.prototype.toggle = function() {
+  const value = this.peek();
+  if (value === void 0 || value === null || isBoolean(value)) {
+    this.set(!value);
+  } else if (process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") {
+    throw new Error("[legend-state] Cannot toggle a non-boolean value");
+  }
 };
-ObservablePrimitiveClass.prototype.delete = function () {
-    this.set(undefined);
-    return this;
+ObservablePrimitiveClass.prototype.delete = function() {
+  this.set(void 0);
+  return this;
 };
 
+// src/observable.ts
 function observable(value) {
-    return createObservable(value, false, extractPromise, getProxy, ObservablePrimitiveClass);
+  return createObservable(value, false, extractPromise, getProxy, ObservablePrimitiveClass);
 }
 function observablePrimitive(value) {
-    return createObservable(value, true, extractPromise, getProxy, ObservablePrimitiveClass);
+  return createObservable(value, true, extractPromise, getProxy, ObservablePrimitiveClass);
 }
 function syncState(obs) {
-    const node = getNode(obs);
-    if (!node.state) {
-        peekInternal(node);
-    }
-    if (!node.state) {
-        node.state = observable({});
-    }
-    return node.state;
+  const node = getNode(obs);
+  if (!node.state) {
+    peekInternal(node);
+  }
+  if (!node.state) {
+    node.state = observable({});
+  }
+  return node.state;
 }
 
-function computed(get, set) {
-    return observable(set ? linked({ get: get, set: ({ value }) => set(value) }) : get);
+// src/computed.ts
+function computed(get2, set2) {
+  return observable(
+    set2 ? linked({ get: get2, set: ({ value }) => set2(value) }) : get2
+  );
 }
 
-function configureLegendState({ observableFunctions, observableProperties: observableProperties$1, jsonReplacer, jsonReviver, }) {
-    if (observableFunctions) {
-        for (const key in observableFunctions) {
-            const fn = observableFunctions[key];
-            observableFns.set(key, fn);
-            ObservablePrimitiveClass.prototype[key] = function (...args) {
-                return fn.call(this, this._node, ...args);
-            };
-        }
-    }
-    if (observableProperties$1) {
-        for (const key in observableProperties$1) {
-            const fns = observableProperties$1[key];
-            observableProperties.set(key, fns);
-            Object.defineProperty(ObservablePrimitiveClass.prototype, key, {
-                configurable: true,
-                get() {
-                    return fns.get.call(this, this._node);
-                },
-                set(value) {
-                    return fns.set.call(this, this._node, value);
-                },
-            });
+// src/config.ts
+function configureLegendState({
+  observableFunctions,
+  observableProperties: observableProperties2,
+  jsonReplacer,
+  jsonReviver
+}) {
+  if (observableFunctions) {
+    for (const key in observableFunctions) {
+      const fn = observableFunctions[key];
+      observableFns.set(key, fn);
+      ObservablePrimitiveClass.prototype[key] = function(...args) {
+        return fn.call(this, this._node, ...args);
+      };
+    }
+  }
+  if (observableProperties2) {
+    for (const key in observableProperties2) {
+      const fns2 = observableProperties2[key];
+      observableProperties.set(key, fns2);
+      Object.defineProperty(ObservablePrimitiveClass.prototype, key, {
+        configurable: true,
+        get() {
+          return fns2.get.call(this, this._node);
+        },
+        set(value) {
+          return fns2.set.call(this, this._node, value);
         }
+      });
     }
-    if (jsonReplacer) {
-        globalState.replacer = jsonReplacer;
-    }
-    if (jsonReviver) {
-        globalState.reviver = jsonReviver;
-    }
+  }
+  if (jsonReplacer) {
+    globalState.replacer = jsonReplacer;
+  }
+  if (jsonReviver) {
+    globalState.reviver = jsonReviver;
+  }
 }
 
+// src/event.ts
 function event() {
-    // event simply wraps around a number observable
-    // which increments its value to dispatch change events
-    const obs = observable(0);
-    const node = getNode(obs);
-    node.isEvent = true;
-    return {
-        fire: function () {
-            // Notify increments the value so that the observable changes
-            obs.set((v) => v + 1);
-        },
-        on: function (cb) {
-            return obs.onChange(cb);
-        },
-        get: function () {
-            // Return the value so that when will be truthy
-            return obs.get();
-        },
-        // @ts-expect-error eslint doesn't like adding symbols to the object but this does work
-        [symbolGetNode]: node,
-    };
+  const obs = observable(0);
+  const node = getNode(obs);
+  node.isEvent = true;
+  return {
+    fire: function() {
+      obs.set((v) => v + 1);
+    },
+    on: function(cb) {
+      return obs.onChange(cb);
+    },
+    get: function() {
+      return obs.get();
+    },
+    // @ts-expect-error eslint doesn't like adding symbols to the object but this does work
+    [symbolGetNode]: node
+  };
 }
 
-function proxy(get, set) {
-    return observable((key) => set
-        ? linked({
-            get: () => get(key),
-            set: ({ value }) => set(key, value),
-        })
-        : get(key));
+// src/proxy.ts
+function proxy(get2, set2) {
+  return observable(
+    (key) => set2 ? linked({
+      get: () => get2(key),
+      set: ({ value }) => set2(key, value)
+    }) : get2(key)
+  );
 }
 
+// src/retry.ts
 function calculateRetryDelay(retryOptions, attemptNum) {
-    const { backoff, delay = 1000, infinite, times = 3, maxDelay = 30000 } = retryOptions;
-    if (infinite || attemptNum < times) {
-        const delayTime = Math.min(delay * (backoff === 'constant' ? 1 : 2 ** attemptNum), maxDelay);
-        return delayTime;
-    }
-    return null;
+  const { backoff, delay = 1e3, infinite, times = 3, maxDelay = 3e4 } = retryOptions;
+  if (infinite || attemptNum < times) {
+    const delayTime = Math.min(delay * (backoff === "constant" ? 1 : 2 ** attemptNum), maxDelay);
+    return delayTime;
+  }
+  return null;
 }
 function createRetryTimeout(retryOptions, attemptNum, fn) {
-    const delayTime = calculateRetryDelay(retryOptions, attemptNum);
-    if (delayTime) {
-        return setTimeout(fn, delayTime);
-    }
+  const delayTime = calculateRetryDelay(retryOptions, attemptNum);
+  if (delayTime) {
+    return setTimeout(fn, delayTime);
+  }
 }
 function runWithRetry(node, state, fn) {
-    const { waitFor } = node.activationState;
-    const { retry } = state;
-    const e = { cancel: false };
-    let value = undefined;
-    if (waitFor) {
-        value = whenReady(waitFor, () => {
-            node.activationState.waitFor = undefined;
-            return fn(e);
-        });
-    }
-    else {
-        value = fn(e);
-    }
-    if (isPromise(value) && retry) {
-        let timeoutRetry;
-        return new Promise((resolve) => {
-            const run = () => {
-                value
-                    .then((val) => {
-                    node.activationState.persistedRetry = false;
-                    resolve(val);
-                })
-                    .catch(() => {
-                    state.attemptNum++;
-                    if (timeoutRetry) {
-                        clearTimeout(timeoutRetry);
-                    }
-                    if (!e.cancel) {
-                        timeoutRetry = createRetryTimeout(retry, state.attemptNum, () => {
-                            value = fn(e);
-                            run();
-                        });
-                    }
-                })
-                    .finally(() => {
-                    node.activationState.persistedRetry = false;
-                });
-            };
-            run();
+  const { waitFor } = node.activationState;
+  const { retry } = state;
+  const e = { cancel: false };
+  let value = void 0;
+  if (waitFor) {
+    value = whenReady(waitFor, () => {
+      node.activationState.waitFor = void 0;
+      return fn(e);
+    });
+  } else {
+    value = fn(e);
+  }
+  if (isPromise(value) && retry) {
+    let timeoutRetry;
+    return new Promise((resolve) => {
+      const run = () => {
+        value.then((val) => {
+          node.activationState.persistedRetry = false;
+          resolve(val);
+        }).catch(() => {
+          state.attemptNum++;
+          if (timeoutRetry) {
+            clearTimeout(timeoutRetry);
+          }
+          if (!e.cancel) {
+            timeoutRetry = createRetryTimeout(retry, state.attemptNum, () => {
+              value = fn(e);
+              run();
+            });
+          }
+        }).finally(() => {
+          node.activationState.persistedRetry = false;
         });
-    }
-    return value;
+      };
+      run();
+    });
+  }
+  return value;
 }
 
-const internal = {
-    createPreviousHandler,
-    clone,
-    ensureNodeValue,
-    findIDKey,
-    get,
-    getNode,
-    getNodeValue,
-    getPathType,
-    getProxy,
-    getValueAtPath: getValueAtPath$1,
-    globalState,
-    initializePathType,
-    observableFns,
-    optimized,
-    peek,
-    runWithRetry,
-    safeParse,
-    safeStringify,
-    set,
-    setAtPath,
-    setNodeValue,
-    symbolLinked,
-    symbolDelete,
-    tracking,
+// index.ts
+var internal = {
+  createPreviousHandler,
+  clone,
+  ensureNodeValue,
+  findIDKey,
+  get,
+  getNode,
+  getNodeValue,
+  getPathType,
+  getProxy,
+  getValueAtPath,
+  globalState,
+  initializePathType,
+  observableFns,
+  optimized,
+  peek,
+  runWithRetry,
+  safeParse,
+  safeStringify,
+  set,
+  setAtPath,
+  setNodeValue,
+  symbolLinked,
+  symbolDelete,
+  tracking
 };
 
 exports.ObservablePrimitiveClass = ObservablePrimitiveClass;
@@ -2509,4 +2349,3 @@ exports.tracking = tracking;
 exports.updateTracking = updateTracking;
 exports.when = when;
 exports.whenReady = whenReady;
-//# sourceMappingURL=index.js.map