@vitest/browser 2.1.0 → 2.1.2

package/dist/client/__vitest_browser__/orchestrator-N9hisloQ.js

@@ -0,0 +1,1096 @@
+var __defProp = Object.defineProperty;
+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, typeof key !== "symbol" ? key + "" : key, value);
+import { M as MockerRegistry, _ as __vitePreload, a as ManualMockedModule, g as getBrowserState, b as getConfig } from "./preload-helper-D-WYp1PK.js";
+import { channel, client, globalChannel } from "@vitest/browser/client";
+var f = {
+  reset: [0, 0],
+  bold: [1, 22, "\x1B[22m\x1B[1m"],
+  dim: [2, 22, "\x1B[22m\x1B[2m"],
+  italic: [3, 23],
+  underline: [4, 24],
+  inverse: [7, 27],
+  hidden: [8, 28],
+  strikethrough: [9, 29],
+  black: [30, 39],
+  red: [31, 39],
+  green: [32, 39],
+  yellow: [33, 39],
+  blue: [34, 39],
+  magenta: [35, 39],
+  cyan: [36, 39],
+  white: [37, 39],
+  gray: [90, 39],
+  bgBlack: [40, 49],
+  bgRed: [41, 49],
+  bgGreen: [42, 49],
+  bgYellow: [43, 49],
+  bgBlue: [44, 49],
+  bgMagenta: [45, 49],
+  bgCyan: [46, 49],
+  bgWhite: [47, 49],
+  blackBright: [90, 39],
+  redBright: [91, 39],
+  greenBright: [92, 39],
+  yellowBright: [93, 39],
+  blueBright: [94, 39],
+  magentaBright: [95, 39],
+  cyanBright: [96, 39],
+  whiteBright: [97, 39],
+  bgBlackBright: [100, 49],
+  bgRedBright: [101, 49],
+  bgGreenBright: [102, 49],
+  bgYellowBright: [103, 49],
+  bgBlueBright: [104, 49],
+  bgMagentaBright: [105, 49],
+  bgCyanBright: [106, 49],
+  bgWhiteBright: [107, 49]
+}, h = Object.entries(f);
+function a(n) {
+  return String(n);
+}
+a.open = "";
+a.close = "";
+function C(n = false) {
+  let e = typeof process != "undefined" ? process : void 0, i = (e == null ? void 0 : e.env) || {}, g = (e == null ? void 0 : e.argv) || [];
+  return !("NO_COLOR" in i || g.includes("--no-color")) && ("FORCE_COLOR" in i || g.includes("--color") || (e == null ? void 0 : e.platform) === "win32" || n && i.TERM !== "dumb" || "CI" in i) || typeof window != "undefined" && !!window.chrome;
+}
+function p(n = false) {
+  let e = C(n), i = (r, t, c, o) => {
+    let l = "", s = 0;
+    do
+      l += r.substring(s, o) + c, s = o + t.length, o = r.indexOf(t, s);
+    while (~o);
+    return l + r.substring(s);
+  }, g = (r, t, c = r) => {
+    let o = (l) => {
+      let s = String(l), b = s.indexOf(t, r.length);
+      return ~b ? r + i(s, t, c, b) + t : r + s + t;
+    };
+    return o.open = r, o.close = t, o;
+  }, u = {
+    isColorSupported: e
+  }, d = (r) => `\x1B[${r}m`;
+  for (let [r, t] of h)
+    u[r] = e ? g(
+      d(t[0]),
+      d(t[1]),
+      t[2]
+    ) : a;
+  return u;
+}
+p(false);
+let getPromiseValue = () => "Promise{…}";
+try {
+  const { getPromiseDetails, kPending, kRejected } = process.binding("util");
+  if (Array.isArray(getPromiseDetails(Promise.resolve()))) {
+    getPromiseValue = (value, options) => {
+      const [state, innerValue] = getPromiseDetails(value);
+      if (state === kPending) {
+        return "Promise{<pending>}";
+      }
+      return `Promise${state === kRejected ? "!" : ""}{${options.inspect(innerValue, options)}}`;
+    };
+  }
+} catch (notNode) {
+}
+let nodeInspect = false;
+try {
+  const nodeUtil = require("util");
+  nodeInspect = nodeUtil.inspect ? nodeUtil.inspect.custom : false;
+} catch (noNodeInspect) {
+  nodeInspect = false;
+}
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+  if (!input) {
+    return input;
+  }
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
+function cwd() {
+  if (typeof process !== "undefined" && typeof process.cwd === "function") {
+    return process.cwd().replace(/\\/g, "/");
+  }
+  return "/";
+}
+const resolve = function(...arguments_) {
+  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+    const path = index >= 0 ? arguments_[index] : cwd();
+    if (!path || path.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path}/${resolvedPath}`;
+    resolvedAbsolute = isAbsolute(path);
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+    return `/${resolvedPath}`;
+  }
+  return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path.length; ++index) {
+    if (index < path.length) {
+      char = path[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) ;
+      else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+const isAbsolute = function(p2) {
+  return _IS_ABSOLUTE_RE.test(p2);
+};
+const relative = function(from, to) {
+  const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
+  const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
+  if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) {
+    return _to.join("/");
+  }
+  const _fromCopy = [..._from];
+  for (const segment of _fromCopy) {
+    if (_to[0] !== segment) {
+      break;
+    }
+    _from.shift();
+    _to.shift();
+  }
+  return [..._from.map(() => ".."), ..._to].join("/");
+};
+var jsTokens_1;
+var hasRequiredJsTokens;
+function requireJsTokens() {
+  if (hasRequiredJsTokens) return jsTokens_1;
+  hasRequiredJsTokens = 1;
+  var Identifier, JSXIdentifier, JSXPunctuator, JSXString, JSXText, KeywordsWithExpressionAfter, KeywordsWithNoLineTerminatorAfter, LineTerminatorSequence, MultiLineComment, Newline, NumericLiteral, Punctuator, RegularExpressionLiteral, SingleLineComment, StringLiteral, Template, TokensNotPrecedingObjectLiteral, TokensPrecedingExpression, WhiteSpace;
+  RegularExpressionLiteral = /\/(?![*\/])(?:\[(?:(?![\]\\]).|\\.)*\]|(?![\/\\]).|\\.)*(\/[$_\u200C\u200D\p{ID_Continue}]*|\\)?/yu;
+  Punctuator = /--|\+\+|=>|\.{3}|\??\.(?!\d)|(?:&&|\|\||\?\?|[+\-%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2}|\/(?![\/*]))=?|[?~,:;[\](){}]/y;
+  Identifier = /(\x23?)(?=[$_\p{ID_Start}\\])(?:[$_\u200C\u200D\p{ID_Continue}]|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+/yu;
+  StringLiteral = /(['"])(?:(?!\1)[^\\\n\r]|\\(?:\r\n|[^]))*(\1)?/y;
+  NumericLiteral = /(?:0[xX][\da-fA-F](?:_?[\da-fA-F])*|0[oO][0-7](?:_?[0-7])*|0[bB][01](?:_?[01])*)n?|0n|[1-9](?:_?\d)*n|(?:(?:0(?!\d)|0\d*[89]\d*|[1-9](?:_?\d)*)(?:\.(?:\d(?:_?\d)*)?)?|\.\d(?:_?\d)*)(?:[eE][+-]?\d(?:_?\d)*)?|0[0-7]+/y;
+  Template = /[`}](?:[^`\\$]|\\[^]|\$(?!\{))*(`|\$\{)?/y;
+  WhiteSpace = /[\t\v\f\ufeff\p{Zs}]+/yu;
+  LineTerminatorSequence = /\r?\n|[\r\u2028\u2029]/y;
+  MultiLineComment = /\/\*(?:[^*]|\*(?!\/))*(\*\/)?/y;
+  SingleLineComment = /\/\/.*/y;
+  JSXPunctuator = /[<>.:={}]|\/(?![\/*])/y;
+  JSXIdentifier = /[$_\p{ID_Start}][$_\u200C\u200D\p{ID_Continue}-]*/yu;
+  JSXString = /(['"])(?:(?!\1)[^])*(\1)?/y;
+  JSXText = /[^<>{}]+/y;
+  TokensPrecedingExpression = /^(?:[\/+-]|\.{3}|\?(?:InterpolationIn(?:JSX|Template)|NoLineTerminatorHere|NonExpressionParenEnd|UnaryIncDec))?$|[{}([,;<>=*%&|^!~?:]$/;
+  TokensNotPrecedingObjectLiteral = /^(?:=>|[;\]){}]|else|\?(?:NoLineTerminatorHere|NonExpressionParenEnd))?$/;
+  KeywordsWithExpressionAfter = /^(?:await|case|default|delete|do|else|instanceof|new|return|throw|typeof|void|yield)$/;
+  KeywordsWithNoLineTerminatorAfter = /^(?:return|throw|yield)$/;
+  Newline = RegExp(LineTerminatorSequence.source);
+  jsTokens_1 = function* (input, { jsx = false } = {}) {
+    var braces, firstCodePoint, isExpression, lastIndex, lastSignificantToken, length, match, mode, nextLastIndex, nextLastSignificantToken, parenNesting, postfixIncDec, punctuator, stack;
+    ({ length } = input);
+    lastIndex = 0;
+    lastSignificantToken = "";
+    stack = [
+      { tag: "JS" }
+    ];
+    braces = [];
+    parenNesting = 0;
+    postfixIncDec = false;
+    while (lastIndex < length) {
+      mode = stack[stack.length - 1];
+      switch (mode.tag) {
+        case "JS":
+        case "JSNonExpressionParen":
+        case "InterpolationInTemplate":
+        case "InterpolationInJSX":
+          if (input[lastIndex] === "/" && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken))) {
+            RegularExpressionLiteral.lastIndex = lastIndex;
+            if (match = RegularExpressionLiteral.exec(input)) {
+              lastIndex = RegularExpressionLiteral.lastIndex;
+              lastSignificantToken = match[0];
+              postfixIncDec = true;
+              yield {
+                type: "RegularExpressionLiteral",
+                value: match[0],
+                closed: match[1] !== void 0 && match[1] !== "\\"
+              };
+              continue;
+            }
+          }
+          Punctuator.lastIndex = lastIndex;
+          if (match = Punctuator.exec(input)) {
+            punctuator = match[0];
+            nextLastIndex = Punctuator.lastIndex;
+            nextLastSignificantToken = punctuator;
+            switch (punctuator) {
+              case "(":
+                if (lastSignificantToken === "?NonExpressionParenKeyword") {
+                  stack.push({
+                    tag: "JSNonExpressionParen",
+                    nesting: parenNesting
+                  });
+                }
+                parenNesting++;
+                postfixIncDec = false;
+                break;
+              case ")":
+                parenNesting--;
+                postfixIncDec = true;
+                if (mode.tag === "JSNonExpressionParen" && parenNesting === mode.nesting) {
+                  stack.pop();
+                  nextLastSignificantToken = "?NonExpressionParenEnd";
+                  postfixIncDec = false;
+                }
+                break;
+              case "{":
+                Punctuator.lastIndex = 0;
+                isExpression = !TokensNotPrecedingObjectLiteral.test(lastSignificantToken) && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken));
+                braces.push(isExpression);
+                postfixIncDec = false;
+                break;
+              case "}":
+                switch (mode.tag) {
+                  case "InterpolationInTemplate":
+                    if (braces.length === mode.nesting) {
+                      Template.lastIndex = lastIndex;
+                      match = Template.exec(input);
+                      lastIndex = Template.lastIndex;
+                      lastSignificantToken = match[0];
+                      if (match[1] === "${") {
+                        lastSignificantToken = "?InterpolationInTemplate";
+                        postfixIncDec = false;
+                        yield {
+                          type: "TemplateMiddle",
+                          value: match[0]
+                        };
+                      } else {
+                        stack.pop();
+                        postfixIncDec = true;
+                        yield {
+                          type: "TemplateTail",
+                          value: match[0],
+                          closed: match[1] === "`"
+                        };
+                      }
+                      continue;
+                    }
+                    break;
+                  case "InterpolationInJSX":
+                    if (braces.length === mode.nesting) {
+                      stack.pop();
+                      lastIndex += 1;
+                      lastSignificantToken = "}";
+                      yield {
+                        type: "JSXPunctuator",
+                        value: "}"
+                      };
+                      continue;
+                    }
+                }
+                postfixIncDec = braces.pop();
+                nextLastSignificantToken = postfixIncDec ? "?ExpressionBraceEnd" : "}";
+                break;
+              case "]":
+                postfixIncDec = true;
+                break;
+              case "++":
+              case "--":
+                nextLastSignificantToken = postfixIncDec ? "?PostfixIncDec" : "?UnaryIncDec";
+                break;
+              case "<":
+                if (jsx && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken))) {
+                  stack.push({ tag: "JSXTag" });
+                  lastIndex += 1;
+                  lastSignificantToken = "<";
+                  yield {
+                    type: "JSXPunctuator",
+                    value: punctuator
+                  };
+                  continue;
+                }
+                postfixIncDec = false;
+                break;
+              default:
+                postfixIncDec = false;
+            }
+            lastIndex = nextLastIndex;
+            lastSignificantToken = nextLastSignificantToken;
+            yield {
+              type: "Punctuator",
+              value: punctuator
+            };
+            continue;
+          }
+          Identifier.lastIndex = lastIndex;
+          if (match = Identifier.exec(input)) {
+            lastIndex = Identifier.lastIndex;
+            nextLastSignificantToken = match[0];
+            switch (match[0]) {
+              case "for":
+              case "if":
+              case "while":
+              case "with":
+                if (lastSignificantToken !== "." && lastSignificantToken !== "?.") {
+                  nextLastSignificantToken = "?NonExpressionParenKeyword";
+                }
+            }
+            lastSignificantToken = nextLastSignificantToken;
+            postfixIncDec = !KeywordsWithExpressionAfter.test(match[0]);
+            yield {
+              type: match[1] === "#" ? "PrivateIdentifier" : "IdentifierName",
+              value: match[0]
+            };
+            continue;
+          }
+          StringLiteral.lastIndex = lastIndex;
+          if (match = StringLiteral.exec(input)) {
+            lastIndex = StringLiteral.lastIndex;
+            lastSignificantToken = match[0];
+            postfixIncDec = true;
+            yield {
+              type: "StringLiteral",
+              value: match[0],
+              closed: match[2] !== void 0
+            };
+            continue;
+          }
+          NumericLiteral.lastIndex = lastIndex;
+          if (match = NumericLiteral.exec(input)) {
+            lastIndex = NumericLiteral.lastIndex;
+            lastSignificantToken = match[0];
+            postfixIncDec = true;
+            yield {
+              type: "NumericLiteral",
+              value: match[0]
+            };
+            continue;
+          }
+          Template.lastIndex = lastIndex;
+          if (match = Template.exec(input)) {
+            lastIndex = Template.lastIndex;
+            lastSignificantToken = match[0];
+            if (match[1] === "${") {
+              lastSignificantToken = "?InterpolationInTemplate";
+              stack.push({
+                tag: "InterpolationInTemplate",
+                nesting: braces.length
+              });
+              postfixIncDec = false;
+              yield {
+                type: "TemplateHead",
+                value: match[0]
+              };
+            } else {
+              postfixIncDec = true;
+              yield {
+                type: "NoSubstitutionTemplate",
+                value: match[0],
+                closed: match[1] === "`"
+              };
+            }
+            continue;
+          }
+          break;
+        case "JSXTag":
+        case "JSXTagEnd":
+          JSXPunctuator.lastIndex = lastIndex;
+          if (match = JSXPunctuator.exec(input)) {
+            lastIndex = JSXPunctuator.lastIndex;
+            nextLastSignificantToken = match[0];
+            switch (match[0]) {
+              case "<":
+                stack.push({ tag: "JSXTag" });
+                break;
+              case ">":
+                stack.pop();
+                if (lastSignificantToken === "/" || mode.tag === "JSXTagEnd") {
+                  nextLastSignificantToken = "?JSX";
+                  postfixIncDec = true;
+                } else {
+                  stack.push({ tag: "JSXChildren" });
+                }
+                break;
+              case "{":
+                stack.push({
+                  tag: "InterpolationInJSX",
+                  nesting: braces.length
+                });
+                nextLastSignificantToken = "?InterpolationInJSX";
+                postfixIncDec = false;
+                break;
+              case "/":
+                if (lastSignificantToken === "<") {
+                  stack.pop();
+                  if (stack[stack.length - 1].tag === "JSXChildren") {
+                    stack.pop();
+                  }
+                  stack.push({ tag: "JSXTagEnd" });
+                }
+            }
+            lastSignificantToken = nextLastSignificantToken;
+            yield {
+              type: "JSXPunctuator",
+              value: match[0]
+            };
+            continue;
+          }
+          JSXIdentifier.lastIndex = lastIndex;
+          if (match = JSXIdentifier.exec(input)) {
+            lastIndex = JSXIdentifier.lastIndex;
+            lastSignificantToken = match[0];
+            yield {
+              type: "JSXIdentifier",
+              value: match[0]
+            };
+            continue;
+          }
+          JSXString.lastIndex = lastIndex;
+          if (match = JSXString.exec(input)) {
+            lastIndex = JSXString.lastIndex;
+            lastSignificantToken = match[0];
+            yield {
+              type: "JSXString",
+              value: match[0],
+              closed: match[2] !== void 0
+            };
+            continue;
+          }
+          break;
+        case "JSXChildren":
+          JSXText.lastIndex = lastIndex;
+          if (match = JSXText.exec(input)) {
+            lastIndex = JSXText.lastIndex;
+            lastSignificantToken = match[0];
+            yield {
+              type: "JSXText",
+              value: match[0]
+            };
+            continue;
+          }
+          switch (input[lastIndex]) {
+            case "<":
+              stack.push({ tag: "JSXTag" });
+              lastIndex++;
+              lastSignificantToken = "<";
+              yield {
+                type: "JSXPunctuator",
+                value: "<"
+              };
+              continue;
+            case "{":
+              stack.push({
+                tag: "InterpolationInJSX",
+                nesting: braces.length
+              });
+              lastIndex++;
+              lastSignificantToken = "?InterpolationInJSX";
+              postfixIncDec = false;
+              yield {
+                type: "JSXPunctuator",
+                value: "{"
+              };
+              continue;
+          }
+      }
+      WhiteSpace.lastIndex = lastIndex;
+      if (match = WhiteSpace.exec(input)) {
+        lastIndex = WhiteSpace.lastIndex;
+        yield {
+          type: "WhiteSpace",
+          value: match[0]
+        };
+        continue;
+      }
+      LineTerminatorSequence.lastIndex = lastIndex;
+      if (match = LineTerminatorSequence.exec(input)) {
+        lastIndex = LineTerminatorSequence.lastIndex;
+        postfixIncDec = false;
+        if (KeywordsWithNoLineTerminatorAfter.test(lastSignificantToken)) {
+          lastSignificantToken = "?NoLineTerminatorHere";
+        }
+        yield {
+          type: "LineTerminatorSequence",
+          value: match[0]
+        };
+        continue;
+      }
+      MultiLineComment.lastIndex = lastIndex;
+      if (match = MultiLineComment.exec(input)) {
+        lastIndex = MultiLineComment.lastIndex;
+        if (Newline.test(match[0])) {
+          postfixIncDec = false;
+          if (KeywordsWithNoLineTerminatorAfter.test(lastSignificantToken)) {
+            lastSignificantToken = "?NoLineTerminatorHere";
+          }
+        }
+        yield {
+          type: "MultiLineComment",
+          value: match[0],
+          closed: match[1] !== void 0
+        };
+        continue;
+      }
+      SingleLineComment.lastIndex = lastIndex;
+      if (match = SingleLineComment.exec(input)) {
+        lastIndex = SingleLineComment.lastIndex;
+        postfixIncDec = false;
+        yield {
+          type: "SingleLineComment",
+          value: match[0]
+        };
+        continue;
+      }
+      firstCodePoint = String.fromCodePoint(input.codePointAt(lastIndex));
+      lastIndex += firstCodePoint.length;
+      lastSignificantToken = firstCodePoint;
+      postfixIncDec = false;
+      yield {
+        type: mode.tag.startsWith("JSX") ? "JSXInvalid" : "Invalid",
+        value: firstCodePoint
+      };
+    }
+    return void 0;
+  };
+  return jsTokens_1;
+}
+requireJsTokens();
+var reservedWords = {
+  keyword: [
+    "break",
+    "case",
+    "catch",
+    "continue",
+    "debugger",
+    "default",
+    "do",
+    "else",
+    "finally",
+    "for",
+    "function",
+    "if",
+    "return",
+    "switch",
+    "throw",
+    "try",
+    "var",
+    "const",
+    "while",
+    "with",
+    "new",
+    "this",
+    "super",
+    "class",
+    "extends",
+    "export",
+    "import",
+    "null",
+    "true",
+    "false",
+    "in",
+    "instanceof",
+    "typeof",
+    "void",
+    "delete"
+  ],
+  strict: [
+    "implements",
+    "interface",
+    "let",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "static",
+    "yield"
+  ]
+};
+new Set(reservedWords.keyword);
+new Set(reservedWords.strict);
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+  let id = "";
+  let i = size;
+  while (i--) {
+    id += urlAlphabet[Math.random() * 64 | 0];
+  }
+  return id;
+}
+function generateHash(str) {
+  let hash = 0;
+  if (str.length === 0) {
+    return `${hash}`;
+  }
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return `${hash}`;
+}
+function getUiAPI() {
+  return window.__vitest_ui_api__;
+}
+const postfixRE = /[?#].*$/;
+function cleanUrl(url2) {
+  return url2.replace(postfixRE, "");
+}
+class ModuleMockerMSWInterceptor {
+  constructor(options = {}) {
+    __publicField(this, "mocks", new MockerRegistry());
+    __publicField(this, "started", false);
+    __publicField(this, "startPromise");
+    this.options = options;
+    if (!options.globalThisAccessor) {
+      options.globalThisAccessor = '"__vitest_mocker__"';
+    }
+  }
+  async register(module) {
+    await this.init();
+    this.mocks.add(module);
+  }
+  async delete(url2) {
+    await this.init();
+    this.mocks.delete(url2);
+  }
+  invalidate() {
+    this.mocks.clear();
+  }
+  async resolveManualMock(mock) {
+    const exports = Object.keys(await mock.resolve());
+    const module = `const module = globalThis[${this.options.globalThisAccessor}].getFactoryModule("${mock.url}");`;
+    const keys = exports.map((name) => {
+      if (name === "default") {
+        return `export default module["default"];`;
+      }
+      return `export const ${name} = module["${name}"];`;
+    }).join("\n");
+    const text = `${module}
+${keys}`;
+    return new Response(text, {
+      headers: {
+        "Content-Type": "application/javascript"
+      }
+    });
+  }
+  async init() {
+    if (this.started) {
+      return;
+    }
+    if (this.startPromise) {
+      return this.startPromise;
+    }
+    const worker = this.options.mswWorker;
+    this.startPromise = Promise.all([
+      worker ? {
+        setupWorker(handler) {
+          worker.use(handler);
+          return worker;
+        }
+      } : __vitePreload(() => import("msw/browser"), true ? [] : void 0),
+      __vitePreload(() => import("msw/core/http"), true ? [] : void 0)
+    ]).then(([{ setupWorker }, { http }]) => {
+      const worker2 = setupWorker(
+        http.get(/.+/, async ({ request }) => {
+          const path = cleanQuery(request.url.slice(location.origin.length));
+          if (!this.mocks.has(path)) {
+            if (path.includes("/deps/")) {
+              return fetch(bypass(request));
+            }
+            return passthrough();
+          }
+          const mock = this.mocks.get(path);
+          switch (mock.type) {
+            case "manual":
+              return this.resolveManualMock(mock);
+            case "automock":
+            case "autospy":
+              return Response.redirect(injectQuery(path, `mock=${mock.type}`));
+            case "redirect":
+              return Response.redirect(mock.redirect);
+            default:
+              throw new Error(`Unknown mock type: ${mock.type}`);
+          }
+        })
+      );
+      return worker2.start(this.options.mswOptions);
+    }).finally(() => {
+      this.started = true;
+      this.startPromise = void 0;
+    });
+    await this.startPromise;
+  }
+}
+const timestampRegexp = /(\?|&)t=\d{13}/;
+const versionRegexp = /(\?|&)v=\w{8}/;
+function cleanQuery(url2) {
+  return url2.replace(timestampRegexp, "").replace(versionRegexp, "");
+}
+function passthrough() {
+  return new Response(null, {
+    status: 302,
+    statusText: "Passthrough",
+    headers: {
+      "x-msw-intention": "passthrough"
+    }
+  });
+}
+function bypass(request) {
+  const clonedRequest = request.clone();
+  clonedRequest.headers.set("x-msw-intention", "bypass");
+  const cacheControl = clonedRequest.headers.get("cache-control");
+  if (cacheControl) {
+    clonedRequest.headers.set(
+      "cache-control",
+      // allow reinvalidation of the cache so mocks can be updated
+      cacheControl.replace(", immutable", "")
+    );
+  }
+  return clonedRequest;
+}
+const replacePercentageRE = /%/g;
+function injectQuery(url2, queryToInject) {
+  const resolvedUrl = new URL(
+    url2.replace(replacePercentageRE, "%25"),
+    location.href
+  );
+  const { search, hash } = resolvedUrl;
+  const pathname = cleanUrl(url2);
+  return `${pathname}?${queryToInject}${search ? `&${search.slice(1)}` : ""}${hash ?? ""}`;
+}
+class VitestBrowserModuleMockerInterceptor extends ModuleMockerMSWInterceptor {
+  async register(event) {
+    if (event.type === "manual") {
+      const module = ManualMockedModule.fromJSON(event, async () => {
+        const keys = await getFactoryExports(event.url);
+        return Object.fromEntries(keys.map((key) => [key, null]));
+      });
+      await super.register(module);
+    } else {
+      await this.init();
+      this.mocks.register(event);
+    }
+    channel.postMessage({ type: "mock:done" });
+  }
+  async delete(url2) {
+    await super.delete(url2);
+    channel.postMessage({ type: "unmock:done" });
+  }
+}
+function createModuleMockerInterceptor() {
+  return new VitestBrowserModuleMockerInterceptor({
+    globalThisAccessor: '"__vitest_mocker__"',
+    mswOptions: {
+      serviceWorker: {
+        url: "/__vitest_msw__"
+      },
+      quiet: true
+    }
+  });
+}
+function getFactoryExports(id) {
+  const eventId = nanoid();
+  channel.postMessage({
+    type: "mock-factory:request",
+    eventId,
+    id
+  });
+  return new Promise((resolve2, reject) => {
+    channel.addEventListener(
+      "message",
+      function onMessage(e) {
+        if (e.data.type === "mock-factory:response" && e.data.eventId === eventId) {
+          resolve2(e.data.exports);
+          channel.removeEventListener("message", onMessage);
+        }
+        if (e.data.type === "mock-factory:error" && e.data.eventId === eventId) {
+          reject(e.data.error);
+          channel.removeEventListener("message", onMessage);
+        }
+      }
+    );
+  });
+}
+const url = new URL(location.href);
+const ID_ALL = "__vitest_all__";
+class IframeOrchestrator {
+  constructor() {
+    __publicField(this, "cancelled", false);
+    __publicField(this, "runningFiles", /* @__PURE__ */ new Set());
+    __publicField(this, "interceptor", createModuleMockerInterceptor());
+    __publicField(this, "iframes", /* @__PURE__ */ new Map());
+  }
+  async init() {
+    const testFiles = getBrowserState().files;
+    debug("test files", testFiles.join(", "));
+    this.runningFiles.clear();
+    testFiles.forEach((file) => this.runningFiles.add(file));
+    channel.addEventListener(
+      "message",
+      (e) => this.onIframeEvent(e)
+    );
+    globalChannel.addEventListener(
+      "message",
+      (e) => this.onGlobalChannelEvent(e)
+    );
+  }
+  async createTesters(testFiles) {
+    this.cancelled = false;
+    this.runningFiles.clear();
+    testFiles.forEach((file) => this.runningFiles.add(file));
+    const config = getConfig();
+    const container = await getContainer(config);
+    if (config.browser.ui) {
+      container.className = "absolute origin-top mt-[8px]";
+      container.parentElement.setAttribute("data-ready", "true");
+      container.textContent = "";
+    }
+    const { width, height } = config.browser.viewport;
+    this.iframes.forEach((iframe) => iframe.remove());
+    this.iframes.clear();
+    if (config.isolate === false) {
+      const iframe = this.createIframe(container, ID_ALL);
+      await setIframeViewport(iframe, width, height);
+      return;
+    }
+    for (const file of testFiles) {
+      if (this.cancelled) {
+        done();
+        return;
+      }
+      const iframe = this.createIframe(container, file);
+      await setIframeViewport(iframe, width, height);
+      await new Promise((resolve2) => {
+        channel.addEventListener(
+          "message",
+          function handler(e) {
+            if (e.data.type === "done" || e.data.type === "error") {
+              channel.removeEventListener("message", handler);
+              resolve2();
+            }
+          }
+        );
+      });
+    }
+  }
+  createIframe(container, file) {
+    if (this.iframes.has(file)) {
+      this.iframes.get(file).remove();
+      this.iframes.delete(file);
+    }
+    const iframe = document.createElement("iframe");
+    iframe.setAttribute("loading", "eager");
+    iframe.setAttribute(
+      "src",
+      `${url.pathname}__vitest_test__/__test__/${getBrowserState().contextId}/${encodeURIComponent(file)}`
+    );
+    iframe.setAttribute("data-vitest", "true");
+    iframe.style.border = "none";
+    iframe.style.width = "100%";
+    iframe.style.height = "100%";
+    iframe.setAttribute("allowfullscreen", "true");
+    iframe.setAttribute("allow", "clipboard-write;");
+    iframe.setAttribute("name", "vitest-iframe");
+    this.iframes.set(file, iframe);
+    container.appendChild(iframe);
+    return iframe;
+  }
+  async onGlobalChannelEvent(e) {
+    debug("global channel event", JSON.stringify(e.data));
+    switch (e.data.type) {
+      case "cancel": {
+        this.cancelled = true;
+        break;
+      }
+    }
+  }
+  async onIframeEvent(e) {
+    var _a;
+    debug("iframe event", JSON.stringify(e.data));
+    switch (e.data.type) {
+      case "viewport": {
+        const { width, height, id } = e.data;
+        const iframe = this.iframes.get(id);
+        if (!iframe) {
+          const error = new Error(`Cannot find iframe with id ${id}`);
+          channel.postMessage({
+            type: "viewport:fail",
+            id,
+            error: error.message
+          });
+          await client.rpc.onUnhandledError(
+            {
+              name: "Teardown Error",
+              message: error.message
+            },
+            "Teardown Error"
+          );
+          return;
+        }
+        await setIframeViewport(iframe, width, height);
+        channel.postMessage({ type: "viewport:done", id });
+        break;
+      }
+      case "done": {
+        const filenames = e.data.filenames;
+        filenames.forEach((filename) => this.runningFiles.delete(filename));
+        if (!this.runningFiles.size) {
+          const ui = getUiAPI();
+          if (ui && filenames.length > 1) {
+            const id = generateFileId(filenames[filenames.length - 1]);
+            ui.setCurrentFileId(id);
+          }
+          await done();
+        } else {
+          const iframeId = e.data.id;
+          (_a = this.iframes.get(iframeId)) == null ? void 0 : _a.remove();
+          this.iframes.delete(iframeId);
+        }
+        break;
+      }
+      case "error": {
+        const iframeId = e.data.id;
+        this.iframes.delete(iframeId);
+        await client.rpc.onUnhandledError(e.data.error, e.data.errorType);
+        if (iframeId === ID_ALL) {
+          this.runningFiles.clear();
+        } else {
+          this.runningFiles.delete(iframeId);
+        }
+        if (!this.runningFiles.size) {
+          await done();
+        }
+        break;
+      }
+      case "mock:invalidate":
+        this.interceptor.invalidate();
+        break;
+      case "unmock":
+        await this.interceptor.delete(e.data.url);
+        break;
+      case "mock":
+        await this.interceptor.register(e.data.module);
+        break;
+      case "mock-factory:error":
+      case "mock-factory:response":
+        break;
+      default: {
+        e.data;
+        await client.rpc.onUnhandledError(
+          {
+            name: "Unexpected Event",
+            message: `Unexpected event: ${e.data.type}`
+          },
+          "Unexpected Event"
+        );
+        await done();
+      }
+    }
+  }
+}
+const orchestrator = new IframeOrchestrator();
+let promiseTesters;
+getBrowserState().createTesters = async (files) => {
+  await promiseTesters;
+  promiseTesters = orchestrator.createTesters(files).finally(() => {
+    promiseTesters = void 0;
+  });
+  await promiseTesters;
+};
+async function done() {
+  await client.rpc.finishBrowserTests(getBrowserState().contextId);
+}
+async function getContainer(config) {
+  if (config.browser.ui) {
+    const element = document.querySelector("#tester-ui");
+    if (!element) {
+      return new Promise((resolve2) => {
+        setTimeout(() => {
+          resolve2(getContainer(config));
+        }, 30);
+      });
+    }
+    return element;
+  }
+  return document.querySelector("#vitest-tester");
+}
+client.waitForConnection().then(async () => {
+  const testFiles = getBrowserState().files;
+  await orchestrator.init();
+  if (testFiles.length) {
+    await orchestrator.createTesters(testFiles);
+  }
+});
+function generateFileId(file) {
+  const config = getConfig();
+  const project = config.name || "";
+  const path = relative(config.root, file);
+  return generateHash(`${path}${project}`);
+}
+async function setIframeViewport(iframe, width, height) {
+  const ui = getUiAPI();
+  if (ui) {
+    await ui.setIframeViewport(width, height);
+  } else {
+    iframe.style.width = `${width}px`;
+    iframe.style.height = `${height}px`;
+  }
+}
+function debug(...args) {
+  const debug2 = getConfig().env.VITEST_BROWSER_DEBUG;
+  if (debug2 && debug2 !== "false") {
+    client.rpc.debug(...args.map(String));
+  }
+}