@fragno-dev/workflows 0.0.1

package/dist/node/node_modules/.pnpm/micromatch@4.0.8/node_modules/micromatch/index.js

@@ -0,0 +1,404 @@
+import { __commonJS, __require } from "../../../../../_virtual/rolldown_runtime.js";
+import { require_braces } from "../../../braces@3.0.3/node_modules/braces/index.js";
+import { require_utils } from "../../../picomatch@2.3.1/node_modules/picomatch/lib/utils.js";
+import { require_picomatch } from "../../../picomatch@2.3.1/node_modules/picomatch/index.js";
+
+//#region ../../node_modules/.pnpm/micromatch@4.0.8/node_modules/micromatch/index.js
+var require_micromatch = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/micromatch@4.0.8/node_modules/micromatch/index.js": ((exports, module) => {
+	const util = __require("util");
+	const braces = require_braces();
+	const picomatch = require_picomatch();
+	const utils = require_utils();
+	const isEmptyString = (v) => v === "" || v === "./";
+	const hasBraces = (v) => {
+		const index = v.indexOf("{");
+		return index > -1 && v.indexOf("}", index) > -1;
+	};
+	/**
+	* Returns an array of strings that match one or more glob patterns.
+	*
+	* ```js
+	* const mm = require('micromatch');
+	* // mm(list, patterns[, options]);
+	*
+	* console.log(mm(['a.js', 'a.txt'], ['*.js']));
+	* //=> [ 'a.js' ]
+	* ```
+	* @param {String|Array<string>} `list` List of strings to match.
+	* @param {String|Array<string>} `patterns` One or more glob patterns to use for matching.
+	* @param {Object} `options` See available [options](#options)
+	* @return {Array} Returns an array of matches
+	* @summary false
+	* @api public
+	*/
+	const micromatch = (list, patterns, options) => {
+		patterns = [].concat(patterns);
+		list = [].concat(list);
+		let omit = /* @__PURE__ */ new Set();
+		let keep = /* @__PURE__ */ new Set();
+		let items = /* @__PURE__ */ new Set();
+		let negatives = 0;
+		let onResult = (state) => {
+			items.add(state.output);
+			if (options && options.onResult) options.onResult(state);
+		};
+		for (let i = 0; i < patterns.length; i++) {
+			let isMatch = picomatch(String(patterns[i]), {
+				...options,
+				onResult
+			}, true);
+			let negated = isMatch.state.negated || isMatch.state.negatedExtglob;
+			if (negated) negatives++;
+			for (let item of list) {
+				let matched = isMatch(item, true);
+				if (!(negated ? !matched.isMatch : matched.isMatch)) continue;
+				if (negated) omit.add(matched.output);
+				else {
+					omit.delete(matched.output);
+					keep.add(matched.output);
+				}
+			}
+		}
+		let matches = (negatives === patterns.length ? [...items] : [...keep]).filter((item) => !omit.has(item));
+		if (options && matches.length === 0) {
+			if (options.failglob === true) throw new Error(`No matches found for "${patterns.join(", ")}"`);
+			if (options.nonull === true || options.nullglob === true) return options.unescape ? patterns.map((p) => p.replace(/\\/g, "")) : patterns;
+		}
+		return matches;
+	};
+	/**
+	* Backwards compatibility
+	*/
+	micromatch.match = micromatch;
+	/**
+	* Returns a 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
+	* const mm = require('micromatch');
+	* // mm.matcher(pattern[, options]);
+	*
+	* const isMatch = mm.matcher('*.!(*a)');
+	* console.log(isMatch('a.a')); //=> false
+	* console.log(isMatch('a.b')); //=> true
+	* ```
+	* @param {String} `pattern` Glob pattern
+	* @param {Object} `options`
+	* @return {Function} Returns a matcher function.
+	* @api public
+	*/
+	micromatch.matcher = (pattern, options) => picomatch(pattern, options);
+	/**
+	* Returns true if **any** of the given glob `patterns` match the specified `string`.
+	*
+	* ```js
+	* const mm = require('micromatch');
+	* // mm.isMatch(string, patterns[, options]);
+	*
+	* console.log(mm.isMatch('a.a', ['b.*', '*.a'])); //=> true
+	* console.log(mm.isMatch('a.a', 'b.*')); //=> false
+	* ```
+	* @param {String} `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).
+	* @return {Boolean} Returns true if any patterns match `str`
+	* @api public
+	*/
+	micromatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+	/**
+	* Backwards compatibility
+	*/
+	micromatch.any = micromatch.isMatch;
+	/**
+	* Returns a list of strings that _**do not match any**_ of the given `patterns`.
+	*
+	* ```js
+	* const 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 = (list, patterns, options = {}) => {
+		patterns = [].concat(patterns).map(String);
+		let result = /* @__PURE__ */ new Set();
+		let items = [];
+		let onResult = (state) => {
+			if (options.onResult) options.onResult(state);
+			items.push(state.output);
+		};
+		let matches = new Set(micromatch(list, patterns, {
+			...options,
+			onResult
+		}));
+		for (let item of items) if (!matches.has(item)) result.add(item);
+		return [...result];
+	};
+	/**
+	* 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 any of the patterns matches any part of `str`.
+	* @api public
+	*/
+	micromatch.contains = (str, pattern, options) => {
+		if (typeof str !== "string") throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
+		if (Array.isArray(pattern)) return pattern.some((p) => micromatch.contains(str, p, options));
+		if (typeof pattern === "string") {
+			if (isEmptyString(str) || isEmptyString(pattern)) return false;
+			if (str.includes(pattern) || str.startsWith("./") && str.slice(2).includes(pattern)) return true;
+		}
+		return micromatch.isMatch(str, pattern, {
+			...options,
+			contains: 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
+	* const mm = require('micromatch');
+	* // mm.matchKeys(object, patterns[, options]);
+	*
+	* const 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 = (obj, patterns, options) => {
+		if (!utils.isObject(obj)) throw new TypeError("Expected the first argument to be an object");
+		let keys = micromatch(Object.keys(obj), patterns, options);
+		let res = {};
+		for (let key of keys) res[key] = obj[key];
+		return res;
+	};
+	/**
+	* Returns true if some of the strings in the given `list` match any of the given glob `patterns`.
+	*
+	* ```js
+	* const 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` matches any of the strings in `list`
+	* @api public
+	*/
+	micromatch.some = (list, patterns, options) => {
+		let items = [].concat(list);
+		for (let pattern of [].concat(patterns)) {
+			let isMatch = picomatch(String(pattern), options);
+			if (items.some((item) => isMatch(item))) return true;
+		}
+		return false;
+	};
+	/**
+	* Returns true if every string in the given `list` matches
+	* any of the given glob `patterns`.
+	*
+	* ```js
+	* const 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 all `patterns` matches all of the strings in `list`
+	* @api public
+	*/
+	micromatch.every = (list, patterns, options) => {
+		let items = [].concat(list);
+		for (let pattern of [].concat(patterns)) {
+			let isMatch = picomatch(String(pattern), options);
+			if (!items.every((item) => isMatch(item))) return false;
+		}
+		return true;
+	};
+	/**
+	* Returns true if **all** of the given `patterns` match
+	* the specified string.
+	*
+	* ```js
+	* const 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 = (str, patterns, options) => {
+		if (typeof str !== "string") throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
+		return [].concat(patterns).every((p) => picomatch(p, options)(str));
+	};
+	/**
+	* Returns an array of matches captured by `pattern` in `string, or `null` if the pattern did not match.
+	*
+	* ```js
+	* const 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} `glob` Glob pattern to use for matching.
+	* @param {String} `input` String to match
+	* @param {Object} `options` See available [options](#options) for changing how matches are performed
+	* @return {Array|null} Returns an array of captures if the input matches the glob pattern, otherwise `null`.
+	* @api public
+	*/
+	micromatch.capture = (glob, input, options) => {
+		let posix = utils.isWindows(options);
+		let match = picomatch.makeRe(String(glob), {
+			...options,
+			capture: true
+		}).exec(posix ? utils.toPosixSlashes(input) : input);
+		if (match) return match.slice(1).map((v) => v === void 0 ? "" : v);
+	};
+	/**
+	* Create a regular expression from the given glob `pattern`.
+	*
+	* ```js
+	* const 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`
+	* @return {RegExp} Returns a regex created from the given pattern.
+	* @api public
+	*/
+	micromatch.makeRe = (...args) => picomatch.makeRe(...args);
+	/**
+	* Scan a glob pattern to separate the pattern into segments. Used
+	* by the [split](#split) method.
+	*
+	* ```js
+	* const mm = require('micromatch');
+	* const state = mm.scan(pattern[, options]);
+	* ```
+	* @param {String} `pattern`
+	* @param {Object} `options`
+	* @return {Object} Returns an object with
+	* @api public
+	*/
+	micromatch.scan = (...args) => picomatch.scan(...args);
+	/**
+	* Parse a glob pattern to create the source string for a regular
+	* expression.
+	*
+	* ```js
+	* const mm = require('micromatch');
+	* const state = mm.parse(pattern[, options]);
+	* ```
+	* @param {String} `glob`
+	* @param {Object} `options`
+	* @return {Object} Returns an object with useful properties and output to be used as regex source string.
+	* @api public
+	*/
+	micromatch.parse = (patterns, options) => {
+		let res = [];
+		for (let pattern of [].concat(patterns || [])) for (let str of braces(String(pattern), options)) res.push(picomatch.parse(str, options));
+		return res;
+	};
+	/**
+	* Process the given brace `pattern`.
+	*
+	* ```js
+	* const { braces } = require('micromatch');
+	* console.log(braces('foo/{a,b,c}/bar'));
+	* //=> [ 'foo/(a|b|c)/bar' ]
+	*
+	* console.log(braces('foo/{a,b,c}/bar', { expand: true }));
+	* //=> [ 'foo/a/bar', 'foo/b/bar', 'foo/c/bar' ]
+	* ```
+	* @param {String} `pattern` String with brace pattern to process.
+	* @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 = (pattern, options) => {
+		if (typeof pattern !== "string") throw new TypeError("Expected a string");
+		if (options && options.nobrace === true || !hasBraces(pattern)) return [pattern];
+		return braces(pattern, options);
+	};
+	/**
+	* Expand braces
+	*/
+	micromatch.braceExpand = (pattern, options) => {
+		if (typeof pattern !== "string") throw new TypeError("Expected a string");
+		return micromatch.braces(pattern, {
+			...options,
+			expand: true
+		});
+	};
+	/**
+	* Expose micromatch
+	*/
+	micromatch.hasBraces = hasBraces;
+	module.exports = micromatch;
+}) });
+
+//#endregion
+export default require_micromatch();
+
+export { require_micromatch };
+//# sourceMappingURL=index.js.map

package/dist/node/node_modules/.pnpm/micromatch@4.0.8/node_modules/micromatch/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../../../../../../node_modules/.pnpm/micromatch@4.0.8/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"],"x_google_ignoreList":[0],"mappings":"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"}