@shopify/cli-hydrogen 7.1.0 → 7.1.2

package/dist/lib/vite/worker-entry.js

@@ -0,0 +1,1518 @@
+// ../../node_modules/vite/dist/node/runtime.js
+var HMRContext = class {
+  hmrClient;
+  ownerPath;
+  newListeners;
+  constructor(hmrClient, ownerPath) {
+    this.hmrClient = hmrClient;
+    this.ownerPath = ownerPath;
+    if (!hmrClient.dataMap.has(ownerPath)) {
+      hmrClient.dataMap.set(ownerPath, {});
+    }
+    const mod = hmrClient.hotModulesMap.get(ownerPath);
+    if (mod) {
+      mod.callbacks = [];
+    }
+    const staleListeners = hmrClient.ctxToListenersMap.get(ownerPath);
+    if (staleListeners) {
+      for (const [event, staleFns] of staleListeners) {
+        const listeners = hmrClient.customListenersMap.get(event);
+        if (listeners) {
+          hmrClient.customListenersMap.set(event, listeners.filter((l) => !staleFns.includes(l)));
+        }
+      }
+    }
+    this.newListeners = /* @__PURE__ */ new Map();
+    hmrClient.ctxToListenersMap.set(ownerPath, this.newListeners);
+  }
+  get data() {
+    return this.hmrClient.dataMap.get(this.ownerPath);
+  }
+  accept(deps, callback) {
+    if (typeof deps === "function" || !deps) {
+      this.acceptDeps([this.ownerPath], ([mod]) => deps?.(mod));
+    } else if (typeof deps === "string") {
+      this.acceptDeps([deps], ([mod]) => callback?.(mod));
+    } else if (Array.isArray(deps)) {
+      this.acceptDeps(deps, callback);
+    } else {
+      throw new Error(`invalid hot.accept() usage.`);
+    }
+  }
+  // export names (first arg) are irrelevant on the client side, they're
+  // extracted in the server for propagation
+  acceptExports(_, callback) {
+    this.acceptDeps([this.ownerPath], ([mod]) => callback?.(mod));
+  }
+  dispose(cb) {
+    this.hmrClient.disposeMap.set(this.ownerPath, cb);
+  }
+  prune(cb) {
+    this.hmrClient.pruneMap.set(this.ownerPath, cb);
+  }
+  // Kept for backward compatibility (#11036)
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  decline() {
+  }
+  invalidate(message) {
+    this.hmrClient.notifyListeners("vite:invalidate", {
+      path: this.ownerPath,
+      message
+    });
+    this.send("vite:invalidate", { path: this.ownerPath, message });
+    this.hmrClient.logger.debug(`[vite] invalidate ${this.ownerPath}${message ? `: ${message}` : ""}`);
+  }
+  on(event, cb) {
+    const addToMap = (map) => {
+      const existing = map.get(event) || [];
+      existing.push(cb);
+      map.set(event, existing);
+    };
+    addToMap(this.hmrClient.customListenersMap);
+    addToMap(this.newListeners);
+  }
+  off(event, cb) {
+    const removeFromMap = (map) => {
+      const existing = map.get(event);
+      if (existing === void 0) {
+        return;
+      }
+      const pruned = existing.filter((l) => l !== cb);
+      if (pruned.length === 0) {
+        map.delete(event);
+        return;
+      }
+      map.set(event, pruned);
+    };
+    removeFromMap(this.hmrClient.customListenersMap);
+    removeFromMap(this.newListeners);
+  }
+  send(event, data) {
+    this.hmrClient.messenger.send(JSON.stringify({ type: "custom", event, data }));
+  }
+  acceptDeps(deps, callback = () => {
+  }) {
+    const mod = this.hmrClient.hotModulesMap.get(this.ownerPath) || {
+      id: this.ownerPath,
+      callbacks: []
+    };
+    mod.callbacks.push({
+      deps,
+      fn: callback
+    });
+    this.hmrClient.hotModulesMap.set(this.ownerPath, mod);
+  }
+};
+var HMRMessenger = class {
+  connection;
+  constructor(connection) {
+    this.connection = connection;
+  }
+  queue = [];
+  send(message) {
+    this.queue.push(message);
+    this.flush();
+  }
+  flush() {
+    if (this.connection.isReady()) {
+      this.queue.forEach((msg) => this.connection.send(msg));
+      this.queue = [];
+    }
+  }
+};
+var HMRClient = class {
+  logger;
+  importUpdatedModule;
+  hotModulesMap = /* @__PURE__ */ new Map();
+  disposeMap = /* @__PURE__ */ new Map();
+  pruneMap = /* @__PURE__ */ new Map();
+  dataMap = /* @__PURE__ */ new Map();
+  customListenersMap = /* @__PURE__ */ new Map();
+  ctxToListenersMap = /* @__PURE__ */ new Map();
+  messenger;
+  constructor(logger, connection, importUpdatedModule) {
+    this.logger = logger;
+    this.importUpdatedModule = importUpdatedModule;
+    this.messenger = new HMRMessenger(connection);
+  }
+  async notifyListeners(event, data) {
+    const cbs = this.customListenersMap.get(event);
+    if (cbs) {
+      await Promise.allSettled(cbs.map((cb) => cb(data)));
+    }
+  }
+  clear() {
+    this.hotModulesMap.clear();
+    this.disposeMap.clear();
+    this.pruneMap.clear();
+    this.dataMap.clear();
+    this.customListenersMap.clear();
+    this.ctxToListenersMap.clear();
+  }
+  // After an HMR update, some modules are no longer imported on the page
+  // but they may have left behind side effects that need to be cleaned up
+  // (.e.g style injections)
+  // TODO Trigger their dispose callbacks.
+  prunePaths(paths) {
+    paths.forEach((path) => {
+      const fn = this.pruneMap.get(path);
+      if (fn) {
+        fn(this.dataMap.get(path));
+      }
+    });
+  }
+  warnFailedUpdate(err, path) {
+    if (!err.message.includes("fetch")) {
+      this.logger.error(err);
+    }
+    this.logger.error(`[hmr] Failed to reload ${path}. This could be due to syntax errors or importing non-existent modules. (see errors above)`);
+  }
+  updateQueue = [];
+  pendingUpdateQueue = false;
+  /**
+   * buffer multiple hot updates triggered by the same src change
+   * so that they are invoked in the same order they were sent.
+   * (otherwise the order may be inconsistent because of the http request round trip)
+   */
+  async queueUpdate(payload) {
+    this.updateQueue.push(this.fetchUpdate(payload));
+    if (!this.pendingUpdateQueue) {
+      this.pendingUpdateQueue = true;
+      await Promise.resolve();
+      this.pendingUpdateQueue = false;
+      const loading = [...this.updateQueue];
+      this.updateQueue = [];
+      (await Promise.all(loading)).forEach((fn) => fn && fn());
+    }
+  }
+  async fetchUpdate(update) {
+    const { path, acceptedPath } = update;
+    const mod = this.hotModulesMap.get(path);
+    if (!mod) {
+      return;
+    }
+    let fetchedModule;
+    const isSelfUpdate = path === acceptedPath;
+    const qualifiedCallbacks = mod.callbacks.filter(({ deps }) => deps.includes(acceptedPath));
+    if (isSelfUpdate || qualifiedCallbacks.length > 0) {
+      const disposer = this.disposeMap.get(acceptedPath);
+      if (disposer)
+        await disposer(this.dataMap.get(acceptedPath));
+      try {
+        fetchedModule = await this.importUpdatedModule(update);
+      } catch (e) {
+        this.warnFailedUpdate(e, acceptedPath);
+      }
+    }
+    return () => {
+      for (const { deps, fn } of qualifiedCallbacks) {
+        fn(deps.map((dep) => dep === acceptedPath ? fetchedModule : void 0));
+      }
+      const loggedPath = isSelfUpdate ? path : `${acceptedPath} via ${path}`;
+      this.logger.debug(`[vite] hot updated: ${loggedPath}`);
+    };
+  }
+};
+var isWindows = typeof process !== "undefined" && process.platform === "win32";
+var decodeBase64 = typeof atob !== "undefined" ? atob : (str) => Buffer.from(str, "base64").toString("utf-8");
+var NULL_BYTE_PLACEHOLDER = `__x00__`;
+var VALID_ID_PREFIX = `/@id/`;
+function wrapId(id) {
+  return id.startsWith(VALID_ID_PREFIX) ? id : VALID_ID_PREFIX + id.replace("\0", NULL_BYTE_PLACEHOLDER);
+}
+function unwrapId(id) {
+  return id.startsWith(VALID_ID_PREFIX) ? id.slice(VALID_ID_PREFIX.length).replace(NULL_BYTE_PLACEHOLDER, "\0") : id;
+}
+var windowsSlashRE = /\\/g;
+function slash(p) {
+  return p.replace(windowsSlashRE, "/");
+}
+var postfixRE = /[?#].*$/;
+function cleanUrl(url) {
+  return url.replace(postfixRE, "");
+}
+function isPrimitive(value) {
+  return !value || typeof value !== "object" && typeof value !== "function";
+}
+var CHAR_FORWARD_SLASH = 47;
+var CHAR_BACKWARD_SLASH = 92;
+var percentRegEx = /%/g;
+var backslashRegEx = /\\/g;
+var newlineRegEx = /\n/g;
+var carriageReturnRegEx = /\r/g;
+var tabRegEx = /\t/g;
+var questionRegex = /\?/g;
+var hashRegex = /#/g;
+function encodePathChars(filepath) {
+  if (filepath.indexOf("%") !== -1)
+    filepath = filepath.replace(percentRegEx, "%25");
+  if (!isWindows && filepath.indexOf("\\") !== -1)
+    filepath = filepath.replace(backslashRegEx, "%5C");
+  if (filepath.indexOf("\n") !== -1)
+    filepath = filepath.replace(newlineRegEx, "%0A");
+  if (filepath.indexOf("\r") !== -1)
+    filepath = filepath.replace(carriageReturnRegEx, "%0D");
+  if (filepath.indexOf("	") !== -1)
+    filepath = filepath.replace(tabRegEx, "%09");
+  return filepath;
+}
+function posixPathToFileHref(posixPath) {
+  let resolved = posixResolve(posixPath);
+  const filePathLast = posixPath.charCodeAt(posixPath.length - 1);
+  if ((filePathLast === CHAR_FORWARD_SLASH || isWindows && filePathLast === CHAR_BACKWARD_SLASH) && resolved[resolved.length - 1] !== "/")
+    resolved += "/";
+  resolved = encodePathChars(resolved);
+  if (resolved.indexOf("?") !== -1)
+    resolved = resolved.replace(questionRegex, "%3F");
+  if (resolved.indexOf("#") !== -1)
+    resolved = resolved.replace(hashRegex, "%23");
+  return new URL(`file://${resolved}`).href;
+}
+function posixDirname(filepath) {
+  const normalizedPath = filepath.endsWith("/") ? filepath.substring(0, filepath.length - 1) : filepath;
+  return normalizedPath.substring(0, normalizedPath.lastIndexOf("/")) || "/";
+}
+function toWindowsPath(path) {
+  return path.replace(/\//g, "\\");
+}
+function cwd() {
+  if (typeof process !== "undefined" && typeof process.cwd === "function") {
+    return slash(process.cwd());
+  }
+  return "/";
+}
+function posixResolve(...segments) {
+  segments = segments.map((argument) => slash(argument));
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let index = segments.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+    const path = index >= 0 ? segments[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 : ".";
+}
+var _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+function isAbsolute(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+}
+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;
+}
+var DecodedMap = class {
+  map;
+  _encoded;
+  _decoded;
+  _decodedMemo;
+  url;
+  version;
+  names = [];
+  resolvedSources;
+  constructor(map, from) {
+    this.map = map;
+    const { mappings, names, sources } = map;
+    this.version = map.version;
+    this.names = names || [];
+    this._encoded = mappings || "";
+    this._decodedMemo = memoizedState();
+    this.url = from;
+    this.resolvedSources = (sources || []).map((s) => posixResolve(s || "", from));
+  }
+};
+function indexOf(mappings, index) {
+  const idx = mappings.indexOf(";", index);
+  return idx === -1 ? mappings.length : idx;
+}
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+  const c = chars.charCodeAt(i);
+  charToInt[c] = i;
+}
+function decodeInteger(mappings, pos, state, j) {
+  let value = 0;
+  let shift = 0;
+  let integer = 0;
+  do {
+    const c = mappings.charCodeAt(pos++);
+    integer = charToInt[c];
+    value |= (integer & 31) << shift;
+    shift += 5;
+  } while (integer & 32);
+  const shouldNegate = value & 1;
+  value >>>= 1;
+  if (shouldNegate) {
+    value = -2147483648 | -value;
+  }
+  state[j] += value;
+  return pos;
+}
+var comma = ",".charCodeAt(0);
+function hasMoreVlq(mappings, i, length) {
+  if (i >= length)
+    return false;
+  return mappings.charCodeAt(i) !== comma;
+}
+function decode(mappings) {
+  const state = new Int32Array(5);
+  const decoded = [];
+  let index = 0;
+  do {
+    const semi = indexOf(mappings, index);
+    const line = [];
+    let sorted = true;
+    let lastCol = 0;
+    state[0] = 0;
+    for (let i = index; i < semi; i++) {
+      let seg;
+      i = decodeInteger(mappings, i, state, 0);
+      const col = state[0];
+      if (col < lastCol)
+        sorted = false;
+      lastCol = col;
+      if (hasMoreVlq(mappings, i, semi)) {
+        i = decodeInteger(mappings, i, state, 1);
+        i = decodeInteger(mappings, i, state, 2);
+        i = decodeInteger(mappings, i, state, 3);
+        if (hasMoreVlq(mappings, i, semi)) {
+          i = decodeInteger(mappings, i, state, 4);
+          seg = [col, state[1], state[2], state[3], state[4]];
+        } else {
+          seg = [col, state[1], state[2], state[3]];
+        }
+      } else {
+        seg = [col];
+      }
+      line.push(seg);
+    }
+    if (!sorted)
+      line.sort((a, b) => a[0] - b[0]);
+    decoded.push(line);
+    index = semi + 1;
+  } while (index <= mappings.length);
+  return decoded;
+}
+var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
+var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
+var COLUMN = 0;
+var SOURCES_INDEX = 1;
+var SOURCE_LINE = 2;
+var SOURCE_COLUMN = 3;
+var NAMES_INDEX = 4;
+function OMapping(source, line, column, name) {
+  return { source, line, column, name };
+}
+function decodedMappings(map) {
+  return map._decoded || (map._decoded = decode(map._encoded));
+}
+var found = false;
+function binarySearch(haystack, needle, low, high) {
+  while (low <= high) {
+    const mid = low + (high - low >> 1);
+    const cmp = haystack[mid][COLUMN] - needle;
+    if (cmp === 0) {
+      found = true;
+      return mid;
+    }
+    if (cmp < 0) {
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  found = false;
+  return low - 1;
+}
+function lowerBound(haystack, needle, index) {
+  for (let i = index - 1; i >= 0; index = i--) {
+    if (haystack[i][COLUMN] !== needle)
+      break;
+  }
+  return index;
+}
+function memoizedState() {
+  return {
+    lastKey: -1,
+    lastNeedle: -1,
+    lastIndex: -1
+  };
+}
+function memoizedBinarySearch(haystack, needle, state, key) {
+  const { lastKey, lastNeedle, lastIndex } = state;
+  let low = 0;
+  let high = haystack.length - 1;
+  if (key === lastKey) {
+    if (needle === lastNeedle) {
+      found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+      return lastIndex;
+    }
+    if (needle >= lastNeedle) {
+      low = lastIndex === -1 ? 0 : lastIndex;
+    } else {
+      high = lastIndex;
+    }
+  }
+  state.lastKey = key;
+  state.lastNeedle = needle;
+  return state.lastIndex = binarySearch(haystack, needle, low, high);
+}
+function traceSegmentInternal(segments, memo, line, column) {
+  let index = memoizedBinarySearch(segments, column, memo, line);
+  if (found) {
+    index = lowerBound(segments, column, index);
+  }
+  if (index === -1 || index === segments.length)
+    return -1;
+  return index;
+}
+function getOriginalPosition(map, { line, column }) {
+  line--;
+  if (line < 0)
+    throw new Error(LINE_GTR_ZERO);
+  if (column < 0)
+    throw new Error(COL_GTR_EQ_ZERO);
+  map._decodedMemo ??= memoizedState();
+  const decoded = decodedMappings(map);
+  if (line >= decoded.length)
+    return null;
+  const segments = decoded[line];
+  const index = traceSegmentInternal(segments, map._decodedMemo, line, column);
+  if (index === -1)
+    return null;
+  const segment = segments[index];
+  if (segment.length === 1)
+    return null;
+  const { names, resolvedSources } = map;
+  return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
+}
+var SOURCEMAPPING_URL = "sourceMa";
+SOURCEMAPPING_URL += "ppingURL";
+var VITE_RUNTIME_SOURCEMAPPING_URL = `${SOURCEMAPPING_URL}=data:application/json;charset=utf-8`;
+var VITE_RUNTIME_SOURCEMAPPING_REGEXP = new RegExp(`//# ${VITE_RUNTIME_SOURCEMAPPING_URL};base64,(.+)`);
+var ModuleCacheMap = class extends Map {
+  root;
+  constructor(root, entries) {
+    super(entries);
+    this.root = withTrailingSlash(root);
+  }
+  normalize(fsPath) {
+    return normalizeModuleId(fsPath, this.root);
+  }
+  /**
+   * Assign partial data to the map
+   */
+  update(fsPath, mod) {
+    fsPath = this.normalize(fsPath);
+    if (!super.has(fsPath))
+      this.setByModuleId(fsPath, mod);
+    else
+      Object.assign(super.get(fsPath), mod);
+    return this;
+  }
+  setByModuleId(modulePath, mod) {
+    return super.set(modulePath, mod);
+  }
+  set(fsPath, mod) {
+    return this.setByModuleId(this.normalize(fsPath), mod);
+  }
+  getByModuleId(modulePath) {
+    if (!super.has(modulePath))
+      this.setByModuleId(modulePath, {});
+    const mod = super.get(modulePath);
+    if (!mod.imports) {
+      Object.assign(mod, {
+        imports: /* @__PURE__ */ new Set(),
+        importers: /* @__PURE__ */ new Set()
+      });
+    }
+    return mod;
+  }
+  get(fsPath) {
+    return this.getByModuleId(this.normalize(fsPath));
+  }
+  deleteByModuleId(modulePath) {
+    return super.delete(modulePath);
+  }
+  delete(fsPath) {
+    return this.deleteByModuleId(this.normalize(fsPath));
+  }
+  /**
+   * Invalidate modules that dependent on the given modules, up to the main entry
+   */
+  invalidateDepTree(ids, invalidated = /* @__PURE__ */ new Set()) {
+    for (const _id of ids) {
+      const id = this.normalize(_id);
+      if (invalidated.has(id))
+        continue;
+      invalidated.add(id);
+      const mod = super.get(id);
+      if (mod?.importers)
+        this.invalidateDepTree(mod.importers, invalidated);
+      super.delete(id);
+    }
+    return invalidated;
+  }
+  /**
+   * Invalidate dependency modules of the given modules, down to the bottom-level dependencies
+   */
+  invalidateSubDepTree(ids, invalidated = /* @__PURE__ */ new Set()) {
+    for (const _id of ids) {
+      const id = this.normalize(_id);
+      if (invalidated.has(id))
+        continue;
+      invalidated.add(id);
+      const subIds = Array.from(super.entries()).filter(([, mod]) => mod.importers?.has(id)).map(([key]) => key);
+      subIds.length && this.invalidateSubDepTree(subIds, invalidated);
+      super.delete(id);
+    }
+    return invalidated;
+  }
+  getSourceMap(moduleId) {
+    const mod = this.get(moduleId);
+    if (mod.map)
+      return mod.map;
+    if (!mod.meta || !("code" in mod.meta))
+      return null;
+    const mapString = mod.meta.code.match(VITE_RUNTIME_SOURCEMAPPING_REGEXP)?.[1];
+    if (!mapString)
+      return null;
+    const baseFile = mod.meta.file || moduleId.split("?")[0];
+    mod.map = new DecodedMap(JSON.parse(decodeBase64(mapString)), baseFile);
+    return mod.map;
+  }
+};
+function withTrailingSlash(path) {
+  if (path[path.length - 1] !== "/") {
+    return `${path}/`;
+  }
+  return path;
+}
+var prefixedBuiltins = /* @__PURE__ */ new Set(["node:test"]);
+function normalizeModuleId(file, root) {
+  if (prefixedBuiltins.has(file))
+    return file;
+  let unixFile = file.replace(/\\/g, "/").replace(/^\/@fs\//, isWindows ? "" : "/").replace(/^node:/, "").replace(/^\/+/, "/");
+  if (unixFile.startsWith(root)) {
+    unixFile = unixFile.slice(root.length - 1);
+  }
+  return unixFile.replace(/^file:\//, "/");
+}
+var ssrModuleExportsKey = `__vite_ssr_exports__`;
+var ssrImportKey = `__vite_ssr_import__`;
+var ssrDynamicImportKey = `__vite_ssr_dynamic_import__`;
+var ssrExportAllKey = `__vite_ssr_exportAll__`;
+var ssrImportMetaKey = `__vite_ssr_import_meta__`;
+var noop = () => {
+};
+var silentConsole = {
+  debug: noop,
+  error: noop
+};
+function createHMRHandler(runtime2) {
+  const queue = new Queue();
+  return (payload) => queue.enqueue(() => handleHMRPayload(runtime2, payload));
+}
+async function handleHMRPayload(runtime2, payload) {
+  const hmrClient = runtime2.hmrClient;
+  if (!hmrClient || runtime2.isDestroyed())
+    return;
+  switch (payload.type) {
+    case "connected":
+      hmrClient.logger.debug(`[vite] connected.`);
+      hmrClient.messenger.flush();
+      break;
+    case "update":
+      await hmrClient.notifyListeners("vite:beforeUpdate", payload);
+      await Promise.all(payload.updates.map(async (update) => {
+        if (update.type === "js-update") {
+          update.acceptedPath = unwrapId(update.acceptedPath);
+          update.path = unwrapId(update.path);
+          return hmrClient.queueUpdate(update);
+        }
+        hmrClient.logger.error("[vite] css hmr is not supported in runtime mode.");
+      }));
+      await hmrClient.notifyListeners("vite:afterUpdate", payload);
+      break;
+    case "custom": {
+      await hmrClient.notifyListeners(payload.event, payload.data);
+      break;
+    }
+    case "full-reload":
+      hmrClient.logger.debug(`[vite] program reload`);
+      await hmrClient.notifyListeners("vite:beforeFullReload", payload);
+      Array.from(runtime2.moduleCache.keys()).forEach((id) => {
+        if (!id.includes("node_modules")) {
+          runtime2.moduleCache.deleteByModuleId(id);
+        }
+      });
+      for (const id of runtime2.entrypoints) {
+        await runtime2.executeUrl(id);
+      }
+      break;
+    case "prune":
+      await hmrClient.notifyListeners("vite:beforePrune", payload);
+      hmrClient.prunePaths(payload.paths);
+      break;
+    case "error": {
+      await hmrClient.notifyListeners("vite:error", payload);
+      const err = payload.err;
+      hmrClient.logger.error(`[vite] Internal Server Error
+${err.message}
+${err.stack}`);
+      break;
+    }
+    default: {
+      const check = payload;
+      return check;
+    }
+  }
+}
+var Queue = class {
+  queue = [];
+  pending = false;
+  enqueue(promise) {
+    return new Promise((resolve, reject) => {
+      this.queue.push({
+        promise,
+        resolve,
+        reject
+      });
+      this.dequeue();
+    });
+  }
+  dequeue() {
+    if (this.pending) {
+      return false;
+    }
+    const item = this.queue.shift();
+    if (!item) {
+      return false;
+    }
+    this.pending = true;
+    item.promise().then(item.resolve).catch(item.reject).finally(() => {
+      this.pending = false;
+      this.dequeue();
+    });
+    return true;
+  }
+};
+var sourceMapCache = {};
+var fileContentsCache = {};
+var moduleGraphs = /* @__PURE__ */ new Set();
+var retrieveFileHandlers = /* @__PURE__ */ new Set();
+var retrieveSourceMapHandlers = /* @__PURE__ */ new Set();
+var createExecHandlers = (handlers) => {
+  return (...args) => {
+    for (const handler of handlers) {
+      const result = handler(...args);
+      if (result)
+        return result;
+    }
+    return null;
+  };
+};
+var retrieveFileFromHandlers = createExecHandlers(retrieveFileHandlers);
+var retrievSourceMapFromHandlers = createExecHandlers(retrieveSourceMapHandlers);
+var overriden = false;
+var originalPrepare = Error.prepareStackTrace;
+function resetInterceptor(runtime2, options) {
+  moduleGraphs.delete(runtime2.moduleCache);
+  if (options.retrieveFile)
+    retrieveFileHandlers.delete(options.retrieveFile);
+  if (options.retrieveSourceMap)
+    retrieveSourceMapHandlers.delete(options.retrieveSourceMap);
+  if (moduleGraphs.size === 0) {
+    Error.prepareStackTrace = originalPrepare;
+    overriden = false;
+  }
+}
+function interceptStackTrace(runtime2, options = {}) {
+  if (!overriden) {
+    Error.prepareStackTrace = prepareStackTrace;
+    overriden = true;
+  }
+  moduleGraphs.add(runtime2.moduleCache);
+  if (options.retrieveFile)
+    retrieveFileHandlers.add(options.retrieveFile);
+  if (options.retrieveSourceMap)
+    retrieveSourceMapHandlers.add(options.retrieveSourceMap);
+  return () => resetInterceptor(runtime2, options);
+}
+function supportRelativeURL(file, url) {
+  if (!file)
+    return url;
+  const dir = posixDirname(file.replace(/\\/g, "/"));
+  const match = /^\w+:\/\/[^/]*/.exec(dir);
+  let protocol = match ? match[0] : "";
+  const startPath = dir.slice(protocol.length);
+  if (protocol && /^\/\w:/.test(startPath)) {
+    protocol += "/";
+    return protocol + posixResolve(dir.slice(protocol.length), url).replace(/\\/g, "/");
+  }
+  return protocol + posixResolve(dir.slice(protocol.length), url);
+}
+function getRuntimeSourceMap(position) {
+  for (const moduleCache of moduleGraphs) {
+    const sourceMap = moduleCache.getSourceMap(position.source);
+    if (sourceMap) {
+      return {
+        url: position.source,
+        map: sourceMap,
+        vite: true
+      };
+    }
+  }
+  return null;
+}
+function retrieveFile(path) {
+  if (path in fileContentsCache)
+    return fileContentsCache[path];
+  const content = retrieveFileFromHandlers(path);
+  if (typeof content === "string") {
+    fileContentsCache[path] = content;
+    return content;
+  }
+  return null;
+}
+function retrieveSourceMapURL(source) {
+  const fileData = retrieveFile(source);
+  if (!fileData)
+    return null;
+  const re = /\/\/[@#]\s*sourceMappingURL=([^\s'"]+)\s*$|\/\*[@#]\s*sourceMappingURL=[^\s*'"]+\s*\*\/\s*$/gm;
+  let lastMatch, match;
+  while (match = re.exec(fileData))
+    lastMatch = match;
+  if (!lastMatch)
+    return null;
+  return lastMatch[1];
+}
+var reSourceMap = /^data:application\/json[^,]+base64,/;
+function retrieveSourceMap(source) {
+  const urlAndMap = retrievSourceMapFromHandlers(source);
+  if (urlAndMap)
+    return urlAndMap;
+  let sourceMappingURL = retrieveSourceMapURL(source);
+  if (!sourceMappingURL)
+    return null;
+  let sourceMapData;
+  if (reSourceMap.test(sourceMappingURL)) {
+    const rawData = sourceMappingURL.slice(sourceMappingURL.indexOf(",") + 1);
+    sourceMapData = Buffer.from(rawData, "base64").toString();
+    sourceMappingURL = source;
+  } else {
+    sourceMappingURL = supportRelativeURL(source, sourceMappingURL);
+    sourceMapData = retrieveFile(sourceMappingURL);
+  }
+  if (!sourceMapData)
+    return null;
+  return {
+    url: sourceMappingURL,
+    map: sourceMapData
+  };
+}
+function mapSourcePosition(position) {
+  if (!position.source)
+    return position;
+  let sourceMap = getRuntimeSourceMap(position);
+  if (!sourceMap)
+    sourceMap = sourceMapCache[position.source];
+  if (!sourceMap) {
+    const urlAndMap = retrieveSourceMap(position.source);
+    if (urlAndMap && urlAndMap.map) {
+      const url = urlAndMap.url;
+      sourceMap = sourceMapCache[position.source] = {
+        url,
+        map: new DecodedMap(typeof urlAndMap.map === "string" ? JSON.parse(urlAndMap.map) : urlAndMap.map, url)
+      };
+      const contents = sourceMap.map?.map.sourcesContent;
+      if (sourceMap.map && contents) {
+        sourceMap.map.resolvedSources.forEach((source, i) => {
+          const content = contents[i];
+          if (content && source && url) {
+            const contentUrl = supportRelativeURL(url, source);
+            fileContentsCache[contentUrl] = content;
+          }
+        });
+      }
+    } else {
+      sourceMap = sourceMapCache[position.source] = {
+        url: null,
+        map: null
+      };
+    }
+  }
+  if (sourceMap && sourceMap.map && sourceMap.url) {
+    const originalPosition = getOriginalPosition(sourceMap.map, position);
+    if (originalPosition && originalPosition.source != null) {
+      originalPosition.source = supportRelativeURL(sourceMap.url, originalPosition.source);
+      if (sourceMap.vite) {
+        originalPosition._vite = true;
+      }
+      return originalPosition;
+    }
+  }
+  return position;
+}
+function mapEvalOrigin(origin) {
+  let match = /^eval at ([^(]+) \((.+):(\d+):(\d+)\)$/.exec(origin);
+  if (match) {
+    const position = mapSourcePosition({
+      name: null,
+      source: match[2],
+      line: +match[3],
+      column: +match[4] - 1
+    });
+    return `eval at ${match[1]} (${position.source}:${position.line}:${position.column + 1})`;
+  }
+  match = /^eval at ([^(]+) \((.+)\)$/.exec(origin);
+  if (match)
+    return `eval at ${match[1]} (${mapEvalOrigin(match[2])})`;
+  return origin;
+}
+function CallSiteToString() {
+  let fileName;
+  let fileLocation = "";
+  if (this.isNative()) {
+    fileLocation = "native";
+  } else {
+    fileName = this.getScriptNameOrSourceURL();
+    if (!fileName && this.isEval()) {
+      fileLocation = this.getEvalOrigin();
+      fileLocation += ", ";
+    }
+    if (fileName) {
+      fileLocation += fileName;
+    } else {
+      fileLocation += "<anonymous>";
+    }
+    const lineNumber = this.getLineNumber();
+    if (lineNumber != null) {
+      fileLocation += `:${lineNumber}`;
+      const columnNumber = this.getColumnNumber();
+      if (columnNumber)
+        fileLocation += `:${columnNumber}`;
+    }
+  }
+  let line = "";
+  const functionName = this.getFunctionName();
+  let addSuffix = true;
+  const isConstructor = this.isConstructor();
+  const isMethodCall = !(this.isToplevel() || isConstructor);
+  if (isMethodCall) {
+    let typeName = this.getTypeName();
+    if (typeName === "[object Object]")
+      typeName = "null";
+    const methodName = this.getMethodName();
+    if (functionName) {
+      if (typeName && functionName.indexOf(typeName) !== 0)
+        line += `${typeName}.`;
+      line += functionName;
+      if (methodName && functionName.indexOf(`.${methodName}`) !== functionName.length - methodName.length - 1)
+        line += ` [as ${methodName}]`;
+    } else {
+      line += `${typeName}.${methodName || "<anonymous>"}`;
+    }
+  } else if (isConstructor) {
+    line += `new ${functionName || "<anonymous>"}`;
+  } else if (functionName) {
+    line += functionName;
+  } else {
+    line += fileLocation;
+    addSuffix = false;
+  }
+  if (addSuffix)
+    line += ` (${fileLocation})`;
+  return line;
+}
+function cloneCallSite(frame) {
+  const object = {};
+  Object.getOwnPropertyNames(Object.getPrototypeOf(frame)).forEach((name) => {
+    const key = name;
+    object[key] = /^(?:is|get)/.test(name) ? function() {
+      return frame[key].call(frame);
+    } : frame[key];
+  });
+  object.toString = CallSiteToString;
+  return object;
+}
+function wrapCallSite(frame, state) {
+  if (state === void 0)
+    state = { nextPosition: null, curPosition: null };
+  if (frame.isNative()) {
+    state.curPosition = null;
+    return frame;
+  }
+  const source = frame.getFileName() || frame.getScriptNameOrSourceURL();
+  if (source) {
+    const line = frame.getLineNumber();
+    let column = frame.getColumnNumber() - 1;
+    const headerLength = 62;
+    if (line === 1 && column > headerLength && !frame.isEval())
+      column -= headerLength;
+    const position = mapSourcePosition({
+      name: null,
+      source,
+      line,
+      column
+    });
+    state.curPosition = position;
+    frame = cloneCallSite(frame);
+    const originalFunctionName = frame.getFunctionName;
+    frame.getFunctionName = function() {
+      const name = (() => {
+        if (state.nextPosition == null)
+          return originalFunctionName();
+        return state.nextPosition.name || originalFunctionName();
+      })();
+      return name === "eval" && "_vite" in position ? null : name;
+    };
+    frame.getFileName = function() {
+      return position.source ?? void 0;
+    };
+    frame.getLineNumber = function() {
+      return position.line;
+    };
+    frame.getColumnNumber = function() {
+      return position.column + 1;
+    };
+    frame.getScriptNameOrSourceURL = function() {
+      return position.source;
+    };
+    return frame;
+  }
+  let origin = frame.isEval() && frame.getEvalOrigin();
+  if (origin) {
+    origin = mapEvalOrigin(origin);
+    frame = cloneCallSite(frame);
+    frame.getEvalOrigin = function() {
+      return origin || void 0;
+    };
+    return frame;
+  }
+  return frame;
+}
+function prepareStackTrace(error, stack) {
+  const name = error.name || "Error";
+  const message = error.message || "";
+  const errorString = `${name}: ${message}`;
+  const state = { nextPosition: null, curPosition: null };
+  const processedStack = [];
+  for (let i = stack.length - 1; i >= 0; i--) {
+    processedStack.push(`
+    at ${wrapCallSite(stack[i], state)}`);
+    state.nextPosition = state.curPosition;
+  }
+  state.curPosition = state.nextPosition = null;
+  return errorString + processedStack.reverse().join("");
+}
+function enableSourceMapSupport(runtime2) {
+  if (runtime2.options.sourcemapInterceptor === "node") {
+    if (typeof process === "undefined") {
+      throw new TypeError(`Cannot use "sourcemapInterceptor: 'node'" because global "process" variable is not available.`);
+    }
+    if (typeof process.setSourceMapsEnabled !== "function") {
+      throw new TypeError(`Cannot use "sourcemapInterceptor: 'node'" because "process.setSourceMapsEnabled" function is not available. Please use Node >= 16.6.0.`);
+    }
+    const isEnabledAlready = process.sourceMapsEnabled ?? false;
+    process.setSourceMapsEnabled(true);
+    return () => !isEnabledAlready && process.setSourceMapsEnabled(false);
+  }
+  return interceptStackTrace(runtime2, typeof runtime2.options.sourcemapInterceptor === "object" ? runtime2.options.sourcemapInterceptor : void 0);
+}
+var ViteRuntime = class {
+  options;
+  runner;
+  debug;
+  /**
+   * Holds the cache of modules
+   * Keys of the map are ids
+   */
+  moduleCache;
+  hmrClient;
+  entrypoints = /* @__PURE__ */ new Set();
+  idToUrlMap = /* @__PURE__ */ new Map();
+  fileToIdMap = /* @__PURE__ */ new Map();
+  envProxy = new Proxy({}, {
+    get(_, p) {
+      throw new Error(`[vite-runtime] Dynamic access of "import.meta.env" is not supported. Please, use "import.meta.env.${String(p)}" instead.`);
+    }
+  });
+  _destroyed = false;
+  _resetSourceMapSupport;
+  constructor(options, runner, debug) {
+    this.options = options;
+    this.runner = runner;
+    this.debug = debug;
+    this.moduleCache = options.moduleCache ?? new ModuleCacheMap(options.root);
+    if (typeof options.hmr === "object") {
+      this.hmrClient = new HMRClient(options.hmr.logger === false ? silentConsole : options.hmr.logger || console, options.hmr.connection, ({ acceptedPath, ssrInvalidates }) => {
+        this.moduleCache.delete(acceptedPath);
+        if (ssrInvalidates) {
+          this.invalidateFiles(ssrInvalidates);
+        }
+        return this.executeUrl(acceptedPath);
+      });
+      options.hmr.connection.onUpdate(createHMRHandler(this));
+    }
+    if (options.sourcemapInterceptor !== false) {
+      this._resetSourceMapSupport = enableSourceMapSupport(this);
+    }
+  }
+  /**
+   * URL to execute. Accepts file path, server path or id relative to the root.
+   */
+  async executeUrl(url) {
+    url = this.normalizeEntryUrl(url);
+    const fetchedModule = await this.cachedModule(url);
+    return await this.cachedRequest(url, fetchedModule);
+  }
+  /**
+   * Entrypoint URL to execute. Accepts file path, server path or id relative to the root.
+   * In the case of a full reload triggered by HMR, this is the module that will be reloaded.
+   * If this method is called multiple times, all entrypoints will be reloaded one at a time.
+   */
+  async executeEntrypoint(url) {
+    url = this.normalizeEntryUrl(url);
+    const fetchedModule = await this.cachedModule(url);
+    return await this.cachedRequest(url, fetchedModule, [], {
+      entrypoint: true
+    });
+  }
+  /**
+   * Clear all caches including HMR listeners.
+   */
+  clearCache() {
+    this.moduleCache.clear();
+    this.idToUrlMap.clear();
+    this.entrypoints.clear();
+    this.hmrClient?.clear();
+  }
+  /**
+   * Clears all caches, removes all HMR listeners, and resets source map support.
+   * This method doesn't stop the HMR connection.
+   */
+  async destroy() {
+    this._resetSourceMapSupport?.();
+    this.clearCache();
+    this.hmrClient = void 0;
+    this._destroyed = true;
+  }
+  /**
+   * Returns `true` if the runtime has been destroyed by calling `destroy()` method.
+   */
+  isDestroyed() {
+    return this._destroyed;
+  }
+  invalidateFiles(files) {
+    files.forEach((file) => {
+      const ids = this.fileToIdMap.get(file);
+      if (ids) {
+        ids.forEach((id) => this.moduleCache.deleteByModuleId(id));
+      }
+    });
+  }
+  // we don't use moduleCache.normalize because this URL doesn't have to follow the same rules
+  // this URL is something that user passes down manually, and is later resolved by fetchModule
+  // moduleCache.normalize is used on resolved "file" property
+  normalizeEntryUrl(url) {
+    if (url[0] === ".") {
+      return url;
+    }
+    if (url.startsWith("file://")) {
+      url = url.slice(isWindows ? 8 : 7);
+    }
+    url = url.replace(/\\/g, "/");
+    const _root = this.options.root;
+    const root = _root[_root.length - 1] === "/" ? _root : `${_root}/`;
+    if (url.startsWith(root)) {
+      return url.slice(root.length - 1);
+    }
+    return url[0] === "/" ? url : wrapId(url);
+  }
+  processImport(exports, fetchResult, metadata) {
+    if (!("externalize" in fetchResult)) {
+      return exports;
+    }
+    const { id, type } = fetchResult;
+    if (type !== "module" && type !== "commonjs")
+      return exports;
+    analyzeImportedModDifference(exports, id, type, metadata);
+    return proxyGuardOnlyEsm(exports, id, metadata);
+  }
+  async cachedRequest(id, fetchedModule, callstack = [], metadata) {
+    const moduleId = fetchedModule.id;
+    if (metadata?.entrypoint) {
+      this.entrypoints.add(moduleId);
+    }
+    const mod = this.moduleCache.getByModuleId(moduleId);
+    const { imports, importers } = mod;
+    const importee = callstack[callstack.length - 1];
+    if (importee)
+      importers.add(importee);
+    if (callstack.includes(moduleId) || Array.from(imports.values()).some((i) => importers.has(i))) {
+      if (mod.exports)
+        return this.processImport(mod.exports, fetchedModule, metadata);
+    }
+    let debugTimer;
+    if (this.debug) {
+      debugTimer = setTimeout(() => {
+        const getStack = () => `stack:
+${[...callstack, moduleId].reverse().map((p) => `  - ${p}`).join("\n")}`;
+        this.debug(`[vite-runtime] module ${moduleId} takes over 2s to load.
+${getStack()}`);
+      }, 2e3);
+    }
+    try {
+      if (mod.promise)
+        return this.processImport(await mod.promise, fetchedModule, metadata);
+      const promise = this.directRequest(id, fetchedModule, callstack);
+      mod.promise = promise;
+      mod.evaluated = false;
+      return this.processImport(await promise, fetchedModule, metadata);
+    } finally {
+      mod.evaluated = true;
+      if (debugTimer)
+        clearTimeout(debugTimer);
+    }
+  }
+  async cachedModule(id, importer) {
+    if (this._destroyed) {
+      throw new Error(`[vite] Vite runtime has been destroyed.`);
+    }
+    const normalized = this.idToUrlMap.get(id);
+    if (normalized) {
+      const mod2 = this.moduleCache.getByModuleId(normalized);
+      if (mod2.meta) {
+        return mod2.meta;
+      }
+    }
+    this.debug?.("[vite-runtime] fetching", id);
+    const fetchedModule = id.startsWith("data:") ? { externalize: id, type: "builtin" } : await this.options.fetchModule(id, importer);
+    const idQuery = id.split("?")[1];
+    const query = idQuery ? `?${idQuery}` : "";
+    const file = "file" in fetchedModule ? fetchedModule.file : void 0;
+    const fullFile = file ? `${file}${query}` : id;
+    const moduleId = this.moduleCache.normalize(fullFile);
+    const mod = this.moduleCache.getByModuleId(moduleId);
+    fetchedModule.id = moduleId;
+    mod.meta = fetchedModule;
+    if (file) {
+      const fileModules = this.fileToIdMap.get(file) || [];
+      fileModules.push(moduleId);
+      this.fileToIdMap.set(file, fileModules);
+    }
+    this.idToUrlMap.set(id, moduleId);
+    this.idToUrlMap.set(unwrapId(id), moduleId);
+    return fetchedModule;
+  }
+  // override is allowed, consider this a public API
+  async directRequest(id, fetchResult, _callstack) {
+    const moduleId = fetchResult.id;
+    const callstack = [..._callstack, moduleId];
+    const mod = this.moduleCache.getByModuleId(moduleId);
+    const request = async (dep, metadata) => {
+      const fetchedModule = await this.cachedModule(dep, moduleId);
+      const depMod = this.moduleCache.getByModuleId(fetchedModule.id);
+      depMod.importers.add(moduleId);
+      mod.imports.add(fetchedModule.id);
+      return this.cachedRequest(dep, fetchedModule, callstack, metadata);
+    };
+    const dynamicRequest = async (dep) => {
+      dep = String(dep);
+      if (dep[0] === ".") {
+        dep = posixResolve(posixDirname(id), dep);
+      }
+      return request(dep, { isDynamicImport: true });
+    };
+    if ("externalize" in fetchResult) {
+      const { externalize } = fetchResult;
+      this.debug?.("[vite-runtime] externalizing", externalize);
+      const exports2 = await this.runner.runExternalModule(externalize);
+      mod.exports = exports2;
+      return exports2;
+    }
+    const { code, file } = fetchResult;
+    if (code == null) {
+      const importer = callstack[callstack.length - 2];
+      throw new Error(`[vite-runtime] Failed to load "${id}"${importer ? ` imported from ${importer}` : ""}`);
+    }
+    const modulePath = cleanUrl(file || moduleId);
+    const href = posixPathToFileHref(modulePath);
+    const filename = modulePath;
+    const dirname = posixDirname(modulePath);
+    const meta = {
+      filename: isWindows ? toWindowsPath(filename) : filename,
+      dirname: isWindows ? toWindowsPath(dirname) : dirname,
+      url: href,
+      env: this.envProxy,
+      resolve(id2, parent) {
+        throw new Error('[vite-runtime] "import.meta.resolve" is not supported.');
+      },
+      // should be replaced during transformation
+      glob() {
+        throw new Error('[vite-runtime] "import.meta.glob" is not supported.');
+      }
+    };
+    const exports = /* @__PURE__ */ Object.create(null);
+    Object.defineProperty(exports, Symbol.toStringTag, {
+      value: "Module",
+      enumerable: false,
+      configurable: false
+    });
+    mod.exports = exports;
+    let hotContext;
+    if (this.hmrClient) {
+      Object.defineProperty(meta, "hot", {
+        enumerable: true,
+        get: () => {
+          if (!this.hmrClient) {
+            throw new Error(`[vite-runtime] HMR client was destroyed.`);
+          }
+          this.debug?.("[vite-runtime] creating hmr context for", moduleId);
+          hotContext ||= new HMRContext(this.hmrClient, moduleId);
+          return hotContext;
+        },
+        set: (value) => {
+          hotContext = value;
+        }
+      });
+    }
+    const context = {
+      [ssrImportKey]: request,
+      [ssrDynamicImportKey]: dynamicRequest,
+      [ssrModuleExportsKey]: exports,
+      [ssrExportAllKey]: (obj) => exportAll(exports, obj),
+      [ssrImportMetaKey]: meta
+    };
+    this.debug?.("[vite-runtime] executing", href);
+    await this.runner.runViteModule(context, code, id);
+    return exports;
+  }
+};
+function exportAll(exports, sourceModule) {
+  if (exports === sourceModule)
+    return;
+  if (isPrimitive(sourceModule) || Array.isArray(sourceModule) || sourceModule instanceof Promise)
+    return;
+  for (const key in sourceModule) {
+    if (key !== "default" && key !== "__esModule") {
+      try {
+        Object.defineProperty(exports, key, {
+          enumerable: true,
+          configurable: true,
+          get: () => sourceModule[key]
+        });
+      } catch (_err) {
+      }
+    }
+  }
+}
+function analyzeImportedModDifference(mod, rawId, moduleType, metadata) {
+  if (metadata?.isDynamicImport)
+    return;
+  if (moduleType === "module")
+    return;
+  if (metadata?.importedNames?.length) {
+    const missingBindings = metadata.importedNames.filter((s) => !(s in mod));
+    if (missingBindings.length) {
+      const lastBinding = missingBindings[missingBindings.length - 1];
+      throw new SyntaxError(`[vite] Named export '${lastBinding}' not found. The requested module '${rawId}' is a CommonJS module, which may not support all module.exports as named exports.
+CommonJS modules can always be imported via the default export, for example using:
+
+import pkg from '${rawId}';
+const {${missingBindings.join(", ")}} = pkg;
+`);
+    }
+  }
+}
+function proxyGuardOnlyEsm(mod, rawId, metadata) {
+  if (!metadata?.importedNames?.length)
+    return mod;
+  return new Proxy(mod, {
+    get(mod2, prop) {
+      if (prop !== "then" && !(prop in mod2)) {
+        throw new SyntaxError(`[vite] The requested module '${rawId}' does not provide an export named '${prop.toString()}'`);
+      }
+      return mod2[prop];
+    }
+  });
+}
+var AsyncFunction = async function() {
+}.constructor;
+
+// src/lib/vite/worker-entry.ts
+var O2_PREFIX = "[o2:runtime]";
+var worker_entry_default = {
+  /**
+   * Worker entry module that wraps the user app's entry module.
+   */
+  async fetch(request, env, ctx) {
+    env.__VITE_SETUP_ENV(request);
+    const url = new URL(request.url);
+    const module = await fetchEntryModule(url, env);
+    if (url.pathname === env.__VITE_WARMUP_PATHNAME) {
+      return new globalThis.Response(null);
+    }
+    return module.default.fetch(request, createUserEnv(env), ctx);
+  }
+};
+function createUserEnv(env) {
+  return Object.fromEntries(
+    Object.entries(env).filter(([key]) => !key.startsWith("__VITE_"))
+  );
+}
+var runtime;
+function fetchEntryModule(publicUrl, env) {
+  if (!runtime) {
+    let onHmrRecieve;
+    let hmrReady = false;
+    connectHmrWsClient(publicUrl, env).then((hmrWs) => {
+      hmrReady = !!hmrWs;
+      hmrWs?.addEventListener("message", (message) => {
+        if (onHmrRecieve) {
+          let data = JSON.parse(message.data?.toString());
+          if (data?.type === "update") {
+            data = { type: "full-reload", path: "*" };
+          }
+          onHmrRecieve(data);
+        }
+      });
+    }).catch((error) => console.error(error));
+    runtime = new ViteRuntime(
+      {
+        root: env.__VITE_ROOT,
+        sourcemapInterceptor: "prepareStackTrace",
+        fetchModule: (id, importer) => {
+          const url = new URL(env.__VITE_FETCH_MODULE_PATHNAME, publicUrl);
+          url.searchParams.set("id", id);
+          if (importer)
+            url.searchParams.set("importer", importer);
+          return fetch(url).then((res) => res.json());
+        },
+        hmr: {
+          connection: {
+            isReady: () => hmrReady,
+            send: () => {
+            },
+            onUpdate(receiver) {
+              onHmrRecieve = receiver;
+              return () => {
+                onHmrRecieve = void 0;
+              };
+            }
+          }
+        }
+      },
+      {
+        runExternalModule(filepath) {
+          throw new Error(
+            `${O2_PREFIX} External modules are not supported: "${filepath}"`
+          );
+        },
+        async runViteModule(context, code, id) {
+          if (!env.__VITE_UNSAFE_EVAL) {
+            throw new Error(`${O2_PREFIX} unsafeEval module is not set`);
+          }
+          const initModule = env.__VITE_UNSAFE_EVAL.eval(
+            // 'use strict' is implied in ESM so we enable it here. Also, we
+            // add an extra block scope (`{}`) to allow redeclaring variables
+            // with the same name as the parameters.
+            `'use strict';async (${Object.keys(context).join(
+              ","
+            )})=>{{${code}
+}}`,
+            id
+          );
+          await initModule(...Object.values(context));
+          Object.freeze(context[ssrModuleExportsKey]);
+        }
+      }
+    );
+  }
+  return runtime.executeEntrypoint(env.__VITE_RUNTIME_EXECUTE_URL);
+}
+function connectHmrWsClient(url, env) {
+  const hmrUrl = env.__VITE_HMR_URL.startsWith("http://") ? env.__VITE_HMR_URL : new URL(env.__VITE_HMR_URL, url.origin);
+  return fetch(hmrUrl, {
+    // When the HTTP port and the HMR port are the same, Vite reuses the same server for both.
+    // This happens when not specifying the HMR port in the Vite config. Otherwise, Vite creates
+    // a new server for HMR. In the first case, the protocol header is required to specify
+    // that the connection to the main HTTP server via WS is for HMR.
+    // Ref: https://github.com/vitejs/vite/blob/7440191715b07a50992fcf8c90d07600dffc375e/packages/vite/src/node/server/ws.ts#L120-L127
+    headers: { Upgrade: "websocket", "sec-websocket-protocol": "vite-hmr" }
+  }).then((response) => {
+    const ws = response.webSocket;
+    if (!ws)
+      throw new Error(`${O2_PREFIX} Failed to connect to HMR server`);
+    ws.accept();
+    return ws;
+  });
+}
+export {
+  worker_entry_default as default
+};