what-core 0.10.0 → 0.11.0

package/dist/chunk-GZRA4IAJ.js

@@ -0,0 +1,1699 @@
+import {
+  h
+} from "./chunk-AZP2EOGX.js";
+
+// packages/core/src/reactive.js
+var __DEV__ = typeof process !== "undefined" ? true : true;
+var __devtools = null;
+function __setDevToolsHooks(hooks) {
+  if (__DEV__) __devtools = hooks;
+}
+var currentEffect = null;
+var currentRoot = null;
+var currentOwner = null;
+var insideComputed = false;
+var batchDepth = 0;
+var pendingEffects = [];
+var pendingNeedSort = false;
+var NEEDS_UPSTREAM = /* @__PURE__ */ Symbol("needs_upstream");
+var iterativeEvalStack = null;
+function signal(initial, debugName) {
+  let value = initial;
+  const subs = /* @__PURE__ */ new Set();
+  let lastTracked = null;
+  let lastTrackedEpoch = 0;
+  function _sigWrite(next) {
+    if (__DEV__ && insideComputed) {
+      console.warn(
+        "[what] Signal.set() called inside a computed function. This may cause infinite loops. Use effect() instead." + (debugName ? ` (signal: ${debugName})` : "")
+      );
+    }
+    const nextVal = typeof next === "function" ? next(value) : next;
+    if (value === nextVal || value !== value && nextVal !== nextVal) return;
+    value = nextVal;
+    lastTracked = null;
+    if (__DEV__ && __devtools) __devtools.onSignalUpdate(sig);
+    if (subs.size > 0) notify(subs);
+  }
+  function sig(newVal) {
+    if (arguments.length === 0) {
+      const ce = currentEffect;
+      if (ce !== null) {
+        if (ce !== lastTracked || ce._epoch !== lastTrackedEpoch) {
+          lastTracked = ce;
+          lastTrackedEpoch = ce._epoch;
+          subs.add(ce);
+          ce.deps.push(subs);
+        }
+      }
+      return value;
+    }
+    _sigWrite(newVal);
+  }
+  sig.set = _sigWrite;
+  sig.peek = () => value;
+  sig.subscribe = (fn) => {
+    return effect(() => fn(sig()));
+  };
+  sig._signal = true;
+  if (__DEV__) {
+    sig._subs = subs;
+    if (debugName) sig._debugName = debugName;
+  }
+  if (__DEV__ && __devtools) __devtools.onSignalCreate(sig);
+  return sig;
+}
+function computed(fn) {
+  let value, dirty = true;
+  const subs = /* @__PURE__ */ new Set();
+  let lastTracked = null;
+  let lastTrackedEpoch = 0;
+  const inner = _createEffect(() => {
+    const prevInsideComputed = insideComputed;
+    if (__DEV__) insideComputed = true;
+    try {
+      value = fn();
+      dirty = false;
+    } finally {
+      if (__DEV__) insideComputed = prevInsideComputed;
+    }
+  }, true);
+  inner._level = 1;
+  inner._computed = true;
+  inner._computedSubs = subs;
+  subs._owner = inner;
+  inner._markDirty = () => {
+    dirty = true;
+  };
+  inner._isDirty = () => dirty;
+  function read() {
+    const ce = currentEffect;
+    if (ce !== null) {
+      if (ce !== lastTracked || ce._epoch !== lastTrackedEpoch) {
+        lastTracked = ce;
+        lastTrackedEpoch = ce._epoch;
+        subs.add(ce);
+        ce.deps.push(subs);
+      }
+    }
+    if (dirty) _evaluateComputed(inner);
+    return value;
+  }
+  inner._onNotify = () => {
+    dirty = true;
+    lastTracked = null;
+    if (subs.size > 0) notify(subs);
+  };
+  read._signal = true;
+  read.peek = () => {
+    if (dirty) _evaluateComputed(inner);
+    return value;
+  };
+  return read;
+}
+function _evaluateComputed(computedEffect) {
+  if (iterativeEvalStack !== null) {
+    iterativeEvalStack.push(computedEffect);
+    throw NEEDS_UPSTREAM;
+  }
+  const stack = [computedEffect];
+  iterativeEvalStack = stack;
+  try {
+    while (stack.length > 0) {
+      const current = stack[stack.length - 1];
+      if (!current._isDirty || !current._isDirty()) {
+        stack.pop();
+        continue;
+      }
+      let pushedUpstream = false;
+      const deps = current.deps;
+      for (let i = 0; i < deps.length; i++) {
+        const depOwner = deps[i]._owner;
+        if (depOwner && depOwner._computed && depOwner._isDirty && depOwner._isDirty()) {
+          stack.push(depOwner);
+          pushedUpstream = true;
+        }
+      }
+      if (pushedUpstream) {
+        continue;
+      }
+      try {
+        const prevDepsLen = current.deps.length;
+        _runEffect(current);
+        if (current.deps.length !== prevDepsLen) {
+          _updateLevel(current);
+        }
+        stack.pop();
+      } catch (err) {
+        if (err === NEEDS_UPSTREAM) {
+          current._markDirty();
+        } else {
+          throw err;
+        }
+      }
+    }
+  } finally {
+    iterativeEvalStack = null;
+  }
+}
+function _updateLevel(e) {
+  let maxDepLevel = 0;
+  const deps = e.deps;
+  for (let i = 0; i < deps.length; i++) {
+    const owner = deps[i]._owner;
+    if (owner) {
+      const depLevel = owner._level;
+      if (depLevel > maxDepLevel) maxDepLevel = depLevel;
+    }
+  }
+  e._level = maxDepLevel + 1;
+}
+var _noopDispose = () => {
+};
+function effect(fn, opts) {
+  const e = _createEffect(fn);
+  e._level = 1;
+  const prev = currentEffect;
+  currentEffect = e;
+  try {
+    const result = e.fn();
+    if (typeof result === "function") e._cleanup = result;
+  } finally {
+    currentEffect = prev;
+  }
+  _updateLevel(e);
+  if (opts?.stable) e._stable = true;
+  if (e.deps.length === 0 && e._cleanup === null) {
+    e.disposed = true;
+    if (__DEV__ && __devtools) __devtools.onEffectDispose(e);
+    return _noopDispose;
+  }
+  const dispose = () => _disposeEffect(e);
+  if (currentRoot) {
+    currentRoot.disposals.push(dispose);
+  }
+  return dispose;
+}
+function batch(fn) {
+  batchDepth++;
+  try {
+    fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0) flush();
+  }
+}
+function _createEffect(fn, lazy2) {
+  const e = {
+    fn,
+    deps: [],
+    // array of subscriber sets (cheaper than Set for typical 1-3 deps)
+    lazy: lazy2 || false,
+    _onNotify: null,
+    disposed: false,
+    _pending: false,
+    _stable: false,
+    // stable effects skip cleanup/re-subscribe on re-run
+    _level: 0,
+    // topological depth: signals=0, computed/effects=max(deps)+1
+    _computed: false,
+    // true for computed inner effects
+    _computedSubs: null,
+    // reference to the computed's subscriber set
+    _isDirty: null,
+    // function to check if computed is dirty (set by computed())
+    _markDirty: null,
+    // function to mark computed dirty (set by computed())
+    _cleanup: null,
+    // cleanup function returned by effect fn (declared upfront for shape)
+    _epoch: 0
+    // incremented on cleanup — used by signal lastTracked cache
+  };
+  if (__DEV__ && __devtools) __devtools.onEffectCreate(e);
+  return e;
+}
+function _runEffect(e) {
+  if (e.disposed) return;
+  if (e._stable) {
+    if (e._cleanup) {
+      try {
+        e._cleanup();
+      } catch (err) {
+        if (__DEV__) console.warn("[what] Error in effect cleanup:", err);
+      }
+      e._cleanup = null;
+    }
+    const prev2 = currentEffect;
+    currentEffect = null;
+    try {
+      const result = e.fn();
+      if (typeof result === "function") e._cleanup = result;
+    } catch (err) {
+      if (__devtools?.onError) __devtools.onError(err, { type: "effect", effect: e });
+      if (__DEV__) console.warn("[what] Error in stable effect:", err);
+    } finally {
+      currentEffect = prev2;
+    }
+    if (__DEV__ && __devtools?.onEffectRun) __devtools.onEffectRun(e);
+    return;
+  }
+  const singleDep = e.deps.length === 1 ? e.deps[0] : null;
+  cleanup(e);
+  if (e._cleanup) {
+    try {
+      e._cleanup();
+    } catch (err) {
+      if (__DEV__ && __devtools?.onError) __devtools.onError(err, { type: "effect-cleanup", effect: e });
+      if (__DEV__) console.warn("[what] Error in effect cleanup:", err);
+    }
+    e._cleanup = null;
+  }
+  const prev = currentEffect;
+  currentEffect = e;
+  try {
+    const result = e.fn();
+    if (typeof result === "function") {
+      e._cleanup = result;
+    }
+  } catch (err) {
+    if (err === NEEDS_UPSTREAM) throw err;
+    if (__DEV__ && __devtools?.onError) __devtools.onError(err, { type: "effect", effect: e });
+    throw err;
+  } finally {
+    currentEffect = prev;
+  }
+  if (singleDep !== null && e.deps.length === 1 && e.deps[0] === singleDep && !e._cleanup && !e._pending) {
+    e._stable = true;
+  }
+  if (__DEV__ && __devtools?.onEffectRun) __devtools.onEffectRun(e);
+}
+function _disposeEffect(e) {
+  e.disposed = true;
+  if (__DEV__ && __devtools) __devtools.onEffectDispose(e);
+  cleanup(e);
+  if (e._cleanup) {
+    try {
+      e._cleanup();
+    } catch (err) {
+      if (__DEV__) console.warn("[what] Error in effect cleanup on dispose:", err);
+    }
+    e._cleanup = null;
+  }
+}
+function cleanup(e) {
+  const deps = e.deps;
+  for (let i = 0; i < deps.length; i++) deps[i].delete(e);
+  deps.length = 0;
+  e._epoch++;
+}
+var notifyDepth = 0;
+var notifyQueue = null;
+var notifyQueueLen = 0;
+function _processSubscriber(e) {
+  if (e.disposed) return;
+  if (e._onNotify) {
+    e._onNotify();
+  } else if (!e._pending) {
+    if (batchDepth === 0 && e._stable) {
+      const prev = currentEffect;
+      currentEffect = null;
+      try {
+        const result = e.fn();
+        if (typeof result === "function") {
+          if (e._cleanup) try {
+            e._cleanup();
+          } catch (err) {
+          }
+          e._cleanup = result;
+        }
+      } catch (err) {
+        if (__DEV__ && __devtools?.onError) __devtools.onError(err, { type: "effect", effect: e });
+        if (__DEV__) console.warn("[what] Error in stable effect:", err);
+      } finally {
+        currentEffect = prev;
+      }
+    } else {
+      e._pending = true;
+      const level = e._level;
+      const len = pendingEffects.length;
+      if (len > 0 && pendingEffects[len - 1]._level > level) {
+        pendingNeedSort = true;
+      }
+      pendingEffects.push(e);
+    }
+  }
+}
+function notify(subs) {
+  if (notifyDepth === 0) {
+    notifyDepth = 1;
+    try {
+      for (const e of subs) {
+        _processSubscriber(e);
+      }
+      if (notifyQueueLen > 0) {
+        let qi = 0;
+        while (qi < notifyQueueLen) {
+          const queuedSubs = notifyQueue[qi];
+          notifyQueue[qi] = null;
+          qi++;
+          for (const e of queuedSubs) {
+            _processSubscriber(e);
+          }
+        }
+        notifyQueueLen = 0;
+      }
+    } finally {
+      notifyDepth = 0;
+    }
+    if (batchDepth === 0 && pendingEffects.length > 0) scheduleMicrotask();
+  } else {
+    if (notifyQueue === null) notifyQueue = [];
+    if (notifyQueueLen >= notifyQueue.length) {
+      notifyQueue.push(subs);
+    } else {
+      notifyQueue[notifyQueueLen] = subs;
+    }
+    notifyQueueLen++;
+  }
+}
+var microtaskScheduled = false;
+function scheduleMicrotask() {
+  if (!microtaskScheduled) {
+    microtaskScheduled = true;
+    queueMicrotask(() => {
+      microtaskScheduled = false;
+      flush();
+    });
+  }
+}
+var isFlushing = false;
+function flush() {
+  if (isFlushing) return;
+  isFlushing = true;
+  try {
+    let iterations = 0;
+    while (pendingEffects.length > 0 && iterations < 25) {
+      const batch2 = pendingEffects;
+      pendingEffects = [];
+      if (batch2.length > 1 && pendingNeedSort) {
+        batch2.sort((a, b) => a._level - b._level);
+      }
+      pendingNeedSort = false;
+      for (let i = 0; i < batch2.length; i++) {
+        const e = batch2[i];
+        e._pending = false;
+        if (!e.disposed && !e._onNotify) {
+          const prevDepsLen = e.deps.length;
+          try {
+            _runEffect(e);
+          } catch (err) {
+            if (err === NEEDS_UPSTREAM) throw err;
+            if (__DEV__ && __devtools?.onError) __devtools.onError(err, { type: "effect", effect: e });
+            try {
+              console.error("[what] Uncaught error in effect during update:", err);
+            } catch {
+            }
+            continue;
+          }
+          if (!e._computed && e.deps.length !== prevDepsLen) {
+            _updateLevel(e);
+          }
+        }
+      }
+      iterations++;
+    }
+    if (iterations >= 25) {
+      if (__DEV__) {
+        const remaining = pendingEffects.slice(0, 3);
+        const effectNames = remaining.map((e) => e.fn?.name || e.fn?.toString().slice(0, 60) || "(anonymous)");
+        console.warn(
+          `[what] Possible infinite effect loop detected (25 iterations). Likely cause: an effect writes to a signal it also reads, creating a cycle. Use untrack() to read signals without subscribing. Looping effects: ${effectNames.join(", ")}`
+        );
+      } else {
+        console.warn("[what] Possible infinite effect loop detected");
+      }
+      for (let i = 0; i < pendingEffects.length; i++) pendingEffects[i]._pending = false;
+      pendingEffects.length = 0;
+    }
+  } finally {
+    isFlushing = false;
+  }
+}
+function memo(fn) {
+  let value;
+  const subs = /* @__PURE__ */ new Set();
+  const e = _createEffect(() => {
+    const next = fn();
+    if (!Object.is(value, next)) {
+      value = next;
+      for (const sub of subs) {
+        if (sub.disposed) continue;
+        if (sub._onNotify) {
+          sub._onNotify();
+        } else if (!sub._pending) {
+          sub._pending = true;
+          const level = sub._level;
+          const len = pendingEffects.length;
+          if (len > 0 && pendingEffects[len - 1]._level > level) {
+            pendingNeedSort = true;
+          }
+          pendingEffects.push(sub);
+        }
+      }
+    }
+  });
+  e._level = 1;
+  _runEffect(e);
+  _updateLevel(e);
+  subs._owner = e;
+  if (currentRoot) {
+    currentRoot.disposals.push(() => _disposeEffect(e));
+  }
+  function read() {
+    if (currentEffect) {
+      subs.add(currentEffect);
+      currentEffect.deps.push(subs);
+    }
+    return value;
+  }
+  read._signal = true;
+  read.peek = () => value;
+  return read;
+}
+function flushSync() {
+  if (isFlushing) {
+    if (__DEV__) {
+      console.warn(
+        "[what] flushSync() called during an active flush (e.g., inside a component render or effect). This is a no-op to prevent infinite loops. Move flushSync() to an event handler or onMount callback."
+      );
+    }
+    return;
+  }
+  if (currentEffect) {
+    if (__DEV__) {
+      console.warn(
+        "[what] flushSync() called during effect execution. This is a no-op to prevent infinite loops. Move flushSync() to an event handler or onMount callback."
+      );
+    }
+    return;
+  }
+  microtaskScheduled = false;
+  flush();
+}
+function untrack(fn) {
+  const prev = currentEffect;
+  currentEffect = null;
+  try {
+    return fn();
+  } finally {
+    currentEffect = prev;
+  }
+}
+function getOwner() {
+  return currentOwner;
+}
+function runWithOwner(owner, fn) {
+  const prev = currentOwner;
+  const prevRoot = currentRoot;
+  currentOwner = owner;
+  currentRoot = owner;
+  try {
+    return fn();
+  } finally {
+    currentOwner = prev;
+    currentRoot = prevRoot;
+  }
+}
+function createRoot(fn) {
+  const prevRoot = currentRoot;
+  const prevOwner = currentOwner;
+  const root = {
+    disposals: [],
+    owner: currentOwner,
+    // parent owner for ownership tree
+    children: [],
+    // child roots (ownership tree)
+    _disposed: false
+  };
+  if (currentOwner) {
+    currentOwner.children.push(root);
+  }
+  currentRoot = root;
+  currentOwner = root;
+  try {
+    const dispose = () => {
+      if (root._disposed) return;
+      root._disposed = true;
+      for (let i = root.children.length - 1; i >= 0; i--) {
+        _disposeRoot(root.children[i]);
+      }
+      root.children.length = 0;
+      for (let i = root.disposals.length - 1; i >= 0; i--) {
+        root.disposals[i]();
+      }
+      root.disposals.length = 0;
+      if (root.owner) {
+        const idx = root.owner.children.indexOf(root);
+        if (idx >= 0) root.owner.children.splice(idx, 1);
+      }
+    };
+    return fn(dispose);
+  } finally {
+    currentRoot = prevRoot;
+    currentOwner = prevOwner;
+  }
+}
+function _disposeRoot(root) {
+  if (root._disposed) return;
+  root._disposed = true;
+  for (let i = root.children.length - 1; i >= 0; i--) {
+    _disposeRoot(root.children[i]);
+  }
+  root.children.length = 0;
+  for (let i = root.disposals.length - 1; i >= 0; i--) {
+    root.disposals[i]();
+  }
+  root.disposals.length = 0;
+}
+function _createItemScope(fn) {
+  const prevRoot = currentRoot;
+  const prevOwner = currentOwner;
+  const scope = {
+    disposals: [],
+    owner: null,
+    // No parent registration
+    children: [],
+    // Kept for compat with effects that create sub-roots
+    _disposed: false
+  };
+  currentRoot = scope;
+  currentOwner = scope;
+  try {
+    const dispose = () => {
+      if (scope._disposed) return;
+      scope._disposed = true;
+      for (let i = scope.children.length - 1; i >= 0; i--) {
+        _disposeRoot(scope.children[i]);
+      }
+      scope.children.length = 0;
+      for (let i = scope.disposals.length - 1; i >= 0; i--) {
+        scope.disposals[i]();
+      }
+      scope.disposals.length = 0;
+    };
+    return fn(dispose);
+  } finally {
+    currentRoot = prevRoot;
+    currentOwner = prevOwner;
+  }
+}
+function onCleanup(fn) {
+  if (currentRoot) {
+    currentRoot.disposals.push(fn);
+  }
+}
+if (__DEV__ && typeof WeakRef !== "undefined") {
+  const PREINSTALL_CAP = 2e3;
+  const buffer = { signals: /* @__PURE__ */ new Set(), effects: /* @__PURE__ */ new Set(), components: [] };
+  __devtools = {
+    __isPreinstallBuffer: true,
+    onSignalCreate(sig) {
+      if (buffer.signals.size < PREINSTALL_CAP) buffer.signals.add(new WeakRef(sig));
+    },
+    onSignalUpdate() {
+    },
+    onEffectCreate(e) {
+      if (buffer.effects.size < PREINSTALL_CAP) buffer.effects.add(new WeakRef(e));
+    },
+    onEffectDispose() {
+    },
+    onEffectRun() {
+    },
+    onError() {
+    },
+    onComponentMount(ctx) {
+      if (buffer.components.length < PREINSTALL_CAP) buffer.components.push(ctx);
+    },
+    onComponentUnmount() {
+    },
+    __buffer: buffer
+  };
+}
+function __drainPreinstallBuffer() {
+  if (!__DEV__) return { signals: [], effects: [], components: [] };
+  const out = { signals: [], effects: [], components: [] };
+  const buf = typeof __preinstallSnapshot !== "undefined" ? __preinstallSnapshot : null;
+  if (!buf) return out;
+  for (const ref of buf.signals) {
+    const v = ref.deref?.();
+    if (v) out.signals.push(v);
+  }
+  for (const ref of buf.effects) {
+    const v = ref.deref?.();
+    if (v) out.effects.push(v);
+  }
+  for (const ctx of buf.components) out.components.push(ctx);
+  return out;
+}
+var __preinstallSnapshot = null;
+if (__DEV__ && __devtools?.__isPreinstallBuffer) {
+  __preinstallSnapshot = __devtools.__buffer;
+}
+
+// packages/core/src/components.js
+function memo2(Component, _areEqual) {
+  const MemoWrapper = function MemoWrapper2(props) {
+    return Component(props);
+  };
+  MemoWrapper.displayName = `Memo(${Component.name || "Anonymous"})`;
+  return MemoWrapper;
+}
+var _getCurrentComponent = null;
+function _injectGetCurrentComponent(fn) {
+  _getCurrentComponent = fn;
+}
+function lazy(loader) {
+  let Component = null;
+  let loadPromise = null;
+  let loadError = null;
+  const listeners = /* @__PURE__ */ new Set();
+  function LazyWrapper(props) {
+    if (loadError) throw loadError;
+    if (Component) return h(Component, props);
+    if (!loadPromise) {
+      loadPromise = loader().then((mod) => {
+        Component = mod.default || mod;
+        listeners.forEach((fn) => fn());
+        listeners.clear();
+      }).catch((err) => {
+        loadError = err;
+      });
+    }
+    throw loadPromise;
+  }
+  LazyWrapper.displayName = "Lazy";
+  LazyWrapper._lazy = true;
+  LazyWrapper._onLoad = (fn) => {
+    if (Component) fn();
+    else listeners.add(fn);
+  };
+  return LazyWrapper;
+}
+function Suspense({ fallback, children }) {
+  const loading = signal(false);
+  const pendingPromises = /* @__PURE__ */ new Set();
+  const boundary = {
+    _suspense: true,
+    onSuspend(promise) {
+      loading.set(true);
+      pendingPromises.add(promise);
+      promise.finally(() => {
+        pendingPromises.delete(promise);
+        if (pendingPromises.size === 0) {
+          loading.set(false);
+        }
+      });
+    }
+  };
+  return {
+    tag: "__suspense",
+    props: { boundary, fallback, loading },
+    children: Array.isArray(children) ? children : [children],
+    _vnode: true
+  };
+}
+function ErrorBoundary({ fallback, children, onError }) {
+  const errorState = signal(null);
+  const handleError = (error) => {
+    errorState.set(error);
+    if (onError) {
+      try {
+        onError(error);
+      } catch (e) {
+        console.error("Error in onError handler:", e);
+      }
+    }
+  };
+  const reset = () => errorState.set(null);
+  return {
+    tag: "__errorBoundary",
+    props: { errorState, handleError, fallback, reset },
+    children: Array.isArray(children) ? children : [children],
+    _vnode: true
+  };
+}
+function reportError(error, startCtx) {
+  let ctx = startCtx || _getCurrentComponent?.();
+  while (ctx) {
+    if (ctx._errorBoundary) {
+      ctx._errorBoundary(error);
+      return true;
+    }
+    ctx = ctx._parentCtx;
+  }
+  return false;
+}
+function Show({ when, fallback = null, children }) {
+  const condition = typeof when === "function" ? when() : when;
+  return condition ? children : fallback;
+}
+function For({ each: each2, fallback = null, children }) {
+  const list = typeof each2 === "function" ? each2() : each2;
+  if (!list || list.length === 0) return fallback;
+  const renderFn = Array.isArray(children) ? children[0] : children;
+  if (typeof renderFn !== "function") {
+    console.warn("[what] For: children must be a render function, e.g. <For each={items}>{(item) => ...}</For>");
+    return fallback;
+  }
+  return list.map((item, index) => {
+    const vnode = renderFn(item, index);
+    if (vnode && typeof vnode === "object" && vnode.key == null) {
+      if (item != null && typeof item === "object") {
+        if (item.id != null) vnode.key = item.id;
+        else if (item.key != null) vnode.key = item.key;
+      } else if (typeof item === "string" || typeof item === "number") {
+        vnode.key = item;
+      }
+    }
+    return vnode;
+  });
+}
+function Switch({ fallback = null, children }) {
+  const kids = Array.isArray(children) ? children : [children];
+  for (const child of kids) {
+    if (child && child.tag === Match) {
+      const condition = typeof child.props.when === "function" ? child.props.when() : child.props.when;
+      if (condition) {
+        return child.children;
+      }
+    }
+  }
+  return fallback;
+}
+function Match({ when, children }) {
+  return { tag: Match, props: { when }, children, _vnode: true };
+}
+function Island({ component: Component, mode, mediaQuery, ...props }) {
+  const placeholder = h("div", { "data-island": Component.name || "Island", "data-hydrate": mode });
+  const wrapper = signal(null);
+  const hydrated = signal(false);
+  function doHydrate() {
+    if (hydrated()) return;
+    hydrated.set(true);
+    wrapper.set(h(Component, props));
+  }
+  function scheduleHydration(el) {
+    switch (mode) {
+      case "load":
+        queueMicrotask(doHydrate);
+        break;
+      case "idle":
+        if (typeof requestIdleCallback !== "undefined") {
+          requestIdleCallback(doHydrate);
+        } else {
+          setTimeout(doHydrate, 200);
+        }
+        break;
+      case "visible": {
+        const observer = new IntersectionObserver((entries) => {
+          if (entries[0].isIntersecting) {
+            observer.disconnect();
+            doHydrate();
+          }
+        });
+        observer.observe(el);
+        break;
+      }
+      case "interaction": {
+        const hydrate = () => {
+          el.removeEventListener("click", hydrate);
+          el.removeEventListener("focus", hydrate);
+          el.removeEventListener("mouseenter", hydrate);
+          doHydrate();
+        };
+        el.addEventListener("click", hydrate, { once: true });
+        el.addEventListener("focus", hydrate, { once: true });
+        el.addEventListener("mouseenter", hydrate, { once: true });
+        break;
+      }
+      case "media": {
+        if (!mediaQuery) {
+          doHydrate();
+          break;
+        }
+        const mq = window.matchMedia(mediaQuery);
+        if (mq.matches) {
+          queueMicrotask(doHydrate);
+        } else {
+          const checkMedia = () => {
+            if (mq.matches) {
+              mq.removeEventListener("change", checkMedia);
+              doHydrate();
+            }
+          };
+          mq.addEventListener("change", checkMedia);
+        }
+        break;
+      }
+      default:
+        queueMicrotask(doHydrate);
+    }
+  }
+  const refCallback = (el) => {
+    if (el) scheduleHydration(el);
+  };
+  return h(
+    "div",
+    { "data-island": Component.name || "Island", "data-hydrate": mode, ref: refCallback },
+    hydrated() ? wrapper() : null
+  );
+}
+
+// packages/core/src/helpers.js
+var _eachWarned = false;
+function each(list, fn, keyFn) {
+  if (!_eachWarned) {
+    _eachWarned = true;
+    console.warn("[what] each() is deprecated. Use the <For> component or Array.map() instead.");
+  }
+  if (!list || list.length === 0) return [];
+  return list.map((item, index) => {
+    const vnode = fn(item, index);
+    if (keyFn && vnode && typeof vnode === "object") {
+      vnode.key = keyFn(item, index);
+    }
+    return vnode;
+  });
+}
+function cls(...args) {
+  const classes = [];
+  for (const arg of args) {
+    if (!arg) continue;
+    if (typeof arg === "string") {
+      classes.push(arg);
+    } else if (typeof arg === "object") {
+      for (const [key, val] of Object.entries(arg)) {
+        if (val) classes.push(key);
+      }
+    }
+  }
+  return classes.join(" ");
+}
+function style(obj) {
+  if (typeof obj === "string") return obj;
+  return Object.entries(obj).filter(([, v]) => v != null && v !== "").map(([k, v]) => `${camelToKebab(k)}:${v}`).join(";");
+}
+function camelToKebab(str) {
+  return str.replace(/([A-Z])/g, "-$1").toLowerCase();
+}
+function debounce(fn, ms) {
+  let timer;
+  return (...args) => {
+    clearTimeout(timer);
+    timer = setTimeout(() => fn(...args), ms);
+  };
+}
+function throttle(fn, ms) {
+  let last = 0;
+  return (...args) => {
+    const now = Date.now();
+    if (now - last >= ms) {
+      last = now;
+      fn(...args);
+    }
+  };
+}
+var _getCurrentComponentRef = null;
+function _setComponentRef(fn) {
+  _getCurrentComponentRef = fn;
+}
+function useMediaQuery(query) {
+  if (typeof window === "undefined") return signal(false);
+  const mq = window.matchMedia(query);
+  const s = signal(mq.matches);
+  const handler = (e) => s.set(e.matches);
+  mq.addEventListener("change", handler);
+  const ctx = _getCurrentComponentRef?.();
+  if (ctx) {
+    ctx._cleanupCallbacks = ctx._cleanupCallbacks || [];
+    ctx._cleanupCallbacks.push(() => mq.removeEventListener("change", handler));
+  }
+  return s;
+}
+function useLocalStorage(key, initial) {
+  let stored;
+  try {
+    const raw = localStorage.getItem(key);
+    stored = raw !== null ? JSON.parse(raw) : initial;
+  } catch {
+    stored = initial;
+  }
+  const s = signal(stored);
+  const dispose = effect(() => {
+    try {
+      localStorage.setItem(key, JSON.stringify(s()));
+    } catch (e) {
+      if (__DEV__) console.warn("[what] localStorage write failed (quota exceeded?):", e);
+    }
+  });
+  let storageHandler = null;
+  if (typeof window !== "undefined") {
+    storageHandler = (e) => {
+      if (e.key === key && e.newValue !== null) {
+        try {
+          s.set(JSON.parse(e.newValue));
+        } catch (err) {
+          if (__DEV__) console.warn("[what] localStorage parse failed:", err);
+        }
+      }
+    };
+    window.addEventListener("storage", storageHandler);
+  }
+  const ctx = _getCurrentComponentRef?.();
+  if (ctx) {
+    ctx._cleanupCallbacks = ctx._cleanupCallbacks || [];
+    ctx._cleanupCallbacks.push(() => {
+      dispose();
+      if (storageHandler) window.removeEventListener("storage", storageHandler);
+    });
+  }
+  return s;
+}
+function Portal({ target, children }) {
+  if (typeof document === "undefined") return null;
+  const container = typeof target === "string" ? document.querySelector(target) : target;
+  if (!container) return null;
+  return { tag: "__portal", props: { container }, children: Array.isArray(children) ? children : [children], _vnode: true };
+}
+function useClickOutside(ref, handler) {
+  if (typeof document === "undefined") return;
+  const listener = (e) => {
+    const el = ref.current || ref;
+    if (!el || el.contains(e.target)) return;
+    handler(e);
+  };
+  document.addEventListener("mousedown", listener);
+  document.addEventListener("touchstart", listener);
+  const ctx = _getCurrentComponentRef?.();
+  if (ctx) {
+    ctx._cleanupCallbacks = ctx._cleanupCallbacks || [];
+    ctx._cleanupCallbacks.push(() => {
+      document.removeEventListener("mousedown", listener);
+      document.removeEventListener("touchstart", listener);
+    });
+  }
+}
+function transition(name, active) {
+  return {
+    class: active ? `${name}-enter ${name}-enter-active` : `${name}-leave ${name}-leave-active`
+  };
+}
+
+// packages/core/src/dom.js
+var SVG_ELEMENTS = /* @__PURE__ */ new Set([
+  "svg",
+  "path",
+  "circle",
+  "rect",
+  "line",
+  "polyline",
+  "polygon",
+  "ellipse",
+  "g",
+  "defs",
+  "use",
+  "symbol",
+  "clipPath",
+  "mask",
+  "pattern",
+  "image",
+  "text",
+  "tspan",
+  "textPath",
+  "foreignObject",
+  "linearGradient",
+  "radialGradient",
+  "stop",
+  "marker",
+  "animate",
+  "animateTransform",
+  "animateMotion",
+  "set",
+  "filter",
+  "feBlend",
+  "feColorMatrix",
+  "feComponentTransfer",
+  "feComposite",
+  "feConvolveMatrix",
+  "feDiffuseLighting",
+  "feDisplacementMap",
+  "feFlood",
+  "feGaussianBlur",
+  "feImage",
+  "feMerge",
+  "feMergeNode",
+  "feMorphology",
+  "feOffset",
+  "feSpecularLighting",
+  "feTile",
+  "feTurbulence"
+]);
+var SVG_NS = "http://www.w3.org/2000/svg";
+var mountedComponents = /* @__PURE__ */ new Set();
+var _commentCtxMap = /* @__PURE__ */ new WeakMap();
+function isDomNode(value) {
+  if (!value || typeof value !== "object") return false;
+  if (typeof Node !== "undefined" && value instanceof Node) return true;
+  return typeof value.nodeType === "number" && typeof value.nodeName === "string";
+}
+function isVNode(value) {
+  return !!value && typeof value === "object" && (value._vnode === true || "tag" in value);
+}
+function disposeComponent(ctx) {
+  if (ctx.disposed) return;
+  ctx.disposed = true;
+  if (ctx.cleanups) {
+    for (const cleanup2 of ctx.cleanups) {
+      try {
+        cleanup2();
+      } catch (e) {
+        console.error("[what] cleanup error:", e);
+      }
+    }
+  }
+  if (ctx.effects) {
+    for (const dispose of ctx.effects) {
+      try {
+        dispose();
+      } catch (e) {
+      }
+    }
+  }
+  if (ctx.hooks) {
+    for (const hook of ctx.hooks) {
+      if (hook && typeof hook.cleanup === "function") {
+        try {
+          hook.cleanup();
+        } catch (e) {
+          console.error("[what] hook cleanup error:", e);
+        }
+      }
+    }
+  }
+  if (ctx._cleanupCallbacks) {
+    for (const fn of ctx._cleanupCallbacks) {
+      try {
+        fn();
+      } catch (e) {
+        console.error("[what] onCleanup error:", e);
+      }
+    }
+  }
+  if (__DEV__ && __devtools?.onComponentUnmount) __devtools.onComponentUnmount(ctx);
+  mountedComponents.delete(ctx);
+}
+function disposeTree(node) {
+  if (!node) return;
+  if (node._componentCtx) {
+    disposeComponent(node._componentCtx);
+  }
+  if (node.nodeType === 8) {
+    const commentCtx = _commentCtxMap.get(node);
+    if (commentCtx) {
+      disposeComponent(commentCtx);
+    }
+  }
+  if (node._dispose) {
+    try {
+      node._dispose();
+    } catch (e) {
+    }
+  }
+  if (node._propEffects) {
+    for (const key in node._propEffects) {
+      try {
+        node._propEffects[key]();
+      } catch (e) {
+      }
+    }
+  }
+  const children = node.childNodes;
+  if (children && children.length > 0) {
+    for (let i = 0; i < children.length; i++) {
+      disposeTree(children[i]);
+    }
+  }
+}
+function mount(vnode, container) {
+  if (typeof container === "string") {
+    container = document.querySelector(container);
+  }
+  disposeTree(container);
+  container.textContent = "";
+  const node = createDOM(vnode, container);
+  if (node) container.appendChild(node);
+  return () => {
+    disposeTree(container);
+    container.textContent = "";
+  };
+}
+function createDOM(vnode, parent, isSvg) {
+  if (vnode == null || vnode === false || vnode === true) {
+    return document.createComment("");
+  }
+  if (typeof vnode === "string" || typeof vnode === "number") {
+    return document.createTextNode(String(vnode));
+  }
+  if (isDomNode(vnode)) {
+    return vnode;
+  }
+  if (typeof vnode === "function" && vnode._mapArray) {
+    const frag = document.createDocumentFragment();
+    const endMarker = document.createComment("/list-frag");
+    frag.appendChild(endMarker);
+    vnode(frag, endMarker);
+    return frag;
+  }
+  if (typeof vnode === "function") {
+    const startMarker = document.createComment("fn");
+    const endMarker = document.createComment("/fn");
+    let currentNodes = [];
+    const frag = document.createDocumentFragment();
+    frag.appendChild(startMarker);
+    frag.appendChild(endMarker);
+    const dispose = effect(() => {
+      const val = vnode();
+      const vnodes = val == null || val === false || val === true ? [] : Array.isArray(val) ? val : [val];
+      const realParent = endMarker.parentNode;
+      if (!realParent) return;
+      for (const old of currentNodes) {
+        disposeTree(old);
+        if (old.parentNode === realParent) realParent.removeChild(old);
+      }
+      currentNodes = [];
+      for (const v of vnodes) {
+        const node = createDOM(v, realParent, parent?._isSvg);
+        if (node) {
+          if (node.nodeType === 11) {
+            const children = Array.from(node.childNodes);
+            realParent.insertBefore(node, endMarker);
+            for (const child of children) currentNodes.push(child);
+          } else {
+            realParent.insertBefore(node, endMarker);
+            currentNodes.push(node);
+          }
+        }
+      }
+    });
+    startMarker._dispose = dispose;
+    endMarker._dispose = dispose;
+    return frag;
+  }
+  if (Array.isArray(vnode)) {
+    const frag = document.createDocumentFragment();
+    for (const child of vnode) {
+      const node = createDOM(child, parent, isSvg);
+      if (node) frag.appendChild(node);
+    }
+    return frag;
+  }
+  if (isVNode(vnode) && typeof vnode.tag === "function") {
+    return createComponent(vnode, parent, isSvg);
+  }
+  if (isVNode(vnode) && typeof vnode.tag === "string") {
+    if (vnode.tag === "__errorBoundary") return createErrorBoundary(vnode, parent);
+    if (vnode.tag === "__suspense") return createSuspenseBoundary(vnode, parent);
+    if (vnode.tag === "__portal") return createPortalDOM(vnode, parent);
+    return createElementFromVNode(vnode, parent, isSvg);
+  }
+  return document.createTextNode(String(vnode));
+}
+var _propsProxyHandler = {
+  get(target, key) {
+    if (key === "_sig") return void 0;
+    if (key === "__proto__" || key === "constructor" || key === "prototype") return void 0;
+    return target._sig()[key];
+  },
+  has(target, key) {
+    if (key === "_sig") return false;
+    return key in target._sig();
+  },
+  ownKeys(target) {
+    return Reflect.ownKeys(target._sig());
+  },
+  getOwnPropertyDescriptor(target, key) {
+    if (key === "_sig") return void 0;
+    const current = target._sig();
+    if (key in current) {
+      return { value: current[key], writable: false, enumerable: true, configurable: true };
+    }
+    return void 0;
+  },
+  set(target, key) {
+    return false;
+  }
+};
+var componentStack = [];
+function getCurrentComponent() {
+  return componentStack[componentStack.length - 1];
+}
+_injectGetCurrentComponent(getCurrentComponent);
+_setComponentRef(getCurrentComponent);
+function getComponentStack() {
+  return componentStack;
+}
+function createComponent(vnode, parent, isSvg) {
+  let { tag: Component, props, children } = vnode;
+  if (typeof Component === "function" && (Component.prototype?.isReactComponent || Component.prototype?.render)) {
+    const ClassComp = Component;
+    Component = function ClassComponentBridge(props2) {
+      const instance = new ClassComp(props2);
+      return instance.render();
+    };
+    Component.displayName = ClassComp.displayName || ClassComp.name || "ClassComponent";
+  }
+  if (Component === "__errorBoundary" || vnode.tag === "__errorBoundary") {
+    return createErrorBoundary(vnode, parent);
+  }
+  if (Component === "__suspense" || vnode.tag === "__suspense") {
+    return createSuspenseBoundary(vnode, parent);
+  }
+  if (Component === "__portal" || vnode.tag === "__portal") {
+    return createPortalDOM(vnode, parent);
+  }
+  const parentCtx = componentStack[componentStack.length - 1] || null;
+  let errorBoundary = null;
+  if (parentCtx) {
+    errorBoundary = parentCtx._errorBoundary || null;
+    if (!errorBoundary) {
+      let p = parentCtx._parentCtx;
+      while (p) {
+        if (p._errorBoundary) {
+          errorBoundary = p._errorBoundary;
+          break;
+        }
+        p = p._parentCtx;
+      }
+    }
+  }
+  const ctx = {
+    hooks: [],
+    hookIndex: 0,
+    effects: [],
+    cleanups: [],
+    mounted: false,
+    disposed: false,
+    Component,
+    _parentCtx: parentCtx,
+    _errorBoundary: errorBoundary
+  };
+  const startComment = document.createComment("c:start");
+  const endComment = document.createComment("c:end");
+  _commentCtxMap.set(startComment, ctx);
+  ctx._startComment = startComment;
+  ctx._endComment = endComment;
+  const container = document.createDocumentFragment();
+  container._componentCtx = ctx;
+  ctx._wrapper = startComment;
+  mountedComponents.add(ctx);
+  if (__DEV__ && __devtools?.onComponentMount) __devtools.onComponentMount(ctx);
+  const propsChildren = children.length === 0 ? void 0 : children.length === 1 ? children[0] : children;
+  let mergedProps;
+  if (propsChildren !== void 0) {
+    mergedProps = props ? Object.assign({}, props, { children: propsChildren }) : { children: propsChildren };
+  } else {
+    mergedProps = props ? Object.assign({}, props) : {};
+  }
+  const propsSignal = signal(mergedProps);
+  ctx._propsSignal = propsSignal;
+  const reactiveProps = new Proxy({ _sig: propsSignal }, _propsProxyHandler);
+  componentStack.push(ctx);
+  let result;
+  try {
+    result = untrack(() => Component(reactiveProps));
+  } catch (error) {
+    componentStack.pop();
+    if (!reportError(error, ctx)) {
+      console.error("[what] Uncaught error in component:", Component.name || "Anonymous", error);
+      throw error;
+    }
+    container.appendChild(startComment);
+    container.appendChild(endComment);
+    return container;
+  }
+  componentStack.pop();
+  ctx.mounted = true;
+  if (ctx._mountCallbacks) {
+    queueMicrotask(() => {
+      if (ctx.disposed) return;
+      for (const fn of ctx._mountCallbacks) {
+        try {
+          fn();
+        } catch (e) {
+          console.error("[what] onMount error:", e);
+        }
+      }
+    });
+  }
+  container.appendChild(startComment);
+  const vnodes = Array.isArray(result) ? result : [result];
+  for (const v of vnodes) {
+    const node = createDOM(v, container, isSvg);
+    if (node) container.appendChild(node);
+  }
+  container.appendChild(endComment);
+  return container;
+}
+function createErrorBoundary(vnode, parent) {
+  const { errorState, handleError, fallback, reset } = vnode.props;
+  const children = vnode.children;
+  const startComment = document.createComment("eb:start");
+  const endComment = document.createComment("eb:end");
+  const boundaryCtx = {
+    hooks: [],
+    hookIndex: 0,
+    effects: [],
+    cleanups: [],
+    mounted: false,
+    disposed: false,
+    _parentCtx: componentStack[componentStack.length - 1] || null,
+    _errorBoundary: handleError,
+    _startComment: startComment,
+    _endComment: endComment
+  };
+  _commentCtxMap.set(startComment, boundaryCtx);
+  const container = document.createDocumentFragment();
+  container._componentCtx = boundaryCtx;
+  container.appendChild(startComment);
+  container.appendChild(endComment);
+  const dispose = effect(() => {
+    const error = errorState();
+    componentStack.push(boundaryCtx);
+    if (startComment.parentNode) {
+      while (startComment.nextSibling && startComment.nextSibling !== endComment) {
+        const old = startComment.nextSibling;
+        disposeTree(old);
+        old.parentNode.removeChild(old);
+      }
+    }
+    let vnodes;
+    if (error) {
+      vnodes = typeof fallback === "function" ? [fallback({ error, reset })] : [fallback];
+    } else {
+      vnodes = children;
+    }
+    vnodes = Array.isArray(vnodes) ? vnodes : [vnodes];
+    for (const v of vnodes) {
+      const node = createDOM(v, parent);
+      if (node) {
+        if (endComment.parentNode) {
+          endComment.parentNode.insertBefore(node, endComment);
+        } else {
+          container.insertBefore(node, endComment);
+        }
+      }
+    }
+    componentStack.pop();
+  });
+  boundaryCtx.effects.push(dispose);
+  return container;
+}
+function createSuspenseBoundary(vnode, parent) {
+  const { boundary, fallback, loading } = vnode.props;
+  const children = vnode.children;
+  const startComment = document.createComment("sb:start");
+  const endComment = document.createComment("sb:end");
+  const boundaryCtx = {
+    hooks: [],
+    hookIndex: 0,
+    effects: [],
+    cleanups: [],
+    mounted: false,
+    disposed: false,
+    _parentCtx: componentStack[componentStack.length - 1] || null,
+    _startComment: startComment,
+    _endComment: endComment
+  };
+  _commentCtxMap.set(startComment, boundaryCtx);
+  const container = document.createDocumentFragment();
+  container._componentCtx = boundaryCtx;
+  container.appendChild(startComment);
+  container.appendChild(endComment);
+  const dispose = effect(() => {
+    const isLoading = loading();
+    const vnodes = isLoading ? [fallback] : children;
+    const normalized = Array.isArray(vnodes) ? vnodes : [vnodes];
+    componentStack.push(boundaryCtx);
+    if (startComment.parentNode) {
+      while (startComment.nextSibling && startComment.nextSibling !== endComment) {
+        const old = startComment.nextSibling;
+        disposeTree(old);
+        old.parentNode.removeChild(old);
+      }
+    }
+    for (const v of normalized) {
+      const node = createDOM(v, parent);
+      if (node) {
+        if (endComment.parentNode) {
+          endComment.parentNode.insertBefore(node, endComment);
+        } else {
+          container.insertBefore(node, endComment);
+        }
+      }
+    }
+    componentStack.pop();
+  });
+  boundaryCtx.effects.push(dispose);
+  return container;
+}
+function createPortalDOM(vnode, parent) {
+  const { container } = vnode.props;
+  const children = vnode.children;
+  if (!container) {
+    console.warn("[what] Portal: target container not found");
+    return document.createComment("portal:empty");
+  }
+  const portalCtx = {
+    hooks: [],
+    hookIndex: 0,
+    effects: [],
+    cleanups: [],
+    mounted: false,
+    disposed: false,
+    _parentCtx: componentStack[componentStack.length - 1] || null
+  };
+  const placeholder = document.createComment("portal");
+  placeholder._componentCtx = portalCtx;
+  const portalNodes = [];
+  for (const child of children) {
+    const node = createDOM(child, container);
+    if (node) {
+      container.appendChild(node);
+      portalNodes.push(node);
+    }
+  }
+  portalCtx._cleanupCallbacks = [() => {
+    for (const node of portalNodes) {
+      disposeTree(node);
+      if (node.parentNode) node.parentNode.removeChild(node);
+    }
+  }];
+  return placeholder;
+}
+function createElementFromVNode(vnode, parent, isSvg) {
+  const { tag, props, children } = vnode;
+  const svgContext = isSvg || SVG_ELEMENTS.has(tag);
+  const el = svgContext ? document.createElementNS(SVG_NS, tag) : document.createElement(tag);
+  if (props) {
+    applyProps(el, props, {}, svgContext);
+  }
+  const isSvgChildren = svgContext && tag !== "foreignObject";
+  for (let i = 0; i < children.length; i++) {
+    const node = createDOM(children[i], el, isSvgChildren);
+    if (node) el.appendChild(node);
+  }
+  el._vnode = vnode;
+  return el;
+}
+function applyProps(el, newProps, oldProps, isSvg) {
+  if (!newProps) return;
+  for (const key in newProps) {
+    if (key === "key" || key === "children") continue;
+    if (key === "ref") {
+      const ref = newProps.ref;
+      if (typeof ref === "function") ref(el);
+      else if (ref) ref.current = el;
+      continue;
+    }
+    setProp(el, key, newProps[key], isSvg);
+  }
+}
+function _setSelectValue(el, value) {
+  el.value = value;
+  if (el.value !== String(value)) {
+    queueMicrotask(() => {
+      el.value = value;
+    });
+  }
+}
+function setProp(el, key, value, isSvg) {
+  if (typeof value === "function" && !(key.startsWith("on") && key.length > 2) && key !== "ref") {
+    if (!el._propEffects) el._propEffects = {};
+    if (el._propEffects[key]) {
+      try {
+        el._propEffects[key]();
+      } catch (e) {
+      }
+    }
+    el._propEffects[key] = effect(() => {
+      const resolved = value();
+      setProp(el, key, resolved, isSvg);
+    });
+    return;
+  }
+  if (key.startsWith("on") && key.length > 2) {
+    let eventName = key.slice(2);
+    let useCapture = false;
+    if (eventName.endsWith("Capture")) {
+      eventName = eventName.slice(0, -7);
+      useCapture = true;
+    }
+    const event = eventName.toLowerCase();
+    const storageKey = useCapture ? event + "_capture" : event;
+    const old = el._events?.[storageKey];
+    if (old && old._original === value) return;
+    if (old) el.removeEventListener(event, old, useCapture);
+    if (value == null) return;
+    if (!el._events) el._events = {};
+    const wrappedHandler = (e) => {
+      if (!e.nativeEvent) e.nativeEvent = e;
+      return untrack(() => wrappedHandler._handler(e));
+    };
+    wrappedHandler._handler = value;
+    wrappedHandler._original = value;
+    el._events[storageKey] = wrappedHandler;
+    const eventOpts = value._eventOpts;
+    el.addEventListener(event, wrappedHandler, eventOpts || useCapture || void 0);
+    return;
+  }
+  if (key === "className" || key === "class") {
+    if (isSvg) {
+      el.setAttribute("class", value || "");
+    } else {
+      el.className = value || "";
+    }
+    return;
+  }
+  if (key === "style") {
+    if (typeof value === "string") {
+      el.style.cssText = value;
+      el._prevStyle = null;
+    } else if (typeof value === "object") {
+      const oldStyle = el._prevStyle || {};
+      for (const prop in oldStyle) {
+        if (!(prop in value)) el.style[prop] = "";
+      }
+      for (const prop in value) {
+        el.style[prop] = value[prop] ?? "";
+      }
+      el._prevStyle = { ...value };
+    }
+    return;
+  }
+  if (key === "dangerouslySetInnerHTML") {
+    const html = value?.__html ?? "";
+    if (__DEV__ && typeof html === "string" && /(<script|onerror\s*=|onload\s*=|javascript:)/i.test(html)) {
+      console.warn("[what] dangerouslySetInnerHTML contains potential XSS vectors. Ensure content is sanitized.");
+    }
+    el.innerHTML = html;
+    return;
+  }
+  if (key === "innerHTML") {
+    if (value == null) return;
+    if (value && typeof value === "object" && "__html" in value) {
+      const html = value.__html ?? "";
+      if (__DEV__ && typeof html === "string" && /(<script|onerror\s*=|onload\s*=|javascript:)/i.test(html)) {
+        console.warn("[what] dangerouslySetInnerHTML contains potential XSS vectors. Ensure content is sanitized.");
+      }
+      el.innerHTML = html;
+    } else {
+      if (__DEV__) {
+        console.warn(
+          "[what] innerHTML received a raw string. This is a security risk (XSS). Use innerHTML={{ __html: trustedString }} or dangerouslySetInnerHTML={{ __html: trustedString }} instead."
+        );
+      }
+      return;
+    }
+    return;
+  }
+  if (typeof value === "boolean") {
+    if (value) el.setAttribute(key, "");
+    else el.removeAttribute(key);
+    return;
+  }
+  if (key.startsWith("data-") || key.startsWith("aria-")) {
+    el.setAttribute(key, value);
+    return;
+  }
+  if (isSvg) {
+    if (value === false || value == null) {
+      el.removeAttribute(key);
+    } else {
+      el.setAttribute(key, value === true ? "" : String(value));
+    }
+    return;
+  }
+  if (key === "value" && el.tagName === "SELECT") {
+    _setSelectValue(el, value);
+    return;
+  }
+  if (key in el) {
+    el[key] = value;
+  } else {
+    el.setAttribute(key, value);
+  }
+}
+
+export {
+  __DEV__,
+  __setDevToolsHooks,
+  signal,
+  computed,
+  effect,
+  batch,
+  memo,
+  flushSync,
+  untrack,
+  getOwner,
+  runWithOwner,
+  createRoot,
+  _createItemScope,
+  onCleanup,
+  __drainPreinstallBuffer,
+  memo2,
+  lazy,
+  Suspense,
+  ErrorBoundary,
+  Show,
+  For,
+  Switch,
+  Match,
+  Island,
+  each,
+  cls,
+  style,
+  debounce,
+  throttle,
+  useMediaQuery,
+  useLocalStorage,
+  Portal,
+  useClickOutside,
+  transition,
+  disposeTree,
+  mount,
+  createDOM,
+  getCurrentComponent,
+  getComponentStack,
+  _setSelectValue
+};
+//# sourceMappingURL=chunk-GZRA4IAJ.js.map