@remote-dom/polyfill 1.0.6 → 1.2.0

package/build/cjs/selectors.cjs

@@ -0,0 +1,203 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const constants = require('./constants.cjs');
+const shared = require('./shared.cjs');
+
+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[constants.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[constants.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 (shared.isElementNode(node)) {
+    if (matchesSelectorRecursive(node, parts)) {
+      if (callback(node) === false) return false;
+    }
+    const child = node[constants.CHILD];
+    if (child && walkNodesForSelector(child, parts, callback) === false) {
+      return false;
+    }
+  }
+  const next = node[constants.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 ? constants.PARENT : constants.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 ? constants.PARENT : constants.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;
+}
+
+exports.parseSelector = parseSelector;
+exports.querySelector = querySelector;
+exports.querySelectorAll = querySelectorAll;

package/build/cjs/serialization.cjs

@@ -0,0 +1,99 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const constants = require('./constants.cjs');
+
+// 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[constants.CHILD];
+  while (child) {
+    out += serializeNode(child);
+    child = child[constants.NEXT];
+  }
+  return out;
+}
+function serializeNode(node) {
+  switch (node.nodeType) {
+    case constants.NodeType.ELEMENT_NODE:
+      {
+        const el = node;
+        let out = `<${el[constants.NAME]}`;
+        let attr = el[constants.ATTRIBUTES]?.[constants.CHILD];
+        while (attr) {
+          out += ` ${attr[constants.NAME]}`;
+          let value = attr[constants.VALUE];
+          if (value !== '') {
+            value = String(value).replace(/&/g, '&amp;').replace(/"/g, '&quot;');
+            out += `="${value}"`;
+          }
+          attr = attr[constants.NEXT];
+        }
+        out += '>';
+        out += serializeChildren(el);
+        // let child = el[CHILD];
+        // while (child) {
+        //   out += serialize(child);
+        //   child = child[NEXT];
+        // }
+        out += `</${el[constants.NAME]}>`;
+        return out;
+      }
+    case constants.NodeType.TEXT_NODE:
+      {
+        const text = node;
+        return text[constants.DATA].replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+      }
+    case constants.NodeType.COMMENT_NODE:
+      {
+        const text = node;
+        return `<!--${text[constants.DATA]}-->`;
+      }
+  }
+  return '';
+}
+
+exports.parseHtml = parseHtml;
+exports.serializeChildren = serializeChildren;
+exports.serializeNode = serializeNode;

package/build/cjs/shared.cjs

@@ -0,0 +1,65 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const constants = require('./constants.cjs');
+
+function isCharacterData(node) {
+  return constants.DATA in node;
+}
+function isTextNode(node) {
+  return node.nodeType === constants.NodeType.TEXT_NODE;
+}
+function isCommentNode(node) {
+  return node.nodeType === constants.NodeType.COMMENT_NODE;
+}
+function isElementNode(node) {
+  return node.nodeType === constants.NodeType.ELEMENT_NODE;
+}
+function isDocumentFragmentNode(node) {
+  return node.nodeType === constants.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[constants.ATTRIBUTES]) {
+      for (let i = 0; i < node[constants.ATTRIBUTES].length; i++) {
+        const attribute = node[constants.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[constants.OWNER_DOCUMENT] = document;
+    return cloned;
+  }
+}
+
+exports.cloneNode = cloneNode;
+exports.isCharacterData = isCharacterData;
+exports.isCommentNode = isCommentNode;
+exports.isDocumentFragmentNode = isDocumentFragmentNode;
+exports.isElementNode = isElementNode;
+exports.isParentNode = isParentNode;
+exports.isTextNode = isTextNode;

package/build/esm/Attr.mjs

@@ -1,5 +1,4 @@
-import { hooks } from './hooks.mjs';
-import { NodeType, NS, NEXT, OWNER_ELEMENT, NAME, VALUE } from './constants.mjs';
+import { NodeType, NS, NEXT, OWNER_ELEMENT, NAME, VALUE, HOOKS } from './constants.mjs';
 import { Node } from './Node.mjs';
 
 class Attr extends Node {
@@ -30,7 +29,7 @@ class Attr extends Node {
     this[VALUE] = str;
     const ownerElement = this[OWNER_ELEMENT];
     if (!ownerElement) return;
-    hooks.setAttribute?.(ownerElement, this[NAME], str, this[NS]);
+    this[HOOKS].setAttribute?.(ownerElement, this[NAME], str, this[NS]);
   }
   get nodeValue() {
     return this.value;

package/build/esm/CharacterData.mjs

@@ -1,12 +1,11 @@
-import { hooks } from './hooks.mjs';
-import { DATA } from './constants.mjs';
+import { DATA, HOOKS } from './constants.mjs';
 import { ChildNode } from './ChildNode.mjs';
 
 class CharacterData extends ChildNode {
   [DATA] = '';
   constructor(data) {
     super();
-    this.setData(data);
+    this[DATA] = data == null ? '' : String(data);
   }
   setData(data) {
     let str = '';
@@ -14,7 +13,7 @@ class CharacterData extends ChildNode {
       str = typeof data === 'string' ? data : String(data);
     }
     this[DATA] = str;
-    hooks.setText?.(this, str);
+    this[HOOKS].setText?.(this, str);
   }
   get data() {
     return this[DATA];

package/build/esm/Document.mjs

@@ -1,5 +1,4 @@
-import { hooks } from './hooks.mjs';
-import { NodeType, NAME, OWNER_DOCUMENT, NamespaceURI, NS } from './constants.mjs';
+import { NodeType, NAME, OWNER_DOCUMENT, NamespaceURI, NS, HOOKS } from './constants.mjs';
 import { Event } from './Event.mjs';
 import { ParentNode } from './ParentNode.mjs';
 import { Element } from './Element.mjs';
@@ -85,7 +84,7 @@ function setupElement(element, ownerDocument, name, namespace) {
       value: namespace
     });
   }
-  hooks.createElement?.(element, namespace);
+  ownerDocument[HOOKS].createElement?.(element, namespace);
   return element;
 }
 function adoptNode(node, document) {

package/build/esm/EventTarget.mjs

@@ -1,9 +1,13 @@
-import { hooks } from './hooks.mjs';
-import { LISTENERS } from './constants.mjs';
+import { LISTENERS, OWNER_DOCUMENT, HOOKS } from './constants.mjs';
 import { fireEvent, CAPTURE_MARKER, EventPhase } from './Event.mjs';
 
 const ONCE_LISTENERS = Symbol('onceListeners');
 class EventTarget {
+  /**
+   * Property set by entities that extend this class that are part of the DOM tree.
+   * @internal
+   */
+
   addEventListener(type, listener, options) {
     if (listener == null) return;
     const capture = options === true || options && options.capture === true;
@@ -40,7 +44,7 @@ class EventTarget {
       once: true
     });
     list.add(normalizedListener);
-    hooks.addEventListener?.(this, type, listener, options);
+    this[OWNER_DOCUMENT]?.defaultView[HOOKS].addEventListener?.(this, type, listener, options);
   }
   removeEventListener(type, listener, options) {
     return removeEventListener.call(this, type, listener, options);
@@ -92,7 +96,7 @@ function removeEventListener(type, listener, options) {
   if (list) {
     const deleted = list.delete(normalizedListener);
     if (deleted) {
-      hooks.removeEventListener?.(this, type, listener, options);
+      this[OWNER_DOCUMENT]?.defaultView[HOOKS].removeEventListener?.(this, type, listener, options);
     }
   }
 }

package/build/esm/NamedNodeMap.mjs

@@ -1,5 +1,4 @@
-import { hooks } from './hooks.mjs';
-import { CHILD, OWNER_ELEMENT, NS, NEXT } from './constants.mjs';
+import { CHILD, OWNER_ELEMENT, NS, NEXT, HOOKS } from './constants.mjs';
 
 class NamedNodeMap {
   [CHILD] = null;
@@ -49,7 +48,7 @@ class NamedNodeMap {
         if (prev) prev[NEXT] = attr[NEXT];
         if (this[CHILD] === attr) this[CHILD] = attr[NEXT];
         updateElementAttribute(ownerElement, attr.name, attr.value, null);
-        hooks.removeAttribute?.(ownerElement, name, namespaceURI);
+        ownerElement[HOOKS].removeAttribute?.(ownerElement, name, namespaceURI);
         return attr;
       }
       prev = attr;
@@ -86,7 +85,7 @@ class NamedNodeMap {
     // only invoke the protocol if the value changed
     if (!old || old.value !== attr.value) {
       updateElementAttribute(ownerElement, attr.name, old?.value ?? null, attr.value);
-      hooks.setAttribute?.(ownerElement, attr.name, attr.value, attr[NS]);
+      ownerElement[HOOKS].setAttribute?.(ownerElement, attr.name, attr.value, attr[NS]);
     }
     return old;
   }

package/build/esm/Node.mjs

@@ -1,4 +1,4 @@
-import { NodeType, NAME, PARENT, CHILD, PREV, NEXT, OWNER_DOCUMENT, NamespaceURI } from './constants.mjs';
+import { NodeType, NAME, PARENT, CHILD, PREV, NEXT, HOOKS, OWNER_DOCUMENT, NamespaceURI } from './constants.mjs';
 import { EventTarget } from './EventTarget.mjs';
 import { isCharacterData, isParentNode, cloneNode, isTextNode } from './shared.mjs';
 
@@ -9,6 +9,9 @@ class Node extends EventTarget {
   [CHILD] = null;
   [PREV] = null;
   [NEXT] = null;
+  get [HOOKS]() {
+    return this[OWNER_DOCUMENT].defaultView[HOOKS];
+  }
   get localName() {
     return this[NAME];
   }

package/build/esm/ParentNode.mjs

@@ -1,5 +1,4 @@
-import { hooks } from './hooks.mjs';
-import { PREV, NEXT, CHILD, NodeType, OWNER_DOCUMENT, PARENT } from './constants.mjs';
+import { PREV, NEXT, CHILD, HOOKS, NodeType, OWNER_DOCUMENT, PARENT } from './constants.mjs';
 import { ChildNode, toNode } from './ChildNode.mjs';
 import { NodeList } from './NodeList.mjs';
 import { querySelectorAll, querySelector } from './selectors.mjs';
@@ -46,7 +45,7 @@ class ParentNode extends ChildNode {
       const children = this.children;
       children.splice(children.indexOf(child), 1);
     }
-    hooks.removeChild?.(this, child, childNodesIndex);
+    this[HOOKS].removeChild?.(this, child, childNodesIndex);
   }
   replaceChild(newChild, oldChild) {
     if (oldChild.parentNode !== this) {
@@ -121,7 +120,7 @@ class ParentNode extends ChildNode {
       childNodes.push(child);
       if (isElement) this.children.push(child);
     }
-    hooks.insertChild?.(this, child, insertIndex);
+    this[HOOKS].insertChild?.(this, child, insertIndex);
   }
 }
 

package/build/esm/Window.mjs

@@ -15,8 +15,10 @@ import { DocumentFragment } from './DocumentFragment.mjs';
 import { HTMLTemplateElement } from './HTMLTemplateElement.mjs';
 import { CustomElementRegistryImplementation } from './CustomElementRegistry.mjs';
 import { MutationObserver } from './MutationObserver.mjs';
+import { HOOKS } from './constants.mjs';
 
 class Window extends EventTarget {
+  [HOOKS] = {};
   name = '';
   parent = this;
   self = this;

package/build/esm/constants.mjs

@@ -13,6 +13,7 @@ const LISTENERS = Symbol('listeners');
 const IS_TRUSTED = Symbol('isTrusted');
 const CONTENT = Symbol('content');
 const SLOT = Symbol('slot');
+const HOOKS = Symbol('hooks');
 
 // @TODO remove explicit values
 let NodeType = /*#__PURE__*/function (NodeType) {
@@ -36,4 +37,4 @@ let NamespaceURI = /*#__PURE__*/function (NamespaceURI) {
   return NamespaceURI;
 }({});
 
-export { ATTRIBUTES, CHILD, CONTENT, DATA, IS_TRUSTED, LISTENERS, NAME, NEXT, NS, NamespaceURI, NodeType, OWNER_DOCUMENT, OWNER_ELEMENT, PARENT, PREV, SLOT, VALUE };
+export { ATTRIBUTES, CHILD, CONTENT, DATA, HOOKS, IS_TRUSTED, LISTENERS, NAME, NEXT, NS, NamespaceURI, NodeType, OWNER_DOCUMENT, OWNER_ELEMENT, PARENT, PREV, SLOT, VALUE };

package/build/esm/index.mjs

@@ -1,2 +1,3 @@
-export { hooks } from './hooks.mjs';
+export { HOOKS } from './constants.mjs';
 export { Window } from './Window.mjs';
+export { HTMLElement } from './HTMLElement.mjs';

package/build/esnext/Attr.esnext

@@ -1,5 +1,4 @@
-import { hooks } from './hooks.esnext';
-import { NodeType, NS, NEXT, VALUE, OWNER_ELEMENT, NAME } from './constants.esnext';
+import { NodeType, NS, NEXT, VALUE, OWNER_ELEMENT, NAME, HOOKS } from './constants.esnext';
 import { Node } from './Node.esnext';
 
 class Attr extends Node {
@@ -33,7 +32,7 @@ class Attr extends Node {
     this[VALUE] = str;
     const ownerElement = this[OWNER_ELEMENT];
     if (!ownerElement) return;
-    hooks.setAttribute?.(ownerElement, this[NAME], str, this[NS]);
+    this[HOOKS].setAttribute?.(ownerElement, this[NAME], str, this[NS]);
   }
   get nodeValue() {
     return this.value;

package/build/esnext/CharacterData.esnext

@@ -1,12 +1,11 @@
-import { hooks } from './hooks.esnext';
-import { DATA } from './constants.esnext';
+import { DATA, HOOKS } from './constants.esnext';
 import { ChildNode } from './ChildNode.esnext';
 
 class CharacterData extends ChildNode {
   [DATA] = "";
   constructor(data) {
     super();
-    this.setData(data);
+    this[DATA] = data == null ? "" : String(data);
   }
   setData(data) {
     let str = "";
@@ -14,7 +13,7 @@ class CharacterData extends ChildNode {
       str = typeof data === "string" ? data : String(data);
     }
     this[DATA] = str;
-    hooks.setText?.(this, str);
+    this[HOOKS].setText?.(this, str);
   }
   get data() {
     return this[DATA];

package/build/esnext/Document.esnext

@@ -1,5 +1,4 @@
-import { hooks } from './hooks.esnext';
-import { NodeType, NAME, OWNER_DOCUMENT, NamespaceURI, NS } from './constants.esnext';
+import { NodeType, NAME, OWNER_DOCUMENT, NamespaceURI, NS, HOOKS } from './constants.esnext';
 import { Event } from './Event.esnext';
 import { ParentNode } from './ParentNode.esnext';
 import { Element } from './Element.esnext';
@@ -85,7 +84,7 @@ function setupElement(element, ownerDocument, name, namespace) {
   if (namespace) {
     Object.defineProperty(element, NS, { value: namespace });
   }
-  hooks.createElement?.(element, namespace);
+  ownerDocument[HOOKS].createElement?.(element, namespace);
   return element;
 }
 function adoptNode(node, document) {

package/build/esnext/EventTarget.esnext

@@ -1,11 +1,15 @@
-import { hooks } from './hooks.esnext';
-import { LISTENERS } from './constants.esnext';
+import { LISTENERS, OWNER_DOCUMENT, HOOKS } from './constants.esnext';
 import { fireEvent, EventPhase, CAPTURE_MARKER } from './Event.esnext';
 
 const ONCE_LISTENERS = Symbol("onceListeners");
 class EventTarget {
   [LISTENERS];
   [ONCE_LISTENERS];
+  /**
+   * Property set by entities that extend this class that are part of the DOM tree.
+   * @internal
+   */
+  [OWNER_DOCUMENT];
   addEventListener(type, listener, options) {
     if (listener == null) return;
     const capture = options === true || options && options.capture === true;
@@ -44,7 +48,12 @@ class EventTarget {
       { once: true }
     );
     list.add(normalizedListener);
-    hooks.addEventListener?.(this, type, listener, options);
+    this[OWNER_DOCUMENT]?.defaultView[HOOKS].addEventListener?.(
+      this,
+      type,
+      listener,
+      options
+    );
   }
   removeEventListener(type, listener, options) {
     return removeEventListener.call(this, type, listener, options);
@@ -90,7 +99,12 @@ function removeEventListener(type, listener, options) {
   if (list) {
     const deleted = list.delete(normalizedListener);
     if (deleted) {
-      hooks.removeEventListener?.(this, type, listener, options);
+      this[OWNER_DOCUMENT]?.defaultView[HOOKS].removeEventListener?.(
+        this,
+        type,
+        listener,
+        options
+      );
     }
   }
 }