@remote-dom/polyfill 1.1.0 → 1.2.1

package/build/cjs/selectors.cjs

@@ -0,0 +1,203 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const constants = require('./constants.cjs');
+const shared = require('./shared.cjs');
+
+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[constants.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[constants.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 (shared.isElementNode(node)) {
+    if (matchesSelectorRecursive(node, parts)) {
+      if (callback(node) === false) return false;
+    }
+    const child = node[constants.CHILD];
+    if (child && walkNodesForSelector(child, parts, callback) === false) {
+      return false;
+    }
+  }
+  const next = node[constants.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 ? constants.PARENT : constants.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 ? constants.PARENT : constants.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;
+}
+
+exports.parseSelector = parseSelector;
+exports.querySelector = querySelector;
+exports.querySelectorAll = querySelectorAll;

package/build/cjs/serialization.cjs

@@ -0,0 +1,99 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const constants = require('./constants.cjs');
+
+// 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[constants.CHILD];
+  while (child) {
+    out += serializeNode(child);
+    child = child[constants.NEXT];
+  }
+  return out;
+}
+function serializeNode(node) {
+  switch (node.nodeType) {
+    case constants.NodeType.ELEMENT_NODE:
+      {
+        const el = node;
+        let out = `<${el[constants.NAME]}`;
+        let attr = el[constants.ATTRIBUTES]?.[constants.CHILD];
+        while (attr) {
+          out += ` ${attr[constants.NAME]}`;
+          let value = attr[constants.VALUE];
+          if (value !== '') {
+            value = String(value).replace(/&/g, '&amp;').replace(/"/g, '&quot;');
+            out += `="${value}"`;
+          }
+          attr = attr[constants.NEXT];
+        }
+        out += '>';
+        out += serializeChildren(el);
+        // let child = el[CHILD];
+        // while (child) {
+        //   out += serialize(child);
+        //   child = child[NEXT];
+        // }
+        out += `</${el[constants.NAME]}>`;
+        return out;
+      }
+    case constants.NodeType.TEXT_NODE:
+      {
+        const text = node;
+        return text[constants.DATA].replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+      }
+    case constants.NodeType.COMMENT_NODE:
+      {
+        const text = node;
+        return `<!--${text[constants.DATA]}-->`;
+      }
+  }
+  return '';
+}
+
+exports.parseHtml = parseHtml;
+exports.serializeChildren = serializeChildren;
+exports.serializeNode = serializeNode;

package/build/cjs/shared.cjs

@@ -0,0 +1,65 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const constants = require('./constants.cjs');
+
+function isCharacterData(node) {
+  return constants.DATA in node;
+}
+function isTextNode(node) {
+  return node.nodeType === constants.NodeType.TEXT_NODE;
+}
+function isCommentNode(node) {
+  return node.nodeType === constants.NodeType.COMMENT_NODE;
+}
+function isElementNode(node) {
+  return node.nodeType === constants.NodeType.ELEMENT_NODE;
+}
+function isDocumentFragmentNode(node) {
+  return node.nodeType === constants.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[constants.ATTRIBUTES]) {
+      for (let i = 0; i < node[constants.ATTRIBUTES].length; i++) {
+        const attribute = node[constants.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[constants.OWNER_DOCUMENT] = document;
+    return cloned;
+  }
+}
+
+exports.cloneNode = cloneNode;
+exports.isCharacterData = isCharacterData;
+exports.isCommentNode = isCommentNode;
+exports.isDocumentFragmentNode = isDocumentFragmentNode;
+exports.isElementNode = isElementNode;
+exports.isParentNode = isParentNode;
+exports.isTextNode = isTextNode;

package/build/esm/Element.mjs

@@ -1,4 +1,4 @@
-import { NodeType, NS, NamespaceURI, SLOT, ATTRIBUTES } from './constants.mjs';
+import { NodeType, NS, NamespaceURI, ATTRIBUTES } from './constants.mjs';
 import { ParentNode } from './ParentNode.mjs';
 import { NamedNodeMap } from './NamedNodeMap.mjs';
 import { Attr } from './Attr.mjs';
@@ -7,7 +7,6 @@ import { serializeNode, serializeChildren, parseHtml } from './serialization.mjs
 class Element extends ParentNode {
   nodeType = NodeType.ELEMENT_NODE;
   [NS] = NamespaceURI.XHTML;
-  [SLOT] = '';
   get namespaceURI() {
     return this[NS];
   }
@@ -15,11 +14,10 @@ class Element extends ParentNode {
     return this.nodeName;
   }
   get slot() {
-    return this[SLOT];
+    return this.getAttribute('slot') ?? '';
   }
   set slot(slot) {
     const finalSlot = String(slot);
-    this[SLOT] = finalSlot;
     if (this.getAttribute('slot') !== finalSlot) {
       this.attributes.setNamedItem(new Attr('slot', finalSlot));
     }

package/build/esm/NamedNodeMap.mjs

@@ -107,7 +107,7 @@ function updateElementAttribute(element, name, oldValue, newValue) {
   const {
     attributeChangedCallback
   } = element;
-  if (name === 'slot' && element.slot !== newValue) {
+  if (name === 'slot') {
     element.slot = newValue ?? '';
   }
   if (attributeChangedCallback == null || observedAttributes == null || !observedAttributes.includes(name)) {

package/build/esm/constants.mjs

@@ -12,7 +12,6 @@ const DATA = Symbol('data');
 const LISTENERS = Symbol('listeners');
 const IS_TRUSTED = Symbol('isTrusted');
 const CONTENT = Symbol('content');
-const SLOT = Symbol('slot');
 const HOOKS = Symbol('hooks');
 
 // @TODO remove explicit values
@@ -37,4 +36,4 @@ let NamespaceURI = /*#__PURE__*/function (NamespaceURI) {
   return NamespaceURI;
 }({});
 
-export { ATTRIBUTES, CHILD, CONTENT, DATA, HOOKS, IS_TRUSTED, LISTENERS, NAME, NEXT, NS, NamespaceURI, NodeType, OWNER_DOCUMENT, OWNER_ELEMENT, PARENT, PREV, SLOT, VALUE };
+export { ATTRIBUTES, CHILD, CONTENT, DATA, HOOKS, IS_TRUSTED, LISTENERS, NAME, NEXT, NS, NamespaceURI, NodeType, OWNER_DOCUMENT, OWNER_ELEMENT, PARENT, PREV, VALUE };

package/build/esnext/Element.esnext

@@ -1,4 +1,4 @@
-import { NodeType, NS, NamespaceURI, SLOT, ATTRIBUTES } from './constants.esnext';
+import { NodeType, NS, NamespaceURI, ATTRIBUTES } from './constants.esnext';
 import { ParentNode } from './ParentNode.esnext';
 import { NamedNodeMap } from './NamedNodeMap.esnext';
 import { Attr } from './Attr.esnext';
@@ -8,7 +8,6 @@ class Element extends ParentNode {
   static observedAttributes;
   nodeType = NodeType.ELEMENT_NODE;
   [NS] = NamespaceURI.XHTML;
-  [SLOT] = "";
   get namespaceURI() {
     return this[NS];
   }
@@ -17,11 +16,10 @@ class Element extends ParentNode {
   }
   [ATTRIBUTES];
   get slot() {
-    return this[SLOT];
+    return this.getAttribute("slot") ?? "";
   }
   set slot(slot) {
     const finalSlot = String(slot);
-    this[SLOT] = finalSlot;
     if (this.getAttribute("slot") !== finalSlot) {
       this.attributes.setNamedItem(new Attr("slot", finalSlot));
     }

package/build/esnext/NamedNodeMap.esnext

@@ -115,7 +115,7 @@ class NamedNodeMap {
 function updateElementAttribute(element, name, oldValue, newValue) {
   const { observedAttributes } = element.constructor;
   const { attributeChangedCallback } = element;
-  if (name === "slot" && element.slot !== newValue) {
+  if (name === "slot") {
     element.slot = newValue ?? "";
   }
   if (attributeChangedCallback == null || observedAttributes == null || !observedAttributes.includes(name)) {

package/build/esnext/constants.esnext

@@ -12,7 +12,6 @@ const DATA = Symbol("data");
 const LISTENERS = Symbol("listeners");
 const IS_TRUSTED = Symbol("isTrusted");
 const CONTENT = Symbol("content");
-const SLOT = Symbol("slot");
 const HOOKS = Symbol("hooks");
 var NodeType = /* @__PURE__ */ ((NodeType2) => {
   NodeType2[NodeType2["NODE"] = 0] = "NODE";
@@ -35,4 +34,4 @@ var NamespaceURI = /* @__PURE__ */ ((NamespaceURI2) => {
   return NamespaceURI2;
 })(NamespaceURI || {});
 
-export { ATTRIBUTES, CHILD, CONTENT, DATA, HOOKS, IS_TRUSTED, LISTENERS, NAME, NEXT, NS, NamespaceURI, NodeType, OWNER_DOCUMENT, OWNER_ELEMENT, PARENT, PREV, SLOT, VALUE };
+export { ATTRIBUTES, CHILD, CONTENT, DATA, HOOKS, IS_TRUSTED, LISTENERS, NAME, NEXT, NS, NamespaceURI, NodeType, OWNER_DOCUMENT, OWNER_ELEMENT, PARENT, PREV, VALUE };