@remote-dom/polyfill 0.0.1 → 0.1.0

package/build/cjs/Element.cjs

@@ -1,81 +0,0 @@
-'use strict';
-
-var constants = require('./constants.cjs');
-var ParentNode = require('./ParentNode.cjs');
-var NamedNodeMap = require('./NamedNodeMap.cjs');
-var Attr = require('./Attr.cjs');
-var serialization = require('./serialization.cjs');
-
-class Element extends ParentNode.ParentNode {
-  nodeType = constants.NodeType.ELEMENT_NODE;
-  [constants.NS] = constants.NamespaceURI.XHTML;
-  [constants.SLOT] = '';
-  get namespaceURI() {
-    return this[constants.NS];
-  }
-  get tagName() {
-    return this.nodeName;
-  }
-  get slot() {
-    return this[constants.SLOT];
-  }
-  set slot(slot) {
-    const finalSlot = String(slot);
-    this[constants.SLOT] = finalSlot;
-    if (this.getAttribute('slot') !== finalSlot) {
-      this.attributes.setNamedItem(new Attr.Attr('slot', finalSlot));
-    }
-  }
-  get attributes() {
-    let attributes = this[constants.ATTRIBUTES];
-    if (!attributes) {
-      attributes = new NamedNodeMap.NamedNodeMap(this);
-      this[constants.ATTRIBUTES] = attributes;
-    }
-    return attributes;
-  }
-  setAttribute(name, value) {
-    this.attributes.setNamedItem(new Attr.Attr(name, String(value)));
-  }
-  setAttributeNS(namespace, name, value) {
-    this.attributes.setNamedItemNS(new Attr.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 serialization.serializeNode(this);
-  }
-  get innerHTML() {
-    return serialization.serializeChildren(this);
-  }
-  set innerHTML(html) {
-    if (html == null || html === '') {
-      this.replaceChildren();
-    } else {
-      const fragment = serialization.parseHtml(String(html), this);
-      this.replaceChildren(fragment);
-    }
-  }
-}
-
-exports.Element = Element;

package/build/cjs/Event.cjs

@@ -1,113 +0,0 @@
-'use strict';
-
-var constants = require('./constants.cjs');
-
-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, constants.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[constants.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[constants.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;
-}
-
-exports.CAPTURE_MARKER = CAPTURE_MARKER;
-exports.Event = Event;
-exports.EventPhase = EventPhase;
-exports.fireEvent = fireEvent;

package/build/cjs/EventTarget.cjs

@@ -1,101 +0,0 @@
-'use strict';
-
-var hooks = require('./hooks.cjs');
-var constants = require('./constants.cjs');
-var Event = require('./Event.cjs');
-
-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 ? Event.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[constants.LISTENERS];
-    if (!listeners) {
-      listeners = new Map();
-      this[constants.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.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 (Event.fireEvent(event, path[i], Event.EventPhase.CAPTURING_PHASE)) {
-        defaultPrevented = true;
-      }
-    }
-    if (Event.fireEvent(event, this, Event.EventPhase.AT_TARGET)) {
-      defaultPrevented = true;
-    }
-    for (let i = 1; i < path.length; i++) {
-      if (Event.fireEvent(event, path[i], Event.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 ? Event.CAPTURE_MARKER : ''}`;
-  const list = this[constants.LISTENERS]?.get(key);
-  if (list) {
-    const deleted = list.delete(normalizedListener);
-    if (deleted) {
-      hooks.hooks.removeEventListener?.(this, type, listener, options);
-    }
-  }
-}
-
-exports.EventTarget = EventTarget;

package/build/cjs/HTMLElement.cjs

@@ -1,7 +0,0 @@
-'use strict';
-
-var Element = require('./Element.cjs');
-
-class HTMLElement extends Element.Element {}
-
-exports.HTMLElement = HTMLElement;

package/build/cjs/HTMLTemplateElement.cjs

@@ -1,26 +0,0 @@
-'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

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

package/build/cjs/NamedNodeMap.cjs

@@ -1,115 +0,0 @@
-'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

@@ -1,102 +0,0 @@
-'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

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

package/build/cjs/ParentNode.cjs

@@ -1,130 +0,0 @@
-'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;