@remote-dom/polyfill 1.5.0 → 1.6.0

package/build/cjs/selectors.cjs

@@ -4,28 +4,54 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const constants = require('./constants.cjs');
 const shared = require('./shared.cjs');
+const NodeList = require('./NodeList.cjs');
+const domException = require('./dom-exception.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]/;
+const COMBINATOR_DESCENDANT = 0;
+const COMBINATOR_CHILD = 1;
+const COMBINATOR_SIBLING = 2;
+const COMBINATOR_ADJACENT = 3;
+const COMBINATOR_INNER = 4;
+const MATCHER_UNKNOWN = 0;
+const MATCHER_ELEMENT = 1;
+const MATCHER_ID = 2;
+const MATCHER_CLASS = 3;
+const MATCHER_ATTRIBUTE = 4;
+const MATCHER_PSEUDO = 5;
+const MATCHER_FUNCTION = 6;
+const MATCHER_SCOPE = 7;
+const SUPPORTED_IDENTIFIER_TEST = /^(?:--|-?[A-Za-z_\u0080-\u{10FFFF}])[A-Za-z0-9_\u0080-\u{10FFFF}-]*$/u;
+function readFunctionArgument(selector, start) {
+  let depth = 1;
+  let quote = null;
+  for (let index = start; index < selector.length; index++) {
+    const character = selector[index];
+    if (quote) {
+      if (character === '\\') {
+        index++;
+      } else if (character === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+    } else if (character === '(') {
+      depth++;
+    } else if (character === ')' && --depth === 0) {
+      return [selector.slice(start, index), index + 1];
+    }
+  }
+  return [selector.slice(start), selector.length];
+}
+function throwSelectorSyntaxError(selector) {
+  throw domException.createDOMException(`Invalid or unsupported selector: "${selector}"`, 'SyntaxError');
+}
 function querySelector(within, selector) {
-  const parts = parseSelector(selector);
+  const parts = typeof selector === 'string' ? parseSelector(selector) : [{
+    combinator: COMBINATOR_INNER,
+    matchers: selector
+  }];
   let result = null;
   const child = within[constants.CHILD];
   if (child && parts[0].matchers.length) {
@@ -37,8 +63,11 @@ function querySelector(within, selector) {
   return result;
 }
 function querySelectorAll(within, selector) {
-  const parts = parseSelector(selector);
-  const results = [];
+  const parts = typeof selector === 'string' ? parseSelector(selector) : [{
+    combinator: COMBINATOR_INNER,
+    matchers: selector
+  }];
+  const results = new NodeList.NodeList();
   const child = within[constants.CHILD];
   if (child && parts[0].matchers.length) {
     walkNodesForSelector(child, parts, node => {
@@ -47,98 +76,170 @@ function querySelectorAll(within, selector) {
   }
   return results;
 }
-function parseSelector(selector) {
+function parseSelector(selector, insideHas = false, allowLeadingCombinator = false) {
   let part = {
-    combinator: Combinator.Inner,
+    combinator: COMBINATOR_INNER,
     matchers: []
   };
   const parts = [part];
-  const tokenizer = /\s*?([>\s+~]?)\s*?(?:(?:\[\s*([^\]=]+)(?:=(['"])(.*?)\3)?\s*\])|([#.]?)([^\s#.[>:+~]+)|:(\w+)(?:\((.*?)\))?)/gi;
+  const tokenizer = /[\t\n\f\r ]*?([>\t\n\f\r +~]?)[\t\n\f\r ]*?(?:(?:\[[\t\n\f\r ]*([^\]=\t\n\f\r ]+)[\t\n\f\r ]*(?:=[\t\n\f\r ]*(?:(['"])(.*?)\3|([^\]\t\n\f\r ]+)))?[\t\n\f\r ]*(?:\]|$))|([#.]?)([^\t\n\f\r #.[>:+~()]+)|:(\w+)(\()?)/gi;
+  const normalizedSelector = selector.replace(/^[\t\n\f\r ]+|[\t\n\f\r ]+$/g, '');
+  if (normalizedSelector === '') throwSelectorSyntaxError(selector);
+  let consumed = 0;
   let token;
-  while (token = tokenizer.exec(selector)) {
-    // [1]: ancestor/parent/sibling/adjacent
+  while (token = tokenizer.exec(normalizedSelector)) {
+    if (token.index !== consumed) throwSelectorSyntaxError(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
+    // [3]/[4]: quoted attribute value
+    // [5]: unquoted attribute value
+    // [6]: id/class sigil
+    // [7]: id/class/type name
+    // [8]: :pseudo/:function() name
+    // [9]: :function opening parenthesis
     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:
+      if (part.matchers.length === 0 && !(allowLeadingCombinator && parts.length === 1)) {
+        throwSelectorSyntaxError(selector);
+      }
+      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;
       part = {
-        combinator: Combinator.Inner,
+        combinator: COMBINATOR_INNER,
         matchers: []
       };
       parts.push(part);
     }
-    let type = MatcherType.Unknown;
+    const name = token[8] ? constants.asciiLowercase(token[8]) : token[2] || token[7];
+    const isTypeSelector = token[7] != null && !token[6];
+    if (isTypeSelector && part.matchers.length > 0) {
+      throwSelectorSyntaxError(selector);
+    }
+    let type;
+    let value = token[4] ?? token[5] ?? token[7];
     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;
+      if (!SUPPORTED_IDENTIFIER_TEST.test(name)) {
+        throwSelectorSyntaxError(selector);
+      }
+      const unquotedValue = token[5];
+      const openingQuote = unquotedValue?.[0];
+      if (token[3] == null && (openingQuote === '"' || openingQuote === "'")) {
+        const valueOffset = token[0].lastIndexOf(unquotedValue);
+        value = normalizedSelector.slice(token.index + valueOffset + 1);
+        tokenizer.lastIndex = normalizedSelector.length;
+      } else if (unquotedValue != null && !SUPPORTED_IDENTIFIER_TEST.test(unquotedValue)) {
+        throwSelectorSyntaxError(selector);
+      }
+      type = MATCHER_ATTRIBUTE;
     } else if (token[6]) {
-      if (token[6] === '*') {
-        type = MatcherType.Unknown; // Universal selector matches all
-      } else if (ELEMENT_SELECTOR_TEST.test(token[6])) {
-        type = MatcherType.Element;
+      if (!SUPPORTED_IDENTIFIER_TEST.test(name)) {
+        throwSelectorSyntaxError(selector);
       }
+      type = token[6] === '#' ? MATCHER_ID : MATCHER_CLASS;
+    } else if (token[8]) {
+      type = token[9] == null ? MATCHER_PSEUDO : MATCHER_FUNCTION;
+    } else if (token[7] === '*') {
+      type = MATCHER_UNKNOWN;
+    } else if (token[7] && SUPPORTED_IDENTIFIER_TEST.test(token[7])) {
+      type = MATCHER_ELEMENT;
+    } else {
+      throwSelectorSyntaxError(selector);
+    }
+    if (token[9]) {
+      [value, tokenizer.lastIndex] = readFunctionArgument(normalizedSelector, tokenizer.lastIndex);
+      if (name !== 'has' && name !== 'not') {
+        throwSelectorSyntaxError(selector);
+      }
+      if (name === 'has' && insideHas) throwSelectorSyntaxError(selector);
+      parseSelector(value, insideHas || name === 'has', name === 'has');
+    } else if (type === MATCHER_PSEUDO) {
+      throwSelectorSyntaxError(selector);
     }
     part.matchers.push({
       type,
-      name: token[2] || token[6] || token[7],
-      value: token[4] ?? token[6] ?? token[8]
+      name,
+      value
     });
+    consumed = tokenizer.lastIndex;
+  }
+  if (consumed !== normalizedSelector.length || part.matchers.length === 0) {
+    throwSelectorSyntaxError(selector);
   }
   return parts;
 }
 function matchesSelector(element, selector) {
   const parsed = parseSelector(selector);
-  let part;
-  while (part = parsed.pop()) {
-    if (!matchesSelectorPart(element, part)) return false;
-  }
-  return true;
+  return parsed[0]?.matchers.length ? matchesSelectorRecursive(element, parsed) : false;
 }
-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;
-    }
+function matchesRelativeSelector(scope, selector) {
+  const parts = parseSelector(selector, true, true);
+  const first = parts[0];
+  if (parts.length === 1 && first.matchers.length === 0) return false;
+  let leadingCombinator = COMBINATOR_DESCENDANT;
+  const scopeMatcher = {
+    type: MATCHER_SCOPE,
+    name: ':scope'
+  };
+  if (first.matchers.length === 0) {
+    leadingCombinator = first.combinator;
+    first.matchers.push(scopeMatcher);
+  } else {
+    parts.unshift({
+      combinator: COMBINATOR_DESCENDANT,
+      matchers: [scopeMatcher]
+    });
   }
-  const next = node[constants.NEXT];
-  if (next && walkNodesForSelector(next, parts, callback) === false) {
+  if (parts.some(({
+    matchers
+  }) => matchers.length === 0)) return false;
+  const root = leadingCombinator === COMBINATOR_ADJACENT || leadingCombinator === COMBINATOR_SIBLING ? scope[constants.NEXT] : scope[constants.CHILD];
+  if (!root) return false;
+  let matched = false;
+  walkNodesForSelector(root, parts, () => {
+    matched = true;
     return false;
+  }, scope);
+  return matched;
+}
+function walkNodesForSelector(node, parts, callback, scope) {
+  const pendingSiblings = [];
+  let current = node;
+  while (current) {
+    if (shared.isElementNode(current)) {
+      if (matchesSelectorRecursive(current, parts, scope)) {
+        if (callback(current) === false) return false;
+      }
+      const child = current[constants.CHILD];
+      if (child) {
+        const sibling = current[constants.NEXT];
+        if (sibling) pendingSiblings.push(sibling);
+        current = child;
+        continue;
+      }
+    }
+    current = current[constants.NEXT] ?? pendingSiblings.pop() ?? null;
   }
   return true;
 }
-function matchesSelectorRecursive(element, parts) {
+function matchesSelectorRecursive(element, parts, scope) {
   const {
     combinator,
     matchers
   } = parts[parts.length - 1];
-  if (combinator === Combinator.Inner) {
-    if (!matchesSelectorMatcher(element, matchers)) return false;
+  if (combinator === COMBINATOR_INNER) {
+    if (!matchesSelectorMatcher(element, matchers, scope)) return false;
     const pp = parts.slice(0, -1);
-    return pp.length === 0 || matchesSelectorRecursive(element, pp);
+    return pp.length === 0 || matchesSelectorRecursive(element, pp, scope);
   }
-  const link = combinator === Combinator.Child || combinator === Combinator.Descendant ? constants.PARENT : constants.PREV;
+  const link = combinator === COMBINATOR_CHILD || combinator === COMBINATOR_DESCENDANT ? constants.PARENT : constants.PREV;
   let ref = element[link];
   if (!ref) return false;
-  if (combinator === Combinator.Descendant || combinator === Combinator.Sibling) {
+  if (combinator === COMBINATOR_DESCENDANT || combinator === COMBINATOR_SIBLING) {
     // For descendant/sibling combinators, search through all ancestors/siblings
     while (ref) {
-      if (shared.isElementNode(ref) && matchesSelectorMatcher(ref, matchers)) {
+      if (shared.isElementNode(ref) && matchesSelectorMatcher(ref, matchers, scope)) {
         const pp = parts.slice(0, -1);
         if (pp.length === 0) return true;
-        if (matchesSelectorRecursive(element, pp)) return true;
+        if (matchesSelectorRecursive(ref, pp, scope)) return true;
       }
       ref = ref[link];
     }
@@ -146,53 +247,30 @@ function matchesSelectorRecursive(element, parts) {
   } else {
     // For child/adjacent combinators, check only the immediate parent/sibling
     // For sibling combinators, skip non-element siblings
-    if (combinator === Combinator.Adjacent && !shared.isElementNode(ref)) {
+    if (combinator === COMBINATOR_ADJACENT && !shared.isElementNode(ref)) {
       // Skip to next element sibling
       while (ref && !shared.isElementNode(ref)) {
         ref = ref[link];
       }
       if (!ref) return false;
     }
-    if (!shared.isElementNode(ref) || !matchesSelectorMatcher(ref, matchers)) {
+    if (!shared.isElementNode(ref) || !matchesSelectorMatcher(ref, matchers, scope)) {
       return false;
     }
     const pp = parts.slice(0, -1);
-    return pp.length === 0 || matchesSelectorRecursive(element, pp);
+    return pp.length === 0 || matchesSelectorRecursive(ref, pp, scope);
   }
 }
-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) return false;
-
-  // For sibling combinators, skip non-element siblings
-  if (combinator === Combinator.Adjacent && !shared.isElementNode(ref)) {
-    while (ref && !shared.isElementNode(ref)) {
-      ref = ref[link];
-    }
-    if (!ref) return false;
-  }
-  if (!shared.isElementNode(ref) || !matchesSelectorMatcher(ref, matchers)) {
-    return false;
-  }
-  if (combinator === Combinator.Descendant || combinator === Combinator.Sibling) {
-    while (ref = ref[link]) {
-      if (shared.isElementNode(ref) && matchesSelectorMatcher(ref, matchers)) return true;
-    }
-  }
-  return true;
+function getSelectorAttribute(element, name) {
+  return element.getAttributeNS(null, element.namespaceURI === constants.HTML_NAMESPACE ? constants.asciiLowercase(name) : name);
 }
-function matchesSelectorMatcher(element, matcher) {
+function matchesSelectorMatcher(element, matcher, scope) {
   if (!element) return false;
   if (Array.isArray(matcher)) {
     for (const single of matcher) {
-      if (matchesSelectorMatcher(element, single) === false) return false;
+      if (matchesSelectorMatcher(element, single, scope) === false) {
+        return false;
+      }
     }
     return true;
   }
@@ -202,37 +280,50 @@ function matchesSelectorMatcher(element, matcher) {
     value
   } = matcher;
   switch (type) {
-    case MatcherType.Unknown:
+    case MATCHER_UNKNOWN:
       return name === '*';
     // Universal selector
-    case MatcherType.Element:
-      return element.localName === name;
-    case MatcherType.Id:
-      return element.getAttribute('id') === name;
-    case MatcherType.Class:
-      const classAttr = element.getAttribute('class');
+    case MATCHER_ELEMENT:
+      return element.namespaceURI === constants.HTML_NAMESPACE ? element.localName === constants.asciiLowercase(name) : element.localName === name;
+    case MATCHER_ID:
+      return getSelectorAttribute(element, 'id') === name;
+    case MATCHER_CLASS:
+      const classAttr = getSelectorAttribute(element, 'class');
       if (!classAttr) return false;
-      return classAttr.split(/\s+/).includes(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:
+      return constants.splitOnASCIIWhitespace(classAttr).includes(name);
+    case MATCHER_ATTRIBUTE:
+      const attribute = getSelectorAttribute(element, name);
+      return value == null ? attribute != null : attribute === value;
+    case MATCHER_SCOPE:
+      return element === scope;
+    case MATCHER_PSEUDO:
+      throwSelectorSyntaxError(`:${name}`);
+    case MATCHER_FUNCTION:
       switch (name) {
         case 'has':
-          return matchesSelector(element, value || '');
+          return matchesRelativeSelector(element, value || '');
         case 'not':
           return !matchesSelector(element, value || '');
         default:
-          throw Error(`Function :${name}(${value}) not implemented`);
+          throwSelectorSyntaxError(`:${name}(${value})`);
       }
   }
   return false;
 }
 
+exports.COMBINATOR_ADJACENT = COMBINATOR_ADJACENT;
+exports.COMBINATOR_CHILD = COMBINATOR_CHILD;
+exports.COMBINATOR_DESCENDANT = COMBINATOR_DESCENDANT;
+exports.COMBINATOR_INNER = COMBINATOR_INNER;
+exports.COMBINATOR_SIBLING = COMBINATOR_SIBLING;
+exports.MATCHER_ATTRIBUTE = MATCHER_ATTRIBUTE;
+exports.MATCHER_CLASS = MATCHER_CLASS;
+exports.MATCHER_ELEMENT = MATCHER_ELEMENT;
+exports.MATCHER_FUNCTION = MATCHER_FUNCTION;
+exports.MATCHER_ID = MATCHER_ID;
+exports.MATCHER_PSEUDO = MATCHER_PSEUDO;
+exports.MATCHER_SCOPE = MATCHER_SCOPE;
+exports.MATCHER_UNKNOWN = MATCHER_UNKNOWN;
 exports.parseSelector = parseSelector;
 exports.querySelector = querySelector;
 exports.querySelectorAll = querySelectorAll;