html-validate 9.4.0 → 9.4.2-rc.1

package/dist/es/core.js

@@ -1935,15 +1935,15 @@ function nthChild(node, args) {
   return cur === n;
 }
 
-function scope(node) {
-  return node.isSameNode(this.scope);
+function scope$1(node) {
+  return Boolean(this.scope && node.isSameNode(this.scope));
 }
 
 const table = {
   "first-child": firstChild,
   "last-child": lastChild,
   "nth-child": nthChild,
-  scope
+  scope: scope$1
 };
 function factory(name, context) {
   const fn = table[name];
@@ -1954,139 +1954,12 @@ function factory(name, context) {
   }
 }
 
-const escapedCodepoints = ["9", "a", "d"];
-function* splitSelectorElements(selector) {
-  let begin = 0;
-  let end = 0;
-  function initialState(ch, p) {
-    if (ch === "\\") {
-      return 1 /* ESCAPED */;
-    }
-    if (ch === " ") {
-      end = p;
-      return 2 /* WHITESPACE */;
-    }
-    return 0 /* INITIAL */;
-  }
-  function escapedState(ch) {
-    if (escapedCodepoints.includes(ch)) {
-      return 1 /* ESCAPED */;
-    }
-    return 0 /* INITIAL */;
-  }
-  function* whitespaceState(ch, p) {
-    if (ch === " ") {
-      return 2 /* WHITESPACE */;
-    }
-    yield selector.slice(begin, end);
-    begin = p;
-    end = p;
-    return 0 /* INITIAL */;
-  }
-  let state = 0 /* INITIAL */;
-  for (let p = 0; p < selector.length; p++) {
-    const ch = selector[p];
-    switch (state) {
-      case 0 /* INITIAL */:
-        state = initialState(ch, p);
-        break;
-      case 1 /* ESCAPED */:
-        state = escapedState(ch);
-        break;
-      case 2 /* WHITESPACE */:
-        state = yield* whitespaceState(ch, p);
-        break;
-    }
-  }
-  if (begin !== selector.length) {
-    yield selector.slice(begin);
-  }
-}
-
 function stripslashes(value) {
   return value.replace(/\\(.)/g, "$1");
 }
-function unescapeCodepoint(value) {
-  const replacement = {
-    "\\9 ": "	",
-    "\\a ": "\n",
-    "\\d ": "\r"
-  };
-  return value.replace(
-    /(\\[\u0039\u0061\u0064] )/g,
-    (_, codepoint) => replacement[codepoint]
-  );
-}
-function escapeSelectorComponent(text) {
-  const codepoints = {
-    "	": "\\9 ",
-    "\n": "\\a ",
-    "\r": "\\d "
-  };
-  return text.toString().replace(/([\t\n\r]|[^a-z0-9_-])/gi, (_, ch) => {
-    if (codepoints[ch]) {
-      return codepoints[ch];
-    } else {
-      return `\\${ch}`;
-    }
-  });
-}
-function generateIdSelector(id) {
-  const escaped = escapeSelectorComponent(id);
-  return escaped.match(/^\d/) ? `[id="${escaped}"]` : `#${escaped}`;
-}
-function isDelimiter(ch) {
-  return /[.#[:]/.test(ch);
-}
-function isQuotationMark(ch) {
-  return /['"]/.test(ch);
-}
-function isPseudoElement(ch, buffer) {
-  return ch === ":" && buffer === ":";
-}
-function* splitPattern(pattern) {
-  if (pattern === "") {
-    return;
-  }
-  const end = pattern.length;
-  let begin = 0;
-  let cur = 1;
-  let quoted = false;
-  while (cur < end) {
-    const ch = pattern[cur];
-    const buffer = pattern.slice(begin, cur);
-    if (ch === "\\") {
-      cur += 2;
-      continue;
-    }
-    if (quoted) {
-      if (ch === quoted) {
-        quoted = false;
-      }
-      cur += 1;
-      continue;
-    }
-    if (isQuotationMark(ch)) {
-      quoted = ch;
-      cur += 1;
-      continue;
-    }
-    if (isPseudoElement(ch, buffer)) {
-      cur += 1;
-      continue;
-    }
-    if (isDelimiter(ch)) {
-      begin = cur;
-      yield buffer;
-    }
-    cur += 1;
-  }
-  const tail = pattern.slice(begin, cur);
-  yield tail;
-}
-class Matcher {
+class Condition {
 }
-class ClassMatcher extends Matcher {
+class ClassCondition extends Condition {
   classname;
   constructor(classname) {
     super();
@@ -2096,7 +1969,7 @@ class ClassMatcher extends Matcher {
     return node.classList.contains(this.classname);
   }
 }
-class IdMatcher extends Matcher {
+class IdCondition extends Condition {
   id;
   constructor(id) {
     super();
@@ -2106,7 +1979,7 @@ class IdMatcher extends Matcher {
     return node.id === this.id;
   }
 }
-class AttrMatcher extends Matcher {
+class AttributeCondition extends Condition {
   key;
   op;
   value;
@@ -2132,7 +2005,7 @@ class AttrMatcher extends Matcher {
     });
   }
 }
-class PseudoClassMatcher extends Matcher {
+class PseudoClassCondition extends Condition {
   name;
   args;
   constructor(pseudoclass, context) {
@@ -2150,11 +2023,62 @@ class PseudoClassMatcher extends Matcher {
     return fn(node, this.args);
   }
 }
-class Pattern {
+
+function isDelimiter(ch) {
+  return /[.#[:]/.test(ch);
+}
+function isQuotationMark(ch) {
+  return /['"]/.test(ch);
+}
+function isPseudoElement(ch, buffer) {
+  return ch === ":" && buffer === ":";
+}
+function* splitCompound(pattern) {
+  if (pattern === "") {
+    return;
+  }
+  const end = pattern.length;
+  let begin = 0;
+  let cur = 1;
+  let quoted = false;
+  while (cur < end) {
+    const ch = pattern[cur];
+    const buffer = pattern.slice(begin, cur);
+    if (ch === "\\") {
+      cur += 2;
+      continue;
+    }
+    if (quoted) {
+      if (ch === quoted) {
+        quoted = false;
+      }
+      cur += 1;
+      continue;
+    }
+    if (isQuotationMark(ch)) {
+      quoted = ch;
+      cur += 1;
+      continue;
+    }
+    if (isPseudoElement(ch, buffer)) {
+      cur += 1;
+      continue;
+    }
+    if (isDelimiter(ch)) {
+      begin = cur;
+      yield buffer;
+    }
+    cur += 1;
+  }
+  const tail = pattern.slice(begin, cur);
+  yield tail;
+}
+
+class Compound {
   combinator;
   tagName;
   selector;
-  pattern;
+  conditions;
   constructor(pattern) {
     const match = pattern.match(/^([~+\->]?)((?:[*]|[^.#[:]+)?)([^]*)$/);
     if (!match) {
@@ -2164,25 +2088,168 @@ class Pattern {
     this.selector = pattern;
     this.combinator = parseCombinator(match.shift(), pattern);
     this.tagName = match.shift() || "*";
-    this.pattern = Array.from(splitPattern(match[0]), (it) => this.createMatcher(it));
+    this.conditions = Array.from(splitCompound(match[0]), (it) => this.createCondition(it));
   }
   match(node, context) {
-    return node.is(this.tagName) && this.pattern.every((cur) => cur.match(node, context));
+    return node.is(this.tagName) && this.conditions.every((cur) => cur.match(node, context));
   }
-  createMatcher(pattern) {
+  createCondition(pattern) {
     switch (pattern[0]) {
       case ".":
-        return new ClassMatcher(pattern.slice(1));
+        return new ClassCondition(pattern.slice(1));
       case "#":
-        return new IdMatcher(pattern.slice(1));
+        return new IdCondition(pattern.slice(1));
       case "[":
-        return new AttrMatcher(pattern.slice(1, -1));
+        return new AttributeCondition(pattern.slice(1, -1));
       case ":":
-        return new PseudoClassMatcher(pattern.slice(1), this.selector);
+        return new PseudoClassCondition(pattern.slice(1), this.selector);
       default:
-        throw new Error(`Failed to create matcher for "${pattern}"`);
+        throw new Error(`Failed to create selector condition for "${pattern}"`);
+    }
+  }
+}
+
+function* ancestors$1(element) {
+  let current = element.parent;
+  while (current && !current.isRootElement()) {
+    yield current;
+    current = current.parent;
+  }
+}
+function* parent(element) {
+  const parent2 = element.parent;
+  if (parent2 && !parent2.isRootElement()) {
+    yield parent2;
+  }
+}
+function* adjacentSibling(element) {
+  const sibling = element.previousSibling;
+  if (sibling) {
+    yield sibling;
+  }
+}
+function* generalSibling(element) {
+  const siblings = element.siblings;
+  const index = siblings.findIndex((it) => it.isSameNode(element));
+  for (let i = 0; i < index; i++) {
+    yield siblings[i];
+  }
+}
+function* scope(element) {
+  yield element;
+}
+function candidatesFromCombinator(element, combinator) {
+  switch (combinator) {
+    case Combinator.DESCENDANT:
+      return ancestors$1(element);
+    case Combinator.CHILD:
+      return parent(element);
+    case Combinator.ADJACENT_SIBLING:
+      return adjacentSibling(element);
+    case Combinator.GENERAL_SIBLING:
+      return generalSibling(element);
+    case Combinator.SCOPE:
+      return scope(element);
+  }
+}
+function matchElement(element, compounds, context) {
+  if (compounds.length === 0) {
+    return true;
+  }
+  const last = compounds[compounds.length - 1];
+  if (!last.match(element, context)) {
+    return false;
+  }
+  const remainder = compounds.slice(0, -1);
+  if (remainder.length === 0) {
+    return true;
+  }
+  const candidates = candidatesFromCombinator(element, last.combinator);
+  for (const candidate of candidates) {
+    if (matchElement(candidate, remainder, context)) {
+      return true;
     }
   }
+  return false;
+}
+
+const escapedCodepoints = ["9", "a", "d"];
+function* splitSelectorElements(selector) {
+  let begin = 0;
+  let end = 0;
+  function initialState(ch, p) {
+    if (ch === "\\") {
+      return 1 /* ESCAPED */;
+    }
+    if (ch === " ") {
+      end = p;
+      return 2 /* WHITESPACE */;
+    }
+    return 0 /* INITIAL */;
+  }
+  function escapedState(ch) {
+    if (escapedCodepoints.includes(ch)) {
+      return 1 /* ESCAPED */;
+    }
+    return 0 /* INITIAL */;
+  }
+  function* whitespaceState(ch, p) {
+    if (ch === " ") {
+      return 2 /* WHITESPACE */;
+    }
+    yield selector.slice(begin, end);
+    begin = p;
+    end = p;
+    return 0 /* INITIAL */;
+  }
+  let state = 0 /* INITIAL */;
+  for (let p = 0; p < selector.length; p++) {
+    const ch = selector[p];
+    switch (state) {
+      case 0 /* INITIAL */:
+        state = initialState(ch, p);
+        break;
+      case 1 /* ESCAPED */:
+        state = escapedState(ch);
+        break;
+      case 2 /* WHITESPACE */:
+        state = yield* whitespaceState(ch, p);
+        break;
+    }
+  }
+  if (begin !== selector.length) {
+    yield selector.slice(begin);
+  }
+}
+
+function unescapeCodepoint(value) {
+  const replacement = {
+    "\\9 ": "	",
+    "\\a ": "\n",
+    "\\d ": "\r"
+  };
+  return value.replace(
+    /(\\[\u0039\u0061\u0064] )/g,
+    (_, codepoint) => replacement[codepoint]
+  );
+}
+function escapeSelectorComponent(text) {
+  const codepoints = {
+    "	": "\\9 ",
+    "\n": "\\a ",
+    "\r": "\\d "
+  };
+  return text.toString().replace(/([\t\n\r]|[^a-z0-9_-])/gi, (_, ch) => {
+    if (codepoints[ch]) {
+      return codepoints[ch];
+    } else {
+      return `\\${ch}`;
+    }
+  });
+}
+function generateIdSelector(id) {
+  const escaped = escapeSelectorComponent(id);
+  return escaped.match(/^\d/) ? `[id="${escaped}"]` : `#${escaped}`;
 }
 class Selector {
   pattern;
@@ -2199,6 +2266,13 @@ class Selector {
     const context = { scope: root };
     yield* this.matchInternal(root, 0, context);
   }
+  /**
+   * Returns `true` if the element matches this selector.
+   */
+  matchElement(element) {
+    const context = { scope: null };
+    return matchElement(element, this.pattern, context);
+  }
   *matchInternal(root, level, context) {
     if (level >= this.pattern.length) {
       yield root;
@@ -2216,7 +2290,7 @@ class Selector {
   static parse(selector) {
     selector = selector.replace(/([+~>]) /g, "$1");
     return Array.from(splitSelectorElements(selector), (element) => {
-      return new Pattern(unescapeCodepoint(element));
+      return new Compound(unescapeCodepoint(element));
     });
   }
   static findCandidates(root, pattern) {
@@ -2232,7 +2306,6 @@ class Selector {
       case Combinator.SCOPE:
         return [root];
     }
-    return [];
   }
   static findAdjacentSibling(node) {
     let adjacent = false;
@@ -2568,17 +2641,11 @@ class HtmlElement extends DOMNode {
    *
    * Implementation of DOM specification of Element.matches(selectors).
    */
-  matches(selector) {
-    let root = this;
-    while (root.parent) {
-      root = root.parent;
-    }
-    for (const match of root.querySelectorAll(selector)) {
-      if (match.unique === this.unique) {
-        return true;
-      }
-    }
-    return false;
+  matches(selectorList) {
+    return selectorList.split(",").some((it) => {
+      const selector = new Selector(it.trim());
+      return selector.matchElement(this);
+    });
   }
   get meta() {
     return this.metaElement;
@@ -6626,7 +6693,7 @@ class HeadingLevel extends Rule {
   constructor(options) {
     super({ ...defaults$j, ...options });
     this.minInitialRank = parseMaxInitial(this.options.minInitialRank);
-    this.sectionRoots = this.options.sectioningRoots.map((it) => new Pattern(it));
+    this.sectionRoots = this.options.sectioningRoots.map((it) => new Compound(it));
     this.stack.push({
       node: null,
       current: 0,
@@ -11643,7 +11710,7 @@ class EventHandler {
 }
 
 const name = "html-validate";
-const version = "9.4.0";
+const version = "9.4.2-rc.1";
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";
 
 function freeze(src) {