@remote-dom/polyfill 1.5.0 → 1.6.0

package/build/esnext/Node.esnext

@@ -1,24 +1,26 @@
-import { NodeType, OWNER_DOCUMENT, NAME, PARENT, CHILD, PREV, NEXT, IS_CONNECTED, HOOKS, NamespaceURI } from './constants.esnext';
+import { NODE_TYPE_NODE, OWNER_DOCUMENT, NAME, PARENT, HOST, CHILD, PREV, NEXT, IS_CONNECTED, HOOKS, HOOKS_DISPATCH, NODE_TYPE_ATTRIBUTE, NODE_TYPE_DOCUMENT_FRAGMENT, NODE_TYPE_DOCUMENT_TYPE, NODE_TYPE_DOCUMENT, NODE_TYPE_ELEMENT, XMLNS_NAMESPACE } from './constants.esnext';
 import { EventTarget } from './EventTarget.esnext';
+import { normalizeNamespace } from './names.esnext';
 import { isCharacterData, descendants, isTextNode, isParentNode, cloneNode } from './shared.esnext';
 
 class Node extends EventTarget {
-  nodeType = NodeType.NODE;
+  nodeType = NODE_TYPE_NODE;
   [OWNER_DOCUMENT];
   [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];
@@ -27,7 +29,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];
@@ -102,11 +105,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) {
@@ -114,12 +118,46 @@ 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/esnext/NodeList.esnext

@@ -1,6 +1,6 @@
 class NodeList extends Array {
   item(index) {
-    return this[index];
+    return this[index] ?? null;
   }
 }
 

package/build/esnext/ParentNode.esnext

@@ -1,72 +1,130 @@
-import { PREV, NEXT, CHILD, PARENT, IS_CONNECTED, NodeType, HOOKS, OWNER_DOCUMENT } from './constants.esnext';
-import { ChildNode, toNode } from './ChildNode.esnext';
+import { IS_CONNECTED, PREV, NEXT, NODE_TYPE_DOCUMENT_FRAGMENT, CHILD, OWNER_DOCUMENT, PARENT, NODE_TYPE_ELEMENT, HOOKS } from './constants.esnext';
+import { ChildNode, REPLACE_NODE, validateInsertionNodes, INSERT_NODE, PREFLIGHT_INSERTIONS, stageNodes, toNode } from './ChildNode.esnext';
 import { NodeList } from './NodeList.esnext';
 import { querySelectorAll, querySelector } from './selectors.esnext';
-import { selfAndDescendants } from './shared.esnext';
+import { selfAndDescendants, collectAdoptionSnapshot, adoptNodes, isElementNode } from './shared.esnext';
+import { childListObserversActive, queueMutationRecord, mutationNodeList } from './MutationObserver.esnext';
+import { performWithCustomElementReactions, enqueueCustomElementReaction } from './custom-element-reactions.esnext';
+import { performHookEffects, isCoveredByPendingPublication } from './hook-effects.esnext';
+import { createDOMException } from './dom-exception.esnext';
 
 class ParentNode extends ChildNode {
   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) : void 0;
+    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) : void 0;
+    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);
@@ -74,26 +132,110 @@ class ParentNode extends ChildNode {
   querySelector(selector) {
     return querySelector(this, selector);
   }
-  insertInto(child, before) {
-    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 +250,171 @@ 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 : void 0;
+  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/esnext/SVGElement.esnext

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

package/build/esnext/Text.esnext

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