@zudojs/http 1.4.3 → 1.5.0

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

@@ -38,4 +38,3 @@ export interface RouteResultOptions {
 }
 export declare const DEFAULT_ROUTE_STATUS = 200;
 export declare const DEFAULT_CONTENT_TYPE = "application/json; charset=utf-8";
-//# sourceMappingURL=httpRoute.result.type.d.ts.map

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

@@ -6,4 +6,3 @@
 /* -------------------------------------------------------------------------- */
 export const DEFAULT_ROUTE_STATUS = 200;
 export const DEFAULT_CONTENT_TYPE = "application/json; charset=utf-8";
-//# sourceMappingURL=httpRoute.result.type.js.map

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

@@ -5,4 +5,3 @@ export declare function normalizeHeaders(headers?: HeadersInit): Record<string,
 export declare function getHeader(headers: Record<string, string>, name: string): string | undefined;
 export declare function validateStatus(status: number): void;
 export declare function isReadableStream(value: unknown): value is ReadableStream<Uint8Array>;
-//# sourceMappingURL=httpRoute.result.util.d.ts.map

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

@@ -49,4 +49,3 @@ export function validateStatus(status) {
 export function isReadableStream(value) {
     return (typeof ReadableStream !== "undefined" && value instanceof ReadableStream);
 }
-//# sourceMappingURL=httpRoute.result.util.js.map

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

@@ -3,4 +3,3 @@
  */
 export { HttpRouteResult, ok, created, noContent, redirect, badRequest, unauthorized, forbidden, notFound, conflict, tooManyRequests, internalServerError, accepted, methodNotAllowed, unprocessableEntity, notImplemented, serviceUnavailable, routeResult, response, normalizeRouteResult, resultFromContext, isRouteResult, isRouteResultInit, isRouteResultBody, DEFAULT_ROUTE_STATUS, DEFAULT_CONTENT_TYPE, } from "./httpRoute.result.js";
 export type { RouteResultBody, RouteResultValue, RouteResultInit, RouteResult, RouteResultContext, RouteResultOptions, } from "./httpRoute.result.type.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/httpRouter/result/index.js

@@ -2,4 +2,3 @@
  * HTTP route results.
  */
 export { HttpRouteResult, ok, created, noContent, redirect, badRequest, unauthorized, forbidden, notFound, conflict, tooManyRequests, internalServerError, accepted, methodNotAllowed, unprocessableEntity, notImplemented, serviceUnavailable, routeResult, response, normalizeRouteResult, resultFromContext, isRouteResult, isRouteResultInit, isRouteResultBody, DEFAULT_ROUTE_STATUS, DEFAULT_CONTENT_TYPE, } from "./httpRoute.result.js";
-//# sourceMappingURL=index.js.map

package/dist/httpRouter/tree/core/httpTree.enumerate.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Route tree enumeration helpers.
+ *
+ * @module httpRoute/tree/enumerate
+ */
+import type { MutableRouteTreeNode } from "./httpTree.type.js";
+/**
+ * Collects optional routes from the tree.
+ */
+export declare function collectOptionalRoutes(node: MutableRouteTreeNode): MutableRouteTreeNode[];
+/**
+ * Collects all routes from the tree.
+ */
+export declare function collectRoutes(node: MutableRouteTreeNode, path: string): Array<{
+    readonly path: string;
+    readonly node: MutableRouteTreeNode;
+}>;
+/**
+ * Finds a static child node.
+ */
+export declare function findStaticChild(node: MutableRouteTreeNode, name: string): MutableRouteTreeNode | undefined;

package/dist/httpRouter/tree/core/httpTree.enumerate.js

@@ -0,0 +1,43 @@
+/**
+ * Route tree enumeration helpers.
+ *
+ * @module httpRoute/tree/enumerate
+ */
+import { literalKey } from "./httpTree.nodeCreation.js";
+/**
+ * Collects optional routes from the tree.
+ */
+export function collectOptionalRoutes(node) {
+    const results = [];
+    for (const child of node.children.values()) {
+        if (child.type === "optional" || child.wildcard) {
+            results.push(child);
+            results.push(...collectOptionalRoutes(child));
+        }
+    }
+    return results;
+}
+/**
+ * Collects all routes from the tree.
+ */
+export function collectRoutes(node, path) {
+    const results = [];
+    if (node.handler) {
+        results.push({ path, node });
+    }
+    for (const [key, child] of node.children) {
+        const childPath = child.type === "parameter"
+            ? `${path}/:${child.param ?? key}`
+            : child.type === "wildcard"
+                ? `${path}/*${child.param ?? ""}`
+                : `${path}/${child.name}`;
+        results.push(...collectRoutes(child, childPath));
+    }
+    return results;
+}
+/**
+ * Finds a static child node.
+ */
+export function findStaticChild(node, name) {
+    return node.children.get(literalKey(name, false)) ?? node.children.get(name);
+}

package/dist/httpRouter/tree/core/httpTree.helper.d.ts

@@ -11,11 +11,11 @@ export declare function getPatternSegments(path: string): readonly string[];
 /**
  * Inserts a segment into the tree.
  */
-export declare function insertSegment(node: MutableRouteTreeNode, segments: readonly string[], handler: unknown, methods: readonly string[], metadata: Record<string, unknown>): void;
+export declare function insertSegment(node: MutableRouteTreeNode, segments: readonly string[], handler: unknown, methods: readonly string[], metadata: Record<string, unknown>, caseSensitive?: boolean): void;
 /**
  * Removes a route from the tree.
  */
-export declare function removeRouteFromTree(node: MutableRouteTreeNode, segments: readonly string[]): boolean;
+export declare function removeRouteFromTree(node: MutableRouteTreeNode, segments: readonly string[], caseSensitive?: boolean): boolean;
 /**
  * Checks if a node is empty.
  */
@@ -28,4 +28,3 @@ export declare function matchesMethod(node: MutableRouteTreeNode, method: string
  * Splits a path into segments.
  */
 export declare function splitPath(path: string): readonly string[];
-//# sourceMappingURL=httpTree.helper.d.ts.map

package/dist/httpRouter/tree/core/httpTree.helper.js

@@ -3,7 +3,7 @@
  *
  * @module httpRoute/tree/helpers
  */
-import { createChildNode } from "./httpTree.nodeCreation.js";
+import { childKey, createChildNode } from "./httpTree.nodeCreation.js";
 /**
  * Gets pattern segments from a path.
  */
@@ -13,7 +13,7 @@ export function getPatternSegments(path) {
 /**
  * Inserts a segment into the tree.
  */
-export function insertSegment(node, segments, handler, methods, metadata) {
+export function insertSegment(node, segments, handler, methods, metadata, caseSensitive = false) {
     if (segments.length === 0) {
         node.handler = handler;
         for (const method of methods) {
@@ -26,17 +26,18 @@ export function insertSegment(node, segments, handler, methods, metadata) {
     if (segment === undefined) {
         return;
     }
-    let child = node.children.get(segment);
+    const key = childKey(segment, caseSensitive);
+    let child = node.children.get(key);
     if (!child) {
         child = createChildNode(segment);
-        node.children.set(segment, child);
+        node.children.set(key, child);
     }
-    insertSegment(child, rest, handler, methods, metadata);
+    insertSegment(child, rest, handler, methods, metadata, caseSensitive);
 }
 /**
  * Removes a route from the tree.
  */
-export function removeRouteFromTree(node, segments) {
+export function removeRouteFromTree(node, segments, caseSensitive = false) {
     if (segments.length === 0) {
         if (node.handler) {
             node.handler = undefined;
@@ -49,13 +50,14 @@ export function removeRouteFromTree(node, segments) {
     if (segment === undefined) {
         return false;
     }
-    const child = node.children.get(segment);
+    const key = childKey(segment, caseSensitive);
+    const child = node.children.get(key);
     if (!child) {
         return false;
     }
-    const removed = removeRouteFromTree(child, rest);
+    const removed = removeRouteFromTree(child, rest, caseSensitive);
     if (removed && isEmptyNode(child)) {
-        node.children.delete(segment);
+        node.children.delete(key);
     }
     return removed;
 }
@@ -77,4 +79,3 @@ export function matchesMethod(node, method) {
 export function splitPath(path) {
     return path.split("/").filter(Boolean);
 }
-//# sourceMappingURL=httpTree.helper.js.map

package/dist/httpRouter/tree/core/httpTree.nodeCreation.d.ts

@@ -4,8 +4,22 @@
  * @module httpRoute/tree/nodeCreation
  */
 import type { MutableRouteTreeNode } from "./httpTree.type.js";
+/**
+ * The key a literal segment is stored under. Literals are compared
+ * case-insensitively unless the tree is case sensitive, matching the router's
+ * default; the tree used to match `/PAYMENTS/x` against nothing.
+ */
+export declare function literalKey(segment: string, caseSensitive: boolean): string;
+/**
+ * The key a pattern segment is stored under: literals by
+ * {@link literalKey}, parameters and wildcards by their spelling.
+ */
+export declare function childKey(segment: string, caseSensitive: boolean): string;
 /**
  * Creates a child node based on the segment.
+ *
+ * Understands every spelling the router does: `:id`, `:id?`, `{name}`,
+ * `{name?}`, `*rest` (a named wildcard; only a bare `*` used to count, so
+ * `/admin/*rest` was stored as a literal segment) and a static `name?`.
  */
 export declare function createChildNode(segment: string): MutableRouteTreeNode;
-//# sourceMappingURL=httpTree.nodeCreation.d.ts.map

package/dist/httpRouter/tree/core/httpTree.nodeCreation.js

@@ -3,52 +3,76 @@
  *
  * @module httpRoute/tree/nodeCreation
  */
+const BRACE_PARAMETER = /^\{([a-zA-Z_][a-zA-Z0-9_-]*)(\?)?(?::.+)?\}$/;
+/**
+ * The key a literal segment is stored under. Literals are compared
+ * case-insensitively unless the tree is case sensitive, matching the router's
+ * default; the tree used to match `/PAYMENTS/x` against nothing.
+ */
+export function literalKey(segment, caseSensitive) {
+    return caseSensitive ? segment : segment.toLowerCase();
+}
+/**
+ * The key a pattern segment is stored under: literals by
+ * {@link literalKey}, parameters and wildcards by their spelling.
+ */
+export function childKey(segment, caseSensitive) {
+    if (segment.startsWith(":") ||
+        segment.startsWith("*") ||
+        segment.startsWith("{")) {
+        return segment;
+    }
+    return literalKey(segment.endsWith("?") ? segment.slice(0, -1) : segment, caseSensitive);
+}
+function node(fields) {
+    return {
+        ...fields,
+        children: new Map(),
+        methods: new Set(),
+        metadata: {},
+    };
+}
 /**
  * Creates a child node based on the segment.
+ *
+ * Understands every spelling the router does: `:id`, `:id?`, `{name}`,
+ * `{name?}`, `*rest` (a named wildcard; only a bare `*` used to count, so
+ * `/admin/*rest` was stored as a literal segment) and a static `name?`.
  */
 export function createChildNode(segment) {
     if (segment.startsWith(":")) {
-        return {
-            name: segment.slice(1),
-            type: "parameter",
-            children: new Map(),
-            methods: new Set(),
-            metadata: {},
-            optional: false,
+        const optional = segment.endsWith("?");
+        const name = segment.slice(1, optional ? -1 : undefined);
+        return node({
+            name,
+            type: optional ? "optional" : "parameter",
+            optional,
+            wildcard: false,
+            param: name,
+        });
+    }
+    const brace = BRACE_PARAMETER.exec(segment);
+    if (brace && brace[1] !== undefined) {
+        const optional = brace[2] !== undefined;
+        return node({
+            name: brace[1],
+            type: optional ? "optional" : "parameter",
+            optional,
             wildcard: false,
-            param: segment.slice(1),
-        };
+            param: brace[1],
+        });
     }
-    if (segment === "*") {
-        return {
-            name: "*",
-            type: "wildcard",
-            children: new Map(),
-            methods: new Set(),
-            metadata: {},
-            optional: false,
-            wildcard: true,
-        };
+    if (segment.startsWith("*")) {
+        const name = segment.slice(1) || "*";
+        return node({ name, type: "wildcard", optional: false, wildcard: true, param: name });
     }
     if (segment.endsWith("?")) {
-        return {
+        return node({
             name: segment.slice(0, -1),
             type: "optional",
-            children: new Map(),
-            methods: new Set(),
-            metadata: {},
             optional: true,
             wildcard: false,
-        };
+        });
     }
-    return {
-        name: segment,
-        type: "static",
-        children: new Map(),
-        methods: new Set(),
-        metadata: {},
-        optional: false,
-        wildcard: false,
-    };
+    return node({ name: segment, type: "static", optional: false, wildcard: false });
 }
-//# sourceMappingURL=httpTree.nodeCreation.js.map

package/dist/httpRouter/tree/core/httpTree.traversal.d.ts

@@ -5,22 +5,23 @@
  */
 import type { MutableRouteTreeNode } from "./httpTree.type.js";
 /**
- * Collects candidates from the tree.
+ * A node that matched a path, with every parameter captured on the way.
  */
-export declare function collectCandidates(node: MutableRouteTreeNode, segments: readonly string[]): MutableRouteTreeNode[];
+export interface RouteTreeCandidate {
+    readonly node: MutableRouteTreeNode;
+    readonly params: Readonly<Record<string, string>>;
+}
 /**
- * Collects optional routes from the tree.
+ * Collects the nodes matching `segments`, most specific first: at each level
+ * a literal child, then parameter children, then an optional child skipped,
+ * then a wildcard. Parameters are accumulated along the path — the old
+ * traversal returned bare nodes, so only the last parameter was ever
+ * reported — and a wildcard captures the rest of the path.
  */
-export declare function collectOptionalRoutes(node: MutableRouteTreeNode): MutableRouteTreeNode[];
+export declare function collectMatches(node: MutableRouteTreeNode, segments: readonly string[], caseSensitive: boolean, index?: number, params?: Readonly<Record<string, string>>): RouteTreeCandidate[];
 /**
- * Collects all routes from the tree.
- */
-export declare function collectRoutes(node: MutableRouteTreeNode, path: string): Array<{
-    readonly path: string;
-    readonly node: MutableRouteTreeNode;
-}>;
-/**
- * Finds a static child node.
+ * Collects candidate nodes for `segments`, in priority order.
+ *
+ * Kept for compatibility; {@link collectMatches} also reports parameters.
  */
-export declare function findStaticChild(node: MutableRouteTreeNode, name: string): MutableRouteTreeNode | undefined;
-//# sourceMappingURL=httpTree.traversal.d.ts.map
+export declare function collectCandidates(node: MutableRouteTreeNode, segments: readonly string[]): MutableRouteTreeNode[];

package/dist/httpRouter/tree/core/httpTree.traversal.js

@@ -3,71 +3,69 @@
  *
  * @module httpRoute/tree/traversal
  */
+import { literalKey } from "./httpTree.nodeCreation.js";
 /**
- * Collects candidates from the tree.
+ * Collects the nodes matching `segments`, most specific first: at each level
+ * a literal child, then parameter children, then an optional child skipped,
+ * then a wildcard. Parameters are accumulated along the path — the old
+ * traversal returned bare nodes, so only the last parameter was ever
+ * reported — and a wildcard captures the rest of the path.
  */
-export function collectCandidates(node, segments) {
-    if (segments.length === 0) {
-        return [node];
-    }
-    const [segment, ...rest] = segments;
+export function collectMatches(node, segments, caseSensitive, index = 0, params = {}) {
+    const matches = [];
+    const recurse = (child, next, captured) => {
+        matches.push(...collectMatches(child, segments, caseSensitive, next, captured));
+    };
+    const segment = segments[index];
     if (segment === undefined) {
-        return [node];
+        if (node.handler !== undefined) {
+            matches.push({ node, params });
+        }
+        for (const child of node.children.values()) {
+            if (child.type === "optional") {
+                recurse(child, index, params);
+            }
+            else if (child.type === "wildcard" && child.handler !== undefined) {
+                matches.push({ node: child, params: { ...params, [child.param ?? "*"]: "" } });
+            }
+        }
+        return matches;
     }
-    const candidates = [];
-    const staticChild = node.children.get(segment);
-    if (staticChild) {
-        candidates.push(...collectCandidates(staticChild, rest));
+    const literal = node.children.get(literalKey(segment, caseSensitive));
+    if (literal && literal.param === undefined && literal.type !== "wildcard") {
+        recurse(literal, index + 1, params);
     }
     for (const child of node.children.values()) {
-        if (child.type === "parameter") {
-            candidates.push(...collectCandidates(child, rest));
-        }
-        if (child.type === "wildcard") {
-            candidates.push(child);
+        if (child.param !== undefined && child.type !== "wildcard") {
+            recurse(child, index + 1, { ...params, [child.param]: decodeSegment(segment) });
         }
+    }
+    for (const child of node.children.values()) {
         if (child.type === "optional") {
-            candidates.push(...collectCandidates(child, rest));
-            candidates.push(child);
+            recurse(child, index, params);
         }
     }
-    return candidates;
-}
-/**
- * Collects optional routes from the tree.
- */
-export function collectOptionalRoutes(node) {
-    const results = [];
     for (const child of node.children.values()) {
-        if (child.type === "optional" || child.wildcard) {
-            results.push(child);
-            results.push(...collectOptionalRoutes(child));
+        if (child.type === "wildcard" && child.handler !== undefined) {
+            const rest = segments.slice(index).map(decodeSegment).join("/");
+            matches.push({ node: child, params: { ...params, [child.param ?? "*"]: rest } });
         }
     }
-    return results;
+    return matches;
 }
-/**
- * Collects all routes from the tree.
- */
-export function collectRoutes(node, path) {
-    const results = [];
-    if (node.handler) {
-        results.push({ path, node });
+function decodeSegment(value) {
+    try {
+        return decodeURIComponent(value);
     }
-    for (const [key, child] of node.children) {
-        const childPath = child.type === "parameter"
-            ? `${path}:${key}`
-            : child.type === "wildcard"
-                ? `${path}*`
-                : `${path}/${key}`;
-        results.push(...collectRoutes(child, childPath));
+    catch {
+        return value;
     }
-    return results;
 }
 /**
- * Finds a static child node.
+ * Collects candidate nodes for `segments`, in priority order.
+ *
+ * Kept for compatibility; {@link collectMatches} also reports parameters.
  */
-export function findStaticChild(node, name) {
-    return node.children.get(name);
+export function collectCandidates(node, segments) {
+    return collectMatches(node, segments, false).map((match) => match.node);
 }
-//# sourceMappingURL=httpTree.traversal.js.map

package/dist/httpRouter/tree/core/httpTree.type.d.ts

@@ -18,13 +18,15 @@ export type RouteTreeNodeType = "static" | "parameter" | "wildcard" | "optional"
 /**
  * Options for {@link RouteTree}.
  *
- * Deliberately empty. `caseSensitive` and `strict` were declared here and never
- * read — case sensitivity and trailing-slash handling are owned by
- * `RouterOptions` and applied by `RouteMatcher`, which is the path requests
- * actually take. Declaring them here again promised behaviour this structure
- * never implemented.
+ * `strict` (trailing-slash handling) is deliberately not offered: the tree
+ * splits on `/` and drops empty segments, so `/a` and `/a/` are one path.
  */
 export interface RouteTreeOptions {
+    /**
+     * Whether literal segments are compared case-sensitively. Defaults to
+     * `false`, the router's default, so the two agree on `/PAYMENTS/x`.
+     */
+    readonly caseSensitive?: boolean;
 }
 export interface RouteTreeMatch {
     readonly params: Record<string, string>;
@@ -49,4 +51,3 @@ export interface MutableRouteTreeNode {
     wildcard: boolean;
     param?: string;
 }
-//# sourceMappingURL=httpTree.type.d.ts.map

package/dist/httpRouter/tree/core/httpTree.type.js

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

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

@@ -7,4 +7,4 @@ export * from "./httpTree.type.js";
 export * from "./httpTree.helper.js";
 export * from "./httpTree.nodeCreation.js";
 export * from "./httpTree.traversal.js";
-//# sourceMappingURL=index.d.ts.map
+export * from "./httpTree.enumerate.js";

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

@@ -7,4 +7,4 @@ export * from "./httpTree.type.js";
 export * from "./httpTree.helper.js";
 export * from "./httpTree.nodeCreation.js";
 export * from "./httpTree.traversal.js";
-//# sourceMappingURL=index.js.map
+export * from "./httpTree.enumerate.js";

package/dist/httpRouter/tree/httpTree.core.d.ts

@@ -6,16 +6,20 @@
 import type { RouteTreeOptions, RouteTreeMatch, RouteTreeSnapshot } from "./core/httpTree.type.js";
 export declare class RouteTree {
     private readonly root;
+    private readonly caseSensitive;
     private nodeCount;
-    constructor(_options?: RouteTreeOptions);
+    constructor(options?: RouteTreeOptions);
     insert(path: string, handler: unknown, methods?: readonly string[], metadata?: Record<string, unknown>): void;
     remove(path: string): boolean;
+    /**
+     * Finds the most specific route for a path: literal segments first, then
+     * parameters, then wildcards, left to right, as the router ranks them.
+     * Every parameter along the path is reported.
+     */
     lookup(path: string, method?: string): RouteTreeMatch | undefined;
     has(path: string, method?: string): boolean;
     clear(): void;
     snapshot(): RouteTreeSnapshot;
     get size(): number;
-    private extractParams;
     private freezeNode;
 }
-//# sourceMappingURL=httpTree.core.d.ts.map

package/dist/httpRouter/tree/httpTree.core.js

@@ -4,11 +4,13 @@
  * @module httpRoute/tree/tree
  */
 import { insertSegment, removeRouteFromTree, matchesMethod, splitPath, } from "./core/httpTree.helper.js";
-import { collectCandidates } from "./core/httpTree.traversal.js";
+import { collectMatches } from "./core/httpTree.traversal.js";
 export class RouteTree {
     root;
+    caseSensitive;
     nodeCount = 0;
-    constructor(_options = {}) {
+    constructor(options = {}) {
+        this.caseSensitive = options.caseSensitive ?? false;
         this.root = {
             name: "",
             type: "static",
@@ -21,28 +23,32 @@ export class RouteTree {
     }
     insert(path, handler, methods = ["GET"], metadata = {}) {
         const segments = splitPath(path);
-        insertSegment(this.root, segments, handler, methods, metadata);
+        insertSegment(this.root, segments, handler, methods, metadata, this.caseSensitive);
         this.nodeCount++;
     }
     remove(path) {
         const segments = splitPath(path);
-        const removed = removeRouteFromTree(this.root, segments);
+        const removed = removeRouteFromTree(this.root, segments, this.caseSensitive);
         if (removed) {
             this.nodeCount--;
         }
         return removed;
     }
+    /**
+     * Finds the most specific route for a path: literal segments first, then
+     * parameters, then wildcards, left to right, as the router ranks them.
+     * Every parameter along the path is reported.
+     */
     lookup(path, method) {
         const segments = splitPath(path);
-        const candidates = collectCandidates(this.root, segments);
-        for (const candidate of candidates) {
-            if (candidate.handler && (!method || matchesMethod(candidate, method))) {
+        for (const { node, params } of collectMatches(this.root, segments, this.caseSensitive)) {
+            if (node.handler && (!method || matchesMethod(node, method))) {
                 return {
-                    params: this.extractParams(segments, candidate),
+                    params: { ...params },
                     path,
-                    handler: candidate.handler,
-                    methods: Array.from(candidate.methods),
-                    metadata: { ...candidate.metadata },
+                    handler: node.handler,
+                    methods: Array.from(node.methods),
+                    metadata: { ...node.metadata },
                 };
             }
         }
@@ -68,13 +74,6 @@ export class RouteTree {
     get size() {
         return this.nodeCount;
     }
-    extractParams(segments, node) {
-        const params = {};
-        if (node.type === "parameter" && node.param) {
-            params[node.param] = segments[segments.length - 1] ?? "";
-        }
-        return params;
-    }
     freezeNode(node) {
         const children = new Map();
         for (const [key, child] of node.children) {
@@ -93,4 +92,3 @@ export class RouteTree {
         };
     }
 }
-//# sourceMappingURL=httpTree.core.js.map

package/dist/httpRouter/tree/httpTree.factory.d.ts

@@ -9,4 +9,3 @@ import { RouteTree } from "./httpTree.core.js";
  * Creates a new route tree.
  */
 export declare function createRouteTree(options?: RouteTreeOptions): RouteTree;
-//# sourceMappingURL=httpTree.factory.d.ts.map

package/dist/httpRouter/tree/httpTree.factory.js

@@ -10,4 +10,3 @@ import { RouteTree } from "./httpTree.core.js";
 export function createRouteTree(options = {}) {
     return new RouteTree(options);
 }
-//# sourceMappingURL=httpTree.factory.js.map

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

@@ -4,4 +4,3 @@
 export type { RouteTreeNode, RouteTreeNodeType, RouteTreeOptions, RouteTreeMatch, RouteTreeSnapshot, MutableRouteTreeNode, } from "./core/httpTree.type.js";
 export { RouteTree } from "./httpTree.core.js";
 export { createRouteTree } from "./httpTree.factory.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/httpRouter/tree/index.js

@@ -3,4 +3,3 @@
  */
 export { RouteTree } from "./httpTree.core.js";
 export { createRouteTree } from "./httpTree.factory.js";
-//# sourceMappingURL=index.js.map