sibujs 4.13.1 → 4.14.0

package/dist/ssr-dom.cjs

@@ -0,0 +1,1862 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ssr-dom.ts
+var ssr_dom_exports = {};
+__export(ssr_dom_exports, {
+  ServerDocument: () => ServerDocument,
+  ServerElement: () => ServerElement,
+  ServerNode: () => ServerNode,
+  createServerDocument: () => createServerDocument,
+  installServerDom: () => installServerDom,
+  isServerDom: () => isServerDom
+});
+module.exports = __toCommonJS(ssr_dom_exports);
+
+// src/core/dev.ts
+var DEV = typeof __SIBU_DEV__ !== "undefined" ? !!__SIBU_DEV__ : typeof globalThis.__SIBU_DEV__ !== "undefined" ? !!globalThis.__SIBU_DEV__ : (
+  // safe default: off in browser, on in test/dev Node
+  typeof process !== "undefined" && process.env?.NODE_ENV !== "production"
+);
+
+// src/core/ssr-context.ts
+var SSR_KEY = /* @__PURE__ */ Symbol.for("sibujs.ssr.v1");
+function detectSSRShared() {
+  let detected = null;
+  try {
+    if (typeof process !== "undefined" && process.versions && process.versions.node) {
+      let mod = null;
+      const getBuiltin = process.getBuiltinModule;
+      if (typeof getBuiltin === "function") {
+        mod = getBuiltin("node:async_hooks");
+      } else if (typeof require === "function") {
+        mod = require("async_hooks");
+      }
+      if (mod) detected = new mod.AsyncLocalStorage();
+    }
+    const globalAls = globalThis.AsyncLocalStorage;
+    if (!detected && typeof globalAls === "function") detected = new globalAls();
+  } catch {
+    detected = null;
+  }
+  return {
+    als: detected,
+    fallbackStore: { ssr: false, suspenseIdCounter: 0, locale: void 0 },
+    fallbackDepth: 0
+  };
+}
+var _shared = globalThis[SSR_KEY] ?? (globalThis[SSR_KEY] = detectSSRShared());
+var als = _shared.als;
+var fallbackStore = _shared.fallbackStore;
+_shared.fallbackDepth ?? (_shared.fallbackDepth = 0);
+function getRequestStore() {
+  if (als) return als.getStore() ?? null;
+  return _shared.fallbackDepth > 0 ? fallbackStore : null;
+}
+function requestSlot(name, create) {
+  const store = getRequestStore();
+  if (!store) return void 0;
+  const slots = store.slots ?? (store.slots = /* @__PURE__ */ new Map());
+  if (!slots.has(name) && create) slots.set(name, create());
+  return slots.get(name);
+}
+
+// src/platform/serverDom.ts
+var HTML_NS = "http://www.w3.org/1999/xhtml";
+var SVG_NS = "http://www.w3.org/2000/svg";
+var MATHML_NS = "http://www.w3.org/1998/Math/MathML";
+var ELEMENT_NODE = 1;
+var ATTRIBUTE_NODE = 2;
+var TEXT_NODE = 3;
+var COMMENT_NODE = 8;
+var DOCUMENT_NODE = 9;
+var DOCUMENT_FRAGMENT_NODE = 11;
+function callerFrame() {
+  const stack = new Error().stack ?? "";
+  const lines = stack.split("\n").slice(1);
+  for (const line of lines) {
+    if (line.includes("serverDom")) continue;
+    const trimmed = line.trim();
+    if (trimmed) return trimmed.replace(/^at\s+/, "");
+  }
+  return "(unknown caller)";
+}
+var warnedSites = /* @__PURE__ */ new Set();
+function reportBrowserApi(api) {
+  const frame = callerFrame();
+  const entry = `${api} at ${frame}`;
+  requestSlot("browserApis", () => /* @__PURE__ */ new Set())?.add(entry);
+  if (DEV && !warnedSites.has(entry) && warnedSites.size < 200) {
+    warnedSites.add(entry);
+    console.warn(
+      `[SibuJS SSR] ${api} was used during a server render (${frame}). It only exists in a browser: move the code into onMount() or an effect, or render it with ClientOnly().`
+    );
+  }
+  return frame;
+}
+function unavailable(api) {
+  const frame = reportBrowserApi(api);
+  throw new Error(
+    `[SibuJS SSR] ${api} is not available in the SibuJS server DOM (called from ${frame}). It needs a browser: call it from onMount() or an effect, or render the component with ClientOnly().`
+  );
+}
+function invalidCharacter(name) {
+  const Ctor = globalThis.DOMException;
+  const message = `"${name}" did not match the Name production`;
+  throw Ctor ? new Ctor(message, "InvalidCharacterError") : new Error(message);
+}
+var NAME_RE = /^[A-Za-z_:][-A-Za-z0-9_.:·À-￿]*$/;
+var ServerNodeList = class extends Array {
+  static get [Symbol.species]() {
+    return Array;
+  }
+  item(index) {
+    return this[index] ?? null;
+  }
+};
+var observations = [];
+function queueRecord(record) {
+  if (observations.length === 0) return;
+  for (const obs of observations) {
+    const o = obs.options;
+    const wants = record.type === "childList" ? o.childList : record.type === "attributes" ? o.attributes : o.characterData;
+    if (!wants) continue;
+    if (obs.target !== record.target && !(o.subtree && obs.target.contains(record.target))) continue;
+    obs.observer._enqueue(record);
+  }
+}
+var ServerMutationObserver = class {
+  constructor(callback) {
+    this.callback = callback;
+    this.records = [];
+    this.scheduled = false;
+  }
+  observe(target, options = {}) {
+    const opts = { ...options };
+    if (opts.attributeFilter || opts.attributeOldValue) opts.attributes ?? (opts.attributes = true);
+    if (opts.characterDataOldValue) opts.characterData ?? (opts.characterData = true);
+    const existing = observations.find((o) => o.observer === this && o.target === target);
+    if (existing) existing.options = opts;
+    else observations.push({ observer: this, target, options: opts });
+  }
+  disconnect() {
+    for (let i = observations.length - 1; i >= 0; i--) if (observations[i].observer === this) observations.splice(i, 1);
+    this.records = [];
+  }
+  takeRecords() {
+    const out = this.records;
+    this.records = [];
+    return out;
+  }
+  /** @internal */
+  _enqueue(record) {
+    this.records.push(record);
+    if (this.scheduled) return;
+    this.scheduled = true;
+    queueMicrotask(() => {
+      this.scheduled = false;
+      const records = this.takeRecords();
+      if (records.length > 0) this.callback(records, this);
+    });
+  }
+};
+var _ServerNode = class _ServerNode {
+  constructor(ownerDocument) {
+    this.ownerDocument = ownerDocument;
+    /** @internal */
+    this._parent = null;
+    /** @internal */
+    this._prev = null;
+    /** @internal */
+    this._next = null;
+    /** @internal */
+    this._first = null;
+    /** @internal */
+    this._last = null;
+    /** @internal */
+    this._count = 0;
+    /** @internal */
+    this._list = null;
+    /** @internal */
+    this._listeners = null;
+  }
+  get nodeType() {
+    return 0;
+  }
+  get nodeName() {
+    return "";
+  }
+  get nodeValue() {
+    return null;
+  }
+  set nodeValue(_value) {
+  }
+  get parentNode() {
+    return this._parent;
+  }
+  get parentElement() {
+    return this._parent instanceof ServerElement ? this._parent : null;
+  }
+  get firstChild() {
+    return this._first;
+  }
+  get lastChild() {
+    return this._last;
+  }
+  get nextSibling() {
+    return this._next;
+  }
+  get previousSibling() {
+    return this._prev;
+  }
+  get childNodes() {
+    if (!this._list) {
+      const list = new ServerNodeList();
+      for (let n = this._first; n; n = n._next) list.push(n);
+      this._list = list;
+    }
+    return this._list;
+  }
+  hasChildNodes() {
+    return this._first !== null;
+  }
+  get isConnected() {
+    let n = this;
+    while (n) {
+      if (n.nodeType === DOCUMENT_NODE) return true;
+      n = n._parent;
+    }
+    return false;
+  }
+  getRootNode() {
+    let n = this;
+    while (n._parent) n = n._parent;
+    return n;
+  }
+  get textContent() {
+    let out = "";
+    for (let n = this._first; n; n = n._next) {
+      if (n.nodeType === TEXT_NODE) out += n.data;
+      else if (n.nodeType === ELEMENT_NODE || n.nodeType === DOCUMENT_FRAGMENT_NODE) out += n.textContent ?? "";
+    }
+    return out;
+  }
+  set textContent(value) {
+    while (this._first) this.removeChild(this._first);
+    const text = value == null ? "" : String(value);
+    if (text !== "") this.appendChild(new ServerText(this.ownerDocument, text));
+  }
+  contains(other) {
+    for (let n = other; n; n = n._parent) if (n === this) return true;
+    return false;
+  }
+  compareDocumentPosition(other) {
+    if (other === this) return 0;
+    if (this.getRootNode() !== other.getRootNode()) return 1 | 32;
+    if (this.contains(other)) return 16 | 4;
+    if (other.contains(this)) return 8 | 2;
+    const chain = (n) => {
+      const out = [];
+      for (let c = n; c; c = c._parent) out.unshift(c);
+      return out;
+    };
+    const a = chain(this);
+    const b = chain(other);
+    let i = 0;
+    while (a[i] === b[i]) i++;
+    for (let n = a[i]._next; n; n = n._next) if (n === b[i]) return 4;
+    return 2;
+  }
+  // ── Mutation ──
+  /** @internal */
+  _assertParentOf(node) {
+    if (!(node instanceof _ServerNode))
+      throw new TypeError("Failed to execute on Node: parameter is not of type 'Node'.");
+    if (node.contains(this)) {
+      const Ctor = globalThis.DOMException;
+      const message = "The new child element contains the parent.";
+      throw Ctor ? new Ctor(message, "HierarchyRequestError") : new Error(message);
+    }
+  }
+  insertBefore(node, ref) {
+    if (ref && ref._parent !== this) {
+      const Ctor = globalThis.DOMException;
+      const message = "The node before which the new node is to be inserted is not a child of this node.";
+      throw Ctor ? new Ctor(message, "NotFoundError") : new Error(message);
+    }
+    if (node.nodeType === DOCUMENT_FRAGMENT_NODE) {
+      const moved = [];
+      while (node._first) {
+        const child = node._first;
+        node._unlink(child, true);
+        moved.push(child);
+      }
+      for (const child of moved) this._link(child, ref, true);
+      if (moved.length > 0) this._recordChildList(moved, [], moved[0]._prev, ref);
+      return node;
+    }
+    this._assertParentOf(node);
+    if (ref === node) ref = node._next;
+    if (node._parent) node._parent.removeChild(node);
+    this._link(node, ref, false);
+    this._recordChildList([node], [], node._prev, node._next);
+    return node;
+  }
+  appendChild(node) {
+    return this.insertBefore(node, null);
+  }
+  removeChild(node) {
+    if (node._parent !== this) {
+      const Ctor = globalThis.DOMException;
+      const message = "The node to be removed is not a child of this node.";
+      throw Ctor ? new Ctor(message, "NotFoundError") : new Error(message);
+    }
+    const prev = node._prev;
+    const next = node._next;
+    this._unlink(node, false);
+    this._recordChildList([], [node], prev, next);
+    return node;
+  }
+  replaceChild(node, old) {
+    if (node === old) return old;
+    const next = old._next === node ? node._next : old._next;
+    this.removeChild(old);
+    this.insertBefore(node, next);
+    return old;
+  }
+  /** @internal */
+  _link(node, ref, quiet) {
+    node._parent = this;
+    if (ref) {
+      node._prev = ref._prev;
+      node._next = ref;
+      if (ref._prev) ref._prev._next = node;
+      else this._first = node;
+      ref._prev = node;
+    } else {
+      node._prev = this._last;
+      node._next = null;
+      if (this._last) this._last._next = node;
+      else this._first = node;
+      this._last = node;
+    }
+    this._count++;
+    this._list = null;
+    void quiet;
+  }
+  /** @internal */
+  _unlink(node, quiet) {
+    if (node._prev) node._prev._next = node._next;
+    else this._first = node._next;
+    if (node._next) node._next._prev = node._prev;
+    else this._last = node._prev;
+    node._parent = null;
+    node._prev = null;
+    node._next = null;
+    this._count--;
+    this._list = null;
+    void quiet;
+  }
+  /** @internal */
+  _recordChildList(added, removed, prev, next) {
+    if (observations.length === 0) return;
+    queueRecord({
+      type: "childList",
+      target: this,
+      addedNodes: added,
+      removedNodes: removed,
+      previousSibling: prev,
+      nextSibling: next,
+      attributeName: null,
+      attributeNamespace: null,
+      oldValue: null
+    });
+  }
+  // ── ChildNode / ParentNode ──
+  remove() {
+    this._parent?.removeChild(this);
+  }
+  replaceWith(...nodes) {
+    const parent = this._parent;
+    if (!parent) return;
+    const next = this._next;
+    parent.removeChild(this);
+    for (const n of nodes) parent.insertBefore(toNode(this.ownerDocument, n), next);
+  }
+  before(...nodes) {
+    const parent = this._parent;
+    if (!parent) return;
+    for (const n of nodes) parent.insertBefore(toNode(this.ownerDocument, n), this);
+  }
+  after(...nodes) {
+    const parent = this._parent;
+    if (!parent) return;
+    const next = this._next;
+    for (const n of nodes) parent.insertBefore(toNode(this.ownerDocument, n), next);
+  }
+  append(...nodes) {
+    for (const n of nodes) this.appendChild(toNode(this.ownerDocument, n));
+  }
+  prepend(...nodes) {
+    const first = this._first;
+    for (const n of nodes) this.insertBefore(toNode(this.ownerDocument, n), first);
+  }
+  replaceChildren(...nodes) {
+    while (this._first) this.removeChild(this._first);
+    this.append(...nodes);
+  }
+  get children() {
+    const list = new ServerNodeList();
+    for (let n = this._first; n; n = n._next) if (n.nodeType === ELEMENT_NODE) list.push(n);
+    return list;
+  }
+  get childElementCount() {
+    let c = 0;
+    for (let n = this._first; n; n = n._next) if (n.nodeType === ELEMENT_NODE) c++;
+    return c;
+  }
+  get firstElementChild() {
+    for (let n = this._first; n; n = n._next) if (n.nodeType === ELEMENT_NODE) return n;
+    return null;
+  }
+  get lastElementChild() {
+    for (let n = this._last; n; n = n._prev) if (n.nodeType === ELEMENT_NODE) return n;
+    return null;
+  }
+  get nextElementSibling() {
+    for (let n = this._next; n; n = n._next) if (n.nodeType === ELEMENT_NODE) return n;
+    return null;
+  }
+  get previousElementSibling() {
+    for (let n = this._prev; n; n = n._prev) if (n.nodeType === ELEMENT_NODE) return n;
+    return null;
+  }
+  querySelector(selector) {
+    const sel = compileSelector(selector);
+    let found = null;
+    walkElements(this, (el) => {
+      if (matchesCompiled(el, sel, this)) {
+        found = el;
+        return true;
+      }
+      return false;
+    });
+    return found;
+  }
+  querySelectorAll(selector) {
+    const sel = compileSelector(selector);
+    const out = new ServerNodeList();
+    walkElements(this, (el) => {
+      if (matchesCompiled(el, sel, this)) out.push(el);
+      return false;
+    });
+    return out;
+  }
+  getElementsByTagName(name) {
+    return this.querySelectorAll(name === "*" ? "*" : name);
+  }
+  getElementsByClassName(names) {
+    const selector = names.trim().split(/\s+/).filter(Boolean).map((n) => `.${n}`).join("");
+    return selector ? this.querySelectorAll(selector) : new ServerNodeList();
+  }
+  cloneNode(deep = false) {
+    const copy = this._shallowClone();
+    if (deep) for (let n = this._first; n; n = n._next) copy.appendChild(n.cloneNode(true));
+    return copy;
+  }
+  /** @internal */
+  _shallowClone() {
+    return new _ServerNode(this.ownerDocument);
+  }
+  isEqualNode(other) {
+    return !!other && serializeForDebug(this) === serializeForDebug(other);
+  }
+  isSameNode(other) {
+    return other === this;
+  }
+  normalize() {
+    for (let n = this._first; n; ) {
+      const next = n._next;
+      if (n.nodeType === TEXT_NODE) {
+        const text = n;
+        if (text.data === "") this.removeChild(n);
+        else
+          while (text._next && text._next.nodeType === TEXT_NODE) {
+            text.data += text._next.data;
+            this.removeChild(text._next);
+          }
+      } else n.normalize();
+      n = n._parent === this ? n._next : next;
+    }
+  }
+  // ── EventTarget ──
+  addEventListener(type, fn, options) {
+    if (!fn) return;
+    const capture = typeof options === "boolean" ? options : !!options?.capture;
+    const once = typeof options === "object" && !!options?.once;
+    const map = this._listeners ?? (this._listeners = /* @__PURE__ */ new Map());
+    const list = map.get(type) ?? [];
+    if (list.some((l) => l.fn === fn && l.capture === capture)) return;
+    list.push({ fn, capture, once });
+    map.set(type, list);
+    const signal = typeof options === "object" ? options?.signal : void 0;
+    signal?.addEventListener("abort", () => this.removeEventListener(type, fn, options), { once: true });
+  }
+  removeEventListener(type, fn, options) {
+    const list = this._listeners?.get(type);
+    if (!list || !fn) return;
+    const capture = typeof options === "boolean" ? options : !!options?.capture;
+    const i = list.findIndex((l) => l.fn === fn && l.capture === capture);
+    if (i !== -1) list.splice(i, 1);
+  }
+  dispatchEvent(event) {
+    const ev = event;
+    let stopped = false;
+    let stoppedNow = false;
+    const ownStop = ev.stopPropagation.bind(ev);
+    const ownStopNow = ev.stopImmediatePropagation.bind(ev);
+    defineOwn(ev, "stopPropagation", () => {
+      stopped = true;
+      ownStop();
+    });
+    defineOwn(ev, "stopImmediatePropagation", () => {
+      stopped = true;
+      stoppedNow = true;
+      ownStopNow();
+    });
+    defineOwn(ev, "target", this);
+    const path = [];
+    for (let n = this; n; n = n._parent) path.push(n);
+    const phase = (node, capture) => {
+      const list = node._listeners?.get(ev.type);
+      if (!list) return;
+      defineOwn(ev, "currentTarget", node);
+      for (const l of list.slice()) {
+        if (capture !== null && l.capture !== capture) continue;
+        if (l.once) node.removeEventListener(ev.type, l.fn, l.capture);
+        if (typeof l.fn === "function") l.fn.call(node, event);
+        else l.fn.handleEvent(event);
+        if (stoppedNow) return;
+      }
+    };
+    for (let i = path.length - 1; i > 0 && !stopped; i--) phase(path[i], true);
+    if (!stopped) phase(this, null);
+    if (ev.bubbles) for (let i = 1; i < path.length && !stopped; i++) phase(path[i], false);
+    defineOwn(ev, "currentTarget", null);
+    return !ev.defaultPrevented;
+  }
+};
+_ServerNode.ELEMENT_NODE = ELEMENT_NODE;
+_ServerNode.ATTRIBUTE_NODE = ATTRIBUTE_NODE;
+_ServerNode.TEXT_NODE = TEXT_NODE;
+_ServerNode.COMMENT_NODE = COMMENT_NODE;
+_ServerNode.DOCUMENT_NODE = DOCUMENT_NODE;
+_ServerNode.DOCUMENT_FRAGMENT_NODE = DOCUMENT_FRAGMENT_NODE;
+_ServerNode.DOCUMENT_POSITION_DISCONNECTED = 1;
+_ServerNode.DOCUMENT_POSITION_PRECEDING = 2;
+_ServerNode.DOCUMENT_POSITION_FOLLOWING = 4;
+_ServerNode.DOCUMENT_POSITION_CONTAINS = 8;
+_ServerNode.DOCUMENT_POSITION_CONTAINED_BY = 16;
+var ServerNode = _ServerNode;
+function defineOwn(obj, key, value) {
+  Object.defineProperty(obj, key, { value, configurable: true, writable: true });
+}
+function toNode(doc, n) {
+  return typeof n === "string" ? new ServerText(doc, n) : n;
+}
+function walkElements(root, visit) {
+  for (let n = root._first; n; n = n._next) {
+    if (n.nodeType === ELEMENT_NODE) {
+      if (visit(n)) return true;
+      if (walkElements(n, visit)) return true;
+    } else if (n.nodeType === DOCUMENT_FRAGMENT_NODE && walkElements(n, visit)) return true;
+  }
+  return false;
+}
+var ServerCharacterData = class extends ServerNode {
+  constructor(doc, data) {
+    super(doc);
+    this._data = data;
+  }
+  get data() {
+    return this._data;
+  }
+  set data(value) {
+    const old = this._data;
+    this._data = value == null ? "" : String(value);
+    if (observations.length > 0) {
+      queueRecord({
+        type: "characterData",
+        target: this,
+        addedNodes: [],
+        removedNodes: [],
+        previousSibling: null,
+        nextSibling: null,
+        attributeName: null,
+        attributeNamespace: null,
+        oldValue: old
+      });
+    }
+  }
+  get length() {
+    return this._data.length;
+  }
+  get nodeValue() {
+    return this._data;
+  }
+  set nodeValue(value) {
+    this.data = value ?? "";
+  }
+  get textContent() {
+    return this._data;
+  }
+  set textContent(value) {
+    this.data = value ?? "";
+  }
+  appendChild(_node) {
+    throw new TypeError("This node type does not support this method.");
+  }
+  insertBefore(_node, _ref) {
+    throw new TypeError("This node type does not support this method.");
+  }
+};
+var ServerText = class _ServerText extends ServerCharacterData {
+  get nodeType() {
+    return TEXT_NODE;
+  }
+  get nodeName() {
+    return "#text";
+  }
+  get wholeText() {
+    return this._data;
+  }
+  splitText(offset) {
+    const rest = new _ServerText(this.ownerDocument, this._data.slice(offset));
+    this.data = this._data.slice(0, offset);
+    this._parent?.insertBefore(rest, this._next);
+    return rest;
+  }
+  _shallowClone() {
+    return new _ServerText(this.ownerDocument, this._data);
+  }
+};
+var ServerComment = class _ServerComment extends ServerCharacterData {
+  get nodeType() {
+    return COMMENT_NODE;
+  }
+  get nodeName() {
+    return "#comment";
+  }
+  _shallowClone() {
+    return new _ServerComment(this.ownerDocument, this._data);
+  }
+};
+var ServerDocumentFragment = class _ServerDocumentFragment extends ServerNode {
+  get nodeType() {
+    return DOCUMENT_FRAGMENT_NODE;
+  }
+  get nodeName() {
+    return "#document-fragment";
+  }
+  getElementById(id) {
+    return this.querySelector(`#${cssEscapeIdent(id)}`);
+  }
+  _shallowClone() {
+    return new _ServerDocumentFragment(this.ownerDocument);
+  }
+};
+var ServerAttr = class {
+  constructor(ownerElement, namespaceURI, prefix, localName, value) {
+    this.ownerElement = ownerElement;
+    this.namespaceURI = namespaceURI;
+    this.prefix = prefix;
+    this.localName = localName;
+    this.nodeType = ATTRIBUTE_NODE;
+    this.specified = true;
+    this._value = value;
+  }
+  get name() {
+    return this.prefix ? `${this.prefix}:${this.localName}` : this.localName;
+  }
+  get nodeName() {
+    return this.name;
+  }
+  get value() {
+    return this._value;
+  }
+  set value(v) {
+    if (this.ownerElement) this.ownerElement.setAttributeNS(this.namespaceURI, this.name, v);
+    else this._value = String(v);
+  }
+  get nodeValue() {
+    return this._value;
+  }
+  get textContent() {
+    return this._value;
+  }
+};
+var ServerNamedNodeMap = class extends Array {
+  static get [Symbol.species]() {
+    return Array;
+  }
+  item(index) {
+    return this[index] ?? null;
+  }
+  getNamedItem(name) {
+    return this.find((a) => a.name === name) ?? null;
+  }
+  getNamedItemNS(ns, localName) {
+    return this.find((a) => a.namespaceURI === (ns || null) && a.localName === localName) ?? null;
+  }
+};
+function splitDeclarations(text) {
+  const out = [];
+  let depth = 0;
+  let quote = "";
+  let start = 0;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (quote) {
+      if (c === "\\") i++;
+      else if (c === quote) quote = "";
+    } else if (c === '"' || c === "'") quote = c;
+    else if (c === "(") depth++;
+    else if (c === ")") depth = Math.max(0, depth - 1);
+    else if (c === ";" && depth === 0) {
+      out.push(text.slice(start, i));
+      start = i + 1;
+    }
+  }
+  out.push(text.slice(start));
+  return out;
+}
+var CAMEL_EXCEPTIONS = { cssFloat: "float" };
+function toKebab(prop) {
+  if (prop.startsWith("--")) return prop;
+  if (Object.hasOwn(CAMEL_EXCEPTIONS, prop)) return CAMEL_EXCEPTIONS[prop];
+  return prop.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`).replace(/^(webkit|moz|ms)-/, "-$1-");
+}
+var ServerStyle = class {
+  constructor(el) {
+    this.el = el;
+    /** @internal */
+    this._decls = /* @__PURE__ */ new Map();
+    /** @internal */
+    this._parsedFrom = null;
+  }
+  /** @internal */
+  _sync() {
+    const attr = this.el.getAttribute("style");
+    if (attr === this._parsedFrom) return;
+    this._decls = /* @__PURE__ */ new Map();
+    this._parsedFrom = attr;
+    if (!attr) return;
+    for (const decl of splitDeclarations(attr)) {
+      const colon = decl.indexOf(":");
+      if (colon === -1) continue;
+      const name = decl.slice(0, colon).trim();
+      let value = decl.slice(colon + 1).trim();
+      if (!name || !value) continue;
+      let priority = "";
+      const bang = value.lastIndexOf("!");
+      if (bang !== -1 && /^!\s*important$/i.test(value.slice(bang))) {
+        priority = "important";
+        value = value.slice(0, bang).trim();
+      }
+      this._decls.set(name.startsWith("--") ? name : name.toLowerCase(), { value, priority });
+    }
+  }
+  /** @internal */
+  _commit() {
+    const text = this.cssText;
+    this._parsedFrom = text === "" ? null : text;
+    if (text === "") this.el.removeAttribute("style");
+    else this.el.setAttribute("style", text);
+    this._parsedFrom = this.el.getAttribute("style");
+  }
+  get cssText() {
+    this._sync();
+    const parts = [];
+    for (const [name, d] of this._decls) parts.push(`${name}: ${d.value}${d.priority ? " !important" : ""};`);
+    return parts.join(" ");
+  }
+  set cssText(text) {
+    this.el.setAttribute("style", String(text ?? ""));
+    this._sync();
+    if (this._decls.size === 0) this.el.removeAttribute("style");
+    else this._commit();
+  }
+  get length() {
+    this._sync();
+    return this._decls.size;
+  }
+  item(index) {
+    this._sync();
+    return Array.from(this._decls.keys())[index] ?? "";
+  }
+  getPropertyValue(name) {
+    this._sync();
+    return this._decls.get(name.startsWith("--") ? name : name.toLowerCase())?.value ?? "";
+  }
+  getPropertyPriority(name) {
+    this._sync();
+    return this._decls.get(name.startsWith("--") ? name : name.toLowerCase())?.priority ?? "";
+  }
+  setProperty(name, value, priority = "") {
+    this._sync();
+    const key = name.startsWith("--") ? name : name.toLowerCase();
+    const v = value == null ? "" : String(value).trim();
+    if (v === "") {
+      this.removeProperty(key);
+      return;
+    }
+    this._decls.set(key, { value: v, priority: priority === "important" ? "important" : "" });
+    this._commit();
+  }
+  removeProperty(name) {
+    this._sync();
+    const key = name.startsWith("--") ? name : name.toLowerCase();
+    const old = this._decls.get(key)?.value ?? "";
+    if (this._decls.delete(key)) this._commit();
+    return old;
+  }
+  *[Symbol.iterator]() {
+    this._sync();
+    yield* this._decls.keys();
+  }
+};
+function styleProxy(style) {
+  return new Proxy(style, {
+    get(target, key, receiver) {
+      if (typeof key === "string" && !(key in target)) {
+        if (/^\d+$/.test(key)) return target.item(Number(key));
+        return target.getPropertyValue(toKebab(key));
+      }
+      return Reflect.get(target, key, receiver);
+    },
+    set(target, key, value, receiver) {
+      if (typeof key === "string" && !(key in target)) {
+        target.setProperty(toKebab(key), value == null ? "" : String(value));
+        return true;
+      }
+      return Reflect.set(target, key, value, receiver);
+    }
+  });
+}
+var ServerTokenList = class {
+  constructor(el, attr) {
+    this.el = el;
+    this.attr = attr;
+  }
+  tokens() {
+    return (this.el.getAttribute(this.attr) ?? "").split(/\s+/).filter(Boolean);
+  }
+  write(tokens) {
+    this.el.setAttribute(this.attr, Array.from(new Set(tokens)).join(" "));
+  }
+  get length() {
+    return new Set(this.tokens()).size;
+  }
+  get value() {
+    return this.el.getAttribute(this.attr) ?? "";
+  }
+  set value(v) {
+    this.el.setAttribute(this.attr, v);
+  }
+  item(i) {
+    return Array.from(new Set(this.tokens()))[i] ?? null;
+  }
+  contains(token) {
+    return this.tokens().includes(token);
+  }
+  add(...tokens) {
+    this.write([...this.tokens(), ...tokens]);
+  }
+  remove(...tokens) {
+    this.write(this.tokens().filter((t) => !tokens.includes(t)));
+  }
+  toggle(token, force) {
+    const has = this.contains(token);
+    const want = force === void 0 ? !has : force;
+    if (want && !has) this.add(token);
+    else if (!want && has) this.remove(token);
+    return want;
+  }
+  replace(oldToken, newToken) {
+    const tokens = this.tokens();
+    const i = tokens.indexOf(oldToken);
+    if (i === -1) return false;
+    tokens[i] = newToken;
+    this.write(tokens);
+    return true;
+  }
+  forEach(fn) {
+    Array.from(new Set(this.tokens())).forEach(fn);
+  }
+  [Symbol.iterator]() {
+    return new Set(this.tokens()).values();
+  }
+  toString() {
+    return this.value;
+  }
+};
+function datasetKeyToAttr(key) {
+  return `data-${key.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`)}`;
+}
+var ServerElement = class _ServerElement extends ServerNode {
+  constructor(doc, localName, namespaceURI, prefix = null) {
+    super(doc);
+    this.localName = localName;
+    this.namespaceURI = namespaceURI;
+    this.prefix = prefix;
+    /** @internal */
+    this._attrs = new ServerNamedNodeMap();
+    /** @internal */
+    this._style = null;
+    /** @internal */
+    this._classList = null;
+    this.scrollTop = 0;
+    this.scrollLeft = 0;
+  }
+  get nodeType() {
+    return ELEMENT_NODE;
+  }
+  get isHtml() {
+    return this.namespaceURI === HTML_NS;
+  }
+  get tagName() {
+    const q = this.prefix ? `${this.prefix}:${this.localName}` : this.localName;
+    return this.isHtml ? q.toUpperCase() : q;
+  }
+  get nodeName() {
+    return this.tagName;
+  }
+  get attributes() {
+    return this._attrs;
+  }
+  findAttr(name) {
+    const n = this.isHtml ? name.toLowerCase() : name;
+    return this._attrs.find((a) => a.name === n);
+  }
+  getAttribute(name) {
+    return this.findAttr(String(name))?.value ?? null;
+  }
+  getAttributeNames() {
+    return this._attrs.map((a) => a.name);
+  }
+  hasAttribute(name) {
+    return this.findAttr(String(name)) !== void 0;
+  }
+  hasAttributes() {
+    return this._attrs.length > 0;
+  }
+  setAttribute(name, value) {
+    name = String(name);
+    if (!NAME_RE.test(name)) invalidCharacter(name);
+    const v = String(value);
+    const existing = this.findAttr(name);
+    const old = existing ? existing._value : null;
+    if (existing) existing._value = v;
+    else this._attrs.push(new ServerAttr(this, null, null, this.isHtml ? name.toLowerCase() : name, v));
+    this._recordAttr(this.isHtml ? name.toLowerCase() : name, null, old);
+  }
+  removeAttribute(name) {
+    const attr = this.findAttr(String(name));
+    if (!attr) return;
+    this._attrs.splice(this._attrs.indexOf(attr), 1);
+    this._recordAttr(attr.name, attr.namespaceURI, attr._value);
+  }
+  toggleAttribute(name, force) {
+    const has = this.hasAttribute(name);
+    const want = force === void 0 ? !has : force;
+    if (want && !has) this.setAttribute(name, "");
+    else if (!want && has) this.removeAttribute(name);
+    return want;
+  }
+  getAttributeNS(ns, localName) {
+    return this._attrs.getNamedItemNS(ns, localName)?.value ?? null;
+  }
+  hasAttributeNS(ns, localName) {
+    return this._attrs.getNamedItemNS(ns, localName) !== null;
+  }
+  setAttributeNS(ns, qualifiedName, value) {
+    if (!NAME_RE.test(qualifiedName)) invalidCharacter(qualifiedName);
+    const colon = qualifiedName.indexOf(":");
+    const prefix = colon === -1 ? null : qualifiedName.slice(0, colon);
+    const localName = colon === -1 ? qualifiedName : qualifiedName.slice(colon + 1);
+    const namespace = ns || null;
+    if (namespace === null) {
+      this.setAttribute(qualifiedName, value);
+      return;
+    }
+    const existing = this._attrs.getNamedItemNS(namespace, localName);
+    const old = existing ? existing._value : null;
+    if (existing) existing._value = String(value);
+    else this._attrs.push(new ServerAttr(this, namespace, prefix, localName, String(value)));
+    this._recordAttr(localName, namespace, old);
+  }
+  removeAttributeNS(ns, localName) {
+    const attr = this._attrs.getNamedItemNS(ns, localName);
+    if (!attr) return;
+    this._attrs.splice(this._attrs.indexOf(attr), 1);
+    this._recordAttr(localName, attr.namespaceURI, attr._value);
+  }
+  getAttributeNode(name) {
+    return this.findAttr(name) ?? null;
+  }
+  /** @internal */
+  _recordAttr(name, ns, oldValue) {
+    if (observations.length === 0) return;
+    queueRecord({
+      type: "attributes",
+      target: this,
+      addedNodes: [],
+      removedNodes: [],
+      previousSibling: null,
+      nextSibling: null,
+      attributeName: name,
+      attributeNamespace: ns,
+      oldValue
+    });
+  }
+  get id() {
+    return this.getAttribute("id") ?? "";
+  }
+  set id(v) {
+    this.setAttribute("id", v);
+  }
+  get className() {
+    return this.getAttribute("class") ?? "";
+  }
+  set className(v) {
+    this.setAttribute("class", v);
+  }
+  get classList() {
+    this._classList ?? (this._classList = new ServerTokenList(this, "class"));
+    return this._classList;
+  }
+  get style() {
+    this._style ?? (this._style = styleProxy(new ServerStyle(this)));
+    return this._style;
+  }
+  set style(v) {
+    this.style.cssText = v;
+  }
+  get dataset() {
+    return new Proxy(
+      {},
+      {
+        get: (_t, key) => typeof key === "string" ? this.getAttribute(datasetKeyToAttr(key)) ?? void 0 : void 0,
+        set: (_t, key, value) => {
+          if (typeof key === "string") this.setAttribute(datasetKeyToAttr(key), String(value));
+          return true;
+        },
+        deleteProperty: (_t, key) => {
+          if (typeof key === "string") this.removeAttribute(datasetKeyToAttr(key));
+          return true;
+        },
+        has: (_t, key) => typeof key === "string" && this.hasAttribute(datasetKeyToAttr(key)),
+        ownKeys: () => this._attrs.filter((a) => a.name.startsWith("data-")).map((a) => a.name.slice(5).replace(/-([a-z])/g, (_m, c) => c.toUpperCase())),
+        getOwnPropertyDescriptor: (_t, key) => typeof key === "string" && this.hasAttribute(datasetKeyToAttr(key)) ? { enumerable: true, configurable: true, value: this.getAttribute(datasetKeyToAttr(key)) } : void 0
+      }
+    );
+  }
+  get innerHTML() {
+    let out = "";
+    for (let n = this._first; n; n = n._next) out += serializeForDebug(n);
+    return out;
+  }
+  set innerHTML(_value) {
+    unavailable("Element.innerHTML assignment (the server DOM has no HTML parser)");
+  }
+  get outerHTML() {
+    return serializeForDebug(this);
+  }
+  insertAdjacentHTML() {
+    unavailable("Element.insertAdjacentHTML()");
+  }
+  matches(selector) {
+    return matchesCompiled(this, compileSelector(selector), null);
+  }
+  closest(selector) {
+    const sel = compileSelector(selector);
+    for (let n = this; n; n = n._parent) {
+      if (n instanceof _ServerElement && matchesCompiled(n, sel, null)) return n;
+    }
+    return null;
+  }
+  // ── Layout and focus: no-ops on a server ──
+  focus() {
+  }
+  blur() {
+  }
+  click() {
+    const Ctor = globalThis.Event;
+    if (Ctor) this.dispatchEvent(new Ctor("click", { bubbles: true, cancelable: true }));
+  }
+  scrollIntoView() {
+  }
+  scrollTo() {
+  }
+  scrollBy() {
+  }
+  getBoundingClientRect() {
+    return { x: 0, y: 0, width: 0, height: 0, top: 0, right: 0, bottom: 0, left: 0, toJSON: () => ({}) };
+  }
+  getClientRects() {
+    return [];
+  }
+  get offsetWidth() {
+    return 0;
+  }
+  get offsetHeight() {
+    return 0;
+  }
+  get offsetTop() {
+    return 0;
+  }
+  get offsetLeft() {
+    return 0;
+  }
+  get offsetParent() {
+    return null;
+  }
+  get clientWidth() {
+    return 0;
+  }
+  get clientHeight() {
+    return 0;
+  }
+  get scrollWidth() {
+    return 0;
+  }
+  get scrollHeight() {
+    return 0;
+  }
+  // ── Browser-only APIs: a clear error instead of "is not a function" ──
+  animate() {
+    return unavailable("Element.animate()");
+  }
+  getAnimations() {
+    return unavailable("Element.getAnimations()");
+  }
+  attachShadow() {
+    return unavailable("Element.attachShadow()");
+  }
+  requestFullscreen() {
+    return unavailable("Element.requestFullscreen()");
+  }
+  requestPointerLock() {
+    return unavailable("Element.requestPointerLock()");
+  }
+  setPointerCapture() {
+    return unavailable("Element.setPointerCapture()");
+  }
+  _shallowClone() {
+    const copy = this.ownerDocument ? this.ownerDocument.createElementNS(
+      this.namespaceURI,
+      this.prefix ? `${this.prefix}:${this.localName}` : this.localName
+    ) : new _ServerElement(null, this.localName, this.namespaceURI, this.prefix);
+    for (const a of this._attrs)
+      copy._attrs.push(new ServerAttr(copy, a.namespaceURI, a.prefix, a.localName, a._value));
+    return copy;
+  }
+};
+var ServerHTMLElement = class extends ServerElement {
+  get hidden() {
+    return this.hasAttribute("hidden");
+  }
+  set hidden(v) {
+    this.toggleAttribute("hidden", !!v);
+  }
+  get title() {
+    return this.getAttribute("title") ?? "";
+  }
+  set title(v) {
+    this.setAttribute("title", v);
+  }
+  get lang() {
+    return this.getAttribute("lang") ?? "";
+  }
+  set lang(v) {
+    this.setAttribute("lang", v);
+  }
+  get dir() {
+    return this.getAttribute("dir") ?? "";
+  }
+  set dir(v) {
+    this.setAttribute("dir", v);
+  }
+  get tabIndex() {
+    const v = Number.parseInt(this.getAttribute("tabindex") ?? "", 10);
+    return Number.isNaN(v) ? -1 : v;
+  }
+  set tabIndex(v) {
+    this.setAttribute("tabindex", String(v));
+  }
+  get innerText() {
+    return this.textContent ?? "";
+  }
+  set innerText(v) {
+    this.textContent = v;
+  }
+};
+function reflectDisabled(proto) {
+  Object.defineProperty(proto, "disabled", {
+    get() {
+      return this.hasAttribute("disabled");
+    },
+    set(v) {
+      this.toggleAttribute("disabled", !!v);
+    },
+    configurable: true
+  });
+}
+var ServerInputElement = class extends ServerHTMLElement {
+  constructor() {
+    super(...arguments);
+    /** @internal */
+    this._value = null;
+    /** @internal */
+    this._checked = null;
+  }
+  get value() {
+    return this._value ?? this.getAttribute("value") ?? "";
+  }
+  set value(v) {
+    this._value = v == null ? "" : String(v);
+  }
+  get defaultValue() {
+    return this.getAttribute("value") ?? "";
+  }
+  set defaultValue(v) {
+    this.setAttribute("value", v);
+  }
+  get checked() {
+    return this._checked ?? this.hasAttribute("checked");
+  }
+  set checked(v) {
+    this._checked = !!v;
+  }
+  get defaultChecked() {
+    return this.hasAttribute("checked");
+  }
+  get type() {
+    return (this.getAttribute("type") ?? "text").toLowerCase();
+  }
+  set type(v) {
+    this.setAttribute("type", v);
+  }
+  get name() {
+    return this.getAttribute("name") ?? "";
+  }
+  set name(v) {
+    this.setAttribute("name", v);
+  }
+  select() {
+  }
+  setSelectionRange() {
+  }
+  checkValidity() {
+    return true;
+  }
+  reportValidity() {
+    return true;
+  }
+};
+reflectDisabled(ServerInputElement.prototype);
+var ServerTextAreaElement = class extends ServerHTMLElement {
+  constructor() {
+    super(...arguments);
+    /** @internal */
+    this._value = null;
+  }
+  get value() {
+    return this._value ?? this.textContent ?? "";
+  }
+  set value(v) {
+    this._value = v == null ? "" : String(v);
+  }
+  get defaultValue() {
+    return this.textContent ?? "";
+  }
+  set defaultValue(v) {
+    this.textContent = v;
+  }
+  get name() {
+    return this.getAttribute("name") ?? "";
+  }
+  set name(v) {
+    this.setAttribute("name", v);
+  }
+  select() {
+  }
+  setSelectionRange() {
+  }
+};
+reflectDisabled(ServerTextAreaElement.prototype);
+var ServerOptionElement = class extends ServerHTMLElement {
+  constructor() {
+    super(...arguments);
+    /** @internal */
+    this._selected = null;
+  }
+  get value() {
+    return this.getAttribute("value") ?? this.text;
+  }
+  set value(v) {
+    this.setAttribute("value", v);
+  }
+  get text() {
+    return (this.textContent ?? "").replace(/\s+/g, " ").trim();
+  }
+  set text(v) {
+    this.textContent = v;
+  }
+  get label() {
+    return this.getAttribute("label") ?? this.text;
+  }
+  get selected() {
+    return this._selected ?? this.hasAttribute("selected");
+  }
+  set selected(v) {
+    this._selected = !!v;
+  }
+  get defaultSelected() {
+    return this.hasAttribute("selected");
+  }
+};
+reflectDisabled(ServerOptionElement.prototype);
+var ServerSelectElement = class extends ServerHTMLElement {
+  get options() {
+    return this.querySelectorAll("option");
+  }
+  get selectedIndex() {
+    const opts = this.options;
+    for (let i = 0; i < opts.length; i++) if (opts[i].selected) return i;
+    return opts.length > 0 && !this.hasAttribute("multiple") ? 0 : -1;
+  }
+  set selectedIndex(i) {
+    this.options.forEach((o, j) => {
+      o.selected = j === i;
+    });
+  }
+  get value() {
+    const i = this.selectedIndex;
+    return i === -1 ? "" : this.options[i].value;
+  }
+  set value(v) {
+    this.options.forEach((o) => {
+      o.selected = o.value === String(v);
+    });
+  }
+  get name() {
+    return this.getAttribute("name") ?? "";
+  }
+  set name(v) {
+    this.setAttribute("name", v);
+  }
+};
+reflectDisabled(ServerSelectElement.prototype);
+var ServerButtonElement = class extends ServerHTMLElement {
+  get type() {
+    return (this.getAttribute("type") ?? "submit").toLowerCase();
+  }
+  set type(v) {
+    this.setAttribute("type", v);
+  }
+  get value() {
+    return this.getAttribute("value") ?? "";
+  }
+  set value(v) {
+    this.setAttribute("value", v);
+  }
+};
+reflectDisabled(ServerButtonElement.prototype);
+var ServerDisableableElement = class extends ServerHTMLElement {
+};
+reflectDisabled(ServerDisableableElement.prototype);
+var ServerCanvasElement = class extends ServerHTMLElement {
+  get width() {
+    return Number(this.getAttribute("width") ?? 300);
+  }
+  set width(v) {
+    this.setAttribute("width", String(v));
+  }
+  get height() {
+    return Number(this.getAttribute("height") ?? 150);
+  }
+  set height(v) {
+    this.setAttribute("height", String(v));
+  }
+  /** No drawing context on a server: warns and returns `null`, as a browser does for an unsupported context. */
+  getContext() {
+    reportBrowserApi("HTMLCanvasElement.getContext()");
+    return null;
+  }
+  toDataURL() {
+    return unavailable("HTMLCanvasElement.toDataURL()");
+  }
+  toBlob() {
+    return unavailable("HTMLCanvasElement.toBlob()");
+  }
+};
+var ServerDialogElement = class extends ServerHTMLElement {
+  get open() {
+    return this.hasAttribute("open");
+  }
+  set open(v) {
+    this.toggleAttribute("open", !!v);
+  }
+  showModal() {
+    return unavailable("HTMLDialogElement.showModal()");
+  }
+  show() {
+    this.open = true;
+  }
+  close() {
+    this.open = false;
+  }
+};
+var ServerMediaElement = class extends ServerHTMLElement {
+  play() {
+    return unavailable("HTMLMediaElement.play()");
+  }
+  pause() {
+  }
+  load() {
+  }
+};
+var ServerTemplateElement = class extends ServerHTMLElement {
+  constructor() {
+    super(...arguments);
+    /** @internal */
+    this._content = null;
+  }
+  get content() {
+    this._content ?? (this._content = new ServerDocumentFragment(this.ownerDocument));
+    return this._content;
+  }
+};
+var ServerSVGElement = class extends ServerElement {
+};
+var ServerMathMLElement = class extends ServerElement {
+};
+var HTML_CLASSES = {
+  input: ServerInputElement,
+  textarea: ServerTextAreaElement,
+  select: ServerSelectElement,
+  option: ServerOptionElement,
+  button: ServerButtonElement,
+  fieldset: ServerDisableableElement,
+  optgroup: ServerDisableableElement,
+  canvas: ServerCanvasElement,
+  dialog: ServerDialogElement,
+  video: ServerMediaElement,
+  audio: ServerMediaElement,
+  template: ServerTemplateElement
+};
+var NODE_FILTER = {
+  FILTER_ACCEPT: 1,
+  FILTER_REJECT: 2,
+  FILTER_SKIP: 3,
+  SHOW_ALL: 4294967295,
+  SHOW_ELEMENT: 1,
+  SHOW_ATTRIBUTE: 2,
+  SHOW_TEXT: 4,
+  SHOW_COMMENT: 128,
+  SHOW_DOCUMENT: 256,
+  SHOW_DOCUMENT_FRAGMENT: 1024
+};
+var ServerTreeWalker = class {
+  constructor(root, whatToShow, filter) {
+    this.root = root;
+    this.whatToShow = whatToShow;
+    this.filter = filter;
+    this.currentNode = root;
+  }
+  accept(node) {
+    if (!(1 << node.nodeType - 1 & this.whatToShow)) return NODE_FILTER.FILTER_SKIP;
+    if (!this.filter) return NODE_FILTER.FILTER_ACCEPT;
+    return typeof this.filter === "function" ? this.filter(node) : this.filter.acceptNode(node);
+  }
+  nextNode() {
+    let node = this.currentNode;
+    for (; ; ) {
+      let next = null;
+      if (node._first) next = node._first;
+      else {
+        let n = node;
+        while (n && n !== this.root && !n._next) n = n._parent;
+        next = n && n !== this.root ? n._next : null;
+      }
+      if (!next) return null;
+      node = next;
+      if (this.accept(node) === NODE_FILTER.FILTER_ACCEPT) {
+        this.currentNode = node;
+        return node;
+      }
+    }
+  }
+  firstChild() {
+    for (let n = this.currentNode._first; n; n = n._next) {
+      if (this.accept(n) === NODE_FILTER.FILTER_ACCEPT) {
+        this.currentNode = n;
+        return n;
+      }
+    }
+    return null;
+  }
+  nextSibling() {
+    for (let n = this.currentNode._next; n; n = n._next) {
+      if (this.accept(n) === NODE_FILTER.FILTER_ACCEPT) {
+        this.currentNode = n;
+        return n;
+      }
+    }
+    return null;
+  }
+  parentNode() {
+    const p = this.currentNode === this.root ? null : this.currentNode._parent;
+    if (p) this.currentNode = p;
+    return p;
+  }
+};
+var ServerDocument = class extends ServerNode {
+  constructor() {
+    super(null);
+    this.defaultView = null;
+    this.readyState = "complete";
+    this.contentType = "text/html";
+    this.characterSet = "UTF-8";
+    this.compatMode = "CSS1Compat";
+    this.visibilityState = "visible";
+    this.hidden = false;
+    this.cookie = "";
+    this.ownerDocument = null;
+    this.documentElement = this.createElement("html");
+    this.head = this.createElement("head");
+    this.body = this.createElement("body");
+    this.documentElement.appendChild(this.head);
+    this.documentElement.appendChild(this.body);
+    this.appendChild(this.documentElement);
+  }
+  get nodeType() {
+    return DOCUMENT_NODE;
+  }
+  get nodeName() {
+    return "#document";
+  }
+  get activeElement() {
+    return this.body;
+  }
+  get title() {
+    return this.head.querySelector("title")?.textContent ?? "";
+  }
+  set title(v) {
+    let el = this.head.querySelector("title");
+    if (!el) {
+      el = this.createElement("title");
+      this.head.appendChild(el);
+    }
+    el.textContent = v;
+  }
+  /** Font loading does not exist on a server: recorded as a browser-only read, answers `undefined`. */
+  get fonts() {
+    reportBrowserApi("document.fonts");
+    return void 0;
+  }
+  createElement(name) {
+    name = String(name);
+    if (!NAME_RE.test(name)) invalidCharacter(name);
+    const local = name.toLowerCase();
+    const Ctor = Object.hasOwn(HTML_CLASSES, local) ? HTML_CLASSES[local] : ServerHTMLElement;
+    return new Ctor(this, local, HTML_NS);
+  }
+  createElementNS(ns, qualifiedName) {
+    if (!NAME_RE.test(qualifiedName)) invalidCharacter(qualifiedName);
+    const namespace = ns || null;
+    if (namespace === HTML_NS) return this.createElement(qualifiedName);
+    const colon = qualifiedName.indexOf(":");
+    const prefix = colon === -1 ? null : qualifiedName.slice(0, colon);
+    const local = colon === -1 ? qualifiedName : qualifiedName.slice(colon + 1);
+    if (namespace === SVG_NS) return new ServerSVGElement(this, local, namespace, prefix);
+    if (namespace === MATHML_NS) return new ServerMathMLElement(this, local, namespace, prefix);
+    return new ServerElement(this, local, namespace, prefix);
+  }
+  createTextNode(data) {
+    return new ServerText(this, String(data));
+  }
+  createComment(data) {
+    return new ServerComment(this, String(data));
+  }
+  createDocumentFragment() {
+    return new ServerDocumentFragment(this);
+  }
+  createTreeWalker(root, whatToShow = NODE_FILTER.SHOW_ALL, filter = null) {
+    return new ServerTreeWalker(root, whatToShow, filter);
+  }
+  createEvent() {
+    return unavailable("document.createEvent() (construct `new Event(type)` instead)");
+  }
+  getElementById(id) {
+    return this.querySelector(`#${cssEscapeIdent(id)}`);
+  }
+  hasFocus() {
+    return false;
+  }
+  getSelection() {
+    return null;
+  }
+  elementFromPoint() {
+    return null;
+  }
+  execCommand() {
+    return unavailable("document.execCommand()");
+  }
+};
+var selectorCache = /* @__PURE__ */ new Map();
+function cssEscapeIdent(value) {
+  return value.replace(/([^A-Za-z0-9_-])/g, "\\$1");
+}
+function unescapeIdent(value) {
+  return value.replace(/\\(.)/g, "$1");
+}
+function compileSelector(selector) {
+  const cached = selectorCache.get(selector);
+  if (cached) return cached;
+  const groups = [];
+  for (const part of splitTopLevel(selector, ",")) {
+    const text = part.trim();
+    if (!text) throw syntaxError(selector);
+    const tokens = text.match(/(?:\\.|\[[^\]]*\]|[^\s>])+|>/g) ?? [];
+    const compounds = [];
+    const combinators = [];
+    let pending = " ";
+    let scoped = false;
+    for (const token of tokens) {
+      if (token === ">") {
+        pending = ">";
+        continue;
+      }
+      if (token === ":scope") {
+        scoped = true;
+        pending = " ";
+        continue;
+      }
+      if (compounds.length > 0) combinators.unshift(pending);
+      compounds.unshift(parseCompound(token, selector));
+      pending = " ";
+    }
+    if (compounds.length === 0) throw syntaxError(selector);
+    groups.push({ compounds, combinators, scoped });
+  }
+  if (selectorCache.size > 500) selectorCache.clear();
+  selectorCache.set(selector, groups);
+  return groups;
+}
+function splitTopLevel(text, sep) {
+  const out = [];
+  let depth = 0;
+  let quote = "";
+  let start = 0;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (quote) {
+      if (c === "\\") i++;
+      else if (c === quote) quote = "";
+    } else if (c === '"' || c === "'") quote = c;
+    else if (c === "\\") i++;
+    else if (c === "[" || c === "(") depth++;
+    else if (c === "]" || c === ")") depth--;
+    else if (c === sep && depth === 0) {
+      out.push(text.slice(start, i));
+      start = i + 1;
+    }
+  }
+  out.push(text.slice(start));
+  return out;
+}
+function syntaxError(selector) {
+  const Ctor = globalThis.DOMException;
+  const message = `'${selector}' is not a valid selector (the SibuJS server DOM supports tag, #id, .class, [attr], [attr=value], descendant and > combinators)`;
+  return Ctor ? new Ctor(message, "SyntaxError") : new Error(message);
+}
+function parseCompound(token, selector) {
+  const c = { tag: null, id: null, classes: [], attrs: [] };
+  const re = /(\\.|[^#.[\\])+|#((?:\\.|[^#.[\\])+)|\.((?:\\.|[^#.[\\])+)|\[([^\]]*)\]/gy;
+  let consumed = 0;
+  for (let m = re.exec(token); m; m = re.exec(token)) {
+    consumed = re.lastIndex;
+    if (m[2] !== void 0) c.id = unescapeIdent(m[2]);
+    else if (m[3] !== void 0) c.classes.push(unescapeIdent(m[3]));
+    else if (m[4] !== void 0) {
+      const am = /^\s*([^\s~|^$*=]+)\s*(?:([~|^$*]?=)\s*(?:"((?:\\.|[^"])*)"|'((?:\\.|[^'])*)'|([^\s"']+)))?\s*$/.exec(
+        m[4]
+      );
+      if (!am) throw syntaxError(selector);
+      c.attrs.push({
+        name: am[1].toLowerCase(),
+        op: am[2] ?? null,
+        value: unescapeIdent(am[3] ?? am[4] ?? am[5] ?? "")
+      });
+    } else {
+      const t = m[0];
+      if (t.startsWith(":")) throw syntaxError(selector);
+      c.tag = t === "*" ? null : unescapeIdent(t);
+    }
+    if (re.lastIndex === token.length) break;
+  }
+  if (consumed !== token.length) throw syntaxError(selector);
+  return c;
+}
+function matchesCompound(el, c) {
+  if (c.tag !== null) {
+    const isHtml = el.namespaceURI === HTML_NS;
+    if (isHtml ? el.localName !== c.tag.toLowerCase() : el.localName !== c.tag) return false;
+  }
+  if (c.id !== null && el.getAttribute("id") !== c.id) return false;
+  if (c.classes.length > 0) {
+    const tokens = (el.getAttribute("class") ?? "").split(/\s+/);
+    for (const cls of c.classes) if (!tokens.includes(cls)) return false;
+  }
+  for (const a of c.attrs) {
+    const v = el.getAttribute(a.name);
+    if (v === null) return false;
+    if (a.op === null) continue;
+    if (a.op === "=" && v !== a.value) return false;
+    if (a.op === "~=" && !v.split(/\s+/).includes(a.value)) return false;
+    if (a.op === "|=" && v !== a.value && !v.startsWith(`${a.value}-`)) return false;
+    if (a.op === "^=" && (!a.value || !v.startsWith(a.value))) return false;
+    if (a.op === "$=" && (!a.value || !v.endsWith(a.value))) return false;
+    if (a.op === "*=" && (!a.value || !v.includes(a.value))) return false;
+  }
+  return true;
+}
+function matchesCompiled(el, groups, scope) {
+  for (const g of groups) if (matchesComplex(el, g, 0, scope)) return true;
+  return false;
+}
+function matchesComplex(el, g, i, scope) {
+  if (!matchesCompound(el, g.compounds[i])) return false;
+  if (i === g.compounds.length - 1) {
+    if (!g.scoped || !scope) return true;
+    return el._parent === scope || (g.combinators.length === 0 ? false : scope.contains(el));
+  }
+  const comb = g.combinators[i];
+  for (let p = el._parent; p && p instanceof ServerElement; p = p._parent) {
+    if (scope && p === scope && g.scoped) return false;
+    if (matchesComplex(p, g, i + 1, scope)) return true;
+    if (comb === ">") return false;
+  }
+  return false;
+}
+var VOID = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "source",
+  "track",
+  "wbr"
+]);
+function escapeText(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function serializeForDebug(node) {
+  if (node.nodeType === TEXT_NODE) return escapeText(node.data);
+  if (node.nodeType === COMMENT_NODE) return `<!--${node.data}-->`;
+  if (node.nodeType !== ELEMENT_NODE) {
+    let out2 = "";
+    for (let n = node._first; n; n = n._next) out2 += serializeForDebug(n);
+    return out2;
+  }
+  const el = node;
+  const tag = el.prefix ? `${el.prefix}:${el.localName}` : el.localName;
+  let out = `<${tag}`;
+  for (const a of el._attrs) out += ` ${a.name}="${escapeText(a._value).replace(/"/g, "&quot;")}"`;
+  out += ">";
+  if (el.namespaceURI === HTML_NS && VOID.has(el.localName)) return out;
+  for (let n = el._first; n; n = n._next) out += serializeForDebug(n);
+  return `${out}</${tag}>`;
+}
+function createServerDocument() {
+  return new ServerDocument();
+}
+var INSTALLED = /* @__PURE__ */ Symbol.for("sibujs.serverDom.v1");
+function isServerDom() {
+  return typeof document !== "undefined" && document instanceof ServerDocument;
+}
+function installServerDom(options = {}) {
+  const g = globalThis;
+  if (typeof g.document !== "undefined" && !options.force) return () => {
+  };
+  const globals = {
+    document: new ServerDocument(),
+    Node: ServerNode,
+    Element: ServerElement,
+    HTMLElement: ServerHTMLElement,
+    SVGElement: ServerSVGElement,
+    MathMLElement: ServerMathMLElement,
+    HTMLInputElement: ServerInputElement,
+    HTMLTextAreaElement: ServerTextAreaElement,
+    HTMLSelectElement: ServerSelectElement,
+    HTMLOptionElement: ServerOptionElement,
+    HTMLButtonElement: ServerButtonElement,
+    HTMLCanvasElement: ServerCanvasElement,
+    HTMLDialogElement: ServerDialogElement,
+    HTMLTemplateElement: ServerTemplateElement,
+    Text: ServerText,
+    Comment: ServerComment,
+    CharacterData: ServerCharacterData,
+    DocumentFragment: ServerDocumentFragment,
+    Document: ServerDocument,
+    Attr: ServerAttr,
+    MutationObserver: ServerMutationObserver,
+    NodeFilter: NODE_FILTER
+  };
+  const previous = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(globals)) {
+    previous.set(key, Object.getOwnPropertyDescriptor(g, key));
+    Object.defineProperty(g, key, { value, configurable: true, writable: true, enumerable: false });
+  }
+  g[INSTALLED] = true;
+  return () => {
+    for (const [key, desc] of previous) {
+      if (desc) Object.defineProperty(g, key, desc);
+      else delete g[key];
+    }
+    delete g[INSTALLED];
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ServerDocument,
+  ServerElement,
+  ServerNode,
+  createServerDocument,
+  installServerDom,
+  isServerDom
+});