@remote-dom/polyfill 1.5.1 → 1.6.0

package/build/cjs/NamedNodeMap.cjs

@@ -3,6 +3,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const constants = require('./constants.cjs');
+const names = require('./names.cjs');
+const MutationObserver = require('./MutationObserver.cjs');
+const customElementReactions = require('./custom-element-reactions.cjs');
+const attributeReactions = require('./attribute-reactions.cjs');
+const domException = require('./dom-exception.cjs');
 
 class NamedNodeMap {
   [constants.CHILD] = null;
@@ -10,12 +15,21 @@ class NamedNodeMap {
     this[constants.OWNER_ELEMENT] = ownerElement;
   }
   getNamedItem(name) {
-    return this.getNamedItemNS(null, name);
+    const qualifiedName = String(name);
+    const normalizedName = this[constants.OWNER_ELEMENT][constants.NS] === constants.HTML_NAMESPACE ? constants.asciiLowercase(qualifiedName) : qualifiedName;
+    let attr = this[constants.CHILD];
+    while (attr) {
+      if (attr.name === normalizedName) return attr;
+      attr = attr[constants.NEXT];
+    }
+    return null;
   }
-  getNamedItemNS(namespaceURI, name) {
+  getNamedItemNS(namespaceURI, localName) {
+    const namespace = names.normalizeNamespace(namespaceURI);
+    const normalizedLocalName = String(localName);
     let attr = this[constants.CHILD];
     while (attr) {
-      if (attr.name === name && attr[constants.NS] == namespaceURI) {
+      if (attr.localName === normalizedLocalName && attr[constants.NS] === namespace) {
         return attr;
       }
       attr = attr[constants.NEXT];
@@ -41,18 +55,37 @@ class NamedNodeMap {
     return index;
   }
   removeNamedItem(name) {
-    return this.removeNamedItemNS(null, name);
+    const qualifiedName = String(name);
+    const normalizedName = this[constants.OWNER_ELEMENT][constants.NS] === constants.HTML_NAMESPACE ? constants.asciiLowercase(qualifiedName) : qualifiedName;
+    return customElementReactions.performWithCustomElementReactions(() => this.removeNamedItemImmediately(attr => attr.name === normalizedName));
+  }
+  removeNamedItemNS(namespaceURI, localName) {
+    const namespace = names.normalizeNamespace(namespaceURI);
+    const normalizedLocalName = String(localName);
+    return customElementReactions.performWithCustomElementReactions(() => this.removeNamedItemImmediately(attr => attr.localName === normalizedLocalName && attr[constants.NS] === namespace));
   }
-  removeNamedItemNS(namespaceURI, name) {
+  removeNamedItemImmediately(matches) {
     const ownerElement = this[constants.OWNER_ELEMENT];
     let attr = this[constants.CHILD];
     let prev = null;
     while (attr != null) {
-      if (attr.name === name && attr[constants.NS] == namespaceURI) {
+      if (matches(attr)) {
         if (prev) prev[constants.NEXT] = attr[constants.NEXT];
         if (this[constants.CHILD] === attr) this[constants.CHILD] = attr[constants.NEXT];
-        updateElementAttribute(ownerElement, attr.name, attr.value, null);
-        ownerElement[constants.HOOKS].removeAttribute?.(ownerElement, name, namespaceURI);
+        const oldValue = attr.value;
+        attr[constants.NEXT] = null;
+        attr[constants.OWNER_ELEMENT] = null;
+        if (MutationObserver.attributeObserversActive) {
+          MutationObserver.queueMutationRecord({
+            type: 'attributes',
+            target: ownerElement,
+            attributeName: attr.name,
+            attributeNamespace: attr[constants.NS],
+            oldValue
+          });
+        }
+        ownerElement[constants.HOOKS].removeAttribute?.(ownerElement, attr.name, attr[constants.NS]);
+        attributeReactions.enqueueAttributeReaction(ownerElement, attr.localName, oldValue, null, attr[constants.NS]);
         return attr;
       }
       prev = attr;
@@ -61,36 +94,55 @@ class NamedNodeMap {
     return null;
   }
   setNamedItem(attr) {
+    return customElementReactions.performWithCustomElementReactions(() => this.setNamedItemImmediately(attr));
+  }
+  setNamedItemImmediately(attr) {
     const ownerElement = this[constants.OWNER_ELEMENT];
+    const currentOwner = attr[constants.OWNER_ELEMENT];
+    if (currentOwner != null && currentOwner !== ownerElement) {
+      throw domException.createDOMException('The attribute is already in use by another element.', 'InUseAttributeError');
+    }
     let old = null;
     let child = this[constants.CHILD];
-    attr[constants.OWNER_ELEMENT] = ownerElement;
-    if (child == null) {
-      this[constants.CHILD] = attr;
-      // return null;
-    } else {
-      let prev;
-      while (child) {
-        if (child.name === attr.name && child[constants.NS] == attr[constants.NS]) {
-          if (prev) prev[constants.NEXT] = attr;else this[constants.CHILD] = attr;
-          attr[constants.NEXT] = child[constants.NEXT];
-          child[constants.NEXT] = null;
-          old = child;
-          break;
-          // return child;
-        }
-        prev = child;
-        child = child[constants.NEXT];
+    let prev = null;
+    while (child) {
+      if (child.localName === attr.localName && child[constants.NS] === attr[constants.NS]) {
+        if (child === attr) return child;
+        if (prev) prev[constants.NEXT] = attr;else this[constants.CHILD] = attr;
+        attr[constants.NEXT] = child[constants.NEXT];
+        child[constants.NEXT] = null;
+        old = child;
+        break;
       }
+      prev = child;
+      child = child[constants.NEXT];
+    }
+    if (old == null) {
       if (prev) prev[constants.NEXT] = attr;else this[constants.CHILD] = attr;
-      // return null;
     }
-
-    // only invoke the protocol if the value changed
-    if (!old || old.value !== attr.value) {
-      updateElementAttribute(ownerElement, attr.name, old?.value ?? null, attr.value);
+    attr[constants.OWNER_ELEMENT] = ownerElement;
+    attr[constants.OWNER_DOCUMENT] = ownerElement[constants.OWNER_DOCUMENT];
+    if (old) old[constants.OWNER_ELEMENT] = null;
+    const valueChanged = old == null || old.value !== attr.value;
+    const qualifiedNameChanged = old != null && old.name !== attr.name;
+    if (valueChanged && MutationObserver.attributeObserversActive) {
+      MutationObserver.queueMutationRecord({
+        type: 'attributes',
+        target: ownerElement,
+        attributeName: attr.name,
+        attributeNamespace: attr[constants.NS],
+        oldValue: old?.value ?? null
+      });
+    }
+    if (qualifiedNameChanged) {
+      ownerElement[constants.HOOKS].removeAttribute?.(ownerElement, old.name, old[constants.NS]);
+    }
+    if (valueChanged || qualifiedNameChanged) {
       ownerElement[constants.HOOKS].setAttribute?.(ownerElement, attr.name, attr.value, attr[constants.NS]);
     }
+    if (valueChanged) {
+      attributeReactions.enqueueAttributeReaction(ownerElement, attr.localName, old?.value ?? null, attr.value, attr[constants.NS]);
+    }
     return old;
   }
   setNamedItemNS(attr) {
@@ -104,20 +156,5 @@ class NamedNodeMap {
     }
   }
 }
-function updateElementAttribute(element, name, oldValue, newValue) {
-  const {
-    observedAttributes
-  } = element.constructor;
-  const {
-    attributeChangedCallback
-  } = element;
-  if (name === 'slot') {
-    element.slot = newValue ?? '';
-  }
-  if (attributeChangedCallback == null || observedAttributes == null || !observedAttributes.includes(name)) {
-    return;
-  }
-  return attributeChangedCallback.call(element, name, oldValue, newValue);
-}
 
 exports.NamedNodeMap = NamedNodeMap;

package/build/cjs/Node.cjs

@@ -4,24 +4,26 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const constants = require('./constants.cjs');
 const EventTarget = require('./EventTarget.cjs');
+const names = require('./names.cjs');
 const shared = require('./shared.cjs');
 
 class Node extends EventTarget.EventTarget {
-  nodeType = (() => constants.NodeType.NODE)();
+  nodeType = constants.NODE_TYPE_NODE;
   [constants.NAME] = '';
   [constants.PARENT] = null;
+  [constants.HOST] = null;
   [constants.CHILD] = null;
   [constants.PREV] = null;
   [constants.NEXT] = null;
   [constants.IS_CONNECTED] = false;
   get [constants.HOOKS]() {
-    return this[constants.OWNER_DOCUMENT].defaultView[constants.HOOKS];
+    return this[constants.OWNER_DOCUMENT].defaultView[constants.HOOKS_DISPATCH];
   }
   get localName() {
     return this[constants.NAME];
   }
   get nodeName() {
-    return this[constants.NAME].toUpperCase();
+    return this[constants.NAME];
   }
   get ownerDocument() {
     return this[constants.OWNER_DOCUMENT];
@@ -30,7 +32,8 @@ class Node extends EventTarget.EventTarget {
     return this[constants.IS_CONNECTED];
   }
   isDefaultNamespace(namespace) {
-    return namespace === constants.NamespaceURI.XHTML;
+    const normalizedNamespace = names.normalizeNamespace(namespace);
+    return locateNamespace(this) === normalizedNamespace;
   }
   get parentNode() {
     return this[constants.PARENT];
@@ -97,11 +100,12 @@ class Node extends EventTarget.EventTarget {
     if (shared.isCharacterData(this)) {
       this.data = data;
     } else if (shared.isParentNode(this)) {
-      let child;
-      while (child = this[constants.CHILD]) {
-        this.removeChild(child);
+      const text = data == null ? '' : String(data);
+      if (text === '') {
+        this.replaceChildren();
+      } else {
+        this.replaceChildren(text);
       }
-      this.append(data);
     }
   }
   cloneNode(deep) {
@@ -109,12 +113,44 @@ class Node extends EventTarget.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 constants.NODE_TYPE_ELEMENT:
+        {
+          const element = current;
+          if (element.prefix == null && element.namespaceURI != null) {
+            return element.namespaceURI;
+          }
+          const namespace = element.attributes.getNamedItemNS(constants.XMLNS_NAMESPACE, 'xmlns');
+          if (namespace != null && namespace.prefix == null) {
+            return names.normalizeNamespace(namespace.value);
+          }
+          current = element.parentElement;
+          break;
+        }
+      case constants.NODE_TYPE_DOCUMENT:
+        current = current.documentElement;
+        break;
+      case constants.NODE_TYPE_DOCUMENT_TYPE:
+      case constants.NODE_TYPE_DOCUMENT_FRAGMENT:
+        return null;
+      case constants.NODE_TYPE_ATTRIBUTE:
+        current = current.ownerElement;
+        break;
+      default:
+        current = current.parentElement;
     }
   }
+  return null;
 }
 
 exports.Node = Node;

package/build/cjs/NodeList.cjs

@@ -2,9 +2,17 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
+// 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;
   }
 }