@noma.to/qwik-testing-library 1.2.0 → 1.3.0

package/lib/node_modules/.pnpm/vitest@2.1.1_@types_node@22.7.4_@vitest_ui@2.1.1_jsdom@25.0.1/node_modules/vitest/dist/chunks/vi.D6IHiKAI.qwik.cjs

@@ -1,2556 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const chai$1 = require("../../../../../chai@5.1.1/node_modules/chai/chai.qwik.cjs");
-const _commonjsHelpers_BFTU3MAI = require("./_commonjsHelpers.BFTU3MAI.qwik.cjs");
-const index = require("../../../../../@vitest_expect@2.1.1/node_modules/@vitest/expect/dist/index.qwik.cjs");
-const index$1 = require("../../../../../@vitest_snapshot@2.1.1/node_modules/@vitest/snapshot/dist/index.qwik.cjs");
-const chunkTasks = require("../../../../../@vitest_runner@2.1.1/node_modules/@vitest/runner/dist/chunk-tasks.qwik.cjs");
-const index$3 = require("../../../../../@vitest_utils@2.1.1/node_modules/@vitest/utils/dist/index.qwik.cjs");
-require("../../../../../@vitest_runner@2.1.1/node_modules/@vitest/runner/dist/index.qwik.cjs");
-const utils_Ck2hJTRs = require("./utils.Ck2hJTRs.qwik.cjs");
-const sourceMap = require("../../../../../@vitest_utils@2.1.1/node_modules/@vitest/utils/dist/source-map.qwik.cjs");
-const base_BlXpj3e_ = require("./base.BlXpj3e_.qwik.cjs");
-const date_W2xKR2qe = require("./date.W2xKR2qe.qwik.cjs");
-const index$2 = require("../../../../../@vitest_spy@2.1.1/node_modules/@vitest/spy/dist/index.qwik.cjs");
-const helpers = require("../../../../../@vitest_utils@2.1.1/node_modules/@vitest/utils/dist/helpers.qwik.cjs");
-function resetModules(modules, resetMocks = false) {
-  const skipPaths = [
-    // Vitest
-    /\/vitest\/dist\//,
-    /\/vite-node\/dist\//,
-    // yarn's .store folder
-    /vitest-virtual-\w+\/dist/,
-    // cnpm
-    /@vitest\/dist/,
-    // don't clear mocks
-    ...!resetMocks ? [/^mock:/] : []
-  ];
-  modules.forEach((mod, path) => {
-    if (skipPaths.some((re) => re.test(path))) {
-      return;
-    }
-    modules.invalidateModule(mod);
-  });
-}
-function waitNextTick() {
-  const { setTimeout } = index$3.getSafeTimers();
-  return new Promise((resolve) => setTimeout(resolve, 0));
-}
-async function waitForImportsToResolve() {
-  await waitNextTick();
-  const state = utils_Ck2hJTRs.g();
-  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;
-  }
-  await Promise.allSettled(promises);
-  await waitForImportsToResolve();
-}
-function commonjsRequire(path) {
-  throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
-}
-var chaiSubset = { exports: {} };
-(function(module2, exports2) {
-  (function() {
-    (function(chaiSubset2) {
-      if (typeof commonjsRequire === "function" && true && true) {
-        return module2.exports = chaiSubset2;
-      } else {
-        return chai.use(chaiSubset2);
-      }
-    })(function(chai2, utils) {
-      var Assertion = chai2.Assertion;
-      var assertionPrototype = Assertion.prototype;
-      Assertion.addMethod("containSubset", function(expected) {
-        var actual = utils.flag(this, "object");
-        var showDiff = chai2.config.showDiff;
-        assertionPrototype.assert.call(
-          this,
-          compare(expected, actual),
-          "expected #{act} to contain subset #{exp}",
-          "expected #{act} to not contain subset #{exp}",
-          expected,
-          actual,
-          showDiff
-        );
-      });
-      chai2.assert.containSubset = function(val, exp, msg) {
-        new chai2.Assertion(val, msg).to.be.containSubset(exp);
-      };
-      function compare(expected, actual) {
-        if (expected === actual) {
-          return true;
-        }
-        if (typeof actual !== typeof expected) {
-          return false;
-        }
-        if (typeof expected !== "object" || expected === null) {
-          return expected === actual;
-        }
-        if (!!expected && !actual) {
-          return false;
-        }
-        if (Array.isArray(expected)) {
-          if (typeof actual.length !== "number") {
-            return false;
-          }
-          var aa = Array.prototype.slice.call(actual);
-          return expected.every(function(exp) {
-            return aa.some(function(act) {
-              return compare(exp, act);
-            });
-          });
-        }
-        if (expected instanceof Date) {
-          if (actual instanceof Date) {
-            return expected.getTime() === actual.getTime();
-          } else {
-            return false;
-          }
-        }
-        return Object.keys(expected).every(function(key) {
-          var eo = expected[key];
-          var ao = actual[key];
-          if (typeof eo === "object" && eo !== null && ao !== null) {
-            return compare(eo, ao);
-          }
-          if (typeof eo === "function") {
-            return eo(ao);
-          }
-          return ao === eo;
-        });
-      }
-    });
-  }).call(_commonjsHelpers_BFTU3MAI.c);
-})(chaiSubset);
-var chaiSubsetExports = chaiSubset.exports;
-var Subset = /* @__PURE__ */ _commonjsHelpers_BFTU3MAI.g(chaiSubsetExports);
-function recordAsyncExpect(test, promise) {
-  if (test && promise instanceof Promise) {
-    promise = promise.finally(() => {
-      const index2 = test.promises.indexOf(promise);
-      if (index2 !== -1) {
-        test.promises.splice(index2, 1);
-      }
-    });
-    if (!test.promises) {
-      test.promises = [];
-    }
-    test.promises.push(promise);
-  }
-  return promise;
-}
-let _client;
-function getSnapshotClient() {
-  if (!_client) {
-    _client = new index$1.SnapshotClient({
-      isEqual: (received, expected) => {
-        return index.equals(received, expected, [index.iterableEquality, index.subsetEquality]);
-      }
-    });
-  }
-  return _client;
-}
-function getError(expected, promise) {
-  if (typeof expected !== "function") {
-    if (!promise) {
-      throw new Error(
-        `expected must be a function, received ${typeof expected}`
-      );
-    }
-    return expected;
-  }
-  try {
-    expected();
-  } catch (e) {
-    return e;
-  }
-  throw new Error("snapshot function didn't throw");
-}
-function getTestNames(test) {
-  if (!test) {
-    return {};
-  }
-  return {
-    filepath: test.file.filepath,
-    name: chunkTasks.k(test).slice(1).join(" > ")
-  };
-}
-const SnapshotPlugin = (chai2, utils) => {
-  for (const key of ["matchSnapshot", "toMatchSnapshot"]) {
-    utils.addMethod(
-      chai2.Assertion.prototype,
-      key,
-      function(properties, message) {
-        const isNot = utils.flag(this, "negate");
-        if (isNot) {
-          throw new Error(`${key} cannot be used with "not"`);
-        }
-        const expected = utils.flag(this, "object");
-        const test = utils.flag(this, "vitest-test");
-        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(test)
-        });
-      }
-    );
-  }
-  utils.addMethod(
-    chai2.Assertion.prototype,
-    "toMatchFileSnapshot",
-    function(file, message) {
-      const isNot = utils.flag(this, "negate");
-      if (isNot) {
-        throw new Error('toMatchFileSnapshot cannot be used with "not"');
-      }
-      const expected = utils.flag(this, "object");
-      const test = utils.flag(this, "vitest-test");
-      const errorMessage = utils.flag(this, "message");
-      const promise = getSnapshotClient().assertRaw({
-        received: expected,
-        message,
-        isInline: false,
-        rawSnapshot: {
-          file
-        },
-        errorMessage,
-        ...getTestNames(test)
-      });
-      return recordAsyncExpect(test, promise);
-    }
-  );
-  utils.addMethod(
-    chai2.Assertion.prototype,
-    "toMatchInlineSnapshot",
-    function __INLINE_SNAPSHOT__(properties, inlineSnapshot, message) {
-      const isNot = utils.flag(this, "negate");
-      if (isNot) {
-        throw new Error('toMatchInlineSnapshot cannot be used with "not"');
-      }
-      const test = utils.flag(this, "vitest-test");
-      const isInsideEach = test && (test.each || test.suite?.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") {
-        message = inlineSnapshot;
-        inlineSnapshot = properties;
-        properties = void 0;
-      }
-      if (inlineSnapshot) {
-        inlineSnapshot = index$1.stripSnapshotIndentation(inlineSnapshot);
-      }
-      const errorMessage = utils.flag(this, "message");
-      getSnapshotClient().assert({
-        received: expected,
-        message,
-        isInline: true,
-        properties,
-        inlineSnapshot,
-        error,
-        errorMessage,
-        ...getTestNames(test)
-      });
-    }
-  );
-  utils.addMethod(
-    chai2.Assertion.prototype,
-    "toThrowErrorMatchingSnapshot",
-    function(message) {
-      const isNot = utils.flag(this, "negate");
-      if (isNot) {
-        throw new Error(
-          'toThrowErrorMatchingSnapshot cannot be used with "not"'
-        );
-      }
-      const expected = utils.flag(this, "object");
-      const test = utils.flag(this, "vitest-test");
-      const promise = utils.flag(this, "promise");
-      const errorMessage = utils.flag(this, "message");
-      getSnapshotClient().assert({
-        received: getError(expected, promise),
-        message,
-        errorMessage,
-        ...getTestNames(test)
-      });
-    }
-  );
-  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"'
-        );
-      }
-      const test = utils.flag(this, "vitest-test");
-      const isInsideEach = test && (test.each || test.suite?.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 = index$1.stripSnapshotIndentation(inlineSnapshot);
-      }
-      getSnapshotClient().assert({
-        received: getError(expected, promise),
-        message,
-        inlineSnapshot,
-        isInline: true,
-        error,
-        errorMessage,
-        ...getTestNames(test)
-      });
-    }
-  );
-  utils.addMethod(chai2.expect, "addSnapshotSerializer", index$1.addSerializer);
-};
-chai$1.use(index.JestExtend);
-chai$1.use(index.JestChaiExpect);
-chai$1.use(Subset);
-chai$1.use(SnapshotPlugin);
-chai$1.use(index.JestAsymmetricMatchers);
-const unsupported = [
-  // .poll is meant to retry matchers until they succeed, and
-  // snapshots will always succeed as long as the poll method doesn't thow an error
-  // in this case using the `vi.waitFor` method is more appropriate
-  "matchSnapshot",
-  "toMatchSnapshot",
-  "toMatchInlineSnapshot",
-  "toThrowErrorMatchingSnapshot",
-  "toThrowErrorMatchingInlineSnapshot",
-  // toThrow will never succeed because we call the poll callback until it doesn't throw
-  "throws",
-  "Throw",
-  "throw",
-  "toThrow",
-  "toThrowError"
-  // these are not supported because you can call them without `.poll`,
-  // we throw an error inside the rejects/resolves methods to prevent this
-  // rejects,
-  // resolves
-];
-function createExpectPoll(expect) {
-  return function poll(fn, options = {}) {
-    const state = utils_Ck2hJTRs.g();
-    const defaults = state.config.expect?.poll ?? {};
-    const {
-      interval = defaults.interval ?? 50,
-      timeout = defaults.timeout ?? 1e3,
-      message
-    } = options;
-    const assertion = expect(null, message).withContext({
-      poll: true
-    });
-    const proxy = new Proxy(assertion, {
-      get(target, key, receiver) {
-        const assertionFunction = Reflect.get(target, key, receiver);
-        if (typeof assertionFunction !== "function") {
-          return assertionFunction instanceof chai$1.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");
-          return new Promise((resolve, reject) => {
-            let intervalId;
-            let lastError;
-            const { setTimeout, clearTimeout } = index$3.getSafeTimers();
-            const timeoutId = setTimeout(() => {
-              clearTimeout(intervalId);
-              reject(
-                copyStackTrace$1(
-                  new Error(`Matcher did not succeed in ${timeout}ms`, {
-                    cause: lastError
-                  }),
-                  STACK_TRACE_ERROR
-                )
-              );
-            }, timeout);
-            const check = async () => {
-              try {
-                const obj = await fn();
-                chai$1.util.flag(assertion, "object", obj);
-                resolve(await assertionFunction.call(assertion, ...args));
-                clearTimeout(intervalId);
-                clearTimeout(timeoutId);
-              } catch (err) {
-                lastError = err;
-                intervalId = setTimeout(check, interval);
-              }
-            };
-            check();
-          });
-        };
-      }
-    });
-    return proxy;
-  };
-}
-function copyStackTrace$1(target, source) {
-  if (source.stack !== void 0) {
-    target.stack = source.stack.replace(source.message, target.message);
-  }
-  return target;
-}
-function createExpect(test) {
-  const expect = (value, message) => {
-    const { assertionCalls } = index.getState(expect);
-    index.setState({ assertionCalls: assertionCalls + 1 }, expect);
-    const assert2 = chai$1.expect(value, message);
-    {
-      return assert2;
-    }
-  };
-  Object.assign(expect, chai$1.expect);
-  Object.assign(expect, globalThis[index.ASYMMETRIC_MATCHERS_OBJECT]);
-  expect.getState = () => index.getState(expect);
-  expect.setState = (state) => index.setState(state, expect);
-  const globalState = index.getState(globalThis[index.GLOBAL_EXPECT]) || {};
-  index.setState(
-    {
-      // this should also add "snapshotState" that is added conditionally
-      ...globalState,
-      assertionCalls: 0,
-      isExpectingAssertions: false,
-      isExpectingAssertionsError: null,
-      expectedAssertionsNumber: null,
-      expectedAssertionsNumberErrorGen: null,
-      environment: utils_Ck2hJTRs.a(),
-      get testPath() {
-        return utils_Ck2hJTRs.g().filepath;
-      },
-      currentTestName: globalState.currentTestName
-    },
-    expect
-  );
-  expect.extend = (matchers) => chai$1.expect.extend(expect, matchers);
-  expect.addEqualityTesters = (customTesters) => index.addCustomEqualityTesters(customTesters);
-  expect.soft = (...args) => {
-    return expect(...args).withContext({ soft: true });
-  };
-  expect.poll = createExpectPoll(expect);
-  expect.unreachable = (message) => {
-    chai$1.assert.fail(
-      `expected${message ? ` "${message}" ` : " "}not to be reached`
-    );
-  };
-  function assertions(expected) {
-    const errorGen = () => new Error(
-      `expected number of assertions to be ${expected}, but got ${expect.getState().assertionCalls}`
-    );
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(errorGen(), assertions);
-    }
-    expect.setState({
-      expectedAssertionsNumber: expected,
-      expectedAssertionsNumberErrorGen: errorGen
-    });
-  }
-  function hasAssertions() {
-    const error = new Error("expected any number of assertion, but got none");
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(error, hasAssertions);
-    }
-    expect.setState({
-      isExpectingAssertions: true,
-      isExpectingAssertionsError: error
-    });
-  }
-  chai$1.util.addMethod(expect, "assertions", assertions);
-  chai$1.util.addMethod(expect, "hasAssertions", hasAssertions);
-  return expect;
-}
-const globalExpect = createExpect();
-Object.defineProperty(globalThis, index.GLOBAL_EXPECT, {
-  value: globalExpect,
-  writable: true,
-  configurable: true
-});
-var globalObject$1;
-if (typeof _commonjsHelpers_BFTU3MAI.c !== "undefined") {
-  globalObject$1 = _commonjsHelpers_BFTU3MAI.c;
-} else if (typeof window !== "undefined") {
-  globalObject$1 = window;
-} else {
-  globalObject$1 = self;
-}
-var global = globalObject$1;
-let throwsOnProto$1;
-try {
-  const object2 = {};
-  object2.__proto__;
-  throwsOnProto$1 = false;
-} catch (_) {
-  throwsOnProto$1 = true;
-}
-var throwsOnProto_1 = throwsOnProto$1;
-var call = Function.call;
-var throwsOnProto = throwsOnProto_1;
-var disallowedProperties = [
-  // ignore size because it throws from Map
-  "size",
-  "caller",
-  "callee",
-  "arguments"
-];
-if (throwsOnProto) {
-  disallowedProperties.push("__proto__");
-}
-var copyPrototypeMethods = function copyPrototypeMethods2(prototype) {
-  return Object.getOwnPropertyNames(prototype).reduce(
-    function(result, name) {
-      if (disallowedProperties.includes(name)) {
-        return result;
-      }
-      if (typeof prototype[name] !== "function") {
-        return result;
-      }
-      result[name] = call.bind(prototype[name]);
-      return result;
-    },
-    /* @__PURE__ */ Object.create(null)
-  );
-};
-var copyPrototype$5 = copyPrototypeMethods;
-var array = copyPrototype$5(Array.prototype);
-var every$1 = array.every;
-function hasCallsLeft(callMap, spy) {
-  if (callMap[spy.id] === void 0) {
-    callMap[spy.id] = 0;
-  }
-  return callMap[spy.id] < spy.callCount;
-}
-function checkAdjacentCalls(callMap, spy, index2, spies) {
-  var calledBeforeNext = true;
-  if (index2 !== spies.length - 1) {
-    calledBeforeNext = spy.calledBefore(spies[index2 + 1]);
-  }
-  if (hasCallsLeft(callMap, spy) && calledBeforeNext) {
-    callMap[spy.id] += 1;
-    return true;
-  }
-  return false;
-}
-function calledInOrder(spies) {
-  var callMap = {};
-  var _spies = arguments.length > 1 ? arguments : spies;
-  return every$1(_spies, checkAdjacentCalls.bind(null, callMap));
-}
-var calledInOrder_1 = calledInOrder;
-var functionName$1 = function functionName(func) {
-  if (!func) {
-    return "";
-  }
-  try {
-    return func.displayName || func.name || // Use function decomposition as a last resort to get function
-    // name. Does not rely on function decomposition to work - if it
-    // doesn't debugging will be slightly less informative
-    // (i.e. toString will say 'spy' rather than 'myFunc').
-    (String(func).match(/function ([^\s(]+)/) || [])[1];
-  } catch (e) {
-    return "";
-  }
-};
-var functionName2 = functionName$1;
-function className(value) {
-  return value.constructor && value.constructor.name || // The next branch is for IE11 support only:
-  // Because the name property is not set on the prototype
-  // of the Function object, we finally try to grab the
-  // name from its definition. This will never be reached
-  // in node, so we are not able to test this properly.
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name
-  typeof value.constructor === "function" && /* istanbul ignore next */
-  functionName2(value.constructor) || null;
-}
-var className_1 = className;
-var deprecated = {};
-(function(exports2) {
-  exports2.wrap = function(func, msg) {
-    var wrapped = function() {
-      exports2.printWarning(msg);
-      return func.apply(this, arguments);
-    };
-    if (func.prototype) {
-      wrapped.prototype = func.prototype;
-    }
-    return wrapped;
-  };
-  exports2.defaultMsg = function(packageName, funcName) {
-    return `${packageName}.${funcName} is deprecated and will be removed from the public API in a future version of ${packageName}.`;
-  };
-  exports2.printWarning = function(msg) {
-    if (typeof process === "object" && process.emitWarning) {
-      process.emitWarning(msg);
-    } else if (console.info) {
-      console.info(msg);
-    } else {
-      console.log(msg);
-    }
-  };
-})(deprecated);
-var every = function every2(obj, fn) {
-  var pass = true;
-  try {
-    obj.forEach(function() {
-      if (!fn.apply(this, arguments)) {
-        throw new Error();
-      }
-    });
-  } catch (e) {
-    pass = false;
-  }
-  return pass;
-};
-var sort = array.sort;
-var slice = array.slice;
-function comparator(a, b) {
-  var aCall = a.getCall(0);
-  var bCall = b.getCall(0);
-  var aId = aCall && aCall.callId || -1;
-  var bId = bCall && bCall.callId || -1;
-  return aId < bId ? -1 : 1;
-}
-function orderByFirstCall(spies) {
-  return sort(slice(spies), comparator);
-}
-var orderByFirstCall_1 = orderByFirstCall;
-var copyPrototype$4 = copyPrototypeMethods;
-var _function = copyPrototype$4(Function.prototype);
-var copyPrototype$3 = copyPrototypeMethods;
-var map = copyPrototype$3(Map.prototype);
-var copyPrototype$2 = copyPrototypeMethods;
-var object = copyPrototype$2(Object.prototype);
-var copyPrototype$1 = copyPrototypeMethods;
-var set = copyPrototype$1(Set.prototype);
-var copyPrototype = copyPrototypeMethods;
-var string = copyPrototype(String.prototype);
-var prototypes = {
-  array,
-  function: _function,
-  map,
-  object,
-  set,
-  string
-};
-var typeDetect = { exports: {} };
-(function(module2, exports2) {
-  (function(global2, factory) {
-    module2.exports = factory();
-  })(_commonjsHelpers_BFTU3MAI.c, function() {
-    var promiseExists = typeof Promise === "function";
-    var globalObject2 = typeof self === "object" ? self : _commonjsHelpers_BFTU3MAI.c;
-    var symbolExists = typeof Symbol !== "undefined";
-    var mapExists = typeof Map !== "undefined";
-    var setExists = typeof Set !== "undefined";
-    var weakMapExists = typeof WeakMap !== "undefined";
-    var weakSetExists = typeof WeakSet !== "undefined";
-    var dataViewExists = typeof DataView !== "undefined";
-    var symbolIteratorExists = symbolExists && typeof Symbol.iterator !== "undefined";
-    var symbolToStringTagExists = symbolExists && typeof Symbol.toStringTag !== "undefined";
-    var setEntriesExists = setExists && typeof Set.prototype.entries === "function";
-    var mapEntriesExists = mapExists && typeof Map.prototype.entries === "function";
-    var setIteratorPrototype = setEntriesExists && Object.getPrototypeOf((/* @__PURE__ */ new Set()).entries());
-    var mapIteratorPrototype = mapEntriesExists && Object.getPrototypeOf((/* @__PURE__ */ new Map()).entries());
-    var arrayIteratorExists = symbolIteratorExists && typeof Array.prototype[Symbol.iterator] === "function";
-    var arrayIteratorPrototype = arrayIteratorExists && Object.getPrototypeOf([][Symbol.iterator]());
-    var stringIteratorExists = symbolIteratorExists && typeof String.prototype[Symbol.iterator] === "function";
-    var stringIteratorPrototype = stringIteratorExists && Object.getPrototypeOf(""[Symbol.iterator]());
-    var toStringLeftSliceLength = 8;
-    var toStringRightSliceLength = -1;
-    function typeDetect2(obj) {
-      var typeofObj = typeof obj;
-      if (typeofObj !== "object") {
-        return typeofObj;
-      }
-      if (obj === null) {
-        return "null";
-      }
-      if (obj === globalObject2) {
-        return "global";
-      }
-      if (Array.isArray(obj) && (symbolToStringTagExists === false || !(Symbol.toStringTag in obj))) {
-        return "Array";
-      }
-      if (typeof window === "object" && window !== null) {
-        if (typeof window.location === "object" && obj === window.location) {
-          return "Location";
-        }
-        if (typeof window.document === "object" && obj === window.document) {
-          return "Document";
-        }
-        if (typeof window.navigator === "object") {
-          if (typeof window.navigator.mimeTypes === "object" && obj === window.navigator.mimeTypes) {
-            return "MimeTypeArray";
-          }
-          if (typeof window.navigator.plugins === "object" && obj === window.navigator.plugins) {
-            return "PluginArray";
-          }
-        }
-        if ((typeof window.HTMLElement === "function" || typeof window.HTMLElement === "object") && obj instanceof window.HTMLElement) {
-          if (obj.tagName === "BLOCKQUOTE") {
-            return "HTMLQuoteElement";
-          }
-          if (obj.tagName === "TD") {
-            return "HTMLTableDataCellElement";
-          }
-          if (obj.tagName === "TH") {
-            return "HTMLTableHeaderCellElement";
-          }
-        }
-      }
-      var stringTag = symbolToStringTagExists && obj[Symbol.toStringTag];
-      if (typeof stringTag === "string") {
-        return stringTag;
-      }
-      var objPrototype = Object.getPrototypeOf(obj);
-      if (objPrototype === RegExp.prototype) {
-        return "RegExp";
-      }
-      if (objPrototype === Date.prototype) {
-        return "Date";
-      }
-      if (promiseExists && objPrototype === Promise.prototype) {
-        return "Promise";
-      }
-      if (setExists && objPrototype === Set.prototype) {
-        return "Set";
-      }
-      if (mapExists && objPrototype === Map.prototype) {
-        return "Map";
-      }
-      if (weakSetExists && objPrototype === WeakSet.prototype) {
-        return "WeakSet";
-      }
-      if (weakMapExists && objPrototype === WeakMap.prototype) {
-        return "WeakMap";
-      }
-      if (dataViewExists && objPrototype === DataView.prototype) {
-        return "DataView";
-      }
-      if (mapExists && objPrototype === mapIteratorPrototype) {
-        return "Map Iterator";
-      }
-      if (setExists && objPrototype === setIteratorPrototype) {
-        return "Set Iterator";
-      }
-      if (arrayIteratorExists && objPrototype === arrayIteratorPrototype) {
-        return "Array Iterator";
-      }
-      if (stringIteratorExists && objPrototype === stringIteratorPrototype) {
-        return "String Iterator";
-      }
-      if (objPrototype === null) {
-        return "Object";
-      }
-      return Object.prototype.toString.call(obj).slice(toStringLeftSliceLength, toStringRightSliceLength);
-    }
-    return typeDetect2;
-  });
-})(typeDetect);
-var typeDetectExports = typeDetect.exports;
-var type = typeDetectExports;
-var typeOf = function typeOf2(value) {
-  return type(value).toLowerCase();
-};
-function valueToString(value) {
-  if (value && value.toString) {
-    return value.toString();
-  }
-  return String(value);
-}
-var valueToString_1 = valueToString;
-var lib = {
-  global,
-  calledInOrder: calledInOrder_1,
-  className: className_1,
-  deprecated,
-  every,
-  functionName: functionName$1,
-  orderByFirstCall: orderByFirstCall_1,
-  prototypes,
-  typeOf,
-  valueToString: valueToString_1
-};
-const globalObject = lib.global;
-let timersModule;
-if (typeof __vitest_required__ !== "undefined") {
-  try {
-    timersModule = __vitest_required__.timers;
-  } catch (e) {
-  }
-}
-function withGlobal(_global) {
-  const maxTimeout = Math.pow(2, 31) - 1;
-  const idCounterStart = 1e12;
-  const NOOP = function() {
-    return void 0;
-  };
-  const NOOP_ARRAY = function() {
-    return [];
-  };
-  const timeoutResult = _global.setTimeout(NOOP, 0);
-  const addTimerReturnsObject = typeof timeoutResult === "object";
-  const hrtimePresent = _global.process && typeof _global.process.hrtime === "function";
-  const hrtimeBigintPresent = hrtimePresent && typeof _global.process.hrtime.bigint === "function";
-  const nextTickPresent = _global.process && typeof _global.process.nextTick === "function";
-  const utilPromisify = _global.process && _global.__vitest_required__ && _global.__vitest_required__.util.promisify;
-  const performancePresent = _global.performance && typeof _global.performance.now === "function";
-  const hasPerformancePrototype = _global.Performance && (typeof _global.Performance).match(/^(function|object)$/);
-  const hasPerformanceConstructorPrototype = _global.performance && _global.performance.constructor && _global.performance.constructor.prototype;
-  const queueMicrotaskPresent = _global.hasOwnProperty("queueMicrotask");
-  const requestAnimationFramePresent = _global.requestAnimationFrame && typeof _global.requestAnimationFrame === "function";
-  const cancelAnimationFramePresent = _global.cancelAnimationFrame && typeof _global.cancelAnimationFrame === "function";
-  const requestIdleCallbackPresent = _global.requestIdleCallback && typeof _global.requestIdleCallback === "function";
-  const cancelIdleCallbackPresent = _global.cancelIdleCallback && typeof _global.cancelIdleCallback === "function";
-  const setImmediatePresent = _global.setImmediate && typeof _global.setImmediate === "function";
-  const intlPresent = _global.Intl && typeof _global.Intl === "object";
-  _global.clearTimeout(timeoutResult);
-  const NativeDate = _global.Date;
-  const NativeIntl = _global.Intl;
-  let uniqueTimerId = idCounterStart;
-  function isNumberFinite(num) {
-    if (Number.isFinite) {
-      return Number.isFinite(num);
-    }
-    return isFinite(num);
-  }
-  let isNearInfiniteLimit = false;
-  function checkIsNearInfiniteLimit(clock, i) {
-    if (clock.loopLimit && i === clock.loopLimit - 1) {
-      isNearInfiniteLimit = true;
-    }
-  }
-  function resetIsNearInfiniteLimit() {
-    isNearInfiniteLimit = false;
-  }
-  function parseTime(str) {
-    if (!str) {
-      return 0;
-    }
-    const strings = str.split(":");
-    const l = strings.length;
-    let i = l;
-    let ms = 0;
-    let parsed;
-    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"
-      );
-    }
-    while (i--) {
-      parsed = parseInt(strings[i], 10);
-      if (parsed >= 60) {
-        throw new Error(`Invalid time ${str}`);
-      }
-      ms += parsed * Math.pow(60, l - i - 1);
-    }
-    return ms * 1e3;
-  }
-  function nanoRemainder(msFloat) {
-    const modulo = 1e6;
-    const remainder = msFloat * 1e6 % modulo;
-    const positiveRemainder = remainder < 0 ? remainder + modulo : remainder;
-    return Math.floor(positiveRemainder);
-  }
-  function getEpoch(epoch) {
-    if (!epoch) {
-      return 0;
-    }
-    if (typeof epoch.getTime === "function") {
-      return epoch.getTime();
-    }
-    if (typeof epoch === "number") {
-      return epoch;
-    }
-    throw new TypeError("now should be milliseconds since UNIX epoch");
-  }
-  function inRange(from, to, timer) {
-    return timer && timer.callAt >= from && timer.callAt <= to;
-  }
-  function getInfiniteLoopError(clock, job) {
-    const infiniteLoopError = new Error(
-      `Aborting after running ${clock.loopLimit} timers, assuming an infinite loop!`
-    );
-    if (!job.error) {
-      return infiniteLoopError;
-    }
-    const computedTargetPattern = /target\.*[<|(|[].*?[>|\]|)]\s*/;
-    let clockMethodPattern = new RegExp(
-      String(Object.keys(clock).join("|"))
-    );
-    if (addTimerReturnsObject) {
-      clockMethodPattern = new RegExp(
-        `\\s+at (Object\\.)?(?:${Object.keys(clock).join("|")})\\s+`
-      );
-    }
-    let matchedLineIndex = -1;
-    job.error.stack.split("\n").some(function(line, i) {
-      const matchedComputedTarget = line.match(computedTargetPattern);
-      if (matchedComputedTarget) {
-        matchedLineIndex = i;
-        return true;
-      }
-      const matchedClockMethod = line.match(clockMethodPattern);
-      if (matchedClockMethod) {
-        matchedLineIndex = i;
-        return false;
-      }
-      return matchedLineIndex >= 0;
-    });
-    const stack = `${infiniteLoopError}
-${job.type || "Microtask"} - ${job.func.name || "anonymous"}
-${job.error.stack.split("\n").slice(matchedLineIndex + 1).join("\n")}`;
-    try {
-      Object.defineProperty(infiniteLoopError, "stack", {
-        value: stack
-      });
-    } catch (e) {
-    }
-    return infiniteLoopError;
-  }
-  function mirrorDateProperties(target, source) {
-    let prop;
-    for (prop in source) {
-      if (source.hasOwnProperty(prop)) {
-        target[prop] = source[prop];
-      }
-    }
-    if (source.now) {
-      target.now = function now() {
-        return target.clock.now;
-      };
-    } else {
-      delete target.now;
-    }
-    if (source.toSource) {
-      target.toSource = function toSource() {
-        return source.toSource();
-      };
-    } else {
-      delete target.toSource;
-    }
-    target.toString = function toString() {
-      return source.toString();
-    };
-    target.prototype = source.prototype;
-    target.parse = source.parse;
-    target.UTC = source.UTC;
-    target.prototype.toUTCString = source.prototype.toUTCString;
-    target.isFake = true;
-    return target;
-  }
-  function createDate() {
-    function ClockDate(year, month, date, hour, minute, second, ms) {
-      if (!(this instanceof ClockDate)) {
-        return new NativeDate(ClockDate.clock.now).toString();
-      }
-      switch (arguments.length) {
-        case 0:
-          return new NativeDate(ClockDate.clock.now);
-        case 1:
-          return new NativeDate(year);
-        case 2:
-          return new NativeDate(year, month);
-        case 3:
-          return new NativeDate(year, month, date);
-        case 4:
-          return new NativeDate(year, month, date, hour);
-        case 5:
-          return new NativeDate(year, month, date, hour, minute);
-        case 6:
-          return new NativeDate(
-            year,
-            month,
-            date,
-            hour,
-            minute,
-            second
-          );
-        default:
-          return new NativeDate(
-            year,
-            month,
-            date,
-            hour,
-            minute,
-            second,
-            ms
-          );
-      }
-    }
-    return mirrorDateProperties(ClockDate, NativeDate);
-  }
-  function createIntl() {
-    const ClockIntl = { ...NativeIntl };
-    ClockIntl.DateTimeFormat = function(...args) {
-      const realFormatter = new NativeIntl.DateTimeFormat(...args);
-      const formatter = {};
-      ["formatRange", "formatRangeToParts", "resolvedOptions"].forEach(
-        (method) => {
-          formatter[method] = realFormatter[method].bind(realFormatter);
-        }
-      );
-      ["format", "formatToParts"].forEach((method) => {
-        formatter[method] = function(date) {
-          return realFormatter[method](date || ClockIntl.clock.now);
-        };
-      });
-      return formatter;
-    };
-    ClockIntl.DateTimeFormat.prototype = Object.create(
-      NativeIntl.DateTimeFormat.prototype
-    );
-    ClockIntl.DateTimeFormat.supportedLocalesOf = NativeIntl.DateTimeFormat.supportedLocalesOf;
-    return ClockIntl;
-  }
-  function enqueueJob(clock, job) {
-    if (!clock.jobs) {
-      clock.jobs = [];
-    }
-    clock.jobs.push(job);
-  }
-  function runJobs(clock) {
-    if (!clock.jobs) {
-      return;
-    }
-    for (let i = 0; i < clock.jobs.length; i++) {
-      const job = clock.jobs[i];
-      job.func.apply(null, job.args);
-      checkIsNearInfiniteLimit(clock, i);
-      if (clock.loopLimit && i > clock.loopLimit) {
-        throw getInfiniteLoopError(clock, job);
-      }
-    }
-    resetIsNearInfiniteLimit();
-    clock.jobs = [];
-  }
-  function addTimer(clock, timer) {
-    if (timer.func === void 0) {
-      throw new Error("Callback must be provided to timer calls");
-    }
-    if (addTimerReturnsObject) {
-      if (typeof timer.func !== "function") {
-        throw new TypeError(
-          `[ERR_INVALID_CALLBACK]: Callback must be a function. Received ${timer.func} of type ${typeof timer.func}`
-        );
-      }
-    }
-    if (isNearInfiniteLimit) {
-      timer.error = new Error();
-    }
-    timer.type = timer.immediate ? "Immediate" : "Timeout";
-    if (timer.hasOwnProperty("delay")) {
-      if (typeof timer.delay !== "number") {
-        timer.delay = parseInt(timer.delay, 10);
-      }
-      if (!isNumberFinite(timer.delay)) {
-        timer.delay = 0;
-      }
-      timer.delay = timer.delay > maxTimeout ? 1 : timer.delay;
-      timer.delay = Math.max(0, timer.delay);
-    }
-    if (timer.hasOwnProperty("interval")) {
-      timer.type = "Interval";
-      timer.interval = timer.interval > maxTimeout ? 1 : timer.interval;
-    }
-    if (timer.hasOwnProperty("animation")) {
-      timer.type = "AnimationFrame";
-      timer.animation = true;
-    }
-    if (timer.hasOwnProperty("idleCallback")) {
-      timer.type = "IdleCallback";
-      timer.idleCallback = true;
-    }
-    if (!clock.timers) {
-      clock.timers = {};
-    }
-    timer.id = uniqueTimerId++;
-    timer.createdAt = clock.now;
-    timer.callAt = clock.now + (parseInt(timer.delay) || (clock.duringTick ? 1 : 0));
-    clock.timers[timer.id] = timer;
-    if (addTimerReturnsObject) {
-      const res = {
-        refed: true,
-        ref: function() {
-          this.refed = true;
-          return res;
-        },
-        unref: function() {
-          this.refed = false;
-          return res;
-        },
-        hasRef: function() {
-          return this.refed;
-        },
-        refresh: function() {
-          timer.callAt = clock.now + (parseInt(timer.delay) || (clock.duringTick ? 1 : 0));
-          clock.timers[timer.id] = timer;
-          return res;
-        },
-        [Symbol.toPrimitive]: function() {
-          return timer.id;
-        }
-      };
-      return res;
-    }
-    return timer.id;
-  }
-  function compareTimers(a, b) {
-    if (a.callAt < b.callAt) {
-      return -1;
-    }
-    if (a.callAt > b.callAt) {
-      return 1;
-    }
-    if (a.immediate && !b.immediate) {
-      return -1;
-    }
-    if (!a.immediate && b.immediate) {
-      return 1;
-    }
-    if (a.createdAt < b.createdAt) {
-      return -1;
-    }
-    if (a.createdAt > b.createdAt) {
-      return 1;
-    }
-    if (a.id < b.id) {
-      return -1;
-    }
-    if (a.id > b.id) {
-      return 1;
-    }
-  }
-  function firstTimerInRange(clock, from, to) {
-    const timers2 = clock.timers;
-    let timer = null;
-    let id, isInRange;
-    for (id in timers2) {
-      if (timers2.hasOwnProperty(id)) {
-        isInRange = inRange(from, to, timers2[id]);
-        if (isInRange && (!timer || compareTimers(timer, timers2[id]) === 1)) {
-          timer = timers2[id];
-        }
-      }
-    }
-    return timer;
-  }
-  function firstTimer(clock) {
-    const timers2 = clock.timers;
-    let timer = null;
-    let id;
-    for (id in timers2) {
-      if (timers2.hasOwnProperty(id)) {
-        if (!timer || compareTimers(timer, timers2[id]) === 1) {
-          timer = timers2[id];
-        }
-      }
-    }
-    return timer;
-  }
-  function lastTimer(clock) {
-    const timers2 = clock.timers;
-    let timer = null;
-    let id;
-    for (id in timers2) {
-      if (timers2.hasOwnProperty(id)) {
-        if (!timer || compareTimers(timer, timers2[id]) === -1) {
-          timer = timers2[id];
-        }
-      }
-    }
-    return timer;
-  }
-  function callTimer(clock, timer) {
-    if (typeof timer.interval === "number") {
-      clock.timers[timer.id].callAt += timer.interval;
-    } else {
-      delete clock.timers[timer.id];
-    }
-    if (typeof timer.func === "function") {
-      timer.func.apply(null, timer.args);
-    } else {
-      const eval2 = eval;
-      (function() {
-        eval2(timer.func);
-      })();
-    }
-  }
-  function getClearHandler(ttype) {
-    if (ttype === "IdleCallback" || ttype === "AnimationFrame") {
-      return `cancel${ttype}`;
-    }
-    return `clear${ttype}`;
-  }
-  function getScheduleHandler(ttype) {
-    if (ttype === "IdleCallback" || ttype === "AnimationFrame") {
-      return `request${ttype}`;
-    }
-    return `set${ttype}`;
-  }
-  function createWarnOnce() {
-    let calls = 0;
-    return function(msg) {
-      !calls++ && console.warn(msg);
-    };
-  }
-  const warnOnce = createWarnOnce();
-  function clearTimer(clock, timerId, ttype) {
-    if (!timerId) {
-      return;
-    }
-    if (!clock.timers) {
-      clock.timers = {};
-    }
-    const id = Number(timerId);
-    if (Number.isNaN(id) || id < idCounterStart) {
-      const handlerName = getClearHandler(ttype);
-      if (clock.shouldClearNativeTimers === true) {
-        const nativeHandler = clock[`_${handlerName}`];
-        return typeof nativeHandler === "function" ? nativeHandler(timerId) : void 0;
-      }
-      warnOnce(
-        `FakeTimers: ${handlerName} was invoked to clear a native timer instead of one created by this library.
-To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
-      );
-    }
-    if (clock.timers.hasOwnProperty(id)) {
-      const timer = clock.timers[id];
-      if (timer.type === ttype || timer.type === "Timeout" && ttype === "Interval" || timer.type === "Interval" && ttype === "Timeout") {
-        delete clock.timers[id];
-      } else {
-        const clear = getClearHandler(ttype);
-        const schedule = getScheduleHandler(timer.type);
-        throw new Error(
-          `Cannot clear timer: timer created with ${schedule}() but cleared with ${clear}()`
-        );
-      }
-    }
-  }
-  function uninstall(clock, config) {
-    let method, i, l;
-    const installedHrTime = "_hrtime";
-    const installedNextTick = "_nextTick";
-    for (i = 0, l = clock.methods.length; i < l; i++) {
-      method = clock.methods[i];
-      if (method === "hrtime" && _global.process) {
-        _global.process.hrtime = clock[installedHrTime];
-      } else if (method === "nextTick" && _global.process) {
-        _global.process.nextTick = clock[installedNextTick];
-      } else if (method === "performance") {
-        const originalPerfDescriptor = Object.getOwnPropertyDescriptor(
-          clock,
-          `_${method}`
-        );
-        if (originalPerfDescriptor && originalPerfDescriptor.get && !originalPerfDescriptor.set) {
-          Object.defineProperty(
-            _global,
-            method,
-            originalPerfDescriptor
-          );
-        } else if (originalPerfDescriptor.configurable) {
-          _global[method] = clock[`_${method}`];
-        }
-      } else {
-        if (_global[method] && _global[method].hadOwnProperty) {
-          _global[method] = clock[`_${method}`];
-        } else {
-          try {
-            delete _global[method];
-          } catch (ignore) {
-          }
-        }
-      }
-      if (clock.timersModuleMethods !== void 0) {
-        for (let j = 0; j < clock.timersModuleMethods.length; j++) {
-          const entry = clock.timersModuleMethods[j];
-          timersModule[entry.methodName] = entry.original;
-        }
-      }
-    }
-    if (config.shouldAdvanceTime === true) {
-      _global.clearInterval(clock.attachedInterval);
-    }
-    clock.methods = [];
-    if (!clock.timers) {
-      return [];
-    }
-    return Object.keys(clock.timers).map(function mapper(key) {
-      return clock.timers[key];
-    });
-  }
-  function hijackMethod(target, method, clock) {
-    clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call(
-      target,
-      method
-    );
-    clock[`_${method}`] = target[method];
-    if (method === "Date") {
-      const date = mirrorDateProperties(clock[method], target[method]);
-      target[method] = date;
-    } else if (method === "Intl") {
-      target[method] = clock[method];
-    } else if (method === "performance") {
-      const originalPerfDescriptor = Object.getOwnPropertyDescriptor(
-        target,
-        method
-      );
-      if (originalPerfDescriptor && originalPerfDescriptor.get && !originalPerfDescriptor.set) {
-        Object.defineProperty(
-          clock,
-          `_${method}`,
-          originalPerfDescriptor
-        );
-        const perfDescriptor = Object.getOwnPropertyDescriptor(
-          clock,
-          method
-        );
-        Object.defineProperty(target, method, perfDescriptor);
-      } else {
-        target[method] = clock[method];
-      }
-    } else {
-      target[method] = function() {
-        return clock[method].apply(clock, arguments);
-      };
-      Object.defineProperties(
-        target[method],
-        Object.getOwnPropertyDescriptors(clock[method])
-      );
-    }
-    target[method].clock = clock;
-  }
-  function doIntervalTick(clock, advanceTimeDelta) {
-    clock.tick(advanceTimeDelta);
-  }
-  const timers = {
-    setTimeout: _global.setTimeout,
-    clearTimeout: _global.clearTimeout,
-    setInterval: _global.setInterval,
-    clearInterval: _global.clearInterval,
-    Date: _global.Date
-  };
-  if (setImmediatePresent) {
-    timers.setImmediate = _global.setImmediate;
-    timers.clearImmediate = _global.clearImmediate;
-  }
-  if (hrtimePresent) {
-    timers.hrtime = _global.process.hrtime;
-  }
-  if (nextTickPresent) {
-    timers.nextTick = _global.process.nextTick;
-  }
-  if (performancePresent) {
-    timers.performance = _global.performance;
-  }
-  if (requestAnimationFramePresent) {
-    timers.requestAnimationFrame = _global.requestAnimationFrame;
-  }
-  if (queueMicrotaskPresent) {
-    timers.queueMicrotask = true;
-  }
-  if (cancelAnimationFramePresent) {
-    timers.cancelAnimationFrame = _global.cancelAnimationFrame;
-  }
-  if (requestIdleCallbackPresent) {
-    timers.requestIdleCallback = _global.requestIdleCallback;
-  }
-  if (cancelIdleCallbackPresent) {
-    timers.cancelIdleCallback = _global.cancelIdleCallback;
-  }
-  if (intlPresent) {
-    timers.Intl = _global.Intl;
-  }
-  const originalSetTimeout = _global.setImmediate || _global.setTimeout;
-  function createClock(start, loopLimit) {
-    start = Math.floor(getEpoch(start));
-    loopLimit = loopLimit || 1e3;
-    let nanos = 0;
-    const adjustedSystemTime = [0, 0];
-    if (NativeDate === void 0) {
-      throw new Error(
-        "The global scope doesn't have a `Date` object (see https://github.com/sinonjs/sinon/issues/1852#issuecomment-419622780)"
-      );
-    }
-    const clock = {
-      now: start,
-      Date: createDate(),
-      loopLimit
-    };
-    clock.Date.clock = clock;
-    function getTimeToNextFrame() {
-      return 16 - (clock.now - start) % 16;
-    }
-    function hrtime(prev) {
-      const millisSinceStart = clock.now - adjustedSystemTime[0] - start;
-      const secsSinceStart = Math.floor(millisSinceStart / 1e3);
-      const remainderInNanos = (millisSinceStart - secsSinceStart * 1e3) * 1e6 + nanos - adjustedSystemTime[1];
-      if (Array.isArray(prev)) {
-        if (prev[1] > 1e9) {
-          throw new TypeError(
-            "Number of nanoseconds can't exceed a billion"
-          );
-        }
-        const oldSecs = prev[0];
-        let nanoDiff = remainderInNanos - prev[1];
-        let secDiff = secsSinceStart - oldSecs;
-        if (nanoDiff < 0) {
-          nanoDiff += 1e9;
-          secDiff -= 1;
-        }
-        return [secDiff, nanoDiff];
-      }
-      return [secsSinceStart, remainderInNanos];
-    }
-    function fakePerformanceNow() {
-      const hrt = hrtime();
-      const millis = hrt[0] * 1e3 + hrt[1] / 1e6;
-      return millis;
-    }
-    if (hrtimeBigintPresent) {
-      hrtime.bigint = function() {
-        const parts = hrtime();
-        return BigInt(parts[0]) * BigInt(1e9) + BigInt(parts[1]);
-      };
-    }
-    if (intlPresent) {
-      clock.Intl = createIntl();
-      clock.Intl.clock = clock;
-    }
-    clock.requestIdleCallback = function requestIdleCallback(func, timeout) {
-      let timeToNextIdlePeriod = 0;
-      if (clock.countTimers() > 0) {
-        timeToNextIdlePeriod = 50;
-      }
-      const result = addTimer(clock, {
-        func,
-        args: Array.prototype.slice.call(arguments, 2),
-        delay: typeof timeout === "undefined" ? timeToNextIdlePeriod : Math.min(timeout, timeToNextIdlePeriod),
-        idleCallback: true
-      });
-      return Number(result);
-    };
-    clock.cancelIdleCallback = function cancelIdleCallback(timerId) {
-      return clearTimer(clock, timerId, "IdleCallback");
-    };
-    clock.setTimeout = function setTimeout(func, timeout) {
-      return addTimer(clock, {
-        func,
-        args: Array.prototype.slice.call(arguments, 2),
-        delay: timeout
-      });
-    };
-    if (typeof _global.Promise !== "undefined" && utilPromisify) {
-      clock.setTimeout[utilPromisify.custom] = function promisifiedSetTimeout(timeout, arg) {
-        return new _global.Promise(function setTimeoutExecutor(resolve) {
-          addTimer(clock, {
-            func: resolve,
-            args: [arg],
-            delay: timeout
-          });
-        });
-      };
-    }
-    clock.clearTimeout = function clearTimeout(timerId) {
-      return clearTimer(clock, timerId, "Timeout");
-    };
-    clock.nextTick = function nextTick(func) {
-      return enqueueJob(clock, {
-        func,
-        args: Array.prototype.slice.call(arguments, 1),
-        error: isNearInfiniteLimit ? new Error() : null
-      });
-    };
-    clock.queueMicrotask = function queueMicrotask(func) {
-      return clock.nextTick(func);
-    };
-    clock.setInterval = function setInterval(func, timeout) {
-      timeout = parseInt(timeout, 10);
-      return addTimer(clock, {
-        func,
-        args: Array.prototype.slice.call(arguments, 2),
-        delay: timeout,
-        interval: timeout
-      });
-    };
-    clock.clearInterval = function clearInterval(timerId) {
-      return clearTimer(clock, timerId, "Interval");
-    };
-    if (setImmediatePresent) {
-      clock.setImmediate = function setImmediate(func) {
-        return addTimer(clock, {
-          func,
-          args: Array.prototype.slice.call(arguments, 1),
-          immediate: true
-        });
-      };
-      if (typeof _global.Promise !== "undefined" && utilPromisify) {
-        clock.setImmediate[utilPromisify.custom] = function promisifiedSetImmediate(arg) {
-          return new _global.Promise(
-            function setImmediateExecutor(resolve) {
-              addTimer(clock, {
-                func: resolve,
-                args: [arg],
-                immediate: true
-              });
-            }
-          );
-        };
-      }
-      clock.clearImmediate = function clearImmediate(timerId) {
-        return clearTimer(clock, timerId, "Immediate");
-      };
-    }
-    clock.countTimers = function countTimers() {
-      return Object.keys(clock.timers || {}).length + (clock.jobs || []).length;
-    };
-    clock.requestAnimationFrame = function requestAnimationFrame(func) {
-      const result = addTimer(clock, {
-        func,
-        delay: getTimeToNextFrame(),
-        get args() {
-          return [fakePerformanceNow()];
-        },
-        animation: true
-      });
-      return Number(result);
-    };
-    clock.cancelAnimationFrame = function cancelAnimationFrame(timerId) {
-      return clearTimer(clock, timerId, "AnimationFrame");
-    };
-    clock.runMicrotasks = function runMicrotasks() {
-      runJobs(clock);
-    };
-    function doTick(tickValue, isAsync, resolve, reject) {
-      const msFloat = typeof tickValue === "number" ? tickValue : parseTime(tickValue);
-      const ms = Math.floor(msFloat);
-      const remainder = nanoRemainder(msFloat);
-      let nanosTotal = nanos + remainder;
-      let tickTo = clock.now + ms;
-      if (msFloat < 0) {
-        throw new TypeError("Negative ticks are not supported");
-      }
-      if (nanosTotal >= 1e6) {
-        tickTo += 1;
-        nanosTotal -= 1e6;
-      }
-      nanos = nanosTotal;
-      let tickFrom = clock.now;
-      let previous = clock.now;
-      let timer, firstException, oldNow, nextPromiseTick, compensationCheck, postTimerCall;
-      clock.duringTick = true;
-      oldNow = clock.now;
-      runJobs(clock);
-      if (oldNow !== clock.now) {
-        tickFrom += clock.now - oldNow;
-        tickTo += clock.now - oldNow;
-      }
-      function doTickInner() {
-        timer = firstTimerInRange(clock, tickFrom, tickTo);
-        while (timer && tickFrom <= tickTo) {
-          if (clock.timers[timer.id]) {
-            tickFrom = timer.callAt;
-            clock.now = timer.callAt;
-            oldNow = clock.now;
-            try {
-              runJobs(clock);
-              callTimer(clock, timer);
-            } catch (e) {
-              firstException = firstException || e;
-            }
-            if (isAsync) {
-              originalSetTimeout(nextPromiseTick);
-              return;
-            }
-            compensationCheck();
-          }
-          postTimerCall();
-        }
-        oldNow = clock.now;
-        runJobs(clock);
-        if (oldNow !== clock.now) {
-          tickFrom += clock.now - oldNow;
-          tickTo += clock.now - oldNow;
-        }
-        clock.duringTick = false;
-        timer = firstTimerInRange(clock, tickFrom, tickTo);
-        if (timer) {
-          try {
-            clock.tick(tickTo - clock.now);
-          } catch (e) {
-            firstException = firstException || e;
-          }
-        } else {
-          clock.now = tickTo;
-          nanos = nanosTotal;
-        }
-        if (firstException) {
-          throw firstException;
-        }
-        if (isAsync) {
-          resolve(clock.now);
-        } else {
-          return clock.now;
-        }
-      }
-      nextPromiseTick = isAsync && function() {
-        try {
-          compensationCheck();
-          postTimerCall();
-          doTickInner();
-        } catch (e) {
-          reject(e);
-        }
-      };
-      compensationCheck = function() {
-        if (oldNow !== clock.now) {
-          tickFrom += clock.now - oldNow;
-          tickTo += clock.now - oldNow;
-          previous += clock.now - oldNow;
-        }
-      };
-      postTimerCall = function() {
-        timer = firstTimerInRange(clock, previous, tickTo);
-        previous = tickFrom;
-      };
-      return doTickInner();
-    }
-    clock.tick = function tick(tickValue) {
-      return doTick(tickValue, false);
-    };
-    if (typeof _global.Promise !== "undefined") {
-      clock.tickAsync = function tickAsync(tickValue) {
-        return new _global.Promise(function(resolve, reject) {
-          originalSetTimeout(function() {
-            try {
-              doTick(tickValue, true, resolve, reject);
-            } catch (e) {
-              reject(e);
-            }
-          });
-        });
-      };
-    }
-    clock.next = function next() {
-      runJobs(clock);
-      const timer = firstTimer(clock);
-      if (!timer) {
-        return clock.now;
-      }
-      clock.duringTick = true;
-      try {
-        clock.now = timer.callAt;
-        callTimer(clock, timer);
-        runJobs(clock);
-        return clock.now;
-      } finally {
-        clock.duringTick = false;
-      }
-    };
-    if (typeof _global.Promise !== "undefined") {
-      clock.nextAsync = function nextAsync() {
-        return new _global.Promise(function(resolve, reject) {
-          originalSetTimeout(function() {
-            try {
-              const timer = firstTimer(clock);
-              if (!timer) {
-                resolve(clock.now);
-                return;
-              }
-              let err;
-              clock.duringTick = true;
-              clock.now = timer.callAt;
-              try {
-                callTimer(clock, timer);
-              } catch (e) {
-                err = e;
-              }
-              clock.duringTick = false;
-              originalSetTimeout(function() {
-                if (err) {
-                  reject(err);
-                } else {
-                  resolve(clock.now);
-                }
-              });
-            } catch (e) {
-              reject(e);
-            }
-          });
-        });
-      };
-    }
-    clock.runAll = function runAll() {
-      let numTimers, i;
-      runJobs(clock);
-      for (i = 0; i < clock.loopLimit; i++) {
-        if (!clock.timers) {
-          resetIsNearInfiniteLimit();
-          return clock.now;
-        }
-        numTimers = Object.keys(clock.timers).length;
-        if (numTimers === 0) {
-          resetIsNearInfiniteLimit();
-          return clock.now;
-        }
-        clock.next();
-        checkIsNearInfiniteLimit(clock, i);
-      }
-      const excessJob = firstTimer(clock);
-      throw getInfiniteLoopError(clock, excessJob);
-    };
-    clock.runToFrame = function runToFrame() {
-      return clock.tick(getTimeToNextFrame());
-    };
-    if (typeof _global.Promise !== "undefined") {
-      clock.runAllAsync = function runAllAsync() {
-        return new _global.Promise(function(resolve, reject) {
-          let i = 0;
-          function doRun() {
-            originalSetTimeout(function() {
-              try {
-                let numTimers;
-                if (i < clock.loopLimit) {
-                  if (!clock.timers) {
-                    resetIsNearInfiniteLimit();
-                    resolve(clock.now);
-                    return;
-                  }
-                  numTimers = Object.keys(
-                    clock.timers
-                  ).length;
-                  if (numTimers === 0) {
-                    resetIsNearInfiniteLimit();
-                    resolve(clock.now);
-                    return;
-                  }
-                  clock.next();
-                  i++;
-                  doRun();
-                  checkIsNearInfiniteLimit(clock, i);
-                  return;
-                }
-                const excessJob = firstTimer(clock);
-                reject(getInfiniteLoopError(clock, excessJob));
-              } catch (e) {
-                reject(e);
-              }
-            });
-          }
-          doRun();
-        });
-      };
-    }
-    clock.runToLast = function runToLast() {
-      const timer = lastTimer(clock);
-      if (!timer) {
-        runJobs(clock);
-        return clock.now;
-      }
-      return clock.tick(timer.callAt - clock.now);
-    };
-    if (typeof _global.Promise !== "undefined") {
-      clock.runToLastAsync = function runToLastAsync() {
-        return new _global.Promise(function(resolve, reject) {
-          originalSetTimeout(function() {
-            try {
-              const timer = lastTimer(clock);
-              if (!timer) {
-                resolve(clock.now);
-              }
-              resolve(clock.tickAsync(timer.callAt - clock.now));
-            } catch (e) {
-              reject(e);
-            }
-          });
-        });
-      };
-    }
-    clock.reset = function reset() {
-      nanos = 0;
-      clock.timers = {};
-      clock.jobs = [];
-      clock.now = start;
-    };
-    clock.setSystemTime = function setSystemTime(systemTime) {
-      const newNow = getEpoch(systemTime);
-      const difference = newNow - clock.now;
-      let id, timer;
-      adjustedSystemTime[0] = adjustedSystemTime[0] + difference;
-      adjustedSystemTime[1] = adjustedSystemTime[1] + nanos;
-      clock.now = newNow;
-      nanos = 0;
-      for (id in clock.timers) {
-        if (clock.timers.hasOwnProperty(id)) {
-          timer = clock.timers[id];
-          timer.createdAt += difference;
-          timer.callAt += difference;
-        }
-      }
-    };
-    clock.jump = function jump(tickValue) {
-      const msFloat = typeof tickValue === "number" ? tickValue : parseTime(tickValue);
-      const ms = Math.floor(msFloat);
-      for (const timer of Object.values(clock.timers)) {
-        if (clock.now + ms > timer.callAt) {
-          timer.callAt = clock.now + ms;
-        }
-      }
-      clock.tick(ms);
-    };
-    if (performancePresent) {
-      clock.performance = /* @__PURE__ */ Object.create(null);
-      clock.performance.now = fakePerformanceNow;
-    }
-    if (hrtimePresent) {
-      clock.hrtime = hrtime;
-    }
-    return clock;
-  }
-  function install(config) {
-    if (arguments.length > 1 || config instanceof Date || Array.isArray(config) || typeof config === "number") {
-      throw new TypeError(
-        `FakeTimers.install called with ${String(
-          config
-        )} install requires an object parameter`
-      );
-    }
-    if (_global.Date.isFake === true) {
-      throw new TypeError(
-        "Can't install fake timers twice on the same global object."
-      );
-    }
-    config = typeof config !== "undefined" ? config : {};
-    config.shouldAdvanceTime = config.shouldAdvanceTime || false;
-    config.advanceTimeDelta = config.advanceTimeDelta || 20;
-    config.shouldClearNativeTimers = config.shouldClearNativeTimers || false;
-    if (config.target) {
-      throw new TypeError(
-        "config.target is no longer supported. Use `withGlobal(target)` instead."
-      );
-    }
-    let i, l;
-    const clock = createClock(config.now, config.loopLimit);
-    clock.shouldClearNativeTimers = config.shouldClearNativeTimers;
-    clock.uninstall = function() {
-      return uninstall(clock, config);
-    };
-    clock.methods = config.toFake || [];
-    if (clock.methods.length === 0) {
-      clock.methods = Object.keys(timers).filter(function(key) {
-        return key !== "nextTick" && key !== "queueMicrotask";
-      });
-    }
-    if (config.shouldAdvanceTime === true) {
-      const intervalTick = doIntervalTick.bind(
-        null,
-        clock,
-        config.advanceTimeDelta
-      );
-      const intervalId = _global.setInterval(
-        intervalTick,
-        config.advanceTimeDelta
-      );
-      clock.attachedInterval = intervalId;
-    }
-    if (clock.methods.includes("performance")) {
-      const proto = (() => {
-        if (hasPerformanceConstructorPrototype) {
-          return _global.performance.constructor.prototype;
-        }
-        if (hasPerformancePrototype) {
-          return _global.Performance.prototype;
-        }
-      })();
-      if (proto) {
-        Object.getOwnPropertyNames(proto).forEach(function(name) {
-          if (name !== "now") {
-            clock.performance[name] = name.indexOf("getEntries") === 0 ? NOOP_ARRAY : NOOP;
-          }
-        });
-      } else if ((config.toFake || []).includes("performance")) {
-        throw new ReferenceError(
-          "non-existent performance object cannot be faked"
-        );
-      }
-    }
-    if (_global === globalObject && timersModule) {
-      clock.timersModuleMethods = [];
-    }
-    for (i = 0, l = clock.methods.length; i < l; i++) {
-      const nameOfMethodToReplace = clock.methods[i];
-      if (nameOfMethodToReplace === "hrtime") {
-        if (_global.process && typeof _global.process.hrtime === "function") {
-          hijackMethod(_global.process, nameOfMethodToReplace, clock);
-        }
-      } else if (nameOfMethodToReplace === "nextTick") {
-        if (_global.process && typeof _global.process.nextTick === "function") {
-          hijackMethod(_global.process, nameOfMethodToReplace, clock);
-        }
-      } else {
-        hijackMethod(_global, nameOfMethodToReplace, clock);
-      }
-      if (clock.timersModuleMethods !== void 0 && timersModule[nameOfMethodToReplace]) {
-        const original = timersModule[nameOfMethodToReplace];
-        clock.timersModuleMethods.push({
-          methodName: nameOfMethodToReplace,
-          original
-        });
-        timersModule[nameOfMethodToReplace] = _global[nameOfMethodToReplace];
-      }
-    }
-    return clock;
-  }
-  return {
-    timers,
-    createClock,
-    install,
-    withGlobal
-  };
-}
-const defaultImplementation = withGlobal(globalObject);
-defaultImplementation.timers;
-defaultImplementation.createClock;
-defaultImplementation.install;
-var withGlobal_1 = withGlobal;
-class FakeTimers {
-  constructor({
-    global: global2,
-    config
-  }) {
-    __publicField(this, "_global");
-    __publicField(this, "_clock");
-    __publicField(this, "_fakingTime");
-    __publicField(this, "_fakingDate");
-    __publicField(this, "_fakeTimers");
-    __publicField(this, "_userConfig");
-    __publicField(this, "_now", date_W2xKR2qe.R.now);
-    this._userConfig = config;
-    this._fakingDate = false;
-    this._fakingTime = false;
-    this._fakeTimers = withGlobal_1(global2);
-    this._global = global2;
-  }
-  clearAllTimers() {
-    if (this._fakingTime) {
-      this._clock.reset();
-    }
-  }
-  dispose() {
-    this.useRealTimers();
-  }
-  runAllTimers() {
-    if (this._checkFakeTimers()) {
-      this._clock.runAll();
-    }
-  }
-  async runAllTimersAsync() {
-    if (this._checkFakeTimers()) {
-      await this._clock.runAllAsync();
-    }
-  }
-  runOnlyPendingTimers() {
-    if (this._checkFakeTimers()) {
-      this._clock.runToLast();
-    }
-  }
-  async runOnlyPendingTimersAsync() {
-    if (this._checkFakeTimers()) {
-      await this._clock.runToLastAsync();
-    }
-  }
-  advanceTimersToNextTimer(steps = 1) {
-    if (this._checkFakeTimers()) {
-      for (let i = steps; i > 0; i--) {
-        this._clock.next();
-        this._clock.tick(0);
-        if (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;
-        }
-      }
-    }
-  }
-  advanceTimersByTime(msToRun) {
-    if (this._checkFakeTimers()) {
-      this._clock.tick(msToRun);
-    }
-  }
-  async advanceTimersByTimeAsync(msToRun) {
-    if (this._checkFakeTimers()) {
-      await this._clock.tickAsync(msToRun);
-    }
-  }
-  advanceTimersToNextFrame() {
-    if (this._checkFakeTimers()) {
-      this._clock.runToFrame();
-    }
-  }
-  runAllTicks() {
-    if (this._checkFakeTimers()) {
-      this._clock.runMicrotasks();
-    }
-  }
-  useRealTimers() {
-    if (this._fakingDate) {
-      date_W2xKR2qe.r();
-      this._fakingDate = false;
-    }
-    if (this._fakingTime) {
-      this._clock.uninstall();
-      this._fakingTime = false;
-    }
-  }
-  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._fakingTime) {
-      const toFake = Object.keys(this._fakeTimers.timers).filter(
-        (timer) => timer !== "nextTick"
-      );
-      if (this._userConfig?.toFake?.includes("nextTick") && base_BlXpj3e_.i()) {
-        throw new Error(
-          "process.nextTick cannot be mocked inside child_process"
-        );
-      }
-      const existingFakedMethods = (this._userConfig?.toFake || toFake).filter(
-        (method) => {
-          switch (method) {
-            case "setImmediate":
-            case "clearImmediate":
-              return method in this._global && this._global[method];
-            default:
-              return true;
-          }
-        }
-      );
-      this._clock = this._fakeTimers.install({
-        now: Date.now(),
-        ...this._userConfig,
-        toFake: existingFakedMethods
-      });
-      this._fakingTime = true;
-    }
-  }
-  reset() {
-    if (this._checkFakeTimers()) {
-      const { now } = this._clock;
-      this._clock.reset();
-      this._clock.setSystemTime(now);
-    }
-  }
-  setSystemTime(now) {
-    if (this._fakingTime) {
-      this._clock.setSystemTime(now);
-    } else {
-      date_W2xKR2qe.m(now ?? this.getRealSystemTime());
-      this._fakingDate = true;
-    }
-  }
-  getRealSystemTime() {
-    return this._now();
-  }
-  getTimerCount() {
-    if (this._checkFakeTimers()) {
-      return this._clock.countTimers();
-    }
-    return 0;
-  }
-  configure(config) {
-    this._userConfig = config;
-  }
-  isFakeTimers() {
-    return this._fakingTime;
-  }
-  _checkFakeTimers() {
-    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);
-  }
-  return target;
-}
-function waitFor(callback, options = {}) {
-  const { setTimeout, setInterval, clearTimeout, clearInterval } = index$3.getSafeTimers();
-  const { interval = 50, timeout = 1e3 } = typeof options === "number" ? { timeout: options } : options;
-  const STACK_TRACE_ERROR = new Error("STACK_TRACE_ERROR");
-  return new Promise((resolve, reject) => {
-    let lastError;
-    let promiseStatus = "idle";
-    let timeoutId;
-    let intervalId;
-    const onResolve = (result) => {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
-      if (intervalId) {
-        clearInterval(intervalId);
-      }
-      resolve(result);
-    };
-    const handleTimeout = () => {
-      if (intervalId) {
-        clearInterval(intervalId);
-      }
-      let error = lastError;
-      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;
-      }
-      try {
-        const result = callback();
-        if (result !== null && typeof result === "object" && typeof result.then === "function") {
-          const thenable = result;
-          promiseStatus = "pending";
-          thenable.then(
-            (resolvedValue) => {
-              promiseStatus = "resolved";
-              onResolve(resolvedValue);
-            },
-            (rejectedValue) => {
-              promiseStatus = "rejected";
-              lastError = rejectedValue;
-            }
-          );
-        } else {
-          onResolve(result);
-          return true;
-        }
-      } catch (error) {
-        lastError = error;
-      }
-    };
-    if (checkCallback() === true) {
-      return;
-    }
-    timeoutId = setTimeout(handleTimeout, timeout);
-    intervalId = setInterval(checkCallback, interval);
-  });
-}
-function waitUntil(callback, options = {}) {
-  const { setTimeout, setInterval, clearTimeout, clearInterval } = index$3.getSafeTimers();
-  const { interval = 50, timeout = 1e3 } = typeof options === "number" ? { timeout: options } : options;
-  const STACK_TRACE_ERROR = new Error("STACK_TRACE_ERROR");
-  return new Promise((resolve, reject) => {
-    let promiseStatus = "idle";
-    let timeoutId;
-    let intervalId;
-    const onReject = (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);
-      }
-      resolve(result);
-      return true;
-    };
-    const checkCallback = () => {
-      if (vi.isFakeTimers()) {
-        vi.advanceTimersByTime(interval);
-      }
-      if (promiseStatus === "pending") {
-        return;
-      }
-      try {
-        const result = callback();
-        if (result !== null && typeof result === "object" && typeof result.then === "function") {
-          const thenable = result;
-          promiseStatus = "pending";
-          thenable.then(
-            (resolvedValue) => {
-              promiseStatus = "resolved";
-              onResolve(resolvedValue);
-            },
-            (rejectedValue) => {
-              promiseStatus = "rejected";
-              onReject(rejectedValue);
-            }
-          );
-        } else {
-          return onResolve(result);
-        }
-      } catch (error) {
-        onReject(error);
-      }
-    };
-    if (checkCallback() === true) {
-      return;
-    }
-    timeoutId = setTimeout(onReject, timeout);
-    intervalId = setInterval(checkCallback, interval);
-  });
-}
-function createVitest() {
-  let _mockedDate = null;
-  let _config = null;
-  const workerState = utils_Ck2hJTRs.g();
-  let _timers;
-  const timers = () => _timers || (_timers = new FakeTimers({
-    global: globalThis,
-    config: workerState.config.fakeTimers
-  }));
-  const _stubsGlobal = /* @__PURE__ */ new Map();
-  const _stubsEnv = /* @__PURE__ */ new Map();
-  const _envBooleans = ["PROD", "DEV", "SSR"];
-  const utils = {
-    useFakeTimers(config) {
-      if (base_BlXpj3e_.i()) {
-        if (config?.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 (config) {
-        timers().configure({ ...workerState.config.fakeTimers, ...config });
-      } else {
-        timers().configure(workerState.config.fakeTimers);
-      }
-      timers().useFakeTimers();
-      return utils;
-    },
-    isFakeTimers() {
-      return timers().isFakeTimers();
-    },
-    useRealTimers() {
-      timers().useRealTimers();
-      _mockedDate = null;
-      return utils;
-    },
-    runOnlyPendingTimers() {
-      timers().runOnlyPendingTimers();
-      return utils;
-    },
-    async runOnlyPendingTimersAsync() {
-      await timers().runOnlyPendingTimersAsync();
-      return utils;
-    },
-    runAllTimers() {
-      timers().runAllTimers();
-      return utils;
-    },
-    async runAllTimersAsync() {
-      await timers().runAllTimersAsync();
-      return utils;
-    },
-    runAllTicks() {
-      timers().runAllTicks();
-      return utils;
-    },
-    advanceTimersByTime(ms) {
-      timers().advanceTimersByTime(ms);
-      return utils;
-    },
-    async advanceTimersByTimeAsync(ms) {
-      await timers().advanceTimersByTimeAsync(ms);
-      return utils;
-    },
-    advanceTimersToNextTimer() {
-      timers().advanceTimersToNextTimer();
-      return utils;
-    },
-    async advanceTimersToNextTimerAsync() {
-      await timers().advanceTimersToNextTimerAsync();
-      return utils;
-    },
-    advanceTimersToNextFrame() {
-      timers().advanceTimersToNextFrame();
-      return utils;
-    },
-    getTimerCount() {
-      return timers().getTimerCount();
-    },
-    setSystemTime(time) {
-      const date = time instanceof Date ? time : new Date(time);
-      _mockedDate = date;
-      timers().setSystemTime(date);
-      return utils;
-    },
-    getMockedSystemTime() {
-      return _mockedDate;
-    },
-    getRealSystemTime() {
-      return timers().getRealSystemTime();
-    },
-    clearAllTimers() {
-      timers().clearAllTimers();
-      return utils;
-    },
-    // mocks
-    spyOn: index$2.spyOn,
-    fn: index$2.fn,
-    waitFor,
-    waitUntil,
-    hoisted(factory) {
-      helpers.assertTypes(factory, '"vi.hoisted" factory', ["function"]);
-      return factory();
-    },
-    mock(path, factory) {
-      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}`
-        );
-      }
-      _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}`
-        );
-      }
-      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}`
-        );
-      }
-      _mocker().queueUnmock(path, getImporter("doUnmock"));
-    },
-    async importActual(path) {
-      return _mocker().importActual(
-        path,
-        getImporter("importActual"),
-        _mocker().getMockContext().callstack
-      );
-    },
-    async importMock(path) {
-      return _mocker().importMock(path, getImporter("importMock"));
-    },
-    // this is typed in the interface so it's not necessary to type it here
-    mocked(item, _options = {}) {
-      return item;
-    },
-    isMockFunction(fn2) {
-      return index$2.isMockFunction(fn2);
-    },
-    clearAllMocks() {
-      index$2.mocks.forEach((spy) => spy.mockClear());
-      return utils;
-    },
-    resetAllMocks() {
-      index$2.mocks.forEach((spy) => spy.mockReset());
-      return utils;
-    },
-    restoreAllMocks() {
-      index$2.mocks.forEach((spy) => spy.mockRestore());
-      return utils;
-    },
-    stubGlobal(name, value) {
-      if (!_stubsGlobal.has(name)) {
-        _stubsGlobal.set(
-          name,
-          Object.getOwnPropertyDescriptor(globalThis, name)
-        );
-      }
-      Object.defineProperty(globalThis, name, {
-        value,
-        writable: true,
-        configurable: true,
-        enumerable: true
-      });
-      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);
-      }
-      return utils;
-    },
-    unstubAllGlobals() {
-      _stubsGlobal.forEach((original, name) => {
-        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;
-        }
-      });
-      _stubsEnv.clear();
-      return utils;
-    },
-    resetModules() {
-      resetModules(workerState.moduleCache);
-      return utils;
-    },
-    async dynamicImportSettled() {
-      return waitForImportsToResolve();
-    },
-    setConfig(config) {
-      if (!_config) {
-        _config = { ...workerState.config };
-      }
-      Object.assign(workerState.config, config);
-    },
-    resetConfig() {
-      if (_config) {
-        Object.assign(workerState.config, _config);
-      }
-    }
-  };
-  return utils;
-}
-const vitest = createVitest();
-const vi = vitest;
-function _mocker() {
-  return typeof __vitest_mocker__ !== "undefined" ? __vitest_mocker__ : new Proxy(
-    {},
-    {
-      get(_, name) {
-        throw new Error(
-          `Vitest mocker was not initialized in this environment. vi.${String(name)}() is forbidden.`
-        );
-      }
-    }
-  );
-}
-function getImporter(name) {
-  const stackTrace = helpers.createSimpleStackTrace({ stackTraceLimit: 5 });
-  const stackArray = stackTrace.split("\n");
-  const importerStackIndex = stackArray.findIndex((stack2) => {
-    return stack2.includes(` at Object.${name}`) || stack2.includes(`${name}@`);
-  });
-  const stack = sourceMap.parseSingleStack(stackArray[importerStackIndex + 1]);
-  return stack?.file || "";
-}
-exports.a = globalExpect;
-exports.b = vitest;
-exports.c = createExpect;
-exports.g = getSnapshotClient;
-exports.r = resetModules;
-exports.v = vi;