@visulima/connect 3.0.24 → 3.0.26

package/dist/index.mjs

@@ -1 +1,6 @@
-import{default as o}from"./packem_shared/expressWrapper-D-d31tgs.mjs";import{default as a}from"./packem_shared/withZod-wmNwBerD.mjs";import{EdgeRouter as d,createEdgeRouter as f}from"./packem_shared/EdgeRouter-DkYqae6k.mjs";import{NodeRouter as s,createRouter as x,createRouter as R}from"./packem_shared/createRouter-Bp84h_yy.mjs";import{Router as c}from"./packem_shared/Router-Dg3J0bWq.mjs";import{default as g}from"./packem_shared/sendJson-zUtTFUYn.mjs";export{d as EdgeRouter,s as NodeRouter,c as Router,f as createEdgeRouter,x as createNodeRouter,R as createRouter,o as expressWrapper,g as sendJson,a as withZod};
+export { default as expressWrapper } from './packem_shared/expressWrapper-spfs58is.mjs';
+export { default as withZod } from './packem_shared/withZod-HYgoC7AX.mjs';
+export { EdgeRouter, createEdgeRouter } from './packem_shared/EdgeRouter-CdtQHTwm.mjs';
+export { NodeRouter, createRouter as createNodeRouter, createRouter } from './packem_shared/createRouter-_G1XhaP4.mjs';
+export { Router } from './packem_shared/Router-ChnTdYfl.mjs';
+export { default as sendJson } from './packem_shared/sendJson-DwLYLDbt.mjs';

package/dist/node.d.cts

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,33 @@
+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>;

package/dist/packem_shared/EdgeRouter-B-e2l9un.cjs

@@ -0,0 +1,96 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const withZod = require('./withZod-ULTsdyM5.cjs');
+const Router = require('./Router-Eg_OPxIL.cjs');
+
+const onNoMatch = async (request) => new Response(request.method === "HEAD" ? null : `Route ${request.method} ${request.url} not found`, { status: 404 });
+const onError = async (error) => {
+  console.error(error);
+  return new Response("Internal Server Error", { status: 500 });
+};
+const getPathname = (request) => (
+  // eslint-disable-next-line compat/compat
+  (request.nextUrl ?? new URL(request.url)).pathname
+);
+class EdgeRouter {
+  all = this.add.bind(this, "");
+  connect = this.add.bind(this, "CONNECT");
+  delete = this.add.bind(this, "DELETE");
+  get = this.add.bind(this, "GET");
+  head = this.add.bind(this, "HEAD");
+  options = this.add.bind(this, "OPTIONS");
+  patch = this.add.bind(this, "PATCH");
+  post = this.add.bind(this, "POST");
+  put = this.add.bind(this, "PUT");
+  trace = this.add.bind(this, "TRACE");
+  onError;
+  onNoMatch;
+  router = new Router.Router();
+  constructor(options = {}) {
+    this.onNoMatch = options.onNoMatch ?? onNoMatch;
+    this.onError = options.onError ?? onError;
+  }
+  clone() {
+    const r = new EdgeRouter({ onError: this.onError, onNoMatch: this.onNoMatch });
+    r.router = this.router.clone();
+    return r;
+  }
+  handler() {
+    const { routes } = this.router;
+    return async (request, context_) => {
+      const result = this.router.find(request.method, getPathname(request));
+      this.prepareRequest(request, result);
+      try {
+        return await (result.fns.length === 0 || result.middleOnly ? this.onNoMatch(request, context_, routes) : Router.Router.exec(result.fns, request, context_));
+      } catch (error) {
+        return await this.onError(error, request, context_, routes);
+      }
+    };
+  }
+  async run(request, context_) {
+    const result = this.router.find(request.method, getPathname(request));
+    if (result.fns.length === 0) {
+      return;
+    }
+    this.prepareRequest(request, result);
+    return await Router.Router.exec(result.fns, request, context_);
+  }
+  use(base, ...fns) {
+    if (typeof base === "function" || base instanceof EdgeRouter) {
+      fns.unshift(base);
+      base = "/";
+    }
+    this.router.use(base, ...fns.map((function_) => function_ instanceof EdgeRouter ? function_.router : function_));
+    return this;
+  }
+  add(method, routeOrFunction, zodOrRouteOrFunction, ...fns) {
+    if (typeof routeOrFunction === "string" && typeof zodOrRouteOrFunction === "function") {
+      fns = [zodOrRouteOrFunction];
+    } else if (typeof zodOrRouteOrFunction === "object") {
+      if (typeof routeOrFunction === "function") {
+        fns = [withZod(zodOrRouteOrFunction, routeOrFunction)];
+      } else {
+        fns = fns.map((function_) => withZod(zodOrRouteOrFunction, function_));
+      }
+    } else if (typeof zodOrRouteOrFunction === "function") {
+      fns = [zodOrRouteOrFunction];
+    }
+    this.router.add(method, routeOrFunction, ...fns);
+    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 createEdgeRouter = (options = {}) => new EdgeRouter(options);
+
+exports.EdgeRouter = EdgeRouter;
+exports.createEdgeRouter = createEdgeRouter;
+exports.getPathname = getPathname;

package/dist/packem_shared/EdgeRouter-CdtQHTwm.mjs

@@ -0,0 +1,90 @@
+import withZod from './withZod-HYgoC7AX.mjs';
+import { Router } from './Router-ChnTdYfl.mjs';
+
+const onNoMatch = async (request) => new Response(request.method === "HEAD" ? null : `Route ${request.method} ${request.url} not found`, { status: 404 });
+const onError = async (error) => {
+  console.error(error);
+  return new Response("Internal Server Error", { status: 500 });
+};
+const getPathname = (request) => (
+  // eslint-disable-next-line compat/compat
+  (request.nextUrl ?? new URL(request.url)).pathname
+);
+class EdgeRouter {
+  all = this.add.bind(this, "");
+  connect = this.add.bind(this, "CONNECT");
+  delete = this.add.bind(this, "DELETE");
+  get = this.add.bind(this, "GET");
+  head = this.add.bind(this, "HEAD");
+  options = this.add.bind(this, "OPTIONS");
+  patch = this.add.bind(this, "PATCH");
+  post = this.add.bind(this, "POST");
+  put = this.add.bind(this, "PUT");
+  trace = this.add.bind(this, "TRACE");
+  onError;
+  onNoMatch;
+  router = new Router();
+  constructor(options = {}) {
+    this.onNoMatch = options.onNoMatch ?? onNoMatch;
+    this.onError = options.onError ?? onError;
+  }
+  clone() {
+    const r = new EdgeRouter({ onError: this.onError, onNoMatch: this.onNoMatch });
+    r.router = this.router.clone();
+    return r;
+  }
+  handler() {
+    const { routes } = this.router;
+    return async (request, context_) => {
+      const result = this.router.find(request.method, getPathname(request));
+      this.prepareRequest(request, result);
+      try {
+        return await (result.fns.length === 0 || result.middleOnly ? this.onNoMatch(request, context_, routes) : Router.exec(result.fns, request, context_));
+      } catch (error) {
+        return await this.onError(error, request, context_, routes);
+      }
+    };
+  }
+  async run(request, context_) {
+    const result = this.router.find(request.method, getPathname(request));
+    if (result.fns.length === 0) {
+      return;
+    }
+    this.prepareRequest(request, result);
+    return await Router.exec(result.fns, request, context_);
+  }
+  use(base, ...fns) {
+    if (typeof base === "function" || base instanceof EdgeRouter) {
+      fns.unshift(base);
+      base = "/";
+    }
+    this.router.use(base, ...fns.map((function_) => function_ instanceof EdgeRouter ? function_.router : function_));
+    return this;
+  }
+  add(method, routeOrFunction, zodOrRouteOrFunction, ...fns) {
+    if (typeof routeOrFunction === "string" && typeof zodOrRouteOrFunction === "function") {
+      fns = [zodOrRouteOrFunction];
+    } else if (typeof zodOrRouteOrFunction === "object") {
+      if (typeof routeOrFunction === "function") {
+        fns = [withZod(zodOrRouteOrFunction, routeOrFunction)];
+      } else {
+        fns = fns.map((function_) => withZod(zodOrRouteOrFunction, function_));
+      }
+    } else if (typeof zodOrRouteOrFunction === "function") {
+      fns = [zodOrRouteOrFunction];
+    }
+    this.router.add(method, routeOrFunction, ...fns);
+    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 createEdgeRouter = (options = {}) => new EdgeRouter(options);
+
+export { EdgeRouter, createEdgeRouter, getPathname };

package/dist/packem_shared/Router-ChnTdYfl.mjs

@@ -0,0 +1,135 @@
+import { parse } from 'regexparam';
+
+class Router {
+  constructor(base = "/", routes = []) {
+    this.base = base;
+    this.routes = routes;
+  }
+  static async exec(fns, ...arguments_) {
+    let index = 0;
+    const next = () => {
+      const function_ = fns[++index];
+      if (function_ === void 0) {
+        return Promise.resolve();
+      }
+      return function_(...arguments_, next);
+    };
+    return fns[index](...arguments_, next);
+  }
+  add(method, route, ...fns) {
+    if (typeof route === "function") {
+      fns.unshift(route);
+      route = "";
+    }
+    if (route === "") {
+      this.routes.push({
+        fns,
+        isMiddleware: false,
+        matchAll: true,
+        method
+      });
+    } else {
+      const { keys, pattern } = parse(route);
+      this.routes.push({
+        fns,
+        isMiddleware: false,
+        keys,
+        method,
+        pattern
+      });
+    }
+    return this;
+  }
+  clone(base) {
+    return new Router(base, [...this.routes]);
+  }
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  find(method, pathname) {
+    let middleOnly = true;
+    const fns = [];
+    const parameters = {};
+    const isHead = method === "HEAD";
+    for (const route of this.routes) {
+      if (route.method !== method && route.method !== "" && !(isHead && route.method === "GET")) {
+        continue;
+      }
+      let matched = false;
+      if ("matchAll" in route) {
+        matched = true;
+      } else if (route.keys === false) {
+        const matches = route.pattern.exec(pathname);
+        if (matches === null) {
+          continue;
+        }
+        if (matches.groups !== void 0) {
+          Object.keys(matches.groups).forEach((key) => {
+            parameters[key] = matches.groups[key];
+          });
+        }
+        matched = true;
+      } else if (route.keys.length > 0) {
+        const matches = route.pattern.exec(pathname);
+        if (matches === null) {
+          continue;
+        }
+        for (let index = 0; index < route.keys.length; ) {
+          const parameterKey = route.keys[index];
+          parameters[parameterKey] = matches[++index];
+        }
+        matched = true;
+      } else if (route.pattern.test(pathname)) {
+        matched = true;
+      }
+      if (matched) {
+        fns.push(
+          ...route.fns.flatMap((function_) => {
+            if (function_ instanceof Router) {
+              const { base } = function_;
+              let stripPathname = pathname.slice(base.length);
+              if (!stripPathname.startsWith("/")) {
+                stripPathname = `/${stripPathname}`;
+              }
+              const result = function_.find(method, stripPathname);
+              if (!result.middleOnly) {
+                middleOnly = false;
+              }
+              Object.assign(parameters, result.params);
+              return result.fns;
+            }
+            return function_;
+          })
+        );
+        if (!route.isMiddleware) {
+          middleOnly = false;
+        }
+      }
+    }
+    return { fns, middleOnly, params: parameters };
+  }
+  use(base, ...fns) {
+    if (typeof base === "function" || base instanceof Router) {
+      fns.unshift(base);
+      base = "/";
+    }
+    fns = fns.map((function_) => {
+      if (function_ instanceof Router) {
+        if (typeof base === "string") {
+          return function_.clone(base);
+        }
+        throw new Error("Mounting a router to RegExp base is not supported");
+      }
+      return function_;
+    });
+    const { keys, pattern } = parse(base, true);
+    this.routes.push({
+      fns,
+      isMiddleware: true,
+      keys,
+      method: "",
+      pattern
+    });
+    return this;
+  }
+}
+
+export { Router };

package/dist/packem_shared/Router-Eg_OPxIL.cjs

@@ -0,0 +1,139 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const regexparam = require('regexparam');
+
+class Router {
+  constructor(base = "/", routes = []) {
+    this.base = base;
+    this.routes = routes;
+  }
+  static async exec(fns, ...arguments_) {
+    let index = 0;
+    const next = () => {
+      const function_ = fns[++index];
+      if (function_ === void 0) {
+        return Promise.resolve();
+      }
+      return function_(...arguments_, next);
+    };
+    return fns[index](...arguments_, next);
+  }
+  add(method, route, ...fns) {
+    if (typeof route === "function") {
+      fns.unshift(route);
+      route = "";
+    }
+    if (route === "") {
+      this.routes.push({
+        fns,
+        isMiddleware: false,
+        matchAll: true,
+        method
+      });
+    } else {
+      const { keys, pattern } = regexparam.parse(route);
+      this.routes.push({
+        fns,
+        isMiddleware: false,
+        keys,
+        method,
+        pattern
+      });
+    }
+    return this;
+  }
+  clone(base) {
+    return new Router(base, [...this.routes]);
+  }
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  find(method, pathname) {
+    let middleOnly = true;
+    const fns = [];
+    const parameters = {};
+    const isHead = method === "HEAD";
+    for (const route of this.routes) {
+      if (route.method !== method && route.method !== "" && !(isHead && route.method === "GET")) {
+        continue;
+      }
+      let matched = false;
+      if ("matchAll" in route) {
+        matched = true;
+      } else if (route.keys === false) {
+        const matches = route.pattern.exec(pathname);
+        if (matches === null) {
+          continue;
+        }
+        if (matches.groups !== void 0) {
+          Object.keys(matches.groups).forEach((key) => {
+            parameters[key] = matches.groups[key];
+          });
+        }
+        matched = true;
+      } else if (route.keys.length > 0) {
+        const matches = route.pattern.exec(pathname);
+        if (matches === null) {
+          continue;
+        }
+        for (let index = 0; index < route.keys.length; ) {
+          const parameterKey = route.keys[index];
+          parameters[parameterKey] = matches[++index];
+        }
+        matched = true;
+      } else if (route.pattern.test(pathname)) {
+        matched = true;
+      }
+      if (matched) {
+        fns.push(
+          ...route.fns.flatMap((function_) => {
+            if (function_ instanceof Router) {
+              const { base } = function_;
+              let stripPathname = pathname.slice(base.length);
+              if (!stripPathname.startsWith("/")) {
+                stripPathname = `/${stripPathname}`;
+              }
+              const result = function_.find(method, stripPathname);
+              if (!result.middleOnly) {
+                middleOnly = false;
+              }
+              Object.assign(parameters, result.params);
+              return result.fns;
+            }
+            return function_;
+          })
+        );
+        if (!route.isMiddleware) {
+          middleOnly = false;
+        }
+      }
+    }
+    return { fns, middleOnly, params: parameters };
+  }
+  use(base, ...fns) {
+    if (typeof base === "function" || base instanceof Router) {
+      fns.unshift(base);
+      base = "/";
+    }
+    fns = fns.map((function_) => {
+      if (function_ instanceof Router) {
+        if (typeof base === "string") {
+          return function_.clone(base);
+        }
+        throw new Error("Mounting a router to RegExp base is not supported");
+      }
+      return function_;
+    });
+    const { keys, pattern } = regexparam.parse(base, true);
+    this.routes.push({
+      fns,
+      isMiddleware: true,
+      keys,
+      method: "",
+      pattern
+    });
+    return this;
+  }
+}
+
+exports.Router = Router;

package/dist/packem_shared/createRouter-C8hDVJcV.cjs

@@ -0,0 +1,102 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const withZod = require('./withZod-ULTsdyM5.cjs');
+const Router = require('./Router-Eg_OPxIL.cjs');
+
+const onNoMatch = async (request, response) => {
+  response.statusCode = 404;
+  response.end(request.method === "HEAD" ? void 0 : `Route ${request.method} ${request.url} not found`);
+};
+const onError = async (error, _request, response) => {
+  response.statusCode = 500;
+  console.error(error);
+  response.end("Internal Server Error");
+};
+const getPathname = (url) => {
+  const queryIndex = url.indexOf("?");
+  return queryIndex === -1 ? url : url.slice(0, Math.max(0, queryIndex));
+};
+class NodeRouter {
+  all = this.add.bind(this, "");
+  connect = this.add.bind(this, "CONNECT");
+  delete = this.add.bind(this, "DELETE");
+  get = this.add.bind(this, "GET");
+  head = this.add.bind(this, "HEAD");
+  options = this.add.bind(this, "OPTIONS");
+  patch = this.add.bind(this, "PATCH");
+  post = this.add.bind(this, "POST");
+  put = this.add.bind(this, "PUT");
+  trace = this.add.bind(this, "TRACE");
+  onError;
+  onNoMatch;
+  router = new Router.Router();
+  constructor(options = {}) {
+    this.onNoMatch = options.onNoMatch ?? onNoMatch;
+    this.onError = options.onError ?? onError;
+  }
+  clone() {
+    const r = new NodeRouter({ onError: this.onError, onNoMatch: this.onNoMatch });
+    r.router = this.router.clone();
+    return r;
+  }
+  handler() {
+    const { routes } = this.router;
+    return async (request, response) => {
+      const result = this.router.find(request.method, getPathname(request.url));
+      this.prepareRequest(request, result);
+      try {
+        await (result.fns.length === 0 || result.middleOnly ? this.onNoMatch(request, response, routes) : Router.Router.exec(result.fns, request, response));
+      } catch (error) {
+        await this.onError(error, request, response, routes);
+      }
+    };
+  }
+  async run(request, response) {
+    const result = this.router.find(request.method, getPathname(request.url));
+    if (result.fns.length === 0) {
+      return;
+    }
+    this.prepareRequest(request, result);
+    return await Router.Router.exec(result.fns, request, response);
+  }
+  use(base, ...fns) {
+    if (typeof base === "function" || base instanceof NodeRouter) {
+      fns.unshift(base);
+      base = "/";
+    }
+    this.router.use(base, ...fns.map((function_) => function_ instanceof NodeRouter ? function_.router : function_));
+    return this;
+  }
+  add(method, routeOrFunction, zodOrRouteOrFunction, ...fns) {
+    if (typeof routeOrFunction === "string" && typeof zodOrRouteOrFunction === "function") {
+      fns = [zodOrRouteOrFunction];
+    } else if (typeof zodOrRouteOrFunction === "object") {
+      if (typeof routeOrFunction === "function") {
+        fns = [withZod(zodOrRouteOrFunction, routeOrFunction)];
+      } else {
+        fns = fns.map(
+          (function_) => withZod(zodOrRouteOrFunction, function_)
+        );
+      }
+    } else if (typeof zodOrRouteOrFunction === "function") {
+      fns = [zodOrRouteOrFunction];
+    }
+    this.router.add(method, routeOrFunction, ...fns);
+    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);
+
+exports.NodeRouter = NodeRouter;
+exports.createRouter = createRouter;
+exports.getPathname = getPathname;