defuss 2.1.11 → 3.2.0

package/dist/dom-DWDVSwjd.cjs

@@ -0,0 +1,2566 @@
+'use strict';
+
+var defussRuntime = require('defuss-runtime');
+
+class Call {
+  name;
+  fn;
+  args;
+  constructor(name, fn, ...args) {
+    this.name = name;
+    this.fn = fn;
+    this.args = args;
+  }
+}
+const globalRegistry = globalThis;
+if (!globalRegistry.__defuss_nonChainedReturnCallNames) {
+  globalRegistry.__defuss_nonChainedReturnCallNames = [
+    "getFirstElement",
+    "toArray",
+    "map",
+    "isHidden",
+    "isVisible",
+    "hasClass",
+    "dimension",
+    "position",
+    "offset",
+    "prop",
+    "val",
+    "form",
+    "attr",
+    "data",
+    "css",
+    "html",
+    "serialize"
+  ];
+}
+function addNonChainedReturnCallNames(callNames) {
+  const global = globalRegistry.__defuss_nonChainedReturnCallNames;
+  callNames.forEach((name) => {
+    if (!global.includes(name)) {
+      global.push(name);
+    }
+  });
+}
+function getNonChainedReturnCallNames() {
+  return [...globalRegistry.__defuss_nonChainedReturnCallNames];
+}
+function isNonChainedReturnCall(callName) {
+  return globalRegistry.__defuss_nonChainedReturnCallNames.includes(callName);
+}
+const emptyImpl = (nodes) => {
+  nodes.forEach((el) => {
+    const element = el;
+    while (element.firstChild) {
+      element.firstChild.remove();
+    }
+  });
+  return nodes;
+};
+class CallChainImpl {
+  isResolved;
+  options;
+  elementCreationOptions;
+  callStack;
+  resultStack;
+  stackPointer;
+  lastResolvedStackPointer;
+  stoppedWithError;
+  lastResult;
+  length;
+  chainStartTime;
+  chainAsyncStartTime;
+  chainAsyncFinishTime;
+  // SSR-ability
+  document;
+  window;
+  performance;
+  Parser;
+  constructor(options = {}) {
+    this.options = {
+      ...getDefaultDequeryOptions(),
+      ...options
+    };
+    const optionsKeys = Object.keys(getDefaultDequeryOptions());
+    this.options = defussRuntime.pick(this.options, optionsKeys);
+    this.window = this.options.globals.window;
+    this.document = this.options.globals.window.document;
+    this.performance = this.options.globals.performance;
+    this.Parser = this.options.globals.window.DOMParser;
+    const elementCreationOptions = defussRuntime.omit(
+      options,
+      optionsKeys
+    );
+    this.elementCreationOptions = elementCreationOptions;
+    this.callStack = [];
+    this.resultStack = options.resultStack ? [options.resultStack] : [];
+    this.stackPointer = 0;
+    this.lastResolvedStackPointer = 0;
+    this.stoppedWithError = null;
+    this.lastResult = [];
+    this.length = 0;
+    this.isResolved = false;
+    this.chainStartTime = this.performance.now() ?? 0;
+    this.chainAsyncStartTime = 0;
+    this.chainAsyncFinishTime = 0;
+  }
+  get globals() {
+    return this.options.globals;
+  }
+  // sync methods
+  // currently selected nodes
+  get nodes() {
+    return this.resultStack.length > 0 ? this.resultStack[this.resultStack.length - 1] : [];
+  }
+  // allow for for .. of loop
+  [Symbol.iterator]() {
+    return this.nodes[Symbol.iterator]();
+  }
+  // async, direct result method
+  getFirstElement() {
+    return createCall(
+      this,
+      "getFirstElement",
+      async () => this[0]
+    );
+  }
+  // async, wrapped/chainable API methods
+  debug(cb) {
+    return createCall(this, "debug", async () => {
+      cb(this);
+      return this.nodes;
+    });
+  }
+  ref(ref) {
+    return createCall(this, "ref", async () => {
+      if (ref.current) {
+        return [ref.current];
+      }
+      await defussRuntime.waitForRef(ref, this.options.timeout);
+      if (ref.current) {
+        return [ref.current];
+      } else {
+        console.log("\u274C ref() - ref is still null after timeout");
+        throw new Error("Ref is null or undefined after timeout");
+      }
+    });
+  }
+  query(selector) {
+    return createCall(
+      this,
+      "query",
+      async () => {
+        return Array.from(
+          await waitForDOM(
+            () => Array.from(this.document.querySelectorAll(selector)),
+            this.options.timeout,
+            this.document
+          )
+        );
+      },
+      selector
+    );
+  }
+  next() {
+    return traverse(this, "next", (el) => el.nextElementSibling);
+  }
+  prev() {
+    return traverse(this, "prev", (el) => el.previousElementSibling);
+  }
+  find(selector) {
+    return createCall(
+      this,
+      "find",
+      async () => {
+        const results = await Promise.all(
+          this.nodes.map(async (el) => {
+            return await waitForDOM(
+              () => Array.from(el.querySelectorAll(selector)),
+              this.options.timeout,
+              this.document
+            );
+          })
+        );
+        return results.flat();
+      },
+      selector
+    );
+  }
+  parent() {
+    return traverse(this, "parent", (el) => el.parentElement);
+  }
+  children() {
+    return traverse(this, "children", (el) => Array.from(el.children));
+  }
+  closest(selector) {
+    return traverse(this, "closest", (el) => el.closest(selector));
+  }
+  first() {
+    return createCall(this, "first", async () => {
+      return this.nodes.slice(0, 1);
+    });
+  }
+  last() {
+    return createCall(this, "last", async () => {
+      return this.nodes.slice(-1);
+    });
+  }
+  attr(name, value) {
+    return createGetterSetterCall(
+      this,
+      "attr",
+      value,
+      // Getter function
+      () => {
+        if (this.nodes.length === 0) return null;
+        return this.nodes[0].getAttribute(name);
+      },
+      // Setter function
+      (val) => {
+        this.nodes.forEach((el) => el.setAttribute(name, val));
+      }
+    );
+  }
+  prop(name, value) {
+    return createGetterSetterCall(
+      this,
+      "prop",
+      value,
+      // Getter function
+      () => {
+        if (this.nodes.length === 0) return void 0;
+        return this.nodes[0][name];
+      },
+      // Setter function
+      (val) => {
+        this.nodes.forEach((el) => {
+          el[name] = val;
+        });
+      }
+    );
+  }
+  // --- CSS & Class Methods ---
+  static resultCache = /* @__PURE__ */ new WeakMap();
+  css(prop, value) {
+    if (typeof prop === "object") {
+      return createCall(this, "css", async () => {
+        const elements = this.nodes;
+        elements.forEach((el) => {
+          const htmlEl = el;
+          Object.entries(prop).forEach(([key, val]) => {
+            htmlEl.style.setProperty(
+              key.replace(/([A-Z])/g, "-$1").toLowerCase(),
+              String(val)
+            );
+          });
+        });
+        return this.nodes;
+      });
+    }
+    return createGetterSetterCall(
+      this,
+      "css",
+      value,
+      // Getter with caching
+      () => {
+        if (this.nodes.length === 0) return "";
+        const el = this.nodes[0];
+        const cache = CallChainImpl.resultCache.get(el) || /* @__PURE__ */ new Map();
+        const cacheKey = `css:${prop}`;
+        if (cache.has(cacheKey)) {
+          return cache.get(cacheKey);
+        }
+        const result = el.style.getPropertyValue(prop);
+        cache.set(cacheKey, result);
+        CallChainImpl.resultCache.set(el, cache);
+        return result;
+      },
+      // Setter with cache invalidation
+      (val) => {
+        this.nodes.forEach((el) => {
+          el.style.setProperty(prop, String(val));
+          const cache = CallChainImpl.resultCache.get(el);
+          if (cache) {
+            cache.delete(`css:${prop}`);
+          }
+        });
+      }
+    );
+  }
+  addClass(name) {
+    return createCall(this, "addClass", async () => {
+      const list = Array.isArray(name) ? name : [name];
+      this.nodes.forEach((el) => el.classList.add(...list));
+      return this.nodes;
+    });
+  }
+  removeClass(name) {
+    return createCall(this, "removeClass", async () => {
+      const list = Array.isArray(name) ? name : [name];
+      this.nodes.forEach((el) => el.classList.remove(...list));
+      return this.nodes;
+    });
+  }
+  hasClass(name) {
+    return createCall(
+      this,
+      "hasClass",
+      async () => this.nodes.every(
+        (el) => el.classList.contains(name)
+      )
+    );
+  }
+  toggleClass(name) {
+    return createCall(this, "toggleClass", async () => {
+      this.nodes.forEach((el) => el.classList.toggle(name));
+      return this.nodes;
+    });
+  }
+  animateClass(name, duration) {
+    return createCall(this, "animateClass", async () => {
+      this.nodes.forEach((el) => {
+        const e = el;
+        e.classList.add(name);
+        setTimeout(() => e.classList.remove(name), duration);
+      });
+      return this.nodes;
+    });
+  }
+  // --- Content Manipulation Methods ---
+  empty() {
+    return createCall(
+      this,
+      "empty",
+      async () => emptyImpl(this.nodes)
+    );
+  }
+  html(html) {
+    return createGetterSetterCall(
+      this,
+      "html",
+      html,
+      () => {
+        if (this.nodes.length === 0) return "";
+        return this.nodes[0].innerHTML;
+      },
+      (val) => {
+        this.nodes.forEach((el) => {
+          el.innerHTML = val;
+        });
+      }
+    );
+  }
+  jsx(vdom) {
+    if (!isJSX(vdom)) {
+      throw new Error("Invalid JSX input");
+    }
+    return createCall(this, "jsx", async () => {
+      this.nodes.forEach(
+        (el) => updateDomWithVdom(el, vdom, globalThis)
+      );
+      return this.nodes;
+    });
+  }
+  text(text) {
+    return createGetterSetterCall(
+      this,
+      "text",
+      text,
+      // Getter function
+      () => {
+        if (this.nodes.length === 0) return "";
+        return this.nodes[0].textContent || "";
+      },
+      // Setter function
+      (val) => {
+        this.nodes.forEach((el) => {
+          el.textContent = val;
+        });
+      }
+    );
+  }
+  remove() {
+    return createCall(this, "remove", async () => {
+      const removedElements = [...this.nodes];
+      this.nodes.forEach((el) => el.remove());
+      return removedElements;
+    });
+  }
+  replaceWith(content) {
+    return createCall(this, "replaceWith", async () => {
+      const newElements = [];
+      const newElement = await renderNode(content, this);
+      for (const originalEl of this.nodes) {
+        if (!originalEl?.parentNode) continue;
+        if (!newElement) continue;
+        originalEl.parentNode.replaceChild(newElement, originalEl);
+        newElements.push(newElement);
+      }
+      this.resultStack[this.resultStack.length - 1] = newElements;
+      mapArrayIndexAccess(this, this);
+      return newElements;
+    });
+  }
+  append(content) {
+    return createCall(this, "append", async () => {
+      if (content == null) {
+        return this.nodes;
+      }
+      if (content instanceof Node) {
+        this.nodes.forEach((el) => {
+          if (el && content && !el.isEqualNode(content) && el.parentNode !== content) {
+            el.appendChild(content);
+          }
+        });
+        return this.nodes;
+      }
+      const element = await renderNode(content, this);
+      if (!element) return this.nodes;
+      if (isDequery(content)) {
+        this.nodes.forEach((el) => {
+          content.nodes.forEach((childEl) => {
+            if (childEl.nodeType && el.nodeType && !childEl.isEqualNode(el) && el.parentNode !== childEl) {
+              el.appendChild(childEl);
+            }
+          });
+        });
+      } else if (typeof content === "string" && isMarkup(content, this.Parser)) {
+        const elements = renderMarkup(content, this.Parser);
+        this.nodes.forEach((el) => {
+          elements.forEach(
+            (childEl) => el.appendChild(childEl)
+          );
+        });
+      } else {
+        this.nodes.forEach((el) => {
+          if (!element) return;
+          el.appendChild(element);
+        });
+      }
+      return this.nodes;
+    });
+  }
+  appendTo(target) {
+    return createCall(this, "appendTo", async () => {
+      const nodes = await resolveNodes(
+        target,
+        this.options.timeout,
+        this.document
+      );
+      if (nodes.length === 0) {
+        return this.nodes;
+      }
+      nodes.forEach((node) => {
+        this.nodes.forEach((el) => {
+          if (!node || !el) return;
+          node.appendChild(el.cloneNode(true));
+        });
+      });
+      return this.nodes;
+    });
+  }
+  update(input, transitionConfig) {
+    return createCall(this, "update", async () => {
+      return await updateDom(
+        input,
+        this.nodes,
+        this.options.timeout,
+        this.Parser,
+        transitionConfig
+      );
+    });
+  }
+  // --- Event Methods ---
+  on(event, handler) {
+    return createCall(
+      this,
+      "on",
+      async () => {
+        this.nodes.forEach((el) => {
+          addElementEvent(el, event, handler);
+        });
+        return this.nodes;
+      },
+      event,
+      handler
+    );
+  }
+  off(event, handler) {
+    return createCall(this, "off", async () => {
+      this.nodes.forEach((el) => {
+        removeElementEvent(el, event, handler);
+      });
+      return this.nodes;
+    });
+  }
+  clearEvents() {
+    return createCall(this, "clearEvents", async () => {
+      this.nodes.forEach((el) => {
+        clearElementEvents(el);
+      });
+      return this.nodes;
+    });
+  }
+  trigger(eventType) {
+    return createCall(this, "trigger", async () => {
+      this.nodes.forEach(
+        (el) => el.dispatchEvent(
+          new Event(eventType, { bubbles: true, cancelable: true })
+        )
+      );
+      return this.nodes;
+    });
+  }
+  // --- Position Methods ---
+  position() {
+    return createCall(
+      this,
+      "position",
+      async () => ({
+        top: this.nodes[0].offsetTop,
+        left: this.nodes[0].offsetLeft
+      })
+    );
+  }
+  offset() {
+    return createCall(this, "offset", async () => {
+      const el = this.nodes[0];
+      const rect = el.getBoundingClientRect();
+      return {
+        top: rect.top + window.scrollY,
+        left: rect.left + window.scrollX
+      };
+    });
+  }
+  // --- Data Methods ---
+  data(name, value) {
+    return createGetterSetterCall(
+      this,
+      "data",
+      value,
+      // Getter function
+      () => {
+        if (this.nodes.length === 0) return void 0;
+        return this.nodes[0].dataset[name];
+      },
+      // Setter function
+      (val) => {
+        this.nodes.forEach((el) => {
+          el.dataset[name] = val;
+        });
+      }
+    );
+  }
+  val(val) {
+    return createGetterSetterCall(
+      this,
+      "val",
+      val,
+      // Getter function
+      () => {
+        if (this.nodes.length === 0) return "";
+        const el = this.nodes[0];
+        if (el.type === "checkbox") {
+          return el.checked;
+        }
+        return el.value;
+      },
+      // Setter function
+      (value) => {
+        this.nodes.forEach((el) => {
+          const input = el;
+          if (input.type === "checkbox" && typeof value === "boolean") {
+            input.checked = value;
+          } else {
+            input.value = String(value);
+          }
+        });
+      }
+    );
+  }
+  serialize(format = "querystring") {
+    const mapValue = (value) => typeof value === "boolean" ? value ? "on" : "off" : value;
+    return createCall(this, "serialize", async () => {
+      const formData = getAllFormValues(this);
+      if (format === "json") {
+        return JSON.stringify(formData);
+      } else {
+        const urlSearchParams = new URLSearchParams();
+        const keys = Object.keys(formData);
+        keys.forEach((key) => {
+          const value = formData[key];
+          if (typeof value === "string") {
+            urlSearchParams.append(key, value);
+          } else if (typeof value === "boolean") {
+            urlSearchParams.append(key, mapValue(value));
+          } else if (Array.isArray(value)) {
+            value.forEach(
+              (value2) => urlSearchParams.append(key, mapValue(value2))
+            );
+          }
+        });
+        return urlSearchParams.toString();
+      }
+    });
+  }
+  form(formData) {
+    return createGetterSetterCall(
+      this,
+      "form",
+      formData,
+      // Getter function
+      () => getAllFormValues(this),
+      // Setter function
+      (values) => {
+        this.nodes.forEach((el) => {
+          processAllFormElements(el, (input, key) => {
+            if (values[key] !== void 0) {
+              if (input.type === "checkbox") {
+                input.checked = Boolean(values[key]);
+              } else {
+                input.value = String(values[key]);
+              }
+            }
+          });
+        });
+      }
+    );
+  }
+  // --- Dimension Methods ---
+  dimension(includeMarginOrPadding, includePaddingIfMarginTrue) {
+    return createCall(this, "dimension", async () => {
+      if (this.nodes.length === 0) {
+        return { width: 0, height: 0 };
+      }
+      const el = this.nodes[0];
+      const style = this.window.getComputedStyle(el);
+      if (!style) return { width: 0, height: 0 };
+      const rect = el.getBoundingClientRect();
+      let width = rect.width;
+      let height = rect.height;
+      let includeMargin = false;
+      let includePadding = true;
+      if (includePaddingIfMarginTrue !== void 0) {
+        includeMargin = !!includeMarginOrPadding;
+        includePadding = !!includePaddingIfMarginTrue;
+      } else if (includeMarginOrPadding !== void 0) {
+        includePadding = !!includeMarginOrPadding;
+      }
+      if (!includePadding) {
+        const paddingLeft = Number.parseFloat(style.paddingLeft) || 0;
+        const paddingRight = Number.parseFloat(style.paddingRight) || 0;
+        const paddingTop = Number.parseFloat(style.paddingTop) || 0;
+        const paddingBottom = Number.parseFloat(style.paddingBottom) || 0;
+        const borderLeft = Number.parseFloat(style.borderLeftWidth) || 0;
+        const borderRight = Number.parseFloat(style.borderRightWidth) || 0;
+        const borderTop = Number.parseFloat(style.borderTopWidth) || 0;
+        const borderBottom = Number.parseFloat(style.borderBottomWidth) || 0;
+        width -= paddingLeft + paddingRight + borderLeft + borderRight;
+        height -= paddingTop + paddingBottom + borderTop + borderBottom;
+      }
+      if (includeMargin) {
+        const marginLeft = Number.parseFloat(style.marginLeft) || 0;
+        const marginRight = Number.parseFloat(style.marginRight) || 0;
+        const marginTop = Number.parseFloat(style.marginTop) || 0;
+        const marginBottom = Number.parseFloat(style.marginBottom) || 0;
+        const baseWidthForOuter = includePadding ? rect.width : width;
+        const baseHeightForOuter = includePadding ? rect.height : height;
+        const outerWidth = baseWidthForOuter + marginLeft + marginRight;
+        const outerHeight = baseHeightForOuter + marginTop + marginBottom;
+        return {
+          width,
+          height,
+          outerWidth,
+          outerHeight
+        };
+      }
+      return {
+        width,
+        height
+      };
+    });
+  }
+  // --- Visibility Methods ---
+  isVisible() {
+    return createCall(this, "isVisible", async () => {
+      if (this.nodes.length === 0) return false;
+      const el = this.nodes[0];
+      return checkElementVisibility(el, this.window, this.document);
+    });
+  }
+  isHidden() {
+    return createCall(this, "isHidden", async () => {
+      if (this.nodes.length === 0) return true;
+      const el = this.nodes[0];
+      return !checkElementVisibility(el, this.window, this.document);
+    });
+  }
+  // --- Scrolling Methods ---
+  scrollTo(xOrOptions, y) {
+    return createCall(this, "scrollTo", async () => {
+      return scrollHelper("scrollTo", this.nodes, xOrOptions, y);
+    });
+  }
+  scrollBy(xOrOptions, y) {
+    return createCall(this, "scrollBy", async () => {
+      return scrollHelper("scrollBy", this.nodes, xOrOptions, y);
+    });
+  }
+  scrollIntoView(options) {
+    return createCall(this, "scrollIntoView", async () => {
+      if (this.nodes.length === 0) return this.nodes;
+      this.nodes[0].scrollIntoView(options);
+      return this.nodes;
+    });
+  }
+  // --- Transformation Methods ---
+  map(cb) {
+    return createCall(this, "map", async () => {
+      const elements = this.nodes;
+      const results = new Array(elements.length);
+      for (let i = 0; i < elements.length; i++) {
+        results[i] = cb(elements[i], i);
+      }
+      return results;
+    });
+  }
+  toArray() {
+    return createCall(
+      this,
+      "toArray",
+      async () => [...this.nodes]
+    );
+  }
+  filter(selector) {
+    return createCall(
+      this,
+      "filter",
+      async () => this.nodes.filter(
+        (el) => el instanceof Element && el.matches(selector)
+      )
+    );
+  }
+  // --- Cleanup Methods ---
+  /** memory cleanup (chain becomes useless after calling this method) */
+  dispose() {
+    return createCall(this, "dispose", async () => {
+      this.nodes.forEach((el) => {
+        CallChainImpl.resultCache.delete(el);
+      });
+      this.callStack.length = 0;
+      this.resultStack.length = 0;
+      this.stackPointer = 0;
+      this.lastResolvedStackPointer = 0;
+      return void 0;
+    });
+  }
+  ready(callback) {
+    return createCall(this, "ready", async () => {
+      if (this.document.readyState === "complete" || this.document.readyState === "interactive") {
+        if (callback) {
+          callback();
+        }
+        return this.nodes;
+      }
+      const nodes = this.nodes;
+      const document = this.document;
+      return new Promise((resolve) => {
+        const handleDOMContentLoaded = () => {
+          document.removeEventListener(
+            "DOMContentLoaded",
+            handleDOMContentLoaded
+          );
+          if (callback) {
+            callback();
+          }
+          resolve(nodes);
+        };
+        document.addEventListener("DOMContentLoaded", handleDOMContentLoaded);
+      });
+    });
+  }
+  // TODO:
+  // - deserialize (from URL string, JSON, etc.)
+}
+class CallChainImplThenable extends CallChainImpl {
+  constructor(options = {}, isResolved = false) {
+    super(options);
+    this.isResolved = isResolved;
+  }
+  // biome-ignore lint/suspicious/noThenProperty: <explanation>
+  then(onfulfilled, onrejected) {
+    this.chainAsyncStartTime = this.performance.now() ?? 0;
+    if (this.stoppedWithError) {
+      return Promise.reject(this.stoppedWithError).then(
+        onfulfilled,
+        onrejected
+      );
+    }
+    if (this.isResolved && this.stackPointer >= this.callStack.length) {
+      this.lastResolvedStackPointer = this.stackPointer;
+      const lastCallName = this.callStack[this.callStack.length - 1]?.name;
+      let result;
+      if (isNonChainedReturnCall(lastCallName)) {
+        result = this.lastResult;
+      } else {
+        result = createSubChain(this, CallChainImpl, true);
+      }
+      this.chainAsyncFinishTime = (this.performance.now() ?? 0) - this.chainAsyncStartTime;
+      return Promise.resolve(result).then(onfulfilled, onrejected);
+    }
+    return runWithTimeGuard(
+      this.options.timeout,
+      async () => {
+        let call;
+        while (this.stackPointer < this.callStack.length) {
+          call = this.callStack[this.stackPointer];
+          try {
+            const callReturnValue = await call.fn.apply(this);
+            this.lastResult = callReturnValue;
+            if (!isNonChainedReturnCall(call.name)) {
+              this.resultStack.push(callReturnValue);
+            }
+            if (Array.isArray(this.lastResult)) {
+              mapArrayIndexAccess(this, this);
+            }
+            this.stackPointer++;
+          } catch (err) {
+            this.stoppedWithError = err;
+            throw err;
+          }
+        }
+        this.isResolved = true;
+        this.chainAsyncFinishTime = (this.performance.now() ?? 0) - this.chainAsyncStartTime;
+        return this;
+      },
+      [this],
+      // ← Pass the chain context as args[0]
+      // Timeout error handler - called by runWithTimeGuard when timeout is exceeded
+      (ms, call) => {
+        this.stoppedWithError = new Error(
+          `Chain execution timeout after ${ms}ms`
+        );
+      }
+    ).then((result) => {
+      onfulfilled(result);
+      return result;
+    }).catch(onrejected);
+  }
+  catch(onrejected) {
+    return this.then(void 0, onrejected);
+  }
+  finally(onfinally) {
+    return this.then(
+      (value) => {
+        onfinally?.();
+        return value;
+      },
+      (reason) => {
+        onfinally?.();
+        throw reason;
+      }
+    );
+  }
+}
+function scrollHelper(methodName, elements, xOrOptions, y) {
+  elements.forEach((el) => {
+    const element = el;
+    if (typeof xOrOptions === "object") {
+      element[methodName](xOrOptions);
+    } else if (y !== void 0) {
+      element[methodName](xOrOptions, y);
+    } else {
+      element[methodName](xOrOptions, 0);
+    }
+  });
+  return elements;
+}
+function getAllFormValues(chain) {
+  const formFields = {};
+  const mapCheckboxValue = (value) => value === "on" ? true : value;
+  chain.nodes.forEach((el) => {
+    processAllFormElements(el, (input, key) => {
+      if (!key) return;
+      if (input instanceof HTMLInputElement) {
+        if (input.type === "checkbox") {
+          if (input.checked) {
+            const value = mapCheckboxValue(input.value);
+            if (typeof formFields[key] !== "undefined") {
+              formFields[key] = [formFields[key], value];
+            } else if (Array.isArray(formFields[key])) {
+              formFields[key].push(value);
+            } else {
+              formFields[key] = value;
+            }
+          }
+        } else if (input.type === "radio") {
+          if (input.checked) {
+            formFields[key] = input.value === "on" ? true : input.value;
+          }
+        } else if (input.type === "file") {
+          if (input.files?.length) {
+            const fileNames = Array.from(input.files).map((file) => file.name);
+            formFields[key] = fileNames.length === 1 ? fileNames[0] : fileNames;
+          }
+        } else {
+          formFields[key] = input.value;
+        }
+      } else if (input instanceof HTMLSelectElement) {
+        if (input.multiple) {
+          const values = Array.from(input.selectedOptions).map(
+            (option) => option.value
+          );
+          formFields[key] = values.length === 1 ? values[0] : values;
+        } else {
+          formFields[key] = input.value;
+        }
+      } else if (input instanceof HTMLTextAreaElement) {
+        formFields[key] = input.value;
+      }
+    });
+  });
+  return formFields;
+}
+function delayedAutoStart(chain) {
+  if (chain.options.autoStart) {
+    setTimeout(async () => {
+      if (chain.chainAsyncStartTime === 0) {
+        chain = await chain;
+      }
+    }, chain.options.autoStartDelay);
+  }
+  return chain;
+}
+function dequery(selectorRefOrEl, options = getDefaultDequeryOptions()) {
+  if (typeof selectorRefOrEl === "function") {
+    const syncChain = dequery("body", options);
+    queueMicrotask(async () => {
+      const result = await selectorRefOrEl();
+      if (!syncChain.isResolved) {
+        if (typeof result !== "undefined") {
+          const newChain = dequery(result, options);
+          syncChain.resultStack = newChain.resultStack;
+          syncChain.lastResult = newChain.lastResult;
+          mapArrayIndexAccess(newChain, syncChain);
+        }
+      }
+    });
+    return delayedAutoStart(syncChain);
+  }
+  const chain = new CallChainImplThenable({
+    ...options,
+    resultStack: []
+  });
+  if (!selectorRefOrEl)
+    throw new Error("dequery: selector/ref/element required");
+  if (typeof selectorRefOrEl === "string") {
+    if (selectorRefOrEl.indexOf("<") === 0) {
+      const elements = renderMarkup(selectorRefOrEl, chain.Parser);
+      const renderRootEl = elements[0];
+      const { text, html, ...attributes } = chain.elementCreationOptions;
+      if (renderRootEl instanceof Element) {
+        Object.entries(attributes).forEach(([key, value]) => {
+          renderRootEl.setAttribute(key, String(value));
+        });
+        if (html) {
+          renderRootEl.innerHTML = html;
+        } else if (text) {
+          renderRootEl.textContent = text;
+        }
+      }
+      chain.resultStack = [elements];
+      return delayedAutoStart(chain);
+    } else {
+      return delayedAutoStart(
+        chain.query(selectorRefOrEl)
+      );
+    }
+  } else if (isRef(selectorRefOrEl)) {
+    return delayedAutoStart(
+      chain.ref(selectorRefOrEl)
+    );
+  } else if (selectorRefOrEl.nodeType) {
+    chain.resultStack = [[selectorRefOrEl]];
+    return delayedAutoStart(chain);
+  } else if (isJSX(selectorRefOrEl)) {
+    const renderResult = renderIsomorphicSync(
+      selectorRefOrEl,
+      chain.document.body,
+      chain.globals
+    );
+    const elements = typeof renderResult !== "undefined" ? Array.isArray(renderResult) ? renderResult : [renderResult] : [];
+    chain.resultStack = [elements];
+    return delayedAutoStart(chain);
+  }
+  throw new Error("Unsupported selectorOrEl type");
+}
+dequery.extend = (ExtensionClass, nonChainedReturnCalls = []) => {
+  const extensionPrototype = ExtensionClass.prototype;
+  const basePrototype = CallChainImpl.prototype;
+  const extensionMethods = Object.getOwnPropertyNames(extensionPrototype);
+  const baseMethods = Object.getOwnPropertyNames(basePrototype);
+  extensionMethods.forEach((methodName) => {
+    if (methodName !== "constructor" && !baseMethods.includes(methodName) && typeof extensionPrototype[methodName] === "function") {
+      CallChainImpl.prototype[methodName] = extensionPrototype[methodName];
+      CallChainImplThenable.prototype[methodName] = extensionPrototype[methodName];
+    }
+  });
+  if (nonChainedReturnCalls.length > 0) {
+    addNonChainedReturnCallNames(nonChainedReturnCalls);
+  }
+  return (selectorRefOrEl, options) => {
+    return dequery(
+      selectorRefOrEl,
+      options
+    );
+  };
+};
+const $ = dequery;
+function isDequery(obj) {
+  return typeof obj === "object" && obj !== null && "isResolved" in obj && "lastResult" in obj && "resultStack" in obj && "callStack" in obj && "stackPointer" in obj;
+}
+function isDequeryOptionsObject(o) {
+  return o && typeof o === "object" && o.timeout !== void 0 && o.globals !== void 0;
+}
+let defaultOptions = null;
+function getDefaultDequeryOptions() {
+  if (!defaultOptions) {
+    defaultOptions = {
+      timeout: 5e3,
+      // even long sync chains would execute in < .1ms
+      // so after 1ms, we can assume the "await" in front is
+      // missing (intentionally non-blocking in sync code)
+      autoStartDelay: 1,
+      autoStart: true,
+      resultStack: [],
+      globals: {
+        document: globalThis.document,
+        window: globalThis.window,
+        performance: globalThis.performance
+      }
+    };
+  }
+  return { ...defaultOptions };
+}
+function mapArrayIndexAccess(source, target) {
+  const elements = source.nodes;
+  for (let i = 0; i < elements.length; i++) {
+    target[i] = elements[i];
+  }
+  target.length = elements.length;
+}
+function createCall(chain, methodName, handler, ...callArgs) {
+  chain.callStack.push(new Call(methodName, handler, ...callArgs));
+  return subChainForNextAwait(chain);
+}
+function createGetterSetterCall(chain, methodName, value, getter, setter) {
+  if (value !== void 0) {
+    return createCall(chain, methodName, async () => {
+      setter(value);
+      return chain.nodes;
+    });
+  } else {
+    return createCall(chain, methodName, async () => {
+      return getter();
+    });
+  }
+}
+function createSubChain(source, Constructor = CallChainImpl, isResolved = false) {
+  const subChain = new Constructor(source.options);
+  subChain.callStack = source.callStack;
+  subChain.resultStack = source.resultStack;
+  subChain.stackPointer = source.stackPointer;
+  subChain.stoppedWithError = source.stoppedWithError;
+  subChain.lastResult = source.lastResult;
+  subChain.isResolved = typeof isResolved !== "undefined" ? isResolved : source.isResolved;
+  subChain.lastResolvedStackPointer = source.lastResolvedStackPointer;
+  if (Array.isArray(subChain.lastResult)) {
+    mapArrayIndexAccess(source, subChain);
+  }
+  return delayedAutoStart(subChain);
+}
+function subChainForNextAwait(source) {
+  if (source.lastResolvedStackPointer) {
+    source.callStack = source.callStack.slice(source.lastResolvedStackPointer);
+    source.stackPointer = source.stackPointer - source.lastResolvedStackPointer;
+    source.resultStack = source.resultStack.slice(
+      source.lastResolvedStackPointer
+    );
+    source.lastResult = source.resultStack[source.resultStack.length - 1] || [];
+    source.lastResolvedStackPointer = 0;
+    source.stoppedWithError = null;
+  }
+  return source instanceof CallChainImplThenable ? source : createSubChain(source, CallChainImplThenable);
+}
+function runWithTimeGuard(timeout, fn, args, onError) {
+  const operationId = Math.random().toString(36).substr(2, 9);
+  return defussRuntime.createTimeoutPromise(
+    timeout,
+    async () => {
+      const chainContext = args[0];
+      if (chainContext?.callStack && chainContext.stackPointer !== void 0) {
+        chainContext.callStack.slice(chainContext.stackPointer).map((call) => call.name).join(" -> ");
+      }
+      const result = await fn(...args);
+      return result;
+    },
+    (ms) => {
+      console.log(`\u{1F534} TIMEOUT [${operationId}] after ${ms}ms`);
+      const chainContext = args[0];
+      if (chainContext?.callStack && chainContext.stackPointer !== void 0) {
+        const currentCall = chainContext.callStack[chainContext.stackPointer];
+        const remainingCalls = chainContext.callStack.slice(chainContext.stackPointer).map((call) => `${call.name}(${call.args.join(", ")})`).join(" -> ");
+        console.log(
+          `\u{1F534} TIMEOUT occurred during call: ${currentCall?.name || "unknown"}`
+        );
+        console.log(`\u{1F534} Remaining calls were: ${remainingCalls}`);
+      } else {
+        console.log("\u{1F534} Call stack at timeout: unknown");
+      }
+      const fakeCall = new Call("timeout", async () => []);
+      onError(ms, fakeCall);
+    }
+  );
+}
+async function renderNode(input, chain) {
+  if (input == null) {
+    return null;
+  }
+  if (typeof input === "string") {
+    if (isMarkup(input, chain.Parser)) {
+      return renderMarkup(input, chain.Parser)[0];
+    } else {
+      return chain.document.createTextNode(input);
+    }
+  } else if (isJSX(input)) {
+    return renderIsomorphicSync(
+      input,
+      chain.document.body,
+      chain.options.globals
+    );
+  } else if (isRef(input)) {
+    await defussRuntime.waitForRef(input, chain.options.timeout);
+    return input.current;
+  } else if (input && typeof input === "object" && "nodeType" in input) {
+    return input;
+  } else if (isDequery(input)) {
+    return await input.getFirstElement();
+  }
+  console.warn("resolveContent: unsupported content type", input);
+  return null;
+}
+async function resolveNodes(input, timeout, document) {
+  let nodes = [];
+  if (isRef(input)) {
+    await defussRuntime.waitForRef(input, timeout);
+    nodes = [input.current];
+  } else if (typeof input === "string" && document) {
+    const result = await waitForDOM(
+      () => {
+        const el2 = document.querySelector(input);
+        if (el2) {
+          return [el2];
+        } else {
+          return [];
+        }
+      },
+      timeout,
+      document
+    );
+    const el = result[0];
+    if (el) nodes = [el];
+  } else if (input && typeof input === "object" && "nodeType" in input) {
+    nodes = [input];
+  } else if (isDequery(input)) {
+    const elements = input.nodes;
+    nodes = elements.filter((el) => el.nodeType !== void 0).map((el) => el);
+  } else {
+    console.warn("resolveTargets: expected selector, ref or node, got", input);
+  }
+  return nodes;
+}
+function traverse(chain, methodName, selector) {
+  return createCall(chain, methodName, async () => {
+    return chain.nodes.flatMap((el) => {
+      if (el instanceof Element) {
+        try {
+          const result = selector(el);
+          if (Array.isArray(result)) {
+            return result.filter(
+              (item) => item instanceof Element
+            );
+          } else if (result instanceof Element) {
+            return [result];
+          }
+        } catch (err) {
+          console.warn("Error in traverse selector function:", err);
+        }
+      }
+      return [];
+    });
+  });
+}
+
+const newInMemoryGenericStorageBackend = () => {
+  const cache = /* @__PURE__ */ new Map();
+  return {
+    clear: () => {
+      cache.clear();
+    },
+    getItem: (key) => {
+      return cache.get(String(key)) ?? null;
+    },
+    removeItem: (key) => {
+      cache.delete(String(key));
+    },
+    setItem: (key, value) => {
+      cache.set(String(key), value);
+    }
+  };
+};
+const memory = newInMemoryGenericStorageBackend();
+class WebStorageProvider {
+  storage;
+  constructor(storage) {
+    this.storage = storage || memory;
+  }
+  get(key, defaultValue, middlewareFn) {
+    const rawValue = this.storage.getItem(key);
+    if (rawValue === null) return defaultValue;
+    let value = JSON.parse(rawValue);
+    if (middlewareFn) {
+      value = middlewareFn(key, value);
+    }
+    return value;
+  }
+  set(key, value, middlewareFn) {
+    if (middlewareFn) {
+      value = middlewareFn(key, value);
+    }
+    this.storage.setItem(key, JSON.stringify(value));
+  }
+  remove(key) {
+    this.storage.removeItem(key);
+  }
+  removeAll() {
+    this.storage.clear();
+  }
+  get backendApi() {
+    return this.storage;
+  }
+}
+
+const getPersistenceProvider$1 = (provider, _options) => {
+  switch (provider) {
+    case "session":
+      return new WebStorageProvider(window.sessionStorage);
+    case "local":
+      return new WebStorageProvider(window.localStorage);
+  }
+  return new WebStorageProvider();
+};
+
+const getPersistenceProvider = (_provider, _options) => {
+  return new WebStorageProvider();
+};
+
+const isServer = () => typeof window === "undefined" || typeof window.document === "undefined";
+
+const webstorage = (provider = "local", options) => {
+  if (isServer()) {
+    return getPersistenceProvider();
+  } else {
+    return getPersistenceProvider$1(provider);
+  }
+};
+
+const createStore = (initialValue) => {
+  let value = initialValue;
+  const listeners = [];
+  const notify = (oldValue, changedKey) => {
+    listeners.forEach((listener) => listener(value, oldValue, changedKey));
+  };
+  let storage = null;
+  let storageKey = null;
+  let storageProvider;
+  const initStorage = (provider) => {
+    if (!storage || storageProvider !== provider) {
+      storage = webstorage(provider);
+      storageProvider = provider;
+    }
+    return storage;
+  };
+  const persistToStorage = () => {
+    if (storage && storageKey) {
+      storage.set(storageKey, value);
+    }
+  };
+  return {
+    // allow reading value but prevent external mutation
+    get value() {
+      return value;
+    },
+    persist(key, provider = "local") {
+      storage = initStorage(provider);
+      storageKey = key;
+      persistToStorage();
+    },
+    restore(key, provider = "local") {
+      storage = initStorage(provider);
+      storageKey = key;
+      const storedValue = storage.get(key, value);
+      const valueAsString = JSON.stringify(value);
+      const storedValueAsString = JSON.stringify(storedValue);
+      if (valueAsString !== storedValueAsString) {
+        value = storedValue;
+        notify(value);
+      }
+    },
+    get(path) {
+      return path ? defussRuntime.getByPath(value, path) : value;
+    },
+    set(pathOrValue, newValue) {
+      const oldValue = value;
+      if (newValue === void 0) {
+        const valueAsString = JSON.stringify(value);
+        const newValueAsString = JSON.stringify(pathOrValue);
+        if (valueAsString !== newValueAsString) {
+          value = pathOrValue;
+          notify(oldValue);
+          persistToStorage();
+        }
+      } else {
+        const updatedValue = defussRuntime.setByPath(value, pathOrValue, newValue);
+        const updatedValueAsString = JSON.stringify(updatedValue);
+        const oldValueAsString = JSON.stringify(oldValue);
+        if (oldValueAsString !== updatedValueAsString) {
+          value = updatedValue;
+          notify(oldValue, pathOrValue);
+          persistToStorage();
+        }
+      }
+    },
+    subscribe(listener) {
+      listeners.push(listener);
+      return () => {
+        const index = listeners.indexOf(listener);
+        if (index >= 0) listeners.splice(index, 1);
+      };
+    }
+  };
+};
+
+const isRef = (obj) => Boolean(obj && typeof obj === "object" && "current" in obj);
+function createRef(refUpdateFn, defaultState) {
+  const stateStore = createStore(defaultState);
+  const ref = {
+    current: null,
+    store: stateStore,
+    get state() {
+      return stateStore.value;
+    },
+    set state(value) {
+      stateStore.set(value);
+    },
+    persist: (key, provider = "local") => {
+      stateStore.persist(key, provider);
+    },
+    restore: (key, provider = "local") => {
+      stateStore.restore(key, provider);
+    },
+    updateState: (state) => {
+      stateStore.set(state);
+    },
+    update: async (input) => await $(ref.current).update(input),
+    subscribe: (refUpdateFn2) => stateStore.subscribe(refUpdateFn2)
+  };
+  if (typeof refUpdateFn === "function") {
+    ref.subscribe(refUpdateFn);
+  }
+  return ref;
+}
+
+const injectShakeKeyframes = () => {
+  if (!document.getElementById("defuss-shake")) {
+    const style = document.createElement("style");
+    style.id = "defuss-shake";
+    style.textContent = "@keyframes shake{0%,100%{transform:translate3d(0,0,0)}10%,30%,50%,70%,90%{transform:translate3d(-10px,0,0)}20%,40%,60%,80%{transform:translate3d(10px,0,0)}}";
+    document.head.appendChild(style);
+  }
+};
+const getTransitionStyles = (type, duration, easing = "ease-in-out") => {
+  const t = `transform ${duration}ms ${easing}, opacity ${duration}ms ${easing}`;
+  const styles = {
+    fade: {
+      enter: { opacity: "0", transition: t, transform: "translate3d(0,0,0)" },
+      enterActive: { opacity: "1" },
+      exit: { opacity: "1", transition: t, transform: "translate3d(0,0,0)" },
+      exitActive: { opacity: "0" }
+    },
+    "slide-left": {
+      enter: {
+        transform: "translate3d(100%,0,0)",
+        opacity: "0.5",
+        transition: t
+      },
+      enterActive: { transform: "translate3d(0,0,0)", opacity: "1" },
+      exit: { transform: "translate3d(0,0,0)", opacity: "1", transition: t },
+      exitActive: { transform: "translate3d(-100%,0,0)", opacity: "0.5" }
+    },
+    "slide-right": {
+      enter: {
+        transform: "translate3d(-100%,0,0)",
+        opacity: "0.5",
+        transition: t
+      },
+      enterActive: { transform: "translate3d(0,0,0)", opacity: "1" },
+      exit: { transform: "translate3d(0,0,0)", opacity: "1", transition: t },
+      exitActive: { transform: "translate3d(100%,0,0)", opacity: "0.5" }
+    },
+    shake: (() => {
+      injectShakeKeyframes();
+      return {
+        enter: {
+          transform: "translate3d(0,0,0)",
+          opacity: "1",
+          transition: "none"
+        },
+        enterActive: {
+          transform: "translate3d(0,0,0)",
+          opacity: "1",
+          animation: `shake ${duration}ms cubic-bezier(0.36,0.07,0.19,0.97)`
+        },
+        exit: {
+          transform: "translate3d(0,0,0)",
+          opacity: "1",
+          transition: "none"
+        },
+        exitActive: {
+          transform: "translate3d(0,0,0)",
+          opacity: "1",
+          animation: `shake ${duration}ms cubic-bezier(0.36,0.07,0.19,0.97)`
+        }
+      };
+    })()
+  };
+  return styles[type] || { enter: {}, enterActive: {}, exit: {}, exitActive: {} };
+};
+const applyStyles = (el, styles) => Object.entries(styles).forEach(
+  ([k, v]) => el.style.setProperty(k, String(v))
+);
+const DEFAULT_TRANSITION_CONFIG = {
+  type: "fade",
+  duration: 300,
+  easing: "ease-in-out",
+  delay: 0,
+  target: "parent"
+};
+const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+const performCrossfade = async (element, updateCallback, duration, easing) => {
+  const originalStyle = element.style.cssText;
+  const snapshot = element.cloneNode(true);
+  try {
+    const container = element.parentElement || element;
+    const rect = element.getBoundingClientRect();
+    snapshot.style.cssText = `position:absolute;top:${rect.top}px;left:${rect.left}px;width:${rect.width}px;height:${rect.height}px;opacity:1;transition:opacity ${duration}ms ${easing};z-index:1000;`;
+    element.style.opacity = "0";
+    element.style.transition = `opacity ${duration}ms ${easing}`;
+    document.body.appendChild(snapshot);
+    await updateCallback();
+    void element.offsetHeight;
+    snapshot.style.opacity = "0";
+    element.style.opacity = "1";
+    await wait(duration);
+    document.body.removeChild(snapshot);
+  } catch (error) {
+    if (snapshot.parentElement) document.body.removeChild(snapshot);
+    throw error;
+  } finally {
+    element.style.cssText = originalStyle;
+  }
+};
+const performTransition = async (element, updateCallback, config = {}) => {
+  const {
+    type = "fade",
+    duration = 300,
+    easing = "ease-in-out",
+    delay = 0
+  } = { ...DEFAULT_TRANSITION_CONFIG, ...config };
+  if (type === "none") {
+    await updateCallback();
+    return;
+  }
+  if (delay > 0) await wait(delay);
+  if (type === "fade") {
+    await performCrossfade(element, updateCallback, duration, easing);
+    return;
+  }
+  const styles = config.styles || getTransitionStyles(type, duration, easing);
+  const originalTransition = element.style.transition;
+  const originalAnimation = element.style.animation;
+  try {
+    if (type === "shake") {
+      element.style.animation = "none";
+      void element.offsetHeight;
+    }
+    applyStyles(element, styles.exit);
+    void element.offsetHeight;
+    applyStyles(element, styles.exitActive);
+    await wait(duration);
+    await updateCallback();
+    applyStyles(element, styles.enter);
+    void element.offsetHeight;
+    applyStyles(element, styles.enterActive);
+    await wait(duration);
+    element.style.transition = originalTransition;
+    element.style.animation = originalAnimation;
+  } catch (error) {
+    element.style.transition = originalTransition;
+    element.style.animation = originalAnimation;
+    throw error;
+  }
+};
+
+const CAPTURE_ONLY_EVENTS = /* @__PURE__ */ new Set([
+  "focus",
+  "blur",
+  "scroll",
+  "mouseenter",
+  "mouseleave",
+  "focusin",
+  "focusout"
+]);
+const elementHandlerMap = /* @__PURE__ */ new WeakMap();
+const installedDocListeners = /* @__PURE__ */ new WeakMap();
+const parseEventPropName = (propName) => {
+  if (!propName.startsWith("on")) return null;
+  const raw = propName.slice(2);
+  if (!raw) return null;
+  const lower = raw.toLowerCase();
+  const isCapture = lower.endsWith("capture");
+  const eventType = isCapture ? lower.slice(0, -"capture".length) : lower;
+  if (!eventType) return null;
+  return { eventType, capture: isCapture };
+};
+const getOrCreateElementHandlers = (el) => {
+  const existing = elementHandlerMap.get(el);
+  if (existing) return existing;
+  const created = /* @__PURE__ */ new Map();
+  elementHandlerMap.set(el, created);
+  return created;
+};
+const getEventPath = (event) => {
+  const composedPath = event.composedPath?.();
+  if (composedPath && composedPath.length > 0) return composedPath;
+  const path = [];
+  let node = event.target;
+  while (node) {
+    path.push(node);
+    const maybeNode = node;
+    if (typeof maybeNode === "object" && maybeNode && "parentNode" in maybeNode) {
+      node = maybeNode.parentNode;
+      continue;
+    }
+    break;
+  }
+  const doc = event.target?.ownerDocument;
+  if (doc && path[path.length - 1] !== doc) path.push(doc);
+  const win = doc?.defaultView;
+  if (win && path[path.length - 1] !== win) path.push(win);
+  return path;
+};
+const ensureDocumentListener = (doc, eventType, phase) => {
+  const installed = installedDocListeners.get(doc) ?? /* @__PURE__ */ new Set();
+  installedDocListeners.set(doc, installed);
+  const key = `${eventType}:${phase}`;
+  if (installed.has(key)) return;
+  const useCapture = phase === "capture";
+  const handler = (event) => {
+    const path = getEventPath(event).filter(
+      (t) => typeof t === "object" && t !== null && t.nodeType === Node.ELEMENT_NODE
+    );
+    const ordered = phase === "capture" ? [...path].reverse() : path;
+    for (const target of ordered) {
+      const handlersByEvent = elementHandlerMap.get(target);
+      if (!handlersByEvent) continue;
+      const entry = handlersByEvent.get(eventType);
+      if (!entry) continue;
+      const fn = phase === "capture" ? entry.capture : entry.bubble;
+      if (!fn) continue;
+      fn.call(target, event);
+      if (event.cancelBubble) return;
+    }
+  };
+  doc.addEventListener(eventType, handler, useCapture);
+  installed.add(key);
+};
+const registerDelegatedEvent = (element, eventType, handler, options = {}) => {
+  const doc = element.ownerDocument ?? globalThis.document;
+  const capture = options.capture || CAPTURE_ONLY_EVENTS.has(eventType);
+  ensureDocumentListener(doc, eventType, capture ? "capture" : "bubble");
+  const byEvent = getOrCreateElementHandlers(element);
+  const entry = byEvent.get(eventType) ?? {};
+  byEvent.set(eventType, entry);
+  if (capture) {
+    entry.capture = handler;
+  } else {
+    entry.bubble = handler;
+  }
+};
+const removeDelegatedEvent = (element, eventType, options = {}) => {
+  const capture = options.capture || CAPTURE_ONLY_EVENTS.has(eventType);
+  const byEvent = elementHandlerMap.get(element);
+  if (!byEvent) return;
+  const entry = byEvent.get(eventType);
+  if (!entry) return;
+  if (capture) {
+    entry.capture = void 0;
+  } else {
+    entry.bubble = void 0;
+  }
+  if (!entry.capture && !entry.bubble) {
+    byEvent.delete(eventType);
+  }
+};
+const clearDelegatedEvents = (element) => {
+  const byEvent = elementHandlerMap.get(element);
+  if (!byEvent) return;
+  byEvent.clear();
+};
+
+const queueCallback = (cb) => () => queueMicrotask(cb);
+
+const CLASS_ATTRIBUTE_NAME = "class";
+const XLINK_ATTRIBUTE_NAME = "xlink";
+const XMLNS_ATTRIBUTE_NAME = "xmlns";
+const REF_ATTRIBUTE_NAME = "ref";
+const DANGEROUSLY_SET_INNER_HTML_ATTRIBUTE = "dangerouslySetInnerHTML";
+const nsMap = {
+  [XMLNS_ATTRIBUTE_NAME]: "http://www.w3.org/2000/xmlns/",
+  [XLINK_ATTRIBUTE_NAME]: "http://www.w3.org/1999/xlink",
+  svg: "http://www.w3.org/2000/svg"
+};
+const isJSXComment = (node) => (
+  /* v8 ignore next */
+  node && typeof node === "object" && !node.attributes && !node.type && !node.children
+);
+const filterComments = (children) => children.filter((child) => !isJSXComment(child));
+const createInPlaceErrorMessageVNode = (error) => ({
+  type: "p",
+  attributes: {},
+  children: [`FATAL ERROR: ${error?.message || error}`]
+});
+const jsx = (type, attributes, key, sourceInfo) => {
+  attributes = { ...attributes };
+  if (typeof key !== "undefined") {
+    attributes.key = key;
+  }
+  let children = (attributes?.children ? [].concat(attributes.children) : []).filter(Boolean);
+  delete attributes?.children;
+  children = filterComments(
+    // Implementation to flatten virtual node children structures like:
+    // [<p>1</p>, [<p>2</p>,<p>3</p>]] to: [<p>1</p>,<p>2</p>,<p>3</p>]
+    [].concat.apply(
+      [],
+      children
+    )
+  );
+  if (type === "fragment") {
+    return filterComments(children);
+  }
+  if (typeof type === "function" && type.constructor.name !== "AsyncFunction") {
+    try {
+      return type({
+        children,
+        ...attributes
+      });
+    } catch (error) {
+      if (typeof error === "string") {
+        error = `[JsxError] in ${type.name}: ${error}`;
+      } else if (error instanceof Error) {
+        error.message = `[JsxError] in ${type.name}: ${error.message}`;
+      }
+      return createInPlaceErrorMessageVNode(error);
+    }
+  }
+  return {
+    type,
+    attributes,
+    children,
+    sourceInfo
+  };
+};
+const observeUnmount = (domNode, onUnmount) => {
+  if (!domNode || typeof onUnmount !== "function") {
+    throw new Error(
+      "Invalid arguments. Ensure domNode and onUnmount are valid."
+    );
+  }
+  const parentNode = domNode.parentNode;
+  if (!parentNode) {
+    throw new Error("The provided domNode does not have a parentNode.");
+  }
+  const observer = new MutationObserver((mutationsList) => {
+    for (const mutation of mutationsList) {
+      if (mutation.removedNodes.length > 0) {
+        for (const removedNode of mutation.removedNodes) {
+          if (removedNode === domNode) {
+            onUnmount();
+            observer.disconnect();
+            return;
+          }
+        }
+      }
+    }
+  });
+  observer.observe(parentNode, { childList: true });
+};
+const handleLifecycleEventsForOnMount = (newEl) => {
+  if (typeof newEl?.$onMount === "function") {
+    newEl.$onMount();
+    newEl.$onMount = null;
+  }
+  if (typeof newEl?.$onUnmount === "function") {
+    observeUnmount(newEl, newEl.$onUnmount);
+  }
+};
+const getRenderer = (document) => {
+  const renderer = {
+    hasElNamespace: (domElement) => domElement.namespaceURI === nsMap.svg,
+    hasSvgNamespace: (parentElement, type) => renderer.hasElNamespace(parentElement) && type !== "STYLE" && type !== "SCRIPT",
+    createElementOrElements: (virtualNode, parentDomElement) => {
+      if (Array.isArray(virtualNode)) {
+        return renderer.createChildElements(virtualNode, parentDomElement);
+      }
+      if (typeof virtualNode !== "undefined") {
+        return renderer.createElement(virtualNode, parentDomElement);
+      }
+      return renderer.createTextNode("", parentDomElement);
+    },
+    createElement: (virtualNode, parentDomElement) => {
+      let newEl = void 0;
+      try {
+        if (virtualNode.constructor.name === "AsyncFunction") {
+          newEl = document.createElement("div");
+        } else if (typeof virtualNode.type === "function") {
+          newEl = document.createElement("div");
+          newEl.innerText = `FATAL ERROR: ${virtualNode.type._error}`;
+        } else if (
+          // SVG support
+          virtualNode.type.toUpperCase() === "SVG" || parentDomElement && renderer.hasSvgNamespace(
+            parentDomElement,
+            virtualNode.type.toUpperCase()
+          )
+        ) {
+          newEl = document.createElementNS(
+            nsMap.svg,
+            virtualNode.type
+          );
+        } else {
+          newEl = document.createElement(virtualNode.type);
+        }
+        if (virtualNode.attributes) {
+          renderer.setAttributes(virtualNode, newEl);
+          if (virtualNode.attributes.dangerouslySetInnerHTML) {
+            newEl.innerHTML = virtualNode.attributes.dangerouslySetInnerHTML.__html;
+          }
+        }
+        if (virtualNode.children) {
+          renderer.createChildElements(virtualNode.children, newEl);
+        }
+        if (parentDomElement) {
+          parentDomElement.appendChild(newEl);
+          handleLifecycleEventsForOnMount(newEl);
+        }
+      } catch (e) {
+        console.error(
+          "Fatal error! Error happend while rendering the VDOM!",
+          e,
+          virtualNode
+        );
+        throw e;
+      }
+      return newEl;
+    },
+    createTextNode: (text, domElement) => {
+      const node = document.createTextNode(text.toString());
+      if (domElement) {
+        domElement.appendChild(node);
+      }
+      return node;
+    },
+    createChildElements: (virtualChildren, domElement) => {
+      const children = [];
+      for (let i = 0; i < virtualChildren.length; i++) {
+        const virtualChild = virtualChildren[i];
+        if (virtualChild === null || typeof virtualChild !== "object" && typeof virtualChild !== "function") {
+          children.push(
+            renderer.createTextNode(
+              (typeof virtualChild === "undefined" || virtualChild === null ? "" : virtualChild).toString(),
+              domElement
+            )
+          );
+        } else {
+          children.push(
+            renderer.createElement(virtualChild, domElement)
+          );
+        }
+      }
+      return children;
+    },
+    setAttribute: (name, value, domElement, virtualNode) => {
+      if (typeof value === "undefined") return;
+      if (name === DANGEROUSLY_SET_INNER_HTML_ATTRIBUTE) return;
+      if (name === "key") {
+        domElement._defussKey = String(value);
+        return;
+      }
+      if (name === REF_ATTRIBUTE_NAME && typeof value !== "function") {
+        const ref = value;
+        ref.current = domElement;
+        domElement._defussRef = value;
+        domElement.$onUnmount = queueCallback(() => {
+        });
+        if (domElement.parentNode) {
+          observeUnmount(domElement, domElement.$onUnmount);
+        } else {
+          queueMicrotask(() => {
+            if (domElement.parentNode) {
+              observeUnmount(domElement, domElement.$onUnmount);
+            }
+          });
+        }
+        return;
+      }
+      const parsed = parseEventPropName(name);
+      if (parsed && typeof value === "function") {
+        const { eventType, capture } = parsed;
+        if (eventType === "mount") {
+          domElement.$onMount = queueCallback(value);
+          return;
+        }
+        if (eventType === "unmount") {
+          if (domElement.$onUnmount) {
+            const existingUnmount = domElement.$onUnmount;
+            domElement.$onUnmount = () => {
+              existingUnmount();
+              value();
+            };
+          } else {
+            domElement.$onUnmount = queueCallback(value);
+          }
+          return;
+        }
+        registerDelegatedEvent(domElement, eventType, value, { capture });
+        return;
+      }
+      if (name === "className") {
+        name = CLASS_ATTRIBUTE_NAME;
+      }
+      if (name === CLASS_ATTRIBUTE_NAME && Array.isArray(value)) {
+        value = value.join(" ");
+      }
+      const nsEndIndex = name.match(/[A-Z]/)?.index;
+      if (renderer.hasElNamespace(domElement) && nsEndIndex) {
+        const ns = name.substring(0, nsEndIndex).toLowerCase();
+        const attrName = name.substring(nsEndIndex, name.length).toLowerCase();
+        const namespace = nsMap[ns] || null;
+        domElement.setAttributeNS(
+          namespace,
+          ns === XLINK_ATTRIBUTE_NAME || ns === XMLNS_ATTRIBUTE_NAME ? `${ns}:${attrName}` : name,
+          String(value)
+        );
+      } else if (name === "style" && typeof value !== "string") {
+        const styleObj = value;
+        for (const prop of Object.keys(styleObj)) {
+          domElement.style[prop] = String(styleObj[prop]);
+        }
+      } else if (typeof value === "boolean") {
+        domElement[name] = value;
+      } else {
+        domElement.setAttribute(name, String(value));
+      }
+    },
+    setAttributes: (virtualNode, domElement) => {
+      const attrNames = Object.keys(virtualNode.attributes);
+      for (let i = 0; i < attrNames.length; i++) {
+        renderer.setAttribute(
+          attrNames[i],
+          virtualNode.attributes[attrNames[i]],
+          domElement,
+          virtualNode
+        );
+      }
+    }
+  };
+  return renderer;
+};
+const renderIsomorphicSync = (virtualNode, parentDomElement, globals) => {
+  if (isDequery(parentDomElement)) {
+    parentDomElement = parentDomElement.getFirstElement() || parentDomElement;
+  }
+  let renderResult;
+  if (typeof virtualNode === "string") {
+    renderResult = getRenderer(globals.window.document).createTextNode(
+      virtualNode,
+      parentDomElement
+    );
+  } else {
+    renderResult = getRenderer(globals.window.document).createElementOrElements(
+      virtualNode,
+      parentDomElement
+    );
+  }
+  return renderResult;
+};
+const renderIsomorphicAsync = async (virtualNode, parentDomElement, globals) => {
+  if (parentDomElement instanceof Promise) {
+    parentDomElement = await parentDomElement;
+  }
+  if (isDequery(parentDomElement)) {
+    parentDomElement = (await parentDomElement.toArray())[0];
+  }
+  if (virtualNode instanceof Promise) {
+    virtualNode = await virtualNode;
+  }
+  return renderIsomorphicSync(
+    virtualNode,
+    parentDomElement,
+    globals
+  );
+};
+const globalScopeDomApis = (window, document) => {
+  globalThis.__defuss_document = document;
+  globalThis.__defuss_window = window;
+};
+const isJSX = (o) => {
+  if (o === null || typeof o !== "object") return false;
+  if (Array.isArray(o)) return o.every(isJSX);
+  if (typeof o.type === "string") return true;
+  if (typeof o.type === "function") return true;
+  if (typeof o.attributes === "object" && typeof o.children === "object")
+    return true;
+  return false;
+};
+const Fragment = (props) => props.children;
+const jsxs = jsx;
+const jsxDEV = (type, attributes, key, allChildrenAreStatic, sourceInfo, selfReference) => {
+  let renderResult;
+  try {
+    if (sourceInfo) {
+      if (typeof type === "function" && type.constructor.name !== "AsyncFunction") {
+        sourceInfo.exportName = type.name || sourceInfo?.exportName;
+      }
+      sourceInfo.allChildrenAreStatic = allChildrenAreStatic;
+      sourceInfo.selfReference = selfReference;
+    }
+    renderResult = jsx(type, attributes, key, sourceInfo);
+  } catch (error) {
+    console.error(
+      "JSX error:",
+      error,
+      "in",
+      sourceInfo,
+      "component",
+      selfReference
+    );
+  }
+  return renderResult;
+};
+async function performCoreDomUpdate(input, nodes, timeout, Parser) {
+  let processedInput = input;
+  if (isDequery(processedInput)) {
+    processedInput = processedInput[0];
+  }
+  if (isRef(processedInput)) {
+    await defussRuntime.waitForRef(processedInput, timeout);
+    processedInput = processedInput.current;
+  }
+  if (processedInput instanceof Node) {
+    const vnode = domNodeToVNode(processedInput);
+    nodes.forEach((el) => {
+      if (el) {
+        updateDomWithVdom(el, vnode, globalThis);
+      }
+    });
+    return;
+  }
+  if (typeof processedInput === "string") {
+    if (isMarkup(processedInput, Parser)) {
+      const vNodes = htmlStringToVNodes(processedInput, Parser);
+      nodes.forEach((el) => {
+        if (el) {
+          updateDomWithVdom(el, vNodes, globalThis);
+        }
+      });
+    } else {
+      nodes.forEach((el) => {
+        if (el) {
+          updateDomWithVdom(
+            el,
+            processedInput,
+            globalThis
+          );
+        }
+      });
+    }
+  } else if (isJSX(processedInput)) {
+    nodes.forEach((el) => {
+      if (el) {
+        updateDomWithVdom(
+          el,
+          processedInput,
+          globalThis
+        );
+      }
+    });
+  } else {
+    console.warn("update: unsupported content type", processedInput);
+  }
+}
+async function updateDom(input, nodes, timeout, Parser, transitionConfig) {
+  if (transitionConfig && transitionConfig.type !== "none") {
+    const config = { ...DEFAULT_TRANSITION_CONFIG, ...transitionConfig };
+    const { target = "self" } = config;
+    const transitionPromises = nodes.map(async (node) => {
+      if (!node) return node;
+      const element = node;
+      const transitionTarget = target === "self" ? element : element.parentElement;
+      if (!transitionTarget) {
+        await performCoreDomUpdate(input, [node], timeout, Parser);
+        return node;
+      }
+      await performTransition(
+        transitionTarget,
+        () => performCoreDomUpdate(input, [node], timeout, Parser),
+        config
+      );
+      return node;
+    });
+    await Promise.all(transitionPromises);
+    return nodes;
+  }
+  await performCoreDomUpdate(input, nodes, timeout, Parser);
+  return nodes;
+}
+
+const areDomNodesEqual = (oldNode, newNode) => {
+  if (oldNode === newNode) return true;
+  if (oldNode.nodeType !== newNode.nodeType) return false;
+  if (oldNode.nodeType === Node.ELEMENT_NODE) {
+    const oldElement = oldNode;
+    const newElement = newNode;
+    if (oldElement.tagName !== newElement.tagName) return false;
+    const oldAttrs = oldElement.attributes;
+    const newAttrs = newElement.attributes;
+    if (oldAttrs.length !== newAttrs.length) return false;
+    for (let i = 0; i < oldAttrs.length; i++) {
+      const oldAttr = oldAttrs[i];
+      const newAttrValue = newElement.getAttribute(oldAttr.name);
+      if (oldAttr.value !== newAttrValue) return false;
+    }
+  }
+  if (oldNode.nodeType === Node.TEXT_NODE) {
+    if (oldNode.textContent !== newNode.textContent) return false;
+  }
+  return true;
+};
+function isTextLike(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function isVNode(value) {
+  return Boolean(value && typeof value === "object" && "type" in value);
+}
+function toValidChild(child) {
+  if (child == null) return child;
+  if (isTextLike(child)) return child;
+  if (isVNode(child)) return child;
+  return void 0;
+}
+function normalizeChildren(input) {
+  const raw = [];
+  const pushChild = (child) => {
+    if (Array.isArray(child)) {
+      child.forEach(pushChild);
+      return;
+    }
+    const valid = toValidChild(child);
+    if (typeof valid === "undefined") return;
+    if (isVNode(valid) && (valid.type === "fragment" || valid.type === "Fragment")) {
+      const nested = Array.isArray(valid.children) ? valid.children : [];
+      nested.forEach(pushChild);
+      return;
+    }
+    if (valid === null || typeof valid === "undefined" || typeof valid === "boolean") return;
+    raw.push(valid);
+  };
+  pushChild(input);
+  const fused = [];
+  let buffer = null;
+  const flush = () => {
+    if (buffer !== null && buffer.length > 0) fused.push(buffer);
+    buffer = null;
+  };
+  for (const child of raw) {
+    if (typeof child === "string" || typeof child === "number" || typeof child === "boolean") {
+      buffer = (buffer ?? "") + String(child);
+      continue;
+    }
+    flush();
+    fused.push(child);
+  }
+  flush();
+  return fused;
+}
+function getVNodeMatchKey(child) {
+  if (!child || typeof child !== "object") return null;
+  const key = child.attributes?.key;
+  if (typeof key === "string" || typeof key === "number") return `k:${String(key)}`;
+  const id = child.attributes?.id;
+  if (typeof id === "string" && id.length > 0) return `id:${id}`;
+  return null;
+}
+function getDomMatchKeys(node) {
+  if (node.nodeType !== Node.ELEMENT_NODE) return [];
+  const el = node;
+  const keys = [];
+  const internalKey = el._defussKey;
+  if (internalKey) keys.push(`k:${internalKey}`);
+  const attrKey = el.getAttribute("key");
+  if (attrKey) keys.push(`k:${attrKey}`);
+  const id = el.id;
+  if (id) keys.push(`id:${id}`);
+  return keys;
+}
+function areNodeAndChildMatching(domNode, child) {
+  if (typeof child === "string" || typeof child === "number" || typeof child === "boolean") {
+    return domNode.nodeType === Node.TEXT_NODE;
+  }
+  if (child && typeof child === "object") {
+    if (domNode.nodeType !== Node.ELEMENT_NODE) return false;
+    const oldTag = domNode.tagName.toLowerCase();
+    const newType = typeof child.type === "string" ? child.type.toLowerCase() : "";
+    if (!newType) return false;
+    return oldTag === newType;
+  }
+  return false;
+}
+function createDomFromChild(child, globals) {
+  const renderer = getRenderer(globals.window.document);
+  if (child == null) return void 0;
+  if (typeof child === "string" || typeof child === "number" || typeof child === "boolean") {
+    return globals.window.document.createTextNode(String(child));
+  }
+  const created = renderer.createElementOrElements(child);
+  if (!created) return void 0;
+  return Array.isArray(created) ? created : [created];
+}
+function shouldPreserveFormStateAttribute(el, attrName, vnode) {
+  const tag = el.tagName.toLowerCase();
+  const hasExplicit = Object.prototype.hasOwnProperty.call(vnode.attributes ?? {}, attrName);
+  if (hasExplicit) return false;
+  if (tag === "input") return attrName === "value" || attrName === "checked";
+  if (tag === "textarea") return attrName === "value";
+  if (tag === "select") return attrName === "value";
+  return false;
+}
+function patchElementInPlace(el, vnode, globals) {
+  const renderer = getRenderer(globals.window.document);
+  const existingAttrs = Array.from(el.attributes);
+  const nextAttrs = vnode.attributes ?? {};
+  for (const attr of existingAttrs) {
+    const { name } = attr;
+    if (name === "key") continue;
+    if (name.startsWith("on")) continue;
+    if (name === "class" && (Object.prototype.hasOwnProperty.call(nextAttrs, "class") || Object.prototype.hasOwnProperty.call(nextAttrs, "className"))) {
+      continue;
+    }
+    if (!Object.prototype.hasOwnProperty.call(nextAttrs, name)) {
+      if (shouldPreserveFormStateAttribute(el, name, vnode)) continue;
+      el.removeAttribute(name);
+    }
+  }
+  renderer.setAttributes(vnode, el);
+  const d = vnode.attributes?.dangerouslySetInnerHTML;
+  if (d && typeof d === "object" && typeof d.__html === "string") {
+    el.innerHTML = d.__html;
+    return;
+  }
+  const tag = el.tagName.toLowerCase();
+  if (tag === "textarea") {
+    const isControlled = Object.prototype.hasOwnProperty.call(nextAttrs, "value");
+    const isActive = el.ownerDocument?.activeElement === el;
+    if (isActive && !isControlled) return;
+  }
+  updateDomWithVdom(el, vnode.children ?? [], globals);
+}
+function morphNode(domNode, child, globals) {
+  if (typeof child === "string" || typeof child === "number" || typeof child === "boolean") {
+    const text = String(child);
+    if (domNode.nodeType === Node.TEXT_NODE) {
+      if (domNode.nodeValue !== text) domNode.nodeValue = text;
+      return domNode;
+    }
+    const next = globals.window.document.createTextNode(text);
+    domNode.parentNode?.replaceChild(next, domNode);
+    return next;
+  }
+  if (child && typeof child === "object") {
+    const newType = typeof child.type === "string" ? child.type : null;
+    if (!newType) return domNode;
+    if (domNode.nodeType !== Node.ELEMENT_NODE) {
+      const created = createDomFromChild(child, globals);
+      const first = Array.isArray(created) ? created[0] : created;
+      if (!first) return null;
+      domNode.parentNode?.replaceChild(first, domNode);
+      handleLifecycleEventsForOnMount(first);
+      return first;
+    }
+    const el = domNode;
+    const oldTag = el.tagName.toLowerCase();
+    const newTag = newType.toLowerCase();
+    if (oldTag !== newTag) {
+      const created = createDomFromChild(child, globals);
+      const first = Array.isArray(created) ? created[0] : created;
+      if (!first) return null;
+      el.parentNode?.replaceChild(first, el);
+      handleLifecycleEventsForOnMount(first);
+      return first;
+    }
+    patchElementInPlace(el, child, globals);
+    return el;
+  }
+  domNode.parentNode?.removeChild(domNode);
+  return null;
+}
+function updateDomWithVdom(parentElement, newVDOM, globals) {
+  const nextChildren = normalizeChildren(newVDOM);
+  const existing = Array.from(parentElement.childNodes);
+  const keyedPool = /* @__PURE__ */ new Map();
+  const nodeKeys = /* @__PURE__ */ new WeakMap();
+  const unkeyedPool = [];
+  for (const node of existing) {
+    const keys = getDomMatchKeys(node);
+    if (keys.length > 0) {
+      nodeKeys.set(node, keys);
+      for (const k of keys) {
+        if (!keyedPool.has(k)) keyedPool.set(k, node);
+      }
+    } else {
+      unkeyedPool.push(node);
+    }
+  }
+  const consumeKeyedNode = (node) => {
+    const keys = nodeKeys.get(node) ?? [];
+    for (const k of keys) keyedPool.delete(k);
+  };
+  const takeUnkeyedMatch = (child) => {
+    for (let i = 0; i < unkeyedPool.length; i++) {
+      const candidate = unkeyedPool[i];
+      if (areNodeAndChildMatching(candidate, child)) {
+        unkeyedPool.splice(i, 1);
+        return candidate;
+      }
+    }
+    return unkeyedPool.shift();
+  };
+  let domIndex = 0;
+  for (const child of nextChildren) {
+    const key = getVNodeMatchKey(child);
+    let match;
+    if (key) {
+      match = keyedPool.get(key);
+      if (match) consumeKeyedNode(match);
+    } else {
+      match = takeUnkeyedMatch(child);
+    }
+    const anchor = parentElement.childNodes[domIndex] ?? null;
+    if (match) {
+      if (match !== anchor) {
+        parentElement.insertBefore(match, anchor);
+      }
+      morphNode(match, child, globals);
+      domIndex++;
+      continue;
+    }
+    const created = createDomFromChild(child, globals);
+    if (!created || Array.isArray(created) && created.length === 0) continue;
+    const nodes = Array.isArray(created) ? created : [created];
+    for (const node of nodes) {
+      parentElement.insertBefore(node, anchor);
+      handleLifecycleEventsForOnMount(node);
+      domIndex++;
+    }
+  }
+  const remaining = /* @__PURE__ */ new Set();
+  for (const node of unkeyedPool) remaining.add(node);
+  for (const node of keyedPool.values()) remaining.add(node);
+  for (const node of remaining) {
+    if (node.parentNode === parentElement) {
+      parentElement.removeChild(node);
+    }
+  }
+}
+function replaceDomWithVdom(parentElement, newVDOM, globals) {
+  while (parentElement.firstChild) {
+    parentElement.removeChild(parentElement.firstChild);
+  }
+  const renderer = getRenderer(globals.window.document);
+  const newDom = renderer.createElementOrElements(
+    newVDOM
+  );
+  if (Array.isArray(newDom)) {
+    for (const node of newDom) {
+      if (node) {
+        parentElement.appendChild(node);
+        handleLifecycleEventsForOnMount(node);
+      }
+    }
+  } else if (newDom) {
+    parentElement.appendChild(newDom);
+    handleLifecycleEventsForOnMount(newDom);
+  }
+}
+async function waitForDOM(check, timeout, document) {
+  const initialResult = check();
+  if (initialResult.length) return initialResult;
+  return defussRuntime.createTimeoutPromise(timeout, () => {
+    return new Promise((resolve) => {
+      if (!document) {
+        setTimeout(() => resolve(check()), 0);
+        return;
+      }
+      const observer = new MutationObserver(() => {
+        const result = check();
+        if (result.length) {
+          observer.disconnect();
+          resolve(result);
+        }
+      });
+      observer.observe(document.documentElement, {
+        childList: true,
+        subtree: true,
+        attributes: true
+      });
+      return () => observer.disconnect();
+    });
+  });
+}
+function parseDOM(input, type, Parser) {
+  return new Parser().parseFromString(input, type);
+}
+function isSVG(input, Parser) {
+  const doc = parseDOM(input, "image/svg+xml", Parser);
+  if (!doc.documentElement) return false;
+  return doc.documentElement.nodeName.toLowerCase() === "svg";
+}
+function isHTML(input, Parser) {
+  const doc = parseDOM(input, "text/html", Parser);
+  return doc.documentElement.querySelectorAll("*").length > 2;
+}
+const isMarkup = (input, Parser) => input.indexOf("<") > -1 && input.indexOf(">") > -1 && (isHTML(input, Parser) || isSVG(input, Parser));
+function renderMarkup(markup, Parser, doc) {
+  return Array.from(
+    (doc ? doc : parseDOM(markup, getMimeType(markup, Parser), Parser)).body.childNodes
+  );
+}
+function getMimeType(input, Parser) {
+  if (isSVG(input, Parser)) {
+    return "image/svg+xml";
+  }
+  return "text/html";
+}
+function processAllFormElements(node, callback) {
+  if (node instanceof Element) {
+    if (node instanceof HTMLFormElement) {
+      Array.from(node.elements).forEach((element) => {
+        if (element instanceof HTMLInputElement || element instanceof HTMLSelectElement || element instanceof HTMLTextAreaElement) {
+          const key = element.name || element.id;
+          if (key) {
+            callback(element, key);
+          }
+        }
+      });
+    } else {
+      const inputElements = node.querySelectorAll("input, select, textarea");
+      inputElements.forEach((element) => {
+        if (element instanceof HTMLInputElement || element instanceof HTMLSelectElement || element instanceof HTMLTextAreaElement) {
+          const key = element.name || element.id;
+          if (key) {
+            callback(element, key);
+          }
+        }
+      });
+    }
+  }
+}
+function checkElementVisibility(element, window, document) {
+  const style = window.getComputedStyle(element);
+  if (!style) return false;
+  if (element.offsetWidth === 0 || element.offsetHeight === 0) return false;
+  if (style.display === "none" || style.visibility === "hidden" || style.opacity === "0" || Number.parseFloat(style.opacity) === 0)
+    return false;
+  if (!document.body.contains(element)) return false;
+  let parent = element.parentElement;
+  while (parent) {
+    const parentStyle = window.getComputedStyle(parent);
+    if (parentStyle && (parentStyle.display === "none" || parentStyle.visibility === "hidden" || parentStyle.opacity === "0" || Number.parseFloat(parentStyle.opacity) === 0)) {
+      return false;
+    }
+    parent = parent.parentElement;
+  }
+  return true;
+}
+function getEventMap(element) {
+  if (!element._dequeryEvents) {
+    element._dequeryEvents = /* @__PURE__ */ new Map();
+  }
+  return element._dequeryEvents;
+}
+function addElementEvent(element, eventType, handler) {
+  const eventMap = getEventMap(element);
+  if (!eventMap.has(eventType)) {
+    eventMap.set(eventType, /* @__PURE__ */ new Set());
+  }
+  eventMap.get(eventType).add(handler);
+  element.addEventListener(eventType, handler);
+}
+function removeElementEvent(element, eventType, handler) {
+  const eventMap = getEventMap(element);
+  if (!eventMap.has(eventType)) return;
+  if (handler) {
+    if (eventMap.get(eventType).has(handler)) {
+      element.removeEventListener(eventType, handler);
+      eventMap.get(eventType).delete(handler);
+      if (eventMap.get(eventType).size === 0) {
+        eventMap.delete(eventType);
+      }
+    }
+  } else {
+    eventMap.get(eventType).forEach((h) => {
+      element.removeEventListener(eventType, h);
+    });
+    eventMap.delete(eventType);
+  }
+}
+function clearElementEvents(element) {
+  const eventMap = getEventMap(element);
+  eventMap.forEach((handlers, eventType) => {
+    handlers.forEach((handler) => {
+      element.removeEventListener(eventType, handler);
+    });
+  });
+  eventMap.clear();
+}
+function domNodeToVNode(node) {
+  if (node.nodeType === Node.TEXT_NODE) {
+    return node.textContent || "";
+  }
+  if (node.nodeType === Node.ELEMENT_NODE) {
+    const element = node;
+    const attributes = {};
+    for (let i = 0; i < element.attributes.length; i++) {
+      const attr = element.attributes[i];
+      attributes[attr.name] = attr.value;
+    }
+    const children = [];
+    for (let i = 0; i < element.childNodes.length; i++) {
+      const childVNode = domNodeToVNode(element.childNodes[i]);
+      children.push(childVNode);
+    }
+    return {
+      type: element.tagName.toLowerCase(),
+      attributes,
+      children
+    };
+  }
+  return "";
+}
+function htmlStringToVNodes(html, Parser) {
+  const parser = new Parser();
+  const doc = parser.parseFromString(html, "text/html");
+  const vNodes = [];
+  for (let i = 0; i < doc.body.childNodes.length; i++) {
+    const vnode = domNodeToVNode(doc.body.childNodes[i]);
+    if (vnode !== "") {
+      vNodes.push(vnode);
+    }
+  }
+  return vNodes;
+}
+
+exports.$ = $;
+exports.CAPTURE_ONLY_EVENTS = CAPTURE_ONLY_EVENTS;
+exports.CLASS_ATTRIBUTE_NAME = CLASS_ATTRIBUTE_NAME;
+exports.Call = Call;
+exports.CallChainImpl = CallChainImpl;
+exports.CallChainImplThenable = CallChainImplThenable;
+exports.DANGEROUSLY_SET_INNER_HTML_ATTRIBUTE = DANGEROUSLY_SET_INNER_HTML_ATTRIBUTE;
+exports.DEFAULT_TRANSITION_CONFIG = DEFAULT_TRANSITION_CONFIG;
+exports.Fragment = Fragment;
+exports.REF_ATTRIBUTE_NAME = REF_ATTRIBUTE_NAME;
+exports.XLINK_ATTRIBUTE_NAME = XLINK_ATTRIBUTE_NAME;
+exports.XMLNS_ATTRIBUTE_NAME = XMLNS_ATTRIBUTE_NAME;
+exports.addElementEvent = addElementEvent;
+exports.addNonChainedReturnCallNames = addNonChainedReturnCallNames;
+exports.applyStyles = applyStyles;
+exports.areDomNodesEqual = areDomNodesEqual;
+exports.checkElementVisibility = checkElementVisibility;
+exports.clearDelegatedEvents = clearDelegatedEvents;
+exports.clearElementEvents = clearElementEvents;
+exports.createCall = createCall;
+exports.createGetterSetterCall = createGetterSetterCall;
+exports.createInPlaceErrorMessageVNode = createInPlaceErrorMessageVNode;
+exports.createRef = createRef;
+exports.createStore = createStore;
+exports.createSubChain = createSubChain;
+exports.delayedAutoStart = delayedAutoStart;
+exports.dequery = dequery;
+exports.domNodeToVNode = domNodeToVNode;
+exports.emptyImpl = emptyImpl;
+exports.getAllFormValues = getAllFormValues;
+exports.getDefaultDequeryOptions = getDefaultDequeryOptions;
+exports.getEventMap = getEventMap;
+exports.getMimeType = getMimeType;
+exports.getNonChainedReturnCallNames = getNonChainedReturnCallNames;
+exports.getRenderer = getRenderer;
+exports.getTransitionStyles = getTransitionStyles;
+exports.globalScopeDomApis = globalScopeDomApis;
+exports.handleLifecycleEventsForOnMount = handleLifecycleEventsForOnMount;
+exports.htmlStringToVNodes = htmlStringToVNodes;
+exports.isDequery = isDequery;
+exports.isDequeryOptionsObject = isDequeryOptionsObject;
+exports.isHTML = isHTML;
+exports.isJSX = isJSX;
+exports.isMarkup = isMarkup;
+exports.isNonChainedReturnCall = isNonChainedReturnCall;
+exports.isRef = isRef;
+exports.isSVG = isSVG;
+exports.isServer = isServer;
+exports.jsx = jsx;
+exports.jsxDEV = jsxDEV;
+exports.jsxs = jsxs;
+exports.mapArrayIndexAccess = mapArrayIndexAccess;
+exports.observeUnmount = observeUnmount;
+exports.parseDOM = parseDOM;
+exports.parseEventPropName = parseEventPropName;
+exports.performTransition = performTransition;
+exports.processAllFormElements = processAllFormElements;
+exports.queueCallback = queueCallback;
+exports.registerDelegatedEvent = registerDelegatedEvent;
+exports.removeDelegatedEvent = removeDelegatedEvent;
+exports.removeElementEvent = removeElementEvent;
+exports.renderIsomorphicAsync = renderIsomorphicAsync;
+exports.renderIsomorphicSync = renderIsomorphicSync;
+exports.renderMarkup = renderMarkup;
+exports.renderNode = renderNode;
+exports.replaceDomWithVdom = replaceDomWithVdom;
+exports.resolveNodes = resolveNodes;
+exports.runWithTimeGuard = runWithTimeGuard;
+exports.scrollHelper = scrollHelper;
+exports.subChainForNextAwait = subChainForNextAwait;
+exports.traverse = traverse;
+exports.updateDom = updateDom;
+exports.updateDomWithVdom = updateDomWithVdom;
+exports.waitForDOM = waitForDOM;
+exports.webstorage = webstorage;