vitest 2.0.0-beta.1 → 2.0.0-beta.10

package/dist/vendor/{cli-api.DTeni0Qq.js → cli-api.CUtJc4r3.js}

@@ -1,33 +1,35 @@
-import { dirname, join, resolve, relative, isAbsolute, normalize, basename, toNamespacedPath } from 'pathe';
-import { A as API_PATH, d as defaultPort, e as extraInlineDeps, a as defaultBrowserPort, b as defaultInspectPort, E as EXIT_CODE_RESTART, w as workspacesFiles, C as CONFIG_NAMES, c as configFiles } from './constants.5SOfHUj0.js';
+import { join, resolve, relative, isAbsolute, dirname, normalize, basename, extname as extname$1, toNamespacedPath } from 'pathe';
+import { A as API_PATH, e as extraInlineDeps, d as defaultPort, a as defaultBrowserPort, b as defaultInspectPort, B as BROWSER_API_PATH, E as EXIT_CODE_RESTART, w as workspacesFiles, C as CONFIG_NAMES, c as configFiles } from './constants.TCjCaw2D.js';
 import { g as getCoverageProvider, C as CoverageProviderMap } from './coverage.ChSqD-qS.js';
-import { g as getEnvPackageName } from './index.DeR1hhfY.js';
-import { isFileServingAllowed, searchForWorkspaceRoot, version, createServer, mergeConfig } from 'vite';
+import { g as getEnvPackageName } from './index.kpsSqFiz.js';
+import { searchForWorkspaceRoot, version, isFileServingAllowed, parseAst, createServer, mergeConfig } from 'vite';
 import path$8, { win32 } from 'node:path';
 import url, { fileURLToPath as fileURLToPath$1, pathToFileURL as pathToFileURL$1, URL as URL$2 } from 'node:url';
 import process$1 from 'node:process';
-import fs$8, { promises as promises$1, existsSync, statSync as statSync$1, realpathSync, readFileSync } from 'node:fs';
+import fs$8, { promises as promises$1, existsSync, statSync as statSync$1, realpathSync, readdirSync, readFileSync } from 'node:fs';
 import { MessageChannel, isMainThread } from 'node:worker_threads';
 import { c as commonjsGlobal, g as getDefaultExportFromCjs } from './_commonjsHelpers.BFTU3MAI.js';
 import require$$0 from 'os';
 import p from 'path';
-import { a as micromatch_1, m as mm } from './index.DP-km6lF.js';
-import require$$0$1 from 'stream';
-import require$$0$3 from 'events';
-import require$$0$2 from 'fs';
+import require$$0$1 from 'util';
+import { t as toRegexRange_1, p as picomatch$1, u as utils$h, m as mm } from './index.CThipSqB.js';
+import require$$0$2 from 'stream';
+import require$$0$4 from 'events';
+import require$$0$3 from 'fs';
 import c from 'picocolors';
 import { ViteNodeRunner } from 'vite-node/client';
 import { SnapshotManager } from '@vitest/snapshot/manager';
 import { ViteNodeServer } from 'vite-node/server';
-import { v as version$1 } from './cac.DzKZaJu2.js';
-import { hasFailed, getTasks, getTests } from '@vitest/runner/utils';
-import { n as noop$2, b as isPrimitive, c as groupBy, A as AggregateErrorPonyfill, a as slash$1, t as toArray, d as deepMerge, e as nanoid, w as wildcardPatternToRegExp, f as stdout } from './base._gnK9Slw.js';
+import { v as version$1 } from './cac.CtYFkoSJ.js';
+import { hasFailed, createFileTask, getTasks, getTests } from '@vitest/runner/utils';
+import { n as noop$1, b as isPrimitive, c as groupBy, A as AggregateErrorPonyfill, a as slash$1, t as toArray, d as deepMerge, e as nanoid, w as wildcardPatternToRegExp, f as stdout } from './base._gnK9Slw.js';
 import { createDefer, toArray as toArray$1, notNullish } from '@vitest/utils';
 import { a as isWindows } from './env.bmJgw1qP.js';
-import { rootDir } from '../path.js';
+import { rootDir, distDir } from '../path.js';
 import { c as createBirpc } from './index.BpSiYbpB.js';
-import require$$0$4 from 'zlib';
-import require$$0$5 from 'buffer';
+import { s as stringify$5, p as parse$5, w as wrapSerializableConfig, f as Typechecker, R as ReportersMap, e as BenchmarkReportsMap, g as RandomSequencer, B as BaseSequencer, h as findNodeAround, i as generateCodeFrame, j as highlightCode, L as Logger, k as BlobReporter, r as readBlobs } from './index.BOMEjpjj.js';
+import require$$0$5 from 'zlib';
+import require$$0$6 from 'buffer';
 import require$$1 from 'crypto';
 import require$$1$1 from 'https';
 import require$$2 from 'http';
@@ -40,20 +42,21 @@ import * as nodeos from 'node:os';
 import nodeos__default, { tmpdir } from 'node:os';
 import EventEmitter$2 from 'node:events';
 import Tinypool$1, { Tinypool } from 'tinypool';
-import { w as wrapSerializableConfig, f as Typechecker, R as ReportersMap, e as BenchmarkReportsMap, g as RandomSequencer, B as BaseSequencer, h as findNodeAround, i as generateCodeFrame, j as highlightCode, L as Logger } from './index.CRxYS9H3.js';
 import crypto, { createHash as createHash$2 } from 'node:crypto';
 import { mkdir, writeFile, rm } from 'node:fs/promises';
+import createDebug from 'debug';
 import { builtinModules, createRequire } from 'node:module';
 import assert from 'node:assert';
 import { format as format$2, inspect } from 'node:util';
 import { isCI, provider as provider$1 } from 'std-env';
-import { normalizeRequestId, cleanUrl } from 'vite-node/utils';
+import { normalizeRequestId, isNodeBuiltin, cleanUrl } from 'vite-node/utils';
 import MagicString from 'magic-string';
 import { esmWalker } from '@vitest/utils/ast';
-import { d as divider, s as stripAnsi } from './utils.D5gGkwyH.js';
+import remapping from '@ampproject/remapping';
 import { a as removeUndefinedValues } from './index._7XLd8Kd.js';
 import readline from 'node:readline';
-import require$$0$6 from 'readline';
+import require$$0$7 from 'readline';
+import { s as stripAnsi } from './utils.YuQ3LT2a.js';
 
 function _mergeNamespaces(n, m) {
   m.forEach(function (e) {
@@ -70,21 +73,25 @@ function _mergeNamespaces(n, m) {
   return Object.freeze(n);
 }
 
-async function getModuleGraph(ctx, id) {
+async function getModuleGraph(ctx, projectName, id, browser = false) {
   const graph = {};
   const externalized = /* @__PURE__ */ new Set();
   const inlined = /* @__PURE__ */ new Set();
+  const project = ctx.getProjectByName(projectName);
   function clearId(id2) {
     return (id2 == null ? void 0 : id2.replace(/\?v=\w+$/, "")) || "";
   }
   async function get(mod, seen = /* @__PURE__ */ new Map()) {
+    var _a;
     if (!mod || !mod.id)
       return;
+    if (mod.id === "\0@vitest/browser/context")
+      return;
     if (seen.has(mod))
       return seen.get(mod);
     let id2 = clearId(mod.id);
     seen.set(mod, id2);
-    const rewrote = await ctx.vitenode.shouldExternalize(id2);
+    const rewrote = browser ? ((_a = mod.file) == null ? void 0 : _a.includes(project.browser.config.cacheDir)) ? mod.id : false : await project.vitenode.shouldExternalize(id2);
     if (rewrote) {
       id2 = rewrote;
       externalized.add(id2);
@@ -96,7 +103,10 @@ async function getModuleGraph(ctx, id) {
     graph[id2] = (await Promise.all(mods.map((m) => get(m, seen)))).filter(Boolean);
     return id2;
   }
-  await get(ctx.server.moduleGraph.getModuleById(id));
+  if (browser && project.browser)
+    await get(project.browser.moduleGraph.getModuleById(id));
+  else
+    await get(project.server.moduleGraph.getModuleById(id));
   return {
     graph,
     externalized: Array.from(externalized),
@@ -111,10 +121,17 @@ function cloneByOwnProperties(value) {
   }), {});
 }
 function stringifyReplace(key, value) {
-  if (value instanceof Error)
-    return cloneByOwnProperties(value);
-  else
+  if (value instanceof Error) {
+    const cloned = cloneByOwnProperties(value);
+    return {
+      name: value.name,
+      message: value.message,
+      stack: value.stack,
+      ...cloned
+    };
+  } else {
     return value;
+  }
 }
 
 /*
@@ -396,7 +413,7 @@ async function findUp(name, options = {}) {
 
 var tasks = {};
 
-var utils$b = {};
+var utils$g = {};
 
 var array$1 = {};
 
@@ -608,135 +625,1717 @@ var strictCheck = function(str) {
       }
     }
 
-    if (pipeIndex !== -1 && str[index] === '(' && str[index + 1] !== '|') {
-      if (pipeIndex < index) {
-        pipeIndex = str.indexOf('|', index);
-      }
-      if (pipeIndex !== -1 && str[pipeIndex + 1] !== ')') {
-        closeParenIndex = str.indexOf(')', pipeIndex);
-        if (closeParenIndex > pipeIndex) {
-          backSlashIndex = str.indexOf('\\', pipeIndex);
-          if (backSlashIndex === -1 || backSlashIndex > closeParenIndex) {
-            return true;
-          }
-        }
-      }
+    if (pipeIndex !== -1 && str[index] === '(' && str[index + 1] !== '|') {
+      if (pipeIndex < index) {
+        pipeIndex = str.indexOf('|', index);
+      }
+      if (pipeIndex !== -1 && str[pipeIndex + 1] !== ')') {
+        closeParenIndex = str.indexOf(')', pipeIndex);
+        if (closeParenIndex > pipeIndex) {
+          backSlashIndex = str.indexOf('\\', pipeIndex);
+          if (backSlashIndex === -1 || backSlashIndex > closeParenIndex) {
+            return true;
+          }
+        }
+      }
+    }
+
+    if (str[index] === '\\') {
+      var open = str[index + 1];
+      index += 2;
+      var close = chars[open];
+
+      if (close) {
+        var n = str.indexOf(close, index);
+        if (n !== -1) {
+          index = n + 1;
+        }
+      }
+
+      if (str[index] === '!') {
+        return true;
+      }
+    } else {
+      index++;
+    }
+  }
+  return false;
+};
+
+var relaxedCheck = function(str) {
+  if (str[0] === '!') {
+    return true;
+  }
+  var index = 0;
+  while (index < str.length) {
+    if (/[*?{}()[\]]/.test(str[index])) {
+      return true;
+    }
+
+    if (str[index] === '\\') {
+      var open = str[index + 1];
+      index += 2;
+      var close = chars[open];
+
+      if (close) {
+        var n = str.indexOf(close, index);
+        if (n !== -1) {
+          index = n + 1;
+        }
+      }
+
+      if (str[index] === '!') {
+        return true;
+      }
+    } else {
+      index++;
+    }
+  }
+  return false;
+};
+
+var isGlob$1 = function isGlob(str, options) {
+  if (typeof str !== 'string' || str === '') {
+    return false;
+  }
+
+  if (isExtglob(str)) {
+    return true;
+  }
+
+  var check = strictCheck;
+
+  // optionally relax check
+  if (options && options.strict === false) {
+    check = relaxedCheck;
+  }
+
+  return check(str);
+};
+
+var isGlob = isGlob$1;
+var pathPosixDirname = p.posix.dirname;
+var isWin32 = require$$0.platform() === 'win32';
+
+var slash = '/';
+var backslash = /\\/g;
+var enclosure = /[\{\[].*[\}\]]$/;
+var globby = /(^|[^\\])([\{\[]|\([^\)]+$)/;
+var escaped = /\\([\!\*\?\|\[\]\(\)\{\}])/g;
+
+/**
+ * @param {string} str
+ * @param {Object} opts
+ * @param {boolean} [opts.flipBackslashes=true]
+ * @returns {string}
+ */
+var globParent$1 = function globParent(str, opts) {
+  var options = Object.assign({ flipBackslashes: true }, opts);
+
+  // flip windows path separators
+  if (options.flipBackslashes && isWin32 && str.indexOf(slash) < 0) {
+    str = str.replace(backslash, slash);
+  }
+
+  // special case for strings ending in enclosure containing path separator
+  if (enclosure.test(str)) {
+    str += slash;
+  }
+
+  // preserves full path in case of trailing path separator
+  str += 'a';
+
+  // remove path parts that are globby
+  do {
+    str = pathPosixDirname(str);
+  } while (isGlob(str) || globby.test(str));
+
+  // remove escape chars and return result
+  return str.replace(escaped, '$1');
+};
+
+var utils$f = {};
+
+(function (exports) {
+
+	exports.isInteger = num => {
+	  if (typeof num === 'number') {
+	    return Number.isInteger(num);
+	  }
+	  if (typeof num === 'string' && num.trim() !== '') {
+	    return Number.isInteger(Number(num));
+	  }
+	  return false;
+	};
+
+	/**
+	 * Find a node of the given type
+	 */
+
+	exports.find = (node, type) => node.nodes.find(node => node.type === type);
+
+	/**
+	 * Find a node of the given type
+	 */
+
+	exports.exceedsLimit = (min, max, step = 1, limit) => {
+	  if (limit === false) return false;
+	  if (!exports.isInteger(min) || !exports.isInteger(max)) return false;
+	  return ((Number(max) - Number(min)) / Number(step)) >= limit;
+	};
+
+	/**
+	 * Escape the given node with '\\' before node.value
+	 */
+
+	exports.escapeNode = (block, n = 0, type) => {
+	  let node = block.nodes[n];
+	  if (!node) return;
+
+	  if ((type && node.type === type) || node.type === 'open' || node.type === 'close') {
+	    if (node.escaped !== true) {
+	      node.value = '\\' + node.value;
+	      node.escaped = true;
+	    }
+	  }
+	};
+
+	/**
+	 * Returns true if the given brace node should be enclosed in literal braces
+	 */
+
+	exports.encloseBrace = node => {
+	  if (node.type !== 'brace') return false;
+	  if ((node.commas >> 0 + node.ranges >> 0) === 0) {
+	    node.invalid = true;
+	    return true;
+	  }
+	  return false;
+	};
+
+	/**
+	 * Returns true if a brace node is invalid.
+	 */
+
+	exports.isInvalidBrace = block => {
+	  if (block.type !== 'brace') return false;
+	  if (block.invalid === true || block.dollar) return true;
+	  if ((block.commas >> 0 + block.ranges >> 0) === 0) {
+	    block.invalid = true;
+	    return true;
+	  }
+	  if (block.open !== true || block.close !== true) {
+	    block.invalid = true;
+	    return true;
+	  }
+	  return false;
+	};
+
+	/**
+	 * Returns true if a node is an open or close node
+	 */
+
+	exports.isOpenOrClose = node => {
+	  if (node.type === 'open' || node.type === 'close') {
+	    return true;
+	  }
+	  return node.open === true || node.close === true;
+	};
+
+	/**
+	 * Reduce an array of text nodes.
+	 */
+
+	exports.reduce = nodes => nodes.reduce((acc, node) => {
+	  if (node.type === 'text') acc.push(node.value);
+	  if (node.type === 'range') node.type = 'text';
+	  return acc;
+	}, []);
+
+	/**
+	 * Flatten an array
+	 */
+
+	exports.flatten = (...args) => {
+	  const result = [];
+	  const flat = arr => {
+	    for (let i = 0; i < arr.length; i++) {
+	      let ele = arr[i];
+	      Array.isArray(ele) ? flat(ele) : ele !== void 0 && result.push(ele);
+	    }
+	    return result;
+	  };
+	  flat(args);
+	  return result;
+	}; 
+} (utils$f));
+
+const utils$e = utils$f;
+
+var stringify$4 = (ast, options = {}) => {
+  let stringify = (node, parent = {}) => {
+    let invalidBlock = options.escapeInvalid && utils$e.isInvalidBrace(parent);
+    let invalidNode = node.invalid === true && options.escapeInvalid === true;
+    let output = '';
+
+    if (node.value) {
+      if ((invalidBlock || invalidNode) && utils$e.isOpenOrClose(node)) {
+        return '\\' + node.value;
+      }
+      return node.value;
+    }
+
+    if (node.value) {
+      return node.value;
+    }
+
+    if (node.nodes) {
+      for (let child of node.nodes) {
+        output += stringify(child);
+      }
+    }
+    return output;
+  };
+
+  return stringify(ast);
+};
+
+/*!
+ * fill-range <https://github.com/jonschlinkert/fill-range>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+const util$3 = require$$0$1;
+const toRegexRange = toRegexRange_1;
+
+const isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
+
+const transform = toNumber => {
+  return value => toNumber === true ? Number(value) : String(value);
+};
+
+const isValidValue = value => {
+  return typeof value === 'number' || (typeof value === 'string' && value !== '');
+};
+
+const isNumber = num => Number.isInteger(+num);
+
+const zeros = input => {
+  let value = `${input}`;
+  let index = -1;
+  if (value[0] === '-') value = value.slice(1);
+  if (value === '0') return false;
+  while (value[++index] === '0');
+  return index > 0;
+};
+
+const stringify$3 = (start, end, options) => {
+  if (typeof start === 'string' || typeof end === 'string') {
+    return true;
+  }
+  return options.stringify === true;
+};
+
+const pad = (input, maxLength, toNumber) => {
+  if (maxLength > 0) {
+    let dash = input[0] === '-' ? '-' : '';
+    if (dash) input = input.slice(1);
+    input = (dash + input.padStart(dash ? maxLength - 1 : maxLength, '0'));
+  }
+  if (toNumber === false) {
+    return String(input);
+  }
+  return input;
+};
+
+const toMaxLen = (input, maxLength) => {
+  let negative = input[0] === '-' ? '-' : '';
+  if (negative) {
+    input = input.slice(1);
+    maxLength--;
+  }
+  while (input.length < maxLength) input = '0' + input;
+  return negative ? ('-' + input) : input;
+};
+
+const toSequence = (parts, options) => {
+  parts.negatives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  parts.positives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+
+  let prefix = options.capture ? '' : '?:';
+  let positives = '';
+  let negatives = '';
+  let result;
+
+  if (parts.positives.length) {
+    positives = parts.positives.join('|');
+  }
+
+  if (parts.negatives.length) {
+    negatives = `-(${prefix}${parts.negatives.join('|')})`;
+  }
+
+  if (positives && negatives) {
+    result = `${positives}|${negatives}`;
+  } else {
+    result = positives || negatives;
+  }
+
+  if (options.wrap) {
+    return `(${prefix}${result})`;
+  }
+
+  return result;
+};
+
+const toRange = (a, b, isNumbers, options) => {
+  if (isNumbers) {
+    return toRegexRange(a, b, { wrap: false, ...options });
+  }
+
+  let start = String.fromCharCode(a);
+  if (a === b) return start;
+
+  let stop = String.fromCharCode(b);
+  return `[${start}-${stop}]`;
+};
+
+const toRegex = (start, end, options) => {
+  if (Array.isArray(start)) {
+    let wrap = options.wrap === true;
+    let prefix = options.capture ? '' : '?:';
+    return wrap ? `(${prefix}${start.join('|')})` : start.join('|');
+  }
+  return toRegexRange(start, end, options);
+};
+
+const rangeError = (...args) => {
+  return new RangeError('Invalid range arguments: ' + util$3.inspect(...args));
+};
+
+const invalidRange = (start, end, options) => {
+  if (options.strictRanges === true) throw rangeError([start, end]);
+  return [];
+};
+
+const invalidStep = (step, options) => {
+  if (options.strictRanges === true) {
+    throw new TypeError(`Expected step "${step}" to be a number`);
+  }
+  return [];
+};
+
+const fillNumbers = (start, end, step = 1, options = {}) => {
+  let a = Number(start);
+  let b = Number(end);
+
+  if (!Number.isInteger(a) || !Number.isInteger(b)) {
+    if (options.strictRanges === true) throw rangeError([start, end]);
+    return [];
+  }
+
+  // fix negative zero
+  if (a === 0) a = 0;
+  if (b === 0) b = 0;
+
+  let descending = a > b;
+  let startString = String(start);
+  let endString = String(end);
+  let stepString = String(step);
+  step = Math.max(Math.abs(step), 1);
+
+  let padded = zeros(startString) || zeros(endString) || zeros(stepString);
+  let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;
+  let toNumber = padded === false && stringify$3(start, end, options) === false;
+  let format = options.transform || transform(toNumber);
+
+  if (options.toRegex && step === 1) {
+    return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);
+  }
+
+  let parts = { negatives: [], positives: [] };
+  let push = num => parts[num < 0 ? 'negatives' : 'positives'].push(Math.abs(num));
+  let range = [];
+  let index = 0;
+
+  while (descending ? a >= b : a <= b) {
+    if (options.toRegex === true && step > 1) {
+      push(a);
+    } else {
+      range.push(pad(format(a, index), maxLen, toNumber));
+    }
+    a = descending ? a - step : a + step;
+    index++;
+  }
+
+  if (options.toRegex === true) {
+    return step > 1
+      ? toSequence(parts, options)
+      : toRegex(range, null, { wrap: false, ...options });
+  }
+
+  return range;
+};
+
+const fillLetters = (start, end, step = 1, options = {}) => {
+  if ((!isNumber(start) && start.length > 1) || (!isNumber(end) && end.length > 1)) {
+    return invalidRange(start, end, options);
+  }
+
+
+  let format = options.transform || (val => String.fromCharCode(val));
+  let a = `${start}`.charCodeAt(0);
+  let b = `${end}`.charCodeAt(0);
+
+  let descending = a > b;
+  let min = Math.min(a, b);
+  let max = Math.max(a, b);
+
+  if (options.toRegex && step === 1) {
+    return toRange(min, max, false, options);
+  }
+
+  let range = [];
+  let index = 0;
+
+  while (descending ? a >= b : a <= b) {
+    range.push(format(a, index));
+    a = descending ? a - step : a + step;
+    index++;
+  }
+
+  if (options.toRegex === true) {
+    return toRegex(range, null, { wrap: false, options });
+  }
+
+  return range;
+};
+
+const fill$2 = (start, end, step, options = {}) => {
+  if (end == null && isValidValue(start)) {
+    return [start];
+  }
+
+  if (!isValidValue(start) || !isValidValue(end)) {
+    return invalidRange(start, end, options);
+  }
+
+  if (typeof step === 'function') {
+    return fill$2(start, end, 1, { transform: step });
+  }
+
+  if (isObject(step)) {
+    return fill$2(start, end, 0, step);
+  }
+
+  let opts = { ...options };
+  if (opts.capture === true) opts.wrap = true;
+  step = step || opts.step || 1;
+
+  if (!isNumber(step)) {
+    if (step != null && !isObject(step)) return invalidStep(step, opts);
+    return fill$2(start, end, 1, step);
+  }
+
+  if (isNumber(start) && isNumber(end)) {
+    return fillNumbers(start, end, step, opts);
+  }
+
+  return fillLetters(start, end, Math.max(Math.abs(step), 1), opts);
+};
+
+var fillRange = fill$2;
+
+const fill$1 = fillRange;
+const utils$d = utils$f;
+
+const compile$1 = (ast, options = {}) => {
+  let walk = (node, parent = {}) => {
+    let invalidBlock = utils$d.isInvalidBrace(parent);
+    let invalidNode = node.invalid === true && options.escapeInvalid === true;
+    let invalid = invalidBlock === true || invalidNode === true;
+    let prefix = options.escapeInvalid === true ? '\\' : '';
+    let output = '';
+
+    if (node.isOpen === true) {
+      return prefix + node.value;
+    }
+    if (node.isClose === true) {
+      return prefix + node.value;
+    }
+
+    if (node.type === 'open') {
+      return invalid ? (prefix + node.value) : '(';
+    }
+
+    if (node.type === 'close') {
+      return invalid ? (prefix + node.value) : ')';
+    }
+
+    if (node.type === 'comma') {
+      return node.prev.type === 'comma' ? '' : (invalid ? node.value : '|');
+    }
+
+    if (node.value) {
+      return node.value;
+    }
+
+    if (node.nodes && node.ranges > 0) {
+      let args = utils$d.reduce(node.nodes);
+      let range = fill$1(...args, { ...options, wrap: false, toRegex: true });
+
+      if (range.length !== 0) {
+        return args.length > 1 && range.length > 1 ? `(${range})` : range;
+      }
+    }
+
+    if (node.nodes) {
+      for (let child of node.nodes) {
+        output += walk(child, node);
+      }
+    }
+    return output;
+  };
+
+  return walk(ast);
+};
+
+var compile_1 = compile$1;
+
+const fill = fillRange;
+const stringify$2 = stringify$4;
+const utils$c = utils$f;
+
+const append = (queue = '', stash = '', enclose = false) => {
+  let result = [];
+
+  queue = [].concat(queue);
+  stash = [].concat(stash);
+
+  if (!stash.length) return queue;
+  if (!queue.length) {
+    return enclose ? utils$c.flatten(stash).map(ele => `{${ele}}`) : stash;
+  }
+
+  for (let item of queue) {
+    if (Array.isArray(item)) {
+      for (let value of item) {
+        result.push(append(value, stash, enclose));
+      }
+    } else {
+      for (let ele of stash) {
+        if (enclose === true && typeof ele === 'string') ele = `{${ele}}`;
+        result.push(Array.isArray(ele) ? append(item, ele, enclose) : (item + ele));
+      }
+    }
+  }
+  return utils$c.flatten(result);
+};
+
+const expand$1 = (ast, options = {}) => {
+  let rangeLimit = options.rangeLimit === void 0 ? 1000 : options.rangeLimit;
+
+  let walk = (node, parent = {}) => {
+    node.queue = [];
+
+    let p = parent;
+    let q = parent.queue;
+
+    while (p.type !== 'brace' && p.type !== 'root' && p.parent) {
+      p = p.parent;
+      q = p.queue;
+    }
+
+    if (node.invalid || node.dollar) {
+      q.push(append(q.pop(), stringify$2(node, options)));
+      return;
+    }
+
+    if (node.type === 'brace' && node.invalid !== true && node.nodes.length === 2) {
+      q.push(append(q.pop(), ['{}']));
+      return;
+    }
+
+    if (node.nodes && node.ranges > 0) {
+      let args = utils$c.reduce(node.nodes);
+
+      if (utils$c.exceedsLimit(...args, options.step, rangeLimit)) {
+        throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.');
+      }
+
+      let range = fill(...args, options);
+      if (range.length === 0) {
+        range = stringify$2(node, options);
+      }
+
+      q.push(append(q.pop(), range));
+      node.nodes = [];
+      return;
+    }
+
+    let enclose = utils$c.encloseBrace(node);
+    let queue = node.queue;
+    let block = node;
+
+    while (block.type !== 'brace' && block.type !== 'root' && block.parent) {
+      block = block.parent;
+      queue = block.queue;
+    }
+
+    for (let i = 0; i < node.nodes.length; i++) {
+      let child = node.nodes[i];
+
+      if (child.type === 'comma' && node.type === 'brace') {
+        if (i === 1) queue.push('');
+        queue.push('');
+        continue;
+      }
+
+      if (child.type === 'close') {
+        q.push(append(q.pop(), queue, enclose));
+        continue;
+      }
+
+      if (child.value && child.type !== 'open') {
+        queue.push(append(queue.pop(), child.value));
+        continue;
+      }
+
+      if (child.nodes) {
+        walk(child, node);
+      }
+    }
+
+    return queue;
+  };
+
+  return utils$c.flatten(walk(ast));
+};
+
+var expand_1 = expand$1;
+
+var constants$2 = {
+  MAX_LENGTH: 1024 * 64,
+
+  // Digits
+  CHAR_0: '0', /* 0 */
+  CHAR_9: '9', /* 9 */
+
+  // Alphabet chars.
+  CHAR_UPPERCASE_A: 'A', /* A */
+  CHAR_LOWERCASE_A: 'a', /* a */
+  CHAR_UPPERCASE_Z: 'Z', /* Z */
+  CHAR_LOWERCASE_Z: 'z', /* z */
+
+  CHAR_LEFT_PARENTHESES: '(', /* ( */
+  CHAR_RIGHT_PARENTHESES: ')', /* ) */
+
+  CHAR_ASTERISK: '*', /* * */
+
+  // Non-alphabetic chars.
+  CHAR_AMPERSAND: '&', /* & */
+  CHAR_AT: '@', /* @ */
+  CHAR_BACKSLASH: '\\', /* \ */
+  CHAR_BACKTICK: '`', /* ` */
+  CHAR_CARRIAGE_RETURN: '\r', /* \r */
+  CHAR_CIRCUMFLEX_ACCENT: '^', /* ^ */
+  CHAR_COLON: ':', /* : */
+  CHAR_COMMA: ',', /* , */
+  CHAR_DOLLAR: '$', /* . */
+  CHAR_DOT: '.', /* . */
+  CHAR_DOUBLE_QUOTE: '"', /* " */
+  CHAR_EQUAL: '=', /* = */
+  CHAR_EXCLAMATION_MARK: '!', /* ! */
+  CHAR_FORM_FEED: '\f', /* \f */
+  CHAR_FORWARD_SLASH: '/', /* / */
+  CHAR_HASH: '#', /* # */
+  CHAR_HYPHEN_MINUS: '-', /* - */
+  CHAR_LEFT_ANGLE_BRACKET: '<', /* < */
+  CHAR_LEFT_CURLY_BRACE: '{', /* { */
+  CHAR_LEFT_SQUARE_BRACKET: '[', /* [ */
+  CHAR_LINE_FEED: '\n', /* \n */
+  CHAR_NO_BREAK_SPACE: '\u00A0', /* \u00A0 */
+  CHAR_PERCENT: '%', /* % */
+  CHAR_PLUS: '+', /* + */
+  CHAR_QUESTION_MARK: '?', /* ? */
+  CHAR_RIGHT_ANGLE_BRACKET: '>', /* > */
+  CHAR_RIGHT_CURLY_BRACE: '}', /* } */
+  CHAR_RIGHT_SQUARE_BRACKET: ']', /* ] */
+  CHAR_SEMICOLON: ';', /* ; */
+  CHAR_SINGLE_QUOTE: '\'', /* ' */
+  CHAR_SPACE: ' ', /*   */
+  CHAR_TAB: '\t', /* \t */
+  CHAR_UNDERSCORE: '_', /* _ */
+  CHAR_VERTICAL_LINE: '|', /* | */
+  CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\uFEFF' /* \uFEFF */
+};
+
+const stringify$1 = stringify$4;
+
+/**
+ * Constants
+ */
+
+const {
+  MAX_LENGTH,
+  CHAR_BACKSLASH, /* \ */
+  CHAR_BACKTICK, /* ` */
+  CHAR_COMMA, /* , */
+  CHAR_DOT, /* . */
+  CHAR_LEFT_PARENTHESES, /* ( */
+  CHAR_RIGHT_PARENTHESES, /* ) */
+  CHAR_LEFT_CURLY_BRACE, /* { */
+  CHAR_RIGHT_CURLY_BRACE, /* } */
+  CHAR_LEFT_SQUARE_BRACKET, /* [ */
+  CHAR_RIGHT_SQUARE_BRACKET, /* ] */
+  CHAR_DOUBLE_QUOTE, /* " */
+  CHAR_SINGLE_QUOTE, /* ' */
+  CHAR_NO_BREAK_SPACE,
+  CHAR_ZERO_WIDTH_NOBREAK_SPACE
+} = constants$2;
+
+/**
+ * parse
+ */
+
+const parse$4 = (input, options = {}) => {
+  if (typeof input !== 'string') {
+    throw new TypeError('Expected a string');
+  }
+
+  let opts = options || {};
+  let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+  if (input.length > max) {
+    throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);
+  }
+
+  let ast = { type: 'root', input, nodes: [] };
+  let stack = [ast];
+  let block = ast;
+  let prev = ast;
+  let brackets = 0;
+  let length = input.length;
+  let index = 0;
+  let depth = 0;
+  let value;
+
+  /**
+   * Helpers
+   */
+
+  const advance = () => input[index++];
+  const push = node => {
+    if (node.type === 'text' && prev.type === 'dot') {
+      prev.type = 'text';
+    }
+
+    if (prev && prev.type === 'text' && node.type === 'text') {
+      prev.value += node.value;
+      return;
+    }
+
+    block.nodes.push(node);
+    node.parent = block;
+    node.prev = prev;
+    prev = node;
+    return node;
+  };
+
+  push({ type: 'bos' });
+
+  while (index < length) {
+    block = stack[stack.length - 1];
+    value = advance();
+
+    /**
+     * Invalid chars
+     */
+
+    if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) {
+      continue;
+    }
+
+    /**
+     * Escaped chars
+     */
+
+    if (value === CHAR_BACKSLASH) {
+      push({ type: 'text', value: (options.keepEscaping ? value : '') + advance() });
+      continue;
+    }
+
+    /**
+     * Right square bracket (literal): ']'
+     */
+
+    if (value === CHAR_RIGHT_SQUARE_BRACKET) {
+      push({ type: 'text', value: '\\' + value });
+      continue;
+    }
+
+    /**
+     * Left square bracket: '['
+     */
+
+    if (value === CHAR_LEFT_SQUARE_BRACKET) {
+      brackets++;
+      let next;
+
+      while (index < length && (next = advance())) {
+        value += next;
+
+        if (next === CHAR_LEFT_SQUARE_BRACKET) {
+          brackets++;
+          continue;
+        }
+
+        if (next === CHAR_BACKSLASH) {
+          value += advance();
+          continue;
+        }
+
+        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+          brackets--;
+
+          if (brackets === 0) {
+            break;
+          }
+        }
+      }
+
+      push({ type: 'text', value });
+      continue;
+    }
+
+    /**
+     * Parentheses
+     */
+
+    if (value === CHAR_LEFT_PARENTHESES) {
+      block = push({ type: 'paren', nodes: [] });
+      stack.push(block);
+      push({ type: 'text', value });
+      continue;
+    }
+
+    if (value === CHAR_RIGHT_PARENTHESES) {
+      if (block.type !== 'paren') {
+        push({ type: 'text', value });
+        continue;
+      }
+      block = stack.pop();
+      push({ type: 'text', value });
+      block = stack[stack.length - 1];
+      continue;
+    }
+
+    /**
+     * Quotes: '|"|`
+     */
+
+    if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) {
+      let open = value;
+      let next;
+
+      if (options.keepQuotes !== true) {
+        value = '';
+      }
+
+      while (index < length && (next = advance())) {
+        if (next === CHAR_BACKSLASH) {
+          value += next + advance();
+          continue;
+        }
+
+        if (next === open) {
+          if (options.keepQuotes === true) value += next;
+          break;
+        }
+
+        value += next;
+      }
+
+      push({ type: 'text', value });
+      continue;
+    }
+
+    /**
+     * Left curly brace: '{'
+     */
+
+    if (value === CHAR_LEFT_CURLY_BRACE) {
+      depth++;
+
+      let dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true;
+      let brace = {
+        type: 'brace',
+        open: true,
+        close: false,
+        dollar,
+        depth,
+        commas: 0,
+        ranges: 0,
+        nodes: []
+      };
+
+      block = push(brace);
+      stack.push(block);
+      push({ type: 'open', value });
+      continue;
+    }
+
+    /**
+     * Right curly brace: '}'
+     */
+
+    if (value === CHAR_RIGHT_CURLY_BRACE) {
+      if (block.type !== 'brace') {
+        push({ type: 'text', value });
+        continue;
+      }
+
+      let type = 'close';
+      block = stack.pop();
+      block.close = true;
+
+      push({ type, value });
+      depth--;
+
+      block = stack[stack.length - 1];
+      continue;
+    }
+
+    /**
+     * Comma: ','
+     */
+
+    if (value === CHAR_COMMA && depth > 0) {
+      if (block.ranges > 0) {
+        block.ranges = 0;
+        let open = block.nodes.shift();
+        block.nodes = [open, { type: 'text', value: stringify$1(block) }];
+      }
+
+      push({ type: 'comma', value });
+      block.commas++;
+      continue;
+    }
+
+    /**
+     * Dot: '.'
+     */
+
+    if (value === CHAR_DOT && depth > 0 && block.commas === 0) {
+      let siblings = block.nodes;
+
+      if (depth === 0 || siblings.length === 0) {
+        push({ type: 'text', value });
+        continue;
+      }
+
+      if (prev.type === 'dot') {
+        block.range = [];
+        prev.value += value;
+        prev.type = 'range';
+
+        if (block.nodes.length !== 3 && block.nodes.length !== 5) {
+          block.invalid = true;
+          block.ranges = 0;
+          prev.type = 'text';
+          continue;
+        }
+
+        block.ranges++;
+        block.args = [];
+        continue;
+      }
+
+      if (prev.type === 'range') {
+        siblings.pop();
+
+        let before = siblings[siblings.length - 1];
+        before.value += prev.value + value;
+        prev = before;
+        block.ranges--;
+        continue;
+      }
+
+      push({ type: 'dot', value });
+      continue;
+    }
+
+    /**
+     * Text
+     */
+
+    push({ type: 'text', value });
+  }
+
+  // Mark imbalanced braces and brackets as invalid
+  do {
+    block = stack.pop();
+
+    if (block.type !== 'root') {
+      block.nodes.forEach(node => {
+        if (!node.nodes) {
+          if (node.type === 'open') node.isOpen = true;
+          if (node.type === 'close') node.isClose = true;
+          if (!node.nodes) node.type = 'text';
+          node.invalid = true;
+        }
+      });
+
+      // get the location of the block on parent.nodes (block's siblings)
+      let parent = stack[stack.length - 1];
+      let index = parent.nodes.indexOf(block);
+      // replace the (invalid) block with it's nodes
+      parent.nodes.splice(index, 1, ...block.nodes);
+    }
+  } while (stack.length > 0);
+
+  push({ type: 'eos' });
+  return ast;
+};
+
+var parse_1 = parse$4;
+
+const stringify = stringify$4;
+const compile = compile_1;
+const expand = expand_1;
+const parse$3 = parse_1;
+
+/**
+ * Expand the given pattern or create a regex-compatible string.
+ *
+ * ```js
+ * const braces = require('braces');
+ * console.log(braces('{a,b,c}', { compile: true })); //=> ['(a|b|c)']
+ * console.log(braces('{a,b,c}')); //=> ['a', 'b', 'c']
+ * ```
+ * @param {String} `str`
+ * @param {Object} `options`
+ * @return {String}
+ * @api public
+ */
+
+const braces$1 = (input, options = {}) => {
+  let output = [];
+
+  if (Array.isArray(input)) {
+    for (let pattern of input) {
+      let result = braces$1.create(pattern, options);
+      if (Array.isArray(result)) {
+        output.push(...result);
+      } else {
+        output.push(result);
+      }
+    }
+  } else {
+    output = [].concat(braces$1.create(input, options));
+  }
+
+  if (options && options.expand === true && options.nodupes === true) {
+    output = [...new Set(output)];
+  }
+  return output;
+};
+
+/**
+ * Parse the given `str` with the given `options`.
+ *
+ * ```js
+ * // braces.parse(pattern, [, options]);
+ * const ast = braces.parse('a/{b,c}/d');
+ * console.log(ast);
+ * ```
+ * @param {String} pattern Brace pattern to parse
+ * @param {Object} options
+ * @return {Object} Returns an AST
+ * @api public
+ */
+
+braces$1.parse = (input, options = {}) => parse$3(input, options);
+
+/**
+ * Creates a braces string from an AST, or an AST node.
+ *
+ * ```js
+ * const braces = require('braces');
+ * let ast = braces.parse('foo/{a,b}/bar');
+ * console.log(stringify(ast.nodes[2])); //=> '{a,b}'
+ * ```
+ * @param {String} `input` Brace pattern or AST.
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
+ */
+
+braces$1.stringify = (input, options = {}) => {
+  if (typeof input === 'string') {
+    return stringify(braces$1.parse(input, options), options);
+  }
+  return stringify(input, options);
+};
+
+/**
+ * Compiles a brace pattern into a regex-compatible, optimized string.
+ * This method is called by the main [braces](#braces) function by default.
+ *
+ * ```js
+ * const braces = require('braces');
+ * console.log(braces.compile('a/{b,c}/d'));
+ * //=> ['a/(b|c)/d']
+ * ```
+ * @param {String} `input` Brace pattern or AST.
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
+ */
+
+braces$1.compile = (input, options = {}) => {
+  if (typeof input === 'string') {
+    input = braces$1.parse(input, options);
+  }
+  return compile(input, options);
+};
+
+/**
+ * Expands a brace pattern into an array. This method is called by the
+ * main [braces](#braces) function when `options.expand` is true. Before
+ * using this method it's recommended that you read the [performance notes](#performance))
+ * and advantages of using [.compile](#compile) instead.
+ *
+ * ```js
+ * const braces = require('braces');
+ * console.log(braces.expand('a/{b,c}/d'));
+ * //=> ['a/b/d', 'a/c/d'];
+ * ```
+ * @param {String} `pattern` Brace pattern
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
+ */
+
+braces$1.expand = (input, options = {}) => {
+  if (typeof input === 'string') {
+    input = braces$1.parse(input, options);
+  }
+
+  let result = expand(input, options);
+
+  // filter out empty strings if specified
+  if (options.noempty === true) {
+    result = result.filter(Boolean);
+  }
+
+  // filter out duplicates if specified
+  if (options.nodupes === true) {
+    result = [...new Set(result)];
+  }
+
+  return result;
+};
+
+/**
+ * Processes a brace pattern and returns either an expanded array
+ * (if `options.expand` is true), a highly optimized regex-compatible string.
+ * This method is called by the main [braces](#braces) function.
+ *
+ * ```js
+ * const braces = require('braces');
+ * console.log(braces.create('user-{200..300}/project-{a,b,c}-{1..10}'))
+ * //=> 'user-(20[0-9]|2[1-9][0-9]|300)/project-(a|b|c)-([1-9]|10)'
+ * ```
+ * @param {String} `pattern` Brace pattern
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
+ */
+
+braces$1.create = (input, options = {}) => {
+  if (input === '' || input.length < 3) {
+    return [input];
+  }
+
+ return options.expand !== true
+    ? braces$1.compile(input, options)
+    : braces$1.expand(input, options);
+};
+
+/**
+ * Expose "braces"
+ */
+
+var braces_1 = braces$1;
+
+const util$2 = require$$0$1;
+const braces = braces_1;
+const picomatch = picomatch$1;
+const utils$b = utils$h;
+const isEmptyString = val => val === '' || val === './';
+
+/**
+ * Returns an array of strings that match one or more glob patterns.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm(list, patterns[, options]);
+ *
+ * console.log(mm(['a.js', 'a.txt'], ['*.js']));
+ * //=> [ 'a.js' ]
+ * ```
+ * @param {String|Array<string>} `list` List of strings to match.
+ * @param {String|Array<string>} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options)
+ * @return {Array} Returns an array of matches
+ * @summary false
+ * @api public
+ */
+
+const micromatch$1 = (list, patterns, options) => {
+  patterns = [].concat(patterns);
+  list = [].concat(list);
+
+  let omit = new Set();
+  let keep = new Set();
+  let items = new Set();
+  let negatives = 0;
+
+  let onResult = state => {
+    items.add(state.output);
+    if (options && options.onResult) {
+      options.onResult(state);
+    }
+  };
+
+  for (let i = 0; i < patterns.length; i++) {
+    let isMatch = picomatch(String(patterns[i]), { ...options, onResult }, true);
+    let negated = isMatch.state.negated || isMatch.state.negatedExtglob;
+    if (negated) negatives++;
+
+    for (let item of list) {
+      let matched = isMatch(item, true);
+
+      let match = negated ? !matched.isMatch : matched.isMatch;
+      if (!match) continue;
+
+      if (negated) {
+        omit.add(matched.output);
+      } else {
+        omit.delete(matched.output);
+        keep.add(matched.output);
+      }
+    }
+  }
+
+  let result = negatives === patterns.length ? [...items] : [...keep];
+  let matches = result.filter(item => !omit.has(item));
+
+  if (options && matches.length === 0) {
+    if (options.failglob === true) {
+      throw new Error(`No matches found for "${patterns.join(', ')}"`);
     }
 
-    if (str[index] === '\\') {
-      var open = str[index + 1];
-      index += 2;
-      var close = chars[open];
+    if (options.nonull === true || options.nullglob === true) {
+      return options.unescape ? patterns.map(p => p.replace(/\\/g, '')) : patterns;
+    }
+  }
 
-      if (close) {
-        var n = str.indexOf(close, index);
-        if (n !== -1) {
-          index = n + 1;
-        }
-      }
+  return matches;
+};
 
-      if (str[index] === '!') {
-        return true;
-      }
-    } else {
-      index++;
+/**
+ * Backwards compatibility
+ */
+
+micromatch$1.match = micromatch$1;
+
+/**
+ * Returns a matcher function from the given glob `pattern` and `options`.
+ * The returned function takes a string to match as its only argument and returns
+ * true if the string is a match.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.matcher(pattern[, options]);
+ *
+ * const isMatch = mm.matcher('*.!(*a)');
+ * console.log(isMatch('a.a')); //=> false
+ * console.log(isMatch('a.b')); //=> true
+ * ```
+ * @param {String} `pattern` Glob pattern
+ * @param {Object} `options`
+ * @return {Function} Returns a matcher function.
+ * @api public
+ */
+
+micromatch$1.matcher = (pattern, options) => picomatch(pattern, options);
+
+/**
+ * Returns true if **any** of the given glob `patterns` match the specified `string`.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.isMatch(string, patterns[, options]);
+ *
+ * console.log(mm.isMatch('a.a', ['b.*', '*.a'])); //=> true
+ * console.log(mm.isMatch('a.a', 'b.*')); //=> false
+ * ```
+ * @param {String} `str` The string to test.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `[options]` See available [options](#options).
+ * @return {Boolean} Returns true if any patterns match `str`
+ * @api public
+ */
+
+micromatch$1.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+
+/**
+ * Backwards compatibility
+ */
+
+micromatch$1.any = micromatch$1.isMatch;
+
+/**
+ * Returns a list of strings that _**do not match any**_ of the given `patterns`.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.not(list, patterns[, options]);
+ *
+ * console.log(mm.not(['a.a', 'b.b', 'c.c'], '*.a'));
+ * //=> ['b.b', 'c.c']
+ * ```
+ * @param {Array} `list` Array of strings to match.
+ * @param {String|Array} `patterns` One or more glob pattern to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Array} Returns an array of strings that **do not match** the given patterns.
+ * @api public
+ */
+
+micromatch$1.not = (list, patterns, options = {}) => {
+  patterns = [].concat(patterns).map(String);
+  let result = new Set();
+  let items = [];
+
+  let onResult = state => {
+    if (options.onResult) options.onResult(state);
+    items.push(state.output);
+  };
+
+  let matches = new Set(micromatch$1(list, patterns, { ...options, onResult }));
+
+  for (let item of items) {
+    if (!matches.has(item)) {
+      result.add(item);
     }
   }
-  return false;
+  return [...result];
 };
 
-var relaxedCheck = function(str) {
-  if (str[0] === '!') {
-    return true;
+/**
+ * Returns true if the given `string` contains the given pattern. Similar
+ * to [.isMatch](#isMatch) but the pattern can match any part of the string.
+ *
+ * ```js
+ * var mm = require('micromatch');
+ * // mm.contains(string, pattern[, options]);
+ *
+ * console.log(mm.contains('aa/bb/cc', '*b'));
+ * //=> true
+ * console.log(mm.contains('aa/bb/cc', '*d'));
+ * //=> false
+ * ```
+ * @param {String} `str` The string to match.
+ * @param {String|Array} `patterns` Glob pattern to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Boolean} Returns true if any of the patterns matches any part of `str`.
+ * @api public
+ */
+
+micromatch$1.contains = (str, pattern, options) => {
+  if (typeof str !== 'string') {
+    throw new TypeError(`Expected a string: "${util$2.inspect(str)}"`);
   }
-  var index = 0;
-  while (index < str.length) {
-    if (/[*?{}()[\]]/.test(str[index])) {
+
+  if (Array.isArray(pattern)) {
+    return pattern.some(p => micromatch$1.contains(str, p, options));
+  }
+
+  if (typeof pattern === 'string') {
+    if (isEmptyString(str) || isEmptyString(pattern)) {
+      return false;
+    }
+
+    if (str.includes(pattern) || (str.startsWith('./') && str.slice(2).includes(pattern))) {
       return true;
     }
+  }
 
-    if (str[index] === '\\') {
-      var open = str[index + 1];
-      index += 2;
-      var close = chars[open];
+  return micromatch$1.isMatch(str, pattern, { ...options, contains: true });
+};
 
-      if (close) {
-        var n = str.indexOf(close, index);
-        if (n !== -1) {
-          index = n + 1;
-        }
-      }
+/**
+ * Filter the keys of the given object with the given `glob` pattern
+ * and `options`. Does not attempt to match nested keys. If you need this feature,
+ * use [glob-object][] instead.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.matchKeys(object, patterns[, options]);
+ *
+ * const obj = { aa: 'a', ab: 'b', ac: 'c' };
+ * console.log(mm.matchKeys(obj, '*b'));
+ * //=> { ab: 'b' }
+ * ```
+ * @param {Object} `object` The object with keys to filter.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Object} Returns an object with only keys that match the given patterns.
+ * @api public
+ */
 
-      if (str[index] === '!') {
-        return true;
-      }
-    } else {
-      index++;
+micromatch$1.matchKeys = (obj, patterns, options) => {
+  if (!utils$b.isObject(obj)) {
+    throw new TypeError('Expected the first argument to be an object');
+  }
+  let keys = micromatch$1(Object.keys(obj), patterns, options);
+  let res = {};
+  for (let key of keys) res[key] = obj[key];
+  return res;
+};
+
+/**
+ * Returns true if some of the strings in the given `list` match any of the given glob `patterns`.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.some(list, patterns[, options]);
+ *
+ * console.log(mm.some(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
+ * // true
+ * console.log(mm.some(['foo.js'], ['*.js', '!foo.js']));
+ * // false
+ * ```
+ * @param {String|Array} `list` The string or array of strings to test. Returns as soon as the first match is found.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Boolean} Returns true if any `patterns` matches any of the strings in `list`
+ * @api public
+ */
+
+micromatch$1.some = (list, patterns, options) => {
+  let items = [].concat(list);
+
+  for (let pattern of [].concat(patterns)) {
+    let isMatch = picomatch(String(pattern), options);
+    if (items.some(item => isMatch(item))) {
+      return true;
     }
   }
   return false;
 };
 
-var isGlob$1 = function isGlob(str, options) {
-  if (typeof str !== 'string' || str === '') {
-    return false;
-  }
+/**
+ * Returns true if every string in the given `list` matches
+ * any of the given glob `patterns`.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.every(list, patterns[, options]);
+ *
+ * console.log(mm.every('foo.js', ['foo.js']));
+ * // true
+ * console.log(mm.every(['foo.js', 'bar.js'], ['*.js']));
+ * // true
+ * console.log(mm.every(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
+ * // false
+ * console.log(mm.every(['foo.js'], ['*.js', '!foo.js']));
+ * // false
+ * ```
+ * @param {String|Array} `list` The string or array of strings to test.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Boolean} Returns true if all `patterns` matches all of the strings in `list`
+ * @api public
+ */
 
-  if (isExtglob(str)) {
-    return true;
+micromatch$1.every = (list, patterns, options) => {
+  let items = [].concat(list);
+
+  for (let pattern of [].concat(patterns)) {
+    let isMatch = picomatch(String(pattern), options);
+    if (!items.every(item => isMatch(item))) {
+      return false;
+    }
   }
+  return true;
+};
 
-  var check = strictCheck;
+/**
+ * Returns true if **all** of the given `patterns` match
+ * the specified string.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.all(string, patterns[, options]);
+ *
+ * console.log(mm.all('foo.js', ['foo.js']));
+ * // true
+ *
+ * console.log(mm.all('foo.js', ['*.js', '!foo.js']));
+ * // false
+ *
+ * console.log(mm.all('foo.js', ['*.js', 'foo.js']));
+ * // true
+ *
+ * console.log(mm.all('foo.js', ['*.js', 'f*', '*o*', '*o.js']));
+ * // true
+ * ```
+ * @param {String|Array} `str` The string to test.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Boolean} Returns true if any patterns match `str`
+ * @api public
+ */
 
-  // optionally relax check
-  if (options && options.strict === false) {
-    check = relaxedCheck;
+micromatch$1.all = (str, patterns, options) => {
+  if (typeof str !== 'string') {
+    throw new TypeError(`Expected a string: "${util$2.inspect(str)}"`);
   }
 
-  return check(str);
+  return [].concat(patterns).every(p => picomatch(p, options)(str));
 };
 
-var isGlob = isGlob$1;
-var pathPosixDirname = p.posix.dirname;
-var isWin32 = require$$0.platform() === 'win32';
+/**
+ * Returns an array of matches captured by `pattern` in `string, or `null` if the pattern did not match.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.capture(pattern, string[, options]);
+ *
+ * console.log(mm.capture('test/*.js', 'test/foo.js'));
+ * //=> ['foo']
+ * console.log(mm.capture('test/*.js', 'foo/bar.css'));
+ * //=> null
+ * ```
+ * @param {String} `glob` Glob pattern to use for matching.
+ * @param {String} `input` String to match
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Array|null} Returns an array of captures if the input matches the glob pattern, otherwise `null`.
+ * @api public
+ */
 
-var slash = '/';
-var backslash = /\\/g;
-var enclosure = /[\{\[].*[\}\]]$/;
-var globby = /(^|[^\\])([\{\[]|\([^\)]+$)/;
-var escaped = /\\([\!\*\?\|\[\]\(\)\{\}])/g;
+micromatch$1.capture = (glob, input, options) => {
+  let posix = utils$b.isWindows(options);
+  let regex = picomatch.makeRe(String(glob), { ...options, capture: true });
+  let match = regex.exec(posix ? utils$b.toPosixSlashes(input) : input);
+
+  if (match) {
+    return match.slice(1).map(v => v === void 0 ? '' : v);
+  }
+};
 
 /**
- * @param {string} str
- * @param {Object} opts
- * @param {boolean} [opts.flipBackslashes=true]
- * @returns {string}
+ * Create a regular expression from the given glob `pattern`.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.makeRe(pattern[, options]);
+ *
+ * console.log(mm.makeRe('*.js'));
+ * //=> /^(?:(\.[\\\/])?(?!\.)(?=.)[^\/]*?\.js)$/
+ * ```
+ * @param {String} `pattern` A glob pattern to convert to regex.
+ * @param {Object} `options`
+ * @return {RegExp} Returns a regex created from the given pattern.
+ * @api public
  */
-var globParent$1 = function globParent(str, opts) {
-  var options = Object.assign({ flipBackslashes: true }, opts);
 
-  // flip windows path separators
-  if (options.flipBackslashes && isWin32 && str.indexOf(slash) < 0) {
-    str = str.replace(backslash, slash);
-  }
+micromatch$1.makeRe = (...args) => picomatch.makeRe(...args);
 
-  // special case for strings ending in enclosure containing path separator
-  if (enclosure.test(str)) {
-    str += slash;
+/**
+ * Scan a glob pattern to separate the pattern into segments. Used
+ * by the [split](#split) method.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * const state = mm.scan(pattern[, options]);
+ * ```
+ * @param {String} `pattern`
+ * @param {Object} `options`
+ * @return {Object} Returns an object with
+ * @api public
+ */
+
+micromatch$1.scan = (...args) => picomatch.scan(...args);
+
+/**
+ * Parse a glob pattern to create the source string for a regular
+ * expression.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * const state = mm.parse(pattern[, options]);
+ * ```
+ * @param {String} `glob`
+ * @param {Object} `options`
+ * @return {Object} Returns an object with useful properties and output to be used as regex source string.
+ * @api public
+ */
+
+micromatch$1.parse = (patterns, options) => {
+  let res = [];
+  for (let pattern of [].concat(patterns || [])) {
+    for (let str of braces(String(pattern), options)) {
+      res.push(picomatch.parse(str, options));
+    }
   }
+  return res;
+};
 
-  // preserves full path in case of trailing path separator
-  str += 'a';
+/**
+ * Process the given brace `pattern`.
+ *
+ * ```js
+ * const { braces } = require('micromatch');
+ * console.log(braces('foo/{a,b,c}/bar'));
+ * //=> [ 'foo/(a|b|c)/bar' ]
+ *
+ * console.log(braces('foo/{a,b,c}/bar', { expand: true }));
+ * //=> [ 'foo/a/bar', 'foo/b/bar', 'foo/c/bar' ]
+ * ```
+ * @param {String} `pattern` String with brace pattern to process.
+ * @param {Object} `options` Any [options](#options) to change how expansion is performed. See the [braces][] library for all available options.
+ * @return {Array}
+ * @api public
+ */
 
-  // remove path parts that are globby
-  do {
-    str = pathPosixDirname(str);
-  } while (isGlob(str) || globby.test(str));
+micromatch$1.braces = (pattern, options) => {
+  if (typeof pattern !== 'string') throw new TypeError('Expected a string');
+  if ((options && options.nobrace === true) || !/\{.*\}/.test(pattern)) {
+    return [pattern];
+  }
+  return braces(pattern, options);
+};
 
-  // remove escape chars and return result
-  return str.replace(escaped, '$1');
+/**
+ * Expand braces
+ */
+
+micromatch$1.braceExpand = (pattern, options) => {
+  if (typeof pattern !== 'string') throw new TypeError('Expected a string');
+  return micromatch$1.braces(pattern, { ...options, expand: true });
 };
 
+/**
+ * Expose micromatch
+ */
+
+var micromatch_1 = micromatch$1;
+
 Object.defineProperty(pattern$1, "__esModule", { value: true });
 pattern$1.removeDuplicateSlashes = pattern$1.matchAny = pattern$1.convertPatternsToRe = pattern$1.makeRe = pattern$1.getPatternParts = pattern$1.expandBraceExpansion = pattern$1.expandPatternsWithBraceExpansion = pattern$1.isAffectDepthOfReadingPattern = pattern$1.endsWithSlashGlobStar = pattern$1.hasGlobStar = pattern$1.getBaseDirectory = pattern$1.isPatternRelatedToParentDirectory = pattern$1.getPatternsOutsideCurrentDirectory = pattern$1.getPatternsInsideCurrentDirectory = pattern$1.getPositivePatterns = pattern$1.getNegativePatterns = pattern$1.isPositivePattern = pattern$1.isNegativePattern = pattern$1.convertToNegativePattern = pattern$1.convertToPositivePattern = pattern$1.isDynamicPattern = pattern$1.isStaticPattern = void 0;
 const path$5 = p;
@@ -934,7 +2533,7 @@ var stream$4 = {};
  * Copyright (c) 2014-2020 Teambition
  * Licensed under the MIT license.
  */
-const Stream = require$$0$1;
+const Stream = require$$0$2;
 const PassThrough = Stream.PassThrough;
 const slice = Array.prototype.slice;
 
@@ -1101,26 +2700,26 @@ function isEmpty(input) {
 }
 string$1.isEmpty = isEmpty;
 
-Object.defineProperty(utils$b, "__esModule", { value: true });
-utils$b.string = utils$b.stream = utils$b.pattern = utils$b.path = utils$b.fs = utils$b.errno = utils$b.array = void 0;
+Object.defineProperty(utils$g, "__esModule", { value: true });
+utils$g.string = utils$g.stream = utils$g.pattern = utils$g.path = utils$g.fs = utils$g.errno = utils$g.array = void 0;
 const array = array$1;
-utils$b.array = array;
+utils$g.array = array;
 const errno = errno$1;
-utils$b.errno = errno;
+utils$g.errno = errno;
 const fs$6 = fs$7;
-utils$b.fs = fs$6;
+utils$g.fs = fs$6;
 const path$4 = path$7;
-utils$b.path = path$4;
+utils$g.path = path$4;
 const pattern = pattern$1;
-utils$b.pattern = pattern;
+utils$g.pattern = pattern;
 const stream$3 = stream$4;
-utils$b.stream = stream$3;
+utils$g.stream = stream$3;
 const string = string$1;
-utils$b.string = string;
+utils$g.string = string;
 
 Object.defineProperty(tasks, "__esModule", { value: true });
 tasks.convertPatternGroupToTask = tasks.convertPatternGroupsToTasks = tasks.groupPatternsByBaseDirectory = tasks.getNegativePatternsAsPositive = tasks.getPositivePatterns = tasks.convertPatternsToTasks = tasks.generate = void 0;
-const utils$a = utils$b;
+const utils$a = utils$g;
 function generate(input, settings) {
     const patterns = processPatterns(input, settings);
     const ignore = processPatterns(settings.ignore, settings);
@@ -1314,7 +2913,7 @@ var fs$5 = {};
 (function (exports) {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
-	const fs = require$$0$2;
+	const fs = require$$0$3;
 	exports.FILE_SYSTEM_ADAPTER = {
 	    lstat: fs.lstat,
 	    stat: fs.stat,
@@ -1665,7 +3264,7 @@ var fs$1 = {};
 (function (exports) {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
-	const fs = require$$0$2;
+	const fs = require$$0$3;
 	exports.FILE_SYSTEM_ADAPTER = {
 	    lstat: fs.lstat,
 	    stat: fs.stat,
@@ -1790,8 +3389,8 @@ function fastqueue (context, worker, concurrency) {
 
   var self = {
     push: push,
-    drain: noop$1,
-    saturated: noop$1,
+    drain: noop,
+    saturated: noop,
     pause: pause,
     paused: false,
     concurrency: concurrency,
@@ -1801,7 +3400,7 @@ function fastqueue (context, worker, concurrency) {
     length: length,
     getQueue: getQueue,
     unshift: unshift,
-    empty: noop$1,
+    empty: noop,
     kill: kill,
     killAndDrain: killAndDrain,
     error: error
@@ -1860,7 +3459,7 @@ function fastqueue (context, worker, concurrency) {
     current.context = context;
     current.release = release;
     current.value = value;
-    current.callback = done || noop$1;
+    current.callback = done || noop;
     current.errorHandler = errorHandler;
 
     if (_running === self.concurrency || self.paused) {
@@ -1884,7 +3483,7 @@ function fastqueue (context, worker, concurrency) {
     current.context = context;
     current.release = release;
     current.value = value;
-    current.callback = done || noop$1;
+    current.callback = done || noop;
 
     if (_running === self.concurrency || self.paused) {
       if (queueHead) {
@@ -1928,14 +3527,14 @@ function fastqueue (context, worker, concurrency) {
   function kill () {
     queueHead = null;
     queueTail = null;
-    self.drain = noop$1;
+    self.drain = noop;
   }
 
   function killAndDrain () {
     queueHead = null;
     queueTail = null;
     self.drain();
-    self.drain = noop$1;
+    self.drain = noop;
   }
 
   function error (handler) {
@@ -1943,13 +3542,13 @@ function fastqueue (context, worker, concurrency) {
   }
 }
 
-function noop$1 () {}
+function noop () {}
 
 function Task () {
   this.value = null;
-  this.callback = noop$1;
+  this.callback = noop;
   this.next = null;
-  this.release = noop$1;
+  this.release = noop;
   this.context = null;
   this.errorHandler = null;
 
@@ -1960,7 +3559,7 @@ function Task () {
     var errorHandler = self.errorHandler;
     var val = self.value;
     self.value = null;
-    self.callback = noop$1;
+    self.callback = noop;
     if (self.errorHandler) {
       errorHandler(err, val);
     }
@@ -2008,7 +3607,7 @@ function queueAsPromised (context, worker, concurrency) {
     // Let's fork the promise chain to
     // make the error bubble up to the user but
     // not lead to a unhandledRejection
-    p.catch(noop$1);
+    p.catch(noop);
 
     return p
   }
@@ -2027,7 +3626,7 @@ function queueAsPromised (context, worker, concurrency) {
     // Let's fork the promise chain to
     // make the error bubble up to the user but
     // not lead to a unhandledRejection
-    p.catch(noop$1);
+    p.catch(noop);
 
     return p
   }
@@ -2098,7 +3697,7 @@ let Reader$1 = class Reader {
 reader$1.default = Reader$1;
 
 Object.defineProperty(async$4, "__esModule", { value: true });
-const events_1 = require$$0$3;
+const events_1 = require$$0$4;
 const fsScandir$2 = out$2;
 const fastq = queueExports;
 const common$1 = common$3;
@@ -2227,7 +3826,7 @@ function callSuccessCallback(callback, entries) {
 var stream$2 = {};
 
 Object.defineProperty(stream$2, "__esModule", { value: true });
-const stream_1$5 = require$$0$1;
+const stream_1$5 = require$$0$2;
 const async_1$3 = async$4;
 class StreamProvider {
     constructor(_root, _settings) {
@@ -2404,7 +4003,7 @@ var reader = {};
 Object.defineProperty(reader, "__esModule", { value: true });
 const path$1 = p;
 const fsStat$2 = out$1;
-const utils$6 = utils$b;
+const utils$6 = utils$g;
 class Reader {
     constructor(_settings) {
         this._settings = _settings;
@@ -2437,7 +4036,7 @@ reader.default = Reader;
 var stream$1 = {};
 
 Object.defineProperty(stream$1, "__esModule", { value: true });
-const stream_1$3 = require$$0$1;
+const stream_1$3 = require$$0$2;
 const fsStat$1 = out$1;
 const fsWalk$2 = out$3;
 const reader_1$2 = reader;
@@ -2535,7 +4134,7 @@ var partial = {};
 var matcher = {};
 
 Object.defineProperty(matcher, "__esModule", { value: true });
-const utils$5 = utils$b;
+const utils$5 = utils$g;
 class Matcher {
     constructor(_patterns, _settings, _micromatchOptions) {
         this._patterns = _patterns;
@@ -2618,7 +4217,7 @@ class PartialMatcher extends matcher_1.default {
 partial.default = PartialMatcher;
 
 Object.defineProperty(deep, "__esModule", { value: true });
-const utils$4 = utils$b;
+const utils$4 = utils$g;
 const partial_1 = partial;
 class DeepFilter {
     constructor(_settings, _micromatchOptions) {
@@ -2682,7 +4281,7 @@ deep.default = DeepFilter;
 var entry$1 = {};
 
 Object.defineProperty(entry$1, "__esModule", { value: true });
-const utils$3 = utils$b;
+const utils$3 = utils$g;
 class EntryFilter {
     constructor(_settings, _micromatchOptions) {
         this._settings = _settings;
@@ -2747,7 +4346,7 @@ entry$1.default = EntryFilter;
 var error = {};
 
 Object.defineProperty(error, "__esModule", { value: true });
-const utils$2 = utils$b;
+const utils$2 = utils$g;
 class ErrorFilter {
     constructor(_settings) {
         this._settings = _settings;
@@ -2764,7 +4363,7 @@ error.default = ErrorFilter;
 var entry = {};
 
 Object.defineProperty(entry, "__esModule", { value: true });
-const utils$1 = utils$b;
+const utils$1 = utils$g;
 class EntryTransformer {
     constructor(_settings) {
         this._settings = _settings;
@@ -2863,7 +4462,7 @@ async$7.default = ProviderAsync;
 var stream = {};
 
 Object.defineProperty(stream, "__esModule", { value: true });
-const stream_1$1 = require$$0$1;
+const stream_1$1 = require$$0$2;
 const stream_2 = stream$1;
 const provider_1$1 = provider;
 class ProviderStream extends provider_1$1.default {
@@ -2968,7 +4567,7 @@ var settings = {};
 (function (exports) {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
-	const fs = require$$0$2;
+	const fs = require$$0$3;
 	const os = require$$0;
 	/**
 	 * The `os.cpus` method can return zero. We expect the number of cores to be greater than zero.
@@ -3031,7 +4630,7 @@ const async_1 = async$7;
 const stream_1 = stream;
 const sync_1 = sync$1;
 const settings_1 = settings;
-const utils = utils$b;
+const utils = utils$g;
 async function FastGlob(source, options) {
     assertPatternsInput(source);
     const works = getWorks(source, async_1.default, options);
@@ -3128,113 +4727,6 @@ var out = FastGlob;
 
 var fg = /*@__PURE__*/getDefaultExportFromCjs(out);
 
-/// <reference types="../types/index.d.ts" />
-
-// (c) 2020-present Andrea Giammarchi
-
-const {parse: $parse, stringify: $stringify} = JSON;
-const {keys: keys$1} = Object;
-
-const Primitive = String;   // it could be Number
-const primitive = 'string'; // it could be 'number'
-
-const ignore = {};
-const object = 'object';
-
-const noop = (_, value) => value;
-
-const primitives = value => (
-  value instanceof Primitive ? Primitive(value) : value
-);
-
-const Primitives = (_, value) => (
-  typeof value === primitive ? new Primitive(value) : value
-);
-
-const revive = (input, parsed, output, $) => {
-  const lazy = [];
-  for (let ke = keys$1(output), {length} = ke, y = 0; y < length; y++) {
-    const k = ke[y];
-    const value = output[k];
-    if (value instanceof Primitive) {
-      const tmp = input[value];
-      if (typeof tmp === object && !parsed.has(tmp)) {
-        parsed.add(tmp);
-        output[k] = ignore;
-        lazy.push({k, a: [input, parsed, tmp, $]});
-      }
-      else
-        output[k] = $.call(output, k, tmp);
-    }
-    else if (output[k] !== ignore)
-      output[k] = $.call(output, k, value);
-  }
-  for (let {length} = lazy, i = 0; i < length; i++) {
-    const {k, a} = lazy[i];
-    output[k] = $.call(output, k, revive.apply(null, a));
-  }
-  return output;
-};
-
-const set = (known, input, value) => {
-  const index = Primitive(input.push(value) - 1);
-  known.set(value, index);
-  return index;
-};
-
-/**
- * Converts a specialized flatted string into a JS value.
- * @param {string} text
- * @param {(this: any, key: string, value: any) => any} [reviver]
- * @returns {any}
- */
-const parse$3 = (text, reviver) => {
-  const input = $parse(text, Primitives).map(primitives);
-  const value = input[0];
-  const $ = reviver || noop;
-  const tmp = typeof value === object && value ?
-              revive(input, new Set, value, $) :
-              value;
-  return $.call({'': tmp}, '', tmp);
-};
-
-/**
- * Converts a JS value into a specialized flatted string.
- * @param {any} value
- * @param {((this: any, key: string, value: any) => any) | (string | number)[] | null | undefined} [replacer]
- * @param {string | number | undefined} [space]
- * @returns {string}
- */
-const stringify = (value, replacer, space) => {
-  const $ = replacer && typeof replacer === object ?
-            (k, v) => (k === '' || -1 < replacer.indexOf(k) ? v : void 0) :
-            (replacer || noop);
-  const known = new Map;
-  const input = [];
-  const output = [];
-  let i = +set(known, input, $.call({'': value}, '', value));
-  let firstRun = !i;
-  while (i < input.length) {
-    firstRun = true;
-    output[i] = $stringify(input[i++], replace, space);
-  }
-  return '[' + output.join(',') + ']';
-  function replace(key, value) {
-    if (firstRun) {
-      firstRun = !firstRun;
-      return value;
-    }
-    const after = $.call(this, key, value);
-    switch (typeof after) {
-      case object:
-        if (after === null) return after;
-      case primitive:
-        return known.get(after) || set(known, input, after);
-    }
-    return after;
-  }
-};
-
 var bufferUtil$1 = {exports: {}};
 
 var constants = {
@@ -3437,7 +4929,7 @@ let Limiter$1 = class Limiter {
 
 var limiter = Limiter$1;
 
-const zlib = require$$0$4;
+const zlib = require$$0$5;
 
 const bufferUtil = bufferUtilExports;
 const Limiter = limiter;
@@ -3954,7 +5446,7 @@ var validation = {exports: {}};
 
 var isValidUTF8_1;
 
-const { isUtf8 } = require$$0$5;
+const { isUtf8 } = require$$0$6;
 
 //
 // Allowed token characters:
@@ -4085,7 +5577,7 @@ if (isUtf8) {
 
 var validationExports = validation.exports;
 
-const { Writable } = require$$0$1;
+const { Writable } = require$$0$2;
 
 const PerMessageDeflate$3 = permessageDeflate;
 const {
@@ -5757,7 +7249,7 @@ var extension$1 = { format: format$1, parse: parse$2 };
 
 /* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex|Readable$", "caughtErrors": "none" }] */
 
-const EventEmitter$1 = require$$0$3;
+const EventEmitter$1 = require$$0$4;
 const https = require$$1$1;
 const http$1 = require$$2;
 const net = require$$3;
@@ -7152,7 +8644,7 @@ var subprotocol$1 = { parse };
 
 /* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex$", "caughtErrors": "none" }] */
 
-const EventEmitter = require$$0$3;
+const EventEmitter = require$$0$4;
 const http = require$$2;
 const { createHash } = require$$1;
 
@@ -7689,9 +9181,8 @@ function abortHandshakeOrEmitwsClientError(server, req, socket, code, message) {
 
 var WebSocketServer$1 = /*@__PURE__*/getDefaultExportFromCjs(websocketServer);
 
-function setup(vitestOrWorkspace, _server) {
+function setup(ctx, _server) {
   var _a;
-  const ctx = "ctx" in vitestOrWorkspace ? vitestOrWorkspace.ctx : vitestOrWorkspace;
   const wss = new WebSocketServer$1({ noServer: true });
   const clients = /* @__PURE__ */ new Map();
   const server = _server || ctx.server;
@@ -7706,16 +9197,9 @@ function setup(vitestOrWorkspace, _server) {
       setupClient(ws);
     });
   });
-  function checkFileAccess(path) {
-    if (!isFileServingAllowed(path, server))
-      throw new Error(`Access denied to "${path}". See Vite config documentation for "server.fs": https://vitejs.dev/config/server-options.html#server-fs-strict.`);
-  }
   function setupClient(ws) {
     const rpc = createBirpc(
       {
-        async onUnhandledError(error, type) {
-          ctx.state.catchError(error, type);
-        },
         async onCollected(files) {
           ctx.state.collectFiles(files);
           await ctx.report("onCollected", files);
@@ -7724,30 +9208,11 @@ function setup(vitestOrWorkspace, _server) {
           ctx.state.updateTasks(packs);
           await ctx.report("onTaskUpdate", packs);
         },
-        onAfterSuiteRun(meta) {
-          var _a2;
-          (_a2 = ctx.coverageProvider) == null ? void 0 : _a2.onAfterSuiteRun(meta);
-        },
-        getFiles() {
-          return ctx.state.getFiles();
-        },
-        getPaths() {
-          return ctx.state.getPaths();
-        },
-        sendLog(log) {
-          return ctx.report("onUserConsoleLog", log);
-        },
-        resolveSnapshotPath(testPath) {
-          return ctx.snapshot.resolvePath(testPath);
-        },
-        resolveSnapshotRawPath(testPath, rawPath) {
-          return ctx.snapshot.resolveRawPath(testPath, rawPath);
+        getFiles() {
+          return ctx.state.getFiles();
         },
-        async readSnapshotFile(snapshotPath) {
-          checkFileAccess(snapshotPath);
-          if (!existsSync(snapshotPath))
-            return null;
-          return promises$1.readFile(snapshotPath, "utf-8");
+        getPaths() {
+          return ctx.state.getPaths();
         },
         async readTestFile(id) {
           if (!ctx.state.filesMap.has(id) || !existsSync(id))
@@ -7759,35 +9224,15 @@ function setup(vitestOrWorkspace, _server) {
             throw new Error(`Test file "${id}" was not registered, so it cannot be updated using the API.`);
           return promises$1.writeFile(id, content, "utf-8");
         },
-        async saveSnapshotFile(id, content) {
-          checkFileAccess(id);
-          await promises$1.mkdir(dirname(id), { recursive: true });
-          return promises$1.writeFile(id, content, "utf-8");
-        },
-        async removeSnapshotFile(id) {
-          checkFileAccess(id);
-          if (!existsSync(id))
-            throw new Error(`Snapshot file "${id}" does not exist.`);
-          return promises$1.unlink(id);
-        },
-        snapshotSaved(snapshot) {
-          ctx.snapshot.add(snapshot);
-        },
         async rerun(files) {
           await ctx.rerunFiles(files);
         },
         getConfig() {
-          return vitestOrWorkspace.config;
-        },
-        async getBrowserFileSourceMap(id) {
-          var _a2, _b;
-          if (!("ctx" in vitestOrWorkspace))
-            return void 0;
-          const mod = (_a2 = vitestOrWorkspace.browser) == null ? void 0 : _a2.moduleGraph.getModuleById(id);
-          return (_b = mod == null ? void 0 : mod.transformResult) == null ? void 0 : _b.map;
+          return ctx.config;
         },
-        async getTransformResult(id) {
-          const result = await ctx.vitenode.transformRequest(id);
+        async getTransformResult(projectName, id, browser = false) {
+          const project = ctx.getProjectByName(projectName);
+          const result = browser ? await project.browser.transformRequest(id) : await project.vitenode.transformRequest(id);
           if (result) {
             try {
               result.source = result.source || await promises$1.readFile(id, "utf-8");
@@ -7796,59 +9241,36 @@ function setup(vitestOrWorkspace, _server) {
             return result;
           }
         },
-        async getModuleGraph(id) {
-          return getModuleGraph(ctx, id);
+        async getModuleGraph(project, id, browser) {
+          return getModuleGraph(ctx, project, id, browser);
         },
         updateSnapshot(file) {
           if (!file)
             return ctx.updateSnapshot();
           return ctx.updateSnapshot([file.filepath]);
         },
-        onCancel(reason) {
-          ctx.cancelCurrentRun(reason);
-        },
-        debug(...args) {
-          ctx.logger.console.debug(...args);
-        },
-        getCountOfFailedTests() {
-          return ctx.state.getCountOfFailedTests();
-        },
         getUnhandledErrors() {
           return ctx.state.getUnhandledErrors();
         },
-        // TODO: have a separate websocket conection for private browser API
-        getBrowserFiles() {
-          var _a2;
-          if (!("ctx" in vitestOrWorkspace))
-            throw new Error("`getBrowserTestFiles` is only available in the browser API");
-          return ((_a2 = vitestOrWorkspace.browserState) == null ? void 0 : _a2.files) ?? [];
-        },
-        finishBrowserTests() {
-          var _a2;
-          if (!("ctx" in vitestOrWorkspace))
-            throw new Error("`finishBrowserTests` is only available in the browser API");
-          return (_a2 = vitestOrWorkspace.browserState) == null ? void 0 : _a2.resolve();
-        },
-        getProvidedContext() {
-          return "ctx" in vitestOrWorkspace ? vitestOrWorkspace.getProvidedContext() : {};
-        },
         async getTestFiles() {
           const spec = await ctx.globTestFiles();
-          return spec.map(([project, file]) => [project.getName(), file]);
+          return spec.map(([project, file]) => [{
+            name: project.config.name,
+            root: project.config.root
+          }, file]);
         }
       },
       {
         post: (msg) => ws.send(msg),
         on: (fn) => ws.on("message", fn),
-        eventNames: ["onUserConsoleLog", "onFinished", "onFinishedReportCoverage", "onCollected", "onCancel", "onTaskUpdate"],
-        serialize: (data) => stringify(data, stringifyReplace),
-        deserialize: parse$3,
+        eventNames: ["onUserConsoleLog", "onFinished", "onFinishedReportCoverage", "onCollected", "onTaskUpdate"],
+        serialize: (data) => stringify$5(data, stringifyReplace),
+        deserialize: parse$5,
         onTimeoutError(functionName) {
           throw new Error(`[vitest-api]: Timeout calling "${functionName}"`);
         }
       }
     );
-    ctx.onCancel((reason) => rpc.onCancel(reason));
     clients.set(ws, rpc);
     ws.on("close", () => {
       clients.delete(ws);
@@ -7867,7 +9289,15 @@ class WebSocketReporter {
       return;
     this.clients.forEach((client) => {
       var _a, _b, _c;
-      (_c = (_b = (_a = client.onCollected) == null ? void 0 : _a.call(client, files)) == null ? void 0 : _b.catch) == null ? void 0 : _c.call(_b, noop$2);
+      (_c = (_b = (_a = client.onCollected) == null ? void 0 : _a.call(client, files)) == null ? void 0 : _b.catch) == null ? void 0 : _c.call(_b, noop$1);
+    });
+  }
+  onSpecsCollected(specs) {
+    if (this.clients.size === 0)
+      return;
+    this.clients.forEach((client) => {
+      var _a, _b, _c;
+      (_c = (_b = (_a = client.onSpecsCollected) == null ? void 0 : _a.call(client, specs)) == null ? void 0 : _b.catch) == null ? void 0 : _c.call(_b, noop$1);
     });
   }
   async onTaskUpdate(packs) {
@@ -7886,25 +9316,25 @@ class WebSocketReporter {
     });
     this.clients.forEach((client) => {
       var _a, _b, _c;
-      (_c = (_b = (_a = client.onTaskUpdate) == null ? void 0 : _a.call(client, packs)) == null ? void 0 : _b.catch) == null ? void 0 : _c.call(_b, noop$2);
+      (_c = (_b = (_a = client.onTaskUpdate) == null ? void 0 : _a.call(client, packs)) == null ? void 0 : _b.catch) == null ? void 0 : _c.call(_b, noop$1);
     });
   }
   onFinished(files, errors) {
     this.clients.forEach((client) => {
       var _a, _b, _c;
-      (_c = (_b = (_a = client.onFinished) == null ? void 0 : _a.call(client, files, errors)) == null ? void 0 : _b.catch) == null ? void 0 : _c.call(_b, noop$2);
+      (_c = (_b = (_a = client.onFinished) == null ? void 0 : _a.call(client, files, errors)) == null ? void 0 : _b.catch) == null ? void 0 : _c.call(_b, noop$1);
     });
   }
   onFinishedReportCoverage() {
     this.clients.forEach((client) => {
       var _a, _b, _c;
-      (_c = (_b = (_a = client.onFinishedReportCoverage) == null ? void 0 : _a.call(client)) == null ? void 0 : _b.catch) == null ? void 0 : _c.call(_b, noop$2);
+      (_c = (_b = (_a = client.onFinishedReportCoverage) == null ? void 0 : _a.call(client)) == null ? void 0 : _b.catch) == null ? void 0 : _c.call(_b, noop$1);
     });
   }
   onUserConsoleLog(log) {
     this.clients.forEach((client) => {
       var _a, _b, _c;
-      (_c = (_b = (_a = client.onUserConsoleLog) == null ? void 0 : _a.call(client, log)) == null ? void 0 : _b.catch) == null ? void 0 : _c.call(_b, noop$2);
+      (_c = (_b = (_a = client.onUserConsoleLog) == null ? void 0 : _a.call(client, log)) == null ? void 0 : _b.catch) == null ? void 0 : _c.call(_b, noop$1);
     });
   }
 }
@@ -7932,7 +9362,7 @@ async function groupFilesByEnv(files) {
   const filesWithEnv = await Promise.all(files.map(async ([project, file]) => {
     var _a, _b;
     const code = await promises$1.readFile(file, "utf-8");
-    let env = (_a = code.match(/@(?:vitest|jest)-environment\s+?([\w-]+)\b/)) == null ? void 0 : _a[1];
+    let env = (_a = code.match(/@(?:vitest|jest)-environment\s+([\w-]+)\b/)) == null ? void 0 : _a[1];
     if (!env) {
       for (const [glob, target] of project.config.environmentMatchGlobs || []) {
         if (mm.isMatch(file, glob, { cwd: project.config.root })) {
@@ -8355,34 +9785,78 @@ See https://vitest.dev/guide/common-errors.html#failed-to-terminate-worker for t
   };
 }
 
+function createDebugger(namespace) {
+  const debug = createDebug(namespace);
+  if (debug.enabled)
+    return debug;
+}
+
+const debug$1 = createDebugger("vitest:browser:pool");
 function createBrowserPool(ctx) {
   const providers = /* @__PURE__ */ new Set();
-  const waitForTests = async (project, files) => {
-    var _a;
+  const waitForTests = async (contextId, project, files) => {
     const defer = createDefer();
-    (_a = project.browserState) == null ? void 0 : _a.resolve();
-    project.browserState = {
+    project.browserState.set(contextId, {
       files,
       resolve: () => {
         defer.resolve();
-        project.browserState = void 0;
+        project.browserState.delete(contextId);
       },
       reject: defer.reject
-    };
+    });
     return await defer;
   };
   const runTests = async (project, files) => {
     var _a;
     ctx.state.clearFiles(project, files);
+    const threadsCount = getThreadsCount(project);
     const provider = project.browserProvider;
     providers.add(provider);
     const resolvedUrls = (_a = project.browser) == null ? void 0 : _a.resolvedUrls;
     const origin = (resolvedUrls == null ? void 0 : resolvedUrls.local[0]) ?? (resolvedUrls == null ? void 0 : resolvedUrls.network[0]);
     if (!origin)
       throw new Error(`Can't find browser origin URL for project "${project.config.name}"`);
-    const promise = waitForTests(project, files);
-    await provider.openPage(new URL("/", origin).toString());
-    await promise;
+    const filesPerThread = Math.ceil(files.length / threadsCount);
+    const chunks = [];
+    for (let i = 0; i < files.length; i += filesPerThread) {
+      const chunk = files.slice(i, i + filesPerThread);
+      chunks.push(chunk);
+    }
+    debug$1 == null ? void 0 : debug$1(
+      `[%s] Running %s tests in %s chunks (%s threads)`,
+      project.getName() || "core",
+      files.length,
+      chunks.length,
+      threadsCount
+    );
+    const orchestrators = [...project.browserRpc.orchestrators.entries()];
+    const promises = [];
+    chunks.forEach((files2, index) => {
+      if (orchestrators[index]) {
+        const [contextId, orchestrator] = orchestrators[index];
+        debug$1 == null ? void 0 : debug$1(
+          "Reusing orchestrator (context %s) for files: %s",
+          contextId,
+          [...files2.map((f) => relative(project.config.root, f))].join(", ")
+        );
+        const promise = waitForTests(contextId, project, files2);
+        promises.push(promise);
+        orchestrator.createTesters(files2);
+      } else {
+        const contextId = crypto.randomUUID();
+        const waitPromise = waitForTests(contextId, project, files2);
+        debug$1 == null ? void 0 : debug$1(
+          "Opening a new context %s for files: %s",
+          contextId,
+          [...files2.map((f) => relative(project.config.root, f))].join(", ")
+        );
+        const url = new URL("/", origin);
+        url.searchParams.set("contextId", contextId);
+        const page = provider.openPage(contextId, url.toString()).then(() => waitPromise);
+        promises.push(page);
+      }
+    });
+    await Promise.all(promises);
   };
   const runWorkspaceTests = async (specs) => {
     const groupedFiles = /* @__PURE__ */ new Map();
@@ -8394,6 +9868,15 @@ function createBrowserPool(ctx) {
     for (const [project, files] of groupedFiles.entries())
       await runTests(project, files);
   };
+  const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
+  function getThreadsCount(project) {
+    const config = project.config.browser;
+    if (!config.headless || !project.browserProvider.supportsParallelism)
+      return 1;
+    if (!config.fileParallelism)
+      return 1;
+    return ctx.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
+  }
   return {
     name: "browser",
     async close() {
@@ -8420,7 +9903,7 @@ function stringToBytes(input, percentageReference) {
     return input;
   if (typeof input === "string") {
     if (Number.isNaN(Number.parseFloat(input.slice(-1)))) {
-      let [, numericString, trailingChars] = input.match(/(.*?)([^0-9.-]+)$/i) || [];
+      let [, numericString, trailingChars] = input.match(/(.*?)([^0-9.-]+)$/) || [];
       if (trailingChars && numericString) {
         const numericValue = Number.parseFloat(numericString);
         trailingChars = trailingChars.toLowerCase();
@@ -8821,6 +10304,26 @@ function getMemoryLimit(config) {
 }
 
 const builtinPools = ["forks", "threads", "browser", "vmThreads", "vmForks", "typescript"];
+function getDefaultPoolName(project, file) {
+  if (project.config.typecheck.enabled) {
+    for (const glob of project.config.typecheck.include) {
+      if (mm.isMatch(file, glob, { cwd: project.config.root }))
+        return "typescript";
+    }
+  }
+  if (project.config.browser.enabled)
+    return "browser";
+  return project.config.pool;
+}
+function getFilePoolName(project, file) {
+  for (const [glob, pool] of project.config.poolMatchGlobs) {
+    if (pool === "browser")
+      throw new Error('Since Vitest 0.31.0 "browser" pool is not supported in "poolMatchGlobs". You can create a workspace to run some of your tests in browser in parallel. Read more: https://vitest.dev/guide/workspace');
+    if (mm.isMatch(file, glob, { cwd: project.config.root }))
+      return pool;
+  }
+  return getDefaultPoolName(project, file);
+}
 function createPool(ctx) {
   const pools = {
     forks: null,
@@ -8830,26 +10333,6 @@ function createPool(ctx) {
     vmForks: null,
     typescript: null
   };
-  function getDefaultPoolName(project, file) {
-    if (project.config.typecheck.enabled) {
-      for (const glob of project.config.typecheck.include) {
-        if (mm.isMatch(file, glob, { cwd: project.config.root }))
-          return "typescript";
-      }
-    }
-    if (project.config.browser.enabled)
-      return "browser";
-    return project.config.pool;
-  }
-  function getPoolName([project, file]) {
-    for (const [glob, pool] of project.config.poolMatchGlobs) {
-      if (pool === "browser")
-        throw new Error('Since Vitest 0.31.0 "browser" pool is not supported in "poolMatchGlobs". You can create a workspace to run some of your tests in browser in parallel. Read more: https://vitest.dev/guide/workspace');
-      if (mm.isMatch(file, glob, { cwd: project.config.root }))
-        return pool;
-    }
-    return getDefaultPoolName(project, file);
-  }
   const potentialConditions = /* @__PURE__ */ new Set(["production", "development", ...ctx.server.config.resolve.conditions]);
   const conditions = [...potentialConditions].filter((condition) => {
     if (condition === "production")
@@ -8912,7 +10395,7 @@ function createPool(ctx) {
       typescript: () => createTypecheckPool(ctx)
     };
     for (const spec of files) {
-      const pool = getPoolName(spec);
+      const pool = getFilePoolName(spec[0], spec[1]);
       filesByPool[pool] ?? (filesByPool[pool] = []);
       filesByPool[pool].push(spec);
     }
@@ -9068,6 +10551,9 @@ class StateManager {
     files.forEach((file) => {
       const existing = this.filesMap.get(file.filepath) || [];
       const otherProject = existing.filter((i) => i.projectName !== file.projectName);
+      const currentFile = existing.find((i) => i.projectName === file.projectName);
+      if (currentFile)
+        file.logs = currentFile.logs;
       otherProject.push(file);
       this.filesMap.set(file.filepath, otherProject);
       this.updateId(file);
@@ -9078,13 +10564,21 @@ class StateManager {
     const project = _project;
     paths.forEach((path) => {
       const files = this.filesMap.get(path);
-      if (!files)
+      const fileTask = createFileTask(path, project.config.root, project.config.name);
+      this.idMap.set(fileTask.id, fileTask);
+      if (!files) {
+        this.filesMap.set(path, [fileTask]);
         return;
+      }
       const filtered = files.filter((file) => file.projectName !== project.config.name);
-      if (!filtered.length)
-        this.filesMap.delete(path);
-      else
-        this.filesMap.set(path, filtered);
+      if (!filtered.length) {
+        this.filesMap.set(path, [fileTask]);
+      } else {
+        this.filesMap.set(path, [
+          ...filtered,
+          fileTask
+        ]);
+      }
     });
   }
   updateId(task) {
@@ -9123,25 +10617,7 @@ class StateManager {
     }).length;
   }
   cancelFiles(files, root, projectName) {
-    this.collectFiles(files.map((filepath) => {
-      const file = {
-        filepath,
-        name: relative(root, filepath),
-        id: filepath,
-        mode: "skip",
-        type: "suite",
-        result: {
-          state: "skip"
-        },
-        meta: {},
-        // Cancelled files have not yet collected tests
-        tasks: [],
-        projectName,
-        file: null
-      };
-      file.file = file;
-      return file;
-    }));
+    this.collectFiles(files.map((filepath) => createFileTask(filepath, root, projectName)));
   }
 }
 
@@ -11313,7 +12789,7 @@ const config = {
   watch: !isCI,
   globals: false,
   environment: "node",
-  pool: "threads",
+  pool: "forks",
   clearMocks: false,
   restoreMocks: false,
   mockReset: false,
@@ -11484,12 +12960,12 @@ function parseInspector(inspect) {
     return { host };
   return { host, port: Number(port) || defaultInspectPort };
 }
-function resolveApiServerConfig(options) {
+function resolveApiServerConfig(options, defaultPort2) {
   let api;
   if (options.ui && !options.api)
-    api = { port: defaultPort };
+    api = { port: defaultPort2 };
   else if (options.api === true)
-    api = { port: defaultPort };
+    api = { port: defaultPort2 };
   else if (typeof options.api === "number")
     api = { port: options.api };
   if (typeof options.api === "object") {
@@ -11506,14 +12982,14 @@ function resolveApiServerConfig(options) {
   }
   if (api) {
     if (!api.port && !api.middlewareMode)
-      api.port = defaultPort;
+      api.port = defaultPort2;
   } else {
     api = { middlewareMode: true };
   }
   return api;
 }
 function resolveConfig(mode, options, viteConfig, logger) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K, _L, _M;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K, _L, _M, _N, _O, _P;
   if (options.dom) {
     if (((_a = viteConfig.test) == null ? void 0 : _a.environment) != null && viteConfig.test.environment !== "happy-dom") {
       logger.console.warn(
@@ -11554,27 +13030,26 @@ function resolveConfig(mode, options, viteConfig, logger) {
   }
   if (resolved.standalone && !resolved.watch)
     throw new Error(`Vitest standalone mode requires --watch`);
+  if (resolved.mergeReports && resolved.watch)
+    throw new Error(`Cannot merge reports with --watch enabled`);
   if (resolved.maxWorkers)
     resolved.maxWorkers = Number(resolved.maxWorkers);
   if (resolved.minWorkers)
     resolved.minWorkers = Number(resolved.minWorkers);
   resolved.browser ?? (resolved.browser = {});
-  (_c = resolved.browser).fileParallelism ?? (_c.fileParallelism = resolved.fileParallelism ?? false);
   resolved.fileParallelism ?? (resolved.fileParallelism = mode !== "benchmark");
   if (!resolved.fileParallelism) {
     resolved.maxWorkers = 1;
     resolved.minWorkers = 1;
   }
   if (resolved.inspect || resolved.inspectBrk) {
-    const isSingleThread = resolved.pool === "threads" && ((_e = (_d = resolved.poolOptions) == null ? void 0 : _d.threads) == null ? void 0 : _e.singleThread);
-    const isSingleFork = resolved.pool === "forks" && ((_g = (_f = resolved.poolOptions) == null ? void 0 : _f.forks) == null ? void 0 : _g.singleFork);
+    const isSingleThread = resolved.pool === "threads" && ((_d = (_c = resolved.poolOptions) == null ? void 0 : _c.threads) == null ? void 0 : _d.singleThread);
+    const isSingleFork = resolved.pool === "forks" && ((_f = (_e = resolved.poolOptions) == null ? void 0 : _e.forks) == null ? void 0 : _f.singleFork);
     if (resolved.fileParallelism && !isSingleThread && !isSingleFork) {
       const inspectOption = `--inspect${resolved.inspectBrk ? "-brk" : ""}`;
       throw new Error(`You cannot use ${inspectOption} without "--no-file-parallelism", "poolOptions.threads.singleThread" or "poolOptions.forks.singleFork"`);
     }
   }
-  if (resolved.coverage.provider === "c8")
-    throw new Error('"coverage.provider: c8" is not supported anymore. Use "coverage.provider: v8" instead');
   if (resolved.coverage.provider === "v8" && resolved.coverage.enabled && isBrowserEnabled(resolved))
     throw new Error("@vitest/coverage-v8 does not work with --browser. Use @vitest/coverage-istanbul instead");
   if (resolved.coverage.enabled && resolved.coverage.reportsDirectory) {
@@ -11582,8 +13057,9 @@ function resolveConfig(mode, options, viteConfig, logger) {
     if (reportsDirectory === resolved.root || reportsDirectory === process.cwd())
       throw new Error(`You cannot set "coverage.reportsDirectory" as ${reportsDirectory}. Vitest needs to be able to remove this directory before test run`);
   }
+  resolved.expect ?? (resolved.expect = {});
   resolved.deps ?? (resolved.deps = {});
-  (_h = resolved.deps).moduleDirectories ?? (_h.moduleDirectories = []);
+  (_g = resolved.deps).moduleDirectories ?? (_g.moduleDirectories = []);
   resolved.deps.moduleDirectories = resolved.deps.moduleDirectories.map((dir) => {
     if (!dir.startsWith("/"))
       dir = `/${dir}`;
@@ -11593,17 +13069,17 @@ function resolveConfig(mode, options, viteConfig, logger) {
   });
   if (!resolved.deps.moduleDirectories.includes("/node_modules/"))
     resolved.deps.moduleDirectories.push("/node_modules/");
-  (_i = resolved.deps).optimizer ?? (_i.optimizer = {});
-  (_j = resolved.deps.optimizer).ssr ?? (_j.ssr = {});
-  (_k = resolved.deps.optimizer.ssr).enabled ?? (_k.enabled = true);
-  (_l = resolved.deps.optimizer).web ?? (_l.web = {});
-  (_m = resolved.deps.optimizer.web).enabled ?? (_m.enabled = true);
-  (_n = resolved.deps).web ?? (_n.web = {});
-  (_o = resolved.deps.web).transformAssets ?? (_o.transformAssets = true);
-  (_p = resolved.deps.web).transformCss ?? (_p.transformCss = true);
-  (_q = resolved.deps.web).transformGlobPattern ?? (_q.transformGlobPattern = []);
+  (_h = resolved.deps).optimizer ?? (_h.optimizer = {});
+  (_i = resolved.deps.optimizer).ssr ?? (_i.ssr = {});
+  (_j = resolved.deps.optimizer.ssr).enabled ?? (_j.enabled = true);
+  (_k = resolved.deps.optimizer).web ?? (_k.web = {});
+  (_l = resolved.deps.optimizer.web).enabled ?? (_l.enabled = true);
+  (_m = resolved.deps).web ?? (_m.web = {});
+  (_n = resolved.deps.web).transformAssets ?? (_n.transformAssets = true);
+  (_o = resolved.deps.web).transformCss ?? (_o.transformCss = true);
+  (_p = resolved.deps.web).transformGlobPattern ?? (_p.transformGlobPattern = []);
   resolved.server ?? (resolved.server = {});
-  (_r = resolved.server).deps ?? (_r.deps = {});
+  (_q = resolved.server).deps ?? (_q.deps = {});
   const deprecatedDepsOptions = ["inline", "external", "fallbackCJS"];
   deprecatedDepsOptions.forEach((option) => {
     if (resolved.deps[option] === void 0)
@@ -11628,11 +13104,11 @@ function resolveConfig(mode, options, viteConfig, logger) {
     if ((ssrOptions == null ? void 0 : ssrOptions.noExternal) === true && resolved.server.deps.inline == null) {
       resolved.server.deps.inline = true;
     } else {
-      (_s = resolved.server.deps).inline ?? (_s.inline = []);
+      (_r = resolved.server.deps).inline ?? (_r.inline = []);
       resolved.server.deps.inline.push(...extraInlineDeps);
     }
   }
-  (_t = resolved.server.deps).moduleDirectories ?? (_t.moduleDirectories = []);
+  (_s = resolved.server.deps).moduleDirectories ?? (_s.moduleDirectories = []);
   resolved.server.deps.moduleDirectories.push(...resolved.deps.moduleDirectories);
   if (resolved.runner)
     resolved.runner = resolvePath(resolved.runner, resolved.root);
@@ -11662,11 +13138,11 @@ function resolveConfig(mode, options, viteConfig, logger) {
     resolved.poolOptions = {
       ...resolved.poolOptions,
       threads: {
-        ...(_u = resolved.poolOptions) == null ? void 0 : _u.threads,
+        ...(_t = resolved.poolOptions) == null ? void 0 : _t.threads,
         maxThreads: Number.parseInt(process.env.VITEST_MAX_THREADS)
       },
       vmThreads: {
-        ...(_v = resolved.poolOptions) == null ? void 0 : _v.vmThreads,
+        ...(_u = resolved.poolOptions) == null ? void 0 : _u.vmThreads,
         maxThreads: Number.parseInt(process.env.VITEST_MAX_THREADS)
       }
     };
@@ -11675,11 +13151,11 @@ function resolveConfig(mode, options, viteConfig, logger) {
     resolved.poolOptions = {
       ...resolved.poolOptions,
       threads: {
-        ...(_w = resolved.poolOptions) == null ? void 0 : _w.threads,
+        ...(_v = resolved.poolOptions) == null ? void 0 : _v.threads,
         minThreads: Number.parseInt(process.env.VITEST_MIN_THREADS)
       },
       vmThreads: {
-        ...(_x = resolved.poolOptions) == null ? void 0 : _x.vmThreads,
+        ...(_w = resolved.poolOptions) == null ? void 0 : _w.vmThreads,
         minThreads: Number.parseInt(process.env.VITEST_MIN_THREADS)
       }
     };
@@ -11688,11 +13164,11 @@ function resolveConfig(mode, options, viteConfig, logger) {
     resolved.poolOptions = {
       ...resolved.poolOptions,
       forks: {
-        ...(_y = resolved.poolOptions) == null ? void 0 : _y.forks,
+        ...(_x = resolved.poolOptions) == null ? void 0 : _x.forks,
         maxForks: Number.parseInt(process.env.VITEST_MAX_FORKS)
       },
       vmForks: {
-        ...(_z = resolved.poolOptions) == null ? void 0 : _z.vmForks,
+        ...(_y = resolved.poolOptions) == null ? void 0 : _y.vmForks,
         maxForks: Number.parseInt(process.env.VITEST_MAX_FORKS)
       }
     };
@@ -11701,11 +13177,11 @@ function resolveConfig(mode, options, viteConfig, logger) {
     resolved.poolOptions = {
       ...resolved.poolOptions,
       forks: {
-        ...(_A = resolved.poolOptions) == null ? void 0 : _A.forks,
+        ...(_z = resolved.poolOptions) == null ? void 0 : _z.forks,
         minForks: Number.parseInt(process.env.VITEST_MIN_FORKS)
       },
       vmForks: {
-        ...(_B = resolved.poolOptions) == null ? void 0 : _B.vmForks,
+        ...(_A = resolved.poolOptions) == null ? void 0 : _A.vmForks,
         minForks: Number.parseInt(process.env.VITEST_MIN_FORKS)
       }
     };
@@ -11760,7 +13236,7 @@ function resolveConfig(mode, options, viteConfig, logger) {
     resolved.diff = resolvePath(resolved.diff, resolved.root);
     resolved.forceRerunTriggers.push(resolved.diff);
   }
-  resolved.api = resolveApiServerConfig(options);
+  resolved.api = resolveApiServerConfig(options, defaultPort);
   if (options.related)
     resolved.related = toArray(options.related).map((file) => resolve(resolved.root, file));
   if (options.reporters) {
@@ -11801,8 +13277,8 @@ function resolveConfig(mode, options, viteConfig, logger) {
     resolved.passWithNoTests ?? (resolved.passWithNoTests = true);
   resolved.css ?? (resolved.css = {});
   if (typeof resolved.css === "object") {
-    (_C = resolved.css).modules ?? (_C.modules = {});
-    (_D = resolved.css.modules).classNameStrategy ?? (_D.classNameStrategy = "stable");
+    (_B = resolved.css).modules ?? (_B.modules = {});
+    (_C = resolved.css.modules).classNameStrategy ?? (_C.classNameStrategy = "stable");
   }
   if (resolved.cache !== false) {
     let cacheDir = VitestCache.resolveCacheDir("", resolve(viteConfig.cacheDir, "vitest"), resolved.name);
@@ -11819,32 +13295,40 @@ function resolveConfig(mode, options, viteConfig, logger) {
   resolved.sequence ?? (resolved.sequence = {});
   if (resolved.sequence.shuffle && typeof resolved.sequence.shuffle === "object") {
     const { files, tests } = resolved.sequence.shuffle;
-    (_E = resolved.sequence).sequencer ?? (_E.sequencer = files ? RandomSequencer : BaseSequencer);
+    (_D = resolved.sequence).sequencer ?? (_D.sequencer = files ? RandomSequencer : BaseSequencer);
     resolved.sequence.shuffle = tests;
   }
-  if (!((_F = resolved.sequence) == null ? void 0 : _F.sequencer)) {
+  if (!((_E = resolved.sequence) == null ? void 0 : _E.sequencer)) {
     resolved.sequence.sequencer = resolved.sequence.shuffle ? RandomSequencer : BaseSequencer;
   }
-  (_G = resolved.sequence).hooks ?? (_G.hooks = "stack");
+  (_F = resolved.sequence).hooks ?? (_F.hooks = "stack");
   if (resolved.sequence.sequencer === RandomSequencer)
-    (_H = resolved.sequence).seed ?? (_H.seed = Date.now());
+    (_G = resolved.sequence).seed ?? (_G.seed = Date.now());
   resolved.typecheck = {
     ...configDefaults.typecheck,
     ...resolved.typecheck
   };
-  resolved.environmentMatchGlobs = (resolved.environmentMatchGlobs || []).map((i) => [resolve(resolved.root, i[0]), i[1]]);
+  resolved.environmentMatchGlobs = (resolved.environmentMatchGlobs || []).map(
+    (i) => [resolve(resolved.root, i[0]), i[1]]
+  );
   resolved.typecheck ?? (resolved.typecheck = {});
-  (_I = resolved.typecheck).enabled ?? (_I.enabled = false);
+  (_H = resolved.typecheck).enabled ?? (_H.enabled = false);
   if (resolved.typecheck.enabled)
     logger.console.warn(c.yellow("Testing types with tsc and vue-tsc is an experimental feature.\nBreaking changes might not follow SemVer, please pin Vitest's version when using it."));
   resolved.browser ?? (resolved.browser = {});
-  (_J = resolved.browser).enabled ?? (_J.enabled = false);
-  (_K = resolved.browser).headless ?? (_K.headless = isCI);
-  (_L = resolved.browser).slowHijackESM ?? (_L.slowHijackESM = false);
-  (_M = resolved.browser).isolate ?? (_M.isolate = true);
+  (_I = resolved.browser).enabled ?? (_I.enabled = false);
+  (_J = resolved.browser).headless ?? (_J.headless = isCI);
+  (_K = resolved.browser).isolate ?? (_K.isolate = true);
+  (_L = resolved.browser).fileParallelism ?? (_L.fileParallelism = options.fileParallelism ?? mode !== "benchmark");
+  (_M = resolved.browser).ui ?? (_M.ui = resolved.browser.headless === true ? false : !isCI);
+  if (resolved.browser.screenshotDirectory)
+    resolved.browser.screenshotDirectory = resolve(resolved.root, resolved.browser.screenshotDirectory);
+  (_N = resolved.browser).viewport ?? (_N.viewport = {});
+  (_O = resolved.browser.viewport).width ?? (_O.width = 414);
+  (_P = resolved.browser.viewport).height ?? (_P.height = 896);
   if (resolved.browser.enabled && provider$1 === "stackblitz")
-    resolved.browser.provider = "none";
-  resolved.browser.api = resolveApiServerConfig(resolved.browser) || {
+    resolved.browser.provider = "preview";
+  resolved.browser.api = resolveApiServerConfig(resolved.browser, defaultBrowserPort) || {
     port: defaultBrowserPort
   };
   resolved.testTransformMode ?? (resolved.testTransformMode = {});
@@ -11901,7 +13385,7 @@ function getBetterEnd(code, node) {
     end += 1;
   return end;
 }
-const regexpHoistable = /\b(vi|vitest)\s*\.\s*(mock|unmock|hoisted|doMock|doUnmock)\(/;
+const regexpHoistable = /\b(?:vi|vitest)\s*\.\s*(?:mock|unmock|hoisted|doMock|doUnmock)\(/;
 const hashbangRE = /^#!.*\n/;
 function hoistMocks(code, id, parse, colors) {
   var _a;
@@ -12151,6 +13635,8 @@ function MocksPlugin() {
     name: "vitest:mocks",
     enforce: "post",
     transform(code, id) {
+      if (id.includes(distDir))
+        return;
       return hoistMocks(code, id, this.parse);
     }
   };
@@ -12253,6 +13739,287 @@ function resolveFsAllow(projectRoot, rootConfigFile) {
   return [dirname(rootConfigFile), searchForWorkspaceRoot(projectRoot), rootDir];
 }
 
+function automockModule(code, parse) {
+  const ast = parse(code);
+  const m = new MagicString(code);
+  const allSpecifiers = [];
+  let importIndex = 0;
+  for (const _node of ast.body) {
+    if (_node.type === "ExportAllDeclaration") {
+      throw new Error(
+        `automocking files with \`export *\` is not supported in browser mode because it cannot be statically analysed`
+      );
+    }
+    if (_node.type === "ExportNamedDeclaration") {
+      let traversePattern2 = function(expression) {
+        if (expression.type === "Identifier") {
+          allSpecifiers.push({ name: expression.name });
+        } else if (expression.type === "ArrayPattern") {
+          expression.elements.forEach((element) => {
+            if (!element)
+              return;
+            traversePattern2(element);
+          });
+        } else if (expression.type === "ObjectPattern") {
+          expression.properties.forEach((property) => {
+            if (property.type === "RestElement")
+              traversePattern2(property);
+            else if (property.type === "Property")
+              traversePattern2(property.value);
+            else
+              ;
+          });
+        } else if (expression.type === "RestElement") {
+          traversePattern2(expression.argument);
+        } else if (expression.type === "AssignmentPattern") {
+          throw new Error(`AssignmentPattern is not supported. Please open a new bug report.`);
+        } else if (expression.type === "MemberExpression") {
+          throw new Error(`MemberExpression is not supported. Please open a new bug report.`);
+        } else ;
+      };
+      const node = _node;
+      const declaration = node.declaration;
+      if (declaration) {
+        if (declaration.type === "FunctionDeclaration") {
+          allSpecifiers.push({ name: declaration.id.name });
+        } else if (declaration.type === "VariableDeclaration") {
+          declaration.declarations.forEach((declaration2) => {
+            traversePattern2(declaration2.id);
+          });
+        } else if (declaration.type === "ClassDeclaration") {
+          allSpecifiers.push({ name: declaration.id.name });
+        } else ;
+        m.remove(node.start, declaration.start);
+      }
+      const specifiers = node.specifiers || [];
+      const source = node.source;
+      if (!source && specifiers.length) {
+        specifiers.forEach((specifier) => {
+          const exported = specifier.exported;
+          allSpecifiers.push({
+            alias: exported.type === "Literal" ? exported.raw : exported.name,
+            name: specifier.local.name
+          });
+        });
+        m.remove(node.start, node.end);
+      } else if (source && specifiers.length) {
+        const importNames = [];
+        specifiers.forEach((specifier) => {
+          const importedName = `__vitest_imported_${importIndex++}__`;
+          const exported = specifier.exported;
+          importNames.push([specifier.local.name, importedName]);
+          allSpecifiers.push({
+            name: importedName,
+            alias: exported.type === "Literal" ? exported.raw : exported.name
+          });
+        });
+        const importString = `import { ${importNames.map(([name, alias]) => `${name} as ${alias}`).join(", ")} } from '${source.value}'`;
+        m.overwrite(node.start, node.end, importString);
+      }
+    }
+    if (_node.type === "ExportDefaultDeclaration") {
+      const node = _node;
+      const declaration = node.declaration;
+      allSpecifiers.push({ name: "__vitest_default", alias: "default" });
+      m.overwrite(node.start, declaration.start, `const __vitest_default = `);
+    }
+  }
+  const moduleObject = `
+const __vitest_es_current_module__ = {
+  __esModule: true,
+  ${allSpecifiers.map(({ name }) => `["${name}"]: ${name},`).join("\n  ")}
+}
+const __vitest_mocked_module__ = __vitest_mocker__.mockObject(__vitest_es_current_module__)
+`;
+  const assigning = allSpecifiers.map(({ name }, index) => {
+    return `const __vitest_mocked_${index}__ = __vitest_mocked_module__["${name}"]`;
+  }).join("\n");
+  const redeclarations = allSpecifiers.map(({ name, alias }, index) => {
+    return `  __vitest_mocked_${index}__ as ${alias || name},`;
+  }).join("\n");
+  const specifiersExports = `
+export {
+${redeclarations}
+}
+`;
+  m.append(moduleObject + assigning + specifiersExports);
+  return m;
+}
+
+const debug = createDebugger("vitest:browser:api");
+function setupBrowserRpc(project, server) {
+  var _a;
+  const ctx = project.ctx;
+  const wss = new WebSocketServer$1({ noServer: true });
+  (_a = server.httpServer) == null ? void 0 : _a.on("upgrade", (request, socket, head) => {
+    if (!request.url)
+      return;
+    const { pathname, searchParams } = new URL(request.url, "http://localhost");
+    if (pathname !== BROWSER_API_PATH)
+      return;
+    const type = searchParams.get("type") ?? "tester";
+    const sessionId = searchParams.get("sessionId") ?? "0";
+    wss.handleUpgrade(request, socket, head, (ws) => {
+      wss.emit("connection", ws, request);
+      const rpc = setupClient(sessionId, ws);
+      const rpcs = project.browserRpc;
+      const clients = type === "tester" ? rpcs.testers : rpcs.orchestrators;
+      clients.set(sessionId, rpc);
+      debug == null ? void 0 : debug("[%s] Browser API connected to %s", sessionId, type);
+      ws.on("close", () => {
+        debug == null ? void 0 : debug("[%s] Browser API disconnected from %s", sessionId, type);
+        clients.delete(sessionId);
+      });
+    });
+  });
+  function checkFileAccess(path) {
+    if (!isFileServingAllowed(path, server))
+      throw new Error(`Access denied to "${path}". See Vite config documentation for "server.fs": https://vitejs.dev/config/server-options.html#server-fs-strict.`);
+  }
+  function setupClient(sessionId, ws) {
+    const rpc = createBirpc(
+      {
+        async onUnhandledError(error, type) {
+          ctx.state.catchError(error, type);
+        },
+        async onCollected(files) {
+          ctx.state.collectFiles(files);
+          await ctx.report("onCollected", files);
+        },
+        async onTaskUpdate(packs) {
+          ctx.state.updateTasks(packs);
+          await ctx.report("onTaskUpdate", packs);
+        },
+        onAfterSuiteRun(meta) {
+          var _a2;
+          (_a2 = ctx.coverageProvider) == null ? void 0 : _a2.onAfterSuiteRun(meta);
+        },
+        sendLog(log) {
+          return ctx.report("onUserConsoleLog", log);
+        },
+        resolveSnapshotPath(testPath) {
+          return ctx.snapshot.resolvePath(testPath);
+        },
+        resolveSnapshotRawPath(testPath, rawPath) {
+          return ctx.snapshot.resolveRawPath(testPath, rawPath);
+        },
+        snapshotSaved(snapshot) {
+          ctx.snapshot.add(snapshot);
+        },
+        async readSnapshotFile(snapshotPath) {
+          checkFileAccess(snapshotPath);
+          if (!existsSync(snapshotPath))
+            return null;
+          return promises$1.readFile(snapshotPath, "utf-8");
+        },
+        async saveSnapshotFile(id, content) {
+          checkFileAccess(id);
+          await promises$1.mkdir(dirname(id), { recursive: true });
+          return promises$1.writeFile(id, content, "utf-8");
+        },
+        async removeSnapshotFile(id) {
+          checkFileAccess(id);
+          if (!existsSync(id))
+            throw new Error(`Snapshot file "${id}" does not exist.`);
+          return promises$1.unlink(id);
+        },
+        async getBrowserFileSourceMap(id) {
+          var _a2, _b;
+          const mod = (_a2 = project.browser) == null ? void 0 : _a2.moduleGraph.getModuleById(id);
+          return (_b = mod == null ? void 0 : mod.transformResult) == null ? void 0 : _b.map;
+        },
+        onCancel(reason) {
+          ctx.cancelCurrentRun(reason);
+        },
+        async resolveId(id, importer) {
+          const result = await project.server.pluginContainer.resolveId(id, importer, {
+            ssr: false
+          });
+          return result;
+        },
+        debug(...args) {
+          ctx.logger.console.debug(...args);
+        },
+        getCountOfFailedTests() {
+          return ctx.state.getCountOfFailedTests();
+        },
+        async triggerCommand(contextId, command, testPath, payload) {
+          var _a2;
+          debug == null ? void 0 : debug('[%s] Triggering command "%s"', contextId, command);
+          const provider = project.browserProvider;
+          if (!provider)
+            throw new Error("Commands are only available for browser tests.");
+          const commands = (_a2 = project.config.browser) == null ? void 0 : _a2.commands;
+          if (!commands || !commands[command])
+            throw new Error(`Unknown command "${command}".`);
+          if (provider.beforeCommand)
+            await provider.beforeCommand(command, payload);
+          const context = Object.assign({
+            testPath,
+            project,
+            provider,
+            contextId
+          }, provider.getCommandsContext(contextId));
+          let result;
+          try {
+            result = await commands[command](context, ...payload);
+          } finally {
+            if (provider.afterCommand)
+              await provider.afterCommand(command, payload);
+          }
+          return result;
+        },
+        finishBrowserTests(contextId) {
+          var _a2;
+          debug == null ? void 0 : debug("[%s] Finishing browser tests for context", contextId);
+          return (_a2 = project.browserState.get(contextId)) == null ? void 0 : _a2.resolve();
+        },
+        getProvidedContext() {
+          return "ctx" in project ? project.getProvidedContext() : {};
+        },
+        // TODO: cache this automock result
+        async automock(id) {
+          const result = await project.browser.transformRequest(id);
+          if (!result)
+            throw new Error(`Module "${id}" not found.`);
+          const ms = automockModule(result.code, parseAst);
+          const code = ms.toString();
+          const sourcemap = ms.generateMap({ hires: "boundary", source: id });
+          const combinedMap = result.map && result.map.mappings ? remapping(
+            [{ ...sourcemap, version: 3 }, result.map],
+            () => null
+          ) : sourcemap;
+          return `${code}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,${Buffer.from(JSON.stringify(combinedMap)).toString("base64")}`;
+        },
+        resolveMock(rawId, importer, hasFactory) {
+          return project.browserMocker.resolveMock(rawId, importer, hasFactory);
+        },
+        invalidate(ids) {
+          ids.forEach((id) => {
+            const moduleGraph = project.browser.moduleGraph;
+            const module = moduleGraph.getModuleById(id);
+            if (module)
+              moduleGraph.invalidateModule(module, /* @__PURE__ */ new Set(), Date.now(), true);
+          });
+        }
+      },
+      {
+        post: (msg) => ws.send(msg),
+        on: (fn) => ws.on("message", fn),
+        eventNames: ["onCancel"],
+        serialize: (data) => stringify$5(data, stringifyReplace),
+        deserialize: parse$5,
+        onTimeoutError(functionName) {
+          throw new Error(`[vitest-api]: Timeout calling "${functionName}"`);
+        }
+      }
+    );
+    ctx.onCancel((reason) => rpc.onCancel(reason));
+    return rpc;
+  }
+}
+
 async function createBrowserServer(project, configFile) {
   var _a;
   const root = project.config.root;
@@ -12261,18 +14028,19 @@ async function createBrowserServer(project, configFile) {
   const server = await createServer({
     ...project.options,
     // spread project config inlined in root workspace config
+    base: "/",
     logLevel: "error",
     mode: project.config.mode,
     configFile: configPath,
     // watch is handled by Vitest
     server: {
       hmr: false,
-      watch: {
-        ignored: ["**/**"]
-      }
+      watch: null,
+      preTransformRequests: false
     },
     plugins: [
       ...((_a = project.options) == null ? void 0 : _a.plugins) || [],
+      MocksPlugin(),
       (await import('@vitest/browser')).default(project, "/"),
       CoverageTransform(project.ctx),
       {
@@ -12280,13 +14048,14 @@ async function createBrowserServer(project, configFile) {
         name: "vitest:browser:config",
         async config(config) {
           var _a2, _b, _c;
-          const server2 = resolveApiServerConfig(((_a2 = config.test) == null ? void 0 : _a2.browser) || {}) || {
+          const server2 = resolveApiServerConfig(((_a2 = config.test) == null ? void 0 : _a2.browser) || {}, defaultBrowserPort) || {
             port: defaultBrowserPort
           };
           server2.middlewareMode = false;
           config.server = {
             ...config.server,
-            ...server2
+            ...server2,
+            open: false
           };
           (_b = config.server).fs ?? (_b.fs = {});
           config.server.fs.allow = config.server.fs.allow || [];
@@ -12299,27 +14068,25 @@ async function createBrowserServer(project, configFile) {
           return {
             resolve: {
               alias: (_c = config.test) == null ? void 0 : _c.alias
-            },
-            server: {
-              watch: null
             }
           };
         }
-      },
-      MocksPlugin()
+      }
     ]
   });
   await server.listen();
-  (await Promise.resolve().then(function () { return setup$1; })).setup(project, server);
+  setupBrowserRpc(project, server);
+  if (project.config.browser.ui)
+    setup(project.ctx, server);
   return server;
 }
 
-const builtinProviders = ["webdriverio", "playwright", "none"];
+const builtinProviders = ["webdriverio", "playwright", "preview"];
 async function getBrowserProvider(options, project) {
   if (options.provider == null || builtinProviders.includes(options.provider)) {
     await project.ctx.packageInstaller.ensureInstalled("@vitest/browser", project.config.root);
     const providers = await project.runner.executeId("@vitest/browser/providers");
-    const provider = options.provider || "webdriverio";
+    const provider = options.provider || "preview";
     return providers[provider];
   }
   let customProviderModule;
@@ -12333,6 +14100,69 @@ async function getBrowserProvider(options, project) {
   return customProviderModule.default;
 }
 
+var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
+var _project;
+class VitestBrowserServerMocker {
+  constructor(project) {
+    // string means it will read from __mocks__ folder
+    // undefined means there is a factory mock that will be called on the server
+    // null means it should be auto mocked
+    __publicField(this, "mocks", /* @__PURE__ */ new Map());
+    // private because the typecheck fails on build if it's exposed
+    // due to a self reference
+    __privateAdd(this, _project);
+    __privateSet(this, _project, project);
+  }
+  async resolveMock(rawId, importer, hasFactory) {
+    const { id, fsPath, external } = await this.resolveId(rawId, importer);
+    if (hasFactory)
+      return { type: "factory", resolvedId: id };
+    const mockPath = this.resolveMockPath(fsPath, external);
+    return {
+      type: mockPath === null ? "automock" : "redirect",
+      mockPath,
+      resolvedId: id
+    };
+  }
+  async resolveId(rawId, importer) {
+    const resolved = await __privateGet(this, _project).browser.pluginContainer.resolveId(rawId, importer, {
+      ssr: false
+    });
+    return __privateGet(this, _project).vitenode.resolveModule(rawId, resolved);
+  }
+  resolveMockPath(mockPath, external) {
+    const path = external || mockPath;
+    if (external || isNodeBuiltin(mockPath) || !existsSync(mockPath)) {
+      const mockDirname = dirname(path);
+      const mockFolder = join(__privateGet(this, _project).config.root, "__mocks__", mockDirname);
+      if (!existsSync(mockFolder))
+        return null;
+      const files = readdirSync(mockFolder);
+      const baseOriginal = basename(path);
+      for (const file of files) {
+        const baseFile = basename(file, extname$1(file));
+        if (baseFile === baseOriginal)
+          return resolve(mockFolder, file);
+      }
+      return null;
+    }
+    const dir = dirname(path);
+    const baseId = basename(path);
+    const fullPath = resolve(dir, "__mocks__", baseId);
+    return existsSync(fullPath) ? fullPath : null;
+  }
+}
+_project = new WeakMap();
+
 function generateCssFilenameHash(filepath) {
   return createHash$2("md5").update(filepath).digest("hex").slice(0, 6);
 }
@@ -12345,10 +14175,10 @@ function generateScopedClassName(strategy, name, filename) {
   return `_${name}_${hash}`;
 }
 
-const cssLangs = "\\.(css|less|sass|scss|styl|stylus|pcss|postcss)($|\\?)";
+const cssLangs = "\\.(?:css|less|sass|scss|styl|stylus|pcss|postcss)(?:$|\\?)";
 const cssLangRE = new RegExp(cssLangs);
 const cssModuleRE = new RegExp(`\\.module${cssLangs}`);
-const cssInlineRE = /[?&]inline(&|$)/;
+const cssInlineRE = /[?&]inline(?:&|$)/;
 function isCSS(id) {
   return cssLangRE.test(id);
 }
@@ -12960,7 +14790,7 @@ function NormalizeURLPlugin() {
       if (ssr || !code.includes("new URL") || !code.includes("import.meta.url"))
         return;
       const cleanString = stripLiteral(code);
-      const assetImportMetaUrlRE = /\bnew\s+URL\s*\(\s*('[^']+'|"[^"]+"|`[^`]+`)\s*,\s*import\.meta\.url\s*(?:,\s*)?\)/g;
+      const assetImportMetaUrlRE = /\bnew\s+URL\s*\(\s*(?:'[^']+'|"[^"]+"|`[^`]+`)\s*,\s*import\.meta\.url\s*(?:,\s*)?\)/g;
       let updatedCode = code;
       let match;
       while (match = assetImportMetaUrlRE.exec(cleanString)) {
@@ -13053,17 +14883,12 @@ function WorkspaceVitestPlugin(project, options) {
         hijackVitePluginInject(viteConfig);
       },
       async configureServer(server) {
-        try {
-          const options2 = deepMerge(
-            {},
-            configDefaults,
-            server.config.test || {}
-          );
-          await project.setServer(options2, server);
-        } catch (err) {
-          project.ctx.logger.printError(err, { fullStack: true });
-          process.exit(1);
-        }
+        const options2 = deepMerge(
+          {},
+          configDefaults,
+          server.config.test || {}
+        );
+        await project.setServer(options2, server);
         await server.watcher.close();
       }
     },
@@ -13152,8 +14977,15 @@ class WorkspaceProject {
   browser;
   typechecker;
   closingPromise;
+  // TODO: abstract browser related things and move to @vitest/browser
   browserProvider;
-  browserState;
+  browserMocker = new VitestBrowserServerMocker(this);
+  // TODO: I mean, we really need to abstract it
+  browserRpc = {
+    orchestrators: /* @__PURE__ */ new Map(),
+    testers: /* @__PURE__ */ new Map()
+  };
+  browserState = /* @__PURE__ */ new Map();
   testFilesList = null;
   id = nanoid();
   tmpDir = join(tmpdir(), this.id);
@@ -13188,35 +15020,21 @@ class WorkspaceProject {
     if (this._globalSetups)
       return;
     this._globalSetups = await loadGlobalSetupFiles(this.runner, this.config.globalSetup);
-    try {
-      for (const globalSetupFile of this._globalSetups) {
-        const teardown = await ((_a = globalSetupFile.setup) == null ? void 0 : _a.call(globalSetupFile, { provide: this.provide, config: this.config }));
-        if (teardown == null || !!globalSetupFile.teardown)
-          continue;
-        if (typeof teardown !== "function")
-          throw new Error(`invalid return value in globalSetup file ${globalSetupFile.file}. Must return a function`);
-        globalSetupFile.teardown = teardown;
-      }
-    } catch (e) {
-      this.logger.error(`
-${c.red(divider(c.bold(c.inverse(" Error during global setup "))))}`);
-      this.logger.printError(e);
-      process.exit(1);
+    for (const globalSetupFile of this._globalSetups) {
+      const teardown = await ((_a = globalSetupFile.setup) == null ? void 0 : _a.call(globalSetupFile, { provide: this.provide, config: this.config }));
+      if (teardown == null || !!globalSetupFile.teardown)
+        continue;
+      if (typeof teardown !== "function")
+        throw new Error(`invalid return value in globalSetup file ${globalSetupFile.file}. Must return a function`);
+      globalSetupFile.teardown = teardown;
     }
   }
   async teardownGlobalSetup() {
     var _a;
     if (!this._globalSetups)
       return;
-    for (const globalSetupFile of [...this._globalSetups].reverse()) {
-      try {
-        await ((_a = globalSetupFile.teardown) == null ? void 0 : _a.call(globalSetupFile));
-      } catch (error) {
-        this.logger.error(`error during global teardown of ${globalSetupFile.file}`, error);
-        this.logger.printError(error);
-        process.exitCode = 1;
-      }
-    }
+    for (const globalSetupFile of [...this._globalSetups].reverse())
+      await ((_a = globalSetupFile.teardown) == null ? void 0 : _a.call(globalSetupFile));
   }
   get logger() {
     return this.ctx.logger;
@@ -13419,7 +15237,14 @@ ${c.red(divider(c.bold(c.inverse(" Error during global setup "))))}`);
       env: {
         ...(_v = this.server) == null ? void 0 : _v.config.env,
         ...this.config.env
-      }
+      },
+      browser: {
+        ...this.ctx.config.browser,
+        orchestratorScripts: [],
+        testerScripts: [],
+        commands: {}
+      },
+      printConsoleTrace: this.config.printConsoleTrace ?? this.ctx.config.printConsoleTrace
     }, this.ctx.configOverride || {});
   }
   close() {
@@ -13617,9 +15442,12 @@ class Vitest {
   getProjectByTaskId(taskId) {
     var _a;
     const task = this.state.idMap.get(taskId);
-    const projectName = task.projectName || ((_a = task == null ? void 0 : task.file) == null ? void 0 : _a.projectName);
+    const projectName = task.projectName || ((_a = task == null ? void 0 : task.file) == null ? void 0 : _a.projectName) || "";
     return this.projects.find((p) => p.getName() === projectName) || this.getCoreWorkspaceProject() || this.projects[0];
   }
+  getProjectByName(name = "") {
+    return this.projects.find((p) => p.getName() === name) || this.getCoreWorkspaceProject() || this.projects[0];
+  }
   async getWorkspaceConfigPath() {
     if (this.config.workspace)
       return this.config.workspace;
@@ -13707,7 +15535,8 @@ class Vitest {
       "testNamePattern",
       "passWithNoTests",
       "bail",
-      "isolate"
+      "isolate",
+      "printConsoleTrace"
     ];
     const cliOverrides = overridesOptions.reduce((acc, name) => {
       if (name in cliOptions)
@@ -13766,8 +15595,52 @@ class Vitest {
   async initBrowserProviders() {
     return Promise.all(this.projects.map((w) => w.initBrowserProvider()));
   }
-  async start(filters) {
+  async mergeReports() {
     var _a, _b;
+    if (this.reporters.some((r) => r instanceof BlobReporter))
+      throw new Error("Cannot merge reports when `--reporter=blob` is used. Remove blob reporter from the config first.");
+    const { files, errors, coverages } = await readBlobs(this.config.mergeReports, this.projects);
+    await this.report("onInit", this);
+    await this.report("onPathsCollected", files.flatMap((f) => f.filepath));
+    const workspaceSpecs = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      const project = this.getProjectByName(file.projectName);
+      const specs = workspaceSpecs.get(project) || [];
+      specs.push(file);
+      workspaceSpecs.set(project, specs);
+    }
+    for (const [project, files2] of workspaceSpecs) {
+      const filepaths = files2.map((f) => f.filepath);
+      this.state.clearFiles(project, filepaths);
+      files2.forEach((file) => {
+        var _a2;
+        (_a2 = file.logs) == null ? void 0 : _a2.forEach((log) => this.state.updateUserLog(log));
+      });
+      this.state.collectFiles(files2);
+    }
+    await this.report("onCollected", files).catch(noop$1);
+    for (const file of files) {
+      const logs = [];
+      const taskPacks = [];
+      const tasks = getTasks(file);
+      for (const task of tasks) {
+        if (task.logs)
+          logs.push(...task.logs);
+        taskPacks.push([task.id, task.result, task.meta]);
+      }
+      logs.sort((log1, log2) => log1.time - log2.time);
+      for (const log of logs)
+        await this.report("onUserConsoleLog", log).catch(noop$1);
+      await this.report("onTaskUpdate", taskPacks).catch(noop$1);
+    }
+    if (hasFailed(files))
+      process.exitCode = 1;
+    await this.report("onFinished", files, errors);
+    await this.initCoverageProvider();
+    await ((_b = (_a = this.coverageProvider) == null ? void 0 : _a.mergeReports) == null ? void 0 : _b.call(_a, coverages));
+  }
+  async start(filters) {
+    var _a, _b, _c, _d;
     this._onClose = [];
     try {
       await this.initCoverageProvider();
@@ -13780,9 +15653,10 @@ class Vitest {
       await this.globTestFiles(filters)
     );
     if (!files.length) {
-      await this.reportCoverage(true);
+      const coverage = await ((_c = (_b = this.coverageProvider) == null ? void 0 : _b.generateCoverage) == null ? void 0 : _c.call(_b, { allTestsRun: true }));
+      await this.reportCoverage(coverage, true);
       this.logger.printNoTestFound(filters);
-      if (!this.config.watch || !(this.config.changed || ((_b = this.config.related) == null ? void 0 : _b.length))) {
+      if (!this.config.watch || !(this.config.changed || ((_d = this.config.related) == null ? void 0 : _d.length))) {
         const exitCode = this.config.passWithNoTests ? 0 : 1;
         process.exit(exitCode);
       }
@@ -13884,11 +15758,14 @@ class Vitest {
     const vitestDir = projectVitestPath ? resolve(projectVitestPath.id, "../..") : rootDir;
     this.distPath = join(vitestDir, "dist");
   }
-  async runFiles(paths, allTestsRun) {
+  async runFiles(specs, allTestsRun) {
     await this.initializeDistPath();
-    const filepaths = paths.map(([, file]) => file);
+    const filepaths = specs.map(([, file]) => file);
     this.state.collectPaths(filepaths);
     await this.report("onPathsCollected", filepaths);
+    await this.report("onSpecsCollected", specs.map(
+      ([project, file]) => [{ name: project.config.name, root: project.config.root }, file]
+    ));
     await this.runningPromise;
     this._onCancelListeners = [];
     this.isCancelling = false;
@@ -13902,9 +15779,9 @@ class Vitest {
       this.state.clearErrors();
       if (!this.isFirstRun && this.config.coverage.cleanOnRerun)
         await ((_a = this.coverageProvider) == null ? void 0 : _a.clean());
-      await this.initializeGlobalSetup(paths);
+      await this.initializeGlobalSetup(specs);
       try {
-        await this.pool.runTests(paths, invalidates);
+        await this.pool.runTests(specs, invalidates);
       } catch (err) {
         this.state.catchError(err, "Unhandled Error");
       }
@@ -13914,9 +15791,11 @@ class Vitest {
       this.cache.results.updateResults(files);
       await this.cache.results.writeToCache();
     })().finally(async () => {
-      const specs = Array.from(new Set(paths.map(([, p]) => p)));
-      await this.report("onFinished", this.state.getFiles(specs), this.state.getUnhandledErrors());
-      await this.reportCoverage(allTestsRun);
+      var _a;
+      const files = Array.from(new Set(specs.map(([, p]) => p)));
+      const coverage = await ((_a = this.coverageProvider) == null ? void 0 : _a.generateCoverage({ allTestsRun }));
+      await this.report("onFinished", this.state.getFiles(files), this.state.getUnhandledErrors(), coverage);
+      await this.reportCoverage(coverage, allTestsRun);
       this.runningPromise = void 0;
       this.isFirstRun = false;
       this.config.changed = false;
@@ -14037,7 +15916,7 @@ class Vitest {
       tests.map((test) => slash$1(test))
     );
   }
-  unregisterWatcher = noop$2;
+  unregisterWatcher = noop$1;
   registerWatcher() {
     const updateLastChanged = (filepath) => {
       const projects = this.getModuleProjects(filepath);
@@ -14101,7 +15980,7 @@ class Vitest {
       watcher.off("change", onChange);
       watcher.off("unlink", onUnlink);
       watcher.off("add", onAdd);
-      this.unregisterWatcher = noop$2;
+      this.unregisterWatcher = noop$1;
     };
   }
   /**
@@ -14148,11 +16027,11 @@ class Vitest {
     }
     return Array.from(new Set(files));
   }
-  async reportCoverage(allTestsRun) {
+  async reportCoverage(coverage, allTestsRun) {
     if (!this.config.coverage.reportOnFailure && this.state.getCountOfFailedTests() > 0)
       return;
     if (this.coverageProvider) {
-      await this.coverageProvider.reportCoverage({ allTestsRun });
+      await this.coverageProvider.reportCoverage(coverage, { allTestsRun });
       for (const reporter of this.reporters) {
         if (reporter instanceof WebSocketReporter)
           reporter.onFinishedReportCoverage();
@@ -14285,7 +16164,7 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
           removeUndefinedValues(viteConfig.test ?? {}),
           options
         );
-        testConfig.api = resolveApiServerConfig(testConfig);
+        testConfig.api = resolveApiServerConfig(testConfig, defaultPort);
         const defines = deleteDefineConfig(viteConfig);
         options.defines = defines;
         let open = false;
@@ -14329,7 +16208,7 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
                 isolate: ((_c = (_b = options.poolOptions) == null ? void 0 : _b.threads) == null ? void 0 : _c.isolate) ?? options.isolate ?? ((_e = (_d = testConfig.poolOptions) == null ? void 0 : _d.threads) == null ? void 0 : _e.isolate) ?? ((_f = viteConfig.test) == null ? void 0 : _f.isolate)
               },
               forks: {
-                isolate: ((_h = (_g = options.poolOptions) == null ? void 0 : _g.threads) == null ? void 0 : _h.isolate) ?? options.isolate ?? ((_j = (_i = testConfig.poolOptions) == null ? void 0 : _i.threads) == null ? void 0 : _j.isolate) ?? ((_k = viteConfig.test) == null ? void 0 : _k.isolate)
+                isolate: ((_h = (_g = options.poolOptions) == null ? void 0 : _g.forks) == null ? void 0 : _h.isolate) ?? options.isolate ?? ((_j = (_i = testConfig.poolOptions) == null ? void 0 : _i.forks) == null ? void 0 : _j.isolate) ?? ((_k = viteConfig.test) == null ? void 0 : _k.isolate)
               }
             }
           }
@@ -14380,7 +16259,7 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
           viteConfigTest,
           options
         );
-        options.api = resolveApiServerConfig(options);
+        options.api = resolveApiServerConfig(options, defaultPort);
         const { PROD, DEV, ...envs } = viteConfig.env;
         (_a = process.env).PROD ?? (_a.PROD = PROD ? "1" : "");
         (_b = process.env).DEV ?? (_b.DEV = DEV ? "1" : "");
@@ -14396,14 +16275,9 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
             console.log("[debug] watcher is ready");
           });
         }
-        try {
-          await ctx.setServer(options, server, userConfig);
-          if (options.api && options.watch)
-            (await Promise.resolve().then(function () { return setup$1; })).setup(ctx);
-        } catch (err) {
-          ctx.logger.printError(err, { fullStack: true });
-          process.exit(1);
-        }
+        await ctx.setServer(options, server, userConfig);
+        if (options.api && options.watch)
+          (await Promise.resolve().then(function () { return setup$1; })).setup(ctx);
         if (!options.watch)
           await server.watcher.close();
       }
@@ -14930,12 +16804,12 @@ function requirePrompt$1 () {
 	if (hasRequiredPrompt$1) return prompt$2;
 	hasRequiredPrompt$1 = 1;
 
-	const readline = require$$0$6;
+	const readline = require$$0$7;
 
 	const _require = requireUtil$1(),
 	      action = _require.action;
 
-	const EventEmitter = require$$0$3;
+	const EventEmitter = require$$0$4;
 
 	const _require2 = requireSrc(),
 	      beep = _require2.beep,
@@ -18095,9 +19969,9 @@ function requirePrompt () {
 	if (hasRequiredPrompt) return prompt$1;
 	hasRequiredPrompt = 1;
 
-	const readline = require$$0$6;
+	const readline = require$$0$7;
 	const { action } = requireUtil();
-	const EventEmitter = require$$0$3;
+	const EventEmitter = require$$0$4;
 	const { beep, cursor } = requireSrc();
 	const color = requireKleur();
 
@@ -21038,13 +22912,15 @@ async function startVitest(mode, cliFilters = [], options = {}, viteOverrides, v
       ctx.start(cliFilters);
   });
   try {
-    if (ctx.config.standalone)
+    if (ctx.config.mergeReports)
+      await ctx.mergeReports();
+    else if (ctx.config.standalone)
       await ctx.init();
     else
       await ctx.start(cliFilters);
   } catch (e) {
     process.exitCode = 1;
-    await ctx.logger.printError(e, { fullStack: true, type: "Unhandled Error" });
+    ctx.logger.printError(e, { fullStack: true, type: "Unhandled Error" });
     ctx.logger.error("\n\n");
     return ctx;
   }
@@ -21060,4 +22936,4 @@ var cliApi = /*#__PURE__*/Object.freeze({
   startVitest: startVitest
 });
 
-export { VitestPlugin as V, createMethodsRPC as a, VitestPackageInstaller as b, createVitest as c, cliApi as d, registerConsoleShortcuts as r, startVitest as s };
+export { VitestPlugin as V, createMethodsRPC as a, VitestPackageInstaller as b, createVitest as c, cliApi as d, getFilePoolName as g, registerConsoleShortcuts as r, startVitest as s };