Initial commit

Author: wooorm

.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

@@ -0,0 +1,7 @@
+.DS_Store
+*.log
+.nyc_output/
+coverage/
+node_modules/
+hast-util-select.js
+hast-util-select.min.js

.travis.yml

@@ -0,0 +1,22 @@
+language: node_js
+node_js:
+- '4.0'
+- '6.0'
+after_script: bash <(curl -s https://codecov.io/bash)
+deploy:
+  - provider: npm
+    email: [email protected]
+    api_key:
+      secure: WU/Ei+6g5ZaqF8qpsu/xGklg4P/LnXC4mkGh6Gsh3b5Nx54Fev+Ahw0Bur7xwJhCnVEBZBmLXyjsNPIbUpvmdKpvmuRUhZrDBRdSACel8wnNw5uwAbJdzw4xg4bagciS0F7F81fTqp0GEuOWfS9tIlF9gFBqC4VMJwePPlrvg5Qf8BbAtOavUN1f4Gm6x3+yvfTL770NSXZD7uUqCwaHXbOjGYZ9EMhiqakPcrVten8YKbdtqOO9SBbdHui8N9rGE14o7EIhLAwQ9tbuukvGLemKvBw3NxR9hBLBuP00FJw8wcdOf95drWh35tqclnypO4GRaIMGwZImKgt/l7IXEX/t9DGfGGQIyZQGO3r5DTkJdKYtlZIoNBj8kDkVd+Ns4UuhgDxjl+0OqZ9EadJzvhHOqHXIEkKK7xHiE/uRLUwNZsJpC/exdB+l3IisGoFOEayMDR9a2dxZ4ZeqOEC3kgb7rpuDVLkJCw766tmFoW4YmSgNWMqjLXVmeWddJvXsAoly9HVpXdqaqdnA5P5CHEbxcPoKSE+GyZzvvkUHtqZ0ltQM2J25H/cHxVPzbE4+5uB+umgt+Q81yCjxOyskcj5KNy1936t4adR8XiTTlAMdWAZS8+VrqOopFhknqHhUfQJwNn735m/86gs6AKF42CJD4yWBB30nXWPjRN7LilE=
+    on:
+      tags: true
+      node: '4.0'
+  - provider: releases
+    api_key:
+      secure: C5PDLRBnypcx44UYfgy7dlx9RyrhFIXYque3CCtCfTS3jC02HfSTrXMXR4mEPW378Rly+Rtw0OlE+XV05kDEXZ85aEzpiiLIyavVrgjtWQSHNJsToUVLamFEF44ad93Q3ZnBg/KiqtwblMZo1ue9w3lTASiFbKW949WwFkWvur7lJcoX42qeneYq0Y2486bv/gu3V+2t5RyI+MdYt8D7ttCKHrxiNzbtU4pMjp39nRJannWEw1oXOpilB1J7CVRRTD7bR8iatbdZkRl2CF7i4QayV/j/mjTingMUAKRAtG728qzoCmc3sc4F+tqBPP1aS/TYrDLtfDI+7atUgrZ2o8pF4squ+3FasGAVnjmUHTnwrxlwtmAyKfHU2L7uay9ixSLy29aHB9JiMaXTrVBmXLsOmC2ItuK0AbNmDw+meZiSoIJM7Ehp2zx1z4o+NHnLTkUUgsEepLmknWnQzSpCQ6/rKxdLrRiPQEFumHpzoMjMjvfsOapSi4x0rKyu9XhBo7PeLr7P+UC1aUOM4cJnB6bVDh+YTcqJptS2Zh017oYZwv4tRw5lVBMPV4mklqfkN2uoQwzLptDlF0dJ5ajh16qo924AKhhBuzF+Nmouhd+KhuPGI+8TV/HcL8ROAp8sAjHwIRHFBIl9uqIFlJBKBxxoUgFpoFMgKwmRHrzECVw=
+    file:
+      - "hast-util-select.js"
+      - "hast-util-select.min.js"
+    on:
+      tags: true
+      node: '7.0'

LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2017 Titus Wormer <[email protected]>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

index.js

@@ -0,0 +1,38 @@
+'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 = new Parser();
+
+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;
+
+function matches(selector, node) {
+  return Boolean(any(parse(selector), node, {one: true, shallow: true})[0]);
+}
+
+function select(selector, node) {
+  return any(parse(selector), node, {one: true})[0] || null;
+}
+
+function selectAll(selector, node) {
+  return any(parse(selector), node, {});
+}
+
+function parse(selector) {
+  if (typeof selector !== 'string') {
+    throw new Error('Expected `string` as selector, not `' + selector + '`');
+  }
+
+  return compile(parser.parse(selector));
+}

lib/any.js

@@ -0,0 +1,129 @@
+'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 = {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 elements 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(element) {
+      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(element) === -1) {
+        result.push(element);
+      }
+    }
+  }
+}

lib/attribute.js

@@ -0,0 +1,157 @@
+'use strict';
+
+module.exports = match;
+
+var camelcase = require('camelcase');
+var zwitch = require('zwitch');
+var has = require('hast-util-has-property');
+var information = require('property-information');
+var spaceSeparated = require('space-separated-tokens');
+var commaSeparated = require('comma-separated-tokens');
+
+var handle = zwitch('operator');
+var handlers = handle.handlers;
+
+match.support = ['~', '|', '^', '$', '*'];
+
+handle.unknown = unknownOperator;
+handle.invalid = exists;
+handlers['='] = exact;
+handlers['~='] = spaceSeparatedList;
+handlers['|='] = exactOrPrefix;
+handlers['^='] = begins;
+handlers['$='] = ends;
+handlers['*='] = contains;
+
+function match(query, node) {
+  var attrs = query.attrs;
+  var length = attrs.length;
+  var index = -1;
+  var info;
+  var attr;
+
+  while (++index < length) {
+    attr = attrs[index];
+    info = information(attr.name) || {};
+    attr.propertyName = info.propertyName || camelcase(attr.name);
+
+    if (!handle(attr, node, info)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/* [attr] */
+function exists(query, node) {
+  return has(node, query.propertyName);
+}
+
+/* [attr=value] */
+function exact(query, node, info) {
+  if (!has(node, query.propertyName)) {
+    return false;
+  }
+
+  return normalizeValue(node.properties[query.propertyName], info) === query.value;
+}
+
+/* [attr~=value] */
+function spaceSeparatedList(query, node, info) {
+  var val;
+
+  if (!has(node, query.propertyName)) {
+    return false;
+  }
+
+  val = node.properties[query.propertyName];
+
+  /* If this is a comma-separated list, and the query is contained in it,
+   * return true. */
+  if (
+    typeof val === 'object' &&
+    !info.commaSeparated &&
+    val.indexOf(query.value) !== -1
+  ) {
+    return true;
+  }
+
+  /* For all other values (including comma-separated lists),
+   * return whether this is an exact match. */
+  return normalizeValue(val, info) === query.value;
+}
+
+/* [attr|=value] */
+function exactOrPrefix(query, node, info) {
+  var value;
+
+  if (!has(node, query.propertyName)) {
+    return false;
+  }
+
+  value = normalizeValue(node.properties[query.propertyName], info);
+
+  return Boolean(
+    value === query.value ||
+    (
+      value.slice(0, query.value.length) === query.value &&
+      value.charAt(query.value.length) === '-'
+    )
+  );
+}
+
+/* [attr^=value] */
+function begins(query, node, info) {
+  if (!has(node, query.propertyName)) {
+    return false;
+  }
+
+  return normalizeValue(node.properties[query.propertyName], info)
+    .slice(0, query.value.length) === query.value;
+}
+
+/* [attr$=value] */
+function ends(query, node, info) {
+  if (!has(node, query.propertyName)) {
+    return false;
+  }
+
+  return normalizeValue(node.properties[query.propertyName], info)
+    .slice(-query.value.length) === query.value;
+}
+
+/* [attr*=value] */
+function contains(query, node, info) {
+  if (!has(node, query.propertyName)) {
+    return false;
+  }
+
+  return normalizeValue(node.properties[query.propertyName], info)
+    .indexOf(query.value) !== -1;
+}
+
+/* istanbul ignore next - Shouldn’t be invoked, Parser throws an error instead. */
+function unknownOperator(query) {
+  throw new Error('Unknown operator `' + query.operator + '`');
+}
+
+/* Stringify a HAST value back to its HTML form. */
+function normalizeValue(value, info) {
+  if (info.commaSeparated) {
+    value = commaSeparated.stringify(value);
+  } else if (info.spaceSeparated) {
+    value = spaceSeparated.stringify(value);
+  } else if (info.boolean) {
+    /* `false` is ignored by `has()`. */
+    value = info.name;
+  } else if (info.overloadedBoolean) {
+    if (value === true) {
+      value = info.name;
+    }
+  } else if (info.positiveNumeric || info.numeric) {
+    value = String(value);
+  }
+
+  return value;
+}