vitest 0.17.0 → 0.18.1

package/LICENSE.md

@@ -1245,7 +1245,7 @@ Repository: unjs/mlly
 
 > MIT License
 > 
-> Copyright (c) 2021
+> Copyright (c) 2022 UnJS
 > 
 > Permission is hereby granted, free of charge, to any person obtaining a copy
 > of this software and associated documentation files (the "Software"), to deal

package/dist/{chunk-api-setup.5282c6cb.mjs → chunk-api-setup.9d3f7670.mjs}

@@ -1,5 +1,5 @@
 import { promises } from 'fs';
-import { c as createBirpc } from './chunk-vite-node-utils.4b58ae05.mjs';
+import { c as createBirpc } from './chunk-vite-node-utils.8077cd3c.mjs';
 import require$$0$1 from 'stream';
 import require$$0 from 'zlib';
 import require$$3 from 'net';
@@ -9,14 +9,14 @@ import require$$2 from 'events';
 import require$$1 from 'https';
 import require$$2$1 from 'http';
 import url from 'url';
-import { A as API_PATH } from './chunk-constants.511c6e9b.mjs';
-import { j as interpretSourcePos, b as parseStacktrace } from './chunk-utils-source-map.f52527bc.mjs';
+import { A as API_PATH } from './chunk-constants.d4406290.mjs';
+import { j as interpretSourcePos, b as parseStacktrace } from './chunk-utils-source-map.c03f8bc4.mjs';
 import 'module';
 import 'vm';
-import './chunk-utils-global.79a8b1cc.mjs';
+import './chunk-utils-global.0a7416cf.mjs';
+import 'path';
 import 'tty';
 import 'local-pkg';
-import 'path';
 import 'assert';
 import 'util';
 import 'debug';
@@ -3217,11 +3217,11 @@ function initAsClient(websocket, address, protocols, options) {
     ? parsedUrl.hostname.slice(1, -1)
     : parsedUrl.hostname;
   opts.headers = {
+    ...opts.headers,
     'Sec-WebSocket-Version': opts.protocolVersion,
     'Sec-WebSocket-Key': key,
     Connection: 'Upgrade',
-    Upgrade: 'websocket',
-    ...opts.headers
+    Upgrade: 'websocket'
   };
   opts.path = parsedUrl.pathname + parsedUrl.search;
   opts.timeout = opts.handshakeTimeout;
@@ -3275,8 +3275,11 @@ function initAsClient(websocket, address, protocols, options) {
 
   if (opts.followRedirects) {
     if (websocket._redirects === 0) {
+      websocket._originalUnixSocket = isUnixSocket;
       websocket._originalSecure = isSecure;
-      websocket._originalHost = parsedUrl.host;
+      websocket._originalHostOrSocketPath = isUnixSocket
+        ? opts.socketPath
+        : parsedUrl.host;
 
       const headers = options && options.headers;
 
@@ -3292,7 +3295,13 @@ function initAsClient(websocket, address, protocols, options) {
         }
       }
     } else if (websocket.listenerCount('redirect') === 0) {
-      const isSameHost = parsedUrl.host === websocket._originalHost;
+      const isSameHost = isUnixSocket
+        ? websocket._originalUnixSocket
+          ? opts.socketPath === websocket._originalHostOrSocketPath
+          : false
+        : websocket._originalUnixSocket
+        ? false
+        : parsedUrl.host === websocket._originalHostOrSocketPath;
 
       if (!isSameHost || (websocket._originalSecure && !isSecure)) {
         //

package/dist/{chunk-constants.511c6e9b.mjs → chunk-constants.d4406290.mjs}

@@ -1,5 +1,5 @@
 import { fileURLToPath } from 'url';
-import { m as resolve } from './chunk-utils-global.79a8b1cc.mjs';
+import { q as resolve } from './chunk-utils-global.0a7416cf.mjs';
 
 const distDir = resolve(fileURLToPath(import.meta.url), "../../dist");
 const defaultPort = 51204;

package/dist/{chunk-env-node.dc514f41.mjs → chunk-env-node.bbba78e5.mjs}

@@ -2,7 +2,7 @@ import { importModule } from 'local-pkg';
 import { existsSync, promises } from 'fs';
 import { createRequire } from 'module';
 import { pathToFileURL } from 'url';
-import { C as toArray, m as resolve } from './chunk-utils-global.79a8b1cc.mjs';
+import { F as toArray, q as resolve } from './chunk-utils-global.0a7416cf.mjs';
 
 var node = {
   name: "node",
@@ -237,7 +237,8 @@ const KEYS = LIVING_KEYS.concat(OTHER_KEYS);
 
 const allowRewrite = [
   "Event",
-  "EventTarget"
+  "EventTarget",
+  "MessageEvent"
 ];
 const skipKeys = [
   "window",
@@ -532,6 +533,7 @@ const defaultCoverageExcludes = [
   "test{,s}/**",
   "test{,-*}.{js,cjs,mjs,ts,tsx,jsx}",
   "**/*{.,-}test.{js,cjs,mjs,ts,tsx,jsx}",
+  "**/*{.,-}spec.{js,cjs,mjs,ts,tsx,jsx}",
   "**/__tests__/**",
   "**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc}.config.{js,cjs,mjs,ts}",
   "**/.{eslint,mocha,prettier}rc.{js,cjs,yml}"
@@ -575,7 +577,11 @@ const config = {
   hookTimeout: 1e4,
   isolate: true,
   watchExclude: ["**/node_modules/**", "**/dist/**"],
-  forceRerunTriggers: [],
+  forceRerunTriggers: [
+    "**/package.json/**",
+    "**/vitest.config.*/**",
+    "**/vite.config.*/**"
+  ],
   update: false,
   reporters: [],
   silent: false,

package/dist/{chunk-install-pkg.3fa50769.mjs → chunk-install-pkg.2dcb2c04.mjs}

@@ -2,7 +2,7 @@ import path$2 from 'path';
 import fs$2 from 'fs';
 import require$$0 from 'util';
 import childProcess$1 from 'child_process';
-import { p as pathKey, s as signalExit, m as mergeStream$1, g as getStream$1, c as crossSpawn$1, o as onetime$1 } from './vendor-index.e5dc6622.mjs';
+import { p as pathKey, s as signalExit, m as mergeStream$1, g as getStream$1, c as crossSpawn$1, o as onetime$1 } from './vendor-index.4bf9c627.mjs';
 import require$$0$1 from 'os';
 import './vendor-_commonjsHelpers.4da45ef5.mjs';
 import 'assert';

package/dist/chunk-integrations-globals.00b6e1ad.mjs

@@ -0,0 +1,23 @@
+import { g as globalApis } from './chunk-constants.d4406290.mjs';
+import { i as index } from './chunk-runtime-chain.b60d57da.mjs';
+import 'url';
+import './chunk-utils-global.0a7416cf.mjs';
+import 'path';
+import 'tty';
+import 'local-pkg';
+import 'util';
+import 'chai';
+import './vendor-_commonjsHelpers.4da45ef5.mjs';
+import './chunk-runtime-rpc.9d1f4c48.mjs';
+import 'fs';
+import './chunk-utils-source-map.c03f8bc4.mjs';
+import './spy.mjs';
+import 'tinyspy';
+
+function registerApiGlobally() {
+  globalApis.forEach((api) => {
+    globalThis[api] = index[api];
+  });
+}
+
+export { registerApiGlobally };

package/dist/{chunk-runtime-chain.68f305d0.mjs → chunk-runtime-chain.b60d57da.mjs}

@@ -1,11 +1,11 @@
-import chai$1, { expect, AssertionError, util } from 'chai';
+import require$$0, { format } from 'util';
+import { i as isObject, j as join, d as dirname, g as getCallLastIndex, s as slash, a as getWorkerState, b as getNames, c as assertTypes, p as picocolors, e as getFullName, f as safeSetTimeout, h as safeClearTimeout, n as noop, R as RealDate, r as resetDate, m as mockDate, k as resetModules } from './chunk-utils-global.0a7416cf.mjs';
+import chai$1, { expect, AssertionError, util, assert, should } from 'chai';
 import { c as commonjsGlobal } from './vendor-_commonjsHelpers.4da45ef5.mjs';
-import { r as rpc } from './chunk-runtime-rpc.5e78af38.mjs';
-import { i as isObject, j as join, d as dirname, g as getCallLastIndex, s as slash, a as getWorkerState, b as getNames, c as assertTypes, p as picocolors, e as getFullName, f as safeSetTimeout, h as safeClearTimeout, n as noop, r as resetModules } from './chunk-utils-global.79a8b1cc.mjs';
+import { r as rpc } from './chunk-runtime-rpc.9d1f4c48.mjs';
 import fs, { promises } from 'fs';
-import { p as plugins_1, f as format_1, g as getOriginalPos, a as posToNumber, n as numberToPos, l as lineSplitRE, b as parseStacktrace, u as unifiedDiff, s as stringify, m as matcherUtils } from './chunk-utils-source-map.f52527bc.mjs';
-import { i as isMockFunction, s as spyOn, f as fn, a as spies } from './chunk-integrations-spy.674b628e.mjs';
-import require$$0, { format } from 'util';
+import { p as plugins_1, f as format_1, g as getOriginalPos, a as posToNumber, n as numberToPos, l as lineSplitRE, b as parseStacktrace, u as unifiedDiff, s as stringify, m as matcherUtils } from './chunk-utils-source-map.c03f8bc4.mjs';
+import { isMockFunction, spyOn, fn, spies } from './spy.mjs';
 
 function createChainable(keys, fn) {
   function create(obj) {
@@ -1884,7 +1884,8 @@ function formatTitle(template, items, idx) {
 }
 const describe = suite;
 const it = test;
-const defaultSuite = suite("");
+const workerState = getWorkerState();
+const defaultSuite = workerState.config.sequence.shuffle ? suite.shuffle("") : suite("");
 function clearCollectorContext() {
   collectorContext.tasks.length = 0;
   defaultSuite.clear();
@@ -1902,7 +1903,7 @@ function createSuiteHooks() {
   };
 }
 function createSuiteCollector(name, factory = () => {
-}, mode, concurrent) {
+}, mode, concurrent, shuffle) {
   const tasks = [];
   const factoryQueue = [];
   let suite2;
@@ -1919,6 +1920,8 @@ function createSuiteCollector(name, factory = () => {
     };
     if (this.concurrent || concurrent)
       test3.concurrent = true;
+    if (shuffle)
+      test3.shuffle = true;
     const context = createTestContext(test3);
     Object.defineProperty(test3, "context", {
       value: context,
@@ -1946,6 +1949,7 @@ function createSuiteCollector(name, factory = () => {
       type: "suite",
       name,
       mode,
+      shuffle,
       tasks: []
     };
     setHooks(suite2, createSuiteHooks());
@@ -1975,9 +1979,9 @@ function createSuiteCollector(name, factory = () => {
   return collector;
 }
 function createSuite() {
-  const suite2 = createChainable(["concurrent", "skip", "only", "todo"], function(name, factory) {
+  const suite2 = createChainable(["concurrent", "shuffle", "skip", "only", "todo"], function(name, factory) {
     const mode = this.only ? "only" : this.skip ? "skip" : this.todo ? "todo" : "run";
-    return createSuiteCollector(name, factory, mode, this.concurrent);
+    return createSuiteCollector(name, factory, mode, this.concurrent, this.shuffle);
   });
   suite2.each = (cases) => {
     return (name, fn) => {
@@ -4548,55 +4552,6 @@ defaultImplementation.createClock;
 defaultImplementation.install;
 var withGlobal_1 = withGlobal;
 
-const RealDate = Date;
-let now = null;
-class MockDate extends RealDate {
-  constructor(y, m, d, h, M, s, ms) {
-    super();
-    let date;
-    switch (arguments.length) {
-      case 0:
-        if (now !== null)
-          date = new RealDate(now.valueOf());
-        else
-          date = new RealDate();
-        break;
-      case 1:
-        date = new RealDate(y);
-        break;
-      default:
-        d = typeof d === "undefined" ? 1 : d;
-        h = h || 0;
-        M = M || 0;
-        s = s || 0;
-        ms = ms || 0;
-        date = new RealDate(y, m, d, h, M, s, ms);
-        break;
-    }
-    return date;
-  }
-}
-MockDate.UTC = RealDate.UTC;
-MockDate.now = function() {
-  return new MockDate().valueOf();
-};
-MockDate.parse = function(dateString) {
-  return RealDate.parse(dateString);
-};
-MockDate.toString = function() {
-  return RealDate.toString();
-};
-function mockDate(date) {
-  const dateObj = new RealDate(date.valueOf());
-  if (isNaN(dateObj.getTime()))
-    throw new TypeError(`mockdate: The time set is an invalid date: ${date}`);
-  globalThis.Date = MockDate;
-  now = dateObj.valueOf();
-}
-function resetDate() {
-  globalThis.Date = RealDate;
-}
-
 class FakeTimers {
   constructor({
     global,
@@ -4844,4 +4799,28 @@ function isWatchMode() {
   return getRunningMode() === "watch";
 }
 
-export { getState as A, GLOBAL_EXPECT as G, RealDate as R, isFirstRun as a, beforeAll as b, afterAll as c, describe as d, beforeEach as e, afterEach as f, createExpect as g, globalExpect as h, it as i, vi as j, getRunningMode as k, isWatchMode as l, resetRunOnceCounter as m, clearCollectorContext as n, defaultSuite as o, setHooks as p, getHooks as q, runOnce as r, suite as s, test as t, collectorContext as u, vitest as v, withCallback as w, getSnapshotClient as x, setState as y, getFn as z };
+var index = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  suite: suite,
+  test: test,
+  describe: describe,
+  it: it,
+  runOnce: runOnce,
+  isFirstRun: isFirstRun,
+  beforeAll: beforeAll,
+  afterAll: afterAll,
+  beforeEach: beforeEach,
+  afterEach: afterEach,
+  withCallback: withCallback,
+  assert: assert,
+  should: should,
+  createExpect: createExpect,
+  chai: chai$1,
+  expect: globalExpect,
+  vitest: vitest,
+  vi: vi,
+  getRunningMode: getRunningMode,
+  isWatchMode: isWatchMode
+});
+
+export { getRunningMode as A, isWatchMode as B, GLOBAL_EXPECT as G, collectorContext as a, getSnapshotClient as b, clearCollectorContext as c, defaultSuite as d, setState as e, getFn as f, getHooks as g, getState as h, index as i, suite as j, describe as k, it as l, runOnce as m, isFirstRun as n, beforeAll as o, afterAll as p, beforeEach as q, resetRunOnceCounter as r, setHooks as s, test as t, afterEach as u, vi as v, withCallback as w, createExpect as x, globalExpect as y, vitest as z };

package/dist/{chunk-runtime-mocker.1c207219.mjs → chunk-runtime-mocker.1d853e3a.mjs}

@@ -1,9 +1,30 @@
-import { n as normalizeRequestId, i as isNodeBuiltin, b as toFilePath, V as ViteNodeRunner } from './chunk-vite-node-utils.4b58ae05.mjs';
+import { n as normalizeRequestId, i as isNodeBuiltin, b as toFilePath, V as ViteNodeRunner } from './chunk-vite-node-utils.8077cd3c.mjs';
 import { normalizePath } from 'vite';
-import { a as getWorkerState, J as isWindows, K as mergeSlashes, d as dirname, m as resolve, l as basename, L as getType, M as getAllProperties, s as slash } from './chunk-utils-global.79a8b1cc.mjs';
+import { a as getWorkerState, M as isWindows, N as mergeSlashes, d as dirname, j as join, o as basename, q as resolve, s as slash, O as getType, P as getAllProperties } from './chunk-utils-global.0a7416cf.mjs';
 import { existsSync, readdirSync } from 'fs';
-import { d as distDir } from './chunk-constants.511c6e9b.mjs';
+import { d as distDir } from './chunk-constants.d4406290.mjs';
 
+class RefTracker {
+  constructor() {
+    this.idMap = /* @__PURE__ */ new Map();
+    this.mockedValueMap = /* @__PURE__ */ new Map();
+  }
+  getId(value) {
+    return this.idMap.get(value);
+  }
+  getMockedValue(id) {
+    return this.mockedValueMap.get(id);
+  }
+  track(originalValue, mockedValue) {
+    const newId = this.idMap.size;
+    this.idMap.set(originalValue, newId);
+    this.mockedValueMap.set(newId, mockedValue);
+    return newId;
+  }
+}
+function isSpecialProp(prop, parentType) {
+  return parentType.includes("Function") && typeof prop === "string" && ["arguments", "callee", "caller", "length", "name"].includes(prop);
+}
 const _VitestMocker = class {
   constructor(options, moduleCache, request) {
     this.options = options;
@@ -74,7 +95,7 @@ const _VitestMocker = class {
     const path = normalizeRequestId(external || mockPath);
     if (external || isNodeBuiltin(mockPath) || !existsSync(mockPath)) {
       const mockDirname = dirname(path);
-      const mockFolder = resolve(this.root, "__mocks__", mockDirname);
+      const mockFolder = join(this.root, "__mocks__", mockDirname);
       if (!existsSync(mockFolder))
         return null;
       const files = readdirSync(mockFolder);
@@ -82,36 +103,63 @@ const _VitestMocker = class {
       for (const file of files) {
         const [basename2] = file.split(".");
         if (basename2 === baseFilename)
-          return resolve(mockFolder, file).replace(this.root, "");
+          return resolve(mockFolder, file);
       }
       return null;
     }
     const dir = dirname(path);
     const baseId = basename(path);
     const fullPath = resolve(dir, "__mocks__", baseId);
-    return existsSync(fullPath) ? fullPath.replace(this.root, "") : null;
+    return existsSync(fullPath) ? fullPath : null;
   }
-  mockValue(value) {
+  mockObject(object) {
     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 properties = getAllProperties(value);
-    for (const k of properties) {
-      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 });
+    const spyModule = _VitestMocker.spyModule;
+    const finalizers = new Array();
+    const refs = new RefTracker();
+    const mockPropertiesOf = (container, newContainer) => {
+      const containerType = getType(container);
+      const isModule = containerType === "Module" || !!container.__esModule;
+      for (const property of getAllProperties(container)) {
+        if (!isModule) {
+          const descriptor = Object.getOwnPropertyDescriptor(container, property);
+          if ((descriptor == null ? void 0 : descriptor.get) || (descriptor == null ? void 0 : descriptor.set))
+            continue;
+        }
+        if (isSpecialProp(property, containerType))
+          continue;
+        const value = container[property];
+        const refId = refs.getId(value);
+        if (refId) {
+          finalizers.push(() => newContainer[property] = refs.getMockedValue(refId));
+          continue;
+        }
+        const type = getType(value);
+        if (Array.isArray(value)) {
+          newContainer[property] = [];
+          continue;
+        }
+        const isFunction = type.includes("Function") && typeof value === "function";
+        if ((!isFunction || value.__isMockFunction) && type !== "Object" && type !== "Module") {
+          newContainer[property] = value;
+          continue;
+        }
+        newContainer[property] = isFunction ? value : {};
+        if (isFunction) {
+          spyModule.spyOn(newContainer, property).mockImplementation(() => void 0);
+          Object.defineProperty(newContainer[property], "length", { value: 0 });
+        }
+        refs.track(value, newContainer[property]);
+        mockPropertiesOf(value, newContainer[property]);
       }
-    }
-    Object.setPrototypeOf(newObj, Object.getPrototypeOf(value));
-    return newObj;
+    };
+    const mockedObject = {};
+    mockPropertiesOf(object, mockedObject);
+    for (const finalizer of finalizers)
+      finalizer();
+    return mockedObject;
   }
   unmockPath(path) {
     const suitefile = this.getSuiteFilepath();
@@ -135,17 +183,17 @@ const _VitestMocker = class {
   }
   async importMock(id, importer) {
     const { path, external } = await this.resolvePath(id, importer);
-    let mock = this.getDependencyMock(path);
+    const fsPath = this.getFsPath(path, external);
+    let mock = this.getDependencyMock(fsPath);
     if (mock === void 0)
-      mock = this.resolveMockPath(path, external);
+      mock = this.resolveMockPath(fsPath, external);
     if (mock === null) {
       await this.ensureSpy();
-      const fsPath = this.getFsPath(path, external);
       const mod = await this.request(fsPath);
-      return this.mockValue(mod);
+      return this.mockObject(mod);
     }
     if (typeof mock === "function")
-      return this.callFunctionMock(path, mock);
+      return this.callFunctionMock(fsPath, mock);
     return this.requestWithMock(mock);
   }
   async ensureSpy() {
@@ -168,7 +216,7 @@ const _VitestMocker = class {
         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);
+      const exports = this.mockObject(mod);
       this.moduleCache.set(cacheName, { exports });
       return exports;
     }

package/dist/{chunk-runtime-rpc.5e78af38.mjs → chunk-runtime-rpc.9d1f4c48.mjs}

@@ -1,4 +1,4 @@
-import { a as getWorkerState, w as withSafeTimers } from './chunk-utils-global.79a8b1cc.mjs';
+import { a as getWorkerState, w as withSafeTimers } from './chunk-utils-global.0a7416cf.mjs';
 
 const rpc = () => {
   const { rpc: rpc2 } = getWorkerState();

package/dist/{chunk-utils-global.79a8b1cc.mjs → chunk-utils-global.0a7416cf.mjs}

@@ -1,6 +1,6 @@
+import path from 'path';
 import require$$0 from 'tty';
 import { isPackageExists } from 'local-pkg';
-import path from 'path';
 
 var picocolors = {exports: {}};
 
@@ -250,14 +250,63 @@ function getWorkerState() {
   return globalThis.__vitest_worker__;
 }
 
+const RealDate = Date;
+let now = null;
+class MockDate extends RealDate {
+  constructor(y, m, d, h, M, s, ms) {
+    super();
+    let date;
+    switch (arguments.length) {
+      case 0:
+        if (now !== null)
+          date = new RealDate(now.valueOf());
+        else
+          date = new RealDate();
+        break;
+      case 1:
+        date = new RealDate(y);
+        break;
+      default:
+        d = typeof d === "undefined" ? 1 : d;
+        h = h || 0;
+        M = M || 0;
+        s = s || 0;
+        ms = ms || 0;
+        date = new RealDate(y, m, d, h, M, s, ms);
+        break;
+    }
+    return date;
+  }
+}
+MockDate.UTC = RealDate.UTC;
+MockDate.now = function() {
+  return new MockDate().valueOf();
+};
+MockDate.parse = function(dateString) {
+  return RealDate.parse(dateString);
+};
+MockDate.toString = function() {
+  return RealDate.toString();
+};
+function mockDate(date) {
+  const dateObj = new RealDate(date.valueOf());
+  if (isNaN(dateObj.getTime()))
+    throw new TypeError(`mockdate: The time set is an invalid date: ${date}`);
+  globalThis.Date = MockDate;
+  now = dateObj.valueOf();
+}
+function resetDate() {
+  globalThis.Date = RealDate;
+}
+
 function isFinalObj(obj) {
   return obj === Object.prototype || obj === Function.prototype || obj === RegExp.prototype;
 }
 function collectOwnProperties(obj, collector) {
   const props = Object.getOwnPropertyNames(obj);
-  const symbs = Object.getOwnPropertySymbols(obj);
+  const symbols = Object.getOwnPropertySymbols(obj);
   props.forEach((prop) => collector.add(prop));
-  symbs.forEach((symb) => collector.add(symb));
+  symbols.forEach((symbol) => collector.add(symbol));
 }
 function getAllProperties(obj) {
   const allProps = /* @__PURE__ */ new Set();
@@ -358,6 +407,21 @@ function assertTypes(value, name, types) {
 function stdout() {
   return console._stdout || process.stdout;
 }
+function random(seed) {
+  const x = Math.sin(seed++) * 1e4;
+  return x - Math.floor(x);
+}
+function shuffle(array, seed = RealDate.now()) {
+  let length = array.length;
+  while (length) {
+    const index = Math.floor(random(seed) * length--);
+    const previous = array[length];
+    array[length] = array[index];
+    array[index] = previous;
+    ++seed;
+  }
+  return array;
+}
 
 function getTests(suite) {
   return toArray(suite).flatMap((s) => s.type === "test" ? [s] : s.tasks.flatMap((c) => c.type === "test" ? [c] : getTests(c)));
@@ -459,14 +523,14 @@ async function ensurePackageInstalled(dependency, promptInstall = !process.env.C
 `));
   if (!promptInstall)
     return false;
-  const prompts = await import('./vendor-index.98e769c1.mjs').then(function (n) { return n.i; });
+  const prompts = await import('./vendor-index.de788b6a.mjs').then(function (n) { return n.i; });
   const { install } = await prompts.prompt({
     type: "confirm",
     name: "install",
     message: picocolors.exports.reset(`Do you want to install ${picocolors.exports.green(dependency)}?`)
   });
   if (install) {
-    await (await import('./chunk-install-pkg.3fa50769.mjs')).installPackage(dependency, { dev: true });
+    await (await import('./chunk-install-pkg.2dcb2c04.mjs')).installPackage(dependency, { dev: true });
     process.stderr.write(picocolors.exports.yellow(`
 Package ${dependency} installed, re-run the command to start.
 `));
@@ -510,4 +574,4 @@ class AggregateErrorPonyfill extends Error {
   }
 }
 
-export { AggregateErrorPonyfill as A, safeClearInterval as B, toArray as C, normalize as D, deepMerge as E, toNamespacedPath as F, ensurePackageInstalled as G, stdout as H, extname as I, isWindows as J, mergeSlashes as K, getType as L, getAllProperties as M, deepClone as N, partitionSuiteChildren as O, hasTests as P, getWorkerState as a, getNames as b, assertTypes as c, dirname as d, getFullName as e, safeSetTimeout as f, getCallLastIndex as g, safeClearTimeout as h, isObject as i, join as j, notNullish as k, basename as l, resolve as m, noop as n, isAbsolute as o, picocolors as p, relative as q, resetModules as r, slash as s, isNode as t, getTests as u, hasFailed as v, withSafeTimers as w, hasFailedSnapshot as x, getSuites as y, safeSetInterval as z };
+export { AggregateErrorPonyfill as A, safeSetInterval as B, safeClearInterval as C, getSuites as D, shuffle as E, toArray as F, normalize as G, deepMerge as H, toNamespacedPath as I, ensurePackageInstalled as J, stdout as K, extname as L, isWindows as M, mergeSlashes as N, getType as O, getAllProperties as P, deepClone as Q, RealDate as R, partitionSuiteChildren as S, hasTests as T, getWorkerState as a, getNames as b, assertTypes as c, dirname as d, getFullName as e, safeSetTimeout as f, getCallLastIndex as g, safeClearTimeout as h, isObject as i, join as j, resetModules as k, notNullish as l, mockDate as m, noop as n, basename as o, picocolors as p, resolve as q, resetDate as r, slash as s, isAbsolute as t, relative as u, isNode as v, withSafeTimers as w, getTests as x, hasFailed as y, hasFailedSnapshot as z };

package/dist/{chunk-utils-source-map.f52527bc.mjs → chunk-utils-source-map.c03f8bc4.mjs}

@@ -1,4 +1,4 @@
-import { s as slash, k as notNullish, p as picocolors } from './chunk-utils-global.79a8b1cc.mjs';
+import { s as slash, l as notNullish, p as picocolors } from './chunk-utils-global.0a7416cf.mjs';
 
 var build = {};
 
@@ -7435,4 +7435,4 @@ var matcherUtils = /*#__PURE__*/Object.freeze({
 	diff: diff
 });
 
-export { posToNumber as a, parseStacktrace as b, stripAnsi as c, stringWidth as d, ansiStyles as e, format_1 as f, getOriginalPos as g, sliceAnsi as h, cliTruncate as i, interpretSourcePos as j, lineSplitRE as l, matcherUtils as m, numberToPos as n, plugins_1 as p, stringify as s, unifiedDiff as u };
+export { posToNumber as a, parseStacktrace as b, stripAnsi as c, cliTruncate as d, stringWidth as e, format_1 as f, getOriginalPos as g, ansiStyles as h, sliceAnsi as i, interpretSourcePos as j, lineSplitRE as l, matcherUtils as m, numberToPos as n, plugins_1 as p, stringify as s, unifiedDiff as u };