@remote-dom/polyfill 0.0.1

package/build/cjs/HTMLTemplateElement.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+var constants = require('./constants.cjs');
+var Element = require('./Element.cjs');
+var serialization = require('./serialization.cjs');
+
+class HTMLTemplateElement extends Element.Element {
+  get content() {
+    let content = this[constants.CONTENT];
+    if (!content) {
+      content = this.ownerDocument.createDocumentFragment();
+      this[constants.CONTENT] = content;
+    }
+    return content;
+  }
+  set content(_) {}
+  set innerHTML(html) {
+    this.content.replaceChildren(serialization.parseHtml(String(html), this));
+  }
+  get innerHTML() {
+    const content = this[constants.CONTENT];
+    return content ? serialization.serializeChildren(content) : '';
+  }
+}
+
+exports.HTMLTemplateElement = HTMLTemplateElement;

package/build/cjs/MutationObserver.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+class MutationObserver {
+  // stub implementation
+}
+
+exports.MutationObserver = MutationObserver;

package/build/cjs/NamedNodeMap.cjs

@@ -0,0 +1,115 @@
+'use strict';
+
+var hooks = require('./hooks.cjs');
+var constants = require('./constants.cjs');
+
+class NamedNodeMap {
+  [constants.CHILD] = null;
+  constructor(ownerElement) {
+    this[constants.OWNER_ELEMENT] = ownerElement;
+  }
+  getNamedItem(name) {
+    return this.getNamedItemNS(null, name);
+  }
+  getNamedItemNS(namespaceURI, name) {
+    let attr = this[constants.CHILD];
+    while (attr) {
+      if (attr.name === name && attr[constants.NS] == namespaceURI) {
+        return attr;
+      }
+      attr = attr[constants.NEXT];
+    }
+    return null;
+  }
+  item(index) {
+    let attr = this[constants.CHILD];
+    let i = 0;
+    while (attr) {
+      if (i++ === index) return attr;
+      attr = attr[constants.NEXT];
+    }
+    return null;
+  }
+  get length() {
+    let index = 0;
+    let attr = this[constants.CHILD];
+    while (attr) {
+      index++;
+      attr = attr[constants.NEXT];
+    }
+    return index;
+  }
+  removeNamedItem(name) {
+    return this.removeNamedItemNS(null, name);
+  }
+  removeNamedItemNS(namespaceURI, name) {
+    const ownerElement = this[constants.OWNER_ELEMENT];
+    let attr = this[constants.CHILD];
+    let prev = null;
+    while (attr != null) {
+      if (attr.name === name && attr[constants.NS] == namespaceURI) {
+        if (prev) prev[constants.NEXT] = attr[constants.NEXT];
+        if (this[constants.CHILD] === attr) this[constants.CHILD] = attr[constants.NEXT];
+        updateElementAttribute(ownerElement, attr.name, attr.value, null);
+        hooks.hooks.removeAttribute?.(ownerElement, name, namespaceURI);
+        return attr;
+      }
+      prev = attr;
+      attr = attr[constants.NEXT];
+    }
+    return null;
+  }
+  setNamedItem(attr) {
+    const ownerElement = this[constants.OWNER_ELEMENT];
+    let old = null;
+    let child = this[constants.CHILD];
+    attr[constants.OWNER_ELEMENT] = ownerElement;
+    if (child == null) {
+      this[constants.CHILD] = attr;
+      // return null;
+    } else {
+      let prev;
+      while (child) {
+        if (child.name === attr.name && child[constants.NS] == attr[constants.NS]) {
+          if (prev) prev[constants.NEXT] = attr;else this[constants.CHILD] = attr;
+          attr[constants.NEXT] = child[constants.NEXT];
+          child[constants.NEXT] = null;
+          old = child;
+          break;
+          // return child;
+        }
+
+        prev = child;
+        child = child[constants.NEXT];
+      }
+      if (prev) prev[constants.NEXT] = attr;else this[constants.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.hooks.setAttribute?.(ownerElement, attr.name, attr.value, attr[constants.NS]);
+    }
+    return old;
+  }
+  setNamedItemNS(attr) {
+    return this.setNamedItem(attr);
+  }
+}
+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);
+}
+
+exports.NamedNodeMap = NamedNodeMap;

package/build/cjs/Node.cjs

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

package/build/cjs/NodeList.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+class NodeList extends Array {
+  item(index) {
+    return this[index];
+  }
+}
+
+exports.NodeList = NodeList;

package/build/cjs/ParentNode.cjs

@@ -0,0 +1,130 @@
+'use strict';
+
+var hooks = require('./hooks.cjs');
+var constants = require('./constants.cjs');
+var ChildNode = require('./ChildNode.cjs');
+var NodeList = require('./NodeList.cjs');
+var selectors = require('./selectors.cjs');
+
+class ParentNode extends ChildNode.ChildNode {
+  childNodes = new NodeList.NodeList();
+  children = new NodeList.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(ChildNode.toNode(this, child));
+    }
+  }
+  prepend(...nodes) {
+    const before = this.firstChild;
+    for (const child of nodes) {
+      if (child == null) continue;
+      this.insertBefore(ChildNode.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[constants.PREV];
+    const next = child[constants.NEXT];
+    if (prev) prev[constants.NEXT] = next;else this[constants.CHILD] = next;
+    if (next) next[constants.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.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[constants.NEXT];
+    this.removeChild(oldChild);
+    this.insertInto(newChild, next);
+  }
+  querySelectorAll(selector) {
+    return selectors.querySelectorAll(this, selector);
+  }
+  querySelector(selector) {
+    return selectors.querySelector(this, selector);
+  }
+  insertInto(child, before) {
+    // append the children of a DocumentFragment:
+    if (child.nodeType === constants.NodeType.DOCUMENT_FRAGMENT_NODE) {
+      let node = child[constants.CHILD];
+      while (node) {
+        const next = node[constants.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[constants.NEXT] = before;
+      child[constants.PREV] = before[constants.PREV];
+      if (before[constants.PREV] === null) this[constants.CHILD] = child;
+      before[constants.PREV] = child;
+    } else {
+      child[constants.NEXT] = null;
+      let last = this[constants.CHILD];
+      if (last) {
+        let next;
+        while (next = last[constants.NEXT]) last = next;
+        last[constants.NEXT] = child;
+        child[constants.PREV] = last;
+      } else {
+        this[constants.CHILD] = child;
+        child[constants.PREV] = null;
+      }
+    }
+    const ownerDocument = this[constants.OWNER_DOCUMENT];
+    const isElement = child.nodeType === constants.NodeType.ELEMENT_NODE;
+    child[constants.PARENT] = this;
+    child[constants.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[constants.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.hooks.insertChild?.(this, child, insertIndex);
+  }
+}
+
+exports.ParentNode = ParentNode;

package/build/cjs/SVGElement.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var constants = require('./constants.cjs');
+var Element = require('./Element.cjs');
+
+class SVGElement extends Element.Element {
+  [constants.NS] = constants.NamespaceURI.SVG;
+  get ownerSVGElement() {
+    let root = null;
+    let parent = this.parentNode;
+    while (parent instanceof SVGElement) {
+      root = parent;
+      parent = parent.parentNode;
+    }
+    return root;
+  }
+}
+
+exports.SVGElement = SVGElement;

package/build/cjs/Text.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var constants = require('./constants.cjs');
+var CharacterData = require('./CharacterData.cjs');
+
+class Text extends CharacterData.CharacterData {
+  nodeType = constants.NodeType.TEXT_NODE;
+  [constants.NAME] = '#text';
+}
+
+exports.Text = Text;

package/build/cjs/Window.cjs

@@ -0,0 +1,69 @@
+'use strict';
+
+var Document = require('./Document.cjs');
+var Event = require('./Event.cjs');
+var EventTarget = require('./EventTarget.cjs');
+var CustomEvent = require('./CustomEvent.cjs');
+var Node = require('./Node.cjs');
+var ParentNode = require('./ParentNode.cjs');
+var ChildNode = require('./ChildNode.cjs');
+var Element = require('./Element.cjs');
+var HTMLElement = require('./HTMLElement.cjs');
+var SVGElement = require('./SVGElement.cjs');
+var CharacterData = require('./CharacterData.cjs');
+var Text = require('./Text.cjs');
+var Comment = require('./Comment.cjs');
+var DocumentFragment = require('./DocumentFragment.cjs');
+var HTMLTemplateElement = require('./HTMLTemplateElement.cjs');
+var CustomElementRegistry = require('./CustomElementRegistry.cjs');
+var MutationObserver = require('./MutationObserver.cjs');
+
+class Window extends EventTarget.EventTarget {
+  name = '';
+  parent = this;
+  self = this;
+  top = this;
+  document = new Document.Document(this);
+  customElements = new CustomElementRegistry.CustomElementRegistryImplementation();
+  location = globalThis.location;
+  navigator = globalThis.navigator;
+  Event = Event.Event;
+  Node = Node.Node;
+  ParentNode = ParentNode.ParentNode;
+  ChildNode = ChildNode.ChildNode;
+  EventTarget = EventTarget.EventTarget;
+  CustomEvent = CustomEvent.CustomEvent;
+  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;
+}
+function installWindowAsGlobal(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);
+  }
+}
+
+exports.Window = Window;
+exports.installWindowAsGlobal = installWindowAsGlobal;

package/build/cjs/constants.cjs

@@ -0,0 +1,57 @@
+'use strict';
+
+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;
+}({});
+
+exports.ATTRIBUTES = ATTRIBUTES;
+exports.CHILD = CHILD;
+exports.CONTENT = CONTENT;
+exports.DATA = DATA;
+exports.IS_TRUSTED = IS_TRUSTED;
+exports.LISTENERS = LISTENERS;
+exports.NAME = NAME;
+exports.NEXT = NEXT;
+exports.NS = NS;
+exports.NamespaceURI = NamespaceURI;
+exports.NodeType = NodeType;
+exports.OWNER_DOCUMENT = OWNER_DOCUMENT;
+exports.OWNER_ELEMENT = OWNER_ELEMENT;
+exports.PARENT = PARENT;
+exports.PREV = PREV;
+exports.SLOT = SLOT;
+exports.VALUE = VALUE;

package/build/cjs/hooks.cjs

@@ -0,0 +1,5 @@
+'use strict';
+
+const hooks = {};
+
+exports.hooks = hooks;

package/build/cjs/index.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var hooks = require('./hooks.cjs');
+var Window = require('./Window.cjs');
+
+
+
+exports.hooks = hooks.hooks;
+exports.Window = Window.Window;
+exports.installWindowAsGlobal = Window.installWindowAsGlobal;