@remote-dom/polyfill 1.5.1 → 1.6.0

package/build/esm/Window.mjs

@@ -20,43 +20,114 @@ 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';
+import { HOOKS, EXTENSIONS, HOOKS_DISPATCH } from './constants.mjs';
 
+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.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 {
   [HOOKS] = {};
+  [EXTENSIONS] = [];
+  [HOOKS_DISPATCH] = createHooksDispatcher(this);
   name = '';
   window = this;
   parent = this;
   self = this;
   top = this;
-  document = (() => new Document(this))();
-  customElements = (() => new CustomElementRegistryImplementation())();
-  location = (() => globalThis.location)();
-  navigator = (() => globalThis.navigator)();
-  Event = (() => Event)();
-  ErrorEvent = (() => ErrorEvent)();
-  PromiseRejectionEvent = (() => PromiseRejectionEvent)();
-  ToggleEvent = (() => ToggleEvent)();
-  FocusEvent = (() => FocusEvent)();
-  ClipboardEvent = (() => ClipboardEvent)();
-  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)();
+  document = new Document(this);
+  customElements = new CustomElementRegistryImplementation();
+  location = globalThis.location;
+  navigator = globalThis.navigator;
+  Event = Event;
+  ErrorEvent = ErrorEvent;
+  PromiseRejectionEvent = PromiseRejectionEvent;
+  ToggleEvent = ToggleEvent;
+  FocusEvent = FocusEvent;
+  ClipboardEvent = ClipboardEvent;
+  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;
   #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;
   }
@@ -95,21 +166,26 @@ class Window extends 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) {
@@ -118,16 +194,33 @@ class Window extends EventTarget {
         window[property] = globalThis;
       }
     }
-    const properties = Object.getOwnPropertyDescriptors(window);
-    const eventTargetPrototypeProperties = Object.getOwnPropertyDescriptors(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[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[EXTENSIONS]) {
+    const hook = hooks[name];
+    hook?.apply(hooks, args);
   }
+  const hooks = window[HOOKS];
+  const legacyHook = hooks[name];
+  legacyHook?.apply(hooks, args);
 }
 
 export { Window };

package/build/esm/attribute-reactions.mjs

@@ -0,0 +1,16 @@
+import { enqueueCustomElementReaction } from './custom-element-reactions.mjs';
+
+function enqueueAttributeReaction(element, localName, oldValue, newValue, namespace) {
+  const {
+    observedAttributes
+  } = element.constructor;
+  const {
+    attributeChangedCallback
+  } = element;
+  if (attributeChangedCallback == null || observedAttributes == null || !observedAttributes.includes(localName)) {
+    return;
+  }
+  enqueueCustomElementReaction(element, () => attributeChangedCallback.call(element, localName, oldValue, newValue, namespace));
+}
+
+export { enqueueAttributeReaction };

package/build/esm/constants.mjs

@@ -1,4 +1,5 @@
 const NAME = Symbol('name');
+const PREFIX = Symbol('prefix');
 const VALUE = Symbol('value');
 const NS = Symbol('ns');
 const OWNER_ELEMENT = Symbol('owner');
@@ -8,35 +9,39 @@ 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');
+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));
+}
 
-// @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, HOOKS, IS_CONNECTED, IS_TRUSTED, LISTENERS, NAME, NEXT, NS, NamespaceURI, NodeType, OWNER_DOCUMENT, OWNER_ELEMENT, PARENT, PATH, PREV, STOP_IMMEDIATE_PROPAGATION, VALUE };
+export { ATTRIBUTES, CHILD, CONTENT, CREATE_ELEMENT, DATA, DISPATCHING, EXTENSIONS, HOOKS, HOOKS_DISPATCH, HOST, HTML_NAMESPACE, IS_CONNECTED, IS_TRUSTED, LISTENERS, NAME, NEXT, NODE_TYPE_ATTRIBUTE, NODE_TYPE_COMMENT, NODE_TYPE_DOCUMENT, NODE_TYPE_DOCUMENT_FRAGMENT, NODE_TYPE_DOCUMENT_TYPE, NODE_TYPE_ELEMENT, NODE_TYPE_NODE, NODE_TYPE_TEXT, NS, OWNER_DOCUMENT, OWNER_ELEMENT, PARENT, PATH, PREFIX, PREV, STOP_IMMEDIATE_PROPAGATION, SVG_NAMESPACE, VALUE, XMLNS_NAMESPACE, XML_NAMESPACE, asciiLowercase, asciiUppercase, splitOnASCIIWhitespace };

package/build/esm/custom-element-reactions.mjs

@@ -0,0 +1,47 @@
+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;
+}
+
+export { enqueueCustomElementReaction, performWithCustomElementReactions };

package/build/esm/dom-exception.mjs

@@ -0,0 +1,11 @@
+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;
+}
+
+export { createDOMException };

package/build/esm/hook-effects.mjs

@@ -0,0 +1,46 @@
+import { PARENT, HOST } from './constants.mjs';
+
+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[PARENT] ?? current[HOST];
+  }
+  return false;
+}
+
+export { isCoveredByPendingPublication, performHookEffects };

package/build/esm/names.mjs

@@ -0,0 +1,54 @@
+import { XML_NAMESPACE, XMLNS_NAMESPACE } from './constants.mjs';
+import { createDOMException } from './dom-exception.mjs';
+
+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 createDOMException(`A namespace is required for the prefix in "${qualifiedName}"`, 'NamespaceError');
+  }
+  if (prefix === 'xml' && namespace !== XML_NAMESPACE) {
+    throw createDOMException(`The xml prefix requires the XML namespace`, 'NamespaceError');
+  }
+  if ((qualifiedName === 'xmlns' || prefix === 'xmlns') && namespace !== XMLNS_NAMESPACE) {
+    throw createDOMException(`The xmlns name requires the XMLNS namespace`, 'NamespaceError');
+  }
+  if (namespace === XMLNS_NAMESPACE && qualifiedName !== 'xmlns' && prefix !== 'xmlns') {
+    throw createDOMException(`The XMLNS namespace requires the xmlns name or prefix`, 'NamespaceError');
+  }
+  return {
+    namespace,
+    qualifiedName,
+    prefix,
+    localName
+  };
+}
+function throwInvalidCharacterError(name) {
+  throw createDOMException(`Invalid name: "${name}"`, 'InvalidCharacterError');
+}
+
+export { normalizeNamespace, validateAndExtractQualifiedName, validateAttributeLocalName, validateElementLocalName };