@remote-dom/polyfill 0.0.1

package/build/esnext/Document.esnext

@@ -0,0 +1,86 @@
+import { OWNER_DOCUMENT, NodeType, NAME, NamespaceURI, NS } from './constants.esnext';
+import { Event } from './Event.esnext';
+import { ParentNode } from './ParentNode.esnext';
+import { Element } from './Element.esnext';
+import { SVGElement } from './SVGElement.esnext';
+import { Text } from './Text.esnext';
+import { Comment } from './Comment.esnext';
+import { DocumentFragment } from './DocumentFragment.esnext';
+import { HTMLTemplateElement } from './HTMLTemplateElement.esnext';
+import { cloneNode, isParentNode } from './shared.esnext';
+
+class Document extends ParentNode {
+  constructor(defaultView) {
+    super();
+    this.defaultView = defaultView;
+    this[OWNER_DOCUMENT] = this;
+  }
+  nodeType = NodeType.DOCUMENT_NODE;
+  [NAME] = "#document";
+  createElement(localName) {
+    const lowerName = String(localName).toLowerCase();
+    if (lowerName === "template") {
+      return createElement(new HTMLTemplateElement(), this, "template");
+    }
+    const CustomElement = this.defaultView.customElements.get(localName);
+    if (CustomElement) {
+      return createElement(new CustomElement(), this, localName);
+    } else {
+      return createElement(new Element(), this, localName);
+    }
+  }
+  createElementNS(localName, namespaceURI) {
+    if (namespaceURI === NamespaceURI.SVG) {
+      return createElement(new SVGElement(), this, localName);
+    }
+    return createElement(new Element(), this, localName, namespaceURI);
+  }
+  createTextNode(data) {
+    return createNode(new Text(data), this);
+  }
+  createComment(data) {
+    return createNode(new Comment(data), this);
+  }
+  createDocumentFragment() {
+    return createNode(new DocumentFragment(), this);
+  }
+  createEvent() {
+    return new Event("");
+  }
+  importNode(node, deep) {
+    return cloneNode(node, deep, this);
+  }
+  adoptNode(node) {
+    if (node[OWNER_DOCUMENT] === this)
+      return node;
+    node.parentNode?.removeChild(node);
+    adoptNode(node, this);
+    return node;
+  }
+}
+function createNode(node, ownerDocument) {
+  Object.defineProperty(node, OWNER_DOCUMENT, {
+    value: ownerDocument,
+    writable: true,
+    enumerable: false
+  });
+  return node;
+}
+function createElement(element, ownerDocument, name, namespace) {
+  createNode(element, ownerDocument);
+  Object.defineProperty(element, NAME, { value: name });
+  if (namespace) {
+    Object.defineProperty(element, NS, { value: namespace });
+  }
+  return element;
+}
+function adoptNode(node, document) {
+  node[OWNER_DOCUMENT] = document;
+  if (isParentNode(node)) {
+    for (const child of node.childNodes) {
+      adoptNode(child, document);
+    }
+  }
+}
+
+export { Document, adoptNode, createElement, createNode };

package/build/esnext/DocumentFragment.esnext

@@ -0,0 +1,10 @@
+import { NodeType, NAME, OWNER_DOCUMENT } from './constants.esnext';
+import { ParentNode } from './ParentNode.esnext';
+
+class DocumentFragment extends ParentNode {
+  nodeType = NodeType.DOCUMENT_FRAGMENT_NODE;
+  [NAME] = "#document-fragment";
+  [OWNER_DOCUMENT] = window.document;
+}
+
+export { DocumentFragment };

package/build/esnext/Element.esnext

@@ -0,0 +1,99 @@
+import { NodeType, NS, NamespaceURI, SLOT, ATTRIBUTES } from './constants.esnext';
+import { ParentNode } from './ParentNode.esnext';
+import { NamedNodeMap } from './NamedNodeMap.esnext';
+import { Attr } from './Attr.esnext';
+import { serializeNode, serializeChildren, parseHtml } from './serialization.esnext';
+
+class Element extends ParentNode {
+  static observedAttributes;
+  nodeType = NodeType.ELEMENT_NODE;
+  [NS] = NamespaceURI.XHTML;
+  [SLOT] = "";
+  get namespaceURI() {
+    return this[NS];
+  }
+  get tagName() {
+    return this.nodeName;
+  }
+  [ATTRIBUTES];
+  get slot() {
+    return this[SLOT];
+  }
+  set slot(slot) {
+    const finalSlot = String(slot);
+    this[SLOT] = finalSlot;
+    if (this.getAttribute("slot") !== finalSlot) {
+      this.attributes.setNamedItem(new Attr("slot", finalSlot));
+    }
+  }
+  get attributes() {
+    let attributes = this[ATTRIBUTES];
+    if (!attributes) {
+      attributes = new NamedNodeMap(this);
+      this[ATTRIBUTES] = attributes;
+    }
+    return attributes;
+  }
+  get firstElementChild() {
+    return this.children[0] ?? null;
+  }
+  get lastElementChild() {
+    return this.children[this.children.length - 1] ?? null;
+  }
+  get nextElementSibling() {
+    let sib = this.nextSibling;
+    while (sib && sib.nodeType !== 1)
+      sib = sib.nextSibling;
+    return sib;
+  }
+  get previewElementSibling() {
+    let sib = this.previousSibling;
+    while (sib && sib.nodeType !== 1)
+      sib = sib.previousSibling;
+    return sib;
+  }
+  setAttribute(name, value) {
+    this.attributes.setNamedItem(new Attr(name, String(value)));
+  }
+  setAttributeNS(namespace, name, value) {
+    this.attributes.setNamedItemNS(new Attr(name, String(value), namespace));
+  }
+  getAttribute(name) {
+    const attr = this.attributes.getNamedItem(name);
+    return attr && attr.value;
+  }
+  getAttributeNS(namespace, name) {
+    const attr = this.attributes.getNamedItemNS(namespace, name);
+    return attr && attr.value;
+  }
+  hasAttribute(name) {
+    const attr = this.attributes.getNamedItem(name);
+    return attr != null;
+  }
+  hasAttributeNS(namespace, name) {
+    const attr = this.attributes.getNamedItemNS(namespace, name);
+    return attr != null;
+  }
+  removeAttribute(name) {
+    this.attributes.removeNamedItem(name);
+  }
+  removeAttributeNS(namespace, name) {
+    this.attributes.removeNamedItemNS(namespace, name);
+  }
+  get outerHTML() {
+    return serializeNode(this);
+  }
+  get innerHTML() {
+    return serializeChildren(this);
+  }
+  set innerHTML(html) {
+    if (html == null || html === "") {
+      this.replaceChildren();
+    } else {
+      const fragment = parseHtml(String(html), this);
+      this.replaceChildren(fragment);
+    }
+  }
+}
+
+export { Element };

package/build/esnext/Event.esnext

@@ -0,0 +1,109 @@
+import { IS_TRUSTED, LISTENERS } from './constants.esnext';
+
+var EventPhase = /* @__PURE__ */ ((EventPhase2) => {
+  EventPhase2[EventPhase2["NONE"] = 0] = "NONE";
+  EventPhase2[EventPhase2["CAPTURING_PHASE"] = 1] = "CAPTURING_PHASE";
+  EventPhase2[EventPhase2["AT_TARGET"] = 2] = "AT_TARGET";
+  EventPhase2[EventPhase2["BUBBLING_PHASE"] = 3] = "BUBBLING_PHASE";
+  return EventPhase2;
+})(EventPhase || {});
+const CAPTURE_MARKER = "@";
+const now = typeof performance === "undefined" ? Date.now : performance.now.bind(performance);
+class Event {
+  constructor(type, options) {
+    this.type = type;
+    Object.defineProperty(this, IS_TRUSTED, { writable: true, value: false });
+    if (options) {
+      if (options.bubbles)
+        this.bubbles = options.bubbles;
+      if (options.cancelable)
+        this.cancelable = options.cancelable;
+      if (options.composed)
+        this.composed = options.composed;
+    }
+  }
+  static NONE = 0 /* NONE */;
+  static CAPTURING_PHASE = 1 /* CAPTURING_PHASE */;
+  static AT_TARGET = 2 /* AT_TARGET */;
+  static BUBBLING_PHASE = 3 /* BUBBLING_PHASE */;
+  // NONE = EventPhase.NONE;
+  // CAPTURING_PHASE = EventPhase.CAPTURING_PHASE;
+  // AT_TARGET = EventPhase.AT_TARGET;
+  // BUBBLING_PHASE = EventPhase.BUBBLING_PHASE;
+  timeStamp = now();
+  target = null;
+  currentTarget = null;
+  srcElement = null;
+  bubbles = false;
+  cancelable = false;
+  composed = false;
+  defaultPrevented = false;
+  cancelBubble = false;
+  immediatePropagationStopped = false;
+  eventPhase = 0;
+  path = [];
+  // private inPassiveListener = false;
+  data;
+  [IS_TRUSTED];
+  get composedPath() {
+    return this.path;
+  }
+  get isTrusted() {
+    return this[IS_TRUSTED];
+  }
+  stopPropagation() {
+    this.cancelBubble = true;
+  }
+  stopImmediatePropagation() {
+    this.immediatePropagationStopped = true;
+  }
+  preventDefault() {
+    this.defaultPrevented = true;
+  }
+  set returnValue(value) {
+    this.defaultPrevented = value;
+  }
+  get returnValue() {
+    return this.defaultPrevented;
+  }
+  /** @deprecated */
+  initEvent(type, bubbles, cancelable) {
+    this.type = type;
+    this.bubbles = Boolean(bubbles);
+    this.cancelable = Boolean(cancelable);
+  }
+}
+function fireEvent(event, target, phase) {
+  const listeners = target[LISTENERS];
+  const list = listeners?.get(
+    `${event.type}${phase === 1 /* CAPTURING_PHASE */ ? CAPTURE_MARKER : ""}`
+  );
+  if (!list)
+    return false;
+  let defaultPrevented = false;
+  for (const listener of list) {
+    event.eventPhase = phase;
+    event.currentTarget = target;
+    try {
+      if (typeof listener === "object") {
+        listener.handleEvent(event);
+      } else {
+        listener.call(target, event);
+      }
+    } catch (err) {
+      setTimeout(thrower, 0, err);
+    }
+    if (event.defaultPrevented === true) {
+      defaultPrevented = true;
+    }
+    if (event.immediatePropagationStopped) {
+      break;
+    }
+  }
+  return defaultPrevented;
+}
+function thrower(error) {
+  throw error;
+}
+
+export { CAPTURE_MARKER, Event, EventPhase, fireEvent };

package/build/esnext/EventTarget.esnext

@@ -0,0 +1,99 @@
+import { hooks } from './hooks.esnext';
+import { LISTENERS } from './constants.esnext';
+import { fireEvent, EventPhase, CAPTURE_MARKER } from './Event.esnext';
+
+const ONCE_LISTENERS = Symbol("onceListeners");
+class EventTarget {
+  [LISTENERS];
+  [ONCE_LISTENERS];
+  addEventListener(type, listener, options) {
+    if (listener == null)
+      return;
+    const capture = options === true || options && options.capture === true;
+    const once = typeof options === "object" && options.once === true;
+    const signal = typeof options === "object" ? options.signal : void 0;
+    const key = `${type}${capture ? CAPTURE_MARKER : ""}`;
+    let normalizedListener = listener;
+    if (once) {
+      normalizedListener = function normalizedListener2(...args) {
+        this.removeEventListener(type, listener, options);
+        return typeof listener === "object" ? listener.handleEvent(...args) : listener.call(this, ...args);
+      };
+      let onceListeners = this[ONCE_LISTENERS];
+      if (!onceListeners) {
+        onceListeners = /* @__PURE__ */ new WeakMap();
+        this[ONCE_LISTENERS] = onceListeners;
+      }
+      onceListeners.set(listener, normalizedListener);
+    }
+    let listeners = this[LISTENERS];
+    if (!listeners) {
+      listeners = /* @__PURE__ */ new Map();
+      this[LISTENERS] = listeners;
+    }
+    let list = listeners.get(key);
+    if (!list) {
+      list = /* @__PURE__ */ new Set();
+      listeners.set(key, list);
+    }
+    list.add(normalizedListener);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        removeEventListener.call(this, type, listener, options);
+      },
+      { once: true }
+    );
+    hooks.addEventListener?.(this, type, listener, options);
+  }
+  removeEventListener(type, listener, options) {
+    return removeEventListener.call(this, type, listener, options);
+  }
+  // function isChildNode(node: EventTarget): node is ChildNode {
+  //   return PARENT in node;
+  // }
+  dispatchEvent(event) {
+    const path = [];
+    let target = this;
+    while (target != null) {
+      path.push(target);
+      target = target.parentNode;
+    }
+    event.target = this;
+    event.srcElement = this;
+    event.path = path;
+    let defaultPrevented = false;
+    for (let i = path.length; --i; ) {
+      if (fireEvent(event, path[i], EventPhase.CAPTURING_PHASE)) {
+        defaultPrevented = true;
+      }
+    }
+    if (fireEvent(event, this, EventPhase.AT_TARGET)) {
+      defaultPrevented = true;
+    }
+    for (let i = 1; i < path.length; i++) {
+      if (fireEvent(event, path[i], EventPhase.BUBBLING_PHASE)) {
+        defaultPrevented = true;
+      }
+    }
+    return !defaultPrevented;
+  }
+}
+function removeEventListener(type, listener, options) {
+  if (listener == null)
+    return;
+  const onceListeners = this[ONCE_LISTENERS];
+  const normalizedListener = onceListeners?.get(listener) ?? listener;
+  onceListeners?.delete(listener);
+  const capture = options === true || options && options.capture === true;
+  const key = `${type}${capture ? CAPTURE_MARKER : ""}`;
+  const list = this[LISTENERS]?.get(key);
+  if (list) {
+    const deleted = list.delete(normalizedListener);
+    if (deleted) {
+      hooks.removeEventListener?.(this, type, listener, options);
+    }
+  }
+}
+
+export { EventTarget };

package/build/esnext/HTMLElement.esnext

@@ -0,0 +1,6 @@
+import { Element } from './Element.esnext';
+
+class HTMLElement extends Element {
+}
+
+export { HTMLElement };

package/build/esnext/HTMLTemplateElement.esnext

@@ -0,0 +1,26 @@
+import { CONTENT } from './constants.esnext';
+import { Element } from './Element.esnext';
+import { parseHtml, serializeChildren } from './serialization.esnext';
+
+class HTMLTemplateElement extends Element {
+  [CONTENT];
+  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/esnext/MutationObserver.esnext

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

package/build/esnext/NamedNodeMap.esnext

@@ -0,0 +1,131 @@
+import { hooks } from './hooks.esnext';
+import { CHILD, OWNER_ELEMENT, NS, NEXT } from './constants.esnext';
+
+class NamedNodeMap {
+  [CHILD] = null;
+  [OWNER_ELEMENT];
+  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;
+    } 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;
+        }
+        prev = child;
+        child = child[NEXT];
+      }
+      if (prev)
+        prev[NEXT] = attr;
+      else
+        this[CHILD] = attr;
+    }
+    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/esnext/Node.esnext

@@ -0,0 +1,116 @@
+import { NodeType, OWNER_DOCUMENT, NAME, PARENT, CHILD, PREV, NEXT, NamespaceURI } from './constants.esnext';
+import { EventTarget } from './EventTarget.esnext';
+import { isCharacterData, isParentNode, cloneNode, isTextNode } from './shared.esnext';
+
+class Node extends EventTarget {
+  nodeType = NodeType.NODE;
+  [OWNER_DOCUMENT];
+  [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/esnext/NodeList.esnext

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