@visulima/connect 4.0.0-alpha.1 → 4.0.0-alpha.11

package/dist/packem_shared/{createRouter-_G1XhaP4.mjs → createRouter-DGGDIRda.mjs}

@@ -1,13 +1,13 @@
-import withZod from './withZod-HYgoC7AX.mjs';
-import { Router } from './Router-ChnTdYfl.mjs';
+import withZod from './withZod-DMHxmHJB.mjs';
+import { Router } from './Router-CT_g_29S.mjs';
 
-const onNoMatch = async (request, response) => {
+const onNoMatch = (request, response) => {
   response.statusCode = 404;
-  response.end(request.method === "HEAD" ? void 0 : `Route ${request.method} ${request.url} not found`);
+  response.end(request.method === "HEAD" ? void 0 : `Route ${String(request.method)} ${String(request.url)} not found`);
 };
-const onError = async (error, _request, response) => {
+const onError = (error, _request, response) => {
   response.statusCode = 500;
-  console.error(error);
+  globalThis.console.error(error);
   response.end("Internal Server Error");
 };
 const getPathname = (url) => {
@@ -15,6 +15,13 @@ const getPathname = (url) => {
   return queryIndex === -1 ? url : url.slice(0, Math.max(0, queryIndex));
 };
 class NodeRouter {
+  static prepareRequest(request, findResult) {
+    request.params = {
+      ...findResult.params,
+      ...request.params
+      // original params will take precedence
+    };
+  }
   all = this.add.bind(this, "");
   connect = this.add.bind(this, "CONNECT");
   delete = this.add.bind(this, "DELETE");
@@ -40,8 +47,10 @@ class NodeRouter {
   handler() {
     const { routes } = this.router;
     return async (request, response) => {
-      const result = this.router.find(request.method, getPathname(request.url));
-      this.prepareRequest(request, result);
+      const pathname = getPathname(request.url);
+      const method = request.method;
+      const result = this.router.find(method, pathname);
+      NodeRouter.prepareRequest(request, result);
       try {
         await (result.fns.length === 0 || result.middleOnly ? this.onNoMatch(request, response, routes) : Router.exec(result.fns, request, response));
       } catch (error) {
@@ -50,46 +59,48 @@ class NodeRouter {
     };
   }
   async run(request, response) {
-    const result = this.router.find(request.method, getPathname(request.url));
+    const pathname = getPathname(request.url);
+    const method = request.method;
+    const result = this.router.find(method, pathname);
     if (result.fns.length === 0) {
-      return;
+      return void 0;
     }
-    this.prepareRequest(request, result);
-    return await Router.exec(result.fns, request, response);
+    NodeRouter.prepareRequest(request, result);
+    return Router.exec(result.fns, request, response);
   }
   use(base, ...fns) {
+    let resolvedBase;
     if (typeof base === "function" || base instanceof NodeRouter) {
       fns.unshift(base);
-      base = "/";
+      resolvedBase = "/";
+    } else {
+      resolvedBase = base;
     }
-    this.router.use(base, ...fns.map((function_) => function_ instanceof NodeRouter ? function_.router : function_));
+    this.router.use(
+      resolvedBase,
+      ...fns.map((function_) => {
+        if (function_ instanceof NodeRouter) {
+          return function_.router;
+        }
+        return function_;
+      })
+    );
     return this;
   }
   add(method, routeOrFunction, zodOrRouteOrFunction, ...fns) {
+    let resolvedFns;
     if (typeof routeOrFunction === "string" && typeof zodOrRouteOrFunction === "function") {
-      fns = [zodOrRouteOrFunction];
+      resolvedFns = [zodOrRouteOrFunction];
     } else if (typeof zodOrRouteOrFunction === "object") {
-      if (typeof routeOrFunction === "function") {
-        fns = [withZod(zodOrRouteOrFunction, routeOrFunction)];
-      } else {
-        fns = fns.map(
-          (function_) => withZod(zodOrRouteOrFunction, function_)
-        );
-      }
+      resolvedFns = typeof routeOrFunction === "function" ? [withZod(zodOrRouteOrFunction, routeOrFunction)] : fns.map((function_) => withZod(zodOrRouteOrFunction, function_));
     } else if (typeof zodOrRouteOrFunction === "function") {
-      fns = [zodOrRouteOrFunction];
+      resolvedFns = [zodOrRouteOrFunction];
+    } else {
+      resolvedFns = fns;
     }
-    this.router.add(method, routeOrFunction, ...fns);
+    this.router.add(method, routeOrFunction, ...resolvedFns);
     return this;
   }
-  // eslint-disable-next-line class-methods-use-this
-  prepareRequest(request, findResult) {
-    request.params = {
-      ...findResult.params,
-      ...request.params
-      // original params will take precedence
-    };
-  }
 }
 const createRouter = (options = {}) => new NodeRouter(options);
 

package/dist/packem_shared/expressWrapper-CeTFmeNH.mjs

@@ -0,0 +1,14 @@
+const expressWrapper = (function_) => async (request, response, next) => {
+  await new Promise((resolve, reject) => {
+    function_(request, response, (error) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve();
+      }
+    });
+  });
+  return next();
+};
+
+export { expressWrapper as default };

package/dist/packem_shared/expressWrapper-oEj2tv9s.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+const expressWrapper = (function_) => async (request, response, next) => {
+  await new Promise((resolve, reject) => {
+    function_(request, response, (error) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve();
+      }
+    });
+  });
+  return next();
+};
+
+module.exports = expressWrapper;

package/dist/packem_shared/{sendJson-DwLYLDbt.mjs → sendJson-Cd6CsJC_.mjs}

@@ -1,7 +1,7 @@
 const sendJson = (response, statusCode, jsonBody) => {
   response.setHeader("content-type", "application/json; charset=utf-8");
   response.statusCode = statusCode;
-  response.end(JSON.stringify(jsonBody, null, 2));
+  response.end(JSON.stringify(jsonBody, void 0, 2));
 };
 
 export { sendJson as default };

package/dist/packem_shared/{sendJson-pJY2tT2n.cjs → sendJson-DjC80Qht.cjs}

@@ -3,7 +3,7 @@
 const sendJson = (response, statusCode, jsonBody) => {
   response.setHeader("content-type", "application/json; charset=utf-8");
   response.statusCode = statusCode;
-  response.end(JSON.stringify(jsonBody, null, 2));
+  response.end(JSON.stringify(jsonBody, void 0, 2));
 };
 
 module.exports = sendJson;

package/dist/packem_shared/{withZod-HYgoC7AX.mjs → withZod-DMHxmHJB.mjs}

@@ -1,15 +1,12 @@
 import createHttpError from 'http-errors';
-import { ZodError } from 'zod';
+import * as z from 'zod';
 
 const withZod = (schema, handler) => async (request, response, next) => {
-  let transformedRequest = request;
+  let transformedRequest;
   try {
     transformedRequest = await schema.parseAsync(request);
   } catch (error) {
-    let { message } = error;
-    if (error instanceof ZodError && typeof error.format === "function") {
-      message = error.issues.map((issue) => `${issue.path.join("/")} - ${issue.message}`).join("/n");
-    }
+    const message = error instanceof z.ZodError && typeof error.format === "function" ? error.issues.map((issue) => `${issue.path.join("/")} - ${issue.message}`).join("/n") : error.message;
     throw createHttpError(422, message);
   }
   return handler(transformedRequest, response, next);

package/dist/packem_shared/withZod-hpoT0ByV.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+const createHttpError = require('http-errors');
+const z = require('zod');
+
+const _interopDefaultCompat = e => e && typeof e === 'object' && 'default' in e ? e.default : e;
+
+function _interopNamespaceCompat(e) {
+    if (e && typeof e === 'object' && 'default' in e) return e;
+    const n = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } });
+    if (e) {
+        for (const k in e) {
+            n[k] = e[k];
+        }
+    }
+    n.default = e;
+    return n;
+}
+
+const createHttpError__default = /*#__PURE__*/_interopDefaultCompat(createHttpError);
+const z__namespace = /*#__PURE__*/_interopNamespaceCompat(z);
+
+const withZod = (schema, handler) => async (request, response, next) => {
+  let transformedRequest;
+  try {
+    transformedRequest = await schema.parseAsync(request);
+  } catch (error) {
+    const message = error instanceof z__namespace.ZodError && typeof error.format === "function" ? error.issues.map((issue) => `${issue.path.join("/")} - ${issue.message}`).join("/n") : error.message;
+    throw createHttpError__default(422, message);
+  }
+  return handler(transformedRequest, response, next);
+};
+
+module.exports = withZod;

package/package.json

@@ -1,20 +1,21 @@
 {
   "name": "@visulima/connect",
-  "version": "4.0.0-alpha.1",
+  "version": "4.0.0-alpha.11",
   "description": "The minimal router and middleware layer for Next.js, Micro, Vercel, or Node.js http/http2 with support for zod validation.",
   "keywords": [
+    "connect",
+    "http",
+    "http2",
     "javascript",
-    "nextjs",
     "middleware",
+    "nextjs",
+    "node",
     "router",
-    "connect",
     "vercel",
-    "node",
-    "http",
-    "http2",
+    "visulima",
     "zod"
   ],
-  "homepage": "https://www.visulima.com/docs/package/connect",
+  "homepage": "https://visulima.com/packages/connect/",
   "bugs": {
     "url": "https://github.com/visulima/visulima/issues"
   },
@@ -74,10 +75,10 @@
     "regexparam": "^3.0.0"
   },
   "peerDependencies": {
-    "zod": "^3.22.5"
+    "zod": "4.4.1"
   },
   "engines": {
-    "node": ">=22.13 <=25.x"
+    "node": "^22.14.0 || >=24.10.0"
   },
   "os": [
     "darwin",

package/dist/adapter/express.d.cts

@@ -1,7 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-import type { RequestHandler } from "../node.d.cts";
-import type { Nextable } from "../types.d.d.cts";
-type NextFunction = (error?: any) => void;
-declare const expressWrapper: <Request extends IncomingMessage, Response extends ServerResponse>(function_: ExpressRequestHandler<Request, Response>) => Nextable<RequestHandler<Request, Response>>;
-export type ExpressRequestHandler<Request, Response> = (request: Request, response: Response, next: NextFunction) => void;
-export = expressWrapper;

package/dist/adapter/express.d.mts

@@ -1,7 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-import type { RequestHandler } from "../node.d.mts";
-import type { Nextable } from "../types.d.d.mts";
-type NextFunction = (error?: any) => void;
-declare const expressWrapper: <Request extends IncomingMessage, Response extends ServerResponse>(function_: ExpressRequestHandler<Request, Response>) => Nextable<RequestHandler<Request, Response>>;
-export type ExpressRequestHandler<Request, Response> = (request: Request, response: Response, next: NextFunction) => void;
-export default expressWrapper;

package/dist/adapter/express.d.ts

@@ -1,7 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-import type { RequestHandler } from "../node.d.ts";
-import type { Nextable } from "../types.d.d.ts";
-type NextFunction = (error?: any) => void;
-declare const expressWrapper: <Request extends IncomingMessage, Response extends ServerResponse>(function_: ExpressRequestHandler<Request, Response>) => Nextable<RequestHandler<Request, Response>>;
-export type ExpressRequestHandler<Request, Response> = (request: Request, response: Response, next: NextFunction) => void;
-export = expressWrapper;

package/dist/adapter/with-zod.d.cts

@@ -1,8 +0,0 @@
-import type { ZodObject } from "zod";
-import type { Nextable, NextHandler } from "../types.d.d.cts";
-declare const withZod: <Request, Response, Handler extends Nextable<any>, Schema extends ZodObject<{
-    body?: ZodObject<any>;
-    headers?: ZodObject<any>;
-    query?: ZodObject<any>;
-}>>(schema: Schema, handler: Handler) => (request: Request, response: Response, next: NextHandler) => Promise<Response>;
-export = withZod;

package/dist/adapter/with-zod.d.mts

@@ -1,8 +0,0 @@
-import type { ZodObject } from "zod";
-import type { Nextable, NextHandler } from "../types.d.d.mts";
-declare const withZod: <Request, Response, Handler extends Nextable<any>, Schema extends ZodObject<{
-    body?: ZodObject<any>;
-    headers?: ZodObject<any>;
-    query?: ZodObject<any>;
-}>>(schema: Schema, handler: Handler) => (request: Request, response: Response, next: NextHandler) => Promise<Response>;
-export default withZod;

package/dist/adapter/with-zod.d.ts

@@ -1,8 +0,0 @@
-import type { ZodObject } from "zod";
-import type { Nextable, NextHandler } from "../types.d.d.ts";
-declare const withZod: <Request, Response, Handler extends Nextable<any>, Schema extends ZodObject<{
-    body?: ZodObject<any>;
-    headers?: ZodObject<any>;
-    query?: ZodObject<any>;
-}>>(schema: Schema, handler: Handler) => (request: Request, response: Response, next: NextHandler) => Promise<Response>;
-export = withZod;

package/dist/edge.d.cts

@@ -1,30 +0,0 @@
-import type { ZodObject } from "zod";
-import type { Route } from "./router.d.cts";
-import type { FunctionLike, HandlerOptions, Nextable, RouteMatch, RoutesExtendedRequestHandler, RouteShortcutMethod, ValueOrPromise } from "./types.d.d.cts";
-export declare const getPathname: (request: Request & {
-    nextUrl?: URL;
-}) => string;
-export type RequestHandler<R extends Request, Context> = (request: R, context_: Context) => ValueOrPromise<Response | void>;
-export declare class EdgeRouter<R extends Request = Request, Context = unknown, RResponse extends Response = Response, Schema extends ZodObject<any> = ZodObject<any>> {
-    all: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    connect: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    delete: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    get: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    head: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    options: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    patch: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    post: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    put: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    trace: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    private readonly onError;
-    private readonly onNoMatch;
-    private router;
-    constructor(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, RResponse, Route<Nextable<FunctionLike>>[]>>);
-    clone(): EdgeRouter<R, Context, RResponse, Schema>;
-    handler(): (request: R, context_: Context) => Promise<any> | ReturnType<FunctionLike> | ValueOrPromise<RResponse>;
-    run(request: R, context_: Context): Promise<unknown>;
-    use(base: EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>> | RouteMatch, ...fns: (EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>>)[]): this;
-    private add;
-    private prepareRequest;
-}
-export declare const createEdgeRouter: <R extends Request, Context>(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, Response, Route<Nextable<FunctionLike>>[]>>) => EdgeRouter<R, Context>;

package/dist/edge.d.mts

@@ -1,30 +0,0 @@
-import type { ZodObject } from "zod";
-import type { Route } from "./router.d.mts";
-import type { FunctionLike, HandlerOptions, Nextable, RouteMatch, RoutesExtendedRequestHandler, RouteShortcutMethod, ValueOrPromise } from "./types.d.d.mts";
-export declare const getPathname: (request: Request & {
-    nextUrl?: URL;
-}) => string;
-export type RequestHandler<R extends Request, Context> = (request: R, context_: Context) => ValueOrPromise<Response | void>;
-export declare class EdgeRouter<R extends Request = Request, Context = unknown, RResponse extends Response = Response, Schema extends ZodObject<any> = ZodObject<any>> {
-    all: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    connect: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    delete: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    get: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    head: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    options: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    patch: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    post: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    put: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    trace: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    private readonly onError;
-    private readonly onNoMatch;
-    private router;
-    constructor(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, RResponse, Route<Nextable<FunctionLike>>[]>>);
-    clone(): EdgeRouter<R, Context, RResponse, Schema>;
-    handler(): (request: R, context_: Context) => Promise<any> | ReturnType<FunctionLike> | ValueOrPromise<RResponse>;
-    run(request: R, context_: Context): Promise<unknown>;
-    use(base: EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>> | RouteMatch, ...fns: (EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>>)[]): this;
-    private add;
-    private prepareRequest;
-}
-export declare const createEdgeRouter: <R extends Request, Context>(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, Response, Route<Nextable<FunctionLike>>[]>>) => EdgeRouter<R, Context>;

package/dist/edge.d.ts

@@ -1,30 +0,0 @@
-import type { ZodObject } from "zod";
-import type { Route } from "./router.d.ts";
-import type { FunctionLike, HandlerOptions, Nextable, RouteMatch, RoutesExtendedRequestHandler, RouteShortcutMethod, ValueOrPromise } from "./types.d.d.ts";
-export declare const getPathname: (request: Request & {
-    nextUrl?: URL;
-}) => string;
-export type RequestHandler<R extends Request, Context> = (request: R, context_: Context) => ValueOrPromise<Response | void>;
-export declare class EdgeRouter<R extends Request = Request, Context = unknown, RResponse extends Response = Response, Schema extends ZodObject<any> = ZodObject<any>> {
-    all: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    connect: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    delete: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    get: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    head: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    options: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    patch: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    post: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    put: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    trace: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    private readonly onError;
-    private readonly onNoMatch;
-    private router;
-    constructor(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, RResponse, Route<Nextable<FunctionLike>>[]>>);
-    clone(): EdgeRouter<R, Context, RResponse, Schema>;
-    handler(): (request: R, context_: Context) => Promise<any> | ReturnType<FunctionLike> | ValueOrPromise<RResponse>;
-    run(request: R, context_: Context): Promise<unknown>;
-    use(base: EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>> | RouteMatch, ...fns: (EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>>)[]): this;
-    private add;
-    private prepareRequest;
-}
-export declare const createEdgeRouter: <R extends Request, Context>(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, Response, Route<Nextable<FunctionLike>>[]>>) => EdgeRouter<R, Context>;

package/dist/node.d.cts

@@ -1,33 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-import type { ZodObject } from "zod";
-import type { Route } from "./router.d.cts";
-import type { FunctionLike, HandlerOptions, Nextable, RouteMatch, RoutesExtendedRequestHandler, RouteShortcutMethod, ValueOrPromise } from "./types.d.d.cts";
-export declare const getPathname: (url: string) => string;
-export type RequestHandler<Request extends IncomingMessage, Response extends ServerResponse> = (request: Request, response: Response) => ValueOrPromise<void>;
-export declare class NodeRouter<Request extends IncomingMessage = IncomingMessage, Response extends ServerResponse = ServerResponse, Schema extends ZodObject<any> = ZodObject<never>> {
-    all: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    connect: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    delete: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    get: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    head: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    options: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    patch: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    post: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    put: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    trace: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    private readonly onError;
-    private readonly onNoMatch;
-    private router;
-    constructor(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>);
-    clone(): NodeRouter<Request, Response, Schema>;
-    handler(): (request: Request, response: Response) => Promise<void>;
-    run(request: Request, response: Response): Promise<unknown>;
-    use(base: Nextable<RequestHandler<Request, Response>> | NodeRouter<Request, Response, Schema> | RouteMatch, ...fns: (Nextable<RequestHandler<Request, Response>> | NodeRouter<Request, Response, Schema>)[]): this;
-    private add;
-    private prepareRequest;
-}
-export declare const createRouter: <Request extends IncomingMessage, Response extends ServerResponse, Schema extends ZodObject<any> = ZodObject<{
-    body?: ZodObject<any>;
-    headers?: ZodObject<any>;
-    query?: ZodObject<any>;
-}>>(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>) => NodeRouter<Request, Response, Schema>;

package/dist/node.d.mts

@@ -1,33 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-import type { ZodObject } from "zod";
-import type { Route } from "./router.d.mts";
-import type { FunctionLike, HandlerOptions, Nextable, RouteMatch, RoutesExtendedRequestHandler, RouteShortcutMethod, ValueOrPromise } from "./types.d.d.mts";
-export declare const getPathname: (url: string) => string;
-export type RequestHandler<Request extends IncomingMessage, Response extends ServerResponse> = (request: Request, response: Response) => ValueOrPromise<void>;
-export declare class NodeRouter<Request extends IncomingMessage = IncomingMessage, Response extends ServerResponse = ServerResponse, Schema extends ZodObject<any> = ZodObject<never>> {
-    all: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    connect: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    delete: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    get: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    head: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    options: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    patch: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    post: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    put: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    trace: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    private readonly onError;
-    private readonly onNoMatch;
-    private router;
-    constructor(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>);
-    clone(): NodeRouter<Request, Response, Schema>;
-    handler(): (request: Request, response: Response) => Promise<void>;
-    run(request: Request, response: Response): Promise<unknown>;
-    use(base: Nextable<RequestHandler<Request, Response>> | NodeRouter<Request, Response, Schema> | RouteMatch, ...fns: (Nextable<RequestHandler<Request, Response>> | NodeRouter<Request, Response, Schema>)[]): this;
-    private add;
-    private prepareRequest;
-}
-export declare const createRouter: <Request extends IncomingMessage, Response extends ServerResponse, Schema extends ZodObject<any> = ZodObject<{
-    body?: ZodObject<any>;
-    headers?: ZodObject<any>;
-    query?: ZodObject<any>;
-}>>(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>) => NodeRouter<Request, Response, Schema>;

package/dist/node.d.ts

@@ -1,33 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-import type { ZodObject } from "zod";
-import type { Route } from "./router.d.ts";
-import type { FunctionLike, HandlerOptions, Nextable, RouteMatch, RoutesExtendedRequestHandler, RouteShortcutMethod, ValueOrPromise } from "./types.d.d.ts";
-export declare const getPathname: (url: string) => string;
-export type RequestHandler<Request extends IncomingMessage, Response extends ServerResponse> = (request: Request, response: Response) => ValueOrPromise<void>;
-export declare class NodeRouter<Request extends IncomingMessage = IncomingMessage, Response extends ServerResponse = ServerResponse, Schema extends ZodObject<any> = ZodObject<never>> {
-    all: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    connect: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    delete: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    get: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    head: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    options: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    patch: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    post: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    put: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    trace: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    private readonly onError;
-    private readonly onNoMatch;
-    private router;
-    constructor(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>);
-    clone(): NodeRouter<Request, Response, Schema>;
-    handler(): (request: Request, response: Response) => Promise<void>;
-    run(request: Request, response: Response): Promise<unknown>;
-    use(base: Nextable<RequestHandler<Request, Response>> | NodeRouter<Request, Response, Schema> | RouteMatch, ...fns: (Nextable<RequestHandler<Request, Response>> | NodeRouter<Request, Response, Schema>)[]): this;
-    private add;
-    private prepareRequest;
-}
-export declare const createRouter: <Request extends IncomingMessage, Response extends ServerResponse, Schema extends ZodObject<any> = ZodObject<{
-    body?: ZodObject<any>;
-    headers?: ZodObject<any>;
-    query?: ZodObject<any>;
-}>>(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>) => NodeRouter<Request, Response, Schema>;