vitest 0.0.68 → 0.0.72

package/dist/global-e40b54d6.js

@@ -0,0 +1,16 @@
+import { g as globalApis } from './constants-d4c70610.js';
+import { i as index } from './index-e37648e9.js';
+import 'path';
+import 'url';
+import './suite-819c135e.js';
+import './index-6427e0f2.js';
+import 'chai';
+import 'sinon';
+
+function registerApiGlobally() {
+  globalApis.forEach((api) => {
+    globalThis[api] = index[api];
+  });
+}
+
+export { registerApiGlobally };

package/dist/index-6427e0f2.js

@@ -0,0 +1,12 @@
+let urlAlphabet =
+  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
+let nanoid = (size = 21) => {
+  let id = '';
+  let i = size;
+  while (i--) {
+    id += urlAlphabet[(Math.random() * 64) | 0];
+  }
+  return id
+};
+
+export { nanoid as n };

package/dist/index-e37648e9.js

@@ -0,0 +1,31 @@
+import { s as suite, d as defaultSuite, c as createSuiteHooks, t as test, a as describe, i as it, b as beforeAll, e as afterAll, f as beforeEach, g as afterEach, h as clearContext } from './suite-819c135e.js';
+import chai, { assert, should, expect } from 'chai';
+import sinon from 'sinon';
+
+const { mock, spy, stub } = sinon;
+sinon.fn = sinon.spy;
+
+var index = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  suite: suite,
+  defaultSuite: defaultSuite,
+  createSuiteHooks: createSuiteHooks,
+  test: test,
+  describe: describe,
+  it: it,
+  beforeAll: beforeAll,
+  afterAll: afterAll,
+  beforeEach: beforeEach,
+  afterEach: afterEach,
+  clearContext: clearContext,
+  assert: assert,
+  should: should,
+  expect: expect,
+  chai: chai,
+  sinon: sinon,
+  mock: mock,
+  spy: spy,
+  stub: stub
+});
+
+export { stub as a, index as i, mock as m, spy as s };

package/dist/index.d.ts

@@ -1,11 +1,404 @@
-import { R as ResolvedConfig, F as File, T as TaskResultPack, S as SnapshotResult, a as TestFactory, b as SuiteCollector, c as TestFunction, d as SuiteHooks, U as UserOptions } from './options-63a726fa';
-export { u as Arrayable, A as Awaitable, C as CliOptions, g as ComputeMode, v as Environment, E as EnvironmentReturn, F as File, G as GlobalContext, H as HookListener, M as ModuleCache, N as Nullable, n as Reporter, R as ResolvedConfig, e as RunMode, o as SnapshotData, r as SnapshotMatchOptions, S as SnapshotResult, q as SnapshotStateOptions, t as SnapshotSummary, p as SnapshotUpdateState, j as Suite, b as SuiteCollector, d as SuiteHooks, l as Task, h as TaskBase, i as TaskResult, T as TaskResultPack, f as TaskState, k as Test, m as TestCollector, a as TestFactory, c as TestFunction, s as UncheckedSnapshot, U as UserOptions, V as VitestContext } from './options-63a726fa';
+import { Formatter } from 'picocolors/types';
+import { TransformResult, ViteDevServer } from 'vite';
+import { OptionsReceived } from 'pretty-format';
 import { MessagePort } from 'worker_threads';
-import { TransformResult } from 'vite';
 export { assert, default as chai, expect, should } from 'chai';
 import sinon from 'sinon';
 export { default as sinon } from 'sinon';
-import 'pretty-format';
+
+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 type MatcherHintOptions = {
+    comment?: string;
+    expectedColor?: Formatter;
+    isDirectExpectCall?: boolean;
+    isNot?: boolean;
+    promise?: string;
+    receivedColor?: Formatter;
+    secondArgument?: string;
+    secondArgumentColor?: Formatter;
+};
+declare function matcherHint(matcherName: string, received?: string, expected?: string, options?: MatcherHintOptions): string;
+declare const stringify: (object: unknown, maxDepth?: number) => string;
+declare const printReceived: (object: unknown) => string;
+declare const printExpected: (value: unknown) => string;
+declare type 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 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;
+type jestMatcherUtils_MatcherHintOptions = MatcherHintOptions;
+declare const jestMatcherUtils_matcherHint: typeof matcherHint;
+declare const jestMatcherUtils_stringify: typeof stringify;
+declare const jestMatcherUtils_printReceived: typeof printReceived;
+declare const jestMatcherUtils_printExpected: typeof printExpected;
+type jestMatcherUtils_DiffOptions = DiffOptions;
+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_MatcherHintOptions as MatcherHintOptions,
+    jestMatcherUtils_matcherHint as matcherHint,
+    jestMatcherUtils_stringify as stringify,
+    jestMatcherUtils_printReceived as printReceived,
+    jestMatcherUtils_printExpected as printExpected,
+    jestMatcherUtils_DiffOptions as DiffOptions,
+    jestMatcherUtils_diff as diff,
+  };
+}
+
+declare type Tester = (a: any, b: any) => boolean | undefined;
+declare type 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;
+    expectedAssertionsNumberError?: Error;
+    isExpectingAssertions?: boolean;
+    isExpectingAssertionsError?: Error;
+    isNot: boolean;
+    promise: string;
+    suppressedErrors: Array<Error>;
+    testPath?: string;
+    utils: typeof jestMatcherUtils & {
+        iterableEquality: Tester;
+        subsetEquality: Tester;
+    };
+};
+declare type SyncExpectationResult = {
+    pass: boolean;
+    message: () => string;
+};
+declare type AsyncExpectationResult = Promise<SyncExpectationResult>;
+declare type ExpectationResult = SyncExpectationResult | AsyncExpectationResult;
+declare type RawMatcherFn<T extends MatcherState = MatcherState> = {
+    (this: T, received: any, expected: any, options?: any): ExpectationResult;
+};
+declare type MatchersObject<T extends MatcherState = MatcherState> = {
+    [id: string]: RawMatcherFn<T>;
+};
+
+declare class StateManager {
+    filesMap: Record<string, File>;
+    idMap: Record<string, Task>;
+    taskFileMap: WeakMap<Task, File>;
+    getFiles(keys?: string[]): File[];
+    collectFiles(files: File[]): void;
+    updateId(task: Task): void;
+    updateTasks(packs: TaskResultPack[]): void;
+}
+
+declare class SnapshotManager {
+    config: ResolvedConfig;
+    summary: SnapshotSummary;
+    constructor(config: ResolvedConfig);
+    clear(): void;
+    add(result: SnapshotResult): void;
+}
+
+declare type Awaitable<T> = T | PromiseLike<T>;
+declare type Nullable<T> = T | null | undefined;
+declare type Arrayable<T> = T | Array<T>;
+interface ModuleCache {
+    promise?: Promise<any>;
+    exports?: any;
+    transformResult?: TransformResult;
+}
+interface EnvironmentReturn {
+    teardown: (global: any) => Awaitable<void>;
+}
+interface Environment {
+    name: string;
+    setup(global: any): Awaitable<EnvironmentReturn>;
+}
+interface VitestContext {
+    config: ResolvedConfig;
+    server: ViteDevServer;
+    state: StateManager;
+    snapshot: SnapshotManager;
+    reporter: Reporter;
+}
+
+declare type RunMode = 'run' | 'skip' | 'only' | 'todo';
+declare type TaskState = RunMode | 'pass' | 'fail';
+declare type ComputeMode = 'serial' | 'concurrent';
+interface TaskBase {
+    id: string;
+    name: string;
+    mode: RunMode;
+    computeMode: ComputeMode;
+    suite?: Suite;
+    file?: File;
+    result?: TaskResult;
+}
+interface TaskResult {
+    state: TaskState;
+    start: number;
+    end?: number;
+    error?: unknown;
+}
+declare type TaskResultPack = [id: string, result: TaskResult | undefined];
+interface Suite extends TaskBase {
+    type: 'suite';
+    tasks: Task[];
+}
+interface File extends Suite {
+    filepath: string;
+}
+interface Test extends TaskBase {
+    type: 'test';
+    suite: Suite;
+    result?: TaskResult;
+}
+declare type Task = Test | Suite | File;
+declare type TestFunction = () => Awaitable<void>;
+declare type TestCollectorFn = (name: string, fn: TestFunction, timeout?: number) => void;
+interface ConcurrentCollector {
+    (name: string, fn: TestFunction, timeout?: number): void;
+    only: TestCollectorFn;
+    skip: TestCollectorFn;
+    todo: (name: string) => void;
+}
+interface OnlyCollector {
+    (name: string, fn: TestFunction, timeout?: number): void;
+    concurrent: TestCollectorFn;
+}
+interface SkipCollector {
+    (name: string, fn: TestFunction, timeout?: number): void;
+    concurrent: TestCollectorFn;
+}
+interface TodoCollector {
+    (name: string): void;
+    concurrent: (name: string) => void;
+}
+interface TestCollector {
+    (name: string, fn: TestFunction, timeout?: number): void;
+    concurrent: ConcurrentCollector;
+    only: OnlyCollector;
+    skip: SkipCollector;
+    todo: TodoCollector;
+}
+declare type HookListener<T extends any[]> = (...args: T) => Awaitable<void>;
+interface SuiteHooks {
+    beforeAll: HookListener<[Suite]>[];
+    afterAll: HookListener<[Suite]>[];
+    beforeEach: HookListener<[Test, Suite]>[];
+    afterEach: HookListener<[Test, Suite]>[];
+}
+interface SuiteCollector {
+    readonly name: string;
+    readonly mode: RunMode;
+    type: 'collector';
+    test: TestCollector;
+    tasks: (Suite | Test | SuiteCollector)[];
+    collect: (file?: File) => Promise<Suite>;
+    clear: () => void;
+    on: <T extends keyof SuiteHooks>(name: T, ...fn: SuiteHooks[T]) => void;
+}
+declare type TestFactory = (test: (name: string, fn: TestFunction) => void) => Awaitable<void>;
+interface GlobalContext {
+    tasks: (SuiteCollector | Test)[];
+    currentSuite: SuiteCollector | null;
+}
+
+interface Reporter {
+    onStart?: (files?: string[]) => Awaitable<void>;
+    onFinished?: (files?: File[]) => Awaitable<void>;
+    onTaskUpdate?: (pack: TaskResultPack) => Awaitable<void>;
+    onWatcherStart?: () => Awaitable<void>;
+    onWatcherRerun?: (files: string[], trigger: string) => Awaitable<void>;
+}
+
+declare type SnapshotData = Record<string, string>;
+declare type SnapshotUpdateState = 'all' | 'new' | 'none';
+declare type SnapshotStateOptions = {
+    updateSnapshot: SnapshotUpdateState;
+    expand?: boolean;
+    snapshotFormat?: OptionsReceived;
+};
+declare type SnapshotMatchOptions = {
+    testName: string;
+    received: unknown;
+    key?: string;
+    inlineSnapshot?: string;
+    isInline: boolean;
+    error?: Error;
+};
+interface SnapshotResult {
+    filepath: string;
+    added: number;
+    fileDeleted: boolean;
+    matched: number;
+    unchecked: number;
+    uncheckedKeys: Array<string>;
+    unmatched: number;
+    updated: number;
+}
+interface UncheckedSnapshot {
+    filePath: string;
+    keys: Array<string>;
+}
+interface SnapshotSummary {
+    added: number;
+    didUpdate: boolean;
+    failure: boolean;
+    filesAdded: number;
+    filesRemoved: number;
+    filesRemovedList: Array<string>;
+    filesUnmatched: number;
+    filesUpdated: number;
+    matched: number;
+    total: number;
+    unchecked: number;
+    uncheckedKeysByFile: Array<UncheckedSnapshot>;
+    unmatched: number;
+    updated: number;
+}
+
+interface UserOptions {
+    /**
+     * Include globs for test files
+     *
+     * @default ['**\/*.test.ts']
+     */
+    includes?: string[];
+    /**
+     * Exclude globs for test files
+     * @default ['**\/node_modules\/**']
+     */
+    excludes?: string[];
+    /**
+     * Handling for dependencies inlining or externalizing
+     */
+    deps?: {
+        /**
+         * Externalize means that Vite will bypass the package to native Node.
+         *
+         * Externaled dependencies will not be applied Vite's transformers and resolvers.
+         * And does not support HMR on reload.
+         *
+         * Typically, packages under `node_modules` are externalized.
+         */
+        external?: (string | RegExp)[];
+        /**
+         * Vite will process inlined modules.
+         *
+         * This could be helpful to handle packages that ship `.js` in ESM format (that Node can't handle).
+         */
+        inline?: (string | RegExp)[];
+    };
+    /**
+     * Register apis globally
+     *
+     * @default false
+     */
+    global?: boolean;
+    /**
+     * Running environment
+     *
+     * Supports 'node', 'jsdom', 'happy-dom'
+     *
+     * @default 'node'
+     */
+    environment?: 'node' | 'jsdom' | 'happy-dom';
+    /**
+     * Update snapshot files
+     *
+     * @default false
+     */
+    update?: boolean;
+    /**
+     * Watch mode
+     *
+     * @default false
+     */
+    watch?: boolean;
+    /**
+     * Project root
+     */
+    root?: string;
+    /**
+     * Custom reporter for output
+     */
+    reporter?: Reporter;
+    /**
+     * Enable multi-threading
+     *
+     * @default true
+     */
+    threads?: boolean;
+    /**
+     * Maximum number of threads
+     *
+     * @default available CPUs
+     */
+    maxThreads?: number;
+    /**
+     * Minimum number of threads
+     *
+     * @default available CPUs
+     */
+    minThreads?: number;
+    interpretDefault?: boolean;
+    testTimeout?: number;
+    hookTimeout?: number;
+}
+interface CliOptions extends UserOptions {
+    /**
+     * Filters by name
+     */
+    cliFilters?: string[];
+    /**
+     * Path to the config file.
+     *
+     * Default resolving to one of:
+     * - `vitest.config.js`
+     * - `vitest.config.ts`
+     * - `vite.config.js`
+     * - `vite.config.ts`
+     */
+    config?: string | undefined;
+    dom?: boolean;
+}
+interface ResolvedConfig extends Omit<Required<CliOptions>, 'config' | 'filters'> {
+    config?: string;
+    filters?: string[];
+    depsInline: (string | RegExp)[];
+    depsExternal: (string | RegExp)[];
+    snapshotOptions: SnapshotStateOptions;
+}
 
 interface WorkerContext {
     port: MessagePort;
@@ -127,6 +520,17 @@ declare const afterAll: (fn: SuiteHooks['afterAll'][0], timeout?: number | undef
 declare const beforeEach: (fn: SuiteHooks['beforeEach'][0], timeout?: number | undefined) => void;
 declare const afterEach: (fn: SuiteHooks['afterEach'][0], timeout?: number | undefined) => void;
 declare function clearContext(): void;
+declare global {
+    namespace NodeJS {
+        interface Process {
+            __vitest_worker__: {
+                config: ResolvedConfig;
+                rpc: RpcCall;
+                send: RpcSend;
+            };
+        }
+    }
+}
 
 declare const mock: sinon.SinonMockStatic;
 declare const spy: sinon.SinonSpyStatic;
@@ -142,6 +546,9 @@ declare module 'vite' {
 }
 declare global {
     namespace Chai {
+        interface ExpectStatic {
+            extend(expects: MatchersObject): void;
+        }
         interface Assertion {
             toMatchSnapshot(message?: string): Assertion;
             matchSnapshot(message?: string): Assertion;
@@ -192,4 +599,4 @@ declare global {
     }
 }
 
-export { RpcCall, RpcMap, RpcPayload, RpcSend, WorkerContext, afterAll, afterEach, beforeAll, beforeEach, clearContext, createSuiteHooks, defaultSuite, describe, it, mock, spy, stub, suite, test };
+export { Arrayable, Awaitable, CliOptions, ComputeMode, Environment, EnvironmentReturn, File, GlobalContext, HookListener, ModuleCache, Nullable, Reporter, ResolvedConfig, RpcCall, RpcMap, RpcPayload, RpcSend, RunMode, SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, Suite, SuiteCollector, SuiteHooks, Task, TaskBase, TaskResult, TaskResultPack, TaskState, Test, TestCollector, TestFactory, TestFunction, UncheckedSnapshot, UserOptions, VitestContext, WorkerContext, afterAll, afterEach, beforeAll, beforeEach, clearContext, createSuiteHooks, defaultSuite, describe, it, mock, spy, stub, suite, test };

package/dist/index.js

@@ -1,46 +1,5 @@
-import {
-  assert,
-  chai,
-  expect,
-  mock,
-  should,
-  sinon,
-  spy,
-  stub
-} from "./chunk-YPKHVZRP.js";
-import {
-  afterAll,
-  afterEach,
-  beforeAll,
-  beforeEach,
-  clearContext,
-  createSuiteHooks,
-  defaultSuite,
-  describe,
-  it,
-  suite,
-  test
-} from "./chunk-ANPMHBIF.js";
-import "./chunk-APGELTDH.js";
-import "./chunk-R2SMNEBL.js";
-export {
-  afterAll,
-  afterEach,
-  assert,
-  beforeAll,
-  beforeEach,
-  chai,
-  clearContext,
-  createSuiteHooks,
-  defaultSuite,
-  describe,
-  expect,
-  it,
-  mock,
-  should,
-  sinon,
-  spy,
-  stub,
-  suite,
-  test
-};
+export { e as afterAll, g as afterEach, b as beforeAll, f as beforeEach, h as clearContext, c as createSuiteHooks, d as defaultSuite, a as describe, i as it, s as suite, t as test } from './suite-819c135e.js';
+export { assert, default as chai, expect, should } from 'chai';
+export { m as mock, s as spy, a as stub } from './index-e37648e9.js';
+export { default as sinon } from 'sinon';
+import './index-6427e0f2.js';

package/dist/{chunk-ANPMHBIF.js → suite-819c135e.js}

@@ -1,24 +1,12 @@
-import {
-  nanoid
-} from "./chunk-APGELTDH.js";
-import {
-  init_esm_shims
-} from "./chunk-R2SMNEBL.js";
+import { n as nanoid } from './index-6427e0f2.js';
 
-// src/runtime/suite.ts
-init_esm_shims();
-
-// src/runtime/context.ts
-init_esm_shims();
-var context = {
+const context = {
   tasks: [],
   currentSuite: null
 };
 
-// src/runtime/map.ts
-init_esm_shims();
-var fnMap = new WeakMap();
-var hooksMap = new WeakMap();
+const fnMap = new WeakMap();
+const hooksMap = new WeakMap();
 function setFn(key, fn) {
   fnMap.set(key, fn);
 }
@@ -32,17 +20,16 @@ function getHooks(key) {
   return hooksMap.get(key);
 }
 
-// src/runtime/suite.ts
-var suite = createSuite();
-var defaultSuite = suite("");
+const suite = createSuite();
+const defaultSuite = suite("");
 function getCurrentSuite() {
   return context.currentSuite || defaultSuite;
 }
-var getDefaultTestTimeout = () => {
+const getDefaultTestTimeout = () => {
   var _a, _b;
   return ((_b = (_a = process.__vitest_worker__) == null ? void 0 : _a.config) == null ? void 0 : _b.testTimeout) ?? 5e3;
 };
-var getDefaultHookTimeout = () => {
+const getDefaultHookTimeout = () => {
   var _a, _b;
   return ((_b = (_a = process.__vitest_worker__) == null ? void 0 : _a.config) == null ? void 0 : _b.hookTimeout) ?? 5e3;
 };
@@ -152,7 +139,7 @@ function createTestCollector(collectTest) {
   todo.concurrent = todo;
   return test2;
 }
-var test = function() {
+const test = function() {
   function test2(name, fn, timeout) {
     return getCurrentSuite().test(name, fn, timeout);
   }
@@ -208,12 +195,12 @@ function createSuite() {
   suite2.todo = todo;
   return suite2;
 }
-var describe = suite;
-var it = test;
-var beforeAll = (fn, timeout) => getCurrentSuite().on("beforeAll", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
-var afterAll = (fn, timeout) => getCurrentSuite().on("afterAll", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
-var beforeEach = (fn, timeout) => getCurrentSuite().on("beforeEach", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
-var afterEach = (fn, timeout) => getCurrentSuite().on("afterEach", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
+const describe = suite;
+const it = test;
+const beforeAll = (fn, timeout) => getCurrentSuite().on("beforeAll", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
+const afterAll = (fn, timeout) => getCurrentSuite().on("afterAll", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
+const beforeEach = (fn, timeout) => getCurrentSuite().on("beforeEach", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
+const afterEach = (fn, timeout) => getCurrentSuite().on("afterEach", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
 function clearContext() {
   context.tasks.length = 0;
   defaultSuite.clear();
@@ -234,20 +221,4 @@ function withTimeout(fn, _timeout) {
   };
 }
 
-export {
-  context,
-  getFn,
-  setHooks,
-  getHooks,
-  suite,
-  defaultSuite,
-  createSuiteHooks,
-  test,
-  describe,
-  it,
-  beforeAll,
-  afterAll,
-  beforeEach,
-  afterEach,
-  clearContext
-};
+export { describe as a, beforeAll as b, createSuiteHooks as c, defaultSuite as d, afterAll as e, beforeEach as f, afterEach as g, clearContext as h, it as i, setHooks as j, context as k, getHooks as l, getFn as m, suite as s, test as t };

package/dist/{chunk-5TNYWP3O.js → utils-9dcc4050.js}

@@ -1,9 +1,3 @@
-import {
-  init_esm_shims
-} from "./chunk-R2SMNEBL.js";
-
-// src/utils.ts
-init_esm_shims();
 function toArray(array) {
   array = array || [];
   if (Array.isArray(array))
@@ -67,15 +61,4 @@ function getNames(task) {
   return names;
 }
 
-export {
-  toArray,
-  notNullish,
-  slash,
-  partitionSuiteChildren,
-  interpretOnlyMode,
-  getTests,
-  getSuites,
-  hasTests,
-  hasFailed,
-  getNames
-};
+export { getTests as a, getSuites as b, hasTests as c, getNames as g, hasFailed as h, interpretOnlyMode as i, notNullish as n, partitionSuiteChildren as p, slash as s, toArray as t };