Fix.

node_modules/expand-brackets/index.js

@@ -0,0 +1,211 @@
+'use strict';
+
+/**
+ * Local dependencies
+ */
+
+var compilers = require('./lib/compilers');
+var parsers = require('./lib/parsers');
+
+/**
+ * Module dependencies
+ */
+
+var debug = require('debug')('expand-brackets');
+var extend = require('extend-shallow');
+var Snapdragon = require('snapdragon');
+var toRegex = require('to-regex');
+
+/**
+ * Parses the given POSIX character class `pattern` and returns a
+ * string that can be used for creating regular expressions for matching.
+ *
+ * @param {String} `pattern`
+ * @param {Object} `options`
+ * @return {Object}
+ * @api public
+ */
+
+function brackets(pattern, options) {
+  debug('initializing from <%s>', __filename);
+  var res = brackets.create(pattern, options);
+  return res.output;
+}
+
+/**
+ * Takes an array of strings and a POSIX character class pattern, and returns a new
+ * array with only the strings that matched the pattern.
+ *
+ * ```js
+ * var brackets = require('expand-brackets');
+ * console.log(brackets.match(['1', 'a', 'ab'], '[[:alpha:]]'));
+ * //=> ['a']
+ *
+ * console.log(brackets.match(['1', 'a', 'ab'], '[[:alpha:]]+'));
+ * //=> ['a', 'ab']
+ * ```
+ * @param {Array} `arr` Array of strings to match
+ * @param {String} `pattern` POSIX character class pattern(s)
+ * @param {Object} `options`
+ * @return {Array}
+ * @api public
+ */
+
+brackets.match = function(arr, pattern, options) {
+  arr = [].concat(arr);
+  var opts = extend({}, options);
+  var isMatch = brackets.matcher(pattern, opts);
+  var len = arr.length;
+  var idx = -1;
+  var res = [];
+
+  while (++idx < len) {
+    var ele = arr[idx];
+    if (isMatch(ele)) {
+      res.push(ele);
+    }
+  }
+
+  if (res.length === 0) {
+    if (opts.failglob === true) {
+      throw new Error('no matches found for "' + pattern + '"');
+    }
+
+    if (opts.nonull === true || opts.nullglob === true) {
+      return [pattern.split('\\').join('')];
+    }
+  }
+  return res;
+};
+
+/**
+ * Returns true if the specified `string` matches the given
+ * brackets `pattern`.
+ *
+ * ```js
+ * var brackets = require('expand-brackets');
+ *
+ * console.log(brackets.isMatch('a.a', '[[:alpha:]].[[:alpha:]]'));
+ * //=> true
+ * console.log(brackets.isMatch('1.2', '[[:alpha:]].[[:alpha:]]'));
+ * //=> false
+ * ```
+ * @param {String} `string` String to match
+ * @param {String} `pattern` Poxis pattern
+ * @param {String} `options`
+ * @return {Boolean}
+ * @api public
+ */
+
+brackets.isMatch = function(str, pattern, options) {
+  return brackets.matcher(pattern, options)(str);
+};
+
+/**
+ * Takes a POSIX character class pattern and returns a matcher function. The returned
+ * function takes the string to match as its only argument.
+ *
+ * ```js
+ * var brackets = require('expand-brackets');
+ * var isMatch = brackets.matcher('[[:lower:]].[[:upper:]]');
+ *
+ * console.log(isMatch('a.a'));
+ * //=> false
+ * console.log(isMatch('a.A'));
+ * //=> true
+ * ```
+ * @param {String} `pattern` Poxis pattern
+ * @param {String} `options`
+ * @return {Boolean}
+ * @api public
+ */
+
+brackets.matcher = function(pattern, options) {
+  var re = brackets.makeRe(pattern, options);
+  return function(str) {
+    return re.test(str);
+  };
+};
+
+/**
+ * Create a regular expression from the given `pattern`.
+ *
+ * ```js
+ * var brackets = require('expand-brackets');
+ * var re = brackets.makeRe('[[:alpha:]]');
+ * console.log(re);
+ * //=> /^(?:[a-zA-Z])$/
+ * ```
+ * @param {String} `pattern` The pattern to convert to regex.
+ * @param {Object} `options`
+ * @return {RegExp}
+ * @api public
+ */
+
+brackets.makeRe = function(pattern, options) {
+  var res = brackets.create(pattern, options);
+  var opts = extend({strictErrors: false}, options);
+  return toRegex(res.output, opts);
+};
+
+/**
+ * Parses the given POSIX character class `pattern` and returns an object
+ * with the compiled `output` and optional source `map`.
+ *
+ * ```js
+ * var brackets = require('expand-brackets');
+ * console.log(brackets('[[:alpha:]]'));
+ * // { options: { source: 'string' },
+ * //   input: '[[:alpha:]]',
+ * //   state: {},
+ * //   compilers:
+ * //    { eos: [Function],
+ * //      noop: [Function],
+ * //      bos: [Function],
+ * //      not: [Function],
+ * //      escape: [Function],
+ * //      text: [Function],
+ * //      posix: [Function],
+ * //      bracket: [Function],
+ * //      'bracket.open': [Function],
+ * //      'bracket.inner': [Function],
+ * //      'bracket.literal': [Function],
+ * //      'bracket.close': [Function] },
+ * //   output: '[a-zA-Z]',
+ * //   ast:
+ * //    { type: 'root',
+ * //      errors: [],
+ * //      nodes: [ [Object], [Object], [Object] ] },
+ * //   parsingErrors: [] }
+ * ```
+ * @param {String} `pattern`
+ * @param {Object} `options`
+ * @return {Object}
+ * @api public
+ */
+
+brackets.create = function(pattern, options) {
+  var snapdragon = (options && options.snapdragon) || new Snapdragon(options);
+  compilers(snapdragon);
+  parsers(snapdragon);
+
+  var ast = snapdragon.parse(pattern, options);
+  ast.input = pattern;
+  var res = snapdragon.compile(ast, options);
+  res.input = pattern;
+  return res;
+};
+
+/**
+ * Expose `brackets` constructor, parsers and compilers
+ */
+
+brackets.compilers = compilers;
+brackets.parsers = parsers;
+
+/**
+ * Expose `brackets`
+ * @type {Function}
+ */
+
+module.exports = brackets;