vitest 0.12.4 → 0.12.7

package/dist/node.d.ts

@@ -393,6 +393,9 @@ declare type BuiltinReporters = keyof typeof ReportersMap;
 declare type Awaitable<T> = T | PromiseLike<T>;
 declare type Arrayable<T> = T | Array<T>;
 declare type ArgumentsType<T> = T extends (...args: infer U) => any ? U : never;
+interface Constructable {
+    new (...args: any[]): any;
+}
 interface UserConsoleLog {
     content: string;
     type: 'stdout' | 'stderr';
@@ -994,6 +997,218 @@ interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters'
     api?: ApiConfig;
 }
 
+declare type VitestInlineConfig = InlineConfig;
+declare module 'vite' {
+    interface UserConfig {
+        /**
+         * Options for Vitest
+         */
+        test?: VitestInlineConfig;
+    }
+}
+
+declare type Formatter = (input: string | number | null | undefined) => string;
+
+interface MatcherHintOptions {
+    comment?: string;
+    expectedColor?: Formatter;
+    isDirectExpectCall?: boolean;
+    isNot?: boolean;
+    promise?: string;
+    receivedColor?: Formatter;
+    secondArgument?: string;
+    secondArgumentColor?: Formatter;
+}
+interface DiffOptions {
+    aAnnotation?: string;
+    aColor?: Formatter;
+    aIndicator?: string;
+    bAnnotation?: string;
+    bColor?: Formatter;
+    bIndicator?: string;
+    changeColor?: Formatter;
+    changeLineTrailingSpaceColor?: Formatter;
+    commonColor?: Formatter;
+    commonIndicator?: string;
+    commonLineTrailingSpaceColor?: Formatter;
+    contextLines?: number;
+    emptyFirstOrLastLinePlaceholder?: string;
+    expand?: boolean;
+    includeChangeCounts?: boolean;
+    omitAnnotationLines?: boolean;
+    patchColor?: Formatter;
+    compareKeys?: any;
+}
+
+declare const EXPECTED_COLOR: Formatter;
+declare const RECEIVED_COLOR: Formatter;
+declare const INVERTED_COLOR: Formatter;
+declare const BOLD_WEIGHT: Formatter;
+declare const DIM_COLOR: Formatter;
+declare function matcherHint(matcherName: string, received?: string, expected?: string, options?: MatcherHintOptions): string;
+declare function stringify(object: unknown, maxDepth?: number, options?: PrettyFormatOptions): string;
+declare const printReceived: (object: unknown) => string;
+declare const printExpected: (value: unknown) => string;
+declare function diff(a: any, b: any, options?: DiffOptions): string;
+
+declare const jestMatcherUtils_EXPECTED_COLOR: typeof EXPECTED_COLOR;
+declare const jestMatcherUtils_RECEIVED_COLOR: typeof RECEIVED_COLOR;
+declare const jestMatcherUtils_INVERTED_COLOR: typeof INVERTED_COLOR;
+declare const jestMatcherUtils_BOLD_WEIGHT: typeof BOLD_WEIGHT;
+declare const jestMatcherUtils_DIM_COLOR: typeof DIM_COLOR;
+declare const jestMatcherUtils_matcherHint: typeof matcherHint;
+declare const jestMatcherUtils_stringify: typeof stringify;
+declare const jestMatcherUtils_printReceived: typeof printReceived;
+declare const jestMatcherUtils_printExpected: typeof printExpected;
+declare const jestMatcherUtils_diff: typeof diff;
+declare namespace jestMatcherUtils {
+  export {
+    jestMatcherUtils_EXPECTED_COLOR as EXPECTED_COLOR,
+    jestMatcherUtils_RECEIVED_COLOR as RECEIVED_COLOR,
+    jestMatcherUtils_INVERTED_COLOR as INVERTED_COLOR,
+    jestMatcherUtils_BOLD_WEIGHT as BOLD_WEIGHT,
+    jestMatcherUtils_DIM_COLOR as DIM_COLOR,
+    jestMatcherUtils_matcherHint as matcherHint,
+    jestMatcherUtils_stringify as stringify,
+    jestMatcherUtils_printReceived as printReceived,
+    jestMatcherUtils_printExpected as printExpected,
+    jestMatcherUtils_diff as diff,
+  };
+}
+
+declare type Tester = (a: any, b: any) => boolean | undefined;
+interface MatcherState {
+    assertionCalls: number;
+    currentTestName?: string;
+    dontThrow?: () => void;
+    error?: Error;
+    equals: (a: unknown, b: unknown, customTesters?: Array<Tester>, strictCheck?: boolean) => boolean;
+    expand?: boolean;
+    expectedAssertionsNumber?: number | null;
+    expectedAssertionsNumberErrorGen?: (() => Error) | null;
+    isExpectingAssertions?: boolean;
+    isExpectingAssertionsError?: Error | null;
+    isNot: boolean;
+    promise: string;
+    suppressedErrors: Array<Error>;
+    testPath?: string;
+    utils: typeof jestMatcherUtils & {
+        iterableEquality: Tester;
+        subsetEquality: Tester;
+    };
+}
+interface SyncExpectationResult {
+    pass: boolean;
+    message: () => string;
+    actual?: any;
+    expected?: any;
+}
+declare type AsyncExpectationResult = Promise<SyncExpectationResult>;
+declare type ExpectationResult = SyncExpectationResult | AsyncExpectationResult;
+interface RawMatcherFn<T extends MatcherState = MatcherState> {
+    (this: T, received: any, expected: any, options?: any): ExpectationResult;
+}
+declare type MatchersObject<T extends MatcherState = MatcherState> = Record<string, RawMatcherFn<T>>;
+
+declare type Promisify<O> = {
+    [K in keyof O]: O[K] extends (...args: infer A) => infer R ? O extends R ? Promisify<O[K]> : (...args: A) => Promise<R> : O[K];
+};
+declare global {
+    namespace jest {
+        interface Matchers<R, T = {}> {
+        }
+    }
+    namespace Vi {
+        interface ExpectStatic extends Chai.ExpectStatic, AsymmetricMatchersContaining {
+            <T>(actual: T, message?: string): Vi.Assertion<T>;
+            extend(expects: MatchersObject): void;
+            assertions(expected: number): void;
+            hasAssertions(): void;
+            anything(): any;
+            any(constructor: unknown): any;
+            addSnapshotSerializer(plugin: Plugin): void;
+            getState(): MatcherState;
+            setState(state: Partial<MatcherState>): void;
+            not: AsymmetricMatchersContaining;
+        }
+        interface AsymmetricMatchersContaining {
+            stringContaining(expected: string): any;
+            objectContaining(expected: any): any;
+            arrayContaining<T = unknown>(expected: Array<T>): any;
+            stringMatching(expected: string | RegExp): any;
+        }
+        interface JestAssertion<T = any> extends jest.Matchers<void, T> {
+            toMatchSnapshot<U extends {
+                [P in keyof T]: any;
+            }>(snapshot: Partial<U>, message?: string): void;
+            toMatchSnapshot(message?: string): void;
+            matchSnapshot<U extends {
+                [P in keyof T]: any;
+            }>(snapshot: Partial<U>, message?: string): void;
+            matchSnapshot(message?: string): void;
+            toMatchInlineSnapshot<U extends {
+                [P in keyof T]: any;
+            }>(properties: Partial<U>, snapshot?: string, message?: string): void;
+            toMatchInlineSnapshot(snapshot?: string, message?: string): void;
+            toThrowErrorMatchingSnapshot(message?: string): void;
+            toThrowErrorMatchingInlineSnapshot(snapshot?: string, message?: string): void;
+            toEqual<E>(expected: E): void;
+            toStrictEqual<E>(expected: E): void;
+            toBe<E>(expected: E): void;
+            toMatch(expected: string | RegExp): void;
+            toMatchObject<E extends {} | any[]>(expected: E): void;
+            toContain<E>(item: E): void;
+            toContainEqual<E>(item: E): void;
+            toBeTruthy(): void;
+            toBeFalsy(): void;
+            toBeGreaterThan(num: number | bigint): void;
+            toBeGreaterThanOrEqual(num: number | bigint): void;
+            toBeLessThan(num: number | bigint): void;
+            toBeLessThanOrEqual(num: number | bigint): void;
+            toBeNaN(): void;
+            toBeUndefined(): void;
+            toBeNull(): void;
+            toBeDefined(): void;
+            toBeTypeOf(expected: 'bigint' | 'boolean' | 'function' | 'number' | 'object' | 'string' | 'symbol' | 'undefined'): void;
+            toBeInstanceOf<E>(expected: E): void;
+            toBeCalledTimes(times: number): void;
+            toHaveLength(length: number): void;
+            toHaveProperty<E>(property: string | string[], value?: E): void;
+            toBeCloseTo(number: number, numDigits?: number): void;
+            toHaveBeenCalledTimes(times: number): void;
+            toHaveBeenCalledOnce(): void;
+            toHaveBeenCalled(): void;
+            toBeCalled(): void;
+            toHaveBeenCalledWith<E extends any[]>(...args: E): void;
+            toBeCalledWith<E extends any[]>(...args: E): void;
+            toHaveBeenNthCalledWith<E extends any[]>(n: number, ...args: E): void;
+            nthCalledWith<E extends any[]>(nthCall: number, ...args: E): void;
+            toHaveBeenLastCalledWith<E extends any[]>(...args: E): void;
+            lastCalledWith<E extends any[]>(...args: E): void;
+            toThrow(expected?: string | Constructable | RegExp | Error): void;
+            toThrowError(expected?: string | Constructable | RegExp | Error): void;
+            toReturn(): void;
+            toHaveReturned(): void;
+            toReturnTimes(times: number): void;
+            toHaveReturnedTimes(times: number): void;
+            toReturnWith<E>(value: E): void;
+            toHaveReturnedWith<E>(value: E): void;
+            toHaveLastReturnedWith<E>(value: E): void;
+            lastReturnedWith<E>(value: E): void;
+            toHaveNthReturnedWith<E>(nthCall: number, value: E): void;
+            nthReturnedWith<E>(nthCall: number, value: E): void;
+            toSatisfy<E>(matcher: (value: E) => boolean, message?: string): void;
+        }
+        type VitestAssertion<A, T> = {
+            [K in keyof A]: A[K] extends Chai.Assertion ? Assertion<T> : A[K] extends (...args: any[]) => any ? A[K] : VitestAssertion<A[K], T>;
+        } & ((type: string, message?: string) => Assertion);
+        interface Assertion<T = any> extends VitestAssertion<Chai.Assertion, T>, JestAssertion<T> {
+            resolves: Promisify<Assertion<T>>;
+            rejects: Promisify<Assertion<T>>;
+        }
+    }
+}
+
 declare type MockMap = Map<string, Record<string, string | null | (() => unknown)>>;
 
 declare class SnapshotManager {

package/dist/node.js

@@ -1,10 +1,10 @@
-export { V as VitestPlugin, c as createVitest, s as startVitest } from './chunk-vite-node-externalize.cfbecaaf.js';
-export { V as VitestRunner } from './chunk-runtime-mocker.acd615bd.js';
+export { V as VitestPlugin, c as createVitest, s as startVitest } from './chunk-vite-node-externalize.0aac0c8e.js';
+export { V as VitestRunner } from './chunk-runtime-mocker.42fa71a8.js';
 import 'buffer';
 import 'path';
 import 'child_process';
 import 'process';
-import './vendor-index.40be925a.js';
+import './vendor-index.6c69a0a8.js';
 import './vendor-_commonjsHelpers.addc3445.js';
 import 'fs';
 import 'assert';
@@ -13,19 +13,20 @@ import 'stream';
 import 'util';
 import 'url';
 import 'os';
-import './chunk-utils-global.a5a8641f.js';
+import './chunk-utils-global.2fab7e5c.js';
 import 'tty';
 import 'local-pkg';
 import 'vite';
-import './chunk-constants.0567483c.js';
+import './chunk-constants.3570739f.js';
 import 'readline';
-import './chunk-vite-node-utils.1536f168.js';
+import './chunk-vite-node-utils.9975fd9e.js';
 import 'module';
 import 'vm';
-import './chunk-defaults.ecb46baf.js';
+import 'debug';
+import './chunk-defaults.7d81a6ca.js';
 import 'worker_threads';
 import 'tinypool';
 import 'perf_hooks';
-import './chunk-utils-timers.f25e8f44.js';
-import './chunk-magic-string.d5e0e473.js';
+import './chunk-utils-timers.da6ac0a6.js';
+import './chunk-magic-string.41232190.js';
 import './vendor-index.405e58ef.js';

package/dist/{vendor-entry.d50b0f20.js → vendor-entry.7d6cc1fd.js}

@@ -1,14 +1,11 @@
 import { promises } from 'fs';
-import { a as getWorkerState, t as toArray, G as clone, E as getType, l as relative, H as partitionSuiteChildren, I as hasTests, q as hasFailed, o as getFullName, r as resetModules } from './chunk-utils-global.a5a8641f.js';
-import { Console } from 'console';
-import { Writable } from 'stream';
+import { m as isNode, a as getWorkerState, t as toArray, H as clone, F as getType, l as relative, I as partitionSuiteChildren, J as hasTests, u as hasFailed, q as getFullName, r as resetModules } from './chunk-utils-global.2fab7e5c.js';
 import { importModule } from 'local-pkg';
-import { s as suite, t as test, d as describe, i as it, r as runOnce, a as isFirstRun, b as beforeAll, c as afterAll, e as beforeEach, f as afterEach, w as withCallback, g as createExpect, h as expect, v as vitest, j as vi, k as getRunningMode, l as isWatchMode, m as resetRunOnceCounter, R as RealDate, n as clearCollectorContext, o as defaultSuite, p as setHooks, q as getHooks, u as collectorContext, x as getSnapshotClient, y as setState, z as getFn, A as getState } from './chunk-runtime-chain.f8567c17.js';
+import { s as suite, t as test, d as describe, i as it, r as runOnce, a as isFirstRun, b as beforeAll, c as afterAll, e as beforeEach, f as afterEach, w as withCallback, g as createExpect, h as expect, v as vitest, j as vi, k as getRunningMode, l as isWatchMode, m as resetRunOnceCounter, R as RealDate, n as clearCollectorContext, o as defaultSuite, p as setHooks, q as getHooks, u as collectorContext, x as getSnapshotClient, y as setState, z as getFn, A as getState } from './chunk-runtime-chain.5021a6b6.js';
 import chai, { assert, should, util } from 'chai';
-import { r as rpc } from './chunk-runtime-rpc.63398738.js';
-import { d as clearTimeout, c as setTimeout, s as stringify } from './chunk-utils-timers.f25e8f44.js';
-import { t as takeCoverage } from './chunk-defaults.ecb46baf.js';
-import { createHash } from 'crypto';
+import { r as rpc } from './chunk-runtime-rpc.47bae3f9.js';
+import { d as clearTimeout, c as setTimeout, s as stringify } from './chunk-utils-timers.da6ac0a6.js';
+import { t as takeCoverage } from './chunk-defaults.7d81a6ca.js';
 import { format } from 'util';
 
 var index = /*#__PURE__*/Object.freeze({
@@ -287,15 +284,16 @@ function getWindowKeys(global, win) {
 function populateGlobal(global, win, options = {}) {
   const { bindFunctions = false } = options;
   const keys = getWindowKeys(global, win);
+  const originals = new Map(allowRewrite.map(([key]) => [key, global[key]]));
   const overrideObject = /* @__PURE__ */ new Map();
   for (const key of keys) {
-    const shouldBind = bindFunctions && typeof win[key] === "function";
+    const bindedFunction = bindFunctions && typeof win[key] === "function" && win[key].bind(win);
     Object.defineProperty(global, key, {
       get() {
         if (overrideObject.has(key))
           return overrideObject.get(key);
-        if (shouldBind)
-          return win[key].bind(win);
+        if (bindedFunction)
+          return bindedFunction;
         return win[key];
       },
       set(v) {
@@ -304,76 +302,16 @@ function populateGlobal(global, win, options = {}) {
       configurable: true
     });
   }
-  const globalKeys = /* @__PURE__ */ new Set(["window", "self", "top", "parent"]);
-  const globalProxy = new Proxy(win.window, {
-    get(target, p, receiver) {
-      if (overrideObject.has(p))
-        return overrideObject.get(p);
-      return Reflect.get(target, p, receiver);
-    },
-    set(target, p, value, receiver) {
-      try {
-        Object.defineProperty(global, p, {
-          get: () => overrideObject.get(p),
-          set: (value2) => overrideObject.set(p, value2),
-          configurable: true
-        });
-        overrideObject.set(p, value);
-        Reflect.set(target, p, value, receiver);
-      } catch {
-      }
-      return true;
-    },
-    deleteProperty(target, p) {
-      Reflect.deleteProperty(global, p);
-      overrideObject.delete(p);
-      return Reflect.deleteProperty(target, p);
-    },
-    defineProperty(target, p, attributes) {
-      if (attributes.writable && "value" in attributes) ; else if (attributes.get) {
-        overrideObject.delete(p);
-        Reflect.defineProperty(global, p, attributes);
-      }
-      return Reflect.defineProperty(target, p, attributes);
-    }
-  });
-  globalKeys.forEach((key) => {
-    if (!win[key])
-      return;
-    Object.defineProperty(global, key, {
-      get() {
-        return globalProxy;
-      },
-      configurable: true
-    });
-  });
-  const globalThisProxy = new Proxy(global.globalThis, {
-    set(target, key, value, receiver) {
-      overrideObject.set(key, value);
-      return Reflect.set(target, key, value, receiver);
-    },
-    deleteProperty(target, key) {
-      overrideObject.delete(key);
-      return Reflect.deleteProperty(target, key);
-    },
-    defineProperty(target, p, attributes) {
-      if (attributes.writable && "value" in attributes) ; else if (attributes.get && !globalKeys.has(p)) {
-        globalKeys.forEach((key) => {
-          if (win[key])
-            Object.defineProperty(win[key], p, attributes);
-        });
-      }
-      return Reflect.defineProperty(target, p, attributes);
-    }
-  });
-  global.globalThis = globalThisProxy;
+  global.window = global;
+  global.self = global;
+  global.top = global;
   if (global.global)
-    global.global = globalThisProxy;
+    global.global = global;
   skipKeys.forEach((k) => keys.add(k));
   return {
     keys,
     skipKeys,
-    allowRewrite
+    originals
   };
 }
 
@@ -448,8 +386,7 @@ var jsdom = {
       contentType,
       userAgent
     }, restOptions));
-    const { keys, allowRewrite } = populateGlobal(global, dom.window);
-    const originals = new Map(allowRewrite.map(([key]) => [key, global[key]]));
+    const { keys, originals } = populateGlobal(global, dom.window, { bindFunctions: true });
     return {
       teardown(global2) {
         keys.forEach((key) => delete global2[key]);
@@ -464,8 +401,7 @@ var happy = {
   async setup(global) {
     const { Window, GlobalWindow } = await importModule("happy-dom");
     const win = new (GlobalWindow || Window)();
-    const { keys, allowRewrite } = populateGlobal(global, win, { bindFunctions: true });
-    const originals = new Map(allowRewrite.map(([key]) => [key, global[key]]));
+    const { keys, originals } = populateGlobal(global, win, { bindFunctions: true });
     return {
       teardown(global2) {
         win.happyDOM.cancelAsync();
@@ -493,19 +429,22 @@ async function setupGlobalEnv(config) {
   if (globalSetup)
     return;
   globalSetup = true;
-  setupConsoleLogSpy();
+  if (isNode)
+    await setupConsoleLogSpy();
   if (config.globals)
-    (await import('./chunk-integrations-globals.f3e83abb.js')).registerApiGlobally();
+    (await import('./chunk-integrations-globals.36dc71fa.js')).registerApiGlobally();
 }
 function setupDefines(defines) {
   for (const key in defines)
     globalThis[key] = defines[key];
 }
-function setupConsoleLogSpy() {
+async function setupConsoleLogSpy() {
   const stdoutBuffer = /* @__PURE__ */ new Map();
   const stderrBuffer = /* @__PURE__ */ new Map();
   const timers = /* @__PURE__ */ new Map();
   const unknownTestId = "__vitest__unknown_test__";
+  const { Writable } = await import('stream');
+  const { Console } = await import('console');
   function schedule(taskId) {
     const timer = timers.get(taskId);
     const { stdoutTime, stderrTime } = timer;
@@ -677,14 +616,17 @@ function processError(err) {
     err.expected = stringify(err.expected);
   if (typeof err.actual !== "string")
     err.actual = stringify(err.actual);
-  if (typeof err.message === "string")
-    err.message = normalizeErrorMessage(err.message);
-  if (typeof err.cause === "object" && err.cause.message === "string")
-    err.cause.message = normalizeErrorMessage(err.cause.message);
+  try {
+    if (typeof err.message === "string")
+      err.message = normalizeErrorMessage(err.message);
+    if (typeof err.cause === "object" && err.cause.message === "string")
+      err.cause.message = normalizeErrorMessage(err.cause.message);
+  } catch {
+  }
   try {
     return serializeError(err);
   } catch (e) {
-    return serializeError(new Error(`Failed to fully serialize error: ${e == null ? void 0 : e.message}.
+    return serializeError(new Error(`Failed to fully serialize error: ${e == null ? void 0 : e.message}
 Inner error message: ${err == null ? void 0 : err.message}`));
   }
 }
@@ -722,8 +664,16 @@ function replaceAsymmetricMatcher(actual, expected) {
 }
 
 const now$1 = Date.now;
-function hash(str, length = 10) {
-  return createHash("md5").update(str).digest("hex").slice(0, length);
+function hash(str) {
+  let hash2 = 0;
+  if (str.length === 0)
+    return `${hash2}`;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash2 = (hash2 << 5) - hash2 + char;
+    hash2 = hash2 & hash2;
+  }
+  return `${hash2}`;
 }
 async function collectTests(paths, config) {
   const files = [];

package/dist/worker.js

@@ -1,8 +1,8 @@
-import { h as resolve, a as getWorkerState } from './chunk-utils-global.a5a8641f.js';
-import { c as createBirpc, M as ModuleCacheMap } from './chunk-vite-node-utils.1536f168.js';
-import { d as distDir } from './chunk-constants.0567483c.js';
-import { e as executeInViteNode } from './chunk-runtime-mocker.acd615bd.js';
-import { r as rpc } from './chunk-runtime-rpc.63398738.js';
+import { h as resolve, a as getWorkerState } from './chunk-utils-global.2fab7e5c.js';
+import { c as createBirpc, M as ModuleCacheMap } from './chunk-vite-node-utils.9975fd9e.js';
+import { d as distDir } from './chunk-constants.3570739f.js';
+import { e as executeInViteNode } from './chunk-runtime-mocker.42fa71a8.js';
+import { r as rpc } from './chunk-runtime-rpc.47bae3f9.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
@@ -12,6 +12,7 @@ import 'vm';
 import 'fs';
 import 'assert';
 import 'util';
+import 'debug';
 import 'vite';
 
 let _viteNode;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vitest",
   "type": "module",
-  "version": "0.12.4",
+  "version": "0.12.7",
   "description": "A blazing fast unit test framework powered by Vite",
   "keywords": [
     "vite",
@@ -78,6 +78,7 @@
     "@types/chai": "^4.3.1",
     "@types/chai-subset": "^1.3.3",
     "chai": "^4.3.6",
+    "debug": "^4.3.4",
     "local-pkg": "^0.4.1",
     "tinypool": "^0.1.3",
     "tinyspy": "^0.3.2",
@@ -90,10 +91,10 @@
     "@types/jsdom": "^16.2.14",
     "@types/micromatch": "^4.0.2",
     "@types/natural-compare": "^1.4.1",
-    "@types/node": "^17.0.31",
+    "@types/node": "^17.0.33",
     "@types/prompts": "^2.4.0",
     "@types/sinonjs__fake-timers": "^8.1.2",
-    "@vitest/ui": "0.12.4",
+    "@vitest/ui": "0.12.7",
     "birpc": "^0.2.2",
     "c8": "^7.11.2",
     "cac": "^6.7.12",
@@ -104,10 +105,10 @@
     "fast-glob": "^3.2.11",
     "find-up": "^6.3.0",
     "flatted": "^3.2.5",
-    "happy-dom": "^3.1.1",
+    "happy-dom": "^3.2.0",
     "jsdom": "^19.0.0",
     "log-update": "^5.0.1",
-    "magic-string": "^0.26.1",
+    "magic-string": "^0.26.2",
     "micromatch": "^4.0.5",
     "mlly": "^0.5.2",
     "natural-compare": "^1.4.0",
@@ -116,11 +117,11 @@
     "pkg-types": "^0.3.2",
     "pretty-format": "^27.5.1",
     "prompts": "^2.4.2",
-    "rollup": "^2.72.1",
+    "rollup": "^2.73.0",
     "source-map-js": "^1.0.2",
     "strip-ansi": "^7.0.1",
     "typescript": "^4.6.4",
-    "vite-node": "0.12.4",
+    "vite-node": "0.12.7",
     "ws": "^8.6.0"
   },
   "engines": {

package/dist/chunk-integrations-globals.f3e83abb.js

@@ -1,29 +0,0 @@
-import { g as globalApis } from './chunk-constants.0567483c.js';
-import { i as index } from './vendor-entry.d50b0f20.js';
-import 'url';
-import './chunk-utils-global.a5a8641f.js';
-import 'tty';
-import 'local-pkg';
-import 'path';
-import 'fs';
-import 'console';
-import 'stream';
-import './chunk-runtime-chain.f8567c17.js';
-import 'chai';
-import './vendor-_commonjsHelpers.addc3445.js';
-import './chunk-runtime-rpc.63398738.js';
-import './chunk-utils-timers.f25e8f44.js';
-import './chunk-integrations-spy.bee66426.js';
-import 'tinyspy';
-import 'util';
-import './chunk-defaults.ecb46baf.js';
-import 'module';
-import 'crypto';
-
-function registerApiGlobally() {
-  globalApis.forEach((api) => {
-    globalThis[api] = index[api];
-  });
-}
-
-export { registerApiGlobally };