Add progressive web app companion for cross-platform access

Vite + TypeScript PWA that mirrors the Android app's core features:
- Pre-processed shelter data (build-time UTM33N→WGS84 conversion)
- Leaflet map with shelter markers, user location, and offline tiles
- Canvas compass arrow (ported from DirectionArrowView.kt)
- IndexedDB shelter cache with 7-day staleness check
- Service worker with CacheFirst tiles and precached app shell
- i18n for en, nb, nn (ported from Android strings.xml)
- iOS/Android compass handling with low-pass filter
- Respects user map interaction (no auto-snap on pan/zoom)
- Build revision cache-breaker for reliable SW updates

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

pwa/node_modules/vitest/README.md

@@ -0,0 +1,7 @@
+# vitest
+
+[![NPM version](https://img.shields.io/npm/v/vitest?color=a1b858&label=)](https://www.npmjs.com/package/vitest)
+
+Next generation testing framework powered by Vite.
+
+[GitHub](https://github.com/vitest-dev/vitest) | [Documentation](https://vitest.dev/)

pwa/node_modules/vitest/browser.d.ts

@@ -0,0 +1 @@
+export * from './dist/browser.js'

pwa/node_modules/vitest/config.d.ts

@@ -0,0 +1 @@
+export * from './dist/config.js'

pwa/node_modules/vitest/coverage.d.ts

@@ -0,0 +1 @@
+export * from './dist/coverage.js'

pwa/node_modules/vitest/dist/browser.d.ts

@@ -0,0 +1,63 @@
+import { C as CoverageProvider, b as CoverageProviderModule } from './chunks/reporters.nr4dxCkA.js';
+import { a as SerializedCoverageConfig, S as SerializedConfig } from './chunks/config.Cy0C388Z.js';
+import * as spy$1 from '@vitest/spy';
+import { DiffOptions } from '@vitest/expect';
+import { VitestExecutor } from './execute.js';
+export { collectTests, processError, startTests } from '@vitest/runner';
+import './chunks/environment.LoooBwUu.js';
+import 'node:stream';
+import 'vite';
+import '@vitest/utils';
+import '@vitest/pretty-format';
+import '@vitest/snapshot';
+import 'vite-node';
+import 'chai';
+import '@vitest/utils/source-map';
+import 'vite-node/client';
+import 'vite-node/server';
+import './chunks/benchmark.geERunq4.js';
+import '@vitest/runner/utils';
+import 'tinybench';
+import '@vitest/snapshot/manager';
+import 'node:fs';
+import '@vitest/snapshot/environment';
+import './chunks/worker.tN5KGIih.js';
+import 'node:vm';
+import '@vitest/mocker';
+import './chunks/mocker.cRtM890J.js';
+
+function _mergeNamespaces(n, m) {
+  m.forEach(function (e) {
+    e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
+      if (k !== 'default' && !(k in n)) {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  });
+  return Object.freeze(n);
+}
+
+var spy = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null
+}, [spy$1]);
+
+interface Loader {
+    executeId: (id: string) => Promise<{
+        default: CoverageProviderModule;
+    }>;
+    isBrowser?: boolean;
+}
+declare function getCoverageProvider(options: SerializedCoverageConfig | undefined, loader: Loader): Promise<CoverageProvider | null>;
+declare function startCoverageInsideWorker(options: SerializedCoverageConfig | undefined, loader: Loader): Promise<unknown>;
+declare function takeCoverageInsideWorker(options: SerializedCoverageConfig | undefined, loader: Loader): Promise<unknown>;
+declare function stopCoverageInsideWorker(options: SerializedCoverageConfig | undefined, loader: Loader): Promise<unknown>;
+
+declare function setupCommonEnv(config: SerializedConfig): Promise<void>;
+declare function loadDiffConfig(config: SerializedConfig, executor: VitestExecutor): Promise<DiffOptions | undefined>;
+declare function loadSnapshotSerializers(config: SerializedConfig, executor: VitestExecutor): Promise<void>;
+
+export { spy as SpyModule, getCoverageProvider, loadDiffConfig, loadSnapshotSerializers, setupCommonEnv, startCoverageInsideWorker, stopCoverageInsideWorker, takeCoverageInsideWorker };

pwa/node_modules/vitest/dist/browser.js

@@ -0,0 +1,9 @@
+export { g as getCoverageProvider, s as startCoverageInsideWorker, a as stopCoverageInsideWorker, t as takeCoverageInsideWorker } from './chunks/coverage.BoMDb1ip.js';
+export { s as SpyModule } from './chunks/spy.Cf_4R5Oe.js';
+export { l as loadDiffConfig, a as loadSnapshotSerializers, s as setupCommonEnv } from './chunks/setup-common.Dj6BZI3u.js';
+export { collectTests, processError, startTests } from '@vitest/runner';
+import '@vitest/spy';
+import '@vitest/snapshot';
+import '@vitest/utils';
+import './chunks/run-once.2ogXb3JV.js';
+import './chunks/utils.C8RiOc4B.js';

pwa/node_modules/vitest/dist/chunks/_commonjsHelpers.BFTU3MAI.js

@@ -0,0 +1,7 @@
+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;
+}
+
+export { commonjsGlobal as c, getDefaultExportFromCjs as g };

pwa/node_modules/vitest/dist/chunks/base.BZZh4cSm.js

@@ -0,0 +1,38 @@
+import { ModuleCacheMap } from 'vite-node/client';
+import { g as getDefaultRequestStubs, s as startVitestExecutor } from './execute.2pr0rHgK.js';
+import { p as provideWorkerState } from './utils.C8RiOc4B.js';
+
+let _viteNode;
+const moduleCache = new ModuleCacheMap();
+async function startViteNode(options) {
+  if (_viteNode) {
+    return _viteNode;
+  }
+  _viteNode = await startVitestExecutor(options);
+  return _viteNode;
+}
+async function runBaseTests(method, state) {
+  const { ctx } = state;
+  state.moduleCache = moduleCache;
+  provideWorkerState(globalThis, state);
+  if (ctx.invalidates) {
+    ctx.invalidates.forEach((fsPath) => {
+      moduleCache.delete(fsPath);
+      moduleCache.delete(`mock:${fsPath}`);
+    });
+  }
+  ctx.files.forEach((i) => state.moduleCache.delete(i));
+  const [executor, { run }] = await Promise.all([
+    startViteNode({ state, requestStubs: getDefaultRequestStubs() }),
+    import('./runBaseTests.3qpJUEJM.js')
+  ]);
+  await run(
+    method,
+    ctx.files,
+    ctx.config,
+    { environment: state.environment, options: ctx.environment.options },
+    executor
+  );
+}
+
+export { runBaseTests as r };

pwa/node_modules/vitest/dist/chunks/benchmark.Cdu9hjj4.js

@@ -0,0 +1,40 @@
+import { getCurrentSuite } from '@vitest/runner';
+import { createChainable } from '@vitest/runner/utils';
+import { noop } from '@vitest/utils';
+import { g as getWorkerState } from './utils.C8RiOc4B.js';
+
+const benchFns = /* @__PURE__ */ new WeakMap();
+const benchOptsMap = /* @__PURE__ */ new WeakMap();
+function getBenchOptions(key) {
+  return benchOptsMap.get(key);
+}
+function getBenchFn(key) {
+  return benchFns.get(key);
+}
+const bench = createBenchmark(function(name, fn = noop, options = {}) {
+  if (getWorkerState().config.mode !== "benchmark") {
+    throw new Error("`bench()` is only available in benchmark mode.");
+  }
+  const task = getCurrentSuite().task(formatName(name), {
+    ...this,
+    meta: {
+      benchmark: true
+    }
+  });
+  benchFns.set(task, fn);
+  benchOptsMap.set(task, options);
+});
+function createBenchmark(fn) {
+  const benchmark = createChainable(
+    ["skip", "only", "todo"],
+    fn
+  );
+  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);
+}
+
+export { getBenchOptions as a, bench as b, getBenchFn as g };

pwa/node_modules/vitest/dist/chunks/benchmark.geERunq4.d.ts

@@ -0,0 +1,24 @@
+import { Custom } from '@vitest/runner';
+import { ChainableFunction } from '@vitest/runner/utils';
+import { TaskResult, Bench, Options } from 'tinybench';
+
+interface Benchmark extends Custom {
+    meta: {
+        benchmark: true;
+        result?: TaskResult;
+    };
+}
+interface BenchmarkResult extends TaskResult {
+    name: string;
+    rank: number;
+    sampleCount: number;
+    median: number;
+}
+type BenchFunction = (this: Bench) => Promise<void> | void;
+type ChainableBenchmarkAPI = ChainableFunction<'skip' | 'only' | 'todo', (name: string | Function, fn?: BenchFunction, options?: Options) => void>;
+type BenchmarkAPI = ChainableBenchmarkAPI & {
+    skipIf: (condition: any) => ChainableBenchmarkAPI;
+    runIf: (condition: any) => ChainableBenchmarkAPI;
+};
+
+export type { BenchmarkResult as B, BenchFunction as a, Benchmark as b, BenchmarkAPI as c };

pwa/node_modules/vitest/dist/chunks/config.Cy0C388Z.d.ts

@@ -0,0 +1,208 @@
+import { PrettyFormatOptions } from '@vitest/pretty-format';
+import { SequenceHooks, SequenceSetupFiles } from '@vitest/runner';
+import { SnapshotUpdateState } from '@vitest/snapshot';
+import { SnapshotEnvironment } from '@vitest/snapshot/environment';
+
+/**
+ * Names of clock methods that may be faked by install.
+ */
+type FakeMethod =
+    | "setTimeout"
+    | "clearTimeout"
+    | "setImmediate"
+    | "clearImmediate"
+    | "setInterval"
+    | "clearInterval"
+    | "Date"
+    | "nextTick"
+    | "hrtime"
+    | "requestAnimationFrame"
+    | "cancelAnimationFrame"
+    | "requestIdleCallback"
+    | "cancelIdleCallback"
+    | "performance"
+    | "queueMicrotask";
+
+interface FakeTimerInstallOpts {
+    /**
+     * Installs fake timers with the specified unix epoch (default: 0)
+     */
+    now?: number | Date | undefined;
+
+    /**
+     * An array with names of global methods and APIs to fake.
+     * For instance, `vi.useFakeTimer({ toFake: ['setTimeout', 'performance'] })` will fake only `setTimeout()` and `performance.now()`
+     * @default ['setTimeout', 'clearTimeout', 'setImmediate', 'clearImmediate', 'setInterval', 'clearInterval', 'Date']
+     */
+    toFake?: FakeMethod[] | undefined;
+
+    /**
+     * The maximum number of timers that will be run when calling runAll()
+     * @default 10000
+     */
+    loopLimit?: number | undefined;
+
+    /**
+     * Tells @sinonjs/fake-timers to increment mocked time automatically based on the real system time shift (e.g. the mocked time will be incremented by
+     * 20ms for every 20ms change in the real system time) (default: false)
+     */
+    shouldAdvanceTime?: boolean | undefined;
+
+    /**
+     * Relevant only when using with shouldAdvanceTime: true. increment mocked time by advanceTimeDelta ms every advanceTimeDelta ms change
+     * in the real system time (default: 20)
+     */
+    advanceTimeDelta?: number | undefined;
+
+    /**
+     * Tells FakeTimers to clear 'native' (i.e. not fake) timers by delegating to their respective handlers.
+     * @default true
+     */
+    shouldClearNativeTimers?: boolean | undefined;
+}
+
+/**
+ * Config that tests have access to.
+ */
+interface SerializedConfig {
+    name: string | undefined;
+    globals: boolean;
+    base: string | undefined;
+    snapshotEnvironment?: string;
+    disableConsoleIntercept: boolean | undefined;
+    runner: string | undefined;
+    isolate: boolean;
+    mode: 'test' | 'benchmark';
+    bail: number | undefined;
+    environmentOptions?: Record<string, any>;
+    root: string;
+    setupFiles: string[];
+    passWithNoTests: boolean;
+    testNamePattern: RegExp | undefined;
+    allowOnly: boolean;
+    testTimeout: number;
+    hookTimeout: number;
+    clearMocks: boolean;
+    mockReset: boolean;
+    restoreMocks: boolean;
+    unstubGlobals: boolean;
+    unstubEnvs: boolean;
+    fakeTimers: FakeTimerInstallOpts;
+    maxConcurrency: number;
+    defines: Record<string, any>;
+    expect: {
+        requireAssertions?: boolean;
+        poll?: {
+            timeout?: number;
+            interval?: number;
+        };
+    };
+    printConsoleTrace: boolean | undefined;
+    sequence: {
+        shuffle?: boolean;
+        concurrent?: boolean;
+        seed: number;
+        hooks: SequenceHooks;
+        setupFiles: SequenceSetupFiles;
+    };
+    poolOptions: {
+        forks: {
+            singleFork: boolean;
+            isolate: boolean;
+        };
+        threads: {
+            singleThread: boolean;
+            isolate: boolean;
+        };
+        vmThreads: {
+            singleThread: boolean;
+        };
+        vmForks: {
+            singleFork: boolean;
+        };
+    };
+    deps: {
+        web: {
+            transformAssets?: boolean;
+            transformCss?: boolean;
+            transformGlobPattern?: RegExp | RegExp[];
+        };
+        optimizer: {
+            web: {
+                enabled: boolean;
+            };
+            ssr: {
+                enabled: boolean;
+            };
+        };
+        interopDefault: boolean | undefined;
+        moduleDirectories: string[] | undefined;
+    };
+    snapshotOptions: {
+        updateSnapshot: SnapshotUpdateState;
+        expand: boolean | undefined;
+        snapshotFormat: PrettyFormatOptions | undefined;
+        /**
+         * only exists for tests, not available in the main process
+         */
+        snapshotEnvironment: SnapshotEnvironment;
+    };
+    pool: string;
+    snapshotSerializers: string[];
+    chaiConfig: {
+        includeStack?: boolean;
+        showDiff?: boolean;
+        truncateThreshold?: number;
+    } | undefined;
+    diff: string | undefined;
+    retry: number;
+    includeTaskLocation: boolean | undefined;
+    inspect: boolean | string | undefined;
+    inspectBrk: boolean | string | undefined;
+    inspector: {
+        enabled?: boolean;
+        port?: number;
+        host?: string;
+        waitForDebugger?: boolean;
+    };
+    watch: boolean;
+    env: Record<string, any>;
+    browser: {
+        name: string;
+        headless: boolean;
+        isolate: boolean;
+        fileParallelism: boolean;
+        ui: boolean;
+        viewport: {
+            width: number;
+            height: number;
+        };
+        locators: {
+            testIdAttribute: string;
+        };
+        screenshotFailures: boolean;
+    };
+    standalone: boolean;
+    logHeapUsage: boolean | undefined;
+    coverage: SerializedCoverageConfig;
+    benchmark?: {
+        includeSamples: boolean;
+    };
+}
+interface SerializedCoverageConfig {
+    provider: 'istanbul' | 'v8' | 'custom' | undefined;
+    reportsDirectory: string;
+    htmlReporter: {
+        subdir: string | undefined;
+    } | undefined;
+    enabled: boolean;
+    customProviderModule: string | undefined;
+}
+type RuntimeConfig = Pick<SerializedConfig, 'allowOnly' | 'testTimeout' | 'hookTimeout' | 'clearMocks' | 'mockReset' | 'restoreMocks' | 'fakeTimers' | 'maxConcurrency' | 'expect' | 'printConsoleTrace'> & {
+    sequence?: {
+        hooks?: SequenceHooks;
+    };
+};
+type RuntimeOptions = Partial<RuntimeConfig>;
+
+export type { FakeTimerInstallOpts as F, RuntimeOptions as R, SerializedConfig as S, SerializedCoverageConfig as a, RuntimeConfig as b };

pwa/node_modules/vitest/dist/chunks/console.BYGVloWk.js

@@ -0,0 +1,170 @@
+import { Console } from 'node:console';
+import { relative } from 'node:path';
+import { Writable } from 'node:stream';
+import { getSafeTimers } from '@vitest/utils';
+import c from 'tinyrainbow';
+import { R as RealDate } from './date.W2xKR2qe.js';
+import { g as getWorkerState } from './utils.C8RiOc4B.js';
+
+const UNKNOWN_TEST_ID = "__vitest__unknown_test__";
+function getTaskIdByStack(root) {
+  const stack = new Error("STACK_TRACE_ERROR").stack?.split("\n");
+  if (!stack) {
+    return UNKNOWN_TEST_ID;
+  }
+  const index = stack.findIndex((line2) => line2.includes("at Console.value"));
+  const line = index === -1 ? null : stack[index + 2];
+  if (!line) {
+    return UNKNOWN_TEST_ID;
+  }
+  const filepath = line.match(/at\s(.*)\s?/)?.[1];
+  if (filepath) {
+    return relative(root, filepath);
+  }
+  return UNKNOWN_TEST_ID;
+}
+function createCustomConsole(defaultState) {
+  const stdoutBuffer = /* @__PURE__ */ new Map();
+  const stderrBuffer = /* @__PURE__ */ new Map();
+  const timers = /* @__PURE__ */ new Map();
+  const { setTimeout, clearTimeout } = getSafeTimers();
+  const state = () => defaultState || getWorkerState();
+  function schedule(taskId) {
+    const timer = timers.get(taskId);
+    const { stdoutTime, stderrTime } = timer;
+    clearTimeout(timer.timer);
+    timer.timer = setTimeout(() => {
+      if (stderrTime < stdoutTime) {
+        sendStderr(taskId);
+        sendStdout(taskId);
+      } else {
+        sendStdout(taskId);
+        sendStderr(taskId);
+      }
+    });
+  }
+  function sendStdout(taskId) {
+    sendBuffer("stdout", taskId);
+  }
+  function sendStderr(taskId) {
+    sendBuffer("stderr", taskId);
+  }
+  function sendBuffer(type, taskId) {
+    const buffers = type === "stdout" ? stdoutBuffer : stderrBuffer;
+    const buffer = buffers.get(taskId);
+    if (!buffer) {
+      return;
+    }
+    if (state().config.printConsoleTrace) {
+      buffer.forEach(([buffer2, origin]) => {
+        sendLog(type, taskId, String(buffer2), buffer2.length, origin);
+      });
+    } else {
+      const content = buffer.map((i) => String(i[0])).join("");
+      sendLog(type, taskId, content, buffer.length);
+    }
+    const timer = timers.get(taskId);
+    buffers.delete(taskId);
+    if (type === "stderr") {
+      timer.stderrTime = 0;
+    } else {
+      timer.stdoutTime = 0;
+    }
+  }
+  function sendLog(type, taskId, content, size, origin) {
+    const timer = timers.get(taskId);
+    const time = type === "stderr" ? timer.stderrTime : timer.stdoutTime;
+    state().rpc.onUserConsoleLog({
+      type,
+      content: content || "<empty line>",
+      taskId,
+      time: time || RealDate.now(),
+      size,
+      origin
+    });
+  }
+  const stdout = new Writable({
+    write(data, encoding, callback) {
+      const s = state();
+      const id = s?.current?.id || s?.current?.suite?.id || s.current?.file.id || getTaskIdByStack(s.config.root);
+      let timer = timers.get(id);
+      if (timer) {
+        timer.stdoutTime = timer.stdoutTime || RealDate.now();
+      } else {
+        timer = {
+          stdoutTime: RealDate.now(),
+          stderrTime: RealDate.now(),
+          timer: 0
+        };
+        timers.set(id, timer);
+      }
+      let buffer = stdoutBuffer.get(id);
+      if (!buffer) {
+        buffer = [];
+        stdoutBuffer.set(id, buffer);
+      }
+      if (state().config.printConsoleTrace) {
+        const limit = Error.stackTraceLimit;
+        Error.stackTraceLimit = limit + 6;
+        const stack = new Error("STACK_TRACE").stack;
+        const trace = stack?.split("\n").slice(7).join("\n");
+        Error.stackTraceLimit = limit;
+        buffer.push([data, trace]);
+      } else {
+        buffer.push([data, void 0]);
+      }
+      schedule(id);
+      callback();
+    }
+  });
+  const stderr = new Writable({
+    write(data, encoding, callback) {
+      const s = state();
+      const id = s?.current?.id || s?.current?.suite?.id || s.current?.file.id || getTaskIdByStack(s.config.root);
+      let timer = timers.get(id);
+      if (timer) {
+        timer.stderrTime = timer.stderrTime || RealDate.now();
+      } else {
+        timer = {
+          stderrTime: RealDate.now(),
+          stdoutTime: RealDate.now(),
+          timer: 0
+        };
+        timers.set(id, timer);
+      }
+      let buffer = stderrBuffer.get(id);
+      if (!buffer) {
+        buffer = [];
+        stderrBuffer.set(id, buffer);
+      }
+      if (state().config.printConsoleTrace) {
+        const limit = Error.stackTraceLimit;
+        Error.stackTraceLimit = limit + 6;
+        const stack = new Error("STACK_TRACE").stack?.split("\n");
+        Error.stackTraceLimit = limit;
+        const isTrace = stack?.some(
+          (line) => line.includes("at Console.trace")
+        );
+        if (isTrace) {
+          buffer.push([data, void 0]);
+        } else {
+          const trace = stack?.slice(7).join("\n");
+          Error.stackTraceLimit = limit;
+          buffer.push([data, trace]);
+        }
+      } else {
+        buffer.push([data, void 0]);
+      }
+      schedule(id);
+      callback();
+    }
+  });
+  return new Console({
+    stdout,
+    stderr,
+    colorMode: c.isColorSupported,
+    groupIndentation: 2
+  });
+}
+
+export { UNKNOWN_TEST_ID, createCustomConsole };

pwa/node_modules/vitest/dist/chunks/constants.fzPh7AOq.js

@@ -0,0 +1,46 @@
+const defaultPort = 51204;
+const defaultBrowserPort = 63315;
+const defaultInspectPort = 9229;
+const API_PATH = "/__vitest_api__";
+const extraInlineDeps = [
+  /^(?!.*node_modules).*\.mjs$/,
+  /^(?!.*node_modules).*\.cjs\.js$/,
+  // Vite client
+  /vite\w*\/dist\/client\/env.mjs/
+];
+const CONFIG_NAMES = ["vitest.config", "vite.config"];
+const WORKSPACES_NAMES = ["vitest.workspace", "vitest.projects"];
+const CONFIG_EXTENSIONS = [".ts", ".mts", ".cts", ".js", ".mjs", ".cjs"];
+const configFiles = CONFIG_NAMES.flatMap(
+  (name) => CONFIG_EXTENSIONS.map((ext) => name + ext)
+);
+const WORKSPACES_EXTENSIONS = [...CONFIG_EXTENSIONS, ".json"];
+const workspacesFiles = WORKSPACES_NAMES.flatMap(
+  (name) => WORKSPACES_EXTENSIONS.map((ext) => name + ext)
+);
+const globalApis = [
+  // suite
+  "suite",
+  "test",
+  "describe",
+  "it",
+  // chai
+  "chai",
+  "expect",
+  "assert",
+  // typecheck
+  "expectTypeOf",
+  "assertType",
+  // utils
+  "vitest",
+  "vi",
+  // hooks
+  "beforeAll",
+  "afterAll",
+  "beforeEach",
+  "afterEach",
+  "onTestFinished",
+  "onTestFailed"
+];
+
+export { API_PATH as A, defaultBrowserPort as a, defaultInspectPort as b, configFiles as c, defaultPort as d, extraInlineDeps as e, globalApis as g, workspacesFiles as w };

pwa/node_modules/vitest/dist/chunks/coverage.BoMDb1ip.js

@@ -0,0 +1,68 @@
+const CoverageProviderMap = {
+  v8: "@vitest/coverage-v8",
+  istanbul: "@vitest/coverage-istanbul"
+};
+async function resolveCoverageProviderModule(options, loader) {
+  if (!options?.enabled || !options.provider) {
+    return null;
+  }
+  const provider = options.provider;
+  if (provider === "v8" || provider === "istanbul") {
+    let builtInModule = CoverageProviderMap[provider];
+    if (provider === "v8" && loader.isBrowser) {
+      builtInModule += "/browser";
+    }
+    const { default: coverageModule } = await loader.executeId(builtInModule);
+    if (!coverageModule) {
+      throw new Error(
+        `Failed to load ${CoverageProviderMap[provider]}. Default export is missing.`
+      );
+    }
+    return coverageModule;
+  }
+  let customProviderModule;
+  try {
+    customProviderModule = await loader.executeId(options.customProviderModule);
+  } catch (error) {
+    throw new Error(
+      `Failed to load custom CoverageProviderModule from ${options.customProviderModule}`,
+      { cause: error }
+    );
+  }
+  if (customProviderModule.default == null) {
+    throw new Error(
+      `Custom CoverageProviderModule loaded from ${options.customProviderModule} was not the default export`
+    );
+  }
+  return customProviderModule.default;
+}
+async function getCoverageProvider(options, loader) {
+  const coverageModule = await resolveCoverageProviderModule(options, loader);
+  if (coverageModule) {
+    return coverageModule.getProvider();
+  }
+  return null;
+}
+async function startCoverageInsideWorker(options, loader) {
+  const coverageModule = await resolveCoverageProviderModule(options, loader);
+  if (coverageModule) {
+    return coverageModule.startCoverage?.();
+  }
+  return null;
+}
+async function takeCoverageInsideWorker(options, loader) {
+  const coverageModule = await resolveCoverageProviderModule(options, loader);
+  if (coverageModule) {
+    return coverageModule.takeCoverage?.();
+  }
+  return null;
+}
+async function stopCoverageInsideWorker(options, loader) {
+  const coverageModule = await resolveCoverageProviderModule(options, loader);
+  if (coverageModule) {
+    return coverageModule.stopCoverage?.();
+  }
+  return null;
+}
+
+export { CoverageProviderMap as C, stopCoverageInsideWorker as a, getCoverageProvider as g, startCoverageInsideWorker as s, takeCoverageInsideWorker as t };

pwa/node_modules/vitest/dist/chunks/creator.IIqd8RWT.js

@@ -0,0 +1,671 @@
+import { existsSync, writeFileSync, readFileSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { resolve, dirname, relative } from 'node:path';
+import { detectPackageManager, installPackage } from './index.CqYx2Nsr.js';
+import { p as prompt, f as findUp } from './index.BJDntFik.js';
+import { x } from 'tinyexec';
+import c from 'tinyrainbow';
+import { c as configFiles } from './constants.fzPh7AOq.js';
+import 'process';
+import 'node:process';
+import 'fs';
+import 'path';
+import 'node:url';
+import './_commonjsHelpers.BFTU3MAI.js';
+import 'readline';
+import 'events';
+
+const jsxExample = {
+  name: "HelloWorld.jsx",
+  js: `
+export default function HelloWorld({ name }) {
+  return (
+    <div>
+      <h1>Hello {name}!</h1>
+    </div>
+  )
+}
+`,
+  ts: `
+export default function HelloWorld({ name }: { name: string }) {
+  return (
+    <div>
+      <h1>Hello {name}!</h1>
+    </div>
+  )
+}
+`,
+  test: `
+import { expect, test } from 'vitest'
+import { render } from '@testing-library/jsx'
+import HelloWorld from './HelloWorld.jsx'
+
+test('renders name', async () => {
+  const { getByText } = render(<HelloWorld name="Vitest" />)
+  await expect.element(getByText('Hello Vitest!')).toBeInTheDocument()
+})
+`
+};
+const vueExample = {
+  name: "HelloWorld.vue",
+  js: `
+<script setup>
+defineProps({
+  name: String
+})
+<\/script>
+
+<template>
+  <div>
+    <h1>Hello {{ name }}!</h1>
+  </div>
+</template>
+`,
+  ts: `
+<script setup lang="ts">
+defineProps<{
+  name: string
+}>()
+<\/script>
+
+<template>
+  <div>
+    <h1>Hello {{ name }}!</h1>
+  </div>
+</template>
+`,
+  test: `
+import { expect, test } from 'vitest'
+import { render } from 'vitest-browser-vue'
+import HelloWorld from './HelloWorld.vue'
+
+test('renders name', async () => {
+  const { getByText } = render(HelloWorld, {
+    props: { name: 'Vitest' },
+  })
+  await expect.element(getByText('Hello Vitest!')).toBeInTheDocument()
+})
+`
+};
+const svelteExample = {
+  name: "HelloWorld.svelte",
+  js: `
+<script>
+  export let name
+<\/script>
+
+<h1>Hello {name}!</h1>
+`,
+  ts: `
+<script lang="ts">
+  export let name: string
+<\/script>
+
+<h1>Hello {name}!</h1>
+`,
+  test: `
+import { expect, test } from 'vitest'
+import { render } from 'vitest-browser-svelte'
+import HelloWorld from './HelloWorld.svelte'
+
+test('renders name', async () => {
+  const { getByText } = render(HelloWorld, { name: 'Vitest' })
+  await expect.element(getByText('Hello Vitest!')).toBeInTheDocument()
+})
+`
+};
+const markoExample = {
+  name: "HelloWorld.marko",
+  js: `
+class {
+  onCreate() {
+    this.state = { name: null }
+  }
+}
+
+<h1>Hello \${state.name}!</h1>
+`,
+  ts: `
+export interface Input {
+  name: string
+}
+
+<h1>Hello \${input.name}!</h1>
+`,
+  test: `
+import { expect, test } from 'vitest'
+import { render } from '@marko/testing-library'
+import HelloWorld from './HelloWorld.svelte'
+
+test('renders name', async () => {
+  const { getByText } = await render(HelloWorld, { name: 'Vitest' })
+  const element = getByText('Hello Vitest!')
+  expect(element).toBeInTheDocument()
+})
+`
+};
+const vanillaExample = {
+  name: "HelloWorld.js",
+  js: `
+export default function HelloWorld({ name }) {
+  const parent = document.createElement('div')
+
+  const h1 = document.createElement('h1')
+  h1.textContent = 'Hello ' + name + '!'
+  parent.appendChild(h1)
+
+  return parent
+}
+`,
+  ts: `
+export default function HelloWorld({ name }: { name: string }): HTMLDivElement {
+  const parent = document.createElement('div')
+
+  const h1 = document.createElement('h1')
+  h1.textContent = 'Hello ' + name + '!'
+  parent.appendChild(h1)
+
+  return parent
+}
+`,
+  test: `
+import { expect, test } from 'vitest'
+import { getByText } from '@testing-library/dom'
+import HelloWorld from './HelloWorld.js'
+
+test('renders name', () => {
+  const parent = HelloWorld({ name: 'Vitest' })
+  document.body.appendChild(parent)
+
+  const element = getByText(parent, 'Hello Vitest!')
+  expect(element).toBeInTheDocument()
+})
+`
+};
+function getExampleTest(framework) {
+  switch (framework) {
+    case "solid":
+    case "preact":
+      return {
+        ...jsxExample,
+        test: jsxExample.test.replace("@testing-library/jsx", `@testing-library/${framework}`)
+      };
+    case "react":
+      return {
+        ...jsxExample,
+        test: jsxExample.test.replace("@testing-library/jsx", "vitest-browser-react")
+      };
+    case "vue":
+      return vueExample;
+    case "svelte":
+      return svelteExample;
+    case "marko":
+      return markoExample;
+    default:
+      return vanillaExample;
+  }
+}
+async function generateExampleFiles(framework, lang) {
+  const example = getExampleTest(framework);
+  let fileName = example.name;
+  const folder = resolve(process.cwd(), "vitest-example");
+  const fileContent = example[lang];
+  if (!existsSync(folder)) {
+    await mkdir(folder, { recursive: true });
+  }
+  const isJSX = fileName.endsWith(".jsx");
+  if (isJSX && lang === "ts") {
+    fileName = fileName.replace(".jsx", ".tsx");
+  } else if (fileName.endsWith(".js") && lang === "ts") {
+    fileName = fileName.replace(".js", ".ts");
+  }
+  const filePath = resolve(folder, fileName);
+  const testPath = resolve(folder, `HelloWorld.test.${isJSX ? `${lang}x` : lang}`);
+  writeFileSync(filePath, fileContent.trimStart(), "utf-8");
+  writeFileSync(testPath, example.test.trimStart(), "utf-8");
+  return testPath;
+}
+
+const log = console.log;
+function getProviderOptions() {
+  const providers = {
+    playwright: "Playwright relies on Chrome DevTools protocol. Read more: https://playwright.dev",
+    webdriverio: "WebdriverIO uses WebDriver protocol. Read more: https://webdriver.io",
+    preview: "Preview is useful to quickly run your tests in the browser, but not suitable for CI."
+  };
+  return Object.entries(providers).map(([provider, description]) => {
+    return {
+      title: provider,
+      description,
+      value: provider
+    };
+  });
+}
+function getBrowserNames(provider) {
+  switch (provider) {
+    case "webdriverio":
+      return ["chrome", "firefox", "edge", "safari"];
+    case "playwright":
+      return ["chromium", "firefox", "webkit"];
+    case "preview":
+      return ["chrome", "firefox", "safari"];
+  }
+}
+function getProviderPackageNames(provider) {
+  switch (provider) {
+    case "webdriverio":
+      return {
+        types: "@vitest/browser/providers/webdriverio",
+        pkg: "webdriverio"
+      };
+    case "playwright":
+      return {
+        types: "@vitest/browser/providers/playwright",
+        pkg: "playwright"
+      };
+    case "preview":
+      return {
+        types: "@vitest/browser/matchers",
+        pkg: null
+      };
+  }
+  throw new Error(`Unsupported provider: ${provider}`);
+}
+function getFramework() {
+  return [
+    {
+      title: "vanilla",
+      value: "vanilla",
+      description: "No framework, just plain JavaScript or TypeScript."
+    },
+    {
+      title: "vue",
+      value: "vue",
+      description: '"The Progressive JavaScript Framework"'
+    },
+    {
+      title: "svelte",
+      value: "svelte",
+      description: '"Svelte: cybernetically enhanced web apps"'
+    },
+    {
+      title: "react",
+      value: "react",
+      description: '"The library for web and native user interfaces"'
+    },
+    {
+      title: "preact",
+      value: "preact",
+      description: '"Fast 3kB alternative to React with the same modern API"'
+    },
+    {
+      title: "solid",
+      value: "solid",
+      description: '"Simple and performant reactivity for building user interfaces"'
+    },
+    {
+      title: "marko",
+      value: "marko",
+      description: '"A declarative, HTML-based language that makes building web apps fun"'
+    }
+  ];
+}
+function getFrameworkTestPackage(framework) {
+  switch (framework) {
+    case "vanilla":
+      return null;
+    case "vue":
+      return "vitest-browser-vue";
+    case "svelte":
+      return "vitest-browser-svelte";
+    case "react":
+      return "vitest-browser-react";
+    case "preact":
+      return "@testing-library/preact";
+    case "solid":
+      return "@solidjs/testing-library";
+    case "marko":
+      return "@marko/testing-library";
+  }
+  throw new Error(`Unsupported framework: ${framework}`);
+}
+function getFrameworkPluginPackage(framework) {
+  switch (framework) {
+    case "vue":
+      return "@vitejs/plugin-vue";
+    case "svelte":
+      return "@sveltejs/vite-plugin-svelte";
+    case "react":
+      return "@vitejs/plugin-react";
+    case "preact":
+      return "@preact/preset-vite";
+    case "solid":
+      return "vite-plugin-solid";
+    case "marko":
+      return "@marko/vite";
+  }
+  return null;
+}
+async function updateTsConfig(type) {
+  if (type == null) {
+    return;
+  }
+  const msg = `Add "${c.bold(type)}" to your tsconfig.json "${c.bold("compilerOptions.types")}" field to have better intellisense support.`;
+  log();
+  log(c.yellow("\u25FC"), c.yellow(msg));
+}
+function getLanguageOptions() {
+  return [
+    {
+      title: "TypeScript",
+      description: "Use TypeScript.",
+      value: "ts"
+    },
+    {
+      title: "JavaScript",
+      description: "Use plain JavaScript.",
+      value: "js"
+    }
+  ];
+}
+async function installPackages(pkgManager, packages) {
+  if (!packages.length) {
+    log(c.green("\u2714"), c.bold("All packages are already installed."));
+    return;
+  }
+  log(c.cyan("\u25FC"), c.bold("Installing packages..."));
+  log(c.cyan("\u25FC"), packages.join(", "));
+  log();
+  await installPackage(packages, { dev: true, packageManager: pkgManager ?? void 0 });
+}
+function readPkgJson(path) {
+  if (!existsSync(path)) {
+    return null;
+  }
+  const content = readFileSync(path, "utf-8");
+  return JSON.parse(content);
+}
+function getPossibleDefaults(dependencies) {
+  const provider = getPossibleProvider(dependencies);
+  const framework = getPossibleFramework(dependencies);
+  return {
+    lang: "ts",
+    provider,
+    framework
+  };
+}
+function getPossibleFramework(dependencies) {
+  if (dependencies.vue || dependencies["vue-tsc"] || dependencies["@vue/reactivity"]) {
+    return "vue";
+  }
+  if (dependencies.react || dependencies["react-dom"]) {
+    return "react";
+  }
+  if (dependencies.svelte || dependencies["@sveltejs/kit"]) {
+    return "svelte";
+  }
+  if (dependencies.preact) {
+    return "preact";
+  }
+  if (dependencies["solid-js"] || dependencies["@solidjs/start"]) {
+    return "solid";
+  }
+  if (dependencies.marko) {
+    return "marko";
+  }
+  return "vanilla";
+}
+function getPossibleProvider(dependencies) {
+  if (dependencies.webdriverio || dependencies["@wdio/cli"] || dependencies["@wdio/config"]) {
+    return "webdriverio";
+  }
+  return "playwright";
+}
+function getProviderDocsLink(provider) {
+  switch (provider) {
+    case "playwright":
+      return "https://playwright.dev";
+    case "webdriverio":
+      return "https://webdriver.io";
+  }
+}
+function sort(choices, value) {
+  const index = choices.findIndex((i) => i.value === value);
+  if (index === -1) {
+    return choices;
+  }
+  const item = choices.splice(index, 1)[0];
+  return [item, ...choices];
+}
+function fail() {
+  process.exitCode = 1;
+}
+async function generateWorkspaceFile(options) {
+  const relativeRoot = relative(dirname(options.configPath), options.rootConfig);
+  const workspaceContent = [
+    `import { defineWorkspace } from 'vitest/config'`,
+    "",
+    "export default defineWorkspace([",
+    "  // If you want to keep running your existing tests in Node.js, uncomment the next line.",
+    `  // '${relativeRoot}',`,
+    `  {`,
+    `    extends: '${relativeRoot}',`,
+    `    test: {`,
+    `      browser: {`,
+    `        enabled: true,`,
+    `        name: '${options.browser}',`,
+    `        provider: '${options.provider}',`,
+    options.provider !== "preview" && `        // ${getProviderDocsLink(options.provider)}`,
+    options.provider !== "preview" && `        providerOptions: {},`,
+    `      },`,
+    `    },`,
+    `  },`,
+    `])`,
+    ""
+  ].filter((c2) => typeof c2 === "string").join("\n");
+  await writeFile(options.configPath, workspaceContent);
+}
+async function generateFrameworkConfigFile(options) {
+  const frameworkImport = options.framework === "svelte" ? `import { svelte } from '${options.frameworkPlugin}'` : `import ${options.framework} from '${options.frameworkPlugin}'`;
+  const configContent = [
+    `import { defineConfig } from 'vitest/config'`,
+    options.frameworkPlugin ? frameworkImport : null,
+    ``,
+    "export default defineConfig({",
+    options.frameworkPlugin ? `  plugins: [${options.framework}()],` : null,
+    `  test: {`,
+    `    browser: {`,
+    `      enabled: true,`,
+    `      name: '${options.browser}',`,
+    `      provider: '${options.provider}',`,
+    options.provider !== "preview" && `      // ${getProviderDocsLink(options.provider)}`,
+    options.provider !== "preview" && `      providerOptions: {},`,
+    `    },`,
+    `  },`,
+    `})`,
+    ""
+  ].filter((t) => typeof t === "string").join("\n");
+  await writeFile(options.configPath, configContent);
+}
+async function updatePkgJsonScripts(pkgJsonPath, vitestScript) {
+  if (!existsSync(pkgJsonPath)) {
+    const pkg = {
+      scripts: {
+        "test:browser": vitestScript
+      }
+    };
+    await writeFile(pkgJsonPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf-8");
+  } else {
+    const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+    pkg.scripts = pkg.scripts || {};
+    pkg.scripts["test:browser"] = vitestScript;
+    await writeFile(pkgJsonPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf-8");
+  }
+  log(c.green("\u2714"), 'Added "test:browser" script to your package.json.');
+}
+function getRunScript(pkgManager) {
+  switch (pkgManager) {
+    case "yarn@berry":
+    case "yarn":
+      return "yarn test:browser";
+    case "pnpm@6":
+    case "pnpm":
+      return "pnpm test:browser";
+    case "bun":
+      return "bun test:browser";
+    default:
+      return "npm run test:browser";
+  }
+}
+function getPlaywrightRunArgs(pkgManager) {
+  switch (pkgManager) {
+    case "yarn@berry":
+    case "yarn":
+      return ["yarn", "exec"];
+    case "pnpm@6":
+    case "pnpm":
+      return ["pnpx"];
+    case "bun":
+      return ["bunx"];
+    default:
+      return ["npx"];
+  }
+}
+async function create() {
+  log(c.cyan("\u25FC"), "This utility will help you set up a browser testing environment.\n");
+  const pkgJsonPath = resolve(process.cwd(), "package.json");
+  const pkg = readPkgJson(pkgJsonPath) || {};
+  const dependencies = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+  const defaults = getPossibleDefaults(dependencies);
+  const { lang } = await prompt({
+    type: "select",
+    name: "lang",
+    message: "Choose a language for your tests",
+    choices: sort(getLanguageOptions(), defaults?.lang)
+  });
+  if (!lang) {
+    return fail();
+  }
+  const { provider } = await prompt({
+    type: "select",
+    name: "provider",
+    message: "Choose a browser provider. Vitest will use its API to control the testing environment",
+    choices: sort(getProviderOptions(), defaults?.provider)
+  });
+  if (!provider) {
+    return fail();
+  }
+  const { browser } = await prompt({
+    type: "select",
+    name: "browser",
+    message: "Choose a browser",
+    choices: getBrowserNames(provider).map((browser2) => ({
+      title: browser2,
+      value: browser2
+    }))
+  });
+  if (!provider) {
+    return fail();
+  }
+  const { framework } = await prompt({
+    type: "select",
+    name: "framework",
+    message: "Choose your framework",
+    choices: sort(getFramework(), defaults?.framework)
+  });
+  if (!framework) {
+    return fail();
+  }
+  let installPlaywright = false;
+  if (provider === "playwright") {
+    ({ installPlaywright } = await prompt({
+      type: "confirm",
+      name: "installPlaywright",
+      message: `Install Playwright browsers (can be done manually via 'pnpm exec playwright install')?`
+    }));
+  }
+  if (installPlaywright == null) {
+    return fail();
+  }
+  const dependenciesToInstall = [
+    "@vitest/browser"
+  ];
+  const frameworkPackage = getFrameworkTestPackage(framework);
+  if (frameworkPackage) {
+    dependenciesToInstall.push(frameworkPackage);
+  }
+  const providerPkg = getProviderPackageNames(provider);
+  if (providerPkg.pkg) {
+    dependenciesToInstall.push(providerPkg.pkg);
+  }
+  const frameworkPlugin = getFrameworkPluginPackage(framework);
+  if (frameworkPlugin) {
+    dependenciesToInstall.push(frameworkPlugin);
+  }
+  const pkgManager = await detectPackageManager();
+  log();
+  await installPackages(
+    pkgManager,
+    dependenciesToInstall.filter((pkg2) => !dependencies[pkg2])
+  );
+  const rootConfig = await findUp(configFiles, {
+    cwd: process.cwd()
+  });
+  let scriptCommand = "vitest";
+  log();
+  if (rootConfig) {
+    let browserWorkspaceFile = resolve(dirname(rootConfig), `vitest.workspace.${lang}`);
+    if (existsSync(browserWorkspaceFile)) {
+      log(c.yellow("\u26A0"), c.yellow("A workspace file already exists. Creating a new one for the browser tests - you can merge them manually if needed."));
+      browserWorkspaceFile = resolve(process.cwd(), `vitest.workspace.browser.${lang}`);
+    }
+    scriptCommand = `vitest --workspace=${relative(process.cwd(), browserWorkspaceFile)}`;
+    await generateWorkspaceFile({
+      configPath: browserWorkspaceFile,
+      rootConfig,
+      provider,
+      browser
+    });
+    log(c.green("\u2714"), "Created a workspace file for browser tests:", c.bold(relative(process.cwd(), browserWorkspaceFile)));
+  } else {
+    const configPath = resolve(process.cwd(), `vitest.config.${lang}`);
+    await generateFrameworkConfigFile({
+      configPath,
+      framework,
+      frameworkPlugin,
+      provider,
+      browser
+    });
+    log(c.green("\u2714"), "Created a config file for browser tests", c.bold(relative(process.cwd(), configPath)));
+  }
+  log();
+  await updatePkgJsonScripts(pkgJsonPath, scriptCommand);
+  if (installPlaywright) {
+    log();
+    const [command, ...args] = getPlaywrightRunArgs(pkgManager);
+    const allArgs = [...args, "playwright", "install", "--with-deps"];
+    log(c.cyan("\u25FC"), `Installing Playwright dependencies with \`${c.bold(command)} ${c.bold(allArgs.join(" "))}\`...`);
+    log();
+    await x(command, allArgs, {
+      nodeOptions: {
+        stdio: ["pipe", "inherit", "inherit"]
+      }
+    });
+  }
+  if (lang === "ts") {
+    await updateTsConfig(providerPkg?.types);
+  }
+  log();
+  const exampleTestFile = await generateExampleFiles(framework, lang);
+  log(c.green("\u2714"), "Created example test file in", c.bold(relative(process.cwd(), exampleTestFile)));
+  log(c.dim("  You can safely delete this file once you have written your own tests."));
+  log();
+  log(c.cyan("\u25FC"), "All done! Run your tests with", c.bold(getRunScript(pkgManager)));
+}
+
+export { create };

pwa/node_modules/vitest/dist/chunks/date.W2xKR2qe.js

@@ -0,0 +1,53 @@
+const RealDate = Date;
+let now = null;
+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;
+}
+
+export { RealDate as R, mockDate as m, resetDate as r };

pwa/node_modules/vitest/dist/chunks/environment.LoooBwUu.d.ts

@@ -0,0 +1,174 @@
+type Awaitable<T> = T | PromiseLike<T>;
+type Nullable<T> = T | null | undefined;
+type Arrayable<T> = T | Array<T>;
+type ArgumentsType<T> = T extends (...args: infer U) => any ? U : never;
+type MutableArray<T extends readonly any[]> = {
+    -readonly [k in keyof T]: T[k];
+};
+interface Constructable {
+    new (...args: any[]): any;
+}
+type TransformMode = 'web' | 'ssr';
+/** @deprecated not used */
+interface ModuleCache {
+    promise?: Promise<any>;
+    exports?: any;
+    code?: string;
+}
+interface AfterSuiteRunMeta {
+    coverage?: unknown;
+    testFiles: string[];
+    transformMode: TransformMode | 'browser';
+    projectName?: string;
+}
+interface UserConsoleLog {
+    content: string;
+    origin?: string;
+    browser?: boolean;
+    type: 'stdout' | 'stderr';
+    taskId?: string;
+    time: number;
+    size: number;
+}
+interface ModuleGraphData {
+    graph: Record<string, string[]>;
+    externalized: string[];
+    inlined: string[];
+}
+type OnServerRestartHandler = (reason?: string) => Promise<void> | void;
+interface ProvidedContext {
+}
+
+/**
+ * Happy DOM options.
+ */
+interface HappyDOMOptions {
+    width?: number;
+    height?: number;
+    url?: string;
+    settings?: {
+        disableJavaScriptEvaluation?: boolean;
+        disableJavaScriptFileLoading?: boolean;
+        disableCSSFileLoading?: boolean;
+        disableIframePageLoading?: boolean;
+        disableComputedStyleRendering?: boolean;
+        enableFileSystemHttpRequests?: boolean;
+        navigator?: {
+            userAgent?: string;
+        };
+        device?: {
+            prefersColorScheme?: string;
+            mediaType?: string;
+        };
+    };
+}
+
+interface JSDOMOptions {
+    /**
+     * The html content for the test.
+     *
+     * @default '<!DOCTYPE html>'
+     */
+    html?: string | ArrayBufferLike;
+    /**
+     * referrer just affects the value read from document.referrer.
+     * It defaults to no referrer (which reflects as the empty string).
+     */
+    referrer?: string;
+    /**
+     * userAgent affects the value read from navigator.userAgent, as well as the User-Agent header sent while fetching subresources.
+     *
+     * @default `Mozilla/5.0 (${process.platform}) AppleWebKit/537.36 (KHTML, like Gecko) jsdom/${jsdomVersion}`
+     */
+    userAgent?: string;
+    /**
+     * url sets the value returned by window.location, document.URL, and document.documentURI,
+     * and affects things like resolution of relative URLs within the document
+     * and the same-origin restrictions and referrer used while fetching subresources.
+     *
+     * @default 'http://localhost:3000'.
+     */
+    url?: string;
+    /**
+     * contentType affects the value read from document.contentType, and how the document is parsed: as HTML or as XML.
+     * Values that are not "text/html" or an XML mime type will throw.
+     *
+     * @default 'text/html'.
+     */
+    contentType?: string;
+    /**
+     * The maximum size in code units for the separate storage areas used by localStorage and sessionStorage.
+     * Attempts to store data larger than this limit will cause a DOMException to be thrown. By default, it is set
+     * to 5,000,000 code units per origin, as inspired by the HTML specification.
+     *
+     * @default 5_000_000
+     */
+    storageQuota?: number;
+    /**
+     * Enable console?
+     *
+     * @default false
+     */
+    console?: boolean;
+    /**
+     * jsdom does not have the capability to render visual content, and will act like a headless browser by default.
+     * It provides hints to web pages through APIs such as document.hidden that their content is not visible.
+     *
+     * When the `pretendToBeVisual` option is set to `true`, jsdom will pretend that it is rendering and displaying
+     * content.
+     *
+     * @default true
+     */
+    pretendToBeVisual?: boolean;
+    /**
+     * `includeNodeLocations` preserves the location info produced by the HTML parser,
+     * allowing you to retrieve it with the nodeLocation() method (described below).
+     *
+     * It defaults to false to give the best performance,
+     * and cannot be used with an XML content type since our XML parser does not support location info.
+     *
+     * @default false
+     */
+    includeNodeLocations?: boolean | undefined;
+    /**
+     * @default 'dangerously'
+     */
+    runScripts?: 'dangerously' | 'outside-only';
+    /**
+     * Enable CookieJar
+     *
+     * @default false
+     */
+    cookieJar?: boolean;
+    resources?: 'usable';
+}
+
+interface EnvironmentReturn {
+    teardown: (global: any) => Awaitable<void>;
+}
+interface VmEnvironmentReturn {
+    getVmContext: () => {
+        [key: string]: any;
+    };
+    teardown: () => Awaitable<void>;
+}
+interface Environment {
+    name: string;
+    transformMode: 'web' | 'ssr';
+    setupVM?: (options: Record<string, any>) => Awaitable<VmEnvironmentReturn>;
+    setup: (global: any, options: Record<string, any>) => Awaitable<EnvironmentReturn>;
+}
+interface EnvironmentOptions {
+    /**
+     * jsdom options.
+     */
+    jsdom?: JSDOMOptions;
+    happyDOM?: HappyDOMOptions;
+    [x: string]: unknown;
+}
+interface ResolvedTestEnvironment {
+    environment: Environment;
+    options: Record<string, any> | null;
+}
+
+export type { AfterSuiteRunMeta as A, Constructable as C, Environment as E, HappyDOMOptions as H, JSDOMOptions as J, ModuleGraphData as M, Nullable as N, OnServerRestartHandler as O, ProvidedContext as P, ResolvedTestEnvironment as R, TransformMode as T, UserConsoleLog as U, VmEnvironmentReturn as V, EnvironmentReturn as a, Awaitable as b, Arrayable as c, ArgumentsType as d, MutableArray as e, EnvironmentOptions as f, ModuleCache as g };

pwa/node_modules/vitest/dist/chunks/execute.2pr0rHgK.js

@@ -0,0 +1,816 @@
+import fs from 'node:fs';
+import { pathToFileURL } from 'node:url';
+import vm from 'node:vm';
+import { processError } from '@vitest/utils/error';
+import { normalize as normalize$1, relative } from 'pathe';
+import { ViteNodeRunner, DEFAULT_REQUEST_STUBS } from 'vite-node/client';
+import { isInternalRequest, isNodeBuiltin as isNodeBuiltin$1, toFilePath, isPrimitive } from 'vite-node/utils';
+import { distDir } from '../path.js';
+import { resolve as resolve$1, isAbsolute as isAbsolute$1 } from 'node:path';
+import { MockerRegistry, mockObject, RedirectedModule, AutomockedModule } from '@vitest/mocker';
+import { builtinModules } from 'node:module';
+import { highlight } from '@vitest/utils';
+
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+  if (!input) {
+    return input;
+  }
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const normalize = function(path) {
+  if (path.length === 0) {
+    return ".";
+  }
+  path = normalizeWindowsPath(path);
+  const isUNCPath = path.match(_UNC_REGEX);
+  const isPathAbsolute = isAbsolute(path);
+  const trailingSeparator = path[path.length - 1] === "/";
+  path = normalizeString(path, !isPathAbsolute);
+  if (path.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path += "/";
+  }
+  if (_DRIVE_LETTER_RE.test(path)) {
+    path += "/";
+  }
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path}`;
+    }
+    return `//${path}`;
+  }
+  return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+const join = function(...arguments_) {
+  if (arguments_.length === 0) {
+    return ".";
+  }
+  let joined;
+  for (const argument of arguments_) {
+    if (argument && argument.length > 0) {
+      if (joined === void 0) {
+        joined = argument;
+      } else {
+        joined += `/${argument}`;
+      }
+    }
+  }
+  if (joined === void 0) {
+    return ".";
+  }
+  return normalize(joined.replace(/\/\/+/g, "/"));
+};
+function cwd() {
+  if (typeof process !== "undefined" && typeof process.cwd === "function") {
+    return process.cwd().replace(/\\/g, "/");
+  }
+  return "/";
+}
+const resolve = function(...arguments_) {
+  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+    const path = index >= 0 ? arguments_[index] : cwd();
+    if (!path || path.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path}/${resolvedPath}`;
+    resolvedAbsolute = isAbsolute(path);
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+    return `/${resolvedPath}`;
+  }
+  return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path.length; ++index) {
+    if (index < path.length) {
+      char = path[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) ;
+      else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+const isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+};
+const _EXTNAME_RE = /.(\.[^./]+)$/;
+const extname = function(p) {
+  const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
+  return match && match[1] || "";
+};
+const dirname = function(p) {
+  const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+  if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) {
+    segments[0] += "/";
+  }
+  return segments.join("/") || (isAbsolute(p) ? "/" : ".");
+};
+const basename = function(p, extension) {
+  const lastSegment = normalizeWindowsPath(p).split("/").pop();
+  return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
+};
+
+const { existsSync, readdirSync, statSync } = fs;
+function findMockRedirect(root, mockPath, external) {
+  const path = external || mockPath;
+  if (external || isNodeBuiltin(mockPath) || !existsSync(mockPath)) {
+    let findFile2 = function(mockFolder2, baseOriginal2) {
+      const files = readdirSync(mockFolder2);
+      for (const file of files) {
+        const baseFile = basename(file, extname(file));
+        if (baseFile === baseOriginal2) {
+          const path2 = resolve(mockFolder2, file);
+          if (statSync(path2).isFile()) {
+            return path2;
+          } else {
+            const indexFile = findFile2(path2, "index");
+            if (indexFile) {
+              return indexFile;
+            }
+          }
+        }
+      }
+      return null;
+    };
+    const mockDirname = dirname(path);
+    const mockFolder = join(root, "__mocks__", mockDirname);
+    if (!existsSync(mockFolder)) {
+      return null;
+    }
+    const baseOriginal = basename(path);
+    return findFile2(mockFolder, baseOriginal);
+  }
+  const dir = dirname(path);
+  const baseId = basename(path);
+  const fullPath = resolve(dir, "__mocks__", baseId);
+  return existsSync(fullPath) ? fullPath : null;
+}
+const builtins = /* @__PURE__ */ new Set([
+  ...builtinModules,
+  "assert/strict",
+  "diagnostics_channel",
+  "dns/promises",
+  "fs/promises",
+  "path/posix",
+  "path/win32",
+  "readline/promises",
+  "stream/consumers",
+  "stream/promises",
+  "stream/web",
+  "timers/promises",
+  "util/types",
+  "wasi"
+]);
+const prefixedBuiltins = /* @__PURE__ */ new Set(["node:test", "node:sqlite"]);
+const NODE_BUILTIN_NAMESPACE = "node:";
+function isNodeBuiltin(id) {
+  if (prefixedBuiltins.has(id)) {
+    return true;
+  }
+  return builtins.has(
+    id.startsWith(NODE_BUILTIN_NAMESPACE) ? id.slice(NODE_BUILTIN_NAMESPACE.length) : id
+  );
+}
+
+const spyModulePath = resolve$1(distDir, "spy.js");
+class VitestMocker {
+  constructor(executor) {
+    this.executor = executor;
+    const context = this.executor.options.context;
+    if (context) {
+      this.primitives = vm.runInContext(
+        "({ Object, Error, Function, RegExp, Symbol, Array, Map })",
+        context
+      );
+    } else {
+      this.primitives = {
+        Object,
+        Error,
+        Function,
+        RegExp,
+        Symbol: globalThis.Symbol,
+        Array,
+        Map
+      };
+    }
+    const Symbol2 = this.primitives.Symbol;
+    this.filterPublicKeys = [
+      "__esModule",
+      Symbol2.asyncIterator,
+      Symbol2.hasInstance,
+      Symbol2.isConcatSpreadable,
+      Symbol2.iterator,
+      Symbol2.match,
+      Symbol2.matchAll,
+      Symbol2.replace,
+      Symbol2.search,
+      Symbol2.split,
+      Symbol2.species,
+      Symbol2.toPrimitive,
+      Symbol2.toStringTag,
+      Symbol2.unscopables
+    ];
+  }
+  static pendingIds = [];
+  spyModule;
+  primitives;
+  filterPublicKeys;
+  registries = /* @__PURE__ */ new Map();
+  mockContext = {
+    callstack: null
+  };
+  get root() {
+    return this.executor.options.root;
+  }
+  get moduleCache() {
+    return this.executor.moduleCache;
+  }
+  get moduleDirectories() {
+    return this.executor.options.moduleDirectories || [];
+  }
+  async initializeSpyModule() {
+    this.spyModule = await this.executor.executeId(spyModulePath);
+  }
+  getMockerRegistry() {
+    const suite = this.getSuiteFilepath();
+    if (!this.registries.has(suite)) {
+      this.registries.set(suite, new MockerRegistry());
+    }
+    return this.registries.get(suite);
+  }
+  reset() {
+    this.registries.clear();
+  }
+  deleteCachedItem(id) {
+    const mockId = this.getMockPath(id);
+    if (this.moduleCache.has(mockId)) {
+      this.moduleCache.delete(mockId);
+    }
+  }
+  isModuleDirectory(path) {
+    return this.moduleDirectories.some((dir) => path.includes(dir));
+  }
+  getSuiteFilepath() {
+    return this.executor.state.filepath || "global";
+  }
+  createError(message, codeFrame) {
+    const Error2 = this.primitives.Error;
+    const error = new Error2(message);
+    Object.assign(error, { codeFrame });
+    return error;
+  }
+  async resolvePath(rawId, importer) {
+    let id;
+    let fsPath;
+    try {
+      [id, fsPath] = await this.executor.originalResolveUrl(rawId, importer);
+    } catch (error) {
+      if (error.code === "ERR_MODULE_NOT_FOUND") {
+        const { id: unresolvedId } = error[Symbol.for("vitest.error.not_found.data")];
+        id = unresolvedId;
+        fsPath = unresolvedId;
+      } else {
+        throw error;
+      }
+    }
+    const external = !isAbsolute$1(fsPath) || this.isModuleDirectory(fsPath) ? rawId : null;
+    return {
+      id,
+      fsPath,
+      external: external ? this.normalizePath(external) : external
+    };
+  }
+  async resolveMocks() {
+    if (!VitestMocker.pendingIds.length) {
+      return;
+    }
+    await Promise.all(
+      VitestMocker.pendingIds.map(async (mock) => {
+        const { fsPath, external } = await this.resolvePath(
+          mock.id,
+          mock.importer
+        );
+        if (mock.action === "unmock") {
+          this.unmockPath(fsPath);
+        }
+        if (mock.action === "mock") {
+          this.mockPath(
+            mock.id,
+            fsPath,
+            external,
+            mock.type,
+            mock.factory
+          );
+        }
+      })
+    );
+    VitestMocker.pendingIds = [];
+  }
+  async callFunctionMock(dep, mock) {
+    const cached = this.moduleCache.get(dep)?.exports;
+    if (cached) {
+      return cached;
+    }
+    const exports = await mock.resolve();
+    const moduleExports = new Proxy(exports, {
+      get: (target, prop) => {
+        const val = target[prop];
+        if (prop === "then") {
+          if (target instanceof Promise) {
+            return target.then.bind(target);
+          }
+        } else if (!(prop in target)) {
+          if (this.filterPublicKeys.includes(prop)) {
+            return void 0;
+          }
+          throw this.createError(
+            `[vitest] No "${String(prop)}" export is defined on the "${mock.raw}" mock. Did you forget to return it from "vi.mock"?
+If you need to partially mock a module, you can use "importOriginal" helper inside:
+`,
+            highlight(`vi.mock(import("${mock.raw}"), async (importOriginal) => {
+  const actual = await importOriginal()
+  return {
+    ...actual,
+    // your mocked methods
+  }
+})`)
+          );
+        }
+        return val;
+      }
+    });
+    this.moduleCache.set(dep, { exports: moduleExports });
+    return moduleExports;
+  }
+  // public method to avoid circular dependency
+  getMockContext() {
+    return this.mockContext;
+  }
+  // path used to store mocked dependencies
+  getMockPath(dep) {
+    return `mock:${dep}`;
+  }
+  getDependencyMock(id) {
+    const registry = this.getMockerRegistry();
+    return registry.get(id);
+  }
+  normalizePath(path) {
+    return this.moduleCache.normalizePath(path);
+  }
+  resolveMockPath(mockPath, external) {
+    return findMockRedirect(this.root, mockPath, external);
+  }
+  mockObject(object, mockExports = {}, behavior = "automock") {
+    const spyOn = this.spyModule?.spyOn;
+    if (!spyOn) {
+      throw this.createError(
+        "[vitest] `spyModule` is not defined. This is a Vitest error. Please open a new issue with reproduction."
+      );
+    }
+    return mockObject({
+      globalConstructors: this.primitives,
+      spyOn,
+      type: behavior
+    }, object, mockExports);
+  }
+  unmockPath(path) {
+    const registry = this.getMockerRegistry();
+    const id = this.normalizePath(path);
+    registry.delete(id);
+    this.deleteCachedItem(id);
+  }
+  mockPath(originalId, path, external, mockType, factory) {
+    const registry = this.getMockerRegistry();
+    const id = this.normalizePath(path);
+    if (mockType === "manual") {
+      registry.register("manual", originalId, id, factory);
+    } else if (mockType === "autospy") {
+      registry.register("autospy", originalId, id);
+    } else {
+      const redirect = this.resolveMockPath(id, external);
+      if (redirect) {
+        registry.register("redirect", originalId, id, redirect);
+      } else {
+        registry.register("automock", originalId, id);
+      }
+    }
+    this.deleteCachedItem(id);
+  }
+  async importActual(rawId, importer, callstack) {
+    const { id, fsPath } = await this.resolvePath(rawId, importer);
+    const result = await this.executor.cachedRequest(
+      id,
+      fsPath,
+      callstack || [importer]
+    );
+    return result;
+  }
+  async importMock(rawId, importee) {
+    const { id, fsPath, external } = await this.resolvePath(rawId, importee);
+    const normalizedId = this.normalizePath(fsPath);
+    let mock = this.getDependencyMock(normalizedId);
+    if (!mock) {
+      const redirect = this.resolveMockPath(normalizedId, external);
+      if (redirect) {
+        mock = new RedirectedModule(rawId, normalizedId, redirect);
+      } else {
+        mock = new AutomockedModule(rawId, normalizedId);
+      }
+    }
+    if (mock.type === "automock" || mock.type === "autospy") {
+      const mod = await this.executor.cachedRequest(id, fsPath, [importee]);
+      return this.mockObject(mod, {}, mock.type);
+    }
+    if (mock.type === "manual") {
+      return this.callFunctionMock(fsPath, mock);
+    }
+    return this.executor.dependencyRequest(mock.redirect, mock.redirect, [importee]);
+  }
+  async requestWithMock(url, callstack) {
+    const id = this.normalizePath(url);
+    const mock = this.getDependencyMock(id);
+    if (!mock) {
+      return;
+    }
+    const mockPath = this.getMockPath(id);
+    if (mock.type === "automock" || mock.type === "autospy") {
+      const cache = this.moduleCache.get(mockPath);
+      if (cache.exports) {
+        return cache.exports;
+      }
+      const exports = {};
+      this.moduleCache.set(mockPath, { exports });
+      const mod = await this.executor.directRequest(url, url, callstack);
+      this.mockObject(mod, exports, mock.type);
+      return exports;
+    }
+    if (mock.type === "manual" && !callstack.includes(mockPath) && !callstack.includes(url)) {
+      try {
+        callstack.push(mockPath);
+        this.mockContext.callstack = callstack;
+        return await this.callFunctionMock(mockPath, mock);
+      } finally {
+        this.mockContext.callstack = null;
+        const indexMock = callstack.indexOf(mockPath);
+        callstack.splice(indexMock, 1);
+      }
+    } else if (mock.type === "redirect" && !callstack.includes(mock.redirect)) {
+      return mock.redirect;
+    }
+  }
+  queueMock(id, importer, factoryOrOptions) {
+    const mockType = getMockType(factoryOrOptions);
+    VitestMocker.pendingIds.push({
+      action: "mock",
+      id,
+      importer,
+      factory: typeof factoryOrOptions === "function" ? factoryOrOptions : void 0,
+      type: mockType
+    });
+  }
+  queueUnmock(id, importer) {
+    VitestMocker.pendingIds.push({
+      action: "unmock",
+      id,
+      importer
+    });
+  }
+}
+function getMockType(factoryOrOptions) {
+  if (!factoryOrOptions) {
+    return "automock";
+  }
+  if (typeof factoryOrOptions === "function") {
+    return "manual";
+  }
+  return factoryOrOptions.spy ? "autospy" : "automock";
+}
+
+const normalizedDistDir = normalize$1(distDir);
+const { readFileSync } = fs;
+async function createVitestExecutor(options) {
+  const runner = new VitestExecutor(options);
+  await runner.executeId("/@vite/env");
+  await runner.mocker.initializeSpyModule();
+  return runner;
+}
+const externalizeMap = /* @__PURE__ */ new Map();
+const bareVitestRegexp = /^@?vitest(?:\/|$)/;
+const dispose = [];
+function listenForErrors(state) {
+  dispose.forEach((fn) => fn());
+  dispose.length = 0;
+  function catchError(err, type, event) {
+    const worker = state();
+    if (worker.current) {
+      const listeners = process.listeners(event);
+      if (listeners.length > 1) {
+        return;
+      }
+    }
+    const error = processError(err);
+    if (!isPrimitive(error)) {
+      error.VITEST_TEST_NAME = worker.current?.name;
+      if (worker.filepath) {
+        error.VITEST_TEST_PATH = relative(state().config.root, worker.filepath);
+      }
+      error.VITEST_AFTER_ENV_TEARDOWN = worker.environmentTeardownRun;
+    }
+    state().rpc.onUnhandledError(error, type);
+  }
+  const uncaughtException = (e) => catchError(e, "Uncaught Exception", "uncaughtException");
+  const unhandledRejection = (e) => catchError(e, "Unhandled Rejection", "unhandledRejection");
+  process.on("uncaughtException", uncaughtException);
+  process.on("unhandledRejection", unhandledRejection);
+  dispose.push(() => {
+    process.off("uncaughtException", uncaughtException);
+    process.off("unhandledRejection", unhandledRejection);
+  });
+}
+async function startVitestExecutor(options) {
+  const state = () => (
+    // @ts-expect-error injected untyped global
+    globalThis.__vitest_worker__ || options.state
+  );
+  const rpc = () => state().rpc;
+  process.exit = (code = process.exitCode || 0) => {
+    throw new Error(`process.exit unexpectedly called with "${code}"`);
+  };
+  listenForErrors(state);
+  const getTransformMode = () => {
+    return state().environment.transformMode ?? "ssr";
+  };
+  return await createVitestExecutor({
+    async fetchModule(id) {
+      if (externalizeMap.has(id)) {
+        return { externalize: externalizeMap.get(id) };
+      }
+      if (id.includes(distDir) || id.includes(normalizedDistDir)) {
+        const { path } = toFilePath(id, state().config.root);
+        const externalize = pathToFileURL(path).toString();
+        externalizeMap.set(id, externalize);
+        return { externalize };
+      }
+      if (bareVitestRegexp.test(id)) {
+        externalizeMap.set(id, id);
+        return { externalize: id };
+      }
+      const result = await rpc().fetch(id, getTransformMode());
+      if (result.id && !result.externalize) {
+        const code = readFileSync(result.id, "utf-8");
+        return { code };
+      }
+      return result;
+    },
+    resolveId(id, importer) {
+      return rpc().resolveId(id, importer, getTransformMode());
+    },
+    get moduleCache() {
+      return state().moduleCache;
+    },
+    get interopDefault() {
+      return state().config.deps.interopDefault;
+    },
+    get moduleDirectories() {
+      return state().config.deps.moduleDirectories;
+    },
+    get root() {
+      return state().config.root;
+    },
+    get base() {
+      return state().config.base;
+    },
+    ...options
+  });
+}
+function updateStyle(id, css) {
+  if (typeof document === "undefined") {
+    return;
+  }
+  const element = document.querySelector(`[data-vite-dev-id="${id}"]`);
+  if (element) {
+    element.textContent = css;
+    return;
+  }
+  const head = document.querySelector("head");
+  const style = document.createElement("style");
+  style.setAttribute("type", "text/css");
+  style.setAttribute("data-vite-dev-id", id);
+  style.textContent = css;
+  head?.appendChild(style);
+}
+function removeStyle(id) {
+  if (typeof document === "undefined") {
+    return;
+  }
+  const sheet = document.querySelector(`[data-vite-dev-id="${id}"]`);
+  if (sheet) {
+    document.head.removeChild(sheet);
+  }
+}
+function getDefaultRequestStubs(context) {
+  if (!context) {
+    const clientStub2 = {
+      ...DEFAULT_REQUEST_STUBS["@vite/client"],
+      updateStyle,
+      removeStyle
+    };
+    return {
+      "/@vite/client": clientStub2,
+      "@vite/client": clientStub2
+    };
+  }
+  const clientStub = vm.runInContext(
+    `(defaultClient) => ({ ...defaultClient, updateStyle: ${updateStyle.toString()}, removeStyle: ${removeStyle.toString()} })`,
+    context
+  )(DEFAULT_REQUEST_STUBS["@vite/client"]);
+  return {
+    "/@vite/client": clientStub,
+    "@vite/client": clientStub
+  };
+}
+class VitestExecutor extends ViteNodeRunner {
+  constructor(options) {
+    super({
+      ...options,
+      // interop is done inside the external executor instead
+      interopDefault: options.context ? false : options.interopDefault
+    });
+    this.options = options;
+    this.mocker = new VitestMocker(this);
+    if (!options.context) {
+      Object.defineProperty(globalThis, "__vitest_mocker__", {
+        value: this.mocker,
+        writable: true,
+        configurable: true
+      });
+      this.primitives = { Object, Reflect, Symbol };
+    } else if (options.externalModulesExecutor) {
+      this.primitives = vm.runInContext(
+        "({ Object, Reflect, Symbol })",
+        options.context
+      );
+      this.externalModules = options.externalModulesExecutor;
+    } else {
+      throw new Error(
+        "When context is provided, externalModulesExecutor must be provided as well."
+      );
+    }
+  }
+  mocker;
+  externalModules;
+  primitives;
+  getContextPrimitives() {
+    return this.primitives;
+  }
+  get state() {
+    return globalThis.__vitest_worker__ || this.options.state;
+  }
+  shouldResolveId(id, _importee) {
+    if (isInternalRequest(id) || id.startsWith("data:")) {
+      return false;
+    }
+    const transformMode = this.state.environment?.transformMode ?? "ssr";
+    return transformMode === "ssr" ? !isNodeBuiltin$1(id) : !id.startsWith("node:");
+  }
+  async originalResolveUrl(id, importer) {
+    return super.resolveUrl(id, importer);
+  }
+  async resolveUrl(id, importer) {
+    if (VitestMocker.pendingIds.length) {
+      await this.mocker.resolveMocks();
+    }
+    if (importer && importer.startsWith("mock:")) {
+      importer = importer.slice(5);
+    }
+    try {
+      return await super.resolveUrl(id, importer);
+    } catch (error) {
+      if (error.code === "ERR_MODULE_NOT_FOUND") {
+        const { id: id2 } = error[Symbol.for("vitest.error.not_found.data")];
+        const path = this.mocker.normalizePath(id2);
+        const mock = this.mocker.getDependencyMock(path);
+        if (mock !== void 0) {
+          return [id2, id2];
+        }
+      }
+      throw error;
+    }
+  }
+  async runModule(context, transformed) {
+    const vmContext = this.options.context;
+    if (!vmContext || !this.externalModules) {
+      return super.runModule(context, transformed);
+    }
+    const codeDefinition = `'use strict';async (${Object.keys(context).join(
+      ","
+    )})=>{{`;
+    const code = `${codeDefinition}${transformed}
+}}`;
+    const options = {
+      filename: context.__filename,
+      lineOffset: 0,
+      columnOffset: -codeDefinition.length
+    };
+    const fn = vm.runInContext(code, vmContext, {
+      ...options,
+      // if we encountered an import, it's not inlined
+      importModuleDynamically: this.externalModules.importModuleDynamically
+    });
+    await fn(...Object.values(context));
+  }
+  async importExternalModule(path) {
+    if (this.externalModules) {
+      return this.externalModules.import(path);
+    }
+    return super.importExternalModule(path);
+  }
+  async dependencyRequest(id, fsPath, callstack) {
+    const mocked = await this.mocker.requestWithMock(fsPath, callstack);
+    if (typeof mocked === "string") {
+      return super.dependencyRequest(mocked, mocked, callstack);
+    }
+    if (mocked && typeof mocked === "object") {
+      return mocked;
+    }
+    return super.dependencyRequest(id, fsPath, callstack);
+  }
+  prepareContext(context) {
+    if (this.state.filepath && normalize$1(this.state.filepath) === normalize$1(context.__filename)) {
+      const globalNamespace = this.options.context || globalThis;
+      Object.defineProperty(context.__vite_ssr_import_meta__, "vitest", {
+        // @ts-expect-error injected untyped global
+        get: () => globalNamespace.__vitest_index__
+      });
+    }
+    if (this.options.context && this.externalModules) {
+      context.require = this.externalModules.createRequire(context.__filename);
+    }
+    return context;
+  }
+}
+
+export { VitestExecutor as V, getDefaultRequestStubs as g, startVitestExecutor as s };

pwa/node_modules/vitest/dist/chunks/git.B5SDxu-n.js

@@ -0,0 +1,69 @@
+import { resolve } from 'pathe';
+import { x } from 'tinyexec';
+
+class VitestGit {
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  root;
+  async resolveFilesWithGitCommand(args) {
+    let result;
+    try {
+      result = await x("git", args, { nodeOptions: { cwd: this.root } });
+    } catch (e) {
+      e.message = e.stderr;
+      throw e;
+    }
+    return result.stdout.split("\n").filter((s) => s !== "").map((changedPath) => resolve(this.root, changedPath));
+  }
+  async findChangedFiles(options) {
+    const root = await this.getRoot(this.cwd);
+    if (!root) {
+      return null;
+    }
+    this.root = root;
+    const changedSince = options.changedSince;
+    if (typeof changedSince === "string") {
+      const [committed, staged2, unstaged2] = await Promise.all([
+        this.getFilesSince(changedSince),
+        this.getStagedFiles(),
+        this.getUnstagedFiles()
+      ]);
+      return [...committed, ...staged2, ...unstaged2];
+    }
+    const [staged, unstaged] = await Promise.all([
+      this.getStagedFiles(),
+      this.getUnstagedFiles()
+    ]);
+    return [...staged, ...unstaged];
+  }
+  getFilesSince(hash) {
+    return this.resolveFilesWithGitCommand([
+      "diff",
+      "--name-only",
+      `${hash}...HEAD`
+    ]);
+  }
+  getStagedFiles() {
+    return this.resolveFilesWithGitCommand(["diff", "--cached", "--name-only"]);
+  }
+  getUnstagedFiles() {
+    return this.resolveFilesWithGitCommand([
+      "ls-files",
+      "--other",
+      "--modified",
+      "--exclude-standard"
+    ]);
+  }
+  async getRoot(cwd) {
+    const args = ["rev-parse", "--show-cdup"];
+    try {
+      const result = await x("git", args, { nodeOptions: { cwd } });
+      return resolve(cwd, result.stdout.trim());
+    } catch {
+      return null;
+    }
+  }
+}
+
+export { VitestGit };

pwa/node_modules/vitest/dist/chunks/globals.D8ZVAdXd.js

@@ -0,0 +1,26 @@
+import { g as globalApis } from './constants.fzPh7AOq.js';
+import { V as VitestIndex } from './index.ckWaX2gY.js';
+import './vi.DgezovHB.js';
+import '@vitest/expect';
+import '@vitest/runner';
+import '@vitest/runner/utils';
+import 'chai';
+import './utils.C8RiOc4B.js';
+import '@vitest/utils';
+import './_commonjsHelpers.BFTU3MAI.js';
+import '@vitest/snapshot';
+import '@vitest/utils/error';
+import '@vitest/utils/source-map';
+import './date.W2xKR2qe.js';
+import '@vitest/spy';
+import './run-once.2ogXb3JV.js';
+import './benchmark.Cdu9hjj4.js';
+import 'expect-type';
+
+function registerApiGlobally() {
+  globalApis.forEach((api) => {
+    globalThis[api] = VitestIndex[api];
+  });
+}
+
+export { registerApiGlobally };

pwa/node_modules/vitest/dist/chunks/index.68735LiX.js

@@ -0,0 +1,126 @@
+const DEFAULT_TIMEOUT = 6e4;
+function defaultSerialize(i) {
+  return i;
+}
+const defaultDeserialize = defaultSerialize;
+const { clearTimeout, setTimeout } = globalThis;
+const random = Math.random.bind(Math);
+function createBirpc(functions, options) {
+  const {
+    post,
+    on,
+    off = () => {
+    },
+    eventNames = [],
+    serialize = defaultSerialize,
+    deserialize = defaultDeserialize,
+    resolver,
+    bind = "rpc",
+    timeout = DEFAULT_TIMEOUT
+  } = options;
+  const rpcPromiseMap = /* @__PURE__ */ new Map();
+  let _promise;
+  let closed = false;
+  const rpc = new Proxy({}, {
+    get(_, method) {
+      if (method === "$functions")
+        return functions;
+      if (method === "$close")
+        return close;
+      if (method === "then" && !eventNames.includes("then") && !("then" in functions))
+        return void 0;
+      const sendEvent = (...args) => {
+        post(serialize({ m: method, a: args, t: "q" }));
+      };
+      if (eventNames.includes(method)) {
+        sendEvent.asEvent = sendEvent;
+        return sendEvent;
+      }
+      const sendCall = async (...args) => {
+        if (closed)
+          throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+        if (_promise) {
+          try {
+            await _promise;
+          } finally {
+            _promise = void 0;
+          }
+        }
+        return new Promise((resolve, reject) => {
+          const id = nanoid();
+          let timeoutId;
+          if (timeout >= 0) {
+            timeoutId = setTimeout(() => {
+              try {
+                options.onTimeoutError?.(method, args);
+                throw new Error(`[birpc] timeout on calling "${method}"`);
+              } catch (e) {
+                reject(e);
+              }
+              rpcPromiseMap.delete(id);
+            }, timeout);
+            if (typeof timeoutId === "object")
+              timeoutId = timeoutId.unref?.();
+          }
+          rpcPromiseMap.set(id, { resolve, reject, timeoutId, method });
+          post(serialize({ m: method, a: args, i: id, t: "q" }));
+        });
+      };
+      sendCall.asEvent = sendEvent;
+      return sendCall;
+    }
+  });
+  function close() {
+    closed = true;
+    rpcPromiseMap.forEach(({ reject, method }) => {
+      reject(new Error(`[birpc] rpc is closed, cannot call "${method}"`));
+    });
+    rpcPromiseMap.clear();
+    off(onMessage);
+  }
+  async function onMessage(data, ...extra) {
+    const msg = deserialize(data);
+    if (msg.t === "q") {
+      const { m: method, a: args } = msg;
+      let result, error;
+      const fn = resolver ? resolver(method, functions[method]) : functions[method];
+      if (!fn) {
+        error = new Error(`[birpc] function "${method}" not found`);
+      } else {
+        try {
+          result = await fn.apply(bind === "rpc" ? rpc : functions, args);
+        } catch (e) {
+          error = e;
+        }
+      }
+      if (msg.i) {
+        if (error && options.onError)
+          options.onError(error, method, args);
+        post(serialize({ t: "s", i: msg.i, r: result, e: error }), ...extra);
+      }
+    } else {
+      const { i: ack, r: result, e: error } = msg;
+      const promise = rpcPromiseMap.get(ack);
+      if (promise) {
+        clearTimeout(promise.timeoutId);
+        if (error)
+          promise.reject(error);
+        else
+          promise.resolve(result);
+      }
+      rpcPromiseMap.delete(ack);
+    }
+  }
+  _promise = on(onMessage);
+  return rpc;
+}
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+  let id = "";
+  let i = size;
+  while (i--)
+    id += urlAlphabet[random() * 64 | 0];
+  return id;
+}
+
+export { createBirpc as c };

pwa/node_modules/vitest/dist/chunks/index.CqYx2Nsr.js

@@ -0,0 +1,133 @@
+import process$1 from 'process';
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import a from 'node:path';
+import process from 'node:process';
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import { x } from 'tinyexec';
+
+const AGENTS = [
+  "npm",
+  "yarn",
+  "yarn@berry",
+  "pnpm",
+  "pnpm@6",
+  "bun"
+];
+const LOCKS = {
+  "bun.lockb": "bun",
+  "pnpm-lock.yaml": "pnpm",
+  "yarn.lock": "yarn",
+  "package-lock.json": "npm",
+  "npm-shrinkwrap.json": "npm"
+};
+
+async function detect({ cwd, onUnknown } = {}) {
+  for (const directory of lookup(cwd)) {
+    for (const lock of Object.keys(LOCKS)) {
+      if (await fileExists(a.join(directory, lock))) {
+        const name = LOCKS[lock];
+        const result2 = await parsePackageJson(a.join(directory, "package.json"), onUnknown);
+        if (result2)
+          return result2;
+        else
+          return { name, agent: name };
+      }
+    }
+    const result = await parsePackageJson(a.join(directory, "package.json"), onUnknown);
+    if (result)
+      return result;
+  }
+  return null;
+}
+function* lookup(cwd = process.cwd()) {
+  let directory = a.resolve(cwd);
+  const { root } = a.parse(directory);
+  while (directory && directory !== root) {
+    yield directory;
+    directory = a.dirname(directory);
+  }
+}
+async function parsePackageJson(filepath, onUnknown) {
+  if (!filepath || !await fileExists(filepath))
+    return null;
+  try {
+    const pkg = JSON.parse(fs.readFileSync(filepath, "utf8"));
+    let agent;
+    if (typeof pkg.packageManager === "string") {
+      const [name, ver] = pkg.packageManager.replace(/^\^/, "").split("@");
+      let version = ver;
+      if (name === "yarn" && Number.parseInt(ver) > 1) {
+        agent = "yarn@berry";
+        version = "berry";
+        return { name, agent, version };
+      } else if (name === "pnpm" && Number.parseInt(ver) < 7) {
+        agent = "pnpm@6";
+        return { name, agent, version };
+      } else if (AGENTS.includes(name)) {
+        agent = name;
+        return { name, agent, version };
+      } else {
+        return onUnknown?.(pkg.packageManager) ?? null;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function fileExists(filePath) {
+  try {
+    const stats = await fsp.stat(filePath);
+    if (stats.isFile()) {
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+
+// src/detect.ts
+async function detectPackageManager(cwd = process$1.cwd()) {
+  const result = await detect({
+    cwd,
+    onUnknown(packageManager) {
+      console.warn("[@antfu/install-pkg] Unknown packageManager:", packageManager);
+      return void 0;
+    }
+  });
+  return result?.agent || null;
+}
+async function installPackage(names, options = {}) {
+  const detectedAgent = options.packageManager || await detectPackageManager(options.cwd) || "npm";
+  const [agent] = detectedAgent.split("@");
+  if (!Array.isArray(names))
+    names = [names];
+  const args = options.additionalArgs || [];
+  if (options.preferOffline) {
+    if (detectedAgent === "yarn@berry")
+      args.unshift("--cached");
+    else
+      args.unshift("--prefer-offline");
+  }
+  if (agent === "pnpm" && existsSync(resolve(options.cwd ?? process$1.cwd(), "pnpm-workspace.yaml")))
+    args.unshift("-w");
+  return x(
+    agent,
+    [
+      agent === "yarn" ? "add" : "install",
+      options.dev ? "-D" : "",
+      ...args,
+      ...names
+    ].filter(Boolean),
+    {
+      nodeOptions: {
+        stdio: options.silent ? "ignore" : "inherit",
+        cwd: options.cwd
+      },
+      throwOnError: true
+    }
+  );
+}
+
+export { detectPackageManager, installPackage };

pwa/node_modules/vitest/dist/chunks/index.K90BXFOx.js

@@ -0,0 +1,658 @@
+import { Console } from 'node:console';
+
+const LIVING_KEYS = [
+  "DOMException",
+  "URL",
+  "URLSearchParams",
+  "EventTarget",
+  "NamedNodeMap",
+  "Node",
+  "Attr",
+  "Element",
+  "DocumentFragment",
+  "DOMImplementation",
+  "Document",
+  "XMLDocument",
+  "CharacterData",
+  "Text",
+  "CDATASection",
+  "ProcessingInstruction",
+  "Comment",
+  "DocumentType",
+  "NodeList",
+  "RadioNodeList",
+  "HTMLCollection",
+  "HTMLOptionsCollection",
+  "DOMStringMap",
+  "DOMTokenList",
+  "StyleSheetList",
+  "HTMLElement",
+  "HTMLHeadElement",
+  "HTMLTitleElement",
+  "HTMLBaseElement",
+  "HTMLLinkElement",
+  "HTMLMetaElement",
+  "HTMLStyleElement",
+  "HTMLBodyElement",
+  "HTMLHeadingElement",
+  "HTMLParagraphElement",
+  "HTMLHRElement",
+  "HTMLPreElement",
+  "HTMLUListElement",
+  "HTMLOListElement",
+  "HTMLLIElement",
+  "HTMLMenuElement",
+  "HTMLDListElement",
+  "HTMLDivElement",
+  "HTMLAnchorElement",
+  "HTMLAreaElement",
+  "HTMLBRElement",
+  "HTMLButtonElement",
+  "HTMLCanvasElement",
+  "HTMLDataElement",
+  "HTMLDataListElement",
+  "HTMLDetailsElement",
+  "HTMLDialogElement",
+  "HTMLDirectoryElement",
+  "HTMLFieldSetElement",
+  "HTMLFontElement",
+  "HTMLFormElement",
+  "HTMLHtmlElement",
+  "HTMLImageElement",
+  "HTMLInputElement",
+  "HTMLLabelElement",
+  "HTMLLegendElement",
+  "HTMLMapElement",
+  "HTMLMarqueeElement",
+  "HTMLMediaElement",
+  "HTMLMeterElement",
+  "HTMLModElement",
+  "HTMLOptGroupElement",
+  "HTMLOptionElement",
+  "HTMLOutputElement",
+  "HTMLPictureElement",
+  "HTMLProgressElement",
+  "HTMLQuoteElement",
+  "HTMLScriptElement",
+  "HTMLSelectElement",
+  "HTMLSlotElement",
+  "HTMLSourceElement",
+  "HTMLSpanElement",
+  "HTMLTableCaptionElement",
+  "HTMLTableCellElement",
+  "HTMLTableColElement",
+  "HTMLTableElement",
+  "HTMLTimeElement",
+  "HTMLTableRowElement",
+  "HTMLTableSectionElement",
+  "HTMLTemplateElement",
+  "HTMLTextAreaElement",
+  "HTMLUnknownElement",
+  "HTMLFrameElement",
+  "HTMLFrameSetElement",
+  "HTMLIFrameElement",
+  "HTMLEmbedElement",
+  "HTMLObjectElement",
+  "HTMLParamElement",
+  "HTMLVideoElement",
+  "HTMLAudioElement",
+  "HTMLTrackElement",
+  "HTMLFormControlsCollection",
+  "SVGElement",
+  "SVGGraphicsElement",
+  "SVGSVGElement",
+  "SVGTitleElement",
+  "SVGAnimatedString",
+  "SVGNumber",
+  "SVGStringList",
+  "Event",
+  "CloseEvent",
+  "CustomEvent",
+  "MessageEvent",
+  "ErrorEvent",
+  "HashChangeEvent",
+  "PopStateEvent",
+  "StorageEvent",
+  "ProgressEvent",
+  "PageTransitionEvent",
+  "SubmitEvent",
+  "UIEvent",
+  "FocusEvent",
+  "InputEvent",
+  "MouseEvent",
+  "KeyboardEvent",
+  "TouchEvent",
+  "CompositionEvent",
+  "WheelEvent",
+  "BarProp",
+  "External",
+  "Location",
+  "History",
+  "Screen",
+  "Crypto",
+  "Performance",
+  "Navigator",
+  "PluginArray",
+  "MimeTypeArray",
+  "Plugin",
+  "MimeType",
+  "FileReader",
+  "Blob",
+  "File",
+  "FileList",
+  "ValidityState",
+  "DOMParser",
+  "XMLSerializer",
+  "FormData",
+  "XMLHttpRequestEventTarget",
+  "XMLHttpRequestUpload",
+  "XMLHttpRequest",
+  "WebSocket",
+  "NodeFilter",
+  "NodeIterator",
+  "TreeWalker",
+  "AbstractRange",
+  "Range",
+  "StaticRange",
+  "Selection",
+  "Storage",
+  "CustomElementRegistry",
+  "ShadowRoot",
+  "MutationObserver",
+  "MutationRecord",
+  "Headers",
+  "AbortController",
+  "AbortSignal",
+  "Uint8Array",
+  "Uint16Array",
+  "Uint32Array",
+  "Uint8ClampedArray",
+  "Int8Array",
+  "Int16Array",
+  "Int32Array",
+  "Float32Array",
+  "Float64Array",
+  "ArrayBuffer",
+  "DOMRectReadOnly",
+  "DOMRect",
+  // not specified in docs, but is available
+  "Image",
+  "Audio",
+  "Option",
+  "CSS"
+];
+const OTHER_KEYS = [
+  "addEventListener",
+  "alert",
+  // 'atob',
+  "blur",
+  // 'btoa',
+  "cancelAnimationFrame",
+  /* 'clearInterval', */
+  /* 'clearTimeout', */
+  "close",
+  "confirm",
+  /* 'console', */
+  "createPopup",
+  "dispatchEvent",
+  "document",
+  "focus",
+  "frames",
+  "getComputedStyle",
+  "history",
+  "innerHeight",
+  "innerWidth",
+  "length",
+  "location",
+  "matchMedia",
+  "moveBy",
+  "moveTo",
+  "name",
+  "navigator",
+  "open",
+  "outerHeight",
+  "outerWidth",
+  "pageXOffset",
+  "pageYOffset",
+  "parent",
+  "postMessage",
+  "print",
+  "prompt",
+  "removeEventListener",
+  "requestAnimationFrame",
+  "resizeBy",
+  "resizeTo",
+  "screen",
+  "screenLeft",
+  "screenTop",
+  "screenX",
+  "screenY",
+  "scroll",
+  "scrollBy",
+  "scrollLeft",
+  "scrollTo",
+  "scrollTop",
+  "scrollX",
+  "scrollY",
+  "self",
+  /* 'setInterval', */
+  /* 'setTimeout', */
+  "stop",
+  /* 'toString', */
+  "top",
+  "Window",
+  "window"
+];
+const KEYS = LIVING_KEYS.concat(OTHER_KEYS);
+
+const skipKeys = ["window", "self", "top", "parent"];
+function getWindowKeys(global, win, additionalKeys = []) {
+  const keysArray = [...additionalKeys, ...KEYS];
+  const keys = new Set(
+    keysArray.concat(Object.getOwnPropertyNames(win)).filter((k) => {
+      if (skipKeys.includes(k)) {
+        return false;
+      }
+      if (k in global) {
+        return keysArray.includes(k);
+      }
+      return true;
+    })
+  );
+  return keys;
+}
+function isClassLikeName(name) {
+  return name[0] === name[0].toUpperCase();
+}
+function populateGlobal(global, win, options = {}) {
+  const { bindFunctions = false } = options;
+  const keys = getWindowKeys(global, win, options.additionalKeys);
+  const originals = /* @__PURE__ */ new Map();
+  const overrideObject = /* @__PURE__ */ new Map();
+  for (const key of keys) {
+    const boundFunction = bindFunctions && typeof win[key] === "function" && !isClassLikeName(key) && win[key].bind(win);
+    if (KEYS.includes(key) && key in global) {
+      originals.set(key, global[key]);
+    }
+    Object.defineProperty(global, key, {
+      get() {
+        if (overrideObject.has(key)) {
+          return overrideObject.get(key);
+        }
+        if (boundFunction) {
+          return boundFunction;
+        }
+        return win[key];
+      },
+      set(v) {
+        overrideObject.set(key, v);
+      },
+      configurable: true
+    });
+  }
+  global.window = global;
+  global.self = global;
+  global.top = global;
+  global.parent = global;
+  if (global.global) {
+    global.global = global;
+  }
+  if (global.document && global.document.defaultView) {
+    Object.defineProperty(global.document, "defaultView", {
+      get: () => global,
+      enumerable: true,
+      configurable: true
+    });
+  }
+  skipKeys.forEach((k) => keys.add(k));
+  return {
+    keys,
+    skipKeys,
+    originals
+  };
+}
+
+var edge = {
+  name: "edge-runtime",
+  transformMode: "ssr",
+  async setupVM() {
+    const { EdgeVM } = await import('@edge-runtime/vm');
+    const vm = new EdgeVM({
+      extend: (context) => {
+        context.global = context;
+        context.Buffer = Buffer;
+        return context;
+      }
+    });
+    return {
+      getVmContext() {
+        return vm.context;
+      },
+      teardown() {
+      }
+    };
+  },
+  async setup(global) {
+    const { EdgeVM } = await import('@edge-runtime/vm');
+    const vm = new EdgeVM({
+      extend: (context) => {
+        context.global = context;
+        context.Buffer = Buffer;
+        KEYS.forEach((key) => {
+          if (key in global) {
+            context[key] = global[key];
+          }
+        });
+        return context;
+      }
+    });
+    const { keys, originals } = populateGlobal(global, vm.context, {
+      bindFunctions: true
+    });
+    return {
+      teardown(global2) {
+        keys.forEach((key) => delete global2[key]);
+        originals.forEach((v, k) => global2[k] = v);
+      }
+    };
+  }
+};
+
+async function teardownWindow(win) {
+  if (win.close && win.happyDOM.abort) {
+    await win.happyDOM.abort();
+    win.close();
+  } else {
+    win.happyDOM.cancelAsync();
+  }
+}
+var happy = {
+  name: "happy-dom",
+  transformMode: "web",
+  async setupVM({ happyDOM = {} }) {
+    const { Window } = await import('happy-dom');
+    let win = new Window({
+      ...happyDOM,
+      console: console && globalThis.console ? globalThis.console : void 0,
+      url: happyDOM.url || "http://localhost:3000",
+      settings: {
+        ...happyDOM.settings,
+        disableErrorCapturing: true
+      }
+    });
+    win.Buffer = Buffer;
+    if (typeof structuredClone !== "undefined" && !win.structuredClone) {
+      win.structuredClone = structuredClone;
+    }
+    return {
+      getVmContext() {
+        return win;
+      },
+      async teardown() {
+        await teardownWindow(win);
+        win = void 0;
+      }
+    };
+  },
+  async setup(global, { happyDOM = {} }) {
+    const { Window, GlobalWindow } = await import('happy-dom');
+    const win = new (GlobalWindow || Window)({
+      ...happyDOM,
+      console: console && global.console ? global.console : void 0,
+      url: happyDOM.url || "http://localhost:3000",
+      settings: {
+        ...happyDOM.settings,
+        disableErrorCapturing: true
+      }
+    });
+    const { keys, originals } = populateGlobal(global, win, {
+      bindFunctions: true,
+      // jsdom doesn't support Request and Response, but happy-dom does
+      additionalKeys: ["Request", "Response", "MessagePort", "fetch"]
+    });
+    return {
+      async teardown(global2) {
+        await teardownWindow(win);
+        keys.forEach((key) => delete global2[key]);
+        originals.forEach((v, k) => global2[k] = v);
+      }
+    };
+  }
+};
+
+function catchWindowErrors(window) {
+  let userErrorListenerCount = 0;
+  function throwUnhandlerError(e) {
+    if (userErrorListenerCount === 0 && e.error != null) {
+      process.emit("uncaughtException", e.error);
+    }
+  }
+  const addEventListener = window.addEventListener.bind(window);
+  const removeEventListener = window.removeEventListener.bind(window);
+  window.addEventListener("error", throwUnhandlerError);
+  window.addEventListener = function(...args) {
+    if (args[0] === "error") {
+      userErrorListenerCount++;
+    }
+    return addEventListener.apply(this, args);
+  };
+  window.removeEventListener = function(...args) {
+    if (args[0] === "error" && userErrorListenerCount) {
+      userErrorListenerCount--;
+    }
+    return removeEventListener.apply(this, args);
+  };
+  return function clearErrorHandlers() {
+    window.removeEventListener("error", throwUnhandlerError);
+  };
+}
+var jsdom = {
+  name: "jsdom",
+  transformMode: "web",
+  async setupVM({ jsdom = {} }) {
+    const { CookieJar, JSDOM, ResourceLoader, VirtualConsole } = await import('jsdom');
+    const {
+      html = "<!DOCTYPE html>",
+      userAgent,
+      url = "http://localhost:3000",
+      contentType = "text/html",
+      pretendToBeVisual = true,
+      includeNodeLocations = false,
+      runScripts = "dangerously",
+      resources,
+      console = false,
+      cookieJar = false,
+      ...restOptions
+    } = jsdom;
+    let dom = new JSDOM(html, {
+      pretendToBeVisual,
+      resources: resources ?? (userAgent ? new ResourceLoader({ userAgent }) : void 0),
+      runScripts,
+      url,
+      virtualConsole: console && globalThis.console ? new VirtualConsole().sendTo(globalThis.console) : void 0,
+      cookieJar: cookieJar ? new CookieJar() : void 0,
+      includeNodeLocations,
+      contentType,
+      userAgent,
+      ...restOptions
+    });
+    const clearWindowErrors = catchWindowErrors(dom.window);
+    dom.window.Buffer = Buffer;
+    dom.window.jsdom = dom;
+    const globalNames = [
+      "structuredClone",
+      "fetch",
+      "Request",
+      "Response",
+      "BroadcastChannel",
+      "MessageChannel",
+      "MessagePort",
+      "TextEncoder",
+      "TextDecoder"
+    ];
+    for (const name of globalNames) {
+      const value = globalThis[name];
+      if (typeof value !== "undefined" && typeof dom.window[name] === "undefined") {
+        dom.window[name] = value;
+      }
+    }
+    return {
+      getVmContext() {
+        return dom.getInternalVMContext();
+      },
+      teardown() {
+        clearWindowErrors();
+        dom.window.close();
+        dom = void 0;
+      }
+    };
+  },
+  async setup(global, { jsdom = {} }) {
+    const { CookieJar, JSDOM, ResourceLoader, VirtualConsole } = await import('jsdom');
+    const {
+      html = "<!DOCTYPE html>",
+      userAgent,
+      url = "http://localhost:3000",
+      contentType = "text/html",
+      pretendToBeVisual = true,
+      includeNodeLocations = false,
+      runScripts = "dangerously",
+      resources,
+      console = false,
+      cookieJar = false,
+      ...restOptions
+    } = jsdom;
+    const dom = new JSDOM(html, {
+      pretendToBeVisual,
+      resources: resources ?? (userAgent ? new ResourceLoader({ userAgent }) : void 0),
+      runScripts,
+      url,
+      virtualConsole: console && global.console ? new VirtualConsole().sendTo(global.console) : void 0,
+      cookieJar: cookieJar ? new CookieJar() : void 0,
+      includeNodeLocations,
+      contentType,
+      userAgent,
+      ...restOptions
+    });
+    const { keys, originals } = populateGlobal(global, dom.window, {
+      bindFunctions: true
+    });
+    const clearWindowErrors = catchWindowErrors(global);
+    global.jsdom = dom;
+    return {
+      teardown(global2) {
+        clearWindowErrors();
+        dom.window.close();
+        delete global2.jsdom;
+        keys.forEach((key) => delete global2[key]);
+        originals.forEach((v, k) => global2[k] = v);
+      }
+    };
+  }
+};
+
+const denyList = /* @__PURE__ */ new Set([
+  "GLOBAL",
+  "root",
+  "global",
+  "Buffer",
+  "ArrayBuffer",
+  "Uint8Array"
+]);
+const nodeGlobals = new Map(
+  Object.getOwnPropertyNames(globalThis).filter((global) => !denyList.has(global)).map((nodeGlobalsKey) => {
+    const descriptor = Object.getOwnPropertyDescriptor(
+      globalThis,
+      nodeGlobalsKey
+    );
+    if (!descriptor) {
+      throw new Error(
+        `No property descriptor for ${nodeGlobalsKey}, this is a bug in Vitest.`
+      );
+    }
+    return [nodeGlobalsKey, descriptor];
+  })
+);
+var node = {
+  name: "node",
+  transformMode: "ssr",
+  // this is largely copied from jest's node environment
+  async setupVM() {
+    const vm = await import('node:vm');
+    let context = vm.createContext();
+    let global = vm.runInContext("this", context);
+    const contextGlobals = new Set(Object.getOwnPropertyNames(global));
+    for (const [nodeGlobalsKey, descriptor] of nodeGlobals) {
+      if (!contextGlobals.has(nodeGlobalsKey)) {
+        if (descriptor.configurable) {
+          Object.defineProperty(global, nodeGlobalsKey, {
+            configurable: true,
+            enumerable: descriptor.enumerable,
+            get() {
+              const val = globalThis[nodeGlobalsKey];
+              Object.defineProperty(global, nodeGlobalsKey, {
+                configurable: true,
+                enumerable: descriptor.enumerable,
+                value: val,
+                writable: descriptor.writable === true || nodeGlobalsKey === "performance"
+              });
+              return val;
+            },
+            set(val) {
+              Object.defineProperty(global, nodeGlobalsKey, {
+                configurable: true,
+                enumerable: descriptor.enumerable,
+                value: val,
+                writable: true
+              });
+            }
+          });
+        } else if ("value" in descriptor) {
+          Object.defineProperty(global, nodeGlobalsKey, {
+            configurable: false,
+            enumerable: descriptor.enumerable,
+            value: descriptor.value,
+            writable: descriptor.writable
+          });
+        } else {
+          Object.defineProperty(global, nodeGlobalsKey, {
+            configurable: false,
+            enumerable: descriptor.enumerable,
+            get: descriptor.get,
+            set: descriptor.set
+          });
+        }
+      }
+    }
+    global.global = global;
+    global.Buffer = Buffer;
+    global.ArrayBuffer = ArrayBuffer;
+    global.Uint8Array = Uint8Array;
+    return {
+      getVmContext() {
+        return context;
+      },
+      teardown() {
+        context = void 0;
+        global = void 0;
+      }
+    };
+  },
+  async setup(global) {
+    global.console.Console = Console;
+    return {
+      teardown(global2) {
+        delete global2.console.Console;
+      }
+    };
+  }
+};
+
+const environments = {
+  node,
+  jsdom,
+  "happy-dom": happy,
+  "edge-runtime": edge
+};
+
+export { environments as e, populateGlobal as p };

pwa/node_modules/vitest/dist/chunks/index.ckWaX2gY.js

@@ -0,0 +1,54 @@
+import { c as createExpect, a as globalExpect, v as vi, b as vitest } from './vi.DgezovHB.js';
+import { g as getWorkerState } from './utils.C8RiOc4B.js';
+import { i as isFirstRun, a as runOnce } from './run-once.2ogXb3JV.js';
+import { b as bench } from './benchmark.Cdu9hjj4.js';
+import { expectTypeOf } from 'expect-type';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
+import * as chai from 'chai';
+import { assert, should } from 'chai';
+
+function inject(key) {
+  const workerState = getWorkerState();
+  return workerState.providedContext[key];
+}
+
+function getRunningMode() {
+  return process.env.VITEST_MODE === "WATCH" ? "watch" : "run";
+}
+function isWatchMode() {
+  return getRunningMode() === "watch";
+}
+
+const assertType = function assertType2() {
+};
+
+var VitestIndex = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  afterAll: afterAll,
+  afterEach: afterEach,
+  assert: assert,
+  assertType: assertType,
+  beforeAll: beforeAll,
+  beforeEach: beforeEach,
+  bench: bench,
+  chai: chai,
+  createExpect: createExpect,
+  describe: describe,
+  expect: globalExpect,
+  expectTypeOf: expectTypeOf,
+  getRunningMode: getRunningMode,
+  inject: inject,
+  isFirstRun: isFirstRun,
+  isWatchMode: isWatchMode,
+  it: it,
+  onTestFailed: onTestFailed,
+  onTestFinished: onTestFinished,
+  runOnce: runOnce,
+  should: should,
+  suite: suite,
+  test: test,
+  vi: vi,
+  vitest: vitest
+});
+
+export { VitestIndex as V, isWatchMode as a, assertType as b, getRunningMode as g, inject as i };

pwa/node_modules/vitest/dist/chunks/index.nEwtF0bu.js

@@ -0,0 +1,107 @@
+import * as chai from 'chai';
+import { resolve } from 'node:path';
+import { t as takeCoverageInsideWorker } from './coverage.BoMDb1ip.js';
+import { distDir } from '../path.js';
+import { r as rpc } from './rpc.C3q9uwRX.js';
+import { l as loadDiffConfig, a as loadSnapshotSerializers } from './setup-common.Dj6BZI3u.js';
+import { g as getWorkerState } from './utils.C8RiOc4B.js';
+
+function setupChaiConfig(config) {
+  Object.assign(chai.config, config);
+}
+
+async function resolveSnapshotEnvironment(config, executor) {
+  if (!config.snapshotEnvironment) {
+    const { VitestNodeSnapshotEnvironment } = await import('./node.AKq966Jp.js');
+    return new VitestNodeSnapshotEnvironment();
+  }
+  const mod = await executor.executeId(config.snapshotEnvironment);
+  if (typeof mod.default !== "object" || !mod.default) {
+    throw new Error(
+      "Snapshot environment module must have a default export object with a shape of `SnapshotEnvironment`"
+    );
+  }
+  return mod.default;
+}
+
+const runnersFile = resolve(distDir, "runners.js");
+async function getTestRunnerConstructor(config, executor) {
+  if (!config.runner) {
+    const { VitestTestRunner, NodeBenchmarkRunner } = await executor.executeFile(runnersFile);
+    return config.mode === "test" ? VitestTestRunner : NodeBenchmarkRunner;
+  }
+  const mod = await executor.executeId(config.runner);
+  if (!mod.default && typeof mod.default !== "function") {
+    throw new Error(
+      `Runner must export a default function, but got ${typeof mod.default} imported from ${config.runner}`
+    );
+  }
+  return mod.default;
+}
+async function resolveTestRunner(config, executor) {
+  const TestRunner = await getTestRunnerConstructor(config, executor);
+  const testRunner = new TestRunner(config);
+  Object.defineProperty(testRunner, "__vitest_executor", {
+    value: executor,
+    enumerable: false,
+    configurable: false
+  });
+  if (!testRunner.config) {
+    testRunner.config = config;
+  }
+  if (!testRunner.importFile) {
+    throw new Error('Runner must implement "importFile" method.');
+  }
+  const [diffOptions] = await Promise.all([
+    loadDiffConfig(config, executor),
+    loadSnapshotSerializers(config, executor)
+  ]);
+  testRunner.config.diffOptions = diffOptions;
+  const originalOnTaskUpdate = testRunner.onTaskUpdate;
+  testRunner.onTaskUpdate = async (task) => {
+    const p = rpc().onTaskUpdate(task);
+    await originalOnTaskUpdate?.call(testRunner, task);
+    return p;
+  };
+  const originalOnCollected = testRunner.onCollected;
+  testRunner.onCollected = async (files) => {
+    const state = getWorkerState();
+    files.forEach((file) => {
+      file.prepareDuration = state.durations.prepare;
+      file.environmentLoad = state.durations.environment;
+      state.durations.prepare = 0;
+      state.durations.environment = 0;
+    });
+    rpc().onCollected(files);
+    await originalOnCollected?.call(testRunner, files);
+  };
+  const originalOnAfterRun = testRunner.onAfterRunFiles;
+  testRunner.onAfterRunFiles = async (files) => {
+    const state = getWorkerState();
+    const coverage = await takeCoverageInsideWorker(config.coverage, executor);
+    if (coverage) {
+      rpc().onAfterSuiteRun({
+        coverage,
+        testFiles: files.map((file) => file.name).sort(),
+        transformMode: state.environment.transformMode,
+        projectName: state.ctx.projectName
+      });
+    }
+    await originalOnAfterRun?.call(testRunner, files);
+  };
+  const originalOnAfterRunTask = testRunner.onAfterRunTask;
+  testRunner.onAfterRunTask = async (test) => {
+    if (config.bail && test.result?.state === "fail") {
+      const previousFailures = await rpc().getCountOfFailedTests();
+      const currentFailures = 1 + previousFailures;
+      if (currentFailures >= config.bail) {
+        rpc().onCancel("test-failure");
+        testRunner.onCancel?.("test-failure");
+      }
+    }
+    await originalOnAfterRunTask?.call(testRunner, test);
+  };
+  return testRunner;
+}
+
+export { resolveSnapshotEnvironment as a, resolveTestRunner as r, setupChaiConfig as s };

pwa/node_modules/vitest/dist/chunks/inspector.70d6emsh.js

@@ -0,0 +1,54 @@
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+
+const __require = createRequire(import.meta.url);
+let inspector;
+let session;
+function setupInspect(ctx) {
+  const config = ctx.config;
+  const isEnabled = config.inspector.enabled;
+  if (isEnabled) {
+    inspector = __require("node:inspector");
+    const isOpen = inspector.url() !== void 0;
+    if (!isOpen) {
+      inspector.open(
+        config.inspector.port,
+        config.inspector.host,
+        config.inspector.waitForDebugger
+      );
+      if (config.inspectBrk) {
+        const firstTestFile = ctx.files[0];
+        if (firstTestFile) {
+          session = new inspector.Session();
+          session.connect();
+          session.post("Debugger.enable");
+          session.post("Debugger.setBreakpointByUrl", {
+            lineNumber: 0,
+            url: pathToFileURL(firstTestFile)
+          });
+        }
+      }
+    }
+  }
+  const keepOpen = shouldKeepOpen(config);
+  return function cleanup() {
+    if (isEnabled && !keepOpen && inspector) {
+      inspector.close();
+      session?.disconnect();
+    }
+  };
+}
+function closeInspector(config) {
+  const keepOpen = shouldKeepOpen(config);
+  if (inspector && !keepOpen) {
+    inspector.close();
+    session?.disconnect();
+  }
+}
+function shouldKeepOpen(config) {
+  const isIsolatedSingleThread = config.pool === "threads" && config.poolOptions?.threads?.isolate === false && config.poolOptions?.threads?.singleThread;
+  const isIsolatedSingleFork = config.pool === "forks" && config.poolOptions?.forks?.isolate === false && config.poolOptions?.forks?.singleFork;
+  return config.watch && (isIsolatedSingleFork || isIsolatedSingleThread);
+}
+
+export { closeInspector as c, setupInspect as s };

pwa/node_modules/vitest/dist/chunks/mocker.cRtM890J.d.ts

@@ -0,0 +1,17 @@
+import { MockedModuleType } from '@vitest/mocker';
+
+type Promisable<T> = T | Promise<T>;
+type MockFactoryWithHelper<M = unknown> = (importOriginal: <T extends M = M>() => Promise<T>) => Promisable<Partial<M>>;
+type MockFactory = () => any;
+interface MockOptions {
+    spy?: boolean;
+}
+interface PendingSuiteMock {
+    id: string;
+    importer: string;
+    action: 'mock' | 'unmock';
+    type?: MockedModuleType;
+    factory?: MockFactory;
+}
+
+export type { MockFactoryWithHelper as M, PendingSuiteMock as P, MockOptions as a, MockFactory as b };

pwa/node_modules/vitest/dist/chunks/node.AKq966Jp.js

@@ -0,0 +1,15 @@
+import { NodeSnapshotEnvironment } from '@vitest/snapshot/environment';
+import { g as getWorkerState } from './utils.C8RiOc4B.js';
+import '@vitest/utils';
+
+class VitestNodeSnapshotEnvironment extends NodeSnapshotEnvironment {
+  getHeader() {
+    return `// Vitest Snapshot v${this.getVersion()}, https://vitest.dev/guide/snapshot.html`;
+  }
+  resolvePath(filepath) {
+    const rpc = getWorkerState().rpc;
+    return rpc.resolveSnapshotPath(filepath);
+  }
+}
+
+export { VitestNodeSnapshotEnvironment };

pwa/node_modules/vitest/dist/chunks/rpc.C3q9uwRX.js

@@ -0,0 +1,103 @@
+import { getSafeTimers } from '@vitest/utils';
+import { c as createBirpc } from './index.68735LiX.js';
+import { g as getWorkerState } from './utils.C8RiOc4B.js';
+
+const { get } = Reflect;
+function withSafeTimers(fn) {
+  const { setTimeout, clearTimeout, nextTick, setImmediate, clearImmediate } = getSafeTimers();
+  const currentSetTimeout = globalThis.setTimeout;
+  const currentClearTimeout = globalThis.clearTimeout;
+  const currentSetImmediate = globalThis.setImmediate;
+  const currentClearImmediate = globalThis.clearImmediate;
+  const currentNextTick = globalThis.process?.nextTick;
+  try {
+    globalThis.setTimeout = setTimeout;
+    globalThis.clearTimeout = clearTimeout;
+    globalThis.setImmediate = setImmediate;
+    globalThis.clearImmediate = clearImmediate;
+    if (globalThis.process) {
+      globalThis.process.nextTick = nextTick;
+    }
+    const result = fn();
+    return result;
+  } finally {
+    globalThis.setTimeout = currentSetTimeout;
+    globalThis.clearTimeout = currentClearTimeout;
+    globalThis.setImmediate = currentSetImmediate;
+    globalThis.clearImmediate = currentClearImmediate;
+    if (globalThis.process) {
+      nextTick(() => {
+        globalThis.process.nextTick = currentNextTick;
+      });
+    }
+  }
+}
+const promises = /* @__PURE__ */ new Set();
+async function rpcDone() {
+  if (!promises.size) {
+    return;
+  }
+  const awaitable = Array.from(promises);
+  return Promise.all(awaitable);
+}
+function createRuntimeRpc(options) {
+  let setCancel = (_reason) => {
+  };
+  const onCancel = new Promise((resolve) => {
+    setCancel = resolve;
+  });
+  const rpc2 = createSafeRpc(
+    createBirpc(
+      {
+        onCancel: setCancel
+      },
+      {
+        eventNames: [
+          "onUserConsoleLog",
+          "onFinished",
+          "onCollected",
+          "onCancel"
+        ],
+        onTimeoutError(functionName, args) {
+          let message = `[vitest-worker]: Timeout calling "${functionName}"`;
+          if (functionName === "fetch" || functionName === "transform" || functionName === "resolveId") {
+            message += ` with "${JSON.stringify(args)}"`;
+          }
+          if (functionName === "onUnhandledError") {
+            message += ` with "${args[0]?.message || args[0]}"`;
+          }
+          throw new Error(message);
+        },
+        ...options
+      }
+    )
+  );
+  return {
+    rpc: rpc2,
+    onCancel
+  };
+}
+function createSafeRpc(rpc2) {
+  return new Proxy(rpc2, {
+    get(target, p, handler) {
+      const sendCall = get(target, p, handler);
+      const safeSendCall = (...args) => withSafeTimers(async () => {
+        const result = sendCall(...args);
+        promises.add(result);
+        try {
+          return await result;
+        } finally {
+          promises.delete(result);
+        }
+      });
+      safeSendCall.asEvent = sendCall.asEvent;
+      return safeSendCall;
+    }
+  });
+}
+function rpc() {
+  const { rpc: rpc2 } = getWorkerState();
+  return rpc2;
+}
+
+export { rpcDone as a, createRuntimeRpc as c, rpc as r };

pwa/node_modules/vitest/dist/chunks/run-once.2ogXb3JV.js

@@ -0,0 +1,28 @@
+import { g as getWorkerState } from './utils.C8RiOc4B.js';
+
+const filesCount = /* @__PURE__ */ new Map();
+const cache = /* @__PURE__ */ new Map();
+function runOnce(fn, 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, fn());
+  }
+  return cache.get(id);
+}
+function isFirstRun() {
+  let firstRun = false;
+  runOnce(() => {
+    firstRun = true;
+  }, "__vitest_first_run__");
+  return firstRun;
+}
+function resetRunOnceCounter() {
+  filesCount.clear();
+}
+
+export { runOnce as a, isFirstRun as i, resetRunOnceCounter as r };

pwa/node_modules/vitest/dist/chunks/runBaseTests.3qpJUEJM.js

@@ -0,0 +1,139 @@
+import { performance } from 'node:perf_hooks';
+import { startTests, collectTests } from '@vitest/runner';
+import { a as resolveSnapshotEnvironment, s as setupChaiConfig, r as resolveTestRunner } from './index.nEwtF0bu.js';
+import { s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from './coverage.BoMDb1ip.js';
+import { a as globalExpect, v as vi } from './vi.DgezovHB.js';
+import { c as closeInspector } from './inspector.70d6emsh.js';
+import { createRequire } from 'node:module';
+import timers from 'node:timers';
+import util from 'node:util';
+import { getSafeTimers } from '@vitest/utils';
+import { KNOWN_ASSET_TYPES } from 'vite-node/constants';
+import { installSourcemapsSupport } from 'vite-node/source-map';
+import { V as VitestIndex } from './index.ckWaX2gY.js';
+import { s as setupCommonEnv } from './setup-common.Dj6BZI3u.js';
+import { g as getWorkerState, r as resetModules } from './utils.C8RiOc4B.js';
+import 'chai';
+import 'node:path';
+import '../path.js';
+import 'node:url';
+import './rpc.C3q9uwRX.js';
+import './index.68735LiX.js';
+import '@vitest/expect';
+import '@vitest/runner/utils';
+import './_commonjsHelpers.BFTU3MAI.js';
+import '@vitest/snapshot';
+import '@vitest/utils/error';
+import '@vitest/utils/source-map';
+import './date.W2xKR2qe.js';
+import '@vitest/spy';
+import './run-once.2ogXb3JV.js';
+import './benchmark.Cdu9hjj4.js';
+import 'expect-type';
+
+let globalSetup = false;
+async function setupGlobalEnv(config, { environment }, executor) {
+  await setupCommonEnv(config);
+  Object.defineProperty(globalThis, "__vitest_index__", {
+    value: VitestIndex,
+    enumerable: false
+  });
+  const state = getWorkerState();
+  if (!state.config.snapshotOptions.snapshotEnvironment) {
+    state.config.snapshotOptions.snapshotEnvironment = await resolveSnapshotEnvironment(config, executor);
+  }
+  if (globalSetup) {
+    return;
+  }
+  globalSetup = true;
+  if (environment.transformMode === "web") {
+    const _require = createRequire(import.meta.url);
+    _require.extensions[".css"] = resolveCss;
+    _require.extensions[".scss"] = resolveCss;
+    _require.extensions[".sass"] = resolveCss;
+    _require.extensions[".less"] = resolveCss;
+    KNOWN_ASSET_TYPES.forEach((type) => {
+      _require.extensions[`.${type}`] = resolveAsset;
+    });
+    process.env.SSR = "";
+  } else {
+    process.env.SSR = "1";
+  }
+  globalThis.__vitest_required__ = {
+    util,
+    timers
+  };
+  installSourcemapsSupport({
+    getSourceMap: (source) => state.moduleCache.getSourceMap(source)
+  });
+  if (!config.disableConsoleIntercept) {
+    await setupConsoleLogSpy();
+  }
+}
+function resolveCss(mod) {
+  mod.exports = "";
+}
+function resolveAsset(mod, url) {
+  mod.exports = url;
+}
+async function setupConsoleLogSpy() {
+  const { createCustomConsole } = await import('./console.BYGVloWk.js');
+  globalThis.console = createCustomConsole();
+}
+async function withEnv({ environment }, options, fn) {
+  globalThis.__vitest_environment__ = environment.name;
+  globalExpect.setState({
+    environment: environment.name
+  });
+  const env = await environment.setup(globalThis, options);
+  try {
+    await fn();
+  } finally {
+    const { setTimeout } = getSafeTimers();
+    await new Promise((resolve) => setTimeout(resolve));
+    await env.teardown(globalThis);
+  }
+}
+
+async function run(method, files, config, environment, executor) {
+  const workerState = getWorkerState();
+  await setupGlobalEnv(config, environment, executor);
+  await startCoverageInsideWorker(config.coverage, executor);
+  if (config.chaiConfig) {
+    setupChaiConfig(config.chaiConfig);
+  }
+  const runner = await resolveTestRunner(config, executor);
+  workerState.onCancel.then((reason) => {
+    closeInspector(config);
+    runner.onCancel?.(reason);
+  });
+  workerState.durations.prepare = performance.now() - workerState.durations.prepare;
+  workerState.durations.environment = performance.now();
+  await withEnv(
+    environment,
+    environment.options || config.environmentOptions || {},
+    async () => {
+      workerState.durations.environment = performance.now() - workerState.durations.environment;
+      for (const file of files) {
+        const isIsolatedThreads = config.pool === "threads" && (config.poolOptions?.threads?.isolate ?? true);
+        const isIsolatedForks = config.pool === "forks" && (config.poolOptions?.forks?.isolate ?? true);
+        if (isIsolatedThreads || isIsolatedForks) {
+          executor.mocker.reset();
+          resetModules(workerState.moduleCache, true);
+        }
+        workerState.filepath = file;
+        if (method === "run") {
+          await startTests([file], runner);
+        } else {
+          await collectTests([file], runner);
+        }
+        vi.resetConfig();
+        vi.restoreAllMocks();
+      }
+      await stopCoverageInsideWorker(config.coverage, executor);
+    }
+  );
+  workerState.environmentTeardownRun = true;
+}
+
+export { run };

pwa/node_modules/vitest/dist/chunks/setup-common.Dj6BZI3u.js

@@ -0,0 +1,70 @@
+import { addSerializer } from '@vitest/snapshot';
+import { setSafeTimers } from '@vitest/utils';
+import { r as resetRunOnceCounter } from './run-once.2ogXb3JV.js';
+
+let globalSetup = false;
+async function setupCommonEnv(config) {
+  resetRunOnceCounter();
+  setupDefines(config.defines);
+  setupEnv(config.env);
+  if (globalSetup) {
+    return;
+  }
+  globalSetup = true;
+  setSafeTimers();
+  if (config.globals) {
+    (await import('./globals.D8ZVAdXd.js')).registerApiGlobally();
+  }
+}
+function setupDefines(defines) {
+  for (const key in defines) {
+    globalThis[key] = defines[key];
+  }
+}
+function setupEnv(env) {
+  if (typeof process === "undefined") {
+    return;
+  }
+  const { PROD, DEV, ...restEnvs } = env;
+  process.env.PROD = PROD ? "1" : "";
+  process.env.DEV = DEV ? "1" : "";
+  for (const key in restEnvs) {
+    process.env[key] = env[key];
+  }
+}
+async function loadDiffConfig(config, executor) {
+  if (typeof config.diff !== "string") {
+    return;
+  }
+  const diffModule = await executor.executeId(config.diff);
+  if (diffModule && typeof diffModule.default === "object" && diffModule.default != null) {
+    return diffModule.default;
+  } else {
+    throw new Error(
+      `invalid diff config file ${config.diff}. Must have a default export with config object`
+    );
+  }
+}
+async function loadSnapshotSerializers(config, executor) {
+  const files = config.snapshotSerializers;
+  const snapshotSerializers = await Promise.all(
+    files.map(async (file) => {
+      const mo = await executor.executeId(file);
+      if (!mo || typeof mo.default !== "object" || mo.default === null) {
+        throw new Error(
+          `invalid snapshot serializer file ${file}. Must export a default object`
+        );
+      }
+      const config2 = mo.default;
+      if (typeof config2.test !== "function" || typeof config2.serialize !== "function" && typeof config2.print !== "function") {
+        throw new TypeError(
+          `invalid snapshot serializer in ${file}. Must have a 'test' method along with either a 'serialize' or 'print' method.`
+        );
+      }
+      return config2;
+    })
+  );
+  snapshotSerializers.forEach((serializer) => addSerializer(serializer));
+}
+
+export { loadSnapshotSerializers as a, loadDiffConfig as l, setupCommonEnv as s };

pwa/node_modules/vitest/dist/chunks/spy.Cf_4R5Oe.js

@@ -0,0 +1,22 @@
+import * as spy$1 from '@vitest/spy';
+
+function _mergeNamespaces(n, m) {
+	m.forEach(function (e) {
+		e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
+			if (k !== 'default' && !(k in n)) {
+				var d = Object.getOwnPropertyDescriptor(e, k);
+				Object.defineProperty(n, k, d.get ? d : {
+					enumerable: true,
+					get: function () { return e[k]; }
+				});
+			}
+		});
+	});
+	return Object.freeze(n);
+}
+
+var spy = /*#__PURE__*/_mergeNamespaces({
+	__proto__: null
+}, [spy$1]);
+
+export { spy as s };

pwa/node_modules/vitest/dist/chunks/suite.B2jumIFP.d.ts

@@ -0,0 +1,10 @@
+import { Custom } from '@vitest/runner';
+import { a as BenchFunction, c as BenchmarkAPI } from './benchmark.geERunq4.js';
+import { Options } from 'tinybench';
+import '@vitest/runner/utils';
+
+declare function getBenchOptions(key: Custom): Options;
+declare function getBenchFn(key: Custom): BenchFunction;
+declare const bench: BenchmarkAPI;
+
+export { getBenchOptions as a, bench as b, getBenchFn as g };

pwa/node_modules/vitest/dist/chunks/utils.C8RiOc4B.js

@@ -0,0 +1,77 @@
+import { getSafeTimers } from '@vitest/utils';
+
+const NAME_WORKER_STATE = "__vitest_worker__";
+function getWorkerState() {
+  const workerState = globalThis[NAME_WORKER_STATE];
+  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 provideWorkerState(context, state) {
+  Object.defineProperty(context, NAME_WORKER_STATE, {
+    value: state,
+    configurable: true,
+    writable: true,
+    enumerable: false
+  });
+  return state;
+}
+function getCurrentEnvironment() {
+  const state = getWorkerState();
+  return state?.environment.name;
+}
+function isChildProcess() {
+  return typeof process !== "undefined" && !!process.send;
+}
+function setProcessTitle(title) {
+  try {
+    process.title = `node (${title})`;
+  } catch {
+  }
+}
+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();
+}
+
+export { getCurrentEnvironment as a, getWorkerState as g, isChildProcess as i, provideWorkerState as p, resetModules as r, setProcessTitle as s, waitForImportsToResolve as w };

pwa/node_modules/vitest/dist/chunks/utils.Cn0zI1t3.js

@@ -0,0 +1,68 @@
+import { parseRegexp } from '@vitest/utils';
+
+const REGEXP_WRAP_PREFIX = "$$vitest:";
+const processSend = process.send?.bind(process);
+const processOn = process.on?.bind(process);
+const processOff = process.off?.bind(process);
+const dispose = [];
+function createThreadsRpcOptions({
+  port
+}) {
+  return {
+    post: (v) => {
+      port.postMessage(v);
+    },
+    on: (fn) => {
+      port.addListener("message", fn);
+    }
+  };
+}
+function disposeInternalListeners() {
+  for (const fn of dispose) {
+    try {
+      fn();
+    } catch {
+    }
+  }
+  dispose.length = 0;
+}
+function createForksRpcOptions(nodeV8) {
+  return {
+    serialize: nodeV8.serialize,
+    deserialize: (v) => nodeV8.deserialize(Buffer.from(v)),
+    post(v) {
+      processSend(v);
+    },
+    on(fn) {
+      const handler = (message, ...extras) => {
+        if (message?.__tinypool_worker_message__) {
+          return;
+        }
+        return fn(message, ...extras);
+      };
+      processOn("message", handler);
+      dispose.push(() => processOff("message", handler));
+    }
+  };
+}
+function unwrapSerializableConfig(config) {
+  if (config.testNamePattern && typeof config.testNamePattern === "string") {
+    const testNamePattern = config.testNamePattern;
+    if (testNamePattern.startsWith(REGEXP_WRAP_PREFIX)) {
+      config.testNamePattern = parseRegexp(
+        testNamePattern.slice(REGEXP_WRAP_PREFIX.length)
+      );
+    }
+  }
+  if (config.defines && Array.isArray(config.defines.keys) && config.defines.original) {
+    const { keys, original } = config.defines;
+    const defines = {};
+    for (const key of keys) {
+      defines[key] = original[key];
+    }
+    config.defines = defines;
+  }
+  return config;
+}
+
+export { createThreadsRpcOptions as a, createForksRpcOptions as c, disposeInternalListeners as d, unwrapSerializableConfig as u };

pwa/node_modules/vitest/dist/chunks/utils.DNoFbBUZ.js

@@ -0,0 +1,212 @@
+import { stripVTControlCharacters } from 'node:util';
+import { slash } from '@vitest/utils';
+import { isAbsolute, relative, dirname, basename } from 'pathe';
+import c from 'tinyrainbow';
+
+const F_RIGHT = "\u2192";
+const F_DOWN = "\u2193";
+const F_DOWN_RIGHT = "\u21B3";
+const F_POINTER = "\u276F";
+const F_DOT = "\xB7";
+const F_CHECK = "\u2713";
+const F_CROSS = "\xD7";
+const F_LONG_DASH = "\u23AF";
+
+const spinnerMap = /* @__PURE__ */ new WeakMap();
+const hookSpinnerMap = /* @__PURE__ */ new WeakMap();
+const pointer = c.yellow(F_POINTER);
+const skipped = c.dim(c.gray(F_DOWN));
+const benchmarkPass = c.green(F_DOT);
+const testPass = c.green(F_CHECK);
+const taskFail = c.red(F_CROSS);
+const suiteFail = c.red(F_POINTER);
+const pending = c.gray("\xB7");
+function getCols(delta = 0) {
+  let length = process.stdout?.columns;
+  if (!length || Number.isNaN(length)) {
+    length = 30;
+  }
+  return Math.max(length + delta, 0);
+}
+function divider(text, left, right) {
+  const cols = getCols();
+  if (text) {
+    const textLength = stripVTControlCharacters(text).length;
+    if (left == null && right != null) {
+      left = cols - textLength - right;
+    } else {
+      left = left ?? Math.floor((cols - textLength) / 2);
+      right = cols - textLength - left;
+    }
+    left = Math.max(0, left);
+    right = Math.max(0, right);
+    return `${F_LONG_DASH.repeat(left)}${text}${F_LONG_DASH.repeat(right)}`;
+  }
+  return F_LONG_DASH.repeat(cols);
+}
+function formatTestPath(root, path) {
+  if (isAbsolute(path)) {
+    path = relative(root, path);
+  }
+  const dir = dirname(path);
+  const ext = path.match(/(\.(spec|test)\.[cm]?[tj]sx?)$/)?.[0] || "";
+  const base = basename(path, ext);
+  return slash(c.dim(`${dir}/`) + c.bold(base)) + c.dim(ext);
+}
+function renderSnapshotSummary(rootDir, snapshots) {
+  const summary = [];
+  if (snapshots.added) {
+    summary.push(c.bold(c.green(`${snapshots.added} written`)));
+  }
+  if (snapshots.unmatched) {
+    summary.push(c.bold(c.red(`${snapshots.unmatched} failed`)));
+  }
+  if (snapshots.updated) {
+    summary.push(c.bold(c.green(`${snapshots.updated} updated `)));
+  }
+  if (snapshots.filesRemoved) {
+    if (snapshots.didUpdate) {
+      summary.push(c.bold(c.green(`${snapshots.filesRemoved} files removed `)));
+    } else {
+      summary.push(
+        c.bold(c.yellow(`${snapshots.filesRemoved} files obsolete `))
+      );
+    }
+  }
+  if (snapshots.filesRemovedList && snapshots.filesRemovedList.length) {
+    const [head, ...tail] = snapshots.filesRemovedList;
+    summary.push(`${c.gray(F_DOWN_RIGHT)} ${formatTestPath(rootDir, head)}`);
+    tail.forEach((key) => {
+      summary.push(`  ${c.gray(F_DOT)} ${formatTestPath(rootDir, key)}`);
+    });
+  }
+  if (snapshots.unchecked) {
+    if (snapshots.didUpdate) {
+      summary.push(c.bold(c.green(`${snapshots.unchecked} removed`)));
+    } else {
+      summary.push(c.bold(c.yellow(`${snapshots.unchecked} obsolete`)));
+    }
+    snapshots.uncheckedKeysByFile.forEach((uncheckedFile) => {
+      summary.push(
+        `${c.gray(F_DOWN_RIGHT)} ${formatTestPath(
+          rootDir,
+          uncheckedFile.filePath
+        )}`
+      );
+      uncheckedFile.keys.forEach(
+        (key) => summary.push(`  ${c.gray(F_DOT)} ${key}`)
+      );
+    });
+  }
+  return summary;
+}
+function countTestErrors(tasks) {
+  return tasks.reduce((c2, i) => c2 + (i.result?.errors?.length || 0), 0);
+}
+function getStateString(tasks, name = "tests", showTotal = true) {
+  if (tasks.length === 0) {
+    return c.dim(`no ${name}`);
+  }
+  const passed = tasks.filter((i) => i.result?.state === "pass");
+  const failed = tasks.filter((i) => i.result?.state === "fail");
+  const skipped2 = tasks.filter((i) => i.mode === "skip");
+  const todo = tasks.filter((i) => i.mode === "todo");
+  return [
+    failed.length ? c.bold(c.red(`${failed.length} failed`)) : null,
+    passed.length ? c.bold(c.green(`${passed.length} passed`)) : null,
+    skipped2.length ? c.yellow(`${skipped2.length} skipped`) : null,
+    todo.length ? c.gray(`${todo.length} todo`) : null
+  ].filter(Boolean).join(c.dim(" | ")) + (showTotal ? c.gray(` (${tasks.length})`) : "");
+}
+function getStateSymbol(task) {
+  if (task.mode === "skip" || task.mode === "todo") {
+    return skipped;
+  }
+  if (!task.result) {
+    return pending;
+  }
+  if (task.result.state === "run") {
+    if (task.type === "suite") {
+      return pointer;
+    }
+    let spinner = spinnerMap.get(task);
+    if (!spinner) {
+      spinner = elegantSpinner();
+      spinnerMap.set(task, spinner);
+    }
+    return c.yellow(spinner());
+  }
+  if (task.result.state === "pass") {
+    return task.meta?.benchmark ? benchmarkPass : testPass;
+  }
+  if (task.result.state === "fail") {
+    return task.type === "suite" ? suiteFail : taskFail;
+  }
+  return " ";
+}
+function getHookStateSymbol(task, hookName) {
+  const state = task.result?.hooks?.[hookName];
+  if (state && state === "run") {
+    let spinnerMap2 = hookSpinnerMap.get(task);
+    if (!spinnerMap2) {
+      spinnerMap2 = /* @__PURE__ */ new Map();
+      hookSpinnerMap.set(task, spinnerMap2);
+    }
+    let spinner = spinnerMap2.get(hookName);
+    if (!spinner) {
+      spinner = elegantSpinner();
+      spinnerMap2.set(hookName, spinner);
+    }
+    return c.yellow(spinner());
+  }
+}
+const spinnerFrames = process.platform === "win32" ? ["-", "\\", "|", "/"] : ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function elegantSpinner() {
+  let index = 0;
+  return () => {
+    index = ++index % spinnerFrames.length;
+    return spinnerFrames[index];
+  };
+}
+function formatTimeString(date) {
+  return date.toTimeString().split(" ")[0];
+}
+function formatProjectName(name, suffix = " ") {
+  if (!name) {
+    return "";
+  }
+  const index = name.split("").reduce((acc, v, idx) => acc + v.charCodeAt(0) + idx, 0);
+  const colors = [c.blue, c.yellow, c.cyan, c.green, c.magenta];
+  return colors[index % colors.length](`|${name}|`) + suffix;
+}
+function withLabel(color, label, message) {
+  return `${c.bold(c.inverse(c[color](` ${label} `)))} ${c[color](message)}`;
+}
+
+var utils = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  benchmarkPass: benchmarkPass,
+  countTestErrors: countTestErrors,
+  divider: divider,
+  elegantSpinner: elegantSpinner,
+  formatProjectName: formatProjectName,
+  formatTestPath: formatTestPath,
+  formatTimeString: formatTimeString,
+  getCols: getCols,
+  getHookStateSymbol: getHookStateSymbol,
+  getStateString: getStateString,
+  getStateSymbol: getStateSymbol,
+  hookSpinnerMap: hookSpinnerMap,
+  pending: pending,
+  pointer: pointer,
+  renderSnapshotSummary: renderSnapshotSummary,
+  skipped: skipped,
+  spinnerFrames: spinnerFrames,
+  spinnerMap: spinnerMap,
+  suiteFail: suiteFail,
+  taskFail: taskFail,
+  testPass: testPass,
+  withLabel: withLabel
+});
+
+export { F_POINTER as F, formatTimeString as a, F_RIGHT as b, F_CHECK as c, divider as d, getStateString as e, formatProjectName as f, getStateSymbol as g, countTestErrors as h, getCols as i, getHookStateSymbol as j, renderSnapshotSummary as r, taskFail as t, utils as u, withLabel as w };

pwa/node_modules/vitest/dist/chunks/vite.CzKp4x9w.d.ts

@@ -0,0 +1,11 @@
+import { I as InlineConfig } from './reporters.nr4dxCkA.js';
+
+type VitestInlineConfig = InlineConfig;
+declare module 'vite' {
+    interface UserConfig {
+        /**
+         * Options for Vitest
+         */
+        test?: VitestInlineConfig;
+    }
+}

pwa/node_modules/vitest/dist/chunks/vm.Zr4qWzDJ.js

@@ -0,0 +1,841 @@
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import vm, { isContext } from 'node:vm';
+import { dirname, basename, extname, normalize, join, resolve } from 'pathe';
+import { distDir } from '../path.js';
+import { createCustomConsole } from './console.BYGVloWk.js';
+import { g as getDefaultRequestStubs, s as startVitestExecutor } from './execute.2pr0rHgK.js';
+import fs from 'node:fs';
+import { dirname as dirname$1 } from 'node:path';
+import { isNodeBuiltin, isPrimitive, toArray, getCachedData, setCacheData } from 'vite-node/utils';
+import { createRequire, Module } from 'node:module';
+import { CSS_LANGS_RE, KNOWN_ASSET_RE } from 'vite-node/constants';
+import { p as provideWorkerState } from './utils.C8RiOc4B.js';
+
+const _require = createRequire(import.meta.url);
+const requiresCache = /* @__PURE__ */ new WeakMap();
+class CommonjsExecutor {
+  context;
+  requireCache = /* @__PURE__ */ new Map();
+  publicRequireCache = this.createProxyCache();
+  moduleCache = /* @__PURE__ */ new Map();
+  builtinCache = /* @__PURE__ */ Object.create(null);
+  extensions = /* @__PURE__ */ Object.create(null);
+  fs;
+  Module;
+  constructor(options) {
+    this.context = options.context;
+    this.fs = options.fileMap;
+    const primitives = vm.runInContext(
+      "({ Object, Array, Error })",
+      this.context
+    );
+    const executor = this;
+    this.Module = class Module$1 {
+      exports;
+      isPreloading = false;
+      id;
+      filename;
+      loaded;
+      parent;
+      children = [];
+      path;
+      paths = [];
+      constructor(id = "", parent) {
+        this.exports = primitives.Object.create(Object.prototype);
+        this.path = dirname(id);
+        this.id = id;
+        this.filename = id;
+        this.loaded = false;
+        this.parent = parent;
+      }
+      get require() {
+        const require = requiresCache.get(this);
+        if (require) {
+          return require;
+        }
+        const _require2 = Module$1.createRequire(this.id);
+        requiresCache.set(this, _require2);
+        return _require2;
+      }
+      static register = () => {
+        throw new Error(
+          `[vitest] "register" is not available when running in Vitest.`
+        );
+      };
+      _compile(code, filename) {
+        const cjsModule = Module$1.wrap(code);
+        const script = new vm.Script(cjsModule, {
+          filename,
+          importModuleDynamically: options.importModuleDynamically
+        });
+        script.identifier = filename;
+        const fn = script.runInContext(executor.context);
+        const __dirname = dirname(filename);
+        executor.requireCache.set(filename, this);
+        try {
+          fn(this.exports, this.require, this, filename, __dirname);
+          return this.exports;
+        } finally {
+          this.loaded = true;
+        }
+      }
+      // exposed for external use, Node.js does the opposite
+      static _load = (request, parent, _isMain) => {
+        const require = Module$1.createRequire(parent?.filename ?? request);
+        return require(request);
+      };
+      static wrap = (script) => {
+        return Module$1.wrapper[0] + script + Module$1.wrapper[1];
+      };
+      static wrapper = new primitives.Array(
+        "(function (exports, require, module, __filename, __dirname) { ",
+        "\n});"
+      );
+      static builtinModules = Module.builtinModules;
+      static findSourceMap = Module.findSourceMap;
+      static SourceMap = Module.SourceMap;
+      static syncBuiltinESMExports = Module.syncBuiltinESMExports;
+      static _cache = executor.moduleCache;
+      static _extensions = executor.extensions;
+      static createRequire = (filename) => {
+        return executor.createRequire(filename);
+      };
+      static runMain = () => {
+        throw new primitives.Error('[vitest] "runMain" is not implemented.');
+      };
+      // @ts-expect-error not typed
+      static _resolveFilename = Module._resolveFilename;
+      // @ts-expect-error not typed
+      static _findPath = Module._findPath;
+      // @ts-expect-error not typed
+      static _initPaths = Module._initPaths;
+      // @ts-expect-error not typed
+      static _preloadModules = Module._preloadModules;
+      // @ts-expect-error not typed
+      static _resolveLookupPaths = Module._resolveLookupPaths;
+      // @ts-expect-error not typed
+      static globalPaths = Module.globalPaths;
+      static isBuiltin = Module.isBuiltin;
+      static constants = Module.constants;
+      static enableCompileCache = Module.enableCompileCache;
+      static getCompileCacheDir = Module.getCompileCacheDir;
+      static Module = Module$1;
+    };
+    this.extensions[".js"] = this.requireJs;
+    this.extensions[".json"] = this.requireJson;
+  }
+  requireJs = (m, filename) => {
+    const content = this.fs.readFile(filename);
+    m._compile(content, filename);
+  };
+  requireJson = (m, filename) => {
+    const code = this.fs.readFile(filename);
+    m.exports = JSON.parse(code);
+  };
+  createRequire = (filename) => {
+    const _require2 = createRequire(filename);
+    const require = (id) => {
+      const resolved = _require2.resolve(id);
+      const ext = extname(resolved);
+      if (ext === ".node" || isNodeBuiltin(resolved)) {
+        return this.requireCoreModule(resolved);
+      }
+      const module = new this.Module(resolved);
+      return this.loadCommonJSModule(module, resolved);
+    };
+    require.resolve = _require2.resolve;
+    Object.defineProperty(require, "extensions", {
+      get: () => this.extensions,
+      set: () => {
+      },
+      configurable: true
+    });
+    require.main = void 0;
+    require.cache = this.publicRequireCache;
+    return require;
+  };
+  createProxyCache() {
+    return new Proxy(/* @__PURE__ */ Object.create(null), {
+      defineProperty: () => true,
+      deleteProperty: () => true,
+      set: () => true,
+      get: (_, key) => this.requireCache.get(key),
+      has: (_, key) => this.requireCache.has(key),
+      ownKeys: () => Array.from(this.requireCache.keys()),
+      getOwnPropertyDescriptor() {
+        return {
+          configurable: true,
+          enumerable: true
+        };
+      }
+    });
+  }
+  // very naive implementation for Node.js require
+  loadCommonJSModule(module, filename) {
+    const cached = this.requireCache.get(filename);
+    if (cached) {
+      return cached.exports;
+    }
+    const extension = this.findLongestRegisteredExtension(filename);
+    const loader = this.extensions[extension] || this.extensions[".js"];
+    loader(module, filename);
+    return module.exports;
+  }
+  findLongestRegisteredExtension(filename) {
+    const name = basename(filename);
+    let currentExtension;
+    let index;
+    let startIndex = 0;
+    while ((index = name.indexOf(".", startIndex)) !== -1) {
+      startIndex = index + 1;
+      if (index === 0) {
+        continue;
+      }
+      currentExtension = name.slice(index);
+      if (this.extensions[currentExtension]) {
+        return currentExtension;
+      }
+    }
+    return ".js";
+  }
+  require(identifier) {
+    const ext = extname(identifier);
+    if (ext === ".node" || isNodeBuiltin(identifier)) {
+      return this.requireCoreModule(identifier);
+    }
+    const module = new this.Module(identifier);
+    return this.loadCommonJSModule(module, identifier);
+  }
+  requireCoreModule(identifier) {
+    const normalized = identifier.replace(/^node:/, "");
+    if (this.builtinCache[normalized]) {
+      return this.builtinCache[normalized].exports;
+    }
+    const moduleExports = _require(identifier);
+    if (identifier === "node:module" || identifier === "module") {
+      const module = new this.Module("/module.js");
+      module.exports = this.Module;
+      this.builtinCache[normalized] = module;
+      return module.exports;
+    }
+    this.builtinCache[normalized] = _require.cache[normalized];
+    return moduleExports;
+  }
+}
+
+function interopCommonJsModule(interopDefault, mod) {
+  if (isPrimitive(mod) || Array.isArray(mod) || mod instanceof Promise) {
+    return {
+      keys: [],
+      moduleExports: {},
+      defaultExport: mod
+    };
+  }
+  if (interopDefault !== false && "__esModule" in mod && !isPrimitive(mod.default)) {
+    const defaultKets = Object.keys(mod.default);
+    const moduleKeys = Object.keys(mod);
+    const allKeys = /* @__PURE__ */ new Set([...defaultKets, ...moduleKeys]);
+    allKeys.delete("default");
+    return {
+      keys: Array.from(allKeys),
+      moduleExports: new Proxy(mod, {
+        get(mod2, prop) {
+          return mod2[prop] ?? mod2.default?.[prop];
+        }
+      }),
+      defaultExport: mod
+    };
+  }
+  return {
+    keys: Object.keys(mod).filter((key) => key !== "default"),
+    moduleExports: mod,
+    defaultExport: mod
+  };
+}
+const SyntheticModule$1 = vm.SyntheticModule;
+const SourceTextModule = vm.SourceTextModule;
+
+const dataURIRegex = /^data:(?<mime>text\/javascript|application\/json|application\/wasm)(?:;(?<encoding>charset=utf-8|base64))?,(?<code>.*)$/;
+class EsmExecutor {
+  constructor(executor, options) {
+    this.executor = executor;
+    this.context = options.context;
+  }
+  moduleCache = /* @__PURE__ */ new Map();
+  esmLinkMap = /* @__PURE__ */ new WeakMap();
+  context;
+  #httpIp = IPnumber("127.0.0.0");
+  async evaluateModule(m) {
+    if (m.status === "unlinked") {
+      this.esmLinkMap.set(
+        m,
+        m.link(
+          (identifier, referencer) => this.executor.resolveModule(identifier, referencer.identifier)
+        )
+      );
+    }
+    await this.esmLinkMap.get(m);
+    if (m.status === "linked") {
+      await m.evaluate();
+    }
+    return m;
+  }
+  async createEsModule(fileURL, getCode) {
+    const cached = this.moduleCache.get(fileURL);
+    if (cached) {
+      return cached;
+    }
+    const promise = this.loadEsModule(fileURL, getCode);
+    this.moduleCache.set(fileURL, promise);
+    return promise;
+  }
+  async loadEsModule(fileURL, getCode) {
+    const code = await getCode();
+    if (fileURL.endsWith(".json")) {
+      const m2 = new SyntheticModule$1(["default"], () => {
+        const result = JSON.parse(code);
+        m2.setExport("default", result);
+      });
+      this.moduleCache.set(fileURL, m2);
+      return m2;
+    }
+    const m = new SourceTextModule(code, {
+      identifier: fileURL,
+      context: this.context,
+      importModuleDynamically: this.executor.importModuleDynamically,
+      initializeImportMeta: (meta, mod) => {
+        meta.url = mod.identifier;
+        if (mod.identifier.startsWith("file:")) {
+          const filename = fileURLToPath(mod.identifier);
+          meta.filename = filename;
+          meta.dirname = dirname$1(filename);
+        }
+        meta.resolve = (specifier, importer) => {
+          return this.executor.resolve(
+            specifier,
+            importer != null ? importer.toString() : mod.identifier
+          );
+        };
+      }
+    });
+    this.moduleCache.set(fileURL, m);
+    return m;
+  }
+  async createWebAssemblyModule(fileUrl, getCode) {
+    const cached = this.moduleCache.get(fileUrl);
+    if (cached) {
+      return cached;
+    }
+    const m = this.loadWebAssemblyModule(getCode(), fileUrl);
+    this.moduleCache.set(fileUrl, m);
+    return m;
+  }
+  async createNetworkModule(fileUrl) {
+    if (fileUrl.startsWith("http:")) {
+      const url = new URL(fileUrl);
+      if (url.hostname !== "localhost" && url.hostname !== "::1" && (IPnumber(url.hostname) & IPmask(8)) !== this.#httpIp) {
+        throw new Error(
+          // we don't know the importer, so it's undefined (the same happens in --pool=threads)
+          `import of '${fileUrl}' by undefined is not supported: http can only be used to load local resources (use https instead).`
+        );
+      }
+    }
+    return this.createEsModule(fileUrl, () => fetch(fileUrl).then((r) => r.text()));
+  }
+  async loadWebAssemblyModule(source, identifier) {
+    const cached = this.moduleCache.get(identifier);
+    if (cached) {
+      return cached;
+    }
+    const wasmModule = await WebAssembly.compile(source);
+    const exports = WebAssembly.Module.exports(wasmModule);
+    const imports = WebAssembly.Module.imports(wasmModule);
+    const moduleLookup = {};
+    for (const { module } of imports) {
+      if (moduleLookup[module] === void 0) {
+        moduleLookup[module] = await this.executor.resolveModule(
+          module,
+          identifier
+        );
+      }
+    }
+    const syntheticModule = new SyntheticModule$1(
+      exports.map(({ name }) => name),
+      async () => {
+        const importsObject = {};
+        for (const { module, name } of imports) {
+          if (!importsObject[module]) {
+            importsObject[module] = {};
+          }
+          await this.evaluateModule(moduleLookup[module]);
+          importsObject[module][name] = moduleLookup[module].namespace[name];
+        }
+        const wasmInstance = new WebAssembly.Instance(
+          wasmModule,
+          importsObject
+        );
+        for (const { name } of exports) {
+          syntheticModule.setExport(name, wasmInstance.exports[name]);
+        }
+      },
+      { context: this.context, identifier }
+    );
+    return syntheticModule;
+  }
+  cacheModule(identifier, module) {
+    this.moduleCache.set(identifier, module);
+  }
+  resolveCachedModule(identifier) {
+    return this.moduleCache.get(identifier);
+  }
+  async createDataModule(identifier) {
+    const cached = this.moduleCache.get(identifier);
+    if (cached) {
+      return cached;
+    }
+    const match = identifier.match(dataURIRegex);
+    if (!match || !match.groups) {
+      throw new Error("Invalid data URI");
+    }
+    const mime = match.groups.mime;
+    const encoding = match.groups.encoding;
+    if (mime === "application/wasm") {
+      if (!encoding) {
+        throw new Error("Missing data URI encoding");
+      }
+      if (encoding !== "base64") {
+        throw new Error(`Invalid data URI encoding: ${encoding}`);
+      }
+      const module = this.loadWebAssemblyModule(
+        Buffer.from(match.groups.code, "base64"),
+        identifier
+      );
+      this.moduleCache.set(identifier, module);
+      return module;
+    }
+    let code = match.groups.code;
+    if (!encoding || encoding === "charset=utf-8") {
+      code = decodeURIComponent(code);
+    } else if (encoding === "base64") {
+      code = Buffer.from(code, "base64").toString();
+    } else {
+      throw new Error(`Invalid data URI encoding: ${encoding}`);
+    }
+    if (mime === "application/json") {
+      const module = new SyntheticModule$1(
+        ["default"],
+        () => {
+          const obj = JSON.parse(code);
+          module.setExport("default", obj);
+        },
+        { context: this.context, identifier }
+      );
+      this.moduleCache.set(identifier, module);
+      return module;
+    }
+    return this.createEsModule(identifier, () => code);
+  }
+}
+function IPnumber(address) {
+  const ip = address.match(/^(\d+)\.(\d+)\.(\d+)\.(\d+)$/);
+  if (ip) {
+    return (+ip[1] << 24) + (+ip[2] << 16) + (+ip[3] << 8) + +ip[4];
+  }
+  throw new Error(`Expected IP address, received ${address}`);
+}
+function IPmask(maskSize) {
+  return -1 << 32 - maskSize;
+}
+
+const CLIENT_ID = "/@vite/client";
+const CLIENT_FILE = pathToFileURL(CLIENT_ID).href;
+class ViteExecutor {
+  constructor(options) {
+    this.options = options;
+    this.esm = options.esmExecutor;
+  }
+  esm;
+  resolve = (identifier, parent) => {
+    if (identifier === CLIENT_ID) {
+      if (this.workerState.environment.transformMode === "web") {
+        return identifier;
+      }
+      const packageName = this.getPackageName(parent);
+      throw new Error(
+        `[vitest] Vitest cannot handle ${CLIENT_ID} imported in ${parent} when running in SSR environment. Add "${packageName}" to "ssr.noExternal" if you are using Vite SSR, or to "server.deps.inline" if you are using Vite Node.`
+      );
+    }
+  };
+  get workerState() {
+    return this.options.context.__vitest_worker__;
+  }
+  getPackageName(modulePath) {
+    const path = normalize(modulePath);
+    let name = path.split("/node_modules/").pop() || "";
+    if (name?.startsWith("@")) {
+      name = name.split("/").slice(0, 2).join("/");
+    } else {
+      name = name.split("/")[0];
+    }
+    return name;
+  }
+  async createViteModule(fileUrl) {
+    if (fileUrl === CLIENT_FILE) {
+      return this.createViteClientModule();
+    }
+    const cached = this.esm.resolveCachedModule(fileUrl);
+    if (cached) {
+      return cached;
+    }
+    return this.esm.createEsModule(fileUrl, async () => {
+      const result = await this.options.transform(fileUrl, "web");
+      if (!result.code) {
+        throw new Error(
+          `[vitest] Failed to transform ${fileUrl}. Does the file exist?`
+        );
+      }
+      return result.code;
+    });
+  }
+  createViteClientModule() {
+    const identifier = CLIENT_ID;
+    const cached = this.esm.resolveCachedModule(identifier);
+    if (cached) {
+      return cached;
+    }
+    const stub = this.options.viteClientModule;
+    const moduleKeys = Object.keys(stub);
+    const module = new SyntheticModule$1(
+      moduleKeys,
+      () => {
+        moduleKeys.forEach((key) => {
+          module.setExport(key, stub[key]);
+        });
+      },
+      { context: this.options.context, identifier }
+    );
+    this.esm.cacheModule(identifier, module);
+    return module;
+  }
+  canResolve = (fileUrl) => {
+    const transformMode = this.workerState.environment.transformMode;
+    if (transformMode !== "web") {
+      return false;
+    }
+    if (fileUrl === CLIENT_FILE) {
+      return true;
+    }
+    const config = this.workerState.config.deps?.web || {};
+    const [modulePath] = fileUrl.split("?");
+    if (config.transformCss && CSS_LANGS_RE.test(modulePath)) {
+      return true;
+    }
+    if (config.transformAssets && KNOWN_ASSET_RE.test(modulePath)) {
+      return true;
+    }
+    if (toArray(config.transformGlobPattern).some(
+      (pattern) => pattern.test(modulePath)
+    )) {
+      return true;
+    }
+    return false;
+  };
+}
+
+const SyntheticModule = vm.SyntheticModule;
+const { existsSync, statSync } = fs;
+const nativeResolve = import.meta.resolve;
+class ExternalModulesExecutor {
+  constructor(options) {
+    this.options = options;
+    this.context = options.context;
+    this.fs = options.fileMap;
+    this.esm = new EsmExecutor(this, {
+      context: this.context
+    });
+    this.cjs = new CommonjsExecutor({
+      context: this.context,
+      importModuleDynamically: this.importModuleDynamically,
+      fileMap: options.fileMap
+    });
+    this.vite = new ViteExecutor({
+      esmExecutor: this.esm,
+      context: this.context,
+      transform: options.transform,
+      viteClientModule: options.viteClientModule
+    });
+    this.resolvers = [this.vite.resolve];
+  }
+  cjs;
+  esm;
+  vite;
+  context;
+  fs;
+  resolvers = [];
+  #networkSupported = null;
+  async import(identifier) {
+    const module = await this.createModule(identifier);
+    await this.esm.evaluateModule(module);
+    return module.namespace;
+  }
+  require(identifier) {
+    return this.cjs.require(identifier);
+  }
+  createRequire(identifier) {
+    return this.cjs.createRequire(identifier);
+  }
+  // dynamic import can be used in both ESM and CJS, so we have it in the executor
+  importModuleDynamically = async (specifier, referencer) => {
+    const module = await this.resolveModule(specifier, referencer.identifier);
+    return await this.esm.evaluateModule(module);
+  };
+  resolveModule = async (specifier, referencer) => {
+    let identifier = this.resolve(specifier, referencer);
+    if (identifier instanceof Promise) {
+      identifier = await identifier;
+    }
+    return await this.createModule(identifier);
+  };
+  resolve(specifier, parent) {
+    for (const resolver of this.resolvers) {
+      const id = resolver(specifier, parent);
+      if (id) {
+        return id;
+      }
+    }
+    return nativeResolve(specifier, parent);
+  }
+  findNearestPackageData(basedir) {
+    const originalBasedir = basedir;
+    const packageCache = this.options.packageCache;
+    while (basedir) {
+      const cached = getCachedData(packageCache, basedir, originalBasedir);
+      if (cached) {
+        return cached;
+      }
+      const pkgPath = join(basedir, "package.json");
+      try {
+        if (statSync(pkgPath, { throwIfNoEntry: false })?.isFile()) {
+          const pkgData = JSON.parse(this.fs.readFile(pkgPath));
+          if (packageCache) {
+            setCacheData(packageCache, pkgData, basedir, originalBasedir);
+          }
+          return pkgData;
+        }
+      } catch {
+      }
+      const nextBasedir = dirname$1(basedir);
+      if (nextBasedir === basedir) {
+        break;
+      }
+      basedir = nextBasedir;
+    }
+    return {};
+  }
+  wrapCoreSynteticModule(identifier, exports) {
+    const moduleKeys = Object.keys(exports);
+    const m = new SyntheticModule(
+      [...moduleKeys, "default"],
+      () => {
+        for (const key of moduleKeys) {
+          m.setExport(key, exports[key]);
+        }
+        m.setExport("default", exports);
+      },
+      {
+        context: this.context,
+        identifier
+      }
+    );
+    return m;
+  }
+  wrapCommonJsSynteticModule(identifier, exports) {
+    const { keys, moduleExports, defaultExport } = interopCommonJsModule(
+      this.options.interopDefault,
+      exports
+    );
+    const m = new SyntheticModule(
+      [...keys, "default"],
+      () => {
+        for (const key of keys) {
+          m.setExport(key, moduleExports[key]);
+        }
+        m.setExport("default", defaultExport);
+      },
+      {
+        context: this.context,
+        identifier
+      }
+    );
+    return m;
+  }
+  getModuleInformation(identifier) {
+    if (identifier.startsWith("data:")) {
+      return { type: "data", url: identifier, path: identifier };
+    }
+    const extension = extname(identifier);
+    if (extension === ".node" || isNodeBuiltin(identifier)) {
+      return { type: "builtin", url: identifier, path: identifier };
+    }
+    if (this.isNetworkSupported && (identifier.startsWith("http:") || identifier.startsWith("https:"))) {
+      return { type: "network", url: identifier, path: identifier };
+    }
+    const isFileUrl = identifier.startsWith("file://");
+    const pathUrl = isFileUrl ? fileURLToPath(identifier.split("?")[0]) : identifier;
+    const fileUrl = isFileUrl ? identifier : pathToFileURL(pathUrl).toString();
+    let type;
+    if (this.vite.canResolve(fileUrl)) {
+      type = "vite";
+    } else if (extension === ".mjs") {
+      type = "module";
+    } else if (extension === ".cjs") {
+      type = "commonjs";
+    } else if (extension === ".wasm") {
+      type = "wasm";
+    } else {
+      const pkgData = this.findNearestPackageData(normalize(pathUrl));
+      type = pkgData.type === "module" ? "module" : "commonjs";
+    }
+    return { type, path: pathUrl, url: fileUrl };
+  }
+  async createModule(identifier) {
+    const { type, url, path } = this.getModuleInformation(identifier);
+    if ((type === "module" || type === "commonjs" || type === "wasm") && !existsSync(path)) {
+      const error = new Error(`Cannot find module '${path}'`);
+      error.code = "ERR_MODULE_NOT_FOUND";
+      throw error;
+    }
+    switch (type) {
+      case "data":
+        return await this.esm.createDataModule(identifier);
+      case "builtin": {
+        const exports = this.require(identifier);
+        return this.wrapCoreSynteticModule(identifier, exports);
+      }
+      case "vite":
+        return await this.vite.createViteModule(url);
+      case "wasm":
+        return await this.esm.createWebAssemblyModule(url, () => this.fs.readBuffer(path));
+      case "module":
+        return await this.esm.createEsModule(url, () => this.fs.readFileAsync(path));
+      case "commonjs": {
+        const exports = this.require(path);
+        return this.wrapCommonJsSynteticModule(identifier, exports);
+      }
+      case "network":
+        return await this.esm.createNetworkModule(url);
+      default: {
+        const _deadend = type;
+        return _deadend;
+      }
+    }
+  }
+  get isNetworkSupported() {
+    if (this.#networkSupported == null) {
+      if (process.execArgv.includes("--experimental-network-imports")) {
+        this.#networkSupported = true;
+      } else if (process.env.NODE_OPTIONS?.includes("--experimental-network-imports")) {
+        this.#networkSupported = true;
+      } else {
+        this.#networkSupported = false;
+      }
+    }
+    return this.#networkSupported;
+  }
+}
+
+const { promises, readFileSync } = fs;
+class FileMap {
+  fsCache = /* @__PURE__ */ new Map();
+  fsBufferCache = /* @__PURE__ */ new Map();
+  async readFileAsync(path) {
+    const cached = this.fsCache.get(path);
+    if (cached != null) {
+      return cached;
+    }
+    const source = await promises.readFile(path, "utf-8");
+    this.fsCache.set(path, source);
+    return source;
+  }
+  readFile(path) {
+    const cached = this.fsCache.get(path);
+    if (cached != null) {
+      return cached;
+    }
+    const source = readFileSync(path, "utf-8");
+    this.fsCache.set(path, source);
+    return source;
+  }
+  readBuffer(path) {
+    const cached = this.fsBufferCache.get(path);
+    if (cached != null) {
+      return cached;
+    }
+    const buffer = readFileSync(path);
+    this.fsBufferCache.set(path, buffer);
+    return buffer;
+  }
+}
+
+const entryFile = pathToFileURL(resolve(distDir, "workers/runVmTests.js")).href;
+const fileMap = new FileMap();
+const packageCache = /* @__PURE__ */ new Map();
+async function runVmTests(method, state) {
+  const { environment, ctx, rpc } = state;
+  if (!environment.setupVM) {
+    const envName = ctx.environment.name;
+    const packageId = envName[0] === "." ? envName : `vitest-environment-${envName}`;
+    throw new TypeError(
+      `Environment "${ctx.environment.name}" is not a valid environment. Path "${packageId}" doesn't support vm environment because it doesn't provide "setupVM" method.`
+    );
+  }
+  const vm = await environment.setupVM(
+    ctx.environment.options || ctx.config.environmentOptions || {}
+  );
+  state.durations.environment = performance.now() - state.durations.environment;
+  process.env.VITEST_VM_POOL = "1";
+  if (!vm.getVmContext) {
+    throw new TypeError(
+      `Environment ${environment.name} doesn't provide "getVmContext" method. It should return a context created by "vm.createContext" method.`
+    );
+  }
+  const context = vm.getVmContext();
+  if (!isContext(context)) {
+    throw new TypeError(
+      `Environment ${environment.name} doesn't provide a valid context. It should be created by "vm.createContext" method.`
+    );
+  }
+  provideWorkerState(context, state);
+  context.process = process;
+  context.global = context;
+  context.console = state.config.disableConsoleIntercept ? console : createCustomConsole(state);
+  context.setImmediate = setImmediate;
+  context.clearImmediate = clearImmediate;
+  const stubs = getDefaultRequestStubs(context);
+  const externalModulesExecutor = new ExternalModulesExecutor({
+    context,
+    fileMap,
+    packageCache,
+    transform: rpc.transform,
+    viteClientModule: stubs["/@vite/client"]
+  });
+  const executor = await startVitestExecutor({
+    context,
+    moduleCache: state.moduleCache,
+    state,
+    externalModulesExecutor,
+    requestStubs: stubs
+  });
+  context.__vitest_mocker__ = executor.mocker;
+  const { run } = await executor.importExternalModule(
+    entryFile
+  );
+  try {
+    await run(method, ctx.files, ctx.config, executor);
+  } finally {
+    await vm.teardown?.();
+    state.environmentTeardownRun = true;
+  }
+}
+
+export { runVmTests as r };

pwa/node_modules/vitest/dist/chunks/worker.B9FxPCaC.d.ts

@@ -0,0 +1,8 @@
+import { MessagePort } from 'node:worker_threads';
+import { C as ContextRPC } from './worker.tN5KGIih.js';
+
+interface WorkerContext extends ContextRPC {
+    port: MessagePort;
+}
+
+export type { WorkerContext as W };

pwa/node_modules/vitest/dist/chunks/worker.tN5KGIih.d.ts

@@ -0,0 +1,156 @@
+import { File, TaskResultPack, CancelReason, Task } from '@vitest/runner';
+import { ViteNodeResolveId, ModuleCacheMap } from 'vite-node';
+import { S as SerializedConfig } from './config.Cy0C388Z.js';
+import { T as TransformMode, U as UserConsoleLog, A as AfterSuiteRunMeta, E as Environment } from './environment.LoooBwUu.js';
+import { SnapshotResult } from '@vitest/snapshot';
+
+type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never;
+type ReturnType<T> = T extends (...args: any) => infer R ? R : never;
+type PromisifyFn<T> = ReturnType<T> extends Promise<any> ? T : (...args: ArgumentsType<T>) => Promise<Awaited<ReturnType<T>>>;
+type BirpcResolver = (name: string, resolved: (...args: unknown[]) => unknown) => ((...args: unknown[]) => unknown) | undefined;
+interface ChannelOptions {
+    /**
+     * Function to post raw message
+     */
+    post: (data: any, ...extras: any[]) => any | Promise<any>;
+    /**
+     * Listener to receive raw message
+     */
+    on: (fn: (data: any, ...extras: any[]) => void) => any | Promise<any>;
+    /**
+     * Clear the listener when `$close` is called
+     */
+    off?: (fn: (data: any, ...extras: any[]) => void) => any | Promise<any>;
+    /**
+     * Custom function to serialize data
+     *
+     * by default it passes the data as-is
+     */
+    serialize?: (data: any) => any;
+    /**
+     * Custom function to deserialize data
+     *
+     * by default it passes the data as-is
+     */
+    deserialize?: (data: any) => any;
+    /**
+     * Call the methods with the RPC context or the original functions object
+     */
+    bind?: 'rpc' | 'functions';
+}
+interface EventOptions<Remote> {
+    /**
+     * Names of remote functions that do not need response.
+     */
+    eventNames?: (keyof Remote)[];
+    /**
+     * Maximum timeout for waiting for response, in milliseconds.
+     *
+     * @default 60_000
+     */
+    timeout?: number;
+    /**
+     * Custom resolver to resolve function to be called
+     *
+     * For advanced use cases only
+     */
+    resolver?: BirpcResolver;
+    /**
+     * Custom error handler
+     */
+    onError?: (error: Error, functionName: string, args: any[]) => boolean | void;
+    /**
+     * Custom error handler for timeouts
+     */
+    onTimeoutError?: (functionName: string, args: any[]) => boolean | void;
+}
+type BirpcOptions<Remote> = EventOptions<Remote> & ChannelOptions;
+type BirpcFn<T> = PromisifyFn<T> & {
+    /**
+     * Send event without asking for response
+     */
+    asEvent: (...args: ArgumentsType<T>) => void;
+};
+type BirpcReturn<RemoteFunctions, LocalFunctions = Record<string, never>> = {
+    [K in keyof RemoteFunctions]: BirpcFn<RemoteFunctions[K]>;
+} & {
+    $functions: LocalFunctions;
+    $close: () => void;
+};
+
+interface RuntimeRPC {
+    fetch: (id: string, transformMode: TransformMode) => Promise<{
+        externalize?: string;
+        id?: string;
+    }>;
+    transform: (id: string, transformMode: TransformMode) => Promise<{
+        code?: string;
+    }>;
+    resolveId: (id: string, importer: string | undefined, transformMode: TransformMode) => Promise<{
+        external?: boolean | 'absolute' | 'relative';
+        id: string;
+        /** @deprecated */
+        meta?: Record<string, any> | null;
+        /** @deprecated */
+        moduleSideEffects?: boolean | 'no-treeshake' | null;
+        /** @deprecated */
+        syntheticNamedExports?: boolean | string | null;
+    } | null>;
+    /**
+     * @deprecated unused
+     */
+    getSourceMap: (id: string, force?: boolean) => Promise<any>;
+    onFinished: (files: File[], errors?: unknown[]) => void;
+    onPathsCollected: (paths: string[]) => void;
+    onUserConsoleLog: (log: UserConsoleLog) => void;
+    onUnhandledError: (err: unknown, type: string) => void;
+    onCollected: (files: File[]) => Promise<void>;
+    onAfterSuiteRun: (meta: AfterSuiteRunMeta) => void;
+    onTaskUpdate: (pack: TaskResultPack[]) => Promise<void>;
+    onCancel: (reason: CancelReason) => void;
+    getCountOfFailedTests: () => number;
+    snapshotSaved: (snapshot: SnapshotResult) => void;
+    resolveSnapshotPath: (testPath: string) => string;
+}
+interface RunnerRPC {
+    onCancel: (reason: CancelReason) => void;
+}
+
+/** @deprecated unused */
+type ResolveIdFunction = (id: string, importer?: string) => Promise<ViteNodeResolveId | null>;
+type WorkerRPC = BirpcReturn<RuntimeRPC, RunnerRPC>;
+interface ContextTestEnvironment {
+    name: string;
+    transformMode?: TransformMode;
+    options: Record<string, any> | null;
+}
+interface ContextRPC {
+    pool: string;
+    worker: string;
+    workerId: number;
+    config: SerializedConfig;
+    projectName: string;
+    files: string[];
+    environment: ContextTestEnvironment;
+    providedContext: Record<string, any>;
+    invalidates?: string[];
+}
+interface WorkerGlobalState {
+    ctx: ContextRPC;
+    config: SerializedConfig;
+    rpc: WorkerRPC;
+    current?: Task;
+    filepath?: string;
+    environment: Environment;
+    environmentTeardownRun?: boolean;
+    onCancel: Promise<CancelReason>;
+    moduleCache: ModuleCacheMap;
+    providedContext: Record<string, any>;
+    durations: {
+        environment: number;
+        prepare: number;
+    };
+    onFilterStackTrace?: (trace: string) => string;
+}
+
+export type { BirpcOptions as B, ContextRPC as C, RuntimeRPC as R, WorkerGlobalState as W, BirpcReturn as a, WorkerRPC as b, RunnerRPC as c, ContextTestEnvironment as d, ResolveIdFunction as e };

pwa/node_modules/vitest/dist/cli.js

@@ -0,0 +1,8 @@
+import { c as createCLI } from './chunks/cac.CB_9Zo9Q.js';
+import '@vitest/utils';
+import 'events';
+import 'pathe';
+import 'tinyrainbow';
+import './chunks/constants.fzPh7AOq.js';
+
+createCLI().parse();

pwa/node_modules/vitest/dist/config.cjs

@@ -0,0 +1,158 @@
+'use strict';
+
+var os = require('node:os');
+var stdEnv = require('std-env');
+var vite = require('vite');
+
+const defaultBrowserPort = 63315;
+const extraInlineDeps = [
+  /^(?!.*node_modules).*\.mjs$/,
+  /^(?!.*node_modules).*\.cjs\.js$/,
+  // Vite client
+  /vite\w*\/dist\/client\/env.mjs/
+];
+
+const isNode = typeof process < "u" && typeof process.stdout < "u" && !process.versions?.deno && !globalThis.window;
+const isDeno = typeof process < "u" && typeof process.stdout < "u" && process.versions?.deno !== void 0;
+(isNode || isDeno) && process.platform === "win32";
+
+const defaultInclude = ["**/*.{test,spec}.?(c|m)[jt]s?(x)"];
+const defaultExclude = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/cypress/**",
+  "**/.{idea,git,cache,output,temp}/**",
+  "**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*"
+];
+const defaultCoverageExcludes = [
+  "coverage/**",
+  "dist/**",
+  "**/node_modules/**",
+  "**/[.]**",
+  "packages/*/test?(s)/**",
+  "**/*.d.ts",
+  "**/virtual:*",
+  "**/__x00__*",
+  "**/\0*",
+  "cypress/**",
+  "test?(s)/**",
+  "test?(-*).?(c|m)[jt]s?(x)",
+  "**/*{.,-}{test,spec,bench,benchmark}?(-d).?(c|m)[jt]s?(x)",
+  "**/__tests__/**",
+  "**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*",
+  "**/vitest.{workspace,projects}.[jt]s?(on)",
+  "**/.{eslint,mocha,prettier}rc.{?(c|m)js,yml}"
+];
+const coverageConfigDefaults = {
+  provider: "v8",
+  enabled: false,
+  all: true,
+  clean: true,
+  cleanOnRerun: true,
+  reportsDirectory: "./coverage",
+  exclude: defaultCoverageExcludes,
+  reportOnFailure: false,
+  reporter: [
+    ["text", {}],
+    ["html", {}],
+    ["clover", {}],
+    ["json", {}]
+  ],
+  extension: [
+    ".js",
+    ".cjs",
+    ".mjs",
+    ".ts",
+    ".mts",
+    ".tsx",
+    ".jsx",
+    ".vue",
+    ".svelte",
+    ".marko",
+    ".astro"
+  ],
+  allowExternal: false,
+  excludeAfterRemap: false,
+  ignoreEmptyLines: true,
+  processingConcurrency: Math.min(
+    20,
+    os.availableParallelism?.() ?? os.cpus().length
+  )
+};
+const fakeTimersDefaults = {
+  loopLimit: 1e4,
+  shouldClearNativeTimers: true,
+  toFake: [
+    "setTimeout",
+    "clearTimeout",
+    "setInterval",
+    "clearInterval",
+    "setImmediate",
+    "clearImmediate",
+    "Date"
+  ]
+};
+const config = {
+  allowOnly: !stdEnv.isCI,
+  isolate: true,
+  watch: !stdEnv.isCI,
+  globals: false,
+  environment: "node",
+  pool: "forks",
+  clearMocks: false,
+  restoreMocks: false,
+  mockReset: false,
+  unstubGlobals: false,
+  unstubEnvs: false,
+  include: defaultInclude,
+  exclude: defaultExclude,
+  teardownTimeout: 1e4,
+  forceRerunTriggers: ["**/package.json/**", "**/{vitest,vite}.config.*/**"],
+  update: false,
+  reporters: [],
+  silent: false,
+  hideSkippedTests: false,
+  api: false,
+  ui: false,
+  uiBase: "/__vitest__/",
+  open: !stdEnv.isCI,
+  css: {
+    include: []
+  },
+  coverage: coverageConfigDefaults,
+  fakeTimers: fakeTimersDefaults,
+  maxConcurrency: 5,
+  dangerouslyIgnoreUnhandledErrors: false,
+  typecheck: {
+    checker: "tsc",
+    include: ["**/*.{test,spec}-d.?(c|m)[jt]s?(x)"],
+    exclude: defaultExclude
+  },
+  slowTestThreshold: 300,
+  disableConsoleIntercept: false
+};
+const configDefaults = Object.freeze(config);
+
+function defineConfig(config) {
+  return config;
+}
+function defineProject(config) {
+  return config;
+}
+function defineWorkspace(config) {
+  return config;
+}
+
+Object.defineProperty(exports, "mergeConfig", {
+  enumerable: true,
+  get: function () { return vite.mergeConfig; }
+});
+exports.configDefaults = configDefaults;
+exports.coverageConfigDefaults = coverageConfigDefaults;
+exports.defaultBrowserPort = defaultBrowserPort;
+exports.defaultExclude = defaultExclude;
+exports.defaultInclude = defaultInclude;
+exports.defineConfig = defineConfig;
+exports.defineProject = defineProject;
+exports.defineWorkspace = defineWorkspace;
+exports.extraInlineDeps = extraInlineDeps;

pwa/node_modules/vitest/dist/config.d.ts

@@ -0,0 +1,93 @@
+import { UserConfig as UserConfig$1, ConfigEnv } from 'vite';
+export { ConfigEnv, Plugin, UserConfig as ViteUserConfig, mergeConfig } from 'vite';
+import { R as ResolvedCoverageOptions, c as CoverageV8Options, U as UserWorkspaceConfig, d as UserProjectConfigFn, e as UserProjectConfigExport, W as WorkspaceProjectConfiguration } from './chunks/reporters.nr4dxCkA.js';
+import './chunks/vite.CzKp4x9w.js';
+import '@vitest/runner';
+import './chunks/environment.LoooBwUu.js';
+import 'node:stream';
+import '@vitest/utils';
+import './chunks/config.Cy0C388Z.js';
+import '@vitest/pretty-format';
+import '@vitest/snapshot';
+import '@vitest/snapshot/environment';
+import 'vite-node';
+import 'chai';
+import '@vitest/utils/source-map';
+import 'vite-node/client';
+import 'vite-node/server';
+import './chunks/benchmark.geERunq4.js';
+import '@vitest/runner/utils';
+import 'tinybench';
+import '@vitest/snapshot/manager';
+import 'node:fs';
+
+declare const defaultBrowserPort = 63315;
+declare const extraInlineDeps: RegExp[];
+
+declare const defaultInclude: string[];
+declare const defaultExclude: string[];
+declare const coverageConfigDefaults: ResolvedCoverageOptions;
+declare const configDefaults: Readonly<{
+    allowOnly: boolean;
+    isolate: true;
+    watch: boolean;
+    globals: false;
+    environment: "node";
+    pool: "forks";
+    clearMocks: false;
+    restoreMocks: false;
+    mockReset: false;
+    unstubGlobals: false;
+    unstubEnvs: false;
+    include: string[];
+    exclude: string[];
+    teardownTimeout: number;
+    forceRerunTriggers: string[];
+    update: false;
+    reporters: never[];
+    silent: false;
+    hideSkippedTests: false;
+    api: false;
+    ui: false;
+    uiBase: string;
+    open: boolean;
+    css: {
+        include: never[];
+    };
+    coverage: CoverageV8Options;
+    fakeTimers: {
+        loopLimit: number;
+        shouldClearNativeTimers: true;
+        toFake: ("setTimeout" | "setInterval" | "clearInterval" | "clearTimeout" | "setImmediate" | "clearImmediate" | "Date")[];
+    };
+    maxConcurrency: number;
+    dangerouslyIgnoreUnhandledErrors: false;
+    typecheck: {
+        checker: "tsc";
+        include: string[];
+        exclude: string[];
+    };
+    slowTestThreshold: number;
+    disableConsoleIntercept: false;
+}>;
+
+/**
+ * @deprecated Use `ViteUserConfig` instead
+ */
+type UserConfig = UserConfig$1;
+
+type UserConfigFnObject = (env: ConfigEnv) => UserConfig$1;
+type UserConfigFnPromise = (env: ConfigEnv) => Promise<UserConfig$1>;
+type UserConfigFn = (env: ConfigEnv) => UserConfig$1 | Promise<UserConfig$1>;
+type UserConfigExport = UserConfig$1 | Promise<UserConfig$1> | UserConfigFnObject | UserConfigFnPromise | UserConfigFn;
+declare function defineConfig(config: UserConfig$1): UserConfig$1;
+declare function defineConfig(config: Promise<UserConfig$1>): Promise<UserConfig$1>;
+declare function defineConfig(config: UserConfigFnObject): UserConfigFnObject;
+declare function defineConfig(config: UserConfigExport): UserConfigExport;
+declare function defineProject(config: UserWorkspaceConfig): UserWorkspaceConfig;
+declare function defineProject(config: Promise<UserWorkspaceConfig>): Promise<UserWorkspaceConfig>;
+declare function defineProject(config: UserProjectConfigFn): UserProjectConfigFn;
+declare function defineProject(config: UserProjectConfigExport): UserProjectConfigExport;
+declare function defineWorkspace(config: WorkspaceProjectConfiguration[]): WorkspaceProjectConfiguration[];
+
+export { type UserConfig, type UserConfigExport, type UserConfigFn, type UserConfigFnObject, type UserConfigFnPromise, UserProjectConfigExport, UserProjectConfigFn, UserWorkspaceConfig, WorkspaceProjectConfiguration, configDefaults, coverageConfigDefaults, defaultBrowserPort, defaultExclude, defaultInclude, defineConfig, defineProject, defineWorkspace, extraInlineDeps };

pwa/node_modules/vitest/dist/config.js

@@ -0,0 +1,144 @@
+import os from 'node:os';
+import { isCI } from 'std-env';
+export { mergeConfig } from 'vite';
+
+const defaultBrowserPort = 63315;
+const extraInlineDeps = [
+  /^(?!.*node_modules).*\.mjs$/,
+  /^(?!.*node_modules).*\.cjs\.js$/,
+  // Vite client
+  /vite\w*\/dist\/client\/env.mjs/
+];
+
+const isNode = typeof process < "u" && typeof process.stdout < "u" && !process.versions?.deno && !globalThis.window;
+const isDeno = typeof process < "u" && typeof process.stdout < "u" && process.versions?.deno !== void 0;
+(isNode || isDeno) && process.platform === "win32";
+
+const defaultInclude = ["**/*.{test,spec}.?(c|m)[jt]s?(x)"];
+const defaultExclude = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/cypress/**",
+  "**/.{idea,git,cache,output,temp}/**",
+  "**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*"
+];
+const defaultCoverageExcludes = [
+  "coverage/**",
+  "dist/**",
+  "**/node_modules/**",
+  "**/[.]**",
+  "packages/*/test?(s)/**",
+  "**/*.d.ts",
+  "**/virtual:*",
+  "**/__x00__*",
+  "**/\0*",
+  "cypress/**",
+  "test?(s)/**",
+  "test?(-*).?(c|m)[jt]s?(x)",
+  "**/*{.,-}{test,spec,bench,benchmark}?(-d).?(c|m)[jt]s?(x)",
+  "**/__tests__/**",
+  "**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*",
+  "**/vitest.{workspace,projects}.[jt]s?(on)",
+  "**/.{eslint,mocha,prettier}rc.{?(c|m)js,yml}"
+];
+const coverageConfigDefaults = {
+  provider: "v8",
+  enabled: false,
+  all: true,
+  clean: true,
+  cleanOnRerun: true,
+  reportsDirectory: "./coverage",
+  exclude: defaultCoverageExcludes,
+  reportOnFailure: false,
+  reporter: [
+    ["text", {}],
+    ["html", {}],
+    ["clover", {}],
+    ["json", {}]
+  ],
+  extension: [
+    ".js",
+    ".cjs",
+    ".mjs",
+    ".ts",
+    ".mts",
+    ".tsx",
+    ".jsx",
+    ".vue",
+    ".svelte",
+    ".marko",
+    ".astro"
+  ],
+  allowExternal: false,
+  excludeAfterRemap: false,
+  ignoreEmptyLines: true,
+  processingConcurrency: Math.min(
+    20,
+    os.availableParallelism?.() ?? os.cpus().length
+  )
+};
+const fakeTimersDefaults = {
+  loopLimit: 1e4,
+  shouldClearNativeTimers: true,
+  toFake: [
+    "setTimeout",
+    "clearTimeout",
+    "setInterval",
+    "clearInterval",
+    "setImmediate",
+    "clearImmediate",
+    "Date"
+  ]
+};
+const config = {
+  allowOnly: !isCI,
+  isolate: true,
+  watch: !isCI,
+  globals: false,
+  environment: "node",
+  pool: "forks",
+  clearMocks: false,
+  restoreMocks: false,
+  mockReset: false,
+  unstubGlobals: false,
+  unstubEnvs: false,
+  include: defaultInclude,
+  exclude: defaultExclude,
+  teardownTimeout: 1e4,
+  forceRerunTriggers: ["**/package.json/**", "**/{vitest,vite}.config.*/**"],
+  update: false,
+  reporters: [],
+  silent: false,
+  hideSkippedTests: false,
+  api: false,
+  ui: false,
+  uiBase: "/__vitest__/",
+  open: !isCI,
+  css: {
+    include: []
+  },
+  coverage: coverageConfigDefaults,
+  fakeTimers: fakeTimersDefaults,
+  maxConcurrency: 5,
+  dangerouslyIgnoreUnhandledErrors: false,
+  typecheck: {
+    checker: "tsc",
+    include: ["**/*.{test,spec}-d.?(c|m)[jt]s?(x)"],
+    exclude: defaultExclude
+  },
+  slowTestThreshold: 300,
+  disableConsoleIntercept: false
+};
+const configDefaults = Object.freeze(config);
+
+function defineConfig(config) {
+  return config;
+}
+function defineProject(config) {
+  return config;
+}
+function defineWorkspace(config) {
+  return config;
+}
+
+export { configDefaults, coverageConfigDefaults, defaultBrowserPort, defaultExclude, defaultInclude, defineConfig, defineProject, defineWorkspace, extraInlineDeps };

pwa/node_modules/vitest/dist/coverage.d.ts

@@ -0,0 +1,207 @@
+import * as vite from 'vite';
+import { R as ResolvedCoverageOptions, V as Vitest, a as ReportContext } from './chunks/reporters.nr4dxCkA.js';
+import { A as AfterSuiteRunMeta } from './chunks/environment.LoooBwUu.js';
+import '@vitest/runner';
+import 'node:stream';
+import '@vitest/utils';
+import './chunks/config.Cy0C388Z.js';
+import '@vitest/pretty-format';
+import '@vitest/snapshot';
+import '@vitest/snapshot/environment';
+import 'vite-node';
+import 'chai';
+import '@vitest/utils/source-map';
+import 'vite-node/client';
+import 'vite-node/server';
+import './chunks/benchmark.geERunq4.js';
+import '@vitest/runner/utils';
+import 'tinybench';
+import '@vitest/snapshot/manager';
+import 'node:fs';
+
+interface CoverageSummaryData {
+    lines: Totals;
+    statements: Totals;
+    branches: Totals;
+    functions: Totals;
+}
+
+declare class CoverageSummary {
+    constructor(data: CoverageSummary | CoverageSummaryData);
+    merge(obj: CoverageSummary): CoverageSummary;
+    toJSON(): CoverageSummaryData;
+    isEmpty(): boolean;
+    data: CoverageSummaryData;
+    lines: Totals;
+    statements: Totals;
+    branches: Totals;
+    functions: Totals;
+}
+
+interface CoverageMapData {
+    [key: string]: FileCoverage | FileCoverageData;
+}
+
+declare class CoverageMap {
+    constructor(data: CoverageMapData | CoverageMap);
+    addFileCoverage(pathOrObject: string | FileCoverage | FileCoverageData): void;
+    files(): string[];
+    fileCoverageFor(filename: string): FileCoverage;
+    filter(callback: (key: string) => boolean): void;
+    getCoverageSummary(): CoverageSummary;
+    merge(data: CoverageMapData | CoverageMap): void;
+    toJSON(): CoverageMapData;
+    data: CoverageMapData;
+}
+
+interface Location {
+    line: number;
+    column: number;
+}
+
+interface Range {
+    start: Location;
+    end: Location;
+}
+
+interface BranchMapping {
+    loc: Range;
+    type: string;
+    locations: Range[];
+    line: number;
+}
+
+interface FunctionMapping {
+    name: string;
+    decl: Range;
+    loc: Range;
+    line: number;
+}
+
+interface FileCoverageData {
+    path: string;
+    statementMap: { [key: string]: Range };
+    fnMap: { [key: string]: FunctionMapping };
+    branchMap: { [key: string]: BranchMapping };
+    s: { [key: string]: number };
+    f: { [key: string]: number };
+    b: { [key: string]: number[] };
+}
+
+interface Totals {
+    total: number;
+    covered: number;
+    skipped: number;
+    pct: number;
+}
+
+interface Coverage {
+    covered: number;
+    total: number;
+    coverage: number;
+}
+
+declare class FileCoverage implements FileCoverageData {
+    constructor(data: string | FileCoverage | FileCoverageData);
+    merge(other: FileCoverageData): void;
+    getBranchCoverageByLine(): { [line: number]: Coverage };
+    getLineCoverage(): { [line: number]: number };
+    getUncoveredLines(): number[];
+    resetHits(): void;
+    computeBranchTotals(): Totals;
+    computeSimpleTotals(): Totals;
+    toSummary(): CoverageSummary;
+    toJSON(): object;
+
+    data: FileCoverageData;
+    path: string;
+    statementMap: { [key: string]: Range };
+    fnMap: { [key: string]: FunctionMapping };
+    branchMap: { [key: string]: BranchMapping };
+    s: { [key: string]: number };
+    f: { [key: string]: number };
+    b: { [key: string]: number[] };
+}
+
+type Threshold = 'lines' | 'functions' | 'statements' | 'branches';
+interface ResolvedThreshold {
+    coverageMap: CoverageMap;
+    name: string;
+    thresholds: Partial<Record<Threshold, number | undefined>>;
+}
+/**
+ * Holds info about raw coverage results that are stored on file system:
+ *
+ * ```json
+ * "project-a": {
+ *   "web": {
+ *     "tests/math.test.ts": "coverage-1.json",
+ *     "tests/utils.test.ts": "coverage-2.json",
+ * //                          ^^^^^^^^^^^^^^^ Raw coverage on file system
+ *   },
+ *   "ssr": { ... },
+ *   "browser": { ... },
+ * },
+ * "project-b": ...
+ * ```
+ */
+type CoverageFiles = Map<NonNullable<AfterSuiteRunMeta['projectName']> | symbol, Record<AfterSuiteRunMeta['transformMode'], {
+    [TestFilenames: string]: string;
+}>>;
+declare class BaseCoverageProvider<Options extends ResolvedCoverageOptions<'istanbul' | 'v8'>> {
+    ctx: Vitest;
+    readonly name: 'v8' | 'istanbul';
+    version: string;
+    options: Options;
+    coverageFiles: CoverageFiles;
+    pendingPromises: Promise<void>[];
+    coverageFilesDirectory: string;
+    _initialize(ctx: Vitest): void;
+    createCoverageMap(): CoverageMap;
+    generateReports(_: CoverageMap, __: boolean | undefined): Promise<void>;
+    parseConfigModule(_: string): Promise<{
+        generate: () => {
+            code: string;
+        };
+    }>;
+    resolveOptions(): Options;
+    clean(clean?: boolean): Promise<void>;
+    onAfterSuiteRun({ coverage, transformMode, projectName, testFiles }: AfterSuiteRunMeta): void;
+    readCoverageFiles<CoverageType>({ onFileRead, onFinished, onDebug }: {
+        /** Callback invoked with a single coverage result */
+        onFileRead: (data: CoverageType) => void;
+        /** Callback invoked once all results of a project for specific transform mode are read */
+        onFinished: (project: Vitest['projects'][number], transformMode: AfterSuiteRunMeta['transformMode']) => Promise<void>;
+        onDebug: ((...logs: any[]) => void) & {
+            enabled: boolean;
+        };
+    }): Promise<void>;
+    cleanAfterRun(): Promise<void>;
+    onTestFailure(): Promise<void>;
+    reportCoverage(coverageMap: unknown, { allTestsRun }: ReportContext): Promise<void>;
+    reportThresholds(coverageMap: CoverageMap, allTestsRun: boolean | undefined): Promise<void>;
+    /**
+     * Constructs collected coverage and users' threshold options into separate sets
+     * where each threshold set holds their own coverage maps. Threshold set is either
+     * for specific files defined by glob pattern or global for all other files.
+     */
+    private resolveThresholds;
+    /**
+     * Check collected coverage against configured thresholds. Sets exit code to 1 when thresholds not reached.
+     */
+    private checkThresholds;
+    /**
+     * Check if current coverage is above configured thresholds and bump the thresholds if needed
+     */
+    updateThresholds({ thresholds: allThresholds, onUpdate, configurationFile }: {
+        thresholds: ResolvedThreshold[];
+        configurationFile: unknown;
+        onUpdate: () => void;
+    }): Promise<void>;
+    mergeReports(coverageMaps: unknown[]): Promise<void>;
+    hasTerminalReporter(reporters: ResolvedCoverageOptions['reporter']): boolean;
+    toSlices<T>(array: T[], size: number): T[][];
+    createUncoveredFileTransformer(ctx: Vitest): (filename: string) => Promise<vite.TransformResult | null | undefined>;
+}
+
+export { BaseCoverageProvider };

pwa/node_modules/vitest/dist/coverage.js

@@ -0,0 +1,461 @@
+import { existsSync, promises, readdirSync, writeFileSync } from 'node:fs';
+import { c as coverageConfigDefaults, r as resolveCoverageReporters, m as mm } from './chunks/resolveConfig.rBxzbVsl.js';
+import { resolve, relative } from 'pathe';
+import c from 'tinyrainbow';
+import 'node:crypto';
+import '@vitest/utils';
+import 'node:path';
+import 'node:fs/promises';
+import 'node:process';
+import 'node:module';
+import 'node:url';
+import 'node:assert';
+import 'node:v8';
+import 'node:util';
+import './chunks/constants.fzPh7AOq.js';
+import 'node:os';
+import './chunks/RandomSequencer.CMRlh2v4.js';
+import 'std-env';
+import 'node:perf_hooks';
+import '@vitest/runner/utils';
+import '@vitest/utils/source-map';
+import 'tinyexec';
+import 'vite';
+import 'fs';
+import 'vite-node/utils';
+import './chunks/_commonjsHelpers.BFTU3MAI.js';
+import 'util';
+import 'path';
+import 'node:events';
+import './chunks/index.68735LiX.js';
+import 'tinypool';
+import 'node:worker_threads';
+import './path.js';
+
+const THRESHOLD_KEYS = [
+  "lines",
+  "functions",
+  "statements",
+  "branches"
+];
+const GLOBAL_THRESHOLDS_KEY = "global";
+const DEFAULT_PROJECT = Symbol.for("default-project");
+let uniqueId = 0;
+class BaseCoverageProvider {
+  ctx;
+  name;
+  version;
+  options;
+  coverageFiles = /* @__PURE__ */ new Map();
+  pendingPromises = [];
+  coverageFilesDirectory;
+  _initialize(ctx) {
+    this.ctx = ctx;
+    if (ctx.version !== this.version) {
+      ctx.logger.warn(
+        c.yellow(
+          `Loaded ${c.inverse(c.yellow(` vitest@${ctx.version} `))} and ${c.inverse(c.yellow(` @vitest/coverage-${this.name}@${this.version} `))}.
+Running mixed versions is not supported and may lead into bugs
+Update your dependencies and make sure the versions match.`
+        )
+      );
+    }
+    const config = ctx.config.coverage;
+    this.options = {
+      ...coverageConfigDefaults,
+      // User's options
+      ...config,
+      // Resolved fields
+      provider: this.name,
+      reportsDirectory: resolve(
+        ctx.config.root,
+        config.reportsDirectory || coverageConfigDefaults.reportsDirectory
+      ),
+      reporter: resolveCoverageReporters(
+        config.reporter || coverageConfigDefaults.reporter
+      ),
+      thresholds: config.thresholds && {
+        ...config.thresholds,
+        lines: config.thresholds["100"] ? 100 : config.thresholds.lines,
+        branches: config.thresholds["100"] ? 100 : config.thresholds.branches,
+        functions: config.thresholds["100"] ? 100 : config.thresholds.functions,
+        statements: config.thresholds["100"] ? 100 : config.thresholds.statements
+      }
+    };
+    const shard = this.ctx.config.shard;
+    const tempDirectory = `.tmp${shard ? `-${shard.index}-${shard.count}` : ""}`;
+    this.coverageFilesDirectory = resolve(
+      this.options.reportsDirectory,
+      tempDirectory
+    );
+  }
+  createCoverageMap() {
+    throw new Error("BaseReporter's createCoverageMap was not overwritten");
+  }
+  async generateReports(_, __) {
+    throw new Error("BaseReporter's generateReports was not overwritten");
+  }
+  async parseConfigModule(_) {
+    throw new Error("BaseReporter's parseConfigModule was not overwritten");
+  }
+  resolveOptions() {
+    return this.options;
+  }
+  async clean(clean = true) {
+    if (clean && existsSync(this.options.reportsDirectory)) {
+      await promises.rm(this.options.reportsDirectory, {
+        recursive: true,
+        force: true,
+        maxRetries: 10
+      });
+    }
+    if (existsSync(this.coverageFilesDirectory)) {
+      await promises.rm(this.coverageFilesDirectory, {
+        recursive: true,
+        force: true,
+        maxRetries: 10
+      });
+    }
+    await promises.mkdir(this.coverageFilesDirectory, { recursive: true });
+    this.coverageFiles = /* @__PURE__ */ new Map();
+    this.pendingPromises = [];
+  }
+  onAfterSuiteRun({ coverage, transformMode, projectName, testFiles }) {
+    if (!coverage) {
+      return;
+    }
+    if (transformMode !== "web" && transformMode !== "ssr" && transformMode !== "browser") {
+      throw new Error(`Invalid transform mode: ${transformMode}`);
+    }
+    let entry = this.coverageFiles.get(projectName || DEFAULT_PROJECT);
+    if (!entry) {
+      entry = { web: {}, ssr: {}, browser: {} };
+      this.coverageFiles.set(projectName || DEFAULT_PROJECT, entry);
+    }
+    const testFilenames = testFiles.join();
+    const filename = resolve(
+      this.coverageFilesDirectory,
+      `coverage-${uniqueId++}.json`
+    );
+    entry[transformMode][testFilenames] = filename;
+    const promise = promises.writeFile(filename, JSON.stringify(coverage), "utf-8");
+    this.pendingPromises.push(promise);
+  }
+  async readCoverageFiles({ onFileRead, onFinished, onDebug }) {
+    let index = 0;
+    const total = this.pendingPromises.length;
+    await Promise.all(this.pendingPromises);
+    this.pendingPromises = [];
+    for (const [projectName, coveragePerProject] of this.coverageFiles.entries()) {
+      for (const [transformMode, coverageByTestfiles] of Object.entries(coveragePerProject)) {
+        const filenames = Object.values(coverageByTestfiles);
+        const project = this.ctx.getProjectByName(projectName);
+        for (const chunk of this.toSlices(filenames, this.options.processingConcurrency)) {
+          if (onDebug.enabled) {
+            index += chunk.length;
+            onDebug("Covered files %d/%d", index, total);
+          }
+          await Promise.all(
+            chunk.map(async (filename) => {
+              const contents = await promises.readFile(filename, "utf-8");
+              const coverage = JSON.parse(contents);
+              onFileRead(coverage);
+            })
+          );
+        }
+        await onFinished(project, transformMode);
+      }
+    }
+  }
+  async cleanAfterRun() {
+    this.coverageFiles = /* @__PURE__ */ new Map();
+    await promises.rm(this.coverageFilesDirectory, { recursive: true });
+    if (readdirSync(this.options.reportsDirectory).length === 0) {
+      await promises.rm(this.options.reportsDirectory, { recursive: true });
+    }
+  }
+  async onTestFailure() {
+    if (!this.options.reportOnFailure) {
+      await this.cleanAfterRun();
+    }
+  }
+  async reportCoverage(coverageMap, { allTestsRun }) {
+    await this.generateReports(
+      coverageMap || this.createCoverageMap(),
+      allTestsRun
+    );
+    const keepResults = !this.options.cleanOnRerun && this.ctx.config.watch;
+    if (!keepResults) {
+      await this.cleanAfterRun();
+    }
+  }
+  async reportThresholds(coverageMap, allTestsRun) {
+    const resolvedThresholds = this.resolveThresholds(coverageMap);
+    this.checkThresholds(resolvedThresholds);
+    if (this.options.thresholds?.autoUpdate && allTestsRun) {
+      if (!this.ctx.server.config.configFile) {
+        throw new Error(
+          'Missing configurationFile. The "coverage.thresholds.autoUpdate" can only be enabled when configuration file is used.'
+        );
+      }
+      const configFilePath = this.ctx.server.config.configFile;
+      const configModule = await this.parseConfigModule(configFilePath);
+      await this.updateThresholds({
+        thresholds: resolvedThresholds,
+        configurationFile: configModule,
+        onUpdate: () => writeFileSync(
+          configFilePath,
+          configModule.generate().code,
+          "utf-8"
+        )
+      });
+    }
+  }
+  /**
+   * Constructs collected coverage and users' threshold options into separate sets
+   * where each threshold set holds their own coverage maps. Threshold set is either
+   * for specific files defined by glob pattern or global for all other files.
+   */
+  resolveThresholds(coverageMap) {
+    const resolvedThresholds = [];
+    const files = coverageMap.files();
+    const globalCoverageMap = this.createCoverageMap();
+    for (const key of Object.keys(this.options.thresholds)) {
+      if (key === "perFile" || key === "autoUpdate" || key === "100" || THRESHOLD_KEYS.includes(key)) {
+        continue;
+      }
+      const glob = key;
+      const globThresholds = resolveGlobThresholds(this.options.thresholds[glob]);
+      const globCoverageMap = this.createCoverageMap();
+      const matchingFiles = files.filter(
+        (file) => mm.isMatch(relative(this.ctx.config.root, file), glob)
+      );
+      for (const file of matchingFiles) {
+        const fileCoverage = coverageMap.fileCoverageFor(file);
+        globCoverageMap.addFileCoverage(fileCoverage);
+      }
+      resolvedThresholds.push({
+        name: glob,
+        coverageMap: globCoverageMap,
+        thresholds: globThresholds
+      });
+    }
+    for (const file of files) {
+      const fileCoverage = coverageMap.fileCoverageFor(file);
+      globalCoverageMap.addFileCoverage(fileCoverage);
+    }
+    resolvedThresholds.unshift({
+      name: GLOBAL_THRESHOLDS_KEY,
+      coverageMap: globalCoverageMap,
+      thresholds: {
+        branches: this.options.thresholds?.branches,
+        functions: this.options.thresholds?.functions,
+        lines: this.options.thresholds?.lines,
+        statements: this.options.thresholds?.statements
+      }
+    });
+    return resolvedThresholds;
+  }
+  /**
+   * Check collected coverage against configured thresholds. Sets exit code to 1 when thresholds not reached.
+   */
+  checkThresholds(allThresholds) {
+    for (const { coverageMap, thresholds, name } of allThresholds) {
+      if (thresholds.branches === void 0 && thresholds.functions === void 0 && thresholds.lines === void 0 && thresholds.statements === void 0) {
+        continue;
+      }
+      const summaries = this.options.thresholds?.perFile ? coverageMap.files().map((file) => ({
+        file,
+        summary: coverageMap.fileCoverageFor(file).toSummary()
+      })) : [{ file: null, summary: coverageMap.getCoverageSummary() }];
+      for (const { summary, file } of summaries) {
+        for (const thresholdKey of THRESHOLD_KEYS) {
+          const threshold = thresholds[thresholdKey];
+          if (threshold !== void 0) {
+            const coverage = summary.data[thresholdKey].pct;
+            if (coverage < threshold) {
+              process.exitCode = 1;
+              let errorMessage = `ERROR: Coverage for ${thresholdKey} (${coverage}%) does not meet ${name === GLOBAL_THRESHOLDS_KEY ? name : `"${name}"`} threshold (${threshold}%)`;
+              if (this.options.thresholds?.perFile && file) {
+                errorMessage += ` for ${relative("./", file).replace(/\\/g, "/")}`;
+              }
+              this.ctx.logger.error(errorMessage);
+            }
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Check if current coverage is above configured thresholds and bump the thresholds if needed
+   */
+  async updateThresholds({ thresholds: allThresholds, onUpdate, configurationFile }) {
+    let updatedThresholds = false;
+    const config = resolveConfig(configurationFile);
+    assertConfigurationModule(config);
+    for (const { coverageMap, thresholds, name } of allThresholds) {
+      const summaries = this.options.thresholds?.perFile ? coverageMap.files().map(
+        (file) => coverageMap.fileCoverageFor(file).toSummary()
+      ) : [coverageMap.getCoverageSummary()];
+      const thresholdsToUpdate = [];
+      for (const key of THRESHOLD_KEYS) {
+        const threshold = thresholds[key] ?? 100;
+        const actual = Math.min(
+          ...summaries.map((summary) => summary[key].pct)
+        );
+        if (actual > threshold) {
+          thresholdsToUpdate.push([key, actual]);
+        }
+      }
+      if (thresholdsToUpdate.length === 0) {
+        continue;
+      }
+      updatedThresholds = true;
+      for (const [threshold, newValue] of thresholdsToUpdate) {
+        if (name === GLOBAL_THRESHOLDS_KEY) {
+          config.test.coverage.thresholds[threshold] = newValue;
+        } else {
+          const glob = config.test.coverage.thresholds[name];
+          glob[threshold] = newValue;
+        }
+      }
+    }
+    if (updatedThresholds) {
+      this.ctx.logger.log("Updating thresholds to configuration file. You may want to push with updated coverage thresholds.");
+      onUpdate();
+    }
+  }
+  async mergeReports(coverageMaps) {
+    const coverageMap = this.createCoverageMap();
+    for (const coverage of coverageMaps) {
+      coverageMap.merge(coverage);
+    }
+    await this.generateReports(coverageMap, true);
+  }
+  hasTerminalReporter(reporters) {
+    return reporters.some(
+      ([reporter]) => reporter === "text" || reporter === "text-summary" || reporter === "text-lcov" || reporter === "teamcity"
+    );
+  }
+  toSlices(array, size) {
+    return array.reduce((chunks, item) => {
+      const index = Math.max(0, chunks.length - 1);
+      const lastChunk = chunks[index] || [];
+      chunks[index] = lastChunk;
+      if (lastChunk.length >= size) {
+        chunks.push([item]);
+      } else {
+        lastChunk.push(item);
+      }
+      return chunks;
+    }, []);
+  }
+  createUncoveredFileTransformer(ctx) {
+    const servers = [
+      ...ctx.projects.map((project) => ({
+        root: project.config.root,
+        vitenode: project.vitenode
+      })),
+      // Check core last as it will match all files anyway
+      { root: ctx.config.root, vitenode: ctx.vitenode }
+    ];
+    return async function transformFile(filename) {
+      let lastError;
+      for (const { root, vitenode } of servers) {
+        if (!filename.startsWith(root)) {
+          continue;
+        }
+        try {
+          return await vitenode.transformRequest(filename);
+        } catch (error) {
+          lastError = error;
+        }
+      }
+      throw lastError;
+    };
+  }
+}
+function resolveGlobThresholds(thresholds) {
+  if (!thresholds || typeof thresholds !== "object") {
+    return {};
+  }
+  if (100 in thresholds && thresholds[100] === true) {
+    return {
+      lines: 100,
+      branches: 100,
+      functions: 100,
+      statements: 100
+    };
+  }
+  return {
+    lines: "lines" in thresholds && typeof thresholds.lines === "number" ? thresholds.lines : void 0,
+    branches: "branches" in thresholds && typeof thresholds.branches === "number" ? thresholds.branches : void 0,
+    functions: "functions" in thresholds && typeof thresholds.functions === "number" ? thresholds.functions : void 0,
+    statements: "statements" in thresholds && typeof thresholds.statements === "number" ? thresholds.statements : void 0
+  };
+}
+function assertConfigurationModule(config) {
+  try {
+    if (typeof config.test.coverage.thresholds !== "object") {
+      throw new TypeError(
+        "Expected config.test.coverage.thresholds to be an object"
+      );
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Unable to parse thresholds from configuration file: ${message}`
+    );
+  }
+}
+function resolveConfig(configModule) {
+  const mod = configModule.exports.default;
+  try {
+    if (mod.$type === "object") {
+      return mod;
+    }
+    let config = resolveDefineConfig(mod);
+    if (config) {
+      return config;
+    }
+    if (mod.$type === "function-call" && mod.$callee === "mergeConfig") {
+      config = resolveMergeConfig(mod);
+      if (config) {
+        return config;
+      }
+    }
+  } catch (error) {
+    throw new Error(error instanceof Error ? error.message : String(error));
+  }
+  throw new Error(
+    "Failed to update coverage thresholds. Configuration file is too complex."
+  );
+}
+function resolveDefineConfig(mod) {
+  if (mod.$type === "function-call" && mod.$callee === "defineConfig") {
+    if (mod.$args[0].$type === "object") {
+      return mod.$args[0];
+    }
+    if (mod.$args[0].$type === "arrow-function-expression") {
+      if (mod.$args[0].$body.$type === "object") {
+        return mod.$args[0].$body;
+      }
+      const config = resolveMergeConfig(mod.$args[0].$body);
+      if (config) {
+        return config;
+      }
+    }
+  }
+}
+function resolveMergeConfig(mod) {
+  if (mod.$type === "function-call" && mod.$callee === "mergeConfig") {
+    for (const arg of mod.$args) {
+      const config = resolveDefineConfig(arg);
+      if (config) {
+        return config;
+      }
+    }
+  }
+}
+
+export { BaseCoverageProvider };

pwa/node_modules/vitest/dist/environments.d.ts

@@ -0,0 +1,21 @@
+import { E as Environment } from './chunks/environment.LoooBwUu.js';
+export { a as EnvironmentReturn, V as VmEnvironmentReturn } from './chunks/environment.LoooBwUu.js';
+
+declare const environments: {
+    node: Environment;
+    jsdom: Environment;
+    'happy-dom': Environment;
+    'edge-runtime': Environment;
+};
+
+interface PopulateOptions {
+    bindFunctions?: boolean;
+    additionalKeys?: string[];
+}
+declare function populateGlobal(global: any, win: any, options?: PopulateOptions): {
+    keys: Set<string>;
+    skipKeys: string[];
+    originals: Map<string | symbol, any>;
+};
+
+export { Environment, environments as builtinEnvironments, populateGlobal };

pwa/node_modules/vitest/dist/environments.js

@@ -0,0 +1,2 @@
+export { e as builtinEnvironments, p as populateGlobal } from './chunks/index.K90BXFOx.js';
+import 'node:console';

pwa/node_modules/vitest/dist/execute.d.ts

@@ -0,0 +1,144 @@
+import { ViteNodeRunnerOptions } from 'vite-node';
+import { ViteNodeRunner } from 'vite-node/client';
+import { R as RuntimeRPC, W as WorkerGlobalState } from './chunks/worker.tN5KGIih.js';
+import vm from 'node:vm';
+import * as _vitest_mocker from '@vitest/mocker';
+import { MockedModuleType } from '@vitest/mocker';
+import { P as PendingSuiteMock, b as MockFactory, a as MockOptions } from './chunks/mocker.cRtM890J.js';
+import '@vitest/runner';
+import './chunks/config.Cy0C388Z.js';
+import '@vitest/pretty-format';
+import '@vitest/snapshot';
+import '@vitest/snapshot/environment';
+import './chunks/environment.LoooBwUu.js';
+
+declare class FileMap {
+    private fsCache;
+    private fsBufferCache;
+    readFileAsync(path: string): Promise<string>;
+    readFile(path: string): string;
+    readBuffer(path: string): Buffer;
+}
+
+interface ModuleEvaluateOptions {
+    timeout?: vm.RunningScriptOptions['timeout'] | undefined;
+    breakOnSigint?: vm.RunningScriptOptions['breakOnSigint'] | undefined;
+}
+type ModuleLinker = (specifier: string, referencingModule: VMModule, extra: {
+    assert: object;
+}) => VMModule | Promise<VMModule>;
+type ModuleStatus = 'unlinked' | 'linking' | 'linked' | 'evaluating' | 'evaluated' | 'errored';
+declare class VMModule {
+    dependencySpecifiers: readonly string[];
+    error: any;
+    identifier: string;
+    context: vm.Context;
+    namespace: object;
+    status: ModuleStatus;
+    evaluate(options?: ModuleEvaluateOptions): Promise<void>;
+    link(linker: ModuleLinker): Promise<void>;
+}
+
+interface ExternalModulesExecutorOptions {
+    context: vm.Context;
+    fileMap: FileMap;
+    packageCache: Map<string, any>;
+    transform: RuntimeRPC['transform'];
+    interopDefault?: boolean;
+    viteClientModule: Record<string, unknown>;
+}
+declare class ExternalModulesExecutor {
+    #private;
+    private options;
+    private cjs;
+    private esm;
+    private vite;
+    private context;
+    private fs;
+    private resolvers;
+    constructor(options: ExternalModulesExecutorOptions);
+    import(identifier: string): Promise<object>;
+    require(identifier: string): any;
+    createRequire(identifier: string): NodeRequire;
+    importModuleDynamically: (specifier: string, referencer: VMModule) => Promise<VMModule>;
+    resolveModule: (specifier: string, referencer: string) => Promise<VMModule>;
+    resolve(specifier: string, parent: string): string;
+    private findNearestPackageData;
+    private wrapCoreSynteticModule;
+    private wrapCommonJsSynteticModule;
+    private getModuleInformation;
+    private createModule;
+    private get isNetworkSupported();
+}
+
+interface MockContext {
+    /**
+     * When mocking with a factory, this refers to the module that imported the mock.
+     */
+    callstack: null | string[];
+}
+declare class VitestMocker {
+    executor: VitestExecutor;
+    static pendingIds: PendingSuiteMock[];
+    private spyModule?;
+    private primitives;
+    private filterPublicKeys;
+    private registries;
+    private mockContext;
+    constructor(executor: VitestExecutor);
+    private get root();
+    private get moduleCache();
+    private get moduleDirectories();
+    initializeSpyModule(): Promise<void>;
+    private getMockerRegistry;
+    reset(): void;
+    private deleteCachedItem;
+    private isModuleDirectory;
+    getSuiteFilepath(): string;
+    private createError;
+    private resolvePath;
+    resolveMocks(): Promise<void>;
+    private callFunctionMock;
+    getMockContext(): MockContext;
+    getMockPath(dep: string): string;
+    getDependencyMock(id: string): _vitest_mocker.MockedModule | undefined;
+    normalizePath(path: string): string;
+    resolveMockPath(mockPath: string, external: string | null): string | null;
+    mockObject(object: Record<string | symbol, any>, mockExports?: Record<string | symbol, any>, behavior?: MockedModuleType): Record<string | symbol, any>;
+    unmockPath(path: string): void;
+    mockPath(originalId: string, path: string, external: string | null, mockType: MockedModuleType | undefined, factory: MockFactory | undefined): void;
+    importActual<T>(rawId: string, importer: string, callstack?: string[] | null): Promise<T>;
+    importMock(rawId: string, importee: string): Promise<any>;
+    requestWithMock(url: string, callstack: string[]): Promise<any>;
+    queueMock(id: string, importer: string, factoryOrOptions?: MockFactory | MockOptions): void;
+    queueUnmock(id: string, importer: string): void;
+}
+
+interface ExecuteOptions extends ViteNodeRunnerOptions {
+    moduleDirectories?: string[];
+    state: WorkerGlobalState;
+    context?: vm.Context;
+    externalModulesExecutor?: ExternalModulesExecutor;
+}
+declare class VitestExecutor extends ViteNodeRunner {
+    options: ExecuteOptions;
+    mocker: VitestMocker;
+    externalModules?: ExternalModulesExecutor;
+    private primitives;
+    constructor(options: ExecuteOptions);
+    protected getContextPrimitives(): {
+        Object: typeof Object;
+        Reflect: typeof Reflect;
+        Symbol: typeof Symbol;
+    };
+    get state(): WorkerGlobalState;
+    shouldResolveId(id: string, _importee?: string | undefined): boolean;
+    originalResolveUrl(id: string, importer?: string): Promise<[url: string, fsPath: string]>;
+    resolveUrl(id: string, importer?: string): Promise<[url: string, fsPath: string]>;
+    protected runModule(context: Record<string, any>, transformed: string): Promise<void>;
+    importExternalModule(path: string): Promise<any>;
+    dependencyRequest(id: string, fsPath: string, callstack: string[]): Promise<any>;
+    prepareContext(context: Record<string, any>): Record<string, any>;
+}
+
+export { VitestExecutor };

pwa/node_modules/vitest/dist/execute.js

@@ -0,0 +1,13 @@
+export { V as VitestExecutor } from './chunks/execute.2pr0rHgK.js';
+import 'node:fs';
+import 'node:url';
+import 'node:vm';
+import '@vitest/utils/error';
+import 'pathe';
+import 'vite-node/client';
+import 'vite-node/utils';
+import './path.js';
+import 'node:path';
+import '@vitest/mocker';
+import 'node:module';
+import '@vitest/utils';

pwa/node_modules/vitest/dist/index.d.ts

@@ -0,0 +1,715 @@
+import { TaskResultPack as TaskResultPack$1, File as File$1, TaskPopulated, Suite as Suite$1, Test as Test$1, Custom as Custom$1, Task as Task$1, TaskBase as TaskBase$1, TaskResult as TaskResult$1, DoneCallback as DoneCallback$1, RuntimeContext as RuntimeContext$1, SuiteHooks as SuiteHooks$1, SequenceHooks as SequenceHooks$1, SequenceSetupFiles as SequenceSetupFiles$1 } from '@vitest/runner';
+export { CancelReason, ExtendedContext, HookCleanupCallback, HookListener, OnTestFailedHandler, OnTestFinishedHandler, RunMode, Custom as RunnerCustomCase, Task as RunnerTask, TaskBase as RunnerTaskBase, TaskResult as RunnerTaskResult, TaskResultPack as RunnerTaskResultPack, Test as RunnerTestCase, File as RunnerTestFile, Suite as RunnerTestSuite, SuiteAPI, SuiteCollector, SuiteFactory, TaskContext, TaskCustomOptions, TaskMeta, TaskState, TestAPI, TestContext, TestFunction, TestOptions, afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
+import { f as VitestEnvironment$1, S as SerializedTestSpecification, g as RawErrsMap$1, T as TscErrorInfo$1, h as CollectLineNumbers$1, i as CollectLines$1, j as RootAndTarget$1, k as Context$1, C as CoverageProvider$1, a as ReportContext$1, b as CoverageProviderModule$1, l as CoverageReporter$1, m as CoverageProviderName, n as CoverageOptions$1, R as ResolvedCoverageOptions$1, B as BaseCoverageOptions$1, o as CoverageIstanbulOptions$1, c as CoverageV8Options$1, p as CustomProviderOptions$1, q as Reporter$1, V as Vitest$1, r as BrowserScript$1, s as BrowserConfigOptions$1, t as BuiltinEnvironment$1, P as Pool$1, u as PoolOptions$1, v as CSSModuleScopeStrategy$1, A as ApiConfig$1, w as VitestRunMode$1, D as DepsOptimizationOptions$1, x as TransformModePatterns$1, I as InlineConfig$1, y as TypecheckConfig$1, z as UserConfig$1, E as ResolvedConfig$1, F as ProjectConfig$1, U as UserWorkspaceConfig$1, G as BenchmarkUserOptions$1 } from './chunks/reporters.nr4dxCkA.js';
+import { W as WorkerContext$1 } from './chunks/worker.B9FxPCaC.js';
+import { U as UserConsoleLog, M as ModuleGraphData, b as Awaitable$1, P as ProvidedContext, N as Nullable$1, c as Arrayable$1, d as ArgumentsType$1, e as MutableArray$1, C as Constructable$1, O as OnServerRestartHandler$1, a as EnvironmentReturn$1, V as VmEnvironmentReturn$1, E as Environment$1, R as ResolvedTestEnvironment$1, J as JSDOMOptions$1, H as HappyDOMOptions$1, f as EnvironmentOptions$1 } from './chunks/environment.LoooBwUu.js';
+export { A as AfterSuiteRunMeta, g as ModuleCache } from './chunks/environment.LoooBwUu.js';
+import { a as BirpcReturn, b as WorkerRPC$1 } from './chunks/worker.tN5KGIih.js';
+export { C as ContextRPC, d as ContextTestEnvironment, e as ResolveIdFunction, c as RunnerRPC, R as RuntimeRPC, W as WorkerGlobalState } from './chunks/worker.tN5KGIih.js';
+import './chunks/vite.CzKp4x9w.js';
+import { PromisifyAssertion, Tester, ExpectStatic } from '@vitest/expect';
+export { Assertion, AsymmetricMatchersContaining, ExpectPollOptions, ExpectStatic, JestAssertion } from '@vitest/expect';
+import { Plugin } from '@vitest/pretty-format';
+import { SnapshotState } from '@vitest/snapshot';
+export { SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotSerializer, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, UncheckedSnapshot } from '@vitest/snapshot';
+import { B as BenchmarkResult } from './chunks/benchmark.geERunq4.js';
+export { a as BenchFunction, b as Benchmark, c as BenchmarkAPI } from './chunks/benchmark.geERunq4.js';
+import { S as SerializedConfig, F as FakeTimerInstallOpts, R as RuntimeOptions } from './chunks/config.Cy0C388Z.js';
+export { b as RuntimeConfig, a as SerializedCoverageConfig } from './chunks/config.Cy0C388Z.js';
+import { spyOn, fn, MaybeMockedDeep, MaybeMocked, MaybePartiallyMocked, MaybePartiallyMockedDeep, MockInstance } from '@vitest/spy';
+export { Mock, MockContext, MockInstance, Mocked, MockedClass, MockedFunction, MockedObject } from '@vitest/spy';
+import { M as MockFactoryWithHelper, a as MockOptions } from './chunks/mocker.cRtM890J.js';
+export { b as bench } from './chunks/suite.B2jumIFP.js';
+export { ExpectTypeOf, expectTypeOf } from 'expect-type';
+export { ErrorWithDiff, ParsedStack, SerializedError, TestError } from '@vitest/utils';
+export { DiffOptions } from '@vitest/utils/diff';
+import * as chai from 'chai';
+export { chai };
+export { assert, should } from 'chai';
+export { Bench as BenchFactory, Options as BenchOptions, Task as BenchTask, TaskResult as BenchTaskResult } from 'tinybench';
+import 'node:stream';
+import 'vite';
+import 'vite-node';
+import '@vitest/utils/source-map';
+import 'vite-node/client';
+import 'vite-node/server';
+import '@vitest/snapshot/manager';
+import 'node:fs';
+import 'node:worker_threads';
+import '@vitest/runner/utils';
+import '@vitest/snapshot/environment';
+import '@vitest/mocker';
+
+declare global {
+    namespace Chai {
+        interface Assertion {
+            containSubset: (expected: any) => Assertion;
+        }
+        interface Assert {
+            containSubset: (val: any, exp: any, msg?: string) => void;
+        }
+    }
+}
+interface SnapshotMatcher<T> {
+    <U extends {
+        [P in keyof T]: any;
+    }>(snapshot: Partial<U>, message?: string): void;
+    (message?: string): void;
+}
+interface InlineSnapshotMatcher<T> {
+    <U extends {
+        [P in keyof T]: any;
+    }>(properties: Partial<U>, snapshot?: string, message?: string): void;
+    (message?: string): void;
+}
+declare module '@vitest/expect' {
+    interface MatcherState {
+        environment: VitestEnvironment$1;
+        snapshotState: SnapshotState;
+    }
+    interface ExpectPollOptions {
+        interval?: number;
+        timeout?: number;
+        message?: string;
+    }
+    interface ExpectStatic {
+        unreachable: (message?: string) => never;
+        soft: <T>(actual: T, message?: string) => Assertion<T>;
+        poll: <T>(actual: () => T, options?: ExpectPollOptions) => PromisifyAssertion<Awaited<T>>;
+        addEqualityTesters: (testers: Array<Tester>) => void;
+        assertions: (expected: number) => void;
+        hasAssertions: () => void;
+        addSnapshotSerializer: (plugin: Plugin) => void;
+    }
+    interface Assertion<T> {
+        matchSnapshot: SnapshotMatcher<T>;
+        toMatchSnapshot: SnapshotMatcher<T>;
+        toMatchInlineSnapshot: InlineSnapshotMatcher<T>;
+        /**
+         * Checks that an error thrown by a function matches a previously recorded snapshot.
+         *
+         * @param message - Optional custom error message.
+         *
+         * @example
+         * expect(functionWithError).toThrowErrorMatchingSnapshot();
+         */
+        toThrowErrorMatchingSnapshot: (message?: string) => void;
+        /**
+         * Checks that an error thrown by a function matches an inline snapshot within the test file.
+         * Useful for keeping snapshots close to the test code.
+         *
+         * @param snapshot - Optional inline snapshot string to match.
+         * @param message - Optional custom error message.
+         *
+         * @example
+         * const throwError = () => { throw new Error('Error occurred') };
+         * expect(throwError).toThrowErrorMatchingInlineSnapshot(`"Error occurred"`);
+         */
+        toThrowErrorMatchingInlineSnapshot: (snapshot?: string, message?: string) => void;
+        /**
+         * Compares the received value to a snapshot saved in a specified file.
+         * Useful for cases where snapshot content is large or needs to be shared across tests.
+         *
+         * @param filepath - Path to the snapshot file.
+         * @param message - Optional custom error message.
+         *
+         * @example
+         * await expect(largeData).toMatchFileSnapshot('path/to/snapshot.json');
+         */
+        toMatchFileSnapshot: (filepath: string, message?: string) => Promise<void>;
+    }
+}
+declare module '@vitest/runner' {
+    interface TestContext {
+        expect: ExpectStatic;
+    }
+    interface TaskMeta {
+        typecheck?: boolean;
+        benchmark?: boolean;
+        failScreenshotPath?: string;
+    }
+    interface File {
+        prepareDuration?: number;
+        environmentLoad?: number;
+    }
+    interface TaskBase {
+        logs?: UserConsoleLog[];
+    }
+    interface TaskResult {
+        benchmark?: BenchmarkResult;
+    }
+}
+
+interface SourceMap {
+    file: string;
+    mappings: string;
+    names: string[];
+    sources: string[];
+    sourcesContent?: string[];
+    version: number;
+    toString: () => string;
+    toUrl: () => string;
+}
+interface TransformResultWithSource {
+    code: string;
+    map: SourceMap | {
+        mappings: '';
+    } | null;
+    etag?: string;
+    deps?: string[];
+    dynamicDeps?: string[];
+    source?: string;
+}
+interface WebSocketHandlers {
+    onTaskUpdate: (packs: TaskResultPack$1[]) => void;
+    getFiles: () => File$1[];
+    getTestFiles: () => Promise<SerializedTestSpecification[]>;
+    getPaths: () => string[];
+    getConfig: () => SerializedConfig;
+    getModuleGraph: (projectName: string, id: string, browser?: boolean) => Promise<ModuleGraphData>;
+    getTransformResult: (projectName: string, id: string, browser?: boolean) => Promise<TransformResultWithSource | undefined>;
+    readTestFile: (id: string) => Promise<string | null>;
+    saveTestFile: (id: string, content: string) => Promise<void>;
+    rerun: (files: string[]) => Promise<void>;
+    updateSnapshot: (file?: File$1) => Promise<void>;
+    getUnhandledErrors: () => unknown[];
+}
+interface WebSocketEvents {
+    onCollected?: (files?: File$1[]) => Awaitable$1<void>;
+    onFinished?: (files: File$1[], errors: unknown[], coverage?: unknown) => Awaitable$1<void>;
+    onTaskUpdate?: (packs: TaskResultPack$1[]) => Awaitable$1<void>;
+    onUserConsoleLog?: (log: UserConsoleLog) => Awaitable$1<void>;
+    onPathsCollected?: (paths?: string[]) => Awaitable$1<void>;
+    onSpecsCollected?: (specs?: SerializedTestSpecification[]) => Awaitable$1<void>;
+    onFinishedReportCoverage: () => void;
+}
+type WebSocketRPC = BirpcReturn<WebSocketEvents, WebSocketHandlers>;
+
+declare function createExpect(test?: TaskPopulated): ExpectStatic;
+declare const globalExpect: ExpectStatic;
+
+/**
+ * Gives access to injected context provided from the main thread.
+ * This usually returns a value provided by `globalSetup` or an external library.
+ */
+declare function inject<T extends keyof ProvidedContext & string>(key: T): ProvidedContext[T];
+
+/**
+ * This utils allows computational intensive tasks to only be ran once
+ * across test reruns to improve the watch mode performance.
+ *
+ * Currently only works with `poolOptions.<pool>.isolate: false`
+ *
+ * @experimental
+ */
+declare function runOnce<T>(fn: () => T, key?: string): T;
+/**
+ * Get a boolean indicates whether the task is running in the first time.
+ * Could only be `false` in watch mode.
+ *
+ * Currently only works with `isolate: false`
+ *
+ * @experimental
+ */
+declare function isFirstRun(): boolean;
+
+declare function getRunningMode(): "watch" | "run";
+declare function isWatchMode(): boolean;
+
+type WaitForCallback<T> = () => T | Promise<T>;
+interface WaitForOptions {
+    /**
+     * @description Time in ms between each check callback
+     * @default 50ms
+     */
+    interval?: number;
+    /**
+     * @description Time in ms after which the throw a timeout error
+     * @default 1000ms
+     */
+    timeout?: number;
+}
+declare function waitFor<T>(callback: WaitForCallback<T>, options?: number | WaitForOptions): Promise<T>;
+type WaitUntilCallback<T> = () => T | Promise<T>;
+interface WaitUntilOptions extends Pick<WaitForOptions, 'interval' | 'timeout'> {
+}
+type Truthy<T> = T extends false | '' | 0 | null | undefined ? never : T;
+declare function waitUntil<T>(callback: WaitUntilCallback<T>, options?: number | WaitUntilOptions): Promise<Truthy<T>>;
+
+type ESModuleExports = Record<string, unknown>;
+interface VitestUtils {
+    /**
+     * Checks if fake timers are enabled.
+     */
+    isFakeTimers: () => boolean;
+    /**
+     * This method wraps all further calls to timers until [`vi.useRealTimers()`](https://vitest.dev/api/vi#vi-userealtimers) is called.
+     */
+    useFakeTimers: (config?: FakeTimerInstallOpts) => VitestUtils;
+    /**
+     * Restores mocked timers to their original implementations. All timers that were scheduled before will be discarded.
+     */
+    useRealTimers: () => VitestUtils;
+    /**
+     * This method will call every timer that was initiated after [`vi.useFakeTimers`](https://vitest.dev/api/vi#vi-usefaketimers) call.
+     * It will not fire any timer that was initiated during its call.
+     */
+    runOnlyPendingTimers: () => VitestUtils;
+    /**
+     * This method will asynchronously call every timer that was initiated after [`vi.useFakeTimers`](https://vitest.dev/api/vi#vi-usefaketimers) call, even asynchronous ones.
+     * It will not fire any timer that was initiated during its call.
+     */
+    runOnlyPendingTimersAsync: () => Promise<VitestUtils>;
+    /**
+     * This method will invoke every initiated timer until the timer queue is empty. It means that every timer called during `runAllTimers` will be fired.
+     * If you have an infinite interval, it will throw after 10,000 tries (can be configured with [`fakeTimers.loopLimit`](https://vitest.dev/config/#faketimers-looplimit)).
+     */
+    runAllTimers: () => VitestUtils;
+    /**
+     * This method will asynchronously invoke every initiated timer until the timer queue is empty. It means that every timer called during `runAllTimersAsync` will be fired even asynchronous timers.
+     * If you have an infinite interval, it will throw after 10 000 tries (can be configured with [`fakeTimers.loopLimit`](https://vitest.dev/config/#faketimers-looplimit)).
+     */
+    runAllTimersAsync: () => Promise<VitestUtils>;
+    /**
+     * Calls every microtask that was queued by `process.nextTick`. This will also run all microtasks scheduled by themselves.
+     */
+    runAllTicks: () => VitestUtils;
+    /**
+     * This method will invoke every initiated timer until the specified number of milliseconds is passed or the queue is empty - whatever comes first.
+     */
+    advanceTimersByTime: (ms: number) => VitestUtils;
+    /**
+     * This method will invoke every initiated timer until the specified number of milliseconds is passed or the queue is empty - whatever comes first. This will include and await asynchronously set timers.
+     */
+    advanceTimersByTimeAsync: (ms: number) => Promise<VitestUtils>;
+    /**
+     * Will call next available timer. Useful to make assertions between each timer call. You can chain call it to manage timers by yourself.
+     */
+    advanceTimersToNextTimer: () => VitestUtils;
+    /**
+     * Will call next available timer and wait until it's resolved if it was set asynchronously. Useful to make assertions between each timer call.
+     */
+    advanceTimersToNextTimerAsync: () => Promise<VitestUtils>;
+    /**
+     * Similar to [`vi.advanceTimersByTime`](https://vitest.dev/api/vi#vi-advancetimersbytime), but will advance timers by the milliseconds needed to execute callbacks currently scheduled with `requestAnimationFrame`.
+     */
+    advanceTimersToNextFrame: () => VitestUtils;
+    /**
+     * Get the number of waiting timers.
+     */
+    getTimerCount: () => number;
+    /**
+     * If fake timers are enabled, this method simulates a user changing the system clock (will affect date related API like `hrtime`, `performance.now` or `new Date()`) - however, it will not fire any timers.
+     * If fake timers are not enabled, this method will only mock `Date.*` and `new Date()` calls.
+     */
+    setSystemTime: (time: number | string | Date) => VitestUtils;
+    /**
+     * Returns mocked current date that was set using `setSystemTime`. If date is not mocked the method will return `null`.
+     */
+    getMockedSystemTime: () => Date | null;
+    /**
+     * When using `vi.useFakeTimers`, `Date.now` calls are mocked. If you need to get real time in milliseconds, you can call this function.
+     */
+    getRealSystemTime: () => number;
+    /**
+     * Removes all timers that are scheduled to run. These timers will never run in the future.
+     */
+    clearAllTimers: () => VitestUtils;
+    /**
+     * Creates a spy on a method or getter/setter of an object similar to [`vi.fn()`](https://vitest.dev/api/vi#vi-fn). It returns a [mock function](https://vitest.dev/api/mock).
+     * @example
+     * ```ts
+     * const cart = {
+     *   getApples: () => 42
+     * }
+     *
+     * const spy = vi.spyOn(cart, 'getApples').mockReturnValue(10)
+     *
+     * expect(cart.getApples()).toBe(10)
+     * expect(spy).toHaveBeenCalled()
+     * expect(spy).toHaveReturnedWith(10)
+     * ```
+     */
+    spyOn: typeof spyOn;
+    /**
+     * Creates a spy on a function, though can be initiated without one. Every time a function is invoked, it stores its call arguments, returns, and instances. Also, you can manipulate its behavior with [methods](https://vitest.dev/api/mock).
+     *
+     * If no function is given, mock will return `undefined`, when invoked.
+     * @example
+     * ```ts
+     * const getApples = vi.fn(() => 0)
+     *
+     * getApples()
+     *
+     * expect(getApples).toHaveBeenCalled()
+     * expect(getApples).toHaveReturnedWith(0)
+     *
+     * getApples.mockReturnValueOnce(5)
+     *
+     * expect(getApples()).toBe(5)
+     * expect(getApples).toHaveNthReturnedWith(2, 5)
+     * ```
+     */
+    fn: typeof fn;
+    /**
+     * Wait for the callback to execute successfully. If the callback throws an error or returns a rejected promise it will continue to wait until it succeeds or times out.
+     *
+     * This is very useful when you need to wait for some asynchronous action to complete, for example, when you start a server and need to wait for it to start.
+     * @example
+     * ```ts
+     * const server = createServer()
+     *
+     * await vi.waitFor(
+     *   () => {
+     *     if (!server.isReady)
+     *       throw new Error('Server not started')
+     *
+     *     console.log('Server started')
+     *   }, {
+     *     timeout: 500, // default is 1000
+     *     interval: 20, // default is 50
+     *   }
+     * )
+     * ```
+     */
+    waitFor: typeof waitFor;
+    /**
+     * This is similar to [`vi.waitFor`](https://vitest.dev/api/vi#vi-waitfor), but if the callback throws any errors, execution is immediately interrupted and an error message is received.
+     *
+     * If the callback returns a falsy value, the next check will continue until a truthy value is returned. This is useful when you need to wait for something to exist before taking the next step.
+     * @example
+     * ```ts
+     * const element = await vi.waitUntil(
+     *   () => document.querySelector('.element'),
+     *   {
+     *     timeout: 500, // default is 1000
+     *     interval: 20, // default is 50
+     *   }
+     * )
+     *
+     * // do something with the element
+     * expect(element.querySelector('.element-child')).toBeTruthy()
+     * ```
+     */
+    waitUntil: typeof waitUntil;
+    /**
+     * Run the factory before imports are evaluated. You can return a value from the factory
+     * to reuse it inside your [`vi.mock`](https://vitest.dev/api/vi#vi-mock) factory and tests.
+     *
+     * If used with [`vi.mock`](https://vitest.dev/api/vi#vi-mock), both will be hoisted in the order they are defined in.
+     */
+    hoisted: <T>(factory: () => T) => T;
+    /**
+     * Mocks every import call to the module even if it was already statically imported.
+     *
+     * The call to `vi.mock` is hoisted to the top of the file, so you don't have access to variables declared in the global file scope
+     * unless they are defined with [`vi.hoisted`](https://vitest.dev/api/vi#vi-hoisted) before this call.
+     *
+     * Mocking algorithm is described in [documentation](https://vitest.dev/guide/mocking#modules).
+     * @param path Path to the module. Can be aliased, if your Vitest config supports it
+     * @param factory Mocked module factory. The result of this function will be an exports object
+     */
+    mock(path: string, factory?: MockFactoryWithHelper | MockOptions): void;
+    mock<T>(module: Promise<T>, factory?: MockFactoryWithHelper<T> | MockOptions): void;
+    /**
+     * Removes module from mocked registry. All calls to import will return the original module even if it was mocked before.
+     *
+     * This call is hoisted to the top of the file, so it will only unmock modules that were defined in `setupFiles`, for example.
+     * @param path Path to the module. Can be aliased, if your Vitest config supports it
+     */
+    unmock(path: string): void;
+    unmock(module: Promise<unknown>): void;
+    /**
+     * Mocks every subsequent [dynamic import](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/import) call.
+     *
+     * Unlike [`vi.mock`](https://vitest.dev/api/vi#vi-mock), this method will not mock statically imported modules because it is not hoisted to the top of the file.
+     *
+     * Mocking algorithm is described in [documentation](https://vitest.dev/guide/mocking#modules).
+     * @param path Path to the module. Can be aliased, if your Vitest config supports it
+     * @param factory Mocked module factory. The result of this function will be an exports object
+     */
+    doMock(path: string, factory?: MockFactoryWithHelper | MockOptions): void;
+    doMock<T>(module: Promise<T>, factory?: MockFactoryWithHelper<T> | MockOptions): void;
+    /**
+     * Removes module from mocked registry. All subsequent calls to import will return original module.
+     *
+     * Unlike [`vi.unmock`](https://vitest.dev/api/vi#vi-unmock), this method is not hoisted to the top of the file.
+     * @param path Path to the module. Can be aliased, if your Vitest config supports it
+     */
+    doUnmock(path: string): void;
+    doUnmock(module: Promise<unknown>): void;
+    /**
+     * Imports module, bypassing all checks if it should be mocked.
+     * Can be useful if you want to mock module partially.
+     * @example
+     * ```ts
+     * vi.mock('./example.js', async () => {
+     *  const axios = await vi.importActual<typeof import('./example.js')>('./example.js')
+     *
+     *  return { ...axios, get: vi.fn() }
+     * })
+     * ```
+     * @param path Path to the module. Can be aliased, if your config supports it
+     */
+    importActual: <T = ESModuleExports>(path: string) => Promise<T>;
+    /**
+     * Imports a module with all of its properties and nested properties mocked.
+     *
+     * Mocking algorithm is described in [documentation](https://vitest.dev/guide/mocking#modules).
+     * @example
+     * ```ts
+     * const example = await vi.importMock<typeof import('./example.js')>('./example.js')
+     * example.calc.mockReturnValue(10)
+     * expect(example.calc()).toBe(10)
+     * ```
+     * @param path Path to the module. Can be aliased, if your config supports it
+     * @returns Fully mocked module
+     */
+    importMock: <T = ESModuleExports>(path: string) => Promise<MaybeMockedDeep<T>>;
+    /**
+     * Type helper for TypeScript. Just returns the object that was passed.
+     *
+     * When `partial` is `true` it will expect a `Partial<T>` as a return value. By default, this will only make TypeScript believe that
+     * the first level values are mocked. You can pass down `{ deep: true }` as a second argument to tell TypeScript that the whole object is mocked, if it actually is.
+     * @example
+     * ```ts
+     * import example from './example.js'
+     * vi.mock('./example.js')
+     *
+     * test('1 + 1 equals 10' async () => {
+     *  vi.mocked(example.calc).mockReturnValue(10)
+     *  expect(example.calc(1, '+', 1)).toBe(10)
+     * })
+     * ```
+     * @param item Anything that can be mocked
+     * @param deep If the object is deeply mocked
+     * @param options If the object is partially or deeply mocked
+     */
+    mocked: (<T>(item: T, deep?: false) => MaybeMocked<T>) & (<T>(item: T, deep: true) => MaybeMockedDeep<T>) & (<T>(item: T, options: {
+        partial?: false;
+        deep?: false;
+    }) => MaybeMocked<T>) & (<T>(item: T, options: {
+        partial?: false;
+        deep: true;
+    }) => MaybeMockedDeep<T>) & (<T>(item: T, options: {
+        partial: true;
+        deep?: false;
+    }) => MaybePartiallyMocked<T>) & (<T>(item: T, options: {
+        partial: true;
+        deep: true;
+    }) => MaybePartiallyMockedDeep<T>) & (<T>(item: T) => MaybeMocked<T>);
+    /**
+     * Checks that a given parameter is a mock function. If you are using TypeScript, it will also narrow down its type.
+     */
+    isMockFunction: (fn: any) => fn is MockInstance;
+    /**
+     * Calls [`.mockClear()`](https://vitest.dev/api/mock#mockclear) on every mocked function. This will only empty `.mock` state, it will not reset implementation.
+     *
+     * It is useful if you need to clean up mock between different assertions.
+     */
+    clearAllMocks: () => VitestUtils;
+    /**
+     * Calls [`.mockReset()`](https://vitest.dev/api/mock#mockreset) on every mocked function. This will empty `.mock` state, reset "once" implementations and force the base implementation to return `undefined` when invoked.
+     *
+     * This is useful when you want to completely reset a mock to the default state.
+     */
+    resetAllMocks: () => VitestUtils;
+    /**
+     * Calls [`.mockRestore()`](https://vitest.dev/api/mock#mockrestore) on every mocked function. This will restore all original implementations.
+     */
+    restoreAllMocks: () => VitestUtils;
+    /**
+     * Makes value available on global namespace.
+     * Useful, if you want to have global variables available, like `IntersectionObserver`.
+     * You can return it back to original value with `vi.unstubAllGlobals`, or by enabling `unstubGlobals` config option.
+     */
+    stubGlobal: (name: string | symbol | number, value: unknown) => VitestUtils;
+    /**
+     * Changes the value of `import.meta.env` and `process.env`.
+     * You can return it back to original value with `vi.unstubAllEnvs`, or by enabling `unstubEnvs` config option.
+     */
+    stubEnv: <T extends string>(name: T, value: T extends 'PROD' | 'DEV' | 'SSR' ? boolean : string | undefined) => VitestUtils;
+    /**
+     * Reset the value to original value that was available before first `vi.stubGlobal` was called.
+     */
+    unstubAllGlobals: () => VitestUtils;
+    /**
+     * Reset environmental variables to the ones that were available before first `vi.stubEnv` was called.
+     */
+    unstubAllEnvs: () => VitestUtils;
+    /**
+     * Resets modules registry by clearing the cache of all modules. This allows modules to be reevaluated when reimported.
+     * Top-level imports cannot be re-evaluated. Might be useful to isolate modules where local state conflicts between tests.
+     *
+     * This method does not reset mocks registry. To clear mocks registry, use [`vi.unmock`](https://vitest.dev/api/vi#vi-unmock) or [`vi.doUnmock`](https://vitest.dev/api/vi#vi-dounmock).
+     */
+    resetModules: () => VitestUtils;
+    /**
+     * Wait for all imports to load. Useful, if you have a synchronous call that starts
+     * importing a module that you cannot await otherwise.
+     * Will also wait for new imports, started during the wait.
+     */
+    dynamicImportSettled: () => Promise<void>;
+    /**
+     * Updates runtime config. You can only change values that are used when executing tests.
+     */
+    setConfig: (config: RuntimeOptions) => void;
+    /**
+     * If config was changed with `vi.setConfig`, this will reset it to the original state.
+     */
+    resetConfig: () => void;
+}
+declare const vitest: VitestUtils;
+declare const vi: VitestUtils;
+
+interface AssertType {
+    <T>(value: T): void;
+}
+declare const assertType: AssertType;
+
+interface BrowserUI {
+    setCurrentFileId: (fileId: string) => void;
+    setIframeViewport: (width: number, height: number) => Promise<void>;
+}
+
+/** @deprecated import `TypeCheckRawErrorsMap` from `vitest/node` instead */
+type RawErrsMap = RawErrsMap$1;
+/** @deprecated import `TypeCheckErrorInfo` from `vitest/node` instead */
+type TscErrorInfo = TscErrorInfo$1;
+/** @deprecated import `TypeCheckCollectLineNumbers` from `vitest/node` instead */
+type CollectLineNumbers = CollectLineNumbers$1;
+/** @deprecated import `TypeCheckCollectLines` from `vitest/node` instead */
+type CollectLines = CollectLines$1;
+/** @deprecated import `TypeCheckRootAndTarget` from `vitest/node` instead */
+type RootAndTarget = RootAndTarget$1;
+/** @deprecated import `TypeCheckContext` from `vitest/node` instead */
+type Context = Context$1;
+/** @deprecated use `RunnerTestSuite` instead */
+type Suite = Suite$1;
+/** @deprecated use `RunnerTestFile` instead */
+type File = File$1;
+/** @deprecated use `RunnerTestCase` instead */
+type Test = Test$1;
+/** @deprecated use `RunnerCustomCase` instead */
+type Custom = Custom$1;
+/** @deprecated use `RunnerTask` instead */
+type Task = Task$1;
+/** @deprecated use `RunnerTaskBase` instead */
+type TaskBase = TaskBase$1;
+/** @deprecated use `RunnerTaskResult` instead */
+type TaskResult = TaskResult$1;
+/** @deprecated use `RunnerTaskResultPack` instead */
+type TaskResultPack = TaskResultPack$1;
+/** @deprecated don't use `DoneCallback` since it's not supported */
+type DoneCallback = DoneCallback$1;
+/** @deprecated internal type, don't use it */
+type RuntimeContext = RuntimeContext$1;
+/** @deprecated internal type, don't use it */
+type SuiteHooks = SuiteHooks$1;
+
+/** @deprecated import from `vitest/node` instead */
+type WorkerContext = WorkerContext$1;
+/** @deprecated import from `vitest/node` instead */
+type WorkerRPC = WorkerRPC$1;
+
+/** @deprecated do not use, internal helper */
+type Awaitable<T> = Awaitable$1<T>;
+/** @deprecated do not use, internal helper */
+type Nullable<T> = Nullable$1<T>;
+/** @deprecated do not use, internal helper */
+type Arrayable<T> = Arrayable$1<T>;
+/** @deprecated do not use, internal helper */
+type ArgumentsType<T> = ArgumentsType$1<T>;
+/** @deprecated do not use, internal helper */
+type MutableArray<T extends readonly any[]> = MutableArray$1<T>;
+/** @deprecated do not use, internal helper */
+type Constructable = Constructable$1;
+/** @deprecated import from `vitest/node` instead */
+type OnServerRestartHandler = OnServerRestartHandler$1;
+
+/** @deprecated import from `vitest/environments` instead */
+type EnvironmentReturn = EnvironmentReturn$1;
+/** @deprecated import from `vitest/environments` instead */
+type VmEnvironmentReturn = VmEnvironmentReturn$1;
+/** @deprecated import from `vitest/environments` instead */
+type Environment = Environment$1;
+/** @deprecated do not use it */
+type ResolvedTestEnvironment = ResolvedTestEnvironment$1;
+/** @deprecated import from `vitest/node` instead */
+type CoverageProvider = CoverageProvider$1;
+/** @deprecated import from `vitest/node` instead */
+type ReportContext = ReportContext$1;
+/** @deprecated import from `vitest/node` instead */
+type CoverageProviderModule = CoverageProviderModule$1;
+/** @deprecated import from `vitest/node` instead */
+type CoverageReporter = CoverageReporter$1;
+/** @deprecated import from `vitest/node` instead */
+type CoverageOptions<T extends CoverageProviderName = CoverageProviderName> = CoverageOptions$1<T>;
+/** @deprecated import from `vitest/node` instead */
+type ResolvedCoverageOptions<T extends CoverageProviderName = CoverageProviderName> = ResolvedCoverageOptions$1<T>;
+/** @deprecated import from `vitest/node` instead */
+type BaseCoverageOptions = BaseCoverageOptions$1;
+/** @deprecated import from `vitest/node` instead */
+type CoverageIstanbulOptions = CoverageIstanbulOptions$1;
+/** @deprecated import from `vitest/node` instead */
+type CoverageV8Options = CoverageV8Options$1;
+/** @deprecated import from `vitest/node` instead */
+type CustomProviderOptions = CustomProviderOptions$1;
+
+/** @deprecated import from `vitest/reporter` instead */
+type Reporter = Reporter$1;
+/** @deprecated import from `vitest/node` instead */
+type Vitest = Vitest$1;
+
+/** @deprecated import from `vitest/node` instead */
+type BrowserScript = BrowserScript$1;
+/** @deprecated import from `vitest/node` instead */
+type BrowserConfigOptions = BrowserConfigOptions$1;
+/** @deprecated import from `vitest/node` instead */
+type SequenceHooks = SequenceHooks$1;
+/** @deprecated import from `vitest/node` instead */
+type SequenceSetupFiles = SequenceSetupFiles$1;
+/** @deprecated import from `vitest/node` instead */
+type BuiltinEnvironment = BuiltinEnvironment$1;
+/** @deprecated import from `vitest/node` instead */
+type VitestEnvironment = VitestEnvironment$1;
+/** @deprecated import from `vitest/node` instead */
+type Pool = Pool$1;
+/** @deprecated import from `vitest/node` instead */
+type PoolOptions = PoolOptions$1;
+/** @deprecated import from `vitest/node` instead */
+type CSSModuleScopeStrategy = CSSModuleScopeStrategy$1;
+/** @deprecated import from `vitest/node` instead */
+type ApiConfig = ApiConfig$1;
+/** @deprecated import from `vitest/node` instead */
+type JSDOMOptions = JSDOMOptions$1;
+/** @deprecated import from `vitest/node` instead */
+type HappyDOMOptions = HappyDOMOptions$1;
+/** @deprecated import from `vitest/node` instead */
+type EnvironmentOptions = EnvironmentOptions$1;
+/** @deprecated import from `vitest/node` instead */
+type VitestRunMode = VitestRunMode$1;
+/** @deprecated import from `vitest/node` instead */
+type DepsOptimizationOptions = DepsOptimizationOptions$1;
+/** @deprecated import from `vitest/node` instead */
+type TransformModePatterns = TransformModePatterns$1;
+/** @deprecated import from `vitest/node` instead */
+type InlineConfig = InlineConfig$1;
+/** @deprecated import from `vitest/node` instead */
+type TypecheckConfig = TypecheckConfig$1;
+/** @deprecated import from `vitest/node` instead */
+type UserConfig = UserConfig$1;
+/** @deprecated import from `vitest/node` instead */
+type ResolvedConfig = ResolvedConfig$1;
+/** @deprecated import from `vitest/node` instead */
+type ProjectConfig = ProjectConfig$1;
+/** @deprecated import from `vitest/node` instead */
+type UserWorkspaceConfig = UserWorkspaceConfig$1;
+
+/** @deprecated use `SerializedTestSpecification` instead */
+type SerializableSpec = SerializedTestSpecification;
+
+/** @deprecated import from `vitest/node` instead */
+type BenchmarkUserOptions = BenchmarkUserOptions$1;
+
+export { type ApiConfig, type ArgumentsType, type Arrayable, type AssertType, type Awaitable, type BaseCoverageOptions, BenchmarkResult, type BenchmarkUserOptions, type BrowserConfigOptions, type BrowserScript, type BrowserUI, type BuiltinEnvironment, type CSSModuleScopeStrategy, type CollectLineNumbers, type CollectLines, type Constructable, type Context, type CoverageIstanbulOptions, type CoverageOptions, type CoverageProvider, type CoverageProviderModule, type CoverageReporter, type CoverageV8Options, type Custom, type CustomProviderOptions, type DepsOptimizationOptions, type DoneCallback, type Environment, type EnvironmentOptions, type EnvironmentReturn, type File, type HappyDOMOptions, type InlineConfig, type JSDOMOptions, ModuleGraphData, type MutableArray, type Nullable, type OnServerRestartHandler, type Pool, type PoolOptions, type ProjectConfig, ProvidedContext, type RawErrsMap, type ReportContext, type Reporter, type ResolvedConfig, type ResolvedCoverageOptions, type ResolvedTestEnvironment, type RootAndTarget, type RuntimeContext, type SequenceHooks, type SequenceSetupFiles, type SerializableSpec, SerializedConfig, SerializedTestSpecification, type Suite, type SuiteHooks, type Task, type TaskBase, type TaskResult, type TaskResultPack, type Test, type TransformModePatterns, type TransformResultWithSource, type TscErrorInfo, type TypecheckConfig, type UserConfig, UserConsoleLog, type UserWorkspaceConfig, type Vitest, type VitestEnvironment, type VitestRunMode, type VitestUtils, type VmEnvironmentReturn, type WebSocketEvents, type WebSocketHandlers, type WebSocketRPC, type WorkerContext, type WorkerRPC, assertType, createExpect, globalExpect as expect, getRunningMode, inject, isFirstRun, isWatchMode, runOnce, vi, vitest };

pwa/node_modules/vitest/dist/index.js

@@ -0,0 +1,19 @@
+export { c as createExpect, a as expect, v as vi, b as vitest } from './chunks/vi.DgezovHB.js';
+export { b as assertType, g as getRunningMode, i as inject, a as isWatchMode } from './chunks/index.ckWaX2gY.js';
+export { i as isFirstRun, a as runOnce } from './chunks/run-once.2ogXb3JV.js';
+export { b as bench } from './chunks/benchmark.Cdu9hjj4.js';
+export { expectTypeOf } from 'expect-type';
+export { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
+import * as chai from 'chai';
+export { chai };
+export { assert, should } from 'chai';
+import '@vitest/expect';
+import '@vitest/runner/utils';
+import './chunks/utils.C8RiOc4B.js';
+import '@vitest/utils';
+import './chunks/_commonjsHelpers.BFTU3MAI.js';
+import '@vitest/snapshot';
+import '@vitest/utils/error';
+import '@vitest/utils/source-map';
+import './chunks/date.W2xKR2qe.js';
+import '@vitest/spy';

pwa/node_modules/vitest/dist/mocker.d.ts

@@ -0,0 +1 @@
+export * from '@vitest/mocker';

pwa/node_modules/vitest/dist/mocker.js

@@ -0,0 +1 @@
+export * from '@vitest/mocker';

pwa/node_modules/vitest/dist/node.d.ts

@@ -0,0 +1,125 @@
+import { E as ResolvedConfig, w as VitestRunMode, H as VitestOptions, V as Vitest, z as UserConfig$1, A as ApiConfig, L as Logger, J as WorkspaceProject, K as TestSequencer, M as WorkspaceSpec, N as TestModule, O as ModuleDiagnostic } from './chunks/reporters.nr4dxCkA.js';
+export { B as BaseCoverageOptions, G as BenchmarkUserOptions, ad as BrowserBuiltinProvider, ae as BrowserCommand, af as BrowserCommandContext, s as BrowserConfigOptions, ag as BrowserOrchestrator, ah as BrowserProvider, ai as BrowserProviderInitializationOptions, aj as BrowserProviderModule, ak as BrowserProviderOptions, r as BrowserScript, al as BrowserServer, am as BrowserServerState, an as BrowserServerStateContext, t as BuiltinEnvironment, ao as CDPSession, v as CSSModuleScopeStrategy, o as CoverageIstanbulOptions, n as CoverageOptions, C as CoverageProvider, b as CoverageProviderModule, l as CoverageReporter, c as CoverageV8Options, p as CustomProviderOptions, D as DepsOptimizationOptions, $ as HTMLOptions, I as InlineConfig, a1 as JUnitOptions, a0 as JsonOptions, P as Pool, u as PoolOptions, X as ProcessPool, F as ProjectConfig, a as ReportContext, ap as ResolvedBrowserOptions, R as ResolvedCoverageOptions, aq as ResolvedProjectConfig, _ as SerializedTestProject, a4 as TaskOptions, a2 as TestCase, a5 as TestCollection, a6 as TestDiagnostic, Z as TestProject, a7 as TestResult, a8 as TestResultFailed, a9 as TestResultPassed, aa as TestResultSkipped, ab as TestSequencerConstructor, ac as TestSpecification, a3 as TestSuite, x as TransformModePatterns, h as TypeCheckCollectLineNumbers, i as TypeCheckCollectLines, k as TypeCheckContext, T as TypeCheckErrorInfo, g as TypeCheckRawErrorsMap, j as TypeCheckRootAndTarget, y as TypecheckConfig, U as UserWorkspaceConfig, f as VitestEnvironment, Q as VitestPackageInstaller, Y as getFilePoolName } from './chunks/reporters.nr4dxCkA.js';
+import { UserConfig, ResolvedConfig as ResolvedConfig$1, Plugin, LogLevel, LoggerOptions, Logger as Logger$1, createServer as createServer$1 } from 'vite';
+import * as vite from 'vite';
+export { vite as Vite };
+export { isFileServingAllowed, parseAst, parseAstAsync } from 'vite';
+import { IncomingMessage } from 'node:http';
+import { P as ProvidedContext } from './chunks/environment.LoooBwUu.js';
+export { f as EnvironmentOptions, H as HappyDOMOptions, J as JSDOMOptions, O as OnServerRestartHandler } from './chunks/environment.LoooBwUu.js';
+import { R as RuntimeRPC } from './chunks/worker.tN5KGIih.js';
+import { Writable } from 'node:stream';
+export { W as WorkerContext } from './chunks/worker.B9FxPCaC.js';
+import createDebug from 'debug';
+export { b as RuntimeConfig } from './chunks/config.Cy0C388Z.js';
+export { SequenceHooks, SequenceSetupFiles } from '@vitest/runner';
+import '@vitest/utils';
+import '@vitest/pretty-format';
+import '@vitest/snapshot';
+import 'vite-node';
+import 'chai';
+import '@vitest/utils/source-map';
+import 'vite-node/client';
+import 'vite-node/server';
+import './chunks/benchmark.geERunq4.js';
+import '@vitest/runner/utils';
+import 'tinybench';
+import '@vitest/snapshot/manager';
+import 'node:fs';
+import 'node:worker_threads';
+import '@vitest/snapshot/environment';
+
+declare function isValidApiRequest(config: ResolvedConfig, req: IncomingMessage): boolean;
+
+interface CliOptions extends UserConfig$1 {
+    /**
+     * Override the watch mode
+     */
+    run?: boolean;
+    /**
+     * Removes colors from the console output
+     */
+    color?: boolean;
+    /**
+     * Output collected tests as JSON or to a file
+     */
+    json?: string | boolean;
+    /**
+     * Output collected test files only
+     */
+    filesOnly?: boolean;
+}
+/**
+ * Start Vitest programmatically
+ *
+ * Returns a Vitest instance if initialized successfully.
+ */
+declare function startVitest(mode: VitestRunMode, cliFilters?: string[], options?: CliOptions, viteOverrides?: UserConfig, vitestOptions?: VitestOptions): Promise<Vitest | undefined>;
+
+interface CLIOptions {
+    allowUnknownOptions?: boolean;
+}
+declare function parseCLI(argv: string | string[], config?: CLIOptions): {
+    filter: string[];
+    options: CliOptions;
+};
+
+declare function resolveApiServerConfig<Options extends ApiConfig & UserConfig$1>(options: Options, defaultPort: number): ApiConfig | undefined;
+declare function resolveConfig(mode: VitestRunMode, options: UserConfig$1, viteConfig: ResolvedConfig$1, logger: Logger): ResolvedConfig;
+
+declare function createVitest(mode: VitestRunMode, options: UserConfig$1, viteOverrides?: UserConfig, vitestOptions?: VitestOptions): Promise<Vitest>;
+
+declare class FilesNotFoundError extends Error {
+    code: string;
+    constructor(mode: 'test' | 'benchmark');
+}
+declare class GitNotFoundError extends Error {
+    code: string;
+    constructor();
+}
+
+interface GlobalSetupContext {
+    config: ResolvedConfig;
+    provide: <T extends keyof ProvidedContext & string>(key: T, value: ProvidedContext[T]) => void;
+}
+
+declare function VitestPlugin(options?: UserConfig$1, ctx?: Vitest): Promise<Plugin[]>;
+
+declare function resolveFsAllow(projectRoot: string, rootConfigFile: string | false | undefined): string[];
+
+interface MethodsOptions {
+    cacheFs?: boolean;
+}
+declare function createMethodsRPC(project: WorkspaceProject, options?: MethodsOptions): RuntimeRPC;
+
+declare class BaseSequencer implements TestSequencer {
+    protected ctx: Vitest;
+    constructor(ctx: Vitest);
+    shard(files: WorkspaceSpec[]): Promise<WorkspaceSpec[]>;
+    sort(files: WorkspaceSpec[]): Promise<WorkspaceSpec[]>;
+}
+
+declare function registerConsoleShortcuts(ctx: Vitest, stdin: NodeJS.ReadStream | undefined, stdout: NodeJS.WriteStream | Writable): () => void;
+
+declare function createViteLogger(console: Logger, level?: LogLevel, options?: LoggerOptions): Logger$1;
+
+declare const rootDir: string;
+declare const distDir: string;
+
+declare function createDebugger(namespace: `vitest:${string}`): createDebug.Debugger | undefined;
+
+/** @deprecated use `createViteServer` instead */
+declare const createServer: typeof createServer$1;
+declare const createViteServer: typeof createServer$1;
+
+/**
+ * @deprecated Use `TestModule` instead
+ */
+declare const TestFile: typeof TestModule;
+
+/**
+ * @deprecated Use `ModuleDiagnostic` instead
+ */
+type FileDiagnostic = ModuleDiagnostic;
+
+export { ApiConfig, BaseSequencer, type FileDiagnostic, GitNotFoundError, type GlobalSetupContext, ModuleDiagnostic, ResolvedConfig, TestFile, TestModule, TestSequencer, FilesNotFoundError as TestsNotFoundError, UserConfig$1 as UserConfig, Vitest, VitestPlugin, VitestRunMode, WorkspaceProject, WorkspaceSpec, createDebugger, createMethodsRPC, createServer, createViteLogger, createViteServer, createVitest, distDir, isValidApiRequest, parseCLI, registerConsoleShortcuts, resolveApiServerConfig, resolveConfig, resolveFsAllow, rootDir, startVitest };

pwa/node_modules/vitest/dist/node.js

@@ -0,0 +1,76 @@
+import { createServer as createServer$1 } from 'vite';
+export { isFileServingAllowed, parseAst, parseAstAsync } from 'vite';
+import { f as TestModule } from './chunks/index.DsZFoqi9.js';
+export { e as TestCase, i as TestProject, g as TestSuite } from './chunks/index.DsZFoqi9.js';
+export { G as GitNotFoundError, T as TestSpecification, F as TestsNotFoundError, V as VitestPackageInstaller, a as VitestPlugin, d as createViteLogger, c as createVitest, i as isValidApiRequest, b as registerConsoleShortcuts, r as resolveFsAllow, s as startVitest } from './chunks/cli-api.DqsSTaIi.js';
+export { p as parseCLI } from './chunks/cac.CB_9Zo9Q.js';
+export { d as createMethodsRPC, g as getFilePoolName, a as resolveApiServerConfig, b as resolveConfig } from './chunks/resolveConfig.rBxzbVsl.js';
+export { B as BaseSequencer } from './chunks/RandomSequencer.CMRlh2v4.js';
+export { distDir, rootDir } from './path.js';
+import createDebug from 'debug';
+import 'node:fs';
+import '@vitest/runner/utils';
+import 'pathe';
+import 'tinyrainbow';
+import './chunks/utils.DNoFbBUZ.js';
+import 'node:util';
+import '@vitest/utils';
+import 'node:perf_hooks';
+import '@vitest/utils/source-map';
+import 'std-env';
+import 'node:fs/promises';
+import 'node:stream';
+import 'node:console';
+import 'node:process';
+import './chunks/_commonjsHelpers.BFTU3MAI.js';
+import 'assert';
+import 'events';
+import 'node:module';
+import 'node:os';
+import './chunks/coverage.BoMDb1ip.js';
+import 'node:path';
+import './chunks/index.BJDntFik.js';
+import 'node:url';
+import 'readline';
+import './chunks/constants.fzPh7AOq.js';
+import '@vitest/snapshot/manager';
+import 'vite-node/client';
+import 'vite-node/server';
+import './chunks/index.68735LiX.js';
+import 'stream';
+import 'zlib';
+import 'buffer';
+import 'crypto';
+import 'https';
+import 'http';
+import 'net';
+import 'tls';
+import 'url';
+import 'node:crypto';
+import 'os';
+import 'path';
+import 'fs';
+import 'vite-node/utils';
+import '@vitest/mocker/node';
+import 'magic-string';
+import 'node:readline';
+import 'node:assert';
+import 'node:v8';
+import 'util';
+import 'node:events';
+import 'tinypool';
+import 'node:worker_threads';
+import 'tinyexec';
+
+function createDebugger(namespace) {
+  const debug = createDebug(namespace);
+  if (debug.enabled) {
+    return debug;
+  }
+}
+
+const createServer = createServer$1;
+const createViteServer = createServer$1;
+const TestFile = TestModule;
+
+export { TestFile, TestModule, createDebugger, createServer, createViteServer };

pwa/node_modules/vitest/dist/path.js

@@ -0,0 +1,10 @@
+import { resolve } from 'node:path';
+import url from 'node:url';
+
+const rootDir = resolve(url.fileURLToPath(import.meta.url), "../../");
+const distDir = resolve(
+  url.fileURLToPath(import.meta.url),
+  "../../dist"
+);
+
+export { distDir, rootDir };

pwa/node_modules/vitest/dist/reporters.d.ts

@@ -0,0 +1,20 @@
+export { aB as BaseReporter, ar as BasicReporter, aL as BenchmarkBuiltinReporters, aK as BenchmarkReportsMap, aG as BuiltinReporterOptions, aF as BuiltinReporters, as as DefaultReporter, at as DotReporter, aD as FileDiagnostic, au as GithubActionsReporter, av as HangingProcessReporter, ax as JUnitReporter, aH as JsonAssertionResult, aw as JsonReporter, aI as JsonTestResult, aJ as JsonTestResults, q as Reporter, aE as ReportersMap, ay as TapFlatReporter, az as TapReporter, a4 as TaskOptions, a2 as TestCase, a5 as TestCollection, a6 as TestDiagnostic, aC as TestFile, N as TestModule, Z as TestProject, a7 as TestResult, a8 as TestResultFailed, a9 as TestResultPassed, aa as TestResultSkipped, a3 as TestSuite, aA as VerboseReporter } from './chunks/reporters.nr4dxCkA.js';
+import '@vitest/runner';
+import './chunks/environment.LoooBwUu.js';
+import 'node:stream';
+import 'vite';
+import '@vitest/utils';
+import './chunks/config.Cy0C388Z.js';
+import '@vitest/pretty-format';
+import '@vitest/snapshot';
+import '@vitest/snapshot/environment';
+import 'vite-node';
+import 'chai';
+import '@vitest/utils/source-map';
+import 'vite-node/client';
+import 'vite-node/server';
+import './chunks/benchmark.geERunq4.js';
+import '@vitest/runner/utils';
+import 'tinybench';
+import '@vitest/snapshot/manager';
+import 'node:fs';

pwa/node_modules/vitest/dist/reporters.js

@@ -0,0 +1,28 @@
+export { B as BasicReporter, h as BenchmarkReportsMap, D as DefaultReporter, a as DotReporter, G as GithubActionsReporter, H as HangingProcessReporter, b as JUnitReporter, J as JsonReporter, R as ReportersMap, T as TapFlatReporter, c as TapReporter, e as TestCase, d as TestFile, f as TestModule, g as TestSuite, V as VerboseReporter } from './chunks/index.DsZFoqi9.js';
+import 'node:fs';
+import '@vitest/runner/utils';
+import 'pathe';
+import 'tinyrainbow';
+import './chunks/utils.DNoFbBUZ.js';
+import 'node:util';
+import '@vitest/utils';
+import 'node:perf_hooks';
+import '@vitest/utils/source-map';
+import './chunks/RandomSequencer.CMRlh2v4.js';
+import 'std-env';
+import 'node:fs/promises';
+import 'tinyexec';
+import 'vite';
+import 'node:os';
+import 'node:url';
+import 'node:path';
+import 'node:module';
+import 'fs';
+import 'vite-node/utils';
+import 'node:crypto';
+import 'node:stream';
+import 'node:console';
+import 'node:process';
+import './chunks/_commonjsHelpers.BFTU3MAI.js';
+import 'assert';
+import 'events';

pwa/node_modules/vitest/dist/runners.d.ts

@@ -0,0 +1,41 @@
+import * as tinybench from 'tinybench';
+import { VitestRunner, VitestRunnerImportSource, Suite, File, Task, CancelReason, Test, Custom, TaskContext, ExtendedContext } from '@vitest/runner';
+import { S as SerializedConfig } from './chunks/config.Cy0C388Z.js';
+import '@vitest/pretty-format';
+import '@vitest/snapshot';
+import '@vitest/snapshot/environment';
+
+declare class NodeBenchmarkRunner implements VitestRunner {
+    config: SerializedConfig;
+    private __vitest_executor;
+    constructor(config: SerializedConfig);
+    importTinybench(): Promise<typeof tinybench>;
+    importFile(filepath: string, source: VitestRunnerImportSource): unknown;
+    runSuite(suite: Suite): Promise<void>;
+    runTask(): Promise<void>;
+}
+
+declare class VitestTestRunner implements VitestRunner {
+    config: SerializedConfig;
+    private snapshotClient;
+    private workerState;
+    private __vitest_executor;
+    private cancelRun;
+    private assertionsErrors;
+    pool: string;
+    constructor(config: SerializedConfig);
+    importFile(filepath: string, source: VitestRunnerImportSource): unknown;
+    onCollectStart(file: File): void;
+    onBeforeRunFiles(): void;
+    onAfterRunFiles(): void;
+    onAfterRunSuite(suite: Suite): Promise<void>;
+    onAfterRunTask(test: Task): void;
+    onCancel(_reason: CancelReason): void;
+    onBeforeRunTask(test: Task): Promise<void>;
+    onBeforeRunSuite(suite: Suite): Promise<void>;
+    onBeforeTryTask(test: Task): void;
+    onAfterTryTask(test: Task): void;
+    extendTaskContext<T extends Test | Custom>(context: TaskContext<T>): ExtendedContext<T>;
+}
+
+export { NodeBenchmarkRunner, VitestTestRunner };

pwa/node_modules/vitest/dist/runners.js

@@ -0,0 +1,302 @@
+import { updateTask } from '@vitest/runner';
+import { createDefer, getSafeTimers } from '@vitest/utils';
+import { a as getBenchOptions, g as getBenchFn } from './chunks/benchmark.Cdu9hjj4.js';
+import { g as getWorkerState } from './chunks/utils.C8RiOc4B.js';
+import { setState, GLOBAL_EXPECT, getState } from '@vitest/expect';
+import { getTests, getNames, getTestName } from '@vitest/runner/utils';
+import { g as getSnapshotClient, c as createExpect, v as vi } from './chunks/vi.DgezovHB.js';
+import { r as rpc } from './chunks/rpc.C3q9uwRX.js';
+import 'chai';
+import './chunks/_commonjsHelpers.BFTU3MAI.js';
+import '@vitest/snapshot';
+import '@vitest/utils/error';
+import '@vitest/utils/source-map';
+import './chunks/date.W2xKR2qe.js';
+import '@vitest/spy';
+import './chunks/index.68735LiX.js';
+
+function createBenchmarkResult(name) {
+  return {
+    name,
+    rank: 0,
+    rme: 0,
+    samples: []
+  };
+}
+const benchmarkTasks = /* @__PURE__ */ new WeakMap();
+async function runBenchmarkSuite(suite, runner) {
+  const { Task, Bench } = await runner.importTinybench();
+  const start = performance.now();
+  const benchmarkGroup = [];
+  const benchmarkSuiteGroup = [];
+  for (const task of suite.tasks) {
+    if (task.mode !== "run") {
+      continue;
+    }
+    if (task.meta?.benchmark) {
+      benchmarkGroup.push(task);
+    } else if (task.type === "suite") {
+      benchmarkSuiteGroup.push(task);
+    }
+  }
+  for (const subSuite of benchmarkSuiteGroup) {
+    await runBenchmarkSuite(subSuite, runner);
+  }
+  if (benchmarkGroup.length) {
+    const defer = createDefer();
+    suite.result = {
+      state: "run",
+      startTime: start,
+      benchmark: createBenchmarkResult(suite.name)
+    };
+    updateTask$1(suite);
+    const addBenchTaskListener = (task, benchmark) => {
+      task.addEventListener(
+        "complete",
+        (e) => {
+          const task2 = e.task;
+          const taskRes = task2.result;
+          const result = benchmark.result.benchmark;
+          Object.assign(result, taskRes);
+          const samples = result.samples;
+          result.sampleCount = samples.length;
+          result.median = samples.length % 2 ? samples[Math.floor(samples.length / 2)] : (samples[samples.length / 2] + samples[samples.length / 2 - 1]) / 2;
+          if (!runner.config.benchmark?.includeSamples) {
+            result.samples.length = 0;
+          }
+          updateTask$1(benchmark);
+        },
+        {
+          once: true
+        }
+      );
+      task.addEventListener(
+        "error",
+        (e) => {
+          const task2 = e.task;
+          defer.reject(benchmark ? task2.result.error : e);
+        },
+        {
+          once: true
+        }
+      );
+    };
+    benchmarkGroup.forEach((benchmark) => {
+      const options = getBenchOptions(benchmark);
+      const benchmarkInstance = new Bench(options);
+      const benchmarkFn = getBenchFn(benchmark);
+      benchmark.result = {
+        state: "run",
+        startTime: start,
+        benchmark: createBenchmarkResult(benchmark.name)
+      };
+      const task = new Task(benchmarkInstance, benchmark.name, benchmarkFn);
+      benchmarkTasks.set(benchmark, task);
+      addBenchTaskListener(task, benchmark);
+      updateTask$1(benchmark);
+    });
+    const { setTimeout } = getSafeTimers();
+    const tasks = [];
+    for (const benchmark of benchmarkGroup) {
+      const task = benchmarkTasks.get(benchmark);
+      await task.warmup();
+      tasks.push([
+        await new Promise(
+          (resolve) => setTimeout(async () => {
+            resolve(await task.run());
+          })
+        ),
+        benchmark
+      ]);
+    }
+    suite.result.duration = performance.now() - start;
+    suite.result.state = "pass";
+    tasks.sort(([taskA], [taskB]) => taskA.result.mean - taskB.result.mean).forEach(([, benchmark], idx) => {
+      benchmark.result.state = "pass";
+      if (benchmark) {
+        const result = benchmark.result.benchmark;
+        result.rank = Number(idx) + 1;
+        updateTask$1(benchmark);
+      }
+    });
+    updateTask$1(suite);
+    defer.resolve(null);
+    await defer;
+  }
+  function updateTask$1(task) {
+    updateTask(task, runner);
+  }
+}
+class NodeBenchmarkRunner {
+  constructor(config) {
+    this.config = config;
+  }
+  __vitest_executor;
+  async importTinybench() {
+    return await import('tinybench');
+  }
+  importFile(filepath, source) {
+    if (source === "setup") {
+      getWorkerState().moduleCache.delete(filepath);
+    }
+    return this.__vitest_executor.executeId(filepath);
+  }
+  async runSuite(suite) {
+    await runBenchmarkSuite(suite, this);
+  }
+  async runTask() {
+    throw new Error("`test()` and `it()` is only available in test mode.");
+  }
+}
+
+class VitestTestRunner {
+  constructor(config) {
+    this.config = config;
+  }
+  snapshotClient = getSnapshotClient();
+  workerState = getWorkerState();
+  __vitest_executor;
+  cancelRun = false;
+  assertionsErrors = /* @__PURE__ */ new WeakMap();
+  pool = this.workerState.ctx.pool;
+  importFile(filepath, source) {
+    if (source === "setup") {
+      this.workerState.moduleCache.delete(filepath);
+    }
+    return this.__vitest_executor.executeId(filepath);
+  }
+  onCollectStart(file) {
+    this.workerState.current = file;
+  }
+  onBeforeRunFiles() {
+    this.snapshotClient.clear();
+  }
+  onAfterRunFiles() {
+    this.workerState.current = void 0;
+  }
+  async onAfterRunSuite(suite) {
+    if (this.config.logHeapUsage && typeof process !== "undefined") {
+      suite.result.heap = process.memoryUsage().heapUsed;
+    }
+    if (suite.mode !== "skip" && "filepath" in suite) {
+      for (const test of getTests(suite)) {
+        if (test.mode === "skip") {
+          const name = getNames(test).slice(1).join(" > ");
+          this.snapshotClient.skipTestSnapshots(name);
+        }
+      }
+      const result = await this.snapshotClient.finishCurrentRun();
+      if (result) {
+        await rpc().snapshotSaved(result);
+      }
+    }
+    this.workerState.current = suite.suite || suite.file;
+  }
+  onAfterRunTask(test) {
+    this.snapshotClient.clearTest();
+    if (this.config.logHeapUsage && typeof process !== "undefined") {
+      test.result.heap = process.memoryUsage().heapUsed;
+    }
+    this.workerState.current = test.suite || test.file;
+  }
+  onCancel(_reason) {
+    this.cancelRun = true;
+  }
+  async onBeforeRunTask(test) {
+    if (this.cancelRun) {
+      test.mode = "skip";
+    }
+    if (test.mode !== "run") {
+      return;
+    }
+    clearModuleMocks(this.config);
+    this.workerState.current = test;
+  }
+  async onBeforeRunSuite(suite) {
+    if (this.cancelRun) {
+      suite.mode = "skip";
+    }
+    if (suite.mode !== "skip" && "filepath" in suite) {
+      await this.snapshotClient.startCurrentRun(
+        suite.filepath,
+        "__default_name_",
+        this.workerState.config.snapshotOptions
+      );
+    }
+    this.workerState.current = suite;
+  }
+  onBeforeTryTask(test) {
+    setState(
+      {
+        assertionCalls: 0,
+        isExpectingAssertions: false,
+        isExpectingAssertionsError: null,
+        expectedAssertionsNumber: null,
+        expectedAssertionsNumberErrorGen: null,
+        testPath: test.file.filepath,
+        currentTestName: getTestName(test),
+        snapshotState: this.snapshotClient.snapshotState
+      },
+      globalThis[GLOBAL_EXPECT]
+    );
+  }
+  onAfterTryTask(test) {
+    const {
+      assertionCalls,
+      expectedAssertionsNumber,
+      expectedAssertionsNumberErrorGen,
+      isExpectingAssertions,
+      isExpectingAssertionsError
+    } = "context" in test && test.context._local ? test.context.expect.getState() : getState(globalThis[GLOBAL_EXPECT]);
+    if (expectedAssertionsNumber !== null && assertionCalls !== expectedAssertionsNumber) {
+      throw expectedAssertionsNumberErrorGen();
+    }
+    if (isExpectingAssertions === true && assertionCalls === 0) {
+      throw isExpectingAssertionsError;
+    }
+    if (this.config.expect.requireAssertions && assertionCalls === 0) {
+      throw this.assertionsErrors.get(test);
+    }
+  }
+  extendTaskContext(context) {
+    if (this.config.expect.requireAssertions) {
+      this.assertionsErrors.set(
+        context.task,
+        new Error("expected any number of assertion, but got none")
+      );
+    }
+    let _expect;
+    Object.defineProperty(context, "expect", {
+      get() {
+        if (!_expect) {
+          _expect = createExpect(context.task);
+        }
+        return _expect;
+      }
+    });
+    Object.defineProperty(context, "_local", {
+      get() {
+        return _expect != null;
+      }
+    });
+    return context;
+  }
+}
+function clearModuleMocks(config) {
+  const { clearMocks, mockReset, restoreMocks, unstubEnvs, unstubGlobals } = config;
+  if (restoreMocks) {
+    vi.restoreAllMocks();
+  } else if (mockReset) {
+    vi.resetAllMocks();
+  } else if (clearMocks) {
+    vi.clearAllMocks();
+  }
+  if (unstubEnvs) {
+    vi.unstubAllEnvs();
+  }
+  if (unstubGlobals) {
+    vi.unstubAllGlobals();
+  }
+}
+
+export { NodeBenchmarkRunner, VitestTestRunner };

pwa/node_modules/vitest/dist/snapshot.d.ts

@@ -0,0 +1,9 @@
+import { NodeSnapshotEnvironment } from '@vitest/snapshot/environment';
+export { SnapshotEnvironment } from '@vitest/snapshot/environment';
+
+declare class VitestNodeSnapshotEnvironment extends NodeSnapshotEnvironment {
+    getHeader(): string;
+    resolvePath(filepath: string): Promise<string>;
+}
+
+export { VitestNodeSnapshotEnvironment as VitestSnapshotEnvironment };

pwa/node_modules/vitest/dist/snapshot.js

@@ -0,0 +1,4 @@
+export { VitestNodeSnapshotEnvironment as VitestSnapshotEnvironment } from './chunks/node.AKq966Jp.js';
+import '@vitest/snapshot/environment';
+import './chunks/utils.C8RiOc4B.js';
+import '@vitest/utils';

pwa/node_modules/vitest/dist/spy.js

@@ -0,0 +1 @@
+export * from '@vitest/spy';

pwa/node_modules/vitest/dist/suite.d.ts

@@ -0,0 +1,5 @@
+export { g as getBenchFn, a as getBenchOptions } from './chunks/suite.B2jumIFP.js';
+export { createTaskCollector, getCurrentSuite, getCurrentTest, getFn, getHooks, setFn, setHooks } from '@vitest/runner';
+export { createChainable } from '@vitest/runner/utils';
+import './chunks/benchmark.geERunq4.js';
+import 'tinybench';

pwa/node_modules/vitest/dist/suite.js

@@ -0,0 +1,5 @@
+export { g as getBenchFn, a as getBenchOptions } from './chunks/benchmark.Cdu9hjj4.js';
+export { createTaskCollector, getCurrentSuite, getCurrentTest, getFn, getHooks, setFn, setHooks } from '@vitest/runner';
+export { createChainable } from '@vitest/runner/utils';
+import '@vitest/utils';
+import './chunks/utils.C8RiOc4B.js';

pwa/node_modules/vitest/dist/utils.d.ts

@@ -0,0 +1,3 @@
+export * from '@vitest/utils';
+export * from '@vitest/utils/source-map';
+import '@vitest/mocker';

pwa/node_modules/vitest/dist/utils.js

@@ -0,0 +1,2 @@
+export * from '@vitest/utils';
+export * from '@vitest/utils/source-map';

pwa/node_modules/vitest/dist/worker.js

@@ -0,0 +1,141 @@
+import { pathToFileURL } from 'node:url';
+import { createStackString, parseStacktrace } from '@vitest/utils/source-map';
+import { workerId } from 'tinypool';
+import { ViteNodeRunner, ModuleCacheMap } from 'vite-node/client';
+import { readFileSync } from 'node:fs';
+import { resolve, normalize } from 'pathe';
+import { e as environments } from './chunks/index.K90BXFOx.js';
+import { s as setupInspect } from './chunks/inspector.70d6emsh.js';
+import { c as createRuntimeRpc, a as rpcDone } from './chunks/rpc.C3q9uwRX.js';
+import { i as isChildProcess, s as setProcessTitle } from './chunks/utils.C8RiOc4B.js';
+import { d as disposeInternalListeners } from './chunks/utils.Cn0zI1t3.js';
+import 'node:console';
+import 'node:module';
+import '@vitest/utils';
+import './chunks/index.68735LiX.js';
+
+function isBuiltinEnvironment(env) {
+  return env in environments;
+}
+const _loaders = /* @__PURE__ */ new Map();
+async function createEnvironmentLoader(options) {
+  if (!_loaders.has(options.root)) {
+    const loader = new ViteNodeRunner(options);
+    await loader.executeId("/@vite/env");
+    _loaders.set(options.root, loader);
+  }
+  return _loaders.get(options.root);
+}
+async function loadEnvironment(ctx, rpc) {
+  const name = ctx.environment.name;
+  if (isBuiltinEnvironment(name)) {
+    return environments[name];
+  }
+  const loader = await createEnvironmentLoader({
+    root: ctx.config.root,
+    fetchModule: async (id) => {
+      const result = await rpc.fetch(id, "ssr");
+      if (result.id) {
+        return { code: readFileSync(result.id, "utf-8") };
+      }
+      return result;
+    },
+    resolveId: (id, importer) => rpc.resolveId(id, importer, "ssr")
+  });
+  const root = loader.root;
+  const packageId = name[0] === "." || name[0] === "/" ? resolve(root, name) : (await rpc.resolveId(`vitest-environment-${name}`, void 0, "ssr"))?.id ?? resolve(root, name);
+  const pkg = await loader.executeId(normalize(packageId));
+  if (!pkg || !pkg.default || typeof pkg.default !== "object") {
+    throw new TypeError(
+      `Environment "${name}" is not a valid environment. Path "${packageId}" should export default object with a "setup" or/and "setupVM" method.`
+    );
+  }
+  const environment = pkg.default;
+  if (environment.transformMode !== "web" && environment.transformMode !== "ssr") {
+    throw new TypeError(
+      `Environment "${name}" is not a valid environment. Path "${packageId}" should export default object with a "transformMode" method equal to "ssr" or "web".`
+    );
+  }
+  return environment;
+}
+
+if (isChildProcess()) {
+  setProcessTitle(`vitest ${workerId}`);
+  const isProfiling = process.execArgv.some(
+    (execArg) => execArg.startsWith("--prof") || execArg.startsWith("--cpu-prof") || execArg.startsWith("--heap-prof") || execArg.startsWith("--diagnostic-dir")
+  );
+  if (isProfiling) {
+    process.on("SIGTERM", () => {
+      process.exit();
+    });
+  }
+}
+async function execute(method, ctx) {
+  disposeInternalListeners();
+  const prepareStart = performance.now();
+  const inspectorCleanup = setupInspect(ctx);
+  process.env.VITEST_WORKER_ID = String(ctx.workerId);
+  process.env.VITEST_POOL_ID = String(workerId);
+  try {
+    if (ctx.worker[0] === ".") {
+      throw new Error(
+        `Path to the test runner cannot be relative, received "${ctx.worker}"`
+      );
+    }
+    const file = ctx.worker.startsWith("file:") ? ctx.worker : pathToFileURL(ctx.worker).toString();
+    const testRunnerModule = await import(file);
+    if (!testRunnerModule.default || typeof testRunnerModule.default !== "object") {
+      throw new TypeError(
+        `Test worker object should be exposed as a default export. Received "${typeof testRunnerModule.default}"`
+      );
+    }
+    const worker = testRunnerModule.default;
+    if (!worker.getRpcOptions || typeof worker.getRpcOptions !== "function") {
+      throw new TypeError(
+        `Test worker should expose "getRpcOptions" method. Received "${typeof worker.getRpcOptions}".`
+      );
+    }
+    const { rpc, onCancel } = createRuntimeRpc(worker.getRpcOptions(ctx));
+    const beforeEnvironmentTime = performance.now();
+    const environment = await loadEnvironment(ctx, rpc);
+    if (ctx.environment.transformMode) {
+      environment.transformMode = ctx.environment.transformMode;
+    }
+    const state = {
+      ctx,
+      // here we create a new one, workers can reassign this if they need to keep it non-isolated
+      moduleCache: new ModuleCacheMap(),
+      config: ctx.config,
+      onCancel,
+      environment,
+      durations: {
+        environment: beforeEnvironmentTime,
+        prepare: prepareStart
+      },
+      rpc,
+      providedContext: ctx.providedContext,
+      onFilterStackTrace(stack) {
+        return createStackString(parseStacktrace(stack));
+      }
+    };
+    const methodName = method === "collect" ? "collectTests" : "runTests";
+    if (!worker[methodName] || typeof worker[methodName] !== "function") {
+      throw new TypeError(
+        `Test worker should expose "runTests" method. Received "${typeof worker.runTests}".`
+      );
+    }
+    await worker[methodName](state);
+  } finally {
+    await rpcDone().catch(() => {
+    });
+    inspectorCleanup();
+  }
+}
+function run(ctx) {
+  return execute("run", ctx);
+}
+function collect(ctx) {
+  return execute("collect", ctx);
+}
+
+export { collect, run };

pwa/node_modules/vitest/dist/workers.d.ts

@@ -0,0 +1,37 @@
+import { W as WorkerGlobalState, C as ContextRPC, B as BirpcOptions, R as RuntimeRPC } from './chunks/worker.tN5KGIih.js';
+import { Awaitable } from '@vitest/utils';
+import * as v8 from 'v8';
+import { S as SerializedConfig } from './chunks/config.Cy0C388Z.js';
+import { W as WorkerContext } from './chunks/worker.B9FxPCaC.js';
+import '@vitest/runner';
+import 'vite-node';
+import './chunks/environment.LoooBwUu.js';
+import '@vitest/snapshot';
+import '@vitest/pretty-format';
+import '@vitest/snapshot/environment';
+import 'node:worker_threads';
+
+declare function provideWorkerState(context: any, state: WorkerGlobalState): WorkerGlobalState;
+
+declare function run(ctx: ContextRPC): Promise<void>;
+declare function collect(ctx: ContextRPC): Promise<void>;
+
+declare function runBaseTests(method: 'run' | 'collect', state: WorkerGlobalState): Promise<void>;
+
+type WorkerRpcOptions = Pick<BirpcOptions<RuntimeRPC>, 'on' | 'post' | 'serialize' | 'deserialize'>;
+interface VitestWorker {
+    getRpcOptions: (ctx: ContextRPC) => WorkerRpcOptions;
+    runTests: (state: WorkerGlobalState) => Awaitable<unknown>;
+    collectTests: (state: WorkerGlobalState) => Awaitable<unknown>;
+}
+
+declare function createThreadsRpcOptions({ port, }: WorkerContext): WorkerRpcOptions;
+declare function createForksRpcOptions(nodeV8: typeof v8): WorkerRpcOptions;
+/**
+ * Reverts the wrapping done by `utils/config-helpers.ts`'s `wrapSerializableConfig`
+ */
+declare function unwrapSerializableConfig(config: SerializedConfig): SerializedConfig;
+
+declare function runVmTests(method: 'run' | 'collect', state: WorkerGlobalState): Promise<void>;
+
+export { type VitestWorker, type WorkerRpcOptions, collect as collectVitestWorkerTests, createForksRpcOptions, createThreadsRpcOptions, provideWorkerState, runBaseTests, run as runVitestWorker, runVmTests, unwrapSerializableConfig };

pwa/node_modules/vitest/dist/workers.js

@@ -0,0 +1,30 @@
+export { p as provideWorkerState } from './chunks/utils.C8RiOc4B.js';
+export { collect as collectVitestWorkerTests, run as runVitestWorker } from './worker.js';
+export { r as runBaseTests } from './chunks/base.BZZh4cSm.js';
+export { c as createForksRpcOptions, a as createThreadsRpcOptions, u as unwrapSerializableConfig } from './chunks/utils.Cn0zI1t3.js';
+export { r as runVmTests } from './chunks/vm.Zr4qWzDJ.js';
+import '@vitest/utils';
+import 'node:url';
+import '@vitest/utils/source-map';
+import 'tinypool';
+import 'vite-node/client';
+import 'node:fs';
+import 'pathe';
+import './chunks/index.K90BXFOx.js';
+import 'node:console';
+import './chunks/inspector.70d6emsh.js';
+import 'node:module';
+import './chunks/rpc.C3q9uwRX.js';
+import './chunks/index.68735LiX.js';
+import './chunks/execute.2pr0rHgK.js';
+import 'node:vm';
+import '@vitest/utils/error';
+import 'vite-node/utils';
+import './path.js';
+import 'node:path';
+import '@vitest/mocker';
+import './chunks/console.BYGVloWk.js';
+import 'node:stream';
+import 'tinyrainbow';
+import './chunks/date.W2xKR2qe.js';
+import 'vite-node/constants';

pwa/node_modules/vitest/dist/workers/forks.js

@@ -0,0 +1,41 @@
+import v8 from 'node:v8';
+import { r as runBaseTests } from '../chunks/base.BZZh4cSm.js';
+import { c as createForksRpcOptions, u as unwrapSerializableConfig } from '../chunks/utils.Cn0zI1t3.js';
+import 'vite-node/client';
+import '../chunks/execute.2pr0rHgK.js';
+import 'node:fs';
+import 'node:url';
+import 'node:vm';
+import '@vitest/utils/error';
+import 'pathe';
+import 'vite-node/utils';
+import '../path.js';
+import 'node:path';
+import '@vitest/mocker';
+import 'node:module';
+import '@vitest/utils';
+import '../chunks/utils.C8RiOc4B.js';
+
+class ForksBaseWorker {
+  getRpcOptions() {
+    return createForksRpcOptions(v8);
+  }
+  async executeTests(method, state) {
+    const exit = process.exit;
+    state.ctx.config = unwrapSerializableConfig(state.ctx.config);
+    try {
+      await runBaseTests(method, state);
+    } finally {
+      process.exit = exit;
+    }
+  }
+  runTests(state) {
+    return this.executeTests("run", state);
+  }
+  collectTests(state) {
+    return this.executeTests("collect", state);
+  }
+}
+var forks = new ForksBaseWorker();
+
+export { forks as default };

pwa/node_modules/vitest/dist/workers/runVmTests.js

@@ -0,0 +1,95 @@
+import { createRequire } from 'node:module';
+import { performance } from 'node:perf_hooks';
+import timers from 'node:timers';
+import util from 'node:util';
+import { startTests, collectTests } from '@vitest/runner';
+import { KNOWN_ASSET_TYPES } from 'vite-node/constants';
+import { installSourcemapsSupport } from 'vite-node/source-map';
+import { s as setupChaiConfig, r as resolveTestRunner, a as resolveSnapshotEnvironment } from '../chunks/index.nEwtF0bu.js';
+import { s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from '../chunks/coverage.BoMDb1ip.js';
+import { V as VitestIndex } from '../chunks/index.ckWaX2gY.js';
+import { c as closeInspector } from '../chunks/inspector.70d6emsh.js';
+import { s as setupCommonEnv } from '../chunks/setup-common.Dj6BZI3u.js';
+import { g as getWorkerState } from '../chunks/utils.C8RiOc4B.js';
+import 'chai';
+import 'node:path';
+import '../path.js';
+import 'node:url';
+import '../chunks/rpc.C3q9uwRX.js';
+import '@vitest/utils';
+import '../chunks/index.68735LiX.js';
+import '../chunks/vi.DgezovHB.js';
+import '@vitest/expect';
+import '@vitest/runner/utils';
+import '../chunks/_commonjsHelpers.BFTU3MAI.js';
+import '@vitest/snapshot';
+import '@vitest/utils/error';
+import '@vitest/utils/source-map';
+import '../chunks/date.W2xKR2qe.js';
+import '@vitest/spy';
+import '../chunks/run-once.2ogXb3JV.js';
+import '../chunks/benchmark.Cdu9hjj4.js';
+import 'expect-type';
+
+async function run(method, files, config, executor) {
+  const workerState = getWorkerState();
+  await setupCommonEnv(config);
+  Object.defineProperty(globalThis, "__vitest_index__", {
+    value: VitestIndex,
+    enumerable: false
+  });
+  if (workerState.environment.transformMode === "web") {
+    const _require = createRequire(import.meta.url);
+    _require.extensions[".css"] = resolveCss;
+    _require.extensions[".scss"] = resolveCss;
+    _require.extensions[".sass"] = resolveCss;
+    _require.extensions[".less"] = resolveCss;
+    KNOWN_ASSET_TYPES.forEach((type) => {
+      _require.extensions[`.${type}`] = resolveAsset;
+    });
+    process.env.SSR = "";
+  } else {
+    process.env.SSR = "1";
+  }
+  globalThis.__vitest_required__ = {
+    util,
+    timers
+  };
+  installSourcemapsSupport({
+    getSourceMap: (source) => workerState.moduleCache.getSourceMap(source)
+  });
+  await startCoverageInsideWorker(config.coverage, executor);
+  if (config.chaiConfig) {
+    setupChaiConfig(config.chaiConfig);
+  }
+  const [runner, snapshotEnvironment] = await Promise.all([
+    resolveTestRunner(config, executor),
+    resolveSnapshotEnvironment(config, executor)
+  ]);
+  config.snapshotOptions.snapshotEnvironment = snapshotEnvironment;
+  workerState.onCancel.then((reason) => {
+    closeInspector(config);
+    runner.onCancel?.(reason);
+  });
+  workerState.durations.prepare = performance.now() - workerState.durations.prepare;
+  const { vi } = VitestIndex;
+  for (const file of files) {
+    workerState.filepath = file;
+    if (method === "run") {
+      await startTests([file], runner);
+    } else {
+      await collectTests([file], runner);
+    }
+    vi.resetConfig();
+    vi.restoreAllMocks();
+  }
+  await stopCoverageInsideWorker(config.coverage, executor);
+}
+function resolveCss(mod) {
+  mod.exports = "";
+}
+function resolveAsset(mod, url) {
+  mod.exports = url;
+}
+
+export { run };

pwa/node_modules/vitest/dist/workers/threads.js

@@ -0,0 +1,31 @@
+import { r as runBaseTests } from '../chunks/base.BZZh4cSm.js';
+import { a as createThreadsRpcOptions } from '../chunks/utils.Cn0zI1t3.js';
+import 'vite-node/client';
+import '../chunks/execute.2pr0rHgK.js';
+import 'node:fs';
+import 'node:url';
+import 'node:vm';
+import '@vitest/utils/error';
+import 'pathe';
+import 'vite-node/utils';
+import '../path.js';
+import 'node:path';
+import '@vitest/mocker';
+import 'node:module';
+import '@vitest/utils';
+import '../chunks/utils.C8RiOc4B.js';
+
+class ThreadsBaseWorker {
+  getRpcOptions(ctx) {
+    return createThreadsRpcOptions(ctx);
+  }
+  runTests(state) {
+    return runBaseTests("run", state);
+  }
+  collectTests(state) {
+    return runBaseTests("collect", state);
+  }
+}
+var threads = new ThreadsBaseWorker();
+
+export { threads as default };

pwa/node_modules/vitest/dist/workers/vmForks.js

@@ -0,0 +1,47 @@
+import v8 from 'node:v8';
+import { c as createForksRpcOptions, u as unwrapSerializableConfig } from '../chunks/utils.Cn0zI1t3.js';
+import { r as runVmTests } from '../chunks/vm.Zr4qWzDJ.js';
+import '@vitest/utils';
+import 'node:url';
+import 'node:vm';
+import 'pathe';
+import '../path.js';
+import 'node:path';
+import '../chunks/console.BYGVloWk.js';
+import 'node:console';
+import 'node:stream';
+import 'tinyrainbow';
+import '../chunks/date.W2xKR2qe.js';
+import '../chunks/utils.C8RiOc4B.js';
+import '../chunks/execute.2pr0rHgK.js';
+import 'node:fs';
+import '@vitest/utils/error';
+import 'vite-node/client';
+import 'vite-node/utils';
+import '@vitest/mocker';
+import 'node:module';
+import 'vite-node/constants';
+
+class ForksVmWorker {
+  getRpcOptions() {
+    return createForksRpcOptions(v8);
+  }
+  async executeTests(method, state) {
+    const exit = process.exit;
+    state.ctx.config = unwrapSerializableConfig(state.ctx.config);
+    try {
+      await runVmTests(method, state);
+    } finally {
+      process.exit = exit;
+    }
+  }
+  runTests(state) {
+    return this.executeTests("run", state);
+  }
+  collectTests(state) {
+    return this.executeTests("collect", state);
+  }
+}
+var vmForks = new ForksVmWorker();
+
+export { vmForks as default };

pwa/node_modules/vitest/dist/workers/vmThreads.js

@@ -0,0 +1,37 @@
+import { a as createThreadsRpcOptions } from '../chunks/utils.Cn0zI1t3.js';
+import { r as runVmTests } from '../chunks/vm.Zr4qWzDJ.js';
+import '@vitest/utils';
+import 'node:url';
+import 'node:vm';
+import 'pathe';
+import '../path.js';
+import 'node:path';
+import '../chunks/console.BYGVloWk.js';
+import 'node:console';
+import 'node:stream';
+import 'tinyrainbow';
+import '../chunks/date.W2xKR2qe.js';
+import '../chunks/utils.C8RiOc4B.js';
+import '../chunks/execute.2pr0rHgK.js';
+import 'node:fs';
+import '@vitest/utils/error';
+import 'vite-node/client';
+import 'vite-node/utils';
+import '@vitest/mocker';
+import 'node:module';
+import 'vite-node/constants';
+
+class ThreadsVmWorker {
+  getRpcOptions(ctx) {
+    return createThreadsRpcOptions(ctx);
+  }
+  runTests(state) {
+    return runVmTests("run", state);
+  }
+  collectTests(state) {
+    return runVmTests("collect", state);
+  }
+}
+var vmThreads = new ThreadsVmWorker();
+
+export { vmThreads as default };

pwa/node_modules/vitest/environments.d.ts

@@ -0,0 +1 @@
+export * from './dist/environments'

pwa/node_modules/vitest/execute.d.ts

@@ -0,0 +1 @@
+export * from './dist/execute.js'

pwa/node_modules/vitest/globals.d.ts

@@ -0,0 +1,19 @@
+declare global {
+  const suite: typeof import('vitest')['suite']
+  const test: typeof import('vitest')['test']
+  const describe: typeof import('vitest')['describe']
+  const it: typeof import('vitest')['it']
+  const expectTypeOf: typeof import('vitest')['expectTypeOf']
+  const assertType: typeof import('vitest')['assertType']
+  const expect: typeof import('vitest')['expect']
+  const assert: typeof import('vitest')['assert']
+  const vitest: typeof import('vitest')['vitest']
+  const vi: typeof import('vitest')['vitest']
+  const beforeAll: typeof import('vitest')['beforeAll']
+  const afterAll: typeof import('vitest')['afterAll']
+  const beforeEach: typeof import('vitest')['beforeEach']
+  const afterEach: typeof import('vitest')['afterEach']
+  const onTestFailed: typeof import('vitest')['onTestFailed']
+  const onTestFinished: typeof import('vitest')['onTestFinished']
+}
+export {}

pwa/node_modules/vitest/import-meta.d.ts

@@ -0,0 +1,5 @@
+/// <reference path="./importMeta.d.ts" />
+
+// https://github.com/microsoft/TypeScript/issues/45096
+// TypeScript has a bug that makes <reference types="vite/types/importMeta" />
+// not possible in userland. This file provides a workaround for now.

pwa/node_modules/vitest/importMeta.d.ts

@@ -0,0 +1,4 @@
+interface ImportMeta {
+  url: string
+  readonly vitest?: typeof import('vitest')
+}

pwa/node_modules/vitest/index.cjs

@@ -0,0 +1,5 @@
+throw new Error(
+  'Vitest cannot be imported in a CommonJS module using require(). Please use "import" instead.'
+  + '\n\nIf you are using "import" in your source code, then it\'s possible it was bundled into require() automatically by your bundler. '
+  + 'In that case, do not bundle CommonJS output since it will never work with Vitest, or use dynamic import() which is available in all CommonJS modules.',
+)

pwa/node_modules/vitest/index.d.cts

@@ -0,0 +1 @@
+export * from './dist/index.js'

pwa/node_modules/vitest/jsdom.d.ts

@@ -0,0 +1,6 @@
+import type { JSDOM } from 'jsdom'
+
+declare global {
+  const jsdom: JSDOM
+}
+export {}

pwa/node_modules/vitest/mocker.d.ts

@@ -0,0 +1 @@
+export * from './dist/mocker.js'

pwa/node_modules/vitest/node.d.ts

@@ -0,0 +1 @@
+export * from './dist/node.js'

pwa/node_modules/vitest/package.json

@@ -0,0 +1,207 @@
+{
+  "name": "vitest",
+  "type": "module",
+  "version": "2.1.9",
+  "description": "Next generation testing framework powered by Vite",
+  "author": "Anthony Fu <anthonyfu117@hotmail.com>",
+  "license": "MIT",
+  "funding": "https://opencollective.com/vitest",
+  "homepage": "https://github.com/vitest-dev/vitest#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vitest-dev/vitest.git",
+    "directory": "packages/vitest"
+  },
+  "bugs": {
+    "url": "https://github.com/vitest-dev/vitest/issues"
+  },
+  "keywords": [
+    "vite",
+    "vitest",
+    "test",
+    "jest"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./index.d.cts",
+        "default": "./index.cjs"
+      }
+    },
+    "./*": "./*",
+    "./globals": {
+      "types": "./globals.d.ts"
+    },
+    "./jsdom": {
+      "types": "./jsdom.d.ts"
+    },
+    "./importMeta": {
+      "types": "./importMeta.d.ts"
+    },
+    "./import-meta": {
+      "types": "./import-meta.d.ts"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "default": "./dist/node.js"
+    },
+    "./execute": {
+      "types": "./dist/execute.d.ts",
+      "default": "./dist/execute.js"
+    },
+    "./workers": {
+      "types": "./dist/workers.d.ts",
+      "import": "./dist/workers.js"
+    },
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "default": "./dist/browser.js"
+    },
+    "./runners": {
+      "types": "./dist/runners.d.ts",
+      "default": "./dist/runners.js"
+    },
+    "./suite": {
+      "types": "./dist/suite.d.ts",
+      "default": "./dist/suite.js"
+    },
+    "./environments": {
+      "types": "./dist/environments.d.ts",
+      "default": "./dist/environments.js"
+    },
+    "./utils": {
+      "types": "./dist/utils.d.ts",
+      "default": "./dist/utils.js"
+    },
+    "./config": {
+      "types": "./config.d.ts",
+      "require": "./dist/config.cjs",
+      "default": "./dist/config.js"
+    },
+    "./coverage": {
+      "types": "./coverage.d.ts",
+      "default": "./dist/coverage.js"
+    },
+    "./reporters": {
+      "types": "./dist/reporters.d.ts",
+      "default": "./dist/reporters.js"
+    },
+    "./snapshot": {
+      "types": "./dist/snapshot.d.ts",
+      "default": "./dist/snapshot.js"
+    },
+    "./mocker": {
+      "types": "./dist/mocker.d.ts",
+      "default": "./dist/mocker.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "vitest": "./vitest.mjs"
+  },
+  "files": [
+    "*.cjs",
+    "*.d.cts",
+    "*.d.ts",
+    "*.mjs",
+    "bin",
+    "dist"
+  ],
+  "engines": {
+    "node": "^18.0.0 || >=20.0.0"
+  },
+  "peerDependencies": {
+    "@edge-runtime/vm": "*",
+    "@types/node": "^18.0.0 || >=20.0.0",
+    "happy-dom": "*",
+    "jsdom": "*",
+    "@vitest/browser": "2.1.9",
+    "@vitest/ui": "2.1.9"
+  },
+  "peerDependenciesMeta": {
+    "@edge-runtime/vm": {
+      "optional": true
+    },
+    "@types/node": {
+      "optional": true
+    },
+    "@vitest/browser": {
+      "optional": true
+    },
+    "@vitest/ui": {
+      "optional": true
+    },
+    "happy-dom": {
+      "optional": true
+    },
+    "jsdom": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "chai": "^5.1.2",
+    "debug": "^4.3.7",
+    "expect-type": "^1.1.0",
+    "magic-string": "^0.30.12",
+    "pathe": "^1.1.2",
+    "std-env": "^3.8.0",
+    "tinybench": "^2.9.0",
+    "tinyexec": "^0.3.1",
+    "tinypool": "^1.0.1",
+    "tinyrainbow": "^1.2.0",
+    "vite": "^5.0.0",
+    "why-is-node-running": "^2.3.0",
+    "@vitest/expect": "2.1.9",
+    "@vitest/mocker": "2.1.9",
+    "@vitest/runner": "2.1.9",
+    "@vitest/snapshot": "2.1.9",
+    "@vitest/pretty-format": "^2.1.9",
+    "@vitest/spy": "2.1.9",
+    "vite-node": "2.1.9",
+    "@vitest/utils": "2.1.9"
+  },
+  "devDependencies": {
+    "@ampproject/remapping": "^2.3.0",
+    "@antfu/install-pkg": "^0.4.1",
+    "@edge-runtime/vm": "^4.0.4",
+    "@sinonjs/fake-timers": "11.1.0",
+    "@types/debug": "^4.1.12",
+    "@types/estree": "^1.0.6",
+    "@types/istanbul-lib-coverage": "^2.0.6",
+    "@types/istanbul-reports": "^3.0.4",
+    "@types/jsdom": "^21.1.7",
+    "@types/micromatch": "^4.0.9",
+    "@types/node": "^22.9.0",
+    "@types/prompts": "^2.4.9",
+    "@types/sinonjs__fake-timers": "^8.1.5",
+    "acorn-walk": "^8.3.4",
+    "birpc": "0.2.19",
+    "cac": "^6.7.14",
+    "chai-subset": "^1.6.0",
+    "cli-truncate": "^4.0.0",
+    "fast-glob": "3.3.2",
+    "find-up": "^6.3.0",
+    "flatted": "^3.3.1",
+    "get-tsconfig": "^4.8.1",
+    "happy-dom": "^15.11.4",
+    "jsdom": "^25.0.1",
+    "local-pkg": "^0.5.0",
+    "log-update": "^5.0.1",
+    "micromatch": "^4.0.8",
+    "pretty-format": "^29.7.0",
+    "prompts": "^2.4.2",
+    "strip-literal": "^2.1.0",
+    "ws": "^8.18.0"
+  },
+  "scripts": {
+    "build": "rimraf dist && rollup -c",
+    "dev": "NODE_OPTIONS=\"--max-old-space-size=8192\" rollup -c --watch -m inline"
+  }
+}

pwa/node_modules/vitest/reporters.d.ts

@@ -0,0 +1 @@
+export * from './dist/reporters.js'

pwa/node_modules/vitest/runners.d.ts

@@ -0,0 +1 @@
+export * from './dist/runners.js'

pwa/node_modules/vitest/snapshot.d.ts

@@ -0,0 +1 @@
+export * from './dist/snapshot.js'