@ng-org/alien-deepsignals 0.1.2

package/dist/index.js

@@ -0,0 +1,975 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/core.ts
+
+
+
+
+
+
+
+
+var _aliensignals = require('alien-signals');
+
+
+
+
+
+
+function tagSignal(fn) {
+  Object.defineProperty(fn, "__v_isSignal" /* IS_SIGNAL */, { value: true });
+  Object.defineProperty(fn, "value", {
+    get: () => fn(),
+    set: (v) => fn(v)
+  });
+  if (!fn.peek) Object.defineProperty(fn, "peek", { value: () => fn() });
+  if (!fn.get) Object.defineProperty(fn, "get", { value: () => fn() });
+  if (!fn.set) Object.defineProperty(fn, "set", { value: (v) => fn(v) });
+  return fn;
+}
+function tagComputed(fn) {
+  Object.defineProperty(fn, "__v_isSignal" /* IS_SIGNAL */, { value: true });
+  Object.defineProperty(fn, "value", { get: () => fn() });
+  if (!fn.peek) Object.defineProperty(fn, "peek", { value: () => fn() });
+  if (!fn.get) Object.defineProperty(fn, "get", { value: () => fn() });
+  return fn;
+}
+var signal2 = (v) => tagSignal(_aliensignals.signal.call(void 0, v));
+var computed2 = (getter) => tagComputed(_aliensignals.computed.call(void 0, getter));
+var isSignal = (s) => typeof s === "function" && !!s && !!s["__v_isSignal" /* IS_SIGNAL */];
+function batch(fn) {
+  _aliensignals.startBatch.call(void 0, );
+  try {
+    return fn();
+  } finally {
+    _aliensignals.endBatch.call(void 0, );
+  }
+}
+
+// src/iteratorHelpers.ts
+function hasNativeIteratorHelpers() {
+  return typeof Iterator !== "undefined" && typeof Iterator.from === "function";
+}
+var iteratorHelperKeys = /* @__PURE__ */ new Set([
+  "map",
+  "filter",
+  "take",
+  "drop",
+  "flatMap",
+  "reduce",
+  "toArray",
+  "forEach",
+  "some",
+  "every",
+  "find"
+]);
+function createIteratorWithHelpers(nextImpl, sourceIterator) {
+  const base = {
+    next: nextImpl,
+    [Symbol.iterator]() {
+      return this;
+    },
+    return() {
+      if (sourceIterator && typeof sourceIterator.return === "function") {
+        sourceIterator.return();
+      }
+      return { value: void 0, done: true };
+    }
+  };
+  if (hasNativeIteratorHelpers()) {
+    return Iterator.from(base);
+  }
+  return base;
+}
+
+// src/deepSignal.ts
+var rawToProxy = /* @__PURE__ */ new WeakMap();
+var proxyToMeta = /* @__PURE__ */ new WeakMap();
+var proxySignals = /* @__PURE__ */ new WeakMap();
+var iterableSignals = /* @__PURE__ */ new WeakMap();
+var ignored = /* @__PURE__ */ new WeakSet();
+var rootStates = /* @__PURE__ */ new Map();
+var pendingRoots = /* @__PURE__ */ new Set();
+var supported = /* @__PURE__ */ new Set([Object, Array, Set]);
+var descriptor = Object.getOwnPropertyDescriptor;
+var blankNodeCounter = 0;
+var wellKnownSymbols = /* @__PURE__ */ new Set([
+  Symbol.asyncDispose,
+  Symbol.asyncIterator,
+  Symbol.dispose,
+  Symbol.hasInstance,
+  Symbol.iterator,
+  Symbol.isConcatSpreadable,
+  Symbol.match,
+  Symbol.matchAll,
+  Symbol.metadata,
+  Symbol.replace,
+  Symbol.search,
+  Symbol.species,
+  Symbol.split,
+  Symbol.toPrimitive,
+  Symbol.toStringTag,
+  Symbol.unscopables
+]);
+var forcedSyntheticIds = /* @__PURE__ */ new WeakMap();
+var META_KEY = "__meta__";
+var RAW_KEY = "__raw__";
+var DEFAULT_SYNTHETIC_ID_PROPERTY_NAME = "@id";
+function getMeta(target) {
+  if (!target || typeof target !== "object") return void 0;
+  return proxyToMeta.get(target);
+}
+function getRaw(value) {
+  const meta = getMeta(value);
+  return _nullishCoalesce(_optionalChain([meta, 'optionalAccess', _ => _.raw]), () => ( value));
+}
+function shouldProxy(value) {
+  return !!value && typeof value === "object" && supported.has(value.constructor) && !ignored.has(value);
+}
+function ensureSignalMap(proxy) {
+  if (!proxySignals.has(proxy)) proxySignals.set(proxy, /* @__PURE__ */ new Map());
+  return proxySignals.get(proxy);
+}
+function setSignalValue(signals, key, value) {
+  if (!signals.has(key)) {
+    signals.set(key, signal2(value));
+    return;
+  }
+  const existing = signals.get(key);
+  if (typeof existing.set === "function") {
+    existing.set(value);
+  }
+}
+function ensureIterableSignal(target) {
+  if (!iterableSignals.has(target)) iterableSignals.set(target, signal2(0));
+  return iterableSignals.get(target);
+}
+function touchIterable(target) {
+  if (!iterableSignals.has(target)) return;
+  const sig = iterableSignals.get(target);
+  sig.set(sig() + 1);
+}
+function hasGetter(target, key) {
+  return typeof _optionalChain([descriptor, 'call', _2 => _2(target, key), 'optionalAccess', _3 => _3.get]) === "function";
+}
+function ensureComputed(signals, target, key, receiver) {
+  if (!signals.has(key) && hasGetter(target, key)) {
+    signals.set(
+      key,
+      computed2(() => Reflect.get(target, key, receiver))
+    );
+  }
+}
+function escapePathSegment(segment) {
+  return segment.replace(/~/g, "~0").replace(/\//g, "~1").replace(/\|/g, "~2");
+}
+function isReactiveSymbol(key) {
+  return typeof key === "symbol" && !wellKnownSymbols.has(key);
+}
+function buildPath(meta, key, skipEscape = false) {
+  const path = [];
+  const format = (segment) => {
+    if (typeof segment === "symbol") {
+      return _nullishCoalesce(segment.description, () => ( segment.toString()));
+    }
+    return segment;
+  };
+  const push = (segment, synthetic = false) => {
+    if (typeof segment === "number") {
+      path.unshift(segment);
+      return;
+    }
+    const normalized = format(segment);
+    path.unshift(
+      synthetic || skipEscape ? normalized : escapePathSegment(String(normalized))
+    );
+  };
+  push(key, skipEscape);
+  let cursor = meta;
+  while (cursor && cursor.parent && cursor.key !== void 0) {
+    push(cursor.key, !!cursor.isSyntheticId);
+    cursor = getMeta(cursor.parent);
+  }
+  return path;
+}
+function resolveContainerPath(meta) {
+  if (!meta || !meta.parent || meta.key === void 0) return [];
+  const parentMeta = getMeta(meta.parent);
+  return buildPath(parentMeta, meta.key, !!meta.isSyntheticId);
+}
+function schedulePatch(meta, build) {
+  if (!meta) return;
+  const state = rootStates.get(meta.root);
+  const hasListeners = state && (state.listeners.size > 0 || state.justInTimeListeners.size > 0);
+  if (!hasListeners) return;
+  const result = build();
+  if (!result) return;
+  const patches = Array.isArray(result) ? result : [result];
+  if (!patches.length) return;
+  state.pendingPatches.push(...patches);
+  state.justInTimeListeners.forEach((cb) => cb({ patches }));
+  if (state.listeners.size > 0 && !pendingRoots.has(meta.root)) {
+    pendingRoots.add(meta.root);
+    queueMicrotask(() => {
+      pendingRoots.delete(meta.root);
+      const state2 = rootStates.get(meta.root);
+      if (!state2) return;
+      if (!state2.pendingPatches.length || state2.listeners.size === 0) {
+        state2.pendingPatches.length = 0;
+        return;
+      }
+      state2.version += 1;
+      const batch2 = {
+        version: state2.version,
+        patches: state2.pendingPatches.slice()
+      };
+      state2.pendingPatches.length = 0;
+      state2.listeners.forEach((cb) => cb(batch2));
+    });
+  }
+}
+function applyPropGeneratorResult(meta, value, basePath, inSet) {
+  if (!value || typeof value !== "object" || value.constructor !== Object || !_optionalChain([meta, 'access', _4 => _4.options, 'optionalAccess', _5 => _5.propGenerator])) {
+    return;
+  }
+  const result = meta.options.propGenerator({
+    path: basePath,
+    inSet,
+    object: value
+  });
+  if (result.extraProps) {
+    Object.entries(result.extraProps).forEach(([k, v]) => {
+      value[k] = v;
+    });
+  }
+  if (result.syntheticId !== void 0 && meta.options.syntheticIdPropertyName && !(meta.options.syntheticIdPropertyName in value)) {
+    Object.defineProperty(value, meta.options.syntheticIdPropertyName, {
+      value: result.syntheticId,
+      enumerable: true,
+      configurable: false,
+      writable: false
+    });
+  }
+}
+function initializeObjectTree(meta, value, basePath, inSet) {
+  if (!_optionalChain([meta, 'access', _6 => _6.options, 'optionalAccess', _7 => _7.propGenerator])) return;
+  if (!value || typeof value !== "object") return;
+  if (Array.isArray(value)) {
+    value.forEach((entry, idx) => {
+      if (entry && typeof entry === "object") {
+        initializeObjectTree(meta, entry, [...basePath, idx], false);
+      }
+    });
+    return;
+  }
+  if (value instanceof Set) {
+    for (const entry of value) {
+      if (entry && typeof entry === "object") {
+        const synthetic = assignSyntheticId(
+          meta,
+          entry,
+          basePath,
+          true
+        );
+        initializeObjectTree(
+          meta,
+          entry,
+          [...basePath, synthetic],
+          true
+        );
+      }
+    }
+    return;
+  }
+  if (value.constructor !== Object) return;
+  applyPropGeneratorResult(meta, value, basePath, inSet);
+  Object.keys(value).forEach((childKey) => {
+    if (childKey === meta.options.syntheticIdPropertyName) return;
+    const child = value[childKey];
+    if (child && typeof child === "object") {
+      initializeObjectTree(meta, child, [...basePath, childKey], false);
+    }
+  });
+}
+function initializeObjectTreeIfNoListeners(meta, basePath, value, inSet) {
+  if (!meta || !_optionalChain([meta, 'access', _8 => _8.options, 'optionalAccess', _9 => _9.propGenerator])) return;
+  if (!value || typeof value !== "object") return;
+  const state = rootStates.get(meta.root);
+  if (state && (state.listeners.size > 0 || state.justInTimeListeners.size > 0))
+    return;
+  initializeObjectTree(meta, value, _nullishCoalesce(basePath, () => ( [])), inSet);
+}
+function ensureChildProxy(value, parentProxy, key, isSyntheticId = false) {
+  if (!shouldProxy(value)) return value;
+  if (rawToProxy.has(value)) {
+    const proxied = rawToProxy.get(value);
+    const proxiedMeta = getMeta(proxied);
+    if (proxiedMeta) {
+      proxiedMeta.parent = parentProxy;
+      proxiedMeta.key = key;
+      proxiedMeta.isSyntheticId = isSyntheticId;
+    }
+    return proxied;
+  }
+  const parentMeta = getMeta(parentProxy);
+  if (!parentMeta) return value;
+  const proxy = createProxy(
+    value,
+    parentMeta.root,
+    parentMeta.options,
+    parentProxy,
+    key,
+    isSyntheticId
+  );
+  return proxy;
+}
+function ensureSetInfo(meta) {
+  if (!meta.setInfo) {
+    meta.setInfo = {
+      idForObject: /* @__PURE__ */ new WeakMap(),
+      objectForId: /* @__PURE__ */ new Map()
+    };
+  }
+  return meta.setInfo;
+}
+function assignSyntheticId(meta, entry, path, inSet) {
+  const rawEntry = getRaw(entry);
+  if (!rawEntry || typeof rawEntry !== "object") {
+    return rawEntry;
+  }
+  const info = ensureSetInfo(meta);
+  if (info.idForObject.has(rawEntry)) return info.idForObject.get(rawEntry);
+  let synthetic = forcedSyntheticIds.get(rawEntry);
+  const generatorValue = _optionalChain([meta, 'access', _10 => _10.options, 'optionalAccess', _11 => _11.propGenerator, 'optionalCall', _12 => _12({
+    path,
+    inSet,
+    object: rawEntry
+  })]);
+  if (synthetic === void 0 && _optionalChain([generatorValue, 'optionalAccess', _13 => _13.syntheticId]) !== void 0) {
+    synthetic = generatorValue.syntheticId;
+  }
+  if (_optionalChain([generatorValue, 'optionalAccess', _14 => _14.extraProps]) && rawEntry && typeof rawEntry === "object") {
+    Object.entries(generatorValue.extraProps).forEach(([k, v]) => {
+      rawEntry[k] = v;
+    });
+  }
+  const idPropName = _optionalChain([meta, 'access', _15 => _15.options, 'optionalAccess', _16 => _16.syntheticIdPropertyName]);
+  if (synthetic === void 0 && idPropName && rawEntry && typeof rawEntry === "object" && rawEntry[idPropName] !== void 0) {
+    synthetic = rawEntry[idPropName];
+  }
+  if (synthetic === void 0) {
+    synthetic = `_s${++blankNodeCounter}`;
+  }
+  const idString = String(synthetic);
+  info.idForObject.set(rawEntry, idString);
+  info.objectForId.set(idString, rawEntry);
+  if (idPropName && rawEntry && typeof rawEntry === "object" && !(idPropName in rawEntry)) {
+    Object.defineProperty(rawEntry, idPropName, {
+      value: idString,
+      enumerable: true,
+      configurable: false,
+      writable: false
+    });
+  }
+  return idString;
+}
+function createProxy(target, root, options, parent, key, isSyntheticId) {
+  const handlers = target instanceof Set ? setHandlers : objectHandlers;
+  const proxy = new Proxy(target, handlers);
+  const meta = {
+    raw: target,
+    parent,
+    key,
+    isSyntheticId,
+    root,
+    options
+  };
+  proxyToMeta.set(proxy, meta);
+  proxySignals.set(proxy, /* @__PURE__ */ new Map());
+  rawToProxy.set(target, proxy);
+  return proxy;
+}
+function ensureValueForWrite(value, receiver, key) {
+  const rawValue = getRaw(value);
+  const proxied = shouldProxy(rawValue) ? ensureChildProxy(rawValue, receiver, key) : rawValue;
+  return { raw: rawValue, proxied };
+}
+function snapshotLiteral(value) {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  return void 0;
+}
+function emitPatchesForNew(value, meta, basePath, inSet = false) {
+  applyPropGeneratorResult(meta, value, basePath, inSet);
+  if (value === null || value === void 0 || typeof value !== "object") {
+    const literal = snapshotLiteral(value);
+    if (literal === void 0) return [];
+    return [
+      {
+        path: basePath,
+        op: "add",
+        value: literal
+      }
+    ];
+  }
+  const patches = [
+    {
+      path: basePath,
+      op: "add",
+      type: value instanceof Set ? "set" : "object",
+      value: value instanceof Set ? [] : void 0
+    }
+  ];
+  const idPropName = meta.options.syntheticIdPropertyName;
+  if (idPropName in value) {
+    const literal = snapshotLiteral(value[idPropName]);
+    if (literal !== void 0) {
+      patches.push({
+        path: [...basePath, idPropName],
+        op: "add",
+        value: literal
+      });
+    }
+  }
+  if (Array.isArray(value)) {
+    value.forEach((entry, idx) => {
+      patches.push(...emitPatchesForNew(entry, meta, [...basePath, idx]));
+    });
+  } else if (value instanceof Set) {
+    const setMeta = ensureSetInfo(meta);
+    for (const entry of value) {
+      if (entry && typeof entry === "object") {
+        const synthetic = assignSyntheticId(
+          meta,
+          entry,
+          basePath,
+          true
+        );
+        setMeta.objectForId.set(String(synthetic), entry);
+        patches.push(
+          ...emitPatchesForNew(
+            entry,
+            meta,
+            [...basePath, synthetic],
+            true
+          )
+        );
+      } else {
+        const literal = snapshotLiteral(entry);
+        if (literal !== void 0) {
+          patches.push({
+            path: basePath,
+            op: "add",
+            type: "set",
+            value: [literal]
+          });
+        }
+      }
+    }
+  } else {
+    Object.keys(value).forEach((childKey) => {
+      if (childKey === idPropName) return;
+      patches.push(
+        ...emitPatchesForNew(value[childKey], meta, [
+          ...basePath,
+          childKey
+        ])
+      );
+    });
+  }
+  return patches;
+}
+var objectHandlers = {
+  get(target, key, receiver) {
+    if (key === RAW_KEY) return _nullishCoalesce(_optionalChain([getMeta, 'call', _17 => _17(receiver), 'optionalAccess', _18 => _18.raw]), () => ( target));
+    if (key === META_KEY) return getMeta(receiver);
+    if (typeof key === "symbol") {
+      if (key === Symbol.iterator) {
+        const iterableSig = ensureIterableSignal(target);
+        iterableSig();
+      }
+      if (!isReactiveSymbol(key))
+        return Reflect.get(target, key, receiver);
+    }
+    const signals = ensureSignalMap(receiver);
+    ensureComputed(signals, target, key, receiver);
+    if (!signals.has(key)) {
+      let rawValue = Reflect.get(target, key, receiver);
+      if (typeof rawValue === "function")
+        return rawValue.bind(_nullishCoalesce(receiver, () => ( target)));
+      rawValue = shouldProxy(rawValue) ? ensureChildProxy(rawValue, receiver, key) : rawValue;
+      signals.set(key, signal2(rawValue));
+    }
+    const sig = signals.get(key);
+    return sig();
+  },
+  set(target, key, value, receiver) {
+    if (typeof key === "symbol" && !isReactiveSymbol(key))
+      return Reflect.set(target, key, value, receiver);
+    const meta = getMeta(receiver);
+    if (_optionalChain([meta, 'optionalAccess', _19 => _19.options, 'optionalAccess', _20 => _20.readOnlyProps, 'optionalAccess', _21 => _21.includes, 'call', _22 => _22(String(key))])) {
+      throw new Error(`Cannot modify readonly property '${String(key)}'`);
+    }
+    const path = meta ? buildPath(meta, key) : void 0;
+    const desc = descriptor(target, key);
+    const hasAccessor = !!desc && (typeof desc.get === "function" || typeof desc.set === "function");
+    const { raw, proxied } = ensureValueForWrite(value, receiver, key);
+    const hadKey = Object.prototype.hasOwnProperty.call(target, key);
+    const previous = hadKey ? target[key] : void 0;
+    const result = Reflect.set(target, key, raw, receiver);
+    if (!hasAccessor) {
+      const signals = ensureSignalMap(receiver);
+      setSignalValue(signals, key, proxied);
+    }
+    if (!hadKey) touchIterable(target);
+    if (meta && path && typeof raw === "object") {
+      initializeObjectTreeIfNoListeners(meta, path, raw, false);
+    }
+    schedulePatch(meta, () => {
+      const resolvedPath = _nullishCoalesce(path, () => ( buildPath(meta, key)));
+      if (!hadKey || typeof raw === "object") {
+        return emitPatchesForNew(raw, meta, resolvedPath);
+      }
+      if (snapshotLiteral(raw) === void 0) return void 0;
+      return {
+        path: resolvedPath,
+        op: "add",
+        value: raw
+      };
+    });
+    return result;
+  },
+  deleteProperty(target, key) {
+    if (typeof key === "symbol" && !isReactiveSymbol(key))
+      return Reflect.deleteProperty(target, key);
+    const receiver = rawToProxy.get(target);
+    const meta = receiver ? getMeta(receiver) : void 0;
+    const hadKey = Object.prototype.hasOwnProperty.call(target, key);
+    const result = Reflect.deleteProperty(target, key);
+    if (hadKey) {
+      if (receiver && proxySignals.has(receiver)) {
+        const signals = proxySignals.get(receiver);
+        const existing = signals.get(key);
+        if (existing && typeof existing.set === "function") {
+          existing.set(void 0);
+        }
+        signals.delete(key);
+      }
+      touchIterable(target);
+      schedulePatch(meta, () => ({
+        path: buildPath(meta, key),
+        op: "remove"
+      }));
+    }
+    return result;
+  },
+  ownKeys(target) {
+    const sig = ensureIterableSignal(target);
+    sig();
+    return Reflect.ownKeys(target);
+  }
+};
+function ensureEntryProxy(receiver, entry, syntheticKey, meta) {
+  return shouldProxy(entry) ? ensureChildProxy(entry, receiver, syntheticKey, true) : entry;
+}
+function createSetIterator(target, receiver, mapValue) {
+  const iterator = target.values();
+  const iterableSignal = ensureIterableSignal(target);
+  iterableSignal();
+  return createIteratorWithHelpers(() => {
+    const next = iterator.next();
+    if (next.done) return next;
+    const meta = getMeta(receiver);
+    const proxied = ensureEntryProxy(
+      receiver,
+      next.value,
+      assignSyntheticId(meta, next.value, [], true),
+      meta
+    );
+    return {
+      value: mapValue(proxied),
+      done: false
+    };
+  });
+}
+var setHandlers = {
+  get(target, key, receiver) {
+    if (key === RAW_KEY) return _nullishCoalesce(_optionalChain([getMeta, 'call', _23 => _23(receiver), 'optionalAccess', _24 => _24.raw]), () => ( target));
+    if (key === META_KEY) return getMeta(receiver);
+    if (key === "size") {
+      const sig = ensureIterableSignal(target);
+      sig();
+      return target.size;
+    }
+    if (key === "first") {
+      return function first() {
+        const iterableSig = ensureIterableSignal(target);
+        iterableSig();
+        const iterator = target.values().next();
+        if (iterator.done) return void 0;
+        const meta = getMeta(receiver);
+        return ensureEntryProxy(
+          receiver,
+          iterator.value,
+          assignSyntheticId(meta, iterator.value, [], true),
+          meta
+        );
+      };
+    }
+    if (key === "getById") {
+      return function getById(id) {
+        const iterableSig = ensureIterableSignal(target);
+        iterableSig();
+        const meta = getMeta(receiver);
+        if (!_optionalChain([meta, 'optionalAccess', _25 => _25.setInfo])) return void 0;
+        const entry = meta.setInfo.objectForId.get(String(id));
+        if (!entry) return void 0;
+        return ensureEntryProxy(receiver, entry, String(id), meta);
+      };
+    }
+    if (key === "getBy") {
+      return function getBy(graphIri, subjectIri) {
+        const iterableSig = ensureIterableSignal(target);
+        iterableSig();
+        return this.getById(`${graphIri}|${subjectIri}`);
+      };
+    }
+    if (key === "add") {
+      return function add(value) {
+        const meta = getMeta(receiver);
+        const containerPath = resolveContainerPath(meta);
+        const rawValue = getRaw(value);
+        const sizeBefore = target.size;
+        const result = target.add(rawValue);
+        if (target.size !== sizeBefore) {
+          touchIterable(target);
+          if (rawValue && typeof rawValue === "object") {
+            const synthetic = assignSyntheticId(
+              meta,
+              rawValue,
+              containerPath,
+              true
+            );
+            initializeObjectTreeIfNoListeners(
+              meta,
+              [...containerPath, synthetic],
+              rawValue,
+              true
+            );
+            ensureEntryProxy(receiver, rawValue, synthetic, meta);
+            schedulePatch(
+              meta,
+              () => emitPatchesForNew(
+                rawValue,
+                meta,
+                [...containerPath, synthetic],
+                true
+              )
+            );
+          } else {
+            const literal = snapshotLiteral(rawValue);
+            if (literal !== void 0) {
+              schedulePatch(meta, () => ({
+                path: containerPath,
+                op: "add",
+                type: "set",
+                value: [literal]
+              }));
+            }
+          }
+        }
+        return receiver;
+      };
+    }
+    if (key === "delete") {
+      return function deleteEntry(value) {
+        const meta = getMeta(receiver);
+        const containerPath = resolveContainerPath(meta);
+        const rawValue = getRaw(value);
+        const synthetic = rawValue && typeof rawValue === "object" ? ensureSetInfo(meta).idForObject.get(rawValue) : rawValue;
+        const existed = target.delete(rawValue);
+        if (existed && synthetic !== void 0) {
+          touchIterable(target);
+          if (rawValue && typeof rawValue === "object") {
+            schedulePatch(meta, () => ({
+              path: [...containerPath, synthetic],
+              op: "remove"
+            }));
+            if (meta.setInfo) {
+              meta.setInfo.objectForId.delete(String(synthetic));
+              meta.setInfo.idForObject.delete(rawValue);
+            }
+          } else {
+            schedulePatch(meta, () => ({
+              path: containerPath,
+              op: "remove",
+              type: "set",
+              value: rawValue
+            }));
+          }
+        }
+        return existed;
+      };
+    }
+    if (key === "clear") {
+      return function clear() {
+        const meta = getMeta(receiver);
+        const containerPath = resolveContainerPath(meta);
+        if (meta.setInfo) {
+          meta.setInfo.objectForId.clear();
+          meta.setInfo.idForObject = /* @__PURE__ */ new WeakMap();
+        }
+        target.clear();
+        touchIterable(target);
+        schedulePatch(meta, () => ({
+          path: containerPath,
+          op: "add",
+          type: "set",
+          value: []
+        }));
+      };
+    }
+    if (key === Symbol.iterator) {
+      return function iterator() {
+        return createSetIterator(target, receiver, (value) => value);
+      };
+    }
+    if (key === "values" || key === "keys") {
+      return function values() {
+        return createSetIterator(target, receiver, (value) => value);
+      };
+    }
+    if (key === "entries") {
+      return function entries() {
+        return createSetIterator(target, receiver, (value) => [
+          value,
+          value
+        ]);
+      };
+    }
+    if (typeof key === "string" && iteratorHelperKeys.has(key)) {
+      return function iteratorHelper(...args) {
+        const iterator = createSetIterator(
+          target,
+          receiver,
+          (value) => value
+        );
+        const helper = iterator[key];
+        if (typeof helper !== "function") {
+          throw new TypeError(
+            `Iterator helper '${String(key)}' is not available`
+          );
+        }
+        return helper.apply(iterator, args);
+      };
+    }
+    if (key === "forEach") {
+      return function forEach(callback, thisArg) {
+        const iterableSig = ensureIterableSignal(target);
+        iterableSig();
+        const meta = getMeta(receiver);
+        let index = 0;
+        const expectsIteratorSignature = callback.length <= 2;
+        const iteratorCallback = callback;
+        target.forEach((entry) => {
+          const proxied = ensureEntryProxy(
+            receiver,
+            entry,
+            assignSyntheticId(meta, entry, [], true),
+            meta
+          );
+          if (expectsIteratorSignature) {
+            iteratorCallback.call(thisArg, proxied, index++);
+          } else {
+            callback.call(thisArg, proxied, proxied, receiver);
+          }
+        });
+      };
+    }
+    if (key === "has") {
+      return function has(value) {
+        return target.has(getRaw(value));
+      };
+    }
+    return Reflect.get(target, key, receiver);
+  }
+};
+function isDeepSignal(value) {
+  return !!getMeta(value);
+}
+function deepSignal(input, options) {
+  if (isDeepSignal(input)) return input;
+  if (!shouldProxy(input))
+    throw new Error("deepSignal() expects an object, array, or Set");
+  if (rawToProxy.has(input)) return rawToProxy.get(input);
+  const root = Symbol("deepSignalRoot");
+  const rootState = {
+    options: {
+      syntheticIdPropertyName: DEFAULT_SYNTHETIC_ID_PROPERTY_NAME,
+      ...options
+    },
+    version: 0,
+    listeners: /* @__PURE__ */ new Set(),
+    justInTimeListeners: /* @__PURE__ */ new Set(),
+    pendingPatches: []
+  };
+  rootStates.set(root, rootState);
+  const proxy = createProxy(input, root, rootState.options);
+  return proxy;
+}
+function subscribeDeepMutations(root, cb, triggerInstantly = false) {
+  const rootId = typeof root === "symbol" ? root : getDeepSignalRootId(root);
+  if (!rootId)
+    throw new Error("subscribeDeepMutations() expects a deepSignal root");
+  const state = rootStates.get(rootId);
+  if (!state) throw new Error("Unknown deepSignal root");
+  if (triggerInstantly) {
+    state.justInTimeListeners.add(cb);
+    return () => {
+      state.justInTimeListeners.delete(cb);
+    };
+  } else {
+    state.listeners.add(cb);
+    return () => {
+      state.listeners.delete(cb);
+    };
+  }
+}
+function getDeepSignalRootId(value) {
+  return _optionalChain([getMeta, 'call', _26 => _26(value), 'optionalAccess', _27 => _27.root]);
+}
+function getDeepSignalVersion(root) {
+  const rootId = typeof root === "symbol" ? root : getDeepSignalRootId(root);
+  if (!rootId) return void 0;
+  return _optionalChain([rootStates, 'access', _28 => _28.get, 'call', _29 => _29(rootId), 'optionalAccess', _30 => _30.version]);
+}
+function shallow(obj) {
+  ignored.add(obj);
+  return obj;
+}
+function setSetEntrySyntheticId(obj, id) {
+  if (!obj || typeof obj !== "object") return;
+  forcedSyntheticIds.set(getRaw(obj), String(id));
+}
+function addWithId(set, entry, id) {
+  if (entry && typeof entry === "object") {
+    setSetEntrySyntheticId(entry, id);
+  }
+  set.add(entry);
+  if (entry && typeof entry === "object") {
+    const getter = _optionalChain([set, 'optionalAccess', _31 => _31.getById]);
+    if (typeof getter === "function") {
+      const proxied = getter.call(set, String(id));
+      if (proxied) return proxied;
+    }
+  }
+  return entry;
+}
+
+// src/watch.ts
+function watch(source, callback, options = {}) {
+  if (!isDeepSignal(source)) {
+    throw new Error("watch() expects a deepSignal root proxy");
+  }
+  const rootId = getDeepSignalRootId(source);
+  if (!rootId) throw new Error("Unable to resolve deepSignal root id");
+  let active = true;
+  let cleanup;
+  const { immediate, once } = options;
+  const registerCleanup = (fn) => {
+    cleanup = fn;
+  };
+  const runCleanup = () => {
+    if (!cleanup) return;
+    try {
+      cleanup();
+    } finally {
+      cleanup = void 0;
+    }
+  };
+  const stopListening = () => {
+    if (!active) return;
+    active = false;
+    runCleanup();
+    unsubscribe();
+  };
+  const deliver = (batch2) => {
+    if (!active) return;
+    runCleanup();
+    const next = source;
+    callback({
+      patches: batch2.patches,
+      version: batch2.version,
+      newValue: next
+    });
+    if (once) stopListening();
+  };
+  const unsubscribe = subscribeDeepMutations(
+    rootId,
+    (batch2) => {
+      if (!batch2.patches.length) return;
+      deliver(batch2);
+    },
+    options.triggerInstantly
+  );
+  if (immediate) {
+    deliver({
+      patches: [],
+      version: _nullishCoalesce(getDeepSignalVersion(rootId), () => ( 0))
+    });
+  }
+  return {
+    stopListening,
+    registerCleanup
+  };
+}
+
+// src/effect.ts
+function effect2(run) {
+  let cleanup;
+  const registerCleanup = (fn) => {
+    cleanup = fn;
+  };
+  const stop = _aliensignals.effect.call(void 0, () => {
+    if (cleanup) {
+      try {
+        cleanup();
+      } finally {
+        cleanup = void 0;
+      }
+    }
+    run(registerCleanup);
+  });
+  return () => {
+    if (cleanup) {
+      try {
+        cleanup();
+      } finally {
+        cleanup = void 0;
+      }
+    }
+    stop();
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports._rawComputed = _aliensignals.computed; exports._rawEffect = _aliensignals.effect; exports._rawEndBatch = _aliensignals.endBatch; exports._rawGetCurrentSub = _aliensignals.getCurrentSub; exports._rawSetCurrentSub = _aliensignals.setCurrentSub; exports._rawSignal = _aliensignals.signal; exports._rawStartBatch = _aliensignals.startBatch; exports.addWithId = addWithId; exports.batch = batch; exports.computed = computed2; exports.deepSignal = deepSignal; exports.effect = effect2; exports.getDeepSignalRootId = getDeepSignalRootId; exports.getDeepSignalVersion = getDeepSignalVersion; exports.isDeepSignal = isDeepSignal; exports.isSignal = isSignal; exports.setSetEntrySyntheticId = setSetEntrySyntheticId; exports.shallow = shallow; exports.signal = signal2; exports.subscribeDeepMutations = subscribeDeepMutations; exports.watch = watch;