@zudojs/http 1.4.3 → 1.5.0

package/dist/httpRouter/core/factory/httpRoute.factory.base.js

@@ -139,33 +139,36 @@ export function createOptionsResponse(allowedMethods) {
  * Default handler used when no route matches a request.
  */
 export function defaultNotFoundHandler(context) {
-    return new HttpResponseContext({
-        status: 404,
-        headers: { "content-type": "application/json; charset=utf-8" },
-        body: {
-            error: "Not Found",
-            method: context.method,
-            path: context.path,
-        },
+    return jsonErrorResponse(404, {
+        error: "Not Found",
+        code: "NOT_FOUND",
+        method: context.method,
+        path: context.path,
     });
 }
 /**
  * Default handler used when a path matches but the method does not.
  */
 export function defaultMethodNotAllowedHandler(context, allowedMethods) {
-    return new HttpResponseContext({
-        status: 405,
-        headers: {
-            allow: formatAllowHeader(allowedMethods),
-            "content-type": "application/json; charset=utf-8",
-        },
-        body: {
-            error: "Method Not Allowed",
-            method: context.method,
-            path: context.path,
-            allowed: [...allowedMethods],
-        },
-    });
+    return jsonErrorResponse(405, {
+        error: "Method Not Allowed",
+        code: "METHOD_NOT_ALLOWED",
+        method: context.method,
+        path: context.path,
+        allowed: [...allowedMethods],
+    }).setHeader("allow", formatAllowHeader(allowedMethods));
+}
+/**
+ * Builds a default error response the same way `.json()` does, so its body
+ * is the serialized string every other JSON response carries. The default
+ * 404/405 used to keep a plain object as the body while a handler's
+ * `.json()` produced a string, so `result.response.body` had two types.
+ * Every framework-built error body carries `error` and `code`.
+ */
+function jsonErrorResponse(status, body) {
+    return new HttpResponseContext({ status })
+        .json(body)
+        .setHeader("content-type", "application/json; charset=utf-8");
 }
 /* -------------------------------------------------------------------------- */
 /* Route Execution                                                            */
@@ -239,4 +242,3 @@ export async function executeRoute(route, context) {
     };
     return run(0);
 }
-//# sourceMappingURL=httpRoute.factory.base.js.map

package/dist/httpRouter/core/factory/httpRoute.factory.d.ts

@@ -15,6 +15,13 @@ export declare function createRouter(options?: RouterOptions): HttpRouter;
 export declare function createRoute(definition: RouteDefinition): RouteDefinition;
 /**
  * Builds a route path from a pattern and parameters.
+ *
+ * Handles every parameter spelling the router accepts — `:id`, `:id?`,
+ * `:id(\\d+)`, `{name}`, `{name?:\\w+}` and a trailing `*rest` — and
+ * percent-encodes each value (a wildcard value segment by segment). An
+ * omitted optional parameter no longer leaves a trailing slash
+ * (`/reports/2026/`), and a missing required parameter throws
+ * {@link HttpRouterError} rather than a plain `Error`.
  */
 export declare function buildRoutePath(pattern: string, params?: Readonly<Record<string, string | number>>): string;
 /**
@@ -33,4 +40,3 @@ export declare function isRouteConflictError(value: unknown): value is RouteConf
  * Type guard for InvalidRoutePatternError instances.
  */
 export declare function isInvalidRoutePatternError(value: unknown): value is InvalidRoutePatternError;
-//# sourceMappingURL=httpRoute.factory.d.ts.map

package/dist/httpRouter/core/factory/httpRoute.factory.js

@@ -3,7 +3,7 @@
  */
 import { HttpRouter } from "../register/httpRouter.register.js";
 import { HttpRouterGroup } from "../group/httpRouterGroup.core.js";
-import { RouteConflictError, InvalidRoutePatternError, } from "../error/httpRouter.error.js";
+import { HttpRouterError, RouteConflictError, InvalidRoutePatternError, } from "../error/httpRouter.error.js";
 import { normalizeRoutePattern } from "../util/httpRoute.util.js";
 /**
  * Creates a new HTTP router instance.
@@ -24,21 +24,45 @@ export function createRoute(definition) {
 }
 /**
  * Builds a route path from a pattern and parameters.
+ *
+ * Handles every parameter spelling the router accepts — `:id`, `:id?`,
+ * `:id(\\d+)`, `{name}`, `{name?:\\w+}` and a trailing `*rest` — and
+ * percent-encodes each value (a wildcard value segment by segment). An
+ * omitted optional parameter no longer leaves a trailing slash
+ * (`/reports/2026/`), and a missing required parameter throws
+ * {@link HttpRouterError} rather than a plain `Error`.
  */
 export function buildRoutePath(pattern, params = {}) {
     const normalized = normalizeRoutePattern(pattern);
-    return normalized
-        .replace(/:([a-zA-Z_][a-zA-Z0-9_-]*)(\?)?/g, (_match, name, optional) => {
-        const value = params[name];
-        if (value === undefined || value === null) {
-            if (optional) {
-                return "";
-            }
-            throw new Error(`Missing route parameter "${name}".`);
+    const segments = normalized
+        .split("/")
+        .filter((segment) => segment !== "")
+        .map((segment) => buildSegment(segment, params))
+        .filter((segment) => segment !== undefined);
+    return `/${segments.join("/")}`;
+}
+const COLON_PARAMETER = /^:([a-zA-Z_][a-zA-Z0-9_-]*)(?:\(.*\))?(\?)?$/;
+const BRACE_PARAMETER = /^\{([a-zA-Z_][a-zA-Z0-9_-]*)(\?)?(?::.+)?\}$/;
+function buildSegment(segment, params) {
+    if (segment.startsWith("*")) {
+        const value = params[segment.slice(1) || "*"];
+        return value === undefined
+            ? undefined
+            : String(value).split("/").map(encodeURIComponent).join("/");
+    }
+    const match = COLON_PARAMETER.exec(segment) ?? BRACE_PARAMETER.exec(segment);
+    if (!match) {
+        return segment;
+    }
+    const [, name, optional] = match;
+    const value = name === undefined ? undefined : params[name];
+    if (value === undefined || value === null) {
+        if (optional) {
+            return undefined;
         }
-        return encodeURIComponent(String(value));
-    })
-        .replace(/\/+/g, "/");
+        throw new HttpRouterError(`Missing route parameter "${name}".`);
+    }
+    return encodeURIComponent(String(value));
 }
 /**
  * Type guard for HttpRouter instances.
@@ -64,4 +88,3 @@ export function isRouteConflictError(value) {
 export function isInvalidRoutePatternError(value) {
     return value instanceof InvalidRoutePatternError;
 }
-//# sourceMappingURL=httpRoute.factory.js.map

package/dist/httpRouter/core/factory/index.d.ts

@@ -5,4 +5,3 @@
  */
 export * from "./httpRoute.factory.js";
 export * from "./httpRoute.factory.base.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/httpRouter/core/factory/index.js

@@ -5,4 +5,3 @@
  */
 export * from "./httpRoute.factory.js";
 export * from "./httpRoute.factory.base.js";
-//# sourceMappingURL=index.js.map

package/dist/httpRouter/core/group/httpRouterGroup.core.d.ts

@@ -24,4 +24,3 @@ export declare class HttpRouterGroup {
     private resolve;
     private mergeOptions;
 }
-//# sourceMappingURL=httpRouterGroup.core.d.ts.map

package/dist/httpRouter/core/group/httpRouterGroup.core.js

@@ -78,4 +78,3 @@ function openAPIOf(options) {
     return options.openapi ??
         options.metadata?.["openapi"];
 }
-//# sourceMappingURL=httpRouterGroup.core.js.map

package/dist/httpRouter/core/group/index.d.ts

@@ -4,4 +4,3 @@
  * HTTP router group utilities.
  */
 export * from "./httpRouterGroup.core.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/httpRouter/core/group/index.js

@@ -4,4 +4,3 @@
  * HTTP router group utilities.
  */
 export * from "./httpRouterGroup.core.js";
-//# sourceMappingURL=index.js.map

package/dist/httpRouter/core/index.d.ts

@@ -10,4 +10,3 @@ export * from "./error/index.js";
 export * from "./group/index.js";
 export * from "./register/index.js";
 export * from "./util/index.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/httpRouter/core/index.js

@@ -10,4 +10,3 @@ export * from "./error/index.js";
 export * from "./group/index.js";
 export * from "./register/index.js";
 export * from "./util/index.js";
-//# sourceMappingURL=index.js.map

package/dist/httpRouter/core/register/httpRouter.register.d.ts

@@ -6,6 +6,13 @@ import type { HttpRequestContext as RequestContext } from "../../../httpRequest/
 import { HttpRouterGroup } from "../group/httpRouterGroup.core.js";
 export declare class HttpRouter {
     private readonly routes;
+    /**
+     * The routes in matching order. Rebuilt lazily after a registration or
+     * removal; `match()` used to copy and sort every route on every request.
+     */
+    private sortedCache;
+    private readonly shadowedRoutes;
+    private readonly errorHandler;
     private readonly routerOptions;
     private readonly notFoundHandler;
     private readonly methodNotAllowedHandler;
@@ -35,11 +42,18 @@ export declare class HttpRouter {
     compiled(): readonly CompiledRoute[];
     find(id: string): MatchedRoute | undefined;
     match(method: string, path: string): RouterMatch;
+    private withAutomaticMethods;
     dispatch(request: RequestContext, options?: {
         readonly signal?: AbortSignal;
         readonly state?: Map<string, unknown>;
     }): Promise<RouterResult>;
     private register;
+    /**
+     * Refuses a registration that leaves a route unreachable: the new route
+     * when an earlier-ranked route already matches everything it would, or an
+     * existing route the new one would rank ahead of and fully cover.
+     */
+    private assertReachable;
+    private compareRoutes;
     private sortedRoutes;
 }
-//# sourceMappingURL=httpRouter.register.d.ts.map

package/dist/httpRouter/core/register/httpRouter.register.js

@@ -3,13 +3,21 @@
  */
 import { HttpRouterError, RouteConflictError, } from "../error/httpRouter.error.js";
 import { HttpRouterGroup } from "../group/httpRouterGroup.core.js";
-import { collectAllowedMethods, createFallbackRoute, createOptionsResponse, defaultMethodNotAllowedHandler, defaultNotFoundHandler, executeRoute, extractRouteSequence, isHttpMethod, normalizeMethod, normalizeMethods, normalizeResponse, } from "../factory/httpRoute.factory.base.js";
+import { collectAllowedMethods, createFallbackRoute, createOptionsResponse, defaultMethodNotAllowedHandler, defaultNotFoundHandler, executeRoute, extractRouteSequence, normalizeMethod, normalizeMethods, normalizeResponse, } from "../factory/httpRoute.factory.base.js";
 import { getRequestMethod, getRequestSignal, applyRouteParams, getRequestUrl, normalizeMatchPath, normalizePath, normalizeRoutePattern, parseQuery, parseUrl, } from "../util/httpRoute.util.js";
 import { matchCompiledRoute } from "../../matching/httpRoute.matcher.core.js";
 import { compareSegmentSpecificity, compileRoute, } from "../../pattern/httpRoute.pattern.parse.js";
 import { createRouterMiddlewareContext } from "../../httpRouter.context.js";
+import { shadowsRoute } from "./httpRouter.shadow.js";
 export class HttpRouter {
     routes = [];
+    /**
+     * The routes in matching order. Rebuilt lazily after a registration or
+     * removal; `match()` used to copy and sort every route on every request.
+     */
+    sortedCache;
+    shadowedRoutes;
+    errorHandler;
     routerOptions;
     notFoundHandler;
     methodNotAllowedHandler;
@@ -24,6 +32,8 @@ export class HttpRouter {
         this.notFoundHandler = options.notFoundHandler ?? defaultNotFoundHandler;
         this.methodNotAllowedHandler =
             options.methodNotAllowedHandler ?? defaultMethodNotAllowedHandler;
+        this.shadowedRoutes = options.shadowedRoutes ?? "throw";
+        this.errorHandler = options.onError;
     }
     /* ------------------------------------------------------------------------ */
     /* Route Registration                                                       */
@@ -96,10 +106,12 @@ export class HttpRouter {
             return false;
         }
         this.routes.splice(index, 1);
+        this.sortedCache = undefined;
         return true;
     }
     clear() {
         this.routes.length = 0;
+        this.sortedCache = undefined;
     }
     count() {
         return this.routes.length;
@@ -125,8 +137,7 @@ export class HttpRouter {
         const normalizedPath = normalizePath(path);
         const matchPath = normalizeMatchPath(path);
         const candidates = this.sortedRoutes();
-        const allowedForPath = () => collectAllowedMethods(candidates, matchPath, this.routerOptions.caseSensitive);
-        const allowed = new Set();
+        const allowedForPath = () => this.withAutomaticMethods(collectAllowedMethods(candidates, matchPath, this.routerOptions.caseSensitive));
         let pathMatched = false;
         for (const route of candidates) {
             const params = matchCompiledRoute(route, matchPath, this.routerOptions.caseSensitive);
@@ -140,14 +151,11 @@ export class HttpRouter {
                     matched: true,
                     route: route.definition,
                     params,
-                    allowedMethods: Object.freeze([...allowedForPath()]),
+                    allowedMethods: Object.freeze(allowedForPath()),
                     path: normalizedPath,
                     method: normalizedMethod,
                 };
             }
-            if (isHttpMethod(routeMethod)) {
-                allowed.add(routeMethod);
-            }
         }
         if (normalizedMethod === "HEAD" && this.routerOptions.automaticHead) {
             for (const route of candidates) {
@@ -160,7 +168,7 @@ export class HttpRouter {
                         matched: true,
                         route: route.definition,
                         params,
-                        allowedMethods: Object.freeze([...allowedForPath(), "HEAD"]),
+                        allowedMethods: Object.freeze(allowedForPath()),
                         path: normalizedPath,
                         method: normalizedMethod,
                     };
@@ -174,20 +182,39 @@ export class HttpRouter {
                 matched: true,
                 route: undefined,
                 params: {},
-                allowedMethods: Object.freeze([...allowedForPath(), "OPTIONS"]),
+                allowedMethods: Object.freeze(allowedForPath()),
                 path: normalizedPath,
                 method: normalizedMethod,
             };
         }
+        /*
+         * The methods a `405` advertises must be the ones the router actually
+         * answers: the automatic `HEAD` (for a `GET` route) and `OPTIONS` were
+         * left out, so `Allow: GET, PATCH` contradicted the `OPTIONS` response
+         * for the same path.
+         */
         return {
             matched: false,
             route: undefined,
             params: {},
-            allowedMethods: Object.freeze([...allowed]),
+            allowedMethods: Object.freeze(pathMatched ? allowedForPath() : []),
             path: normalizedPath,
             method: normalizedMethod,
         };
     }
+    withAutomaticMethods(methods) {
+        const result = new Set(methods);
+        if (result.size === 0) {
+            return [];
+        }
+        if (this.routerOptions.automaticHead && result.has("GET")) {
+            result.add("HEAD");
+        }
+        if (this.routerOptions.automaticOptions) {
+            result.add("OPTIONS");
+        }
+        return [...result];
+    }
     /* ------------------------------------------------------------------------ */
     /* Dispatch                                                                 */
     /* ------------------------------------------------------------------------ */
@@ -213,11 +240,34 @@ export class HttpRouter {
         };
         if (match.matched && match.route) {
             applyRouteParams(request, match.params);
-            const response = await executeRoute(match.route, routerContext);
-            return {
-                response: await normalizeResponse(response),
-                route: match.route,
-            };
+            try {
+                const response = await executeRoute(match.route, routerContext);
+                return {
+                    response: await normalizeResponse(response),
+                    route: match.route,
+                };
+            }
+            catch (error) {
+                if (!this.errorHandler) {
+                    throw error;
+                }
+                const handled = await this.errorHandler(error, {
+                    request,
+                    path,
+                    method,
+                    signal,
+                    state,
+                    route: match.route,
+                });
+                if (handled === undefined) {
+                    throw error;
+                }
+                return {
+                    response: await normalizeResponse(handled),
+                    route: match.route,
+                    error,
+                };
+            }
         }
         if (method.toUpperCase() === "OPTIONS" &&
             match.allowedMethods.length > 0 &&
@@ -282,26 +332,74 @@ export class HttpRouter {
             handler,
             middleware: Object.freeze([...(options.middleware ?? [])]),
         };
-        this.routes.push({
+        const route = {
             definition,
             segments: compiled.segments,
             score: compiled.score,
             strictTrailingSlash: compiled.strictTrailingSlash,
             expectsTrailingSlash: compiled.expectsTrailingSlash,
-        });
+        };
+        if (this.shadowedRoutes === "throw") {
+            this.assertReachable(route);
+        }
+        this.routes.push(route);
+        this.sortedCache = undefined;
         return () => {
             this.remove(normalizedMethod, normalizedPath);
         };
     }
-    sortedRoutes() {
-        return [...this.routes].sort((left, right) => {
-            const specificity = compareSegmentSpecificity(left.segments, right.segments);
-            if (specificity !== 0) {
-                return specificity;
+    /**
+     * Refuses a registration that leaves a route unreachable: the new route
+     * when an earlier-ranked route already matches everything it would, or an
+     * existing route the new one would rank ahead of and fully cover.
+     */
+    assertReachable(candidate) {
+        for (const existing of this.routes) {
+            const existingFirst = this.compareRoutes(existing, candidate) < 0;
+            const [first, second] = existingFirst
+                ? [existing, candidate]
+                : [candidate, existing];
+            if (!shadowsRoute(first, second, this.routerOptions.caseSensitive)) {
+                continue;
             }
-            return (extractRouteSequence(left.definition.id) -
-                extractRouteSequence(right.definition.id));
-        });
+            throw shadowedRouteError(second, first);
+        }
     }
+    compareRoutes(left, right) {
+        const specificity = compareSegmentSpecificity(left.segments, right.segments);
+        if (specificity !== 0) {
+            return specificity;
+        }
+        /*
+         * At equal specificity a method-specific route is tried before an
+         * `all()` route, so `all("/x/:id")` no longer swallows a later
+         * `get("/x/:id")`.
+         */
+        const leftAny = left.definition.method === "*" ? 1 : 0;
+        const rightAny = right.definition.method === "*" ? 1 : 0;
+        if (leftAny !== rightAny) {
+            return leftAny - rightAny;
+        }
+        return (extractRouteSequence(left.definition.id) -
+            extractRouteSequence(right.definition.id));
+    }
+    sortedRoutes() {
+        if (this.sortedCache === undefined) {
+            this.sortedCache = [...this.routes].sort((left, right) => this.compareRoutes(left, right));
+        }
+        return this.sortedCache;
+    }
+}
+/**
+ * Builds the conflict error for a shadowed route, naming the route that
+ * shadows it in both the message and `reason`.
+ */
+function shadowedRouteError(shadowed, by) {
+    return new RouteConflictError(shadowed.definition.path, shadowed.definition.method, {
+        reason: `shadowed by ${by.definition.method} ${by.definition.path}`,
+        message: `Route ${shadowed.definition.method} ${shadowed.definition.path} can ` +
+            `never match: ${by.definition.method} ${by.definition.path} is tried ` +
+            "first and matches every request it would. Pass " +
+            '{ shadowedRoutes: "ignore" } to register it anyway.',
+    });
 }
-//# sourceMappingURL=httpRouter.register.js.map

package/dist/httpRouter/core/register/httpRouter.shadow.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Route shadow detection: a route at least as general as one tried before
+ * it, for the same method, can never be reached. Only an exact duplicate
+ * used to be refused, so `/x/:id` followed by `/x/:slug` registered without
+ * complaint and the second handler never ran.
+ */
+import type { CompiledRoute } from "../types/httpRouter.type.js";
+/**
+ * Whether `first`, which the router tries before `second`, matches every
+ * request `second` matches, leaving `second` unreachable. Deliberately
+ * conservative: only a shadow provable from the two patterns alone is
+ * reported, so `/x/:id(\\d+)` before `/x/:slug` never is.
+ *
+ * @param first - The route tried first.
+ * @param second - The route tried afterwards.
+ * @param caseSensitive - The router's literal comparison mode.
+ */
+export declare function shadowsRoute(first: CompiledRoute, second: CompiledRoute, caseSensitive: boolean): boolean;

package/dist/httpRouter/core/register/httpRouter.shadow.js

@@ -0,0 +1,91 @@
+/**
+ * Route shadow detection: a route at least as general as one tried before
+ * it, for the same method, can never be reached. Only an exact duplicate
+ * used to be refused, so `/x/:id` followed by `/x/:slug` registered without
+ * complaint and the second handler never ran.
+ */
+/**
+ * Whether `first`, which the router tries before `second`, matches every
+ * request `second` matches, leaving `second` unreachable. Deliberately
+ * conservative: only a shadow provable from the two patterns alone is
+ * reported, so `/x/:id(\\d+)` before `/x/:slug` never is.
+ *
+ * @param first - The route tried first.
+ * @param second - The route tried afterwards.
+ * @param caseSensitive - The router's literal comparison mode.
+ */
+export function shadowsRoute(first, second, caseSensitive) {
+    if (!methodCovers(first.definition.method, second.definition.method)) {
+        return false;
+    }
+    if (first.strictTrailingSlash !== second.strictTrailingSlash) {
+        return false;
+    }
+    if (first.strictTrailingSlash &&
+        (first.expectsTrailingSlash ?? false) !==
+            (second.expectsTrailingSlash ?? false)) {
+        return false;
+    }
+    return segmentsCover(first.segments, second.segments, caseSensitive);
+}
+function methodCovers(first, second) {
+    return first === "*" || first === second;
+}
+function segmentsCover(first, second, caseSensitive) {
+    const length = Math.max(first.length, second.length);
+    for (let index = 0; index < length; index += 1) {
+        const left = first[index];
+        const right = second[index];
+        if (left === undefined) {
+            return false;
+        }
+        if (left.type === "wildcard") {
+            return true;
+        }
+        if (right === undefined) {
+            return tailMatchesNothing(first, index);
+        }
+        if (!segmentCovers(left, right, caseSensitive)) {
+            return false;
+        }
+    }
+    return true;
+}
+function tailMatchesNothing(segments, start) {
+    for (let index = start; index < segments.length; index += 1) {
+        const segment = segments[index];
+        if (segment === undefined || segment.type === "wildcard") {
+            continue;
+        }
+        if (segment.type === "literal" || !segment.optional) {
+            return false;
+        }
+    }
+    return true;
+}
+function segmentCovers(left, right, caseSensitive) {
+    if (right.type === "wildcard") {
+        return false;
+    }
+    if (left.type === "literal") {
+        return (right.type === "literal" &&
+            (caseSensitive
+                ? left.value === right.value
+                : left.value.toLowerCase() === right.value.toLowerCase()));
+    }
+    if (right.type === "literal") {
+        return left.pattern === undefined || left.pattern.test(right.value);
+    }
+    if (right.optional && !left.optional) {
+        return false;
+    }
+    return constraintCovers(left, right);
+}
+function constraintCovers(left, right) {
+    if (left.pattern === undefined) {
+        return true;
+    }
+    return (right.pattern !== undefined &&
+        right.pattern.source === left.pattern.source &&
+        right.pattern.flags === left.pattern.flags);
+}

package/dist/httpRouter/core/register/index.d.ts

@@ -4,4 +4,4 @@
  * HTTP route registration utilities.
  */
 export * from "./httpRouter.register.js";
-//# sourceMappingURL=index.d.ts.map
+export * from "./httpRouter.shadow.js";

package/dist/httpRouter/core/register/index.js

@@ -4,4 +4,4 @@
  * HTTP route registration utilities.
  */
 export * from "./httpRouter.register.js";
-//# sourceMappingURL=index.js.map
+export * from "./httpRouter.shadow.js";

package/dist/httpRouter/core/registry/core/httpRegistry.helper.d.ts

@@ -31,4 +31,3 @@ export declare function matchesLookup(entry: RouteRegistryEntry, path: string, m
  */
 export declare function extractSequence(path: string): number;
 export {};
-//# sourceMappingURL=httpRegistry.helper.d.ts.map

package/dist/httpRouter/core/registry/core/httpRegistry.helper.js

@@ -66,4 +66,3 @@ export function extractSequence(path) {
     const sequence = /:(\d+)/.exec(path)?.[1];
     return sequence === undefined ? 0 : parseInt(sequence, 10);
 }
-//# sourceMappingURL=httpRegistry.helper.js.map

package/dist/httpRouter/core/registry/core/httpRegistry.type.d.ts

@@ -30,4 +30,3 @@ export interface RouteRegistrySnapshot {
     readonly timestamp: number;
     readonly version: number;
 }
-//# sourceMappingURL=httpRegistry.type.d.ts.map

package/dist/httpRouter/core/registry/core/httpRegistry.type.js

@@ -4,4 +4,3 @@
  * @module httpRoute/registry/types
  */
 export {};
-//# sourceMappingURL=httpRegistry.type.js.map

package/dist/httpRouter/core/registry/core/index.d.ts

@@ -5,4 +5,3 @@
  */
 export * from "./httpRegistry.type.js";
 export * from "./httpRegistry.helper.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/httpRouter/core/registry/core/index.js

@@ -5,4 +5,3 @@
  */
 export * from "./httpRegistry.type.js";
 export * from "./httpRegistry.helper.js";
-//# sourceMappingURL=index.js.map

package/dist/httpRouter/core/registry/httpRegistry.core.d.ts

@@ -20,4 +20,3 @@ export declare class RouteRegistry {
     get version_number(): number;
     private createKey;
 }
-//# sourceMappingURL=httpRegistry.core.d.ts.map

package/dist/httpRouter/core/registry/httpRegistry.core.js

@@ -94,4 +94,3 @@ export class RouteRegistry {
         return `${normalizedMethod}:${normalizedPath}`;
     }
 }
-//# sourceMappingURL=httpRegistry.core.js.map