@remote-dom/polyfill 0.0.0-preview-20240219211553

package/build/esnext/ParentNode.esnext

@@ -0,0 +1,138 @@
+import { hooks } from './hooks.esnext';
+import { PREV, NEXT, CHILD, NodeType, OWNER_DOCUMENT, PARENT } from './constants.esnext';
+import { ChildNode, toNode } from './ChildNode.esnext';
+import { NodeList } from './NodeList.esnext';
+import { querySelectorAll, querySelector } from './selectors.esnext';
+
+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) {
+    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/esnext/SVGElement.esnext

@@ -0,0 +1,17 @@
+import { NS, NamespaceURI } from './constants.esnext';
+import { Element } from './Element.esnext';
+
+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/esnext/Text.esnext

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

package/build/esnext/Window.esnext

@@ -0,0 +1,59 @@
+import { Document } from './Document.esnext';
+import { Event } from './Event.esnext';
+import { EventTarget } from './EventTarget.esnext';
+import { CustomEvent } from './CustomEvent.esnext';
+import { Node } from './Node.esnext';
+import { ParentNode } from './ParentNode.esnext';
+import { ChildNode } from './ChildNode.esnext';
+import { Element } from './Element.esnext';
+import { HTMLElement } from './HTMLElement.esnext';
+import { SVGElement } from './SVGElement.esnext';
+import { CharacterData } from './CharacterData.esnext';
+import { Text } from './Text.esnext';
+import { Comment } from './Comment.esnext';
+import { DocumentFragment } from './DocumentFragment.esnext';
+import { HTMLTemplateElement } from './HTMLTemplateElement.esnext';
+import { CustomElementRegistryImplementation } from './CustomElementRegistry.esnext';
+import { MutationObserver } from './MutationObserver.esnext';
+
+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 {
+      Object.defineProperties(self, properties);
+    }
+  }
+}
+
+export { Window };

package/build/esnext/constants.esnext

@@ -0,0 +1,37 @@
+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");
+var NodeType = /* @__PURE__ */ ((NodeType2) => {
+  NodeType2[NodeType2["NODE"] = 0] = "NODE";
+  NodeType2[NodeType2["ELEMENT_NODE"] = 1] = "ELEMENT_NODE";
+  NodeType2[NodeType2["ATTRIBUTE_NODE"] = 2] = "ATTRIBUTE_NODE";
+  NodeType2[NodeType2["TEXT_NODE"] = 3] = "TEXT_NODE";
+  NodeType2[NodeType2["CDATA_SECTION_NODE"] = 4] = "CDATA_SECTION_NODE";
+  NodeType2[NodeType2["ENTITY_REFERENCE_NODE"] = 5] = "ENTITY_REFERENCE_NODE";
+  NodeType2[NodeType2["ENTITY_NODE"] = 6] = "ENTITY_NODE";
+  NodeType2[NodeType2["PROCESSING_INSTRUCTION_NODE"] = 7] = "PROCESSING_INSTRUCTION_NODE";
+  NodeType2[NodeType2["COMMENT_NODE"] = 8] = "COMMENT_NODE";
+  NodeType2[NodeType2["DOCUMENT_NODE"] = 9] = "DOCUMENT_NODE";
+  NodeType2[NodeType2["DOCUMENT_TYPE_NODE"] = 10] = "DOCUMENT_TYPE_NODE";
+  NodeType2[NodeType2["DOCUMENT_FRAGMENT_NODE"] = 11] = "DOCUMENT_FRAGMENT_NODE";
+  return NodeType2;
+})(NodeType || {});
+var NamespaceURI = /* @__PURE__ */ ((NamespaceURI2) => {
+  NamespaceURI2["XHTML"] = "http://www.w3.org/1999/xhtml";
+  NamespaceURI2["SVG"] = "http://www.w3.org/2000/svg";
+  return NamespaceURI2;
+})(NamespaceURI || {});
+
+export { ATTRIBUTES, CHILD, CONTENT, DATA, IS_TRUSTED, LISTENERS, NAME, NEXT, NS, NamespaceURI, NodeType, OWNER_DOCUMENT, OWNER_ELEMENT, PARENT, PREV, SLOT, VALUE };

package/build/esnext/hooks.esnext

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

package/build/esnext/index.esnext

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

package/build/esnext/selectors.esnext

@@ -0,0 +1,169 @@
+import { CHILD, NEXT, PARENT, PREV } from './constants.esnext';
+import { isElementNode } from './shared.esnext';
+
+const ELEMENT_SELECTOR_TEST = /[a-z]/;
+function querySelector(within, selector) {
+  const parts = parseSelector(selector);
+  let result = null;
+  const child = within[CHILD];
+  if (child && parts[0].matchers.length) {
+    walkNodesForSelector(child, parts, (node) => {
+      result = node;
+      return false;
+    });
+  }
+  return result;
+}
+function querySelectorAll(within, selector) {
+  const parts = parseSelector(selector);
+  const results = [];
+  const child = within[CHILD];
+  if (child && parts[0].matchers.length) {
+    walkNodesForSelector(child, parts, (node) => {
+      results.push(node);
+    });
+  }
+  return results;
+}
+function parseSelector(selector) {
+  let part = { combinator: 4 /* Inner */, matchers: [] };
+  const parts = [part];
+  const tokenizer = /\s*?([>\s+~]?)\s*?(?:(?:\[\s*([^\]=]+)(?:=(['"])(.*?)\3)?\s*\])|([#.]?)([^\s#.[>:]+)|:(\w+)(?:\((.*?)\))?)/gi;
+  let token;
+  while (token = tokenizer.exec(selector)) {
+    if (token[1]) {
+      if (token[1] === ">")
+        part.combinator = 1 /* Child */;
+      else if (token[1] === "+")
+        part.combinator = 3 /* Adjacent */;
+      else if (token[1] === "~")
+        part.combinator = 2 /* Sibling */;
+      else
+        part.combinator = 0 /* Descendant */;
+      part = { combinator: 4 /* Inner */, matchers: [] };
+      parts.push(part);
+    }
+    let type = 0 /* Unknown */;
+    if (token[2]) {
+      type = 4 /* Attribute */;
+    } else if (token[5]) {
+      type = token[5] === "#" ? 2 /* Id */ : 3 /* Class */;
+    } else if (token[7]) {
+      type = token[8] == null ? 5 /* Pseudo */ : 6 /* Function */;
+    } else if (token[6] && ELEMENT_SELECTOR_TEST.test(token[6])) {
+      type = 1 /* Element */;
+    }
+    part.matchers.push({
+      type,
+      name: token[2] || token[6] || token[7],
+      value: token[4] ?? token[6] ?? token[8]
+    });
+  }
+  return parts;
+}
+function matchesSelector(element, selector) {
+  const parsed = parseSelector(selector);
+  let part;
+  while (part = parsed.pop()) {
+    if (!matchesSelectorPart(element, part))
+      return false;
+  }
+  return true;
+}
+function walkNodesForSelector(node, parts, callback) {
+  if (isElementNode(node)) {
+    if (matchesSelectorRecursive(node, parts)) {
+      if (callback(node) === false)
+        return false;
+    }
+    const child = node[CHILD];
+    if (child && walkNodesForSelector(child, parts, callback) === false) {
+      return false;
+    }
+  }
+  const next = node[NEXT];
+  if (next && walkNodesForSelector(next, parts, callback) === false) {
+    return false;
+  }
+  return true;
+}
+function matchesSelectorRecursive(element, parts) {
+  const { combinator, matchers } = parts[parts.length - 1];
+  if (combinator === 4 /* Inner */) {
+    if (!matchesSelectorMatcher(element, matchers))
+      return false;
+    const pp = parts.slice(0, -1);
+    return pp.length === 0 || matchesSelectorRecursive(element, pp);
+  }
+  const link = combinator === 1 /* Child */ || combinator === 0 /* Descendant */ ? PARENT : PREV;
+  let ref = element[link];
+  if (!ref || !matchesSelectorMatcher(ref, matchers)) {
+    return false;
+  }
+  if (combinator === 0 /* Descendant */ || combinator === 2 /* Sibling */) {
+    while (ref = ref[link]) {
+      if (matchesSelectorMatcher(ref, matchers)) {
+        const pp = parts.slice(0, -1);
+        if (pp.length === 0)
+          return true;
+        if (matchesSelectorRecursive(element, pp))
+          return true;
+      }
+    }
+  }
+  return false;
+}
+function matchesSelectorPart(element, { combinator, matchers }) {
+  if (combinator === 4 /* Inner */) {
+    return matchesSelectorMatcher(element, matchers);
+  }
+  const link = combinator === 1 /* Child */ || combinator === 0 /* Descendant */ ? PARENT : PREV;
+  let ref = element[link];
+  if (!ref || !matchesSelectorMatcher(ref, matchers)) {
+    return false;
+  }
+  if (combinator === 0 /* Descendant */ || combinator === 2 /* Sibling */) {
+    while (ref = ref[link]) {
+      if (matchesSelectorMatcher(ref, matchers))
+        return true;
+    }
+  }
+  return false;
+}
+function matchesSelectorMatcher(element, matcher) {
+  if (!element)
+    return false;
+  if (Array.isArray(matcher)) {
+    for (const single of matcher) {
+      if (matchesSelectorMatcher(element, single) === false)
+        return false;
+    }
+    return true;
+  }
+  const { type, name, value } = matcher;
+  switch (type) {
+    case 1 /* Element */:
+      return element.localName === name;
+    case 2 /* Id */:
+      return element.getAttribute("id") === name;
+    case 3 /* Class */:
+      return element.getAttribute("class") === name;
+    case 4 /* Attribute */:
+      return value == null ? element.hasAttribute(name) : element.getAttribute(name) === value;
+    case 5 /* Pseudo */:
+      switch (name) {
+        default:
+          throw Error(`Pseudo :${name} not implemented`);
+      }
+    case 6 /* Function */:
+      switch (name) {
+        case "has":
+          return matchesSelector(element, value || "");
+        default:
+          throw Error(`Function :${name}(${value}) not implemented`);
+      }
+  }
+  return false;
+}
+
+export { parseSelector, querySelector, querySelectorAll };

package/build/esnext/serialization.esnext

@@ -0,0 +1,76 @@
+import { CHILD, NEXT, NodeType, DATA, NAME, ATTRIBUTES, VALUE } from './constants.esnext';
+
+const elementTokenizer = /(?:<([a-z][a-z0-9-:]*)((?:\s[^<>'"=\n\s]+(?:=(['"])[^\n]*?\3|=[^>'"\n\s]*|))*)\s*(\/?)\s*>|<\/([a-z][a-z0-9-:]*)>|<!--(.*?)-->|([^&<>]+))/gi;
+const attributeTokenizer = /\s([^<>'"=\n\s]+)(?:=(['"])([^\n]*?)\2|=([^>'"\n\s]*)|)/g;
+function parseHtml(html, contextNode) {
+  const document = contextNode.ownerDocument;
+  const root = document.createDocumentFragment();
+  const stack = [root];
+  let parent = root;
+  let token;
+  elementTokenizer.lastIndex = 0;
+  while (token = elementTokenizer.exec(html)) {
+    const tag = token[1];
+    if (tag) {
+      const node = document.createElement(tag);
+      const attrs = token[2];
+      attributeTokenizer.lastIndex = 0;
+      let t;
+      while (t = attributeTokenizer.exec(attrs)) {
+        node.setAttribute(t[1], t[3] || t[4] || "");
+      }
+      parent.append(node);
+      stack.push(parent);
+      parent = node;
+    } else if (token[5]) {
+      parent = stack.pop() || root;
+    } else if (token[6]) {
+      parent.append(document.createComment(token[6]));
+    } else {
+      parent.append(token[7]);
+    }
+  }
+  return root;
+}
+function serializeChildren(parentNode) {
+  let out = "";
+  let child = parentNode[CHILD];
+  while (child) {
+    out += serializeNode(child);
+    child = child[NEXT];
+  }
+  return out;
+}
+function serializeNode(node) {
+  switch (node.nodeType) {
+    case NodeType.ELEMENT_NODE: {
+      const el = node;
+      let out = `<${el[NAME]}`;
+      let attr = el[ATTRIBUTES]?.[CHILD];
+      while (attr) {
+        out += ` ${attr[NAME]}`;
+        let value = attr[VALUE];
+        if (value !== "") {
+          value = String(value).replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+          out += `="${value}"`;
+        }
+        attr = attr[NEXT];
+      }
+      out += ">";
+      out += serializeChildren(el);
+      out += `</${el[NAME]}>`;
+      return out;
+    }
+    case NodeType.TEXT_NODE: {
+      const text = node;
+      return text[DATA].replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    }
+    case NodeType.COMMENT_NODE: {
+      const text = node;
+      return `<!--${text[DATA]}-->`;
+    }
+  }
+  return "";
+}
+
+export { parseHtml, serializeChildren, serializeNode };

package/build/esnext/shared.esnext

@@ -0,0 +1,59 @@
+import { DATA, ATTRIBUTES, OWNER_DOCUMENT, NodeType } from './constants.esnext';
+
+function isCharacterData(node) {
+  return DATA in node;
+}
+function isTextNode(node) {
+  return node.nodeType === NodeType.TEXT_NODE;
+}
+function isCommentNode(node) {
+  return node.nodeType === NodeType.COMMENT_NODE;
+}
+function isElementNode(node) {
+  return node.nodeType === NodeType.ELEMENT_NODE;
+}
+function isDocumentFragmentNode(node) {
+  return node.nodeType === NodeType.DOCUMENT_FRAGMENT_NODE;
+}
+function isParentNode(node) {
+  return "appendChild" in node;
+}
+function cloneNode(node, deep, document = node.ownerDocument) {
+  if (isTextNode(node)) {
+    return document.createTextNode(node.data);
+  } else if (isCommentNode(node)) {
+    return document.createComment(node.data);
+  } else if (isElementNode(node)) {
+    const cloned = document.createElement(node.localName);
+    if (node[ATTRIBUTES]) {
+      for (let i = 0; i < node[ATTRIBUTES].length; i++) {
+        const attribute = node[ATTRIBUTES].item(i);
+        cloned.setAttributeNS(
+          attribute.namespaceURI,
+          attribute.name,
+          attribute.value
+        );
+      }
+    }
+    if (deep) {
+      for (const child of node.childNodes) {
+        cloned.appendChild(cloneNode(child, true, document));
+      }
+    }
+    return cloned;
+  } else if (isDocumentFragmentNode(node)) {
+    const fragment = document.createDocumentFragment();
+    if (deep) {
+      for (const child of node.childNodes) {
+        fragment.appendChild(cloneNode(child, true, document));
+      }
+    }
+    return fragment;
+  } else {
+    const cloned = new node.constructor();
+    cloned[OWNER_DOCUMENT] = document;
+    return cloned;
+  }
+}
+
+export { cloneNode, isCharacterData, isCommentNode, isDocumentFragmentNode, isElementNode, isParentNode, isTextNode };