vitest 0.8.2 → 0.8.5

package/dist/chunk-runtime-mocker.7cc59bee.js

@@ -0,0 +1,258 @@
+import { n as normalizeRequestId, i as isNodeBuiltin, t as toFilePath, V as ViteNodeRunner } from './chunk-vite-node-utils.a6890356.js';
+import { normalizePath } from 'vite';
+import { z as isWindows, A as mergeSlashes, h as dirname, f as basename, u as resolve } from './chunk-utils-base.aff0a195.js';
+import { existsSync, readdirSync } from 'fs';
+import { d as distDir } from './chunk-constants.76cf224a.js';
+import { g as getWorkerState } from './chunk-utils-global.7bcfa03c.js';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+function getType(value) {
+  return Object.prototype.toString.apply(value).slice(8, -1);
+}
+function getAllProperties(obj) {
+  const allProps = /* @__PURE__ */ new Set();
+  let curr = obj;
+  do {
+    if (curr === Object.prototype || curr === Function.prototype || curr === RegExp.prototype)
+      break;
+    const props = Object.getOwnPropertyNames(curr);
+    props.forEach((prop) => allProps.add(prop));
+  } while (curr = Object.getPrototypeOf(curr));
+  return Array.from(allProps);
+}
+const _VitestMocker = class {
+  constructor(options, moduleCache, request) {
+    this.options = options;
+    this.moduleCache = moduleCache;
+    this.callbacks = {};
+    this.root = this.options.root;
+    this.request = request;
+  }
+  get mockMap() {
+    return this.options.mockMap;
+  }
+  on(event, cb) {
+    var _a;
+    (_a = this.callbacks)[event] ?? (_a[event] = []);
+    this.callbacks[event].push(cb);
+  }
+  emit(event, ...args) {
+    (this.callbacks[event] ?? []).forEach((fn) => fn(...args));
+  }
+  getSuiteFilepath() {
+    return getWorkerState().filepath || "global";
+  }
+  getMocks() {
+    const suite = this.getSuiteFilepath();
+    const suiteMocks = this.mockMap.get(suite);
+    const globalMocks = this.mockMap.get("global");
+    return __spreadValues(__spreadValues({}, globalMocks), suiteMocks);
+  }
+  async resolvePath(id, importer) {
+    const path = await this.options.resolveId(id, importer);
+    return {
+      path: normalizeRequestId((path == null ? void 0 : path.id) || id),
+      external: (path == null ? void 0 : path.id.includes("/node_modules/")) ? id : null
+    };
+  }
+  async resolveMocks() {
+    await Promise.all(_VitestMocker.pendingIds.map(async (mock) => {
+      const { path, external } = await this.resolvePath(mock.id, mock.importer);
+      if (mock.type === "unmock")
+        this.unmockPath(path);
+      if (mock.type === "mock")
+        this.mockPath(path, external, mock.factory);
+    }));
+    _VitestMocker.pendingIds = [];
+  }
+  async callFunctionMock(dep, mock) {
+    var _a;
+    const cacheName = `${dep}__mock`;
+    const cached = (_a = this.moduleCache.get(cacheName)) == null ? void 0 : _a.exports;
+    if (cached)
+      return cached;
+    const exports = await mock();
+    this.emit("mocked", cacheName, { exports });
+    return exports;
+  }
+  getDependencyMock(dep) {
+    return this.getMocks()[this.resolveDependency(dep)];
+  }
+  resolveDependency(dep) {
+    return normalizeRequestId(dep).replace(/^\/@fs\//, isWindows ? "" : "/");
+  }
+  normalizePath(path) {
+    return normalizeRequestId(path.replace(this.root, "")).replace(/^\/@fs\//, isWindows ? "" : "/");
+  }
+  getFsPath(path, external) {
+    if (external)
+      return mergeSlashes(`/@fs/${path}`);
+    return normalizeRequestId(path.replace(this.root, ""));
+  }
+  resolveMockPath(mockPath, external) {
+    const path = normalizeRequestId(external || mockPath);
+    if (external || isNodeBuiltin(mockPath)) {
+      const mockDirname = dirname(path);
+      const baseFilename = basename(path);
+      const mockFolder = resolve(this.root, "__mocks__", mockDirname);
+      if (!existsSync(mockFolder))
+        return null;
+      const files = readdirSync(mockFolder);
+      for (const file of files) {
+        const [basename2] = file.split(".");
+        if (basename2 === baseFilename)
+          return resolve(mockFolder, file).replace(this.root, "");
+      }
+      return null;
+    }
+    const dir = dirname(path);
+    const baseId = basename(path);
+    const fullPath = resolve(dir, "__mocks__", baseId);
+    return existsSync(fullPath) ? fullPath.replace(this.root, "") : null;
+  }
+  mockValue(value) {
+    if (!_VitestMocker.spyModule) {
+      throw new Error("Error: Spy module is not defined. This is likely an internal bug in Vitest. Please report it to https://github.com/vitest-dev/vitest/issues");
+    }
+    const type = getType(value);
+    if (Array.isArray(value))
+      return [];
+    else if (type !== "Object" && type !== "Module")
+      return value;
+    const newObj = {};
+    const proproperties = getAllProperties(value);
+    for (const k of proproperties) {
+      newObj[k] = this.mockValue(value[k]);
+      const type2 = getType(value[k]);
+      if (type2.includes("Function") && !value[k]._isMockFunction) {
+        _VitestMocker.spyModule.spyOn(newObj, k).mockImplementation(() => void 0);
+        Object.defineProperty(newObj[k], "length", { value: 0 });
+      }
+    }
+    Object.setPrototypeOf(newObj, Object.getPrototypeOf(value));
+    return newObj;
+  }
+  unmockPath(path) {
+    const suitefile = this.getSuiteFilepath();
+    const fsPath = this.normalizePath(path);
+    const mock = this.mockMap.get(suitefile);
+    if (mock == null ? void 0 : mock[fsPath])
+      delete mock[fsPath];
+  }
+  mockPath(path, external, factory) {
+    const suitefile = this.getSuiteFilepath();
+    const fsPath = this.normalizePath(path);
+    if (!this.mockMap.has(suitefile))
+      this.mockMap.set(suitefile, {});
+    this.mockMap.get(suitefile)[fsPath] = factory || this.resolveMockPath(path, external);
+  }
+  async importActual(id, importer) {
+    const { path, external } = await this.resolvePath(id, importer);
+    const fsPath = this.getFsPath(path, external);
+    const result = await this.request(fsPath);
+    return result;
+  }
+  async importMock(id, importer) {
+    const { path, external } = await this.resolvePath(id, importer);
+    let mock = this.getDependencyMock(path);
+    if (mock === void 0)
+      mock = this.resolveMockPath(path, external);
+    if (mock === null) {
+      await this.ensureSpy();
+      const fsPath = this.getFsPath(path, external);
+      const mod = await this.request(fsPath);
+      return this.mockValue(mod);
+    }
+    if (typeof mock === "function")
+      return this.callFunctionMock(path, mock);
+    return this.requestWithMock(mock);
+  }
+  async ensureSpy() {
+    if (_VitestMocker.spyModule)
+      return;
+    _VitestMocker.spyModule = await this.request(resolve(distDir, "spy.js"));
+  }
+  async requestWithMock(dep) {
+    var _a;
+    await this.ensureSpy();
+    await this.resolveMocks();
+    const mock = this.getDependencyMock(dep);
+    if (mock === null) {
+      const cacheName = `${dep}__mock`;
+      const cache = this.moduleCache.get(cacheName);
+      if (cache == null ? void 0 : cache.exports)
+        return cache.exports;
+      const cacheKey = toFilePath(dep, this.root);
+      const mod = ((_a = this.moduleCache.get(cacheKey)) == null ? void 0 : _a.exports) || await this.request(dep);
+      const exports = this.mockValue(mod);
+      this.emit("mocked", cacheName, { exports });
+      return exports;
+    }
+    if (typeof mock === "function")
+      return this.callFunctionMock(dep, mock);
+    if (typeof mock === "string")
+      dep = mock;
+    return this.request(dep);
+  }
+  queueMock(id, importer, factory) {
+    _VitestMocker.pendingIds.push({ type: "mock", id, importer, factory });
+  }
+  queueUnmock(id, importer) {
+    _VitestMocker.pendingIds.push({ type: "unmock", id, importer });
+  }
+  withRequest(request) {
+    return new _VitestMocker(this.options, this.moduleCache, request);
+  }
+};
+let VitestMocker = _VitestMocker;
+VitestMocker.pendingIds = [];
+
+async function executeInViteNode(options) {
+  const runner = new VitestRunner(options);
+  await runner.executeId("/@vite/env");
+  const result = [];
+  for (const file of options.files)
+    result.push(await runner.executeFile(file));
+  return result;
+}
+class VitestRunner extends ViteNodeRunner {
+  constructor(options) {
+    super(options);
+    this.options = options;
+    this.entries = /* @__PURE__ */ new Set();
+    this.mocker = new VitestMocker(options, this.moduleCache);
+  }
+  prepareContext(context) {
+    const request = context.__vite_ssr_import__;
+    const mocker = this.mocker.withRequest(request);
+    mocker.on("mocked", (dep, module) => {
+      this.moduleCache.set(dep, module);
+    });
+    const workerState = getWorkerState();
+    if (workerState.filepath && normalizePath(workerState.filepath) === normalizePath(context.__filename)) {
+      Object.defineProperty(context.__vite_ssr_import_meta__, "vitest", { get: () => globalThis.__vitest_index__ });
+    }
+    return Object.assign(context, {
+      __vite_ssr_import__: (dep) => mocker.requestWithMock(dep),
+      __vite_ssr_dynamic_import__: (dep) => mocker.requestWithMock(dep),
+      __vitest_mocker__: mocker
+    });
+  }
+}
+
+export { VitestRunner as V, executeInViteNode as e };

package/dist/chunk-runtime-rpc.5263102e.js

@@ -0,0 +1,8 @@
+import './chunk-utils-base.aff0a195.js';
+import { g as getWorkerState } from './chunk-utils-global.7bcfa03c.js';
+
+const rpc = () => {
+  return getWorkerState().rpc;
+};
+
+export { rpc as r };

package/dist/chunk-utils-base.aff0a195.js

@@ -0,0 +1,408 @@
+import path from 'path';
+import require$$0 from 'tty';
+import { isPackageExists } from 'local-pkg';
+
+var picocolors = {exports: {}};
+
+let tty = require$$0;
+
+let isColorSupported =
+	!("NO_COLOR" in process.env || process.argv.includes("--no-color")) &&
+	("FORCE_COLOR" in process.env ||
+		process.argv.includes("--color") ||
+		process.platform === "win32" ||
+		(tty.isatty(1) && process.env.TERM !== "dumb") ||
+		"CI" in process.env);
+
+let formatter =
+	(open, close, replace = open) =>
+	input => {
+		let string = "" + input;
+		let index = string.indexOf(close, open.length);
+		return ~index
+			? open + replaceClose(string, close, replace, index) + close
+			: open + string + close
+	};
+
+let replaceClose = (string, close, replace, index) => {
+	let start = string.substring(0, index) + replace;
+	let end = string.substring(index + close.length);
+	let nextIndex = end.indexOf(close);
+	return ~nextIndex ? start + replaceClose(end, close, replace, nextIndex) : start + end
+};
+
+let createColors = (enabled = isColorSupported) => ({
+	isColorSupported: enabled,
+	reset: enabled ? s => `\x1b[0m${s}\x1b[0m` : String,
+	bold: enabled ? formatter("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m") : String,
+	dim: enabled ? formatter("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m") : String,
+	italic: enabled ? formatter("\x1b[3m", "\x1b[23m") : String,
+	underline: enabled ? formatter("\x1b[4m", "\x1b[24m") : String,
+	inverse: enabled ? formatter("\x1b[7m", "\x1b[27m") : String,
+	hidden: enabled ? formatter("\x1b[8m", "\x1b[28m") : String,
+	strikethrough: enabled ? formatter("\x1b[9m", "\x1b[29m") : String,
+	black: enabled ? formatter("\x1b[30m", "\x1b[39m") : String,
+	red: enabled ? formatter("\x1b[31m", "\x1b[39m") : String,
+	green: enabled ? formatter("\x1b[32m", "\x1b[39m") : String,
+	yellow: enabled ? formatter("\x1b[33m", "\x1b[39m") : String,
+	blue: enabled ? formatter("\x1b[34m", "\x1b[39m") : String,
+	magenta: enabled ? formatter("\x1b[35m", "\x1b[39m") : String,
+	cyan: enabled ? formatter("\x1b[36m", "\x1b[39m") : String,
+	white: enabled ? formatter("\x1b[37m", "\x1b[39m") : String,
+	gray: enabled ? formatter("\x1b[90m", "\x1b[39m") : String,
+	bgBlack: enabled ? formatter("\x1b[40m", "\x1b[49m") : String,
+	bgRed: enabled ? formatter("\x1b[41m", "\x1b[49m") : String,
+	bgGreen: enabled ? formatter("\x1b[42m", "\x1b[49m") : String,
+	bgYellow: enabled ? formatter("\x1b[43m", "\x1b[49m") : String,
+	bgBlue: enabled ? formatter("\x1b[44m", "\x1b[49m") : String,
+	bgMagenta: enabled ? formatter("\x1b[45m", "\x1b[49m") : String,
+	bgCyan: enabled ? formatter("\x1b[46m", "\x1b[49m") : String,
+	bgWhite: enabled ? formatter("\x1b[47m", "\x1b[49m") : String,
+});
+
+picocolors.exports = createColors();
+picocolors.exports.createColors = createColors;
+
+var c = picocolors.exports;
+
+function normalizeWindowsPath(input = "") {
+  if (!input.includes("\\")) {
+    return input;
+  }
+  return input.replace(/\\/g, "/");
+}
+
+const _UNC_REGEX = /^[/][/]/;
+const _UNC_DRIVE_REGEX = /^[/][/]([.]{1,2}[/])?([a-zA-Z]):[/]/;
+const _IS_ABSOLUTE_RE = /^\/|^\\|^[a-zA-Z]:[/\\]/;
+const sep = "/";
+const delimiter = ":";
+const normalize = function(path2) {
+  if (path2.length === 0) {
+    return ".";
+  }
+  path2 = normalizeWindowsPath(path2);
+  const isUNCPath = path2.match(_UNC_REGEX);
+  const hasUNCDrive = isUNCPath && path2.match(_UNC_DRIVE_REGEX);
+  const isPathAbsolute = isAbsolute(path2);
+  const trailingSeparator = path2[path2.length - 1] === "/";
+  path2 = normalizeString(path2, !isPathAbsolute);
+  if (path2.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path2 += "/";
+  }
+  if (isUNCPath) {
+    if (hasUNCDrive) {
+      return `//./${path2}`;
+    }
+    return `//${path2}`;
+  }
+  return isPathAbsolute && !isAbsolute(path2) ? `/${path2}` : path2;
+};
+const join = function(...args) {
+  if (args.length === 0) {
+    return ".";
+  }
+  let joined;
+  for (let i = 0; i < args.length; ++i) {
+    const arg = args[i];
+    if (arg.length > 0) {
+      if (joined === void 0) {
+        joined = arg;
+      } else {
+        joined += `/${arg}`;
+      }
+    }
+  }
+  if (joined === void 0) {
+    return ".";
+  }
+  return normalize(joined);
+};
+const resolve = function(...args) {
+  args = args.map((arg) => normalizeWindowsPath(arg));
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+    const path2 = i >= 0 ? args[i] : process.cwd();
+    if (path2.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path2}/${resolvedPath}`;
+    resolvedAbsolute = isAbsolute(path2);
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+    return `/${resolvedPath}`;
+  }
+  return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path2, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let i = 0; i <= path2.length; ++i) {
+    if (i < path2.length) {
+      char = path2[i];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === i - 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 = i;
+            dots = 0;
+            continue;
+          } else if (res.length !== 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = i;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path2.slice(lastSlash + 1, i)}`;
+        } else {
+          res = path2.slice(lastSlash + 1, i);
+        }
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+const isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+};
+const toNamespacedPath = function(p) {
+  return normalizeWindowsPath(p);
+};
+const extname = function(p) {
+  return path.posix.extname(normalizeWindowsPath(p));
+};
+const relative = function(from, to) {
+  return path.posix.relative(normalizeWindowsPath(from), normalizeWindowsPath(to));
+};
+const dirname = function(p) {
+  return path.posix.dirname(normalizeWindowsPath(p));
+};
+const format = function(p) {
+  return normalizeWindowsPath(path.posix.format(p));
+};
+const basename = function(p, ext) {
+  return path.posix.basename(normalizeWindowsPath(p), ext);
+};
+const parse = function(p) {
+  return path.posix.parse(normalizeWindowsPath(p));
+};
+
+const _path = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  sep: sep,
+  delimiter: delimiter,
+  normalize: normalize,
+  join: join,
+  resolve: resolve,
+  normalizeString: normalizeString,
+  isAbsolute: isAbsolute,
+  toNamespacedPath: toNamespacedPath,
+  extname: extname,
+  relative: relative,
+  dirname: dirname,
+  format: format,
+  basename: basename,
+  parse: parse
+});
+
+const index = {
+  ..._path
+};
+
+function notNullish(v) {
+  return v != null;
+}
+function slash(str) {
+  return str.replace(/\\/g, "/");
+}
+function mergeSlashes(str) {
+  return str.replace(/\/\//g, "/");
+}
+const noop = () => {
+};
+function toArray(array) {
+  if (array === null || array === void 0)
+    array = [];
+  if (Array.isArray(array))
+    return array;
+  return [array];
+}
+const toString = (v) => Object.prototype.toString.call(v);
+const isPlainObject = (val) => toString(val) === "[object Object]" && (!val.constructor || val.constructor.name === "Object");
+function isObject(item) {
+  return item != null && typeof item === "object" && !Array.isArray(item);
+}
+function deepMerge(target, ...sources) {
+  if (!sources.length)
+    return target;
+  const source = sources.shift();
+  if (source === void 0)
+    return target;
+  if (isMergableObject(target) && isMergableObject(source)) {
+    Object.keys(source).forEach((key) => {
+      if (isMergableObject(source[key])) {
+        if (!target[key])
+          target[key] = {};
+        deepMerge(target[key], source[key]);
+      } else {
+        target[key] = source[key];
+      }
+    });
+  }
+  return deepMerge(target, ...sources);
+}
+function isMergableObject(item) {
+  return isPlainObject(item) && !Array.isArray(item);
+}
+function assertTypes(value, name, types) {
+  const receivedType = typeof value;
+  const pass = types.includes(receivedType);
+  if (!pass)
+    throw new TypeError(`${name} value must be ${types.join(" or ")}, received "${receivedType}"`);
+}
+
+function getTests(suite) {
+  return toArray(suite).flatMap((s) => s.type === "test" ? [s] : s.tasks.flatMap((c) => c.type === "test" ? [c] : getTests(c)));
+}
+function getSuites(suite) {
+  return toArray(suite).flatMap((s) => s.type === "suite" ? [s, ...getSuites(s.tasks)] : []);
+}
+function hasTests(suite) {
+  return toArray(suite).some((s) => s.tasks.some((c) => c.type === "test" || hasTests(c)));
+}
+function hasFailed(suite) {
+  return toArray(suite).some((s) => {
+    var _a;
+    return ((_a = s.result) == null ? void 0 : _a.state) === "fail" || s.type === "suite" && hasFailed(s.tasks);
+  });
+}
+function hasFailedSnapshot(suite) {
+  return getTests(suite).some((s) => {
+    var _a, _b;
+    const message = (_b = (_a = s.result) == null ? void 0 : _a.error) == null ? void 0 : _b.message;
+    return message == null ? void 0 : message.match(/Snapshot .* mismatched/);
+  });
+}
+function getNames(task) {
+  const names = [task.name];
+  let current = task;
+  while ((current == null ? void 0 : current.suite) || (current == null ? void 0 : current.file)) {
+    current = current.suite || current.file;
+    if (current == null ? void 0 : current.name)
+      names.unshift(current.name);
+  }
+  return names;
+}
+
+const isWindows = process.platform === "win32";
+function partitionSuiteChildren(suite) {
+  let tasksGroup = [];
+  const tasksGroups = [];
+  for (const c2 of suite.tasks) {
+    if (tasksGroup.length === 0 || c2.concurrent === tasksGroup[0].concurrent) {
+      tasksGroup.push(c2);
+    } else {
+      tasksGroups.push(tasksGroup);
+      tasksGroup = [c2];
+    }
+  }
+  if (tasksGroup.length > 0)
+    tasksGroups.push(tasksGroup);
+  return tasksGroups;
+}
+function getFullName(task) {
+  return getNames(task).join(c.dim(" > "));
+}
+async function ensurePackageInstalled(dependency, promptInstall = !process.env.CI && process.stdout.isTTY) {
+  if (isPackageExists(dependency))
+    return true;
+  process.stderr.write(c.red(`${c.inverse(c.red(" MISSING DEP "))} Can not find dependency '${dependency}'
+
+`));
+  if (!promptInstall)
+    return false;
+  const prompts = await import('./vendor-index.ee829ed6.js').then(function (n) { return n.i; });
+  const { install } = await prompts.prompt({
+    type: "confirm",
+    name: "install",
+    message: c.reset(`Do you want to install ${c.green(dependency)}?`)
+  });
+  if (install) {
+    await (await import('./chunk-install-pkg.7dd40977.js')).installPackage(dependency, { dev: true });
+    process.stderr.write(c.yellow(`
+Package ${dependency} installed, re-run the command to start.
+`));
+    process.exit(1);
+    return true;
+  }
+  return false;
+}
+function getCallLastIndex(code) {
+  let charIndex = -1;
+  let inString = null;
+  let startedBracers = 0;
+  let endedBracers = 0;
+  let beforeChar = null;
+  while (charIndex <= code.length) {
+    beforeChar = code[charIndex];
+    charIndex++;
+    const char = code[charIndex];
+    const isCharString = char === '"' || char === "'" || char === "`";
+    if (isCharString && beforeChar !== "\\") {
+      if (inString === char)
+        inString = null;
+      else if (!inString)
+        inString = char;
+    }
+    if (!inString) {
+      if (char === "(")
+        startedBracers++;
+      if (char === ")")
+        endedBracers++;
+    }
+    if (startedBracers && endedBracers && startedBracers === endedBracers)
+      return charIndex;
+  }
+  return null;
+}
+
+export { mergeSlashes as A, partitionSuiteChildren as B, hasTests as C, index as a, getNames as b, c, assertTypes as d, notNullish as e, basename as f, getCallLastIndex as g, dirname as h, isObject as i, join as j, isAbsolute as k, getFullName as l, hasFailed as m, noop as n, hasFailedSnapshot as o, getSuites as p, getTests as q, relative as r, slash as s, toArray as t, resolve as u, deepMerge as v, toNamespacedPath as w, ensurePackageInstalled as x, extname as y, isWindows as z };

package/dist/chunk-utils-global.7bcfa03c.js

@@ -3,4 +3,3 @@ function getWorkerState() {
 }
 
 export { getWorkerState as g };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2h1bmstdXRpbHMtZ2xvYmFsLjdiY2ZhMDNjLmpzIiwic291cmNlcyI6WyIuLi9zcmMvdXRpbHMvZ2xvYmFsLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgV29ya2VyR2xvYmFsU3RhdGUgfSBmcm9tICcuLi90eXBlcydcblxuZXhwb3J0IGZ1bmN0aW9uIGdldFdvcmtlclN0YXRlKCk6IFdvcmtlckdsb2JhbFN0YXRlIHtcbiAgLy8gQHRzLWV4cGVjdC1lcnJvciB1bnR5cGVkIGdsb2JhbFxuICByZXR1cm4gZ2xvYmFsVGhpcy5fX3ZpdGVzdF93b3JrZXJfX1xufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFPLENBQUEsQ0FBQSxDQUFBLENBQUEsQ0FBQSxDQUFBLENBQUEsQ0FBQSxDQUFTLGNBQWMsQ0FBRyxDQUFBLENBQUEsQ0FBQTtBQUNqQyxDQUFBLENBQUUsQ0FBTyxDQUFBLENBQUEsQ0FBQSxDQUFBLENBQUEsQ0FBQSxDQUFBLENBQUEsQ0FBQSxDQUFBLENBQUEsQ0FBQSxDQUFBLENBQUEsQ0FBQSxDQUFVLENBQUMsQ0FBQSxDQUFBLENBQUEsQ0FBQSxDQUFBLENBQUEsQ0FBQSxDQUFBLENBQUEsQ0FBQSxDQUFBLENBQUEsQ0FBQSxDQUFBLENBQUEsQ0FBQSxDQUFpQixDQUFDO0FBQ3RDLENBQUE7OyJ9