@rstest/core 0.7.9 → 0.8.1

package/dist/browser-runtime/389.js

@@ -7378,6 +7378,104 @@ __webpack_require__.add({
             return number < 0 ? -1 : 1;
         };
     },
+    "../../node_modules/.pnpm/os-browserify@0.3.0/node_modules/os-browserify/browser.js" (__unused_rspack_module, exports) {
+        exports.endianness = function() {
+            return 'LE';
+        };
+        exports.hostname = function() {
+            if ("u" > typeof location) return location.hostname;
+            return '';
+        };
+        exports.loadavg = function() {
+            return [];
+        };
+        exports.uptime = function() {
+            return 0;
+        };
+        exports.freemem = function() {
+            return Number.MAX_VALUE;
+        };
+        exports.totalmem = function() {
+            return Number.MAX_VALUE;
+        };
+        exports.cpus = function() {
+            return [];
+        };
+        exports.type = function() {
+            return 'Browser';
+        };
+        exports.release = function() {
+            if ("u" > typeof navigator) return navigator.appVersion;
+            return '';
+        };
+        exports.networkInterfaces = exports.getNetworkInterfaces = function() {
+            return {};
+        };
+        exports.arch = function() {
+            return "javascript";
+        };
+        exports.platform = function() {
+            return 'browser';
+        };
+        exports.tmpdir = exports.tmpDir = function() {
+            return '/tmp';
+        };
+        exports.EOL = '\n';
+        exports.homedir = function() {
+            return '/';
+        };
+    },
+    "../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.browser.js" (module) {
+        var x = String;
+        var create = function() {
+            return {
+                isColorSupported: false,
+                reset: x,
+                bold: x,
+                dim: x,
+                italic: x,
+                underline: x,
+                inverse: x,
+                hidden: x,
+                strikethrough: x,
+                black: x,
+                red: x,
+                green: x,
+                yellow: x,
+                blue: x,
+                magenta: x,
+                cyan: x,
+                white: x,
+                gray: x,
+                bgBlack: x,
+                bgRed: x,
+                bgGreen: x,
+                bgYellow: x,
+                bgBlue: x,
+                bgMagenta: x,
+                bgCyan: x,
+                bgWhite: x,
+                blackBright: x,
+                redBright: x,
+                greenBright: x,
+                yellowBright: x,
+                blueBright: x,
+                magentaBright: x,
+                cyanBright: x,
+                whiteBright: x,
+                bgBlackBright: x,
+                bgRedBright: x,
+                bgGreenBright: x,
+                bgYellowBright: x,
+                bgBlueBright: x,
+                bgMagentaBright: x,
+                bgCyanBright: x,
+                bgWhiteBright: x
+            };
+        };
+        module.exports = create();
+        module.exports.createColors = create;
+    },
     "../../node_modules/.pnpm/possible-typed-array-names@1.1.0/node_modules/possible-typed-array-names/index.js" (module) {
         module.exports = [
             'Float16Array',
@@ -8701,6 +8799,19 @@ __webpack_require__.add({
         exports.setImmediate = "u" > typeof self && self.setImmediate || void 0 !== __webpack_require__.g && __webpack_require__.g.setImmediate || this && this.setImmediate;
         exports.clearImmediate = "u" > typeof self && self.clearImmediate || void 0 !== __webpack_require__.g && __webpack_require__.g.clearImmediate || this && this.clearImmediate;
     },
+    "../../node_modules/.pnpm/tty-browserify@0.0.1/node_modules/tty-browserify/index.js" (__unused_rspack_module, exports) {
+        exports.isatty = function() {
+            return false;
+        };
+        function ReadStream() {
+            throw new Error('tty.ReadStream is not implemented');
+        }
+        exports.ReadStream = ReadStream;
+        function WriteStream() {
+            throw new Error('tty.WriteStream is not implemented');
+        }
+        exports.WriteStream = WriteStream;
+    },
     "../../node_modules/.pnpm/type-detect@4.0.8/node_modules/type-detect/type-detect.js" (module, __unused_rspack_exports, __webpack_require__) {
         (function(global, factory) {
             module.exports = factory();
@@ -17760,6 +17871,302 @@ const JestExtend = (chai, utils)=>{
         use(JestExtendPlugin(chai, expect, expects));
     });
 };
+const browser = __webpack_require__("../../node_modules/.pnpm/process@0.11.10/node_modules/process/browser.js");
+const browser_0 = __webpack_require__("../../node_modules/.pnpm/os-browserify@0.3.0/node_modules/os-browserify/browser.js");
+const tty_browserify = __webpack_require__("../../node_modules/.pnpm/tty-browserify@0.0.1/node_modules/tty-browserify/index.js");
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : browser.argv) {
+    const prefix = flag.startsWith('-') ? '' : 1 === flag.length ? '-' : '--';
+    const position = argv.indexOf(prefix + flag);
+    const terminatorPosition = argv.indexOf('--');
+    return -1 !== position && (-1 === terminatorPosition || position < terminatorPosition);
+}
+const { env: env } = browser;
+let flagForceColor;
+if (hasFlag('no-color') || hasFlag('no-colors') || hasFlag('color=false') || hasFlag('color=never')) flagForceColor = 0;
+else if (hasFlag('color') || hasFlag('colors') || hasFlag('color=true') || hasFlag('color=always')) flagForceColor = 1;
+function envForceColor() {
+    if (!('FORCE_COLOR' in env)) return;
+    if ('true' === env.FORCE_COLOR) return 1;
+    if ('false' === env.FORCE_COLOR) return 0;
+    if (0 === env.FORCE_COLOR.length) return 1;
+    const level = Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+    if (![
+        0,
+        1,
+        2,
+        3
+    ].includes(level)) return;
+    return level;
+}
+function translateLevel(level) {
+    if (0 === level) return false;
+    return {
+        level,
+        hasBasic: true,
+        has256: level >= 2,
+        has16m: level >= 3
+    };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+    const noFlagForceColor = envForceColor();
+    if (void 0 !== noFlagForceColor) flagForceColor = noFlagForceColor;
+    const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+    if (0 === forceColor) return 0;
+    if (sniffFlags) {
+        if (hasFlag('color=16m') || hasFlag('color=full') || hasFlag('color=truecolor')) return 3;
+        if (hasFlag('color=256')) return 2;
+    }
+    if ('TF_BUILD' in env && 'AGENT_NAME' in env) return 1;
+    if (haveStream && !streamIsTTY && void 0 === forceColor) return 0;
+    const min = forceColor || 0;
+    if ('dumb' === env.TERM) return min;
+    if ('win32' === browser.platform) {
+        const osRelease = browser_0.release().split('.');
+        if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) return Number(osRelease[2]) >= 14931 ? 3 : 2;
+        return 1;
+    }
+    if ('CI' in env) {
+        if ([
+            'GITHUB_ACTIONS',
+            'GITEA_ACTIONS',
+            'CIRCLECI'
+        ].some((key)=>key in env)) return 3;
+        if ([
+            'TRAVIS',
+            'APPVEYOR',
+            'GITLAB_CI',
+            'BUILDKITE',
+            'DRONE'
+        ].some((sign)=>sign in env) || 'codeship' === env.CI_NAME) return 1;
+        return min;
+    }
+    if ('TEAMCITY_VERSION' in env) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+    if ('truecolor' === env.COLORTERM) return 3;
+    if ('xterm-kitty' === env.TERM) return 3;
+    if ('xterm-ghostty' === env.TERM) return 3;
+    if ('wezterm' === env.TERM) return 3;
+    if ('TERM_PROGRAM' in env) {
+        const version = Number.parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+        switch(env.TERM_PROGRAM){
+            case 'iTerm.app':
+                return version >= 3 ? 3 : 2;
+            case 'Apple_Terminal':
+                return 2;
+        }
+    }
+    if (/-256(color)?$/i.test(env.TERM)) return 2;
+    if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) return 1;
+    if ('COLORTERM' in env) return 1;
+    return min;
+}
+function createSupportsColor(stream, options = {}) {
+    const level = _supportsColor(stream, {
+        streamIsTTY: stream && stream.isTTY,
+        ...options
+    });
+    return translateLevel(level);
+}
+const supportsColor = {
+    stdout: createSupportsColor({
+        isTTY: tty_browserify.isatty(1)
+    }),
+    stderr: createSupportsColor({
+        isTTY: tty_browserify.isatty(2)
+    })
+};
+const supports_color = supportsColor;
+const colorLevel = supports_color.stdout ? supports_color.stdout.level : 0;
+let errorStackRegExp = /at [^\r\n]{0,200}:\d+:\d+[\s\)]*$/;
+let anonymousErrorStackRegExp = /at [^\r\n]{0,200}\(<anonymous>\)$/;
+let indexErrorStackRegExp = /at [^\r\n]{0,200}\(index\s\d+\)$/;
+let isErrorStackMessage = (message)=>errorStackRegExp.test(message) || anonymousErrorStackRegExp.test(message) || indexErrorStackRegExp.test(message);
+let formatter = (open, close, replace = open)=>colorLevel >= 2 ? (input)=>{
+        let string = '' + input;
+        let index = string.indexOf(close, open.length);
+        return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    } : String;
+let replaceClose = (string, close, replace, index)=>{
+    let start = string.substring(0, index) + replace;
+    let end = string.substring(index + close.length);
+    let nextIndex = end.indexOf(close);
+    return ~nextIndex ? start + replaceClose(end, close, replace, nextIndex) : start + end;
+};
+const bold = formatter('\x1b[1m', '\x1b[22m', '\x1b[22m\x1b[1m');
+const red = formatter('\x1b[31m', '\x1b[39m');
+const green = formatter('\x1b[32m', '\x1b[39m');
+const yellow = formatter('\x1b[33m', '\x1b[39m');
+const magenta = formatter('\x1b[35m', '\x1b[39m');
+const cyan = formatter('\x1b[36m', '\x1b[39m');
+const gray = formatter('\x1b[90m', '\x1b[39m');
+let startColor = [
+    189,
+    255,
+    243
+];
+let endColor = [
+    74,
+    194,
+    154
+];
+let isWord = (char)=>!/[\s\n]/.test(char);
+let gradient = (message)=>{
+    if (colorLevel < 3) return 2 === colorLevel ? bold(cyan(message)) : message;
+    let chars = [
+        ...message
+    ];
+    let steps = chars.filter(isWord).length;
+    let r = startColor[0];
+    let g = startColor[1];
+    let b = startColor[2];
+    let rStep = (endColor[0] - r) / steps;
+    let gStep = (endColor[1] - g) / steps;
+    let bStep = (endColor[2] - b) / steps;
+    let output = '';
+    for (let char of chars){
+        if (isWord(char)) {
+            r += rStep;
+            g += gStep;
+            b += bStep;
+        }
+        output += `\x1b[38;2;${Math.round(r)};${Math.round(g)};${Math.round(b)}m${char}\x1b[39m`;
+    }
+    return bold(output);
+};
+let LOG_LEVEL = {
+    silent: -1,
+    error: 0,
+    warn: 1,
+    info: 2,
+    log: 2,
+    verbose: 3
+};
+let LOG_TYPES = {
+    error: {
+        label: 'error',
+        level: 'error',
+        color: red
+    },
+    warn: {
+        label: 'warn',
+        level: 'warn',
+        color: yellow
+    },
+    info: {
+        label: 'info',
+        level: 'info',
+        color: cyan
+    },
+    start: {
+        label: 'start',
+        level: 'info',
+        color: cyan
+    },
+    ready: {
+        label: 'ready',
+        level: 'info',
+        color: green
+    },
+    success: {
+        label: 'success',
+        level: 'info',
+        color: green
+    },
+    log: {
+        level: 'info'
+    },
+    debug: {
+        label: 'debug',
+        level: 'verbose',
+        color: magenta
+    }
+};
+const dist_normalizeErrorMessage = (err)=>{
+    if (err.stack) {
+        let [name, ...rest] = err.stack.split('\n');
+        if (name.startsWith('Error: ')) name = name.slice(7);
+        return `${name}\n${gray(rest.join('\n'))}`;
+    }
+    return err.message;
+};
+let createLogger = (options = {})=>{
+    let maxLevel = options.level || 'info';
+    let log = (type, message, ...args)=>{
+        let logType = LOG_TYPES[type];
+        const { level } = logType;
+        if (LOG_LEVEL[level] > LOG_LEVEL[maxLevel]) return;
+        if (null == message) return console.log();
+        let label = '';
+        let text = '';
+        if ('label' in logType) {
+            label = (logType.label || '').padEnd(7);
+            label = bold(logType.color ? logType.color(label) : label);
+        }
+        if (message instanceof Error) {
+            text += dist_normalizeErrorMessage(message);
+            const { cause } = message;
+            if (cause) {
+                text += yellow('\n  [cause]: ');
+                text += cause instanceof Error ? dist_normalizeErrorMessage(cause) : String(cause);
+            }
+        } else if ('error' === level && 'string' == typeof message) {
+            let lines = message.split('\n');
+            text = lines.map((line)=>isErrorStackMessage(line) ? gray(line) : line).join('\n');
+        } else text = `${message}`;
+        const method = 'error' === level || 'warn' === level ? level : 'log';
+        console[method](label.length ? `${label} ${text}` : text, ...args);
+    };
+    let logger = {
+        greet: (message)=>log('log', gradient(message))
+    };
+    Object.keys(LOG_TYPES).forEach((key)=>{
+        logger[key] = (...args)=>log(key, ...args);
+    });
+    Object.defineProperty(logger, 'level', {
+        get: ()=>maxLevel,
+        set (val) {
+            maxLevel = val;
+        }
+    });
+    logger.override = (customLogger)=>{
+        Object.assign(logger, customLogger);
+    };
+    return logger;
+};
+let src_logger = createLogger();
+const picocolors_browser = __webpack_require__("../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.browser.js");
+var logger_process = __webpack_require__("../../node_modules/.pnpm/process@0.11.10/node_modules/process/browser.js");
+const isDebug = ()=>{
+    if (!logger_process.env.DEBUG) return false;
+    const values = logger_process.env.DEBUG.toLocaleLowerCase().split(',');
+    return [
+        'rstest',
+        'rsbuild',
+        'builder',
+        '*'
+    ].some((key)=>values.includes(key));
+};
+const logger_color = (0, picocolors_browser.createColors)();
+if (isDebug()) src_logger.level = 'verbose';
+function getTime() {
+    const now = new Date();
+    const hours = String(now.getHours()).padStart(2, '0');
+    const minutes = String(now.getMinutes()).padStart(2, '0');
+    const seconds = String(now.getSeconds()).padStart(2, '0');
+    return `${hours}:${minutes}:${seconds}`;
+}
+src_logger.override({
+    debug: (message, ...args)=>{
+        if ('verbose' !== src_logger.level) return;
+        const time = logger_color.gray(getTime());
+        console.log(`  ${logger_color.magenta('rstest')} ${time} ${message}`, ...args);
+    }
+});
+({
+    ...src_logger,
+    stderr: (message, ...args)=>{
+        console.error(message, ...args);
+    }
+});
 var helper_process = __webpack_require__("../../node_modules/.pnpm/process@0.11.10/node_modules/process/browser.js");
 const helper_isObject = (obj)=>'[object Object]' === Object.prototype.toString.call(obj);
 const castArray = (arr)=>{
@@ -18079,11 +18486,11 @@ const pathe_M_eThtNZ_isAbsolute = function(p) {
 };
 var snapshot_dist_process = __webpack_require__("../../node_modules/.pnpm/process@0.11.10/node_modules/process/browser.js");
 const comma = ','.charCodeAt(0);
-const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const dist_chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
 const intToChar = new Uint8Array(64);
 const charToInt = new Uint8Array(128);
-for(let i = 0; i < chars.length; i++){
-    const c = chars.charCodeAt(i);
+for(let i = 0; i < dist_chars.length; i++){
+    const c = dist_chars.charCodeAt(i);
     intToChar[i] = c;
     charToInt[c] = i;
 }
@@ -18589,10 +18996,10 @@ function parseSingleV8Stack(raw) {
     if (!CHROME_IE_STACK_REGEXP.test(line)) return null;
     if (line.includes("(eval ")) line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(,.*$)/g, "");
     let sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, "");
-    const location = sanitizedLine.match(/ (\(.+\)$)/);
-    sanitizedLine = location ? sanitizedLine.replace(location[0], "") : sanitizedLine;
-    const [url, lineNumber, columnNumber] = extractLocation(location ? location[1] : sanitizedLine);
-    let method = location && sanitizedLine || "";
+    const location1 = sanitizedLine.match(/ (\(.+\)$)/);
+    sanitizedLine = location1 ? sanitizedLine.replace(location1[0], "") : sanitizedLine;
+    const [url, lineNumber, columnNumber] = extractLocation(location1 ? location1[1] : sanitizedLine);
+    let method = location1 && sanitizedLine || "";
     let file = url && [
         "eval",
         "<anonymous>"
@@ -21151,7 +21558,7 @@ class RunnerRuntime {
             type: 'suite'
         };
     }
-    describe({ name, fn, runMode = 'run', each = false, concurrent, sequential, location }) {
+    describe({ name, fn, runMode = 'run', each = false, concurrent, sequential, location: location1 }) {
         this.checkStatus(name, 'suite');
         const currentSuite = {
             project: this.project,
@@ -21163,7 +21570,7 @@ class RunnerRuntime {
             testPath: this.testPath,
             concurrent,
             sequential,
-            location
+            location: location1
         };
         if (!fn) {
             this.addTest(currentSuite);
@@ -21232,7 +21639,7 @@ class RunnerRuntime {
     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, location }) {
+    it({ name, fn, originalFn = fn, fixtures, timeout = this.runtimeConfig.testTimeout, runMode = 'run', fails = false, each = false, concurrent, sequential, location: location1 }) {
         this.checkStatus(name, 'case');
         this.addTestCase({
             project: this.project,
@@ -21250,7 +21657,7 @@ class RunnerRuntime {
             fails,
             onFinished: [],
             onFailed: [],
-            location
+            location: location1
         });
     }
     describeEach({ cases, ...options }) {
@@ -21705,6 +22112,152 @@ class FakeTimers {
         this._fakeTimers = (0, fake_timers_src.withGlobal)(global);
     }
 }
+function getTypeName(value) {
+    return Object.prototype.toString.call(value).slice(8, -1);
+}
+function mockObject_isPlainObject(value) {
+    if (!value || 'object' != typeof value) return false;
+    const type = getTypeName(value);
+    return 'Object' === type || 'Module' === type;
+}
+function isFunction(value) {
+    return 'function' == typeof value;
+}
+function isBuiltinReadonly(target, prop) {
+    const builtinFunctionProps = [
+        'arguments',
+        'callee',
+        'caller',
+        'length',
+        'name'
+    ];
+    const builtinRegExpProps = [
+        'source',
+        'global',
+        'flags'
+    ];
+    const type = getTypeName(target);
+    if (builtinFunctionProps.includes(prop)) return 'Function' === type || 'AsyncFunction' === type;
+    if (builtinRegExpProps.includes(prop)) return 'RegExp' === type;
+    return false;
+}
+function collectPrototypeMethods(proto) {
+    const methods = [];
+    let current = proto;
+    while(current && current !== Object.prototype){
+        for (const key of [
+            ...Object.getOwnPropertyNames(current),
+            ...Object.getOwnPropertySymbols(current)
+        ]){
+            if ('constructor' === key) continue;
+            const descriptor = Object.getOwnPropertyDescriptor(current, key);
+            if (descriptor?.value && 'function' == typeof descriptor.value) methods.push(key);
+        }
+        current = Object.getPrototypeOf(current);
+    }
+    return methods;
+}
+function getEnumerableProperties(obj, constructors) {
+    const props = new Set();
+    const isModule = 'Module' === getTypeName(obj) || obj.__esModule;
+    if (isModule) {
+        for (const k of Object.getOwnPropertyNames(obj))props.add(k);
+        for (const k of Object.getOwnPropertySymbols(obj))props.add(k);
+        return [
+            ...props
+        ];
+    }
+    const builtinPrototypes = [
+        constructors.Object.prototype,
+        constructors.Function.prototype,
+        constructors.Array.prototype,
+        constructors.Map.prototype,
+        constructors.RegExp.prototype
+    ];
+    let current = obj;
+    while(current && !builtinPrototypes.includes(current)){
+        for (const key of [
+            ...Object.getOwnPropertyNames(current),
+            ...Object.getOwnPropertySymbols(current)
+        ])if ('constructor' !== key) props.add(key);
+        current = Object.getPrototypeOf(current);
+    }
+    return [
+        ...props
+    ];
+}
+function mockObject(options, object, mockExports = {}) {
+    const { createMockInstance, globalConstructors, type } = options;
+    const isSpyMode = 'autospy' === type;
+    const processedRefs = new WeakMap();
+    const deferredAssignments = [];
+    const createFunctionMock = (fn)=>{
+        const prototypeMembers = fn.prototype ? collectPrototypeMethods(fn.prototype) : [];
+        return createMockInstance({
+            name: fn.name,
+            prototypeMembers,
+            originalImplementation: isSpyMode ? fn : void 0,
+            keepMembersImplementation: isSpyMode
+        });
+    };
+    const processValue = (value)=>{
+        if (null == value) return value;
+        if ('object' != typeof value && 'function' != typeof value) return value;
+        if (value._isMockFunction) return value;
+        if ('object' == typeof value && processedRefs.has(value)) return processedRefs.get(value);
+        if (isFunction(value)) {
+            const mock = createFunctionMock(value);
+            processProperties(value, mock);
+            return mock;
+        }
+        if (Array.isArray(value)) {
+            if (!isSpyMode) return [];
+            return value.map(processValue);
+        }
+        if (mockObject_isPlainObject(value)) {
+            const result = {};
+            processedRefs.set(value, result);
+            processProperties(value, result);
+            return result;
+        }
+        return value;
+    };
+    const processProperties = (source, target)=>{
+        const props = getEnumerableProperties(source, globalConstructors);
+        const isModule = 'Module' === getTypeName(source) || source.__esModule;
+        for (const prop of props){
+            if (isBuiltinReadonly(source, prop)) continue;
+            const descriptor = Object.getOwnPropertyDescriptor(source, prop);
+            if (!descriptor) continue;
+            if (!isModule && descriptor.get) {
+                try {
+                    if (isSpyMode) Object.defineProperty(target, prop, descriptor);
+                    else Object.defineProperty(target, prop, {
+                        configurable: descriptor.configurable,
+                        enumerable: descriptor.enumerable,
+                        get: ()=>void 0,
+                        set: descriptor.set ? ()=>{} : void 0
+                    });
+                } catch  {}
+                continue;
+            }
+            const value = source[prop];
+            if (value && 'object' == typeof value && processedRefs.has(value)) {
+                deferredAssignments.push(()=>{
+                    target[prop] = processedRefs.get(value);
+                });
+                continue;
+            }
+            try {
+                target[prop] = processValue(value);
+            } catch  {}
+        }
+    };
+    processedRefs.set(object, mockExports);
+    processProperties(object, mockExports);
+    for (const assign of deferredAssignments)assign();
+    return mockExports;
+}
 const spy_isMockFunction = (fn)=>'function' == typeof fn && '_isMockFunction' in fn && fn._isMockFunction;
 const initSpy = ()=>{
     let callOrder = 0;
@@ -21843,11 +22396,46 @@ const initSpy = ()=>{
         } : methodName;
         return wrapSpy(obj, method);
     };
+    const createMockInstance = (options)=>{
+        const { name, originalImplementation, prototypeMembers = [], keepMembersImplementation = false } = options || {};
+        const mockName = name ? String(name) : 'rstest.fn()';
+        const isClass = originalImplementation && /^class\s/.test(Function.prototype.toString.call(originalImplementation));
+        if (isClass && originalImplementation) {
+            const classWrapper = function(...args) {
+                const instance = Reflect.construct(originalImplementation, args, new.target || originalImplementation);
+                if (keepMembersImplementation && prototypeMembers.length > 0) for (const memberName of prototypeMembers){
+                    const originalMethod = instance[memberName];
+                    if ('function' == typeof originalMethod) {
+                        const methodSpy = wrapSpy(instance, memberName, originalMethod.bind(instance));
+                        instance[memberName] = methodSpy;
+                    }
+                }
+                return instance;
+            };
+            Object.defineProperty(classWrapper, 'name', {
+                value: mockName,
+                configurable: true
+            });
+            classWrapper.prototype = originalImplementation.prototype;
+            const mock = wrapSpy({
+                [mockName]: classWrapper
+            }, mockName, classWrapper);
+            Object.setPrototypeOf(mock, Function.prototype);
+            mock.prototype = originalImplementation.prototype;
+            return mock;
+        }
+        const mock = wrapSpy({
+            [mockName]: originalImplementation
+        }, mockName, originalImplementation);
+        if (prototypeMembers.length > 0 && originalImplementation?.prototype) Object.setPrototypeOf(mock.prototype, originalImplementation.prototype);
+        return mock;
+    };
     return {
         isMockFunction: spy_isMockFunction,
         spyOn,
         fn,
-        mocks
+        mocks,
+        createMockInstance
     };
 };
 var utilities_process = __webpack_require__("../../node_modules/.pnpm/process@0.11.10/node_modules/process/browser.js");
@@ -21862,11 +22450,25 @@ const createRstestUtilities = async (workerState)=>{
         });
         return _timers;
     };
-    const { fn, spyOn, isMockFunction, mocks } = initSpy();
+    const { fn, spyOn, isMockFunction, mocks, createMockInstance } = initSpy();
     const rstest = {
         fn,
         spyOn,
         isMockFunction,
+        mockObject: (value, options)=>mockObject({
+                globalConstructors: {
+                    Object,
+                    Function,
+                    Array,
+                    Map,
+                    RegExp
+                },
+                createMockInstance,
+                type: options?.spy ? 'autospy' : 'automock'
+            }, {
+                value
+            }, {}).value,
+        mocked: (item)=>item,
         clearAllMocks: ()=>{
             for (const mock of mocks)mock.mockClear();
             return rstest;