@fynixorg/ui 1.0.11 → 1.0.12

package/dist/runtime.js

@@ -1,869 +1,882 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { activeContext, setActiveContext } from "./context/context";
+import { Button, Path } from "./custom/index";
 import { removeErrorOverlay, showErrorOverlay } from "./error/errorOverlay";
-import { setActiveContext, activeContext } from "./context/context.js";
-import { nixStore } from "./hooks/nixStore";
-import { nixState } from "./hooks/nixState";
-import { nixEffect } from "./hooks/nixEffect";
 import { nixAsync } from "./hooks/nixAsync";
-import { nixMemo } from "./hooks/nixMemo";
-import { nixCallback } from "./hooks/nixCallback";
-import { nixComputed } from "./hooks/nixComputed";
-import { nixDebounce } from "./hooks/nixDebounce";
-import { nixInterval } from "./hooks/nixInterval";
-import { nixRef } from "./hooks/nixRef";
-import { nixLocalStorage } from "./hooks/nixLocalStorage";
-import { nixPrevious } from "./hooks/nixPrevious";
-import { nixLazy, Suspense } from "./hooks/nixLazy.js";
-import { nixForm } from "./hooks/nixForm.js";
-import { Path, Button } from "./custom/index.js";
 import { nixAsyncCached } from "./hooks/nixAsyncCache";
 import { nixAsyncDebounce } from "./hooks/nixAsyncDebounce";
 import { nixAsyncQuery } from "./hooks/nixAsyncQuery";
-import { nixEffectAlways } from "./hooks/nixEffect";
-import { nixEffectOnce } from "./hooks/nixEffect";
+import { nixCallback } from "./hooks/nixCallback";
+import { nixComputed } from "./hooks/nixComputed";
+import { nixDebounce } from "./hooks/nixDebounce";
+import { nixEffect, nixEffectAlways, nixEffectOnce } from "./hooks/nixEffect";
+import { nixForm } from "./hooks/nixForm";
 import { nixFormAsync } from "./hooks/nixFormAsync";
+import { nixInterval } from "./hooks/nixInterval";
+import { nixLazy, Suspense } from "./hooks/nixLazy";
 import { nixLazyAsync } from "./hooks/nixLazyAsync";
 import { nixLazyFormAsync } from "./hooks/nixLazyFormAsync";
-import createFynix from "./router/router.js";
-const TEXT = Symbol("text");
-const Fragment = Symbol("Fragment");
-const BOOLEAN_ATTRS = /* @__PURE__ */ new Set([
-  "checked",
-  "selected",
-  "disabled",
-  "readonly",
-  "multiple",
-  "autoplay",
-  "controls",
-  "loop",
-  "muted",
-  "open",
-  "required",
-  "reversed",
-  "scoped",
-  "seamless",
-  "autofocus",
-  "novalidate",
-  "formnovalidate"
+import { nixLocalStorage } from "./hooks/nixLocalStorage";
+import { nixMemo } from "./hooks/nixMemo";
+import { nixPrevious } from "./hooks/nixPrevious";
+import { nixRef } from "./hooks/nixRef";
+import { nixState } from "./hooks/nixState";
+import { nixStore } from "./hooks/nixStore";
+import createFynix from "./router/router";
+export const TEXT = Symbol("text");
+export const Fragment = Symbol("Fragment");
+const BOOLEAN_ATTRS = new Set([
+    "checked",
+    "selected",
+    "disabled",
+    "readonly",
+    "multiple",
+    "autoplay",
+    "controls",
+    "loop",
+    "muted",
+    "open",
+    "required",
+    "reversed",
+    "scoped",
+    "seamless",
+    "autofocus",
+    "novalidate",
+    "formnovalidate",
 ]);
-const DOM_PROPERTIES = /* @__PURE__ */ new Set([
-  "value",
-  "checked",
-  "selected",
-  "selectedIndex",
-  "innerHTML",
-  "textContent",
-  "innerText"
+const DOM_PROPERTIES = new Set([
+    "value",
+    "checked",
+    "selected",
+    "selectedIndex",
+    "innerHTML",
+    "textContent",
+    "innerText",
 ]);
-function createTextVNode(text) {
-  if (text == null || text === false)
-    return { type: TEXT, props: { nodeValue: "" }, key: null };
-  if (text && typeof text === "object" && text._isNixState) {
-    const vnode = {
-      type: TEXT,
-      props: { nodeValue: String(text.value) },
-      key: null,
-      _state: text,
-      _cleanup: null
-      // FIX: Track subscription cleanup
-    };
-    vnode._cleanup = text.subscribe(() => {
-      if (vnode._domNode)
-        vnode._domNode.nodeValue = String(text.value);
-    });
-    return vnode;
-  }
-  return { type: TEXT, props: { nodeValue: String(text) }, key: null };
+export function createTextVNode(text) {
+    if (text == null || text === false) {
+        return { type: TEXT, props: { nodeValue: "" }, key: null };
+    }
+    if (text && typeof text === "object" && text._isNixState) {
+        const vnode = {
+            type: TEXT,
+            props: { nodeValue: String(text.value) },
+            key: null,
+            _state: text,
+            _cleanup: null,
+        };
+        vnode._cleanup = text.subscribe(() => {
+            if (vnode._domNode) {
+                vnode._domNode.nodeValue = String(text.value);
+            }
+        });
+        return vnode;
+    }
+    return { type: TEXT, props: { nodeValue: String(text) }, key: null };
 }
-__name(createTextVNode, "createTextVNode");
-function h(type, props = {}, ...children) {
-  if (props === null || typeof props !== "object" || Array.isArray(props))
-    props = {};
-  const flatChildren = [];
-  for (const c of children.flat(Infinity)) {
-    if (c == null || c === false)
-      continue;
-    if (c && typeof c === "object" && c._isNixState)
-      flatChildren.push(createTextVNode(c));
-    else if (typeof c === "string" || typeof c === "number")
-      flatChildren.push(createTextVNode(c));
-    else if (c?.type === Fragment)
-      flatChildren.push(
-        ...(c.props.children || []).filter((x) => x != null && x !== false)
-      );
-    else if (c?.type)
-      flatChildren.push(c);
-    else
-      flatChildren.push(createTextVNode(String(c)));
-  }
-  const key = props.key ?? null;
-  if (key)
-    delete props.key;
-  if (type === Fragment)
-    return { type: Fragment, props: { children: flatChildren }, key };
-  return { type, props: { ...props, children: flatChildren }, key };
+export function h(type, props = null, ...children) {
+    const normalizedProps = props === null || typeof props !== "object" || Array.isArray(props)
+        ? {}
+        : props;
+    const flatChildren = [];
+    for (const c of children.flat(Infinity)) {
+        if (c == null || c === false)
+            continue;
+        if (c && typeof c === "object" && "_isNixState" in c) {
+            flatChildren.push(createTextVNode(c));
+        }
+        else if (typeof c === "string" || typeof c === "number") {
+            flatChildren.push(createTextVNode(c));
+        }
+        else if (c && typeof c === "object" && "type" in c) {
+            if (c.type === Fragment) {
+                const fragmentChildren = (c.props.children || []).filter((x) => x != null && x !== false);
+                flatChildren.push(...fragmentChildren);
+            }
+            else {
+                flatChildren.push(c);
+            }
+        }
+        else {
+            flatChildren.push(createTextVNode(String(c)));
+        }
+    }
+    const key = normalizedProps.key ?? null;
+    if (key !== undefined)
+        delete normalizedProps.key;
+    if (type === Fragment) {
+        return { type: Fragment, props: { children: flatChildren }, key };
+    }
+    return {
+        type,
+        props: { ...normalizedProps, children: flatChildren },
+        key,
+    };
 }
-__name(h, "h");
-h.Fragment = ({ children }) => children;
-const Fynix = h;
+h.Fragment = ({ children }) => children || [];
+export const Fynix = h;
 Fynix.Fragment = h.Fragment;
-const componentInstances = /* @__PURE__ */ new WeakMap();
+const componentInstances = new WeakMap();
 let rootRenderFn = null;
-const pendingRerenders = /* @__PURE__ */ new WeakSet();
+const pendingRerenders = new WeakSet();
 function beginComponent(vnode) {
-  let ctx = componentInstances.get(vnode);
-  if (!ctx) {
-    ctx = {
-      hooks: [],
-      hookIndex: 0,
-      effects: [],
-      cleanups: [],
-      _vnode: vnode,
-      _accessedStates: /* @__PURE__ */ new Set(),
-      _subscriptions: /* @__PURE__ */ new Set(),
-      _subscriptionCleanups: [],
-      version: 0,
-      /** @type {undefined | (() => void)} */
-      rerender: void 0,
-      Component: vnode.type,
-      _isMounted: false,
-      _isRerendering: false
-    };
-    componentInstances.set(vnode, ctx);
-  }
-  ctx.hookIndex = 0;
-  ctx._accessedStates.clear();
-  setActiveContext(ctx);
-  ctx.version++;
-  return ctx;
+    let ctx = componentInstances.get(vnode);
+    if (!ctx) {
+        ctx = {
+            hooks: [],
+            hookIndex: 0,
+            effects: [],
+            cleanups: [],
+            _vnode: vnode,
+            _accessedStates: new Set(),
+            _subscriptions: new Set(),
+            _subscriptionCleanups: [],
+            version: 0,
+            rerender: null,
+            Component: vnode.type,
+            _isMounted: false,
+            _isRerendering: false,
+        };
+        componentInstances.set(vnode, ctx);
+    }
+    ctx.hookIndex = 0;
+    ctx._accessedStates.clear();
+    setActiveContext(ctx);
+    ctx.version++;
+    return ctx;
 }
-__name(beginComponent, "beginComponent");
 function endComponent() {
-  const ctx = activeContext;
-  if (!ctx)
-    return;
-  ctx._accessedStates.forEach((state) => {
-    if (!ctx._subscriptions.has(state)) {
-      if (!ctx.rerender) {
-        let rerenderTimeout = null;
-        ctx.rerender = /* @__PURE__ */ __name(function rerender() {
-          if (ctx._isRerendering || pendingRerenders.has(ctx)) {
-            return;
-          }
-          if (rerenderTimeout) {
-            clearTimeout(rerenderTimeout);
-          }
-          rerenderTimeout = setTimeout(() => {
-            if (ctx._isRerendering || !ctx._isMounted)
-              return;
-            ctx._isRerendering = true;
-            pendingRerenders.add(ctx);
-            try {
-              removeErrorOverlay();
-              const vnode = ctx._vnode;
-              const oldRendered = vnode._rendered;
-              beginComponent(vnode);
-              const newRendered = ctx.Component(vnode.props);
-              endComponent();
-              vnode._rendered = newRendered;
-              const domNode = vnode._domNode;
-              if (domNode && domNode.parentNode) {
-                patch(domNode.parentNode, newRendered, oldRendered).then(() => {
-                  vnode._domNode = newRendered?._domNode;
-                }).finally(() => {
-                  ctx._isRerendering = false;
-                  pendingRerenders.delete(ctx);
-                });
-              } else if (rootRenderFn) {
-                rootRenderFn().finally(() => {
-                  ctx._isRerendering = false;
-                  pendingRerenders.delete(ctx);
-                });
-              } else {
-                ctx._isRerendering = false;
-                pendingRerenders.delete(ctx);
-              }
-            } catch (err) {
-              console.error("[Fynix] Component rerender error:", err);
-              showErrorOverlay(err);
-              ctx._isRerendering = false;
-              pendingRerenders.delete(ctx);
-            }
-            rerenderTimeout = null;
-          }, 0);
-        }, "rerender");
-      }
-      const unsub = state.subscribe(() => {
-        if (ctx.rerender && ctx._isMounted) {
-          if (typeof queueMicrotask === "function")
-            queueMicrotask(() => ctx.rerender());
-          else
-            setTimeout(ctx.rerender, 0);
-        }
-      });
-      ctx._subscriptions.add(state);
-      ctx._subscriptionCleanups.push(unsub);
-    }
-  });
-  setActiveContext(null);
-}
-__name(endComponent, "endComponent");
-function renderComponent(Component, props = {}) {
-  const vnode = { type: Component, props };
-  const ctx = beginComponent(vnode);
-  ctx.Component = Component;
-  if (!ctx.rerender) {
-    let rerenderTimeout = null;
-    ctx.rerender = () => {
-      if (ctx._isRerendering || pendingRerenders.has(ctx))
+    const ctx = activeContext;
+    if (!ctx)
         return;
-      if (rerenderTimeout) {
-        clearTimeout(rerenderTimeout);
-      }
-      rerenderTimeout = setTimeout(() => {
-        if (ctx._isRerendering || !ctx._isMounted)
-          return;
-        ctx._isRerendering = true;
-        pendingRerenders.add(ctx);
-        try {
-          removeErrorOverlay();
-          const vnode2 = ctx._vnode;
-          const oldRendered = vnode2._rendered;
-          beginComponent(vnode2);
-          const newRendered = ctx.Component(vnode2.props);
-          endComponent();
-          vnode2._rendered = newRendered;
-          const domNode = vnode2._domNode;
-          if (domNode && domNode.parentNode) {
-            patch(domNode.parentNode, newRendered, oldRendered).then(() => {
-              vnode2._domNode = newRendered?._domNode;
-            }).finally(() => {
-              ctx._isRerendering = false;
-              pendingRerenders.delete(ctx);
+    ctx._accessedStates.forEach((state) => {
+        if (!ctx._subscriptions.has(state)) {
+            if (!ctx.rerender) {
+                let rerenderTimeout = null;
+                ctx.rerender = function rerender() {
+                    if (ctx._isRerendering || pendingRerenders.has(ctx)) {
+                        return;
+                    }
+                    if (rerenderTimeout) {
+                        clearTimeout(rerenderTimeout);
+                    }
+                    rerenderTimeout = setTimeout(async () => {
+                        if (ctx._isRerendering || !ctx._isMounted)
+                            return;
+                        ctx._isRerendering = true;
+                        pendingRerenders.add(ctx);
+                        try {
+                            removeErrorOverlay();
+                            const vnode = ctx._vnode;
+                            const oldRendered = vnode._rendered;
+                            beginComponent(vnode);
+                            const result = ctx.Component(vnode.props);
+                            const newRendered = result instanceof Promise ? await result : result;
+                            endComponent();
+                            vnode._rendered = newRendered;
+                            const domNode = vnode._domNode;
+                            if (domNode && domNode.parentNode) {
+                                await patch(domNode.parentNode, newRendered, oldRendered);
+                                if (newRendered && typeof newRendered === "object") {
+                                    vnode._domNode = newRendered._domNode;
+                                }
+                                ctx._isRerendering = false;
+                                pendingRerenders.delete(ctx);
+                            }
+                            else if (rootRenderFn) {
+                                await rootRenderFn();
+                                ctx._isRerendering = false;
+                                pendingRerenders.delete(ctx);
+                            }
+                            else {
+                                ctx._isRerendering = false;
+                                pendingRerenders.delete(ctx);
+                            }
+                        }
+                        catch (err) {
+                            console.error("[Fynix] Component rerender error:", err);
+                            showErrorOverlay(err);
+                            ctx._isRerendering = false;
+                            pendingRerenders.delete(ctx);
+                        }
+                        rerenderTimeout = null;
+                    }, 0);
+                };
+            }
+            const unsub = state.subscribe(() => {
+                if (ctx.rerender && ctx._isMounted) {
+                    if (typeof queueMicrotask === "function") {
+                        queueMicrotask(() => ctx.rerender());
+                    }
+                    else {
+                        setTimeout(ctx.rerender, 0);
+                    }
+                }
             });
-          } else if (rootRenderFn) {
-            rootRenderFn().finally(() => {
-              ctx._isRerendering = false;
-              pendingRerenders.delete(ctx);
+            ctx._subscriptions.add(state);
+            ctx._subscriptionCleanups.push(unsub);
+        }
+    });
+    setActiveContext(null);
+}
+export function renderComponent(Component, props = {}) {
+    const vnode = { type: Component, props, key: null };
+    const ctx = beginComponent(vnode);
+    ctx.Component = Component;
+    if (!ctx.rerender) {
+        let rerenderTimeout = null;
+        ctx.rerender = () => {
+            if (ctx._isRerendering || pendingRerenders.has(ctx))
+                return;
+            if (rerenderTimeout) {
+                clearTimeout(rerenderTimeout);
+            }
+            rerenderTimeout = setTimeout(async () => {
+                if (ctx._isRerendering || !ctx._isMounted)
+                    return;
+                ctx._isRerendering = true;
+                pendingRerenders.add(ctx);
+                try {
+                    removeErrorOverlay();
+                    const vnode = ctx._vnode;
+                    const oldRendered = vnode._rendered;
+                    beginComponent(vnode);
+                    const result = ctx.Component(vnode.props);
+                    const newRendered = result instanceof Promise ? await result : result;
+                    endComponent();
+                    vnode._rendered = newRendered;
+                    const domNode = vnode._domNode;
+                    if (domNode && domNode.parentNode) {
+                        await patch(domNode.parentNode, newRendered, oldRendered);
+                        if (newRendered && typeof newRendered === "object") {
+                            vnode._domNode = newRendered._domNode;
+                        }
+                        ctx._isRerendering = false;
+                        pendingRerenders.delete(ctx);
+                    }
+                    else if (rootRenderFn) {
+                        await rootRenderFn();
+                        ctx._isRerendering = false;
+                        pendingRerenders.delete(ctx);
+                    }
+                    else {
+                        ctx._isRerendering = false;
+                        pendingRerenders.delete(ctx);
+                    }
+                }
+                catch (err) {
+                    console.error("[Fynix] Component rerender error:", err);
+                    showErrorOverlay(err);
+                    ctx._isRerendering = false;
+                    pendingRerenders.delete(ctx);
+                }
+                rerenderTimeout = null;
+            }, 0);
+        };
+    }
+    try {
+        removeErrorOverlay();
+        const result = Component(props);
+        if (result instanceof Promise) {
+            const placeholderVNode = h("div", null, "Loading...");
+            ctx._vnode = vnode;
+            vnode._rendered = placeholderVNode;
+            ctx._isMounted = true;
+            result
+                .then((resolvedVNode) => {
+                vnode._rendered = resolvedVNode;
+                if (ctx.rerender) {
+                    ctx.rerender();
+                }
+            })
+                .catch((err) => {
+                console.error("[Fynix] Async component error:", err);
+                showErrorOverlay(err);
             });
-          } else {
-            ctx._isRerendering = false;
-            pendingRerenders.delete(ctx);
-          }
-        } catch (err) {
-          console.error("[Fynix] Component rerender error:", err);
-          showErrorOverlay(err);
-          ctx._isRerendering = false;
-          pendingRerenders.delete(ctx);
-        }
-        rerenderTimeout = null;
-      }, 0);
-    };
-  }
-  try {
-    removeErrorOverlay();
-    const result = Component(props);
-    ctx._vnode = vnode;
-    vnode._rendered = result;
-    ctx._isMounted = true;
-    return result;
-  } catch (err) {
-    console.error("[Fynix] Component render error:", err);
-    showErrorOverlay(err);
-    return h("div", { style: "color:red" }, `Error: ${err.message}`);
-  } finally {
-    endComponent();
-  }
+            return placeholderVNode;
+        }
+        ctx._vnode = vnode;
+        vnode._rendered = result;
+        ctx._isMounted = true;
+        return result;
+    }
+    catch (err) {
+        console.error("[Fynix] Component render error:", err);
+        showErrorOverlay(err);
+        return h("div", { style: "color:red" }, `Error: ${err.message}`);
+    }
+    finally {
+        endComponent();
+    }
 }
-__name(renderComponent, "renderComponent");
-const delegatedEvents = /* @__PURE__ */ new Map();
+const delegatedEvents = new Map();
 let eventIdCounter = 1;
 function ensureDelegated(eventType) {
-  if (delegatedEvents.has(eventType))
-    return;
-  delegatedEvents.set(eventType, /* @__PURE__ */ new Map());
-  document.addEventListener(eventType, (e) => {
-    let cur = e.target;
-    while (cur && cur !== document) {
-      if (cur.nodeType !== 1)
-        break;
-      const eid = cur._rest_eid;
-      const map = delegatedEvents.get(eventType);
-      if (eid != null && map?.has(eid)) {
-        map.get(eid)(e);
+    if (delegatedEvents.has(eventType))
         return;
-      }
-      cur = cur.parentElement;
-    }
-  });
+    delegatedEvents.set(eventType, new Map());
+    document.addEventListener(eventType, (e) => {
+        let cur = e.target;
+        while (cur && cur !== document) {
+            if (cur.nodeType !== 1)
+                break;
+            const el = cur;
+            const eid = el._rest_eid;
+            const map = delegatedEvents.get(eventType);
+            if (eid != null && map?.has(eid)) {
+                map.get(eid)(e);
+                return;
+            }
+            cur = cur.parentElement;
+        }
+    });
 }
-__name(ensureDelegated, "ensureDelegated");
 function registerDelegatedHandler(el, eventName, fn) {
-  if (!fn || el.nodeType !== 1)
-    return;
-  const eid = el._rest_eid ?? (el._rest_eid = ++eventIdCounter);
-  ensureDelegated(eventName);
-  delegatedEvents.get(eventName).set(eid, (e) => {
-    try {
-      fn.call(el, e);
-    } catch (err) {
-      console.error("[Fynix] Event handler error:", err);
-      showErrorOverlay(err);
-    }
-  });
+    if (!fn || el.nodeType !== 1)
+        return;
+    const anyEl = el;
+    const eid = anyEl._rest_eid ?? (anyEl._rest_eid = ++eventIdCounter);
+    ensureDelegated(eventName);
+    delegatedEvents.get(eventName).set(eid, (e) => {
+        try {
+            fn.call(el, e);
+        }
+        catch (err) {
+            console.error("[Fynix] Event handler error:", err);
+            showErrorOverlay(err);
+        }
+    });
 }
-__name(registerDelegatedHandler, "registerDelegatedHandler");
 function setProperty(el, key, value) {
-  const k = key.toLowerCase();
-  if (key === "r-class" || key === "rc") {
-    if (typeof value === "string")
-      el.setAttribute("class", value);
-    else if (value && (value._isNixState || value._isRestState)) {
-      el.setAttribute("class", value.value);
-      if (!el._fynixCleanups)
-        el._fynixCleanups = [];
-      const unsub = value.subscribe(
-        () => el.setAttribute("class", value.value)
-      );
-      el._fynixCleanups.push(unsub);
-    }
-    return;
-  }
-  if (key.startsWith("r-")) {
-    registerDelegatedHandler(el, key.slice(2).toLowerCase(), value);
-    return;
-  }
-  if (key === "style" && typeof value === "object") {
-    Object.assign(el.style, value);
-    return;
-  }
-  if (key === "innerHTML" || key === "outerHTML") {
-    console.warn(
-      "[Fynix] Security: innerHTML/outerHTML not allowed. Use textContent or children."
-    );
-    return;
-  }
-  if (BOOLEAN_ATTRS.has(k)) {
-    if (value) {
-      el.setAttribute(k, "");
-      el[k] = true;
-    } else {
-      el.removeAttribute(k);
-      el[k] = false;
-    }
-    return;
-  }
-  if (DOM_PROPERTIES.has(key)) {
-    el[key] = value ?? "";
-    return;
-  }
-  if (key.startsWith("data-") || key.startsWith("aria-")) {
-    if (value != null && value !== false)
-      el.setAttribute(key, value);
-    else
-      el.removeAttribute(key);
-    return;
-  }
-  if ((key === "href" || key === "src") && typeof value === "string") {
-    if (value.trim().toLowerCase().startsWith("javascript:")) {
-      console.warn("[Fynix] Security: javascript: protocol blocked in", key);
-      return;
-    }
-  }
-  if (value != null && value !== false)
-    el.setAttribute(key, value);
+    const k = key.toLowerCase();
+    if (key === "r-class" || key === "rc") {
+        if (typeof value === "string") {
+            el.setAttribute("class", value);
+        }
+        else if (value && (value._isNixState || value._isRestState)) {
+            el.setAttribute("class", value.value);
+            const anyEl = el;
+            if (!anyEl._fynixCleanups)
+                anyEl._fynixCleanups = [];
+            const unsub = value.subscribe(() => el.setAttribute("class", value.value));
+            anyEl._fynixCleanups.push(unsub);
+        }
+        return;
+    }
+    if (key.startsWith("r-")) {
+        registerDelegatedHandler(el, key.slice(2).toLowerCase(), value);
+        return;
+    }
+    if (key === "style" && typeof value === "object") {
+        Object.assign(el.style, value);
+        return;
+    }
+    if (key === "innerHTML" || key === "outerHTML") {
+        console.warn("[Fynix] Security: innerHTML/outerHTML not allowed. Use textContent or children.");
+        return;
+    }
+    if (BOOLEAN_ATTRS.has(k)) {
+        if (value) {
+            el.setAttribute(k, "");
+            el[k] = true;
+        }
+        else {
+            el.removeAttribute(k);
+            el[k] = false;
+        }
+        return;
+    }
+    if (DOM_PROPERTIES.has(key)) {
+        el[key] = value ?? "";
+        return;
+    }
+    if (key.startsWith("data-") || key.startsWith("aria-")) {
+        if (value != null && value !== false) {
+            el.setAttribute(key, value);
+        }
+        else {
+            el.removeAttribute(key);
+        }
+        return;
+    }
+    if ((key === "href" || key === "src") && typeof value === "string") {
+        if (value.trim().toLowerCase().startsWith("javascript:")) {
+            console.warn("[Fynix] Security: javascript: protocol blocked in", key);
+            return;
+        }
+    }
+    if (value != null && value !== false) {
+        el.setAttribute(key, value);
+    }
 }
-__name(setProperty, "setProperty");
 async function createDom(vnode, existing = null) {
-  if (vnode == null || vnode === false)
-    return document.createTextNode("");
-  if (typeof vnode === "string" || typeof vnode === "number")
-    return document.createTextNode(String(vnode));
-  if (vnode.type === TEXT) {
-    const textNode = existing || document.createTextNode(vnode.props.nodeValue ?? "");
-    vnode._domNode = textNode;
-    return textNode;
-  }
-  if (vnode instanceof Promise) {
-    const placeholder = document.createTextNode("Loading...");
-    vnode.then(async (resolved) => {
-      try {
-        const dom = await createDom(resolved);
-        if (placeholder.parentNode) {
-          placeholder.replaceWith(dom);
-        }
-      } catch (err) {
-        console.error("[Fynix] Async component error:", err);
-        if (placeholder.parentNode) {
-          placeholder.textContent = "Error loading component";
-        }
-      }
-    }).catch((err) => {
-      console.error("[Fynix] Async component promise error:", err);
-      if (placeholder.parentNode) {
-        placeholder.textContent = "Error loading async component";
-      }
-    });
-    return placeholder;
-  }
-  if (vnode.type === Fragment) {
-    const frag = document.createDocumentFragment();
-    for (const child of vnode.props?.children || [])
-      frag.appendChild(await createDom(child));
-    vnode._domNode = frag;
-    return frag;
-  }
-  if (typeof vnode.type === "function") {
-    const rendered = await renderMaybeAsyncComponent(
-      vnode.type,
-      vnode.props,
-      vnode
-    );
-    vnode._rendered = rendered;
-    const dom = await createDom(rendered);
-    vnode._domNode = dom;
-    return dom;
-  }
-  const el = existing || document.createElement(vnode.type);
-  for (const [k, v] of Object.entries(vnode.props || {}))
-    if (k !== "children")
-      setProperty(el, k, v);
-  for (const child of vnode.props?.children || [])
-    el.appendChild(await createDom(child));
-  vnode._domNode = el;
-  return el;
+    if (vnode == null) {
+        return document.createTextNode("");
+    }
+    if (typeof vnode === "string" || typeof vnode === "number") {
+        return document.createTextNode(String(vnode));
+    }
+    if (vnode instanceof Promise) {
+        const placeholder = document.createTextNode("Loading...");
+        vnode
+            .then(async (resolved) => {
+            try {
+                const dom = await createDom(resolved);
+                if (placeholder.parentNode) {
+                    placeholder.replaceWith(dom);
+                }
+            }
+            catch (err) {
+                console.error("[Fynix] Async component error:", err);
+                if (placeholder.parentNode) {
+                    placeholder.textContent = "Error loading component";
+                }
+            }
+        })
+            .catch((err) => {
+            console.error("[Fynix] Async component promise error:", err);
+            if (placeholder.parentNode) {
+                placeholder.textContent = "Error loading async component";
+            }
+        });
+        return placeholder;
+    }
+    const vnodeObj = vnode;
+    if (vnodeObj.type === TEXT) {
+        const textNode = existing || document.createTextNode(vnodeObj.props.nodeValue ?? "");
+        vnodeObj._domNode = textNode;
+        return textNode;
+    }
+    if (vnodeObj.type === Fragment) {
+        const frag = document.createDocumentFragment();
+        for (const child of vnodeObj.props?.children || []) {
+            frag.appendChild(await createDom(child));
+        }
+        vnodeObj._domNode = frag;
+        return frag;
+    }
+    if (typeof vnodeObj.type === "function") {
+        const rendered = await renderMaybeAsyncComponent(vnodeObj.type, vnodeObj.props, vnodeObj);
+        vnodeObj._rendered = rendered;
+        const dom = await createDom(rendered);
+        vnodeObj._domNode = dom;
+        return dom;
+    }
+    const el = existing || document.createElement(vnodeObj.type);
+    for (const [k, v] of Object.entries(vnodeObj.props || {})) {
+        if (k !== "children") {
+            setProperty(el, k, v);
+        }
+    }
+    for (const child of vnodeObj.props?.children || []) {
+        el.appendChild(await createDom(child));
+    }
+    vnodeObj._domNode = el;
+    return el;
 }
-__name(createDom, "createDom");
 async function renderMaybeAsyncComponent(Component, props, vnode) {
-  const ctx = beginComponent(vnode);
-  removeErrorOverlay();
-  try {
-    const result = await Component(props);
-    ctx._vnode = vnode;
-    vnode._rendered = result;
-    ctx._isMounted = true;
-    endComponent();
-    return result ?? null;
-  } catch (err) {
-    console.error("[Fynix] async render error:", err);
-    showErrorOverlay(err);
-    ctx._isMounted = false;
-    endComponent();
-    return h("div", { style: "color:red" }, `Error: ${err.message}`);
-  }
+    const ctx = beginComponent(vnode);
+    removeErrorOverlay();
+    try {
+        const result = await Component(props);
+        ctx._vnode = vnode;
+        vnode._rendered = result;
+        ctx._isMounted = true;
+        endComponent();
+        return result ?? null;
+    }
+    catch (err) {
+        console.error("[Fynix] async render error:", err);
+        showErrorOverlay(err);
+        ctx._isMounted = false;
+        endComponent();
+        return h("div", { style: "color:red" }, `Error: ${err.message}`);
+    }
 }
-__name(renderMaybeAsyncComponent, "renderMaybeAsyncComponent");
-async function patch(parent, newVNode, oldVNode) {
-  if (!(parent instanceof Node)) {
-    console.error(
-      "[Fynix] patch() expects a DOM Node, got:",
-      typeof parent,
-      parent
-    );
-    return;
-  }
-  if (!newVNode && !oldVNode)
-    return;
-  if (!newVNode && oldVNode) {
-    const domNode = oldVNode._domNode;
-    if (domNode?.parentNode)
-      domNode.parentNode.removeChild(domNode);
-    unmountVNode(oldVNode);
-    return;
-  }
-  if (newVNode && !oldVNode) {
-    const newDom = await createDom(newVNode);
-    if (newDom instanceof Node) {
-      parent.appendChild(newDom);
-    }
-    return;
-  }
-  const newIsPrimitive = typeof newVNode === "string" || typeof newVNode === "number";
-  const oldIsPrimitive = typeof oldVNode === "string" || typeof oldVNode === "number";
-  if (newIsPrimitive || oldIsPrimitive) {
-    if (newIsPrimitive && oldIsPrimitive && newVNode === oldVNode)
-      return;
-    const newDom = await createDom(newVNode);
-    const oldDom = oldVNode._domNode || parent.firstChild;
-    if (oldDom?.parentNode && newDom instanceof Node) {
-      oldDom.parentNode.replaceChild(newDom, oldDom);
-    }
-    if (oldVNode && typeof oldVNode === "object") {
-      unmountVNode(oldVNode);
-    }
-    return;
-  }
-  const newType = newVNode.type;
-  const oldType = oldVNode.type;
-  if (newType !== oldType) {
-    const newDom = await createDom(newVNode);
-    const oldDom = oldVNode._domNode;
-    if (oldDom?.parentNode && newDom instanceof Node) {
-      oldDom.parentNode.replaceChild(newDom, oldDom);
-    }
-    unmountVNode(oldVNode);
-    return;
-  }
-  if (newType === TEXT) {
-    const oldDom = oldVNode._domNode;
-    const newText = newVNode.props.nodeValue ?? "";
-    const oldText = oldVNode.props.nodeValue ?? "";
-    if (newText !== oldText && oldDom) {
-      oldDom.nodeValue = newText;
-    }
-    newVNode._domNode = oldDom;
-    return;
-  }
-  if (newType === Fragment) {
-    const newChildren2 = newVNode.props?.children || [];
-    const oldChildren2 = oldVNode.props?.children || [];
-    await patchChildren(parent, newChildren2, oldChildren2);
-    newVNode._domNode = oldVNode._domNode;
-    return;
-  }
-  if (typeof newType === "function") {
-    const oldCtx = componentInstances.get(oldVNode);
-    if (oldCtx && newType === oldType) {
-      componentInstances.delete(oldVNode);
-      componentInstances.set(newVNode, oldCtx);
-      oldCtx._vnode = newVNode;
-      beginComponent(newVNode);
-      const rendered = await oldCtx.Component(newVNode.props);
-      endComponent();
-      newVNode._rendered = rendered;
-      const oldRendered = oldVNode._rendered;
-      const oldDom = oldVNode._domNode;
-      if (oldDom?.parentNode instanceof Node) {
-        await patch(oldDom.parentNode, rendered, oldRendered);
-        newVNode._domNode = rendered?._domNode || oldDom;
-      }
-    } else {
-      const rendered = await renderMaybeAsyncComponent(
-        newType,
-        newVNode.props,
-        newVNode
-      );
-      newVNode._rendered = rendered;
-      const oldRendered = oldVNode._rendered;
-      const oldDom = oldVNode._domNode;
-      if (oldDom?.parentNode instanceof Node) {
-        await patch(oldDom.parentNode, rendered, oldRendered);
-        newVNode._domNode = rendered?._domNode || oldDom;
-      } else {
-        const newDom = await createDom(rendered);
-        if (parent && newDom instanceof Node) {
-          parent.appendChild(newDom);
+export async function patch(parent, newVNode, oldVNode) {
+    if (!(parent instanceof Node)) {
+        console.error("[Fynix] patch() expects a DOM Node, got:", typeof parent, parent);
+        return;
+    }
+    if (!newVNode && !oldVNode)
+        return;
+    if (!newVNode && oldVNode) {
+        const domNode = oldVNode._domNode;
+        if (domNode?.parentNode) {
+            domNode.parentNode.removeChild(domNode);
         }
-        newVNode._domNode = newDom;
-      }
-      if (oldCtx && newType !== oldType) {
         unmountVNode(oldVNode);
-      }
-    }
-    return;
-  }
-  const el = oldVNode._domNode;
-  if (!el || el.nodeType !== 1) {
-    const newDom = await createDom(newVNode);
-    if (parent && newDom instanceof Node) {
-      parent.appendChild(newDom);
-    }
-    unmountVNode(oldVNode);
-    return;
-  }
-  updateProps(el, newVNode.props, oldVNode.props);
-  newVNode._domNode = el;
-  const newChildren = newVNode.props?.children || [];
-  const oldChildren = oldVNode.props?.children || [];
-  await patchChildren(el, newChildren, oldChildren);
+        return;
+    }
+    if (newVNode && !oldVNode) {
+        const newDom = await createDom(newVNode);
+        if (newDom instanceof Node) {
+            parent.appendChild(newDom);
+        }
+        return;
+    }
+    const newIsPrimitive = typeof newVNode === "string" || typeof newVNode === "number";
+    const oldIsPrimitive = typeof oldVNode === "string" || typeof oldVNode === "number";
+    if (newIsPrimitive || oldIsPrimitive) {
+        if (newIsPrimitive &&
+            oldIsPrimitive &&
+            String(newVNode) === String(oldVNode))
+            return;
+        const newDom = await createDom(newVNode);
+        const oldDom = oldVNode?._domNode || parent.firstChild;
+        if (oldDom?.parentNode && newDom instanceof Node) {
+            oldDom.parentNode.replaceChild(newDom, oldDom);
+        }
+        if (oldVNode && typeof oldVNode === "object") {
+            unmountVNode(oldVNode);
+        }
+        return;
+    }
+    const newVN = newVNode;
+    const oldVN = oldVNode;
+    const newType = newVN.type;
+    const oldType = oldVN.type;
+    if (newType !== oldType) {
+        const newDom = await createDom(newVN);
+        const oldDom = oldVN._domNode;
+        if (oldDom?.parentNode && newDom instanceof Node) {
+            oldDom.parentNode.replaceChild(newDom, oldDom);
+        }
+        unmountVNode(oldVN);
+        return;
+    }
+    if (newType === TEXT) {
+        const oldDom = oldVN._domNode;
+        const newText = newVN.props.nodeValue ?? "";
+        const oldText = oldVN.props.nodeValue ?? "";
+        if (newText !== oldText && oldDom) {
+            oldDom.nodeValue = newText;
+        }
+        newVN._domNode = oldDom;
+        return;
+    }
+    if (newType === Fragment) {
+        const newChildren = newVN.props?.children || [];
+        const oldChildren = oldVN.props?.children || [];
+        await patchChildren(parent, newChildren, oldChildren);
+        newVN._domNode = oldVN._domNode;
+        return;
+    }
+    if (typeof newType === "function") {
+        const oldCtx = componentInstances.get(oldVN);
+        if (oldCtx && newType === oldType) {
+            componentInstances.delete(oldVN);
+            componentInstances.set(newVN, oldCtx);
+            oldCtx._vnode = newVN;
+            beginComponent(newVN);
+            const rendered = await oldCtx.Component(newVN.props);
+            endComponent();
+            newVN._rendered = rendered;
+            const oldRendered = oldVN._rendered;
+            const oldDom = oldVN._domNode;
+            if (oldDom?.parentNode instanceof Node) {
+                await patch(oldDom.parentNode, rendered, oldRendered);
+                newVN._domNode = rendered?._domNode || oldDom;
+            }
+        }
+        else {
+            const rendered = await renderMaybeAsyncComponent(newType, newVN.props, newVN);
+            newVN._rendered = rendered;
+            const oldRendered = oldVN._rendered;
+            const oldDom = oldVN._domNode;
+            if (oldDom?.parentNode instanceof Node) {
+                await patch(oldDom.parentNode, rendered, oldRendered);
+                newVN._domNode = rendered?._domNode || oldDom;
+            }
+            else {
+                const newDom = await createDom(rendered);
+                if (parent && newDom instanceof Node) {
+                    parent.appendChild(newDom);
+                }
+                newVN._domNode = newDom;
+            }
+            if (oldCtx && newType !== oldType) {
+                unmountVNode(oldVN);
+            }
+        }
+        return;
+    }
+    const el = oldVN._domNode;
+    if (!el || el.nodeType !== 1) {
+        const newDom = await createDom(newVN);
+        if (parent && newDom instanceof Node) {
+            parent.appendChild(newDom);
+        }
+        unmountVNode(oldVN);
+        return;
+    }
+    updateProps(el, newVN.props, oldVN.props);
+    newVN._domNode = el;
+    const newChildren = newVN.props?.children || [];
+    const oldChildren = oldVN.props?.children || [];
+    await patchChildren(el, newChildren, oldChildren);
 }
-__name(patch, "patch");
 async function patchChildren(parent, newChildren, oldChildren) {
-  if (!(parent instanceof Node))
-    return;
-  const hasKeys = newChildren.some((c) => c?.key != null) || oldChildren.some((c) => c?.key != null);
-  if (!hasKeys) {
-    const maxLen = Math.max(newChildren.length, oldChildren.length);
-    for (let i = 0; i < maxLen; i++) {
-      const newChild = newChildren[i];
-      const oldChild = oldChildren[i];
-      if (i >= newChildren.length) {
-        const dom = oldChild?._domNode;
-        if (dom?.parentNode)
-          dom.parentNode.removeChild(dom);
-        unmountVNode(oldChild);
-      } else if (i >= oldChildren.length) {
-        const newDom = await createDom(newChild);
-        if (newDom instanceof Node) {
-          parent.appendChild(newDom);
-        }
-      } else {
-        await patch(parent, newChild, oldChild);
-      }
-    }
-    return;
-  }
-  const oldKeyMap = /* @__PURE__ */ new Map();
-  const oldIndexMap = /* @__PURE__ */ new Map();
-  oldChildren.forEach((child, idx) => {
-    if (child?.key != null) {
-      oldKeyMap.set(child.key, child);
-      oldIndexMap.set(child.key, idx);
-    }
-  });
-  const newKeySet = new Set(
-    newChildren.filter((c) => c?.key != null).map((c) => c.key)
-  );
-  oldChildren.forEach((oldChild) => {
-    if (oldChild?.key != null && !newKeySet.has(oldChild.key)) {
-      const dom = oldChild._domNode;
-      if (dom?.parentNode)
-        dom.parentNode.removeChild(dom);
-      unmountVNode(oldChild);
-    }
-  });
-  for (let i = 0; i < newChildren.length; i++) {
-    const newChild = newChildren[i];
-    const key = newChild?.key;
-    if (key != null && oldKeyMap.has(key)) {
-      const oldChild = oldKeyMap.get(key);
-      const oldDom = oldChild._domNode;
-      const childNodes = Array.from(parent.childNodes);
-      const currentPos = childNodes.indexOf(oldDom);
-      const desiredPos = i;
-      if (currentPos !== desiredPos) {
-        const refNode = childNodes[desiredPos] || null;
-        if (oldDom && oldDom.parentNode === parent) {
-          parent.insertBefore(oldDom, refNode);
-        }
-      }
-      await patch(parent, newChild, oldChild);
-    } else {
-      const newDom = await createDom(newChild);
-      if (newDom instanceof Node) {
-        const childNodes = Array.from(parent.childNodes);
-        const refNode = childNodes[i] || null;
-        parent.insertBefore(newDom, refNode);
-      }
-    }
-  }
+    if (!(parent instanceof Node))
+        return;
+    const hasKeys = newChildren.some((c) => c?.key != null) ||
+        oldChildren.some((c) => c?.key != null);
+    if (!hasKeys) {
+        const maxLen = Math.max(newChildren.length, oldChildren.length);
+        for (let i = 0; i < maxLen; i++) {
+            const newChild = newChildren[i];
+            const oldChild = oldChildren[i];
+            if (i >= newChildren.length) {
+                const dom = oldChild?._domNode;
+                if (dom?.parentNode) {
+                    dom.parentNode.removeChild(dom);
+                }
+                unmountVNode(oldChild);
+            }
+            else if (i >= oldChildren.length) {
+                const newDom = await createDom(newChild);
+                if (newDom instanceof Node) {
+                    parent.appendChild(newDom);
+                }
+            }
+            else {
+                await patch(parent, newChild, oldChild);
+            }
+        }
+        return;
+    }
+    const oldKeyMap = new Map();
+    oldChildren.forEach((child) => {
+        if (child?.key != null) {
+            oldKeyMap.set(child.key, child);
+        }
+    });
+    const newKeySet = new Set(newChildren.filter((c) => c?.key != null).map((c) => c.key));
+    oldChildren.forEach((oldChild) => {
+        if (oldChild?.key != null && !newKeySet.has(oldChild.key)) {
+            const dom = oldChild._domNode;
+            if (dom?.parentNode) {
+                dom.parentNode.removeChild(dom);
+            }
+            unmountVNode(oldChild);
+        }
+    });
+    for (let i = 0; i < newChildren.length; i++) {
+        const newChild = newChildren[i];
+        const key = newChild?.key;
+        if (key != null && oldKeyMap.has(key)) {
+            const oldChild = oldKeyMap.get(key);
+            const oldDom = oldChild._domNode;
+            const childNodes = Array.from(parent.childNodes);
+            const currentPos = childNodes.indexOf(oldDom);
+            const desiredPos = i;
+            if (currentPos !== desiredPos) {
+                const refNode = childNodes[desiredPos] || null;
+                if (oldDom && oldDom.parentNode === parent) {
+                    parent.insertBefore(oldDom, refNode);
+                }
+            }
+            await patch(parent, newChild, oldChild);
+        }
+        else {
+            const newDom = await createDom(newChild);
+            if (newDom instanceof Node) {
+                const childNodes = Array.from(parent.childNodes);
+                const refNode = childNodes[i] || null;
+                parent.insertBefore(newDom, refNode);
+            }
+        }
+    }
 }
-__name(patchChildren, "patchChildren");
 function unmountVNode(vnode) {
-  if (!vnode)
-    return;
-  if (vnode._cleanup && typeof vnode._cleanup === "function") {
-    try {
-      vnode._cleanup();
-    } catch (e) {
-      console.error("[Fynix] Text vnode cleanup error:", e);
-    }
-    vnode._cleanup = null;
-  }
-  if (typeof vnode.type === "function") {
-    const ctx = componentInstances.get(vnode);
-    if (ctx) {
-      ctx._isMounted = false;
-      ctx._subscriptionCleanups.forEach((u) => {
+    if (!vnode)
+        return;
+    if (vnode._cleanup && typeof vnode._cleanup === "function") {
         try {
-          u();
-        } catch (e) {
-          console.error("[Fynix] Cleanup error:", e);
+            vnode._cleanup();
         }
-      });
-      ctx.cleanups.forEach((c) => {
-        try {
-          c?.();
-        } catch (e) {
-          console.error("[Fynix] Effect cleanup error:", e);
-        }
-      });
-      ctx._subscriptions.clear();
-      ctx._accessedStates.clear();
-      ctx._subscriptionCleanups = [];
-      ctx.cleanups = [];
-      ctx.hooks = [];
-      ctx.effects = [];
-      ctx.rerender = null;
-      ctx._vnode = null;
-      componentInstances.delete(vnode);
-      pendingRerenders.delete(ctx);
-    }
-    unmountVNode(vnode._rendered);
-    return;
-  }
-  if (vnode._domNode && vnode._domNode.nodeType === 1) {
-    const eid = vnode._domNode._rest_eid;
-    if (eid) {
-      delegatedEvents.forEach((map) => map.delete(eid));
-    }
-    if (vnode._domNode._fynixCleanups) {
-      vnode._domNode._fynixCleanups.forEach((cleanup) => {
-        try {
-          cleanup();
-        } catch (e) {
-          console.error("[Fynix] Element cleanup error:", e);
-        }
-      });
-      vnode._domNode._fynixCleanups = null;
-    }
-  }
-  if (vnode.props?.children)
-    vnode.props.children.forEach((c) => unmountVNode(c));
-  vnode._domNode = null;
-  vnode._rendered = null;
+        catch (e) {
+            console.error("[Fynix] Text vnode cleanup error:", e);
+        }
+        vnode._cleanup = null;
+    }
+    if (typeof vnode.type === "function") {
+        const ctx = componentInstances.get(vnode);
+        if (ctx) {
+            ctx._isMounted = false;
+            ctx._subscriptionCleanups.forEach((u) => {
+                try {
+                    u();
+                }
+                catch (e) {
+                    console.error("[Fynix] Cleanup error:", e);
+                }
+            });
+            ctx.cleanups.forEach((c) => {
+                try {
+                    c?.();
+                }
+                catch (e) {
+                    console.error("[Fynix] Effect cleanup error:", e);
+                }
+            });
+            ctx._subscriptions.clear();
+            ctx._accessedStates.clear();
+            ctx._subscriptionCleanups = [];
+            ctx.cleanups = [];
+            ctx.hooks = [];
+            ctx.effects = [];
+            ctx.rerender = null;
+            ctx._vnode = null;
+            componentInstances.delete(vnode);
+            pendingRerenders.delete(ctx);
+        }
+        unmountVNode(vnode._rendered);
+        return;
+    }
+    if (vnode._domNode && vnode._domNode.nodeType === 1) {
+        const anyNode = vnode._domNode;
+        const eid = anyNode._rest_eid;
+        if (eid) {
+            delegatedEvents.forEach((map) => map.delete(eid));
+        }
+        if (anyNode._fynixCleanups) {
+            anyNode._fynixCleanups.forEach((cleanup) => {
+                try {
+                    cleanup();
+                }
+                catch (e) {
+                    console.error("[Fynix] Element cleanup error:", e);
+                }
+            });
+            anyNode._fynixCleanups = null;
+        }
+    }
+    if (vnode.props?.children) {
+        vnode.props.children.forEach((c) => unmountVNode(c));
+    }
+    vnode._domNode = null;
+    vnode._rendered = null;
 }
-__name(unmountVNode, "unmountVNode");
 function updateProps(el, newProps = {}, oldProps = {}) {
-  if (!el || el.nodeType !== 1)
-    return;
-  for (const k of Object.keys(oldProps)) {
-    if (k === "children")
-      continue;
-    if (!(k in newProps)) {
-      if (k.startsWith("r-")) {
-        const eid = el._rest_eid;
-        if (eid && delegatedEvents.has(k.slice(2).toLowerCase())) {
-          delegatedEvents.get(k.slice(2).toLowerCase()).delete(eid);
-        }
-      } else if (BOOLEAN_ATTRS.has(k.toLowerCase())) {
-        el.removeAttribute(k);
-        el[k] = false;
-      } else if (DOM_PROPERTIES.has(k))
-        el[k] = "";
-      else
-        el.removeAttribute(k);
-    }
-  }
-  for (const [k, v] of Object.entries(newProps)) {
-    if (k === "children")
-      continue;
-    if (oldProps[k] !== v)
-      setProperty(el, k, v);
-  }
+    if (!el || el.nodeType !== 1)
+        return;
+    for (const k of Object.keys(oldProps)) {
+        if (k === "children")
+            continue;
+        if (!(k in newProps)) {
+            if (k.startsWith("r-")) {
+                const anyEl = el;
+                const eid = anyEl._rest_eid;
+                if (eid && delegatedEvents.has(k.slice(2).toLowerCase())) {
+                    delegatedEvents.get(k.slice(2).toLowerCase()).delete(eid);
+                }
+            }
+            else if (BOOLEAN_ATTRS.has(k.toLowerCase())) {
+                el.removeAttribute(k);
+                el[k] = false;
+            }
+            else if (DOM_PROPERTIES.has(k)) {
+                el[k] = "";
+            }
+            else {
+                el.removeAttribute(k);
+            }
+        }
+    }
+    for (const [k, v] of Object.entries(newProps)) {
+        if (k === "children")
+            continue;
+        if (oldProps[k] !== v) {
+            setProperty(el, k, v);
+        }
+    }
 }
-__name(updateProps, "updateProps");
-function mount(AppComponent, root, hydrate = false, props = {}) {
-  if (typeof root === "string") {
-    const element = document.querySelector(root);
-    if (!element) {
-      console.error(
-        "[Fynix] Mount error: Element not found for selector:",
-        root
-      );
-      return;
-    }
-    root = element;
-  }
-  if (!(root instanceof Element)) {
-    console.error("[Fynix] Mount error: Invalid root element", root);
-    return;
-  }
-  let Component = AppComponent;
-  let oldVNode = null;
-  let currentProps = props;
-  let appVNode = null;
-  let isRendering = false;
-  async function renderApp() {
-    if (isRendering) {
-      return;
-    }
-    isRendering = true;
-    try {
-      removeErrorOverlay();
-      const propsToUse = window.__lastRouteProps || window.__fynix__?.lastRouteProps || currentProps;
-      if (!appVNode) {
-        appVNode = { type: Component, props: propsToUse, key: null };
-        if (root instanceof Element) {
-          root.innerHTML = "";
-          const dom = await createDom(appVNode);
-          if (dom instanceof Node) {
-            root.appendChild(dom);
-          }
-        } else {
-          console.error("[Fynix] Mount error: root is not a DOM Element", root);
-          return;
-        }
-        oldVNode = appVNode;
-      } else {
-        appVNode.props = propsToUse;
-        if (root instanceof Node) {
-          await patch(root, appVNode, oldVNode);
-          oldVNode = appVNode;
-        } else {
-          console.error("[Fynix] Patch error: root is not a DOM Node", root);
-          return;
-        }
-      }
-    } catch (err) {
-      console.error("[Fynix] Mount error:", err);
-      showErrorOverlay(err);
-    } finally {
-      isRendering = false;
-    }
-  }
-  __name(renderApp, "renderApp");
-  rootRenderFn = renderApp;
-  window.__fynix__ = window.__fynix__ || {};
-  window.__fynix__.rerender = renderApp;
-  renderApp();
-  if (import.meta.hot) {
-    if (!window.__fynix__.hmr) {
-      window.__fynix__.hmr = async ({ mod }) => {
+export function mount(AppComponent, root, props = {}) {
+    if (typeof root === "string") {
+        const element = document.querySelector(root);
+        if (!element) {
+            console.error("[Fynix] Mount error: Element not found for selector:", root);
+            return;
+        }
+        root = element;
+    }
+    if (!(root instanceof Element)) {
+        console.error("[Fynix] Mount error: Invalid root element", root);
+        return;
+    }
+    let Component = AppComponent;
+    let oldVNode = null;
+    let currentProps = props;
+    let appVNode = null;
+    let isRendering = false;
+    async function renderApp() {
+        if (isRendering)
+            return;
+        isRendering = true;
         try {
-          const UpdatedComponent = mod.App || mod.default;
-          if (UpdatedComponent) {
-            Component = UpdatedComponent;
-            if (appVNode) {
-              appVNode.type = UpdatedComponent;
+            removeErrorOverlay();
+            const win = window;
+            const propsToUse = win.__lastRouteProps || win.__fynix__?.lastRouteProps || currentProps;
+            if (!appVNode) {
+                appVNode = { type: Component, props: propsToUse, key: null };
+                if (root instanceof Element) {
+                    root.innerHTML = "";
+                    const dom = await createDom(appVNode);
+                    if (dom instanceof Node) {
+                        root.appendChild(dom);
+                    }
+                }
+                else {
+                    console.error("[Fynix] Mount error: root is not a DOM Element", root);
+                    return;
+                }
+                oldVNode = appVNode;
+            }
+            else {
+                appVNode.props = propsToUse;
+                if (root instanceof Node) {
+                    await patch(root, appVNode, oldVNode);
+                    oldVNode = appVNode;
+                }
+                else {
+                    console.error("[Fynix] Patch error: root is not a DOM Node", root);
+                    return;
+                }
             }
-            window.__fynix__.rerender?.();
-          }
-        } catch (err) {
-          console.error("[Fynix HMR] update error:", err);
-          showErrorOverlay(err);
         }
-      };
-      import.meta.hot.accept();
+        catch (err) {
+            console.error("[Fynix] Mount error:", err);
+            showErrorOverlay(err);
+        }
+        finally {
+            isRendering = false;
+        }
+    }
+    rootRenderFn = renderApp;
+    const win = window;
+    win.__fynix__ = win.__fynix__ || {};
+    win.__fynix__.rerender = renderApp;
+    renderApp();
+    if (import.meta.hot) {
+        if (!win.__fynix__.hmr) {
+            win.__fynix__.hmr = async ({ mod }) => {
+                try {
+                    const UpdatedComponent = mod.App || mod.default;
+                    if (UpdatedComponent) {
+                        Component = UpdatedComponent;
+                        if (appVNode) {
+                            appVNode.type = UpdatedComponent;
+                        }
+                        win.__fynix__.rerender?.();
+                    }
+                }
+                catch (err) {
+                    console.error("[Fynix HMR] update error:", err);
+                    showErrorOverlay(err);
+                }
+            };
+            import.meta.hot.accept();
+        }
     }
-  }
 }
-__name(mount, "mount");
-export {
-  Button,
-  Fragment,
-  Fynix,
-  Path,
-  Suspense,
-  TEXT,
-  createFynix,
-  createTextVNode,
-  h,
-  mount,
-  nixAsync,
-  nixAsyncCached,
-  nixAsyncDebounce,
-  nixAsyncQuery,
-  nixCallback,
-  nixComputed,
-  nixDebounce,
-  nixEffect,
-  nixEffectAlways,
-  nixEffectOnce,
-  nixForm,
-  nixFormAsync,
-  nixInterval,
-  nixLazy,
-  nixLazyAsync,
-  nixLazyFormAsync,
-  nixLocalStorage,
-  nixMemo,
-  nixPrevious,
-  nixRef,
-  nixState,
-  nixStore,
-  patch,
-  renderComponent
-};
-//# sourceMappingURL=runtime.js.map
+export { Button, createFynix, nixAsync, nixAsyncCached, nixAsyncDebounce, nixAsyncQuery, nixCallback, nixComputed, nixDebounce, nixEffect, nixEffectAlways, nixEffectOnce, nixForm, nixFormAsync, nixInterval, nixLazy, nixLazyAsync, nixLazyFormAsync, nixLocalStorage, nixMemo, nixPrevious, nixRef, nixState, nixStore, Path, Suspense, };