@cloudflare/vite-plugin 0.0.0-229d00fce

package/dist/runner-worker/index.js

@@ -0,0 +1,1679 @@
+// src/runner-worker/index.ts
+import {
+  DurableObject,
+  WorkerEntrypoint,
+  WorkflowEntrypoint
+} from "cloudflare:workers";
+
+// src/shared.ts
+var UNKNOWN_HOST = "http://localhost";
+var INIT_PATH = "/__vite_plugin_cloudflare_init__";
+
+// src/runner-worker/env.ts
+function stripInternalEnv(internalEnv) {
+  const {
+    __VITE_ROOT__,
+    __VITE_ENTRY_PATH__,
+    __VITE_INVOKE_MODULE__,
+    __VITE_UNSAFE_EVAL__,
+    ...userEnv
+  } = internalEnv;
+  return userEnv;
+}
+
+// ../../node_modules/.pnpm/vite@6.0.7_@types+node@18.19.59_jiti@2.4.2/node_modules/vite/dist/node/module-runner.js
+var VALID_ID_PREFIX = "/@id/";
+var NULL_BYTE_PLACEHOLDER = "__x00__";
+var SOURCEMAPPING_URL = "sourceMa";
+SOURCEMAPPING_URL += "ppingURL";
+var ERR_OUTDATED_OPTIMIZED_DEP = "ERR_OUTDATED_OPTIMIZED_DEP";
+var isWindows = typeof process < "u" && process.platform === "win32";
+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 AsyncFunction = async function() {
+}.constructor;
+var asyncFunctionDeclarationPaddingLineCount;
+function getAsyncFunctionDeclarationPaddingLineCount() {
+  if (typeof asyncFunctionDeclarationPaddingLineCount > "u") {
+    const body = "/*code*/", source = new AsyncFunction("a", "b", body).toString();
+    asyncFunctionDeclarationPaddingLineCount = source.slice(0, source.indexOf(body)).split(`
+`).length - 1;
+  }
+  return asyncFunctionDeclarationPaddingLineCount;
+}
+function promiseWithResolvers() {
+  let resolve2, reject;
+  return { promise: new Promise((_resolve, _reject) => {
+    resolve2 = _resolve, reject = _reject;
+  }), resolve: resolve2, reject };
+}
+var _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+  return input && input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+var _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+var _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+function cwd() {
+  return typeof process < "u" && typeof process.cwd == "function" ? process.cwd().replace(/\\/g, "/") : "/";
+}
+var resolve = function(...arguments_) {
+  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+  let resolvedPath = "", resolvedAbsolute = false;
+  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+    const path = index >= 0 ? arguments_[index] : cwd();
+    !path || path.length === 0 || (resolvedPath = `${path}/${resolvedPath}`, resolvedAbsolute = isAbsolute(path));
+  }
+  return resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute), resolvedAbsolute && !isAbsolute(resolvedPath) ? `/${resolvedPath}` : resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+  let res = "", lastSegmentLength = 0, lastSlash = -1, dots = 0, char = null;
+  for (let index = 0; index <= path.length; ++index) {
+    if (index < path.length)
+      char = path[index];
+    else {
+      if (char === "/")
+        break;
+      char = "/";
+    }
+    if (char === "/") {
+      if (!(lastSlash === index - 1 || dots === 1)) 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("/");
+            lastSlashIndex === -1 ? (res = "", lastSegmentLength = 0) : (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;
+          }
+        }
+        allowAboveRoot && (res += res.length > 0 ? "/.." : "..", lastSegmentLength = 2);
+      } else
+        res.length > 0 ? res += `/${path.slice(lastSlash + 1, index)}` : res = path.slice(lastSlash + 1, index), lastSegmentLength = index - lastSlash - 1;
+      lastSlash = index, dots = 0;
+    } else char === "." && dots !== -1 ? ++dots : dots = -1;
+  }
+  return res;
+}
+var isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+};
+var dirname = function(p) {
+  const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+  return segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0]) && (segments[0] += "/"), segments.join("/") || (isAbsolute(p) ? "/" : ".");
+};
+var decodeBase64 = typeof atob < "u" ? atob : (str) => Buffer.from(str, "base64").toString("utf-8");
+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) {
+  return filepath.indexOf("%") !== -1 && (filepath = filepath.replace(percentRegEx, "%25")), !isWindows && filepath.indexOf("\\") !== -1 && (filepath = filepath.replace(backslashRegEx, "%5C")), filepath.indexOf(`
+`) !== -1 && (filepath = filepath.replace(newlineRegEx, "%0A")), filepath.indexOf("\r") !== -1 && (filepath = filepath.replace(carriageReturnRegEx, "%0D")), filepath.indexOf("	") !== -1 && (filepath = filepath.replace(tabRegEx, "%09")), filepath;
+}
+var posixDirname = dirname;
+var posixResolve = resolve;
+function posixPathToFileHref(posixPath) {
+  let resolved = posixResolve(posixPath);
+  const filePathLast = posixPath.charCodeAt(posixPath.length - 1);
+  return (filePathLast === CHAR_FORWARD_SLASH || isWindows && filePathLast === CHAR_BACKWARD_SLASH) && resolved[resolved.length - 1] !== "/" && (resolved += "/"), resolved = encodePathChars(resolved), resolved.indexOf("?") !== -1 && (resolved = resolved.replace(questionRegex, "%3F")), resolved.indexOf("#") !== -1 && (resolved = resolved.replace(hashRegex, "%23")), new URL(`file://${resolved}`).href;
+}
+function toWindowsPath(path) {
+  return path.replace(/\//g, "\\");
+}
+var comma = 44;
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+  const c = chars.charCodeAt(i);
+  intToChar[i] = c, charToInt[c] = i;
+}
+function decodeInteger(reader, relative) {
+  let value = 0, shift = 0, integer = 0;
+  do {
+    const c = reader.next();
+    integer = charToInt[c], value |= (integer & 31) << shift, shift += 5;
+  } while (integer & 32);
+  const shouldNegate = value & 1;
+  return value >>>= 1, shouldNegate && (value = -2147483648 | -value), relative + value;
+}
+function hasMoreVlq(reader, max) {
+  return reader.pos >= max ? false : reader.peek() !== comma;
+}
+var StringReader = class {
+  constructor(buffer) {
+    this.pos = 0, this.buffer = buffer;
+  }
+  next() {
+    return this.buffer.charCodeAt(this.pos++);
+  }
+  peek() {
+    return this.buffer.charCodeAt(this.pos);
+  }
+  indexOf(char) {
+    const { buffer, pos } = this, idx = buffer.indexOf(char, pos);
+    return idx === -1 ? buffer.length : idx;
+  }
+};
+function decode(mappings) {
+  const { length } = mappings, reader = new StringReader(mappings), decoded = [];
+  let genColumn = 0, sourcesIndex = 0, sourceLine = 0, sourceColumn = 0, namesIndex = 0;
+  do {
+    const semi = reader.indexOf(";"), line = [];
+    let sorted = true, lastCol = 0;
+    for (genColumn = 0; reader.pos < semi; ) {
+      let seg;
+      genColumn = decodeInteger(reader, genColumn), genColumn < lastCol && (sorted = false), lastCol = genColumn, hasMoreVlq(reader, semi) ? (sourcesIndex = decodeInteger(reader, sourcesIndex), sourceLine = decodeInteger(reader, sourceLine), sourceColumn = decodeInteger(reader, sourceColumn), hasMoreVlq(reader, semi) ? (namesIndex = decodeInteger(reader, namesIndex), seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex]) : seg = [genColumn, sourcesIndex, sourceLine, sourceColumn]) : seg = [genColumn], line.push(seg), reader.pos++;
+    }
+    sorted || sort(line), decoded.push(line), reader.pos = semi + 1;
+  } while (reader.pos <= length);
+  return decoded;
+}
+function sort(line) {
+  line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+  return a[0] - b[0];
+}
+var COLUMN = 0;
+var SOURCES_INDEX = 1;
+var SOURCE_LINE = 2;
+var SOURCE_COLUMN = 3;
+var NAMES_INDEX = 4;
+var found = false;
+function binarySearch(haystack, needle, low, high) {
+  for (; low <= high; ) {
+    const mid = low + (high - low >> 1), cmp = haystack[mid][COLUMN] - needle;
+    if (cmp === 0)
+      return found = true, mid;
+    cmp < 0 ? low = mid + 1 : high = mid - 1;
+  }
+  return found = false, low - 1;
+}
+function upperBound(haystack, needle, index) {
+  for (let i = index + 1; i < haystack.length && haystack[i][COLUMN] === needle; index = i++)
+    ;
+  return index;
+}
+function lowerBound(haystack, needle, index) {
+  for (let i = index - 1; i >= 0 && haystack[i][COLUMN] === needle; index = i--)
+    ;
+  return index;
+}
+function memoizedBinarySearch(haystack, needle, state, key) {
+  const { lastKey, lastNeedle, lastIndex } = state;
+  let low = 0, high = haystack.length - 1;
+  if (key === lastKey) {
+    if (needle === lastNeedle)
+      return found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle, lastIndex;
+    needle >= lastNeedle ? low = lastIndex === -1 ? 0 : lastIndex : high = lastIndex;
+  }
+  return state.lastKey = key, state.lastNeedle = needle, state.lastIndex = binarySearch(haystack, needle, low, high);
+}
+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 LEAST_UPPER_BOUND = -1;
+var GREATEST_LOWER_BOUND = 1;
+function decodedMappings(map) {
+  var _a;
+  return (_a = map)._decoded || (_a._decoded = decode(map._encoded));
+}
+function originalPositionFor(map, needle) {
+  let { line, column, bias } = needle;
+  if (line--, line < 0)
+    throw new Error(LINE_GTR_ZERO);
+  if (column < 0)
+    throw new Error(COL_GTR_EQ_ZERO);
+  const decoded = decodedMappings(map);
+  if (line >= decoded.length)
+    return OMapping(null, null, null, null);
+  const segments = decoded[line], index = traceSegmentInternal(segments, map._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
+  if (index === -1)
+    return OMapping(null, null, null, null);
+  const segment = segments[index];
+  if (segment.length === 1)
+    return OMapping(null, null, null, 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);
+}
+function OMapping(source, line, column, name) {
+  return { source, line, column, name };
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+  let index = memoizedBinarySearch(segments, column, memo, line);
+  return found ? index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index) : bias === LEAST_UPPER_BOUND && index++, index === -1 || index === segments.length ? -1 : index;
+}
+var DecodedMap = class {
+  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)
+    );
+  }
+  _encoded;
+  _decoded;
+  _decodedMemo;
+  url;
+  version;
+  names = [];
+  resolvedSources;
+};
+function memoizedState() {
+  return {
+    lastKey: -1,
+    lastNeedle: -1,
+    lastIndex: -1
+  };
+}
+function getOriginalPosition(map, needle) {
+  const result = originalPositionFor(map, needle);
+  return result.column == null ? null : result;
+}
+var MODULE_RUNNER_SOURCEMAPPING_REGEXP = new RegExp(
+  `//# ${SOURCEMAPPING_URL}=data:application/json;base64,(.+)`
+);
+var EvaluatedModuleNode = class {
+  constructor(id, url) {
+    this.id = id, this.url = url, this.file = cleanUrl(id);
+  }
+  importers = /* @__PURE__ */ new Set();
+  imports = /* @__PURE__ */ new Set();
+  evaluated = false;
+  meta;
+  promise;
+  exports;
+  file;
+  map;
+};
+var EvaluatedModules = class {
+  idToModuleMap = /* @__PURE__ */ new Map();
+  fileToModulesMap = /* @__PURE__ */ new Map();
+  urlToIdModuleMap = /* @__PURE__ */ new Map();
+  /**
+   * Returns the module node by the resolved module ID. Usually, module ID is
+   * the file system path with query and/or hash. It can also be a virtual module.
+   *
+   * Module runner graph will have 1 to 1 mapping with the server module graph.
+   * @param id Resolved module ID
+   */
+  getModuleById(id) {
+    return this.idToModuleMap.get(id);
+  }
+  /**
+   * Returns all modules related to the file system path. Different modules
+   * might have different query parameters or hash, so it's possible to have
+   * multiple modules for the same file.
+   * @param file The file system path of the module
+   */
+  getModulesByFile(file) {
+    return this.fileToModulesMap.get(file);
+  }
+  /**
+   * Returns the module node by the URL that was used in the import statement.
+   * Unlike module graph on the server, the URL is not resolved and is used as is.
+   * @param url Server URL that was used in the import statement
+   */
+  getModuleByUrl(url) {
+    return this.urlToIdModuleMap.get(unwrapId(url));
+  }
+  /**
+   * Ensure that module is in the graph. If the module is already in the graph,
+   * it will return the existing module node. Otherwise, it will create a new
+   * module node and add it to the graph.
+   * @param id Resolved module ID
+   * @param url URL that was used in the import statement
+   */
+  ensureModule(id, url) {
+    if (id = normalizeModuleId(id), this.idToModuleMap.has(id)) {
+      const moduleNode2 = this.idToModuleMap.get(id);
+      return this.urlToIdModuleMap.set(url, moduleNode2), moduleNode2;
+    }
+    const moduleNode = new EvaluatedModuleNode(id, url);
+    this.idToModuleMap.set(id, moduleNode), this.urlToIdModuleMap.set(url, moduleNode);
+    const fileModules = this.fileToModulesMap.get(moduleNode.file) || /* @__PURE__ */ new Set();
+    return fileModules.add(moduleNode), this.fileToModulesMap.set(moduleNode.file, fileModules), moduleNode;
+  }
+  invalidateModule(node) {
+    node.evaluated = false, node.meta = void 0, node.map = void 0, node.promise = void 0, node.exports = void 0, node.imports.clear();
+  }
+  /**
+   * Extracts the inlined source map from the module code and returns the decoded
+   * source map. If the source map is not inlined, it will return null.
+   * @param id Resolved module ID
+   */
+  getModuleSourceMapById(id) {
+    const mod = this.getModuleById(id);
+    if (!mod) return null;
+    if (mod.map) return mod.map;
+    if (!mod.meta || !("code" in mod.meta)) return null;
+    const mapString = MODULE_RUNNER_SOURCEMAPPING_REGEXP.exec(
+      mod.meta.code
+    )?.[1];
+    return mapString ? (mod.map = new DecodedMap(JSON.parse(decodeBase64(mapString)), mod.file), mod.map) : null;
+  }
+  clear() {
+    this.idToModuleMap.clear(), this.fileToModulesMap.clear(), this.urlToIdModuleMap.clear();
+  }
+};
+var prefixedBuiltins = /* @__PURE__ */ new Set([
+  "node:sea",
+  "node:sqlite",
+  "node:test",
+  "node:test/reporters"
+]);
+function normalizeModuleId(file) {
+  return prefixedBuiltins.has(file) ? file : slash(file).replace(/^\/@fs\//, isWindows ? "" : "/").replace(/^node:/, "").replace(/^\/+/, "/").replace(/^file:\//, "/");
+}
+var HMRContext = class {
+  constructor(hmrClient, ownerPath) {
+    this.hmrClient = hmrClient, this.ownerPath = ownerPath, hmrClient.dataMap.has(ownerPath) || hmrClient.dataMap.set(ownerPath, {});
+    const mod = hmrClient.hotModulesMap.get(ownerPath);
+    mod && (mod.callbacks = []);
+    const staleListeners = hmrClient.ctxToListenersMap.get(ownerPath);
+    if (staleListeners)
+      for (const [event, staleFns] of staleListeners) {
+        const listeners = hmrClient.customListenersMap.get(event);
+        listeners && hmrClient.customListenersMap.set(
+          event,
+          listeners.filter((l) => !staleFns.includes(l))
+        );
+      }
+    this.newListeners = /* @__PURE__ */ new Map(), hmrClient.ctxToListenersMap.set(ownerPath, this.newListeners);
+  }
+  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(
+      `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.send({ 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 HMRClient = class {
+  constructor(logger, transport, importUpdatedModule) {
+    this.logger = logger, this.transport = transport, this.importUpdatedModule = 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();
+  async notifyListeners(event, data) {
+    const cbs = this.customListenersMap.get(event);
+    cbs && await Promise.allSettled(cbs.map((cb) => cb(data)));
+  }
+  send(payload) {
+    this.transport.send(payload).catch((err) => {
+      this.logger.error(err);
+    });
+  }
+  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)
+  async prunePaths(paths) {
+    await Promise.all(
+      paths.map((path) => {
+        const disposer = this.disposeMap.get(path);
+        if (disposer) return disposer(this.dataMap.get(path));
+      })
+    ), paths.forEach((path) => {
+      const fn = this.pruneMap.get(path);
+      fn && fn(this.dataMap.get(path));
+    });
+  }
+  warnFailedUpdate(err, path) {
+    err.message.includes("fetch") || this.logger.error(err), this.logger.error(
+      `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) {
+    if (this.updateQueue.push(this.fetchUpdate(payload)), !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, mod = this.hotModulesMap.get(path);
+    if (!mod)
+      return;
+    let fetchedModule;
+    const isSelfUpdate = path === acceptedPath, qualifiedCallbacks = mod.callbacks.filter(
+      ({ deps }) => deps.includes(acceptedPath)
+    );
+    if (isSelfUpdate || qualifiedCallbacks.length > 0) {
+      const disposer = this.disposeMap.get(acceptedPath);
+      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(`hot updated: ${loggedPath}`);
+    };
+  }
+};
+function analyzeImportedModDifference(mod, rawId, moduleType, metadata) {
+  if (!metadata?.isDynamicImport && metadata?.importedNames?.length) {
+    const missingBindings = metadata.importedNames.filter((s) => !(s in mod));
+    if (missingBindings.length) {
+      const lastBinding = missingBindings[missingBindings.length - 1];
+      throw moduleType === "module" ? new SyntaxError(
+        `[vite] The requested module '${rawId}' does not provide an export named '${lastBinding}'`
+      ) : 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;
+`);
+    }
+  }
+}
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+var nanoid = (size = 21) => {
+  let id = "", i = size | 0;
+  for (; i--; )
+    id += urlAlphabet[Math.random() * 64 | 0];
+  return id;
+};
+function reviveInvokeError(e) {
+  const error = new Error(e.message || "Unknown invoke error");
+  return Object.assign(error, e, {
+    // pass the whole error instead of just the stacktrace
+    // so that it gets formatted nicely with console.log
+    runnerError: new Error("RunnerError")
+  }), error;
+}
+var createInvokeableTransport = (transport) => {
+  if (transport.invoke)
+    return {
+      ...transport,
+      async invoke(name, data) {
+        const result = await transport.invoke({
+          type: "custom",
+          event: "vite:invoke",
+          data: {
+            id: "send",
+            name,
+            data
+          }
+        });
+        if ("error" in result)
+          throw reviveInvokeError(result.error);
+        return result.result;
+      }
+    };
+  if (!transport.send || !transport.connect)
+    throw new Error(
+      "transport must implement send and connect when invoke is not implemented"
+    );
+  const rpcPromises = /* @__PURE__ */ new Map();
+  return {
+    ...transport,
+    connect({ onMessage, onDisconnection }) {
+      return transport.connect({
+        onMessage(payload) {
+          if (payload.type === "custom" && payload.event === "vite:invoke") {
+            const data = payload.data;
+            if (data.id.startsWith("response:")) {
+              const invokeId = data.id.slice(9), promise = rpcPromises.get(invokeId);
+              if (!promise) return;
+              promise.timeoutId && clearTimeout(promise.timeoutId), rpcPromises.delete(invokeId);
+              const { error, result } = data.data;
+              error ? promise.reject(error) : promise.resolve(result);
+              return;
+            }
+          }
+          onMessage(payload);
+        },
+        onDisconnection
+      });
+    },
+    disconnect() {
+      return rpcPromises.forEach((promise) => {
+        promise.reject(
+          new Error(
+            `transport was disconnected, cannot call ${JSON.stringify(promise.name)}`
+          )
+        );
+      }), rpcPromises.clear(), transport.disconnect?.();
+    },
+    send(data) {
+      return transport.send(data);
+    },
+    async invoke(name, data) {
+      const promiseId = nanoid(), wrappedData = {
+        type: "custom",
+        event: "vite:invoke",
+        data: {
+          name,
+          id: `send:${promiseId}`,
+          data
+        }
+      }, sendPromise = transport.send(wrappedData), { promise, resolve: resolve2, reject } = promiseWithResolvers(), timeout = transport.timeout ?? 6e4;
+      let timeoutId;
+      timeout > 0 && (timeoutId = setTimeout(() => {
+        rpcPromises.delete(promiseId), reject(
+          new Error(
+            `transport invoke timed out after ${timeout}ms (data: ${JSON.stringify(wrappedData)})`
+          )
+        );
+      }, timeout), timeoutId?.unref?.()), rpcPromises.set(promiseId, { resolve: resolve2, reject, name, timeoutId }), sendPromise && sendPromise.catch((err) => {
+        clearTimeout(timeoutId), rpcPromises.delete(promiseId), reject(err);
+      });
+      try {
+        return await promise;
+      } catch (err) {
+        throw reviveInvokeError(err);
+      }
+    }
+  };
+};
+var normalizeModuleRunnerTransport = (transport) => {
+  const invokeableTransport = createInvokeableTransport(transport);
+  let isConnected = !invokeableTransport.connect, connectingPromise;
+  return {
+    ...transport,
+    ...invokeableTransport.connect ? {
+      async connect(onMessage) {
+        if (isConnected) return;
+        if (connectingPromise) {
+          await connectingPromise;
+          return;
+        }
+        const maybePromise = invokeableTransport.connect({
+          onMessage: onMessage ?? (() => {
+          }),
+          onDisconnection() {
+            isConnected = false;
+          }
+        });
+        maybePromise && (connectingPromise = maybePromise, await connectingPromise, connectingPromise = void 0), isConnected = true;
+      }
+    } : {},
+    ...invokeableTransport.disconnect ? {
+      async disconnect() {
+        isConnected && (connectingPromise && await connectingPromise, isConnected = false, await invokeableTransport.disconnect());
+      }
+    } : {},
+    async send(data) {
+      if (invokeableTransport.send) {
+        if (!isConnected)
+          if (connectingPromise)
+            await connectingPromise;
+          else
+            throw new Error("send was called before connect");
+        await invokeableTransport.send(data);
+      }
+    },
+    async invoke(name, data) {
+      if (!isConnected)
+        if (connectingPromise)
+          await connectingPromise;
+        else
+          throw new Error("invoke was called before connect");
+      return invokeableTransport.invoke(name, data);
+    }
+  };
+};
+var createWebSocketModuleRunnerTransport = (options) => {
+  const pingInterval = options.pingInterval ?? 3e4;
+  let ws, pingIntervalId;
+  return {
+    async connect({ onMessage, onDisconnection }) {
+      const socket = options.createConnection();
+      socket.addEventListener("message", async ({ data }) => {
+        onMessage(JSON.parse(data));
+      });
+      let isOpened = socket.readyState === socket.OPEN;
+      isOpened || await new Promise((resolve2, reject) => {
+        socket.addEventListener(
+          "open",
+          () => {
+            isOpened = true, resolve2();
+          },
+          { once: true }
+        ), socket.addEventListener("close", async () => {
+          if (!isOpened) {
+            reject(new Error("WebSocket closed without opened."));
+            return;
+          }
+          onMessage({
+            type: "custom",
+            event: "vite:ws:disconnect",
+            data: { webSocket: socket }
+          }), onDisconnection();
+        });
+      }), onMessage({
+        type: "custom",
+        event: "vite:ws:connect",
+        data: { webSocket: socket }
+      }), ws = socket, pingIntervalId = setInterval(() => {
+        socket.readyState === socket.OPEN && socket.send(JSON.stringify({ type: "ping" }));
+      }, pingInterval);
+    },
+    disconnect() {
+      clearInterval(pingIntervalId), ws?.close();
+    },
+    send(data) {
+      ws.send(JSON.stringify(data));
+    }
+  };
+};
+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
+};
+var hmrLogger = {
+  debug: (...msg) => console.log("[vite]", ...msg),
+  error: (error) => console.log("[vite]", error)
+};
+function createHMRHandler(runner) {
+  const queue = new Queue();
+  return (payload) => queue.enqueue(() => handleHotPayload(runner, payload));
+}
+async function handleHotPayload(runner, payload) {
+  const hmrClient = runner.hmrClient;
+  if (!(!hmrClient || runner.isClosed()))
+    switch (payload.type) {
+      case "connected":
+        hmrClient.logger.debug("connected.");
+        break;
+      case "update":
+        await hmrClient.notifyListeners("vite:beforeUpdate", payload), await Promise.all(
+          payload.updates.map(async (update) => {
+            if (update.type === "js-update")
+              return update.acceptedPath = unwrapId(update.acceptedPath), update.path = unwrapId(update.path), hmrClient.queueUpdate(update);
+            hmrClient.logger.error("css hmr is not supported in runner mode.");
+          })
+        ), await hmrClient.notifyListeners("vite:afterUpdate", payload);
+        break;
+      case "custom": {
+        await hmrClient.notifyListeners(payload.event, payload.data);
+        break;
+      }
+      case "full-reload": {
+        const { triggeredBy } = payload, clearEntrypointUrls = triggeredBy ? getModulesEntrypoints(
+          runner,
+          getModulesByFile(runner, slash(triggeredBy))
+        ) : findAllEntrypoints(runner);
+        if (!clearEntrypointUrls.size) break;
+        hmrClient.logger.debug("program reload"), await hmrClient.notifyListeners("vite:beforeFullReload", payload), runner.evaluatedModules.clear();
+        for (const url of clearEntrypointUrls)
+          try {
+            await runner.import(url);
+          } catch (err) {
+            err.code !== ERR_OUTDATED_OPTIMIZED_DEP && hmrClient.logger.error(
+              `An error happened during full reload
+${err.message}
+${err.stack}`
+            );
+          }
+        break;
+      }
+      case "prune":
+        await hmrClient.notifyListeners("vite:beforePrune", payload), await hmrClient.prunePaths(payload.paths);
+        break;
+      case "error": {
+        await hmrClient.notifyListeners("vite:error", payload);
+        const err = payload.err;
+        hmrClient.logger.error(
+          `Internal Server Error
+${err.message}
+${err.stack}`
+        );
+        break;
+      }
+      case "ping":
+        break;
+      default:
+        return payload;
+    }
+}
+var Queue = class {
+  queue = [];
+  pending = false;
+  enqueue(promise) {
+    return new Promise((resolve2, reject) => {
+      this.queue.push({
+        promise,
+        resolve: resolve2,
+        reject
+      }), this.dequeue();
+    });
+  }
+  dequeue() {
+    if (this.pending)
+      return false;
+    const item = this.queue.shift();
+    return item ? (this.pending = true, item.promise().then(item.resolve).catch(item.reject).finally(() => {
+      this.pending = false, this.dequeue();
+    }), true) : false;
+  }
+};
+function getModulesByFile(runner, file) {
+  const nodes = runner.evaluatedModules.getModulesByFile(file);
+  return nodes ? [...nodes].map((node) => node.id) : [];
+}
+function getModulesEntrypoints(runner, modules, visited = /* @__PURE__ */ new Set(), entrypoints = /* @__PURE__ */ new Set()) {
+  for (const moduleId of modules) {
+    if (visited.has(moduleId)) continue;
+    visited.add(moduleId);
+    const module = runner.evaluatedModules.getModuleById(moduleId);
+    if (module) {
+      if (!module.importers.size) {
+        entrypoints.add(module.url);
+        continue;
+      }
+      for (const importer of module.importers)
+        getModulesEntrypoints(runner, [importer], visited, entrypoints);
+    }
+  }
+  return entrypoints;
+}
+function findAllEntrypoints(runner, entrypoints = /* @__PURE__ */ new Set()) {
+  for (const mod of runner.evaluatedModules.idToModuleMap.values())
+    mod.importers.size || entrypoints.add(mod.url);
+  return entrypoints;
+}
+var sourceMapCache = {};
+var fileContentsCache = {};
+var evaluatedModulesCache = /* @__PURE__ */ new Set();
+var retrieveFileHandlers = /* @__PURE__ */ new Set();
+var retrieveSourceMapHandlers = /* @__PURE__ */ new Set();
+var createExecHandlers = (handlers) => (...args) => {
+  for (const handler of handlers) {
+    const result = handler(...args);
+    if (result) return result;
+  }
+  return null;
+};
+var retrieveFileFromHandlers = createExecHandlers(retrieveFileHandlers);
+var retrieveSourceMapFromHandlers = createExecHandlers(
+  retrieveSourceMapHandlers
+);
+var overridden = false;
+var originalPrepare = Error.prepareStackTrace;
+function resetInterceptor(runner, options) {
+  evaluatedModulesCache.delete(runner.evaluatedModules), options.retrieveFile && retrieveFileHandlers.delete(options.retrieveFile), options.retrieveSourceMap && retrieveSourceMapHandlers.delete(options.retrieveSourceMap), evaluatedModulesCache.size === 0 && (Error.prepareStackTrace = originalPrepare, overridden = false);
+}
+function interceptStackTrace(runner, options = {}) {
+  return overridden || (Error.prepareStackTrace = prepareStackTrace, overridden = true), evaluatedModulesCache.add(runner.evaluatedModules), options.retrieveFile && retrieveFileHandlers.add(options.retrieveFile), options.retrieveSourceMap && retrieveSourceMapHandlers.add(options.retrieveSourceMap), () => resetInterceptor(runner, options);
+}
+function supportRelativeURL(file, url) {
+  if (!file) return url;
+  const dir = posixDirname(slash(file)), match = /^\w+:\/\/[^/]*/.exec(dir);
+  let protocol = match ? match[0] : "";
+  const startPath = dir.slice(protocol.length);
+  return protocol && /^\/\w:/.test(startPath) ? (protocol += "/", protocol + slash(posixResolve(startPath, url))) : protocol + posixResolve(startPath, url);
+}
+function getRunnerSourceMap(position) {
+  for (const moduleGraph of evaluatedModulesCache) {
+    const sourceMap = moduleGraph.getModuleSourceMapById(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);
+  return typeof content == "string" ? (fileContentsCache[path] = content, content) : 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;
+  for (; match = re.exec(fileData); ) lastMatch = match;
+  return lastMatch ? lastMatch[1] : null;
+}
+var reSourceMap = /^data:application\/json[^,]+base64,/;
+function retrieveSourceMap(source) {
+  const urlAndMap = retrieveSourceMapFromHandlers(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);
+  return sourceMapData ? {
+    url: sourceMappingURL,
+    map: sourceMapData
+  } : null;
+}
+function mapSourcePosition(position) {
+  if (!position.source) return position;
+  let sourceMap = getRunnerSourceMap(position);
+  if (sourceMap || (sourceMap = sourceMapCache[position.source]), !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;
+      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.map && sourceMap.url) {
+    const originalPosition = getOriginalPosition(sourceMap.map, position);
+    if (originalPosition && originalPosition.source != null)
+      return originalPosition.source = supportRelativeURL(
+        sourceMap.url,
+        originalPosition.source
+      ), sourceMap.vite && (originalPosition._vite = true), 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})`;
+  }
+  return match = /^eval at ([^(]+) \((.+)\)$/.exec(origin), match ? `eval at ${match[1]} (${mapEvalOrigin(match[2])})` : origin;
+}
+function CallSiteToString() {
+  let fileName, fileLocation = "";
+  if (this.isNative())
+    fileLocation = "native";
+  else {
+    fileName = this.getScriptNameOrSourceURL(), !fileName && this.isEval() && (fileLocation = this.getEvalOrigin(), fileLocation += ", "), fileName ? fileLocation += fileName : fileLocation += "<anonymous>";
+    const lineNumber = this.getLineNumber();
+    if (lineNumber != null) {
+      fileLocation += `:${lineNumber}`;
+      const columnNumber = this.getColumnNumber();
+      columnNumber && (fileLocation += `:${columnNumber}`);
+    }
+  }
+  let line = "";
+  const functionName = this.getFunctionName();
+  let addSuffix = true;
+  const isConstructor = this.isConstructor();
+  if (this.isToplevel() || isConstructor)
+    isConstructor ? line += `new ${functionName || "<anonymous>"}` : functionName ? line += functionName : (line += fileLocation, addSuffix = false);
+  else {
+    let typeName = this.getTypeName();
+    typeName === "[object Object]" && (typeName = "null");
+    const methodName = this.getMethodName();
+    functionName ? (typeName && functionName.indexOf(typeName) !== 0 && (line += `${typeName}.`), line += functionName, methodName && functionName.indexOf(`.${methodName}`) !== functionName.length - methodName.length - 1 && (line += ` [as ${methodName}]`)) : line += `${typeName}.${methodName || "<anonymous>"}`;
+  }
+  return addSuffix && (line += ` (${fileLocation})`), line;
+}
+function cloneCallSite(frame) {
+  const object = {};
+  return 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, object;
+}
+function wrapCallSite(frame, state) {
+  if (state === void 0 && (state = { nextPosition: null, curPosition: null }), frame.isNative())
+    return state.curPosition = null, frame;
+  const source = frame.getFileName() || frame.getScriptNameOrSourceURL();
+  if (source) {
+    const line = frame.getLineNumber();
+    let column = frame.getColumnNumber() - 1;
+    const headerLength = 62;
+    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;
+    return frame.getFunctionName = function() {
+      const name = state.nextPosition == null ? originalFunctionName() : 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;
+    }, frame;
+  }
+  let origin = frame.isEval() && frame.getEvalOrigin();
+  return origin && (origin = mapEvalOrigin(origin), frame = cloneCallSite(frame), frame.getEvalOrigin = function() {
+    return origin || void 0;
+  }), frame;
+}
+function prepareStackTrace(error, stack) {
+  const name = error.name || "Error", message = error.message || "", errorString = `${name}: ${message}`, state = { nextPosition: null, curPosition: null }, processedStack = [];
+  for (let i = stack.length - 1; i >= 0; i--)
+    processedStack.push(`
+    at ${wrapCallSite(stack[i], state)}`), state.nextPosition = state.curPosition;
+  return state.curPosition = state.nextPosition = null, errorString + processedStack.reverse().join("");
+}
+function enableSourceMapSupport(runner) {
+  if (runner.options.sourcemapInterceptor === "node") {
+    if (typeof process > "u")
+      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;
+    return process.setSourceMapsEnabled(true), () => !isEnabledAlready && process.setSourceMapsEnabled(false);
+  }
+  return interceptStackTrace(
+    runner,
+    typeof runner.options.sourcemapInterceptor == "object" ? runner.options.sourcemapInterceptor : void 0
+  );
+}
+var ESModulesEvaluator = class {
+  startOffset = getAsyncFunctionDeclarationPaddingLineCount();
+  async runInlinedModule(context, code) {
+    await new AsyncFunction(
+      ssrModuleExportsKey,
+      ssrImportMetaKey,
+      ssrImportKey,
+      ssrDynamicImportKey,
+      ssrExportAllKey,
+      // source map should already be inlined by Vite
+      '"use strict";' + code
+    )(
+      context[ssrModuleExportsKey],
+      context[ssrImportMetaKey],
+      context[ssrImportKey],
+      context[ssrDynamicImportKey],
+      context[ssrExportAllKey]
+    ), Object.seal(context[ssrModuleExportsKey]);
+  }
+  runExternalModule(filepath) {
+    return import(filepath);
+  }
+};
+var ModuleRunner = class {
+  constructor(options, evaluator = new ESModulesEvaluator(), debug) {
+    if (this.options = options, this.evaluator = evaluator, this.debug = debug, this.evaluatedModules = options.evaluatedModules ?? new EvaluatedModules(), this.transport = normalizeModuleRunnerTransport(options.transport), options.hmr !== false) {
+      const optionsHmr = options.hmr ?? true, resolvedHmrLogger = optionsHmr === true || optionsHmr.logger === void 0 ? hmrLogger : optionsHmr.logger === false ? silentConsole : optionsHmr.logger;
+      if (this.hmrClient = new HMRClient(
+        resolvedHmrLogger,
+        this.transport,
+        ({ acceptedPath }) => this.import(acceptedPath)
+      ), !this.transport.connect)
+        throw new Error(
+          "HMR is not supported by this runner transport, but `hmr` option was set to true"
+        );
+      this.transport.connect(createHMRHandler(this));
+    } else
+      this.transport.connect?.();
+    options.sourcemapInterceptor !== false && (this.resetSourceMapSupport = enableSourceMapSupport(this));
+  }
+  evaluatedModules;
+  hmrClient;
+  envProxy = new Proxy({}, {
+    get(_, p) {
+      throw new Error(
+        `[module runner] Dynamic access of "import.meta.env" is not supported. Please, use "import.meta.env.${String(p)}" instead.`
+      );
+    }
+  });
+  transport;
+  resetSourceMapSupport;
+  concurrentModuleNodePromises = /* @__PURE__ */ new Map();
+  closed = false;
+  /**
+   * URL to execute. Accepts file path, server path or id relative to the root.
+   */
+  async import(url) {
+    const fetchedModule = await this.cachedModule(url);
+    return await this.cachedRequest(url, fetchedModule);
+  }
+  /**
+   * Clear all caches including HMR listeners.
+   */
+  clearCache() {
+    this.evaluatedModules.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 close() {
+    this.resetSourceMapSupport?.(), this.clearCache(), this.hmrClient = void 0, this.closed = true, await this.transport.disconnect?.();
+  }
+  /**
+   * Returns `true` if the runtime has been closed by calling `close()` method.
+   */
+  isClosed() {
+    return this.closed;
+  }
+  processImport(exports, fetchResult, metadata) {
+    if (!("externalize" in fetchResult))
+      return exports;
+    const { url, type } = fetchResult;
+    return type !== "module" && type !== "commonjs" || analyzeImportedModDifference(exports, url, type, metadata), exports;
+  }
+  isCircularModule(mod) {
+    for (const importedFile of mod.imports)
+      if (mod.importers.has(importedFile))
+        return true;
+    return false;
+  }
+  isCircularImport(importers, moduleUrl, visited = /* @__PURE__ */ new Set()) {
+    for (const importer of importers) {
+      if (visited.has(importer))
+        continue;
+      if (visited.add(importer), importer === moduleUrl)
+        return true;
+      const mod = this.evaluatedModules.getModuleById(importer);
+      if (mod && mod.importers.size && this.isCircularImport(mod.importers, moduleUrl, visited))
+        return true;
+    }
+    return false;
+  }
+  async cachedRequest(url, mod, callstack = [], metadata) {
+    const meta = mod.meta, moduleId = meta.id, { importers } = mod, importee = callstack[callstack.length - 1];
+    if (importee && importers.add(importee), (callstack.includes(moduleId) || this.isCircularModule(mod) || this.isCircularImport(importers, moduleId)) && mod.exports)
+      return this.processImport(mod.exports, meta, metadata);
+    let debugTimer;
+    this.debug && (debugTimer = setTimeout(() => {
+      const getStack = () => `stack:
+${[...callstack, moduleId].reverse().map((p) => `  - ${p}`).join(`
+`)}`;
+      this.debug(
+        `[module runner] module ${moduleId} takes over 2s to load.
+${getStack()}`
+      );
+    }, 2e3));
+    try {
+      if (mod.promise)
+        return this.processImport(await mod.promise, meta, metadata);
+      const promise = this.directRequest(url, mod, callstack);
+      return mod.promise = promise, mod.evaluated = false, this.processImport(await promise, meta, metadata);
+    } finally {
+      mod.evaluated = true, debugTimer && clearTimeout(debugTimer);
+    }
+  }
+  async cachedModule(url, importer) {
+    let cached = this.concurrentModuleNodePromises.get(url);
+    if (cached)
+      this.debug?.("[module runner] using cached module info for", url);
+    else {
+      const cachedModule = this.evaluatedModules.getModuleByUrl(url);
+      cached = this.getModuleInformation(url, importer, cachedModule).finally(
+        () => {
+          this.concurrentModuleNodePromises.delete(url);
+        }
+      ), this.concurrentModuleNodePromises.set(url, cached);
+    }
+    return cached;
+  }
+  async getModuleInformation(url, importer, cachedModule) {
+    if (this.closed)
+      throw new Error("Vite module runner has been closed.");
+    this.debug?.("[module runner] fetching", url);
+    const isCached = !!(typeof cachedModule == "object" && cachedModule.meta), fetchedModule = (
+      // fast return for established externalized pattern
+      url.startsWith("data:") ? { externalize: url, type: "builtin" } : await this.transport.invoke("fetchModule", [
+        url,
+        importer,
+        {
+          cached: isCached,
+          startOffset: this.evaluator.startOffset
+        }
+      ])
+    );
+    if ("cache" in fetchedModule) {
+      if (!cachedModule || !cachedModule.meta)
+        throw new Error(
+          `Module "${url}" was mistakenly invalidated during fetch phase.`
+        );
+      return cachedModule;
+    }
+    const moduleId = "externalize" in fetchedModule ? fetchedModule.externalize : fetchedModule.id, moduleUrl = "url" in fetchedModule ? fetchedModule.url : url, module = this.evaluatedModules.ensureModule(moduleId, moduleUrl);
+    return "invalidate" in fetchedModule && fetchedModule.invalidate && this.evaluatedModules.invalidateModule(module), fetchedModule.url = moduleUrl, fetchedModule.id = moduleId, module.meta = fetchedModule, module;
+  }
+  // override is allowed, consider this a public API
+  async directRequest(url, mod, _callstack) {
+    const fetchResult = mod.meta, moduleId = fetchResult.id, callstack = [..._callstack, moduleId], request = async (dep, metadata) => {
+      const importer = "file" in fetchResult && fetchResult.file || moduleId, depMod = await this.cachedModule(dep, importer);
+      return depMod.importers.add(moduleId), mod.imports.add(depMod.id), this.cachedRequest(dep, depMod, callstack, metadata);
+    }, dynamicRequest = async (dep) => (dep = String(dep), dep[0] === "." && (dep = posixResolve(posixDirname(url), dep)), request(dep, { isDynamicImport: true }));
+    if ("externalize" in fetchResult) {
+      const { externalize } = fetchResult;
+      this.debug?.("[module runner] externalizing", externalize);
+      const exports2 = await this.evaluator.runExternalModule(externalize);
+      return mod.exports = exports2, exports2;
+    }
+    const { code, file } = fetchResult;
+    if (code == null) {
+      const importer = callstack[callstack.length - 2];
+      throw new Error(
+        `[module runner] Failed to load "${url}"${importer ? ` imported from ${importer}` : ""}`
+      );
+    }
+    const modulePath = cleanUrl(file || moduleId), href = posixPathToFileHref(modulePath), filename = modulePath, dirname2 = posixDirname(modulePath), meta = {
+      filename: isWindows ? toWindowsPath(filename) : filename,
+      dirname: isWindows ? toWindowsPath(dirname2) : dirname2,
+      url: href,
+      env: this.envProxy,
+      resolve(_id, _parent) {
+        throw new Error(
+          '[module runner] "import.meta.resolve" is not supported.'
+        );
+      },
+      // should be replaced during transformation
+      glob() {
+        throw new Error(
+          '[module runner] "import.meta.glob" is statically replaced during file transformation. Make sure to reference it by the full name.'
+        );
+      }
+    }, exports = /* @__PURE__ */ Object.create(null);
+    Object.defineProperty(exports, Symbol.toStringTag, {
+      value: "Module",
+      enumerable: false,
+      configurable: false
+    }), mod.exports = exports;
+    let hotContext;
+    this.hmrClient && Object.defineProperty(meta, "hot", {
+      enumerable: true,
+      get: () => {
+        if (!this.hmrClient)
+          throw new Error("[module runner] HMR client was closed.");
+        return this.debug?.("[module runner] creating hmr context for", mod.url), hotContext ||= new HMRContext(this.hmrClient, mod.url), hotContext;
+      },
+      set: (value) => {
+        hotContext = value;
+      }
+    });
+    const context = {
+      [ssrImportKey]: request,
+      [ssrDynamicImportKey]: dynamicRequest,
+      [ssrModuleExportsKey]: exports,
+      [ssrExportAllKey]: (obj) => exportAll(exports, obj),
+      [ssrImportMetaKey]: meta
+    };
+    return this.debug?.("[module runner] executing", href), await this.evaluator.runInlinedModule(context, code, mod), exports;
+  }
+};
+function exportAll(exports, sourceModule) {
+  if (exports !== sourceModule && !(isPrimitive(sourceModule) || Array.isArray(sourceModule) || sourceModule instanceof Promise)) {
+    for (const key in sourceModule)
+      if (key !== "default" && key !== "__esModule")
+        try {
+          Object.defineProperty(exports, key, {
+            enumerable: true,
+            configurable: true,
+            get: () => sourceModule[key]
+          });
+        } catch {
+        }
+  }
+}
+
+// src/runner-worker/module-runner.ts
+var moduleRunner;
+async function createModuleRunner(env, webSocket) {
+  if (moduleRunner) {
+    throw new Error("Runner already initialized");
+  }
+  const transport = createWebSocketModuleRunnerTransport({
+    createConnection() {
+      webSocket.accept();
+      return webSocket;
+    }
+  });
+  moduleRunner = new ModuleRunner(
+    {
+      root: env.__VITE_ROOT__,
+      sourcemapInterceptor: "prepareStackTrace",
+      transport: {
+        ...transport,
+        async invoke(data) {
+          const response = await env.__VITE_INVOKE_MODULE__.fetch(
+            new Request(UNKNOWN_HOST, {
+              method: "POST",
+              body: JSON.stringify(data)
+            })
+          );
+          if (!response.ok) {
+            throw new Error(await response.text());
+          }
+          const result = await response.json();
+          return result;
+        }
+      },
+      hmr: true
+    },
+    {
+      async runInlinedModule(context, transformed, module) {
+        if (module.file.includes("/node_modules") && !module.file.includes("/node_modules/.vite")) {
+          throw new Error(
+            `[Error] Trying to import non-prebundled module (only prebundled modules are allowed): ${module.id}
+
+(have you excluded the module via \`optimizeDeps.exclude\`?)`
+          );
+        }
+        const codeDefinition = `'use strict';async (${Object.keys(context).join(
+          ","
+        )})=>{{`;
+        const code = `${codeDefinition}${transformed}
+}}`;
+        try {
+          const fn = env.__VITE_UNSAFE_EVAL__.eval(code, module.id);
+          await fn(...Object.values(context));
+          Object.freeze(context.__vite_ssr_exports__);
+        } catch (e) {
+          console.error("error running", module.id);
+          console.error(e instanceof Error ? e.stack : e);
+          throw e;
+        }
+      },
+      async runExternalModule(filepath) {
+        if (filepath.includes("/node_modules") && !filepath.includes("/node_modules/.vite")) {
+          throw new Error(
+            `[Error] Trying to import non-prebundled module (only prebundled modules are allowed): ${filepath}
+
+(have you externalized the module via \`resolve.external\`?)`
+          );
+        }
+        filepath = filepath.replace(/^file:\/\//, "");
+        return import(filepath);
+      }
+    }
+  );
+}
+async function getWorkerEntryExport(path, entrypoint) {
+  const module = await moduleRunner.import(path);
+  const entrypointValue = typeof module === "object" && module !== null && entrypoint in module && module[entrypoint];
+  if (!entrypointValue) {
+    throw new Error(`${path} does not export a ${entrypoint} entrypoint.`);
+  }
+  return entrypointValue;
+}
+
+// src/runner-worker/index.ts
+var WORKER_ENTRYPOINT_KEYS = [
+  "fetch",
+  "tail",
+  "trace",
+  "scheduled",
+  "queue",
+  "test"
+];
+var DURABLE_OBJECT_KEYS = [
+  "fetch",
+  "alarm",
+  "webSocketMessage",
+  "webSocketClose",
+  "webSocketError"
+];
+var WORKFLOW_ENTRYPOINT_KEYS = ["run"];
+function getRpcProperty(ctor, instance, key) {
+  const prototypeHasKey = Reflect.has(ctor.prototype, key);
+  if (!prototypeHasKey) {
+    const instanceHasKey = Reflect.has(instance, key);
+    if (instanceHasKey) {
+      throw new TypeError(
+        [
+          `The RPC receiver's prototype does not implement '${key}', but the receiver instance does.`,
+          "Only properties and methods defined on the prototype can be accessed over RPC.",
+          `Ensure properties are declared as \`get ${key}() { ... }\` instead of \`${key} = ...\`,`,
+          `and methods are declared as \`${key}() { ... }\` instead of \`${key} = () => { ... }\`.`
+        ].join("\n")
+      );
+    }
+    throw new TypeError(`The RPC receiver does not implement '${key}'.`);
+  }
+  return Reflect.get(ctor.prototype, key, instance);
+}
+function getRpcPropertyCallableThenable(key, property) {
+  const fn = async function(...args) {
+    const maybeFn = await property;
+    if (typeof maybeFn !== "function") {
+      throw new TypeError(`'${key}' is not a function.`);
+    }
+    return maybeFn(...args);
+  };
+  fn.then = (onFulfilled, onRejected) => property.then(onFulfilled, onRejected);
+  fn.catch = (onRejected) => property.catch(onRejected);
+  fn.finally = (onFinally) => property.finally(onFinally);
+  return fn;
+}
+async function getWorkerEntrypointRpcProperty(entrypoint, key) {
+  const entryPath = this.env.__VITE_ENTRY_PATH__;
+  const ctor = await getWorkerEntryExport(
+    entryPath,
+    entrypoint
+  );
+  const userEnv = stripInternalEnv(this.env);
+  const expectedWorkerEntrypointMessage = `Expected ${entrypoint} export of ${entryPath} to be a subclass of \`WorkerEntrypoint\` for RPC.`;
+  if (typeof ctor !== "function") {
+    throw new TypeError(expectedWorkerEntrypointMessage);
+  }
+  const instance = new ctor(this.ctx, userEnv);
+  if (!(instance instanceof WorkerEntrypoint)) {
+    throw new TypeError(expectedWorkerEntrypointMessage);
+  }
+  const value = getRpcProperty(ctor, instance, key);
+  if (typeof value === "function") {
+    return value.bind(instance);
+  }
+  return value;
+}
+function createWorkerEntrypointWrapper(entrypoint) {
+  class Wrapper extends WorkerEntrypoint {
+    constructor(ctx, env) {
+      super(ctx, env);
+      return new Proxy(this, {
+        get(target, key, receiver) {
+          const value = Reflect.get(target, key, receiver);
+          if (value !== void 0) {
+            return value;
+          }
+          if (key === "self" || typeof key === "symbol" || DURABLE_OBJECT_KEYS.includes(key)) {
+            return;
+          }
+          const property = getWorkerEntrypointRpcProperty.call(
+            receiver,
+            entrypoint,
+            key
+          );
+          return getRpcPropertyCallableThenable(key, property);
+        }
+      });
+    }
+  }
+  for (const key of WORKER_ENTRYPOINT_KEYS) {
+    Wrapper.prototype[key] = async function(arg) {
+      const entryPath = this.env.__VITE_ENTRY_PATH__;
+      if (key === "fetch") {
+        const request = arg;
+        const url = new URL(request.url);
+        if (url.pathname === INIT_PATH) {
+          const { 0: client, 1: server } = new WebSocketPair();
+          createModuleRunner(this.env, server);
+          return new Response(null, { status: 101, webSocket: client });
+        }
+      }
+      const entrypointValue = await getWorkerEntryExport(entryPath, entrypoint);
+      const userEnv = stripInternalEnv(this.env);
+      if (typeof entrypointValue === "object" && entrypointValue !== null) {
+        const maybeFn = entrypointValue[key];
+        if (typeof maybeFn !== "function") {
+          throw new TypeError(
+            `Expected ${entrypoint} export of ${entryPath} to define a \`${key}()\` function.`
+          );
+        }
+        return maybeFn.call(entrypointValue, arg, userEnv, this.ctx);
+      } else if (typeof entrypointValue === "function") {
+        const ctor = entrypointValue;
+        const instance = new ctor(this.ctx, userEnv);
+        if (!(instance instanceof WorkerEntrypoint)) {
+          throw new TypeError(
+            `Expected ${entrypoint} export of ${entryPath} to be a subclass of \`WorkerEntrypoint\`.`
+          );
+        }
+        const maybeFn = instance[key];
+        if (typeof maybeFn !== "function") {
+          throw new TypeError(
+            `Expected ${entrypoint} export of ${entryPath} to define a \`${key}()\` method.`
+          );
+        }
+        return maybeFn.call(instance, arg);
+      } else {
+        return new TypeError(
+          `Expected ${entrypoint} export of ${entryPath} to be an object or a class. Got ${entrypointValue}.`
+        );
+      }
+    };
+  }
+  return Wrapper;
+}
+var kInstance = Symbol("kInstance");
+var kEnsureInstance = Symbol("kEnsureInstance");
+async function getDurableObjectRpcProperty(className, key) {
+  const entryPath = this.env.__VITE_ENTRY_PATH__;
+  const { ctor, instance } = await this[kEnsureInstance]();
+  if (!(instance instanceof DurableObject)) {
+    throw new TypeError(
+      `Expected ${className} export of ${entryPath} to be a subclass of \`DurableObject\` for RPC.`
+    );
+  }
+  const value = getRpcProperty(ctor, instance, key);
+  if (typeof value === "function") {
+    return value.bind(instance);
+  }
+  return value;
+}
+function createDurableObjectWrapper(className) {
+  class Wrapper extends DurableObject {
+    [kInstance];
+    constructor(ctx, env) {
+      super(ctx, env);
+      return new Proxy(this, {
+        get(target, key, receiver) {
+          const value = Reflect.get(target, key, receiver);
+          if (value !== void 0) {
+            return value;
+          }
+          if (key === "self" || typeof key === "symbol" || WORKER_ENTRYPOINT_KEYS.includes(key)) {
+            return;
+          }
+          const property = getDurableObjectRpcProperty.call(
+            receiver,
+            className,
+            key
+          );
+          return getRpcPropertyCallableThenable(key, property);
+        }
+      });
+    }
+    async [kEnsureInstance]() {
+      const entryPath = this.env.__VITE_ENTRY_PATH__;
+      const ctor = await getWorkerEntryExport(
+        entryPath,
+        className
+      );
+      if (typeof ctor !== "function") {
+        throw new TypeError(
+          `${entryPath} does not export a ${className} Durable Object.`
+        );
+      }
+      if (!this[kInstance] || this[kInstance].ctor !== ctor) {
+        const userEnv = stripInternalEnv(this.env);
+        const instance = new ctor(this.ctx, userEnv);
+        this[kInstance] = { ctor, instance };
+        await this.ctx.blockConcurrencyWhile(async () => {
+        });
+      }
+      return this[kInstance];
+    }
+  }
+  for (const key of DURABLE_OBJECT_KEYS) {
+    Wrapper.prototype[key] = async function(...args) {
+      const entryPath = this.env.__VITE_ENTRY_PATH__;
+      const { instance } = await this[kEnsureInstance]();
+      const maybeFn = instance[key];
+      if (typeof maybeFn !== "function") {
+        throw new TypeError(
+          `Expected ${className} export of ${entryPath} to define a \`${key}()\` function.`
+        );
+      }
+      return maybeFn.apply(instance, args);
+    };
+  }
+  return Wrapper;
+}
+function createWorkflowEntrypointWrapper(className) {
+  class Wrapper extends WorkflowEntrypoint {
+  }
+  for (const key of WORKFLOW_ENTRYPOINT_KEYS) {
+    Wrapper.prototype[key] = async function(...args) {
+      const entryPath = this.env.__VITE_ENTRY_PATH__;
+      const ctor = await getWorkerEntryExport(
+        entryPath,
+        className
+      );
+      const userEnv = stripInternalEnv(this.env);
+      const instance = new ctor(this.ctx, userEnv);
+      if (!(instance instanceof WorkflowEntrypoint)) {
+        throw new TypeError(
+          `Expected ${className} export of ${entryPath} to be a subclass of \`WorkflowEntrypoint\`.`
+        );
+      }
+      const maybeFn = instance[key];
+      if (typeof maybeFn !== "function") {
+        throw new TypeError(
+          `Expected ${className} export of ${entryPath} to define a \`${key}()\` function.`
+        );
+      }
+      return maybeFn.apply(instance, args);
+    };
+  }
+  return Wrapper;
+}
+export {
+  createDurableObjectWrapper,
+  createWorkerEntrypointWrapper,
+  createWorkflowEntrypointWrapper
+};