@rstest/core 0.6.1 → 0.6.2

package/dist/0~85.js

@@ -1,1819 +0,0 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
-export const __webpack_id__ = "85";
-export const __webpack_ids__ = [
-    "85"
-];
-export const __webpack_modules__ = {
-    "./src/runtime/api/index.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            createRstestRuntime: ()=>createRstestRuntime
-        });
-        var dist = __webpack_require__("../../node_modules/.pnpm/@vitest+expect@3.2.4/node_modules/@vitest/expect/dist/index.js");
-        var src_utils = __webpack_require__("./src/utils/index.ts");
-        var node_modules_chai = __webpack_require__("../../node_modules/.pnpm/chai@5.3.3/node_modules/chai/index.js");
-        var runtime_util = __webpack_require__("./src/runtime/util.ts");
-        const unsupported = [
-            'matchSnapshot',
-            'toMatchSnapshot',
-            'toMatchInlineSnapshot',
-            'toThrowErrorMatchingSnapshot',
-            'toThrowErrorMatchingInlineSnapshot',
-            'throws',
-            'Throw',
-            'throw',
-            'toThrow',
-            'toThrowError'
-        ];
-        function createExpectPoll(expect) {
-            return function poll(fn, options = {}) {
-                const { interval = 50, timeout = 1000, message } = options;
-                const assertion = expect(null, message).withContext({
-                    poll: true
-                });
-                fn = fn.bind(assertion);
-                const test = node_modules_chai.ZS.flag(assertion, 'vitest-test');
-                if (!test) throw new Error('expect.poll() must be called inside a test');
-                const proxy = new Proxy(assertion, {
-                    get (target, key, receiver) {
-                        const assertionFunction = Reflect.get(target, key, receiver);
-                        if ('function' != typeof assertionFunction) return assertionFunction instanceof node_modules_chai.zo ? proxy : assertionFunction;
-                        if ('assert' === key) return assertionFunction;
-                        if ('string' == typeof key && unsupported.includes(key)) throw new SyntaxError(`expect.poll() is not supported in combination with .${key}(). Use rstest.waitFor() if your assertion condition is unstable.`);
-                        return function(...args) {
-                            const STACK_TRACE_ERROR = new Error('STACK_TRACE_ERROR');
-                            const promise = ()=>new Promise((resolve, reject)=>{
-                                    let intervalId;
-                                    let timeoutId;
-                                    let lastError;
-                                    const check = async ()=>{
-                                        try {
-                                            node_modules_chai.ZS.flag(assertion, '_name', key);
-                                            const obj = await fn();
-                                            node_modules_chai.ZS.flag(assertion, 'object', obj);
-                                            resolve(await assertionFunction.call(assertion, ...args));
-                                            clearTimeout(intervalId);
-                                            clearTimeout(timeoutId);
-                                        } catch (err) {
-                                            lastError = err;
-                                            if (!node_modules_chai.ZS.flag(assertion, '_isLastPollAttempt')) intervalId = (0, runtime_util.rZ)().setTimeout(check, interval);
-                                        }
-                                    };
-                                    timeoutId = (0, runtime_util.rZ)().setTimeout(()=>{
-                                        clearTimeout(intervalId);
-                                        node_modules_chai.ZS.flag(assertion, '_isLastPollAttempt', true);
-                                        const rejectWithCause = (cause)=>{
-                                            reject(copyStackTrace(new Error(`Matcher did not succeed in ${timeout}ms`, {
-                                                cause
-                                            }), STACK_TRACE_ERROR));
-                                        };
-                                        check().then(()=>rejectWithCause(lastError)).catch((e)=>rejectWithCause(e));
-                                    }, timeout);
-                                    check();
-                                });
-                            let awaited = false;
-                            test.onFinished ??= [];
-                            test.onFinished.push(()=>{
-                                if (!awaited) {
-                                    const negated = node_modules_chai.ZS.flag(assertion, 'negate') ? 'not.' : '';
-                                    const name = node_modules_chai.ZS.flag(assertion, '_poll.element') ? 'element(locator)' : 'poll(assertion)';
-                                    const assertionString = `expect.${name}.${negated}${String(key)}()`;
-                                    const error = new Error(`${assertionString} was not awaited. This assertion is asynchronous and must be awaited; otherwise, it is not executed to avoid unhandled rejections:\n\nawait ${assertionString}\n`);
-                                    throw copyStackTrace(error, STACK_TRACE_ERROR);
-                                }
-                            });
-                            let resultPromise;
-                            return {
-                                then (onFulfilled, onRejected) {
-                                    awaited = true;
-                                    resultPromise ||= promise();
-                                    return resultPromise.then(onFulfilled, onRejected);
-                                },
-                                catch (onRejected) {
-                                    resultPromise ||= promise();
-                                    return resultPromise.catch(onRejected);
-                                },
-                                finally (onFinally) {
-                                    resultPromise ||= promise();
-                                    return resultPromise.finally(onFinally);
-                                },
-                                [Symbol.toStringTag]: 'Promise'
-                            };
-                        };
-                    }
-                });
-                return proxy;
-            };
-        }
-        function copyStackTrace(target, source) {
-            if (void 0 !== source.stack) target.stack = source.stack.replace(source.message, target.message);
-            return target;
-        }
-        var snapshot_dist = __webpack_require__("../../node_modules/.pnpm/@vitest+snapshot@3.2.4/node_modules/@vitest/snapshot/dist/index.js");
-        let _client;
-        function getSnapshotClient() {
-            if (!_client) _client = new snapshot_dist.s({
-                isEqual: (received, expected)=>(0, dist.aI)(received, expected, [
-                        dist.D,
-                        dist.j2
-                    ])
-            });
-            return _client;
-        }
-        function recordAsyncExpect(_test, promise, assertion, error) {
-            const test = _test;
-            if (test && promise instanceof Promise) {
-                promise = promise.finally(()=>{
-                    if (!test.promises) return;
-                    const index = test.promises.indexOf(promise);
-                    if (-1 !== index) test.promises.splice(index, 1);
-                });
-                if (!test.promises) test.promises = [];
-                test.promises.push(promise);
-                let resolved = false;
-                test.onFinished ??= [];
-                test.onFinished.push(()=>{
-                    if (!resolved) {
-                        const processor = globalThis.__vitest_worker__?.onFilterStackTrace || ((s)=>s || '');
-                        const stack = processor(error.stack);
-                        console.warn([
-                            `Promise returned by \`${assertion}\` was not awaited. `,
-                            'Rstest currently auto-awaits hanging assertions at the end of the test.',
-                            'Please remember to await the assertion.\n',
-                            stack
-                        ].join(''));
-                    }
-                });
-                return {
-                    then (onFulfilled, onRejected) {
-                        resolved = true;
-                        return promise.then(onFulfilled, onRejected);
-                    },
-                    catch (onRejected) {
-                        return promise.catch(onRejected);
-                    },
-                    finally (onFinally) {
-                        return promise.finally(onFinally);
-                    },
-                    [Symbol.toStringTag]: 'Promise'
-                };
-            }
-            return promise;
-        }
-        function createAssertionMessage(util, assertion, hasArgs) {
-            const not = util.flag(assertion, 'negate') ? 'not.' : '';
-            const name = `${util.flag(assertion, '_name')}(${hasArgs ? 'expected' : ''})`;
-            const promiseName = util.flag(assertion, 'promise');
-            const promise = promiseName ? `.${promiseName}` : '';
-            return `expect(actual)${promise}.${not}${name}`;
-        }
-        function getError(expected, promise) {
-            if ('function' != typeof expected) {
-                if (!promise) throw new Error(`expected must be a function, received ${typeof expected}`);
-                return expected;
-            }
-            try {
-                expected();
-            } catch (e) {
-                return e;
-            }
-            throw new Error("snapshot function didn't throw");
-        }
-        function getTestNames(test) {
-            return {
-                filepath: test.testPath,
-                name: (0, src_utils.fN)(test)
-            };
-        }
-        const SnapshotPlugin = (chai, utils)=>{
-            function getTest(assertionName, obj) {
-                const test = utils.flag(obj, 'vitest-test');
-                if (!test) throw new Error(`'${assertionName}' cannot be used without test context`);
-                return test;
-            }
-            for (const key of [
-                'matchSnapshot',
-                'toMatchSnapshot'
-            ])utils.addMethod(chai.Assertion.prototype, key, function(properties, message) {
-                utils.flag(this, '_name', key);
-                const isNot = utils.flag(this, 'negate');
-                if (isNot) throw new Error(`${key} cannot be used with "not"`);
-                const expected = utils.flag(this, 'object');
-                const test = getTest(key, this);
-                if ('string' == typeof properties && void 0 === message) {
-                    message = properties;
-                    properties = void 0;
-                }
-                const errorMessage = utils.flag(this, 'message');
-                getSnapshotClient().assert({
-                    received: expected,
-                    message,
-                    isInline: false,
-                    properties,
-                    errorMessage,
-                    ...getTestNames(test)
-                });
-            });
-            utils.addMethod(chai.Assertion.prototype, 'toMatchFileSnapshot', function(file, message) {
-                utils.flag(this, '_name', 'toMatchFileSnapshot');
-                const isNot = utils.flag(this, 'negate');
-                if (isNot) throw new Error('toMatchFileSnapshot cannot be used with "not"');
-                const error = new Error('resolves');
-                const expected = utils.flag(this, 'object');
-                const test = getTest('toMatchFileSnapshot', this);
-                const errorMessage = utils.flag(this, 'message');
-                const promise = getSnapshotClient().assertRaw({
-                    received: expected,
-                    message,
-                    isInline: false,
-                    rawSnapshot: {
-                        file
-                    },
-                    errorMessage,
-                    ...getTestNames(test)
-                });
-                return recordAsyncExpect(test, promise, createAssertionMessage(utils, this, true), error);
-            });
-            utils.addMethod(chai.Assertion.prototype, 'toMatchInlineSnapshot', function __INLINE_SNAPSHOT__(properties, inlineSnapshot, message) {
-                utils.flag(this, '_name', 'toMatchInlineSnapshot');
-                const isNot = utils.flag(this, 'negate');
-                if (isNot) throw new Error('toMatchInlineSnapshot cannot be used with "not"');
-                const test = getTest('toMatchInlineSnapshot', this);
-                const isInsideEach = test.each || test.inTestEach;
-                if (isInsideEach) throw new Error('InlineSnapshot cannot be used inside of test.each or describe.each');
-                const expected = utils.flag(this, 'object');
-                const error = utils.flag(this, 'error');
-                if ('string' == typeof properties) {
-                    message = inlineSnapshot;
-                    inlineSnapshot = properties;
-                    properties = void 0;
-                }
-                if (inlineSnapshot) inlineSnapshot = (0, snapshot_dist.cN)(inlineSnapshot);
-                const errorMessage = utils.flag(this, 'message');
-                getSnapshotClient().assert({
-                    received: expected,
-                    message,
-                    isInline: true,
-                    properties,
-                    inlineSnapshot,
-                    error,
-                    errorMessage,
-                    ...getTestNames(test)
-                });
-            });
-            utils.addMethod(chai.Assertion.prototype, 'toThrowErrorMatchingSnapshot', function(message) {
-                utils.flag(this, '_name', 'toThrowErrorMatchingSnapshot');
-                const isNot = utils.flag(this, 'negate');
-                if (isNot) throw new Error('toThrowErrorMatchingSnapshot cannot be used with "not"');
-                const expected = utils.flag(this, 'object');
-                const test = getTest('toThrowErrorMatchingSnapshot', this);
-                const promise = utils.flag(this, 'promise');
-                const errorMessage = utils.flag(this, 'message');
-                getSnapshotClient().assert({
-                    received: getError(expected, promise),
-                    message,
-                    errorMessage,
-                    ...getTestNames(test)
-                });
-            });
-            utils.addMethod(chai.Assertion.prototype, 'toThrowErrorMatchingInlineSnapshot', function __INLINE_SNAPSHOT__(inlineSnapshot, message) {
-                const isNot = utils.flag(this, 'negate');
-                if (isNot) throw new Error('toThrowErrorMatchingInlineSnapshot cannot be used with "not"');
-                const test = getTest('toThrowErrorMatchingInlineSnapshot', this);
-                const isInsideEach = test.each || test.inTestEach;
-                if (isInsideEach) throw new Error('InlineSnapshot cannot be used inside of test.each or describe.each');
-                const expected = utils.flag(this, 'object');
-                const error = utils.flag(this, 'error');
-                const promise = utils.flag(this, 'promise');
-                const errorMessage = utils.flag(this, 'message');
-                if (inlineSnapshot) inlineSnapshot = (0, snapshot_dist.cN)(inlineSnapshot);
-                getSnapshotClient().assert({
-                    received: getError(expected, promise),
-                    message,
-                    inlineSnapshot,
-                    isInline: true,
-                    error,
-                    errorMessage,
-                    ...getTestNames(test)
-                });
-            });
-            utils.addMethod(chai.expect, 'addSnapshotSerializer', snapshot_dist.U$);
-        };
-        node_modules_chai.Yx(dist.Xs);
-        node_modules_chai.Yx(dist.dB);
-        node_modules_chai.Yx(SnapshotPlugin);
-        node_modules_chai.Yx(dist.Mc);
-        function createExpect({ getCurrentTest, workerState }) {
-            const expect = (value, message)=>{
-                const { assertionCalls } = (0, dist.Gu)(expect);
-                (0, dist.wb)({
-                    assertionCalls: assertionCalls + 1
-                }, expect);
-                const assert = node_modules_chai.E3(value, message);
-                const _test = getCurrentTest();
-                if (_test) return assert.withTest(_test);
-                return assert;
-            };
-            Object.assign(expect, node_modules_chai.E3);
-            Object.assign(expect, globalThis[dist.fs]);
-            expect.getState = ()=>(0, dist.Gu)(expect);
-            expect.setState = (state)=>(0, dist.wb)(state, expect);
-            const globalState = (0, dist.Gu)(globalThis[dist.mZ]) || {};
-            (0, dist.wb)({
-                ...globalState,
-                assertionCalls: 0,
-                isExpectingAssertions: false,
-                isExpectingAssertionsError: null,
-                expectedAssertionsNumber: null,
-                expectedAssertionsNumberErrorGen: null,
-                get testPath () {
-                    return workerState.testPath;
-                }
-            }, expect);
-            expect.extend = (matchers)=>node_modules_chai.E3.extend(expect, matchers);
-            expect.addEqualityTesters = (customTesters)=>(0, dist.TB)(customTesters);
-            expect.soft = (...args)=>expect(...args).withContext({
-                    soft: true
-                });
-            expect.poll = createExpectPoll(expect);
-            expect.unreachable = (message)=>{
-                node_modules_chai.vA.fail(`expected ${message ? `"${message}" ` : ''}not to be reached`);
-            };
-            function assertions(expected) {
-                const errorGen = ()=>new Error(`expected number of assertions to be ${expected}, but got ${expect.getState().assertionCalls}`);
-                if (Error.captureStackTrace) Error.captureStackTrace(errorGen(), assertions);
-                expect.setState({
-                    expectedAssertionsNumber: expected,
-                    expectedAssertionsNumberErrorGen: errorGen
-                });
-            }
-            function hasAssertions() {
-                const error = new Error('expected any number of assertion, but got none');
-                if (Error.captureStackTrace) Error.captureStackTrace(error, hasAssertions);
-                expect.setState({
-                    isExpectingAssertions: true,
-                    isExpectingAssertionsError: error
-                });
-            }
-            node_modules_chai.ZS.addMethod(expect, 'assertions', assertions);
-            node_modules_chai.ZS.addMethod(expect, 'hasAssertions', hasAssertions);
-            expect.extend(dist.Pf);
-            return expect;
-        }
-        const normalizeFixtures = (fixtures = {}, extendFixtures = {})=>{
-            const result = {};
-            for(const key in fixtures){
-                const fixtureOptionKeys = [
-                    'auto'
-                ];
-                const value = fixtures[key];
-                if (Array.isArray(value)) {
-                    if (1 === value.length && 'function' == typeof value[0]) {
-                        result[key] = {
-                            isFn: true,
-                            value: value[0]
-                        };
-                        continue;
-                    }
-                    if ((0, src_utils.Gv)(value[1]) && Object.keys(value[1]).some((key)=>fixtureOptionKeys.includes(key))) {
-                        result[key] = {
-                            isFn: 'function' == typeof value[0],
-                            value: value[0],
-                            options: value[1]
-                        };
-                        continue;
-                    }
-                }
-                result[key] = {
-                    isFn: 'function' == typeof value,
-                    value
-                };
-            }
-            const formattedResult = Object.fromEntries(Object.entries(result).map(([key, value])=>{
-                if (value.isFn) {
-                    const usedProps = getFixtureUsedProps(value.value);
-                    value.deps = usedProps.filter((p)=>p in result || p in extendFixtures);
-                }
-                return [
-                    key,
-                    value
-                ];
-            }));
-            return {
-                ...extendFixtures,
-                ...formattedResult
-            };
-        };
-        const handleFixtures = async (test, context)=>{
-            const cleanups = [];
-            if (!test.fixtures) return {
-                cleanups
-            };
-            const doneMap = new Set();
-            const pendingMap = new Set();
-            const usedKeys = test.originalFn ? getFixtureUsedProps(test.originalFn) : [];
-            const useFixture = async (name, NormalizedFixture)=>{
-                if (doneMap.has(name)) return;
-                if (pendingMap.has(name)) throw new Error(`Circular fixture dependency: ${name}`);
-                const { isFn, deps, value: fixtureValue } = NormalizedFixture;
-                if (!isFn) {
-                    context[name] = fixtureValue;
-                    doneMap.add(name);
-                    return;
-                }
-                pendingMap.add(name);
-                if (deps?.length) for (const dep of deps)await useFixture(dep, test.fixtures[dep]);
-                await new Promise((fixtureResolve)=>{
-                    let useDone;
-                    const block = fixtureValue(context, async (value)=>{
-                        context[name] = value;
-                        fixtureResolve();
-                        return new Promise((useFnResolve)=>{
-                            useDone = useFnResolve;
-                        });
-                    });
-                    cleanups.unshift(()=>{
-                        useDone?.();
-                        return block;
-                    });
-                });
-                doneMap.add(name);
-                pendingMap.delete(name);
-            };
-            for (const [name, params] of Object.entries(test.fixtures)){
-                const shouldAdd = params.options?.auto || usedKeys.includes(name);
-                if (shouldAdd) await useFixture(name, params);
-            }
-            return {
-                cleanups
-            };
-        };
-        function splitByComma(s) {
-            const result = [];
-            const stack = [];
-            let start = 0;
-            for(let i = 0; i < s.length; i++)if ('{' === s[i] || '[' === s[i]) stack.push('{' === s[i] ? '}' : ']');
-            else if (s[i] === stack[stack.length - 1]) stack.pop();
-            else if (!stack.length && ',' === s[i]) {
-                const token = s.substring(start, i).trim();
-                if (token) result.push(token);
-                start = i + 1;
-            }
-            const lastToken = s.substring(start).trim();
-            if (lastToken) result.push(lastToken);
-            return result;
-        }
-        function filterOutComments(s) {
-            const result = [];
-            let commentState = 'none';
-            for(let i = 0; i < s.length; ++i)if ('singleline' === commentState) {
-                if ('\n' === s[i]) commentState = 'none';
-            } else if ('multiline' === commentState) {
-                if ('*' === s[i - 1] && '/' === s[i]) commentState = 'none';
-            } else if ('none' === commentState) if ('/' === s[i] && '/' === s[i + 1]) commentState = 'singleline';
-            else if ('/' === s[i] && '*' === s[i + 1]) {
-                commentState = 'multiline';
-                i += 2;
-            } else result.push(s[i]);
-            return result.join('');
-        }
-        function getFixtureUsedProps(fn) {
-            const text = filterOutComments(fn.toString());
-            const match = text.match(/(?:async)?(?:\s+function)?[^(]*\(([^)]*)/);
-            if (!match) return [];
-            const trimmedParams = match[1].trim();
-            if (!trimmedParams) return [];
-            const [firstParam] = splitByComma(trimmedParams);
-            if (firstParam?.[0] !== '{' || '}' !== firstParam[firstParam.length - 1]) {
-                if (firstParam?.startsWith('_')) return [];
-                throw new Error(`First argument must use the object destructuring pattern: ${firstParam}`);
-            }
-            const props = splitByComma(firstParam.substring(1, firstParam.length - 1)).map((prop)=>{
-                const colon = prop.indexOf(':');
-                return -1 === colon ? prop.trim() : prop.substring(0, colon).trim();
-            });
-            const restProperty = props.find((prop)=>prop.startsWith('...'));
-            if (restProperty) throw new Error(`Rest property "${restProperty}" is not supported. List all used fixtures explicitly, separated by comma.`);
-            return props;
-        }
-        const getTestStatus = (results, defaultStatus)=>{
-            if (0 === results.length) return defaultStatus;
-            return results.some((result)=>'fail' === result.status) ? 'fail' : results.every((result)=>'todo' === result.status) ? 'todo' : results.every((result)=>'skip' === result.status) ? 'skip' : 'pass';
-        };
-        function hasOnlyTest(test) {
-            return test.some((t)=>'only' === t.runMode || 'suite' === t.type && hasOnlyTest(t.tests));
-        }
-        const shouldTestSkip = (test, runOnly, testNamePattern)=>{
-            if (runOnly && 'only' !== test.runMode) return true;
-            if (testNamePattern && !(0, src_utils.fN)(test, '').match(testNamePattern)) return true;
-            return false;
-        };
-        const traverseUpdateTestRunMode = (testSuite, parentRunMode, runOnly, testNamePattern)=>{
-            if (0 === testSuite.tests.length) return;
-            if (runOnly && 'only' !== testSuite.runMode && !hasOnlyTest(testSuite.tests)) testSuite.runMode = 'skip';
-            else if ([
-                'skip',
-                'todo'
-            ].includes(parentRunMode)) testSuite.runMode = parentRunMode;
-            const tests = testSuite.tests.map((test)=>{
-                const runSubOnly = runOnly && 'only' !== testSuite.runMode ? runOnly : hasOnlyTest(testSuite.tests);
-                if ('case' === test.type) {
-                    if ([
-                        'skip',
-                        'todo'
-                    ].includes(testSuite.runMode)) test.runMode = testSuite.runMode;
-                    if (shouldTestSkip(test, runSubOnly, testNamePattern)) test.runMode = 'skip';
-                    return test;
-                }
-                traverseUpdateTestRunMode(test, testSuite.runMode, runSubOnly, testNamePattern);
-                return test;
-            });
-            if ('run' !== testSuite.runMode) return;
-            const hasRunTest = tests.some((test)=>'run' === test.runMode || 'only' === test.runMode);
-            if (hasRunTest) {
-                testSuite.runMode = 'run';
-                return;
-            }
-            const allTodoTest = tests.every((test)=>'todo' === test.runMode);
-            testSuite.runMode = allTodoTest ? 'todo' : 'skip';
-        };
-        const updateTestModes = (tests, testNamePattern)=>{
-            const hasOnly = hasOnlyTest(tests);
-            for (const test of tests)if ('suite' === test.type) traverseUpdateTestRunMode(test, 'run', hasOnly, testNamePattern);
-            else if (shouldTestSkip(test, hasOnly, testNamePattern)) test.runMode = 'skip';
-        };
-        const updateTestParents = (tests, parentNames = [])=>{
-            for (const test of tests)if ('suite' === test.type) {
-                const names = test.name === src_utils.q_ ? parentNames : parentNames.concat(test.name);
-                updateTestParents(test.tests, names);
-            } else test.parentNames = parentNames;
-        };
-        const traverseUpdateTest = (tests, testNamePattern)=>{
-            updateTestParents(tests);
-            updateTestModes(tests, testNamePattern);
-        };
-        const markAllTestAsSkipped = (test)=>{
-            for (const t of test){
-                t.runMode = 'skip';
-                if ('suite' === t.type) markAllTestAsSkipped(t.tests);
-            }
-        };
-        function registerTestSuiteListener(suite, key, fn) {
-            const listenersKey = `${key}Listeners`;
-            suite[listenersKey] ??= [];
-            suite[listenersKey].push(fn);
-        }
-        function makeError(message, stackTraceError) {
-            const error = new Error(message);
-            if (stackTraceError?.stack) error.stack = stackTraceError.stack.replace(error.message, stackTraceError.message);
-            return error;
-        }
-        function wrapTimeout({ name, fn, timeout, stackTraceError }) {
-            if (!timeout) return fn;
-            return async (...args)=>{
-                let timeoutId;
-                const timeoutPromise = new Promise((_, reject)=>{
-                    timeoutId = (0, runtime_util.rZ)().setTimeout(()=>reject(makeError(`${name} timed out in ${timeout}ms`, stackTraceError)), timeout);
-                });
-                try {
-                    const result = await Promise.race([
-                        fn(...args),
-                        timeoutPromise
-                    ]);
-                    timeoutId && clearTimeout(timeoutId);
-                    return result;
-                } catch (error) {
-                    timeoutId && clearTimeout(timeoutId);
-                    throw error;
-                }
-            };
-        }
-        function limitConcurrency(concurrency = 1 / 0) {
-            let running = 0;
-            const queue = [];
-            const runNext = ()=>{
-                if (queue.length > 0 && running < concurrency) {
-                    running++;
-                    const next = queue.shift();
-                    next();
-                }
-            };
-            return (func, ...args)=>new Promise((resolve, reject)=>{
-                    const task = ()=>{
-                        Promise.resolve(func(...args)).then(resolve).catch(reject).finally(()=>{
-                            running--;
-                            runNext();
-                        });
-                    };
-                    if (running < concurrency) {
-                        running++;
-                        task();
-                    } else queue.push(task);
-                });
-        }
-        const RealDate = Date;
-        class TestRunner {
-            _test;
-            workerState;
-            async runTests({ tests, testPath, state, hooks, api }) {
-                this.workerState = state;
-                const { runtimeConfig: { passWithNoTests, retry, maxConcurrency }, project, snapshotOptions } = state;
-                const results = [];
-                const errors = [];
-                let defaultStatus = 'pass';
-                const snapshotClient = getSnapshotClient();
-                await snapshotClient.setup(testPath, snapshotOptions);
-                const runTestsCase = async (test, parentHooks)=>{
-                    if ('skip' === test.runMode) {
-                        snapshotClient.skipTest(testPath, (0, src_utils.fN)(test));
-                        const result = {
-                            status: 'skip',
-                            parentNames: test.parentNames,
-                            name: test.name,
-                            testPath,
-                            project
-                        };
-                        return result;
-                    }
-                    if ('todo' === test.runMode) {
-                        const result = {
-                            status: 'todo',
-                            parentNames: test.parentNames,
-                            name: test.name,
-                            testPath,
-                            project
-                        };
-                        return result;
-                    }
-                    let result;
-                    this.beforeEach(test, state, api);
-                    const cleanups = [];
-                    try {
-                        for (const fn of parentHooks.beforeEachListeners){
-                            const cleanupFn = await fn();
-                            cleanupFn && cleanups.push(cleanupFn);
-                        }
-                    } catch (error) {
-                        result = {
-                            status: 'fail',
-                            parentNames: test.parentNames,
-                            name: test.name,
-                            errors: (0, runtime_util.o9)(error, test),
-                            testPath,
-                            project
-                        };
-                    }
-                    if (result?.status !== 'fail') if (test.fails) try {
-                        const fixtureCleanups = await this.beforeRunTest(test, snapshotClient.getSnapshotState(testPath));
-                        cleanups.push(...fixtureCleanups);
-                        await test.fn?.(test.context);
-                        this.afterRunTest(test);
-                        result = {
-                            status: 'fail',
-                            parentNames: test.parentNames,
-                            name: test.name,
-                            testPath,
-                            project,
-                            errors: [
-                                {
-                                    message: 'Expect test to fail'
-                                }
-                            ]
-                        };
-                    } catch (_err) {
-                        result = {
-                            project,
-                            status: 'pass',
-                            parentNames: test.parentNames,
-                            name: test.name,
-                            testPath
-                        };
-                    }
-                    else try {
-                        const fixtureCleanups = await this.beforeRunTest(test, snapshotClient.getSnapshotState(testPath));
-                        cleanups.push(...fixtureCleanups);
-                        await test.fn?.(test.context);
-                        this.afterRunTest(test);
-                        result = {
-                            project,
-                            parentNames: test.parentNames,
-                            name: test.name,
-                            status: 'pass',
-                            testPath
-                        };
-                    } catch (error) {
-                        result = {
-                            project,
-                            status: 'fail',
-                            parentNames: test.parentNames,
-                            name: test.name,
-                            errors: (0, runtime_util.o9)(error, test),
-                            testPath
-                        };
-                    }
-                    const afterEachFns = [
-                        ...parentHooks.afterEachListeners || []
-                    ].reverse().concat(cleanups).concat(test.onFinished);
-                    try {
-                        for (const fn of afterEachFns)await fn({
-                            task: {
-                                result
-                            }
-                        });
-                    } catch (error) {
-                        result.status = 'fail';
-                        result.errors ??= [];
-                        result.errors.push(...(0, runtime_util.o9)(error));
-                    }
-                    if ('fail' === result.status) for (const fn of [
-                        ...test.onFailed
-                    ].reverse())try {
-                        await fn({
-                            task: {
-                                result
-                            }
-                        });
-                    } catch (error) {
-                        result.errors ??= [];
-                        result.errors.push(...(0, runtime_util.o9)(error));
-                    }
-                    this.resetCurrentTest();
-                    return result;
-                };
-                const limitMaxConcurrency = limitConcurrency(maxConcurrency);
-                const runTests = async (allTest, parentHooks)=>{
-                    const tests = [
-                        ...allTest
-                    ];
-                    while(tests.length){
-                        const suite = tests.shift();
-                        if (suite.concurrent) {
-                            const cases = [
-                                suite
-                            ];
-                            while(tests[0]?.concurrent)cases.push(tests.shift());
-                            await Promise.all(cases.map((test)=>{
-                                if ('suite' === test.type) return runTest(test, parentHooks);
-                                return limitMaxConcurrency(()=>runTest(test, parentHooks));
-                            }));
-                            continue;
-                        }
-                        await runTest(suite, parentHooks);
-                    }
-                };
-                const runTest = async (test, parentHooks)=>{
-                    if ('suite' === test.type) {
-                        if (0 === test.tests.length) {
-                            if ([
-                                'todo',
-                                'skip'
-                            ].includes(test.runMode)) {
-                                defaultStatus = 'skip';
-                                return;
-                            }
-                            if (passWithNoTests) return;
-                            const noTestError = {
-                                message: `No test found in suite: ${test.name}`,
-                                name: 'No tests'
-                            };
-                            errors.push(noTestError);
-                            const result = {
-                                status: 'fail',
-                                parentNames: test.parentNames,
-                                name: test.name,
-                                testPath,
-                                errors: [
-                                    noTestError
-                                ],
-                                project
-                            };
-                            hooks.onTestCaseResult?.(result);
-                        }
-                        const cleanups = [];
-                        let hasBeforeAllError = false;
-                        if ([
-                            'run',
-                            'only'
-                        ].includes(test.runMode) && test.beforeAllListeners) try {
-                            for (const fn of test.beforeAllListeners){
-                                const cleanupFn = await fn({
-                                    filepath: testPath
-                                });
-                                cleanupFn && cleanups.push(cleanupFn);
-                            }
-                        } catch (error) {
-                            hasBeforeAllError = true;
-                            errors.push(...(0, runtime_util.o9)(error));
-                        }
-                        if (hasBeforeAllError) markAllTestAsSkipped(test.tests);
-                        await runTests(test.tests, {
-                            beforeEachListeners: parentHooks.beforeEachListeners.concat(test.beforeEachListeners || []),
-                            afterEachListeners: parentHooks.afterEachListeners.concat(test.afterEachListeners || [])
-                        });
-                        const afterAllFns = [
-                            ...test.afterAllListeners || []
-                        ].reverse().concat(cleanups);
-                        if ([
-                            'run',
-                            'only'
-                        ].includes(test.runMode) && afterAllFns.length) try {
-                            for (const fn of afterAllFns)await fn({
-                                filepath: testPath
-                            });
-                        } catch (error) {
-                            errors.push(...(0, runtime_util.o9)(error));
-                        }
-                    } else {
-                        const start = RealDate.now();
-                        let result;
-                        let retryCount = 0;
-                        do {
-                            const currentResult = await runTestsCase(test, parentHooks);
-                            result = {
-                                ...currentResult,
-                                errors: 'fail' === currentResult.status && result && result.errors ? result.errors.concat(...currentResult.errors || []) : currentResult.errors
-                            };
-                            retryCount++;
-                        }while (retryCount <= retry && 'fail' === result.status);
-                        result.duration = RealDate.now() - start;
-                        result.retryCount = retryCount - 1;
-                        hooks.onTestCaseResult?.(result);
-                        results.push(result);
-                    }
-                };
-                const start = RealDate.now();
-                if (0 === tests.length) {
-                    if (passWithNoTests) return {
-                        project,
-                        testPath,
-                        name: '',
-                        status: 'pass',
-                        results
-                    };
-                    return {
-                        project,
-                        testPath,
-                        name: '',
-                        status: 'fail',
-                        results,
-                        errors: [
-                            {
-                                message: `No test suites found in file: ${testPath}`,
-                                name: 'No tests'
-                            }
-                        ]
-                    };
-                }
-                await runTests(tests, {
-                    beforeEachListeners: [],
-                    afterEachListeners: []
-                });
-                const snapshotResult = await snapshotClient.finish(testPath);
-                return {
-                    project,
-                    testPath,
-                    name: '',
-                    status: errors.length ? 'fail' : getTestStatus(results, defaultStatus),
-                    results,
-                    snapshotResult,
-                    errors,
-                    duration: RealDate.now() - start
-                };
-            }
-            resetCurrentTest() {
-                this._test = void 0;
-            }
-            setCurrentTest(test) {
-                this._test = test;
-            }
-            getCurrentTest() {
-                return this._test;
-            }
-            beforeEach(test, state, api) {
-                const { runtimeConfig: { clearMocks, resetMocks, restoreMocks, unstubEnvs, unstubGlobals } } = state;
-                this.setCurrentTest(test);
-                if (restoreMocks) api.rstest.restoreAllMocks();
-                else if (resetMocks) api.rstest.resetAllMocks();
-                else if (clearMocks) api.rstest.clearAllMocks();
-                if (unstubEnvs) api.rstest.unstubAllEnvs();
-                if (unstubGlobals) api.rstest.unstubAllGlobals();
-            }
-            createTestContext() {
-                const context = ()=>{
-                    throw new Error('done() callback is deprecated, use promise instead');
-                };
-                let _expect;
-                const current = this._test;
-                Object.defineProperty(context, 'expect', {
-                    get: ()=>{
-                        if (!_expect) _expect = createExpect({
-                            workerState: this.workerState,
-                            getCurrentTest: ()=>current
-                        });
-                        return _expect;
-                    }
-                });
-                Object.defineProperty(context, '_useLocalExpect', {
-                    get () {
-                        return null != _expect;
-                    }
-                });
-                Object.defineProperty(context, 'onTestFinished', {
-                    get: ()=>(fn, timeout)=>{
-                            this.onTestFinished(current, fn, timeout);
-                        }
-                });
-                Object.defineProperty(context, 'onTestFailed', {
-                    get: ()=>(fn, timeout)=>{
-                            this.onTestFailed(current, fn, timeout);
-                        }
-                });
-                return context;
-            }
-            onTestFinished(test, fn, timeout) {
-                if (!test) throw new Error('onTestFinished() can only be called inside a test');
-                test.onFinished.push(wrapTimeout({
-                    name: 'onTestFinished hook',
-                    fn,
-                    timeout: timeout || this.workerState.runtimeConfig.hookTimeout,
-                    stackTraceError: new Error('STACK_TRACE_ERROR')
-                }));
-            }
-            onTestFailed(test, fn, timeout) {
-                if (!test) throw new Error('onTestFailed() can only be called inside a test');
-                test.onFailed.push(wrapTimeout({
-                    name: 'onTestFailed hook',
-                    fn,
-                    timeout: timeout || this.workerState.runtimeConfig.hookTimeout,
-                    stackTraceError: new Error('STACK_TRACE_ERROR')
-                }));
-            }
-            async beforeRunTest(test, snapshotState) {
-                (0, dist.wb)({
-                    assertionCalls: 0,
-                    isExpectingAssertions: false,
-                    isExpectingAssertionsError: null,
-                    expectedAssertionsNumber: null,
-                    expectedAssertionsNumberErrorGen: null,
-                    testPath: test.testPath,
-                    snapshotState,
-                    currentTestName: (0, src_utils.fN)(test)
-                }, globalThis[dist.mZ]);
-                const context = this.createTestContext();
-                const { cleanups } = await handleFixtures(test, context);
-                Object.defineProperty(test, 'context', {
-                    value: context,
-                    enumerable: false
-                });
-                return cleanups;
-            }
-            afterRunTest(test) {
-                const expect = test.context._useLocalExpect ? test.context.expect : globalThis[dist.mZ];
-                const { assertionCalls, expectedAssertionsNumber, expectedAssertionsNumberErrorGen, isExpectingAssertions, isExpectingAssertionsError } = (0, dist.Gu)(expect);
-                if (test.result?.state === 'fail') throw test.result.errors;
-                if (null !== expectedAssertionsNumber && assertionCalls !== expectedAssertionsNumber) throw expectedAssertionsNumberErrorGen();
-                if (true === isExpectingAssertions && 0 === assertionCalls) throw isExpectingAssertionsError;
-            }
-        }
-        class RunnerRuntime {
-            tests = [];
-            _currentTest = [];
-            testPath;
-            status = 'collect';
-            collectStatus = 'lazy';
-            currentCollectList = [];
-            runtimeConfig;
-            project;
-            constructor({ testPath, runtimeConfig, project }){
-                this.project = project;
-                this.testPath = testPath;
-                this.runtimeConfig = runtimeConfig;
-            }
-            updateStatus(status) {
-                this.status = status;
-            }
-            checkStatus(name, type) {
-                if ('running' === this.status) {
-                    const error = new runtime_util.si(`${'case' === type ? 'Test' : 'Describe'} '${name}' cannot run`);
-                    throw error;
-                }
-            }
-            afterAll(fn, timeout = this.runtimeConfig.hookTimeout) {
-                const currentSuite = this.getCurrentSuite();
-                registerTestSuiteListener(currentSuite, 'afterAll', wrapTimeout({
-                    name: 'afterAll hook',
-                    fn,
-                    timeout,
-                    stackTraceError: new Error('STACK_TRACE_ERROR')
-                }));
-            }
-            beforeAll(fn, timeout = this.runtimeConfig.hookTimeout) {
-                const currentSuite = this.getCurrentSuite();
-                registerTestSuiteListener(currentSuite, 'beforeAll', wrapTimeout({
-                    name: 'beforeAll hook',
-                    fn,
-                    timeout,
-                    stackTraceError: new Error('STACK_TRACE_ERROR')
-                }));
-            }
-            afterEach(fn, timeout = this.runtimeConfig.hookTimeout) {
-                const currentSuite = this.getCurrentSuite();
-                registerTestSuiteListener(currentSuite, 'afterEach', wrapTimeout({
-                    name: 'afterEach hook',
-                    fn,
-                    timeout,
-                    stackTraceError: new Error('STACK_TRACE_ERROR')
-                }));
-            }
-            beforeEach(fn, timeout = this.runtimeConfig.hookTimeout) {
-                const currentSuite = this.getCurrentSuite();
-                registerTestSuiteListener(currentSuite, 'beforeEach', wrapTimeout({
-                    name: 'beforeEach hook',
-                    fn,
-                    timeout,
-                    stackTraceError: new Error('STACK_TRACE_ERROR')
-                }));
-            }
-            getDefaultRootSuite() {
-                return {
-                    project: this.project,
-                    runMode: 'run',
-                    testPath: this.testPath,
-                    name: src_utils.q_,
-                    tests: [],
-                    type: 'suite'
-                };
-            }
-            describe({ name, fn, runMode = 'run', each = false, concurrent, sequential }) {
-                this.checkStatus(name, 'suite');
-                const currentSuite = {
-                    project: this.project,
-                    name,
-                    runMode,
-                    tests: [],
-                    type: 'suite',
-                    each,
-                    testPath: this.testPath,
-                    concurrent,
-                    sequential
-                };
-                if (!fn) {
-                    this.addTest(currentSuite);
-                    this.resetCurrentTest();
-                    return;
-                }
-                this.collectStatus = 'lazy';
-                this.currentCollectList.push(async ()=>{
-                    this.addTest(currentSuite);
-                    const result = fn();
-                    if (result instanceof Promise) await result;
-                    await this.collectCurrentTest();
-                    this.resetCurrentTest();
-                });
-            }
-            resetCurrentTest() {
-                this._currentTest.pop();
-            }
-            addTest(test) {
-                if (0 === this._currentTest.length) this.tests.push(test);
-                else {
-                    const current = this._currentTest[this._currentTest.length - 1];
-                    if (current.each || current.inTestEach) test.inTestEach = true;
-                    if (current.concurrent && true !== test.sequential) test.concurrent = true;
-                    if (current.sequential && true !== test.concurrent) test.sequential = true;
-                    if ('case' === current.type) throw new Error('Calling the test function inside another test function is not allowed. Please put it inside "describe" so it can be properly collected.');
-                    current.tests.push(test);
-                }
-                this._currentTest.push(test);
-            }
-            async collectCurrentTest() {
-                const currentCollectList = this.currentCollectList;
-                this.currentCollectList = [];
-                while(currentCollectList.length > 0){
-                    this.collectStatus = 'running';
-                    const fn = currentCollectList.shift();
-                    await fn();
-                }
-            }
-            async getTests() {
-                while(this.currentCollectList.length > 0)await this.collectCurrentTest();
-                return this.tests;
-            }
-            addTestCase(test) {
-                if ('lazy' === this.collectStatus) this.currentCollectList.push(()=>{
-                    this.addTest({
-                        ...test,
-                        testPath: this.testPath,
-                        context: void 0
-                    });
-                    this.resetCurrentTest();
-                });
-                else {
-                    this.addTest({
-                        ...test,
-                        testPath: this.testPath,
-                        context: void 0
-                    });
-                    this.resetCurrentTest();
-                }
-            }
-            ensureRootSuite() {
-                if (0 === this._currentTest.length) this.addTest(this.getDefaultRootSuite());
-            }
-            it({ name, fn, originalFn = fn, fixtures, timeout = this.runtimeConfig.testTimeout, runMode = 'run', fails = false, each = false, concurrent, sequential }) {
-                this.checkStatus(name, 'case');
-                this.addTestCase({
-                    project: this.project,
-                    name,
-                    originalFn,
-                    fn: fn ? wrapTimeout({
-                        name: 'test',
-                        fn,
-                        timeout,
-                        stackTraceError: new Error('STACK_TRACE_ERROR')
-                    }) : fn,
-                    runMode,
-                    type: 'case',
-                    timeout,
-                    fixtures,
-                    concurrent,
-                    sequential,
-                    each,
-                    fails,
-                    onFinished: [],
-                    onFailed: []
-                });
-            }
-            describeEach({ cases, ...options }) {
-                return (name, fn)=>{
-                    for(let i = 0; i < cases.length; i++){
-                        const param = cases[i];
-                        const params = (0, src_utils.bg)(param);
-                        this.describe({
-                            name: (0, runtime_util.nD)(name, param, i),
-                            fn: ()=>fn?.(...params),
-                            ...options,
-                            each: true
-                        });
-                    }
-                };
-            }
-            describeFor({ cases, ...options }) {
-                return (name, fn)=>{
-                    for(let i = 0; i < cases.length; i++){
-                        const param = cases[i];
-                        this.describe({
-                            name: (0, runtime_util.nD)(name, param, i),
-                            fn: ()=>fn?.(param),
-                            ...options,
-                            each: true
-                        });
-                    }
-                };
-            }
-            each({ cases, ...options }) {
-                return (name, fn, timeout = this.runtimeConfig.testTimeout)=>{
-                    for(let i = 0; i < cases.length; i++){
-                        const param = cases[i];
-                        const params = (0, src_utils.bg)(param);
-                        this.it({
-                            name: (0, runtime_util.nD)(name, param, i),
-                            originalFn: fn,
-                            fn: ()=>fn?.(...params),
-                            timeout,
-                            ...options,
-                            each: true
-                        });
-                    }
-                };
-            }
-            for({ cases, ...options }) {
-                return (name, fn, timeout = this.runtimeConfig.testTimeout)=>{
-                    for(let i = 0; i < cases.length; i++){
-                        const param = cases[i];
-                        this.it({
-                            name: (0, runtime_util.nD)(name, param, i),
-                            originalFn: fn,
-                            fn: (context)=>fn?.(param, context),
-                            timeout,
-                            ...options,
-                            each: true
-                        });
-                    }
-                };
-            }
-            getCurrentSuite() {
-                this.ensureRootSuite();
-                for(let i = this._currentTest.length - 1; i >= 0; i--){
-                    const test = this._currentTest[i];
-                    if ('suite' === test.type) return test;
-                }
-                throw new Error('Expect to find a suite, but got undefined');
-            }
-        }
-        const createRuntimeAPI = ({ testPath, runtimeConfig, project })=>{
-            const runtimeInstance = new RunnerRuntime({
-                project,
-                testPath,
-                runtimeConfig
-            });
-            const createTestAPI = (options = {})=>{
-                const testFn = (name, fn, timeout)=>runtimeInstance.it({
-                        name,
-                        fn,
-                        timeout,
-                        ...options
-                    });
-                for (const { name, overrides } of [
-                    {
-                        name: 'fails',
-                        overrides: {
-                            fails: true
-                        }
-                    },
-                    {
-                        name: 'concurrent',
-                        overrides: {
-                            concurrent: true
-                        }
-                    },
-                    {
-                        name: 'sequential',
-                        overrides: {
-                            sequential: true
-                        }
-                    },
-                    {
-                        name: 'skip',
-                        overrides: {
-                            runMode: 'skip'
-                        }
-                    },
-                    {
-                        name: 'todo',
-                        overrides: {
-                            runMode: 'todo'
-                        }
-                    },
-                    {
-                        name: 'only',
-                        overrides: {
-                            runMode: 'only'
-                        }
-                    }
-                ])Object.defineProperty(testFn, name, {
-                    get: ()=>createTestAPI({
-                            ...options,
-                            ...overrides
-                        }),
-                    enumerable: true
-                });
-                testFn.runIf = (condition)=>condition ? testFn : testFn.skip;
-                testFn.skipIf = (condition)=>condition ? testFn.skip : testFn;
-                testFn.each = (cases)=>runtimeInstance.each({
-                        cases,
-                        ...options
-                    });
-                testFn.for = (cases)=>runtimeInstance.for({
-                        cases,
-                        ...options
-                    });
-                return testFn;
-            };
-            const it = createTestAPI();
-            it.extend = (fixtures)=>{
-                const extend = (fixtures, extendFixtures)=>{
-                    const normalizedFixtures = normalizeFixtures(fixtures, extendFixtures);
-                    const api = createTestAPI({
-                        fixtures: normalizedFixtures
-                    });
-                    api.extend = (subFixtures)=>extend(subFixtures, normalizedFixtures);
-                    return api;
-                };
-                return extend(fixtures);
-            };
-            const createDescribeAPI = (options = {})=>{
-                const describeFn = (name, fn)=>runtimeInstance.describe({
-                        name,
-                        fn,
-                        ...options
-                    });
-                for (const { name, overrides } of [
-                    {
-                        name: 'only',
-                        overrides: {
-                            runMode: 'only'
-                        }
-                    },
-                    {
-                        name: 'todo',
-                        overrides: {
-                            runMode: 'todo'
-                        }
-                    },
-                    {
-                        name: 'skip',
-                        overrides: {
-                            runMode: 'skip'
-                        }
-                    },
-                    {
-                        name: 'concurrent',
-                        overrides: {
-                            concurrent: true
-                        }
-                    },
-                    {
-                        name: 'sequential',
-                        overrides: {
-                            sequential: true
-                        }
-                    }
-                ])Object.defineProperty(describeFn, name, {
-                    get: ()=>createDescribeAPI({
-                            ...options,
-                            ...overrides
-                        }),
-                    enumerable: true
-                });
-                describeFn.skipIf = (condition)=>condition ? describeFn.skip : describeFn;
-                describeFn.runIf = (condition)=>condition ? describeFn : describeFn.skip;
-                describeFn.each = (cases)=>runtimeInstance.describeEach({
-                        cases,
-                        ...options
-                    });
-                describeFn.for = (cases)=>runtimeInstance.describeFor({
-                        cases,
-                        ...options
-                    });
-                return describeFn;
-            };
-            const describe = createDescribeAPI();
-            return {
-                api: {
-                    describe,
-                    it,
-                    test: it,
-                    afterAll: runtimeInstance.afterAll.bind(runtimeInstance),
-                    beforeAll: runtimeInstance.beforeAll.bind(runtimeInstance),
-                    afterEach: runtimeInstance.afterEach.bind(runtimeInstance),
-                    beforeEach: runtimeInstance.beforeEach.bind(runtimeInstance)
-                },
-                instance: runtimeInstance
-            };
-        };
-        function createRunner({ workerState }) {
-            const { testPath, project, runtimeConfig: { testNamePattern } } = workerState;
-            const runtime = createRuntimeAPI({
-                project,
-                testPath,
-                runtimeConfig: workerState.runtimeConfig
-            });
-            const testRunner = new TestRunner();
-            return {
-                api: {
-                    ...runtime.api,
-                    onTestFinished: (fn, timeout)=>{
-                        testRunner.onTestFinished(testRunner.getCurrentTest(), fn, timeout);
-                    },
-                    onTestFailed: (fn, timeout)=>{
-                        testRunner.onTestFailed(testRunner.getCurrentTest(), fn, timeout);
-                    }
-                },
-                runner: {
-                    runTests: async (testPath, hooks, api)=>{
-                        const tests = await runtime.instance.getTests();
-                        traverseUpdateTest(tests, testNamePattern);
-                        runtime.instance.updateStatus('running');
-                        const results = await testRunner.runTests({
-                            tests,
-                            testPath,
-                            state: workerState,
-                            hooks,
-                            api
-                        });
-                        return results;
-                    },
-                    collectTests: async ()=>{
-                        const tests = await runtime.instance.getTests();
-                        traverseUpdateTest(tests, testNamePattern);
-                        return tests;
-                    },
-                    getCurrentTest: ()=>testRunner.getCurrentTest()
-                }
-            };
-        }
-        var fake_timers_src = __webpack_require__("../../node_modules/.pnpm/@sinonjs+fake-timers@14.0.0/node_modules/@sinonjs/fake-timers/src/fake-timers-src.js");
-        const fakeTimers_RealDate = Date;
-        class FakeTimers {
-            _clock;
-            _config;
-            _fakingTime;
-            _fakeTimers;
-            constructor({ global, config = {} }){
-                this._config = config;
-                this._fakingTime = false;
-                this._fakeTimers = (0, fake_timers_src.withGlobal)(global);
-            }
-            clearAllTimers() {
-                if (this._fakingTime) this._clock.reset();
-            }
-            dispose() {
-                this.useRealTimers();
-            }
-            runAllTimers() {
-                if (this._checkFakeTimers()) this._clock.runAll();
-            }
-            async runAllTimersAsync() {
-                if (this._checkFakeTimers()) await this._clock.runAllAsync();
-            }
-            runOnlyPendingTimers() {
-                if (this._checkFakeTimers()) this._clock.runToLast();
-            }
-            async runOnlyPendingTimersAsync() {
-                if (this._checkFakeTimers()) await this._clock.runToLastAsync();
-            }
-            advanceTimersToNextTimer(steps = 1) {
-                if (this._checkFakeTimers()) for(let i = steps; i > 0; i--){
-                    this._clock.next();
-                    this._clock.tick(0);
-                    if (0 === this._clock.countTimers()) break;
-                }
-            }
-            async advanceTimersToNextTimerAsync(steps = 1) {
-                if (this._checkFakeTimers()) for(let i = steps; i > 0; i--){
-                    await this._clock.nextAsync();
-                    await this._clock.tickAsync(0);
-                    if (0 === this._clock.countTimers()) break;
-                }
-            }
-            advanceTimersByTime(msToRun) {
-                if (this._checkFakeTimers()) this._clock.tick(msToRun);
-            }
-            async advanceTimersByTimeAsync(msToRun) {
-                if (this._checkFakeTimers()) await this._clock.tickAsync(msToRun);
-            }
-            advanceTimersToNextFrame() {
-                if (this._checkFakeTimers()) this._clock.runToFrame();
-            }
-            runAllTicks() {
-                if (this._checkFakeTimers()) this._clock.runMicrotasks();
-            }
-            useRealTimers() {
-                if (this._fakingTime) {
-                    this._clock.uninstall();
-                    this._fakingTime = false;
-                }
-            }
-            useFakeTimers(fakeTimersConfig = {}) {
-                if (this._fakingTime) this._clock.uninstall();
-                const toFake = Object.keys(this._fakeTimers.timers).filter((timer)=>'nextTick' !== timer && 'queueMicrotask' !== timer);
-                const isChildProcess = 'undefined' != typeof process && !!process.send;
-                if (this._config?.toFake?.includes('nextTick') && isChildProcess) throw new Error('process.nextTick cannot be mocked inside child_process');
-                this._clock = this._fakeTimers.install({
-                    loopLimit: 10000,
-                    shouldClearNativeTimers: true,
-                    now: Date.now(),
-                    toFake: [
-                        ...toFake
-                    ],
-                    ignoreMissingTimers: true,
-                    ...fakeTimersConfig
-                });
-                this._fakingTime = true;
-            }
-            reset() {
-                if (this._checkFakeTimers()) {
-                    const { now } = this._clock;
-                    this._clock.reset();
-                    this._clock.setSystemTime(now);
-                }
-            }
-            setSystemTime(now) {
-                if (this._checkFakeTimers()) this._clock.setSystemTime(now);
-            }
-            getRealSystemTime() {
-                return fakeTimers_RealDate.now();
-            }
-            now() {
-                if (this._fakingTime) return this._clock.now;
-                return Date.now();
-            }
-            getTimerCount() {
-                if (this._checkFakeTimers()) return this._clock.countTimers();
-                return 0;
-            }
-            _checkFakeTimers() {
-                if (!this._fakingTime) throw new Error('Timers are not mocked. Try calling "rstest.useFakeTimers()" first.');
-                return this._fakingTime;
-            }
-            isFakeTimers() {
-                return this._fakingTime;
-            }
-        }
-        var tinyspy_dist = __webpack_require__("../../node_modules/.pnpm/tinyspy@4.0.4/node_modules/tinyspy/dist/index.js");
-        let callOrder = 0;
-        const mocks = new Set();
-        const wrapSpy = (obj, methodName, mockFn)=>{
-            const spyImpl = (0, tinyspy_dist.jo)(obj, methodName, mockFn);
-            const spyFn = spyImpl;
-            let mockImplementationOnce = [];
-            let implementation = mockFn;
-            let mockName = mockFn?.name;
-            const initMockState = ()=>({
-                    instances: [],
-                    contexts: [],
-                    invocationCallOrder: []
-                });
-            let mockState = initMockState();
-            const spyState = (0, tinyspy_dist.lf)(spyImpl);
-            spyFn.getMockName = ()=>mockName || methodName;
-            spyFn.mockName = (name)=>{
-                mockName = name;
-                return spyFn;
-            };
-            spyFn.getMockImplementation = ()=>mockImplementationOnce.length ? mockImplementationOnce[mockImplementationOnce.length - 1] : implementation;
-            function withImplementation(fn, cb) {
-                const originalImplementation = implementation;
-                const originalMockImplementationOnce = mockImplementationOnce;
-                implementation = fn;
-                mockImplementationOnce = [];
-                spyState.willCall(willCall);
-                const reset = ()=>{
-                    implementation = originalImplementation;
-                    mockImplementationOnce = originalMockImplementationOnce;
-                };
-                const result = cb();
-                if (result instanceof Promise) return result.then(()=>{
-                    reset();
-                });
-                reset();
-            }
-            spyFn.withImplementation = withImplementation;
-            spyFn.mockImplementation = (fn)=>{
-                implementation = fn;
-                return spyFn;
-            };
-            spyFn.mockImplementationOnce = (fn)=>{
-                mockImplementationOnce.push(fn);
-                return spyFn;
-            };
-            spyFn.mockReturnValue = (value)=>spyFn.mockImplementation(()=>value);
-            spyFn.mockReturnValueOnce = (value)=>spyFn.mockImplementationOnce(()=>value);
-            spyFn.mockResolvedValue = (value)=>spyFn.mockImplementation(()=>Promise.resolve(value));
-            spyFn.mockResolvedValueOnce = (value)=>spyFn.mockImplementationOnce(()=>Promise.resolve(value));
-            spyFn.mockRejectedValue = (value)=>spyFn.mockImplementation(()=>Promise.reject(value));
-            spyFn.mockRejectedValueOnce = (value)=>spyFn.mockImplementationOnce(()=>Promise.reject(value));
-            spyFn.mockReturnThis = ()=>spyFn.mockImplementation(function() {
-                    return this;
-                });
-            function willCall(...args) {
-                let impl = implementation || spyState.getOriginal();
-                mockState.instances.push(this);
-                mockState.contexts.push(this);
-                mockState.invocationCallOrder.push(++callOrder);
-                if (mockImplementationOnce.length) impl = mockImplementationOnce.shift();
-                return impl?.apply(this, args);
-            }
-            spyState.willCall(willCall);
-            Object.defineProperty(spyFn, 'mock', {
-                get: ()=>({
-                        get calls () {
-                            return spyState.calls;
-                        },
-                        get lastCall () {
-                            return spyState.calls[spyState.callCount - 1];
-                        },
-                        get instances () {
-                            return mockState.instances;
-                        },
-                        get contexts () {
-                            return mockState.contexts;
-                        },
-                        get invocationCallOrder () {
-                            return mockState.invocationCallOrder;
-                        },
-                        get results () {
-                            return spyState.results.map(([resultType, value])=>{
-                                const type = 'error' === resultType ? 'throw' : 'return';
-                                return {
-                                    type: type,
-                                    value
-                                };
-                            });
-                        },
-                        get settledResults () {
-                            return spyState.resolves.map(([resultType, value])=>{
-                                const type = 'error' === resultType ? 'rejected' : 'fulfilled';
-                                return {
-                                    type,
-                                    value
-                                };
-                            });
-                        }
-                    })
-            });
-            spyFn.mockClear = ()=>{
-                mockState = initMockState();
-                spyState.reset();
-                return spyFn;
-            };
-            spyFn.mockReset = ()=>{
-                spyFn.mockClear();
-                implementation = mockFn;
-                mockImplementationOnce = [];
-                return spyFn;
-            };
-            spyFn.mockRestore = ()=>{
-                spyFn.mockReset();
-                spyState.restore();
-                mockName = mockFn?.name;
-            };
-            mocks.add(spyFn);
-            return spyFn;
-        };
-        const spy_fn = (mockFn)=>{
-            const defaultName = 'rstest.fn()';
-            return wrapSpy({
-                [defaultName]: mockFn
-            }, defaultName, mockFn);
-        };
-        const spyOn = (obj, methodName, accessType)=>{
-            const accessTypeMap = {
-                get: 'getter',
-                set: 'setter'
-            };
-            const method = accessType ? {
-                [accessTypeMap[accessType]]: methodName
-            } : methodName;
-            return wrapSpy(obj, method);
-        };
-        const isMockFunction = (fn)=>'function' == typeof fn && '_isMockFunction' in fn && fn._isMockFunction;
-        const createRstestUtilities = (workerState)=>{
-            const originalEnvValues = new Map();
-            const originalGlobalValues = new Map();
-            let _timers;
-            let originalConfig;
-            const timers = ()=>{
-                if (!_timers) _timers = new FakeTimers({
-                    global: globalThis
-                });
-                return _timers;
-            };
-            const rstest = {
-                fn: spy_fn,
-                spyOn: spyOn,
-                isMockFunction: isMockFunction,
-                clearAllMocks: ()=>{
-                    for (const mock of mocks)mock.mockClear();
-                    return rstest;
-                },
-                resetAllMocks: ()=>{
-                    for (const mock of mocks)mock.mockReset();
-                    return rstest;
-                },
-                restoreAllMocks: ()=>{
-                    for (const mock of mocks)mock.mockRestore();
-                    return rstest;
-                },
-                mock: ()=>{},
-                mockRequire: ()=>{},
-                doMock: ()=>{},
-                doMockRequire: ()=>{},
-                unmock: ()=>{},
-                doUnmock: ()=>{},
-                importMock: async ()=>({}),
-                requireMock: ()=>({}),
-                importActual: async ()=>({}),
-                requireActual: ()=>({}),
-                resetModules: ()=>rstest,
-                setConfig: (config)=>{
-                    if (!originalConfig) originalConfig = {
-                        ...workerState.runtimeConfig
-                    };
-                    Object.assign(workerState.runtimeConfig, config);
-                },
-                resetConfig: ()=>{
-                    if (originalConfig) Object.assign(workerState.runtimeConfig, originalConfig);
-                },
-                stubEnv: (name, value)=>{
-                    if (!originalEnvValues.has(name)) originalEnvValues.set(name, process.env[name]);
-                    if (void 0 === value) delete process.env[name];
-                    else process.env[name] = value;
-                    return rstest;
-                },
-                unstubAllEnvs: ()=>{
-                    for (const [name, value] of originalEnvValues)if (void 0 === value) delete process.env[name];
-                    else process.env[name] = value;
-                    originalEnvValues.clear();
-                    return rstest;
-                },
-                stubGlobal: (name, value)=>{
-                    if (!originalGlobalValues.has(name)) originalGlobalValues.set(name, Object.getOwnPropertyDescriptor(globalThis, name));
-                    Object.defineProperty(globalThis, name, {
-                        value,
-                        writable: true,
-                        configurable: true,
-                        enumerable: true
-                    });
-                    return rstest;
-                },
-                unstubAllGlobals: ()=>{
-                    originalGlobalValues.forEach((original, name)=>{
-                        if (original) Object.defineProperty(globalThis, name, original);
-                        else Reflect.deleteProperty(globalThis, name);
-                    });
-                    originalGlobalValues.clear();
-                    return rstest;
-                },
-                useFakeTimers: (opts)=>{
-                    timers().useFakeTimers(opts);
-                    return rstest;
-                },
-                useRealTimers: ()=>{
-                    timers().useRealTimers();
-                    return rstest;
-                },
-                setSystemTime: (now)=>{
-                    timers().setSystemTime(now);
-                    return rstest;
-                },
-                getRealSystemTime: ()=>_timers ? timers().getRealSystemTime() : Date.now(),
-                isFakeTimers: ()=>_timers ? timers().isFakeTimers() : false,
-                runAllTimers: ()=>{
-                    timers().runAllTimers();
-                    return rstest;
-                },
-                runAllTimersAsync: async ()=>{
-                    await timers().runAllTimersAsync();
-                    return rstest;
-                },
-                runAllTicks: ()=>{
-                    timers().runAllTicks();
-                    return rstest;
-                },
-                runOnlyPendingTimers: ()=>{
-                    timers().runOnlyPendingTimers();
-                    return rstest;
-                },
-                runOnlyPendingTimersAsync: async ()=>{
-                    await timers().runOnlyPendingTimersAsync();
-                    return rstest;
-                },
-                advanceTimersByTime: (ms)=>{
-                    timers().advanceTimersByTime(ms);
-                    return rstest;
-                },
-                advanceTimersByTimeAsync: async (ms)=>{
-                    await timers().advanceTimersByTimeAsync(ms);
-                    return rstest;
-                },
-                advanceTimersToNextTimer: (steps)=>{
-                    timers().advanceTimersToNextTimer(steps);
-                    return rstest;
-                },
-                advanceTimersToNextTimerAsync: async (steps)=>{
-                    await timers().advanceTimersToNextTimerAsync(steps);
-                    return rstest;
-                },
-                advanceTimersToNextFrame: ()=>{
-                    timers().advanceTimersToNextFrame();
-                    return rstest;
-                },
-                getTimerCount: ()=>timers().getTimerCount(),
-                clearAllTimers: ()=>{
-                    timers().clearAllTimers();
-                    return rstest;
-                }
-            };
-            return rstest;
-        };
-        const createRstestRuntime = (workerState)=>{
-            const { runner, api: runnerAPI } = createRunner({
-                workerState
-            });
-            const expect = createExpect({
-                workerState,
-                getCurrentTest: ()=>runner.getCurrentTest()
-            });
-            Object.defineProperty(globalThis, dist.mZ, {
-                value: expect,
-                writable: true,
-                configurable: true
-            });
-            const rstest = createRstestUtilities(workerState);
-            const runtime = {
-                runner,
-                api: {
-                    ...runnerAPI,
-                    expect,
-                    assert: node_modules_chai.vA,
-                    rstest,
-                    rs: rstest
-                }
-            };
-            globalThis.RSTEST_API = runtime.api;
-            return runtime;
-        };
-    }
-};