@remote-dom/polyfill 0.0.1

package/build/esm/SVGElement.mjs

@@ -0,0 +1,17 @@
+import { NS, NamespaceURI } from './constants.mjs';
+import { Element } from './Element.mjs';
+
+class SVGElement extends Element {
+  [NS] = NamespaceURI.SVG;
+  get ownerSVGElement() {
+    let root = null;
+    let parent = this.parentNode;
+    while (parent instanceof SVGElement) {
+      root = parent;
+      parent = parent.parentNode;
+    }
+    return root;
+  }
+}
+
+export { SVGElement };

package/build/esm/Text.mjs

@@ -0,0 +1,9 @@
+import { NodeType, NAME } from './constants.mjs';
+import { CharacterData } from './CharacterData.mjs';
+
+class Text extends CharacterData {
+  nodeType = NodeType.TEXT_NODE;
+  [NAME] = '#text';
+}
+
+export { Text };

package/build/esm/Window.mjs

@@ -0,0 +1,66 @@
+import { Document } from './Document.mjs';
+import { Event } from './Event.mjs';
+import { EventTarget } from './EventTarget.mjs';
+import { CustomEvent } from './CustomEvent.mjs';
+import { Node } from './Node.mjs';
+import { ParentNode } from './ParentNode.mjs';
+import { ChildNode } from './ChildNode.mjs';
+import { Element } from './Element.mjs';
+import { HTMLElement } from './HTMLElement.mjs';
+import { SVGElement } from './SVGElement.mjs';
+import { CharacterData } from './CharacterData.mjs';
+import { Text } from './Text.mjs';
+import { Comment } from './Comment.mjs';
+import { DocumentFragment } from './DocumentFragment.mjs';
+import { HTMLTemplateElement } from './HTMLTemplateElement.mjs';
+import { CustomElementRegistryImplementation } from './CustomElementRegistry.mjs';
+import { MutationObserver } from './MutationObserver.mjs';
+
+class Window extends EventTarget {
+  name = '';
+  parent = this;
+  self = this;
+  top = this;
+  document = new Document(this);
+  customElements = new CustomElementRegistryImplementation();
+  location = globalThis.location;
+  navigator = globalThis.navigator;
+  Event = Event;
+  EventTarget = EventTarget;
+  CustomEvent = CustomEvent;
+  Node = Node;
+  ParentNode = ParentNode;
+  ChildNode = ChildNode;
+  DocumentFragment = DocumentFragment;
+  Document = Document;
+  CharacterData = CharacterData;
+  Comment = Comment;
+  Text = Text;
+  Element = Element;
+  HTMLElement = HTMLElement;
+  SVGElement = SVGElement;
+  HTMLTemplateElement = HTMLTemplateElement;
+  MutationObserver = MutationObserver;
+  static setGlobal(window) {
+    const properties = Object.getOwnPropertyDescriptors(window);
+    delete properties.self;
+    Object.defineProperties(globalThis, {
+      ...properties,
+      window: {
+        value: window
+      }
+    });
+    if (typeof self === 'undefined') {
+      Object.defineProperty(globalThis, 'self', {
+        value: window
+      });
+    } else {
+      // There can already be a `self`, like when polyfilling the DOM
+      // in a Web Worker. In those cases, just mirror all the `Window`
+      // properties onto `self`, rather than wholly redefining it.
+      Object.defineProperties(self, properties);
+    }
+  }
+}
+
+export { Window };

package/build/esm/constants.mjs

@@ -0,0 +1,39 @@
+const NAME = Symbol('name');
+const VALUE = Symbol('value');
+const NS = Symbol('ns');
+const OWNER_ELEMENT = Symbol('owner');
+const OWNER_DOCUMENT = Symbol('owner_document');
+const ATTRIBUTES = Symbol('attributes');
+const PREV = Symbol('prev');
+const NEXT = Symbol('next');
+const CHILD = Symbol('child');
+const PARENT = Symbol('parent');
+const DATA = Symbol('data');
+const LISTENERS = Symbol('listeners');
+const IS_TRUSTED = Symbol('isTrusted');
+const CONTENT = Symbol('content');
+const SLOT = Symbol('slot');
+
+// @TODO remove explicit values
+let NodeType = /*#__PURE__*/function (NodeType) {
+  NodeType[NodeType["NODE"] = 0] = "NODE";
+  NodeType[NodeType["ELEMENT_NODE"] = 1] = "ELEMENT_NODE";
+  NodeType[NodeType["ATTRIBUTE_NODE"] = 2] = "ATTRIBUTE_NODE";
+  NodeType[NodeType["TEXT_NODE"] = 3] = "TEXT_NODE";
+  NodeType[NodeType["CDATA_SECTION_NODE"] = 4] = "CDATA_SECTION_NODE";
+  NodeType[NodeType["ENTITY_REFERENCE_NODE"] = 5] = "ENTITY_REFERENCE_NODE";
+  NodeType[NodeType["ENTITY_NODE"] = 6] = "ENTITY_NODE";
+  NodeType[NodeType["PROCESSING_INSTRUCTION_NODE"] = 7] = "PROCESSING_INSTRUCTION_NODE";
+  NodeType[NodeType["COMMENT_NODE"] = 8] = "COMMENT_NODE";
+  NodeType[NodeType["DOCUMENT_NODE"] = 9] = "DOCUMENT_NODE";
+  NodeType[NodeType["DOCUMENT_TYPE_NODE"] = 10] = "DOCUMENT_TYPE_NODE";
+  NodeType[NodeType["DOCUMENT_FRAGMENT_NODE"] = 11] = "DOCUMENT_FRAGMENT_NODE";
+  return NodeType;
+}({});
+let NamespaceURI = /*#__PURE__*/function (NamespaceURI) {
+  NamespaceURI["XHTML"] = "http://www.w3.org/1999/xhtml";
+  NamespaceURI["SVG"] = "http://www.w3.org/2000/svg";
+  return NamespaceURI;
+}({});
+
+export { ATTRIBUTES, CHILD, CONTENT, DATA, IS_TRUSTED, LISTENERS, NAME, NEXT, NS, NamespaceURI, NodeType, OWNER_DOCUMENT, OWNER_ELEMENT, PARENT, PREV, SLOT, VALUE };

package/build/esm/hooks.mjs

@@ -0,0 +1,3 @@
+const hooks = {};
+
+export { hooks };

package/build/esm/index.mjs

@@ -0,0 +1,2 @@
+export { hooks } from './hooks.mjs';
+export { Window } from './Window.mjs';

package/build/esm/selectors.mjs

@@ -0,0 +1,197 @@
+import { CHILD, NEXT, PARENT, PREV } from './constants.mjs';
+import { isElementNode } from './shared.mjs';
+
+var Combinator = /*#__PURE__*/function (Combinator) {
+  Combinator[Combinator["Descendant"] = 0] = "Descendant";
+  Combinator[Combinator["Child"] = 1] = "Child";
+  Combinator[Combinator["Sibling"] = 2] = "Sibling";
+  Combinator[Combinator["Adjacent"] = 3] = "Adjacent";
+  Combinator[Combinator["Inner"] = 4] = "Inner";
+  return Combinator;
+}(Combinator || {});
+var MatcherType = /*#__PURE__*/function (MatcherType) {
+  MatcherType[MatcherType["Unknown"] = 0] = "Unknown";
+  MatcherType[MatcherType["Element"] = 1] = "Element";
+  MatcherType[MatcherType["Id"] = 2] = "Id";
+  MatcherType[MatcherType["Class"] = 3] = "Class";
+  MatcherType[MatcherType["Attribute"] = 4] = "Attribute";
+  MatcherType[MatcherType["Pseudo"] = 5] = "Pseudo";
+  MatcherType[MatcherType["Function"] = 6] = "Function";
+  return MatcherType;
+}(MatcherType || {});
+const ELEMENT_SELECTOR_TEST = /[a-z]/;
+function querySelector(within, selector) {
+  const parts = parseSelector(selector);
+  let result = null;
+  const child = within[CHILD];
+  if (child && parts[0].matchers.length) {
+    walkNodesForSelector(child, parts, node => {
+      result = node;
+      return false;
+    });
+  }
+  return result;
+}
+function querySelectorAll(within, selector) {
+  const parts = parseSelector(selector);
+  const results = [];
+  const child = within[CHILD];
+  if (child && parts[0].matchers.length) {
+    walkNodesForSelector(child, parts, node => {
+      results.push(node);
+    });
+  }
+  return results;
+}
+function parseSelector(selector) {
+  let part = {
+    combinator: Combinator.Inner,
+    matchers: []
+  };
+  const parts = [part];
+  const tokenizer = /\s*?([>\s+~]?)\s*?(?:(?:\[\s*([^\]=]+)(?:=(['"])(.*?)\3)?\s*\])|([#.]?)([^\s#.[>:]+)|:(\w+)(?:\((.*?)\))?)/gi;
+  let token;
+  while (token = tokenizer.exec(selector)) {
+    // [1]: ancestor/parent/sibling/adjacent
+    // [2]: attribute name
+    // [4]: attribute value
+    // [5]: id/class sigil
+    // [6]: id/class name
+    // [7]: :pseudo/:function() name
+    // [8]: :function(argument) value
+    if (token[1]) {
+      // Update the combinator on the (now parent) Part:
+      if (token[1] === '>') part.combinator = Combinator.Child;else if (token[1] === '+') part.combinator = Combinator.Adjacent;else if (token[1] === '~') part.combinator = Combinator.Sibling;else part.combinator = Combinator.Descendant;
+      // Add a new Part for the next selector parts:
+      part = {
+        combinator: Combinator.Inner,
+        matchers: []
+      };
+      parts.push(part);
+    }
+    let type = MatcherType.Unknown;
+    if (token[2]) {
+      type = MatcherType.Attribute;
+    } else if (token[5]) {
+      type = token[5] === '#' ? MatcherType.Id : MatcherType.Class;
+    } else if (token[7]) {
+      type = token[8] == null ? MatcherType.Pseudo : MatcherType.Function;
+    } else if (token[6] && ELEMENT_SELECTOR_TEST.test(token[6])) {
+      type = MatcherType.Element;
+    }
+    part.matchers.push({
+      type,
+      name: token[2] || token[6] || token[7],
+      value: token[4] ?? token[6] ?? token[8]
+    });
+  }
+  return parts;
+}
+function matchesSelector(element, selector) {
+  const parsed = parseSelector(selector);
+  let part;
+  while (part = parsed.pop()) {
+    if (!matchesSelectorPart(element, part)) return false;
+  }
+  return true;
+}
+function walkNodesForSelector(node, parts, callback) {
+  if (isElementNode(node)) {
+    if (matchesSelectorRecursive(node, parts)) {
+      if (callback(node) === false) return false;
+    }
+    const child = node[CHILD];
+    if (child && walkNodesForSelector(child, parts, callback) === false) {
+      return false;
+    }
+  }
+  const next = node[NEXT];
+  if (next && walkNodesForSelector(next, parts, callback) === false) {
+    return false;
+  }
+  return true;
+}
+function matchesSelectorRecursive(element, parts) {
+  const {
+    combinator,
+    matchers
+  } = parts[parts.length - 1];
+  if (combinator === Combinator.Inner) {
+    if (!matchesSelectorMatcher(element, matchers)) return false;
+    const pp = parts.slice(0, -1);
+    return pp.length === 0 || matchesSelectorRecursive(element, pp);
+  }
+  const link = combinator === Combinator.Child || combinator === Combinator.Descendant ? PARENT : PREV;
+  let ref = element[link];
+  if (!ref || !matchesSelectorMatcher(ref, matchers)) {
+    return false;
+  }
+  if (combinator === Combinator.Descendant || combinator === Combinator.Sibling) {
+    while (ref = ref[link]) {
+      if (matchesSelectorMatcher(ref, matchers)) {
+        const pp = parts.slice(0, -1);
+        if (pp.length === 0) return true;
+        if (matchesSelectorRecursive(element, pp)) return true;
+      }
+    }
+  }
+  return false;
+}
+function matchesSelectorPart(element, {
+  combinator,
+  matchers
+}) {
+  if (combinator === Combinator.Inner) {
+    return matchesSelectorMatcher(element, matchers);
+  }
+  const link = combinator === Combinator.Child || combinator === Combinator.Descendant ? PARENT : PREV;
+  let ref = element[link];
+  if (!ref || !matchesSelectorMatcher(ref, matchers)) {
+    return false;
+  }
+  if (combinator === Combinator.Descendant || combinator === Combinator.Sibling) {
+    while (ref = ref[link]) {
+      if (matchesSelectorMatcher(ref, matchers)) return true;
+    }
+  }
+  return false;
+}
+function matchesSelectorMatcher(element, matcher) {
+  if (!element) return false;
+  if (Array.isArray(matcher)) {
+    for (const single of matcher) {
+      if (matchesSelectorMatcher(element, single) === false) return false;
+    }
+    return true;
+  }
+  const {
+    type,
+    name,
+    value
+  } = matcher;
+  switch (type) {
+    case MatcherType.Element:
+      return element.localName === name;
+    case MatcherType.Id:
+      return element.getAttribute('id') === name;
+    case MatcherType.Class:
+      return element.getAttribute('class') === name;
+    case MatcherType.Attribute:
+      return value == null ? element.hasAttribute(name) : element.getAttribute(name) === value;
+    case MatcherType.Pseudo:
+      switch (name) {
+        default:
+          throw Error(`Pseudo :${name} not implemented`);
+      }
+    case MatcherType.Function:
+      switch (name) {
+        case 'has':
+          return matchesSelector(element, value || '');
+        default:
+          throw Error(`Function :${name}(${value}) not implemented`);
+      }
+  }
+  return false;
+}
+
+export { parseSelector, querySelector, querySelectorAll };

package/build/esm/serialization.mjs

@@ -0,0 +1,92 @@
+import { CHILD, NEXT, NodeType, DATA, NAME, ATTRIBUTES, VALUE } from './constants.mjs';
+
+// const voidElements = {
+//   img: true,
+//   image: true,
+// };
+// const elementTokenizer =
+//   /(?:<([a-z][a-z0-9-:]*)( [^<>'"\n=\s]+=(['"])[^>'"\n]*\3)*\s*(\/?)\s*>|<\/([a-z][a-z0-9-:]*)>|([^&<>]+))/gi;
+// const attributeTokenizer = / ([^<>'"\n=\s]+)=(['"])([^>'"\n]*)\2/g;
+const elementTokenizer = /(?:<([a-z][a-z0-9-:]*)((?:\s[^<>'"=\n\s]+(?:=(['"])[^\n]*?\3|=[^>'"\n\s]*|))*)\s*(\/?)\s*>|<\/([a-z][a-z0-9-:]*)>|<!--(.*?)-->|([^&<>]+))/gi;
+const attributeTokenizer = /\s([^<>'"=\n\s]+)(?:=(['"])([^\n]*?)\2|=([^>'"\n\s]*)|)/g;
+function parseHtml(html, contextNode) {
+  const document = contextNode.ownerDocument;
+  const root = document.createDocumentFragment();
+  const stack = [root];
+  let parent = root;
+  let token;
+  elementTokenizer.lastIndex = 0;
+  while (token = elementTokenizer.exec(html)) {
+    const tag = token[1];
+    if (tag) {
+      const node = document.createElement(tag);
+      const attrs = token[2];
+      attributeTokenizer.lastIndex = 0;
+      let t;
+      while (t = attributeTokenizer.exec(attrs)) {
+        node.setAttribute(t[1], t[3] || t[4] || '');
+      }
+      parent.append(node);
+      // if (voidElements[tag] === true) continue;
+      stack.push(parent);
+      parent = node;
+    } else if (token[5]) {
+      parent = stack.pop() || root;
+    } else if (token[6]) {
+      parent.append(document.createComment(token[6]));
+    } else {
+      parent.append(token[7]);
+    }
+  }
+  return root;
+}
+function serializeChildren(parentNode) {
+  let out = '';
+  let child = parentNode[CHILD];
+  while (child) {
+    out += serializeNode(child);
+    child = child[NEXT];
+  }
+  return out;
+}
+function serializeNode(node) {
+  switch (node.nodeType) {
+    case NodeType.ELEMENT_NODE:
+      {
+        const el = node;
+        let out = `<${el[NAME]}`;
+        let attr = el[ATTRIBUTES]?.[CHILD];
+        while (attr) {
+          out += ` ${attr[NAME]}`;
+          let value = attr[VALUE];
+          if (value !== '') {
+            value = String(value).replace(/&/g, '&amp;').replace(/"/g, '&quot;');
+            out += `="${value}"`;
+          }
+          attr = attr[NEXT];
+        }
+        out += '>';
+        out += serializeChildren(el);
+        // let child = el[CHILD];
+        // while (child) {
+        //   out += serialize(child);
+        //   child = child[NEXT];
+        // }
+        out += `</${el[NAME]}>`;
+        return out;
+      }
+    case NodeType.TEXT_NODE:
+      {
+        const text = node;
+        return text[DATA].replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+      }
+    case NodeType.COMMENT_NODE:
+      {
+        const text = node;
+        return `<!--${text[DATA]}-->`;
+      }
+  }
+  return '';
+}
+
+export { parseHtml, serializeChildren, serializeNode };

package/build/esm/shared.mjs

@@ -0,0 +1,55 @@
+import { DATA, ATTRIBUTES, OWNER_DOCUMENT, NodeType } from './constants.mjs';
+
+function isCharacterData(node) {
+  return DATA in node;
+}
+function isTextNode(node) {
+  return node.nodeType === NodeType.TEXT_NODE;
+}
+function isCommentNode(node) {
+  return node.nodeType === NodeType.COMMENT_NODE;
+}
+function isElementNode(node) {
+  return node.nodeType === NodeType.ELEMENT_NODE;
+}
+function isDocumentFragmentNode(node) {
+  return node.nodeType === NodeType.DOCUMENT_FRAGMENT_NODE;
+}
+function isParentNode(node) {
+  return 'appendChild' in node;
+}
+function cloneNode(node, deep, document = node.ownerDocument) {
+  if (isTextNode(node)) {
+    return document.createTextNode(node.data);
+  } else if (isCommentNode(node)) {
+    return document.createComment(node.data);
+  } else if (isElementNode(node)) {
+    const cloned = document.createElement(node.localName);
+    if (node[ATTRIBUTES]) {
+      for (let i = 0; i < node[ATTRIBUTES].length; i++) {
+        const attribute = node[ATTRIBUTES].item(i);
+        cloned.setAttributeNS(attribute.namespaceURI, attribute.name, attribute.value);
+      }
+    }
+    if (deep) {
+      for (const child of node.childNodes) {
+        cloned.appendChild(cloneNode(child, true, document));
+      }
+    }
+    return cloned;
+  } else if (isDocumentFragmentNode(node)) {
+    const fragment = document.createDocumentFragment();
+    if (deep) {
+      for (const child of node.childNodes) {
+        fragment.appendChild(cloneNode(child, true, document));
+      }
+    }
+    return fragment;
+  } else {
+    const cloned = new node.constructor();
+    cloned[OWNER_DOCUMENT] = document;
+    return cloned;
+  }
+}
+
+export { cloneNode, isCharacterData, isCommentNode, isDocumentFragmentNode, isElementNode, isParentNode, isTextNode };

package/build/esnext/Attr.esnext

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

package/build/esnext/CharacterData.esnext

@@ -0,0 +1,27 @@
+import { hooks } from './hooks.esnext';
+import { DATA } from './constants.esnext';
+import { ChildNode } from './ChildNode.esnext';
+
+class CharacterData extends ChildNode {
+  [DATA] = "";
+  constructor(data) {
+    super();
+    this.setData(data);
+  }
+  setData(data) {
+    let str = "";
+    if (data != null) {
+      str = typeof data === "string" ? data : String(data);
+    }
+    this[DATA] = str;
+    hooks.setText?.(this, str);
+  }
+  get data() {
+    return this[DATA];
+  }
+  set data(data) {
+    this.setData(data);
+  }
+}
+
+export { CharacterData };

package/build/esnext/ChildNode.esnext

@@ -0,0 +1,47 @@
+import { NEXT } from './constants.esnext';
+import { Node } from './Node.esnext';
+
+class ChildNode extends 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[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[NEXT];
+    for (const node of nodes) {
+      parent.insertBefore(toNode(parent, node), next);
+    }
+  }
+}
+function toNode(parent, node) {
+  if (node instanceof Node)
+    return node;
+  const ownerDocument = parent.ownerDocument;
+  return ownerDocument.createTextNode(String(node));
+}
+
+export { ChildNode, toNode };

package/build/esnext/Comment.esnext

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

package/build/esnext/CustomElementRegistry.esnext

@@ -0,0 +1,34 @@
+class CustomElementRegistryImplementation {
+  registry = /* @__PURE__ */ new Map();
+  listenersByName = /* @__PURE__ */ 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) {
+  }
+}
+
+export { CustomElementRegistryImplementation };

package/build/esnext/CustomEvent.esnext

@@ -0,0 +1,25 @@
+import { Event } from './Event.esnext';
+
+class CustomEvent extends 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)
+   */
+  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;
+  }
+}
+
+export { CustomEvent };