@mastra/evals 0.10.2 → 0.10.3

package/dist/{dist-TRBEMZ6L.js → dist-5D6XVBCU.js}

@@ -32,21 +32,21 @@ var require_utils = __commonJS({
 // ../../node_modules/.pnpm/expect-type@1.2.1/node_modules/expect-type/dist/index.js
 var require_dist = __commonJS({
   "../../node_modules/.pnpm/expect-type@1.2.1/node_modules/expect-type/dist/index.js"(exports) {
-    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m3, k2, k22) {
-      if (k22 === void 0) k22 = k2;
-      var desc = Object.getOwnPropertyDescriptor(m3, k2);
-      if (!desc || ("get" in desc ? !m3.__esModule : desc.writable || desc.configurable)) {
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m2, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m2, k);
+      if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
         desc = { enumerable: true, get: function() {
-          return m3[k2];
+          return m2[k];
         } };
       }
-      Object.defineProperty(o, k22, desc);
-    } : function(o, m3, k2, k22) {
-      if (k22 === void 0) k22 = k2;
-      o[k22] = m3[k2];
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m2, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m2[k];
     });
-    var __exportStar = exports && exports.__exportStar || function(m3, exports2) {
-      for (var p3 in m3) if (p3 !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p3)) __createBinding(exports2, m3, p3);
+    var __exportStar = exports && exports.__exportStar || function(m2, exports2) {
+      for (var p3 in m2) if (p3 !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p3)) __createBinding(exports2, m2, p3);
     };
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.expectTypeOf = void 0;
@@ -164,41 +164,41 @@ function C(n = false) {
 }
 function p(n = false) {
   let e = C(n), i = (r2, t, c, o) => {
-    let l2 = "", s2 = 0;
+    let l = "", s2 = 0;
     do
-      l2 += r2.substring(s2, o) + c, s2 = o + t.length, o = r2.indexOf(t, s2);
+      l += r2.substring(s2, o) + c, s2 = o + t.length, o = r2.indexOf(t, s2);
     while (~o);
-    return l2 + r2.substring(s2);
+    return l + r2.substring(s2);
   }, g = (r2, t, c = r2) => {
-    let o = (l2) => {
-      let s2 = String(l2), b = s2.indexOf(t, r2.length);
+    let o = (l) => {
+      let s2 = String(l), b = s2.indexOf(t, r2.length);
       return ~b ? r2 + i(s2, t, c, b) + t : r2 + s2 + t;
     };
     return o.open = r2, o.close = t, o;
-  }, u3 = {
+  }, u2 = {
     isColorSupported: e
-  }, d2 = (r2) => `\x1B[${r2}m`;
+  }, d = (r2) => `\x1B[${r2}m`;
   for (let [r2, t] of h)
-    u3[r2] = e ? g(
-      d2(t[0]),
-      d2(t[1]),
+    u2[r2] = e ? g(
+      d(t[0]),
+      d(t[1]),
       t[2]
     ) : a;
-  return u3;
+  return u2;
 }
 var r = process.env.FORCE_TTY !== void 0 || isatty(1);
 var u = p(r);
 
-// ../../node_modules/.pnpm/@vitest+pretty-format@3.1.2/node_modules/@vitest/pretty-format/dist/index.js
-function _mergeNamespaces(n, m3) {
-  m3.forEach(function(e) {
-    e && typeof e !== "string" && !Array.isArray(e) && Object.keys(e).forEach(function(k2) {
-      if (k2 !== "default" && !(k2 in n)) {
-        var d2 = Object.getOwnPropertyDescriptor(e, k2);
-        Object.defineProperty(n, k2, d2.get ? d2 : {
+// ../../node_modules/.pnpm/@vitest+pretty-format@3.2.2/node_modules/@vitest/pretty-format/dist/index.js
+function _mergeNamespaces(n, m2) {
+  m2.forEach(function(e) {
+    e && typeof e !== "string" && !Array.isArray(e) && Object.keys(e).forEach(function(k) {
+      if (k !== "default" && !(k in n)) {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
           enumerable: true,
           get: function() {
-            return e[k2];
+            return e[k];
           }
         });
       }
@@ -273,7 +273,7 @@ function printIteratorValues(iterator, config2, indentation, depth, refs, printe
 function printListItems(list, config2, indentation, depth, refs, printer2) {
   let result = "";
   list = list instanceof ArrayBuffer ? new DataView(list) : list;
-  const isDataView = (l2) => l2 instanceof DataView;
+  const isDataView = (l) => l instanceof DataView;
   const length = isDataView(list) ? list.byteLength : list.length;
   if (length > 0) {
     result += config2.spacingOuter;
@@ -534,8 +534,8 @@ var plugin$2 = {
   serialize: serialize$2,
   test: test$2
 };
-function getDefaultExportFromCjs(x2) {
-  return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
 var reactIs$1 = { exports: {} };
 var reactIs_production = {};
@@ -747,25 +747,25 @@ var hasRequiredReactIs_production_min;
 function requireReactIs_production_min() {
   if (hasRequiredReactIs_production_min) return reactIs_production_min;
   hasRequiredReactIs_production_min = 1;
-  var b = Symbol.for("react.element"), c = Symbol.for("react.portal"), d2 = Symbol.for("react.fragment"), e = Symbol.for("react.strict_mode"), f4 = Symbol.for("react.profiler"), g = Symbol.for("react.provider"), h3 = Symbol.for("react.context"), k2 = Symbol.for("react.server_context"), l2 = Symbol.for("react.forward_ref"), m3 = Symbol.for("react.suspense"), n = Symbol.for("react.suspense_list"), p3 = Symbol.for("react.memo"), q = Symbol.for("react.lazy"), t = Symbol.for("react.offscreen"), u3;
-  u3 = Symbol.for("react.module.reference");
+  var b = Symbol.for("react.element"), c = Symbol.for("react.portal"), d = Symbol.for("react.fragment"), e = Symbol.for("react.strict_mode"), f3 = Symbol.for("react.profiler"), g = Symbol.for("react.provider"), h3 = Symbol.for("react.context"), k = Symbol.for("react.server_context"), l = Symbol.for("react.forward_ref"), m2 = Symbol.for("react.suspense"), n = Symbol.for("react.suspense_list"), p3 = Symbol.for("react.memo"), q = Symbol.for("react.lazy"), t = Symbol.for("react.offscreen"), u2;
+  u2 = Symbol.for("react.module.reference");
   function v(a3) {
     if ("object" === typeof a3 && null !== a3) {
       var r2 = a3.$$typeof;
       switch (r2) {
         case b:
           switch (a3 = a3.type, a3) {
-            case d2:
-            case f4:
+            case d:
+            case f3:
             case e:
-            case m3:
+            case m2:
             case n:
               return a3;
             default:
               switch (a3 = a3 && a3.$$typeof, a3) {
-                case k2:
+                case k:
                 case h3:
-                case l2:
+                case l:
                 case q:
                 case p3:
                 case g:
@@ -782,14 +782,14 @@ function requireReactIs_production_min() {
   reactIs_production_min.ContextConsumer = h3;
   reactIs_production_min.ContextProvider = g;
   reactIs_production_min.Element = b;
-  reactIs_production_min.ForwardRef = l2;
-  reactIs_production_min.Fragment = d2;
+  reactIs_production_min.ForwardRef = l;
+  reactIs_production_min.Fragment = d;
   reactIs_production_min.Lazy = q;
   reactIs_production_min.Memo = p3;
   reactIs_production_min.Portal = c;
-  reactIs_production_min.Profiler = f4;
+  reactIs_production_min.Profiler = f3;
   reactIs_production_min.StrictMode = e;
-  reactIs_production_min.Suspense = m3;
+  reactIs_production_min.Suspense = m2;
   reactIs_production_min.SuspenseList = n;
   reactIs_production_min.isAsyncMode = function() {
     return false;
@@ -807,10 +807,10 @@ function requireReactIs_production_min() {
     return "object" === typeof a3 && null !== a3 && a3.$$typeof === b;
   };
   reactIs_production_min.isForwardRef = function(a3) {
-    return v(a3) === l2;
+    return v(a3) === l;
   };
   reactIs_production_min.isFragment = function(a3) {
-    return v(a3) === d2;
+    return v(a3) === d;
   };
   reactIs_production_min.isLazy = function(a3) {
     return v(a3) === q;
@@ -822,19 +822,19 @@ function requireReactIs_production_min() {
     return v(a3) === c;
   };
   reactIs_production_min.isProfiler = function(a3) {
-    return v(a3) === f4;
+    return v(a3) === f3;
   };
   reactIs_production_min.isStrictMode = function(a3) {
     return v(a3) === e;
   };
   reactIs_production_min.isSuspense = function(a3) {
-    return v(a3) === m3;
+    return v(a3) === m2;
   };
   reactIs_production_min.isSuspenseList = function(a3) {
     return v(a3) === n;
   };
   reactIs_production_min.isValidElementType = function(a3) {
-    return "string" === typeof a3 || "function" === typeof a3 || a3 === d2 || a3 === f4 || a3 === e || a3 === m3 || a3 === n || a3 === t || "object" === typeof a3 && null !== a3 && (a3.$$typeof === q || a3.$$typeof === p3 || a3.$$typeof === g || a3.$$typeof === h3 || a3.$$typeof === l2 || a3.$$typeof === u3 || void 0 !== a3.getModuleId) ? true : false;
+    return "string" === typeof a3 || "function" === typeof a3 || a3 === d || a3 === f3 || a3 === e || a3 === m2 || a3 === n || a3 === t || "object" === typeof a3 && null !== a3 && (a3.$$typeof === q || a3.$$typeof === p3 || a3.$$typeof === g || a3.$$typeof === h3 || a3.$$typeof === l || a3.$$typeof === u2 || void 0 !== a3.getModuleId) ? true : false;
   };
   reactIs_production_min.typeOf = v;
   return reactIs_production_min;
@@ -1054,7 +1054,7 @@ var reactIsMethods = [
   "isSuspenseList",
   "isValidElementType"
 ];
-var ReactIs = Object.fromEntries(reactIsMethods.map((m3) => [m3, (v) => ReactIs18[m3](v) || ReactIs19[m3](v)]));
+var ReactIs = Object.fromEntries(reactIsMethods.map((m2) => [m2, (v) => ReactIs18[m2](v) || ReactIs19[m2](v)]));
 function getChildren(arg, children = []) {
   if (Array.isArray(arg)) {
     for (const item of arg) {
@@ -1986,7 +1986,7 @@ function inspect(value, opts = {}) {
   return options.stylize(String(value), type3);
 }
 
-// ../../node_modules/.pnpm/@vitest+utils@3.1.2/node_modules/@vitest/utils/dist/chunk-_commonjsHelpers.js
+// ../../node_modules/.pnpm/@vitest+utils@3.2.2/node_modules/@vitest/utils/dist/chunk-_commonjsHelpers.js
 var { AsymmetricMatcher, DOMCollection, DOMElement, Immutable, ReactElement, ReactTestComponent } = plugins;
 var PLUGINS = [
   ReactTestComponent,
@@ -2035,14 +2035,14 @@ function format2(...args) {
   const len = args.length;
   let i = 1;
   const template = args[0];
-  let str = String(template).replace(formatRegExp, (x2) => {
-    if (x2 === "%%") {
+  let str = String(template).replace(formatRegExp, (x) => {
+    if (x === "%%") {
       return "%";
     }
     if (i >= len) {
-      return x2;
+      return x;
     }
-    switch (x2) {
+    switch (x) {
       case "%s": {
         const value = args[i++];
         if (typeof value === "bigint") {
@@ -2093,21 +2093,21 @@ function format2(...args) {
         try {
           return JSON.stringify(args[i++]);
         } catch (err) {
-          const m3 = err.message;
-          if (m3.includes("circular structure") || m3.includes("cyclic structures") || m3.includes("cyclic object")) {
+          const m2 = err.message;
+          if (m2.includes("circular structure") || m2.includes("cyclic structures") || m2.includes("cyclic object")) {
             return "[Circular]";
           }
           throw err;
         }
       default:
-        return x2;
+        return x;
     }
   });
-  for (let x2 = args[i]; i < len; x2 = args[++i]) {
-    if (x2 === null || typeof x2 !== "object") {
-      str += ` ${x2}`;
+  for (let x = args[i]; i < len; x = args[++i]) {
+    if (x === null || typeof x !== "object") {
+      str += ` ${x}`;
     } else {
-      str += ` ${inspect2(x2)}`;
+      str += ` ${inspect2(x)}`;
     }
   }
   return str;
@@ -2140,11 +2140,11 @@ function objDisplay(obj, options = {}) {
   }
   return str;
 }
-function getDefaultExportFromCjs2(x2) {
-  return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
+function getDefaultExportFromCjs2(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
 
-// ../../node_modules/.pnpm/@vitest+utils@3.1.2/node_modules/@vitest/utils/dist/helpers.js
+// ../../node_modules/.pnpm/@vitest+utils@3.2.2/node_modules/@vitest/utils/dist/helpers.js
 function createSimpleStackTrace(options) {
   const { message = "$$stack trace error", stackTraceLimit = 1 } = options || {};
   const limit = Error.stackTraceLimit;
@@ -2201,15 +2201,15 @@ function deepClone(val, options = defaultCloneOptions) {
   return clone(val, seen, options);
 }
 function clone(val, seen, options = defaultCloneOptions) {
-  let k2, out;
+  let k, out;
   if (seen.has(val)) {
     return seen.get(val);
   }
   if (Array.isArray(val)) {
-    out = Array.from({ length: k2 = val.length });
+    out = Array.from({ length: k = val.length });
     seen.set(val, out);
-    while (k2--) {
-      out[k2] = clone(val[k2], seen, options);
+    while (k--) {
+      out[k] = clone(val[k], seen, options);
     }
     return out;
   }
@@ -2217,28 +2217,28 @@ function clone(val, seen, options = defaultCloneOptions) {
     out = Object.create(Object.getPrototypeOf(val));
     seen.set(val, out);
     const props = getOwnProperties(val);
-    for (const k3 of props) {
-      const descriptor = Object.getOwnPropertyDescriptor(val, k3);
+    for (const k2 of props) {
+      const descriptor = Object.getOwnPropertyDescriptor(val, k2);
       if (!descriptor) {
         continue;
       }
-      const cloned = clone(val[k3], seen, options);
+      const cloned = clone(val[k2], seen, options);
       if (options.forceWritable) {
-        Object.defineProperty(out, k3, {
+        Object.defineProperty(out, k2, {
           enumerable: descriptor.enumerable,
           configurable: true,
           writable: true,
           value: cloned
         });
       } else if ("get" in descriptor) {
-        Object.defineProperty(out, k3, {
+        Object.defineProperty(out, k2, {
           ...descriptor,
           get() {
             return cloned;
           }
         });
       } else {
-        Object.defineProperty(out, k3, {
+        Object.defineProperty(out, k2, {
           ...descriptor,
           value: cloned
         });
@@ -2350,7 +2350,7 @@ function getSafeTimers() {
   };
 }
 
-// ../../node_modules/.pnpm/@vitest+utils@3.1.2/node_modules/@vitest/utils/dist/diff.js
+// ../../node_modules/.pnpm/@vitest+utils@3.2.2/node_modules/@vitest/utils/dist/diff.js
 var DIFF_DELETE = -1;
 var DIFF_INSERT = 1;
 var DIFF_EQUAL = 0;
@@ -2705,9 +2705,9 @@ function requireBuild() {
     }
     return nCommon;
   };
-  const extendPathsF = (d2, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF) => {
+  const extendPathsF = (d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF) => {
     let iF = 0;
-    let kF = -d2;
+    let kF = -d;
     let aFirst = aIndexesF[iF];
     let aIndexPrev1 = aFirst;
     aIndexesF[iF] += countCommonItemsF(
@@ -2717,9 +2717,9 @@ function requireBuild() {
       bEnd,
       isCommon
     );
-    const nF = d2 < iMaxF ? d2 : iMaxF;
+    const nF = d < iMaxF ? d : iMaxF;
     for (iF += 1, kF += 2; iF <= nF; iF += 1, kF += 2) {
-      if (iF !== d2 && aIndexPrev1 < aIndexesF[iF]) {
+      if (iF !== d && aIndexPrev1 < aIndexesF[iF]) {
         aFirst = aIndexesF[iF];
       } else {
         aFirst = aIndexPrev1 + 1;
@@ -2732,9 +2732,9 @@ function requireBuild() {
     }
     return iMaxF;
   };
-  const extendPathsR = (d2, aStart, bStart, bR, isCommon, aIndexesR, iMaxR) => {
+  const extendPathsR = (d, aStart, bStart, bR, isCommon, aIndexesR, iMaxR) => {
     let iR = 0;
-    let kR = d2;
+    let kR = d;
     let aFirst = aIndexesR[iR];
     let aIndexPrev1 = aFirst;
     aIndexesR[iR] -= countCommonItemsR(
@@ -2744,9 +2744,9 @@ function requireBuild() {
       bR + aFirst - kR - 1,
       isCommon
     );
-    const nR = d2 < iMaxR ? d2 : iMaxR;
+    const nR = d < iMaxR ? d : iMaxR;
     for (iR += 1, kR -= 2; iR <= nR; iR += 1, kR -= 2) {
-      if (iR !== d2 && aIndexesR[iR] < aIndexPrev1) {
+      if (iR !== d && aIndexesR[iR] < aIndexPrev1) {
         aFirst = aIndexesR[iR];
       } else {
         aFirst = aIndexPrev1 - 1;
@@ -2765,17 +2765,17 @@ function requireBuild() {
     }
     return iMaxR;
   };
-  const extendOverlappablePathsF = (d2, aStart, aEnd, bStart, bEnd, isCommon, aIndexesF, iMaxF, aIndexesR, iMaxR, division) => {
+  const extendOverlappablePathsF = (d, aStart, aEnd, bStart, bEnd, isCommon, aIndexesF, iMaxF, aIndexesR, iMaxR, division) => {
     const bF = bStart - aStart;
     const aLength = aEnd - aStart;
     const bLength = bEnd - bStart;
     const baDeltaLength = bLength - aLength;
-    const kMinOverlapF = -baDeltaLength - (d2 - 1);
-    const kMaxOverlapF = -baDeltaLength + (d2 - 1);
+    const kMinOverlapF = -baDeltaLength - (d - 1);
+    const kMaxOverlapF = -baDeltaLength + (d - 1);
     let aIndexPrev1 = NOT_YET_SET;
-    const nF = d2 < iMaxF ? d2 : iMaxF;
-    for (let iF = 0, kF = -d2; iF <= nF; iF += 1, kF += 2) {
-      const insert = iF === 0 || iF !== d2 && aIndexPrev1 < aIndexesF[iF];
+    const nF = d < iMaxF ? d : iMaxF;
+    for (let iF = 0, kF = -d; iF <= nF; iF += 1, kF += 2) {
+      const insert = iF === 0 || iF !== d && aIndexPrev1 < aIndexesF[iF];
       const aLastPrev = insert ? aIndexesF[iF] : aIndexPrev1;
       const aFirst = insert ? aLastPrev : aLastPrev + 1;
       const bFirst = bF + aFirst - kF;
@@ -2790,7 +2790,7 @@ function requireBuild() {
       aIndexPrev1 = aIndexesF[iF];
       aIndexesF[iF] = aLast;
       if (kMinOverlapF <= kF && kF <= kMaxOverlapF) {
-        const iR = (d2 - 1 - (kF + baDeltaLength)) / 2;
+        const iR = (d - 1 - (kF + baDeltaLength)) / 2;
         if (iR <= iMaxR && aIndexesR[iR] - 1 <= aLast) {
           const bLastPrev = bF + aLastPrev - (insert ? kF + 1 : kF - 1);
           const nCommonR = countCommonItemsR(
@@ -2804,8 +2804,8 @@ function requireBuild() {
           const bIndexPrevFirst = bLastPrev - nCommonR;
           const aEndPreceding = aIndexPrevFirst + 1;
           const bEndPreceding = bIndexPrevFirst + 1;
-          division.nChangePreceding = d2 - 1;
-          if (d2 - 1 === aEndPreceding + bEndPreceding - aStart - bStart) {
+          division.nChangePreceding = d - 1;
+          if (d - 1 === aEndPreceding + bEndPreceding - aStart - bStart) {
             division.aEndPreceding = aStart;
             division.bEndPreceding = bStart;
           } else {
@@ -2824,8 +2824,8 @@ function requireBuild() {
           }
           const aStartFollowing = aLast + 1;
           const bStartFollowing = bFirst + nCommonF + 1;
-          division.nChangeFollowing = d2 - 1;
-          if (d2 - 1 === aEnd + bEnd - aStartFollowing - bStartFollowing) {
+          division.nChangeFollowing = d - 1;
+          if (d - 1 === aEnd + bEnd - aStartFollowing - bStartFollowing) {
             division.aStartFollowing = aEnd;
             division.bStartFollowing = bEnd;
           } else {
@@ -2838,17 +2838,17 @@ function requireBuild() {
     }
     return false;
   };
-  const extendOverlappablePathsR = (d2, aStart, aEnd, bStart, bEnd, isCommon, aIndexesF, iMaxF, aIndexesR, iMaxR, division) => {
+  const extendOverlappablePathsR = (d, aStart, aEnd, bStart, bEnd, isCommon, aIndexesF, iMaxF, aIndexesR, iMaxR, division) => {
     const bR = bEnd - aEnd;
     const aLength = aEnd - aStart;
     const bLength = bEnd - bStart;
     const baDeltaLength = bLength - aLength;
-    const kMinOverlapR = baDeltaLength - d2;
-    const kMaxOverlapR = baDeltaLength + d2;
+    const kMinOverlapR = baDeltaLength - d;
+    const kMaxOverlapR = baDeltaLength + d;
     let aIndexPrev1 = NOT_YET_SET;
-    const nR = d2 < iMaxR ? d2 : iMaxR;
-    for (let iR = 0, kR = d2; iR <= nR; iR += 1, kR -= 2) {
-      const insert = iR === 0 || iR !== d2 && aIndexesR[iR] < aIndexPrev1;
+    const nR = d < iMaxR ? d : iMaxR;
+    for (let iR = 0, kR = d; iR <= nR; iR += 1, kR -= 2) {
+      const insert = iR === 0 || iR !== d && aIndexesR[iR] < aIndexPrev1;
       const aLastPrev = insert ? aIndexesR[iR] : aIndexPrev1;
       const aFirst = insert ? aLastPrev : aLastPrev - 1;
       const bFirst = bR + aFirst - kR;
@@ -2863,11 +2863,11 @@ function requireBuild() {
       aIndexPrev1 = aIndexesR[iR];
       aIndexesR[iR] = aLast;
       if (kMinOverlapR <= kR && kR <= kMaxOverlapR) {
-        const iF = (d2 + (kR - baDeltaLength)) / 2;
+        const iF = (d + (kR - baDeltaLength)) / 2;
         if (iF <= iMaxF && aLast - 1 <= aIndexesF[iF]) {
           const bLast = bFirst - nCommonR;
-          division.nChangePreceding = d2;
-          if (d2 === aLast + bLast - aStart - bStart) {
+          division.nChangePreceding = d;
+          if (d === aLast + bLast - aStart - bStart) {
             division.aEndPreceding = aStart;
             division.bEndPreceding = bStart;
           } else {
@@ -2879,8 +2879,8 @@ function requireBuild() {
             division.aCommonPreceding = aLast;
             division.bCommonPreceding = bLast;
           }
-          division.nChangeFollowing = d2 - 1;
-          if (d2 === 1) {
+          division.nChangeFollowing = d - 1;
+          if (d === 1) {
             division.nCommonFollowing = 0;
             division.aStartFollowing = aEnd;
             division.bStartFollowing = bEnd;
@@ -2900,7 +2900,7 @@ function requireBuild() {
             }
             const aStartFollowing = aLastPrev + nCommonF;
             const bStartFollowing = bLastPrev + nCommonF;
-            if (d2 - 1 === aEnd + bEnd - aStartFollowing - bStartFollowing) {
+            if (d - 1 === aEnd + bEnd - aStartFollowing - bStartFollowing) {
               division.aStartFollowing = aEnd;
               division.bStartFollowing = bEnd;
             } else {
@@ -2927,15 +2927,15 @@ function requireBuild() {
     if (baDeltaLength % 2 === 0) {
       const dMin = (nChange || baDeltaLength) / 2;
       const dMax = (aLength + bLength) / 2;
-      for (let d2 = 1; d2 <= dMax; d2 += 1) {
-        iMaxF = extendPathsF(d2, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);
-        if (d2 < dMin) {
-          iMaxR = extendPathsR(d2, aStart, bStart, bR, isCommon, aIndexesR, iMaxR);
+      for (let d = 1; d <= dMax; d += 1) {
+        iMaxF = extendPathsF(d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);
+        if (d < dMin) {
+          iMaxR = extendPathsR(d, aStart, bStart, bR, isCommon, aIndexesR, iMaxR);
         } else if (
           // If a reverse path overlaps a forward path in the same diagonal,
           // return a division of the index intervals at the middle change.
           extendOverlappablePathsR(
-            d2,
+            d,
             aStart,
             aEnd,
             bStart,
@@ -2954,11 +2954,11 @@ function requireBuild() {
     } else {
       const dMin = ((nChange || baDeltaLength) + 1) / 2;
       const dMax = (aLength + bLength + 1) / 2;
-      let d2 = 1;
-      iMaxF = extendPathsF(d2, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);
-      for (d2 += 1; d2 <= dMax; d2 += 1) {
+      let d = 1;
+      iMaxF = extendPathsF(d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);
+      for (d += 1; d <= dMax; d += 1) {
         iMaxR = extendPathsR(
-          d2 - 1,
+          d - 1,
           aStart,
           bStart,
           bR,
@@ -2966,13 +2966,13 @@ function requireBuild() {
           aIndexesR,
           iMaxR
         );
-        if (d2 < dMin) {
-          iMaxF = extendPathsF(d2, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);
+        if (d < dMin) {
+          iMaxF = extendPathsF(d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);
         } else if (
           // If a forward path overlaps a reverse path in the same diagonal,
           // return a division of the index intervals at the middle change.
           extendOverlappablePathsF(
-            d2,
+            d,
             aStart,
             aEnd,
             bStart,
@@ -3587,9 +3587,11 @@ var ChangeBuffer = class {
   isLineEmpty() {
     return this.line.length === 0;
   }
+  // Minor input to buffer.
   pushDiff(diff2) {
     this.line.push(diff2);
   }
+  // Main input to buffer.
   align(diff2) {
     const string2 = diff2[1];
     if (string2.includes("\n")) {
@@ -3607,6 +3609,7 @@ var ChangeBuffer = class {
       this.pushDiff(diff2);
     }
   }
+  // Output from buffer.
   moveLinesTo(lines) {
     if (!this.isLineEmpty()) {
       this.pushLine();
@@ -3640,6 +3643,7 @@ var CommonBuffer = class {
     this.deleteBuffer.moveLinesTo(this.lines);
     this.insertBuffer.moveLinesTo(this.lines);
   }
+  // Input to buffer.
   align(diff2) {
     const op = diff2[0];
     const string2 = diff2[1];
@@ -3666,6 +3670,7 @@ var CommonBuffer = class {
       this.pushDiffChangeLines(diff2);
     }
   }
+  // Output from buffer.
   getLines() {
     this.flushChangeLines();
     return this.lines;
@@ -3941,113 +3946,166 @@ function getCommonAndChangedSubstrings(diffs, op, hasCommonDiff2) {
   return diffs.reduce((reduced, diff2) => reduced + (diff2[0] === DIFF_EQUAL ? diff2[1] : diff2[0] === op ? hasCommonDiff2 ? u.inverse(diff2[1]) : diff2[1] : ""), "");
 }
 
-// ../../node_modules/.pnpm/tinyspy@3.0.2/node_modules/tinyspy/dist/index.js
-function d(e, t) {
-  if (!e)
-    throw new Error(t);
-}
-function y(e, t) {
-  return typeof t === e;
-}
-function w(e) {
-  return e instanceof Promise;
-}
-function f2(e, t, n) {
-  Object.defineProperty(e, t, n);
-}
-function l(e, t, n) {
-  Object.defineProperty(e, t, { value: n });
-}
-var u2 = Symbol.for("tinyspy:spy");
-var x = /* @__PURE__ */ new Set();
-var P = (e) => {
-  e.called = false, e.callCount = 0, e.calls = [], e.results = [], e.resolves = [], e.next = [];
-};
-var K = (e) => (f2(e, u2, { value: { reset: () => P(e[u2]) } }), e[u2]);
-var T = (e) => e[u2] || K(e);
-function m2(e) {
-  d(
-    y("function", e) || y("undefined", e),
+// ../../node_modules/.pnpm/tinyspy@4.0.3/node_modules/tinyspy/dist/index.js
+function assert(condition, message) {
+  if (!condition)
+    throw new Error(message);
+}
+function isType(type3, value) {
+  return typeof value === type3;
+}
+function isPromise(value) {
+  return value instanceof Promise;
+}
+function define(obj, key, descriptor) {
+  Object.defineProperty(obj, key, descriptor);
+}
+function defineValue(obj, key, value) {
+  define(obj, key, { value, configurable: true, writable: true });
+}
+var SYMBOL_STATE = Symbol.for("tinyspy:spy");
+var spies = /* @__PURE__ */ new Set();
+var reset = (state) => {
+  state.called = false, state.callCount = 0, state.calls = [], state.results = [], state.resolves = [], state.next = [];
+};
+var defineState = (spy2) => (define(spy2, SYMBOL_STATE, {
+  value: { reset: () => reset(spy2[SYMBOL_STATE]) }
+}), spy2[SYMBOL_STATE]);
+var getInternalState = (spy2) => spy2[SYMBOL_STATE] || defineState(spy2);
+function createInternalSpy(cb) {
+  assert(
+    isType("function", cb) || isType("undefined", cb),
     "cannot spy on a non-function value"
   );
-  let t = function(...s2) {
-    let r2 = T(t);
-    r2.called = true, r2.callCount++, r2.calls.push(s2);
-    let S = r2.next.shift();
-    if (S) {
-      r2.results.push(S);
-      let [o, g] = S;
-      if (o === "ok")
-        return g;
-      throw g;
-    }
-    let p3, c = "ok", a3 = r2.results.length;
-    if (r2.impl)
+  let fn2 = function(...args) {
+    let state2 = getInternalState(fn2);
+    state2.called = true, state2.callCount++, state2.calls.push(args);
+    let next = state2.next.shift();
+    if (next) {
+      state2.results.push(next);
+      let [type22, result2] = next;
+      if (type22 === "ok")
+        return result2;
+      throw result2;
+    }
+    let result, type3 = "ok", resultIndex = state2.results.length;
+    if (state2.impl)
       try {
-        new.target ? p3 = Reflect.construct(r2.impl, s2, new.target) : p3 = r2.impl.apply(this, s2), c = "ok";
-      } catch (o) {
-        throw p3 = o, c = "error", r2.results.push([c, o]), o;
-      }
-    let R = [c, p3];
-    return w(p3) && p3.then(
-      (o) => r2.resolves[a3] = ["ok", o],
-      (o) => r2.resolves[a3] = ["error", o]
-    ), r2.results.push(R), p3;
-  };
-  l(t, "_isMockFunction", true), l(t, "length", e ? e.length : 0), l(t, "name", e && e.name || "spy");
-  let n = T(t);
-  return n.reset(), n.impl = e, t;
-}
-var k = (e, t) => Object.getOwnPropertyDescriptor(e, t);
-var O = (e, t) => {
-  t != null && typeof t == "function" && t.prototype != null && Object.setPrototypeOf(e.prototype, t.prototype);
-};
-function C2(e, t, n) {
-  d(
-    !y("undefined", e),
+        new.target ? result = Reflect.construct(state2.impl, args, new.target) : result = state2.impl.apply(this, args), type3 = "ok";
+      } catch (err) {
+        throw result = err, type3 = "error", state2.results.push([type3, err]), err;
+      }
+    let resultTuple = [type3, result];
+    return isPromise(result) && result.then(
+      (r2) => state2.resolves[resultIndex] = ["ok", r2],
+      (e) => state2.resolves[resultIndex] = ["error", e]
+    ), state2.results.push(resultTuple), result;
+  };
+  defineValue(fn2, "_isMockFunction", true), defineValue(fn2, "length", cb ? cb.length : 0), defineValue(fn2, "name", cb && cb.name || "spy");
+  let state = getInternalState(fn2);
+  return state.reset(), state.impl = cb, fn2;
+}
+function isMockFunction(obj) {
+  return !!obj && obj._isMockFunction === true;
+}
+var getDescriptor = (obj, method) => {
+  let objDescriptor = Object.getOwnPropertyDescriptor(obj, method);
+  if (objDescriptor)
+    return [obj, objDescriptor];
+  let currentProto = Object.getPrototypeOf(obj);
+  for (; currentProto !== null; ) {
+    let descriptor = Object.getOwnPropertyDescriptor(currentProto, method);
+    if (descriptor)
+      return [currentProto, descriptor];
+    currentProto = Object.getPrototypeOf(currentProto);
+  }
+};
+var setPototype = (fn2, val) => {
+  val != null && typeof val == "function" && val.prototype != null && Object.setPrototypeOf(fn2.prototype, val.prototype);
+};
+function internalSpyOn(obj, methodName, mock) {
+  assert(
+    !isType("undefined", obj),
     "spyOn could not find an object to spy upon"
-  ), d(
-    y("object", e) || y("function", e),
+  ), assert(
+    isType("object", obj) || isType("function", obj),
     "cannot spyOn on a primitive value"
   );
-  let [s2, r2] = (() => {
-    if (!y("object", t))
-      return [t, "value"];
-    if ("getter" in t && "setter" in t)
+  let [accessName, accessType] = (() => {
+    if (!isType("object", methodName))
+      return [methodName, "value"];
+    if ("getter" in methodName && "setter" in methodName)
       throw new Error("cannot spy on both getter and setter");
-    if ("getter" in t)
-      return [t.getter, "get"];
-    if ("setter" in t)
-      return [t.setter, "set"];
+    if ("getter" in methodName)
+      return [methodName.getter, "get"];
+    if ("setter" in methodName)
+      return [methodName.setter, "set"];
     throw new Error("specify getter or setter to spy on");
-  })(), S = k(e, s2), p3 = Object.getPrototypeOf(e), c = p3 && k(p3, s2), a3 = S || c;
-  d(
-    a3 || s2 in e,
-    `${String(s2)} does not exist`
+  })(), [originalDescriptorObject, originalDescriptor] = getDescriptor(obj, accessName) || [];
+  assert(
+    originalDescriptor || accessName in obj,
+    `${String(accessName)} does not exist`
   );
-  let R = false;
-  r2 === "value" && a3 && !a3.value && a3.get && (r2 = "get", R = true, n = a3.get());
-  let o;
-  a3 ? o = a3[r2] : r2 !== "value" ? o = () => e[s2] : o = e[s2];
-  let g = (v) => {
-    let { value: M, ...h3 } = a3 || {
+  let ssr = false;
+  accessType === "value" && originalDescriptor && !originalDescriptor.value && originalDescriptor.get && (accessType = "get", ssr = true, mock = originalDescriptor.get());
+  let original;
+  originalDescriptor ? original = originalDescriptor[accessType] : accessType !== "value" ? original = () => obj[accessName] : original = obj[accessName], original && isSpyFunction(original) && (original = original[SYMBOL_STATE].getOriginal());
+  let reassign = (cb) => {
+    let { value, ...desc } = originalDescriptor || {
       configurable: true,
       writable: true
     };
-    r2 !== "value" && delete h3.writable, h3[r2] = v, f2(e, s2, h3);
-  }, b = () => a3 ? f2(e, s2, a3) : g(o);
-  n || (n = o);
-  let i = m2(n);
-  r2 === "value" && O(i, o);
-  let I = i[u2];
-  return l(I, "restore", b), l(I, "getOriginal", () => R ? o() : o), l(I, "willCall", (v) => (I.impl = v, i)), g(
-    R ? () => (O(i, n), i) : i
-  ), x.add(i), i;
+    accessType !== "value" && delete desc.writable, desc[accessType] = cb, define(obj, accessName, desc);
+  }, restore = () => {
+    originalDescriptorObject !== obj ? Reflect.deleteProperty(obj, accessName) : originalDescriptor && !original ? define(obj, accessName, originalDescriptor) : reassign(original);
+  };
+  mock || (mock = original);
+  let spy2 = wrap(createInternalSpy(mock), mock);
+  accessType === "value" && setPototype(spy2, original);
+  let state = spy2[SYMBOL_STATE];
+  return defineValue(state, "restore", restore), defineValue(state, "getOriginal", () => ssr ? original() : original), defineValue(state, "willCall", (newCb) => (state.impl = newCb, spy2)), reassign(
+    ssr ? () => (setPototype(spy2, mock), spy2) : spy2
+  ), spies.add(spy2), spy2;
+}
+var ignoreProperties = /* @__PURE__ */ new Set([
+  "length",
+  "name",
+  "prototype"
+]);
+function getAllProperties(original) {
+  let properties = /* @__PURE__ */ new Set(), descriptors2 = {};
+  for (; original && original !== Object.prototype && original !== Function.prototype; ) {
+    let ownProperties = [
+      ...Object.getOwnPropertyNames(original),
+      ...Object.getOwnPropertySymbols(original)
+    ];
+    for (let prop of ownProperties)
+      descriptors2[prop] || ignoreProperties.has(prop) || (properties.add(prop), descriptors2[prop] = Object.getOwnPropertyDescriptor(original, prop));
+    original = Object.getPrototypeOf(original);
+  }
+  return {
+    properties,
+    descriptors: descriptors2
+  };
+}
+function wrap(mock, original) {
+  if (!original || // the original is already a spy, so it has all the properties
+  SYMBOL_STATE in original)
+    return mock;
+  let { properties, descriptors: descriptors2 } = getAllProperties(original);
+  for (let key of properties) {
+    let descriptor = descriptors2[key];
+    getDescriptor(mock, key) || define(mock, key, descriptor);
+  }
+  return mock;
+}
+function isSpyFunction(obj) {
+  return isMockFunction(obj) && "getOriginal" in obj[SYMBOL_STATE];
 }
 
-// ../../node_modules/.pnpm/@vitest+spy@3.1.2/node_modules/@vitest/spy/dist/index.js
+// ../../node_modules/.pnpm/@vitest+spy@3.2.2/node_modules/@vitest/spy/dist/index.js
 var mocks = /* @__PURE__ */ new Set();
-function isMockFunction(fn2) {
+function isMockFunction2(fn2) {
   return typeof fn2 === "function" && "_isMockFunction" in fn2 && fn2._isMockFunction;
 }
 function spyOn(obj, method, accessType) {
@@ -4056,17 +4114,29 @@ function spyOn(obj, method, accessType) {
     set: "setter"
   };
   const objMethod = accessType ? { [dictionary[accessType]]: method } : method;
-  const stub = C2(obj, objMethod);
-  return enhanceSpy(stub);
+  let state;
+  const descriptor = getDescriptor2(obj, method);
+  const fn2 = descriptor && descriptor[accessType || "value"];
+  if (isMockFunction2(fn2)) {
+    state = fn2.mock._state();
+  }
+  const stub = internalSpyOn(obj, objMethod);
+  const spy = enhanceSpy(stub);
+  if (state) {
+    spy.mock._state(state);
+  }
+  return spy;
 }
 var callOrder = 0;
 function enhanceSpy(spy) {
   const stub = spy;
   let implementation;
+  let onceImplementations = [];
+  let implementationChangedTemporarily = false;
   let instances = [];
   let contexts = [];
   let invocations = [];
-  const state = T(spy);
+  const state = getInternalState(spy);
   const mockContext = {
     get calls() {
       return state.calls;
@@ -4100,10 +4170,20 @@ function enhanceSpy(spy) {
     },
     get lastCall() {
       return state.calls[state.calls.length - 1];
+    },
+    _state(state2) {
+      if (state2) {
+        implementation = state2.implementation;
+        onceImplementations = state2.onceImplementations;
+        implementationChangedTemporarily = state2.implementationChangedTemporarily;
+      }
+      return {
+        implementation,
+        onceImplementations,
+        implementationChangedTemporarily
+      };
     }
   };
-  let onceImplementations = [];
-  let implementationChangedTemporarily = false;
   function mockCall(...args) {
     instances.push(this);
     contexts.push(this);
@@ -4136,6 +4216,9 @@ function enhanceSpy(spy) {
     state.restore();
     return stub;
   };
+  if (Symbol.dispose) {
+    stub[Symbol.dispose] = () => stub.mockRestore();
+  }
   stub.getMockImplementation = () => implementationChangedTemporarily ? implementation : onceImplementations.at(0) || implementation;
   stub.mockImplementation = (fn2) => {
     implementation = fn2;
@@ -4151,18 +4234,18 @@ function enhanceSpy(spy) {
     implementation = fn2;
     state.willCall(mockCall);
     implementationChangedTemporarily = true;
-    const reset = () => {
+    const reset2 = () => {
       implementation = originalImplementation;
       implementationChangedTemporarily = false;
     };
     const result = cb();
-    if (result instanceof Promise) {
+    if (typeof result === "object" && result && typeof result.then === "function") {
       return result.then(() => {
-        reset();
+        reset2();
         return stub;
       });
     }
-    reset();
+    reset2();
     return stub;
   }
   stub.withImplementation = withImplementation;
@@ -4181,15 +4264,29 @@ function enhanceSpy(spy) {
   return stub;
 }
 function fn(implementation) {
-  const enhancedSpy = enhanceSpy(C2({ spy: implementation || function() {
+  const enhancedSpy = enhanceSpy(internalSpyOn({ spy: implementation || function() {
   } }, "spy"));
   if (implementation) {
     enhancedSpy.mockImplementation(implementation);
   }
   return enhancedSpy;
 }
+function getDescriptor2(obj, method) {
+  const objDescriptor = Object.getOwnPropertyDescriptor(obj, method);
+  if (objDescriptor) {
+    return objDescriptor;
+  }
+  let currentProto = Object.getPrototypeOf(obj);
+  while (currentProto !== null) {
+    const descriptor = Object.getOwnPropertyDescriptor(currentProto, method);
+    if (descriptor) {
+      return descriptor;
+    }
+    currentProto = Object.getPrototypeOf(currentProto);
+  }
+}
 
-// ../../node_modules/.pnpm/@vitest+utils@3.1.2/node_modules/@vitest/utils/dist/error.js
+// ../../node_modules/.pnpm/@vitest+utils@3.2.2/node_modules/@vitest/utils/dist/error.js
 var IS_RECORD_SYMBOL = "@@__IMMUTABLE_RECORD__@@";
 var IS_COLLECTION_SYMBOL = "@@__IMMUTABLE_ITERABLE__@@";
 function isImmutable(v) {
@@ -4209,6 +4306,24 @@ function serializeValue(val, seen = /* @__PURE__ */ new WeakMap()) {
   if (!val || typeof val === "string") {
     return val;
   }
+  if (val instanceof Error && "toJSON" in val && typeof val.toJSON === "function") {
+    const jsonValue = val.toJSON();
+    if (jsonValue && jsonValue !== val && typeof jsonValue === "object") {
+      if (typeof val.message === "string") {
+        safe(() => jsonValue.message ?? (jsonValue.message = val.message));
+      }
+      if (typeof val.stack === "string") {
+        safe(() => jsonValue.stack ?? (jsonValue.stack = val.stack));
+      }
+      if (typeof val.name === "string") {
+        safe(() => jsonValue.name ?? (jsonValue.name = val.name));
+      }
+      if (val.cause != null) {
+        safe(() => jsonValue.cause ?? (jsonValue.cause = serializeValue(val.cause, seen)));
+      }
+    }
+    return serializeValue(jsonValue, seen);
+  }
   if (typeof val === "function") {
     return `Function<${val.name || "anonymous"}>`;
   }
@@ -4268,6 +4383,12 @@ function serializeValue(val, seen = /* @__PURE__ */ new WeakMap()) {
     return clone2;
   }
 }
+function safe(fn2) {
+  try {
+    return fn2();
+  } catch {
+  }
+}
 function normalizeErrorMessage(message) {
   return message.replace(/__(vite_ssr_import|vi_import)_\d+__\./g, "");
 }
@@ -4276,22 +4397,16 @@ function processError(_err, diffOptions, seen = /* @__PURE__ */ new WeakSet()) {
     return { message: String(_err) };
   }
   const err = _err;
-  if (err.stack) {
-    err.stackStr = String(err.stack);
-  }
-  if (err.name) {
-    err.nameStr = String(err.name);
-  }
   if (err.showDiff || err.showDiff === void 0 && err.expected !== void 0 && err.actual !== void 0) {
     err.diff = printDiffOrStringify(err.actual, err.expected, {
       ...diffOptions,
       ...err.diffOptions
     });
   }
-  if (typeof err.expected !== "string") {
+  if ("expected" in err && typeof err.expected !== "string") {
     err.expected = stringify(err.expected, 10);
   }
-  if (typeof err.actual !== "string") {
+  if ("actual" in err && typeof err.actual !== "string") {
     err.actual = stringify(err.actual, 10);
   }
   try {
@@ -4321,7 +4436,7 @@ __export(chai_exports, {
   Assertion: () => Assertion,
   AssertionError: () => AssertionError,
   Should: () => Should,
-  assert: () => assert,
+  assert: () => assert2,
   config: () => config,
   expect: () => expect,
   should: () => should,
@@ -7107,7 +7222,7 @@ function closeTo(expected, delta, msg) {
       ssfi
     );
   new Assertion(expected, flagMsg, ssfi, true).is.numeric;
-  const abs = /* @__PURE__ */ __name((x2) => x2 < 0n ? -x2 : x2, "abs");
+  const abs = /* @__PURE__ */ __name((x) => x < 0n ? -x : x, "abs");
   const strip = /* @__PURE__ */ __name((number) => parseFloat(parseFloat(number).toPrecision(12)), "strip");
   this.assert(
     strip(abs(obj - expected)) <= delta,
@@ -7519,12 +7634,12 @@ function loadShould() {
 __name(loadShould, "loadShould");
 var should = loadShould;
 var Should = loadShould;
-function assert(express, errmsg) {
-  var test22 = new Assertion(null, null, assert, true);
+function assert2(express, errmsg) {
+  var test22 = new Assertion(null, null, assert2, true);
   test22.assert(express, errmsg, "[ negation message unavailable ]");
 }
-__name(assert, "assert");
-assert.fail = function(actual, expected, message, operator) {
+__name(assert2, "assert");
+assert2.fail = function(actual, expected, message, operator) {
   if (arguments.length < 2) {
     message = actual;
     actual = void 0;
@@ -7537,17 +7652,17 @@ assert.fail = function(actual, expected, message, operator) {
       expected,
       operator
     },
-    assert.fail
+    assert2.fail
   );
 };
-assert.isOk = function(val, msg) {
-  new Assertion(val, msg, assert.isOk, true).is.ok;
+assert2.isOk = function(val, msg) {
+  new Assertion(val, msg, assert2.isOk, true).is.ok;
 };
-assert.isNotOk = function(val, msg) {
-  new Assertion(val, msg, assert.isNotOk, true).is.not.ok;
+assert2.isNotOk = function(val, msg) {
+  new Assertion(val, msg, assert2.isNotOk, true).is.not.ok;
 };
-assert.equal = function(act, exp, msg) {
-  var test22 = new Assertion(act, msg, assert.equal, true);
+assert2.equal = function(act, exp, msg) {
+  var test22 = new Assertion(act, msg, assert2.equal, true);
   test22.assert(
     exp == flag(test22, "object"),
     "expected #{this} to equal #{exp}",
@@ -7557,8 +7672,8 @@ assert.equal = function(act, exp, msg) {
     true
   );
 };
-assert.notEqual = function(act, exp, msg) {
-  var test22 = new Assertion(act, msg, assert.notEqual, true);
+assert2.notEqual = function(act, exp, msg) {
+  var test22 = new Assertion(act, msg, assert2.notEqual, true);
   test22.assert(
     exp != flag(test22, "object"),
     "expected #{this} to not equal #{exp}",
@@ -7568,370 +7683,370 @@ assert.notEqual = function(act, exp, msg) {
     true
   );
 };
-assert.strictEqual = function(act, exp, msg) {
-  new Assertion(act, msg, assert.strictEqual, true).to.equal(exp);
+assert2.strictEqual = function(act, exp, msg) {
+  new Assertion(act, msg, assert2.strictEqual, true).to.equal(exp);
 };
-assert.notStrictEqual = function(act, exp, msg) {
-  new Assertion(act, msg, assert.notStrictEqual, true).to.not.equal(exp);
+assert2.notStrictEqual = function(act, exp, msg) {
+  new Assertion(act, msg, assert2.notStrictEqual, true).to.not.equal(exp);
 };
-assert.deepEqual = assert.deepStrictEqual = function(act, exp, msg) {
-  new Assertion(act, msg, assert.deepEqual, true).to.eql(exp);
+assert2.deepEqual = assert2.deepStrictEqual = function(act, exp, msg) {
+  new Assertion(act, msg, assert2.deepEqual, true).to.eql(exp);
 };
-assert.notDeepEqual = function(act, exp, msg) {
-  new Assertion(act, msg, assert.notDeepEqual, true).to.not.eql(exp);
+assert2.notDeepEqual = function(act, exp, msg) {
+  new Assertion(act, msg, assert2.notDeepEqual, true).to.not.eql(exp);
 };
-assert.isAbove = function(val, abv, msg) {
-  new Assertion(val, msg, assert.isAbove, true).to.be.above(abv);
+assert2.isAbove = function(val, abv, msg) {
+  new Assertion(val, msg, assert2.isAbove, true).to.be.above(abv);
 };
-assert.isAtLeast = function(val, atlst, msg) {
-  new Assertion(val, msg, assert.isAtLeast, true).to.be.least(atlst);
+assert2.isAtLeast = function(val, atlst, msg) {
+  new Assertion(val, msg, assert2.isAtLeast, true).to.be.least(atlst);
 };
-assert.isBelow = function(val, blw, msg) {
-  new Assertion(val, msg, assert.isBelow, true).to.be.below(blw);
+assert2.isBelow = function(val, blw, msg) {
+  new Assertion(val, msg, assert2.isBelow, true).to.be.below(blw);
 };
-assert.isAtMost = function(val, atmst, msg) {
-  new Assertion(val, msg, assert.isAtMost, true).to.be.most(atmst);
+assert2.isAtMost = function(val, atmst, msg) {
+  new Assertion(val, msg, assert2.isAtMost, true).to.be.most(atmst);
 };
-assert.isTrue = function(val, msg) {
-  new Assertion(val, msg, assert.isTrue, true).is["true"];
+assert2.isTrue = function(val, msg) {
+  new Assertion(val, msg, assert2.isTrue, true).is["true"];
 };
-assert.isNotTrue = function(val, msg) {
-  new Assertion(val, msg, assert.isNotTrue, true).to.not.equal(true);
+assert2.isNotTrue = function(val, msg) {
+  new Assertion(val, msg, assert2.isNotTrue, true).to.not.equal(true);
 };
-assert.isFalse = function(val, msg) {
-  new Assertion(val, msg, assert.isFalse, true).is["false"];
+assert2.isFalse = function(val, msg) {
+  new Assertion(val, msg, assert2.isFalse, true).is["false"];
 };
-assert.isNotFalse = function(val, msg) {
-  new Assertion(val, msg, assert.isNotFalse, true).to.not.equal(false);
+assert2.isNotFalse = function(val, msg) {
+  new Assertion(val, msg, assert2.isNotFalse, true).to.not.equal(false);
 };
-assert.isNull = function(val, msg) {
-  new Assertion(val, msg, assert.isNull, true).to.equal(null);
+assert2.isNull = function(val, msg) {
+  new Assertion(val, msg, assert2.isNull, true).to.equal(null);
 };
-assert.isNotNull = function(val, msg) {
-  new Assertion(val, msg, assert.isNotNull, true).to.not.equal(null);
+assert2.isNotNull = function(val, msg) {
+  new Assertion(val, msg, assert2.isNotNull, true).to.not.equal(null);
 };
-assert.isNaN = function(val, msg) {
-  new Assertion(val, msg, assert.isNaN, true).to.be.NaN;
+assert2.isNaN = function(val, msg) {
+  new Assertion(val, msg, assert2.isNaN, true).to.be.NaN;
 };
-assert.isNotNaN = function(value, message) {
-  new Assertion(value, message, assert.isNotNaN, true).not.to.be.NaN;
+assert2.isNotNaN = function(value, message) {
+  new Assertion(value, message, assert2.isNotNaN, true).not.to.be.NaN;
 };
-assert.exists = function(val, msg) {
-  new Assertion(val, msg, assert.exists, true).to.exist;
+assert2.exists = function(val, msg) {
+  new Assertion(val, msg, assert2.exists, true).to.exist;
 };
-assert.notExists = function(val, msg) {
-  new Assertion(val, msg, assert.notExists, true).to.not.exist;
+assert2.notExists = function(val, msg) {
+  new Assertion(val, msg, assert2.notExists, true).to.not.exist;
 };
-assert.isUndefined = function(val, msg) {
-  new Assertion(val, msg, assert.isUndefined, true).to.equal(void 0);
+assert2.isUndefined = function(val, msg) {
+  new Assertion(val, msg, assert2.isUndefined, true).to.equal(void 0);
 };
-assert.isDefined = function(val, msg) {
-  new Assertion(val, msg, assert.isDefined, true).to.not.equal(void 0);
+assert2.isDefined = function(val, msg) {
+  new Assertion(val, msg, assert2.isDefined, true).to.not.equal(void 0);
 };
-assert.isCallable = function(value, message) {
-  new Assertion(value, message, assert.isCallable, true).is.callable;
+assert2.isCallable = function(value, message) {
+  new Assertion(value, message, assert2.isCallable, true).is.callable;
 };
-assert.isNotCallable = function(value, message) {
-  new Assertion(value, message, assert.isNotCallable, true).is.not.callable;
+assert2.isNotCallable = function(value, message) {
+  new Assertion(value, message, assert2.isNotCallable, true).is.not.callable;
 };
-assert.isObject = function(val, msg) {
-  new Assertion(val, msg, assert.isObject, true).to.be.a("object");
+assert2.isObject = function(val, msg) {
+  new Assertion(val, msg, assert2.isObject, true).to.be.a("object");
 };
-assert.isNotObject = function(val, msg) {
-  new Assertion(val, msg, assert.isNotObject, true).to.not.be.a("object");
+assert2.isNotObject = function(val, msg) {
+  new Assertion(val, msg, assert2.isNotObject, true).to.not.be.a("object");
 };
-assert.isArray = function(val, msg) {
-  new Assertion(val, msg, assert.isArray, true).to.be.an("array");
+assert2.isArray = function(val, msg) {
+  new Assertion(val, msg, assert2.isArray, true).to.be.an("array");
 };
-assert.isNotArray = function(val, msg) {
-  new Assertion(val, msg, assert.isNotArray, true).to.not.be.an("array");
+assert2.isNotArray = function(val, msg) {
+  new Assertion(val, msg, assert2.isNotArray, true).to.not.be.an("array");
 };
-assert.isString = function(val, msg) {
-  new Assertion(val, msg, assert.isString, true).to.be.a("string");
+assert2.isString = function(val, msg) {
+  new Assertion(val, msg, assert2.isString, true).to.be.a("string");
 };
-assert.isNotString = function(val, msg) {
-  new Assertion(val, msg, assert.isNotString, true).to.not.be.a("string");
+assert2.isNotString = function(val, msg) {
+  new Assertion(val, msg, assert2.isNotString, true).to.not.be.a("string");
 };
-assert.isNumber = function(val, msg) {
-  new Assertion(val, msg, assert.isNumber, true).to.be.a("number");
+assert2.isNumber = function(val, msg) {
+  new Assertion(val, msg, assert2.isNumber, true).to.be.a("number");
 };
-assert.isNotNumber = function(val, msg) {
-  new Assertion(val, msg, assert.isNotNumber, true).to.not.be.a("number");
+assert2.isNotNumber = function(val, msg) {
+  new Assertion(val, msg, assert2.isNotNumber, true).to.not.be.a("number");
 };
-assert.isNumeric = function(val, msg) {
-  new Assertion(val, msg, assert.isNumeric, true).is.numeric;
+assert2.isNumeric = function(val, msg) {
+  new Assertion(val, msg, assert2.isNumeric, true).is.numeric;
 };
-assert.isNotNumeric = function(val, msg) {
-  new Assertion(val, msg, assert.isNotNumeric, true).is.not.numeric;
+assert2.isNotNumeric = function(val, msg) {
+  new Assertion(val, msg, assert2.isNotNumeric, true).is.not.numeric;
 };
-assert.isFinite = function(val, msg) {
-  new Assertion(val, msg, assert.isFinite, true).to.be.finite;
+assert2.isFinite = function(val, msg) {
+  new Assertion(val, msg, assert2.isFinite, true).to.be.finite;
 };
-assert.isBoolean = function(val, msg) {
-  new Assertion(val, msg, assert.isBoolean, true).to.be.a("boolean");
+assert2.isBoolean = function(val, msg) {
+  new Assertion(val, msg, assert2.isBoolean, true).to.be.a("boolean");
 };
-assert.isNotBoolean = function(val, msg) {
-  new Assertion(val, msg, assert.isNotBoolean, true).to.not.be.a("boolean");
+assert2.isNotBoolean = function(val, msg) {
+  new Assertion(val, msg, assert2.isNotBoolean, true).to.not.be.a("boolean");
 };
-assert.typeOf = function(val, type3, msg) {
-  new Assertion(val, msg, assert.typeOf, true).to.be.a(type3);
+assert2.typeOf = function(val, type3, msg) {
+  new Assertion(val, msg, assert2.typeOf, true).to.be.a(type3);
 };
-assert.notTypeOf = function(value, type3, message) {
-  new Assertion(value, message, assert.notTypeOf, true).to.not.be.a(type3);
+assert2.notTypeOf = function(value, type3, message) {
+  new Assertion(value, message, assert2.notTypeOf, true).to.not.be.a(type3);
 };
-assert.instanceOf = function(val, type3, msg) {
-  new Assertion(val, msg, assert.instanceOf, true).to.be.instanceOf(type3);
+assert2.instanceOf = function(val, type3, msg) {
+  new Assertion(val, msg, assert2.instanceOf, true).to.be.instanceOf(type3);
 };
-assert.notInstanceOf = function(val, type3, msg) {
-  new Assertion(val, msg, assert.notInstanceOf, true).to.not.be.instanceOf(
+assert2.notInstanceOf = function(val, type3, msg) {
+  new Assertion(val, msg, assert2.notInstanceOf, true).to.not.be.instanceOf(
     type3
   );
 };
-assert.include = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.include, true).include(inc);
+assert2.include = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert2.include, true).include(inc);
 };
-assert.notInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.notInclude, true).not.include(inc);
+assert2.notInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert2.notInclude, true).not.include(inc);
 };
-assert.deepInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.deepInclude, true).deep.include(inc);
+assert2.deepInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert2.deepInclude, true).deep.include(inc);
 };
-assert.notDeepInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.notDeepInclude, true).not.deep.include(inc);
+assert2.notDeepInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert2.notDeepInclude, true).not.deep.include(inc);
 };
-assert.nestedInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.nestedInclude, true).nested.include(inc);
+assert2.nestedInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert2.nestedInclude, true).nested.include(inc);
 };
-assert.notNestedInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.notNestedInclude, true).not.nested.include(
+assert2.notNestedInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert2.notNestedInclude, true).not.nested.include(
     inc
   );
 };
-assert.deepNestedInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.deepNestedInclude, true).deep.nested.include(
+assert2.deepNestedInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert2.deepNestedInclude, true).deep.nested.include(
     inc
   );
 };
-assert.notDeepNestedInclude = function(exp, inc, msg) {
+assert2.notDeepNestedInclude = function(exp, inc, msg) {
   new Assertion(
     exp,
     msg,
-    assert.notDeepNestedInclude,
+    assert2.notDeepNestedInclude,
     true
   ).not.deep.nested.include(inc);
 };
-assert.ownInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.ownInclude, true).own.include(inc);
+assert2.ownInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert2.ownInclude, true).own.include(inc);
 };
-assert.notOwnInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.notOwnInclude, true).not.own.include(inc);
+assert2.notOwnInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert2.notOwnInclude, true).not.own.include(inc);
 };
-assert.deepOwnInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.deepOwnInclude, true).deep.own.include(inc);
+assert2.deepOwnInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert2.deepOwnInclude, true).deep.own.include(inc);
 };
-assert.notDeepOwnInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.notDeepOwnInclude, true).not.deep.own.include(
+assert2.notDeepOwnInclude = function(exp, inc, msg) {
+  new Assertion(exp, msg, assert2.notDeepOwnInclude, true).not.deep.own.include(
     inc
   );
 };
-assert.match = function(exp, re, msg) {
-  new Assertion(exp, msg, assert.match, true).to.match(re);
+assert2.match = function(exp, re, msg) {
+  new Assertion(exp, msg, assert2.match, true).to.match(re);
 };
-assert.notMatch = function(exp, re, msg) {
-  new Assertion(exp, msg, assert.notMatch, true).to.not.match(re);
+assert2.notMatch = function(exp, re, msg) {
+  new Assertion(exp, msg, assert2.notMatch, true).to.not.match(re);
 };
-assert.property = function(obj, prop, msg) {
-  new Assertion(obj, msg, assert.property, true).to.have.property(prop);
+assert2.property = function(obj, prop, msg) {
+  new Assertion(obj, msg, assert2.property, true).to.have.property(prop);
 };
-assert.notProperty = function(obj, prop, msg) {
-  new Assertion(obj, msg, assert.notProperty, true).to.not.have.property(prop);
+assert2.notProperty = function(obj, prop, msg) {
+  new Assertion(obj, msg, assert2.notProperty, true).to.not.have.property(prop);
 };
-assert.propertyVal = function(obj, prop, val, msg) {
-  new Assertion(obj, msg, assert.propertyVal, true).to.have.property(prop, val);
+assert2.propertyVal = function(obj, prop, val, msg) {
+  new Assertion(obj, msg, assert2.propertyVal, true).to.have.property(prop, val);
 };
-assert.notPropertyVal = function(obj, prop, val, msg) {
-  new Assertion(obj, msg, assert.notPropertyVal, true).to.not.have.property(
+assert2.notPropertyVal = function(obj, prop, val, msg) {
+  new Assertion(obj, msg, assert2.notPropertyVal, true).to.not.have.property(
     prop,
     val
   );
 };
-assert.deepPropertyVal = function(obj, prop, val, msg) {
-  new Assertion(obj, msg, assert.deepPropertyVal, true).to.have.deep.property(
+assert2.deepPropertyVal = function(obj, prop, val, msg) {
+  new Assertion(obj, msg, assert2.deepPropertyVal, true).to.have.deep.property(
     prop,
     val
   );
 };
-assert.notDeepPropertyVal = function(obj, prop, val, msg) {
+assert2.notDeepPropertyVal = function(obj, prop, val, msg) {
   new Assertion(
     obj,
     msg,
-    assert.notDeepPropertyVal,
+    assert2.notDeepPropertyVal,
     true
   ).to.not.have.deep.property(prop, val);
 };
-assert.ownProperty = function(obj, prop, msg) {
-  new Assertion(obj, msg, assert.ownProperty, true).to.have.own.property(prop);
+assert2.ownProperty = function(obj, prop, msg) {
+  new Assertion(obj, msg, assert2.ownProperty, true).to.have.own.property(prop);
 };
-assert.notOwnProperty = function(obj, prop, msg) {
-  new Assertion(obj, msg, assert.notOwnProperty, true).to.not.have.own.property(
+assert2.notOwnProperty = function(obj, prop, msg) {
+  new Assertion(obj, msg, assert2.notOwnProperty, true).to.not.have.own.property(
     prop
   );
 };
-assert.ownPropertyVal = function(obj, prop, value, msg) {
-  new Assertion(obj, msg, assert.ownPropertyVal, true).to.have.own.property(
+assert2.ownPropertyVal = function(obj, prop, value, msg) {
+  new Assertion(obj, msg, assert2.ownPropertyVal, true).to.have.own.property(
     prop,
     value
   );
 };
-assert.notOwnPropertyVal = function(obj, prop, value, msg) {
+assert2.notOwnPropertyVal = function(obj, prop, value, msg) {
   new Assertion(
     obj,
     msg,
-    assert.notOwnPropertyVal,
+    assert2.notOwnPropertyVal,
     true
   ).to.not.have.own.property(prop, value);
 };
-assert.deepOwnPropertyVal = function(obj, prop, value, msg) {
+assert2.deepOwnPropertyVal = function(obj, prop, value, msg) {
   new Assertion(
     obj,
     msg,
-    assert.deepOwnPropertyVal,
+    assert2.deepOwnPropertyVal,
     true
   ).to.have.deep.own.property(prop, value);
 };
-assert.notDeepOwnPropertyVal = function(obj, prop, value, msg) {
+assert2.notDeepOwnPropertyVal = function(obj, prop, value, msg) {
   new Assertion(
     obj,
     msg,
-    assert.notDeepOwnPropertyVal,
+    assert2.notDeepOwnPropertyVal,
     true
   ).to.not.have.deep.own.property(prop, value);
 };
-assert.nestedProperty = function(obj, prop, msg) {
-  new Assertion(obj, msg, assert.nestedProperty, true).to.have.nested.property(
+assert2.nestedProperty = function(obj, prop, msg) {
+  new Assertion(obj, msg, assert2.nestedProperty, true).to.have.nested.property(
     prop
   );
 };
-assert.notNestedProperty = function(obj, prop, msg) {
+assert2.notNestedProperty = function(obj, prop, msg) {
   new Assertion(
     obj,
     msg,
-    assert.notNestedProperty,
+    assert2.notNestedProperty,
     true
   ).to.not.have.nested.property(prop);
 };
-assert.nestedPropertyVal = function(obj, prop, val, msg) {
+assert2.nestedPropertyVal = function(obj, prop, val, msg) {
   new Assertion(
     obj,
     msg,
-    assert.nestedPropertyVal,
+    assert2.nestedPropertyVal,
     true
   ).to.have.nested.property(prop, val);
 };
-assert.notNestedPropertyVal = function(obj, prop, val, msg) {
+assert2.notNestedPropertyVal = function(obj, prop, val, msg) {
   new Assertion(
     obj,
     msg,
-    assert.notNestedPropertyVal,
+    assert2.notNestedPropertyVal,
     true
   ).to.not.have.nested.property(prop, val);
 };
-assert.deepNestedPropertyVal = function(obj, prop, val, msg) {
+assert2.deepNestedPropertyVal = function(obj, prop, val, msg) {
   new Assertion(
     obj,
     msg,
-    assert.deepNestedPropertyVal,
+    assert2.deepNestedPropertyVal,
     true
   ).to.have.deep.nested.property(prop, val);
 };
-assert.notDeepNestedPropertyVal = function(obj, prop, val, msg) {
+assert2.notDeepNestedPropertyVal = function(obj, prop, val, msg) {
   new Assertion(
     obj,
     msg,
-    assert.notDeepNestedPropertyVal,
+    assert2.notDeepNestedPropertyVal,
     true
   ).to.not.have.deep.nested.property(prop, val);
 };
-assert.lengthOf = function(exp, len, msg) {
-  new Assertion(exp, msg, assert.lengthOf, true).to.have.lengthOf(len);
+assert2.lengthOf = function(exp, len, msg) {
+  new Assertion(exp, msg, assert2.lengthOf, true).to.have.lengthOf(len);
 };
-assert.hasAnyKeys = function(obj, keys2, msg) {
-  new Assertion(obj, msg, assert.hasAnyKeys, true).to.have.any.keys(keys2);
+assert2.hasAnyKeys = function(obj, keys2, msg) {
+  new Assertion(obj, msg, assert2.hasAnyKeys, true).to.have.any.keys(keys2);
 };
-assert.hasAllKeys = function(obj, keys2, msg) {
-  new Assertion(obj, msg, assert.hasAllKeys, true).to.have.all.keys(keys2);
+assert2.hasAllKeys = function(obj, keys2, msg) {
+  new Assertion(obj, msg, assert2.hasAllKeys, true).to.have.all.keys(keys2);
 };
-assert.containsAllKeys = function(obj, keys2, msg) {
-  new Assertion(obj, msg, assert.containsAllKeys, true).to.contain.all.keys(
+assert2.containsAllKeys = function(obj, keys2, msg) {
+  new Assertion(obj, msg, assert2.containsAllKeys, true).to.contain.all.keys(
     keys2
   );
 };
-assert.doesNotHaveAnyKeys = function(obj, keys2, msg) {
-  new Assertion(obj, msg, assert.doesNotHaveAnyKeys, true).to.not.have.any.keys(
+assert2.doesNotHaveAnyKeys = function(obj, keys2, msg) {
+  new Assertion(obj, msg, assert2.doesNotHaveAnyKeys, true).to.not.have.any.keys(
     keys2
   );
 };
-assert.doesNotHaveAllKeys = function(obj, keys2, msg) {
-  new Assertion(obj, msg, assert.doesNotHaveAllKeys, true).to.not.have.all.keys(
+assert2.doesNotHaveAllKeys = function(obj, keys2, msg) {
+  new Assertion(obj, msg, assert2.doesNotHaveAllKeys, true).to.not.have.all.keys(
     keys2
   );
 };
-assert.hasAnyDeepKeys = function(obj, keys2, msg) {
-  new Assertion(obj, msg, assert.hasAnyDeepKeys, true).to.have.any.deep.keys(
+assert2.hasAnyDeepKeys = function(obj, keys2, msg) {
+  new Assertion(obj, msg, assert2.hasAnyDeepKeys, true).to.have.any.deep.keys(
     keys2
   );
 };
-assert.hasAllDeepKeys = function(obj, keys2, msg) {
-  new Assertion(obj, msg, assert.hasAllDeepKeys, true).to.have.all.deep.keys(
+assert2.hasAllDeepKeys = function(obj, keys2, msg) {
+  new Assertion(obj, msg, assert2.hasAllDeepKeys, true).to.have.all.deep.keys(
     keys2
   );
 };
-assert.containsAllDeepKeys = function(obj, keys2, msg) {
+assert2.containsAllDeepKeys = function(obj, keys2, msg) {
   new Assertion(
     obj,
     msg,
-    assert.containsAllDeepKeys,
+    assert2.containsAllDeepKeys,
     true
   ).to.contain.all.deep.keys(keys2);
 };
-assert.doesNotHaveAnyDeepKeys = function(obj, keys2, msg) {
+assert2.doesNotHaveAnyDeepKeys = function(obj, keys2, msg) {
   new Assertion(
     obj,
     msg,
-    assert.doesNotHaveAnyDeepKeys,
+    assert2.doesNotHaveAnyDeepKeys,
     true
   ).to.not.have.any.deep.keys(keys2);
 };
-assert.doesNotHaveAllDeepKeys = function(obj, keys2, msg) {
+assert2.doesNotHaveAllDeepKeys = function(obj, keys2, msg) {
   new Assertion(
     obj,
     msg,
-    assert.doesNotHaveAllDeepKeys,
+    assert2.doesNotHaveAllDeepKeys,
     true
   ).to.not.have.all.deep.keys(keys2);
 };
-assert.throws = function(fn2, errorLike, errMsgMatcher, msg) {
+assert2.throws = function(fn2, errorLike, errMsgMatcher, msg) {
   if ("string" === typeof errorLike || errorLike instanceof RegExp) {
     errMsgMatcher = errorLike;
     errorLike = null;
   }
-  var assertErr = new Assertion(fn2, msg, assert.throws, true).to.throw(
+  var assertErr = new Assertion(fn2, msg, assert2.throws, true).to.throw(
     errorLike,
     errMsgMatcher
   );
   return flag(assertErr, "object");
 };
-assert.doesNotThrow = function(fn2, errorLike, errMsgMatcher, message) {
+assert2.doesNotThrow = function(fn2, errorLike, errMsgMatcher, message) {
   if ("string" === typeof errorLike || errorLike instanceof RegExp) {
     errMsgMatcher = errorLike;
     errorLike = null;
   }
-  new Assertion(fn2, message, assert.doesNotThrow, true).to.not.throw(
+  new Assertion(fn2, message, assert2.doesNotThrow, true).to.not.throw(
     errorLike,
     errMsgMatcher
   );
 };
-assert.operator = function(val, operator, val2, msg) {
+assert2.operator = function(val, operator, val2, msg) {
   var ok;
   switch (operator) {
     case "==":
@@ -7963,162 +8078,162 @@ assert.operator = function(val, operator, val2, msg) {
       throw new AssertionError(
         msg + 'Invalid operator "' + operator + '"',
         void 0,
-        assert.operator
+        assert2.operator
       );
   }
-  var test22 = new Assertion(ok, msg, assert.operator, true);
+  var test22 = new Assertion(ok, msg, assert2.operator, true);
   test22.assert(
     true === flag(test22, "object"),
     "expected " + inspect22(val) + " to be " + operator + " " + inspect22(val2),
     "expected " + inspect22(val) + " to not be " + operator + " " + inspect22(val2)
   );
 };
-assert.closeTo = function(act, exp, delta, msg) {
-  new Assertion(act, msg, assert.closeTo, true).to.be.closeTo(exp, delta);
+assert2.closeTo = function(act, exp, delta, msg) {
+  new Assertion(act, msg, assert2.closeTo, true).to.be.closeTo(exp, delta);
 };
-assert.approximately = function(act, exp, delta, msg) {
-  new Assertion(act, msg, assert.approximately, true).to.be.approximately(
+assert2.approximately = function(act, exp, delta, msg) {
+  new Assertion(act, msg, assert2.approximately, true).to.be.approximately(
     exp,
     delta
   );
 };
-assert.sameMembers = function(set1, set22, msg) {
-  new Assertion(set1, msg, assert.sameMembers, true).to.have.same.members(set22);
+assert2.sameMembers = function(set1, set22, msg) {
+  new Assertion(set1, msg, assert2.sameMembers, true).to.have.same.members(set22);
 };
-assert.notSameMembers = function(set1, set22, msg) {
+assert2.notSameMembers = function(set1, set22, msg) {
   new Assertion(
     set1,
     msg,
-    assert.notSameMembers,
+    assert2.notSameMembers,
     true
   ).to.not.have.same.members(set22);
 };
-assert.sameDeepMembers = function(set1, set22, msg) {
+assert2.sameDeepMembers = function(set1, set22, msg) {
   new Assertion(
     set1,
     msg,
-    assert.sameDeepMembers,
+    assert2.sameDeepMembers,
     true
   ).to.have.same.deep.members(set22);
 };
-assert.notSameDeepMembers = function(set1, set22, msg) {
+assert2.notSameDeepMembers = function(set1, set22, msg) {
   new Assertion(
     set1,
     msg,
-    assert.notSameDeepMembers,
+    assert2.notSameDeepMembers,
     true
   ).to.not.have.same.deep.members(set22);
 };
-assert.sameOrderedMembers = function(set1, set22, msg) {
+assert2.sameOrderedMembers = function(set1, set22, msg) {
   new Assertion(
     set1,
     msg,
-    assert.sameOrderedMembers,
+    assert2.sameOrderedMembers,
     true
   ).to.have.same.ordered.members(set22);
 };
-assert.notSameOrderedMembers = function(set1, set22, msg) {
+assert2.notSameOrderedMembers = function(set1, set22, msg) {
   new Assertion(
     set1,
     msg,
-    assert.notSameOrderedMembers,
+    assert2.notSameOrderedMembers,
     true
   ).to.not.have.same.ordered.members(set22);
 };
-assert.sameDeepOrderedMembers = function(set1, set22, msg) {
+assert2.sameDeepOrderedMembers = function(set1, set22, msg) {
   new Assertion(
     set1,
     msg,
-    assert.sameDeepOrderedMembers,
+    assert2.sameDeepOrderedMembers,
     true
   ).to.have.same.deep.ordered.members(set22);
 };
-assert.notSameDeepOrderedMembers = function(set1, set22, msg) {
+assert2.notSameDeepOrderedMembers = function(set1, set22, msg) {
   new Assertion(
     set1,
     msg,
-    assert.notSameDeepOrderedMembers,
+    assert2.notSameDeepOrderedMembers,
     true
   ).to.not.have.same.deep.ordered.members(set22);
 };
-assert.includeMembers = function(superset, subset, msg) {
-  new Assertion(superset, msg, assert.includeMembers, true).to.include.members(
+assert2.includeMembers = function(superset, subset, msg) {
+  new Assertion(superset, msg, assert2.includeMembers, true).to.include.members(
     subset
   );
 };
-assert.notIncludeMembers = function(superset, subset, msg) {
+assert2.notIncludeMembers = function(superset, subset, msg) {
   new Assertion(
     superset,
     msg,
-    assert.notIncludeMembers,
+    assert2.notIncludeMembers,
     true
   ).to.not.include.members(subset);
 };
-assert.includeDeepMembers = function(superset, subset, msg) {
+assert2.includeDeepMembers = function(superset, subset, msg) {
   new Assertion(
     superset,
     msg,
-    assert.includeDeepMembers,
+    assert2.includeDeepMembers,
     true
   ).to.include.deep.members(subset);
 };
-assert.notIncludeDeepMembers = function(superset, subset, msg) {
+assert2.notIncludeDeepMembers = function(superset, subset, msg) {
   new Assertion(
     superset,
     msg,
-    assert.notIncludeDeepMembers,
+    assert2.notIncludeDeepMembers,
     true
   ).to.not.include.deep.members(subset);
 };
-assert.includeOrderedMembers = function(superset, subset, msg) {
+assert2.includeOrderedMembers = function(superset, subset, msg) {
   new Assertion(
     superset,
     msg,
-    assert.includeOrderedMembers,
+    assert2.includeOrderedMembers,
     true
   ).to.include.ordered.members(subset);
 };
-assert.notIncludeOrderedMembers = function(superset, subset, msg) {
+assert2.notIncludeOrderedMembers = function(superset, subset, msg) {
   new Assertion(
     superset,
     msg,
-    assert.notIncludeOrderedMembers,
+    assert2.notIncludeOrderedMembers,
     true
   ).to.not.include.ordered.members(subset);
 };
-assert.includeDeepOrderedMembers = function(superset, subset, msg) {
+assert2.includeDeepOrderedMembers = function(superset, subset, msg) {
   new Assertion(
     superset,
     msg,
-    assert.includeDeepOrderedMembers,
+    assert2.includeDeepOrderedMembers,
     true
   ).to.include.deep.ordered.members(subset);
 };
-assert.notIncludeDeepOrderedMembers = function(superset, subset, msg) {
+assert2.notIncludeDeepOrderedMembers = function(superset, subset, msg) {
   new Assertion(
     superset,
     msg,
-    assert.notIncludeDeepOrderedMembers,
+    assert2.notIncludeDeepOrderedMembers,
     true
   ).to.not.include.deep.ordered.members(subset);
 };
-assert.oneOf = function(inList, list, msg) {
-  new Assertion(inList, msg, assert.oneOf, true).to.be.oneOf(list);
+assert2.oneOf = function(inList, list, msg) {
+  new Assertion(inList, msg, assert2.oneOf, true).to.be.oneOf(list);
 };
-assert.isIterable = function(obj, msg) {
+assert2.isIterable = function(obj, msg) {
   if (obj == void 0 || !obj[Symbol.iterator]) {
     msg = msg ? `${msg} expected ${inspect22(obj)} to be an iterable` : `expected ${inspect22(obj)} to be an iterable`;
-    throw new AssertionError(msg, void 0, assert.isIterable);
+    throw new AssertionError(msg, void 0, assert2.isIterable);
   }
 };
-assert.changes = function(fn2, obj, prop, msg) {
+assert2.changes = function(fn2, obj, prop, msg) {
   if (arguments.length === 3 && typeof obj === "function") {
     msg = prop;
     prop = null;
   }
-  new Assertion(fn2, msg, assert.changes, true).to.change(obj, prop);
+  new Assertion(fn2, msg, assert2.changes, true).to.change(obj, prop);
 };
-assert.changesBy = function(fn2, obj, prop, delta, msg) {
+assert2.changesBy = function(fn2, obj, prop, delta, msg) {
   if (arguments.length === 4 && typeof obj === "function") {
     var tmpMsg = delta;
     delta = prop;
@@ -8127,19 +8242,19 @@ assert.changesBy = function(fn2, obj, prop, delta, msg) {
     delta = prop;
     prop = null;
   }
-  new Assertion(fn2, msg, assert.changesBy, true).to.change(obj, prop).by(delta);
+  new Assertion(fn2, msg, assert2.changesBy, true).to.change(obj, prop).by(delta);
 };
-assert.doesNotChange = function(fn2, obj, prop, msg) {
+assert2.doesNotChange = function(fn2, obj, prop, msg) {
   if (arguments.length === 3 && typeof obj === "function") {
     msg = prop;
     prop = null;
   }
-  return new Assertion(fn2, msg, assert.doesNotChange, true).to.not.change(
+  return new Assertion(fn2, msg, assert2.doesNotChange, true).to.not.change(
     obj,
     prop
   );
 };
-assert.changesButNotBy = function(fn2, obj, prop, delta, msg) {
+assert2.changesButNotBy = function(fn2, obj, prop, delta, msg) {
   if (arguments.length === 4 && typeof obj === "function") {
     var tmpMsg = delta;
     delta = prop;
@@ -8148,16 +8263,16 @@ assert.changesButNotBy = function(fn2, obj, prop, delta, msg) {
     delta = prop;
     prop = null;
   }
-  new Assertion(fn2, msg, assert.changesButNotBy, true).to.change(obj, prop).but.not.by(delta);
+  new Assertion(fn2, msg, assert2.changesButNotBy, true).to.change(obj, prop).but.not.by(delta);
 };
-assert.increases = function(fn2, obj, prop, msg) {
+assert2.increases = function(fn2, obj, prop, msg) {
   if (arguments.length === 3 && typeof obj === "function") {
     msg = prop;
     prop = null;
   }
-  return new Assertion(fn2, msg, assert.increases, true).to.increase(obj, prop);
+  return new Assertion(fn2, msg, assert2.increases, true).to.increase(obj, prop);
 };
-assert.increasesBy = function(fn2, obj, prop, delta, msg) {
+assert2.increasesBy = function(fn2, obj, prop, delta, msg) {
   if (arguments.length === 4 && typeof obj === "function") {
     var tmpMsg = delta;
     delta = prop;
@@ -8166,19 +8281,19 @@ assert.increasesBy = function(fn2, obj, prop, delta, msg) {
     delta = prop;
     prop = null;
   }
-  new Assertion(fn2, msg, assert.increasesBy, true).to.increase(obj, prop).by(delta);
+  new Assertion(fn2, msg, assert2.increasesBy, true).to.increase(obj, prop).by(delta);
 };
-assert.doesNotIncrease = function(fn2, obj, prop, msg) {
+assert2.doesNotIncrease = function(fn2, obj, prop, msg) {
   if (arguments.length === 3 && typeof obj === "function") {
     msg = prop;
     prop = null;
   }
-  return new Assertion(fn2, msg, assert.doesNotIncrease, true).to.not.increase(
+  return new Assertion(fn2, msg, assert2.doesNotIncrease, true).to.not.increase(
     obj,
     prop
   );
 };
-assert.increasesButNotBy = function(fn2, obj, prop, delta, msg) {
+assert2.increasesButNotBy = function(fn2, obj, prop, delta, msg) {
   if (arguments.length === 4 && typeof obj === "function") {
     var tmpMsg = delta;
     delta = prop;
@@ -8187,16 +8302,16 @@ assert.increasesButNotBy = function(fn2, obj, prop, delta, msg) {
     delta = prop;
     prop = null;
   }
-  new Assertion(fn2, msg, assert.increasesButNotBy, true).to.increase(obj, prop).but.not.by(delta);
+  new Assertion(fn2, msg, assert2.increasesButNotBy, true).to.increase(obj, prop).but.not.by(delta);
 };
-assert.decreases = function(fn2, obj, prop, msg) {
+assert2.decreases = function(fn2, obj, prop, msg) {
   if (arguments.length === 3 && typeof obj === "function") {
     msg = prop;
     prop = null;
   }
-  return new Assertion(fn2, msg, assert.decreases, true).to.decrease(obj, prop);
+  return new Assertion(fn2, msg, assert2.decreases, true).to.decrease(obj, prop);
 };
-assert.decreasesBy = function(fn2, obj, prop, delta, msg) {
+assert2.decreasesBy = function(fn2, obj, prop, delta, msg) {
   if (arguments.length === 4 && typeof obj === "function") {
     var tmpMsg = delta;
     delta = prop;
@@ -8205,19 +8320,19 @@ assert.decreasesBy = function(fn2, obj, prop, delta, msg) {
     delta = prop;
     prop = null;
   }
-  new Assertion(fn2, msg, assert.decreasesBy, true).to.decrease(obj, prop).by(delta);
+  new Assertion(fn2, msg, assert2.decreasesBy, true).to.decrease(obj, prop).by(delta);
 };
-assert.doesNotDecrease = function(fn2, obj, prop, msg) {
+assert2.doesNotDecrease = function(fn2, obj, prop, msg) {
   if (arguments.length === 3 && typeof obj === "function") {
     msg = prop;
     prop = null;
   }
-  return new Assertion(fn2, msg, assert.doesNotDecrease, true).to.not.decrease(
+  return new Assertion(fn2, msg, assert2.doesNotDecrease, true).to.not.decrease(
     obj,
     prop
   );
 };
-assert.doesNotDecreaseBy = function(fn2, obj, prop, delta, msg) {
+assert2.doesNotDecreaseBy = function(fn2, obj, prop, delta, msg) {
   if (arguments.length === 4 && typeof obj === "function") {
     var tmpMsg = delta;
     delta = prop;
@@ -8226,9 +8341,9 @@ assert.doesNotDecreaseBy = function(fn2, obj, prop, delta, msg) {
     delta = prop;
     prop = null;
   }
-  return new Assertion(fn2, msg, assert.doesNotDecreaseBy, true).to.not.decrease(obj, prop).by(delta);
+  return new Assertion(fn2, msg, assert2.doesNotDecreaseBy, true).to.not.decrease(obj, prop).by(delta);
 };
-assert.decreasesButNotBy = function(fn2, obj, prop, delta, msg) {
+assert2.decreasesButNotBy = function(fn2, obj, prop, delta, msg) {
   if (arguments.length === 4 && typeof obj === "function") {
     var tmpMsg = delta;
     delta = prop;
@@ -8237,41 +8352,41 @@ assert.decreasesButNotBy = function(fn2, obj, prop, delta, msg) {
     delta = prop;
     prop = null;
   }
-  new Assertion(fn2, msg, assert.decreasesButNotBy, true).to.decrease(obj, prop).but.not.by(delta);
+  new Assertion(fn2, msg, assert2.decreasesButNotBy, true).to.decrease(obj, prop).but.not.by(delta);
 };
-assert.ifError = function(val) {
+assert2.ifError = function(val) {
   if (val) {
     throw val;
   }
 };
-assert.isExtensible = function(obj, msg) {
-  new Assertion(obj, msg, assert.isExtensible, true).to.be.extensible;
+assert2.isExtensible = function(obj, msg) {
+  new Assertion(obj, msg, assert2.isExtensible, true).to.be.extensible;
 };
-assert.isNotExtensible = function(obj, msg) {
-  new Assertion(obj, msg, assert.isNotExtensible, true).to.not.be.extensible;
+assert2.isNotExtensible = function(obj, msg) {
+  new Assertion(obj, msg, assert2.isNotExtensible, true).to.not.be.extensible;
 };
-assert.isSealed = function(obj, msg) {
-  new Assertion(obj, msg, assert.isSealed, true).to.be.sealed;
+assert2.isSealed = function(obj, msg) {
+  new Assertion(obj, msg, assert2.isSealed, true).to.be.sealed;
 };
-assert.isNotSealed = function(obj, msg) {
-  new Assertion(obj, msg, assert.isNotSealed, true).to.not.be.sealed;
+assert2.isNotSealed = function(obj, msg) {
+  new Assertion(obj, msg, assert2.isNotSealed, true).to.not.be.sealed;
 };
-assert.isFrozen = function(obj, msg) {
-  new Assertion(obj, msg, assert.isFrozen, true).to.be.frozen;
+assert2.isFrozen = function(obj, msg) {
+  new Assertion(obj, msg, assert2.isFrozen, true).to.be.frozen;
 };
-assert.isNotFrozen = function(obj, msg) {
-  new Assertion(obj, msg, assert.isNotFrozen, true).to.not.be.frozen;
+assert2.isNotFrozen = function(obj, msg) {
+  new Assertion(obj, msg, assert2.isNotFrozen, true).to.not.be.frozen;
 };
-assert.isEmpty = function(val, msg) {
-  new Assertion(val, msg, assert.isEmpty, true).to.be.empty;
+assert2.isEmpty = function(val, msg) {
+  new Assertion(val, msg, assert2.isEmpty, true).to.be.empty;
 };
-assert.isNotEmpty = function(val, msg) {
-  new Assertion(val, msg, assert.isNotEmpty, true).to.not.be.empty;
+assert2.isNotEmpty = function(val, msg) {
+  new Assertion(val, msg, assert2.isNotEmpty, true).to.not.be.empty;
 };
-assert.containsSubset = function(val, exp, msg) {
+assert2.containsSubset = function(val, exp, msg) {
   new Assertion(val, msg).to.containSubset(exp);
 };
-assert.doesNotContainSubset = function(val, exp, msg) {
+assert2.doesNotContainSubset = function(val, exp, msg) {
   new Assertion(val, msg).to.not.containSubset(exp);
 };
 var aliases = [
@@ -8292,7 +8407,7 @@ var aliases = [
   ["containsSubset", "containSubset"]
 ];
 for (const [name, as] of aliases) {
-  assert[as] = assert[name];
+  assert2[as] = assert2[name];
 }
 var used = [];
 function use(fn2) {
@@ -8302,7 +8417,7 @@ function use(fn2) {
     util: utils_exports,
     config,
     expect,
-    assert,
+    assert: assert2,
     Assertion,
     ...should_exports
   };
@@ -8314,7 +8429,7 @@ function use(fn2) {
 }
 __name(use, "use");
 
-// ../../node_modules/.pnpm/@vitest+expect@3.1.2/node_modules/@vitest/expect/dist/index.js
+// ../../node_modules/.pnpm/@vitest+expect@3.2.2/node_modules/@vitest/expect/dist/index.js
 var MATCHERS_OBJECT = Symbol.for("matchers-object");
 var JEST_MATCHERS_OBJECT = Symbol.for("$$jest-matchers-object");
 var GLOBAL_EXPECT = Symbol.for("expect-global");
@@ -8512,6 +8627,16 @@ function eq(a3, b, aStack, bStack, customTesters, hasKey2) {
     }
     case "[object RegExp]":
       return a3.source === b.source && a3.flags === b.flags;
+    case "[object Temporal.Instant]":
+    case "[object Temporal.ZonedDateTime]":
+    case "[object Temporal.PlainDateTime]":
+    case "[object Temporal.PlainDate]":
+    case "[object Temporal.PlainTime]":
+    case "[object Temporal.PlainYearMonth]":
+    case "[object Temporal.PlainMonthDay]":
+      return a3.equals(b);
+    case "[object Temporal.Duration]":
+      return a3.toString() === b.toString();
   }
   if (typeof a3 !== "object" || typeof b !== "object") {
     return false;
@@ -8700,7 +8825,7 @@ function iterableEquality(a3, b, customTesters = [], aStack = [], bStack = []) {
   if (!isImmutableList(a3) && !isImmutableOrderedKeyed(a3) && !isImmutableOrderedSet(a3) && !isImmutableRecord(a3)) {
     const aEntries = Object.entries(a3);
     const bEntries = Object.entries(b);
-    if (!equals(aEntries, bEntries)) {
+    if (!equals(aEntries, bEntries, filteredCustomTesters)) {
       return false;
     }
   }
@@ -8877,6 +9002,7 @@ function setState(state, expect2) {
   map2.set(expect2, results);
 }
 var AsymmetricMatcher3 = class {
+  // should have "jest" to be compatible with its ecosystem
   $$typeof = Symbol.for("jest.asymmetricMatcher");
   constructor(sample, inverse = false) {
     this.sample = sample;
@@ -9231,8 +9357,8 @@ var JestChaiExpect = (chai2, utils) => {
     "throw",
     "throws",
     "Throw"
-  ].forEach((m3) => {
-    utils.overwriteMethod(chai2.Assertion.prototype, m3, (_super) => {
+  ].forEach((m2) => {
+    utils.overwriteMethod(chai2.Assertion.prototype, m2, (_super) => {
       return function(...args) {
         const promise = utils.flag(this, "promise");
         const object2 = utils.flag(this, "object");
@@ -9457,7 +9583,7 @@ var JestChaiExpect = (chai2, utils) => {
     return this.assert(pass, `expected #{this} to be close to #{exp}, received difference is ${receivedDiff}, but expected ${expectedDiff}`, `expected #{this} to not be close to #{exp}, received difference is ${receivedDiff}, but expected ${expectedDiff}`, received, expected, false);
   });
   function assertIsMock(assertion) {
-    if (!isMockFunction(assertion._obj)) {
+    if (!isMockFunction2(assertion._obj)) {
       throw new TypeError(`${utils.inspect(assertion._obj)} is not a spy or a call to a spy!`);
     }
   }
@@ -9559,14 +9685,14 @@ var JestChaiExpect = (chai2, utils) => {
   }
   def(["toHaveBeenCalledBefore"], function(resultSpy, failIfNoFirstInvocation = true) {
     const expectSpy = getSpy(this);
-    if (!isMockFunction(resultSpy)) {
+    if (!isMockFunction2(resultSpy)) {
       throw new TypeError(`${utils.inspect(resultSpy)} is not a spy or a call to a spy`);
     }
     this.assert(isSpyCalledBeforeAnotherSpy(expectSpy, resultSpy, failIfNoFirstInvocation), `expected "${expectSpy.getMockName()}" to have been called before "${resultSpy.getMockName()}"`, `expected "${expectSpy.getMockName()}" to not have been called before "${resultSpy.getMockName()}"`, resultSpy, expectSpy);
   });
   def(["toHaveBeenCalledAfter"], function(resultSpy, failIfNoFirstInvocation = true) {
     const expectSpy = getSpy(this);
-    if (!isMockFunction(resultSpy)) {
+    if (!isMockFunction2(resultSpy)) {
       throw new TypeError(`${utils.inspect(resultSpy)} is not a spy or a call to a spy`);
     }
     this.assert(isSpyCalledBeforeAnotherSpy(resultSpy, expectSpy, failIfNoFirstInvocation), `expected "${expectSpy.getMockName()}" to have been called after "${resultSpy.getMockName()}"`, `expected "${expectSpy.getMockName()}" to not have been called after "${resultSpy.getMockName()}"`, resultSpy, expectSpy);
@@ -9695,14 +9821,7 @@ var JestChaiExpect = (chai2, utils) => {
       const results = action === "return" ? spy.mock.results : spy.mock.settledResults;
       const result = results[results.length - 1];
       const spyName = spy.getMockName();
-      this.assert(
-        condition(spy, value),
-        `expected last "${spyName}" call to ${action} #{exp}`,
-        `expected last "${spyName}" call to not ${action} #{exp}`,
-        value,
-        // for jest compat
-        result === null || result === void 0 ? void 0 : result.value
-      );
+      this.assert(condition(spy, value), `expected last "${spyName}" call to ${action} #{exp}`, `expected last "${spyName}" call to not ${action} #{exp}`, value, result === null || result === void 0 ? void 0 : result.value);
     });
   });
   [{
@@ -9808,14 +9927,14 @@ var JestChaiExpect = (chai2, utils) => {
 };
 function ordinalOf(i) {
   const j = i % 10;
-  const k2 = i % 100;
-  if (j === 1 && k2 !== 11) {
+  const k = i % 100;
+  if (j === 1 && k !== 11) {
     return `${i}st`;
   }
-  if (j === 2 && k2 !== 12) {
+  if (j === 2 && k !== 12) {
     return `${i}nd`;
   }
-  if (j === 3 && k2 !== 13) {
+  if (j === 3 && k !== 13) {
     return `${i}rd`;
   }
   return `${i}th`;
@@ -10279,53 +10398,7 @@ var isAbsolute2 = function(p3) {
   return _IS_ABSOLUTE_RE2.test(p3);
 };
 
-// ../../node_modules/.pnpm/@vitest+runner@3.1.2/node_modules/@vitest/runner/dist/chunk-tasks.js
-function createChainable(keys2, fn2) {
-  function create(context) {
-    const chain2 = function(...args) {
-      return fn2.apply(context, args);
-    };
-    Object.assign(chain2, fn2);
-    chain2.withContext = () => chain2.bind(context);
-    chain2.setContext = (key, value) => {
-      context[key] = value;
-    };
-    chain2.mergeContext = (ctx) => {
-      Object.assign(context, ctx);
-    };
-    for (const key of keys2) {
-      Object.defineProperty(chain2, key, { get() {
-        return create({
-          ...context,
-          [key]: true
-        });
-      } });
-    }
-    return chain2;
-  }
-  const chain = create({});
-  chain.fn = fn2;
-  return chain;
-}
-function getNames(task) {
-  const names = [task.name];
-  let current = task;
-  while (current === null || current === void 0 ? void 0 : current.suite) {
-    current = current.suite;
-    if (current === null || current === void 0 ? void 0 : current.name) {
-      names.unshift(current.name);
-    }
-  }
-  if (current !== task.file) {
-    names.unshift(task.file.name);
-  }
-  return names;
-}
-function getTestName(task, separator = " > ") {
-  return getNames(task).slice(1).join(separator);
-}
-
-// ../../node_modules/.pnpm/@vitest+runner@3.1.2/node_modules/@vitest/runner/dist/index.js
+// ../../node_modules/.pnpm/@vitest+runner@3.2.2/node_modules/@vitest/runner/dist/chunk-hooks.js
 var PendingError = class extends Error {
   code = "VITEST_PENDING";
   taskId;
@@ -10371,14 +10444,23 @@ function mergeScopedFixtures(testFixtures, scopedFixtures) {
   }
   return Object.values(newFixtures);
 }
-function mergeContextFixtures(fixtures, context, inject2) {
-  const fixtureOptionKeys = ["auto", "injected"];
+function mergeContextFixtures(fixtures, context, runner2) {
+  const fixtureOptionKeys = [
+    "auto",
+    "injected",
+    "scope"
+  ];
   const fixtureArray = Object.entries(fixtures).map(([prop, value]) => {
     const fixtureItem = { value };
     if (Array.isArray(value) && value.length >= 2 && isObject(value[1]) && Object.keys(value[1]).some((key) => fixtureOptionKeys.includes(key))) {
+      var _runner$injectValue;
       Object.assign(fixtureItem, value[1]);
       const userValue = value[0];
-      fixtureItem.value = fixtureItem.injected ? inject2(prop) ?? userValue : userValue;
+      fixtureItem.value = fixtureItem.injected ? ((_runner$injectValue = runner2.injectValue) === null || _runner$injectValue === void 0 ? void 0 : _runner$injectValue.call(runner2, prop)) ?? userValue : userValue;
+    }
+    fixtureItem.scope = fixtureItem.scope || "test";
+    if (fixtureItem.scope === "worker" && !runner2.getWorkerContext) {
+      fixtureItem.scope = "file";
     }
     fixtureItem.prop = prop;
     fixtureItem.isFn = typeof fixtureItem.value === "function";
@@ -10395,13 +10477,28 @@ function mergeContextFixtures(fixtures, context, inject2) {
       if (usedProps.length) {
         fixture.deps = context.fixtures.filter(({ prop }) => prop !== fixture.prop && usedProps.includes(prop));
       }
+      if (fixture.scope !== "test") {
+        var _fixture$deps2;
+        (_fixture$deps2 = fixture.deps) === null || _fixture$deps2 === void 0 ? void 0 : _fixture$deps2.forEach((dep) => {
+          if (!dep.isFn) {
+            return;
+          }
+          if (fixture.scope === "worker" && dep.scope === "worker") {
+            return;
+          }
+          if (fixture.scope === "file" && dep.scope !== "test") {
+            return;
+          }
+          throw new SyntaxError(`cannot use the ${dep.scope} fixture "${dep.prop}" inside the ${fixture.scope} fixture "${fixture.prop}"`);
+        });
+      }
     }
   });
   return context;
 }
 var fixtureValueMaps = /* @__PURE__ */ new Map();
 var cleanupFnArrayMap = /* @__PURE__ */ new Map();
-function withFixtures(fn2, testContext) {
+function withFixtures(runner2, fn2, testContext) {
   return (hookContext) => {
     const context = hookContext || testContext;
     if (!context) {
@@ -10434,17 +10531,63 @@ function withFixtures(fn2, testContext) {
         if (fixtureValueMap.has(fixture)) {
           continue;
         }
-        const resolvedValue = fixture.isFn ? await resolveFixtureFunction(fixture.value, context, cleanupFnArray) : fixture.value;
+        const resolvedValue = await resolveFixtureValue(runner2, fixture, context, cleanupFnArray);
         context[fixture.prop] = resolvedValue;
         fixtureValueMap.set(fixture, resolvedValue);
-        cleanupFnArray.unshift(() => {
-          fixtureValueMap.delete(fixture);
-        });
+        if (fixture.scope === "test") {
+          cleanupFnArray.unshift(() => {
+            fixtureValueMap.delete(fixture);
+          });
+        }
       }
     }
     return resolveFixtures().then(() => fn2(context));
   };
 }
+var globalFixturePromise = /* @__PURE__ */ new WeakMap();
+function resolveFixtureValue(runner2, fixture, context, cleanupFnArray) {
+  var _runner$getWorkerCont;
+  const fileContext = getFileContext(context.task.file);
+  const workerContext = (_runner$getWorkerCont = runner2.getWorkerContext) === null || _runner$getWorkerCont === void 0 ? void 0 : _runner$getWorkerCont.call(runner2);
+  if (!fixture.isFn) {
+    var _fixture$prop;
+    fileContext[_fixture$prop = fixture.prop] ?? (fileContext[_fixture$prop] = fixture.value);
+    if (workerContext) {
+      var _fixture$prop2;
+      workerContext[_fixture$prop2 = fixture.prop] ?? (workerContext[_fixture$prop2] = fixture.value);
+    }
+    return fixture.value;
+  }
+  if (fixture.scope === "test") {
+    return resolveFixtureFunction(fixture.value, context, cleanupFnArray);
+  }
+  if (globalFixturePromise.has(fixture)) {
+    return globalFixturePromise.get(fixture);
+  }
+  let fixtureContext;
+  if (fixture.scope === "worker") {
+    if (!workerContext) {
+      throw new TypeError("[@vitest/runner] The worker context is not available in the current test runner. Please, provide the `getWorkerContext` method when initiating the runner.");
+    }
+    fixtureContext = workerContext;
+  } else {
+    fixtureContext = fileContext;
+  }
+  if (fixture.prop in fixtureContext) {
+    return fixtureContext[fixture.prop];
+  }
+  if (!cleanupFnArrayMap.has(fixtureContext)) {
+    cleanupFnArrayMap.set(fixtureContext, []);
+  }
+  const cleanupFnFileArray = cleanupFnArrayMap.get(fixtureContext);
+  const promise = resolveFixtureFunction(fixture.value, fixtureContext, cleanupFnFileArray).then((value) => {
+    fixtureContext[fixture.prop] = value;
+    globalFixturePromise.delete(fixture);
+    return value;
+  });
+  globalFixturePromise.set(fixture, promise);
+  return promise;
+}
 async function resolveFixtureFunction(fixtureFn, context, cleanupFnArray) {
   const useFnArgPromise = createDefer();
   let isUseFnArgResolved = false;
@@ -10476,7 +10619,7 @@ function resolveDeps(fixtures, depSet = /* @__PURE__ */ new Set(), pendingFixtur
       return;
     }
     if (depSet.has(fixture)) {
-      throw new Error(`Circular fixture dependency detected: ${fixture.prop} <- ${[...depSet].reverse().map((d2) => d2.prop).join(" <- ")}`);
+      throw new Error(`Circular fixture dependency detected: ${fixture.prop} <- ${[...depSet].reverse().map((d) => d.prop).join(" <- ")}`);
     }
     depSet.add(fixture);
     resolveDeps(fixture.deps, depSet, pendingFixtures);
@@ -10487,8 +10630,8 @@ function resolveDeps(fixtures, depSet = /* @__PURE__ */ new Set(), pendingFixtur
 }
 function getUsedProps(fn2) {
   let fnString = fn2.toString();
-  if (/__async\(this, (?:null|arguments|\[[_0-9, ]*\]), function\*/.test(fnString)) {
-    fnString = fnString.split("__async(this,")[1];
+  if (/__async\((?:this|null), (?:null|arguments|\[[_0-9, ]*\]), function\*/.test(fnString)) {
+    fnString = fnString.split(/__async\((?:this|null),/)[1];
   }
   const match = fnString.match(/[^(]*\(([^)]*)/);
   if (!match) {
@@ -10545,6 +10688,33 @@ var _test;
 function getCurrentTest() {
   return _test;
 }
+function createChainable(keys2, fn2) {
+  function create(context) {
+    const chain2 = function(...args) {
+      return fn2.apply(context, args);
+    };
+    Object.assign(chain2, fn2);
+    chain2.withContext = () => chain2.bind(context);
+    chain2.setContext = (key, value) => {
+      context[key] = value;
+    };
+    chain2.mergeContext = (ctx) => {
+      Object.assign(context, ctx);
+    };
+    for (const key of keys2) {
+      Object.defineProperty(chain2, key, { get() {
+        return create({
+          ...context,
+          [key]: true
+        });
+      } });
+    }
+    return chain2;
+  }
+  const chain = create({});
+  chain.fn = fn2;
+  return chain;
+}
 var suite = createSuite();
 var test3 = createTest(function(name, optionsOrFn, optionsOrTest) {
   getCurrentSuite().test.fn.call(this, formatName(name), optionsOrFn, optionsOrTest);
@@ -10554,7 +10724,7 @@ var it = test3;
 var runner;
 var defaultSuite;
 var currentTestFilepath;
-function assert2(condition, message) {
+function assert3(condition, message) {
   if (!condition) {
     throw new Error(`Vitest failed to find ${message}. This is a bug in Vitest. Please, open an issue with reproduction.`);
   }
@@ -10563,12 +10733,12 @@ function getTestFilepath() {
   return currentTestFilepath;
 }
 function getRunner() {
-  assert2(runner, "the runner");
+  assert3(runner, "the runner");
   return runner;
 }
 function getCurrentSuite() {
   const currentSuite = collectorContext.currentSuite || defaultSuite;
-  assert2(currentSuite, "the current suite");
+  assert3(currentSuite, "the current suite");
   return currentSuite;
 }
 function createSuiteHooks() {
@@ -10628,7 +10798,8 @@ function createSuiteCollector(name, factory = () => {
       retry: options.retry ?? runner.config.retry,
       repeats: options.repeats,
       mode: options.only ? "only" : options.skip ? "skip" : options.todo ? "todo" : "run",
-      meta: options.meta ?? /* @__PURE__ */ Object.create(null)
+      meta: options.meta ?? /* @__PURE__ */ Object.create(null),
+      annotations: []
     };
     const handler = options.handler;
     if (options.concurrent || !options.sequential && runner.config.sequence.concurrent) {
@@ -10646,11 +10817,11 @@ function createSuiteCollector(name, factory = () => {
     const stackTraceError = new Error("STACK_TRACE_ERROR");
     Error.stackTraceLimit = limit;
     if (handler) {
-      setFn(task2, withTimeout(withAwaitAsyncAssertions(withFixtures(handler, context), task2), timeout, false, stackTraceError));
+      setFn(task2, withTimeout(withAwaitAsyncAssertions(withFixtures(runner, handler, context), task2), timeout, false, stackTraceError, (_, error) => abortIfTimeout([context], error)));
     }
     if (runner.config.includeTaskLocation) {
       const error = stackTraceError.stack;
-      const stack = findTestFileStackTrace(error, task2.each ?? false);
+      const stack = findTestFileStackTrace(error);
       if (stack) {
         task2.location = stack;
       }
@@ -10689,10 +10860,7 @@ function createSuiteCollector(name, factory = () => {
       return collectorFixtures;
     },
     scoped(fixtures) {
-      const parsed = mergeContextFixtures(fixtures, { fixtures: collectorFixtures }, (key) => {
-        var _getRunner$injectValu, _getRunner;
-        return (_getRunner$injectValu = (_getRunner = getRunner()).injectValue) === null || _getRunner$injectValu === void 0 ? void 0 : _getRunner$injectValu.call(_getRunner, key);
-      });
+      const parsed = mergeContextFixtures(fixtures, { fixtures: collectorFixtures }, runner);
       if (parsed.fixtures) {
         collectorFixtures = parsed.fixtures;
       }
@@ -10890,10 +11058,7 @@ function createTaskCollector(fn2, context) {
     collector.scoped(fixtures);
   };
   taskFn.extend = function(fixtures) {
-    const _context = mergeContextFixtures(fixtures, context || {}, (key) => {
-      var _getRunner$injectValu2, _getRunner2;
-      return (_getRunner$injectValu2 = (_getRunner2 = getRunner()).injectValue) === null || _getRunner$injectValu2 === void 0 ? void 0 : _getRunner$injectValu2.call(_getRunner2, key);
-    });
+    const _context = mergeContextFixtures(fixtures, context || {}, runner);
     return createTest(function fn3(name, optionsOrFn, optionsOrTest) {
       const collector = getCurrentSuite();
       const scopedFixtures = collector.fixtures();
@@ -10965,19 +11130,66 @@ function formatTemplateString(cases, args) {
   }
   return res;
 }
-function findTestFileStackTrace(error, each) {
+function findTestFileStackTrace(error) {
+  const testFilePath = getTestFilepath();
   const lines = error.split("\n").slice(1);
   for (const line of lines) {
     const stack = parseSingleStack(line);
-    if (stack && stack.file === getTestFilepath()) {
+    if (stack && stack.file === testFilePath) {
       return {
         line: stack.line,
-        column: each ? stack.column + 1 : stack.column
+        column: stack.column
       };
     }
   }
 }
-var now$2 = Date.now;
+globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
+function getNames(task) {
+  const names = [task.name];
+  let current = task;
+  while (current === null || current === void 0 ? void 0 : current.suite) {
+    current = current.suite;
+    if (current === null || current === void 0 ? void 0 : current.name) {
+      names.unshift(current.name);
+    }
+  }
+  if (current !== task.file) {
+    names.unshift(task.file.name);
+  }
+  return names;
+}
+function getTestName(task, separator = " > ") {
+  return getNames(task).slice(1).join(separator);
+}
+globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
+var packs = /* @__PURE__ */ new Map();
+var eventsPacks = [];
+var pendingTasksUpdates = [];
+function sendTasksUpdate(runner2) {
+  if (packs.size) {
+    var _runner$onTaskUpdate;
+    const taskPacks = Array.from(packs).map(([id, task]) => {
+      return [
+        id,
+        task[0],
+        task[1]
+      ];
+    });
+    const p3 = (_runner$onTaskUpdate = runner2.onTaskUpdate) === null || _runner$onTaskUpdate === void 0 ? void 0 : _runner$onTaskUpdate.call(runner2, taskPacks, eventsPacks);
+    if (p3) {
+      pendingTasksUpdates.push(p3);
+      p3.then(() => pendingTasksUpdates.splice(pendingTasksUpdates.indexOf(p3), 1), () => {
+      });
+    }
+    eventsPacks.length = 0;
+    packs.clear();
+  }
+}
+async function finishSendTasksUpdate(runner2) {
+  sendTasksUpdate(runner2);
+  await Promise.all(pendingTasksUpdates);
+}
+var now = Date.now;
 var collectorContext = {
   currentSuite: null
 };
@@ -10991,13 +11203,13 @@ async function runWithSuite(suite2, fn2) {
   await fn2();
   collectorContext.currentSuite = prev;
 }
-function withTimeout(fn2, timeout, isHook = false, stackTraceError) {
+function withTimeout(fn2, timeout, isHook = false, stackTraceError, onTimeout) {
   if (timeout <= 0 || timeout === Number.POSITIVE_INFINITY) {
     return fn2;
   }
   const { setTimeout, clearTimeout } = getSafeTimers();
   return function runWithTimeout(...args) {
-    const startTime = now$2();
+    const startTime = now();
     const runner2 = getRunner();
     runner2._currentTaskStartTime = startTime;
     runner2._currentTaskTimeout = timeout;
@@ -11009,13 +11221,15 @@ function withTimeout(fn2, timeout, isHook = false, stackTraceError) {
       }, timeout);
       (_timer$unref = timer.unref) === null || _timer$unref === void 0 ? void 0 : _timer$unref.call(timer);
       function rejectTimeoutError() {
-        reject_(makeTimeoutError(isHook, timeout, stackTraceError));
+        const error = makeTimeoutError(isHook, timeout, stackTraceError);
+        onTimeout === null || onTimeout === void 0 ? void 0 : onTimeout(args, error);
+        reject_(error);
       }
       function resolve4(result) {
         runner2._currentTaskStartTime = void 0;
         runner2._currentTaskTimeout = void 0;
         clearTimeout(timer);
-        if (now$2() - startTime >= timeout) {
+        if (now() - startTime >= timeout) {
           rejectTimeoutError();
           return;
         }
@@ -11040,11 +11254,27 @@ function withTimeout(fn2, timeout, isHook = false, stackTraceError) {
     });
   };
 }
+var abortControllers = /* @__PURE__ */ new WeakMap();
+function abortIfTimeout([context], error) {
+  if (context) {
+    abortContextSignal(context, error);
+  }
+}
+function abortContextSignal(context, error) {
+  const abortController = abortControllers.get(context);
+  abortController === null || abortController === void 0 ? void 0 : abortController.abort(error);
+}
 function createTestContext(test5, runner2) {
   var _runner$extendTaskCon;
   const context = function() {
     throw new Error("done() callback is deprecated, use promise instead");
   };
+  let abortController = abortControllers.get(context);
+  if (!abortController) {
+    abortController = new AbortController();
+    abortControllers.set(context, abortController);
+  }
+  context.signal = abortController.signal;
   context.task = test5;
   context.skip = (condition, note) => {
     if (condition === false) {
@@ -11054,13 +11284,63 @@ function createTestContext(test5, runner2) {
     test5.result.pending = true;
     throw new PendingError("test is skipped; abort execution", test5, typeof condition === "string" ? condition : note);
   };
+  async function annotate(message, location, type3, attachment) {
+    const annotation = {
+      message,
+      type: type3 || "notice"
+    };
+    if (attachment) {
+      if (!attachment.body && !attachment.path) {
+        throw new TypeError(`Test attachment requires body or path to be set. Both are missing.`);
+      }
+      if (attachment.body && attachment.path) {
+        throw new TypeError(`Test attachment requires only one of "body" or "path" to be set. Both are specified.`);
+      }
+      annotation.attachment = attachment;
+      if (attachment.body instanceof Uint8Array) {
+        attachment.body = encodeUint8Array(attachment.body);
+      }
+    }
+    if (location) {
+      annotation.location = location;
+    }
+    if (!runner2.onTestAnnotate) {
+      throw new Error(`Test runner doesn't support test annotations.`);
+    }
+    await finishSendTasksUpdate(runner2);
+    const resolvedAnnotation = await runner2.onTestAnnotate(test5, annotation);
+    test5.annotations.push(resolvedAnnotation);
+    return resolvedAnnotation;
+  }
+  context.annotate = (message, type3, attachment) => {
+    if (test5.result && test5.result.state !== "run") {
+      throw new Error(`Cannot annotate tests outside of the test run. The test "${test5.name}" finished running with the "${test5.result.state}" state already.`);
+    }
+    let location;
+    const stack = new Error("STACK_TRACE").stack;
+    const index2 = stack.includes("STACK_TRACE") ? 2 : 1;
+    const stackLine = stack.split("\n")[index2];
+    const parsed = parseSingleStack(stackLine);
+    if (parsed) {
+      location = {
+        file: parsed.file,
+        line: parsed.line,
+        column: parsed.column
+      };
+    }
+    if (typeof type3 === "object") {
+      return recordAsyncAnnotation(test5, annotate(message, location, void 0, type3));
+    } else {
+      return recordAsyncAnnotation(test5, annotate(message, location, type3, attachment));
+    }
+  };
   context.onTestFailed = (handler, timeout) => {
     test5.onFailed || (test5.onFailed = []);
-    test5.onFailed.push(withTimeout(handler, timeout ?? runner2.config.hookTimeout, true, new Error("STACK_TRACE_ERROR")));
+    test5.onFailed.push(withTimeout(handler, timeout ?? runner2.config.hookTimeout, true, new Error("STACK_TRACE_ERROR"), (_, error) => abortController.abort(error)));
   };
   context.onTestFinished = (handler, timeout) => {
     test5.onFinished || (test5.onFinished = []);
-    test5.onFinished.push(withTimeout(handler, timeout ?? runner2.config.hookTimeout, true, new Error("STACK_TRACE_ERROR")));
+    test5.onFinished.push(withTimeout(handler, timeout ?? runner2.config.hookTimeout, true, new Error("STACK_TRACE_ERROR"), (_, error) => abortController.abort(error)));
   };
   return ((_runner$extendTaskCon = runner2.extendTaskContext) === null || _runner$extendTaskCon === void 0 ? void 0 : _runner$extendTaskCon.call(runner2, context)) || context;
 }
@@ -11073,6 +11353,71 @@ If this is a long-running ${isHook ? "hook" : "test"}, pass a timeout value as t
   }
   return error;
 }
+var fileContexts = /* @__PURE__ */ new WeakMap();
+function getFileContext(file) {
+  const context = fileContexts.get(file);
+  if (!context) {
+    throw new Error(`Cannot find file context for ${file.name}`);
+  }
+  return context;
+}
+var table = [];
+for (let i = 65; i < 91; i++) {
+  table.push(String.fromCharCode(i));
+}
+for (let i = 97; i < 123; i++) {
+  table.push(String.fromCharCode(i));
+}
+for (let i = 0; i < 10; i++) {
+  table.push(i.toString(10));
+}
+function encodeUint8Array(bytes) {
+  let base64 = "";
+  const len = bytes.byteLength;
+  for (let i = 0; i < len; i += 3) {
+    if (len === i + 1) {
+      const a3 = (bytes[i] & 252) >> 2;
+      const b = (bytes[i] & 3) << 4;
+      base64 += table[a3];
+      base64 += table[b];
+      base64 += "==";
+    } else if (len === i + 2) {
+      const a3 = (bytes[i] & 252) >> 2;
+      const b = (bytes[i] & 3) << 4 | (bytes[i + 1] & 240) >> 4;
+      const c = (bytes[i + 1] & 15) << 2;
+      base64 += table[a3];
+      base64 += table[b];
+      base64 += table[c];
+      base64 += "=";
+    } else {
+      const a3 = (bytes[i] & 252) >> 2;
+      const b = (bytes[i] & 3) << 4 | (bytes[i + 1] & 240) >> 4;
+      const c = (bytes[i + 1] & 15) << 2 | (bytes[i + 2] & 192) >> 6;
+      const d = bytes[i + 2] & 63;
+      base64 += table[a3];
+      base64 += table[b];
+      base64 += table[c];
+      base64 += table[d];
+    }
+  }
+  return base64;
+}
+function recordAsyncAnnotation(test5, promise) {
+  promise = promise.finally(() => {
+    if (!test5.promises) {
+      return;
+    }
+    const index2 = test5.promises.indexOf(promise);
+    if (index2 !== -1) {
+      test5.promises.splice(index2, 1);
+    }
+  });
+  if (!test5.promises) {
+    test5.promises = [];
+  }
+  test5.promises.push(promise);
+  return promise;
+}
 function getDefaultHookTimeout() {
   return getRunner().config.hookTimeout;
 }
@@ -11093,14 +11438,16 @@ function afterAll(fn2, timeout) {
 function beforeEach(fn2, timeout = getDefaultHookTimeout()) {
   assertTypes(fn2, '"beforeEach" callback', ["function"]);
   const stackTraceError = new Error("STACK_TRACE_ERROR");
-  return getCurrentSuite().on("beforeEach", Object.assign(withTimeout(withFixtures(fn2), timeout ?? getDefaultHookTimeout(), true, stackTraceError), {
+  const runner2 = getRunner();
+  return getCurrentSuite().on("beforeEach", Object.assign(withTimeout(withFixtures(runner2, fn2), timeout ?? getDefaultHookTimeout(), true, stackTraceError, abortIfTimeout), {
     [CLEANUP_TIMEOUT_KEY]: timeout,
     [CLEANUP_STACK_TRACE_KEY]: stackTraceError
   }));
 }
 function afterEach(fn2, timeout) {
   assertTypes(fn2, '"afterEach" callback', ["function"]);
-  return getCurrentSuite().on("afterEach", withTimeout(withFixtures(fn2), timeout ?? getDefaultHookTimeout(), true, new Error("STACK_TRACE_ERROR")));
+  const runner2 = getRunner();
+  return getCurrentSuite().on("afterEach", withTimeout(withFixtures(runner2, fn2), timeout ?? getDefaultHookTimeout(), true, new Error("STACK_TRACE_ERROR"), abortIfTimeout));
 }
 var onTestFailed = createTestHook("onTestFailed");
 var onTestFinished = createTestHook("onTestFinished");
@@ -11112,10 +11459,8 @@ function createTestHook(name, handler) {
     }
   };
 }
-globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
-globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
 
-// ../../node_modules/.pnpm/vitest@3.1.2_@edge-runtime+vm@3.2.0_@types+debug@4.1.12_@types+node@20.17.32_@vitest+ui_3f295c4d69ef1c15dd9f9eff0f44d011/node_modules/vitest/dist/chunks/utils.CgTj3MsC.js
+// ../../node_modules/.pnpm/vitest@3.2.2_@edge-runtime+vm@3.2.0_@types+debug@4.1.12_@types+node@20.19.0_@vitest+ui@_eb265836689cb09b255052147598b424/node_modules/vitest/dist/chunks/utils.XdZDrNZV.js
 var NAME_WORKER_STATE = "__vitest_worker__";
 function getWorkerState() {
   const workerState = globalThis[NAME_WORKER_STATE];
@@ -11141,9 +11486,7 @@ function resetModules(modules, resetMocks = false) {
     ...!resetMocks ? [/^mock:/] : []
   ];
   modules.forEach((mod, path) => {
-    if (skipPaths.some((re) => re.test(path))) {
-      return;
-    }
+    if (skipPaths.some((re) => re.test(path))) return;
     modules.invalidateModule(mod);
   });
 }
@@ -11157,27 +11500,21 @@ async function waitForImportsToResolve() {
   const promises = [];
   let resolvingCount = 0;
   for (const mod of state.moduleCache.values()) {
-    if (mod.promise && !mod.evaluated) {
-      promises.push(mod.promise);
-    }
-    if (mod.resolving) {
-      resolvingCount++;
-    }
-  }
-  if (!promises.length && !resolvingCount) {
-    return;
+    if (mod.promise && !mod.evaluated) promises.push(mod.promise);
+    if (mod.resolving) resolvingCount++;
   }
+  if (!promises.length && !resolvingCount) return;
   await Promise.allSettled(promises);
   await waitForImportsToResolve();
 }
 
-// ../../node_modules/.pnpm/vitest@3.1.2_@edge-runtime+vm@3.2.0_@types+debug@4.1.12_@types+node@20.17.32_@vitest+ui_3f295c4d69ef1c15dd9f9eff0f44d011/node_modules/vitest/dist/chunks/_commonjsHelpers.BFTU3MAI.js
+// ../../node_modules/.pnpm/vitest@3.2.2_@edge-runtime+vm@3.2.0_@types+debug@4.1.12_@types+node@20.19.0_@vitest+ui@_eb265836689cb09b255052147598b424/node_modules/vitest/dist/chunks/_commonjsHelpers.BFTU3MAI.js
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
-function getDefaultExportFromCjs3(x2) {
-  return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
+function getDefaultExportFromCjs3(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
 
-// ../../node_modules/.pnpm/@vitest+snapshot@3.1.2/node_modules/@vitest/snapshot/dist/index.js
+// ../../node_modules/.pnpm/@vitest+snapshot@3.2.2/node_modules/@vitest/snapshot/dist/index.js
 var comma2 = ",".charCodeAt(0);
 var chars2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 var intToChar2 = new Uint8Array(64);
@@ -11804,6 +12141,9 @@ function parseStacktrace(stack, options = {}) {
       const fileUrl = stack2.file.startsWith("file://") ? stack2.file : `file://${stack2.file}`;
       const sourceRootUrl = map2.sourceRoot ? new URL(map2.sourceRoot, fileUrl) : fileUrl;
       file = new URL(source, sourceRootUrl).pathname;
+      if (file.match(/\/\w:\//)) {
+        file = file.slice(1);
+      }
     }
     if (shouldFilter(ignoreStackEntries, file)) {
       return null;
@@ -11835,8 +12175,8 @@ function parseErrorStacktrace(e, options = {}) {
   if (e.stacks) {
     return e.stacks;
   }
-  const stackStr = e.stack || e.stackStr || "";
-  let stackFrames = parseStacktrace(stackStr, options);
+  const stackStr = e.stack || "";
+  let stackFrames = typeof stackStr === "string" ? parseStacktrace(stackStr, options) : [];
   if (!stackFrames.length) {
     const e_ = e;
     if (e_.fileName != null && e_.lineNumber != null && e_.columnNumber != null) {
@@ -11847,7 +12187,7 @@ function parseErrorStacktrace(e, options = {}) {
     }
   }
   if (options.frameFilter) {
-    stackFrames = stackFrames.filter((f4) => options.frameFilter(e, f4) !== false);
+    stackFrames = stackFrames.filter((f3) => options.frameFilter(e, f3) !== false);
   }
   e.stacks = stackFrames;
   return stackFrames;
@@ -11861,8 +12201,8 @@ try {
   __require("util");
 } catch (noNodeInspect) {
 }
-function getDefaultExportFromCjs4(x2) {
-  return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
+function getDefaultExportFromCjs4(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
 var reservedWords2 = {
   keyword: [
@@ -11916,7 +12256,7 @@ var reservedWords2 = {
 };
 new Set(reservedWords2.keyword);
 new Set(reservedWords2.strict);
-var f3 = {
+var f2 = {
   reset: [0, 0],
   bold: [1, 22, "\x1B[22m\x1B[1m"],
   dim: [2, 22, "\x1B[22m\x1B[2m"],
@@ -11959,39 +12299,39 @@ var f3 = {
   bgCyanBright: [106, 49],
   bgWhiteBright: [107, 49]
 };
-var h2 = Object.entries(f3);
+var h2 = Object.entries(f2);
 function a2(n) {
   return String(n);
 }
 a2.open = "";
 a2.close = "";
-function C3(n = false) {
+function C2(n = false) {
   let e = typeof process != "undefined" ? process : void 0, i = (e == null ? void 0 : e.env) || {}, g = (e == null ? void 0 : e.argv) || [];
   return !("NO_COLOR" in i || g.includes("--no-color")) && ("FORCE_COLOR" in i || g.includes("--color") || (e == null ? void 0 : e.platform) === "win32" || n && i.TERM !== "dumb" || "CI" in i) || typeof window != "undefined" && !!window.chrome;
 }
 function p2(n = false) {
-  let e = C3(n), i = (r2, t, c, o) => {
-    let l2 = "", s2 = 0;
+  let e = C2(n), i = (r2, t, c, o) => {
+    let l = "", s2 = 0;
     do
-      l2 += r2.substring(s2, o) + c, s2 = o + t.length, o = r2.indexOf(t, s2);
+      l += r2.substring(s2, o) + c, s2 = o + t.length, o = r2.indexOf(t, s2);
     while (~o);
-    return l2 + r2.substring(s2);
+    return l + r2.substring(s2);
   }, g = (r2, t, c = r2) => {
-    let o = (l2) => {
-      let s2 = String(l2), b = s2.indexOf(t, r2.length);
+    let o = (l) => {
+      let s2 = String(l), b = s2.indexOf(t, r2.length);
       return ~b ? r2 + i(s2, t, c, b) + t : r2 + s2 + t;
     };
     return o.open = r2, o.close = t, o;
-  }, u3 = {
+  }, u2 = {
     isColorSupported: e
-  }, d2 = (r2) => `\x1B[${r2}m`;
+  }, d = (r2) => `\x1B[${r2}m`;
   for (let [r2, t] of h2)
-    u3[r2] = e ? g(
-      d2(t[0]),
-      d2(t[1]),
+    u2[r2] = e ? g(
+      d(t[0]),
+      d(t[1]),
       t[2]
     ) : a2;
-  return u3;
+  return u2;
 }
 p2();
 var lineSplitRE = /\r?\n/;
@@ -12362,6 +12702,11 @@ var CounterMap = class extends DefaultMap {
   constructor() {
     super(() => 0);
   }
+  // compat for jest-image-snapshot https://github.com/vitest-dev/vitest/issues/7322
+  // `valueOf` and `Snapshot.added` setter allows
+  //   snapshotState.added = snapshotState.added + 1
+  // to function as
+  //   snapshotState.added.total_ = snapshotState.added.total() + 1
   _total;
   valueOf() {
     return this._total = this.total();
@@ -12377,14 +12722,14 @@ var CounterMap = class extends DefaultMap {
       return this._total;
     }
     let total = 0;
-    for (const x2 of this.values()) {
-      total += x2;
+    for (const x of this.values()) {
+      total += x;
     }
     return total;
   }
 };
-function isSameStackPosition(x2, y2) {
-  return x2.file === y2.file && x2.column === y2.column && x2.line === y2.line;
+function isSameStackPosition(x, y) {
+  return x.file === y.file && x.column === y.column && x.line === y.line;
 }
 var SnapshotState = class _SnapshotState {
   _counters = new CounterMap();
@@ -12401,6 +12746,8 @@ var SnapshotState = class _SnapshotState {
   _environment;
   _fileExists;
   expand;
+  // getter/setter for jest-image-snapshot compat
+  // https://github.com/vitest-dev/vitest/issues/7322
   _added = new CounterMap();
   _matched = new CounterMap();
   _unmatched = new CounterMap();
@@ -12795,31 +13142,28 @@ var SnapshotClient = class {
   }
 };
 
-// ../../node_modules/.pnpm/vitest@3.1.2_@edge-runtime+vm@3.2.0_@types+debug@4.1.12_@types+node@20.17.32_@vitest+ui_3f295c4d69ef1c15dd9f9eff0f44d011/node_modules/vitest/dist/chunks/date.CDOsz-HY.js
+// ../../node_modules/.pnpm/vitest@3.2.2_@edge-runtime+vm@3.2.0_@types+debug@4.1.12_@types+node@20.19.0_@vitest+ui@_eb265836689cb09b255052147598b424/node_modules/vitest/dist/chunks/date.Bq6ZW5rf.js
 var RealDate = Date;
 var now2 = null;
 var MockDate = class _MockDate extends RealDate {
-  constructor(y2, m3, d2, h3, M, s2, ms) {
+  constructor(y, m2, d, h3, M, s2, ms) {
     super();
     let date;
     switch (arguments.length) {
       case 0:
-        if (now2 !== null) {
-          date = new RealDate(now2.valueOf());
-        } else {
-          date = new RealDate();
-        }
+        if (now2 !== null) date = new RealDate(now2.valueOf());
+        else date = new RealDate();
         break;
       case 1:
-        date = new RealDate(y2);
+        date = new RealDate(y);
         break;
       default:
-        d2 = typeof d2 === "undefined" ? 1 : d2;
+        d = typeof d === "undefined" ? 1 : d;
         h3 = h3 || 0;
         M = M || 0;
         s2 = s2 || 0;
         ms = ms || 0;
-        date = new RealDate(y2, m3, d2, h3, M, s2, ms);
+        date = new RealDate(y, m2, d, h3, M, s2, ms);
         break;
     }
     Object.setPrototypeOf(date, _MockDate.prototype);
@@ -12838,9 +13182,7 @@ MockDate.toString = function() {
 };
 function mockDate(date) {
   const dateObj = new RealDate(date.valueOf());
-  if (Number.isNaN(dateObj.getTime())) {
-    throw new TypeError(`mockdate: The time set is an invalid date: ${date}`);
-  }
+  if (Number.isNaN(dateObj.getTime())) throw new TypeError(`mockdate: The time set is an invalid date: ${date}`);
   globalThis.Date = MockDate;
   now2 = dateObj.valueOf();
 }
@@ -12848,7 +13190,7 @@ function resetDate() {
   globalThis.Date = RealDate;
 }
 
-// ../../node_modules/.pnpm/vitest@3.1.2_@edge-runtime+vm@3.2.0_@types+debug@4.1.12_@types+node@20.17.32_@vitest+ui_3f295c4d69ef1c15dd9f9eff0f44d011/node_modules/vitest/dist/chunks/vi.ClIskdbk.js
+// ../../node_modules/.pnpm/vitest@3.2.2_@edge-runtime+vm@3.2.0_@types+debug@4.1.12_@types+node@20.19.0_@vitest+ui@_eb265836689cb09b255052147598b424/node_modules/vitest/dist/chunks/vi.bdSIJ99Y.js
 var unsupported = [
   "matchSnapshot",
   "toMatchSnapshot",
@@ -12869,20 +13211,12 @@ function createExpectPoll(expect2) {
     const assertion = expect2(null, message).withContext({ poll: true });
     fn2 = fn2.bind(assertion);
     const test5 = utils_exports.flag(assertion, "vitest-test");
-    if (!test5) {
-      throw new Error("expect.poll() must be called inside a test");
-    }
+    if (!test5) 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 (typeof assertionFunction !== "function") {
-        return assertionFunction instanceof Assertion ? proxy : assertionFunction;
-      }
-      if (key === "assert") {
-        return assertionFunction;
-      }
-      if (typeof key === "string" && unsupported.includes(key)) {
-        throw new SyntaxError(`expect.poll() is not supported in combination with .${key}(). Use vi.waitFor() if your assertion condition is unstable.`);
-      }
+      if (typeof assertionFunction !== "function") return assertionFunction instanceof Assertion ? proxy : assertionFunction;
+      if (key === "assert") return assertionFunction;
+      if (typeof key === "string" && unsupported.includes(key)) throw new SyntaxError(`expect.poll() is not supported in combination with .${key}(). Use vi.waitFor() if your assertion condition is unstable.`);
       return function(...args) {
         const STACK_TRACE_ERROR = new Error("STACK_TRACE_ERROR");
         const promise = () => new Promise((resolve4, reject) => {
@@ -12900,9 +13234,7 @@ function createExpectPoll(expect2) {
               clearTimeout(timeoutId);
             } catch (err) {
               lastError = err;
-              if (!utils_exports.flag(assertion, "_isLastPollAttempt")) {
-                intervalId = setTimeout(check, interval);
-              }
+              if (!utils_exports.flag(assertion, "_isLastPollAttempt")) intervalId = setTimeout(check, interval);
             }
           };
           timeoutId = setTimeout(() => {
@@ -12949,9 +13281,7 @@ await ${assertionString}
   };
 }
 function copyStackTrace$1(target, source) {
-  if (source.stack !== void 0) {
-    target.stack = source.stack.replace(source.message, target.message);
-  }
+  if (source.stack !== void 0) target.stack = source.stack.replace(source.message, target.message);
   return target;
 }
 function commonjsRequire(path) {
@@ -13051,17 +13381,11 @@ function recordAsyncExpect2(_test2, promise, assertion, error) {
   const test5 = _test2;
   if (test5 && promise instanceof Promise) {
     promise = promise.finally(() => {
-      if (!test5.promises) {
-        return;
-      }
+      if (!test5.promises) return;
       const index2 = test5.promises.indexOf(promise);
-      if (index2 !== -1) {
-        test5.promises.splice(index2, 1);
-      }
+      if (index2 !== -1) test5.promises.splice(index2, 1);
     });
-    if (!test5.promises) {
-      test5.promises = [];
-    }
+    if (!test5.promises) test5.promises = [];
     test5.promises.push(promise);
     let resolved = false;
     test5.onFinished ??= [];
@@ -13095,18 +13419,14 @@ function recordAsyncExpect2(_test2, promise, assertion, error) {
 }
 var _client;
 function getSnapshotClient() {
-  if (!_client) {
-    _client = new SnapshotClient({ isEqual: (received, expected) => {
-      return equals(received, expected, [iterableEquality, subsetEquality]);
-    } });
-  }
+  if (!_client) _client = new SnapshotClient({ isEqual: (received, expected) => {
+    return equals(received, expected, [iterableEquality, subsetEquality]);
+  } });
   return _client;
 }
 function getError(expected, promise) {
   if (typeof expected !== "function") {
-    if (!promise) {
-      throw new Error(`expected must be a function, received ${typeof expected}`);
-    }
+    if (!promise) throw new Error(`expected must be a function, received ${typeof expected}`);
     return expected;
   }
   try {
@@ -13126,41 +13446,33 @@ function getTestNames(test5) {
 var SnapshotPlugin = (chai2, utils) => {
   function getTest(assertionName, obj) {
     const test5 = utils.flag(obj, "vitest-test");
-    if (!test5) {
-      throw new Error(`'${assertionName}' cannot be used without test context`);
-    }
+    if (!test5) throw new Error(`'${assertionName}' cannot be used without test context`);
     return test5;
   }
-  for (const key of ["matchSnapshot", "toMatchSnapshot"]) {
-    utils.addMethod(chai2.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 test5 = getTest(key, this);
-      if (typeof properties === "string" && typeof message === "undefined") {
-        message = properties;
-        properties = void 0;
-      }
-      const errorMessage = utils.flag(this, "message");
-      getSnapshotClient().assert({
-        received: expected,
-        message,
-        isInline: false,
-        properties,
-        errorMessage,
-        ...getTestNames(test5)
-      });
+  for (const key of ["matchSnapshot", "toMatchSnapshot"]) utils.addMethod(chai2.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 test5 = getTest(key, this);
+    if (typeof properties === "string" && typeof message === "undefined") {
+      message = properties;
+      properties = void 0;
+    }
+    const errorMessage = utils.flag(this, "message");
+    getSnapshotClient().assert({
+      received: expected,
+      message,
+      isInline: false,
+      properties,
+      errorMessage,
+      ...getTestNames(test5)
     });
-  }
+  });
   utils.addMethod(chai2.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"');
-    }
+    if (isNot) throw new Error('toMatchFileSnapshot cannot be used with "not"');
     const error = new Error("resolves");
     const expected = utils.flag(this, "object");
     const test5 = getTest("toMatchFileSnapshot", this);
@@ -13178,14 +13490,10 @@ var SnapshotPlugin = (chai2, utils) => {
   utils.addMethod(chai2.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"');
-    }
+    if (isNot) throw new Error('toMatchInlineSnapshot cannot be used with "not"');
     const test5 = getTest("toMatchInlineSnapshot", this);
     const isInsideEach = test5.each || test5.suite?.each;
-    if (isInsideEach) {
-      throw new Error("InlineSnapshot cannot be used inside of test.each or describe.each");
-    }
+    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 (typeof properties === "string") {
@@ -13193,9 +13501,7 @@ var SnapshotPlugin = (chai2, utils) => {
       inlineSnapshot = properties;
       properties = void 0;
     }
-    if (inlineSnapshot) {
-      inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
-    }
+    if (inlineSnapshot) inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
     const errorMessage = utils.flag(this, "message");
     getSnapshotClient().assert({
       received: expected,
@@ -13211,9 +13517,7 @@ var SnapshotPlugin = (chai2, utils) => {
   utils.addMethod(chai2.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"');
-    }
+    if (isNot) throw new Error('toThrowErrorMatchingSnapshot cannot be used with "not"');
     const expected = utils.flag(this, "object");
     const test5 = getTest("toThrowErrorMatchingSnapshot", this);
     const promise = utils.flag(this, "promise");
@@ -13227,21 +13531,15 @@ var SnapshotPlugin = (chai2, utils) => {
   });
   utils.addMethod(chai2.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"');
-    }
+    if (isNot) throw new Error('toThrowErrorMatchingInlineSnapshot cannot be used with "not"');
     const test5 = getTest("toThrowErrorMatchingInlineSnapshot", this);
     const isInsideEach = test5.each || test5.suite?.each;
-    if (isInsideEach) {
-      throw new Error("InlineSnapshot cannot be used inside of test.each or describe.each");
-    }
+    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 = stripSnapshotIndentation(inlineSnapshot);
-    }
+    if (inlineSnapshot) inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
     getSnapshotClient().assert({
       received: getError(expected, promise),
       message,
@@ -13263,13 +13561,11 @@ function createExpect(test5) {
   const expect2 = (value, message) => {
     const { assertionCalls } = getState(expect2);
     setState({ assertionCalls: assertionCalls + 1 }, expect2);
-    const assert3 = expect(value, message);
+    const assert4 = expect(value, message);
     const _test2 = test5 || getCurrentTest();
-    if (_test2) {
-      return assert3.withTest(_test2);
-    } else {
-      return assert3;
-    }
+    if (_test2)
+      return assert4.withTest(_test2);
+    else return assert4;
   };
   Object.assign(expect2, expect);
   Object.assign(expect2, globalThis[ASYMMETRIC_MATCHERS_OBJECT]);
@@ -13296,13 +13592,11 @@ function createExpect(test5) {
   };
   expect2.poll = createExpectPoll(expect2);
   expect2.unreachable = (message) => {
-    assert.fail(`expected${message ? ` "${message}" ` : " "}not to be reached`);
+    assert2.fail(`expected${message ? ` "${message}" ` : " "}not to be reached`);
   };
   function assertions(expected) {
     const errorGen = () => new Error(`expected number of assertions to be ${expected}, but got ${expect2.getState().assertionCalls}`);
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(errorGen(), assertions);
-    }
+    if (Error.captureStackTrace) Error.captureStackTrace(errorGen(), assertions);
     expect2.setState({
       expectedAssertionsNumber: expected,
       expectedAssertionsNumberErrorGen: errorGen
@@ -13310,9 +13604,7 @@ function createExpect(test5) {
   }
   function hasAssertions() {
     const error = new Error("expected any number of assertion, but got none");
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(error, hasAssertions);
-    }
+    if (Error.captureStackTrace) Error.captureStackTrace(error, hasAssertions);
     expect2.setState({
       isExpectingAssertions: true,
       isExpectingAssertionsError: error
@@ -13419,10 +13711,10 @@ function requireCalledInOrder() {
     }
     return callMap[spy.id] < spy.callCount;
   }
-  function checkAdjacentCalls(callMap, spy, index2, spies) {
+  function checkAdjacentCalls(callMap, spy, index2, spies2) {
     var calledBeforeNext = true;
-    if (index2 !== spies.length - 1) {
-      calledBeforeNext = spy.calledBefore(spies[index2 + 1]);
+    if (index2 !== spies2.length - 1) {
+      calledBeforeNext = spy.calledBefore(spies2[index2 + 1]);
     }
     if (hasCallsLeft(callMap, spy) && calledBeforeNext) {
       callMap[spy.id] += 1;
@@ -13430,9 +13722,9 @@ function requireCalledInOrder() {
     }
     return false;
   }
-  function calledInOrder(spies) {
+  function calledInOrder(spies2) {
     var callMap = {};
-    var _spies = arguments.length > 1 ? arguments : spies;
+    var _spies = arguments.length > 1 ? arguments : spies2;
     return every2(_spies, checkAdjacentCalls.bind(null, callMap));
   }
   calledInOrder_1 = calledInOrder;
@@ -13536,8 +13828,8 @@ function requireOrderByFirstCall() {
     var bId = bCall && bCall.callId || -1;
     return aId < bId ? -1 : 1;
   }
-  function orderByFirstCall(spies) {
-    return sort2(slice(spies), comparator);
+  function orderByFirstCall(spies2) {
+    return sort2(slice(spies2), comparator);
   }
   orderByFirstCall_1 = orderByFirstCall;
   return orderByFirstCall_1;
@@ -13864,11 +14156,11 @@ function requireFakeTimersSrc() {
         return 0;
       }
       const strings = str.split(":");
-      const l2 = strings.length;
-      let i = l2;
+      const l = strings.length;
+      let i = l;
       let ms = 0;
       let parsed;
-      if (l2 > 3 || !/^(\d\d:){0,2}\d\d?$/.test(str)) {
+      if (l > 3 || !/^(\d\d:){0,2}\d\d?$/.test(str)) {
         throw new Error(
           "tick only understands numbers, 'm:s' and 'h:m:s'. Each part must be two digits"
         );
@@ -13878,7 +14170,7 @@ function requireFakeTimersSrc() {
         if (parsed >= 60) {
           throw new Error(`Invalid time ${str}`);
         }
-        ms += parsed * Math.pow(60, l2 - i - 1);
+        ms += parsed * Math.pow(60, l - i - 1);
       }
       return ms * 1e3;
     }
@@ -14250,10 +14542,10 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
       }
     }
     function uninstall(clock, config2) {
-      let method, i, l2;
+      let method, i, l;
       const installedHrTime = "_hrtime";
       const installedNextTick = "_nextTick";
-      for (i = 0, l2 = clock.methods.length; i < l2; i++) {
+      for (i = 0, l = clock.methods.length; i < l; i++) {
         method = clock.methods[i];
         if (method === "hrtime" && _global.process) {
           _global.process.hrtime = clock[installedHrTime];
@@ -14796,7 +15088,7 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
           });
         };
       }
-      clock.reset = function reset() {
+      clock.reset = function reset2() {
         nanos = 0;
         clock.timers = {};
         clock.jobs = [];
@@ -14867,7 +15159,7 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
           `non-existent timers and/or objects cannot be faked: '${timer}'`
         );
       }
-      let i, l2;
+      let i, l;
       const clock = createClock(config2.now, config2.loopLimit);
       clock.shouldClearNativeTimers = config2.shouldClearNativeTimers;
       clock.uninstall = function() {
@@ -14918,7 +15210,7 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
       if (_global === globalObject && timersPromisesModule) {
         clock.timersPromisesModuleMethods = [];
       }
-      for (i = 0, l2 = clock.methods.length; i < l2; i++) {
+      for (i = 0, l = clock.methods.length; i < l; i++) {
         const nameOfMethodToReplace = clock.methods[i];
         if (!isPresent[nameOfMethodToReplace]) {
           handleMissingTimer(nameOfMethodToReplace);
@@ -15152,6 +15444,12 @@ var fakeTimersSrcExports = requireFakeTimersSrc();
 var FakeTimers = class {
   _global;
   _clock;
+  // | _fakingTime | _fakingDate |
+  // +-------------+-------------+
+  // | false       | falsy       | initial
+  // | false       | truthy     | vi.setSystemTime called first (for mocking only Date without fake timers)
+  // | true        | falsy       | vi.useFakeTimers called first
+  // | true        | truthy     | unreachable
   _fakingTime;
   _fakingDate;
   _fakeTimers;
@@ -15165,74 +15463,49 @@ var FakeTimers = class {
     this._global = global3;
   }
   clearAllTimers() {
-    if (this._fakingTime) {
-      this._clock.reset();
-    }
+    if (this._fakingTime) this._clock.reset();
   }
   dispose() {
     this.useRealTimers();
   }
   runAllTimers() {
-    if (this._checkFakeTimers()) {
-      this._clock.runAll();
-    }
+    if (this._checkFakeTimers()) this._clock.runAll();
   }
   async runAllTimersAsync() {
-    if (this._checkFakeTimers()) {
-      await this._clock.runAllAsync();
-    }
+    if (this._checkFakeTimers()) await this._clock.runAllAsync();
   }
   runOnlyPendingTimers() {
-    if (this._checkFakeTimers()) {
-      this._clock.runToLast();
-    }
+    if (this._checkFakeTimers()) this._clock.runToLast();
   }
   async runOnlyPendingTimersAsync() {
-    if (this._checkFakeTimers()) {
-      await this._clock.runToLastAsync();
-    }
+    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 (this._clock.countTimers() === 0) {
-          break;
-        }
-      }
+    if (this._checkFakeTimers()) for (let i = steps; i > 0; i--) {
+      this._clock.next();
+      this._clock.tick(0);
+      if (this._clock.countTimers() === 0) break;
     }
   }
   async advanceTimersToNextTimerAsync(steps = 1) {
-    if (this._checkFakeTimers()) {
-      for (let i = steps; i > 0; i--) {
-        await this._clock.nextAsync();
-        this._clock.tick(0);
-        if (this._clock.countTimers() === 0) {
-          break;
-        }
-      }
+    if (this._checkFakeTimers()) for (let i = steps; i > 0; i--) {
+      await this._clock.nextAsync();
+      this._clock.tick(0);
+      if (this._clock.countTimers() === 0) break;
     }
   }
   advanceTimersByTime(msToRun) {
-    if (this._checkFakeTimers()) {
-      this._clock.tick(msToRun);
-    }
+    if (this._checkFakeTimers()) this._clock.tick(msToRun);
   }
   async advanceTimersByTimeAsync(msToRun) {
-    if (this._checkFakeTimers()) {
-      await this._clock.tickAsync(msToRun);
-    }
+    if (this._checkFakeTimers()) await this._clock.tickAsync(msToRun);
   }
   advanceTimersToNextFrame() {
-    if (this._checkFakeTimers()) {
-      this._clock.runToFrame();
-    }
+    if (this._checkFakeTimers()) this._clock.runToFrame();
   }
   runAllTicks() {
-    if (this._checkFakeTimers()) {
+    if (this._checkFakeTimers())
       this._clock.runMicrotasks();
-    }
   }
   useRealTimers() {
     if (this._fakingDate) {
@@ -15245,14 +15518,10 @@ var FakeTimers = class {
     }
   }
   useFakeTimers() {
-    if (this._fakingDate) {
-      throw new Error('"setSystemTime" was called already and date was mocked. Reset timers using `vi.useRealTimers()` if you want to use fake timers again.');
-    }
+    if (this._fakingDate) throw new Error('"setSystemTime" was called already and date was mocked. Reset timers using `vi.useRealTimers()` if you want to use fake timers again.');
     if (!this._fakingTime) {
       const toFake = Object.keys(this._fakeTimers.timers).filter((timer) => timer !== "nextTick" && timer !== "queueMicrotask");
-      if (this._userConfig?.toFake?.includes("nextTick") && isChildProcess()) {
-        throw new Error("process.nextTick cannot be mocked inside child_process");
-      }
+      if (this._userConfig?.toFake?.includes("nextTick") && isChildProcess()) throw new Error("process.nextTick cannot be mocked inside child_process");
       this._clock = this._fakeTimers.install({
         now: Date.now(),
         ...this._userConfig,
@@ -15271,9 +15540,8 @@ var FakeTimers = class {
   }
   setSystemTime(now3) {
     const date = typeof now3 === "undefined" || now3 instanceof Date ? now3 : new Date(now3);
-    if (this._fakingTime) {
-      this._clock.setSystemTime(date);
-    } else {
+    if (this._fakingTime) this._clock.setSystemTime(date);
+    else {
       this._fakingDate = date ?? new Date(this.getRealSystemTime());
       mockDate(this._fakingDate);
     }
@@ -15285,9 +15553,7 @@ var FakeTimers = class {
     return this._now();
   }
   getTimerCount() {
-    if (this._checkFakeTimers()) {
-      return this._clock.countTimers();
-    }
+    if (this._checkFakeTimers()) return this._clock.countTimers();
     return 0;
   }
   configure(config2) {
@@ -15297,16 +15563,12 @@ var FakeTimers = class {
     return this._fakingTime;
   }
   _checkFakeTimers() {
-    if (!this._fakingTime) {
-      throw new Error('Timers are not mocked. Try calling "vi.useFakeTimers()" first.');
-    }
+    if (!this._fakingTime) throw new Error('Timers are not mocked. Try calling "vi.useFakeTimers()" first.');
     return this._fakingTime;
   }
 };
 function copyStackTrace(target, source) {
-  if (source.stack !== void 0) {
-    target.stack = source.stack.replace(source.message, target.message);
-  }
+  if (source.stack !== void 0) target.stack = source.stack.replace(source.message, target.message);
   return target;
 }
 function waitFor(callback, options = {}) {
@@ -15319,31 +15581,19 @@ function waitFor(callback, options = {}) {
     let timeoutId;
     let intervalId;
     const onResolve = (result) => {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
-      if (intervalId) {
-        clearInterval(intervalId);
-      }
+      if (timeoutId) clearTimeout(timeoutId);
+      if (intervalId) clearInterval(intervalId);
       resolve4(result);
     };
     const handleTimeout = () => {
-      if (intervalId) {
-        clearInterval(intervalId);
-      }
+      if (intervalId) clearInterval(intervalId);
       let error = lastError;
-      if (!error) {
-        error = copyStackTrace(new Error("Timed out in waitFor!"), STACK_TRACE_ERROR);
-      }
+      if (!error) error = copyStackTrace(new Error("Timed out in waitFor!"), STACK_TRACE_ERROR);
       reject(error);
     };
     const checkCallback = () => {
-      if (vi.isFakeTimers()) {
-        vi.advanceTimersByTime(interval);
-      }
-      if (promiseStatus === "pending") {
-        return;
-      }
+      if (vi.isFakeTimers()) vi.advanceTimersByTime(interval);
+      if (promiseStatus === "pending") return;
       try {
         const result = callback();
         if (result !== null && typeof result === "object" && typeof result.then === "function") {
@@ -15364,9 +15614,7 @@ function waitFor(callback, options = {}) {
         lastError = error;
       }
     };
-    if (checkCallback() === true) {
-      return;
-    }
+    if (checkCallback() === true) return;
     timeoutId = setTimeout(handleTimeout, timeout);
     intervalId = setInterval(checkCallback, interval);
   });
@@ -15380,34 +15628,20 @@ function waitUntil(callback, options = {}) {
     let timeoutId;
     let intervalId;
     const onReject = (error) => {
-      if (intervalId) {
-        clearInterval(intervalId);
-      }
-      if (!error) {
-        error = copyStackTrace(new Error("Timed out in waitUntil!"), STACK_TRACE_ERROR);
-      }
+      if (intervalId) clearInterval(intervalId);
+      if (!error) error = copyStackTrace(new Error("Timed out in waitUntil!"), STACK_TRACE_ERROR);
       reject(error);
     };
     const onResolve = (result) => {
-      if (!result) {
-        return;
-      }
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
-      if (intervalId) {
-        clearInterval(intervalId);
-      }
+      if (!result) return;
+      if (timeoutId) clearTimeout(timeoutId);
+      if (intervalId) clearInterval(intervalId);
       resolve4(result);
       return true;
     };
     const checkCallback = () => {
-      if (vi.isFakeTimers()) {
-        vi.advanceTimersByTime(interval);
-      }
-      if (promiseStatus === "pending") {
-        return;
-      }
+      if (vi.isFakeTimers()) vi.advanceTimersByTime(interval);
+      if (promiseStatus === "pending") return;
       try {
         const result = callback();
         if (result !== null && typeof result === "object" && typeof result.then === "function") {
@@ -15420,16 +15654,12 @@ function waitUntil(callback, options = {}) {
             promiseStatus = "rejected";
             onReject(rejectedValue);
           });
-        } else {
-          return onResolve(result);
-        }
+        } else return onResolve(result);
       } catch (error) {
         onReject(error);
       }
     };
-    if (checkCallback() === true) {
-      return;
-    }
+    if (checkCallback() === true) return;
     timeoutId = setTimeout(onReject, timeout);
     intervalId = setInterval(checkCallback, interval);
   });
@@ -15452,18 +15682,13 @@ function createVitest() {
   const utils = {
     useFakeTimers(config2) {
       if (isChildProcess()) {
-        if (config2?.toFake?.includes("nextTick") || workerState.config?.fakeTimers?.toFake?.includes("nextTick")) {
-          throw new Error('vi.useFakeTimers({ toFake: ["nextTick"] }) is not supported in node:child_process. Use --pool=threads if mocking nextTick is required.');
-        }
-      }
-      if (config2) {
-        timers().configure({
-          ...workerState.config.fakeTimers,
-          ...config2
-        });
-      } else {
-        timers().configure(workerState.config.fakeTimers);
+        if (config2?.toFake?.includes("nextTick") || workerState.config?.fakeTimers?.toFake?.includes("nextTick")) throw new Error('vi.useFakeTimers({ toFake: ["nextTick"] }) is not supported in node:child_process. Use --pool=threads if mocking nextTick is required.');
       }
+      if (config2) timers().configure({
+        ...workerState.config.fakeTimers,
+        ...config2
+      });
+      else timers().configure(workerState.config.fakeTimers);
       timers().useFakeTimers();
       return utils;
     },
@@ -15540,29 +15765,21 @@ function createVitest() {
       return factory();
     },
     mock(path, factory) {
-      if (typeof path !== "string") {
-        throw new TypeError(`vi.mock() expects a string path, but received a ${typeof path}`);
-      }
+      if (typeof path !== "string") throw new TypeError(`vi.mock() expects a string path, but received a ${typeof path}`);
       const importer = getImporter("mock");
       _mocker().queueMock(path, importer, typeof factory === "function" ? () => factory(() => _mocker().importActual(path, importer, _mocker().getMockContext().callstack)) : factory);
     },
     unmock(path) {
-      if (typeof path !== "string") {
-        throw new TypeError(`vi.unmock() expects a string path, but received a ${typeof path}`);
-      }
+      if (typeof path !== "string") throw new TypeError(`vi.unmock() expects a string path, but received a ${typeof path}`);
       _mocker().queueUnmock(path, getImporter("unmock"));
     },
     doMock(path, factory) {
-      if (typeof path !== "string") {
-        throw new TypeError(`vi.doMock() expects a string path, but received a ${typeof path}`);
-      }
+      if (typeof path !== "string") throw new TypeError(`vi.doMock() expects a string path, but received a ${typeof path}`);
       const importer = getImporter("doMock");
       _mocker().queueMock(path, importer, typeof factory === "function" ? () => factory(() => _mocker().importActual(path, importer, _mocker().getMockContext().callstack)) : factory);
     },
     doUnmock(path) {
-      if (typeof path !== "string") {
-        throw new TypeError(`vi.doUnmock() expects a string path, but received a ${typeof path}`);
-      }
+      if (typeof path !== "string") throw new TypeError(`vi.doUnmock() expects a string path, but received a ${typeof path}`);
       _mocker().queueUnmock(path, getImporter("doUnmock"));
     },
     async importActual(path) {
@@ -15571,11 +15788,14 @@ function createVitest() {
     async importMock(path) {
       return _mocker().importMock(path, getImporter("importMock"));
     },
+    mockObject(value) {
+      return _mocker().mockObject({ value }).value;
+    },
     mocked(item, _options = {}) {
       return item;
     },
     isMockFunction(fn2) {
-      return isMockFunction(fn2);
+      return isMockFunction2(fn2);
     },
     clearAllMocks() {
       [...mocks].reverse().forEach((spy) => spy.mockClear());
@@ -15590,9 +15810,7 @@ function createVitest() {
       return utils;
     },
     stubGlobal(name, value) {
-      if (!_stubsGlobal.has(name)) {
-        _stubsGlobal.set(name, Object.getOwnPropertyDescriptor(globalThis, name));
-      }
+      if (!_stubsGlobal.has(name)) _stubsGlobal.set(name, Object.getOwnPropertyDescriptor(globalThis, name));
       Object.defineProperty(globalThis, name, {
         value,
         writable: true,
@@ -15602,36 +15820,24 @@ function createVitest() {
       return utils;
     },
     stubEnv(name, value) {
-      if (!_stubsEnv.has(name)) {
-        _stubsEnv.set(name, process.env[name]);
-      }
-      if (_envBooleans.includes(name)) {
-        process.env[name] = value ? "1" : "";
-      } else if (value === void 0) {
-        delete process.env[name];
-      } else {
-        process.env[name] = String(value);
-      }
+      if (!_stubsEnv.has(name)) _stubsEnv.set(name, process.env[name]);
+      if (_envBooleans.includes(name)) process.env[name] = value ? "1" : "";
+      else if (value === void 0) delete process.env[name];
+      else process.env[name] = String(value);
       return utils;
     },
     unstubAllGlobals() {
       _stubsGlobal.forEach((original, name) => {
-        if (!original) {
-          Reflect.deleteProperty(globalThis, name);
-        } else {
-          Object.defineProperty(globalThis, name, original);
-        }
+        if (!original) Reflect.deleteProperty(globalThis, name);
+        else Object.defineProperty(globalThis, name, original);
       });
       _stubsGlobal.clear();
       return utils;
     },
     unstubAllEnvs() {
       _stubsEnv.forEach((original, name) => {
-        if (original === void 0) {
-          delete process.env[name];
-        } else {
-          process.env[name] = original;
-        }
+        if (original === void 0) delete process.env[name];
+        else process.env[name] = original;
       });
       _stubsEnv.clear();
       return utils;
@@ -15644,15 +15850,11 @@ function createVitest() {
       return waitForImportsToResolve();
     },
     setConfig(config2) {
-      if (!_config) {
-        _config = { ...workerState.config };
-      }
+      if (!_config) _config = { ...workerState.config };
       Object.assign(workerState.config, config2);
     },
     resetConfig() {
-      if (_config) {
-        Object.assign(workerState.config, _config);
-      }
+      if (_config) Object.assign(workerState.config, _config);
     }
   };
   return utils;
@@ -15674,36 +15876,11 @@ function getImporter(name) {
   return stack?.file || "";
 }
 
-// ../../node_modules/.pnpm/vitest@3.1.2_@edge-runtime+vm@3.2.0_@types+debug@4.1.12_@types+node@20.17.32_@vitest+ui_3f295c4d69ef1c15dd9f9eff0f44d011/node_modules/vitest/dist/chunks/run-once.Dimr7O9f.js
-var filesCount = /* @__PURE__ */ new Map();
-var cache = /* @__PURE__ */ new Map();
-function runOnce(fn2, key) {
-  const filepath = getWorkerState().filepath || "__unknown_files__";
-  if (!key) {
-    filesCount.set(filepath, (filesCount.get(filepath) || 0) + 1);
-    key = String(filesCount.get(filepath));
-  }
-  const id = `${filepath}:${key}`;
-  if (!cache.has(id)) {
-    cache.set(id, fn2());
-  }
-  return cache.get(id);
-}
-function isFirstRun() {
-  let firstRun = false;
-  runOnce(() => {
-    firstRun = true;
-  }, "__vitest_first_run__");
-  return firstRun;
-}
-
-// ../../node_modules/.pnpm/vitest@3.1.2_@edge-runtime+vm@3.2.0_@types+debug@4.1.12_@types+node@20.17.32_@vitest+ui_3f295c4d69ef1c15dd9f9eff0f44d011/node_modules/vitest/dist/chunks/benchmark.BoF7jW0Q.js
+// ../../node_modules/.pnpm/vitest@3.2.2_@edge-runtime+vm@3.2.0_@types+debug@4.1.12_@types+node@20.19.0_@vitest+ui@_eb265836689cb09b255052147598b424/node_modules/vitest/dist/chunks/benchmark.CYdenmiT.js
 var benchFns = /* @__PURE__ */ new WeakMap();
 var benchOptsMap = /* @__PURE__ */ new WeakMap();
 var bench = createBenchmark(function(name, fn2 = noop, options = {}) {
-  if (getWorkerState().config.mode !== "benchmark") {
-    throw new Error("`bench()` is only available in benchmark mode.");
-  }
+  if (getWorkerState().config.mode !== "benchmark") throw new Error("`bench()` is only available in benchmark mode.");
   const task = getCurrentSuite().task(formatName2(name), {
     ...this,
     meta: { benchmark: true }
@@ -15725,18 +15902,12 @@ function formatName2(name) {
   return typeof name === "string" ? name : typeof name === "function" ? name.name || "<anonymous>" : String(name);
 }
 
-// ../../node_modules/.pnpm/vitest@3.1.2_@edge-runtime+vm@3.2.0_@types+debug@4.1.12_@types+node@20.17.32_@vitest+ui_3f295c4d69ef1c15dd9f9eff0f44d011/node_modules/vitest/dist/chunks/index.B0uVAVvx.js
+// ../../node_modules/.pnpm/vitest@3.2.2_@edge-runtime+vm@3.2.0_@types+debug@4.1.12_@types+node@20.19.0_@vitest+ui@_eb265836689cb09b255052147598b424/node_modules/vitest/dist/chunks/index.CdQS2e2Q.js
 __toESM(require_dist(), 1);
-function getRunningMode() {
-  return process.env.VITEST_MODE === "WATCH" ? "watch" : "run";
-}
-function isWatchMode() {
-  return getRunningMode() === "watch";
-}
 var assertType = function assertType2() {
 };
 
-// ../../node_modules/.pnpm/vitest@3.1.2_@edge-runtime+vm@3.2.0_@types+debug@4.1.12_@types+node@20.17.32_@vitest+ui_3f295c4d69ef1c15dd9f9eff0f44d011/node_modules/vitest/dist/index.js
+// ../../node_modules/.pnpm/vitest@3.2.2_@edge-runtime+vm@3.2.0_@types+debug@4.1.12_@types+node@20.19.0_@vitest+ui@_eb265836689cb09b255052147598b424/node_modules/vitest/dist/index.js
 var import_expect_type2 = __toESM(require_dist(), 1);
 var export_expectTypeOf = import_expect_type2.expectTypeOf;
 /*! Bundled license information:
@@ -16031,4 +16202,4 @@ chai/chai.js:
    *)
 */
 
-export { afterAll, afterEach, assert, assertType, beforeAll, beforeEach, bench, chai_exports as chai, createExpect, describe, globalExpect as expect, export_expectTypeOf as expectTypeOf, getRunningMode, inject, isFirstRun, isWatchMode, it, onTestFailed, onTestFinished, runOnce, should, suite, test3 as test, vi, vitest };
+export { afterAll, afterEach, assert2 as assert, assertType, beforeAll, beforeEach, bench, chai_exports as chai, createExpect, describe, globalExpect as expect, export_expectTypeOf as expectTypeOf, inject, it, onTestFailed, onTestFinished, should, suite, test3 as test, vi, vitest };