@adonisjs/http-server 8.0.0-next.8 → 8.0.0-next.9

package/build/chunk-CVZAIRWJ.js

@@ -0,0 +1,1222 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/helpers.ts
+import cookie from "cookie";
+import matchit from "@poppinss/matchit";
+import string3 from "@poppinss/utils/string";
+import { parseBindingReference } from "@adonisjs/fold";
+
+// src/utils.ts
+import Cache from "tmp-cache";
+import { InvalidArgumentsException } from "@poppinss/utils/exception";
+
+// src/router/group.ts
+import Macroable4 from "@poppinss/macroable";
+
+// src/router/brisk.ts
+import Macroable2 from "@poppinss/macroable";
+
+// src/router/route.ts
+import is from "@sindresorhus/is";
+import Macroable from "@poppinss/macroable";
+import Middleware from "@poppinss/middleware";
+import { RuntimeException } from "@poppinss/utils/exception";
+import { moduleCaller, moduleImporter } from "@adonisjs/fold";
+
+// src/debug.ts
+import { debuglog } from "util";
+var debug_default = debuglog("adonisjs:http");
+
+// src/router/factories/use_return_value.ts
+function canWriteResponseBody(value, ctx) {
+  return value !== void 0 && // Return value is explicitly defined
+  !ctx.response.hasLazyBody && // Lazy body is not set
+  value !== ctx.response;
+}
+function useReturnValue(ctx) {
+  return function(value) {
+    if (canWriteResponseBody(value, ctx)) {
+      ctx.response.send(value);
+    }
+  };
+}
+
+// src/tracing_channels.ts
+var tracing_channels_exports = {};
+__export(tracing_channels_exports, {
+  httpExceptionHandler: () => httpExceptionHandler,
+  httpMiddleware: () => httpMiddleware,
+  httpRequest: () => httpRequest,
+  httpResponseSerializer: () => httpResponseSerializer,
+  httpRouteHandler: () => httpRouteHandler
+});
+import diagnostics_channel from "diagnostics_channel";
+var httpRequest = diagnostics_channel.tracingChannel("adonisjs.http.request");
+var httpMiddleware = diagnostics_channel.tracingChannel("adonisjs.http.middleware");
+var httpExceptionHandler = diagnostics_channel.tracingChannel(
+  "adonisjs.http.exception.handler"
+);
+var httpRouteHandler = diagnostics_channel.tracingChannel("adonisjs.http.route.handler");
+var httpResponseSerializer = diagnostics_channel.tracingChannel(
+  "adonisjs.http.response.serializer"
+);
+
+// src/router/executor.ts
+function execute(route, resolver, ctx, errorResponder) {
+  return route.middleware.runner().errorHandler((error) => errorResponder(error, ctx)).finalHandler(() => {
+    if (typeof route.handler === "function") {
+      return httpRouteHandler.tracePromise(
+        ($ctx) => Promise.resolve(route.handler($ctx)),
+        httpRouteHandler.hasSubscribers ? { route } : void 0,
+        void 0,
+        ctx
+      ).then(useReturnValue(ctx));
+    }
+    return httpRouteHandler.tracePromise(
+      route.handler.handle,
+      httpRouteHandler.hasSubscribers ? { route } : void 0,
+      void 0,
+      resolver,
+      ctx
+    ).then(useReturnValue(ctx));
+  }).run(async (middleware, next) => {
+    if (typeof middleware === "function") {
+      return httpMiddleware.tracePromise(
+        middleware,
+        httpMiddleware.hasSubscribers ? { middleware } : void 0,
+        void 0,
+        ctx,
+        next
+      );
+    }
+    return httpMiddleware.tracePromise(
+      middleware.handle,
+      httpMiddleware.hasSubscribers ? { middleware } : void 0,
+      void 0,
+      resolver,
+      ctx,
+      next,
+      middleware.args
+    );
+  });
+}
+
+// src/router/route.ts
+import StringBuilder from "@poppinss/utils/string_builder";
+import string from "@poppinss/utils/string";
+var Route = class extends Macroable {
+  /**
+   * Route pattern
+   */
+  #pattern;
+  /**
+   * HTTP Methods for the route
+   */
+  #methods;
+  /**
+   * A unique name for the route
+   */
+  #name;
+  /**
+   * A boolean to prevent route from getting registered within
+   * the store.
+   *
+   * This flag must be set before "Router.commit" method
+   */
+  #isDeleted = false;
+  /**
+   * Route handler
+   */
+  #handler;
+  /**
+   * Matchers inherited from the router
+   */
+  #globalMatchers;
+  /**
+   * Reference to the AdonisJS application
+   */
+  #app;
+  /**
+   * Middleware registered on the router
+   */
+  #routerMiddleware;
+  /**
+   * By default the route is part of the `root` domain. Root domain is used
+   * when no domain is defined
+   */
+  #routeDomain = "root";
+  /**
+   * An object of matchers to be forwarded to the store. The matchers
+   * list is populated by calling `where` method
+   */
+  #matchers = {};
+  /**
+   * Custom prefixes defined on the route or the route parent
+   * groups
+   */
+  #prefixes = [];
+  /**
+   * Middleware defined directly on the route or the route parent
+   * routes. We mantain an array for each layer of the stack
+   */
+  #middleware = [];
+  /**
+   * Creates a new Route instance
+   * @param app - The AdonisJS application instance
+   * @param routerMiddleware - Array of global middleware registered on the router
+   * @param options - Configuration options for the route
+   */
+  constructor(app, routerMiddleware, options) {
+    super();
+    this.#app = app;
+    this.#routerMiddleware = routerMiddleware;
+    this.#pattern = options.pattern;
+    this.#methods = options.methods;
+    this.#globalMatchers = options.globalMatchers;
+    const { handler, routeName } = this.#resolveRouteHandle(options.handler);
+    this.#handler = handler;
+    this.#name = routeName;
+  }
+  /**
+   * Resolves the route handler string expression to a
+   * handler method object
+   */
+  #resolveRouteHandle(handler) {
+    if (typeof handler === "string") {
+      const parts = handler.split(".");
+      const method = parts.length === 1 ? "handle" : parts.pop();
+      const moduleRefId = parts.join(".");
+      return {
+        handler: {
+          method,
+          reference: handler,
+          importExpression: moduleRefId,
+          ...moduleImporter(() => this.#app.import(moduleRefId), method).toHandleMethod(),
+          name: handler
+        },
+        routeName: `${new StringBuilder(moduleRefId.split("/").pop()).removeSuffix("controller").snakeCase()}.${string.snakeCase(method)}`
+      };
+    }
+    if (Array.isArray(handler)) {
+      const controller = handler[0];
+      const method = handler[1] ?? "handle";
+      if (is.class(controller)) {
+        return {
+          handler: {
+            method,
+            reference: handler,
+            importExpression: null,
+            ...moduleCaller(controller, method).toHandleMethod()
+          },
+          routeName: `${new StringBuilder(controller.name).removeSuffix("controller").snakeCase()}.${string.snakeCase(method)}`
+        };
+      }
+      return {
+        handler: {
+          method,
+          reference: handler,
+          importExpression: String(controller),
+          ...moduleImporter(controller, method).toHandleMethod()
+        },
+        routeName: controller.name ? `${new StringBuilder(controller.name).removeSuffix("controller").snakeCase()}.${string.snakeCase(method)}` : void 0
+      };
+    }
+    return { handler };
+  }
+  /**
+   * Returns an object of param matchers by merging global and local
+   * matchers. The local copy is given preference over the global
+   * one's
+   */
+  #getMatchers() {
+    return { ...this.#globalMatchers, ...this.#matchers };
+  }
+  /**
+   * Returns a normalized pattern string by prefixing the `prefix` (if defined).
+   */
+  #computePattern() {
+    const pattern = dropSlash(this.#pattern);
+    const prefix = this.#prefixes.slice().reverse().map((one) => dropSlash(one)).join("");
+    return prefix ? `${prefix}${pattern === "/" ? "" : pattern}` : pattern;
+  }
+  /**
+   * Define matcher for a given param. If a matcher exists, then we do not
+   * override that, since the routes inside a group will set matchers
+   * before the group, so they should have priority over the group
+   * matchers.
+   *
+   * ```ts
+   * Route.group(() => {
+   *   Route.get('/:id', 'handler').where('id', /^[0-9]$/)
+   * }).where('id', /[^a-z$]/)
+   * ```
+   *
+   * The `/^[0-9]$/` will win over the matcher defined by the group
+   */
+  where(param, matcher) {
+    if (this.#matchers[param]) {
+      return this;
+    }
+    if (typeof matcher === "string") {
+      this.#matchers[param] = { match: new RegExp(matcher) };
+    } else if (is.regExp(matcher)) {
+      this.#matchers[param] = { match: matcher };
+    } else {
+      this.#matchers[param] = matcher;
+    }
+    return this;
+  }
+  /**
+   * Define prefix for the route. Calling this method multiple times
+   * applies multiple prefixes in the reverse order.
+   * @param prefix - The prefix to add to the route
+   * @returns Current Route instance for method chaining
+   */
+  prefix(prefix) {
+    this.#prefixes.push(prefix);
+    return this;
+  }
+  /**
+   * Define a custom domain for the route. We do not overwrite the domain
+   * unless `overwrite` flag is set to true.
+   */
+  domain(domain, overwrite = false) {
+    if (this.#routeDomain === "root" || overwrite) {
+      this.#routeDomain = domain;
+    }
+    return this;
+  }
+  /**
+   * Define one or more middleware to be executed before the route
+   * handler.
+   *
+   * Named middleware can be referenced using the name registered with
+   * the router middleware store.
+   */
+  use(middleware) {
+    this.#middleware.push(Array.isArray(middleware) ? middleware : [middleware]);
+    return this;
+  }
+  /**
+   * Alias for {@link Route.use}
+   */
+  middleware(middleware) {
+    return this.use(middleware);
+  }
+  /**
+   * Give a unique name to the route. Assinging a new unique removes the
+   * existing name of the route.
+   *
+   * Setting prepends to true prefixes the name to the existing name.
+   */
+  as(name, prepend = false) {
+    if (prepend) {
+      if (!this.#name) {
+        throw new RuntimeException(
+          `Routes inside a group must have names before calling "router.group.as"`
+        );
+      }
+      this.#name = `${name}.${this.#name}`;
+      return this;
+    }
+    this.#name = name;
+    return this;
+  }
+  /**
+   * Check if the route was marked to be deleted
+   */
+  isDeleted() {
+    return this.#isDeleted;
+  }
+  /**
+   * Mark route as deleted. Deleted routes are not registered
+   * with the route store
+   */
+  markAsDeleted() {
+    this.#isDeleted = true;
+  }
+  /**
+   * Get the route name
+   */
+  getName() {
+    return this.#name;
+  }
+  /**
+   * Get the route pattern
+   */
+  getPattern() {
+    return this.#pattern;
+  }
+  /**
+   * Set the route pattern
+   */
+  setPattern(pattern) {
+    this.#pattern = pattern;
+    return this;
+  }
+  /**
+   * Returns the stack of middleware registered on the route.
+   * The value is shared by reference.
+   */
+  getMiddleware() {
+    return this.#middleware;
+  }
+  /**
+   * Returns the middleware instance for persistence inside the
+   * store
+   */
+  #getMiddlewareForStore() {
+    const middleware = new Middleware();
+    this.#routerMiddleware.forEach((one) => {
+      debug_default("adding global middleware to route %s, %O", this.#pattern, one);
+      middleware.add(one);
+    });
+    this.#middleware.flat().forEach((one) => {
+      debug_default("adding named middleware to route %s, %O", this.#pattern, one);
+      middleware.add(one);
+    });
+    middleware.freeze();
+    return middleware;
+  }
+  /**
+   * Returns JSON representation of the route
+   */
+  toJSON() {
+    const pattern = this.#computePattern();
+    const matchers = this.#getMatchers();
+    return {
+      domain: this.#routeDomain,
+      pattern,
+      matchers,
+      tokens: parseRoute(pattern, matchers),
+      meta: {},
+      name: this.#name,
+      handler: this.#handler,
+      methods: this.#methods,
+      middleware: this.#getMiddlewareForStore(),
+      execute
+    };
+  }
+};
+
+// src/router/brisk.ts
+var BriskRoute = class extends Macroable2 {
+  /**
+   * Route pattern
+   */
+  #pattern;
+  /**
+   * Matchers inherited from the router
+   */
+  #globalMatchers;
+  /**
+   * Reference to the AdonisJS application
+   */
+  #app;
+  /**
+   * Middleware registered on the router
+   */
+  #routerMiddleware;
+  /**
+   * Reference to route instance. Set after `setHandler` is called
+   */
+  route = null;
+  /**
+   * Creates a new BriskRoute instance
+   * @param app - The AdonisJS application instance
+   * @param routerMiddleware - Array of global middleware registered on the router
+   * @param options - Configuration options for the brisk route
+   */
+  constructor(app, routerMiddleware, options) {
+    super();
+    this.#app = app;
+    this.#routerMiddleware = routerMiddleware;
+    this.#pattern = options.pattern;
+    this.#globalMatchers = options.globalMatchers;
+  }
+  /**
+   * Set handler for the brisk route
+   * @param handler - The route handler function
+   * @returns The created route instance
+   */
+  setHandler(handler) {
+    this.route = new Route(this.#app, this.#routerMiddleware, {
+      pattern: this.#pattern,
+      globalMatchers: this.#globalMatchers,
+      methods: ["GET", "HEAD"],
+      handler
+    });
+    return this.route;
+  }
+  /**
+   * Redirects to a given route. Params from the original request will
+   * be used when no custom params are defined.
+   * @param args - Route identifier, parameters, and options for building the redirect URL
+   * @returns The created route instance
+   */
+  redirect(...args) {
+    const [identifier, params, options] = args;
+    function redirectsToRoute(ctx) {
+      const redirector = ctx.response.redirect();
+      if (options?.status) {
+        redirector.status(options.status);
+      }
+      return redirector.toRoute(identifier, params || ctx.params, options);
+    }
+    Object.defineProperty(redirectsToRoute, "listArgs", { value: identifier, writable: false });
+    return this.setHandler(redirectsToRoute);
+  }
+  /**
+   * Redirect request to a fixed URL
+   * @param url - The URL to redirect to
+   * @param options - Optional redirect options including HTTP status code
+   * @returns The created route instance
+   */
+  redirectToPath(url, options) {
+    function redirectsToPath(ctx) {
+      const redirector = ctx.response.redirect();
+      if (options?.status) {
+        redirector.status(options.status);
+      }
+      return redirector.toPath(url);
+    }
+    Object.defineProperty(redirectsToPath, "listArgs", { value: url, writable: false });
+    return this.setHandler(redirectsToPath);
+  }
+};
+
+// src/router/resource.ts
+import string2 from "@poppinss/utils/string";
+import Macroable3 from "@poppinss/macroable";
+import { RuntimeException as RuntimeException2 } from "@poppinss/utils/exception";
+var RouteResource = class extends Macroable3 {
+  /**
+   * Resource identifier. Nested resources are separated
+   * with a dot notation
+   */
+  #resource;
+  /**
+   * The controller to handle resource routing requests
+   */
+  #controller;
+  /**
+   * Is it a shallow resource? Shallow resources URLs do not have parent
+   * resource name and id once they can be identified with the id.
+   */
+  #shallow = false;
+  /**
+   * Matchers inherited from the router
+   */
+  #globalMatchers;
+  /**
+   * Reference to the AdonisJS application
+   */
+  #app;
+  /**
+   * Middleware registered on the router
+   */
+  #routerMiddleware;
+  /**
+   * Parameter names for the resources. Defaults to `id` for
+   * a singular resource and `resource_id` for nested
+   * resources.
+   */
+  #params = {};
+  /**
+   * Base name for the routes. We suffix action names
+   * on top of the base name
+   */
+  #routesBaseName;
+  /**
+   * A collection of routes instances that belongs to this resource
+   */
+  routes = [];
+  /**
+   * Creates a new RouteResource instance
+   * @param app - The AdonisJS application instance
+   * @param routerMiddleware - Array of global middleware registered on the router
+   * @param options - Configuration options for the route resource
+   */
+  constructor(app, routerMiddleware, options) {
+    super();
+    this.#validateResourceName(options.resource);
+    this.#app = app;
+    this.#shallow = options.shallow;
+    this.#routerMiddleware = routerMiddleware;
+    this.#controller = options.controller;
+    this.#globalMatchers = options.globalMatchers;
+    this.#resource = this.#normalizeResourceName(options.resource);
+    this.#routesBaseName = this.#getRoutesBaseName();
+    this.#buildRoutes();
+  }
+  /**
+   * Normalizes the resource name to dropping leading and trailing
+   * slashes.
+   */
+  #normalizeResourceName(resource) {
+    return resource.replace(/^\//, "").replace(/\/$/, "");
+  }
+  /**
+   * Ensure resource name is not an empty string
+   */
+  #validateResourceName(resource) {
+    if (!resource || resource === "/") {
+      throw new RuntimeException2(`Invalid resource name "${resource}"`);
+    }
+  }
+  /**
+   * Converting segments of a resource to snake case to
+   * make the route name.
+   */
+  #getRoutesBaseName() {
+    return this.#resource.split(".").map((token) => string2.snakeCase(token)).join(".");
+  }
+  /**
+   * Create a new route for the given pattern, methods and controller action
+   */
+  #createRoute(pattern, methods, action) {
+    const route = new Route(this.#app, this.#routerMiddleware, {
+      pattern,
+      methods,
+      handler: typeof this.#controller === "string" ? `${this.#controller}.${action}` : [this.#controller, action],
+      globalMatchers: this.#globalMatchers
+    });
+    route.as(`${this.#routesBaseName}.${action}`);
+    this.routes.push(route);
+  }
+  /**
+   * Returns the `resource_id` name for a given resource. The
+   * resource name is converted to singular form and
+   * transformed to snake case.
+   *
+   * photos becomes photo_id
+   * users becomes user_id
+   */
+  #getResourceId(resource) {
+    return `${string2.snakeCase(string2.singular(resource))}_id`;
+  }
+  /**
+   * Build routes for the given resource
+   */
+  #buildRoutes() {
+    const resources = this.#resource.split(".");
+    const mainResource = resources.pop();
+    this.#params[mainResource] = ":id";
+    const baseURI = `${resources.map((resource) => {
+      const paramName = `:${this.#getResourceId(resource)}`;
+      this.#params[resource] = paramName;
+      return `${resource}/${paramName}`;
+    }).join("/")}/${mainResource}`;
+    this.#createRoute(baseURI, ["GET", "HEAD"], "index");
+    this.#createRoute(`${baseURI}/create`, ["GET", "HEAD"], "create");
+    this.#createRoute(baseURI, ["POST"], "store");
+    this.#createRoute(`${this.#shallow ? mainResource : baseURI}/:id`, ["GET", "HEAD"], "show");
+    this.#createRoute(`${this.#shallow ? mainResource : baseURI}/:id/edit`, ["GET", "HEAD"], "edit");
+    this.#createRoute(`${this.#shallow ? mainResource : baseURI}/:id`, ["PUT", "PATCH"], "update");
+    this.#createRoute(`${this.#shallow ? mainResource : baseURI}/:id`, ["DELETE"], "destroy");
+  }
+  /**
+   * Filter the routes based on their partial names
+   */
+  #filter(names, inverse) {
+    const actions = Array.isArray(names) ? names : [names];
+    return this.routes.filter((route) => {
+      const match = actions.find((name) => route.getName().endsWith(name));
+      return inverse ? !match : match;
+    });
+  }
+  /**
+   * Register only given routes and remove others
+   * @param names - Array of action names to keep
+   * @returns Current RouteResource instance with filtered actions
+   */
+  only(names) {
+    this.#filter(names, true).forEach((route) => route.markAsDeleted());
+    return this;
+  }
+  /**
+   * Register all routes, except the one's defined
+   * @param names - Array of action names to exclude
+   * @returns Current RouteResource instance with filtered actions
+   */
+  except(names) {
+    this.#filter(names, false).forEach((route) => route.markAsDeleted());
+    return this;
+  }
+  /**
+   * Register api only routes. The `create` and `edit` routes, which
+   * are meant to show forms will not be registered
+   * @returns Current RouteResource instance without create and edit actions
+   */
+  apiOnly() {
+    return this.except(["create", "edit"]);
+  }
+  /**
+   * Define matcher for params inside the resource
+   * @param key - The parameter name to match
+   * @param matcher - The matcher pattern (RegExp, string, or RouteMatcher)
+   * @returns Current RouteResource instance for method chaining
+   */
+  where(key, matcher) {
+    this.routes.forEach((route) => {
+      route.where(key, matcher);
+    });
+    return this;
+  }
+  tap(actions, callback) {
+    if (typeof actions === "function") {
+      this.routes.forEach((route) => {
+        if (!route.isDeleted()) {
+          actions(route);
+        }
+      });
+      return this;
+    }
+    this.#filter(actions, false).forEach((route) => {
+      if (!route.isDeleted()) {
+        callback(route);
+      }
+    });
+    return this;
+  }
+  /**
+   * Set the param name for a given resource
+   * @param resources - Object mapping resource names to parameter names
+   * @returns Current RouteResource instance for method chaining
+   */
+  params(resources) {
+    Object.keys(resources).forEach((resource) => {
+      const param = resources[resource];
+      const existingParam = this.#params[resource];
+      this.#params[resource] = `:${param}`;
+      this.routes.forEach((route) => {
+        route.setPattern(
+          route.getPattern().replace(`${resource}/${existingParam}`, `${resource}/:${param}`)
+        );
+      });
+    });
+    return this;
+  }
+  /**
+   * Define one or more middleware on the routes created by
+   * the resource.
+   *
+   * Calling this method multiple times will append middleware
+   * to existing list.
+   * @param actions - Action name(s) or '*' for all actions
+   * @param middleware - Middleware function(s) to apply
+   * @returns Current RouteResource instance for method chaining
+   */
+  use(actions, middleware) {
+    if (actions === "*") {
+      this.tap((route) => route.use(middleware));
+    } else {
+      this.tap(actions, (route) => route.use(middleware));
+    }
+    return this;
+  }
+  /**
+   * Alias for {@link RouteResource.use}
+   * @param actions - Action name(s) or '*' for all actions
+   * @param middleware - Middleware function(s) to apply
+   * @returns Current RouteResource instance for method chaining
+   */
+  middleware(actions, middleware) {
+    return this.use(actions, middleware);
+  }
+  /**
+   * Prepend name to all the routes
+   * @param name - The name to prepend to all route names
+   * @param normalizeName - Whether to normalize the name to snake_case
+   * @returns Current RouteResource instance for method chaining
+   */
+  as(name, normalizeName = true) {
+    name = normalizeName ? string2.snakeCase(name) : name;
+    this.routes.forEach((route) => {
+      route.as(route.getName().replace(this.#routesBaseName, name), false);
+    });
+    this.#routesBaseName = name;
+    return this;
+  }
+};
+
+// src/router/group.ts
+var RouteGroup = class _RouteGroup extends Macroable4 {
+  /**
+   * Creates a new RouteGroup instance
+   * @param routes - Array of routes that belong to this group
+   */
+  constructor(routes) {
+    super();
+    this.routes = routes;
+  }
+  /**
+   * Array of middleware registered on the group.
+   */
+  #middleware = [];
+  /**
+   * Shares midldeware stack with the routes. The method is invoked recursively
+   * to only register middleware with the route class and not with the
+   * resource or the child group
+   */
+  #shareMiddlewareStackWithRoutes(route) {
+    if (route instanceof _RouteGroup) {
+      route.routes.forEach((child) => this.#shareMiddlewareStackWithRoutes(child));
+      return;
+    }
+    if (route instanceof RouteResource) {
+      route.routes.forEach((child) => child.getMiddleware().unshift(this.#middleware));
+      return;
+    }
+    if (route instanceof BriskRoute) {
+      route.route.getMiddleware().unshift(this.#middleware);
+      return;
+    }
+    route.getMiddleware().unshift(this.#middleware);
+  }
+  /**
+   * Updates the route name. The method is invoked recursively to only update
+   * the name with the route class and not with the resource or the child
+   * group.
+   */
+  #updateRouteName(route, name) {
+    if (route instanceof _RouteGroup) {
+      route.routes.forEach((child) => this.#updateRouteName(child, name));
+      return;
+    }
+    if (route instanceof RouteResource) {
+      route.routes.forEach((child) => child.as(name, true));
+      return;
+    }
+    if (route instanceof BriskRoute) {
+      route.route.as(name, true);
+      return;
+    }
+    route.as(name, true);
+  }
+  /**
+   * Sets prefix on the route. The method is invoked recursively to only set
+   * the prefix with the route class and not with the resource or the
+   * child group.
+   */
+  #setRoutePrefix(route, prefix) {
+    if (route instanceof _RouteGroup) {
+      route.routes.forEach((child) => this.#setRoutePrefix(child, prefix));
+      return;
+    }
+    if (route instanceof RouteResource) {
+      route.routes.forEach((child) => child.prefix(prefix));
+      return;
+    }
+    if (route instanceof BriskRoute) {
+      route.route.prefix(prefix);
+      return;
+    }
+    route.prefix(prefix);
+  }
+  /**
+   * Updates domain on the route. The method is invoked recursively to only update
+   * the domain with the route class and not with the resource or the child
+   * group.
+   */
+  #updateRouteDomain(route, domain) {
+    if (route instanceof _RouteGroup) {
+      route.routes.forEach((child) => this.#updateRouteDomain(child, domain));
+      return;
+    }
+    if (route instanceof RouteResource) {
+      route.routes.forEach((child) => child.domain(domain));
+      return;
+    }
+    if (route instanceof BriskRoute) {
+      route.route.domain(domain, false);
+      return;
+    }
+    route.domain(domain, false);
+  }
+  /**
+   * Updates matchers on the route. The method is invoked recursively to only update
+   * the matchers with the route class and not with the resource or the child
+   * group.
+   */
+  #updateRouteMatchers(route, param, matcher) {
+    if (route instanceof _RouteGroup) {
+      route.routes.forEach((child) => this.#updateRouteMatchers(child, param, matcher));
+      return;
+    }
+    if (route instanceof RouteResource) {
+      route.routes.forEach((child) => child.where(param, matcher));
+      return;
+    }
+    if (route instanceof BriskRoute) {
+      route.route.where(param, matcher);
+      return;
+    }
+    route.where(param, matcher);
+  }
+  /**
+   * Define route param matcher
+   *
+   * ```ts
+   * Route.group(() => {
+   * }).where('id', /^[0-9]+/)
+   * ```
+   * @param param - The parameter name to match
+   * @param matcher - The matcher pattern (RegExp, string, or RouteMatcher)
+   * @returns Current RouteGroup instance for method chaining
+   */
+  where(param, matcher) {
+    this.routes.forEach((route) => this.#updateRouteMatchers(route, param, matcher));
+    return this;
+  }
+  /**
+   * Define prefix all the routes in the group.
+   *
+   * ```ts
+   * Route.group(() => {
+   * }).prefix('v1')
+   * ```
+   * @param prefix - The prefix to add to all routes in the group
+   * @returns Current RouteGroup instance for method chaining
+   */
+  prefix(prefix) {
+    this.routes.forEach((route) => this.#setRoutePrefix(route, prefix));
+    return this;
+  }
+  /**
+   * Define domain for all the routes.
+   *
+   * ```ts
+   * Route.group(() => {
+   * }).domain(':name.adonisjs.com')
+   * ```
+   * @param domain - The domain pattern for all routes in the group
+   * @returns Current RouteGroup instance for method chaining
+   */
+  domain(domain) {
+    this.routes.forEach((route) => this.#updateRouteDomain(route, domain));
+    return this;
+  }
+  /**
+   * Prepend name to the routes name.
+   *
+   * ```ts
+   * Route.group(() => {
+   * }).as('version1')
+   * ```
+   * @param name - The name to prepend to all route names in the group
+   * @returns Current RouteGroup instance for method chaining
+   */
+  as(name) {
+    this.routes.forEach((route) => this.#updateRouteName(route, name));
+    return this;
+  }
+  /**
+   * Prepend an array of middleware to all routes middleware.
+   *
+   * ```ts
+   * Route.group(() => {
+   * }).use(middleware.auth())
+   * ```
+   * @param middleware - Middleware function(s) to apply to all routes in the group
+   * @returns Current RouteGroup instance for method chaining
+   */
+  use(middleware) {
+    if (!this.#middleware.length) {
+      this.routes.forEach((route) => this.#shareMiddlewareStackWithRoutes(route));
+    }
+    if (Array.isArray(middleware)) {
+      for (let one of middleware) {
+        this.#middleware.push(one);
+      }
+    } else {
+      this.#middleware.push(middleware);
+    }
+    return this;
+  }
+  /**
+   * Alias for {@link RouteGroup.use}
+   * @param middleware - Middleware function(s) to apply to all routes in the group
+   * @returns Current RouteGroup instance for method chaining
+   */
+  middleware(middleware) {
+    return this.use(middleware);
+  }
+};
+
+// src/utils.ts
+var proxyCache = new Cache({ max: 200 });
+function dropSlash(input) {
+  if (input === "/") {
+    return "/";
+  }
+  return `/${input.replace(/^\//, "").replace(/\/$/, "")}`;
+}
+function toRoutesJSON(routes) {
+  return routes.reduce((list, route) => {
+    if (route instanceof RouteGroup) {
+      list = list.concat(toRoutesJSON(route.routes));
+      return list;
+    }
+    if (route instanceof RouteResource) {
+      list = list.concat(toRoutesJSON(route.routes));
+      return list;
+    }
+    if (route instanceof BriskRoute) {
+      if (route.route && !route.route.isDeleted()) {
+        list.push(route.route.toJSON());
+      }
+      return list;
+    }
+    if (!route.isDeleted()) {
+      list.push(route.toJSON());
+    }
+    return list;
+  }, []);
+}
+function trustProxy(remoteAddress, proxyFn) {
+  if (proxyCache.has(remoteAddress)) {
+    return proxyCache.get(remoteAddress);
+  }
+  const result = proxyFn(remoteAddress, 0);
+  proxyCache.set(remoteAddress, result);
+  return result;
+}
+function parseRange(range, value) {
+  const parts = range.split("..");
+  const min = Number(parts[0]);
+  const max = Number(parts[1]);
+  if (parts.length === 1 && !Number.isNaN(min)) {
+    return {
+      [min]: value
+    };
+  }
+  if (Number.isNaN(min) || Number.isNaN(max)) {
+    return {};
+  }
+  if (min === max) {
+    return {
+      [min]: value
+    };
+  }
+  if (max < min) {
+    throw new InvalidArgumentsException(`Invalid range "${range}"`);
+  }
+  return [...Array(max - min + 1).keys()].reduce(
+    (result, step) => {
+      result[min + step] = value;
+      return result;
+    },
+    {}
+  );
+}
+function decodeComponentChar(highCharCode, lowCharCode) {
+  if (highCharCode === 50) {
+    if (lowCharCode === 53) return "%";
+    if (lowCharCode === 51) return "#";
+    if (lowCharCode === 52) return "$";
+    if (lowCharCode === 54) return "&";
+    if (lowCharCode === 66) return "+";
+    if (lowCharCode === 98) return "+";
+    if (lowCharCode === 67) return ",";
+    if (lowCharCode === 99) return ",";
+    if (lowCharCode === 70) return "/";
+    if (lowCharCode === 102) return "/";
+    return null;
+  }
+  if (highCharCode === 51) {
+    if (lowCharCode === 65) return ":";
+    if (lowCharCode === 97) return ":";
+    if (lowCharCode === 66) return ";";
+    if (lowCharCode === 98) return ";";
+    if (lowCharCode === 68) return "=";
+    if (lowCharCode === 100) return "=";
+    if (lowCharCode === 70) return "?";
+    if (lowCharCode === 102) return "?";
+    return null;
+  }
+  if (highCharCode === 52 && lowCharCode === 48) {
+    return "@";
+  }
+  return null;
+}
+function safeDecodeURI(path, useSemicolonDelimiter) {
+  let shouldDecode = false;
+  let shouldDecodeParam = false;
+  let querystring = "";
+  for (let i = 1; i < path.length; i++) {
+    const charCode = path.charCodeAt(i);
+    if (charCode === 37) {
+      const highCharCode = path.charCodeAt(i + 1);
+      const lowCharCode = path.charCodeAt(i + 2);
+      if (decodeComponentChar(highCharCode, lowCharCode) === null) {
+        shouldDecode = true;
+      } else {
+        shouldDecodeParam = true;
+        if (highCharCode === 50 && lowCharCode === 53) {
+          shouldDecode = true;
+          path = path.slice(0, i + 1) + "25" + path.slice(i + 1);
+          i += 2;
+        }
+        i += 2;
+      }
+    } else if (charCode === 63 || charCode === 35 || charCode === 59 && useSemicolonDelimiter) {
+      querystring = path.slice(i + 1);
+      path = path.slice(0, i);
+      break;
+    }
+  }
+  const decodedPath = shouldDecode ? decodeURI(path) : path;
+  return { pathname: decodedPath, query: querystring, shouldDecodeParam };
+}
+
+// src/helpers.ts
+import { default as default2 } from "encodeurl";
+import { default as default3 } from "mime-types";
+function parseRoute(pattern, matchers) {
+  const tokens = matchit.parse(pattern, matchers);
+  return tokens;
+}
+function createURL(pattern, tokens, searchParamsStringifier, params, options) {
+  const uriSegments = [];
+  const paramsArray = Array.isArray(params) ? params : null;
+  const paramsObject = !Array.isArray(params) ? params ?? {} : {};
+  let paramsIndex = 0;
+  for (const token of tokens) {
+    if (token.type === 0) {
+      uriSegments.push(token.val === "/" ? "" : `${token.val}${token.end}`);
+      continue;
+    }
+    if (token.type === 2) {
+      const values = paramsArray ? paramsArray.slice(paramsIndex) : paramsObject["*"];
+      if (!Array.isArray(values) || !values.length) {
+        throw new Error(
+          `Cannot make URL for "${pattern}". Invalid value provided for the wildcard param`
+        );
+      }
+      uriSegments.push(`${values.join("/")}${token.end}`);
+      break;
+    }
+    const paramName = token.val;
+    const value = paramsArray ? paramsArray[paramsIndex] : paramsObject[paramName];
+    const isDefined = value !== void 0 && value !== null;
+    if (token.type === 1 && !isDefined) {
+      throw new Error(
+        `Cannot make URL for "${pattern}". Missing value for the "${paramName}" param`
+      );
+    }
+    if (isDefined) {
+      uriSegments.push(`${value}${token.end}`);
+    }
+    paramsIndex++;
+  }
+  let URI = `/${uriSegments.join("/")}`;
+  if (options?.prefixUrl) {
+    URI = `${options?.prefixUrl.replace(/\/$/, "")}${URI}`;
+  }
+  if (options?.qs) {
+    const queryString = searchParamsStringifier(options?.qs);
+    URI = queryString ? `${URI}?${queryString}` : URI;
+  }
+  return URI;
+}
+function createSignedURL(identifier, tokens, searchParamsStringifier, encryption, params, options) {
+  const signature = encryption.verifier.sign(
+    createURL(identifier, tokens, searchParamsStringifier, params, {
+      ...options,
+      prefixUrl: void 0
+    }),
+    options?.expiresIn,
+    options?.purpose
+  );
+  return createURL(identifier, tokens, searchParamsStringifier, params, {
+    ...options,
+    qs: { ...options?.qs, signature }
+  });
+}
+function matchRoute(url, patterns) {
+  const tokensBucket = patterns.map((pattern) => parseRoute(pattern));
+  const match = matchit.match(url, tokensBucket);
+  if (!match.length) {
+    return null;
+  }
+  return matchit.exec(url, match);
+}
+function serializeCookie(key, value, options) {
+  let expires;
+  let maxAge;
+  if (options) {
+    expires = typeof options.expires === "function" ? options.expires() : options.expires;
+    maxAge = options.maxAge ? string3.seconds.parse(options.maxAge) : void 0;
+  }
+  return cookie.serialize(key, value, { ...options, maxAge, expires });
+}
+async function middlewareInfo(middleware) {
+  if (typeof middleware === "function") {
+    return {
+      type: "closure",
+      name: middleware.name || "closure"
+    };
+  }
+  if ("args" in middleware) {
+    return {
+      type: "named",
+      name: middleware.name,
+      args: middleware.args,
+      ...await parseBindingReference([middleware.reference])
+    };
+  }
+  return {
+    type: "global",
+    name: middleware.name,
+    ...await parseBindingReference([middleware.reference])
+  };
+}
+async function routeInfo(route) {
+  return "reference" in route.handler ? {
+    type: "controller",
+    ...await parseBindingReference(route.handler.reference)
+  } : {
+    type: "closure",
+    name: route.handler.name || "closure",
+    args: "listArgs" in route.handler ? String(route.handler.listArgs) : void 0
+  };
+}
+function appendQueryString(uri, queryString, qsParser) {
+  const { query, pathname } = safeDecodeURI(uri, false);
+  const mergedQueryString = qsParser.stringify(Object.assign(qsParser.parse(query), queryString));
+  return mergedQueryString ? `${pathname}?${mergedQueryString}` : pathname;
+}
+
+export {
+  __export,
+  debug_default,
+  canWriteResponseBody,
+  httpRequest,
+  httpMiddleware,
+  httpExceptionHandler,
+  httpResponseSerializer,
+  tracing_channels_exports,
+  parseRoute,
+  createURL,
+  createSignedURL,
+  matchRoute,
+  serializeCookie,
+  middlewareInfo,
+  routeInfo,
+  appendQueryString,
+  default2 as default,
+  default3 as default2,
+  Route,
+  BriskRoute,
+  RouteResource,
+  RouteGroup,
+  toRoutesJSON,
+  trustProxy,
+  parseRange,
+  safeDecodeURI
+};