@hyperfrontend/builder 0.1.0

package/_dependencies/@rollup/plugin-typescript/index.esm.js

@@ -0,0 +1,4819 @@
+import * as path$2 from 'path';
+import path__default, { win32, posix, isAbsolute, resolve as resolve$2, dirname, relative } from 'path';
+import * as fs__default from 'fs';
+import fs__default__default, { promises, readFileSync } from 'fs';
+import * as require$$0 from 'os';
+import require$$0__default from 'os';
+import typescript$1 from 'typescript';
+import { fileURLToPath } from 'url';
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var utils = {};
+
+var constants$2;
+var hasRequiredConstants;
+
+function requireConstants () {
+	if (hasRequiredConstants) return constants$2;
+	hasRequiredConstants = 1;
+
+	const WIN_SLASH = '\\\\/';
+	const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+
+	const DEFAULT_MAX_EXTGLOB_RECURSION = 0;
+
+	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 SEP = '/';
+
+	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,
+	  SEP
+	};
+
+	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}]|$)`,
+	  SEP: '\\'
+	};
+
+	const POSIX_REGEX_SOURCE = {
+	  __proto__: null,
+	  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'
+	};
+
+	constants$2 = {
+	  DEFAULT_MAX_EXTGLOB_RECURSION,
+	  MAX_LENGTH: 1024 * 64,
+	  POSIX_REGEX_SOURCE,
+
+	  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,
+
+	  REPLACEMENTS: {
+	    __proto__: null,
+	    '***': '*',
+	    '**/**': '**',
+	    '**/**/**': '**'
+	  },
+
+	  CHAR_0: 48, 
+	  CHAR_9: 57, 
+
+	  CHAR_UPPERCASE_A: 65, 
+	  CHAR_LOWERCASE_A: 97, 
+	  CHAR_UPPERCASE_Z: 90, 
+	  CHAR_LOWERCASE_Z: 122, 
+
+	  CHAR_LEFT_PARENTHESES: 40, 
+	  CHAR_RIGHT_PARENTHESES: 41, 
+
+	  CHAR_ASTERISK: 42, 
+
+	  CHAR_AMPERSAND: 38, 
+	  CHAR_AT: 64, 
+	  CHAR_BACKWARD_SLASH: 92, 
+	  CHAR_CARRIAGE_RETURN: 13, 
+	  CHAR_CIRCUMFLEX_ACCENT: 94, 
+	  CHAR_COLON: 58, 
+	  CHAR_COMMA: 44, 
+	  CHAR_DOT: 46, 
+	  CHAR_DOUBLE_QUOTE: 34, 
+	  CHAR_EQUAL: 61, 
+	  CHAR_EXCLAMATION_MARK: 33, 
+	  CHAR_FORM_FEED: 12, 
+	  CHAR_FORWARD_SLASH: 47, 
+	  CHAR_GRAVE_ACCENT: 96, 
+	  CHAR_HASH: 35, 
+	  CHAR_HYPHEN_MINUS: 45, 
+	  CHAR_LEFT_ANGLE_BRACKET: 60, 
+	  CHAR_LEFT_CURLY_BRACE: 123, 
+	  CHAR_LEFT_SQUARE_BRACKET: 91, 
+	  CHAR_LINE_FEED: 10, 
+	  CHAR_NO_BREAK_SPACE: 160, 
+	  CHAR_PERCENT: 37, 
+	  CHAR_PLUS: 43, 
+	  CHAR_QUESTION_MARK: 63, 
+	  CHAR_RIGHT_ANGLE_BRACKET: 62, 
+	  CHAR_RIGHT_CURLY_BRACE: 125, 
+	  CHAR_RIGHT_SQUARE_BRACKET: 93, 
+	  CHAR_SEMICOLON: 59, 
+	  CHAR_SINGLE_QUOTE: 39, 
+	  CHAR_SPACE: 32, 
+	  CHAR_TAB: 9, 
+	  CHAR_UNDERSCORE: 95, 
+	  CHAR_VERTICAL_LINE: 124, 
+	  CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, 
+
+	  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: ')' }
+	    };
+	  },
+
+	  globChars(win32) {
+	    return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
+	  }
+	};
+	return constants$2;
+}
+
+var hasRequiredUtils;
+
+function requireUtils () {
+	if (hasRequiredUtils) return utils;
+	hasRequiredUtils = 1;
+	(function (exports$1) {
+
+		const {
+		  REGEX_BACKSLASH,
+		  REGEX_REMOVE_BACKSLASH,
+		  REGEX_SPECIAL_CHARS,
+		  REGEX_SPECIAL_CHARS_GLOBAL
+		} = /*@__PURE__*/ requireConstants();
+
+		exports$1.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
+		exports$1.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);
+		exports$1.isRegexChar = str => str.length === 1 && exports$1.hasRegexChars(str);
+		exports$1.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
+		exports$1.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/');
+
+		exports$1.isWindows = () => {
+		  if (typeof navigator !== 'undefined' && navigator.platform) {
+		    const platform = navigator.platform.toLowerCase();
+		    return platform === 'win32' || platform === 'windows';
+		  }
+
+		  if (typeof process !== 'undefined' && process.platform) {
+		    return process.platform === 'win32';
+		  }
+
+		  return false;
+		};
+
+		exports$1.removeBackslashes = str => {
+		  return str.replace(REGEX_REMOVE_BACKSLASH, match => {
+		    return match === '\\' ? '' : match;
+		  });
+		};
+
+		exports$1.escapeLast = (input, char, lastIdx) => {
+		  const idx = input.lastIndexOf(char, lastIdx);
+		  if (idx === -1) return input;
+		  if (input[idx - 1] === '\\') return exports$1.escapeLast(input, char, idx - 1);
+		  return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+		};
+
+		exports$1.removePrefix = (input, state = {}) => {
+		  let output = input;
+		  if (output.startsWith('./')) {
+		    output = output.slice(2);
+		    state.prefix = './';
+		  }
+		  return output;
+		};
+
+		exports$1.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;
+		};
+
+		exports$1.basename = (path, { windows } = {}) => {
+		  const segs = path.split(windows ? /[\\/]/ : '/');
+		  const last = segs[segs.length - 1];
+
+		  if (last === '') {
+		    return segs[segs.length - 2];
+		  }
+
+		  return last;
+		}; 
+	} (utils));
+	return utils;
+}
+
+var scan_1;
+var hasRequiredScan;
+
+function requireScan () {
+	if (hasRequiredScan) return scan_1;
+	hasRequiredScan = 1;
+
+	const utils = /*@__PURE__*/ requireUtils();
+	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  
+	} = /*@__PURE__*/ requireConstants();
+
+	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;
+	  }
+	};
+
+	const scan = (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.removeBackslashes(glob);
+
+	    if (base && backslashes === true) {
+	      base = utils.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;
+	};
+
+	scan_1 = scan;
+	return scan_1;
+}
+
+var parse_1;
+var hasRequiredParse;
+
+function requireParse () {
+	if (hasRequiredParse) return parse_1;
+	hasRequiredParse = 1;
+
+	const constants = /*@__PURE__*/ requireConstants();
+	const utils = /*@__PURE__*/ requireUtils();
+
+	const {
+	  MAX_LENGTH,
+	  POSIX_REGEX_SOURCE,
+	  REGEX_NON_SPECIAL_CHARS,
+	  REGEX_SPECIAL_CHARS_BACKREF,
+	  REPLACEMENTS
+	} = constants;
+
+	const expandRange = (args, options) => {
+	  if (typeof options.expandRange === 'function') {
+	    return options.expandRange(...args, options);
+	  }
+
+	  args.sort();
+	  const value = `[${args.join('-')}]`;
+
+	  try {
+	    new RegExp(value);
+	  } catch (ex) {
+	    return args.map(v => utils.escapeRegex(v)).join('..');
+	  }
+
+	  return value;
+	};
+
+	const syntaxError = (type, char) => {
+	  return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+	};
+
+	const splitTopLevel = input => {
+	  const parts = [];
+	  let bracket = 0;
+	  let paren = 0;
+	  let quote = 0;
+	  let value = '';
+	  let escaped = false;
+
+	  for (const ch of input) {
+	    if (escaped === true) {
+	      value += ch;
+	      escaped = false;
+	      continue;
+	    }
+
+	    if (ch === '\\') {
+	      value += ch;
+	      escaped = true;
+	      continue;
+	    }
+
+	    if (ch === '"') {
+	      quote = quote === 1 ? 0 : 1;
+	      value += ch;
+	      continue;
+	    }
+
+	    if (quote === 0) {
+	      if (ch === '[') {
+	        bracket++;
+	      } else if (ch === ']' && bracket > 0) {
+	        bracket--;
+	      } else if (bracket === 0) {
+	        if (ch === '(') {
+	          paren++;
+	        } else if (ch === ')' && paren > 0) {
+	          paren--;
+	        } else if (ch === '|' && paren === 0) {
+	          parts.push(value);
+	          value = '';
+	          continue;
+	        }
+	      }
+	    }
+
+	    value += ch;
+	  }
+
+	  parts.push(value);
+	  return parts;
+	};
+
+	const isPlainBranch = branch => {
+	  let escaped = false;
+
+	  for (const ch of branch) {
+	    if (escaped === true) {
+	      escaped = false;
+	      continue;
+	    }
+
+	    if (ch === '\\') {
+	      escaped = true;
+	      continue;
+	    }
+
+	    if (/[?*+@!()[\]{}]/.test(ch)) {
+	      return false;
+	    }
+	  }
+
+	  return true;
+	};
+
+	const normalizeSimpleBranch = branch => {
+	  let value = branch.trim();
+	  let changed = true;
+
+	  while (changed === true) {
+	    changed = false;
+
+	    if (/^@\([^\\()[\]{}|]+\)$/.test(value)) {
+	      value = value.slice(2, -1);
+	      changed = true;
+	    }
+	  }
+
+	  if (!isPlainBranch(value)) {
+	    return;
+	  }
+
+	  return value.replace(/\\(.)/g, '$1');
+	};
+
+	const hasRepeatedCharPrefixOverlap = branches => {
+	  const values = branches.map(normalizeSimpleBranch).filter(Boolean);
+
+	  for (let i = 0; i < values.length; i++) {
+	    for (let j = i + 1; j < values.length; j++) {
+	      const a = values[i];
+	      const b = values[j];
+	      const char = a[0];
+
+	      if (!char || a !== char.repeat(a.length) || b !== char.repeat(b.length)) {
+	        continue;
+	      }
+
+	      if (a === b || a.startsWith(b) || b.startsWith(a)) {
+	        return true;
+	      }
+	    }
+	  }
+
+	  return false;
+	};
+
+	const parseRepeatedExtglob = (pattern, requireEnd = true) => {
+	  if ((pattern[0] !== '+' && pattern[0] !== '*') || pattern[1] !== '(') {
+	    return;
+	  }
+
+	  let bracket = 0;
+	  let paren = 0;
+	  let quote = 0;
+	  let escaped = false;
+
+	  for (let i = 1; i < pattern.length; i++) {
+	    const ch = pattern[i];
+
+	    if (escaped === true) {
+	      escaped = false;
+	      continue;
+	    }
+
+	    if (ch === '\\') {
+	      escaped = true;
+	      continue;
+	    }
+
+	    if (ch === '"') {
+	      quote = quote === 1 ? 0 : 1;
+	      continue;
+	    }
+
+	    if (quote === 1) {
+	      continue;
+	    }
+
+	    if (ch === '[') {
+	      bracket++;
+	      continue;
+	    }
+
+	    if (ch === ']' && bracket > 0) {
+	      bracket--;
+	      continue;
+	    }
+
+	    if (bracket > 0) {
+	      continue;
+	    }
+
+	    if (ch === '(') {
+	      paren++;
+	      continue;
+	    }
+
+	    if (ch === ')') {
+	      paren--;
+
+	      if (paren === 0) {
+	        if (requireEnd === true && i !== pattern.length - 1) {
+	          return;
+	        }
+
+	        return {
+	          type: pattern[0],
+	          body: pattern.slice(2, i),
+	          end: i
+	        };
+	      }
+	    }
+	  }
+	};
+
+	const getStarExtglobSequenceOutput = pattern => {
+	  let index = 0;
+	  const chars = [];
+
+	  while (index < pattern.length) {
+	    const match = parseRepeatedExtglob(pattern.slice(index), false);
+
+	    if (!match || match.type !== '*') {
+	      return;
+	    }
+
+	    const branches = splitTopLevel(match.body).map(branch => branch.trim());
+	    if (branches.length !== 1) {
+	      return;
+	    }
+
+	    const branch = normalizeSimpleBranch(branches[0]);
+	    if (!branch || branch.length !== 1) {
+	      return;
+	    }
+
+	    chars.push(branch);
+	    index += match.end + 1;
+	  }
+
+	  if (chars.length < 1) {
+	    return;
+	  }
+
+	  const source = chars.length === 1
+	    ? utils.escapeRegex(chars[0])
+	    : `[${chars.map(ch => utils.escapeRegex(ch)).join('')}]`;
+
+	  return `${source}*`;
+	};
+
+	const repeatedExtglobRecursion = pattern => {
+	  let depth = 0;
+	  let value = pattern.trim();
+	  let match = parseRepeatedExtglob(value);
+
+	  while (match) {
+	    depth++;
+	    value = match.body.trim();
+	    match = parseRepeatedExtglob(value);
+	  }
+
+	  return depth;
+	};
+
+	const analyzeRepeatedExtglob = (body, options) => {
+	  if (options.maxExtglobRecursion === false) {
+	    return { risky: false };
+	  }
+
+	  const max =
+	    typeof options.maxExtglobRecursion === 'number'
+	      ? options.maxExtglobRecursion
+	      : constants.DEFAULT_MAX_EXTGLOB_RECURSION;
+
+	  const branches = splitTopLevel(body).map(branch => branch.trim());
+
+	  if (branches.length > 1) {
+	    if (
+	      branches.some(branch => branch === '') ||
+	      branches.some(branch => /^[*?]+$/.test(branch)) ||
+	      hasRepeatedCharPrefixOverlap(branches)
+	    ) {
+	      return { risky: true };
+	    }
+	  }
+
+	  for (const branch of branches) {
+	    const safeOutput = getStarExtglobSequenceOutput(branch);
+	    if (safeOutput) {
+	      return { risky: true, safeOutput };
+	    }
+
+	    if (repeatedExtglobRecursion(branch) > max) {
+	      return { risky: true };
+	    }
+	  }
+
+	  return { risky: false };
+	};
+
+	const parse = (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 PLATFORM_CHARS = constants.globChars(opts.windows);
+	  const EXTGLOB_CHARS = constants.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})`;
+	  }
+
+	  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.removePrefix(input, state);
+	  len = input.length;
+
+	  const extglobs = [];
+	  const braces = [];
+	  const stack = [];
+	  let prev = bos;
+	  let value;
+
+	  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();
+	  };
+
+	  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.output = (prev.output || prev.value) + tok.value;
+	      prev.value += 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;
+	    token.startIndex = state.index;
+	    token.tokensIndex = tokens.length;
+	    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 => {
+	    const literal = input.slice(token.startIndex, state.index + 1);
+	    const body = input.slice(token.startIndex + 2, state.index);
+	    const analysis = analyzeRepeatedExtglob(body, opts);
+
+	    if ((token.type === 'plus' || token.type === 'star') && analysis.risky) {
+	      const safeOutput = analysis.safeOutput
+	        ? (token.output ? '' : ONE_CHAR) + (opts.capture ? `(${analysis.safeOutput})` : analysis.safeOutput)
+	        : undefined;
+	      const open = tokens[token.tokensIndex];
+
+	      open.type = 'text';
+	      open.value = literal;
+	      open.output = safeOutput || utils.escapeRegex(literal);
+
+	      for (let i = token.tokensIndex + 1; i < tokens.length; i++) {
+	        tokens[i].value = '';
+	        tokens[i].output = '';
+	        delete tokens[i].suffix;
+	      }
+
+	      state.output = token.output + open.output;
+	      state.backtrack = true;
+
+	      push({ type: 'paren', extglob: true, value, output: '' });
+	      decrement('parens');
+	      return;
+	    }
+
+	    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)) {
+	        const expression = parse(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');
+	  };
+
+	  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.wrapOutput(output, state, options);
+	    return state;
+	  }
+
+	  while (!eos()) {
+	    value = advance();
+
+	    if (value === '\u0000') {
+	      continue;
+	    }
+
+	    if (value === '\\') {
+	      const next = peek();
+
+	      if (next === '/' && opts.bash !== true) {
+	        continue;
+	      }
+
+	      if (next === '.' || next === ';') {
+	        continue;
+	      }
+
+	      if (!next) {
+	        value += '\\';
+	        push({ type: 'text', value });
+	        continue;
+	      }
+
+	      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 (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 (state.quotes === 1 && value !== '"') {
+	      value = utils.escapeRegex(value);
+	      prev.value += value;
+	      append({ value });
+	      continue;
+	    }
+
+	    if (value === '"') {
+	      state.quotes = state.quotes === 1 ? 0 : 1;
+	      if (opts.keepQuotes === true) {
+	        push({ type: 'text', value });
+	      }
+	      continue;
+	    }
+
+	    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;
+	    }
+
+	    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 });
+
+	      if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) {
+	        continue;
+	      }
+
+	      const escaped = utils.escapeRegex(prev.value);
+	      state.output = state.output.slice(0, -prev.value.length);
+
+	      if (opts.literalBrackets === true) {
+	        state.output += escaped;
+	        prev.value = escaped;
+	        continue;
+	      }
+
+	      prev.value = `(${capture}${escaped}|${prev.value})`;
+	      state.output += prev.value;
+	      continue;
+	    }
+
+	    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;
+	    }
+
+	    if (value === '|') {
+	      if (extglobs.length > 0) {
+	        extglobs[extglobs.length - 1].conditions++;
+	      }
+	      push({ type: 'text', value });
+	      continue;
+	    }
+
+	    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;
+	    }
+
+	    if (value === '/') {
+	      if (prev.type === 'dot' && state.index === state.start + 1) {
+	        state.start = state.index + 1;
+	        state.consumed = '';
+	        state.output = '';
+	        tokens.pop();
+	        prev = bos; 
+	        continue;
+	      }
+
+	      push({ type: 'slash', value, output: SLASH_LITERAL });
+	      continue;
+	    }
+
+	    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;
+	    }
+
+	    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 ((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;
+	    }
+
+	    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;
+	      }
+	    }
+
+	    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;
+	    }
+
+	    if (value === '@') {
+	      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+	        push({ type: 'at', extglob: true, value, output: '' });
+	        continue;
+	      }
+
+	      push({ type: 'text', value });
+	      continue;
+	    }
+
+	    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;
+	    }
+
+	    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;
+	      }
+
+	      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;
+	      }
+
+	      state.output = state.output.slice(0, -prev.output.length);
+
+	      prev.type = 'globstar';
+	      prev.output = globstar(opts);
+	      prev.value += value;
+
+	      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.escapeLast(state.output, '[');
+	    decrement('brackets');
+	  }
+
+	  while (state.parens > 0) {
+	    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')'));
+	    state.output = utils.escapeLast(state.output, '(');
+	    decrement('parens');
+	  }
+
+	  while (state.braces > 0) {
+	    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}'));
+	    state.output = utils.escapeLast(state.output, '{');
+	    decrement('braces');
+	  }
+
+	  if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) {
+	    push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` });
+	  }
+
+	  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;
+	};
+
+	parse.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 {
+	    DOT_LITERAL,
+	    SLASH_LITERAL,
+	    ONE_CHAR,
+	    DOTS_SLASH,
+	    NO_DOT,
+	    NO_DOTS,
+	    NO_DOTS_SLASH,
+	    STAR,
+	    START_ANCHOR
+	  } = constants.globChars(opts.windows);
+
+	  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.removePrefix(input, state);
+	  let source = create(output);
+
+	  if (source && opts.strictSlashes !== true) {
+	    source += `${SLASH_LITERAL}?`;
+	  }
+
+	  return source;
+	};
+
+	parse_1 = parse;
+	return parse_1;
+}
+
+var picomatch_1$1;
+var hasRequiredPicomatch$1;
+
+function requirePicomatch$1 () {
+	if (hasRequiredPicomatch$1) return picomatch_1$1;
+	hasRequiredPicomatch$1 = 1;
+
+	const scan = /*@__PURE__*/ requireScan();
+	const parse = /*@__PURE__*/ requireParse();
+	const utils = /*@__PURE__*/ requireUtils();
+	const constants = /*@__PURE__*/ requireConstants();
+	const isObject = val => val && typeof val === 'object' && !Array.isArray(val);
+
+	const picomatch = (glob, options, returnState = false) => {
+	  if (Array.isArray(glob)) {
+	    const fns = glob.map(input => picomatch(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 = opts.windows;
+	  const regex = isState
+	    ? picomatch.compileRe(glob, options)
+	    : picomatch.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(opts.ignore, ignoreOpts, returnState);
+	  }
+
+	  const matcher = (input, returnObject = false) => {
+	    const { isMatch, match, output } = picomatch.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;
+	};
+
+	picomatch.test = (input, regex, options, { glob, posix } = {}) => {
+	  if (typeof input !== 'string') {
+	    throw new TypeError('Expected input to be a string');
+	  }
+
+	  if (input === '') {
+	    return { isMatch: false, output: '' };
+	  }
+
+	  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.matchBase(input, regex, options, posix);
+	    } else {
+	      match = regex.exec(output);
+	    }
+	  }
+
+	  return { isMatch: Boolean(match), match, output };
+	};
+
+	picomatch.matchBase = (input, glob, options) => {
+	  const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
+	  return regex.test(utils.basename(input));
+	};
+
+	picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+
+	picomatch.parse = (pattern, options) => {
+	  if (Array.isArray(pattern)) return pattern.map(p => picomatch.parse(p, options));
+	  return parse(pattern, { ...options, fastpaths: false });
+	};
+
+	picomatch.scan = (input, options) => scan(input, options);
+
+	picomatch.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.toRegex(source, options);
+	  if (returnState === true) {
+	    regex.state = state;
+	  }
+
+	  return regex;
+	};
+
+	picomatch.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.compileRe(parsed, options, returnOutput, returnState);
+	};
+
+	picomatch.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 = constants;
+
+	picomatch_1$1 = picomatch;
+	return picomatch_1$1;
+}
+
+var picomatch_1;
+var hasRequiredPicomatch;
+
+function requirePicomatch () {
+	if (hasRequiredPicomatch) return picomatch_1;
+	hasRequiredPicomatch = 1;
+
+	const pico = /*@__PURE__*/ requirePicomatch$1();
+	const utils = /*@__PURE__*/ requireUtils();
+
+	function picomatch(glob, options, returnState = false) {
+	  if (options && (options.windows === null || options.windows === undefined)) {
+	    options = { ...options, windows: utils.isWindows() };
+	  }
+
+	  return pico(glob, options, returnState);
+	}
+
+	Object.assign(picomatch, pico);
+	picomatch_1 = picomatch;
+	return picomatch_1;
+}
+
+var picomatchExports = /*@__PURE__*/ requirePicomatch();
+const pm = /*@__PURE__*/getDefaultExportFromCjs(picomatchExports);
+
+function isArray(arg) {
+    return Array.isArray(arg);
+}
+function ensureArray(thing) {
+    if (isArray(thing))
+        return thing;
+    if (thing == null)
+        return [];
+    return [thing];
+}
+
+const normalizePathRegExp = new RegExp(`\\${win32.sep}`, 'g');
+const normalizePath$1 = function normalizePath(filename) {
+    return filename.replace(normalizePathRegExp, posix.sep);
+};
+
+function getMatcherString(id, resolutionBase) {
+    if (resolutionBase === false || isAbsolute(id) || id.startsWith('**')) {
+        return normalizePath$1(id);
+    }
+    const basePath = normalizePath$1(resolve$2(resolutionBase || ''))
+        .replace(/[-^$*+?.()|[\]{}]/g, '\\$&');
+    return posix.join(basePath, normalizePath$1(id));
+}
+const createFilter = function createFilter(include, exclude, options) {
+    const resolutionBase = options && options.resolve;
+    const getMatcher = (id) => id instanceof RegExp
+        ? id
+        : {
+            test: (what) => {
+                const pattern = getMatcherString(id, resolutionBase);
+                const fn = pm(pattern, { dot: true });
+                const result = fn(what);
+                return result;
+            }
+        };
+    const includeMatchers = ensureArray(include).map(getMatcher);
+    const excludeMatchers = ensureArray(exclude).map(getMatcher);
+    if (!includeMatchers.length && !excludeMatchers.length)
+        return (id) => typeof id === 'string' && !id.includes('\0');
+    return function result(id) {
+        if (typeof id !== 'string')
+            return false;
+        if (id.includes('\0'))
+            return false;
+        const pathId = normalizePath$1(id);
+        for (let i = 0; i < excludeMatchers.length; ++i) {
+            const matcher = excludeMatchers[i];
+            if (matcher instanceof RegExp) {
+                matcher.lastIndex = 0;
+            }
+            if (matcher.test(pathId))
+                return false;
+        }
+        for (let i = 0; i < includeMatchers.length; ++i) {
+            const matcher = includeMatchers[i];
+            if (matcher instanceof RegExp) {
+                matcher.lastIndex = 0;
+            }
+            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('');
+
+var homedir;
+var hasRequiredHomedir;
+
+function requireHomedir () {
+	if (hasRequiredHomedir) return homedir;
+	hasRequiredHomedir = 1;
+
+	var os = require$$0__default;
+
+	homedir = os.homedir || function homedir() {
+	    var home = process.env.HOME;
+	    var user = process.env.LOGNAME || process.env.USER || process.env.LNAME || process.env.USERNAME;
+
+	    if (process.platform === 'win32') {
+	        return process.env.USERPROFILE || process.env.HOMEDRIVE + process.env.HOMEPATH || home || null;
+	    }
+
+	    if (process.platform === 'darwin') {
+	        return home || (user ? '/Users/' + user : null);
+	    }
+
+	    if (process.platform === 'linux') {
+	        return home || (process.getuid() === 0 ? '/root' : (user ? '/home/' + user : null)); 
+	    }
+
+	    return home || null;
+	};
+	return homedir;
+}
+
+var caller;
+var hasRequiredCaller;
+
+function requireCaller () {
+	if (hasRequiredCaller) return caller;
+	hasRequiredCaller = 1;
+	caller = function () {
+	    var origPrepareStackTrace = Error.prepareStackTrace;
+	    Error.prepareStackTrace = function (_, stack) { return stack; };
+	    var stack = (new Error()).stack;
+	    Error.prepareStackTrace = origPrepareStackTrace;
+	    return stack[2].getFileName();
+	};
+	return caller;
+}
+
+var pathParse = {exports: {}};
+
+var hasRequiredPathParse;
+
+function requirePathParse () {
+	if (hasRequiredPathParse) return pathParse.exports;
+	hasRequiredPathParse = 1;
+
+	var isWindows = process.platform === 'win32';
+
+	var splitWindowsRe =
+	    /^(((?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?[\\\/]?)(?:[^\\\/]*[\\\/])*)((\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))[\\\/]*$/;
+
+	var win32 = {};
+
+	function win32SplitPath(filename) {
+	  return splitWindowsRe.exec(filename).slice(1);
+	}
+
+	win32.parse = function(pathString) {
+	  if (typeof pathString !== 'string') {
+	    throw new TypeError(
+	        "Parameter 'pathString' must be a string, not " + typeof pathString
+	    );
+	  }
+	  var allParts = win32SplitPath(pathString);
+	  if (!allParts || allParts.length !== 5) {
+	    throw new TypeError("Invalid path '" + pathString + "'");
+	  }
+	  return {
+	    root: allParts[1],
+	    dir: allParts[0] === allParts[1] ? allParts[0] : allParts[0].slice(0, -1),
+	    base: allParts[2],
+	    ext: allParts[4],
+	    name: allParts[3]
+	  };
+	};
+
+
+
+	var splitPathRe =
+	    /^((\/?)(?:[^\/]*\/)*)((\.{1,2}|[^\/]+?|)(\.[^.\/]*|))[\/]*$/;
+	var posix = {};
+
+
+	function posixSplitPath(filename) {
+	  return splitPathRe.exec(filename).slice(1);
+	}
+
+
+	posix.parse = function(pathString) {
+	  if (typeof pathString !== 'string') {
+	    throw new TypeError(
+	        "Parameter 'pathString' must be a string, not " + typeof pathString
+	    );
+	  }
+	  var allParts = posixSplitPath(pathString);
+	  if (!allParts || allParts.length !== 5) {
+	    throw new TypeError("Invalid path '" + pathString + "'");
+	  }
+	  
+	  return {
+	    root: allParts[1],
+	    dir: allParts[0].slice(0, -1),
+	    base: allParts[2],
+	    ext: allParts[4],
+	    name: allParts[3],
+	  };
+	};
+
+
+	if (isWindows)
+	  pathParse.exports = win32.parse;
+	else 
+	  pathParse.exports = posix.parse;
+
+	pathParse.exports.posix = posix.parse;
+	pathParse.exports.win32 = win32.parse;
+	return pathParse.exports;
+}
+
+var nodeModulesPaths;
+var hasRequiredNodeModulesPaths;
+
+function requireNodeModulesPaths () {
+	if (hasRequiredNodeModulesPaths) return nodeModulesPaths;
+	hasRequiredNodeModulesPaths = 1;
+	var path = path__default;
+	var parse = path.parse || requirePathParse(); 
+
+	var driveLetterRegex = /^([A-Za-z]:)/;
+	var uncPathRegex = /^\\\\/;
+
+	var getNodeModulesDirs = function getNodeModulesDirs(absoluteStart, modules) {
+	    var prefix = '/';
+	    if (driveLetterRegex.test(absoluteStart)) {
+	        prefix = '';
+	    } else if (uncPathRegex.test(absoluteStart)) {
+	        prefix = '\\\\';
+	    }
+
+	    var paths = [absoluteStart];
+	    var parsed = parse(absoluteStart);
+	    while (parsed.dir !== paths[paths.length - 1]) {
+	        paths.push(parsed.dir);
+	        parsed = parse(parsed.dir);
+	    }
+
+	    return paths.reduce(function (dirs, aPath) {
+	        return dirs.concat(modules.map(function (moduleDir) {
+	            return path.resolve(prefix, aPath, moduleDir);
+	        }));
+	    }, []);
+	};
+
+	nodeModulesPaths = function nodeModulesPaths(start, opts, request) {
+	    var modules = opts && opts.moduleDirectory
+	        ? [].concat(opts.moduleDirectory)
+	        : ['node_modules'];
+
+	    if (opts && typeof opts.paths === 'function') {
+	        return opts.paths(
+	            request,
+	            start,
+	            function () { return getNodeModulesDirs(start, modules); },
+	            opts
+	        );
+	    }
+
+	    var dirs = getNodeModulesDirs(start, modules);
+	    return opts && opts.paths ? dirs.concat(opts.paths) : dirs;
+	};
+	return nodeModulesPaths;
+}
+
+var normalizeOptions;
+var hasRequiredNormalizeOptions;
+
+function requireNormalizeOptions () {
+	if (hasRequiredNormalizeOptions) return normalizeOptions;
+	hasRequiredNormalizeOptions = 1;
+	normalizeOptions = function (x, opts) {
+	    return opts || {};
+	};
+	return normalizeOptions;
+}
+
+var implementation;
+var hasRequiredImplementation;
+
+function requireImplementation () {
+	if (hasRequiredImplementation) return implementation;
+	hasRequiredImplementation = 1;
+
+	var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';
+	var toStr = Object.prototype.toString;
+	var max = Math.max;
+	var funcType = '[object Function]';
+
+	var concatty = function concatty(a, b) {
+	    var arr = [];
+
+	    for (var i = 0; i < a.length; i += 1) {
+	        arr[i] = a[i];
+	    }
+	    for (var j = 0; j < b.length; j += 1) {
+	        arr[j + a.length] = b[j];
+	    }
+
+	    return arr;
+	};
+
+	var slicy = function slicy(arrLike, offset) {
+	    var arr = [];
+	    for (var i = offset, j = 0; i < arrLike.length; i += 1, j += 1) {
+	        arr[j] = arrLike[i];
+	    }
+	    return arr;
+	};
+
+	var joiny = function (arr, joiner) {
+	    var str = '';
+	    for (var i = 0; i < arr.length; i += 1) {
+	        str += arr[i];
+	        if (i + 1 < arr.length) {
+	            str += joiner;
+	        }
+	    }
+	    return str;
+	};
+
+	implementation = function bind(that) {
+	    var target = this;
+	    if (typeof target !== 'function' || toStr.apply(target) !== funcType) {
+	        throw new TypeError(ERROR_MESSAGE + target);
+	    }
+	    var args = slicy(arguments, 1);
+
+	    var bound;
+	    var binder = function () {
+	        if (this instanceof bound) {
+	            var result = target.apply(
+	                this,
+	                concatty(args, arguments)
+	            );
+	            if (Object(result) === result) {
+	                return result;
+	            }
+	            return this;
+	        }
+	        return target.apply(
+	            that,
+	            concatty(args, arguments)
+	        );
+
+	    };
+
+	    var boundLength = max(0, target.length - args.length);
+	    var boundArgs = [];
+	    for (var i = 0; i < boundLength; i++) {
+	        boundArgs[i] = '$' + i;
+	    }
+
+	    bound = Function('binder', 'return function (' + joiny(boundArgs, ',') + '){ return binder.apply(this,arguments); }')(binder);
+
+	    if (target.prototype) {
+	        var Empty = function Empty() {};
+	        Empty.prototype = target.prototype;
+	        bound.prototype = new Empty();
+	        Empty.prototype = null;
+	    }
+
+	    return bound;
+	};
+	return implementation;
+}
+
+var functionBind;
+var hasRequiredFunctionBind;
+
+function requireFunctionBind () {
+	if (hasRequiredFunctionBind) return functionBind;
+	hasRequiredFunctionBind = 1;
+
+	var implementation = requireImplementation();
+
+	functionBind = Function.prototype.bind || implementation;
+	return functionBind;
+}
+
+var hasown;
+var hasRequiredHasown;
+
+function requireHasown () {
+	if (hasRequiredHasown) return hasown;
+	hasRequiredHasown = 1;
+
+	var call = Function.prototype.call;
+	var $hasOwn = Object.prototype.hasOwnProperty;
+	var bind = requireFunctionBind();
+
+	hasown = bind.call(call, $hasOwn);
+	return hasown;
+}
+
+var assert$1 = true;
+var async_hooks$1 = ">= 8";
+var buffer_ieee754$1 = ">= 0.5 && < 0.9.7";
+var buffer$1 = true;
+var child_process$1 = true;
+var cluster$1 = ">= 0.5";
+var console$1 = true;
+var constants$1 = true;
+var crypto$1 = true;
+var _debug_agent$1 = ">= 1 && < 8";
+var _debugger$1 = "< 8";
+var dgram$1 = true;
+var diagnostics_channel$1 = [
+	">= 14.17 && < 15",
+	">= 15.1"
+];
+var dns$1 = true;
+var domain$1 = ">= 0.7.12";
+var events$1 = true;
+var freelist$1 = "< 6";
+var fs$1 = true;
+var _http_agent$1 = ">= 0.11.1";
+var _http_client$1 = ">= 0.11.1";
+var _http_common$1 = ">= 0.11.1";
+var _http_incoming$1 = ">= 0.11.1";
+var _http_outgoing$1 = ">= 0.11.1";
+var _http_server$1 = ">= 0.11.1";
+var http$1 = true;
+var http2$1 = ">= 8.8";
+var https$1 = true;
+var inspector$1 = ">= 8";
+var _linklist$1 = "< 8";
+var module$2 = true;
+var net$1 = true;
+var os$1 = true;
+var path$1 = true;
+var perf_hooks$1 = ">= 8.5";
+var process$2 = ">= 1";
+var punycode$1 = ">= 0.5";
+var querystring$1 = true;
+var readline$1 = true;
+var repl$1 = true;
+var smalloc$1 = ">= 0.11.5 && < 3";
+var _stream_duplex$1 = ">= 0.9.4";
+var _stream_transform$1 = ">= 0.9.4";
+var _stream_wrap$1 = ">= 1.4.1";
+var _stream_passthrough$1 = ">= 0.9.4";
+var _stream_readable$1 = ">= 0.9.4";
+var _stream_writable$1 = ">= 0.9.4";
+var stream$1 = true;
+var string_decoder$1 = true;
+var sys$1 = [
+	">= 0.4 && < 0.7",
+	">= 0.8"
+];
+var timers$1 = true;
+var _tls_common$1 = ">= 0.11.13";
+var _tls_legacy$1 = ">= 0.11.3 && < 10";
+var _tls_wrap$1 = ">= 0.11.3";
+var tls$1 = true;
+var trace_events$1 = ">= 10";
+var tty$1 = true;
+var url$1 = true;
+var util$1 = true;
+var v8$1 = ">= 1";
+var vm$1 = true;
+var wasi$1 = [
+	">= 13.4 && < 13.5",
+	">= 18.17 && < 19",
+	">= 20"
+];
+var worker_threads$1 = ">= 11.7";
+var zlib$1 = ">= 0.5";
+const require$$1$1 = {
+	assert: assert$1,
+	"node:assert": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"assert/strict": ">= 15",
+	"node:assert/strict": ">= 16",
+	async_hooks: async_hooks$1,
+	"node:async_hooks": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	buffer_ieee754: buffer_ieee754$1,
+	buffer: buffer$1,
+	"node:buffer": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	child_process: child_process$1,
+	"node:child_process": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	cluster: cluster$1,
+	"node:cluster": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	console: console$1,
+	"node:console": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	constants: constants$1,
+	"node:constants": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	crypto: crypto$1,
+	"node:crypto": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_debug_agent: _debug_agent$1,
+	_debugger: _debugger$1,
+	dgram: dgram$1,
+	"node:dgram": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	diagnostics_channel: diagnostics_channel$1,
+	"node:diagnostics_channel": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	dns: dns$1,
+	"node:dns": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"dns/promises": ">= 15",
+	"node:dns/promises": ">= 16",
+	domain: domain$1,
+	"node:domain": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	events: events$1,
+	"node:events": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	freelist: freelist$1,
+	fs: fs$1,
+	"node:fs": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"fs/promises": [
+	">= 10 && < 10.1",
+	">= 14"
+],
+	"node:fs/promises": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_http_agent: _http_agent$1,
+	"node:_http_agent": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_http_client: _http_client$1,
+	"node:_http_client": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_http_common: _http_common$1,
+	"node:_http_common": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_http_incoming: _http_incoming$1,
+	"node:_http_incoming": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_http_outgoing: _http_outgoing$1,
+	"node:_http_outgoing": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_http_server: _http_server$1,
+	"node:_http_server": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	http: http$1,
+	"node:http": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	http2: http2$1,
+	"node:http2": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	https: https$1,
+	"node:https": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	inspector: inspector$1,
+	"node:inspector": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"inspector/promises": [
+	">= 19"
+],
+	"node:inspector/promises": [
+	">= 19"
+],
+	_linklist: _linklist$1,
+	module: module$2,
+	"node:module": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	net: net$1,
+	"node:net": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"node-inspect/lib/_inspect": ">= 7.6 && < 12",
+	"node-inspect/lib/internal/inspect_client": ">= 7.6 && < 12",
+	"node-inspect/lib/internal/inspect_repl": ">= 7.6 && < 12",
+	os: os$1,
+	"node:os": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	path: path$1,
+	"node:path": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"path/posix": ">= 15.3",
+	"node:path/posix": ">= 16",
+	"path/win32": ">= 15.3",
+	"node:path/win32": ">= 16",
+	perf_hooks: perf_hooks$1,
+	"node:perf_hooks": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	process: process$2,
+	"node:process": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	punycode: punycode$1,
+	"node:punycode": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	querystring: querystring$1,
+	"node:querystring": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	readline: readline$1,
+	"node:readline": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"readline/promises": ">= 17",
+	"node:readline/promises": ">= 17",
+	repl: repl$1,
+	"node:repl": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"node:sea": [
+	">= 20.12 && < 21",
+	">= 21.7"
+],
+	smalloc: smalloc$1,
+	"node:sqlite": [
+	">= 22.13 && < 23",
+	">= 23.4"
+],
+	_stream_duplex: _stream_duplex$1,
+	"node:_stream_duplex": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_stream_transform: _stream_transform$1,
+	"node:_stream_transform": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_stream_wrap: _stream_wrap$1,
+	"node:_stream_wrap": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_stream_passthrough: _stream_passthrough$1,
+	"node:_stream_passthrough": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_stream_readable: _stream_readable$1,
+	"node:_stream_readable": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_stream_writable: _stream_writable$1,
+	"node:_stream_writable": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	stream: stream$1,
+	"node:stream": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"stream/consumers": ">= 16.7",
+	"node:stream/consumers": ">= 16.7",
+	"stream/promises": ">= 15",
+	"node:stream/promises": ">= 16",
+	"stream/web": ">= 16.5",
+	"node:stream/web": ">= 16.5",
+	string_decoder: string_decoder$1,
+	"node:string_decoder": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	sys: sys$1,
+	"node:sys": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"test/reporters": ">= 19.9 && < 20.2",
+	"node:test/reporters": [
+	">= 18.17 && < 19",
+	">= 19.9",
+	">= 20"
+],
+	"test/mock_loader": ">= 22.3 && < 22.7",
+	"node:test/mock_loader": ">= 22.3 && < 22.7",
+	"node:test": [
+	">= 16.17 && < 17",
+	">= 18"
+],
+	timers: timers$1,
+	"node:timers": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"timers/promises": ">= 15",
+	"node:timers/promises": ">= 16",
+	_tls_common: _tls_common$1,
+	"node:_tls_common": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_tls_legacy: _tls_legacy$1,
+	_tls_wrap: _tls_wrap$1,
+	"node:_tls_wrap": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	tls: tls$1,
+	"node:tls": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	trace_events: trace_events$1,
+	"node:trace_events": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	tty: tty$1,
+	"node:tty": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	url: url$1,
+	"node:url": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	util: util$1,
+	"node:util": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"util/types": ">= 15.3",
+	"node:util/types": ">= 16",
+	"v8/tools/arguments": ">= 10 && < 12",
+	"v8/tools/codemap": [
+	">= 4.4 && < 5",
+	">= 5.2 && < 12"
+],
+	"v8/tools/consarray": [
+	">= 4.4 && < 5",
+	">= 5.2 && < 12"
+],
+	"v8/tools/csvparser": [
+	">= 4.4 && < 5",
+	">= 5.2 && < 12"
+],
+	"v8/tools/logreader": [
+	">= 4.4 && < 5",
+	">= 5.2 && < 12"
+],
+	"v8/tools/profile_view": [
+	">= 4.4 && < 5",
+	">= 5.2 && < 12"
+],
+	"v8/tools/splaytree": [
+	">= 4.4 && < 5",
+	">= 5.2 && < 12"
+],
+	v8: v8$1,
+	"node:v8": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	vm: vm$1,
+	"node:vm": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	wasi: wasi$1,
+	"node:wasi": [
+	">= 18.17 && < 19",
+	">= 20"
+],
+	worker_threads: worker_threads$1,
+	"node:worker_threads": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	zlib: zlib$1,
+	"node:zlib": [
+	">= 14.18 && < 15",
+	">= 16"
+]
+};
+
+var isCoreModule;
+var hasRequiredIsCoreModule;
+
+function requireIsCoreModule () {
+	if (hasRequiredIsCoreModule) return isCoreModule;
+	hasRequiredIsCoreModule = 1;
+
+	var hasOwn = /*@__PURE__*/ requireHasown();
+
+	function specifierIncluded(current, specifier) {
+		var nodeParts = current.split('.');
+		var parts = specifier.split(' ');
+		var op = parts.length > 1 ? parts[0] : '=';
+		var versionParts = (parts.length > 1 ? parts[1] : parts[0]).split('.');
+
+		for (var i = 0; i < 3; ++i) {
+			var cur = parseInt(nodeParts[i] || 0, 10);
+			var ver = parseInt(versionParts[i] || 0, 10);
+			if (cur === ver) {
+				continue; 
+			}
+			if (op === '<') {
+				return cur < ver;
+			}
+			if (op === '>=') {
+				return cur >= ver;
+			}
+			return false;
+		}
+		return op === '>=';
+	}
+
+	function matchesRange(current, range) {
+		var specifiers = range.split(/ ?&& ?/);
+		if (specifiers.length === 0) {
+			return false;
+		}
+		for (var i = 0; i < specifiers.length; ++i) {
+			if (!specifierIncluded(current, specifiers[i])) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	function versionIncluded(nodeVersion, specifierValue) {
+		if (typeof specifierValue === 'boolean') {
+			return specifierValue;
+		}
+
+		var current = typeof nodeVersion === 'undefined'
+			? process.versions && process.versions.node
+			: nodeVersion;
+
+		if (typeof current !== 'string') {
+			throw new TypeError(typeof nodeVersion === 'undefined' ? 'Unable to determine current node version' : 'If provided, a valid node version is required');
+		}
+
+		if (specifierValue && typeof specifierValue === 'object') {
+			for (var i = 0; i < specifierValue.length; ++i) {
+				if (matchesRange(current, specifierValue[i])) {
+					return true;
+				}
+			}
+			return false;
+		}
+		return matchesRange(current, specifierValue);
+	}
+
+	var data = require$$1$1;
+
+	isCoreModule = function isCore(x, nodeVersion) {
+		return hasOwn(data, x) && versionIncluded(nodeVersion, data[x]);
+	};
+	return isCoreModule;
+}
+
+var async;
+var hasRequiredAsync;
+
+function requireAsync () {
+	if (hasRequiredAsync) return async;
+	hasRequiredAsync = 1;
+	var fs = fs__default__default;
+	var getHomedir = requireHomedir();
+	var path = path__default;
+	var caller = requireCaller();
+	var nodeModulesPaths = requireNodeModulesPaths();
+	var normalizeOptions = requireNormalizeOptions();
+	var isCore = /*@__PURE__*/ requireIsCoreModule();
+
+	var realpathFS = process.platform !== 'win32' && fs.realpath && typeof fs.realpath.native === 'function' ? fs.realpath.native : fs.realpath;
+
+	var relativePathRegex = /^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/;
+	var windowsDriveRegex = /^\w:[/\\]*$/;
+	var nodeModulesRegex = /[/\\]node_modules[/\\]*$/;
+
+	var homedir = getHomedir();
+	var defaultPaths = function () {
+	    return [
+	        path.join(homedir, '.node_modules'),
+	        path.join(homedir, '.node_libraries')
+	    ];
+	};
+
+	var defaultIsFile = function isFile(file, cb) {
+	    fs.stat(file, function (err, stat) {
+	        if (!err) {
+	            return cb(null, stat.isFile() || stat.isFIFO());
+	        }
+	        if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
+	        return cb(err);
+	    });
+	};
+
+	var defaultIsDir = function isDirectory(dir, cb) {
+	    fs.stat(dir, function (err, stat) {
+	        if (!err) {
+	            return cb(null, stat.isDirectory());
+	        }
+	        if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
+	        return cb(err);
+	    });
+	};
+
+	var defaultRealpath = function realpath(x, cb) {
+	    realpathFS(x, function (realpathErr, realPath) {
+	        if (realpathErr && realpathErr.code !== 'ENOENT') cb(realpathErr);
+	        else cb(null, realpathErr ? x : realPath);
+	    });
+	};
+
+	var maybeRealpath = function maybeRealpath(realpath, x, opts, cb) {
+	    if (opts && opts.preserveSymlinks === false) {
+	        realpath(x, cb);
+	    } else {
+	        cb(null, x);
+	    }
+	};
+
+	var defaultReadPackage = function defaultReadPackage(readFile, pkgfile, cb) {
+	    readFile(pkgfile, function (readFileErr, body) {
+	        if (readFileErr) cb(readFileErr);
+	        else {
+	            try {
+	                var pkg = JSON.parse(body);
+	                cb(null, pkg);
+	            } catch (jsonErr) {
+	                cb(null);
+	            }
+	        }
+	    });
+	};
+
+	var getPackageCandidates = function getPackageCandidates(x, start, opts) {
+	    var dirs = nodeModulesPaths(start, opts, x);
+	    for (var i = 0; i < dirs.length; i++) {
+	        dirs[i] = path.join(dirs[i], x);
+	    }
+	    return dirs;
+	};
+
+	async = function resolve(x, options, callback) {
+	    var cb = callback;
+	    var opts = options;
+	    if (typeof options === 'function') {
+	        cb = opts;
+	        opts = {};
+	    }
+	    if (typeof x !== 'string') {
+	        var err = new TypeError('Path must be a string.');
+	        return process.nextTick(function () {
+	            cb(err);
+	        });
+	    }
+
+	    opts = normalizeOptions(x, opts);
+
+	    var isFile = opts.isFile || defaultIsFile;
+	    var isDirectory = opts.isDirectory || defaultIsDir;
+	    var readFile = opts.readFile || fs.readFile;
+	    var realpath = opts.realpath || defaultRealpath;
+	    var readPackage = opts.readPackage || defaultReadPackage;
+	    if (opts.readFile && opts.readPackage) {
+	        var conflictErr = new TypeError('`readFile` and `readPackage` are mutually exclusive.');
+	        return process.nextTick(function () {
+	            cb(conflictErr);
+	        });
+	    }
+	    var packageIterator = opts.packageIterator;
+
+	    var extensions = opts.extensions || ['.js'];
+	    var includeCoreModules = opts.includeCoreModules !== false;
+	    var basedir = opts.basedir || path.dirname(caller());
+	    var parent = opts.filename || basedir;
+
+	    opts.paths = opts.paths || defaultPaths();
+
+	    var absoluteStart = path.resolve(basedir);
+
+	    maybeRealpath(
+	        realpath,
+	        absoluteStart,
+	        opts,
+	        function (err, realStart) {
+	            if (err) cb(err);
+	            else init(realStart);
+	        }
+	    );
+
+	    var res;
+	    function init(basedir) {
+	        if (relativePathRegex.test(x)) {
+	            res = path.resolve(basedir, x);
+	            if (x === '.' || x === '..' || x.slice(-1) === '/') res += '/';
+	            if (x.slice(-1) === '/' && res === basedir) {
+	                loadAsDirectory(res, opts.package, onfile);
+	            } else loadAsFile(res, opts.package, onfile);
+	        } else if (includeCoreModules && isCore(x)) {
+	            return cb(null, x);
+	        } else loadNodeModules(x, basedir, function (err, n, pkg) {
+	            if (err) cb(err);
+	            else if (n) {
+	                return maybeRealpath(realpath, n, opts, function (err, realN) {
+	                    if (err) {
+	                        cb(err);
+	                    } else {
+	                        cb(null, realN, pkg);
+	                    }
+	                });
+	            } else {
+	                var moduleError = new Error("Cannot find module '" + x + "' from '" + parent + "'");
+	                moduleError.code = 'MODULE_NOT_FOUND';
+	                cb(moduleError);
+	            }
+	        });
+	    }
+
+	    function onfile(err, m, pkg) {
+	        if (err) cb(err);
+	        else if (m) cb(null, m, pkg);
+	        else loadAsDirectory(res, function (err, d, pkg) {
+	            if (err) cb(err);
+	            else if (d) {
+	                maybeRealpath(realpath, d, opts, function (err, realD) {
+	                    if (err) {
+	                        cb(err);
+	                    } else {
+	                        cb(null, realD, pkg);
+	                    }
+	                });
+	            } else {
+	                var moduleError = new Error("Cannot find module '" + x + "' from '" + parent + "'");
+	                moduleError.code = 'MODULE_NOT_FOUND';
+	                cb(moduleError);
+	            }
+	        });
+	    }
+
+	    function loadAsFile(x, thePackage, callback) {
+	        var loadAsFilePackage = thePackage;
+	        var cb = callback;
+	        if (typeof loadAsFilePackage === 'function') {
+	            cb = loadAsFilePackage;
+	            loadAsFilePackage = undefined;
+	        }
+
+	        var exts = [''].concat(extensions);
+	        load(exts, x, loadAsFilePackage);
+
+	        function load(exts, x, loadPackage) {
+	            if (exts.length === 0) return cb(null, undefined, loadPackage);
+	            var file = x + exts[0];
+
+	            var pkg = loadPackage;
+	            if (pkg) onpkg(null, pkg);
+	            else loadpkg(path.dirname(file), onpkg);
+
+	            function onpkg(err, pkg_, dir) {
+	                pkg = pkg_;
+	                if (err) return cb(err);
+	                if (dir && pkg && opts.pathFilter) {
+	                    var rfile = path.relative(dir, file);
+	                    var rel = rfile.slice(0, rfile.length - exts[0].length);
+	                    var r = opts.pathFilter(pkg, x, rel);
+	                    if (r) return load(
+	                        [''].concat(extensions.slice()),
+	                        path.resolve(dir, r),
+	                        pkg
+	                    );
+	                }
+	                isFile(file, onex);
+	            }
+	            function onex(err, ex) {
+	                if (err) return cb(err);
+	                if (ex) return cb(null, file, pkg);
+	                load(exts.slice(1), x, pkg);
+	            }
+	        }
+	    }
+
+	    function loadpkg(dir, cb) {
+	        if (dir === '' || dir === '/') return cb(null);
+	        if (process.platform === 'win32' && windowsDriveRegex.test(dir)) {
+	            return cb(null);
+	        }
+	        if (nodeModulesRegex.test(dir)) return cb(null);
+
+	        maybeRealpath(realpath, dir, opts, function (unwrapErr, pkgdir) {
+	            if (unwrapErr) return loadpkg(path.dirname(dir), cb);
+	            var pkgfile = path.join(pkgdir, 'package.json');
+	            isFile(pkgfile, function (err, ex) {
+	                if (!ex) return loadpkg(path.dirname(dir), cb);
+
+	                readPackage(readFile, pkgfile, function (err, pkgParam) {
+	                    if (err) cb(err);
+
+	                    var pkg = pkgParam;
+
+	                    if (pkg && opts.packageFilter) {
+	                        pkg = opts.packageFilter(pkg, pkgfile);
+	                    }
+	                    cb(null, pkg, dir);
+	                });
+	            });
+	        });
+	    }
+
+	    function loadAsDirectory(x, loadAsDirectoryPackage, callback) {
+	        var cb = callback;
+	        var fpkg = loadAsDirectoryPackage;
+	        if (typeof fpkg === 'function') {
+	            cb = fpkg;
+	            fpkg = opts.package;
+	        }
+
+	        maybeRealpath(realpath, x, opts, function (unwrapErr, pkgdir) {
+	            if (unwrapErr) return cb(unwrapErr);
+	            var pkgfile = path.join(pkgdir, 'package.json');
+	            isFile(pkgfile, function (err, ex) {
+	                if (err) return cb(err);
+	                if (!ex) return loadAsFile(path.join(x, 'index'), fpkg, cb);
+
+	                readPackage(readFile, pkgfile, function (err, pkgParam) {
+	                    if (err) return cb(err);
+
+	                    var pkg = pkgParam;
+
+	                    if (pkg && opts.packageFilter) {
+	                        pkg = opts.packageFilter(pkg, pkgfile);
+	                    }
+
+	                    if (pkg && pkg.main) {
+	                        if (typeof pkg.main !== 'string') {
+	                            var mainError = new TypeError('package “' + pkg.name + '” `main` must be a string');
+	                            mainError.code = 'INVALID_PACKAGE_MAIN';
+	                            return cb(mainError);
+	                        }
+	                        if (pkg.main === '.' || pkg.main === './') {
+	                            pkg.main = 'index';
+	                        }
+	                        loadAsFile(path.resolve(x, pkg.main), pkg, function (err, m, pkg) {
+	                            if (err) return cb(err);
+	                            if (m) return cb(null, m, pkg);
+	                            if (!pkg) return loadAsFile(path.join(x, 'index'), pkg, cb);
+
+	                            var dir = path.resolve(x, pkg.main);
+	                            loadAsDirectory(dir, pkg, function (err, n, pkg) {
+	                                if (err) return cb(err);
+	                                if (n) return cb(null, n, pkg);
+	                                loadAsFile(path.join(x, 'index'), pkg, cb);
+	                            });
+	                        });
+	                        return;
+	                    }
+
+	                    loadAsFile(path.join(x, '/index'), pkg, cb);
+	                });
+	            });
+	        });
+	    }
+
+	    function processDirs(cb, dirs) {
+	        if (dirs.length === 0) return cb(null, undefined);
+	        var dir = dirs[0];
+
+	        isDirectory(path.dirname(dir), isdir);
+
+	        function isdir(err, isdir) {
+	            if (err) return cb(err);
+	            if (!isdir) return processDirs(cb, dirs.slice(1));
+	            loadAsFile(dir, opts.package, onfile);
+	        }
+
+	        function onfile(err, m, pkg) {
+	            if (err) return cb(err);
+	            if (m) return cb(null, m, pkg);
+	            loadAsDirectory(dir, opts.package, ondir);
+	        }
+
+	        function ondir(err, n, pkg) {
+	            if (err) return cb(err);
+	            if (n) return cb(null, n, pkg);
+	            processDirs(cb, dirs.slice(1));
+	        }
+	    }
+	    function loadNodeModules(x, start, cb) {
+	        var thunk = function () { return getPackageCandidates(x, start, opts); };
+	        processDirs(
+	            cb,
+	            packageIterator ? packageIterator(x, start, thunk, opts) : thunk()
+	        );
+	    }
+	};
+	return async;
+}
+
+var assert = true;
+var async_hooks = ">= 8";
+var buffer_ieee754 = ">= 0.5 && < 0.9.7";
+var buffer = true;
+var child_process = true;
+var cluster = ">= 0.5";
+var console = true;
+var constants = true;
+var crypto = true;
+var _debug_agent = ">= 1 && < 8";
+var _debugger = "< 8";
+var dgram = true;
+var diagnostics_channel = [
+	">= 14.17 && < 15",
+	">= 15.1"
+];
+var dns = true;
+var domain = ">= 0.7.12";
+var events = true;
+var freelist = "< 6";
+var fs = true;
+var _http_agent = ">= 0.11.1";
+var _http_client = ">= 0.11.1";
+var _http_common = ">= 0.11.1";
+var _http_incoming = ">= 0.11.1";
+var _http_outgoing = ">= 0.11.1";
+var _http_server = ">= 0.11.1";
+var http = true;
+var http2 = ">= 8.8";
+var https = true;
+var inspector = ">= 8";
+var _linklist = "< 8";
+var module$1 = true;
+var net = true;
+var os = true;
+var path = true;
+var perf_hooks = ">= 8.5";
+var process$1 = ">= 1";
+var punycode = ">= 0.5";
+var querystring = true;
+var readline = true;
+var repl = true;
+var smalloc = ">= 0.11.5 && < 3";
+var _stream_duplex = ">= 0.9.4";
+var _stream_transform = ">= 0.9.4";
+var _stream_wrap = ">= 1.4.1";
+var _stream_passthrough = ">= 0.9.4";
+var _stream_readable = ">= 0.9.4";
+var _stream_writable = ">= 0.9.4";
+var stream = true;
+var string_decoder = true;
+var sys = [
+	">= 0.4 && < 0.7",
+	">= 0.8"
+];
+var timers = true;
+var _tls_common = ">= 0.11.13";
+var _tls_legacy = ">= 0.11.3 && < 10";
+var _tls_wrap = ">= 0.11.3";
+var tls = true;
+var trace_events = ">= 10";
+var tty = true;
+var url = true;
+var util = true;
+var v8 = ">= 1";
+var vm = true;
+var wasi = [
+	">= 13.4 && < 13.5",
+	">= 18.17 && < 19",
+	">= 20"
+];
+var worker_threads = ">= 11.7";
+var zlib = ">= 0.5";
+const require$$1 = {
+	assert: assert,
+	"node:assert": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"assert/strict": ">= 15",
+	"node:assert/strict": ">= 16",
+	async_hooks: async_hooks,
+	"node:async_hooks": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	buffer_ieee754: buffer_ieee754,
+	buffer: buffer,
+	"node:buffer": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	child_process: child_process,
+	"node:child_process": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	cluster: cluster,
+	"node:cluster": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	console: console,
+	"node:console": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	constants: constants,
+	"node:constants": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	crypto: crypto,
+	"node:crypto": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_debug_agent: _debug_agent,
+	_debugger: _debugger,
+	dgram: dgram,
+	"node:dgram": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	diagnostics_channel: diagnostics_channel,
+	"node:diagnostics_channel": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	dns: dns,
+	"node:dns": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"dns/promises": ">= 15",
+	"node:dns/promises": ">= 16",
+	domain: domain,
+	"node:domain": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	events: events,
+	"node:events": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	freelist: freelist,
+	fs: fs,
+	"node:fs": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"fs/promises": [
+	">= 10 && < 10.1",
+	">= 14"
+],
+	"node:fs/promises": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_http_agent: _http_agent,
+	"node:_http_agent": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_http_client: _http_client,
+	"node:_http_client": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_http_common: _http_common,
+	"node:_http_common": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_http_incoming: _http_incoming,
+	"node:_http_incoming": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_http_outgoing: _http_outgoing,
+	"node:_http_outgoing": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_http_server: _http_server,
+	"node:_http_server": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	http: http,
+	"node:http": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	http2: http2,
+	"node:http2": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	https: https,
+	"node:https": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	inspector: inspector,
+	"node:inspector": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"inspector/promises": [
+	">= 19"
+],
+	"node:inspector/promises": [
+	">= 19"
+],
+	_linklist: _linklist,
+	module: module$1,
+	"node:module": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	net: net,
+	"node:net": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"node-inspect/lib/_inspect": ">= 7.6 && < 12",
+	"node-inspect/lib/internal/inspect_client": ">= 7.6 && < 12",
+	"node-inspect/lib/internal/inspect_repl": ">= 7.6 && < 12",
+	os: os,
+	"node:os": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	path: path,
+	"node:path": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"path/posix": ">= 15.3",
+	"node:path/posix": ">= 16",
+	"path/win32": ">= 15.3",
+	"node:path/win32": ">= 16",
+	perf_hooks: perf_hooks,
+	"node:perf_hooks": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	process: process$1,
+	"node:process": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	punycode: punycode,
+	"node:punycode": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	querystring: querystring,
+	"node:querystring": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	readline: readline,
+	"node:readline": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"readline/promises": ">= 17",
+	"node:readline/promises": ">= 17",
+	repl: repl,
+	"node:repl": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"node:sea": [
+	">= 20.12 && < 21",
+	">= 21.7"
+],
+	smalloc: smalloc,
+	"node:sqlite": [
+	">= 22.13 && < 23",
+	">= 23.4"
+],
+	_stream_duplex: _stream_duplex,
+	"node:_stream_duplex": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_stream_transform: _stream_transform,
+	"node:_stream_transform": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_stream_wrap: _stream_wrap,
+	"node:_stream_wrap": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_stream_passthrough: _stream_passthrough,
+	"node:_stream_passthrough": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_stream_readable: _stream_readable,
+	"node:_stream_readable": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_stream_writable: _stream_writable,
+	"node:_stream_writable": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	stream: stream,
+	"node:stream": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"stream/consumers": ">= 16.7",
+	"node:stream/consumers": ">= 16.7",
+	"stream/promises": ">= 15",
+	"node:stream/promises": ">= 16",
+	"stream/web": ">= 16.5",
+	"node:stream/web": ">= 16.5",
+	string_decoder: string_decoder,
+	"node:string_decoder": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	sys: sys,
+	"node:sys": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"test/reporters": ">= 19.9 && < 20.2",
+	"node:test/reporters": [
+	">= 18.17 && < 19",
+	">= 19.9",
+	">= 20"
+],
+	"test/mock_loader": ">= 22.3 && < 22.7",
+	"node:test/mock_loader": ">= 22.3 && < 22.7",
+	"node:test": [
+	">= 16.17 && < 17",
+	">= 18"
+],
+	timers: timers,
+	"node:timers": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"timers/promises": ">= 15",
+	"node:timers/promises": ">= 16",
+	_tls_common: _tls_common,
+	"node:_tls_common": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_tls_legacy: _tls_legacy,
+	_tls_wrap: _tls_wrap,
+	"node:_tls_wrap": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	tls: tls,
+	"node:tls": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	trace_events: trace_events,
+	"node:trace_events": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	tty: tty,
+	"node:tty": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	url: url,
+	"node:url": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	util: util,
+	"node:util": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"util/types": ">= 15.3",
+	"node:util/types": ">= 16",
+	"v8/tools/arguments": ">= 10 && < 12",
+	"v8/tools/codemap": [
+	">= 4.4 && < 5",
+	">= 5.2 && < 12"
+],
+	"v8/tools/consarray": [
+	">= 4.4 && < 5",
+	">= 5.2 && < 12"
+],
+	"v8/tools/csvparser": [
+	">= 4.4 && < 5",
+	">= 5.2 && < 12"
+],
+	"v8/tools/logreader": [
+	">= 4.4 && < 5",
+	">= 5.2 && < 12"
+],
+	"v8/tools/profile_view": [
+	">= 4.4 && < 5",
+	">= 5.2 && < 12"
+],
+	"v8/tools/splaytree": [
+	">= 4.4 && < 5",
+	">= 5.2 && < 12"
+],
+	v8: v8,
+	"node:v8": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	vm: vm,
+	"node:vm": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	wasi: wasi,
+	"node:wasi": [
+	">= 18.17 && < 19",
+	">= 20"
+],
+	worker_threads: worker_threads,
+	"node:worker_threads": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	zlib: zlib,
+	"node:zlib": [
+	">= 14.18 && < 15",
+	">= 16"
+]
+};
+
+var core_1;
+var hasRequiredCore;
+
+function requireCore () {
+	if (hasRequiredCore) return core_1;
+	hasRequiredCore = 1;
+
+	var isCoreModule = /*@__PURE__*/ requireIsCoreModule();
+	var data = require$$1;
+
+	var core = {};
+	for (var mod in data) { 
+	    if (Object.prototype.hasOwnProperty.call(data, mod)) {
+	        core[mod] = isCoreModule(mod);
+	    }
+	}
+	core_1 = core;
+	return core_1;
+}
+
+var isCore;
+var hasRequiredIsCore;
+
+function requireIsCore () {
+	if (hasRequiredIsCore) return isCore;
+	hasRequiredIsCore = 1;
+	var isCoreModule = /*@__PURE__*/ requireIsCoreModule();
+
+	isCore = function isCore(x) {
+	    return isCoreModule(x);
+	};
+	return isCore;
+}
+
+var sync;
+var hasRequiredSync;
+
+function requireSync () {
+	if (hasRequiredSync) return sync;
+	hasRequiredSync = 1;
+	var isCore = /*@__PURE__*/ requireIsCoreModule();
+	var fs = fs__default__default;
+	var path = path__default;
+	var getHomedir = requireHomedir();
+	var caller = requireCaller();
+	var nodeModulesPaths = requireNodeModulesPaths();
+	var normalizeOptions = requireNormalizeOptions();
+
+	var realpathFS = process.platform !== 'win32' && fs.realpathSync && typeof fs.realpathSync.native === 'function' ? fs.realpathSync.native : fs.realpathSync;
+
+	var relativePathRegex = /^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/;
+	var windowsDriveRegex = /^\w:[/\\]*$/;
+	var nodeModulesRegex = /[/\\]node_modules[/\\]*$/;
+
+	var homedir = getHomedir();
+	var defaultPaths = function () {
+	    return [
+	        path.join(homedir, '.node_modules'),
+	        path.join(homedir, '.node_libraries')
+	    ];
+	};
+
+	var defaultIsFile = function isFile(file) {
+	    try {
+	        var stat = fs.statSync(file, { throwIfNoEntry: false });
+	    } catch (e) {
+	        if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
+	        throw e;
+	    }
+	    return !!stat && (stat.isFile() || stat.isFIFO());
+	};
+
+	var defaultIsDir = function isDirectory(dir) {
+	    try {
+	        var stat = fs.statSync(dir, { throwIfNoEntry: false });
+	    } catch (e) {
+	        if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
+	        throw e;
+	    }
+	    return !!stat && stat.isDirectory();
+	};
+
+	var defaultRealpathSync = function realpathSync(x) {
+	    try {
+	        return realpathFS(x);
+	    } catch (realpathErr) {
+	        if (realpathErr.code !== 'ENOENT') {
+	            throw realpathErr;
+	        }
+	    }
+	    return x;
+	};
+
+	var maybeRealpathSync = function maybeRealpathSync(realpathSync, x, opts) {
+	    if (opts && opts.preserveSymlinks === false) {
+	        return realpathSync(x);
+	    }
+	    return x;
+	};
+
+	var defaultReadPackageSync = function defaultReadPackageSync(readFileSync, pkgfile) {
+	    var body = readFileSync(pkgfile);
+	    try {
+	        var pkg = JSON.parse(body);
+	        return pkg;
+	    } catch (jsonErr) {}
+	};
+
+	var getPackageCandidates = function getPackageCandidates(x, start, opts) {
+	    var dirs = nodeModulesPaths(start, opts, x);
+	    for (var i = 0; i < dirs.length; i++) {
+	        dirs[i] = path.join(dirs[i], x);
+	    }
+	    return dirs;
+	};
+
+	sync = function resolveSync(x, options) {
+	    if (typeof x !== 'string') {
+	        throw new TypeError('Path must be a string.');
+	    }
+	    var opts = normalizeOptions(x, options);
+
+	    var isFile = opts.isFile || defaultIsFile;
+	    var readFileSync = opts.readFileSync || fs.readFileSync;
+	    var isDirectory = opts.isDirectory || defaultIsDir;
+	    var realpathSync = opts.realpathSync || defaultRealpathSync;
+	    var readPackageSync = opts.readPackageSync || defaultReadPackageSync;
+	    if (opts.readFileSync && opts.readPackageSync) {
+	        throw new TypeError('`readFileSync` and `readPackageSync` are mutually exclusive.');
+	    }
+	    var packageIterator = opts.packageIterator;
+
+	    var extensions = opts.extensions || ['.js'];
+	    var includeCoreModules = opts.includeCoreModules !== false;
+	    var basedir = opts.basedir || path.dirname(caller());
+	    var parent = opts.filename || basedir;
+
+	    opts.paths = opts.paths || defaultPaths();
+
+	    var absoluteStart = maybeRealpathSync(realpathSync, path.resolve(basedir), opts);
+
+	    if (relativePathRegex.test(x)) {
+	        var res = path.resolve(absoluteStart, x);
+	        if (x === '.' || x === '..' || x.slice(-1) === '/') res += '/';
+	        var m = loadAsFileSync(res) || loadAsDirectorySync(res);
+	        if (m) return maybeRealpathSync(realpathSync, m, opts);
+	    } else if (includeCoreModules && isCore(x)) {
+	        return x;
+	    } else {
+	        var n = loadNodeModulesSync(x, absoluteStart);
+	        if (n) return maybeRealpathSync(realpathSync, n, opts);
+	    }
+
+	    var err = new Error("Cannot find module '" + x + "' from '" + parent + "'");
+	    err.code = 'MODULE_NOT_FOUND';
+	    throw err;
+
+	    function loadAsFileSync(x) {
+	        var pkg = loadpkg(path.dirname(x));
+
+	        if (pkg && pkg.dir && pkg.pkg && opts.pathFilter) {
+	            var rfile = path.relative(pkg.dir, x);
+	            var r = opts.pathFilter(pkg.pkg, x, rfile);
+	            if (r) {
+	                x = path.resolve(pkg.dir, r); 
+	            }
+	        }
+
+	        if (isFile(x)) {
+	            return x;
+	        }
+
+	        for (var i = 0; i < extensions.length; i++) {
+	            var file = x + extensions[i];
+	            if (isFile(file)) {
+	                return file;
+	            }
+	        }
+	    }
+
+	    function loadpkg(dir) {
+	        if (dir === '' || dir === '/') return;
+	        if (process.platform === 'win32' && windowsDriveRegex.test(dir)) {
+	            return;
+	        }
+	        if (nodeModulesRegex.test(dir)) return;
+
+	        var pkgfile = path.join(maybeRealpathSync(realpathSync, dir, opts), 'package.json');
+
+	        if (!isFile(pkgfile)) {
+	            return loadpkg(path.dirname(dir));
+	        }
+
+	        var pkg = readPackageSync(readFileSync, pkgfile);
+
+	        if (pkg && opts.packageFilter) {
+	            pkg = opts.packageFilter(pkg,  dir); 
+	        }
+
+	        return { pkg: pkg, dir: dir };
+	    }
+
+	    function loadAsDirectorySync(x) {
+	        var pkgfile = path.join(maybeRealpathSync(realpathSync, x, opts), '/package.json');
+	        if (isFile(pkgfile)) {
+	            try {
+	                var pkg = readPackageSync(readFileSync, pkgfile);
+	            } catch (e) {}
+
+	            if (pkg && opts.packageFilter) {
+	                pkg = opts.packageFilter(pkg,  x); 
+	            }
+
+	            if (pkg && pkg.main) {
+	                if (typeof pkg.main !== 'string') {
+	                    var mainError = new TypeError('package “' + pkg.name + '” `main` must be a string');
+	                    mainError.code = 'INVALID_PACKAGE_MAIN';
+	                    throw mainError;
+	                }
+	                if (pkg.main === '.' || pkg.main === './') {
+	                    pkg.main = 'index';
+	                }
+	                try {
+	                    var m = loadAsFileSync(path.resolve(x, pkg.main));
+	                    if (m) return m;
+	                    var n = loadAsDirectorySync(path.resolve(x, pkg.main));
+	                    if (n) return n;
+	                } catch (e) {}
+	            }
+	        }
+
+	        return loadAsFileSync(path.join(x, '/index'));
+	    }
+
+	    function loadNodeModulesSync(x, start) {
+	        var thunk = function () { return getPackageCandidates(x, start, opts); };
+	        var dirs = packageIterator ? packageIterator(x, start, thunk, opts) : thunk();
+
+	        for (var i = 0; i < dirs.length; i++) {
+	            var dir = dirs[i];
+	            if (isDirectory(path.dirname(dir))) {
+	                var m = loadAsFileSync(dir);
+	                if (m) return m;
+	                var n = loadAsDirectorySync(dir);
+	                if (n) return n;
+	            }
+	        }
+	    }
+	};
+	return sync;
+}
+
+var resolve$1;
+var hasRequiredResolve;
+
+function requireResolve () {
+	if (hasRequiredResolve) return resolve$1;
+	hasRequiredResolve = 1;
+	var async = requireAsync();
+	async.core = requireCore();
+	async.isCore = requireIsCore();
+	async.sync = requireSync();
+
+	resolve$1 = async;
+	return resolve$1;
+}
+
+var resolveExports = requireResolve();
+const resolve = /*@__PURE__*/getDefaultExportFromCjs(resolveExports);
+
+function createFormattingHost(ts, compilerOptions) {
+    return {
+        getCompilationSettings: () => compilerOptions,
+        getCurrentDirectory: () => process.cwd(),
+        getNewLine() {
+            switch (compilerOptions.newLine) {
+                case ts.NewLineKind.CarriageReturnLineFeed:
+                    return '\r\n';
+                case ts.NewLineKind.LineFeed:
+                    return '\n';
+                default:
+                    return ts.sys.newLine;
+            }
+        },
+        getCanonicalFileName: (fileName) => ts.sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase()
+    };
+}
+
+function createModuleResolver(ts, host, filter) {
+    const compilerOptions = host.getCompilationSettings();
+    const cache = ts.createModuleResolutionCache(process.cwd(), host.getCanonicalFileName, compilerOptions);
+    const moduleHost = { ...ts.sys, ...host };
+    return (moduleName, containingFile, redirectedReference, mode) => {
+        const { resolvedModule } = ts.resolveModuleName(moduleName, containingFile, compilerOptions, moduleHost, cache, redirectedReference, mode);
+        if ((resolvedModule === null || resolvedModule === void 0 ? void 0 : resolvedModule.isExternalLibraryImport) && filter(resolvedModule === null || resolvedModule === void 0 ? void 0 : resolvedModule.resolvedFileName)) {
+            resolvedModule.isExternalLibraryImport = false;
+        }
+        return resolvedModule;
+    };
+}
+
+const resolveId = (file, opts) => resolve.sync(file, opts);
+const getTsLibPath = () => {
+    try {
+        return resolveId(process.env.__TSLIB_TEST_PATH__ || 'tslib/tslib.es6.js', {
+            basedir: fileURLToPath(new URL('.', import.meta.url))
+        });
+    }
+    catch (_) {
+        return null;
+    }
+};
+
+const getPluginOptions = (options) => {
+    const { cacheDir, exclude, include, filterRoot, noForceEmit, transformers, recreateTransformersOnRebuild, tsconfig, tslib, typescript, outputToFilesystem, compilerOptions, 
+    ...extra } = options;
+    return {
+        cacheDir,
+        include,
+        exclude,
+        filterRoot,
+        noForceEmit: noForceEmit || false,
+        tsconfig,
+        compilerOptions: { ...extra, ...compilerOptions },
+        typescript: typescript || typescript$1,
+        tslib: tslib || getTsLibPath(),
+        transformers,
+        recreateTransformersOnRebuild: recreateTransformersOnRebuild === true,
+        outputToFilesystem
+    };
+};
+
+function diagnosticToWarning(ts, host, diagnostic) {
+    const pluginCode = `TS${diagnostic.code}`;
+    const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+    const warning = {
+        pluginCode,
+        message: `@rollup/plugin-typescript ${pluginCode}: ${message}`
+    };
+    if (diagnostic.file) {
+        const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+        warning.loc = {
+            column: character + 1,
+            line: line + 1,
+            file: diagnostic.file.fileName
+        };
+        if (host) {
+            const formatted = ts.formatDiagnosticsWithColorAndContext([diagnostic], host);
+            let frame = formatted.slice(formatted.indexOf(message) + message.length);
+            const newLine = host.getNewLine();
+            if (frame.startsWith(newLine)) {
+                frame = frame.slice(frame.indexOf(newLine) + newLine.length);
+            }
+            warning.frame = frame;
+        }
+    }
+    return warning;
+}
+
+const DEFAULT_COMPILER_OPTIONS = {
+    module: 'esnext',
+    skipLibCheck: true
+};
+const OVERRIDABLE_EMIT_COMPILER_OPTIONS = {
+    noEmit: false,
+    emitDeclarationOnly: false
+};
+const FORCED_COMPILER_OPTIONS = {
+    noEmitHelpers: true,
+    importHelpers: true,
+    noResolve: false
+};
+
+const DIRECTORY_PROPS = ['outDir', 'declarationDir'];
+function makePathsAbsolute(compilerOptions, relativeTo) {
+    for (const pathProp of DIRECTORY_PROPS) {
+        if (compilerOptions[pathProp]) {
+            compilerOptions[pathProp] = resolve$2(relativeTo, compilerOptions[pathProp]);
+        }
+    }
+}
+function normalizeCompilerOptions(ts, compilerOptions) {
+    let autoSetSourceMap = false;
+    if (compilerOptions.inlineSourceMap) {
+        compilerOptions.sourceMap = true;
+        compilerOptions.inlineSourceMap = false;
+    }
+    else if (typeof compilerOptions.sourceMap !== 'boolean') {
+        compilerOptions.sourceMap = true;
+        compilerOptions.inlineSources = true;
+        autoSetSourceMap = true;
+    }
+    switch (compilerOptions.module) {
+        case ts.ModuleKind.ES2015:
+        case ts.ModuleKind.ESNext:
+        case ts.ModuleKind.Node16:
+        case ts.ModuleKind.NodeNext:
+        case ts.ModuleKind.CommonJS:
+            return autoSetSourceMap;
+        case ts.ModuleKind.None:
+        case ts.ModuleKind.AMD:
+        case ts.ModuleKind.UMD:
+        case ts.ModuleKind.System: {
+            const moduleType = ts.ModuleKind[compilerOptions.module];
+            throw new Error(`@rollup/plugin-typescript: The module kind should be 'ES2015', 'ESNext', 'node16' or 'nodenext', found: '${moduleType}'`);
+        }
+        default:
+            compilerOptions.module = ts.ModuleKind.ESNext;
+    }
+    return autoSetSourceMap;
+}
+
+const { ModuleKind: ModuleKind$1, ModuleResolutionKind } = typescript$1;
+function makeForcedCompilerOptions(noForceEmit) {
+    return { ...FORCED_COMPILER_OPTIONS, ...(noForceEmit ? {} : OVERRIDABLE_EMIT_COMPILER_OPTIONS) };
+}
+function getTsConfigPath(ts, relativePath) {
+    if (relativePath === false)
+        return null;
+    const tsConfigPath = resolve$2(process.cwd(), relativePath || 'tsconfig.json');
+    if (!ts.sys.fileExists(tsConfigPath)) {
+        if (relativePath) {
+            throw new Error(`Could not find specified tsconfig.json at ${tsConfigPath}`);
+        }
+        else {
+            return null;
+        }
+    }
+    return tsConfigPath;
+}
+function readTsConfigFile(ts, tsConfigPath) {
+    const { config, error } = ts.readConfigFile(tsConfigPath, (path) => readFileSync(path, 'utf8'));
+    if (error) {
+        throw Object.assign(Error(), diagnosticToWarning(ts, null, error));
+    }
+    return config || {};
+}
+function containsEnumOptions(compilerOptions) {
+    const enums = [
+        'module',
+        'target',
+        'jsx',
+        'moduleResolution',
+        'newLine'
+    ];
+    return enums.some((prop) => prop in compilerOptions && typeof compilerOptions[prop] === 'number');
+}
+function setModuleResolutionKind(parsedConfig) {
+    const moduleKind = parsedConfig.options.module;
+    const moduleResolution = moduleKind === ModuleKind$1.Node16
+        ? ModuleResolutionKind.Node16
+        : moduleKind === ModuleKind$1.NodeNext
+            ? ModuleResolutionKind.NodeNext
+            : ModuleResolutionKind.NodeJs;
+    return {
+        ...parsedConfig,
+        options: {
+            moduleResolution,
+            ...parsedConfig.options
+        }
+    };
+}
+const configCache = new Map();
+function parseTypescriptConfig(ts, tsconfig, compilerOptions, noForceEmit) {
+    const cwd = process.cwd();
+    makePathsAbsolute(compilerOptions, cwd);
+    let parsedConfig;
+    const tsConfigPath = getTsConfigPath(ts, tsconfig) || undefined;
+    const tsConfigFile = tsConfigPath ? readTsConfigFile(ts, tsConfigPath) : {};
+    const basePath = tsConfigPath ? dirname(tsConfigPath) : cwd;
+    if (containsEnumOptions(compilerOptions)) {
+        parsedConfig = setModuleResolutionKind(ts.parseJsonConfigFileContent({
+            ...tsConfigFile,
+            compilerOptions: {
+                ...DEFAULT_COMPILER_OPTIONS,
+                ...tsConfigFile.compilerOptions
+            }
+        }, ts.sys, basePath, { ...compilerOptions, ...makeForcedCompilerOptions(noForceEmit) }, tsConfigPath, undefined, undefined, configCache));
+    }
+    else {
+        parsedConfig = setModuleResolutionKind(ts.parseJsonConfigFileContent({
+            ...tsConfigFile,
+            compilerOptions: {
+                ...DEFAULT_COMPILER_OPTIONS,
+                ...tsConfigFile.compilerOptions,
+                ...compilerOptions
+            }
+        }, ts.sys, basePath, makeForcedCompilerOptions(noForceEmit), tsConfigPath, undefined, undefined, configCache));
+    }
+    const autoSetSourceMap = normalizeCompilerOptions(ts, parsedConfig.options);
+    return {
+        ...parsedConfig,
+        autoSetSourceMap
+    };
+}
+function emitParsedOptionsErrors(ts, context, parsedOptions) {
+    if (parsedOptions.errors.length > 0) {
+        parsedOptions.errors.forEach((error) => context.warn(diagnosticToWarning(ts, null, error)));
+        context.error(`@rollup/plugin-typescript: Couldn't process compiler options`);
+    }
+}
+
+function validateSourceMap(context, compilerOptions, outputOptions, autoSetSourceMap) {
+    if (compilerOptions.sourceMap && !outputOptions.sourcemap && !autoSetSourceMap) {
+        context.warn(`@rollup/plugin-typescript: Rollup 'sourcemap' option must be set to generate source maps.`);
+    }
+    else if (!compilerOptions.sourceMap && outputOptions.sourcemap) {
+        context.warn(`@rollup/plugin-typescript: Typescript 'sourceMap' compiler option must be set to generate source maps.`);
+    }
+}
+function validatePaths(context, compilerOptions, outputOptions) {
+    if (compilerOptions.out) {
+        context.error(`@rollup/plugin-typescript: Deprecated Typescript compiler option 'out' is not supported. Use 'outDir' instead.`);
+    }
+    else if (compilerOptions.outFile) {
+        context.error(`@rollup/plugin-typescript: Typescript compiler option 'outFile' is not supported. Use 'outDir' instead.`);
+    }
+    let outputDir = outputOptions.dir;
+    if (outputOptions.file) {
+        outputDir = dirname(outputOptions.file);
+    }
+    for (const dirProperty of DIRECTORY_PROPS) {
+        if (compilerOptions[dirProperty] && outputDir) {
+            if (outputOptions.dir) {
+                const fromRollupDirToTs = relative(outputDir, compilerOptions[dirProperty]);
+                if (fromRollupDirToTs.startsWith('..')) {
+                    context.error(`@rollup/plugin-typescript: Path of Typescript compiler option '${dirProperty}' must be located inside Rollup 'dir' option.`);
+                }
+            }
+            else if (dirProperty === 'outDir') {
+                const fromTsDirToRollup = relative(compilerOptions[dirProperty], outputDir);
+                if (fromTsDirToRollup.startsWith('..')) {
+                    context.error(`@rollup/plugin-typescript: Path of Typescript compiler option '${dirProperty}' must be located inside the same directory as the Rollup 'file' option.`);
+                }
+            }
+            else {
+                const fromTsDirToRollup = relative(outputDir, compilerOptions[dirProperty]);
+                if (fromTsDirToRollup.startsWith('..')) {
+                    context.error(`@rollup/plugin-typescript: Path of Typescript compiler option '${dirProperty}' must be located inside the same directory as the Rollup 'file' option.`);
+                }
+            }
+        }
+    }
+    if (compilerOptions.declaration || compilerOptions.declarationMap || compilerOptions.composite) {
+        if (DIRECTORY_PROPS.every((dirProperty) => !compilerOptions[dirProperty])) {
+            context.error(`@rollup/plugin-typescript: You are using one of Typescript's compiler options 'declaration', 'declarationMap' or 'composite'. ` +
+                `In this case 'outDir' or 'declarationDir' must be specified to generate declaration files.`);
+        }
+    }
+}
+
+function isCodeOutputFile(name) {
+    return !isMapOutputFile(name) && !isDeclarationOutputFile(name);
+}
+function isMapOutputFile(name) {
+    return name.endsWith('.map');
+}
+function isTypeScriptMapOutputFile(name) {
+    return name.endsWith('ts.map');
+}
+function isDeclarationOutputFile(name) {
+    return /\.d\.[cm]?ts$/.test(name);
+}
+function getEmittedFile(fileName, emittedFiles, tsCache) {
+    let code;
+    if (fileName) {
+        if (emittedFiles.has(fileName)) {
+            code = emittedFiles.get(fileName);
+        }
+        else {
+            code = tsCache.getCached(fileName);
+        }
+    }
+    return code;
+}
+function findTypescriptOutput(ts, parsedOptions, id, emittedFiles, tsCache) {
+    const emittedFileNames = ts.getOutputFileNames(parsedOptions, id, !ts.sys.useCaseSensitiveFileNames);
+    const codeFile = emittedFileNames.find(isCodeOutputFile);
+    const mapFile = emittedFileNames.find(isMapOutputFile);
+    return {
+        code: getEmittedFile(codeFile, emittedFiles, tsCache),
+        map: getEmittedFile(mapFile, emittedFiles, tsCache),
+        declarations: emittedFileNames.filter((name) => name !== codeFile && name !== mapFile)
+    };
+}
+function normalizePath(fileName) {
+    return fileName.split(path$2.win32.sep).join(path$2.posix.sep);
+}
+async function emitFile({ dir }, outputToFilesystem, context, filePath, fileSource) {
+    const normalizedFilePath = normalizePath(filePath);
+    const relativePath = dir ? path$2.relative(dir, normalizedFilePath) : '..';
+    if (relativePath.startsWith('..')) {
+        if (outputToFilesystem == null) {
+            context.warn(`@rollup/plugin-typescript: outputToFilesystem option is defaulting to true.`);
+        }
+        if (outputToFilesystem !== false) {
+            await promises.mkdir(path$2.dirname(normalizedFilePath), { recursive: true });
+            await promises.writeFile(normalizedFilePath, fileSource);
+        }
+    }
+    else {
+        context.emitFile({
+            type: 'asset',
+            fileName: relativePath,
+            source: fileSource
+        });
+    }
+}
+
+const { ModuleKind } = typescript$1;
+const pluginName = '@rollup/plugin-typescript';
+const moduleErrorMessage = `
+${pluginName}: Rollup requires that TypeScript produces ES Modules. Unfortunately your configuration specifies a
+ "module" other than "esnext". Unless you know what you're doing, please change "module" to "esnext"
+ in the target tsconfig.json file or plugin options.`.replace(/\n/g, '');
+const tsLibErrorMessage = `${pluginName}: Could not find module 'tslib', which is required by this plugin. Is it installed?`;
+let undef;
+const validModules = [
+    ModuleKind.ES2015,
+    ModuleKind.ES2020,
+    ModuleKind.ESNext,
+    ModuleKind.Node16,
+    ModuleKind.NodeNext,
+    undef
+];
+const preflight = ({ config, context, inputPreserveModules, tslib }) => {
+    if (!validModules.includes(config.options.module)) {
+        context.warn(moduleErrorMessage);
+    }
+    if (!inputPreserveModules && tslib === null) {
+        context.error(tsLibErrorMessage);
+    }
+};
+
+const CANNOT_COMPILE_ESM = 1204;
+function emitDiagnostic(ts, context, host, diagnostic) {
+    if (diagnostic.code === CANNOT_COMPILE_ESM)
+        return;
+    const { noEmitOnError } = host.getCompilationSettings();
+    const warning = diagnosticToWarning(ts, host, diagnostic);
+    if (noEmitOnError && diagnostic.category === ts.DiagnosticCategory.Error) {
+        context.error(warning);
+    }
+    else {
+        context.warn(warning);
+    }
+}
+function buildDiagnosticReporter(ts, context, host) {
+    return function reportDiagnostics(diagnostic) {
+        emitDiagnostic(ts, context, host, diagnostic);
+    };
+}
+
+function mergeTransformers(builder, ...input) {
+    const transformerTypes = ['after', 'afterDeclarations', 'before'];
+    const accumulator = {
+        after: [],
+        afterDeclarations: [],
+        before: []
+    };
+    let program;
+    let typeChecker;
+    input.forEach((transformers) => {
+        if (!transformers) {
+            return;
+        }
+        transformerTypes.forEach((stage) => {
+            getTransformers(transformers[stage]).forEach((transformer) => {
+                if (!transformer) {
+                    return;
+                }
+                if ('type' in transformer) {
+                    if (typeof transformer.factory === 'function') {
+                        let factory;
+                        if (transformer.type === 'program') {
+                            const currentProgram = program !== null && program !== void 0 ? program : builder.getProgram();
+                            factory = transformer.factory(currentProgram, () => builder.getProgram());
+                            program = currentProgram;
+                        }
+                        else {
+                            const currentProgram = program !== null && program !== void 0 ? program : builder.getProgram();
+                            const currentTypeChecker = typeChecker !== null && typeChecker !== void 0 ? typeChecker : currentProgram.getTypeChecker();
+                            factory = transformer.factory(currentTypeChecker);
+                            program = currentProgram;
+                            typeChecker = currentTypeChecker;
+                        }
+                        if (factory) {
+                            accumulator[stage].push(factory);
+                        }
+                    }
+                }
+                else {
+                    accumulator[stage].push(transformer);
+                }
+            });
+        });
+    });
+    return accumulator;
+}
+function getTransformers(transformers) {
+    return transformers || [];
+}
+
+const { DiagnosticCategory } = typescript$1;
+var DiagnosticCode;
+(function (DiagnosticCode) {
+    DiagnosticCode[DiagnosticCode["FILE_CHANGE_DETECTED"] = 6032] = "FILE_CHANGE_DETECTED";
+    DiagnosticCode[DiagnosticCode["FOUND_1_ERROR_WATCHING_FOR_FILE_CHANGES"] = 6193] = "FOUND_1_ERROR_WATCHING_FOR_FILE_CHANGES";
+    DiagnosticCode[DiagnosticCode["FOUND_N_ERRORS_WATCHING_FOR_FILE_CHANGES"] = 6194] = "FOUND_N_ERRORS_WATCHING_FOR_FILE_CHANGES";
+})(DiagnosticCode || (DiagnosticCode = {}));
+function createDeferred(timeout) {
+    let promise;
+    let resolve = () => { };
+    if (timeout) {
+        promise = Promise.race([
+            new Promise((r) => setTimeout(r, timeout, true)),
+            new Promise((r) => (resolve = r))
+        ]);
+    }
+    else {
+        promise = new Promise((r) => (resolve = r));
+    }
+    return { promise, resolve };
+}
+class WatchProgramHelper {
+    constructor() {
+        this._startDeferred = null;
+        this._finishDeferred = null;
+    }
+    watch(timeout = 1000) {
+        this._startDeferred = createDeferred(timeout);
+        this._finishDeferred = createDeferred();
+    }
+    handleStatus(diagnostic) {
+        if (diagnostic.category === DiagnosticCategory.Message) {
+            switch (diagnostic.code) {
+                case DiagnosticCode.FILE_CHANGE_DETECTED:
+                    this.resolveStart();
+                    break;
+                case DiagnosticCode.FOUND_1_ERROR_WATCHING_FOR_FILE_CHANGES:
+                case DiagnosticCode.FOUND_N_ERRORS_WATCHING_FOR_FILE_CHANGES:
+                    this.resolveFinish();
+                    break;
+            }
+        }
+    }
+    resolveStart() {
+        if (this._startDeferred) {
+            this._startDeferred.resolve(false);
+            this._startDeferred = null;
+        }
+    }
+    resolveFinish() {
+        if (this._finishDeferred) {
+            this._finishDeferred.resolve(false);
+            this._finishDeferred = null;
+        }
+    }
+    async wait() {
+        var _a;
+        if (this._startDeferred) {
+            const timeout = await this._startDeferred.promise;
+            if (timeout) {
+                this._startDeferred = null;
+                this._finishDeferred = null;
+            }
+            await ((_a = this._finishDeferred) === null || _a === void 0 ? void 0 : _a.promise);
+        }
+    }
+}
+function createWatchHost(ts, context, { formatHost, parsedOptions, writeFile, status, resolveModule, transformers, recreateTransformersOnRebuild }) {
+    const createProgram = ts.createEmitAndSemanticDiagnosticsBuilderProgram;
+    const baseHost = ts.createWatchCompilerHost(parsedOptions.fileNames, parsedOptions.options, ts.sys, createProgram, buildDiagnosticReporter(ts, context, formatHost), status, parsedOptions.projectReferences);
+    let createdTransformers;
+    return {
+        ...baseHost,
+        afterProgramCreate(program) {
+            if (recreateTransformersOnRebuild) {
+                createdTransformers = void 0;
+            }
+            const origEmit = program.emit;
+            program.emit = (targetSourceFile, _, cancellationToken, emitOnlyDtsFiles, customTransformers) => {
+                createdTransformers !== null && createdTransformers !== void 0 ? createdTransformers : (createdTransformers = typeof transformers === 'function'
+                    ? transformers(program.getProgram())
+                    : mergeTransformers(program, transformers, customTransformers));
+                return origEmit(targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, createdTransformers);
+            };
+            return baseHost.afterProgramCreate(program);
+        },
+        resolveModuleNames(moduleNames, containingFile, _reusedNames, redirectedReference, _optionsOnlyWithNewerTsVersions, containingSourceFile) {
+            return moduleNames.map((moduleName, i) => {
+                var _a;
+                const mode = containingSourceFile
+                    ? (_a = ts.getModeForResolutionAtIndex) === null || _a === void 0 ? void 0 : _a.call(ts, containingSourceFile, i)
+                    : undefined; 
+                return resolveModule(moduleName, containingFile, redirectedReference, mode);
+            });
+        }
+    };
+}
+function createWatchProgram(ts, context, options) {
+    return ts.createWatchProgram(createWatchHost(ts, context, options));
+}
+
+const createFileFolder = (filePath) => {
+    const folderPath = path__default.dirname(filePath);
+    fs__default__default.mkdirSync(folderPath, { recursive: true });
+};
+class TSCache {
+    constructor(cacheFolder = '.rollup.cache') {
+        this._cacheFolder = cacheFolder;
+    }
+    cachedFilename(fileName) {
+        return path__default.join(this._cacheFolder, fileName.replace(/^([a-zA-Z]+):/, '$1'));
+    }
+    cacheCode(fileName, code) {
+        const cachedPath = this.cachedFilename(fileName);
+        createFileFolder(cachedPath);
+        fs__default__default.writeFileSync(cachedPath, code);
+    }
+    isCached(fileName) {
+        return fs__default__default.existsSync(this.cachedFilename(fileName));
+    }
+    getCached(fileName) {
+        let code;
+        if (this.isCached(fileName)) {
+            code = fs__default__default.readFileSync(this.cachedFilename(fileName), { encoding: 'utf-8' });
+        }
+        return code;
+    }
+}
+
+function typescript(options = {}) {
+    const { cacheDir, compilerOptions, exclude, filterRoot, include, outputToFilesystem, noForceEmit, transformers, recreateTransformersOnRebuild, tsconfig, tslib, typescript: ts } = getPluginOptions(options);
+    const tsCache = new TSCache(cacheDir);
+    const emittedFiles = new Map();
+    const watchProgramHelper = new WatchProgramHelper();
+    let autoOutDir = null;
+    const cleanupAutoOutDir = () => {
+        if (!autoOutDir)
+            return;
+        try {
+            fs__default.rmSync(autoOutDir, { recursive: true, force: true });
+        }
+        catch {
+        }
+        autoOutDir = null;
+    };
+    const closeProgramAndCleanup = () => {
+        try {
+            program === null || program === void 0 ? void 0 : program.close();
+        }
+        finally {
+            cleanupAutoOutDir();
+        }
+    };
+    const parsedOptions = parseTypescriptConfig(ts, tsconfig, compilerOptions, noForceEmit);
+    if (parsedOptions.options.allowJs && !parsedOptions.options.outDir) {
+        autoOutDir = fs__default.mkdtempSync(path$2.join(require$$0.tmpdir(), 'rollup-plugin-typescript-allowjs-'));
+        parsedOptions.options.outDir = autoOutDir;
+    }
+    const defaultInclude = parsedOptions.options.allowJs
+        ? '{,**/}*.{cts,mts,ts,tsx,js,jsx,mjs,cjs}'
+        : '{,**/}*.{cts,mts,ts,tsx}';
+    const filterExclude = Array.isArray(exclude) ? [...exclude] : exclude ? [exclude] : [];
+    if (parsedOptions.options.allowJs && !include && !exclude) {
+        filterExclude.push('**/node_modules/**');
+    }
+    const effectiveOutDir = parsedOptions.options.outDir
+        ? path$2.resolve(parsedOptions.options.outDir)
+        : null;
+    const willResolvePatterns = filterRoot !== false;
+    const configuredBase = willResolvePatterns
+        ? typeof filterRoot === 'string'
+            ? filterRoot
+            : parsedOptions.options.rootDir
+        : null;
+    const filterBaseAbs = configuredBase ? path$2.resolve(configuredBase) : null;
+    if (effectiveOutDir) {
+        const baseForContainment = filterBaseAbs !== null && filterBaseAbs !== void 0 ? filterBaseAbs : process.cwd();
+        const outDirContainsFilterBase = (() => {
+            const getRoot = (p) => {
+                const r = path$2.parse(p).root;
+                return process.platform === 'win32' ? r.toLowerCase() : r;
+            };
+            if (getRoot(effectiveOutDir) !== getRoot(baseForContainment))
+                return false;
+            const rel = path$2.relative(effectiveOutDir, baseForContainment);
+            return rel === '' || (!rel.startsWith('..') && !path$2.isAbsolute(rel));
+        })();
+        if (!outDirContainsFilterBase) {
+            filterExclude.push(normalizePath(path$2.join(effectiveOutDir, '**')));
+        }
+    }
+    const filter = createFilter(include || defaultInclude, filterExclude, {
+        resolve: typeof filterRoot === 'string'
+            ? filterRoot
+            : filterRoot === false
+                ? false
+                : parsedOptions.options.rootDir || process.cwd()
+    });
+    parsedOptions.fileNames = parsedOptions.fileNames.filter(filter);
+    const formatHost = createFormattingHost(ts, parsedOptions.options);
+    const resolveModule = createModuleResolver(ts, formatHost, filter);
+    let program = null;
+    return {
+        name: 'typescript',
+        buildStart(rollupOptions) {
+            emitParsedOptionsErrors(ts, this, parsedOptions);
+            preflight({
+                config: parsedOptions,
+                context: this,
+                inputPreserveModules: rollupOptions
+                    .preserveModules,
+                tslib
+            });
+            if (this.meta.watchMode !== true) {
+                program === null || program === void 0 ? void 0 : program.close();
+                program = null;
+            }
+            if (!program) {
+                program = createWatchProgram(ts, this, {
+                    formatHost,
+                    resolveModule,
+                    parsedOptions,
+                    writeFile(fileName, data) {
+                        if (parsedOptions.options.composite || parsedOptions.options.incremental) {
+                            tsCache.cacheCode(fileName, data);
+                        }
+                        emittedFiles.set(fileName, data);
+                    },
+                    status(diagnostic) {
+                        watchProgramHelper.handleStatus(diagnostic);
+                    },
+                    transformers,
+                    recreateTransformersOnRebuild
+                });
+            }
+        },
+        watchChange(id) {
+            if (!filter(id))
+                return;
+            watchProgramHelper.watch();
+        },
+        buildEnd() {
+            if (this.meta.watchMode !== true) {
+                closeProgramAndCleanup();
+            }
+        },
+        closeWatcher() {
+            closeProgramAndCleanup();
+        },
+        renderStart(outputOptions) {
+            validateSourceMap(this, parsedOptions.options, outputOptions, parsedOptions.autoSetSourceMap);
+            validatePaths(this, parsedOptions.options, outputOptions);
+        },
+        resolveId(importee, importer) {
+            if (importee === 'tslib') {
+                return tslib;
+            }
+            if (!importer)
+                return null;
+            const containingFile = normalizePath(importer);
+            const mode = typeof ts.getImpliedNodeFormatForFile === 'function'
+                ? ts.getImpliedNodeFormatForFile(
+                containingFile, undefined, 
+                { ...ts.sys, ...formatHost }, parsedOptions.options)
+                : undefined; 
+            const resolved = resolveModule(importee, containingFile, undefined, mode);
+            if (resolved) {
+                if (/\.d\.[cm]?ts/.test(resolved.extension))
+                    return null;
+                if (!filter(resolved.resolvedFileName))
+                    return null;
+                return path$2.normalize(resolved.resolvedFileName);
+            }
+            return null;
+        },
+        async load(id) {
+            if (!filter(id))
+                return null;
+            this.addWatchFile(id);
+            await watchProgramHelper.wait();
+            const fileName = normalizePath(id);
+            if (!parsedOptions.fileNames.includes(fileName)) {
+                parsedOptions.fileNames.push(fileName);
+            }
+            const output = findTypescriptOutput(ts, parsedOptions, id, emittedFiles, tsCache);
+            return output.code != null ? output : null;
+        },
+        async generateBundle(outputOptions) {
+            const declarationAndTypeScriptMapFiles = [...emittedFiles.keys()].filter((fileName) => isDeclarationOutputFile(fileName) || isTypeScriptMapOutputFile(fileName));
+            declarationAndTypeScriptMapFiles.forEach((id) => {
+                const code = getEmittedFile(id, emittedFiles, tsCache);
+                if (!code || !parsedOptions.options.declaration) {
+                    return;
+                }
+                let baseDir;
+                if (outputOptions.dir) {
+                    baseDir = outputOptions.dir;
+                }
+                else if (outputOptions.file) {
+                    baseDir = path$2.dirname(outputOptions.file);
+                }
+                if (!baseDir)
+                    return;
+                this.emitFile({
+                    type: 'asset',
+                    fileName: normalizePath(path$2.relative(baseDir, id)),
+                    source: code
+                });
+            });
+            const tsBuildInfoPath = ts.getTsBuildInfoEmitOutputFilePath(parsedOptions.options);
+            if (tsBuildInfoPath) {
+                const tsBuildInfoSource = emittedFiles.get(tsBuildInfoPath);
+                if (tsBuildInfoSource) {
+                    await emitFile(outputOptions, outputToFilesystem, this, tsBuildInfoPath, tsBuildInfoSource);
+                }
+            }
+        }
+    };
+}
+
+export { typescript as default };