Pseudo-elements cannot be qualified by a complex selector

A logical pseudo-class passes any restriction at its position to its arguments,
which are restricted to pseudos when the logical pseudo-class is compounded to
a pseudo-element.

The implementation checked that these arguments were pseudos allowed to be
compounded to this pseudo-element, but not whether they were combined.

Author: cdoublev

__tests__/value.js

@@ -4388,7 +4388,7 @@ describe('<selector-list>', () => {
             '::before:not(:only-child)',
             '::before:not(:not(:only-child))',
             '::before:not(type)',
-            '::before:not(:hover > type)',
+            '::before:not(:hover > :hover)',
             '::part(name):only-child',
             '::part(name):empty',
             '::part(name):nth-child(1)',
@@ -4400,6 +4400,7 @@ describe('<selector-list>', () => {
             '::part(name):not(type)',
             '::part(name):has(:hover)',
             '::part(name):not(:has(:hover))',
+            '::part(name):not(:hover > :hover)',
             // Invalid functional pseudo argument
             ':has(:not(:has(type)))',
             ':current(:not(type > type))',

lib/parse/preprocess.js

@@ -73,7 +73,9 @@ function preParseCalcValue(node) {
  * selectors.
  *
  * It aborts parsing when the input is at the back of a pseudo-element with no
- * internal structure but is still not at the end of the selector.
+ * internal structure, or in a functional pseudo compounded to it, but is still
+ * not at the end of the selector. It only aborts parsing the combinator if it
+ * is at the end of the selector.
  *
  * It aborts parsing when the grammar wants a relative selector but the context
  * only allows a compound selector.
@@ -85,14 +87,15 @@ function preParseCombinator(node) {
     const pseudoElement = findSibling(
         node,
         node => node.definition.name === '<pseudo-element-selector>',
-        ({ definition: { name } }) => name === '<subclass-selector>' || name?.startsWith('<relative'))
+        ({ definition: { name } }) => name === '<subclass-selector>' || name?.startsWith('<relative'),
+        true)
     if (pseudoElement) {
         const { value: [, [, { name, types, value }]] } = pseudoElement
         const definition = types[0] === '<function>'
             ? pseudos.elements.functions[name]
             : pseudos.elements.identifiers[value]
         if (!definition?.structured) {
-            return error(node)
+            return isComma(node.input.next()) ? null : error(node)
         }
     }
     const { context: { trees } } = node