@remote-dom/polyfill 1.5.1 → 1.6.0

package/build/cjs/Element.cjs

@@ -3,26 +3,45 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const constants = require('./constants.cjs');
+const names = require('./names.cjs');
 const ParentNode = require('./ParentNode.cjs');
 const NamedNodeMap = require('./NamedNodeMap.cjs');
 const Attr = require('./Attr.cjs');
 const serialization = require('./serialization.cjs');
+const shared = require('./shared.cjs');
 
 class Element extends ParentNode.ParentNode {
-  nodeType = (() => constants.NodeType.ELEMENT_NODE)();
-  [constants.NS] = (() => constants.NamespaceURI.XHTML)();
+  nodeType = constants.NODE_TYPE_ELEMENT;
+  [constants.NS] = constants.HTML_NAMESPACE;
+  [constants.PREFIX] = null;
   get namespaceURI() {
     return this[constants.NS];
   }
+  get prefix() {
+    return this[constants.PREFIX];
+  }
+  get localName() {
+    const prefix = this[constants.PREFIX];
+    return prefix == null ? this[constants.NAME] : this[constants.NAME].slice(prefix.length + 1);
+  }
+  get nodeName() {
+    return this[constants.NS] === constants.HTML_NAMESPACE ? constants.asciiUppercase(this[constants.NAME]) : this[constants.NAME];
+  }
   get tagName() {
     return this.nodeName;
   }
+  get id() {
+    return this.getAttributeNS(null, 'id') ?? '';
+  }
+  set id(id) {
+    this.setAttribute('id', String(id));
+  }
   get slot() {
-    return this.getAttribute('slot') ?? '';
+    return this.getAttributeNS(null, 'slot') ?? '';
   }
   set slot(slot) {
     const finalSlot = String(slot);
-    if (this.getAttribute('slot') !== finalSlot) {
+    if (this.getAttributeNS(null, 'slot') !== finalSlot) {
       this.attributes.setNamedItem(new Attr.Attr('slot', finalSlot));
     }
   }
@@ -37,9 +56,15 @@ class Element extends ParentNode.ParentNode {
   getAttributeNames() {
     return [...this.attributes].map(attr => attr.name);
   }
+  getElementsByTagName(qualifiedName) {
+    return shared.getElementsByTagName(this, qualifiedName);
+  }
   get firstElementChild() {
     return this.children[0] ?? null;
   }
+  getElementsByClassName(classNames) {
+    return shared.getElementsByClassName(this, classNames);
+  }
   get lastElementChild() {
     return this.children[this.children.length - 1] ?? null;
   }
@@ -54,10 +79,43 @@ class Element extends ParentNode.ParentNode {
     return sib;
   }
   setAttribute(name, value) {
-    this.attributes.setNamedItem(new Attr.Attr(name, String(value)));
+    const qualifiedName = String(name);
+    const normalizedValue = String(value);
+    names.validateAttributeLocalName(qualifiedName);
+    const normalizedName = this[constants.NS] === constants.HTML_NAMESPACE ? constants.asciiLowercase(qualifiedName) : qualifiedName;
+    const attribute = this.attributes.getNamedItemNS(null, normalizedName);
+    if (attribute) {
+      attribute.value = normalizedValue;
+    } else {
+      this.attributes.setNamedItem(new Attr.Attr(normalizedName, normalizedValue));
+    }
+  }
+  setAttributeNS(namespace, qualifiedName, value) {
+    const normalizedNamespace = names.normalizeNamespace(namespace);
+    const normalizedQualifiedName = String(qualifiedName);
+    const normalizedValue = String(value);
+    const name = names.validateAndExtractQualifiedName(normalizedNamespace, normalizedQualifiedName, 'attribute');
+    const attribute = this.attributes.getNamedItemNS(name.namespace, name.localName);
+    if (attribute) {
+      attribute.value = normalizedValue;
+    } else {
+      this.attributes.setNamedItemNS(new Attr.Attr(name.qualifiedName, normalizedValue, name.namespace));
+    }
   }
-  setAttributeNS(namespace, name, value) {
-    this.attributes.setNamedItemNS(new Attr.Attr(name, String(value), namespace));
+  toggleAttribute(name, force) {
+    const qualifiedName = String(name);
+    names.validateAttributeLocalName(qualifiedName);
+    const normalizedName = this[constants.NS] === constants.HTML_NAMESPACE ? constants.asciiLowercase(qualifiedName) : qualifiedName;
+    const attribute = this.attributes.getNamedItemNS(null, normalizedName);
+    const normalizedForce = force === undefined ? undefined : Boolean(force);
+    if (attribute == null) {
+      if (normalizedForce === false) return false;
+      this.attributes.setNamedItem(new Attr.Attr(normalizedName, ''));
+      return true;
+    }
+    if (normalizedForce === true) return true;
+    this.attributes.removeNamedItemNS(null, normalizedName);
+    return false;
   }
   getAttribute(name) {
     const attr = this.attributes.getNamedItem(name);
@@ -76,7 +134,9 @@ class Element extends ParentNode.ParentNode {
     return attr != null;
   }
   removeAttribute(name) {
-    this.attributes.removeNamedItem(name);
+    const qualifiedName = String(name);
+    const normalizedName = this[constants.NS] === constants.HTML_NAMESPACE ? constants.asciiLowercase(qualifiedName) : qualifiedName;
+    this.attributes.removeNamedItemNS(null, normalizedName);
   }
   removeAttributeNS(namespace, name) {
     this.attributes.removeNamedItemNS(namespace, name);

package/build/cjs/Event.cjs

@@ -4,27 +4,23 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const 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 EVENT_PHASE_NONE = 0;
+const EVENT_PHASE_CAPTURING = 1;
+const EVENT_PHASE_AT_TARGET = 2;
+const EVENT_PHASE_BUBBLING = 3;
 const now = typeof performance === 'undefined' ? Date.now : performance.now.bind(performance);
 class Event {
-  static NONE = (() => EventPhase.NONE)();
-  static CAPTURING_PHASE = (() => EventPhase.CAPTURING_PHASE)();
-  static AT_TARGET = (() => EventPhase.AT_TARGET)();
-  static BUBBLING_PHASE = (() => EventPhase.BUBBLING_PHASE)();
+  static NONE = EVENT_PHASE_NONE;
+  static CAPTURING_PHASE = EVENT_PHASE_CAPTURING;
+  static AT_TARGET = EVENT_PHASE_AT_TARGET;
+  static BUBBLING_PHASE = EVENT_PHASE_BUBBLING;
 
-  // NONE = EventPhase.NONE;
-  // CAPTURING_PHASE = EventPhase.CAPTURING_PHASE;
-  // AT_TARGET = EventPhase.AT_TARGET;
-  // BUBBLING_PHASE = EventPhase.BUBBLING_PHASE;
+  // NONE = EVENT_PHASE_NONE;
+  // CAPTURING_PHASE = EVENT_PHASE_CAPTURING;
+  // AT_TARGET = EVENT_PHASE_AT_TARGET;
+  // BUBBLING_PHASE = EVENT_PHASE_BUBBLING;
 
-  timeStamp = (() => now())();
+  timeStamp = now();
   target = null;
   currentTarget = null;
   srcElement = null;
@@ -33,11 +29,12 @@ class Event {
   composed = false;
   defaultPrevented = false;
   cancelBubble = false;
-  eventPhase = 0;
+  eventPhase = EVENT_PHASE_NONE;
   // private inPassiveListener = false;
 
   [constants.PATH] = [];
   [constants.STOP_IMMEDIATE_PROPAGATION] = false;
+  [constants.DISPATCHING] = false;
   constructor(type, options) {
     this.type = type;
     Object.defineProperty(this, constants.IS_TRUSTED, {
@@ -54,7 +51,7 @@ class Event {
     return this[constants.IS_TRUSTED];
   }
   composedPath() {
-    return this[constants.PATH];
+    return [...this[constants.PATH]];
   }
   stopPropagation() {
     this.cancelBubble = true;
@@ -64,13 +61,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 */
@@ -81,12 +78,15 @@ class Event {
   }
 }
 function fireEvent(event, currentTarget, phase) {
+  if (event.cancelBubble) return;
   const listeners = currentTarget[constants.LISTENERS];
-  const list = listeners?.get(`${event.type}${phase === EventPhase.CAPTURING_PHASE ? CAPTURE_MARKER : ''}`);
+  const list = listeners?.get(event.type)?.[phase === EVENT_PHASE_CAPTURING ? 'capture' : 'bubble'];
   if (!list) return;
-  for (const listener of list) {
-    event.eventPhase = event.target === currentTarget ? EventPhase.AT_TARGET : phase;
+  for (const registration of [...list]) {
+    if (!list.has(registration) || registration.signal?.aborted) continue;
+    event.eventPhase = event.target === currentTarget ? EVENT_PHASE_AT_TARGET : phase;
     event.currentTarget = currentTarget;
+    const listener = registration.normalizedListener;
     try {
       if (typeof listener === 'object') {
         listener.handleEvent(event);
@@ -103,7 +103,9 @@ function thrower(error) {
   throw error;
 }
 
-exports.CAPTURE_MARKER = CAPTURE_MARKER;
+exports.EVENT_PHASE_AT_TARGET = EVENT_PHASE_AT_TARGET;
+exports.EVENT_PHASE_BUBBLING = EVENT_PHASE_BUBBLING;
+exports.EVENT_PHASE_CAPTURING = EVENT_PHASE_CAPTURING;
+exports.EVENT_PHASE_NONE = EVENT_PHASE_NONE;
 exports.Event = Event;
-exports.EventPhase = EventPhase;
 exports.fireEvent = fireEvent;

package/build/cjs/EventTarget.cjs

@@ -3,55 +3,88 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const constants = require('./constants.cjs');
+const domException = require('./dom-exception.cjs');
 const Event = require('./Event.cjs');
 
-const ONCE_LISTENERS = Symbol('onceListeners');
+const LISTENER_REGISTRATIONS = Symbol('listenerRegistrations');
 class EventTarget {
-  [constants.LISTENERS] = (() => undefined)();
-  [ONCE_LISTENERS] = (() => undefined)();
+  [constants.LISTENERS] = undefined;
+  [LISTENER_REGISTRATIONS] = undefined;
 
   /**
    * Property set by entities that extend this class that are part of the DOM tree.
    * @internal
    */
-  [constants.OWNER_DOCUMENT] = (() => undefined)();
+  [constants.OWNER_DOCUMENT] = undefined;
   addEventListener(type, listener, options) {
     if (listener == null) return;
-    const capture = options === true || options && options.capture === true;
+    const capture = options === true || typeof options === 'object' && 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);
+    if (signal?.aborted) return;
+    const phase = listenerPhase(capture);
+    let registrations = this[LISTENER_REGISTRATIONS];
+    if (!registrations) {
+      registrations = new Map();
+      this[LISTENER_REGISTRATIONS] = registrations;
+    }
+    let registrationsForType = registrations.get(type);
+    if (!registrationsForType) {
+      registrationsForType = {};
+      registrations.set(type, registrationsForType);
+    }
+    let registrationsForPhase = registrationsForType[phase];
+    if (!registrationsForPhase) {
+      registrationsForPhase = new Map();
+      registrationsForType[phase] = registrationsForPhase;
+    }
+    if (registrationsForPhase.has(listener)) return;
+    const target = this;
+    const registration = {
+      type,
+      listener,
+      capture,
+      once,
+      normalizedListener: listener,
+      signal
+    };
+    if (once || signal) {
+      registration.normalizedListener = function normalizedListener(...args) {
+        if (registration.signal?.aborted) {
+          removeListenerRegistration(target, registration);
+          return;
+        }
+        if (registration.once) removeListenerRegistration(target, registration);
+        return typeof registration.listener === 'object' ? registration.listener.handleEvent(...args) : registration.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);
+    let listenersForType = listeners.get(type);
+    if (!listenersForType) {
+      listenersForType = {};
+      listeners.set(type, listenersForType);
+    }
+    let list = listenersForType[phase];
     if (!list) {
       list = new Set();
-      listeners.set(key, list);
+      listenersForType[phase] = list;
     }
-    if (list.has(normalizedListener)) return;
-    signal?.addEventListener('abort', () => {
-      removeEventListener.call(this, type, listener, options);
-    }, {
-      once: true
-    });
-    list.add(normalizedListener);
-    this[constants.OWNER_DOCUMENT]?.defaultView[constants.HOOKS].addEventListener?.(this, type, listener, options);
+    registrationsForPhase.set(listener, registration);
+    list.add(registration);
+    if (signal) {
+      const abortListener = () => {
+        removeListenerRegistration(target, registration);
+      };
+      registration.abortListener = abortListener;
+      signal.addEventListener('abort', abortListener, {
+        once: true
+      });
+    }
+    this[constants.OWNER_DOCUMENT]?.defaultView[constants.HOOKS_DISPATCH].addEventListener?.(this, type, listener, options);
   }
   removeEventListener(type, listener, options) {
     return removeEventListener.call(this, type, listener, options);
@@ -62,45 +95,82 @@ class EventTarget {
   // }
 
   dispatchEvent(event) {
-    const path = [];
-    // instanceof here is just to keep TypeScript happy
-    let target = this;
-    while (target != null) {
-      path.push(target);
-      target = target.parentNode;
+    if (event[constants.DISPATCHING]) {
+      throw domException.createDOMException(`Failed to execute 'dispatchEvent' on 'EventTarget': The event is already being dispatched.`, 'InvalidStateError');
     }
-    // while (target instanceof Node && (target = target.parentNode)) {
-    //   path.push(target);
-    // }
-    event.target = this;
-    event.srcElement = this;
-    event[constants.PATH] = path;
-    for (let i = path.length; i--;) {
-      Event.fireEvent(event, path[i], Event.EventPhase.CAPTURING_PHASE);
-      if (event.cancelBubble) return event.defaultPrevented;
-    }
-    const bubblePath = event.bubbles ? path : path.slice(0, 1);
-    for (let i = 0; i < bubblePath.length; i++) {
-      Event.fireEvent(event, bubblePath[i], Event.EventPhase.BUBBLING_PHASE);
-      if (event.cancelBubble) return event.defaultPrevented;
+    event[constants.DISPATCHING] = true;
+    try {
+      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[constants.PATH] = path;
+      for (let i = path.length; i--;) {
+        Event.fireEvent(event, path[i], Event.EVENT_PHASE_CAPTURING);
+        if (event.cancelBubble) return !event.defaultPrevented;
+      }
+      const bubblePath = event.bubbles ? path : path.slice(0, 1);
+      for (let i = 0; i < bubblePath.length; i++) {
+        Event.fireEvent(event, bubblePath[i], Event.EVENT_PHASE_BUBBLING);
+        if (event.cancelBubble) return !event.defaultPrevented;
+      }
+      return !event.defaultPrevented;
+    } finally {
+      event[constants.DISPATCHING] = false;
+      event.cancelBubble = false;
+      event[constants.STOP_IMMEDIATE_PROPAGATION] = false;
+      event.eventPhase = Event.EVENT_PHASE_NONE;
+      event.currentTarget = null;
+      event[constants.PATH] = [];
     }
-    return event.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) {
-      this[constants.OWNER_DOCUMENT]?.defaultView[constants.HOOKS].removeEventListener?.(this, type, listener, options);
-    }
+  const phase = listenerPhase(Boolean(capture));
+  const registration = this[LISTENER_REGISTRATIONS]?.get(type)?.[phase]?.get(listener);
+  if (!registration) return;
+  removeListenerRegistration(this, registration);
+}
+function listenerPhase(capture) {
+  return capture ? 'capture' : 'bubble';
+}
+function removeListenerRegistration(target, registration) {
+  const phase = listenerPhase(registration.capture);
+  const registrations = target[LISTENER_REGISTRATIONS];
+  const registrationsForType = registrations?.get(registration.type);
+  if (!registrationsForType) return;
+  const registrationsForPhase = registrationsForType[phase];
+  if (!registrationsForPhase || registrationsForPhase.get(registration.listener) !== registration) {
+    return;
+  }
+  registrationsForPhase.delete(registration.listener);
+  if (registrationsForPhase.size === 0) delete registrationsForType[phase];
+  if (!registrationsForType.bubble && !registrationsForType.capture) {
+    registrations?.delete(registration.type);
+  }
+  if (registration.signal && registration.abortListener) {
+    registration.signal.removeEventListener('abort', registration.abortListener);
+  }
+  const listeners = target[constants.LISTENERS];
+  const listenersForType = listeners?.get(registration.type);
+  if (!listenersForType) return;
+  const list = listenersForType[phase];
+  if (!list?.delete(registration)) return;
+  if (list.size === 0) delete listenersForType[phase];
+  if (!listenersForType.bubble && !listenersForType.capture) {
+    listeners?.delete(registration.type);
   }
+  target[constants.OWNER_DOCUMENT]?.defaultView[constants.HOOKS_DISPATCH].removeEventListener?.(target, registration.type, registration.listener, registration.capture);
 }
 
 exports.EventTarget = EventTarget;

package/build/cjs/HTMLTemplateElement.cjs

@@ -11,6 +11,7 @@ class HTMLTemplateElement extends Element.Element {
     let content = this[constants.CONTENT];
     if (!content) {
       content = this.ownerDocument.createDocumentFragment();
+      content[constants.HOST] = this;
       this[constants.CONTENT] = content;
     }
     return content;

package/build/cjs/MutationObserver.cjs

@@ -2,8 +2,174 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
+const NodeList = require('./NodeList.cjs');
+
+let registrations;
+let registrationCount = 0;
+let attributeRegistrationCount = 0;
+let characterDataRegistrationCount = 0;
+let childListRegistrationCount = 0;
+
+// Mutation sites read these live bindings before capturing old values or
+// allocating record data. Keep them split so observing one mutation type does
+// not add work to unrelated mutations.
+/** @internal */
+exports.attributeObserversActive = false;
+/** @internal */
+exports.characterDataObserversActive = false;
+/** @internal */
+exports.childListObserversActive = false;
 class MutationObserver {
-  // stub implementation
+  #callback;
+  #records = [];
+  #targets = new Set();
+  #scheduled = false;
+  constructor(callback) {
+    if (typeof callback !== 'function') {
+      throw new TypeError('MutationObserver callback must be a function');
+    }
+    this.#callback = callback;
+  }
+  observe(target, options = {}) {
+    const normalizedOptions = normalizeOptions(options);
+    const currentRegistrations = registrations ??= new WeakMap();
+    let targetRegistrations = currentRegistrations.get(target);
+    if (targetRegistrations == null) {
+      targetRegistrations = new Map();
+      currentRegistrations.set(target, targetRegistrations);
+    }
+    const previousOptions = targetRegistrations.get(this);
+    if (previousOptions == null) {
+      registrationCount++;
+    } else {
+      updateRegistrationCounts(previousOptions, -1);
+    }
+    targetRegistrations.set(this, normalizedOptions);
+    updateRegistrationCounts(normalizedOptions, 1);
+    this.#targets.add(target);
+  }
+  disconnect() {
+    const currentRegistrations = registrations;
+    if (currentRegistrations == null) return;
+    for (const target of this.#targets) {
+      const targetRegistrations = currentRegistrations.get(target);
+      const options = targetRegistrations?.get(this);
+      if (options != null) {
+        targetRegistrations.delete(this);
+        registrationCount--;
+        updateRegistrationCounts(options, -1);
+      }
+      if (targetRegistrations?.size === 0) {
+        currentRegistrations.delete(target);
+      }
+    }
+    this.#targets.clear();
+    this.#records.length = 0;
+    if (registrationCount === 0) {
+      registrations = undefined;
+    }
+  }
+  takeRecords() {
+    return this.#records.splice(0);
+  }
+
+  /** @internal */
+  enqueue(record) {
+    this.#records.push(record);
+    if (this.#scheduled) return;
+    this.#scheduled = true;
+    queueMicrotask(() => {
+      this.#scheduled = false;
+      const records = this.takeRecords();
+      if (records.length > 0) {
+        this.#callback.call(this, records, this);
+      }
+    });
+  }
+}
+
+/** @internal */
+function queueMutationRecord(init) {
+  const currentRegistrations = registrations;
+  if (currentRegistrations == null) return;
+  const interestedObservers = new Map();
+  let node = init.target;
+  while (node) {
+    const targetRegistrations = currentRegistrations.get(node);
+    if (targetRegistrations) {
+      for (const [observer, options] of targetRegistrations) {
+        if (node !== init.target && !options.subtree) continue;
+        let includeOldValue = false;
+        if (init.type === 'attributes') {
+          if (!options.attributes) continue;
+          if (options.attributeFilter && !options.attributeFilter.has(init.attributeName ?? '')) {
+            continue;
+          }
+          includeOldValue = options.attributeOldValue;
+        } else if (init.type === 'characterData') {
+          if (!options.characterData) continue;
+          includeOldValue = options.characterDataOldValue;
+        } else if (!options.childList) {
+          continue;
+        }
+        interestedObservers.set(observer, interestedObservers.get(observer) === true || includeOldValue);
+      }
+    }
+    node = node.parentNode;
+  }
+  for (const [observer, includeOldValue] of interestedObservers) {
+    observer.enqueue({
+      addedNodes: init.addedNodes ?? new NodeList.NodeList(),
+      attributeName: init.attributeName ?? null,
+      attributeNamespace: init.attributeNamespace ?? null,
+      nextSibling: init.nextSibling ?? null,
+      oldValue: includeOldValue ? init.oldValue ?? null : null,
+      previousSibling: init.previousSibling ?? null,
+      removedNodes: init.removedNodes ?? new NodeList.NodeList(),
+      target: init.target,
+      type: init.type
+    });
+  }
+}
+
+/** @internal */
+function mutationNodeList(...nodes) {
+  const list = new NodeList.NodeList();
+  list.push(...nodes);
+  return list;
+}
+function normalizeOptions(options) {
+  if (options.attributes === false && (options.attributeOldValue || options.attributeFilter != null)) {
+    throw new TypeError('attributeOldValue and attributeFilter require attributes to be enabled');
+  }
+  if (options.characterData === false && options.characterDataOldValue) {
+    throw new TypeError('characterDataOldValue requires characterData to be enabled');
+  }
+  const attributes = options.attributes ?? (options.attributeOldValue === true || options.attributeFilter != null);
+  const characterData = options.characterData ?? options.characterDataOldValue === true;
+  const childList = options.childList === true;
+  if (!attributes && !characterData && !childList) {
+    throw new TypeError('MutationObserver options must enable childList, attributes, or characterData');
+  }
+  return {
+    attributes,
+    attributeFilter: options.attributeFilter == null ? undefined : new Set(options.attributeFilter.map(String)),
+    attributeOldValue: options.attributeOldValue === true,
+    characterData,
+    characterDataOldValue: options.characterDataOldValue === true,
+    childList,
+    subtree: options.subtree === true
+  };
+}
+function updateRegistrationCounts(options, delta) {
+  if (options.attributes) attributeRegistrationCount += delta;
+  if (options.characterData) characterDataRegistrationCount += delta;
+  if (options.childList) childListRegistrationCount += delta;
+  exports.attributeObserversActive = attributeRegistrationCount > 0;
+  exports.characterDataObserversActive = characterDataRegistrationCount > 0;
+  exports.childListObserversActive = childListRegistrationCount > 0;
 }
 
 exports.MutationObserver = MutationObserver;
+exports.mutationNodeList = mutationNodeList;
+exports.queueMutationRecord = queueMutationRecord;