🐛 Update: Added support for the 'find' command in settings.local.json. Enhanced logging for various modules, including initialization and performance metrics. Improved SQLite database optimization and ensured better tracking of user interactions and system processes. 📚
This commit is contained in:
877
network-visualization/node_modules/micromatch/index.js
generated
vendored
Normal file
877
network-visualization/node_modules/micromatch/index.js
generated
vendored
Normal file
@@ -0,0 +1,877 @@
|
||||
'use strict';
|
||||
|
||||
/**
|
||||
* Module dependencies
|
||||
*/
|
||||
|
||||
var util = require('util');
|
||||
var braces = require('braces');
|
||||
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 mm = require('micromatch');
|
||||
* mm(list, patterns[, options]);
|
||||
*
|
||||
* console.log(mm(['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 micromatch(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 micromatch.match(list, patterns[0], options);
|
||||
}
|
||||
|
||||
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, micromatch.match(list, pattern.slice(1), options));
|
||||
} else {
|
||||
keep.push.apply(keep, micromatch.match(list, pattern, options));
|
||||
}
|
||||
}
|
||||
|
||||
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 mm = require('micromatch');
|
||||
* mm.match(list, pattern[, options]);
|
||||
*
|
||||
* console.log(mm.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
|
||||
*/
|
||||
|
||||
micromatch.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, micromatch.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 = micromatch.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 mm = require('micromatch');
|
||||
* mm.isMatch(string, pattern[, options]);
|
||||
*
|
||||
* console.log(mm.isMatch('a.a', '*.a'));
|
||||
* //=> true
|
||||
* console.log(mm.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
|
||||
*/
|
||||
|
||||
micromatch.isMatch = function(str, pattern, options) {
|
||||
if (typeof str !== 'string') {
|
||||
throw new TypeError('expected a string: "' + util.inspect(str) + '"');
|
||||
}
|
||||
|
||||
if (isEmptyString(str) || isEmptyString(pattern)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
var equals = utils.equalsPattern(options);
|
||||
if (equals(str)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
var isMatch = memoize('isMatch', pattern, options, micromatch.matcher);
|
||||
return isMatch(str);
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns true if some of the strings in the given `list` match any of the
|
||||
* given glob `patterns`.
|
||||
*
|
||||
* ```js
|
||||
* var mm = require('micromatch');
|
||||
* mm.some(list, patterns[, options]);
|
||||
*
|
||||
* console.log(mm.some(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
|
||||
* // true
|
||||
* console.log(mm.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
|
||||
*/
|
||||
|
||||
micromatch.some = function(list, patterns, options) {
|
||||
if (typeof list === 'string') {
|
||||
list = [list];
|
||||
}
|
||||
for (var i = 0; i < list.length; i++) {
|
||||
if (micromatch(list[i], patterns, options).length === 1) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns true if every string in the given `list` matches
|
||||
* any of the given glob `patterns`.
|
||||
*
|
||||
* ```js
|
||||
* var mm = require('micromatch');
|
||||
* mm.every(list, patterns[, options]);
|
||||
*
|
||||
* console.log(mm.every('foo.js', ['foo.js']));
|
||||
* // true
|
||||
* console.log(mm.every(['foo.js', 'bar.js'], ['*.js']));
|
||||
* // true
|
||||
* console.log(mm.every(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
|
||||
* // false
|
||||
* console.log(mm.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
|
||||
*/
|
||||
|
||||
micromatch.every = function(list, patterns, options) {
|
||||
if (typeof list === 'string') {
|
||||
list = [list];
|
||||
}
|
||||
for (var i = 0; i < list.length; i++) {
|
||||
if (micromatch(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 mm = require('micromatch');
|
||||
* mm.any(string, patterns[, options]);
|
||||
*
|
||||
* console.log(mm.any('a.a', ['b.*', '*.a']));
|
||||
* //=> true
|
||||
* console.log(mm.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
|
||||
*/
|
||||
|
||||
micromatch.any = function(str, patterns, options) {
|
||||
if (typeof str !== 'string') {
|
||||
throw new TypeError('expected a string: "' + util.inspect(str) + '"');
|
||||
}
|
||||
|
||||
if (isEmptyString(str) || isEmptyString(patterns)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (typeof patterns === 'string') {
|
||||
patterns = [patterns];
|
||||
}
|
||||
|
||||
for (var i = 0; i < patterns.length; i++) {
|
||||
if (micromatch.isMatch(str, patterns[i], options)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns true if **all** of the given `patterns` match
|
||||
* the specified string.
|
||||
*
|
||||
* ```js
|
||||
* var mm = require('micromatch');
|
||||
* mm.all(string, patterns[, options]);
|
||||
*
|
||||
* console.log(mm.all('foo.js', ['foo.js']));
|
||||
* // true
|
||||
*
|
||||
* console.log(mm.all('foo.js', ['*.js', '!foo.js']));
|
||||
* // false
|
||||
*
|
||||
* console.log(mm.all('foo.js', ['*.js', 'foo.js']));
|
||||
* // true
|
||||
*
|
||||
* console.log(mm.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
|
||||
*/
|
||||
|
||||
micromatch.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 (!micromatch.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 mm = require('micromatch');
|
||||
* mm.not(list, patterns[, options]);
|
||||
*
|
||||
* console.log(mm.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
|
||||
*/
|
||||
|
||||
micromatch.not = function(list, patterns, options) {
|
||||
var opts = extend({}, options);
|
||||
var ignore = opts.ignore;
|
||||
delete opts.ignore;
|
||||
|
||||
var unixify = utils.unixify(opts);
|
||||
list = utils.arrayify(list).map(unixify);
|
||||
|
||||
var matches = utils.diff(list, micromatch(list, patterns, opts));
|
||||
if (ignore) {
|
||||
matches = utils.diff(matches, micromatch(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 mm = require('micromatch');
|
||||
* mm.contains(string, pattern[, options]);
|
||||
*
|
||||
* console.log(mm.contains('aa/bb/cc', '*b'));
|
||||
* //=> true
|
||||
* console.log(mm.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
|
||||
*/
|
||||
|
||||
micromatch.contains = function(str, patterns, options) {
|
||||
if (typeof str !== 'string') {
|
||||
throw new TypeError('expected a string: "' + util.inspect(str) + '"');
|
||||
}
|
||||
|
||||
if (typeof patterns === 'string') {
|
||||
if (isEmptyString(str) || 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 micromatch.any(str, patterns, opts);
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns true if the given pattern and options should enable
|
||||
* the `matchBase` option.
|
||||
* @return {Boolean}
|
||||
* @api private
|
||||
*/
|
||||
|
||||
micromatch.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 mm = require('micromatch');
|
||||
* mm.matchKeys(object, patterns[, options]);
|
||||
*
|
||||
* var obj = { aa: 'a', ab: 'b', ac: 'c' };
|
||||
* console.log(mm.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
|
||||
*/
|
||||
|
||||
micromatch.matchKeys = function(obj, patterns, options) {
|
||||
if (!utils.isObject(obj)) {
|
||||
throw new TypeError('expected the first argument to be an object');
|
||||
}
|
||||
var keys = micromatch(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 mm = require('micromatch');
|
||||
* mm.matcher(pattern[, options]);
|
||||
*
|
||||
* var isMatch = mm.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
|
||||
*/
|
||||
|
||||
micromatch.matcher = function matcher(pattern, options) {
|
||||
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 = micromatch.makeRe(pattern, options);
|
||||
|
||||
// if `options.matchBase` or `options.basename` is defined
|
||||
if (micromatch.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;
|
||||
};
|
||||
}
|
||||
|
||||
var fn = test(re);
|
||||
Object.defineProperty(fn, 'result', {
|
||||
configurable: true,
|
||||
enumerable: false,
|
||||
value: re.result
|
||||
});
|
||||
return fn;
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns an array of matches captured by `pattern` in `string, or `null` if the pattern did not match.
|
||||
*
|
||||
* ```js
|
||||
* var mm = require('micromatch');
|
||||
* mm.capture(pattern, string[, options]);
|
||||
*
|
||||
* console.log(mm.capture('test/*.js', 'test/foo.js'));
|
||||
* //=> ['foo']
|
||||
* console.log(mm.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
|
||||
*/
|
||||
|
||||
micromatch.capture = function(pattern, str, options) {
|
||||
var re = micromatch.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 mm = require('micromatch');
|
||||
* mm.makeRe(pattern[, options]);
|
||||
*
|
||||
* console.log(mm.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
|
||||
*/
|
||||
|
||||
micromatch.makeRe = function(pattern, options) {
|
||||
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 result = micromatch.create(pattern, options);
|
||||
var ast_array = [];
|
||||
var output = result.map(function(obj) {
|
||||
obj.ast.state = obj.state;
|
||||
ast_array.push(obj.ast);
|
||||
return obj.output;
|
||||
});
|
||||
|
||||
var regex = toRegex(output.join('|'), options);
|
||||
Object.defineProperty(regex, 'result', {
|
||||
configurable: true,
|
||||
enumerable: false,
|
||||
value: ast_array
|
||||
});
|
||||
return regex;
|
||||
}
|
||||
|
||||
return memoize('makeRe', pattern, options, makeRe);
|
||||
};
|
||||
|
||||
/**
|
||||
* Expand the given brace `pattern`.
|
||||
*
|
||||
* ```js
|
||||
* var mm = require('micromatch');
|
||||
* console.log(mm.braces('foo/{a,b}/bar'));
|
||||
* //=> ['foo/(a|b)/bar']
|
||||
*
|
||||
* console.log(mm.braces('foo/{a,b}/bar', {expand: true}));
|
||||
* //=> ['foo/(a|b)/bar']
|
||||
* ```
|
||||
* @param {String} `pattern` String with brace pattern to expand.
|
||||
* @param {Object} `options` Any [options](#options) to change how expansion is performed. See the [braces][] library for all available options.
|
||||
* @return {Array}
|
||||
* @api public
|
||||
*/
|
||||
|
||||
micromatch.braces = function(pattern, options) {
|
||||
if (typeof pattern !== 'string' && !Array.isArray(pattern)) {
|
||||
throw new TypeError('expected pattern to be an array or string');
|
||||
}
|
||||
|
||||
function expand() {
|
||||
if (options && options.nobrace === true || !/\{.*\}/.test(pattern)) {
|
||||
return utils.arrayify(pattern);
|
||||
}
|
||||
return braces(pattern, options);
|
||||
}
|
||||
|
||||
return memoize('braces', pattern, options, expand);
|
||||
};
|
||||
|
||||
/**
|
||||
* Proxy to the [micromatch.braces](#method), for parity with
|
||||
* minimatch.
|
||||
*/
|
||||
|
||||
micromatch.braceExpand = function(pattern, options) {
|
||||
var opts = extend({}, options, {expand: true});
|
||||
return micromatch.braces(pattern, opts);
|
||||
};
|
||||
|
||||
/**
|
||||
* Parses the given glob `pattern` and returns an array of abstract syntax
|
||||
* trees (ASTs), with the compiled `output` and optional source `map` on
|
||||
* each AST.
|
||||
*
|
||||
* ```js
|
||||
* var mm = require('micromatch');
|
||||
* mm.create(pattern[, options]);
|
||||
*
|
||||
* console.log(mm.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
|
||||
*/
|
||||
|
||||
micromatch.create = function(pattern, options) {
|
||||
return memoize('create', pattern, options, function() {
|
||||
function create(str, opts) {
|
||||
return micromatch.compile(micromatch.parse(str, opts), opts);
|
||||
}
|
||||
|
||||
pattern = micromatch.braces(pattern, options);
|
||||
var len = pattern.length;
|
||||
var idx = -1;
|
||||
var res = [];
|
||||
|
||||
while (++idx < len) {
|
||||
res.push(create(pattern[idx], options));
|
||||
}
|
||||
return res;
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* Parse the given `str` with the given `options`.
|
||||
*
|
||||
* ```js
|
||||
* var mm = require('micromatch');
|
||||
* mm.parse(pattern[, options]);
|
||||
*
|
||||
* var ast = mm.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
|
||||
*/
|
||||
|
||||
micromatch.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 mm = require('micromatch');
|
||||
* mm.compile(ast[, options]);
|
||||
*
|
||||
* var ast = mm.parse('a/{b,c}/d');
|
||||
* console.log(mm.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
|
||||
*/
|
||||
|
||||
micromatch.compile = function(ast, options) {
|
||||
if (typeof ast === 'string') {
|
||||
ast = micromatch.parse(ast, options);
|
||||
}
|
||||
|
||||
return memoize('compile', ast.input, options, function() {
|
||||
var snapdragon = utils.instantiate(ast, options);
|
||||
compilers(snapdragon, options);
|
||||
return snapdragon.compile(ast, options);
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* Clear the regex cache.
|
||||
*
|
||||
* ```js
|
||||
* mm.clearCache();
|
||||
* ```
|
||||
* @api public
|
||||
*/
|
||||
|
||||
micromatch.clearCache = function() {
|
||||
micromatch.cache.caches = {};
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns true if the given value is effectively an empty string
|
||||
*/
|
||||
|
||||
function isEmptyString(val) {
|
||||
return String(val) === '' || String(val) === './';
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 `micromatch`
|
||||
*/
|
||||
|
||||
micromatch.compilers = compilers;
|
||||
micromatch.parsers = parsers;
|
||||
micromatch.caches = cache.caches;
|
||||
|
||||
/**
|
||||
* Expose `micromatch`
|
||||
* @type {Function}
|
||||
*/
|
||||
|
||||
module.exports = micromatch;
|
||||
Reference in New Issue
Block a user