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/mocker/dist/auto-register.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

pwa/node_modules/@vitest/mocker/dist/auto-register.js

@@ -0,0 +1,11 @@
+import { M as ModuleMockerServerInterceptor } from './chunk-interceptor-native.js';
+import { registerModuleMocker } from './register.js';
+import './chunk-mocker.js';
+import './index.js';
+import './chunk-registry.js';
+import './chunk-pathe.ff20891b.js';
+import '@vitest/spy';
+
+registerModuleMocker(
+  () => new ModuleMockerServerInterceptor()
+);

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

@@ -0,0 +1,51 @@
+import { M as ModuleMockerInterceptor } from './mocker-pQgp1HFr.js';
+export { C as CompilerHintsOptions, b as ModuleMocker, a as ModuleMockerCompilerHints, d as ModuleMockerConfig, e as ModuleMockerRPC, R as ResolveIdResult, f as ResolveMockResul, c as createCompilerHints } from './mocker-pQgp1HFr.js';
+import { StartOptions, SetupWorker } from 'msw/browser';
+import { c as MockerRegistry, g as MockedModule } from './types-DZOqTgiN.js';
+import '@vitest/spy';
+
+interface ModuleMockerMSWInterceptorOptions {
+    /**
+     * The identifier to access the globalThis object in the worker.
+     * This will be injected into the script as is, so make sure it's a valid JS expression.
+     * @example
+     * ```js
+     * // globalThisAccessor: '__my_variable__' produces:
+     * globalThis[__my_variable__]
+     * // globalThisAccessor: 'Symbol.for('secret:mocks')' produces:
+     * globalThis[Symbol.for('secret:mocks')]
+     * // globalThisAccessor: '"__vitest_mocker__"' (notice quotes) produces:
+     * globalThis["__vitest_mocker__"]
+     * ```
+     * @default `"__vitest_mocker__"`
+     */
+    globalThisAccessor?: string;
+    /**
+     * Options passed down to `msw.setupWorker().start(options)`
+     */
+    mswOptions?: StartOptions;
+    /**
+     * A pre-configured `msw.setupWorker` instance.
+     */
+    mswWorker?: SetupWorker;
+}
+declare class ModuleMockerMSWInterceptor implements ModuleMockerInterceptor {
+    private readonly options;
+    protected readonly mocks: MockerRegistry;
+    private startPromise;
+    private worker;
+    constructor(options?: ModuleMockerMSWInterceptorOptions);
+    register(module: MockedModule): Promise<void>;
+    delete(url: string): Promise<void>;
+    invalidate(): void;
+    private resolveManualMock;
+    protected init(): Promise<SetupWorker>;
+}
+
+declare class ModuleMockerServerInterceptor implements ModuleMockerInterceptor {
+    register(module: MockedModule): Promise<void>;
+    delete(id: string): Promise<void>;
+    invalidate(): void;
+}
+
+export { ModuleMockerInterceptor, ModuleMockerMSWInterceptor, type ModuleMockerMSWInterceptorOptions, ModuleMockerServerInterceptor };

pwa/node_modules/@vitest/mocker/dist/browser.js

@@ -0,0 +1,116 @@
+export { M as ModuleMocker, c as createCompilerHints } from './chunk-mocker.js';
+import { M as MockerRegistry } from './chunk-registry.js';
+import { c as cleanUrl } from './chunk-utils.js';
+export { M as ModuleMockerServerInterceptor } from './chunk-interceptor-native.js';
+import './index.js';
+import './chunk-pathe.ff20891b.js';
+
+class ModuleMockerMSWInterceptor {
+  constructor(options = {}) {
+    this.options = options;
+    if (!options.globalThisAccessor) {
+      options.globalThisAccessor = '"__vitest_mocker__"';
+    }
+  }
+  mocks = new MockerRegistry();
+  startPromise;
+  worker;
+  async register(module) {
+    await this.init();
+    this.mocks.add(module);
+  }
+  async delete(url) {
+    await this.init();
+    this.mocks.delete(url);
+  }
+  invalidate() {
+    this.mocks.clear();
+  }
+  async resolveManualMock(mock) {
+    const exports = Object.keys(await mock.resolve());
+    const module = `const module = globalThis[${this.options.globalThisAccessor}].getFactoryModule("${mock.url}");`;
+    const keys = exports.map((name) => {
+      if (name === "default") {
+        return `export default module["default"];`;
+      }
+      return `export const ${name} = module["${name}"];`;
+    }).join("\n");
+    const text = `${module}
+${keys}`;
+    return new Response(text, {
+      headers: {
+        "Content-Type": "application/javascript"
+      }
+    });
+  }
+  async init() {
+    if (this.worker) {
+      return this.worker;
+    }
+    if (this.startPromise) {
+      return this.startPromise;
+    }
+    const worker = this.options.mswWorker;
+    this.startPromise = Promise.all([
+      worker ? {
+        setupWorker(handler) {
+          worker.use(handler);
+          return worker;
+        }
+      } : import('msw/browser'),
+      import('msw/core/http')
+    ]).then(([{ setupWorker }, { http }]) => {
+      const worker2 = setupWorker(
+        http.get(/.+/, async ({ request }) => {
+          const path = cleanQuery(request.url.slice(location.origin.length));
+          if (!this.mocks.has(path)) {
+            return passthrough();
+          }
+          const mock = this.mocks.get(path);
+          switch (mock.type) {
+            case "manual":
+              return this.resolveManualMock(mock);
+            case "automock":
+            case "autospy":
+              return Response.redirect(injectQuery(path, `mock=${mock.type}`));
+            case "redirect":
+              return Response.redirect(mock.redirect);
+            default:
+              throw new Error(`Unknown mock type: ${mock.type}`);
+          }
+        })
+      );
+      return worker2.start(this.options.mswOptions).then(() => worker2);
+    }).finally(() => {
+      this.worker = worker;
+      this.startPromise = void 0;
+    });
+    return await this.startPromise;
+  }
+}
+const timestampRegexp = /(\?|&)t=\d{13}/;
+const versionRegexp = /(\?|&)v=\w{8}/;
+function cleanQuery(url) {
+  return url.replace(timestampRegexp, "").replace(versionRegexp, "");
+}
+function passthrough() {
+  return new Response(null, {
+    status: 302,
+    statusText: "Passthrough",
+    headers: {
+      "x-msw-intention": "passthrough"
+    }
+  });
+}
+const replacePercentageRE = /%/g;
+function injectQuery(url, queryToInject) {
+  const resolvedUrl = new URL(
+    url.replace(replacePercentageRE, "%25"),
+    location.href
+  );
+  const { search, hash } = resolvedUrl;
+  const pathname = cleanUrl(url);
+  return `${pathname}?${queryToInject}${search ? `&${search.slice(1)}` : ""}${hash ?? ""}`;
+}
+
+export { ModuleMockerMSWInterceptor };

pwa/node_modules/@vitest/mocker/dist/chunk-interceptor-native.js

@@ -0,0 +1,15 @@
+import { r as rpc } from './chunk-mocker.js';
+
+class ModuleMockerServerInterceptor {
+  async register(module) {
+    await rpc("vitest:interceptor:register", module.toJSON());
+  }
+  async delete(id) {
+    await rpc("vitest:interceptor:delete", id);
+  }
+  invalidate() {
+    rpc("vitest:interceptor:invalidate");
+  }
+}
+
+export { ModuleMockerServerInterceptor as M };

pwa/node_modules/@vitest/mocker/dist/chunk-mocker.js

@@ -0,0 +1,532 @@
+import { mockObject } from './index.js';
+import { M as MockerRegistry, R as RedirectedModule, A as AutomockedModule } from './chunk-registry.js';
+import { e as extname, j as join } from './chunk-pathe.ff20891b.js';
+
+function createSimpleStackTrace(options) {
+  const { message = "$$stack trace error", stackTraceLimit = 1 } = options || {};
+  const limit = Error.stackTraceLimit;
+  const prepareStackTrace = Error.prepareStackTrace;
+  Error.stackTraceLimit = stackTraceLimit;
+  Error.prepareStackTrace = (e) => e.stack;
+  const err = new Error(message);
+  const stackTrace = err.stack || "";
+  Error.prepareStackTrace = prepareStackTrace;
+  Error.stackTraceLimit = limit;
+  return stackTrace;
+}
+
+const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const intToChar = new Uint8Array(64);
+const charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+  const c = chars.charCodeAt(i);
+  intToChar[i] = c;
+  charToInt[c] = i;
+}
+var UrlType;
+(function(UrlType2) {
+  UrlType2[UrlType2["Empty"] = 1] = "Empty";
+  UrlType2[UrlType2["Hash"] = 2] = "Hash";
+  UrlType2[UrlType2["Query"] = 3] = "Query";
+  UrlType2[UrlType2["RelativePath"] = 4] = "RelativePath";
+  UrlType2[UrlType2["AbsolutePath"] = 5] = "AbsolutePath";
+  UrlType2[UrlType2["SchemeRelative"] = 6] = "SchemeRelative";
+  UrlType2[UrlType2["Absolute"] = 7] = "Absolute";
+})(UrlType || (UrlType = {}));
+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 _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+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 CHROME_IE_STACK_REGEXP = /^\s*at .*(?:\S:\d+|\(native\))/m;
+const SAFARI_NATIVE_CODE_REGEXP = /^(?:eval@)?(?:\[native code\])?$/;
+function extractLocation(urlLike) {
+  if (!urlLike.includes(":")) {
+    return [urlLike];
+  }
+  const regExp = /(.+?)(?::(\d+))?(?::(\d+))?$/;
+  const parts = regExp.exec(urlLike.replace(/^\(|\)$/g, ""));
+  if (!parts) {
+    return [urlLike];
+  }
+  let url = parts[1];
+  if (url.startsWith("async ")) {
+    url = url.slice(6);
+  }
+  if (url.startsWith("http:") || url.startsWith("https:")) {
+    const urlObj = new URL(url);
+    url = urlObj.pathname;
+  }
+  if (url.startsWith("/@fs/")) {
+    const isWindows = /^\/@fs\/[a-zA-Z]:\//.test(url);
+    url = url.slice(isWindows ? 5 : 4);
+  }
+  return [url, parts[2] || void 0, parts[3] || void 0];
+}
+function parseSingleFFOrSafariStack(raw) {
+  let line = raw.trim();
+  if (SAFARI_NATIVE_CODE_REGEXP.test(line)) {
+    return null;
+  }
+  if (line.includes(" > eval")) {
+    line = line.replace(
+      / line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g,
+      ":$1"
+    );
+  }
+  if (!line.includes("@") && !line.includes(":")) {
+    return null;
+  }
+  const functionNameRegex = /((.*".+"[^@]*)?[^@]*)(@)/;
+  const matches = line.match(functionNameRegex);
+  const functionName = matches && matches[1] ? matches[1] : void 0;
+  const [url, lineNumber, columnNumber] = extractLocation(
+    line.replace(functionNameRegex, "")
+  );
+  if (!url || !lineNumber || !columnNumber) {
+    return null;
+  }
+  return {
+    file: url,
+    method: functionName || "",
+    line: Number.parseInt(lineNumber),
+    column: Number.parseInt(columnNumber)
+  };
+}
+function parseSingleStack(raw) {
+  const line = raw.trim();
+  if (!CHROME_IE_STACK_REGEXP.test(line)) {
+    return parseSingleFFOrSafariStack(line);
+  }
+  return parseSingleV8Stack(line);
+}
+function parseSingleV8Stack(raw) {
+  let line = raw.trim();
+  if (!CHROME_IE_STACK_REGEXP.test(line)) {
+    return null;
+  }
+  if (line.includes("(eval ")) {
+    line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(,.*$)/g, "");
+  }
+  let sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, "");
+  const location = sanitizedLine.match(/ (\(.+\)$)/);
+  sanitizedLine = location ? sanitizedLine.replace(location[0], "") : sanitizedLine;
+  const [url, lineNumber, columnNumber] = extractLocation(
+    location ? location[1] : sanitizedLine
+  );
+  let method = location && sanitizedLine || "";
+  let file = url && ["eval", "<anonymous>"].includes(url) ? void 0 : url;
+  if (!file || !lineNumber || !columnNumber) {
+    return null;
+  }
+  if (method.startsWith("async ")) {
+    method = method.slice(6);
+  }
+  if (file.startsWith("file://")) {
+    file = file.slice(7);
+  }
+  file = resolve(file);
+  if (method) {
+    method = method.replace(/__vite_ssr_import_\d+__\./g, "");
+  }
+  return {
+    method,
+    file,
+    line: Number.parseInt(lineNumber),
+    column: Number.parseInt(columnNumber)
+  };
+}
+
+function createCompilerHints(options) {
+  const globalThisAccessor = (options == null ? void 0 : options.globalThisKey) || "__vitest_mocker__";
+  function _mocker() {
+    return typeof globalThis[globalThisAccessor] !== "undefined" ? globalThis[globalThisAccessor] : new Proxy(
+      {},
+      {
+        get(_, name) {
+          throw new Error(
+            `Vitest mocker was not initialized in this environment. vi.${String(name)}() is forbidden.`
+          );
+        }
+      }
+    );
+  }
+  return {
+    hoisted(factory) {
+      if (typeof factory !== "function") {
+        throw new TypeError(
+          `vi.hoisted() expects a function, but received a ${typeof factory}`
+        );
+      }
+      return factory();
+    },
+    mock(path, factory) {
+      if (typeof path !== "string") {
+        throw new TypeError(
+          `vi.mock() expects a string path, but received a ${typeof path}`
+        );
+      }
+      const importer = getImporter("mock");
+      _mocker().queueMock(
+        path,
+        importer,
+        typeof factory === "function" ? () => factory(
+          () => _mocker().importActual(
+            path,
+            importer
+          )
+        ) : factory
+      );
+    },
+    unmock(path) {
+      if (typeof path !== "string") {
+        throw new TypeError(
+          `vi.unmock() expects a string path, but received a ${typeof path}`
+        );
+      }
+      _mocker().queueUnmock(path, getImporter("unmock"));
+    },
+    doMock(path, factory) {
+      if (typeof path !== "string") {
+        throw new TypeError(
+          `vi.doMock() expects a string path, but received a ${typeof path}`
+        );
+      }
+      const importer = getImporter("doMock");
+      _mocker().queueMock(
+        path,
+        importer,
+        typeof factory === "function" ? () => factory(
+          () => _mocker().importActual(
+            path,
+            importer
+          )
+        ) : factory
+      );
+    },
+    doUnmock(path) {
+      if (typeof path !== "string") {
+        throw new TypeError(
+          `vi.doUnmock() expects a string path, but received a ${typeof path}`
+        );
+      }
+      _mocker().queueUnmock(path, getImporter("doUnmock"));
+    },
+    async importActual(path) {
+      return _mocker().importActual(
+        path,
+        getImporter("importActual")
+      );
+    },
+    async importMock(path) {
+      return _mocker().importMock(path, getImporter("importMock"));
+    }
+  };
+}
+function getImporter(name) {
+  const stackTrace = /* @__PURE__ */ createSimpleStackTrace({ stackTraceLimit: 5 });
+  const stackArray = stackTrace.split("\n");
+  const importerStackIndex = stackArray.findIndex((stack2) => {
+    return stack2.includes(` at Object.${name}`) || stack2.includes(`${name}@`);
+  });
+  const stack = /* @__PURE__ */ parseSingleStack(stackArray[importerStackIndex + 1]);
+  return (stack == null ? void 0 : stack.file) || "";
+}
+
+const hot = import.meta.hot || {
+  on: warn,
+  off: warn,
+  send: warn
+};
+function warn() {
+  console.warn("Vitest mocker cannot work if Vite didn't establish WS connection.");
+}
+function rpc(event, data) {
+  hot.send(event, data);
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error(`Failed to resolve ${event} in time`));
+    }, 5e3);
+    hot.on(`${event}:result`, function r(data2) {
+      resolve(data2);
+      clearTimeout(timeout);
+      hot.off("vitest:mocks:resolvedId:result", r);
+    });
+  });
+}
+
+const { now } = Date;
+class ModuleMocker {
+  constructor(interceptor, rpc, spyOn, config) {
+    this.interceptor = interceptor;
+    this.rpc = rpc;
+    this.spyOn = spyOn;
+    this.config = config;
+  }
+  registry = new MockerRegistry();
+  queue = /* @__PURE__ */ new Set();
+  mockedIds = /* @__PURE__ */ new Set();
+  async prepare() {
+    if (!this.queue.size) {
+      return;
+    }
+    await Promise.all([...this.queue.values()]);
+  }
+  async resolveFactoryModule(id) {
+    const mock = this.registry.get(id);
+    if (!mock || mock.type !== "manual") {
+      throw new Error(`Mock ${id} wasn't registered. This is probably a Vitest error. Please, open a new issue with reproduction.`);
+    }
+    const result = await mock.resolve();
+    return result;
+  }
+  getFactoryModule(id) {
+    const mock = this.registry.get(id);
+    if (!mock || mock.type !== "manual") {
+      throw new Error(`Mock ${id} wasn't registered. This is probably a Vitest error. Please, open a new issue with reproduction.`);
+    }
+    if (!mock.cache) {
+      throw new Error(`Mock ${id} wasn't resolved. This is probably a Vitest error. Please, open a new issue with reproduction.`);
+    }
+    return mock.cache;
+  }
+  async invalidate() {
+    const ids = Array.from(this.mockedIds);
+    if (!ids.length) {
+      return;
+    }
+    await this.rpc.invalidate(ids);
+    this.interceptor.invalidate();
+    this.registry.clear();
+  }
+  async importActual(id, importer) {
+    const resolved = await this.rpc.resolveId(id, importer);
+    if (resolved == null) {
+      throw new Error(
+        `[vitest] Cannot resolve "${id}" imported from "${importer}"`
+      );
+    }
+    const ext = extname(resolved.id);
+    const url = new URL(resolved.url, location.href);
+    const query = `_vitest_original&ext${ext}`;
+    const actualUrl = `${url.pathname}${url.search ? `${url.search}&${query}` : `?${query}`}${url.hash}`;
+    return this.wrapDynamicImport(() => import(
+      /* @vite-ignore */
+      actualUrl
+    )).then((mod) => {
+      if (!resolved.optimized || typeof mod.default === "undefined") {
+        return mod;
+      }
+      const m = mod.default;
+      return (m == null ? void 0 : m.__esModule) ? m : { ...typeof m === "object" && !Array.isArray(m) || typeof m === "function" ? m : {}, default: m };
+    });
+  }
+  async importMock(rawId, importer) {
+    await this.prepare();
+    const { resolvedId, redirectUrl } = await this.rpc.resolveMock(
+      rawId,
+      importer,
+      { mock: "auto" }
+    );
+    const mockUrl = this.resolveMockPath(cleanVersion(resolvedId));
+    let mock = this.registry.get(mockUrl);
+    if (!mock) {
+      if (redirectUrl) {
+        const resolvedRedirect = new URL(this.resolveMockPath(cleanVersion(redirectUrl)), location.href).toString();
+        mock = new RedirectedModule(rawId, mockUrl, resolvedRedirect);
+      } else {
+        mock = new AutomockedModule(rawId, mockUrl);
+      }
+    }
+    if (mock.type === "manual") {
+      return await mock.resolve();
+    }
+    if (mock.type === "automock" || mock.type === "autospy") {
+      const url = new URL(`/@id/${resolvedId}`, location.href);
+      const query = url.search ? `${url.search}&t=${now()}` : `?t=${now()}`;
+      const moduleObject = await import(
+        /* @vite-ignore */
+        `${url.pathname}${query}&mock=${mock.type}${url.hash}`
+      );
+      return this.mockObject(moduleObject, mock.type);
+    }
+    return import(
+      /* @vite-ignore */
+      mock.redirect
+    );
+  }
+  mockObject(object, moduleType = "automock") {
+    return mockObject({
+      globalConstructors: {
+        Object,
+        Function,
+        Array,
+        Map,
+        RegExp
+      },
+      spyOn: this.spyOn,
+      type: moduleType
+    }, object);
+  }
+  queueMock(rawId, importer, factoryOrOptions) {
+    const promise = this.rpc.resolveMock(rawId, importer, {
+      mock: typeof factoryOrOptions === "function" ? "factory" : (factoryOrOptions == null ? void 0 : factoryOrOptions.spy) ? "spy" : "auto"
+    }).then(async ({ redirectUrl, resolvedId, needsInterop, mockType }) => {
+      const mockUrl = this.resolveMockPath(cleanVersion(resolvedId));
+      this.mockedIds.add(resolvedId);
+      const factory = typeof factoryOrOptions === "function" ? async () => {
+        const data = await factoryOrOptions();
+        return needsInterop ? { default: data } : data;
+      } : void 0;
+      const mockRedirect = typeof redirectUrl === "string" ? new URL(this.resolveMockPath(cleanVersion(redirectUrl)), location.href).toString() : null;
+      let module;
+      if (mockType === "manual") {
+        module = this.registry.register("manual", rawId, mockUrl, factory);
+      } else if (mockType === "autospy") {
+        module = this.registry.register("autospy", rawId, mockUrl);
+      } else if (mockType === "redirect") {
+        module = this.registry.register("redirect", rawId, mockUrl, mockRedirect);
+      } else {
+        module = this.registry.register("automock", rawId, mockUrl);
+      }
+      await this.interceptor.register(module);
+    }).finally(() => {
+      this.queue.delete(promise);
+    });
+    this.queue.add(promise);
+  }
+  queueUnmock(id, importer) {
+    const promise = this.rpc.resolveId(id, importer).then(async (resolved) => {
+      if (!resolved) {
+        return;
+      }
+      const mockUrl = this.resolveMockPath(cleanVersion(resolved.id));
+      this.mockedIds.add(resolved.id);
+      this.registry.delete(mockUrl);
+      await this.interceptor.delete(mockUrl);
+    }).finally(() => {
+      this.queue.delete(promise);
+    });
+    this.queue.add(promise);
+  }
+  // We need to await mock registration before importing the actual module
+  // In case there is a mocked module in the import chain
+  wrapDynamicImport(moduleFactory) {
+    if (typeof moduleFactory === "function") {
+      const promise = new Promise((resolve, reject) => {
+        this.prepare().finally(() => {
+          moduleFactory().then(resolve, reject);
+        });
+      });
+      return promise;
+    }
+    return moduleFactory;
+  }
+  resolveMockPath(path) {
+    const config = this.config;
+    const fsRoot = join("/@fs/", config.root);
+    if (path.startsWith(config.root)) {
+      return path.slice(config.root.length);
+    }
+    if (path.startsWith(fsRoot)) {
+      return path.slice(fsRoot.length);
+    }
+    return path;
+  }
+}
+const versionRegexp = /(\?|&)v=\w{8}/;
+function cleanVersion(url) {
+  return url.replace(versionRegexp, "");
+}
+
+export { ModuleMocker as M, createCompilerHints as c, hot as h, rpc as r };

pwa/node_modules/@vitest/mocker/dist/chunk-pathe.ff20891b.js

@@ -0,0 +1,163 @@
+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;
+};
+
+export { basename as b, dirname as d, extname as e, isAbsolute as i, join as j, resolve as r };

pwa/node_modules/@vitest/mocker/dist/chunk-registry.js

@@ -0,0 +1,171 @@
+class MockerRegistry {
+  registry = /* @__PURE__ */ new Map();
+  clear() {
+    this.registry.clear();
+  }
+  keys() {
+    return this.registry.keys();
+  }
+  add(mock) {
+    this.registry.set(mock.url, mock);
+  }
+  register(typeOrEvent, raw, url, factoryOrRedirect) {
+    const type = typeof typeOrEvent === "object" ? typeOrEvent.type : typeOrEvent;
+    if (typeof typeOrEvent === "object") {
+      const event = typeOrEvent;
+      if (event instanceof AutomockedModule || event instanceof AutospiedModule || event instanceof ManualMockedModule || event instanceof RedirectedModule) {
+        throw new TypeError(
+          `[vitest] Cannot register a mock that is already defined. Expected a JSON representation from \`MockedModule.toJSON\`, instead got "${event.type}". Use "registry.add()" to update a mock instead.`
+        );
+      }
+      if (event.type === "automock") {
+        const module = AutomockedModule.fromJSON(event);
+        this.add(module);
+        return module;
+      } else if (event.type === "autospy") {
+        const module = AutospiedModule.fromJSON(event);
+        this.add(module);
+        return module;
+      } else if (event.type === "redirect") {
+        const module = RedirectedModule.fromJSON(event);
+        this.add(module);
+        return module;
+      } else if (event.type === "manual") {
+        throw new Error(`Cannot set serialized manual mock. Define a factory function manually with \`ManualMockedModule.fromJSON()\`.`);
+      } else {
+        throw new Error(`Unknown mock type: ${event.type}`);
+      }
+    }
+    if (typeof raw !== "string") {
+      throw new TypeError("[vitest] Mocks require a raw string.");
+    }
+    if (typeof url !== "string") {
+      throw new TypeError("[vitest] Mocks require a url string.");
+    }
+    if (type === "manual") {
+      if (typeof factoryOrRedirect !== "function") {
+        throw new TypeError("[vitest] Manual mocks require a factory function.");
+      }
+      const mock = new ManualMockedModule(raw, url, factoryOrRedirect);
+      this.add(mock);
+      return mock;
+    } else if (type === "automock" || type === "autospy") {
+      const mock = type === "automock" ? new AutomockedModule(raw, url) : new AutospiedModule(raw, url);
+      this.add(mock);
+      return mock;
+    } else if (type === "redirect") {
+      if (typeof factoryOrRedirect !== "string") {
+        throw new TypeError("[vitest] Redirect mocks require a redirect string.");
+      }
+      const mock = new RedirectedModule(raw, url, factoryOrRedirect);
+      this.add(mock);
+      return mock;
+    } else {
+      throw new Error(`[vitest] Unknown mock type: ${type}`);
+    }
+  }
+  delete(id) {
+    this.registry.delete(id);
+  }
+  get(id) {
+    return this.registry.get(id);
+  }
+  has(id) {
+    return this.registry.has(id);
+  }
+}
+class AutomockedModule {
+  constructor(raw, url) {
+    this.raw = raw;
+    this.url = url;
+  }
+  type = "automock";
+  static fromJSON(data) {
+    return new AutospiedModule(data.raw, data.url);
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      url: this.url,
+      raw: this.raw
+    };
+  }
+}
+class AutospiedModule {
+  constructor(raw, url) {
+    this.raw = raw;
+    this.url = url;
+  }
+  type = "autospy";
+  static fromJSON(data) {
+    return new AutospiedModule(data.raw, data.url);
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      url: this.url,
+      raw: this.raw
+    };
+  }
+}
+class RedirectedModule {
+  constructor(raw, url, redirect) {
+    this.raw = raw;
+    this.url = url;
+    this.redirect = redirect;
+  }
+  type = "redirect";
+  static fromJSON(data) {
+    return new RedirectedModule(data.raw, data.url, data.redirect);
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      url: this.url,
+      raw: this.raw,
+      redirect: this.redirect
+    };
+  }
+}
+class ManualMockedModule {
+  constructor(raw, url, factory) {
+    this.raw = raw;
+    this.url = url;
+    this.factory = factory;
+  }
+  cache;
+  type = "manual";
+  async resolve() {
+    if (this.cache) {
+      return this.cache;
+    }
+    let exports;
+    try {
+      exports = await this.factory();
+    } catch (err) {
+      const vitestError = new Error(
+        '[vitest] There was an error when mocking a module. If you are using "vi.mock" factory, make sure there are no top level variables inside, since this call is hoisted to top of the file. Read more: https://vitest.dev/api/vi.html#vi-mock'
+      );
+      vitestError.cause = err;
+      throw vitestError;
+    }
+    if (exports === null || typeof exports !== "object" || Array.isArray(exports)) {
+      throw new TypeError(
+        `[vitest] vi.mock("${this.raw}", factory?: () => unknown) is not returning an object. Did you mean to return an object with a "default" key?`
+      );
+    }
+    return this.cache = exports;
+  }
+  static fromJSON(data, factory) {
+    return new ManualMockedModule(data.raw, data.url, factory);
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      url: this.url,
+      raw: this.raw
+    };
+  }
+}
+
+export { AutomockedModule as A, MockerRegistry as M, RedirectedModule as R, ManualMockedModule as a, AutospiedModule as b };

pwa/node_modules/@vitest/mocker/dist/chunk-utils.js

@@ -0,0 +1,6 @@
+const postfixRE = /[?#].*$/;
+function cleanUrl(url) {
+  return url.replace(postfixRE, "");
+}
+
+export { cleanUrl as c };

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

@@ -0,0 +1,19 @@
+import { M as MockedModuleType } from './types-DZOqTgiN.js';
+export { A as AutomockedModule, d as AutomockedModuleSerialized, a as AutospiedModule, e as AutospiedModuleSerialized, b as ManualMockedModule, f as ManualMockedModuleSerialized, g as MockedModule, h as MockedModuleSerialized, c as MockerRegistry, j as ModuleMockFactory, k as ModuleMockFactoryWithHelper, l as ModuleMockOptions, R as RedirectedModule, i as RedirectedModuleSerialized } from './types-DZOqTgiN.js';
+
+type Key = string | symbol;
+interface MockObjectOptions {
+    type: MockedModuleType;
+    globalConstructors: GlobalConstructors;
+    spyOn: (obj: any, prop: Key) => any;
+}
+declare function mockObject(options: MockObjectOptions, object: Record<Key, any>, mockExports?: Record<Key, any>): Record<Key, any>;
+interface GlobalConstructors {
+    Object: ObjectConstructor;
+    Function: FunctionConstructor;
+    RegExp: RegExpConstructor;
+    Array: ArrayConstructor;
+    Map: MapConstructor;
+}
+
+export { type GlobalConstructors, type MockObjectOptions, MockedModuleType, mockObject };

pwa/node_modules/@vitest/mocker/dist/index.js

@@ -0,0 +1,158 @@
+export { A as AutomockedModule, b as AutospiedModule, a as ManualMockedModule, M as MockerRegistry, R as RedirectedModule } from './chunk-registry.js';
+
+function mockObject(options, object, mockExports = {}) {
+  const finalizers = new Array();
+  const refs = new RefTracker();
+  const define = (container, key, value) => {
+    try {
+      container[key] = value;
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const mockPropertiesOf = (container, newContainer) => {
+    const containerType = getType(container);
+    const isModule = containerType === "Module" || !!container.__esModule;
+    for (const { key: property, descriptor } of getAllMockableProperties(
+      container,
+      isModule,
+      options.globalConstructors
+    )) {
+      if (!isModule && descriptor.get) {
+        try {
+          Object.defineProperty(newContainer, property, descriptor);
+        } catch {
+        }
+        continue;
+      }
+      if (isSpecialProp(property, containerType)) {
+        continue;
+      }
+      const value = container[property];
+      const refId = refs.getId(value);
+      if (refId !== void 0) {
+        finalizers.push(
+          () => define(newContainer, property, refs.getMockedValue(refId))
+        );
+        continue;
+      }
+      const type = getType(value);
+      if (Array.isArray(value)) {
+        define(newContainer, property, []);
+        continue;
+      }
+      const isFunction = type.includes("Function") && typeof value === "function";
+      if ((!isFunction || value.__isMockFunction) && type !== "Object" && type !== "Module") {
+        define(newContainer, property, value);
+        continue;
+      }
+      if (!define(newContainer, property, isFunction ? value : {})) {
+        continue;
+      }
+      if (isFunction) {
+        let mockFunction2 = function() {
+          if (this instanceof newContainer[property]) {
+            for (const { key, descriptor: descriptor2 } of getAllMockableProperties(
+              this,
+              false,
+              options.globalConstructors
+            )) {
+              if (descriptor2.get) {
+                continue;
+              }
+              const value2 = this[key];
+              const type2 = getType(value2);
+              const isFunction2 = type2.includes("Function") && typeof value2 === "function";
+              if (isFunction2) {
+                const original = this[key];
+                const mock2 = spyOn(this, key).mockImplementation(original);
+                mock2.mockRestore = () => {
+                  mock2.mockReset();
+                  mock2.mockImplementation(original);
+                  return mock2;
+                };
+              }
+            }
+          }
+        };
+        if (!options.spyOn) {
+          throw new Error(
+            "[@vitest/mocker] `spyOn` is not defined. This is a Vitest error. Please open a new issue with reproduction."
+          );
+        }
+        const spyOn = options.spyOn;
+        const mock = spyOn(newContainer, property);
+        if (options.type === "automock") {
+          mock.mockImplementation(mockFunction2);
+          mock.mockRestore = () => {
+            mock.mockReset();
+            mock.mockImplementation(mockFunction2);
+            return mock;
+          };
+        }
+        Object.defineProperty(newContainer[property], "length", { value: 0 });
+      }
+      refs.track(value, newContainer[property]);
+      mockPropertiesOf(value, newContainer[property]);
+    }
+  };
+  const mockedObject = mockExports;
+  mockPropertiesOf(object, mockedObject);
+  for (const finalizer of finalizers) {
+    finalizer();
+  }
+  return mockedObject;
+}
+class RefTracker {
+  idMap = /* @__PURE__ */ new Map();
+  mockedValueMap = /* @__PURE__ */ new Map();
+  getId(value) {
+    return this.idMap.get(value);
+  }
+  getMockedValue(id) {
+    return this.mockedValueMap.get(id);
+  }
+  track(originalValue, mockedValue) {
+    const newId = this.idMap.size;
+    this.idMap.set(originalValue, newId);
+    this.mockedValueMap.set(newId, mockedValue);
+    return newId;
+  }
+}
+function getType(value) {
+  return Object.prototype.toString.apply(value).slice(8, -1);
+}
+function isSpecialProp(prop, parentType) {
+  return parentType.includes("Function") && typeof prop === "string" && ["arguments", "callee", "caller", "length", "name"].includes(prop);
+}
+function getAllMockableProperties(obj, isModule, constructors) {
+  const { Map: Map2, Object: Object2, Function, RegExp, Array: Array2 } = constructors;
+  const allProps = new Map2();
+  let curr = obj;
+  do {
+    if (curr === Object2.prototype || curr === Function.prototype || curr === RegExp.prototype) {
+      break;
+    }
+    collectOwnProperties(curr, (key) => {
+      const descriptor = Object2.getOwnPropertyDescriptor(curr, key);
+      if (descriptor) {
+        allProps.set(key, { key, descriptor });
+      }
+    });
+  } while (curr = Object2.getPrototypeOf(curr));
+  if (isModule && !allProps.has("default") && "default" in obj) {
+    const descriptor = Object2.getOwnPropertyDescriptor(obj, "default");
+    if (descriptor) {
+      allProps.set("default", { key: "default", descriptor });
+    }
+  }
+  return Array2.from(allProps.values());
+}
+function collectOwnProperties(obj, collector) {
+  const collect = typeof collector === "function" ? collector : (key) => collector.add(key);
+  Object.getOwnPropertyNames(obj).forEach(collect);
+  Object.getOwnPropertySymbols(obj).forEach(collect);
+}
+
+export { mockObject };

pwa/node_modules/@vitest/mocker/dist/mocker-pQgp1HFr.d.ts

@@ -0,0 +1,78 @@
+import { MaybeMockedDeep } from '@vitest/spy';
+import { l as ModuleMockOptions, k as ModuleMockFactoryWithHelper, g as MockedModule, c as MockerRegistry, M as MockedModuleType } from './types-DZOqTgiN.js';
+
+interface CompilerHintsOptions {
+    /**
+     * This is the key used to access the globalThis object in the worker.
+     * Unlike `globalThisAccessor` in other APIs, this is not injected into the script.
+     * ```ts
+     * // globalThisKey: '__my_variable__' produces:
+     * globalThis['__my_variable__']
+     * // globalThisKey: '"__my_variable__"' produces:
+     * globalThis['"__my_variable__"'] // notice double quotes
+     * ```
+     * @default '__vitest_mocker__'
+     */
+    globalThisKey?: string;
+}
+interface ModuleMockerCompilerHints {
+    hoisted: <T>(factory: () => T) => T;
+    mock: (path: string | Promise<unknown>, factory?: ModuleMockOptions | ModuleMockFactoryWithHelper) => void;
+    unmock: (path: string | Promise<unknown>) => void;
+    doMock: (path: string | Promise<unknown>, factory?: ModuleMockOptions | ModuleMockFactoryWithHelper) => void;
+    doUnmock: (path: string | Promise<unknown>) => void;
+    importActual: <T>(path: string) => Promise<T>;
+    importMock: <T>(path: string) => Promise<MaybeMockedDeep<T>>;
+}
+declare function createCompilerHints(options?: CompilerHintsOptions): ModuleMockerCompilerHints;
+
+interface ModuleMockerInterceptor {
+    register: (module: MockedModule) => Promise<void>;
+    delete: (url: string) => Promise<void>;
+    invalidate: () => void;
+}
+
+declare class ModuleMocker {
+    private interceptor;
+    private rpc;
+    private spyOn;
+    private config;
+    protected registry: MockerRegistry;
+    private queue;
+    private mockedIds;
+    constructor(interceptor: ModuleMockerInterceptor, rpc: ModuleMockerRPC, spyOn: (obj: any, method: string | symbol) => any, config: ModuleMockerConfig);
+    prepare(): Promise<void>;
+    resolveFactoryModule(id: string): Promise<Record<string | symbol, any>>;
+    getFactoryModule(id: string): any;
+    invalidate(): Promise<void>;
+    importActual<T>(id: string, importer: string): Promise<T>;
+    importMock<T>(rawId: string, importer: string): Promise<T>;
+    mockObject(object: Record<string | symbol, any>, moduleType?: MockedModuleType): Record<string | symbol, any>;
+    queueMock(rawId: string, importer: string, factoryOrOptions?: ModuleMockOptions | (() => any)): void;
+    queueUnmock(id: string, importer: string): void;
+    wrapDynamicImport<T>(moduleFactory: () => Promise<T>): Promise<T>;
+    private resolveMockPath;
+}
+interface ResolveIdResult {
+    id: string;
+    url: string;
+    optimized: boolean;
+}
+interface ResolveMockResul {
+    mockType: MockedModuleType;
+    resolvedId: string;
+    redirectUrl?: string | null;
+    needsInterop?: boolean;
+}
+interface ModuleMockerRPC {
+    invalidate: (ids: string[]) => Promise<void>;
+    resolveId: (id: string, importer: string) => Promise<ResolveIdResult | null>;
+    resolveMock: (id: string, importer: string, options: {
+        mock: 'spy' | 'factory' | 'auto';
+    }) => Promise<ResolveMockResul>;
+}
+interface ModuleMockerConfig {
+    root: string;
+}
+
+export { type CompilerHintsOptions as C, type ModuleMockerInterceptor as M, type ResolveIdResult as R, type ModuleMockerCompilerHints as a, ModuleMocker as b, createCompilerHints as c, type ModuleMockerConfig as d, type ModuleMockerRPC as e, type ResolveMockResul as f };

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

@@ -0,0 +1,801 @@
+import { Plugin, Rollup, ViteDevServer } from 'vite';
+import MagicString, { SourceMap } from 'magic-string';
+export { findMockRedirect } from './redirect.js';
+
+interface AutomockPluginOptions {
+    /**
+     * @default "__vitest_mocker__"
+     */
+    globalThisAccessor?: string;
+}
+declare function automockPlugin(options?: AutomockPluginOptions): Plugin;
+declare function automockModule(code: string, mockType: 'automock' | 'autospy', parse: (code: string) => any, options?: AutomockPluginOptions): MagicString;
+
+interface DynamicImportPluginOptions {
+    /**
+     * @default `"__vitest_mocker__"`
+     */
+    globalThisAccessor?: string;
+    filter?: (id: string) => boolean;
+}
+declare function dynamicImportPlugin(options?: DynamicImportPluginOptions): Plugin;
+
+// This definition file follows a somewhat unusual format. ESTree allows
+// runtime type checks based on the `type` parameter. In order to explain this
+// to typescript we want to use discriminated union types:
+// https://github.com/Microsoft/TypeScript/pull/9163
+//
+// For ESTree this is a bit tricky because the high level interfaces like
+// Node or Function are pulling double duty. We want to pass common fields down
+// to the interfaces that extend them (like Identifier or
+// ArrowFunctionExpression), but you can't extend a type union or enforce
+// common fields on them. So we've split the high level interfaces into two
+// types, a base type which passes down inherited fields, and a type union of
+// all types which extend the base type. Only the type union is exported, and
+// the union is how other types refer to the collection of inheriting types.
+//
+// This makes the definitions file here somewhat more difficult to maintain,
+// but it has the notable advantage of making ESTree much easier to use as
+// an end user.
+
+interface BaseNodeWithoutComments {
+    // Every leaf interface that extends BaseNode must specify a type property.
+    // The type property should be a string literal. For example, Identifier
+    // has: `type: "Identifier"`
+    type: string;
+    loc?: SourceLocation | null | undefined;
+    range?: [number, number] | undefined;
+}
+
+interface BaseNode extends BaseNodeWithoutComments {
+    leadingComments?: Comment[] | undefined;
+    trailingComments?: Comment[] | undefined;
+}
+
+interface NodeMap {
+    AssignmentProperty: AssignmentProperty;
+    CatchClause: CatchClause;
+    Class: Class;
+    ClassBody: ClassBody;
+    Expression: Expression;
+    Function: Function;
+    Identifier: Identifier;
+    Literal: Literal;
+    MethodDefinition: MethodDefinition;
+    ModuleDeclaration: ModuleDeclaration;
+    ModuleSpecifier: ModuleSpecifier;
+    Pattern: Pattern;
+    PrivateIdentifier: PrivateIdentifier;
+    Program: Program;
+    Property: Property;
+    PropertyDefinition: PropertyDefinition;
+    SpreadElement: SpreadElement;
+    Statement: Statement;
+    Super: Super;
+    SwitchCase: SwitchCase;
+    TemplateElement: TemplateElement;
+    VariableDeclarator: VariableDeclarator;
+}
+
+type Node$1 = NodeMap[keyof NodeMap];
+
+interface Comment extends BaseNodeWithoutComments {
+    type: "Line" | "Block";
+    value: string;
+}
+
+interface SourceLocation {
+    source?: string | null | undefined;
+    start: Position;
+    end: Position;
+}
+
+interface Position {
+    /** >= 1 */
+    line: number;
+    /** >= 0 */
+    column: number;
+}
+
+interface Program extends BaseNode {
+    type: "Program";
+    sourceType: "script" | "module";
+    body: Array<Directive | Statement | ModuleDeclaration>;
+    comments?: Comment[] | undefined;
+}
+
+interface Directive extends BaseNode {
+    type: "ExpressionStatement";
+    expression: Literal;
+    directive: string;
+}
+
+interface BaseFunction extends BaseNode {
+    params: Pattern[];
+    generator?: boolean | undefined;
+    async?: boolean | undefined;
+    // The body is either BlockStatement or Expression because arrow functions
+    // can have a body that's either. FunctionDeclarations and
+    // FunctionExpressions have only BlockStatement bodies.
+    body: BlockStatement | Expression;
+}
+
+type Function = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
+
+type Statement =
+    | ExpressionStatement
+    | BlockStatement
+    | StaticBlock
+    | EmptyStatement
+    | DebuggerStatement
+    | WithStatement
+    | ReturnStatement
+    | LabeledStatement
+    | BreakStatement
+    | ContinueStatement
+    | IfStatement
+    | SwitchStatement
+    | ThrowStatement
+    | TryStatement
+    | WhileStatement
+    | DoWhileStatement
+    | ForStatement
+    | ForInStatement
+    | ForOfStatement
+    | Declaration;
+
+interface BaseStatement extends BaseNode {}
+
+interface EmptyStatement extends BaseStatement {
+    type: "EmptyStatement";
+}
+
+interface BlockStatement extends BaseStatement {
+    type: "BlockStatement";
+    body: Statement[];
+    innerComments?: Comment[] | undefined;
+}
+
+interface StaticBlock extends Omit<BlockStatement, "type"> {
+    type: "StaticBlock";
+}
+
+interface ExpressionStatement extends BaseStatement {
+    type: "ExpressionStatement";
+    expression: Expression;
+}
+
+interface IfStatement extends BaseStatement {
+    type: "IfStatement";
+    test: Expression;
+    consequent: Statement;
+    alternate?: Statement | null | undefined;
+}
+
+interface LabeledStatement extends BaseStatement {
+    type: "LabeledStatement";
+    label: Identifier;
+    body: Statement;
+}
+
+interface BreakStatement extends BaseStatement {
+    type: "BreakStatement";
+    label?: Identifier | null | undefined;
+}
+
+interface ContinueStatement extends BaseStatement {
+    type: "ContinueStatement";
+    label?: Identifier | null | undefined;
+}
+
+interface WithStatement extends BaseStatement {
+    type: "WithStatement";
+    object: Expression;
+    body: Statement;
+}
+
+interface SwitchStatement extends BaseStatement {
+    type: "SwitchStatement";
+    discriminant: Expression;
+    cases: SwitchCase[];
+}
+
+interface ReturnStatement extends BaseStatement {
+    type: "ReturnStatement";
+    argument?: Expression | null | undefined;
+}
+
+interface ThrowStatement extends BaseStatement {
+    type: "ThrowStatement";
+    argument: Expression;
+}
+
+interface TryStatement extends BaseStatement {
+    type: "TryStatement";
+    block: BlockStatement;
+    handler?: CatchClause | null | undefined;
+    finalizer?: BlockStatement | null | undefined;
+}
+
+interface WhileStatement extends BaseStatement {
+    type: "WhileStatement";
+    test: Expression;
+    body: Statement;
+}
+
+interface DoWhileStatement extends BaseStatement {
+    type: "DoWhileStatement";
+    body: Statement;
+    test: Expression;
+}
+
+interface ForStatement extends BaseStatement {
+    type: "ForStatement";
+    init?: VariableDeclaration | Expression | null | undefined;
+    test?: Expression | null | undefined;
+    update?: Expression | null | undefined;
+    body: Statement;
+}
+
+interface BaseForXStatement extends BaseStatement {
+    left: VariableDeclaration | Pattern;
+    right: Expression;
+    body: Statement;
+}
+
+interface ForInStatement extends BaseForXStatement {
+    type: "ForInStatement";
+}
+
+interface DebuggerStatement extends BaseStatement {
+    type: "DebuggerStatement";
+}
+
+type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
+
+interface BaseDeclaration extends BaseStatement {}
+
+interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
+    type: "FunctionDeclaration";
+    /** It is null when a function declaration is a part of the `export default function` statement */
+    id: Identifier | null;
+    body: BlockStatement;
+}
+
+interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
+    id: Identifier;
+}
+
+interface VariableDeclaration extends BaseDeclaration {
+    type: "VariableDeclaration";
+    declarations: VariableDeclarator[];
+    kind: "var" | "let" | "const";
+}
+
+interface VariableDeclarator extends BaseNode {
+    type: "VariableDeclarator";
+    id: Pattern;
+    init?: Expression | null | undefined;
+}
+
+interface ExpressionMap {
+    ArrayExpression: ArrayExpression;
+    ArrowFunctionExpression: ArrowFunctionExpression;
+    AssignmentExpression: AssignmentExpression;
+    AwaitExpression: AwaitExpression;
+    BinaryExpression: BinaryExpression;
+    CallExpression: CallExpression;
+    ChainExpression: ChainExpression;
+    ClassExpression: ClassExpression;
+    ConditionalExpression: ConditionalExpression;
+    FunctionExpression: FunctionExpression;
+    Identifier: Identifier;
+    ImportExpression: ImportExpression;
+    Literal: Literal;
+    LogicalExpression: LogicalExpression;
+    MemberExpression: MemberExpression;
+    MetaProperty: MetaProperty;
+    NewExpression: NewExpression;
+    ObjectExpression: ObjectExpression;
+    SequenceExpression: SequenceExpression;
+    TaggedTemplateExpression: TaggedTemplateExpression;
+    TemplateLiteral: TemplateLiteral;
+    ThisExpression: ThisExpression;
+    UnaryExpression: UnaryExpression;
+    UpdateExpression: UpdateExpression;
+    YieldExpression: YieldExpression;
+}
+
+type Expression = ExpressionMap[keyof ExpressionMap];
+
+interface BaseExpression extends BaseNode {}
+
+type ChainElement = SimpleCallExpression | MemberExpression;
+
+interface ChainExpression extends BaseExpression {
+    type: "ChainExpression";
+    expression: ChainElement;
+}
+
+interface ThisExpression extends BaseExpression {
+    type: "ThisExpression";
+}
+
+interface ArrayExpression extends BaseExpression {
+    type: "ArrayExpression";
+    elements: Array<Expression | SpreadElement | null>;
+}
+
+interface ObjectExpression extends BaseExpression {
+    type: "ObjectExpression";
+    properties: Array<Property | SpreadElement>;
+}
+
+interface PrivateIdentifier extends BaseNode {
+    type: "PrivateIdentifier";
+    name: string;
+}
+
+interface Property extends BaseNode {
+    type: "Property";
+    key: Expression | PrivateIdentifier;
+    value: Expression | Pattern; // Could be an AssignmentProperty
+    kind: "init" | "get" | "set";
+    method: boolean;
+    shorthand: boolean;
+    computed: boolean;
+}
+
+interface PropertyDefinition extends BaseNode {
+    type: "PropertyDefinition";
+    key: Expression | PrivateIdentifier;
+    value?: Expression | null | undefined;
+    computed: boolean;
+    static: boolean;
+}
+
+interface FunctionExpression extends BaseFunction, BaseExpression {
+    id?: Identifier | null | undefined;
+    type: "FunctionExpression";
+    body: BlockStatement;
+}
+
+interface SequenceExpression extends BaseExpression {
+    type: "SequenceExpression";
+    expressions: Expression[];
+}
+
+interface UnaryExpression extends BaseExpression {
+    type: "UnaryExpression";
+    operator: UnaryOperator;
+    prefix: true;
+    argument: Expression;
+}
+
+interface BinaryExpression extends BaseExpression {
+    type: "BinaryExpression";
+    operator: BinaryOperator;
+    left: Expression | PrivateIdentifier;
+    right: Expression;
+}
+
+interface AssignmentExpression extends BaseExpression {
+    type: "AssignmentExpression";
+    operator: AssignmentOperator;
+    left: Pattern | MemberExpression;
+    right: Expression;
+}
+
+interface UpdateExpression extends BaseExpression {
+    type: "UpdateExpression";
+    operator: UpdateOperator;
+    argument: Expression;
+    prefix: boolean;
+}
+
+interface LogicalExpression extends BaseExpression {
+    type: "LogicalExpression";
+    operator: LogicalOperator;
+    left: Expression;
+    right: Expression;
+}
+
+interface ConditionalExpression extends BaseExpression {
+    type: "ConditionalExpression";
+    test: Expression;
+    alternate: Expression;
+    consequent: Expression;
+}
+
+interface BaseCallExpression extends BaseExpression {
+    callee: Expression | Super;
+    arguments: Array<Expression | SpreadElement>;
+}
+type CallExpression = SimpleCallExpression | NewExpression;
+
+interface SimpleCallExpression extends BaseCallExpression {
+    type: "CallExpression";
+    optional: boolean;
+}
+
+interface NewExpression extends BaseCallExpression {
+    type: "NewExpression";
+}
+
+interface MemberExpression extends BaseExpression, BasePattern {
+    type: "MemberExpression";
+    object: Expression | Super;
+    property: Expression | PrivateIdentifier;
+    computed: boolean;
+    optional: boolean;
+}
+
+type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
+
+interface BasePattern extends BaseNode {}
+
+interface SwitchCase extends BaseNode {
+    type: "SwitchCase";
+    test?: Expression | null | undefined;
+    consequent: Statement[];
+}
+
+interface CatchClause extends BaseNode {
+    type: "CatchClause";
+    param: Pattern | null;
+    body: BlockStatement;
+}
+
+interface Identifier extends BaseNode, BaseExpression, BasePattern {
+    type: "Identifier";
+    name: string;
+}
+
+type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
+
+interface SimpleLiteral extends BaseNode, BaseExpression {
+    type: "Literal";
+    value: string | boolean | number | null;
+    raw?: string | undefined;
+}
+
+interface RegExpLiteral extends BaseNode, BaseExpression {
+    type: "Literal";
+    value?: RegExp | null | undefined;
+    regex: {
+        pattern: string;
+        flags: string;
+    };
+    raw?: string | undefined;
+}
+
+interface BigIntLiteral extends BaseNode, BaseExpression {
+    type: "Literal";
+    value?: bigint | null | undefined;
+    bigint: string;
+    raw?: string | undefined;
+}
+
+type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
+
+type BinaryOperator =
+    | "=="
+    | "!="
+    | "==="
+    | "!=="
+    | "<"
+    | "<="
+    | ">"
+    | ">="
+    | "<<"
+    | ">>"
+    | ">>>"
+    | "+"
+    | "-"
+    | "*"
+    | "/"
+    | "%"
+    | "**"
+    | "|"
+    | "^"
+    | "&"
+    | "in"
+    | "instanceof";
+
+type LogicalOperator = "||" | "&&" | "??";
+
+type AssignmentOperator =
+    | "="
+    | "+="
+    | "-="
+    | "*="
+    | "/="
+    | "%="
+    | "**="
+    | "<<="
+    | ">>="
+    | ">>>="
+    | "|="
+    | "^="
+    | "&="
+    | "||="
+    | "&&="
+    | "??=";
+
+type UpdateOperator = "++" | "--";
+
+interface ForOfStatement extends BaseForXStatement {
+    type: "ForOfStatement";
+    await: boolean;
+}
+
+interface Super extends BaseNode {
+    type: "Super";
+}
+
+interface SpreadElement extends BaseNode {
+    type: "SpreadElement";
+    argument: Expression;
+}
+
+interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
+    type: "ArrowFunctionExpression";
+    expression: boolean;
+    body: BlockStatement | Expression;
+}
+
+interface YieldExpression extends BaseExpression {
+    type: "YieldExpression";
+    argument?: Expression | null | undefined;
+    delegate: boolean;
+}
+
+interface TemplateLiteral extends BaseExpression {
+    type: "TemplateLiteral";
+    quasis: TemplateElement[];
+    expressions: Expression[];
+}
+
+interface TaggedTemplateExpression extends BaseExpression {
+    type: "TaggedTemplateExpression";
+    tag: Expression;
+    quasi: TemplateLiteral;
+}
+
+interface TemplateElement extends BaseNode {
+    type: "TemplateElement";
+    tail: boolean;
+    value: {
+        /** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */
+        cooked?: string | null | undefined;
+        raw: string;
+    };
+}
+
+interface AssignmentProperty extends Property {
+    value: Pattern;
+    kind: "init";
+    method: boolean; // false
+}
+
+interface ObjectPattern extends BasePattern {
+    type: "ObjectPattern";
+    properties: Array<AssignmentProperty | RestElement>;
+}
+
+interface ArrayPattern extends BasePattern {
+    type: "ArrayPattern";
+    elements: Array<Pattern | null>;
+}
+
+interface RestElement extends BasePattern {
+    type: "RestElement";
+    argument: Pattern;
+}
+
+interface AssignmentPattern extends BasePattern {
+    type: "AssignmentPattern";
+    left: Pattern;
+    right: Expression;
+}
+
+type Class = ClassDeclaration | ClassExpression;
+interface BaseClass extends BaseNode {
+    superClass?: Expression | null | undefined;
+    body: ClassBody;
+}
+
+interface ClassBody extends BaseNode {
+    type: "ClassBody";
+    body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
+}
+
+interface MethodDefinition extends BaseNode {
+    type: "MethodDefinition";
+    key: Expression | PrivateIdentifier;
+    value: FunctionExpression;
+    kind: "constructor" | "method" | "get" | "set";
+    computed: boolean;
+    static: boolean;
+}
+
+interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration {
+    type: "ClassDeclaration";
+    /** It is null when a class declaration is a part of the `export default class` statement */
+    id: Identifier | null;
+}
+
+interface ClassDeclaration extends MaybeNamedClassDeclaration {
+    id: Identifier;
+}
+
+interface ClassExpression extends BaseClass, BaseExpression {
+    type: "ClassExpression";
+    id?: Identifier | null | undefined;
+}
+
+interface MetaProperty extends BaseExpression {
+    type: "MetaProperty";
+    meta: Identifier;
+    property: Identifier;
+}
+
+type ModuleDeclaration =
+    | ImportDeclaration
+    | ExportNamedDeclaration
+    | ExportDefaultDeclaration
+    | ExportAllDeclaration;
+interface BaseModuleDeclaration extends BaseNode {}
+
+type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier;
+interface BaseModuleSpecifier extends BaseNode {
+    local: Identifier;
+}
+
+interface ImportDeclaration extends BaseModuleDeclaration {
+    type: "ImportDeclaration";
+    specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
+    source: Literal;
+}
+
+interface ImportSpecifier extends BaseModuleSpecifier {
+    type: "ImportSpecifier";
+    imported: Identifier | Literal;
+}
+
+interface ImportExpression extends BaseExpression {
+    type: "ImportExpression";
+    source: Expression;
+}
+
+interface ImportDefaultSpecifier extends BaseModuleSpecifier {
+    type: "ImportDefaultSpecifier";
+}
+
+interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
+    type: "ImportNamespaceSpecifier";
+}
+
+interface ExportNamedDeclaration extends BaseModuleDeclaration {
+    type: "ExportNamedDeclaration";
+    declaration?: Declaration | null | undefined;
+    specifiers: ExportSpecifier[];
+    source?: Literal | null | undefined;
+}
+
+interface ExportSpecifier extends Omit<BaseModuleSpecifier, "local"> {
+    type: "ExportSpecifier";
+    local: Identifier | Literal;
+    exported: Identifier | Literal;
+}
+
+interface ExportDefaultDeclaration extends BaseModuleDeclaration {
+    type: "ExportDefaultDeclaration";
+    declaration: MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression;
+}
+
+interface ExportAllDeclaration extends BaseModuleDeclaration {
+    type: "ExportAllDeclaration";
+    exported: Identifier | Literal | null;
+    source: Literal;
+}
+
+interface AwaitExpression extends BaseExpression {
+    type: "AwaitExpression";
+    argument: Expression;
+}
+
+type Positioned<T> = T & {
+    start: number;
+    end: number;
+};
+type Node = Positioned<Node$1>;
+
+interface HoistMocksOptions {
+    /**
+     * List of modules that should always be imported before compiler hints.
+     * @default ['vitest']
+     */
+    hoistedModules?: string[];
+    /**
+     * @default ["vi", "vitest"]
+     */
+    utilsObjectNames?: string[];
+    /**
+     * @default ["mock", "unmock"]
+     */
+    hoistableMockMethodNames?: string[];
+    /**
+     * @default ["mock", "unmock", "doMock", "doUnmock"]
+     */
+    dynamicImportMockMethodNames?: string[];
+    /**
+     * @default ["hoisted"]
+     */
+    hoistedMethodNames?: string[];
+    regexpHoistable?: RegExp;
+    codeFrameGenerator?: CodeFrameGenerator;
+}
+interface HoistMocksPluginOptions extends Omit<HoistMocksOptions, 'regexpHoistable'> {
+    include?: string | RegExp | (string | RegExp)[];
+    exclude?: string | RegExp | (string | RegExp)[];
+    /**
+     * overrides include/exclude options
+     */
+    filter?: (id: string) => boolean;
+}
+declare function hoistMocksPlugin(options?: HoistMocksPluginOptions): Plugin;
+interface HoistMocksResult {
+    ast: Rollup.ProgramNode;
+    code: string;
+    map: SourceMap;
+}
+interface CodeFrameGenerator {
+    (node: Positioned<Node>, id: string, code: string): string;
+}
+declare function hoistMocks(code: string, id: string, parse: Rollup.PluginContext['parse'], options?: HoistMocksOptions): HoistMocksResult | undefined;
+
+interface InterceptorPluginOptions {
+    /**
+     * @default "__vitest_mocker__"
+     */
+    globalThisAccessor?: string;
+}
+declare function interceptorPlugin(options: InterceptorPluginOptions): Plugin;
+
+interface MockerPluginOptions extends AutomockPluginOptions {
+    hoistMocks?: HoistMocksPluginOptions;
+}
+declare function mockerPlugin(options?: MockerPluginOptions): Plugin[];
+
+interface ServerResolverOptions {
+    /**
+     * @default ['/node_modules/']
+     */
+    moduleDirectories?: string[];
+}
+declare class ServerMockResolver {
+    private server;
+    private options;
+    constructor(server: ViteDevServer, options?: ServerResolverOptions);
+    resolveMock(rawId: string, importer: string, options: {
+        mock: 'spy' | 'factory' | 'auto';
+    }): Promise<ServerMockResolution>;
+    invalidate(ids: string[]): void;
+    resolveId(id: string, importer?: string): Promise<ServerIdResolution | null>;
+    private resolveMockId;
+    private resolveModule;
+}
+interface ServerMockResolution {
+    mockType: 'manual' | 'redirect' | 'automock' | 'autospy';
+    resolvedId: string;
+    needsInterop?: boolean;
+    redirectUrl?: string | null;
+}
+interface ServerIdResolution {
+    id: string;
+    url: string;
+    optimized: boolean;
+}
+
+export { type AutomockPluginOptions, type HoistMocksPluginOptions, type HoistMocksResult, type InterceptorPluginOptions, type ServerIdResolution, type ServerMockResolution, ServerMockResolver, type ServerResolverOptions, automockModule, automockPlugin, dynamicImportPlugin, hoistMocks, hoistMocksPlugin, interceptorPlugin, mockerPlugin };

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

@@ -0,0 +1,3 @@
+declare function findMockRedirect(root: string, mockPath: string, external: string | null): string | null;
+
+export { findMockRedirect };

pwa/node_modules/@vitest/mocker/dist/redirect.js

@@ -0,0 +1,67 @@
+import fs from 'node:fs';
+import { builtinModules } from 'node:module';
+import { d as dirname, j as join, b as basename, r as resolve, e as extname } from './chunk-pathe.ff20891b.js';
+
+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
+  );
+}
+
+export { findMockRedirect };

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

@@ -0,0 +1,8 @@
+import { M as ModuleMockerInterceptor, a as ModuleMockerCompilerHints, b as ModuleMocker } from './mocker-pQgp1HFr.js';
+import '@vitest/spy';
+import './types-DZOqTgiN.js';
+
+declare function registerModuleMocker(interceptor: (accessor: string) => ModuleMockerInterceptor): ModuleMockerCompilerHints;
+declare function registerNativeFactoryResolver(mocker: ModuleMocker): void;
+
+export { registerModuleMocker, registerNativeFactoryResolver };

pwa/node_modules/@vitest/mocker/dist/register.js

@@ -0,0 +1,40 @@
+import { spyOn } from '@vitest/spy';
+import { M as ModuleMocker, r as rpc, c as createCompilerHints, h as hot } from './chunk-mocker.js';
+import './index.js';
+import './chunk-registry.js';
+import './chunk-pathe.ff20891b.js';
+
+function registerModuleMocker(interceptor) {
+  const mocker = new ModuleMocker(
+    interceptor(__VITEST_GLOBAL_THIS_ACCESSOR__),
+    {
+      resolveId(id, importer) {
+        return rpc("vitest:mocks:resolveId", { id, importer });
+      },
+      resolveMock(id, importer, options) {
+        return rpc("vitest:mocks:resolveMock", { id, importer, options });
+      },
+      async invalidate(ids) {
+        return rpc("vitest:mocks:invalidate", { ids });
+      }
+    },
+    spyOn,
+    {
+      root: __VITEST_MOCKER_ROOT__
+    }
+  );
+  globalThis[__VITEST_GLOBAL_THIS_ACCESSOR__] = mocker;
+  registerNativeFactoryResolver(mocker);
+  return createCompilerHints({
+    globalThisKey: __VITEST_GLOBAL_THIS_ACCESSOR__
+  });
+}
+function registerNativeFactoryResolver(mocker) {
+  hot.on("vitest:interceptor:resolve", async (url) => {
+    const exports = await mocker.resolveFactoryModule(url);
+    const keys = Object.keys(exports);
+    hot.send("vitest:interceptor:resolved", { url, keys });
+  });
+}
+
+export { registerModuleMocker, registerNativeFactoryResolver };

pwa/node_modules/@vitest/mocker/dist/types-DZOqTgiN.d.ts

@@ -0,0 +1,83 @@
+declare class MockerRegistry {
+    private readonly registry;
+    clear(): void;
+    keys(): IterableIterator<string>;
+    add(mock: MockedModule): void;
+    register(json: MockedModuleSerialized): MockedModule;
+    register(type: 'redirect', raw: string, url: string, redirect: string): RedirectedModule;
+    register(type: 'manual', raw: string, url: string, factory: () => any): ManualMockedModule;
+    register(type: 'automock', raw: string, url: string): AutomockedModule;
+    register(type: 'autospy', raw: string, url: string): AutospiedModule;
+    delete(id: string): void;
+    get(id: string): MockedModule | undefined;
+    has(id: string): boolean;
+}
+type MockedModule = AutomockedModule | AutospiedModule | ManualMockedModule | RedirectedModule;
+type MockedModuleType = 'automock' | 'autospy' | 'manual' | 'redirect';
+type MockedModuleSerialized = AutomockedModuleSerialized | AutospiedModuleSerialized | ManualMockedModuleSerialized | RedirectedModuleSerialized;
+declare class AutomockedModule {
+    raw: string;
+    url: string;
+    readonly type = "automock";
+    constructor(raw: string, url: string);
+    static fromJSON(data: AutomockedModuleSerialized): AutospiedModule;
+    toJSON(): AutomockedModuleSerialized;
+}
+interface AutomockedModuleSerialized {
+    type: 'automock';
+    url: string;
+    raw: string;
+}
+declare class AutospiedModule {
+    raw: string;
+    url: string;
+    readonly type = "autospy";
+    constructor(raw: string, url: string);
+    static fromJSON(data: AutospiedModuleSerialized): AutospiedModule;
+    toJSON(): AutospiedModuleSerialized;
+}
+interface AutospiedModuleSerialized {
+    type: 'autospy';
+    url: string;
+    raw: string;
+}
+declare class RedirectedModule {
+    raw: string;
+    url: string;
+    redirect: string;
+    readonly type = "redirect";
+    constructor(raw: string, url: string, redirect: string);
+    static fromJSON(data: RedirectedModuleSerialized): RedirectedModule;
+    toJSON(): RedirectedModuleSerialized;
+}
+interface RedirectedModuleSerialized {
+    type: 'redirect';
+    url: string;
+    raw: string;
+    redirect: string;
+}
+declare class ManualMockedModule {
+    raw: string;
+    url: string;
+    factory: () => any;
+    cache: Record<string | symbol, any> | undefined;
+    readonly type = "manual";
+    constructor(raw: string, url: string, factory: () => any);
+    resolve(): Promise<Record<string | symbol, any>>;
+    static fromJSON(data: ManualMockedModuleSerialized, factory: () => any): ManualMockedModule;
+    toJSON(): ManualMockedModuleSerialized;
+}
+interface ManualMockedModuleSerialized {
+    type: 'manual';
+    url: string;
+    raw: string;
+}
+
+type Awaitable<T> = T | PromiseLike<T>;
+type ModuleMockFactoryWithHelper<M = unknown> = (importOriginal: <T extends M = M>() => Promise<T>) => Awaitable<Partial<M>>;
+type ModuleMockFactory = () => any;
+interface ModuleMockOptions {
+    spy?: boolean;
+}
+
+export { AutomockedModule as A, type MockedModuleType as M, RedirectedModule as R, AutospiedModule as a, ManualMockedModule as b, MockerRegistry as c, type AutomockedModuleSerialized as d, type AutospiedModuleSerialized as e, type ManualMockedModuleSerialized as f, type MockedModule as g, type MockedModuleSerialized as h, type RedirectedModuleSerialized as i, type ModuleMockFactory as j, type ModuleMockFactoryWithHelper as k, type ModuleMockOptions as l };