@aura-stack/router 0.1.0 → 0.3.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2025 Aura Stack
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2025 Aura Stack
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,128 +1,31 @@
 # `@aura-stack/router`
 
-A modern, **TypeScript-first** router and endpoint definition library for Node.js.  
-Build fully-typed APIs with declarative endpoints, automatic parameter inference, and first-class middleware support — all returning native `Response` objects for seamless compatibility with the Fetch API.
+<div align="center">
 
-## Table of Contents
+**A modern, TypeScript-first router and endpoint definition library**
 
-- [Features](#features)
-- [Installation](#installation)
-- [Quick Start](#quick-start)
-- [Defining Endpoints](#defining-endpoints)
-- [Validation & Middlewares](#validation--middlewares)
-- [API Reference](#api-reference)
+Build fully-typed APIs with declarative endpoints, automatic parameter inference, and first-class middleware support — all returning native `Response` objects.
 
-## Features
+[![npm version](https://img.shields.io/npm/v/@aura-stack/router.svg)](https://www.npmjs.com/package/@aura-stack/router)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue.svg)](https://www.typescriptlang.org/)
 
-- `Type-safe routing` — only configured HTTP methods are available at compile time.
-- `Declarative API` — define endpoints using `createEndpoint` and group them with `createRouter`.
-- `Typed params & queries` — automatic inference of path (`/users/:id`) and search parameters.
-- `Schema validation` — built-in support for `zod` to validate request bodies, queries, or params.
-- `Middleware chaining` — supports global and per-endpoint middleware execution, with short-circuit control.
+[Documentation](https://aura-stack-router.vercel.app) · [Quick Start](https://aura-stack-router.vercel.app/docs)
 
-## Installation
+</div>
 
-```bash
-pnpm add @aura-stack/router
-# or
-npm install @aura-stack/router
-# or
-yarn add @aura-stack/router
-```
+---
 
-## Quick Start
+## Documentation
 
-```ts
-import { createEndpoint, createRouter } from "@aura-stack/router"
+Visit our [**documentation website**](https://aura-stack-router.vercel.app) for comprehensive guides, examples, and API references.
 
-const session = createEndpoint("GET", "/auth/session", async (_, ctx) => {
-  return Response.json(
-    {
-      session: {
-        userId: "uuid",
-        username: "John",
-      },
-    },
-    { headers: ctx.headers }
-  )
-})
+## License
 
-const { GET } = createRouter([session])
-```
+This project is licensed under the MIT License - see the [LICENSE](./LICENSE) file for details.
 
-## Defining Endpoints
+---
 
-```ts
-import { z } from "zod"
-import { createEndpoint, createEndpointConfig } from "@aura-stack/router"
-
-const credentialsConfig = createEndpointConfig({
-  schemas: {
-    body: z.object({
-      username: z.string(),
-      password: z.string(),
-    }),
-  },
-})
-
-export const signIn = createEndpoint(
-  "POST",
-  "/auth/credentials",
-  async (request, ctx) => {
-    const { body, headers } = ctx
-    headers.set("x-login", "success")
-    return Response.json({ status: "ok", body }, { headers })
-  },
-  credentialsConfig
-)
-```
-
-## Validation & Middlewares
-
-**Validation.** Provide Zod schemas in `createEndpointConfig`:
-
-```ts
-import { createEndpoint, createEndpointConfig } from "@aura-stack/router"
-
-const config = createEndpointConfig({
-  schemas: {
-    searchParams: z.object({
-      redirect_uri: z.string(),
-    }),
-  },
-})
-
-const oauth = createEndpoint(
-  "GET",
-  "/auth/signin/:provider",
-  async (_req, ctx) => {
-    const { provider } = ctx.params
-    const { redirect_uri } = ctx.searchParams
-    return Response.json({ provider, redirect_uri }, { status: 302 })
-  },
-  config
-)
-```
-
-If validation fails, the helper throws an informative error before your handler executes.
-
-**Middlewares.** Provide async middleware functions to read or modify the request.
-
-```ts
-import { createRouter, type GlobalMiddleware } from "@aura-stack/router"
-
-const audit: GlobalMiddleware = async (request) => {
-  request.headers.set("x-request-id", crypto.randomUUID())
-  return request
-}
-
-const router = createRouter([oauth], { middlewares: [audit] })
-```
-
-## API Reference
-
-| Function                                          | Description                                                                |
-| ------------------------------------------------- | -------------------------------------------------------------------------- |
-| `createEndpoint(method, route, handler, config?)` | Define a type-safe endpoint with optional validation and middlewares.      |
-| `createEndpointConfig(config)`                    | Helper that preserves Zod inference for endpoint schemas.                  |
-| `createRouter(endpoints, config?)`                | Build a router that dispatches native Fetch requests to the right handler. |
+<p align="center">
+  Made with ❤️ by <a href="https://github.com/aura-stack-js">Aura Stack team</a>
+</p>

package/dist/assert.cjs

@@ -20,19 +20,72 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/assert.ts
 var assert_exports = {};
 __export(assert_exports, {
+  isRouterError: () => isRouterError,
   isSupportedBodyMethod: () => isSupportedBodyMethod,
   isSupportedMethod: () => isSupportedMethod,
   isValidHandler: () => isValidHandler,
-  isValidRoute: () => isValidRoute
+  isValidRoute: () => isValidRoute,
+  supportedProtocols: () => supportedProtocols
 });
 module.exports = __toCommonJS(assert_exports);
-var supportedMethods = ["GET", "POST", "DELETE", "PUT", "PATCH"];
-var supportedBodyMethods = ["POST", "PUT", "PATCH"];
+
+// src/error.ts
+var statusCode = {
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NO_CONTENT: 204,
+  MULTIPLE_CHOICES: 300,
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  SEE_OTHER: 303,
+  NOT_MODIFIED: 304,
+  TEMPORARY_REDIRECT: 307,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  NOT_ACCEPTABLE: 406,
+  PROXY_AUTHENTICATION_REQUIRED: 407,
+  UNPROCESSABLE_ENTITY: 422,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  HTTP_VERSION_NOT_SUPPORTED: 505
+};
+var statusText = Object.keys(statusCode).reduce(
+  (previous, status) => {
+    return { ...previous, [status]: status };
+  },
+  {}
+);
+var AuraStackRouterError = class extends Error {
+  constructor(type, message, name) {
+    super(message);
+    this.name = name ?? "RouterError";
+    this.status = statusCode[type];
+    this.statusText = statusText[type];
+  }
+};
+var RouterError = class extends AuraStackRouterError {
+  constructor(type, message, name) {
+    super(type, message, name);
+    this.name = name ?? "RouterError";
+  }
+};
+
+// src/assert.ts
+var supportedMethods = /* @__PURE__ */ new Set(["GET", "POST", "DELETE", "PUT", "PATCH", "OPTIONS", "HEAD", "TRACE", "CONNECT"]);
+var supportedBodyMethods = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH"]);
+var supportedProtocols = /* @__PURE__ */ new Set(["http:", "https:"]);
 var isSupportedMethod = (method) => {
-  return supportedMethods.includes(method);
+  return supportedMethods.has(method);
 };
 var isSupportedBodyMethod = (method) => {
-  return supportedBodyMethods.includes(method);
+  return supportedBodyMethods.has(method);
 };
 var isValidRoute = (route) => {
   const routePattern = /^\/[a-zA-Z0-9/_:-]*$/;
@@ -41,10 +94,15 @@ var isValidRoute = (route) => {
 var isValidHandler = (handler) => {
   return typeof handler === "function";
 };
+var isRouterError = (error) => {
+  return error instanceof RouterError;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  isRouterError,
   isSupportedBodyMethod,
   isSupportedMethod,
   isValidHandler,
-  isValidRoute
+  isValidRoute,
+  supportedProtocols
 });

package/dist/assert.d.cts

@@ -1,6 +1,8 @@
+import { RouterError } from './error.cjs';
 import { HTTPMethod, RoutePattern, RouteHandler } from './types.cjs';
 import 'zod';
 
+declare const supportedProtocols: Set<string>;
 /**
  * Checks if the provided method is a supported HTTP method.
  *
@@ -28,5 +30,23 @@ declare const isValidRoute: (route: string) => route is RoutePattern;
  * @returns True if the handler is valid, false otherwise.
  */
 declare const isValidHandler: (handler: unknown) => handler is RouteHandler<any, any>;
+/**
+ * Asserts that the error is an instance of RouterError. It is useful if you want
+ * to check if the error thrown by the router is an RouterError or by other sources.
+ *
+ * @param error - The error to check
+ * @returns True if the error is an instance of RouterError, false otherwise.
+ * @example
+ * import { isRouterError } from "aura-stack/router";
+ *
+ * try {
+ *   // Some router operation that may throw an error
+ * } catch (error) {
+ *  if (isRouterError(error)) {
+ *    // Handle RouterError
+ *  }
+ * }
+ */
+declare const isRouterError: (error: unknown) => error is RouterError;
 
-export { isSupportedBodyMethod, isSupportedMethod, isValidHandler, isValidRoute };
+export { isRouterError, isSupportedBodyMethod, isSupportedMethod, isValidHandler, isValidRoute, supportedProtocols };

package/dist/assert.d.ts

@@ -1,6 +1,8 @@
+import { RouterError } from './error.js';
 import { HTTPMethod, RoutePattern, RouteHandler } from './types.js';
 import 'zod';
 
+declare const supportedProtocols: Set<string>;
 /**
  * Checks if the provided method is a supported HTTP method.
  *
@@ -28,5 +30,23 @@ declare const isValidRoute: (route: string) => route is RoutePattern;
  * @returns True if the handler is valid, false otherwise.
  */
 declare const isValidHandler: (handler: unknown) => handler is RouteHandler<any, any>;
+/**
+ * Asserts that the error is an instance of RouterError. It is useful if you want
+ * to check if the error thrown by the router is an RouterError or by other sources.
+ *
+ * @param error - The error to check
+ * @returns True if the error is an instance of RouterError, false otherwise.
+ * @example
+ * import { isRouterError } from "aura-stack/router";
+ *
+ * try {
+ *   // Some router operation that may throw an error
+ * } catch (error) {
+ *  if (isRouterError(error)) {
+ *    // Handle RouterError
+ *  }
+ * }
+ */
+declare const isRouterError: (error: unknown) => error is RouterError;
 
-export { isSupportedBodyMethod, isSupportedMethod, isValidHandler, isValidRoute };
+export { isRouterError, isSupportedBodyMethod, isSupportedMethod, isValidHandler, isValidRoute, supportedProtocols };

package/dist/assert.js

@@ -1,12 +1,17 @@
 import {
+  isRouterError,
   isSupportedBodyMethod,
   isSupportedMethod,
   isValidHandler,
-  isValidRoute
-} from "./chunk-ENOBC3XN.js";
+  isValidRoute,
+  supportedProtocols
+} from "./chunk-JNMXLKDG.js";
+import "./chunk-GJC3ODME.js";
 export {
+  isRouterError,
   isSupportedBodyMethod,
   isSupportedMethod,
   isValidHandler,
-  isValidRoute
+  isValidRoute,
+  supportedProtocols
 };

package/dist/chunk-6PZEXNTS.js

@@ -0,0 +1,31 @@
+import {
+  isSupportedMethod,
+  isValidHandler,
+  isValidRoute
+} from "./chunk-JNMXLKDG.js";
+import {
+  RouterError
+} from "./chunk-GJC3ODME.js";
+
+// src/endpoint.ts
+var createEndpoint = (method, route, handler, config = {}) => {
+  if (!isSupportedMethod(method)) {
+    throw new RouterError("METHOD_NOT_ALLOWED", `Unsupported HTTP method: ${method}`);
+  }
+  if (!isValidRoute(route)) {
+    throw new RouterError("BAD_REQUEST", `Invalid route format: ${route}`);
+  }
+  if (!isValidHandler(handler)) {
+    throw new RouterError("BAD_REQUEST", "Handler must be a function");
+  }
+  return { method, route, handler, config };
+};
+function createEndpointConfig(...args) {
+  if (typeof args[0] === "string") return args[1];
+  return args[0];
+}
+
+export {
+  createEndpoint,
+  createEndpointConfig
+};

package/dist/{chunk-RVJ2F7OL.js → chunk-FWDOXDWG.js}

@@ -1,13 +1,13 @@
 import {
-  AuraStackRouterError
-} from "./chunk-RFYOPPMW.js";
+  RouterError
+} from "./chunk-GJC3ODME.js";
 
-// src/middleware.ts
+// src/middlewares.ts
 var executeGlobalMiddlewares = async (request, middlewares) => {
   if (!middlewares) return request;
   for (const middleware of middlewares) {
     if (typeof middleware !== "function") {
-      throw new AuraStackRouterError("BAD_REQUEST", "Global middlewares must be functions");
+      throw new RouterError("BAD_REQUEST", "Global middlewares must be functions");
     }
     const executed = await middleware(request);
     if (executed instanceof Response) {
@@ -16,7 +16,7 @@ var executeGlobalMiddlewares = async (request, middlewares) => {
     request = executed;
   }
   if (!request || !(request instanceof Request)) {
-    throw new AuraStackRouterError("BAD_REQUEST", "Global middleware must return a Request or Response object");
+    throw new RouterError("BAD_REQUEST", "Global middleware must return a Request or Response object");
   }
   return request;
 };
@@ -25,13 +25,13 @@ var executeMiddlewares = async (request, context, middlewares = []) => {
     let ctx = context;
     for (const middleware of middlewares) {
       if (typeof middleware !== "function") {
-        throw new AuraStackRouterError("BAD_REQUEST", "Middleware must be a function");
+        throw new RouterError("BAD_REQUEST", "Middleware must be a function");
       }
       ctx = await middleware(request, ctx);
     }
     return ctx;
   } catch {
-    throw new AuraStackRouterError("BAD_REQUEST", "Handler threw an error");
+    throw new RouterError("BAD_REQUEST", "Handler threw an error");
   }
 };
 

package/dist/{chunk-RFYOPPMW.js → chunk-GJC3ODME.js}

@@ -25,21 +25,30 @@ var statusCode = {
   SERVICE_UNAVAILABLE: 503,
   HTTP_VERSION_NOT_SUPPORTED: 505
 };
-var statusText = Object.entries(statusCode).reduce(
-  (previous, [status, code]) => {
-    return { ...previous, [code]: status };
+var statusText = Object.keys(statusCode).reduce(
+  (previous, status) => {
+    return { ...previous, [status]: status };
   },
   {}
 );
 var AuraStackRouterError = class extends Error {
   constructor(type, message, name) {
     super(message);
-    this.name = name ?? "AuraStackRouterError";
+    this.name = name ?? "RouterError";
     this.status = statusCode[type];
-    this.statusText = statusText[this.status];
+    this.statusText = statusText[type];
+  }
+};
+var RouterError = class extends AuraStackRouterError {
+  constructor(type, message, name) {
+    super(type, message, name);
+    this.name = name ?? "RouterError";
   }
 };
 
 export {
-  AuraStackRouterError
+  statusCode,
+  statusText,
+  AuraStackRouterError,
+  RouterError
 };

package/dist/chunk-JIA6NLL6.js

@@ -0,0 +1,143 @@
+import {
+  getBody,
+  getHeaders,
+  getRouteParams,
+  getSearchParams
+} from "./chunk-PT4GU6PH.js";
+import {
+  isRouterError,
+  isSupportedMethod
+} from "./chunk-JNMXLKDG.js";
+import {
+  executeGlobalMiddlewares,
+  executeMiddlewares
+} from "./chunk-FWDOXDWG.js";
+import {
+  RouterError,
+  statusText
+} from "./chunk-GJC3ODME.js";
+
+// src/router.ts
+var createNode = () => ({
+  statics: /* @__PURE__ */ new Map(),
+  endpoints: /* @__PURE__ */ new Map()
+});
+var insert = (root, endpoint) => {
+  if (!root || !endpoint) return;
+  let node = root;
+  const segments = endpoint.route === "/" ? [] : endpoint.route.split("/").filter(Boolean);
+  for (const segment of segments) {
+    if (segment.startsWith(":")) {
+      const name = segment.slice(1);
+      if (!node.param) {
+        node.param = { name, node: createNode() };
+      } else if (node.param.name !== name) {
+        throw new RouterError(
+          "BAD_REQUEST",
+          `Conflicting in the route by the dynamic segment "${node.param.name}" and "${name}"`
+        );
+      }
+      node = node.param.node;
+    } else {
+      if (!node.statics.has(segment)) {
+        node.statics.set(segment, createNode());
+      }
+      node = node.statics.get(segment);
+    }
+  }
+  if (node.endpoints.has(endpoint.method)) {
+    throw new RouterError("BAD_REQUEST", `Duplicate endpoint for ${endpoint?.method} ${endpoint?.route}`);
+  }
+  node.endpoints.set(endpoint.method, endpoint);
+};
+var search = (method, root, pathname) => {
+  let node = root;
+  const params = {};
+  const segments = pathname === "/" ? [] : pathname.split("/").filter(Boolean);
+  for (const segment of segments) {
+    if (node?.statics.has(segment)) {
+      node = node.statics.get(segment);
+    } else if (node?.param) {
+      params[node.param.name] = decodeURIComponent(segment);
+      node = node.param.node;
+    } else {
+      throw new RouterError("NOT_FOUND", `No route found for path: ${pathname}`);
+    }
+  }
+  if (!node.endpoints.has(method)) {
+    throw new RouterError("NOT_FOUND", `No route found for path: ${pathname}`);
+  }
+  return { endpoint: node.endpoints.get(method), params };
+};
+var handleError = async (error, request, config) => {
+  if (config.onError) {
+    try {
+      const response = await config.onError(error, request);
+      return response;
+    } catch {
+      return Response.json(
+        { message: "A critical failure occurred during error handling" },
+        { status: 500, statusText: statusText.INTERNAL_SERVER_ERROR }
+      );
+    }
+  }
+  if (isRouterError(error)) {
+    const { message, status, statusText: statusText2 } = error;
+    return Response.json({ message }, { status, statusText: statusText2 });
+  }
+  return Response.json({ message: "Internal Server Error" }, { status: 500, statusText: statusText.INTERNAL_SERVER_ERROR });
+};
+var handleRequest = async (method, request, config, root) => {
+  try {
+    if (!isSupportedMethod(request.method)) {
+      throw new RouterError("METHOD_NOT_ALLOWED", `The HTTP method '${request.method}' is not supported`);
+    }
+    const globalRequest = await executeGlobalMiddlewares(request, config.middlewares);
+    if (globalRequest instanceof Response) return globalRequest;
+    const url = new URL(globalRequest.url);
+    const pathnameWithBase = url.pathname;
+    if (globalRequest.method !== method) {
+      throw new RouterError("METHOD_NOT_ALLOWED", `The HTTP method '${globalRequest.method}' is not allowed`);
+    }
+    const { endpoint, params } = search(method, root, pathnameWithBase);
+    if (endpoint.method !== globalRequest.method) {
+      throw new RouterError("METHOD_NOT_ALLOWED", `The HTTP method '${globalRequest.method}' is not allowed`);
+    }
+    const dynamicParams = getRouteParams(params, endpoint.config);
+    const body = await getBody(globalRequest, endpoint.config);
+    const searchParams = getSearchParams(globalRequest.url, endpoint.config);
+    const headers = getHeaders(globalRequest);
+    const context = {
+      params: dynamicParams,
+      searchParams,
+      headers,
+      body
+    };
+    await executeMiddlewares(globalRequest, context, endpoint.config.middlewares);
+    const response = await endpoint.handler(globalRequest, context);
+    return response;
+  } catch (error) {
+    return handleError(error, request, config);
+  }
+};
+var createRouter = (endpoints, config = {}) => {
+  const root = createNode();
+  const server = {};
+  const methods = /* @__PURE__ */ new Set();
+  for (const endpoint of endpoints) {
+    const withBasePath = config.basePath ? `${config.basePath}${endpoint.route}` : endpoint.route;
+    insert(root, { ...endpoint, route: withBasePath });
+    methods.add(endpoint.method);
+  }
+  for (const method of methods) {
+    server[method] = (request) => handleRequest(method, request, config, root);
+  }
+  return server;
+};
+
+export {
+  createNode,
+  insert,
+  search,
+  createRouter
+};

package/dist/chunk-JNMXLKDG.js

@@ -0,0 +1,33 @@
+import {
+  RouterError
+} from "./chunk-GJC3ODME.js";
+
+// src/assert.ts
+var supportedMethods = /* @__PURE__ */ new Set(["GET", "POST", "DELETE", "PUT", "PATCH", "OPTIONS", "HEAD", "TRACE", "CONNECT"]);
+var supportedBodyMethods = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH"]);
+var supportedProtocols = /* @__PURE__ */ new Set(["http:", "https:"]);
+var isSupportedMethod = (method) => {
+  return supportedMethods.has(method);
+};
+var isSupportedBodyMethod = (method) => {
+  return supportedBodyMethods.has(method);
+};
+var isValidRoute = (route) => {
+  const routePattern = /^\/[a-zA-Z0-9/_:-]*$/;
+  return routePattern.test(route);
+};
+var isValidHandler = (handler) => {
+  return typeof handler === "function";
+};
+var isRouterError = (error) => {
+  return error instanceof RouterError;
+};
+
+export {
+  supportedProtocols,
+  isSupportedMethod,
+  isSupportedBodyMethod,
+  isValidRoute,
+  isValidHandler,
+  isRouterError
+};