@vxrn/vite-native-client 0.0.7 → 0.1.0

package/dist/cjs/client.native.js

@@ -1,224 +1,635 @@
 "use strict";
-console.log("[vite] connecting...");
-const importMetaUrl = {
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod2);
+var client_exports = {};
+module.exports = __toCommonJS(client_exports);
+function _array_like_to_array(arr, len) {
+  (len == null || len > arr.length) && (len = arr.length);
+  for (var i = 0, arr2 = new Array(len); i < len; i++)
+    arr2[i] = arr[i];
+  return arr2;
+}
+function _array_with_holes(arr) {
+  if (Array.isArray(arr))
+    return arr;
+}
+function _array_without_holes(arr) {
+  if (Array.isArray(arr))
+    return _array_like_to_array(arr);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg), value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+  info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+  return function() {
+    var self = this, args = arguments;
+    return new Promise(function(resolve, reject) {
+      var gen = fn.apply(self, args);
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+      _next(void 0);
+    });
+  };
+}
+function _iterable_to_array(iter) {
+  if (typeof Symbol < "u" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
+    return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+  var _i = arr == null ? null : typeof Symbol < "u" && arr[Symbol.iterator] || arr["@@iterator"];
+  if (_i != null) {
+    var _arr = [], _n = !0, _d = !1, _s, _e;
+    try {
+      for (_i = _i.call(arr); !(_n = (_s = _i.next()).done) && (_arr.push(_s.value), !(i && _arr.length === i)); _n = !0)
+        ;
+    } catch (err) {
+      _d = !0, _e = err;
+    } finally {
+      try {
+        !_n && _i.return != null && _i.return();
+      } finally {
+        if (_d)
+          throw _e;
+      }
+    }
+    return _arr;
+  }
+}
+function _non_iterable_rest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+  return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+  return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+  if (o) {
+    if (typeof o == "string")
+      return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor && (n = o.constructor.name), n === "Map" || n === "Set")
+      return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+      return _array_like_to_array(o, minLen);
+  }
+}
+function _ts_generator(thisArg, body) {
+  var f, y, t, g, _ = {
+    label: 0,
+    sent: function() {
+      if (t[0] & 1)
+        throw t[1];
+      return t[1];
+    },
+    trys: [],
+    ops: []
+  };
+  return g = {
+    next: verb(0),
+    throw: verb(1),
+    return: verb(2)
+  }, typeof Symbol == "function" && (g[Symbol.iterator] = function() {
+    return this;
+  }), g;
+  function verb(n) {
+    return function(v) {
+      return step([
+        n,
+        v
+      ]);
+    };
+  }
+  function step(op) {
+    if (f)
+      throw new TypeError("Generator is already executing.");
+    for (; _; )
+      try {
+        if (f = 1, y && (t = op[0] & 2 ? y.return : op[0] ? y.throw || ((t = y.return) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+          return t;
+        switch (y = 0, t && (op = [
+          op[0] & 2,
+          t.value
+        ]), op[0]) {
+          case 0:
+          case 1:
+            t = op;
+            break;
+          case 4:
+            return _.label++, {
+              value: op[1],
+              done: !1
+            };
+          case 5:
+            _.label++, y = op[1], op = [
+              0
+            ];
+            continue;
+          case 7:
+            op = _.ops.pop(), _.trys.pop();
+            continue;
+          default:
+            if (t = _.trys, !(t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+              _ = 0;
+              continue;
+            }
+            if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+              _.label = op[1];
+              break;
+            }
+            if (op[0] === 6 && _.label < t[1]) {
+              _.label = t[1], t = op;
+              break;
+            }
+            if (t && _.label < t[2]) {
+              _.label = t[2], _.ops.push(op);
+              break;
+            }
+            t[2] && _.ops.pop(), _.trys.pop();
+            continue;
+        }
+        op = body.call(thisArg, _);
+      } catch (e2) {
+        op = [
+          6,
+          e2
+        ], y = 0;
+      } finally {
+        f = t = 0;
+      }
+    if (op[0] & 5)
+      throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: !0
+    };
+  }
+}
+console.info("[vite] connecting...");
+var importMetaUrl = {
   hostname: "127.0.0.1",
   protocol: "http",
   port: 5173
-}, serverHost = __SERVER_HOST__, socketProtocol = __HMR_PROTOCOL__ || (importMetaUrl.protocol === "https:" ? "wss" : "ws"), hmrPort = __HMR_PORT__ || 5173, socketHost = `${__HMR_HOSTNAME__ || importMetaUrl.hostname}:${hmrPort || importMetaUrl.port}${__HMR_BASE__}`, directSocketHost = __HMR_DIRECT_TARGET__, base = __BASE__ || "/", messageBuffer = [];
-let socket;
+}, serverHost = __SERVER_HOST__, socketProtocol = __HMR_PROTOCOL__ || (importMetaUrl.protocol === "https:" ? "wss" : "ws"), hmrPort = __HMR_PORT__ || 5173, socketHost = "".concat(__HMR_HOSTNAME__ || importMetaUrl.hostname, ":").concat(hmrPort || importMetaUrl.port).concat(__HMR_BASE__), directSocketHost = __HMR_DIRECT_TARGET__, base = __BASE__ || "/", messageBuffer = [], socket;
 try {
-  let fallback;
-  hmrPort || (fallback = () => {
-    socket = setupWebSocket(socketProtocol, directSocketHost, () => {
-      console.error(
-        `[vite] failed to connect to websocket.
+  var fallback;
+  hmrPort || (fallback = function() {
+    socket = setupWebSocket(socketProtocol, directSocketHost, function() {
+      console.error(`[vite] failed to connect to websocket.
 your current setup:
-  (browser) ${JSON.stringify(
-          importMetaUrl
-        )} <--[HTTP]--> ${serverHost} (server)
-  (browser) ${socketHost} <--[WebSocket (failing)]--> ${directSocketHost} (server)
-Check out your Vite / network configuration and https://vitejs.dev/config/server-options.html#server-hmr .`
-      );
-    }), socket.addEventListener(
-      "open",
-      () => {
-        console.log(
-          "[vite] Direct websocket connection fallback. Check out https://vitejs.dev/config/server-options.html#server-hmr to remove the previous connection error."
-        );
-      },
-      { once: !0 }
-    );
+` + "  (browser) ".concat(JSON.stringify(importMetaUrl), " <--[HTTP]--> ").concat(serverHost, ` (server)
+`) + "  (browser) ".concat(socketHost, " <--[WebSocket (failing)]--> ").concat(directSocketHost, ` (server)
+`) + "Check out your Vite / network configuration and https://vitejs.dev/config/server-options.html#server-hmr .");
+    }), socket.addEventListener("open", function() {
+      console.info("[vite] Direct websocket connection fallback. Check out https://vitejs.dev/config/server-options.html#server-hmr to remove the previous connection error.");
+    }, {
+      once: !0
+    });
   }), socket = setupWebSocket(socketProtocol, socketHost, fallback);
 } catch (error) {
-  console.error(`[vite] failed to connect to websocket (${error}). `);
+  console.error("[vite] failed to connect to websocket (".concat(error, "). "));
 }
 function setupWebSocket(protocol, hostAndPath, onCloseWithoutOpen) {
-  const endpoint = `${protocol}://${hostAndPath}`, socket2 = new WebSocket(endpoint, "vite-hmr");
-  let isOpened = !1;
-  return socket2.addEventListener(
-    "open",
-    () => {
-      isOpened = !0, notifyListeners("vite:ws:connect", { webSocket: socket2 });
-    },
-    { once: !0 }
-  ), socket2.addEventListener("message", ({ data }) => {
-    console.log("\u{1F336}\uFE0F" + data), handleMessage(JSON.parse(data));
-  }), socket2.addEventListener("error", (err) => {
-    console.log("err" + err.message + err.stack);
-  }), socket2.addEventListener("close", ({ wasClean }) => {
+  var endpoint = "".concat(protocol, "://").concat(hostAndPath), socket1 = new WebSocket(endpoint, "vite-hmr"), isOpened = !1;
+  return socket1.addEventListener("open", function() {
+    isOpened = !0, notifyListeners("vite:ws:connect", {
+      webSocket: socket1
+    });
+  }, {
+    once: !0
+  }), socket1.addEventListener("message", function(param2) {
+    var data = param2.data;
+    console.info("\u{1F336}\uFE0F" + data), handleMessage(JSON.parse(data));
+  }), socket1.addEventListener("error", function(err) {
+    console.info("err" + err.message + err.stack);
+  }), socket1.addEventListener("close", function(param2) {
+    var wasClean = param2.wasClean;
     if (!wasClean) {
       if (!isOpened && onCloseWithoutOpen) {
         onCloseWithoutOpen();
         return;
       }
-      notifyListeners("vite:ws:disconnect", { webSocket: socket2 }), console.log("[vite] server connection lost. polling for restart..."), waitForSuccessfulPing(protocol, hostAndPath).then(() => {
-        console.log("shuld reload");
+      notifyListeners("vite:ws:disconnect", {
+        webSocket: socket1
+      }), console.info("[vite] server connection lost. polling for restart..."), waitForSuccessfulPing(protocol, hostAndPath).then(function() {
+        console.info("should reload");
       });
     }
-  }), socket2;
+  }), socket1;
 }
 function warnFailedFetch(err, path2) {
-  console.error(`${err}`), console.error(
-    `[hmr] Failed to reload ${path2}. This could be due to syntax errors or importing non-existent modules. (see errors above)`
-  );
+  console.error("".concat(err)), console.error("[hmr] Failed to reload ".concat(path2, ". ") + "This could be due to syntax errors or importing non-existent modules. (see errors above)");
 }
-let isFirstUpdate = !0;
-const debounceReload = (time) => {
-  let timer;
-  return () => {
-    timer && (clearTimeout(timer), timer = null), timer = setTimeout(() => {
+var isFirstUpdate = !0, debounceReload = function(time) {
+  var timer;
+  return function() {
+    timer && (clearTimeout(timer), timer = null), timer = setTimeout(function() {
       location.reload();
     }, time);
   };
 }, pageReload = debounceReload(50);
-async function handleMessage(payload) {
-  switch (payload.type) {
-    case "connected":
-      console.log("[vite] connected."), sendMessageBuffer(), setInterval(() => {
-        socket.readyState === socket.OPEN && socket.send('{"type":"ping"}');
-      }, __HMR_TIMEOUT__);
-      break;
-    case "update":
-      if (notifyListeners("vite:beforeUpdate", payload), isFirstUpdate && hasErrorOverlay())
-        return;
-      isFirstUpdate = !1, await Promise.all(
-        payload.updates.map((update) => {
-          if (update.type === "js-update")
-            return queueUpdate(fetchUpdate(update));
-        })
-      ), notifyListeners("vite:afterUpdate", payload);
-      break;
-    case "custom": {
-      notifyListeners(payload.event, payload.data);
-      break;
-    }
-    case "full-reload":
-      if (notifyListeners("vite:beforeFullReload", payload), payload.path && payload.path.endsWith(".html")) {
-        const pagePath = decodeURI(location.pathname), payloadPath = base + payload.path.slice(1);
-        (pagePath === payloadPath || payload.path === "/index.html" || pagePath.endsWith("/") && pagePath + "index.html" === payloadPath) && pageReload();
-        return;
-      } else
-        pageReload();
-      break;
-    case "prune":
-      notifyListeners("vite:beforePrune", payload), payload.paths.forEach((path2) => {
-        const fn = pruneMap.get(path2);
-        fn && fn(dataMap.get(path2));
-      });
-      break;
-    case "error": {
-      notifyListeners("vite:error", payload);
-      const err = payload.err;
-      enableOverlay ? createErrorOverlay(err) : console.error(`[vite] Internal Server Error
-${err.message}
-${err.stack}`);
-      break;
-    }
-    default:
-      return payload;
-  }
+function handleMessage(payload) {
+  return _handleMessage.apply(this, arguments);
+}
+function _handleMessage() {
+  return _handleMessage = _async_to_generator(function(payload) {
+    var _, pagePath, payloadPath, err, check;
+    return _ts_generator(this, function(_state2) {
+      switch (_state2.label) {
+        case 0:
+          switch (_ = payload.type, _) {
+            case "connected":
+              return [
+                3,
+                1
+              ];
+            case "update":
+              return [
+                3,
+                2
+              ];
+            case "custom":
+              return [
+                3,
+                4
+              ];
+            case "full-reload":
+              return [
+                3,
+                5
+              ];
+            case "prune":
+              return [
+                3,
+                6
+              ];
+            case "error":
+              return [
+                3,
+                7
+              ];
+          }
+          return [
+            3,
+            8
+          ];
+        case 1:
+          return console.info("[vite] connected."), sendMessageBuffer(), setInterval(function() {
+            socket.readyState === socket.OPEN && socket.send('{"type":"ping"}');
+          }, __HMR_TIMEOUT__), [
+            3,
+            9
+          ];
+        case 2:
+          return notifyListeners("vite:beforeUpdate", payload), isFirstUpdate && hasErrorOverlay() ? [
+            2
+          ] : (isFirstUpdate = !1, [
+            4,
+            Promise.all(payload.updates.map(function(update) {
+              if (update.type === "js-update")
+                return queueUpdate(fetchUpdate(update));
+            }))
+          ]);
+        case 3:
+          return _state2.sent(), notifyListeners("vite:afterUpdate", payload), [
+            3,
+            9
+          ];
+        case 4:
+          return notifyListeners(payload.event, payload.data), [
+            3,
+            9
+          ];
+        case 5:
+          return notifyListeners("vite:beforeFullReload", payload), payload.path && payload.path.endsWith(".html") ? (pagePath = decodeURI(location.pathname), payloadPath = base + payload.path.slice(1), (pagePath === payloadPath || payload.path === "/index.html" || pagePath.endsWith("/") && pagePath + "index.html" === payloadPath) && pageReload(), [
+            2
+          ]) : (pageReload(), [
+            3,
+            9
+          ]);
+        case 6:
+          return notifyListeners("vite:beforePrune", payload), payload.paths.forEach(function(path2) {
+            var fn = pruneMap.get(path2);
+            fn && fn(dataMap.get(path2));
+          }), [
+            3,
+            9
+          ];
+        case 7:
+          return notifyListeners("vite:error", payload), err = payload.err, enableOverlay ? createErrorOverlay(err) : console.error(`[vite] Internal Server Error
+`.concat(err.message, `
+`).concat(err.stack)), [
+            3,
+            9
+          ];
+        case 8:
+          return check = payload, [
+            2,
+            check
+          ];
+        case 9:
+          return [
+            2
+          ];
+      }
+    });
+  }), _handleMessage.apply(this, arguments);
 }
 function notifyListeners(event, data) {
-  const cbs = customListenersMap.get(event);
-  cbs && cbs.forEach((cb) => cb(data));
+  var cbs = customListenersMap.get(event);
+  cbs && cbs.forEach(function(cb) {
+    return cb(data);
+  });
 }
-const enableOverlay = __HMR_ENABLE_OVERLAY__;
+var enableOverlay = __HMR_ENABLE_OVERLAY__;
 function createErrorOverlay(err) {
-  enableOverlay && console.log("create error", err);
+  enableOverlay && console.error("create error", err);
 }
 function clearErrorOverlay() {
 }
 function hasErrorOverlay() {
   return !1;
 }
-let pending = !1, queued = [];
-async function queueUpdate(p) {
-  if (queued.push(p), !pending) {
-    pending = !0, await Promise.resolve(), pending = !1;
-    const loading = [...queued];
-    queued = [], (await Promise.all(loading)).forEach((fn) => fn && fn());
-  }
+var pending = !1, queued = [];
+function queueUpdate(p) {
+  return _queueUpdate.apply(this, arguments);
 }
-async function waitForSuccessfulPing(socketProtocol2, hostAndPath, ms = 1e3) {
-  const pingHostProtocol = socketProtocol2 === "wss" ? "https" : "http", ping = async () => {
-    try {
-      return await fetch(`${pingHostProtocol}://${hostAndPath}`, {
-        mode: "no-cors",
-        headers: {
-          // Custom headers won't be included in a request with no-cors so (ab)use one of the
-          // safelisted headers to identify the ping request
-          Accept: "text/x-vite-ping"
-        }
-      }), !0;
-    } catch {
-    }
-    return !1;
-  };
-  if (!await ping())
-    for (await wait(ms); !await ping(); )
-      await wait(ms);
+function _queueUpdate() {
+  return _queueUpdate = /**
+  * 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_to_generator(function(p) {
+    var loading;
+    return _ts_generator(this, function(_state2) {
+      switch (_state2.label) {
+        case 0:
+          return queued.push(p), pending ? [
+            3,
+            3
+          ] : (pending = !0, [
+            4,
+            Promise.resolve()
+          ]);
+        case 1:
+          return _state2.sent(), pending = !1, loading = _to_consumable_array(queued), queued = [], [
+            4,
+            Promise.all(loading)
+          ];
+        case 2:
+          _state2.sent().forEach(function(fn) {
+            return fn && fn();
+          }), _state2.label = 3;
+        case 3:
+          return [
+            2
+          ];
+      }
+    });
+  }), _queueUpdate.apply(this, arguments);
+}
+function waitForSuccessfulPing(socketProtocol1, hostAndPath) {
+  return _waitForSuccessfulPing.apply(this, arguments);
+}
+function _waitForSuccessfulPing() {
+  return _waitForSuccessfulPing = _async_to_generator(function(socketProtocol1, hostAndPath) {
+    var ms, pingHostProtocol, ping, _arguments = arguments;
+    return _ts_generator(this, function(_state2) {
+      switch (_state2.label) {
+        case 0:
+          return ms = _arguments.length > 2 && _arguments[2] !== void 0 ? _arguments[2] : 1e3, pingHostProtocol = socketProtocol1 === "wss" ? "https" : "http", ping = function() {
+            var _ref = _async_to_generator(function() {
+              var e2;
+              return _ts_generator(this, function(_state3) {
+                switch (_state3.label) {
+                  case 0:
+                    return _state3.trys.push([
+                      0,
+                      2,
+                      ,
+                      3
+                    ]), [
+                      4,
+                      fetch("".concat(pingHostProtocol, "://").concat(hostAndPath), {
+                        mode: "no-cors",
+                        headers: {
+                          // Custom headers won't be included in a request with no-cors so (ab)use one of the
+                          // safelisted headers to identify the ping request
+                          Accept: "text/x-vite-ping"
+                        }
+                      })
+                    ];
+                  case 1:
+                    return _state3.sent(), [
+                      2,
+                      !0
+                    ];
+                  case 2:
+                    return e2 = _state3.sent(), [
+                      3,
+                      3
+                    ];
+                  case 3:
+                    return [
+                      2,
+                      !1
+                    ];
+                }
+              });
+            });
+            return function() {
+              return _ref.apply(this, arguments);
+            };
+          }(), [
+            4,
+            ping()
+          ];
+        case 1:
+          return _state2.sent() ? [
+            2
+          ] : [
+            4,
+            wait(ms)
+          ];
+        case 2:
+          _state2.sent(), _state2.label = 3;
+        case 3:
+          return [
+            4,
+            ping()
+          ];
+        case 4:
+          return _state2.sent() ? [
+            3,
+            6
+          ] : [
+            4,
+            wait(ms)
+          ];
+        case 5:
+          return _state2.sent(), [
+            3,
+            3
+          ];
+        case 6:
+          return [
+            2
+          ];
+      }
+    });
+  }), _waitForSuccessfulPing.apply(this, arguments);
 }
 function wait(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise(function(resolve) {
+    return setTimeout(resolve, ms);
+  });
 }
-async function fetchUpdate({
-  path,
-  acceptedPath,
-  timestamp,
-  explicitImportRequired
-}) {
-  const mod = 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 = disposeMap.get(acceptedPath);
-    disposer && await disposer(dataMap.get(acceptedPath));
-    const [acceptedPathWithoutQuery, query] = acceptedPath.split("?");
-    try {
-      const filePath = acceptedPathWithoutQuery, finalQuery = `file?file=${encodeURIComponent(filePath)}&${explicitImportRequired ? "import&" : ""}t=${timestamp}${query ? `&${query}` : ""}`, scriptUrl = (
-        // re-route to our cjs endpoint
-        `http://${serverHost.replace("5173", "8081")}` + finalQuery
-      );
-      console.log(`fetching update: ${JSON.stringify({ path, mod, scriptUrl })}`);
-      const source = await fetch(scriptUrl).then((res) => res.text()), evaluatedModule = eval(source);
-      fetchedModule = evaluatedModule;
-    } catch (e) {
-      warnFailedFetch(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}`;
-    console.log(`[vite] hot updated: ${loggedPath}`);
-  };
+function fetchUpdate(_) {
+  return _fetchUpdate.apply(this, arguments);
+}
+function _fetchUpdate() {
+  return _fetchUpdate = _async_to_generator(function(param) {
+    var path, acceptedPath, timestamp, explicitImportRequired, mod, fetchedModule, isSelfUpdate, qualifiedCallbacks, disposer, _acceptedPath_split, acceptedPathWithoutQuery, query, filePath, finalQuery, scriptUrl, source, evaluatedModule, e;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return path = param.path, acceptedPath = param.acceptedPath, timestamp = param.timestamp, explicitImportRequired = param.explicitImportRequired, mod = hotModulesMap.get(path), mod ? (isSelfUpdate = path === acceptedPath, qualifiedCallbacks = mod.callbacks.filter(function(param2) {
+            var deps = param2.deps;
+            return deps.includes(acceptedPath);
+          }), isSelfUpdate || qualifiedCallbacks.length > 0 ? (disposer = disposeMap.get(acceptedPath), disposer ? [
+            4,
+            disposer(dataMap.get(acceptedPath))
+          ] : [
+            3,
+            2
+          ]) : [
+            3,
+            6
+          ]) : [
+            2
+          ];
+        case 1:
+          _state.sent(), _state.label = 2;
+        case 2:
+          _acceptedPath_split = _sliced_to_array(acceptedPath.split("?"), 2), acceptedPathWithoutQuery = _acceptedPath_split[0], query = _acceptedPath_split[1], _state.label = 3;
+        case 3:
+          return _state.trys.push([
+            3,
+            5,
+            ,
+            6
+          ]), filePath = acceptedPathWithoutQuery, finalQuery = "file?file=".concat(encodeURIComponent(filePath), "&").concat(explicitImportRequired ? "import&" : "", "t=").concat(timestamp).concat(query ? "&".concat(query) : ""), scriptUrl = // re-route to our cjs endpoint
+          "http://".concat(serverHost.replace("5173", "8081")) + finalQuery, console.info("fetching update: ".concat(JSON.stringify({
+            path,
+            mod,
+            scriptUrl
+          }))), [
+            4,
+            fetch(scriptUrl).then(function(res) {
+              return res.text();
+            })
+          ];
+        case 4:
+          return source = _state.sent(), evaluatedModule = eval(source), fetchedModule = evaluatedModule, [
+            3,
+            6
+          ];
+        case 5:
+          return e = _state.sent(), warnFailedFetch(e, acceptedPath), [
+            3,
+            6
+          ];
+        case 6:
+          return [
+            2,
+            function() {
+              var _iteratorNormalCompletion = !0, _didIteratorError = !1, _iteratorError = void 0;
+              try {
+                for (var _iterator = qualifiedCallbacks[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
+                  var _step_value = _step.value, deps = _step_value.deps, fn = _step_value.fn;
+                  fn(deps.map(function(dep) {
+                    return dep === acceptedPath ? fetchedModule : void 0;
+                  }));
+                }
+              } catch (err) {
+                _didIteratorError = !0, _iteratorError = err;
+              } finally {
+                try {
+                  !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+                } finally {
+                  if (_didIteratorError)
+                    throw _iteratorError;
+                }
+              }
+              var loggedPath = isSelfUpdate ? path : "".concat(acceptedPath, " via ").concat(path);
+              console.info("[vite] hot updated: ".concat(loggedPath));
+            }
+          ];
+      }
+    });
+  }), _fetchUpdate.apply(this, arguments);
 }
 function sendMessageBuffer() {
-  socket.readyState === 1 && (messageBuffer.forEach((msg) => socket.send(msg)), messageBuffer.length = 0);
+  socket.readyState === 1 && (messageBuffer.forEach(function(msg) {
+    return socket.send(msg);
+  }), messageBuffer.length = 0);
 }
-const hotModulesMap = /* @__PURE__ */ new Map(), disposeMap = /* @__PURE__ */ new Map(), pruneMap = /* @__PURE__ */ new Map(), dataMap = /* @__PURE__ */ new Map(), customListenersMap = /* @__PURE__ */ new Map(), ctxToListenersMap = /* @__PURE__ */ new Map();
+var hotModulesMap = /* @__PURE__ */ new Map(), disposeMap = /* @__PURE__ */ new Map(), pruneMap = /* @__PURE__ */ new Map(), dataMap = /* @__PURE__ */ new Map(), customListenersMap = /* @__PURE__ */ new Map(), ctxToListenersMap = /* @__PURE__ */ new Map();
 globalThis.createHotContext = function createHotContext(ownerPath) {
   dataMap.has(ownerPath) || dataMap.set(ownerPath, {});
-  const mod2 = hotModulesMap.get(ownerPath);
+  var mod2 = hotModulesMap.get(ownerPath);
   mod2 && (mod2.callbacks = []);
-  const staleListeners = ctxToListenersMap.get(ownerPath);
-  if (staleListeners)
-    for (const [event, staleFns] of staleListeners) {
-      const listeners = customListenersMap.get(event);
-      listeners && customListenersMap.set(
-        event,
-        listeners.filter((l) => !staleFns.includes(l))
-      );
+  var staleListeners = ctxToListenersMap.get(ownerPath);
+  if (staleListeners) {
+    var _iteratorNormalCompletion = !0, _didIteratorError = !1, _iteratorError = void 0;
+    try {
+      for (var _loop = function() {
+        var _step_value = _sliced_to_array(_step.value, 2), event = _step_value[0], staleFns = _step_value[1], listeners = customListenersMap.get(event);
+        listeners && customListenersMap.set(event, listeners.filter(function(l) {
+          return !staleFns.includes(l);
+        }));
+      }, _iterator = staleListeners[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0)
+        _loop();
+    } catch (err) {
+      _didIteratorError = !0, _iteratorError = err;
+    } finally {
+      try {
+        !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+      } finally {
+        if (_didIteratorError)
+          throw _iteratorError;
+      }
     }
-  const newListeners = /* @__PURE__ */ new Map();
+  }
+  var newListeners = /* @__PURE__ */ new Map();
   ctxToListenersMap.set(ownerPath, newListeners);
-  function acceptDeps(deps, callback = () => {
-  }) {
-    const mod3 = hotModulesMap.get(ownerPath) || {
+  function acceptDeps(deps) {
+    var callback = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : function() {
+    }, mod3 = hotModulesMap.get(ownerPath) || {
       id: ownerPath,
       callbacks: []
     };
@@ -227,15 +638,25 @@ globalThis.createHotContext = function createHotContext(ownerPath) {
       fn: callback
     }), hotModulesMap.set(ownerPath, mod3);
   }
-  return {
+  var hot = {
     get data() {
       return dataMap.get(ownerPath);
     },
-    accept(deps, callback) {
+    accept: function(deps, callback) {
       if (typeof deps == "function" || !deps)
-        acceptDeps([ownerPath], ([mod3]) => deps == null ? void 0 : deps(mod3));
+        acceptDeps([
+          ownerPath
+        ], function(param2) {
+          var _param = _sliced_to_array(param2, 1), mod3 = _param[0];
+          return deps == null ? void 0 : deps(mod3);
+        });
       else if (typeof deps == "string")
-        acceptDeps([deps], ([mod3]) => callback == null ? void 0 : callback(mod3));
+        acceptDeps([
+          deps
+        ], function(param2) {
+          var _param = _sliced_to_array(param2, 1), mod3 = _param[0];
+          return callback == null ? void 0 : callback(mod3);
+        });
       else if (Array.isArray(deps))
         acceptDeps(deps, callback);
       else
@@ -243,35 +664,51 @@ globalThis.createHotContext = function createHotContext(ownerPath) {
     },
     // export names (first arg) are irrelevant on the client side, they're
     // extracted in the server for propagation
-    acceptExports(_, callback) {
-      acceptDeps([ownerPath], ([mod3]) => callback == null ? void 0 : callback(mod3));
+    acceptExports: function(_, callback) {
+      acceptDeps([
+        ownerPath
+      ], function(param2) {
+        var _param = _sliced_to_array(param2, 1), mod3 = _param[0];
+        return callback == null ? void 0 : callback(mod3);
+      });
     },
-    dispose(cb) {
+    dispose: function(cb) {
       disposeMap.set(ownerPath, cb);
     },
-    prune(cb) {
+    prune: function(cb) {
       pruneMap.set(ownerPath, cb);
     },
     // Kept for backward compatibility (#11036)
     // @ts-expect-error untyped
     // eslint-disable-next-line @typescript-eslint/no-empty-function
-    decline() {
+    decline: function() {
     },
     // tell the server to re-perform hmr propagation from this module as root
-    invalidate(message) {
-      notifyListeners("vite:invalidate", { path: ownerPath, message }), this.send("vite:invalidate", { path: ownerPath, message }), console.log(`[vite] invalidate ${ownerPath}${message ? `: ${message}` : ""}`);
+    invalidate: function(message) {
+      notifyListeners("vite:invalidate", {
+        path: ownerPath,
+        message
+      }), this.send("vite:invalidate", {
+        path: ownerPath,
+        message
+      }), console.info("[vite] invalidate ".concat(ownerPath).concat(message ? ": ".concat(message) : ""));
     },
     // custom events
-    on(event, cb) {
-      const addToMap = (map) => {
-        const existing = map.get(event) || [];
+    on: function(event, cb) {
+      var addToMap = function(map) {
+        var existing = map.get(event) || [];
         existing.push(cb), map.set(event, existing);
       };
       addToMap(customListenersMap), addToMap(newListeners);
     },
-    send(event, data) {
-      messageBuffer.push(JSON.stringify({ type: "custom", event, data })), sendMessageBuffer();
+    send: function(event, data) {
+      messageBuffer.push(JSON.stringify({
+        type: "custom",
+        event,
+        data
+      })), sendMessageBuffer();
     }
   };
+  return hot;
 };
 //# sourceMappingURL=client.js.map