Refactor code-style

Author: wooorm

.prettierignore

@@ -0,0 +1,3 @@
+coverage/
+hast-util-select.js
+hast-util-select.min.js

index.js

@@ -1,38 +1,38 @@
-'use strict';
+'use strict'
 
-var Parser = require('css-selector-parser').CssSelectorParser;
-var attributes = require('./lib/attribute');
-var pseudos = require('./lib/pseudo');
-var any = require('./lib/any');
-var nesting = require('./lib/nest');
-var compile = require('./lib/compile');
+var Parser = require('css-selector-parser').CssSelectorParser
+var attributes = require('./lib/attribute')
+var pseudos = require('./lib/pseudo')
+var any = require('./lib/any')
+var nesting = require('./lib/nest')
+var compile = require('./lib/compile')
 
-var parser = new Parser();
+var parser = new Parser()
 
-parser.registerAttrEqualityMods.apply(parser, attributes.support);
-parser.registerSelectorPseudos.apply(parser, pseudos.selectorPseudoSupport);
-parser.registerNestingOperators.apply(parser, nesting.support);
+parser.registerAttrEqualityMods.apply(parser, attributes.support)
+parser.registerSelectorPseudos.apply(parser, pseudos.selectorPseudoSupport)
+parser.registerNestingOperators.apply(parser, nesting.support)
 
-exports.matches = matches;
-exports.selectAll = selectAll;
-exports.select = select;
+exports.matches = matches
+exports.selectAll = selectAll
+exports.select = select
 
 function matches(selector, node) {
-  return Boolean(any(parse(selector), node, {one: true, shallow: true})[0]);
+  return Boolean(any(parse(selector), node, {one: true, shallow: true})[0])
 }
 
 function select(selector, node) {
-  return any(parse(selector), node, {one: true})[0] || null;
+  return any(parse(selector), node, {one: true})[0] || null
 }
 
 function selectAll(selector, node) {
-  return any(parse(selector), node, {});
+  return any(parse(selector), node, {})
 }
 
 function parse(selector) {
   if (typeof selector !== 'string') {
-    throw new Error('Expected `string` as selector, not `' + selector + '`');
+    throw new Error('Expected `string` as selector, not `' + selector + '`')
   }
 
-  return compile(parser.parse(selector));
+  return compile(parser.parse(selector))
 }

lib/any.js

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