mirror of
https://github.com/arthur-pbty/portfolio2023.git
synced 2026-06-15 08:13:20 +02:00
modified
This commit is contained in:
Tutur33
-57
@@ -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
@@ -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
File diff suppressed because it is too large
Load Diff
-838
@@ -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;
|
||||
-134
@@ -1,134 +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
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user