How to use the unist-util-select.select function in unist-util-select

return () => /* attacher */ (tree) => {
    /* transformer */
    if (excerpt) {
      return select(selector, tree)
    }
    return tree
  }
}

tester.has = (selector) => {
      assert.ok(select.select(selector, node), `Markdown AST does not include node matching selector "${selector}"
${inspect(node)}`);
      return tester;
    };
    tester.equals = (selector, value) => {

return (tree, file) => {
    const heading = select('heading', tree)
    file.data.title = heading ? toString(heading) : ''

    visit(tree, ['yaml'], node => {
      file.data = {
        ...file.data,
        ...yaml(node.value)
      }
    })

    visit(tree, ['toml'], node => {
      file.data = {
        ...file.data,
        ...toml(node.value)
      }
    })
  }

function findGroupOrCreate(group, action) {
  let groupNode = select(`group[name=${group}]`, action);

  if (groupNode) {
    return groupNode;
  }

  groupNode = createGroup({ name: group });
  action.children.push(groupNode);
  return groupNode;
}

selectNode(selector, base = this.ast) {
    return select(selector, base)
  }

function compile(tree, file) {
    const preface = select('preface', tree);
    const unreleased = select('release[identifier=unreleased]', tree);
    let releases = selectAll('release', tree).filter(r => !r.unreleased);
    const version = semver.valid(userVersion);
    const prereleases = releases.filter(
      r => !!semver.prerelease(r.version) && semver.eq(semver.valid(semver.coerce(r.version)), version)
    );
    let isYanked = yanked;

    if (!version) {
      file.fail('Version release is not valid.');
    }

    const isPrerelease = !!semver.prerelease(version);
    const toMergePrereleases = !isPrerelease && mergePrerelease && prereleases.length > 0;

    if (!unreleased) {
      file.fail('Missing unreleased header.', null, 'release:missing-unreleased');

.map(ast => {
          const { date, export_date, export_title, ...properties } = getProperties(ast)
          const title = export_title || select(`text`, ast).value

          const d = parseTimestamp(date) ||
                parseTimestamp(export_date) ||
                select(`timestamp`, ast) ||
                select(`planning[keyword=CLOSED]`, ast)

          const metadata = {
            title,
            export_file_name: sanitise(title),
            category: category || orgFileNode.fileName,
            keyword: ast.keyword,
            tags: ast.tags,
            ...properties,
          }

          if (d && d.date) { metadata.date = d.date }
          if (d && d.end) { metadata.end = d.end }

          const absolutePath = `${orgFileNode.fileAbsolutePath}::*${title}`
          return {
            metadata,

function findActionOrCreate(action, release) {
  let name = action.toLowerCase().trim();
  name = name[0].toUpperCase() + name.substr(1);

  let actionNode = select(`action[name=${name}]`, release);

  if (actionNode) {
    return actionNode;
  }

  actionNode = createAction({ name });
  release.children.push(actionNode);
  return actionNode;
}