@remote-dom/polyfill 1.5.1 → 1.6.0

package/build/esm/Node.mjs

@@ -1,23 +1,25 @@
-import { NodeType, NAME, PARENT, CHILD, PREV, NEXT, IS_CONNECTED, HOOKS, OWNER_DOCUMENT, NamespaceURI } from './constants.mjs';
+import { NODE_TYPE_NODE, NAME, PARENT, HOST, CHILD, PREV, NEXT, IS_CONNECTED, HOOKS, OWNER_DOCUMENT, HOOKS_DISPATCH, NODE_TYPE_ATTRIBUTE, NODE_TYPE_DOCUMENT_FRAGMENT, NODE_TYPE_DOCUMENT_TYPE, NODE_TYPE_DOCUMENT, NODE_TYPE_ELEMENT, XMLNS_NAMESPACE } from './constants.mjs';
 import { EventTarget } from './EventTarget.mjs';
+import { normalizeNamespace } from './names.mjs';
 import { isCharacterData, descendants, isTextNode, isParentNode, cloneNode } from './shared.mjs';
 
 class Node extends EventTarget {
-  nodeType = (() => NodeType.NODE)();
+  nodeType = NODE_TYPE_NODE;
   [NAME] = '';
   [PARENT] = null;
+  [HOST] = null;
   [CHILD] = null;
   [PREV] = null;
   [NEXT] = null;
   [IS_CONNECTED] = false;
   get [HOOKS]() {
-    return this[OWNER_DOCUMENT].defaultView[HOOKS];
+    return this[OWNER_DOCUMENT].defaultView[HOOKS_DISPATCH];
   }
   get localName() {
     return this[NAME];
   }
   get nodeName() {
-    return this[NAME].toUpperCase();
+    return this[NAME];
   }
   get ownerDocument() {
     return this[OWNER_DOCUMENT];
@@ -26,7 +28,8 @@ class Node extends EventTarget {
     return this[IS_CONNECTED];
   }
   isDefaultNamespace(namespace) {
-    return namespace === NamespaceURI.XHTML;
+    const normalizedNamespace = normalizeNamespace(namespace);
+    return locateNamespace(this) === normalizedNamespace;
   }
   get parentNode() {
     return this[PARENT];
@@ -93,11 +96,12 @@ class Node extends EventTarget {
     if (isCharacterData(this)) {
       this.data = data;
     } else if (isParentNode(this)) {
-      let child;
-      while (child = this[CHILD]) {
-        this.removeChild(child);
+      const text = data == null ? '' : String(data);
+      if (text === '') {
+        this.replaceChildren();
+      } else {
+        this.replaceChildren(text);
       }
-      this.append(data);
     }
   }
   cloneNode(deep) {
@@ -105,12 +109,44 @@ class Node extends EventTarget {
   }
   contains(node) {
     let currentNode = node;
-    while (true) {
-      if (currentNode == null) return false;
+    while (currentNode != null) {
       if (currentNode === this) return true;
-      currentNode = node.parentNode;
+      currentNode = currentNode.parentNode;
+    }
+    return false;
+  }
+}
+function locateNamespace(node) {
+  let current = node;
+  while (current) {
+    switch (current.nodeType) {
+      case NODE_TYPE_ELEMENT:
+        {
+          const element = current;
+          if (element.prefix == null && element.namespaceURI != null) {
+            return element.namespaceURI;
+          }
+          const namespace = element.attributes.getNamedItemNS(XMLNS_NAMESPACE, 'xmlns');
+          if (namespace != null && namespace.prefix == null) {
+            return normalizeNamespace(namespace.value);
+          }
+          current = element.parentElement;
+          break;
+        }
+      case NODE_TYPE_DOCUMENT:
+        current = current.documentElement;
+        break;
+      case NODE_TYPE_DOCUMENT_TYPE:
+      case NODE_TYPE_DOCUMENT_FRAGMENT:
+        return null;
+      case NODE_TYPE_ATTRIBUTE:
+        current = current.ownerElement;
+        break;
+      default:
+        current = current.parentElement;
     }
   }
+  return null;
 }
 
 export { Node };

package/build/esm/NodeList.mjs

@@ -1,6 +1,14 @@
+// Performance note (2026-09-02): Benchmarks on an Apple M4 Pro with Node.js
+// 24.19.0 (V8 13.6.233.17-node.51) and Chromium 152 showed indexed access and
+// `for...of` iteration at parity with Array. Construction, `push()`, and some
+// inherited methods (`forEach()`, `includes()`, `map()`, `filter()`, and
+// `slice()`) were slower, but the measured end-to-end `querySelectorAll()`
+// overhead was 0–12% (up to about 1 µs in the tested 100–1,000-element trees)
+// and decreased as selector traversal dominated. Keep this direct subclass
+// while indexed access and iteration remain the primary usage patterns.
 class NodeList extends Array {
   item(index) {
-    return this[index];
+    return this[index] ?? null;
   }
 }
 

package/build/esm/ParentNode.mjs

@@ -1,71 +1,114 @@
-import { PREV, NEXT, CHILD, PARENT, IS_CONNECTED, NodeType, HOOKS, OWNER_DOCUMENT } from './constants.mjs';
-import { ChildNode, toNode } from './ChildNode.mjs';
+import { IS_CONNECTED, PREV, NEXT, NODE_TYPE_DOCUMENT_FRAGMENT, CHILD, OWNER_DOCUMENT, PARENT, NODE_TYPE_ELEMENT, HOOKS } from './constants.mjs';
+import { ChildNode, REPLACE_NODE, validateInsertionNodes, INSERT_NODE, PREFLIGHT_INSERTIONS, stageNodes, toNode } from './ChildNode.mjs';
 import { NodeList } from './NodeList.mjs';
 import { querySelectorAll, querySelector } from './selectors.mjs';
-import { selfAndDescendants } from './shared.mjs';
+import { selfAndDescendants, collectAdoptionSnapshot, adoptNodes, isElementNode } from './shared.mjs';
+import { childListObserversActive, queueMutationRecord, mutationNodeList } from './MutationObserver.mjs';
+import { performWithCustomElementReactions, enqueueCustomElementReaction } from './custom-element-reactions.mjs';
+import { performHookEffects, isCoveredByPendingPublication } from './hook-effects.mjs';
+import { createDOMException } from './dom-exception.mjs';
 
 class ParentNode extends ChildNode {
-  childNodes = (() => new NodeList())();
-  children = (() => new NodeList())();
+  childNodes = new NodeList();
+  children = new NodeList();
   appendChild(child) {
-    this.insertInto(child, null);
+    return performWithCustomElementReactions(() => this[INSERT_NODE](child, null));
   }
   insertBefore(child, ref) {
-    this.insertInto(child, ref || null);
+    return performWithCustomElementReactions(() => this[INSERT_NODE](child, ref || null));
   }
   append(...nodes) {
-    for (const child of nodes) {
-      if (child == null) continue;
-      this.appendChild(toNode(this, child));
-    }
+    return performWithCustomElementReactions(() => {
+      const staged = stageNodes(nodes.filter(node => node != null));
+      if (staged.length > 1) validateInsertionNodes(this, staged);
+      for (const child of staged) {
+        this[INSERT_NODE](toNode(this, child), null);
+      }
+    });
   }
   prepend(...nodes) {
-    const before = this.firstChild;
-    for (const child of nodes) {
-      if (child == null) continue;
-      this.insertBefore(toNode(this, child), before);
-    }
+    return performWithCustomElementReactions(() => {
+      const staged = stageNodes(nodes.filter(node => node != null));
+      if (staged.length > 1) validateInsertionNodes(this, staged);
+      const before = this.firstChild;
+      for (const child of staged) {
+        this[INSERT_NODE](toNode(this, child), before);
+      }
+    });
   }
   replaceChildren(...nodes) {
-    let child;
-    while (child = this.firstChild) {
-      this.removeChild(child);
-    }
-    this.append(...nodes);
+    return performWithCustomElementReactions(() => {
+      const staged = stageNodes(nodes.filter(node => node != null));
+      validateInsertionNodes(this, staged);
+      let child;
+      while (child = this.firstChild) {
+        this.removeChildImmediately(child);
+      }
+      for (const node of staged) {
+        this[INSERT_NODE](toNode(this, node), null);
+      }
+    });
   }
   removeChild(child) {
-    if (child.parentNode !== this) throw Error(`not a child of this node`);
-    const prev = child[PREV];
-    const next = child[NEXT];
-    if (prev) prev[NEXT] = next;else this[CHILD] = next;
-    if (next) next[PREV] = prev;
-    const childNodes = this.childNodes;
-    const childNodesIndex = childNodes.indexOf(child);
-    childNodes.splice(childNodesIndex, 1);
-    if (child.nodeType === 1) {
-      const children = this.children;
-      children.splice(children.indexOf(child), 1);
-    }
-    child[PARENT] = null;
-    child[NEXT] = null;
-    child[PREV] = null;
-    if (this[IS_CONNECTED]) {
-      for (const node of selfAndDescendants(child)) {
-        node[IS_CONNECTED] = false;
-        node.disconnectedCallback?.();
-      }
+    return performWithCustomElementReactions(() => {
+      this.removeChildImmediately(child);
+      return child;
+    });
+  }
+  removeChildImmediately(child) {
+    if (child.parentNode !== this) {
+      throw createDOMException('The node is not a child of this node', 'NotFoundError');
+    }
+    const disconnectedNodes = this[IS_CONNECTED] ? selfAndDescendants(child) : undefined;
+    const previousSibling = child[PREV];
+    const nextSibling = child[NEXT];
+    const childNodesIndex = detachChild(this, child);
+    if (disconnectedNodes) {
+      for (const node of disconnectedNodes) node[IS_CONNECTED] = false;
     }
-    if (this.nodeType === NodeType.ELEMENT_NODE) {
-      this[HOOKS].removeChild?.(this, child, childNodesIndex);
+    this.queueRemovalMutationRecord(this, child, previousSibling, nextSibling);
+    if (disconnectedNodes) {
+      this.enqueueTreeReactions(disconnectedNodes, 'disconnectedCallback');
     }
+    performHookEffects(this.collectRemovalHookEffects(child, childNodesIndex));
   }
   replaceChild(newChild, oldChild) {
+    return performWithCustomElementReactions(() => this[REPLACE_NODE](newChild, oldChild));
+  }
+  [REPLACE_NODE](newChild, oldChild, hookEffects) {
+    validateInsertionNodes(this, [newChild]);
     if (oldChild.parentNode !== this) {
-      throw Error('reference node is not a child of this parent');
+      throw createDOMException('The reference node is not a child of this parent', 'NotFoundError');
     }
+    const previous = oldChild[PREV];
     const next = oldChild[NEXT];
-    this.removeChild(oldChild);
-    this.insertInto(newChild, next);
+    const insertion = this.prepareInsertion(newChild);
+    const removedNodes = this[IS_CONNECTED] ? selfAndDescendants(oldChild) : undefined;
+    const insertionRoots = new Set(insertion.map(({
+      node
+    }) => node));
+    let before = next;
+    while (before && insertionRoots.has(before)) before = before[NEXT];
+    const oldChildIndex = detachChild(this, oldChild);
+    if (removedNodes) {
+      for (const node of removedNodes) node[IS_CONNECTED] = false;
+      const removedNodeSet = new Set(removedNodes);
+      for (const prepared of insertion) {
+        if (removedNodeSet.has(prepared.node)) {
+          prepared.shouldDisconnect = false;
+        }
+      }
+    }
+    this.commitInsertion(insertion, before);
+    const destinationIsConnected = this[IS_CONNECTED];
+    this.queueRemovalMutationRecord(this, oldChild, previous, next);
+    this.queueInsertionMutationRecords(insertion);
+    if (removedNodes) {
+      this.enqueueTreeReactions(removedNodes, 'disconnectedCallback');
+    }
+    this.enqueueInsertionReactions(insertion, destinationIsConnected);
+    this.performOrCollectHookEffects([...this.collectRemovalHookEffects(oldChild, oldChildIndex), ...this.collectInsertionHookEffects(insertion)], hookEffects);
+    return oldChild;
   }
   querySelectorAll(selector) {
     return querySelectorAll(this, selector);
@@ -73,27 +116,111 @@ class ParentNode extends ChildNode {
   querySelector(selector) {
     return querySelector(this, selector);
   }
-  insertInto(child, before) {
-    // append the children of a DocumentFragment:
-    if (child.nodeType === NodeType.DOCUMENT_FRAGMENT_NODE) {
+  [INSERT_NODE](child, before, hookEffects) {
+    this.validateInsertion(child, before);
+    this.insertIntoValidated(child, before, hookEffects);
+    return child;
+  }
+  [PREFLIGHT_INSERTIONS](children) {
+    for (const child of children) {
+      this.validateInsertion(child, null);
+      this.prepareInsertion(child);
+    }
+  }
+  validateInsertion(child, before) {
+    validateInsertionNodes(this, [child]);
+    if (before && before.parentNode !== this) {
+      throw createDOMException('The reference node is not a child of this parent', 'NotFoundError');
+    }
+  }
+  insertIntoValidated(child, before, hookEffects) {
+    if (child === before) before = child[NEXT];
+    const insertion = this.prepareInsertion(child);
+    this.commitInsertion(insertion, before);
+    const destinationIsConnected = this[IS_CONNECTED];
+    this.queueInsertionMutationRecords(insertion);
+    this.enqueueInsertionReactions(insertion, destinationIsConnected);
+    this.performOrCollectHookEffects(this.collectInsertionHookEffects(insertion), hookEffects);
+  }
+  performOrCollectHookEffects(effects, hookEffects) {
+    if (hookEffects) hookEffects.push(...effects);else performHookEffects(effects);
+  }
+  prepareInsertion(child) {
+    const roots = [];
+    if (child.nodeType === NODE_TYPE_DOCUMENT_FRAGMENT) {
       let node = child[CHILD];
       while (node) {
-        const next = node[NEXT];
-        this.insertInto(node, before);
-        node = next;
+        roots.push(node);
+        node = node[NEXT];
       }
-      return;
+    } else {
+      roots.push(child);
     }
-    if (child.parentNode !== null) {
-      child.parentNode.removeChild(child);
+    const destinationIsConnected = this[IS_CONNECTED];
+    const ownerDocument = this[OWNER_DOCUMENT];
+    const insertion = [];
+    for (const node of roots) {
+      const wasConnected = node[IS_CONNECTED];
+      const shouldTraverse = wasConnected || destinationIsConnected;
+      let nodes;
+      let adoption;
+      if (node[OWNER_DOCUMENT] === ownerDocument) {
+        if (shouldTraverse) nodes = selfAndDescendants(node);
+      } else {
+        const snapshot = collectAdoptionSnapshot(node);
+        adoption = snapshot.nodes;
+        if (shouldTraverse) nodes = snapshot.treeNodes;
+      }
+      insertion.push({
+        node,
+        nodes,
+        adoption,
+        shouldDisconnect: wasConnected
+      });
     }
-    if (before) {
-      if (before.parentNode !== this) {
-        throw Error('reference node is not a child of this parent');
+    return insertion;
+  }
+  commitInsertion(insertion, before) {
+    for (const prepared of insertion) {
+      const sourceParent = prepared.node[PARENT];
+      if (sourceParent) {
+        const previousSibling = prepared.node[PREV];
+        const nextSibling = prepared.node[NEXT];
+        prepared.source = {
+          parent: sourceParent,
+          index: detachChild(sourceParent, prepared.node),
+          previousSibling,
+          nextSibling
+        };
       }
+    }
+    for (const prepared of insertion) {
+      const attached = this.attachChild(prepared.node, before);
+      prepared.insertIndex = attached.index;
+      prepared.previousSibling = attached.previousSibling;
+      prepared.nextSibling = attached.nextSibling;
+    }
+    const ownerDocument = this[OWNER_DOCUMENT];
+    for (const {
+      adoption
+    } of insertion) {
+      if (adoption) adoptNodes(adoption, ownerDocument);
+    }
+    const isConnected = this[IS_CONNECTED];
+    for (const {
+      nodes
+    } of insertion) {
+      if (nodes) {
+        for (const node of nodes) node[IS_CONNECTED] = isConnected;
+      }
+    }
+  }
+  attachChild(child, before) {
+    if (before) {
+      const previous = before[PREV];
       child[NEXT] = before;
-      child[PREV] = before[PREV];
-      if (before[PREV] === null) this[CHILD] = child;
+      child[PREV] = previous;
+      if (previous) previous[NEXT] = child;else this[CHILD] = child;
       before[PREV] = child;
     } else {
       child[NEXT] = null;
@@ -108,40 +235,154 @@ class ParentNode extends ChildNode {
         child[PREV] = null;
       }
     }
-    const ownerDocument = this[OWNER_DOCUMENT];
-    const isElement = child.nodeType === NodeType.ELEMENT_NODE;
+    const isElement = isElementNode(child);
     child[PARENT] = this;
-    child[OWNER_DOCUMENT] = ownerDocument;
-    const childNodes = this.childNodes;
     let insertIndex;
     if (before) {
-      insertIndex = childNodes.indexOf(before);
-      childNodes.splice(insertIndex, 0, child);
+      insertIndex = this.childNodes.indexOf(before);
+      this.childNodes.splice(insertIndex, 0, child);
       if (isElement) {
-        const children = this.children;
-        let ref = before;
-        while (ref && ref.nodeType !== 1) ref = ref[NEXT];
-        if (ref) {
-          children.splice(children.indexOf(ref), 0, child);
+        let reference = before;
+        while (reference && !isElementNode(reference)) {
+          reference = reference[NEXT];
+        }
+        if (reference) {
+          this.children.splice(this.children.indexOf(reference), 0, child);
         } else {
-          children.push(child);
+          this.children.push(child);
         }
       }
     } else {
-      insertIndex = childNodes.length;
-      childNodes.push(child);
+      insertIndex = this.childNodes.length;
+      this.childNodes.push(child);
       if (isElement) this.children.push(child);
     }
-    if (this[IS_CONNECTED]) {
-      for (const node of selfAndDescendants(child)) {
-        node[IS_CONNECTED] = true;
-        node.connectedCallback?.();
+    return {
+      index: insertIndex,
+      previousSibling: child[PREV],
+      nextSibling: child[NEXT]
+    };
+  }
+  queueRemovalMutationRecord(parent, child, previousSibling, nextSibling) {
+    if (!childListObserversActive) return;
+    queueMutationRecord({
+      type: 'childList',
+      target: parent,
+      removedNodes: mutationNodeList(child),
+      previousSibling,
+      nextSibling
+    });
+  }
+  queueInsertionMutationRecords(insertion) {
+    if (!childListObserversActive) return;
+    for (const prepared of insertion) {
+      const {
+        node,
+        source
+      } = prepared;
+      if (source) {
+        this.queueRemovalMutationRecord(source.parent, node, source.previousSibling, source.nextSibling);
+      }
+      queueMutationRecord({
+        type: 'childList',
+        target: this,
+        addedNodes: mutationNodeList(node),
+        previousSibling: prepared.previousSibling,
+        nextSibling: prepared.nextSibling
+      });
+    }
+  }
+  collectRemovalHookEffects(child, childNodesIndex) {
+    if (this.nodeType !== NODE_TYPE_ELEMENT || isCoveredByPendingPublication(this)) {
+      return [];
+    }
+    return [[() => this[HOOKS].removeChild?.(this, child, childNodesIndex)]];
+  }
+  collectInsertionHookEffects(insertion) {
+    const effects = [];
+    for (const prepared of insertion) {
+      const {
+        node,
+        source
+      } = prepared;
+      if (source?.parent.nodeType === NODE_TYPE_ELEMENT && !isCoveredByPendingPublication(source.parent)) {
+        effects.push([() => source.parent[HOOKS].removeChild?.(source.parent, node, source.index)]);
+      }
+      if (this.nodeType === NODE_TYPE_ELEMENT && !isCoveredByPendingPublication(this)) {
+        effects.push([() => this[HOOKS].insertChild?.(this, node, prepared.insertIndex), node]);
+      }
+    }
+    return effects;
+  }
+  enqueueInsertionReactions(insertion, destinationIsConnected) {
+    for (const prepared of insertion) {
+      const {
+        nodes
+      } = prepared;
+      if (nodes) {
+        if (prepared.shouldDisconnect) {
+          this.enqueueTreeReactions(nodes, 'disconnectedCallback');
+        }
+        if (destinationIsConnected) {
+          this.enqueueTreeReactions(nodes, 'connectedCallback');
+        }
       }
     }
-    if (this.nodeType === NodeType.ELEMENT_NODE) {
-      this[HOOKS].insertChild?.(this, child, insertIndex);
+  }
+  enqueueTreeReactions(nodes, callbackName) {
+    enqueueTreeReactions(nodes, callbackName);
+  }
+}
+function removeChildForAdoption(parent, child, adoption, destination) {
+  if (child.parentNode !== parent) throw Error(`not a child of this node`);
+  const disconnectedNodes = parent[IS_CONNECTED] ? adoption.treeNodes : undefined;
+  const previousSibling = child[PREV];
+  const nextSibling = child[NEXT];
+  const childNodesIndex = detachChild(parent, child);
+  if (disconnectedNodes) {
+    for (const node of disconnectedNodes) node[IS_CONNECTED] = false;
+  }
+  adoptNodes(adoption.nodes, destination);
+  if (childListObserversActive) {
+    queueMutationRecord({
+      type: 'childList',
+      target: parent,
+      removedNodes: mutationNodeList(child),
+      previousSibling,
+      nextSibling
+    });
+  }
+  if (disconnectedNodes) {
+    enqueueTreeReactions(disconnectedNodes, 'disconnectedCallback');
+  }
+  const effects = [];
+  if (parent.nodeType === NODE_TYPE_ELEMENT && !isCoveredByPendingPublication(parent)) {
+    effects.push([() => parent[HOOKS].removeChild?.(parent, child, childNodesIndex)]);
+  }
+  performHookEffects(effects);
+}
+function detachChild(parent, child) {
+  const previous = child[PREV];
+  const next = child[NEXT];
+  if (previous) previous[NEXT] = next;else parent[CHILD] = next;
+  if (next) next[PREV] = previous;
+  const childNodesIndex = parent.childNodes.indexOf(child);
+  parent.childNodes.splice(childNodesIndex, 1);
+  if (isElementNode(child)) {
+    parent.children.splice(parent.children.indexOf(child), 1);
+  }
+  child[PARENT] = null;
+  child[NEXT] = null;
+  child[PREV] = null;
+  return childNodesIndex;
+}
+function enqueueTreeReactions(nodes, callbackName) {
+  for (const node of nodes) {
+    const callback = node[callbackName];
+    if (typeof callback === 'function') {
+      enqueueCustomElementReaction(node, () => callback.call(node));
     }
   }
 }
 
-export { ParentNode };
+export { ParentNode, removeChildForAdoption };

package/build/esm/SVGElement.mjs

@@ -1,8 +1,8 @@
-import { NS, NamespaceURI } from './constants.mjs';
+import { SVG_NAMESPACE, NS } from './constants.mjs';
 import { Element } from './Element.mjs';
 
 class SVGElement extends Element {
-  [NS] = (() => NamespaceURI.SVG)();
+  [NS] = SVG_NAMESPACE;
   get ownerSVGElement() {
     let root = null;
     let parent = this.parentNode;

package/build/esm/Text.mjs

@@ -1,8 +1,8 @@
-import { NodeType, NAME } from './constants.mjs';
+import { NODE_TYPE_TEXT, NAME } from './constants.mjs';
 import { CharacterData } from './CharacterData.mjs';
 
 class Text extends CharacterData {
-  nodeType = (() => NodeType.TEXT_NODE)();
+  nodeType = NODE_TYPE_TEXT;
   [NAME] = '#text';
 }