├── .prettierignore
├── .npmrc
├── .gitignore
├── test
    ├── index.js
    ├── svg.js
    ├── core.js
    ├── select.js
    ├── select-all.js
    └── matches.js
├── index.js
├── .editorconfig
├── .github
    └── workflows
    │   ├── bb.yml
    │   └── main.yml
├── tsconfig.json
├── lib
    ├── id.js
    ├── name.js
    ├── parse.js
    ├── class-name.js
    ├── test.js
    ├── attribute.js
    ├── enter-state.js
    ├── index.js
    ├── walk.js
    └── pseudo.js
├── license
├── package.json
└── readme.md


/.prettierignore:
--------------------------------------------------------------------------------
1 | coverage/
2 | *.md
3 | 


--------------------------------------------------------------------------------
/.npmrc:
--------------------------------------------------------------------------------
1 | ignore-scripts=true
2 | package-lock=false
3 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | *.d.ts
2 | *.log
3 | *.map
4 | *.tsbuildinfo
5 | .DS_Store
6 | coverage/
7 | node_modules/
8 | yarn.lock
9 | 


--------------------------------------------------------------------------------
/test/index.js:
--------------------------------------------------------------------------------
1 | import './core.js'
2 | import './matches.js'
3 | import './select.js'
4 | import './select-all.js'
5 | import './svg.js'
6 | 


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
1 | /**
2 |  * @typedef {import('./lib/index.js').Space} Space
3 |  */
4 | 
5 | export {matches, select, selectAll} from './lib/index.js'
6 | 


--------------------------------------------------------------------------------
/.editorconfig:
--------------------------------------------------------------------------------
 1 | root = true
 2 | 
 3 | [*]
 4 | charset = utf-8
 5 | end_of_line = lf
 6 | indent_size = 2
 7 | indent_style = space
 8 | insert_final_newline = true
 9 | trim_trailing_whitespace = true
10 | 


--------------------------------------------------------------------------------
/.github/workflows/bb.yml:
--------------------------------------------------------------------------------
 1 | name: bb
 2 | on:
 3 |   issues:
 4 |     types: [closed, edited, labeled, opened, reopened, unlabeled]
 5 |   pull_request_target:
 6 |     types: [closed, edited, labeled, opened, reopened, unlabeled]
 7 | jobs:
 8 |   main:
 9 |     runs-on: ubuntu-latest
10 |     steps:
11 |       - uses: unifiedjs/beep-boop-beta@main
12 |         with:
13 |           repo-token: ${{secrets.GITHUB_TOKEN}}
14 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "checkJs": true,
 4 |     "customConditions": ["development"],
 5 |     "declarationMap": true,
 6 |     "declaration": true,
 7 |     "emitDeclarationOnly": true,
 8 |     "exactOptionalPropertyTypes": true,
 9 |     "lib": ["es2022"],
10 |     "module": "node16",
11 |     "strict": true,
12 |     "target": "es2022"
13 |   },
14 |   "exclude": ["coverage/", "node_modules/"],
15 |   "include": ["**/*.js"]
16 | }
17 | 


--------------------------------------------------------------------------------
/lib/id.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @import {AstId} from 'css-selector-parser'
 3 |  * @import {Element} from 'hast'
 4 |  */
 5 | 
 6 | /**
 7 |  * Check whether an element has an ID.
 8 |  *
 9 |  * @param {AstId} query
10 |  *   AST rule (with `ids`).
11 |  * @param {Element} element
12 |  *   Element.
13 |  * @returns {boolean}
14 |  *   Whether `element` matches `query`.
15 |  */
16 | export function id(query, element) {
17 |   return element.properties.id === query.name
18 | }
19 | 


--------------------------------------------------------------------------------
/lib/name.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @import {AstTagName} from 'css-selector-parser'
 3 |  * @import {Element} from 'hast'
 4 |  */
 5 | 
 6 | /**
 7 |  * Check whether an element has a tag name.
 8 |  *
 9 |  * @param {AstTagName} query
10 |  *   AST rule (with `tag`).
11 |  * @param {Element} element
12 |  *   Element.
13 |  * @returns {boolean}
14 |  *   Whether `element` matches `query`.
15 |  */
16 | export function name(query, element) {
17 |   return query.name === element.tagName
18 | }
19 | 


--------------------------------------------------------------------------------
/.github/workflows/main.yml:
--------------------------------------------------------------------------------
 1 | jobs:
 2 |   main:
 3 |     name: ${{matrix.node}}
 4 |     runs-on: ubuntu-latest
 5 |     steps:
 6 |       - uses: actions/checkout@v4
 7 |       - uses: actions/setup-node@v4
 8 |         with:
 9 |           node-version: ${{matrix.node}}
10 |       - run: npm install
11 |       - run: npm test
12 |       - uses: codecov/codecov-action@v5
13 |     strategy:
14 |       matrix:
15 |         node:
16 |           - lts/hydrogen
17 |           - node
18 | name: main
19 | on:
20 |   - pull_request
21 |   - push
22 | 


--------------------------------------------------------------------------------
/lib/parse.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @import {AstSelector} from 'css-selector-parser'
 3 |  */
 4 | 
 5 | import {createParser} from 'css-selector-parser'
 6 | 
 7 | const cssSelectorParse = createParser({syntax: 'selectors-4'})
 8 | 
 9 | /**
10 |  * @param {string} selector
11 |  *   Selector to parse.
12 |  * @returns {AstSelector}
13 |  *   Parsed selector.
14 |  */
15 | export function parse(selector) {
16 |   if (typeof selector !== 'string') {
17 |     throw new TypeError('Expected `string` as selector, not `' + selector + '`')
18 |   }
19 | 
20 |   return cssSelectorParse(selector)
21 | }
22 | 


--------------------------------------------------------------------------------
/lib/class-name.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @import {AstClassName} from 'css-selector-parser'
 3 |  * @import {Element} from 'hast'
 4 |  */
 5 | 
 6 | /** @type {Array<never>} */
 7 | const emptyClassNames = []
 8 | 
 9 | /**
10 |  * Check whether an element has all class names.
11 |  *
12 |  * @param {AstClassName} query
13 |  *   AST rule (with `classNames`).
14 |  * @param {Element} element
15 |  *   Element.
16 |  * @returns {boolean}
17 |  *   Whether `element` matches `query`.
18 |  */
19 | export function className(query, element) {
20 |   // Assume array.
21 |   const value = /** @type {Readonly<Array<string>>} */ (
22 |     element.properties.className || emptyClassNames
23 |   )
24 | 
25 |   return value.includes(query.name)
26 | }
27 | 


--------------------------------------------------------------------------------
/license:
--------------------------------------------------------------------------------
 1 | (The MIT License)
 2 | 
 3 | Copyright (c) Titus Wormer <tituswormer@gmail.com>
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining
 6 | a copy of this software and associated documentation files (the
 7 | 'Software'), to deal in the Software without restriction, including
 8 | without limitation the rights to use, copy, modify, merge, publish,
 9 | distribute, sublicense, and/or sell copies of the Software, and to
10 | permit persons to whom the Software is furnished to do so, subject to
11 | the following conditions:
12 | 
13 | The above copyright notice and this permission notice shall be
14 | included in all copies or substantial portions of the Software.
15 | 
16 | THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19 | IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
20 | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
21 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
22 | SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 | 


--------------------------------------------------------------------------------
/lib/test.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @import {AstRule} from 'css-selector-parser'
 3 |  * @import {Element, Parents} from 'hast'
 4 |  * @import {State} from './index.js'
 5 |  */
 6 | 
 7 | import {attribute} from './attribute.js'
 8 | import {className} from './class-name.js'
 9 | import {id} from './id.js'
10 | import {name} from './name.js'
11 | import {pseudo} from './pseudo.js'
12 | 
13 | /**
14 |  * Test a rule.
15 |  *
16 |  * @param {AstRule} query
17 |  *   AST rule (with `pseudoClasses`).
18 |  * @param {Element} element
19 |  *   Element.
20 |  * @param {number | undefined} index
21 |  *   Index of `element` in `parent`.
22 |  * @param {Parents | undefined} parent
23 |  *   Parent of `element`.
24 |  * @param {State} state
25 |  *   State.
26 |  * @returns {boolean}
27 |  *   Whether `element` matches `query`.
28 |  */
29 | export function test(query, element, index, parent, state) {
30 |   for (const item of query.items) {
31 |     // eslint-disable-next-line unicorn/prefer-switch
32 |     if (item.type === 'Attribute') {
33 |       if (!attribute(item, element, state.schema)) return false
34 |     } else if (item.type === 'Id') {
35 |       if (!id(item, element)) return false
36 |     } else if (item.type === 'ClassName') {
37 |       if (!className(item, element)) return false
38 |     } else if (item.type === 'PseudoClass') {
39 |       if (!pseudo(item, element, index, parent, state)) return false
40 |     } else if (item.type === 'PseudoElement') {
41 |       throw new Error('Invalid selector: `::' + item.name + '`')
42 |     } else if (item.type === 'TagName') {
43 |       if (!name(item, element)) return false
44 |     } else {
45 |       // Otherwise `item.type` is `WildcardTag`, which matches.
46 |     }
47 |   }
48 | 
49 |   return true
50 | }
51 | 


--------------------------------------------------------------------------------
/test/svg.js:
--------------------------------------------------------------------------------
 1 | import assert from 'node:assert/strict'
 2 | import test from 'node:test'
 3 | import {h, s} from 'hastscript'
 4 | import {select, selectAll} from 'hast-util-select'
 5 | import {u} from 'unist-builder'
 6 | 
 7 | test('svg', async function (t) {
 8 |   await t.test('should match svg (#1)', async function () {
 9 |     assert.deepEqual(
10 |       select(
11 |         '[writing-mode]',
12 |         u('root', [
13 |           s('svg', [s('text', {writingMode: 'lr-tb'}, '!')]),
14 |           s('p', [
15 |             h(
16 |               'text',
17 |               {writingMode: 'lr-tb'},
18 |               'this is a camelcased HTML attribute'
19 |             )
20 |           ])
21 |         ])
22 |       ),
23 |       s('text', {writingMode: 'lr-tb'}, '!')
24 |     )
25 |   })
26 | 
27 |   await t.test('should match svg (#2)', async function () {
28 |     assert.deepEqual(
29 |       selectAll(
30 |         '[writing-mode]',
31 |         u('root', [
32 |           s('svg', [s('text', {writingMode: 'lr-tb'}, '!')]),
33 |           s('p', [
34 |             h(
35 |               'text',
36 |               {writingMode: 'lr-tb'},
37 |               'this is a camelcased HTML attribute'
38 |             )
39 |           ])
40 |         ])
41 |       ),
42 |       [s('text', {writingMode: 'lr-tb'}, '!')]
43 |     )
44 |   })
45 | 
46 |   await t.test('should match svg (#3)', async function () {
47 |     assert.deepEqual(
48 |       select('[writing-mode]', s('text', {writingMode: 'lr-tb'}, '!')),
49 |       undefined
50 |     )
51 |   })
52 | 
53 |   await t.test('should match svg (#4)', async function () {
54 |     assert.deepEqual(
55 |       select('[writing-mode]', s('text', {writingMode: 'lr-tb'}, '!'), 'svg'),
56 |       s('text', {writingMode: 'lr-tb'}, '!')
57 |     )
58 |   })
59 | })
60 | 


--------------------------------------------------------------------------------
/lib/attribute.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * @import {AstAttribute} from 'css-selector-parser'
  3 |  * @import {Element, Properties} from 'hast'
  4 |  * @import {Info, Schema} from 'property-information'
  5 |  */
  6 | 
  7 | import {stringify as commas} from 'comma-separated-tokens'
  8 | import {ok as assert} from 'devlop'
  9 | import {find} from 'property-information'
 10 | import * as spaces from 'space-separated-tokens'
 11 | 
 12 | /**
 13 |  * @param {AstAttribute} query
 14 |  *   Query.
 15 |  * @param {Element} element
 16 |  *   Element.
 17 |  * @param {Schema} schema
 18 |  *   Schema of element.
 19 |  * @returns {boolean}
 20 |  *   Whether `element` matches `query`.
 21 |  */
 22 | export function attribute(query, element, schema) {
 23 |   const info = find(schema, query.name)
 24 |   const propertyValue = element.properties[info.property]
 25 |   let value = normalizeValue(propertyValue, info)
 26 | 
 27 |   // Exists.
 28 |   if (!query.value) {
 29 |     return value !== undefined
 30 |   }
 31 | 
 32 |   assert(query.value.type === 'String', 'expected plain string')
 33 |   let key = query.value.value
 34 | 
 35 |   // Case-sensitivity.
 36 |   if (query.caseSensitivityModifier === 'i') {
 37 |     key = key.toLowerCase()
 38 | 
 39 |     if (value) {
 40 |       value = value.toLowerCase()
 41 |     }
 42 |   }
 43 | 
 44 |   if (value !== undefined) {
 45 |     switch (query.operator) {
 46 |       // Exact.
 47 |       case '=': {
 48 |         return key === value
 49 |       }
 50 | 
 51 |       // Ends.
 52 |       case '$=': {
 53 |         return key === value.slice(-key.length)
 54 |       }
 55 | 
 56 |       // Contains.
 57 |       case '*=': {
 58 |         return value.includes(key)
 59 |       }
 60 | 
 61 |       // Begins.
 62 |       case '^=': {
 63 |         return key === value.slice(0, key.length)
 64 |       }
 65 | 
 66 |       // Exact or prefix.
 67 |       case '|=': {
 68 |         return (
 69 |           key === value ||
 70 |           (key === value.slice(0, key.length) &&
 71 |             value.charAt(key.length) === '-')
 72 |         )
 73 |       }
 74 | 
 75 |       // Space-separated list.
 76 |       case '~=': {
 77 |         return (
 78 |           // For all other values (including comma-separated lists), return whether this
 79 |           // is an exact match.
 80 |           key === value ||
 81 |           // If this is a space-separated list, and the query is contained in it, return
 82 |           // true.
 83 |           spaces.parse(value).includes(key)
 84 |         )
 85 |       }
 86 |       // Other values are not yet supported by CSS.
 87 |       // No default
 88 |     }
 89 |   }
 90 | 
 91 |   return false
 92 | }
 93 | 
 94 | /**
 95 |  *
 96 |  * @param {Properties[keyof Properties]} value
 97 |  * @param {Info} info
 98 |  * @returns {string | undefined}
 99 |  */
100 | function normalizeValue(value, info) {
101 |   if (value === null || value === undefined) {
102 |     // Empty.
103 |   } else if (typeof value === 'boolean') {
104 |     if (value) {
105 |       return info.attribute
106 |     }
107 |   } else if (Array.isArray(value)) {
108 |     if (value.length > 0) {
109 |       return (info.commaSeparated ? commas : spaces.stringify)(value)
110 |     }
111 |   } else {
112 |     return String(value)
113 |   }
114 | }
115 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "author": "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)",
  3 |   "bugs": "https://github.com/syntax-tree/hast-util-select/issues",
  4 |   "contributors": [
  5 |     "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)"
  6 |   ],
  7 |   "dependencies": {
  8 |     "@types/hast": "^3.0.0",
  9 |     "@types/unist": "^3.0.0",
 10 |     "bcp-47-match": "^2.0.0",
 11 |     "comma-separated-tokens": "^2.0.0",
 12 |     "css-selector-parser": "^3.0.0",
 13 |     "devlop": "^1.0.0",
 14 |     "direction": "^2.0.0",
 15 |     "hast-util-has-property": "^3.0.0",
 16 |     "hast-util-to-string": "^3.0.0",
 17 |     "hast-util-whitespace": "^3.0.0",
 18 |     "nth-check": "^2.0.0",
 19 |     "property-information": "^7.0.0",
 20 |     "space-separated-tokens": "^2.0.0",
 21 |     "unist-util-visit": "^5.0.0",
 22 |     "zwitch": "^2.0.0"
 23 |   },
 24 |   "description": "hast utility for `querySelector`, `querySelectorAll`, and `matches`",
 25 |   "devDependencies": {
 26 |     "@types/node": "^22.0.0",
 27 |     "c8": "^10.0.0",
 28 |     "hastscript": "^9.0.0",
 29 |     "prettier": "^3.0.0",
 30 |     "remark-cli": "^12.0.0",
 31 |     "remark-preset-wooorm": "^11.0.0",
 32 |     "type-coverage": "^2.0.0",
 33 |     "typescript": "^5.0.0",
 34 |     "unist-builder": "^4.0.0",
 35 |     "xo": "^0.60.0"
 36 |   },
 37 |   "exports": "./index.js",
 38 |   "files": [
 39 |     "lib/",
 40 |     "index.d.ts.map",
 41 |     "index.d.ts",
 42 |     "index.js"
 43 |   ],
 44 |   "funding": {
 45 |     "type": "opencollective",
 46 |     "url": "https://opencollective.com/unified"
 47 |   },
 48 |   "keywords": [
 49 |     "css",
 50 |     "hast-util",
 51 |     "hast",
 52 |     "html",
 53 |     "match",
 54 |     "matches",
 55 |     "query",
 56 |     "selectall",
 57 |     "selector",
 58 |     "select",
 59 |     "unist",
 60 |     "utility",
 61 |     "util"
 62 |   ],
 63 |   "license": "MIT",
 64 |   "name": "hast-util-select",
 65 |   "prettier": {
 66 |     "bracketSpacing": false,
 67 |     "semi": false,
 68 |     "singleQuote": true,
 69 |     "tabWidth": 2,
 70 |     "trailingComma": "none",
 71 |     "useTabs": false
 72 |   },
 73 |   "remarkConfig": {
 74 |     "plugins": [
 75 |       "remark-preset-wooorm"
 76 |     ]
 77 |   },
 78 |   "repository": "syntax-tree/hast-util-select",
 79 |   "scripts": {
 80 |     "build": "tsc --build --clean && tsc --build && type-coverage",
 81 |     "format": "remark --frail --output --quiet -- . && prettier --log-level warn --write -- . && xo --fix",
 82 |     "prepack": "npm run build && npm run format",
 83 |     "test-api": "node --conditions development test/index.js",
 84 |     "test-coverage": "c8 --100 --reporter lcov npm run test-api",
 85 |     "test": "npm run build && npm run format && npm run test-coverage"
 86 |   },
 87 |   "sideEffects": false,
 88 |   "typeCoverage": {
 89 |     "atLeast": 100,
 90 |     "detail": true,
 91 |     "ignoreCatch": true,
 92 |     "strict": true
 93 |   },
 94 |   "type": "module",
 95 |   "version": "6.0.4",
 96 |   "xo": {
 97 |     "overrides": [
 98 |       {
 99 |         "files": [
100 |           "test/**/*.js"
101 |         ],
102 |         "rules": {
103 |           "import/no-unassigned-import": "off",
104 |           "max-nested-callbacks": "off",
105 |           "no-await-in-loop": "off"
106 |         }
107 |       }
108 |     ],
109 |     "prettier": true,
110 |     "rules": {
111 |       "logical-assignment-operators": "off",
112 |       "max-params": "off",
113 |       "unicorn/prefer-at": "off"
114 |     }
115 |   }
116 | }
117 | 


--------------------------------------------------------------------------------
/test/core.js:
--------------------------------------------------------------------------------
  1 | import assert from 'node:assert/strict'
  2 | import test from 'node:test'
  3 | import {h} from 'hastscript'
  4 | import {selectAll} from 'hast-util-select'
  5 | import {u} from 'unist-builder'
  6 | 
  7 | test('hast-util-select', async function (t) {
  8 |   await t.test('should expose the public api', async function () {
  9 |     assert.deepEqual(Object.keys(await import('hast-util-select')).sort(), [
 10 |       'matches',
 11 |       'select',
 12 |       'selectAll'
 13 |     ])
 14 |   })
 15 | 
 16 |   await t.test('should select stuff (#1)', async function () {
 17 |     assert.deepEqual(
 18 |       selectAll(
 19 |         'dl > dt.foo:nth-of-type(odd)',
 20 |         u('root', [
 21 |           h('dl', [
 22 |             '\n  ',
 23 |             h('dt.foo', 'Alpha'),
 24 |             '\n  ',
 25 |             h('dd', 'Bravo'),
 26 |             '\n  ',
 27 |             h('dt', 'Charlie'),
 28 |             '\n  ',
 29 |             h('dd', 'Delta'),
 30 |             '\n  ',
 31 |             h('dt', 'Echo'),
 32 |             '\n  ',
 33 |             h('dd', 'Foxtrot'),
 34 |             '\n'
 35 |           ])
 36 |         ])
 37 |       ),
 38 |       [h('dt.foo', 'Alpha')]
 39 |     )
 40 |   })
 41 | 
 42 |   await t.test('should select stuff (#2)', async function () {
 43 |     assert.deepEqual(
 44 |       selectAll(
 45 |         '.foo ~ dd:nth-of-type(even)',
 46 |         u('root', [
 47 |           h('dl', [
 48 |             '\n  ',
 49 |             h('dt', 'Alpha'),
 50 |             '\n  ',
 51 |             h('dd', 'Bravo'),
 52 |             '\n  ',
 53 |             h('dt.foo', 'Charlie'),
 54 |             '\n  ',
 55 |             h('dd', 'Delta'),
 56 |             '\n  ',
 57 |             h('dt', 'Echo'),
 58 |             '\n  ',
 59 |             h('dd', 'Foxtrot'),
 60 |             '\n  ',
 61 |             h('dt', 'Golf'),
 62 |             '\n  ',
 63 |             h('dd', 'Hotel'),
 64 |             '\n'
 65 |           ])
 66 |         ])
 67 |       ),
 68 |       [h('dd', 'Delta'), h('dd', 'Hotel')]
 69 |     )
 70 |   })
 71 | 
 72 |   await t.test('should select stuff (#3)', async function () {
 73 |     assert.deepEqual(
 74 |       selectAll(
 75 |         '.foo + dd:nth-of-type(even)',
 76 |         u('root', [
 77 |           h('dl', [
 78 |             '\n  ',
 79 |             h('dt', 'Alpha'),
 80 |             '\n  ',
 81 |             h('dd', 'Bravo'),
 82 |             '\n  ',
 83 |             h('dt.foo', 'Charlie'),
 84 |             '\n  ',
 85 |             h('dd', 'Delta'),
 86 |             '\n  ',
 87 |             h('dt', 'Echo'),
 88 |             '\n  ',
 89 |             h('dd', 'Foxtrot'),
 90 |             '\n  ',
 91 |             h('dt', 'Golf'),
 92 |             '\n  ',
 93 |             h('dd', 'Hotel'),
 94 |             '\n'
 95 |           ])
 96 |         ])
 97 |       ),
 98 |       [h('dd', 'Delta')]
 99 |     )
100 |   })
101 | 
102 |   await t.test('should select stuff (#4)', async function () {
103 |     assert.deepEqual(
104 |       selectAll(
105 |         '.foo, :nth-of-type(even), [title]',
106 |         u('root', [
107 |           h('dl', [
108 |             h('dt', {title: 'bar'}, 'Alpha'),
109 |             h('dd', 'Bravo'),
110 |             h('dt.foo', 'Charlie'),
111 |             h('dd', 'Delta'),
112 |             h('dt', 'Echo'),
113 |             h('dd.foo', {title: 'baz'}, 'Foxtrot'),
114 |             h('dt', 'Golf'),
115 |             h('dd', 'Hotel')
116 |           ])
117 |         ])
118 |       ),
119 |       [
120 |         h('dt', {title: 'bar'}, 'Alpha'),
121 |         h('dt.foo', 'Charlie'),
122 |         h('dd', 'Delta'),
123 |         h('dd.foo', {title: 'baz'}, 'Foxtrot'),
124 |         h('dt', 'Golf'),
125 |         h('dd', 'Hotel')
126 |       ]
127 |     )
128 |   })
129 | 
130 |   await t.test('should select stuff (#5)', async function () {
131 |     assert.deepEqual(
132 |       selectAll(
133 |         'a:not([class])',
134 |         u('root', [h('a#w.a'), h('a#x'), h('a#y.b'), h('a#z')])
135 |       ),
136 |       [h('a#x'), h('a#z')],
137 |       'should support `:not` with multiple matches (GH-6)'
138 |     )
139 |   })
140 | })
141 | 


--------------------------------------------------------------------------------
/lib/enter-state.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * @import {Visitor} from 'unist-util-visit'
  3 |  * @import {ElementContent, Nodes} from 'hast'
  4 |  * @import {Direction, State} from './index.js'
  5 |  */
  6 | 
  7 | import {direction} from 'direction'
  8 | import {toString} from 'hast-util-to-string'
  9 | import {svg} from 'property-information'
 10 | import {EXIT, SKIP, visit} from 'unist-util-visit'
 11 | 
 12 | /**
 13 |  * Enter a node.
 14 |  *
 15 |  * The caller is responsible for calling the return value `exit`.
 16 |  *
 17 |  * @param {State} state
 18 |  *   Current state.
 19 |  *
 20 |  *   Will be mutated: `exit` undos the changes.
 21 |  * @param {Nodes} node
 22 |  *   Node to enter.
 23 |  * @returns {() => undefined}
 24 |  *   Call to exit.
 25 |  */
 26 | // eslint-disable-next-line complexity
 27 | export function enterState(state, node) {
 28 |   const schema = state.schema
 29 |   const language = state.language
 30 |   const currentDirection = state.direction
 31 |   const editableOrEditingHost = state.editableOrEditingHost
 32 |   /** @type {Direction | undefined} */
 33 |   let directionInferred
 34 | 
 35 |   if (node.type === 'element') {
 36 |     const lang = node.properties.xmlLang || node.properties.lang
 37 |     const type = node.properties.type || 'text'
 38 |     const direction = directionProperty(node)
 39 | 
 40 |     if (lang !== null && lang !== undefined) {
 41 |       state.language = String(lang)
 42 |     }
 43 | 
 44 |     if (schema && schema.space === 'html') {
 45 |       if (node.properties.contentEditable === 'true') {
 46 |         state.editableOrEditingHost = true
 47 |       }
 48 | 
 49 |       if (node.tagName === 'svg') {
 50 |         state.schema = svg
 51 |       }
 52 | 
 53 |       // See: <https://html.spec.whatwg.org/#the-directionality>.
 54 |       // Explicit `[dir=rtl]`.
 55 |       if (direction === 'rtl') {
 56 |         directionInferred = direction
 57 |       } else if (
 58 |         // Explicit `[dir=ltr]`.
 59 |         direction === 'ltr' ||
 60 |         // HTML with an invalid or no `[dir]`.
 61 |         (direction !== 'auto' && node.tagName === 'html') ||
 62 |         // `input[type=tel]` with an invalid or no `[dir]`.
 63 |         (direction !== 'auto' && node.tagName === 'input' && type === 'tel')
 64 |       ) {
 65 |         directionInferred = 'ltr'
 66 |         // `[dir=auto]` or `bdi` with an invalid or no `[dir]`.
 67 |       } else if (direction === 'auto' || node.tagName === 'bdi') {
 68 |         if (node.tagName === 'textarea') {
 69 |           // Check contents of `<textarea>`.
 70 |           directionInferred = directionBidi(toString(node))
 71 |         } else if (
 72 |           node.tagName === 'input' &&
 73 |           (type === 'email' ||
 74 |             type === 'search' ||
 75 |             type === 'tel' ||
 76 |             type === 'text')
 77 |         ) {
 78 |           // Check value of `<input>`.
 79 |           directionInferred = node.properties.value
 80 |             ? directionBidi(String(node.properties.value))
 81 |             : 'ltr'
 82 |         } else {
 83 |           // Check text nodes in `node`.
 84 |           visit(node, inferDirectionality)
 85 |         }
 86 |       }
 87 | 
 88 |       if (directionInferred) {
 89 |         state.direction = directionInferred
 90 |       }
 91 |     }
 92 |     // Turn off editing mode in non-HTML spaces.
 93 |     else if (state.editableOrEditingHost) {
 94 |       state.editableOrEditingHost = false
 95 |     }
 96 |   }
 97 | 
 98 |   return reset
 99 | 
100 |   /**
101 |    * @returns {undefined}
102 |    *   Nothing.
103 |    */
104 |   function reset() {
105 |     state.schema = schema
106 |     state.language = language
107 |     state.direction = currentDirection
108 |     state.editableOrEditingHost = editableOrEditingHost
109 |   }
110 | 
111 |   /** @type {Visitor<ElementContent>} */
112 |   function inferDirectionality(child) {
113 |     if (child.type === 'text') {
114 |       directionInferred = directionBidi(child.value)
115 |       return directionInferred ? EXIT : undefined
116 |     }
117 | 
118 |     if (
119 |       child !== node &&
120 |       child.type === 'element' &&
121 |       (child.tagName === 'bdi' ||
122 |         child.tagName === 'script' ||
123 |         child.tagName === 'style' ||
124 |         child.tagName === 'textare' ||
125 |         directionProperty(child))
126 |     ) {
127 |       return SKIP
128 |     }
129 |   }
130 | }
131 | 
132 | /**
133 |  * See `wooorm/direction`.
134 |  *
135 |  * @param {string} value
136 |  *   Value to check.
137 |  * @returns {Exclude<Direction, 'auto'> | undefined}
138 |  *   Directionality.
139 |  */
140 | function directionBidi(value) {
141 |   const result = direction(value)
142 |   return result === 'neutral' ? undefined : result
143 | }
144 | 
145 | /**
146 |  * @param {ElementContent} node
147 |  *   Node to check.
148 |  * @returns {Direction | undefined}
149 |  *   Directionality.
150 |  */
151 | function directionProperty(node) {
152 |   const value =
153 |     node.type === 'element' && typeof node.properties.dir === 'string'
154 |       ? node.properties.dir.toLowerCase()
155 |       : undefined
156 | 
157 |   return value === 'auto' || value === 'ltr' || value === 'rtl'
158 |     ? value
159 |     : undefined
160 | }
161 | 


--------------------------------------------------------------------------------
/lib/index.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * @import {AstSelector} from 'css-selector-parser'
  3 |  * @import {Element, Nodes, RootContent} from 'hast'
  4 |  * @import {Schema} from 'property-information'
  5 |  */
  6 | 
  7 | /**
  8 |  * @typedef {'html' | 'svg'} Space
  9 |  *   Name of namespace.
 10 |  *
 11 |  * @typedef {'auto' | 'ltr' | 'rtl'} Direction
 12 |  *   Direction.
 13 |  *
 14 |  * @typedef State
 15 |  *   Current state.
 16 |  * @property {Direction} direction
 17 |  *   Current direction.
 18 |  * @property {boolean} editableOrEditingHost
 19 |  *   Whether we’re in `contentEditable`.
 20 |  * @property {number | undefined} elementCount
 21 |  *   Track siblings: there are `n` siblings.
 22 |  * @property {number | undefined} elementIndex
 23 |  *   Track siblings: this current element has `n` elements before it.
 24 |  * @property {boolean} found
 25 |  *   Whether we found at least one match.
 26 |  * @property {string | undefined} language
 27 |  *   Current language.
 28 |  * @property {boolean} one
 29 |  *   Whether we can stop looking after we found one element.
 30 |  * @property {Array<Element>} results
 31 |  *   Matches.
 32 |  * @property {AstSelector} rootQuery
 33 |  *   Original root selectors.
 34 |  * @property {Schema} schema
 35 |  *   Current schema.
 36 |  * @property {Array<RootContent>} scopeElements
 37 |  *   Elements in scope.
 38 |  * @property {boolean} shallow
 39 |  *   Whether we only allow selectors without nesting.
 40 |  * @property {number | undefined} typeCount
 41 |  *   Track siblings: there are `n` siblings with this element’s tag name.
 42 |  * @property {number | undefined} typeIndex
 43 |  *   Track siblings: this current element has `n` elements with its tag name
 44 |  *   before it.
 45 |  */
 46 | 
 47 | import {html, svg} from 'property-information'
 48 | import {parse} from './parse.js'
 49 | import {walk} from './walk.js'
 50 | 
 51 | /**
 52 |  * Check that the given `node` matches `selector`.
 53 |  *
 54 |  * This only checks the element itself, not the surrounding tree.
 55 |  * Thus, nesting in selectors is not supported (`p b`, `p > b`), neither are
 56 |  * selectors like `:first-child`, etc.
 57 |  * This only checks that the given element matches the selector.
 58 |  *
 59 |  * @param {string} selector
 60 |  *   CSS selector, such as (`h1`, `a, b`).
 61 |  * @param {Nodes | null | undefined} [node]
 62 |  *   Node that might match `selector`, should be an element (optional).
 63 |  * @param {Space | null | undefined} [space='html']
 64 |  *   Name of namespace (default: `'html'`).
 65 |  * @returns {boolean}
 66 |  *   Whether `node` matches `selector`.
 67 |  */
 68 | export function matches(selector, node, space) {
 69 |   const state = createState(selector, node, space)
 70 |   state.one = true
 71 |   state.shallow = true
 72 |   walk(state, node || undefined)
 73 |   return state.results.length > 0
 74 | }
 75 | 
 76 | /**
 77 |  * Select the first element that matches `selector` in the given `tree`.
 78 |  * Searches the tree in *preorder*.
 79 |  *
 80 |  * @param {string} selector
 81 |  *   CSS selector, such as (`h1`, `a, b`).
 82 |  * @param {Nodes | null | undefined} [tree]
 83 |  *   Tree to search (optional).
 84 |  * @param {Space | null | undefined} [space='html']
 85 |  *   Name of namespace (default: `'html'`).
 86 |  * @returns {Element | undefined}
 87 |  *   First element in `tree` that matches `selector` or `undefined` if nothing
 88 |  *   is found; this could be `tree` itself.
 89 |  */
 90 | export function select(selector, tree, space) {
 91 |   const state = createState(selector, tree, space)
 92 |   state.one = true
 93 |   walk(state, tree || undefined)
 94 |   return state.results[0]
 95 | }
 96 | 
 97 | /**
 98 |  * Select all elements that match `selector` in the given `tree`.
 99 |  * Searches the tree in *preorder*.
100 |  *
101 |  * @param {string} selector
102 |  *   CSS selector, such as (`h1`, `a, b`).
103 |  * @param {Nodes | null | undefined} [tree]
104 |  *   Tree to search (optional).
105 |  * @param {Space | null | undefined} [space='html']
106 |  *   Name of namespace (default: `'html'`).
107 |  * @returns {Array<Element>}
108 |  *   Elements in `tree` that match `selector`.
109 |  *   This could include `tree` itself.
110 |  */
111 | export function selectAll(selector, tree, space) {
112 |   const state = createState(selector, tree, space)
113 |   walk(state, tree || undefined)
114 |   return state.results
115 | }
116 | 
117 | /**
118 |  * @param {string} selector
119 |  *   CSS selector, such as (`h1`, `a, b`).
120 |  * @param {Nodes | null | undefined} [tree]
121 |  *   Tree to search (optional).
122 |  * @param {Space | null | undefined} [space='html']
123 |  *   Name of namespace (default: `'html'`).
124 |  * @returns {State} State
125 |  *   State.
126 |  */
127 | function createState(selector, tree, space) {
128 |   return {
129 |     direction: 'ltr',
130 |     editableOrEditingHost: false,
131 |     elementCount: undefined,
132 |     elementIndex: undefined,
133 |     found: false,
134 |     language: undefined,
135 |     one: false,
136 |     // State of the query.
137 |     results: [],
138 |     rootQuery: parse(selector),
139 |     schema: space === 'svg' ? svg : html,
140 |     scopeElements: tree ? (tree.type === 'root' ? tree.children : [tree]) : [],
141 |     shallow: false,
142 |     typeIndex: undefined,
143 |     typeCount: undefined
144 |   }
145 | }
146 | 


--------------------------------------------------------------------------------
/lib/walk.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * @import {AstRule} from 'css-selector-parser'
  3 |  * @import {Element, Nodes, Parents} from 'hast'
  4 |  * @import {State} from './index.js'
  5 |  */
  6 | 
  7 | /**
  8 |  * @typedef Counts
  9 |  *   Info on elements in a parent.
 10 |  * @property {number} count
 11 |  *   Number of elements.
 12 |  * @property {Map<string, number>} types
 13 |  *   Number of elements by tag name.
 14 |  *
 15 |  * @typedef Nest
 16 |  *   Rule sets by nesting.
 17 |  * @property {Array<AstRule> | undefined} adjacentSibling
 18 |  *   `a + b`
 19 |  * @property {Array<AstRule> | undefined} descendant
 20 |  *   `a b`
 21 |  * @property {Array<AstRule> | undefined} directChild
 22 |  *   `a > b`
 23 |  * @property {Array<AstRule> | undefined} generalSibling
 24 |  *   `a ~ b`
 25 |  */
 26 | 
 27 | import {enterState} from './enter-state.js'
 28 | import {test} from './test.js'
 29 | 
 30 | /** @type {Array<never>} */
 31 | const empty = []
 32 | 
 33 | /**
 34 |  * Walk a tree.
 35 |  *
 36 |  * @param {State} state
 37 |  *   State.
 38 |  * @param {Nodes | undefined} tree
 39 |  *   Tree.
 40 |  */
 41 | export function walk(state, tree) {
 42 |   if (tree) {
 43 |     one(state, [], tree, undefined, undefined, tree)
 44 |   }
 45 | }
 46 | 
 47 | /**
 48 |  * Add a rule to a nesting map.
 49 |  *
 50 |  * @param {Nest} nest
 51 |  *   Nesting.
 52 |  * @param {keyof Nest} field
 53 |  *   Field.
 54 |  * @param {AstRule} rule
 55 |  *   Rule.
 56 |  */
 57 | function add(nest, field, rule) {
 58 |   const list = nest[field]
 59 |   if (list) {
 60 |     list.push(rule)
 61 |   } else {
 62 |     nest[field] = [rule]
 63 |   }
 64 | }
 65 | 
 66 | /**
 67 |  * Check in a parent.
 68 |  *
 69 |  * @param {State} state
 70 |  *   State.
 71 |  * @param {Nest} nest
 72 |  *   Nesting.
 73 |  * @param {Parents} node
 74 |  *   Parent.
 75 |  * @param {Nodes} tree
 76 |  *   Tree.
 77 |  * @returns {undefined}
 78 |  *   Nothing.
 79 |  */
 80 | function all(state, nest, node, tree) {
 81 |   const fromParent = combine(nest.descendant, nest.directChild)
 82 |   /** @type {Array<AstRule> | undefined} */
 83 |   let fromSibling
 84 |   let index = -1
 85 |   /**
 86 |    * Total counts.
 87 |    * @type {Counts}
 88 |    */
 89 |   const total = {count: 0, types: new Map()}
 90 |   /**
 91 |    * Counts of previous siblings.
 92 |    * @type {Counts}
 93 |    */
 94 |   const before = {count: 0, types: new Map()}
 95 | 
 96 |   while (++index < node.children.length) {
 97 |     count(total, node.children[index])
 98 |   }
 99 | 
100 |   index = -1
101 | 
102 |   while (++index < node.children.length) {
103 |     const child = node.children[index]
104 |     // Uppercase to prevent prototype polution, injecting `constructor` or so.
105 |     // Normalize because HTML is insensitive.
106 |     const name =
107 |       child.type === 'element' ? child.tagName.toUpperCase() : undefined
108 |     // Before counting further elements:
109 |     state.elementIndex = before.count
110 |     state.typeIndex = name ? before.types.get(name) || 0 : 0
111 |     // After counting all elements.
112 |     state.elementCount = total.count
113 |     state.typeCount = name ? total.types.get(name) : 0
114 | 
115 |     // Only apply if this is a parent, this should be an element, but we check
116 |     // for parents so that we delve into custom nodes too.
117 |     if ('children' in child) {
118 |       const forSibling = combine(fromParent, fromSibling)
119 |       const nest = one(
120 |         state,
121 |         forSibling,
122 |         node.children[index],
123 |         index,
124 |         node,
125 |         tree
126 |       )
127 |       fromSibling = combine(nest.generalSibling, nest.adjacentSibling)
128 |     }
129 | 
130 |     // We found one thing, and one is enough.
131 |     if (state.one && state.found) {
132 |       break
133 |     }
134 | 
135 |     count(before, node.children[index])
136 |   }
137 | }
138 | 
139 | /**
140 |  * Apply selectors to an element.
141 |  *
142 |  * @param {State} state
143 |  *   Current state.
144 |  * @param {Array<AstRule>} rules
145 |  *   Rules to apply.
146 |  * @param {Element} node
147 |  *   Element to apply rules to.
148 |  * @param {number | undefined} index
149 |  *   Index of `node` in `parent`.
150 |  * @param {Parents | undefined} parent
151 |  *   Parent of `node`.
152 |  * @returns {Nest}
153 |  *   Further rules.
154 |  */
155 | function applySelectors(state, rules, node, index, parent) {
156 |   /** @type {Nest} */
157 |   const nestResult = {
158 |     adjacentSibling: undefined,
159 |     descendant: undefined,
160 |     directChild: undefined,
161 |     generalSibling: undefined
162 |   }
163 |   let selectorIndex = -1
164 | 
165 |   while (++selectorIndex < rules.length) {
166 |     const rule = rules[selectorIndex]
167 | 
168 |     // We found one thing, and one is enough.
169 |     if (state.one && state.found) {
170 |       break
171 |     }
172 | 
173 |     // When shallow, we don’t allow nested rules.
174 |     // Idea: we could allow a stack of parents?
175 |     // Might get quite complex though.
176 |     if (state.shallow && rule.nestedRule) {
177 |       throw new Error('Expected selector without nesting')
178 |     }
179 | 
180 |     // If this rule matches:
181 |     if (test(rule, node, index, parent, state)) {
182 |       const nest = rule.nestedRule
183 | 
184 |       // Are there more?
185 |       if (nest) {
186 |         /** @type {keyof Nest} */
187 |         const label =
188 |           nest.combinator === '+'
189 |             ? 'adjacentSibling'
190 |             : nest.combinator === '~'
191 |               ? 'generalSibling'
192 |               : nest.combinator === '>'
193 |                 ? 'directChild'
194 |                 : 'descendant'
195 |         add(nestResult, label, nest)
196 |       } else {
197 |         // We have a match!
198 |         state.found = true
199 | 
200 |         if (!state.results.includes(node)) {
201 |           state.results.push(node)
202 |         }
203 |       }
204 |     }
205 | 
206 |     // Descendant.
207 |     if (rule.combinator === undefined) {
208 |       add(nestResult, 'descendant', rule)
209 |     }
210 |     // Adjacent.
211 |     else if (rule.combinator === '~') {
212 |       add(nestResult, 'generalSibling', rule)
213 |     }
214 |     // Drop direct child (`>`), adjacent sibling (`+`).
215 |   }
216 | 
217 |   return nestResult
218 | }
219 | 
220 | /**
221 |  * Combine two lists, if needed.
222 |  *
223 |  * This is optimized to create as few lists as possible.
224 |  *
225 |  * @param {Array<AstRule> | undefined} left
226 |  *   Rules.
227 |  * @param {Array<AstRule> | undefined} right
228 |  *   Rules.
229 |  * @returns {Array<AstRule>}
230 |  *   Rules.
231 |  */
232 | function combine(left, right) {
233 |   return left && right && left.length > 0 && right.length > 0
234 |     ? [...left, ...right]
235 |     : left && left.length > 0
236 |       ? left
237 |       : right && right.length > 0
238 |         ? right
239 |         : empty
240 | }
241 | 
242 | /**
243 |  * Count a node.
244 |  *
245 |  * @param {Counts} counts
246 |  *   Counts.
247 |  * @param {Nodes} node
248 |  *   Node (we’re looking for elements).
249 |  * @returns {undefined}
250 |  *   Nothing.
251 |  */
252 | function count(counts, node) {
253 |   if (node.type === 'element') {
254 |     // Uppercase to prevent prototype polution, injecting `constructor` or so.
255 |     // Normalize because HTML is insensitive.
256 |     const name = node.tagName.toUpperCase()
257 |     const count = (counts.types.get(name) || 0) + 1
258 |     counts.count++
259 |     counts.types.set(name, count)
260 |   }
261 | }
262 | 
263 | /**
264 |  * Check a node.
265 |  *
266 |  * @param {State} state
267 |  *   State.
268 |  * @param {Array<AstRule>} currentRules
269 |  *   Rules.
270 |  * @param {Nodes} node
271 |  *   Node.
272 |  * @param {number | undefined} index
273 |  *   Index of `node` in `parent`.
274 |  * @param {Parents | undefined} parent
275 |  *   Parent of `node`.
276 |  * @param {Nodes} tree
277 |  *   Tree.
278 |  * @returns {Nest}
279 |  *   Nesting.
280 |  */
281 | function one(state, currentRules, node, index, parent, tree) {
282 |   /** @type {Nest} */
283 |   let nestResult = {
284 |     adjacentSibling: undefined,
285 |     descendant: undefined,
286 |     directChild: undefined,
287 |     generalSibling: undefined
288 |   }
289 | 
290 |   const exit = enterState(state, node)
291 | 
292 |   if (node.type === 'element') {
293 |     let rootRules = state.rootQuery.rules
294 | 
295 |     // Remove direct child rules if this is the root.
296 |     // This only happens for a `:has()` rule, which can be like
297 |     // `a:has(> b)`.
298 |     if (parent && parent !== tree) {
299 |       rootRules = state.rootQuery.rules.filter(
300 |         (d) =>
301 |           d.combinator === undefined ||
302 |           (d.combinator === '>' && parent === tree)
303 |       )
304 |     }
305 | 
306 |     nestResult = applySelectors(
307 |       state,
308 |       // Try the root rules for this element too.
309 |       combine(currentRules, rootRules),
310 |       node,
311 |       index,
312 |       parent
313 |     )
314 |   }
315 | 
316 |   // If this is a parent, and we want to delve into them, and we haven’t found
317 |   // our single result yet.
318 |   if ('children' in node && !state.shallow && !(state.one && state.found)) {
319 |     all(state, nestResult, node, tree)
320 |   }
321 | 
322 |   exit()
323 | 
324 |   return nestResult
325 | }
326 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
  1 | # hast-util-select
  2 | 
  3 | [![Build][badge-build-image]][badge-build-url]
  4 | [![Coverage][badge-coverage-image]][badge-coverage-url]
  5 | [![Downloads][badge-downloads-image]][badge-downloads-url]
  6 | [![Size][badge-size-image]][badge-size-url]
  7 | 
  8 | [hast][github-hast] utility with equivalents for
  9 | `matches`, `querySelector`, and `querySelectorAll`.
 10 | 
 11 | ## Contents
 12 | 
 13 | * [What is this?](#what-is-this)
 14 | * [When should I use this?](#when-should-i-use-this)
 15 | * [Install](#install)
 16 | * [Use](#use)
 17 | * [API](#api)
 18 |   * [`matches(selector, node[, space])`](#matchesselector-node-space)
 19 |   * [`select(selector, tree[, space])`](#selectselector-tree-space)
 20 |   * [`selectAll(selector, tree[, space])`](#selectallselector-tree-space)
 21 |   * [`Space`](#space)
 22 | * [Support](#support)
 23 | * [Unsupported](#unsupported)
 24 | * [Types](#types)
 25 | * [Compatibility](#compatibility)
 26 | * [Security](#security)
 27 | * [Related](#related)
 28 | * [Contribute](#contribute)
 29 | * [License](#license)
 30 | 
 31 | ## What is this?
 32 | 
 33 | This package lets you find nodes in a tree,
 34 | similar to how `matches`,
 35 | `querySelector`,
 36 | and
 37 | `querySelectorAll` work with the DOM.
 38 | 
 39 | One notable difference between DOM and hast is that DOM nodes have references
 40 | to their parents,
 41 | meaning that `document.body.matches(':last-child')` can be evaluated to check
 42 | whether the body is the last child of its parent.
 43 | This information is not stored in hast,
 44 | so selectors like that don’t work.
 45 | 
 46 | ## When should I use this?
 47 | 
 48 | This is a small utility that is quite useful,
 49 | but is rather slow if you use it a lot.
 50 | For each call,
 51 | it has to walk the entire tree.
 52 | In some cases,
 53 | walking the tree once with
 54 | [`unist-util-visit`][github-unist-util-visit]
 55 | is smarter,
 56 | such as when you want to change certain nodes.
 57 | On the other hand,
 58 | this is quite powerful and fast enough for many other cases.
 59 | 
 60 | This utility is similar to
 61 | [`unist-util-select`][github-unist-util-select],
 62 | which can find and match any unist node.
 63 | 
 64 | ## Install
 65 | 
 66 | This package is [ESM only][github-gist-esm].
 67 | In Node.js (version 16+),
 68 | install with [npm][npmjs-install]:
 69 | 
 70 | ```sh
 71 | npm install hast-util-select
 72 | ```
 73 | 
 74 | In Deno with [`esm.sh`][esmsh]:
 75 | 
 76 | ```js
 77 | import {matches, select, selectAll} from 'https://esm.sh/hast-util-select@6'
 78 | ```
 79 | 
 80 | In browsers with [`esm.sh`][esmsh]:
 81 | 
 82 | ```html
 83 | <script type="module">
 84 |   import {matches, select, selectAll} from 'https://esm.sh/hast-util-select@6?bundle'
 85 | </script>
 86 | ```
 87 | 
 88 | ## Use
 89 | 
 90 | ```js
 91 | import {h} from 'hastscript'
 92 | import {matches, select, selectAll} from 'hast-util-select'
 93 | 
 94 | const tree = h('section', [
 95 |   h('p', 'Alpha'),
 96 |   h('p', 'Bravo'),
 97 |   h('h1', 'Charlie'),
 98 |   h('p', 'Delta'),
 99 |   h('p', 'Echo'),
100 |   h('p', 'Foxtrot'),
101 |   h('p', 'Golf')
102 | ])
103 | 
104 | console.log(matches('section', tree)) // `true`
105 | 
106 | console.log(select('h1 ~ :nth-child(even)', tree))
107 | // The paragraph with `Delta`
108 | 
109 | console.log(selectAll('h1 ~ :nth-child(even)', tree))
110 | // The paragraphs with `Delta` and `Foxtrot`
111 | ```
112 | 
113 | ## API
114 | 
115 | This package exports the identifiers [`matches`][api-matches],
116 | [`select`][api-select],
117 | and [`selectAll`][api-select-all].
118 | There is no default export.
119 | 
120 | ### `matches(selector, node[, space])`
121 | 
122 | Check that the given `node` matches `selector`.
123 | 
124 | This only checks the element itself,
125 | not the surrounding tree.
126 | Thus,
127 | nesting in selectors is not supported (`p b`, `p > b`),
128 | neither are selectors like `:first-child`,
129 | etc.
130 | This only checks that the given element matches the selector.
131 | 
132 | ###### Parameters
133 | 
134 | * `selector`
135 |   (`string`, example: `'h1'`, `'a, b'`)
136 |   — CSS selector
137 | * `node`
138 |   ([`Node`][github-hast-nodes], optional)
139 |   — node that might match `selector`,
140 |   should be an element
141 | * `space`
142 |   ([`Space`][api-space], default: `'html'`)
143 |   — name of namespace
144 | 
145 | ###### Returns
146 | 
147 | Whether `node` matches `selector` (`boolean`).
148 | 
149 | ###### Example
150 | 
151 | ```js
152 | import {h} from 'hastscript'
153 | import {matches} from 'hast-util-select'
154 | 
155 | matches('b, i', h('b')) // => true
156 | matches(':any-link', h('a')) // => false
157 | matches(':any-link', h('a', {href: '#'})) // => true
158 | matches('.classy', h('a', {className: ['classy']})) // => true
159 | matches('#id', h('a', {id: 'id'})) // => true
160 | matches('[lang|=en]', h('a', {lang: 'en'})) // => true
161 | matches('[lang|=en]', h('a', {lang: 'en-GB'})) // => true
162 | ```
163 | 
164 | ### `select(selector, tree[, space])`
165 | 
166 | Select the first element that matches `selector` in the given `tree`.
167 | Searches the tree in *[preorder][github-unist-preorder]*.
168 | 
169 | ###### Parameters
170 | 
171 | * `selector`
172 |   (`string`, example: `'h1'`, `'a, b'`)
173 |   — CSS selector, such as (`h1`, `a, b`)
174 | * `tree`
175 |   ([`Node`][github-hast-nodes], optional)
176 |   — tree to search
177 | * `space`
178 |   ([`Space`][api-space], default: `'html'`)
179 |   — name of namespace
180 | 
181 | ###### Returns
182 | 
183 | First element in `tree` that matches `selector` or `undefined` if nothing is
184 | found.
185 | This could be `tree` itself.
186 | 
187 | ###### Example
188 | 
189 | ```js
190 | import {h} from 'hastscript'
191 | import {select} from 'hast-util-select'
192 | 
193 | console.log(
194 |   select(
195 |     'h1 ~ :nth-child(even)',
196 |     h('section', [
197 |       h('p', 'Alpha'),
198 |       h('p', 'Bravo'),
199 |       h('h1', 'Charlie'),
200 |       h('p', 'Delta'),
201 |       h('p', 'Echo')
202 |     ])
203 |   )
204 | )
205 | ```
206 | 
207 | Yields:
208 | 
209 | ```js
210 | { type: 'element',
211 |   tagName: 'p',
212 |   properties: {},
213 |   children: [ { type: 'text', value: 'Delta' } ] }
214 | ```
215 | 
216 | ### `selectAll(selector, tree[, space])`
217 | 
218 | Select all elements that match `selector` in the given `tree`.
219 | Searches the tree in *[preorder][github-unist-preorder]*.
220 | 
221 | ###### Parameters
222 | 
223 | * `selector`
224 |   (`string`, example: `'h1'`, `'a, b'`)
225 |   — CSS selector
226 | * `tree`
227 |   ([`Node`][github-hast-nodes], optional)
228 |   — tree to search
229 | * `space`
230 |   ([`Space`][api-space], default: `'html'`)
231 |   — name of namespace
232 | 
233 | ###### Returns
234 | 
235 | Elements in `tree` that match `selector`.
236 | This could include `tree` itself.
237 | 
238 | ###### Example
239 | 
240 | ```js
241 | import {h} from 'hastscript'
242 | import {selectAll} from 'hast-util-select'
243 | 
244 | console.log(
245 |   selectAll(
246 |     'h1 ~ :nth-child(even)',
247 |     h('section', [
248 |       h('p', 'Alpha'),
249 |       h('p', 'Bravo'),
250 |       h('h1', 'Charlie'),
251 |       h('p', 'Delta'),
252 |       h('p', 'Echo'),
253 |       h('p', 'Foxtrot'),
254 |       h('p', 'Golf')
255 |     ])
256 |   )
257 | )
258 | ```
259 | 
260 | Yields:
261 | 
262 | ```js
263 | [ { type: 'element',
264 |     tagName: 'p',
265 |     properties: {},
266 |     children: [ { type: 'text', value: 'Delta' } ] },
267 |   { type: 'element',
268 |     tagName: 'p',
269 |     properties: {},
270 |     children: [ { type: 'text', value: 'Foxtrot' } ] } ]
271 | ```
272 | 
273 | ### `Space`
274 | 
275 | Namespace (TypeScript type).
276 | 
277 | ###### Type
278 | 
279 | ```ts
280 | type Space = 'html' | 'svg'
281 | ```
282 | 
283 | ## Support
284 | 
285 | * [x] `*` (universal selector)
286 | * [x] `,` (multiple selector)
287 | * [x] `p` (type selector)
288 | * [x] `.class` (class selector)
289 | * [x] `#id` (id selector)
290 | * [x] `article p` (combinator: descendant selector)
291 | * [x] `article > p` (combinator: child selector)
292 | * [x] `h1 + p` (combinator: next-sibling selector)
293 | * [x] `h1 ~ p` (combinator: subsequent sibling selector)
294 | * [x] `[attr]` (attribute existence)
295 | * [x] `[attr… i]` (attribute case-insensitive)
296 | * [x] `[attr… s]` (attribute case-sensitive) (useless, default)
297 | * [x] `[attr=value]` (attribute equality)
298 | * [x] `[attr~=value]` (attribute contains in space-separated list)
299 | * [x] `[attr|=value]` (attribute equality or prefix)
300 | * [x] `[attr^=value]` (attribute begins with)
301 | * [x] `[attr$=value]` (attribute ends with)
302 | * [x] `[attr*=value]` (attribute contains)
303 | * [x] `:dir()` (functional pseudo-class)
304 | * [x] `:has()` (functional pseudo-class; also supports `a:has(> b)`)
305 | * [x] `:is()` (functional pseudo-class)
306 | * [x] `:lang()` (functional pseudo-class)
307 | * [x] `:not()` (functional pseudo-class)
308 | * [x] `:any-link` (pseudo-class)
309 | * [x] `:blank` (pseudo-class)
310 | * [x] `:checked` (pseudo-class)
311 | * [x] `:disabled` (pseudo-class)
312 | * [x] `:empty` (pseudo-class)
313 | * [x] `:enabled` (pseudo-class)
314 | * [x] `:optional` (pseudo-class)
315 | * [x] `:read-only` (pseudo-class)
316 | * [x] `:read-write` (pseudo-class)
317 | * [x] `:required` (pseudo-class)
318 | * [x] `:root` (pseudo-class)
319 | * [x] `:scope` (pseudo-class):
320 | * [x] \* `:first-child` (pseudo-class)
321 | * [x] \* `:first-of-type` (pseudo-class)
322 | * [x] \* `:last-child` (pseudo-class)
323 | * [x] \* `:last-of-type` (pseudo-class)
324 | * [x] \* `:only-child` (pseudo-class)
325 | * [x] \* `:only-of-type` (pseudo-class)
326 | * [x] \* `:nth-child()` (functional pseudo-class)
327 | * [x] \* `:nth-last-child()` (functional pseudo-class)
328 | * [x] \* `:nth-last-of-type()` (functional pseudo-class)
329 | * [x] \* `:nth-of-type()` (functional pseudo-class)
330 | 
331 | ## Unsupported
332 | 
333 | * [ ] † `||` (column combinator)
334 | * [ ] † `ns|E` (namespace type selector)
335 | * [ ] † `*|E` (any namespace type selector)
336 | * [ ] † `|E` (no namespace type selector)
337 | * [ ] † `[ns|attr]` (namespace attribute)
338 | * [ ] † `[*|attr]` (any namespace attribute)
339 | * [ ] † `[|attr]` (no namespace attribute)
340 | * [ ] ‖ `:nth-child(n of S)` (functional pseudo-class, note: scoping to
341 |   parents is not supported)
342 | * [ ] ‖ `:nth-last-child(n of S)` (functional pseudo-class, note: scoping to
343 |   parents is not supported)
344 | * [ ] † `:active` (pseudo-class)
345 | * [ ] † `:autofill` (pseudo-class)
346 | * [ ] † `:buffering` (pseudo-class)
347 | * [ ] § `:closed` (pseudo-class)
348 | * [ ] † `:current` (pseudo-class)
349 | * [ ] † `:current()` (functional pseudo-class)
350 | * [ ] † `:default` (pseudo-class)
351 | * [ ] † `:defined` (pseudo-class)
352 | * [ ] † `:focus` (pseudo-class)
353 | * [ ] † `:focus-visible` (pseudo-class)
354 | * [ ] † `:focus-within` (pseudo-class)
355 | * [ ] † `:fullscreen` (pseudo-class)
356 | * [ ] † `:future` (pseudo-class)
357 | * [ ] § `:host()` (functional pseudo-class)
358 | * [ ] § `:host-context()` (functional pseudo-class)
359 | * [ ] † `:hover` (pseudo-class)
360 | * [ ] ‡ `:in-range` (pseudo-class)
361 | * [ ] † `:indeterminate` (pseudo-class)
362 | * [ ] ‡ `:invalid` (pseudo-class)
363 | * [ ] † `:link` (pseudo-class)
364 | * [ ] † `:local-link` (pseudo-class)
365 | * [ ] † `:modal` (pseudo-class)
366 | * [ ] † `:muted` (pseudo-class)
367 | * [ ] † `:nth-col()` (functional pseudo-class)
368 | * [ ] † `:nth-last-col()` (functional pseudo-class)
369 | * [ ] § `:open` (pseudo-class)
370 | * [ ] ‡ `:out-of-range` (pseudo-class)
371 | * [ ] † `:past` (pseudo-class)
372 | * [ ] † `:paused` (pseudo-class)
373 | * [ ] † `:placeholder-shown` (pseudo-class)
374 | * [ ] † `:playing` (pseudo-class)
375 | * [ ] † `:seeking` (pseudo-class)
376 | * [ ] † `:stalled` (pseudo-class)
377 | * [ ] † `:target` (pseudo-class)
378 | * [ ] † `:target-within` (pseudo-class)
379 | * [ ] † `:user-invalid` (pseudo-class)
380 | * [ ] ‡ `:valid` (pseudo-class)
381 | * [ ] † `:visited` (pseudo-class)
382 | * [ ] † `:volume-locked` (pseudo-class)
383 | * [ ] § `:where()` (functional pseudo-class)
384 | * [ ] † `::before` (pseudo-elements: none are supported)
385 | 
386 | ###### Notes
387 | 
388 | * \* — not supported in `matches`
389 | * † — needs a user,
390 |   browser,
391 |   interactivity,
392 |   scripting,
393 |   or whole CSS to make sense
394 | * ‡ — not very interested in writing / including the code for this
395 | * § — too new,
396 |   the spec is still changing
397 | * ‖ — pr wanted!
398 | * `:any()` and `:matches()` are renamed to `:is()` in CSS.
399 | 
400 | ## Types
401 | 
402 | This package is fully typed with [TypeScript][].
403 | It exports the additional type [`Space`][api-space].
404 | 
405 | ## Compatibility
406 | 
407 | Projects maintained by the unified collective are compatible with maintained
408 | versions of Node.js.
409 | 
410 | When we cut a new major release,
411 | we drop support for unmaintained versions of Node.
412 | This means we try to keep the current release line,
413 | `hast-util-select@6`,
414 | compatible with Node.js 16.
415 | 
416 | ## Security
417 | 
418 | This package does not change the syntax tree so there are no openings for
419 | [cross-site scripting (XSS)][wikipedia-xss] attacks.
420 | 
421 | ## Related
422 | 
423 | * [`unist-util-select`][github-unist-util-select]
424 |   — select unist nodes with CSS-like selectors
425 | * [`hast-util-find-and-replace`](https://github.com/syntax-tree/hast-util-find-and-replace)
426 |   — find and replace text in a hast tree
427 | * [`hast-util-parse-selector`](https://github.com/syntax-tree/hast-util-parse-selector)
428 |   — create an element from a simple CSS selector
429 | * [`hast-util-from-selector`](https://github.com/syntax-tree/hast-util-from-selector)
430 |   — create an element from a complex CSS selector
431 | 
432 | ## Contribute
433 | 
434 | See [`contributing.md`][health-contributing]
435 | in
436 | [`syntax-tree/.github`][health]
437 | for ways to get started.
438 | See [`support.md`][health-support] for ways to get help.
439 | 
440 | This project has a [code of conduct][health-coc].
441 | By interacting with this repository,
442 | organization,
443 | or community you agree to abide by its terms.
444 | 
445 | ## License
446 | 
447 | [MIT][file-license] © [Titus Wormer][wooorm]
448 | 
449 | <!-- Definitions -->
450 | 
451 | [api-matches]: #matchesselector-node-space
452 | 
453 | [api-select]: #selectselector-tree-space
454 | 
455 | [api-select-all]: #selectallselector-tree-space
456 | 
457 | [api-space]: #space
458 | 
459 | [badge-build-image]: https://github.com/syntax-tree/hast-util-select/workflows/main/badge.svg
460 | 
461 | [badge-build-url]: https://github.com/syntax-tree/hast-util-select/actions
462 | 
463 | [badge-coverage-image]: https://img.shields.io/codecov/c/github/syntax-tree/hast-util-select.svg
464 | 
465 | [badge-coverage-url]: https://codecov.io/github/syntax-tree/hast-util-select
466 | 
467 | [badge-downloads-image]: https://img.shields.io/npm/dm/hast-util-select.svg
468 | 
469 | [badge-downloads-url]: https://www.npmjs.com/package/hast-util-select
470 | 
471 | [badge-size-image]: https://img.shields.io/bundlejs/size/hast-util-select
472 | 
473 | [badge-size-url]: https://bundlejs.com/?q=hast-util-select
474 | 
475 | [esmsh]: https://esm.sh
476 | 
477 | [file-license]: license
478 | 
479 | [github-gist-esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c
480 | 
481 | [github-hast]: https://github.com/syntax-tree/hast
482 | 
483 | [github-hast-nodes]: https://github.com/syntax-tree/hast#nodes
484 | 
485 | [github-unist-preorder]: https://github.com/syntax-tree/unist#preorder
486 | 
487 | [github-unist-util-select]: https://github.com/syntax-tree/unist-util-select
488 | 
489 | [github-unist-util-visit]: https://github.com/syntax-tree/unist-util-visit
490 | 
491 | [health]: https://github.com/syntax-tree/.github
492 | 
493 | [health-coc]: https://github.com/syntax-tree/.github/blob/main/code-of-conduct.md
494 | 
495 | [health-contributing]: https://github.com/syntax-tree/.github/blob/main/contributing.md
496 | 
497 | [health-support]: https://github.com/syntax-tree/.github/blob/main/support.md
498 | 
499 | [npmjs-install]: https://docs.npmjs.com/cli/install
500 | 
501 | [typescript]: https://www.typescriptlang.org
502 | 
503 | [wikipedia-xss]: https://en.wikipedia.org/wiki/Cross-site_scripting
504 | 
505 | [wooorm]: https://wooorm.com
506 | 


--------------------------------------------------------------------------------
/lib/pseudo.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * @import {AstPseudoClass} from 'css-selector-parser'
  3 |  * @import {default as NthCheck} from 'nth-check'
  4 |  * @import {ElementContent, Element, Parents} from 'hast'
  5 |  * @import {State} from './index.js'
  6 |  */
  7 | 
  8 | import {extendedFilter} from 'bcp-47-match'
  9 | import {parse as commas} from 'comma-separated-tokens'
 10 | import {ok as assert, unreachable} from 'devlop'
 11 | import {hasProperty} from 'hast-util-has-property'
 12 | import {whitespace} from 'hast-util-whitespace'
 13 | import fauxEsmNthCheck from 'nth-check'
 14 | import {zwitch} from 'zwitch'
 15 | import {walk} from './walk.js'
 16 | 
 17 | /** @type {NthCheck} */
 18 | // @ts-expect-error: types are broken.
 19 | const nthCheck = fauxEsmNthCheck.default || fauxEsmNthCheck
 20 | 
 21 | /** @type {(rule: AstPseudoClass, element: Element, index: number | undefined, parent: Parents | undefined, state: State) => boolean} */
 22 | export const pseudo = zwitch('name', {
 23 |   handlers: {
 24 |     'any-link': anyLink,
 25 |     blank,
 26 |     checked,
 27 |     dir,
 28 |     disabled,
 29 |     empty,
 30 |     enabled,
 31 |     'first-child': firstChild,
 32 |     'first-of-type': firstOfType,
 33 |     has,
 34 |     is,
 35 |     lang,
 36 |     'last-child': lastChild,
 37 |     'last-of-type': lastOfType,
 38 |     not,
 39 |     'nth-child': nthChild,
 40 |     'nth-last-child': nthLastChild,
 41 |     'nth-last-of-type': nthLastOfType,
 42 |     'nth-of-type': nthOfType,
 43 |     'only-child': onlyChild,
 44 |     'only-of-type': onlyOfType,
 45 |     optional,
 46 |     'read-only': readOnly,
 47 |     'read-write': readWrite,
 48 |     required,
 49 |     root,
 50 |     scope
 51 |   },
 52 |   invalid: invalidPseudo,
 53 |   unknown: unknownPseudo
 54 | })
 55 | 
 56 | /**
 57 |  * Check whether an element matches an `:any-link` pseudo.
 58 |  *
 59 |  * @param {AstPseudoClass} _
 60 |  *   Query.
 61 |  * @param {Element} element
 62 |  *   Element.
 63 |  * @returns {boolean}
 64 |  *   Whether `element` matches `query`.
 65 |  */
 66 | function anyLink(_, element) {
 67 |   return (
 68 |     (element.tagName === 'a' ||
 69 |       element.tagName === 'area' ||
 70 |       element.tagName === 'link') &&
 71 |     hasProperty(element, 'href')
 72 |   )
 73 | }
 74 | 
 75 | /**
 76 |  * @param {State} state
 77 |  *   State.
 78 |  * @param {AstPseudoClass} query
 79 |  *   Query.
 80 |  */
 81 | function assertDeep(state, query) {
 82 |   if (state.shallow) {
 83 |     throw new Error('Cannot use `:' + query.name + '` without parent')
 84 |   }
 85 | }
 86 | 
 87 | /**
 88 |  * Check whether an element matches a `:blank` pseudo.
 89 |  *
 90 |  * @param {AstPseudoClass} _
 91 |  *   Query.
 92 |  * @param {Element} element
 93 |  *   Element.
 94 |  * @returns {boolean}
 95 |  *   Whether `element` matches `query`.
 96 |  */
 97 | function blank(_, element) {
 98 |   return !someChildren(element, check)
 99 | 
100 |   /**
101 |    * @param {ElementContent} child
102 |    * @returns {boolean}
103 |    */
104 |   function check(child) {
105 |     return (
106 |       child.type === 'element' || (child.type === 'text' && !whitespace(child))
107 |     )
108 |   }
109 | }
110 | 
111 | /**
112 |  * Check whether an element matches a `:checked` pseudo.
113 |  *
114 |  * @param {AstPseudoClass} _
115 |  *   Query.
116 |  * @param {Element} element
117 |  *   Element.
118 |  * @returns {boolean}
119 |  *   Whether `element` matches `query`.
120 |  */
121 | function checked(_, element) {
122 |   if (element.tagName === 'input' || element.tagName === 'menuitem') {
123 |     return Boolean(
124 |       (element.properties.type === 'checkbox' ||
125 |         element.properties.type === 'radio') &&
126 |         hasProperty(element, 'checked')
127 |     )
128 |   }
129 | 
130 |   if (element.tagName === 'option') {
131 |     return hasProperty(element, 'selected')
132 |   }
133 | 
134 |   return false
135 | }
136 | 
137 | /**
138 |  * Check whether an element matches a `:dir()` pseudo.
139 |  *
140 |  * @param {AstPseudoClass} query
141 |  *   Query.
142 |  * @param {Element} _1
143 |  *   Element.
144 |  * @param {number | undefined} _2
145 |  *   Index of `element` in `parent`.
146 |  * @param {Parents | undefined} _3
147 |  *   Parent of `element`.
148 |  * @param {State} state
149 |  *   State.
150 |  * @returns {boolean}
151 |  *   Whether `element` matches `query`.
152 |  */
153 | // eslint-disable-next-line unicorn/prevent-abbreviations
154 | function dir(query, _1, _2, _3, state) {
155 |   assert(query.argument, 'expected `argument`')
156 |   assert(query.argument.type === 'String', 'expected plain text')
157 |   return state.direction === query.argument.value
158 | }
159 | 
160 | /**
161 |  * Check whether an element matches a `:disabled` pseudo.
162 |  *
163 |  * @param {AstPseudoClass} _
164 |  *   Query.
165 |  * @param {Element} element
166 |  *   Element.
167 |  * @returns {boolean}
168 |  *   Whether `element` matches `query`.
169 |  */
170 | function disabled(_, element) {
171 |   return (
172 |     (element.tagName === 'button' ||
173 |       element.tagName === 'input' ||
174 |       element.tagName === 'select' ||
175 |       element.tagName === 'textarea' ||
176 |       element.tagName === 'optgroup' ||
177 |       element.tagName === 'option' ||
178 |       element.tagName === 'menuitem' ||
179 |       element.tagName === 'fieldset') &&
180 |     hasProperty(element, 'disabled')
181 |   )
182 | }
183 | 
184 | /**
185 |  * Check whether an element matches an `:empty` pseudo.
186 |  *
187 |  * @param {AstPseudoClass} _
188 |  *   Query.
189 |  * @param {Element} element
190 |  *   Element.
191 |  * @returns {boolean}
192 |  *   Whether `element` matches `query`.
193 |  */
194 | function empty(_, element) {
195 |   return !someChildren(element, check)
196 | 
197 |   /**
198 |    * @param {ElementContent} child
199 |    * @returns {boolean}
200 |    */
201 |   function check(child) {
202 |     return child.type === 'element' || child.type === 'text'
203 |   }
204 | }
205 | 
206 | /**
207 |  * Check whether an element matches an `:enabled` pseudo.
208 |  *
209 |  * @param {AstPseudoClass} query
210 |  *   Query.
211 |  * @param {Element} element
212 |  *   Element.
213 |  * @returns {boolean}
214 |  *   Whether `element` matches `query`.
215 |  */
216 | function enabled(query, element) {
217 |   return !disabled(query, element)
218 | }
219 | 
220 | /**
221 |  * Check whether an element matches a `:first-child` pseudo.
222 |  *
223 |  * @param {AstPseudoClass} query
224 |  *   Query.
225 |  * @param {Element} _1
226 |  *   Element.
227 |  * @param {number | undefined} _2
228 |  *   Index of `element` in `parent`.
229 |  * @param {Parents | undefined} _3
230 |  *   Parent of `element`.
231 |  * @param {State} state
232 |  *   State.
233 |  * @returns {boolean}
234 |  *   Whether `element` matches `query`.
235 |  */
236 | function firstChild(query, _1, _2, _3, state) {
237 |   assertDeep(state, query)
238 |   return state.elementIndex === 0
239 | }
240 | 
241 | /**
242 |  * Check whether an element matches a `:first-of-type` pseudo.
243 |  *
244 |  * @param {AstPseudoClass} query
245 |  *   Query.
246 |  * @param {Element} _1
247 |  *   Element.
248 |  * @param {number | undefined} _2
249 |  *   Index of `element` in `parent`.
250 |  * @param {Parents | undefined} _3
251 |  *   Parent of `element`.
252 |  * @param {State} state
253 |  *   State.
254 |  * @returns {boolean}
255 |  *   Whether `element` matches `query`.
256 |  */
257 | function firstOfType(query, _1, _2, _3, state) {
258 |   assertDeep(state, query)
259 |   return state.typeIndex === 0
260 | }
261 | 
262 | /**
263 |  * @param {AstPseudoClass} query
264 |  *   Query.
265 |  * @returns {(value: number) => boolean}
266 |  *   N.
267 |  */
268 | function getCachedNthCheck(query) {
269 |   /** @type {(value: number) => boolean} */
270 |   // @ts-expect-error: cache.
271 |   let cachedFunction = query._cachedFn
272 | 
273 |   if (!cachedFunction) {
274 |     const value = query.argument
275 |     assert(value, 'expected `argument`')
276 | 
277 |     if (value.type !== 'Formula') {
278 |       throw new Error(
279 |         'Expected `nth` formula, such as `even` or `2n+1` (`of` is not yet supported)'
280 |       )
281 |     }
282 | 
283 |     cachedFunction = nthCheck(value.a + 'n+' + value.b)
284 |     // @ts-expect-error: cache.
285 |     query._cachedFn = cachedFunction
286 |   }
287 | 
288 |   return cachedFunction
289 | }
290 | 
291 | /**
292 |  * @param {AstPseudoClass} query
293 |  *   Query.
294 |  * @param {Element} element
295 |  *   Element.
296 |  * @param {number | undefined} _1
297 |  *   Index of `element` in `parent`.
298 |  * @param {Parents | undefined} _2
299 |  *   Parent of `element`.
300 |  * @param {State} state
301 |  *   State.
302 |  * @returns {boolean}
303 |  *   Whether `element` matches `query`.
304 |  */
305 | function has(query, element, _1, _2, state) {
306 |   assert(query.argument, 'expected `argument`')
307 |   assert(query.argument.type === 'Selector', 'expected selector')
308 | 
309 |   /** @type {State} */
310 |   const childState = {
311 |     ...state,
312 |     // Not found yet.
313 |     found: false,
314 |     // One result is enough.
315 |     one: true,
316 |     results: [],
317 |     rootQuery: query.argument,
318 |     scopeElements: [element],
319 |     // Do walk deep.
320 |     shallow: false
321 |   }
322 | 
323 |   walk(childState, {type: 'root', children: element.children})
324 | 
325 |   return childState.results.length > 0
326 | }
327 | 
328 | // Shouldn’t be called, parser gives correct data.
329 | /* c8 ignore next 3 */
330 | function invalidPseudo() {
331 |   unreachable('Invalid pseudo-selector')
332 | }
333 | 
334 | /**
335 |  * Check whether an element `:is` further selectors.
336 |  *
337 |  * @param {AstPseudoClass} query
338 |  *   Query.
339 |  * @param {Element} element
340 |  *   Element.
341 |  * @param {number | undefined} _1
342 |  *   Index of `element` in `parent`.
343 |  * @param {Parents | undefined} _2
344 |  *   Parent of `element`.
345 |  * @param {State} state
346 |  *   State.
347 |  * @returns {boolean}
348 |  *   Whether `element` matches `query`.
349 |  */
350 | function is(query, element, _1, _2, state) {
351 |   assert(query.argument, 'expected `argument`')
352 |   assert(query.argument.type === 'Selector', 'expected selector')
353 | 
354 |   /** @type {State} */
355 |   const childState = {
356 |     ...state,
357 |     // Not found yet.
358 |     found: false,
359 |     // One result is enough.
360 |     one: true,
361 |     results: [],
362 |     rootQuery: query.argument,
363 |     scopeElements: [element],
364 |     // Do walk deep.
365 |     shallow: false
366 |   }
367 | 
368 |   walk(childState, element)
369 | 
370 |   return childState.results[0] === element
371 | }
372 | 
373 | /**
374 |  * Check whether an element matches a `:lang()` pseudo.
375 |  *
376 |  * @param {AstPseudoClass} query
377 |  *   Query.
378 |  * @param {Element} _1
379 |  *   Element.
380 |  * @param {number | undefined} _2
381 |  *   Index of `element` in `parent`.
382 |  * @param {Parents | undefined} _3
383 |  *   Parent of `element`.
384 |  * @param {State} state
385 |  *   State.
386 |  * @returns {boolean}
387 |  *   Whether `element` matches `query`.
388 |  */
389 | function lang(query, _1, _2, _3, state) {
390 |   assert(query.argument, 'expected `argument`')
391 |   assert(query.argument.type === 'String', 'expected string')
392 | 
393 |   return (
394 |     state.language !== '' &&
395 |     state.language !== undefined &&
396 |     extendedFilter(state.language, commas(query.argument.value)).length > 0
397 |   )
398 | }
399 | 
400 | /**
401 |  * Check whether an element matches a `:last-child` pseudo.
402 |  *
403 |  * @param {AstPseudoClass} query
404 |  *   Query.
405 |  * @param {Element} _1
406 |  *   Element.
407 |  * @param {number | undefined} _2
408 |  *   Index of `element` in `parent`.
409 |  * @param {Parents | undefined} _3
410 |  *   Parent of `element`.
411 |  * @param {State} state
412 |  *   State.
413 |  * @returns {boolean}
414 |  *   Whether `element` matches `query`.
415 |  */
416 | function lastChild(query, _1, _2, _3, state) {
417 |   assertDeep(state, query)
418 |   return Boolean(
419 |     state.elementCount && state.elementIndex === state.elementCount - 1
420 |   )
421 | }
422 | 
423 | /**
424 |  * Check whether an element matches a `:last-of-type` pseudo.
425 |  *
426 |  * @param {AstPseudoClass} query
427 |  *   Query.
428 |  * @param {Element} _1
429 |  *   Element.
430 |  * @param {number | undefined} _2
431 |  *   Index of `element` in `parent`.
432 |  * @param {Parents | undefined} _3
433 |  *   Parent of `element`.
434 |  * @param {State} state
435 |  *   State.
436 |  * @returns {boolean}
437 |  *   Whether `element` matches `query`.
438 |  */
439 | function lastOfType(query, _1, _2, _3, state) {
440 |   assertDeep(state, query)
441 |   return (
442 |     typeof state.typeIndex === 'number' &&
443 |     typeof state.typeCount === 'number' &&
444 |     state.typeIndex === state.typeCount - 1
445 |   )
446 | }
447 | 
448 | /**
449 |  * Check whether an element does `:not` match further selectors.
450 |  *
451 |  * @param {AstPseudoClass} query
452 |  *   Query.
453 |  * @param {Element} element
454 |  *   Element.
455 |  * @param {number | undefined} index
456 |  *   Index of `element` in `parent`.
457 |  * @param {Parents | undefined} parent
458 |  *   Parent of `element`.
459 |  * @param {State} state
460 |  *   State.
461 |  * @returns {boolean}
462 |  *   Whether `element` matches `query`.
463 |  */
464 | function not(query, element, index, parent, state) {
465 |   return !is(query, element, index, parent, state)
466 | }
467 | 
468 | /**
469 |  * Check whether an element matches an `:nth-child` pseudo.
470 |  *
471 |  * @param {AstPseudoClass} query
472 |  *   Query.
473 |  * @param {Element} _1
474 |  *   Element.
475 |  * @param {number | undefined} _2
476 |  *   Index of `element` in `parent`.
477 |  * @param {Parents | undefined} _3
478 |  *   Parent of `element`.
479 |  * @param {State} state
480 |  *   State.
481 |  * @returns {boolean}
482 |  *   Whether `element` matches `query`.
483 |  */
484 | function nthChild(query, _1, _2, _3, state) {
485 |   const cachedFunction = getCachedNthCheck(query)
486 |   assertDeep(state, query)
487 |   return (
488 |     typeof state.elementIndex === 'number' && cachedFunction(state.elementIndex)
489 |   )
490 | }
491 | 
492 | /**
493 |  * Check whether an element matches an `:nth-last-child` pseudo.
494 |  *
495 |  * @param {AstPseudoClass} query
496 |  *   Query.
497 |  * @param {Element} _1
498 |  *   Element.
499 |  * @param {number | undefined} _2
500 |  *   Index of `element` in `parent`.
501 |  * @param {Parents | undefined} _3
502 |  *   Parent of `element`.
503 |  * @param {State} state
504 |  *   State.
505 |  * @returns {boolean}
506 |  *   Whether `element` matches `query`.
507 |  */
508 | function nthLastChild(query, _1, _2, _3, state) {
509 |   const cachedFunction = getCachedNthCheck(query)
510 |   assertDeep(state, query)
511 |   return Boolean(
512 |     typeof state.elementCount === 'number' &&
513 |       typeof state.elementIndex === 'number' &&
514 |       cachedFunction(state.elementCount - state.elementIndex - 1)
515 |   )
516 | }
517 | 
518 | /**
519 |  * Check whether an element matches a `:nth-last-of-type` pseudo.
520 |  *
521 |  * @param {AstPseudoClass} query
522 |  *   Query.
523 |  * @param {Element} _1
524 |  *   Element.
525 |  * @param {number | undefined} _2
526 |  *   Index of `element` in `parent`.
527 |  * @param {Parents | undefined} _3
528 |  *   Parent of `element`.
529 |  * @param {State} state
530 |  *   State.
531 |  * @returns {boolean}
532 |  *   Whether `element` matches `query`.
533 |  */
534 | function nthLastOfType(query, _1, _2, _3, state) {
535 |   const cachedFunction = getCachedNthCheck(query)
536 |   assertDeep(state, query)
537 |   return (
538 |     typeof state.typeCount === 'number' &&
539 |     typeof state.typeIndex === 'number' &&
540 |     cachedFunction(state.typeCount - 1 - state.typeIndex)
541 |   )
542 | }
543 | 
544 | /**
545 |  * Check whether an element matches an `:nth-of-type` pseudo.
546 |  *
547 |  * @param {AstPseudoClass} query
548 |  *   Query.
549 |  * @param {Element} _1
550 |  *   Element.
551 |  * @param {number | undefined} _2
552 |  *   Index of `element` in `parent`.
553 |  * @param {Parents | undefined} _3
554 |  *   Parent of `element`.
555 |  * @param {State} state
556 |  *   State.
557 |  * @returns {boolean}
558 |  *   Whether `element` matches `query`.
559 |  */
560 | function nthOfType(query, _1, _2, _3, state) {
561 |   const cachedFunction = getCachedNthCheck(query)
562 |   assertDeep(state, query)
563 |   return typeof state.typeIndex === 'number' && cachedFunction(state.typeIndex)
564 | }
565 | 
566 | /**
567 |  * Check whether an element matches an `:only-child` pseudo.
568 |  *
569 |  * @param {AstPseudoClass} query
570 |  *   Query.
571 |  * @param {Element} _1
572 |  *   Element.
573 |  * @param {number | undefined} _2
574 |  *   Index of `element` in `parent`.
575 |  * @param {Parents | undefined} _3
576 |  *   Parent of `element`.
577 |  * @param {State} state
578 |  *   State.
579 |  * @returns {boolean}
580 |  *   Whether `element` matches `query`.
581 |  */
582 | function onlyChild(query, _1, _2, _3, state) {
583 |   assertDeep(state, query)
584 |   return state.elementCount === 1
585 | }
586 | 
587 | /**
588 |  * Check whether an element matches an `:only-of-type` pseudo.
589 |  *
590 |  * @param {AstPseudoClass} query
591 |  *   Query.
592 |  * @param {Element} _1
593 |  *   Element.
594 |  * @param {number | undefined} _2
595 |  *   Index of `element` in `parent`.
596 |  * @param {Parents | undefined} _3
597 |  *   Parent of `element`.
598 |  * @param {State} state
599 |  *   State.
600 |  * @returns {boolean}
601 |  *   Whether `element` matches `query`.
602 |  */
603 | function onlyOfType(query, _1, _2, _3, state) {
604 |   assertDeep(state, query)
605 |   return state.typeCount === 1
606 | }
607 | 
608 | /**
609 |  * Check whether an element matches an `:optional` pseudo.
610 |  *
611 |  * @param {AstPseudoClass} query
612 |  *   Query.
613 |  * @param {Element} element
614 |  *   Element.
615 |  * @returns {boolean}
616 |  *   Whether `element` matches `query`.
617 |  */
618 | function optional(query, element) {
619 |   return !required(query, element)
620 | }
621 | 
622 | /**
623 |  * Check whether an element matches a `:read-only` pseudo.
624 |  *
625 |  * @param {AstPseudoClass} query
626 |  *   Query.
627 |  * @param {Element} element
628 |  *   Element.
629 |  * @param {number | undefined} index
630 |  *   Index of `element` in `parent`.
631 |  * @param {Parents | undefined} parent
632 |  *   Parent of `element`.
633 |  * @param {State} state
634 |  *   State.
635 |  * @returns {boolean}
636 |  *   Whether `element` matches `query`.
637 |  */
638 | function readOnly(query, element, index, parent, state) {
639 |   return !readWrite(query, element, index, parent, state)
640 | }
641 | 
642 | /**
643 |  * Check whether an element matches a `:read-write` pseudo.
644 |  *
645 |  * @param {AstPseudoClass} _
646 |  *   Query.
647 |  * @param {Element} element
648 |  *   Element.
649 |  * @param {number | undefined} _1
650 |  *   Index of `element` in `parent`.
651 |  * @param {Parents | undefined} _2
652 |  *   Parent of `element`.
653 |  * @param {State} state
654 |  *   State.
655 |  * @returns {boolean}
656 |  *   Whether `element` matches `query`.
657 |  */
658 | function readWrite(_, element, _1, _2, state) {
659 |   return element.tagName === 'input' || element.tagName === 'textarea'
660 |     ? !hasProperty(element, 'readOnly') && !hasProperty(element, 'disabled')
661 |     : Boolean(state.editableOrEditingHost)
662 | }
663 | 
664 | /**
665 |  * Check whether an element matches a `:required` pseudo.
666 |  *
667 |  * @param {AstPseudoClass} _
668 |  *   Query.
669 |  * @param {Element} element
670 |  *   Element.
671 |  * @returns {boolean}
672 |  *   Whether `element` matches `query`.
673 |  */
674 | function required(_, element) {
675 |   return (
676 |     (element.tagName === 'input' ||
677 |       element.tagName === 'textarea' ||
678 |       element.tagName === 'select') &&
679 |     hasProperty(element, 'required')
680 |   )
681 | }
682 | 
683 | /**
684 |  * Check whether an element matches a `:root` pseudo.
685 |  *
686 |  * @param {AstPseudoClass} _1
687 |  *   Query.
688 |  * @param {Element} element
689 |  *   Element.
690 |  * @param {number | undefined} _2
691 |  *   Index of `element` in `parent`.
692 |  * @param {Parents | undefined} parent
693 |  *   Parent of `element`.
694 |  * @param {State} state
695 |  *   State.
696 |  * @returns {boolean}
697 |  *   Whether `element` matches `query`.
698 |  */
699 | function root(_1, element, _2, parent, state) {
700 |   return Boolean(
701 |     (!parent || parent.type === 'root') &&
702 |       state.schema &&
703 |       (state.schema.space === 'html' || state.schema.space === 'svg') &&
704 |       (element.tagName === 'html' || element.tagName === 'svg')
705 |   )
706 | }
707 | 
708 | /**
709 |  * Check whether an element matches a `:scope` pseudo.
710 |  *
711 |  * @param {AstPseudoClass} _1
712 |  *   Query.
713 |  * @param {Element} element
714 |  *   Element.
715 |  * @param {number | undefined} _2
716 |  *   Index of `element` in `parent`.
717 |  * @param {Parents | undefined} _3
718 |  *   Parent of `element`.
719 |  * @param {State} state
720 |  *   State.
721 |  * @returns {boolean}
722 |  *   Whether `element` matches `query`.
723 |  */
724 | function scope(_1, element, _2, _3, state) {
725 |   return state.scopeElements.includes(element)
726 | }
727 | 
728 | /**
729 |  * Check children.
730 |  *
731 |  * @param {Element} element
732 |  *   Element.
733 |  * @param {(child: ElementContent) => boolean} check
734 |  *   Check.
735 |  * @returns {boolean}
736 |  *   Whether a child of `element` matches `check`.
737 |  */
738 | function someChildren(element, check) {
739 |   const children = element.children
740 |   let index = -1
741 | 
742 |   while (++index < children.length) {
743 |     if (check(children[index])) return true
744 |   }
745 | 
746 |   return false
747 | }
748 | 
749 | /**
750 |  * @param {unknown} query_
751 |  *   Query-like value.
752 |  * @returns {never}
753 |  *   Nothing.
754 |  * @throws
755 |  *   Exception.
756 |  */
757 | function unknownPseudo(query_) {
758 |   // Runtime JS guarantees it has a `name`.
759 |   const query = /** @type {AstPseudoClass} */ (query_)
760 |   throw new Error('Unknown pseudo-selector `' + query.name + '`')
761 | }
762 | 


--------------------------------------------------------------------------------
/test/select.js:
--------------------------------------------------------------------------------
   1 | import assert from 'node:assert/strict'
   2 | import test from 'node:test'
   3 | import {h, s} from 'hastscript'
   4 | import {select} from 'hast-util-select'
   5 | import {u} from 'unist-builder'
   6 | 
   7 | test('select.select()', async function (t) {
   8 |   await t.test('invalid selectors', async function (t) {
   9 |     await t.test('should throw without selector', async function () {
  10 |       assert.throws(function () {
  11 |         // @ts-expect-error: check how the runtime handles a missing `selector`.
  12 |         select()
  13 |       }, /Error: Expected `string` as selector, not `undefined`/)
  14 |     })
  15 | 
  16 |     await t.test('should throw w/ invalid selector (1)', async function () {
  17 |       assert.throws(function () {
  18 |         // @ts-expect-error: check how the runtime handles an incorrect `selector`.
  19 |         select([], h(''))
  20 |       }, /Error: Expected `string` as selector, not ``/)
  21 |     })
  22 | 
  23 |     await t.test('should throw w/ invalid selector (2)', async function () {
  24 |       assert.throws(function () {
  25 |         select('@supports (transform-origin: 5% 5%) {}', h(''))
  26 |       }, /Expected rule but "@" found/)
  27 |     })
  28 | 
  29 |     await t.test(
  30 |       'should throw on invalid attribute operators',
  31 |       async function () {
  32 |         assert.throws(function () {
  33 |           select('[foo%=bar]', h(''))
  34 |         }, /Expected a valid attribute selector operator/)
  35 |       }
  36 |     )
  37 | 
  38 |     await t.test('should throw on invalid pseudo classes', async function () {
  39 |       assert.throws(function () {
  40 |         select(':active', h(''))
  41 |       }, /Error: Unknown pseudo-selector `active`/)
  42 |     })
  43 | 
  44 |     await t.test(
  45 |       'should throw on invalid pseudo class “functions”',
  46 |       async function () {
  47 |         assert.throws(function () {
  48 |           select(':nth-foo(2n+1)', h(''))
  49 |         }, /Unknown pseudo-class/)
  50 |       }
  51 |     )
  52 | 
  53 |     await t.test('should throw on invalid pseudo elements', async function () {
  54 |       assert.throws(function () {
  55 |         select('::before', h(''))
  56 |       }, /Invalid selector: `::before`/)
  57 |     })
  58 |   })
  59 | 
  60 |   await t.test('general', async function (t) {
  61 |     await t.test('should throw on empty selectors', async function () {
  62 |       assert.throws(function () {
  63 |         select('', h())
  64 |       }, /Expected rule but end of input reached/)
  65 |     })
  66 | 
  67 |     await t.test(
  68 |       'should throw for a white-space only selector',
  69 |       async function () {
  70 |         assert.throws(function () {
  71 |           select(' ', h())
  72 |         }, /Expected rule but end of input reached/)
  73 |       }
  74 |     )
  75 | 
  76 |     await t.test('should not select if not given a node', async function () {
  77 |       assert.equal(select('*'), undefined)
  78 |     })
  79 | 
  80 |     await t.test(
  81 |       'should not select if not given an element',
  82 |       async function () {
  83 |         assert.equal(select('*', {type: 'text', value: 'a'}), undefined)
  84 |       }
  85 |     )
  86 | 
  87 |     await t.test('should select one of several elements', async function () {
  88 |       assert.deepEqual(
  89 |         select('h1, h2', h('main', [h('h1', 'Alpha'), h('h2', 'Bravo')])),
  90 |         h('h1', 'Alpha')
  91 |       )
  92 |     })
  93 |   })
  94 | 
  95 |   await t.test('descendant selector', async function (t) {
  96 |     await t.test('should return the first descendant node', async function () {
  97 |       assert.deepEqual(
  98 |         select(
  99 |           'div',
 100 |           u('root', [
 101 |             h('#one'),
 102 |             h('main', [h('#two'), h('article', h('#three'))])
 103 |           ])
 104 |         ),
 105 |         h('#one')
 106 |       )
 107 |     })
 108 | 
 109 |     await t.test(
 110 |       'should return the given node if it matches',
 111 |       async function () {
 112 |         assert.deepEqual(select('div', h('#one')), h('#one'))
 113 |       }
 114 |     )
 115 | 
 116 |     await t.test('should return the first match', async function () {
 117 |       assert.deepEqual(
 118 |         select(
 119 |           'div',
 120 |           u('root', [h('#one', [h('#two'), h('#three', h('#four'))])])
 121 |         ),
 122 |         h('#one', [h('#two'), h('#three', h('#four'))])
 123 |       )
 124 |     })
 125 | 
 126 |     await t.test('should return deep matches', async function () {
 127 |       assert.deepEqual(
 128 |         select('p i s', u('root', [h('p', h('i', h('s', h('s'))))])),
 129 |         h('s', h('s'))
 130 |       )
 131 |     })
 132 |   })
 133 | 
 134 |   await t.test('child selector', async function (t) {
 135 |     await t.test('should return child nodes', async function () {
 136 |       assert.deepEqual(
 137 |         select(
 138 |           'main > article',
 139 |           u('root', [
 140 |             h('#one'),
 141 |             h('main', [h('#two'), h('article', h('#three'))])
 142 |           ])
 143 |         ),
 144 |         h('article', h('#three'))
 145 |       )
 146 |     })
 147 | 
 148 |     await t.test(
 149 |       'should return matches with nested matches',
 150 |       async function () {
 151 |         assert.deepEqual(
 152 |           select(
 153 |             'div > div',
 154 |             u('root', [h('#one', [h('#two'), h('#three', h('#four'))])])
 155 |           ),
 156 |           h('#two')
 157 |         )
 158 |       }
 159 |     )
 160 | 
 161 |     await t.test('should return deep matches', async function () {
 162 |       assert.deepEqual(
 163 |         select('p > i > s', u('root', [h('p', h('i', h('s', h('s'))))])),
 164 |         h('s', h('s'))
 165 |       )
 166 |     })
 167 |   })
 168 | 
 169 |   await t.test('next-sibling selector', async function (t) {
 170 |     await t.test('should return next-sibling', async function () {
 171 |       assert.deepEqual(
 172 |         select(
 173 |           'h1 + p',
 174 |           u('root', [
 175 |             h('p', 'Alpha'),
 176 |             h('h1', 'Bravo'),
 177 |             h('p', 'Charlie'),
 178 |             h('p', 'Delta'),
 179 |             h('div', [h('p', 'Echo')])
 180 |           ])
 181 |         ),
 182 |         h('p', 'Charlie')
 183 |       )
 184 |     })
 185 | 
 186 |     await t.test(
 187 |       'should return next-sibling ignoring non-elements',
 188 |       async function () {
 189 |         assert.deepEqual(
 190 |           select(
 191 |             'a + b',
 192 |             u('root', [
 193 |               u('text', '\n'),
 194 |               h('a', 'Lorem'),
 195 |               u('text', ' ipsum '),
 196 |               h('b', 'dolor'),
 197 |               u('text', ' sit '),
 198 |               h('i', 'amet'),
 199 |               u('text', ' sed '),
 200 |               h('b', 'do'),
 201 |               u('text', ' eiusmod '),
 202 |               h('i', 'tempor'),
 203 |               u('text', '.\n')
 204 |             ])
 205 |           ),
 206 |           h('b', 'dolor')
 207 |         )
 208 |       }
 209 |     )
 210 | 
 211 |     await t.test('should return nothing without matches', async function () {
 212 |       assert.equal(
 213 |         select(
 214 |           'h1 + p',
 215 |           u('root', [
 216 |             h('p', 'Alpha'),
 217 |             h('h1', 'Bravo'),
 218 |             h('h2', 'Charlie'),
 219 |             h('p', 'Delta')
 220 |           ])
 221 |         ),
 222 |         undefined
 223 |       )
 224 |     })
 225 |   })
 226 | 
 227 |   await t.test('subsequent sibling selector', async function (t) {
 228 |     await t.test(
 229 |       'should return the first subsequent sibling',
 230 |       async function () {
 231 |         assert.deepEqual(
 232 |           select(
 233 |             'h1 ~ p',
 234 |             u('root', [
 235 |               h('p', 'Alpha'),
 236 |               h('h1', 'Bravo'),
 237 |               h('p', 'Charlie'),
 238 |               h('p', 'Delta'),
 239 |               h('div', [h('p', 'Echo')])
 240 |             ])
 241 |           ),
 242 |           h('p', 'Charlie')
 243 |         )
 244 |       }
 245 |     )
 246 | 
 247 |     await t.test('should return subsequent siblings', async function () {
 248 |       assert.deepEqual(
 249 |         select(
 250 |           'h1 ~ p',
 251 |           u('root', [
 252 |             h('p', 'Alpha'),
 253 |             h('h1', 'Bravo'),
 254 |             h('h2', 'Charlie'),
 255 |             h('p', 'Delta')
 256 |           ])
 257 |         ),
 258 |         h('p', 'Delta')
 259 |       )
 260 |     })
 261 | 
 262 |     await t.test(
 263 |       'should return siblings ignoring non-elements',
 264 |       async function () {
 265 |         assert.deepEqual(
 266 |           select(
 267 |             'a ~ i',
 268 |             u('root', [
 269 |               u('text', '\n'),
 270 |               h('a', 'Lorem'),
 271 |               u('text', ' ipsum '),
 272 |               h('b', 'dolor'),
 273 |               u('text', ' sit '),
 274 |               h('i', 'amet'),
 275 |               u('text', ' sed '),
 276 |               h('b', 'do'),
 277 |               u('text', ' eiusmod '),
 278 |               h('i', 'tempor'),
 279 |               u('text', '.\n')
 280 |             ])
 281 |           ),
 282 |           h('i', 'amet')
 283 |         )
 284 |       }
 285 |     )
 286 | 
 287 |     await t.test('should return nothing without matches', async function () {
 288 |       assert.equal(
 289 |         select(
 290 |           'h1 ~ p',
 291 |           u('root', [h('p', 'Alpha'), h('h1', 'Bravo'), h('h2', 'Charlie')])
 292 |         ),
 293 |         undefined
 294 |       )
 295 |     })
 296 |   })
 297 | 
 298 |   await t.test('parent-sensitive pseudo-selectors', async function (t) {
 299 |     await t.test(':first-child', async function (t) {
 300 |       await t.test('should return the first child', async function () {
 301 |         assert.deepEqual(
 302 |           select(
 303 |             ':first-child',
 304 |             u('root', [
 305 |               h('p', 'Alpha'),
 306 |               h('h1', 'Bravo'),
 307 |               h('p', 'Charlie'),
 308 |               h('p', 'Delta'),
 309 |               h('div', [h('p', 'Echo')])
 310 |             ])
 311 |           ),
 312 |           h('p', 'Alpha')
 313 |         )
 314 |       })
 315 | 
 316 |       await t.test(
 317 |         'should return nothing if nothing matches',
 318 |         async function () {
 319 |           assert.equal(
 320 |             select(
 321 |               'h1:first-child',
 322 |               u('root', [h('p', 'Alpha'), h('h1', 'Bravo'), h('p', 'Charlie')])
 323 |             ),
 324 |             undefined
 325 |           )
 326 |         }
 327 |       )
 328 |     })
 329 | 
 330 |     await t.test(':last-child', async function (t) {
 331 |       await t.test('should return the last child', async function () {
 332 |         assert.deepEqual(
 333 |           select(
 334 |             ':last-child',
 335 |             u('root', [
 336 |               h('p', 'Alpha'),
 337 |               h('h1', 'Bravo'),
 338 |               h('p', 'Charlie'),
 339 |               h('p', 'Delta'),
 340 |               h('div', [h('p', 'Echo')])
 341 |             ])
 342 |           ),
 343 |           h('div', [h('p', 'Echo')])
 344 |         )
 345 |       })
 346 | 
 347 |       await t.test(
 348 |         'should return nothing if nothing matches',
 349 |         async function () {
 350 |           assert.equal(
 351 |             select(
 352 |               'h1:last-child',
 353 |               u('root', [h('p', 'Alpha'), h('h1', 'Bravo'), h('p', 'Charlie')])
 354 |             ),
 355 |             undefined
 356 |           )
 357 |         }
 358 |       )
 359 |     })
 360 | 
 361 |     await t.test(':only-child', async function (t) {
 362 |       await t.test('should return an only child', async function () {
 363 |         assert.deepEqual(
 364 |           select(
 365 |             ':only-child',
 366 |             u('root', [
 367 |               h('p', 'Alpha'),
 368 |               h('h1', 'Bravo'),
 369 |               h('p', 'Charlie'),
 370 |               h('p', 'Delta'),
 371 |               h('div', [h('p', 'Echo')])
 372 |             ])
 373 |           ),
 374 |           h('p', 'Echo')
 375 |         )
 376 |       })
 377 | 
 378 |       await t.test(
 379 |         'should return nothing if nothing matches',
 380 |         async function () {
 381 |           assert.equal(
 382 |             select(
 383 |               'h1:only-child',
 384 |               u('root', [h('p', 'Alpha'), h('h1', 'Bravo'), h('p', 'Charlie')])
 385 |             ),
 386 |             undefined
 387 |           )
 388 |         }
 389 |       )
 390 |     })
 391 | 
 392 |     await t.test(':nth-child', async function (t) {
 393 |       await t.test(
 394 |         'should return the match for `:nth-child(odd)`',
 395 |         async function () {
 396 |           assert.deepEqual(
 397 |             select(
 398 |               'li:nth-child(odd)',
 399 |               h('ol', [
 400 |                 h('li', 'Alpha'),
 401 |                 h('li', 'Bravo'),
 402 |                 h('li', 'Charlie'),
 403 |                 h('li', 'Delta'),
 404 |                 h('li', 'Echo'),
 405 |                 h('li', 'Foxtrot')
 406 |               ])
 407 |             ),
 408 |             h('li', 'Alpha')
 409 |           )
 410 |         }
 411 |       )
 412 | 
 413 |       await t.test(
 414 |         'should return the match for `:nth-child(2n+1)`',
 415 |         async function () {
 416 |           assert.deepEqual(
 417 |             select(
 418 |               'li:nth-child(2n+1)',
 419 |               h('ol', [
 420 |                 h('li', 'Alpha'),
 421 |                 h('li', 'Bravo'),
 422 |                 h('li', 'Charlie'),
 423 |                 h('li', 'Delta'),
 424 |                 h('li', 'Echo'),
 425 |                 h('li', 'Foxtrot')
 426 |               ])
 427 |             ),
 428 |             h('li', 'Alpha')
 429 |           )
 430 |         }
 431 |       )
 432 | 
 433 |       await t.test(
 434 |         'should return the match for `:nth-child(even)`',
 435 |         async function () {
 436 |           assert.deepEqual(
 437 |             select(
 438 |               'li:nth-child(even)',
 439 |               h('ol', [
 440 |                 h('li', 'Alpha'),
 441 |                 h('li', 'Bravo'),
 442 |                 h('li', 'Charlie'),
 443 |                 h('li', 'Delta'),
 444 |                 h('li', 'Echo'),
 445 |                 h('li', 'Foxtrot')
 446 |               ])
 447 |             ),
 448 |             h('li', 'Bravo')
 449 |           )
 450 |         }
 451 |       )
 452 | 
 453 |       await t.test(
 454 |         'should return the match for `:nth-child(2n+0)`',
 455 |         async function () {
 456 |           assert.deepEqual(
 457 |             select(
 458 |               'li:nth-child(2n+0)',
 459 |               h('ol', [
 460 |                 h('li', 'Alpha'),
 461 |                 h('li', 'Bravo'),
 462 |                 h('li', 'Charlie'),
 463 |                 h('li', 'Delta'),
 464 |                 h('li', 'Echo'),
 465 |                 h('li', 'Foxtrot')
 466 |               ])
 467 |             ),
 468 |             h('li', 'Bravo')
 469 |           )
 470 |         }
 471 |       )
 472 |     })
 473 | 
 474 |     await t.test(':nth-last-child', async function (t) {
 475 |       await t.test(
 476 |         'should return the last match for `:nth-last-child(odd)`',
 477 |         async function () {
 478 |           assert.deepEqual(
 479 |             select(
 480 |               'li:nth-last-child(odd)',
 481 |               h('ol', [
 482 |                 h('li', 'Alpha'),
 483 |                 h('li', 'Bravo'),
 484 |                 h('li', 'Charlie'),
 485 |                 h('li', 'Delta'),
 486 |                 h('li', 'Echo'),
 487 |                 h('li', 'Foxtrot')
 488 |               ])
 489 |             ),
 490 |             h('li', 'Bravo')
 491 |           )
 492 |         }
 493 |       )
 494 | 
 495 |       await t.test(
 496 |         'should return the last match for `:nth-last-child(2n+1)`',
 497 |         async function () {
 498 |           assert.deepEqual(
 499 |             select(
 500 |               'li:nth-last-child(2n+1)',
 501 |               h('ol', [
 502 |                 h('li', 'Alpha'),
 503 |                 h('li', 'Bravo'),
 504 |                 h('li', 'Charlie'),
 505 |                 h('li', 'Delta'),
 506 |                 h('li', 'Echo'),
 507 |                 h('li', 'Foxtrot')
 508 |               ])
 509 |             ),
 510 |             h('li', 'Bravo')
 511 |           )
 512 |         }
 513 |       )
 514 | 
 515 |       await t.test(
 516 |         'should return the last match for `:nth-last-child(even)`',
 517 |         async function () {
 518 |           assert.deepEqual(
 519 |             select(
 520 |               'li:nth-last-child(even)',
 521 |               h('ol', [
 522 |                 h('li', 'Alpha'),
 523 |                 h('li', 'Bravo'),
 524 |                 h('li', 'Charlie'),
 525 |                 h('li', 'Delta'),
 526 |                 h('li', 'Echo'),
 527 |                 h('li', 'Foxtrot')
 528 |               ])
 529 |             ),
 530 |             h('li', 'Alpha')
 531 |           )
 532 |         }
 533 |       )
 534 | 
 535 |       await t.test(
 536 |         'should return the last match for `:nth-last-child(2n+0)`',
 537 |         async function () {
 538 |           assert.deepEqual(
 539 |             select(
 540 |               'li:nth-last-child(2n+0)',
 541 |               h('ol', [
 542 |                 h('li', 'Alpha'),
 543 |                 h('li', 'Bravo'),
 544 |                 h('li', 'Charlie'),
 545 |                 h('li', 'Delta'),
 546 |                 h('li', 'Echo'),
 547 |                 h('li', 'Foxtrot')
 548 |               ])
 549 |             ),
 550 |             h('li', 'Alpha')
 551 |           )
 552 |         }
 553 |       )
 554 |     })
 555 | 
 556 |     await t.test(':nth-of-type', async function (t) {
 557 |       await t.test(
 558 |         'should return the first match for `:nth-of-type(odd)`',
 559 |         async function () {
 560 |           assert.deepEqual(
 561 |             select(
 562 |               'dt:nth-of-type(odd)',
 563 |               h('dl', [
 564 |                 h('dt', 'Alpha'),
 565 |                 h('dd', 'Bravo'),
 566 |                 h('dt', 'Charlie'),
 567 |                 h('dd', 'Delta'),
 568 |                 h('dt', 'Echo'),
 569 |                 h('dd', 'Foxtrot')
 570 |               ])
 571 |             ),
 572 |             h('dt', 'Alpha')
 573 |           )
 574 |         }
 575 |       )
 576 | 
 577 |       await t.test(
 578 |         'should return the first match for `:nth-of-type(2n+1)`',
 579 |         async function () {
 580 |           assert.deepEqual(
 581 |             select(
 582 |               'dt:nth-of-type(2n+1)',
 583 |               h('dl', [
 584 |                 h('dt', 'Alpha'),
 585 |                 h('dd', 'Bravo'),
 586 |                 h('dt', 'Charlie'),
 587 |                 h('dd', 'Delta'),
 588 |                 h('dt', 'Echo'),
 589 |                 h('dd', 'Foxtrot')
 590 |               ])
 591 |             ),
 592 |             h('dt', 'Alpha')
 593 |           )
 594 |         }
 595 |       )
 596 | 
 597 |       await t.test(
 598 |         'should return the first match for `:nth-of-type(even)`',
 599 |         async function () {
 600 |           assert.deepEqual(
 601 |             select(
 602 |               'dt:nth-of-type(even)',
 603 |               h('dl', [
 604 |                 h('dt', 'Alpha'),
 605 |                 h('dd', 'Bravo'),
 606 |                 h('dt', 'Charlie'),
 607 |                 h('dd', 'Delta'),
 608 |                 h('dt', 'Echo'),
 609 |                 h('dd', 'Foxtrot')
 610 |               ])
 611 |             ),
 612 |             h('dt', 'Charlie')
 613 |           )
 614 |         }
 615 |       )
 616 | 
 617 |       await t.test(
 618 |         'should return the first match for `:nth-of-type(2n+0)`',
 619 |         async function () {
 620 |           assert.deepEqual(
 621 |             select(
 622 |               'dt:nth-of-type(2n+0)',
 623 |               h('dl', [
 624 |                 h('dt', 'Alpha'),
 625 |                 h('dd', 'Bravo'),
 626 |                 h('dt', 'Charlie'),
 627 |                 h('dd', 'Delta'),
 628 |                 h('dt', 'Echo'),
 629 |                 h('dd', 'Foxtrot')
 630 |               ])
 631 |             ),
 632 |             h('dt', 'Charlie')
 633 |           )
 634 |         }
 635 |       )
 636 |     })
 637 | 
 638 |     await t.test(':nth-last-of-type', async function (t) {
 639 |       await t.test(
 640 |         'should return the last match for `:nth-last-of-type(odd)`s',
 641 |         async function () {
 642 |           assert.deepEqual(
 643 |             select(
 644 |               'dt:nth-last-of-type(odd)',
 645 |               h('dl', [
 646 |                 h('dt', 'Alpha'),
 647 |                 h('dd', 'Bravo'),
 648 |                 h('dt', 'Charlie'),
 649 |                 h('dd', 'Delta'),
 650 |                 h('dt', 'Echo'),
 651 |                 h('dd', 'Foxtrot')
 652 |               ])
 653 |             ),
 654 |             h('dt', 'Alpha')
 655 |           )
 656 |         }
 657 |       )
 658 | 
 659 |       await t.test(
 660 |         'should return the last match for `:nth-last-of-type(2n+1)`',
 661 |         async function () {
 662 |           assert.deepEqual(
 663 |             select(
 664 |               'dt:nth-last-of-type(2n+1)',
 665 |               h('dl', [
 666 |                 h('dt', 'Alpha'),
 667 |                 h('dd', 'Bravo'),
 668 |                 h('dt', 'Charlie'),
 669 |                 h('dd', 'Delta'),
 670 |                 h('dt', 'Echo'),
 671 |                 h('dd', 'Foxtrot')
 672 |               ])
 673 |             ),
 674 |             h('dt', 'Alpha')
 675 |           )
 676 |         }
 677 |       )
 678 | 
 679 |       await t.test(
 680 |         'should return the last match for `:nth-last-of-type(even)`',
 681 |         async function () {
 682 |           assert.deepEqual(
 683 |             select(
 684 |               'dt:nth-last-of-type(even)',
 685 |               h('dl', [
 686 |                 h('dt', 'Alpha'),
 687 |                 h('dd', 'Bravo'),
 688 |                 h('dt', 'Charlie'),
 689 |                 h('dd', 'Delta'),
 690 |                 h('dt', 'Echo'),
 691 |                 h('dd', 'Foxtrot')
 692 |               ])
 693 |             ),
 694 |             h('dt', 'Charlie')
 695 |           )
 696 |         }
 697 |       )
 698 | 
 699 |       await t.test(
 700 |         'should return the last match for `:nth-last-of-type(2n+0)`',
 701 |         async function () {
 702 |           assert.deepEqual(
 703 |             select(
 704 |               'dt:nth-last-of-type(2n+0)',
 705 |               h('dl', [
 706 |                 h('dt', 'Alpha'),
 707 |                 h('dd', 'Bravo'),
 708 |                 h('dt', 'Charlie'),
 709 |                 h('dd', 'Delta'),
 710 |                 h('dt', 'Echo'),
 711 |                 h('dd', 'Foxtrot')
 712 |               ])
 713 |             ),
 714 |             h('dt', 'Charlie')
 715 |           )
 716 |         }
 717 |       )
 718 |     })
 719 | 
 720 |     await t.test(':first-of-type', async function (t) {
 721 |       await t.test(
 722 |         'should return the first match for `:first-of-type`',
 723 |         async function () {
 724 |           assert.deepEqual(
 725 |             select(
 726 |               'dt:first-of-type',
 727 |               h('dl', [
 728 |                 h('dt', 'Alpha'),
 729 |                 h('dd', 'Bravo'),
 730 |                 h('dt', 'Charlie'),
 731 |                 h('dd', 'Delta'),
 732 |                 h('dt', 'Echo'),
 733 |                 h('dd', 'Foxtrot')
 734 |               ])
 735 |             ),
 736 |             h('dt', 'Alpha')
 737 |           )
 738 |         }
 739 |       )
 740 | 
 741 |       await t.test('should return nothing without matches', async function () {
 742 |         assert.equal(select('dt:first-of-type', h('dl', [])), undefined)
 743 |       })
 744 |     })
 745 | 
 746 |     await t.test(':last-of-type', async function (t) {
 747 |       await t.test(
 748 |         'should return the last match for `:last-of-type`s',
 749 |         async function () {
 750 |           assert.deepEqual(
 751 |             select(
 752 |               'dt:last-of-type',
 753 |               h('dl', [
 754 |                 h('dt', 'Alpha'),
 755 |                 h('dd', 'Bravo'),
 756 |                 h('dt', 'Charlie'),
 757 |                 h('dd', 'Delta'),
 758 |                 h('dt', 'Echo'),
 759 |                 h('dd', 'Foxtrot')
 760 |               ])
 761 |             ),
 762 |             h('dt', 'Echo')
 763 |           )
 764 |         }
 765 |       )
 766 | 
 767 |       await t.test('should return nothing without matches', async function () {
 768 |         assert.equal(select('dt:last-of-type', h('dl', [])), undefined)
 769 |       })
 770 |     })
 771 | 
 772 |     await t.test(':only-of-type', async function (t) {
 773 |       await t.test('should return the only match', async function () {
 774 |         assert.deepEqual(
 775 |           select(
 776 |             'dd:only-of-type',
 777 |             h('dl', [
 778 |               h('dt', 'Alpha'),
 779 |               h('dt', 'Bravo'),
 780 |               h('dd', 'Charlie'),
 781 |               h('dt', 'Delta')
 782 |             ])
 783 |           ),
 784 |           h('dd', 'Charlie')
 785 |         )
 786 |       })
 787 | 
 788 |       await t.test(
 789 |         'should return nothing with too many matches',
 790 |         async function () {
 791 |           assert.equal(
 792 |             select(
 793 |               'dt:only-of-type',
 794 |               h('dl', [
 795 |                 h('dt', 'Alpha'),
 796 |                 h('dd', 'Bravo'),
 797 |                 h('dt', 'Charlie'),
 798 |                 h('dd', 'Delta'),
 799 |                 h('dt', 'Echo'),
 800 |                 h('dd', 'Foxtrot')
 801 |               ])
 802 |             ),
 803 |             undefined
 804 |           )
 805 |         }
 806 |       )
 807 | 
 808 |       await t.test('should return nothing without matches', async function () {
 809 |         assert.equal(select('dt:only-of-type', h('dl', [])), undefined)
 810 |       })
 811 |     })
 812 |   })
 813 | 
 814 |   await t.test(':lang()', async function (t) {
 815 |     await t.test(
 816 |       'should return the correct matching element',
 817 |       async function () {
 818 |         assert.deepEqual(
 819 |           select(
 820 |             'q:lang(en)',
 821 |             u('root', [
 822 |               h('div', {lang: 'en'}, h('p', {lang: ''}, h('q', '0'))),
 823 |               h('p', {lang: 'fr'}, h('q', {lang: 'fr'}, 'A')),
 824 |               h('p', {lang: 'fr'}, h('q', {lang: ''}, 'B')),
 825 |               h('p', {lang: 'fr'}, h('q', {lang: 'en-GB'}, 'C')),
 826 |               h('p', {lang: 'fr'}, h('q', {lang: 'en'}, 'D'))
 827 |             ])
 828 |           ),
 829 |           h('q', {lang: 'en-GB'}, 'C')
 830 |         )
 831 |       }
 832 |     )
 833 |   })
 834 | 
 835 |   await t.test(':dir()', async function (t) {
 836 |     const ltr = 'a'
 837 |     const rtl = 'أ'
 838 |     const neutral = '!'
 839 | 
 840 |     await t.test(
 841 |       'should return the correct matching element',
 842 |       async function () {
 843 |         assert.deepEqual(
 844 |           select(
 845 |             'q:dir(rtl)',
 846 |             u('root', [
 847 |               h('div', {dir: 'rtl'}, h('p', {dir: ''}, h('q', ltr))),
 848 |               h('p', {dir: 'ltr'}, h('q', {dir: 'ltr'}, rtl)),
 849 |               h('p', {dir: 'ltr'}, h('q', {dir: ''}, neutral)),
 850 |               h('p', {dir: 'ltr'}, h('q', {dir: 'foo'}, ltr)),
 851 |               h('p', {dir: 'ltr'}, h('q', {dir: 'rtl'}, rtl))
 852 |             ])
 853 |           ),
 854 |           h('q', ltr)
 855 |         )
 856 |       }
 857 |     )
 858 |   })
 859 | 
 860 |   await t.test(':read-write', async function (t) {
 861 |     await t.test(
 862 |       'should return elements inside `[contentEditable=true]`',
 863 |       async function () {
 864 |         assert.deepEqual(
 865 |           select(
 866 |             'p:read-write',
 867 |             u('root', [h('div', {contentEditable: 'true'}, [h('p', 'A')])])
 868 |           ),
 869 |           h('p', 'A')
 870 |         )
 871 |       }
 872 |     )
 873 | 
 874 |     await t.test(
 875 |       'should not return elements inside SVG embedded in `[contentEditable=true]`',
 876 |       async function () {
 877 |         assert.deepEqual(
 878 |           select(
 879 |             'a:read-write',
 880 |             u('root', [
 881 |               h('div', {contentEditable: 'true'}, [
 882 |                 s('svg', {viewBox: [0, 0, 50, 50]}, [
 883 |                   s('a', {download: true}, '!')
 884 |                 ])
 885 |               ])
 886 |             ])
 887 |           ),
 888 |           undefined
 889 |         )
 890 |       }
 891 |     )
 892 |   })
 893 | 
 894 |   await t.test(':read-only', async function (t) {
 895 |     await t.test(
 896 |       'should not return elements inside `[contentEditable=true]`',
 897 |       async function () {
 898 |         assert.deepEqual(
 899 |           select(
 900 |             'p:read-only',
 901 |             u('root', [h('div', {contentEditable: 'true'}, [h('p', 'A')])])
 902 |           ),
 903 |           undefined
 904 |         )
 905 |       }
 906 |     )
 907 | 
 908 |     await t.test(
 909 |       'should return elements inside SVG embedded in `[contentEditable=true]`',
 910 |       async function () {
 911 |         assert.deepEqual(
 912 |           select(
 913 |             'a:read-only',
 914 |             u('root', [
 915 |               h('div', {contentEditable: 'true'}, [
 916 |                 s('svg', {viewBox: [0, 0, 50, 50]}, [
 917 |                   s('a', {download: true}, '!')
 918 |                 ])
 919 |               ])
 920 |             ])
 921 |           ),
 922 |           s('a', {download: true}, '!')
 923 |         )
 924 |       }
 925 |     )
 926 |   })
 927 | 
 928 |   await t.test(':root', async function (t) {
 929 |     await t.test(
 930 |       'should return the `<html>` element with a `root` as parent',
 931 |       async function () {
 932 |         assert.deepEqual(
 933 |           select(
 934 |             ':root',
 935 |             u('root', [
 936 |               u('doctype', {name: 'html'}),
 937 |               h('html', [h('title', 'Hello'), h('p', 'World')])
 938 |             ])
 939 |           ),
 940 |           h('html', [h('title', 'Hello'), h('p', 'World')])
 941 |         )
 942 |       }
 943 |     )
 944 | 
 945 |     await t.test(
 946 |       'should return the `<html>` element with a no parent',
 947 |       async function () {
 948 |         assert.deepEqual(
 949 |           select(':root', h('html', [h('title', 'Hello'), h('p', 'World')])),
 950 |           h('html', [h('title', 'Hello'), h('p', 'World')])
 951 |         )
 952 |       }
 953 |     )
 954 | 
 955 |     await t.test(
 956 |       'should return the `<svg>` element with a `root` as parent',
 957 |       async function () {
 958 |         assert.deepEqual(
 959 |           select(
 960 |             ':root',
 961 |             u('root', [
 962 |               s('svg', {viewBox: [0, 0, 10, 10]}, [
 963 |                 s('circle', {cx: 10, cy: 10, r: 10})
 964 |               ])
 965 |             ]),
 966 |             'svg'
 967 |           ),
 968 |           s('svg', {viewBox: [0, 0, 10, 10]}, [
 969 |             s('circle', {cx: 10, cy: 10, r: 10})
 970 |           ])
 971 |         )
 972 |       }
 973 |     )
 974 | 
 975 |     await t.test(
 976 |       'should return the `<svg>` element with a no parent',
 977 |       async function () {
 978 |         assert.deepEqual(
 979 |           select(
 980 |             ':root',
 981 |             s('svg', {viewBox: [0, 0, 10, 10]}, [
 982 |               s('circle', {cx: 10, cy: 10, r: 10})
 983 |             ]),
 984 |             'svg'
 985 |           ),
 986 |           s('svg', {viewBox: [0, 0, 10, 10]}, [
 987 |             s('circle', {cx: 10, cy: 10, r: 10})
 988 |           ])
 989 |         )
 990 |       }
 991 |     )
 992 | 
 993 |     await t.test(
 994 |       'should return the `<html>` element, not an embedded `<svg>` element',
 995 |       async function () {
 996 |         assert.deepEqual(
 997 |           select(
 998 |             ':root',
 999 |             u('root', [
1000 |               u('doctype', {name: 'html'}),
1001 |               h('html', [
1002 |                 h('title', 'Hello'),
1003 |                 h('p', 'World'),
1004 |                 s('svg', {viewBox: [0, 0, 10, 10]}, [
1005 |                   s('circle', {cx: 10, cy: 10, r: 10})
1006 |                 ])
1007 |               ])
1008 |             ])
1009 |           ),
1010 |           h('html', [
1011 |             h('title', 'Hello'),
1012 |             h('p', 'World'),
1013 |             s('svg', {viewBox: [0, 0, 10, 10]}, [
1014 |               s('circle', {cx: 10, cy: 10, r: 10})
1015 |             ])
1016 |           ])
1017 |         )
1018 |       }
1019 |     )
1020 |   })
1021 | 
1022 |   await t.test(':scope', async function (t) {
1023 |     await t.test(
1024 |       'should select the first element directly in a `root`, if a `root` is given',
1025 |       async function () {
1026 |         assert.deepEqual(
1027 |           select(
1028 |             ':scope',
1029 |             u('root', [h('strong', h('b', 'a')), h('em', h('i', 'b'))])
1030 |           ),
1031 |           h('strong', h('b', 'a'))
1032 |         )
1033 |       }
1034 |     )
1035 | 
1036 |     await t.test(
1037 |       'should select the root element if one is given',
1038 |       async function () {
1039 |         assert.deepEqual(
1040 |           select(':scope', h('em', h('i', 'b'))),
1041 |           h('em', h('i', 'b'))
1042 |         )
1043 |       }
1044 |     )
1045 |   })
1046 | 
1047 |   await t.test(':is', async function (t) {
1048 |     await t.test('should support parent-sensitive `:is`', async function () {
1049 |       assert.deepEqual(
1050 |         select('y:is(:first-child)', h('x', [h('y#a'), h('y#b')])),
1051 |         h('y#a')
1052 |       )
1053 |     })
1054 |   })
1055 | 
1056 |   await t.test(':not', async function (t) {
1057 |     await t.test('should support parent-sensitive `:not`', async function () {
1058 |       assert.deepEqual(
1059 |         select('y:not(:first-child)', h('x', [h('y#a'), h('y#b')])),
1060 |         h('y#b')
1061 |       )
1062 |     })
1063 |   })
1064 | })
1065 | 


--------------------------------------------------------------------------------
/test/select-all.js:
--------------------------------------------------------------------------------
   1 | import assert from 'node:assert/strict'
   2 | import test from 'node:test'
   3 | import {h, s} from 'hastscript'
   4 | import {selectAll} from 'hast-util-select'
   5 | import {u} from 'unist-builder'
   6 | 
   7 | test('select.selectAll()', async function (t) {
   8 |   await t.test('invalid selectors', async function (t) {
   9 |     await t.test('should throw without selector', async function () {
  10 |       assert.throws(function () {
  11 |         // @ts-expect-error: check how the runtime handles a missing `selector`.
  12 |         selectAll()
  13 |       }, /Error: Expected `string` as selector, not `undefined`/)
  14 |     })
  15 | 
  16 |     await t.test('should throw w/ invalid selector (1)', async function () {
  17 |       assert.throws(function () {
  18 |         // @ts-expect-error: check how the runtime handles an incorrect `selector`.
  19 |         selectAll([], h(''))
  20 |       }, /Error: Expected `string` as selector, not ``/)
  21 |     })
  22 | 
  23 |     await t.test('should throw w/ invalid selector (2)', async function () {
  24 |       assert.throws(function () {
  25 |         selectAll('@supports (transform-origin: 5% 5%) {}', h(''))
  26 |       }, /Expected rule but "@" found/)
  27 |     })
  28 | 
  29 |     await t.test(
  30 |       'should throw on invalid attribute operators',
  31 |       async function () {
  32 |         assert.throws(function () {
  33 |           selectAll('[foo%=bar]', h(''))
  34 |         }, /Expected a valid attribute selector operator/)
  35 |       }
  36 |     )
  37 | 
  38 |     await t.test('should throw on invalid pseudo classes', async function () {
  39 |       assert.throws(function () {
  40 |         selectAll(':active', h(''))
  41 |       }, /Error: Unknown pseudo-selector `active`/)
  42 |     })
  43 | 
  44 |     await t.test(
  45 |       'should throw on invalid pseudo class “functions”',
  46 |       async function () {
  47 |         assert.throws(function () {
  48 |           selectAll(':nth-foo(2n+1)', h(''))
  49 |         }, /Unknown pseudo-class/)
  50 |       }
  51 |     )
  52 | 
  53 |     await t.test('should throw on invalid pseudo elements', async function () {
  54 |       assert.throws(function () {
  55 |         selectAll('::before', h(''))
  56 |       }, /Invalid selector: `::before`/)
  57 |     })
  58 |   })
  59 | 
  60 |   await t.test('general', async function (t) {
  61 |     await t.test('should throw on empty selectors', async function () {
  62 |       assert.throws(function () {
  63 |         selectAll('', h())
  64 |       }, /Expected rule but end of input reached/)
  65 |     })
  66 | 
  67 |     await t.test(
  68 |       'should throw for a white-space only selector',
  69 |       async function () {
  70 |         assert.throws(function () {
  71 |           selectAll(' ', h())
  72 |         }, /Expected rule but end of input reached/)
  73 |       }
  74 |     )
  75 | 
  76 |     await t.test('should be empty if not given a node', async function () {
  77 |       assert.deepEqual(selectAll('*'), [])
  78 |     })
  79 | 
  80 |     await t.test('should be empty if not given an element', async function () {
  81 |       assert.deepEqual(selectAll('*', {type: 'text', value: 'a'}), [])
  82 |     })
  83 |   })
  84 | 
  85 |   await t.test('descendant selector', async function (t) {
  86 |     await t.test('should return descendant nodes', async function () {
  87 |       assert.deepEqual(
  88 |         selectAll(
  89 |           'div',
  90 |           u('root', [
  91 |             h('#one'),
  92 |             h('main', [h('#two'), h('article', h('#three'))])
  93 |           ])
  94 |         ),
  95 |         [h('#one'), h('#two'), h('#three')]
  96 |       )
  97 |     })
  98 | 
  99 |     await t.test(
 100 |       'should return the given node if it matches',
 101 |       async function () {
 102 |         assert.deepEqual(selectAll('div', h('#one')), [h('#one')])
 103 |       }
 104 |     )
 105 | 
 106 |     await t.test(
 107 |       'should return matches with nested matches',
 108 |       async function () {
 109 |         assert.deepEqual(
 110 |           selectAll(
 111 |             'div',
 112 |             u('root', [h('#one', [h('#two'), h('#three', h('#four'))])])
 113 |           ),
 114 |           [
 115 |             h('#one', [h('#two'), h('#three', h('#four'))]),
 116 |             h('#two'),
 117 |             h('#three', h('#four')),
 118 |             h('#four')
 119 |           ]
 120 |         )
 121 |       }
 122 |     )
 123 | 
 124 |     await t.test('should return deep matches', async function () {
 125 |       assert.deepEqual(
 126 |         selectAll('p i s', u('root', [h('p', h('i', h('s', h('s'))))])),
 127 |         [h('s', h('s')), h('s')]
 128 |       )
 129 |     })
 130 | 
 131 |     await t.test('should not match outside other matches', async function () {
 132 |       assert.deepEqual(
 133 |         selectAll('b s', h('p', [h('b', h('s', '1')), h('i', h('s', '2'))])),
 134 |         [h('s', '1')]
 135 |       )
 136 |     })
 137 |   })
 138 | 
 139 |   await t.test('child selector', async function (t) {
 140 |     await t.test('should return child nodes', async function () {
 141 |       assert.deepEqual(
 142 |         selectAll(
 143 |           'main > article',
 144 |           u('root', [
 145 |             h('#one'),
 146 |             h('main', [h('#two'), h('article', h('#three'))])
 147 |           ])
 148 |         ),
 149 |         [h('article', h('#three'))]
 150 |       )
 151 |     })
 152 | 
 153 |     await t.test(
 154 |       'should return matches with nested matches',
 155 |       async function () {
 156 |         assert.deepEqual(
 157 |           selectAll(
 158 |             'div > div',
 159 |             u('root', [h('#one', [h('#two'), h('#three', h('#four'))])])
 160 |           ),
 161 |           [h('#two'), h('#three', h('#four')), h('#four')]
 162 |         )
 163 |       }
 164 |     )
 165 | 
 166 |     await t.test('should return deep matches', async function () {
 167 |       assert.deepEqual(
 168 |         selectAll('p > i > s', u('root', [h('p', h('i', h('s', h('s'))))])),
 169 |         [h('s', h('s'))]
 170 |       )
 171 |     })
 172 |   })
 173 | 
 174 |   await t.test('next-sibling selector', async function (t) {
 175 |     await t.test('should return next-sibling', async function () {
 176 |       assert.deepEqual(
 177 |         selectAll(
 178 |           'h1 + p',
 179 |           u('root', [
 180 |             h('p', 'Alpha'),
 181 |             h('h1', 'Bravo'),
 182 |             h('p', 'Charlie'),
 183 |             h('p', 'Delta'),
 184 |             h('div', [h('p', 'Echo')])
 185 |           ])
 186 |         ),
 187 |         [h('p', 'Charlie')]
 188 |       )
 189 |     })
 190 | 
 191 |     await t.test(
 192 |       'should return next-sibling ignoring non-elements',
 193 |       async function () {
 194 |         assert.deepEqual(
 195 |           selectAll(
 196 |             'a + b',
 197 |             u('root', [
 198 |               u('text', '\n'),
 199 |               h('a', 'Lorem'),
 200 |               u('text', ' ipsum '),
 201 |               h('b', 'dolor'),
 202 |               u('text', ' sit '),
 203 |               h('i', 'amet'),
 204 |               u('text', ' sed '),
 205 |               h('b', 'do'),
 206 |               u('text', ' eiusmod '),
 207 |               h('i', 'tempor'),
 208 |               u('text', '.\n')
 209 |             ])
 210 |           ),
 211 |           [h('b', 'dolor')]
 212 |         )
 213 |       }
 214 |     )
 215 | 
 216 |     await t.test('should return nothing without matches', async function () {
 217 |       assert.deepEqual(
 218 |         selectAll(
 219 |           'h1 + p',
 220 |           u('root', [
 221 |             h('p', 'Alpha'),
 222 |             h('h1', 'Bravo'),
 223 |             h('h2', 'Charlie'),
 224 |             h('p', 'Delta')
 225 |           ])
 226 |         ),
 227 |         []
 228 |       )
 229 |     })
 230 |   })
 231 | 
 232 |   await t.test('subsequent sibling selector', async function (t) {
 233 |     await t.test('should return subsequent sibling', async function () {
 234 |       assert.deepEqual(
 235 |         selectAll(
 236 |           'h1 ~ p',
 237 |           u('root', [
 238 |             h('p', 'Alpha'),
 239 |             h('h1', 'Bravo'),
 240 |             h('p', 'Charlie'),
 241 |             h('p', 'Delta'),
 242 |             h('div', [h('p', 'Echo')])
 243 |           ])
 244 |         ),
 245 |         [h('p', 'Charlie'), h('p', 'Delta')]
 246 |       )
 247 |     })
 248 | 
 249 |     await t.test('should return subsequent siblings', async function () {
 250 |       assert.deepEqual(
 251 |         selectAll(
 252 |           'h1 ~ p',
 253 |           u('root', [
 254 |             h('p', 'Alpha'),
 255 |             h('h1', 'Bravo'),
 256 |             h('h2', 'Charlie'),
 257 |             h('p', 'Delta')
 258 |           ])
 259 |         ),
 260 |         [h('p', 'Delta')]
 261 |       )
 262 |     })
 263 | 
 264 |     await t.test(
 265 |       'should return siblings ignoring non-elements',
 266 |       async function () {
 267 |         assert.deepEqual(
 268 |           selectAll(
 269 |             'a ~ i',
 270 |             u('root', [
 271 |               u('text', '\n'),
 272 |               h('a', 'Lorem'),
 273 |               u('text', ' ipsum '),
 274 |               h('b', 'dolor'),
 275 |               u('text', ' sit '),
 276 |               h('i', 'amet'),
 277 |               u('text', ' sed '),
 278 |               h('b', 'do'),
 279 |               u('text', ' eiusmod '),
 280 |               h('i', 'tempor'),
 281 |               u('text', '.\n')
 282 |             ])
 283 |           ),
 284 |           [h('i', 'amet'), h('i', 'tempor')]
 285 |         )
 286 |       }
 287 |     )
 288 | 
 289 |     await t.test('should return nothing without matches', async function () {
 290 |       assert.deepEqual(
 291 |         selectAll(
 292 |           'h1 ~ p',
 293 |           u('root', [h('p', 'Alpha'), h('h1', 'Bravo'), h('h2', 'Charlie')])
 294 |         ),
 295 |         []
 296 |       )
 297 |     })
 298 |   })
 299 | 
 300 |   await t.test('parent-sensitive pseudo-selectors', async function (t) {
 301 |     await t.test(':first-child', async function (t) {
 302 |       await t.test('should return all `:first-child`s (1)', async function () {
 303 |         assert.deepEqual(
 304 |           selectAll(
 305 |             ':first-child',
 306 |             u('root', [
 307 |               h('p', 'Alpha'),
 308 |               h('h1', 'Bravo'),
 309 |               h('p', 'Charlie'),
 310 |               h('p', 'Delta'),
 311 |               h('div', [h('p', 'Echo')])
 312 |             ])
 313 |           ),
 314 |           [h('p', 'Alpha'), h('p', 'Echo')]
 315 |         )
 316 |       })
 317 | 
 318 |       await t.test('should return all `:first-child`s (2)', async function () {
 319 |         assert.deepEqual(
 320 |           selectAll(
 321 |             'p:first-child',
 322 |             u('root', [h('p', 'Alpha'), h('h1', 'Bravo'), h('p', 'Charlie')])
 323 |           ),
 324 |           [h('p', 'Alpha')]
 325 |         )
 326 |       })
 327 | 
 328 |       await t.test(
 329 |         'should return nothing if nothing matches',
 330 |         async function () {
 331 |           assert.deepEqual(
 332 |             selectAll(
 333 |               'h1:first-child',
 334 |               u('root', [h('p', 'Alpha'), h('h1', 'Bravo'), h('p', 'Charlie')])
 335 |             ),
 336 |             []
 337 |           )
 338 |         }
 339 |       )
 340 |     })
 341 | 
 342 |     await t.test(':last-child', async function (t) {
 343 |       await t.test('should return all `:last-child`s (1)', async function () {
 344 |         assert.deepEqual(
 345 |           selectAll(
 346 |             ':last-child',
 347 |             u('root', [
 348 |               h('p', 'Alpha'),
 349 |               h('h1', 'Bravo'),
 350 |               h('p', 'Charlie'),
 351 |               h('p', 'Delta'),
 352 |               h('div', [h('p', 'Echo')])
 353 |             ])
 354 |           ),
 355 |           [h('div', [h('p', 'Echo')]), h('p', 'Echo')]
 356 |         )
 357 |       })
 358 | 
 359 |       await t.test('should return all `:last-child`s (2)', async function () {
 360 |         assert.deepEqual(
 361 |           selectAll(
 362 |             'p:last-child',
 363 |             u('root', [h('p', 'Alpha'), h('h1', 'Bravo'), h('p', 'Charlie')])
 364 |           ),
 365 |           [h('p', 'Charlie')]
 366 |         )
 367 |       })
 368 | 
 369 |       await t.test(
 370 |         'should return nothing if nothing matches',
 371 |         async function () {
 372 |           assert.deepEqual(
 373 |             selectAll(
 374 |               'h1:last-child',
 375 |               u('root', [h('p', 'Alpha'), h('h1', 'Bravo'), h('p', 'Charlie')])
 376 |             ),
 377 |             []
 378 |           )
 379 |         }
 380 |       )
 381 |     })
 382 | 
 383 |     await t.test(':only-child', async function (t) {
 384 |       await t.test('should return all `:only-child`s', async function () {
 385 |         assert.deepEqual(
 386 |           selectAll(
 387 |             ':only-child',
 388 |             u('root', [
 389 |               h('p', 'Alpha'),
 390 |               h('h1', 'Bravo'),
 391 |               h('p', 'Charlie'),
 392 |               h('p', 'Delta'),
 393 |               h('div', [h('p', 'Echo')])
 394 |             ])
 395 |           ),
 396 |           [h('p', 'Echo')]
 397 |         )
 398 |       })
 399 | 
 400 |       await t.test(
 401 |         'should return nothing if nothing matches',
 402 |         async function () {
 403 |           assert.deepEqual(
 404 |             selectAll(
 405 |               'h1:only-child',
 406 |               u('root', [h('p', 'Alpha'), h('h1', 'Bravo'), h('p', 'Charlie')])
 407 |             ),
 408 |             []
 409 |           )
 410 |         }
 411 |       )
 412 |     })
 413 | 
 414 |     await t.test(':nth-child', async function (t) {
 415 |       await t.test('should return all `:nth-child(odd)`s', async function () {
 416 |         assert.deepEqual(
 417 |           selectAll(
 418 |             'li:nth-child(odd)',
 419 |             h('ol', [
 420 |               h('li', 'Alpha'),
 421 |               h('li', 'Bravo'),
 422 |               h('li', 'Charlie'),
 423 |               h('li', 'Delta'),
 424 |               h('li', 'Echo'),
 425 |               h('li', 'Foxtrot')
 426 |             ])
 427 |           ),
 428 |           [h('li', 'Alpha'), h('li', 'Charlie'), h('li', 'Echo')]
 429 |         )
 430 |       })
 431 | 
 432 |       await t.test('should return all `:nth-child(2n+1)`s', async function () {
 433 |         assert.deepEqual(
 434 |           selectAll(
 435 |             'li:nth-child(2n+1)',
 436 |             h('ol', [
 437 |               h('li', 'Alpha'),
 438 |               h('li', 'Bravo'),
 439 |               h('li', 'Charlie'),
 440 |               h('li', 'Delta'),
 441 |               h('li', 'Echo'),
 442 |               h('li', 'Foxtrot')
 443 |             ])
 444 |           ),
 445 |           [h('li', 'Alpha'), h('li', 'Charlie'), h('li', 'Echo')]
 446 |         )
 447 |       })
 448 | 
 449 |       await t.test('should return all `:nth-child(even)`s', async function () {
 450 |         assert.deepEqual(
 451 |           selectAll(
 452 |             'li:nth-child(even)',
 453 |             h('ol', [
 454 |               h('li', 'Alpha'),
 455 |               h('li', 'Bravo'),
 456 |               h('li', 'Charlie'),
 457 |               h('li', 'Delta'),
 458 |               h('li', 'Echo'),
 459 |               h('li', 'Foxtrot')
 460 |             ])
 461 |           ),
 462 |           [h('li', 'Bravo'), h('li', 'Delta'), h('li', 'Foxtrot')]
 463 |         )
 464 |       })
 465 | 
 466 |       await t.test('should return all `:nth-child(2n+0)`s', async function () {
 467 |         assert.deepEqual(
 468 |           selectAll(
 469 |             'li:nth-child(2n+0)',
 470 |             h('ol', [
 471 |               h('li', 'Alpha'),
 472 |               h('li', 'Bravo'),
 473 |               h('li', 'Charlie'),
 474 |               h('li', 'Delta'),
 475 |               h('li', 'Echo'),
 476 |               h('li', 'Foxtrot')
 477 |             ])
 478 |           ),
 479 |           [h('li', 'Bravo'), h('li', 'Delta'), h('li', 'Foxtrot')]
 480 |         )
 481 |       })
 482 | 
 483 |       await t.test(
 484 |         'should throw on unsupported `of` syntax',
 485 |         async function () {
 486 |           assert.throws(function () {
 487 |             selectAll(':nth-child(odd of a)', h('span'))
 488 |           }, /Expected `nth` formula, such as `even` or `2n\+1` \(`of` is not yet supported\)/)
 489 |         }
 490 |       )
 491 | 
 492 |       // To do: add `of Selector` syntax.
 493 |       // These can be deep, such as `:nth-child(even of section h1)`.
 494 |       // To add this, I think we need to add support to `matches` to pass a
 495 |       // list of ancestors (which is likely useful in and of itself).
 496 |       // In `:nth` stuff we can than filter nodes both on the `nth`, and the
 497 |       // `of` selector.
 498 |       // await t.test('should support `of` syntax (reference)', async function () {
 499 |       //   const tree = h('section', [
 500 |       //     h('p', 'Alpha'),
 501 |       //     h('p', 'Bravo'),
 502 |       //     h('h1', 'Charlie'),
 503 |       //     h('p', 'Delta'),
 504 |       //     h('p', 'Echo'),
 505 |       //     h('p', 'Foxtrot'),
 506 |       //     h('h1', 'Golf')
 507 |       //   ])
 508 | 
 509 |       //   assert.deepEqual(selectAll(':is(h1, p):nth-child(even)', tree), [
 510 |       //     tree.children[1],
 511 |       //     tree.children[3],
 512 |       //     tree.children[5]
 513 |       //   ])
 514 |       // })
 515 | 
 516 |       // await t.test('should support `of` syntax (#1)', async function () {
 517 |       //   const tree = h('section', [
 518 |       //     h('p', 'Alpha'),
 519 |       //     h('p', 'Bravo'),
 520 |       //     h('h1', 'Charlie'),
 521 |       //     h('p', 'Delta'),
 522 |       //     h('p', 'Echo'),
 523 |       //     h('p', 'Foxtrot'),
 524 |       //     h('h1', 'Golf')
 525 |       //   ])
 526 | 
 527 |       //   assert.deepEqual(selectAll(':is(h1, p):nth-child(even of p)', tree), [
 528 |       //     tree.children[1],
 529 |       //     tree.children[4]
 530 |       //   ])
 531 |       // })
 532 | 
 533 |       // await t.test('should support `of` syntax (#2)', async function () {
 534 |       //   const tree = h('section', [
 535 |       //     h('p', 'Alpha'),
 536 |       //     h('p', 'Bravo'),
 537 |       //     h('h1', 'Charlie'),
 538 |       //     h('p', 'Delta'),
 539 |       //     h('p', 'Echo'),
 540 |       //     h('p', 'Foxtrot'),
 541 |       //     h('h1', 'Golf')
 542 |       //   ])
 543 | 
 544 |       //   assert.deepEqual(selectAll(':is(h1, p):nth-child(even of h1)', tree), [
 545 |       //     tree.children[6]
 546 |       //   ])
 547 |       // })
 548 | 
 549 |       // await t.test('should support `of` syntax (#3)', async function () {
 550 |       //   const tree = h('section', [
 551 |       //     h('p', 'Alpha'),
 552 |       //     h('p', 'Bravo'),
 553 |       //     h('h1', 'Charlie'),
 554 |       //     h('p', 'Delta'),
 555 |       //     h('p', 'Echo'),
 556 |       //     h('p', 'Foxtrot'),
 557 |       //     h('h1', 'Golf')
 558 |       //   ])
 559 | 
 560 |       //   assert.deepEqual(
 561 |       //     selectAll(':is(h1, p):nth-child(even of section h1)', tree),
 562 |       //     [tree.children[6]]
 563 |       //   )
 564 |       // })
 565 |     })
 566 | 
 567 |     await t.test(':nth-last-child', async function (t) {
 568 |       await t.test(
 569 |         'should return all `:nth-last-child(odd)`s',
 570 |         async function () {
 571 |           assert.deepEqual(
 572 |             selectAll(
 573 |               'li:nth-last-child(odd)',
 574 |               h('ol', [
 575 |                 h('li', 'Alpha'),
 576 |                 h('li', 'Bravo'),
 577 |                 h('li', 'Charlie'),
 578 |                 h('li', 'Delta'),
 579 |                 h('li', 'Echo'),
 580 |                 h('li', 'Foxtrot')
 581 |               ])
 582 |             ),
 583 |             [h('li', 'Bravo'), h('li', 'Delta'), h('li', 'Foxtrot')]
 584 |           )
 585 |         }
 586 |       )
 587 | 
 588 |       await t.test(
 589 |         'should return all `:nth-last-child(2n+1)`s',
 590 |         async function () {
 591 |           assert.deepEqual(
 592 |             selectAll(
 593 |               'li:nth-last-child(2n+1)',
 594 |               h('ol', [
 595 |                 h('li', 'Alpha'),
 596 |                 h('li', 'Bravo'),
 597 |                 h('li', 'Charlie'),
 598 |                 h('li', 'Delta'),
 599 |                 h('li', 'Echo'),
 600 |                 h('li', 'Foxtrot')
 601 |               ])
 602 |             ),
 603 |             [h('li', 'Bravo'), h('li', 'Delta'), h('li', 'Foxtrot')]
 604 |           )
 605 |         }
 606 |       )
 607 | 
 608 |       await t.test(
 609 |         'should return all `:nth-last-child(even)`s',
 610 |         async function () {
 611 |           assert.deepEqual(
 612 |             selectAll(
 613 |               'li:nth-last-child(even)',
 614 |               h('ol', [
 615 |                 h('li', 'Alpha'),
 616 |                 h('li', 'Bravo'),
 617 |                 h('li', 'Charlie'),
 618 |                 h('li', 'Delta'),
 619 |                 h('li', 'Echo'),
 620 |                 h('li', 'Foxtrot')
 621 |               ])
 622 |             ),
 623 |             [h('li', 'Alpha'), h('li', 'Charlie'), h('li', 'Echo')]
 624 |           )
 625 |         }
 626 |       )
 627 | 
 628 |       await t.test(
 629 |         'should return all `:nth-last-child(2n+0)`s',
 630 |         async function () {
 631 |           assert.deepEqual(
 632 |             selectAll(
 633 |               'li:nth-last-child(2n+0)',
 634 |               h('ol', [
 635 |                 h('li', 'Alpha'),
 636 |                 h('li', 'Bravo'),
 637 |                 h('li', 'Charlie'),
 638 |                 h('li', 'Delta'),
 639 |                 h('li', 'Echo'),
 640 |                 h('li', 'Foxtrot')
 641 |               ])
 642 |             ),
 643 |             [h('li', 'Alpha'), h('li', 'Charlie'), h('li', 'Echo')]
 644 |           )
 645 |         }
 646 |       )
 647 |     })
 648 | 
 649 |     await t.test(':nth-of-type', async function (t) {
 650 |       await t.test('should return all `:nth-of-type(odd)`s', async function () {
 651 |         assert.deepEqual(
 652 |           selectAll(
 653 |             'dt:nth-of-type(odd)',
 654 |             h('dl', [
 655 |               h('dt', 'Alpha'),
 656 |               h('dd', 'Bravo'),
 657 |               h('dt', 'Charlie'),
 658 |               h('dd', 'Delta'),
 659 |               h('dt', 'Echo'),
 660 |               h('dd', 'Foxtrot')
 661 |             ])
 662 |           ),
 663 |           [h('dt', 'Alpha'), h('dt', 'Echo')]
 664 |         )
 665 |       })
 666 | 
 667 |       await t.test(
 668 |         'should return all `:nth-of-type(2n+1)`s',
 669 |         async function () {
 670 |           assert.deepEqual(
 671 |             selectAll(
 672 |               'dt:nth-of-type(2n+1)',
 673 |               h('dl', [
 674 |                 h('dt', 'Alpha'),
 675 |                 h('dd', 'Bravo'),
 676 |                 h('dt', 'Charlie'),
 677 |                 h('dd', 'Delta'),
 678 |                 h('dt', 'Echo'),
 679 |                 h('dd', 'Foxtrot')
 680 |               ])
 681 |             ),
 682 |             [h('dt', 'Alpha'), h('dt', 'Echo')]
 683 |           )
 684 |         }
 685 |       )
 686 | 
 687 |       await t.test(
 688 |         'should return all `:nth-of-type(even)`s',
 689 |         async function () {
 690 |           assert.deepEqual(
 691 |             selectAll(
 692 |               'dt:nth-of-type(even)',
 693 |               h('dl', [
 694 |                 h('dt', 'Alpha'),
 695 |                 h('dd', 'Bravo'),
 696 |                 h('dt', 'Charlie'),
 697 |                 h('dd', 'Delta'),
 698 |                 h('dt', 'Echo'),
 699 |                 h('dd', 'Foxtrot')
 700 |               ])
 701 |             ),
 702 |             [h('dt', 'Charlie')]
 703 |           )
 704 |         }
 705 |       )
 706 | 
 707 |       await t.test(
 708 |         'should return all `:nth-of-type(2n+0)`s',
 709 |         async function () {
 710 |           assert.deepEqual(
 711 |             selectAll(
 712 |               'dt:nth-of-type(2n+0)',
 713 |               h('dl', [
 714 |                 h('dt', 'Alpha'),
 715 |                 h('dd', 'Bravo'),
 716 |                 h('dt', 'Charlie'),
 717 |                 h('dd', 'Delta'),
 718 |                 h('dt', 'Echo'),
 719 |                 h('dd', 'Foxtrot')
 720 |               ])
 721 |             ),
 722 |             [h('dt', 'Charlie')]
 723 |           )
 724 |         }
 725 |       )
 726 |     })
 727 | 
 728 |     await t.test(':nth-last-of-type', async function (t) {
 729 |       await t.test(
 730 |         'should return all `:nth-last-of-type(odd)`s',
 731 |         async function () {
 732 |           assert.deepEqual(
 733 |             selectAll(
 734 |               'dt:nth-last-of-type(odd)',
 735 |               h('dl', [
 736 |                 h('dt', 'Alpha'),
 737 |                 h('dd', 'Bravo'),
 738 |                 h('dt', 'Charlie'),
 739 |                 h('dd', 'Delta'),
 740 |                 h('dt', 'Echo'),
 741 |                 h('dd', 'Foxtrot')
 742 |               ])
 743 |             ),
 744 |             [h('dt', 'Alpha'), h('dt', 'Echo')]
 745 |           )
 746 |         }
 747 |       )
 748 | 
 749 |       await t.test(
 750 |         'should return all `:nth-last-of-type(2n+1)`s',
 751 |         async function () {
 752 |           assert.deepEqual(
 753 |             selectAll(
 754 |               'dt:nth-last-of-type(2n+1)',
 755 |               h('dl', [
 756 |                 h('dt', 'Alpha'),
 757 |                 h('dd', 'Bravo'),
 758 |                 h('dt', 'Charlie'),
 759 |                 h('dd', 'Delta'),
 760 |                 h('dt', 'Echo'),
 761 |                 h('dd', 'Foxtrot')
 762 |               ])
 763 |             ),
 764 |             [h('dt', 'Alpha'), h('dt', 'Echo')]
 765 |           )
 766 |         }
 767 |       )
 768 | 
 769 |       await t.test(
 770 |         'should return all `:nth-last-of-type(even)`s',
 771 |         async function () {
 772 |           assert.deepEqual(
 773 |             selectAll(
 774 |               'dt:nth-last-of-type(even)',
 775 |               h('dl', [
 776 |                 h('dt', 'Alpha'),
 777 |                 h('dd', 'Bravo'),
 778 |                 h('dt', 'Charlie'),
 779 |                 h('dd', 'Delta'),
 780 |                 h('dt', 'Echo'),
 781 |                 h('dd', 'Foxtrot')
 782 |               ])
 783 |             ),
 784 |             [h('dt', 'Charlie')]
 785 |           )
 786 |         }
 787 |       )
 788 | 
 789 |       await t.test(
 790 |         'should return all `:nth-last-of-type(2n+0)`s',
 791 |         async function () {
 792 |           assert.deepEqual(
 793 |             selectAll(
 794 |               'dt:nth-last-of-type(2n+0)',
 795 |               h('dl', [
 796 |                 h('dt', 'Alpha'),
 797 |                 h('dd', 'Bravo'),
 798 |                 h('dt', 'Charlie'),
 799 |                 h('dd', 'Delta'),
 800 |                 h('dt', 'Echo'),
 801 |                 h('dd', 'Foxtrot')
 802 |               ])
 803 |             ),
 804 |             [h('dt', 'Charlie')]
 805 |           )
 806 |         }
 807 |       )
 808 |     })
 809 | 
 810 |     await t.test(':first-of-type', async function (t) {
 811 |       await t.test('should return all `:first-of-type`s', async function () {
 812 |         assert.deepEqual(
 813 |           selectAll(
 814 |             'dt:first-of-type',
 815 |             h('dl', [
 816 |               h('dt', 'Alpha'),
 817 |               h('dd', 'Bravo'),
 818 |               h('dt', 'Charlie'),
 819 |               h('dd', 'Delta'),
 820 |               h('dt', 'Echo'),
 821 |               h('dd', 'Foxtrot')
 822 |             ])
 823 |           ),
 824 |           [h('dt', 'Alpha')]
 825 |         )
 826 |       })
 827 | 
 828 |       await t.test('should return nothing without matches', async function () {
 829 |         assert.deepEqual(selectAll('dt:first-of-type', h('dl', [])), [])
 830 |       })
 831 |     })
 832 | 
 833 |     await t.test(':last-of-type', async function (t) {
 834 |       await t.test('should return all `:last-of-type`s', async function () {
 835 |         assert.deepEqual(
 836 |           selectAll(
 837 |             'dt:last-of-type',
 838 |             h('dl', [
 839 |               h('dt', 'Alpha'),
 840 |               h('dd', 'Bravo'),
 841 |               h('dt', 'Charlie'),
 842 |               h('dd', 'Delta'),
 843 |               h('dt', 'Echo'),
 844 |               h('dd', 'Foxtrot')
 845 |             ])
 846 |           ),
 847 |           [h('dt', 'Echo')]
 848 |         )
 849 |       })
 850 | 
 851 |       await t.test('should return nothing without matches', async function () {
 852 |         assert.deepEqual(selectAll('dt:last-of-type', h('dl', [])), [])
 853 |       })
 854 |     })
 855 | 
 856 |     await t.test(':only-of-type', async function (t) {
 857 |       await t.test('should return the only type', async function () {
 858 |         assert.deepEqual(
 859 |           selectAll(
 860 |             'dd:only-of-type',
 861 |             h('dl', [
 862 |               h('dt', 'Alpha'),
 863 |               h('dt', 'Bravo'),
 864 |               h('dd', 'Charlie'),
 865 |               h('dt', 'Delta')
 866 |             ])
 867 |           ),
 868 |           [h('dd', 'Charlie')]
 869 |         )
 870 |       })
 871 | 
 872 |       await t.test(
 873 |         'should return nothing with too many matches',
 874 |         async function () {
 875 |           assert.deepEqual(
 876 |             selectAll(
 877 |               'dt:only-of-type',
 878 |               h('dl', [
 879 |                 h('dt', 'Alpha'),
 880 |                 h('dd', 'Bravo'),
 881 |                 h('dt', 'Charlie'),
 882 |                 h('dd', 'Delta'),
 883 |                 h('dt', 'Echo'),
 884 |                 h('dd', 'Foxtrot')
 885 |               ])
 886 |             ),
 887 |             []
 888 |           )
 889 |         }
 890 |       )
 891 | 
 892 |       await t.test('should return nothing without matches', async function () {
 893 |         assert.deepEqual(selectAll('dt:only-of-type', h('dl', [])), [])
 894 |       })
 895 |     })
 896 |   })
 897 | 
 898 |   await t.test(':lang()', async function (t) {
 899 |     await t.test(
 900 |       'should return the correct matching elements',
 901 |       async function () {
 902 |         assert.deepEqual(
 903 |           selectAll(
 904 |             'q:lang(en)',
 905 |             u('root', [
 906 |               h('div', {lang: 'en'}, h('p', {lang: ''}, h('q', '0'))),
 907 |               h('p', {lang: 'fr'}, h('q', {lang: 'fr'}, 'A')),
 908 |               h('p', {lang: 'fr'}, h('q', {lang: 'en'}, 'B')),
 909 |               h('p', {lang: 'fr'}, h('q', {lang: 'en-GB'}, 'C')),
 910 |               h('p', {lang: 'fr'}, h('q', {lang: ''}, 'D')),
 911 |               h('p', {lang: 'fr'}, h('q', 'E')),
 912 |               h('p', {lang: 'en'}, h('q', {lang: 'fr'}, 'F')),
 913 |               h('p', {lang: 'en'}, h('q', {lang: 'en'}, 'G')),
 914 |               h('p', {lang: 'en'}, h('q', {lang: 'en-GB'}, 'H')),
 915 |               h('p', {lang: 'en'}, h('q', {lang: ''}, 'I')),
 916 |               h('p', {lang: 'en'}, h('q', 'J')),
 917 |               h('p', {lang: 'en-GB'}, h('q', {lang: 'fr'}, 'K')),
 918 |               h('p', {lang: 'en-GB'}, h('q', {lang: 'en'}, 'L')),
 919 |               h('p', {lang: 'en-GB'}, h('q', {lang: 'en-GB'}, 'M')),
 920 |               h('p', {lang: 'en-GB'}, h('q', {lang: ''}, 'N')),
 921 |               h('p', {lang: 'en-GB'}, h('q', 'O'))
 922 |             ])
 923 |           ),
 924 |           [
 925 |             h('q', {lang: 'en'}, 'B'),
 926 |             h('q', {lang: 'en-GB'}, 'C'),
 927 |             h('q', {lang: 'en'}, 'G'),
 928 |             h('q', {lang: 'en-GB'}, 'H'),
 929 |             h('q', 'J'),
 930 |             h('q', {lang: 'en'}, 'L'),
 931 |             h('q', {lang: 'en-GB'}, 'M'),
 932 |             h('q', 'O')
 933 |           ]
 934 |         )
 935 |       }
 936 |     )
 937 |   })
 938 | 
 939 |   await t.test(':dir()', async function (t) {
 940 |     const ltr = 'a'
 941 |     const rtl = 'أ'
 942 | 
 943 |     await t.test(
 944 |       'should return the correct matching element',
 945 |       async function () {
 946 |         assert.deepEqual(
 947 |           selectAll(
 948 |             'q:dir(rtl)',
 949 |             u('root', [
 950 |               h('div', {dir: 'rtl'}, h('p', {dir: ''}, h('q#a', ltr))),
 951 |               h('p', {dir: 'ltr'}, h('q#b', {dir: 'ltr'}, rtl)),
 952 |               h('p', {dir: 'ltr'}, h('q#c', {dir: ''}, rtl)),
 953 |               h('p', {dir: 'ltr'}, h('q#d', {dir: 'foo'}, rtl)),
 954 |               h('p', {dir: 'ltr'}, h('q#e', {dir: 'rtl'}, rtl))
 955 |             ])
 956 |           ),
 957 |           [h('q#a', ltr), h('q#e', {dir: 'rtl'}, rtl)]
 958 |         )
 959 |       }
 960 |     )
 961 |   })
 962 | 
 963 |   await t.test(':read-write', async function (t) {
 964 |     await t.test(
 965 |       'should return elements inside `[contentEditable=true]`',
 966 |       async function () {
 967 |         assert.deepEqual(
 968 |           selectAll(
 969 |             'p:read-write',
 970 |             u('root', [h('div', {contentEditable: 'true'}, [h('p', 'A')])])
 971 |           ),
 972 |           [h('p', 'A')]
 973 |         )
 974 |       }
 975 |     )
 976 | 
 977 |     await t.test(
 978 |       'should not return elements inside SVG embedded in `[contentEditable=true]`',
 979 |       async function () {
 980 |         assert.deepEqual(
 981 |           selectAll(
 982 |             'a:read-write',
 983 |             u('root', [
 984 |               h('div', {contentEditable: 'true'}, [
 985 |                 s('svg', {viewBox: [0, 0, 50, 50]}, [
 986 |                   s('a', {download: true}, '!')
 987 |                 ])
 988 |               ])
 989 |             ])
 990 |           ),
 991 |           []
 992 |         )
 993 |       }
 994 |     )
 995 |   })
 996 | 
 997 |   await t.test(':read-only', async function (t) {
 998 |     await t.test(
 999 |       'should not return elements inside `[contentEditable=true]`',
1000 |       async function () {
1001 |         assert.deepEqual(
1002 |           selectAll(
1003 |             'p:read-only',
1004 |             u('root', [h('div', {contentEditable: 'true'}, [h('p', 'A')])])
1005 |           ),
1006 |           []
1007 |         )
1008 |       }
1009 |     )
1010 | 
1011 |     await t.test(
1012 |       'should return elements inside SVG embedded in `[contentEditable=true]`',
1013 |       async function () {
1014 |         assert.deepEqual(
1015 |           selectAll(
1016 |             'a:read-only',
1017 |             u('root', [
1018 |               h('div', {contentEditable: 'true'}, [
1019 |                 s('svg', {viewBox: [0, 0, 50, 50]}, [
1020 |                   s('a', {download: true}, '!')
1021 |                 ])
1022 |               ])
1023 |             ])
1024 |           ),
1025 |           [s('a', {download: true}, '!')]
1026 |         )
1027 |       }
1028 |     )
1029 |   })
1030 | 
1031 |   await t.test(':root', async function (t) {
1032 |     await t.test(
1033 |       'should return the `<html>` element with a `root` as parent',
1034 |       async function () {
1035 |         assert.deepEqual(
1036 |           selectAll(
1037 |             ':root',
1038 |             u('root', [
1039 |               u('doctype', {name: 'html'}),
1040 |               h('html', [h('title', 'Hello'), h('p', 'World')])
1041 |             ])
1042 |           ),
1043 |           [h('html', [h('title', 'Hello'), h('p', 'World')])]
1044 |         )
1045 |       }
1046 |     )
1047 | 
1048 |     await t.test(
1049 |       'should return the `<html>` element with a no parent',
1050 |       async function () {
1051 |         assert.deepEqual(
1052 |           selectAll(':root', h('html', [h('title', 'Hello'), h('p', 'World')])),
1053 |           [h('html', [h('title', 'Hello'), h('p', 'World')])]
1054 |         )
1055 |       }
1056 |     )
1057 | 
1058 |     await t.test(
1059 |       'should return the `<svg>` element with a `root` as parent',
1060 |       async function () {
1061 |         assert.deepEqual(
1062 |           selectAll(
1063 |             ':root',
1064 |             u('root', [
1065 |               s('svg', {viewBox: [0, 0, 10, 10]}, [
1066 |                 s('circle', {cx: 10, cy: 10, r: 10})
1067 |               ])
1068 |             ]),
1069 |             'svg'
1070 |           ),
1071 |           [
1072 |             s('svg', {viewBox: [0, 0, 10, 10]}, [
1073 |               s('circle', {cx: 10, cy: 10, r: 10})
1074 |             ])
1075 |           ]
1076 |         )
1077 |       }
1078 |     )
1079 | 
1080 |     await t.test(
1081 |       'should return the `<svg>` element with a no parent',
1082 |       async function () {
1083 |         assert.deepEqual(
1084 |           selectAll(
1085 |             ':root',
1086 |             s('svg', {viewBox: [0, 0, 10, 10]}, [
1087 |               s('circle', {cx: 10, cy: 10, r: 10})
1088 |             ]),
1089 |             'svg'
1090 |           ),
1091 |           [
1092 |             s('svg', {viewBox: [0, 0, 10, 10]}, [
1093 |               s('circle', {cx: 10, cy: 10, r: 10})
1094 |             ])
1095 |           ]
1096 |         )
1097 |       }
1098 |     )
1099 | 
1100 |     await t.test(
1101 |       'should return the `<html>` element, not an embedded `<svg>` element',
1102 |       async function () {
1103 |         assert.deepEqual(
1104 |           selectAll(
1105 |             ':root',
1106 |             u('root', [
1107 |               u('doctype', {name: 'html'}),
1108 |               h('html', [
1109 |                 h('title', 'Hello'),
1110 |                 h('p', 'World'),
1111 |                 s('svg', {viewBox: [0, 0, 10, 10]}, [
1112 |                   s('circle', {cx: 10, cy: 10, r: 10})
1113 |                 ])
1114 |               ])
1115 |             ])
1116 |           ),
1117 |           [
1118 |             h('html', [
1119 |               h('title', 'Hello'),
1120 |               h('p', 'World'),
1121 |               s('svg', {viewBox: [0, 0, 10, 10]}, [
1122 |                 s('circle', {cx: 10, cy: 10, r: 10})
1123 |               ])
1124 |             ])
1125 |           ]
1126 |         )
1127 |       }
1128 |     )
1129 |   })
1130 | 
1131 |   await t.test(':scope', async function (t) {
1132 |     await t.test(
1133 |       'should select the elements directly in `root`, if a `root` is given',
1134 |       async function () {
1135 |         assert.deepEqual(
1136 |           selectAll(
1137 |             ':scope',
1138 |             u('root', [h('strong', h('b', 'a')), h('em', h('i', 'b'))])
1139 |           ),
1140 |           [h('strong', h('b', 'a')), h('em', h('i', 'b'))]
1141 |         )
1142 |       }
1143 |     )
1144 | 
1145 |     await t.test(
1146 |       'should select the root element if one is given',
1147 |       async function () {
1148 |         assert.deepEqual(selectAll(':scope', h('em', h('i', 'b'))), [
1149 |           h('em', h('i', 'b'))
1150 |         ])
1151 |       }
1152 |     )
1153 |   })
1154 | 
1155 |   await t.test(':is', async function (t) {
1156 |     await t.test('should support parent-sensitive `:is`', async function () {
1157 |       assert.deepEqual(
1158 |         selectAll('y:is(:first-child)', h('x', [h('y#a'), h('y#b')])),
1159 |         [h('y#a')]
1160 |       )
1161 |     })
1162 |   })
1163 | 
1164 |   await t.test(':not', async function (t) {
1165 |     await t.test('should support parent-sensitive `:not`', async function () {
1166 |       assert.deepEqual(
1167 |         selectAll('y:not(:first-child)', h('x', [h('y#a'), h('y#b')])),
1168 |         [h('y#b')]
1169 |       )
1170 |     })
1171 |   })
1172 | })
1173 | 


--------------------------------------------------------------------------------
/test/matches.js:
--------------------------------------------------------------------------------
   1 | import assert from 'node:assert/strict'
   2 | import test from 'node:test'
   3 | import {h, s} from 'hastscript'
   4 | import {matches} from 'hast-util-select'
   5 | import {u} from 'unist-builder'
   6 | 
   7 | test('select.matches()', async function (t) {
   8 |   await t.test('invalid selector', async function (t) {
   9 |     await t.test('should throw without selector', async function () {
  10 |       assert.throws(function () {
  11 |         // @ts-expect-error: check how the runtime handles a missing `selector`.
  12 |         matches()
  13 |       }, /Error: Expected `string` as selector, not `undefined`/)
  14 |     })
  15 | 
  16 |     await t.test('should throw w/ invalid selector (1)', async function () {
  17 |       assert.throws(function () {
  18 |         // @ts-expect-error: check how the runtime handles an incorrect `selector`.
  19 |         matches([], h(''))
  20 |       }, /Error: Expected `string` as selector, not ``/)
  21 |     })
  22 | 
  23 |     await t.test('should throw w/ invalid selector (2)', async function () {
  24 |       assert.throws(function () {
  25 |         matches('@supports (transform-origin: 5% 5%) {}', h(''))
  26 |       }, /Expected rule but "@" found/)
  27 |     })
  28 | 
  29 |     await t.test(
  30 |       'should throw on invalid attribute operators',
  31 |       async function () {
  32 |         assert.throws(function () {
  33 |           matches('[foo%=bar]', h(''))
  34 |         }, /Expected a valid attribute selector operator/)
  35 |       }
  36 |     )
  37 | 
  38 |     await t.test('should throw on invalid pseudo classes', async function () {
  39 |       assert.throws(function () {
  40 |         matches(':active', h(''))
  41 |       }, /Error: Unknown pseudo-selector `active`/)
  42 |     })
  43 | 
  44 |     await t.test(
  45 |       'should throw on invalid pseudo class “functions”',
  46 |       async function () {
  47 |         assert.throws(function () {
  48 |           matches(':nth-foo(2n+1)', h(''))
  49 |         }, /Unknown pseudo-class/)
  50 |       }
  51 |     )
  52 | 
  53 |     await t.test('should throw on invalid pseudo elements', async function () {
  54 |       assert.throws(function () {
  55 |         matches('::before', h(''))
  56 |       }, /Invalid selector: `::before`/)
  57 |     })
  58 | 
  59 |     await t.test(
  60 |       'should throw on nested selectors (descendant)',
  61 |       async function () {
  62 |         assert.throws(function () {
  63 |           matches('foo bar', h(''))
  64 |         }, /Error: Expected selector without nesting/)
  65 |       }
  66 |     )
  67 | 
  68 |     await t.test(
  69 |       'should throw on nested selectors (direct child)',
  70 |       async function () {
  71 |         assert.throws(function () {
  72 |           matches('foo > bar', h(''))
  73 |         }, /Error: Expected selector without nesting/)
  74 |       }
  75 |     )
  76 |   })
  77 | 
  78 |   await t.test('parent-sensitive pseudo-selectors', async function (t) {
  79 |     const simplePseudos = [
  80 |       'first-child',
  81 |       'first-of-type',
  82 |       'last-child',
  83 |       'last-of-type',
  84 |       'only-child',
  85 |       'only-of-type'
  86 |     ]
  87 |     const functionalPseudos = [
  88 |       'nth-child',
  89 |       'nth-last-child',
  90 |       'nth-of-type',
  91 |       'nth-last-of-type'
  92 |     ]
  93 |     let index = -1
  94 | 
  95 |     while (++index < simplePseudos.length) {
  96 |       const pseudo = simplePseudos[index]
  97 | 
  98 |       await t.test('should throw on `' + pseudo + '`', async function () {
  99 |         assert.throws(
 100 |           function () {
 101 |             matches(':' + pseudo, h(''))
 102 |           },
 103 |           new RegExp('Error: Cannot use `:' + pseudo + '` without parent')
 104 |         )
 105 |       })
 106 |     }
 107 | 
 108 |     index = -1
 109 | 
 110 |     while (++index < functionalPseudos.length) {
 111 |       const pseudo = functionalPseudos[index]
 112 | 
 113 |       await t.test('should throw on `' + pseudo + '()`', async function () {
 114 |         assert.throws(function () {
 115 |           matches(':' + pseudo + '()', h(''))
 116 |         }, /Formula parse error/)
 117 |       })
 118 |     }
 119 |   })
 120 | 
 121 |   await t.test('general', async function (t) {
 122 |     await t.test('should throw on empty selectors', async function () {
 123 |       assert.throws(function () {
 124 |         matches('', h())
 125 |       }, /Expected rule but end of input reached/)
 126 |     })
 127 | 
 128 |     await t.test(
 129 |       'should throw for a white-space only selector',
 130 |       async function () {
 131 |         assert.throws(function () {
 132 |           matches(' ', h())
 133 |         }, /Expected rule but end of input reached/)
 134 |       }
 135 |     )
 136 | 
 137 |     await t.test('should not match w/o a node', async function () {
 138 |       assert.ok(!matches('*'))
 139 |     })
 140 | 
 141 |     await t.test('should not match w/ non-element', async function () {
 142 |       assert.ok(!matches('*', {type: 'text', value: 'a'}))
 143 |     })
 144 |   })
 145 | 
 146 |   await t.test('multiple selectors', async function (t) {
 147 |     await t.test('should match if one selector matches', async function () {
 148 |       assert.ok(matches('b, i', h('b')))
 149 |     })
 150 | 
 151 |     await t.test('should not match if no selector matches', async function () {
 152 |       assert.ok(!matches('i, s', h('b')))
 153 |     })
 154 |   })
 155 | 
 156 |   await t.test('tag-names: `div`, `*`', async function (t) {
 157 |     await t.test('should match the wildcard `*`', async function () {
 158 |       assert.ok(matches('*', h('')))
 159 |     })
 160 | 
 161 |     await t.test('should match a tag name', async function () {
 162 |       assert.ok(matches('b', h('b')))
 163 |     })
 164 | 
 165 |     await t.test(
 166 |       'should not match if the tag names doesn’t',
 167 |       async function () {
 168 |         assert.ok(!matches('b', h('i')))
 169 |       }
 170 |     )
 171 |   })
 172 | 
 173 |   await t.test('id: `#id`', async function (t) {
 174 |     await t.test('should not match if no id exists', async function () {
 175 |       assert.ok(!matches('#one', h('')))
 176 |     })
 177 | 
 178 |     await t.test('should match for matchesing id’s', async function () {
 179 |       assert.ok(matches('#one', h('#one')))
 180 |     })
 181 | 
 182 |     await t.test('should not match for mismatchesed id’s', async function () {
 183 |       assert.ok(!matches('#two', h('#one')))
 184 |     })
 185 | 
 186 |     await t.test('should never match multiple ids (#1)', async function () {
 187 |       assert.ok(!matches('#a#x', h('#a')))
 188 |     })
 189 | 
 190 |     await t.test('should never match multiple ids (#2)', async function () {
 191 |       assert.ok(!matches('#a#x', h('#x')))
 192 |     })
 193 |   })
 194 | 
 195 |   await t.test('class: `.class`', async function (t) {
 196 |     await t.test('should not match if no class-name exists', async function () {
 197 |       assert.ok(!matches('.one', h('')))
 198 |     })
 199 | 
 200 |     await t.test('should match for matchesing class-name', async function () {
 201 |       assert.ok(matches('.one', h('.one')))
 202 |     })
 203 | 
 204 |     await t.test(
 205 |       'should match when matchesing in multiple class-name',
 206 |       async function () {
 207 |         assert.ok(matches('.one', h('.one.two')))
 208 |       }
 209 |     )
 210 | 
 211 |     await t.test(
 212 |       'should not match if not all class-names exist',
 213 |       async function () {
 214 |         assert.ok(!matches('.one.two', h('.one')))
 215 |       }
 216 |     )
 217 |   })
 218 | 
 219 |   await t.test('attributes, existence: `[attr]`', async function (t) {
 220 |     await t.test('should match if attribute exists', async function () {
 221 |       assert.ok(matches('[class]', h('.one')))
 222 |     })
 223 | 
 224 |     await t.test(
 225 |       'should not match if attribute does not exist',
 226 |       async function () {
 227 |         assert.ok(!matches('[for]', h('.one')))
 228 |       }
 229 |     )
 230 | 
 231 |     await t.test('should match if attribute exists (2)', async function () {
 232 |       assert.ok(matches('[accesskey]', h('div', {accessKey: ['a']})))
 233 |     })
 234 | 
 235 |     await t.test('should match if attribute exists (3)', async function () {
 236 |       assert.ok(matches('[data-foo]', h('div', {dataFoo: 'bar'})))
 237 |     })
 238 | 
 239 |     await t.test(
 240 |       'should not match if attribute does not exist (2)',
 241 |       async function () {
 242 |         assert.ok(!matches('[data-bar]', h('div', {dataFoo: 'bar'})))
 243 |       }
 244 |     )
 245 |   })
 246 | 
 247 |   await t.test('attributes, equality: `[attr=value]`', async function (t) {
 248 |     await t.test(
 249 |       'should match if attribute matches (string value)',
 250 |       async function () {
 251 |         assert.ok(matches('[id=one]', h('#one')))
 252 |       }
 253 |     )
 254 | 
 255 |     await t.test(
 256 |       'should match if attribute matches (space-separated list, 1)',
 257 |       async function () {
 258 |         assert.ok(matches('[class=one]', h('.one')))
 259 |       }
 260 |     )
 261 | 
 262 |     await t.test(
 263 |       'should match if attribute matches (space-separated list, 2)',
 264 |       async function () {
 265 |         assert.ok(matches('[class="one two"]', h('.one.two')))
 266 |       }
 267 |     )
 268 | 
 269 |     await t.test(
 270 |       'should match if attribute matches (comma-separated list)',
 271 |       async function () {
 272 |         assert.ok(
 273 |           matches(
 274 |             '[accept="audio/*"]',
 275 |             h('input', {type: 'file', accept: ['audio/*']})
 276 |           )
 277 |         )
 278 |       }
 279 |     )
 280 | 
 281 |     await t.test(
 282 |       'should match if attribute matches (boolean)',
 283 |       async function () {
 284 |         assert.ok(matches('[hidden=hidden]', h('div', {hidden: true})))
 285 |       }
 286 |     )
 287 | 
 288 |     await t.test(
 289 |       'should match if attribute matches (overloaded boolean, 1)',
 290 |       async function () {
 291 |         assert.ok(matches('[download=download]', h('a', {download: true})))
 292 |       }
 293 |     )
 294 | 
 295 |     await t.test(
 296 |       'should match if attribute matches (overloaded boolean, 2)',
 297 |       async function () {
 298 |         assert.ok(
 299 |           matches('[download="image.png"]', h('a', {download: 'image.png'}))
 300 |         )
 301 |       }
 302 |     )
 303 | 
 304 |     await t.test(
 305 |       'should match if attribute matches (numeric)',
 306 |       async function () {
 307 |         assert.ok(matches('[tabindex="-1"]', h('div', {tabIndex: -1})))
 308 |       }
 309 |     )
 310 | 
 311 |     await t.test(
 312 |       'should match if attribute matches (positive numeric)',
 313 |       async function () {
 314 |         assert.ok(matches('[minlength="3"]', h('input', {minLength: 3})))
 315 |       }
 316 |     )
 317 | 
 318 |     await t.test(
 319 |       'should not match if attribute does not matches (string value)',
 320 |       async function () {
 321 |         assert.ok(!matches('[id="two"]', h('#one')))
 322 |       }
 323 |     )
 324 | 
 325 |     await t.test(
 326 |       'should not match if attribute does not matches (space-separated list, 1)',
 327 |       async function () {
 328 |         assert.ok(!matches('[class=two]', h('.one')))
 329 |       }
 330 |     )
 331 | 
 332 |     await t.test(
 333 |       'should not match if attribute does not matches (space-separated list, 2)',
 334 |       async function () {
 335 |         assert.ok(!matches('[class="three four"]', h('.one.two')))
 336 |       }
 337 |     )
 338 | 
 339 |     await t.test(
 340 |       'should not match if attribute does not matches (comma-separated list)',
 341 |       async function () {
 342 |         assert.ok(
 343 |           !matches(
 344 |             '[accept="image/*"]',
 345 |             h('input', {type: 'file', accept: ['audio/*']})
 346 |           )
 347 |         )
 348 |       }
 349 |     )
 350 | 
 351 |     await t.test(
 352 |       'should not match if attribute does not matches (boolean)',
 353 |       async function () {
 354 |         assert.ok(!matches('[hidden=hidden]', h('div', {hidden: false})))
 355 |       }
 356 |     )
 357 | 
 358 |     await t.test(
 359 |       'should not match if attribute does not matches (overloaded boolean, 1)',
 360 |       async function () {
 361 |         assert.ok(!matches('[download=download]', h('a', {download: false})))
 362 |       }
 363 |     )
 364 | 
 365 |     await t.test(
 366 |       'should not match if attribute does not matches (overloaded boolean, 2)',
 367 |       async function () {
 368 |         assert.ok(
 369 |           !matches('[download="image.png"]', h('a', {download: 'photo.png'}))
 370 |         )
 371 |       }
 372 |     )
 373 | 
 374 |     await t.test(
 375 |       'should not match if attribute does not matches (numeric)',
 376 |       async function () {
 377 |         assert.ok(!matches('[tabindex="-1"]', h('div', {tabIndex: -2})))
 378 |       }
 379 |     )
 380 | 
 381 |     await t.test(
 382 |       'should not match if attribute does not matches (positive numeric)',
 383 |       async function () {
 384 |         assert.ok(!matches('[minlength="3"]', h('input', {minLength: 2})))
 385 |       }
 386 |     )
 387 |   })
 388 | 
 389 |   await t.test('attributes, begins: `[attr^=value]`', async function (t) {
 390 |     await t.test(
 391 |       'should match if attribute matches (string value)',
 392 |       async function () {
 393 |         assert.ok(matches('[id^=one]', h('#one')))
 394 |       }
 395 |     )
 396 | 
 397 |     await t.test(
 398 |       'should match if attribute starts with (string value)',
 399 |       async function () {
 400 |         assert.ok(matches('[id^=on]', h('#one')))
 401 |       }
 402 |     )
 403 | 
 404 |     await t.test(
 405 |       'should match if attribute starts with (space-separated list)',
 406 |       async function () {
 407 |         assert.ok(matches('[class^=one]', h('.one.two')))
 408 |       }
 409 |     )
 410 | 
 411 |     await t.test(
 412 |       'should match if attribute starts with (comma-separated list)',
 413 |       async function () {
 414 |         assert.ok(
 415 |           matches(
 416 |             '[accept^=audio]',
 417 |             h('input', {type: 'file', accept: ['audio/*']})
 418 |           )
 419 |         )
 420 |       }
 421 |     )
 422 | 
 423 |     await t.test(
 424 |       'should match if attribute starts with (boolean)',
 425 |       async function () {
 426 |         assert.ok(matches('[hidden^=hid]', h('div', {hidden: true})))
 427 |       }
 428 |     )
 429 | 
 430 |     await t.test(
 431 |       'should match if attribute starts with (overloaded boolean)',
 432 |       async function () {
 433 |         assert.ok(matches('[download^=down]', h('a', {download: true})))
 434 |       }
 435 |     )
 436 | 
 437 |     await t.test(
 438 |       'should match if attribute starts with (overloaded boolean, 2)',
 439 |       async function () {
 440 |         assert.ok(matches('[download^=ima]', h('a', {download: 'image.png'})))
 441 |       }
 442 |     )
 443 | 
 444 |     await t.test(
 445 |       'should match if attribute starts with (numeric)',
 446 |       async function () {
 447 |         assert.ok(matches('[tabindex^="-"]', h('div', {tabIndex: -1})))
 448 |       }
 449 |     )
 450 | 
 451 |     await t.test(
 452 |       'should match if attribute starts with (positive numeric)',
 453 |       async function () {
 454 |         assert.ok(matches('[minlength^="1"]', h('input', {minLength: 10})))
 455 |       }
 456 |     )
 457 | 
 458 |     await t.test(
 459 |       'should not match if attribute does not start with (string value)',
 460 |       async function () {
 461 |         assert.ok(!matches('[id^=t]', h('#one')))
 462 |       }
 463 |     )
 464 | 
 465 |     await t.test(
 466 |       'should not match if attribute does not start with (space-separated list)',
 467 |       async function () {
 468 |         assert.ok(!matches('[class^=t]', h('.one')))
 469 |       }
 470 |     )
 471 | 
 472 |     await t.test(
 473 |       'should not match if attribute does not start with (comma-separated list)',
 474 |       async function () {
 475 |         assert.ok(
 476 |           !matches(
 477 |             '[accept^=video]',
 478 |             h('input', {type: 'file', accept: ['audio/*']})
 479 |           )
 480 |         )
 481 |       }
 482 |     )
 483 | 
 484 |     await t.test(
 485 |       'should not match if attribute does not start with (boolean)',
 486 |       async function () {
 487 |         assert.ok(!matches('[hidden^=hid]', h('div', {hidden: false})))
 488 |       }
 489 |     )
 490 | 
 491 |     await t.test(
 492 |       'should not match if attribute does not start with (overloaded boolean, 1)',
 493 |       async function () {
 494 |         assert.ok(!matches('[download^=down]', h('a', {download: false})))
 495 |       }
 496 |     )
 497 | 
 498 |     await t.test(
 499 |       'should not match if attribute does not start with (overloaded boolean, 2)',
 500 |       async function () {
 501 |         assert.ok(
 502 |           !matches('[download^=image]', h('a', {download: 'photo.png'}))
 503 |         )
 504 |       }
 505 |     )
 506 | 
 507 |     await t.test(
 508 |       'should not match if attribute does not start with (numeric)',
 509 |       async function () {
 510 |         assert.ok(!matches('[tabindex^="-"]', h('div', {tabIndex: 2})))
 511 |       }
 512 |     )
 513 | 
 514 |     await t.test(
 515 |       'should not match if attribute does not start with (positive numeric)',
 516 |       async function () {
 517 |         assert.ok(!matches('[minlength^="1"]', h('input', {minLength: 2})))
 518 |       }
 519 |     )
 520 |   })
 521 | 
 522 |   await t.test('attributes, ends: `[attr$=value]`', async function (t) {
 523 |     await t.test(
 524 |       'should match if attribute matches (string value)',
 525 |       async function () {
 526 |         assert.ok(matches('[id$=one]', h('#one')))
 527 |       }
 528 |     )
 529 | 
 530 |     await t.test(
 531 |       'should match if attribute ends with (string value)',
 532 |       async function () {
 533 |         assert.ok(matches('[id$=ne]', h('#one')))
 534 |       }
 535 |     )
 536 | 
 537 |     await t.test(
 538 |       'should match if attribute ends with (space-separated list)',
 539 |       async function () {
 540 |         assert.ok(matches('[class$=wo]', h('.one.two')))
 541 |       }
 542 |     )
 543 | 
 544 |     await t.test(
 545 |       'should match if attribute ends with (comma-separated list)',
 546 |       async function () {
 547 |         assert.ok(
 548 |           matches(
 549 |             '[accept$="*"]',
 550 |             h('input', {type: 'file', accept: ['audio/*']})
 551 |           )
 552 |         )
 553 |       }
 554 |     )
 555 | 
 556 |     await t.test(
 557 |       'should match if attribute ends with (boolean)',
 558 |       async function () {
 559 |         assert.ok(matches('[hidden$=den]', h('div', {hidden: true})))
 560 |       }
 561 |     )
 562 | 
 563 |     await t.test(
 564 |       'should match if attribute ends with (overloaded boolean)',
 565 |       async function () {
 566 |         assert.ok(matches('[download$=load]', h('a', {download: true})))
 567 |       }
 568 |     )
 569 | 
 570 |     await t.test(
 571 |       'should match if attribute ends with (overloaded boolean, 2)',
 572 |       async function () {
 573 |         assert.ok(matches('[download$=png]', h('a', {download: 'image.png'})))
 574 |       }
 575 |     )
 576 | 
 577 |     await t.test(
 578 |       'should match if attribute ends with (numeric)',
 579 |       async function () {
 580 |         assert.ok(matches('[tabindex$="1"]', h('div', {tabIndex: -1})))
 581 |       }
 582 |     )
 583 | 
 584 |     await t.test(
 585 |       'should match if attribute ends with (positive numeric)',
 586 |       async function () {
 587 |         assert.ok(matches('[minlength$="0"]', h('input', {minLength: 10})))
 588 |       }
 589 |     )
 590 | 
 591 |     await t.test(
 592 |       'should not match if attribute does not end with (string value)',
 593 |       async function () {
 594 |         assert.ok(!matches('[id$=wo]', h('#one')))
 595 |       }
 596 |     )
 597 | 
 598 |     await t.test(
 599 |       'should not match if attribute does not end with (space-separated list)',
 600 |       async function () {
 601 |         assert.ok(!matches('[class$=wo]', h('.one')))
 602 |       }
 603 |     )
 604 | 
 605 |     await t.test(
 606 |       'should not match if attribute does not end with (comma-separated list)',
 607 |       async function () {
 608 |         assert.ok(
 609 |           !matches(
 610 |             '[accept$=doc]',
 611 |             h('input', {type: 'file', accept: ['audio/*']})
 612 |           )
 613 |         )
 614 |       }
 615 |     )
 616 | 
 617 |     await t.test(
 618 |       'should not match if attribute does not end with (boolean)',
 619 |       async function () {
 620 |         assert.ok(!matches('[hidden$=den]', h('div', {hidden: false})))
 621 |       }
 622 |     )
 623 | 
 624 |     await t.test(
 625 |       'should not match if attribute does not end with (overloaded boolean, 1)',
 626 |       async function () {
 627 |         assert.ok(!matches('[download$=load]', h('a', {download: false})))
 628 |       }
 629 |     )
 630 | 
 631 |     await t.test(
 632 |       'should not match if attribute does not end with (overloaded boolean, 2)',
 633 |       async function () {
 634 |         assert.ok(!matches('[download$=jpg]', h('a', {download: 'photo.png'})))
 635 |       }
 636 |     )
 637 | 
 638 |     await t.test(
 639 |       'should not match if attribute does not end with (numeric)',
 640 |       async function () {
 641 |         assert.ok(!matches('[tabindex$="2"]', h('div', {tabIndex: -1})))
 642 |       }
 643 |     )
 644 | 
 645 |     await t.test(
 646 |       'should not match if attribute does not start with (positive numeric)',
 647 |       async function () {
 648 |         assert.ok(!matches('[minlength$="1"]', h('input', {minLength: 2})))
 649 |       }
 650 |     )
 651 |   })
 652 | 
 653 |   await t.test('attributes, contains: `[attr*=value]`', async function (t) {
 654 |     await t.test(
 655 |       'should match if attribute matches (string value)',
 656 |       async function () {
 657 |         assert.ok(matches('[id*=one]', h('#one')))
 658 |       }
 659 |     )
 660 | 
 661 |     await t.test(
 662 |       'should match if attribute contains (string value)',
 663 |       async function () {
 664 |         assert.ok(matches('[id*=n]', h('#one')))
 665 |       }
 666 |     )
 667 | 
 668 |     await t.test(
 669 |       'should match if attribute contains (space-separated list)',
 670 |       async function () {
 671 |         assert.ok(matches('[class*=w]', h('.one.two')))
 672 |       }
 673 |     )
 674 | 
 675 |     await t.test(
 676 |       'should match if attribute contains (comma-separated list)',
 677 |       async function () {
 678 |         assert.ok(
 679 |           matches(
 680 |             '[accept*="audio/*"]',
 681 |             h('input', {type: 'file', accept: ['audio/*']})
 682 |           )
 683 |         )
 684 |       }
 685 |     )
 686 | 
 687 |     await t.test(
 688 |       'should match if attribute contains (boolean)',
 689 |       async function () {
 690 |         assert.ok(matches('[hidden*=dd]', h('div', {hidden: true})))
 691 |       }
 692 |     )
 693 | 
 694 |     await t.test(
 695 |       'should match if attribute contains (overloaded boolean)',
 696 |       async function () {
 697 |         assert.ok(matches('[download*=nl]', h('a', {download: true})))
 698 |       }
 699 |     )
 700 | 
 701 |     await t.test(
 702 |       'should match if attribute contains (overloaded boolean, 2)',
 703 |       async function () {
 704 |         assert.ok(matches('[download*=age]', h('a', {download: 'image.png'})))
 705 |       }
 706 |     )
 707 | 
 708 |     await t.test(
 709 |       'should match if attribute contains (numeric)',
 710 |       async function () {
 711 |         assert.ok(matches('[tabindex*="1"]', h('div', {tabIndex: -12})))
 712 |       }
 713 |     )
 714 | 
 715 |     await t.test(
 716 |       'should match if attribute contains (positive numeric)',
 717 |       async function () {
 718 |         assert.ok(matches('[minlength*="0"]', h('input', {minLength: 102})))
 719 |       }
 720 |     )
 721 | 
 722 |     await t.test(
 723 |       'should not match if attribute does not contain (string value)',
 724 |       async function () {
 725 |         assert.ok(!matches('[id*=w]', h('#one')))
 726 |       }
 727 |     )
 728 | 
 729 |     await t.test(
 730 |       'should not match if attribute does not contain (space-separated list)',
 731 |       async function () {
 732 |         assert.ok(!matches('[class*=w]', h('.one')))
 733 |       }
 734 |     )
 735 | 
 736 |     await t.test(
 737 |       'should not match if attribute does not contain (comma-separated list)',
 738 |       async function () {
 739 |         assert.ok(
 740 |           !matches(
 741 |             '[accept*="video/*"]',
 742 |             h('input', {type: 'file', accept: ['audio/*']})
 743 |           )
 744 |         )
 745 |       }
 746 |     )
 747 | 
 748 |     await t.test(
 749 |       'should not match if attribute does not contain (boolean)',
 750 |       async function () {
 751 |         assert.ok(!matches('[hidden*=dd]', h('div', {hidden: false})))
 752 |       }
 753 |     )
 754 | 
 755 |     await t.test(
 756 |       'should not match if attribute does not contain (overloaded boolean, 1)',
 757 |       async function () {
 758 |         assert.ok(!matches('[download*=nl]', h('a', {download: false})))
 759 |       }
 760 |     )
 761 | 
 762 |     await t.test(
 763 |       'should not match if attribute does not contain (overloaded boolean, 2)',
 764 |       async function () {
 765 |         assert.ok(!matches('[download*=age]', h('a', {download: 'photo.png'})))
 766 |       }
 767 |     )
 768 | 
 769 |     await t.test(
 770 |       'should not match if attribute does not contain (numeric)',
 771 |       async function () {
 772 |         assert.ok(!matches('[tabindex*="3"]', h('div', {tabIndex: -12})))
 773 |       }
 774 |     )
 775 | 
 776 |     await t.test(
 777 |       'should not match if attribute does not contain (positive numeric)',
 778 |       async function () {
 779 |         assert.ok(!matches('[minlength*="3"]', h('input', {minLength: 102})))
 780 |       }
 781 |     )
 782 |   })
 783 | 
 784 |   await t.test(
 785 |     'attributes, contains in space-separated list: `[attr~=value]`',
 786 |     async function (t) {
 787 |       await t.test(
 788 |         'should match if attribute matches (string value)',
 789 |         async function () {
 790 |           assert.ok(matches('[id~=one]', h('#one')))
 791 |         }
 792 |       )
 793 | 
 794 |       await t.test(
 795 |         'should match if attribute matches (space-separated list, 1)',
 796 |         async function () {
 797 |           assert.ok(matches('[class~=one]', h('.one')))
 798 |         }
 799 |       )
 800 | 
 801 |       await t.test(
 802 |         'should match if attribute matches (space-separated list, 2)',
 803 |         async function () {
 804 |           assert.ok(matches('[class~="one two"]', h('.one.two')))
 805 |         }
 806 |       )
 807 | 
 808 |       await t.test(
 809 |         'should match if attribute matches (comma-separated list)',
 810 |         async function () {
 811 |           assert.ok(
 812 |             matches(
 813 |               '[accept~="audio/*"]',
 814 |               h('input', {type: 'file', accept: ['audio/*']})
 815 |             )
 816 |           )
 817 |         }
 818 |       )
 819 | 
 820 |       await t.test(
 821 |         'should match if attribute matches (boolean)',
 822 |         async function () {
 823 |           assert.ok(matches('[hidden~=hidden]', h('div', {hidden: true})))
 824 |         }
 825 |       )
 826 | 
 827 |       await t.test(
 828 |         'should match if attribute matches (overloaded boolean, 1)',
 829 |         async function () {
 830 |           assert.ok(matches('[download~=download]', h('a', {download: true})))
 831 |         }
 832 |       )
 833 | 
 834 |       await t.test(
 835 |         'should match if attribute matches (overloaded boolean, 2)',
 836 |         async function () {
 837 |           assert.ok(
 838 |             matches('[download~="image.png"]', h('a', {download: 'image.png'}))
 839 |           )
 840 |         }
 841 |       )
 842 | 
 843 |       await t.test(
 844 |         'should match if attribute matches (numeric)',
 845 |         async function () {
 846 |           assert.ok(matches('[tabindex~="-1"]', h('div', {tabIndex: -1})))
 847 |         }
 848 |       )
 849 | 
 850 |       await t.test(
 851 |         'should match if attribute matches (positive numeric)',
 852 |         async function () {
 853 |           assert.ok(matches('[minlength~="3"]', h('input', {minLength: 3})))
 854 |         }
 855 |       )
 856 | 
 857 |       await t.test(
 858 |         'should not match if attribute does not matches (string value)',
 859 |         async function () {
 860 |           assert.ok(!matches('[id~=two]', h('#one')))
 861 |         }
 862 |       )
 863 | 
 864 |       await t.test(
 865 |         'should not match if attribute does not matches (space-separated list, 1)',
 866 |         async function () {
 867 |           assert.ok(!matches('[class~=two]', h('.one')))
 868 |         }
 869 |       )
 870 | 
 871 |       await t.test(
 872 |         'should not match if attribute does not matches (space-separated list, 2)',
 873 |         async function () {
 874 |           assert.ok(!matches('[class~="three four"]', h('.one.two')))
 875 |         }
 876 |       )
 877 | 
 878 |       await t.test(
 879 |         'should not match if attribute does not matches (comma-separated list)',
 880 |         async function () {
 881 |           assert.ok(
 882 |             !matches(
 883 |               '[accept~="video/*"]',
 884 |               h('input', {type: 'file', accept: ['audio/*']})
 885 |             )
 886 |           )
 887 |         }
 888 |       )
 889 | 
 890 |       await t.test(
 891 |         'should not match if attribute does not matches (boolean)',
 892 |         async function () {
 893 |           assert.ok(!matches('[hidden~=hidden]', h('div', {hidden: false})))
 894 |         }
 895 |       )
 896 | 
 897 |       await t.test(
 898 |         'should not match if attribute does not matches (overloaded boolean, 1)',
 899 |         async function () {
 900 |           assert.ok(!matches('[download~=download]', h('a', {download: false})))
 901 |         }
 902 |       )
 903 | 
 904 |       await t.test(
 905 |         'should not match if attribute does not matches (overloaded boolean, 2)',
 906 |         async function () {
 907 |           assert.ok(
 908 |             !matches('[download~="image.png"]', h('a', {download: 'photo.png'}))
 909 |           )
 910 |         }
 911 |       )
 912 | 
 913 |       await t.test(
 914 |         'should not match if attribute does not matches (numeric)',
 915 |         async function () {
 916 |           assert.ok(!matches('[tabindex~="-1"]', h('div', {tabIndex: -2})))
 917 |         }
 918 |       )
 919 | 
 920 |       await t.test(
 921 |         'should not match if attribute does not matches (positive numeric)',
 922 |         async function () {
 923 |           assert.ok(!matches('[minlength~="3"]', h('input', {minLength: 2})))
 924 |         }
 925 |       )
 926 | 
 927 |       await t.test(
 928 |         'should match if attribute part exists (space-separated list, 1)',
 929 |         async function () {
 930 |           assert.ok(matches('[class~=one]', h('.one.two')))
 931 |         }
 932 |       )
 933 | 
 934 |       await t.test(
 935 |         'should match if attribute part exists (space-separated list, 2)',
 936 |         async function () {
 937 |           assert.ok(matches('[class~=two]', h('.one.two')))
 938 |         }
 939 |       )
 940 | 
 941 |       await t.test(
 942 |         'should not match if attribute part does not exist (space-separated list)',
 943 |         async function () {
 944 |           assert.ok(!matches('[class~=three]', h('.one.two')))
 945 |         }
 946 |       )
 947 |     }
 948 |   )
 949 | 
 950 |   await t.test(
 951 |     'attributes, starts or prefixes: `[attr|=value]`',
 952 |     async function (t) {
 953 |       await t.test(
 954 |         'should match if attribute matches (string value)',
 955 |         async function () {
 956 |           assert.ok(matches('[id|=one]', h('#one')))
 957 |         }
 958 |       )
 959 | 
 960 |       await t.test(
 961 |         'should match if attribute matches (space-separated list, 1)',
 962 |         async function () {
 963 |           assert.ok(matches('[class|=one]', h('.one')))
 964 |         }
 965 |       )
 966 | 
 967 |       await t.test(
 968 |         'should match if attribute matches (space-separated list, 2)',
 969 |         async function () {
 970 |           assert.ok(matches('[class|="one two"]', h('.one.two')))
 971 |         }
 972 |       )
 973 | 
 974 |       await t.test(
 975 |         'should match if attribute matches (comma-separated list)',
 976 |         async function () {
 977 |           assert.ok(
 978 |             matches(
 979 |               '[accept|="audio/*"]',
 980 |               h('input', {type: 'file', accept: ['audio/*']})
 981 |             )
 982 |           )
 983 |         }
 984 |       )
 985 | 
 986 |       await t.test(
 987 |         'should match if attribute matches (boolean)',
 988 |         async function () {
 989 |           assert.ok(matches('[hidden|=hidden]', h('div', {hidden: true})))
 990 |         }
 991 |       )
 992 | 
 993 |       await t.test(
 994 |         'should match if attribute matches (overloaded boolean, 1)',
 995 |         async function () {
 996 |           assert.ok(matches('[download|=download]', h('a', {download: true})))
 997 |         }
 998 |       )
 999 | 
1000 |       await t.test(
1001 |         'should match if attribute matches (overloaded boolean, 2)',
1002 |         async function () {
1003 |           assert.ok(
1004 |             matches('[download|="image.png"]', h('a', {download: 'image.png'}))
1005 |           )
1006 |         }
1007 |       )
1008 | 
1009 |       await t.test(
1010 |         'should match if attribute matches (numeric)',
1011 |         async function () {
1012 |           assert.ok(matches('[tabindex|="-1"]', h('div', {tabIndex: -1})))
1013 |         }
1014 |       )
1015 | 
1016 |       await t.test(
1017 |         'should match if attribute matches (positive numeric)',
1018 |         async function () {
1019 |           assert.ok(matches('[minlength|="3"]', h('input', {minLength: 3})))
1020 |         }
1021 |       )
1022 | 
1023 |       await t.test(
1024 |         'should not match if attribute does not matches (string value)',
1025 |         async function () {
1026 |           assert.ok(!matches('[id|=two]', h('#one')))
1027 |         }
1028 |       )
1029 | 
1030 |       await t.test(
1031 |         'should not match if attribute does not matches (space-separated list, 1)',
1032 |         async function () {
1033 |           assert.ok(!matches('[class|=two]', h('.one')))
1034 |         }
1035 |       )
1036 | 
1037 |       await t.test(
1038 |         'should not match if attribute does not matches (space-separated list, 2)',
1039 |         async function () {
1040 |           assert.ok(!matches('[class|="three four"]', h('.one.two')))
1041 |         }
1042 |       )
1043 | 
1044 |       await t.test(
1045 |         'should not match if attribute does not matches (comma-separated list)',
1046 |         async function () {
1047 |           assert.ok(
1048 |             !matches(
1049 |               '[accept|="video/*"]',
1050 |               h('input', {type: 'file', accept: ['audio/*']})
1051 |             )
1052 |           )
1053 |         }
1054 |       )
1055 | 
1056 |       await t.test(
1057 |         'should not match if attribute does not matches (boolean)',
1058 |         async function () {
1059 |           assert.ok(!matches('[hidden|=hidden]', h('div', {hidden: false})))
1060 |         }
1061 |       )
1062 | 
1063 |       await t.test(
1064 |         'should not match if attribute does not matches (overloaded boolean, 1)',
1065 |         async function () {
1066 |           assert.ok(!matches('[download|=download]', h('a', {download: false})))
1067 |         }
1068 |       )
1069 | 
1070 |       await t.test(
1071 |         'should not match if attribute does not matches (overloaded boolean, 2)',
1072 |         async function () {
1073 |           assert.ok(
1074 |             !matches('[download|="image.png"]', h('a', {download: 'photo.png'}))
1075 |           )
1076 |         }
1077 |       )
1078 | 
1079 |       await t.test(
1080 |         'should not match if attribute does not matches (numeric)',
1081 |         async function () {
1082 |           assert.ok(!matches('[tabindex|="-1"]', h('div', {tabIndex: -2})))
1083 |         }
1084 |       )
1085 | 
1086 |       await t.test(
1087 |         'should not match if attribute does not matches (positive numeric)',
1088 |         async function () {
1089 |           assert.ok(!matches('[minlength|="3"]', h('input', {minLength: 2})))
1090 |         }
1091 |       )
1092 | 
1093 |       await t.test('should match if value starts with', async function () {
1094 |         assert.ok(matches('[alpha|=bravo]', h('div', {alpha: 'bravo'})))
1095 |       })
1096 | 
1097 |       await t.test('should match if value prefixes', async function () {
1098 |         assert.ok(matches('[alpha|=bravo]', h('div', {alpha: 'bravo-charlie'})))
1099 |       })
1100 | 
1101 |       await t.test(
1102 |         'should not match if value does not prefix',
1103 |         async function () {
1104 |           assert.ok(
1105 |             !matches('[alpha|=bravo]', h('div', {alpha: 'bravocharlie'}))
1106 |           )
1107 |         }
1108 |       )
1109 | 
1110 |       await t.test(
1111 |         'should not match if value does start with',
1112 |         async function () {
1113 |           assert.ok(!matches('[alpha|=charlie]', h('div', {alpha: 'bravo'})))
1114 |         }
1115 |       )
1116 |     }
1117 |   )
1118 | 
1119 |   await t.test('attributes, case modifiers `[attr i]`', async function (t) {
1120 |     await t.test(
1121 |       'should throw when using a modifier in a wrong place',
1122 |       async function () {
1123 |         assert.throws(function () {
1124 |           matches('[x y]', h('a'))
1125 |         }, /Expected a valid attribute selector operator/)
1126 |       }
1127 |     )
1128 | 
1129 |     await t.test(
1130 |       'should throw when using an unknown modifier',
1131 |       async function () {
1132 |         assert.throws(function () {
1133 |           matches('[x=y z]', h('a'))
1134 |         }, /Unknown attribute case sensitivity modifier/)
1135 |       }
1136 |     )
1137 | 
1138 |     await t.test(
1139 |       'should match sensitively (default) with `s` (#1)',
1140 |       async function () {
1141 |         assert.ok(matches('[x=y s]', h('a', {x: 'y'})))
1142 |       }
1143 |     )
1144 | 
1145 |     await t.test(
1146 |       'should match sensitively (default) with `s` (#2)',
1147 |       async function () {
1148 |         assert.ok(!matches('[x=y s]', h('a', {x: 'Y'})))
1149 |       }
1150 |     )
1151 | 
1152 |     await t.test('should match insensitively with `i` (#1)', async function () {
1153 |       assert.ok(matches('[x=y i]', h('a', {x: 'y'})))
1154 |     })
1155 | 
1156 |     await t.test('should match insensitively with `i` (#2)', async function () {
1157 |       assert.ok(matches('[x=y i]', h('a', {x: 'Y'})))
1158 |     })
1159 | 
1160 |     await t.test('should match insensitively with `i` (#3)', async function () {
1161 |       assert.ok(matches('[x=Y i]', h('a', {x: 'y'})))
1162 |     })
1163 | 
1164 |     await t.test('should match insensitively with `i` (#4)', async function () {
1165 |       assert.ok(matches('[x=Y i]', h('a', {x: 'Y'})))
1166 |     })
1167 |   })
1168 | 
1169 |   await t.test('pseudo-classes', async function (t) {
1170 |     await t.test(':is()', async function (t) {
1171 |       await t.test('should match if any matches (type)', async function () {
1172 |         assert.ok(matches(':is(a, [title], .class)', h('a')))
1173 |       })
1174 | 
1175 |       await t.test('should match if any matches (.class)', async function () {
1176 |         assert.ok(matches(':is(a, [title], .class)', h('.class')))
1177 |       })
1178 | 
1179 |       await t.test(
1180 |         'should match if any matches (attribute existence)',
1181 |         async function () {
1182 |           assert.ok(matches(':is(a, [title], .class)', h('div', {title: '1'})))
1183 |         }
1184 |       )
1185 | 
1186 |       await t.test('should not match if nothing matches', async function () {
1187 |         assert.ok(!matches(':is(a, [title], .class)', h('i')))
1188 |       })
1189 | 
1190 |       await t.test('should not match if children match', async function () {
1191 |         assert.ok(!matches(':is(a, [title], .class)', h('div', h('i.class'))))
1192 |       })
1193 |     })
1194 | 
1195 |     await t.test(':not()', async function (t) {
1196 |       await t.test('should not match if any matches (type)', async function () {
1197 |         assert.ok(!matches(':not(a, [title], .class)', h('a')))
1198 |       })
1199 | 
1200 |       await t.test(
1201 |         'should not match if any matches (.class)',
1202 |         async function () {
1203 |           assert.ok(!matches(':not(a, [title], .class)', h('.class')))
1204 |         }
1205 |       )
1206 | 
1207 |       await t.test(
1208 |         'should not match if any matches (attribute existence)',
1209 |         async function () {
1210 |           assert.ok(
1211 |             !matches(':not(a, [title], .class)', h('div', {title: '1'}))
1212 |           )
1213 |         }
1214 |       )
1215 | 
1216 |       await t.test('should match if nothing matches', async function () {
1217 |         assert.ok(matches(':not(a, [title], .class)', h('i')))
1218 |       })
1219 | 
1220 |       await t.test('should match if children match', async function () {
1221 |         assert.ok(matches(':not(a, [title], .class)', h('div', h('i.class'))))
1222 |       })
1223 |     })
1224 | 
1225 |     await t.test(':has', async function (t) {
1226 |       await t.test('should throw on empty selectors', async function () {
1227 |         assert.throws(function () {
1228 |           matches('a:not(:has())', h('p'))
1229 |         }, /Expected rule but "\)" found/)
1230 |       })
1231 | 
1232 |       await t.test('should throw on empty selectors', async function () {
1233 |         assert.throws(function () {
1234 |           matches('a:has()', h('p'))
1235 |         }, /Expected rule but "\)" found/)
1236 |       })
1237 | 
1238 |       await t.test(
1239 |         'should not match the scope element (#1)',
1240 |         async function () {
1241 |           assert.ok(!matches('p:has(p)', h('p', h('s'))))
1242 |         }
1243 |       )
1244 | 
1245 |       await t.test(
1246 |         'should not match the scope element (#2)',
1247 |         async function () {
1248 |           assert.ok(matches('p:has(p)', h('p', h('p'))))
1249 |         }
1250 |       )
1251 | 
1252 |       await t.test(
1253 |         'should match if children match the descendant selector',
1254 |         async function () {
1255 |           assert.ok(matches('a:has(img)', h('a', h('img'))))
1256 |         }
1257 |       )
1258 | 
1259 |       await t.test(
1260 |         'should not match if no children match the descendant selector',
1261 |         async function () {
1262 |           assert.ok(!matches('a:has(img)', h('a', h('span'))))
1263 |         }
1264 |       )
1265 | 
1266 |       await t.test(
1267 |         'should match if descendants match the descendant selector',
1268 |         async function () {
1269 |           assert.ok(matches('a:has(img)', h('a', h('span'), h('img'))))
1270 |         }
1271 |       )
1272 | 
1273 |       await t.test(
1274 |         'should not match if no descendants match the descendant selector',
1275 |         async function () {
1276 |           assert.ok(!matches('a:has(img)', h('a', h('span', h('span')))))
1277 |         }
1278 |       )
1279 | 
1280 |       await t.test(
1281 |         'should support a nested next-sibling selector (#1)',
1282 |         async function () {
1283 |           assert.ok(matches('dd:has(dt + dd)', h('dd', [h('dt'), h('dd')])))
1284 |         }
1285 |       )
1286 | 
1287 |       await t.test(
1288 |         'should support a nested next-sibling selector (#2)',
1289 |         async function () {
1290 |           assert.ok(!matches('dd:has(dt + dd)', h('dd', [h('dt'), h('dt')])))
1291 |         }
1292 |       )
1293 | 
1294 |       await t.test(
1295 |         'should add `:scope` to sub-selectors (#1)',
1296 |         async function () {
1297 |           assert.ok(matches('a:has([title])', h('a', h('s', {title: 'a'}))))
1298 |         }
1299 |       )
1300 | 
1301 |       await t.test(
1302 |         'should add `:scope` to sub-selectors (#2)',
1303 |         async function () {
1304 |           assert.ok(!matches('a:has([title])', h('a', {title: '!'}, h('s'))))
1305 |         }
1306 |       )
1307 | 
1308 |       await t.test(
1309 |         'should add `:scope` to all sub-selectors (#2)',
1310 |         async function () {
1311 |           assert.ok(!matches('a:has(a, :scope i)', h('a', h('s'))))
1312 |         }
1313 |       )
1314 | 
1315 |       await t.test(
1316 |         'should add `:scope` to all sub-selectors (#3)',
1317 |         async function () {
1318 |           assert.ok(
1319 |             matches(
1320 |               'section:not(:has(h1, h2, h3, h4, h5, h6))',
1321 |               h('section', [])
1322 |             )
1323 |           )
1324 |         }
1325 |       )
1326 | 
1327 |       await t.test(
1328 |         'should add `:scope` to all sub-selectors (#4)',
1329 |         async function () {
1330 |           assert.ok(
1331 |             matches(
1332 |               'section:not(:has(h1, h2, h3, h4, h5, h6))',
1333 |               h('section', [h('p', '!')])
1334 |             )
1335 |           )
1336 |         }
1337 |       )
1338 | 
1339 |       await t.test('should ignore commas in parens (#1)', async function () {
1340 |         assert.ok(
1341 |           !matches(
1342 |             'section:has(:lang(en, fr))',
1343 |             h('section', [h('q', {lang: 'de'})])
1344 |           )
1345 |         )
1346 |       })
1347 | 
1348 |       await t.test('should ignore commas in parens (#2)', async function () {
1349 |         assert.ok(
1350 |           matches(
1351 |             'section:has(:lang(en, fr))',
1352 |             h('section', [h('q', {lang: 'en'})])
1353 |           )
1354 |         )
1355 |       })
1356 | 
1357 |       await t.test(
1358 |         'should support multiple relative selectors (#1)',
1359 |         async function () {
1360 |           assert.ok(
1361 |             !matches('section:has(:is(i), :is(b))', h('section', [h('s')]))
1362 |           )
1363 |         }
1364 |       )
1365 | 
1366 |       await t.test(
1367 |         'should support multiple relative selectors (#2)',
1368 |         async function () {
1369 |           assert.ok(
1370 |             matches('section:has(:is(i), :is(b))', h('section', [h('b')]))
1371 |           )
1372 |         }
1373 |       )
1374 | 
1375 |       // These check white space.
1376 | 
1377 |       await t.test('should match w/o whitespace (#1)', async function () {
1378 |         assert.ok(matches('a:has( img)', h('a', h('img'))))
1379 |       })
1380 | 
1381 |       await t.test('should match w/o whitespace (#2)', async function () {
1382 |         assert.ok(matches('a:has( img  )', h('a', h('img'))))
1383 |       })
1384 | 
1385 |       await t.test('should match w/o whitespace (#3)', async function () {
1386 |         assert.ok(matches('a:has(img )', h('a', h('img'))))
1387 |       })
1388 | 
1389 |       await t.test('should match w/o whitespace (#4)', async function () {
1390 |         assert.ok(matches('a:has( img  ,\t p )', h('a', h('img'))))
1391 |       })
1392 | 
1393 |       await t.test(
1394 |         'should match for relative direct child selector',
1395 |         async function () {
1396 |           assert.ok(matches('a:has(> img)', h('a', h('img'))))
1397 |         }
1398 |       )
1399 | 
1400 |       await t.test(
1401 |         'should not match for relative direct child selectors',
1402 |         async function () {
1403 |           assert.ok(!matches('a:has(> img)', h('a', h('span', h('img')))))
1404 |         }
1405 |       )
1406 | 
1407 |       await t.test(
1408 |         'should support a list of relative selectors',
1409 |         async function () {
1410 |           assert.ok(
1411 |             matches('a:has(> img, > span)', h('a', h('span', h('span'))))
1412 |           )
1413 |         }
1414 |       )
1415 |     })
1416 | 
1417 |     await t.test(':any-link', async function (t) {
1418 |       const links = ['a', 'area', 'link']
1419 |       let index = -1
1420 | 
1421 |       while (++index < links.length) {
1422 |         const name = links[index]
1423 | 
1424 |         await t.test('should match if w/ href on ' + name, async function () {
1425 |           assert.ok(matches(':any-link', h(name, {href: '#'})))
1426 |         })
1427 | 
1428 |         await t.test(
1429 |           'should not match if w/o href on ' + name,
1430 |           async function () {
1431 |             assert.ok(!matches(':any-link', h(name)))
1432 |           }
1433 |         )
1434 |       }
1435 |     })
1436 | 
1437 |     await t.test(':checked', async function (t) {
1438 |       await t.test(
1439 |         'should match for checkbox inputs w/ `checked`',
1440 |         async function () {
1441 |           assert.ok(
1442 |             matches(':checked', h('input', {type: 'checkbox', checked: true}))
1443 |           )
1444 |         }
1445 |       )
1446 | 
1447 |       await t.test(
1448 |         'should match for radio inputs w/ `checked`',
1449 |         async function () {
1450 |           assert.ok(
1451 |             matches(':checked', h('input', {type: 'radio', checked: true}))
1452 |           )
1453 |         }
1454 |       )
1455 | 
1456 |       await t.test(
1457 |         'should match for checkbox menuitems w/ `checked`',
1458 |         async function () {
1459 |           assert.ok(
1460 |             matches(
1461 |               ':checked',
1462 |               h('menuitem', {type: 'checkbox', checked: true})
1463 |             )
1464 |           )
1465 |         }
1466 |       )
1467 | 
1468 |       await t.test(
1469 |         'should match for radio menuitems w/ `checked`',
1470 |         async function () {
1471 |           assert.ok(
1472 |             matches(':checked', h('menuitem', {type: 'radio', checked: true}))
1473 |           )
1474 |         }
1475 |       )
1476 | 
1477 |       await t.test('should match for options w/ `selected`', async function () {
1478 |         assert.ok(matches(':checked', h('option', {selected: true})))
1479 |       })
1480 | 
1481 |       await t.test(
1482 |         'should not match for checkbox inputs w/o `checked`',
1483 |         async function () {
1484 |           assert.ok(
1485 |             !matches(':checked', h('input', {type: 'checkbox', checked: false}))
1486 |           )
1487 |         }
1488 |       )
1489 | 
1490 |       await t.test(
1491 |         'should not match for radio inputs w/o `checked`',
1492 |         async function () {
1493 |           assert.ok(
1494 |             !matches(':checked', h('input', {type: 'radio', checked: false}))
1495 |           )
1496 |         }
1497 |       )
1498 | 
1499 |       await t.test(
1500 |         'should not match for checkbox menuitems w/o `checked`',
1501 |         async function () {
1502 |           assert.ok(
1503 |             !matches(
1504 |               ':checked',
1505 |               h('menuitem', {type: 'checkbox', checked: false})
1506 |             )
1507 |           )
1508 |         }
1509 |       )
1510 | 
1511 |       await t.test(
1512 |         'should not match for radio menuitems w/o `checked`',
1513 |         async function () {
1514 |           assert.ok(
1515 |             !matches(':checked', h('menuitem', {type: 'radio', checked: false}))
1516 |           )
1517 |         }
1518 |       )
1519 | 
1520 |       await t.test(
1521 |         'should not match for options w/o `selected`',
1522 |         async function () {
1523 |           assert.ok(!matches(':checked', h('option', {selected: false})))
1524 |         }
1525 |       )
1526 | 
1527 |       await t.test('should not match for other nodes', async function () {
1528 |         assert.ok(!matches(':checked', h('')))
1529 |       })
1530 |     })
1531 | 
1532 |     await t.test(':disabled', async function (t) {
1533 |       const things = [
1534 |         'button',
1535 |         'input',
1536 |         'select',
1537 |         'textarea',
1538 |         'optgroup',
1539 |         'option',
1540 |         'menuitem',
1541 |         'fieldset'
1542 |       ]
1543 |       let index = -1
1544 | 
1545 |       while (++index < things.length) {
1546 |         const name = things[index]
1547 | 
1548 |         await t.test(
1549 |           'should match if w/ disabled on ' + name,
1550 |           async function () {
1551 |             assert.ok(matches(':disabled', h(name, {disabled: true})))
1552 |           }
1553 |         )
1554 | 
1555 |         await t.test(
1556 |           'should not match if w/o disabled on ' + name,
1557 |           async function () {
1558 |             assert.ok(!matches(':disabled', h(name)))
1559 |           }
1560 |         )
1561 |       }
1562 |     })
1563 | 
1564 |     await t.test(':enabled', async function (t) {
1565 |       const things = [
1566 |         'button',
1567 |         'input',
1568 |         'select',
1569 |         'textarea',
1570 |         'optgroup',
1571 |         'option',
1572 |         'menuitem',
1573 |         'fieldset'
1574 |       ]
1575 |       let index = -1
1576 | 
1577 |       while (++index < things.length) {
1578 |         const name = things[index]
1579 | 
1580 |         await t.test(
1581 |           'should match if w/o disabled on ' + name,
1582 |           async function () {
1583 |             assert.ok(matches(':enabled', h(name)))
1584 |           }
1585 |         )
1586 | 
1587 |         await t.test(
1588 |           'should not match if w/ disabled on ' + name,
1589 |           async function () {
1590 |             assert.ok(!matches(':enabled', h(name, {disabled: true})))
1591 |           }
1592 |         )
1593 |       }
1594 |     })
1595 | 
1596 |     await t.test(':required', async function (t) {
1597 |       const things = ['input', 'textarea', 'select']
1598 |       let index = -1
1599 | 
1600 |       while (++index < things.length) {
1601 |         const name = things[index]
1602 | 
1603 |         await t.test(
1604 |           'should match if w/ required on ' + name,
1605 |           async function () {
1606 |             assert.ok(matches(':required', h(name, {required: true})))
1607 |           }
1608 |         )
1609 | 
1610 |         await t.test(
1611 |           'should not match if w/o required on ' + name,
1612 |           async function () {
1613 |             assert.ok(!matches(':required', h(name)))
1614 |           }
1615 |         )
1616 |       }
1617 |     })
1618 | 
1619 |     await t.test(':optional', async function (t) {
1620 |       const things = ['input', 'textarea', 'select']
1621 | 
1622 |       let index = -1
1623 | 
1624 |       while (++index < things.length) {
1625 |         const name = things[index]
1626 | 
1627 |         await t.test(
1628 |           'should match if w/o required on ' + name,
1629 |           async function () {
1630 |             assert.ok(matches(':optional', h(name)))
1631 |           }
1632 |         )
1633 | 
1634 |         await t.test(
1635 |           'should not match if w/ required on ' + name,
1636 |           async function () {
1637 |             assert.ok(!matches(':optional', h(name, {required: true})))
1638 |           }
1639 |         )
1640 |       }
1641 |     })
1642 | 
1643 |     await t.test(':empty', async function (t) {
1644 |       await t.test('should match if w/o children', async function () {
1645 |         assert.ok(matches(':empty', h('')))
1646 |       })
1647 | 
1648 |       await t.test('should match if w/o elements or texts', async function () {
1649 |         assert.ok(matches(':empty', h('', [u('comment', '?')])))
1650 |       })
1651 | 
1652 |       await t.test('should not match if w/ elements', async function () {
1653 |         assert.ok(!matches(':empty', h('', h(''))))
1654 |       })
1655 | 
1656 |       await t.test('should not match if w/ text', async function () {
1657 |         assert.ok(!matches(':empty', h('', [u('text', '.')])))
1658 |       })
1659 | 
1660 |       await t.test(
1661 |         'should not match if w/ white-space text',
1662 |         async function () {
1663 |           assert.ok(!matches(':empty', h('', [u('text', ' ')])))
1664 |         }
1665 |       )
1666 |     })
1667 | 
1668 |     await t.test(':blank', async function (t) {
1669 |       await t.test('should match if w/o children', async function () {
1670 |         assert.ok(matches(':blank', h('')))
1671 |       })
1672 | 
1673 |       await t.test('should match if w/o elements or texts', async function () {
1674 |         assert.ok(matches(':blank', h('', u('comment', '?'))))
1675 |       })
1676 | 
1677 |       await t.test('should match if w/ white-space text', async function () {
1678 |         assert.ok(matches(':blank', h('', [u('text', ' ')])))
1679 |       })
1680 | 
1681 |       await t.test('should not match if w/ elements', async function () {
1682 |         assert.ok(!matches(':blank', h('', h(''))))
1683 |       })
1684 | 
1685 |       await t.test('should not match if w/ text', async function () {
1686 |         assert.ok(!matches(':blank', h('', [u('text', '.')])))
1687 |       })
1688 |     })
1689 | 
1690 |     await t.test(':lang()', async function (t) {
1691 |       await t.test(
1692 |         'should match if the element has an `xml:lang` attribute',
1693 |         async function () {
1694 |           assert.ok(matches(':lang(de, en)', h('html', {xmlLang: 'en'})))
1695 |         }
1696 |       )
1697 | 
1698 |       await t.test(
1699 |         'should match if the element has a `lang` attribute',
1700 |         async function () {
1701 |           assert.ok(matches(':lang(de, en)', h('html', {lang: 'de'})))
1702 |         }
1703 |       )
1704 | 
1705 |       await t.test(
1706 |         'should not match if the element has an different language set',
1707 |         async function () {
1708 |           assert.ok(!matches(':lang(de, en)', h('html', {xmlLang: 'jp'})))
1709 |         }
1710 |       )
1711 | 
1712 |       await t.test(
1713 |         'should prefer `xmlLang` over `lang` (#1)',
1714 |         async function () {
1715 |           assert.ok(
1716 |             !matches(':lang(de, en)', h('html', {xmlLang: 'jp', lang: 'de'}))
1717 |           )
1718 |         }
1719 |       )
1720 | 
1721 |       await t.test(
1722 |         'should prefer `xmlLang` over `lang` (#2)',
1723 |         async function () {
1724 |           assert.ok(
1725 |             matches(':lang(de, en)', h('html', {xmlLang: 'de', lang: 'jp'}))
1726 |           )
1727 |         }
1728 |       )
1729 | 
1730 |       await t.test(
1731 |         'should not match if the element has an different language set',
1732 |         async function () {
1733 |           assert.ok(!matches(':lang(de, en)', h('html', {xmlLang: 'jp'})))
1734 |         }
1735 |       )
1736 | 
1737 |       await t.test('should support wildcards', async function () {
1738 |         assert.ok(matches(':lang(*)', h('html', {lang: 'en'})))
1739 |       })
1740 | 
1741 |       await t.test(
1742 |         'should not match if [lang] is an empty string (means unknown language)',
1743 |         async function () {
1744 |           assert.ok(!matches(':lang(en)', h('html', {lang: ''})))
1745 |         }
1746 |       )
1747 | 
1748 |       await t.test(
1749 |         'should not match with wildcard if [lang] is an empty string (means unknown language)',
1750 |         async function () {
1751 |           assert.ok(!matches(':lang(*)', h('html', {lang: ''})))
1752 |         }
1753 |       )
1754 | 
1755 |       await t.test(
1756 |         'should support non-primary wildcard subtags (#1)',
1757 |         async function () {
1758 |           assert.ok(matches(':lang(de-*-DE)', h('html', {lang: 'de-Latn-DE'})))
1759 |         }
1760 |       )
1761 | 
1762 |       await t.test(
1763 |         'should support non-primary wildcard subtags (#2)',
1764 |         async function () {
1765 |           assert.ok(
1766 |             matches(':lang(fr-BE, de-*-DE)', h('html', {lang: 'de-Latn-DE'}))
1767 |           )
1768 |         }
1769 |       )
1770 |     })
1771 | 
1772 |     await t.test(':dir()', async function (t) {
1773 |       const ltr = 'a'
1774 |       const rtl = 'أ'
1775 |       const neutral = '!'
1776 | 
1777 |       await t.test(
1778 |         'should match `ltr` if the element has a matching explicit `dir` attribute',
1779 |         async function () {
1780 |           assert.ok(matches(':dir(ltr)', h('html', {dir: 'ltr'})))
1781 |         }
1782 |       )
1783 | 
1784 |       await t.test(
1785 |         'should match `rtl` if the element has a matching explicit `dir` attribute',
1786 |         async function () {
1787 |           assert.ok(matches(':dir(rtl)', h('html', {dir: 'rtl'})))
1788 |         }
1789 |       )
1790 | 
1791 |       await t.test(
1792 |         'should match `ltr` if the element is `html` with no `dir` attribute',
1793 |         async function () {
1794 |           assert.ok(matches(':dir(ltr)', h('html')))
1795 |         }
1796 |       )
1797 | 
1798 |       await t.test(
1799 |         'should match `ltr` if the element is `html` with an invalid `dir` attribute',
1800 |         async function () {
1801 |           assert.ok(matches(':dir(ltr)', h('html', {dir: 'foo'})))
1802 |         }
1803 |       )
1804 | 
1805 |       await t.test(
1806 |         'should match `ltr` if the element is `input[type=tel]` with no `dir` attribute',
1807 |         async function () {
1808 |           assert.ok(matches(':dir(ltr)', h('input', {type: 'tel'})))
1809 |         }
1810 |       )
1811 | 
1812 |       await t.test(
1813 |         'should match `ltr` if the element is `input[type=tel]` with an invalid `dir` attribute',
1814 |         async function () {
1815 |           assert.ok(matches(':dir(ltr)', h('input', {type: 'tel', dir: 'foo'})))
1816 |         }
1817 |       )
1818 | 
1819 |       await t.test(
1820 |         'should match `ltr` if `[dir=auto]` on a textarea and it’s content is BIDI LTR',
1821 |         async function () {
1822 |           assert.ok(matches(':dir(ltr)', h('textarea', {dir: 'auto'}, ltr)))
1823 |         }
1824 |       )
1825 | 
1826 |       await t.test(
1827 |         'should match `rtl` if `[dir=auto]` on a textarea and it’s content is BIDI RTL',
1828 |         async function () {
1829 |           assert.ok(matches(':dir(rtl)', h('textarea', {dir: 'auto'}, rtl)))
1830 |         }
1831 |       )
1832 | 
1833 |       await t.test(
1834 |         'should match `ltr` if `[dir=auto]` on a textarea and it’s content is BIDI neutral',
1835 |         async function () {
1836 |           assert.ok(matches(':dir(ltr)', h('textarea', {dir: 'auto'}, neutral)))
1837 |         }
1838 |       )
1839 | 
1840 |       await t.test(
1841 |         'should match `ltr` if `[dir=auto]` on a text input and it’s value is BIDI LTR',
1842 |         async function () {
1843 |           assert.ok(matches(':dir(ltr)', h('input', {dir: 'auto', value: ltr})))
1844 |         }
1845 |       )
1846 | 
1847 |       await t.test(
1848 |         'should match `rtl` if `[dir=auto]` on a search input and it’s value is BIDI RTL',
1849 |         async function () {
1850 |           assert.ok(
1851 |             matches(
1852 |               ':dir(rtl)',
1853 |               h('input', {type: 'search', dir: 'auto', value: rtl})
1854 |             )
1855 |           )
1856 |         }
1857 |       )
1858 | 
1859 |       await t.test(
1860 |         'should match `ltr` if `[dir=auto]` on a URL input and it’s value is BIDI neutral',
1861 |         async function () {
1862 |           assert.ok(
1863 |             matches(
1864 |               ':dir(ltr)',
1865 |               h('input', {type: 'url', dir: 'auto', value: neutral})
1866 |             )
1867 |           )
1868 |         }
1869 |       )
1870 | 
1871 |       await t.test(
1872 |         'should match `ltr` if `[dir=auto]` on an email input without value',
1873 |         async function () {
1874 |           assert.ok(
1875 |             matches(':dir(ltr)', h('input', {type: 'email', dir: 'auto'}))
1876 |           )
1877 |         }
1878 |       )
1879 | 
1880 |       await t.test(
1881 |         'should match `ltr` if `[dir=auto]` and the element has BIDI LTR text',
1882 |         async function () {
1883 |           assert.ok(matches(':dir(ltr)', h('p', {dir: 'auto'}, ltr)))
1884 |         }
1885 |       )
1886 | 
1887 |       await t.test(
1888 |         'should match `rtl` if `[dir=auto]` and the element has BIDI RTL text',
1889 |         async function () {
1890 |           assert.ok(matches(':dir(rtl)', h('p', {dir: 'auto'}, rtl)))
1891 |         }
1892 |       )
1893 | 
1894 |       await t.test(
1895 |         'should match `ltr` if `[dir=auto]` and the element has BIDI neutral text',
1896 |         async function () {
1897 |           assert.ok(matches(':dir(ltr)', h('p', {dir: 'auto'}, neutral)))
1898 |         }
1899 |       )
1900 | 
1901 |       await t.test(
1902 |         'should match `ltr` if `[dir=auto]` and the element has BIDI neutral text followed by LTR text',
1903 |         async function () {
1904 |           assert.ok(
1905 |             matches(':dir(ltr)', h('p', {dir: 'auto'}, [neutral, ltr, rtl]))
1906 |           )
1907 |         }
1908 |       )
1909 | 
1910 |       await t.test(
1911 |         'should match `rtl` if `[dir=auto]` and the element has BIDI neutral text followed by RTL text',
1912 |         async function () {
1913 |           assert.ok(
1914 |             matches(':dir(rtl)', h('p', {dir: 'auto'}, [neutral, rtl, ltr]))
1915 |           )
1916 |         }
1917 |       )
1918 | 
1919 |       await t.test(
1920 |         'should match `ltr` if `[dir=auto]`, ignoring BIDI text in scripts, followed by LTR text',
1921 |         async function () {
1922 |           assert.ok(
1923 |             matches(
1924 |               ':dir(ltr)',
1925 |               h('p', {dir: 'auto'}, [neutral, h('script', rtl), ltr])
1926 |             )
1927 |           )
1928 |         }
1929 |       )
1930 | 
1931 |       await t.test(
1932 |         'should match `rtl` if `[dir=auto]`, ignoring BIDI text in styles, followed by RTL text',
1933 |         async function () {
1934 |           assert.ok(
1935 |             matches(
1936 |               ':dir(rtl)',
1937 |               h('p', {dir: 'auto'}, [neutral, h('style', ltr), rtl])
1938 |             )
1939 |           )
1940 |         }
1941 |       )
1942 | 
1943 |       await t.test(
1944 |         'should match `ltr` if `[dir=auto]`, ignoring elements with directions, followed by LTR text',
1945 |         async function () {
1946 |           assert.ok(
1947 |             matches(
1948 |               ':dir(ltr)',
1949 |               h('p', {dir: 'auto'}, [
1950 |                 neutral,
1951 |                 h('span', {dir: 'rtl'}, rtl),
1952 |                 ltr
1953 |               ])
1954 |             )
1955 |           )
1956 |         }
1957 |       )
1958 | 
1959 |       await t.test(
1960 |         'should match `rtl` if `[dir=auto]`, ignoring elements with directions, followed by RTL text',
1961 |         async function () {
1962 |           assert.ok(
1963 |             matches(
1964 |               ':dir(rtl)',
1965 |               h('p', {dir: 'auto'}, [
1966 |                 neutral,
1967 |                 h('span', {dir: 'ltr'}, ltr),
1968 |                 rtl
1969 |               ])
1970 |             )
1971 |           )
1972 |         }
1973 |       )
1974 | 
1975 |       await t.test(
1976 |         'should match `ltr` on `bdi` elements, ignoring elements with directions, followed by LTR text',
1977 |         async function () {
1978 |           assert.ok(
1979 |             matches(
1980 |               ':dir(ltr)',
1981 |               h('bdi', [neutral, h('span', {dir: 'rtl'}, rtl), ltr])
1982 |             )
1983 |           )
1984 |         }
1985 |       )
1986 | 
1987 |       await t.test(
1988 |         'should match `rtl` on `bdi` elements, ignoring elements with directions, followed by RTL text',
1989 |         async function () {
1990 |           assert.ok(
1991 |             matches(
1992 |               ':dir(rtl)',
1993 |               h('bdi', [neutral, h('span', {dir: 'ltr'}, ltr), rtl])
1994 |             )
1995 |           )
1996 |         }
1997 |       )
1998 |     })
1999 | 
2000 |     await t.test(':root', async function (t) {
2001 |       await t.test('should match if `<html>` in HTML space', async function () {
2002 |         assert.ok(matches(':root', h('html')))
2003 |       })
2004 | 
2005 |       await t.test(
2006 |         'should not match if not `<html>` in HTML space',
2007 |         async function () {
2008 |           assert.ok(!matches(':root', h('div')))
2009 |         }
2010 |       )
2011 | 
2012 |       await t.test('should match if `<svg>` in SVG space', async function () {
2013 |         assert.ok(matches(':root', s('svg'), 'svg'))
2014 |       })
2015 | 
2016 |       await t.test(
2017 |         'should not match if not `<svg>` in SVG space',
2018 |         async function () {
2019 |           assert.ok(!matches(':root', s('circle'), 'svg'))
2020 |         }
2021 |       )
2022 |     })
2023 | 
2024 |     await t.test(':scope', async function (t) {
2025 |       await t.test('should always be true for elements', async function () {
2026 |         assert.ok(matches(':scope', h('html')))
2027 |       })
2028 | 
2029 |       await t.test('should always be true for elements', async function () {
2030 |         assert.ok(matches(':scope', h('p')))
2031 |       })
2032 | 
2033 |       await t.test('should always be true for elements', async function () {
2034 |         assert.ok(!matches(':scope', u('text', '!')))
2035 |       })
2036 |     })
2037 | 
2038 |     await t.test(':read-write', async function (t) {
2039 |       await t.test('should match on input', async function () {
2040 |         assert.ok(matches(':read-write', h('input')))
2041 |       })
2042 | 
2043 |       await t.test('should match on textarea', async function () {
2044 |         assert.ok(matches(':read-write', h('input')))
2045 |       })
2046 | 
2047 |       await t.test('should not match on input w/ readonly', async function () {
2048 |         assert.ok(!matches(':read-write', h('input', {readOnly: true})))
2049 |       })
2050 | 
2051 |       await t.test(
2052 |         'should not match on textarea w/ readonly',
2053 |         async function () {
2054 |           assert.ok(!matches(':read-write', h('textarea', {readOnly: true})))
2055 |         }
2056 |       )
2057 | 
2058 |       await t.test('should not match on input w/ disabled', async function () {
2059 |         assert.ok(!matches(':read-write', h('input', {disabled: true})))
2060 |       })
2061 | 
2062 |       await t.test(
2063 |         'should not match on textarea w/ disabled',
2064 |         async function () {
2065 |           assert.ok(!matches(':read-write', h('textarea', {disabled: true})))
2066 |         }
2067 |       )
2068 | 
2069 |       await t.test(
2070 |         'should match on element w/ contenteditable',
2071 |         async function () {
2072 |           assert.ok(matches(':read-write', h('div', {contentEditable: 'true'})))
2073 |         }
2074 |       )
2075 |     })
2076 | 
2077 |     await t.test(':read-only', async function (t) {
2078 |       await t.test('should not match on input', async function () {
2079 |         assert.ok(!matches(':read-only', h('input')))
2080 |       })
2081 | 
2082 |       await t.test('should not match on textarea', async function () {
2083 |         assert.ok(!matches(':read-only', h('input')))
2084 |       })
2085 | 
2086 |       await t.test('should match on input w/ readonly', async function () {
2087 |         assert.ok(matches(':read-only', h('input', {readOnly: true})))
2088 |       })
2089 | 
2090 |       await t.test('should match on textarea w/ readonly', async function () {
2091 |         assert.ok(matches(':read-only', h('textarea', {readOnly: true})))
2092 |       })
2093 | 
2094 |       await t.test('should match on input w/ disabled', async function () {
2095 |         assert.ok(matches(':read-only', h('input', {disabled: true})))
2096 |       })
2097 | 
2098 |       await t.test('should match on textarea w/ disabled', async function () {
2099 |         assert.ok(matches(':read-only', h('textarea', {disabled: true})))
2100 |       })
2101 | 
2102 |       await t.test(
2103 |         'should not match on element w/ contenteditable',
2104 |         async function () {
2105 |           assert.ok(!matches(':read-only', h('div', {contentEditable: 'true'})))
2106 |         }
2107 |       )
2108 |     })
2109 |   })
2110 | })
2111 | 


--------------------------------------------------------------------------------