essor 0.0.15 → 0.0.16-beta.2

package/dist/chunk-FIBC7TTZ.esm.js

@@ -0,0 +1,4361 @@
+/**
+* essor v0.0.16-beta.2
+* build time 2026-05-08T05:50:51.766Z
+* (c) 2023-Present jiangxd <jiangxd2016@gmail.com>
+* @license MIT
+**/
+
+// src/version.ts
+var __version = "0.0.16-beta.2";
+
+// ../shared/dist/shared.esm.js
+var isObject = (val) => val !== null && typeof val === "object";
+function isPromise(val) {
+  return _toString.call(val) === "[object Promise]";
+}
+var isArray = Array.isArray;
+function isString(val) {
+  return typeof val === "string";
+}
+function isNumber(val) {
+  return typeof val === "number";
+}
+function isSymbol(val) {
+  return typeof val === "symbol";
+}
+function isSet(val) {
+  return _toString.call(val) === "[object Set]";
+}
+function isWeakMap(val) {
+  return _toString.call(val) === "[object WeakMap]";
+}
+function isWeakSet(val) {
+  return _toString.call(val) === "[object WeakSet]";
+}
+function isMap(val) {
+  return _toString.call(val) === "[object Map]";
+}
+function isNil(val) {
+  return val === null || val === void 0;
+}
+var isFunction = (val) => typeof val === "function";
+var isPlainObject = (val) => _toString.call(val) === "[object Object]";
+function isStringNumber(val) {
+  if (!isString(val) || val === "") {
+    return false;
+  }
+  return !Number.isNaN(Number(val));
+}
+var _toString = Object.prototype.toString;
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var hasOwn = (val, key) => hasOwnProperty.call(val, key);
+function coerceArray(data) {
+  return isArray(data) ? data : [data];
+}
+var hasChanged = (value, oldValue) => !Object.is(value, oldValue);
+function isBrowser() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+var cacheStringFunction = (fn) => {
+  const cache = /* @__PURE__ */ Object.create(null);
+  return ((str) => {
+    const hit = cache[str];
+    return hit || (cache[str] = fn(str));
+  });
+};
+var isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && key.charCodeAt(2) >= 65 && // uppercase letter A-Z
+key.charCodeAt(2) <= 90;
+var hyphenateRE = /\B([A-Z])/g;
+var kebabCase = cacheStringFunction(
+  (str) => str.replaceAll(hyphenateRE, "-$1").toLowerCase()
+);
+var camelizeRE = /[_-](\w)/g;
+var camelCase = cacheStringFunction((str) => {
+  str = str.replaceAll(/^[_-]+|[_-]+$/g, "");
+  str = str.replaceAll(/[_-]+/g, "-");
+  return str.replaceAll(camelizeRE, (_, c) => c.toUpperCase());
+});
+var capitalize = cacheStringFunction(
+  (str) => {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+);
+function warn(msg, ...args) {
+  console.warn(`[Essor warn]: ${msg}`, ...args);
+}
+function error(msg, ...args) {
+  console.error(`[Essor error]: ${msg}`, ...args);
+}
+var escapeRE = /["&'<>]/;
+function escapeHTML(string) {
+  const str = `${string}`;
+  const match = escapeRE.exec(str);
+  if (!match) {
+    return str;
+  }
+  let html = "";
+  let escaped;
+  let index;
+  let lastIndex = 0;
+  for (index = match.index; index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34:
+        escaped = "&quot;";
+        break;
+      case 38:
+        escaped = "&amp;";
+        break;
+      case 39:
+        escaped = "&#39;";
+        break;
+      case 60:
+        escaped = "&lt;";
+        break;
+      case 62:
+        escaped = "&gt;";
+        break;
+      default:
+        continue;
+    }
+    if (lastIndex !== index) {
+      html += str.slice(lastIndex, index);
+    }
+    lastIndex = index + 1;
+    html += escaped;
+  }
+  return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+}
+function makeMap(str) {
+  const map = /* @__PURE__ */ Object.create(null);
+  for (const key of str.split(",")) {
+    map[key] = 1;
+  }
+  return (val) => val in map;
+}
+var specialBooleanAttrs = "itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly";
+var isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
+var isBooleanAttr = /* @__PURE__ */ makeMap(
+  `${specialBooleanAttrs},async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`
+);
+function includeBooleanAttr(value) {
+  return !!value || value === "";
+}
+var STYLE_SEPARATOR_REGEX = /;(?![^(]*\))/g;
+var PROPERTY_VALUE_SEPARATOR_REGEX = /:([\s\S]+)/;
+var STYLE_COMMENT_REGEX = /\/\*[\s\S]*?\*\//g;
+function parseStyleString(cssText) {
+  const styleObject = {};
+  cssText.replaceAll(STYLE_COMMENT_REGEX, "").split(STYLE_SEPARATOR_REGEX).forEach((styleItem) => {
+    if (styleItem) {
+      const parts = styleItem.split(PROPERTY_VALUE_SEPARATOR_REGEX);
+      if (parts.length > 1) {
+        styleObject[parts[0].trim()] = parts[1].trim();
+      }
+    }
+  });
+  return styleObject;
+}
+function normalizeStyle(styleValue) {
+  if (isArray(styleValue)) {
+    const normalizedStyleObject = {};
+    for (const styleItem of styleValue) {
+      const normalizedItem = isString(styleItem) ? parseStyleString(styleItem) : normalizeStyle(styleItem);
+      if (normalizedItem) {
+        for (const key in normalizedItem) {
+          normalizedStyleObject[key] = normalizedItem[key];
+        }
+      }
+    }
+    return normalizedStyleObject;
+  }
+  if (isString(styleValue) || isObject(styleValue)) {
+    return styleValue;
+  }
+  return void 0;
+}
+function styleToString(styleValue) {
+  if (!styleValue) {
+    return "";
+  }
+  if (isString(styleValue)) {
+    return styleValue;
+  }
+  let cssText = "";
+  for (const propName in styleValue) {
+    const propValue = styleValue[propName];
+    if (isString(propValue) || isNumber(propValue)) {
+      const normalizedPropName = propName.startsWith("--") ? propName : kebabCase(propName);
+      cssText += `${normalizedPropName}:${propValue};`;
+    }
+  }
+  return cssText;
+}
+function normalizeClassName(classValue) {
+  if (classValue == null) {
+    return "";
+  }
+  if (isString(classValue)) {
+    return classValue.trim();
+  }
+  if (isArray(classValue)) {
+    return classValue.map(normalizeClassName).filter(Boolean).join(" ");
+  }
+  if (isObject(classValue)) {
+    let count = 0;
+    for (const key in classValue) {
+      if (classValue[key]) count++;
+    }
+    if (count === 0) return "";
+    const result = new Array(count);
+    let index = 0;
+    for (const key in classValue) {
+      if (classValue[key]) {
+        result[index++] = key;
+      }
+    }
+    return result.join(" ");
+  }
+  return String(classValue).trim();
+}
+
+// ../signals/dist/signals.dev.esm.js
+var __defProp = Object.defineProperty;
+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 TriggerOpTypes = {
+  SET: "SET",
+  ADD: "ADD",
+  DELETE: "DELETE",
+  CLEAR: "CLEAR"
+};
+var ARRAY_KEY = /* @__PURE__ */ Symbol("Array_Key");
+var COLLECTION_KEY = /* @__PURE__ */ Symbol("Collection_Key");
+var WEAK_COLLECTION_KEY = /* @__PURE__ */ Symbol("WeakCollection_Key");
+var ITERATE_KEY = /* @__PURE__ */ Symbol("Iterate_Key");
+var ARRAY_ITERATE_KEY = /* @__PURE__ */ Symbol("Array_Iterate_Key");
+function enqueueEffect(effect2) {
+  var _a52;
+  (_a52 = effect2 == null ? void 0 : effect2.notify) == null ? void 0 : _a52.call(effect2);
+}
+function propagate(link) {
+  let next2 = link.nextSubLink;
+  let stack;
+  top: do {
+    const sub = link.subNode;
+    const watcherBit = sub.flag & 2;
+    let flags = sub.flag;
+    if (!(flags & (16 | 32 | 8 | 4))) {
+      sub.flag = flags | 32;
+      if (watcherBit) {
+        enqueueEffect(sub);
+      }
+    } else if (!(flags & (8 | 4))) {
+      flags = 0;
+    } else if (!(flags & 4)) {
+      sub.flag = flags & -9 | 32;
+    } else if (!(flags & (16 | 32)) && isValidLink(link, sub)) {
+      sub.flag = flags | (8 | 32);
+      if (watcherBit) {
+        enqueueEffect(sub);
+      }
+      flags &= 1;
+    } else {
+      flags = 0;
+    }
+    if (flags & 1) {
+      const subSubs = sub.subLink;
+      if (subSubs !== void 0) {
+        const nextSub = subSubs.nextSubLink;
+        if (nextSub !== void 0) {
+          stack = { value: next2, prev: stack };
+          next2 = nextSub;
+        }
+        link = subSubs;
+        continue;
+      }
+    }
+    if ((link = next2) !== void 0) {
+      next2 = link.nextSubLink;
+      continue;
+    }
+    while (stack !== void 0) {
+      link = stack.value;
+      stack = stack.prev;
+      if (link !== void 0) {
+        next2 = link.nextSubLink;
+        continue top;
+      }
+    }
+    break;
+  } while (true);
+}
+function shallowPropagate(link) {
+  while (link) {
+    const sub = link.subNode;
+    const flags = sub.flag;
+    if ((flags & (32 | 16)) === 32) {
+      sub.flag = flags | 16;
+      if ((flags & (2 | 4)) === 2) {
+        enqueueEffect(sub);
+      }
+    }
+    link = link.nextSubLink;
+  }
+}
+var currentLinkVersion = 0;
+var activeSub;
+var isUntracking = false;
+var Dep = class {
+  constructor(map, key) {
+    this.map = map;
+    this.key = key;
+    this.isDep = true;
+    this.flag = 0;
+  }
+  get subLink() {
+    return this._subLink;
+  }
+  set subLink(value) {
+    this._subLink = value;
+    if (value === void 0) {
+      this.map.delete(this.key);
+    }
+  }
+};
+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 && 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;
+      if (!depNode.isDep) {
+        depNode.flag |= 16;
+      }
+      {
+        if (depNode.depLink) {
+          error(
+            "[Link] Cascading cleanup failed: depNode still has dependency links. This indicates a bug in the unlinking logic."
+          );
+        }
+      }
+    }
+  }
+  return nextDep;
+}
+function checkDirty(link, sub) {
+  let stack;
+  let checkDepth = 0;
+  let dirty = false;
+  top: do {
+    let currentDirty = false;
+    if (sub.flag & 16) {
+      currentDirty = true;
+    } else {
+      const dep = link.depNode;
+      const depFlags = dep.flag;
+      if ((depFlags & (1 | 16)) === (1 | 16)) {
+        const subs = dep.subLink;
+        if (subs && subs.nextSubLink) {
+          shallowPropagate2(subs);
+        }
+        currentDirty = true;
+      } else if ((depFlags & (1 | 32)) === (1 | 32)) {
+        if (dep.depLink) {
+          stack = { link, prev: stack };
+          link = dep.depLink;
+          sub = dep;
+          ++checkDepth;
+          continue top;
+        } else {
+          dep.flag &= -33;
+        }
+      } else if (depFlags & 32) {
+        dep.flag &= -33;
+      }
+    }
+    if (!currentDirty && link.nextDepLink !== void 0) {
+      link = link.nextDepLink;
+      continue top;
+    }
+    dirty = currentDirty;
+    while (checkDepth--) {
+      link = stack.link;
+      stack = stack.prev;
+      sub = link.subNode;
+      const checkedDep = link.depNode;
+      if (dirty) {
+        checkedDep.flag = checkedDep.flag & -33 | 16;
+      } else {
+        checkedDep.flag &= -33;
+      }
+      if (checkedDep.flag & 16) {
+        dirty = true;
+      }
+      if (!dirty && link.nextDepLink !== void 0) {
+        link = link.nextDepLink;
+        continue top;
+      }
+    }
+    if (dirty) {
+      sub.flag = sub.flag & -33 | 16;
+    } else {
+      sub.flag &= -33;
+    }
+    return dirty;
+  } while (true);
+}
+function shallowPropagate2(link) {
+  while (link) {
+    const sub = link.subNode;
+    const flags = sub.flag;
+    if ((flags & (32 | 16)) === 32) {
+      sub.flag = flags | 16;
+    }
+    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;
+  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;
+}
+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();
+var triggerVersion = 0;
+function collectTriggeredEffects(dep, effects, version) {
+  if (!dep) {
+    return;
+  }
+  for (let link = dep.subLink; link; link = link.nextSubLink) {
+    const effect2 = link.subNode;
+    if (effect2._triggerVersion === version) {
+      continue;
+    }
+    effect2._triggerVersion = version;
+    effects.push(effect2);
+  }
+}
+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 = new Dep(depsMap, key);
+    depsMap.set(key, dep);
+  }
+  linkReactiveNode(dep, activeSub);
+}
+function trigger(target, type, key, newValue) {
+  var _a52;
+  const depsMap = targetMap.get(target);
+  if (!depsMap) {
+    return;
+  }
+  const effects = [];
+  const version = ++triggerVersion;
+  if (key !== void 0) {
+    if (Array.isArray(key)) {
+      for (const element of key) {
+        collectTriggeredEffects(depsMap.get(element), effects, version);
+      }
+    } else {
+      collectTriggeredEffects(depsMap.get(key), effects, version);
+    }
+  }
+  if (type === "ADD" || type === "DELETE" || type === "CLEAR") {
+    const iterationKey = Array.isArray(target) ? ARRAY_ITERATE_KEY : ITERATE_KEY;
+    collectTriggeredEffects(depsMap.get(iterationKey), effects, version);
+  }
+  for (const effect2 of effects) {
+    if (isFunction(effect2.onTrigger)) {
+      effect2.onTrigger({
+        effect: effect2,
+        target,
+        type,
+        key,
+        newValue
+      });
+    }
+    if (effect2.flag & 2) {
+      (_a52 = effect2.notify) == null ? void 0 : _a52.call(effect2);
+    } else if (effect2.flag & 1) {
+      effect2.flag |= 16;
+      if (effect2.subLink) {
+        propagate(effect2.subLink);
+      }
+    }
+  }
+}
+var reactiveCaches = /* @__PURE__ */ new WeakMap();
+function toRaw(value) {
+  if (!value || !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") && 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, 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) => 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);
+      return Array.prototype[key].apply(this, args);
+    };
+  });
+  ["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 {
+        /**
+         * Returns the next iterator result.
+         */
+        next() {
+          const { value, done } = rawIterator.next();
+          if (done) {
+            return { value, done };
+          }
+          if (Array.isArray(value)) {
+            return {
+              value: value.map((v) => isObject(v) ? reactiveImpl(v, isShallowMode) : v),
+              done
+            };
+          }
+          return {
+            value: isObject(value) ? reactiveImpl(value, isShallowMode) : value,
+            done
+          };
+        },
+        /**
+         * Returns an iterator for the current collection.
+         */
+        [Symbol.iterator]() {
+          return this;
+        }
+      };
+    };
+  });
+  return instrumentations;
+}
+var arrayHandlers = (shallow) => ({
+  get: (target, key, receiver) => {
+    if (key === "_RAW") {
+      return target;
+    }
+    if (key === "_IS_REACTIVE") {
+      return true;
+    }
+    if (key === "_IS_SHALLOW") {
+      return shallow;
+    }
+    if (hasOwn(arrayInstrumentations, key)) {
+      return arrayInstrumentations[key];
+    }
+    const value = Reflect.get(target, key, receiver);
+    if (isStringNumber(key)) {
+      track(target, key);
+    }
+    track(target, ARRAY_KEY);
+    if (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 (hasChanged(value, oldValue)) {
+      if (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 = {
+  /**
+   * Exposes collection proxy flags and instrumented methods.
+   */
+  get(target, key) {
+    if (key === "_IS_REACTIVE") {
+      return true;
+    }
+    if (key === "_RAW") {
+      return target;
+    }
+    return Reflect.get(
+      hasOwn(collectionInstrumentations, key) ? collectionInstrumentations : target,
+      key,
+      target
+    );
+  }
+};
+var weakCollectionHandlers = {
+  /**
+   * Exposes weak-collection proxy flags and instrumented methods.
+   */
+  get(target, key) {
+    if (key === "_IS_REACTIVE") {
+      return true;
+    }
+    if (key === "_RAW") {
+      return target;
+    }
+    return Reflect.get(
+      hasOwn(weakInstrumentations, key) && key in target ? weakInstrumentations : target,
+      key,
+      target
+    );
+  }
+};
+var collectionInstrumentations = {
+  /**
+   * Reads a Map entry with dependency tracking.
+   */
+  get(key) {
+    const target = toRaw(this);
+    track(target, COLLECTION_KEY);
+    const value = target.get(key);
+    if (isObject(value) && !isShallow(this)) {
+      return reactiveImpl(value);
+    }
+    return value;
+  },
+  /**
+   * Sets the requested 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 || hasChanged(oldValue, rawValue)) {
+      trigger(target, TriggerOpTypes.SET, COLLECTION_KEY);
+    }
+    return this;
+  },
+  /**
+   * Adds the requested value.
+   */
+  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);
+    }
+    return this;
+  },
+  /**
+   * Returns whether the requested value exists.
+   */
+  has(key) {
+    const target = toRaw(this);
+    track(target, COLLECTION_KEY);
+    const hasKey = target.has(key);
+    if (!hasKey && isObject(key)) {
+      return target.has(toRaw(key));
+    }
+    return hasKey;
+  },
+  /**
+   * Deletes the requested value.
+   */
+  delete(key) {
+    const target = toRaw(this);
+    const hadKey = target.has(key);
+    let result = target.delete(key);
+    if (!result && isObject(key)) {
+      result = target.delete(toRaw(key));
+    }
+    if (hadKey || result) {
+      trigger(target, TriggerOpTypes.DELETE, COLLECTION_KEY);
+    }
+    return result;
+  },
+  /**
+   * Clears the current collection.
+   */
+  clear() {
+    const target = toRaw(this);
+    const hadItems = target.size > 0;
+    const result = target.clear();
+    if (hadItems) {
+      trigger(target, TriggerOpTypes.CLEAR, COLLECTION_KEY);
+    }
+    return result;
+  },
+  /**
+   * Iterates over each collection entry.
+   */
+  forEach(callback, thisArg) {
+    const target = toRaw(this);
+    const isShallowMode = isShallow(this);
+    track(target, COLLECTION_KEY);
+    target.forEach((value, key) => {
+      const wrappedValue = isShallowMode || !isObject(value) ? value : reactiveImpl(value);
+      const wrappedKey = isShallowMode || !isObject(key) ? key : reactiveImpl(key);
+      callback.call(thisArg, wrappedValue, wrappedKey, this);
+    });
+  },
+  /**
+   * Returns an iterator for the current collection.
+   */
+  [Symbol.iterator]() {
+    const target = toRaw(this);
+    const isShallowMode = isShallow(this);
+    track(target, COLLECTION_KEY);
+    const rawIterator = target[Symbol.iterator]();
+    return {
+      /**
+       * Returns the next iterator result.
+       */
+      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) => isObject(v) ? reactiveImpl(v) : v),
+            done
+          };
+        }
+        return {
+          value: isObject(value) ? reactiveImpl(value) : value,
+          done
+        };
+      },
+      /**
+       * Returns an iterator for the current collection.
+       */
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  },
+  /**
+   * Returns the current collection size.
+   */
+  get size() {
+    const target = toRaw(this);
+    track(target, COLLECTION_KEY);
+    return target.size;
+  },
+  /**
+   * Returns an iterator over the current keys.
+   */
+  keys() {
+    const target = toRaw(this);
+    const isShallowMode = isShallow(this);
+    track(target, COLLECTION_KEY);
+    const rawIterator = target.keys();
+    return {
+      /**
+       * Returns the next iterator result.
+       */
+      next() {
+        const { value, done } = rawIterator.next();
+        if (done) {
+          return { value, done };
+        }
+        return {
+          value: isShallowMode || !isObject(value) ? value : reactiveImpl(value),
+          done
+        };
+      },
+      /**
+       * Returns an iterator for the current collection.
+       */
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  },
+  /**
+   * Returns an iterator over the current values.
+   */
+  values() {
+    const target = toRaw(this);
+    const isShallowMode = isShallow(this);
+    track(target, COLLECTION_KEY);
+    const rawIterator = target.values();
+    return {
+      /**
+       * Returns the next iterator result.
+       */
+      next() {
+        const { value, done } = rawIterator.next();
+        if (done) {
+          return { value, done };
+        }
+        return {
+          value: isShallowMode || !isObject(value) ? value : reactiveImpl(value),
+          done
+        };
+      },
+      /**
+       * Returns an iterator for the current collection.
+       */
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  },
+  /**
+   * Returns an iterator over the current entries.
+   */
+  entries() {
+    const target = toRaw(this);
+    const isShallowMode = isShallow(this);
+    track(target, COLLECTION_KEY);
+    const rawIterator = target.entries();
+    return {
+      /**
+       * Returns the next iterator result.
+       */
+      next() {
+        const { value, done } = rawIterator.next();
+        if (done) {
+          return { value, done };
+        }
+        if (isShallowMode) {
+          return { value, done };
+        }
+        return {
+          value: value.map((v) => isObject(v) ? reactiveImpl(v) : v),
+          done
+        };
+      },
+      /**
+       * Returns an iterator for the current collection.
+       */
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  }
+};
+var weakInstrumentations = {
+  /**
+   * Reads a WeakMap entry with dependency tracking.
+   */
+  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 (isObject(value) && !isShallow(this)) {
+      return reactiveImpl(value);
+    }
+    return value;
+  },
+  /**
+   * Sets the requested 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 || hasChanged(oldValue, rawValue)) {
+      trigger(target, TriggerOpTypes.SET, WEAK_COLLECTION_KEY);
+    }
+    return this;
+  },
+  /**
+   * Adds the requested value.
+   */
+  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;
+  },
+  /**
+   * Returns whether the requested value exists.
+   */
+  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;
+  },
+  /**
+   * Deletes the requested value.
+   */
+  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) => ({
+  /**
+   * Reads an object property, unwraps signals, and tracks the access.
+   */
+  get(target, key, receiver) {
+    if (key === "_RAW") {
+      return target;
+    }
+    if (key === "_IS_REACTIVE") {
+      return true;
+    }
+    if (key === "_IS_SHALLOW") {
+      return shallow;
+    }
+    const value = Reflect.get(target, key, receiver);
+    const valueUnwrapped = isSignal(value) ? value.value : value;
+    track(target, key);
+    if (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 (hasChanged(value, oldValue)) {
+      trigger(target, TriggerOpTypes.SET, key, value);
+    }
+    return result;
+  },
+  deleteProperty: (target, key) => {
+    const hadKey = hasOwn(target, key);
+    const result = Reflect.deleteProperty(target, key);
+    if (hadKey && result) {
+      trigger(target, TriggerOpTypes.DELETE, key, void 0);
+    }
+    return result;
+  }
+});
+var shallowObjectHandlers = objectHandlers(true);
+var deepObjectHandlers = objectHandlers(false);
+function reactiveImpl(target, shallow = false) {
+  if (!isObject(target)) {
+    return target;
+  }
+  if (isReactive(target)) {
+    return target;
+  }
+  const existingProxy = reactiveCaches.get(target);
+  if (existingProxy) {
+    return existingProxy;
+  }
+  let handler;
+  if (isArray(target)) {
+    handler = shallow ? shallowArrayHandlers : deepArrayHandlers;
+  } else if (isSet(target) || isMap(target)) {
+    handler = collectionHandlers;
+  } else if (isWeakMap(target) || isWeakSet(target)) {
+    handler = weakCollectionHandlers;
+  } else {
+    handler = shallow ? shallowObjectHandlers : deepObjectHandlers;
+  }
+  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)) {
+    return target;
+  }
+  if (isSignal(target)) {
+    return target;
+  }
+  return reactiveImpl(target);
+}
+function shallowReactive(target) {
+  if (isReactive(target)) {
+    return target;
+  }
+  if (isSignal(target)) {
+    return target;
+  }
+  return reactiveImpl(target, true);
+}
+function isShallow(value) {
+  return !!(value && value[
+    "_IS_SHALLOW"
+    /* IS_SHALLOW */
+  ]);
+}
+var toReactive = (value) => isObject(value) ? reactive(value) : value;
+var _a;
+_a = "_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;
+    this[_a] = true;
+    const unwrapped = toRaw(value);
+    this._rawValue = unwrapped;
+    this[
+      "_IS_SHALLOW"
+      /* IS_SHALLOW */
+    ] = shallow;
+    if (!shouldWrapReactiveValue(unwrapped)) {
+      this._value = unwrapped;
+    } else {
+      if (isReactive(value)) {
+        this._value = value;
+      } else {
+        this._value = shallow ? shallowReactive(unwrapped) : reactive(unwrapped);
+      }
+    }
+  }
+  /**
+   * Returns the dependency node used for tracking.
+   *
+   * @returns {this} The dependency node.
+   */
+  get dep() {
+    return this;
+  }
+  /**
+   * Returns the current value.
+   *
+   * @returns {T} The current value.
+   */
+  get value() {
+    const sub = activeSub;
+    if (sub) {
+      linkReactiveNode(this, sub);
+    }
+    const flags = this.flag;
+    if (flags & 16 && this.shouldUpdate()) {
+      const subs = this.subLink;
+      if (subs) {
+        shallowPropagate2(subs);
+      }
+    }
+    return this._value;
+  }
+  /**
+   * Updates the current value.
+   *
+   * @param newValue - The new value to set.
+   */
+  set value(newValue) {
+    if (isSignal(newValue)) {
+      {
+        warn(
+          "Setting a signal value to another signal is not recommended. The value will be unwrapped automatically."
+        );
+      }
+      newValue = newValue.peek();
+    }
+    const originalValue = newValue;
+    const rawValue = toRaw(newValue);
+    if (!hasChanged(this._rawValue, rawValue)) {
+      return;
+    }
+    this._oldValue = this._rawValue;
+    this._rawValue = rawValue;
+    this.flag |= 16;
+    if (!shouldWrapReactiveValue(rawValue)) {
+      this._value = rawValue;
+    } else if (isReactive(originalValue)) {
+      this._value = originalValue;
+    } else {
+      const shallow = this[
+        "_IS_SHALLOW"
+        /* IS_SHALLOW */
+      ];
+      this._value = shallow ? shallowReactive(rawValue) : reactive(rawValue);
+    }
+    const subs = this.subLink;
+    if (subs) {
+      propagate(subs);
+    }
+  }
+  /**
+   * Check if the value should be updated.
+   *
+   * @returns {boolean} True if the value should be updated.
+   */
+  shouldUpdate() {
+    this.flag &= -17;
+    if (!("_oldValue" in this)) {
+      return true;
+    }
+    const changed = hasChanged(this._oldValue, this._rawValue);
+    this._oldValue = this._rawValue;
+    return changed;
+  }
+  /**
+   * Get current value without triggering dependency tracking.
+   *
+   * @returns {T} The current value.
+   */
+  peek() {
+    return this._value;
+  }
+  /**
+   * Sets the requested value.
+   *
+   * @param value - The new value to set.
+   * @returns {void}
+   */
+  set(value) {
+    this.value = value;
+  }
+  /**
+   * Update value using an updater function.
+   *
+   * @param updater - A function that receives the current value and returns the new value.
+   * @returns {void}
+   */
+  update(updater) {
+    const nextValue = updater(this.peek());
+    if (isSignal(nextValue)) {
+      {
+        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 shouldWrapReactiveValue(value) {
+  if (!isObject(value)) return false;
+  return isArray(value) || isMap(value) || isSet(value) || isWeakMap(value) || isWeakSet(value) || isPlainObject(value);
+}
+function signal(value) {
+  if (isSignal(value)) {
+    {
+      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)) {
+    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) {
+  return fn ? p.then(fn) : 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) {
+    for (const job of queue) {
+      try {
+        job();
+      } catch (_error) {
+        {
+          error("Error executing queued job:", _error);
+        }
+      }
+    }
+    queue.clear();
+  }
+}
+function flushPreFlushCbs() {
+  const callbacks = Array.from(activePreFlushCbs);
+  activePreFlushCbs.clear();
+  for (const callback of callbacks) {
+    try {
+      callback();
+    } catch (_error) {
+      {
+        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:
+      {
+        warn(`Invalid flush timing: ${flush}. Defaulting to 'post'.`);
+      }
+      return () => queueJob(effect2);
+  }
+}
+var batchDepth = 0;
+function batch(fn) {
+  startBatch();
+  try {
+    return fn();
+  } finally {
+    endBatch();
+  }
+}
+function startBatch() {
+  batchDepth++;
+}
+function endBatch() {
+  if (batchDepth === 0) {
+    warn(
+      "[Batch] endBatch() called without matching startBatch(). This indicates unbalanced batch calls in your code. Make sure every startBatch() has a corresponding endBatch(), or use the batch() function which handles this automatically."
+    );
+    return;
+  }
+  batchDepth--;
+  if (batchDepth === 0) {
+    flushJobs();
+  }
+}
+function isBatching() {
+  return batchDepth > 0;
+}
+function getBatchDepth() {
+  return batchDepth;
+}
+var _a2;
+_a2 = "_IS_EFFECT";
+var EffectImpl = class {
+  /**
+   * Create an Effect instance.
+   *
+   * @param fn - The effect function.
+   * @param options - Configuration options.
+   */
+  constructor(fn, options) {
+    this.flag = 2 | 16;
+    this[_a2] = true;
+    this._active = true;
+    this.fn = fn;
+    if (options) {
+      this.options = options;
+      const scheduler = options.flush || options.scheduler;
+      if (scheduler && !isFunction(scheduler)) {
+        this._flushScheduler = createScheduler(() => this.run(), scheduler);
+      }
+      {
+        if (options.onTrack) this.onTrack = options.onTrack;
+        if (options.onTrigger) this.onTrigger = options.onTrigger;
+      }
+    }
+  }
+  /**
+   * Check if the Effect is active.
+   *
+   * @returns {boolean} True if the effect is active.
+   */
+  get active() {
+    return this._active;
+  }
+  /**
+   * Check if the Effect is dirty (needs re-execution).
+   *
+   * @returns {boolean} True if the effect is dirty.
+   */
+  get dirty() {
+    const flags = this.flag;
+    if (flags & 16) {
+      return true;
+    }
+    if (flags & 32) {
+      if (this.depLink && checkDirty(this.depLink, this)) {
+        this.flag = flags & -33 | 16;
+        return true;
+      }
+      this.flag = flags & -33;
+    }
+    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.
+   *
+   * @returns {void}
+   */
+  pause() {
+    this.flag |= 256;
+  }
+  /**
+   * 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.
+   *
+   * @returns {void}
+   */
+  resume() {
+    const flags = this.flag;
+    const nextFlags = flags & -257;
+    this.flag = nextFlags;
+    const wasDirty = (nextFlags & 16) !== 0;
+    const wasPending = (nextFlags & 32) !== 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 {T} The return value of the effect function.
+   */
+  run() {
+    if (!this._active) {
+      return this.fn();
+    }
+    const flags = this.flag;
+    this.flag = flags & -49 | 512;
+    const prevSub = startTracking(this);
+    try {
+      return this.fn();
+    } catch (error5) {
+      this.flag |= 16;
+      throw error5;
+    } finally {
+      this.flag &= -513;
+      endTracking(this, prevSub);
+    }
+  }
+  /**
+   * Get or create the job function for this effect.
+   *
+   * @returns {() => void} The job function.
+   */
+  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.
+   *
+   * @returns {void}
+   */
+  notify() {
+    var _a52, _b2, _c, _d;
+    const flags = this.flag;
+    if (!this._active || flags & (256 | 512 | 16)) {
+      return;
+    }
+    this.flag = flags | 16;
+    if ((_a52 = this.options) == null ? void 0 : _a52.onTrigger) {
+      this.options.onTrigger({
+        effect: this,
+        target: {},
+        type: "set"
+      });
+    }
+    const scheduler = ((_b2 = this.options) == null ? void 0 : _b2.flush) || ((_c = this.options) == null ? void 0 : _c.scheduler);
+    if (scheduler) {
+      if (isFunction(scheduler)) {
+        scheduler(this);
+      } else {
+        (_d = this._flushScheduler) == null ? void 0 : _d.call(this);
+      }
+    } 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.
+   *
+   * @returns {void}
+   */
+  stop() {
+    var _a52;
+    if (!this._active) {
+      {
+        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._flushScheduler = void 0;
+    this.depLinkTail = void 0;
+    this.subLinkTail = void 0;
+    {
+      if (this.depLink) {
+        error(
+          "[Effect] Cleanup verification failed: depLink not cleared. This indicates a memory leak in the dependency tracking system."
+        );
+      }
+      if (this.subLink) {
+        error(
+          "[Effect] Cleanup verification failed: subLink not cleared. This indicates a memory leak in the subscription system."
+        );
+      }
+    }
+    if ((_a52 = this.options) == null ? void 0 : _a52.onStop) {
+      this.options.onStop();
+    }
+  }
+};
+function effect(fn, options) {
+  const effectInstance = new EffectImpl(fn, options);
+  try {
+    effectInstance.run();
+  } catch (_error) {
+    effectInstance.stop();
+    {
+      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 = /* @__PURE__ */ Symbol("computed-no-value");
+var _a3;
+_a3 = "_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 | 16;
+    this[_a3] = true;
+    this._value = NO_VALUE;
+    this.getter = getter;
+    this.setter = setter;
+    this.onTrack = onTrack;
+    this.onTrigger = onTrigger;
+    this.flag |= 16;
+  }
+  /**
+   * Returns the current value.
+   *
+   * @returns {T} The current value.
+   */
+  get value() {
+    if (activeSub) {
+      linkReactiveNode(this, activeSub);
+    }
+    const flags = this.flag;
+    const hasValue = this._value !== NO_VALUE;
+    if (hasValue && !(flags & (16 | 32))) {
+      return this._value;
+    }
+    if (!hasValue || flags & 16) {
+      this.recompute();
+      return this._value;
+    }
+    if (flags & 32) {
+      if (this.depLink && checkDirty(this.depLink, this)) {
+        this.recompute();
+      } else {
+        this.flag = flags & -33;
+      }
+    }
+    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 {
+      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 {T} The 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 subs = this.subLink;
+      const clearMask = ~(16 | 32);
+      const valueChanged = !hadValue || 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 (subs) {
+          shallowPropagate(subs);
+        }
+      } else {
+        this.flag = flags & clearMask;
+      }
+    } catch (_error) {
+      const clearMask = -49;
+      this.flag &= clearMask;
+      this._value = NO_VALUE;
+      {
+        error(
+          "[Computed] Error occurred while computing value.\nThe computed will retry on next access.\nCommon causes:\n  - Accessing undefined properties\n  - Circular dependencies\n  - Exceptions in getter function\nCheck your getter function for errors.",
+          _error
+        );
+      }
+      throw _error;
+    } finally {
+      endTracking(this, prevSub);
+    }
+  }
+  /**
+   * Check if update is needed.
+   *
+   * Internal use, called by reactive system.
+   *
+   * @returns {boolean} True if value changed.
+   */
+  shouldUpdate() {
+    const hadValue = this._value !== NO_VALUE;
+    const oldValue = this._value;
+    this.recompute();
+    if (!hadValue) {
+      return true;
+    }
+    return hasChanged(this._value, oldValue);
+  }
+};
+function computed(getterOrOptions) {
+  if (isComputed(getterOrOptions)) {
+    {
+      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 (isFunction(getterOrOptions)) {
+    return new ComputedImpl(getterOrOptions);
+  }
+  if (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 (!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) {
+    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 notifySubscribers = (state2) => {
+    subscriptions.forEach((callback) => callback(state2));
+    actionCallbacks.forEach((callback) => callback(state2));
+  };
+  const defaultActions = {
+    /**
+     * Applies a partial patch to the reactive store state.
+     */
+    patch$(payload) {
+      if (!payload) {
+        warn("Patch payload is required");
+        return;
+      }
+      batch(() => {
+        Object.assign(reactiveState, payload);
+      });
+      notifySubscribers(reactiveState);
+    },
+    /**
+     * Registers a store subscriber callback.
+     */
+    subscribe$(callback) {
+      if (!callback) {
+        warn("Subscribe callback is required");
+        return;
+      }
+      subscriptions.add(callback);
+    },
+    /**
+     * Removes a previously registered store subscriber.
+     */
+    unsubscribe$(callback) {
+      subscriptions.delete(callback);
+    },
+    /**
+     * Registers a callback for store action notifications.
+     */
+    onAction$(callback) {
+      if (!callback) {
+        warn("Action callback is required");
+        return;
+      }
+      actionCallbacks.add(callback);
+    },
+    /**
+     * Removes a previously registered action callback.
+     */
+    offAction$(callback) {
+      actionCallbacks.delete(callback);
+    },
+    /**
+     * Resets the reactive state back to its initial snapshot.
+     */
+    reset$() {
+      batch(() => {
+        Object.assign(reactiveState, initState);
+      });
+      notifySubscribers(reactiveState);
+    }
+  };
+  const store = {};
+  for (const key of Object.keys(initState)) {
+    Object.defineProperty(store, key, {
+      get: () => reactiveState[key],
+      set: (value) => {
+        reactiveState[key] = value;
+      },
+      enumerable: true,
+      configurable: true
+    });
+  }
+  Object.defineProperty(store, "state", {
+    value: reactiveState,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  });
+  Object.assign(store, defaultActions);
+  if (getters) {
+    for (const key in getters) {
+      const getter = getters[key];
+      if (!getter) continue;
+      const getterValue = computed(() => getter.call(store, reactiveState));
+      Object.defineProperty(store, key, {
+        get: () => getterValue.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(store, 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 (isFunction(descriptor.get)) {
+        getters[key] = function() {
+          return descriptor.get.call(this);
+        };
+      } else if (isFunction(descriptor.value) && key !== "constructor") {
+        actions[key] = function(...args) {
+          return descriptor.value.apply(this, args);
+        };
+      }
+    }
+  });
+  return {
+    state,
+    getters,
+    actions
+  };
+}
+function createStore(storeDefinition) {
+  if (!storeDefinition) {
+    warn("Store definition is required");
+    throw new Error("Store definition is required");
+  }
+  return () => {
+    let options;
+    if (isFunction(storeDefinition)) {
+      options = createClassStore(storeDefinition);
+    } else {
+      options = storeDefinition;
+    }
+    return createOptionsStore(options);
+  };
+}
+var _a4;
+var _b;
+var RefImpl = class extends (_b = SignalImpl, _a4 = "_IS_REF", _b) {
+  /**
+   * Creates a new ref with the given initial value.
+   *
+   * @param value - The initial value
+   */
+  constructor(value) {
+    super(value, true);
+    this[_a4] = true;
+  }
+  /**
+   * Returns the current value.
+   *
+   * @returns {T} The current value.
+   */
+  get value() {
+    const sub = activeSub;
+    if (sub) {
+      linkReactiveNode(this, sub);
+    }
+    return this._value;
+  }
+  /**
+   * Updates the current value.
+   *
+   * @param newValue - The new value.
+   */
+  set value(newValue) {
+    if (isSignal(newValue)) {
+      newValue = newValue.peek();
+    }
+    if (isRef(newValue)) {
+      newValue = newValue.value;
+    }
+    if (hasChanged(this._value, newValue)) {
+      this._rawValue = newValue;
+      this._value = newValue;
+      this.flag |= 16;
+      if (this.subLink) {
+        propagate(this.subLink);
+      }
+    }
+  }
+};
+function ref(value = void 0) {
+  if (isRef(value)) {
+    return value;
+  }
+  if (isSignal(value)) {
+    return new RefImpl(value.peek());
+  }
+  return new RefImpl(value);
+}
+function isRef(value) {
+  return !!value && !!value[
+    "_IS_REF"
+    /* IS_REF */
+  ];
+}
+var INITIAL_WATCHER_VALUE = {};
+var _traverseSeen = /* @__PURE__ */ new Set();
+function traverse(value, seen) {
+  if (!seen) {
+    _traverseSeen.clear();
+    seen = _traverseSeen;
+  }
+  if (!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 (isMap(value)) {
+    value.forEach((v) => {
+      traverse(v, seen);
+    });
+    value.keys();
+    value.values();
+  } else if (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) {
+  return value;
+}
+function resolveSingleSource(source) {
+  if (isFunction(source)) {
+    return source;
+  }
+  if (isSignal(source) || isComputed(source)) {
+    return () => source.value;
+  }
+  if (isReactive(source)) {
+    return () => traverse(source);
+  }
+  return () => source;
+}
+function resolveSource(source) {
+  if (Array.isArray(source)) {
+    const getters = source.map((s) => resolveSingleSource(s));
+    return () => getters.map((g) => g());
+  }
+  return resolveSingleSource(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 (deep || isObject(newValue) || 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();
+  };
+}
+
+// ../template/dist/chunk-3E4EK64L.dev.esm.js
+var __getOwnPropSymbols2 = Object.getOwnPropertySymbols;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __propIsEnum2 = Object.prototype.propertyIsEnumerable;
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp2.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols2)
+    for (var prop of __getOwnPropSymbols2(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum2.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve2, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve2(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var activeScope = null;
+var scopeId = 0;
+function getActiveScope() {
+  return activeScope;
+}
+function createScope(parent = activeScope) {
+  const scope = {
+    id: ++scopeId,
+    parent,
+    children: null,
+    // Lazy initialized
+    provides: null,
+    // Lazy initialized
+    cleanup: null,
+    // Lazy initialized
+    onMount: null,
+    // Lazy initialized
+    onUpdate: null,
+    // Lazy initialized
+    onDestroy: null,
+    // Lazy initialized
+    isMounted: false,
+    isDestroyed: false
+  };
+  if (parent) {
+    if (!parent.children) {
+      parent.children = /* @__PURE__ */ new Set();
+    }
+    parent.children.add(scope);
+  }
+  return scope;
+}
+function runWithScope(scope, fn) {
+  const prevScope = activeScope;
+  activeScope = scope;
+  try {
+    return fn();
+  } finally {
+    activeScope = prevScope;
+  }
+}
+function disposeScope(scope) {
+  var _a6;
+  if (!scope || scope.isDestroyed) {
+    return;
+  }
+  scope.isDestroyed = true;
+  if (scope.children && scope.children.size > 0) {
+    for (const child2 of scope.children) {
+      if (child2) {
+        child2.parent = null;
+        disposeScope(child2);
+      }
+    }
+    scope.children.clear();
+  }
+  const prevScope = activeScope;
+  activeScope = scope;
+  try {
+    if (scope.onDestroy) {
+      for (let i = 0; i < scope.onDestroy.length; i++) {
+        try {
+          scope.onDestroy[i]();
+        } catch (error_) {
+          if (true) {
+            error(`Scope(${scope.id}): Error in destroy hook:`, error_);
+          }
+        }
+      }
+      scope.onDestroy = null;
+    }
+    if (scope.cleanup) {
+      for (let i = 0; i < scope.cleanup.length; i++) {
+        try {
+          scope.cleanup[i]();
+        } catch (error_) {
+          if (true) {
+            error(`Scope(${scope.id}): Error in cleanup:`, error_);
+          }
+        }
+      }
+      scope.cleanup = null;
+    }
+  } finally {
+    activeScope = prevScope;
+  }
+  if ((_a6 = scope.parent) == null ? void 0 : _a6.children) {
+    scope.parent.children.delete(scope);
+  }
+  if (scope.provides) {
+    scope.provides.clear();
+    scope.provides = null;
+  }
+  scope.onMount = null;
+  scope.onUpdate = null;
+  scope.children = null;
+  scope.parent = null;
+}
+function onCleanup(fn) {
+  const scope = activeScope;
+  if (!scope) {
+    {
+      error("onCleanup() must be called within a scope");
+    }
+    return;
+  }
+  if (!scope.cleanup) {
+    scope.cleanup = [];
+  }
+  scope.cleanup.push(fn);
+}
+
+// ../template/dist/template.dev.esm.js
+var SPREAD_NAME = "_$spread$";
+var REF_KEY = "ref";
+var KEY_PROP = "key";
+var SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+var XLINK_NAMESPACE = "http://www.w3.org/2000/xlink";
+var XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/";
+var FRAGMENT_COMPONENT = /* @__PURE__ */ Symbol("Fragment Component");
+var PORTAL_COMPONENT = /* @__PURE__ */ Symbol("Portal Component");
+var SUSPENSE_COMPONENT = /* @__PURE__ */ Symbol("Suspense Component");
+var FOR_COMPONENT = /* @__PURE__ */ Symbol("For Component");
+function patchAttr(el, key, prev, next2) {
+  if (key === KEY_PROP) {
+    if (next2 == null) {
+      el.removeAttribute(key);
+    } else {
+      el.setAttribute(key, String(next2));
+    }
+    return;
+  }
+  if (key === SPREAD_NAME) {
+    const prevObj = isObject(prev) ? prev : null;
+    const nextObj = isObject(next2) ? next2 : null;
+    {
+      if (next2 != null && !nextObj) {
+        warn("spread attribute must be an object");
+      }
+    }
+    if (prevObj) {
+      for (const attrKey in prevObj) {
+        if (attrKey === SPREAD_NAME) {
+          {
+            warn("nested spread attributes are ignored");
+          }
+          continue;
+        }
+        if (!nextObj || !(attrKey in nextObj)) {
+          patchAttr(el, attrKey, prevObj[attrKey], null);
+        }
+      }
+    }
+    if (nextObj) {
+      for (const attrKey in nextObj) {
+        if (attrKey === SPREAD_NAME) {
+          {
+            warn("nested spread attributes are ignored");
+          }
+          continue;
+        }
+        patchAttr(el, attrKey, prevObj == null ? void 0 : prevObj[attrKey], nextObj[attrKey]);
+      }
+    }
+    return;
+  }
+  const elementIsSVG = (el == null ? void 0 : el.namespaceURI) === SVG_NAMESPACE;
+  const isXlink = elementIsSVG && key.startsWith("xlink:");
+  const isXmlns = elementIsSVG && key.startsWith("xmlns:");
+  const isBoolean = isSpecialBooleanAttr(key) || isBooleanAttr(key);
+  if (prev === next2) {
+    return;
+  }
+  if (key.length > 2 && key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110) {
+    return;
+  }
+  const lowerKey = key.toLowerCase();
+  if (lowerKey === "innerhtml" || lowerKey === "srcdoc") {
+    {
+      warn(`${key} updates are ignored by patchAttr`);
+    }
+    return;
+  }
+  if (next2 == null) {
+    if (isXlink) {
+      el.removeAttributeNS(XLINK_NAMESPACE, key.slice(6));
+    } else if (isXmlns) {
+      const localName = key.slice(6);
+      el.removeAttributeNS(XMLNS_NAMESPACE, localName);
+    } else {
+      el.removeAttribute(key);
+    }
+    return;
+  }
+  if (isBoolean) {
+    if (includeBooleanAttr(next2)) {
+      el.setAttribute(key, "");
+    } else {
+      el.removeAttribute(key);
+    }
+    return;
+  }
+  const attrValue = isSymbol(next2) ? String(next2) : next2;
+  const isUrlAttr = lowerKey === "href" || lowerKey === "src" || lowerKey === "xlink:href" || lowerKey === "action" || lowerKey === "formaction" || lowerKey === "poster";
+  if (isUrlAttr && isString(attrValue)) {
+    const v = attrValue.trim().toLowerCase();
+    if (v.startsWith("javascript:") || v.startsWith("data:")) {
+      return;
+    }
+  }
+  if (isXlink) {
+    el.setAttributeNS(XLINK_NAMESPACE, key, String(attrValue));
+    return;
+  }
+  if (isXmlns) {
+    el.setAttributeNS(XMLNS_NAMESPACE, key, String(attrValue));
+    return;
+  }
+  if (elementIsSVG) {
+    el.setAttribute(key, String(attrValue));
+  } else {
+    if (key in el) {
+      try {
+        el[key] = attrValue;
+      } catch (e) {
+        el.setAttribute(key, String(attrValue));
+      }
+    } else {
+      el.setAttribute(key, String(attrValue));
+    }
+  }
+}
+function patchClass(el, prev, next2, isSVG = false) {
+  if (prev === next2) {
+    return;
+  }
+  const normalizedNext = normalizeClass(next2);
+  if (!normalizedNext) {
+    el.removeAttribute("class");
+    return;
+  }
+  const normalizedPrev = isString(prev) ? prev : normalizeClass(prev);
+  if (normalizedPrev === normalizedNext) {
+    return;
+  }
+  if (isSVG) {
+    el.setAttribute("class", normalizedNext);
+  } else {
+    el.className = normalizedNext;
+  }
+}
+var normalizeClass = normalizeClassName;
+var importantRE = /\s*!important$/;
+var prefixes = ["Webkit", "Moz", "ms"];
+var prefixCache = {};
+function patchStyle(el, prev, next2) {
+  const style = el.style;
+  if (next2 && isString(next2)) {
+    if (prev !== next2) {
+      style.cssText = next2;
+    }
+    return;
+  }
+  if (!next2) {
+    if (prev) {
+      el.removeAttribute("style");
+    }
+    return;
+  }
+  if (prev && !isString(prev)) {
+    const prevObj = prev;
+    for (const key in prevObj) {
+      if (!next2 || next2[key] == null) {
+        setStyle(style, key, "");
+      }
+    }
+  } else if (prev && isString(prev)) {
+    const declRE = /(?:^|;)\s*([a-z][a-z\d-]*)\s*:/gi;
+    let match;
+    while ((match = declRE.exec(prev)) !== null) {
+      const key = match[1].trim();
+      if (key && next2 && isObject(next2) && next2[key] == null) {
+        setStyle(style, key, "");
+      }
+    }
+  }
+  if (next2 && !isString(next2)) {
+    const nextObj = next2;
+    for (const key in nextObj) {
+      const value = nextObj[key];
+      if ((!prev || isString(prev) || prev[key] !== value) && value != null) {
+        setStyle(style, key, value);
+      }
+    }
+  }
+}
+function setStyle(style, name, val) {
+  if (isArray(val)) {
+    for (const element of val) {
+      setStyle(style, name, element);
+    }
+    return;
+  }
+  if (val == null || val === "") {
+    val = "";
+  }
+  if (name.startsWith("--")) {
+    style.setProperty(name, val);
+    return;
+  }
+  const prefixed = autoPrefix(style, name);
+  if (isString(val) && importantRE.test(val)) {
+    style.setProperty(camelCase(prefixed), val.replace(importantRE, ""), "important");
+  } else {
+    style[prefixed] = val;
+  }
+}
+function autoPrefix(style, rawName) {
+  const cached = prefixCache[rawName];
+  if (cached) {
+    return cached;
+  }
+  let name = camelCase(rawName);
+  if (name !== "filter" && name in style) {
+    return prefixCache[rawName] = name;
+  }
+  name = capitalize(name);
+  for (const prefix of prefixes) {
+    const prefixed = prefix + name;
+    if (prefixed in style) {
+      return prefixCache[rawName] = prefixed;
+    }
+  }
+  return rawName;
+}
+var _hydrationKey = 0;
+function getHydrationKey() {
+  return String(_hydrationKey++);
+}
+function resetHydrationKey() {
+  _hydrationKey = 0;
+}
+var _isHydrating = false;
+function isHydrating() {
+  return _isHydrating;
+}
+var _registry = /* @__PURE__ */ new Map();
+function gatherHydratable(root) {
+  const nodes = root.querySelectorAll("[data-hk]");
+  for (const node of nodes) {
+    const key = node.dataset.hk;
+    if (key != null && !_registry.has(key)) {
+      _registry.set(key, node);
+    }
+  }
+}
+var _teleportCallsiteAnchors = [];
+var _teleportTargetStarts = /* @__PURE__ */ new Map();
+function gatherTeleportAnchors() {
+  if (typeof document === "undefined") return;
+  const walker = document.createNodeIterator(document.body, NodeFilter.SHOW_COMMENT);
+  let node;
+  while (node = walker.nextNode()) {
+    const data = node.data;
+    if (data === "teleport-anchor") {
+      _teleportCallsiteAnchors.push(node);
+    } else if (data === "teleport-start") {
+      const parent = node.parentElement;
+      if (!parent) continue;
+      let bucket = _teleportTargetStarts.get(parent);
+      if (!bucket) {
+        bucket = [];
+        _teleportTargetStarts.set(parent, bucket);
+      }
+      bucket.push(node);
+    }
+  }
+}
+function consumeTeleportAnchor() {
+  var _a22;
+  return (_a22 = _teleportCallsiteAnchors.shift()) != null ? _a22 : null;
+}
+function consumeTeleportBlock(target) {
+  const bucket = _teleportTargetStarts.get(target);
+  const start = bucket == null ? void 0 : bucket.shift();
+  if (!start) return null;
+  const nodes = [];
+  let cursor = start.nextSibling;
+  while (cursor) {
+    if (cursor.nodeType === Node.COMMENT_NODE && cursor.data === "teleport-end") {
+      return { start, end: cursor, nodes };
+    }
+    nodes.push(cursor);
+    cursor = cursor.nextSibling;
+  }
+  {
+    warn("[Portal] hydration: orphaned <!--teleport-start--> without matching <!--teleport-end-->");
+  }
+  return null;
+}
+function beginHydration(root) {
+  _isHydrating = true;
+  _hydrationKey = 0;
+  _registry.clear();
+  _teleportCallsiteAnchors.length = 0;
+  _teleportTargetStarts.clear();
+  gatherHydratable(root);
+  gatherTeleportAnchors();
+}
+function endHydration() {
+  _isHydrating = false;
+  _registry.clear();
+  _teleportCallsiteAnchors.length = 0;
+  _teleportTargetStarts.clear();
+}
+function getRenderedElement(html) {
+  if (!isBrowser()) {
+    return () => {
+      throw new Error("[essor] getRenderedElement called in non-browser environment");
+    };
+  }
+  let _csrFactory = null;
+  return () => {
+    if (!_isHydrating) {
+      if (!_csrFactory) _csrFactory = template(html);
+      return _csrFactory();
+    }
+    const key = getHydrationKey();
+    const node = _registry.get(key);
+    if (node) {
+      _registry.delete(key);
+      return node;
+    }
+    warn(`[essor] hydration mismatch: no SSR element for key "${key}"`);
+    if (!_csrFactory) _csrFactory = template(html);
+    return _csrFactory();
+  };
+}
+function patchClassHydrate(el, prev, next2, isSVG) {
+  if (_isHydrating) return;
+  patchClass(el, prev, next2, isSVG);
+}
+function patchAttrHydrate(el, key, prev, next2) {
+  if (_isHydrating) return;
+  patchAttr(el, key, prev, next2);
+}
+function patchStyleHydrate(el, prev, next2) {
+  if (_isHydrating) return;
+  patchStyle(el, prev, next2);
+}
+function resolveInsertAnchor(parent, candidate) {
+  return candidate && candidate.parentNode === parent ? candidate : null;
+}
+function reconcileArrays(parent, oldNodes, newNodes, anchor) {
+  const fallbackAnchor = resolveInsertAnchor(parent, anchor);
+  const oldLength = oldNodes.length;
+  const newLength = newNodes.length;
+  if (oldLength === 0 && newLength === 0) return newNodes;
+  if (oldLength === 0) {
+    for (let i = 0; i < newLength; i++) {
+      insertNode(parent, newNodes[i], fallbackAnchor);
+    }
+    return newNodes;
+  }
+  if (newLength === 0) {
+    for (let i = 0; i < oldLength; i++) {
+      removeNode(oldNodes[i]);
+    }
+    return [];
+  }
+  let start = 0;
+  let oldEnd = oldLength - 1;
+  let newEnd = newLength - 1;
+  while (start <= oldEnd && start <= newEnd) {
+    if (oldNodes[start] === newNodes[start]) {
+      start++;
+    } else {
+      break;
+    }
+  }
+  while (oldEnd >= start && newEnd >= start) {
+    if (oldNodes[oldEnd] === newNodes[newEnd]) {
+      oldEnd--;
+      newEnd--;
+    } else {
+      break;
+    }
+  }
+  if (start > oldEnd) {
+    if (start <= newEnd) {
+      const nextPos = newEnd + 1;
+      const nextNode = resolveInsertAnchor(
+        parent,
+        nextPos < newLength ? newNodes[nextPos] : fallbackAnchor
+      );
+      for (let i = start; i <= newEnd; i++) {
+        insertNode(parent, newNodes[i], nextNode);
+      }
+    }
+  } else if (start > newEnd) {
+    for (let i = start; i <= oldEnd; i++) {
+      removeNode(oldNodes[i]);
+    }
+  } else {
+    reconcileUnknownSequence(parent, oldNodes, newNodes, start, oldEnd, newEnd, fallbackAnchor);
+  }
+  return newNodes;
+}
+function reconcileUnknownSequence(parent, oldNodes, newNodes, start, oldEnd, newEnd, anchor) {
+  const newLength = newEnd - start + 1;
+  const newIndexMap = /* @__PURE__ */ new Map();
+  for (let i = start; i <= newEnd; i++) {
+    newIndexMap.set(newNodes[i], i);
+  }
+  const newIndexToOldIndexMap = new Int32Array(newLength);
+  newIndexToOldIndexMap.fill(0);
+  let patched = 0;
+  let moved = false;
+  let maxNewIndexSoFar = 0;
+  for (let i = start; i <= oldEnd; i++) {
+    const oldNode = oldNodes[i];
+    if (patched >= newLength) {
+      removeNode(oldNode);
+      continue;
+    }
+    const newIndex = newIndexMap.get(oldNode);
+    if (newIndex === void 0) {
+      removeNode(oldNode);
+    } else {
+      newIndexToOldIndexMap[newIndex - start] = i + 1;
+      if (newIndex >= maxNewIndexSoFar) {
+        maxNewIndexSoFar = newIndex;
+      } else {
+        moved = true;
+      }
+      patched++;
+    }
+  }
+  const increasingNewIndexSequence = moved ? getSequence(newIndexToOldIndexMap) : [];
+  let j = increasingNewIndexSequence.length - 1;
+  for (let i = newLength - 1; i >= 0; i--) {
+    const nextIndex = start + i;
+    const nextNode = newNodes[nextIndex];
+    const anchorNode = resolveInsertAnchor(
+      parent,
+      nextIndex + 1 < newNodes.length ? newNodes[nextIndex + 1] : anchor
+    );
+    if (newIndexToOldIndexMap[i] === 0) {
+      insertNode(parent, nextNode, anchorNode);
+    } else if (moved) {
+      if (j < 0 || i !== increasingNewIndexSequence[j]) {
+        insertNode(parent, nextNode, anchorNode);
+      } else {
+        j--;
+      }
+    }
+  }
+}
+function getSequence(arr) {
+  const p2 = new Int32Array(arr.length);
+  const result = [0];
+  const len = arr.length;
+  let i;
+  let j;
+  let u;
+  let v;
+  let c;
+  for (i = 0; i < len; i++) {
+    const arrI = arr[i];
+    if (arrI !== 0) {
+      j = result[result.length - 1];
+      if (arr[j] < arrI) {
+        p2[i] = j;
+        result.push(i);
+        continue;
+      }
+      u = 0;
+      v = result.length - 1;
+      while (u < v) {
+        c = u + v >> 1;
+        if (arr[result[c]] < arrI) {
+          u = c + 1;
+        } else {
+          v = c;
+        }
+      }
+      if (arrI < arr[result[u]]) {
+        if (u > 0) {
+          p2[i] = result[u - 1];
+        }
+        result[u] = i;
+      }
+    }
+  }
+  u = result.length;
+  v = result[u - 1];
+  while (u-- > 0) {
+    result[u] = v;
+    v = p2[v];
+  }
+  return result;
+}
+function removeNode(node) {
+  if (!node) return;
+  if (isComponent(node)) {
+    node.destroy();
+  } else {
+    const element = node;
+    if (element.parentNode) {
+      element.remove();
+    }
+  }
+}
+function insertNode(parent, child2, before) {
+  if (!parent || !child2) return;
+  const beforeNode = isComponent(before) ? before.firstChild : before;
+  if (isComponent(child2)) {
+    child2.mount(parent, beforeNode);
+    return;
+  }
+  if (beforeNode) {
+    parent.insertBefore(child2, beforeNode);
+  } else {
+    {
+      if (!child2) {
+        error("insertNode: child is not a Node", child2);
+      }
+    }
+    parent.appendChild(child2);
+  }
+}
+function normalizeNode(node) {
+  if (node instanceof Node) return node;
+  if (isComponent(node)) return node;
+  const t = typeof node;
+  if (node == null || t === "string" || t === "number" || t === "boolean" || t === "symbol") {
+    return document.createTextNode(node === false || node == null ? "" : String(node));
+  }
+  if (isObject(node)) {
+    warn(
+      "Rendering a plain object as a node is not recommended. The object will be converted to its string representation.",
+      node
+    );
+  }
+  return document.createTextNode(String(node));
+}
+function insert(parent, nodeFactory, before) {
+  if (!parent) return;
+  const ownerScope = getActiveScope();
+  let renderedNodes = [];
+  let isFirstRun = true;
+  const resolveNodes = (raw) => {
+    if (raw instanceof Node) return [raw];
+    if (isComponent(raw)) return [raw];
+    const t = typeof raw;
+    if (raw == null || t === "string" || t === "number" || t === "boolean") {
+      return [normalizeNode(raw)];
+    }
+    return coerceArray(raw).map((item) => isFunction(item) ? item() : item).flatMap((i) => i).map(normalizeNode);
+  };
+  const effectRunner = effect(() => {
+    const executeUpdate = () => {
+      const rawNodes = isFunction(nodeFactory) ? nodeFactory() : nodeFactory;
+      const nodes = resolveNodes(rawNodes);
+      if (isFirstRun && isHydrating() && nodes.every((node) => node instanceof Node && node.parentNode === parent)) {
+        renderedNodes = nodes;
+        isFirstRun = false;
+        return;
+      }
+      renderedNodes = reconcileArrays(parent, renderedNodes, nodes, before);
+      isFirstRun = false;
+    };
+    if (ownerScope && !ownerScope.isDestroyed) {
+      runWithScope(ownerScope, executeUpdate);
+    } else {
+      executeUpdate();
+    }
+  });
+  onCleanup(() => {
+    effectRunner.stop();
+    for (const node of renderedNodes) removeNode(node);
+    renderedNodes = [];
+  });
+  return renderedNodes;
+}
+function child(node) {
+  return (node == null ? void 0 : node.firstChild) || null;
+}
+function next(node, step = 1) {
+  while (node && step > 0) {
+    node = node.nextSibling;
+    step--;
+  }
+  return node || null;
+}
+function nthChild(node, index) {
+  if (!node || index < 0) return null;
+  let current = node.firstChild;
+  while (current && index > 0) {
+    current = current.nextSibling;
+    index--;
+  }
+  return current || null;
+}
+function addEvent(el, event, handler, options) {
+  if (!(options == null ? void 0 : options.delegate)) {
+    el.addEventListener(event, handler, options);
+    return () => el.removeEventListener(event, handler, options);
+  }
+  const selector = options.delegate;
+  const wrappedHandler = (e) => {
+    const target = e.target;
+    if (target.matches(selector) || target.closest(selector)) {
+      handler.call(el, e);
+    }
+  };
+  const _a22 = options, { delegate: _ } = _a22, nativeOptions = __objRest(_a22, ["delegate"]);
+  el.addEventListener(event, wrappedHandler, nativeOptions);
+  return () => {
+    el.removeEventListener(event, wrappedHandler, nativeOptions);
+  };
+}
+function registerScopedHook(scope, listKey, hook) {
+  let hookList = scope[listKey];
+  if (!hookList) {
+    hookList = [];
+    scope[listKey] = hookList;
+  }
+  hookList.push(hook);
+}
+function executeHooks(hooks, scopeId2, phase) {
+  const len = hooks.length;
+  if (len === 0) return;
+  let pending;
+  for (let i = 0; i < len; i++) {
+    try {
+      const result = hooks[i]();
+      if (isPromise(result)) {
+        const safePromise = result.catch((error_) => {
+          if (true) {
+            error(`Scope(${scopeId2}): Async ${phase} hook rejected:`, error_);
+          }
+        });
+        (pending || (pending = [])).push(safePromise);
+      }
+    } catch (error_) {
+      {
+        error(`Scope(${scopeId2}): Error in ${phase} hook:`, error_);
+      }
+    }
+  }
+  if (!pending) return;
+  return Promise.all(pending).then(() => {
+  });
+}
+function onMount(hook) {
+  const scope = getActiveScope();
+  if (!scope) {
+    error("onMount() must be called within a scope");
+    return;
+  }
+  if (scope.isMounted) {
+    try {
+      const result = hook();
+      if (isPromise(result)) {
+        result.catch((error_) => {
+          if (true) error(`Scope(${scope.id}): Async mount hook rejected:`, error_);
+        });
+      }
+    } catch (error_) {
+      error(`Scope(${scope.id}): Error in mount hook:`, error_);
+    }
+    return;
+  }
+  registerScopedHook(scope, "onMount", hook);
+}
+function onUpdate(hook) {
+  const scope = getActiveScope();
+  if (!scope) {
+    error("onUpdate() must be called within a scope");
+    return;
+  }
+  registerScopedHook(scope, "onUpdate", hook);
+}
+function onDestroy(hook) {
+  const scope = getActiveScope();
+  if (!scope) {
+    error("onDestroy() must be called within a scope");
+    return;
+  }
+  registerScopedHook(scope, "onDestroy", hook);
+}
+function triggerMountHooks(scope) {
+  if (scope.isDestroyed) {
+    return;
+  }
+  if (!scope.onMount || scope.onMount.length === 0) {
+    scope.isMounted = true;
+    return;
+  }
+  const mountHooks = scope.onMount;
+  const result = runWithScope(scope, () => executeHooks(mountHooks, scope.id, "mount"));
+  mountHooks.length = 0;
+  scope.isMounted = true;
+  return result;
+}
+function triggerUpdateHooks(scope) {
+  if (scope.isDestroyed || !scope.onUpdate || scope.onUpdate.length === 0) return;
+  return runWithScope(scope, () => executeHooks(scope.onUpdate, scope.id, "update"));
+}
+function syncDescriptors(target, source, pruneMissing = false) {
+  const seen = pruneMissing ? /* @__PURE__ */ new Set() : null;
+  for (const key of Object.getOwnPropertyNames(source)) {
+    seen == null ? void 0 : seen.add(key);
+    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+  }
+  if (seen) {
+    for (const key of Object.getOwnPropertyNames(target)) {
+      if (!seen.has(key)) delete target[key];
+    }
+  }
+}
+function readProp(source, key) {
+  const descriptor = Object.getOwnPropertyDescriptor(source, key);
+  return descriptor.get ? descriptor.get.call(source) : descriptor.value;
+}
+var _a5;
+_a5 = "normal";
+var Component = class {
+  constructor(component, props = {}) {
+    this.component = component;
+    this.props = props;
+    this[_a5] = true;
+    this.scope = null;
+    this.state = 0;
+    this.beforeNode = void 0;
+    this.renderedNodes = [];
+    this.firstChild = void 0;
+    this.parentNode = void 0;
+    this.rootEventCleanups = [];
+    this.parentScope = getActiveScope();
+    const container = {};
+    syncDescriptors(container, props);
+    this.reactiveProps = shallowReactive(container);
+  }
+  /**
+   * Mount the component into `parentNode` (optionally before `beforeNode`).
+   * If already rendered, the existing DOM is re-inserted without re-running
+   * the component function.
+   */
+  mount(parentNode, beforeNode) {
+    var _a22;
+    this.parentNode = parentNode;
+    this.beforeNode = beforeNode;
+    this.state = 1;
+    if (this.renderedNodes.length > 0) {
+      for (const node of this.renderedNodes) {
+        insertNode(parentNode, node, beforeNode);
+      }
+      this.state = 2;
+      return this.renderedNodes;
+    }
+    const scope = createScope((_a22 = this.parentScope) != null ? _a22 : getActiveScope());
+    this.scope = scope;
+    const renderedNodes = runWithScope(scope, () => {
+      var _a32;
+      let result = this.component(this.reactiveProps);
+      if (isFunction(result)) {
+        result = result(this.reactiveProps);
+      }
+      if (isSignal(result) || isComputed(result)) {
+        result = result.value;
+      }
+      return (_a32 = insert(parentNode, result, beforeNode)) != null ? _a32 : [];
+    });
+    this.renderedNodes = renderedNodes;
+    this.firstChild = renderedNodes[0];
+    this.syncSpecialProps(this.props);
+    this.state = 2;
+    triggerMountHooks(scope);
+    return this.renderedNodes;
+  }
+  /**
+   * Re-install props into the same `reactiveProps` container (preserving
+   * any closures already holding a reference to it) and re-apply
+   * refs/events against the current root element.
+   */
+  update(props) {
+    this.props = props;
+    const scope = this.scope;
+    if (!scope || scope.isDestroyed) return;
+    syncDescriptors(
+      this.reactiveProps,
+      props != null ? props : {},
+      /* pruneMissing */
+      true
+    );
+    this.syncSpecialProps(props);
+    triggerUpdateHooks(scope);
+  }
+  /**
+   * Tear down and re-mount the component at its current insertion point.
+   * No-op if the component has never been mounted.
+   */
+  forceUpdate() {
+    if (!this.parentNode) return;
+    const parent = this.parentNode;
+    const before = this.beforeNode;
+    this.destroy();
+    this.mount(parent, before);
+  }
+  /**
+   * Dispose the scope, remove all rendered nodes, and clear bookkeeping.
+   * Idempotent: subsequent calls are no-ops.
+   */
+  destroy() {
+    const scope = this.scope;
+    if (!scope || scope.isDestroyed) return;
+    this.scope = null;
+    this.releaseSpecialProps();
+    disposeScope(scope);
+    for (const node of this.renderedNodes) removeNode(node);
+    this.renderedNodes = [];
+    this.firstChild = void 0;
+    this.parentNode = void 0;
+  }
+  /**
+   * Apply props that bind to the root DOM element rather than flowing into
+   * the component body: `ref` (signal/function) and `onXxx` event handlers.
+   * The render-facing `reactiveProps` already has those keys; here we just
+   * wire them to the actual DOM node.
+   */
+  syncSpecialProps(props) {
+    if (!props) return;
+    const root = this.firstChild;
+    if (!root) return;
+    this.releaseSpecialProps();
+    for (const key of Object.getOwnPropertyNames(props)) {
+      const value = readProp(props, key);
+      if (key === REF_KEY) {
+        this.rootRefCleanup = this.bindRootRef(value, root);
+        continue;
+      }
+      if (isOn(key) && isFunction(value)) {
+        const eventName = key.slice(2).toLowerCase();
+        this.rootEventCleanups.push(addEvent(root, eventName, value));
+      }
+    }
+  }
+  /**
+   * Remove all listeners/ref bindings currently attached to the root element.
+   */
+  releaseSpecialProps() {
+    for (const cleanup of this.rootEventCleanups) {
+      cleanup();
+    }
+    this.rootEventCleanups.length = 0;
+    if (this.rootRefCleanup) {
+      this.rootRefCleanup();
+      this.rootRefCleanup = void 0;
+    }
+  }
+  /**
+   * Bind the root ref prop and return a cleanup that restores the previous ref state.
+   */
+  bindRootRef(value, root) {
+    if (isFunction(value)) {
+      value(root);
+      return () => value(null);
+    }
+    if (isSignal(value)) {
+      const previousValue = value.value;
+      value.value = root;
+      return () => {
+        if (value.value === root) {
+          value.value = previousValue;
+        }
+      };
+    }
+    return void 0;
+  }
+};
+function isComponent(node) {
+  return !!node && !!node[
+    "normal"
+    /* NORMAL */
+  ];
+}
+function createComponent(componentFn, props) {
+  if (isComponent(componentFn)) {
+    return componentFn;
+  }
+  return new Component(componentFn, props);
+}
+function template(html) {
+  let node;
+  const create = () => {
+    const template2 = document.createElement("template");
+    template2.innerHTML = html;
+    const firstChild = template2.content.firstChild;
+    if (!firstChild) {
+      throw new Error("Invalid template: empty content");
+    }
+    return firstChild;
+  };
+  return () => (node || (node = create())).cloneNode(true);
+}
+function createApp(component, target) {
+  const container = isString(target) ? document.querySelector(target) : target;
+  if (!container) {
+    {
+      warn(`Target element not found: ${target}`);
+    }
+    return;
+  }
+  const existingContent = container.innerHTML;
+  if (existingContent) {
+    {
+      warn(`Target element is not empty, it will be cleared: ${target}`);
+    }
+    container.innerHTML = "";
+  }
+  const scope = createScope();
+  let rootNode;
+  try {
+    runWithScope(scope, () => {
+      const mountedRoot = createComponent(component);
+      if (isComponent(mountedRoot)) {
+        rootNode = mountedRoot;
+        insertNode(container, mountedRoot);
+      }
+    });
+  } catch (error_) {
+    disposeScope(scope);
+    throw error_;
+  }
+  return {
+    root: rootNode,
+    unmount: () => {
+      disposeScope(scope);
+      rootNode == null ? void 0 : rootNode.destroy();
+    }
+  };
+}
+function hydrate(component, target) {
+  const container = isString(target) ? document.querySelector(target) : target;
+  if (!container) {
+    {
+      warn(`[essor] hydrate: target element not found: ${target}`);
+    }
+    return;
+  }
+  beginHydration(container);
+  const scope = createScope();
+  let rootNode;
+  try {
+    runWithScope(scope, () => {
+      const mountedRoot = createComponent(component);
+      if (isComponent(mountedRoot)) {
+        rootNode = mountedRoot;
+        insert(container, mountedRoot);
+      }
+    });
+  } catch (error_) {
+    disposeScope(scope);
+    throw error_;
+  } finally {
+    endHydration();
+  }
+  return {
+    root: rootNode,
+    unmount: () => {
+      disposeScope(scope);
+      rootNode == null ? void 0 : rootNode.destroy();
+    }
+  };
+}
+function provide(key, value) {
+  const scope = getActiveScope();
+  if (!scope) {
+    {
+      error("provide() must be called within a scope");
+    }
+    return;
+  }
+  if (!scope.provides) {
+    scope.provides = /* @__PURE__ */ new Map();
+  }
+  scope.provides.set(key, value);
+}
+function inject(key, defaultValue) {
+  const scope = getActiveScope();
+  if (!scope) {
+    {
+      error("inject() must be called within a scope");
+    }
+    return defaultValue;
+  }
+  let current = scope;
+  while (current) {
+    if (current.provides) {
+      if (current.provides.has(key)) {
+        return current.provides.get(key);
+      }
+    }
+    current = current.parent;
+  }
+  return defaultValue;
+}
+function reTargetEvent(e, value) {
+  Object.defineProperty(e, "target", {
+    configurable: true,
+    value
+  });
+}
+function eventHandler(e) {
+  let node = e.target;
+  const key = e.type;
+  const oriTarget = e.target;
+  const oriCurrentTarget = e.currentTarget;
+  const handleNode = () => {
+    const handler = node[`_$${key}`];
+    if (handler && isFunction(handler) && !node.disabled) {
+      const data = node[`${key}Data`];
+      data ? handler.call(node, data, e) : handler.call(node, e);
+      if (e.cancelBubble) return false;
+    }
+    if (node.host && !isString(node.host) && !node.host._$host && isFunction(node.contains) && node.contains(e.target)) {
+      reTargetEvent(e, node.host);
+    }
+    return true;
+  };
+  const walkUpTree = () => {
+    while (handleNode() && (node = node._$host || node.parentNode || node.host)) ;
+  };
+  Object.defineProperty(e, "currentTarget", {
+    configurable: true,
+    /**
+     * Returns the current delegated target for the event.
+     */
+    get() {
+      return node || document;
+    }
+  });
+  if (e.composedPath) {
+    const path = e.composedPath();
+    reTargetEvent(e, path[0]);
+    for (let i = 0; i < path.length - 2; i++) {
+      node = path[i];
+      if (!handleNode()) break;
+      if (node._$host) {
+        node = node._$host;
+        walkUpTree();
+        break;
+      }
+      if (node.parentNode === oriCurrentTarget) {
+        break;
+      }
+    }
+  } else walkUpTree();
+  reTargetEvent(e, oriTarget);
+}
+var $EVENTS = /* @__PURE__ */ Symbol("_$EVENTS");
+function delegateEvents(eventNames, document2 = window.document) {
+  const docWithEvents = document2;
+  const eventSet = docWithEvents[$EVENTS] || (docWithEvents[$EVENTS] = /* @__PURE__ */ new Set());
+  for (const name of eventNames) {
+    if (!eventSet.has(name)) {
+      eventSet.add(name);
+      document2.addEventListener(name, eventHandler);
+    }
+  }
+}
+function clearDelegatedEvents(document2 = window.document) {
+  const docWithEvents = document2;
+  const eventSet = docWithEvents[$EVENTS];
+  if (eventSet) {
+    for (const name of eventSet.keys()) {
+      document2.removeEventListener(name, eventHandler);
+    }
+    delete docWithEvents[$EVENTS];
+  }
+}
+function addEventListener(element, event, handler, options) {
+  const cleanup = addEvent(element, event, handler, options);
+  if (getActiveScope()) {
+    onCleanup(cleanup);
+  }
+}
+function writeValue(el, v) {
+  const target = el;
+  const next2 = v == null ? "" : String(v);
+  if (target.value !== next2) target.value = next2;
+}
+var CHECKBOX = {
+  event: "change",
+  forceChange: true,
+  read: (el) => el.checked,
+  write(el, v) {
+    const e = el;
+    const next2 = Boolean(v);
+    if (e.checked !== next2) e.checked = next2;
+  }
+};
+var RADIO = {
+  event: "change",
+  forceChange: true,
+  read(el) {
+    const e = el;
+    return e.checked ? e.value : "";
+  },
+  write(el, v) {
+    const e = el;
+    const next2 = String(v) === e.value;
+    if (e.checked !== next2) e.checked = next2;
+  }
+};
+var FILE = {
+  event: "change",
+  forceChange: true,
+  read: (el) => el.files,
+  write() {
+  }
+  // browsers forbid programmatic writes to file inputs
+};
+var TEXT = {
+  event: "input",
+  ime: true,
+  read: (el) => el.value,
+  write: writeValue
+};
+var TEXTAREA = {
+  event: "input",
+  ime: true,
+  read: (el) => el.value,
+  write: writeValue
+};
+var SELECT = {
+  event: "change",
+  forceChange: true,
+  read(el) {
+    const s = el;
+    return s.multiple ? Array.from(s.selectedOptions, (o) => o.value) : s.value;
+  },
+  write(el, v) {
+    const s = el;
+    if (s.multiple) {
+      const selected = new Set((Array.isArray(v) ? v : []).map(String));
+      for (const opt of Array.from(s.options)) opt.selected = selected.has(opt.value);
+    } else {
+      writeValue(el, v);
+    }
+  }
+};
+function resolve(node, prop) {
+  switch (node.nodeName) {
+    case "INPUT":
+      if (prop === "checked") return node.type === "radio" ? RADIO : CHECKBOX;
+      if (prop === "files") return FILE;
+      return TEXT;
+    case "SELECT":
+      return SELECT;
+    case "TEXTAREA":
+      return TEXTAREA;
+    default:
+      return {
+        event: "input",
+        read: (el) => el[prop],
+        write(el, v) {
+          el[prop] = v;
+        }
+      };
+  }
+}
+function applyModifiers(v, trim, toNum) {
+  if (!isString(v)) return v;
+  let s = v;
+  if (trim) s = s.trim();
+  if (toNum && s !== "") {
+    const n = Number(s);
+    if (!Number.isNaN(n)) return n;
+  }
+  return s;
+}
+function isFocused(el) {
+  const root = el.getRootNode();
+  return (root instanceof Document || root instanceof ShadowRoot) && root.activeElement === el;
+}
+function bindElement(node, prop, getter, setter, modifiers = {}) {
+  if (!node) return;
+  const { event, read, write, forceChange, ime } = resolve(node, prop);
+  const trim = modifiers.trim === true;
+  const toNum = modifiers.number === true;
+  const lazy = modifiers.lazy === true;
+  const shouldCast = (trim || toNum) && prop !== "files";
+  const getModel = isFunction(getter) ? getter : () => getter;
+  const cast = shouldCast ? (v) => applyModifiers(v, trim, toNum) : (v) => v;
+  let composing = false;
+  const eventName = lazy || forceChange ? "change" : event;
+  const syncToModel = () => {
+    if (composing) return;
+    const raw = read(node);
+    if (raw === void 0) return;
+    const next2 = cast(raw);
+    if (!Object.is(getModel(), next2)) setter(next2);
+  };
+  addEventListener(node, eventName, syncToModel);
+  if (!lazy && shouldCast && eventName !== "change") {
+    addEventListener(node, "change", () => write(node, cast(read(node))));
+  }
+  if (ime && !lazy) {
+    addEventListener(node, "compositionstart", () => {
+      composing = true;
+    });
+    addEventListener(node, "compositionend", () => {
+      if (!composing) return;
+      composing = false;
+      syncToModel();
+    });
+  }
+  const runner = effect(() => {
+    const value = getModel();
+    if (ime && !lazy && isFocused(node)) {
+      if (composing) return;
+      if (Object.is(cast(read(node)), value)) return;
+    }
+    write(node, value);
+  });
+  if (getActiveScope()) {
+    onCleanup(() => runner.stop());
+  }
+}
+function omitProps(target, keys) {
+  const excludeSet = new Set(keys);
+  return new Proxy(target, {
+    /**
+     * Returns a property unless it is excluded by the proxy.
+     */
+    get(obj, prop) {
+      if (excludeSet.has(prop)) {
+        return void 0;
+      }
+      return Reflect.get(obj, prop);
+    },
+    /**
+     * Returns the enumerable keys that are not excluded from the proxy.
+     */
+    ownKeys(obj) {
+      return Reflect.ownKeys(obj).filter((key) => !excludeSet.has(key));
+    },
+    /**
+     * Returns the property descriptor unless the key is excluded.
+     */
+    getOwnPropertyDescriptor(obj, prop) {
+      if (excludeSet.has(prop)) {
+        return void 0;
+      }
+      return Reflect.getOwnPropertyDescriptor(obj, prop);
+    },
+    /**
+     * Returns whether the requested value exists.
+     */
+    has(obj, prop) {
+      if (excludeSet.has(prop)) {
+        return false;
+      }
+      return Reflect.has(obj, prop);
+    }
+  });
+}
+function Fragment(props) {
+  if (!props || props.children == null) return null;
+  return props.children;
+}
+Fragment[FRAGMENT_COMPONENT] = true;
+function isFragment(node) {
+  return !!node && !!node[FRAGMENT_COMPONENT];
+}
+function resolveTarget(props) {
+  const raw = isFunction(props.target) ? props.target() : props.target;
+  if (raw == null) return null;
+  if (isString(raw)) return document.querySelector(raw);
+  return raw;
+}
+function evalDisabled(props) {
+  return isFunction(props.disabled) ? !!props.disabled() : !!props.disabled;
+}
+function Portal(props) {
+  if (isHydrating()) {
+    const adopted = tryHydratePortal(props);
+    if (adopted) return adopted;
+  }
+  const placeholder = document.createComment("portal");
+  placeholder[PORTAL_COMPONENT] = true;
+  const { children } = props;
+  if (children == null) return placeholder;
+  const ownerScope = getActiveScope();
+  let innerScope = null;
+  const mountAt = (parent, before) => {
+    innerScope = createScope(ownerScope);
+    runWithScope(innerScope, () => {
+      insert(parent, () => children, before);
+    });
+  };
+  const teardown = () => {
+    if (innerScope) {
+      disposeScope(innerScope);
+      innerScope = null;
+    }
+  };
+  const apply = (disabled, target) => {
+    teardown();
+    if (disabled) {
+      const parent = placeholder.parentNode;
+      if (!parent) return;
+      mountAt(parent, placeholder);
+      return;
+    }
+    if (!target) {
+      {
+        warn(`[Portal] Target element not found: ${String(props.target)}`);
+      }
+      return;
+    }
+    mountAt(target);
+  };
+  let mounted = false;
+  const effectRunner = effect(() => {
+    const disabled = evalDisabled(props);
+    const target = disabled ? null : resolveTarget(props);
+    if (mounted) {
+      apply(disabled, target);
+    }
+  });
+  onMount(() => {
+    mounted = true;
+    const disabled = evalDisabled(props);
+    const target = disabled ? null : resolveTarget(props);
+    if (disabled || target) {
+      apply(disabled, target);
+      return;
+    }
+    queueMicrotask(() => {
+      if (!placeholder.parentNode) return;
+      apply(evalDisabled(props), resolveTarget(props));
+    });
+  });
+  onCleanup(() => {
+    effectRunner.stop();
+    teardown();
+  });
+  return placeholder;
+}
+Portal[PORTAL_COMPONENT] = true;
+function tryHydratePortal(props) {
+  if (evalDisabled(props)) return null;
+  const anchor = consumeTeleportAnchor();
+  if (!anchor) {
+    {
+      warn("[Portal] hydration mismatch: no <!--teleport-anchor--> at call site.");
+    }
+    return null;
+  }
+  const target = resolveTarget(props);
+  if (!target) {
+    {
+      warn(`[Portal] hydration mismatch: target not found: ${String(props.target)}`);
+    }
+    return null;
+  }
+  const block = consumeTeleportBlock(target);
+  if (!block) {
+    {
+      warn(
+        `[Portal] hydration mismatch: no <!--teleport-start--> in target ${String(props.target)}`
+      );
+    }
+    return null;
+  }
+  anchor[PORTAL_COMPONENT] = true;
+  return anchor;
+}
+function isPortal(node) {
+  return !!node && !!node[PORTAL_COMPONENT];
+}
+function clearContainer(el) {
+  while (el.firstChild) {
+    el.removeChild(el.firstChild);
+  }
+}
+function resolveNodeValue(value) {
+  let current = value;
+  while (isFunction(current)) {
+    current = current();
+  }
+  if (isSignal(current) || isComputed(current)) {
+    return resolveNodeValue(current.value);
+  }
+  return current;
+}
+var SuspenseContext = /* @__PURE__ */ Symbol("SuspenseContext");
+function Suspense(props) {
+  var _a22;
+  if (!isBrowser()) {
+    return (_a22 = props.fallback) != null ? _a22 : "";
+  }
+  const container = document.createElement("div");
+  container.style.display = "contents";
+  let isMounted = true;
+  let pendingCount = 0;
+  let isShowingFallback = false;
+  let resolvedChildren = null;
+  const materializeChild = (value) => {
+    const current = resolveNodeValue(value);
+    if (isArray(current)) {
+      const nodes = [];
+      for (const item of current) {
+        const materialized = materializeChild(item);
+        if (isArray(materialized)) {
+          nodes.push(...materialized);
+        } else {
+          nodes.push(materialized);
+        }
+      }
+      return nodes;
+    }
+    return normalizeNode(current);
+  };
+  const insertMaterializedChild = (value) => {
+    const normalized = materializeChild(value);
+    const nodes = isArray(normalized) ? normalized : [normalized];
+    for (const node of nodes) {
+      if (node != null) {
+        insertNode(container, node);
+      }
+    }
+  };
+  const renderFallbackContent = () => {
+    clearContainer(container);
+    if (props.fallback != null) {
+      insertMaterializedChild(props.fallback);
+    }
+  };
+  const showFallback = () => {
+    if (isShowingFallback) return;
+    isShowingFallback = true;
+    renderFallbackContent();
+  };
+  const showChildren = () => {
+    if (!isShowingFallback) return;
+    const hasContent = resolvedChildren || props.children != null && !isPromise(props.children);
+    if (!hasContent) {
+      return;
+    }
+    isShowingFallback = false;
+    clearContainer(container);
+    if (resolvedChildren) {
+      renderChildren(resolvedChildren);
+    } else if (props.children != null && !isPromise(props.children)) {
+      renderChildren(props.children);
+    }
+  };
+  const renderChildren = (children2) => {
+    if (isShowingFallback) return;
+    clearContainer(container);
+    if (children2 == null) return;
+    const childArray = isArray(children2) ? children2 : [children2];
+    for (const child2 of childArray) {
+      if (child2 != null) {
+        insertMaterializedChild(child2);
+      }
+    }
+    if (isShowingFallback) {
+      renderFallbackContent();
+    }
+  };
+  const suspenseContext = {
+    register: (promise) => {
+      pendingCount++;
+      showFallback();
+      promise.then(() => {
+        if (!isMounted) return;
+        pendingCount--;
+        if (pendingCount === 0) {
+          showChildren();
+        }
+      }).catch((error4) => {
+        {
+          warn("[Suspense] Resource failed:", error4);
+        }
+        if (!isMounted) return;
+        pendingCount--;
+        if (pendingCount === 0) {
+          showChildren();
+        }
+      });
+    },
+    increment: () => {
+      pendingCount++;
+      showFallback();
+    },
+    decrement: () => {
+      pendingCount = Math.max(0, pendingCount - 1);
+      if (pendingCount === 0) {
+        showChildren();
+      }
+    }
+  };
+  provide(SuspenseContext, suspenseContext);
+  const children = props.children;
+  if (isPromise(children)) {
+    children.then((resolved) => {
+      resolvedChildren = resolved;
+    }).catch(() => {
+    });
+    suspenseContext.register(children);
+  } else if (children != null) {
+    renderChildren(children);
+  } else {
+    showFallback();
+  }
+  onDestroy(() => {
+    isMounted = false;
+    pendingCount = 0;
+    resolvedChildren = null;
+    clearContainer(container);
+    container.remove();
+  });
+  return container;
+}
+Suspense[SUSPENSE_COMPONENT] = true;
+function isSuspense(node) {
+  return !!node && !!node[SUSPENSE_COMPONENT];
+}
+function createResource(fetcher, options) {
+  const value = signal(options == null ? void 0 : options.initialValue);
+  const loading = signal(true);
+  const error4 = signal(null);
+  const state = signal("pending");
+  let fetchId = 0;
+  let currentPromise = null;
+  let suspenseRegistered = false;
+  const suspenseContext = inject(SuspenseContext, null);
+  const fetch = () => __async(null, null, function* () {
+    const currentFetchId = ++fetchId;
+    loading.value = true;
+    state.value = "pending";
+    error4.value = null;
+    suspenseRegistered = false;
+    if (suspenseContext) {
+      suspenseContext.increment();
+    }
+    try {
+      const promise = fetcher();
+      currentPromise = promise;
+      promise.catch(() => {
+      });
+      const result = yield promise;
+      if (currentFetchId === fetchId) {
+        value.value = result;
+        state.value = "ready";
+        loading.value = false;
+      }
+    } catch (error_) {
+      if (currentFetchId === fetchId) {
+        error4.value = error_ instanceof Error ? error_ : new Error(String(error_));
+        state.value = "errored";
+        loading.value = false;
+      }
+    } finally {
+      if (suspenseContext) {
+        suspenseContext.decrement();
+      }
+    }
+  });
+  fetch();
+  const resource = (() => {
+    if (!suspenseRegistered && loading.value && currentPromise && suspenseContext) {
+      suspenseRegistered = true;
+      suspenseContext.register(currentPromise);
+    }
+    return value.value;
+  });
+  resource.loading = loading;
+  resource.error = error4;
+  resource.state = state;
+  const actions = {
+    mutate: (newValue) => {
+      value.value = newValue;
+      state.value = "ready";
+      loading.value = false;
+      error4.value = null;
+    },
+    refetch: () => __async(null, null, function* () {
+      yield fetch();
+    })
+  };
+  return [resource, actions];
+}
+function resolveModule(mod) {
+  return isFunction(mod) ? mod : mod.default;
+}
+function renderInto(el, fn, props) {
+  const comp = new Component(fn, props);
+  comp.mount(el);
+  return comp;
+}
+function defineAsyncComponent(loader, options = {}) {
+  const { delay = 200, timeout, ssr = "blocking", onError } = options;
+  if (typeof window === "undefined") {
+    if (ssr === "client-only") {
+      const placeholder = () => "";
+      placeholder.__asyncLoader = loader;
+      placeholder.__asyncResolved = () => null;
+      return placeholder;
+    }
+    let ssrResolved = null;
+    let ssrPromise = null;
+    const ssrLoad = () => {
+      if (ssrPromise) return ssrPromise;
+      ssrPromise = loader().then((mod) => {
+        ssrResolved = resolveModule(mod);
+      }).catch(() => {
+      });
+      return ssrPromise;
+    };
+    ssrLoad();
+    const ssrWrapper = (props) => {
+      if (ssrResolved) {
+        return ssrResolved(props);
+      }
+      return "";
+    };
+    ssrWrapper.__asyncLoader = ssrLoad;
+    ssrWrapper.__asyncResolved = () => ssrResolved;
+    return ssrWrapper;
+  }
+  let cachedComponent = null;
+  let cachedError = null;
+  let cachedStatus = "pending";
+  let loadPromise = null;
+  function load() {
+    if (loadPromise) return loadPromise;
+    loadPromise = loader().then((mod) => {
+      cachedComponent = resolveModule(mod);
+      cachedStatus = "resolved";
+    }).catch((error4) => {
+      cachedError = error4 instanceof Error ? error4 : new Error(String(error4));
+      cachedStatus = "errored";
+      loadPromise = null;
+    });
+    return loadPromise;
+  }
+  load();
+  function AsyncWrapper(props) {
+    var _a22;
+    if (cachedStatus === "resolved" && cachedComponent) {
+      const el = document.createElement("div");
+      el.style.display = "contents";
+      const comp = renderInto(el, cachedComponent, props);
+      onCleanup(() => comp.destroy());
+      return el;
+    }
+    if (cachedStatus === "errored" && cachedError) {
+      const el = document.createElement("div");
+      el.style.display = "contents";
+      if (options.error) {
+        let alive2 = true;
+        let currentComp2 = null;
+        const swap2 = (fn, swapProps) => {
+          if (!alive2) return;
+          currentComp2 == null ? void 0 : currentComp2.destroy();
+          currentComp2 = renderInto(el, fn, swapProps);
+        };
+        const retry = () => {
+          loadPromise = null;
+          cachedStatus = "pending";
+          cachedError = null;
+          if (options.loading) swap2(options.loading);
+          load().then(() => {
+            if (!alive2) return;
+            if (cachedStatus === "resolved" && cachedComponent) {
+              swap2(cachedComponent, props);
+            } else if (cachedStatus === "errored" && cachedError) {
+              if (options.error) swap2(options.error, { error: cachedError, retry });
+            }
+          });
+        };
+        swap2(options.error, { error: cachedError, retry });
+        onDestroy(() => {
+          alive2 = false;
+          currentComp2 == null ? void 0 : currentComp2.destroy();
+          currentComp2 = null;
+        });
+      }
+      return el;
+    }
+    const container = document.createElement("div");
+    container.style.display = "contents";
+    let alive = true;
+    let currentComp = null;
+    let delayTimer = null;
+    let timeoutTimer = null;
+    const swap = (fn, swapProps) => {
+      if (!alive) return;
+      currentComp == null ? void 0 : currentComp.destroy();
+      currentComp = renderInto(container, fn, swapProps);
+    };
+    const retryWith = (retryProps) => () => {
+      loadPromise = null;
+      cachedStatus = "pending";
+      cachedError = null;
+      if (options.loading) swap(options.loading);
+      load().then(() => {
+        if (cachedStatus === "resolved" && cachedComponent) {
+          swap(cachedComponent, retryProps);
+        } else if (cachedStatus === "errored" && cachedError) {
+          if (options.error) {
+            swap(options.error, {
+              error: cachedError,
+              retry: retryWith(retryProps)
+            });
+          }
+        }
+      });
+    };
+    onDestroy(() => {
+      alive = false;
+      currentComp == null ? void 0 : currentComp.destroy();
+      currentComp = null;
+      if (delayTimer != null) clearTimeout(delayTimer);
+      if (timeoutTimer != null) clearTimeout(timeoutTimer);
+    });
+    const suspenseCtx = (_a22 = inject(SuspenseContext)) != null ? _a22 : null;
+    const showResolved = (compFn) => swap(compFn, props);
+    const showError = (err) => {
+      if (options.error) swap(options.error, { error: err, retry: retryWith(props) });
+    };
+    const showLoading = () => {
+      if (options.loading) swap(options.loading);
+    };
+    const instancePromise = load().then(() => {
+      if (!alive) return;
+      if (cachedStatus === "resolved" && cachedComponent) {
+        showResolved(cachedComponent);
+      } else if (cachedStatus === "errored" && cachedError) {
+        showError(cachedError);
+        if (onError) onError(cachedError, retryWith(props));
+      }
+      if (delayTimer != null) clearTimeout(delayTimer);
+      if (timeoutTimer != null) clearTimeout(timeoutTimer);
+    });
+    if (suspenseCtx) {
+      suspenseCtx.register(instancePromise);
+    }
+    if (delay > 0) {
+      delayTimer = setTimeout(() => {
+        if (alive && cachedStatus === "pending") {
+          showLoading();
+        }
+      }, delay);
+    } else if (options.loading) {
+      showLoading();
+    }
+    if (timeout != null) {
+      timeoutTimer = setTimeout(() => {
+        if (alive && cachedStatus === "pending") {
+          const err = new Error(`[defineAsyncComponent] Timeout after ${timeout}ms`);
+          cachedError = err;
+          cachedStatus = "errored";
+          showError(err);
+          if (onError) onError(err, retryWith(props));
+        }
+      }, timeout);
+    }
+    return container;
+  }
+  AsyncWrapper.__asyncLoader = load;
+  AsyncWrapper.__asyncResolved = () => cachedComponent;
+  return AsyncWrapper;
+}
+function For(props) {
+  const fragment = document.createDocumentFragment();
+  const marker = document.createComment("");
+  fragment.appendChild(marker);
+  let entries = [];
+  let fallbackNodes = [];
+  const keyFn = props.key;
+  const renderFn = props.children;
+  const getList = () => {
+    var _a22, _b2;
+    const input = props.each;
+    if (isSignal(input)) return (_a22 = input.value) != null ? _a22 : [];
+    if (isFunction(input)) return (_b2 = input()) != null ? _b2 : [];
+    return input != null ? input : [];
+  };
+  const getKey = (item) => keyFn ? keyFn(item) : item;
+  const normalizeNodes = (value) => {
+    if (Array.isArray(value)) {
+      const nodes = [];
+      for (const item of value) {
+        nodes.push(...normalizeNodes(item));
+      }
+      return nodes;
+    }
+    return [normalizeNode(value)];
+  };
+  const mountValue = (value, parent, before) => {
+    const nodes = normalizeNodes(value);
+    for (const node of nodes) {
+      if (before) {
+        parent.insertBefore(node, before);
+      } else {
+        parent.appendChild(node);
+      }
+    }
+    return nodes;
+  };
+  const mountFallback = (parent, before) => {
+    if (!props.fallback) return;
+    const nodes = mountValue(props.fallback(), parent, before);
+    fallbackNodes = nodes;
+  };
+  const clearFallback = () => {
+    for (const node of fallbackNodes) {
+      if (node.parentNode) {
+        node.parentNode.removeChild(node);
+      }
+    }
+    fallbackNodes = [];
+  };
+  const renderItem = (item, index, parent, before) => {
+    const parentScope = getActiveScope();
+    const scope = createScope(parentScope);
+    let mountedNodes = [];
+    runWithScope(scope, () => {
+      mountedNodes = mountValue(renderFn(item, index), parent, before);
+    });
+    return { key: getKey(item), item, nodes: mountedNodes, scope };
+  };
+  const disposeItem = (entry) => {
+    disposeScope(entry.scope);
+    for (const node of entry.nodes) {
+      if (node.parentNode) {
+        node.parentNode.removeChild(node);
+      }
+    }
+  };
+  const effectRunner = effect(() => {
+    const newItems = getList();
+    const parent = marker.parentNode;
+    if (!parent) {
+      if (newItems.length === 0) {
+        mountFallback(fragment, marker);
+      } else {
+        entries = new Array(newItems.length);
+        let idx = 0;
+        for (const newItem of newItems) {
+          entries[idx] = renderItem(newItem, idx, fragment, marker);
+          idx++;
+        }
+      }
+      return;
+    }
+    reconcile(parent, newItems);
+  });
+  function reconcile(parent, newItems) {
+    const oldLen = entries.length;
+    const newLen = newItems.length;
+    if (newLen === 0) {
+      for (let i = 0; i < oldLen; i++) {
+        disposeItem(entries[i]);
+      }
+      entries = [];
+      if (props.fallback && fallbackNodes.length === 0) {
+        mountFallback(parent, marker);
+      }
+      return;
+    }
+    if (oldLen === 0 || fallbackNodes.length > 0) {
+      if (fallbackNodes.length > 0) {
+        clearFallback();
+      }
+      entries = new Array(newLen);
+      const batchFragment2 = document.createDocumentFragment();
+      for (let i = 0; i < newLen; i++) {
+        entries[i] = renderItem(newItems[i], i, batchFragment2, null);
+      }
+      parent.insertBefore(batchFragment2, marker);
+      return;
+    }
+    const oldKeyMap = /* @__PURE__ */ new Map();
+    for (let i = 0; i < oldLen; i++) {
+      const entry = entries[i];
+      const list = oldKeyMap.get(entry.key);
+      const pair = [entry, i];
+      if (list) list.push(pair);
+      else oldKeyMap.set(entry.key, [pair]);
+    }
+    const newEntries = new Array(newLen);
+    const toRemove = [];
+    let batchFragment = null;
+    const newIndexToOldIndex = new Int32Array(newLen);
+    let moved = false;
+    let maxOldSeen = 0;
+    const newKeys = new Array(newLen);
+    for (let i = 0; i < newLen; i++) {
+      newKeys[i] = getKey(newItems[i]);
+    }
+    for (let i = 0; i < newLen; i++) {
+      const item = newItems[i];
+      const key = newKeys[i];
+      const oldList = oldKeyMap.get(key);
+      if (oldList && oldList.length > 0) {
+        const [reused, oldIndex] = oldList.shift();
+        if (Object.is(reused.item, item)) {
+          reused.item = item;
+          newEntries[i] = reused;
+          newIndexToOldIndex[i] = oldIndex + 1;
+          if (oldIndex < maxOldSeen) moved = true;
+          else maxOldSeen = oldIndex;
+        } else {
+          if (!batchFragment) batchFragment = document.createDocumentFragment();
+          disposeItem(reused);
+          newEntries[i] = renderItem(item, i, batchFragment, null);
+        }
+      } else {
+        if (!batchFragment) batchFragment = document.createDocumentFragment();
+        newEntries[i] = renderItem(item, i, batchFragment, null);
+      }
+    }
+    for (const list of oldKeyMap.values()) {
+      for (const [entry] of list) toRemove.push(entry);
+    }
+    for (const entry of toRemove) disposeItem(entry);
+    const lis = moved ? getSequence(newIndexToOldIndex) : [];
+    let lisCursor = lis.length - 1;
+    let nextNode = marker;
+    for (let i = newLen - 1; i >= 0; i--) {
+      const entry = newEntries[i];
+      const nodes = entry.nodes;
+      const isFresh = newIndexToOldIndex[i] === 0;
+      const inLis = !isFresh && moved && lisCursor >= 0 && i === lis[lisCursor];
+      if (inLis) {
+        lisCursor--;
+        for (let j = nodes.length - 1; j >= 0; j--) nextNode = nodes[j];
+        continue;
+      }
+      for (let j = nodes.length - 1; j >= 0; j--) {
+        const node = nodes[j];
+        if (node.nextSibling !== nextNode) {
+          parent.insertBefore(node, nextNode);
+        }
+        nextNode = node;
+      }
+    }
+    entries = newEntries;
+  }
+  onCleanup(() => {
+    effectRunner.stop();
+    for (const entry of entries) {
+      disposeItem(entry);
+    }
+    entries = [];
+    clearFallback();
+    if (marker.parentNode) {
+      marker.parentNode.removeChild(marker);
+    }
+  });
+  return fragment;
+}
+For[FOR_COMPONENT] = true;
+
+export { Component, For, Fragment, Portal, Suspense, TriggerOpTypes, __version, addEvent, addEventListener, batch, beginHydration, bindElement, child, clearDelegatedEvents, computed, consumeTeleportAnchor, consumeTeleportBlock, createApp, createComponent, createResource, createStore, defineAsyncComponent, delegateEvents, effect, endBatch, endHydration, error, escapeHTML, getBatchDepth, getHydrationKey, getRenderedElement, hydrate, inject, insert, isArray, isBatching, isComponent, isComputed, isEffect, isFragment, isFunction, isHydrating, isNil, isObject, isPortal, isPromise, isReactive, isRef, isShallow, isSignal, isString, isSuspense, memoEffect, next, nextTick, normalizeClass, normalizeClassName, normalizeStyle, nthChild, omitProps, onDestroy, onMount, onUpdate, patchAttr, patchAttrHydrate, patchClass, patchClassHydrate, patchStyle, patchStyleHydrate, provide, queueJob, queuePreFlushCb, reactive, ref, resetHydrationKey, setStyle, shallowReactive, shallowSignal, signal, startBatch, stop, styleToString, template, toRaw, toReactive, trigger, untrack, watch };
+//# sourceMappingURL=chunk-FIBC7TTZ.esm.js.map
+//# sourceMappingURL=chunk-FIBC7TTZ.esm.js.map