Server IP : 108.163.255.210 / Your IP : 18.119.166.34 Web Server : Apache System : Linux blossom.urlnameserver.com 3.10.0-1160.80.1.el7.x86_64 #1 SMP Tue Nov 8 15:48:59 UTC 2022 x86_64 User : ( 1172) PHP Version : 7.2.34 Disable Function : eval,escapeshellarg,proc_close,proc_get_status,proc_nice,proc_open,symlink,system,pcntl_exec,getrusage,chown,chgp,closelog,openlog,syslog,define_syslog_variables,php_ini_loaded_file,getservbyname,getservbyport,posix_getgid,posix_getgrgid,proc_terminate,pfsockopen,apache_child_terminate,posix_mkfifo,posix_setpgid,posix_setuid,hypot,pg_host,pos,posix_access,posix_getcwd,posix_getservbyname,myshellexec,getpid,posix_getsid,posix_isatty,posix_kill,posix_mknod,posix_setgid,posix_setsid,posix_setuid,posix_times,posix_uname,ps_fill,posix_getpwuid,global,ini_restore,zip_open,zip_read,rar_open,bzopen,bzread,bzwrite,apache_get_modules,apache_get_version,phpversionphpinfo,php_ini_scanned_files,get_current_user,disk_total_space,diskfreespace,leak,imap_list,hypo,filedump,safe_mode,getmygid,apache_getenv,apache_setenv,bzread,bzwrite,bzopen,phpini,higlight_file,dos_conv,get_cwd,er_log,cmd,e_name,vdir,get_dir,only_read,ftok,ftpexec,posix_getpwnam,mysql_list_dbs,disk_free_space,session_save_path,confirm_phpdoc_compiled,zip_entry_rea,php_u,psockopen,crack_opendict,crack_getlastmessage,crack_closedict,crack_check,fpassthru,posix_get_last_error,posix_getlogin,posix_getgroups,posix_strerror,posix_getrlimit,posix_getpgrp,posix_getgrnam,pos,dl MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : ON | Sudo : ON | Pkexec : ON Directory : /home/unilinki/public_html/indijourneys.com/node_modules/nanomatch/ |
Upload File : |
'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;