{"ast":null,"code":"'use strict';\n\nvar _toConsumableArray = require(\"D:/DSP_Management/node_modules/@babel/runtime/helpers/toConsumableArray.js\")[\"default\"];\nvar _createForOfIteratorHelper = require(\"D:/DSP_Management/node_modules/@babel/runtime/helpers/createForOfIteratorHelper.js\")[\"default\"];\nvar _objectSpread = require(\"D:/DSP_Management/node_modules/@babel/runtime/helpers/objectSpread2.js\")[\"default\"];\nvar util = require('util');\nvar braces = require('braces');\nvar picomatch = require('picomatch');\nvar utils = require('picomatch/lib/utils');\nvar isEmptyString = function isEmptyString(v) {\n  return v === '' || v === './';\n};\nvar hasBraces = function hasBraces(v) {\n  var index = v.indexOf('{');\n  return index > -1 && v.indexOf('}', index) > -1;\n};\n\n/**\n * Returns an array of strings that match one or more glob patterns.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm(list, patterns[, options]);\n *\n * console.log(mm(['a.js', 'a.txt'], ['*.js']));\n * //=> [ 'a.js' ]\n * ```\n * @param {String|Array<string>} `list` List of strings to match.\n * @param {String|Array<string>} `patterns` One or more glob patterns to use for matching.\n * @param {Object} `options` See available [options](#options)\n * @return {Array} Returns an array of matches\n * @summary false\n * @api public\n */\n\nvar micromatch = function micromatch(list, patterns, options) {\n  patterns = [].concat(patterns);\n  list = [].concat(list);\n  var omit = new Set();\n  var keep = new Set();\n  var items = new Set();\n  var negatives = 0;\n  var onResult = function onResult(state) {\n    items.add(state.output);\n    if (options && options.onResult) {\n      options.onResult(state);\n    }\n  };\n  for (var i = 0; i < patterns.length; i++) {\n    var isMatch = picomatch(String(patterns[i]), _objectSpread(_objectSpread({}, options), {}, {\n      onResult: onResult\n    }), true);\n    var negated = isMatch.state.negated || isMatch.state.negatedExtglob;\n    if (negated) negatives++;\n    var _iterator = _createForOfIteratorHelper(list),\n      _step;\n    try {\n      for (_iterator.s(); !(_step = _iterator.n()).done;) {\n        var item = _step.value;\n        var matched = isMatch(item, true);\n        var match = negated ? !matched.isMatch : matched.isMatch;\n        if (!match) continue;\n        if (negated) {\n          omit.add(matched.output);\n        } else {\n          omit[\"delete\"](matched.output);\n          keep.add(matched.output);\n        }\n      }\n    } catch (err) {\n      _iterator.e(err);\n    } finally {\n      _iterator.f();\n    }\n  }\n  var result = negatives === patterns.length ? _toConsumableArray(items) : _toConsumableArray(keep);\n  var matches = result.filter(function (item) {\n    return !omit.has(item);\n  });\n  if (options && matches.length === 0) {\n    if (options.failglob === true) {\n      throw new Error(\"No matches found for \\\"\".concat(patterns.join(', '), \"\\\"\"));\n    }\n    if (options.nonull === true || options.nullglob === true) {\n      return options.unescape ? patterns.map(function (p) {\n        return p.replace(/\\\\/g, '');\n      }) : patterns;\n    }\n  }\n  return matches;\n};\n\n/**\n * Backwards compatibility\n */\n\nmicromatch.match = micromatch;\n\n/**\n * Returns a matcher function from the given glob `pattern` and `options`.\n * The returned function takes a string to match as its only argument and returns\n * true if the string is a match.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.matcher(pattern[, options]);\n *\n * const isMatch = mm.matcher('*.!(*a)');\n * console.log(isMatch('a.a')); //=> false\n * console.log(isMatch('a.b')); //=> true\n * ```\n * @param {String} `pattern` Glob pattern\n * @param {Object} `options`\n * @return {Function} Returns a matcher function.\n * @api public\n */\n\nmicromatch.matcher = function (pattern, options) {\n  return picomatch(pattern, options);\n};\n\n/**\n * Returns true if **any** of the given glob `patterns` match the specified `string`.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.isMatch(string, patterns[, options]);\n *\n * console.log(mm.isMatch('a.a', ['b.*', '*.a'])); //=> true\n * console.log(mm.isMatch('a.a', 'b.*')); //=> false\n * ```\n * @param {String} `str` The string to test.\n * @param {String|Array} `patterns` One or more glob patterns to use for matching.\n * @param {Object} `[options]` See available [options](#options).\n * @return {Boolean} Returns true if any patterns match `str`\n * @api public\n */\n\nmicromatch.isMatch = function (str, patterns, options) {\n  return picomatch(patterns, options)(str);\n};\n\n/**\n * Backwards compatibility\n */\n\nmicromatch.any = micromatch.isMatch;\n\n/**\n * Returns a list of strings that _**do not match any**_ of the given `patterns`.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.not(list, patterns[, options]);\n *\n * console.log(mm.not(['a.a', 'b.b', 'c.c'], '*.a'));\n * //=> ['b.b', 'c.c']\n * ```\n * @param {Array} `list` Array of strings to match.\n * @param {String|Array} `patterns` One or more glob pattern to use for matching.\n * @param {Object} `options` See available [options](#options) for changing how matches are performed\n * @return {Array} Returns an array of strings that **do not match** the given patterns.\n * @api public\n */\n\nmicromatch.not = function (list, patterns) {\n  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  patterns = [].concat(patterns).map(String);\n  var result = new Set();\n  var items = [];\n  var onResult = function onResult(state) {\n    if (options.onResult) options.onResult(state);\n    items.push(state.output);\n  };\n  var matches = new Set(micromatch(list, patterns, _objectSpread(_objectSpread({}, options), {}, {\n    onResult: onResult\n  })));\n  for (var _i = 0, _items = items; _i < _items.length; _i++) {\n    var item = _items[_i];\n    if (!matches.has(item)) {\n      result.add(item);\n    }\n  }\n  return _toConsumableArray(result);\n};\n\n/**\n * Returns true if the given `string` contains the given pattern. Similar\n * to [.isMatch](#isMatch) but the pattern can match any part of the string.\n *\n * ```js\n * var mm = require('micromatch');\n * // mm.contains(string, pattern[, options]);\n *\n * console.log(mm.contains('aa/bb/cc', '*b'));\n * //=> true\n * console.log(mm.contains('aa/bb/cc', '*d'));\n * //=> false\n * ```\n * @param {String} `str` The string to match.\n * @param {String|Array} `patterns` Glob pattern to use for matching.\n * @param {Object} `options` See available [options](#options) for changing how matches are performed\n * @return {Boolean} Returns true if any of the patterns matches any part of `str`.\n * @api public\n */\n\nmicromatch.contains = function (str, pattern, options) {\n  if (typeof str !== 'string') {\n    throw new TypeError(\"Expected a string: \\\"\".concat(util.inspect(str), \"\\\"\"));\n  }\n  if (Array.isArray(pattern)) {\n    return pattern.some(function (p) {\n      return micromatch.contains(str, p, options);\n    });\n  }\n  if (typeof pattern === 'string') {\n    if (isEmptyString(str) || isEmptyString(pattern)) {\n      return false;\n    }\n    if (str.includes(pattern) || str.startsWith('./') && str.slice(2).includes(pattern)) {\n      return true;\n    }\n  }\n  return micromatch.isMatch(str, pattern, _objectSpread(_objectSpread({}, options), {}, {\n    contains: true\n  }));\n};\n\n/**\n * Filter the keys of the given object with the given `glob` pattern\n * and `options`. Does not attempt to match nested keys. If you need this feature,\n * use [glob-object][] instead.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.matchKeys(object, patterns[, options]);\n *\n * const obj = { aa: 'a', ab: 'b', ac: 'c' };\n * console.log(mm.matchKeys(obj, '*b'));\n * //=> { ab: 'b' }\n * ```\n * @param {Object} `object` The object with keys to filter.\n * @param {String|Array} `patterns` One or more glob patterns to use for matching.\n * @param {Object} `options` See available [options](#options) for changing how matches are performed\n * @return {Object} Returns an object with only keys that match the given patterns.\n * @api public\n */\n\nmicromatch.matchKeys = function (obj, patterns, options) {\n  if (!utils.isObject(obj)) {\n    throw new TypeError('Expected the first argument to be an object');\n  }\n  var keys = micromatch(Object.keys(obj), patterns, options);\n  var res = {};\n  var _iterator2 = _createForOfIteratorHelper(keys),\n    _step2;\n  try {\n    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n      var key = _step2.value;\n      res[key] = obj[key];\n    }\n  } catch (err) {\n    _iterator2.e(err);\n  } finally {\n    _iterator2.f();\n  }\n  return res;\n};\n\n/**\n * Returns true if some of the strings in the given `list` match any of the given glob `patterns`.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.some(list, patterns[, options]);\n *\n * console.log(mm.some(['foo.js', 'bar.js'], ['*.js', '!foo.js']));\n * // true\n * console.log(mm.some(['foo.js'], ['*.js', '!foo.js']));\n * // false\n * ```\n * @param {String|Array} `list` The string or array of strings to test. Returns as soon as the first match is found.\n * @param {String|Array} `patterns` One or more glob patterns to use for matching.\n * @param {Object} `options` See available [options](#options) for changing how matches are performed\n * @return {Boolean} Returns true if any `patterns` matches any of the strings in `list`\n * @api public\n */\n\nmicromatch.some = function (list, patterns, options) {\n  var items = [].concat(list);\n  var _iterator3 = _createForOfIteratorHelper([].concat(patterns)),\n    _step3;\n  try {\n    var _loop = function _loop() {\n        var pattern = _step3.value;\n        var isMatch = picomatch(String(pattern), options);\n        if (items.some(function (item) {\n          return isMatch(item);\n        })) {\n          return {\n            v: true\n          };\n        }\n      },\n      _ret;\n    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {\n      _ret = _loop();\n      if (_ret) return _ret.v;\n    }\n  } catch (err) {\n    _iterator3.e(err);\n  } finally {\n    _iterator3.f();\n  }\n  return false;\n};\n\n/**\n * Returns true if every string in the given `list` matches\n * any of the given glob `patterns`.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.every(list, patterns[, options]);\n *\n * console.log(mm.every('foo.js', ['foo.js']));\n * // true\n * console.log(mm.every(['foo.js', 'bar.js'], ['*.js']));\n * // true\n * console.log(mm.every(['foo.js', 'bar.js'], ['*.js', '!foo.js']));\n * // false\n * console.log(mm.every(['foo.js'], ['*.js', '!foo.js']));\n * // false\n * ```\n * @param {String|Array} `list` The string or array of strings to test.\n * @param {String|Array} `patterns` One or more glob patterns to use for matching.\n * @param {Object} `options` See available [options](#options) for changing how matches are performed\n * @return {Boolean} Returns true if all `patterns` matches all of the strings in `list`\n * @api public\n */\n\nmicromatch.every = function (list, patterns, options) {\n  var items = [].concat(list);\n  var _iterator4 = _createForOfIteratorHelper([].concat(patterns)),\n    _step4;\n  try {\n    var _loop2 = function _loop2() {\n        var pattern = _step4.value;\n        var isMatch = picomatch(String(pattern), options);\n        if (!items.every(function (item) {\n          return isMatch(item);\n        })) {\n          return {\n            v: false\n          };\n        }\n      },\n      _ret2;\n    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {\n      _ret2 = _loop2();\n      if (_ret2) return _ret2.v;\n    }\n  } catch (err) {\n    _iterator4.e(err);\n  } finally {\n    _iterator4.f();\n  }\n  return true;\n};\n\n/**\n * Returns true if **all** of the given `patterns` match\n * the specified string.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.all(string, patterns[, options]);\n *\n * console.log(mm.all('foo.js', ['foo.js']));\n * // true\n *\n * console.log(mm.all('foo.js', ['*.js', '!foo.js']));\n * // false\n *\n * console.log(mm.all('foo.js', ['*.js', 'foo.js']));\n * // true\n *\n * console.log(mm.all('foo.js', ['*.js', 'f*', '*o*', '*o.js']));\n * // true\n * ```\n * @param {String|Array} `str` The string to test.\n * @param {String|Array} `patterns` One or more glob patterns to use for matching.\n * @param {Object} `options` See available [options](#options) for changing how matches are performed\n * @return {Boolean} Returns true if any patterns match `str`\n * @api public\n */\n\nmicromatch.all = function (str, patterns, options) {\n  if (typeof str !== 'string') {\n    throw new TypeError(\"Expected a string: \\\"\".concat(util.inspect(str), \"\\\"\"));\n  }\n  return [].concat(patterns).every(function (p) {\n    return picomatch(p, options)(str);\n  });\n};\n\n/**\n * Returns an array of matches captured by `pattern` in `string, or `null` if the pattern did not match.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.capture(pattern, string[, options]);\n *\n * console.log(mm.capture('test/*.js', 'test/foo.js'));\n * //=> ['foo']\n * console.log(mm.capture('test/*.js', 'foo/bar.css'));\n * //=> null\n * ```\n * @param {String} `glob` Glob pattern to use for matching.\n * @param {String} `input` String to match\n * @param {Object} `options` See available [options](#options) for changing how matches are performed\n * @return {Array|null} Returns an array of captures if the input matches the glob pattern, otherwise `null`.\n * @api public\n */\n\nmicromatch.capture = function (glob, input, options) {\n  var posix = utils.isWindows(options);\n  var regex = picomatch.makeRe(String(glob), _objectSpread(_objectSpread({}, options), {}, {\n    capture: true\n  }));\n  var match = regex.exec(posix ? utils.toPosixSlashes(input) : input);\n  if (match) {\n    return match.slice(1).map(function (v) {\n      return v === void 0 ? '' : v;\n    });\n  }\n};\n\n/**\n * Create a regular expression from the given glob `pattern`.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.makeRe(pattern[, options]);\n *\n * console.log(mm.makeRe('*.js'));\n * //=> /^(?:(\\.[\\\\\\/])?(?!\\.)(?=.)[^\\/]*?\\.js)$/\n * ```\n * @param {String} `pattern` A glob pattern to convert to regex.\n * @param {Object} `options`\n * @return {RegExp} Returns a regex created from the given pattern.\n * @api public\n */\n\nmicromatch.makeRe = function () {\n  return picomatch.makeRe.apply(picomatch, arguments);\n};\n\n/**\n * Scan a glob pattern to separate the pattern into segments. Used\n * by the [split](#split) method.\n *\n * ```js\n * const mm = require('micromatch');\n * const state = mm.scan(pattern[, options]);\n * ```\n * @param {String} `pattern`\n * @param {Object} `options`\n * @return {Object} Returns an object with\n * @api public\n */\n\nmicromatch.scan = function () {\n  return picomatch.scan.apply(picomatch, arguments);\n};\n\n/**\n * Parse a glob pattern to create the source string for a regular\n * expression.\n *\n * ```js\n * const mm = require('micromatch');\n * const state = mm.parse(pattern[, options]);\n * ```\n * @param {String} `glob`\n * @param {Object} `options`\n * @return {Object} Returns an object with useful properties and output to be used as regex source string.\n * @api public\n */\n\nmicromatch.parse = function (patterns, options) {\n  var res = [];\n  var _iterator5 = _createForOfIteratorHelper([].concat(patterns || [])),\n    _step5;\n  try {\n    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {\n      var pattern = _step5.value;\n      var _iterator6 = _createForOfIteratorHelper(braces(String(pattern), options)),\n        _step6;\n      try {\n        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {\n          var str = _step6.value;\n          res.push(picomatch.parse(str, options));\n        }\n      } catch (err) {\n        _iterator6.e(err);\n      } finally {\n        _iterator6.f();\n      }\n    }\n  } catch (err) {\n    _iterator5.e(err);\n  } finally {\n    _iterator5.f();\n  }\n  return res;\n};\n\n/**\n * Process the given brace `pattern`.\n *\n * ```js\n * const { braces } = require('micromatch');\n * console.log(braces('foo/{a,b,c}/bar'));\n * //=> [ 'foo/(a|b|c)/bar' ]\n *\n * console.log(braces('foo/{a,b,c}/bar', { expand: true }));\n * //=> [ 'foo/a/bar', 'foo/b/bar', 'foo/c/bar' ]\n * ```\n * @param {String} `pattern` String with brace pattern to process.\n * @param {Object} `options` Any [options](#options) to change how expansion is performed. See the [braces][] library for all available options.\n * @return {Array}\n * @api public\n */\n\nmicromatch.braces = function (pattern, options) {\n  if (typeof pattern !== 'string') throw new TypeError('Expected a string');\n  if (options && options.nobrace === true || !hasBraces(pattern)) {\n    return [pattern];\n  }\n  return braces(pattern, options);\n};\n\n/**\n * Expand braces\n */\n\nmicromatch.braceExpand = function (pattern, options) {\n  if (typeof pattern !== 'string') throw new TypeError('Expected a string');\n  return micromatch.braces(pattern, _objectSpread(_objectSpread({}, options), {}, {\n    expand: true\n  }));\n};\n\n/**\n * Expose micromatch\n */\n\n// exposed for tests\nmicromatch.hasBraces = hasBraces;\nmodule.exports = micromatch;","map":{"version":3,"names":["_toConsumableArray","require","_createForOfIteratorHelper","_objectSpread","util","braces","picomatch","utils","isEmptyString","v","hasBraces","index","indexOf","micromatch","list","patterns","options","concat","omit","Set","keep","items","negatives","onResult","state","add","output","i","length","isMatch","String","negated","negatedExtglob","_iterator","_step","s","n","done","item","value","matched","match","err","e","f","result","matches","filter","has","failglob","Error","join","nonull","nullglob","unescape","map","p","replace","matcher","pattern","str","any","not","arguments","undefined","push","_i","_items","contains","TypeError","inspect","Array","isArray","some","includes","startsWith","slice","matchKeys","obj","isObject","keys","Object","res","_iterator2","_step2","key","_iterator3","_step3","_loop","_ret","every","_iterator4","_step4","_loop2","_ret2","all","capture","glob","input","posix","isWindows","regex","makeRe","exec","toPosixSlashes","apply","scan","parse","_iterator5","_step5","_iterator6","_step6","nobrace","braceExpand","expand","module","exports"],"sources":["D:/DSP_Management/node_modules/http-proxy-middleware/node_modules/micromatch/index.js"],"sourcesContent":["'use strict';\n\nconst util = require('util');\nconst braces = require('braces');\nconst picomatch = require('picomatch');\nconst utils = require('picomatch/lib/utils');\n\nconst isEmptyString = v => v === '' || v === './';\nconst hasBraces = v => {\n  const index = v.indexOf('{');\n  return index > -1 && v.indexOf('}', index) > -1;\n};\n\n/**\n * Returns an array of strings that match one or more glob patterns.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm(list, patterns[, options]);\n *\n * console.log(mm(['a.js', 'a.txt'], ['*.js']));\n * //=> [ 'a.js' ]\n * ```\n * @param {String|Array<string>} `list` List of strings to match.\n * @param {String|Array<string>} `patterns` One or more glob patterns to use for matching.\n * @param {Object} `options` See available [options](#options)\n * @return {Array} Returns an array of matches\n * @summary false\n * @api public\n */\n\nconst micromatch = (list, patterns, options) => {\n  patterns = [].concat(patterns);\n  list = [].concat(list);\n\n  let omit = new Set();\n  let keep = new Set();\n  let items = new Set();\n  let negatives = 0;\n\n  let onResult = state => {\n    items.add(state.output);\n    if (options && options.onResult) {\n      options.onResult(state);\n    }\n  };\n\n  for (let i = 0; i < patterns.length; i++) {\n    let isMatch = picomatch(String(patterns[i]), { ...options, onResult }, true);\n    let negated = isMatch.state.negated || isMatch.state.negatedExtglob;\n    if (negated) negatives++;\n\n    for (let item of list) {\n      let matched = isMatch(item, true);\n\n      let match = negated ? !matched.isMatch : matched.isMatch;\n      if (!match) continue;\n\n      if (negated) {\n        omit.add(matched.output);\n      } else {\n        omit.delete(matched.output);\n        keep.add(matched.output);\n      }\n    }\n  }\n\n  let result = negatives === patterns.length ? [...items] : [...keep];\n  let matches = result.filter(item => !omit.has(item));\n\n  if (options && matches.length === 0) {\n    if (options.failglob === true) {\n      throw new Error(`No matches found for \"${patterns.join(', ')}\"`);\n    }\n\n    if (options.nonull === true || options.nullglob === true) {\n      return options.unescape ? patterns.map(p => p.replace(/\\\\/g, '')) : patterns;\n    }\n  }\n\n  return matches;\n};\n\n/**\n * Backwards compatibility\n */\n\nmicromatch.match = micromatch;\n\n/**\n * Returns a matcher function from the given glob `pattern` and `options`.\n * The returned function takes a string to match as its only argument and returns\n * true if the string is a match.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.matcher(pattern[, options]);\n *\n * const isMatch = mm.matcher('*.!(*a)');\n * console.log(isMatch('a.a')); //=> false\n * console.log(isMatch('a.b')); //=> true\n * ```\n * @param {String} `pattern` Glob pattern\n * @param {Object} `options`\n * @return {Function} Returns a matcher function.\n * @api public\n */\n\nmicromatch.matcher = (pattern, options) => picomatch(pattern, options);\n\n/**\n * Returns true if **any** of the given glob `patterns` match the specified `string`.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.isMatch(string, patterns[, options]);\n *\n * console.log(mm.isMatch('a.a', ['b.*', '*.a'])); //=> true\n * console.log(mm.isMatch('a.a', 'b.*')); //=> false\n * ```\n * @param {String} `str` The string to test.\n * @param {String|Array} `patterns` One or more glob patterns to use for matching.\n * @param {Object} `[options]` See available [options](#options).\n * @return {Boolean} Returns true if any patterns match `str`\n * @api public\n */\n\nmicromatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);\n\n/**\n * Backwards compatibility\n */\n\nmicromatch.any = micromatch.isMatch;\n\n/**\n * Returns a list of strings that _**do not match any**_ of the given `patterns`.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.not(list, patterns[, options]);\n *\n * console.log(mm.not(['a.a', 'b.b', 'c.c'], '*.a'));\n * //=> ['b.b', 'c.c']\n * ```\n * @param {Array} `list` Array of strings to match.\n * @param {String|Array} `patterns` One or more glob pattern to use for matching.\n * @param {Object} `options` See available [options](#options) for changing how matches are performed\n * @return {Array} Returns an array of strings that **do not match** the given patterns.\n * @api public\n */\n\nmicromatch.not = (list, patterns, options = {}) => {\n  patterns = [].concat(patterns).map(String);\n  let result = new Set();\n  let items = [];\n\n  let onResult = state => {\n    if (options.onResult) options.onResult(state);\n    items.push(state.output);\n  };\n\n  let matches = new Set(micromatch(list, patterns, { ...options, onResult }));\n\n  for (let item of items) {\n    if (!matches.has(item)) {\n      result.add(item);\n    }\n  }\n  return [...result];\n};\n\n/**\n * Returns true if the given `string` contains the given pattern. Similar\n * to [.isMatch](#isMatch) but the pattern can match any part of the string.\n *\n * ```js\n * var mm = require('micromatch');\n * // mm.contains(string, pattern[, options]);\n *\n * console.log(mm.contains('aa/bb/cc', '*b'));\n * //=> true\n * console.log(mm.contains('aa/bb/cc', '*d'));\n * //=> false\n * ```\n * @param {String} `str` The string to match.\n * @param {String|Array} `patterns` Glob pattern to use for matching.\n * @param {Object} `options` See available [options](#options) for changing how matches are performed\n * @return {Boolean} Returns true if any of the patterns matches any part of `str`.\n * @api public\n */\n\nmicromatch.contains = (str, pattern, options) => {\n  if (typeof str !== 'string') {\n    throw new TypeError(`Expected a string: \"${util.inspect(str)}\"`);\n  }\n\n  if (Array.isArray(pattern)) {\n    return pattern.some(p => micromatch.contains(str, p, options));\n  }\n\n  if (typeof pattern === 'string') {\n    if (isEmptyString(str) || isEmptyString(pattern)) {\n      return false;\n    }\n\n    if (str.includes(pattern) || (str.startsWith('./') && str.slice(2).includes(pattern))) {\n      return true;\n    }\n  }\n\n  return micromatch.isMatch(str, pattern, { ...options, contains: true });\n};\n\n/**\n * Filter the keys of the given object with the given `glob` pattern\n * and `options`. Does not attempt to match nested keys. If you need this feature,\n * use [glob-object][] instead.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.matchKeys(object, patterns[, options]);\n *\n * const obj = { aa: 'a', ab: 'b', ac: 'c' };\n * console.log(mm.matchKeys(obj, '*b'));\n * //=> { ab: 'b' }\n * ```\n * @param {Object} `object` The object with keys to filter.\n * @param {String|Array} `patterns` One or more glob patterns to use for matching.\n * @param {Object} `options` See available [options](#options) for changing how matches are performed\n * @return {Object} Returns an object with only keys that match the given patterns.\n * @api public\n */\n\nmicromatch.matchKeys = (obj, patterns, options) => {\n  if (!utils.isObject(obj)) {\n    throw new TypeError('Expected the first argument to be an object');\n  }\n  let keys = micromatch(Object.keys(obj), patterns, options);\n  let res = {};\n  for (let key of keys) res[key] = obj[key];\n  return res;\n};\n\n/**\n * Returns true if some of the strings in the given `list` match any of the given glob `patterns`.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.some(list, patterns[, options]);\n *\n * console.log(mm.some(['foo.js', 'bar.js'], ['*.js', '!foo.js']));\n * // true\n * console.log(mm.some(['foo.js'], ['*.js', '!foo.js']));\n * // false\n * ```\n * @param {String|Array} `list` The string or array of strings to test. Returns as soon as the first match is found.\n * @param {String|Array} `patterns` One or more glob patterns to use for matching.\n * @param {Object} `options` See available [options](#options) for changing how matches are performed\n * @return {Boolean} Returns true if any `patterns` matches any of the strings in `list`\n * @api public\n */\n\nmicromatch.some = (list, patterns, options) => {\n  let items = [].concat(list);\n\n  for (let pattern of [].concat(patterns)) {\n    let isMatch = picomatch(String(pattern), options);\n    if (items.some(item => isMatch(item))) {\n      return true;\n    }\n  }\n  return false;\n};\n\n/**\n * Returns true if every string in the given `list` matches\n * any of the given glob `patterns`.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.every(list, patterns[, options]);\n *\n * console.log(mm.every('foo.js', ['foo.js']));\n * // true\n * console.log(mm.every(['foo.js', 'bar.js'], ['*.js']));\n * // true\n * console.log(mm.every(['foo.js', 'bar.js'], ['*.js', '!foo.js']));\n * // false\n * console.log(mm.every(['foo.js'], ['*.js', '!foo.js']));\n * // false\n * ```\n * @param {String|Array} `list` The string or array of strings to test.\n * @param {String|Array} `patterns` One or more glob patterns to use for matching.\n * @param {Object} `options` See available [options](#options) for changing how matches are performed\n * @return {Boolean} Returns true if all `patterns` matches all of the strings in `list`\n * @api public\n */\n\nmicromatch.every = (list, patterns, options) => {\n  let items = [].concat(list);\n\n  for (let pattern of [].concat(patterns)) {\n    let isMatch = picomatch(String(pattern), options);\n    if (!items.every(item => isMatch(item))) {\n      return false;\n    }\n  }\n  return true;\n};\n\n/**\n * Returns true if **all** of the given `patterns` match\n * the specified string.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.all(string, patterns[, options]);\n *\n * console.log(mm.all('foo.js', ['foo.js']));\n * // true\n *\n * console.log(mm.all('foo.js', ['*.js', '!foo.js']));\n * // false\n *\n * console.log(mm.all('foo.js', ['*.js', 'foo.js']));\n * // true\n *\n * console.log(mm.all('foo.js', ['*.js', 'f*', '*o*', '*o.js']));\n * // true\n * ```\n * @param {String|Array} `str` The string to test.\n * @param {String|Array} `patterns` One or more glob patterns to use for matching.\n * @param {Object} `options` See available [options](#options) for changing how matches are performed\n * @return {Boolean} Returns true if any patterns match `str`\n * @api public\n */\n\nmicromatch.all = (str, patterns, options) => {\n  if (typeof str !== 'string') {\n    throw new TypeError(`Expected a string: \"${util.inspect(str)}\"`);\n  }\n\n  return [].concat(patterns).every(p => picomatch(p, options)(str));\n};\n\n/**\n * Returns an array of matches captured by `pattern` in `string, or `null` if the pattern did not match.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.capture(pattern, string[, options]);\n *\n * console.log(mm.capture('test/*.js', 'test/foo.js'));\n * //=> ['foo']\n * console.log(mm.capture('test/*.js', 'foo/bar.css'));\n * //=> null\n * ```\n * @param {String} `glob` Glob pattern to use for matching.\n * @param {String} `input` String to match\n * @param {Object} `options` See available [options](#options) for changing how matches are performed\n * @return {Array|null} Returns an array of captures if the input matches the glob pattern, otherwise `null`.\n * @api public\n */\n\nmicromatch.capture = (glob, input, options) => {\n  let posix = utils.isWindows(options);\n  let regex = picomatch.makeRe(String(glob), { ...options, capture: true });\n  let match = regex.exec(posix ? utils.toPosixSlashes(input) : input);\n\n  if (match) {\n    return match.slice(1).map(v => v === void 0 ? '' : v);\n  }\n};\n\n/**\n * Create a regular expression from the given glob `pattern`.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.makeRe(pattern[, options]);\n *\n * console.log(mm.makeRe('*.js'));\n * //=> /^(?:(\\.[\\\\\\/])?(?!\\.)(?=.)[^\\/]*?\\.js)$/\n * ```\n * @param {String} `pattern` A glob pattern to convert to regex.\n * @param {Object} `options`\n * @return {RegExp} Returns a regex created from the given pattern.\n * @api public\n */\n\nmicromatch.makeRe = (...args) => picomatch.makeRe(...args);\n\n/**\n * Scan a glob pattern to separate the pattern into segments. Used\n * by the [split](#split) method.\n *\n * ```js\n * const mm = require('micromatch');\n * const state = mm.scan(pattern[, options]);\n * ```\n * @param {String} `pattern`\n * @param {Object} `options`\n * @return {Object} Returns an object with\n * @api public\n */\n\nmicromatch.scan = (...args) => picomatch.scan(...args);\n\n/**\n * Parse a glob pattern to create the source string for a regular\n * expression.\n *\n * ```js\n * const mm = require('micromatch');\n * const state = mm.parse(pattern[, options]);\n * ```\n * @param {String} `glob`\n * @param {Object} `options`\n * @return {Object} Returns an object with useful properties and output to be used as regex source string.\n * @api public\n */\n\nmicromatch.parse = (patterns, options) => {\n  let res = [];\n  for (let pattern of [].concat(patterns || [])) {\n    for (let str of braces(String(pattern), options)) {\n      res.push(picomatch.parse(str, options));\n    }\n  }\n  return res;\n};\n\n/**\n * Process the given brace `pattern`.\n *\n * ```js\n * const { braces } = require('micromatch');\n * console.log(braces('foo/{a,b,c}/bar'));\n * //=> [ 'foo/(a|b|c)/bar' ]\n *\n * console.log(braces('foo/{a,b,c}/bar', { expand: true }));\n * //=> [ 'foo/a/bar', 'foo/b/bar', 'foo/c/bar' ]\n * ```\n * @param {String} `pattern` String with brace pattern to process.\n * @param {Object} `options` Any [options](#options) to change how expansion is performed. See the [braces][] library for all available options.\n * @return {Array}\n * @api public\n */\n\nmicromatch.braces = (pattern, options) => {\n  if (typeof pattern !== 'string') throw new TypeError('Expected a string');\n  if ((options && options.nobrace === true) || !hasBraces(pattern)) {\n    return [pattern];\n  }\n  return braces(pattern, options);\n};\n\n/**\n * Expand braces\n */\n\nmicromatch.braceExpand = (pattern, options) => {\n  if (typeof pattern !== 'string') throw new TypeError('Expected a string');\n  return micromatch.braces(pattern, { ...options, expand: true });\n};\n\n/**\n * Expose micromatch\n */\n\n// exposed for tests\nmicromatch.hasBraces = hasBraces;\nmodule.exports = micromatch;\n"],"mappings":"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","ignoreList":[]},"metadata":{},"sourceType":"script","externalDependencies":[]}