@rstest/core 0.4.1 → 0.5.1

package/dist/worker.js

@@ -8,12 +8,10 @@ import * as __WEBPACK_EXTERNAL_MODULE_node_os_74b4b876__ from "node:os";
 import * as __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__ from "node:path";
 import * as __WEBPACK_EXTERNAL_MODULE_node_tty_c64aab7e__ from "node:tty";
 import * as __WEBPACK_EXTERNAL_MODULE_node_util_1b29d436__ from "node:util";
-import * as __WEBPACK_EXTERNAL_MODULE_pathe__ from "pathe";
 import * as __WEBPACK_EXTERNAL_MODULE_node_process_786449bf__ from "node:process";
 import * as __WEBPACK_EXTERNAL_MODULE_node_url_e96de089__ from "node:url";
 import * as __WEBPACK_EXTERNAL_MODULE_node_vm_bd3d9cea__ from "node:vm";
 import * as __WEBPACK_EXTERNAL_MODULE_node_v8_d0df5498__ from "node:v8";
-import * as __WEBPACK_EXTERNAL_MODULE_birpc__ from "birpc";
 var __webpack_modules__ = {
     "../../node_modules/.pnpm/@jest+diff-sequences@30.0.1/node_modules/@jest/diff-sequences/build/index.js": function(module) {
         /*!
@@ -5089,11 +5087,10 @@ var __webpack_modules__ = {
             fN: ()=>getTaskNameWithPrefix,
             gy: ()=>undoSerializableConfig,
             kV: ()=>prettyTime,
-            yW: ()=>picocolors__WEBPACK_IMPORTED_MODULE_2___default.a
+            yW: ()=>picocolors__WEBPACK_IMPORTED_MODULE_1___default.a
         });
-        __webpack_require__("pathe");
-        var picocolors__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
-        var picocolors__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/ __webpack_require__.n(picocolors__WEBPACK_IMPORTED_MODULE_2__);
+        var picocolors__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
+        var picocolors__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/ __webpack_require__.n(picocolors__WEBPACK_IMPORTED_MODULE_1__);
         __webpack_require__("./src/utils/constants.ts");
         const isObject = (obj)=>'[object Object]' === Object.prototype.toString.call(obj);
         const castArray = (arr)=>{
@@ -5154,10 +5151,9 @@ var __webpack_modules__ = {
         var constants = __webpack_require__("./src/utils/constants.ts");
         var helper = __webpack_require__("./src/utils/helper.ts");
         __webpack_require__("./src/utils/logger.ts");
-        __webpack_require__("fs");
+        __webpack_require__("node:fs");
         __webpack_require__("node:fs/promises");
         __webpack_require__("node:module");
-        __webpack_require__("pathe");
     },
     "./src/utils/logger.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
@@ -5443,7 +5439,7 @@ var __webpack_modules__ = {
     "timers/promises": function(module) {
         module.exports = require("timers/promises");
     },
-    fs: function(module) {
+    "node:fs": function(module) {
         module.exports = __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__;
     },
     "node:fs/promises": function(module) {
@@ -5464,8 +5460,462 @@ var __webpack_modules__ = {
     "node:util": function(module) {
         module.exports = __WEBPACK_EXTERNAL_MODULE_node_util_1b29d436__;
     },
-    pathe: function(module) {
-        module.exports = __WEBPACK_EXTERNAL_MODULE_pathe__;
+    "../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            _: ()=>_path,
+            c: ()=>basename,
+            d: ()=>dirname,
+            i: ()=>isAbsolute,
+            j: ()=>join,
+            r: ()=>resolve
+        });
+        let _lazyMatch = ()=>{
+            var __lib__ = (()=>{
+                var m = Object.defineProperty, V = Object.getOwnPropertyDescriptor, G = Object.getOwnPropertyNames, T = Object.prototype.hasOwnProperty, q = (r, e)=>{
+                    for(var n in e)m(r, n, {
+                        get: e[n],
+                        enumerable: true
+                    });
+                }, H = (r, e, n, a)=>{
+                    if (e && "object" == typeof e || "function" == typeof e) for (let t of G(e))T.call(r, t) || t === n || m(r, t, {
+                        get: ()=>e[t],
+                        enumerable: !(a = V(e, t)) || a.enumerable
+                    });
+                    return r;
+                }, J = (r)=>H(m({}, "__esModule", {
+                        value: true
+                    }), r), w = {};
+                q(w, {
+                    default: ()=>re
+                });
+                var A = (r)=>Array.isArray(r), d = (r)=>"function" == typeof r, Q = (r)=>0 === r.length, W = (r)=>"number" == typeof r, K = (r)=>"object" == typeof r && null !== r, X = (r)=>r instanceof RegExp, b = (r)=>"string" == typeof r, h = (r)=>void 0 === r, Y = (r)=>{
+                    const e = new Map;
+                    return (n)=>{
+                        const a = e.get(n);
+                        if (a) return a;
+                        const t = r(n);
+                        return e.set(n, t), t;
+                    };
+                }, rr = (r, e, n = {})=>{
+                    const a = {
+                        cache: {},
+                        input: r,
+                        index: 0,
+                        indexMax: 0,
+                        options: n,
+                        output: []
+                    };
+                    if (v(e)(a) && a.index === r.length) return a.output;
+                    throw new Error(`Failed to parse at index ${a.indexMax}`);
+                }, i = (r, e)=>A(r) ? er(r, e) : b(r) ? ar(r, e) : nr(r, e), er = (r, e)=>{
+                    const n = {};
+                    for (const a of r){
+                        if (1 !== a.length) throw new Error(`Invalid character: "${a}"`);
+                        const t = a.charCodeAt(0);
+                        n[t] = true;
+                    }
+                    return (a)=>{
+                        const t = a.index, o = a.input;
+                        for(; a.index < o.length && o.charCodeAt(a.index) in n;)a.index += 1;
+                        const u = a.index;
+                        if (u > t) {
+                            if (!h(e) && !a.options.silent) {
+                                const s = a.input.slice(t, u), c = d(e) ? e(s, o, String(t)) : e;
+                                h(c) || a.output.push(c);
+                            }
+                            a.indexMax = Math.max(a.indexMax, a.index);
+                        }
+                        return true;
+                    };
+                }, nr = (r, e)=>{
+                    const n = r.source, a = r.flags.replace(/y|$/, "y"), t = new RegExp(n, a);
+                    return g((o)=>{
+                        t.lastIndex = o.index;
+                        const u = t.exec(o.input);
+                        if (!u) return false;
+                        if (!h(e) && !o.options.silent) {
+                            const s = d(e) ? e(...u, o.input, String(o.index)) : e;
+                            h(s) || o.output.push(s);
+                        }
+                        return o.index += u[0].length, o.indexMax = Math.max(o.indexMax, o.index), true;
+                    });
+                }, ar = (r, e)=>(n)=>{
+                        if (!n.input.startsWith(r, n.index)) return false;
+                        if (!h(e) && !n.options.silent) {
+                            const t = d(e) ? e(r, n.input, String(n.index)) : e;
+                            h(t) || n.output.push(t);
+                        }
+                        return n.index += r.length, n.indexMax = Math.max(n.indexMax, n.index), true;
+                    }, C = (r, e, n, a)=>{
+                    const t = v(r);
+                    return g(_(M((o)=>{
+                        let u = 0;
+                        for(; u < n;){
+                            const s = o.index;
+                            if (!t(o) || (u += 1, o.index === s)) break;
+                        }
+                        return u >= e;
+                    })));
+                }, tr = (r, e)=>C(r, 0, 1), f = (r, e)=>C(r, 0, 1 / 0), x = (r, e)=>{
+                    const n = r.map(v);
+                    return g(_(M((a)=>{
+                        for(let t = 0, o = n.length; t < o; t++)if (!n[t](a)) return false;
+                        return true;
+                    })));
+                }, l = (r, e)=>{
+                    const n = r.map(v);
+                    return g(_((a)=>{
+                        for(let t = 0, o = n.length; t < o; t++)if (n[t](a)) return true;
+                        return false;
+                    }));
+                }, M = (r, e = false)=>{
+                    const n = v(r);
+                    return (a)=>{
+                        const t = a.index, o = a.output.length, u = n(a);
+                        return (!u || e) && (a.index = t, a.output.length !== o && (a.output.length = o)), u;
+                    };
+                }, _ = (r, e)=>{
+                    const n = v(r);
+                    return n;
+                }, g = (()=>{
+                    let r = 0;
+                    return (e)=>{
+                        const n = v(e), a = r += 1;
+                        return (t)=>{
+                            var o;
+                            if (false === t.options.memoization) return n(t);
+                            const u = t.index, s = (o = t.cache)[a] || (o[a] = new Map), c = s.get(u);
+                            if (false === c) return false;
+                            if (W(c)) return t.index = c, true;
+                            if (c) return t.index = c.index, c.output?.length && t.output.push(...c.output), true;
+                            {
+                                const Z = t.output.length;
+                                if (!n(t)) return s.set(u, false), false;
+                                {
+                                    const D = t.index, U = t.output.length;
+                                    if (U > Z) {
+                                        const ee = t.output.slice(Z, U);
+                                        s.set(u, {
+                                            index: D,
+                                            output: ee
+                                        });
+                                    } else s.set(u, D);
+                                    return true;
+                                }
+                            }
+                        };
+                    };
+                })(), E = (r)=>{
+                    let e;
+                    return (n)=>(e || (e = v(r())), e(n));
+                }, v = Y((r)=>{
+                    if (d(r)) return Q(r) ? E(r) : r;
+                    if (b(r) || X(r)) return i(r);
+                    if (A(r)) return x(r);
+                    if (K(r)) return l(Object.values(r));
+                    throw new Error("Invalid rule");
+                }), P = "abcdefghijklmnopqrstuvwxyz", ir = (r)=>{
+                    let e = "";
+                    for(; r > 0;){
+                        const n = (r - 1) % 26;
+                        e = P[n] + e, r = Math.floor((r - 1) / 26);
+                    }
+                    return e;
+                }, O = (r)=>{
+                    let e = 0;
+                    for(let n = 0, a = r.length; n < a; n++)e = 26 * e + P.indexOf(r[n]) + 1;
+                    return e;
+                }, S = (r, e)=>{
+                    if (e < r) return S(e, r);
+                    const n = [];
+                    for(; r <= e;)n.push(r++);
+                    return n;
+                }, or = (r, e, n)=>S(r, e).map((a)=>String(a).padStart(n, "0")), R = (r, e)=>S(O(r), O(e)).map(ir), p = (r)=>r, z = (r)=>ur((e)=>rr(e, r, {
+                            memoization: false
+                        }).join("")), ur = (r)=>{
+                    const e = {};
+                    return (n)=>e[n] ?? (e[n] = r(n));
+                }, sr = i(/^\*\*\/\*$/, ".*"), cr = i(/^\*\*\/(\*)?([ a-zA-Z0-9._-]+)$/, (r, e, n)=>`.*${e ? "" : "(?:^|/)"}${n.replaceAll(".", "\\.")}`), lr = i(/^\*\*\/(\*)?([ a-zA-Z0-9._-]*)\{([ a-zA-Z0-9._-]+(?:,[ a-zA-Z0-9._-]+)*)\}$/, (r, e, n, a)=>`.*${e ? "" : "(?:^|/)"}${n.replaceAll(".", "\\.")}(?:${a.replaceAll(",", "|").replaceAll(".", "\\.")})`), y = i(/\\./, p), pr = i(/[$.*+?^(){}[\]\|]/, (r)=>`\\${r}`), vr = i(/./, p), hr = i(/^(?:!!)*!(.*)$/, (r, e)=>`(?!^${L(e)}$).*?`), dr = i(/^(!!)+/, ""), fr = l([
+                    hr,
+                    dr
+                ]), xr = i(/\/(\*\*\/)+/, "(?:/.+/|/)"), gr = i(/^(\*\*\/)+/, "(?:^|.*/)"), mr = i(/\/(\*\*)$/, "(?:/.*|$)"), _r = i(/\*\*/, ".*"), j = l([
+                    xr,
+                    gr,
+                    mr,
+                    _r
+                ]), Sr = i(/\*\/(?!\*\*\/)/, "[^/]*/"), yr = i(/\*/, "[^/]*"), N = l([
+                    Sr,
+                    yr
+                ]), k = i("?", "[^/]"), $r = i("[", p), wr = i("]", p), Ar = i(/[!^]/, "^/"), br = i(/[a-z]-[a-z]|[0-9]-[0-9]/i, p), Cr = i(/[$.*+?^(){}[\|]/, (r)=>`\\${r}`), Mr = i(/[^\]]/, p), Er = l([
+                    y,
+                    Cr,
+                    br,
+                    Mr
+                ]), B = x([
+                    $r,
+                    tr(Ar),
+                    f(Er),
+                    wr
+                ]), Pr = i("{", "(?:"), Or = i("}", ")"), Rr = i(/(\d+)\.\.(\d+)/, (r, e, n)=>or(+e, +n, Math.min(e.length, n.length)).join("|")), zr = i(/([a-z]+)\.\.([a-z]+)/, (r, e, n)=>R(e, n).join("|")), jr = i(/([A-Z]+)\.\.([A-Z]+)/, (r, e, n)=>R(e.toLowerCase(), n.toLowerCase()).join("|").toUpperCase()), Nr = l([
+                    Rr,
+                    zr,
+                    jr
+                ]), I = x([
+                    Pr,
+                    Nr,
+                    Or
+                ]), kr = i("{", "(?:"), Br = i("}", ")"), Ir = i(",", "|"), Fr = i(/[$.*+?^(){[\]\|]/, (r)=>`\\${r}`), Lr = i(/[^}]/, p), Zr = E(()=>F), Dr = l([
+                    j,
+                    N,
+                    k,
+                    B,
+                    I,
+                    Zr,
+                    y,
+                    Fr,
+                    Ir,
+                    Lr
+                ]), F = x([
+                    kr,
+                    f(Dr),
+                    Br
+                ]), Ur = f(l([
+                    sr,
+                    cr,
+                    lr,
+                    fr,
+                    j,
+                    N,
+                    k,
+                    B,
+                    I,
+                    F,
+                    y,
+                    pr,
+                    vr
+                ])), Vr = Ur, Gr = z(Vr), L = Gr, Tr = i(/\\./, p), qr = i(/./, p), Hr = i(/\*\*\*+/, "*"), Jr = i(/([^/{[(!])\*\*/, (r, e)=>`${e}*`), Qr = i(/(^|.)\*\*(?=[^*/)\]}])/, (r, e)=>`${e}*`), Wr = f(l([
+                    Tr,
+                    Hr,
+                    Jr,
+                    Qr,
+                    qr
+                ])), Kr = Wr, Xr = z(Kr), Yr = Xr, $ = (r, e)=>{
+                    const n = Array.isArray(r) ? r : [
+                        r
+                    ];
+                    if (!n.length) return false;
+                    const a = n.map($.compile), t = n.every((s)=>/(\/(?:\*\*)?|\[\/\])$/.test(s)), o = e.replace(/[\\\/]+/g, "/").replace(/\/$/, t ? "/" : "");
+                    return a.some((s)=>s.test(o));
+                };
+                $.compile = (r)=>new RegExp(`^${L(Yr(r))}$`, "s");
+                var re = $;
+                return J(w);
+            })();
+            return __lib__.default || __lib__;
+        };
+        let _match;
+        const zeptomatch = (path, pattern)=>{
+            if (!_match) {
+                _match = _lazyMatch();
+                _lazyMatch = null;
+            }
+            return _match(path, pattern);
+        };
+        const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+        function normalizeWindowsPath(input = "") {
+            if (!input) return input;
+            return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r)=>r.toUpperCase());
+        }
+        const _UNC_REGEX = /^[/\\]{2}/;
+        const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+        const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+        const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
+        const _EXTNAME_RE = /.(\.[^./]+|\.)$/;
+        const _PATH_ROOT_RE = /^[/\\]|^[a-zA-Z]:[/\\]/;
+        const sep = "/";
+        const normalize = function(path) {
+            if (0 === path.length) return ".";
+            path = normalizeWindowsPath(path);
+            const isUNCPath = path.match(_UNC_REGEX);
+            const isPathAbsolute = isAbsolute(path);
+            const trailingSeparator = "/" === path[path.length - 1];
+            path = normalizeString(path, !isPathAbsolute);
+            if (0 === path.length) {
+                if (isPathAbsolute) return "/";
+                return trailingSeparator ? "./" : ".";
+            }
+            if (trailingSeparator) path += "/";
+            if (_DRIVE_LETTER_RE.test(path)) path += "/";
+            if (isUNCPath) {
+                if (!isPathAbsolute) return `//./${path}`;
+                return `//${path}`;
+            }
+            return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+        };
+        const join = function(...segments) {
+            let path = "";
+            for (const seg of segments)if (seg) if (path.length > 0) {
+                const pathTrailing = "/" === path[path.length - 1];
+                const segLeading = "/" === seg[0];
+                const both = pathTrailing && segLeading;
+                if (both) path += seg.slice(1);
+                else path += pathTrailing || segLeading ? seg : `/${seg}`;
+            } else path += seg;
+            return normalize(path);
+        };
+        function cwd() {
+            if ("undefined" != typeof process && "function" == typeof process.cwd) return process.cwd().replace(/\\/g, "/");
+            return "/";
+        }
+        const resolve = function(...arguments_) {
+            arguments_ = arguments_.map((argument)=>normalizeWindowsPath(argument));
+            let resolvedPath = "";
+            let resolvedAbsolute = false;
+            for(let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--){
+                const path = index >= 0 ? arguments_[index] : cwd();
+                if (path && 0 !== path.length) {
+                    resolvedPath = `${path}/${resolvedPath}`;
+                    resolvedAbsolute = isAbsolute(path);
+                }
+            }
+            resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+            if (resolvedAbsolute && !isAbsolute(resolvedPath)) return `/${resolvedPath}`;
+            return resolvedPath.length > 0 ? resolvedPath : ".";
+        };
+        function normalizeString(path, allowAboveRoot) {
+            let res = "";
+            let lastSegmentLength = 0;
+            let lastSlash = -1;
+            let dots = 0;
+            let char = null;
+            for(let index = 0; index <= path.length; ++index){
+                if (index < path.length) char = path[index];
+                else if ("/" === char) break;
+                else char = "/";
+                if ("/" === char) {
+                    if (lastSlash === index - 1 || 1 === dots) ;
+                    else if (2 === dots) {
+                        if (res.length < 2 || 2 !== lastSegmentLength || "." !== res[res.length - 1] || "." !== res[res.length - 2]) {
+                            if (res.length > 2) {
+                                const lastSlashIndex = res.lastIndexOf("/");
+                                if (-1 === lastSlashIndex) {
+                                    res = "";
+                                    lastSegmentLength = 0;
+                                } else {
+                                    res = res.slice(0, lastSlashIndex);
+                                    lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+                                }
+                                lastSlash = index;
+                                dots = 0;
+                                continue;
+                            } else if (res.length > 0) {
+                                res = "";
+                                lastSegmentLength = 0;
+                                lastSlash = index;
+                                dots = 0;
+                                continue;
+                            }
+                        }
+                        if (allowAboveRoot) {
+                            res += res.length > 0 ? "/.." : "..";
+                            lastSegmentLength = 2;
+                        }
+                    } else {
+                        if (res.length > 0) res += `/${path.slice(lastSlash + 1, index)}`;
+                        else res = path.slice(lastSlash + 1, index);
+                        lastSegmentLength = index - lastSlash - 1;
+                    }
+                    lastSlash = index;
+                    dots = 0;
+                } else if ("." === char && -1 !== dots) ++dots;
+                else dots = -1;
+            }
+            return res;
+        }
+        const isAbsolute = function(p) {
+            return _IS_ABSOLUTE_RE.test(p);
+        };
+        const toNamespacedPath = function(p) {
+            return normalizeWindowsPath(p);
+        };
+        const extname = function(p) {
+            if (".." === p) return "";
+            const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
+            return match && match[1] || "";
+        };
+        const relative = function(from, to) {
+            const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
+            const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
+            if (":" === _to[0][1] && ":" === _from[0][1] && _from[0] !== _to[0]) return _to.join("/");
+            const _fromCopy = [
+                ..._from
+            ];
+            for (const segment of _fromCopy){
+                if (_to[0] !== segment) break;
+                _from.shift();
+                _to.shift();
+            }
+            return [
+                ..._from.map(()=>".."),
+                ..._to
+            ].join("/");
+        };
+        const dirname = function(p) {
+            const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+            if (1 === segments.length && _DRIVE_LETTER_RE.test(segments[0])) segments[0] += "/";
+            return segments.join("/") || (isAbsolute(p) ? "/" : ".");
+        };
+        const format = function(p) {
+            const ext = p.ext ? p.ext.startsWith(".") ? p.ext : `.${p.ext}` : "";
+            const segments = [
+                p.root,
+                p.dir,
+                p.base ?? (p.name ?? "") + ext
+            ].filter(Boolean);
+            return normalizeWindowsPath(p.root ? resolve(...segments) : segments.join("/"));
+        };
+        const basename = function(p, extension) {
+            const segments = normalizeWindowsPath(p).split("/");
+            let lastSegment = "";
+            for(let i = segments.length - 1; i >= 0; i--){
+                const val = segments[i];
+                if (val) {
+                    lastSegment = val;
+                    break;
+                }
+            }
+            return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
+        };
+        const parse = function(p) {
+            const root = _PATH_ROOT_RE.exec(p)?.[0]?.replace(/\\/g, "/") || "";
+            const base = basename(p);
+            const extension = extname(base);
+            return {
+                root,
+                dir: dirname(p),
+                base,
+                ext: extension,
+                name: base.slice(0, base.length - extension.length)
+            };
+        };
+        const matchesGlob = (path, pattern)=>zeptomatch(pattern, normalize(path));
+        const _path = {
+            __proto__: null,
+            basename: basename,
+            dirname: dirname,
+            extname: extname,
+            format: format,
+            isAbsolute: isAbsolute,
+            join: join,
+            matchesGlob: matchesGlob,
+            normalize: normalize,
+            normalizeString: normalizeString,
+            parse: parse,
+            relative: relative,
+            resolve: resolve,
+            sep: sep,
+            toNamespacedPath: toNamespacedPath
+        };
     }
 };
 var __webpack_module_cache__ = {};
@@ -5633,7 +6083,22 @@ var constants = __webpack_require__("./src/utils/constants.ts");
 var helper = __webpack_require__("./src/utils/helper.ts");
 var util = __webpack_require__("./src/runtime/util.ts");
 var external_node_path_ = __webpack_require__("node:path");
-var external_pathe_ = __webpack_require__("pathe");
+var pathe_M_eThtNZ = __webpack_require__("../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs");
+const delimiter = /* @__PURE__ */ (()=>globalThis.process?.platform === "win32" ? ";" : ":")();
+const _platforms = {
+    posix: void 0,
+    win32: void 0
+};
+const mix = (del = delimiter)=>new Proxy(pathe_M_eThtNZ._, {
+        get (_, prop) {
+            if ("delimiter" === prop) return del;
+            if ("posix" === prop) return posix;
+            if ("win32" === prop) return win32;
+            return _platforms[prop] || pathe_M_eThtNZ._[prop];
+        }
+    });
+const posix = /* @__PURE__ */ mix(":");
+const win32 = /* @__PURE__ */ mix(";");
 var logger = __webpack_require__("./src/utils/logger.ts");
 const shouldInterop = ({ interopDefault = true, modulePath, mod })=>{
     if (!interopDefault) return false;
@@ -5687,8 +6152,8 @@ const worker_createRequire = (filename, distPath, rstestContext, assetFiles, int
         }
     })();
     const require = (id)=>{
-        const currentDirectory = external_pathe_["default"].dirname(distPath);
-        const joinedPath = isRelativePath(id) ? external_pathe_["default"].join(currentDirectory, id) : id;
+        const currentDirectory = posix.dirname(distPath);
+        const joinedPath = isRelativePath(id) ? posix.join(currentDirectory, id) : id;
         const content = assetFiles[joinedPath];
         if (content) try {
             return cacheableLoadModule({
@@ -5744,7 +6209,7 @@ const defineRstestDynamicImport = ({ testPath, interopDefault, returnModule = fa
         return importedModule;
     };
 const loadModule = ({ codeContent, distPath, testPath, rstestContext, assetFiles, interopDefault })=>{
-    const fileDir = external_pathe_["default"].dirname(testPath);
+    const fileDir = posix.dirname(testPath);
     const localModule = {
         children: [],
         exports: {},
@@ -5795,6 +6260,168 @@ const cacheableLoadModule = ({ codeContent, distPath, testPath, rstestContext, a
     moduleCache.set(testPath, mod);
     return mod;
 };
+const TYPE_REQUEST = "q";
+const TYPE_RESPONSE = "s";
+const DEFAULT_TIMEOUT = 6e4;
+function defaultSerialize(i) {
+    return i;
+}
+const defaultDeserialize = defaultSerialize;
+const { clearTimeout: dist_clearTimeout, setTimeout: dist_setTimeout } = globalThis;
+const random = Math.random.bind(Math);
+function createBirpc(functions, options) {
+    const { post, on, off = ()=>{}, eventNames = [], serialize = defaultSerialize, deserialize = defaultDeserialize, resolver, bind = "rpc", timeout = DEFAULT_TIMEOUT } = options;
+    const rpcPromiseMap = /* @__PURE__ */ new Map();
+    let _promise;
+    let closed = false;
+    const rpc = new Proxy({}, {
+        get (_, method) {
+            if ("$functions" === method) return functions;
+            if ("$close" === method) return close;
+            if ("$rejectPendingCalls" === method) return rejectPendingCalls;
+            if ("$closed" === method) return closed;
+            if ("then" === method && !eventNames.includes("then") && !("then" in functions)) return;
+            const sendEvent = (...args)=>{
+                post(serialize({
+                    m: method,
+                    a: args,
+                    t: TYPE_REQUEST
+                }));
+            };
+            if (eventNames.includes(method)) {
+                sendEvent.asEvent = sendEvent;
+                return sendEvent;
+            }
+            const sendCall = async (...args)=>{
+                if (closed) throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+                if (_promise) try {
+                    await _promise;
+                } finally{
+                    _promise = void 0;
+                }
+                return new Promise((resolve, reject)=>{
+                    const id = nanoid();
+                    let timeoutId;
+                    if (timeout >= 0) {
+                        timeoutId = dist_setTimeout(()=>{
+                            try {
+                                const handleResult = options.onTimeoutError?.(method, args);
+                                if (true !== handleResult) throw new Error(`[birpc] timeout on calling "${method}"`);
+                            } catch (e) {
+                                reject(e);
+                            }
+                            rpcPromiseMap.delete(id);
+                        }, timeout);
+                        if ("object" == typeof timeoutId) timeoutId = timeoutId.unref?.();
+                    }
+                    rpcPromiseMap.set(id, {
+                        resolve,
+                        reject,
+                        timeoutId,
+                        method
+                    });
+                    post(serialize({
+                        m: method,
+                        a: args,
+                        i: id,
+                        t: "q"
+                    }));
+                });
+            };
+            sendCall.asEvent = sendEvent;
+            return sendCall;
+        }
+    });
+    function close(customError) {
+        closed = true;
+        rpcPromiseMap.forEach(({ reject, method })=>{
+            const error = new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+            if (customError) {
+                customError.cause ??= error;
+                return reject(customError);
+            }
+            reject(error);
+        });
+        rpcPromiseMap.clear();
+        off(onMessage);
+    }
+    function rejectPendingCalls(handler) {
+        const entries = Array.from(rpcPromiseMap.values());
+        const handlerResults = entries.map(({ method, reject })=>{
+            if (!handler) return reject(new Error(`[birpc]: rejected pending call "${method}".`));
+            return handler({
+                method,
+                reject
+            });
+        });
+        rpcPromiseMap.clear();
+        return handlerResults;
+    }
+    async function onMessage(data, ...extra) {
+        let msg;
+        try {
+            msg = deserialize(data);
+        } catch (e) {
+            if (options.onGeneralError?.(e) !== true) throw e;
+            return;
+        }
+        if (msg.t === TYPE_REQUEST) {
+            const { m: method, a: args } = msg;
+            let result, error;
+            const fn = resolver ? resolver(method, functions[method]) : functions[method];
+            if (fn) try {
+                result = await fn.apply("rpc" === bind ? rpc : functions, args);
+            } catch (e) {
+                error = e;
+            }
+            else error = new Error(`[birpc] function "${method}" not found`);
+            if (msg.i) {
+                if (error && options.onError) options.onError(error, method, args);
+                if (error && options.onFunctionError) {
+                    if (true === options.onFunctionError(error, method, args)) return;
+                }
+                if (!error) try {
+                    post(serialize({
+                        t: TYPE_RESPONSE,
+                        i: msg.i,
+                        r: result
+                    }), ...extra);
+                    return;
+                } catch (e) {
+                    error = e;
+                    if (options.onGeneralError?.(e, method, args) !== true) throw e;
+                }
+                try {
+                    post(serialize({
+                        t: TYPE_RESPONSE,
+                        i: msg.i,
+                        e: error
+                    }), ...extra);
+                } catch (e) {
+                    if (options.onGeneralError?.(e, method, args) !== true) throw e;
+                }
+            }
+        } else {
+            const { i: ack, r: result, e: error } = msg;
+            const promise = rpcPromiseMap.get(ack);
+            if (promise) {
+                dist_clearTimeout(promise.timeoutId);
+                if (error) promise.reject(error);
+                else promise.resolve(result);
+            }
+            rpcPromiseMap.delete(ack);
+        }
+    }
+    _promise = on(onMessage);
+    return rpc;
+}
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+    let id = "";
+    let i = size;
+    while(i--)id += urlAlphabet[64 * random() | 0];
+    return id;
+}
 const processSend = process.send.bind(process);
 const processOn = process.on.bind(process);
 const processOff = process.off.bind(process);
@@ -5817,12 +6444,12 @@ function createForksRpcOptions(nodeV8 = __WEBPACK_EXTERNAL_MODULE_node_v8_d0df54
     };
 }
 function createRuntimeRpc(options) {
-    const rpc = (0, __WEBPACK_EXTERNAL_MODULE_birpc__.createBirpc)({}, options);
+    const rpc = createBirpc({}, options);
     return {
         rpc
     };
 }
-var external_node_fs_ = __webpack_require__("fs");
+var external_node_fs_ = __webpack_require__("node:fs");
 class NodeSnapshotEnvironment {
     constructor(options = {}){
         this.options = options;
@@ -5834,10 +6461,10 @@ class NodeSnapshotEnvironment {
         return `// Snapshot v${this.getVersion()}`;
     }
     async resolveRawPath(testPath, rawPath) {
-        return (0, external_pathe_.isAbsolute)(rawPath) ? rawPath : (0, external_pathe_.resolve)((0, external_pathe_.dirname)(testPath), rawPath);
+        return (0, pathe_M_eThtNZ.i)(rawPath) ? rawPath : (0, pathe_M_eThtNZ.r)((0, pathe_M_eThtNZ.d)(testPath), rawPath);
     }
     async resolvePath(filepath) {
-        return (0, external_pathe_.join)((0, external_pathe_.join)((0, external_pathe_.dirname)(filepath), this.options.snapshotsDirName ?? "__snapshots__"), `${(0, external_pathe_.basename)(filepath)}.snap`);
+        return (0, pathe_M_eThtNZ.j)((0, pathe_M_eThtNZ.j)((0, pathe_M_eThtNZ.d)(filepath), this.options.snapshotsDirName ?? "__snapshots__"), `${(0, pathe_M_eThtNZ.c)(filepath)}.snap`);
     }
     async prepareDirectory(dirPath) {
         await external_node_fs_.promises.mkdir(dirPath, {
@@ -5845,7 +6472,7 @@ class NodeSnapshotEnvironment {
         });
     }
     async saveSnapshotFile(filepath, snapshot) {
-        await external_node_fs_.promises.mkdir((0, external_pathe_.dirname)(filepath), {
+        await external_node_fs_.promises.mkdir((0, pathe_M_eThtNZ.d)(filepath), {
             recursive: true
         });
         await external_node_fs_.promises.writeFile(filepath, snapshot, "utf-8");
@@ -5874,7 +6501,7 @@ const preparePool = async ({ entryInfo: { distPath, testPath }, sourceMaps, upda
     context.runtimeConfig = (0, helper.gy)(context.runtimeConfig);
     const cleanupFns = [];
     const { rpc } = createRuntimeRpc(createForksRpcOptions());
-    const { runtimeConfig: { globals, printConsoleTrace, disableConsoleIntercept, testEnvironment } } = context;
+    const { runtimeConfig: { globals, printConsoleTrace, disableConsoleIntercept, testEnvironment, snapshotFormat } } = context;
     if (!disableConsoleIntercept) {
         const { createCustomConsole } = await __webpack_require__.e("493").then(__webpack_require__.bind(__webpack_require__, "./src/runtime/worker/console.ts"));
         global.console = createCustomConsole({
@@ -5888,7 +6515,8 @@ const preparePool = async ({ entryInfo: { distPath, testPath }, sourceMaps, upda
         ...context,
         snapshotOptions: {
             updateSnapshot,
-            snapshotEnvironment: new RstestSnapshotEnvironment()
+            snapshotEnvironment: new RstestSnapshotEnvironment(),
+            snapshotFormat
         },
         distPath,
         testPath,
@@ -6075,6 +6703,7 @@ const runInPool = async (options)=>{
                 if (coverageProvider) {
                     const coverageMap = coverageProvider.collect();
                     if (coverageMap) test.coverage = coverageMap.toJSON();
+                    coverageProvider.cleanup();
                 }
                 await rpc.onTestFileResult(test);
             },