Fix support for parent-sensitive pseudos

Previously, `:any`, `:matches`, and `:not` did not support
selectors sensitive to their parent.
This is now fixed.

Closes GH-5.

Author: wooorm

lib/any.js

@@ -78,15 +78,22 @@ function rule(query, tree, state) {
     0,
     null,
     configure(query, {
-      schema: state.space === 'svg' ? svg : html,
-      language: undefined,
-      direction: 'ltr',
-      editableOrEditingHost: false,
       // @ts-expect-error assume elements.
       scopeElements: tree.type === 'root' ? tree.children : [tree],
       iterator,
       one: state.one,
-      shallow: state.shallow
+      shallow: state.shallow,
+      index: false,
+      found: false,
+      space: state.space,
+      schema: state.space === 'svg' ? svg : html,
+      language: undefined,
+      direction: 'ltr',
+      editableOrEditingHost: false,
+      typeIndex: state.typeIndex,
+      elementIndex: state.elementIndex,
+      typeCount: state.typeCount,
+      elementCount: state.elementCount
     })
   )
 

lib/nest.js

@@ -1,6 +1,5 @@
 /**
  * @typedef {import('./types.js').Rule} Rule
- * @typedef {import('./types.js').Node} Node
  * @typedef {import('./types.js').Element} Element
  * @typedef {import('./types.js').Parent} Parent
  * @typedef {import('./types.js').SelectState} SelectState

lib/pseudo.js

@@ -56,10 +56,13 @@ const handle = zwitch('name', {
 })
 
 pseudo.needsIndex = [
+  'any',
   'first-child',
   'first-of-type',
   'last-child',
   'last-of-type',
+  'matches',
+  'not',
   'nth-child',
   'nth-last-child',
   'nth-of-type',
@@ -90,16 +93,16 @@ export function pseudo(query, element, index, parent, state) {
 /**
  * @param {RulePseudoSelector} query
  * @param {Element} element
- * @param {number|null} _1
- * @param {Parent|null} _2
+ * @param {number|null} _
+ * @param {Parent|null} parent
  * @param {SelectState} state
  * @returns {boolean}
  */
-function matches(query, element, _1, _2, state) {
+function matches(query, element, _, parent, state) {
   const shallow = state.shallow
   const one = state.one
 
-  state.shallow = true
+  state.shallow = false
   state.one = true
 
   const result = any(query.value, element, state)[0] === element
@@ -525,12 +528,12 @@ function assertDeep(state, query) {
 /**
  * @param {RulePseudoSelector} query
  * @param {Element} element
- * @param {number|null} _2
- * @param {Parent|null} _3
+ * @param {number|null} _1
+ * @param {Parent|null} _2
  * @param {SelectState} state
  * @returns {boolean}
  */
-function has(query, element, _2, _3, state) {
+function has(query, element, _1, _2, state) {
   const shallow = state.shallow
   const one = state.one
   const scopeElements = state.scopeElements

lib/test.js

@@ -1,10 +1,8 @@
 /**
  * @typedef {import('./types.js').Rule} Rule
  * @typedef {import('./types.js').HastNode} HastNode
- * @typedef {import('./types.js').Element} Element
  * @typedef {import('./types.js').Parent} Parent
  * @typedef {import('./types.js').SelectState} SelectState
- * @typedef {import('hast-util-is-element').AssertPredicate<Element>} IsElement
  */
 
 import {attribute} from './attribute.js'

lib/types.js

@@ -54,10 +54,15 @@
  * @property {string} [language]
  * @property {Direction} [direction]
  * @property {boolean} [editableOrEditingHost]
- * @property {number} [typeIndex] Track siblings
- * @property {number} [elementIndex] Track siblings
- * @property {number} [typeCount] Track siblings
- * @property {number} [elementCount] Track siblings
+ * @property {number} [typeIndex]
+ *   Track siblings: this current element has `n` elements with its tag name
+ *   before it.
+ * @property {number} [elementIndex]
+ *   Track siblings: this current element has `n` elements before it.
+ * @property {number} [typeCount]
+ *   Track siblings: there are `n` siblings with this element’s tag name.
+ * @property {number} [elementCount]
+ *   Track siblings: there are `n` siblings.
  */
 
 /**

test/select-all.js

@@ -968,6 +968,36 @@ test('select.selectAll()', (t) => {
       t.end()
     })
 
+    t.test(':any', (t) => {
+      t.deepEqual(
+        selectAll('y:any(:first-child)', h('x', [h('y#a'), h('y#b')])),
+        [h('y#a')],
+        'should support parent-sensitive `:any`'
+      )
+
+      t.end()
+    })
+
+    t.test(':matches', (t) => {
+      t.deepEqual(
+        selectAll('y:matches(:first-child)', h('x', [h('y#a'), h('y#b')])),
+        [h('y#a')],
+        'should support parent-sensitive `:matches`'
+      )
+
+      t.end()
+    })
+
+    t.test(':not', (t) => {
+      t.deepEqual(
+        selectAll('y:not(:first-child)', h('x', [h('y#a'), h('y#b')])),
+        [h('y#b')],
+        'should support parent-sensitive `:not`'
+      )
+
+      t.end()
+    })
+
     t.end()
   })
 

test/select.js

@@ -912,6 +912,36 @@ test('select.select()', (t) => {
       t.end()
     })
 
+    t.test(':any', (t) => {
+      t.deepEqual(
+        select('y:any(:first-child)', h('x', [h('y#a'), h('y#b')])),
+        h('y#a'),
+        'should support parent-sensitive `:any`'
+      )
+
+      t.end()
+    })
+
+    t.test(':matches', (t) => {
+      t.deepEqual(
+        select('y:matches(:first-child)', h('x', [h('y#a'), h('y#b')])),
+        h('y#a'),
+        'should support parent-sensitive `:matches`'
+      )
+
+      t.end()
+    })
+
+    t.test(':not', (t) => {
+      t.deepEqual(
+        select('y:not(:first-child)', h('x', [h('y#a'), h('y#b')])),
+        h('y#b'),
+        'should support parent-sensitive `:not`'
+      )
+
+      t.end()
+    })
+
     t.end()
   })