kirbyup 2.0.1 → 2.0.2-beta.0

package/dist/shared/kirbyup.3c5fa7eb.mjs

@@ -1,3633 +0,0 @@
-import { existsSync as existsSync$1, unlinkSync } from 'node:fs';
-import { writeFile, readFile } from 'node:fs/promises';
-import { normalize, relative, resolve as resolve$1, dirname, basename } from 'pathe';
-import { transformWithEsbuild, formatPostcssSourceMap, createServer, mergeConfig, build as build$1 } from 'vite';
-import fs, { existsSync, statSync } from 'fs';
-import path$2, { win32, posix, isAbsolute, resolve } from 'path';
-import { createRequire } from 'module';
-import { createHash } from 'crypto';
-import postcssrc from 'postcss-load-config';
-import postcssLogical from 'postcss-logical';
-import postcssDirPseudoClass from 'postcss-dir-pseudo-class';
-import consola from 'consola';
-import { debounce } from 'perfect-debounce';
-import colors from 'picocolors';
-import fullReloadPlugin from 'vite-plugin-full-reload';
-import { gzip } from 'zlib';
-import { promisify } from 'util';
-import { createConfigLoader } from 'unconfig';
-import MagicString from 'magic-string';
-import { detect } from 'detect-package-manager';
-
-var utils$3 = {};
-
-const path$1 = path$2;
-const WIN_SLASH = '\\\\/';
-const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
-
-/**
- * Posix glob regex
- */
-
-const DOT_LITERAL = '\\.';
-const PLUS_LITERAL = '\\+';
-const QMARK_LITERAL = '\\?';
-const SLASH_LITERAL = '\\/';
-const ONE_CHAR = '(?=.)';
-const QMARK = '[^/]';
-const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
-const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
-const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
-const NO_DOT = `(?!${DOT_LITERAL})`;
-const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
-const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
-const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
-const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
-const STAR = `${QMARK}*?`;
-
-const POSIX_CHARS = {
-  DOT_LITERAL,
-  PLUS_LITERAL,
-  QMARK_LITERAL,
-  SLASH_LITERAL,
-  ONE_CHAR,
-  QMARK,
-  END_ANCHOR,
-  DOTS_SLASH,
-  NO_DOT,
-  NO_DOTS,
-  NO_DOT_SLASH,
-  NO_DOTS_SLASH,
-  QMARK_NO_DOT,
-  STAR,
-  START_ANCHOR
-};
-
-/**
- * Windows glob regex
- */
-
-const WINDOWS_CHARS = {
-  ...POSIX_CHARS,
-
-  SLASH_LITERAL: `[${WIN_SLASH}]`,
-  QMARK: WIN_NO_SLASH,
-  STAR: `${WIN_NO_SLASH}*?`,
-  DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
-  NO_DOT: `(?!${DOT_LITERAL})`,
-  NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
-  NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
-  NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
-  QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
-  START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
-  END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
-};
-
-/**
- * POSIX Bracket Regex
- */
-
-const POSIX_REGEX_SOURCE$1 = {
-  alnum: 'a-zA-Z0-9',
-  alpha: 'a-zA-Z',
-  ascii: '\\x00-\\x7F',
-  blank: ' \\t',
-  cntrl: '\\x00-\\x1F\\x7F',
-  digit: '0-9',
-  graph: '\\x21-\\x7E',
-  lower: 'a-z',
-  print: '\\x20-\\x7E ',
-  punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~',
-  space: ' \\t\\r\\n\\v\\f',
-  upper: 'A-Z',
-  word: 'A-Za-z0-9_',
-  xdigit: 'A-Fa-f0-9'
-};
-
-var constants$2 = {
-  MAX_LENGTH: 1024 * 64,
-  POSIX_REGEX_SOURCE: POSIX_REGEX_SOURCE$1,
-
-  // regular expressions
-  REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
-  REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
-  REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
-  REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
-  REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
-  REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
-
-  // Replace globs with equivalent patterns to reduce parsing time.
-  REPLACEMENTS: {
-    '***': '*',
-    '**/**': '**',
-    '**/**/**': '**'
-  },
-
-  // Digits
-  CHAR_0: 48, /* 0 */
-  CHAR_9: 57, /* 9 */
-
-  // Alphabet chars.
-  CHAR_UPPERCASE_A: 65, /* A */
-  CHAR_LOWERCASE_A: 97, /* a */
-  CHAR_UPPERCASE_Z: 90, /* Z */
-  CHAR_LOWERCASE_Z: 122, /* z */
-
-  CHAR_LEFT_PARENTHESES: 40, /* ( */
-  CHAR_RIGHT_PARENTHESES: 41, /* ) */
-
-  CHAR_ASTERISK: 42, /* * */
-
-  // Non-alphabetic chars.
-  CHAR_AMPERSAND: 38, /* & */
-  CHAR_AT: 64, /* @ */
-  CHAR_BACKWARD_SLASH: 92, /* \ */
-  CHAR_CARRIAGE_RETURN: 13, /* \r */
-  CHAR_CIRCUMFLEX_ACCENT: 94, /* ^ */
-  CHAR_COLON: 58, /* : */
-  CHAR_COMMA: 44, /* , */
-  CHAR_DOT: 46, /* . */
-  CHAR_DOUBLE_QUOTE: 34, /* " */
-  CHAR_EQUAL: 61, /* = */
-  CHAR_EXCLAMATION_MARK: 33, /* ! */
-  CHAR_FORM_FEED: 12, /* \f */
-  CHAR_FORWARD_SLASH: 47, /* / */
-  CHAR_GRAVE_ACCENT: 96, /* ` */
-  CHAR_HASH: 35, /* # */
-  CHAR_HYPHEN_MINUS: 45, /* - */
-  CHAR_LEFT_ANGLE_BRACKET: 60, /* < */
-  CHAR_LEFT_CURLY_BRACE: 123, /* { */
-  CHAR_LEFT_SQUARE_BRACKET: 91, /* [ */
-  CHAR_LINE_FEED: 10, /* \n */
-  CHAR_NO_BREAK_SPACE: 160, /* \u00A0 */
-  CHAR_PERCENT: 37, /* % */
-  CHAR_PLUS: 43, /* + */
-  CHAR_QUESTION_MARK: 63, /* ? */
-  CHAR_RIGHT_ANGLE_BRACKET: 62, /* > */
-  CHAR_RIGHT_CURLY_BRACE: 125, /* } */
-  CHAR_RIGHT_SQUARE_BRACKET: 93, /* ] */
-  CHAR_SEMICOLON: 59, /* ; */
-  CHAR_SINGLE_QUOTE: 39, /* ' */
-  CHAR_SPACE: 32, /*   */
-  CHAR_TAB: 9, /* \t */
-  CHAR_UNDERSCORE: 95, /* _ */
-  CHAR_VERTICAL_LINE: 124, /* | */
-  CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
-
-  SEP: path$1.sep,
-
-  /**
-   * Create EXTGLOB_CHARS
-   */
-
-  extglobChars(chars) {
-    return {
-      '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` },
-      '?': { type: 'qmark', open: '(?:', close: ')?' },
-      '+': { type: 'plus', open: '(?:', close: ')+' },
-      '*': { type: 'star', open: '(?:', close: ')*' },
-      '@': { type: 'at', open: '(?:', close: ')' }
-    };
-  },
-
-  /**
-   * Create GLOB_CHARS
-   */
-
-  globChars(win32) {
-    return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
-  }
-};
-
-(function (exports) {
-
-const path = path$2;
-const win32 = process.platform === 'win32';
-const {
-  REGEX_BACKSLASH,
-  REGEX_REMOVE_BACKSLASH,
-  REGEX_SPECIAL_CHARS,
-  REGEX_SPECIAL_CHARS_GLOBAL
-} = constants$2;
-
-exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
-exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);
-exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str);
-exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
-exports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/');
-
-exports.removeBackslashes = str => {
-  return str.replace(REGEX_REMOVE_BACKSLASH, match => {
-    return match === '\\' ? '' : match;
-  });
-};
-
-exports.supportsLookbehinds = () => {
-  const segs = process.version.slice(1).split('.').map(Number);
-  if (segs.length === 3 && segs[0] >= 9 || (segs[0] === 8 && segs[1] >= 10)) {
-    return true;
-  }
-  return false;
-};
-
-exports.isWindows = options => {
-  if (options && typeof options.windows === 'boolean') {
-    return options.windows;
-  }
-  return win32 === true || path.sep === '\\';
-};
-
-exports.escapeLast = (input, char, lastIdx) => {
-  const idx = input.lastIndexOf(char, lastIdx);
-  if (idx === -1) return input;
-  if (input[idx - 1] === '\\') return exports.escapeLast(input, char, idx - 1);
-  return `${input.slice(0, idx)}\\${input.slice(idx)}`;
-};
-
-exports.removePrefix = (input, state = {}) => {
-  let output = input;
-  if (output.startsWith('./')) {
-    output = output.slice(2);
-    state.prefix = './';
-  }
-  return output;
-};
-
-exports.wrapOutput = (input, state = {}, options = {}) => {
-  const prepend = options.contains ? '' : '^';
-  const append = options.contains ? '' : '$';
-
-  let output = `${prepend}(?:${input})${append}`;
-  if (state.negated === true) {
-    output = `(?:^(?!${output}).*$)`;
-  }
-  return output;
-};
-}(utils$3));
-
-const utils$2 = utils$3;
-const {
-  CHAR_ASTERISK,             /* * */
-  CHAR_AT,                   /* @ */
-  CHAR_BACKWARD_SLASH,       /* \ */
-  CHAR_COMMA,                /* , */
-  CHAR_DOT,                  /* . */
-  CHAR_EXCLAMATION_MARK,     /* ! */
-  CHAR_FORWARD_SLASH,        /* / */
-  CHAR_LEFT_CURLY_BRACE,     /* { */
-  CHAR_LEFT_PARENTHESES,     /* ( */
-  CHAR_LEFT_SQUARE_BRACKET,  /* [ */
-  CHAR_PLUS,                 /* + */
-  CHAR_QUESTION_MARK,        /* ? */
-  CHAR_RIGHT_CURLY_BRACE,    /* } */
-  CHAR_RIGHT_PARENTHESES,    /* ) */
-  CHAR_RIGHT_SQUARE_BRACKET  /* ] */
-} = constants$2;
-
-const isPathSeparator = code => {
-  return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
-};
-
-const depth = token => {
-  if (token.isPrefix !== true) {
-    token.depth = token.isGlobstar ? Infinity : 1;
-  }
-};
-
-/**
- * Quickly scans a glob pattern and returns an object with a handful of
- * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
- * `glob` (the actual pattern), `negated` (true if the path starts with `!` but not
- * with `!(`) and `negatedExtglob` (true if the path starts with `!(`).
- *
- * ```js
- * const pm = require('picomatch');
- * console.log(pm.scan('foo/bar/*.js'));
- * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
- * ```
- * @param {String} `str`
- * @param {Object} `options`
- * @return {Object} Returns an object with tokens and regex source string.
- * @api public
- */
-
-const scan$1 = (input, options) => {
-  const opts = options || {};
-
-  const length = input.length - 1;
-  const scanToEnd = opts.parts === true || opts.scanToEnd === true;
-  const slashes = [];
-  const tokens = [];
-  const parts = [];
-
-  let str = input;
-  let index = -1;
-  let start = 0;
-  let lastIndex = 0;
-  let isBrace = false;
-  let isBracket = false;
-  let isGlob = false;
-  let isExtglob = false;
-  let isGlobstar = false;
-  let braceEscaped = false;
-  let backslashes = false;
-  let negated = false;
-  let negatedExtglob = false;
-  let finished = false;
-  let braces = 0;
-  let prev;
-  let code;
-  let token = { value: '', depth: 0, isGlob: false };
-
-  const eos = () => index >= length;
-  const peek = () => str.charCodeAt(index + 1);
-  const advance = () => {
-    prev = code;
-    return str.charCodeAt(++index);
-  };
-
-  while (index < length) {
-    code = advance();
-    let next;
-
-    if (code === CHAR_BACKWARD_SLASH) {
-      backslashes = token.backslashes = true;
-      code = advance();
-
-      if (code === CHAR_LEFT_CURLY_BRACE) {
-        braceEscaped = true;
-      }
-      continue;
-    }
-
-    if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
-      braces++;
-
-      while (eos() !== true && (code = advance())) {
-        if (code === CHAR_BACKWARD_SLASH) {
-          backslashes = token.backslashes = true;
-          advance();
-          continue;
-        }
-
-        if (code === CHAR_LEFT_CURLY_BRACE) {
-          braces++;
-          continue;
-        }
-
-        if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
-          isBrace = token.isBrace = true;
-          isGlob = token.isGlob = true;
-          finished = true;
-
-          if (scanToEnd === true) {
-            continue;
-          }
-
-          break;
-        }
-
-        if (braceEscaped !== true && code === CHAR_COMMA) {
-          isBrace = token.isBrace = true;
-          isGlob = token.isGlob = true;
-          finished = true;
-
-          if (scanToEnd === true) {
-            continue;
-          }
-
-          break;
-        }
-
-        if (code === CHAR_RIGHT_CURLY_BRACE) {
-          braces--;
-
-          if (braces === 0) {
-            braceEscaped = false;
-            isBrace = token.isBrace = true;
-            finished = true;
-            break;
-          }
-        }
-      }
-
-      if (scanToEnd === true) {
-        continue;
-      }
-
-      break;
-    }
-
-    if (code === CHAR_FORWARD_SLASH) {
-      slashes.push(index);
-      tokens.push(token);
-      token = { value: '', depth: 0, isGlob: false };
-
-      if (finished === true) continue;
-      if (prev === CHAR_DOT && index === (start + 1)) {
-        start += 2;
-        continue;
-      }
-
-      lastIndex = index + 1;
-      continue;
-    }
-
-    if (opts.noext !== true) {
-      const isExtglobChar = code === CHAR_PLUS
-        || code === CHAR_AT
-        || code === CHAR_ASTERISK
-        || code === CHAR_QUESTION_MARK
-        || code === CHAR_EXCLAMATION_MARK;
-
-      if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
-        isGlob = token.isGlob = true;
-        isExtglob = token.isExtglob = true;
-        finished = true;
-        if (code === CHAR_EXCLAMATION_MARK && index === start) {
-          negatedExtglob = true;
-        }
-
-        if (scanToEnd === true) {
-          while (eos() !== true && (code = advance())) {
-            if (code === CHAR_BACKWARD_SLASH) {
-              backslashes = token.backslashes = true;
-              code = advance();
-              continue;
-            }
-
-            if (code === CHAR_RIGHT_PARENTHESES) {
-              isGlob = token.isGlob = true;
-              finished = true;
-              break;
-            }
-          }
-          continue;
-        }
-        break;
-      }
-    }
-
-    if (code === CHAR_ASTERISK) {
-      if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
-      isGlob = token.isGlob = true;
-      finished = true;
-
-      if (scanToEnd === true) {
-        continue;
-      }
-      break;
-    }
-
-    if (code === CHAR_QUESTION_MARK) {
-      isGlob = token.isGlob = true;
-      finished = true;
-
-      if (scanToEnd === true) {
-        continue;
-      }
-      break;
-    }
-
-    if (code === CHAR_LEFT_SQUARE_BRACKET) {
-      while (eos() !== true && (next = advance())) {
-        if (next === CHAR_BACKWARD_SLASH) {
-          backslashes = token.backslashes = true;
-          advance();
-          continue;
-        }
-
-        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
-          isBracket = token.isBracket = true;
-          isGlob = token.isGlob = true;
-          finished = true;
-          break;
-        }
-      }
-
-      if (scanToEnd === true) {
-        continue;
-      }
-
-      break;
-    }
-
-    if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
-      negated = token.negated = true;
-      start++;
-      continue;
-    }
-
-    if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
-      isGlob = token.isGlob = true;
-
-      if (scanToEnd === true) {
-        while (eos() !== true && (code = advance())) {
-          if (code === CHAR_LEFT_PARENTHESES) {
-            backslashes = token.backslashes = true;
-            code = advance();
-            continue;
-          }
-
-          if (code === CHAR_RIGHT_PARENTHESES) {
-            finished = true;
-            break;
-          }
-        }
-        continue;
-      }
-      break;
-    }
-
-    if (isGlob === true) {
-      finished = true;
-
-      if (scanToEnd === true) {
-        continue;
-      }
-
-      break;
-    }
-  }
-
-  if (opts.noext === true) {
-    isExtglob = false;
-    isGlob = false;
-  }
-
-  let base = str;
-  let prefix = '';
-  let glob = '';
-
-  if (start > 0) {
-    prefix = str.slice(0, start);
-    str = str.slice(start);
-    lastIndex -= start;
-  }
-
-  if (base && isGlob === true && lastIndex > 0) {
-    base = str.slice(0, lastIndex);
-    glob = str.slice(lastIndex);
-  } else if (isGlob === true) {
-    base = '';
-    glob = str;
-  } else {
-    base = str;
-  }
-
-  if (base && base !== '' && base !== '/' && base !== str) {
-    if (isPathSeparator(base.charCodeAt(base.length - 1))) {
-      base = base.slice(0, -1);
-    }
-  }
-
-  if (opts.unescape === true) {
-    if (glob) glob = utils$2.removeBackslashes(glob);
-
-    if (base && backslashes === true) {
-      base = utils$2.removeBackslashes(base);
-    }
-  }
-
-  const state = {
-    prefix,
-    input,
-    start,
-    base,
-    glob,
-    isBrace,
-    isBracket,
-    isGlob,
-    isExtglob,
-    isGlobstar,
-    negated,
-    negatedExtglob
-  };
-
-  if (opts.tokens === true) {
-    state.maxDepth = 0;
-    if (!isPathSeparator(code)) {
-      tokens.push(token);
-    }
-    state.tokens = tokens;
-  }
-
-  if (opts.parts === true || opts.tokens === true) {
-    let prevIndex;
-
-    for (let idx = 0; idx < slashes.length; idx++) {
-      const n = prevIndex ? prevIndex + 1 : start;
-      const i = slashes[idx];
-      const value = input.slice(n, i);
-      if (opts.tokens) {
-        if (idx === 0 && start !== 0) {
-          tokens[idx].isPrefix = true;
-          tokens[idx].value = prefix;
-        } else {
-          tokens[idx].value = value;
-        }
-        depth(tokens[idx]);
-        state.maxDepth += tokens[idx].depth;
-      }
-      if (idx !== 0 || value !== '') {
-        parts.push(value);
-      }
-      prevIndex = i;
-    }
-
-    if (prevIndex && prevIndex + 1 < input.length) {
-      const value = input.slice(prevIndex + 1);
-      parts.push(value);
-
-      if (opts.tokens) {
-        tokens[tokens.length - 1].value = value;
-        depth(tokens[tokens.length - 1]);
-        state.maxDepth += tokens[tokens.length - 1].depth;
-      }
-    }
-
-    state.slashes = slashes;
-    state.parts = parts;
-  }
-
-  return state;
-};
-
-var scan_1 = scan$1;
-
-const constants$1 = constants$2;
-const utils$1 = utils$3;
-
-/**
- * Constants
- */
-
-const {
-  MAX_LENGTH,
-  POSIX_REGEX_SOURCE,
-  REGEX_NON_SPECIAL_CHARS,
-  REGEX_SPECIAL_CHARS_BACKREF,
-  REPLACEMENTS
-} = constants$1;
-
-/**
- * Helpers
- */
-
-const expandRange = (args, options) => {
-  if (typeof options.expandRange === 'function') {
-    return options.expandRange(...args, options);
-  }
-
-  args.sort();
-  const value = `[${args.join('-')}]`;
-
-  try {
-    /* eslint-disable-next-line no-new */
-    new RegExp(value);
-  } catch (ex) {
-    return args.map(v => utils$1.escapeRegex(v)).join('..');
-  }
-
-  return value;
-};
-
-/**
- * Create the message for a syntax error
- */
-
-const syntaxError = (type, char) => {
-  return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
-};
-
-/**
- * Parse the given input string.
- * @param {String} input
- * @param {Object} options
- * @return {Object}
- */
-
-const parse$1 = (input, options) => {
-  if (typeof input !== 'string') {
-    throw new TypeError('Expected a string');
-  }
-
-  input = REPLACEMENTS[input] || input;
-
-  const opts = { ...options };
-  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
-
-  let len = input.length;
-  if (len > max) {
-    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
-  }
-
-  const bos = { type: 'bos', value: '', output: opts.prepend || '' };
-  const tokens = [bos];
-
-  const capture = opts.capture ? '' : '?:';
-  const win32 = utils$1.isWindows(options);
-
-  // create constants based on platform, for windows or posix
-  const PLATFORM_CHARS = constants$1.globChars(win32);
-  const EXTGLOB_CHARS = constants$1.extglobChars(PLATFORM_CHARS);
-
-  const {
-    DOT_LITERAL,
-    PLUS_LITERAL,
-    SLASH_LITERAL,
-    ONE_CHAR,
-    DOTS_SLASH,
-    NO_DOT,
-    NO_DOT_SLASH,
-    NO_DOTS_SLASH,
-    QMARK,
-    QMARK_NO_DOT,
-    STAR,
-    START_ANCHOR
-  } = PLATFORM_CHARS;
-
-  const globstar = opts => {
-    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
-  };
-
-  const nodot = opts.dot ? '' : NO_DOT;
-  const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
-  let star = opts.bash === true ? globstar(opts) : STAR;
-
-  if (opts.capture) {
-    star = `(${star})`;
-  }
-
-  // minimatch options support
-  if (typeof opts.noext === 'boolean') {
-    opts.noextglob = opts.noext;
-  }
-
-  const state = {
-    input,
-    index: -1,
-    start: 0,
-    dot: opts.dot === true,
-    consumed: '',
-    output: '',
-    prefix: '',
-    backtrack: false,
-    negated: false,
-    brackets: 0,
-    braces: 0,
-    parens: 0,
-    quotes: 0,
-    globstar: false,
-    tokens
-  };
-
-  input = utils$1.removePrefix(input, state);
-  len = input.length;
-
-  const extglobs = [];
-  const braces = [];
-  const stack = [];
-  let prev = bos;
-  let value;
-
-  /**
-   * Tokenizing helpers
-   */
-
-  const eos = () => state.index === len - 1;
-  const peek = state.peek = (n = 1) => input[state.index + n];
-  const advance = state.advance = () => input[++state.index] || '';
-  const remaining = () => input.slice(state.index + 1);
-  const consume = (value = '', num = 0) => {
-    state.consumed += value;
-    state.index += num;
-  };
-
-  const append = token => {
-    state.output += token.output != null ? token.output : token.value;
-    consume(token.value);
-  };
-
-  const negate = () => {
-    let count = 1;
-
-    while (peek() === '!' && (peek(2) !== '(' || peek(3) === '?')) {
-      advance();
-      state.start++;
-      count++;
-    }
-
-    if (count % 2 === 0) {
-      return false;
-    }
-
-    state.negated = true;
-    state.start++;
-    return true;
-  };
-
-  const increment = type => {
-    state[type]++;
-    stack.push(type);
-  };
-
-  const decrement = type => {
-    state[type]--;
-    stack.pop();
-  };
-
-  /**
-   * Push tokens onto the tokens array. This helper speeds up
-   * tokenizing by 1) helping us avoid backtracking as much as possible,
-   * and 2) helping us avoid creating extra tokens when consecutive
-   * characters are plain text. This improves performance and simplifies
-   * lookbehinds.
-   */
-
-  const push = tok => {
-    if (prev.type === 'globstar') {
-      const isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace');
-      const isExtglob = tok.extglob === true || (extglobs.length && (tok.type === 'pipe' || tok.type === 'paren'));
-
-      if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) {
-        state.output = state.output.slice(0, -prev.output.length);
-        prev.type = 'star';
-        prev.value = '*';
-        prev.output = star;
-        state.output += prev.output;
-      }
-    }
-
-    if (extglobs.length && tok.type !== 'paren') {
-      extglobs[extglobs.length - 1].inner += tok.value;
-    }
-
-    if (tok.value || tok.output) append(tok);
-    if (prev && prev.type === 'text' && tok.type === 'text') {
-      prev.value += tok.value;
-      prev.output = (prev.output || '') + tok.value;
-      return;
-    }
-
-    tok.prev = prev;
-    tokens.push(tok);
-    prev = tok;
-  };
-
-  const extglobOpen = (type, value) => {
-    const token = { ...EXTGLOB_CHARS[value], conditions: 1, inner: '' };
-
-    token.prev = prev;
-    token.parens = state.parens;
-    token.output = state.output;
-    const output = (opts.capture ? '(' : '') + token.open;
-
-    increment('parens');
-    push({ type, value, output: state.output ? '' : ONE_CHAR });
-    push({ type: 'paren', extglob: true, value: advance(), output });
-    extglobs.push(token);
-  };
-
-  const extglobClose = token => {
-    let output = token.close + (opts.capture ? ')' : '');
-    let rest;
-
-    if (token.type === 'negate') {
-      let extglobStar = star;
-
-      if (token.inner && token.inner.length > 1 && token.inner.includes('/')) {
-        extglobStar = globstar(opts);
-      }
-
-      if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
-        output = token.close = `)$))${extglobStar}`;
-      }
-
-      if (token.inner.includes('*') && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
-        // Any non-magical string (`.ts`) or even nested expression (`.{ts,tsx}`) can follow after the closing parenthesis.
-        // In this case, we need to parse the string and use it in the output of the original pattern.
-        // Suitable patterns: `/!(*.d).ts`, `/!(*.d).{ts,tsx}`, `**/!(*-dbg).@(js)`.
-        //
-        // Disabling the `fastpaths` option due to a problem with parsing strings as `.ts` in the pattern like `**/!(*.d).ts`.
-        const expression = parse$1(rest, { ...options, fastpaths: false }).output;
-
-        output = token.close = `)${expression})${extglobStar})`;
-      }
-
-      if (token.prev.type === 'bos') {
-        state.negatedExtglob = true;
-      }
-    }
-
-    push({ type: 'paren', extglob: true, value, output });
-    decrement('parens');
-  };
-
-  /**
-   * Fast paths
-   */
-
-  if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
-    let backslashes = false;
-
-    let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
-      if (first === '\\') {
-        backslashes = true;
-        return m;
-      }
-
-      if (first === '?') {
-        if (esc) {
-          return esc + first + (rest ? QMARK.repeat(rest.length) : '');
-        }
-        if (index === 0) {
-          return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');
-        }
-        return QMARK.repeat(chars.length);
-      }
-
-      if (first === '.') {
-        return DOT_LITERAL.repeat(chars.length);
-      }
-
-      if (first === '*') {
-        if (esc) {
-          return esc + first + (rest ? star : '');
-        }
-        return star;
-      }
-      return esc ? m : `\\${m}`;
-    });
-
-    if (backslashes === true) {
-      if (opts.unescape === true) {
-        output = output.replace(/\\/g, '');
-      } else {
-        output = output.replace(/\\+/g, m => {
-          return m.length % 2 === 0 ? '\\\\' : (m ? '\\' : '');
-        });
-      }
-    }
-
-    if (output === input && opts.contains === true) {
-      state.output = input;
-      return state;
-    }
-
-    state.output = utils$1.wrapOutput(output, state, options);
-    return state;
-  }
-
-  /**
-   * Tokenize input until we reach end-of-string
-   */
-
-  while (!eos()) {
-    value = advance();
-
-    if (value === '\u0000') {
-      continue;
-    }
-
-    /**
-     * Escaped characters
-     */
-
-    if (value === '\\') {
-      const next = peek();
-
-      if (next === '/' && opts.bash !== true) {
-        continue;
-      }
-
-      if (next === '.' || next === ';') {
-        continue;
-      }
-
-      if (!next) {
-        value += '\\';
-        push({ type: 'text', value });
-        continue;
-      }
-
-      // collapse slashes to reduce potential for exploits
-      const match = /^\\+/.exec(remaining());
-      let slashes = 0;
-
-      if (match && match[0].length > 2) {
-        slashes = match[0].length;
-        state.index += slashes;
-        if (slashes % 2 !== 0) {
-          value += '\\';
-        }
-      }
-
-      if (opts.unescape === true) {
-        value = advance();
-      } else {
-        value += advance();
-      }
-
-      if (state.brackets === 0) {
-        push({ type: 'text', value });
-        continue;
-      }
-    }
-
-    /**
-     * If we're inside a regex character class, continue
-     * until we reach the closing bracket.
-     */
-
-    if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) {
-      if (opts.posix !== false && value === ':') {
-        const inner = prev.value.slice(1);
-        if (inner.includes('[')) {
-          prev.posix = true;
-
-          if (inner.includes(':')) {
-            const idx = prev.value.lastIndexOf('[');
-            const pre = prev.value.slice(0, idx);
-            const rest = prev.value.slice(idx + 2);
-            const posix = POSIX_REGEX_SOURCE[rest];
-            if (posix) {
-              prev.value = pre + posix;
-              state.backtrack = true;
-              advance();
-
-              if (!bos.output && tokens.indexOf(prev) === 1) {
-                bos.output = ONE_CHAR;
-              }
-              continue;
-            }
-          }
-        }
-      }
-
-      if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) {
-        value = `\\${value}`;
-      }
-
-      if (value === ']' && (prev.value === '[' || prev.value === '[^')) {
-        value = `\\${value}`;
-      }
-
-      if (opts.posix === true && value === '!' && prev.value === '[') {
-        value = '^';
-      }
-
-      prev.value += value;
-      append({ value });
-      continue;
-    }
-
-    /**
-     * If we're inside a quoted string, continue
-     * until we reach the closing double quote.
-     */
-
-    if (state.quotes === 1 && value !== '"') {
-      value = utils$1.escapeRegex(value);
-      prev.value += value;
-      append({ value });
-      continue;
-    }
-
-    /**
-     * Double quotes
-     */
-
-    if (value === '"') {
-      state.quotes = state.quotes === 1 ? 0 : 1;
-      if (opts.keepQuotes === true) {
-        push({ type: 'text', value });
-      }
-      continue;
-    }
-
-    /**
-     * Parentheses
-     */
-
-    if (value === '(') {
-      increment('parens');
-      push({ type: 'paren', value });
-      continue;
-    }
-
-    if (value === ')') {
-      if (state.parens === 0 && opts.strictBrackets === true) {
-        throw new SyntaxError(syntaxError('opening', '('));
-      }
-
-      const extglob = extglobs[extglobs.length - 1];
-      if (extglob && state.parens === extglob.parens + 1) {
-        extglobClose(extglobs.pop());
-        continue;
-      }
-
-      push({ type: 'paren', value, output: state.parens ? ')' : '\\)' });
-      decrement('parens');
-      continue;
-    }
-
-    /**
-     * Square brackets
-     */
-
-    if (value === '[') {
-      if (opts.nobracket === true || !remaining().includes(']')) {
-        if (opts.nobracket !== true && opts.strictBrackets === true) {
-          throw new SyntaxError(syntaxError('closing', ']'));
-        }
-
-        value = `\\${value}`;
-      } else {
-        increment('brackets');
-      }
-
-      push({ type: 'bracket', value });
-      continue;
-    }
-
-    if (value === ']') {
-      if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) {
-        push({ type: 'text', value, output: `\\${value}` });
-        continue;
-      }
-
-      if (state.brackets === 0) {
-        if (opts.strictBrackets === true) {
-          throw new SyntaxError(syntaxError('opening', '['));
-        }
-
-        push({ type: 'text', value, output: `\\${value}` });
-        continue;
-      }
-
-      decrement('brackets');
-
-      const prevValue = prev.value.slice(1);
-      if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) {
-        value = `/${value}`;
-      }
-
-      prev.value += value;
-      append({ value });
-
-      // when literal brackets are explicitly disabled
-      // assume we should match with a regex character class
-      if (opts.literalBrackets === false || utils$1.hasRegexChars(prevValue)) {
-        continue;
-      }
-
-      const escaped = utils$1.escapeRegex(prev.value);
-      state.output = state.output.slice(0, -prev.value.length);
-
-      // when literal brackets are explicitly enabled
-      // assume we should escape the brackets to match literal characters
-      if (opts.literalBrackets === true) {
-        state.output += escaped;
-        prev.value = escaped;
-        continue;
-      }
-
-      // when the user specifies nothing, try to match both
-      prev.value = `(${capture}${escaped}|${prev.value})`;
-      state.output += prev.value;
-      continue;
-    }
-
-    /**
-     * Braces
-     */
-
-    if (value === '{' && opts.nobrace !== true) {
-      increment('braces');
-
-      const open = {
-        type: 'brace',
-        value,
-        output: '(',
-        outputIndex: state.output.length,
-        tokensIndex: state.tokens.length
-      };
-
-      braces.push(open);
-      push(open);
-      continue;
-    }
-
-    if (value === '}') {
-      const brace = braces[braces.length - 1];
-
-      if (opts.nobrace === true || !brace) {
-        push({ type: 'text', value, output: value });
-        continue;
-      }
-
-      let output = ')';
-
-      if (brace.dots === true) {
-        const arr = tokens.slice();
-        const range = [];
-
-        for (let i = arr.length - 1; i >= 0; i--) {
-          tokens.pop();
-          if (arr[i].type === 'brace') {
-            break;
-          }
-          if (arr[i].type !== 'dots') {
-            range.unshift(arr[i].value);
-          }
-        }
-
-        output = expandRange(range, opts);
-        state.backtrack = true;
-      }
-
-      if (brace.comma !== true && brace.dots !== true) {
-        const out = state.output.slice(0, brace.outputIndex);
-        const toks = state.tokens.slice(brace.tokensIndex);
-        brace.value = brace.output = '\\{';
-        value = output = '\\}';
-        state.output = out;
-        for (const t of toks) {
-          state.output += (t.output || t.value);
-        }
-      }
-
-      push({ type: 'brace', value, output });
-      decrement('braces');
-      braces.pop();
-      continue;
-    }
-
-    /**
-     * Pipes
-     */
-
-    if (value === '|') {
-      if (extglobs.length > 0) {
-        extglobs[extglobs.length - 1].conditions++;
-      }
-      push({ type: 'text', value });
-      continue;
-    }
-
-    /**
-     * Commas
-     */
-
-    if (value === ',') {
-      let output = value;
-
-      const brace = braces[braces.length - 1];
-      if (brace && stack[stack.length - 1] === 'braces') {
-        brace.comma = true;
-        output = '|';
-      }
-
-      push({ type: 'comma', value, output });
-      continue;
-    }
-
-    /**
-     * Slashes
-     */
-
-    if (value === '/') {
-      // if the beginning of the glob is "./", advance the start
-      // to the current index, and don't add the "./" characters
-      // to the state. This greatly simplifies lookbehinds when
-      // checking for BOS characters like "!" and "." (not "./")
-      if (prev.type === 'dot' && state.index === state.start + 1) {
-        state.start = state.index + 1;
-        state.consumed = '';
-        state.output = '';
-        tokens.pop();
-        prev = bos; // reset "prev" to the first token
-        continue;
-      }
-
-      push({ type: 'slash', value, output: SLASH_LITERAL });
-      continue;
-    }
-
-    /**
-     * Dots
-     */
-
-    if (value === '.') {
-      if (state.braces > 0 && prev.type === 'dot') {
-        if (prev.value === '.') prev.output = DOT_LITERAL;
-        const brace = braces[braces.length - 1];
-        prev.type = 'dots';
-        prev.output += value;
-        prev.value += value;
-        brace.dots = true;
-        continue;
-      }
-
-      if ((state.braces + state.parens) === 0 && prev.type !== 'bos' && prev.type !== 'slash') {
-        push({ type: 'text', value, output: DOT_LITERAL });
-        continue;
-      }
-
-      push({ type: 'dot', value, output: DOT_LITERAL });
-      continue;
-    }
-
-    /**
-     * Question marks
-     */
-
-    if (value === '?') {
-      const isGroup = prev && prev.value === '(';
-      if (!isGroup && opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
-        extglobOpen('qmark', value);
-        continue;
-      }
-
-      if (prev && prev.type === 'paren') {
-        const next = peek();
-        let output = value;
-
-        if (next === '<' && !utils$1.supportsLookbehinds()) {
-          throw new Error('Node.js v10 or higher is required for regex lookbehinds');
-        }
-
-        if ((prev.value === '(' && !/[!=<:]/.test(next)) || (next === '<' && !/<([!=]|\w+>)/.test(remaining()))) {
-          output = `\\${value}`;
-        }
-
-        push({ type: 'text', value, output });
-        continue;
-      }
-
-      if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) {
-        push({ type: 'qmark', value, output: QMARK_NO_DOT });
-        continue;
-      }
-
-      push({ type: 'qmark', value, output: QMARK });
-      continue;
-    }
-
-    /**
-     * Exclamation
-     */
-
-    if (value === '!') {
-      if (opts.noextglob !== true && peek() === '(') {
-        if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) {
-          extglobOpen('negate', value);
-          continue;
-        }
-      }
-
-      if (opts.nonegate !== true && state.index === 0) {
-        negate();
-        continue;
-      }
-    }
-
-    /**
-     * Plus
-     */
-
-    if (value === '+') {
-      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
-        extglobOpen('plus', value);
-        continue;
-      }
-
-      if ((prev && prev.value === '(') || opts.regex === false) {
-        push({ type: 'plus', value, output: PLUS_LITERAL });
-        continue;
-      }
-
-      if ((prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) || state.parens > 0) {
-        push({ type: 'plus', value });
-        continue;
-      }
-
-      push({ type: 'plus', value: PLUS_LITERAL });
-      continue;
-    }
-
-    /**
-     * Plain text
-     */
-
-    if (value === '@') {
-      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
-        push({ type: 'at', extglob: true, value, output: '' });
-        continue;
-      }
-
-      push({ type: 'text', value });
-      continue;
-    }
-
-    /**
-     * Plain text
-     */
-
-    if (value !== '*') {
-      if (value === '$' || value === '^') {
-        value = `\\${value}`;
-      }
-
-      const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
-      if (match) {
-        value += match[0];
-        state.index += match[0].length;
-      }
-
-      push({ type: 'text', value });
-      continue;
-    }
-
-    /**
-     * Stars
-     */
-
-    if (prev && (prev.type === 'globstar' || prev.star === true)) {
-      prev.type = 'star';
-      prev.star = true;
-      prev.value += value;
-      prev.output = star;
-      state.backtrack = true;
-      state.globstar = true;
-      consume(value);
-      continue;
-    }
-
-    let rest = remaining();
-    if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
-      extglobOpen('star', value);
-      continue;
-    }
-
-    if (prev.type === 'star') {
-      if (opts.noglobstar === true) {
-        consume(value);
-        continue;
-      }
-
-      const prior = prev.prev;
-      const before = prior.prev;
-      const isStart = prior.type === 'slash' || prior.type === 'bos';
-      const afterStar = before && (before.type === 'star' || before.type === 'globstar');
-
-      if (opts.bash === true && (!isStart || (rest[0] && rest[0] !== '/'))) {
-        push({ type: 'star', value, output: '' });
-        continue;
-      }
-
-      const isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace');
-      const isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren');
-      if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) {
-        push({ type: 'star', value, output: '' });
-        continue;
-      }
-
-      // strip consecutive `/**/`
-      while (rest.slice(0, 3) === '/**') {
-        const after = input[state.index + 4];
-        if (after && after !== '/') {
-          break;
-        }
-        rest = rest.slice(3);
-        consume('/**', 3);
-      }
-
-      if (prior.type === 'bos' && eos()) {
-        prev.type = 'globstar';
-        prev.value += value;
-        prev.output = globstar(opts);
-        state.output = prev.output;
-        state.globstar = true;
-        consume(value);
-        continue;
-      }
-
-      if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) {
-        state.output = state.output.slice(0, -(prior.output + prev.output).length);
-        prior.output = `(?:${prior.output}`;
-
-        prev.type = 'globstar';
-        prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '|$)');
-        prev.value += value;
-        state.globstar = true;
-        state.output += prior.output + prev.output;
-        consume(value);
-        continue;
-      }
-
-      if (prior.type === 'slash' && prior.prev.type !== 'bos' && rest[0] === '/') {
-        const end = rest[1] !== void 0 ? '|$' : '';
-
-        state.output = state.output.slice(0, -(prior.output + prev.output).length);
-        prior.output = `(?:${prior.output}`;
-
-        prev.type = 'globstar';
-        prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
-        prev.value += value;
-
-        state.output += prior.output + prev.output;
-        state.globstar = true;
-
-        consume(value + advance());
-
-        push({ type: 'slash', value: '/', output: '' });
-        continue;
-      }
-
-      if (prior.type === 'bos' && rest[0] === '/') {
-        prev.type = 'globstar';
-        prev.value += value;
-        prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
-        state.output = prev.output;
-        state.globstar = true;
-        consume(value + advance());
-        push({ type: 'slash', value: '/', output: '' });
-        continue;
-      }
-
-      // remove single star from output
-      state.output = state.output.slice(0, -prev.output.length);
-
-      // reset previous token to globstar
-      prev.type = 'globstar';
-      prev.output = globstar(opts);
-      prev.value += value;
-
-      // reset output with globstar
-      state.output += prev.output;
-      state.globstar = true;
-      consume(value);
-      continue;
-    }
-
-    const token = { type: 'star', value, output: star };
-
-    if (opts.bash === true) {
-      token.output = '.*?';
-      if (prev.type === 'bos' || prev.type === 'slash') {
-        token.output = nodot + token.output;
-      }
-      push(token);
-      continue;
-    }
-
-    if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) {
-      token.output = value;
-      push(token);
-      continue;
-    }
-
-    if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') {
-      if (prev.type === 'dot') {
-        state.output += NO_DOT_SLASH;
-        prev.output += NO_DOT_SLASH;
-
-      } else if (opts.dot === true) {
-        state.output += NO_DOTS_SLASH;
-        prev.output += NO_DOTS_SLASH;
-
-      } else {
-        state.output += nodot;
-        prev.output += nodot;
-      }
-
-      if (peek() !== '*') {
-        state.output += ONE_CHAR;
-        prev.output += ONE_CHAR;
-      }
-    }
-
-    push(token);
-  }
-
-  while (state.brackets > 0) {
-    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']'));
-    state.output = utils$1.escapeLast(state.output, '[');
-    decrement('brackets');
-  }
-
-  while (state.parens > 0) {
-    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')'));
-    state.output = utils$1.escapeLast(state.output, '(');
-    decrement('parens');
-  }
-
-  while (state.braces > 0) {
-    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}'));
-    state.output = utils$1.escapeLast(state.output, '{');
-    decrement('braces');
-  }
-
-  if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) {
-    push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` });
-  }
-
-  // rebuild the output if we had to backtrack at any point
-  if (state.backtrack === true) {
-    state.output = '';
-
-    for (const token of state.tokens) {
-      state.output += token.output != null ? token.output : token.value;
-
-      if (token.suffix) {
-        state.output += token.suffix;
-      }
-    }
-  }
-
-  return state;
-};
-
-/**
- * Fast paths for creating regular expressions for common glob patterns.
- * This can significantly speed up processing and has very little downside
- * impact when none of the fast paths match.
- */
-
-parse$1.fastpaths = (input, options) => {
-  const opts = { ...options };
-  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
-  const len = input.length;
-  if (len > max) {
-    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
-  }
-
-  input = REPLACEMENTS[input] || input;
-  const win32 = utils$1.isWindows(options);
-
-  // create constants based on platform, for windows or posix
-  const {
-    DOT_LITERAL,
-    SLASH_LITERAL,
-    ONE_CHAR,
-    DOTS_SLASH,
-    NO_DOT,
-    NO_DOTS,
-    NO_DOTS_SLASH,
-    STAR,
-    START_ANCHOR
-  } = constants$1.globChars(win32);
-
-  const nodot = opts.dot ? NO_DOTS : NO_DOT;
-  const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
-  const capture = opts.capture ? '' : '?:';
-  const state = { negated: false, prefix: '' };
-  let star = opts.bash === true ? '.*?' : STAR;
-
-  if (opts.capture) {
-    star = `(${star})`;
-  }
-
-  const globstar = opts => {
-    if (opts.noglobstar === true) return star;
-    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
-  };
-
-  const create = str => {
-    switch (str) {
-      case '*':
-        return `${nodot}${ONE_CHAR}${star}`;
-
-      case '.*':
-        return `${DOT_LITERAL}${ONE_CHAR}${star}`;
-
-      case '*.*':
-        return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
-
-      case '*/*':
-        return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
-
-      case '**':
-        return nodot + globstar(opts);
-
-      case '**/*':
-        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
-
-      case '**/*.*':
-        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
-
-      case '**/.*':
-        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
-
-      default: {
-        const match = /^(.*?)\.(\w+)$/.exec(str);
-        if (!match) return;
-
-        const source = create(match[1]);
-        if (!source) return;
-
-        return source + DOT_LITERAL + match[2];
-      }
-    }
-  };
-
-  const output = utils$1.removePrefix(input, state);
-  let source = create(output);
-
-  if (source && opts.strictSlashes !== true) {
-    source += `${SLASH_LITERAL}?`;
-  }
-
-  return source;
-};
-
-var parse_1 = parse$1;
-
-const path = path$2;
-const scan = scan_1;
-const parse = parse_1;
-const utils = utils$3;
-const constants = constants$2;
-const isObject = val => val && typeof val === 'object' && !Array.isArray(val);
-
-/**
- * Creates a matcher function from one or more glob patterns. The
- * returned function takes a string to match as its first argument,
- * and returns true if the string is a match. The returned matcher
- * function also takes a boolean as the second argument that, when true,
- * returns an object with additional information.
- *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch(glob[, options]);
- *
- * const isMatch = picomatch('*.!(*a)');
- * console.log(isMatch('a.a')); //=> false
- * console.log(isMatch('a.b')); //=> true
- * ```
- * @name picomatch
- * @param {String|Array} `globs` One or more glob patterns.
- * @param {Object=} `options`
- * @return {Function=} Returns a matcher function.
- * @api public
- */
-
-const picomatch$1 = (glob, options, returnState = false) => {
-  if (Array.isArray(glob)) {
-    const fns = glob.map(input => picomatch$1(input, options, returnState));
-    const arrayMatcher = str => {
-      for (const isMatch of fns) {
-        const state = isMatch(str);
-        if (state) return state;
-      }
-      return false;
-    };
-    return arrayMatcher;
-  }
-
-  const isState = isObject(glob) && glob.tokens && glob.input;
-
-  if (glob === '' || (typeof glob !== 'string' && !isState)) {
-    throw new TypeError('Expected pattern to be a non-empty string');
-  }
-
-  const opts = options || {};
-  const posix = utils.isWindows(options);
-  const regex = isState
-    ? picomatch$1.compileRe(glob, options)
-    : picomatch$1.makeRe(glob, options, false, true);
-
-  const state = regex.state;
-  delete regex.state;
-
-  let isIgnored = () => false;
-  if (opts.ignore) {
-    const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
-    isIgnored = picomatch$1(opts.ignore, ignoreOpts, returnState);
-  }
-
-  const matcher = (input, returnObject = false) => {
-    const { isMatch, match, output } = picomatch$1.test(input, regex, options, { glob, posix });
-    const result = { glob, state, regex, posix, input, output, match, isMatch };
-
-    if (typeof opts.onResult === 'function') {
-      opts.onResult(result);
-    }
-
-    if (isMatch === false) {
-      result.isMatch = false;
-      return returnObject ? result : false;
-    }
-
-    if (isIgnored(input)) {
-      if (typeof opts.onIgnore === 'function') {
-        opts.onIgnore(result);
-      }
-      result.isMatch = false;
-      return returnObject ? result : false;
-    }
-
-    if (typeof opts.onMatch === 'function') {
-      opts.onMatch(result);
-    }
-    return returnObject ? result : true;
-  };
-
-  if (returnState) {
-    matcher.state = state;
-  }
-
-  return matcher;
-};
-
-/**
- * Test `input` with the given `regex`. This is used by the main
- * `picomatch()` function to test the input string.
- *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.test(input, regex[, options]);
- *
- * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
- * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
- * ```
- * @param {String} `input` String to test.
- * @param {RegExp} `regex`
- * @return {Object} Returns an object with matching info.
- * @api public
- */
-
-picomatch$1.test = (input, regex, options, { glob, posix } = {}) => {
-  if (typeof input !== 'string') {
-    throw new TypeError('Expected input to be a string');
-  }
-
-  if (input === '') {
-    return { isMatch: false, output: '' };
-  }
-
-  const opts = options || {};
-  const format = opts.format || (posix ? utils.toPosixSlashes : null);
-  let match = input === glob;
-  let output = (match && format) ? format(input) : input;
-
-  if (match === false) {
-    output = format ? format(input) : input;
-    match = output === glob;
-  }
-
-  if (match === false || opts.capture === true) {
-    if (opts.matchBase === true || opts.basename === true) {
-      match = picomatch$1.matchBase(input, regex, options, posix);
-    } else {
-      match = regex.exec(output);
-    }
-  }
-
-  return { isMatch: Boolean(match), match, output };
-};
-
-/**
- * Match the basename of a filepath.
- *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.matchBase(input, glob[, options]);
- * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
- * ```
- * @param {String} `input` String to test.
- * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
- * @return {Boolean}
- * @api public
- */
-
-picomatch$1.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
-  const regex = glob instanceof RegExp ? glob : picomatch$1.makeRe(glob, options);
-  return regex.test(path.basename(input));
-};
-
-/**
- * Returns true if **any** of the given glob `patterns` match the specified `string`.
- *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.isMatch(string, patterns[, options]);
- *
- * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
- * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
- * ```
- * @param {String|Array} str The string to test.
- * @param {String|Array} patterns One or more glob patterns to use for matching.
- * @param {Object} [options] See available [options](#options).
- * @return {Boolean} Returns true if any patterns match `str`
- * @api public
- */
-
-picomatch$1.isMatch = (str, patterns, options) => picomatch$1(patterns, options)(str);
-
-/**
- * Parse a glob pattern to create the source string for a regular
- * expression.
- *
- * ```js
- * const picomatch = require('picomatch');
- * const result = picomatch.parse(pattern[, options]);
- * ```
- * @param {String} `pattern`
- * @param {Object} `options`
- * @return {Object} Returns an object with useful properties and output to be used as a regex source string.
- * @api public
- */
-
-picomatch$1.parse = (pattern, options) => {
-  if (Array.isArray(pattern)) return pattern.map(p => picomatch$1.parse(p, options));
-  return parse(pattern, { ...options, fastpaths: false });
-};
-
-/**
- * Scan a glob pattern to separate the pattern into segments.
- *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.scan(input[, options]);
- *
- * const result = picomatch.scan('!./foo/*.js');
- * console.log(result);
- * { prefix: '!./',
- *   input: '!./foo/*.js',
- *   start: 3,
- *   base: 'foo',
- *   glob: '*.js',
- *   isBrace: false,
- *   isBracket: false,
- *   isGlob: true,
- *   isExtglob: false,
- *   isGlobstar: false,
- *   negated: true }
- * ```
- * @param {String} `input` Glob pattern to scan.
- * @param {Object} `options`
- * @return {Object} Returns an object with
- * @api public
- */
-
-picomatch$1.scan = (input, options) => scan(input, options);
-
-/**
- * Compile a regular expression from the `state` object returned by the
- * [parse()](#parse) method.
- *
- * @param {Object} `state`
- * @param {Object} `options`
- * @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
- * @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
- * @return {RegExp}
- * @api public
- */
-
-picomatch$1.compileRe = (state, options, returnOutput = false, returnState = false) => {
-  if (returnOutput === true) {
-    return state.output;
-  }
-
-  const opts = options || {};
-  const prepend = opts.contains ? '' : '^';
-  const append = opts.contains ? '' : '$';
-
-  let source = `${prepend}(?:${state.output})${append}`;
-  if (state && state.negated === true) {
-    source = `^(?!${source}).*$`;
-  }
-
-  const regex = picomatch$1.toRegex(source, options);
-  if (returnState === true) {
-    regex.state = state;
-  }
-
-  return regex;
-};
-
-/**
- * Create a regular expression from a parsed glob pattern.
- *
- * ```js
- * const picomatch = require('picomatch');
- * const state = picomatch.parse('*.js');
- * // picomatch.compileRe(state[, options]);
- *
- * console.log(picomatch.compileRe(state));
- * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
- * ```
- * @param {String} `state` The object returned from the `.parse` method.
- * @param {Object} `options`
- * @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.
- * @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
- * @return {RegExp} Returns a regex created from the given pattern.
- * @api public
- */
-
-picomatch$1.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
-  if (!input || typeof input !== 'string') {
-    throw new TypeError('Expected a non-empty string');
-  }
-
-  let parsed = { negated: false, fastpaths: true };
-
-  if (options.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
-    parsed.output = parse.fastpaths(input, options);
-  }
-
-  if (!parsed.output) {
-    parsed = parse(input, options);
-  }
-
-  return picomatch$1.compileRe(parsed, options, returnOutput, returnState);
-};
-
-/**
- * Create a regular expression from the given regex source string.
- *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.toRegex(source[, options]);
- *
- * const { output } = picomatch.parse('*.js');
- * console.log(picomatch.toRegex(output));
- * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
- * ```
- * @param {String} `source` Regular expression source string.
- * @param {Object} `options`
- * @return {RegExp}
- * @api public
- */
-
-picomatch$1.toRegex = (source, options) => {
-  try {
-    const opts = options || {};
-    return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
-  } catch (err) {
-    if (options && options.debug === true) throw err;
-    return /$^/;
-  }
-};
-
-/**
- * Picomatch constants.
- * @return {Object}
- */
-
-picomatch$1.constants = constants;
-
-/**
- * Expose "picomatch"
- */
-
-var picomatch_1 = picomatch$1;
-
-var picomatch = picomatch_1;
-
-// Helper since Typescript can't detect readonly arrays with Array.isArray
-function isArray(arg) {
-    return Array.isArray(arg);
-}
-function ensureArray(thing) {
-    if (isArray(thing))
-        return thing;
-    if (thing == null)
-        return [];
-    return [thing];
-}
-
-const normalizePath = function normalizePath(filename) {
-    return filename.split(win32.sep).join(posix.sep);
-};
-
-function getMatcherString(id, resolutionBase) {
-    if (resolutionBase === false || isAbsolute(id) || id.startsWith('*')) {
-        return normalizePath(id);
-    }
-    // resolve('') is valid and will default to process.cwd()
-    const basePath = normalizePath(resolve(resolutionBase || ''))
-        // escape all possible (posix + win) path characters that might interfere with regex
-        .replace(/[-^$*+?.()|[\]{}]/g, '\\$&');
-    // Note that we use posix.join because:
-    // 1. the basePath has been normalized to use /
-    // 2. the incoming glob (id) matcher, also uses /
-    // otherwise Node will force backslash (\) on windows
-    return posix.join(basePath, normalizePath(id));
-}
-const createFilter = function createFilter(include, exclude, options) {
-    const resolutionBase = options && options.resolve;
-    const getMatcher = (id) => id instanceof RegExp
-        ? id
-        : {
-            test: (what) => {
-                // this refactor is a tad overly verbose but makes for easy debugging
-                const pattern = getMatcherString(id, resolutionBase);
-                const fn = picomatch(pattern, { dot: true });
-                const result = fn(what);
-                return result;
-            }
-        };
-    const includeMatchers = ensureArray(include).map(getMatcher);
-    const excludeMatchers = ensureArray(exclude).map(getMatcher);
-    return function result(id) {
-        if (typeof id !== 'string')
-            return false;
-        if (/\0/.test(id))
-            return false;
-        const pathId = normalizePath(id);
-        for (let i = 0; i < excludeMatchers.length; ++i) {
-            const matcher = excludeMatchers[i];
-            if (matcher.test(pathId))
-                return false;
-        }
-        for (let i = 0; i < includeMatchers.length; ++i) {
-            const matcher = includeMatchers[i];
-            if (matcher.test(pathId))
-                return true;
-        }
-        return !includeMatchers.length;
-    };
-};
-
-const reservedWords = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public';
-const builtins = 'arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl';
-const forbiddenIdentifiers = new Set(`${reservedWords} ${builtins}`.split(' '));
-forbiddenIdentifiers.add('');
-
-function resolveCompiler(root) {
-  const compiler = tryRequire("vue/compiler-sfc", root);
-  if (!compiler) {
-    throw new Error(`Failed to resolve vue/compiler-sfc.
-@vitejs/plugin-vue2 requires vue (>=2.7.0) to be present in the dependency tree.`);
-  }
-  return compiler;
-}
-const _require = createRequire(import.meta.url);
-function tryRequire(id, from) {
-  try {
-    return from ? _require(_require.resolve(id, { paths: [from] })) : _require(id);
-  } catch (e) {
-  }
-}
-
-function parseVueRequest(id) {
-  const [filename, rawQuery] = id.split(`?`, 2);
-  const query = Object.fromEntries(new URLSearchParams(rawQuery));
-  if (query.vue != null) {
-    query.vue = true;
-  }
-  if (query.index != null) {
-    query.index = Number(query.index);
-  }
-  if (query.raw != null) {
-    query.raw = true;
-  }
-  if (query.scoped != null) {
-    query.scoped = true;
-  }
-  return {
-    filename,
-    query
-  };
-}
-
-var slash = path => {
-	const isExtendedLengthPath = /^\\\\\?\\/.test(path);
-	const hasNonAscii = /[^\u0000-\u0080]+/.test(path); // eslint-disable-line no-control-regex
-
-	if (isExtendedLengthPath || hasNonAscii) {
-		return path;
-	}
-
-	return path.replace(/\\/g, '/');
-};
-
-const cache = /* @__PURE__ */ new Map();
-const prevCache = /* @__PURE__ */ new Map();
-function createDescriptor(filename, source, { root, isProduction, sourceMap, compiler }) {
-  let descriptor;
-  let errors = [];
-  try {
-    descriptor = compiler.parse({
-      source,
-      filename,
-      sourceMap
-    });
-  } catch (e) {
-    errors = [e];
-    descriptor = compiler.parse({ source: ``, filename });
-  }
-  const normalizedPath = slash(path$2.normalize(path$2.relative(root, filename)));
-  descriptor.id = getHash(normalizedPath + (isProduction ? source : ""));
-  cache.set(filename, descriptor);
-  return { descriptor, errors };
-}
-function getPrevDescriptor(filename) {
-  return prevCache.get(filename);
-}
-function setPrevDescriptor(filename, entry) {
-  prevCache.set(filename, entry);
-}
-function getDescriptor(filename, options, createIfNotFound = true) {
-  if (cache.has(filename)) {
-    return cache.get(filename);
-  }
-  if (createIfNotFound) {
-    const { descriptor, errors } = createDescriptor(filename, fs.readFileSync(filename, "utf-8"), options);
-    if (errors.length) {
-      throw errors[0];
-    }
-    return descriptor;
-  }
-}
-function getSrcDescriptor(filename, query) {
-  if (query.scoped) {
-    return cache.get(`${filename}?src=${query.src}`);
-  }
-  return cache.get(filename);
-}
-function setSrcDescriptor(filename, entry, scoped) {
-  if (scoped) {
-    cache.set(`${filename}?src=${entry.id}`, entry);
-    return;
-  }
-  cache.set(filename, entry);
-}
-function getHash(text) {
-  return createHash("sha256").update(text).digest("hex").substring(0, 8);
-}
-
-const clientCache = /* @__PURE__ */ new WeakMap();
-const ssrCache = /* @__PURE__ */ new WeakMap();
-function getResolvedScript(descriptor, ssr) {
-  return (ssr ? ssrCache : clientCache).get(descriptor);
-}
-function setResolvedScript(descriptor, script, ssr) {
-  (ssr ? ssrCache : clientCache).set(descriptor, script);
-}
-function resolveScript(descriptor, options, ssr) {
-  if (!descriptor.script && !descriptor.scriptSetup) {
-    return null;
-  }
-  const cacheToUse = ssr ? ssrCache : clientCache;
-  const cached = cacheToUse.get(descriptor);
-  if (cached) {
-    return cached;
-  }
-  let resolved = null;
-  resolved = options.compiler.compileScript(descriptor, {
-    ...options.script,
-    id: descriptor.id,
-    isProd: options.isProduction,
-    sourceMap: options.sourceMap
-  });
-  cacheToUse.set(descriptor, resolved);
-  return resolved;
-}
-
-function pad (hash, len) {
-  while (hash.length < len) {
-    hash = '0' + hash;
-  }
-  return hash;
-}
-
-function fold (hash, text) {
-  var i;
-  var chr;
-  var len;
-  if (text.length === 0) {
-    return hash;
-  }
-  for (i = 0, len = text.length; i < len; i++) {
-    chr = text.charCodeAt(i);
-    hash = ((hash << 5) - hash) + chr;
-    hash |= 0;
-  }
-  return hash < 0 ? hash * -2 : hash;
-}
-
-function foldObject (hash, o, seen) {
-  return Object.keys(o).sort().reduce(foldKey, hash);
-  function foldKey (hash, key) {
-    return foldValue(hash, o[key], key, seen);
-  }
-}
-
-function foldValue (input, value, key, seen) {
-  var hash = fold(fold(fold(input, key), toString(value)), typeof value);
-  if (value === null) {
-    return fold(hash, 'null');
-  }
-  if (value === undefined) {
-    return fold(hash, 'undefined');
-  }
-  if (typeof value === 'object' || typeof value === 'function') {
-    if (seen.indexOf(value) !== -1) {
-      return fold(hash, '[Circular]' + key);
-    }
-    seen.push(value);
-
-    var objHash = foldObject(hash, value, seen);
-
-    if (!('valueOf' in value) || typeof value.valueOf !== 'function') {
-      return objHash;
-    }
-
-    try {
-      return fold(objHash, String(value.valueOf()))
-    } catch (err) {
-      return fold(objHash, '[valueOf exception]' + (err.stack || err.message))
-    }
-  }
-  return fold(hash, value.toString());
-}
-
-function toString (o) {
-  return Object.prototype.toString.call(o);
-}
-
-function sum (o) {
-  return pad(foldValue(0, o, '', []).toString(16), 8);
-}
-
-var hashSum = sum;
-
-function createRollupError(id, error) {
-  if ("msg" in error) {
-    return {
-      id,
-      plugin: "vue",
-      message: error.msg,
-      name: "vue-compiler-error"
-    };
-  } else {
-    return {
-      id,
-      plugin: "vue",
-      message: error.message,
-      name: error.name,
-      stack: error.stack
-    };
-  }
-}
-
-const HMR_RUNTIME_ID = "plugin-vue2:hmr-runtime";
-const hmrRuntimeCode = `
-var __VUE_HMR_RUNTIME__ = Object.create(null)
-var map = Object.create(null)
-
-__VUE_HMR_RUNTIME__.createRecord = function (id, options) {
-  if(map[id]) { return }
-
-  var Ctor = null
-  if (typeof options === 'function') {
-    Ctor = options
-    options = Ctor.options
-  }
-  makeOptionsHot(id, options)
-  map[id] = {
-    Ctor: Ctor,
-    options: options,
-    instances: []
-  }
-}
-
-__VUE_HMR_RUNTIME__.isRecorded = function (id) {
-  return typeof map[id] !== 'undefined'
-}
-
-function makeOptionsHot(id, options) {
-  if (options.functional) {
-    var render = options.render
-    options.render = function (h, ctx) {
-      var instances = map[id].instances
-      if (ctx && instances.indexOf(ctx.parent) < 0) {
-        instances.push(ctx.parent)
-      }
-      return render(h, ctx)
-    }
-  } else {
-    injectHook(options, 'beforeCreate', function() {
-      var record = map[id]
-      if (!record.Ctor) {
-        record.Ctor = this.constructor
-      }
-      record.instances.push(this)
-    })
-    injectHook(options, 'beforeDestroy', function() {
-      var instances = map[id].instances
-      instances.splice(instances.indexOf(this), 1)
-    })
-  }
-}
-
-function injectHook(options, name, hook) {
-  var existing = options[name]
-  options[name] = existing
-    ? Array.isArray(existing) ? existing.concat(hook) : [existing, hook]
-    : [hook]
-}
-
-function tryWrap(fn) {
-  return function (id, arg) {
-    try {
-      fn(id, arg)
-    } catch (e) {
-      console.error(e)
-      console.warn(
-        'Something went wrong during Vue component hot-reload. Full reload required.'
-      )
-    }
-  }
-}
-
-function updateOptions (oldOptions, newOptions) {
-  for (var key in oldOptions) {
-    if (!(key in newOptions)) {
-      delete oldOptions[key]
-    }
-  }
-  for (var key$1 in newOptions) {
-    oldOptions[key$1] = newOptions[key$1]
-  }
-}
-
-__VUE_HMR_RUNTIME__.rerender = tryWrap(function (id, options) {
-  var record = map[id]
-  if (!options) {
-    record.instances.slice().forEach(function (instance) {
-      instance.$forceUpdate()
-    })
-    return
-  }
-  if (typeof options === 'function') {
-    options = options.options
-  }
-  if(record.functional){
-    record.render = options.render
-    record.staticRenderFns = options.staticRenderFns
-    __VUE_HMR_RUNTIME__.reload(id, record)
-    return
-  }
-  if (record.Ctor) {
-    record.Ctor.options.render = options.render
-    record.Ctor.options.staticRenderFns = options.staticRenderFns
-    record.instances.slice().forEach(function (instance) {
-      instance.$options.render = options.render
-      instance.$options.staticRenderFns = options.staticRenderFns
-      // reset static trees
-      // pre 2.5, all static trees are cached together on the instance
-      if (instance._staticTrees) {
-        instance._staticTrees = []
-      }
-      // 2.5.0
-      if (Array.isArray(record.Ctor.options.cached)) {
-        record.Ctor.options.cached = []
-      }
-      // 2.5.3
-      if (Array.isArray(instance.$options.cached)) {
-        instance.$options.cached = []
-      }
-
-      // post 2.5.4: v-once trees are cached on instance._staticTrees.
-      // Pure static trees are cached on the staticRenderFns array
-      // (both already reset above)
-
-      // 2.6: temporarily mark rendered scoped slots as unstable so that
-      // child components can be forced to update
-      var restore = patchScopedSlots(instance)
-      instance.$forceUpdate()
-      instance.$nextTick(restore)
-    })
-  } else {
-    // functional or no instance created yet
-    record.options.render = options.render
-    record.options.staticRenderFns = options.staticRenderFns
-
-    // handle functional component re-render
-    if (record.options.functional) {
-      // rerender with full options
-      if (Object.keys(options).length > 2) {
-        updateOptions(record.options, options)
-      } else {
-        // template-only rerender.
-        // need to inject the style injection code for CSS modules
-        // to work properly.
-        var injectStyles = record.options._injectStyles
-        if (injectStyles) {
-          var render = options.render
-          record.options.render = function (h, ctx) {
-            injectStyles.call(ctx)
-            return render(h, ctx)
-          }
-        }
-      }
-      record.options._Ctor = null
-      // 2.5.3
-      if (Array.isArray(record.options.cached)) {
-        record.options.cached = []
-      }
-      record.instances.slice().forEach(function (instance) {
-        instance.$forceUpdate()
-      })
-    }
-  }
-})
-
-__VUE_HMR_RUNTIME__.reload = tryWrap(function (id, options) {
-  var record = map[id]
-  if (options) {
-    if (typeof options === 'function') {
-      options = options.options
-    }
-    makeOptionsHot(id, options)
-    if (record.Ctor) {
-      var newCtor = record.Ctor.super.extend(options)
-      // prevent record.options._Ctor from being overwritten accidentally
-      newCtor.options._Ctor = record.options._Ctor
-      record.Ctor.options = newCtor.options
-      record.Ctor.cid = newCtor.cid
-      record.Ctor.prototype = newCtor.prototype
-      if (newCtor.release) {
-        // temporary global mixin strategy used in < 2.0.0-alpha.6
-        newCtor.release()
-      }
-    } else {
-      updateOptions(record.options, options)
-    }
-  }
-  record.instances.slice().forEach(function (instance) {
-    if (instance.$vnode && instance.$vnode.context) {
-      instance.$vnode.context.$forceUpdate()
-    } else {
-      console.warn(
-        'Root or manually mounted instance modified. Full reload required.'
-      )
-    }
-  })
-})
-
-// 2.6 optimizes template-compiled scoped slots and skips updates if child
-// only uses scoped slots. We need to patch the scoped slots resolving helper
-// to temporarily mark all scoped slots as unstable in order to force child
-// updates.
-function patchScopedSlots (instance) {
-  if (!instance._u) { return }
-  // https://github.com/vuejs/vue/blob/dev/src/core/instance/render-helpers/resolve-scoped-slots.js
-  var original = instance._u
-  instance._u = function (slots) {
-    try {
-      // 2.6.4 ~ 2.6.6
-      return original(slots, true)
-    } catch (e) {
-      // 2.5 / >= 2.6.7
-      return original(slots, null, true)
-    }
-  }
-  return function () {
-    instance._u = original
-  }
-}
-export default __VUE_HMR_RUNTIME__
-`;
-
-async function transformTemplateAsModule(code, descriptor, options, pluginContext, ssr) {
-  let returnCode = compile(code, descriptor, options, pluginContext, ssr);
-  if (options.devServer && options.devServer.config.server.hmr !== false && !ssr && !options.isProduction) {
-    returnCode += `
-import __VUE_HMR_RUNTIME__ from "${HMR_RUNTIME_ID}"`;
-    returnCode += `
-import.meta.hot.accept((updated) => {
-      __VUE_HMR_RUNTIME__.rerender(${JSON.stringify(descriptor.id)}, updated)
-    })`;
-  }
-  return returnCode + `
-export { render, staticRenderFns }`;
-}
-function transformTemplateInMain(code, descriptor, options, pluginContext, ssr) {
-  return compile(code, descriptor, options, pluginContext, ssr).replace(/var (render|staticRenderFns) =/g, "var _sfc_$1 =").replace(/(render._withStripped)/, "_sfc_$1");
-}
-function compile(code, descriptor, options, pluginContext, ssr) {
-  const filename = descriptor.filename;
-  const result = options.compiler.compileTemplate({
-    ...resolveTemplateCompilerOptions(descriptor, options, ssr),
-    source: code
-  });
-  if (result.errors.length) {
-    result.errors.forEach((error) => pluginContext.error(typeof error === "string" ? { id: filename, message: error } : createRollupError(filename, error)));
-  }
-  if (result.tips.length) {
-    result.tips.forEach((tip) => pluginContext.warn({
-      id: filename,
-      message: typeof tip === "string" ? tip : tip.msg
-    }));
-  }
-  return transformRequireToImport(result.code);
-}
-function resolveTemplateCompilerOptions(descriptor, options, ssr) {
-  const block = descriptor.template;
-  if (!block) {
-    return;
-  }
-  const resolvedScript = getResolvedScript(descriptor, ssr);
-  const hasScoped = descriptor.styles.some((s) => s.scoped);
-  const { id, filename } = descriptor;
-  let preprocessOptions = block.lang && options.template?.preprocessOptions;
-  if (block.lang === "pug") {
-    preprocessOptions = {
-      doctype: "html",
-      ...preprocessOptions
-    };
-  }
-  const transformAssetUrls = options.template?.transformAssetUrls ?? true;
-  let assetUrlOptions;
-  if (options.devServer) {
-    if (filename.startsWith(options.root)) {
-      assetUrlOptions = {
-        base: (options.devServer.config.server?.origin ?? "") + options.devServer.config.base + slash(path$2.relative(options.root, path$2.dirname(filename)))
-      };
-    }
-  } else if (transformAssetUrls !== false) {
-    assetUrlOptions = {
-      includeAbsolute: true
-    };
-  }
-  return {
-    transformAssetUrls,
-    ...options.template,
-    filename,
-    isProduction: options.isProduction,
-    isFunctional: !!block.attrs.functional,
-    optimizeSSR: ssr,
-    transformAssetUrlsOptions: {
-      ...options.template?.transformAssetUrlsOptions,
-      ...assetUrlOptions
-    },
-    preprocessLang: block.lang,
-    preprocessOptions,
-    bindings: resolvedScript ? resolvedScript.bindings : void 0,
-    prettify: false,
-    compilerOptions: {
-      whitespace: "condense",
-      outputSourceRange: true,
-      ...options.template?.compilerOptions,
-      scopeId: hasScoped ? `data-v-${id}` : void 0
-    }
-  };
-}
-function transformRequireToImport(code) {
-  const imports = {};
-  let strImports = "";
-  code = code.replace(/require\(("(?:[^"\\]|\\.)+"|'(?:[^'\\]|\\.)+')\)/g, (_, name) => {
-    if (!(name in imports)) {
-      imports[name] = `__$_require_${hashSum(name)}__`;
-      strImports += `import ${imports[name]} from ${name}
-`;
-    }
-    return imports[name];
-  });
-  return strImports + code;
-}
-
-const directRequestRE = /(\?|&)direct\b/;
-async function handleHotUpdate({ file, modules, read, server }, options) {
-  const prevDescriptor = getDescriptor(file, options, false);
-  if (!prevDescriptor) {
-    return;
-  }
-  setPrevDescriptor(file, prevDescriptor);
-  const content = await read();
-  const { descriptor } = createDescriptor(file, content, options);
-  let needRerender = false;
-  const affectedModules = /* @__PURE__ */ new Set();
-  const mainModule = modules.find((m) => !/type=/.test(m.url) || /type=script/.test(m.url));
-  const templateModule = modules.find((m) => /type=template/.test(m.url));
-  if (hasScriptChanged(prevDescriptor, descriptor)) {
-    let scriptModule;
-    if (descriptor.scriptSetup?.lang && !descriptor.scriptSetup.src || descriptor.script?.lang && !descriptor.script.src) {
-      const scriptModuleRE = new RegExp(`type=script.*&lang.${descriptor.scriptSetup?.lang || descriptor.script?.lang}$`);
-      scriptModule = modules.find((m) => scriptModuleRE.test(m.url));
-    }
-    affectedModules.add(scriptModule || mainModule);
-  }
-  if (!isEqualBlock(descriptor.template, prevDescriptor.template)) {
-    if (mainModule && !affectedModules.has(mainModule)) {
-      setResolvedScript(descriptor, getResolvedScript(prevDescriptor, false), false);
-    }
-    affectedModules.add(templateModule);
-    needRerender = true;
-  }
-  const prevStyles = prevDescriptor.styles || [];
-  const nextStyles = descriptor.styles || [];
-  if (prevStyles.some((s) => s.scoped) !== nextStyles.some((s) => s.scoped)) {
-    affectedModules.add(templateModule);
-    affectedModules.add(mainModule);
-  }
-  for (let i = 0; i < nextStyles.length; i++) {
-    const prev = prevStyles[i];
-    const next = nextStyles[i];
-    if (!prev || !isEqualBlock(prev, next)) {
-      const mod = modules.find((m) => m.url.includes(`type=style&index=${i}`) && m.url.endsWith(`.${next.lang || "css"}`) && !directRequestRE.test(m.url));
-      if (mod) {
-        affectedModules.add(mod);
-        if (mod.url.includes("&inline")) {
-          affectedModules.add(mainModule);
-        }
-      } else {
-        affectedModules.add(mainModule);
-      }
-    }
-  }
-  if (prevStyles.length > nextStyles.length) {
-    affectedModules.add(mainModule);
-  }
-  const prevCustoms = prevDescriptor.customBlocks || [];
-  const nextCustoms = descriptor.customBlocks || [];
-  if (prevCustoms.length !== nextCustoms.length) {
-    affectedModules.add(mainModule);
-  } else {
-    for (let i = 0; i < nextCustoms.length; i++) {
-      const prev = prevCustoms[i];
-      const next = nextCustoms[i];
-      if (!prev || !isEqualBlock(prev, next)) {
-        const mod = modules.find((m) => m.url.includes(`type=${prev.type}&index=${i}`));
-        if (mod) {
-          affectedModules.add(mod);
-        } else {
-          affectedModules.add(mainModule);
-        }
-      }
-    }
-  }
-  if (needRerender) {
-    if (!templateModule) {
-      affectedModules.add(mainModule);
-    } else if (mainModule && !affectedModules.has(mainModule)) {
-      const styleImporters = [...mainModule.importers].filter((m) => /\.css($|\?)/.test(m.url));
-      styleImporters.forEach((m) => affectedModules.add(m));
-    }
-  }
-  return [...affectedModules].filter(Boolean);
-}
-function isEqualBlock(a, b) {
-  if (!a && !b)
-    return true;
-  if (!a || !b)
-    return false;
-  if (a.src && b.src && a.src === b.src)
-    return true;
-  if (a.content !== b.content)
-    return false;
-  const keysA = Object.keys(a.attrs);
-  const keysB = Object.keys(b.attrs);
-  if (keysA.length !== keysB.length) {
-    return false;
-  }
-  return keysA.every((key) => a.attrs[key] === b.attrs[key]);
-}
-function isOnlyTemplateChanged(prev, next) {
-  return !hasScriptChanged(prev, next) && prev.styles.length === next.styles.length && prev.styles.every((s, i) => isEqualBlock(s, next.styles[i])) && prev.customBlocks.length === next.customBlocks.length && prev.customBlocks.every((s, i) => isEqualBlock(s, next.customBlocks[i]));
-}
-function hasScriptChanged(prev, next) {
-  if (!isEqualBlock(prev.script, next.script)) {
-    return true;
-  }
-  if (!isEqualBlock(prev.scriptSetup, next.scriptSetup)) {
-    return true;
-  }
-  const prevResolvedScript = getResolvedScript(prev, false);
-  const prevImports = prevResolvedScript?.imports;
-  if (prevImports) {
-    return next.shouldForceReload(prevImports);
-  }
-  return false;
-}
-
-const NORMALIZER_ID = "plugin-vue2:normalizer";
-const normalizerCode = `
-export default function normalizeComponent (
-    scriptExports,
-    render,
-    staticRenderFns,
-    functionalTemplate,
-    injectStyles,
-    scopeId,
-    moduleIdentifier, /* server only */
-    shadowMode /* vue-cli only */
-) {
-  // Vue.extend constructor export interop
-  var options = typeof scriptExports === 'function'
-      ? scriptExports.options
-      : scriptExports
-
-  // render functions
-  if (render) {
-    options.render = render
-    options.staticRenderFns = staticRenderFns
-    options._compiled = true
-  }
-
-  // functional template
-  if (functionalTemplate) {
-    options.functional = true
-  }
-
-  // scopedId
-  if (scopeId) {
-    options._scopeId = 'data-v-' + scopeId
-  }
-
-  var hook
-  if (moduleIdentifier) { // server build
-    hook = function (context) {
-      // 2.3 injection
-      context =
-          context || // cached call
-          (this.$vnode && this.$vnode.ssrContext) || // stateful
-          (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional
-      // 2.2 with runInNewContext: true
-      if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
-        context = __VUE_SSR_CONTEXT__
-      }
-      // inject component styles
-      if (injectStyles) {
-        injectStyles.call(this, context)
-      }
-      // register component module identifier for async chunk inference
-      if (context && context._registeredComponents) {
-        context._registeredComponents.add(moduleIdentifier)
-      }
-    }
-    // used by ssr in case component is cached and beforeCreate
-    // never gets called
-    options._ssrRegister = hook
-  } else if (injectStyles) {
-    hook = shadowMode
-        ? function () {
-          injectStyles.call(
-              this,
-              (options.functional ? this.parent : this).$root.$options.shadowRoot
-          )
-        }
-        : injectStyles
-  }
-
-  if (hook) {
-    if (options.functional) {
-      // for template-only hot-reload because in that case the render fn doesn't
-      // go through the normalizer
-      options._injectStyles = hook
-      // register for functional component in vue file
-      var originalRender = options.render
-      options.render = function renderWithStyleInjection (h, context) {
-        hook.call(context)
-        return originalRender(h, context)
-      }
-    } else {
-      // inject component registration as beforeCreate hook
-      var existing = options.beforeCreate
-      options.beforeCreate = existing
-          ? [].concat(existing, hook)
-          : [hook]
-    }
-  }
-
-  return {
-    exports: scriptExports,
-    options: options
-  }
-}`;
-
-async function transformMain(code, filename, options, pluginContext, ssr) {
-  const { devServer, isProduction, devToolsEnabled } = options;
-  const prevDescriptor = getPrevDescriptor(filename);
-  const { descriptor, errors } = createDescriptor(filename, code, options);
-  if (errors.length) {
-    errors.forEach((error) => pluginContext.error(createRollupError(filename, error)));
-    return null;
-  }
-  const hasScoped = descriptor.styles.some((s) => s.scoped);
-  const hasCssModules = descriptor.styles.some((s) => s.module);
-  const hasFunctional = descriptor.template && descriptor.template.attrs.functional;
-  const { code: scriptCode, map: scriptMap } = await genScriptCode(descriptor, options, pluginContext, ssr);
-  const templateCode = await genTemplateCode(descriptor, options, pluginContext, ssr);
-  const stylesCode = await genStyleCode(descriptor, pluginContext);
-  const customBlocksCode = await genCustomBlockCode(descriptor, pluginContext);
-  const output = [
-    scriptCode,
-    templateCode,
-    stylesCode,
-    customBlocksCode
-  ];
-  output.push(`/* normalize component */
-import __normalizer from "${NORMALIZER_ID}"
-var __component__ = /*#__PURE__*/__normalizer(
-  _sfc_main,
-  _sfc_render,
-  _sfc_staticRenderFns,
-  ${hasFunctional ? "true" : "false"},
-  ${hasCssModules ? `_sfc_injectStyles` : `null`},
-  ${hasScoped ? JSON.stringify(descriptor.id) : "null"},
-  null,
-  null
-)`);
-  if (devToolsEnabled || devServer && !isProduction) {
-    output.push(`__component__.options.__file = ${JSON.stringify(isProduction ? path$2.basename(filename) : filename)}`);
-  }
-  if (devServer && devServer.config.server.hmr !== false && !ssr && !isProduction) {
-    const id = JSON.stringify(descriptor.id);
-    output.push(`import __VUE_HMR_RUNTIME__ from "${HMR_RUNTIME_ID}"`, `if (!__VUE_HMR_RUNTIME__.isRecorded(${id})) {`, `  __VUE_HMR_RUNTIME__.createRecord(${id}, __component__.options)`, `}`);
-    if (hasFunctional || prevDescriptor && isOnlyTemplateChanged(prevDescriptor, descriptor)) {
-      output.push(`export const _rerender_only = true`);
-    }
-    output.push(`import.meta.hot.accept(({ default: updated, _rerender_only }) => {`, `  if (_rerender_only) {`, `    __VUE_HMR_RUNTIME__.rerender(${id}, updated)`, `  } else {`, `    __VUE_HMR_RUNTIME__.reload(${id}, updated)`, `  }`, `})`);
-  }
-  let resolvedMap = scriptMap;
-  output.push(`export default __component__.exports`);
-  let resolvedCode = output.join("\n");
-  if ((descriptor.script?.lang === "ts" || descriptor.scriptSetup?.lang === "ts") && !descriptor.script?.src) {
-    const { code: code2, map } = await transformWithEsbuild(resolvedCode, filename, { loader: "ts", sourcemap: options.sourceMap }, resolvedMap);
-    resolvedCode = code2;
-    resolvedMap = resolvedMap ? map : resolvedMap;
-  }
-  return {
-    code: resolvedCode,
-    map: resolvedMap || {
-      mappings: ""
-    },
-    meta: {
-      vite: {
-        lang: descriptor.script?.lang || descriptor.scriptSetup?.lang || "js"
-      }
-    }
-  };
-}
-async function genTemplateCode(descriptor, options, pluginContext, ssr) {
-  const template = descriptor.template;
-  if (!template) {
-    return "const _sfc_render = null; const _sfc_staticRenderFns = null";
-  }
-  const hasScoped = descriptor.styles.some((style) => style.scoped);
-  if (!template.lang && !template.src) {
-    return transformTemplateInMain(template.content, descriptor, options, pluginContext, ssr);
-  } else {
-    if (template.src) {
-      await linkSrcToDescriptor(template.src, descriptor, pluginContext, hasScoped);
-    }
-    const src = template.src || descriptor.filename;
-    const srcQuery = template.src ? hasScoped ? `&src=${descriptor.id}` : "&src=true" : "";
-    const scopedQuery = hasScoped ? `&scoped=${descriptor.id}` : ``;
-    const attrsQuery = attrsToQuery(template.attrs, "js", true);
-    const query = `?vue&type=template${srcQuery}${scopedQuery}${attrsQuery}`;
-    const request = JSON.stringify(src + query);
-    return `import { render as _sfc_render, staticRenderFns as _sfc_staticRenderFns } from ${request}`;
-  }
-}
-async function genScriptCode(descriptor, options, pluginContext, ssr) {
-  let scriptCode = `const _sfc_main = {}`;
-  let map;
-  const script = resolveScript(descriptor, options, ssr);
-  if (script) {
-    if ((!script.lang || script.lang === "ts" && options.devServer) && !script.src) {
-      const userPlugins = options.script?.babelParserPlugins || [];
-      const defaultPlugins = script.lang === "ts" ? userPlugins.includes("decorators") ? ["typescript"] : ["typescript", "decorators-legacy"] : [];
-      scriptCode = options.compiler.rewriteDefault(script.content, "_sfc_main", [...defaultPlugins, ...userPlugins]);
-      map = script.map;
-    } else {
-      if (script.src) {
-        await linkSrcToDescriptor(script.src, descriptor, pluginContext, false);
-      }
-      const src = script.src || descriptor.filename;
-      const langFallback = script.src && path$2.extname(src).slice(1) || "js";
-      const attrsQuery = attrsToQuery(script.attrs, langFallback);
-      const srcQuery = script.src ? `&src=true` : ``;
-      const query = `?vue&type=script${srcQuery}${attrsQuery}`;
-      const request = JSON.stringify(src + query);
-      scriptCode = `import _sfc_main from ${request}
-export * from ${request}`;
-    }
-  }
-  return {
-    code: scriptCode,
-    map
-  };
-}
-async function genStyleCode(descriptor, pluginContext) {
-  let stylesCode = ``;
-  let cssModulesMap;
-  if (descriptor.styles.length) {
-    for (let i = 0; i < descriptor.styles.length; i++) {
-      const style = descriptor.styles[i];
-      if (style.src) {
-        await linkSrcToDescriptor(style.src, descriptor, pluginContext, style.scoped);
-      }
-      const src = style.src || descriptor.filename;
-      const attrsQuery = attrsToQuery(style.attrs, "css");
-      const srcQuery = style.src ? style.scoped ? `&src=${descriptor.id}` : "&src=true" : "";
-      const directQuery = ``;
-      const scopedQuery = style.scoped ? `&scoped=${descriptor.id}` : ``;
-      const query = `?vue&type=style&index=${i}${srcQuery}${directQuery}${scopedQuery}`;
-      const styleRequest = src + query + attrsQuery;
-      if (style.module) {
-        const [importCode, nameMap] = genCSSModulesCode(i, styleRequest, style.module);
-        stylesCode += importCode;
-        Object.assign(cssModulesMap || (cssModulesMap = {}), nameMap);
-      } else {
-        stylesCode += `
-import ${JSON.stringify(styleRequest)}`;
-      }
-    }
-  }
-  if (cssModulesMap) {
-    const mappingCode = Object.entries(cssModulesMap).reduce((code, [key, value]) => code + `"${key}":${value},
-`, "{\n") + "}";
-    stylesCode += `
-const __cssModules = ${mappingCode}`;
-    stylesCode += `
-function _sfc_injectStyles(ctx) {
-      for (var key in __cssModules) {
-        this[key] = __cssModules[key]
-      }
-    }`;
-  }
-  return stylesCode;
-}
-function genCSSModulesCode(index, request, moduleName) {
-  const styleVar = `style${index}`;
-  const exposedName = typeof moduleName === "string" ? moduleName : "$style";
-  const moduleRequest = request.replace(/\.(\w+)$/, ".module.$1");
-  return [
-    `
-import ${styleVar} from ${JSON.stringify(moduleRequest)}`,
-    { [exposedName]: styleVar }
-  ];
-}
-async function genCustomBlockCode(descriptor, pluginContext) {
-  let code = "";
-  for (let index = 0; index < descriptor.customBlocks.length; index++) {
-    const block = descriptor.customBlocks[index];
-    if (block.src) {
-      await linkSrcToDescriptor(block.src, descriptor, pluginContext, false);
-    }
-    const src = block.src || descriptor.filename;
-    const attrsQuery = attrsToQuery(block.attrs, block.type);
-    const srcQuery = block.src ? `&src=true` : ``;
-    const query = `?vue&type=${block.type}&index=${index}${srcQuery}${attrsQuery}`;
-    const request = JSON.stringify(src + query);
-    code += `import block${index} from ${request}
-`;
-    code += `if (typeof block${index} === 'function') block${index}(_sfc_main)
-`;
-  }
-  return code;
-}
-async function linkSrcToDescriptor(src, descriptor, pluginContext, scoped) {
-  const srcFile = (await pluginContext.resolve(src, descriptor.filename))?.id || src;
-  setSrcDescriptor(srcFile.replace(/\?.*$/, ""), descriptor, scoped);
-}
-const ignoreList = ["id", "index", "src", "type", "lang", "module", "scoped"];
-function attrsToQuery(attrs, langFallback, forceLangFallback = false) {
-  let query = ``;
-  for (const name in attrs) {
-    const value = attrs[name];
-    if (!ignoreList.includes(name)) {
-      query += `&${encodeURIComponent(name)}${value ? `=${encodeURIComponent(value)}` : ``}`;
-    }
-  }
-  if (langFallback || attrs.lang) {
-    query += `lang` in attrs ? forceLangFallback ? `&lang.${langFallback}` : `&lang.${attrs.lang}` : `&lang.${langFallback}`;
-  }
-  return query;
-}
-
-async function transformStyle(code, descriptor, index, options, pluginContext, filename) {
-  const block = descriptor.styles[index];
-  const result = await options.compiler.compileStyleAsync({
-    ...options.style,
-    filename: descriptor.filename,
-    id: `data-v-${descriptor.id}`,
-    isProd: options.isProduction,
-    source: code,
-    scoped: !!block.scoped,
-    ...options.cssDevSourcemap ? {
-      postcssOptions: {
-        map: {
-          from: filename,
-          inline: false,
-          annotation: false
-        }
-      }
-    } : {}
-  });
-  if (result.errors.length) {
-    result.errors.forEach((error) => {
-      if (error.line && error.column) {
-        error.loc = {
-          file: descriptor.filename,
-          line: error.line + getLine(descriptor.source, block.start),
-          column: error.column
-        };
-      }
-      pluginContext.error(error);
-    });
-    return null;
-  }
-  const map = result.map ? await formatPostcssSourceMap(result.map, filename) : { mappings: "" };
-  return {
-    code: result.code,
-    map
-  };
-}
-function getLine(source, start) {
-  const lines = source.split(/\r?\n/g);
-  let cur = 0;
-  for (let i = 0; i < lines.length; i++) {
-    cur += lines[i].length;
-    if (cur >= start) {
-      return i;
-    }
-  }
-}
-
-function vuePlugin(rawOptions = {}) {
-  const {
-    include = /\.vue$/,
-    exclude
-  } = rawOptions;
-  const filter = createFilter(include, exclude);
-  let options = {
-    isProduction: process.env.NODE_ENV === "production",
-    compiler: null,
-    ...rawOptions,
-    include,
-    exclude,
-    root: process.cwd(),
-    sourceMap: true,
-    cssDevSourcemap: false,
-    devToolsEnabled: process.env.NODE_ENV !== "production"
-  };
-  return {
-    name: "vite:vue2",
-    handleHotUpdate(ctx) {
-      if (!filter(ctx.file)) {
-        return;
-      }
-      return handleHotUpdate(ctx, options);
-    },
-    configResolved(config) {
-      options = {
-        ...options,
-        root: config.root,
-        isProduction: config.isProduction,
-        sourceMap: config.command === "build" ? !!config.build.sourcemap : true,
-        cssDevSourcemap: config.css?.devSourcemap ?? false,
-        devToolsEnabled: !config.isProduction
-      };
-      if (!config.resolve.alias.some(({ find }) => find === "vue")) {
-        config.resolve.alias.push({
-          find: "vue",
-          replacement: "vue/dist/vue.runtime.esm.js"
-        });
-      }
-    },
-    configureServer(server) {
-      options.devServer = server;
-    },
-    buildStart() {
-      options.compiler = resolveCompiler();
-    },
-    async resolveId(id) {
-      if (id === NORMALIZER_ID || id === HMR_RUNTIME_ID) {
-        return id;
-      }
-      if (parseVueRequest(id).query.vue) {
-        return id;
-      }
-    },
-    load(id, opt) {
-      const ssr = opt?.ssr === true;
-      if (id === NORMALIZER_ID) {
-        return normalizerCode;
-      }
-      if (id === HMR_RUNTIME_ID) {
-        return hmrRuntimeCode;
-      }
-      const { filename, query } = parseVueRequest(id);
-      if (query.vue) {
-        if (query.src) {
-          return fs.readFileSync(filename, "utf-8");
-        }
-        const descriptor = getDescriptor(filename, options);
-        let block;
-        if (query.type === "script") {
-          block = getResolvedScript(descriptor, ssr);
-        } else if (query.type === "template") {
-          block = descriptor.template;
-        } else if (query.type === "style") {
-          block = descriptor.styles[query.index];
-        } else if (query.index != null) {
-          block = descriptor.customBlocks[query.index];
-        }
-        if (block) {
-          return {
-            code: block.content,
-            map: block.map
-          };
-        }
-      }
-    },
-    async transform(code, id, opt) {
-      const ssr = opt?.ssr === true;
-      const { filename, query } = parseVueRequest(id);
-      if (query.raw) {
-        return;
-      }
-      if (!filter(filename) && !query.vue) {
-        return;
-      }
-      if (!query.vue) {
-        return transformMain(code, filename, options, this, ssr);
-      } else {
-        const descriptor = query.src ? getSrcDescriptor(filename, query) : getDescriptor(filename, options);
-        if (query.type === "template") {
-          return {
-            code: await transformTemplateAsModule(code, descriptor, options, this, ssr),
-            map: {
-              mappings: ""
-            }
-          };
-        } else if (query.type === "style") {
-          return transformStyle(code, descriptor, Number(query.index), options, this, filename);
-        }
-      }
-    }
-  };
-}
-
-const name = "kirbyup";
-const version = "2.0.1";
-
-class PrettyError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = this.constructor.name;
-    if (typeof Error.captureStackTrace === "function")
-      Error.captureStackTrace(this, this.constructor);
-    else
-      this.stack = new Error(message).stack;
-  }
-}
-function handleError(error) {
-  consola.error(error.message);
-  process.exitCode = 1;
-}
-
-function toArray(array) {
-  array = array || [];
-  if (Array.isArray(array))
-    return array;
-  return [array];
-}
-const compress = promisify(gzip);
-async function getCompressedSize(code) {
-  const size = (await compress(typeof code === "string" ? code : Buffer.from(code))).length / 1024;
-  return ` / gzip: ${size.toFixed(2)} KiB`;
-}
-async function printFileInfo(root, outDir, filePath, content, type, maxLength) {
-  const prettyOutDir = `${normalize(relative(root, resolve$1(root, outDir)))}/`;
-  const kibs = content.length / 1024;
-  const compressedSize = await getCompressedSize(content);
-  const writeColor = type === "chunk" ? colors.cyan : colors.magenta;
-  consola.log(
-    colors.white(colors.dim(prettyOutDir)) + writeColor(filePath.padEnd(maxLength + 2)) + colors.dim(`${kibs.toFixed(2)} KiB${compressedSize}`)
-  );
-}
-
-async function loadConfig(cwd = process.cwd(), configOrPath = cwd, extraConfigSources = []) {
-  let inlineConfig = {};
-  if (typeof configOrPath !== "string") {
-    inlineConfig = configOrPath;
-    if (inlineConfig.configFile === false) {
-      return {
-        config: inlineConfig,
-        sources: []
-      };
-    } else {
-      configOrPath = inlineConfig.configFile || process.cwd();
-    }
-  }
-  const resolved = resolve$1(configOrPath);
-  let isFile = false;
-  if (existsSync(resolved) && statSync(resolved).isFile()) {
-    isFile = true;
-    cwd = dirname(resolved);
-  }
-  const loader = createConfigLoader({
-    sources: isFile ? [
-      {
-        files: resolved,
-        extensions: []
-      }
-    ] : [
-      {
-        files: ["kirbyup.config"]
-      },
-      ...extraConfigSources
-    ],
-    cwd,
-    defaults: inlineConfig
-  });
-  const result = await loader.load();
-  result.config = result.config || inlineConfig;
-  return result;
-}
-
-const multilineCommentsRE = /\/\*(.|[\r\n])*?\*\//gm;
-const singlelineCommentsRE = /\/\/.*/g;
-
-function kirbyupAutoImportPlugin() {
-  let config;
-  return {
-    name: "kirbyup:auto-import",
-    configResolved(resolvedConfig) {
-      config = resolvedConfig;
-    },
-    async transform(code) {
-      if (code.includes("kirbyup.import")) {
-        const kirbyupImportRE = /\bkirbyup\.import\s*\(\s*('[^']+'|"[^"]+"|`[^`]+`)\s*\)/g;
-        const noCommentsCode = code.replace(multilineCommentsRE, (m) => " ".repeat(m.length)).replace(singlelineCommentsRE, (m) => " ".repeat(m.length));
-        let s = null;
-        let match;
-        while (match = kirbyupImportRE.exec(noCommentsCode)) {
-          const { 0: exp, 1: rawPath, index } = match;
-          if (!s)
-            s = new MagicString(code);
-          s.overwrite(
-            index,
-            index + exp.length,
-            `kirbyup.import(import.meta.glob(${rawPath}, { eager: true }))`
-          );
-        }
-        if (s) {
-          return {
-            code: s.toString(),
-            map: config.build.sourcemap ? s.generateMap({ hires: true }) : null
-          };
-        }
-      }
-      return null;
-    }
-  };
-}
-
-const __HMR_CODE__ = `
-if (typeof __VUE_HMR_RUNTIME__ !== 'undefined' && import.meta.hot) {
-  __VUE_HMR_RUNTIME__.reload = () => import.meta.hot.invalidate();
-}`.trim();
-const getViteProxyModule = (entryUrl, pm) => `
-try {
-  await import("${entryUrl}");
-} catch (err) {
-  console.error(
-    "[kirbyup] Couldn't connect to the development server. Run \`${pm} run serve\` to start Vite or build the plugin with \`${pm} run build\` so Kirby uses the production version."
-  );
-  throw err;
-}`.trim();
-function kirbyupHmrPlugin(options) {
-  let config;
-  let entry;
-  let indexMjs;
-  return {
-    name: "kirbyup:hmr",
-    apply: "serve",
-    configResolved(resolvedConfig) {
-      config = resolvedConfig;
-      entry = resolve$1(config.root, options.entry);
-      indexMjs = resolve$1(config.root, options.outDir || "", "index.dev.mjs");
-    },
-    transform(code, id) {
-      const { query } = parseVueRequest(id);
-      if (query.raw)
-        return;
-      if ((typeof id !== "string" || /\0/.test(id)) && !query.vue)
-        return;
-      if (/\.vue$/.test(id) && !query.vue)
-        return `${code};${__HMR_CODE__}`;
-    },
-    configureServer(server) {
-      if (!server.httpServer)
-        return;
-      server.httpServer.once("listening", async () => {
-        const entryPath = entry.replace(`${config.root}/`, "");
-        const { address, family, port } = server.httpServer.address();
-        const hostname = family === "IPv6" ? `[${address}]` : address;
-        const baseUrl = `http://${hostname}:${port}${config.base}`;
-        const entryUrl = new URL(entryPath, baseUrl).href;
-        const pm = await detect().catch(() => "npm");
-        await writeFile(indexMjs, getViteProxyModule(entryUrl, pm));
-      });
-    },
-    closeBundle() {
-      if (existsSync$1(indexMjs))
-        unlinkSync(indexMjs);
-    }
-  };
-}
-
-function kirbyupBuildCleanupPlugin(options) {
-  let config;
-  let indexMjs;
-  return {
-    name: "kirbyup:build-cleanup",
-    configResolved(resolvedConfig) {
-      config = resolvedConfig;
-      indexMjs = resolve$1(config.root, options.outDir, "index.dev.mjs");
-    },
-    writeBundle() {
-      if (existsSync$1(indexMjs))
-        unlinkSync(indexMjs);
-    }
-  };
-}
-
-let resolvedKirbyupConfig;
-let resolvedPostCssConfig;
-function getViteConfig(command, options) {
-  const aliasDir = resolve$1(options.cwd, dirname(options.entry));
-  const { alias = {}, extendViteConfig = {} } = resolvedKirbyupConfig;
-  const baseConfig = {
-    resolve: {
-      alias: { "~/": `${aliasDir}/`, "@/": `${aliasDir}/`, ...alias }
-    },
-    plugins: [vuePlugin(), kirbyupAutoImportPlugin()],
-    css: { postcss: resolvedPostCssConfig },
-    envPrefix: ["VITE_", "KIRBYUP_"],
-    logLevel: "warn"
-  };
-  if (command === "serve") {
-    const { port, watch } = options;
-    const serveConfig = mergeConfig(baseConfig, {
-      plugins: [
-        kirbyupHmrPlugin(options),
-        watch && fullReloadPlugin(watch)
-      ],
-      build: { rollupOptions: { input: resolve$1(options.cwd, options.entry) } },
-      server: { port, strictPort: true, origin: `http://localhost:${port}` }
-    });
-    return mergeConfig(serveConfig, extendViteConfig);
-  }
-  const mode = options.watch ? "development" : "production";
-  const buildConfig = mergeConfig(baseConfig, {
-    plugins: [kirbyupBuildCleanupPlugin(options)],
-    mode,
-    build: {
-      lib: {
-        entry: resolve$1(options.cwd, options.entry),
-        formats: ["iife"],
-        name: "kirbyupExport",
-        fileName: () => "index.js"
-      },
-      minify: mode === "production",
-      outDir: options.outDir,
-      emptyOutDir: false,
-      rollupOptions: {
-        external: ["vue"],
-        output: {
-          assetFileNames: "index.[ext]",
-          globals: { vue: "Vue" }
-        }
-      }
-    }
-  });
-  return mergeConfig(buildConfig, extendViteConfig);
-}
-async function generate(options) {
-  const config = getViteConfig("build", options);
-  let result;
-  try {
-    result = await build$1(config);
-  } catch (error) {
-    consola.error("Build failed");
-    if (config.mode === "production")
-      throw error;
-  }
-  if (result && !options.watch) {
-    const { output } = toArray(result)[0];
-    let longest = 0;
-    for (const file in output) {
-      const l = output[file].fileName.length;
-      if (l > longest)
-        longest = l;
-    }
-    for (const {
-      fileName,
-      type,
-      code
-    } of output) {
-      await printFileInfo(
-        options.cwd,
-        options.outDir,
-        fileName,
-        code ?? await readFile(resolve$1(options.outDir, fileName), "utf8"),
-        type,
-        longest
-      );
-    }
-  }
-  return result;
-}
-async function build(options) {
-  ensureEntry(options);
-  const { cwd } = options;
-  const { config, sources: configSources } = await loadConfig(cwd);
-  resolvedKirbyupConfig = config;
-  try {
-    resolvedPostCssConfig = await postcssrc({});
-  } catch (err) {
-    if (!/No PostCSS Config found/.test(err.message))
-      throw err;
-    resolvedPostCssConfig = {
-      plugins: [postcssLogical(), postcssDirPseudoClass()]
-    };
-  }
-  {
-    consola.log(colors.green(`${name} v${version}`));
-    consola.start(`Building ${colors.cyan(options.entry)}`);
-  }
-  if (options.watch)
-    consola.info("Running in watch mode");
-  const debouncedBuild = debounce(async () => {
-    generate(options).catch(handleError);
-  }, 100);
-  const startWatcher = async () => {
-    if (!options.watch)
-      return;
-    const { watch } = await import('chokidar');
-    const ignored = [
-      "**/{.git,node_modules}/**",
-      "index.{css,js}"
-    ];
-    const watchPaths = typeof options.watch === "boolean" ? dirname(options.entry) : Array.isArray(options.watch) ? options.watch.filter(
-      (path) => typeof path === "string"
-    ) : options.watch;
-    consola.info(
-      `Watching for changes in ${toArray(watchPaths).map((i) => colors.cyan(i)).join(", ")}`
-    );
-    const watcher = watch(watchPaths, {
-      ignoreInitial: true,
-      ignorePermissionErrors: true,
-      ignored,
-      cwd
-    });
-    if (configSources.length)
-      watcher.add(configSources);
-    watcher.on("all", async (type, file) => {
-      if (configSources.includes(file)) {
-        resolvedKirbyupConfig = (await loadConfig()).config;
-        consola.info(
-          `${colors.cyan(basename(file))} changed, setting new config`
-        );
-      } else {
-        consola.log(`${colors.green(type)} ${colors.white(colors.dim(file))}`);
-      }
-      debouncedBuild();
-    });
-  };
-  await generate(options);
-  consola.success("Build successful");
-  startWatcher();
-}
-async function serve(options) {
-  ensureEntry(options);
-  const { cwd } = options;
-  const { config } = await loadConfig(cwd);
-  resolvedKirbyupConfig = config;
-  try {
-    resolvedPostCssConfig = await postcssrc({});
-  } catch (err) {
-    if (!/No PostCSS Config found/.test(err.message))
-      throw err;
-    resolvedPostCssConfig = {
-      plugins: [postcssLogical(), postcssDirPseudoClass()]
-    };
-  }
-  {
-    consola.log(colors.green(`${name} v${version}`));
-    consola.info("Starting development server...");
-  }
-  const server = await createServer(getViteConfig("serve", options));
-  await server.listen();
-  consola.success(`Server is listening on :${server.config.server.port}`);
-  return server;
-}
-function ensureEntry(options) {
-  if (!existsSync$1(resolve$1(options.cwd, options.entry)))
-    throw new PrettyError(`Cannot find "${options.entry}"`);
-}
-
-export { build as b, handleError as h, name as n, serve as s, version as v };