@zudojs/http 0.1.0 → 1.1.0

package/dist/httpRouter/pattern/core/httpPattern.regexBuilding.js

@@ -0,0 +1,49 @@
+/**
+ * Regex building for route patterns.
+ *
+ * @module httpRoute/pattern/regexBuilding
+ */
+/**
+ * Builds a regex from route segments.
+ */
+export function buildRegex(segments, options) {
+    let regexStr = "^";
+    for (const segment of segments) {
+        switch (segment.type) {
+            case "static":
+                regexStr += escapeRegex(segment.value);
+                break;
+            case "parameter":
+                regexStr += compileParameterExpression(segment);
+                break;
+            case "wildcard":
+                regexStr += compileWildcardExpression(segment);
+                break;
+        }
+    }
+    if (options.end !== false) {
+        /*
+         * `strict` controls trailing-slash handling: a strict pattern requires the
+         * path exactly as written, a non-strict one tolerates one trailing slash.
+         */
+        if (options.strict !== true) {
+            regexStr += "\\/?";
+        }
+        regexStr += "$";
+    }
+    const flags = options.caseSensitive ? "" : "i";
+    return new RegExp(regexStr, flags);
+}
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function compileWildcardExpression(segment) {
+    return `(?<${segment.name}>.*)`;
+}
+function compileParameterExpression(segment) {
+    if (segment.optional) {
+        return `(?<${segment.name}>[^/]*)?`;
+    }
+    return `(?<${segment.name}>[^/]+)`;
+}
+//# sourceMappingURL=httpPattern.regexBuilding.js.map

package/dist/httpRouter/pattern/core/httpPattern.segmentParsing.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Segment parsing for route patterns.
+ *
+ * @module httpRoute/pattern/segmentParsing
+ */
+import type { RouteSegment } from "./httpPattern.type.js";
+/**
+ * Parses a route pattern string into segments.
+ */
+export declare function parseSegments(pattern: string): readonly RouteSegment[];
+//# sourceMappingURL=httpPattern.segmentParsing.d.ts.map

package/dist/httpRouter/pattern/core/httpPattern.segmentParsing.js

@@ -0,0 +1,117 @@
+/**
+ * Segment parsing for route patterns.
+ *
+ * @module httpRoute/pattern/segmentParsing
+ */
+import { RoutePatternError } from "./httpPattern.type.js";
+/**
+ * Parses a route pattern string into segments.
+ */
+export function parseSegments(pattern) {
+    const segments = [];
+    let i = 0;
+    let wildcardIndex = 0;
+    while (i < pattern.length) {
+        if (pattern[i] === ":") {
+            const result = compileColonParameter(pattern, i);
+            segments.push(result.segment);
+            i = result.endIndex;
+        }
+        else if (pattern[i] === "{") {
+            const result = compileBraceParameter(pattern, i);
+            segments.push(result.segment);
+            i = result.endIndex;
+        }
+        else if (pattern[i] === "*") {
+            /*
+             * `*` is not a legal JavaScript regex group name, so a wildcard that
+             * kept it could never be captured — the compiled pattern used a plain
+             * `(.*)` and `match.groups["*"]` was always undefined. Give each
+             * wildcard a real, unique name instead.
+             */
+            segments.push({
+                type: "wildcard",
+                name: `wildcard${wildcardIndex}`,
+                optional: false,
+            });
+            wildcardIndex += 1;
+            i++;
+        }
+        else {
+            let value = "";
+            while (i < pattern.length &&
+                pattern[i] !== ":" &&
+                pattern[i] !== "{" &&
+                pattern[i] !== "*") {
+                value += pattern[i];
+                i++;
+            }
+            if (value) {
+                segments.push({ type: "static", value });
+            }
+        }
+    }
+    return segments;
+}
+function compileColonParameter(pattern, startIndex) {
+    let i = startIndex + 1;
+    let name = "";
+    let optional = false;
+    if (i < pattern.length && pattern[i] === "?") {
+        optional = true;
+        i++;
+    }
+    while (i < pattern.length) {
+        const char = pattern[i];
+        if (char === undefined || !isValidParamChar(char)) {
+            break;
+        }
+        name += char;
+        i++;
+    }
+    if (!name) {
+        throw new RoutePatternError("Parameter name cannot be empty", {
+            pattern,
+            position: startIndex,
+        });
+    }
+    return {
+        segment: { type: "parameter", name, optional },
+        endIndex: i,
+    };
+}
+function compileBraceParameter(pattern, startIndex) {
+    let i = startIndex + 1;
+    let name = "";
+    let optional = false;
+    while (i < pattern.length && pattern[i] !== "}") {
+        if (pattern[i] === "?" && i === startIndex + 1) {
+            optional = true;
+        }
+        else {
+            name += pattern[i];
+        }
+        i++;
+    }
+    if (i >= pattern.length) {
+        throw new RoutePatternError("Unclosed brace parameter", {
+            pattern,
+            position: startIndex,
+        });
+    }
+    i++; // Skip closing brace
+    if (!name) {
+        throw new RoutePatternError("Parameter name cannot be empty", {
+            pattern,
+            position: startIndex,
+        });
+    }
+    return {
+        segment: { type: "parameter", name, optional },
+        endIndex: i,
+    };
+}
+function isValidParamChar(char) {
+    return /[a-zA-Z0-9_]/.test(char);
+}
+//# sourceMappingURL=httpPattern.segmentParsing.js.map

package/dist/httpRouter/pattern/core/httpPattern.type.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Route pattern types and errors.
+ *
+ * @module httpRoute/pattern/types
+ */
+export type RouteSegment = StaticRouteSegment | ParameterRouteSegment | WildcardRouteSegment;
+export interface StaticRouteSegment {
+    readonly type: "static";
+    readonly value: string;
+}
+export interface ParameterRouteSegment {
+    readonly type: "parameter";
+    readonly name: string;
+    readonly optional: boolean;
+}
+export interface WildcardRouteSegment {
+    readonly type: "wildcard";
+    readonly name: string;
+    readonly optional: boolean;
+}
+export interface RoutePatternOptions {
+    readonly strict?: boolean;
+    readonly caseSensitive?: boolean;
+    readonly end?: boolean;
+}
+export interface CompiledRoutePattern {
+    readonly original: string;
+    readonly segments: readonly RouteSegment[];
+    readonly regex: RegExp;
+    readonly paramNames: readonly string[];
+    readonly options: RoutePatternOptions;
+}
+export interface RouteMatch {
+    readonly params: Record<string, string>;
+    readonly path: string;
+    readonly pattern: string;
+}
+import { RoutePatternError as BaseRoutePatternError, DuplicateRouteParameterError as BaseDuplicateRouteParameterError } from "@zudojs/errors";
+export { BaseRoutePatternError as RoutePatternError, BaseDuplicateRouteParameterError as DuplicateRouteParameterError, };
+//# sourceMappingURL=httpPattern.type.d.ts.map

package/dist/httpRouter/pattern/core/httpPattern.type.js

@@ -0,0 +1,8 @@
+/**
+ * Route pattern types and errors.
+ *
+ * @module httpRoute/pattern/types
+ */
+import { RoutePatternError as BaseRoutePatternError, DuplicateRouteParameterError as BaseDuplicateRouteParameterError, } from "@zudojs/errors";
+export { BaseRoutePatternError as RoutePatternError, BaseDuplicateRouteParameterError as DuplicateRouteParameterError, };
+//# sourceMappingURL=httpPattern.type.js.map

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

@@ -0,0 +1,11 @@
+/**
+ * Core route pattern utilities.
+ *
+ * @module httpRoute/pattern/core
+ */
+export * from "./httpPattern.type.js";
+export * from "./httpPattern.compilation.js";
+export * from "./httpPattern.matching.js";
+export * from "./httpPattern.regexBuilding.js";
+export * from "./httpPattern.segmentParsing.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,11 @@
+/**
+ * Core route pattern utilities.
+ *
+ * @module httpRoute/pattern/core
+ */
+export * from "./httpPattern.type.js";
+export * from "./httpPattern.compilation.js";
+export * from "./httpPattern.matching.js";
+export * from "./httpPattern.regexBuilding.js";
+export * from "./httpPattern.segmentParsing.js";
+//# sourceMappingURL=index.js.map

package/dist/httpRouter/pattern/httpPattern.factory.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Route pattern factory.
+ *
+ * @module httpRoute/pattern/factory
+ */
+import type { CompiledRoutePattern, RoutePatternOptions } from "./core/httpPattern.type.js";
+/**
+ * Creates a compiled route pattern from a string.
+ */
+export declare function createRoutePattern(pattern: string, options?: RoutePatternOptions): CompiledRoutePattern;
+/**
+ * Creates a strict route pattern (exact match required).
+ */
+export declare function createStrictRoutePattern(pattern: string): CompiledRoutePattern;
+/**
+ * Creates a case-insensitive route pattern.
+ */
+export declare function createCaseInsensitiveRoutePattern(pattern: string): CompiledRoutePattern;
+//# sourceMappingURL=httpPattern.factory.d.ts.map

package/dist/httpRouter/pattern/httpPattern.factory.js

@@ -0,0 +1,25 @@
+/**
+ * Route pattern factory.
+ *
+ * @module httpRoute/pattern/factory
+ */
+import { compileRoutePattern } from "./core/httpPattern.compilation.js";
+/**
+ * Creates a compiled route pattern from a string.
+ */
+export function createRoutePattern(pattern, options) {
+    return compileRoutePattern(pattern, options);
+}
+/**
+ * Creates a strict route pattern (exact match required).
+ */
+export function createStrictRoutePattern(pattern) {
+    return compileRoutePattern(pattern, { strict: true, end: true });
+}
+/**
+ * Creates a case-insensitive route pattern.
+ */
+export function createCaseInsensitiveRoutePattern(pattern) {
+    return compileRoutePattern(pattern, { caseSensitive: false });
+}
+//# sourceMappingURL=httpPattern.factory.js.map

package/dist/httpRouter/pattern/httpRoute.pattern.parse.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Route pattern parsing for the router core.
+ *
+ * Compiles a route path into an ordered list of segments that
+ * {@link matchCompiledRoute} can evaluate against an incoming request path.
+ *
+ * Supported syntax:
+ * - `/users/:id`            required parameter
+ * - `/users/:id?`           optional parameter
+ * - `/users/:id(\\d+)`       parameter constrained by a regular expression
+ * - `/files/{name}`         brace parameter
+ * - `/files/{name?:\\w+}`    optional, constrained brace parameter
+ * - `/assets/*path`         trailing wildcard
+ */
+import type { CompiledSegment } from "../core/types/httpRouter.type.js";
+/**
+ * A route path compiled into matchable segments.
+ */
+export interface CompiledRoutePath {
+    readonly segments: readonly CompiledSegment[];
+    readonly score: number;
+    readonly strictTrailingSlash: boolean;
+}
+/**
+ * Compiles a route path into its segments.
+ */
+export declare function compileRouteSegments(path: string): readonly CompiledSegment[];
+/**
+ * Compiles a route path into segments plus a specificity score.
+ *
+ * Higher scores are more specific and are matched first.
+ */
+export declare function compileRoute(path: string, strictTrailingSlash: boolean): CompiledRoutePath;
+/**
+ * Scores compiled segments by specificity.
+ */
+export declare function scoreSegments(segments: readonly CompiledSegment[]): number;
+//# sourceMappingURL=httpRoute.pattern.parse.d.ts.map

package/dist/httpRouter/pattern/httpRoute.pattern.parse.js

@@ -0,0 +1,134 @@
+/**
+ * Route pattern parsing for the router core.
+ *
+ * Compiles a route path into an ordered list of segments that
+ * {@link matchCompiledRoute} can evaluate against an incoming request path.
+ *
+ * Supported syntax:
+ * - `/users/:id`            required parameter
+ * - `/users/:id?`           optional parameter
+ * - `/users/:id(\\d+)`       parameter constrained by a regular expression
+ * - `/files/{name}`         brace parameter
+ * - `/files/{name?:\\w+}`    optional, constrained brace parameter
+ * - `/assets/*path`         trailing wildcard
+ */
+import { InvalidRoutePatternError } from "../core/error/httpRouter.error.js";
+import { splitPath, validateParameterName, } from "../core/util/httpRoute.util.js";
+const SEGMENT_SCORE_LITERAL = 3;
+const SEGMENT_SCORE_PARAMETER = 2;
+const SEGMENT_SCORE_WILDCARD = 1;
+/**
+ * Compiles a route path into its segments.
+ */
+export function compileRouteSegments(path) {
+    const segments = [];
+    const parts = splitPath(path);
+    for (const part of parts) {
+        if (part.startsWith(":")) {
+            segments.push(parseParameter(part, path));
+        }
+        else if (part.startsWith("{")) {
+            segments.push(parseBraceParameter(part, path));
+        }
+        else if (part.startsWith("*")) {
+            segments.push({
+                type: "wildcard",
+                name: part.slice(1) || "*",
+            });
+        }
+        else {
+            segments.push({
+                type: "literal",
+                value: part,
+            });
+        }
+    }
+    return Object.freeze(segments);
+}
+/**
+ * Compiles a route path into segments plus a specificity score.
+ *
+ * Higher scores are more specific and are matched first.
+ */
+export function compileRoute(path, strictTrailingSlash) {
+    const segments = compileRouteSegments(path);
+    return Object.freeze({
+        segments,
+        score: scoreSegments(segments),
+        strictTrailingSlash,
+    });
+}
+/**
+ * Scores compiled segments by specificity.
+ */
+export function scoreSegments(segments) {
+    let score = 0;
+    for (const segment of segments) {
+        if (segment.type === "literal") {
+            score += SEGMENT_SCORE_LITERAL;
+        }
+        else if (segment.type === "parameter") {
+            score += SEGMENT_SCORE_PARAMETER;
+        }
+        else {
+            score += SEGMENT_SCORE_WILDCARD;
+        }
+    }
+    return score;
+}
+function parseParameter(segment, path) {
+    let value = segment.slice(1);
+    let optional = false;
+    if (value.endsWith("?")) {
+        optional = true;
+        value = value.slice(0, -1);
+    }
+    const patternStart = value.indexOf("(");
+    if (patternStart >= 0 && value.endsWith(")")) {
+        const name = value.slice(0, patternStart);
+        const expression = value.slice(patternStart + 1, -1);
+        validateParameterName(name, path);
+        return {
+            type: "parameter",
+            name,
+            optional,
+            pattern: compileExpression(expression, path),
+        };
+    }
+    validateParameterName(value, path);
+    return {
+        type: "parameter",
+        name: value,
+        optional,
+        pattern: undefined,
+    };
+}
+function parseBraceParameter(segment, path) {
+    const match = /^\{([a-zA-Z_][a-zA-Z0-9_-]*)(\?)?(?::(.+))?\}$/.exec(segment);
+    if (!match) {
+        throw new InvalidRoutePatternError(path, `Invalid parameter segment "${segment}".`);
+    }
+    const [, name, optionalMarker, expression] = match;
+    if (name === undefined) {
+        throw new InvalidRoutePatternError(path, `Invalid parameter segment "${segment}".`);
+    }
+    const optional = Boolean(optionalMarker);
+    validateParameterName(name, path);
+    return {
+        type: "parameter",
+        name,
+        optional,
+        pattern: expression === undefined
+            ? undefined
+            : compileExpression(expression, path),
+    };
+}
+function compileExpression(expression, path) {
+    try {
+        return new RegExp(`^(?:${expression})$`);
+    }
+    catch (error) {
+        throw new InvalidRoutePatternError(path, `Invalid parameter expression: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+//# sourceMappingURL=httpRoute.pattern.parse.js.map

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

@@ -0,0 +1,19 @@
+/**
+ * HTTP router pattern compilation.
+ *
+ * Two complementary compilers live here:
+ *
+ * - `compileRoutePattern` (regex based) powers standalone pattern matching.
+ * - `compileRoute` (segment based) powers the router core, and additionally
+ *   supports per-parameter regular expression constraints.
+ */
+export { RoutePatternError, DuplicateRouteParameterError, } from "./core/httpPattern.type.js";
+export type { RouteSegment, StaticRouteSegment, ParameterRouteSegment, WildcardRouteSegment, RoutePatternOptions, CompiledRoutePattern, RouteMatch, } from "./core/httpPattern.type.js";
+export { compileRoutePattern } from "./core/httpPattern.compilation.js";
+export { parseSegments } from "./core/httpPattern.segmentParsing.js";
+export { buildRegex } from "./core/httpPattern.regexBuilding.js";
+export { testRoutePattern, matchRoutePattern, matchRoutePatterns, testRoutePatterns, } from "./core/httpPattern.matching.js";
+export { createRoutePattern, createStrictRoutePattern, createCaseInsensitiveRoutePattern, } from "./httpPattern.factory.js";
+export { compileRoute, compileRouteSegments, scoreSegments, } from "./httpRoute.pattern.parse.js";
+export type { CompiledRoutePath } from "./httpRoute.pattern.parse.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/httpRouter/pattern/index.js

@@ -0,0 +1,17 @@
+/**
+ * HTTP router pattern compilation.
+ *
+ * Two complementary compilers live here:
+ *
+ * - `compileRoutePattern` (regex based) powers standalone pattern matching.
+ * - `compileRoute` (segment based) powers the router core, and additionally
+ *   supports per-parameter regular expression constraints.
+ */
+export { RoutePatternError, DuplicateRouteParameterError, } from "./core/httpPattern.type.js";
+export { compileRoutePattern } from "./core/httpPattern.compilation.js";
+export { parseSegments } from "./core/httpPattern.segmentParsing.js";
+export { buildRegex } from "./core/httpPattern.regexBuilding.js";
+export { testRoutePattern, matchRoutePattern, matchRoutePatterns, testRoutePatterns, } from "./core/httpPattern.matching.js";
+export { createRoutePattern, createStrictRoutePattern, createCaseInsensitiveRoutePattern, } from "./httpPattern.factory.js";
+export { compileRoute, compileRouteSegments, scoreSegments, } from "./httpRoute.pattern.parse.js";
+//# sourceMappingURL=index.js.map

package/dist/httpRouter/result/httpRoute.result.builder.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Zudojs HTTP route result builder methods.
+ *
+ * Extends HttpRouteResult with immutable builder methods via prototype.
+ */
+export {};
+//# sourceMappingURL=httpRoute.result.builder.d.ts.map

package/dist/httpRouter/result/httpRoute.result.builder.js

@@ -0,0 +1,70 @@
+/**
+ * Zudojs HTTP route result builder methods.
+ *
+ * Extends HttpRouteResult with immutable builder methods via prototype.
+ */
+import { HttpRouteResult } from "./httpRoute.result.class.js";
+import { normalizeHeaders } from "./httpRoute.result.util.js";
+/* -------------------------------------------------------------------------- */
+/* Builder Methods                                                            */
+/* -------------------------------------------------------------------------- */
+HttpRouteResult.prototype.withHeader = function (name, value) {
+    return new HttpRouteResult({
+        status: this.status,
+        statusText: this.statusText,
+        headers: {
+            ...this.headers,
+            [name]: value,
+        },
+        body: this.body,
+        contentType: this.contentType,
+        metadata: this.metadata,
+    });
+};
+HttpRouteResult.prototype.withHeaders = function (headers) {
+    return new HttpRouteResult({
+        status: this.status,
+        statusText: this.statusText,
+        headers: {
+            ...this.headers,
+            ...normalizeHeaders(headers),
+        },
+        body: this.body,
+        contentType: this.contentType,
+        metadata: this.metadata,
+    });
+};
+HttpRouteResult.prototype.withBody = function (body) {
+    return new HttpRouteResult({
+        status: this.status,
+        statusText: this.statusText,
+        headers: this.headers,
+        body,
+        contentType: this.contentType,
+        metadata: this.metadata,
+    });
+};
+HttpRouteResult.prototype.withStatus = function (status, statusText) {
+    return new HttpRouteResult({
+        status,
+        statusText: statusText ?? this.statusText,
+        headers: this.headers,
+        body: this.body,
+        contentType: this.contentType,
+        metadata: this.metadata,
+    });
+};
+HttpRouteResult.prototype.withMetadata = function (metadata) {
+    return new HttpRouteResult({
+        status: this.status,
+        statusText: this.statusText,
+        headers: this.headers,
+        body: this.body,
+        contentType: this.contentType,
+        metadata: {
+            ...this.metadata,
+            ...metadata,
+        },
+    });
+};
+//# sourceMappingURL=httpRoute.result.builder.js.map

package/dist/httpRouter/result/httpRoute.result.class.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Zudojs HTTP route result class.
+ */
+import type { RouteResultInit, RouteResultBody, RouteResultOptions } from "./httpRoute.result.type.js";
+export declare class HttpRouteResult {
+    readonly status: number;
+    readonly statusText: string | undefined;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly body: RouteResultBody;
+    readonly contentType: string | undefined;
+    readonly metadata: Readonly<Record<string, unknown>>;
+    constructor(init?: RouteResultInit);
+    withHeader: (name: string, value: string) => HttpRouteResult;
+    withHeaders: (headers: HeadersInit) => HttpRouteResult;
+    withBody: (body: RouteResultBody) => HttpRouteResult;
+    withStatus: (status: number, statusText?: string) => HttpRouteResult;
+    withMetadata: (metadata: Readonly<Record<string, unknown>>) => HttpRouteResult;
+    toResponse: (options?: RouteResultOptions) => Response;
+    toJSON: () => Record<string, unknown>;
+}
+//# sourceMappingURL=httpRoute.result.class.d.ts.map

package/dist/httpRouter/result/httpRoute.result.class.js

@@ -0,0 +1,33 @@
+/**
+ * Zudojs HTTP route result class.
+ */
+import { DEFAULT_ROUTE_STATUS } from "./httpRoute.result.type.js";
+import { validateStatus, normalizeHeaders, getHeader, } from "./httpRoute.result.util.js";
+/* -------------------------------------------------------------------------- */
+/* Route Result Class                                                         */
+/* -------------------------------------------------------------------------- */
+export class HttpRouteResult {
+    status;
+    statusText;
+    headers;
+    body;
+    contentType;
+    metadata;
+    constructor(init = {}) {
+        const status = init.status ?? DEFAULT_ROUTE_STATUS;
+        validateStatus(status);
+        const headers = normalizeHeaders(init.headers);
+        const contentType = init.contentType ?? getHeader(headers, "content-type");
+        this.status = status;
+        this.statusText = init.statusText;
+        this.headers = Object.freeze({
+            ...headers,
+        });
+        this.body = init.body ?? null;
+        this.contentType = contentType;
+        this.metadata = Object.freeze({
+            ...(init.metadata ?? {}),
+        });
+    }
+}
+//# sourceMappingURL=httpRoute.result.class.js.map

package/dist/httpRouter/result/httpRoute.result.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Zudojs HTTP route result.
+ *
+ * Normalizes the different values a route handler may return into a
+ * predictable HTTP response description.
+ *
+ * This file re-exports the public API from the split modules.
+ */
+export type { RouteResultBody, RouteResultValue, RouteResultInit, RouteResult, RouteResultContext, RouteResultOptions, } from "./httpRoute.result.type.js";
+export { DEFAULT_ROUTE_STATUS, DEFAULT_CONTENT_TYPE, } from "./httpRoute.result.type.js";
+export { HttpRouteResult } from "./httpRoute.result.class.js";
+export { routeResult, response, ok, created, accepted, noContent, redirect, } from "./httpRoute.result.factory.js";
+export { badRequest, unauthorized, forbidden, notFound, methodNotAllowed, conflict, unprocessableEntity, tooManyRequests, } from "./httpRoute.result.error.4xx.js";
+export { internalServerError, notImplemented, serviceUnavailable, } from "./httpRoute.result.error.5xx.js";
+export { normalizeRouteResult, resultFromContext, } from "./httpRoute.result.normalize.js";
+export { isRouteResult, isRouteResultInit, isRouteResultBody, } from "./httpRoute.result.guard.js";
+//# sourceMappingURL=httpRoute.result.d.ts.map