npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2024 – Pkg Stats / Ryan Hefner

unist-util-select

v5.1.0

Published

unist utility to select nodes with CSS-like selectors

Downloads

686,034

Readme

unist-util-select

Build Coverage Downloads Size Sponsors Backers Chat

unist utility with equivalents for querySelector, querySelectorAll, and matches.

Contents

What is this?

This package lets you find nodes in a tree, similar to how querySelector, querySelectorAll, and matches 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 utility works on any unist syntax tree and you can select all node types. If you are working with hast, and only want to select elements, use hast-util-select instead.

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-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.

Install

This package is ESM only. In Node.js (version 16+), install with npm:

npm install unist-util-select

In Deno with esm.sh:

import {matches, select, selectAll} from "https://esm.sh/unist-util-select@5"

In browsers with esm.sh:

<script type="module">
  import {matches, select, selectAll} from "https://esm.sh/unist-util-select@5?bundle"
</script>

Use

import {u} from 'unist-builder'
import {matches, select, selectAll} from 'unist-util-select'

const tree = u('blockquote', [
  u('paragraph', [u('text', 'Alpha')]),
  u('paragraph', [u('text', 'Bravo')]),
  u('code', 'Charlie'),
  u('paragraph', [u('text', 'Delta')]),
  u('paragraph', [u('text', 'Echo')]),
  u('paragraph', [u('text', 'Foxtrot')]),
  u('paragraph', [u('text', 'Golf')])
])

console.log(matches('blockquote, list', tree)) // => true

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

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

API

This package exports the identifiers matches, select, and selectAll. There is no default export.

matches(selector, node)

Check that the given node matches selector.

This only checks the node itself, not the surrounding tree. Thus, nesting in selectors is not supported (paragraph strong, paragraph > strong), neither are selectors like :first-child, etc. This only checks that the given node matches the selector.

Parameters
  • selector (string) — CSS selector, such as (heading, link, linkReference).
  • node (Node, optional) — node that might match selector
Returns

Whether node matches selector (boolean).

Example
import {u} from 'unist-builder'
import {matches} from 'unist-util-select'

matches('strong, em', u('strong', [u('text', 'important')])) // => true
matches('[lang]', u('code', {lang: 'js'}, 'console.log(1)')) // => true

select(selector, tree)

Select the first node that matches selector in the given tree.

Searches the tree in preorder.

Parameters
  • selector (string) — CSS selector, such as (heading, link, linkReference).
  • tree (Node, optional) — tree to search
Returns

First node in tree that matches selector or undefined if nothing is found.

This could be tree itself.

Example
import {u} from 'unist-builder'
import {select} from 'unist-util-select'

console.log(
  select(
    'code ~ :nth-child(even)',
    u('blockquote', [
      u('paragraph', [u('text', 'Alpha')]),
      u('paragraph', [u('text', 'Bravo')]),
      u('code', 'Charlie'),
      u('paragraph', [u('text', 'Delta')]),
      u('paragraph', [u('text', 'Echo')])
    ])
  )
)

Yields:

{type: 'paragraph', children: [{type: 'text', value: 'Delta'}]}

selectAll(selector, tree)

Select all nodes that match selector in the given tree.

Searches the tree in preorder.

Parameters
  • selector (string) — CSS selector, such as (heading, link, linkReference).
  • tree (Node, optional) — tree to search
Returns

Nodes in tree that match selector.

This could include tree itself.

Example
import {u} from 'unist-builder'
import {selectAll} from 'unist-util-select'

console.log(
  selectAll(
    'code ~ :nth-child(even)',
    u('blockquote', [
      u('paragraph', [u('text', 'Alpha')]),
      u('paragraph', [u('text', 'Bravo')]),
      u('code', 'Charlie'),
      u('paragraph', [u('text', 'Delta')]),
      u('paragraph', [u('text', 'Echo')]),
      u('paragraph', [u('text', 'Foxtrot')]),
      u('paragraph', [u('text', 'Golf')])
    ])
  )
)

Yields:

[
  {type: 'paragraph', children: [{type: 'text', value: 'Delta'}]},
  {type: 'paragraph', children: [{type: 'text', value: 'Foxtrot'}]}
]

Support

  • [x] * (universal selector)
  • [x] , (multiple selector)
  • [x] paragraph (type selector)
  • [x] blockquote paragraph (combinator: descendant selector)
  • [x] blockquote > paragraph (combinator: child selector)
  • [x] code + paragraph (combinator: adjacent sibling selector)
  • [x] code ~ paragraph (combinator: general sibling selector)
  • [x] [attr] (attribute existence, checks that the value on the tree is not nullish)
  • [x] [attr=value] (attribute equality, this stringifies values on the tree)
  • [x] [attr^=value] (attribute begins with, only works on strings)
  • [x] [attr$=value] (attribute ends with, only works on strings)
  • [x] [attr*=value] (attribute contains, only works on strings)
  • [x] [attr~=value] (attribute contains, checks if value is in the array, if there’s an array on the tree, otherwise same as attribute equality)
  • [x] :is() (functional pseudo-class)
  • [x] :has() (functional pseudo-class; also supports a:has(> b))
  • [x] :not() (functional pseudo-class)
  • [x] :blank (pseudo-class, blank and empty are the same: a parent without children, or a node without value)
  • [x] :empty (pseudo-class, blank and empty are the same: a parent without children, or a node without value)
  • [x] :root (pseudo-class, matches the given node)
  • [x] :scope (pseudo-class, matches the given node)
  • [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)
Notes
  • * — not supported in matches
  • :any() and :matches() are renamed to :is() in CSS

Types

This package is fully typed with TypeScript. It exports no additional types.

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, unist-util-select@^5, compatible with Node.js 16.

Related

Contribute

See contributing.md in syntax-tree/.github for ways to get started. See support.md for ways to get help.

This project has a code of conduct. By interacting with this repository, organization, or community you agree to abide by its terms.

License

MIT © Eugene Sharygin