@remote-dom/polyfill 1.5.1 → 1.6.0

package/build/cjs/Window.cjs

@@ -26,41 +26,112 @@ const CustomElementRegistry = require('./CustomElementRegistry.cjs');
 const MutationObserver = require('./MutationObserver.cjs');
 const constants = require('./constants.cjs');
 
+const EVENT_HANDLER_PROPERTIES = ['onerror', 'onunhandledrejection'];
+const POLYFILL_GLOBAL_PROPERTY = Symbol.for('@remote-dom/polyfill/global-property');
+function windowPropertyDescriptors(window) {
+  return Object.getOwnPropertyDescriptors(window);
+}
+function eventTargetPropertyDescriptors(window) {
+  const properties = {};
+  for (const [property, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(EventTarget.EventTarget.prototype))) {
+    if (property !== 'constructor' && typeof descriptor.value === 'function') {
+      descriptor.value = markPolyfillGlobalProperty(descriptor.value.bind(window));
+      properties[property] = descriptor;
+    }
+  }
+  return properties;
+}
+function eventHandlerPropertyDescriptors(window) {
+  const properties = {};
+  for (const property of EVENT_HANDLER_PROPERTIES) {
+    properties[property] = {
+      configurable: true,
+      enumerable: true,
+      get: markPolyfillGlobalProperty(() => window[property]),
+      set: markPolyfillGlobalProperty(handler => {
+        window[property] = handler;
+      })
+    };
+  }
+  return properties;
+}
+function globalPropertyDescriptors(window) {
+  return Object.assign(windowPropertyDescriptors(window), eventTargetPropertyDescriptors(window), eventHandlerPropertyDescriptors(window));
+}
+function markPolyfillGlobalProperty(value) {
+  Object.defineProperty(value, POLYFILL_GLOBAL_PROPERTY, {
+    value: true
+  });
+  return value;
+}
+function installMissingGlobalProperties(target, properties) {
+  for (const property of Reflect.ownKeys(properties)) {
+    const currentDescriptor = findPropertyDescriptor(target, property);
+    if (currentDescriptor == null || isPolyfillGlobalProperty(currentDescriptor)) {
+      Object.defineProperty(target, property, properties[property]);
+    }
+  }
+}
+function findPropertyDescriptor(target, property) {
+  let currentTarget = target;
+  while (currentTarget) {
+    const descriptor = Object.getOwnPropertyDescriptor(currentTarget, property);
+    if (descriptor) return descriptor;
+    currentTarget = Object.getPrototypeOf(currentTarget);
+  }
+  return undefined;
+}
+function isPolyfillGlobalProperty(descriptor) {
+  return [descriptor.value, descriptor.get, descriptor.set].some(value => typeof value === 'function' && value[POLYFILL_GLOBAL_PROPERTY] === true);
+}
 class Window extends EventTarget.EventTarget {
   [constants.HOOKS] = {};
+  [constants.EXTENSIONS] = [];
+  [constants.HOOKS_DISPATCH] = createHooksDispatcher(this);
   name = '';
   window = this;
   parent = this;
   self = this;
   top = this;
-  document = (() => new Document.Document(this))();
-  customElements = (() => new CustomElementRegistry.CustomElementRegistryImplementation())();
-  location = (() => globalThis.location)();
-  navigator = (() => globalThis.navigator)();
-  Event = (() => Event.Event)();
-  ErrorEvent = (() => ErrorEvent.ErrorEvent)();
-  PromiseRejectionEvent = (() => PromiseRejectionEvent.PromiseRejectionEvent)();
-  ToggleEvent = (() => ToggleEvent.ToggleEvent)();
-  FocusEvent = (() => FocusEvent.FocusEvent)();
-  ClipboardEvent = (() => ClipboardEvent.ClipboardEvent)();
-  EventTarget = (() => EventTarget.EventTarget)();
-  CustomEvent = (() => CustomEvent.CustomEvent)();
-  Node = (() => Node.Node)();
-  ParentNode = (() => ParentNode.ParentNode)();
-  ChildNode = (() => ChildNode.ChildNode)();
-  DocumentFragment = (() => DocumentFragment.DocumentFragment)();
-  Document = (() => Document.Document)();
-  CharacterData = (() => CharacterData.CharacterData)();
-  Comment = (() => Comment.Comment)();
-  Text = (() => Text.Text)();
-  Element = (() => Element.Element)();
-  HTMLElement = (() => HTMLElement.HTMLElement)();
-  SVGElement = (() => SVGElement.SVGElement)();
-  HTMLTemplateElement = (() => HTMLTemplateElement.HTMLTemplateElement)();
-  MutationObserver = (() => MutationObserver.MutationObserver)();
+  document = new Document.Document(this);
+  customElements = new CustomElementRegistry.CustomElementRegistryImplementation();
+  location = globalThis.location;
+  navigator = globalThis.navigator;
+  Event = Event.Event;
+  ErrorEvent = ErrorEvent.ErrorEvent;
+  PromiseRejectionEvent = PromiseRejectionEvent.PromiseRejectionEvent;
+  ToggleEvent = ToggleEvent.ToggleEvent;
+  FocusEvent = FocusEvent.FocusEvent;
+  ClipboardEvent = ClipboardEvent.ClipboardEvent;
+  EventTarget = EventTarget.EventTarget;
+  CustomEvent = CustomEvent.CustomEvent;
+  Node = Node.Node;
+  ParentNode = ParentNode.ParentNode;
+  ChildNode = ChildNode.ChildNode;
+  DocumentFragment = DocumentFragment.DocumentFragment;
+  Document = Document.Document;
+  CharacterData = CharacterData.CharacterData;
+  Comment = Comment.Comment;
+  Text = Text.Text;
+  Element = Element.Element;
+  HTMLElement = HTMLElement.HTMLElement;
+  SVGElement = SVGElement.SVGElement;
+  HTMLTemplateElement = HTMLTemplateElement.HTMLTemplateElement;
+  MutationObserver = MutationObserver.MutationObserver;
   #currentOnErrorHandler = null;
   #currentOriginalOnErrorHandler = null;
   #currentOnUnhandledRejectionHandler = null;
+  static with(...extensions) {
+    const BaseWindow = this;
+    return class ExtendedWindow extends BaseWindow {
+      constructor() {
+        super();
+        for (const extension of extensions) {
+          installExtension(this, extension);
+        }
+      }
+    };
+  }
   get onerror() {
     return this.#currentOriginalOnErrorHandler;
   }
@@ -99,21 +170,26 @@ class Window extends EventTarget.EventTarget {
     }
   }
   static setGlobal(window) {
-    const properties = Object.getOwnPropertyDescriptors(window);
+    const currentSelf = globalThis.self;
+    const currentWindow = globalThis.window;
+    const properties = windowPropertyDescriptors(window);
+    const missingProperties = Object.assign(eventTargetPropertyDescriptors(window), eventHandlerPropertyDescriptors(window));
     delete properties.self;
     Object.defineProperties(globalThis, properties);
-    if (typeof globalThis.self === 'undefined') {
+    installMissingGlobalProperties(globalThis, missingProperties);
+    if (typeof currentSelf === 'undefined' || currentSelf === currentWindow && currentSelf !== globalThis) {
       Object.defineProperty(globalThis, 'self', {
         value: window,
         configurable: true,
         writable: true,
         enumerable: true
       });
-    } else {
+    } else if (currentSelf !== globalThis) {
       // 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);
+      Object.defineProperties(currentSelf, properties);
+      installMissingGlobalProperties(currentSelf, missingProperties);
     }
   }
   static setGlobalThis(window) {
@@ -122,16 +198,33 @@ class Window extends EventTarget.EventTarget {
         window[property] = globalThis;
       }
     }
-    const properties = Object.getOwnPropertyDescriptors(window);
-    const eventTargetPrototypeProperties = Object.getOwnPropertyDescriptors(EventTarget.EventTarget.prototype);
-    for (const descriptor of Object.values(eventTargetPrototypeProperties)) {
-      if (typeof descriptor.value === 'function') {
-        descriptor.value = descriptor.value.bind(window);
-      }
-    }
-    Object.defineProperties(globalThis, properties);
-    Object.defineProperties(globalThis, eventTargetPrototypeProperties);
+    Object.defineProperties(globalThis, globalPropertyDescriptors(window));
+  }
+}
+function installExtension(window, extension) {
+  window[constants.EXTENSIONS].push(extension(window) ?? {});
+}
+function createHooksDispatcher(window) {
+  return {
+    createElement: dispatchHook.bind(null, window, 'createElement'),
+    setAttribute: dispatchHook.bind(null, window, 'setAttribute'),
+    removeAttribute: dispatchHook.bind(null, window, 'removeAttribute'),
+    createText: dispatchHook.bind(null, window, 'createText'),
+    setText: dispatchHook.bind(null, window, 'setText'),
+    insertChild: dispatchHook.bind(null, window, 'insertChild'),
+    removeChild: dispatchHook.bind(null, window, 'removeChild'),
+    addEventListener: dispatchHook.bind(null, window, 'addEventListener'),
+    removeEventListener: dispatchHook.bind(null, window, 'removeEventListener')
+  };
+}
+function dispatchHook(window, name, ...args) {
+  for (const hooks of window[constants.EXTENSIONS]) {
+    const hook = hooks[name];
+    hook?.apply(hooks, args);
   }
+  const hooks = window[constants.HOOKS];
+  const legacyHook = hooks[name];
+  legacyHook?.apply(hooks, args);
 }
 
 exports.Window = Window;

package/build/cjs/attribute-reactions.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const customElementReactions = require('./custom-element-reactions.cjs');
+
+function enqueueAttributeReaction(element, localName, oldValue, newValue, namespace) {
+  const {
+    observedAttributes
+  } = element.constructor;
+  const {
+    attributeChangedCallback
+  } = element;
+  if (attributeChangedCallback == null || observedAttributes == null || !observedAttributes.includes(localName)) {
+    return;
+  }
+  customElementReactions.enqueueCustomElementReaction(element, () => attributeChangedCallback.call(element, localName, oldValue, newValue, namespace));
+}
+
+exports.enqueueAttributeReaction = enqueueAttributeReaction;

package/build/cjs/constants.cjs

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const NAME = Symbol('name');
+const PREFIX = Symbol('prefix');
 const VALUE = Symbol('value');
 const NS = Symbol('ns');
 const OWNER_ELEMENT = Symbol('owner');
@@ -12,54 +13,77 @@ const PREV = Symbol('prev');
 const NEXT = Symbol('next');
 const CHILD = Symbol('child');
 const PARENT = Symbol('parent');
+const HOST = Symbol('host');
 const DATA = Symbol('data');
 const LISTENERS = Symbol('listeners');
 const IS_TRUSTED = Symbol('isTrusted');
 const PATH = Symbol('path');
 const STOP_IMMEDIATE_PROPAGATION = Symbol('stop_immediate_propagation');
+const DISPATCHING = Symbol('dispatching');
 const CONTENT = Symbol('content');
 const HOOKS = Symbol('hooks');
+const EXTENSIONS = Symbol('extensions');
+const HOOKS_DISPATCH = Symbol('hooks_dispatch');
 const IS_CONNECTED = Symbol('is_connected');
-
-// @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;
-}({});
+const CREATE_ELEMENT = Symbol('create_element');
+const NODE_TYPE_NODE = 0;
+const NODE_TYPE_ELEMENT = 1;
+const NODE_TYPE_ATTRIBUTE = 2;
+const NODE_TYPE_TEXT = 3;
+const NODE_TYPE_COMMENT = 8;
+const NODE_TYPE_DOCUMENT = 9;
+const NODE_TYPE_DOCUMENT_TYPE = 10;
+const NODE_TYPE_DOCUMENT_FRAGMENT = 11;
+const HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';
+const SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
+const XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+const XMLNS_NAMESPACE = 'http://www.w3.org/2000/xmlns/';
+function splitOnASCIIWhitespace(value) {
+  return value.split(/[\t\n\f\r ]+/).filter(Boolean);
+}
+function asciiLowercase(value) {
+  return value.replace(/[A-Z]/g, character => String.fromCharCode(character.charCodeAt(0) + 0x20));
+}
+function asciiUppercase(value) {
+  return value.replace(/[a-z]/g, character => String.fromCharCode(character.charCodeAt(0) - 0x20));
+}
 
 exports.ATTRIBUTES = ATTRIBUTES;
 exports.CHILD = CHILD;
 exports.CONTENT = CONTENT;
+exports.CREATE_ELEMENT = CREATE_ELEMENT;
 exports.DATA = DATA;
+exports.DISPATCHING = DISPATCHING;
+exports.EXTENSIONS = EXTENSIONS;
 exports.HOOKS = HOOKS;
+exports.HOOKS_DISPATCH = HOOKS_DISPATCH;
+exports.HOST = HOST;
+exports.HTML_NAMESPACE = HTML_NAMESPACE;
 exports.IS_CONNECTED = IS_CONNECTED;
 exports.IS_TRUSTED = IS_TRUSTED;
 exports.LISTENERS = LISTENERS;
 exports.NAME = NAME;
 exports.NEXT = NEXT;
+exports.NODE_TYPE_ATTRIBUTE = NODE_TYPE_ATTRIBUTE;
+exports.NODE_TYPE_COMMENT = NODE_TYPE_COMMENT;
+exports.NODE_TYPE_DOCUMENT = NODE_TYPE_DOCUMENT;
+exports.NODE_TYPE_DOCUMENT_FRAGMENT = NODE_TYPE_DOCUMENT_FRAGMENT;
+exports.NODE_TYPE_DOCUMENT_TYPE = NODE_TYPE_DOCUMENT_TYPE;
+exports.NODE_TYPE_ELEMENT = NODE_TYPE_ELEMENT;
+exports.NODE_TYPE_NODE = NODE_TYPE_NODE;
+exports.NODE_TYPE_TEXT = NODE_TYPE_TEXT;
 exports.NS = NS;
-exports.NamespaceURI = NamespaceURI;
-exports.NodeType = NodeType;
 exports.OWNER_DOCUMENT = OWNER_DOCUMENT;
 exports.OWNER_ELEMENT = OWNER_ELEMENT;
 exports.PARENT = PARENT;
 exports.PATH = PATH;
+exports.PREFIX = PREFIX;
 exports.PREV = PREV;
 exports.STOP_IMMEDIATE_PROPAGATION = STOP_IMMEDIATE_PROPAGATION;
+exports.SVG_NAMESPACE = SVG_NAMESPACE;
 exports.VALUE = VALUE;
+exports.XMLNS_NAMESPACE = XMLNS_NAMESPACE;
+exports.XML_NAMESPACE = XML_NAMESPACE;
+exports.asciiLowercase = asciiLowercase;
+exports.asciiUppercase = asciiUppercase;
+exports.splitOnASCIIWhitespace = splitOnASCIIWhitespace;

package/build/cjs/custom-element-reactions.cjs

@@ -0,0 +1,52 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const scopes = [];
+const reactionsByTarget = new WeakMap();
+function enqueueCustomElementReaction(target, reaction) {
+  const reactions = reactionsByTarget.get(target);
+  if (reactions) reactions.push(reaction);else reactionsByTarget.set(target, [reaction]);
+  scopes[scopes.length - 1].push(target);
+}
+function performWithCustomElementReactions(mutation) {
+  const scope = [];
+  scopes.push(scope);
+  let result;
+  try {
+    result = mutation();
+  } catch (error) {
+    scopes.pop();
+    try {
+      flushCustomElementReactions(scope);
+    } catch {}
+    throw error;
+  }
+  scopes.pop();
+  flushCustomElementReactions(scope);
+  return result;
+}
+function flushCustomElementReactions(scope) {
+  let firstError;
+  let didThrow = false;
+  for (const target of scope) {
+    const reactions = reactionsByTarget.get(target);
+    if (!reactions) continue;
+    while (reactions.length > 0) {
+      const reaction = reactions.shift();
+      try {
+        reaction();
+      } catch (error) {
+        if (!didThrow) {
+          firstError = error;
+          didThrow = true;
+        }
+      }
+    }
+    reactionsByTarget.delete(target);
+  }
+  if (didThrow) throw firstError;
+}
+
+exports.enqueueCustomElementReaction = enqueueCustomElementReaction;
+exports.performWithCustomElementReactions = performWithCustomElementReactions;

package/build/cjs/dom-exception.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+function createDOMException(message, name) {
+  const DOMExceptionConstructor = globalThis.DOMException;
+  if (typeof DOMExceptionConstructor === 'function') {
+    return new DOMExceptionConstructor(message, name);
+  }
+  const error = new Error(message);
+  error.name = name;
+  return error;
+}
+
+exports.createDOMException = createDOMException;

package/build/cjs/hook-effects.cjs

@@ -0,0 +1,51 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const constants = require('./constants.cjs');
+
+const hookEffects = [];
+const pendingPublications = [];
+let isDispatchingHookEffects = false;
+function performHookEffects(effects) {
+  for (const effect of effects) {
+    hookEffects.push(effect);
+    if (effect[1]) pendingPublications.push(effect[1]);
+  }
+  if (isDispatchingHookEffects) return;
+  isDispatchingHookEffects = true;
+  try {
+    let firstError;
+    let didThrow = false;
+    for (let index = 0; index < hookEffects.length; index++) {
+      const [run, publication] = hookEffects[index];
+      if (publication) {
+        pendingPublications.splice(pendingPublications.indexOf(publication), 1);
+      }
+      try {
+        run();
+      } catch (error) {
+        if (!didThrow) {
+          firstError = error;
+          didThrow = true;
+        }
+      }
+    }
+    if (didThrow) throw firstError;
+  } finally {
+    hookEffects.length = 0;
+    pendingPublications.length = 0;
+    isDispatchingHookEffects = false;
+  }
+}
+function isCoveredByPendingPublication(node) {
+  let current = node;
+  while (current) {
+    if (pendingPublications.includes(current)) return true;
+    current = current[constants.PARENT] ?? current[constants.HOST];
+  }
+  return false;
+}
+
+exports.isCoveredByPendingPublication = isCoveredByPendingPublication;
+exports.performHookEffects = performHookEffects;

package/build/cjs/names.cjs

@@ -0,0 +1,61 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const constants = require('./constants.cjs');
+const domException = require('./dom-exception.cjs');
+
+const VALID_ELEMENT_LOCAL_NAME = /^(?:[A-Za-z][^\0\t\n\f\r\u0020/>]*|[:_\u0080-\u{10FFFF}][A-Za-z0-9-.:_\u0080-\u{10FFFF}]*)$/u;
+const INVALID_ATTRIBUTE_LOCAL_NAME = /[\0\t\n\f\r />=]/u;
+const INVALID_NAMESPACE_PREFIX = /[\0\t\n\f\r />]/u;
+function normalizeNamespace(namespace) {
+  if (namespace == null) return null;
+  const normalized = String(namespace);
+  return normalized === '' ? null : normalized;
+}
+function validateElementLocalName(name) {
+  if (!VALID_ELEMENT_LOCAL_NAME.test(name)) {
+    throwInvalidCharacterError(name);
+  }
+}
+function validateAttributeLocalName(name) {
+  if (name === '' || INVALID_ATTRIBUTE_LOCAL_NAME.test(name)) {
+    throwInvalidCharacterError(name);
+  }
+}
+function validateAndExtractQualifiedName(namespaceValue, qualifiedNameValue, kind) {
+  const namespace = normalizeNamespace(namespaceValue);
+  const qualifiedName = String(qualifiedNameValue);
+  const separator = qualifiedName.indexOf(':');
+  const prefix = separator < 0 ? null : qualifiedName.slice(0, separator);
+  const localName = separator < 0 ? qualifiedName : qualifiedName.slice(separator + 1);
+  if (prefix != null && (prefix === '' || INVALID_NAMESPACE_PREFIX.test(prefix)) || (kind === 'element' ? !VALID_ELEMENT_LOCAL_NAME.test(localName) : localName === '' || INVALID_ATTRIBUTE_LOCAL_NAME.test(localName))) {
+    throwInvalidCharacterError(qualifiedName);
+  }
+  if (prefix != null && namespace == null) {
+    throw domException.createDOMException(`A namespace is required for the prefix in "${qualifiedName}"`, 'NamespaceError');
+  }
+  if (prefix === 'xml' && namespace !== constants.XML_NAMESPACE) {
+    throw domException.createDOMException(`The xml prefix requires the XML namespace`, 'NamespaceError');
+  }
+  if ((qualifiedName === 'xmlns' || prefix === 'xmlns') && namespace !== constants.XMLNS_NAMESPACE) {
+    throw domException.createDOMException(`The xmlns name requires the XMLNS namespace`, 'NamespaceError');
+  }
+  if (namespace === constants.XMLNS_NAMESPACE && qualifiedName !== 'xmlns' && prefix !== 'xmlns') {
+    throw domException.createDOMException(`The XMLNS namespace requires the xmlns name or prefix`, 'NamespaceError');
+  }
+  return {
+    namespace,
+    qualifiedName,
+    prefix,
+    localName
+  };
+}
+function throwInvalidCharacterError(name) {
+  throw domException.createDOMException(`Invalid name: "${name}"`, 'InvalidCharacterError');
+}
+
+exports.normalizeNamespace = normalizeNamespace;
+exports.validateAndExtractQualifiedName = validateAndExtractQualifiedName;
+exports.validateAttributeLocalName = validateAttributeLocalName;
+exports.validateElementLocalName = validateElementLocalName;