@remote-dom/polyfill 0.0.1

package/build/esm/Element.mjs

@@ -0,0 +1,95 @@
+import { NodeType, NS, NamespaceURI, SLOT, ATTRIBUTES } from './constants.mjs';
+import { ParentNode } from './ParentNode.mjs';
+import { NamedNodeMap } from './NamedNodeMap.mjs';
+import { Attr } from './Attr.mjs';
+import { serializeNode, serializeChildren, parseHtml } from './serialization.mjs';
+
+class Element extends ParentNode {
+  nodeType = NodeType.ELEMENT_NODE;
+  [NS] = NamespaceURI.XHTML;
+  [SLOT] = '';
+  get namespaceURI() {
+    return this[NS];
+  }
+  get tagName() {
+    return this.nodeName;
+  }
+  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/esm/Event.mjs

@@ -0,0 +1,108 @@
+import { IS_TRUSTED, LISTENERS } from './constants.mjs';
+
+let EventPhase = /*#__PURE__*/function (EventPhase) {
+  EventPhase[EventPhase["NONE"] = 0] = "NONE";
+  EventPhase[EventPhase["CAPTURING_PHASE"] = 1] = "CAPTURING_PHASE";
+  EventPhase[EventPhase["AT_TARGET"] = 2] = "AT_TARGET";
+  EventPhase[EventPhase["BUBBLING_PHASE"] = 3] = "BUBBLING_PHASE";
+  return EventPhase;
+}({});
+const CAPTURE_MARKER = '@';
+const now = typeof performance === 'undefined' ? Date.now : performance.now.bind(performance);
+class Event {
+  static NONE = EventPhase.NONE;
+  static CAPTURING_PHASE = EventPhase.CAPTURING_PHASE;
+  static AT_TARGET = EventPhase.AT_TARGET;
+  static BUBBLING_PHASE = EventPhase.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;
+
+  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;
+    }
+  }
+  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 === EventPhase.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/esm/EventTarget.mjs

@@ -0,0 +1,99 @@
+import { hooks } from './hooks.mjs';
+import { LISTENERS } from './constants.mjs';
+import { fireEvent, EventPhase, CAPTURE_MARKER } from './Event.mjs';
+
+const ONCE_LISTENERS = Symbol('onceListeners');
+class EventTarget {
+  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 : undefined;
+    const key = `${type}${capture ? CAPTURE_MARKER : ''}`;
+    let normalizedListener = listener;
+    if (once) {
+      normalizedListener = function normalizedListener(...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 = new WeakMap();
+        this[ONCE_LISTENERS] = onceListeners;
+      }
+      onceListeners.set(listener, normalizedListener);
+    }
+    let listeners = this[LISTENERS];
+    if (!listeners) {
+      listeners = new Map();
+      this[LISTENERS] = listeners;
+    }
+    let list = listeners.get(key);
+    if (!list) {
+      list = 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 = [];
+    // instanceof here is just to keep TypeScript happy
+    let target = this;
+    while (target != null) {
+      path.push(target);
+      target = target.parentNode;
+    }
+    // while (target instanceof Node && (target = target.parentNode)) {
+    //   path.push(target);
+    // }
+    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/esm/HTMLElement.mjs

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

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 };