@estjs/signals 0.0.15-beta.1

package/dist/signals.dev.cjs.js

@@ -0,0 +1,1947 @@
+'use strict';
+
+var shared = require('@estjs/shared');
+
+/**
+* @estjs/signals v0.0.15-beta.1
+* (c) 2023-Present jiangxd <jiangxd2016@gmail.com>
+* @license MIT
+**/
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// src/constants.ts
+var TriggerOpTypes = {
+  SET: "SET",
+  ADD: "ADD",
+  DELETE: "DELETE",
+  CLEAR: "CLEAR"
+};
+var SIGNAL_KEY = Symbol("Signal_Key" );
+var ARRAY_KEY = Symbol("Array_Key" );
+var COLLECTION_KEY = Symbol("Collection_Key" );
+var WEAK_COLLECTION_KEY = Symbol("WeakCollection_Key" );
+var ARRAY_ITERATE_KEY = Symbol("Array_Iterate_Key" );
+
+// src/propagation.ts
+function propagate(link) {
+  let next = link.nextSubLink;
+  let stack;
+  top: do {
+    const sub = link.subNode;
+    const queueBit = sub.flag & 64 /* QUEUED */;
+    const watcherBit = sub.flag & 2 /* WATCHING */;
+    let flags = sub.flag & -65 /* QUEUED */;
+    if (!(flags & (16 /* DIRTY */ | 32 /* PENDING */ | 8 /* RECURSED */ | 4 /* RECURSED_CHECK */))) {
+      sub.flag = queueBit | watcherBit | flags | 32 /* PENDING */;
+    } else if (flags & (16 /* DIRTY */ | 32 /* PENDING */)) ; else if (!(flags & (8 /* RECURSED */ | 4 /* RECURSED_CHECK */))) {
+      flags = 0 /* NONE */;
+      sub.flag = queueBit | watcherBit;
+    } else if (!(flags & 4 /* RECURSED_CHECK */)) {
+      sub.flag = queueBit | watcherBit | (flags & -9 /* RECURSED */ | 32 /* PENDING */);
+    } else if (!(flags & (16 /* DIRTY */ | 32 /* PENDING */)) && isValidLink(link, sub)) {
+      sub.flag = queueBit | watcherBit | (flags | 8 /* RECURSED */ | 32 /* PENDING */);
+      flags &= 1 /* MUTABLE */;
+    } else {
+      flags = 0 /* NONE */;
+      sub.flag = queueBit | watcherBit;
+    }
+    if (sub.flag & 2 /* WATCHING */) {
+      enqueueEffect(sub);
+    }
+    if (flags & 1 /* MUTABLE */) {
+      const subSubs = sub.subLink;
+      if (subSubs) {
+        const nextSub = (link = subSubs).nextSubLink;
+        if (nextSub) {
+          stack = { value: next, prev: stack };
+          next = nextSub;
+        }
+        continue;
+      }
+    }
+    if (next) {
+      link = next;
+      next = link.nextSubLink;
+      continue;
+    }
+    while (stack) {
+      link = stack.value;
+      stack = stack.prev;
+      if (link) {
+        next = link.nextSubLink;
+        continue top;
+      }
+    }
+    break;
+  } while (true);
+}
+function shallowPropagate(link) {
+  while (link) {
+    const sub = link.subNode;
+    const queueBit = sub.flag & 64 /* QUEUED */;
+    const flags = sub.flag & -65 /* QUEUED */;
+    if (!(flags & 16 /* DIRTY */) && flags & (1 /* MUTABLE */ | 32 /* PENDING */)) {
+      const newFlags = queueBit | flags & -33 /* PENDING */ | 16 /* DIRTY */;
+      sub.flag = newFlags;
+      if (newFlags & 2 /* WATCHING */) {
+        enqueueEffect(sub);
+      }
+      if (flags & 1 /* MUTABLE */ && sub.subLink) {
+        shallowPropagate(sub.subLink);
+      }
+    }
+    link = link.nextSubLink;
+  }
+}
+function enqueueEffect(effect2) {
+  if (!effect2.active) {
+    return;
+  }
+  effect2.notify();
+}
+
+// src/link.ts
+var currentLinkVersion = 0;
+var activeSub;
+var isUntracking = false;
+function linkReactiveNode(depNode, subNode) {
+  if (isUntracking) {
+    return void 0;
+  }
+  const prevDep = subNode.depLinkTail;
+  if (prevDep && prevDep.depNode === depNode) {
+    return prevDep;
+  }
+  const nextDep = prevDep ? prevDep.nextDepLink : subNode.depLink;
+  if (nextDep && nextDep.depNode === depNode) {
+    nextDep.version = currentLinkVersion;
+    subNode.depLinkTail = nextDep;
+    return nextDep;
+  }
+  const prevSub = depNode.subLinkTail;
+  if (prevSub && prevSub.version === currentLinkVersion && prevSub.subNode === subNode) {
+    subNode.depLinkTail = prevSub;
+    return prevSub;
+  }
+  const newLink = {
+    version: currentLinkVersion,
+    depNode,
+    subNode,
+    // Subscriber chain pointers (horizontal)
+    prevSubLink: prevSub,
+    nextSubLink: void 0,
+    // Dependency chain pointers (vertical)
+    prevDepLink: prevDep,
+    nextDepLink: nextDep
+  };
+  if (nextDep) {
+    nextDep.prevDepLink = newLink;
+  }
+  if (prevDep) {
+    prevDep.nextDepLink = newLink;
+  } else {
+    subNode.depLink = newLink;
+  }
+  if (prevSub) {
+    prevSub.nextSubLink = newLink;
+  } else {
+    depNode.subLink = newLink;
+  }
+  depNode.subLinkTail = newLink;
+  subNode.depLinkTail = newLink;
+  {
+    if (subNode.onTrack && shared.isFunction(subNode == null ? void 0 : subNode.onTrack)) {
+      subNode.onTrack({
+        effect: subNode,
+        target: depNode,
+        type: "get",
+        key: void 0
+      });
+    }
+  }
+  return newLink;
+}
+function unlinkReactiveNode(linkNode, subNode = linkNode.subNode) {
+  const depNode = linkNode.depNode;
+  const prevSub = linkNode.prevSubLink;
+  const nextSub = linkNode.nextSubLink;
+  const prevDep = linkNode.prevDepLink;
+  const nextDep = linkNode.nextDepLink;
+  if (nextDep) {
+    nextDep.prevDepLink = prevDep;
+  } else {
+    subNode.depLinkTail = prevDep;
+  }
+  if (prevDep) {
+    prevDep.nextDepLink = nextDep;
+  } else {
+    subNode.depLink = nextDep;
+  }
+  if (nextSub) {
+    nextSub.prevSubLink = prevSub;
+  } else {
+    depNode.subLinkTail = prevSub;
+  }
+  if (prevSub) {
+    prevSub.nextSubLink = nextSub;
+  } else {
+    depNode.subLink = nextSub;
+    if (nextSub === void 0) {
+      let toRemove = depNode.depLink;
+      while (toRemove) {
+        toRemove = unlinkReactiveNode(toRemove, depNode);
+      }
+      depNode.depLinkTail = void 0;
+      depNode.flag |= 16 /* DIRTY */;
+      {
+        if (depNode.depLink) {
+          shared.error(
+            "[Link] Cascading cleanup failed: depNode still has dependency links. This indicates a bug in the unlinking logic."
+          );
+        }
+      }
+    }
+  }
+  linkNode.depNode = void 0;
+  linkNode.subNode = void 0;
+  linkNode.prevSubLink = void 0;
+  linkNode.nextSubLink = void 0;
+  linkNode.prevDepLink = void 0;
+  linkNode.nextDepLink = void 0;
+  return nextDep;
+}
+function checkDirty(link, sub) {
+  const stack = [{ link, owner: sub }];
+  const pendingNodes = [];
+  while (stack.length > 0) {
+    const frame = stack.pop();
+    let current = frame.link;
+    const owner = frame.owner;
+    while (current) {
+      const dep = current.depNode;
+      const depFlags = dep.flag;
+      if (owner.flag & 16 /* DIRTY */) {
+        return true;
+      }
+      if ((depFlags & (1 /* MUTABLE */ | 16 /* DIRTY */)) === (1 /* MUTABLE */ | 16 /* DIRTY */)) {
+        const subs = dep.subLink;
+        if (subs && subs.nextSubLink) {
+          shallowPropagate2(subs);
+        }
+        for (const node of pendingNodes) {
+          if (node.flag & 32 /* PENDING */) {
+            node.flag = node.flag & -33 /* PENDING */ | 16 /* DIRTY */;
+          }
+        }
+        return true;
+      }
+      if ((depFlags & (1 /* MUTABLE */ | 32 /* PENDING */)) === (1 /* MUTABLE */ | 32 /* PENDING */)) {
+        if (dep.depLink) {
+          pendingNodes.push(dep);
+          stack.push({ link: dep.depLink, owner: dep });
+        } else {
+          dep.flag &= -33 /* PENDING */;
+        }
+      } else if (depFlags & 32 /* PENDING */) {
+        dep.flag &= -33 /* PENDING */;
+      }
+      current = current.nextDepLink;
+    }
+  }
+  for (const node of pendingNodes) {
+    node.flag &= -33 /* PENDING */;
+  }
+  if (sub.flag & 32 /* PENDING */) {
+    sub.flag &= -33 /* PENDING */;
+  }
+  return false;
+}
+function shallowPropagate2(link) {
+  while (link) {
+    const sub = link.subNode;
+    const queueBit = sub.flag & 64 /* QUEUED */;
+    const flags = sub.flag & -65 /* QUEUED */;
+    if ((flags & (32 /* PENDING */ | 16 /* DIRTY */)) === 32 /* PENDING */) {
+      sub.flag = queueBit | flags | 16 /* DIRTY */;
+    }
+    link = link.nextSubLink;
+  }
+}
+function setActiveSub(sub) {
+  const prev = activeSub;
+  activeSub = sub;
+  return prev;
+}
+function startTracking(sub) {
+  currentLinkVersion++;
+  sub.depLinkTail = void 0;
+  sub.flag = sub.flag & -57 | 4 /* RECURSED_CHECK */;
+  return setActiveSub(sub);
+}
+function endTracking(sub, prevSub) {
+  activeSub = prevSub;
+  const depsTail = sub.depLinkTail;
+  let toRemove = depsTail ? depsTail.nextDepLink : sub.depLink;
+  while (toRemove) {
+    toRemove = unlinkReactiveNode(toRemove, sub);
+  }
+  sub.flag &= -5 /* RECURSED_CHECK */;
+}
+function untrack(fn) {
+  const prevSub = setActiveSub(void 0);
+  const prevUntracking = isUntracking;
+  isUntracking = true;
+  try {
+    return fn();
+  } finally {
+    isUntracking = prevUntracking;
+    setActiveSub(prevSub);
+  }
+}
+function isValidLink(checkLink, sub) {
+  let link = sub.depLinkTail;
+  while (link) {
+    if (link === checkLink) {
+      return true;
+    }
+    link = link.prevDepLink;
+  }
+  return false;
+}
+var targetMap = /* @__PURE__ */ new WeakMap();
+function track(target, key) {
+  if (!activeSub || isUntracking) {
+    return;
+  }
+  let depsMap = targetMap.get(target);
+  if (!depsMap) {
+    depsMap = /* @__PURE__ */ new Map();
+    targetMap.set(target, depsMap);
+  }
+  let dep = depsMap.get(key);
+  if (!dep) {
+    dep = /* @__PURE__ */ new Set();
+    depsMap.set(key, dep);
+  }
+  if (!dep.has(activeSub)) {
+    dep.add(activeSub);
+    if (shared.isFunction(activeSub.onTrack)) {
+      activeSub.onTrack({
+        effect: activeSub,
+        target,
+        type: "get",
+        key
+      });
+    }
+  }
+}
+function trigger(target, type, key, newValue) {
+  const depsMap = targetMap.get(target);
+  if (!depsMap) {
+    return;
+  }
+  const effects = /* @__PURE__ */ new Set();
+  if (key !== void 0) {
+    if (Array.isArray(key)) {
+      key.forEach((k) => {
+        const dep = depsMap.get(k);
+        if (dep) {
+          dep.forEach((effect2) => effects.add(effect2));
+        }
+      });
+    } else {
+      const dep = depsMap.get(key);
+      if (dep) {
+        dep.forEach((effect2) => effects.add(effect2));
+      }
+    }
+  }
+  if (type === "ADD" || type === "DELETE" || type === "CLEAR") {
+    const ITERATE_KEY2 = Symbol("iterate");
+    const ARRAY_ITERATE_KEY2 = Symbol("arrayIterate");
+    const iterationKey = Array.isArray(target) ? ARRAY_ITERATE_KEY2 : ITERATE_KEY2;
+    const iterationDep = depsMap.get(iterationKey);
+    if (iterationDep) {
+      iterationDep.forEach((effect2) => effects.add(effect2));
+    }
+  }
+  effects.forEach((effect2) => {
+    var _a5;
+    if (shared.isFunction(effect2.onTrigger)) {
+      effect2.onTrigger({
+        effect: effect2,
+        target,
+        type,
+        key,
+        newValue
+      });
+    }
+    if (effect2.flag & 2 /* WATCHING */) {
+      (_a5 = effect2.notify) == null ? void 0 : _a5.call(effect2);
+    } else if (effect2.flag & 1 /* MUTABLE */) {
+      effect2.flag |= 16 /* DIRTY */;
+      if (effect2.subLink) {
+        propagate(effect2.subLink);
+      }
+    }
+  });
+}
+var reactiveCaches = /* @__PURE__ */ new WeakMap();
+function toRaw(value) {
+  if (!value || !shared.isObject(value)) {
+    return value;
+  }
+  const raw = value["_RAW" /* RAW */];
+  if (raw) {
+    return toRaw(raw);
+  }
+  if (isSignal(value)) {
+    return toRaw(value.peek());
+  }
+  return value;
+}
+var arrayInstrumentations = createArrayInstrumentations();
+function createArrayInstrumentations() {
+  const instrumentations = {};
+  ["includes", "indexOf", "lastIndexOf"].forEach((key) => {
+    instrumentations[key] = function(...args) {
+      const arr = toRaw(this);
+      track(arr, ARRAY_ITERATE_KEY);
+      let res = arr[key](...args);
+      if ((res === -1 || res === false) && args.length > 0) {
+        const rawArgs = args.map((arg) => toRaw(arg));
+        res = arr[key](...rawArgs);
+      }
+      return res;
+    };
+  });
+  ["find", "findIndex", "findLast", "findLastIndex"].forEach((key) => {
+    instrumentations[key] = function(...args) {
+      const arr = toRaw(this);
+      const isShallowMode = isShallow(this);
+      track(arr, ARRAY_ITERATE_KEY);
+      const res = arr[key](...args);
+      if ((key === "find" || key === "findLast") && shared.isObject(res) && !isShallowMode) {
+        return reactiveImpl(res);
+      }
+      return res;
+    };
+  });
+  ["push", "pop", "shift", "unshift", "splice", "sort", "reverse", "fill", "copyWithin"].forEach(
+    (key) => {
+      instrumentations[key] = function(...args) {
+        const arr = toRaw(this);
+        const res = Array.prototype[key].apply(arr, args);
+        trigger(arr, TriggerOpTypes.SET, ARRAY_KEY);
+        trigger(arr, TriggerOpTypes.SET, ARRAY_ITERATE_KEY);
+        return res;
+      };
+    }
+  );
+  ["toReversed", "toSorted", "toSpliced"].forEach((key) => {
+    instrumentations[key] = function(...args) {
+      const arr = toRaw(this);
+      const isShallowMode = isShallow(this);
+      track(arr, ARRAY_ITERATE_KEY);
+      if (key === "toSpliced") {
+        for (let i = 0, l = arr.length; i < l; i++) {
+          track(arr, `${i}`);
+        }
+      }
+      const res = Array.prototype[key].apply(arr, args);
+      if (!Array.isArray(res)) {
+        return res;
+      }
+      return res.map((item) => shared.isObject(item) ? reactiveImpl(item, isShallowMode) : item);
+    };
+  });
+  ["concat", "slice", "filter", "map", "flatMap", "flat"].forEach((key) => {
+    instrumentations[key] = function(...args) {
+      const arr = toRaw(this);
+      track(arr, ARRAY_ITERATE_KEY);
+      const res = Array.prototype[key].apply(arr, args);
+      return res;
+    };
+  });
+  ["join", "toString", "toLocaleString"].forEach((key) => {
+    instrumentations[key] = function(...args) {
+      const arr = toRaw(this);
+      track(arr, ARRAY_ITERATE_KEY);
+      return Array.prototype[key].apply(arr, args);
+    };
+  });
+  ["values", "keys", "entries", Symbol.iterator].forEach((key) => {
+    instrumentations[key] = function() {
+      const arr = toRaw(this);
+      const isShallowMode = isShallow(this);
+      track(arr, ARRAY_KEY);
+      const rawIterator = key === Symbol.iterator ? arr[Symbol.iterator]() : arr[key]();
+      return {
+        next() {
+          const { value, done } = rawIterator.next();
+          if (done) {
+            return { value, done };
+          }
+          if (Array.isArray(value)) {
+            return {
+              value: value.map((v) => shared.isObject(v) ? reactiveImpl(v, isShallowMode) : v),
+              done
+            };
+          }
+          return {
+            value: shared.isObject(value) ? reactiveImpl(value, isShallowMode) : value,
+            done
+          };
+        },
+        [Symbol.iterator]() {
+          return this;
+        }
+      };
+    };
+  });
+  return instrumentations;
+}
+var arrayHandlers = (shallow) => ({
+  get: (target, key, receiver) => {
+    if (key === "_RAW" /* RAW */) {
+      return target;
+    }
+    if (key === "_IS_REACTIVE" /* IS_REACTIVE */) {
+      return true;
+    }
+    if (key === "_IS_SHALLOW" /* IS_SHALLOW */) {
+      return shallow;
+    }
+    if (shared.hasOwn(arrayInstrumentations, key)) {
+      return arrayInstrumentations[key];
+    }
+    const value = Reflect.get(target, key, receiver);
+    if (shared.isStringNumber(key)) {
+      track(target, key);
+    }
+    track(target, ARRAY_KEY);
+    if (shared.isObject(value) && !shallow) {
+      return reactiveImpl(value);
+    }
+    return value;
+  },
+  set: (target, key, value, receiver) => {
+    const oldValue = Reflect.get(target, key, receiver);
+    const result = Reflect.set(target, key, value, receiver);
+    if (shared.hasChanged(value, oldValue)) {
+      if (shared.isStringNumber(key)) {
+        trigger(target, TriggerOpTypes.SET, [key, ARRAY_ITERATE_KEY, ARRAY_KEY]);
+      } else {
+        trigger(target, TriggerOpTypes.SET, key);
+      }
+    }
+    return result;
+  }
+});
+var shallowArrayHandlers = arrayHandlers(true);
+var deepArrayHandlers = arrayHandlers(false);
+var collectionHandlers = {
+  get(target, key) {
+    if (key === "_IS_REACTIVE" /* IS_REACTIVE */) {
+      return true;
+    }
+    if (key === "_RAW" /* RAW */) {
+      return target;
+    }
+    return Reflect.get(
+      shared.hasOwn(collectionInstrumentations, key) ? collectionInstrumentations : target,
+      key,
+      target
+    );
+  }
+};
+var weakCollectionHandlers = {
+  get(target, key) {
+    if (key === "_IS_REACTIVE" /* IS_REACTIVE */) {
+      return true;
+    }
+    if (key === "_RAW" /* RAW */) {
+      return target;
+    }
+    return Reflect.get(
+      shared.hasOwn(weakInstrumentations, key) && key in target ? weakInstrumentations : target,
+      key,
+      target
+    );
+  }
+};
+var collectionInstrumentations = {
+  get(key) {
+    const target = toRaw(this);
+    track(target, COLLECTION_KEY);
+    const value = target.get(key);
+    if (shared.isObject(value) && !isShallow(this)) {
+      return reactiveImpl(value);
+    }
+    return value;
+  },
+  set(key, value) {
+    const target = toRaw(this);
+    const hadKey = target.has(key);
+    const oldValue = target.get(key);
+    const rawValue = toRaw(value);
+    target.set(key, rawValue);
+    if (!hadKey || shared.hasChanged(oldValue, rawValue)) {
+      trigger(target, TriggerOpTypes.SET, COLLECTION_KEY);
+    }
+    return this;
+  },
+  add(value) {
+    const target = toRaw(this);
+    const rawValue = toRaw(value);
+    const hadValue = target.has(rawValue);
+    target.add(rawValue);
+    if (!hadValue) {
+      trigger(target, TriggerOpTypes.ADD, COLLECTION_KEY);
+    } else {
+      trigger(target, TriggerOpTypes.SET, COLLECTION_KEY);
+    }
+    return this;
+  },
+  has(key) {
+    const target = toRaw(this);
+    track(target, COLLECTION_KEY);
+    const hasKey = target.has(key);
+    if (!hasKey && shared.isObject(key)) {
+      return target.has(toRaw(key));
+    }
+    return hasKey;
+  },
+  delete(key) {
+    const target = toRaw(this);
+    const hadKey = target.has(key);
+    let result = target.delete(key);
+    if (!result && shared.isObject(key)) {
+      result = target.delete(toRaw(key));
+    }
+    if (hadKey || result) {
+      trigger(target, TriggerOpTypes.DELETE, COLLECTION_KEY);
+    }
+    return result;
+  },
+  clear() {
+    const target = toRaw(this);
+    const hadItems = target.size > 0;
+    const result = target.clear();
+    if (hadItems) {
+      trigger(target, TriggerOpTypes.CLEAR, COLLECTION_KEY);
+    }
+    return result;
+  },
+  forEach(callback, thisArg) {
+    const target = toRaw(this);
+    const isShallowMode = isShallow(this);
+    track(target, COLLECTION_KEY);
+    target.forEach((value, key) => {
+      const wrappedValue = isShallowMode || !shared.isObject(value) ? value : reactiveImpl(value);
+      const wrappedKey = isShallowMode || !shared.isObject(key) ? key : reactiveImpl(key);
+      callback.call(thisArg, wrappedValue, wrappedKey, this);
+    });
+  },
+  [Symbol.iterator]() {
+    const target = toRaw(this);
+    const isShallowMode = isShallow(this);
+    track(target, COLLECTION_KEY);
+    const rawIterator = target[Symbol.iterator]();
+    return {
+      next() {
+        const { value, done } = rawIterator.next();
+        if (done) {
+          return { value, done };
+        }
+        if (isShallowMode) {
+          return { value, done };
+        }
+        if (Array.isArray(value)) {
+          return {
+            value: value.map((v) => shared.isObject(v) ? reactiveImpl(v) : v),
+            done
+          };
+        }
+        return {
+          value: shared.isObject(value) ? reactiveImpl(value) : value,
+          done
+        };
+      },
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  },
+  get size() {
+    const target = toRaw(this);
+    track(target, COLLECTION_KEY);
+    return target.size;
+  },
+  keys() {
+    const target = toRaw(this);
+    const isShallowMode = isShallow(this);
+    track(target, COLLECTION_KEY);
+    const rawIterator = target.keys();
+    return {
+      next() {
+        const { value, done } = rawIterator.next();
+        if (done) {
+          return { value, done };
+        }
+        return {
+          value: isShallowMode || !shared.isObject(value) ? value : reactiveImpl(value),
+          done
+        };
+      },
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  },
+  values() {
+    const target = toRaw(this);
+    const isShallowMode = isShallow(this);
+    track(target, COLLECTION_KEY);
+    const rawIterator = target.values();
+    return {
+      next() {
+        const { value, done } = rawIterator.next();
+        if (done) {
+          return { value, done };
+        }
+        return {
+          value: isShallowMode || !shared.isObject(value) ? value : reactiveImpl(value),
+          done
+        };
+      },
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  },
+  entries() {
+    const target = toRaw(this);
+    const isShallowMode = isShallow(this);
+    track(target, COLLECTION_KEY);
+    const rawIterator = target.entries();
+    return {
+      next() {
+        const { value, done } = rawIterator.next();
+        if (done) {
+          return { value, done };
+        }
+        if (isShallowMode) {
+          return { value, done };
+        }
+        return {
+          value: value.map((v) => shared.isObject(v) ? reactiveImpl(v) : v),
+          done
+        };
+      },
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  }
+};
+var weakInstrumentations = {
+  get(key) {
+    const target = toRaw(this);
+    track(target, WEAK_COLLECTION_KEY);
+    let value = target.get(key);
+    if (value === void 0 && isReactive(key)) {
+      value = target.get(toRaw(key));
+    }
+    if (shared.isObject(value) && !isShallow(this)) {
+      return reactiveImpl(value);
+    }
+    return value;
+  },
+  set(key, value) {
+    const target = toRaw(this);
+    const rawKey = toRaw(key);
+    const hadKey = target.has(rawKey);
+    const oldValue = target.get(rawKey);
+    const rawValue = toRaw(value);
+    target.set(rawKey, rawValue);
+    if (!hadKey || shared.hasChanged(oldValue, rawValue)) {
+      trigger(target, TriggerOpTypes.SET, WEAK_COLLECTION_KEY);
+    }
+    return this;
+  },
+  add(value) {
+    const target = toRaw(this);
+    const rawValue = toRaw(value);
+    const hadValue = target.has(rawValue);
+    target.add(rawValue);
+    if (!hadValue) {
+      trigger(target, TriggerOpTypes.ADD, WEAK_COLLECTION_KEY);
+    }
+    return this;
+  },
+  has(key) {
+    const target = toRaw(this);
+    track(target, WEAK_COLLECTION_KEY);
+    let hasKey = target.has(key);
+    if (!hasKey && isReactive(key)) {
+      hasKey = target.has(toRaw(key));
+    }
+    return hasKey;
+  },
+  delete(key) {
+    const target = toRaw(this);
+    const rawKey = toRaw(key);
+    const hadKey = target.has(rawKey);
+    const result = target.delete(rawKey);
+    if (hadKey || result) {
+      trigger(target, TriggerOpTypes.DELETE, WEAK_COLLECTION_KEY);
+    }
+    return result;
+  }
+};
+var objectHandlers = (shallow) => ({
+  get(target, key, receiver) {
+    if (key === "_RAW" /* RAW */) {
+      return target;
+    }
+    if (key === "_IS_REACTIVE" /* IS_REACTIVE */) {
+      return true;
+    }
+    if (key === "_IS_SHALLOW" /* IS_SHALLOW */) {
+      return shallow;
+    }
+    const value = Reflect.get(target, key, receiver);
+    const valueUnwrapped = isSignal(value) ? value.value : value;
+    track(target, key);
+    if (shared.isObject(valueUnwrapped) && !shallow) {
+      return reactiveImpl(valueUnwrapped);
+    }
+    return valueUnwrapped;
+  },
+  set: (target, key, value, receiver) => {
+    const oldValue = Reflect.get(target, key, receiver);
+    const result = Reflect.set(target, key, toRaw(value), receiver);
+    if (shared.hasChanged(value, oldValue)) {
+      trigger(target, TriggerOpTypes.SET, key, value);
+    }
+    return result;
+  },
+  deleteProperty: (target, key) => {
+    const hadKey = shared.hasOwn(target, key);
+    const result = Reflect.deleteProperty(target, key);
+    if (hadKey && result) {
+      trigger(target, TriggerOpTypes.DELETE, key, void 0);
+    }
+    return result;
+  }
+});
+function reactiveImpl(target, shallow = false) {
+  if (!shared.isObject(target)) {
+    return target;
+  }
+  if (isReactive(target)) {
+    return target;
+  }
+  const existingProxy = reactiveCaches.get(target);
+  if (existingProxy) {
+    return existingProxy;
+  }
+  let handler;
+  if (shared.isArray(target)) {
+    handler = shallow ? shallowArrayHandlers : deepArrayHandlers;
+  } else if (shared.isSet(target) || shared.isMap(target)) {
+    handler = collectionHandlers;
+  } else if (shared.isWeakMap(target) || shared.isWeakSet(target)) {
+    handler = weakCollectionHandlers;
+  } else {
+    handler = objectHandlers(shallow);
+  }
+  const proxy = new Proxy(target, handler);
+  reactiveCaches.set(target, proxy);
+  return proxy;
+}
+function isReactive(target) {
+  return !!(target && target["_IS_REACTIVE" /* IS_REACTIVE */]);
+}
+function reactive(target) {
+  if (isReactive(target)) {
+    {
+      shared.warn(
+        "[Reactive] Target is already reactive. Returning existing reactive proxy to avoid double wrapping."
+      );
+    }
+    return target;
+  }
+  if (isSignal(target)) {
+    {
+      shared.warn(
+        "[Reactive] Creating a reactive proxy from a signal is not recommended. Use the signal directly or access its value property."
+      );
+    }
+    return target;
+  }
+  return reactiveImpl(target);
+}
+function shallowReactive(target) {
+  if (isReactive(target)) {
+    {
+      if (isShallow(target)) {
+        shared.warn(
+          "[ShallowReactive] Target is already a shallow reactive proxy. Returning existing proxy to avoid double wrapping."
+        );
+      } else {
+        shared.warn(
+          "[ShallowReactive] Target is already a deep reactive proxy. Cannot convert deep reactive to shallow reactive. Returning existing proxy."
+        );
+      }
+    }
+    return target;
+  }
+  if (isSignal(target)) {
+    {
+      shared.warn(
+        "[ShallowReactive] Creating a reactive proxy from a signal is not recommended. Use the signal directly or access its value property."
+      );
+    }
+    return target;
+  }
+  return reactiveImpl(target, true);
+}
+function isShallow(value) {
+  return !!(value && value["_IS_SHALLOW" /* IS_SHALLOW */]);
+}
+var toReactive = (value) => shared.isObject(value) ? reactive(value) : value;
+
+// src/signal.ts
+var _a;
+_a = "_IS_SIGNAL" /* IS_SIGNAL */;
+var SignalImpl = class {
+  // Mark as Signal
+  /**
+   * Create a new Signal with the given initial value.
+   *
+   * @param value - Initial value
+   * @param shallow - Whether only the top level should be reactive
+   */
+  constructor(value, shallow = false) {
+    this.flag = 1 /* MUTABLE */;
+    // Mark whether it's shallow reactive
+    // @ts-ignore
+    this[_a] = true;
+    this._oldValue = this._rawValue = value;
+    if (shallow) {
+      this._value = shared.isObject(value) ? shallowReactive(value) : value;
+    } else {
+      this._value = shared.isObject(value) ? reactive(value) : value;
+    }
+    this["_IS_SHALLOW" /* IS_SHALLOW */] = shallow;
+  }
+  // dep getter, returns itself for dependency collection
+  get dep() {
+    return this;
+  }
+  get value() {
+    const sub = activeSub;
+    if (sub) {
+      linkReactiveNode(this, sub);
+    }
+    if (this.flag & 16 /* DIRTY */ && this.shouldUpdate()) {
+      const subs = this.subLink;
+      if (subs) {
+        shallowPropagate2(subs);
+      }
+    }
+    return this._value;
+  }
+  // value setter, triggers update when value changes
+  set value(value) {
+    if (isSignal(value)) {
+      {
+        shared.warn(
+          "Setting a signal value to another signal is not recommended. The value will be unwrapped automatically."
+        );
+      }
+      value = value.peek();
+    }
+    value = toRaw(value);
+    if (!shared.hasChanged(this._rawValue, value)) {
+      return;
+    }
+    this.flag |= 16 /* DIRTY */;
+    this._rawValue = value;
+    const shallow = this["_IS_SHALLOW" /* IS_SHALLOW */];
+    if (shallow) {
+      this._value = shared.isObject(value) ? shallowReactive(value) : value;
+    } else {
+      this._value = shared.isObject(value) ? reactive(value) : value;
+    }
+    const subs = this.subLink;
+    if (subs) {
+      propagate(subs);
+    }
+  }
+  // Check if the value should be update
+  shouldUpdate() {
+    this.flag &= -17 /* DIRTY */;
+    return shared.hasChanged(this._oldValue, this._oldValue = this._rawValue);
+  }
+  // Get current value without triggering dependency tracking
+  peek() {
+    return this._value;
+  }
+  // set method is an alias for the value setter
+  set(value) {
+    this.value = value;
+  }
+  // Update value using an updater function
+  update(updater) {
+    const nextValue = updater(this.peek());
+    if (isSignal(nextValue)) {
+      {
+        shared.warn(
+          "Returning a signal from an update function is not recommended. The value will be unwrapped."
+        );
+      }
+      this.value = nextValue.peek();
+    } else {
+      this.value = nextValue;
+    }
+  }
+};
+function signal(value) {
+  if (isSignal(value)) {
+    {
+      shared.warn(
+        "Creating a signal with another signal is not recommended. The value will be unwrapped."
+      );
+    }
+    return value;
+  }
+  return new SignalImpl(value);
+}
+function shallowSignal(value) {
+  if (isSignal(value)) {
+    {
+      shared.warn(
+        "Creating a shallow signal with another signal is not recommended. The value will be unwrapped."
+      );
+    }
+    value = value.peek();
+  }
+  return new SignalImpl(value, true);
+}
+function isSignal(value) {
+  return !!value && !!value["_IS_SIGNAL" /* IS_SIGNAL */];
+}
+var queue = /* @__PURE__ */ new Set();
+var activePreFlushCbs = /* @__PURE__ */ new Set();
+var p = Promise.resolve();
+var isFlushPending = false;
+function nextTick(fn) {
+  if (fn) {
+    return new Promise((resolve, reject) => {
+      queueMicrotask(() => {
+        try {
+          fn();
+          resolve();
+        } catch (error6) {
+          reject(error6);
+        }
+      });
+    });
+  }
+  return p;
+}
+function queueJob(job) {
+  queue.add(job);
+  queueFlush();
+}
+function queueFlush() {
+  if (!isFlushPending) {
+    isFlushPending = true;
+    nextTick(flushJobs);
+  }
+}
+function queuePreFlushCb(cb) {
+  activePreFlushCbs.add(cb);
+  queueFlush();
+}
+function flushJobs() {
+  isFlushPending = false;
+  flushPreFlushCbs();
+  while (queue.size > 0) {
+    const jobs = Array.from(queue);
+    queue.clear();
+    for (const job of jobs) {
+      try {
+        job();
+      } catch (_error) {
+        {
+          shared.error("Error executing queued job:", _error);
+        }
+      }
+    }
+  }
+}
+function flushPreFlushCbs() {
+  const callbacks = Array.from(activePreFlushCbs);
+  activePreFlushCbs.clear();
+  for (const callback of callbacks) {
+    try {
+      callback();
+    } catch (_error) {
+      {
+        shared.error("Error executing pre-flush callback:", _error);
+      }
+    }
+  }
+}
+function createScheduler(effect2, flush) {
+  switch (flush) {
+    case "sync":
+      return () => effect2();
+    case "pre":
+      return () => queuePreFlushCb(effect2);
+    case "post":
+      return () => queueJob(effect2);
+    default:
+      {
+        shared.warn(`Invalid flush timing: ${flush}. Defaulting to 'post'.`);
+      }
+      return () => queueJob(effect2);
+  }
+}
+
+// src/batch.ts
+var batchDepth = 0;
+function batch(fn) {
+  startBatch();
+  try {
+    return fn();
+  } finally {
+    endBatch();
+  }
+}
+function startBatch() {
+  batchDepth++;
+}
+function endBatch() {
+  if (batchDepth === 0) {
+    shared.warn(
+      "[Batch] endBatch() called without matching startBatch(). This may indicate unbalanced batch calls in your code."
+    );
+    return;
+  }
+  if (--batchDepth === 0) {
+    flushJobs();
+    if (batchDepth !== 0) {
+      shared.error(
+        `[Batch] Batch depth is not zero after endBatch(). Current depth: ${batchDepth}. This indicates a bug in batch management.`
+      );
+    }
+  }
+}
+function isBatching() {
+  return batchDepth > 0;
+}
+function getBatchDepth() {
+  return batchDepth;
+}
+
+// src/effect.ts
+var _a2;
+_a2 = "_IS_EFFECT" /* IS_EFFECT */;
+var EffectImpl = class {
+  /**
+   * Create an Effect instance
+   *
+   * @param fn - The effect function
+   * @param options - Configuration options
+   */
+  constructor(fn, options) {
+    this.flag = 2 /* WATCHING */ | 16 /* DIRTY */;
+    // @ts-ignore
+    this[_a2] = true;
+    // ===== State management =====
+    this._active = true;
+    this.fn = fn;
+    if (options) {
+      this.scheduler = options.flush || options.scheduler;
+      this.onStop = options.onStop;
+      this.onTrack = options.onTrack;
+      this.onTrigger = options.onTrigger;
+    }
+  }
+  /**
+   * Check if the Effect is active
+   */
+  get active() {
+    return this._active;
+  }
+  /**
+     * Check if the Effect is dirty (needs re-execution)
+  
+     */
+  get dirty() {
+    const flags = this.flag;
+    if (flags & 16 /* DIRTY */) {
+      return true;
+    }
+    if (flags & 32 /* PENDING */) {
+      if (this.depLink && checkDirty(this.depLink, this)) {
+        this.flag = flags & -33 /* PENDING */ | 16 /* DIRTY */;
+        return true;
+      }
+      this.flag = flags & -33 /* PENDING */;
+    }
+    return false;
+  }
+  /**
+   * Pause Effect execution
+   *
+   * When an effect is paused:
+   * - It stops responding to dependency changes
+   * - Notifications are ignored (see notify method)
+   * - DIRTY and PENDING flags are still set when dependencies change
+   * - The effect remains active and maintains its dependency links
+   *
+   * Use cases:
+   * - Temporarily disable effects during bulk updates
+   * - Prevent effects from running during initialization
+   * - Control when side effects should execute
+   *
+   * @example
+   * ```typescript
+   * const count = signal(0);
+   * const runner = effect(() => console.log(count.value));
+   *
+   * runner.effect.pause();
+   * count.value = 1; // Effect won't run
+   * count.value = 2; // Effect won't run
+   * runner.effect.resume(); // Effect runs once with latest value
+   * ```
+   */
+  pause() {
+    this.flag |= 256 /* PAUSED */;
+  }
+  /**
+   * Resume Effect execution
+   *
+   * When an effect is resumed:
+   * - The PAUSED flag is cleared
+   * - If dependencies changed during pause (DIRTY or PENDING flags set),
+   *   the effect executes immediately via notify()
+   * - If no changes occurred, the effect simply becomes active again
+   *
+   * State management:
+   * - Clears PAUSED flag atomically
+   * - Checks for accumulated DIRTY/PENDING flags
+   * - Triggers execution if needed
+   *
+   * @example
+   * ```typescript
+   * const count = signal(0);
+   * const runner = effect(() => console.log(count.value));
+   *
+   * runner.effect.pause();
+   * count.value = 1; // Queued
+   * count.value = 2; // Queued
+   * runner.effect.resume(); // Executes once with count.value = 2
+   * ```
+   */
+  resume() {
+    const flags = this.flag;
+    const nextFlags = flags & -257 /* PAUSED */;
+    this.flag = nextFlags;
+    const wasDirty = (nextFlags & 16 /* DIRTY */) !== 0;
+    const wasPending = (nextFlags & 32 /* PENDING */) !== 0;
+    if (wasDirty || wasPending) {
+      this.notify();
+    }
+  }
+  /**
+     * Execute the Effect function
+     *
+     * Core execution flow:
+     * 1. Check if active
+     * 2. Clear dirty flag
+     * 3. Start tracking dependencies
+     * 4. Execute user function
+     * 5. End tracking, clean up stale dependencies
+  
+     * @returns The return value of the effect function
+     */
+  run() {
+    if (!this._active) {
+      return this.fn();
+    }
+    const flags = this.flag;
+    this.flag = flags & -17 /* DIRTY */ | 1024 /* STOP */;
+    const prevSub = startTracking(this);
+    try {
+      return this.fn();
+    } catch (error6) {
+      this.flag |= 16 /* DIRTY */;
+      throw error6;
+    } finally {
+      this.flag &= -1025 /* STOP */;
+      endTracking(this, prevSub);
+    }
+  }
+  /**
+   * Get or create the job function for this effect
+   */
+  getJob() {
+    if (!this._job) {
+      this._job = () => this.run();
+    }
+    return this._job;
+  }
+  /**
+   * Notify that the Effect needs to execute
+   *
+   * Called by dependent reactive values.
+   * Decides whether to execute immediately or defer based on scheduling strategy.
+   */
+  notify() {
+    const flags = this.flag;
+    if (!this._active || flags & (256 /* PAUSED */ | 1024 /* STOP */ | 16 /* DIRTY */)) {
+      return;
+    }
+    this.flag = flags | 16 /* DIRTY */;
+    if (this.onTrigger) {
+      this.onTrigger({
+        effect: this,
+        target: {},
+        type: "set"
+      });
+    }
+    if (this.scheduler) {
+      if (shared.isFunction(this.scheduler)) {
+        this.scheduler(this);
+      } else {
+        const schedulerFn = createScheduler(() => this.run(), this.scheduler);
+        schedulerFn();
+      }
+    } else if (isBatching()) {
+      queueJob(this.getJob());
+    } else {
+      this.run();
+    }
+  }
+  /**
+   * Stop the Effect
+   *
+   * After stopping:
+   * - No longer responds to dependency changes
+   * - Disconnects all dependency links
+   * - Clears cached job function
+   * - Calls onStop callback
+   * - Verifies complete cleanup in development mode
+   */
+  stop() {
+    if (!this._active) {
+      {
+        shared.warn("[Effect] Attempting to stop an already stopped effect.");
+      }
+      return;
+    }
+    this._active = false;
+    let dep = this.depLink;
+    while (dep) {
+      dep = unlinkReactiveNode(dep, this);
+    }
+    let sub = this.subLink;
+    while (sub) {
+      sub = unlinkReactiveNode(sub);
+    }
+    this._job = void 0;
+    this.depLinkTail = void 0;
+    this.subLinkTail = void 0;
+    {
+      if (this.depLink) {
+        shared.error(
+          "[Effect] Cleanup verification failed: depLink not cleared. This indicates a memory leak in the dependency tracking system."
+        );
+      }
+      if (this.subLink) {
+        shared.error(
+          "[Effect] Cleanup verification failed: subLink not cleared. This indicates a memory leak in the subscription system."
+        );
+      }
+    }
+    if (this.onStop) {
+      this.onStop();
+    }
+  }
+};
+function effect(fn, options) {
+  const effectInstance = new EffectImpl(fn, options);
+  try {
+    effectInstance.run();
+  } catch (_error) {
+    effectInstance.stop();
+    {
+      shared.error(
+        "[Effect] Effect failed during initial execution and has been stopped. Fix the error in your effect function.",
+        _error
+      );
+    }
+    throw _error;
+  }
+  const runner = () => effectInstance.run();
+  runner.effect = effectInstance;
+  runner.stop = () => effectInstance.stop();
+  return runner;
+}
+function stop(runner) {
+  runner.effect.stop();
+}
+function isEffect(value) {
+  return !!(value && value["_IS_EFFECT" /* IS_EFFECT */]);
+}
+function memoEffect(fn, initialState, options) {
+  let currentState = initialState;
+  const effectFn = () => {
+    const result = fn(currentState);
+    currentState = result;
+  };
+  return effect(effectFn, options);
+}
+var NO_VALUE = Symbol("computed-no-value");
+var _a3;
+_a3 = "_IS_COMPUTED" /* IS_COMPUTED */;
+var ComputedImpl = class {
+  /**
+   * Create a Computed instance
+   *
+   * @param getter - The computation function
+   * @param setter - Optional setter function
+   * @param onTrack - Optional debug callback for dependency tracking
+   * @param onTrigger - Optional debug callback for triggers
+   */
+  constructor(getter, setter, onTrack, onTrigger) {
+    this.flag = 1 /* MUTABLE */ | 16 /* DIRTY */;
+    //@ts-ignore
+    this[_a3] = true;
+    // ===== Cache =====
+    // Use symbol sentinel to distinguish "no value" from undefined/null values
+    this._value = NO_VALUE;
+    this.getter = getter;
+    this.setter = setter;
+    this.onTrack = onTrack;
+    this.onTrigger = onTrigger;
+    this.flag |= 16 /* DIRTY */;
+  }
+  get value() {
+    if (activeSub) {
+      linkReactiveNode(this, activeSub);
+    }
+    const flags = this.flag;
+    const hasValue = this._value !== NO_VALUE;
+    if (hasValue && !(flags & (16 /* DIRTY */ | 32 /* PENDING */))) {
+      return this._value;
+    }
+    if (!hasValue || flags & 16 /* DIRTY */) {
+      this.recompute();
+      return this._value;
+    }
+    if (flags & 32 /* PENDING */) {
+      if (this.depLink && checkDirty(this.depLink, this)) {
+        this.recompute();
+      } else {
+        this.flag = flags & -33 /* PENDING */;
+      }
+    }
+    return this._value;
+  }
+  /**
+   * Set value (only effective when setter is provided)
+   *
+   * @param newValue - The new value
+   */
+  set value(newValue) {
+    if (this.setter) {
+      this.setter(newValue);
+    } else {
+      shared.warn(
+        "[Computed] Cannot set readonly computed value. Provide a setter in the computed options to make it writable.\nExample: computed({ get: () => value, set: (v) => { ... } })"
+      );
+    }
+  }
+  /**
+   * Read value without tracking dependencies
+   *
+   * @returns Current value
+   */
+  peek() {
+    if (this._value === NO_VALUE) {
+      this.recompute();
+    }
+    return this._value;
+  }
+  /**
+   * Recompute the value
+   *
+   *  computation logic:
+   * 1. Start tracking dependencies
+   * 2. Execute getter function
+   * 3. Check if value changed using optimized comparison
+   * 4. If changed, update cache and notify subscribers
+   * 5. End tracking, clean up stale dependencies
+   * @private
+   */
+  recompute() {
+    const oldValue = this._value;
+    const hadValue = oldValue !== NO_VALUE;
+    const prevSub = startTracking(this);
+    try {
+      const newValue = this.getter();
+      const flags = this.flag;
+      const clearMask = ~(16 /* DIRTY */ | 32 /* PENDING */);
+      const valueChanged = !hadValue || shared.hasChanged(oldValue, newValue);
+      if (valueChanged) {
+        this._value = newValue;
+        this.flag = flags & clearMask;
+        if (this.onTrigger) {
+          this.onTrigger({
+            effect: this,
+            target: this,
+            type: "set",
+            key: "value",
+            newValue
+          });
+        }
+        if (this.subLink) {
+          shallowPropagate(this.subLink);
+        }
+      } else {
+        this.flag = flags & clearMask;
+      }
+    } catch (_error) {
+      this.flag &= -49;
+      {
+        shared.error(
+          "[Computed] Error occurred while computing value. Check your getter function for errors.",
+          _error
+        );
+      }
+      throw _error;
+    } finally {
+      endTracking(this, prevSub);
+    }
+  }
+  /**
+   * Check if update is needed
+   *
+   * Internal use, called by reactive system.
+   *
+   * @returns true if value changed
+   */
+  shouldUpdate() {
+    const hadValue = this._value !== NO_VALUE;
+    const oldValue = this._value;
+    this.recompute();
+    if (!hadValue) {
+      return true;
+    }
+    return shared.hasChanged(this._value, oldValue);
+  }
+};
+function computed(getterOrOptions) {
+  if (isComputed(getterOrOptions)) {
+    {
+      shared.warn(
+        "[Computed] Creating a computed from another computed is not recommended. The existing computed will be returned to avoid unnecessary wrapping."
+      );
+    }
+    return getterOrOptions;
+  }
+  if (!getterOrOptions) {
+    throw new Error(
+      "[Computed] Invalid argument: computed() requires a getter function or options object."
+    );
+  }
+  if (shared.isFunction(getterOrOptions)) {
+    return new ComputedImpl(getterOrOptions);
+  }
+  if (shared.isPlainObject(getterOrOptions)) {
+    const { get, set, onTrack, onTrigger } = getterOrOptions;
+    if (!get) {
+      throw new Error(
+        "[Computed] Invalid options: getter function is required.\nUsage: computed({ get: () => value, set: (v) => { ... } })"
+      );
+    }
+    if (!shared.isFunction(get)) {
+      throw new TypeError(
+        `[Computed] Invalid options: getter must be a function.
+Received: ${typeof get}`
+      );
+    }
+    return new ComputedImpl(get, set, onTrack, onTrigger);
+  }
+  throw new Error(
+    `[Computed] Invalid argument: expected a function or options object.
+Received: ${typeof getterOrOptions}`
+  );
+}
+function isComputed(value) {
+  return !!value && !!value["_IS_COMPUTED" /* IS_COMPUTED */];
+}
+function createOptionsStore(options) {
+  if (!options.state) {
+    shared.warn("Store state is required");
+    throw new Error("Store state is required");
+  }
+  const { state, getters, actions } = options;
+  const initState = __spreadValues({}, state);
+  const reactiveState = reactive(state);
+  const subscriptions = /* @__PURE__ */ new Set();
+  const actionCallbacks = /* @__PURE__ */ new Set();
+  const defaultActions = {
+    patch$(payload) {
+      if (!payload) {
+        shared.warn("Patch payload is required");
+        return;
+      }
+      batch(() => {
+        Object.assign(reactiveState, payload);
+      });
+      subscriptions.forEach((callback) => callback(reactiveState));
+      actionCallbacks.forEach((callback) => callback(reactiveState));
+    },
+    subscribe$(callback) {
+      if (!callback) {
+        shared.warn("Subscribe callback is required");
+        return;
+      }
+      subscriptions.add(callback);
+    },
+    unsubscribe$(callback) {
+      subscriptions.delete(callback);
+    },
+    onAction$(callback) {
+      if (!callback) {
+        shared.warn("Action callback is required");
+        return;
+      }
+      actionCallbacks.add(callback);
+    },
+    reset$() {
+      batch(() => {
+        Object.assign(reactiveState, initState);
+      });
+      subscriptions.forEach((callback) => callback(reactiveState));
+      actionCallbacks.forEach((callback) => callback(reactiveState));
+    }
+  };
+  const store = __spreadValues(__spreadProps(__spreadValues({}, reactiveState), {
+    state: reactiveState
+  }), defaultActions);
+  if (getters) {
+    for (const key in getters) {
+      const getter = getters[key];
+      if (getter) {
+        Object.defineProperty(store, key, {
+          get() {
+            return computed(() => getter.call(store, reactiveState)).value;
+          },
+          enumerable: true,
+          configurable: true
+        });
+      }
+    }
+  }
+  if (actions) {
+    for (const key in actions) {
+      const action = actions[key];
+      if (action) {
+        store[key] = (...args) => {
+          const result = action.apply(reactiveState, args);
+          actionCallbacks.forEach((callback) => callback(reactiveState));
+          return result;
+        };
+      }
+    }
+  }
+  return store;
+}
+function createClassStore(StoreClass) {
+  const instance = new StoreClass();
+  const state = /* @__PURE__ */ Object.create(null);
+  const getters = {};
+  const actions = {};
+  Object.getOwnPropertyNames(instance).forEach((key) => {
+    state[key] = instance[key];
+  });
+  Object.getOwnPropertyNames(StoreClass.prototype).forEach((key) => {
+    const descriptor = Object.getOwnPropertyDescriptor(StoreClass.prototype, key);
+    if (descriptor) {
+      if (typeof descriptor.get === "function") {
+        getters[key] = function() {
+          return descriptor.get.call(this);
+        };
+      } else if (typeof descriptor.value === "function" && key !== "constructor") {
+        actions[key] = function(...args) {
+          return descriptor.value.apply(this, args);
+        };
+      }
+    }
+  });
+  return {
+    state,
+    getters,
+    actions
+  };
+}
+function createStore(storeDefinition) {
+  if (!storeDefinition) {
+    shared.warn("Store definition is required");
+    throw new Error("Store definition is required");
+  }
+  return () => {
+    let options;
+    if (typeof storeDefinition === "function") {
+      options = createClassStore(storeDefinition);
+    } else {
+      options = storeDefinition;
+    }
+    const store = createOptionsStore(options);
+    if (typeof storeDefinition === "function") {
+      Object.keys(options.actions || {}).forEach((key) => {
+        store[key] = options.actions[key].bind(store);
+      });
+    }
+    return store;
+  };
+}
+var _a4, _b;
+var RefImpl = class extends (_b = SignalImpl, _a4 = "_IS_REF" /* IS_REF */, _b) {
+  /**
+   * Creates a new ref with the given initial value.
+   *
+   * @param value - The initial value
+   */
+  constructor(value) {
+    super(value, true);
+    // @ts-ignore
+    this[_a4] = true;
+  }
+  get value() {
+    track(this, SIGNAL_KEY);
+    return this._value;
+  }
+  set value(newValue) {
+    if (isSignal(newValue)) {
+      newValue = newValue.value;
+    }
+    if (isRef(newValue)) {
+      newValue = newValue.value;
+    }
+    if (shared.hasChanged(this._value, newValue)) {
+      this._value = newValue;
+      if (this.subLink) {
+        shallowPropagate2(this.subLink);
+      }
+      trigger(this, "SET", SIGNAL_KEY);
+    }
+  }
+};
+function ref(value = void 0) {
+  if (isRef(value)) {
+    {
+      shared.info("Creating a ref with another ref is not recommended. The value will be unwrapped.");
+    }
+    return value;
+  }
+  if (isSignal(value)) {
+    {
+      shared.info("Creating a ref with a signal is not recommended. The value will be unwrapped.");
+    }
+    return new RefImpl(value.peek());
+  }
+  return new RefImpl(value);
+}
+function isRef(value) {
+  return !!value && !!value["_IS_REF" /* IS_REF */];
+}
+var INITIAL_WATCHER_VALUE = {};
+var cleanupMap = /* @__PURE__ */ new WeakMap();
+function traverse(value, seen = /* @__PURE__ */ new Set()) {
+  if (!shared.isObject(value) || seen.has(value)) {
+    return value;
+  }
+  seen.add(value);
+  if (isSignal(value) || isComputed(value)) {
+    return traverse(value.value, seen);
+  }
+  if (Array.isArray(value)) {
+    for (const element of value) {
+      traverse(element, seen);
+    }
+  } else if (shared.isMap(value)) {
+    value.forEach((v) => {
+      traverse(v, seen);
+    });
+    value.keys();
+    value.values();
+  } else if (shared.isSet(value)) {
+    value.forEach((v) => {
+      traverse(v, seen);
+    });
+    value.values();
+  } else {
+    Object.keys(value).forEach((key) => {
+      traverse(value[key], seen);
+    });
+  }
+  return value;
+}
+function cloneValue(value) {
+  if (!shared.isObject(value)) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => cloneValue(item));
+  }
+  if (shared.isMap(value)) {
+    const cloned2 = /* @__PURE__ */ new Map();
+    value.forEach((v, k) => {
+      cloned2.set(k, cloneValue(v));
+    });
+    return cloned2;
+  }
+  if (shared.isSet(value)) {
+    const cloned2 = /* @__PURE__ */ new Set();
+    value.forEach((v) => {
+      cloned2.add(cloneValue(v));
+    });
+    return cloned2;
+  }
+  const cloned = {};
+  for (const key of Object.keys(value)) {
+    cloned[key] = cloneValue(value[key]);
+  }
+  return cloned;
+}
+function resolveSource(source) {
+  if (Array.isArray(source)) {
+    return () => source.map((s) => {
+      if (isSignal(s) || isComputed(s)) {
+        return s.value;
+      }
+      if (isReactive(s)) {
+        return traverse(s);
+      }
+      if (shared.isFunction(s)) {
+        return s();
+      }
+      return s;
+    });
+  }
+  if (shared.isFunction(source)) {
+    return source;
+  }
+  if (isSignal(source)) {
+    return () => source.value;
+  }
+  if (shared.isObject(source) && "value" in source) {
+    return () => source.value;
+  }
+  if (isReactive(source)) {
+    return () => traverse(source);
+  }
+  return () => source;
+}
+function watch(source, callback, options = {}) {
+  const { immediate = false, deep = false } = options;
+  let oldValue = INITIAL_WATCHER_VALUE;
+  const getter = resolveSource(source);
+  const job = () => {
+    const currentEffect = runner.effect;
+    if (!currentEffect.run) {
+      return;
+    }
+    const newValue = currentEffect.run();
+    if (shared.hasChanged(newValue, oldValue)) {
+      callback(newValue, oldValue === INITIAL_WATCHER_VALUE ? void 0 : oldValue);
+      oldValue = cloneValue(newValue);
+    }
+  };
+  const runner = effect(
+    () => {
+      const value = getter();
+      if (deep) {
+        traverse(value);
+      }
+      return value;
+    },
+    {
+      // Use scheduler to queue job, implementing async and debouncing.
+      scheduler: () => queueJob(job)
+    }
+  );
+  if (immediate) {
+    job();
+  } else {
+    oldValue = cloneValue(runner.effect.run());
+  }
+  return () => {
+    runner.stop();
+    const cleanups = cleanupMap.get(runner.effect);
+    if (cleanups) {
+      cleanups.forEach((fn) => fn());
+      cleanupMap.delete(runner.effect);
+    }
+  };
+}
+
+exports.TriggerOpTypes = TriggerOpTypes;
+exports.batch = batch;
+exports.computed = computed;
+exports.createStore = createStore;
+exports.effect = effect;
+exports.endBatch = endBatch;
+exports.getBatchDepth = getBatchDepth;
+exports.isBatching = isBatching;
+exports.isComputed = isComputed;
+exports.isEffect = isEffect;
+exports.isReactive = isReactive;
+exports.isRef = isRef;
+exports.isShallow = isShallow;
+exports.isSignal = isSignal;
+exports.memoEffect = memoEffect;
+exports.nextTick = nextTick;
+exports.queueJob = queueJob;
+exports.queuePreFlushCb = queuePreFlushCb;
+exports.reactive = reactive;
+exports.ref = ref;
+exports.shallowReactive = shallowReactive;
+exports.shallowSignal = shallowSignal;
+exports.signal = signal;
+exports.startBatch = startBatch;
+exports.stop = stop;
+exports.toRaw = toRaw;
+exports.toReactive = toReactive;
+exports.trigger = trigger;
+exports.untrack = untrack;
+exports.watch = watch;