@hono/node-server 1.0.1 → 1.1.0

package/README.md

@@ -8,7 +8,13 @@ However, it's worth noting that it is still faster than Express.
 
 ## Requirement
 
-- Node.js version 18 or higher.
+It works on Node.js versions greater than 18.x. The specific required Node.js versions are as follows:
+
+- 18.x => 18.14.1+
+- 19.x => 19.7.0+
+- 20.x => 20.0.0+
+
+Essentially, you can simply use the latest version of each major release.
 
 ## Install
 
@@ -81,7 +87,7 @@ serve({
 ## Middleware
 
 Most built-in middleware also works with Node.js.
-Read [the documentation](https://honojs.dev/docs/builtin-middleware/) and use the Middleware of your liking.
+Read [the documentation](https://hono.dev/middleware/builtin/basic-auth) and use the Middleware of your liking.
 
 ```ts
 import { serve } from '@hono/node-server'
@@ -128,7 +134,7 @@ app.use(
 
 ## Related projects
 
-- Hono - <https://honojs.dev>
+- Hono - <https://hono.dev>
 - Hono GitHub repository - <https://github.com/honojs/hono>
 
 ## Author

package/dist/globals.js

@@ -1,20 +1,37 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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 __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;
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_crypto_1 = __importDefault(require("node:crypto"));
+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 import_node_crypto = __toESM(require("node:crypto"));
 const webFetch = global.fetch;
-/** jest dose not use crypto in the global, but this is OK for node 18 */
-if (typeof global.crypto === 'undefined') {
-    global.crypto = node_crypto_1.default;
+if (typeof global.crypto === "undefined") {
+  global.crypto = import_node_crypto.default;
 }
 global.fetch = (info, init) => {
-    init = {
-        // Disable compression handling so people can return the result of a fetch
-        // directly in the loader without messing with the Content-Encoding header.
-        compress: false,
-        ...init,
-    };
-    return webFetch(info, init);
+  init = {
+    // Disable compression handling so people can return the result of a fetch
+    // directly in the loader without messing with the Content-Encoding header.
+    compress: false,
+    ...init
+  };
+  return webFetch(info, init);
 };

package/dist/globals.mjs

@@ -0,0 +1,15 @@
+// src/globals.ts
+import crypto from "node:crypto";
+var webFetch = global.fetch;
+if (typeof global.crypto === "undefined") {
+  global.crypto = crypto;
+}
+global.fetch = (info, init) => {
+  init = {
+    // Disable compression handling so people can return the result of a fetch
+    // directly in the loader without messing with the Content-Encoding header.
+    compress: false,
+    ...init
+  };
+  return webFetch(info, init);
+};

package/dist/index.d.ts

@@ -1 +1,2 @@
 export { serve, createAdaptorServer } from './server';
+export { getRequestListener } from './listener';

package/dist/index.js

@@ -1,6 +1,33 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAdaptorServer = exports.serve = void 0;
-var server_1 = require("./server");
-Object.defineProperty(exports, "serve", { enumerable: true, get: function () { return server_1.serve; } });
-Object.defineProperty(exports, "createAdaptorServer", { enumerable: true, get: function () { return server_1.createAdaptorServer; } });
+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, {
+  createAdaptorServer: () => import_server.createAdaptorServer,
+  getRequestListener: () => import_listener.getRequestListener,
+  serve: () => import_server.serve
+});
+module.exports = __toCommonJS(src_exports);
+var import_server = require("./server");
+var import_listener = require("./listener");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAdaptorServer,
+  getRequestListener,
+  serve
+});

package/dist/index.mjs

@@ -0,0 +1,8 @@
+// src/index.ts
+import { serve, createAdaptorServer } from "./server.mjs";
+import { getRequestListener } from "./listener.mjs";
+export {
+  createAdaptorServer,
+  getRequestListener,
+  serve
+};

package/dist/listener.d.ts

@@ -1,4 +1,4 @@
-import { IncomingMessage, ServerResponse } from 'node:http';
-import { FetchCallback } from './types';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { FetchCallback } from './types';
 import './globals';
 export declare const getRequestListener: (fetchCallback: FetchCallback) => (incoming: IncomingMessage, outgoing: ServerResponse) => Promise<void>;

package/dist/listener.js

@@ -1,90 +1,90 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRequestListener = void 0;
-const node_stream_1 = require("node:stream");
-const promises_1 = require("node:stream/promises");
-require("./globals");
+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 listener_exports = {};
+__export(listener_exports, {
+  getRequestListener: () => getRequestListener
+});
+module.exports = __toCommonJS(listener_exports);
+var import_node_stream = require("node:stream");
+var import_promises = require("node:stream/promises");
+var import_globals = require("./globals");
 const getRequestListener = (fetchCallback) => {
-    return async (incoming, outgoing) => {
-        const method = incoming.method || 'GET';
-        const url = `http://${incoming.headers.host}${incoming.url}`;
-        const headerRecord = [];
-        const len = incoming.rawHeaders.length;
-        for (let i = 0; i < len; i += 2) {
-            headerRecord.push([incoming.rawHeaders[i], incoming.rawHeaders[i + 1]]);
-        }
-        const init = {
-            method: method,
-            headers: headerRecord,
-        };
-        if (!(method === 'GET' || method === 'HEAD')) {
-            // lazy-consume request body
-            init.body = node_stream_1.Readable.toWeb(incoming);
-            init.duplex = 'half';
-        }
-        let res;
-        try {
-            res = (await fetchCallback(new Request(url.toString(), init)));
-        }
-        catch (e) {
-            res = new Response(null, { status: 500 });
-            if (e instanceof Error) {
-                // timeout error emits 504 timeout
-                if (e.name === 'TimeoutError' || e.constructor.name === 'TimeoutError') {
-                    res = new Response(null, { status: 504 });
-                }
-            }
-        }
-        const contentType = res.headers.get('content-type') || '';
-        // nginx buffering variant
-        const buffering = res.headers.get('x-accel-buffering') || '';
-        const contentEncoding = res.headers.get('content-encoding');
-        const contentLength = res.headers.get('content-length');
-        const transferEncoding = res.headers.get('transfer-encoding');
-        for (const [k, v] of res.headers) {
-            if (k === 'set-cookie') {
-                // node native Headers.prototype has getSetCookie method
-                outgoing.setHeader(k, res.headers.getSetCookie(k));
-            }
-            else {
-                outgoing.setHeader(k, v);
-            }
-        }
-        outgoing.statusCode = res.status;
-        if (res.body) {
-            try {
-                /**
-                 * If content-encoding is set, we assume that the response should be not decoded.
-                 * Else if transfer-encoding is set, we assume that the response should be streamed.
-                 * Else if content-length is set, we assume that the response content has been taken care of.
-                 * Else if x-accel-buffering is set to no, we assume that the response should be streamed.
-                 * Else if content-type is not application/json nor text/* but can be text/event-stream,
-                 * we assume that the response should be streamed.
-                 */
-                if (contentEncoding ||
-                    transferEncoding ||
-                    contentLength ||
-                    /^no$/i.test(buffering) ||
-                    !/^(application\/json\b|text\/(?!event-stream\b))/i.test(contentType)) {
-                    await (0, promises_1.pipeline)(node_stream_1.Readable.fromWeb(res.body), outgoing);
-                }
-                else {
-                    const text = await res.text();
-                    outgoing.setHeader('Content-Length', Buffer.byteLength(text));
-                    outgoing.end(text);
-                }
-            }
-            catch (e) {
-                // try to catch any error, to avoid crash
-                console.error(e);
-                const err = e instanceof Error ? e : new Error('unknown error', { cause: e });
-                // destroy error must accept an instance of Error
-                outgoing.destroy(err);
-            }
+  return async (incoming, outgoing) => {
+    const method = incoming.method || "GET";
+    const url = `http://${incoming.headers.host}${incoming.url}`;
+    const headerRecord = [];
+    const len = incoming.rawHeaders.length;
+    for (let i = 0; i < len; i += 2) {
+      headerRecord.push([incoming.rawHeaders[i], incoming.rawHeaders[i + 1]]);
+    }
+    const init = {
+      method,
+      headers: headerRecord
+    };
+    if (!(method === "GET" || method === "HEAD")) {
+      init.body = import_node_stream.Readable.toWeb(incoming);
+      init.duplex = "half";
+    }
+    let res;
+    try {
+      res = await fetchCallback(new Request(url.toString(), init));
+    } catch (e) {
+      res = new Response(null, { status: 500 });
+      if (e instanceof Error) {
+        if (e.name === "TimeoutError" || e.constructor.name === "TimeoutError") {
+          res = new Response(null, { status: 504 });
         }
-        else {
-            outgoing.end();
+      }
+    }
+    const contentType = res.headers.get("content-type") || "";
+    const buffering = res.headers.get("x-accel-buffering") || "";
+    const contentEncoding = res.headers.get("content-encoding");
+    const contentLength = res.headers.get("content-length");
+    const transferEncoding = res.headers.get("transfer-encoding");
+    for (const [k, v] of res.headers) {
+      if (k === "set-cookie") {
+        outgoing.setHeader(k, res.headers.getSetCookie(k));
+      } else {
+        outgoing.setHeader(k, v);
+      }
+    }
+    outgoing.statusCode = res.status;
+    if (res.body) {
+      try {
+        if (contentEncoding || transferEncoding || contentLength || /^no$/i.test(buffering) || !/^(application\/json\b|text\/(?!event-stream\b))/i.test(contentType)) {
+          await (0, import_promises.pipeline)(import_node_stream.Readable.fromWeb(res.body), outgoing);
+        } else {
+          const text = await res.text();
+          outgoing.setHeader("Content-Length", Buffer.byteLength(text));
+          outgoing.end(text);
         }
-    };
+      } catch (e) {
+        console.error(e);
+        const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
+        outgoing.destroy(err);
+      }
+    } else {
+      outgoing.end();
+    }
+  };
 };
-exports.getRequestListener = getRequestListener;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRequestListener
+});

package/dist/listener.mjs

@@ -0,0 +1,67 @@
+// src/listener.ts
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import "./globals.mjs";
+var getRequestListener = (fetchCallback) => {
+  return async (incoming, outgoing) => {
+    const method = incoming.method || "GET";
+    const url = `http://${incoming.headers.host}${incoming.url}`;
+    const headerRecord = [];
+    const len = incoming.rawHeaders.length;
+    for (let i = 0; i < len; i += 2) {
+      headerRecord.push([incoming.rawHeaders[i], incoming.rawHeaders[i + 1]]);
+    }
+    const init = {
+      method,
+      headers: headerRecord
+    };
+    if (!(method === "GET" || method === "HEAD")) {
+      init.body = Readable.toWeb(incoming);
+      init.duplex = "half";
+    }
+    let res;
+    try {
+      res = await fetchCallback(new Request(url.toString(), init));
+    } catch (e) {
+      res = new Response(null, { status: 500 });
+      if (e instanceof Error) {
+        if (e.name === "TimeoutError" || e.constructor.name === "TimeoutError") {
+          res = new Response(null, { status: 504 });
+        }
+      }
+    }
+    const contentType = res.headers.get("content-type") || "";
+    const buffering = res.headers.get("x-accel-buffering") || "";
+    const contentEncoding = res.headers.get("content-encoding");
+    const contentLength = res.headers.get("content-length");
+    const transferEncoding = res.headers.get("transfer-encoding");
+    for (const [k, v] of res.headers) {
+      if (k === "set-cookie") {
+        outgoing.setHeader(k, res.headers.getSetCookie(k));
+      } else {
+        outgoing.setHeader(k, v);
+      }
+    }
+    outgoing.statusCode = res.status;
+    if (res.body) {
+      try {
+        if (contentEncoding || transferEncoding || contentLength || /^no$/i.test(buffering) || !/^(application\/json\b|text\/(?!event-stream\b))/i.test(contentType)) {
+          await pipeline(Readable.fromWeb(res.body), outgoing);
+        } else {
+          const text = await res.text();
+          outgoing.setHeader("Content-Length", Buffer.byteLength(text));
+          outgoing.end(text);
+        }
+      } catch (e) {
+        console.error(e);
+        const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
+        outgoing.destroy(err);
+      }
+    } else {
+      outgoing.end();
+    }
+  };
+};
+export {
+  getRequestListener
+};

package/dist/serve-static.d.ts

@@ -1,5 +1,4 @@
-import type { Next } from 'hono';
-import { Context } from 'hono';
+import type { MiddlewareHandler } from 'hono';
 export declare type ServeStaticOptions = {
     /**
      * Root path, relative to current working directory. (absolute paths are not supported)
@@ -9,4 +8,4 @@ export declare type ServeStaticOptions = {
     index?: string;
     rewriteRequestPath?: (path: string) => string;
 };
-export declare const serveStatic: (options?: ServeStaticOptions) => (c: Context, next: Next) => Promise<Response | undefined>;
+export declare const serveStatic: (options?: ServeStaticOptions) => MiddlewareHandler;

package/dist/serve-static.js

@@ -1,37 +1,94 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.serveStatic = void 0;
-const fs_1 = require("fs");
-const filepath_1 = require("hono/utils/filepath");
-const mime_1 = require("hono/utils/mime");
-const serveStatic = (options = { root: '' }) => {
-    return async (c, next) => {
-        // Do nothing if Response is already set
-        if (c.finalized) {
-            await next();
-        }
-        const url = new URL(c.req.url);
-        const filename = options.path ?? decodeURI(url.pathname);
-        let path = (0, filepath_1.getFilePath)({
-            filename: options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename,
-            root: options.root,
-            defaultDocument: options.index ?? 'index.html',
-        });
-        path = `./${path}`;
-        if ((0, fs_1.existsSync)(path)) {
-            const content = (0, fs_1.readFileSync)(path);
-            if (content) {
-                const mimeType = (0, mime_1.getMimeType)(path);
-                if (mimeType) {
-                    c.header('Content-Type', mimeType);
-                }
-                // Return Response object
-                return c.body(content);
-            }
-        }
-        console.warn(`Static file: ${path} is not found`);
-        await next();
-        return;
-    };
+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 });
 };
-exports.serveStatic = serveStatic;
+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 serve_static_exports = {};
+__export(serve_static_exports, {
+  serveStatic: () => serveStatic
+});
+module.exports = __toCommonJS(serve_static_exports);
+var import_fs = require("fs");
+var import_filepath = require("hono/utils/filepath");
+var import_mime = require("hono/utils/mime");
+const createStreamBody = (stream) => {
+  const body = new ReadableStream({
+    start(controller) {
+      stream.on("data", (chunk) => {
+        controller.enqueue(chunk);
+      });
+      stream.on("end", () => {
+        controller.close();
+      });
+    },
+    cancel() {
+      stream.destroy();
+    }
+  });
+  return body;
+};
+const serveStatic = (options = { root: "" }) => {
+  return async (c, next) => {
+    if (c.finalized)
+      return next();
+    const url = new URL(c.req.url);
+    const filename = options.path ?? decodeURIComponent(url.pathname);
+    let path = (0, import_filepath.getFilePath)({
+      filename: options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename,
+      root: options.root,
+      defaultDocument: options.index ?? "index.html"
+    });
+    path = `./${path}`;
+    if (!(0, import_fs.existsSync)(path)) {
+      return next();
+    }
+    const mimeType = (0, import_mime.getMimeType)(path);
+    if (mimeType) {
+      c.header("Content-Type", mimeType);
+    }
+    const stat = (0, import_fs.lstatSync)(path);
+    const size = stat.size;
+    if (c.req.method == "HEAD" || c.req.method == "OPTIONS") {
+      c.header("Content-Length", size.toString());
+      c.status(200);
+      return c.body(null);
+    }
+    const range = c.req.header("range") || "";
+    if (!range) {
+      c.header("Content-Length", size.toString());
+      return c.body(createStreamBody((0, import_fs.createReadStream)(path)), 200);
+    }
+    c.header("Accept-Ranges", "bytes");
+    c.header("Date", stat.birthtime.toUTCString());
+    let start = 0;
+    let end = stat.size - 1;
+    const parts = range.replace(/bytes=/, "").split("-");
+    start = parseInt(parts[0], 10);
+    end = parts[1] ? parseInt(parts[1], 10) : end;
+    if (size < end - start + 1) {
+      end = size - 1;
+    }
+    const chunksize = end - start + 1;
+    const stream = (0, import_fs.createReadStream)(path, { start, end });
+    c.header("Content-Length", chunksize.toString());
+    c.header("Content-Range", `bytes ${start}-${end}/${stat.size}`);
+    return c.body(createStreamBody(stream), 206);
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  serveStatic
+});

package/dist/serve-static.mjs

@@ -0,0 +1,71 @@
+// src/serve-static.ts
+import { createReadStream, existsSync, lstatSync } from "fs";
+import { getFilePath } from "hono/utils/filepath";
+import { getMimeType } from "hono/utils/mime";
+var createStreamBody = (stream) => {
+  const body = new ReadableStream({
+    start(controller) {
+      stream.on("data", (chunk) => {
+        controller.enqueue(chunk);
+      });
+      stream.on("end", () => {
+        controller.close();
+      });
+    },
+    cancel() {
+      stream.destroy();
+    }
+  });
+  return body;
+};
+var serveStatic = (options = { root: "" }) => {
+  return async (c, next) => {
+    if (c.finalized)
+      return next();
+    const url = new URL(c.req.url);
+    const filename = options.path ?? decodeURIComponent(url.pathname);
+    let path = getFilePath({
+      filename: options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename,
+      root: options.root,
+      defaultDocument: options.index ?? "index.html"
+    });
+    path = `./${path}`;
+    if (!existsSync(path)) {
+      return next();
+    }
+    const mimeType = getMimeType(path);
+    if (mimeType) {
+      c.header("Content-Type", mimeType);
+    }
+    const stat = lstatSync(path);
+    const size = stat.size;
+    if (c.req.method == "HEAD" || c.req.method == "OPTIONS") {
+      c.header("Content-Length", size.toString());
+      c.status(200);
+      return c.body(null);
+    }
+    const range = c.req.header("range") || "";
+    if (!range) {
+      c.header("Content-Length", size.toString());
+      return c.body(createStreamBody(createReadStream(path)), 200);
+    }
+    c.header("Accept-Ranges", "bytes");
+    c.header("Date", stat.birthtime.toUTCString());
+    let start = 0;
+    let end = stat.size - 1;
+    const parts = range.replace(/bytes=/, "").split("-");
+    start = parseInt(parts[0], 10);
+    end = parts[1] ? parseInt(parts[1], 10) : end;
+    if (size < end - start + 1) {
+      end = size - 1;
+    }
+    const chunksize = end - start + 1;
+    const stream = createReadStream(path, { start, end });
+    c.header("Content-Length", chunksize.toString());
+    c.header("Content-Range", `bytes ${start}-${end}/${stat.size}`);
+    return c.body(createStreamBody(stream), 206);
+  };
+};
+export {
+  serveStatic
+};

package/dist/server.d.ts

@@ -1,5 +1,5 @@
-import { Server } from 'node:http';
-import { Options } from './types';
+import { type Server } from 'node:http';
 import type { AddressInfo } from 'node:net';
+import type { Options } from './types';
 export declare const createAdaptorServer: (options: Options) => Server;
 export declare const serve: (options: Options, listeningListener?: ((info: AddressInfo) => void) | undefined) => Server;

package/dist/server.js

@@ -1,22 +1,46 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.serve = exports.createAdaptorServer = void 0;
-const node_http_1 = require("node:http");
-const listener_1 = require("./listener");
+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 server_exports = {};
+__export(server_exports, {
+  createAdaptorServer: () => createAdaptorServer,
+  serve: () => serve
+});
+module.exports = __toCommonJS(server_exports);
+var import_node_http = require("node:http");
+var import_listener = require("./listener");
 const createAdaptorServer = (options) => {
-    const fetchCallback = options.fetch;
-    const requestListener = (0, listener_1.getRequestListener)(fetchCallback);
-    const createServer = options.createServer || node_http_1.createServer;
-    const server = createServer(options.serverOptions || {}, requestListener);
-    return server;
+  const fetchCallback = options.fetch;
+  const requestListener = (0, import_listener.getRequestListener)(fetchCallback);
+  const createServer = options.createServer || import_node_http.createServer;
+  const server = createServer(options.serverOptions || {}, requestListener);
+  return server;
 };
-exports.createAdaptorServer = createAdaptorServer;
 const serve = (options, listeningListener) => {
-    const server = (0, exports.createAdaptorServer)(options);
-    server.listen(options?.port ?? 3000, options.hostname ?? '0.0.0.0', () => {
-        const serverInfo = server.address();
-        listeningListener && listeningListener(serverInfo);
-    });
-    return server;
+  const server = createAdaptorServer(options);
+  server.listen(options?.port ?? 3e3, options.hostname ?? "0.0.0.0", () => {
+    const serverInfo = server.address();
+    listeningListener && listeningListener(serverInfo);
+  });
+  return server;
 };
-exports.serve = serve;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAdaptorServer,
+  serve
+});

package/dist/server.mjs

@@ -0,0 +1,22 @@
+// src/server.ts
+import { createServer as createServerHTTP } from "node:http";
+import { getRequestListener } from "./listener.mjs";
+var createAdaptorServer = (options) => {
+  const fetchCallback = options.fetch;
+  const requestListener = getRequestListener(fetchCallback);
+  const createServer = options.createServer || createServerHTTP;
+  const server = createServer(options.serverOptions || {}, requestListener);
+  return server;
+};
+var serve = (options, listeningListener) => {
+  const server = createAdaptorServer(options);
+  server.listen(options?.port ?? 3e3, options.hostname ?? "0.0.0.0", () => {
+    const serverInfo = server.address();
+    listeningListener && listeningListener(serverInfo);
+  });
+  return server;
+};
+export {
+  createAdaptorServer,
+  serve
+};

package/dist/vercel.js

@@ -1,8 +1,31 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handle = void 0;
-const listener_1 = require("./listener");
+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 vercel_exports = {};
+__export(vercel_exports, {
+  handle: () => handle
+});
+module.exports = __toCommonJS(vercel_exports);
+var import_listener = require("./listener");
 const handle = (app) => {
-    return (0, listener_1.getRequestListener)(app.fetch);
+  return (0, import_listener.getRequestListener)(app.fetch);
 };
-exports.handle = handle;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handle
+});

package/dist/vercel.mjs

@@ -0,0 +1,8 @@
+// src/vercel.ts
+import { getRequestListener } from "./listener.mjs";
+var handle = (app) => {
+  return getRequestListener(app.fetch);
+};
+export {
+  handle
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hono/node-server",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Node.js Adapter for Hono",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -8,12 +8,27 @@
     "dist"
   ],
   "exports": {
-    ".": "./dist/index.js",
-    "./serve-static": "./dist/serve-static.js",
-    "./vercel": "./dist/vercel.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs"
+    },
+    "./serve-static": {
+      "types": "./dist/serve-static.d.ts",
+      "require": "./dist/serve-static.js",
+      "import": "./dist/serve-static.mjs"
+    },
+    "./vercel": {
+      "types": "./dist/vercel.d.ts",
+      "require": "./dist/vercel.js",
+      "import": "./dist/vercel.mjs"
+    }
   },
   "typesVersions": {
     "*": {
+      ".": [
+        "./dist/index.d.ts"
+      ],
       "serve-static": [
         "./dist/serve-static.d.ts"
       ],
@@ -24,7 +39,8 @@
   },
   "scripts": {
     "test": "jest",
-    "build": "rimraf dist && tsc",
+    "build": "rimraf dist && tsx ./build.ts",
+    "postbuild": "publint",
     "prerelease": "yarn build && yarn test",
     "release": "np"
   },
@@ -44,15 +60,19 @@
   },
   "dependencies": {},
   "devDependencies": {
-    "@types/jest": "^29.0.1",
+    "@types/glob": "^8.1.0",
+    "@types/jest": "^29.5.3",
     "@types/node": "^18.7.16",
     "@types/supertest": "^2.0.12",
-    "hono": "^3.1.5",
-    "jest": "^29.0.3",
+    "esbuild": "^0.18.13",
+    "hono": "^3.3.0",
+    "jest": "^29.6.1",
     "np": "^7.7.0",
+    "publint": "^0.1.16",
     "rimraf": "^3.0.2",
     "supertest": "^6.2.4",
-    "ts-jest": "^29.0.0",
+    "ts-jest": "^29.1.1",
+    "tsx": "^3.12.7",
     "typescript": "^4.8.3"
   }
 }

package/dist/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });