.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true

.gitignore

@@ -1 +1,6 @@
-/node_modules/
+.DS_Store
+*.log
+.nyc_output/
+coverage/
+node_modules/
+yarn.lock

.prettierignore

@@ -0,0 +1 @@
+coverage/

.travis.yml

@@ -1,5 +1,5 @@
 language: node_js
 node_js:
-  - 0.12
-  - 4
-  - node
+- lts/boron
+- node
+after_script: bash <(curl -s https://codecov.io/bash)

index.js

@@ -1,40 +1,20 @@
-'use strict';
+'use strict'
 
-var parseSelector = require('./lib/selector'),
-    matchSelector = require('./lib/select');
+exports.matches = matches
+exports.selectAll = selectAll
+exports.select = select
 
-var debug = require('debug')('unist-util-select');
+var any = require('./lib/any')
+var parse = require('./lib/parse')
 
+function matches(selector, node) {
+  return Boolean(any(parse(selector), node, {one: true, shallow: true})[0])
+}
 
-var select = function select (ast, selector) {
-  if (arguments.length == 1) {
-    return select.bind(this, ast);
-  }
+function select(selector, node) {
+  return any(parse(selector), node, {one: true})[0] || null
+}
 
-  debug('Selector: %j', selector);
-  selector = parseSelector(selector);
-  debug('AST: %s',
-        JSON.stringify(selector, null, 2).replace(/(^|\n)/g, '\n    '));
-  return selector ? matchSelector[selector.type](selector, ast) : [];
-};
-
-
-select.one = function selectOne (ast, selector) {
-  if (arguments.length == 1) {
-    return selectOne.bind(this, ast);
-  }
-
-  var nodes = select(ast, selector);
-
-  if (!nodes.length) {
-    throw Error('Node not found by ' + JSON.stringify(selector));
-  }
-  if (nodes.length > 1) {
-    throw Error('Node matched by ' + JSON.stringify(selector) + ' is not unique');
-  }
-
-  return nodes[0];
-};
-
-
-module.exports = select;
+function selectAll(selector, node) {
+  return any(parse(selector), node, {})
+}

lib/any.js

@@ -0,0 +1,134 @@
+'use strict'
+
+module.exports = match
+
+var zwitch = require('zwitch')
+var needsIndex = require('./pseudo').needsIndex
+var test = require('./test')
+var nest = require('./nest')
+
+var type = zwitch('type')
+var handlers = type.handlers
+
+type.unknown = unknownType
+type.invalid = invalidType
+handlers.selectors = selectors
+handlers.ruleSet = ruleSet
+handlers.rule = rule
+
+function match(query, node, state) {
+  return query && node ? type(query, node, state) : []
+}
+
+function selectors(query, node, state) {
+  var collect = collector(state.one)
+  var ruleSets = query.selectors
+  var length = ruleSets.length
+  var index = -1
+
+  while (++index < length) {
+    collect(ruleSet(ruleSets[index], node, state))
+  }
+
+  return collect.result
+}
+
+function ruleSet(query, node, state) {
+  return rule(query.rule, node, state)
+}
+
+function rule(query, tree, state) {
+  var collect = collector(state.one)
+  var opts = {
+    scopeNodes: tree.type === 'root' ? tree.children : [tree],
+    iterator: match,
+    one: state.one,
+    shallow: state.shallow
+  }
+
+  if (state.shallow && query.rule) {
+    throw new Error('Expected selector without nesting')
+  }
+
+  nest(query, tree, 0, null, configure(query, opts))
+
+  return collect.result
+
+  function match(query, node, index, parent, state) {
+    if (test(query, node, index, parent, state)) {
+      if (query.rule) {
+        nest(query.rule, node, index, parent, configure(query.rule, state))
+      } else {
+        collect(node)
+        state.found = true
+      }
+    }
+  }
+
+  function configure(query, state) {
+    var pseudos = query.pseudos
+    var length = pseudos && pseudos.length
+    var index = -1
+
+    while (++index < length) {
+      if (needsIndex.indexOf(pseudos[index].name) !== -1) {
+        state.index = true
+        break
+      }
+    }
+
+    return state
+  }
+}
+
+/* istanbul ignore next - Shouldn’t be invoked, all data is handled. */
+function unknownType(query) {
+  throw new Error('Unknown type `' + query.type + '`')
+}
+
+/* istanbul ignore next - Shouldn’t be invoked, parser gives correct data. */
+function invalidType() {
+  throw new Error('Invalid type')
+}
+
+function collector(one) {
+  var result = []
+  var found
+
+  collect.result = result
+
+  return collect
+
+  /* Append nodes to array, filtering out duplicates. */
+  function collect(source) {
+    if ('length' in source) {
+      collectAll()
+    } else {
+      collectOne(source)
+    }
+
+    function collectAll() {
+      var length = source.length
+      var index = -1
+
+      while (++index < length) {
+        collectOne(source[index])
+      }
+    }
+
+    function collectOne(node) {
+      if (one) {
+        /* istanbul ignore if - shouldn’t happen, safeguards performance problems. */
+        if (found) {
+          throw new Error('Cannot collect multiple nodes')
+        }
+
+        found = true
+      }
+
+      if (result.indexOf(node) === -1) {
+        result.push(node)
+      }
+    }
+  }
+}