@vitest/browser 3.2.2 → 3.2.4

package/dist/client/__vitest_browser__/{orchestrator-D711E7wO.js → orchestrator-Bo1OwGWc.js}

@@ -475,8 +475,18 @@ function inspectAttribute([key, value], options) {
   }
   return `${options.stylize(String(key), "yellow")}=${options.stylize(`"${value}"`, "string")}`;
 }
-function inspectHTMLCollection(collection, options) {
-  return inspectList(collection, options, inspectHTML, "\n");
+function inspectNodeCollection(collection, options) {
+  return inspectList(collection, options, inspectNode, "\n");
+}
+function inspectNode(node, options) {
+  switch (node.nodeType) {
+    case 1:
+      return inspectHTML(node, options);
+    case 3:
+      return options.inspect(node.data, options);
+    default:
+      return options.inspect(node, options);
+  }
 }
 function inspectHTML(element, options) {
   const properties = element.getAttributeNames();
@@ -492,7 +502,7 @@ function inspectHTML(element, options) {
   }
   options.truncate -= propertyContents.length;
   const truncate2 = options.truncate;
-  let children = inspectHTMLCollection(element.children, options);
+  let children = inspectNodeCollection(element.children, options);
   if (children && children.length > truncate2) {
     children = `${truncator}(${element.children.length})`;
   }
@@ -500,13 +510,7 @@ function inspectHTML(element, options) {
 }
 const symbolsSupported = typeof Symbol === "function" && typeof Symbol.for === "function";
 const chaiInspect = symbolsSupported ? Symbol.for("chai/inspect") : "@@chai/inspect";
-let nodeInspect = false;
-try {
-  const nodeUtil = require("util");
-  nodeInspect = nodeUtil.inspect ? nodeUtil.inspect.custom : false;
-} catch (noNodeInspect) {
-  nodeInspect = false;
-}
+const nodeInspect = Symbol.for("nodejs.util.inspect.custom");
 const constructorMap = /* @__PURE__ */ new WeakMap();
 const stringTagMap = {};
 const baseTypesMap = {
@@ -548,14 +552,14 @@ const baseTypesMap = {
   DataView: () => "",
   ArrayBuffer: () => "",
   Error: inspectObject,
-  HTMLCollection: inspectHTMLCollection,
-  NodeList: inspectHTMLCollection
+  HTMLCollection: inspectNodeCollection,
+  NodeList: inspectNodeCollection
 };
 const inspectCustom = (value, options, type) => {
   if (chaiInspect in value && typeof value[chaiInspect] === "function") {
     return value[chaiInspect](options);
   }
-  if (nodeInspect && nodeInspect in value && typeof value[nodeInspect] === "function") {
+  if (nodeInspect in value && typeof value[nodeInspect] === "function") {
     return value[nodeInspect](options.depth, options);
   }
   if ("inspect" in value && typeof value.inspect === "function") {
@@ -770,11 +774,11 @@ function isNegativeNaN(val) {
   const isNegative = u32[1] >>> 31 === 1;
   return isNegative;
 }
-var jsTokens_1;
-var hasRequiredJsTokens;
-function requireJsTokens() {
-  if (hasRequiredJsTokens) return jsTokens_1;
-  hasRequiredJsTokens = 1;
+var jsTokens_1$1;
+var hasRequiredJsTokens$1;
+function requireJsTokens$1() {
+  if (hasRequiredJsTokens$1) return jsTokens_1$1;
+  hasRequiredJsTokens$1 = 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;
@@ -795,7 +799,7 @@ function requireJsTokens() {
   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 } = {}) {
+  jsTokens_1$1 = function* (input, { jsx = false } = {}) {
     var braces, firstCodePoint, isExpression, lastIndex, lastSignificantToken, length, match, mode, nextLastIndex, nextLastSignificantToken, parenNesting, postfixIncDec, punctuator, stack;
     ({ length } = input);
     lastIndex = 0;
@@ -1161,9 +1165,9 @@ function requireJsTokens() {
     }
     return void 0;
   };
-  return jsTokens_1;
+  return jsTokens_1$1;
 }
-requireJsTokens();
+requireJsTokens$1();
 var reservedWords = {
   keyword: [
     "break",
@@ -1355,22 +1359,22 @@ function extractLocation(urlLike) {
   if (!parts) {
     return [urlLike];
   }
-  let url2 = parts[1];
-  if (url2.startsWith("async ")) {
-    url2 = url2.slice(6);
+  let url = parts[1];
+  if (url.startsWith("async ")) {
+    url = url.slice(6);
   }
-  if (url2.startsWith("http:") || url2.startsWith("https:")) {
-    const urlObj = new URL(url2);
+  if (url.startsWith("http:") || url.startsWith("https:")) {
+    const urlObj = new URL(url);
     urlObj.searchParams.delete("import");
     urlObj.searchParams.delete("browserv");
-    url2 = urlObj.pathname + urlObj.hash + urlObj.search;
+    url = urlObj.pathname + urlObj.hash + urlObj.search;
   }
-  if (url2.startsWith("/@fs/")) {
-    const isWindows = /^\/@fs\/[a-zA-Z]:\//.test(url2);
-    url2 = url2.slice(isWindows ? 5 : 4);
+  if (url.startsWith("/@fs/")) {
+    const isWindows = /^\/@fs\/[a-zA-Z]:\//.test(url);
+    url = url.slice(isWindows ? 5 : 4);
   }
   return [
-    url2,
+    url,
     parts[2] || void 0,
     parts[3] || void 0
   ];
@@ -1389,12 +1393,12 @@ function parseSingleFFOrSafariStack(raw) {
   const functionNameRegex = /((.*".+"[^@]*)?[^@]*)(@)/;
   const matches = line.match(functionNameRegex);
   const functionName = matches && matches[1] ? matches[1] : void 0;
-  const [url2, lineNumber, columnNumber] = extractLocation(line.replace(functionNameRegex, ""));
-  if (!url2 || !lineNumber || !columnNumber) {
+  const [url, lineNumber, columnNumber] = extractLocation(line.replace(functionNameRegex, ""));
+  if (!url || !lineNumber || !columnNumber) {
     return null;
   }
   return {
-    file: url2,
+    file: url,
     method: functionName || "",
     line: Number.parseInt(lineNumber),
     column: Number.parseInt(columnNumber)
@@ -1416,11 +1420,11 @@ function parseSingleV8Stack(raw) {
     line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(,.*$)/g, "");
   }
   let sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, "");
-  const location2 = sanitizedLine.match(/ (\(.+\)$)/);
-  sanitizedLine = location2 ? sanitizedLine.replace(location2[0], "") : sanitizedLine;
-  const [url2, lineNumber, columnNumber] = extractLocation(location2 ? location2[1] : sanitizedLine);
-  let method = location2 && sanitizedLine || "";
-  let file = url2 && ["eval", "<anonymous>"].includes(url2) ? void 0 : url2;
+  const location = sanitizedLine.match(/ (\(.+\)$)/);
+  sanitizedLine = location ? sanitizedLine.replace(location[0], "") : sanitizedLine;
+  const [url, lineNumber, columnNumber] = extractLocation(location ? location[1] : sanitizedLine);
+  let method = location && sanitizedLine || "";
+  let file = url && ["eval", "<anonymous>"].includes(url) ? void 0 : url;
   if (!file || !lineNumber || !columnNumber) {
     return null;
   }
@@ -1441,6 +1445,486 @@ function parseSingleV8Stack(raw) {
     column: Number.parseInt(columnNumber)
   };
 }
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var jsTokens_1;
+var hasRequiredJsTokens;
+function requireJsTokens() {
+  if (hasRequiredJsTokens) return jsTokens_1;
+  hasRequiredJsTokens = 1;
+  var HashbangComment, Identifier, JSXIdentifier, JSXPunctuator, JSXString, JSXText, KeywordsWithExpressionAfter, KeywordsWithNoLineTerminatorAfter, LineTerminatorSequence, MultiLineComment, Newline, NumericLiteral, Punctuator, RegularExpressionLiteral, SingleLineComment, StringLiteral, Template, TokensNotPrecedingObjectLiteral, TokensPrecedingExpression, WhiteSpace;
+  RegularExpressionLiteral = /\/(?![*\/])(?:\[(?:[^\]\\\n\r\u2028\u2029]+|\\.)*\]?|[^\/[\\\n\r\u2028\u2029]+|\\.)*(\/[$_\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 = /(['"])(?:[^'"\\\n\r]+|(?!\1)['"]|\\(?:\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;
+  HashbangComment = /^#!.*/;
+  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;
+    if (match = HashbangComment.exec(input)) {
+      yield {
+        type: "HashbangComment",
+        value: match[0]
+      };
+      lastIndex = match[0].length;
+    }
+    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;
+}
+var jsTokensExports = requireJsTokens();
+const jsTokens = /* @__PURE__ */ getDefaultExportFromCjs(jsTokensExports);
+function stripLiteralJsTokens(code, options) {
+  const FILL = " ";
+  const FILL_COMMENT = " ";
+  let result = "";
+  const tokens = [];
+  for (const token of jsTokens(code, { jsx: false })) {
+    tokens.push(token);
+    if (token.type === "SingleLineComment") {
+      result += FILL_COMMENT.repeat(token.value.length);
+      continue;
+    }
+    if (token.type === "MultiLineComment") {
+      result += token.value.replace(/[^\n]/g, FILL_COMMENT);
+      continue;
+    }
+    if (token.type === "StringLiteral") {
+      if (!token.closed) {
+        result += token.value;
+        continue;
+      }
+      const body = token.value.slice(1, -1);
+      {
+        result += token.value[0] + FILL.repeat(body.length) + token.value[token.value.length - 1];
+        continue;
+      }
+    }
+    if (token.type === "NoSubstitutionTemplate") {
+      const body = token.value.slice(1, -1);
+      {
+        result += `\`${body.replace(/[^\n]/g, FILL)}\``;
+        continue;
+      }
+    }
+    if (token.type === "RegularExpressionLiteral") {
+      const body = token.value;
+      {
+        result += body.replace(/\/(.*)\/(\w?)$/g, (_, $1, $2) => `/${FILL.repeat($1.length)}/${$2}`);
+        continue;
+      }
+    }
+    if (token.type === "TemplateHead") {
+      const body = token.value.slice(1, -2);
+      {
+        result += `\`${body.replace(/[^\n]/g, FILL)}\${`;
+        continue;
+      }
+    }
+    if (token.type === "TemplateTail") {
+      const body = token.value.slice(0, -2);
+      {
+        result += `}${body.replace(/[^\n]/g, FILL)}\``;
+        continue;
+      }
+    }
+    if (token.type === "TemplateMiddle") {
+      const body = token.value.slice(1, -2);
+      {
+        result += `}${body.replace(/[^\n]/g, FILL)}\${`;
+        continue;
+      }
+    }
+    result += token.value;
+  }
+  return {
+    result,
+    tokens
+  };
+}
+function stripLiteral(code, options) {
+  return stripLiteralDetailed(code).result;
+}
+function stripLiteralDetailed(code, options) {
+  return stripLiteralJsTokens(code);
+}
 class PendingError extends Error {
   constructor(message, task, note) {
     super(message);
@@ -1671,7 +2155,7 @@ function resolveDeps(fixtures, depSet = /* @__PURE__ */ new Set(), pendingFixtur
   return pendingFixtures;
 }
 function getUsedProps(fn) {
-  let fnString = fn.toString();
+  let fnString = stripLiteral(fn.toString());
   if (/__async\((?:this|null), (?:null|arguments|\[[_0-9, ]*\]), function\*/.test(fnString)) {
     fnString = fnString.split(/__async\((?:this|null),/)[1];
   }
@@ -2095,14 +2579,17 @@ function createTaskCollector(fn, context) {
   };
   taskFn.extend = function(fixtures) {
     const _context = mergeContextFixtures(fixtures, context || {}, runner);
-    return createTest(function fn2(name, optionsOrFn, optionsOrTest) {
+    const originalWrapper = fn;
+    return createTest(function(name, optionsOrFn, optionsOrTest) {
       const collector = getCurrentSuite();
       const scopedFixtures = collector.fixtures();
       const context2 = { ...this };
       if (scopedFixtures) {
         context2.fixtures = mergeScopedFixtures(context2.fixtures || [], scopedFixtures);
       }
-      collector.test.fn.call(context2, formatName(name), optionsOrFn, optionsOrTest);
+      const { handler, options } = parseArguments(optionsOrFn, optionsOrTest);
+      const timeout = options.timeout ?? void 0;
+      originalWrapper.call(context2, formatName(name), handler, timeout);
     }, _context);
   };
   const _test = createChainable([
@@ -2193,6 +2680,7 @@ function generateHash(str) {
 }
 globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
 globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
+getSafeTimers();
 const packs = /* @__PURE__ */ new Map();
 const eventsPacks = [];
 const pendingTasksUpdates = [];
@@ -2315,7 +2803,7 @@ function createTestContext(test, runner2) {
     test.result.pending = true;
     throw new PendingError("test is skipped; abort execution", test, typeof condition === "string" ? condition : note);
   };
-  async function annotate(message, location2, type, attachment) {
+  async function annotate(message, location, type, attachment) {
     const annotation = {
       message,
       type: type || "notice"
@@ -2332,8 +2820,8 @@ function createTestContext(test, runner2) {
         attachment.body = encodeUint8Array(attachment.body);
       }
     }
-    if (location2) {
-      annotation.location = location2;
+    if (location) {
+      annotation.location = location;
     }
     if (!runner2.onTestAnnotate) {
       throw new Error(`Test runner doesn't support test annotations.`);
@@ -2347,22 +2835,22 @@ function createTestContext(test, runner2) {
     if (test.result && test.result.state !== "run") {
       throw new Error(`Cannot annotate tests outside of the test run. The test "${test.name}" finished running with the "${test.result.state}" state already.`);
     }
-    let location2;
+    let location;
     const stack = new Error("STACK_TRACE").stack;
     const index = stack.includes("STACK_TRACE") ? 2 : 1;
     const stackLine = stack.split("\n")[index];
     const parsed = parseSingleStack(stackLine);
     if (parsed) {
-      location2 = {
+      location = {
         file: parsed.file,
         line: parsed.line,
         column: parsed.column
       };
     }
     if (typeof type === "object") {
-      return recordAsyncAnnotation(test, annotate(message, location2, void 0, type));
+      return recordAsyncAnnotation(test, annotate(message, location, void 0, type));
     } else {
-      return recordAsyncAnnotation(test, annotate(message, location2, type, attachment));
+      return recordAsyncAnnotation(test, annotate(message, location, type, attachment));
     }
   };
   context.onTestFailed = (handler, timeout) => {
@@ -2452,7 +2940,6 @@ function recordAsyncAnnotation(test, promise) {
 function getUiAPI() {
   return window.__vitest_ui_api__;
 }
-const url = new URL(location.href);
 const ID_ALL = "__vitest_all__";
 class IframeOrchestrator {
   constructor() {
@@ -2592,7 +3079,7 @@ class IframeOrchestrator {
   }
   createTestIframe(iframeId) {
     const iframe = document.createElement("iframe");
-    const src = `${url.pathname}__vitest_test__/__test__/?sessionId=${getBrowserState().sessionId}&iframeId=${iframeId}`;
+    const src = `/?sessionId=${getBrowserState().sessionId}&iframeId=${iframeId}`;
     iframe.setAttribute("loading", "eager");
     iframe.setAttribute("src", src);
     iframe.setAttribute("data-vitest", "true");