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/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 };