hast-util-select

hast utility for `querySelector`, `querySelectorAll`, and `matches`

Downloads in past

Stats

StarsIssuesVersionUpdatedCreatedSize
hast-util-select
3106.0.26 months ago7 years agoMinified + gzip package size for hast-util-select in KB

Popular Searches

Readme

hast-util-select
!Buildbuild-badgebuild !Coveragecoverage-badgecoverage !Downloadsdownloads-badgedownloads !Sizesize-badgesize !Sponsorssponsors-badgecollective !Backersbackers-badgecollective !Chatchat-badgechat
hast utility with equivalents for matches, querySelector, and querySelectorAll.

Contents

*   [`matches(selector, node[, space])`](#matchesselector-node-space)
*   [`select(selector, tree[, space])`](#selectselector-tree-space)
*   [`selectAll(selector, tree[, space])`](#selectallselector-tree-space)
*   [`Space`](#space)

What is this?

This package lets you find nodes in a tree, similar to how matches, querySelector, and querySelectorAll work with the DOM.
One notable difference between DOM and hast is that DOM nodes have references to their parents, meaning that document.body.matches(':last-child') can be evaluated to check whether the body is the last child of its parent. This information is not stored in hast, so selectors like that don’t work.

When should I use this?

This is a small utility that is quite useful, but is rather slow if you use it a lot. For each call, it has to walk the entire tree. In some cases, walking the tree once with unist-util-visitunist-util-visit is smarter, such as when you want to change certain nodes. On the other hand, this is quite powerful and fast enough for many other cases.
This utility is similar to unist-util-selectunist-util-select, which can find and match any unist node.

Install

This package is ESM onlyesm. In Node.js (version 16+), install with npm:
npm install hast-util-select

In Deno with esm.shesmsh:
import {matches, select, selectAll} from "https://esm.sh/hast-util-select@6"

In browsers with esm.shesmsh:
<script type="module">
  import {matches, select, selectAll} from "https://esm.sh/hast-util-select@6?bundle"
</script>

Use

import {h} from 'hastscript'
import {matches, select, selectAll} from 'hast-util-select'

const tree = h('section', [
  h('p', 'Alpha'),
  h('p', 'Bravo'),
  h('h1', 'Charlie'),
  h('p', 'Delta'),
  h('p', 'Echo'),
  h('p', 'Foxtrot'),
  h('p', 'Golf')
])

console.log(matches('section', tree)) // `true`

console.log(select('h1 ~ :nth-child(even)', tree))
// The paragraph with `Delta`

console.log(selectAll('h1 ~ :nth-child(even)', tree))
// The paragraphs with `Delta` and `Foxtrot`

API

This package exports the identifiers matchesapi-matches, selectapi-select, and selectAllapi-select-all. There is no default export.

matches(selector, node[, space])

Check that the given node matches selector.
This only checks the element itself, not the surrounding tree. Thus, nesting in selectors is not supported (p b, p > b), neither are selectors like :first-child, etc. This only checks that the given element matches the selector.
Parameters
  • selector (string)
— CSS selector, such as (`h1`, `a, b`)
— node that might match `selector`, should be an element
— name of namespace
Returns
Whether node matches selector (boolean).
Example
import {h} from 'hastscript'
import {matches} from 'hast-util-select'

matches('b, i', h('b')) // => true
matches(':any-link', h('a')) // => false
matches(':any-link', h('a', {href: '#'})) // => true
matches('.classy', h('a', {className: ['classy']})) // => true
matches('#id', h('a', {id: 'id'})) // => true
matches('[lang|=en]', h('a', {lang: 'en'})) // => true
matches('[lang|=en]', h('a', {lang: 'en-GB'})) // => true

select(selector, tree[, space])

Select the first element that matches selector in the given tree. Searches the tree in preorder.
Parameters
  • selector (string)
— CSS selector, such as (`h1`, `a, b`)
— tree to search
— name of namespace
Returns
First element in tree that matches selector or undefined if nothing is found. This could be tree itself.
Example
import {h} from 'hastscript'
import {select} from 'hast-util-select'

console.log(
  select(
    'h1 ~ :nth-child(even)',
    h('section', [
      h('p', 'Alpha'),
      h('p', 'Bravo'),
      h('h1', 'Charlie'),
      h('p', 'Delta'),
      h('p', 'Echo')
    ])
  )
)

Yields:
{ type: 'element',
  tagName: 'p',
  properties: {},
  children: [ { type: 'text', value: 'Delta' } ] }

selectAll(selector, tree[, space])

Select all elements that match selector in the given tree. Searches the tree in preorder.
Parameters
  • selector (string)
— CSS selector, such as (`h1`, `a, b`)
— tree to search
— name of namespace
Returns
Elements in tree that match selector. This could include tree itself.
Example
import {h} from 'hastscript'
import {selectAll} from 'hast-util-select'

console.log(
  selectAll(
    'h1 ~ :nth-child(even)',
    h('section', [
      h('p', 'Alpha'),
      h('p', 'Bravo'),
      h('h1', 'Charlie'),
      h('p', 'Delta'),
      h('p', 'Echo'),
      h('p', 'Foxtrot'),
      h('p', 'Golf')
    ])
  )
)

Yields:
[ { type: 'element',
    tagName: 'p',
    properties: {},
    children: [ { type: 'text', value: 'Delta' } ] },
  { type: 'element',
    tagName: 'p',
    properties: {},
    children: [ { type: 'text', value: 'Foxtrot' } ] } ]

Space

Namespace (TypeScript type).
Type
type Space = 'html' | 'svg'

Support

  • x * (universal selector)
  • x , (multiple selector)
  • x p (type selector)
  • x .class (class selector)
  • x #id (id selector)
  • x article p (combinator: descendant selector)
  • x article > p (combinator: child selector)
  • x h1 + p (combinator: next-sibling selector)
  • x h1 ~ p (combinator: subsequent sibling selector)
  • x [attr] (attribute existence)
  • x [attr… i] (attribute case-insensitive)
  • x [attr… s] (attribute case-sensitive) (useless, default)
  • x [attr=value] (attribute equality)
  • x [attr~=value] (attribute contains in space-separated list)
  • x [attr|=value] (attribute equality or prefix)
  • x [attr^=value] (attribute begins with)
  • x [attr$=value] (attribute ends with)
  • x [attr*=value] (attribute contains)
  • x :dir() (functional pseudo-class)
  • x :has() (functional pseudo-class; also supports a:has(> b))
  • x :is() (functional pseudo-class)
  • x :lang() (functional pseudo-class)
  • x :not() (functional pseudo-class)
  • x :any-link (pseudo-class)
  • x :blank (pseudo-class)
  • x :checked (pseudo-class)
  • x :disabled (pseudo-class)
  • x :empty (pseudo-class)
  • x :enabled (pseudo-class)
  • x :optional (pseudo-class)
  • x :read-only (pseudo-class)
  • x :read-write (pseudo-class)
  • x :required (pseudo-class)
  • x :root (pseudo-class)
  • x :scope (pseudo-class):
  • x \* :first-child (pseudo-class)
  • x \* :first-of-type (pseudo-class)
  • x \* :last-child (pseudo-class)
  • x \* :last-of-type (pseudo-class)
  • x \* :only-child (pseudo-class)
  • x \* :only-of-type (pseudo-class)
  • x \* :nth-child() (functional pseudo-class)
  • x \* :nth-last-child() (functional pseudo-class)
  • x \* :nth-last-of-type() (functional pseudo-class)
  • x \* :nth-of-type() (functional pseudo-class)

Unsupported

  • † || (column combinator)
  • † ns|E (namespace type selector)
  • † *|E (any namespace type selector)
  • † |E (no namespace type selector)
  • † [ns|attr] (namespace attribute)
  • † [*|attr] (any namespace attribute)
  • † [|attr] (no namespace attribute)
  • ‖ :nth-child(n of S) (functional pseudo-class, note: scoping to
parents is not supported)
  • ‖ :nth-last-child(n of S) (functional pseudo-class, note: scoping to
parents is not supported)
  • † :active (pseudo-class)
  • † :autofill (pseudo-class)
  • † :buffering (pseudo-class)
  • § :closed (pseudo-class)
  • † :current (pseudo-class)
  • † :current() (functional pseudo-class)
  • † :default (pseudo-class)
  • † :defined (pseudo-class)
  • † :focus (pseudo-class)
  • † :focus-visible (pseudo-class)
  • † :focus-within (pseudo-class)
  • † :fullscreen (pseudo-class)
  • † :future (pseudo-class)
  • § :host() (functional pseudo-class)
  • § :host-context() (functional pseudo-class)
  • † :hover (pseudo-class)
  • ‡ :in-range (pseudo-class)
  • † :indeterminate (pseudo-class)
  • ‡ :invalid (pseudo-class)
  • † :link (pseudo-class)
  • † :local-link (pseudo-class)
  • † :modal (pseudo-class)
  • † :muted (pseudo-class)
  • † :nth-col() (functional pseudo-class)
  • † :nth-last-col() (functional pseudo-class)
  • § :open (pseudo-class)
  • ‡ :out-of-range (pseudo-class)
  • † :past (pseudo-class)
  • † :paused (pseudo-class)
  • † :placeholder-shown (pseudo-class)
  • † :playing (pseudo-class)
  • † :seeking (pseudo-class)
  • † :stalled (pseudo-class)
  • † :target (pseudo-class)
  • † :target-within (pseudo-class)
  • † :user-invalid (pseudo-class)
  • ‡ :valid (pseudo-class)
  • † :visited (pseudo-class)
  • † :volume-locked (pseudo-class)
  • § :where() (functional pseudo-class)
  • † ::before (pseudo-elements: none are supported)
Notes
  • \ — not supported in matches
  • † — needs a user, browser, interactivity, scripting, or whole CSS to make
sense
  • ‡ — not very interested in writing / including the code for this
  • § — too new, the spec is still changing
  • ‖ — pr wanted!
  • :any() and :matches() are renamed to :is() in CSS.

Types

This package is fully typed with TypeScript. It exports the additional type Spaceapi-space.

Compatibility

Projects maintained by the unified collective are compatible with maintained versions of Node.js.
When we cut a new major release, we drop support for unmaintained versions of Node. This means we try to keep the current release line, hast-util-select@^6, compatible with Node.js 16.

Security

This package does not change the syntax tree so there are no openings for cross-site scripting (XSS)xss attacks.

Related

— select unist nodes with CSS-like selectors
— find and replace text in a hast tree
— create an element from a simple CSS selector
— create an element from a complex CSS selector

Contribute

See contributing.mdcontributing in syntax-tree/.githubhealth for ways to get started. See support.mdhelp for ways to get help.
This project has a code of conductcoc. By interacting with this repository, organization, or community you agree to abide by its terms.

License

MITlicense © Titus Wormerauthor