defuss 2.1.1 → 2.1.5

package/dist/dom-7QMISZ5C.mjs

@@ -0,0 +1,2211 @@
+import { pick, omit, createTimeoutPromise, waitForRef, setByPath, getByPath } from '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 = 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 = 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 () => {
+      await waitForRef(ref, this.options.timeout);
+      if (ref.current) {
+        return [ref.current];
+      } else {
+        throw new Error("Ref is null or undefined");
+      }
+    });
+  }
+  query(selector) {
+    return createCall(this, "query", async () => {
+      return Array.from(
+        await waitForDOM(
+          () => Array.from(this.document.querySelectorAll(selector)),
+          this.options.timeout,
+          this.document
+        )
+      );
+    });
+  }
+  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();
+    });
+  }
+  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) {
+        console.warn("appendTo: no target elements found");
+        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;
+    });
+  }
+  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 () => {
+        const startTime = Date.now();
+        let call;
+        while (this.stackPointer < this.callStack.length) {
+          call = this.callStack[this.stackPointer];
+          if (Date.now() - startTime > this.options.timeout) {
+            throw new Error(`Timeout after ${this.options.timeout}ms`);
+          }
+          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;
+      },
+      [],
+      (ms, call) => {
+        this.stoppedWithError = new Error(`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) {
+            console.log("input radio value", input.value);
+            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: 500,
+      // 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) {
+  chain.callStack.push(new Call(methodName, handler));
+  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) {
+  return createTimeoutPromise(
+    timeout,
+    () => fn(...args),
+    (ms) => {
+      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 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 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 ? 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 = 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 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) => {
+  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
+  };
+};
+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) {
+            updateDom(
+              virtualNode.attributes.dangerouslySetInnerHTML.__html,
+              [newEl],
+              1e3,
+              // timeout in ms
+              globalThis.DOMParser
+            );
+          }
+        }
+        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 === REF_ATTRIBUTE_NAME && typeof value !== "function") {
+        value.current = domElement;
+        domElement._defussRef = value;
+        return;
+      }
+      if (name.startsWith("on") && typeof value === "function") {
+        let eventName = name.substring(2).toLowerCase();
+        const capturePos = eventName.indexOf("capture");
+        const doCapture = capturePos > -1;
+        if (eventName === "mount") {
+          domElement.$onMount = queueCallback(value);
+        }
+        if (eventName === "unmount") {
+          domElement.$onUnmount = queueCallback(value);
+        }
+        if (doCapture) {
+          eventName = eventName.substring(0, capturePos);
+        }
+        domElement.addEventListener(eventName, value, doCapture);
+        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" ? `${ns}:${attrName}` : name,
+          value
+        );
+      } else if (name === "style" && typeof value !== "string") {
+        const propNames = Object.keys(value);
+        for (let i = 0; i < propNames.length; i++) {
+          domElement.style[propNames[i]] = value[propNames[i]];
+        }
+      } else if (typeof value === "boolean") {
+        domElement[name] = value;
+      } else {
+        domElement.setAttribute(name, 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 {
+    console.log("jsxDEV", { type, attributes, key, sourceInfo, selfReference });
+    renderResult = jsx(type, attributes, key);
+  } 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 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 toValidChild(child) {
+  if (child == null) return child;
+  if (typeof child === "string" || typeof child === "number" || typeof child === "boolean") {
+    return child;
+  }
+  if (typeof child === "object" && "type" in child) {
+    return child;
+  }
+  return void 0;
+}
+function areNodeAndChildMatching(domNode, child) {
+  if (typeof child === "string" || typeof child === "number" || typeof child === "boolean") {
+    return domNode.nodeType === Node.TEXT_NODE;
+  } else if (child && typeof child === "object") {
+    if (domNode.nodeType !== Node.ELEMENT_NODE) return false;
+    const oldTag = domNode.tagName.toLowerCase();
+    const newTag = child.type.toLowerCase();
+    return oldTag === newTag;
+  }
+  return false;
+}
+function patchDomInPlace(domNode, child, globals) {
+  const renderer = getRenderer(globals.window.document);
+  if (typeof child === "string" || typeof child === "number" || typeof child === "boolean") {
+    const newText = String(child);
+    if (domNode.nodeValue !== newText) {
+      domNode.nodeValue = newText;
+    }
+    return;
+  }
+  if (domNode.nodeType === Node.ELEMENT_NODE && child && typeof child === "object") {
+    const el = domNode;
+    const existingAttrs = Array.from(el.attributes);
+    for (const attr of existingAttrs) {
+      const { name } = attr;
+      if (!Object.prototype.hasOwnProperty.call(child.attributes, name) && name !== "style") {
+        el.removeAttribute(name);
+      }
+    }
+    renderer.setAttributes(child, el);
+    if (child.attributes?.dangerouslySetInnerHTML) {
+      el.innerHTML = child.attributes.dangerouslySetInnerHTML.__html;
+      return;
+    }
+    if (child.children) {
+      updateDomWithVdom(el, child.children, globals);
+    } else {
+      while (el.firstChild) {
+        el.removeChild(el.firstChild);
+      }
+    }
+  }
+}
+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));
+  }
+  let renderResult = renderer.createElementOrElements(child);
+  if (renderResult && !Array.isArray(renderResult)) {
+    renderResult = [renderResult];
+  }
+  return renderResult;
+}
+function updateDomWithVdom(parentElement, newVDOM, globals) {
+  let newChildren = [];
+  if (Array.isArray(newVDOM)) {
+    newChildren = newVDOM.map(toValidChild).filter((c) => c !== void 0);
+  } else if (typeof newVDOM === "string" || typeof newVDOM === "number" || typeof newVDOM === "boolean") {
+    newChildren = [newVDOM];
+  } else if (newVDOM) {
+    const child = toValidChild(newVDOM);
+    if (child !== void 0) newChildren = [child];
+  }
+  const newDomArray = newChildren.map(
+    (vdomChild) => createDomFromChild(vdomChild, globals)
+  );
+  const oldNodes = Array.from(parentElement.childNodes);
+  const maxLen = Math.max(oldNodes.length, newDomArray.length);
+  for (let i = 0; i < maxLen; i++) {
+    const oldNode = oldNodes[i];
+    const newDom = newDomArray[i];
+    const newChild = newChildren[i];
+    if (oldNode && newDom !== void 0) {
+      if (Array.isArray(newDom)) {
+        if (newDom.length === 0) {
+          parentElement.removeChild(oldNode);
+        } else {
+          const first = newDom[0];
+          parentElement.replaceChild(first, oldNode);
+          for (let k = 1; k < newDom.length; k++) {
+            if (newDom[k]) {
+              parentElement.insertBefore(newDom[k], first.nextSibling);
+              if (typeof newDom[k] !== "undefined") {
+                handleLifecycleEventsForOnMount(newDom[k]);
+              }
+            }
+          }
+          if (typeof first !== "undefined") {
+            handleLifecycleEventsForOnMount(first);
+          }
+        }
+      } else if (newDom) {
+        if (newChild && areNodeAndChildMatching(oldNode, newChild)) {
+          patchDomInPlace(oldNode, newChild, globals);
+        } else {
+          parentElement.replaceChild(newDom, oldNode);
+          handleLifecycleEventsForOnMount(newDom);
+        }
+      }
+    } else if (!oldNode && newDom !== void 0) {
+      if (Array.isArray(newDom)) {
+        newDom.forEach((newNode) => {
+          const wasAdded = newNode && parentElement.appendChild(newNode);
+          if (wasAdded) {
+            handleLifecycleEventsForOnMount(newNode);
+          }
+          return wasAdded;
+        });
+      } else if (newDom) {
+        parentElement.appendChild(newDom);
+        handleLifecycleEventsForOnMount(newDom);
+      }
+    } else if (oldNode && newDom === void 0) {
+      parentElement.removeChild(oldNode);
+    }
+  }
+}
+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);
+    }
+  } else if (newDom) {
+    parentElement.appendChild(newDom);
+  }
+}
+async function waitForDOM(check, timeout, document) {
+  const initialResult = check();
+  if (initialResult.length) return initialResult;
+  return 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;
+}
+
+export { $, observeUnmount as A, handleLifecycleEventsForOnMount as B, CLASS_ATTRIBUTE_NAME as C, DANGEROUSLY_SET_INNER_HTML_ATTRIBUTE as D, getRenderer as E, renderIsomorphicSync as F, renderIsomorphicAsync as G, globalScopeDomApis as H, isJSX as I, Fragment as J, jsxs as K, jsxDEV as L, updateDom as M, getTransitionStyles as N, applyStyles as O, DEFAULT_TRANSITION_CONFIG as P, performTransition as Q, REF_ATTRIBUTE_NAME as R, Call as S, addNonChainedReturnCallNames as T, getNonChainedReturnCallNames as U, isNonChainedReturnCall as V, emptyImpl as W, XLINK_ATTRIBUTE_NAME as X, CallChainImpl as Y, CallChainImplThenable as Z, scrollHelper as _, createRef as a, getAllFormValues as a0, delayedAutoStart as a1, dequery as a2, isDequery as a3, isDequeryOptionsObject as a4, getDefaultDequeryOptions as a5, mapArrayIndexAccess as a6, createCall as a7, createGetterSetterCall as a8, createSubChain as a9, subChainForNextAwait as aa, runWithTimeGuard as ab, renderNode as ac, resolveNodes as ad, traverse as ae, webstorage as af, isRef as b, createStore as c, areDomNodesEqual as d, isSVG as e, isHTML as f, isMarkup as g, renderMarkup as h, isServer as i, getMimeType as j, processAllFormElements as k, checkElementVisibility as l, getEventMap as m, addElementEvent as n, removeElementEvent as o, parseDOM as p, clearElementEvents as q, replaceDomWithVdom as r, domNodeToVNode as s, htmlStringToVNodes as t, updateDomWithVdom as u, queueCallback as v, waitForDOM as w, XMLNS_ATTRIBUTE_NAME as x, createInPlaceErrorMessageVNode as y, jsx as z };