@remote-dom/polyfill 0.0.1

package/LICENSE.md

@@ -0,0 +1,7 @@
+Copyright 2020-present, Shopify Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,45 @@
+# `@remote-dom/polyfill`
+
+A polyfill for the browser APIs used by Remote DOM. This allows you to use Remote DOM in environments that don’t have a native DOM, like [Web Workers](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API).
+
+This package provides a low-level polyfill, with hooks that allow other libraries to intercept changes to the DOM. Unless you know you need this package, you probably want to import from [`@remote-dom/core/polyfill`](../core/README.md#remote-domcorepolyfill) instead, which uses the hooks provided by this library to automatically synchronize remote elements between environments.
+
+## Installation
+
+```sh
+npm install @remote-dom/polyfill --save # npm
+pnpm install @remote-dom/polyfill --save # pnpm
+yarn add @remote-dom/polyfill # yarn
+```
+
+## Usage
+
+This package provides a `Window` class, which implements a limited subset of the [`Window` browser interface](https://developer.mozilla.org/en-US/docs/Web/API/Window). You’ll create an instance of the `Window` class and install it to the global environment using the `Window.setGlobal()` method.
+
+```ts
+import {Window} from '@remote-dom/polyfill';
+
+const window = new Window();
+Window.setGlobal(window);
+
+// Now you can use many important DOM APIs, like `document` and `Element`:
+const div = document.createElement('div');
+```
+
+This process will install polyfilled versions of the following globals:
+
+- [`window`](https://developer.mozilla.org/en-US/docs/Web/API/Window/window), [`parent`](https://developer.mozilla.org/en-US/docs/Web/API/Window/parent), [`top`](https://developer.mozilla.org/en-US/docs/Web/API/Window/top), and [`self`](https://developer.mozilla.org/en-US/docs/Web/API/Window/self) which are all references to the `Window` instance (`self` is only overwritten when it is not already defined, to avoid overwriting the Web Worker `self` binding).
+- [`document`](https://developer.mozilla.org/en-US/docs/Web/API/Window/document)
+- [`customElements`](https://developer.mozilla.org/en-US/docs/Web/API/Window/customElements)
+- [`location`](https://developer.mozilla.org/en-US/docs/Web/API/Window/location) and [`navigator`](https://developer.mozilla.org/en-US/docs/Web/API/Window/navigator), though these are just set to `globalThis.location` and `globalThis.navigator`.
+- The [`Event`](https://developer.mozilla.org/en-US/docs/Web/API/Event), [`EventTarget`](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget), [`CustomEvent`](https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent), [`Node`](https://developer.mozilla.org/en-US/docs/Web/API/Node), [`ParentNode`](https://developer.mozilla.org/en-US/docs/Web/API/ParentNode), [`ChildNode`](https://developer.mozilla.org/en-US/docs/Web/API/ChildNode), [`Document`](https://developer.mozilla.org/en-US/docs/Web/API/Document), [`DocumentFragment`](https://developer.mozilla.org/en-US/docs/Web/API/DocumentFragment), [`CharacterData`](https://developer.mozilla.org/en-US/docs/Web/API/CharacterData), [`Comment`](https://developer.mozilla.org/en-US/docs/Web/API/Comment), [`Text`](https://developer.mozilla.org/en-US/docs/Web/API/Text), [`Element`](https://developer.mozilla.org/en-US/docs/Web/API/Element), [`HTMLElement`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement), [`SVGElement`](https://developer.mozilla.org/en-US/docs/Web/API/SVGElement), [`HTMLTemplateElement`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLTemplateElement), and [`MutationObserver`](https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver) constructors.
+
+This polyfill lets you hook into many of the operations that happen in the DOM, like creating elements, updating attributes, and adding event listeners. You define these hooks by overwriting any of the properties on the `hooks` export of this library.
+
+```ts
+import {hooks} from '@remote-dom/polyfill';
+
+hooks.createElement = (element) => {
+  console.log('Creating element:', element);
+};
+```

package/build/cjs/Attr.cjs

@@ -0,0 +1,54 @@
+'use strict';
+
+var hooks = require('./hooks.cjs');
+var constants = require('./constants.cjs');
+var Node = require('./Node.cjs');
+
+class Attr extends Node.Node {
+  nodeType = constants.NodeType.ATTRIBUTE_NODE;
+  [constants.NS] = null;
+  [constants.NEXT] = null;
+  [constants.OWNER_ELEMENT] = null;
+  isConnected = false;
+  constructor(name, value, namespace) {
+    super();
+    this[constants.NAME] = name;
+    this[constants.VALUE] = value;
+    if (namespace) this[constants.NS] = namespace;
+  }
+  get nodeName() {
+    return this[constants.NAME];
+  }
+  set nodeName(_readonly) {}
+  get name() {
+    return this[constants.NAME];
+  }
+  set name(_readonly) {}
+  get value() {
+    return this[constants.VALUE];
+  }
+  set value(value) {
+    const str = String(value);
+    this[constants.VALUE] = str;
+    const ownerElement = this[constants.OWNER_ELEMENT];
+    if (!ownerElement) return;
+    hooks.hooks.setAttribute?.(ownerElement, this[constants.NAME], str, this[constants.NS]);
+  }
+  get nodeValue() {
+    return this.value;
+  }
+  set nodeValue(value) {
+    this.value = value;
+  }
+  get ownerElement() {
+    return this[constants.OWNER_ELEMENT];
+  }
+  get namespaceURI() {
+    return this[constants.NS];
+  }
+  get specified() {
+    return true;
+  }
+}
+
+exports.Attr = Attr;

package/build/cjs/CharacterData.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+var hooks = require('./hooks.cjs');
+var constants = require('./constants.cjs');
+var ChildNode = require('./ChildNode.cjs');
+
+class CharacterData extends ChildNode.ChildNode {
+  [constants.DATA] = '';
+  constructor(data) {
+    super();
+    this.setData(data);
+  }
+  setData(data) {
+    let str = '';
+    if (data != null) {
+      str = typeof data === 'string' ? data : String(data);
+    }
+    this[constants.DATA] = str;
+    hooks.hooks.setText?.(this, str);
+  }
+  get data() {
+    return this[constants.DATA];
+  }
+  set data(data) {
+    this.setData(data);
+  }
+}
+
+exports.CharacterData = CharacterData;

package/build/cjs/ChildNode.cjs

@@ -0,0 +1,45 @@
+'use strict';
+
+var constants = require('./constants.cjs');
+var Node = require('./Node.cjs');
+
+class ChildNode extends Node.Node {
+  remove() {
+    const parent = this.parentNode;
+    if (!parent) return;
+    parent.removeChild(this);
+  }
+  replaceWith(...nodes) {
+    const parent = this.parentNode;
+    if (!parent) return;
+    const node = toNode(parent, nodes[0]);
+    const next = node[constants.NEXT];
+    parent.replaceChild(this, node);
+    for (let i = 1; i < nodes.length; i++) {
+      parent.insertBefore(toNode(parent, nodes[i]), next);
+    }
+  }
+  before(...nodes) {
+    const parent = this.parentNode;
+    if (!parent) return;
+    for (const node of nodes) {
+      parent.insertBefore(toNode(parent, node), this);
+    }
+  }
+  after(...nodes) {
+    const parent = this.parentNode;
+    if (!parent) return;
+    const next = this[constants.NEXT];
+    for (const node of nodes) {
+      parent.insertBefore(toNode(parent, node), next);
+    }
+  }
+}
+function toNode(parent, node) {
+  if (node instanceof Node.Node) return node;
+  const ownerDocument = parent.ownerDocument;
+  return ownerDocument.createTextNode(String(node));
+}
+
+exports.ChildNode = ChildNode;
+exports.toNode = toNode;

package/build/cjs/Comment.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var constants = require('./constants.cjs');
+var CharacterData = require('./CharacterData.cjs');
+
+class Comment extends CharacterData.CharacterData {
+  nodeType = 8;
+  [constants.NAME] = '#comment';
+}
+
+exports.Comment = Comment;

package/build/cjs/CustomElementRegistry.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+class CustomElementRegistryImplementation {
+  registry = new Map();
+  listenersByName = new Map();
+  define(name, Constructor, _options) {
+    this.registry.set(name, Constructor);
+    const listeners = this.listenersByName.get(name);
+    if (listeners == null) return;
+    this.listenersByName.delete(name);
+    for (const listener of listeners) {
+      listener(Constructor);
+    }
+  }
+  get(name) {
+    return this.registry.get(name);
+  }
+  whenDefined(name) {
+    const Constructor = this.registry.get(name);
+    if (Constructor != null) return Promise.resolve(Constructor);
+    let listeners = this.listenersByName.get(name);
+    if (listeners == null) {
+      listeners = [];
+      this.listenersByName.set(name, listeners);
+    }
+    return new Promise(resolve => {
+      listeners.push(resolve);
+    });
+  }
+  upgrade(_root) {
+    // TODO
+  }
+}
+
+exports.CustomElementRegistryImplementation = CustomElementRegistryImplementation;

package/build/cjs/CustomEvent.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+var Event = require('./Event.cjs');
+
+class CustomEvent extends Event.Event {
+  /**
+   * Returns any custom data event was created with. Typically used for synthetic events.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CustomEvent/detail)
+   */
+
+  constructor(type, eventInitDict) {
+    super(type, eventInitDict);
+    this.detail = eventInitDict?.detail;
+  }
+
+  /**
+   * Returns any custom data event was created with. Typically used for synthetic events.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CustomEvent/detail)
+   */
+  initCustomEvent(type, bubbles, cancelable, detail) {
+    super.initEvent(type, bubbles, cancelable);
+    this.detail = detail;
+  }
+}
+
+exports.CustomEvent = CustomEvent;

package/build/cjs/Document.cjs

@@ -0,0 +1,94 @@
+'use strict';
+
+var constants = require('./constants.cjs');
+var Event = require('./Event.cjs');
+var ParentNode = require('./ParentNode.cjs');
+var Element = require('./Element.cjs');
+var SVGElement = require('./SVGElement.cjs');
+var Text = require('./Text.cjs');
+var Comment = require('./Comment.cjs');
+var DocumentFragment = require('./DocumentFragment.cjs');
+var HTMLTemplateElement = require('./HTMLTemplateElement.cjs');
+var shared = require('./shared.cjs');
+
+class Document extends ParentNode.ParentNode {
+  nodeType = constants.NodeType.DOCUMENT_NODE;
+  [constants.NAME] = '#document';
+  constructor(defaultView) {
+    super();
+    this.defaultView = defaultView;
+    this[constants.OWNER_DOCUMENT] = this;
+  }
+  createElement(localName) {
+    const lowerName = String(localName).toLowerCase();
+    if (lowerName === 'template') {
+      return createElement(new HTMLTemplateElement.HTMLTemplateElement(), this, 'template');
+    }
+    const CustomElement = this.defaultView.customElements.get(localName);
+    if (CustomElement) {
+      return createElement(new CustomElement(), this, localName);
+    } else {
+      return createElement(new Element.Element(), this, localName);
+    }
+  }
+  createElementNS(localName, namespaceURI) {
+    if (namespaceURI === constants.NamespaceURI.SVG) {
+      return createElement(new SVGElement.SVGElement(), this, localName);
+    }
+    return createElement(new Element.Element(), this, localName, namespaceURI);
+  }
+  createTextNode(data) {
+    return createNode(new Text.Text(data), this);
+  }
+  createComment(data) {
+    return createNode(new Comment.Comment(data), this);
+  }
+  createDocumentFragment() {
+    return createNode(new DocumentFragment.DocumentFragment(), this);
+  }
+  createEvent() {
+    return new Event.Event('');
+  }
+  importNode(node, deep) {
+    return shared.cloneNode(node, deep, this);
+  }
+  adoptNode(node) {
+    if (node[constants.OWNER_DOCUMENT] === this) return node;
+    node.parentNode?.removeChild(node);
+    adoptNode(node, this);
+    return node;
+  }
+}
+function createNode(node, ownerDocument) {
+  Object.defineProperty(node, constants.OWNER_DOCUMENT, {
+    value: ownerDocument,
+    writable: true,
+    enumerable: false
+  });
+  return node;
+}
+function createElement(element, ownerDocument, name, namespace) {
+  createNode(element, ownerDocument);
+  Object.defineProperty(element, constants.NAME, {
+    value: name
+  });
+  if (namespace) {
+    Object.defineProperty(element, constants.NS, {
+      value: namespace
+    });
+  }
+  return element;
+}
+function adoptNode(node, document) {
+  node[constants.OWNER_DOCUMENT] = document;
+  if (shared.isParentNode(node)) {
+    for (const child of node.childNodes) {
+      adoptNode(child, document);
+    }
+  }
+}
+
+exports.Document = Document;
+exports.adoptNode = adoptNode;
+exports.createElement = createElement;
+exports.createNode = createNode;

package/build/cjs/DocumentFragment.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var constants = require('./constants.cjs');
+var ParentNode = require('./ParentNode.cjs');
+
+class DocumentFragment extends ParentNode.ParentNode {
+  nodeType = constants.NodeType.DOCUMENT_FRAGMENT_NODE;
+  [constants.NAME] = '#document-fragment';
+  [constants.OWNER_DOCUMENT] = window.document;
+}
+
+exports.DocumentFragment = DocumentFragment;

package/build/cjs/Element.cjs

@@ -0,0 +1,81 @@
+'use strict';
+
+var constants = require('./constants.cjs');
+var ParentNode = require('./ParentNode.cjs');
+var NamedNodeMap = require('./NamedNodeMap.cjs');
+var Attr = require('./Attr.cjs');
+var serialization = require('./serialization.cjs');
+
+class Element extends ParentNode.ParentNode {
+  nodeType = constants.NodeType.ELEMENT_NODE;
+  [constants.NS] = constants.NamespaceURI.XHTML;
+  [constants.SLOT] = '';
+  get namespaceURI() {
+    return this[constants.NS];
+  }
+  get tagName() {
+    return this.nodeName;
+  }
+  get slot() {
+    return this[constants.SLOT];
+  }
+  set slot(slot) {
+    const finalSlot = String(slot);
+    this[constants.SLOT] = finalSlot;
+    if (this.getAttribute('slot') !== finalSlot) {
+      this.attributes.setNamedItem(new Attr.Attr('slot', finalSlot));
+    }
+  }
+  get attributes() {
+    let attributes = this[constants.ATTRIBUTES];
+    if (!attributes) {
+      attributes = new NamedNodeMap.NamedNodeMap(this);
+      this[constants.ATTRIBUTES] = attributes;
+    }
+    return attributes;
+  }
+  setAttribute(name, value) {
+    this.attributes.setNamedItem(new Attr.Attr(name, String(value)));
+  }
+  setAttributeNS(namespace, name, value) {
+    this.attributes.setNamedItemNS(new Attr.Attr(name, String(value), namespace));
+  }
+  getAttribute(name) {
+    const attr = this.attributes.getNamedItem(name);
+    return attr && attr.value;
+  }
+  getAttributeNS(namespace, name) {
+    const attr = this.attributes.getNamedItemNS(namespace, name);
+    return attr && attr.value;
+  }
+  hasAttribute(name) {
+    const attr = this.attributes.getNamedItem(name);
+    return attr != null;
+  }
+  hasAttributeNS(namespace, name) {
+    const attr = this.attributes.getNamedItemNS(namespace, name);
+    return attr != null;
+  }
+  removeAttribute(name) {
+    this.attributes.removeNamedItem(name);
+  }
+  removeAttributeNS(namespace, name) {
+    this.attributes.removeNamedItemNS(namespace, name);
+  }
+  get outerHTML() {
+    return serialization.serializeNode(this);
+  }
+  get innerHTML() {
+    return serialization.serializeChildren(this);
+  }
+  set innerHTML(html) {
+    if (html == null || html === '') {
+      this.replaceChildren();
+    } else {
+      const fragment = serialization.parseHtml(String(html), this);
+      this.replaceChildren(fragment);
+    }
+  }
+}
+
+exports.Element = Element;

package/build/cjs/Event.cjs

@@ -0,0 +1,113 @@
+'use strict';
+
+var constants = require('./constants.cjs');
+
+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 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;
+
+  // NONE = EventPhase.NONE;
+  // CAPTURING_PHASE = EventPhase.CAPTURING_PHASE;
+  // AT_TARGET = EventPhase.AT_TARGET;
+  // BUBBLING_PHASE = EventPhase.BUBBLING_PHASE;
+
+  timeStamp = now();
+  target = null;
+  currentTarget = null;
+  srcElement = null;
+  bubbles = false;
+  cancelable = false;
+  composed = false;
+  defaultPrevented = false;
+  cancelBubble = false;
+  immediatePropagationStopped = false;
+  eventPhase = 0;
+  path = [];
+  // private inPassiveListener = false;
+
+  constructor(type, options) {
+    this.type = type;
+    Object.defineProperty(this, constants.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 composedPath() {
+    return this.path;
+  }
+  get isTrusted() {
+    return this[constants.IS_TRUSTED];
+  }
+  stopPropagation() {
+    this.cancelBubble = true;
+  }
+  stopImmediatePropagation() {
+    this.immediatePropagationStopped = true;
+  }
+  preventDefault() {
+    this.defaultPrevented = true;
+  }
+  set returnValue(value) {
+    this.defaultPrevented = value;
+  }
+  get returnValue() {
+    return this.defaultPrevented;
+  }
+
+  /** @deprecated */
+  initEvent(type, bubbles, cancelable) {
+    this.type = type;
+    this.bubbles = Boolean(bubbles);
+    this.cancelable = Boolean(cancelable);
+  }
+}
+function fireEvent(event, target, phase) {
+  const listeners = target[constants.LISTENERS];
+  const list = listeners?.get(`${event.type}${phase === EventPhase.CAPTURING_PHASE ? CAPTURE_MARKER : ''}`);
+  if (!list) return false;
+  let defaultPrevented = false;
+  for (const listener of list) {
+    event.eventPhase = phase;
+    event.currentTarget = target;
+    try {
+      if (typeof listener === 'object') {
+        listener.handleEvent(event);
+      } else {
+        listener.call(target, event);
+      }
+    } catch (err) {
+      setTimeout(thrower, 0, err);
+    }
+    if (event.defaultPrevented === true) {
+      defaultPrevented = true;
+    }
+    if (event.immediatePropagationStopped) {
+      break;
+    }
+  }
+  return defaultPrevented;
+}
+function thrower(error) {
+  throw error;
+}
+
+exports.CAPTURE_MARKER = CAPTURE_MARKER;
+exports.Event = Event;
+exports.EventPhase = EventPhase;
+exports.fireEvent = fireEvent;

package/build/cjs/EventTarget.cjs

@@ -0,0 +1,101 @@
+'use strict';
+
+var hooks = require('./hooks.cjs');
+var constants = require('./constants.cjs');
+var Event = require('./Event.cjs');
+
+const ONCE_LISTENERS = Symbol('onceListeners');
+class EventTarget {
+  addEventListener(type, listener, options) {
+    if (listener == null) return;
+    const capture = options === true || options && options.capture === true;
+    const once = typeof options === 'object' && options.once === true;
+    const signal = typeof options === 'object' ? options.signal : undefined;
+    const key = `${type}${capture ? Event.CAPTURE_MARKER : ''}`;
+    let normalizedListener = listener;
+    if (once) {
+      normalizedListener = function normalizedListener(...args) {
+        this.removeEventListener(type, listener, options);
+        return typeof listener === 'object' ? listener.handleEvent(...args) : listener.call(this, ...args);
+      };
+      let onceListeners = this[ONCE_LISTENERS];
+      if (!onceListeners) {
+        onceListeners = new WeakMap();
+        this[ONCE_LISTENERS] = onceListeners;
+      }
+      onceListeners.set(listener, normalizedListener);
+    }
+    let listeners = this[constants.LISTENERS];
+    if (!listeners) {
+      listeners = new Map();
+      this[constants.LISTENERS] = listeners;
+    }
+    let list = listeners.get(key);
+    if (!list) {
+      list = new Set();
+      listeners.set(key, list);
+    }
+    list.add(normalizedListener);
+    signal?.addEventListener('abort', () => {
+      removeEventListener.call(this, type, listener, options);
+    }, {
+      once: true
+    });
+    hooks.hooks.addEventListener?.(this, type, listener, options);
+  }
+  removeEventListener(type, listener, options) {
+    return removeEventListener.call(this, type, listener, options);
+  }
+
+  // function isChildNode(node: EventTarget): node is ChildNode {
+  //   return PARENT in node;
+  // }
+
+  dispatchEvent(event) {
+    const path = [];
+    // instanceof here is just to keep TypeScript happy
+    let target = this;
+    while (target != null) {
+      path.push(target);
+      target = target.parentNode;
+    }
+    // while (target instanceof Node && (target = target.parentNode)) {
+    //   path.push(target);
+    // }
+    event.target = this;
+    event.srcElement = this;
+    event.path = path;
+    let defaultPrevented = false;
+    for (let i = path.length; --i;) {
+      if (Event.fireEvent(event, path[i], Event.EventPhase.CAPTURING_PHASE)) {
+        defaultPrevented = true;
+      }
+    }
+    if (Event.fireEvent(event, this, Event.EventPhase.AT_TARGET)) {
+      defaultPrevented = true;
+    }
+    for (let i = 1; i < path.length; i++) {
+      if (Event.fireEvent(event, path[i], Event.EventPhase.BUBBLING_PHASE)) {
+        defaultPrevented = true;
+      }
+    }
+    return !defaultPrevented;
+  }
+}
+function removeEventListener(type, listener, options) {
+  if (listener == null) return;
+  const onceListeners = this[ONCE_LISTENERS];
+  const normalizedListener = onceListeners?.get(listener) ?? listener;
+  onceListeners?.delete(listener);
+  const capture = options === true || options && options.capture === true;
+  const key = `${type}${capture ? Event.CAPTURE_MARKER : ''}`;
+  const list = this[constants.LISTENERS]?.get(key);
+  if (list) {
+    const deleted = list.delete(normalizedListener);
+    if (deleted) {
+      hooks.hooks.removeEventListener?.(this, type, listener, options);
+    }
+  }
+}
+
+exports.EventTarget = EventTarget;

package/build/cjs/HTMLElement.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var Element = require('./Element.cjs');
+
+class HTMLElement extends Element.Element {}
+
+exports.HTMLElement = HTMLElement;