actions/setup-node
1
0
Fork 0
mirror of https://code.forgejo.org/actions/setup-node.git synced 2025-05-19 21:04:45 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

.

Browse source
This commit is contained in:
eric sciple 2020-01-24 12:22:34 -05:00
parent 9fff29ba6c
commit 00c3b50fca
7278 changed files with 0 additions and 1778943 deletions
Download patch file Download diff file Expand all files Collapse all files

57
node_modules/nanomatch/CHANGELOG.md generated vendored
View file

@ -1,57 +0,0 @@
## History
### key
Changelog entries are classified using the following labels _(from [keep-a-changelog][]_):
- `added`: for new features
- `changed`: for changes in existing functionality
- `deprecated`: for once-stable features removed in upcoming releases
- `removed`: for deprecated features removed in this release
- `fixed`: for any bug fixes
- `bumped`: updated dependencies, only minor or higher will be listed.
### [1.1.0] - 2017-04-11
**Fixed**
- adds support for unclosed quotes
**Added**
- adds support for `options.noglobstar`
### [1.0.4] - 2017-04-06
Housekeeping updates. Adds documentation section about escaping, cleans up utils.
### [1.0.3] - 2017-04-06
This release includes fixes for windows path edge cases and other improvements for stricter adherence to bash spec.
**Fixed**
- More windows path edge cases
**Added**
- Support for bash-like quoted strings for escaping sequences of characters, such as `foo/"**"/bar` where `**` should be matched literally and not evaluated as special characters.
### [1.0.1] - 2016-12-12
**Added**
- Support for windows path edge cases where backslashes are used in brackets or other unusual combinations.
### [1.0.0] - 2016-12-12
Stable release.
### [0.1.0] - 2016-10-08
First release.
[Unreleased]: https://github.com/jonschlinkert/nanomatch/compare/0.1.0...HEAD
[0.2.0]: https://github.com/jonschlinkert/nanomatch/compare/0.1.0...0.2.0
[keep-a-changelog]: https://github.com/olivierlacan/keep-a-changelog

21
node_modules/nanomatch/LICENSE generated vendored
View file

@ -1,21 +0,0 @@
The MIT License (MIT)
Copyright (c) 2016-2018, Jon Schlinkert.
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.

1148
node_modules/nanomatch/README.md generated vendored
View file

File diff suppressed because it is too large Load diff

838
node_modules/nanomatch/index.js generated vendored
View file

@ -1,838 +0,0 @@
'use strict';
/**
* Module dependencies
*/
var util = require('util');
var toRegex = require('to-regex');
var extend = require('extend-shallow');
/**
* Local dependencies
*/
var compilers = require('./lib/compilers');
var parsers = require('./lib/parsers');
var cache = require('./lib/cache');
var utils = require('./lib/utils');
var MAX_LENGTH = 1024 * 64;
/**
* The main function takes a list of strings and one or more
* glob patterns to use for matching.
*
* ```js
* var nm = require('nanomatch');
* nm(list, patterns[, options]);
*
* console.log(nm(['a.js', 'a.txt'], ['*.js']));
* //=> [ 'a.js' ]
* ```
* @param {Array} `list` A list of strings to match
* @param {String|Array} `patterns` One or more glob patterns to use for matching.
* @param {Object} `options` See available [options](#options) for changing how matches are performed
* @return {Array} Returns an array of matches
* @summary false
* @api public
*/
function nanomatch(list, patterns, options) {
patterns = utils.arrayify(patterns);
list = utils.arrayify(list);
var len = patterns.length;
if (list.length === 0 || len === 0) {
return [];
}
if (len === 1) {
return nanomatch.match(list, patterns[0], options);
}
var negated = false;
var omit = [];
var keep = [];
var idx = -1;
while (++idx < len) {
var pattern = patterns[idx];
if (typeof pattern === 'string' && pattern.charCodeAt(0) === 33 /* ! */) {
omit.push.apply(omit, nanomatch.match(list, pattern.slice(1), options));
negated = true;
} else {
keep.push.apply(keep, nanomatch.match(list, pattern, options));
}
}
// minimatch.match parity
if (negated && keep.length === 0) {
if (options && options.unixify === false) {
keep = list.slice();
} else {
var unixify = utils.unixify(options);
for (var i = 0; i < list.length; i++) {
keep.push(unixify(list[i]));
}
}
}
var matches = utils.diff(keep, omit);
if (!options || options.nodupes !== false) {
return utils.unique(matches);
}
return matches;
}
/**
* Similar to the main function, but `pattern` must be a string.
*
* ```js
* var nm = require('nanomatch');
* nm.match(list, pattern[, options]);
*
* console.log(nm.match(['a.a', 'a.aa', 'a.b', 'a.c'], '*.a'));
* //=> ['a.a', 'a.aa']
* ```
* @param {Array} `list` Array of strings to match
* @param {String} `pattern` Glob pattern to use for matching.
* @param {Object} `options` See available [options](#options) for changing how matches are performed
* @return {Array} Returns an array of matches
* @api public
*/
nanomatch.match = function(list, pattern, options) {
if (Array.isArray(pattern)) {
throw new TypeError('expected pattern to be a string');
}
var unixify = utils.unixify(options);
var isMatch = memoize('match', pattern, options, nanomatch.matcher);
var matches = [];
list = utils.arrayify(list);
var len = list.length;
var idx = -1;
while (++idx < len) {
var ele = list[idx];
if (ele === pattern || isMatch(ele)) {
matches.push(utils.value(ele, unixify, options));
}
}
// if no options were passed, uniquify results and return
if (typeof options === 'undefined') {
return utils.unique(matches);
}
if (matches.length === 0) {
if (options.failglob === true) {
throw new Error('no matches found for "' + pattern + '"');
}
if (options.nonull === true || options.nullglob === true) {
return [options.unescape ? utils.unescape(pattern) : pattern];
}
}
// if `opts.ignore` was defined, diff ignored list
if (options.ignore) {
matches = nanomatch.not(matches, options.ignore, options);
}
return options.nodupes !== false ? utils.unique(matches) : matches;
};
/**
* Returns true if the specified `string` matches the given glob `pattern`.
*
* ```js
* var nm = require('nanomatch');
* nm.isMatch(string, pattern[, options]);
*
* console.log(nm.isMatch('a.a', '*.a'));
* //=> true
* console.log(nm.isMatch('a.b', '*.a'));
* //=> false
* ```
* @param {String} `string` String to match
* @param {String} `pattern` Glob pattern to use for matching.
* @param {Object} `options` See available [options](#options) for changing how matches are performed
* @return {Boolean} Returns true if the string matches the glob pattern.
* @api public
*/
nanomatch.isMatch = function(str, pattern, options) {
if (typeof str !== 'string') {
throw new TypeError('expected a string: "' + util.inspect(str) + '"');
}
if (utils.isEmptyString(str) || utils.isEmptyString(pattern)) {
return false;
}
var equals = utils.equalsPattern(options);
if (equals(str)) {
return true;
}
var isMatch = memoize('isMatch', pattern, options, nanomatch.matcher);
return isMatch(str);
};
/**
* Returns true if some of the elements in the given `list` match any of the
* given glob `patterns`.
*
* ```js
* var nm = require('nanomatch');
* nm.some(list, patterns[, options]);
*
* console.log(nm.some(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
* // true
* console.log(nm.some(['foo.js'], ['*.js', '!foo.js']));
* // false
* ```
* @param {String|Array} `list` The string or array of strings to test. Returns as soon as the first match is found.
* @param {String|Array} `patterns` One or more glob patterns to use for matching.
* @param {Object} `options` See available [options](#options) for changing how matches are performed
* @return {Boolean} Returns true if any patterns match `str`
* @api public
*/
nanomatch.some = function(list, patterns, options) {
if (typeof list === 'string') {
list = [list];
}
for (var i = 0; i < list.length; i++) {
if (nanomatch(list[i], patterns, options).length === 1) {
return true;
}
}
return false;
};
/**
* Returns true if every element in the given `list` matches
* at least one of the given glob `patterns`.
*
* ```js
* var nm = require('nanomatch');
* nm.every(list, patterns[, options]);
*
* console.log(nm.every('foo.js', ['foo.js']));
* // true
* console.log(nm.every(['foo.js', 'bar.js'], ['*.js']));
* // true
* console.log(nm.every(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
* // false
* console.log(nm.every(['foo.js'], ['*.js', '!foo.js']));
* // false
* ```
* @param {String|Array} `list` The string or array of strings to test.
* @param {String|Array} `patterns` One or more glob patterns to use for matching.
* @param {Object} `options` See available [options](#options) for changing how matches are performed
* @return {Boolean} Returns true if any patterns match `str`
* @api public
*/
nanomatch.every = function(list, patterns, options) {
if (typeof list === 'string') {
list = [list];
}
for (var i = 0; i < list.length; i++) {
if (nanomatch(list[i], patterns, options).length !== 1) {
return false;
}
}
return true;
};
/**
* Returns true if **any** of the given glob `patterns`
* match the specified `string`.
*
* ```js
* var nm = require('nanomatch');
* nm.any(string, patterns[, options]);
*
* console.log(nm.any('a.a', ['b.*', '*.a']));
* //=> true
* console.log(nm.any('a.a', 'b.*'));
* //=> false
* ```
* @param {String|Array} `str` The string to test.
* @param {String|Array} `patterns` One or more glob patterns to use for matching.
* @param {Object} `options` See available [options](#options) for changing how matches are performed
* @return {Boolean} Returns true if any patterns match `str`
* @api public
*/
nanomatch.any = function(str, patterns, options) {
if (typeof str !== 'string') {
throw new TypeError('expected a string: "' + util.inspect(str) + '"');
}
if (utils.isEmptyString(str) || utils.isEmptyString(patterns)) {
return false;
}
if (typeof patterns === 'string') {
patterns = [patterns];
}
for (var i = 0; i < patterns.length; i++) {
if (nanomatch.isMatch(str, patterns[i], options)) {
return true;
}
}
return false;
};
/**
* Returns true if **all** of the given `patterns`
* match the specified string.
*
* ```js
* var nm = require('nanomatch');
* nm.all(string, patterns[, options]);
*
* console.log(nm.all('foo.js', ['foo.js']));
* // true
*
* console.log(nm.all('foo.js', ['*.js', '!foo.js']));
* // false
*
* console.log(nm.all('foo.js', ['*.js', 'foo.js']));
* // true
*
* console.log(nm.all('foo.js', ['*.js', 'f*', '*o*', '*o.js']));
* // true
* ```
* @param {String|Array} `str` The string to test.
* @param {String|Array} `patterns` One or more glob patterns to use for matching.
* @param {Object} `options` See available [options](#options) for changing how matches are performed
* @return {Boolean} Returns true if any patterns match `str`
* @api public
*/
nanomatch.all = function(str, patterns, options) {
if (typeof str !== 'string') {
throw new TypeError('expected a string: "' + util.inspect(str) + '"');
}
if (typeof patterns === 'string') {
patterns = [patterns];
}
for (var i = 0; i < patterns.length; i++) {
if (!nanomatch.isMatch(str, patterns[i], options)) {
return false;
}
}
return true;
};
/**
* Returns a list of strings that _**do not match any**_ of the given `patterns`.
*
* ```js
* var nm = require('nanomatch');
* nm.not(list, patterns[, options]);
*
* console.log(nm.not(['a.a', 'b.b', 'c.c'], '*.a'));
* //=> ['b.b', 'c.c']
* ```
* @param {Array} `list` Array of strings to match.
* @param {String|Array} `patterns` One or more glob pattern to use for matching.
* @param {Object} `options` See available [options](#options) for changing how matches are performed
* @return {Array} Returns an array of strings that **do not match** the given patterns.
* @api public
*/
nanomatch.not = function(list, patterns, options) {
var opts = extend({}, options);
var ignore = opts.ignore;
delete opts.ignore;
list = utils.arrayify(list);
var matches = utils.diff(list, nanomatch(list, patterns, opts));
if (ignore) {
matches = utils.diff(matches, nanomatch(list, ignore));
}
return opts.nodupes !== false ? utils.unique(matches) : matches;
};
/**
* Returns true if the given `string` contains the given pattern. Similar
* to [.isMatch](#isMatch) but the pattern can match any part of the string.
*
* ```js
* var nm = require('nanomatch');
* nm.contains(string, pattern[, options]);
*
* console.log(nm.contains('aa/bb/cc', '*b'));
* //=> true
* console.log(nm.contains('aa/bb/cc', '*d'));
* //=> false
* ```
* @param {String} `str` The string to match.
* @param {String|Array} `patterns` Glob pattern to use for matching.
* @param {Object} `options` See available [options](#options) for changing how matches are performed
* @return {Boolean} Returns true if the patter matches any part of `str`.
* @api public
*/
nanomatch.contains = function(str, patterns, options) {
if (typeof str !== 'string') {
throw new TypeError('expected a string: "' + util.inspect(str) + '"');
}
if (typeof patterns === 'string') {
if (utils.isEmptyString(str) || utils.isEmptyString(patterns)) {
return false;
}
var equals = utils.equalsPattern(patterns, options);
if (equals(str)) {
return true;
}
var contains = utils.containsPattern(patterns, options);
if (contains(str)) {
return true;
}
}
var opts = extend({}, options, {contains: true});
return nanomatch.any(str, patterns, opts);
};
/**
* Returns true if the given pattern and options should enable
* the `matchBase` option.
* @return {Boolean}
* @api private
*/
nanomatch.matchBase = function(pattern, options) {
if (pattern && pattern.indexOf('/') !== -1 || !options) return false;
return options.basename === true || options.matchBase === true;
};
/**
* Filter the keys of the given object with the given `glob` pattern
* and `options`. Does not attempt to match nested keys. If you need this feature,
* use [glob-object][] instead.
*
* ```js
* var nm = require('nanomatch');
* nm.matchKeys(object, patterns[, options]);
*
* var obj = { aa: 'a', ab: 'b', ac: 'c' };
* console.log(nm.matchKeys(obj, '*b'));
* //=> { ab: 'b' }
* ```
* @param {Object} `object` The object with keys to filter.
* @param {String|Array} `patterns` One or more glob patterns to use for matching.
* @param {Object} `options` See available [options](#options) for changing how matches are performed
* @return {Object} Returns an object with only keys that match the given patterns.
* @api public
*/
nanomatch.matchKeys = function(obj, patterns, options) {
if (!utils.isObject(obj)) {
throw new TypeError('expected the first argument to be an object');
}
var keys = nanomatch(Object.keys(obj), patterns, options);
return utils.pick(obj, keys);
};
/**
* Returns a memoized matcher function from the given glob `pattern` and `options`.
* The returned function takes a string to match as its only argument and returns
* true if the string is a match.
*
* ```js
* var nm = require('nanomatch');
* nm.matcher(pattern[, options]);
*
* var isMatch = nm.matcher('*.!(*a)');
* console.log(isMatch('a.a'));
* //=> false
* console.log(isMatch('a.b'));
* //=> true
* ```
* @param {String} `pattern` Glob pattern
* @param {Object} `options` See available [options](#options) for changing how matches are performed.
* @return {Function} Returns a matcher function.
* @api public
*/
nanomatch.matcher = function matcher(pattern, options) {
if (utils.isEmptyString(pattern)) {
return function() {
return false;
};
}
if (Array.isArray(pattern)) {
return compose(pattern, options, matcher);
}
// if pattern is a regex
if (pattern instanceof RegExp) {
return test(pattern);
}
// if pattern is invalid
if (!utils.isString(pattern)) {
throw new TypeError('expected pattern to be an array, string or regex');
}
// if pattern is a non-glob string
if (!utils.hasSpecialChars(pattern)) {
if (options && options.nocase === true) {
pattern = pattern.toLowerCase();
}
return utils.matchPath(pattern, options);
}
// if pattern is a glob string
var re = nanomatch.makeRe(pattern, options);
// if `options.matchBase` or `options.basename` is defined
if (nanomatch.matchBase(pattern, options)) {
return utils.matchBasename(re, options);
}
function test(regex) {
var equals = utils.equalsPattern(options);
var unixify = utils.unixify(options);
return function(str) {
if (equals(str)) {
return true;
}
if (regex.test(unixify(str))) {
return true;
}
return false;
};
}
// create matcher function
var matcherFn = test(re);
// set result object from compiler on matcher function,
// as a non-enumerable property. useful for debugging
utils.define(matcherFn, 'result', re.result);
return matcherFn;
};
/**
* Returns an array of matches captured by `pattern` in `string, or
* `null` if the pattern did not match.
*
* ```js
* var nm = require('nanomatch');
* nm.capture(pattern, string[, options]);
*
* console.log(nm.capture('test/*.js', 'test/foo.js'));
* //=> ['foo']
* console.log(nm.capture('test/*.js', 'foo/bar.css'));
* //=> null
* ```
* @param {String} `pattern` Glob pattern to use for matching.
* @param {String} `string` String to match
* @param {Object} `options` See available [options](#options) for changing how matches are performed
* @return {Boolean} Returns an array of captures if the string matches the glob pattern, otherwise `null`.
* @api public
*/
nanomatch.capture = function(pattern, str, options) {
var re = nanomatch.makeRe(pattern, extend({capture: true}, options));
var unixify = utils.unixify(options);
function match() {
return function(string) {
var match = re.exec(unixify(string));
if (!match) {
return null;
}
return match.slice(1);
};
}
var capture = memoize('capture', pattern, options, match);
return capture(str);
};
/**
* Create a regular expression from the given glob `pattern`.
*
* ```js
* var nm = require('nanomatch');
* nm.makeRe(pattern[, options]);
*
* console.log(nm.makeRe('*.js'));
* //=> /^(?:(\.[\\\/])?(?!\.)(?=.)[^\/]*?\.js)$/
* ```
* @param {String} `pattern` A glob pattern to convert to regex.
* @param {Object} `options` See available [options](#options) for changing how matches are performed.
* @return {RegExp} Returns a regex created from the given pattern.
* @api public
*/
nanomatch.makeRe = function(pattern, options) {
if (pattern instanceof RegExp) {
return pattern;
}
if (typeof pattern !== 'string') {
throw new TypeError('expected pattern to be a string');
}
if (pattern.length > MAX_LENGTH) {
throw new Error('expected pattern to be less than ' + MAX_LENGTH + ' characters');
}
function makeRe() {
var opts = utils.extend({wrap: false}, options);
var result = nanomatch.create(pattern, opts);
var regex = toRegex(result.output, opts);
utils.define(regex, 'result', result);
return regex;
}
return memoize('makeRe', pattern, options, makeRe);
};
/**
* Parses the given glob `pattern` and returns an object with the compiled `output`
* and optional source `map`.
*
* ```js
* var nm = require('nanomatch');
* nm.create(pattern[, options]);
*
* console.log(nm.create('abc/*.js'));
* // { options: { source: 'string', sourcemap: true },
* // state: {},
* // compilers:
* // { ... },
* // output: '(\\.[\\\\\\/])?abc\\/(?!\\.)(?=.)[^\\/]*?\\.js',
* // ast:
* // { type: 'root',
* // errors: [],
* // nodes:
* // [ ... ],
* // dot: false,
* // input: 'abc/*.js' },
* // parsingErrors: [],
* // map:
* // { version: 3,
* // sources: [ 'string' ],
* // names: [],
* // mappings: 'AAAA,GAAG,EAAC,kBAAC,EAAC,EAAE',
* // sourcesContent: [ 'abc/*.js' ] },
* // position: { line: 1, column: 28 },
* // content: {},
* // files: {},
* // idx: 6 }
* ```
* @param {String} `pattern` Glob pattern to parse and compile.
* @param {Object} `options` Any [options](#options) to change how parsing and compiling is performed.
* @return {Object} Returns an object with the parsed AST, compiled string and optional source map.
* @api public
*/
nanomatch.create = function(pattern, options) {
if (typeof pattern !== 'string') {
throw new TypeError('expected a string');
}
function create() {
return nanomatch.compile(nanomatch.parse(pattern, options), options);
}
return memoize('create', pattern, options, create);
};
/**
* Parse the given `str` with the given `options`.
*
* ```js
* var nm = require('nanomatch');
* nm.parse(pattern[, options]);
*
* var ast = nm.parse('a/{b,c}/d');
* console.log(ast);
* // { type: 'root',
* // errors: [],
* // input: 'a/{b,c}/d',
* // nodes:
* // [ { type: 'bos', val: '' },
* // { type: 'text', val: 'a/' },
* // { type: 'brace',
* // nodes:
* // [ { type: 'brace.open', val: '{' },
* // { type: 'text', val: 'b,c' },
* // { type: 'brace.close', val: '}' } ] },
* // { type: 'text', val: '/d' },
* // { type: 'eos', val: '' } ] }
* ```
* @param {String} `str`
* @param {Object} `options`
* @return {Object} Returns an AST
* @api public
*/
nanomatch.parse = function(pattern, options) {
if (typeof pattern !== 'string') {
throw new TypeError('expected a string');
}
function parse() {
var snapdragon = utils.instantiate(null, options);
parsers(snapdragon, options);
var ast = snapdragon.parse(pattern, options);
utils.define(ast, 'snapdragon', snapdragon);
ast.input = pattern;
return ast;
}
return memoize('parse', pattern, options, parse);
};
/**
* Compile the given `ast` or string with the given `options`.
*
* ```js
* var nm = require('nanomatch');
* nm.compile(ast[, options]);
*
* var ast = nm.parse('a/{b,c}/d');
* console.log(nm.compile(ast));
* // { options: { source: 'string' },
* // state: {},
* // compilers:
* // { eos: [Function],
* // noop: [Function],
* // bos: [Function],
* // brace: [Function],
* // 'brace.open': [Function],
* // text: [Function],
* // 'brace.close': [Function] },
* // output: [ 'a/(b|c)/d' ],
* // ast:
* // { ... },
* // parsingErrors: [] }
* ```
* @param {Object|String} `ast`
* @param {Object} `options`
* @return {Object} Returns an object that has an `output` property with the compiled string.
* @api public
*/
nanomatch.compile = function(ast, options) {
if (typeof ast === 'string') {
ast = nanomatch.parse(ast, options);
}
function compile() {
var snapdragon = utils.instantiate(ast, options);
compilers(snapdragon, options);
return snapdragon.compile(ast, options);
}
return memoize('compile', ast.input, options, compile);
};
/**
* Clear the regex cache.
*
* ```js
* nm.clearCache();
* ```
* @api public
*/
nanomatch.clearCache = function() {
nanomatch.cache.__data__ = {};
};
/**
* Compose a matcher function with the given patterns.
* This allows matcher functions to be compiled once and
* called multiple times.
*/
function compose(patterns, options, matcher) {
var matchers;
return memoize('compose', String(patterns), options, function() {
return function(file) {
// delay composition until it's invoked the first time,
// after that it won't be called again
if (!matchers) {
matchers = [];
for (var i = 0; i < patterns.length; i++) {
matchers.push(matcher(patterns[i], options));
}
}
var len = matchers.length;
while (len--) {
if (matchers[len](file) === true) {
return true;
}
}
return false;
};
});
}
/**
* Memoize a generated regex or function. A unique key is generated
* from the `type` (usually method name), the `pattern`, and
* user-defined options.
*/
function memoize(type, pattern, options, fn) {
var key = utils.createKey(type + '=' + pattern, options);
if (options && options.cache === false) {
return fn(pattern, options);
}
if (cache.has(type, key)) {
return cache.get(type, key);
}
var val = fn(pattern, options);
cache.set(type, key, val);
return val;
}
/**
* Expose compiler, parser and cache on `nanomatch`
*/
nanomatch.compilers = compilers;
nanomatch.parsers = parsers;
nanomatch.cache = cache;
/**
* Expose `nanomatch`
* @type {Function}
*/
module.exports = nanomatch;

1
node_modules/nanomatch/lib/cache.js generated vendored
View file

@ -1 +0,0 @@
module.exports = new (require('fragment-cache'))();

339
node_modules/nanomatch/lib/compilers.js generated vendored
View file

@ -1,339 +0,0 @@
'use strict';
/**
* Nanomatch compilers
*/
module.exports = function(nanomatch, options) {
function slash() {
if (options && typeof options.slash === 'string') {
return options.slash;
}
if (options && typeof options.slash === 'function') {
return options.slash.call(nanomatch);
}
return '\\\\/';
}
function star() {
if (options && typeof options.star === 'string') {
return options.star;
}
if (options && typeof options.star === 'function') {
return options.star.call(nanomatch);
}
return '[^' + slash() + ']*?';
}
var ast = nanomatch.ast = nanomatch.parser.ast;
ast.state = nanomatch.parser.state;
nanomatch.compiler.state = ast.state;
nanomatch.compiler
/**
* Negation / escaping
*/
.set('not', function(node) {
var prev = this.prev();
if (this.options.nonegate === true || prev.type !== 'bos') {
return this.emit('\\' + node.val, node);
}
return this.emit(node.val, node);
})
.set('escape', function(node) {
if (this.options.unescape && /^[-\w_.]/.test(node.val)) {
return this.emit(node.val, node);
}
return this.emit('\\' + node.val, node);
})
.set('quoted', function(node) {
return this.emit(node.val, node);
})
/**
* Regex
*/
.set('dollar', function(node) {
if (node.parent.type === 'bracket') {
return this.emit(node.val, node);
}
return this.emit('\\' + node.val, node);
})
/**
* Dot: "."
*/
.set('dot', function(node) {
if (node.dotfiles === true) this.dotfiles = true;
return this.emit('\\' + node.val, node);
})
/**
* Slashes: "/" and "\"
*/
.set('backslash', function(node) {
return this.emit(node.val, node);
})
.set('slash', function(node, nodes, i) {
var val = '[' + slash() + ']';
var parent = node.parent;
var prev = this.prev();
// set "node.hasSlash" to true on all ancestor parens nodes
while (parent.type === 'paren' && !parent.hasSlash) {
parent.hasSlash = true;
parent = parent.parent;
}
if (prev.addQmark) {
val += '?';
}
// word boundary
if (node.rest.slice(0, 2) === '\\b') {
return this.emit(val, node);
}
// globstars
if (node.parsed === '**' || node.parsed === './**') {
this.output = '(?:' + this.output;
return this.emit(val + ')?', node);
}
// negation
if (node.parsed === '!**' && this.options.nonegate !== true) {
return this.emit(val + '?\\b', node);
}
return this.emit(val, node);
})
/**
* Square brackets
*/
.set('bracket', function(node) {
var close = node.close;
var open = !node.escaped ? '[' : '\\[';
var negated = node.negated;
var inner = node.inner;
var val = node.val;
if (node.escaped === true) {
inner = inner.replace(/\\?(\W)/g, '\\$1');
negated = '';
}
if (inner === ']-') {
inner = '\\]\\-';
}
if (negated && inner.indexOf('.') === -1) {
inner += '.';
}
if (negated && inner.indexOf('/') === -1) {
inner += '/';
}
val = open + negated + inner + close;
return this.emit(val, node);
})
/**
* Square: "[.]" (only matches a single character in brackets)
*/
.set('square', function(node) {
var val = (/^\W/.test(node.val) ? '\\' : '') + node.val;
return this.emit(val, node);
})
/**
* Question mark: "?"
*/
.set('qmark', function(node) {
var prev = this.prev();
// don't use "slash" variable so that we always avoid
// matching backslashes and slashes with a qmark
var val = '[^.\\\\/]';
if (this.options.dot || (prev.type !== 'bos' && prev.type !== 'slash')) {
val = '[^\\\\/]';
}
if (node.parsed.slice(-1) === '(') {
var ch = node.rest.charAt(0);
if (ch === '!' || ch === '=' || ch === ':') {
return this.emit(node.val, node);
}
}
if (node.val.length > 1) {
val += '{' + node.val.length + '}';
}
return this.emit(val, node);
})
/**
* Plus
*/
.set('plus', function(node) {
var prev = node.parsed.slice(-1);
if (prev === ']' || prev === ')') {
return this.emit(node.val, node);
}
if (!this.output || (/[?*+]/.test(ch) && node.parent.type !== 'bracket')) {
return this.emit('\\+', node);
}
var ch = this.output.slice(-1);
if (/\w/.test(ch) && !node.inside) {
return this.emit('+\\+?', node);
}
return this.emit('+', node);
})
/**
* globstar: '**'
*/
.set('globstar', function(node, nodes, i) {
if (!this.output) {
this.state.leadingGlobstar = true;
}
var prev = this.prev();
var before = this.prev(2);
var next = this.next();
var after = this.next(2);
var type = prev.type;
var val = node.val;
if (prev.type === 'slash' && next.type === 'slash') {
if (before.type === 'text') {
this.output += '?';
if (after.type !== 'text') {
this.output += '\\b';
}
}
}
var parsed = node.parsed;
if (parsed.charAt(0) === '!') {
parsed = parsed.slice(1);
}
var isInside = node.isInside.paren || node.isInside.brace;
if (parsed && type !== 'slash' && type !== 'bos' && !isInside) {
val = star();
} else {
val = this.options.dot !== true
? '(?:(?!(?:[' + slash() + ']|^)\\.).)*?'
: '(?:(?!(?:[' + slash() + ']|^)(?:\\.{1,2})($|[' + slash() + ']))(?!\\.{2}).)*?';
}
if ((type === 'slash' || type === 'bos') && this.options.dot !== true) {
val = '(?!\\.)' + val;
}
if (prev.type === 'slash' && next.type === 'slash' && before.type !== 'text') {
if (after.type === 'text' || after.type === 'star') {
node.addQmark = true;
}
}
if (this.options.capture) {
val = '(' + val + ')';
}
return this.emit(val, node);
})
/**
* Star: "*"
*/
.set('star', function(node, nodes, i) {
var prior = nodes[i - 2] || {};
var prev = this.prev();
var next = this.next();
var type = prev.type;
function isStart(n) {
return n.type === 'bos' || n.type === 'slash';
}
if (this.output === '' && this.options.contains !== true) {
this.output = '(?![' + slash() + '])';
}
if (type === 'bracket' && this.options.bash === false) {
var str = next && next.type === 'bracket' ? star() : '*?';
if (!prev.nodes || prev.nodes[1].type !== 'posix') {
return this.emit(str, node);
}
}
var prefix = !this.dotfiles && type !== 'text' && type !== 'escape'
? (this.options.dot ? '(?!(?:^|[' + slash() + '])\\.{1,2}(?:$|[' + slash() + ']))' : '(?!\\.)')
: '';
if (isStart(prev) || (isStart(prior) && type === 'not')) {
if (prefix !== '(?!\\.)') {
prefix += '(?!(\\.{2}|\\.[' + slash() + ']))(?=.)';
} else {
prefix += '(?=.)';
}
} else if (prefix === '(?!\\.)') {
prefix = '';
}
if (prev.type === 'not' && prior.type === 'bos' && this.options.dot === true) {
this.output = '(?!\\.)' + this.output;
}
var output = prefix + star();
if (this.options.capture) {
output = '(' + output + ')';
}
return this.emit(output, node);
})
/**
* Text
*/
.set('text', function(node) {
return this.emit(node.val, node);
})
/**
* End-of-string
*/
.set('eos', function(node) {
var prev = this.prev();
var val = node.val;
this.output = '(?:\\.[' + slash() + '](?=.))?' + this.output;
if (this.state.metachar && prev.type !== 'qmark' && prev.type !== 'slash') {
val += (this.options.contains ? '[' + slash() + ']?' : '(?:[' + slash() + ']|$)');
}
return this.emit(val, node);
});
/**
* Allow custom compilers to be passed on options
*/
if (options && typeof options.compilers === 'function') {
options.compilers(nanomatch.compiler);
}
};

386
node_modules/nanomatch/lib/parsers.js generated vendored
View file

@ -1,386 +0,0 @@
'use strict';
var regexNot = require('regex-not');
var toRegex = require('to-regex');
/**
* Characters to use in negation regex (we want to "not" match
* characters that are matched by other parsers)
*/
var cached;
var NOT_REGEX = '[\\[!*+?$^"\'.\\\\/]+';
var not = createTextRegex(NOT_REGEX);
/**
* Nanomatch parsers
*/
module.exports = function(nanomatch, options) {
var parser = nanomatch.parser;
var opts = parser.options;
parser.state = {
slashes: 0,
paths: []
};
parser.ast.state = parser.state;
parser
/**
* Beginning-of-string
*/
.capture('prefix', function() {
if (this.parsed) return;
var m = this.match(/^\.[\\/]/);
if (!m) return;
this.state.strictOpen = !!this.options.strictOpen;
this.state.addPrefix = true;
})
/**
* Escape: "\\."
*/
.capture('escape', function() {
if (this.isInside('bracket')) return;
var pos = this.position();
var m = this.match(/^(?:\\(.)|([$^]))/);
if (!m) return;
return pos({
type: 'escape',
val: m[2] || m[1]
});
})
/**
* Quoted strings
*/
.capture('quoted', function() {
var pos = this.position();
var m = this.match(/^["']/);
if (!m) return;
var quote = m[0];
if (this.input.indexOf(quote) === -1) {
return pos({
type: 'escape',
val: quote
});
}
var tok = advanceTo(this.input, quote);
this.consume(tok.len);
return pos({
type: 'quoted',
val: tok.esc
});
})
/**
* Negations: "!"
*/
.capture('not', function() {
var parsed = this.parsed;
var pos = this.position();
var m = this.match(this.notRegex || /^!+/);
if (!m) return;
var val = m[0];
var isNegated = (val.length % 2) === 1;
if (parsed === '' && !isNegated) {
val = '';
}
// if nothing has been parsed, we know `!` is at the start,
// so we need to wrap the result in a negation regex
if (parsed === '' && isNegated && this.options.nonegate !== true) {
this.bos.val = '(?!^(?:';
this.append = ')$).*';
val = '';
}
return pos({
type: 'not',
val: val
});
})
/**
* Dot: "."
*/
.capture('dot', function() {
var parsed = this.parsed;
var pos = this.position();
var m = this.match(/^\.+/);
if (!m) return;
var val = m[0];
this.state.dot = val === '.' && (parsed === '' || parsed.slice(-1) === '/');
return pos({
type: 'dot',
dotfiles: this.state.dot,
val: val
});
})
/**
* Plus: "+"
*/
.capture('plus', /^\+(?!\()/)
/**
* Question mark: "?"
*/
.capture('qmark', function() {
var parsed = this.parsed;
var pos = this.position();
var m = this.match(/^\?+(?!\()/);
if (!m) return;
this.state.metachar = true;
this.state.qmark = true;
return pos({
type: 'qmark',
parsed: parsed,
val: m[0]
});
})
/**
* Globstar: "**"
*/
.capture('globstar', function() {
var parsed = this.parsed;
var pos = this.position();
var m = this.match(/^\*{2}(?![*(])(?=[,)/]|$)/);
if (!m) return;
var type = opts.noglobstar !== true ? 'globstar' : 'star';
var node = pos({type: type, parsed: parsed});
this.state.metachar = true;
while (this.input.slice(0, 4) === '/**/') {
this.input = this.input.slice(3);
}
node.isInside = {
brace: this.isInside('brace'),
paren: this.isInside('paren')
};
if (type === 'globstar') {
this.state.globstar = true;
node.val = '**';
} else {
this.state.star = true;
node.val = '*';
}
return node;
})
/**
* Star: "*"
*/
.capture('star', function() {
var pos = this.position();
var starRe = /^(?:\*(?![*(])|[*]{3,}(?!\()|[*]{2}(?![(/]|$)|\*(?=\*\())/;
var m = this.match(starRe);
if (!m) return;
this.state.metachar = true;
this.state.star = true;
return pos({
type: 'star',
val: m[0]
});
})
/**
* Slash: "/"
*/
.capture('slash', function() {
var pos = this.position();
var m = this.match(/^\//);
if (!m) return;
this.state.slashes++;
return pos({
type: 'slash',
val: m[0]
});
})
/**
* Backslash: "\\"
*/
.capture('backslash', function() {
var pos = this.position();
var m = this.match(/^\\(?![*+?(){}[\]'"])/);
if (!m) return;
var val = m[0];
if (this.isInside('bracket')) {
val = '\\';
} else if (val.length > 1) {
val = '\\\\';
}
return pos({
type: 'backslash',
val: val
});
})
/**
* Square: "[.]"
*/
.capture('square', function() {
if (this.isInside('bracket')) return;
var pos = this.position();
var m = this.match(/^\[([^!^\\])\]/);
if (!m) return;
return pos({
type: 'square',
val: m[1]
});
})
/**
* Brackets: "[...]" (basic, this can be overridden by other parsers)
*/
.capture('bracket', function() {
var pos = this.position();
var m = this.match(/^(?:\[([!^]?)([^\]]+|\]-)(\]|[^*+?]+)|\[)/);
if (!m) return;
var val = m[0];
var negated = m[1] ? '^' : '';
var inner = (m[2] || '').replace(/\\\\+/, '\\\\');
var close = m[3] || '';
if (m[2] && inner.length < m[2].length) {
val = val.replace(/\\\\+/, '\\\\');
}
var esc = this.input.slice(0, 2);
if (inner === '' && esc === '\\]') {
inner += esc;
this.consume(2);
var str = this.input;
var idx = -1;
var ch;
while ((ch = str[++idx])) {
this.consume(1);
if (ch === ']') {
close = ch;
break;
}
inner += ch;
}
}
return pos({
type: 'bracket',
val: val,
escaped: close !== ']',
negated: negated,
inner: inner,
close: close
});
})
/**
* Text
*/
.capture('text', function() {
if (this.isInside('bracket')) return;
var pos = this.position();
var m = this.match(not);
if (!m || !m[0]) return;
return pos({
type: 'text',
val: m[0]
});
});
/**
* Allow custom parsers to be passed on options
*/
if (options && typeof options.parsers === 'function') {
options.parsers(nanomatch.parser);
}
};
/**
* Advance to the next non-escaped character
*/
function advanceTo(input, endChar) {
var ch = input.charAt(0);
var tok = { len: 1, val: '', esc: '' };
var idx = 0;
function advance() {
if (ch !== '\\') {
tok.esc += '\\' + ch;
tok.val += ch;
}
ch = input.charAt(++idx);
tok.len++;
if (ch === '\\') {
advance();
advance();
}
}
while (ch && ch !== endChar) {
advance();
}
return tok;
}
/**
* Create text regex
*/
function createTextRegex(pattern) {
if (cached) return cached;
var opts = {contains: true, strictClose: false};
var not = regexNot.create(pattern, opts);
var re = toRegex('^(?:[*]\\((?=.)|' + not + ')', opts);
return (cached = re);
}
/**
* Expose negation string
*/
module.exports.not = NOT_REGEX;

379
node_modules/nanomatch/lib/utils.js generated vendored
View file

@ -1,379 +0,0 @@
'use strict';
var utils = module.exports;
var path = require('path');
/**
* Module dependencies
*/
var isWindows = require('is-windows')();
var Snapdragon = require('snapdragon');
utils.define = require('define-property');
utils.diff = require('arr-diff');
utils.extend = require('extend-shallow');
utils.pick = require('object.pick');
utils.typeOf = require('kind-of');
utils.unique = require('array-unique');
/**
* Returns true if the given value is effectively an empty string
*/
utils.isEmptyString = function(val) {
return String(val) === '' || String(val) === './';
};
/**
* Returns true if the platform is windows, or `path.sep` is `\\`.
* This is defined as a function to allow `path.sep` to be set in unit tests,
* or by the user, if there is a reason to do so.
* @return {Boolean}
*/
utils.isWindows = function() {
return path.sep === '\\' || isWindows === true;
};
/**
* Return the last element from an array
*/
utils.last = function(arr, n) {
return arr[arr.length - (n || 1)];
};
/**
* Get the `Snapdragon` instance to use
*/
utils.instantiate = function(ast, options) {
var snapdragon;
// if an instance was created by `.parse`, use that instance
if (utils.typeOf(ast) === 'object' && ast.snapdragon) {
snapdragon = ast.snapdragon;
// if the user supplies an instance on options, use that instance
} else if (utils.typeOf(options) === 'object' && options.snapdragon) {
snapdragon = options.snapdragon;
// create a new instance
} else {
snapdragon = new Snapdragon(options);
}
utils.define(snapdragon, 'parse', function(str, options) {
var parsed = Snapdragon.prototype.parse.call(this, str, options);
parsed.input = str;
// escape unmatched brace/bracket/parens
var last = this.parser.stack.pop();
if (last && this.options.strictErrors !== true) {
var open = last.nodes[0];
var inner = last.nodes[1];
if (last.type === 'bracket') {
if (inner.val.charAt(0) === '[') {
inner.val = '\\' + inner.val;
}
} else {
open.val = '\\' + open.val;
var sibling = open.parent.nodes[1];
if (sibling.type === 'star') {
sibling.loose = true;
}
}
}
// add non-enumerable parser reference
utils.define(parsed, 'parser', this.parser);
return parsed;
});
return snapdragon;
};
/**
* Create the key to use for memoization. The key is generated
* by iterating over the options and concatenating key-value pairs
* to the pattern string.
*/
utils.createKey = function(pattern, options) {
if (typeof options === 'undefined') {
return pattern;
}
var key = pattern;
for (var prop in options) {
if (options.hasOwnProperty(prop)) {
key += ';' + prop + '=' + String(options[prop]);
}
}
return key;
};
/**
* Cast `val` to an array
* @return {Array}
*/
utils.arrayify = function(val) {
if (typeof val === 'string') return [val];
return val ? (Array.isArray(val) ? val : [val]) : [];
};
/**
* Return true if `val` is a non-empty string
*/
utils.isString = function(val) {
return typeof val === 'string';
};
/**
* Return true if `val` is a non-empty string
*/
utils.isRegex = function(val) {
return utils.typeOf(val) === 'regexp';
};
/**
* Return true if `val` is a non-empty string
*/
utils.isObject = function(val) {
return utils.typeOf(val) === 'object';
};
/**
* Escape regex characters in the given string
*/
utils.escapeRegex = function(str) {
return str.replace(/[-[\]{}()^$|*+?.\\/\s]/g, '\\$&');
};
/**
* Combines duplicate characters in the provided `input` string.
* @param {String} `input`
* @returns {String}
*/
utils.combineDupes = function(input, patterns) {
patterns = utils.arrayify(patterns).join('|').split('|');
patterns = patterns.map(function(s) {
return s.replace(/\\?([+*\\/])/g, '\\$1');
});
var substr = patterns.join('|');
var regex = new RegExp('(' + substr + ')(?=\\1)', 'g');
return input.replace(regex, '');
};
/**
* Returns true if the given `str` has special characters
*/
utils.hasSpecialChars = function(str) {
return /(?:(?:(^|\/)[!.])|[*?+()|[\]{}]|[+@]\()/.test(str);
};
/**
* Normalize slashes in the given filepath.
*
* @param {String} `filepath`
* @return {String}
*/
utils.toPosixPath = function(str) {
return str.replace(/\\+/g, '/');
};
/**
* Strip backslashes before special characters in a string.
*
* @param {String} `str`
* @return {String}
*/
utils.unescape = function(str) {
return utils.toPosixPath(str.replace(/\\(?=[*+?!.])/g, ''));
};
/**
* Strip the drive letter from a windows filepath
* @param {String} `fp`
* @return {String}
*/
utils.stripDrive = function(fp) {
return utils.isWindows() ? fp.replace(/^[a-z]:[\\/]+?/i, '/') : fp;
};
/**
* Strip the prefix from a filepath
* @param {String} `fp`
* @return {String}
*/
utils.stripPrefix = function(str) {
if (str.charAt(0) === '.' && (str.charAt(1) === '/' || str.charAt(1) === '\\')) {
return str.slice(2);
}
return str;
};
/**
* Returns true if `str` is a common character that doesn't need
* to be processed to be used for matching.
* @param {String} `str`
* @return {Boolean}
*/
utils.isSimpleChar = function(str) {
return str.trim() === '' || str === '.';
};
/**
* Returns true if the given str is an escaped or
* unescaped path character
*/
utils.isSlash = function(str) {
return str === '/' || str === '\\/' || str === '\\' || str === '\\\\';
};
/**
* Returns a function that returns true if the given
* pattern matches or contains a `filepath`
*
* @param {String} `pattern`
* @return {Function}
*/
utils.matchPath = function(pattern, options) {
return (options && options.contains)
? utils.containsPattern(pattern, options)
: utils.equalsPattern(pattern, options);
};
/**
* Returns true if the given (original) filepath or unixified path are equal
* to the given pattern.
*/
utils._equals = function(filepath, unixPath, pattern) {
return pattern === filepath || pattern === unixPath;
};
/**
* Returns true if the given (original) filepath or unixified path contain
* the given pattern.
*/
utils._contains = function(filepath, unixPath, pattern) {
return filepath.indexOf(pattern) !== -1 || unixPath.indexOf(pattern) !== -1;
};
/**
* Returns a function that returns true if the given
* pattern is the same as a given `filepath`
*
* @param {String} `pattern`
* @return {Function}
*/
utils.equalsPattern = function(pattern, options) {
var unixify = utils.unixify(options);
options = options || {};
return function fn(filepath) {
var equal = utils._equals(filepath, unixify(filepath), pattern);
if (equal === true || options.nocase !== true) {
return equal;
}
var lower = filepath.toLowerCase();
return utils._equals(lower, unixify(lower), pattern);
};
};
/**
* Returns a function that returns true if the given
* pattern contains a `filepath`
*
* @param {String} `pattern`
* @return {Function}
*/
utils.containsPattern = function(pattern, options) {
var unixify = utils.unixify(options);
options = options || {};
return function(filepath) {
var contains = utils._contains(filepath, unixify(filepath), pattern);
if (contains === true || options.nocase !== true) {
return contains;
}
var lower = filepath.toLowerCase();
return utils._contains(lower, unixify(lower), pattern);
};
};
/**
* Returns a function that returns true if the given
* regex matches the `filename` of a file path.
*
* @param {RegExp} `re` Matching regex
* @return {Function}
*/
utils.matchBasename = function(re) {
return function(filepath) {
return re.test(filepath) || re.test(path.basename(filepath));
};
};
/**
* Returns the given value unchanced.
* @return {any}
*/
utils.identity = function(val) {
return val;
};
/**
* Determines the filepath to return based on the provided options.
* @return {any}
*/
utils.value = function(str, unixify, options) {
if (options && options.unixify === false) {
return str;
}
if (options && typeof options.unixify === 'function') {
return options.unixify(str);
}
return unixify(str);
};
/**
* Returns a function that normalizes slashes in a string to forward
* slashes, strips `./` from beginning of paths, and optionally unescapes
* special characters.
* @return {Function}
*/
utils.unixify = function(options) {
var opts = options || {};
return function(filepath) {
if (opts.stripPrefix !== false) {
filepath = utils.stripPrefix(filepath);
}
if (opts.unescape === true) {
filepath = utils.unescape(filepath);
}
if (opts.unixify === true || utils.isWindows()) {
filepath = utils.toPosixPath(filepath);
}
return filepath;
};
};

138
node_modules/nanomatch/package.json generated vendored
View file

@ -1,138 +0,0 @@
{
"name": "nanomatch",
"description": "Fast, minimal glob matcher for node.js. Similar to micromatch, minimatch and multimatch, but complete Bash 4.3 wildcard support only (no support for exglobs, posix brackets or braces)",
"version": "1.2.13",
"homepage": "https://github.com/micromatch/nanomatch",
"author": "Jon Schlinkert (https://github.com/jonschlinkert)",
"contributors": [
"Devon Govett (http://badassjs.com)",
"Jon Schlinkert (http://twitter.com/jonschlinkert)"
],
"repository": "micromatch/nanomatch",
"bugs": {
"url": "https://github.com/micromatch/nanomatch/issues"
},
"license": "MIT",
"files": [
"index.js",
"lib"
],
"main": "index.js",
"engines": {
"node": ">=0.10.0"
},
"scripts": {
"test": "mocha"
},
"dependencies": {
"arr-diff": "^4.0.0",
"array-unique": "^0.3.2",
"define-property": "^2.0.2",
"extend-shallow": "^3.0.2",
"fragment-cache": "^0.2.1",
"is-windows": "^1.0.2",
"kind-of": "^6.0.2",
"object.pick": "^1.3.0",
"regex-not": "^1.0.0",
"snapdragon": "^0.8.1",
"to-regex": "^3.0.1"
},
"devDependencies": {
"bash-match": "^1.0.2",
"for-own": "^1.0.0",
"gulp": "^3.9.1",
"gulp-format-md": "^1.0.0",
"gulp-istanbul": "^1.1.3",
"gulp-mocha": "^5.0.0",
"helper-changelog": "^0.3.0",
"minimatch": "^3.0.4",
"minimist": "^1.2.0",
"mocha": "^3.5.3",
"multimatch": "^2.1.0"
},
"keywords": [
"bash",
"expand",
"expansion",
"expression",
"file",
"files",
"filter",
"find",
"glob",
"globbing",
"globs",
"globstar",
"match",
"matcher",
"matches",
"matching",
"micromatch",
"minimatch",
"multimatch",
"nanomatch",
"path",
"pattern",
"patterns",
"regex",
"regexp",
"regular",
"shell",
"wildcard"
],
"lintDeps": {
"dependencies": {
"options": {
"lock": {
"snapdragon": "^0.8.1"
}
}
},
"devDependencies": {
"files": {
"options": {
"ignore": [
"benchmark/**"
]
}
}
}
},
"verb": {
"toc": "collapsible",
"layout": "default",
"tasks": [
"readme"
],
"helpers": [
"helper-changelog"
],
"plugins": [
"gulp-format-md"
],
"related": {
"list": [
"extglob",
"is-extglob",
"is-glob",
"micromatch"
]
},
"reflinks": [
"expand-brackets",
"expand-tilde",
"glob-object",
"micromatch",
"minimatch",
"options",
"snapdragon"
],
"lint": {
"reflinks": true
}
}
,"_resolved": "https://registry.npmjs.org/nanomatch/-/nanomatch-1.2.13.tgz"
,"_integrity": "sha512-fpoe2T0RbHwBTBUOftAfBPaDEi06ufaUai0mE6Yn1kacc3SnTErfb/h+X94VXzI64rKFHYImXSvdwGGCmwOqCA=="
,"_from": "nanomatch@1.2.13"
}