defuss 2.0.5 → 2.0.7

package/dist/dom-BHDjOwCH.cjs

@@ -0,0 +1,2058 @@
+'use strict';
+
+var defussRuntime = require('defuss-runtime');
+
+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;
+}
+
+class Call {
+  name;
+  fn;
+  args;
+  constructor(name, fn, ...args) {
+    this.name = name;
+    this.fn = fn;
+    this.args = args;
+  }
+}
+const NonChainedReturnCallNames = [
+  "getFirstElement",
+  "toArray",
+  "map",
+  "isHidden",
+  "isVisible",
+  "hasClass",
+  "dimension",
+  "position",
+  "offset",
+  "prop",
+  "val",
+  "form",
+  "attr",
+  "data",
+  "css",
+  "html",
+  "serialize"
+];
+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 () => {
+      await defussRuntime.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 newElement = await renderNode(content, this);
+      if (!newElement) return this.nodes;
+      this.nodes.forEach((el, index) => {
+        if (!el || !newElement) return;
+        if (el.parentNode) {
+          const clone = newElement.cloneNode(true);
+          el.parentNode.replaceChild(clone, el);
+          this.nodes[index] = clone;
+          mapArrayIndexAccess(this, this);
+        }
+      });
+      return this.nodes;
+    });
+  }
+  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.cloneNode(true))
+          );
+        });
+      } else {
+        this.nodes.forEach((el) => {
+          if (!element) return;
+          el.appendChild(element.cloneNode(true));
+        });
+      }
+      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) {
+    return createCall(this, "update", async () => {
+      if (isDequery(input)) {
+        input = input[0];
+      }
+      if (input instanceof Node) {
+        emptyImpl(this.nodes);
+        for (let i = 0; i < this.nodes.length; i++) {
+          const el = this.nodes[i];
+          if (!el || !input || el.isEqualNode(input) || el.parentNode === input) {
+            continue;
+          }
+          el.appendChild(input.cloneNode(true));
+        }
+        return this.nodes;
+      }
+      if (typeof input === "string") {
+        if (isMarkup(input, this.Parser)) {
+          this.nodes.forEach((el) => {
+            updateDom(el, input, this.Parser);
+          });
+        } else {
+          this.nodes.forEach((el) => {
+            el.textContent = input;
+          });
+        }
+      } else if (isJSX(input)) {
+        this.nodes.forEach((el) => {
+          updateDomWithVdom(
+            el,
+            input,
+            globalThis
+          );
+        });
+      } else {
+        console.warn("update: unsupported content type", input);
+      }
+      return this.nodes;
+    });
+  }
+  // --- 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 (NonChainedReturnCallNames.includes(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 (!NonChainedReturnCallNames.includes(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;
+      }
+    });
+  });
+  console.log("formFields", formFields);
+  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) => {
+  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];
+    }
+  });
+  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 defussRuntime.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 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 CLASS_ATTRIBUTE_NAME = "class";
+const XLINK_ATTRIBUTE_NAME = "xlink";
+const XMLNS_ATTRIBUTE_NAME = "xmlns";
+const REF_ATTRIBUTE_NAME = "ref";
+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) {
+            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 === "dangerouslySetInnerHTML") return;
+      if (name === REF_ATTRIBUTE_NAME && typeof value !== "function") {
+        value.current = domElement;
+        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 = value;
+        }
+        if (eventName === "unmount") {
+          domElement.$onUnmount = 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 {
+    renderResult = jsx(type, attributes, key);
+  } catch (error) {
+    console.error(
+      "JSX error:",
+      error,
+      "in",
+      sourceInfo,
+      "component",
+      selfReference
+    );
+  }
+  return renderResult;
+};
+
+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;
+};
+const updateNode = (oldNode, newNode) => {
+  if (!areDomNodesEqual(oldNode, newNode)) {
+    oldNode.parentNode?.replaceChild(newNode.cloneNode(true), oldNode);
+    return;
+  }
+  if (oldNode.nodeType === Node.ELEMENT_NODE) {
+    const oldChildren = oldNode.childNodes;
+    const newChildren = newNode.childNodes;
+    const maxLength = Math.max(oldChildren.length, newChildren.length);
+    for (let i = 0; i < maxLength; i++) {
+      const oldChild = oldChildren[i];
+      const newChild = newChildren[i];
+      if (oldChild && newChild) {
+        updateNode(oldChild, newChild);
+      } else if (newChild && !oldChild) {
+        oldNode.appendChild(newChild.cloneNode(true));
+      } else if (oldChild && !newChild) {
+        oldNode.removeChild(oldChild);
+      }
+    }
+  }
+};
+const updateDom = (targetElement, newHTML, Parser) => {
+  const parser = new Parser();
+  const doc = parser.parseFromString(newHTML, "text/html");
+  const newNodes = Array.from(doc.body.childNodes);
+  if (newNodes.length === 0) {
+    console.warn("No content found in the new HTML.");
+    return;
+  }
+  for (let i = 0; i < newNodes.length; i++) {
+    const newNode = newNodes[i];
+    const oldNode = targetElement.childNodes[i];
+    if (oldNode) {
+      updateNode(oldNode, newNode);
+    } else {
+      targetElement.appendChild(newNode.cloneNode(true));
+    }
+  }
+  while (targetElement.childNodes.length > newNodes.length) {
+    targetElement.removeChild(targetElement.lastChild);
+  }
+};
+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);
+          if (typeof first !== "undefined") {
+            handleLifecycleEventsForOnMount(first);
+          }
+          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]);
+              }
+            }
+          }
+        }
+      } 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 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();
+}
+
+exports.$ = $;
+exports.Call = Call;
+exports.CallChainImpl = CallChainImpl;
+exports.CallChainImplThenable = CallChainImplThenable;
+exports.Fragment = Fragment;
+exports.NonChainedReturnCallNames = NonChainedReturnCallNames;
+exports.addElementEvent = addElementEvent;
+exports.areDomNodesEqual = areDomNodesEqual;
+exports.checkElementVisibility = checkElementVisibility;
+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.emptyImpl = emptyImpl;
+exports.getAllFormValues = getAllFormValues;
+exports.getDefaultDequeryOptions = getDefaultDequeryOptions;
+exports.getEventMap = getEventMap;
+exports.getMimeType = getMimeType;
+exports.getRenderer = getRenderer;
+exports.globalScopeDomApis = globalScopeDomApis;
+exports.handleLifecycleEventsForOnMount = handleLifecycleEventsForOnMount;
+exports.isDequery = isDequery;
+exports.isDequeryOptionsObject = isDequeryOptionsObject;
+exports.isHTML = isHTML;
+exports.isJSX = isJSX;
+exports.isMarkup = isMarkup;
+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.processAllFormElements = processAllFormElements;
+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;