UEA-Prodem

node_modules/@hono/vite-dev-server/dist/adapter/bun.cjs

@@ -0,0 +1,44 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bun_exports = {};
+__export(bun_exports, {
+  bunAdapter: () => bunAdapter,
+  default: () => bun_default
+});
+module.exports = __toCommonJS(bun_exports);
+const bunAdapter = () => {
+  if (typeof globalThis.navigator === "undefined") {
+    globalThis.navigator = {
+      userAgent: "Bun"
+    };
+  } else {
+    Object.defineProperty(globalThis.navigator, "userAgent", {
+      value: "Bun",
+      writable: false
+    });
+  }
+  return {
+    env: process.env
+  };
+};
+var bun_default = bunAdapter;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bunAdapter
+});

node_modules/@hono/vite-dev-server/dist/adapter/bun.d.cts

@@ -0,0 +1,6 @@
+import { Adapter } from '../types.cjs';
+import 'vite';
+
+declare const bunAdapter: () => Adapter;
+
+export { bunAdapter, bunAdapter as default };

node_modules/@hono/vite-dev-server/dist/adapter/bun.d.ts

@@ -0,0 +1,6 @@
+import { Adapter } from '../types.js';
+import 'vite';
+
+declare const bunAdapter: () => Adapter;
+
+export { bunAdapter, bunAdapter as default };

node_modules/@hono/vite-dev-server/dist/adapter/bun.js

@@ -0,0 +1,20 @@
+const bunAdapter = () => {
+  if (typeof globalThis.navigator === "undefined") {
+    globalThis.navigator = {
+      userAgent: "Bun"
+    };
+  } else {
+    Object.defineProperty(globalThis.navigator, "userAgent", {
+      value: "Bun",
+      writable: false
+    });
+  }
+  return {
+    env: process.env
+  };
+};
+var bun_default = bunAdapter;
+export {
+  bunAdapter,
+  bun_default as default
+};

node_modules/@hono/vite-dev-server/dist/adapter/cloudflare.cjs

@@ -0,0 +1,71 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cloudflare_exports = {};
+__export(cloudflare_exports, {
+  cloudflareAdapter: () => cloudflareAdapter,
+  default: () => cloudflare_default
+});
+module.exports = __toCommonJS(cloudflare_exports);
+var import_miniflare = require("miniflare");
+var import_wrangler = require("wrangler");
+Object.assign(globalThis, { WebSocketPair: import_miniflare.WebSocketPair });
+let proxy = void 0;
+const cloudflareAdapter = async (options) => {
+  proxy ??= await (0, import_wrangler.getPlatformProxy)(options?.proxy);
+  Object.assign(globalThis, { caches: proxy.caches });
+  if (typeof globalThis.navigator === "undefined") {
+    globalThis.navigator = {
+      userAgent: "Cloudflare-Workers"
+    };
+  } else {
+    Object.defineProperty(globalThis.navigator, "userAgent", {
+      value: "Cloudflare-Workers",
+      writable: false
+    });
+  }
+  Object.defineProperty(Request.prototype, "cf", {
+    get: function() {
+      if (proxy !== void 0) {
+        return proxy.cf;
+      }
+      throw new Error("Proxy is not initialized");
+    },
+    configurable: true,
+    enumerable: true
+  });
+  return {
+    env: proxy.env,
+    executionContext: proxy.ctx,
+    onServerClose: async () => {
+      if (proxy !== void 0) {
+        try {
+          await proxy.dispose();
+        } catch {
+        } finally {
+          proxy = void 0;
+        }
+      }
+    }
+  };
+};
+var cloudflare_default = cloudflareAdapter;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cloudflareAdapter
+});

node_modules/@hono/vite-dev-server/dist/adapter/cloudflare.d.cts

@@ -0,0 +1,10 @@
+import { getPlatformProxy } from 'wrangler';
+import { Adapter } from '../types.cjs';
+import 'vite';
+
+type CloudflareAdapterOptions = {
+    proxy: Parameters<typeof getPlatformProxy>[0];
+};
+declare const cloudflareAdapter: (options?: CloudflareAdapterOptions) => Promise<Adapter>;
+
+export { cloudflareAdapter, cloudflareAdapter as default };

node_modules/@hono/vite-dev-server/dist/adapter/cloudflare.d.ts

@@ -0,0 +1,10 @@
+import { getPlatformProxy } from 'wrangler';
+import { Adapter } from '../types.js';
+import 'vite';
+
+type CloudflareAdapterOptions = {
+    proxy: Parameters<typeof getPlatformProxy>[0];
+};
+declare const cloudflareAdapter: (options?: CloudflareAdapterOptions) => Promise<Adapter>;
+
+export { cloudflareAdapter, cloudflareAdapter as default };

node_modules/@hono/vite-dev-server/dist/adapter/cloudflare.js

@@ -0,0 +1,47 @@
+import { WebSocketPair } from "miniflare";
+import { getPlatformProxy } from "wrangler";
+Object.assign(globalThis, { WebSocketPair });
+let proxy = void 0;
+const cloudflareAdapter = async (options) => {
+  proxy ??= await getPlatformProxy(options?.proxy);
+  Object.assign(globalThis, { caches: proxy.caches });
+  if (typeof globalThis.navigator === "undefined") {
+    globalThis.navigator = {
+      userAgent: "Cloudflare-Workers"
+    };
+  } else {
+    Object.defineProperty(globalThis.navigator, "userAgent", {
+      value: "Cloudflare-Workers",
+      writable: false
+    });
+  }
+  Object.defineProperty(Request.prototype, "cf", {
+    get: function() {
+      if (proxy !== void 0) {
+        return proxy.cf;
+      }
+      throw new Error("Proxy is not initialized");
+    },
+    configurable: true,
+    enumerable: true
+  });
+  return {
+    env: proxy.env,
+    executionContext: proxy.ctx,
+    onServerClose: async () => {
+      if (proxy !== void 0) {
+        try {
+          await proxy.dispose();
+        } catch {
+        } finally {
+          proxy = void 0;
+        }
+      }
+    }
+  };
+};
+var cloudflare_default = cloudflareAdapter;
+export {
+  cloudflareAdapter,
+  cloudflare_default as default
+};

node_modules/@hono/vite-dev-server/dist/adapter/node.cjs

@@ -0,0 +1,44 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var node_exports = {};
+__export(node_exports, {
+  default: () => node_default,
+  nodeAdapter: () => nodeAdapter
+});
+module.exports = __toCommonJS(node_exports);
+const nodeAdapter = () => {
+  if (typeof globalThis.navigator === "undefined") {
+    globalThis.navigator = {
+      userAgent: "Node.js"
+    };
+  } else {
+    Object.defineProperty(globalThis.navigator, "userAgent", {
+      value: "Node.js",
+      writable: false
+    });
+  }
+  return {
+    env: process.env
+  };
+};
+var node_default = nodeAdapter;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  nodeAdapter
+});

node_modules/@hono/vite-dev-server/dist/adapter/node.d.cts

@@ -0,0 +1,6 @@
+import { Adapter } from '../types.cjs';
+import 'vite';
+
+declare const nodeAdapter: () => Adapter;
+
+export { nodeAdapter as default, nodeAdapter };

node_modules/@hono/vite-dev-server/dist/adapter/node.d.ts

@@ -0,0 +1,6 @@
+import { Adapter } from '../types.js';
+import 'vite';
+
+declare const nodeAdapter: () => Adapter;
+
+export { nodeAdapter as default, nodeAdapter };

node_modules/@hono/vite-dev-server/dist/adapter/node.js

@@ -0,0 +1,20 @@
+const nodeAdapter = () => {
+  if (typeof globalThis.navigator === "undefined") {
+    globalThis.navigator = {
+      userAgent: "Node.js"
+    };
+  } else {
+    Object.defineProperty(globalThis.navigator, "userAgent", {
+      value: "Node.js",
+      writable: false
+    });
+  }
+  return {
+    env: process.env
+  };
+};
+var node_default = nodeAdapter;
+export {
+  node_default as default,
+  nodeAdapter
+};

node_modules/@hono/vite-dev-server/dist/dev-server.cjs

@@ -0,0 +1,246 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dev_server_exports = {};
+__export(dev_server_exports, {
+  defaultOptions: () => defaultOptions,
+  devServer: () => devServer
+});
+module.exports = __toCommonJS(dev_server_exports);
+var import_node_server = require("@hono/node-server");
+var import_minimatch = require("minimatch");
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+const defaultOptions = {
+  entry: "./src/index.ts",
+  export: "default",
+  injectClientScript: true,
+  exclude: [
+    /.*\.css$/,
+    /.*\.ts$/,
+    /.*\.tsx$/,
+    /^\/@.+$/,
+    /\?t\=\d+$/,
+    /^\/favicon\.ico$/,
+    /^\/static\/.+/,
+    /^\/node_modules\/.*/
+  ],
+  ignoreWatching: [/\.wrangler/, /\.mf/],
+  handleHotUpdate: ({ server, modules }) => {
+    const isSSR = modules.some((mod) => mod._ssrModule);
+    if (isSSR) {
+      server.hot.send({ type: "full-reload" });
+      return [];
+    }
+  }
+};
+function devServer(options) {
+  let publicDirPath = "";
+  const entry = options?.entry ?? defaultOptions.entry;
+  const plugin = {
+    name: "@hono/vite-dev-server",
+    configResolved(config) {
+      publicDirPath = config.publicDir;
+    },
+    configureServer: async (server) => {
+      async function createMiddleware(server2) {
+        return async function(req, res, next) {
+          if (req.url) {
+            const filePath = import_path.default.join(publicDirPath, req.url);
+            try {
+              if (import_fs.default.existsSync(filePath) && import_fs.default.statSync(filePath).isFile()) {
+                return next();
+              }
+            } catch {
+            }
+          }
+          const exclude = options?.exclude ?? defaultOptions.exclude;
+          for (const pattern of exclude) {
+            if (req.url) {
+              if (pattern instanceof RegExp) {
+                if (pattern.test(req.url)) {
+                  return next();
+                }
+              } else if ((0, import_minimatch.minimatch)(req.url?.toString(), pattern)) {
+                return next();
+              }
+            }
+          }
+          let loadModule;
+          if (options?.loadModule) {
+            loadModule = options.loadModule;
+          } else {
+            loadModule = async (server3, entry2) => {
+              let appModule;
+              try {
+                appModule = await server3.ssrLoadModule(entry2);
+              } catch (e) {
+                if (e instanceof Error) {
+                  server3.ssrFixStacktrace(e);
+                }
+                throw e;
+              }
+              const exportName = options?.export ?? defaultOptions.export;
+              const app2 = appModule[exportName];
+              if (!app2) {
+                throw new Error(`Failed to find a named export "${exportName}" from ${entry2}`);
+              }
+              return app2;
+            };
+          }
+          let app;
+          try {
+            app = await loadModule(server2, entry);
+          } catch (e) {
+            return next(e);
+          }
+          (0, import_node_server.getRequestListener)(
+            async (request) => {
+              let env = {};
+              if (options?.env) {
+                if (typeof options.env === "function") {
+                  env = { ...env, ...await options.env() };
+                } else {
+                  env = { ...env, ...options.env };
+                }
+              }
+              const adapter = await getAdapterFromOptions(options);
+              if (adapter?.env) {
+                env = { ...env, ...adapter.env };
+              }
+              const executionContext = adapter?.executionContext ?? {
+                waitUntil: async (fn) => fn,
+                passThroughOnException: () => {
+                  throw new Error("`passThroughOnException` is not supported");
+                }
+              };
+              const response = await app.fetch(request, env, executionContext);
+              if (!(response instanceof Response)) {
+                throw response;
+              }
+              if (options?.injectClientScript !== false && response.headers.get("content-type")?.match(/^text\/html/)) {
+                const nonce = response.headers.get("content-security-policy")?.match(/'nonce-([^']+)'/)?.[1];
+                const script = `<script${nonce ? ` nonce="${nonce}"` : ""}>import("/@vite/client")</script>`;
+                return injectStringToResponse(response, script) ?? response;
+              }
+              return response;
+            },
+            {
+              overrideGlobalObjects: false,
+              errorHandler: (e) => {
+                let err;
+                if (e instanceof Error) {
+                  err = e;
+                  server2.ssrFixStacktrace(err);
+                } else if (typeof e === "string") {
+                  err = new Error(`The response is not an instance of "Response", but: ${e}`);
+                } else {
+                  err = new Error(`Unknown error: ${e}`);
+                }
+                next(err);
+              }
+            }
+          )(req, res);
+        };
+      }
+      server.middlewares.use(await createMiddleware(server));
+      server.httpServer?.on("close", async () => {
+        const adapter = await getAdapterFromOptions(options);
+        if (adapter?.onServerClose) {
+          await adapter.onServerClose();
+        }
+      });
+    },
+    handleHotUpdate: options?.handleHotUpdate ?? defaultOptions.handleHotUpdate,
+    config: () => {
+      return {
+        server: {
+          watch: {
+            ignored: options?.ignoreWatching ?? defaultOptions.ignoreWatching
+          }
+        }
+      };
+    }
+  };
+  return plugin;
+}
+const getAdapterFromOptions = async (options) => {
+  let adapter = options?.adapter;
+  if (typeof adapter === "function") {
+    adapter = adapter();
+  }
+  if (adapter instanceof Promise) {
+    adapter = await adapter;
+  }
+  return adapter;
+};
+function injectStringToResponse(response, content) {
+  const stream = response.body;
+  const newContent = new TextEncoder().encode(content);
+  if (!stream) {
+    return null;
+  }
+  const reader = stream.getReader();
+  const newContentReader = new ReadableStream({
+    start(controller) {
+      controller.enqueue(newContent);
+      controller.close();
+    }
+  }).getReader();
+  const combinedStream = new ReadableStream({
+    async start(controller) {
+      for (; ; ) {
+        const [existingResult, newContentResult] = await Promise.all([
+          reader.read(),
+          newContentReader.read()
+        ]);
+        if (existingResult.done && newContentResult.done) {
+          controller.close();
+          break;
+        }
+        if (!existingResult.done) {
+          controller.enqueue(existingResult.value);
+        }
+        if (!newContentResult.done) {
+          controller.enqueue(newContentResult.value);
+        }
+      }
+    }
+  });
+  const headers = new Headers(response.headers);
+  headers.delete("content-length");
+  return new Response(combinedStream, {
+    headers,
+    status: response.status
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaultOptions,
+  devServer
+});

node_modules/@hono/vite-dev-server/dist/dev-server.d.cts

@@ -0,0 +1,46 @@
+import { Plugin } from 'vite';
+import { Env, EnvFunc, LoadModule, Adapter } from './types.cjs';
+
+type DevServerOptions = {
+    entry?: string;
+    export?: string;
+    injectClientScript?: boolean;
+    exclude?: (string | RegExp)[];
+    ignoreWatching?: (string | RegExp)[];
+    env?: Env | EnvFunc;
+    loadModule?: LoadModule;
+    /**
+     * This can be used to inject environment variables into the worker from your wrangler.toml for example,
+     * by making use of the helper function `getPlatformProxy` from `wrangler`.
+     *
+     * @example
+     *
+     * ```ts
+     * import { defineConfig } from 'vite'
+     * import devServer from '@hono/vite-dev-server'
+     * import getPlatformProxy from 'wrangler'
+     *
+     * export default defineConfig(async () => {
+     *    const { env, dispose } = await getPlatformProxy()
+     *    return {
+     *      plugins: [
+     *        devServer({
+     *          adapter: {
+     *            env,
+     *            onServerClose: dispose
+     *          },
+     *        }),
+     *      ],
+     *    }
+     *  })
+     * ```
+     *
+     *
+     */
+    adapter?: Adapter | Promise<Adapter> | (() => Adapter | Promise<Adapter>);
+    handleHotUpdate?: Plugin['handleHotUpdate'];
+};
+declare const defaultOptions: Required<Omit<DevServerOptions, 'env' | 'adapter' | 'loadModule'>>;
+declare function devServer(options?: DevServerOptions): Plugin;
+
+export { DevServerOptions, defaultOptions, devServer };

node_modules/@hono/vite-dev-server/dist/dev-server.d.ts

@@ -0,0 +1,46 @@
+import { Plugin } from 'vite';
+import { Env, EnvFunc, LoadModule, Adapter } from './types.js';
+
+type DevServerOptions = {
+    entry?: string;
+    export?: string;
+    injectClientScript?: boolean;
+    exclude?: (string | RegExp)[];
+    ignoreWatching?: (string | RegExp)[];
+    env?: Env | EnvFunc;
+    loadModule?: LoadModule;
+    /**
+     * This can be used to inject environment variables into the worker from your wrangler.toml for example,
+     * by making use of the helper function `getPlatformProxy` from `wrangler`.
+     *
+     * @example
+     *
+     * ```ts
+     * import { defineConfig } from 'vite'
+     * import devServer from '@hono/vite-dev-server'
+     * import getPlatformProxy from 'wrangler'
+     *
+     * export default defineConfig(async () => {
+     *    const { env, dispose } = await getPlatformProxy()
+     *    return {
+     *      plugins: [
+     *        devServer({
+     *          adapter: {
+     *            env,
+     *            onServerClose: dispose
+     *          },
+     *        }),
+     *      ],
+     *    }
+     *  })
+     * ```
+     *
+     *
+     */
+    adapter?: Adapter | Promise<Adapter> | (() => Adapter | Promise<Adapter>);
+    handleHotUpdate?: Plugin['handleHotUpdate'];
+};
+declare const defaultOptions: Required<Omit<DevServerOptions, 'env' | 'adapter' | 'loadModule'>>;
+declare function devServer(options?: DevServerOptions): Plugin;
+
+export { DevServerOptions, defaultOptions, devServer };

node_modules/@hono/vite-dev-server/dist/dev-server.js

@@ -0,0 +1,211 @@
+import { getRequestListener } from "@hono/node-server";
+import { minimatch } from "minimatch";
+import fs from "fs";
+import path from "path";
+const defaultOptions = {
+  entry: "./src/index.ts",
+  export: "default",
+  injectClientScript: true,
+  exclude: [
+    /.*\.css$/,
+    /.*\.ts$/,
+    /.*\.tsx$/,
+    /^\/@.+$/,
+    /\?t\=\d+$/,
+    /^\/favicon\.ico$/,
+    /^\/static\/.+/,
+    /^\/node_modules\/.*/
+  ],
+  ignoreWatching: [/\.wrangler/, /\.mf/],
+  handleHotUpdate: ({ server, modules }) => {
+    const isSSR = modules.some((mod) => mod._ssrModule);
+    if (isSSR) {
+      server.hot.send({ type: "full-reload" });
+      return [];
+    }
+  }
+};
+function devServer(options) {
+  let publicDirPath = "";
+  const entry = options?.entry ?? defaultOptions.entry;
+  const plugin = {
+    name: "@hono/vite-dev-server",
+    configResolved(config) {
+      publicDirPath = config.publicDir;
+    },
+    configureServer: async (server) => {
+      async function createMiddleware(server2) {
+        return async function(req, res, next) {
+          if (req.url) {
+            const filePath = path.join(publicDirPath, req.url);
+            try {
+              if (fs.existsSync(filePath) && fs.statSync(filePath).isFile()) {
+                return next();
+              }
+            } catch {
+            }
+          }
+          const exclude = options?.exclude ?? defaultOptions.exclude;
+          for (const pattern of exclude) {
+            if (req.url) {
+              if (pattern instanceof RegExp) {
+                if (pattern.test(req.url)) {
+                  return next();
+                }
+              } else if (minimatch(req.url?.toString(), pattern)) {
+                return next();
+              }
+            }
+          }
+          let loadModule;
+          if (options?.loadModule) {
+            loadModule = options.loadModule;
+          } else {
+            loadModule = async (server3, entry2) => {
+              let appModule;
+              try {
+                appModule = await server3.ssrLoadModule(entry2);
+              } catch (e) {
+                if (e instanceof Error) {
+                  server3.ssrFixStacktrace(e);
+                }
+                throw e;
+              }
+              const exportName = options?.export ?? defaultOptions.export;
+              const app2 = appModule[exportName];
+              if (!app2) {
+                throw new Error(`Failed to find a named export "${exportName}" from ${entry2}`);
+              }
+              return app2;
+            };
+          }
+          let app;
+          try {
+            app = await loadModule(server2, entry);
+          } catch (e) {
+            return next(e);
+          }
+          getRequestListener(
+            async (request) => {
+              let env = {};
+              if (options?.env) {
+                if (typeof options.env === "function") {
+                  env = { ...env, ...await options.env() };
+                } else {
+                  env = { ...env, ...options.env };
+                }
+              }
+              const adapter = await getAdapterFromOptions(options);
+              if (adapter?.env) {
+                env = { ...env, ...adapter.env };
+              }
+              const executionContext = adapter?.executionContext ?? {
+                waitUntil: async (fn) => fn,
+                passThroughOnException: () => {
+                  throw new Error("`passThroughOnException` is not supported");
+                }
+              };
+              const response = await app.fetch(request, env, executionContext);
+              if (!(response instanceof Response)) {
+                throw response;
+              }
+              if (options?.injectClientScript !== false && response.headers.get("content-type")?.match(/^text\/html/)) {
+                const nonce = response.headers.get("content-security-policy")?.match(/'nonce-([^']+)'/)?.[1];
+                const script = `<script${nonce ? ` nonce="${nonce}"` : ""}>import("/@vite/client")</script>`;
+                return injectStringToResponse(response, script) ?? response;
+              }
+              return response;
+            },
+            {
+              overrideGlobalObjects: false,
+              errorHandler: (e) => {
+                let err;
+                if (e instanceof Error) {
+                  err = e;
+                  server2.ssrFixStacktrace(err);
+                } else if (typeof e === "string") {
+                  err = new Error(`The response is not an instance of "Response", but: ${e}`);
+                } else {
+                  err = new Error(`Unknown error: ${e}`);
+                }
+                next(err);
+              }
+            }
+          )(req, res);
+        };
+      }
+      server.middlewares.use(await createMiddleware(server));
+      server.httpServer?.on("close", async () => {
+        const adapter = await getAdapterFromOptions(options);
+        if (adapter?.onServerClose) {
+          await adapter.onServerClose();
+        }
+      });
+    },
+    handleHotUpdate: options?.handleHotUpdate ?? defaultOptions.handleHotUpdate,
+    config: () => {
+      return {
+        server: {
+          watch: {
+            ignored: options?.ignoreWatching ?? defaultOptions.ignoreWatching
+          }
+        }
+      };
+    }
+  };
+  return plugin;
+}
+const getAdapterFromOptions = async (options) => {
+  let adapter = options?.adapter;
+  if (typeof adapter === "function") {
+    adapter = adapter();
+  }
+  if (adapter instanceof Promise) {
+    adapter = await adapter;
+  }
+  return adapter;
+};
+function injectStringToResponse(response, content) {
+  const stream = response.body;
+  const newContent = new TextEncoder().encode(content);
+  if (!stream) {
+    return null;
+  }
+  const reader = stream.getReader();
+  const newContentReader = new ReadableStream({
+    start(controller) {
+      controller.enqueue(newContent);
+      controller.close();
+    }
+  }).getReader();
+  const combinedStream = new ReadableStream({
+    async start(controller) {
+      for (; ; ) {
+        const [existingResult, newContentResult] = await Promise.all([
+          reader.read(),
+          newContentReader.read()
+        ]);
+        if (existingResult.done && newContentResult.done) {
+          controller.close();
+          break;
+        }
+        if (!existingResult.done) {
+          controller.enqueue(existingResult.value);
+        }
+        if (!newContentResult.done) {
+          controller.enqueue(newContentResult.value);
+        }
+      }
+    }
+  });
+  const headers = new Headers(response.headers);
+  headers.delete("content-length");
+  return new Response(combinedStream, {
+    headers,
+    status: response.status
+  });
+}
+export {
+  defaultOptions,
+  devServer
+};

node_modules/@hono/vite-dev-server/dist/index.cjs

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  default: () => src_default,
+  defaultOptions: () => import_dev_server2.defaultOptions
+});
+module.exports = __toCommonJS(src_exports);
+var import_dev_server = require("./dev-server.js");
+var import_dev_server2 = require("./dev-server.js");
+var src_default = import_dev_server.devServer;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaultOptions
+});

node_modules/@hono/vite-dev-server/dist/index.d.cts

@@ -0,0 +1,8 @@
+import { devServer } from './dev-server.cjs';
+export { DevServerOptions, defaultOptions } from './dev-server.cjs';
+import 'vite';
+import './types.cjs';
+
+
+
+export { devServer as default };

node_modules/@hono/vite-dev-server/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { devServer } from './dev-server.js';
+export { DevServerOptions, defaultOptions } from './dev-server.js';
+import 'vite';
+import './types.js';
+
+
+
+export { devServer as default };

node_modules/@hono/vite-dev-server/dist/index.js

@@ -0,0 +1,7 @@
+import { devServer } from "./dev-server.js";
+import { defaultOptions } from "./dev-server.js";
+var src_default = devServer;
+export {
+  src_default as default,
+  defaultOptions
+};

node_modules/@hono/vite-dev-server/dist/types.cjs

@@ -0,0 +1,16 @@
+"use strict";
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

node_modules/@hono/vite-dev-server/dist/types.d.cts

@@ -0,0 +1,32 @@
+import { ViteDevServer } from 'vite';
+
+type Env = Record<string, unknown> | Promise<Record<string, unknown>>;
+type EnvFunc = () => Env | Promise<Env>;
+type GetEnv<Options> = (options: Options) => EnvFunc;
+interface ExecutionContext {
+    waitUntil(promise: Promise<unknown>): void;
+    passThroughOnException(): void;
+}
+type Fetch = (request: Request, env: {}, executionContext: ExecutionContext) => Promise<Response>;
+type LoadModule = (server: ViteDevServer, entry: string) => Promise<{
+    fetch: Fetch;
+}>;
+interface Adapter {
+    /**
+     * Environment variables to be injected into the worker
+     */
+    env?: Env;
+    /**
+     * Function called when the vite dev server is closed
+     */
+    onServerClose?: () => Promise<void>;
+    /**
+     * Implementation of waitUntil and passThroughOnException
+     */
+    executionContext?: {
+        waitUntil(promise: Promise<unknown>): void;
+        passThroughOnException(): void;
+    };
+}
+
+export { Adapter, Env, EnvFunc, ExecutionContext, Fetch, GetEnv, LoadModule };

node_modules/@hono/vite-dev-server/dist/types.d.ts

@@ -0,0 +1,32 @@
+import { ViteDevServer } from 'vite';
+
+type Env = Record<string, unknown> | Promise<Record<string, unknown>>;
+type EnvFunc = () => Env | Promise<Env>;
+type GetEnv<Options> = (options: Options) => EnvFunc;
+interface ExecutionContext {
+    waitUntil(promise: Promise<unknown>): void;
+    passThroughOnException(): void;
+}
+type Fetch = (request: Request, env: {}, executionContext: ExecutionContext) => Promise<Response>;
+type LoadModule = (server: ViteDevServer, entry: string) => Promise<{
+    fetch: Fetch;
+}>;
+interface Adapter {
+    /**
+     * Environment variables to be injected into the worker
+     */
+    env?: Env;
+    /**
+     * Function called when the vite dev server is closed
+     */
+    onServerClose?: () => Promise<void>;
+    /**
+     * Implementation of waitUntil and passThroughOnException
+     */
+    executionContext?: {
+        waitUntil(promise: Promise<unknown>): void;
+        passThroughOnException(): void;
+    };
+}
+
+export { Adapter, Env, EnvFunc, ExecutionContext, Fetch, GetEnv, LoadModule };