defuss 2.0.17 → 2.1.1

package/dist/dom-Da94we67.mjs

@@ -0,0 +1,2482 @@
+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.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, 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 getTransitionStyles = (type, duration, easing = "ease-in-out") => {
+  const baseTransition = `all ${duration}ms ${easing}`;
+  const filterUndefined = (obj) => {
+    const filtered = {};
+    Object.entries(obj).forEach(([key, value]) => {
+      if (value !== void 0) {
+        filtered[key] = value;
+      }
+    });
+    return filtered;
+  };
+  switch (type) {
+    case "fade":
+      return {
+        enter: filterUndefined({ opacity: "0", transition: baseTransition }),
+        enterActive: filterUndefined({ opacity: "1" }),
+        exit: filterUndefined({ opacity: "1", transition: baseTransition }),
+        exitActive: filterUndefined({ opacity: "0" })
+      };
+    case "slide-left":
+      return {
+        enter: filterUndefined({
+          transform: "translateX(100%)",
+          opacity: "0",
+          transition: baseTransition
+        }),
+        enterActive: filterUndefined({
+          transform: "translateX(0%)",
+          opacity: "1"
+        }),
+        exit: filterUndefined({
+          transform: "translateX(0%)",
+          opacity: "1",
+          transition: baseTransition
+        }),
+        exitActive: filterUndefined({
+          transform: "translateX(-200%)",
+          opacity: "0"
+        })
+      };
+    case "slide-right":
+      return {
+        enter: filterUndefined({
+          transform: "translateX(-200%)",
+          opacity: "0",
+          transition: baseTransition
+        }),
+        enterActive: filterUndefined({
+          transform: "translateX(0%)",
+          opacity: "1"
+        }),
+        exit: filterUndefined({
+          transform: "translateX(0%)",
+          opacity: "1",
+          transition: baseTransition
+        }),
+        exitActive: filterUndefined({
+          transform: "translateX(100%)",
+          opacity: "0"
+        })
+      };
+    case "slide-up":
+      return {
+        enter: filterUndefined({
+          transform: "translateY(100%)",
+          opacity: "0",
+          transition: baseTransition
+        }),
+        enterActive: filterUndefined({
+          transform: "translateY(0%)",
+          opacity: "1"
+        }),
+        exit: filterUndefined({
+          transform: "translateY(0%)",
+          opacity: "1",
+          transition: baseTransition
+        }),
+        exitActive: filterUndefined({
+          transform: "translateY(-200%)",
+          opacity: "0"
+        })
+      };
+    case "slide-down":
+      return {
+        enter: filterUndefined({
+          transform: "translateY(-200%)",
+          opacity: "0",
+          transition: baseTransition
+        }),
+        enterActive: filterUndefined({
+          transform: "translateY(0%)",
+          opacity: "1"
+        }),
+        exit: filterUndefined({
+          transform: "translateY(0%)",
+          opacity: "1",
+          transition: baseTransition
+        }),
+        exitActive: filterUndefined({
+          transform: "translateY(100%)",
+          opacity: "0"
+        })
+      };
+    case "zoom":
+      return {
+        enter: filterUndefined({
+          transform: "scale(0)",
+          opacity: "0",
+          transition: baseTransition
+        }),
+        enterActive: filterUndefined({ transform: "scale(1)", opacity: "1" }),
+        exit: filterUndefined({
+          transform: "scale(1)",
+          opacity: "1",
+          transition: baseTransition
+        }),
+        exitActive: filterUndefined({ transform: "scale(0)", opacity: "0" })
+      };
+    case "rotate":
+      return {
+        enter: filterUndefined({
+          transform: "rotate(-360deg)",
+          opacity: "0",
+          transition: baseTransition
+        }),
+        enterActive: filterUndefined({
+          transform: "rotate(0deg)",
+          opacity: "1"
+        }),
+        exit: filterUndefined({
+          transform: "rotate(0deg)",
+          opacity: "1",
+          transition: baseTransition
+        }),
+        exitActive: filterUndefined({
+          transform: "rotate(360deg)",
+          opacity: "0"
+        })
+      };
+    case "flip-horizontal":
+      return {
+        enter: filterUndefined({
+          transform: "perspective(1000px) rotateY(-360deg)",
+          opacity: "0",
+          transition: baseTransition
+        }),
+        enterActive: filterUndefined({
+          transform: "perspective(1000px) rotateY(0deg)",
+          opacity: "1"
+        }),
+        exit: filterUndefined({
+          transform: "perspective(1000px) rotateY(0deg)",
+          opacity: "1",
+          transition: baseTransition
+        }),
+        exitActive: filterUndefined({
+          transform: "perspective(1000px) rotateY(360deg)",
+          opacity: "0"
+        })
+      };
+    case "flip-vertical":
+      return {
+        enter: filterUndefined({
+          transform: "perspective(1000px) rotateX(-360deg)",
+          opacity: "0",
+          transition: baseTransition
+        }),
+        enterActive: filterUndefined({
+          transform: "perspective(1000px) rotateX(0deg)",
+          opacity: "1"
+        }),
+        exit: filterUndefined({
+          transform: "perspective(1000px) rotateX(0deg)",
+          opacity: "1",
+          transition: baseTransition
+        }),
+        exitActive: filterUndefined({
+          transform: "perspective(1000px) rotateX(360deg)",
+          opacity: "0"
+        })
+      };
+    case "bounce":
+      return {
+        enter: filterUndefined({
+          transform: "scale(0.3)",
+          opacity: "0",
+          transition: `all ${duration}ms cubic-bezier(0.68, -0.55, 0.265, 1.55)`
+        }),
+        enterActive: filterUndefined({
+          transform: "scale(1)",
+          opacity: "1"
+        }),
+        exit: filterUndefined({
+          transform: "scale(1)",
+          opacity: "1",
+          transition: `all ${duration}ms cubic-bezier(0.68, -0.55, 0.265, 1.55)`
+        }),
+        exitActive: filterUndefined({
+          transform: "scale(0.3)",
+          opacity: "0"
+        })
+      };
+    default:
+      return {
+        enter: {},
+        enterActive: {},
+        exit: {},
+        exitActive: {}
+      };
+  }
+};
+const applyStyles = (element, styles) => {
+  Object.entries(styles).forEach(([property, value]) => {
+    element.style.setProperty(property, String(value));
+  });
+};
+const createContentSnapshot = (element) => {
+  const snapshot = element.cloneNode(true);
+  const computedStyle = window.getComputedStyle(element);
+  const rect = element.getBoundingClientRect();
+  applyStyles(snapshot, {
+    position: "absolute",
+    top: `${rect.top + window.scrollY}px`,
+    left: `${rect.left + window.scrollX}px`,
+    width: `${rect.width}px`,
+    height: `${rect.height}px`,
+    zIndex: "-1",
+    // Behind the original content
+    pointerEvents: "none",
+    // Don't interfere with interactions
+    // Copy important visual styles
+    background: computedStyle.background,
+    border: computedStyle.border,
+    borderRadius: computedStyle.borderRadius,
+    boxShadow: computedStyle.boxShadow,
+    // Preserve text and content styles
+    font: computedStyle.font,
+    color: computedStyle.color,
+    textAlign: computedStyle.textAlign,
+    lineHeight: computedStyle.lineHeight
+  });
+  snapshot.classList.add("defuss-content-snapshot");
+  return snapshot;
+};
+const insertContentSnapshot = (snapshot, targetElement) => {
+  const positionedParent = getPositionedParent(targetElement);
+  (positionedParent || document.body).appendChild(snapshot);
+};
+const removeContentSnapshot = (snapshot) => {
+  if (snapshot.parentNode) {
+    snapshot.parentNode.removeChild(snapshot);
+  }
+};
+const getPositionedParent = (element) => {
+  let parent = element.parentElement;
+  while (parent) {
+    const style = window.getComputedStyle(parent);
+    if (style.position !== "static") {
+      return parent;
+    }
+    parent = parent.parentElement;
+  }
+  return null;
+};
+const DEFAULT_TRANSITION_CONFIG = {
+  type: "fade",
+  duration: 300,
+  easing: "ease-in-out",
+  delay: 0
+};
+const waitForTransition = (element, duration) => {
+  return new Promise((resolve) => {
+    const handleTransitionEnd = () => {
+      element.removeEventListener("transitionend", handleTransitionEnd);
+      resolve();
+    };
+    element.addEventListener("transitionend", handleTransitionEnd);
+    setTimeout(resolve, duration + 50);
+  });
+};
+const scheduleTransitionStep = (callback) => {
+  queueMicrotask(callback);
+};
+const scheduleDelayedStep = (callback, delay) => {
+  if (delay > 0) {
+    setTimeout(callback, delay);
+  } else {
+    queueMicrotask(callback);
+  }
+};
+const scheduleTransitionEnd = (element, duration, callback) => {
+  let resolved = false;
+  const handleTransitionEnd = () => {
+    if (!resolved) {
+      resolved = true;
+      element.removeEventListener("transitionend", handleTransitionEnd);
+      queueMicrotask(callback);
+    }
+  };
+  element.addEventListener("transitionend", handleTransitionEnd);
+  setTimeout(() => {
+    if (!resolved) {
+      resolved = true;
+      element.removeEventListener("transitionend", handleTransitionEnd);
+      queueMicrotask(callback);
+    }
+  }, duration + 50);
+};
+const storeOriginalStyles = (element, styleProperties) => {
+  const originalStyles = {};
+  styleProperties.forEach((property) => {
+    const currentValue = element.style.getPropertyValue(property) || window.getComputedStyle(element).getPropertyValue(property);
+    originalStyles[property] = currentValue;
+  });
+  return originalStyles;
+};
+const restoreOriginalStyles = (element, originalStyles) => {
+  Object.entries(originalStyles).forEach(([property, value]) => {
+    if (value) {
+      element.style.setProperty(property, value);
+    } else {
+      element.style.removeProperty(property);
+    }
+  });
+};
+
+var transitions = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  DEFAULT_TRANSITION_CONFIG: DEFAULT_TRANSITION_CONFIG,
+  applyStyles: applyStyles,
+  createContentSnapshot: createContentSnapshot,
+  getTransitionStyles: getTransitionStyles,
+  insertContentSnapshot: insertContentSnapshot,
+  removeContentSnapshot: removeContentSnapshot,
+  restoreOriginalStyles: restoreOriginalStyles,
+  scheduleDelayedStep: scheduleDelayedStep,
+  scheduleTransitionEnd: scheduleTransitionEnd,
+  scheduleTransitionStep: scheduleTransitionStep,
+  storeOriginalStyles: storeOriginalStyles,
+  waitForTransition: waitForTransition
+});
+
+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 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 === "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 = 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 {
+    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 {
+      getTransitionStyles,
+      applyStyles,
+      storeOriginalStyles,
+      restoreOriginalStyles,
+      waitForTransition,
+      createContentSnapshot,
+      insertContentSnapshot,
+      removeContentSnapshot,
+      scheduleTransitionEnd,
+      scheduleDelayedStep,
+      DEFAULT_TRANSITION_CONFIG
+    } = await Promise.resolve().then(function () { return transitions; });
+    const config = { ...DEFAULT_TRANSITION_CONFIG, ...transitionConfig };
+    const { duration = 300, easing = "ease-in-out", delay = 0 } = config;
+    const transitionStyles = config.styles || getTransitionStyles(config.type || "fade", duration, easing);
+    const transitionPromises = nodes.map(async (node) => {
+      if (!node || !node.parentElement) {
+        await performCoreDomUpdate(input, [node], timeout, Parser);
+        return node;
+      }
+      const element = node;
+      const parentElement = element.parentElement;
+      let contentSnapshot = null;
+      const shouldUseSnapshot = config.type === "fade";
+      if (shouldUseSnapshot) {
+        try {
+          contentSnapshot = createContentSnapshot(parentElement);
+          insertContentSnapshot(contentSnapshot, parentElement);
+        } catch (error) {
+          console.warn(
+            "Failed to create content snapshot, falling back to regular transition:",
+            error
+          );
+          contentSnapshot = null;
+        }
+      }
+      const stylesToStore = [
+        "opacity",
+        "transform",
+        "transition",
+        "overflow",
+        "position",
+        "z-index"
+      ];
+      const originalStyles = storeOriginalStyles(parentElement, stylesToStore);
+      return new Promise((resolve, reject) => {
+        const cleanup = () => {
+          if (contentSnapshot) {
+            removeContentSnapshot(contentSnapshot);
+          }
+          restoreOriginalStyles(parentElement, originalStyles);
+        };
+        const handleError = (error) => {
+          cleanup();
+          reject(error);
+        };
+        const startTransition = () => {
+          try {
+            applyStyles(parentElement, transitionStyles.exit);
+            parentElement.offsetHeight;
+            applyStyles(parentElement, transitionStyles.exitActive);
+            scheduleTransitionEnd(parentElement, duration / 2, performUpdate);
+          } catch (error) {
+            handleError(error);
+          }
+        };
+        const performUpdate = () => {
+          try {
+            performCoreDomUpdate(input, [node], timeout, Parser).then(() => {
+              applyStyles(parentElement, transitionStyles.enter);
+              parentElement.offsetHeight;
+              applyStyles(parentElement, transitionStyles.enterActive);
+              scheduleTransitionEnd(parentElement, duration / 2, finishTransition);
+            }).catch(handleError);
+          } catch (error) {
+            handleError(error);
+          }
+        };
+        const finishTransition = () => {
+          try {
+            cleanup();
+            resolve(node);
+          } catch (error) {
+            handleError(error);
+          }
+        };
+        scheduleDelayedStep(startTransition, delay);
+      });
+    });
+    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 { $, isServer as A, areDomNodesEqual as B, updateDomWithVdom as C, DEFAULT_TRANSITION_CONFIG as D, replaceDomWithVdom as E, Fragment as F, waitForDOM as G, parseDOM as H, isSVG as I, isHTML as J, isMarkup as K, renderMarkup as L, getMimeType as M, processAllFormElements as N, checkElementVisibility as O, getEventMap as P, addElementEvent as Q, removeElementEvent as R, clearElementEvents as S, domNodeToVNode as T, htmlStringToVNodes as U, queueCallback as V, Call as W, addNonChainedReturnCallNames as X, getNonChainedReturnCallNames as Y, isNonChainedReturnCall as Z, emptyImpl as _, renderIsomorphicAsync as a, CallChainImpl as a0, CallChainImplThenable as a1, scrollHelper as a2, getAllFormValues as a3, delayedAutoStart as a4, dequery as a5, isDequery as a6, isDequeryOptionsObject as a7, getDefaultDequeryOptions as a8, mapArrayIndexAccess as a9, createCall as aa, createGetterSetterCall as ab, createSubChain as ac, subChainForNextAwait as ad, runWithTimeGuard as ae, renderNode as af, resolveNodes as ag, traverse as ah, webstorage as ai, globalScopeDomApis as b, createInPlaceErrorMessageVNode as c, jsxs as d, jsxDEV as e, isRef as f, getRenderer as g, handleLifecycleEventsForOnMount as h, isJSX as i, jsx as j, createRef as k, getTransitionStyles as l, applyStyles as m, createContentSnapshot as n, observeUnmount as o, insertContentSnapshot as p, removeContentSnapshot as q, renderIsomorphicSync as r, scheduleTransitionStep as s, scheduleDelayedStep as t, updateDom as u, scheduleTransitionEnd as v, waitForTransition as w, storeOriginalStyles as x, restoreOriginalStyles as y, createStore as z };