@remote-dom/polyfill 1.5.1 → 1.6.0

package/build/esnext/ChildNode.esnext

@@ -1,6 +1,12 @@
-import { NEXT } from './constants.esnext';
+import { PARENT, HOST, NEXT, PREV } from './constants.esnext';
+import { performWithCustomElementReactions } from './custom-element-reactions.esnext';
+import { performHookEffects } from './hook-effects.esnext';
+import { createDOMException } from './dom-exception.esnext';
 import { Node } from './Node.esnext';
 
+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,98 @@ 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/esnext/Comment.esnext

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

package/build/esnext/CustomElementRegistry.esnext

@@ -1,7 +1,44 @@
+import { createDOMException } from './dom-exception.esnext';
+
+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 = /* @__PURE__ */ 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 = /* @__PURE__ */ new Map();
   listenersByName = /* @__PURE__ */ 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 +57,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);
@@ -33,6 +73,8 @@ class CustomElementRegistryImplementation {
   }
   upgrade(_root) {
   }
+  initialize(_root) {
+  }
 }
 
 export { CustomElementRegistryImplementation };

package/build/esnext/CustomEvent.esnext

@@ -9,7 +9,7 @@ class CustomEvent extends Event {
   detail;
   constructor(type, eventInitDict) {
     super(type, eventInitDict);
-    this.detail = eventInitDict?.detail;
+    this.detail = eventInitDict?.detail ?? null;
   }
   /**
    * Returns any custom data event was created with. Typically used for synthetic events.
@@ -18,7 +18,7 @@ class CustomEvent extends Event {
    */
   initCustomEvent(type, bubbles, cancelable, detail) {
     super.initEvent(type, bubbles, cancelable);
-    this.detail = detail;
+    this.detail = detail ?? null;
   }
 }
 

package/build/esnext/Document.esnext

@@ -1,19 +1,22 @@
-import { NodeType, NAME, IS_CONNECTED, OWNER_DOCUMENT, HOOKS, NamespaceURI, NS } from './constants.esnext';
+import { NODE_TYPE_DOCUMENT, NAME, IS_CONNECTED, OWNER_DOCUMENT, HTML_NAMESPACE, asciiLowercase, CREATE_ELEMENT, HOOKS, PREFIX, NS, SVG_NAMESPACE } from './constants.esnext';
+import { validateElementLocalName, validateAndExtractQualifiedName } from './names.esnext';
 import { Event } from './Event.esnext';
-import { ParentNode } from './ParentNode.esnext';
+import { ParentNode, removeChildForAdoption } from './ParentNode.esnext';
 import { Element } from './Element.esnext';
 import { SVGElement } from './SVGElement.esnext';
 import { Text } from './Text.esnext';
 import { Comment } from './Comment.esnext';
 import { DocumentFragment } from './DocumentFragment.esnext';
 import { HTMLTemplateElement } from './HTMLTemplateElement.esnext';
-import { cloneNode, isParentNode } from './shared.esnext';
+import { getElementsByClassName, getElementById, getElementsByTagName, cloneNode, collectAdoptionSnapshot, adoptNodes } from './shared.esnext';
 import { HTMLBodyElement } from './HTMLBodyElement.esnext';
 import { HTMLHeadElement } from './HTMLHeadElement.esnext';
 import { HTMLHtmlElement } from './HTMLHtmlElement.esnext';
+import { performWithCustomElementReactions } from './custom-element-reactions.esnext';
+import { createDOMException } from './dom-exception.esnext';
 
 class Document extends ParentNode {
-  nodeType = NodeType.DOCUMENT_NODE;
+  nodeType = NODE_TYPE_DOCUMENT;
   [NAME] = "#document";
   body;
   head;
@@ -31,15 +34,39 @@ 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, qualifiedName) {
+    const name = validateAndExtractQualifiedName(
+      namespaceURI,
+      qualifiedName,
+      "element"
+    );
+    return createElement(
+      this,
+      name.qualifiedName,
+      name.namespace,
+      name.prefix,
+      name.localName
+    );
   }
-  createElementNS(namespaceURI, localName) {
-    return createElement(this, localName, namespaceURI);
+  [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) {
@@ -51,14 +78,30 @@ 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) {
@@ -69,35 +112,29 @@ 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, { value: namespace });
-  }
+  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/esnext/DocumentFragment.esnext

@@ -1,10 +1,14 @@
-import { NodeType, NAME, OWNER_DOCUMENT } from './constants.esnext';
+import { NODE_TYPE_DOCUMENT_FRAGMENT, NAME, OWNER_DOCUMENT } from './constants.esnext';
 import { ParentNode } from './ParentNode.esnext';
+import { getElementById } from './shared.esnext';
 
 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;
+  getElementById(elementId) {
+    return getElementById(this, elementId);
+  }
 }
 
 export { DocumentFragment };

package/build/esnext/Element.esnext

@@ -1,26 +1,45 @@
-import { NodeType, NS, NamespaceURI, ATTRIBUTES } from './constants.esnext';
+import { NODE_TYPE_ELEMENT, HTML_NAMESPACE, NS, PREFIX, NAME, asciiUppercase, ATTRIBUTES, asciiLowercase } from './constants.esnext';
+import { validateAttributeLocalName, validateAndExtractQualifiedName, normalizeNamespace } from './names.esnext';
 import { ParentNode } from './ParentNode.esnext';
 import { NamedNodeMap } from './NamedNodeMap.esnext';
 import { Attr } from './Attr.esnext';
 import { serializeNode, serializeChildren, parseHtml } from './serialization.esnext';
+import { getElementsByTagName, getElementsByClassName } from './shared.esnext';
 
 class Element extends ParentNode {
   static observedAttributes;
-  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;
   }
   [ATTRIBUTES];
+  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));
     }
   }
@@ -35,9 +54,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;
   }
@@ -52,10 +77,52 @@ 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 === void 0 ? void 0 : 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);
@@ -74,7 +141,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/esnext/Event.esnext

@@ -1,32 +1,20 @@
-import { IS_TRUSTED, PATH, STOP_IMMEDIATE_PROPAGATION, LISTENERS } from './constants.esnext';
+import { PATH, IS_TRUSTED, STOP_IMMEDIATE_PROPAGATION, DISPATCHING, LISTENERS } from './constants.esnext';
 
-var EventPhase = /* @__PURE__ */ ((EventPhase2) => {
-  EventPhase2[EventPhase2["NONE"] = 0] = "NONE";
-  EventPhase2[EventPhase2["CAPTURING_PHASE"] = 1] = "CAPTURING_PHASE";
-  EventPhase2[EventPhase2["AT_TARGET"] = 2] = "AT_TARGET";
-  EventPhase2[EventPhase2["BUBBLING_PHASE"] = 3] = "BUBBLING_PHASE";
-  return EventPhase2;
-})(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 {
-  constructor(type, options) {
-    this.type = type;
-    Object.defineProperty(this, IS_TRUSTED, { writable: true, value: false });
-    if (options) {
-      if (options.bubbles) this.bubbles = options.bubbles;
-      if (options.cancelable) this.cancelable = options.cancelable;
-      if (options.composed) this.composed = options.composed;
-    }
-  }
-  static NONE = 0 /* NONE */;
-  static CAPTURING_PHASE = 1 /* CAPTURING_PHASE */;
-  static AT_TARGET = 2 /* AT_TARGET */;
-  static BUBBLING_PHASE = 3 /* BUBBLING_PHASE */;
-  // NONE = EventPhase.NONE;
-  // CAPTURING_PHASE = EventPhase.CAPTURING_PHASE;
-  // AT_TARGET = EventPhase.AT_TARGET;
-  // 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 = EVENT_PHASE_NONE;
+  // CAPTURING_PHASE = EVENT_PHASE_CAPTURING;
+  // AT_TARGET = EVENT_PHASE_AT_TARGET;
+  // BUBBLING_PHASE = EVENT_PHASE_BUBBLING;
+  type;
   timeStamp = now();
   target = null;
   currentTarget = null;
@@ -36,17 +24,27 @@ class Event {
   composed = false;
   defaultPrevented = false;
   cancelBubble = false;
-  eventPhase = 0;
+  eventPhase = EVENT_PHASE_NONE;
   // private inPassiveListener = false;
   data;
   [PATH] = [];
   [IS_TRUSTED];
   [STOP_IMMEDIATE_PROPAGATION] = false;
+  [DISPATCHING] = false;
+  constructor(type, options) {
+    this.type = type;
+    Object.defineProperty(this, IS_TRUSTED, { writable: true, value: false });
+    if (options) {
+      if (options.bubbles) this.bubbles = options.bubbles;
+      if (options.cancelable) this.cancelable = options.cancelable;
+      if (options.composed) this.composed = options.composed;
+    }
+  }
   get isTrusted() {
     return this[IS_TRUSTED];
   }
   composedPath() {
-    return this[PATH];
+    return [...this[PATH]];
   }
   stopPropagation() {
     this.cancelBubble = true;
@@ -56,13 +54,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 */
   initEvent(type, bubbles, cancelable) {
@@ -72,14 +70,15 @@ class Event {
   }
 }
 function fireEvent(event, currentTarget, phase) {
+  if (event.cancelBubble) return;
   const listeners = currentTarget[LISTENERS];
-  const list = listeners?.get(
-    `${event.type}${phase === 1 /* 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 ? 2 /* 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);
@@ -96,4 +95,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 };