@remote-dom/polyfill 1.5.1 → 1.6.0

package/build/esnext/Window.esnext

@@ -20,10 +20,80 @@ import { DocumentFragment } from './DocumentFragment.esnext';
 import { HTMLTemplateElement } from './HTMLTemplateElement.esnext';
 import { CustomElementRegistryImplementation } from './CustomElementRegistry.esnext';
 import { MutationObserver } from './MutationObserver.esnext';
-import { HOOKS } from './constants.esnext';
+import { HOOKS, EXTENSIONS, HOOKS_DISPATCH } from './constants.esnext';
 
+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 void 0;
+}
+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;
@@ -57,6 +127,17 @@ class Window extends EventTarget {
   #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;
   }
@@ -102,18 +183,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 {
-      Object.defineProperties(self, properties);
+    } else if (currentSelf !== globalThis) {
+      Object.defineProperties(currentSelf, properties);
+      installMissingGlobalProperties(currentSelf, missingProperties);
     }
   }
   static setGlobalThis(window) {
@@ -122,18 +211,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 hooks2 of window[EXTENSIONS]) {
+    const hook = hooks2[name];
+    hook?.apply(hooks2, args);
   }
+  const hooks = window[HOOKS];
+  const legacyHook = hooks[name];
+  legacyHook?.apply(hooks, args);
 }
 
 export { Window };

package/build/esnext/attribute-reactions.esnext

@@ -0,0 +1,21 @@
+import { enqueueCustomElementReaction } from './custom-element-reactions.esnext';
+
+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/esnext/constants.esnext

@@ -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,33 +9,45 @@ 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");
-var NodeType = /* @__PURE__ */ ((NodeType2) => {
-  NodeType2[NodeType2["NODE"] = 0] = "NODE";
-  NodeType2[NodeType2["ELEMENT_NODE"] = 1] = "ELEMENT_NODE";
-  NodeType2[NodeType2["ATTRIBUTE_NODE"] = 2] = "ATTRIBUTE_NODE";
-  NodeType2[NodeType2["TEXT_NODE"] = 3] = "TEXT_NODE";
-  NodeType2[NodeType2["CDATA_SECTION_NODE"] = 4] = "CDATA_SECTION_NODE";
-  NodeType2[NodeType2["ENTITY_REFERENCE_NODE"] = 5] = "ENTITY_REFERENCE_NODE";
-  NodeType2[NodeType2["ENTITY_NODE"] = 6] = "ENTITY_NODE";
-  NodeType2[NodeType2["PROCESSING_INSTRUCTION_NODE"] = 7] = "PROCESSING_INSTRUCTION_NODE";
-  NodeType2[NodeType2["COMMENT_NODE"] = 8] = "COMMENT_NODE";
-  NodeType2[NodeType2["DOCUMENT_NODE"] = 9] = "DOCUMENT_NODE";
-  NodeType2[NodeType2["DOCUMENT_TYPE_NODE"] = 10] = "DOCUMENT_TYPE_NODE";
-  NodeType2[NodeType2["DOCUMENT_FRAGMENT_NODE"] = 11] = "DOCUMENT_FRAGMENT_NODE";
-  return NodeType2;
-})(NodeType || {});
-var NamespaceURI = /* @__PURE__ */ ((NamespaceURI2) => {
-  NamespaceURI2["XHTML"] = "http://www.w3.org/1999/xhtml";
-  NamespaceURI2["SVG"] = "http://www.w3.org/2000/svg";
-  return NamespaceURI2;
-})(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) + 32)
+  );
+}
+function asciiUppercase(value) {
+  return value.replace(
+    /[a-z]/g,
+    (character) => String.fromCharCode(character.charCodeAt(0) - 32)
+  );
+}
 
-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/esnext/custom-element-reactions.esnext

@@ -0,0 +1,49 @@
+const scopes = [];
+const reactionsByTarget = /* @__PURE__ */ 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/esnext/dom-exception.esnext

@@ -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/esnext/hook-effects.esnext

@@ -0,0 +1,46 @@
+import { PARENT, HOST } from './constants.esnext';
+
+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/esnext/names.esnext

@@ -0,0 +1,61 @@
+import { XML_NAMESPACE, XMLNS_NAMESPACE } from './constants.esnext';
+import { createDOMException } from './dom-exception.esnext';
+
+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 };