@remote-dom/polyfill 0.0.0-preview-20240219211553

package/build/esm/HTMLTemplateElement.mjs

@@ -0,0 +1,24 @@
+import { CONTENT } from './constants.mjs';
+import { Element } from './Element.mjs';
+import { parseHtml, serializeChildren } from './serialization.mjs';
+
+class HTMLTemplateElement extends Element {
+  get content() {
+    let content = this[CONTENT];
+    if (!content) {
+      content = this.ownerDocument.createDocumentFragment();
+      this[CONTENT] = content;
+    }
+    return content;
+  }
+  set content(_) {}
+  set innerHTML(html) {
+    this.content.replaceChildren(parseHtml(String(html), this));
+  }
+  get innerHTML() {
+    const content = this[CONTENT];
+    return content ? serializeChildren(content) : '';
+  }
+}
+
+export { HTMLTemplateElement };

package/build/esm/MutationObserver.mjs

@@ -0,0 +1,5 @@
+class MutationObserver {
+  // stub implementation
+}
+
+export { MutationObserver };

package/build/esm/NamedNodeMap.mjs

@@ -0,0 +1,121 @@
+import { hooks } from './hooks.mjs';
+import { CHILD, OWNER_ELEMENT, NS, NEXT } from './constants.mjs';
+
+class NamedNodeMap {
+  [CHILD] = null;
+  constructor(ownerElement) {
+    this[OWNER_ELEMENT] = ownerElement;
+  }
+  getNamedItem(name) {
+    return this.getNamedItemNS(null, name);
+  }
+  getNamedItemNS(namespaceURI, name) {
+    let attr = this[CHILD];
+    while (attr) {
+      if (attr.name === name && attr[NS] == namespaceURI) {
+        return attr;
+      }
+      attr = attr[NEXT];
+    }
+    return null;
+  }
+  item(index) {
+    let attr = this[CHILD];
+    let i = 0;
+    while (attr) {
+      if (i++ === index) return attr;
+      attr = attr[NEXT];
+    }
+    return null;
+  }
+  get length() {
+    let index = 0;
+    let attr = this[CHILD];
+    while (attr) {
+      index++;
+      attr = attr[NEXT];
+    }
+    return index;
+  }
+  removeNamedItem(name) {
+    return this.removeNamedItemNS(null, name);
+  }
+  removeNamedItemNS(namespaceURI, name) {
+    const ownerElement = this[OWNER_ELEMENT];
+    let attr = this[CHILD];
+    let prev = null;
+    while (attr != null) {
+      if (attr.name === name && attr[NS] == namespaceURI) {
+        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);
+        return attr;
+      }
+      prev = attr;
+      attr = attr[NEXT];
+    }
+    return null;
+  }
+  setNamedItem(attr) {
+    const ownerElement = this[OWNER_ELEMENT];
+    let old = null;
+    let child = this[CHILD];
+    attr[OWNER_ELEMENT] = ownerElement;
+    if (child == null) {
+      this[CHILD] = attr;
+      // return null;
+    } else {
+      let prev;
+      while (child) {
+        if (child.name === attr.name && child[NS] == attr[NS]) {
+          if (prev) prev[NEXT] = attr;else this[CHILD] = attr;
+          attr[NEXT] = child[NEXT];
+          child[NEXT] = null;
+          old = child;
+          break;
+          // return child;
+        }
+
+        prev = child;
+        child = child[NEXT];
+      }
+      if (prev) prev[NEXT] = attr;else this[CHILD] = attr;
+      // return null;
+    }
+
+    // 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]);
+    }
+    return old;
+  }
+  setNamedItemNS(attr) {
+    return this.setNamedItem(attr);
+  }
+  *[Symbol.iterator]() {
+    let attr = this[CHILD];
+    while (attr) {
+      yield attr;
+      attr = attr[NEXT];
+    }
+  }
+}
+function updateElementAttribute(element, name, oldValue, newValue) {
+  const {
+    observedAttributes
+  } = element.constructor;
+  const {
+    attributeChangedCallback
+  } = element;
+  if (name === 'slot' && element.slot !== newValue) {
+    element.slot = newValue ?? '';
+  }
+  if (attributeChangedCallback == null || observedAttributes == null || !observedAttributes.includes(name)) {
+    return;
+  }
+  return attributeChangedCallback.call(element, name, oldValue, newValue);
+}
+
+export { NamedNodeMap };

package/build/esm/Node.mjs

@@ -0,0 +1,100 @@
+import { NodeType, NAME, PARENT, CHILD, PREV, NEXT, OWNER_DOCUMENT, NamespaceURI } from './constants.mjs';
+import { EventTarget } from './EventTarget.mjs';
+import { isCharacterData, isParentNode, cloneNode, isTextNode } from './shared.mjs';
+
+class Node extends EventTarget {
+  nodeType = NodeType.NODE;
+  [NAME] = '';
+  [PARENT] = null;
+  [CHILD] = null;
+  [PREV] = null;
+  [NEXT] = null;
+  get localName() {
+    return this[NAME];
+  }
+  get nodeName() {
+    return this[NAME].toUpperCase();
+  }
+  get ownerDocument() {
+    return this[OWNER_DOCUMENT];
+  }
+  isDefaultNamespace(namespace) {
+    return namespace === NamespaceURI.XHTML;
+  }
+  get parentNode() {
+    return this[PARENT];
+  }
+  set parentNode(_readonly) {}
+  get previousSibling() {
+    return this[PREV];
+  }
+  set previousSibling(_readonly) {}
+  get nextSibling() {
+    return this[NEXT];
+  }
+  set nextSibling(_readonly) {}
+  get previousElementSibling() {
+    let sib = this[PREV];
+    while (sib && sib.nodeType !== 1) sib = sib[PREV];
+    return sib;
+  }
+  set previousElementSibling(_readonly) {}
+  get nextElementSibling() {
+    let sib = this[NEXT];
+    while (sib && sib.nodeType !== 1) sib = sib[NEXT];
+    return sib;
+  }
+  set nextElementSibling(_readonly) {}
+  get firstChild() {
+    return this[CHILD];
+  }
+  set firstChild(_readonly) {}
+  get lastChild() {
+    let child = this[CHILD];
+    while (child) {
+      const next = child[NEXT];
+      if (next == null) break;
+      child = next;
+    }
+    return child;
+  }
+  set lastChild(_readonly) {}
+  get nodeValue() {
+    if (isCharacterData(this)) return this.data;
+    return null;
+  }
+  set nodeValue(data) {
+    if (isCharacterData(this)) this.data = data;
+  }
+  get textContent() {
+    if (isCharacterData(this)) return this.data;
+    let text = '';
+    function walk(node) {
+      if (isTextNode(node)) {
+        text += node.data;
+      }
+      const child = node[CHILD];
+      if (child) walk(child);
+      const sibling = node[NEXT];
+      if (sibling) walk(sibling);
+    }
+    walk(this);
+    return text;
+  }
+  set textContent(data) {
+    if (isCharacterData(this)) {
+      this.data = data;
+    } else if (isParentNode(this)) {
+      let child;
+      while (child = this[CHILD]) {
+        this.removeChild(child);
+      }
+      this.append(data);
+    }
+  }
+  cloneNode(deep) {
+    return cloneNode(this, deep);
+  }
+}
+
+export { Node };

package/build/esm/NodeList.mjs

@@ -0,0 +1,7 @@
+class NodeList extends Array {
+  item(index) {
+    return this[index];
+  }
+}
+
+export { NodeList };

package/build/esm/ParentNode.mjs

@@ -0,0 +1,128 @@
+import { hooks } from './hooks.mjs';
+import { PREV, NEXT, CHILD, NodeType, OWNER_DOCUMENT, PARENT } from './constants.mjs';
+import { ChildNode, toNode } from './ChildNode.mjs';
+import { NodeList } from './NodeList.mjs';
+import { querySelectorAll, querySelector } from './selectors.mjs';
+
+class ParentNode extends ChildNode {
+  childNodes = new NodeList();
+  children = new NodeList();
+  appendChild(child) {
+    this.insertInto(child, null);
+  }
+  insertBefore(child, ref) {
+    this.insertInto(child, ref || null);
+  }
+  append(...nodes) {
+    for (const child of nodes) {
+      if (child == null) continue;
+      this.appendChild(toNode(this, child));
+    }
+  }
+  prepend(...nodes) {
+    const before = this.firstChild;
+    for (const child of nodes) {
+      if (child == null) continue;
+      this.insertBefore(toNode(this, child), before);
+    }
+  }
+  replaceChildren(...nodes) {
+    let child;
+    while (child = this.firstChild) {
+      this.removeChild(child);
+    }
+    this.append(...nodes);
+  }
+  removeChild(child) {
+    if (child.parentNode !== this) throw Error(`not a child of this node`);
+    const prev = child[PREV];
+    const next = child[NEXT];
+    if (prev) prev[NEXT] = next;else this[CHILD] = next;
+    if (next) next[PREV] = prev;
+    const childNodes = this.childNodes;
+    const childNodesIndex = childNodes.indexOf(child);
+    childNodes.splice(childNodesIndex, 1);
+    if (child.nodeType === 1) {
+      const children = this.children;
+      children.splice(children.indexOf(child), 1);
+    }
+    hooks.removeChild?.(this, child, childNodesIndex);
+  }
+  replaceChild(newChild, oldChild) {
+    if (oldChild.parentNode !== this) {
+      throw Error('reference node is not a child of this parent');
+    }
+    const next = oldChild[NEXT];
+    this.removeChild(oldChild);
+    this.insertInto(newChild, next);
+  }
+  querySelectorAll(selector) {
+    return querySelectorAll(this, selector);
+  }
+  querySelector(selector) {
+    return querySelector(this, selector);
+  }
+  insertInto(child, before) {
+    // append the children of a DocumentFragment:
+    if (child.nodeType === NodeType.DOCUMENT_FRAGMENT_NODE) {
+      let node = child[CHILD];
+      while (node) {
+        const next = node[NEXT];
+        this.insertInto(node, before);
+        node = next;
+      }
+      return;
+    }
+    if (child.parentNode !== null) {
+      child.parentNode.removeChild(child);
+    }
+    if (before) {
+      if (before.parentNode !== this) {
+        throw Error('reference node is not a child of this parent');
+      }
+      child[NEXT] = before;
+      child[PREV] = before[PREV];
+      if (before[PREV] === null) this[CHILD] = child;
+      before[PREV] = child;
+    } else {
+      child[NEXT] = null;
+      let last = this[CHILD];
+      if (last) {
+        let next;
+        while (next = last[NEXT]) last = next;
+        last[NEXT] = child;
+        child[PREV] = last;
+      } else {
+        this[CHILD] = child;
+        child[PREV] = null;
+      }
+    }
+    const ownerDocument = this[OWNER_DOCUMENT];
+    const isElement = child.nodeType === NodeType.ELEMENT_NODE;
+    child[PARENT] = this;
+    child[OWNER_DOCUMENT] = ownerDocument;
+    const childNodes = this.childNodes;
+    let insertIndex;
+    if (before) {
+      insertIndex = childNodes.indexOf(before);
+      childNodes.splice(insertIndex, 0, child);
+      if (isElement) {
+        const children = this.children;
+        let ref = before;
+        while (ref && ref.nodeType !== 1) ref = ref[NEXT];
+        if (ref) {
+          children.splice(children.indexOf(ref), 0, child);
+        } else {
+          children.push(child);
+        }
+      }
+    } else {
+      insertIndex = childNodes.length;
+      childNodes.push(child);
+      if (isElement) this.children.push(child);
+    }
+    hooks.insertChild?.(this, child, insertIndex);
+  }
+}
+
+export { ParentNode };

package/build/esm/SVGElement.mjs

@@ -0,0 +1,17 @@
+import { NS, NamespaceURI } from './constants.mjs';
+import { Element } from './Element.mjs';
+
+class SVGElement extends Element {
+  [NS] = NamespaceURI.SVG;
+  get ownerSVGElement() {
+    let root = null;
+    let parent = this.parentNode;
+    while (parent instanceof SVGElement) {
+      root = parent;
+      parent = parent.parentNode;
+    }
+    return root;
+  }
+}
+
+export { SVGElement };

package/build/esm/Text.mjs

@@ -0,0 +1,9 @@
+import { NodeType, NAME } from './constants.mjs';
+import { CharacterData } from './CharacterData.mjs';
+
+class Text extends CharacterData {
+  nodeType = NodeType.TEXT_NODE;
+  [NAME] = '#text';
+}
+
+export { Text };

package/build/esm/Window.mjs

@@ -0,0 +1,66 @@
+import { Document } from './Document.mjs';
+import { Event } from './Event.mjs';
+import { EventTarget } from './EventTarget.mjs';
+import { CustomEvent } from './CustomEvent.mjs';
+import { Node } from './Node.mjs';
+import { ParentNode } from './ParentNode.mjs';
+import { ChildNode } from './ChildNode.mjs';
+import { Element } from './Element.mjs';
+import { HTMLElement } from './HTMLElement.mjs';
+import { SVGElement } from './SVGElement.mjs';
+import { CharacterData } from './CharacterData.mjs';
+import { Text } from './Text.mjs';
+import { Comment } from './Comment.mjs';
+import { DocumentFragment } from './DocumentFragment.mjs';
+import { HTMLTemplateElement } from './HTMLTemplateElement.mjs';
+import { CustomElementRegistryImplementation } from './CustomElementRegistry.mjs';
+import { MutationObserver } from './MutationObserver.mjs';
+
+class Window extends EventTarget {
+  name = '';
+  parent = this;
+  self = this;
+  top = this;
+  document = new Document(this);
+  customElements = new CustomElementRegistryImplementation();
+  location = globalThis.location;
+  navigator = globalThis.navigator;
+  Event = Event;
+  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;
+  static setGlobal(window) {
+    const properties = Object.getOwnPropertyDescriptors(window);
+    delete properties.self;
+    Object.defineProperties(globalThis, {
+      ...properties,
+      window: {
+        value: window
+      }
+    });
+    if (typeof self === 'undefined') {
+      Object.defineProperty(globalThis, 'self', {
+        value: window
+      });
+    } else {
+      // 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);
+    }
+  }
+}
+
+export { Window };

package/build/esm/constants.mjs

@@ -0,0 +1,39 @@
+const NAME = Symbol('name');
+const VALUE = Symbol('value');
+const NS = Symbol('ns');
+const OWNER_ELEMENT = Symbol('owner');
+const OWNER_DOCUMENT = Symbol('owner_document');
+const ATTRIBUTES = Symbol('attributes');
+const PREV = Symbol('prev');
+const NEXT = Symbol('next');
+const CHILD = Symbol('child');
+const PARENT = Symbol('parent');
+const DATA = Symbol('data');
+const LISTENERS = Symbol('listeners');
+const IS_TRUSTED = Symbol('isTrusted');
+const CONTENT = Symbol('content');
+const SLOT = Symbol('slot');
+
+// @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, IS_TRUSTED, LISTENERS, NAME, NEXT, NS, NamespaceURI, NodeType, OWNER_DOCUMENT, OWNER_ELEMENT, PARENT, PREV, SLOT, VALUE };

package/build/esm/hooks.mjs

@@ -0,0 +1,3 @@
+const hooks = {};
+
+export { hooks };

package/build/esm/index.mjs

@@ -0,0 +1,2 @@
+export { hooks } from './hooks.mjs';
+export { Window } from './Window.mjs';