@remote-dom/polyfill 0.0.0-preview-20240219211553

package/build/esm/selectors.mjs

@@ -0,0 +1,197 @@
+import { CHILD, NEXT, PARENT, PREV } from './constants.mjs';
+import { isElementNode } from './shared.mjs';
+
+var Combinator = /*#__PURE__*/function (Combinator) {
+  Combinator[Combinator["Descendant"] = 0] = "Descendant";
+  Combinator[Combinator["Child"] = 1] = "Child";
+  Combinator[Combinator["Sibling"] = 2] = "Sibling";
+  Combinator[Combinator["Adjacent"] = 3] = "Adjacent";
+  Combinator[Combinator["Inner"] = 4] = "Inner";
+  return Combinator;
+}(Combinator || {});
+var MatcherType = /*#__PURE__*/function (MatcherType) {
+  MatcherType[MatcherType["Unknown"] = 0] = "Unknown";
+  MatcherType[MatcherType["Element"] = 1] = "Element";
+  MatcherType[MatcherType["Id"] = 2] = "Id";
+  MatcherType[MatcherType["Class"] = 3] = "Class";
+  MatcherType[MatcherType["Attribute"] = 4] = "Attribute";
+  MatcherType[MatcherType["Pseudo"] = 5] = "Pseudo";
+  MatcherType[MatcherType["Function"] = 6] = "Function";
+  return MatcherType;
+}(MatcherType || {});
+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: Combinator.Inner,
+    matchers: []
+  };
+  const parts = [part];
+  const tokenizer = /\s*?([>\s+~]?)\s*?(?:(?:\[\s*([^\]=]+)(?:=(['"])(.*?)\3)?\s*\])|([#.]?)([^\s#.[>:]+)|:(\w+)(?:\((.*?)\))?)/gi;
+  let token;
+  while (token = tokenizer.exec(selector)) {
+    // [1]: ancestor/parent/sibling/adjacent
+    // [2]: attribute name
+    // [4]: attribute value
+    // [5]: id/class sigil
+    // [6]: id/class name
+    // [7]: :pseudo/:function() name
+    // [8]: :function(argument) value
+    if (token[1]) {
+      // Update the combinator on the (now parent) Part:
+      if (token[1] === '>') part.combinator = Combinator.Child;else if (token[1] === '+') part.combinator = Combinator.Adjacent;else if (token[1] === '~') part.combinator = Combinator.Sibling;else part.combinator = Combinator.Descendant;
+      // Add a new Part for the next selector parts:
+      part = {
+        combinator: Combinator.Inner,
+        matchers: []
+      };
+      parts.push(part);
+    }
+    let type = MatcherType.Unknown;
+    if (token[2]) {
+      type = MatcherType.Attribute;
+    } else if (token[5]) {
+      type = token[5] === '#' ? MatcherType.Id : MatcherType.Class;
+    } else if (token[7]) {
+      type = token[8] == null ? MatcherType.Pseudo : MatcherType.Function;
+    } else if (token[6] && ELEMENT_SELECTOR_TEST.test(token[6])) {
+      type = MatcherType.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 === Combinator.Inner) {
+    if (!matchesSelectorMatcher(element, matchers)) return false;
+    const pp = parts.slice(0, -1);
+    return pp.length === 0 || matchesSelectorRecursive(element, pp);
+  }
+  const link = combinator === Combinator.Child || combinator === Combinator.Descendant ? PARENT : PREV;
+  let ref = element[link];
+  if (!ref || !matchesSelectorMatcher(ref, matchers)) {
+    return false;
+  }
+  if (combinator === Combinator.Descendant || combinator === Combinator.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 === Combinator.Inner) {
+    return matchesSelectorMatcher(element, matchers);
+  }
+  const link = combinator === Combinator.Child || combinator === Combinator.Descendant ? PARENT : PREV;
+  let ref = element[link];
+  if (!ref || !matchesSelectorMatcher(ref, matchers)) {
+    return false;
+  }
+  if (combinator === Combinator.Descendant || combinator === Combinator.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 MatcherType.Element:
+      return element.localName === name;
+    case MatcherType.Id:
+      return element.getAttribute('id') === name;
+    case MatcherType.Class:
+      return element.getAttribute('class') === name;
+    case MatcherType.Attribute:
+      return value == null ? element.hasAttribute(name) : element.getAttribute(name) === value;
+    case MatcherType.Pseudo:
+      switch (name) {
+        default:
+          throw Error(`Pseudo :${name} not implemented`);
+      }
+    case MatcherType.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/esm/serialization.mjs

@@ -0,0 +1,92 @@
+import { CHILD, NEXT, NodeType, DATA, NAME, ATTRIBUTES, VALUE } from './constants.mjs';
+
+// const voidElements = {
+//   img: true,
+//   image: true,
+// };
+// const elementTokenizer =
+//   /(?:<([a-z][a-z0-9-:]*)( [^<>'"\n=\s]+=(['"])[^>'"\n]*\3)*\s*(\/?)\s*>|<\/([a-z][a-z0-9-:]*)>|([^&<>]+))/gi;
+// const attributeTokenizer = / ([^<>'"\n=\s]+)=(['"])([^>'"\n]*)\2/g;
+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);
+      // if (voidElements[tag] === true) continue;
+      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);
+        // let child = el[CHILD];
+        // while (child) {
+        //   out += serialize(child);
+        //   child = child[NEXT];
+        // }
+        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/esm/shared.mjs

@@ -0,0 +1,55 @@
+import { DATA, ATTRIBUTES, OWNER_DOCUMENT, NodeType } from './constants.mjs';
+
+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 };

package/build/esnext/Attr.esnext

@@ -0,0 +1,57 @@
+import { hooks } from './hooks.esnext';
+import { NodeType, NS, NEXT, VALUE, OWNER_ELEMENT, NAME } from './constants.esnext';
+import { Node } from './Node.esnext';
+
+class Attr extends Node {
+  nodeType = NodeType.ATTRIBUTE_NODE;
+  [NS] = null;
+  [NEXT] = null;
+  [VALUE];
+  [OWNER_ELEMENT] = null;
+  isConnected = false;
+  constructor(name, value, namespace) {
+    super();
+    this[NAME] = name;
+    this[VALUE] = value;
+    if (namespace)
+      this[NS] = namespace;
+  }
+  get nodeName() {
+    return this[NAME];
+  }
+  set nodeName(_readonly) {
+  }
+  get name() {
+    return this[NAME];
+  }
+  set name(_readonly) {
+  }
+  get value() {
+    return this[VALUE];
+  }
+  set value(value) {
+    const str = String(value);
+    this[VALUE] = str;
+    const ownerElement = this[OWNER_ELEMENT];
+    if (!ownerElement)
+      return;
+    hooks.setAttribute?.(ownerElement, this[NAME], str, this[NS]);
+  }
+  get nodeValue() {
+    return this.value;
+  }
+  set nodeValue(value) {
+    this.value = value;
+  }
+  get ownerElement() {
+    return this[OWNER_ELEMENT];
+  }
+  get namespaceURI() {
+    return this[NS];
+  }
+  get specified() {
+    return true;
+  }
+}
+
+export { Attr };

package/build/esnext/CharacterData.esnext

@@ -0,0 +1,27 @@
+import { hooks } from './hooks.esnext';
+import { DATA } from './constants.esnext';
+import { ChildNode } from './ChildNode.esnext';
+
+class CharacterData extends ChildNode {
+  [DATA] = "";
+  constructor(data) {
+    super();
+    this.setData(data);
+  }
+  setData(data) {
+    let str = "";
+    if (data != null) {
+      str = typeof data === "string" ? data : String(data);
+    }
+    this[DATA] = str;
+    hooks.setText?.(this, str);
+  }
+  get data() {
+    return this[DATA];
+  }
+  set data(data) {
+    this.setData(data);
+  }
+}
+
+export { CharacterData };

package/build/esnext/ChildNode.esnext

@@ -0,0 +1,47 @@
+import { NEXT } from './constants.esnext';
+import { Node } from './Node.esnext';
+
+class ChildNode extends Node {
+  remove() {
+    const parent = this.parentNode;
+    if (!parent)
+      return;
+    parent.removeChild(this);
+  }
+  replaceWith(...nodes) {
+    const parent = this.parentNode;
+    if (!parent)
+      return;
+    const node = toNode(parent, nodes[0]);
+    const next = node[NEXT];
+    parent.replaceChild(this, node);
+    for (let i = 1; i < nodes.length; i++) {
+      parent.insertBefore(toNode(parent, nodes[i]), next);
+    }
+  }
+  before(...nodes) {
+    const parent = this.parentNode;
+    if (!parent)
+      return;
+    for (const node of nodes) {
+      parent.insertBefore(toNode(parent, node), this);
+    }
+  }
+  after(...nodes) {
+    const parent = this.parentNode;
+    if (!parent)
+      return;
+    const next = this[NEXT];
+    for (const node of nodes) {
+      parent.insertBefore(toNode(parent, node), next);
+    }
+  }
+}
+function toNode(parent, node) {
+  if (node instanceof Node)
+    return node;
+  const ownerDocument = parent.ownerDocument;
+  return ownerDocument.createTextNode(String(node));
+}
+
+export { ChildNode, toNode };

package/build/esnext/Comment.esnext

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

package/build/esnext/CustomElementRegistry.esnext

@@ -0,0 +1,34 @@
+class CustomElementRegistryImplementation {
+  registry = /* @__PURE__ */ new Map();
+  listenersByName = /* @__PURE__ */ new Map();
+  define(name, Constructor, _options) {
+    this.registry.set(name, Constructor);
+    const listeners = this.listenersByName.get(name);
+    if (listeners == null)
+      return;
+    this.listenersByName.delete(name);
+    for (const listener of listeners) {
+      listener(Constructor);
+    }
+  }
+  get(name) {
+    return this.registry.get(name);
+  }
+  whenDefined(name) {
+    const Constructor = this.registry.get(name);
+    if (Constructor != null)
+      return Promise.resolve(Constructor);
+    let listeners = this.listenersByName.get(name);
+    if (listeners == null) {
+      listeners = [];
+      this.listenersByName.set(name, listeners);
+    }
+    return new Promise((resolve) => {
+      listeners.push(resolve);
+    });
+  }
+  upgrade(_root) {
+  }
+}
+
+export { CustomElementRegistryImplementation };

package/build/esnext/CustomEvent.esnext

@@ -0,0 +1,25 @@
+import { Event } from './Event.esnext';
+
+class CustomEvent extends Event {
+  /**
+   * Returns any custom data event was created with. Typically used for synthetic events.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CustomEvent/detail)
+   */
+  detail;
+  constructor(type, eventInitDict) {
+    super(type, eventInitDict);
+    this.detail = eventInitDict?.detail;
+  }
+  /**
+   * Returns any custom data event was created with. Typically used for synthetic events.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CustomEvent/detail)
+   */
+  initCustomEvent(type, bubbles, cancelable, detail) {
+    super.initEvent(type, bubbles, cancelable);
+    this.detail = detail;
+  }
+}
+
+export { CustomEvent };

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