@remote-dom/polyfill 1.5.1 → 1.6.0

package/build/esm/ChildNode.mjs

@@ -1,6 +1,12 @@
-import { NEXT } from './constants.mjs';
+import { PARENT, HOST, NEXT, PREV } from './constants.mjs';
+import { performWithCustomElementReactions } from './custom-element-reactions.mjs';
+import { performHookEffects } from './hook-effects.mjs';
+import { createDOMException } from './dom-exception.mjs';
 import { Node } from './Node.mjs';
 
+const INSERT_NODE = Symbol('insertNode');
+const PREFLIGHT_INSERTIONS = Symbol('preflightInsertions');
+const REPLACE_NODE = Symbol('replaceNode');
 class ChildNode extends Node {
   remove() {
     const parent = this.parentNode;
@@ -8,35 +14,90 @@ class ChildNode extends Node {
     parent.removeChild(this);
   }
   replaceWith(...nodes) {
+    const staged = stageNodes(nodes);
     const parent = this.parentNode;
     if (!parent) return;
-    const node = toNode(parent, nodes[0]);
-    const next = node[NEXT];
-    parent.replaceChild(this, node);
-    for (let i = 1; i < nodes.length; i++) {
-      parent.insertBefore(toNode(parent, nodes[i]), next);
-    }
+    return performChildNodeMutation(hookEffects => {
+      validateInsertionNodes(parent, staged);
+      let next = this[NEXT];
+      while (next && staged.includes(next)) next = next[NEXT];
+      const replacement = convertNodesIntoNode(parent, staged, hookEffects);
+      if (this.parentNode === parent) {
+        parent[REPLACE_NODE](replacement, this, hookEffects);
+      } else {
+        parent[INSERT_NODE](replacement, next, hookEffects);
+      }
+    });
   }
   before(...nodes) {
+    const staged = stageNodes(nodes);
     const parent = this.parentNode;
     if (!parent) return;
-    for (const node of nodes) {
-      parent.insertBefore(toNode(parent, node), this);
-    }
+    return performChildNodeMutation(hookEffects => {
+      validateInsertionNodes(parent, staged);
+      let previous = this[PREV];
+      while (previous && staged.includes(previous)) previous = previous[PREV];
+      const node = convertNodesIntoNode(parent, staged, hookEffects);
+      parent[INSERT_NODE](node, previous ? previous[NEXT] : parent.firstChild, hookEffects);
+    });
   }
   after(...nodes) {
+    const staged = stageNodes(nodes);
     const parent = this.parentNode;
     if (!parent) return;
-    const next = this[NEXT];
-    for (const node of nodes) {
-      parent.insertBefore(toNode(parent, node), next);
-    }
+    return performChildNodeMutation(hookEffects => {
+      validateInsertionNodes(parent, staged);
+      let next = this[NEXT];
+      while (next && staged.includes(next)) next = next[NEXT];
+      const node = convertNodesIntoNode(parent, staged, hookEffects);
+      parent[INSERT_NODE](node, next, hookEffects);
+    });
   }
 }
+function performChildNodeMutation(mutation) {
+  return performWithCustomElementReactions(() => {
+    const hookEffects = [];
+    try {
+      mutation(hookEffects);
+    } catch (error) {
+      try {
+        performHookEffects(hookEffects);
+      } catch {}
+      throw error;
+    }
+    performHookEffects(hookEffects);
+  });
+}
+function stageNodes(nodes) {
+  return nodes.map(node => node instanceof Node ? node : String(node));
+}
 function toNode(parent, node) {
   if (node instanceof Node) return node;
   const ownerDocument = parent.ownerDocument;
   return ownerDocument.createTextNode(String(node));
 }
+function validateInsertionNodes(parent, nodes) {
+  for (const node of nodes) {
+    if (!(node instanceof Node)) continue;
+    let ancestor = parent;
+    while (ancestor) {
+      if (ancestor === node) {
+        throw createDOMException('Cannot insert a node into itself or one of its descendants', 'HierarchyRequestError');
+      }
+      ancestor = ancestor[PARENT] ?? ancestor[HOST];
+    }
+  }
+}
+function convertNodesIntoNode(parent, nodes, hookEffects) {
+  const convertedNodes = [];
+  for (const node of nodes) convertedNodes.push(toNode(parent, node));
+  if (convertedNodes.length === 1) return convertedNodes[0];
+  const fragment = parent.ownerDocument.createDocumentFragment();
+  fragment[PREFLIGHT_INSERTIONS](convertedNodes);
+  for (const node of convertedNodes) {
+    fragment[INSERT_NODE](node, null, hookEffects);
+  }
+  return fragment;
+}
 
-export { ChildNode, toNode };
+export { ChildNode, INSERT_NODE, PREFLIGHT_INSERTIONS, REPLACE_NODE, stageNodes, toNode, validateInsertionNodes };

package/build/esm/Comment.mjs

@@ -1,8 +1,8 @@
-import { NAME } from './constants.mjs';
+import { NODE_TYPE_COMMENT, NAME } from './constants.mjs';
 import { CharacterData } from './CharacterData.mjs';
 
 class Comment extends CharacterData {
-  nodeType = 8;
+  nodeType = NODE_TYPE_COMMENT;
   [NAME] = '#comment';
 }
 

package/build/esm/CustomElementRegistry.mjs

@@ -1,7 +1,26 @@
+import { createDOMException } from './dom-exception.mjs';
+
+const VALID_CUSTOM_ELEMENT_NAME = /^[a-z][^A-Z\u0000\t\n\f\r />]*-[^A-Z\u0000\t\n\f\r />]*$/u;
+const RESERVED_CUSTOM_ELEMENT_NAMES = new Set(['annotation-xml', 'color-profile', 'font-face', 'font-face-src', 'font-face-uri', 'font-face-format', 'font-face-name', 'missing-glyph']);
+function isValidCustomElementName(name) {
+  return VALID_CUSTOM_ELEMENT_NAME.test(name) && !RESERVED_CUSTOM_ELEMENT_NAMES.has(name);
+}
+function createInvalidCustomElementNameError(name) {
+  return createDOMException(`Invalid custom element name: "${name}"`, 'SyntaxError');
+}
 class CustomElementRegistryImplementation {
-  registry = (() => new Map())();
-  listenersByName = (() => new Map())();
+  registry = new Map();
+  listenersByName = new Map();
   define(name, Constructor, _options) {
+    if (!isValidCustomElementName(name)) {
+      throw createInvalidCustomElementNameError(name);
+    }
+    if (this.registry.has(name)) {
+      throw createDOMException(`A custom element named "${name}" has already been defined`, 'NotSupportedError');
+    }
+    if (this.getName(Constructor) != null) {
+      throw createDOMException('This constructor has already been registered in this custom element registry', 'NotSupportedError');
+    }
     this.registry.set(name, Constructor);
     const listeners = this.listenersByName.get(name);
     if (listeners == null) return;
@@ -20,6 +39,9 @@ class CustomElementRegistryImplementation {
     return null;
   }
   whenDefined(name) {
+    if (!isValidCustomElementName(name)) {
+      return Promise.reject(createInvalidCustomElementNameError(name));
+    }
     const Constructor = this.registry.get(name);
     if (Constructor != null) return Promise.resolve(Constructor);
     let listeners = this.listenersByName.get(name);
@@ -34,6 +56,9 @@ class CustomElementRegistryImplementation {
   upgrade(_root) {
     // TODO
   }
+  initialize(_root) {
+    // TODO
+  }
 }
 
 export { CustomElementRegistryImplementation };

package/build/esm/CustomEvent.mjs

@@ -9,7 +9,7 @@ class CustomEvent extends Event {
 
   constructor(type, eventInitDict) {
     super(type, eventInitDict);
-    this.detail = eventInitDict?.detail;
+    this.detail = eventInitDict?.detail ?? null;
   }
 
   /**
@@ -19,7 +19,7 @@ class CustomEvent extends Event {
    */
   initCustomEvent(type, bubbles, cancelable, detail) {
     super.initEvent(type, bubbles, cancelable);
-    this.detail = detail;
+    this.detail = detail ?? null;
   }
 }
 

package/build/esm/Document.mjs

@@ -1,19 +1,22 @@
-import { NodeType, NAME, IS_CONNECTED, OWNER_DOCUMENT, HOOKS, NamespaceURI, NS } from './constants.mjs';
+import { NODE_TYPE_DOCUMENT, NAME, IS_CONNECTED, OWNER_DOCUMENT, HTML_NAMESPACE, asciiLowercase, CREATE_ELEMENT, HOOKS, PREFIX, NS, SVG_NAMESPACE } from './constants.mjs';
+import { validateElementLocalName, validateAndExtractQualifiedName } from './names.mjs';
 import { Event } from './Event.mjs';
-import { ParentNode } from './ParentNode.mjs';
+import { ParentNode, removeChildForAdoption } from './ParentNode.mjs';
 import { Element } from './Element.mjs';
 import { SVGElement } from './SVGElement.mjs';
 import { Text } from './Text.mjs';
 import { Comment } from './Comment.mjs';
 import { DocumentFragment } from './DocumentFragment.mjs';
 import { HTMLTemplateElement } from './HTMLTemplateElement.mjs';
-import { cloneNode, isParentNode } from './shared.mjs';
+import { getElementsByClassName, getElementById, getElementsByTagName, cloneNode, collectAdoptionSnapshot, adoptNodes } from './shared.mjs';
 import { HTMLBodyElement } from './HTMLBodyElement.mjs';
 import { HTMLHeadElement } from './HTMLHeadElement.mjs';
 import { HTMLHtmlElement } from './HTMLHtmlElement.mjs';
+import { performWithCustomElementReactions } from './custom-element-reactions.mjs';
+import { createDOMException } from './dom-exception.mjs';
 
 class Document extends ParentNode {
-  nodeType = (() => NodeType.DOCUMENT_NODE)();
+  nodeType = NODE_TYPE_DOCUMENT;
   [NAME] = '#document';
   [IS_CONNECTED] = true;
   constructor(defaultView) {
@@ -27,15 +30,29 @@ class Document extends ParentNode {
     this.documentElement.appendChild(this.head);
     this.documentElement.appendChild(this.body);
   }
+  get textContent() {
+    return null;
+  }
+  set textContent(data) {
+  }
+  getElementsByClassName(classNames) {
+    return getElementsByClassName(this, classNames);
+  }
   createElement(localName) {
-    return createElement(this, localName);
+    const name = String(localName);
+    validateElementLocalName(name);
+    return createElement(this, asciiLowercase(name));
   }
-  createElementNS(namespaceURI, localName) {
-    return createElement(this, localName, namespaceURI);
+  createElementNS(namespaceURI, qualifiedName) {
+    const name = validateAndExtractQualifiedName(namespaceURI, qualifiedName, 'element');
+    return createElement(this, name.qualifiedName, name.namespace, name.prefix, name.localName);
+  }
+  [CREATE_ELEMENT](qualifiedName, namespace, prefix, localName) {
+    return createElement(this, qualifiedName, namespace, prefix, localName);
   }
   createTextNode(data) {
     const text = createNode(new Text(data), this);
-    this[HOOKS].createText?.(text, String(data));
+    this[HOOKS].createText?.(text, text.data);
     return text;
   }
   createComment(data) {
@@ -47,14 +64,26 @@ class Document extends ParentNode {
   createEvent() {
     return new Event('');
   }
+  getElementById(elementId) {
+    return getElementById(this, elementId);
+  }
+  getElementsByTagName(qualifiedName) {
+    return getElementsByTagName(this, qualifiedName);
+  }
   importNode(node, deep) {
+    if (node.nodeType === NODE_TYPE_DOCUMENT) {
+      throw createDOMException('Cannot import a document node', 'NotSupportedError');
+    }
     return cloneNode(node, deep, this);
   }
   adoptNode(node) {
     if (node[OWNER_DOCUMENT] === this) return node;
-    node.parentNode?.removeChild(node);
-    adoptNode(node, this);
-    return node;
+    const adoption = collectAdoptionSnapshot(node);
+    return performWithCustomElementReactions(() => {
+      const parent = node.parentNode;
+      if (parent) removeChildForAdoption(parent, node, adoption, this);else adoptNodes(adoption.nodes, this);
+      return node;
+    });
   }
 }
 function createNode(node, ownerDocument) {
@@ -65,39 +94,35 @@ function createNode(node, ownerDocument) {
   });
   return node;
 }
-function createElement(ownerDocument, name, namespace) {
+function createElement(ownerDocument, qualifiedName, namespace = HTML_NAMESPACE, prefix = null, localName = qualifiedName) {
   let element;
-  const lowerName = String(name).toLowerCase();
-  if (namespace === NamespaceURI.SVG) {
+  if (namespace === SVG_NAMESPACE) {
     element = new SVGElement();
-  } else if (lowerName === 'template') {
+  } else if (namespace === HTML_NAMESPACE && localName === 'template') {
     element = new HTMLTemplateElement();
-  } else {
-    const CustomElement = ownerDocument.defaultView.customElements.get(name);
+  } else if (namespace === HTML_NAMESPACE) {
+    const CustomElement = ownerDocument.defaultView.customElements.get(localName);
     element = CustomElement ? new CustomElement() : new Element();
+  } else {
+    element = new Element();
   }
-  return setupElement(element, ownerDocument, name, namespace);
+  return setupElement(element, ownerDocument, qualifiedName, namespace, prefix);
 }
-function setupElement(element, ownerDocument, name, namespace) {
+function setupElement(element, ownerDocument, qualifiedName, namespace = HTML_NAMESPACE, prefix = null) {
   createNode(element, ownerDocument);
-  Object.defineProperty(element, NAME, {
-    value: name
-  });
-  if (namespace) {
-    Object.defineProperty(element, NS, {
+  Object.defineProperties(element, {
+    [NAME]: {
+      value: qualifiedName
+    },
+    [NS]: {
       value: namespace
-    });
-  }
+    },
+    [PREFIX]: {
+      value: prefix
+    }
+  });
   ownerDocument[HOOKS].createElement?.(element, namespace);
   return element;
 }
-function adoptNode(node, document) {
-  node[OWNER_DOCUMENT] = document;
-  if (isParentNode(node)) {
-    for (const child of node.childNodes) {
-      adoptNode(child, document);
-    }
-  }
-}
 
-export { Document, adoptNode, createElement, createNode, setupElement };
+export { Document, createElement, createNode, setupElement };

package/build/esm/DocumentFragment.mjs

@@ -1,10 +1,14 @@
-import { NodeType, NAME, OWNER_DOCUMENT } from './constants.mjs';
+import { NODE_TYPE_DOCUMENT_FRAGMENT, NAME, OWNER_DOCUMENT } from './constants.mjs';
 import { ParentNode } from './ParentNode.mjs';
+import { getElementById } from './shared.mjs';
 
 class DocumentFragment extends ParentNode {
-  nodeType = (() => NodeType.DOCUMENT_FRAGMENT_NODE)();
+  nodeType = NODE_TYPE_DOCUMENT_FRAGMENT;
   [NAME] = '#document-fragment';
-  [OWNER_DOCUMENT] = (() => typeof window !== 'undefined' ? window.document : null)();
+  [OWNER_DOCUMENT] = typeof window !== 'undefined' ? window.document : null;
+  getElementById(elementId) {
+    return getElementById(this, elementId);
+  }
 }
 
 export { DocumentFragment };

package/build/esm/Element.mjs

@@ -1,24 +1,43 @@
-import { NodeType, NS, NamespaceURI, ATTRIBUTES } from './constants.mjs';
+import { NODE_TYPE_ELEMENT, HTML_NAMESPACE, NS, PREFIX, NAME, asciiUppercase, ATTRIBUTES, asciiLowercase } from './constants.mjs';
+import { validateAttributeLocalName, validateAndExtractQualifiedName, normalizeNamespace } from './names.mjs';
 import { ParentNode } from './ParentNode.mjs';
 import { NamedNodeMap } from './NamedNodeMap.mjs';
 import { Attr } from './Attr.mjs';
 import { serializeNode, serializeChildren, parseHtml } from './serialization.mjs';
+import { getElementsByTagName, getElementsByClassName } from './shared.mjs';
 
 class Element extends ParentNode {
-  nodeType = (() => NodeType.ELEMENT_NODE)();
-  [NS] = (() => NamespaceURI.XHTML)();
+  nodeType = NODE_TYPE_ELEMENT;
+  [NS] = HTML_NAMESPACE;
+  [PREFIX] = null;
   get namespaceURI() {
     return this[NS];
   }
+  get prefix() {
+    return this[PREFIX];
+  }
+  get localName() {
+    const prefix = this[PREFIX];
+    return prefix == null ? this[NAME] : this[NAME].slice(prefix.length + 1);
+  }
+  get nodeName() {
+    return this[NS] === HTML_NAMESPACE ? asciiUppercase(this[NAME]) : this[NAME];
+  }
   get tagName() {
     return this.nodeName;
   }
+  get id() {
+    return this.getAttributeNS(null, 'id') ?? '';
+  }
+  set id(id) {
+    this.setAttribute('id', String(id));
+  }
   get slot() {
-    return this.getAttribute('slot') ?? '';
+    return this.getAttributeNS(null, 'slot') ?? '';
   }
   set slot(slot) {
     const finalSlot = String(slot);
-    if (this.getAttribute('slot') !== finalSlot) {
+    if (this.getAttributeNS(null, 'slot') !== finalSlot) {
       this.attributes.setNamedItem(new Attr('slot', finalSlot));
     }
   }
@@ -33,9 +52,15 @@ class Element extends ParentNode {
   getAttributeNames() {
     return [...this.attributes].map(attr => attr.name);
   }
+  getElementsByTagName(qualifiedName) {
+    return getElementsByTagName(this, qualifiedName);
+  }
   get firstElementChild() {
     return this.children[0] ?? null;
   }
+  getElementsByClassName(classNames) {
+    return getElementsByClassName(this, classNames);
+  }
   get lastElementChild() {
     return this.children[this.children.length - 1] ?? null;
   }
@@ -50,10 +75,43 @@ class Element extends ParentNode {
     return sib;
   }
   setAttribute(name, value) {
-    this.attributes.setNamedItem(new Attr(name, String(value)));
+    const qualifiedName = String(name);
+    const normalizedValue = String(value);
+    validateAttributeLocalName(qualifiedName);
+    const normalizedName = this[NS] === HTML_NAMESPACE ? asciiLowercase(qualifiedName) : qualifiedName;
+    const attribute = this.attributes.getNamedItemNS(null, normalizedName);
+    if (attribute) {
+      attribute.value = normalizedValue;
+    } else {
+      this.attributes.setNamedItem(new Attr(normalizedName, normalizedValue));
+    }
+  }
+  setAttributeNS(namespace, qualifiedName, value) {
+    const normalizedNamespace = normalizeNamespace(namespace);
+    const normalizedQualifiedName = String(qualifiedName);
+    const normalizedValue = String(value);
+    const name = validateAndExtractQualifiedName(normalizedNamespace, normalizedQualifiedName, 'attribute');
+    const attribute = this.attributes.getNamedItemNS(name.namespace, name.localName);
+    if (attribute) {
+      attribute.value = normalizedValue;
+    } else {
+      this.attributes.setNamedItemNS(new Attr(name.qualifiedName, normalizedValue, name.namespace));
+    }
   }
-  setAttributeNS(namespace, name, value) {
-    this.attributes.setNamedItemNS(new Attr(name, String(value), namespace));
+  toggleAttribute(name, force) {
+    const qualifiedName = String(name);
+    validateAttributeLocalName(qualifiedName);
+    const normalizedName = this[NS] === HTML_NAMESPACE ? asciiLowercase(qualifiedName) : qualifiedName;
+    const attribute = this.attributes.getNamedItemNS(null, normalizedName);
+    const normalizedForce = force === undefined ? undefined : Boolean(force);
+    if (attribute == null) {
+      if (normalizedForce === false) return false;
+      this.attributes.setNamedItem(new Attr(normalizedName, ''));
+      return true;
+    }
+    if (normalizedForce === true) return true;
+    this.attributes.removeNamedItemNS(null, normalizedName);
+    return false;
   }
   getAttribute(name) {
     const attr = this.attributes.getNamedItem(name);
@@ -72,7 +130,9 @@ class Element extends ParentNode {
     return attr != null;
   }
   removeAttribute(name) {
-    this.attributes.removeNamedItem(name);
+    const qualifiedName = String(name);
+    const normalizedName = this[NS] === HTML_NAMESPACE ? asciiLowercase(qualifiedName) : qualifiedName;
+    this.attributes.removeNamedItemNS(null, normalizedName);
   }
   removeAttributeNS(namespace, name) {
     this.attributes.removeNamedItemNS(namespace, name);

package/build/esm/Event.mjs

@@ -1,26 +1,22 @@
-import { PATH, STOP_IMMEDIATE_PROPAGATION, IS_TRUSTED, LISTENERS } from './constants.mjs';
+import { PATH, STOP_IMMEDIATE_PROPAGATION, DISPATCHING, IS_TRUSTED, LISTENERS } from './constants.mjs';
 
-let EventPhase = /*#__PURE__*/function (EventPhase) {
-  EventPhase[EventPhase["NONE"] = 0] = "NONE";
-  EventPhase[EventPhase["CAPTURING_PHASE"] = 1] = "CAPTURING_PHASE";
-  EventPhase[EventPhase["AT_TARGET"] = 2] = "AT_TARGET";
-  EventPhase[EventPhase["BUBBLING_PHASE"] = 3] = "BUBBLING_PHASE";
-  return EventPhase;
-}({});
-const CAPTURE_MARKER = '@';
+const EVENT_PHASE_NONE = 0;
+const EVENT_PHASE_CAPTURING = 1;
+const EVENT_PHASE_AT_TARGET = 2;
+const EVENT_PHASE_BUBBLING = 3;
 const now = typeof performance === 'undefined' ? Date.now : performance.now.bind(performance);
 class Event {
-  static NONE = (() => EventPhase.NONE)();
-  static CAPTURING_PHASE = (() => EventPhase.CAPTURING_PHASE)();
-  static AT_TARGET = (() => EventPhase.AT_TARGET)();
-  static BUBBLING_PHASE = (() => EventPhase.BUBBLING_PHASE)();
+  static NONE = EVENT_PHASE_NONE;
+  static CAPTURING_PHASE = EVENT_PHASE_CAPTURING;
+  static AT_TARGET = EVENT_PHASE_AT_TARGET;
+  static BUBBLING_PHASE = EVENT_PHASE_BUBBLING;
 
-  // NONE = EventPhase.NONE;
-  // CAPTURING_PHASE = EventPhase.CAPTURING_PHASE;
-  // AT_TARGET = EventPhase.AT_TARGET;
-  // BUBBLING_PHASE = EventPhase.BUBBLING_PHASE;
+  // NONE = EVENT_PHASE_NONE;
+  // CAPTURING_PHASE = EVENT_PHASE_CAPTURING;
+  // AT_TARGET = EVENT_PHASE_AT_TARGET;
+  // BUBBLING_PHASE = EVENT_PHASE_BUBBLING;
 
-  timeStamp = (() => now())();
+  timeStamp = now();
   target = null;
   currentTarget = null;
   srcElement = null;
@@ -29,11 +25,12 @@ class Event {
   composed = false;
   defaultPrevented = false;
   cancelBubble = false;
-  eventPhase = 0;
+  eventPhase = EVENT_PHASE_NONE;
   // private inPassiveListener = false;
 
   [PATH] = [];
   [STOP_IMMEDIATE_PROPAGATION] = false;
+  [DISPATCHING] = false;
   constructor(type, options) {
     this.type = type;
     Object.defineProperty(this, IS_TRUSTED, {
@@ -50,7 +47,7 @@ class Event {
     return this[IS_TRUSTED];
   }
   composedPath() {
-    return this[PATH];
+    return [...this[PATH]];
   }
   stopPropagation() {
     this.cancelBubble = true;
@@ -60,13 +57,13 @@ class Event {
     this.cancelBubble = true;
   }
   preventDefault() {
-    this.defaultPrevented = true;
+    if (this.cancelable) this.defaultPrevented = true;
   }
   set returnValue(value) {
-    this.defaultPrevented = value;
+    if (!value) this.preventDefault();
   }
   get returnValue() {
-    return this.defaultPrevented;
+    return !this.defaultPrevented;
   }
 
   /** @deprecated */
@@ -77,12 +74,15 @@ class Event {
   }
 }
 function fireEvent(event, currentTarget, phase) {
+  if (event.cancelBubble) return;
   const listeners = currentTarget[LISTENERS];
-  const list = listeners?.get(`${event.type}${phase === EventPhase.CAPTURING_PHASE ? CAPTURE_MARKER : ''}`);
+  const list = listeners?.get(event.type)?.[phase === EVENT_PHASE_CAPTURING ? 'capture' : 'bubble'];
   if (!list) return;
-  for (const listener of list) {
-    event.eventPhase = event.target === currentTarget ? EventPhase.AT_TARGET : phase;
+  for (const registration of [...list]) {
+    if (!list.has(registration) || registration.signal?.aborted) continue;
+    event.eventPhase = event.target === currentTarget ? EVENT_PHASE_AT_TARGET : phase;
     event.currentTarget = currentTarget;
+    const listener = registration.normalizedListener;
     try {
       if (typeof listener === 'object') {
         listener.handleEvent(event);
@@ -99,4 +99,4 @@ function thrower(error) {
   throw error;
 }
 
-export { CAPTURE_MARKER, Event, EventPhase, fireEvent };
+export { EVENT_PHASE_AT_TARGET, EVENT_PHASE_BUBBLING, EVENT_PHASE_CAPTURING, EVENT_PHASE_NONE, Event, fireEvent };