From 5c61d5bcf12f31f78bca7d397b9c56a1da196877 Mon Sep 17 00:00:00 2001 From: Oleksandr Lopatnov Date: Sat, 7 Dec 2019 11:43:39 +0200 Subject: [PATCH] changed uglify to terser --- dist/plugin.d.ts | 13 +- dist/plugin.es.js | 3059 +++++++++++++++++++++++++++++++++++++++- dist/plugin.es.js.map | 2 +- dist/plugin.js | 3128 ++++++++++++++++++++++++++++++++++++++++- dist/plugin.js.map | 2 +- package-lock.json | 15 +- package.json | 12 +- rollup.config.js | 57 +- src/plugin.ts | 32 +- tsconfig.json | 2 +- 10 files changed, 6223 insertions(+), 99 deletions(-) diff --git a/dist/plugin.d.ts b/dist/plugin.d.ts index e3c1ce4..b278d6b 100644 --- a/dist/plugin.d.ts +++ b/dist/plugin.d.ts @@ -1,8 +1,13 @@ -import { MinifyOptions } from 'uglify-js'; -export default function uglify(options?: MinifyOptions): { +import { MinifyOptions } from 'terser'; +export interface IUglifyOptions extends MinifyOptions { + include?: string | RegExp; + exclude?: string | RegExp; +} +declare function uglify(options?: IUglifyOptions): { name: string; - transform(code: any): { + transform(code: any, id: any): { code: string; - map: string; + map: string | import("source-map").RawSourceMap; }; }; +export default uglify; diff --git a/dist/plugin.es.js b/dist/plugin.es.js index cce83bb..75ebbc9 100644 --- a/dist/plugin.es.js +++ b/dist/plugin.es.js @@ -1,11 +1,3066 @@ -import { minify } from 'uglify-js'; +import { minify } from 'terser'; +import path, { sep, resolve } from 'path'; +import util from 'util'; + +function createCommonjsModule(fn, module) { + return module = { exports: {} }, fn(module, module.exports), module.exports; +} + +var utils = createCommonjsModule(function (module, exports) { + exports.isInteger = num => { + if (typeof num === 'number') { + return Number.isInteger(num); + } + if (typeof num === 'string' && num.trim() !== '') { + return Number.isInteger(Number(num)); + } + return false; + }; + /** + * Find a node of the given type + */ + exports.find = (node, type) => node.nodes.find(node => node.type === type); + /** + * Find a node of the given type + */ + exports.exceedsLimit = (min, max, step = 1, limit) => { + if (limit === false) + return false; + if (!exports.isInteger(min) || !exports.isInteger(max)) + return false; + return ((Number(max) - Number(min)) / Number(step)) >= limit; + }; + /** + * Escape the given node with '\\' before node.value + */ + exports.escapeNode = (block, n = 0, type) => { + let node = block.nodes[n]; + if (!node) + return; + if ((type && node.type === type) || node.type === 'open' || node.type === 'close') { + if (node.escaped !== true) { + node.value = '\\' + node.value; + node.escaped = true; + } + } + }; + /** + * Returns true if the given brace node should be enclosed in literal braces + */ + exports.encloseBrace = node => { + if (node.type !== 'brace') + return false; + if ((node.commas >> 0 + node.ranges >> 0) === 0) { + node.invalid = true; + return true; + } + return false; + }; + /** + * Returns true if a brace node is invalid. + */ + exports.isInvalidBrace = block => { + if (block.type !== 'brace') + return false; + if (block.invalid === true || block.dollar) + return true; + if ((block.commas >> 0 + block.ranges >> 0) === 0) { + block.invalid = true; + return true; + } + if (block.open !== true || block.close !== true) { + block.invalid = true; + return true; + } + return false; + }; + /** + * Returns true if a node is an open or close node + */ + exports.isOpenOrClose = node => { + if (node.type === 'open' || node.type === 'close') { + return true; + } + return node.open === true || node.close === true; + }; + /** + * Reduce an array of text nodes. + */ + exports.reduce = nodes => nodes.reduce((acc, node) => { + if (node.type === 'text') + acc.push(node.value); + if (node.type === 'range') + node.type = 'text'; + return acc; + }, []); + /** + * Flatten an array + */ + exports.flatten = (...args) => { + const result = []; + const flat = arr => { + for (let i = 0; i < arr.length; i++) { + let ele = arr[i]; + Array.isArray(ele) ? flat(ele) : ele !== void 0 && result.push(ele); + } + return result; + }; + flat(args); + return result; + }; +}); +var utils_1 = utils.isInteger; +var utils_2 = utils.find; +var utils_3 = utils.exceedsLimit; +var utils_4 = utils.escapeNode; +var utils_5 = utils.encloseBrace; +var utils_6 = utils.isInvalidBrace; +var utils_7 = utils.isOpenOrClose; +var utils_8 = utils.reduce; +var utils_9 = utils.flatten; + +var stringify = (ast, options = {}) => { + let stringify = (node, parent = {}) => { + let invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent); + let invalidNode = node.invalid === true && options.escapeInvalid === true; + let output = ''; + if (node.value) { + if ((invalidBlock || invalidNode) && utils.isOpenOrClose(node)) { + return '\\' + node.value; + } + return node.value; + } + if (node.value) { + return node.value; + } + if (node.nodes) { + for (let child of node.nodes) { + output += stringify(child); + } + } + return output; + }; + return stringify(ast); +}; + +/*! + * is-number + * + * Copyright (c) 2014-present, Jon Schlinkert. + * Released under the MIT License. + */ +var isNumber = function (num) { + if (typeof num === 'number') { + return num - num === 0; + } + if (typeof num === 'string' && num.trim() !== '') { + return Number.isFinite ? Number.isFinite(+num) : isFinite(+num); + } + return false; +}; + +const toRegexRange = (min, max, options) => { + if (isNumber(min) === false) { + throw new TypeError('toRegexRange: expected the first argument to be a number'); + } + if (max === void 0 || min === max) { + return String(min); + } + if (isNumber(max) === false) { + throw new TypeError('toRegexRange: expected the second argument to be a number.'); + } + let opts = Object.assign({ relaxZeros: true }, options); + if (typeof opts.strictZeros === 'boolean') { + opts.relaxZeros = opts.strictZeros === false; + } + let relax = String(opts.relaxZeros); + let shorthand = String(opts.shorthand); + let capture = String(opts.capture); + let wrap = String(opts.wrap); + let cacheKey = min + ':' + max + '=' + relax + shorthand + capture + wrap; + if (toRegexRange.cache.hasOwnProperty(cacheKey)) { + return toRegexRange.cache[cacheKey].result; + } + let a = Math.min(min, max); + let b = Math.max(min, max); + if (Math.abs(a - b) === 1) { + let result = min + '|' + max; + if (opts.capture) { + return `(${result})`; + } + if (opts.wrap === false) { + return result; + } + return `(?:${result})`; + } + let isPadded = hasPadding(min) || hasPadding(max); + let state = { min, max, a, b }; + let positives = []; + let negatives = []; + if (isPadded) { + state.isPadded = isPadded; + state.maxLen = String(state.max).length; + } + if (a < 0) { + let newMin = b < 0 ? Math.abs(b) : 1; + negatives = splitToPatterns(newMin, Math.abs(a), state, opts); + a = state.a = 0; + } + if (b >= 0) { + positives = splitToPatterns(a, b, state, opts); + } + state.negatives = negatives; + state.positives = positives; + state.result = collatePatterns(negatives, positives); + if (opts.capture === true) { + state.result = `(${state.result})`; + } + else if (opts.wrap !== false && (positives.length + negatives.length) > 1) { + state.result = `(?:${state.result})`; + } + toRegexRange.cache[cacheKey] = state; + return state.result; +}; +function collatePatterns(neg, pos, options) { + let onlyNegative = filterPatterns(neg, pos, '-', false) || []; + let onlyPositive = filterPatterns(pos, neg, '', false) || []; + let intersected = filterPatterns(neg, pos, '-?', true) || []; + let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive); + return subpatterns.join('|'); +} +function splitToRanges(min, max) { + let nines = 1; + let zeros = 1; + let stop = countNines(min, nines); + let stops = new Set([max]); + while (min <= stop && stop <= max) { + stops.add(stop); + nines += 1; + stop = countNines(min, nines); + } + stop = countZeros(max + 1, zeros) - 1; + while (min < stop && stop <= max) { + stops.add(stop); + zeros += 1; + stop = countZeros(max + 1, zeros) - 1; + } + stops = [...stops]; + stops.sort(compare); + return stops; +} +/** + * Convert a range to a regex pattern + * @param {Number} `start` + * @param {Number} `stop` + * @return {String} + */ +function rangeToPattern(start, stop, options) { + if (start === stop) { + return { pattern: start, count: [], digits: 0 }; + } + let zipped = zip(start, stop); + let digits = zipped.length; + let pattern = ''; + let count = 0; + for (let i = 0; i < digits; i++) { + let [startDigit, stopDigit] = zipped[i]; + if (startDigit === stopDigit) { + pattern += startDigit; + } + else if (startDigit !== '0' || stopDigit !== '9') { + pattern += toCharacterClass(startDigit, stopDigit); + } + else { + count++; + } + } + if (count) { + pattern += options.shorthand === true ? '\\d' : '[0-9]'; + } + return { pattern, count: [count], digits }; +} +function splitToPatterns(min, max, tok, options) { + let ranges = splitToRanges(min, max); + let tokens = []; + let start = min; + let prev; + for (let i = 0; i < ranges.length; i++) { + let max = ranges[i]; + let obj = rangeToPattern(String(start), String(max), options); + let zeros = ''; + if (!tok.isPadded && prev && prev.pattern === obj.pattern) { + if (prev.count.length > 1) { + prev.count.pop(); + } + prev.count.push(obj.count[0]); + prev.string = prev.pattern + toQuantifier(prev.count); + start = max + 1; + continue; + } + if (tok.isPadded) { + zeros = padZeros(max, tok, options); + } + obj.string = zeros + obj.pattern + toQuantifier(obj.count); + tokens.push(obj); + start = max + 1; + prev = obj; + } + return tokens; +} +function filterPatterns(arr, comparison, prefix, intersection, options) { + let result = []; + for (let ele of arr) { + let { string } = ele; + // only push if _both_ are negative... + if (!intersection && !contains(comparison, 'string', string)) { + result.push(prefix + string); + } + // or _both_ are positive + if (intersection && contains(comparison, 'string', string)) { + result.push(prefix + string); + } + } + return result; +} +/** + * Zip strings + */ +function zip(a, b) { + let arr = []; + for (let i = 0; i < a.length; i++) + arr.push([a[i], b[i]]); + return arr; +} +function compare(a, b) { + return a > b ? 1 : b > a ? -1 : 0; +} +function contains(arr, key, val) { + return arr.some(ele => ele[key] === val); +} +function countNines(min, len) { + return Number(String(min).slice(0, -len) + '9'.repeat(len)); +} +function countZeros(integer, zeros) { + return integer - (integer % Math.pow(10, zeros)); +} +function toQuantifier(digits) { + let [start = 0, stop = ''] = digits; + if (stop || start > 1) { + return `{${start + (stop ? ',' + stop : '')}}`; + } + return ''; +} +function toCharacterClass(a, b, options) { + return `[${a}${(b - a === 1) ? '' : '-'}${b}]`; +} +function hasPadding(str) { + return /^-?(0+)\d/.test(str); +} +function padZeros(value, tok, options) { + if (!tok.isPadded) { + return value; + } + let diff = Math.abs(tok.maxLen - String(value).length); + let relax = options.relaxZeros !== false; + switch (diff) { + case 0: + return ''; + case 1: + return relax ? '0?' : '0'; + case 2: + return relax ? '0{0,2}' : '00'; + default: { + return relax ? `0{0,${diff}}` : `0{${diff}}`; + } + } +} +/** + * Cache + */ +toRegexRange.cache = {}; +toRegexRange.clearCache = () => (toRegexRange.cache = {}); +/** + * Expose `toRegexRange` + */ +var toRegexRange_1 = toRegexRange; + +const isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val); +const transform = toNumber => { + return value => toNumber === true ? Number(value) : String(value); +}; +const isValidValue = value => { + return typeof value === 'number' || (typeof value === 'string' && value !== ''); +}; +const isNumber$1 = num => Number.isInteger(+num); +const zeros = input => { + let value = `${input}`; + let index = -1; + if (value[0] === '-') + value = value.slice(1); + if (value === '0') + return false; + while (value[++index] === '0') + ; + return index > 0; +}; +const stringify$1 = (start, end, options) => { + if (typeof start === 'string' || typeof end === 'string') { + return true; + } + return options.stringify === true; +}; +const pad = (input, maxLength, toNumber) => { + if (maxLength > 0) { + let dash = input[0] === '-' ? '-' : ''; + if (dash) + input = input.slice(1); + input = (dash + input.padStart(dash ? maxLength - 1 : maxLength, '0')); + } + if (toNumber === false) { + return String(input); + } + return input; +}; +const toMaxLen = (input, maxLength) => { + let negative = input[0] === '-' ? '-' : ''; + if (negative) { + input = input.slice(1); + maxLength--; + } + while (input.length < maxLength) + input = '0' + input; + return negative ? ('-' + input) : input; +}; +const toSequence = (parts, options) => { + parts.negatives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0); + parts.positives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0); + let prefix = options.capture ? '' : '?:'; + let positives = ''; + let negatives = ''; + let result; + if (parts.positives.length) { + positives = parts.positives.join('|'); + } + if (parts.negatives.length) { + negatives = `-(${prefix}${parts.negatives.join('|')})`; + } + if (positives && negatives) { + result = `${positives}|${negatives}`; + } + else { + result = positives || negatives; + } + if (options.wrap) { + return `(${prefix}${result})`; + } + return result; +}; +const toRange = (a, b, isNumbers, options) => { + if (isNumbers) { + return toRegexRange_1(a, b, Object.assign({ wrap: false }, options)); + } + let start = String.fromCharCode(a); + if (a === b) + return start; + let stop = String.fromCharCode(b); + return `[${start}-${stop}]`; +}; +const toRegex = (start, end, options) => { + if (Array.isArray(start)) { + let wrap = options.wrap === true; + let prefix = options.capture ? '' : '?:'; + return wrap ? `(${prefix}${start.join('|')})` : start.join('|'); + } + return toRegexRange_1(start, end, options); +}; +const rangeError = (...args) => { + return new RangeError('Invalid range arguments: ' + util.inspect(...args)); +}; +const invalidRange = (start, end, options) => { + if (options.strictRanges === true) + throw rangeError([start, end]); + return []; +}; +const invalidStep = (step, options) => { + if (options.strictRanges === true) { + throw new TypeError(`Expected step "${step}" to be a number`); + } + return []; +}; +const fillNumbers = (start, end, step = 1, options = {}) => { + let a = Number(start); + let b = Number(end); + if (!Number.isInteger(a) || !Number.isInteger(b)) { + if (options.strictRanges === true) + throw rangeError([start, end]); + return []; + } + // fix negative zero + if (a === 0) + a = 0; + if (b === 0) + b = 0; + let descending = a > b; + let startString = String(start); + let endString = String(end); + let stepString = String(step); + step = Math.max(Math.abs(step), 1); + let padded = zeros(startString) || zeros(endString) || zeros(stepString); + let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0; + let toNumber = padded === false && stringify$1(start, end, options) === false; + let format = options.transform || transform(toNumber); + if (options.toRegex && step === 1) { + return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options); + } + let parts = { negatives: [], positives: [] }; + let push = num => parts[num < 0 ? 'negatives' : 'positives'].push(Math.abs(num)); + let range = []; + let index = 0; + while (descending ? a >= b : a <= b) { + if (options.toRegex === true && step > 1) { + push(a); + } + else { + range.push(pad(format(a, index), maxLen, toNumber)); + } + a = descending ? a - step : a + step; + index++; + } + if (options.toRegex === true) { + return step > 1 + ? toSequence(parts, options) + : toRegex(range, null, Object.assign({ wrap: false }, options)); + } + return range; +}; +const fillLetters = (start, end, step = 1, options = {}) => { + if ((!isNumber$1(start) && start.length > 1) || (!isNumber$1(end) && end.length > 1)) { + return invalidRange(start, end, options); + } + let format = options.transform || (val => String.fromCharCode(val)); + let a = `${start}`.charCodeAt(0); + let b = `${end}`.charCodeAt(0); + let descending = a > b; + let min = Math.min(a, b); + let max = Math.max(a, b); + if (options.toRegex && step === 1) { + return toRange(min, max, false, options); + } + let range = []; + let index = 0; + while (descending ? a >= b : a <= b) { + range.push(format(a, index)); + a = descending ? a - step : a + step; + index++; + } + if (options.toRegex === true) { + return toRegex(range, null, { wrap: false, options }); + } + return range; +}; +const fill = (start, end, step, options = {}) => { + if (end == null && isValidValue(start)) { + return [start]; + } + if (!isValidValue(start) || !isValidValue(end)) { + return invalidRange(start, end, options); + } + if (typeof step === 'function') { + return fill(start, end, 1, { transform: step }); + } + if (isObject(step)) { + return fill(start, end, 0, step); + } + let opts = Object.assign({}, options); + if (opts.capture === true) + opts.wrap = true; + step = step || opts.step || 1; + if (!isNumber$1(step)) { + if (step != null && !isObject(step)) + return invalidStep(step, opts); + return fill(start, end, 1, step); + } + if (isNumber$1(start) && isNumber$1(end)) { + return fillNumbers(start, end, step, opts); + } + return fillLetters(start, end, Math.max(Math.abs(step), 1), opts); +}; +var fillRange = fill; + +const compile = (ast, options = {}) => { + let walk = (node, parent = {}) => { + let invalidBlock = utils.isInvalidBrace(parent); + let invalidNode = node.invalid === true && options.escapeInvalid === true; + let invalid = invalidBlock === true || invalidNode === true; + let prefix = options.escapeInvalid === true ? '\\' : ''; + let output = ''; + if (node.isOpen === true) { + return prefix + node.value; + } + if (node.isClose === true) { + return prefix + node.value; + } + if (node.type === 'open') { + return invalid ? (prefix + node.value) : '('; + } + if (node.type === 'close') { + return invalid ? (prefix + node.value) : ')'; + } + if (node.type === 'comma') { + return node.prev.type === 'comma' ? '' : (invalid ? node.value : '|'); + } + if (node.value) { + return node.value; + } + if (node.nodes && node.ranges > 0) { + let args = utils.reduce(node.nodes); + let range = fillRange(...args, Object.assign({}, options, { wrap: false, toRegex: true })); + if (range.length !== 0) { + return args.length > 1 && range.length > 1 ? `(${range})` : range; + } + } + if (node.nodes) { + for (let child of node.nodes) { + output += walk(child, node); + } + } + return output; + }; + return walk(ast); +}; +var compile_1 = compile; + +const append = (queue = '', stash = '', enclose = false) => { + let result = []; + queue = [].concat(queue); + stash = [].concat(stash); + if (!stash.length) + return queue; + if (!queue.length) { + return enclose ? utils.flatten(stash).map(ele => `{${ele}}`) : stash; + } + for (let item of queue) { + if (Array.isArray(item)) { + for (let value of item) { + result.push(append(value, stash, enclose)); + } + } + else { + for (let ele of stash) { + if (enclose === true && typeof ele === 'string') + ele = `{${ele}}`; + result.push(Array.isArray(ele) ? append(item, ele, enclose) : (item + ele)); + } + } + } + return utils.flatten(result); +}; +const expand = (ast, options = {}) => { + let rangeLimit = options.rangeLimit === void 0 ? 1000 : options.rangeLimit; + let walk = (node, parent = {}) => { + node.queue = []; + let p = parent; + let q = parent.queue; + while (p.type !== 'brace' && p.type !== 'root' && p.parent) { + p = p.parent; + q = p.queue; + } + if (node.invalid || node.dollar) { + q.push(append(q.pop(), stringify(node, options))); + return; + } + if (node.type === 'brace' && node.invalid !== true && node.nodes.length === 2) { + q.push(append(q.pop(), ['{}'])); + return; + } + if (node.nodes && node.ranges > 0) { + let args = utils.reduce(node.nodes); + if (utils.exceedsLimit(...args, options.step, rangeLimit)) { + throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.'); + } + let range = fillRange(...args, options); + if (range.length === 0) { + range = stringify(node, options); + } + q.push(append(q.pop(), range)); + node.nodes = []; + return; + } + let enclose = utils.encloseBrace(node); + let queue = node.queue; + let block = node; + while (block.type !== 'brace' && block.type !== 'root' && block.parent) { + block = block.parent; + queue = block.queue; + } + for (let i = 0; i < node.nodes.length; i++) { + let child = node.nodes[i]; + if (child.type === 'comma' && node.type === 'brace') { + if (i === 1) + queue.push(''); + queue.push(''); + continue; + } + if (child.type === 'close') { + q.push(append(q.pop(), queue, enclose)); + continue; + } + if (child.value && child.type !== 'open') { + queue.push(append(queue.pop(), child.value)); + continue; + } + if (child.nodes) { + walk(child, node); + } + } + return queue; + }; + return utils.flatten(walk(ast)); +}; +var expand_1 = expand; + +var constants = { + MAX_LENGTH: 1024 * 64, + // Digits + CHAR_0: '0', + CHAR_9: '9', + // Alphabet chars. + CHAR_UPPERCASE_A: 'A', + CHAR_LOWERCASE_A: 'a', + CHAR_UPPERCASE_Z: 'Z', + CHAR_LOWERCASE_Z: 'z', + CHAR_LEFT_PARENTHESES: '(', + CHAR_RIGHT_PARENTHESES: ')', + CHAR_ASTERISK: '*', + // Non-alphabetic chars. + CHAR_AMPERSAND: '&', + CHAR_AT: '@', + CHAR_BACKSLASH: '\\', + CHAR_BACKTICK: '`', + CHAR_CARRIAGE_RETURN: '\r', + CHAR_CIRCUMFLEX_ACCENT: '^', + CHAR_COLON: ':', + CHAR_COMMA: ',', + CHAR_DOLLAR: '$', + CHAR_DOT: '.', + CHAR_DOUBLE_QUOTE: '"', + CHAR_EQUAL: '=', + CHAR_EXCLAMATION_MARK: '!', + CHAR_FORM_FEED: '\f', + CHAR_FORWARD_SLASH: '/', + CHAR_HASH: '#', + CHAR_HYPHEN_MINUS: '-', + CHAR_LEFT_ANGLE_BRACKET: '<', + CHAR_LEFT_CURLY_BRACE: '{', + CHAR_LEFT_SQUARE_BRACKET: '[', + CHAR_LINE_FEED: '\n', + CHAR_NO_BREAK_SPACE: '\u00A0', + CHAR_PERCENT: '%', + CHAR_PLUS: '+', + CHAR_QUESTION_MARK: '?', + CHAR_RIGHT_ANGLE_BRACKET: '>', + CHAR_RIGHT_CURLY_BRACE: '}', + CHAR_RIGHT_SQUARE_BRACKET: ']', + CHAR_SEMICOLON: ';', + CHAR_SINGLE_QUOTE: '\'', + CHAR_SPACE: ' ', + CHAR_TAB: '\t', + CHAR_UNDERSCORE: '_', + CHAR_VERTICAL_LINE: '|', + CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\uFEFF' /* \uFEFF */ +}; + +/** + * Constants + */ +const { MAX_LENGTH, CHAR_BACKSLASH, /* \ */ CHAR_BACKTICK, /* ` */ CHAR_COMMA, /* , */ CHAR_DOT, /* . */ CHAR_LEFT_PARENTHESES, /* ( */ CHAR_RIGHT_PARENTHESES, /* ) */ CHAR_LEFT_CURLY_BRACE, /* { */ CHAR_RIGHT_CURLY_BRACE, /* } */ CHAR_LEFT_SQUARE_BRACKET, /* [ */ CHAR_RIGHT_SQUARE_BRACKET, /* ] */ CHAR_DOUBLE_QUOTE, /* " */ CHAR_SINGLE_QUOTE, /* ' */ CHAR_NO_BREAK_SPACE, CHAR_ZERO_WIDTH_NOBREAK_SPACE } = constants; +/** + * parse + */ +const parse = (input, options = {}) => { + if (typeof input !== 'string') { + throw new TypeError('Expected a string'); + } + let opts = options || {}; + let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH; + if (input.length > max) { + throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`); + } + let ast = { type: 'root', input, nodes: [] }; + let stack = [ast]; + let block = ast; + let prev = ast; + let brackets = 0; + let length = input.length; + let index = 0; + let depth = 0; + let value; + /** + * Helpers + */ + const advance = () => input[index++]; + const push = node => { + if (node.type === 'text' && prev.type === 'dot') { + prev.type = 'text'; + } + if (prev && prev.type === 'text' && node.type === 'text') { + prev.value += node.value; + return; + } + block.nodes.push(node); + node.parent = block; + node.prev = prev; + prev = node; + return node; + }; + push({ type: 'bos' }); + while (index < length) { + block = stack[stack.length - 1]; + value = advance(); + /** + * Invalid chars + */ + if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) { + continue; + } + /** + * Escaped chars + */ + if (value === CHAR_BACKSLASH) { + push({ type: 'text', value: (options.keepEscaping ? value : '') + advance() }); + continue; + } + /** + * Right square bracket (literal): ']' + */ + if (value === CHAR_RIGHT_SQUARE_BRACKET) { + push({ type: 'text', value: '\\' + value }); + continue; + } + /** + * Left square bracket: '[' + */ + if (value === CHAR_LEFT_SQUARE_BRACKET) { + brackets++; + let next; + while (index < length && (next = advance())) { + value += next; + if (next === CHAR_LEFT_SQUARE_BRACKET) { + brackets++; + continue; + } + if (next === CHAR_BACKSLASH) { + value += advance(); + continue; + } + if (next === CHAR_RIGHT_SQUARE_BRACKET) { + brackets--; + if (brackets === 0) { + break; + } + } + } + push({ type: 'text', value }); + continue; + } + /** + * Parentheses + */ + if (value === CHAR_LEFT_PARENTHESES) { + block = push({ type: 'paren', nodes: [] }); + stack.push(block); + push({ type: 'text', value }); + continue; + } + if (value === CHAR_RIGHT_PARENTHESES) { + if (block.type !== 'paren') { + push({ type: 'text', value }); + continue; + } + block = stack.pop(); + push({ type: 'text', value }); + block = stack[stack.length - 1]; + continue; + } + /** + * Quotes: '|"|` + */ + if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) { + let open = value; + let next; + if (options.keepQuotes !== true) { + value = ''; + } + while (index < length && (next = advance())) { + if (next === CHAR_BACKSLASH) { + value += next + advance(); + continue; + } + if (next === open) { + if (options.keepQuotes === true) + value += next; + break; + } + value += next; + } + push({ type: 'text', value }); + continue; + } + /** + * Left curly brace: '{' + */ + if (value === CHAR_LEFT_CURLY_BRACE) { + depth++; + let dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true; + let brace = { + type: 'brace', + open: true, + close: false, + dollar, + depth, + commas: 0, + ranges: 0, + nodes: [] + }; + block = push(brace); + stack.push(block); + push({ type: 'open', value }); + continue; + } + /** + * Right curly brace: '}' + */ + if (value === CHAR_RIGHT_CURLY_BRACE) { + if (block.type !== 'brace') { + push({ type: 'text', value }); + continue; + } + let type = 'close'; + block = stack.pop(); + block.close = true; + push({ type, value }); + depth--; + block = stack[stack.length - 1]; + continue; + } + /** + * Comma: ',' + */ + if (value === CHAR_COMMA && depth > 0) { + if (block.ranges > 0) { + block.ranges = 0; + let open = block.nodes.shift(); + block.nodes = [open, { type: 'text', value: stringify(block) }]; + } + push({ type: 'comma', value }); + block.commas++; + continue; + } + /** + * Dot: '.' + */ + if (value === CHAR_DOT && depth > 0 && block.commas === 0) { + let siblings = block.nodes; + if (depth === 0 || siblings.length === 0) { + push({ type: 'text', value }); + continue; + } + if (prev.type === 'dot') { + block.range = []; + prev.value += value; + prev.type = 'range'; + if (block.nodes.length !== 3 && block.nodes.length !== 5) { + block.invalid = true; + block.ranges = 0; + prev.type = 'text'; + continue; + } + block.ranges++; + block.args = []; + continue; + } + if (prev.type === 'range') { + siblings.pop(); + let before = siblings[siblings.length - 1]; + before.value += prev.value + value; + prev = before; + block.ranges--; + continue; + } + push({ type: 'dot', value }); + continue; + } + /** + * Text + */ + push({ type: 'text', value }); + } + // Mark imbalanced braces and brackets as invalid + do { + block = stack.pop(); + if (block.type !== 'root') { + block.nodes.forEach(node => { + if (!node.nodes) { + if (node.type === 'open') + node.isOpen = true; + if (node.type === 'close') + node.isClose = true; + if (!node.nodes) + node.type = 'text'; + node.invalid = true; + } + }); + // get the location of the block on parent.nodes (block's siblings) + let parent = stack[stack.length - 1]; + let index = parent.nodes.indexOf(block); + // replace the (invalid) block with it's nodes + parent.nodes.splice(index, 1, ...block.nodes); + } + } while (stack.length > 0); + push({ type: 'eos' }); + return ast; +}; +var parse_1 = parse; + +/** + * Expand the given pattern or create a regex-compatible string. + * + * ```js + * const braces = require('braces'); + * console.log(braces('{a,b,c}', { compile: true })); //=> ['(a|b|c)'] + * console.log(braces('{a,b,c}')); //=> ['a', 'b', 'c'] + * ``` + * @param {String} `str` + * @param {Object} `options` + * @return {String} + * @api public + */ +const braces = (input, options = {}) => { + let output = []; + if (Array.isArray(input)) { + for (let pattern of input) { + let result = braces.create(pattern, options); + if (Array.isArray(result)) { + output.push(...result); + } + else { + output.push(result); + } + } + } + else { + output = [].concat(braces.create(input, options)); + } + if (options && options.expand === true && options.nodupes === true) { + output = [...new Set(output)]; + } + return output; +}; +/** + * Parse the given `str` with the given `options`. + * + * ```js + * // braces.parse(pattern, [, options]); + * const ast = braces.parse('a/{b,c}/d'); + * console.log(ast); + * ``` + * @param {String} pattern Brace pattern to parse + * @param {Object} options + * @return {Object} Returns an AST + * @api public + */ +braces.parse = (input, options = {}) => parse_1(input, options); +/** + * Creates a braces string from an AST, or an AST node. + * + * ```js + * const braces = require('braces'); + * let ast = braces.parse('foo/{a,b}/bar'); + * console.log(stringify(ast.nodes[2])); //=> '{a,b}' + * ``` + * @param {String} `input` Brace pattern or AST. + * @param {Object} `options` + * @return {Array} Returns an array of expanded values. + * @api public + */ +braces.stringify = (input, options = {}) => { + if (typeof input === 'string') { + return stringify(braces.parse(input, options), options); + } + return stringify(input, options); +}; +/** + * Compiles a brace pattern into a regex-compatible, optimized string. + * This method is called by the main [braces](#braces) function by default. + * + * ```js + * const braces = require('braces'); + * console.log(braces.compile('a/{b,c}/d')); + * //=> ['a/(b|c)/d'] + * ``` + * @param {String} `input` Brace pattern or AST. + * @param {Object} `options` + * @return {Array} Returns an array of expanded values. + * @api public + */ +braces.compile = (input, options = {}) => { + if (typeof input === 'string') { + input = braces.parse(input, options); + } + return compile_1(input, options); +}; +/** + * Expands a brace pattern into an array. This method is called by the + * main [braces](#braces) function when `options.expand` is true. Before + * using this method it's recommended that you read the [performance notes](#performance)) + * and advantages of using [.compile](#compile) instead. + * + * ```js + * const braces = require('braces'); + * console.log(braces.expand('a/{b,c}/d')); + * //=> ['a/b/d', 'a/c/d']; + * ``` + * @param {String} `pattern` Brace pattern + * @param {Object} `options` + * @return {Array} Returns an array of expanded values. + * @api public + */ +braces.expand = (input, options = {}) => { + if (typeof input === 'string') { + input = braces.parse(input, options); + } + let result = expand_1(input, options); + // filter out empty strings if specified + if (options.noempty === true) { + result = result.filter(Boolean); + } + // filter out duplicates if specified + if (options.nodupes === true) { + result = [...new Set(result)]; + } + return result; +}; +/** + * Processes a brace pattern and returns either an expanded array + * (if `options.expand` is true), a highly optimized regex-compatible string. + * This method is called by the main [braces](#braces) function. + * + * ```js + * const braces = require('braces'); + * console.log(braces.create('user-{200..300}/project-{a,b,c}-{1..10}')) + * //=> 'user-(20[0-9]|2[1-9][0-9]|300)/project-(a|b|c)-([1-9]|10)' + * ``` + * @param {String} `pattern` Brace pattern + * @param {Object} `options` + * @return {Array} Returns an array of expanded values. + * @api public + */ +braces.create = (input, options = {}) => { + if (input === '' || input.length < 3) { + return [input]; + } + return options.expand !== true + ? braces.compile(input, options) + : braces.expand(input, options); +}; +/** + * Expose "braces" + */ +var braces_1 = braces; + +const WIN_SLASH = '\\\\/'; +const WIN_NO_SLASH = `[^${WIN_SLASH}]`; +/** + * Posix glob regex + */ +const DOT_LITERAL = '\\.'; +const PLUS_LITERAL = '\\+'; +const QMARK_LITERAL = '\\?'; +const SLASH_LITERAL = '\\/'; +const ONE_CHAR = '(?=.)'; +const QMARK = '[^/]'; +const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`; +const START_ANCHOR = `(?:^|${SLASH_LITERAL})`; +const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`; +const NO_DOT = `(?!${DOT_LITERAL})`; +const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`; +const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`; +const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`; +const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`; +const STAR = `${QMARK}*?`; +const POSIX_CHARS = { + DOT_LITERAL, + PLUS_LITERAL, + QMARK_LITERAL, + SLASH_LITERAL, + ONE_CHAR, + QMARK, + END_ANCHOR, + DOTS_SLASH, + NO_DOT, + NO_DOTS, + NO_DOT_SLASH, + NO_DOTS_SLASH, + QMARK_NO_DOT, + STAR, + START_ANCHOR +}; +/** + * Windows glob regex + */ +const WINDOWS_CHARS = Object.assign({}, POSIX_CHARS, { SLASH_LITERAL: `[${WIN_SLASH}]`, QMARK: WIN_NO_SLASH, STAR: `${WIN_NO_SLASH}*?`, DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`, NO_DOT: `(?!${DOT_LITERAL})`, NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`, NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`, NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`, QMARK_NO_DOT: `[^.${WIN_SLASH}]`, START_ANCHOR: `(?:^|[${WIN_SLASH}])`, END_ANCHOR: `(?:[${WIN_SLASH}]|$)` }); +/** + * POSIX Bracket Regex + */ +const POSIX_REGEX_SOURCE = { + alnum: 'a-zA-Z0-9', + alpha: 'a-zA-Z', + ascii: '\\x00-\\x7F', + blank: ' \\t', + cntrl: '\\x00-\\x1F\\x7F', + digit: '0-9', + graph: '\\x21-\\x7E', + lower: 'a-z', + print: '\\x20-\\x7E ', + punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~', + space: ' \\t\\r\\n\\v\\f', + upper: 'A-Z', + word: 'A-Za-z0-9_', + xdigit: 'A-Fa-f0-9' +}; +var constants$1 = { + MAX_LENGTH: 1024 * 64, + POSIX_REGEX_SOURCE, + // regular expressions + REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g, + REGEX_NON_SPECIAL_CHAR: /^[^@![\].,$*+?^{}()|\\/]+/, + REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/, + REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g, + REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g, + REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g, + // Replace globs with equivalent patterns to reduce parsing time. + REPLACEMENTS: { + '***': '*', + '**/**': '**', + '**/**/**': '**' + }, + // Digits + CHAR_0: 48, + CHAR_9: 57, + // Alphabet chars. + CHAR_UPPERCASE_A: 65, + CHAR_LOWERCASE_A: 97, + CHAR_UPPERCASE_Z: 90, + CHAR_LOWERCASE_Z: 122, + CHAR_LEFT_PARENTHESES: 40, + CHAR_RIGHT_PARENTHESES: 41, + CHAR_ASTERISK: 42, + // Non-alphabetic chars. + CHAR_AMPERSAND: 38, + CHAR_AT: 64, + CHAR_BACKWARD_SLASH: 92, + CHAR_CARRIAGE_RETURN: 13, + CHAR_CIRCUMFLEX_ACCENT: 94, + CHAR_COLON: 58, + CHAR_COMMA: 44, + CHAR_DOT: 46, + CHAR_DOUBLE_QUOTE: 34, + CHAR_EQUAL: 61, + CHAR_EXCLAMATION_MARK: 33, + CHAR_FORM_FEED: 12, + CHAR_FORWARD_SLASH: 47, + CHAR_GRAVE_ACCENT: 96, + CHAR_HASH: 35, + CHAR_HYPHEN_MINUS: 45, + CHAR_LEFT_ANGLE_BRACKET: 60, + CHAR_LEFT_CURLY_BRACE: 123, + CHAR_LEFT_SQUARE_BRACKET: 91, + CHAR_LINE_FEED: 10, + CHAR_NO_BREAK_SPACE: 160, + CHAR_PERCENT: 37, + CHAR_PLUS: 43, + CHAR_QUESTION_MARK: 63, + CHAR_RIGHT_ANGLE_BRACKET: 62, + CHAR_RIGHT_CURLY_BRACE: 125, + CHAR_RIGHT_SQUARE_BRACKET: 93, + CHAR_SEMICOLON: 59, + CHAR_SINGLE_QUOTE: 39, + CHAR_SPACE: 32, + CHAR_TAB: 9, + CHAR_UNDERSCORE: 95, + CHAR_VERTICAL_LINE: 124, + CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, + SEP: path.sep, + /** + * Create EXTGLOB_CHARS + */ + extglobChars(chars) { + return { + '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` }, + '?': { type: 'qmark', open: '(?:', close: ')?' }, + '+': { type: 'plus', open: '(?:', close: ')+' }, + '*': { type: 'star', open: '(?:', close: ')*' }, + '@': { type: 'at', open: '(?:', close: ')' } + }; + }, + /** + * Create GLOB_CHARS + */ + globChars(win32) { + return win32 === true ? WINDOWS_CHARS : POSIX_CHARS; + } +}; + +var utils$1 = createCommonjsModule(function (module, exports) { + const win32 = process.platform === 'win32'; + const { REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL, REGEX_REMOVE_BACKSLASH } = constants$1; + exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val); + exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str); + exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str); + exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1'); + exports.toPosixSlashes = str => str.replace(/\\/g, '/'); + exports.removeBackslashes = str => { + return str.replace(REGEX_REMOVE_BACKSLASH, match => { + return match === '\\' ? '' : match; + }); + }; + exports.supportsLookbehinds = () => { + let segs = process.version.slice(1).split('.'); + if (segs.length === 3 && +segs[0] >= 9 || (+segs[0] === 8 && +segs[1] >= 10)) { + return true; + } + return false; + }; + exports.isWindows = options => { + if (options && typeof options.windows === 'boolean') { + return options.windows; + } + return win32 === true || path.sep === '\\'; + }; + exports.escapeLast = (input, char, lastIdx) => { + let idx = input.lastIndexOf(char, lastIdx); + if (idx === -1) + return input; + if (input[idx - 1] === '\\') + return exports.escapeLast(input, char, idx - 1); + return input.slice(0, idx) + '\\' + input.slice(idx); + }; +}); +var utils_1$1 = utils$1.isObject; +var utils_2$1 = utils$1.hasRegexChars; +var utils_3$1 = utils$1.isRegexChar; +var utils_4$1 = utils$1.escapeRegex; +var utils_5$1 = utils$1.toPosixSlashes; +var utils_6$1 = utils$1.removeBackslashes; +var utils_7$1 = utils$1.supportsLookbehinds; +var utils_8$1 = utils$1.isWindows; +var utils_9$1 = utils$1.escapeLast; + +const { CHAR_ASTERISK, /* * */ CHAR_AT, /* @ */ CHAR_BACKWARD_SLASH, /* \ */ CHAR_COMMA: CHAR_COMMA$1, /* , */ CHAR_DOT: CHAR_DOT$1, /* . */ CHAR_EXCLAMATION_MARK, /* ! */ CHAR_FORWARD_SLASH, /* / */ CHAR_LEFT_CURLY_BRACE: CHAR_LEFT_CURLY_BRACE$1, /* { */ CHAR_LEFT_PARENTHESES: CHAR_LEFT_PARENTHESES$1, /* ( */ CHAR_LEFT_SQUARE_BRACKET: CHAR_LEFT_SQUARE_BRACKET$1, /* [ */ CHAR_PLUS, /* + */ CHAR_QUESTION_MARK, /* ? */ CHAR_RIGHT_CURLY_BRACE: CHAR_RIGHT_CURLY_BRACE$1, /* } */ CHAR_RIGHT_PARENTHESES: CHAR_RIGHT_PARENTHESES$1, /* ) */ CHAR_RIGHT_SQUARE_BRACKET: CHAR_RIGHT_SQUARE_BRACKET$1 /* ] */ } = constants$1; +const isPathSeparator = code => { + return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH; +}; +/** + * Quickly scans a glob pattern and returns an object with a handful of + * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists), + * `glob` (the actual pattern), and `negated` (true if the path starts with `!`). + * + * ```js + * const pm = require('picomatch'); + * console.log(pm.scan('foo/bar/*.js')); + * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' } + * ``` + * @param {String} `str` + * @param {Object} `options` + * @return {Object} Returns an object with tokens and regex source string. + * @api public + */ +var scan = (input, options) => { + let opts = options || {}; + let length = input.length - 1; + let index = -1; + let start = 0; + let lastIndex = 0; + let isGlob = false; + let backslashes = false; + let negated = false; + let braces = 0; + let prev; + let code; + let braceEscaped = false; + let eos = () => index >= length; + let advance = () => { + prev = code; + return input.charCodeAt(++index); + }; + while (index < length) { + code = advance(); + let next; + if (code === CHAR_BACKWARD_SLASH) { + backslashes = true; + next = advance(); + if (next === CHAR_LEFT_CURLY_BRACE$1) { + braceEscaped = true; + } + continue; + } + if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE$1) { + braces++; + while (!eos() && (next = advance())) { + if (next === CHAR_BACKWARD_SLASH) { + backslashes = true; + next = advance(); + continue; + } + if (next === CHAR_LEFT_CURLY_BRACE$1) { + braces++; + continue; + } + if (!braceEscaped && next === CHAR_DOT$1 && (next = advance()) === CHAR_DOT$1) { + isGlob = true; + break; + } + if (!braceEscaped && next === CHAR_COMMA$1) { + isGlob = true; + break; + } + if (next === CHAR_RIGHT_CURLY_BRACE$1) { + braces--; + if (braces === 0) { + braceEscaped = false; + break; + } + } + } + } + if (code === CHAR_FORWARD_SLASH) { + if (prev === CHAR_DOT$1 && index === (start + 1)) { + start += 2; + continue; + } + lastIndex = index + 1; + continue; + } + if (code === CHAR_ASTERISK) { + isGlob = true; + break; + } + if (code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK) { + isGlob = true; + break; + } + if (code === CHAR_LEFT_SQUARE_BRACKET$1) { + while (!eos() && (next = advance())) { + if (next === CHAR_BACKWARD_SLASH) { + backslashes = true; + next = advance(); + continue; + } + if (next === CHAR_RIGHT_SQUARE_BRACKET$1) { + isGlob = true; + break; + } + } + } + let isExtglobChar = code === CHAR_PLUS + || code === CHAR_AT + || code === CHAR_EXCLAMATION_MARK; + if (isExtglobChar && input.charCodeAt(index + 1) === CHAR_LEFT_PARENTHESES$1) { + isGlob = true; + break; + } + if (code === CHAR_EXCLAMATION_MARK && index === start) { + negated = true; + start++; + continue; + } + if (code === CHAR_LEFT_PARENTHESES$1) { + while (!eos() && (next = advance())) { + if (next === CHAR_BACKWARD_SLASH) { + backslashes = true; + next = advance(); + continue; + } + if (next === CHAR_RIGHT_PARENTHESES$1) { + isGlob = true; + break; + } + } + } + if (isGlob) { + break; + } + } + let prefix = ''; + let orig = input; + let base = input; + let glob = ''; + if (start > 0) { + prefix = input.slice(0, start); + input = input.slice(start); + lastIndex -= start; + } + if (base && isGlob === true && lastIndex > 0) { + base = input.slice(0, lastIndex); + glob = input.slice(lastIndex); + } + else if (isGlob === true) { + base = ''; + glob = input; + } + else { + base = input; + } + if (base && base !== '' && base !== '/' && base !== input) { + if (isPathSeparator(base.charCodeAt(base.length - 1))) { + base = base.slice(0, -1); + } + } + if (opts.unescape === true) { + if (glob) + glob = utils$1.removeBackslashes(glob); + if (base && backslashes === true) { + base = utils$1.removeBackslashes(base); + } + } + return { prefix, input: orig, base, glob, negated, isGlob }; +}; + +/** + * Constants + */ +const { MAX_LENGTH: MAX_LENGTH$1, POSIX_REGEX_SOURCE: POSIX_REGEX_SOURCE$1, REGEX_NON_SPECIAL_CHAR, REGEX_SPECIAL_CHARS_BACKREF, REPLACEMENTS } = constants$1; +/** + * Helpers + */ +const expandRange = (args, options) => { + if (typeof options.expandRange === 'function') { + return options.expandRange(...args, options); + } + args.sort(); + let value = `[${args.join('-')}]`; + return value; +}; +const negate = state => { + let count = 1; + while (state.peek() === '!' && (state.peek(2) !== '(' || state.peek(3) === '?')) { + state.advance(); + state.start++; + count++; + } + if (count % 2 === 0) { + return false; + } + state.negated = true; + state.start++; + return true; +}; +/** + * Create the message for a syntax error + */ +const syntaxError = (type, char) => { + return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`; +}; +/** + * Parse the given input string. + * @param {String} input + * @param {Object} options + * @return {Object} + */ +const parse$1 = (input, options) => { + if (typeof input !== 'string') { + throw new TypeError('Expected a string'); + } + input = REPLACEMENTS[input] || input; + let opts = Object.assign({}, options); + let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$1, opts.maxLength) : MAX_LENGTH$1; + let len = input.length; + if (len > max) { + throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`); + } + let bos = { type: 'bos', value: '', output: opts.prepend || '' }; + let tokens = [bos]; + let capture = opts.capture ? '' : '?:'; + let win32 = utils$1.isWindows(options); + // create constants based on platform, for windows or posix + const PLATFORM_CHARS = constants$1.globChars(win32); + const EXTGLOB_CHARS = constants$1.extglobChars(PLATFORM_CHARS); + const { DOT_LITERAL, PLUS_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOT_SLASH, NO_DOTS_SLASH, QMARK, QMARK_NO_DOT, STAR, START_ANCHOR } = PLATFORM_CHARS; + const globstar = (opts) => { + return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`; + }; + let nodot = opts.dot ? '' : NO_DOT; + let star = opts.bash === true ? globstar(opts) : STAR; + let qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT; + if (opts.capture) { + star = `(${star})`; + } + // minimatch options support + if (typeof opts.noext === 'boolean') { + opts.noextglob = opts.noext; + } + let state = { + index: -1, + start: 0, + consumed: '', + output: '', + backtrack: false, + brackets: 0, + braces: 0, + parens: 0, + quotes: 0, + tokens + }; + let extglobs = []; + let stack = []; + let prev = bos; + let value; + /** + * Tokenizing helpers + */ + const eos = () => state.index === len - 1; + const peek = state.peek = (n = 1) => input[state.index + n]; + const advance = state.advance = () => input[++state.index]; + const append = token => { + state.output += token.output != null ? token.output : token.value; + state.consumed += token.value || ''; + }; + const increment = type => { + state[type]++; + stack.push(type); + }; + const decrement = type => { + state[type]--; + stack.pop(); + }; + /** + * Push tokens onto the tokens array. This helper speeds up + * tokenizing by 1) helping us avoid backtracking as much as possible, + * and 2) helping us avoid creating extra tokens when consecutive + * characters are plain text. This improves performance and simplifies + * lookbehinds. + */ + const push = tok => { + if (prev.type === 'globstar') { + let isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace'); + let isExtglob = extglobs.length && (tok.type === 'pipe' || tok.type === 'paren'); + if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) { + state.output = state.output.slice(0, -prev.output.length); + prev.type = 'star'; + prev.value = '*'; + prev.output = star; + state.output += prev.output; + } + } + if (extglobs.length && tok.type !== 'paren' && !EXTGLOB_CHARS[tok.value]) { + extglobs[extglobs.length - 1].inner += tok.value; + } + if (tok.value || tok.output) + append(tok); + if (prev && prev.type === 'text' && tok.type === 'text') { + prev.value += tok.value; + return; + } + tok.prev = prev; + tokens.push(tok); + prev = tok; + }; + const extglobOpen = (type, value) => { + let token = Object.assign({}, EXTGLOB_CHARS[value], { conditions: 1, inner: '' }); + token.prev = prev; + token.parens = state.parens; + token.output = state.output; + let output = (opts.capture ? '(' : '') + token.open; + push({ type, value, output: state.output ? '' : ONE_CHAR }); + push({ type: 'paren', extglob: true, value: advance(), output }); + increment('parens'); + extglobs.push(token); + }; + const extglobClose = token => { + let output = token.close + (opts.capture ? ')' : ''); + if (token.type === 'negate') { + let extglobStar = star; + if (token.inner && token.inner.length > 1 && token.inner.includes('/')) { + extglobStar = globstar(opts); + } + if (extglobStar !== star || eos() || /^\)+$/.test(input.slice(state.index + 1))) { + output = token.close = ')$))' + extglobStar; + } + if (token.prev.type === 'bos' && eos()) { + state.negatedExtglob = true; + } + } + push({ type: 'paren', extglob: true, value, output }); + decrement('parens'); + }; + if (opts.fastpaths !== false && !/(^[*!]|[/{[()\]}"])/.test(input)) { + let backslashes = false; + let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => { + if (first === '\\') { + backslashes = true; + return m; + } + if (first === '?') { + if (esc) { + return esc + first + (rest ? QMARK.repeat(rest.length) : ''); + } + if (index === 0) { + return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : ''); + } + return QMARK.repeat(chars.length); + } + if (first === '.') { + return DOT_LITERAL.repeat(chars.length); + } + if (first === '*') { + if (esc) { + return esc + first + (rest ? star : ''); + } + return star; + } + return esc ? m : '\\' + m; + }); + if (backslashes === true) { + if (opts.unescape === true) { + output = output.replace(/\\/g, ''); + } + else { + output = output.replace(/\\+/g, m => { + return m.length % 2 === 0 ? '\\\\' : (m ? '\\' : ''); + }); + } + } + state.output = output; + return state; + } + /** + * Tokenize input until we reach end-of-string + */ + while (!eos()) { + value = advance(); + if (value === '\u0000') { + continue; + } + /** + * Escaped characters + */ + if (value === '\\') { + let next = peek(); + if (next === '/' && opts.bash !== true) { + continue; + } + if (next === '.' || next === ';') { + continue; + } + if (!next) { + value += '\\'; + push({ type: 'text', value }); + continue; + } + // collapse slashes to reduce potential for exploits + let match = /^\\+/.exec(input.slice(state.index + 1)); + let slashes = 0; + if (match && match[0].length > 2) { + slashes = match[0].length; + state.index += slashes; + if (slashes % 2 !== 0) { + value += '\\'; + } + } + if (opts.unescape === true) { + value = advance() || ''; + } + else { + value += advance() || ''; + } + if (state.brackets === 0) { + push({ type: 'text', value }); + continue; + } + } + /** + * If we're inside a regex character class, continue + * until we reach the closing bracket. + */ + if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) { + if (opts.posix !== false && value === ':') { + let inner = prev.value.slice(1); + if (inner.includes('[')) { + prev.posix = true; + if (inner.includes(':')) { + let idx = prev.value.lastIndexOf('['); + let pre = prev.value.slice(0, idx); + let rest = prev.value.slice(idx + 2); + let posix = POSIX_REGEX_SOURCE$1[rest]; + if (posix) { + prev.value = pre + posix; + state.backtrack = true; + advance(); + if (!bos.output && tokens.indexOf(prev) === 1) { + bos.output = ONE_CHAR; + } + continue; + } + } + } + } + if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) { + value = '\\' + value; + } + if (value === ']' && (prev.value === '[' || prev.value === '[^')) { + value = '\\' + value; + } + if (opts.posix === true && value === '!' && prev.value === '[') { + value = '^'; + } + prev.value += value; + append({ value }); + continue; + } + /** + * If we're inside a quoted string, continue + * until we reach the closing double quote. + */ + if (state.quotes === 1 && value !== '"') { + value = utils$1.escapeRegex(value); + prev.value += value; + append({ value }); + continue; + } + /** + * Double quotes + */ + if (value === '"') { + state.quotes = state.quotes === 1 ? 0 : 1; + if (opts.keepQuotes === true) { + push({ type: 'text', value }); + } + continue; + } + /** + * Parentheses + */ + if (value === '(') { + push({ type: 'paren', value }); + increment('parens'); + continue; + } + if (value === ')') { + if (state.parens === 0 && opts.strictBrackets === true) { + throw new SyntaxError(syntaxError('opening', '(')); + } + let extglob = extglobs[extglobs.length - 1]; + if (extglob && state.parens === extglob.parens + 1) { + extglobClose(extglobs.pop()); + continue; + } + push({ type: 'paren', value, output: state.parens ? ')' : '\\)' }); + decrement('parens'); + continue; + } + /** + * Brackets + */ + if (value === '[') { + if (opts.nobracket === true || !input.slice(state.index + 1).includes(']')) { + if (opts.nobracket !== true && opts.strictBrackets === true) { + throw new SyntaxError(syntaxError('closing', ']')); + } + value = '\\' + value; + } + else { + increment('brackets'); + } + push({ type: 'bracket', value }); + continue; + } + if (value === ']') { + if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) { + push({ type: 'text', value, output: '\\' + value }); + continue; + } + if (state.brackets === 0) { + if (opts.strictBrackets === true) { + throw new SyntaxError(syntaxError('opening', '[')); + } + push({ type: 'text', value, output: '\\' + value }); + continue; + } + decrement('brackets'); + let prevValue = prev.value.slice(1); + if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) { + value = '/' + value; + } + prev.value += value; + append({ value }); + // when literal brackets are explicitly disabled + // assume we should match with a regex character class + if (opts.literalBrackets === false || utils$1.hasRegexChars(prevValue)) { + continue; + } + let escaped = utils$1.escapeRegex(prev.value); + state.output = state.output.slice(0, -prev.value.length); + // when literal brackets are explicitly enabled + // assume we should escape the brackets to match literal characters + if (opts.literalBrackets === true) { + state.output += escaped; + prev.value = escaped; + continue; + } + // when the user specifies nothing, try to match both + prev.value = `(${capture}${escaped}|${prev.value})`; + state.output += prev.value; + continue; + } + /** + * Braces + */ + if (value === '{' && opts.nobrace !== true) { + push({ type: 'brace', value, output: '(' }); + increment('braces'); + continue; + } + if (value === '}') { + if (opts.nobrace === true || state.braces === 0) { + push({ type: 'text', value, output: '\\' + value }); + continue; + } + let output = ')'; + if (state.dots === true) { + let arr = tokens.slice(); + let range = []; + for (let i = arr.length - 1; i >= 0; i--) { + tokens.pop(); + if (arr[i].type === 'brace') { + break; + } + if (arr[i].type !== 'dots') { + range.unshift(arr[i].value); + } + } + output = expandRange(range, opts); + state.backtrack = true; + } + push({ type: 'brace', value, output }); + decrement('braces'); + continue; + } + /** + * Pipes + */ + if (value === '|') { + if (extglobs.length > 0) { + extglobs[extglobs.length - 1].conditions++; + } + push({ type: 'text', value }); + continue; + } + /** + * Commas + */ + if (value === ',') { + let output = value; + if (state.braces > 0 && stack[stack.length - 1] === 'braces') { + output = '|'; + } + push({ type: 'comma', value, output }); + continue; + } + /** + * Slashes + */ + if (value === '/') { + // if the beginning of the glob is "./", advance the start + // to the current index, and don't add the "./" characters + // to the state. This greatly simplifies lookbehinds when + // checking for BOS characters like "!" and "." (not "./") + if (prev.type === 'dot' && state.index === 1) { + state.start = state.index + 1; + state.consumed = ''; + state.output = ''; + tokens.pop(); + prev = bos; // reset "prev" to the first token + continue; + } + push({ type: 'slash', value, output: SLASH_LITERAL }); + continue; + } + /** + * Dots + */ + if (value === '.') { + if (state.braces > 0 && prev.type === 'dot') { + if (prev.value === '.') + prev.output = DOT_LITERAL; + prev.type = 'dots'; + prev.output += value; + prev.value += value; + state.dots = true; + continue; + } + push({ type: 'dot', value, output: DOT_LITERAL }); + continue; + } + /** + * Question marks + */ + if (value === '?') { + if (prev && prev.type === 'paren') { + let next = peek(); + let output = value; + if (next === '<' && !utils$1.supportsLookbehinds()) { + throw new Error('Node.js v10 or higher is required for regex lookbehinds'); + } + if (prev.value === '(' && !/[!=<:]/.test(next) || (next === '<' && !/[!=]/.test(peek(2)))) { + output = '\\' + value; + } + push({ type: 'text', value, output }); + continue; + } + if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') { + extglobOpen('qmark', value); + continue; + } + if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) { + push({ type: 'qmark', value, output: QMARK_NO_DOT }); + continue; + } + push({ type: 'qmark', value, output: QMARK }); + continue; + } + /** + * Exclamation + */ + if (value === '!') { + if (opts.noextglob !== true && peek() === '(') { + if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) { + extglobOpen('negate', value); + continue; + } + } + if (opts.nonegate !== true && state.index === 0) { + negate(state); + continue; + } + } + /** + * Plus + */ + if (value === '+') { + if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') { + extglobOpen('plus', value); + continue; + } + if (prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) { + let output = prev.extglob === true ? '\\' + value : value; + push({ type: 'plus', value, output }); + continue; + } + // use regex behavior inside parens + if (state.parens > 0 && opts.regex !== false) { + push({ type: 'plus', value }); + continue; + } + push({ type: 'plus', value: PLUS_LITERAL }); + continue; + } + /** + * Plain text + */ + if (value === '@') { + if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') { + push({ type: 'at', value, output: '' }); + continue; + } + push({ type: 'text', value }); + continue; + } + /** + * Plain text + */ + if (value !== '*') { + if (value === '$' || value === '^') { + value = '\\' + value; + } + let match = REGEX_NON_SPECIAL_CHAR.exec(input.slice(state.index + 1)); + if (match) { + value += match[0]; + state.index += match[0].length; + } + push({ type: 'text', value }); + continue; + } + /** + * Stars + */ + if (prev && (prev.type === 'globstar' || prev.star === true)) { + prev.type = 'star'; + prev.star = true; + prev.value += value; + prev.output = star; + state.backtrack = true; + state.consumed += value; + continue; + } + if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') { + extglobOpen('star', value); + continue; + } + if (prev.type === 'star') { + if (opts.noglobstar === true) { + state.consumed += value; + continue; + } + let prior = prev.prev; + let before = prior.prev; + let isStart = prior.type === 'slash' || prior.type === 'bos'; + let afterStar = before && (before.type === 'star' || before.type === 'globstar'); + if (opts.bash === true && (!isStart || (!eos() && peek() !== '/'))) { + push({ type: 'star', value, output: '' }); + continue; + } + let isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace'); + let isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren'); + if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) { + push({ type: 'star', value, output: '' }); + continue; + } + // strip consecutive `/**/` + while (input.slice(state.index + 1, state.index + 4) === '/**') { + let after = input[state.index + 4]; + if (after && after !== '/') { + break; + } + state.consumed += '/**'; + state.index += 3; + } + if (prior.type === 'bos' && eos()) { + prev.type = 'globstar'; + prev.value += value; + prev.output = globstar(opts); + state.output = prev.output; + state.consumed += value; + continue; + } + if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) { + state.output = state.output.slice(0, -(prior.output + prev.output).length); + prior.output = '(?:' + prior.output; + prev.type = 'globstar'; + prev.output = globstar(opts) + '|$)'; + prev.value += value; + state.output += prior.output + prev.output; + state.consumed += value; + continue; + } + let next = peek(); + if (prior.type === 'slash' && prior.prev.type !== 'bos' && next === '/') { + let end = peek(2) !== void 0 ? '|$' : ''; + state.output = state.output.slice(0, -(prior.output + prev.output).length); + prior.output = '(?:' + prior.output; + prev.type = 'globstar'; + prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`; + prev.value += value; + state.output += prior.output + prev.output; + state.consumed += value + advance(); + push({ type: 'slash', value, output: '' }); + continue; + } + if (prior.type === 'bos' && next === '/') { + prev.type = 'globstar'; + prev.value += value; + prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`; + state.output = prev.output; + state.consumed += value + advance(); + push({ type: 'slash', value, output: '' }); + continue; + } + // remove single star from output + state.output = state.output.slice(0, -prev.output.length); + // reset previous token to globstar + prev.type = 'globstar'; + prev.output = globstar(opts); + prev.value += value; + // reset output with globstar + state.output += prev.output; + state.consumed += value; + continue; + } + let token = { type: 'star', value, output: star }; + if (opts.bash === true) { + token.output = '.*?'; + if (prev.type === 'bos' || prev.type === 'slash') { + token.output = nodot + token.output; + } + push(token); + continue; + } + if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) { + token.output = value; + push(token); + continue; + } + if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') { + if (prev.type === 'dot') { + state.output += NO_DOT_SLASH; + prev.output += NO_DOT_SLASH; + } + else if (opts.dot === true) { + state.output += NO_DOTS_SLASH; + prev.output += NO_DOTS_SLASH; + } + else { + state.output += nodot; + prev.output += nodot; + } + if (peek() !== '*') { + state.output += ONE_CHAR; + prev.output += ONE_CHAR; + } + } + push(token); + } + while (state.brackets > 0) { + if (opts.strictBrackets === true) + throw new SyntaxError(syntaxError('closing', ']')); + state.output = utils$1.escapeLast(state.output, '['); + decrement('brackets'); + } + while (state.parens > 0) { + if (opts.strictBrackets === true) + throw new SyntaxError(syntaxError('closing', ')')); + state.output = utils$1.escapeLast(state.output, '('); + decrement('parens'); + } + while (state.braces > 0) { + if (opts.strictBrackets === true) + throw new SyntaxError(syntaxError('closing', '}')); + state.output = utils$1.escapeLast(state.output, '{'); + decrement('braces'); + } + if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) { + push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` }); + } + // rebuild the output if we had to backtrack at any point + if (state.backtrack === true) { + state.output = ''; + for (let token of state.tokens) { + state.output += token.output != null ? token.output : token.value; + if (token.suffix) { + state.output += token.suffix; + } + } + } + return state; +}; +/** + * Fast paths for creating regular expressions for common glob patterns. + * This can significantly speed up processing and has very little downside + * impact when none of the fast paths match. + */ +parse$1.fastpaths = (input, options) => { + let opts = Object.assign({}, options); + let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$1, opts.maxLength) : MAX_LENGTH$1; + let len = input.length; + if (len > max) { + throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`); + } + input = REPLACEMENTS[input] || input; + let win32 = utils$1.isWindows(options); + // create constants based on platform, for windows or posix + const { DOT_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOTS, NO_DOTS_SLASH, STAR, START_ANCHOR } = constants$1.globChars(win32); + let capture = opts.capture ? '' : '?:'; + let star = opts.bash === true ? '.*?' : STAR; + let nodot = opts.dot ? NO_DOTS : NO_DOT; + let slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT; + if (opts.capture) { + star = `(${star})`; + } + const globstar = (opts) => { + return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`; + }; + const create = str => { + switch (str) { + case '*': + return `${nodot}${ONE_CHAR}${star}`; + case '.*': + return `${DOT_LITERAL}${ONE_CHAR}${star}`; + case '*.*': + return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`; + case '*/*': + return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`; + case '**': + return nodot + globstar(opts); + case '**/*': + return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`; + case '**/*.*': + return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`; + case '**/.*': + return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`; + default: { + let match = /^(.*?)\.(\w+)$/.exec(str); + if (!match) + return; + let source = create(match[1]); + if (!source) + return; + return source + DOT_LITERAL + match[2]; + } + } + }; + let output = create(input); + if (output && opts.strictSlashes !== true) { + output += `${SLASH_LITERAL}?`; + } + return output; +}; +var parse_1$1 = parse$1; + +/** + * Creates a matcher function from one or more glob patterns. The + * returned function takes a string to match as its first argument, + * and returns true if the string is a match. The returned matcher + * function also takes a boolean as the second argument that, when true, + * returns an object with additional information. + * + * ```js + * const picomatch = require('picomatch'); + * // picomatch(glob[, options]); + * + * const isMatch = picomatch('*.!(*a)'); + * console.log(isMatch('a.a')); //=> false + * console.log(isMatch('a.b')); //=> true + * ``` + * @name picomatch + * @param {String|Array} `globs` One or more glob patterns. + * @param {Object=} `options` + * @return {Function=} Returns a matcher function. + * @api public + */ +const picomatch = (glob, options, returnState = false) => { + if (Array.isArray(glob)) { + let fns = glob.map(input => picomatch(input, options, returnState)); + return str => { + for (let isMatch of fns) { + let state = isMatch(str); + if (state) + return state; + } + return false; + }; + } + if (typeof glob !== 'string' || glob === '') { + throw new TypeError('Expected pattern to be a non-empty string'); + } + let opts = options || {}; + let posix = utils$1.isWindows(options); + let regex = picomatch.makeRe(glob, options, false, true); + let state = regex.state; + delete regex.state; + let isIgnored = () => false; + if (opts.ignore) { + let ignoreOpts = Object.assign({}, options, { ignore: null, onMatch: null, onResult: null }); + isIgnored = picomatch(opts.ignore, ignoreOpts, returnState); + } + const matcher = (input, returnObject = false) => { + let { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix }); + let result = { glob, state, regex, posix, input, output, match, isMatch }; + if (typeof opts.onResult === 'function') { + opts.onResult(result); + } + if (isMatch === false) { + result.isMatch = false; + return returnObject ? result : false; + } + if (isIgnored(input)) { + if (typeof opts.onIgnore === 'function') { + opts.onIgnore(result); + } + result.isMatch = false; + return returnObject ? result : false; + } + if (typeof opts.onMatch === 'function') { + opts.onMatch(result); + } + return returnObject ? result : true; + }; + if (returnState) { + matcher.state = state; + } + return matcher; +}; +/** + * Test `input` with the given `regex`. This is used by the main + * `picomatch()` function to test the input string. + * + * ```js + * const picomatch = require('picomatch'); + * // picomatch.test(input, regex[, options]); + * + * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/)); + * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' } + * ``` + * @param {String} `input` String to test. + * @param {RegExp} `regex` + * @return {Object} Returns an object with matching info. + * @api public + */ +picomatch.test = (input, regex, options, { glob, posix } = {}) => { + if (typeof input !== 'string') { + throw new TypeError('Expected input to be a string'); + } + if (input === '') { + return { isMatch: false, output: '' }; + } + let opts = options || {}; + let format = opts.format || (posix ? utils$1.toPosixSlashes : null); + let match = input === glob; + let output = (match && format) ? format(input) : input; + if (match === false) { + output = format ? format(input) : input; + match = output === glob; + } + if (match === false || opts.capture === true) { + if (opts.matchBase === true || opts.basename === true) { + match = picomatch.matchBase(input, regex, options, posix); + } + else { + match = regex.exec(output); + } + } + return { isMatch: !!match, match, output }; +}; +/** + * Match the basename of a filepath. + * + * ```js + * const picomatch = require('picomatch'); + * // picomatch.matchBase(input, glob[, options]); + * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true + * ``` + * @param {String} `input` String to test. + * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe). + * @return {Boolean} + * @api public + */ +picomatch.matchBase = (input, glob, options, posix = utils$1.isWindows(options)) => { + let regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options); + return regex.test(path.basename(input)); +}; +/** + * Returns true if **any** of the given glob `patterns` match the specified `string`. + * + * ```js + * const picomatch = require('picomatch'); + * // picomatch.isMatch(string, patterns[, options]); + * + * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true + * console.log(picomatch.isMatch('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). + * @return {Boolean} Returns true if any patterns match `str` + * @api public + */ +picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str); +/** + * Parse a glob pattern to create the source string for a regular + * expression. + * + * ```js + * const picomatch = require('picomatch'); + * const result = picomatch.parse(glob[, options]); + * ``` + * @param {String} `glob` + * @param {Object} `options` + * @return {Object} Returns an object with useful properties and output to be used as a regex source string. + * @api public + */ +picomatch.parse = (glob, options) => parse_1$1(glob, options); +/** + * Scan a glob pattern to separate the pattern into segments. + * + * ```js + * const picomatch = require('picomatch'); + * // picomatch.scan(input[, options]); + * + * const result = picomatch.scan('!./foo/*.js'); + * console.log(result); + * // { prefix: '!./', + * // input: '!./foo/*.js', + * // base: 'foo', + * // glob: '*.js', + * // negated: true, + * // isGlob: true } + * ``` + * @param {String} `input` Glob pattern to scan. + * @param {Object} `options` + * @return {Object} Returns an object with + * @api public + */ +picomatch.scan = (input, options) => scan(input, options); +/** + * Create a regular expression from a glob pattern. + * + * ```js + * const picomatch = require('picomatch'); + * // picomatch.makeRe(input[, options]); + * + * console.log(picomatch.makeRe('*.js')); + * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/ + * ``` + * @param {String} `input` A glob pattern to convert to regex. + * @param {Object} `options` + * @return {RegExp} Returns a regex created from the given pattern. + * @api public + */ +picomatch.makeRe = (input, options, returnOutput = false, returnState = false) => { + if (!input || typeof input !== 'string') { + throw new TypeError('Expected a non-empty string'); + } + let opts = options || {}; + let prepend = opts.contains ? '' : '^'; + let append = opts.contains ? '' : '$'; + let state = { negated: false, fastpaths: true }; + let prefix = ''; + let output; + if (input.startsWith('./')) { + input = input.slice(2); + prefix = state.prefix = './'; + } + if (opts.fastpaths !== false && (input[0] === '.' || input[0] === '*')) { + output = parse_1$1.fastpaths(input, options); + } + if (output === void 0) { + state = picomatch.parse(input, options); + state.prefix = prefix + (state.prefix || ''); + output = state.output; + } + if (returnOutput === true) { + return output; + } + let source = `${prepend}(?:${output})${append}`; + if (state && state.negated === true) { + source = `^(?!${source}).*$`; + } + let regex = picomatch.toRegex(source, options); + if (returnState === true) { + regex.state = state; + } + return regex; +}; +/** + * Create a regular expression from the given regex source string. + * + * ```js + * const picomatch = require('picomatch'); + * // picomatch.toRegex(source[, options]); + * + * const { output } = picomatch.parse('*.js'); + * console.log(picomatch.toRegex(output)); + * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/ + * ``` + * @param {String} `source` Regular expression source string. + * @param {Object} `options` + * @return {RegExp} + * @api public + */ +picomatch.toRegex = (source, options) => { + try { + let opts = options || {}; + return new RegExp(source, opts.flags || (opts.nocase ? 'i' : '')); + } + catch (err) { + if (options && options.debug === true) + throw err; + return /$^/; + } +}; +/** + * Picomatch constants. + * @return {Object} + */ +picomatch.constants = constants$1; +/** + * Expose "picomatch" + */ +var picomatch_1 = picomatch; + +var picomatch$1 = picomatch_1; + +const isEmptyString = val => typeof val === 'string' && (val === '' || val === './'); +/** + * 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} list 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) + * @return {Array} Returns an array of matches + * @summary false + * @api public + */ +const micromatch = (list, patterns, options) => { + patterns = [].concat(patterns); + list = [].concat(list); + let omit = new Set(); + let keep = new Set(); + let items = 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$1(String(patterns[i]), Object.assign({}, options, { onResult }), true); + let negated = isMatch.state.negated || isMatch.state.negatedExtglob; + if (negated) + negatives++; + for (let item of list) { + let matched = isMatch(item, true); + let match = negated ? !matched.isMatch : matched.isMatch; + if (!match) + continue; + if (negated) { + omit.add(matched.output); + } + else { + omit.delete(matched.output); + keep.add(matched.output); + } + } + } + let result = negatives === patterns.length ? [...items] : [...keep]; + let matches = result.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$1(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$1(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 = new Set(); + let items = []; + let onResult = state => { + if (options.onResult) + options.onResult(state); + items.push(state.output); + }; + let matches = micromatch(list, patterns, Object.assign({}, options, { onResult })); + for (let item of items) { + if (!matches.includes(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 the patter 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, Object.assign({}, 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$1.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 match `str` + * @api public + */ +micromatch.some = (list, patterns, options) => { + let items = [].concat(list); + for (let pattern of [].concat(patterns)) { + let isMatch = picomatch$1(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 any patterns match `str` + * @api public + */ +micromatch.every = (list, patterns, options) => { + let items = [].concat(list); + for (let pattern of [].concat(patterns)) { + let isMatch = picomatch$1(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$1(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 {Boolean} Returns an array of captures if the input matches the glob pattern, otherwise `null`. + * @api public + */ +micromatch.capture = (glob, input, options) => { + let posix = utils$1.isWindows(options); + let regex = picomatch$1.makeRe(String(glob), Object.assign({}, options, { capture: true })); + let match = regex.exec(posix ? utils$1.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$1.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$1.scan(...args); +/** + * Parse a glob pattern to create the source string for a regular + * expression. + * + * ```js + * const mm = require('micromatch'); + * const state = mm(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_1(String(pattern), options)) { + res.push(picomatch$1.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) || !/\{.*\}/.test(pattern)) { + return [pattern]; + } + return braces_1(pattern, options); +}; +/** + * Expand braces + */ +micromatch.braceExpand = (pattern, options) => { + if (typeof pattern !== 'string') + throw new TypeError('Expected a string'); + return micromatch.braces(pattern, Object.assign({}, options, { expand: true })); +}; +/** + * Expose micromatch + */ +var micromatch_1 = micromatch; + +function ensureArray(thing) { + if (Array.isArray(thing)) + return thing; + if (thing == undefined) + return []; + return [thing]; +} + +function getMatcherString(id, resolutionBase) { + if (resolutionBase === false) { + return id; + } + return resolve(...(typeof resolutionBase === 'string' ? [resolutionBase, id] : [id])); +} +const createFilter = function createFilter(include, exclude, options) { + const resolutionBase = options && options.resolve; + const getMatcher = (id) => { + return id instanceof RegExp + ? id + : { + test: micromatch_1.matcher(getMatcherString(id, resolutionBase) + .split(sep) + .join('/'), { dot: true }) + }; + }; + const includeMatchers = ensureArray(include).map(getMatcher); + const excludeMatchers = ensureArray(exclude).map(getMatcher); + return function (id) { + if (typeof id !== 'string') + return false; + if (/\0/.test(id)) + return false; + id = id.split(sep).join('/'); + for (let i = 0; i < excludeMatchers.length; ++i) { + const matcher = excludeMatchers[i]; + if (matcher.test(id)) + return false; + } + for (let i = 0; i < includeMatchers.length; ++i) { + const matcher = includeMatchers[i]; + if (matcher.test(id)) + return true; + } + return !includeMatchers.length; + }; +}; + +const reservedWords = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public'; +const builtins = 'arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl'; +const forbiddenIdentifiers = new Set(`${reservedWords} ${builtins}`.split(' ')); +forbiddenIdentifiers.add(''); function uglify(options) { if (options === void 0) { options = {}; } + var filter = createFilter(options.include, options.exclude); return { name: 'uglify', - transform: function (code) { + transform: function (code, id) { var _this = this; + if (!filter(id)) + return; if (typeof options.sourceMap === 'undefined') { options.sourceMap = true; } diff --git a/dist/plugin.es.js.map b/dist/plugin.es.js.map index 9517869..b0bce34 100644 --- a/dist/plugin.es.js.map +++ b/dist/plugin.es.js.map @@ -1 +1 @@ -{"version":3,"file":"plugin.es.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"} \ No newline at end of file +{"version":3,"file":"plugin.es.js","sources":["../node_modules/rollup-pluginutils/dist/pluginutils.es.js"],"sourcesContent":["import path, { extname, sep, resolve } from 'path';\nimport { walk } from 'estree-walker';\nimport util from 'util';\n\nconst addExtension = function addExtension(filename, ext = '.js') {\n if (!extname(filename))\n filename += ext;\n return filename;\n};\n\nconst extractors = {\n ArrayPattern(names, param) {\n for (const element of param.elements) {\n if (element)\n extractors[element.type](names, element);\n }\n },\n AssignmentPattern(names, param) {\n extractors[param.left.type](names, param.left);\n },\n Identifier(names, param) {\n names.push(param.name);\n },\n MemberExpression() { },\n ObjectPattern(names, param) {\n for (const prop of param.properties) {\n if (prop.type === 'RestElement') {\n extractors.RestElement(names, prop);\n }\n else {\n extractors[prop.value.type](names, prop.value);\n }\n }\n },\n RestElement(names, param) {\n extractors[param.argument.type](names, param.argument);\n }\n};\nconst extractAssignedNames = function extractAssignedNames(param) {\n const names = [];\n extractors[param.type](names, param);\n return names;\n};\n\nconst blockDeclarations = {\n const: true,\n let: true\n};\nclass Scope {\n constructor(options = {}) {\n this.parent = options.parent;\n this.isBlockScope = !!options.block;\n this.declarations = Object.create(null);\n if (options.params) {\n options.params.forEach(param => {\n extractAssignedNames(param).forEach(name => {\n this.declarations[name] = true;\n });\n });\n }\n }\n addDeclaration(node, isBlockDeclaration, isVar) {\n if (!isBlockDeclaration && this.isBlockScope) {\n // it's a `var` or function node, and this\n // is a block scope, so we need to go up\n this.parent.addDeclaration(node, isBlockDeclaration, isVar);\n }\n else if (node.id) {\n extractAssignedNames(node.id).forEach(name => {\n this.declarations[name] = true;\n });\n }\n }\n contains(name) {\n return this.declarations[name] || (this.parent ? this.parent.contains(name) : false);\n }\n}\nconst attachScopes = function attachScopes(ast, propertyName = 'scope') {\n let scope = new Scope();\n walk(ast, {\n enter(node, parent) {\n // function foo () {...}\n // class Foo {...}\n if (/(Function|Class)Declaration/.test(node.type)) {\n scope.addDeclaration(node, false, false);\n }\n // var foo = 1\n if (node.type === 'VariableDeclaration') {\n const kind = node.kind;\n const isBlockDeclaration = blockDeclarations[kind];\n node.declarations.forEach((declaration) => {\n scope.addDeclaration(declaration, isBlockDeclaration, true);\n });\n }\n let newScope;\n // create new function scope\n if (/Function/.test(node.type)) {\n newScope = new Scope({\n parent: scope,\n block: false,\n params: node.params\n });\n // named function expressions - the name is considered\n // part of the function's scope\n if (node.type === 'FunctionExpression' && node.id) {\n newScope.addDeclaration(node, false, false);\n }\n }\n // create new block scope\n if (node.type === 'BlockStatement' && !/Function/.test(parent.type)) {\n newScope = new Scope({\n parent: scope,\n block: true\n });\n }\n // catch clause has its own block scope\n if (node.type === 'CatchClause') {\n newScope = new Scope({\n parent: scope,\n params: node.param ? [node.param] : [],\n block: true\n });\n }\n if (newScope) {\n Object.defineProperty(node, propertyName, {\n value: newScope,\n configurable: true\n });\n scope = newScope;\n }\n },\n leave(node) {\n if (node[propertyName])\n scope = scope.parent;\n }\n });\n return scope;\n};\n\nfunction createCommonjsModule(fn, module) {\n\treturn module = { exports: {} }, fn(module, module.exports), module.exports;\n}\n\nvar utils = createCommonjsModule(function (module, exports) {\n exports.isInteger = num => {\n if (typeof num === 'number') {\n return Number.isInteger(num);\n }\n if (typeof num === 'string' && num.trim() !== '') {\n return Number.isInteger(Number(num));\n }\n return false;\n };\n /**\n * Find a node of the given type\n */\n exports.find = (node, type) => node.nodes.find(node => node.type === type);\n /**\n * Find a node of the given type\n */\n exports.exceedsLimit = (min, max, step = 1, limit) => {\n if (limit === false)\n return false;\n if (!exports.isInteger(min) || !exports.isInteger(max))\n return false;\n return ((Number(max) - Number(min)) / Number(step)) >= limit;\n };\n /**\n * Escape the given node with '\\\\' before node.value\n */\n exports.escapeNode = (block, n = 0, type) => {\n let node = block.nodes[n];\n if (!node)\n return;\n if ((type && node.type === type) || node.type === 'open' || node.type === 'close') {\n if (node.escaped !== true) {\n node.value = '\\\\' + node.value;\n node.escaped = true;\n }\n }\n };\n /**\n * Returns true if the given brace node should be enclosed in literal braces\n */\n exports.encloseBrace = node => {\n if (node.type !== 'brace')\n return false;\n if ((node.commas >> 0 + node.ranges >> 0) === 0) {\n node.invalid = true;\n return true;\n }\n return false;\n };\n /**\n * Returns true if a brace node is invalid.\n */\n exports.isInvalidBrace = block => {\n if (block.type !== 'brace')\n return false;\n if (block.invalid === true || block.dollar)\n return true;\n if ((block.commas >> 0 + block.ranges >> 0) === 0) {\n block.invalid = true;\n return true;\n }\n if (block.open !== true || block.close !== true) {\n block.invalid = true;\n return true;\n }\n return false;\n };\n /**\n * Returns true if a node is an open or close node\n */\n exports.isOpenOrClose = node => {\n if (node.type === 'open' || node.type === 'close') {\n return true;\n }\n return node.open === true || node.close === true;\n };\n /**\n * Reduce an array of text nodes.\n */\n exports.reduce = nodes => nodes.reduce((acc, node) => {\n if (node.type === 'text')\n acc.push(node.value);\n if (node.type === 'range')\n node.type = 'text';\n return acc;\n }, []);\n /**\n * Flatten an array\n */\n exports.flatten = (...args) => {\n const result = [];\n const flat = arr => {\n for (let i = 0; i < arr.length; i++) {\n let ele = arr[i];\n Array.isArray(ele) ? flat(ele, result) : ele !== void 0 && result.push(ele);\n }\n return result;\n };\n flat(args);\n return result;\n };\n});\nvar utils_1 = utils.isInteger;\nvar utils_2 = utils.find;\nvar utils_3 = utils.exceedsLimit;\nvar utils_4 = utils.escapeNode;\nvar utils_5 = utils.encloseBrace;\nvar utils_6 = utils.isInvalidBrace;\nvar utils_7 = utils.isOpenOrClose;\nvar utils_8 = utils.reduce;\nvar utils_9 = utils.flatten;\n\nvar stringify = (ast, options = {}) => {\n let stringify = (node, parent = {}) => {\n let invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent);\n let invalidNode = node.invalid === true && options.escapeInvalid === true;\n let output = '';\n if (node.value) {\n if ((invalidBlock || invalidNode) && utils.isOpenOrClose(node)) {\n return '\\\\' + node.value;\n }\n return node.value;\n }\n if (node.value) {\n return node.value;\n }\n if (node.nodes) {\n for (let child of node.nodes) {\n output += stringify(child);\n }\n }\n return output;\n };\n return stringify(ast);\n};\n\n/*!\n * is-number \n *\n * Copyright (c) 2014-present, Jon Schlinkert.\n * Released under the MIT License.\n */\nvar isNumber = function (num) {\n if (typeof num === 'number') {\n return num - num === 0;\n }\n if (typeof num === 'string' && num.trim() !== '') {\n return Number.isFinite ? Number.isFinite(+num) : isFinite(+num);\n }\n return false;\n};\n\nconst toRegexRange = (min, max, options) => {\n if (isNumber(min) === false) {\n throw new TypeError('toRegexRange: expected the first argument to be a number');\n }\n if (max === void 0 || min === max) {\n return String(min);\n }\n if (isNumber(max) === false) {\n throw new TypeError('toRegexRange: expected the second argument to be a number.');\n }\n let opts = Object.assign({ relaxZeros: true }, options);\n if (typeof opts.strictZeros === 'boolean') {\n opts.relaxZeros = opts.strictZeros === false;\n }\n let relax = String(opts.relaxZeros);\n let shorthand = String(opts.shorthand);\n let capture = String(opts.capture);\n let wrap = String(opts.wrap);\n let cacheKey = min + ':' + max + '=' + relax + shorthand + capture + wrap;\n if (toRegexRange.cache.hasOwnProperty(cacheKey)) {\n return toRegexRange.cache[cacheKey].result;\n }\n let a = Math.min(min, max);\n let b = Math.max(min, max);\n if (Math.abs(a - b) === 1) {\n let result = min + '|' + max;\n if (opts.capture) {\n return `(${result})`;\n }\n if (opts.wrap === false) {\n return result;\n }\n return `(?:${result})`;\n }\n let isPadded = hasPadding(min) || hasPadding(max);\n let state = { min, max, a, b };\n let positives = [];\n let negatives = [];\n if (isPadded) {\n state.isPadded = isPadded;\n state.maxLen = String(state.max).length;\n }\n if (a < 0) {\n let newMin = b < 0 ? Math.abs(b) : 1;\n negatives = splitToPatterns(newMin, Math.abs(a), state, opts);\n a = state.a = 0;\n }\n if (b >= 0) {\n positives = splitToPatterns(a, b, state, opts);\n }\n state.negatives = negatives;\n state.positives = positives;\n state.result = collatePatterns(negatives, positives, opts);\n if (opts.capture === true) {\n state.result = `(${state.result})`;\n }\n else if (opts.wrap !== false && (positives.length + negatives.length) > 1) {\n state.result = `(?:${state.result})`;\n }\n toRegexRange.cache[cacheKey] = state;\n return state.result;\n};\nfunction collatePatterns(neg, pos, options) {\n let onlyNegative = filterPatterns(neg, pos, '-', false, options) || [];\n let onlyPositive = filterPatterns(pos, neg, '', false, options) || [];\n let intersected = filterPatterns(neg, pos, '-?', true, options) || [];\n let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);\n return subpatterns.join('|');\n}\nfunction splitToRanges(min, max) {\n let nines = 1;\n let zeros = 1;\n let stop = countNines(min, nines);\n let stops = new Set([max]);\n while (min <= stop && stop <= max) {\n stops.add(stop);\n nines += 1;\n stop = countNines(min, nines);\n }\n stop = countZeros(max + 1, zeros) - 1;\n while (min < stop && stop <= max) {\n stops.add(stop);\n zeros += 1;\n stop = countZeros(max + 1, zeros) - 1;\n }\n stops = [...stops];\n stops.sort(compare);\n return stops;\n}\n/**\n * Convert a range to a regex pattern\n * @param {Number} `start`\n * @param {Number} `stop`\n * @return {String}\n */\nfunction rangeToPattern(start, stop, options) {\n if (start === stop) {\n return { pattern: start, count: [], digits: 0 };\n }\n let zipped = zip(start, stop);\n let digits = zipped.length;\n let pattern = '';\n let count = 0;\n for (let i = 0; i < digits; i++) {\n let [startDigit, stopDigit] = zipped[i];\n if (startDigit === stopDigit) {\n pattern += startDigit;\n }\n else if (startDigit !== '0' || stopDigit !== '9') {\n pattern += toCharacterClass(startDigit, stopDigit, options);\n }\n else {\n count++;\n }\n }\n if (count) {\n pattern += options.shorthand === true ? '\\\\d' : '[0-9]';\n }\n return { pattern, count: [count], digits };\n}\nfunction splitToPatterns(min, max, tok, options) {\n let ranges = splitToRanges(min, max);\n let tokens = [];\n let start = min;\n let prev;\n for (let i = 0; i < ranges.length; i++) {\n let max = ranges[i];\n let obj = rangeToPattern(String(start), String(max), options);\n let zeros = '';\n if (!tok.isPadded && prev && prev.pattern === obj.pattern) {\n if (prev.count.length > 1) {\n prev.count.pop();\n }\n prev.count.push(obj.count[0]);\n prev.string = prev.pattern + toQuantifier(prev.count);\n start = max + 1;\n continue;\n }\n if (tok.isPadded) {\n zeros = padZeros(max, tok, options);\n }\n obj.string = zeros + obj.pattern + toQuantifier(obj.count);\n tokens.push(obj);\n start = max + 1;\n prev = obj;\n }\n return tokens;\n}\nfunction filterPatterns(arr, comparison, prefix, intersection, options) {\n let result = [];\n for (let ele of arr) {\n let { string } = ele;\n // only push if _both_ are negative...\n if (!intersection && !contains(comparison, 'string', string)) {\n result.push(prefix + string);\n }\n // or _both_ are positive\n if (intersection && contains(comparison, 'string', string)) {\n result.push(prefix + string);\n }\n }\n return result;\n}\n/**\n * Zip strings\n */\nfunction zip(a, b) {\n let arr = [];\n for (let i = 0; i < a.length; i++)\n arr.push([a[i], b[i]]);\n return arr;\n}\nfunction compare(a, b) {\n return a > b ? 1 : b > a ? -1 : 0;\n}\nfunction contains(arr, key, val) {\n return arr.some(ele => ele[key] === val);\n}\nfunction countNines(min, len) {\n return Number(String(min).slice(0, -len) + '9'.repeat(len));\n}\nfunction countZeros(integer, zeros) {\n return integer - (integer % Math.pow(10, zeros));\n}\nfunction toQuantifier(digits) {\n let [start = 0, stop = ''] = digits;\n if (stop || start > 1) {\n return `{${start + (stop ? ',' + stop : '')}}`;\n }\n return '';\n}\nfunction toCharacterClass(a, b, options) {\n return `[${a}${(b - a === 1) ? '' : '-'}${b}]`;\n}\nfunction hasPadding(str) {\n return /^-?(0+)\\d/.test(str);\n}\nfunction padZeros(value, tok, options) {\n if (!tok.isPadded) {\n return value;\n }\n let diff = Math.abs(tok.maxLen - String(value).length);\n let relax = options.relaxZeros !== false;\n switch (diff) {\n case 0:\n return '';\n case 1:\n return relax ? '0?' : '0';\n case 2:\n return relax ? '0{0,2}' : '00';\n default: {\n return relax ? `0{0,${diff}}` : `0{${diff}}`;\n }\n }\n}\n/**\n * Cache\n */\ntoRegexRange.cache = {};\ntoRegexRange.clearCache = () => (toRegexRange.cache = {});\n/**\n * Expose `toRegexRange`\n */\nvar toRegexRange_1 = toRegexRange;\n\nconst isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);\nconst transform = toNumber => {\n return value => toNumber === true ? Number(value) : String(value);\n};\nconst isValidValue = value => {\n return typeof value === 'number' || (typeof value === 'string' && value !== '');\n};\nconst isNumber$1 = num => Number.isInteger(+num);\nconst zeros = input => {\n let value = `${input}`;\n let index = -1;\n if (value[0] === '-')\n value = value.slice(1);\n if (value === '0')\n return false;\n while (value[++index] === '0')\n ;\n return index > 0;\n};\nconst stringify$1 = (start, end, options) => {\n if (typeof start === 'string' || typeof end === 'string') {\n return true;\n }\n return options.stringify === true;\n};\nconst pad = (input, maxLength, toNumber) => {\n if (maxLength > 0) {\n let dash = input[0] === '-' ? '-' : '';\n if (dash)\n input = input.slice(1);\n input = (dash + input.padStart(dash ? maxLength - 1 : maxLength, '0'));\n }\n if (toNumber === false) {\n return String(input);\n }\n return input;\n};\nconst toMaxLen = (input, maxLength) => {\n let negative = input[0] === '-' ? '-' : '';\n if (negative) {\n input = input.slice(1);\n maxLength--;\n }\n while (input.length < maxLength)\n input = '0' + input;\n return negative ? ('-' + input) : input;\n};\nconst toSequence = (parts, options) => {\n parts.negatives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);\n parts.positives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);\n let prefix = options.capture ? '' : '?:';\n let positives = '';\n let negatives = '';\n let result;\n if (parts.positives.length) {\n positives = parts.positives.join('|');\n }\n if (parts.negatives.length) {\n negatives = `-(${prefix}${parts.negatives.join('|')})`;\n }\n if (positives && negatives) {\n result = `${positives}|${negatives}`;\n }\n else {\n result = positives || negatives;\n }\n if (options.wrap) {\n return `(${prefix}${result})`;\n }\n return result;\n};\nconst toRange = (a, b, isNumbers, options) => {\n if (isNumbers) {\n return toRegexRange_1(a, b, Object.assign({ wrap: false }, options));\n }\n let start = String.fromCharCode(a);\n if (a === b)\n return start;\n let stop = String.fromCharCode(b);\n return `[${start}-${stop}]`;\n};\nconst toRegex = (start, end, options) => {\n if (Array.isArray(start)) {\n let wrap = options.wrap === true;\n let prefix = options.capture ? '' : '?:';\n return wrap ? `(${prefix}${start.join('|')})` : start.join('|');\n }\n return toRegexRange_1(start, end, options);\n};\nconst rangeError = (...args) => {\n return new RangeError('Invalid range arguments: ' + util.inspect(...args));\n};\nconst invalidRange = (start, end, options) => {\n if (options.strictRanges === true)\n throw rangeError([start, end]);\n return [];\n};\nconst invalidStep = (step, options) => {\n if (options.strictRanges === true) {\n throw new TypeError(`Expected step \"${step}\" to be a number`);\n }\n return [];\n};\nconst fillNumbers = (start, end, step = 1, options = {}) => {\n let a = Number(start);\n let b = Number(end);\n if (!Number.isInteger(a) || !Number.isInteger(b)) {\n if (options.strictRanges === true)\n throw rangeError([start, end]);\n return [];\n }\n // fix negative zero\n if (a === 0)\n a = 0;\n if (b === 0)\n b = 0;\n let descending = a > b;\n let startString = String(start);\n let endString = String(end);\n let stepString = String(step);\n step = Math.max(Math.abs(step), 1);\n let padded = zeros(startString) || zeros(endString) || zeros(stepString);\n let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;\n let toNumber = padded === false && stringify$1(start, end, options) === false;\n let format = options.transform || transform(toNumber);\n if (options.toRegex && step === 1) {\n return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);\n }\n let parts = { negatives: [], positives: [] };\n let push = num => parts[num < 0 ? 'negatives' : 'positives'].push(Math.abs(num));\n let range = [];\n let index = 0;\n while (descending ? a >= b : a <= b) {\n if (options.toRegex === true && step > 1) {\n push(a);\n }\n else {\n range.push(pad(format(a, index), maxLen, toNumber));\n }\n a = descending ? a - step : a + step;\n index++;\n }\n if (options.toRegex === true) {\n return step > 1\n ? toSequence(parts, options)\n : toRegex(range, null, Object.assign({ wrap: false }, options));\n }\n return range;\n};\nconst fillLetters = (start, end, step = 1, options = {}) => {\n if ((!isNumber$1(start) && start.length > 1) || (!isNumber$1(end) && end.length > 1)) {\n return invalidRange(start, end, options);\n }\n let format = options.transform || (val => String.fromCharCode(val));\n let a = `${start}`.charCodeAt(0);\n let b = `${end}`.charCodeAt(0);\n let descending = a > b;\n let min = Math.min(a, b);\n let max = Math.max(a, b);\n if (options.toRegex && step === 1) {\n return toRange(min, max, false, options);\n }\n let range = [];\n let index = 0;\n while (descending ? a >= b : a <= b) {\n range.push(format(a, index));\n a = descending ? a - step : a + step;\n index++;\n }\n if (options.toRegex === true) {\n return toRegex(range, null, { wrap: false, options });\n }\n return range;\n};\nconst fill = (start, end, step, options = {}) => {\n if (end == null && isValidValue(start)) {\n return [start];\n }\n if (!isValidValue(start) || !isValidValue(end)) {\n return invalidRange(start, end, options);\n }\n if (typeof step === 'function') {\n return fill(start, end, 1, { transform: step });\n }\n if (isObject(step)) {\n return fill(start, end, 0, step);\n }\n let opts = Object.assign({}, options);\n if (opts.capture === true)\n opts.wrap = true;\n step = step || opts.step || 1;\n if (!isNumber$1(step)) {\n if (step != null && !isObject(step))\n return invalidStep(step, opts);\n return fill(start, end, 1, step);\n }\n if (isNumber$1(start) && isNumber$1(end)) {\n return fillNumbers(start, end, step, opts);\n }\n return fillLetters(start, end, Math.max(Math.abs(step), 1), opts);\n};\nvar fillRange = fill;\n\nconst compile = (ast, options = {}) => {\n let walk = (node, parent = {}) => {\n let invalidBlock = utils.isInvalidBrace(parent);\n let invalidNode = node.invalid === true && options.escapeInvalid === true;\n let invalid = invalidBlock === true || invalidNode === true;\n let prefix = options.escapeInvalid === true ? '\\\\' : '';\n let output = '';\n if (node.isOpen === true) {\n return prefix + node.value;\n }\n if (node.isClose === true) {\n return prefix + node.value;\n }\n if (node.type === 'open') {\n return invalid ? (prefix + node.value) : '(';\n }\n if (node.type === 'close') {\n return invalid ? (prefix + node.value) : ')';\n }\n if (node.type === 'comma') {\n return node.prev.type === 'comma' ? '' : (invalid ? node.value : '|');\n }\n if (node.value) {\n return node.value;\n }\n if (node.nodes && node.ranges > 0) {\n let args = utils.reduce(node.nodes);\n let range = fillRange(...args, Object.assign({}, options, { wrap: false, toRegex: true }));\n if (range.length !== 0) {\n return args.length > 1 && range.length > 1 ? `(${range})` : range;\n }\n }\n if (node.nodes) {\n for (let child of node.nodes) {\n output += walk(child, node);\n }\n }\n return output;\n };\n return walk(ast);\n};\nvar compile_1 = compile;\n\nconst append = (queue = '', stash = '', enclose = false) => {\n let result = [];\n queue = [].concat(queue);\n stash = [].concat(stash);\n if (!stash.length)\n return queue;\n if (!queue.length) {\n return enclose ? utils.flatten(stash).map(ele => `{${ele}}`) : stash;\n }\n for (let item of queue) {\n if (Array.isArray(item)) {\n for (let value of item) {\n result.push(append(value, stash, enclose));\n }\n }\n else {\n for (let ele of stash) {\n if (enclose === true && typeof ele === 'string')\n ele = `{${ele}}`;\n result.push(Array.isArray(ele) ? append(item, ele, enclose) : (item + ele));\n }\n }\n }\n return utils.flatten(result);\n};\nconst expand = (ast, options = {}) => {\n let rangeLimit = options.rangeLimit === void 0 ? 1000 : options.rangeLimit;\n let walk = (node, parent = {}) => {\n node.queue = [];\n let p = parent;\n let q = parent.queue;\n while (p.type !== 'brace' && p.type !== 'root' && p.parent) {\n p = p.parent;\n q = p.queue;\n }\n if (node.invalid || node.dollar) {\n q.push(append(q.pop(), stringify(node, options)));\n return;\n }\n if (node.type === 'brace' && node.invalid !== true && node.nodes.length === 2) {\n q.push(append(q.pop(), ['{}']));\n return;\n }\n if (node.nodes && node.ranges > 0) {\n let args = utils.reduce(node.nodes);\n if (utils.exceedsLimit(...args, options.step, rangeLimit)) {\n throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.');\n }\n let range = fillRange(...args, options);\n if (range.length === 0) {\n range = stringify(node, options);\n }\n q.push(append(q.pop(), range));\n node.nodes = [];\n return;\n }\n let enclose = utils.encloseBrace(node);\n let queue = node.queue;\n let block = node;\n while (block.type !== 'brace' && block.type !== 'root' && block.parent) {\n block = block.parent;\n queue = block.queue;\n }\n for (let i = 0; i < node.nodes.length; i++) {\n let child = node.nodes[i];\n if (child.type === 'comma' && node.type === 'brace') {\n if (i === 1)\n queue.push('');\n queue.push('');\n continue;\n }\n if (child.type === 'close') {\n q.push(append(q.pop(), queue, enclose));\n continue;\n }\n if (child.value && child.type !== 'open') {\n queue.push(append(queue.pop(), child.value));\n continue;\n }\n if (child.nodes) {\n walk(child, node);\n }\n }\n return queue;\n };\n return utils.flatten(walk(ast));\n};\nvar expand_1 = expand;\n\nvar constants = {\n MAX_LENGTH: 1024 * 64,\n // Digits\n CHAR_0: '0',\n CHAR_9: '9',\n // Alphabet chars.\n CHAR_UPPERCASE_A: 'A',\n CHAR_LOWERCASE_A: 'a',\n CHAR_UPPERCASE_Z: 'Z',\n CHAR_LOWERCASE_Z: 'z',\n CHAR_LEFT_PARENTHESES: '(',\n CHAR_RIGHT_PARENTHESES: ')',\n CHAR_ASTERISK: '*',\n // Non-alphabetic chars.\n CHAR_AMPERSAND: '&',\n CHAR_AT: '@',\n CHAR_BACKSLASH: '\\\\',\n CHAR_BACKTICK: '`',\n CHAR_CARRIAGE_RETURN: '\\r',\n CHAR_CIRCUMFLEX_ACCENT: '^',\n CHAR_COLON: ':',\n CHAR_COMMA: ',',\n CHAR_DOLLAR: '$',\n CHAR_DOT: '.',\n CHAR_DOUBLE_QUOTE: '\"',\n CHAR_EQUAL: '=',\n CHAR_EXCLAMATION_MARK: '!',\n CHAR_FORM_FEED: '\\f',\n CHAR_FORWARD_SLASH: '/',\n CHAR_HASH: '#',\n CHAR_HYPHEN_MINUS: '-',\n CHAR_LEFT_ANGLE_BRACKET: '<',\n CHAR_LEFT_CURLY_BRACE: '{',\n CHAR_LEFT_SQUARE_BRACKET: '[',\n CHAR_LINE_FEED: '\\n',\n CHAR_NO_BREAK_SPACE: '\\u00A0',\n CHAR_PERCENT: '%',\n CHAR_PLUS: '+',\n CHAR_QUESTION_MARK: '?',\n CHAR_RIGHT_ANGLE_BRACKET: '>',\n CHAR_RIGHT_CURLY_BRACE: '}',\n CHAR_RIGHT_SQUARE_BRACKET: ']',\n CHAR_SEMICOLON: ';',\n CHAR_SINGLE_QUOTE: '\\'',\n CHAR_SPACE: ' ',\n CHAR_TAB: '\\t',\n CHAR_UNDERSCORE: '_',\n CHAR_VERTICAL_LINE: '|',\n CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\\uFEFF' /* \\uFEFF */\n};\n\n/**\n * Constants\n */\nconst { MAX_LENGTH, CHAR_BACKSLASH, /* \\ */ CHAR_BACKTICK, /* ` */ CHAR_COMMA, /* , */ CHAR_DOT, /* . */ CHAR_LEFT_PARENTHESES, /* ( */ CHAR_RIGHT_PARENTHESES, /* ) */ CHAR_LEFT_CURLY_BRACE, /* { */ CHAR_RIGHT_CURLY_BRACE, /* } */ CHAR_LEFT_SQUARE_BRACKET, /* [ */ CHAR_RIGHT_SQUARE_BRACKET, /* ] */ CHAR_DOUBLE_QUOTE, /* \" */ CHAR_SINGLE_QUOTE, /* ' */ CHAR_NO_BREAK_SPACE, CHAR_ZERO_WIDTH_NOBREAK_SPACE } = constants;\n/**\n * parse\n */\nconst parse = (input, options = {}) => {\n if (typeof input !== 'string') {\n throw new TypeError('Expected a string');\n }\n let opts = options || {};\n let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;\n if (input.length > max) {\n throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);\n }\n let ast = { type: 'root', input, nodes: [] };\n let stack = [ast];\n let block = ast;\n let prev = ast;\n let brackets = 0;\n let length = input.length;\n let index = 0;\n let depth = 0;\n let value;\n /**\n * Helpers\n */\n const advance = () => input[index++];\n const push = node => {\n if (node.type === 'text' && prev.type === 'dot') {\n prev.type = 'text';\n }\n if (prev && prev.type === 'text' && node.type === 'text') {\n prev.value += node.value;\n return;\n }\n block.nodes.push(node);\n node.parent = block;\n node.prev = prev;\n prev = node;\n return node;\n };\n push({ type: 'bos' });\n while (index < length) {\n block = stack[stack.length - 1];\n value = advance();\n /**\n * Invalid chars\n */\n if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) {\n continue;\n }\n /**\n * Escaped chars\n */\n if (value === CHAR_BACKSLASH) {\n push({ type: 'text', value: (options.keepEscaping ? value : '') + advance() });\n continue;\n }\n /**\n * Right square bracket (literal): ']'\n */\n if (value === CHAR_RIGHT_SQUARE_BRACKET) {\n push({ type: 'text', value: '\\\\' + value });\n continue;\n }\n /**\n * Left square bracket: '['\n */\n if (value === CHAR_LEFT_SQUARE_BRACKET) {\n brackets++;\n let next;\n while (index < length && (next = advance())) {\n value += next;\n if (next === CHAR_LEFT_SQUARE_BRACKET) {\n brackets++;\n continue;\n }\n if (next === CHAR_BACKSLASH) {\n value += advance();\n continue;\n }\n if (next === CHAR_RIGHT_SQUARE_BRACKET) {\n brackets--;\n if (brackets === 0) {\n break;\n }\n }\n }\n push({ type: 'text', value });\n continue;\n }\n /**\n * Parentheses\n */\n if (value === CHAR_LEFT_PARENTHESES) {\n block = push({ type: 'paren', nodes: [] });\n stack.push(block);\n push({ type: 'text', value });\n continue;\n }\n if (value === CHAR_RIGHT_PARENTHESES) {\n if (block.type !== 'paren') {\n push({ type: 'text', value });\n continue;\n }\n block = stack.pop();\n push({ type: 'text', value });\n block = stack[stack.length - 1];\n continue;\n }\n /**\n * Quotes: '|\"|`\n */\n if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) {\n let open = value;\n let next;\n if (options.keepQuotes !== true) {\n value = '';\n }\n while (index < length && (next = advance())) {\n if (next === CHAR_BACKSLASH) {\n value += next + advance();\n continue;\n }\n if (next === open) {\n if (options.keepQuotes === true)\n value += next;\n break;\n }\n value += next;\n }\n push({ type: 'text', value });\n continue;\n }\n /**\n * Left curly brace: '{'\n */\n if (value === CHAR_LEFT_CURLY_BRACE) {\n depth++;\n let dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true;\n let brace = {\n type: 'brace',\n open: true,\n close: false,\n dollar,\n depth,\n commas: 0,\n ranges: 0,\n nodes: []\n };\n block = push(brace);\n stack.push(block);\n push({ type: 'open', value });\n continue;\n }\n /**\n * Right curly brace: '}'\n */\n if (value === CHAR_RIGHT_CURLY_BRACE) {\n if (block.type !== 'brace') {\n push({ type: 'text', value });\n continue;\n }\n let type = 'close';\n block = stack.pop();\n block.close = true;\n push({ type, value });\n depth--;\n block = stack[stack.length - 1];\n continue;\n }\n /**\n * Comma: ','\n */\n if (value === CHAR_COMMA && depth > 0) {\n if (block.ranges > 0) {\n block.ranges = 0;\n let open = block.nodes.shift();\n block.nodes = [open, { type: 'text', value: stringify(block) }];\n }\n push({ type: 'comma', value });\n block.commas++;\n continue;\n }\n /**\n * Dot: '.'\n */\n if (value === CHAR_DOT && depth > 0 && block.commas === 0) {\n let siblings = block.nodes;\n if (depth === 0 || siblings.length === 0) {\n push({ type: 'text', value });\n continue;\n }\n if (prev.type === 'dot') {\n block.range = [];\n prev.value += value;\n prev.type = 'range';\n if (block.nodes.length !== 3 && block.nodes.length !== 5) {\n block.invalid = true;\n block.ranges = 0;\n prev.type = 'text';\n continue;\n }\n block.ranges++;\n block.args = [];\n continue;\n }\n if (prev.type === 'range') {\n siblings.pop();\n let before = siblings[siblings.length - 1];\n before.value += prev.value + value;\n prev = before;\n block.ranges--;\n continue;\n }\n push({ type: 'dot', value });\n continue;\n }\n /**\n * Text\n */\n push({ type: 'text', value });\n }\n // Mark imbalanced braces and brackets as invalid\n do {\n block = stack.pop();\n if (block.type !== 'root') {\n block.nodes.forEach(node => {\n if (!node.nodes) {\n if (node.type === 'open')\n node.isOpen = true;\n if (node.type === 'close')\n node.isClose = true;\n if (!node.nodes)\n node.type = 'text';\n node.invalid = true;\n }\n });\n // get the location of the block on parent.nodes (block's siblings)\n let parent = stack[stack.length - 1];\n let index = parent.nodes.indexOf(block);\n // replace the (invalid) block with it's nodes\n parent.nodes.splice(index, 1, ...block.nodes);\n }\n } while (stack.length > 0);\n push({ type: 'eos' });\n return ast;\n};\nvar parse_1 = parse;\n\n/**\n * Expand the given pattern or create a regex-compatible string.\n *\n * ```js\n * const braces = require('braces');\n * console.log(braces('{a,b,c}', { compile: true })); //=> ['(a|b|c)']\n * console.log(braces('{a,b,c}')); //=> ['a', 'b', 'c']\n * ```\n * @param {String} `str`\n * @param {Object} `options`\n * @return {String}\n * @api public\n */\nconst braces = (input, options = {}) => {\n let output = [];\n if (Array.isArray(input)) {\n for (let pattern of input) {\n let result = braces.create(pattern, options);\n if (Array.isArray(result)) {\n output.push(...result);\n }\n else {\n output.push(result);\n }\n }\n }\n else {\n output = [].concat(braces.create(input, options));\n }\n if (options && options.expand === true && options.nodupes === true) {\n output = [...new Set(output)];\n }\n return output;\n};\n/**\n * Parse the given `str` with the given `options`.\n *\n * ```js\n * // braces.parse(pattern, [, options]);\n * const ast = braces.parse('a/{b,c}/d');\n * console.log(ast);\n * ```\n * @param {String} pattern Brace pattern to parse\n * @param {Object} options\n * @return {Object} Returns an AST\n * @api public\n */\nbraces.parse = (input, options = {}) => parse_1(input, options);\n/**\n * Creates a braces string from an AST, or an AST node.\n *\n * ```js\n * const braces = require('braces');\n * let ast = braces.parse('foo/{a,b}/bar');\n * console.log(stringify(ast.nodes[2])); //=> '{a,b}'\n * ```\n * @param {String} `input` Brace pattern or AST.\n * @param {Object} `options`\n * @return {Array} Returns an array of expanded values.\n * @api public\n */\nbraces.stringify = (input, options = {}) => {\n if (typeof input === 'string') {\n return stringify(braces.parse(input, options), options);\n }\n return stringify(input, options);\n};\n/**\n * Compiles a brace pattern into a regex-compatible, optimized string.\n * This method is called by the main [braces](#braces) function by default.\n *\n * ```js\n * const braces = require('braces');\n * console.log(braces.compile('a/{b,c}/d'));\n * //=> ['a/(b|c)/d']\n * ```\n * @param {String} `input` Brace pattern or AST.\n * @param {Object} `options`\n * @return {Array} Returns an array of expanded values.\n * @api public\n */\nbraces.compile = (input, options = {}) => {\n if (typeof input === 'string') {\n input = braces.parse(input, options);\n }\n return compile_1(input, options);\n};\n/**\n * Expands a brace pattern into an array. This method is called by the\n * main [braces](#braces) function when `options.expand` is true. Before\n * using this method it's recommended that you read the [performance notes](#performance))\n * and advantages of using [.compile](#compile) instead.\n *\n * ```js\n * const braces = require('braces');\n * console.log(braces.expand('a/{b,c}/d'));\n * //=> ['a/b/d', 'a/c/d'];\n * ```\n * @param {String} `pattern` Brace pattern\n * @param {Object} `options`\n * @return {Array} Returns an array of expanded values.\n * @api public\n */\nbraces.expand = (input, options = {}) => {\n if (typeof input === 'string') {\n input = braces.parse(input, options);\n }\n let result = expand_1(input, options);\n // filter out empty strings if specified\n if (options.noempty === true) {\n result = result.filter(Boolean);\n }\n // filter out duplicates if specified\n if (options.nodupes === true) {\n result = [...new Set(result)];\n }\n return result;\n};\n/**\n * Processes a brace pattern and returns either an expanded array\n * (if `options.expand` is true), a highly optimized regex-compatible string.\n * This method is called by the main [braces](#braces) function.\n *\n * ```js\n * const braces = require('braces');\n * console.log(braces.create('user-{200..300}/project-{a,b,c}-{1..10}'))\n * //=> 'user-(20[0-9]|2[1-9][0-9]|300)/project-(a|b|c)-([1-9]|10)'\n * ```\n * @param {String} `pattern` Brace pattern\n * @param {Object} `options`\n * @return {Array} Returns an array of expanded values.\n * @api public\n */\nbraces.create = (input, options = {}) => {\n if (input === '' || input.length < 3) {\n return [input];\n }\n return options.expand !== true\n ? braces.compile(input, options)\n : braces.expand(input, options);\n};\n/**\n * Expose \"braces\"\n */\nvar braces_1 = braces;\n\nconst WIN_SLASH = '\\\\\\\\/';\nconst WIN_NO_SLASH = `[^${WIN_SLASH}]`;\n/**\n * Posix glob regex\n */\nconst DOT_LITERAL = '\\\\.';\nconst PLUS_LITERAL = '\\\\+';\nconst QMARK_LITERAL = '\\\\?';\nconst SLASH_LITERAL = '\\\\/';\nconst ONE_CHAR = '(?=.)';\nconst QMARK = '[^/]';\nconst END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;\nconst START_ANCHOR = `(?:^|${SLASH_LITERAL})`;\nconst DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;\nconst NO_DOT = `(?!${DOT_LITERAL})`;\nconst NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;\nconst NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;\nconst NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;\nconst QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;\nconst STAR = `${QMARK}*?`;\nconst POSIX_CHARS = {\n DOT_LITERAL,\n PLUS_LITERAL,\n QMARK_LITERAL,\n SLASH_LITERAL,\n ONE_CHAR,\n QMARK,\n END_ANCHOR,\n DOTS_SLASH,\n NO_DOT,\n NO_DOTS,\n NO_DOT_SLASH,\n NO_DOTS_SLASH,\n QMARK_NO_DOT,\n STAR,\n START_ANCHOR\n};\n/**\n * Windows glob regex\n */\nconst WINDOWS_CHARS = Object.assign({}, POSIX_CHARS, { SLASH_LITERAL: `[${WIN_SLASH}]`, QMARK: WIN_NO_SLASH, STAR: `${WIN_NO_SLASH}*?`, DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`, NO_DOT: `(?!${DOT_LITERAL})`, NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`, NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`, NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`, QMARK_NO_DOT: `[^.${WIN_SLASH}]`, START_ANCHOR: `(?:^|[${WIN_SLASH}])`, END_ANCHOR: `(?:[${WIN_SLASH}]|$)` });\n/**\n * POSIX Bracket Regex\n */\nconst POSIX_REGEX_SOURCE = {\n alnum: 'a-zA-Z0-9',\n alpha: 'a-zA-Z',\n ascii: '\\\\x00-\\\\x7F',\n blank: ' \\\\t',\n cntrl: '\\\\x00-\\\\x1F\\\\x7F',\n digit: '0-9',\n graph: '\\\\x21-\\\\x7E',\n lower: 'a-z',\n print: '\\\\x20-\\\\x7E ',\n punct: '\\\\-!\"#$%&\\'()\\\\*+,./:;<=>?@[\\\\]^_`{|}~',\n space: ' \\\\t\\\\r\\\\n\\\\v\\\\f',\n upper: 'A-Z',\n word: 'A-Za-z0-9_',\n xdigit: 'A-Fa-f0-9'\n};\nvar constants$1 = {\n MAX_LENGTH: 1024 * 64,\n POSIX_REGEX_SOURCE,\n // regular expressions\n REGEX_BACKSLASH: /\\\\(?![*+?^${}(|)[\\]])/g,\n REGEX_NON_SPECIAL_CHAR: /^[^@![\\].,$*+?^{}()|\\\\/]+/,\n REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\\]]/,\n REGEX_SPECIAL_CHARS_BACKREF: /(\\\\?)((\\W)(\\3*))/g,\n REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\\]])/g,\n REGEX_REMOVE_BACKSLASH: /(?:\\[.*?[^\\\\]\\]|\\\\(?=.))/g,\n // Replace globs with equivalent patterns to reduce parsing time.\n REPLACEMENTS: {\n '***': '*',\n '**/**': '**',\n '**/**/**': '**'\n },\n // Digits\n CHAR_0: 48,\n CHAR_9: 57,\n // Alphabet chars.\n CHAR_UPPERCASE_A: 65,\n CHAR_LOWERCASE_A: 97,\n CHAR_UPPERCASE_Z: 90,\n CHAR_LOWERCASE_Z: 122,\n CHAR_LEFT_PARENTHESES: 40,\n CHAR_RIGHT_PARENTHESES: 41,\n CHAR_ASTERISK: 42,\n // Non-alphabetic chars.\n CHAR_AMPERSAND: 38,\n CHAR_AT: 64,\n CHAR_BACKWARD_SLASH: 92,\n CHAR_CARRIAGE_RETURN: 13,\n CHAR_CIRCUMFLEX_ACCENT: 94,\n CHAR_COLON: 58,\n CHAR_COMMA: 44,\n CHAR_DOT: 46,\n CHAR_DOUBLE_QUOTE: 34,\n CHAR_EQUAL: 61,\n CHAR_EXCLAMATION_MARK: 33,\n CHAR_FORM_FEED: 12,\n CHAR_FORWARD_SLASH: 47,\n CHAR_GRAVE_ACCENT: 96,\n CHAR_HASH: 35,\n CHAR_HYPHEN_MINUS: 45,\n CHAR_LEFT_ANGLE_BRACKET: 60,\n CHAR_LEFT_CURLY_BRACE: 123,\n CHAR_LEFT_SQUARE_BRACKET: 91,\n CHAR_LINE_FEED: 10,\n CHAR_NO_BREAK_SPACE: 160,\n CHAR_PERCENT: 37,\n CHAR_PLUS: 43,\n CHAR_QUESTION_MARK: 63,\n CHAR_RIGHT_ANGLE_BRACKET: 62,\n CHAR_RIGHT_CURLY_BRACE: 125,\n CHAR_RIGHT_SQUARE_BRACKET: 93,\n CHAR_SEMICOLON: 59,\n CHAR_SINGLE_QUOTE: 39,\n CHAR_SPACE: 32,\n CHAR_TAB: 9,\n CHAR_UNDERSCORE: 95,\n CHAR_VERTICAL_LINE: 124,\n CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,\n SEP: path.sep,\n /**\n * Create EXTGLOB_CHARS\n */\n extglobChars(chars) {\n return {\n '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` },\n '?': { type: 'qmark', open: '(?:', close: ')?' },\n '+': { type: 'plus', open: '(?:', close: ')+' },\n '*': { type: 'star', open: '(?:', close: ')*' },\n '@': { type: 'at', open: '(?:', close: ')' }\n };\n },\n /**\n * Create GLOB_CHARS\n */\n globChars(win32) {\n return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;\n }\n};\n\nvar utils$1 = createCommonjsModule(function (module, exports) {\n const win32 = process.platform === 'win32';\n const { REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL, REGEX_REMOVE_BACKSLASH } = constants$1;\n exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);\n exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);\n exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str);\n exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\\\$1');\n exports.toPosixSlashes = str => str.replace(/\\\\/g, '/');\n exports.removeBackslashes = str => {\n return str.replace(REGEX_REMOVE_BACKSLASH, match => {\n return match === '\\\\' ? '' : match;\n });\n };\n exports.supportsLookbehinds = () => {\n let segs = process.version.slice(1).split('.');\n if (segs.length === 3 && +segs[0] >= 9 || (+segs[0] === 8 && +segs[1] >= 10)) {\n return true;\n }\n return false;\n };\n exports.isWindows = options => {\n if (options && typeof options.windows === 'boolean') {\n return options.windows;\n }\n return win32 === true || path.sep === '\\\\';\n };\n exports.escapeLast = (input, char, lastIdx) => {\n let idx = input.lastIndexOf(char, lastIdx);\n if (idx === -1)\n return input;\n if (input[idx - 1] === '\\\\')\n return exports.escapeLast(input, char, idx - 1);\n return input.slice(0, idx) + '\\\\' + input.slice(idx);\n };\n});\nvar utils_1$1 = utils$1.isObject;\nvar utils_2$1 = utils$1.hasRegexChars;\nvar utils_3$1 = utils$1.isRegexChar;\nvar utils_4$1 = utils$1.escapeRegex;\nvar utils_5$1 = utils$1.toPosixSlashes;\nvar utils_6$1 = utils$1.removeBackslashes;\nvar utils_7$1 = utils$1.supportsLookbehinds;\nvar utils_8$1 = utils$1.isWindows;\nvar utils_9$1 = utils$1.escapeLast;\n\nconst { CHAR_ASTERISK, /* * */ CHAR_AT, /* @ */ CHAR_BACKWARD_SLASH, /* \\ */ CHAR_COMMA: CHAR_COMMA$1, /* , */ CHAR_DOT: CHAR_DOT$1, /* . */ CHAR_EXCLAMATION_MARK, /* ! */ CHAR_FORWARD_SLASH, /* / */ CHAR_LEFT_CURLY_BRACE: CHAR_LEFT_CURLY_BRACE$1, /* { */ CHAR_LEFT_PARENTHESES: CHAR_LEFT_PARENTHESES$1, /* ( */ CHAR_LEFT_SQUARE_BRACKET: CHAR_LEFT_SQUARE_BRACKET$1, /* [ */ CHAR_PLUS, /* + */ CHAR_QUESTION_MARK, /* ? */ CHAR_RIGHT_CURLY_BRACE: CHAR_RIGHT_CURLY_BRACE$1, /* } */ CHAR_RIGHT_PARENTHESES: CHAR_RIGHT_PARENTHESES$1, /* ) */ CHAR_RIGHT_SQUARE_BRACKET: CHAR_RIGHT_SQUARE_BRACKET$1 /* ] */ } = constants$1;\nconst isPathSeparator = code => {\n return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;\n};\n/**\n * Quickly scans a glob pattern and returns an object with a handful of\n * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),\n * `glob` (the actual pattern), and `negated` (true if the path starts with `!`).\n *\n * ```js\n * const pm = require('picomatch');\n * console.log(pm.scan('foo/bar/*.js'));\n * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }\n * ```\n * @param {String} `str`\n * @param {Object} `options`\n * @return {Object} Returns an object with tokens and regex source string.\n * @api public\n */\nvar scan = (input, options) => {\n let opts = options || {};\n let length = input.length - 1;\n let index = -1;\n let start = 0;\n let lastIndex = 0;\n let isGlob = false;\n let backslashes = false;\n let negated = false;\n let braces = 0;\n let prev;\n let code;\n let braceEscaped = false;\n let eos = () => index >= length;\n let advance = () => {\n prev = code;\n return input.charCodeAt(++index);\n };\n while (index < length) {\n code = advance();\n let next;\n if (code === CHAR_BACKWARD_SLASH) {\n backslashes = true;\n next = advance();\n if (next === CHAR_LEFT_CURLY_BRACE$1) {\n braceEscaped = true;\n }\n continue;\n }\n if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE$1) {\n braces++;\n while (!eos() && (next = advance())) {\n if (next === CHAR_BACKWARD_SLASH) {\n backslashes = true;\n next = advance();\n continue;\n }\n if (next === CHAR_LEFT_CURLY_BRACE$1) {\n braces++;\n continue;\n }\n if (!braceEscaped && next === CHAR_DOT$1 && (next = advance()) === CHAR_DOT$1) {\n isGlob = true;\n break;\n }\n if (!braceEscaped && next === CHAR_COMMA$1) {\n isGlob = true;\n break;\n }\n if (next === CHAR_RIGHT_CURLY_BRACE$1) {\n braces--;\n if (braces === 0) {\n braceEscaped = false;\n break;\n }\n }\n }\n }\n if (code === CHAR_FORWARD_SLASH) {\n if (prev === CHAR_DOT$1 && index === (start + 1)) {\n start += 2;\n continue;\n }\n lastIndex = index + 1;\n continue;\n }\n if (code === CHAR_ASTERISK) {\n isGlob = true;\n break;\n }\n if (code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK) {\n isGlob = true;\n break;\n }\n if (code === CHAR_LEFT_SQUARE_BRACKET$1) {\n while (!eos() && (next = advance())) {\n if (next === CHAR_BACKWARD_SLASH) {\n backslashes = true;\n next = advance();\n continue;\n }\n if (next === CHAR_RIGHT_SQUARE_BRACKET$1) {\n isGlob = true;\n break;\n }\n }\n }\n let isExtglobChar = code === CHAR_PLUS\n || code === CHAR_AT\n || code === CHAR_EXCLAMATION_MARK;\n if (isExtglobChar && input.charCodeAt(index + 1) === CHAR_LEFT_PARENTHESES$1) {\n isGlob = true;\n break;\n }\n if (code === CHAR_EXCLAMATION_MARK && index === start) {\n negated = true;\n start++;\n continue;\n }\n if (code === CHAR_LEFT_PARENTHESES$1) {\n while (!eos() && (next = advance())) {\n if (next === CHAR_BACKWARD_SLASH) {\n backslashes = true;\n next = advance();\n continue;\n }\n if (next === CHAR_RIGHT_PARENTHESES$1) {\n isGlob = true;\n break;\n }\n }\n }\n if (isGlob) {\n break;\n }\n }\n let prefix = '';\n let orig = input;\n let base = input;\n let glob = '';\n if (start > 0) {\n prefix = input.slice(0, start);\n input = input.slice(start);\n lastIndex -= start;\n }\n if (base && isGlob === true && lastIndex > 0) {\n base = input.slice(0, lastIndex);\n glob = input.slice(lastIndex);\n }\n else if (isGlob === true) {\n base = '';\n glob = input;\n }\n else {\n base = input;\n }\n if (base && base !== '' && base !== '/' && base !== input) {\n if (isPathSeparator(base.charCodeAt(base.length - 1))) {\n base = base.slice(0, -1);\n }\n }\n if (opts.unescape === true) {\n if (glob)\n glob = utils$1.removeBackslashes(glob);\n if (base && backslashes === true) {\n base = utils$1.removeBackslashes(base);\n }\n }\n return { prefix, input: orig, base, glob, negated, isGlob };\n};\n\n/**\n * Constants\n */\nconst { MAX_LENGTH: MAX_LENGTH$1, POSIX_REGEX_SOURCE: POSIX_REGEX_SOURCE$1, REGEX_NON_SPECIAL_CHAR, REGEX_SPECIAL_CHARS_BACKREF, REPLACEMENTS } = constants$1;\n/**\n * Helpers\n */\nconst expandRange = (args, options) => {\n if (typeof options.expandRange === 'function') {\n return options.expandRange(...args, options);\n }\n args.sort();\n let value = `[${args.join('-')}]`;\n try {\n }\n catch (ex) {\n return args.map(v => utils$1.escapeRegex(v)).join('..');\n }\n return value;\n};\nconst negate = state => {\n let count = 1;\n while (state.peek() === '!' && (state.peek(2) !== '(' || state.peek(3) === '?')) {\n state.advance();\n state.start++;\n count++;\n }\n if (count % 2 === 0) {\n return false;\n }\n state.negated = true;\n state.start++;\n return true;\n};\n/**\n * Create the message for a syntax error\n */\nconst syntaxError = (type, char) => {\n return `Missing ${type}: \"${char}\" - use \"\\\\\\\\${char}\" to match literal characters`;\n};\n/**\n * Parse the given input string.\n * @param {String} input\n * @param {Object} options\n * @return {Object}\n */\nconst parse$1 = (input, options) => {\n if (typeof input !== 'string') {\n throw new TypeError('Expected a string');\n }\n input = REPLACEMENTS[input] || input;\n let opts = Object.assign({}, options);\n let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$1, opts.maxLength) : MAX_LENGTH$1;\n let len = input.length;\n if (len > max) {\n throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);\n }\n let bos = { type: 'bos', value: '', output: opts.prepend || '' };\n let tokens = [bos];\n let capture = opts.capture ? '' : '?:';\n let win32 = utils$1.isWindows(options);\n // create constants based on platform, for windows or posix\n const PLATFORM_CHARS = constants$1.globChars(win32);\n const EXTGLOB_CHARS = constants$1.extglobChars(PLATFORM_CHARS);\n const { DOT_LITERAL, PLUS_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOT_SLASH, NO_DOTS_SLASH, QMARK, QMARK_NO_DOT, STAR, START_ANCHOR } = PLATFORM_CHARS;\n const globstar = (opts) => {\n return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;\n };\n let nodot = opts.dot ? '' : NO_DOT;\n let star = opts.bash === true ? globstar(opts) : STAR;\n let qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;\n if (opts.capture) {\n star = `(${star})`;\n }\n // minimatch options support\n if (typeof opts.noext === 'boolean') {\n opts.noextglob = opts.noext;\n }\n let state = {\n index: -1,\n start: 0,\n consumed: '',\n output: '',\n backtrack: false,\n brackets: 0,\n braces: 0,\n parens: 0,\n quotes: 0,\n tokens\n };\n let extglobs = [];\n let stack = [];\n let prev = bos;\n let value;\n /**\n * Tokenizing helpers\n */\n const eos = () => state.index === len - 1;\n const peek = state.peek = (n = 1) => input[state.index + n];\n const advance = state.advance = () => input[++state.index];\n const append = token => {\n state.output += token.output != null ? token.output : token.value;\n state.consumed += token.value || '';\n };\n const increment = type => {\n state[type]++;\n stack.push(type);\n };\n const decrement = type => {\n state[type]--;\n stack.pop();\n };\n /**\n * Push tokens onto the tokens array. This helper speeds up\n * tokenizing by 1) helping us avoid backtracking as much as possible,\n * and 2) helping us avoid creating extra tokens when consecutive\n * characters are plain text. This improves performance and simplifies\n * lookbehinds.\n */\n const push = tok => {\n if (prev.type === 'globstar') {\n let isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace');\n let isExtglob = extglobs.length && (tok.type === 'pipe' || tok.type === 'paren');\n if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) {\n state.output = state.output.slice(0, -prev.output.length);\n prev.type = 'star';\n prev.value = '*';\n prev.output = star;\n state.output += prev.output;\n }\n }\n if (extglobs.length && tok.type !== 'paren' && !EXTGLOB_CHARS[tok.value]) {\n extglobs[extglobs.length - 1].inner += tok.value;\n }\n if (tok.value || tok.output)\n append(tok);\n if (prev && prev.type === 'text' && tok.type === 'text') {\n prev.value += tok.value;\n return;\n }\n tok.prev = prev;\n tokens.push(tok);\n prev = tok;\n };\n const extglobOpen = (type, value) => {\n let token = Object.assign({}, EXTGLOB_CHARS[value], { conditions: 1, inner: '' });\n token.prev = prev;\n token.parens = state.parens;\n token.output = state.output;\n let output = (opts.capture ? '(' : '') + token.open;\n push({ type, value, output: state.output ? '' : ONE_CHAR });\n push({ type: 'paren', extglob: true, value: advance(), output });\n increment('parens');\n extglobs.push(token);\n };\n const extglobClose = token => {\n let output = token.close + (opts.capture ? ')' : '');\n if (token.type === 'negate') {\n let extglobStar = star;\n if (token.inner && token.inner.length > 1 && token.inner.includes('/')) {\n extglobStar = globstar(opts);\n }\n if (extglobStar !== star || eos() || /^\\)+$/.test(input.slice(state.index + 1))) {\n output = token.close = ')$))' + extglobStar;\n }\n if (token.prev.type === 'bos' && eos()) {\n state.negatedExtglob = true;\n }\n }\n push({ type: 'paren', extglob: true, value, output });\n decrement('parens');\n };\n if (opts.fastpaths !== false && !/(^[*!]|[/{[()\\]}\"])/.test(input)) {\n let backslashes = false;\n let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {\n if (first === '\\\\') {\n backslashes = true;\n return m;\n }\n if (first === '?') {\n if (esc) {\n return esc + first + (rest ? QMARK.repeat(rest.length) : '');\n }\n if (index === 0) {\n return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');\n }\n return QMARK.repeat(chars.length);\n }\n if (first === '.') {\n return DOT_LITERAL.repeat(chars.length);\n }\n if (first === '*') {\n if (esc) {\n return esc + first + (rest ? star : '');\n }\n return star;\n }\n return esc ? m : '\\\\' + m;\n });\n if (backslashes === true) {\n if (opts.unescape === true) {\n output = output.replace(/\\\\/g, '');\n }\n else {\n output = output.replace(/\\\\+/g, m => {\n return m.length % 2 === 0 ? '\\\\\\\\' : (m ? '\\\\' : '');\n });\n }\n }\n state.output = output;\n return state;\n }\n /**\n * Tokenize input until we reach end-of-string\n */\n while (!eos()) {\n value = advance();\n if (value === '\\u0000') {\n continue;\n }\n /**\n * Escaped characters\n */\n if (value === '\\\\') {\n let next = peek();\n if (next === '/' && opts.bash !== true) {\n continue;\n }\n if (next === '.' || next === ';') {\n continue;\n }\n if (!next) {\n value += '\\\\';\n push({ type: 'text', value });\n continue;\n }\n // collapse slashes to reduce potential for exploits\n let match = /^\\\\+/.exec(input.slice(state.index + 1));\n let slashes = 0;\n if (match && match[0].length > 2) {\n slashes = match[0].length;\n state.index += slashes;\n if (slashes % 2 !== 0) {\n value += '\\\\';\n }\n }\n if (opts.unescape === true) {\n value = advance() || '';\n }\n else {\n value += advance() || '';\n }\n if (state.brackets === 0) {\n push({ type: 'text', value });\n continue;\n }\n }\n /**\n * If we're inside a regex character class, continue\n * until we reach the closing bracket.\n */\n if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) {\n if (opts.posix !== false && value === ':') {\n let inner = prev.value.slice(1);\n if (inner.includes('[')) {\n prev.posix = true;\n if (inner.includes(':')) {\n let idx = prev.value.lastIndexOf('[');\n let pre = prev.value.slice(0, idx);\n let rest = prev.value.slice(idx + 2);\n let posix = POSIX_REGEX_SOURCE$1[rest];\n if (posix) {\n prev.value = pre + posix;\n state.backtrack = true;\n advance();\n if (!bos.output && tokens.indexOf(prev) === 1) {\n bos.output = ONE_CHAR;\n }\n continue;\n }\n }\n }\n }\n if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) {\n value = '\\\\' + value;\n }\n if (value === ']' && (prev.value === '[' || prev.value === '[^')) {\n value = '\\\\' + value;\n }\n if (opts.posix === true && value === '!' && prev.value === '[') {\n value = '^';\n }\n prev.value += value;\n append({ value });\n continue;\n }\n /**\n * If we're inside a quoted string, continue\n * until we reach the closing double quote.\n */\n if (state.quotes === 1 && value !== '\"') {\n value = utils$1.escapeRegex(value);\n prev.value += value;\n append({ value });\n continue;\n }\n /**\n * Double quotes\n */\n if (value === '\"') {\n state.quotes = state.quotes === 1 ? 0 : 1;\n if (opts.keepQuotes === true) {\n push({ type: 'text', value });\n }\n continue;\n }\n /**\n * Parentheses\n */\n if (value === '(') {\n push({ type: 'paren', value });\n increment('parens');\n continue;\n }\n if (value === ')') {\n if (state.parens === 0 && opts.strictBrackets === true) {\n throw new SyntaxError(syntaxError('opening', '('));\n }\n let extglob = extglobs[extglobs.length - 1];\n if (extglob && state.parens === extglob.parens + 1) {\n extglobClose(extglobs.pop());\n continue;\n }\n push({ type: 'paren', value, output: state.parens ? ')' : '\\\\)' });\n decrement('parens');\n continue;\n }\n /**\n * Brackets\n */\n if (value === '[') {\n if (opts.nobracket === true || !input.slice(state.index + 1).includes(']')) {\n if (opts.nobracket !== true && opts.strictBrackets === true) {\n throw new SyntaxError(syntaxError('closing', ']'));\n }\n value = '\\\\' + value;\n }\n else {\n increment('brackets');\n }\n push({ type: 'bracket', value });\n continue;\n }\n if (value === ']') {\n if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) {\n push({ type: 'text', value, output: '\\\\' + value });\n continue;\n }\n if (state.brackets === 0) {\n if (opts.strictBrackets === true) {\n throw new SyntaxError(syntaxError('opening', '['));\n }\n push({ type: 'text', value, output: '\\\\' + value });\n continue;\n }\n decrement('brackets');\n let prevValue = prev.value.slice(1);\n if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) {\n value = '/' + value;\n }\n prev.value += value;\n append({ value });\n // when literal brackets are explicitly disabled\n // assume we should match with a regex character class\n if (opts.literalBrackets === false || utils$1.hasRegexChars(prevValue)) {\n continue;\n }\n let escaped = utils$1.escapeRegex(prev.value);\n state.output = state.output.slice(0, -prev.value.length);\n // when literal brackets are explicitly enabled\n // assume we should escape the brackets to match literal characters\n if (opts.literalBrackets === true) {\n state.output += escaped;\n prev.value = escaped;\n continue;\n }\n // when the user specifies nothing, try to match both\n prev.value = `(${capture}${escaped}|${prev.value})`;\n state.output += prev.value;\n continue;\n }\n /**\n * Braces\n */\n if (value === '{' && opts.nobrace !== true) {\n push({ type: 'brace', value, output: '(' });\n increment('braces');\n continue;\n }\n if (value === '}') {\n if (opts.nobrace === true || state.braces === 0) {\n push({ type: 'text', value, output: '\\\\' + value });\n continue;\n }\n let output = ')';\n if (state.dots === true) {\n let arr = tokens.slice();\n let range = [];\n for (let i = arr.length - 1; i >= 0; i--) {\n tokens.pop();\n if (arr[i].type === 'brace') {\n break;\n }\n if (arr[i].type !== 'dots') {\n range.unshift(arr[i].value);\n }\n }\n output = expandRange(range, opts);\n state.backtrack = true;\n }\n push({ type: 'brace', value, output });\n decrement('braces');\n continue;\n }\n /**\n * Pipes\n */\n if (value === '|') {\n if (extglobs.length > 0) {\n extglobs[extglobs.length - 1].conditions++;\n }\n push({ type: 'text', value });\n continue;\n }\n /**\n * Commas\n */\n if (value === ',') {\n let output = value;\n if (state.braces > 0 && stack[stack.length - 1] === 'braces') {\n output = '|';\n }\n push({ type: 'comma', value, output });\n continue;\n }\n /**\n * Slashes\n */\n if (value === '/') {\n // if the beginning of the glob is \"./\", advance the start\n // to the current index, and don't add the \"./\" characters\n // to the state. This greatly simplifies lookbehinds when\n // checking for BOS characters like \"!\" and \".\" (not \"./\")\n if (prev.type === 'dot' && state.index === 1) {\n state.start = state.index + 1;\n state.consumed = '';\n state.output = '';\n tokens.pop();\n prev = bos; // reset \"prev\" to the first token\n continue;\n }\n push({ type: 'slash', value, output: SLASH_LITERAL });\n continue;\n }\n /**\n * Dots\n */\n if (value === '.') {\n if (state.braces > 0 && prev.type === 'dot') {\n if (prev.value === '.')\n prev.output = DOT_LITERAL;\n prev.type = 'dots';\n prev.output += value;\n prev.value += value;\n state.dots = true;\n continue;\n }\n push({ type: 'dot', value, output: DOT_LITERAL });\n continue;\n }\n /**\n * Question marks\n */\n if (value === '?') {\n if (prev && prev.type === 'paren') {\n let next = peek();\n let output = value;\n if (next === '<' && !utils$1.supportsLookbehinds()) {\n throw new Error('Node.js v10 or higher is required for regex lookbehinds');\n }\n if (prev.value === '(' && !/[!=<:]/.test(next) || (next === '<' && !/[!=]/.test(peek(2)))) {\n output = '\\\\' + value;\n }\n push({ type: 'text', value, output });\n continue;\n }\n if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {\n extglobOpen('qmark', value);\n continue;\n }\n if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) {\n push({ type: 'qmark', value, output: QMARK_NO_DOT });\n continue;\n }\n push({ type: 'qmark', value, output: QMARK });\n continue;\n }\n /**\n * Exclamation\n */\n if (value === '!') {\n if (opts.noextglob !== true && peek() === '(') {\n if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) {\n extglobOpen('negate', value);\n continue;\n }\n }\n if (opts.nonegate !== true && state.index === 0) {\n negate(state);\n continue;\n }\n }\n /**\n * Plus\n */\n if (value === '+') {\n if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {\n extglobOpen('plus', value);\n continue;\n }\n if (prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) {\n let output = prev.extglob === true ? '\\\\' + value : value;\n push({ type: 'plus', value, output });\n continue;\n }\n // use regex behavior inside parens\n if (state.parens > 0 && opts.regex !== false) {\n push({ type: 'plus', value });\n continue;\n }\n push({ type: 'plus', value: PLUS_LITERAL });\n continue;\n }\n /**\n * Plain text\n */\n if (value === '@') {\n if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {\n push({ type: 'at', value, output: '' });\n continue;\n }\n push({ type: 'text', value });\n continue;\n }\n /**\n * Plain text\n */\n if (value !== '*') {\n if (value === '$' || value === '^') {\n value = '\\\\' + value;\n }\n let match = REGEX_NON_SPECIAL_CHAR.exec(input.slice(state.index + 1));\n if (match) {\n value += match[0];\n state.index += match[0].length;\n }\n push({ type: 'text', value });\n continue;\n }\n /**\n * Stars\n */\n if (prev && (prev.type === 'globstar' || prev.star === true)) {\n prev.type = 'star';\n prev.star = true;\n prev.value += value;\n prev.output = star;\n state.backtrack = true;\n state.consumed += value;\n continue;\n }\n if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {\n extglobOpen('star', value);\n continue;\n }\n if (prev.type === 'star') {\n if (opts.noglobstar === true) {\n state.consumed += value;\n continue;\n }\n let prior = prev.prev;\n let before = prior.prev;\n let isStart = prior.type === 'slash' || prior.type === 'bos';\n let afterStar = before && (before.type === 'star' || before.type === 'globstar');\n if (opts.bash === true && (!isStart || (!eos() && peek() !== '/'))) {\n push({ type: 'star', value, output: '' });\n continue;\n }\n let isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace');\n let isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren');\n if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) {\n push({ type: 'star', value, output: '' });\n continue;\n }\n // strip consecutive `/**/`\n while (input.slice(state.index + 1, state.index + 4) === '/**') {\n let after = input[state.index + 4];\n if (after && after !== '/') {\n break;\n }\n state.consumed += '/**';\n state.index += 3;\n }\n if (prior.type === 'bos' && eos()) {\n prev.type = 'globstar';\n prev.value += value;\n prev.output = globstar(opts);\n state.output = prev.output;\n state.consumed += value;\n continue;\n }\n if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) {\n state.output = state.output.slice(0, -(prior.output + prev.output).length);\n prior.output = '(?:' + prior.output;\n prev.type = 'globstar';\n prev.output = globstar(opts) + '|$)';\n prev.value += value;\n state.output += prior.output + prev.output;\n state.consumed += value;\n continue;\n }\n let next = peek();\n if (prior.type === 'slash' && prior.prev.type !== 'bos' && next === '/') {\n let end = peek(2) !== void 0 ? '|$' : '';\n state.output = state.output.slice(0, -(prior.output + prev.output).length);\n prior.output = '(?:' + prior.output;\n prev.type = 'globstar';\n prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;\n prev.value += value;\n state.output += prior.output + prev.output;\n state.consumed += value + advance();\n push({ type: 'slash', value, output: '' });\n continue;\n }\n if (prior.type === 'bos' && next === '/') {\n prev.type = 'globstar';\n prev.value += value;\n prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;\n state.output = prev.output;\n state.consumed += value + advance();\n push({ type: 'slash', value, output: '' });\n continue;\n }\n // remove single star from output\n state.output = state.output.slice(0, -prev.output.length);\n // reset previous token to globstar\n prev.type = 'globstar';\n prev.output = globstar(opts);\n prev.value += value;\n // reset output with globstar\n state.output += prev.output;\n state.consumed += value;\n continue;\n }\n let token = { type: 'star', value, output: star };\n if (opts.bash === true) {\n token.output = '.*?';\n if (prev.type === 'bos' || prev.type === 'slash') {\n token.output = nodot + token.output;\n }\n push(token);\n continue;\n }\n if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) {\n token.output = value;\n push(token);\n continue;\n }\n if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') {\n if (prev.type === 'dot') {\n state.output += NO_DOT_SLASH;\n prev.output += NO_DOT_SLASH;\n }\n else if (opts.dot === true) {\n state.output += NO_DOTS_SLASH;\n prev.output += NO_DOTS_SLASH;\n }\n else {\n state.output += nodot;\n prev.output += nodot;\n }\n if (peek() !== '*') {\n state.output += ONE_CHAR;\n prev.output += ONE_CHAR;\n }\n }\n push(token);\n }\n while (state.brackets > 0) {\n if (opts.strictBrackets === true)\n throw new SyntaxError(syntaxError('closing', ']'));\n state.output = utils$1.escapeLast(state.output, '[');\n decrement('brackets');\n }\n while (state.parens > 0) {\n if (opts.strictBrackets === true)\n throw new SyntaxError(syntaxError('closing', ')'));\n state.output = utils$1.escapeLast(state.output, '(');\n decrement('parens');\n }\n while (state.braces > 0) {\n if (opts.strictBrackets === true)\n throw new SyntaxError(syntaxError('closing', '}'));\n state.output = utils$1.escapeLast(state.output, '{');\n decrement('braces');\n }\n if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) {\n push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` });\n }\n // rebuild the output if we had to backtrack at any point\n if (state.backtrack === true) {\n state.output = '';\n for (let token of state.tokens) {\n state.output += token.output != null ? token.output : token.value;\n if (token.suffix) {\n state.output += token.suffix;\n }\n }\n }\n return state;\n};\n/**\n * Fast paths for creating regular expressions for common glob patterns.\n * This can significantly speed up processing and has very little downside\n * impact when none of the fast paths match.\n */\nparse$1.fastpaths = (input, options) => {\n let opts = Object.assign({}, options);\n let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$1, opts.maxLength) : MAX_LENGTH$1;\n let len = input.length;\n if (len > max) {\n throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);\n }\n input = REPLACEMENTS[input] || input;\n let win32 = utils$1.isWindows(options);\n // create constants based on platform, for windows or posix\n const { DOT_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOTS, NO_DOTS_SLASH, STAR, START_ANCHOR } = constants$1.globChars(win32);\n let capture = opts.capture ? '' : '?:';\n let star = opts.bash === true ? '.*?' : STAR;\n let nodot = opts.dot ? NO_DOTS : NO_DOT;\n let slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;\n if (opts.capture) {\n star = `(${star})`;\n }\n const globstar = (opts) => {\n return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;\n };\n const create = str => {\n switch (str) {\n case '*':\n return `${nodot}${ONE_CHAR}${star}`;\n case '.*':\n return `${DOT_LITERAL}${ONE_CHAR}${star}`;\n case '*.*':\n return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;\n case '*/*':\n return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;\n case '**':\n return nodot + globstar(opts);\n case '**/*':\n return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;\n case '**/*.*':\n return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;\n case '**/.*':\n return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;\n default: {\n let match = /^(.*?)\\.(\\w+)$/.exec(str);\n if (!match)\n return;\n let source = create(match[1], options);\n if (!source)\n return;\n return source + DOT_LITERAL + match[2];\n }\n }\n };\n let output = create(input);\n if (output && opts.strictSlashes !== true) {\n output += `${SLASH_LITERAL}?`;\n }\n return output;\n};\nvar parse_1$1 = parse$1;\n\n/**\n * Creates a matcher function from one or more glob patterns. The\n * returned function takes a string to match as its first argument,\n * and returns true if the string is a match. The returned matcher\n * function also takes a boolean as the second argument that, when true,\n * returns an object with additional information.\n *\n * ```js\n * const picomatch = require('picomatch');\n * // picomatch(glob[, options]);\n *\n * const isMatch = picomatch('*.!(*a)');\n * console.log(isMatch('a.a')); //=> false\n * console.log(isMatch('a.b')); //=> true\n * ```\n * @name picomatch\n * @param {String|Array} `globs` One or more glob patterns.\n * @param {Object=} `options`\n * @return {Function=} Returns a matcher function.\n * @api public\n */\nconst picomatch = (glob, options, returnState = false) => {\n if (Array.isArray(glob)) {\n let fns = glob.map(input => picomatch(input, options, returnState));\n return str => {\n for (let isMatch of fns) {\n let state = isMatch(str);\n if (state)\n return state;\n }\n return false;\n };\n }\n if (typeof glob !== 'string' || glob === '') {\n throw new TypeError('Expected pattern to be a non-empty string');\n }\n let opts = options || {};\n let posix = utils$1.isWindows(options);\n let regex = picomatch.makeRe(glob, options, false, true);\n let state = regex.state;\n delete regex.state;\n let isIgnored = () => false;\n if (opts.ignore) {\n let ignoreOpts = Object.assign({}, options, { ignore: null, onMatch: null, onResult: null });\n isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);\n }\n const matcher = (input, returnObject = false) => {\n let { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix });\n let result = { glob, state, regex, posix, input, output, match, isMatch };\n if (typeof opts.onResult === 'function') {\n opts.onResult(result);\n }\n if (isMatch === false) {\n result.isMatch = false;\n return returnObject ? result : false;\n }\n if (isIgnored(input)) {\n if (typeof opts.onIgnore === 'function') {\n opts.onIgnore(result);\n }\n result.isMatch = false;\n return returnObject ? result : false;\n }\n if (typeof opts.onMatch === 'function') {\n opts.onMatch(result);\n }\n return returnObject ? result : true;\n };\n if (returnState) {\n matcher.state = state;\n }\n return matcher;\n};\n/**\n * Test `input` with the given `regex`. This is used by the main\n * `picomatch()` function to test the input string.\n *\n * ```js\n * const picomatch = require('picomatch');\n * // picomatch.test(input, regex[, options]);\n *\n * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\\/([^/]*?))$/));\n * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }\n * ```\n * @param {String} `input` String to test.\n * @param {RegExp} `regex`\n * @return {Object} Returns an object with matching info.\n * @api public\n */\npicomatch.test = (input, regex, options, { glob, posix } = {}) => {\n if (typeof input !== 'string') {\n throw new TypeError('Expected input to be a string');\n }\n if (input === '') {\n return { isMatch: false, output: '' };\n }\n let opts = options || {};\n let format = opts.format || (posix ? utils$1.toPosixSlashes : null);\n let match = input === glob;\n let output = (match && format) ? format(input) : input;\n if (match === false) {\n output = format ? format(input) : input;\n match = output === glob;\n }\n if (match === false || opts.capture === true) {\n if (opts.matchBase === true || opts.basename === true) {\n match = picomatch.matchBase(input, regex, options, posix);\n }\n else {\n match = regex.exec(output);\n }\n }\n return { isMatch: !!match, match, output };\n};\n/**\n * Match the basename of a filepath.\n *\n * ```js\n * const picomatch = require('picomatch');\n * // picomatch.matchBase(input, glob[, options]);\n * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true\n * ```\n * @param {String} `input` String to test.\n * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).\n * @return {Boolean}\n * @api public\n */\npicomatch.matchBase = (input, glob, options, posix = utils$1.isWindows(options)) => {\n let regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);\n return regex.test(path.basename(input));\n};\n/**\n * Returns true if **any** of the given glob `patterns` match the specified `string`.\n *\n * ```js\n * const picomatch = require('picomatch');\n * // picomatch.isMatch(string, patterns[, options]);\n *\n * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true\n * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false\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).\n * @return {Boolean} Returns true if any patterns match `str`\n * @api public\n */\npicomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);\n/**\n * Parse a glob pattern to create the source string for a regular\n * expression.\n *\n * ```js\n * const picomatch = require('picomatch');\n * const result = picomatch.parse(glob[, 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 a regex source string.\n * @api public\n */\npicomatch.parse = (glob, options) => parse_1$1(glob, options);\n/**\n * Scan a glob pattern to separate the pattern into segments.\n *\n * ```js\n * const picomatch = require('picomatch');\n * // picomatch.scan(input[, options]);\n *\n * const result = picomatch.scan('!./foo/*.js');\n * console.log(result);\n * // { prefix: '!./',\n * // input: '!./foo/*.js',\n * // base: 'foo',\n * // glob: '*.js',\n * // negated: true,\n * // isGlob: true }\n * ```\n * @param {String} `input` Glob pattern to scan.\n * @param {Object} `options`\n * @return {Object} Returns an object with\n * @api public\n */\npicomatch.scan = (input, options) => scan(input, options);\n/**\n * Create a regular expression from a glob pattern.\n *\n * ```js\n * const picomatch = require('picomatch');\n * // picomatch.makeRe(input[, options]);\n *\n * console.log(picomatch.makeRe('*.js'));\n * //=> /^(?:(?!\\.)(?=.)[^/]*?\\.js)$/\n * ```\n * @param {String} `input` 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 */\npicomatch.makeRe = (input, options, returnOutput = false, returnState = false) => {\n if (!input || typeof input !== 'string') {\n throw new TypeError('Expected a non-empty string');\n }\n let opts = options || {};\n let prepend = opts.contains ? '' : '^';\n let append = opts.contains ? '' : '$';\n let state = { negated: false, fastpaths: true };\n let prefix = '';\n let output;\n if (input.startsWith('./')) {\n input = input.slice(2);\n prefix = state.prefix = './';\n }\n if (opts.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {\n output = parse_1$1.fastpaths(input, options);\n }\n if (output === void 0) {\n state = picomatch.parse(input, options);\n state.prefix = prefix + (state.prefix || '');\n output = state.output;\n }\n if (returnOutput === true) {\n return output;\n }\n let source = `${prepend}(?:${output})${append}`;\n if (state && state.negated === true) {\n source = `^(?!${source}).*$`;\n }\n let regex = picomatch.toRegex(source, options);\n if (returnState === true) {\n regex.state = state;\n }\n return regex;\n};\n/**\n * Create a regular expression from the given regex source string.\n *\n * ```js\n * const picomatch = require('picomatch');\n * // picomatch.toRegex(source[, options]);\n *\n * const { output } = picomatch.parse('*.js');\n * console.log(picomatch.toRegex(output));\n * //=> /^(?:(?!\\.)(?=.)[^/]*?\\.js)$/\n * ```\n * @param {String} `source` Regular expression source string.\n * @param {Object} `options`\n * @return {RegExp}\n * @api public\n */\npicomatch.toRegex = (source, options) => {\n try {\n let opts = options || {};\n return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));\n }\n catch (err) {\n if (options && options.debug === true)\n throw err;\n return /$^/;\n }\n};\n/**\n * Picomatch constants.\n * @return {Object}\n */\npicomatch.constants = constants$1;\n/**\n * Expose \"picomatch\"\n */\nvar picomatch_1 = picomatch;\n\nvar picomatch$1 = picomatch_1;\n\nconst isEmptyString = val => typeof val === 'string' && (val === '' || val === './');\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} list List of strings to match.\n * @param {String|Array} 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 */\nconst micromatch = (list, patterns, options) => {\n patterns = [].concat(patterns);\n list = [].concat(list);\n let omit = new Set();\n let keep = new Set();\n let items = new Set();\n let negatives = 0;\n let onResult = state => {\n items.add(state.output);\n if (options && options.onResult) {\n options.onResult(state);\n }\n };\n for (let i = 0; i < patterns.length; i++) {\n let isMatch = picomatch$1(String(patterns[i]), Object.assign({}, options, { onResult }), true);\n let negated = isMatch.state.negated || isMatch.state.negatedExtglob;\n if (negated)\n negatives++;\n for (let item of list) {\n let matched = isMatch(item, true);\n let match = negated ? !matched.isMatch : matched.isMatch;\n if (!match)\n continue;\n if (negated) {\n omit.add(matched.output);\n }\n else {\n omit.delete(matched.output);\n keep.add(matched.output);\n }\n }\n }\n let result = negatives === patterns.length ? [...items] : [...keep];\n let matches = result.filter(item => !omit.has(item));\n if (options && matches.length === 0) {\n if (options.failglob === true) {\n throw new Error(`No matches found for \"${patterns.join(', ')}\"`);\n }\n if (options.nonull === true || options.nullglob === true) {\n return options.unescape ? patterns.map(p => p.replace(/\\\\/g, '')) : patterns;\n }\n }\n return matches;\n};\n/**\n * Backwards compatibility\n */\nmicromatch.match = micromatch;\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 */\nmicromatch.matcher = (pattern, options) => picomatch$1(pattern, options);\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 */\nmicromatch.isMatch = (str, patterns, options) => picomatch$1(patterns, options)(str);\n/**\n * Backwards compatibility\n */\nmicromatch.any = micromatch.isMatch;\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 */\nmicromatch.not = (list, patterns, options = {}) => {\n patterns = [].concat(patterns).map(String);\n let result = new Set();\n let items = [];\n let onResult = state => {\n if (options.onResult)\n options.onResult(state);\n items.push(state.output);\n };\n let matches = micromatch(list, patterns, Object.assign({}, options, { onResult }));\n for (let item of items) {\n if (!matches.includes(item)) {\n result.add(item);\n }\n }\n return [...result];\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 the patter matches any part of `str`.\n * @api public\n */\nmicromatch.contains = (str, pattern, options) => {\n if (typeof str !== 'string') {\n throw new TypeError(`Expected a string: \"${util.inspect(str)}\"`);\n }\n if (Array.isArray(pattern)) {\n return pattern.some(p => micromatch.contains(str, p, options));\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, Object.assign({}, options, { contains: true }));\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 */\nmicromatch.matchKeys = (obj, patterns, options) => {\n if (!utils$1.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)\n res[key] = obj[key];\n return res;\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 match `str`\n * @api public\n */\nmicromatch.some = (list, patterns, options) => {\n let items = [].concat(list);\n for (let pattern of [].concat(patterns)) {\n let isMatch = picomatch$1(String(pattern), options);\n if (items.some(item => isMatch(item))) {\n return true;\n }\n }\n return false;\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 any patterns match `str`\n * @api public\n */\nmicromatch.every = (list, patterns, options) => {\n let items = [].concat(list);\n for (let pattern of [].concat(patterns)) {\n let isMatch = picomatch$1(String(pattern), options);\n if (!items.every(item => isMatch(item))) {\n return false;\n }\n }\n return true;\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 */\nmicromatch.all = (str, patterns, options) => {\n if (typeof str !== 'string') {\n throw new TypeError(`Expected a string: \"${util.inspect(str)}\"`);\n }\n return [].concat(patterns).every(p => picomatch$1(p, options)(str));\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 {Boolean} Returns an array of captures if the input matches the glob pattern, otherwise `null`.\n * @api public\n */\nmicromatch.capture = (glob, input, options) => {\n let posix = utils$1.isWindows(options);\n let regex = picomatch$1.makeRe(String(glob), Object.assign({}, options, { capture: true }));\n let match = regex.exec(posix ? utils$1.toPosixSlashes(input) : input);\n if (match) {\n return match.slice(1).map(v => v === void 0 ? '' : v);\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 */\nmicromatch.makeRe = (...args) => picomatch$1.makeRe(...args);\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 */\nmicromatch.scan = (...args) => picomatch$1.scan(...args);\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(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 */\nmicromatch.parse = (patterns, options) => {\n let res = [];\n for (let pattern of [].concat(patterns || [])) {\n for (let str of braces_1(String(pattern), options)) {\n res.push(picomatch$1.parse(str, options));\n }\n }\n return res;\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 */\nmicromatch.braces = (pattern, options) => {\n if (typeof pattern !== 'string')\n throw new TypeError('Expected a string');\n if ((options && options.nobrace === true) || !/\\{.*\\}/.test(pattern)) {\n return [pattern];\n }\n return braces_1(pattern, options);\n};\n/**\n * Expand braces\n */\nmicromatch.braceExpand = (pattern, options) => {\n if (typeof pattern !== 'string')\n throw new TypeError('Expected a string');\n return micromatch.braces(pattern, Object.assign({}, options, { expand: true }));\n};\n/**\n * Expose micromatch\n */\nvar micromatch_1 = micromatch;\n\nfunction ensureArray(thing) {\n if (Array.isArray(thing))\n return thing;\n if (thing == undefined)\n return [];\n return [thing];\n}\n\nfunction getMatcherString(id, resolutionBase) {\n if (resolutionBase === false) {\n return id;\n }\n return resolve(...(typeof resolutionBase === 'string' ? [resolutionBase, id] : [id]));\n}\nconst createFilter = function createFilter(include, exclude, options) {\n const resolutionBase = options && options.resolve;\n const getMatcher = (id) => {\n return id instanceof RegExp\n ? id\n : {\n test: micromatch_1.matcher(getMatcherString(id, resolutionBase)\n .split(sep)\n .join('/'), { dot: true })\n };\n };\n const includeMatchers = ensureArray(include).map(getMatcher);\n const excludeMatchers = ensureArray(exclude).map(getMatcher);\n return function (id) {\n if (typeof id !== 'string')\n return false;\n if (/\\0/.test(id))\n return false;\n id = id.split(sep).join('/');\n for (let i = 0; i < excludeMatchers.length; ++i) {\n const matcher = excludeMatchers[i];\n if (matcher.test(id))\n return false;\n }\n for (let i = 0; i < includeMatchers.length; ++i) {\n const matcher = includeMatchers[i];\n if (matcher.test(id))\n return true;\n }\n return !includeMatchers.length;\n };\n};\n\nconst reservedWords = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public';\nconst builtins = 'arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl';\nconst forbiddenIdentifiers = new Set(`${reservedWords} ${builtins}`.split(' '));\nforbiddenIdentifiers.add('');\nconst makeLegalIdentifier = function makeLegalIdentifier(str) {\n str = str.replace(/-(\\w)/g, (_, letter) => letter.toUpperCase()).replace(/[^$_a-zA-Z0-9]/g, '_');\n if (/\\d/.test(str[0]) || forbiddenIdentifiers.has(str)) {\n str = `_${str}`;\n }\n return str || '_';\n};\n\nfunction stringify$2(obj) {\n return (JSON.stringify(obj) || 'undefined').replace(/[\\u2028\\u2029]/g, char => `\\\\u${('000' + char.charCodeAt(0).toString(16)).slice(-4)}`);\n}\nfunction serializeArray(arr, indent, baseIndent) {\n let output = '[';\n const separator = indent ? '\\n' + baseIndent + indent : '';\n for (let i = 0; i < arr.length; i++) {\n const key = arr[i];\n output += `${i > 0 ? ',' : ''}${separator}${serialize(key, indent, baseIndent + indent)}`;\n }\n return output + `${indent ? '\\n' + baseIndent : ''}]`;\n}\nfunction serializeObject(obj, indent, baseIndent) {\n let output = '{';\n const separator = indent ? '\\n' + baseIndent + indent : '';\n const keys = Object.keys(obj);\n for (let i = 0; i < keys.length; i++) {\n const key = keys[i];\n const stringKey = makeLegalIdentifier(key) === key ? key : stringify$2(key);\n output += `${i > 0 ? ',' : ''}${separator}${stringKey}:${indent ? ' ' : ''}${serialize(obj[key], indent, baseIndent + indent)}`;\n }\n return output + `${indent ? '\\n' + baseIndent : ''}}`;\n}\nfunction serialize(obj, indent, baseIndent) {\n if (obj === Infinity)\n return 'Infinity';\n if (obj === -Infinity)\n return '-Infinity';\n if (obj === 0 && 1 / obj === -Infinity)\n return '-0';\n if (obj instanceof Date)\n return 'new Date(' + obj.getTime() + ')';\n if (obj instanceof RegExp)\n return obj.toString();\n if (obj !== obj)\n return 'NaN';\n if (Array.isArray(obj))\n return serializeArray(obj, indent, baseIndent);\n if (obj === null)\n return 'null';\n if (typeof obj === 'object')\n return serializeObject(obj, indent, baseIndent);\n return stringify$2(obj);\n}\nconst dataToEsm = function dataToEsm(data, options = {}) {\n const t = options.compact ? '' : 'indent' in options ? options.indent : '\\t';\n const _ = options.compact ? '' : ' ';\n const n = options.compact ? '' : '\\n';\n const declarationType = options.preferConst ? 'const' : 'var';\n if (options.namedExports === false ||\n typeof data !== 'object' ||\n Array.isArray(data) ||\n data instanceof Date ||\n data instanceof RegExp ||\n data === null) {\n const code = serialize(data, options.compact ? null : t, '');\n const __ = _ || (/^[{[\\-\\/]/.test(code) ? '' : ' ');\n return `export default${__}${code};`;\n }\n let namedExportCode = '';\n const defaultExportRows = [];\n const dataKeys = Object.keys(data);\n for (let i = 0; i < dataKeys.length; i++) {\n const key = dataKeys[i];\n if (key === makeLegalIdentifier(key)) {\n if (options.objectShorthand)\n defaultExportRows.push(key);\n else\n defaultExportRows.push(`${key}:${_}${key}`);\n namedExportCode += `export ${declarationType} ${key}${_}=${_}${serialize(data[key], options.compact ? null : t, '')};${n}`;\n }\n else {\n defaultExportRows.push(`${stringify$2(key)}:${_}${serialize(data[key], options.compact ? null : t, '')}`);\n }\n }\n return (namedExportCode + `export default${_}{${n}${t}${defaultExportRows.join(`,${n}${t}`)}${n}};${n}`);\n};\n\nexport { addExtension, attachScopes, createFilter, dataToEsm, extractAssignedNames, makeLegalIdentifier };\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/dist/plugin.js b/dist/plugin.js index 9ea0fa8..433768c 100644 --- a/dist/plugin.js +++ b/dist/plugin.js @@ -1,35 +1,3095 @@ -'use strict'; - -var uglifyJs = require('uglify-js'); - -function uglify(options) { - if (options === void 0) { options = {}; } - return { - name: 'uglify', - transform: function (code) { - var _this = this; - if (typeof options.sourceMap === 'undefined') { - options.sourceMap = true; - } - if (typeof options.warnings === 'undefined') { - options.warnings = true; - } - var result = uglifyJs.minify(code, options); - if (result.error) { - throw result.error; - } - if (result.warnings) { - result.warnings.forEach(function (warning) { - _this.warn(warning); - }); - } - return { - code: result.code, - map: result.map - }; - } - }; -} - -module.exports = uglify; +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('terser'), require('path'), require('util')) : + typeof define === 'function' && define.amd ? define(['terser', 'path', 'util'], factory) : + (global = global || self, global.uglify = factory(global.terser, global.path, global.util)); +}(this, (function (terser, path, util) { 'use strict'; + + var path__default = 'default' in path ? path['default'] : path; + util = util && util.hasOwnProperty('default') ? util['default'] : util; + + function createCommonjsModule(fn, module) { + return module = { exports: {} }, fn(module, module.exports), module.exports; + } + + var utils = createCommonjsModule(function (module, exports) { + exports.isInteger = num => { + if (typeof num === 'number') { + return Number.isInteger(num); + } + if (typeof num === 'string' && num.trim() !== '') { + return Number.isInteger(Number(num)); + } + return false; + }; + /** + * Find a node of the given type + */ + exports.find = (node, type) => node.nodes.find(node => node.type === type); + /** + * Find a node of the given type + */ + exports.exceedsLimit = (min, max, step = 1, limit) => { + if (limit === false) + return false; + if (!exports.isInteger(min) || !exports.isInteger(max)) + return false; + return ((Number(max) - Number(min)) / Number(step)) >= limit; + }; + /** + * Escape the given node with '\\' before node.value + */ + exports.escapeNode = (block, n = 0, type) => { + let node = block.nodes[n]; + if (!node) + return; + if ((type && node.type === type) || node.type === 'open' || node.type === 'close') { + if (node.escaped !== true) { + node.value = '\\' + node.value; + node.escaped = true; + } + } + }; + /** + * Returns true if the given brace node should be enclosed in literal braces + */ + exports.encloseBrace = node => { + if (node.type !== 'brace') + return false; + if ((node.commas >> 0 + node.ranges >> 0) === 0) { + node.invalid = true; + return true; + } + return false; + }; + /** + * Returns true if a brace node is invalid. + */ + exports.isInvalidBrace = block => { + if (block.type !== 'brace') + return false; + if (block.invalid === true || block.dollar) + return true; + if ((block.commas >> 0 + block.ranges >> 0) === 0) { + block.invalid = true; + return true; + } + if (block.open !== true || block.close !== true) { + block.invalid = true; + return true; + } + return false; + }; + /** + * Returns true if a node is an open or close node + */ + exports.isOpenOrClose = node => { + if (node.type === 'open' || node.type === 'close') { + return true; + } + return node.open === true || node.close === true; + }; + /** + * Reduce an array of text nodes. + */ + exports.reduce = nodes => nodes.reduce((acc, node) => { + if (node.type === 'text') + acc.push(node.value); + if (node.type === 'range') + node.type = 'text'; + return acc; + }, []); + /** + * Flatten an array + */ + exports.flatten = (...args) => { + const result = []; + const flat = arr => { + for (let i = 0; i < arr.length; i++) { + let ele = arr[i]; + Array.isArray(ele) ? flat(ele) : ele !== void 0 && result.push(ele); + } + return result; + }; + flat(args); + return result; + }; + }); + var utils_1 = utils.isInteger; + var utils_2 = utils.find; + var utils_3 = utils.exceedsLimit; + var utils_4 = utils.escapeNode; + var utils_5 = utils.encloseBrace; + var utils_6 = utils.isInvalidBrace; + var utils_7 = utils.isOpenOrClose; + var utils_8 = utils.reduce; + var utils_9 = utils.flatten; + + var stringify = (ast, options = {}) => { + let stringify = (node, parent = {}) => { + let invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent); + let invalidNode = node.invalid === true && options.escapeInvalid === true; + let output = ''; + if (node.value) { + if ((invalidBlock || invalidNode) && utils.isOpenOrClose(node)) { + return '\\' + node.value; + } + return node.value; + } + if (node.value) { + return node.value; + } + if (node.nodes) { + for (let child of node.nodes) { + output += stringify(child); + } + } + return output; + }; + return stringify(ast); + }; + + /*! + * is-number + * + * Copyright (c) 2014-present, Jon Schlinkert. + * Released under the MIT License. + */ + var isNumber = function (num) { + if (typeof num === 'number') { + return num - num === 0; + } + if (typeof num === 'string' && num.trim() !== '') { + return Number.isFinite ? Number.isFinite(+num) : isFinite(+num); + } + return false; + }; + + const toRegexRange = (min, max, options) => { + if (isNumber(min) === false) { + throw new TypeError('toRegexRange: expected the first argument to be a number'); + } + if (max === void 0 || min === max) { + return String(min); + } + if (isNumber(max) === false) { + throw new TypeError('toRegexRange: expected the second argument to be a number.'); + } + let opts = Object.assign({ relaxZeros: true }, options); + if (typeof opts.strictZeros === 'boolean') { + opts.relaxZeros = opts.strictZeros === false; + } + let relax = String(opts.relaxZeros); + let shorthand = String(opts.shorthand); + let capture = String(opts.capture); + let wrap = String(opts.wrap); + let cacheKey = min + ':' + max + '=' + relax + shorthand + capture + wrap; + if (toRegexRange.cache.hasOwnProperty(cacheKey)) { + return toRegexRange.cache[cacheKey].result; + } + let a = Math.min(min, max); + let b = Math.max(min, max); + if (Math.abs(a - b) === 1) { + let result = min + '|' + max; + if (opts.capture) { + return `(${result})`; + } + if (opts.wrap === false) { + return result; + } + return `(?:${result})`; + } + let isPadded = hasPadding(min) || hasPadding(max); + let state = { min, max, a, b }; + let positives = []; + let negatives = []; + if (isPadded) { + state.isPadded = isPadded; + state.maxLen = String(state.max).length; + } + if (a < 0) { + let newMin = b < 0 ? Math.abs(b) : 1; + negatives = splitToPatterns(newMin, Math.abs(a), state, opts); + a = state.a = 0; + } + if (b >= 0) { + positives = splitToPatterns(a, b, state, opts); + } + state.negatives = negatives; + state.positives = positives; + state.result = collatePatterns(negatives, positives); + if (opts.capture === true) { + state.result = `(${state.result})`; + } + else if (opts.wrap !== false && (positives.length + negatives.length) > 1) { + state.result = `(?:${state.result})`; + } + toRegexRange.cache[cacheKey] = state; + return state.result; + }; + function collatePatterns(neg, pos, options) { + let onlyNegative = filterPatterns(neg, pos, '-', false) || []; + let onlyPositive = filterPatterns(pos, neg, '', false) || []; + let intersected = filterPatterns(neg, pos, '-?', true) || []; + let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive); + return subpatterns.join('|'); + } + function splitToRanges(min, max) { + let nines = 1; + let zeros = 1; + let stop = countNines(min, nines); + let stops = new Set([max]); + while (min <= stop && stop <= max) { + stops.add(stop); + nines += 1; + stop = countNines(min, nines); + } + stop = countZeros(max + 1, zeros) - 1; + while (min < stop && stop <= max) { + stops.add(stop); + zeros += 1; + stop = countZeros(max + 1, zeros) - 1; + } + stops = [...stops]; + stops.sort(compare); + return stops; + } + /** + * Convert a range to a regex pattern + * @param {Number} `start` + * @param {Number} `stop` + * @return {String} + */ + function rangeToPattern(start, stop, options) { + if (start === stop) { + return { pattern: start, count: [], digits: 0 }; + } + let zipped = zip(start, stop); + let digits = zipped.length; + let pattern = ''; + let count = 0; + for (let i = 0; i < digits; i++) { + let [startDigit, stopDigit] = zipped[i]; + if (startDigit === stopDigit) { + pattern += startDigit; + } + else if (startDigit !== '0' || stopDigit !== '9') { + pattern += toCharacterClass(startDigit, stopDigit); + } + else { + count++; + } + } + if (count) { + pattern += options.shorthand === true ? '\\d' : '[0-9]'; + } + return { pattern, count: [count], digits }; + } + function splitToPatterns(min, max, tok, options) { + let ranges = splitToRanges(min, max); + let tokens = []; + let start = min; + let prev; + for (let i = 0; i < ranges.length; i++) { + let max = ranges[i]; + let obj = rangeToPattern(String(start), String(max), options); + let zeros = ''; + if (!tok.isPadded && prev && prev.pattern === obj.pattern) { + if (prev.count.length > 1) { + prev.count.pop(); + } + prev.count.push(obj.count[0]); + prev.string = prev.pattern + toQuantifier(prev.count); + start = max + 1; + continue; + } + if (tok.isPadded) { + zeros = padZeros(max, tok, options); + } + obj.string = zeros + obj.pattern + toQuantifier(obj.count); + tokens.push(obj); + start = max + 1; + prev = obj; + } + return tokens; + } + function filterPatterns(arr, comparison, prefix, intersection, options) { + let result = []; + for (let ele of arr) { + let { string } = ele; + // only push if _both_ are negative... + if (!intersection && !contains(comparison, 'string', string)) { + result.push(prefix + string); + } + // or _both_ are positive + if (intersection && contains(comparison, 'string', string)) { + result.push(prefix + string); + } + } + return result; + } + /** + * Zip strings + */ + function zip(a, b) { + let arr = []; + for (let i = 0; i < a.length; i++) + arr.push([a[i], b[i]]); + return arr; + } + function compare(a, b) { + return a > b ? 1 : b > a ? -1 : 0; + } + function contains(arr, key, val) { + return arr.some(ele => ele[key] === val); + } + function countNines(min, len) { + return Number(String(min).slice(0, -len) + '9'.repeat(len)); + } + function countZeros(integer, zeros) { + return integer - (integer % Math.pow(10, zeros)); + } + function toQuantifier(digits) { + let [start = 0, stop = ''] = digits; + if (stop || start > 1) { + return `{${start + (stop ? ',' + stop : '')}}`; + } + return ''; + } + function toCharacterClass(a, b, options) { + return `[${a}${(b - a === 1) ? '' : '-'}${b}]`; + } + function hasPadding(str) { + return /^-?(0+)\d/.test(str); + } + function padZeros(value, tok, options) { + if (!tok.isPadded) { + return value; + } + let diff = Math.abs(tok.maxLen - String(value).length); + let relax = options.relaxZeros !== false; + switch (diff) { + case 0: + return ''; + case 1: + return relax ? '0?' : '0'; + case 2: + return relax ? '0{0,2}' : '00'; + default: { + return relax ? `0{0,${diff}}` : `0{${diff}}`; + } + } + } + /** + * Cache + */ + toRegexRange.cache = {}; + toRegexRange.clearCache = () => (toRegexRange.cache = {}); + /** + * Expose `toRegexRange` + */ + var toRegexRange_1 = toRegexRange; + + const isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val); + const transform = toNumber => { + return value => toNumber === true ? Number(value) : String(value); + }; + const isValidValue = value => { + return typeof value === 'number' || (typeof value === 'string' && value !== ''); + }; + const isNumber$1 = num => Number.isInteger(+num); + const zeros = input => { + let value = `${input}`; + let index = -1; + if (value[0] === '-') + value = value.slice(1); + if (value === '0') + return false; + while (value[++index] === '0') + ; + return index > 0; + }; + const stringify$1 = (start, end, options) => { + if (typeof start === 'string' || typeof end === 'string') { + return true; + } + return options.stringify === true; + }; + const pad = (input, maxLength, toNumber) => { + if (maxLength > 0) { + let dash = input[0] === '-' ? '-' : ''; + if (dash) + input = input.slice(1); + input = (dash + input.padStart(dash ? maxLength - 1 : maxLength, '0')); + } + if (toNumber === false) { + return String(input); + } + return input; + }; + const toMaxLen = (input, maxLength) => { + let negative = input[0] === '-' ? '-' : ''; + if (negative) { + input = input.slice(1); + maxLength--; + } + while (input.length < maxLength) + input = '0' + input; + return negative ? ('-' + input) : input; + }; + const toSequence = (parts, options) => { + parts.negatives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0); + parts.positives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0); + let prefix = options.capture ? '' : '?:'; + let positives = ''; + let negatives = ''; + let result; + if (parts.positives.length) { + positives = parts.positives.join('|'); + } + if (parts.negatives.length) { + negatives = `-(${prefix}${parts.negatives.join('|')})`; + } + if (positives && negatives) { + result = `${positives}|${negatives}`; + } + else { + result = positives || negatives; + } + if (options.wrap) { + return `(${prefix}${result})`; + } + return result; + }; + const toRange = (a, b, isNumbers, options) => { + if (isNumbers) { + return toRegexRange_1(a, b, Object.assign({ wrap: false }, options)); + } + let start = String.fromCharCode(a); + if (a === b) + return start; + let stop = String.fromCharCode(b); + return `[${start}-${stop}]`; + }; + const toRegex = (start, end, options) => { + if (Array.isArray(start)) { + let wrap = options.wrap === true; + let prefix = options.capture ? '' : '?:'; + return wrap ? `(${prefix}${start.join('|')})` : start.join('|'); + } + return toRegexRange_1(start, end, options); + }; + const rangeError = (...args) => { + return new RangeError('Invalid range arguments: ' + util.inspect(...args)); + }; + const invalidRange = (start, end, options) => { + if (options.strictRanges === true) + throw rangeError([start, end]); + return []; + }; + const invalidStep = (step, options) => { + if (options.strictRanges === true) { + throw new TypeError(`Expected step "${step}" to be a number`); + } + return []; + }; + const fillNumbers = (start, end, step = 1, options = {}) => { + let a = Number(start); + let b = Number(end); + if (!Number.isInteger(a) || !Number.isInteger(b)) { + if (options.strictRanges === true) + throw rangeError([start, end]); + return []; + } + // fix negative zero + if (a === 0) + a = 0; + if (b === 0) + b = 0; + let descending = a > b; + let startString = String(start); + let endString = String(end); + let stepString = String(step); + step = Math.max(Math.abs(step), 1); + let padded = zeros(startString) || zeros(endString) || zeros(stepString); + let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0; + let toNumber = padded === false && stringify$1(start, end, options) === false; + let format = options.transform || transform(toNumber); + if (options.toRegex && step === 1) { + return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options); + } + let parts = { negatives: [], positives: [] }; + let push = num => parts[num < 0 ? 'negatives' : 'positives'].push(Math.abs(num)); + let range = []; + let index = 0; + while (descending ? a >= b : a <= b) { + if (options.toRegex === true && step > 1) { + push(a); + } + else { + range.push(pad(format(a, index), maxLen, toNumber)); + } + a = descending ? a - step : a + step; + index++; + } + if (options.toRegex === true) { + return step > 1 + ? toSequence(parts, options) + : toRegex(range, null, Object.assign({ wrap: false }, options)); + } + return range; + }; + const fillLetters = (start, end, step = 1, options = {}) => { + if ((!isNumber$1(start) && start.length > 1) || (!isNumber$1(end) && end.length > 1)) { + return invalidRange(start, end, options); + } + let format = options.transform || (val => String.fromCharCode(val)); + let a = `${start}`.charCodeAt(0); + let b = `${end}`.charCodeAt(0); + let descending = a > b; + let min = Math.min(a, b); + let max = Math.max(a, b); + if (options.toRegex && step === 1) { + return toRange(min, max, false, options); + } + let range = []; + let index = 0; + while (descending ? a >= b : a <= b) { + range.push(format(a, index)); + a = descending ? a - step : a + step; + index++; + } + if (options.toRegex === true) { + return toRegex(range, null, { wrap: false, options }); + } + return range; + }; + const fill = (start, end, step, options = {}) => { + if (end == null && isValidValue(start)) { + return [start]; + } + if (!isValidValue(start) || !isValidValue(end)) { + return invalidRange(start, end, options); + } + if (typeof step === 'function') { + return fill(start, end, 1, { transform: step }); + } + if (isObject(step)) { + return fill(start, end, 0, step); + } + let opts = Object.assign({}, options); + if (opts.capture === true) + opts.wrap = true; + step = step || opts.step || 1; + if (!isNumber$1(step)) { + if (step != null && !isObject(step)) + return invalidStep(step, opts); + return fill(start, end, 1, step); + } + if (isNumber$1(start) && isNumber$1(end)) { + return fillNumbers(start, end, step, opts); + } + return fillLetters(start, end, Math.max(Math.abs(step), 1), opts); + }; + var fillRange = fill; + + const compile = (ast, options = {}) => { + let walk = (node, parent = {}) => { + let invalidBlock = utils.isInvalidBrace(parent); + let invalidNode = node.invalid === true && options.escapeInvalid === true; + let invalid = invalidBlock === true || invalidNode === true; + let prefix = options.escapeInvalid === true ? '\\' : ''; + let output = ''; + if (node.isOpen === true) { + return prefix + node.value; + } + if (node.isClose === true) { + return prefix + node.value; + } + if (node.type === 'open') { + return invalid ? (prefix + node.value) : '('; + } + if (node.type === 'close') { + return invalid ? (prefix + node.value) : ')'; + } + if (node.type === 'comma') { + return node.prev.type === 'comma' ? '' : (invalid ? node.value : '|'); + } + if (node.value) { + return node.value; + } + if (node.nodes && node.ranges > 0) { + let args = utils.reduce(node.nodes); + let range = fillRange(...args, Object.assign({}, options, { wrap: false, toRegex: true })); + if (range.length !== 0) { + return args.length > 1 && range.length > 1 ? `(${range})` : range; + } + } + if (node.nodes) { + for (let child of node.nodes) { + output += walk(child, node); + } + } + return output; + }; + return walk(ast); + }; + var compile_1 = compile; + + const append = (queue = '', stash = '', enclose = false) => { + let result = []; + queue = [].concat(queue); + stash = [].concat(stash); + if (!stash.length) + return queue; + if (!queue.length) { + return enclose ? utils.flatten(stash).map(ele => `{${ele}}`) : stash; + } + for (let item of queue) { + if (Array.isArray(item)) { + for (let value of item) { + result.push(append(value, stash, enclose)); + } + } + else { + for (let ele of stash) { + if (enclose === true && typeof ele === 'string') + ele = `{${ele}}`; + result.push(Array.isArray(ele) ? append(item, ele, enclose) : (item + ele)); + } + } + } + return utils.flatten(result); + }; + const expand = (ast, options = {}) => { + let rangeLimit = options.rangeLimit === void 0 ? 1000 : options.rangeLimit; + let walk = (node, parent = {}) => { + node.queue = []; + let p = parent; + let q = parent.queue; + while (p.type !== 'brace' && p.type !== 'root' && p.parent) { + p = p.parent; + q = p.queue; + } + if (node.invalid || node.dollar) { + q.push(append(q.pop(), stringify(node, options))); + return; + } + if (node.type === 'brace' && node.invalid !== true && node.nodes.length === 2) { + q.push(append(q.pop(), ['{}'])); + return; + } + if (node.nodes && node.ranges > 0) { + let args = utils.reduce(node.nodes); + if (utils.exceedsLimit(...args, options.step, rangeLimit)) { + throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.'); + } + let range = fillRange(...args, options); + if (range.length === 0) { + range = stringify(node, options); + } + q.push(append(q.pop(), range)); + node.nodes = []; + return; + } + let enclose = utils.encloseBrace(node); + let queue = node.queue; + let block = node; + while (block.type !== 'brace' && block.type !== 'root' && block.parent) { + block = block.parent; + queue = block.queue; + } + for (let i = 0; i < node.nodes.length; i++) { + let child = node.nodes[i]; + if (child.type === 'comma' && node.type === 'brace') { + if (i === 1) + queue.push(''); + queue.push(''); + continue; + } + if (child.type === 'close') { + q.push(append(q.pop(), queue, enclose)); + continue; + } + if (child.value && child.type !== 'open') { + queue.push(append(queue.pop(), child.value)); + continue; + } + if (child.nodes) { + walk(child, node); + } + } + return queue; + }; + return utils.flatten(walk(ast)); + }; + var expand_1 = expand; + + var constants = { + MAX_LENGTH: 1024 * 64, + // Digits + CHAR_0: '0', + CHAR_9: '9', + // Alphabet chars. + CHAR_UPPERCASE_A: 'A', + CHAR_LOWERCASE_A: 'a', + CHAR_UPPERCASE_Z: 'Z', + CHAR_LOWERCASE_Z: 'z', + CHAR_LEFT_PARENTHESES: '(', + CHAR_RIGHT_PARENTHESES: ')', + CHAR_ASTERISK: '*', + // Non-alphabetic chars. + CHAR_AMPERSAND: '&', + CHAR_AT: '@', + CHAR_BACKSLASH: '\\', + CHAR_BACKTICK: '`', + CHAR_CARRIAGE_RETURN: '\r', + CHAR_CIRCUMFLEX_ACCENT: '^', + CHAR_COLON: ':', + CHAR_COMMA: ',', + CHAR_DOLLAR: '$', + CHAR_DOT: '.', + CHAR_DOUBLE_QUOTE: '"', + CHAR_EQUAL: '=', + CHAR_EXCLAMATION_MARK: '!', + CHAR_FORM_FEED: '\f', + CHAR_FORWARD_SLASH: '/', + CHAR_HASH: '#', + CHAR_HYPHEN_MINUS: '-', + CHAR_LEFT_ANGLE_BRACKET: '<', + CHAR_LEFT_CURLY_BRACE: '{', + CHAR_LEFT_SQUARE_BRACKET: '[', + CHAR_LINE_FEED: '\n', + CHAR_NO_BREAK_SPACE: '\u00A0', + CHAR_PERCENT: '%', + CHAR_PLUS: '+', + CHAR_QUESTION_MARK: '?', + CHAR_RIGHT_ANGLE_BRACKET: '>', + CHAR_RIGHT_CURLY_BRACE: '}', + CHAR_RIGHT_SQUARE_BRACKET: ']', + CHAR_SEMICOLON: ';', + CHAR_SINGLE_QUOTE: '\'', + CHAR_SPACE: ' ', + CHAR_TAB: '\t', + CHAR_UNDERSCORE: '_', + CHAR_VERTICAL_LINE: '|', + CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\uFEFF' /* \uFEFF */ + }; + + /** + * Constants + */ + const { MAX_LENGTH, CHAR_BACKSLASH, /* \ */ CHAR_BACKTICK, /* ` */ CHAR_COMMA, /* , */ CHAR_DOT, /* . */ CHAR_LEFT_PARENTHESES, /* ( */ CHAR_RIGHT_PARENTHESES, /* ) */ CHAR_LEFT_CURLY_BRACE, /* { */ CHAR_RIGHT_CURLY_BRACE, /* } */ CHAR_LEFT_SQUARE_BRACKET, /* [ */ CHAR_RIGHT_SQUARE_BRACKET, /* ] */ CHAR_DOUBLE_QUOTE, /* " */ CHAR_SINGLE_QUOTE, /* ' */ CHAR_NO_BREAK_SPACE, CHAR_ZERO_WIDTH_NOBREAK_SPACE } = constants; + /** + * parse + */ + const parse = (input, options = {}) => { + if (typeof input !== 'string') { + throw new TypeError('Expected a string'); + } + let opts = options || {}; + let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH; + if (input.length > max) { + throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`); + } + let ast = { type: 'root', input, nodes: [] }; + let stack = [ast]; + let block = ast; + let prev = ast; + let brackets = 0; + let length = input.length; + let index = 0; + let depth = 0; + let value; + /** + * Helpers + */ + const advance = () => input[index++]; + const push = node => { + if (node.type === 'text' && prev.type === 'dot') { + prev.type = 'text'; + } + if (prev && prev.type === 'text' && node.type === 'text') { + prev.value += node.value; + return; + } + block.nodes.push(node); + node.parent = block; + node.prev = prev; + prev = node; + return node; + }; + push({ type: 'bos' }); + while (index < length) { + block = stack[stack.length - 1]; + value = advance(); + /** + * Invalid chars + */ + if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) { + continue; + } + /** + * Escaped chars + */ + if (value === CHAR_BACKSLASH) { + push({ type: 'text', value: (options.keepEscaping ? value : '') + advance() }); + continue; + } + /** + * Right square bracket (literal): ']' + */ + if (value === CHAR_RIGHT_SQUARE_BRACKET) { + push({ type: 'text', value: '\\' + value }); + continue; + } + /** + * Left square bracket: '[' + */ + if (value === CHAR_LEFT_SQUARE_BRACKET) { + brackets++; + let next; + while (index < length && (next = advance())) { + value += next; + if (next === CHAR_LEFT_SQUARE_BRACKET) { + brackets++; + continue; + } + if (next === CHAR_BACKSLASH) { + value += advance(); + continue; + } + if (next === CHAR_RIGHT_SQUARE_BRACKET) { + brackets--; + if (brackets === 0) { + break; + } + } + } + push({ type: 'text', value }); + continue; + } + /** + * Parentheses + */ + if (value === CHAR_LEFT_PARENTHESES) { + block = push({ type: 'paren', nodes: [] }); + stack.push(block); + push({ type: 'text', value }); + continue; + } + if (value === CHAR_RIGHT_PARENTHESES) { + if (block.type !== 'paren') { + push({ type: 'text', value }); + continue; + } + block = stack.pop(); + push({ type: 'text', value }); + block = stack[stack.length - 1]; + continue; + } + /** + * Quotes: '|"|` + */ + if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) { + let open = value; + let next; + if (options.keepQuotes !== true) { + value = ''; + } + while (index < length && (next = advance())) { + if (next === CHAR_BACKSLASH) { + value += next + advance(); + continue; + } + if (next === open) { + if (options.keepQuotes === true) + value += next; + break; + } + value += next; + } + push({ type: 'text', value }); + continue; + } + /** + * Left curly brace: '{' + */ + if (value === CHAR_LEFT_CURLY_BRACE) { + depth++; + let dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true; + let brace = { + type: 'brace', + open: true, + close: false, + dollar, + depth, + commas: 0, + ranges: 0, + nodes: [] + }; + block = push(brace); + stack.push(block); + push({ type: 'open', value }); + continue; + } + /** + * Right curly brace: '}' + */ + if (value === CHAR_RIGHT_CURLY_BRACE) { + if (block.type !== 'brace') { + push({ type: 'text', value }); + continue; + } + let type = 'close'; + block = stack.pop(); + block.close = true; + push({ type, value }); + depth--; + block = stack[stack.length - 1]; + continue; + } + /** + * Comma: ',' + */ + if (value === CHAR_COMMA && depth > 0) { + if (block.ranges > 0) { + block.ranges = 0; + let open = block.nodes.shift(); + block.nodes = [open, { type: 'text', value: stringify(block) }]; + } + push({ type: 'comma', value }); + block.commas++; + continue; + } + /** + * Dot: '.' + */ + if (value === CHAR_DOT && depth > 0 && block.commas === 0) { + let siblings = block.nodes; + if (depth === 0 || siblings.length === 0) { + push({ type: 'text', value }); + continue; + } + if (prev.type === 'dot') { + block.range = []; + prev.value += value; + prev.type = 'range'; + if (block.nodes.length !== 3 && block.nodes.length !== 5) { + block.invalid = true; + block.ranges = 0; + prev.type = 'text'; + continue; + } + block.ranges++; + block.args = []; + continue; + } + if (prev.type === 'range') { + siblings.pop(); + let before = siblings[siblings.length - 1]; + before.value += prev.value + value; + prev = before; + block.ranges--; + continue; + } + push({ type: 'dot', value }); + continue; + } + /** + * Text + */ + push({ type: 'text', value }); + } + // Mark imbalanced braces and brackets as invalid + do { + block = stack.pop(); + if (block.type !== 'root') { + block.nodes.forEach(node => { + if (!node.nodes) { + if (node.type === 'open') + node.isOpen = true; + if (node.type === 'close') + node.isClose = true; + if (!node.nodes) + node.type = 'text'; + node.invalid = true; + } + }); + // get the location of the block on parent.nodes (block's siblings) + let parent = stack[stack.length - 1]; + let index = parent.nodes.indexOf(block); + // replace the (invalid) block with it's nodes + parent.nodes.splice(index, 1, ...block.nodes); + } + } while (stack.length > 0); + push({ type: 'eos' }); + return ast; + }; + var parse_1 = parse; + + /** + * Expand the given pattern or create a regex-compatible string. + * + * ```js + * const braces = require('braces'); + * console.log(braces('{a,b,c}', { compile: true })); //=> ['(a|b|c)'] + * console.log(braces('{a,b,c}')); //=> ['a', 'b', 'c'] + * ``` + * @param {String} `str` + * @param {Object} `options` + * @return {String} + * @api public + */ + const braces = (input, options = {}) => { + let output = []; + if (Array.isArray(input)) { + for (let pattern of input) { + let result = braces.create(pattern, options); + if (Array.isArray(result)) { + output.push(...result); + } + else { + output.push(result); + } + } + } + else { + output = [].concat(braces.create(input, options)); + } + if (options && options.expand === true && options.nodupes === true) { + output = [...new Set(output)]; + } + return output; + }; + /** + * Parse the given `str` with the given `options`. + * + * ```js + * // braces.parse(pattern, [, options]); + * const ast = braces.parse('a/{b,c}/d'); + * console.log(ast); + * ``` + * @param {String} pattern Brace pattern to parse + * @param {Object} options + * @return {Object} Returns an AST + * @api public + */ + braces.parse = (input, options = {}) => parse_1(input, options); + /** + * Creates a braces string from an AST, or an AST node. + * + * ```js + * const braces = require('braces'); + * let ast = braces.parse('foo/{a,b}/bar'); + * console.log(stringify(ast.nodes[2])); //=> '{a,b}' + * ``` + * @param {String} `input` Brace pattern or AST. + * @param {Object} `options` + * @return {Array} Returns an array of expanded values. + * @api public + */ + braces.stringify = (input, options = {}) => { + if (typeof input === 'string') { + return stringify(braces.parse(input, options), options); + } + return stringify(input, options); + }; + /** + * Compiles a brace pattern into a regex-compatible, optimized string. + * This method is called by the main [braces](#braces) function by default. + * + * ```js + * const braces = require('braces'); + * console.log(braces.compile('a/{b,c}/d')); + * //=> ['a/(b|c)/d'] + * ``` + * @param {String} `input` Brace pattern or AST. + * @param {Object} `options` + * @return {Array} Returns an array of expanded values. + * @api public + */ + braces.compile = (input, options = {}) => { + if (typeof input === 'string') { + input = braces.parse(input, options); + } + return compile_1(input, options); + }; + /** + * Expands a brace pattern into an array. This method is called by the + * main [braces](#braces) function when `options.expand` is true. Before + * using this method it's recommended that you read the [performance notes](#performance)) + * and advantages of using [.compile](#compile) instead. + * + * ```js + * const braces = require('braces'); + * console.log(braces.expand('a/{b,c}/d')); + * //=> ['a/b/d', 'a/c/d']; + * ``` + * @param {String} `pattern` Brace pattern + * @param {Object} `options` + * @return {Array} Returns an array of expanded values. + * @api public + */ + braces.expand = (input, options = {}) => { + if (typeof input === 'string') { + input = braces.parse(input, options); + } + let result = expand_1(input, options); + // filter out empty strings if specified + if (options.noempty === true) { + result = result.filter(Boolean); + } + // filter out duplicates if specified + if (options.nodupes === true) { + result = [...new Set(result)]; + } + return result; + }; + /** + * Processes a brace pattern and returns either an expanded array + * (if `options.expand` is true), a highly optimized regex-compatible string. + * This method is called by the main [braces](#braces) function. + * + * ```js + * const braces = require('braces'); + * console.log(braces.create('user-{200..300}/project-{a,b,c}-{1..10}')) + * //=> 'user-(20[0-9]|2[1-9][0-9]|300)/project-(a|b|c)-([1-9]|10)' + * ``` + * @param {String} `pattern` Brace pattern + * @param {Object} `options` + * @return {Array} Returns an array of expanded values. + * @api public + */ + braces.create = (input, options = {}) => { + if (input === '' || input.length < 3) { + return [input]; + } + return options.expand !== true + ? braces.compile(input, options) + : braces.expand(input, options); + }; + /** + * Expose "braces" + */ + var braces_1 = braces; + + const WIN_SLASH = '\\\\/'; + const WIN_NO_SLASH = `[^${WIN_SLASH}]`; + /** + * Posix glob regex + */ + const DOT_LITERAL = '\\.'; + const PLUS_LITERAL = '\\+'; + const QMARK_LITERAL = '\\?'; + const SLASH_LITERAL = '\\/'; + const ONE_CHAR = '(?=.)'; + const QMARK = '[^/]'; + const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`; + const START_ANCHOR = `(?:^|${SLASH_LITERAL})`; + const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`; + const NO_DOT = `(?!${DOT_LITERAL})`; + const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`; + const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`; + const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`; + const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`; + const STAR = `${QMARK}*?`; + const POSIX_CHARS = { + DOT_LITERAL, + PLUS_LITERAL, + QMARK_LITERAL, + SLASH_LITERAL, + ONE_CHAR, + QMARK, + END_ANCHOR, + DOTS_SLASH, + NO_DOT, + NO_DOTS, + NO_DOT_SLASH, + NO_DOTS_SLASH, + QMARK_NO_DOT, + STAR, + START_ANCHOR + }; + /** + * Windows glob regex + */ + const WINDOWS_CHARS = Object.assign({}, POSIX_CHARS, { SLASH_LITERAL: `[${WIN_SLASH}]`, QMARK: WIN_NO_SLASH, STAR: `${WIN_NO_SLASH}*?`, DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`, NO_DOT: `(?!${DOT_LITERAL})`, NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`, NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`, NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`, QMARK_NO_DOT: `[^.${WIN_SLASH}]`, START_ANCHOR: `(?:^|[${WIN_SLASH}])`, END_ANCHOR: `(?:[${WIN_SLASH}]|$)` }); + /** + * POSIX Bracket Regex + */ + const POSIX_REGEX_SOURCE = { + alnum: 'a-zA-Z0-9', + alpha: 'a-zA-Z', + ascii: '\\x00-\\x7F', + blank: ' \\t', + cntrl: '\\x00-\\x1F\\x7F', + digit: '0-9', + graph: '\\x21-\\x7E', + lower: 'a-z', + print: '\\x20-\\x7E ', + punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~', + space: ' \\t\\r\\n\\v\\f', + upper: 'A-Z', + word: 'A-Za-z0-9_', + xdigit: 'A-Fa-f0-9' + }; + var constants$1 = { + MAX_LENGTH: 1024 * 64, + POSIX_REGEX_SOURCE, + // regular expressions + REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g, + REGEX_NON_SPECIAL_CHAR: /^[^@![\].,$*+?^{}()|\\/]+/, + REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/, + REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g, + REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g, + REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g, + // Replace globs with equivalent patterns to reduce parsing time. + REPLACEMENTS: { + '***': '*', + '**/**': '**', + '**/**/**': '**' + }, + // Digits + CHAR_0: 48, + CHAR_9: 57, + // Alphabet chars. + CHAR_UPPERCASE_A: 65, + CHAR_LOWERCASE_A: 97, + CHAR_UPPERCASE_Z: 90, + CHAR_LOWERCASE_Z: 122, + CHAR_LEFT_PARENTHESES: 40, + CHAR_RIGHT_PARENTHESES: 41, + CHAR_ASTERISK: 42, + // Non-alphabetic chars. + CHAR_AMPERSAND: 38, + CHAR_AT: 64, + CHAR_BACKWARD_SLASH: 92, + CHAR_CARRIAGE_RETURN: 13, + CHAR_CIRCUMFLEX_ACCENT: 94, + CHAR_COLON: 58, + CHAR_COMMA: 44, + CHAR_DOT: 46, + CHAR_DOUBLE_QUOTE: 34, + CHAR_EQUAL: 61, + CHAR_EXCLAMATION_MARK: 33, + CHAR_FORM_FEED: 12, + CHAR_FORWARD_SLASH: 47, + CHAR_GRAVE_ACCENT: 96, + CHAR_HASH: 35, + CHAR_HYPHEN_MINUS: 45, + CHAR_LEFT_ANGLE_BRACKET: 60, + CHAR_LEFT_CURLY_BRACE: 123, + CHAR_LEFT_SQUARE_BRACKET: 91, + CHAR_LINE_FEED: 10, + CHAR_NO_BREAK_SPACE: 160, + CHAR_PERCENT: 37, + CHAR_PLUS: 43, + CHAR_QUESTION_MARK: 63, + CHAR_RIGHT_ANGLE_BRACKET: 62, + CHAR_RIGHT_CURLY_BRACE: 125, + CHAR_RIGHT_SQUARE_BRACKET: 93, + CHAR_SEMICOLON: 59, + CHAR_SINGLE_QUOTE: 39, + CHAR_SPACE: 32, + CHAR_TAB: 9, + CHAR_UNDERSCORE: 95, + CHAR_VERTICAL_LINE: 124, + CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, + SEP: path__default.sep, + /** + * Create EXTGLOB_CHARS + */ + extglobChars(chars) { + return { + '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` }, + '?': { type: 'qmark', open: '(?:', close: ')?' }, + '+': { type: 'plus', open: '(?:', close: ')+' }, + '*': { type: 'star', open: '(?:', close: ')*' }, + '@': { type: 'at', open: '(?:', close: ')' } + }; + }, + /** + * Create GLOB_CHARS + */ + globChars(win32) { + return win32 === true ? WINDOWS_CHARS : POSIX_CHARS; + } + }; + + var utils$1 = createCommonjsModule(function (module, exports) { + const win32 = process.platform === 'win32'; + const { REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL, REGEX_REMOVE_BACKSLASH } = constants$1; + exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val); + exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str); + exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str); + exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1'); + exports.toPosixSlashes = str => str.replace(/\\/g, '/'); + exports.removeBackslashes = str => { + return str.replace(REGEX_REMOVE_BACKSLASH, match => { + return match === '\\' ? '' : match; + }); + }; + exports.supportsLookbehinds = () => { + let segs = process.version.slice(1).split('.'); + if (segs.length === 3 && +segs[0] >= 9 || (+segs[0] === 8 && +segs[1] >= 10)) { + return true; + } + return false; + }; + exports.isWindows = options => { + if (options && typeof options.windows === 'boolean') { + return options.windows; + } + return win32 === true || path__default.sep === '\\'; + }; + exports.escapeLast = (input, char, lastIdx) => { + let idx = input.lastIndexOf(char, lastIdx); + if (idx === -1) + return input; + if (input[idx - 1] === '\\') + return exports.escapeLast(input, char, idx - 1); + return input.slice(0, idx) + '\\' + input.slice(idx); + }; + }); + var utils_1$1 = utils$1.isObject; + var utils_2$1 = utils$1.hasRegexChars; + var utils_3$1 = utils$1.isRegexChar; + var utils_4$1 = utils$1.escapeRegex; + var utils_5$1 = utils$1.toPosixSlashes; + var utils_6$1 = utils$1.removeBackslashes; + var utils_7$1 = utils$1.supportsLookbehinds; + var utils_8$1 = utils$1.isWindows; + var utils_9$1 = utils$1.escapeLast; + + const { CHAR_ASTERISK, /* * */ CHAR_AT, /* @ */ CHAR_BACKWARD_SLASH, /* \ */ CHAR_COMMA: CHAR_COMMA$1, /* , */ CHAR_DOT: CHAR_DOT$1, /* . */ CHAR_EXCLAMATION_MARK, /* ! */ CHAR_FORWARD_SLASH, /* / */ CHAR_LEFT_CURLY_BRACE: CHAR_LEFT_CURLY_BRACE$1, /* { */ CHAR_LEFT_PARENTHESES: CHAR_LEFT_PARENTHESES$1, /* ( */ CHAR_LEFT_SQUARE_BRACKET: CHAR_LEFT_SQUARE_BRACKET$1, /* [ */ CHAR_PLUS, /* + */ CHAR_QUESTION_MARK, /* ? */ CHAR_RIGHT_CURLY_BRACE: CHAR_RIGHT_CURLY_BRACE$1, /* } */ CHAR_RIGHT_PARENTHESES: CHAR_RIGHT_PARENTHESES$1, /* ) */ CHAR_RIGHT_SQUARE_BRACKET: CHAR_RIGHT_SQUARE_BRACKET$1 /* ] */ } = constants$1; + const isPathSeparator = code => { + return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH; + }; + /** + * Quickly scans a glob pattern and returns an object with a handful of + * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists), + * `glob` (the actual pattern), and `negated` (true if the path starts with `!`). + * + * ```js + * const pm = require('picomatch'); + * console.log(pm.scan('foo/bar/*.js')); + * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' } + * ``` + * @param {String} `str` + * @param {Object} `options` + * @return {Object} Returns an object with tokens and regex source string. + * @api public + */ + var scan = (input, options) => { + let opts = options || {}; + let length = input.length - 1; + let index = -1; + let start = 0; + let lastIndex = 0; + let isGlob = false; + let backslashes = false; + let negated = false; + let braces = 0; + let prev; + let code; + let braceEscaped = false; + let eos = () => index >= length; + let advance = () => { + prev = code; + return input.charCodeAt(++index); + }; + while (index < length) { + code = advance(); + let next; + if (code === CHAR_BACKWARD_SLASH) { + backslashes = true; + next = advance(); + if (next === CHAR_LEFT_CURLY_BRACE$1) { + braceEscaped = true; + } + continue; + } + if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE$1) { + braces++; + while (!eos() && (next = advance())) { + if (next === CHAR_BACKWARD_SLASH) { + backslashes = true; + next = advance(); + continue; + } + if (next === CHAR_LEFT_CURLY_BRACE$1) { + braces++; + continue; + } + if (!braceEscaped && next === CHAR_DOT$1 && (next = advance()) === CHAR_DOT$1) { + isGlob = true; + break; + } + if (!braceEscaped && next === CHAR_COMMA$1) { + isGlob = true; + break; + } + if (next === CHAR_RIGHT_CURLY_BRACE$1) { + braces--; + if (braces === 0) { + braceEscaped = false; + break; + } + } + } + } + if (code === CHAR_FORWARD_SLASH) { + if (prev === CHAR_DOT$1 && index === (start + 1)) { + start += 2; + continue; + } + lastIndex = index + 1; + continue; + } + if (code === CHAR_ASTERISK) { + isGlob = true; + break; + } + if (code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK) { + isGlob = true; + break; + } + if (code === CHAR_LEFT_SQUARE_BRACKET$1) { + while (!eos() && (next = advance())) { + if (next === CHAR_BACKWARD_SLASH) { + backslashes = true; + next = advance(); + continue; + } + if (next === CHAR_RIGHT_SQUARE_BRACKET$1) { + isGlob = true; + break; + } + } + } + let isExtglobChar = code === CHAR_PLUS + || code === CHAR_AT + || code === CHAR_EXCLAMATION_MARK; + if (isExtglobChar && input.charCodeAt(index + 1) === CHAR_LEFT_PARENTHESES$1) { + isGlob = true; + break; + } + if (code === CHAR_EXCLAMATION_MARK && index === start) { + negated = true; + start++; + continue; + } + if (code === CHAR_LEFT_PARENTHESES$1) { + while (!eos() && (next = advance())) { + if (next === CHAR_BACKWARD_SLASH) { + backslashes = true; + next = advance(); + continue; + } + if (next === CHAR_RIGHT_PARENTHESES$1) { + isGlob = true; + break; + } + } + } + if (isGlob) { + break; + } + } + let prefix = ''; + let orig = input; + let base = input; + let glob = ''; + if (start > 0) { + prefix = input.slice(0, start); + input = input.slice(start); + lastIndex -= start; + } + if (base && isGlob === true && lastIndex > 0) { + base = input.slice(0, lastIndex); + glob = input.slice(lastIndex); + } + else if (isGlob === true) { + base = ''; + glob = input; + } + else { + base = input; + } + if (base && base !== '' && base !== '/' && base !== input) { + if (isPathSeparator(base.charCodeAt(base.length - 1))) { + base = base.slice(0, -1); + } + } + if (opts.unescape === true) { + if (glob) + glob = utils$1.removeBackslashes(glob); + if (base && backslashes === true) { + base = utils$1.removeBackslashes(base); + } + } + return { prefix, input: orig, base, glob, negated, isGlob }; + }; + + /** + * Constants + */ + const { MAX_LENGTH: MAX_LENGTH$1, POSIX_REGEX_SOURCE: POSIX_REGEX_SOURCE$1, REGEX_NON_SPECIAL_CHAR, REGEX_SPECIAL_CHARS_BACKREF, REPLACEMENTS } = constants$1; + /** + * Helpers + */ + const expandRange = (args, options) => { + if (typeof options.expandRange === 'function') { + return options.expandRange(...args, options); + } + args.sort(); + let value = `[${args.join('-')}]`; + return value; + }; + const negate = state => { + let count = 1; + while (state.peek() === '!' && (state.peek(2) !== '(' || state.peek(3) === '?')) { + state.advance(); + state.start++; + count++; + } + if (count % 2 === 0) { + return false; + } + state.negated = true; + state.start++; + return true; + }; + /** + * Create the message for a syntax error + */ + const syntaxError = (type, char) => { + return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`; + }; + /** + * Parse the given input string. + * @param {String} input + * @param {Object} options + * @return {Object} + */ + const parse$1 = (input, options) => { + if (typeof input !== 'string') { + throw new TypeError('Expected a string'); + } + input = REPLACEMENTS[input] || input; + let opts = Object.assign({}, options); + let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$1, opts.maxLength) : MAX_LENGTH$1; + let len = input.length; + if (len > max) { + throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`); + } + let bos = { type: 'bos', value: '', output: opts.prepend || '' }; + let tokens = [bos]; + let capture = opts.capture ? '' : '?:'; + let win32 = utils$1.isWindows(options); + // create constants based on platform, for windows or posix + const PLATFORM_CHARS = constants$1.globChars(win32); + const EXTGLOB_CHARS = constants$1.extglobChars(PLATFORM_CHARS); + const { DOT_LITERAL, PLUS_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOT_SLASH, NO_DOTS_SLASH, QMARK, QMARK_NO_DOT, STAR, START_ANCHOR } = PLATFORM_CHARS; + const globstar = (opts) => { + return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`; + }; + let nodot = opts.dot ? '' : NO_DOT; + let star = opts.bash === true ? globstar(opts) : STAR; + let qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT; + if (opts.capture) { + star = `(${star})`; + } + // minimatch options support + if (typeof opts.noext === 'boolean') { + opts.noextglob = opts.noext; + } + let state = { + index: -1, + start: 0, + consumed: '', + output: '', + backtrack: false, + brackets: 0, + braces: 0, + parens: 0, + quotes: 0, + tokens + }; + let extglobs = []; + let stack = []; + let prev = bos; + let value; + /** + * Tokenizing helpers + */ + const eos = () => state.index === len - 1; + const peek = state.peek = (n = 1) => input[state.index + n]; + const advance = state.advance = () => input[++state.index]; + const append = token => { + state.output += token.output != null ? token.output : token.value; + state.consumed += token.value || ''; + }; + const increment = type => { + state[type]++; + stack.push(type); + }; + const decrement = type => { + state[type]--; + stack.pop(); + }; + /** + * Push tokens onto the tokens array. This helper speeds up + * tokenizing by 1) helping us avoid backtracking as much as possible, + * and 2) helping us avoid creating extra tokens when consecutive + * characters are plain text. This improves performance and simplifies + * lookbehinds. + */ + const push = tok => { + if (prev.type === 'globstar') { + let isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace'); + let isExtglob = extglobs.length && (tok.type === 'pipe' || tok.type === 'paren'); + if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) { + state.output = state.output.slice(0, -prev.output.length); + prev.type = 'star'; + prev.value = '*'; + prev.output = star; + state.output += prev.output; + } + } + if (extglobs.length && tok.type !== 'paren' && !EXTGLOB_CHARS[tok.value]) { + extglobs[extglobs.length - 1].inner += tok.value; + } + if (tok.value || tok.output) + append(tok); + if (prev && prev.type === 'text' && tok.type === 'text') { + prev.value += tok.value; + return; + } + tok.prev = prev; + tokens.push(tok); + prev = tok; + }; + const extglobOpen = (type, value) => { + let token = Object.assign({}, EXTGLOB_CHARS[value], { conditions: 1, inner: '' }); + token.prev = prev; + token.parens = state.parens; + token.output = state.output; + let output = (opts.capture ? '(' : '') + token.open; + push({ type, value, output: state.output ? '' : ONE_CHAR }); + push({ type: 'paren', extglob: true, value: advance(), output }); + increment('parens'); + extglobs.push(token); + }; + const extglobClose = token => { + let output = token.close + (opts.capture ? ')' : ''); + if (token.type === 'negate') { + let extglobStar = star; + if (token.inner && token.inner.length > 1 && token.inner.includes('/')) { + extglobStar = globstar(opts); + } + if (extglobStar !== star || eos() || /^\)+$/.test(input.slice(state.index + 1))) { + output = token.close = ')$))' + extglobStar; + } + if (token.prev.type === 'bos' && eos()) { + state.negatedExtglob = true; + } + } + push({ type: 'paren', extglob: true, value, output }); + decrement('parens'); + }; + if (opts.fastpaths !== false && !/(^[*!]|[/{[()\]}"])/.test(input)) { + let backslashes = false; + let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => { + if (first === '\\') { + backslashes = true; + return m; + } + if (first === '?') { + if (esc) { + return esc + first + (rest ? QMARK.repeat(rest.length) : ''); + } + if (index === 0) { + return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : ''); + } + return QMARK.repeat(chars.length); + } + if (first === '.') { + return DOT_LITERAL.repeat(chars.length); + } + if (first === '*') { + if (esc) { + return esc + first + (rest ? star : ''); + } + return star; + } + return esc ? m : '\\' + m; + }); + if (backslashes === true) { + if (opts.unescape === true) { + output = output.replace(/\\/g, ''); + } + else { + output = output.replace(/\\+/g, m => { + return m.length % 2 === 0 ? '\\\\' : (m ? '\\' : ''); + }); + } + } + state.output = output; + return state; + } + /** + * Tokenize input until we reach end-of-string + */ + while (!eos()) { + value = advance(); + if (value === '\u0000') { + continue; + } + /** + * Escaped characters + */ + if (value === '\\') { + let next = peek(); + if (next === '/' && opts.bash !== true) { + continue; + } + if (next === '.' || next === ';') { + continue; + } + if (!next) { + value += '\\'; + push({ type: 'text', value }); + continue; + } + // collapse slashes to reduce potential for exploits + let match = /^\\+/.exec(input.slice(state.index + 1)); + let slashes = 0; + if (match && match[0].length > 2) { + slashes = match[0].length; + state.index += slashes; + if (slashes % 2 !== 0) { + value += '\\'; + } + } + if (opts.unescape === true) { + value = advance() || ''; + } + else { + value += advance() || ''; + } + if (state.brackets === 0) { + push({ type: 'text', value }); + continue; + } + } + /** + * If we're inside a regex character class, continue + * until we reach the closing bracket. + */ + if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) { + if (opts.posix !== false && value === ':') { + let inner = prev.value.slice(1); + if (inner.includes('[')) { + prev.posix = true; + if (inner.includes(':')) { + let idx = prev.value.lastIndexOf('['); + let pre = prev.value.slice(0, idx); + let rest = prev.value.slice(idx + 2); + let posix = POSIX_REGEX_SOURCE$1[rest]; + if (posix) { + prev.value = pre + posix; + state.backtrack = true; + advance(); + if (!bos.output && tokens.indexOf(prev) === 1) { + bos.output = ONE_CHAR; + } + continue; + } + } + } + } + if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) { + value = '\\' + value; + } + if (value === ']' && (prev.value === '[' || prev.value === '[^')) { + value = '\\' + value; + } + if (opts.posix === true && value === '!' && prev.value === '[') { + value = '^'; + } + prev.value += value; + append({ value }); + continue; + } + /** + * If we're inside a quoted string, continue + * until we reach the closing double quote. + */ + if (state.quotes === 1 && value !== '"') { + value = utils$1.escapeRegex(value); + prev.value += value; + append({ value }); + continue; + } + /** + * Double quotes + */ + if (value === '"') { + state.quotes = state.quotes === 1 ? 0 : 1; + if (opts.keepQuotes === true) { + push({ type: 'text', value }); + } + continue; + } + /** + * Parentheses + */ + if (value === '(') { + push({ type: 'paren', value }); + increment('parens'); + continue; + } + if (value === ')') { + if (state.parens === 0 && opts.strictBrackets === true) { + throw new SyntaxError(syntaxError('opening', '(')); + } + let extglob = extglobs[extglobs.length - 1]; + if (extglob && state.parens === extglob.parens + 1) { + extglobClose(extglobs.pop()); + continue; + } + push({ type: 'paren', value, output: state.parens ? ')' : '\\)' }); + decrement('parens'); + continue; + } + /** + * Brackets + */ + if (value === '[') { + if (opts.nobracket === true || !input.slice(state.index + 1).includes(']')) { + if (opts.nobracket !== true && opts.strictBrackets === true) { + throw new SyntaxError(syntaxError('closing', ']')); + } + value = '\\' + value; + } + else { + increment('brackets'); + } + push({ type: 'bracket', value }); + continue; + } + if (value === ']') { + if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) { + push({ type: 'text', value, output: '\\' + value }); + continue; + } + if (state.brackets === 0) { + if (opts.strictBrackets === true) { + throw new SyntaxError(syntaxError('opening', '[')); + } + push({ type: 'text', value, output: '\\' + value }); + continue; + } + decrement('brackets'); + let prevValue = prev.value.slice(1); + if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) { + value = '/' + value; + } + prev.value += value; + append({ value }); + // when literal brackets are explicitly disabled + // assume we should match with a regex character class + if (opts.literalBrackets === false || utils$1.hasRegexChars(prevValue)) { + continue; + } + let escaped = utils$1.escapeRegex(prev.value); + state.output = state.output.slice(0, -prev.value.length); + // when literal brackets are explicitly enabled + // assume we should escape the brackets to match literal characters + if (opts.literalBrackets === true) { + state.output += escaped; + prev.value = escaped; + continue; + } + // when the user specifies nothing, try to match both + prev.value = `(${capture}${escaped}|${prev.value})`; + state.output += prev.value; + continue; + } + /** + * Braces + */ + if (value === '{' && opts.nobrace !== true) { + push({ type: 'brace', value, output: '(' }); + increment('braces'); + continue; + } + if (value === '}') { + if (opts.nobrace === true || state.braces === 0) { + push({ type: 'text', value, output: '\\' + value }); + continue; + } + let output = ')'; + if (state.dots === true) { + let arr = tokens.slice(); + let range = []; + for (let i = arr.length - 1; i >= 0; i--) { + tokens.pop(); + if (arr[i].type === 'brace') { + break; + } + if (arr[i].type !== 'dots') { + range.unshift(arr[i].value); + } + } + output = expandRange(range, opts); + state.backtrack = true; + } + push({ type: 'brace', value, output }); + decrement('braces'); + continue; + } + /** + * Pipes + */ + if (value === '|') { + if (extglobs.length > 0) { + extglobs[extglobs.length - 1].conditions++; + } + push({ type: 'text', value }); + continue; + } + /** + * Commas + */ + if (value === ',') { + let output = value; + if (state.braces > 0 && stack[stack.length - 1] === 'braces') { + output = '|'; + } + push({ type: 'comma', value, output }); + continue; + } + /** + * Slashes + */ + if (value === '/') { + // if the beginning of the glob is "./", advance the start + // to the current index, and don't add the "./" characters + // to the state. This greatly simplifies lookbehinds when + // checking for BOS characters like "!" and "." (not "./") + if (prev.type === 'dot' && state.index === 1) { + state.start = state.index + 1; + state.consumed = ''; + state.output = ''; + tokens.pop(); + prev = bos; // reset "prev" to the first token + continue; + } + push({ type: 'slash', value, output: SLASH_LITERAL }); + continue; + } + /** + * Dots + */ + if (value === '.') { + if (state.braces > 0 && prev.type === 'dot') { + if (prev.value === '.') + prev.output = DOT_LITERAL; + prev.type = 'dots'; + prev.output += value; + prev.value += value; + state.dots = true; + continue; + } + push({ type: 'dot', value, output: DOT_LITERAL }); + continue; + } + /** + * Question marks + */ + if (value === '?') { + if (prev && prev.type === 'paren') { + let next = peek(); + let output = value; + if (next === '<' && !utils$1.supportsLookbehinds()) { + throw new Error('Node.js v10 or higher is required for regex lookbehinds'); + } + if (prev.value === '(' && !/[!=<:]/.test(next) || (next === '<' && !/[!=]/.test(peek(2)))) { + output = '\\' + value; + } + push({ type: 'text', value, output }); + continue; + } + if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') { + extglobOpen('qmark', value); + continue; + } + if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) { + push({ type: 'qmark', value, output: QMARK_NO_DOT }); + continue; + } + push({ type: 'qmark', value, output: QMARK }); + continue; + } + /** + * Exclamation + */ + if (value === '!') { + if (opts.noextglob !== true && peek() === '(') { + if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) { + extglobOpen('negate', value); + continue; + } + } + if (opts.nonegate !== true && state.index === 0) { + negate(state); + continue; + } + } + /** + * Plus + */ + if (value === '+') { + if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') { + extglobOpen('plus', value); + continue; + } + if (prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) { + let output = prev.extglob === true ? '\\' + value : value; + push({ type: 'plus', value, output }); + continue; + } + // use regex behavior inside parens + if (state.parens > 0 && opts.regex !== false) { + push({ type: 'plus', value }); + continue; + } + push({ type: 'plus', value: PLUS_LITERAL }); + continue; + } + /** + * Plain text + */ + if (value === '@') { + if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') { + push({ type: 'at', value, output: '' }); + continue; + } + push({ type: 'text', value }); + continue; + } + /** + * Plain text + */ + if (value !== '*') { + if (value === '$' || value === '^') { + value = '\\' + value; + } + let match = REGEX_NON_SPECIAL_CHAR.exec(input.slice(state.index + 1)); + if (match) { + value += match[0]; + state.index += match[0].length; + } + push({ type: 'text', value }); + continue; + } + /** + * Stars + */ + if (prev && (prev.type === 'globstar' || prev.star === true)) { + prev.type = 'star'; + prev.star = true; + prev.value += value; + prev.output = star; + state.backtrack = true; + state.consumed += value; + continue; + } + if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') { + extglobOpen('star', value); + continue; + } + if (prev.type === 'star') { + if (opts.noglobstar === true) { + state.consumed += value; + continue; + } + let prior = prev.prev; + let before = prior.prev; + let isStart = prior.type === 'slash' || prior.type === 'bos'; + let afterStar = before && (before.type === 'star' || before.type === 'globstar'); + if (opts.bash === true && (!isStart || (!eos() && peek() !== '/'))) { + push({ type: 'star', value, output: '' }); + continue; + } + let isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace'); + let isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren'); + if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) { + push({ type: 'star', value, output: '' }); + continue; + } + // strip consecutive `/**/` + while (input.slice(state.index + 1, state.index + 4) === '/**') { + let after = input[state.index + 4]; + if (after && after !== '/') { + break; + } + state.consumed += '/**'; + state.index += 3; + } + if (prior.type === 'bos' && eos()) { + prev.type = 'globstar'; + prev.value += value; + prev.output = globstar(opts); + state.output = prev.output; + state.consumed += value; + continue; + } + if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) { + state.output = state.output.slice(0, -(prior.output + prev.output).length); + prior.output = '(?:' + prior.output; + prev.type = 'globstar'; + prev.output = globstar(opts) + '|$)'; + prev.value += value; + state.output += prior.output + prev.output; + state.consumed += value; + continue; + } + let next = peek(); + if (prior.type === 'slash' && prior.prev.type !== 'bos' && next === '/') { + let end = peek(2) !== void 0 ? '|$' : ''; + state.output = state.output.slice(0, -(prior.output + prev.output).length); + prior.output = '(?:' + prior.output; + prev.type = 'globstar'; + prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`; + prev.value += value; + state.output += prior.output + prev.output; + state.consumed += value + advance(); + push({ type: 'slash', value, output: '' }); + continue; + } + if (prior.type === 'bos' && next === '/') { + prev.type = 'globstar'; + prev.value += value; + prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`; + state.output = prev.output; + state.consumed += value + advance(); + push({ type: 'slash', value, output: '' }); + continue; + } + // remove single star from output + state.output = state.output.slice(0, -prev.output.length); + // reset previous token to globstar + prev.type = 'globstar'; + prev.output = globstar(opts); + prev.value += value; + // reset output with globstar + state.output += prev.output; + state.consumed += value; + continue; + } + let token = { type: 'star', value, output: star }; + if (opts.bash === true) { + token.output = '.*?'; + if (prev.type === 'bos' || prev.type === 'slash') { + token.output = nodot + token.output; + } + push(token); + continue; + } + if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) { + token.output = value; + push(token); + continue; + } + if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') { + if (prev.type === 'dot') { + state.output += NO_DOT_SLASH; + prev.output += NO_DOT_SLASH; + } + else if (opts.dot === true) { + state.output += NO_DOTS_SLASH; + prev.output += NO_DOTS_SLASH; + } + else { + state.output += nodot; + prev.output += nodot; + } + if (peek() !== '*') { + state.output += ONE_CHAR; + prev.output += ONE_CHAR; + } + } + push(token); + } + while (state.brackets > 0) { + if (opts.strictBrackets === true) + throw new SyntaxError(syntaxError('closing', ']')); + state.output = utils$1.escapeLast(state.output, '['); + decrement('brackets'); + } + while (state.parens > 0) { + if (opts.strictBrackets === true) + throw new SyntaxError(syntaxError('closing', ')')); + state.output = utils$1.escapeLast(state.output, '('); + decrement('parens'); + } + while (state.braces > 0) { + if (opts.strictBrackets === true) + throw new SyntaxError(syntaxError('closing', '}')); + state.output = utils$1.escapeLast(state.output, '{'); + decrement('braces'); + } + if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) { + push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` }); + } + // rebuild the output if we had to backtrack at any point + if (state.backtrack === true) { + state.output = ''; + for (let token of state.tokens) { + state.output += token.output != null ? token.output : token.value; + if (token.suffix) { + state.output += token.suffix; + } + } + } + return state; + }; + /** + * Fast paths for creating regular expressions for common glob patterns. + * This can significantly speed up processing and has very little downside + * impact when none of the fast paths match. + */ + parse$1.fastpaths = (input, options) => { + let opts = Object.assign({}, options); + let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$1, opts.maxLength) : MAX_LENGTH$1; + let len = input.length; + if (len > max) { + throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`); + } + input = REPLACEMENTS[input] || input; + let win32 = utils$1.isWindows(options); + // create constants based on platform, for windows or posix + const { DOT_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOTS, NO_DOTS_SLASH, STAR, START_ANCHOR } = constants$1.globChars(win32); + let capture = opts.capture ? '' : '?:'; + let star = opts.bash === true ? '.*?' : STAR; + let nodot = opts.dot ? NO_DOTS : NO_DOT; + let slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT; + if (opts.capture) { + star = `(${star})`; + } + const globstar = (opts) => { + return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`; + }; + const create = str => { + switch (str) { + case '*': + return `${nodot}${ONE_CHAR}${star}`; + case '.*': + return `${DOT_LITERAL}${ONE_CHAR}${star}`; + case '*.*': + return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`; + case '*/*': + return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`; + case '**': + return nodot + globstar(opts); + case '**/*': + return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`; + case '**/*.*': + return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`; + case '**/.*': + return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`; + default: { + let match = /^(.*?)\.(\w+)$/.exec(str); + if (!match) + return; + let source = create(match[1]); + if (!source) + return; + return source + DOT_LITERAL + match[2]; + } + } + }; + let output = create(input); + if (output && opts.strictSlashes !== true) { + output += `${SLASH_LITERAL}?`; + } + return output; + }; + var parse_1$1 = parse$1; + + /** + * Creates a matcher function from one or more glob patterns. The + * returned function takes a string to match as its first argument, + * and returns true if the string is a match. The returned matcher + * function also takes a boolean as the second argument that, when true, + * returns an object with additional information. + * + * ```js + * const picomatch = require('picomatch'); + * // picomatch(glob[, options]); + * + * const isMatch = picomatch('*.!(*a)'); + * console.log(isMatch('a.a')); //=> false + * console.log(isMatch('a.b')); //=> true + * ``` + * @name picomatch + * @param {String|Array} `globs` One or more glob patterns. + * @param {Object=} `options` + * @return {Function=} Returns a matcher function. + * @api public + */ + const picomatch = (glob, options, returnState = false) => { + if (Array.isArray(glob)) { + let fns = glob.map(input => picomatch(input, options, returnState)); + return str => { + for (let isMatch of fns) { + let state = isMatch(str); + if (state) + return state; + } + return false; + }; + } + if (typeof glob !== 'string' || glob === '') { + throw new TypeError('Expected pattern to be a non-empty string'); + } + let opts = options || {}; + let posix = utils$1.isWindows(options); + let regex = picomatch.makeRe(glob, options, false, true); + let state = regex.state; + delete regex.state; + let isIgnored = () => false; + if (opts.ignore) { + let ignoreOpts = Object.assign({}, options, { ignore: null, onMatch: null, onResult: null }); + isIgnored = picomatch(opts.ignore, ignoreOpts, returnState); + } + const matcher = (input, returnObject = false) => { + let { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix }); + let result = { glob, state, regex, posix, input, output, match, isMatch }; + if (typeof opts.onResult === 'function') { + opts.onResult(result); + } + if (isMatch === false) { + result.isMatch = false; + return returnObject ? result : false; + } + if (isIgnored(input)) { + if (typeof opts.onIgnore === 'function') { + opts.onIgnore(result); + } + result.isMatch = false; + return returnObject ? result : false; + } + if (typeof opts.onMatch === 'function') { + opts.onMatch(result); + } + return returnObject ? result : true; + }; + if (returnState) { + matcher.state = state; + } + return matcher; + }; + /** + * Test `input` with the given `regex`. This is used by the main + * `picomatch()` function to test the input string. + * + * ```js + * const picomatch = require('picomatch'); + * // picomatch.test(input, regex[, options]); + * + * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/)); + * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' } + * ``` + * @param {String} `input` String to test. + * @param {RegExp} `regex` + * @return {Object} Returns an object with matching info. + * @api public + */ + picomatch.test = (input, regex, options, { glob, posix } = {}) => { + if (typeof input !== 'string') { + throw new TypeError('Expected input to be a string'); + } + if (input === '') { + return { isMatch: false, output: '' }; + } + let opts = options || {}; + let format = opts.format || (posix ? utils$1.toPosixSlashes : null); + let match = input === glob; + let output = (match && format) ? format(input) : input; + if (match === false) { + output = format ? format(input) : input; + match = output === glob; + } + if (match === false || opts.capture === true) { + if (opts.matchBase === true || opts.basename === true) { + match = picomatch.matchBase(input, regex, options, posix); + } + else { + match = regex.exec(output); + } + } + return { isMatch: !!match, match, output }; + }; + /** + * Match the basename of a filepath. + * + * ```js + * const picomatch = require('picomatch'); + * // picomatch.matchBase(input, glob[, options]); + * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true + * ``` + * @param {String} `input` String to test. + * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe). + * @return {Boolean} + * @api public + */ + picomatch.matchBase = (input, glob, options, posix = utils$1.isWindows(options)) => { + let regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options); + return regex.test(path__default.basename(input)); + }; + /** + * Returns true if **any** of the given glob `patterns` match the specified `string`. + * + * ```js + * const picomatch = require('picomatch'); + * // picomatch.isMatch(string, patterns[, options]); + * + * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true + * console.log(picomatch.isMatch('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). + * @return {Boolean} Returns true if any patterns match `str` + * @api public + */ + picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str); + /** + * Parse a glob pattern to create the source string for a regular + * expression. + * + * ```js + * const picomatch = require('picomatch'); + * const result = picomatch.parse(glob[, options]); + * ``` + * @param {String} `glob` + * @param {Object} `options` + * @return {Object} Returns an object with useful properties and output to be used as a regex source string. + * @api public + */ + picomatch.parse = (glob, options) => parse_1$1(glob, options); + /** + * Scan a glob pattern to separate the pattern into segments. + * + * ```js + * const picomatch = require('picomatch'); + * // picomatch.scan(input[, options]); + * + * const result = picomatch.scan('!./foo/*.js'); + * console.log(result); + * // { prefix: '!./', + * // input: '!./foo/*.js', + * // base: 'foo', + * // glob: '*.js', + * // negated: true, + * // isGlob: true } + * ``` + * @param {String} `input` Glob pattern to scan. + * @param {Object} `options` + * @return {Object} Returns an object with + * @api public + */ + picomatch.scan = (input, options) => scan(input, options); + /** + * Create a regular expression from a glob pattern. + * + * ```js + * const picomatch = require('picomatch'); + * // picomatch.makeRe(input[, options]); + * + * console.log(picomatch.makeRe('*.js')); + * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/ + * ``` + * @param {String} `input` A glob pattern to convert to regex. + * @param {Object} `options` + * @return {RegExp} Returns a regex created from the given pattern. + * @api public + */ + picomatch.makeRe = (input, options, returnOutput = false, returnState = false) => { + if (!input || typeof input !== 'string') { + throw new TypeError('Expected a non-empty string'); + } + let opts = options || {}; + let prepend = opts.contains ? '' : '^'; + let append = opts.contains ? '' : '$'; + let state = { negated: false, fastpaths: true }; + let prefix = ''; + let output; + if (input.startsWith('./')) { + input = input.slice(2); + prefix = state.prefix = './'; + } + if (opts.fastpaths !== false && (input[0] === '.' || input[0] === '*')) { + output = parse_1$1.fastpaths(input, options); + } + if (output === void 0) { + state = picomatch.parse(input, options); + state.prefix = prefix + (state.prefix || ''); + output = state.output; + } + if (returnOutput === true) { + return output; + } + let source = `${prepend}(?:${output})${append}`; + if (state && state.negated === true) { + source = `^(?!${source}).*$`; + } + let regex = picomatch.toRegex(source, options); + if (returnState === true) { + regex.state = state; + } + return regex; + }; + /** + * Create a regular expression from the given regex source string. + * + * ```js + * const picomatch = require('picomatch'); + * // picomatch.toRegex(source[, options]); + * + * const { output } = picomatch.parse('*.js'); + * console.log(picomatch.toRegex(output)); + * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/ + * ``` + * @param {String} `source` Regular expression source string. + * @param {Object} `options` + * @return {RegExp} + * @api public + */ + picomatch.toRegex = (source, options) => { + try { + let opts = options || {}; + return new RegExp(source, opts.flags || (opts.nocase ? 'i' : '')); + } + catch (err) { + if (options && options.debug === true) + throw err; + return /$^/; + } + }; + /** + * Picomatch constants. + * @return {Object} + */ + picomatch.constants = constants$1; + /** + * Expose "picomatch" + */ + var picomatch_1 = picomatch; + + var picomatch$1 = picomatch_1; + + const isEmptyString = val => typeof val === 'string' && (val === '' || val === './'); + /** + * 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} list 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) + * @return {Array} Returns an array of matches + * @summary false + * @api public + */ + const micromatch = (list, patterns, options) => { + patterns = [].concat(patterns); + list = [].concat(list); + let omit = new Set(); + let keep = new Set(); + let items = 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$1(String(patterns[i]), Object.assign({}, options, { onResult }), true); + let negated = isMatch.state.negated || isMatch.state.negatedExtglob; + if (negated) + negatives++; + for (let item of list) { + let matched = isMatch(item, true); + let match = negated ? !matched.isMatch : matched.isMatch; + if (!match) + continue; + if (negated) { + omit.add(matched.output); + } + else { + omit.delete(matched.output); + keep.add(matched.output); + } + } + } + let result = negatives === patterns.length ? [...items] : [...keep]; + let matches = result.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$1(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$1(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 = new Set(); + let items = []; + let onResult = state => { + if (options.onResult) + options.onResult(state); + items.push(state.output); + }; + let matches = micromatch(list, patterns, Object.assign({}, options, { onResult })); + for (let item of items) { + if (!matches.includes(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 the patter 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, Object.assign({}, 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$1.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 match `str` + * @api public + */ + micromatch.some = (list, patterns, options) => { + let items = [].concat(list); + for (let pattern of [].concat(patterns)) { + let isMatch = picomatch$1(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 any patterns match `str` + * @api public + */ + micromatch.every = (list, patterns, options) => { + let items = [].concat(list); + for (let pattern of [].concat(patterns)) { + let isMatch = picomatch$1(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$1(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 {Boolean} Returns an array of captures if the input matches the glob pattern, otherwise `null`. + * @api public + */ + micromatch.capture = (glob, input, options) => { + let posix = utils$1.isWindows(options); + let regex = picomatch$1.makeRe(String(glob), Object.assign({}, options, { capture: true })); + let match = regex.exec(posix ? utils$1.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$1.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$1.scan(...args); + /** + * Parse a glob pattern to create the source string for a regular + * expression. + * + * ```js + * const mm = require('micromatch'); + * const state = mm(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_1(String(pattern), options)) { + res.push(picomatch$1.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) || !/\{.*\}/.test(pattern)) { + return [pattern]; + } + return braces_1(pattern, options); + }; + /** + * Expand braces + */ + micromatch.braceExpand = (pattern, options) => { + if (typeof pattern !== 'string') + throw new TypeError('Expected a string'); + return micromatch.braces(pattern, Object.assign({}, options, { expand: true })); + }; + /** + * Expose micromatch + */ + var micromatch_1 = micromatch; + + function ensureArray(thing) { + if (Array.isArray(thing)) + return thing; + if (thing == undefined) + return []; + return [thing]; + } + + function getMatcherString(id, resolutionBase) { + if (resolutionBase === false) { + return id; + } + return path.resolve(...(typeof resolutionBase === 'string' ? [resolutionBase, id] : [id])); + } + const createFilter = function createFilter(include, exclude, options) { + const resolutionBase = options && options.resolve; + const getMatcher = (id) => { + return id instanceof RegExp + ? id + : { + test: micromatch_1.matcher(getMatcherString(id, resolutionBase) + .split(path.sep) + .join('/'), { dot: true }) + }; + }; + const includeMatchers = ensureArray(include).map(getMatcher); + const excludeMatchers = ensureArray(exclude).map(getMatcher); + return function (id) { + if (typeof id !== 'string') + return false; + if (/\0/.test(id)) + return false; + id = id.split(path.sep).join('/'); + for (let i = 0; i < excludeMatchers.length; ++i) { + const matcher = excludeMatchers[i]; + if (matcher.test(id)) + return false; + } + for (let i = 0; i < includeMatchers.length; ++i) { + const matcher = includeMatchers[i]; + if (matcher.test(id)) + return true; + } + return !includeMatchers.length; + }; + }; + + const reservedWords = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public'; + const builtins = 'arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl'; + const forbiddenIdentifiers = new Set(`${reservedWords} ${builtins}`.split(' ')); + forbiddenIdentifiers.add(''); + + function uglify(options) { + if (options === void 0) { options = {}; } + var filter = createFilter(options.include, options.exclude); + return { + name: 'uglify', + transform: function (code, id) { + var _this = this; + if (!filter(id)) + return; + if (typeof options.sourceMap === 'undefined') { + options.sourceMap = true; + } + if (typeof options.warnings === 'undefined') { + options.warnings = true; + } + var result = terser.minify(code, options); + if (result.error) { + throw result.error; + } + if (result.warnings) { + result.warnings.forEach(function (warning) { + _this.warn(warning); + }); + } + return { + code: result.code, + map: result.map + }; + } + }; + } + + return uglify; + +}))); //# sourceMappingURL=plugin.js.map diff --git a/dist/plugin.js.map b/dist/plugin.js.map index 3e7c7af..4b51cb2 100644 --- a/dist/plugin.js.map +++ b/dist/plugin.js.map @@ -1 +1 @@ -{"version":3,"file":"plugin.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"} \ No newline at end of file +{"version":3,"file":"plugin.js","sources":["../node_modules/rollup-pluginutils/dist/pluginutils.es.js"],"sourcesContent":["import path, { extname, sep, resolve } from 'path';\nimport { walk } from 'estree-walker';\nimport util from 'util';\n\nconst addExtension = function addExtension(filename, ext = '.js') {\n if (!extname(filename))\n filename += ext;\n return filename;\n};\n\nconst extractors = {\n ArrayPattern(names, param) {\n for (const element of param.elements) {\n if (element)\n extractors[element.type](names, element);\n }\n },\n AssignmentPattern(names, param) {\n extractors[param.left.type](names, param.left);\n },\n Identifier(names, param) {\n names.push(param.name);\n },\n MemberExpression() { },\n ObjectPattern(names, param) {\n for (const prop of param.properties) {\n if (prop.type === 'RestElement') {\n extractors.RestElement(names, prop);\n }\n else {\n extractors[prop.value.type](names, prop.value);\n }\n }\n },\n RestElement(names, param) {\n extractors[param.argument.type](names, param.argument);\n }\n};\nconst extractAssignedNames = function extractAssignedNames(param) {\n const names = [];\n extractors[param.type](names, param);\n return names;\n};\n\nconst blockDeclarations = {\n const: true,\n let: true\n};\nclass Scope {\n constructor(options = {}) {\n this.parent = options.parent;\n this.isBlockScope = !!options.block;\n this.declarations = Object.create(null);\n if (options.params) {\n options.params.forEach(param => {\n extractAssignedNames(param).forEach(name => {\n this.declarations[name] = true;\n });\n });\n }\n }\n addDeclaration(node, isBlockDeclaration, isVar) {\n if (!isBlockDeclaration && this.isBlockScope) {\n // it's a `var` or function node, and this\n // is a block scope, so we need to go up\n this.parent.addDeclaration(node, isBlockDeclaration, isVar);\n }\n else if (node.id) {\n extractAssignedNames(node.id).forEach(name => {\n this.declarations[name] = true;\n });\n }\n }\n contains(name) {\n return this.declarations[name] || (this.parent ? this.parent.contains(name) : false);\n }\n}\nconst attachScopes = function attachScopes(ast, propertyName = 'scope') {\n let scope = new Scope();\n walk(ast, {\n enter(node, parent) {\n // function foo () {...}\n // class Foo {...}\n if (/(Function|Class)Declaration/.test(node.type)) {\n scope.addDeclaration(node, false, false);\n }\n // var foo = 1\n if (node.type === 'VariableDeclaration') {\n const kind = node.kind;\n const isBlockDeclaration = blockDeclarations[kind];\n node.declarations.forEach((declaration) => {\n scope.addDeclaration(declaration, isBlockDeclaration, true);\n });\n }\n let newScope;\n // create new function scope\n if (/Function/.test(node.type)) {\n newScope = new Scope({\n parent: scope,\n block: false,\n params: node.params\n });\n // named function expressions - the name is considered\n // part of the function's scope\n if (node.type === 'FunctionExpression' && node.id) {\n newScope.addDeclaration(node, false, false);\n }\n }\n // create new block scope\n if (node.type === 'BlockStatement' && !/Function/.test(parent.type)) {\n newScope = new Scope({\n parent: scope,\n block: true\n });\n }\n // catch clause has its own block scope\n if (node.type === 'CatchClause') {\n newScope = new Scope({\n parent: scope,\n params: node.param ? [node.param] : [],\n block: true\n });\n }\n if (newScope) {\n Object.defineProperty(node, propertyName, {\n value: newScope,\n configurable: true\n });\n scope = newScope;\n }\n },\n leave(node) {\n if (node[propertyName])\n scope = scope.parent;\n }\n });\n return scope;\n};\n\nfunction createCommonjsModule(fn, module) {\n\treturn module = { exports: {} }, fn(module, module.exports), module.exports;\n}\n\nvar utils = createCommonjsModule(function (module, exports) {\n exports.isInteger = num => {\n if (typeof num === 'number') {\n return Number.isInteger(num);\n }\n if (typeof num === 'string' && num.trim() !== '') {\n return Number.isInteger(Number(num));\n }\n return false;\n };\n /**\n * Find a node of the given type\n */\n exports.find = (node, type) => node.nodes.find(node => node.type === type);\n /**\n * Find a node of the given type\n */\n exports.exceedsLimit = (min, max, step = 1, limit) => {\n if (limit === false)\n return false;\n if (!exports.isInteger(min) || !exports.isInteger(max))\n return false;\n return ((Number(max) - Number(min)) / Number(step)) >= limit;\n };\n /**\n * Escape the given node with '\\\\' before node.value\n */\n exports.escapeNode = (block, n = 0, type) => {\n let node = block.nodes[n];\n if (!node)\n return;\n if ((type && node.type === type) || node.type === 'open' || node.type === 'close') {\n if (node.escaped !== true) {\n node.value = '\\\\' + node.value;\n node.escaped = true;\n }\n }\n };\n /**\n * Returns true if the given brace node should be enclosed in literal braces\n */\n exports.encloseBrace = node => {\n if (node.type !== 'brace')\n return false;\n if ((node.commas >> 0 + node.ranges >> 0) === 0) {\n node.invalid = true;\n return true;\n }\n return false;\n };\n /**\n * Returns true if a brace node is invalid.\n */\n exports.isInvalidBrace = block => {\n if (block.type !== 'brace')\n return false;\n if (block.invalid === true || block.dollar)\n return true;\n if ((block.commas >> 0 + block.ranges >> 0) === 0) {\n block.invalid = true;\n return true;\n }\n if (block.open !== true || block.close !== true) {\n block.invalid = true;\n return true;\n }\n return false;\n };\n /**\n * Returns true if a node is an open or close node\n */\n exports.isOpenOrClose = node => {\n if (node.type === 'open' || node.type === 'close') {\n return true;\n }\n return node.open === true || node.close === true;\n };\n /**\n * Reduce an array of text nodes.\n */\n exports.reduce = nodes => nodes.reduce((acc, node) => {\n if (node.type === 'text')\n acc.push(node.value);\n if (node.type === 'range')\n node.type = 'text';\n return acc;\n }, []);\n /**\n * Flatten an array\n */\n exports.flatten = (...args) => {\n const result = [];\n const flat = arr => {\n for (let i = 0; i < arr.length; i++) {\n let ele = arr[i];\n Array.isArray(ele) ? flat(ele, result) : ele !== void 0 && result.push(ele);\n }\n return result;\n };\n flat(args);\n return result;\n };\n});\nvar utils_1 = utils.isInteger;\nvar utils_2 = utils.find;\nvar utils_3 = utils.exceedsLimit;\nvar utils_4 = utils.escapeNode;\nvar utils_5 = utils.encloseBrace;\nvar utils_6 = utils.isInvalidBrace;\nvar utils_7 = utils.isOpenOrClose;\nvar utils_8 = utils.reduce;\nvar utils_9 = utils.flatten;\n\nvar stringify = (ast, options = {}) => {\n let stringify = (node, parent = {}) => {\n let invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent);\n let invalidNode = node.invalid === true && options.escapeInvalid === true;\n let output = '';\n if (node.value) {\n if ((invalidBlock || invalidNode) && utils.isOpenOrClose(node)) {\n return '\\\\' + node.value;\n }\n return node.value;\n }\n if (node.value) {\n return node.value;\n }\n if (node.nodes) {\n for (let child of node.nodes) {\n output += stringify(child);\n }\n }\n return output;\n };\n return stringify(ast);\n};\n\n/*!\n * is-number \n *\n * Copyright (c) 2014-present, Jon Schlinkert.\n * Released under the MIT License.\n */\nvar isNumber = function (num) {\n if (typeof num === 'number') {\n return num - num === 0;\n }\n if (typeof num === 'string' && num.trim() !== '') {\n return Number.isFinite ? Number.isFinite(+num) : isFinite(+num);\n }\n return false;\n};\n\nconst toRegexRange = (min, max, options) => {\n if (isNumber(min) === false) {\n throw new TypeError('toRegexRange: expected the first argument to be a number');\n }\n if (max === void 0 || min === max) {\n return String(min);\n }\n if (isNumber(max) === false) {\n throw new TypeError('toRegexRange: expected the second argument to be a number.');\n }\n let opts = Object.assign({ relaxZeros: true }, options);\n if (typeof opts.strictZeros === 'boolean') {\n opts.relaxZeros = opts.strictZeros === false;\n }\n let relax = String(opts.relaxZeros);\n let shorthand = String(opts.shorthand);\n let capture = String(opts.capture);\n let wrap = String(opts.wrap);\n let cacheKey = min + ':' + max + '=' + relax + shorthand + capture + wrap;\n if (toRegexRange.cache.hasOwnProperty(cacheKey)) {\n return toRegexRange.cache[cacheKey].result;\n }\n let a = Math.min(min, max);\n let b = Math.max(min, max);\n if (Math.abs(a - b) === 1) {\n let result = min + '|' + max;\n if (opts.capture) {\n return `(${result})`;\n }\n if (opts.wrap === false) {\n return result;\n }\n return `(?:${result})`;\n }\n let isPadded = hasPadding(min) || hasPadding(max);\n let state = { min, max, a, b };\n let positives = [];\n let negatives = [];\n if (isPadded) {\n state.isPadded = isPadded;\n state.maxLen = String(state.max).length;\n }\n if (a < 0) {\n let newMin = b < 0 ? Math.abs(b) : 1;\n negatives = splitToPatterns(newMin, Math.abs(a), state, opts);\n a = state.a = 0;\n }\n if (b >= 0) {\n positives = splitToPatterns(a, b, state, opts);\n }\n state.negatives = negatives;\n state.positives = positives;\n state.result = collatePatterns(negatives, positives, opts);\n if (opts.capture === true) {\n state.result = `(${state.result})`;\n }\n else if (opts.wrap !== false && (positives.length + negatives.length) > 1) {\n state.result = `(?:${state.result})`;\n }\n toRegexRange.cache[cacheKey] = state;\n return state.result;\n};\nfunction collatePatterns(neg, pos, options) {\n let onlyNegative = filterPatterns(neg, pos, '-', false, options) || [];\n let onlyPositive = filterPatterns(pos, neg, '', false, options) || [];\n let intersected = filterPatterns(neg, pos, '-?', true, options) || [];\n let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);\n return subpatterns.join('|');\n}\nfunction splitToRanges(min, max) {\n let nines = 1;\n let zeros = 1;\n let stop = countNines(min, nines);\n let stops = new Set([max]);\n while (min <= stop && stop <= max) {\n stops.add(stop);\n nines += 1;\n stop = countNines(min, nines);\n }\n stop = countZeros(max + 1, zeros) - 1;\n while (min < stop && stop <= max) {\n stops.add(stop);\n zeros += 1;\n stop = countZeros(max + 1, zeros) - 1;\n }\n stops = [...stops];\n stops.sort(compare);\n return stops;\n}\n/**\n * Convert a range to a regex pattern\n * @param {Number} `start`\n * @param {Number} `stop`\n * @return {String}\n */\nfunction rangeToPattern(start, stop, options) {\n if (start === stop) {\n return { pattern: start, count: [], digits: 0 };\n }\n let zipped = zip(start, stop);\n let digits = zipped.length;\n let pattern = '';\n let count = 0;\n for (let i = 0; i < digits; i++) {\n let [startDigit, stopDigit] = zipped[i];\n if (startDigit === stopDigit) {\n pattern += startDigit;\n }\n else if (startDigit !== '0' || stopDigit !== '9') {\n pattern += toCharacterClass(startDigit, stopDigit, options);\n }\n else {\n count++;\n }\n }\n if (count) {\n pattern += options.shorthand === true ? '\\\\d' : '[0-9]';\n }\n return { pattern, count: [count], digits };\n}\nfunction splitToPatterns(min, max, tok, options) {\n let ranges = splitToRanges(min, max);\n let tokens = [];\n let start = min;\n let prev;\n for (let i = 0; i < ranges.length; i++) {\n let max = ranges[i];\n let obj = rangeToPattern(String(start), String(max), options);\n let zeros = '';\n if (!tok.isPadded && prev && prev.pattern === obj.pattern) {\n if (prev.count.length > 1) {\n prev.count.pop();\n }\n prev.count.push(obj.count[0]);\n prev.string = prev.pattern + toQuantifier(prev.count);\n start = max + 1;\n continue;\n }\n if (tok.isPadded) {\n zeros = padZeros(max, tok, options);\n }\n obj.string = zeros + obj.pattern + toQuantifier(obj.count);\n tokens.push(obj);\n start = max + 1;\n prev = obj;\n }\n return tokens;\n}\nfunction filterPatterns(arr, comparison, prefix, intersection, options) {\n let result = [];\n for (let ele of arr) {\n let { string } = ele;\n // only push if _both_ are negative...\n if (!intersection && !contains(comparison, 'string', string)) {\n result.push(prefix + string);\n }\n // or _both_ are positive\n if (intersection && contains(comparison, 'string', string)) {\n result.push(prefix + string);\n }\n }\n return result;\n}\n/**\n * Zip strings\n */\nfunction zip(a, b) {\n let arr = [];\n for (let i = 0; i < a.length; i++)\n arr.push([a[i], b[i]]);\n return arr;\n}\nfunction compare(a, b) {\n return a > b ? 1 : b > a ? -1 : 0;\n}\nfunction contains(arr, key, val) {\n return arr.some(ele => ele[key] === val);\n}\nfunction countNines(min, len) {\n return Number(String(min).slice(0, -len) + '9'.repeat(len));\n}\nfunction countZeros(integer, zeros) {\n return integer - (integer % Math.pow(10, zeros));\n}\nfunction toQuantifier(digits) {\n let [start = 0, stop = ''] = digits;\n if (stop || start > 1) {\n return `{${start + (stop ? ',' + stop : '')}}`;\n }\n return '';\n}\nfunction toCharacterClass(a, b, options) {\n return `[${a}${(b - a === 1) ? '' : '-'}${b}]`;\n}\nfunction hasPadding(str) {\n return /^-?(0+)\\d/.test(str);\n}\nfunction padZeros(value, tok, options) {\n if (!tok.isPadded) {\n return value;\n }\n let diff = Math.abs(tok.maxLen - String(value).length);\n let relax = options.relaxZeros !== false;\n switch (diff) {\n case 0:\n return '';\n case 1:\n return relax ? '0?' : '0';\n case 2:\n return relax ? '0{0,2}' : '00';\n default: {\n return relax ? `0{0,${diff}}` : `0{${diff}}`;\n }\n }\n}\n/**\n * Cache\n */\ntoRegexRange.cache = {};\ntoRegexRange.clearCache = () => (toRegexRange.cache = {});\n/**\n * Expose `toRegexRange`\n */\nvar toRegexRange_1 = toRegexRange;\n\nconst isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);\nconst transform = toNumber => {\n return value => toNumber === true ? Number(value) : String(value);\n};\nconst isValidValue = value => {\n return typeof value === 'number' || (typeof value === 'string' && value !== '');\n};\nconst isNumber$1 = num => Number.isInteger(+num);\nconst zeros = input => {\n let value = `${input}`;\n let index = -1;\n if (value[0] === '-')\n value = value.slice(1);\n if (value === '0')\n return false;\n while (value[++index] === '0')\n ;\n return index > 0;\n};\nconst stringify$1 = (start, end, options) => {\n if (typeof start === 'string' || typeof end === 'string') {\n return true;\n }\n return options.stringify === true;\n};\nconst pad = (input, maxLength, toNumber) => {\n if (maxLength > 0) {\n let dash = input[0] === '-' ? '-' : '';\n if (dash)\n input = input.slice(1);\n input = (dash + input.padStart(dash ? maxLength - 1 : maxLength, '0'));\n }\n if (toNumber === false) {\n return String(input);\n }\n return input;\n};\nconst toMaxLen = (input, maxLength) => {\n let negative = input[0] === '-' ? '-' : '';\n if (negative) {\n input = input.slice(1);\n maxLength--;\n }\n while (input.length < maxLength)\n input = '0' + input;\n return negative ? ('-' + input) : input;\n};\nconst toSequence = (parts, options) => {\n parts.negatives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);\n parts.positives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);\n let prefix = options.capture ? '' : '?:';\n let positives = '';\n let negatives = '';\n let result;\n if (parts.positives.length) {\n positives = parts.positives.join('|');\n }\n if (parts.negatives.length) {\n negatives = `-(${prefix}${parts.negatives.join('|')})`;\n }\n if (positives && negatives) {\n result = `${positives}|${negatives}`;\n }\n else {\n result = positives || negatives;\n }\n if (options.wrap) {\n return `(${prefix}${result})`;\n }\n return result;\n};\nconst toRange = (a, b, isNumbers, options) => {\n if (isNumbers) {\n return toRegexRange_1(a, b, Object.assign({ wrap: false }, options));\n }\n let start = String.fromCharCode(a);\n if (a === b)\n return start;\n let stop = String.fromCharCode(b);\n return `[${start}-${stop}]`;\n};\nconst toRegex = (start, end, options) => {\n if (Array.isArray(start)) {\n let wrap = options.wrap === true;\n let prefix = options.capture ? '' : '?:';\n return wrap ? `(${prefix}${start.join('|')})` : start.join('|');\n }\n return toRegexRange_1(start, end, options);\n};\nconst rangeError = (...args) => {\n return new RangeError('Invalid range arguments: ' + util.inspect(...args));\n};\nconst invalidRange = (start, end, options) => {\n if (options.strictRanges === true)\n throw rangeError([start, end]);\n return [];\n};\nconst invalidStep = (step, options) => {\n if (options.strictRanges === true) {\n throw new TypeError(`Expected step \"${step}\" to be a number`);\n }\n return [];\n};\nconst fillNumbers = (start, end, step = 1, options = {}) => {\n let a = Number(start);\n let b = Number(end);\n if (!Number.isInteger(a) || !Number.isInteger(b)) {\n if (options.strictRanges === true)\n throw rangeError([start, end]);\n return [];\n }\n // fix negative zero\n if (a === 0)\n a = 0;\n if (b === 0)\n b = 0;\n let descending = a > b;\n let startString = String(start);\n let endString = String(end);\n let stepString = String(step);\n step = Math.max(Math.abs(step), 1);\n let padded = zeros(startString) || zeros(endString) || zeros(stepString);\n let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;\n let toNumber = padded === false && stringify$1(start, end, options) === false;\n let format = options.transform || transform(toNumber);\n if (options.toRegex && step === 1) {\n return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);\n }\n let parts = { negatives: [], positives: [] };\n let push = num => parts[num < 0 ? 'negatives' : 'positives'].push(Math.abs(num));\n let range = [];\n let index = 0;\n while (descending ? a >= b : a <= b) {\n if (options.toRegex === true && step > 1) {\n push(a);\n }\n else {\n range.push(pad(format(a, index), maxLen, toNumber));\n }\n a = descending ? a - step : a + step;\n index++;\n }\n if (options.toRegex === true) {\n return step > 1\n ? toSequence(parts, options)\n : toRegex(range, null, Object.assign({ wrap: false }, options));\n }\n return range;\n};\nconst fillLetters = (start, end, step = 1, options = {}) => {\n if ((!isNumber$1(start) && start.length > 1) || (!isNumber$1(end) && end.length > 1)) {\n return invalidRange(start, end, options);\n }\n let format = options.transform || (val => String.fromCharCode(val));\n let a = `${start}`.charCodeAt(0);\n let b = `${end}`.charCodeAt(0);\n let descending = a > b;\n let min = Math.min(a, b);\n let max = Math.max(a, b);\n if (options.toRegex && step === 1) {\n return toRange(min, max, false, options);\n }\n let range = [];\n let index = 0;\n while (descending ? a >= b : a <= b) {\n range.push(format(a, index));\n a = descending ? a - step : a + step;\n index++;\n }\n if (options.toRegex === true) {\n return toRegex(range, null, { wrap: false, options });\n }\n return range;\n};\nconst fill = (start, end, step, options = {}) => {\n if (end == null && isValidValue(start)) {\n return [start];\n }\n if (!isValidValue(start) || !isValidValue(end)) {\n return invalidRange(start, end, options);\n }\n if (typeof step === 'function') {\n return fill(start, end, 1, { transform: step });\n }\n if (isObject(step)) {\n return fill(start, end, 0, step);\n }\n let opts = Object.assign({}, options);\n if (opts.capture === true)\n opts.wrap = true;\n step = step || opts.step || 1;\n if (!isNumber$1(step)) {\n if (step != null && !isObject(step))\n return invalidStep(step, opts);\n return fill(start, end, 1, step);\n }\n if (isNumber$1(start) && isNumber$1(end)) {\n return fillNumbers(start, end, step, opts);\n }\n return fillLetters(start, end, Math.max(Math.abs(step), 1), opts);\n};\nvar fillRange = fill;\n\nconst compile = (ast, options = {}) => {\n let walk = (node, parent = {}) => {\n let invalidBlock = utils.isInvalidBrace(parent);\n let invalidNode = node.invalid === true && options.escapeInvalid === true;\n let invalid = invalidBlock === true || invalidNode === true;\n let prefix = options.escapeInvalid === true ? '\\\\' : '';\n let output = '';\n if (node.isOpen === true) {\n return prefix + node.value;\n }\n if (node.isClose === true) {\n return prefix + node.value;\n }\n if (node.type === 'open') {\n return invalid ? (prefix + node.value) : '(';\n }\n if (node.type === 'close') {\n return invalid ? (prefix + node.value) : ')';\n }\n if (node.type === 'comma') {\n return node.prev.type === 'comma' ? '' : (invalid ? node.value : '|');\n }\n if (node.value) {\n return node.value;\n }\n if (node.nodes && node.ranges > 0) {\n let args = utils.reduce(node.nodes);\n let range = fillRange(...args, Object.assign({}, options, { wrap: false, toRegex: true }));\n if (range.length !== 0) {\n return args.length > 1 && range.length > 1 ? `(${range})` : range;\n }\n }\n if (node.nodes) {\n for (let child of node.nodes) {\n output += walk(child, node);\n }\n }\n return output;\n };\n return walk(ast);\n};\nvar compile_1 = compile;\n\nconst append = (queue = '', stash = '', enclose = false) => {\n let result = [];\n queue = [].concat(queue);\n stash = [].concat(stash);\n if (!stash.length)\n return queue;\n if (!queue.length) {\n return enclose ? utils.flatten(stash).map(ele => `{${ele}}`) : stash;\n }\n for (let item of queue) {\n if (Array.isArray(item)) {\n for (let value of item) {\n result.push(append(value, stash, enclose));\n }\n }\n else {\n for (let ele of stash) {\n if (enclose === true && typeof ele === 'string')\n ele = `{${ele}}`;\n result.push(Array.isArray(ele) ? append(item, ele, enclose) : (item + ele));\n }\n }\n }\n return utils.flatten(result);\n};\nconst expand = (ast, options = {}) => {\n let rangeLimit = options.rangeLimit === void 0 ? 1000 : options.rangeLimit;\n let walk = (node, parent = {}) => {\n node.queue = [];\n let p = parent;\n let q = parent.queue;\n while (p.type !== 'brace' && p.type !== 'root' && p.parent) {\n p = p.parent;\n q = p.queue;\n }\n if (node.invalid || node.dollar) {\n q.push(append(q.pop(), stringify(node, options)));\n return;\n }\n if (node.type === 'brace' && node.invalid !== true && node.nodes.length === 2) {\n q.push(append(q.pop(), ['{}']));\n return;\n }\n if (node.nodes && node.ranges > 0) {\n let args = utils.reduce(node.nodes);\n if (utils.exceedsLimit(...args, options.step, rangeLimit)) {\n throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.');\n }\n let range = fillRange(...args, options);\n if (range.length === 0) {\n range = stringify(node, options);\n }\n q.push(append(q.pop(), range));\n node.nodes = [];\n return;\n }\n let enclose = utils.encloseBrace(node);\n let queue = node.queue;\n let block = node;\n while (block.type !== 'brace' && block.type !== 'root' && block.parent) {\n block = block.parent;\n queue = block.queue;\n }\n for (let i = 0; i < node.nodes.length; i++) {\n let child = node.nodes[i];\n if (child.type === 'comma' && node.type === 'brace') {\n if (i === 1)\n queue.push('');\n queue.push('');\n continue;\n }\n if (child.type === 'close') {\n q.push(append(q.pop(), queue, enclose));\n continue;\n }\n if (child.value && child.type !== 'open') {\n queue.push(append(queue.pop(), child.value));\n continue;\n }\n if (child.nodes) {\n walk(child, node);\n }\n }\n return queue;\n };\n return utils.flatten(walk(ast));\n};\nvar expand_1 = expand;\n\nvar constants = {\n MAX_LENGTH: 1024 * 64,\n // Digits\n CHAR_0: '0',\n CHAR_9: '9',\n // Alphabet chars.\n CHAR_UPPERCASE_A: 'A',\n CHAR_LOWERCASE_A: 'a',\n CHAR_UPPERCASE_Z: 'Z',\n CHAR_LOWERCASE_Z: 'z',\n CHAR_LEFT_PARENTHESES: '(',\n CHAR_RIGHT_PARENTHESES: ')',\n CHAR_ASTERISK: '*',\n // Non-alphabetic chars.\n CHAR_AMPERSAND: '&',\n CHAR_AT: '@',\n CHAR_BACKSLASH: '\\\\',\n CHAR_BACKTICK: '`',\n CHAR_CARRIAGE_RETURN: '\\r',\n CHAR_CIRCUMFLEX_ACCENT: '^',\n CHAR_COLON: ':',\n CHAR_COMMA: ',',\n CHAR_DOLLAR: '$',\n CHAR_DOT: '.',\n CHAR_DOUBLE_QUOTE: '\"',\n CHAR_EQUAL: '=',\n CHAR_EXCLAMATION_MARK: '!',\n CHAR_FORM_FEED: '\\f',\n CHAR_FORWARD_SLASH: '/',\n CHAR_HASH: '#',\n CHAR_HYPHEN_MINUS: '-',\n CHAR_LEFT_ANGLE_BRACKET: '<',\n CHAR_LEFT_CURLY_BRACE: '{',\n CHAR_LEFT_SQUARE_BRACKET: '[',\n CHAR_LINE_FEED: '\\n',\n CHAR_NO_BREAK_SPACE: '\\u00A0',\n CHAR_PERCENT: '%',\n CHAR_PLUS: '+',\n CHAR_QUESTION_MARK: '?',\n CHAR_RIGHT_ANGLE_BRACKET: '>',\n CHAR_RIGHT_CURLY_BRACE: '}',\n CHAR_RIGHT_SQUARE_BRACKET: ']',\n CHAR_SEMICOLON: ';',\n CHAR_SINGLE_QUOTE: '\\'',\n CHAR_SPACE: ' ',\n CHAR_TAB: '\\t',\n CHAR_UNDERSCORE: '_',\n CHAR_VERTICAL_LINE: '|',\n CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\\uFEFF' /* \\uFEFF */\n};\n\n/**\n * Constants\n */\nconst { MAX_LENGTH, CHAR_BACKSLASH, /* \\ */ CHAR_BACKTICK, /* ` */ CHAR_COMMA, /* , */ CHAR_DOT, /* . */ CHAR_LEFT_PARENTHESES, /* ( */ CHAR_RIGHT_PARENTHESES, /* ) */ CHAR_LEFT_CURLY_BRACE, /* { */ CHAR_RIGHT_CURLY_BRACE, /* } */ CHAR_LEFT_SQUARE_BRACKET, /* [ */ CHAR_RIGHT_SQUARE_BRACKET, /* ] */ CHAR_DOUBLE_QUOTE, /* \" */ CHAR_SINGLE_QUOTE, /* ' */ CHAR_NO_BREAK_SPACE, CHAR_ZERO_WIDTH_NOBREAK_SPACE } = constants;\n/**\n * parse\n */\nconst parse = (input, options = {}) => {\n if (typeof input !== 'string') {\n throw new TypeError('Expected a string');\n }\n let opts = options || {};\n let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;\n if (input.length > max) {\n throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);\n }\n let ast = { type: 'root', input, nodes: [] };\n let stack = [ast];\n let block = ast;\n let prev = ast;\n let brackets = 0;\n let length = input.length;\n let index = 0;\n let depth = 0;\n let value;\n /**\n * Helpers\n */\n const advance = () => input[index++];\n const push = node => {\n if (node.type === 'text' && prev.type === 'dot') {\n prev.type = 'text';\n }\n if (prev && prev.type === 'text' && node.type === 'text') {\n prev.value += node.value;\n return;\n }\n block.nodes.push(node);\n node.parent = block;\n node.prev = prev;\n prev = node;\n return node;\n };\n push({ type: 'bos' });\n while (index < length) {\n block = stack[stack.length - 1];\n value = advance();\n /**\n * Invalid chars\n */\n if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) {\n continue;\n }\n /**\n * Escaped chars\n */\n if (value === CHAR_BACKSLASH) {\n push({ type: 'text', value: (options.keepEscaping ? value : '') + advance() });\n continue;\n }\n /**\n * Right square bracket (literal): ']'\n */\n if (value === CHAR_RIGHT_SQUARE_BRACKET) {\n push({ type: 'text', value: '\\\\' + value });\n continue;\n }\n /**\n * Left square bracket: '['\n */\n if (value === CHAR_LEFT_SQUARE_BRACKET) {\n brackets++;\n let next;\n while (index < length && (next = advance())) {\n value += next;\n if (next === CHAR_LEFT_SQUARE_BRACKET) {\n brackets++;\n continue;\n }\n if (next === CHAR_BACKSLASH) {\n value += advance();\n continue;\n }\n if (next === CHAR_RIGHT_SQUARE_BRACKET) {\n brackets--;\n if (brackets === 0) {\n break;\n }\n }\n }\n push({ type: 'text', value });\n continue;\n }\n /**\n * Parentheses\n */\n if (value === CHAR_LEFT_PARENTHESES) {\n block = push({ type: 'paren', nodes: [] });\n stack.push(block);\n push({ type: 'text', value });\n continue;\n }\n if (value === CHAR_RIGHT_PARENTHESES) {\n if (block.type !== 'paren') {\n push({ type: 'text', value });\n continue;\n }\n block = stack.pop();\n push({ type: 'text', value });\n block = stack[stack.length - 1];\n continue;\n }\n /**\n * Quotes: '|\"|`\n */\n if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) {\n let open = value;\n let next;\n if (options.keepQuotes !== true) {\n value = '';\n }\n while (index < length && (next = advance())) {\n if (next === CHAR_BACKSLASH) {\n value += next + advance();\n continue;\n }\n if (next === open) {\n if (options.keepQuotes === true)\n value += next;\n break;\n }\n value += next;\n }\n push({ type: 'text', value });\n continue;\n }\n /**\n * Left curly brace: '{'\n */\n if (value === CHAR_LEFT_CURLY_BRACE) {\n depth++;\n let dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true;\n let brace = {\n type: 'brace',\n open: true,\n close: false,\n dollar,\n depth,\n commas: 0,\n ranges: 0,\n nodes: []\n };\n block = push(brace);\n stack.push(block);\n push({ type: 'open', value });\n continue;\n }\n /**\n * Right curly brace: '}'\n */\n if (value === CHAR_RIGHT_CURLY_BRACE) {\n if (block.type !== 'brace') {\n push({ type: 'text', value });\n continue;\n }\n let type = 'close';\n block = stack.pop();\n block.close = true;\n push({ type, value });\n depth--;\n block = stack[stack.length - 1];\n continue;\n }\n /**\n * Comma: ','\n */\n if (value === CHAR_COMMA && depth > 0) {\n if (block.ranges > 0) {\n block.ranges = 0;\n let open = block.nodes.shift();\n block.nodes = [open, { type: 'text', value: stringify(block) }];\n }\n push({ type: 'comma', value });\n block.commas++;\n continue;\n }\n /**\n * Dot: '.'\n */\n if (value === CHAR_DOT && depth > 0 && block.commas === 0) {\n let siblings = block.nodes;\n if (depth === 0 || siblings.length === 0) {\n push({ type: 'text', value });\n continue;\n }\n if (prev.type === 'dot') {\n block.range = [];\n prev.value += value;\n prev.type = 'range';\n if (block.nodes.length !== 3 && block.nodes.length !== 5) {\n block.invalid = true;\n block.ranges = 0;\n prev.type = 'text';\n continue;\n }\n block.ranges++;\n block.args = [];\n continue;\n }\n if (prev.type === 'range') {\n siblings.pop();\n let before = siblings[siblings.length - 1];\n before.value += prev.value + value;\n prev = before;\n block.ranges--;\n continue;\n }\n push({ type: 'dot', value });\n continue;\n }\n /**\n * Text\n */\n push({ type: 'text', value });\n }\n // Mark imbalanced braces and brackets as invalid\n do {\n block = stack.pop();\n if (block.type !== 'root') {\n block.nodes.forEach(node => {\n if (!node.nodes) {\n if (node.type === 'open')\n node.isOpen = true;\n if (node.type === 'close')\n node.isClose = true;\n if (!node.nodes)\n node.type = 'text';\n node.invalid = true;\n }\n });\n // get the location of the block on parent.nodes (block's siblings)\n let parent = stack[stack.length - 1];\n let index = parent.nodes.indexOf(block);\n // replace the (invalid) block with it's nodes\n parent.nodes.splice(index, 1, ...block.nodes);\n }\n } while (stack.length > 0);\n push({ type: 'eos' });\n return ast;\n};\nvar parse_1 = parse;\n\n/**\n * Expand the given pattern or create a regex-compatible string.\n *\n * ```js\n * const braces = require('braces');\n * console.log(braces('{a,b,c}', { compile: true })); //=> ['(a|b|c)']\n * console.log(braces('{a,b,c}')); //=> ['a', 'b', 'c']\n * ```\n * @param {String} `str`\n * @param {Object} `options`\n * @return {String}\n * @api public\n */\nconst braces = (input, options = {}) => {\n let output = [];\n if (Array.isArray(input)) {\n for (let pattern of input) {\n let result = braces.create(pattern, options);\n if (Array.isArray(result)) {\n output.push(...result);\n }\n else {\n output.push(result);\n }\n }\n }\n else {\n output = [].concat(braces.create(input, options));\n }\n if (options && options.expand === true && options.nodupes === true) {\n output = [...new Set(output)];\n }\n return output;\n};\n/**\n * Parse the given `str` with the given `options`.\n *\n * ```js\n * // braces.parse(pattern, [, options]);\n * const ast = braces.parse('a/{b,c}/d');\n * console.log(ast);\n * ```\n * @param {String} pattern Brace pattern to parse\n * @param {Object} options\n * @return {Object} Returns an AST\n * @api public\n */\nbraces.parse = (input, options = {}) => parse_1(input, options);\n/**\n * Creates a braces string from an AST, or an AST node.\n *\n * ```js\n * const braces = require('braces');\n * let ast = braces.parse('foo/{a,b}/bar');\n * console.log(stringify(ast.nodes[2])); //=> '{a,b}'\n * ```\n * @param {String} `input` Brace pattern or AST.\n * @param {Object} `options`\n * @return {Array} Returns an array of expanded values.\n * @api public\n */\nbraces.stringify = (input, options = {}) => {\n if (typeof input === 'string') {\n return stringify(braces.parse(input, options), options);\n }\n return stringify(input, options);\n};\n/**\n * Compiles a brace pattern into a regex-compatible, optimized string.\n * This method is called by the main [braces](#braces) function by default.\n *\n * ```js\n * const braces = require('braces');\n * console.log(braces.compile('a/{b,c}/d'));\n * //=> ['a/(b|c)/d']\n * ```\n * @param {String} `input` Brace pattern or AST.\n * @param {Object} `options`\n * @return {Array} Returns an array of expanded values.\n * @api public\n */\nbraces.compile = (input, options = {}) => {\n if (typeof input === 'string') {\n input = braces.parse(input, options);\n }\n return compile_1(input, options);\n};\n/**\n * Expands a brace pattern into an array. This method is called by the\n * main [braces](#braces) function when `options.expand` is true. Before\n * using this method it's recommended that you read the [performance notes](#performance))\n * and advantages of using [.compile](#compile) instead.\n *\n * ```js\n * const braces = require('braces');\n * console.log(braces.expand('a/{b,c}/d'));\n * //=> ['a/b/d', 'a/c/d'];\n * ```\n * @param {String} `pattern` Brace pattern\n * @param {Object} `options`\n * @return {Array} Returns an array of expanded values.\n * @api public\n */\nbraces.expand = (input, options = {}) => {\n if (typeof input === 'string') {\n input = braces.parse(input, options);\n }\n let result = expand_1(input, options);\n // filter out empty strings if specified\n if (options.noempty === true) {\n result = result.filter(Boolean);\n }\n // filter out duplicates if specified\n if (options.nodupes === true) {\n result = [...new Set(result)];\n }\n return result;\n};\n/**\n * Processes a brace pattern and returns either an expanded array\n * (if `options.expand` is true), a highly optimized regex-compatible string.\n * This method is called by the main [braces](#braces) function.\n *\n * ```js\n * const braces = require('braces');\n * console.log(braces.create('user-{200..300}/project-{a,b,c}-{1..10}'))\n * //=> 'user-(20[0-9]|2[1-9][0-9]|300)/project-(a|b|c)-([1-9]|10)'\n * ```\n * @param {String} `pattern` Brace pattern\n * @param {Object} `options`\n * @return {Array} Returns an array of expanded values.\n * @api public\n */\nbraces.create = (input, options = {}) => {\n if (input === '' || input.length < 3) {\n return [input];\n }\n return options.expand !== true\n ? braces.compile(input, options)\n : braces.expand(input, options);\n};\n/**\n * Expose \"braces\"\n */\nvar braces_1 = braces;\n\nconst WIN_SLASH = '\\\\\\\\/';\nconst WIN_NO_SLASH = `[^${WIN_SLASH}]`;\n/**\n * Posix glob regex\n */\nconst DOT_LITERAL = '\\\\.';\nconst PLUS_LITERAL = '\\\\+';\nconst QMARK_LITERAL = '\\\\?';\nconst SLASH_LITERAL = '\\\\/';\nconst ONE_CHAR = '(?=.)';\nconst QMARK = '[^/]';\nconst END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;\nconst START_ANCHOR = `(?:^|${SLASH_LITERAL})`;\nconst DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;\nconst NO_DOT = `(?!${DOT_LITERAL})`;\nconst NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;\nconst NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;\nconst NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;\nconst QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;\nconst STAR = `${QMARK}*?`;\nconst POSIX_CHARS = {\n DOT_LITERAL,\n PLUS_LITERAL,\n QMARK_LITERAL,\n SLASH_LITERAL,\n ONE_CHAR,\n QMARK,\n END_ANCHOR,\n DOTS_SLASH,\n NO_DOT,\n NO_DOTS,\n NO_DOT_SLASH,\n NO_DOTS_SLASH,\n QMARK_NO_DOT,\n STAR,\n START_ANCHOR\n};\n/**\n * Windows glob regex\n */\nconst WINDOWS_CHARS = Object.assign({}, POSIX_CHARS, { SLASH_LITERAL: `[${WIN_SLASH}]`, QMARK: WIN_NO_SLASH, STAR: `${WIN_NO_SLASH}*?`, DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`, NO_DOT: `(?!${DOT_LITERAL})`, NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`, NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`, NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`, QMARK_NO_DOT: `[^.${WIN_SLASH}]`, START_ANCHOR: `(?:^|[${WIN_SLASH}])`, END_ANCHOR: `(?:[${WIN_SLASH}]|$)` });\n/**\n * POSIX Bracket Regex\n */\nconst POSIX_REGEX_SOURCE = {\n alnum: 'a-zA-Z0-9',\n alpha: 'a-zA-Z',\n ascii: '\\\\x00-\\\\x7F',\n blank: ' \\\\t',\n cntrl: '\\\\x00-\\\\x1F\\\\x7F',\n digit: '0-9',\n graph: '\\\\x21-\\\\x7E',\n lower: 'a-z',\n print: '\\\\x20-\\\\x7E ',\n punct: '\\\\-!\"#$%&\\'()\\\\*+,./:;<=>?@[\\\\]^_`{|}~',\n space: ' \\\\t\\\\r\\\\n\\\\v\\\\f',\n upper: 'A-Z',\n word: 'A-Za-z0-9_',\n xdigit: 'A-Fa-f0-9'\n};\nvar constants$1 = {\n MAX_LENGTH: 1024 * 64,\n POSIX_REGEX_SOURCE,\n // regular expressions\n REGEX_BACKSLASH: /\\\\(?![*+?^${}(|)[\\]])/g,\n REGEX_NON_SPECIAL_CHAR: /^[^@![\\].,$*+?^{}()|\\\\/]+/,\n REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\\]]/,\n REGEX_SPECIAL_CHARS_BACKREF: /(\\\\?)((\\W)(\\3*))/g,\n REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\\]])/g,\n REGEX_REMOVE_BACKSLASH: /(?:\\[.*?[^\\\\]\\]|\\\\(?=.))/g,\n // Replace globs with equivalent patterns to reduce parsing time.\n REPLACEMENTS: {\n '***': '*',\n '**/**': '**',\n '**/**/**': '**'\n },\n // Digits\n CHAR_0: 48,\n CHAR_9: 57,\n // Alphabet chars.\n CHAR_UPPERCASE_A: 65,\n CHAR_LOWERCASE_A: 97,\n CHAR_UPPERCASE_Z: 90,\n CHAR_LOWERCASE_Z: 122,\n CHAR_LEFT_PARENTHESES: 40,\n CHAR_RIGHT_PARENTHESES: 41,\n CHAR_ASTERISK: 42,\n // Non-alphabetic chars.\n CHAR_AMPERSAND: 38,\n CHAR_AT: 64,\n CHAR_BACKWARD_SLASH: 92,\n CHAR_CARRIAGE_RETURN: 13,\n CHAR_CIRCUMFLEX_ACCENT: 94,\n CHAR_COLON: 58,\n CHAR_COMMA: 44,\n CHAR_DOT: 46,\n CHAR_DOUBLE_QUOTE: 34,\n CHAR_EQUAL: 61,\n CHAR_EXCLAMATION_MARK: 33,\n CHAR_FORM_FEED: 12,\n CHAR_FORWARD_SLASH: 47,\n CHAR_GRAVE_ACCENT: 96,\n CHAR_HASH: 35,\n CHAR_HYPHEN_MINUS: 45,\n CHAR_LEFT_ANGLE_BRACKET: 60,\n CHAR_LEFT_CURLY_BRACE: 123,\n CHAR_LEFT_SQUARE_BRACKET: 91,\n CHAR_LINE_FEED: 10,\n CHAR_NO_BREAK_SPACE: 160,\n CHAR_PERCENT: 37,\n CHAR_PLUS: 43,\n CHAR_QUESTION_MARK: 63,\n CHAR_RIGHT_ANGLE_BRACKET: 62,\n CHAR_RIGHT_CURLY_BRACE: 125,\n CHAR_RIGHT_SQUARE_BRACKET: 93,\n CHAR_SEMICOLON: 59,\n CHAR_SINGLE_QUOTE: 39,\n CHAR_SPACE: 32,\n CHAR_TAB: 9,\n CHAR_UNDERSCORE: 95,\n CHAR_VERTICAL_LINE: 124,\n CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,\n SEP: path.sep,\n /**\n * Create EXTGLOB_CHARS\n */\n extglobChars(chars) {\n return {\n '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` },\n '?': { type: 'qmark', open: '(?:', close: ')?' },\n '+': { type: 'plus', open: '(?:', close: ')+' },\n '*': { type: 'star', open: '(?:', close: ')*' },\n '@': { type: 'at', open: '(?:', close: ')' }\n };\n },\n /**\n * Create GLOB_CHARS\n */\n globChars(win32) {\n return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;\n }\n};\n\nvar utils$1 = createCommonjsModule(function (module, exports) {\n const win32 = process.platform === 'win32';\n const { REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL, REGEX_REMOVE_BACKSLASH } = constants$1;\n exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);\n exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);\n exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str);\n exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\\\$1');\n exports.toPosixSlashes = str => str.replace(/\\\\/g, '/');\n exports.removeBackslashes = str => {\n return str.replace(REGEX_REMOVE_BACKSLASH, match => {\n return match === '\\\\' ? '' : match;\n });\n };\n exports.supportsLookbehinds = () => {\n let segs = process.version.slice(1).split('.');\n if (segs.length === 3 && +segs[0] >= 9 || (+segs[0] === 8 && +segs[1] >= 10)) {\n return true;\n }\n return false;\n };\n exports.isWindows = options => {\n if (options && typeof options.windows === 'boolean') {\n return options.windows;\n }\n return win32 === true || path.sep === '\\\\';\n };\n exports.escapeLast = (input, char, lastIdx) => {\n let idx = input.lastIndexOf(char, lastIdx);\n if (idx === -1)\n return input;\n if (input[idx - 1] === '\\\\')\n return exports.escapeLast(input, char, idx - 1);\n return input.slice(0, idx) + '\\\\' + input.slice(idx);\n };\n});\nvar utils_1$1 = utils$1.isObject;\nvar utils_2$1 = utils$1.hasRegexChars;\nvar utils_3$1 = utils$1.isRegexChar;\nvar utils_4$1 = utils$1.escapeRegex;\nvar utils_5$1 = utils$1.toPosixSlashes;\nvar utils_6$1 = utils$1.removeBackslashes;\nvar utils_7$1 = utils$1.supportsLookbehinds;\nvar utils_8$1 = utils$1.isWindows;\nvar utils_9$1 = utils$1.escapeLast;\n\nconst { CHAR_ASTERISK, /* * */ CHAR_AT, /* @ */ CHAR_BACKWARD_SLASH, /* \\ */ CHAR_COMMA: CHAR_COMMA$1, /* , */ CHAR_DOT: CHAR_DOT$1, /* . */ CHAR_EXCLAMATION_MARK, /* ! */ CHAR_FORWARD_SLASH, /* / */ CHAR_LEFT_CURLY_BRACE: CHAR_LEFT_CURLY_BRACE$1, /* { */ CHAR_LEFT_PARENTHESES: CHAR_LEFT_PARENTHESES$1, /* ( */ CHAR_LEFT_SQUARE_BRACKET: CHAR_LEFT_SQUARE_BRACKET$1, /* [ */ CHAR_PLUS, /* + */ CHAR_QUESTION_MARK, /* ? */ CHAR_RIGHT_CURLY_BRACE: CHAR_RIGHT_CURLY_BRACE$1, /* } */ CHAR_RIGHT_PARENTHESES: CHAR_RIGHT_PARENTHESES$1, /* ) */ CHAR_RIGHT_SQUARE_BRACKET: CHAR_RIGHT_SQUARE_BRACKET$1 /* ] */ } = constants$1;\nconst isPathSeparator = code => {\n return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;\n};\n/**\n * Quickly scans a glob pattern and returns an object with a handful of\n * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),\n * `glob` (the actual pattern), and `negated` (true if the path starts with `!`).\n *\n * ```js\n * const pm = require('picomatch');\n * console.log(pm.scan('foo/bar/*.js'));\n * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }\n * ```\n * @param {String} `str`\n * @param {Object} `options`\n * @return {Object} Returns an object with tokens and regex source string.\n * @api public\n */\nvar scan = (input, options) => {\n let opts = options || {};\n let length = input.length - 1;\n let index = -1;\n let start = 0;\n let lastIndex = 0;\n let isGlob = false;\n let backslashes = false;\n let negated = false;\n let braces = 0;\n let prev;\n let code;\n let braceEscaped = false;\n let eos = () => index >= length;\n let advance = () => {\n prev = code;\n return input.charCodeAt(++index);\n };\n while (index < length) {\n code = advance();\n let next;\n if (code === CHAR_BACKWARD_SLASH) {\n backslashes = true;\n next = advance();\n if (next === CHAR_LEFT_CURLY_BRACE$1) {\n braceEscaped = true;\n }\n continue;\n }\n if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE$1) {\n braces++;\n while (!eos() && (next = advance())) {\n if (next === CHAR_BACKWARD_SLASH) {\n backslashes = true;\n next = advance();\n continue;\n }\n if (next === CHAR_LEFT_CURLY_BRACE$1) {\n braces++;\n continue;\n }\n if (!braceEscaped && next === CHAR_DOT$1 && (next = advance()) === CHAR_DOT$1) {\n isGlob = true;\n break;\n }\n if (!braceEscaped && next === CHAR_COMMA$1) {\n isGlob = true;\n break;\n }\n if (next === CHAR_RIGHT_CURLY_BRACE$1) {\n braces--;\n if (braces === 0) {\n braceEscaped = false;\n break;\n }\n }\n }\n }\n if (code === CHAR_FORWARD_SLASH) {\n if (prev === CHAR_DOT$1 && index === (start + 1)) {\n start += 2;\n continue;\n }\n lastIndex = index + 1;\n continue;\n }\n if (code === CHAR_ASTERISK) {\n isGlob = true;\n break;\n }\n if (code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK) {\n isGlob = true;\n break;\n }\n if (code === CHAR_LEFT_SQUARE_BRACKET$1) {\n while (!eos() && (next = advance())) {\n if (next === CHAR_BACKWARD_SLASH) {\n backslashes = true;\n next = advance();\n continue;\n }\n if (next === CHAR_RIGHT_SQUARE_BRACKET$1) {\n isGlob = true;\n break;\n }\n }\n }\n let isExtglobChar = code === CHAR_PLUS\n || code === CHAR_AT\n || code === CHAR_EXCLAMATION_MARK;\n if (isExtglobChar && input.charCodeAt(index + 1) === CHAR_LEFT_PARENTHESES$1) {\n isGlob = true;\n break;\n }\n if (code === CHAR_EXCLAMATION_MARK && index === start) {\n negated = true;\n start++;\n continue;\n }\n if (code === CHAR_LEFT_PARENTHESES$1) {\n while (!eos() && (next = advance())) {\n if (next === CHAR_BACKWARD_SLASH) {\n backslashes = true;\n next = advance();\n continue;\n }\n if (next === CHAR_RIGHT_PARENTHESES$1) {\n isGlob = true;\n break;\n }\n }\n }\n if (isGlob) {\n break;\n }\n }\n let prefix = '';\n let orig = input;\n let base = input;\n let glob = '';\n if (start > 0) {\n prefix = input.slice(0, start);\n input = input.slice(start);\n lastIndex -= start;\n }\n if (base && isGlob === true && lastIndex > 0) {\n base = input.slice(0, lastIndex);\n glob = input.slice(lastIndex);\n }\n else if (isGlob === true) {\n base = '';\n glob = input;\n }\n else {\n base = input;\n }\n if (base && base !== '' && base !== '/' && base !== input) {\n if (isPathSeparator(base.charCodeAt(base.length - 1))) {\n base = base.slice(0, -1);\n }\n }\n if (opts.unescape === true) {\n if (glob)\n glob = utils$1.removeBackslashes(glob);\n if (base && backslashes === true) {\n base = utils$1.removeBackslashes(base);\n }\n }\n return { prefix, input: orig, base, glob, negated, isGlob };\n};\n\n/**\n * Constants\n */\nconst { MAX_LENGTH: MAX_LENGTH$1, POSIX_REGEX_SOURCE: POSIX_REGEX_SOURCE$1, REGEX_NON_SPECIAL_CHAR, REGEX_SPECIAL_CHARS_BACKREF, REPLACEMENTS } = constants$1;\n/**\n * Helpers\n */\nconst expandRange = (args, options) => {\n if (typeof options.expandRange === 'function') {\n return options.expandRange(...args, options);\n }\n args.sort();\n let value = `[${args.join('-')}]`;\n try {\n }\n catch (ex) {\n return args.map(v => utils$1.escapeRegex(v)).join('..');\n }\n return value;\n};\nconst negate = state => {\n let count = 1;\n while (state.peek() === '!' && (state.peek(2) !== '(' || state.peek(3) === '?')) {\n state.advance();\n state.start++;\n count++;\n }\n if (count % 2 === 0) {\n return false;\n }\n state.negated = true;\n state.start++;\n return true;\n};\n/**\n * Create the message for a syntax error\n */\nconst syntaxError = (type, char) => {\n return `Missing ${type}: \"${char}\" - use \"\\\\\\\\${char}\" to match literal characters`;\n};\n/**\n * Parse the given input string.\n * @param {String} input\n * @param {Object} options\n * @return {Object}\n */\nconst parse$1 = (input, options) => {\n if (typeof input !== 'string') {\n throw new TypeError('Expected a string');\n }\n input = REPLACEMENTS[input] || input;\n let opts = Object.assign({}, options);\n let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$1, opts.maxLength) : MAX_LENGTH$1;\n let len = input.length;\n if (len > max) {\n throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);\n }\n let bos = { type: 'bos', value: '', output: opts.prepend || '' };\n let tokens = [bos];\n let capture = opts.capture ? '' : '?:';\n let win32 = utils$1.isWindows(options);\n // create constants based on platform, for windows or posix\n const PLATFORM_CHARS = constants$1.globChars(win32);\n const EXTGLOB_CHARS = constants$1.extglobChars(PLATFORM_CHARS);\n const { DOT_LITERAL, PLUS_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOT_SLASH, NO_DOTS_SLASH, QMARK, QMARK_NO_DOT, STAR, START_ANCHOR } = PLATFORM_CHARS;\n const globstar = (opts) => {\n return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;\n };\n let nodot = opts.dot ? '' : NO_DOT;\n let star = opts.bash === true ? globstar(opts) : STAR;\n let qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;\n if (opts.capture) {\n star = `(${star})`;\n }\n // minimatch options support\n if (typeof opts.noext === 'boolean') {\n opts.noextglob = opts.noext;\n }\n let state = {\n index: -1,\n start: 0,\n consumed: '',\n output: '',\n backtrack: false,\n brackets: 0,\n braces: 0,\n parens: 0,\n quotes: 0,\n tokens\n };\n let extglobs = [];\n let stack = [];\n let prev = bos;\n let value;\n /**\n * Tokenizing helpers\n */\n const eos = () => state.index === len - 1;\n const peek = state.peek = (n = 1) => input[state.index + n];\n const advance = state.advance = () => input[++state.index];\n const append = token => {\n state.output += token.output != null ? token.output : token.value;\n state.consumed += token.value || '';\n };\n const increment = type => {\n state[type]++;\n stack.push(type);\n };\n const decrement = type => {\n state[type]--;\n stack.pop();\n };\n /**\n * Push tokens onto the tokens array. This helper speeds up\n * tokenizing by 1) helping us avoid backtracking as much as possible,\n * and 2) helping us avoid creating extra tokens when consecutive\n * characters are plain text. This improves performance and simplifies\n * lookbehinds.\n */\n const push = tok => {\n if (prev.type === 'globstar') {\n let isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace');\n let isExtglob = extglobs.length && (tok.type === 'pipe' || tok.type === 'paren');\n if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) {\n state.output = state.output.slice(0, -prev.output.length);\n prev.type = 'star';\n prev.value = '*';\n prev.output = star;\n state.output += prev.output;\n }\n }\n if (extglobs.length && tok.type !== 'paren' && !EXTGLOB_CHARS[tok.value]) {\n extglobs[extglobs.length - 1].inner += tok.value;\n }\n if (tok.value || tok.output)\n append(tok);\n if (prev && prev.type === 'text' && tok.type === 'text') {\n prev.value += tok.value;\n return;\n }\n tok.prev = prev;\n tokens.push(tok);\n prev = tok;\n };\n const extglobOpen = (type, value) => {\n let token = Object.assign({}, EXTGLOB_CHARS[value], { conditions: 1, inner: '' });\n token.prev = prev;\n token.parens = state.parens;\n token.output = state.output;\n let output = (opts.capture ? '(' : '') + token.open;\n push({ type, value, output: state.output ? '' : ONE_CHAR });\n push({ type: 'paren', extglob: true, value: advance(), output });\n increment('parens');\n extglobs.push(token);\n };\n const extglobClose = token => {\n let output = token.close + (opts.capture ? ')' : '');\n if (token.type === 'negate') {\n let extglobStar = star;\n if (token.inner && token.inner.length > 1 && token.inner.includes('/')) {\n extglobStar = globstar(opts);\n }\n if (extglobStar !== star || eos() || /^\\)+$/.test(input.slice(state.index + 1))) {\n output = token.close = ')$))' + extglobStar;\n }\n if (token.prev.type === 'bos' && eos()) {\n state.negatedExtglob = true;\n }\n }\n push({ type: 'paren', extglob: true, value, output });\n decrement('parens');\n };\n if (opts.fastpaths !== false && !/(^[*!]|[/{[()\\]}\"])/.test(input)) {\n let backslashes = false;\n let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {\n if (first === '\\\\') {\n backslashes = true;\n return m;\n }\n if (first === '?') {\n if (esc) {\n return esc + first + (rest ? QMARK.repeat(rest.length) : '');\n }\n if (index === 0) {\n return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');\n }\n return QMARK.repeat(chars.length);\n }\n if (first === '.') {\n return DOT_LITERAL.repeat(chars.length);\n }\n if (first === '*') {\n if (esc) {\n return esc + first + (rest ? star : '');\n }\n return star;\n }\n return esc ? m : '\\\\' + m;\n });\n if (backslashes === true) {\n if (opts.unescape === true) {\n output = output.replace(/\\\\/g, '');\n }\n else {\n output = output.replace(/\\\\+/g, m => {\n return m.length % 2 === 0 ? '\\\\\\\\' : (m ? '\\\\' : '');\n });\n }\n }\n state.output = output;\n return state;\n }\n /**\n * Tokenize input until we reach end-of-string\n */\n while (!eos()) {\n value = advance();\n if (value === '\\u0000') {\n continue;\n }\n /**\n * Escaped characters\n */\n if (value === '\\\\') {\n let next = peek();\n if (next === '/' && opts.bash !== true) {\n continue;\n }\n if (next === '.' || next === ';') {\n continue;\n }\n if (!next) {\n value += '\\\\';\n push({ type: 'text', value });\n continue;\n }\n // collapse slashes to reduce potential for exploits\n let match = /^\\\\+/.exec(input.slice(state.index + 1));\n let slashes = 0;\n if (match && match[0].length > 2) {\n slashes = match[0].length;\n state.index += slashes;\n if (slashes % 2 !== 0) {\n value += '\\\\';\n }\n }\n if (opts.unescape === true) {\n value = advance() || '';\n }\n else {\n value += advance() || '';\n }\n if (state.brackets === 0) {\n push({ type: 'text', value });\n continue;\n }\n }\n /**\n * If we're inside a regex character class, continue\n * until we reach the closing bracket.\n */\n if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) {\n if (opts.posix !== false && value === ':') {\n let inner = prev.value.slice(1);\n if (inner.includes('[')) {\n prev.posix = true;\n if (inner.includes(':')) {\n let idx = prev.value.lastIndexOf('[');\n let pre = prev.value.slice(0, idx);\n let rest = prev.value.slice(idx + 2);\n let posix = POSIX_REGEX_SOURCE$1[rest];\n if (posix) {\n prev.value = pre + posix;\n state.backtrack = true;\n advance();\n if (!bos.output && tokens.indexOf(prev) === 1) {\n bos.output = ONE_CHAR;\n }\n continue;\n }\n }\n }\n }\n if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) {\n value = '\\\\' + value;\n }\n if (value === ']' && (prev.value === '[' || prev.value === '[^')) {\n value = '\\\\' + value;\n }\n if (opts.posix === true && value === '!' && prev.value === '[') {\n value = '^';\n }\n prev.value += value;\n append({ value });\n continue;\n }\n /**\n * If we're inside a quoted string, continue\n * until we reach the closing double quote.\n */\n if (state.quotes === 1 && value !== '\"') {\n value = utils$1.escapeRegex(value);\n prev.value += value;\n append({ value });\n continue;\n }\n /**\n * Double quotes\n */\n if (value === '\"') {\n state.quotes = state.quotes === 1 ? 0 : 1;\n if (opts.keepQuotes === true) {\n push({ type: 'text', value });\n }\n continue;\n }\n /**\n * Parentheses\n */\n if (value === '(') {\n push({ type: 'paren', value });\n increment('parens');\n continue;\n }\n if (value === ')') {\n if (state.parens === 0 && opts.strictBrackets === true) {\n throw new SyntaxError(syntaxError('opening', '('));\n }\n let extglob = extglobs[extglobs.length - 1];\n if (extglob && state.parens === extglob.parens + 1) {\n extglobClose(extglobs.pop());\n continue;\n }\n push({ type: 'paren', value, output: state.parens ? ')' : '\\\\)' });\n decrement('parens');\n continue;\n }\n /**\n * Brackets\n */\n if (value === '[') {\n if (opts.nobracket === true || !input.slice(state.index + 1).includes(']')) {\n if (opts.nobracket !== true && opts.strictBrackets === true) {\n throw new SyntaxError(syntaxError('closing', ']'));\n }\n value = '\\\\' + value;\n }\n else {\n increment('brackets');\n }\n push({ type: 'bracket', value });\n continue;\n }\n if (value === ']') {\n if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) {\n push({ type: 'text', value, output: '\\\\' + value });\n continue;\n }\n if (state.brackets === 0) {\n if (opts.strictBrackets === true) {\n throw new SyntaxError(syntaxError('opening', '['));\n }\n push({ type: 'text', value, output: '\\\\' + value });\n continue;\n }\n decrement('brackets');\n let prevValue = prev.value.slice(1);\n if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) {\n value = '/' + value;\n }\n prev.value += value;\n append({ value });\n // when literal brackets are explicitly disabled\n // assume we should match with a regex character class\n if (opts.literalBrackets === false || utils$1.hasRegexChars(prevValue)) {\n continue;\n }\n let escaped = utils$1.escapeRegex(prev.value);\n state.output = state.output.slice(0, -prev.value.length);\n // when literal brackets are explicitly enabled\n // assume we should escape the brackets to match literal characters\n if (opts.literalBrackets === true) {\n state.output += escaped;\n prev.value = escaped;\n continue;\n }\n // when the user specifies nothing, try to match both\n prev.value = `(${capture}${escaped}|${prev.value})`;\n state.output += prev.value;\n continue;\n }\n /**\n * Braces\n */\n if (value === '{' && opts.nobrace !== true) {\n push({ type: 'brace', value, output: '(' });\n increment('braces');\n continue;\n }\n if (value === '}') {\n if (opts.nobrace === true || state.braces === 0) {\n push({ type: 'text', value, output: '\\\\' + value });\n continue;\n }\n let output = ')';\n if (state.dots === true) {\n let arr = tokens.slice();\n let range = [];\n for (let i = arr.length - 1; i >= 0; i--) {\n tokens.pop();\n if (arr[i].type === 'brace') {\n break;\n }\n if (arr[i].type !== 'dots') {\n range.unshift(arr[i].value);\n }\n }\n output = expandRange(range, opts);\n state.backtrack = true;\n }\n push({ type: 'brace', value, output });\n decrement('braces');\n continue;\n }\n /**\n * Pipes\n */\n if (value === '|') {\n if (extglobs.length > 0) {\n extglobs[extglobs.length - 1].conditions++;\n }\n push({ type: 'text', value });\n continue;\n }\n /**\n * Commas\n */\n if (value === ',') {\n let output = value;\n if (state.braces > 0 && stack[stack.length - 1] === 'braces') {\n output = '|';\n }\n push({ type: 'comma', value, output });\n continue;\n }\n /**\n * Slashes\n */\n if (value === '/') {\n // if the beginning of the glob is \"./\", advance the start\n // to the current index, and don't add the \"./\" characters\n // to the state. This greatly simplifies lookbehinds when\n // checking for BOS characters like \"!\" and \".\" (not \"./\")\n if (prev.type === 'dot' && state.index === 1) {\n state.start = state.index + 1;\n state.consumed = '';\n state.output = '';\n tokens.pop();\n prev = bos; // reset \"prev\" to the first token\n continue;\n }\n push({ type: 'slash', value, output: SLASH_LITERAL });\n continue;\n }\n /**\n * Dots\n */\n if (value === '.') {\n if (state.braces > 0 && prev.type === 'dot') {\n if (prev.value === '.')\n prev.output = DOT_LITERAL;\n prev.type = 'dots';\n prev.output += value;\n prev.value += value;\n state.dots = true;\n continue;\n }\n push({ type: 'dot', value, output: DOT_LITERAL });\n continue;\n }\n /**\n * Question marks\n */\n if (value === '?') {\n if (prev && prev.type === 'paren') {\n let next = peek();\n let output = value;\n if (next === '<' && !utils$1.supportsLookbehinds()) {\n throw new Error('Node.js v10 or higher is required for regex lookbehinds');\n }\n if (prev.value === '(' && !/[!=<:]/.test(next) || (next === '<' && !/[!=]/.test(peek(2)))) {\n output = '\\\\' + value;\n }\n push({ type: 'text', value, output });\n continue;\n }\n if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {\n extglobOpen('qmark', value);\n continue;\n }\n if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) {\n push({ type: 'qmark', value, output: QMARK_NO_DOT });\n continue;\n }\n push({ type: 'qmark', value, output: QMARK });\n continue;\n }\n /**\n * Exclamation\n */\n if (value === '!') {\n if (opts.noextglob !== true && peek() === '(') {\n if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) {\n extglobOpen('negate', value);\n continue;\n }\n }\n if (opts.nonegate !== true && state.index === 0) {\n negate(state);\n continue;\n }\n }\n /**\n * Plus\n */\n if (value === '+') {\n if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {\n extglobOpen('plus', value);\n continue;\n }\n if (prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) {\n let output = prev.extglob === true ? '\\\\' + value : value;\n push({ type: 'plus', value, output });\n continue;\n }\n // use regex behavior inside parens\n if (state.parens > 0 && opts.regex !== false) {\n push({ type: 'plus', value });\n continue;\n }\n push({ type: 'plus', value: PLUS_LITERAL });\n continue;\n }\n /**\n * Plain text\n */\n if (value === '@') {\n if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {\n push({ type: 'at', value, output: '' });\n continue;\n }\n push({ type: 'text', value });\n continue;\n }\n /**\n * Plain text\n */\n if (value !== '*') {\n if (value === '$' || value === '^') {\n value = '\\\\' + value;\n }\n let match = REGEX_NON_SPECIAL_CHAR.exec(input.slice(state.index + 1));\n if (match) {\n value += match[0];\n state.index += match[0].length;\n }\n push({ type: 'text', value });\n continue;\n }\n /**\n * Stars\n */\n if (prev && (prev.type === 'globstar' || prev.star === true)) {\n prev.type = 'star';\n prev.star = true;\n prev.value += value;\n prev.output = star;\n state.backtrack = true;\n state.consumed += value;\n continue;\n }\n if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {\n extglobOpen('star', value);\n continue;\n }\n if (prev.type === 'star') {\n if (opts.noglobstar === true) {\n state.consumed += value;\n continue;\n }\n let prior = prev.prev;\n let before = prior.prev;\n let isStart = prior.type === 'slash' || prior.type === 'bos';\n let afterStar = before && (before.type === 'star' || before.type === 'globstar');\n if (opts.bash === true && (!isStart || (!eos() && peek() !== '/'))) {\n push({ type: 'star', value, output: '' });\n continue;\n }\n let isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace');\n let isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren');\n if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) {\n push({ type: 'star', value, output: '' });\n continue;\n }\n // strip consecutive `/**/`\n while (input.slice(state.index + 1, state.index + 4) === '/**') {\n let after = input[state.index + 4];\n if (after && after !== '/') {\n break;\n }\n state.consumed += '/**';\n state.index += 3;\n }\n if (prior.type === 'bos' && eos()) {\n prev.type = 'globstar';\n prev.value += value;\n prev.output = globstar(opts);\n state.output = prev.output;\n state.consumed += value;\n continue;\n }\n if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) {\n state.output = state.output.slice(0, -(prior.output + prev.output).length);\n prior.output = '(?:' + prior.output;\n prev.type = 'globstar';\n prev.output = globstar(opts) + '|$)';\n prev.value += value;\n state.output += prior.output + prev.output;\n state.consumed += value;\n continue;\n }\n let next = peek();\n if (prior.type === 'slash' && prior.prev.type !== 'bos' && next === '/') {\n let end = peek(2) !== void 0 ? '|$' : '';\n state.output = state.output.slice(0, -(prior.output + prev.output).length);\n prior.output = '(?:' + prior.output;\n prev.type = 'globstar';\n prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;\n prev.value += value;\n state.output += prior.output + prev.output;\n state.consumed += value + advance();\n push({ type: 'slash', value, output: '' });\n continue;\n }\n if (prior.type === 'bos' && next === '/') {\n prev.type = 'globstar';\n prev.value += value;\n prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;\n state.output = prev.output;\n state.consumed += value + advance();\n push({ type: 'slash', value, output: '' });\n continue;\n }\n // remove single star from output\n state.output = state.output.slice(0, -prev.output.length);\n // reset previous token to globstar\n prev.type = 'globstar';\n prev.output = globstar(opts);\n prev.value += value;\n // reset output with globstar\n state.output += prev.output;\n state.consumed += value;\n continue;\n }\n let token = { type: 'star', value, output: star };\n if (opts.bash === true) {\n token.output = '.*?';\n if (prev.type === 'bos' || prev.type === 'slash') {\n token.output = nodot + token.output;\n }\n push(token);\n continue;\n }\n if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) {\n token.output = value;\n push(token);\n continue;\n }\n if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') {\n if (prev.type === 'dot') {\n state.output += NO_DOT_SLASH;\n prev.output += NO_DOT_SLASH;\n }\n else if (opts.dot === true) {\n state.output += NO_DOTS_SLASH;\n prev.output += NO_DOTS_SLASH;\n }\n else {\n state.output += nodot;\n prev.output += nodot;\n }\n if (peek() !== '*') {\n state.output += ONE_CHAR;\n prev.output += ONE_CHAR;\n }\n }\n push(token);\n }\n while (state.brackets > 0) {\n if (opts.strictBrackets === true)\n throw new SyntaxError(syntaxError('closing', ']'));\n state.output = utils$1.escapeLast(state.output, '[');\n decrement('brackets');\n }\n while (state.parens > 0) {\n if (opts.strictBrackets === true)\n throw new SyntaxError(syntaxError('closing', ')'));\n state.output = utils$1.escapeLast(state.output, '(');\n decrement('parens');\n }\n while (state.braces > 0) {\n if (opts.strictBrackets === true)\n throw new SyntaxError(syntaxError('closing', '}'));\n state.output = utils$1.escapeLast(state.output, '{');\n decrement('braces');\n }\n if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) {\n push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` });\n }\n // rebuild the output if we had to backtrack at any point\n if (state.backtrack === true) {\n state.output = '';\n for (let token of state.tokens) {\n state.output += token.output != null ? token.output : token.value;\n if (token.suffix) {\n state.output += token.suffix;\n }\n }\n }\n return state;\n};\n/**\n * Fast paths for creating regular expressions for common glob patterns.\n * This can significantly speed up processing and has very little downside\n * impact when none of the fast paths match.\n */\nparse$1.fastpaths = (input, options) => {\n let opts = Object.assign({}, options);\n let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$1, opts.maxLength) : MAX_LENGTH$1;\n let len = input.length;\n if (len > max) {\n throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);\n }\n input = REPLACEMENTS[input] || input;\n let win32 = utils$1.isWindows(options);\n // create constants based on platform, for windows or posix\n const { DOT_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOTS, NO_DOTS_SLASH, STAR, START_ANCHOR } = constants$1.globChars(win32);\n let capture = opts.capture ? '' : '?:';\n let star = opts.bash === true ? '.*?' : STAR;\n let nodot = opts.dot ? NO_DOTS : NO_DOT;\n let slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;\n if (opts.capture) {\n star = `(${star})`;\n }\n const globstar = (opts) => {\n return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;\n };\n const create = str => {\n switch (str) {\n case '*':\n return `${nodot}${ONE_CHAR}${star}`;\n case '.*':\n return `${DOT_LITERAL}${ONE_CHAR}${star}`;\n case '*.*':\n return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;\n case '*/*':\n return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;\n case '**':\n return nodot + globstar(opts);\n case '**/*':\n return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;\n case '**/*.*':\n return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;\n case '**/.*':\n return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;\n default: {\n let match = /^(.*?)\\.(\\w+)$/.exec(str);\n if (!match)\n return;\n let source = create(match[1], options);\n if (!source)\n return;\n return source + DOT_LITERAL + match[2];\n }\n }\n };\n let output = create(input);\n if (output && opts.strictSlashes !== true) {\n output += `${SLASH_LITERAL}?`;\n }\n return output;\n};\nvar parse_1$1 = parse$1;\n\n/**\n * Creates a matcher function from one or more glob patterns. The\n * returned function takes a string to match as its first argument,\n * and returns true if the string is a match. The returned matcher\n * function also takes a boolean as the second argument that, when true,\n * returns an object with additional information.\n *\n * ```js\n * const picomatch = require('picomatch');\n * // picomatch(glob[, options]);\n *\n * const isMatch = picomatch('*.!(*a)');\n * console.log(isMatch('a.a')); //=> false\n * console.log(isMatch('a.b')); //=> true\n * ```\n * @name picomatch\n * @param {String|Array} `globs` One or more glob patterns.\n * @param {Object=} `options`\n * @return {Function=} Returns a matcher function.\n * @api public\n */\nconst picomatch = (glob, options, returnState = false) => {\n if (Array.isArray(glob)) {\n let fns = glob.map(input => picomatch(input, options, returnState));\n return str => {\n for (let isMatch of fns) {\n let state = isMatch(str);\n if (state)\n return state;\n }\n return false;\n };\n }\n if (typeof glob !== 'string' || glob === '') {\n throw new TypeError('Expected pattern to be a non-empty string');\n }\n let opts = options || {};\n let posix = utils$1.isWindows(options);\n let regex = picomatch.makeRe(glob, options, false, true);\n let state = regex.state;\n delete regex.state;\n let isIgnored = () => false;\n if (opts.ignore) {\n let ignoreOpts = Object.assign({}, options, { ignore: null, onMatch: null, onResult: null });\n isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);\n }\n const matcher = (input, returnObject = false) => {\n let { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix });\n let result = { glob, state, regex, posix, input, output, match, isMatch };\n if (typeof opts.onResult === 'function') {\n opts.onResult(result);\n }\n if (isMatch === false) {\n result.isMatch = false;\n return returnObject ? result : false;\n }\n if (isIgnored(input)) {\n if (typeof opts.onIgnore === 'function') {\n opts.onIgnore(result);\n }\n result.isMatch = false;\n return returnObject ? result : false;\n }\n if (typeof opts.onMatch === 'function') {\n opts.onMatch(result);\n }\n return returnObject ? result : true;\n };\n if (returnState) {\n matcher.state = state;\n }\n return matcher;\n};\n/**\n * Test `input` with the given `regex`. This is used by the main\n * `picomatch()` function to test the input string.\n *\n * ```js\n * const picomatch = require('picomatch');\n * // picomatch.test(input, regex[, options]);\n *\n * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\\/([^/]*?))$/));\n * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }\n * ```\n * @param {String} `input` String to test.\n * @param {RegExp} `regex`\n * @return {Object} Returns an object with matching info.\n * @api public\n */\npicomatch.test = (input, regex, options, { glob, posix } = {}) => {\n if (typeof input !== 'string') {\n throw new TypeError('Expected input to be a string');\n }\n if (input === '') {\n return { isMatch: false, output: '' };\n }\n let opts = options || {};\n let format = opts.format || (posix ? utils$1.toPosixSlashes : null);\n let match = input === glob;\n let output = (match && format) ? format(input) : input;\n if (match === false) {\n output = format ? format(input) : input;\n match = output === glob;\n }\n if (match === false || opts.capture === true) {\n if (opts.matchBase === true || opts.basename === true) {\n match = picomatch.matchBase(input, regex, options, posix);\n }\n else {\n match = regex.exec(output);\n }\n }\n return { isMatch: !!match, match, output };\n};\n/**\n * Match the basename of a filepath.\n *\n * ```js\n * const picomatch = require('picomatch');\n * // picomatch.matchBase(input, glob[, options]);\n * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true\n * ```\n * @param {String} `input` String to test.\n * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).\n * @return {Boolean}\n * @api public\n */\npicomatch.matchBase = (input, glob, options, posix = utils$1.isWindows(options)) => {\n let regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);\n return regex.test(path.basename(input));\n};\n/**\n * Returns true if **any** of the given glob `patterns` match the specified `string`.\n *\n * ```js\n * const picomatch = require('picomatch');\n * // picomatch.isMatch(string, patterns[, options]);\n *\n * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true\n * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false\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).\n * @return {Boolean} Returns true if any patterns match `str`\n * @api public\n */\npicomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);\n/**\n * Parse a glob pattern to create the source string for a regular\n * expression.\n *\n * ```js\n * const picomatch = require('picomatch');\n * const result = picomatch.parse(glob[, 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 a regex source string.\n * @api public\n */\npicomatch.parse = (glob, options) => parse_1$1(glob, options);\n/**\n * Scan a glob pattern to separate the pattern into segments.\n *\n * ```js\n * const picomatch = require('picomatch');\n * // picomatch.scan(input[, options]);\n *\n * const result = picomatch.scan('!./foo/*.js');\n * console.log(result);\n * // { prefix: '!./',\n * // input: '!./foo/*.js',\n * // base: 'foo',\n * // glob: '*.js',\n * // negated: true,\n * // isGlob: true }\n * ```\n * @param {String} `input` Glob pattern to scan.\n * @param {Object} `options`\n * @return {Object} Returns an object with\n * @api public\n */\npicomatch.scan = (input, options) => scan(input, options);\n/**\n * Create a regular expression from a glob pattern.\n *\n * ```js\n * const picomatch = require('picomatch');\n * // picomatch.makeRe(input[, options]);\n *\n * console.log(picomatch.makeRe('*.js'));\n * //=> /^(?:(?!\\.)(?=.)[^/]*?\\.js)$/\n * ```\n * @param {String} `input` 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 */\npicomatch.makeRe = (input, options, returnOutput = false, returnState = false) => {\n if (!input || typeof input !== 'string') {\n throw new TypeError('Expected a non-empty string');\n }\n let opts = options || {};\n let prepend = opts.contains ? '' : '^';\n let append = opts.contains ? '' : '$';\n let state = { negated: false, fastpaths: true };\n let prefix = '';\n let output;\n if (input.startsWith('./')) {\n input = input.slice(2);\n prefix = state.prefix = './';\n }\n if (opts.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {\n output = parse_1$1.fastpaths(input, options);\n }\n if (output === void 0) {\n state = picomatch.parse(input, options);\n state.prefix = prefix + (state.prefix || '');\n output = state.output;\n }\n if (returnOutput === true) {\n return output;\n }\n let source = `${prepend}(?:${output})${append}`;\n if (state && state.negated === true) {\n source = `^(?!${source}).*$`;\n }\n let regex = picomatch.toRegex(source, options);\n if (returnState === true) {\n regex.state = state;\n }\n return regex;\n};\n/**\n * Create a regular expression from the given regex source string.\n *\n * ```js\n * const picomatch = require('picomatch');\n * // picomatch.toRegex(source[, options]);\n *\n * const { output } = picomatch.parse('*.js');\n * console.log(picomatch.toRegex(output));\n * //=> /^(?:(?!\\.)(?=.)[^/]*?\\.js)$/\n * ```\n * @param {String} `source` Regular expression source string.\n * @param {Object} `options`\n * @return {RegExp}\n * @api public\n */\npicomatch.toRegex = (source, options) => {\n try {\n let opts = options || {};\n return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));\n }\n catch (err) {\n if (options && options.debug === true)\n throw err;\n return /$^/;\n }\n};\n/**\n * Picomatch constants.\n * @return {Object}\n */\npicomatch.constants = constants$1;\n/**\n * Expose \"picomatch\"\n */\nvar picomatch_1 = picomatch;\n\nvar picomatch$1 = picomatch_1;\n\nconst isEmptyString = val => typeof val === 'string' && (val === '' || val === './');\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} list List of strings to match.\n * @param {String|Array} 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 */\nconst micromatch = (list, patterns, options) => {\n patterns = [].concat(patterns);\n list = [].concat(list);\n let omit = new Set();\n let keep = new Set();\n let items = new Set();\n let negatives = 0;\n let onResult = state => {\n items.add(state.output);\n if (options && options.onResult) {\n options.onResult(state);\n }\n };\n for (let i = 0; i < patterns.length; i++) {\n let isMatch = picomatch$1(String(patterns[i]), Object.assign({}, options, { onResult }), true);\n let negated = isMatch.state.negated || isMatch.state.negatedExtglob;\n if (negated)\n negatives++;\n for (let item of list) {\n let matched = isMatch(item, true);\n let match = negated ? !matched.isMatch : matched.isMatch;\n if (!match)\n continue;\n if (negated) {\n omit.add(matched.output);\n }\n else {\n omit.delete(matched.output);\n keep.add(matched.output);\n }\n }\n }\n let result = negatives === patterns.length ? [...items] : [...keep];\n let matches = result.filter(item => !omit.has(item));\n if (options && matches.length === 0) {\n if (options.failglob === true) {\n throw new Error(`No matches found for \"${patterns.join(', ')}\"`);\n }\n if (options.nonull === true || options.nullglob === true) {\n return options.unescape ? patterns.map(p => p.replace(/\\\\/g, '')) : patterns;\n }\n }\n return matches;\n};\n/**\n * Backwards compatibility\n */\nmicromatch.match = micromatch;\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 */\nmicromatch.matcher = (pattern, options) => picomatch$1(pattern, options);\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 */\nmicromatch.isMatch = (str, patterns, options) => picomatch$1(patterns, options)(str);\n/**\n * Backwards compatibility\n */\nmicromatch.any = micromatch.isMatch;\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 */\nmicromatch.not = (list, patterns, options = {}) => {\n patterns = [].concat(patterns).map(String);\n let result = new Set();\n let items = [];\n let onResult = state => {\n if (options.onResult)\n options.onResult(state);\n items.push(state.output);\n };\n let matches = micromatch(list, patterns, Object.assign({}, options, { onResult }));\n for (let item of items) {\n if (!matches.includes(item)) {\n result.add(item);\n }\n }\n return [...result];\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 the patter matches any part of `str`.\n * @api public\n */\nmicromatch.contains = (str, pattern, options) => {\n if (typeof str !== 'string') {\n throw new TypeError(`Expected a string: \"${util.inspect(str)}\"`);\n }\n if (Array.isArray(pattern)) {\n return pattern.some(p => micromatch.contains(str, p, options));\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, Object.assign({}, options, { contains: true }));\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 */\nmicromatch.matchKeys = (obj, patterns, options) => {\n if (!utils$1.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)\n res[key] = obj[key];\n return res;\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 match `str`\n * @api public\n */\nmicromatch.some = (list, patterns, options) => {\n let items = [].concat(list);\n for (let pattern of [].concat(patterns)) {\n let isMatch = picomatch$1(String(pattern), options);\n if (items.some(item => isMatch(item))) {\n return true;\n }\n }\n return false;\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 any patterns match `str`\n * @api public\n */\nmicromatch.every = (list, patterns, options) => {\n let items = [].concat(list);\n for (let pattern of [].concat(patterns)) {\n let isMatch = picomatch$1(String(pattern), options);\n if (!items.every(item => isMatch(item))) {\n return false;\n }\n }\n return true;\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 */\nmicromatch.all = (str, patterns, options) => {\n if (typeof str !== 'string') {\n throw new TypeError(`Expected a string: \"${util.inspect(str)}\"`);\n }\n return [].concat(patterns).every(p => picomatch$1(p, options)(str));\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 {Boolean} Returns an array of captures if the input matches the glob pattern, otherwise `null`.\n * @api public\n */\nmicromatch.capture = (glob, input, options) => {\n let posix = utils$1.isWindows(options);\n let regex = picomatch$1.makeRe(String(glob), Object.assign({}, options, { capture: true }));\n let match = regex.exec(posix ? utils$1.toPosixSlashes(input) : input);\n if (match) {\n return match.slice(1).map(v => v === void 0 ? '' : v);\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 */\nmicromatch.makeRe = (...args) => picomatch$1.makeRe(...args);\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 */\nmicromatch.scan = (...args) => picomatch$1.scan(...args);\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(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 */\nmicromatch.parse = (patterns, options) => {\n let res = [];\n for (let pattern of [].concat(patterns || [])) {\n for (let str of braces_1(String(pattern), options)) {\n res.push(picomatch$1.parse(str, options));\n }\n }\n return res;\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 */\nmicromatch.braces = (pattern, options) => {\n if (typeof pattern !== 'string')\n throw new TypeError('Expected a string');\n if ((options && options.nobrace === true) || !/\\{.*\\}/.test(pattern)) {\n return [pattern];\n }\n return braces_1(pattern, options);\n};\n/**\n * Expand braces\n */\nmicromatch.braceExpand = (pattern, options) => {\n if (typeof pattern !== 'string')\n throw new TypeError('Expected a string');\n return micromatch.braces(pattern, Object.assign({}, options, { expand: true }));\n};\n/**\n * Expose micromatch\n */\nvar micromatch_1 = micromatch;\n\nfunction ensureArray(thing) {\n if (Array.isArray(thing))\n return thing;\n if (thing == undefined)\n return [];\n return [thing];\n}\n\nfunction getMatcherString(id, resolutionBase) {\n if (resolutionBase === false) {\n return id;\n }\n return resolve(...(typeof resolutionBase === 'string' ? [resolutionBase, id] : [id]));\n}\nconst createFilter = function createFilter(include, exclude, options) {\n const resolutionBase = options && options.resolve;\n const getMatcher = (id) => {\n return id instanceof RegExp\n ? id\n : {\n test: micromatch_1.matcher(getMatcherString(id, resolutionBase)\n .split(sep)\n .join('/'), { dot: true })\n };\n };\n const includeMatchers = ensureArray(include).map(getMatcher);\n const excludeMatchers = ensureArray(exclude).map(getMatcher);\n return function (id) {\n if (typeof id !== 'string')\n return false;\n if (/\\0/.test(id))\n return false;\n id = id.split(sep).join('/');\n for (let i = 0; i < excludeMatchers.length; ++i) {\n const matcher = excludeMatchers[i];\n if (matcher.test(id))\n return false;\n }\n for (let i = 0; i < includeMatchers.length; ++i) {\n const matcher = includeMatchers[i];\n if (matcher.test(id))\n return true;\n }\n return !includeMatchers.length;\n };\n};\n\nconst reservedWords = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public';\nconst builtins = 'arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl';\nconst forbiddenIdentifiers = new Set(`${reservedWords} ${builtins}`.split(' '));\nforbiddenIdentifiers.add('');\nconst makeLegalIdentifier = function makeLegalIdentifier(str) {\n str = str.replace(/-(\\w)/g, (_, letter) => letter.toUpperCase()).replace(/[^$_a-zA-Z0-9]/g, '_');\n if (/\\d/.test(str[0]) || forbiddenIdentifiers.has(str)) {\n str = `_${str}`;\n }\n return str || '_';\n};\n\nfunction stringify$2(obj) {\n return (JSON.stringify(obj) || 'undefined').replace(/[\\u2028\\u2029]/g, char => `\\\\u${('000' + char.charCodeAt(0).toString(16)).slice(-4)}`);\n}\nfunction serializeArray(arr, indent, baseIndent) {\n let output = '[';\n const separator = indent ? '\\n' + baseIndent + indent : '';\n for (let i = 0; i < arr.length; i++) {\n const key = arr[i];\n output += `${i > 0 ? ',' : ''}${separator}${serialize(key, indent, baseIndent + indent)}`;\n }\n return output + `${indent ? '\\n' + baseIndent : ''}]`;\n}\nfunction serializeObject(obj, indent, baseIndent) {\n let output = '{';\n const separator = indent ? '\\n' + baseIndent + indent : '';\n const keys = Object.keys(obj);\n for (let i = 0; i < keys.length; i++) {\n const key = keys[i];\n const stringKey = makeLegalIdentifier(key) === key ? key : stringify$2(key);\n output += `${i > 0 ? ',' : ''}${separator}${stringKey}:${indent ? ' ' : ''}${serialize(obj[key], indent, baseIndent + indent)}`;\n }\n return output + `${indent ? '\\n' + baseIndent : ''}}`;\n}\nfunction serialize(obj, indent, baseIndent) {\n if (obj === Infinity)\n return 'Infinity';\n if (obj === -Infinity)\n return '-Infinity';\n if (obj === 0 && 1 / obj === -Infinity)\n return '-0';\n if (obj instanceof Date)\n return 'new Date(' + obj.getTime() + ')';\n if (obj instanceof RegExp)\n return obj.toString();\n if (obj !== obj)\n return 'NaN';\n if (Array.isArray(obj))\n return serializeArray(obj, indent, baseIndent);\n if (obj === null)\n return 'null';\n if (typeof obj === 'object')\n return serializeObject(obj, indent, baseIndent);\n return stringify$2(obj);\n}\nconst dataToEsm = function dataToEsm(data, options = {}) {\n const t = options.compact ? '' : 'indent' in options ? options.indent : '\\t';\n const _ = options.compact ? '' : ' ';\n const n = options.compact ? '' : '\\n';\n const declarationType = options.preferConst ? 'const' : 'var';\n if (options.namedExports === false ||\n typeof data !== 'object' ||\n Array.isArray(data) ||\n data instanceof Date ||\n data instanceof RegExp ||\n data === null) {\n const code = serialize(data, options.compact ? null : t, '');\n const __ = _ || (/^[{[\\-\\/]/.test(code) ? '' : ' ');\n return `export default${__}${code};`;\n }\n let namedExportCode = '';\n const defaultExportRows = [];\n const dataKeys = Object.keys(data);\n for (let i = 0; i < dataKeys.length; i++) {\n const key = dataKeys[i];\n if (key === makeLegalIdentifier(key)) {\n if (options.objectShorthand)\n defaultExportRows.push(key);\n else\n defaultExportRows.push(`${key}:${_}${key}`);\n namedExportCode += `export ${declarationType} ${key}${_}=${_}${serialize(data[key], options.compact ? null : t, '')};${n}`;\n }\n else {\n defaultExportRows.push(`${stringify$2(key)}:${_}${serialize(data[key], options.compact ? null : t, '')}`);\n }\n }\n return (namedExportCode + `export default${_}{${n}${t}${defaultExportRows.join(`,${n}${t}`)}${n}};${n}`);\n};\n\nexport { addExtension, attachScopes, createFilter, dataToEsm, extractAssignedNames, makeLegalIdentifier };\n"],"names":["path","resolve","sep"],"mappings":"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"} \ No newline at end of file diff --git a/package-lock.json b/package-lock.json index 0e3fe0f..1d35f9c 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,6 +1,6 @@ { "name": "@lopatnov/rollup-plugin-uglify", - "version": "1.0.1", + "version": "1.1.0", "lockfileVersion": 1, "requires": true, "dependencies": { @@ -504,15 +504,6 @@ "typescript": "*" } }, - "@types/uglify-js": { - "version": "3.0.4", - "resolved": "https://registry.npmjs.org/@types/uglify-js/-/uglify-js-3.0.4.tgz", - "integrity": "sha512-SudIN9TRJ+v8g5pTG8RRCqfqTMNqgWCKKd3vtynhGzkIIjxaicNAMuY5TRadJ6tzDu3Dotf3ngaMILtmOdmWEQ==", - "dev": true, - "requires": { - "source-map": "^0.6.1" - } - }, "@types/yargs": { "version": "13.0.3", "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-13.0.3.tgz", @@ -1345,8 +1336,7 @@ "estree-walker": { "version": "0.6.1", "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-0.6.1.tgz", - "integrity": "sha512-SqmZANLWS0mnatqbSfRP5g8OXZC12Fgg1IwNtLsyHDzJizORW4khDfjPqJZsemPWBB2uqykUah5YpQ6epsqC/w==", - "dev": true + "integrity": "sha512-SqmZANLWS0mnatqbSfRP5g8OXZC12Fgg1IwNtLsyHDzJizORW4khDfjPqJZsemPWBB2uqykUah5YpQ6epsqC/w==" }, "esutils": { "version": "2.0.3", @@ -4280,7 +4270,6 @@ "version": "2.8.2", "resolved": "https://registry.npmjs.org/rollup-pluginutils/-/rollup-pluginutils-2.8.2.tgz", "integrity": "sha512-EEp9NhnUkwY8aif6bxgovPHMoMoNr2FulJziTndpt5H9RdwC47GSGuII9XxpSdzVGM0GWrNPHV6ie1LTNJPaLQ==", - "dev": true, "requires": { "estree-walker": "^0.6.1" } diff --git a/package.json b/package.json index f066c7b..1f73da0 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "@lopatnov/rollup-plugin-uglify", - "version": "1.1.0", + "version": "1.2.0", "description": "Rollup plugin. Javascript code minifier", "author": "lopatnov", "license": "Apache-2.0", @@ -22,7 +22,7 @@ "build": "rollup -c", "watch": "rollup -cw", "test": "jest", - "prepare": "npm i --no-save --no-package-lock uglify-js", + "prepare": "npm i --no-save --no-package-lock terser", "configure-npm": "node ./set-registry.js -s https://registry.npmjs.org", "configure-gpr": "node ./set-registry.js -s https://npm.pkg.github.com" }, @@ -33,7 +33,6 @@ "@types/jest": "^24.0.23", "@types/rollup": "^0.54.0", "@types/typescript": "^2.0.0", - "@types/uglify-js": "^3.0.4", "jest": "^24.9.0", "jest-config": "^24.9.0", "rollup": "^1.27.8", @@ -46,7 +45,10 @@ "typescript": "^3.7.3" }, "peerDependencies": { - "rollup": "^1.27.8", - "uglify-js": "^3.7.1" + "rollup": ">=1.0.0", + "terser": "^4.4.2" + }, + "dependencies": { + "rollup-pluginutils": "^2.8.2" } } diff --git a/rollup.config.js b/rollup.config.js index fc72ede..26432aa 100644 --- a/rollup.config.js +++ b/rollup.config.js @@ -5,33 +5,32 @@ import resolve from "rollup-plugin-node-resolve"; import pkg from "./package.json"; -export default - { - input: pkg.source, - output: [ - { - file: pkg.main, - format: "cjs", - name: pkg.umdName, - sourcemap: true - }, - { - file: pkg.module, - format: "esm", - sourcemap: true - } - ], - external: [ - ...Object.keys(pkg.devDependencies || {}), - ...Object.keys(pkg.peerDependencies || {}) - ], +export default { + input: pkg.source, + output: [ + { + file: pkg.main, + format: "umd", + name: pkg.umdName, + sourcemap: true + }, + { + file: pkg.module, + format: "esm", + sourcemap: true + } + ], + external: [ + ...Object.keys(pkg.devDependencies || {}), + ...Object.keys(pkg.peerDependencies || {}) + ], - plugins: [ - json(), - typescript({ - typescript: require("typescript") - }), - resolve(), - commonjs() - ] - }; + plugins: [ + json(), + typescript({ + typescript: require("typescript") + }), + resolve(), + commonjs() + ] +}; diff --git a/src/plugin.ts b/src/plugin.ts index e1e46a0..e0b8037 100644 --- a/src/plugin.ts +++ b/src/plugin.ts @@ -1,14 +1,26 @@ -import { minify, MinifyOptions } from 'uglify-js'; +import { Plugin } from 'rollup'; +import { minify, MinifyOptions } from "terser"; +import { createFilter } from "rollup-pluginutils"; -export default function uglify (options: MinifyOptions = {}) { +export interface IUglifyOptions extends MinifyOptions { + include?: string | RegExp; + exclude?: string | RegExp; +} + +function uglify(options: IUglifyOptions = {}): Plugin { + const filter = createFilter(options.include, options.exclude); return { - name: 'uglify', - transform(code: any) { - if (typeof options.sourceMap === 'undefined') { + name: "uglify", + transform(code: any, id: any) { + if (!filter(id)) { + return; + } + + if (typeof options.sourceMap === "undefined") { options.sourceMap = true; } - if (typeof options.warnings === 'undefined') { + if (typeof options.warnings === "undefined") { options.warnings = true; } @@ -19,7 +31,7 @@ export default function uglify (options: MinifyOptions = {}) { } if (result.warnings) { - result.warnings.forEach((warning) => { + result.warnings.forEach(warning => { this.warn(warning); }); } @@ -27,7 +39,9 @@ export default function uglify (options: MinifyOptions = {}) { return { code: result.code, map: result.map - }; + } as any; } }; -} \ No newline at end of file +} + +export default uglify; diff --git a/tsconfig.json b/tsconfig.json index 2390f0c..6884df3 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -2,7 +2,7 @@ "compilerOptions": { "declaration": true, "declarationDir": "./dist", - "module": "es6", + "module": "ES2015", "noImplicitAny": true, "outDir": "./dist", "target": "es5",