@art-work/cli 0.1.1 → 0.1.2

package/dist/esm/private/store/safePath.test.mjs

@@ -0,0 +1,2637 @@
+// node_modules/vitest/dist/index.js
+import { afterAll as afterAll2, afterEach as afterEach2, beforeAll as beforeAll2, beforeEach as beforeEach2, describe as describe2, it as it2, onTestFailed as onTestFailed2, onTestFinished as onTestFinished2, suite as suite2, test as test2 } from "@vitest/runner.mjs";
+
+// node_modules/vitest/dist/vendor/benchmark.yGkUTKnC.js
+import { getCurrentSuite } from "@vitest/runner.mjs";
+import { createChainable } from "@vitest/runner/utils.mjs";
+import { noop } from "@vitest/utils.mjs";
+
+// node_modules/vitest/dist/vendor/index.SMVOaj7F.js
+import { relative } from "pathe.mjs";
+import "@vitest/runner/utils.mjs";
+import "@vitest/utils.mjs";
+
+// node_modules/vitest/dist/vendor/global.CkGT_TMy.js
+function getWorkerState() {
+  const workerState = globalThis.__vitest_worker__;
+  if (!workerState) {
+    const errorMsg = 'Vitest failed to access its internal state.\n\nOne of the following is possible:\n- "vitest" is imported directly without running "vitest" command\n- "vitest" is imported inside "globalSetup" (to fix this, use "setupFiles" instead, because "globalSetup" runs in a different context)\n- Otherwise, it might be a Vitest bug. Please report it to https://github.com/vitest-dev/vitest/issues\n';
+    throw new Error(errorMsg);
+  }
+  return workerState;
+}
+function getCurrentEnvironment() {
+  const state = getWorkerState();
+  return state == null ? void 0 : state.environment.name;
+}
+
+// node_modules/vitest/dist/vendor/index.SMVOaj7F.js
+function getRunMode() {
+  return getWorkerState().config.mode;
+}
+function isRunningInBenchmark() {
+  return getRunMode() === "benchmark";
+}
+
+// node_modules/vitest/dist/vendor/benchmark.yGkUTKnC.js
+var benchFns = /* @__PURE__ */ new WeakMap();
+var benchOptsMap = /* @__PURE__ */ new WeakMap();
+var bench = createBenchmark(
+  function(name, fn2 = noop, options = {}) {
+    if (!isRunningInBenchmark())
+      throw new Error("`bench()` is only available in benchmark mode.");
+    const task = getCurrentSuite().task(formatName(name), {
+      ...this,
+      meta: {
+        benchmark: true
+      }
+    });
+    benchFns.set(task, fn2);
+    benchOptsMap.set(task, options);
+  }
+);
+function createBenchmark(fn2) {
+  const benchmark = createChainable(
+    ["skip", "only", "todo"],
+    fn2
+  );
+  benchmark.skipIf = (condition) => condition ? benchmark.skip : benchmark;
+  benchmark.runIf = (condition) => condition ? benchmark : benchmark.skip;
+  return benchmark;
+}
+function formatName(name) {
+  return typeof name === "string" ? name : name instanceof Function ? name.name || "<anonymous>" : String(name);
+}
+
+// node_modules/vitest/dist/vendor/run-once.Olz_Zkd8.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/vitest/dist/vendor/vi.YFlodzP_.js
+import * as chai$1 from "chai.mjs";
+
+// node_modules/vitest/dist/vendor/_commonjsHelpers.jjO7Zipk.js
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+
+// node_modules/vitest/dist/vendor/vi.YFlodzP_.js
+import { equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT as GLOBAL_EXPECT$1, ASYMMETRIC_MATCHERS_OBJECT as ASYMMETRIC_MATCHERS_OBJECT$1, getState, setState, addCustomEqualityTesters } from "@vitest/expect.mjs";
+import { stripSnapshotIndentation, addSerializer, SnapshotClient } from "@vitest/snapshot.mjs";
+import { getNames as getNames2 } from "@vitest/runner/utils.mjs";
+import "@vitest/utils/error.mjs";
+import { getCurrentTest } from "@vitest/runner.mjs";
+
+// node_modules/vitest/dist/vendor/tasks.IknbGB2n.js
+import { getNames, getTests } from "@vitest/runner/utils.mjs";
+import "@vitest/utils.mjs";
+function getFullName(task, separator = " > ") {
+  return getNames(task).join(separator);
+}
+
+// node_modules/vitest/dist/vendor/vi.YFlodzP_.js
+import { getSafeTimers, assertTypes, createSimpleStackTrace } from "@vitest/utils.mjs";
+import { parseSingleStack } from "@vitest/utils/source-map.mjs";
+
+// node_modules/vitest/dist/vendor/base.5NT-gWu5.js
+import "@vitest/utils.mjs";
+function isChildProcess() {
+  return typeof process !== "undefined" && !!process.send;
+}
+
+// node_modules/vitest/dist/vendor/date.Ns1pGd_X.js
+var RealDate = Date;
+var now = null;
+var MockDate = class _MockDate extends RealDate {
+  constructor(y, m, d, h, M, s, ms) {
+    super();
+    let date;
+    switch (arguments.length) {
+      case 0:
+        if (now !== null)
+          date = new RealDate(now.valueOf());
+        else
+          date = new RealDate();
+        break;
+      case 1:
+        date = new RealDate(y);
+        break;
+      default:
+        d = typeof d === "undefined" ? 1 : d;
+        h = h || 0;
+        M = M || 0;
+        s = s || 0;
+        ms = ms || 0;
+        date = new RealDate(y, m, d, h, M, s, ms);
+        break;
+    }
+    Object.setPrototypeOf(date, _MockDate.prototype);
+    return date;
+  }
+};
+MockDate.UTC = RealDate.UTC;
+MockDate.now = function() {
+  return new MockDate().valueOf();
+};
+MockDate.parse = function(dateString) {
+  return RealDate.parse(dateString);
+};
+MockDate.toString = function() {
+  return RealDate.toString();
+};
+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}`);
+  globalThis.Date = MockDate;
+  now = dateObj.valueOf();
+}
+function resetDate() {
+  globalThis.Date = RealDate;
+}
+
+// node_modules/vitest/dist/vendor/vi.YFlodzP_.js
+import { spyOn, fn, isMockFunction, mocks } from "@vitest/spy.mjs";
+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 } = getSafeTimers();
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+async function waitForImportsToResolve() {
+  await waitNextTick();
+  const state = getWorkerState();
+  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(module, exports) {
+  (function() {
+    (function(chaiSubset2) {
+      if (typeof commonjsRequire === "function" && true && true) {
+        return module.exports = chaiSubset2;
+      } else {
+        return chai.use(chaiSubset2);
+      }
+    })(function(chai4, utils) {
+      var Assertion = chai4.Assertion;
+      var assertionPrototype = Assertion.prototype;
+      Assertion.addMethod("containSubset", function(expected) {
+        var actual = utils.flag(this, "object");
+        var showDiff = chai4.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
+        );
+      });
+      chai4.assert.containSubset = function(val, exp, msg) {
+        new chai4.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(commonjsGlobal);
+})(chaiSubset);
+var chaiSubsetExports = chaiSubset.exports;
+var Subset = /* @__PURE__ */ getDefaultExportFromCjs(chaiSubsetExports);
+var MATCHERS_OBJECT = /* @__PURE__ */ Symbol.for("matchers-object");
+var JEST_MATCHERS_OBJECT = /* @__PURE__ */ Symbol.for("$$jest-matchers-object");
+var GLOBAL_EXPECT = /* @__PURE__ */ Symbol.for("expect-global");
+var ASYMMETRIC_MATCHERS_OBJECT = /* @__PURE__ */ Symbol.for("asymmetric-matchers-object");
+if (!Object.prototype.hasOwnProperty.call(globalThis, MATCHERS_OBJECT)) {
+  const globalState = /* @__PURE__ */ new WeakMap();
+  const matchers = /* @__PURE__ */ Object.create(null);
+  const customEqualityTesters = [];
+  const assymetricMatchers = /* @__PURE__ */ Object.create(null);
+  Object.defineProperty(globalThis, MATCHERS_OBJECT, {
+    get: () => globalState
+  });
+  Object.defineProperty(globalThis, JEST_MATCHERS_OBJECT, {
+    configurable: true,
+    get: () => ({
+      state: globalState.get(globalThis[GLOBAL_EXPECT]),
+      matchers,
+      customEqualityTesters
+    })
+  });
+  Object.defineProperty(globalThis, ASYMMETRIC_MATCHERS_OBJECT, {
+    get: () => assymetricMatchers
+  });
+}
+function recordAsyncExpect(test3, promise) {
+  if (test3 && promise instanceof Promise) {
+    promise = promise.finally(() => {
+      const index = test3.promises.indexOf(promise);
+      if (index !== -1)
+        test3.promises.splice(index, 1);
+    });
+    if (!test3.promises)
+      test3.promises = [];
+    test3.promises.push(promise);
+  }
+  return promise;
+}
+var _client;
+function getSnapshotClient() {
+  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}`);
+    return expected;
+  }
+  try {
+    expected();
+  } catch (e) {
+    return e;
+  }
+  throw new Error("snapshot function didn't throw");
+}
+var SnapshotPlugin = (chai4, utils) => {
+  const getTestNames = (test3) => {
+    var _a;
+    if (!test3)
+      return {};
+    return {
+      filepath: (_a = test3.file) == null ? void 0 : _a.filepath,
+      name: getNames2(test3).slice(1).join(" > ")
+    };
+  };
+  for (const key of ["matchSnapshot", "toMatchSnapshot"]) {
+    utils.addMethod(
+      chai4.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 test3 = 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(test3)
+        });
+      }
+    );
+  }
+  utils.addMethod(
+    chai4.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 test3 = utils.flag(this, "vitest-test");
+      const errorMessage = utils.flag(this, "message");
+      const promise = getSnapshotClient().assertRaw({
+        received: expected,
+        message,
+        isInline: false,
+        rawSnapshot: {
+          file
+        },
+        errorMessage,
+        ...getTestNames(test3)
+      });
+      return recordAsyncExpect(test3, promise);
+    }
+  );
+  utils.addMethod(
+    chai4.Assertion.prototype,
+    "toMatchInlineSnapshot",
+    function __INLINE_SNAPSHOT__(properties, inlineSnapshot, message) {
+      var _a;
+      const isNot = utils.flag(this, "negate");
+      if (isNot)
+        throw new Error('toMatchInlineSnapshot cannot be used with "not"');
+      const test3 = utils.flag(this, "vitest-test");
+      const isInsideEach = test3 && (test3.each || ((_a = test3.suite) == null ? void 0 : _a.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 = stripSnapshotIndentation(inlineSnapshot);
+      const errorMessage = utils.flag(this, "message");
+      getSnapshotClient().assert({
+        received: expected,
+        message,
+        isInline: true,
+        properties,
+        inlineSnapshot,
+        error,
+        errorMessage,
+        ...getTestNames(test3)
+      });
+    }
+  );
+  utils.addMethod(
+    chai4.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 test3 = 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(test3)
+      });
+    }
+  );
+  utils.addMethod(
+    chai4.Assertion.prototype,
+    "toThrowErrorMatchingInlineSnapshot",
+    function __INLINE_SNAPSHOT__(inlineSnapshot, message) {
+      var _a;
+      const isNot = utils.flag(this, "negate");
+      if (isNot)
+        throw new Error('toThrowErrorMatchingInlineSnapshot cannot be used with "not"');
+      const test3 = utils.flag(this, "vitest-test");
+      const isInsideEach = test3 && (test3.each || ((_a = test3.suite) == null ? void 0 : _a.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);
+      getSnapshotClient().assert({
+        received: getError(expected, promise),
+        message,
+        inlineSnapshot,
+        isInline: true,
+        error,
+        errorMessage,
+        ...getTestNames(test3)
+      });
+    }
+  );
+  utils.addMethod(
+    chai4.expect,
+    "addSnapshotSerializer",
+    addSerializer
+  );
+};
+chai$1.use(JestExtend);
+chai$1.use(JestChaiExpect);
+chai$1.use(Subset);
+chai$1.use(SnapshotPlugin);
+chai$1.use(JestAsymmetricMatchers);
+function createExpect(test3) {
+  var _a;
+  const expect2 = (value, message) => {
+    const { assertionCalls } = getState(expect2);
+    setState({ assertionCalls: assertionCalls + 1, soft: false }, expect2);
+    const assert22 = chai$1.expect(value, message);
+    const _test = test3 || getCurrentTest();
+    if (_test)
+      return assert22.withTest(_test);
+    else
+      return assert22;
+  };
+  Object.assign(expect2, chai$1.expect);
+  Object.assign(expect2, globalThis[ASYMMETRIC_MATCHERS_OBJECT$1]);
+  expect2.getState = () => getState(expect2);
+  expect2.setState = (state) => setState(state, expect2);
+  const globalState = getState(globalThis[GLOBAL_EXPECT$1]) || {};
+  setState({
+    // this should also add "snapshotState" that is added conditionally
+    ...globalState,
+    assertionCalls: 0,
+    isExpectingAssertions: false,
+    isExpectingAssertionsError: null,
+    expectedAssertionsNumber: null,
+    expectedAssertionsNumberErrorGen: null,
+    environment: getCurrentEnvironment(),
+    testPath: test3 ? (_a = test3.suite.file) == null ? void 0 : _a.filepath : globalState.testPath,
+    currentTestName: test3 ? getFullName(test3) : globalState.currentTestName
+  }, expect2);
+  expect2.extend = (matchers) => chai$1.expect.extend(expect2, matchers);
+  expect2.addEqualityTesters = (customTesters) => addCustomEqualityTesters(customTesters);
+  expect2.soft = (...args) => {
+    const assert22 = expect2(...args);
+    expect2.setState({
+      soft: true
+    });
+    return assert22;
+  };
+  expect2.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 ${expect2.getState().assertionCalls}`);
+    if (Error.captureStackTrace)
+      Error.captureStackTrace(errorGen(), assertions);
+    expect2.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);
+    expect2.setState({
+      isExpectingAssertions: true,
+      isExpectingAssertionsError: error
+    });
+  }
+  chai$1.util.addMethod(expect2, "assertions", assertions);
+  chai$1.util.addMethod(expect2, "hasAssertions", hasAssertions);
+  return expect2;
+}
+var globalExpect = createExpect();
+Object.defineProperty(globalThis, GLOBAL_EXPECT$1, {
+  value: globalExpect,
+  writable: true,
+  configurable: true
+});
+var globalObject$1;
+if (typeof commonjsGlobal !== "undefined") {
+  globalObject$1 = commonjsGlobal;
+} else if (typeof window !== "undefined") {
+  globalObject$1 = window;
+} else {
+  globalObject$1 = self;
+}
+var global2 = globalObject$1;
+var 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, index, spies) {
+  var calledBeforeNext = true;
+  if (index !== spies.length - 1) {
+    calledBeforeNext = spy.calledBefore(spies[index + 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(exports) {
+  exports.wrap = function(func, msg) {
+    var wrapped = function() {
+      exports.printWarning(msg);
+      return func.apply(this, arguments);
+    };
+    if (func.prototype) {
+      wrapped.prototype = func.prototype;
+    }
+    return wrapped;
+  };
+  exports.defaultMsg = function(packageName, funcName) {
+    return `${packageName}.${funcName} is deprecated and will be removed from the public API in a future version of ${packageName}.`;
+  };
+  exports.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, fn2) {
+  var pass = true;
+  try {
+    obj.forEach(function() {
+      if (!fn2.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(module, exports) {
+  (function(global3, factory) {
+    module.exports = factory();
+  })(commonjsGlobal, (function() {
+    var promiseExists = typeof Promise === "function";
+    var globalObject2 = typeof self === "object" ? self : commonjsGlobal;
+    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: global2,
+  calledInOrder: calledInOrder_1,
+  className: className_1,
+  deprecated,
+  every,
+  functionName: functionName$1,
+  orderByFirstCall: orderByFirstCall_1,
+  prototypes,
+  typeOf,
+  valueToString: valueToString_1
+};
+var globalObject = lib.global;
+var 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 now2() {
+        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
+  };
+}
+var defaultImplementation = withGlobal(globalObject);
+defaultImplementation.timers;
+defaultImplementation.createClock;
+defaultImplementation.install;
+var withGlobal_1 = withGlobal;
+var FakeTimers = class {
+  _global;
+  _clock;
+  _fakingTime;
+  _fakingDate;
+  _fakeTimers;
+  _userConfig;
+  _now = RealDate.now;
+  constructor({
+    global: global3,
+    config
+  }) {
+    this._userConfig = config;
+    this._fakingDate = false;
+    this._fakingTime = false;
+    this._fakeTimers = withGlobal_1(global3);
+    this._global = global3;
+  }
+  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);
+  }
+  runAllTicks() {
+    if (this._checkFakeTimers()) {
+      this._clock.runMicrotasks();
+    }
+  }
+  useRealTimers() {
+    if (this._fakingDate) {
+      resetDate();
+      this._fakingDate = false;
+    }
+    if (this._fakingTime) {
+      this._clock.uninstall();
+      this._fakingTime = false;
+    }
+  }
+  useFakeTimers() {
+    var _a, _b, _c;
+    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 (((_b = (_a = this._userConfig) == null ? void 0 : _a.toFake) == null ? void 0 : _b.includes("nextTick")) && isChildProcess())
+        throw new Error("process.nextTick cannot be mocked inside child_process");
+      const existingFakedMethods = (((_c = this._userConfig) == null ? void 0 : _c.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: now2 } = this._clock;
+      this._clock.reset();
+      this._clock.setSystemTime(now2);
+    }
+  }
+  setSystemTime(now2) {
+    if (this._fakingTime) {
+      this._clock.setSystemTime(now2);
+    } else {
+      mockDate(now2 ?? 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 } = 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 = () => {
+      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 } = 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 (!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() {
+  const _mocker = 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.`
+      );
+    }
+  });
+  let _mockedDate = null;
+  let _config = null;
+  const workerState = getWorkerState();
+  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 getImporter = () => {
+    const stackTrace = createSimpleStackTrace({ stackTraceLimit: 4 });
+    const importerStack = stackTrace.split("\n")[4];
+    const stack = parseSingleStack(importerStack);
+    return (stack == null ? void 0 : stack.file) || "";
+  };
+  const utils = {
+    useFakeTimers(config) {
+      var _a, _b, _c, _d;
+      if (isChildProcess()) {
+        if (((_a = config == null ? void 0 : config.toFake) == null ? void 0 : _a.includes("nextTick")) || ((_d = (_c = (_b = workerState.config) == null ? void 0 : _b.fakeTimers) == null ? void 0 : _c.toFake) == null ? void 0 : _d.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;
+    },
+    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,
+    fn,
+    waitFor,
+    waitUntil,
+    hoisted(factory) {
+      assertTypes(factory, '"vi.hoisted" factory', ["function"]);
+      return factory();
+    },
+    mock(path, factory) {
+      const importer = getImporter();
+      _mocker.queueMock(
+        path,
+        importer,
+        factory ? () => factory(() => _mocker.importActual(path, importer, _mocker.getMockContext().callstack)) : void 0,
+        true
+      );
+    },
+    unmock(path) {
+      _mocker.queueUnmock(path, getImporter());
+    },
+    doMock(path, factory) {
+      const importer = getImporter();
+      _mocker.queueMock(
+        path,
+        importer,
+        factory ? () => factory(() => _mocker.importActual(path, importer, _mocker.getMockContext().callstack)) : void 0,
+        false
+      );
+    },
+    doUnmock(path) {
+      _mocker.queueUnmock(path, getImporter());
+    },
+    async importActual(path) {
+      return _mocker.importActual(
+        path,
+        getImporter(),
+        _mocker.getMockContext().callstack
+      );
+    },
+    async importMock(path) {
+      return _mocker.importMock(path, getImporter());
+    },
+    // this is typed in the interface so it's not necessary to type it here
+    mocked(item, _options = {}) {
+      return item;
+    },
+    isMockFunction(fn2) {
+      return isMockFunction(fn2);
+    },
+    clearAllMocks() {
+      mocks.forEach((spy) => spy.mockClear());
+      return utils;
+    },
+    resetAllMocks() {
+      mocks.forEach((spy) => spy.mockReset());
+      return utils;
+    },
+    restoreAllMocks() {
+      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
+        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;
+}
+var vitest = createVitest();
+var vi = vitest;
+
+// node_modules/vitest/dist/vendor/index.dI9lHwVn.js
+import { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from "@vitest/runner.mjs";
+import * as chai2 from "chai.mjs";
+import { assert as assert2, should } from "chai.mjs";
+function getRunningMode() {
+  return process.env.VITEST_MODE === "WATCH" ? "watch" : "run";
+}
+function isWatchMode() {
+  return getRunningMode() === "watch";
+}
+function inject(key) {
+  const workerState = getWorkerState();
+  return workerState.providedContext[key];
+}
+var dist = {};
+(function(exports) {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.expectTypeOf = void 0;
+  const fn2 = () => true;
+  const expectTypeOf2 = (_actual) => {
+    const nonFunctionProperties = [
+      "parameters",
+      "returns",
+      "resolves",
+      "not",
+      "items",
+      "constructorParameters",
+      "thisParameter",
+      "instance",
+      "guards",
+      "asserts",
+      "branded"
+    ];
+    const obj = {
+      /* eslint-disable mmkal/@typescript-eslint/no-unsafe-assignment */
+      toBeAny: fn2,
+      toBeUnknown: fn2,
+      toBeNever: fn2,
+      toBeFunction: fn2,
+      toBeObject: fn2,
+      toBeArray: fn2,
+      toBeString: fn2,
+      toBeNumber: fn2,
+      toBeBoolean: fn2,
+      toBeVoid: fn2,
+      toBeSymbol: fn2,
+      toBeNull: fn2,
+      toBeUndefined: fn2,
+      toBeNullable: fn2,
+      toMatchTypeOf: fn2,
+      toEqualTypeOf: fn2,
+      toBeCallableWith: fn2,
+      toBeConstructibleWith: fn2,
+      /* eslint-enable mmkal/@typescript-eslint/no-unsafe-assignment */
+      extract: exports.expectTypeOf,
+      exclude: exports.expectTypeOf,
+      toHaveProperty: exports.expectTypeOf,
+      parameter: exports.expectTypeOf
+    };
+    const getterProperties = nonFunctionProperties;
+    getterProperties.forEach((prop) => Object.defineProperty(obj, prop, { get: () => (0, exports.expectTypeOf)({}) }));
+    return obj;
+  };
+  exports.expectTypeOf = expectTypeOf2;
+})(dist);
+function noop2() {
+}
+var assertType = noop2;
+var VitestIndex = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  afterAll,
+  afterEach,
+  assert: assert2,
+  assertType,
+  beforeAll,
+  beforeEach,
+  bench,
+  chai: chai2,
+  createExpect,
+  describe,
+  expect: globalExpect,
+  expectTypeOf: dist.expectTypeOf,
+  getRunningMode,
+  inject,
+  isFirstRun,
+  isWatchMode,
+  it,
+  onTestFailed,
+  onTestFinished,
+  runOnce,
+  should,
+  suite,
+  test,
+  vi,
+  vitest
+});
+
+// node_modules/vitest/dist/index.js
+import * as chai3 from "chai.mjs";
+import { assert as assert3, should as should2 } from "chai.mjs";
+import "@vitest/runner/utils.mjs";
+import "@vitest/utils.mjs";
+import "pathe.mjs";
+import "std-env.mjs";
+import "@vitest/expect.mjs";
+import "@vitest/snapshot.mjs";
+import "@vitest/utils/error.mjs";
+import "@vitest/utils/source-map.mjs";
+import "@vitest/spy.mjs";
+var expectTypeOf = dist.expectTypeOf;
+
+// src/private/store/safePath.test.ts
+import { safePath } from "./safePath.mjs";
+describe2("safePath", () => {
+  it2("lowercases and replaces non-alphanumerics with hyphens", () => {
+    globalExpect(safePath("Hello World!")).toBe("hello-world-");
+  });
+  it2("collapses consecutive hyphens", () => {
+    globalExpect(safePath("foo___bar")).toBe("foo-bar");
+  });
+});
+//# sourceMappingURL=safePath.test.mjs.map