{"version":3,"file":"index.mjs","sources":["../src/constants.ts","../src/jsx.ts","../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/utils.js","../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/stringify.js","../node_modules/.pnpm/is-number@7.0.0/node_modules/is-number/index.js","../node_modules/.pnpm/to-regex-range@5.0.1/node_modules/to-regex-range/index.js","../node_modules/.pnpm/fill-range@7.1.1/node_modules/fill-range/index.js","../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/parse.js","../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/constants.js","../node_modules/.pnpm/braces@3.0.3/node_modules/braces/index.js","../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/compile.js","../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/expand.js","../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/constants.js","../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/utils.js","../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/picomatch.js","../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/scan.js","../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/parse.js","../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/index.js","../node_modules/.pnpm/micromatch@4.0.8/node_modules/micromatch/index.js","../src/index.ts","../src/vue.ts"],"sourcesContent":["export const EVENT_TAGS = ['a', 'button', 'input', 'textarea', 'select', 'option'];\n\nexport const DIRECTIVE_NAMES = [\n  '@click',\n  '@change',\n  '@input',\n  '@focus',\n  '@blur',\n  '@mouseover',\n  '@mouseout',\n  '@mouseenter',\n  '@mouseleave',\n  '@mousemove',\n  '@mouseup',\n  '@mousedown',\n  '@mousewheel',\n  '@keydown',\n  '@keyup',\n  '@keypress',\n];\n","import fPath from 'path';\nimport * as babelParser from '@babel/parser';\nimport traverseModle, { NodePath } from '@babel/traverse';\nimport generateModule from '@babel/generator';\nimport * as t from '@babel/types';\nimport { TTransformer } from './type';\nimport { EVENT_TAGS, DIRECTIVE_NAMES } from './constants';\n\n// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-ignore\nconst traverse = (traverseModle.default || traverseModle) as typeof traverseModle;\n// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-ignore\nconst generate = (generateModule.default || generateModule) as typeof generateModule;\n\n// Helper function to check if element has event attributes\nconst hasEvent = (path: NodePath<t.JSXOpeningElement>): boolean => {\n  const tagName = path.node.name.type === 'JSXIdentifier' ? path.node.name.name : '';\n\n  // Check if it's an event tag\n  if (EVENT_TAGS.includes(tagName.toLowerCase())) {\n    return true;\n  }\n\n  // Check if it has event handlers (onClick, onChange, etc.)\n  return path.node.attributes.some((attr) => {\n    if (t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name)) {\n      const attrName = attr.name.name;\n      return attrName.startsWith('on') && attrName.length > 2 && attrName[2] === attrName[2].toUpperCase();\n    }\n    return false;\n  });\n};\n\n// --- JSX/TSX 处理 ---\nexport const transformJsx: TTransformer = (code: string, id: string, attributes: string[]) => {\n  // 只在测试构建时执行\n  const isTestBuild = process.env.NODE_ENV === 'test' || process.env.BUILD_MODE === 'test' || process.env.VITE_TEST_BUILD === 'true';\n  if (!isTestBuild) {\n    return { code, map: null };\n  }\n\n  const ast = babelParser.parse(code, {\n    sourceType: 'module',\n    plugins: ['jsx', 'typescript', 'classProperties', 'decorators-legacy'],\n  });\n\n  // 获取相对于 src 上一层的路径\n  const projectRoot = fPath.resolve(process.cwd(), '..');\n  const relativePath = fPath.relative(projectRoot, id);\n\n  const errorMaps = new Map<string, string>();\n\n  traverse(ast, {\n    JSXOpeningElement(path) {\n      const line = path.node.loc?.start.line;\n      const StartColumn = path.node.loc?.start.column;\n      if (!line || StartColumn === undefined) return;\n\n      // 检查是否是 Fragment\n      const isFragment =\n        // 检查 <Fragment>\n        (t.isJSXIdentifier(path.node.name) && path.node.name.name === 'Fragment') ||\n        // 检查 <React.Fragment>\n        (t.isJSXMemberExpression(path.node.name) &&\n          t.isJSXIdentifier(path.node.name.object) &&\n          path.node.name.object.name === 'React' &&\n          t.isJSXIdentifier(path.node.name.property) &&\n          path.node.name.property.name === 'Fragment');\n\n      if (isFragment) return;\n\n      // 检查是否有事件处理器\n      const isHasEvent = hasEvent(path);\n      if (isHasEvent) {\n        const existingAttributes = path.node.attributes\n          .filter((attr): attr is t.JSXAttribute => t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name))\n          .map((attr) => (attr.name as t.JSXIdentifier).name);\n\n        const hasRequiredAttributes = attributes.filter((attr) => existingAttributes.includes(attr));\n\n        if (hasRequiredAttributes.length !== attributes.length) {\n          const missingAttributes = attributes.filter((attr) => !existingAttributes.includes(attr));\n          const tagName = path.node.name.type === 'JSXIdentifier' ? path.node.name.name : '';\n          errorMaps.set(\n            relativePath,\n            `${missingAttributes.join(',')} is required for ${tagName} in ${relativePath}:${line}:${StartColumn}`\n          );\n        }\n      }\n    },\n  });\n\n  const output = generate(ast, {}, code);\n\n  return {\n    code: output.code,\n    map: output.map,\n    errors: Array.from(errorMaps.values()),\n  };\n};\n","'use strict';\n\nexports.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/**\n * Find a node of the given type\n */\n\nexports.find = (node, type) => node.nodes.find(node => node.type === type);\n\n/**\n * Find a node of the given type\n */\n\nexports.exceedsLimit = (min, max, step = 1, limit) => {\n  if (limit === false) return false;\n  if (!exports.isInteger(min) || !exports.isInteger(max)) return false;\n  return ((Number(max) - Number(min)) / Number(step)) >= limit;\n};\n\n/**\n * Escape the given node with '\\\\' before node.value\n */\n\nexports.escapeNode = (block, n = 0, type) => {\n  const node = block.nodes[n];\n  if (!node) return;\n\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/**\n * Returns true if the given brace node should be enclosed in literal braces\n */\n\nexports.encloseBrace = node => {\n  if (node.type !== 'brace') 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/**\n * Returns true if a brace node is invalid.\n */\n\nexports.isInvalidBrace = block => {\n  if (block.type !== 'brace') return false;\n  if (block.invalid === true || block.dollar) 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/**\n * Returns true if a node is an open or close node\n */\n\nexports.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/**\n * Reduce an array of text nodes.\n */\n\nexports.reduce = nodes => nodes.reduce((acc, node) => {\n  if (node.type === 'text') acc.push(node.value);\n  if (node.type === 'range') node.type = 'text';\n  return acc;\n}, []);\n\n/**\n * Flatten an array\n */\n\nexports.flatten = (...args) => {\n  const result = [];\n\n  const flat = arr => {\n    for (let i = 0; i < arr.length; i++) {\n      const ele = arr[i];\n\n      if (Array.isArray(ele)) {\n        flat(ele);\n        continue;\n      }\n\n      if (ele !== undefined) {\n        result.push(ele);\n      }\n    }\n    return result;\n  };\n\n  flat(args);\n  return result;\n};\n","'use strict';\n\nconst utils = require('./utils');\n\nmodule.exports = (ast, options = {}) => {\n  const stringify = (node, parent = {}) => {\n    const invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent);\n    const invalidNode = node.invalid === true && options.escapeInvalid === true;\n    let output = '';\n\n    if (node.value) {\n      if ((invalidBlock || invalidNode) && utils.isOpenOrClose(node)) {\n        return '\\\\' + node.value;\n      }\n      return node.value;\n    }\n\n    if (node.value) {\n      return node.value;\n    }\n\n    if (node.nodes) {\n      for (const child of node.nodes) {\n        output += stringify(child);\n      }\n    }\n    return output;\n  };\n\n  return stringify(ast);\n};\n\n","/*!\n * is-number <https://github.com/jonschlinkert/is-number>\n *\n * Copyright (c) 2014-present, Jon Schlinkert.\n * Released under the MIT License.\n */\n\n'use strict';\n\nmodule.exports = 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","/*!\n * to-regex-range <https://github.com/micromatch/to-regex-range>\n *\n * Copyright (c) 2015-present, Jon Schlinkert.\n * Released under the MIT License.\n */\n\n'use strict';\n\nconst isNumber = require('is-number');\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\n  if (max === void 0 || min === max) {\n    return String(min);\n  }\n\n  if (isNumber(max) === false) {\n    throw new TypeError('toRegexRange: expected the second argument to be a number.');\n  }\n\n  let opts = { relaxZeros: true, ...options };\n  if (typeof opts.strictZeros === 'boolean') {\n    opts.relaxZeros = opts.strictZeros === false;\n  }\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\n  if (toRegexRange.cache.hasOwnProperty(cacheKey)) {\n    return toRegexRange.cache[cacheKey].result;\n  }\n\n  let a = Math.min(min, max);\n  let b = Math.max(min, max);\n\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\n  let isPadded = hasPadding(min) || hasPadding(max);\n  let state = { min, max, a, b };\n  let positives = [];\n  let negatives = [];\n\n  if (isPadded) {\n    state.isPadded = isPadded;\n    state.maxLen = String(state.max).length;\n  }\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\n  if (b >= 0) {\n    positives = splitToPatterns(a, b, state, opts);\n  }\n\n  state.negatives = negatives;\n  state.positives = positives;\n  state.result = collatePatterns(negatives, positives, opts);\n\n  if (opts.capture === true) {\n    state.result = `(${state.result})`;\n  } else if (opts.wrap !== false && (positives.length + negatives.length) > 1) {\n    state.result = `(?:${state.result})`;\n  }\n\n  toRegexRange.cache[cacheKey] = state;\n  return state.result;\n};\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}\n\nfunction splitToRanges(min, max) {\n  let nines = 1;\n  let zeros = 1;\n\n  let stop = countNines(min, nines);\n  let stops = new Set([max]);\n\n  while (min <= stop && stop <= max) {\n    stops.add(stop);\n    nines += 1;\n    stop = countNines(min, nines);\n  }\n\n  stop = countZeros(max + 1, zeros) - 1;\n\n  while (min < stop && stop <= max) {\n    stops.add(stop);\n    zeros += 1;\n    stop = countZeros(max + 1, zeros) - 1;\n  }\n\n  stops = [...stops];\n  stops.sort(compare);\n  return stops;\n}\n\n/**\n * Convert a range to a regex pattern\n * @param {Number} `start`\n * @param {Number} `stop`\n * @return {String}\n */\n\nfunction rangeToPattern(start, stop, options) {\n  if (start === stop) {\n    return { pattern: start, count: [], digits: 0 };\n  }\n\n  let zipped = zip(start, stop);\n  let digits = zipped.length;\n  let pattern = '';\n  let count = 0;\n\n  for (let i = 0; i < digits; i++) {\n    let [startDigit, stopDigit] = zipped[i];\n\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\n  if (count) {\n    pattern += options.shorthand === true ? '\\\\d' : '[0-9]';\n  }\n\n  return { pattern, count: [count], digits };\n}\n\nfunction splitToPatterns(min, max, tok, options) {\n  let ranges = splitToRanges(min, max);\n  let tokens = [];\n  let start = min;\n  let prev;\n\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\n    if (!tok.isPadded && prev && prev.pattern === obj.pattern) {\n      if (prev.count.length > 1) {\n        prev.count.pop();\n      }\n\n      prev.count.push(obj.count[0]);\n      prev.string = prev.pattern + toQuantifier(prev.count);\n      start = max + 1;\n      continue;\n    }\n\n    if (tok.isPadded) {\n      zeros = padZeros(max, tok, options);\n    }\n\n    obj.string = zeros + obj.pattern + toQuantifier(obj.count);\n    tokens.push(obj);\n    start = max + 1;\n    prev = obj;\n  }\n\n  return tokens;\n}\n\nfunction filterPatterns(arr, comparison, prefix, intersection, options) {\n  let result = [];\n\n  for (let ele of arr) {\n    let { string } = ele;\n\n    // only push if _both_ are negative...\n    if (!intersection && !contains(comparison, 'string', string)) {\n      result.push(prefix + string);\n    }\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/**\n * Zip strings\n */\n\nfunction zip(a, b) {\n  let arr = [];\n  for (let i = 0; i < a.length; i++) arr.push([a[i], b[i]]);\n  return arr;\n}\n\nfunction compare(a, b) {\n  return a > b ? 1 : b > a ? -1 : 0;\n}\n\nfunction contains(arr, key, val) {\n  return arr.some(ele => ele[key] === val);\n}\n\nfunction countNines(min, len) {\n  return Number(String(min).slice(0, -len) + '9'.repeat(len));\n}\n\nfunction countZeros(integer, zeros) {\n  return integer - (integer % Math.pow(10, zeros));\n}\n\nfunction toQuantifier(digits) {\n  let [start = 0, stop = ''] = digits;\n  if (stop || start > 1) {\n    return `{${start + (stop ? ',' + stop : '')}}`;\n  }\n  return '';\n}\n\nfunction toCharacterClass(a, b, options) {\n  return `[${a}${(b - a === 1) ? '' : '-'}${b}]`;\n}\n\nfunction hasPadding(str) {\n  return /^-?(0+)\\d/.test(str);\n}\n\nfunction padZeros(value, tok, options) {\n  if (!tok.isPadded) {\n    return value;\n  }\n\n  let diff = Math.abs(tok.maxLen - String(value).length);\n  let relax = options.relaxZeros !== false;\n\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/**\n * Cache\n */\n\ntoRegexRange.cache = {};\ntoRegexRange.clearCache = () => (toRegexRange.cache = {});\n\n/**\n * Expose `toRegexRange`\n */\n\nmodule.exports = toRegexRange;\n","/*!\n * fill-range <https://github.com/jonschlinkert/fill-range>\n *\n * Copyright (c) 2014-present, Jon Schlinkert.\n * Licensed under the MIT License.\n */\n\n'use strict';\n\nconst util = require('util');\nconst toRegexRange = require('to-regex-range');\n\nconst isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);\n\nconst transform = toNumber => {\n  return value => toNumber === true ? Number(value) : String(value);\n};\n\nconst isValidValue = value => {\n  return typeof value === 'number' || (typeof value === 'string' && value !== '');\n};\n\nconst isNumber = num => Number.isInteger(+num);\n\nconst zeros = input => {\n  let value = `${input}`;\n  let index = -1;\n  if (value[0] === '-') value = value.slice(1);\n  if (value === '0') return false;\n  while (value[++index] === '0');\n  return index > 0;\n};\n\nconst stringify = (start, end, options) => {\n  if (typeof start === 'string' || typeof end === 'string') {\n    return true;\n  }\n  return options.stringify === true;\n};\n\nconst pad = (input, maxLength, toNumber) => {\n  if (maxLength > 0) {\n    let dash = input[0] === '-' ? '-' : '';\n    if (dash) 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};\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) input = '0' + input;\n  return negative ? ('-' + input) : input;\n};\n\nconst toSequence = (parts, options, maxLen) => {\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\n  let prefix = options.capture ? '' : '?:';\n  let positives = '';\n  let negatives = '';\n  let result;\n\n  if (parts.positives.length) {\n    positives = parts.positives.map(v => toMaxLen(String(v), maxLen)).join('|');\n  }\n\n  if (parts.negatives.length) {\n    negatives = `-(${prefix}${parts.negatives.map(v => toMaxLen(String(v), maxLen)).join('|')})`;\n  }\n\n  if (positives && negatives) {\n    result = `${positives}|${negatives}`;\n  } else {\n    result = positives || negatives;\n  }\n\n  if (options.wrap) {\n    return `(${prefix}${result})`;\n  }\n\n  return result;\n};\n\nconst toRange = (a, b, isNumbers, options) => {\n  if (isNumbers) {\n    return toRegexRange(a, b, { wrap: false, ...options });\n  }\n\n  let start = String.fromCharCode(a);\n  if (a === b) return start;\n\n  let stop = String.fromCharCode(b);\n  return `[${start}-${stop}]`;\n};\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(start, end, options);\n};\n\nconst rangeError = (...args) => {\n  return new RangeError('Invalid range arguments: ' + util.inspect(...args));\n};\n\nconst invalidRange = (start, end, options) => {\n  if (options.strictRanges === true) throw rangeError([start, end]);\n  return [];\n};\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};\n\nconst fillNumbers = (start, end, step = 1, options = {}) => {\n  let a = Number(start);\n  let b = Number(end);\n\n  if (!Number.isInteger(a) || !Number.isInteger(b)) {\n    if (options.strictRanges === true) throw rangeError([start, end]);\n    return [];\n  }\n\n  // fix negative zero\n  if (a === 0) a = 0;\n  if (b === 0) b = 0;\n\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\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(start, end, options) === false;\n  let format = options.transform || transform(toNumber);\n\n  if (options.toRegex && step === 1) {\n    return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);\n  }\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\n  while (descending ? a >= b : a <= b) {\n    if (options.toRegex === true && step > 1) {\n      push(a);\n    } else {\n      range.push(pad(format(a, index), maxLen, toNumber));\n    }\n    a = descending ? a - step : a + step;\n    index++;\n  }\n\n  if (options.toRegex === true) {\n    return step > 1\n      ? toSequence(parts, options, maxLen)\n      : toRegex(range, null, { wrap: false, ...options });\n  }\n\n  return range;\n};\n\nconst fillLetters = (start, end, step = 1, options = {}) => {\n  if ((!isNumber(start) && start.length > 1) || (!isNumber(end) && end.length > 1)) {\n    return invalidRange(start, end, options);\n  }\n\n  let format = options.transform || (val => String.fromCharCode(val));\n  let a = `${start}`.charCodeAt(0);\n  let b = `${end}`.charCodeAt(0);\n\n  let descending = a > b;\n  let min = Math.min(a, b);\n  let max = Math.max(a, b);\n\n  if (options.toRegex && step === 1) {\n    return toRange(min, max, false, options);\n  }\n\n  let range = [];\n  let index = 0;\n\n  while (descending ? a >= b : a <= b) {\n    range.push(format(a, index));\n    a = descending ? a - step : a + step;\n    index++;\n  }\n\n  if (options.toRegex === true) {\n    return toRegex(range, null, { wrap: false, options });\n  }\n\n  return range;\n};\n\nconst fill = (start, end, step, options = {}) => {\n  if (end == null && isValidValue(start)) {\n    return [start];\n  }\n\n  if (!isValidValue(start) || !isValidValue(end)) {\n    return invalidRange(start, end, options);\n  }\n\n  if (typeof step === 'function') {\n    return fill(start, end, 1, { transform: step });\n  }\n\n  if (isObject(step)) {\n    return fill(start, end, 0, step);\n  }\n\n  let opts = { ...options };\n  if (opts.capture === true) opts.wrap = true;\n  step = step || opts.step || 1;\n\n  if (!isNumber(step)) {\n    if (step != null && !isObject(step)) return invalidStep(step, opts);\n    return fill(start, end, 1, step);\n  }\n\n  if (isNumber(start) && isNumber(end)) {\n    return fillNumbers(start, end, step, opts);\n  }\n\n  return fillLetters(start, end, Math.max(Math.abs(step), 1), opts);\n};\n\nmodule.exports = fill;\n","'use strict';\n\nconst stringify = require('./stringify');\n\n/**\n * Constants\n */\n\nconst {\n  MAX_LENGTH,\n  CHAR_BACKSLASH, /* \\ */\n  CHAR_BACKTICK, /* ` */\n  CHAR_COMMA, /* , */\n  CHAR_DOT, /* . */\n  CHAR_LEFT_PARENTHESES, /* ( */\n  CHAR_RIGHT_PARENTHESES, /* ) */\n  CHAR_LEFT_CURLY_BRACE, /* { */\n  CHAR_RIGHT_CURLY_BRACE, /* } */\n  CHAR_LEFT_SQUARE_BRACKET, /* [ */\n  CHAR_RIGHT_SQUARE_BRACKET, /* ] */\n  CHAR_DOUBLE_QUOTE, /* \" */\n  CHAR_SINGLE_QUOTE, /* ' */\n  CHAR_NO_BREAK_SPACE,\n  CHAR_ZERO_WIDTH_NOBREAK_SPACE\n} = require('./constants');\n\n/**\n * parse\n */\n\nconst parse = (input, options = {}) => {\n  if (typeof input !== 'string') {\n    throw new TypeError('Expected a string');\n  }\n\n  const opts = options || {};\n  const 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\n  const ast = { type: 'root', input, nodes: [] };\n  const stack = [ast];\n  let block = ast;\n  let prev = ast;\n  let brackets = 0;\n  const length = input.length;\n  let index = 0;\n  let depth = 0;\n  let value;\n\n  /**\n   * Helpers\n   */\n\n  const advance = () => input[index++];\n  const push = node => {\n    if (node.type === 'text' && prev.type === 'dot') {\n      prev.type = 'text';\n    }\n\n    if (prev && prev.type === 'text' && node.type === 'text') {\n      prev.value += node.value;\n      return;\n    }\n\n    block.nodes.push(node);\n    node.parent = block;\n    node.prev = prev;\n    prev = node;\n    return node;\n  };\n\n  push({ type: 'bos' });\n\n  while (index < length) {\n    block = stack[stack.length - 1];\n    value = advance();\n\n    /**\n     * Invalid chars\n     */\n\n    if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) {\n      continue;\n    }\n\n    /**\n     * Escaped chars\n     */\n\n    if (value === CHAR_BACKSLASH) {\n      push({ type: 'text', value: (options.keepEscaping ? value : '') + advance() });\n      continue;\n    }\n\n    /**\n     * Right square bracket (literal): ']'\n     */\n\n    if (value === CHAR_RIGHT_SQUARE_BRACKET) {\n      push({ type: 'text', value: '\\\\' + value });\n      continue;\n    }\n\n    /**\n     * Left square bracket: '['\n     */\n\n    if (value === CHAR_LEFT_SQUARE_BRACKET) {\n      brackets++;\n\n      let next;\n\n      while (index < length && (next = advance())) {\n        value += next;\n\n        if (next === CHAR_LEFT_SQUARE_BRACKET) {\n          brackets++;\n          continue;\n        }\n\n        if (next === CHAR_BACKSLASH) {\n          value += advance();\n          continue;\n        }\n\n        if (next === CHAR_RIGHT_SQUARE_BRACKET) {\n          brackets--;\n\n          if (brackets === 0) {\n            break;\n          }\n        }\n      }\n\n      push({ type: 'text', value });\n      continue;\n    }\n\n    /**\n     * Parentheses\n     */\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\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    /**\n     * Quotes: '|\"|`\n     */\n\n    if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) {\n      const open = value;\n      let next;\n\n      if (options.keepQuotes !== true) {\n        value = '';\n      }\n\n      while (index < length && (next = advance())) {\n        if (next === CHAR_BACKSLASH) {\n          value += next + advance();\n          continue;\n        }\n\n        if (next === open) {\n          if (options.keepQuotes === true) value += next;\n          break;\n        }\n\n        value += next;\n      }\n\n      push({ type: 'text', value });\n      continue;\n    }\n\n    /**\n     * Left curly brace: '{'\n     */\n\n    if (value === CHAR_LEFT_CURLY_BRACE) {\n      depth++;\n\n      const dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true;\n      const brace = {\n        type: 'brace',\n        open: true,\n        close: false,\n        dollar,\n        depth,\n        commas: 0,\n        ranges: 0,\n        nodes: []\n      };\n\n      block = push(brace);\n      stack.push(block);\n      push({ type: 'open', value });\n      continue;\n    }\n\n    /**\n     * Right curly brace: '}'\n     */\n\n    if (value === CHAR_RIGHT_CURLY_BRACE) {\n      if (block.type !== 'brace') {\n        push({ type: 'text', value });\n        continue;\n      }\n\n      const type = 'close';\n      block = stack.pop();\n      block.close = true;\n\n      push({ type, value });\n      depth--;\n\n      block = stack[stack.length - 1];\n      continue;\n    }\n\n    /**\n     * Comma: ','\n     */\n\n    if (value === CHAR_COMMA && depth > 0) {\n      if (block.ranges > 0) {\n        block.ranges = 0;\n        const open = block.nodes.shift();\n        block.nodes = [open, { type: 'text', value: stringify(block) }];\n      }\n\n      push({ type: 'comma', value });\n      block.commas++;\n      continue;\n    }\n\n    /**\n     * Dot: '.'\n     */\n\n    if (value === CHAR_DOT && depth > 0 && block.commas === 0) {\n      const siblings = block.nodes;\n\n      if (depth === 0 || siblings.length === 0) {\n        push({ type: 'text', value });\n        continue;\n      }\n\n      if (prev.type === 'dot') {\n        block.range = [];\n        prev.value += value;\n        prev.type = 'range';\n\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\n        block.ranges++;\n        block.args = [];\n        continue;\n      }\n\n      if (prev.type === 'range') {\n        siblings.pop();\n\n        const before = siblings[siblings.length - 1];\n        before.value += prev.value + value;\n        prev = before;\n        block.ranges--;\n        continue;\n      }\n\n      push({ type: 'dot', value });\n      continue;\n    }\n\n    /**\n     * Text\n     */\n\n    push({ type: 'text', value });\n  }\n\n  // Mark imbalanced braces and brackets as invalid\n  do {\n    block = stack.pop();\n\n    if (block.type !== 'root') {\n      block.nodes.forEach(node => {\n        if (!node.nodes) {\n          if (node.type === 'open') node.isOpen = true;\n          if (node.type === 'close') node.isClose = true;\n          if (!node.nodes) node.type = 'text';\n          node.invalid = true;\n        }\n      });\n\n      // get the location of the block on parent.nodes (block's siblings)\n      const parent = stack[stack.length - 1];\n      const 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\n  push({ type: 'eos' });\n  return ast;\n};\n\nmodule.exports = parse;\n","'use strict';\n\nmodule.exports = {\n  MAX_LENGTH: 10000,\n\n  // Digits\n  CHAR_0: '0', /* 0 */\n  CHAR_9: '9', /* 9 */\n\n  // Alphabet chars.\n  CHAR_UPPERCASE_A: 'A', /* A */\n  CHAR_LOWERCASE_A: 'a', /* a */\n  CHAR_UPPERCASE_Z: 'Z', /* Z */\n  CHAR_LOWERCASE_Z: 'z', /* z */\n\n  CHAR_LEFT_PARENTHESES: '(', /* ( */\n  CHAR_RIGHT_PARENTHESES: ')', /* ) */\n\n  CHAR_ASTERISK: '*', /* * */\n\n  // Non-alphabetic chars.\n  CHAR_AMPERSAND: '&', /* & */\n  CHAR_AT: '@', /* @ */\n  CHAR_BACKSLASH: '\\\\', /* \\ */\n  CHAR_BACKTICK: '`', /* ` */\n  CHAR_CARRIAGE_RETURN: '\\r', /* \\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', /* \\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 */\n  CHAR_NO_BREAK_SPACE: '\\u00A0', /* \\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', /* \\t */\n  CHAR_UNDERSCORE: '_', /* _ */\n  CHAR_VERTICAL_LINE: '|', /* | */\n  CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\\uFEFF' /* \\uFEFF */\n};\n","'use strict';\n\nconst stringify = require('./lib/stringify');\nconst compile = require('./lib/compile');\nconst expand = require('./lib/expand');\nconst parse = require('./lib/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 */\n\nconst braces = (input, options = {}) => {\n  let output = [];\n\n  if (Array.isArray(input)) {\n    for (const pattern of input) {\n      const result = braces.create(pattern, options);\n      if (Array.isArray(result)) {\n        output.push(...result);\n      } else {\n        output.push(result);\n      }\n    }\n  } else {\n    output = [].concat(braces.create(input, options));\n  }\n\n  if (options && options.expand === true && options.nodupes === true) {\n    output = [...new Set(output)];\n  }\n  return output;\n};\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 */\n\nbraces.parse = (input, options = {}) => parse(input, options);\n\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 */\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/**\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 */\n\nbraces.compile = (input, options = {}) => {\n  if (typeof input === 'string') {\n    input = braces.parse(input, options);\n  }\n  return compile(input, options);\n};\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 */\n\nbraces.expand = (input, options = {}) => {\n  if (typeof input === 'string') {\n    input = braces.parse(input, options);\n  }\n\n  let result = expand(input, options);\n\n  // filter out empty strings if specified\n  if (options.noempty === true) {\n    result = result.filter(Boolean);\n  }\n\n  // filter out duplicates if specified\n  if (options.nodupes === true) {\n    result = [...new Set(result)];\n  }\n\n  return result;\n};\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 */\n\nbraces.create = (input, options = {}) => {\n  if (input === '' || input.length < 3) {\n    return [input];\n  }\n\n  return options.expand !== true\n    ? braces.compile(input, options)\n    : braces.expand(input, options);\n};\n\n/**\n * Expose \"braces\"\n */\n\nmodule.exports = braces;\n","'use strict';\n\nconst fill = require('fill-range');\nconst utils = require('./utils');\n\nconst compile = (ast, options = {}) => {\n  const walk = (node, parent = {}) => {\n    const invalidBlock = utils.isInvalidBrace(parent);\n    const invalidNode = node.invalid === true && options.escapeInvalid === true;\n    const invalid = invalidBlock === true || invalidNode === true;\n    const prefix = options.escapeInvalid === true ? '\\\\' : '';\n    let output = '';\n\n    if (node.isOpen === true) {\n      return prefix + node.value;\n    }\n\n    if (node.isClose === true) {\n      console.log('node.isClose', prefix, node.value);\n      return prefix + node.value;\n    }\n\n    if (node.type === 'open') {\n      return invalid ? prefix + node.value : '(';\n    }\n\n    if (node.type === 'close') {\n      return invalid ? prefix + node.value : ')';\n    }\n\n    if (node.type === 'comma') {\n      return node.prev.type === 'comma' ? '' : invalid ? node.value : '|';\n    }\n\n    if (node.value) {\n      return node.value;\n    }\n\n    if (node.nodes && node.ranges > 0) {\n      const args = utils.reduce(node.nodes);\n      const range = fill(...args, { ...options, wrap: false, toRegex: true, strictZeros: true });\n\n      if (range.length !== 0) {\n        return args.length > 1 && range.length > 1 ? `(${range})` : range;\n      }\n    }\n\n    if (node.nodes) {\n      for (const child of node.nodes) {\n        output += walk(child, node);\n      }\n    }\n\n    return output;\n  };\n\n  return walk(ast);\n};\n\nmodule.exports = compile;\n","'use strict';\n\nconst fill = require('fill-range');\nconst stringify = require('./stringify');\nconst utils = require('./utils');\n\nconst append = (queue = '', stash = '', enclose = false) => {\n  const result = [];\n\n  queue = [].concat(queue);\n  stash = [].concat(stash);\n\n  if (!stash.length) return queue;\n  if (!queue.length) {\n    return enclose ? utils.flatten(stash).map(ele => `{${ele}}`) : stash;\n  }\n\n  for (const item of queue) {\n    if (Array.isArray(item)) {\n      for (const value of item) {\n        result.push(append(value, stash, enclose));\n      }\n    } else {\n      for (let ele of stash) {\n        if (enclose === true && typeof ele === 'string') ele = `{${ele}}`;\n        result.push(Array.isArray(ele) ? append(item, ele, enclose) : item + ele);\n      }\n    }\n  }\n  return utils.flatten(result);\n};\n\nconst expand = (ast, options = {}) => {\n  const rangeLimit = options.rangeLimit === undefined ? 1000 : options.rangeLimit;\n\n  const walk = (node, parent = {}) => {\n    node.queue = [];\n\n    let p = parent;\n    let q = parent.queue;\n\n    while (p.type !== 'brace' && p.type !== 'root' && p.parent) {\n      p = p.parent;\n      q = p.queue;\n    }\n\n    if (node.invalid || node.dollar) {\n      q.push(append(q.pop(), stringify(node, options)));\n      return;\n    }\n\n    if (node.type === 'brace' && node.invalid !== true && node.nodes.length === 2) {\n      q.push(append(q.pop(), ['{}']));\n      return;\n    }\n\n    if (node.nodes && node.ranges > 0) {\n      const args = utils.reduce(node.nodes);\n\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\n      let range = fill(...args, options);\n      if (range.length === 0) {\n        range = stringify(node, options);\n      }\n\n      q.push(append(q.pop(), range));\n      node.nodes = [];\n      return;\n    }\n\n    const enclose = utils.encloseBrace(node);\n    let queue = node.queue;\n    let block = node;\n\n    while (block.type !== 'brace' && block.type !== 'root' && block.parent) {\n      block = block.parent;\n      queue = block.queue;\n    }\n\n    for (let i = 0; i < node.nodes.length; i++) {\n      const child = node.nodes[i];\n\n      if (child.type === 'comma' && node.type === 'brace') {\n        if (i === 1) queue.push('');\n        queue.push('');\n        continue;\n      }\n\n      if (child.type === 'close') {\n        q.push(append(q.pop(), queue, enclose));\n        continue;\n      }\n\n      if (child.value && child.type !== 'open') {\n        queue.push(append(queue.pop(), child.value));\n        continue;\n      }\n\n      if (child.nodes) {\n        walk(child, node);\n      }\n    }\n\n    return queue;\n  };\n\n  return utils.flatten(walk(ast));\n};\n\nmodule.exports = expand;\n","'use strict';\n\nconst path = require('path');\nconst WIN_SLASH = '\\\\\\\\/';\nconst WIN_NO_SLASH = `[^${WIN_SLASH}]`;\n\n/**\n * Posix glob regex\n */\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}*?`;\n\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/**\n * Windows glob regex\n */\n\nconst WINDOWS_CHARS = {\n  ...POSIX_CHARS,\n\n  SLASH_LITERAL: `[${WIN_SLASH}]`,\n  QMARK: WIN_NO_SLASH,\n  STAR: `${WIN_NO_SLASH}*?`,\n  DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,\n  NO_DOT: `(?!${DOT_LITERAL})`,\n  NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,\n  NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,\n  NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,\n  QMARK_NO_DOT: `[^.${WIN_SLASH}]`,\n  START_ANCHOR: `(?:^|[${WIN_SLASH}])`,\n  END_ANCHOR: `(?:[${WIN_SLASH}]|$)`\n};\n\n/**\n * POSIX Bracket Regex\n */\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};\n\nmodule.exports = {\n  MAX_LENGTH: 1024 * 64,\n  POSIX_REGEX_SOURCE,\n\n  // regular expressions\n  REGEX_BACKSLASH: /\\\\(?![*+?^${}(|)[\\]])/g,\n  REGEX_NON_SPECIAL_CHARS: /^[^@![\\].,$*+?^{}()|\\\\/]+/,\n  REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\\]]/,\n  REGEX_SPECIAL_CHARS_BACKREF: /(\\\\?)((\\W)(\\3*))/g,\n  REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\\]])/g,\n  REGEX_REMOVE_BACKSLASH: /(?:\\[.*?[^\\\\]\\]|\\\\(?=.))/g,\n\n  // Replace globs with equivalent patterns to reduce parsing time.\n  REPLACEMENTS: {\n    '***': '*',\n    '**/**': '**',\n    '**/**/**': '**'\n  },\n\n  // Digits\n  CHAR_0: 48, /* 0 */\n  CHAR_9: 57, /* 9 */\n\n  // Alphabet chars.\n  CHAR_UPPERCASE_A: 65, /* A */\n  CHAR_LOWERCASE_A: 97, /* a */\n  CHAR_UPPERCASE_Z: 90, /* Z */\n  CHAR_LOWERCASE_Z: 122, /* z */\n\n  CHAR_LEFT_PARENTHESES: 40, /* ( */\n  CHAR_RIGHT_PARENTHESES: 41, /* ) */\n\n  CHAR_ASTERISK: 42, /* * */\n\n  // Non-alphabetic chars.\n  CHAR_AMPERSAND: 38, /* & */\n  CHAR_AT: 64, /* @ */\n  CHAR_BACKWARD_SLASH: 92, /* \\ */\n  CHAR_CARRIAGE_RETURN: 13, /* \\r */\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, /* \\f */\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 */\n  CHAR_NO_BREAK_SPACE: 160, /* \\u00A0 */\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, /* \\t */\n  CHAR_UNDERSCORE: 95, /* _ */\n  CHAR_VERTICAL_LINE: 124, /* | */\n  CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \\uFEFF */\n\n  SEP: path.sep,\n\n  /**\n   * Create EXTGLOB_CHARS\n   */\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  /**\n   * Create GLOB_CHARS\n   */\n\n  globChars(win32) {\n    return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;\n  }\n};\n","'use strict';\n\nconst path = require('path');\nconst win32 = process.platform === 'win32';\nconst {\n  REGEX_BACKSLASH,\n  REGEX_REMOVE_BACKSLASH,\n  REGEX_SPECIAL_CHARS,\n  REGEX_SPECIAL_CHARS_GLOBAL\n} = require('./constants');\n\nexports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);\nexports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);\nexports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str);\nexports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\\\$1');\nexports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/');\n\nexports.removeBackslashes = str => {\n  return str.replace(REGEX_REMOVE_BACKSLASH, match => {\n    return match === '\\\\' ? '' : match;\n  });\n};\n\nexports.supportsLookbehinds = () => {\n  const segs = process.version.slice(1).split('.').map(Number);\n  if (segs.length === 3 && segs[0] >= 9 || (segs[0] === 8 && segs[1] >= 10)) {\n    return true;\n  }\n  return false;\n};\n\nexports.isWindows = options => {\n  if (options && typeof options.windows === 'boolean') {\n    return options.windows;\n  }\n  return win32 === true || path.sep === '\\\\';\n};\n\nexports.escapeLast = (input, char, lastIdx) => {\n  const idx = input.lastIndexOf(char, lastIdx);\n  if (idx === -1) return input;\n  if (input[idx - 1] === '\\\\') return exports.escapeLast(input, char, idx - 1);\n  return `${input.slice(0, idx)}\\\\${input.slice(idx)}`;\n};\n\nexports.removePrefix = (input, state = {}) => {\n  let output = input;\n  if (output.startsWith('./')) {\n    output = output.slice(2);\n    state.prefix = './';\n  }\n  return output;\n};\n\nexports.wrapOutput = (input, state = {}, options = {}) => {\n  const prepend = options.contains ? '' : '^';\n  const append = options.contains ? '' : '$';\n\n  let output = `${prepend}(?:${input})${append}`;\n  if (state.negated === true) {\n    output = `(?:^(?!${output}).*$)`;\n  }\n  return output;\n};\n","'use strict';\n\nconst path = require('path');\nconst scan = require('./scan');\nconst parse = require('./parse');\nconst utils = require('./utils');\nconst constants = require('./constants');\nconst isObject = val => val && typeof val === 'object' && !Array.isArray(val);\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 */\n\nconst picomatch = (glob, options, returnState = false) => {\n  if (Array.isArray(glob)) {\n    const fns = glob.map(input => picomatch(input, options, returnState));\n    const arrayMatcher = str => {\n      for (const isMatch of fns) {\n        const state = isMatch(str);\n        if (state) return state;\n      }\n      return false;\n    };\n    return arrayMatcher;\n  }\n\n  const isState = isObject(glob) && glob.tokens && glob.input;\n\n  if (glob === '' || (typeof glob !== 'string' && !isState)) {\n    throw new TypeError('Expected pattern to be a non-empty string');\n  }\n\n  const opts = options || {};\n  const posix = utils.isWindows(options);\n  const regex = isState\n    ? picomatch.compileRe(glob, options)\n    : picomatch.makeRe(glob, options, false, true);\n\n  const state = regex.state;\n  delete regex.state;\n\n  let isIgnored = () => false;\n  if (opts.ignore) {\n    const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };\n    isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);\n  }\n\n  const matcher = (input, returnObject = false) => {\n    const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix });\n    const result = { glob, state, regex, posix, input, output, match, isMatch };\n\n    if (typeof opts.onResult === 'function') {\n      opts.onResult(result);\n    }\n\n    if (isMatch === false) {\n      result.isMatch = false;\n      return returnObject ? result : false;\n    }\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\n    if (typeof opts.onMatch === 'function') {\n      opts.onMatch(result);\n    }\n    return returnObject ? result : true;\n  };\n\n  if (returnState) {\n    matcher.state = state;\n  }\n\n  return matcher;\n};\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 */\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\n  if (input === '') {\n    return { isMatch: false, output: '' };\n  }\n\n  const opts = options || {};\n  const format = opts.format || (posix ? utils.toPosixSlashes : null);\n  let match = input === glob;\n  let output = (match && format) ? format(input) : input;\n\n  if (match === false) {\n    output = format ? format(input) : input;\n    match = output === glob;\n  }\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    } else {\n      match = regex.exec(output);\n    }\n  }\n\n  return { isMatch: Boolean(match), match, output };\n};\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 */\n\npicomatch.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {\n  const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);\n  return regex.test(path.basename(input));\n};\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 */\n\npicomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);\n\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(pattern[, options]);\n * ```\n * @param {String} `pattern`\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 */\n\npicomatch.parse = (pattern, options) => {\n  if (Array.isArray(pattern)) return pattern.map(p => picomatch.parse(p, options));\n  return parse(pattern, { ...options, fastpaths: false });\n};\n\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 *   start: 3,\n *   base: 'foo',\n *   glob: '*.js',\n *   isBrace: false,\n *   isBracket: false,\n *   isGlob: true,\n *   isExtglob: false,\n *   isGlobstar: false,\n *   negated: 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 */\n\npicomatch.scan = (input, options) => scan(input, options);\n\n/**\n * Compile a regular expression from the `state` object returned by the\n * [parse()](#parse) method.\n *\n * @param {Object} `state`\n * @param {Object} `options`\n * @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.\n * @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.\n * @return {RegExp}\n * @api public\n */\n\npicomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {\n  if (returnOutput === true) {\n    return state.output;\n  }\n\n  const opts = options || {};\n  const prepend = opts.contains ? '' : '^';\n  const append = opts.contains ? '' : '$';\n\n  let source = `${prepend}(?:${state.output})${append}`;\n  if (state && state.negated === true) {\n    source = `^(?!${source}).*$`;\n  }\n\n  const regex = picomatch.toRegex(source, options);\n  if (returnState === true) {\n    regex.state = state;\n  }\n\n  return regex;\n};\n\n/**\n * Create a regular expression from a parsed glob pattern.\n *\n * ```js\n * const picomatch = require('picomatch');\n * const state = picomatch.parse('*.js');\n * // picomatch.compileRe(state[, options]);\n *\n * console.log(picomatch.compileRe(state));\n * //=> /^(?:(?!\\.)(?=.)[^/]*?\\.js)$/\n * ```\n * @param {String} `state` The object returned from the `.parse` method.\n * @param {Object} `options`\n * @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.\n * @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.\n * @return {RegExp} Returns a regex created from the given pattern.\n * @api public\n */\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\n  let parsed = { negated: false, fastpaths: true };\n\n  if (options.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {\n    parsed.output = parse.fastpaths(input, options);\n  }\n\n  if (!parsed.output) {\n    parsed = parse(input, options);\n  }\n\n  return picomatch.compileRe(parsed, options, returnOutput, returnState);\n};\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 */\n\npicomatch.toRegex = (source, options) => {\n  try {\n    const opts = options || {};\n    return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));\n  } catch (err) {\n    if (options && options.debug === true) throw err;\n    return /$^/;\n  }\n};\n\n/**\n * Picomatch constants.\n * @return {Object}\n */\n\npicomatch.constants = constants;\n\n/**\n * Expose \"picomatch\"\n */\n\nmodule.exports = picomatch;\n","'use strict';\n\nconst utils = require('./utils');\nconst {\n  CHAR_ASTERISK,             /* * */\n  CHAR_AT,                   /* @ */\n  CHAR_BACKWARD_SLASH,       /* \\ */\n  CHAR_COMMA,                /* , */\n  CHAR_DOT,                  /* . */\n  CHAR_EXCLAMATION_MARK,     /* ! */\n  CHAR_FORWARD_SLASH,        /* / */\n  CHAR_LEFT_CURLY_BRACE,     /* { */\n  CHAR_LEFT_PARENTHESES,     /* ( */\n  CHAR_LEFT_SQUARE_BRACKET,  /* [ */\n  CHAR_PLUS,                 /* + */\n  CHAR_QUESTION_MARK,        /* ? */\n  CHAR_RIGHT_CURLY_BRACE,    /* } */\n  CHAR_RIGHT_PARENTHESES,    /* ) */\n  CHAR_RIGHT_SQUARE_BRACKET  /* ] */\n} = require('./constants');\n\nconst isPathSeparator = code => {\n  return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;\n};\n\nconst depth = token => {\n  if (token.isPrefix !== true) {\n    token.depth = token.isGlobstar ? Infinity : 1;\n  }\n};\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), `negated` (true if the path starts with `!` but not\n * with `!(`) and `negatedExtglob` (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 */\n\nconst scan = (input, options) => {\n  const opts = options || {};\n\n  const length = input.length - 1;\n  const scanToEnd = opts.parts === true || opts.scanToEnd === true;\n  const slashes = [];\n  const tokens = [];\n  const parts = [];\n\n  let str = input;\n  let index = -1;\n  let start = 0;\n  let lastIndex = 0;\n  let isBrace = false;\n  let isBracket = false;\n  let isGlob = false;\n  let isExtglob = false;\n  let isGlobstar = false;\n  let braceEscaped = false;\n  let backslashes = false;\n  let negated = false;\n  let negatedExtglob = false;\n  let finished = false;\n  let braces = 0;\n  let prev;\n  let code;\n  let token = { value: '', depth: 0, isGlob: false };\n\n  const eos = () => index >= length;\n  const peek = () => str.charCodeAt(index + 1);\n  const advance = () => {\n    prev = code;\n    return str.charCodeAt(++index);\n  };\n\n  while (index < length) {\n    code = advance();\n    let next;\n\n    if (code === CHAR_BACKWARD_SLASH) {\n      backslashes = token.backslashes = true;\n      code = advance();\n\n      if (code === CHAR_LEFT_CURLY_BRACE) {\n        braceEscaped = true;\n      }\n      continue;\n    }\n\n    if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {\n      braces++;\n\n      while (eos() !== true && (code = advance())) {\n        if (code === CHAR_BACKWARD_SLASH) {\n          backslashes = token.backslashes = true;\n          advance();\n          continue;\n        }\n\n        if (code === CHAR_LEFT_CURLY_BRACE) {\n          braces++;\n          continue;\n        }\n\n        if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {\n          isBrace = token.isBrace = true;\n          isGlob = token.isGlob = true;\n          finished = true;\n\n          if (scanToEnd === true) {\n            continue;\n          }\n\n          break;\n        }\n\n        if (braceEscaped !== true && code === CHAR_COMMA) {\n          isBrace = token.isBrace = true;\n          isGlob = token.isGlob = true;\n          finished = true;\n\n          if (scanToEnd === true) {\n            continue;\n          }\n\n          break;\n        }\n\n        if (code === CHAR_RIGHT_CURLY_BRACE) {\n          braces--;\n\n          if (braces === 0) {\n            braceEscaped = false;\n            isBrace = token.isBrace = true;\n            finished = true;\n            break;\n          }\n        }\n      }\n\n      if (scanToEnd === true) {\n        continue;\n      }\n\n      break;\n    }\n\n    if (code === CHAR_FORWARD_SLASH) {\n      slashes.push(index);\n      tokens.push(token);\n      token = { value: '', depth: 0, isGlob: false };\n\n      if (finished === true) continue;\n      if (prev === CHAR_DOT && index === (start + 1)) {\n        start += 2;\n        continue;\n      }\n\n      lastIndex = index + 1;\n      continue;\n    }\n\n    if (opts.noext !== true) {\n      const isExtglobChar = code === CHAR_PLUS\n        || code === CHAR_AT\n        || code === CHAR_ASTERISK\n        || code === CHAR_QUESTION_MARK\n        || code === CHAR_EXCLAMATION_MARK;\n\n      if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {\n        isGlob = token.isGlob = true;\n        isExtglob = token.isExtglob = true;\n        finished = true;\n        if (code === CHAR_EXCLAMATION_MARK && index === start) {\n          negatedExtglob = true;\n        }\n\n        if (scanToEnd === true) {\n          while (eos() !== true && (code = advance())) {\n            if (code === CHAR_BACKWARD_SLASH) {\n              backslashes = token.backslashes = true;\n              code = advance();\n              continue;\n            }\n\n            if (code === CHAR_RIGHT_PARENTHESES) {\n              isGlob = token.isGlob = true;\n              finished = true;\n              break;\n            }\n          }\n          continue;\n        }\n        break;\n      }\n    }\n\n    if (code === CHAR_ASTERISK) {\n      if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;\n      isGlob = token.isGlob = true;\n      finished = true;\n\n      if (scanToEnd === true) {\n        continue;\n      }\n      break;\n    }\n\n    if (code === CHAR_QUESTION_MARK) {\n      isGlob = token.isGlob = true;\n      finished = true;\n\n      if (scanToEnd === true) {\n        continue;\n      }\n      break;\n    }\n\n    if (code === CHAR_LEFT_SQUARE_BRACKET) {\n      while (eos() !== true && (next = advance())) {\n        if (next === CHAR_BACKWARD_SLASH) {\n          backslashes = token.backslashes = true;\n          advance();\n          continue;\n        }\n\n        if (next === CHAR_RIGHT_SQUARE_BRACKET) {\n          isBracket = token.isBracket = true;\n          isGlob = token.isGlob = true;\n          finished = true;\n          break;\n        }\n      }\n\n      if (scanToEnd === true) {\n        continue;\n      }\n\n      break;\n    }\n\n    if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {\n      negated = token.negated = true;\n      start++;\n      continue;\n    }\n\n    if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {\n      isGlob = token.isGlob = true;\n\n      if (scanToEnd === true) {\n        while (eos() !== true && (code = advance())) {\n          if (code === CHAR_LEFT_PARENTHESES) {\n            backslashes = token.backslashes = true;\n            code = advance();\n            continue;\n          }\n\n          if (code === CHAR_RIGHT_PARENTHESES) {\n            finished = true;\n            break;\n          }\n        }\n        continue;\n      }\n      break;\n    }\n\n    if (isGlob === true) {\n      finished = true;\n\n      if (scanToEnd === true) {\n        continue;\n      }\n\n      break;\n    }\n  }\n\n  if (opts.noext === true) {\n    isExtglob = false;\n    isGlob = false;\n  }\n\n  let base = str;\n  let prefix = '';\n  let glob = '';\n\n  if (start > 0) {\n    prefix = str.slice(0, start);\n    str = str.slice(start);\n    lastIndex -= start;\n  }\n\n  if (base && isGlob === true && lastIndex > 0) {\n    base = str.slice(0, lastIndex);\n    glob = str.slice(lastIndex);\n  } else if (isGlob === true) {\n    base = '';\n    glob = str;\n  } else {\n    base = str;\n  }\n\n  if (base && base !== '' && base !== '/' && base !== str) {\n    if (isPathSeparator(base.charCodeAt(base.length - 1))) {\n      base = base.slice(0, -1);\n    }\n  }\n\n  if (opts.unescape === true) {\n    if (glob) glob = utils.removeBackslashes(glob);\n\n    if (base && backslashes === true) {\n      base = utils.removeBackslashes(base);\n    }\n  }\n\n  const state = {\n    prefix,\n    input,\n    start,\n    base,\n    glob,\n    isBrace,\n    isBracket,\n    isGlob,\n    isExtglob,\n    isGlobstar,\n    negated,\n    negatedExtglob\n  };\n\n  if (opts.tokens === true) {\n    state.maxDepth = 0;\n    if (!isPathSeparator(code)) {\n      tokens.push(token);\n    }\n    state.tokens = tokens;\n  }\n\n  if (opts.parts === true || opts.tokens === true) {\n    let prevIndex;\n\n    for (let idx = 0; idx < slashes.length; idx++) {\n      const n = prevIndex ? prevIndex + 1 : start;\n      const i = slashes[idx];\n      const value = input.slice(n, i);\n      if (opts.tokens) {\n        if (idx === 0 && start !== 0) {\n          tokens[idx].isPrefix = true;\n          tokens[idx].value = prefix;\n        } else {\n          tokens[idx].value = value;\n        }\n        depth(tokens[idx]);\n        state.maxDepth += tokens[idx].depth;\n      }\n      if (idx !== 0 || value !== '') {\n        parts.push(value);\n      }\n      prevIndex = i;\n    }\n\n    if (prevIndex && prevIndex + 1 < input.length) {\n      const value = input.slice(prevIndex + 1);\n      parts.push(value);\n\n      if (opts.tokens) {\n        tokens[tokens.length - 1].value = value;\n        depth(tokens[tokens.length - 1]);\n        state.maxDepth += tokens[tokens.length - 1].depth;\n      }\n    }\n\n    state.slashes = slashes;\n    state.parts = parts;\n  }\n\n  return state;\n};\n\nmodule.exports = scan;\n","'use strict';\n\nconst constants = require('./constants');\nconst utils = require('./utils');\n\n/**\n * Constants\n */\n\nconst {\n  MAX_LENGTH,\n  POSIX_REGEX_SOURCE,\n  REGEX_NON_SPECIAL_CHARS,\n  REGEX_SPECIAL_CHARS_BACKREF,\n  REPLACEMENTS\n} = constants;\n\n/**\n * Helpers\n */\n\nconst expandRange = (args, options) => {\n  if (typeof options.expandRange === 'function') {\n    return options.expandRange(...args, options);\n  }\n\n  args.sort();\n  const value = `[${args.join('-')}]`;\n\n  try {\n    /* eslint-disable-next-line no-new */\n    new RegExp(value);\n  } catch (ex) {\n    return args.map(v => utils.escapeRegex(v)).join('..');\n  }\n\n  return value;\n};\n\n/**\n * Create the message for a syntax error\n */\n\nconst syntaxError = (type, char) => {\n  return `Missing ${type}: \"${char}\" - use \"\\\\\\\\${char}\" to match literal characters`;\n};\n\n/**\n * Parse the given input string.\n * @param {String} input\n * @param {Object} options\n * @return {Object}\n */\n\nconst parse = (input, options) => {\n  if (typeof input !== 'string') {\n    throw new TypeError('Expected a string');\n  }\n\n  input = REPLACEMENTS[input] || input;\n\n  const opts = { ...options };\n  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;\n\n  let len = input.length;\n  if (len > max) {\n    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);\n  }\n\n  const bos = { type: 'bos', value: '', output: opts.prepend || '' };\n  const tokens = [bos];\n\n  const capture = opts.capture ? '' : '?:';\n  const win32 = utils.isWindows(options);\n\n  // create constants based on platform, for windows or posix\n  const PLATFORM_CHARS = constants.globChars(win32);\n  const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);\n\n  const {\n    DOT_LITERAL,\n    PLUS_LITERAL,\n    SLASH_LITERAL,\n    ONE_CHAR,\n    DOTS_SLASH,\n    NO_DOT,\n    NO_DOT_SLASH,\n    NO_DOTS_SLASH,\n    QMARK,\n    QMARK_NO_DOT,\n    STAR,\n    START_ANCHOR\n  } = PLATFORM_CHARS;\n\n  const globstar = opts => {\n    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;\n  };\n\n  const nodot = opts.dot ? '' : NO_DOT;\n  const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;\n  let star = opts.bash === true ? globstar(opts) : STAR;\n\n  if (opts.capture) {\n    star = `(${star})`;\n  }\n\n  // minimatch options support\n  if (typeof opts.noext === 'boolean') {\n    opts.noextglob = opts.noext;\n  }\n\n  const state = {\n    input,\n    index: -1,\n    start: 0,\n    dot: opts.dot === true,\n    consumed: '',\n    output: '',\n    prefix: '',\n    backtrack: false,\n    negated: false,\n    brackets: 0,\n    braces: 0,\n    parens: 0,\n    quotes: 0,\n    globstar: false,\n    tokens\n  };\n\n  input = utils.removePrefix(input, state);\n  len = input.length;\n\n  const extglobs = [];\n  const braces = [];\n  const stack = [];\n  let prev = bos;\n  let value;\n\n  /**\n   * Tokenizing helpers\n   */\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 remaining = () => input.slice(state.index + 1);\n  const consume = (value = '', num = 0) => {\n    state.consumed += value;\n    state.index += num;\n  };\n\n  const append = token => {\n    state.output += token.output != null ? token.output : token.value;\n    consume(token.value);\n  };\n\n  const negate = () => {\n    let count = 1;\n\n    while (peek() === '!' && (peek(2) !== '(' || peek(3) === '?')) {\n      advance();\n      state.start++;\n      count++;\n    }\n\n    if (count % 2 === 0) {\n      return false;\n    }\n\n    state.negated = true;\n    state.start++;\n    return true;\n  };\n\n  const increment = type => {\n    state[type]++;\n    stack.push(type);\n  };\n\n  const decrement = type => {\n    state[type]--;\n    stack.pop();\n  };\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\n  const push = tok => {\n    if (prev.type === 'globstar') {\n      const isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace');\n      const isExtglob = tok.extglob === true || (extglobs.length && (tok.type === 'pipe' || tok.type === 'paren'));\n\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\n    if (extglobs.length && tok.type !== 'paren') {\n      extglobs[extglobs.length - 1].inner += tok.value;\n    }\n\n    if (tok.value || tok.output) append(tok);\n    if (prev && prev.type === 'text' && tok.type === 'text') {\n      prev.value += tok.value;\n      prev.output = (prev.output || '') + tok.value;\n      return;\n    }\n\n    tok.prev = prev;\n    tokens.push(tok);\n    prev = tok;\n  };\n\n  const extglobOpen = (type, value) => {\n    const token = { ...EXTGLOB_CHARS[value], conditions: 1, inner: '' };\n\n    token.prev = prev;\n    token.parens = state.parens;\n    token.output = state.output;\n    const output = (opts.capture ? '(' : '') + token.open;\n\n    increment('parens');\n    push({ type, value, output: state.output ? '' : ONE_CHAR });\n    push({ type: 'paren', extglob: true, value: advance(), output });\n    extglobs.push(token);\n  };\n\n  const extglobClose = token => {\n    let output = token.close + (opts.capture ? ')' : '');\n    let rest;\n\n    if (token.type === 'negate') {\n      let extglobStar = star;\n\n      if (token.inner && token.inner.length > 1 && token.inner.includes('/')) {\n        extglobStar = globstar(opts);\n      }\n\n      if (extglobStar !== star || eos() || /^\\)+$/.test(remaining())) {\n        output = token.close = `)$))${extglobStar}`;\n      }\n\n      if (token.inner.includes('*') && (rest = remaining()) && /^\\.[^\\\\/.]+$/.test(rest)) {\n        // Any non-magical string (`.ts`) or even nested expression (`.{ts,tsx}`) can follow after the closing parenthesis.\n        // In this case, we need to parse the string and use it in the output of the original pattern.\n        // Suitable patterns: `/!(*.d).ts`, `/!(*.d).{ts,tsx}`, `**/!(*-dbg).@(js)`.\n        //\n        // Disabling the `fastpaths` option due to a problem with parsing strings as `.ts` in the pattern like `**/!(*.d).ts`.\n        const expression = parse(rest, { ...options, fastpaths: false }).output;\n\n        output = token.close = `)${expression})${extglobStar})`;\n      }\n\n      if (token.prev.type === 'bos') {\n        state.negatedExtglob = true;\n      }\n    }\n\n    push({ type: 'paren', extglob: true, value, output });\n    decrement('parens');\n  };\n\n  /**\n   * Fast paths\n   */\n\n  if (opts.fastpaths !== false && !/(^[*!]|[/()[\\]{}\"])/.test(input)) {\n    let backslashes = false;\n\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\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\n      if (first === '.') {\n        return DOT_LITERAL.repeat(chars.length);\n      }\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\n    if (backslashes === true) {\n      if (opts.unescape === true) {\n        output = output.replace(/\\\\/g, '');\n      } else {\n        output = output.replace(/\\\\+/g, m => {\n          return m.length % 2 === 0 ? '\\\\\\\\' : (m ? '\\\\' : '');\n        });\n      }\n    }\n\n    if (output === input && opts.contains === true) {\n      state.output = input;\n      return state;\n    }\n\n    state.output = utils.wrapOutput(output, state, options);\n    return state;\n  }\n\n  /**\n   * Tokenize input until we reach end-of-string\n   */\n\n  while (!eos()) {\n    value = advance();\n\n    if (value === '\\u0000') {\n      continue;\n    }\n\n    /**\n     * Escaped characters\n     */\n\n    if (value === '\\\\') {\n      const next = peek();\n\n      if (next === '/' && opts.bash !== true) {\n        continue;\n      }\n\n      if (next === '.' || next === ';') {\n        continue;\n      }\n\n      if (!next) {\n        value += '\\\\';\n        push({ type: 'text', value });\n        continue;\n      }\n\n      // collapse slashes to reduce potential for exploits\n      const match = /^\\\\+/.exec(remaining());\n      let slashes = 0;\n\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\n      if (opts.unescape === true) {\n        value = advance();\n      } else {\n        value += advance();\n      }\n\n      if (state.brackets === 0) {\n        push({ type: 'text', value });\n        continue;\n      }\n    }\n\n    /**\n     * If we're inside a regex character class, continue\n     * until we reach the closing bracket.\n     */\n\n    if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) {\n      if (opts.posix !== false && value === ':') {\n        const inner = prev.value.slice(1);\n        if (inner.includes('[')) {\n          prev.posix = true;\n\n          if (inner.includes(':')) {\n            const idx = prev.value.lastIndexOf('[');\n            const pre = prev.value.slice(0, idx);\n            const rest = prev.value.slice(idx + 2);\n            const posix = POSIX_REGEX_SOURCE[rest];\n            if (posix) {\n              prev.value = pre + posix;\n              state.backtrack = true;\n              advance();\n\n              if (!bos.output && tokens.indexOf(prev) === 1) {\n                bos.output = ONE_CHAR;\n              }\n              continue;\n            }\n          }\n        }\n      }\n\n      if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) {\n        value = `\\\\${value}`;\n      }\n\n      if (value === ']' && (prev.value === '[' || prev.value === '[^')) {\n        value = `\\\\${value}`;\n      }\n\n      if (opts.posix === true && value === '!' && prev.value === '[') {\n        value = '^';\n      }\n\n      prev.value += value;\n      append({ value });\n      continue;\n    }\n\n    /**\n     * If we're inside a quoted string, continue\n     * until we reach the closing double quote.\n     */\n\n    if (state.quotes === 1 && value !== '\"') {\n      value = utils.escapeRegex(value);\n      prev.value += value;\n      append({ value });\n      continue;\n    }\n\n    /**\n     * Double quotes\n     */\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    /**\n     * Parentheses\n     */\n\n    if (value === '(') {\n      increment('parens');\n      push({ type: 'paren', value });\n      continue;\n    }\n\n    if (value === ')') {\n      if (state.parens === 0 && opts.strictBrackets === true) {\n        throw new SyntaxError(syntaxError('opening', '('));\n      }\n\n      const extglob = extglobs[extglobs.length - 1];\n      if (extglob && state.parens === extglob.parens + 1) {\n        extglobClose(extglobs.pop());\n        continue;\n      }\n\n      push({ type: 'paren', value, output: state.parens ? ')' : '\\\\)' });\n      decrement('parens');\n      continue;\n    }\n\n    /**\n     * Square brackets\n     */\n\n    if (value === '[') {\n      if (opts.nobracket === true || !remaining().includes(']')) {\n        if (opts.nobracket !== true && opts.strictBrackets === true) {\n          throw new SyntaxError(syntaxError('closing', ']'));\n        }\n\n        value = `\\\\${value}`;\n      } else {\n        increment('brackets');\n      }\n\n      push({ type: 'bracket', value });\n      continue;\n    }\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\n      if (state.brackets === 0) {\n        if (opts.strictBrackets === true) {\n          throw new SyntaxError(syntaxError('opening', '['));\n        }\n\n        push({ type: 'text', value, output: `\\\\${value}` });\n        continue;\n      }\n\n      decrement('brackets');\n\n      const prevValue = prev.value.slice(1);\n      if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) {\n        value = `/${value}`;\n      }\n\n      prev.value += value;\n      append({ value });\n\n      // when literal brackets are explicitly disabled\n      // assume we should match with a regex character class\n      if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) {\n        continue;\n      }\n\n      const escaped = utils.escapeRegex(prev.value);\n      state.output = state.output.slice(0, -prev.value.length);\n\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\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    /**\n     * Braces\n     */\n\n    if (value === '{' && opts.nobrace !== true) {\n      increment('braces');\n\n      const open = {\n        type: 'brace',\n        value,\n        output: '(',\n        outputIndex: state.output.length,\n        tokensIndex: state.tokens.length\n      };\n\n      braces.push(open);\n      push(open);\n      continue;\n    }\n\n    if (value === '}') {\n      const brace = braces[braces.length - 1];\n\n      if (opts.nobrace === true || !brace) {\n        push({ type: 'text', value, output: value });\n        continue;\n      }\n\n      let output = ')';\n\n      if (brace.dots === true) {\n        const arr = tokens.slice();\n        const range = [];\n\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\n        output = expandRange(range, opts);\n        state.backtrack = true;\n      }\n\n      if (brace.comma !== true && brace.dots !== true) {\n        const out = state.output.slice(0, brace.outputIndex);\n        const toks = state.tokens.slice(brace.tokensIndex);\n        brace.value = brace.output = '\\\\{';\n        value = output = '\\\\}';\n        state.output = out;\n        for (const t of toks) {\n          state.output += (t.output || t.value);\n        }\n      }\n\n      push({ type: 'brace', value, output });\n      decrement('braces');\n      braces.pop();\n      continue;\n    }\n\n    /**\n     * Pipes\n     */\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    /**\n     * Commas\n     */\n\n    if (value === ',') {\n      let output = value;\n\n      const brace = braces[braces.length - 1];\n      if (brace && stack[stack.length - 1] === 'braces') {\n        brace.comma = true;\n        output = '|';\n      }\n\n      push({ type: 'comma', value, output });\n      continue;\n    }\n\n    /**\n     * Slashes\n     */\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 === state.start + 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\n      push({ type: 'slash', value, output: SLASH_LITERAL });\n      continue;\n    }\n\n    /**\n     * Dots\n     */\n\n    if (value === '.') {\n      if (state.braces > 0 && prev.type === 'dot') {\n        if (prev.value === '.') prev.output = DOT_LITERAL;\n        const brace = braces[braces.length - 1];\n        prev.type = 'dots';\n        prev.output += value;\n        prev.value += value;\n        brace.dots = true;\n        continue;\n      }\n\n      if ((state.braces + state.parens) === 0 && prev.type !== 'bos' && prev.type !== 'slash') {\n        push({ type: 'text', value, output: DOT_LITERAL });\n        continue;\n      }\n\n      push({ type: 'dot', value, output: DOT_LITERAL });\n      continue;\n    }\n\n    /**\n     * Question marks\n     */\n\n    if (value === '?') {\n      const isGroup = prev && prev.value === '(';\n      if (!isGroup && opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {\n        extglobOpen('qmark', value);\n        continue;\n      }\n\n      if (prev && prev.type === 'paren') {\n        const next = peek();\n        let output = value;\n\n        if (next === '<' && !utils.supportsLookbehinds()) {\n          throw new Error('Node.js v10 or higher is required for regex lookbehinds');\n        }\n\n        if ((prev.value === '(' && !/[!=<:]/.test(next)) || (next === '<' && !/<([!=]|\\w+>)/.test(remaining()))) {\n          output = `\\\\${value}`;\n        }\n\n        push({ type: 'text', value, output });\n        continue;\n      }\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\n      push({ type: 'qmark', value, output: QMARK });\n      continue;\n    }\n\n    /**\n     * Exclamation\n     */\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\n      if (opts.nonegate !== true && state.index === 0) {\n        negate();\n        continue;\n      }\n    }\n\n    /**\n     * Plus\n     */\n\n    if (value === '+') {\n      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {\n        extglobOpen('plus', value);\n        continue;\n      }\n\n      if ((prev && prev.value === '(') || opts.regex === false) {\n        push({ type: 'plus', value, output: PLUS_LITERAL });\n        continue;\n      }\n\n      if ((prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) || state.parens > 0) {\n        push({ type: 'plus', value });\n        continue;\n      }\n\n      push({ type: 'plus', value: PLUS_LITERAL });\n      continue;\n    }\n\n    /**\n     * Plain text\n     */\n\n    if (value === '@') {\n      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {\n        push({ type: 'at', extglob: true, value, output: '' });\n        continue;\n      }\n\n      push({ type: 'text', value });\n      continue;\n    }\n\n    /**\n     * Plain text\n     */\n\n    if (value !== '*') {\n      if (value === '$' || value === '^') {\n        value = `\\\\${value}`;\n      }\n\n      const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());\n      if (match) {\n        value += match[0];\n        state.index += match[0].length;\n      }\n\n      push({ type: 'text', value });\n      continue;\n    }\n\n    /**\n     * Stars\n     */\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.globstar = true;\n      consume(value);\n      continue;\n    }\n\n    let rest = remaining();\n    if (opts.noextglob !== true && /^\\([^?]/.test(rest)) {\n      extglobOpen('star', value);\n      continue;\n    }\n\n    if (prev.type === 'star') {\n      if (opts.noglobstar === true) {\n        consume(value);\n        continue;\n      }\n\n      const prior = prev.prev;\n      const before = prior.prev;\n      const isStart = prior.type === 'slash' || prior.type === 'bos';\n      const afterStar = before && (before.type === 'star' || before.type === 'globstar');\n\n      if (opts.bash === true && (!isStart || (rest[0] && rest[0] !== '/'))) {\n        push({ type: 'star', value, output: '' });\n        continue;\n      }\n\n      const isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace');\n      const 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\n      // strip consecutive `/**/`\n      while (rest.slice(0, 3) === '/**') {\n        const after = input[state.index + 4];\n        if (after && after !== '/') {\n          break;\n        }\n        rest = rest.slice(3);\n        consume('/**', 3);\n      }\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.globstar = true;\n        consume(value);\n        continue;\n      }\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\n        prev.type = 'globstar';\n        prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '|$)');\n        prev.value += value;\n        state.globstar = true;\n        state.output += prior.output + prev.output;\n        consume(value);\n        continue;\n      }\n\n      if (prior.type === 'slash' && prior.prev.type !== 'bos' && rest[0] === '/') {\n        const end = rest[1] !== void 0 ? '|$' : '';\n\n        state.output = state.output.slice(0, -(prior.output + prev.output).length);\n        prior.output = `(?:${prior.output}`;\n\n        prev.type = 'globstar';\n        prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;\n        prev.value += value;\n\n        state.output += prior.output + prev.output;\n        state.globstar = true;\n\n        consume(value + advance());\n\n        push({ type: 'slash', value: '/', output: '' });\n        continue;\n      }\n\n      if (prior.type === 'bos' && rest[0] === '/') {\n        prev.type = 'globstar';\n        prev.value += value;\n        prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;\n        state.output = prev.output;\n        state.globstar = true;\n        consume(value + advance());\n        push({ type: 'slash', value: '/', output: '' });\n        continue;\n      }\n\n      // remove single star from output\n      state.output = state.output.slice(0, -prev.output.length);\n\n      // reset previous token to globstar\n      prev.type = 'globstar';\n      prev.output = globstar(opts);\n      prev.value += value;\n\n      // reset output with globstar\n      state.output += prev.output;\n      state.globstar = true;\n      consume(value);\n      continue;\n    }\n\n    const token = { type: 'star', value, output: star };\n\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\n    if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) {\n      token.output = value;\n      push(token);\n      continue;\n    }\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\n      if (peek() !== '*') {\n        state.output += ONE_CHAR;\n        prev.output += ONE_CHAR;\n      }\n    }\n\n    push(token);\n  }\n\n  while (state.brackets > 0) {\n    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']'));\n    state.output = utils.escapeLast(state.output, '[');\n    decrement('brackets');\n  }\n\n  while (state.parens > 0) {\n    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')'));\n    state.output = utils.escapeLast(state.output, '(');\n    decrement('parens');\n  }\n\n  while (state.braces > 0) {\n    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}'));\n    state.output = utils.escapeLast(state.output, '{');\n    decrement('braces');\n  }\n\n  if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) {\n    push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` });\n  }\n\n  // rebuild the output if we had to backtrack at any point\n  if (state.backtrack === true) {\n    state.output = '';\n\n    for (const token of state.tokens) {\n      state.output += token.output != null ? token.output : token.value;\n\n      if (token.suffix) {\n        state.output += token.suffix;\n      }\n    }\n  }\n\n  return state;\n};\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 */\n\nparse.fastpaths = (input, options) => {\n  const opts = { ...options };\n  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;\n  const len = input.length;\n  if (len > max) {\n    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);\n  }\n\n  input = REPLACEMENTS[input] || input;\n  const win32 = utils.isWindows(options);\n\n  // create constants based on platform, for windows or posix\n  const {\n    DOT_LITERAL,\n    SLASH_LITERAL,\n    ONE_CHAR,\n    DOTS_SLASH,\n    NO_DOT,\n    NO_DOTS,\n    NO_DOTS_SLASH,\n    STAR,\n    START_ANCHOR\n  } = constants.globChars(win32);\n\n  const nodot = opts.dot ? NO_DOTS : NO_DOT;\n  const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;\n  const capture = opts.capture ? '' : '?:';\n  const state = { negated: false, prefix: '' };\n  let star = opts.bash === true ? '.*?' : STAR;\n\n  if (opts.capture) {\n    star = `(${star})`;\n  }\n\n  const globstar = opts => {\n    if (opts.noglobstar === true) return star;\n    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;\n  };\n\n  const create = str => {\n    switch (str) {\n      case '*':\n        return `${nodot}${ONE_CHAR}${star}`;\n\n      case '.*':\n        return `${DOT_LITERAL}${ONE_CHAR}${star}`;\n\n      case '*.*':\n        return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;\n\n      case '*/*':\n        return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;\n\n      case '**':\n        return nodot + globstar(opts);\n\n      case '**/*':\n        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;\n\n      case '**/*.*':\n        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;\n\n      case '**/.*':\n        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;\n\n      default: {\n        const match = /^(.*?)\\.(\\w+)$/.exec(str);\n        if (!match) return;\n\n        const source = create(match[1]);\n        if (!source) return;\n\n        return source + DOT_LITERAL + match[2];\n      }\n    }\n  };\n\n  const output = utils.removePrefix(input, state);\n  let source = create(output);\n\n  if (source && opts.strictSlashes !== true) {\n    source += `${SLASH_LITERAL}?`;\n  }\n\n  return source;\n};\n\nmodule.exports = parse;\n","'use strict';\n\nmodule.exports = require('./lib/picomatch');\n","'use strict';\n\nconst util = require('util');\nconst braces = require('braces');\nconst picomatch = require('picomatch');\nconst utils = require('picomatch/lib/utils');\n\nconst isEmptyString = v => v === '' || v === './';\nconst hasBraces = v => {\n  const index = v.indexOf('{');\n  return index > -1 && v.indexOf('}', index) > -1;\n};\n\n/**\n * Returns an array of strings that match one or more glob patterns.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm(list, patterns[, options]);\n *\n * console.log(mm(['a.js', 'a.txt'], ['*.js']));\n * //=> [ 'a.js' ]\n * ```\n * @param {String|Array<string>} `list` List of strings to match.\n * @param {String|Array<string>} `patterns` One or more glob patterns to use for matching.\n * @param {Object} `options` See available [options](#options)\n * @return {Array} Returns an array of matches\n * @summary false\n * @api public\n */\n\nconst micromatch = (list, patterns, options) => {\n  patterns = [].concat(patterns);\n  list = [].concat(list);\n\n  let omit = new Set();\n  let keep = new Set();\n  let items = new Set();\n  let negatives = 0;\n\n  let onResult = state => {\n    items.add(state.output);\n    if (options && options.onResult) {\n      options.onResult(state);\n    }\n  };\n\n  for (let i = 0; i < patterns.length; i++) {\n    let isMatch = picomatch(String(patterns[i]), { ...options, onResult }, true);\n    let negated = isMatch.state.negated || isMatch.state.negatedExtglob;\n    if (negated) negatives++;\n\n    for (let item of list) {\n      let matched = isMatch(item, true);\n\n      let match = negated ? !matched.isMatch : matched.isMatch;\n      if (!match) continue;\n\n      if (negated) {\n        omit.add(matched.output);\n      } else {\n        omit.delete(matched.output);\n        keep.add(matched.output);\n      }\n    }\n  }\n\n  let result = negatives === patterns.length ? [...items] : [...keep];\n  let matches = result.filter(item => !omit.has(item));\n\n  if (options && matches.length === 0) {\n    if (options.failglob === true) {\n      throw new Error(`No matches found for \"${patterns.join(', ')}\"`);\n    }\n\n    if (options.nonull === true || options.nullglob === true) {\n      return options.unescape ? patterns.map(p => p.replace(/\\\\/g, '')) : patterns;\n    }\n  }\n\n  return matches;\n};\n\n/**\n * Backwards compatibility\n */\n\nmicromatch.match = micromatch;\n\n/**\n * Returns a matcher function from the given glob `pattern` and `options`.\n * The returned function takes a string to match as its only argument and returns\n * true if the string is a match.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.matcher(pattern[, options]);\n *\n * const isMatch = mm.matcher('*.!(*a)');\n * console.log(isMatch('a.a')); //=> false\n * console.log(isMatch('a.b')); //=> true\n * ```\n * @param {String} `pattern` Glob pattern\n * @param {Object} `options`\n * @return {Function} Returns a matcher function.\n * @api public\n */\n\nmicromatch.matcher = (pattern, options) => picomatch(pattern, options);\n\n/**\n * Returns true if **any** of the given glob `patterns` match the specified `string`.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.isMatch(string, patterns[, options]);\n *\n * console.log(mm.isMatch('a.a', ['b.*', '*.a'])); //=> true\n * console.log(mm.isMatch('a.a', 'b.*')); //=> false\n * ```\n * @param {String} `str` The string to test.\n * @param {String|Array} `patterns` One or more glob patterns to use for matching.\n * @param {Object} `[options]` See available [options](#options).\n * @return {Boolean} Returns true if any patterns match `str`\n * @api public\n */\n\nmicromatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);\n\n/**\n * Backwards compatibility\n */\n\nmicromatch.any = micromatch.isMatch;\n\n/**\n * Returns a list of strings that _**do not match any**_ of the given `patterns`.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.not(list, patterns[, options]);\n *\n * console.log(mm.not(['a.a', 'b.b', 'c.c'], '*.a'));\n * //=> ['b.b', 'c.c']\n * ```\n * @param {Array} `list` Array of strings to match.\n * @param {String|Array} `patterns` One or more glob pattern to use for matching.\n * @param {Object} `options` See available [options](#options) for changing how matches are performed\n * @return {Array} Returns an array of strings that **do not match** the given patterns.\n * @api public\n */\n\nmicromatch.not = (list, patterns, options = {}) => {\n  patterns = [].concat(patterns).map(String);\n  let result = new Set();\n  let items = [];\n\n  let onResult = state => {\n    if (options.onResult) options.onResult(state);\n    items.push(state.output);\n  };\n\n  let matches = new Set(micromatch(list, patterns, { ...options, onResult }));\n\n  for (let item of items) {\n    if (!matches.has(item)) {\n      result.add(item);\n    }\n  }\n  return [...result];\n};\n\n/**\n * Returns true if the given `string` contains the given pattern. Similar\n * to [.isMatch](#isMatch) but the pattern can match any part of the string.\n *\n * ```js\n * var mm = require('micromatch');\n * // mm.contains(string, pattern[, options]);\n *\n * console.log(mm.contains('aa/bb/cc', '*b'));\n * //=> true\n * console.log(mm.contains('aa/bb/cc', '*d'));\n * //=> false\n * ```\n * @param {String} `str` The string to match.\n * @param {String|Array} `patterns` Glob pattern to use for matching.\n * @param {Object} `options` See available [options](#options) for changing how matches are performed\n * @return {Boolean} Returns true if any of the patterns matches any part of `str`.\n * @api public\n */\n\nmicromatch.contains = (str, pattern, options) => {\n  if (typeof str !== 'string') {\n    throw new TypeError(`Expected a string: \"${util.inspect(str)}\"`);\n  }\n\n  if (Array.isArray(pattern)) {\n    return pattern.some(p => micromatch.contains(str, p, options));\n  }\n\n  if (typeof pattern === 'string') {\n    if (isEmptyString(str) || isEmptyString(pattern)) {\n      return false;\n    }\n\n    if (str.includes(pattern) || (str.startsWith('./') && str.slice(2).includes(pattern))) {\n      return true;\n    }\n  }\n\n  return micromatch.isMatch(str, pattern, { ...options, contains: true });\n};\n\n/**\n * Filter the keys of the given object with the given `glob` pattern\n * and `options`. Does not attempt to match nested keys. If you need this feature,\n * use [glob-object][] instead.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.matchKeys(object, patterns[, options]);\n *\n * const obj = { aa: 'a', ab: 'b', ac: 'c' };\n * console.log(mm.matchKeys(obj, '*b'));\n * //=> { ab: 'b' }\n * ```\n * @param {Object} `object` The object with keys to filter.\n * @param {String|Array} `patterns` One or more glob patterns to use for matching.\n * @param {Object} `options` See available [options](#options) for changing how matches are performed\n * @return {Object} Returns an object with only keys that match the given patterns.\n * @api public\n */\n\nmicromatch.matchKeys = (obj, patterns, options) => {\n  if (!utils.isObject(obj)) {\n    throw new TypeError('Expected the first argument to be an object');\n  }\n  let keys = micromatch(Object.keys(obj), patterns, options);\n  let res = {};\n  for (let key of keys) res[key] = obj[key];\n  return res;\n};\n\n/**\n * Returns true if some of the strings in the given `list` match any of the given glob `patterns`.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.some(list, patterns[, options]);\n *\n * console.log(mm.some(['foo.js', 'bar.js'], ['*.js', '!foo.js']));\n * // true\n * console.log(mm.some(['foo.js'], ['*.js', '!foo.js']));\n * // false\n * ```\n * @param {String|Array} `list` The string or array of strings to test. Returns as soon as the first match is found.\n * @param {String|Array} `patterns` One or more glob patterns to use for matching.\n * @param {Object} `options` See available [options](#options) for changing how matches are performed\n * @return {Boolean} Returns true if any `patterns` matches any of the strings in `list`\n * @api public\n */\n\nmicromatch.some = (list, patterns, options) => {\n  let items = [].concat(list);\n\n  for (let pattern of [].concat(patterns)) {\n    let isMatch = picomatch(String(pattern), options);\n    if (items.some(item => isMatch(item))) {\n      return true;\n    }\n  }\n  return false;\n};\n\n/**\n * Returns true if every string in the given `list` matches\n * any of the given glob `patterns`.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.every(list, patterns[, options]);\n *\n * console.log(mm.every('foo.js', ['foo.js']));\n * // true\n * console.log(mm.every(['foo.js', 'bar.js'], ['*.js']));\n * // true\n * console.log(mm.every(['foo.js', 'bar.js'], ['*.js', '!foo.js']));\n * // false\n * console.log(mm.every(['foo.js'], ['*.js', '!foo.js']));\n * // false\n * ```\n * @param {String|Array} `list` The string or array of strings to test.\n * @param {String|Array} `patterns` One or more glob patterns to use for matching.\n * @param {Object} `options` See available [options](#options) for changing how matches are performed\n * @return {Boolean} Returns true if all `patterns` matches all of the strings in `list`\n * @api public\n */\n\nmicromatch.every = (list, patterns, options) => {\n  let items = [].concat(list);\n\n  for (let pattern of [].concat(patterns)) {\n    let isMatch = picomatch(String(pattern), options);\n    if (!items.every(item => isMatch(item))) {\n      return false;\n    }\n  }\n  return true;\n};\n\n/**\n * Returns true if **all** of the given `patterns` match\n * the specified string.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.all(string, patterns[, options]);\n *\n * console.log(mm.all('foo.js', ['foo.js']));\n * // true\n *\n * console.log(mm.all('foo.js', ['*.js', '!foo.js']));\n * // false\n *\n * console.log(mm.all('foo.js', ['*.js', 'foo.js']));\n * // true\n *\n * console.log(mm.all('foo.js', ['*.js', 'f*', '*o*', '*o.js']));\n * // true\n * ```\n * @param {String|Array} `str` The string to test.\n * @param {String|Array} `patterns` One or more glob patterns to use for matching.\n * @param {Object} `options` See available [options](#options) for changing how matches are performed\n * @return {Boolean} Returns true if any patterns match `str`\n * @api public\n */\n\nmicromatch.all = (str, patterns, options) => {\n  if (typeof str !== 'string') {\n    throw new TypeError(`Expected a string: \"${util.inspect(str)}\"`);\n  }\n\n  return [].concat(patterns).every(p => picomatch(p, options)(str));\n};\n\n/**\n * Returns an array of matches captured by `pattern` in `string, or `null` if the pattern did not match.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.capture(pattern, string[, options]);\n *\n * console.log(mm.capture('test/*.js', 'test/foo.js'));\n * //=> ['foo']\n * console.log(mm.capture('test/*.js', 'foo/bar.css'));\n * //=> null\n * ```\n * @param {String} `glob` Glob pattern to use for matching.\n * @param {String} `input` String to match\n * @param {Object} `options` See available [options](#options) for changing how matches are performed\n * @return {Array|null} Returns an array of captures if the input matches the glob pattern, otherwise `null`.\n * @api public\n */\n\nmicromatch.capture = (glob, input, options) => {\n  let posix = utils.isWindows(options);\n  let regex = picomatch.makeRe(String(glob), { ...options, capture: true });\n  let match = regex.exec(posix ? utils.toPosixSlashes(input) : input);\n\n  if (match) {\n    return match.slice(1).map(v => v === void 0 ? '' : v);\n  }\n};\n\n/**\n * Create a regular expression from the given glob `pattern`.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.makeRe(pattern[, options]);\n *\n * console.log(mm.makeRe('*.js'));\n * //=> /^(?:(\\.[\\\\\\/])?(?!\\.)(?=.)[^\\/]*?\\.js)$/\n * ```\n * @param {String} `pattern` A glob pattern to convert to regex.\n * @param {Object} `options`\n * @return {RegExp} Returns a regex created from the given pattern.\n * @api public\n */\n\nmicromatch.makeRe = (...args) => picomatch.makeRe(...args);\n\n/**\n * Scan a glob pattern to separate the pattern into segments. Used\n * by the [split](#split) method.\n *\n * ```js\n * const mm = require('micromatch');\n * const state = mm.scan(pattern[, options]);\n * ```\n * @param {String} `pattern`\n * @param {Object} `options`\n * @return {Object} Returns an object with\n * @api public\n */\n\nmicromatch.scan = (...args) => picomatch.scan(...args);\n\n/**\n * Parse a glob pattern to create the source string for a regular\n * expression.\n *\n * ```js\n * const mm = require('micromatch');\n * const state = mm.parse(pattern[, options]);\n * ```\n * @param {String} `glob`\n * @param {Object} `options`\n * @return {Object} Returns an object with useful properties and output to be used as regex source string.\n * @api public\n */\n\nmicromatch.parse = (patterns, options) => {\n  let res = [];\n  for (let pattern of [].concat(patterns || [])) {\n    for (let str of braces(String(pattern), options)) {\n      res.push(picomatch.parse(str, options));\n    }\n  }\n  return res;\n};\n\n/**\n * Process the given brace `pattern`.\n *\n * ```js\n * const { braces } = require('micromatch');\n * console.log(braces('foo/{a,b,c}/bar'));\n * //=> [ 'foo/(a|b|c)/bar' ]\n *\n * console.log(braces('foo/{a,b,c}/bar', { expand: true }));\n * //=> [ 'foo/a/bar', 'foo/b/bar', 'foo/c/bar' ]\n * ```\n * @param {String} `pattern` String with brace pattern to process.\n * @param {Object} `options` Any [options](#options) to change how expansion is performed. See the [braces][] library for all available options.\n * @return {Array}\n * @api public\n */\n\nmicromatch.braces = (pattern, options) => {\n  if (typeof pattern !== 'string') throw new TypeError('Expected a string');\n  if ((options && options.nobrace === true) || !hasBraces(pattern)) {\n    return [pattern];\n  }\n  return braces(pattern, options);\n};\n\n/**\n * Expand braces\n */\n\nmicromatch.braceExpand = (pattern, options) => {\n  if (typeof pattern !== 'string') throw new TypeError('Expected a string');\n  return micromatch.braces(pattern, { ...options, expand: true });\n};\n\n/**\n * Expose micromatch\n */\n\n// exposed for tests\nmicromatch.hasBraces = hasBraces;\nmodule.exports = micromatch;\n","import path from 'path';\nimport * as pluginInfo from '../package.json';\nimport { transformJsx } from './jsx';\nimport { transformVue } from './vue';\nimport { PluginOptions, TTransformer } from './type';\nimport crypto from 'node:crypto';\nimport micromatch from 'micromatch';\n\nconst transformerFileTypes: Record<string, string[]> = {\n  vue: ['vue'],\n  jsx: ['jsx', 'tsx', 'js', 'ts'],\n};\n\nconst transformers: Record<string, TTransformer> = {\n  vue: transformVue,\n  jsx: transformJsx,\n};\n\nconst DEFAULT_INCLUDE = ['src/**/*.{vue,jsx,tsx,js,ts}'];\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst cache = new Map<string, { code: string; map?: any }>();\n\nfunction getHash(code: string) {\n  return crypto.createHash('md5').update(code).digest('hex');\n}\n\nconst warningMaps = new Map<string, string[]>();\n\nexport function vitePluginTestIdChecker(options: PluginOptions = {}) {\n  const { include = DEFAULT_INCLUDE, exclude = [], attributes = ['data-testid'] } = options;\n\n  const includeArr = Array.isArray(include) ? include : [include];\n  const excludeArr = Array.isArray(exclude) ? exclude : [exclude];\n\n  function isIncluded(file: string) {\n    const matched = includeArr.some((pattern) => {\n      return micromatch.isMatch(file, pattern);\n    });\n\n    const excluded = excludeArr.length > 0 && excludeArr.some((pattern) => micromatch.isMatch(file, pattern));\n    return matched && !excluded;\n  }\n\n  return {\n    name: pluginInfo.name,\n    enforce: 'pre' as const,\n    apply: 'build' as const,\n    version: pluginInfo.version,\n    async transform(code: string, id: string) {\n      const relativePath = path.relative(process.cwd(), id);\n\n      if (!isIncluded(relativePath)) return;\n      const hash = getHash(code);\n      const cacheKey = `${id}:${hash}`;\n      if (cache.has(cacheKey)) {\n        const value = cache.get(cacheKey);\n        // eslint-disable-next-line consistent-return\n        return value;\n      }\n      const transformer = Object.keys(transformers).find((key) => {\n        const fileTypes = transformerFileTypes[key];\n        return fileTypes.some((type) => id.endsWith(`.${type}`));\n      });\n\n      if (!transformer) {\n        return;\n      }\n      const result = transformers[transformer]?.(code, id, attributes);\n      cache.set(cacheKey, result);\n\n      if (result.errors?.length) {\n        warningMaps.set(relativePath, result.errors);\n      }\n      // eslint-disable-next-line consistent-return\n      return {\n        code: result.code,\n        map: result.map,\n      };\n    },\n    buildEnd() {\n      const errors = Array.from(warningMaps.values()).flat();\n      if (errors.length) {\n        throw new Error(errors.join('\\n'));\n      }\n    },\n  };\n}\n","import path from 'path';\nimport MagicString from 'magic-string';\nimport { parse as parseSFC } from '@vue/compiler-sfc';\nimport { parse as parseTemplate, NodeTypes, ElementNode, DirectiveNode } from '@vue/compiler-dom';\nimport { TTransformer } from './type';\nimport { EVENT_TAGS, DIRECTIVE_NAMES } from './constants';\n\nconst hasEvent = (node: ElementNode) => {\n  return EVENT_TAGS.includes(node.tag) || node.props.some((prop) => DIRECTIVE_NAMES.includes((prop as any).rawName));\n};\n\n// --- Vue 处理 ---\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const transformVue: TTransformer = (code: string, id: string, attributes: string[]) => {\n  // 只在测试构建时执行\n  const isTestBuild = process.env.NODE_ENV === 'test' || process.env.BUILD_MODE === 'test' || process.env.VITE_TEST_BUILD === 'true';\n  if (!isTestBuild) {\n    return { code, map: null };\n  }\n\n  // 获取相对于 src 上一层的路径\n  const projectRoot = path.resolve(process.cwd(), '..');\n  const relativePath = path.relative(projectRoot, id);\n\n  const { descriptor } = parseSFC(code, {\n    filename: id,\n    sourceMap: true,\n  });\n  const { template } = descriptor;\n\n  if (!template) return { code, map: null };\n\n  const ms = new MagicString(code);\n\n  const ast = parseTemplate(template.content, {\n    comments: false,\n    isNativeTag: (tag) => true,\n  });\n\n  const errorMaps = new Map<string, string>();\n\n  const injectAttributes = (node: ElementNode, parentStack: ElementNode[] = []) => {\n    if (node.type === NodeTypes.ELEMENT) {\n      if (node.tag === 'template') return;\n      const isHasEvent = hasEvent(node);\n      if (isHasEvent) {\n        const dataTestIdProp = (node.props as DirectiveNode[]).filter((prop) => attributes.includes(prop.name));\n\n        if (dataTestIdProp.length !== attributes.length) {\n          const missingAttributes = attributes.filter((attr) => !dataTestIdProp.some((prop) => prop.name === attr));\n          errorMaps.set(\n            relativePath,\n            `${missingAttributes.join(',')} is required for ${node.tag} in ${relativePath}:${node.loc.start.line}:${node.loc.start.column}`\n          );\n        }\n      }\n    }\n\n    if (node.children) {\n      node.children.forEach((child) => {\n        if (child.type === NodeTypes.ELEMENT) {\n          injectAttributes(child, [...parentStack, node]);\n        }\n      });\n    }\n  };\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  injectAttributes(ast as any);\n\n  return {\n    code: ms.toString(),\n    map: ms.generateMap({ hires: true }),\n    errors: Array.from(errorMaps.values()),\n  };\n};\n"],"names":["EVENT_TAGS","DIRECTIVE_NAMES","_optionalChain","ops","lastAccessLHS","value","i","length","op","fn","args","call","undefined","traverse","traverseModle","default","generate","generateModule","isInteger","num","Number","trim","exports","find","node","type","nodes","exceedsLimit","min","max","step","limit","escapeNode","block","n","escaped","encloseBrace","commas","ranges","invalid","isInvalidBrace","dollar","open","close","isOpenOrClose","reduce","acc","push","flatten","result","flat","arr","ele","Array","isArray","utils","require$$0","stringify","ast","options","parent","invalidBlock","escapeInvalid","invalidNode","output","child","isNumber","isFinite","toRegexRange","TypeError","String","opts","relaxZeros","strictZeros","cacheKey","shorthand","capture","wrap","cache","hasOwnProperty","a","Math","b","abs","isPadded","hasPadding","state","positives","negatives","maxLen","splitToPatterns","neg","pos","onlyNegative","filterPatterns","onlyPositive","intersected","concat","join","collatePatterns","rangeToPattern","start","stop","pattern","count","digits","zipped","zip","startDigit","stopDigit","toCharacterClass","tok","prev","nines","zeros","countNines","stops","Set","add","countZeros","sort","compare","splitToRanges","tokens","obj","padZeros","string","toQuantifier","pop","comparison","prefix","intersection","contains","key","val","some","len","slice","repeat","integer","pow","str","test","diff","relax","clearCache","toRegexRange_1","util","require$$1","isObject","isValidValue","input","index","pad","maxLength","toNumber","dash","padStart","toMaxLen","negative","toRange","isNumbers","fromCharCode","toRegex","end","rangeError","RangeError","inspect","invalidRange","strictRanges","fillNumbers","descending","startString","endString","stepString","padded","format","transform","parts","range","map","v","toSequence","fill","charCodeAt","fillLetters","invalidStep","fillRange","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","CHAR_0","CHAR_9","CHAR_UPPERCASE_A","CHAR_LOWERCASE_A","CHAR_UPPERCASE_Z","CHAR_LOWERCASE_Z","CHAR_ASTERISK","CHAR_AMPERSAND","CHAR_AT","CHAR_CARRIAGE_RETURN","CHAR_CIRCUMFLEX_ACCENT","CHAR_COLON","CHAR_DOLLAR","CHAR_EQUAL","CHAR_EXCLAMATION_MARK","CHAR_FORM_FEED","CHAR_FORWARD_SLASH","CHAR_HASH","CHAR_HYPHEN_MINUS","CHAR_LEFT_ANGLE_BRACKET","CHAR_LINE_FEED","CHAR_PERCENT","CHAR_PLUS","CHAR_QUESTION_MARK","CHAR_RIGHT_ANGLE_BRACKET","CHAR_SEMICOLON","CHAR_SPACE","CHAR_TAB","CHAR_UNDERSCORE","CHAR_VERTICAL_LINE","parse_1","SyntaxError","stack","brackets","depth","advance","next","keepQuotes","shift","siblings","before","keepEscaping","forEach","isOpen","isClose","indexOf","splice","compile","compile_1","walk","console","log","expand","require$$2","append","queue","stash","enclose","item","expand_1","rangeLimit","p","q","parse","require$$3","braces","create","nodupes","noempty","filter","Boolean","braces_1","path","WIN_SLASH","WIN_NO_SLASH","DOT_LITERAL","SLASH_LITERAL","QMARK","END_ANCHOR","START_ANCHOR","DOTS_SLASH","POSIX_CHARS","PLUS_LITERAL","QMARK_LITERAL","ONE_CHAR","NO_DOT","NO_DOTS","NO_DOT_SLASH","NO_DOTS_SLASH","QMARK_NO_DOT","STAR","WINDOWS_CHARS","POSIX_REGEX_SOURCE","alnum","alpha","ascii","blank","cntrl","digit","graph","lower","print","punct","space","upper","word","xdigit","REGEX_BACKSLASH","REGEX_NON_SPECIAL_CHARS","REGEX_SPECIAL_CHARS","REGEX_SPECIAL_CHARS_BACKREF","REGEX_SPECIAL_CHARS_GLOBAL","REGEX_REMOVE_BACKSLASH","REPLACEMENTS","CHAR_BACKWARD_SLASH","CHAR_GRAVE_ACCENT","SEP","sep","extglobChars","chars","globChars","win32","process","platform","hasRegexChars","isRegexChar","escapeRegex","replace","toPosixSlashes","removeBackslashes","match","supportsLookbehinds","segs","version","split","isWindows","windows","escapeLast","char","lastIdx","idx","lastIndexOf","removePrefix","startsWith","wrapOutput","negated","scan","isPathSeparator","code","token","isPrefix","isGlobstar","Infinity","scan_1","scanToEnd","slashes","lastIndex","isBrace","isBracket","isGlob","isExtglob","braceEscaped","backslashes","negatedExtglob","finished","eos","peek","noext","nonegate","noparen","base","glob","unescape","maxDepth","prevIndex","expandRange","RegExp","ex","syntaxError","bos","prepend","PLATFORM_CHARS","EXTGLOB_CHARS","globstar","dot","nodot","qmarkNoDot","star","bash","noextglob","consumed","backtrack","parens","quotes","extglobs","remaining","consume","negate","increment","decrement","extglob","inner","extglobOpen","conditions","extglobClose","rest","extglobStar","includes","expression","fastpaths","m","esc","first","exec","posix","pre","strictBrackets","nobracket","prevValue","literalBrackets","nobrace","outputIndex","tokensIndex","brace","dots","unshift","comma","out","toks","t","Error","regex","noglobstar","prior","isStart","afterStar","after","strictSlashes","suffix","slashDot","source","require$$4","picomatch","returnState","fns","arrayMatcher","isMatch","isState","compileRe","makeRe","isIgnored","ignore","ignoreOpts","onMatch","onResult","matcher","returnObject","onIgnore","matchBase","basename","patterns","returnOutput","parsed","flags","nocase","err","debug","picomatch_1","isEmptyString","hasBraces","micromatch","list","omit","keep","items","matched","delete","matches","has","failglob","nonull","nullglob","any","not","matchKeys","keys","Object","res","every","all","braceExpand","micromatch_1","transformerFileTypes","vue","jsx","transformers","id","attributes","env","NODE_ENV","BUILD_MODE","VITE_TEST_BUILD","projectRoot","resolve","cwd","relativePath","relative","descriptor","parseSFC","filename","sourceMap","template","ms","MagicString","parseTemplate","content","comments","isNativeTag","tag","errorMaps","Map","injectAttributes","parentStack","NodeTypes","ELEMENT","isHasEvent","props","prop","rawName","hasEvent","dataTestIdProp","name","missingAttributes","attr","set","loc","line","column","children","toString","generateMap","hires","errors","from","values","babelParser","sourceType","plugins","fPath","JSXOpeningElement","_","_2","_3","_4","StartColumn","_5","_6","_7","_8","isJSXIdentifier","isJSXMemberExpression","object","property","tagName","toLowerCase","isJSXAttribute","attrName","toUpperCase","existingAttributes","DEFAULT_INCLUDE","warningMaps","vitePluginTestIdChecker","include","exclude","includeArr","excludeArr","enforce","apply","file","excluded","isIncluded","hash","crypto","createHash","update","digest","getHash","get","transformer","endsWith","buildEnd"],"mappings":"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","x_google_ignoreList":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18]}